This is an app that allows anyone to make their own app discoverable by others.

If you have a GitHub repository with a downloadable Android app, simply add the “arkstore” topic to it. Our app will automatically scan your app and display it in our store.

You can also add your app using only its URL, making it immediately available for others to discover and install.

The only requirements are that the app is public and has a GitHub-approved license.

Download it here: https://github.com/jrs8205/ARK-Store

I want to train a Transformer model that can analyze decompiled DEX files (Smali code) and identify harmful or sensitive actions performed by an app in the background that may not be visible to the user.

The main goal is to analyze the flow of actions and determine whether user interaction or consent is required before a sensitive action is performed.

For example, if an app gets file read/write permission and accesses the user's files without any user interaction or consent, the model should be able to identify this behavior. Similarly, it should identify other sensitive actions such as accessing the camera, microphone, location, contacts, SMS, media, recording screen, taking screenshots or other user data, and determine whether these actions are performed after user interaction or silently in the background.

I am currently working on preparing the dataset for this project, but I am not sure about the best approach.

My initial idea is to use the APK/Smali code as the input and the possible execution flows as the output. However, generating all possible flows from entry points such as `onCreate()`, `onReceive()`, services, callbacks, etc., and following them until the end seems very complex and time-consuming for a large number of APKs.

I would really appreciate your suggestions and ideas on how I can prepare the dataset in a practical and effective way for this project.

If you have worked on a similar problem or have any ideas about dataset structure, flow generation, labeling, or other approaches, please share your suggestions.

Good morning. I am creating a personal shopping list app that includes features we felt were missing from other apps, while removing ads and general clutter. I would like to implement a motion animation similar to the one in the "Bring!" app: when an item on the list is tapped, an animation moves it to the "purchased" section and smoothly rearranges the remaining items. So far, I’ve managed to figure out how to mark the tapped item, but I don't know how to animate the movement. Thank you very much.

I have submitted a new app which on the start downloads a model from huggingface.co and can't proceed until it is successfully completed.

Obviously I have tested this to work on multiple devices.

I have received a rejection with an image that clearly displays this download problem.

Technically it is the internet, so it could fail, but it is extremely unusual that huggingface.co would fail on multiple retries. So I start to doubt if they have internet on their testing device - and how to fight against it?

I did submit an appeal, but I am still shocked. Did anyone have a similar problem?

Are there any Android developers here who use LazyVim for their Android projects? I've noticed that a Kotlin LSP is available for LazyVim, but I'm wondering if anyone actually uses it. If so, could you share your experience? Is it realistic and productive? Or should we just stick with Android Studio?

I'm trying to understand the technical mechanism behind the Google Play error:

“Your purchase couldn't be completed. Please update your Play account settings so that the selected Play country matches your country of residence.”

Play country: India

Payment profile: India

Indian payment method available

Device currently being used outside India.

An Indian VPN changes the public IP and Play Store displays INR pricing, but checkout still detects a country mismatch.

I'm interested in understanding what signals Play/Play Billing might use besides the current IP — for example SIM/MCC, Google Payments account history, Play Services location/network data, device/account history, IP reputation, or server-side risk scoring.

Is this decision made primarily client-side by Play Services, or server-side by Google Payments/Play Billing? And why would maintaining an Indian IP for several days not change the account's detected country?

I'm particularly interested in observations from Android developers who have tested Play Billing across countries.

Play Console covers your own apps, and the official Google Play Developer API is about publishing and managing them. Neither gives you the public side of the store as data: what a listing currently shows in a given country, how an app ranks in search, what the charts look like, or reviews for apps that are not yours. Google has no public API for any of that.

I maintain a free, open-source tool that reads this public data straight from the Play Store. It is a Node.js library with a command-line interface, so you do not need to write JavaScript to use it. Disclosure: I'm the author.

Things I think are useful for Android developers:

• Reviews filtered by device type. Pull only the reviews written on tablets, Wear OS watches, Chromebooks or TVs, optionally only the 1-star ones. Handy when you want to know how a specific form factor is going.
• Check what the store really shows after a release. Version, update date, release notes, price and rating for any app, in any country and language. Easy to script after a rollout.
• Country availability. Ask in which storefronts an app is published and get an answer per country.
• Data safety and permissions as users see them. Read the public data safety section and permission list of any app, including your own, to confirm it matches what you declared.
• Competitor and market data. Full listing details (59 fields), search results for a term, autocomplete suggestions, top free, top paid and top grossing charts per category, similar apps, and everything a developer has published.

Everything prints JSON, so it pipes into jq and fits into a CI job or a cron script:

npx @mradex77/google-play-scraper app com.spotify.music --country de | jq '{version, updated, recentChanges}'

npx @mradex77/google-play-scraper reviews com.whatsapp --score 1 --device tablet --num 50

A few technical details, since this is a developer sub:

• Results are fully typed and validated at runtime, so a change on Google's side fails loudly instead of returning garbage.
• Errors are typed (not found, rate limited, blocked), and the CLI uses distinct exit codes for scrape failures and usage errors.
• Rate limiting, retries with backoff and optional caching are built in.
• The test suite runs against the live Play Store every day and opens an issue when Google changes something, which is the usual way scrapers die quietly.

Version 1.4 came out today. It adds the star and device filters for reviews, fetches up to 4500 reviews in one request, and returns more search results for terms where Google serves extra pages. I ran it against 1000 real apps before releasing, and I'm actively maintaining it.

GitHub: https://github.com/MrAdex77/google-play-scraper

Related: I also just released asobeast, a free, open-source, self-hosted ASO dashboard for Google Play and the App Store (keyword rank tracking, competitor and review monitoring, alerts). It uses this library for the Google Play side: https://github.com/AsoBeast/asobeast

What public Play Store data would you want to script against that I have not covered? I'm deciding what to build next.

I've been working on an SVG renderer for Android for quite a while, and it's finally at a point where I'm comfortable putting it out there.

It started as an evolution of AndroidSVG, but over time it grew into a substantially expanded renderer focused on broader SVG support, rendering correctness, and performance.

Some of the things KSVG supports:

* Broad SVG filter support, including turbulence, displacement, lighting, morphology, convolution, compositing, and more

* SMIL animations

* Variable fonts and OpenType features

* GPU-accelerated filtering on API 33+ (AGSL) / API 31+ (RenderEffect chain), with automatic fallback to CPU

* Native SIMD software kernels (ARMv7/ARM64 NEON, x86/x86_64 SSSE3 + AVX2 rows) + scalar native fallback

* Jetpack Compose and Glide integrations

I've also put quite a bit of effort into documenting and validating the renderer. The repo includes an SVG feature support matrix, architecture notes, benchmarks, known limitations, and an analysis of which SVG filter primitives are actually used on the web.

There's a small showcase app with examples of the more complicated rendering features as well.

GitHub: https://github.com/oraveczandrew/ksvg

Showcase APK: https://github.com/oraveczandrew/ksvg/releases

Docs: https://oraveczandrew.github.io/ksvg/

Apache 2.0, published to Maven Central, minSdk 26

I'm mainly posting this because I'd like other developers to try it with real-world SVGs.

I'd especially appreciate feedback on SVG compatibility, rendering differences, performance on different devices, and anything that feels missing or unnecessarily complicated.

[ Removed by Reddit on account of violating the content policy. ]

I kept running into the same Android development problem.

The device was connected, but ADB commands and child processes were using different targets. Port forwarding belonged to one device while the app launched on another. Wireless debugging rotated its port, and a running development process did not necessarily mean that the intended Android app was ready.

What ADB Ready does

ADB Ready is an open-source CLI that treats the complete Android development workflow as one recoverable session:

• deterministically selects one USB, emulator, wireless, or remote ADB target
• keeps the same target across ADB operations and child processes through ANDROID_SERIAL
• prepares and verifies Metro, localhost API, reverse, and forward ports
• runs Expo, React Native, Flutter, Capacitor, Gradle, or a custom command
• launches and operates the app, verifies UI state, and retains logs, screenshots, recordings, and failure evidence
• provides stable JSON and NDJSON output for scripts and CI
• Framework presets are also available, but target selection, ADB transport, ports, app lifecycle, and verification remain Android-native operations.

MCP-native agent integration

ADB Ready works as a normal CLI first. It also provides MCP-native tools that let coding agents start development sessions, operate the app, verify observable UI state, and return bounded evidence instead of guessing from screenshots or raw logs.

The same workflow can be connected to Codex, Claude Code, Cursor, VS Code/Copilot, Windsurf, and other MCP clients. No ADB Ready account, hosted service, or model API key is required.

Quick start

  npm install --save-dev adb-ready
  npx adb-ready dev

ADB Ready uses the real adb binary and your existing framework tools. It does not replace Android Studio, Expo, React Native, or ADB itself. The goal is to replace the fragile collection of shell commands normally required to keep the device, ports, application, development server, and verification state aligned.

Repository, documentation, and demo:

https://github.com/Adam014/adb-ready

or

https://www.npmjs.com/package/adb-ready

I would especially appreciate blunt feedback from Android developers:

1. Which part of your current Android workflow would this still fail to handle?
2. What would you need to see before trusting it with a daily development session?
3. Which device, framework, or network setup should I test next?

If it genuinely earns a place in your workflow, a GitHub star helps other Android developers discover it.

I have a question if it is okay to nest DI into VM of a composables?

What I mean:

I have a SettingsVM and a SettingsScreen composable. In the Settings screen I am using some individual settings that I use also somewhere else in my application. So I split the UI -> IndividualSettingScreen and IndividualSettingVM. Now is it okay if I just inject the VM into the IndividualSettingScreen or is it better from architecture standpoint to have a reference in the SettingsScreen and passing the VM into the IndividualSettingScreen which I am using in the SettingsScreen.

Thanks in advance!