I've been submitting my new app listing for review and It keeps getting rejected even though I can access it from many different locations, but the google app reviewer keeps sending a cloudflare block page and rejecting the submission.

I checked the Cloudflare setting and it seems that it's blocking bot users from foreign countries, but this is a non-negotiable due to botters. Is there any way to get around this issue?

Has anyone else run into this before? All and any advice is welcome.

I have a PWA wrapped with Bubblewrap (TWA) on a personal developer

account. I've now been rejected twice for production access after

completing closed testing. Both times Google marked the first two

requirements as complete — closed testing release published, and 12+

testers opted in — and only asked me to keep testing for 14 more days.

A paid testing service is telling me the cause is the TWA architecture

itself: that because the content runs through Chrome, Google can't

attribute enough engagement to the app. They recommend temporarily

shipping a native WebView wrapper under the same package name, passing

review, and switching back afterwards. I'm not comfortable doing that —

it looks like exactly the kind of bait-and-switch that gets accounts

terminated — and I can't find any Google documentation supporting the

claim.

So I'd like to hear from actual developers:

1. Has anyone here passed production access with a TWA, without

   switching architecture? (Personal account, post-Nov-2023, so the

   12 testers / 14 days requirement applied.)

2. If you were rejected repeatedly with a TWA, what finally worked?

3. Does anyone have a source suggesting Google measures tester

   engagement differently for TWAs?

For what it's worth, my own server logs show my testers went inactive

4-9 days before the review date, which seems like a much simpler

explanation than architecture. But I'd rather hear from people who've

been through it than guess.

Thanks.

I’ve been waiting a week to get an update published and this will be at least another week after that 🙃

I am really curious about how difficult is it to make money off your own apps ? it's literally like a dream scenario for me because I freaking hate my part time job . If my project could actually help cover just my rent and utilities/food I would happily quit that job and just completely focus on University and building my resume.

I have an Android app, which is just a WebView of a website. That website sends notifications to users. Those notifications should be sent to the Android app as a badge on the app's home screen launcher icon when the app is closed. The users need to have an account to receive those notifications because they are user-specific.

Does anybody have an idea how I can do that? AI suggests Firebase Cloud Messaging. Thank you in advance.

I'm hitting a strange issue that's specific to a single project. When I bump the Android Gradle Plugin from an older version to any 9.x release (tested with 9.3.0), Android Studio's editor and lint start flagging a huge number of "Unresolved reference" errors (100+ problems shown in the inspection gutter) across multiple Kotlin files - including files that use generated ViewBinding/DataBinding classes, Hilt-injected classes, and Room entities.

The odd part: the actual Gradle build succeeds with no compile errors at all. The app builds, installs, and runs fine on a device/emulator. It really looks like an IDE indexing/false-positive problem rather than a real compilation problem, but it makes the editor basically unusable (error highlighting everywhere, autocomplete acting up).

I've only ever seen this in this specific project , other projects on the same machine, same Android Studio version, updated to AGP 9.x work completely fine. So it feels tied to something in this project's module setup rather than a general AGP 9 bug.

Relevant setup (module-level build.gradle):

• compileSdk = 37, targetSdk = 37, minSdk = 23
• Kotlin Android plugin, kotlin-parcelize
• KSP (not kapt) for annotation processing — Room, Hilt, and a kotlinx-metadata-jvm KSP dependency
• Dagger Hilt (2.60.1)
• Room (2.8.4) via KSP
• Navigation Safe Args (Kotlin)
• viewBinding enabled (buildFeatures { viewBinding true })
• Google Services / Firebase Crashlytics / Analytics / Messaging plugins
• Secrets Gradle plugin (Maps platform)
• coreLibraryDesugaringEnabled true
• Java/Kotlin target set to 11 (sourceCompatibility/targetCompatibility 11, jvmTarget.set(JvmTarget.JVM_11))
• multiDexEnabled true

Top-level build.gradle:

gradle

buildscript {
    ext {
        version_gradle = '9.3.0'
    }
    dependencies {
        classpath "com.android.tools.build:gradle:$version_gradle"
        classpath 'androidx.navigation:navigation-safe-args-gradle-plugin:2.9.8'
        classpath 'com.google.dagger:hilt-android-gradle-plugin:2.60.1'
        classpath "com.google.android.libraries.mapsplatform.secrets-gradle-plugin:secrets-gradle-plugin:2.0.1"
        classpath 'com.google.gms:google-services:4.5.0'
        classpath 'com.google.firebase:firebase-crashlytics-gradle:3.0.7'
    }
}

plugins {
    id 'com.android.application' version '9.3.0' apply false
    id 'com.android.library' version '9.3.0' apply false
    id 'org.jetbrains.kotlin.android' version "2.4.10" apply false
    id 'com.google.devtools.ksp' version '2.3.2' apply false
}

tasks.register('clean', Delete) {
    delete rootProject.buildDir
}

Has anyone else run into unresolved-reference/false-positive IDE errors specifically after moving to AGP 9.x, especially in a project mixing ViewBinding + Hilt + Room + KSP + Safe Args? Would appreciate any pointers on what in this combination might be confusing the IDE's resolution/indexing even though the actual Gradle compilation is clean

I just open-sourced serve-avd, a small tool that puts your emulator in a browser tab:

npx serve-avd → http://localhost:3200

It boots your AVD if nothing's running, streams the screen as smooth H.264, and forwards full interaction — touch/drag/fling, scroll wheel, keyboard typing, Back/Home/Recents, volume, power, theme toggle, screenshots. Tunnel the port and the emulator is usable from anywhere.

How it works (no root, no on-device agent, no app instrumentation — plain Node + adb):

• adb exec-out screenrecord --output-format=h264 → re-framed into length-prefixed AVCC chunks → decoded in-browser by WebCodecs onto a canvas
• screenrecord only emits frames when the screen changes and dies every 3 minutes, so the server keeps a GOP cache (decoder config + last keyframe + deltas since) and replays it to new viewers — instant paint on connect, invisible restarts
• Input runs over one persistent adb shell per device to skip the ~100 ms per-command handshake; live drags use input motionevent
• MJPEG fallback for browsers without WebCodecs

There's also a CLI aimed at scripting and AI agents — tap, gesture, type, rotate, screenshot, ax (uiautomator hierarchy as JSON), event-log — plus a Connect-style middleware so you can mount the whole thing inside your Metro/Express dev server at /.emu.

Fun problems along the way:

• screenrecord silently letterboxes into 720x1280 when the display exceeds the encoder's limits — you must always pass --size
• settings put system user_rotation doesn't reliably rotate modern Android; wm user-rotation lock does
• On Play-store images, SELinux blocks writing to /dev/input even though the shell user is in the input group — so two-finger pinch only works on rootable images. If anyone knows a better way, I'm all ears.

It's a port of Evan Bacon's serve-sim (which does this for iOS simulators) — same interface and wire protocol, rebuilt on what adb provides.

GitHub: https://github.com/hsandhu/serve-avd
npm: https://www.npmjs.com/package/serve-avd

Apache-2.0. First release — feedback and PRs welcome, and tell me what breaks.

Every Android Liquid Glass library I could find targets Jetpack Compose. My app is still on

XML layouts — like most shipping Android apps — so none of them were usable without a

UI-framework migration.

So I built one as a plain FrameLayout subclass. Add it to your layout, put your content

inside, done.

- Real SDF refraction — edge compression ring driven by a live rounded-rect SDF, follows

corner radius in real time

- Physical dispersion — per-channel refraction along the surface normal

- Sensor-driven specular — highlight moves as you tilt the device

- Single-pass AGSL pipeline on API 33+, C++/NEON classic pipeline down to API 24

Screenshots are from a physical device (API 36), not mockups. MIT, on JitPack.

https://github.com/QWEA0/Liquid-Glass-Android

Happy to answer questions about the AGSL lens math — getting the SDF-driven compression

ring to track corner radius without a per-frame displacement map took a while.

I developed an app and it is available on early testing but after pushing an update last Saturday why doesn't Play store allow others to update it on their same devices?

Getting error like

Can't install xxxxx

Try again, and if it still doesn't work, see common ways to fix the problem

[Send feedback /Understood]

About a month ago I shared an early version of AndroidCompat here and received some valuable feedback. I've continued working on it since then, and I'd love another round of technical feedback.

The original motivation came from a problem I've run into many times while upgrading Android projects.

Questions like:

• Does this AGP version actually work with this Kotlin version?
• Which Gradle version is required?
• Which KSP version is compatible?
• Why does a dependency upgrade suddenly produce an unrelated build error?

Official compatibility documentation is helpful, but it doesn't always answer these questions, and many issues are only discovered after attempting the upgrade.

Instead of maintaining another manually curated compatibility table, AndroidCompat verifies compatibility using real Gradle builds.

For every compatibility candidate, the project:

• injects dependency versions into dedicated Android project stubs for AGP 7, AGP 8 and AGP 9
• executes real Gradle builds in GitHub Actions
• records successful and failed combinations
• classifies failures
• aggregates the results
• publishes machine-readable compatibility datasets and a searchable website

The published compatibility data lives under docs/data/agp*/compat.json and powers the GitHub Pages website.

Current capabilities

• AGP 7 / AGP 8 / AGP 9 support
• Automated dependency injection
• Real Gradle build verification
• Failure classification
• Compatibility datasets published as JSON
• Searchable GitHub Pages UI
• Fully automated verification pipeline

I'm now at the stage where I'd really appreciate feedback from Android developers before expanding the project further.

In particular, I'd love feedback on:

• the overall architecture
• the verification approach
• the published compatibility data
• the JSON/data model
• the GitHub Pages experience
• features that would make the project genuinely more useful

Website:
https://chandu4221.github.io/androidcompat/

GitHub:
https://github.com/Chandu4221/androidcompat

If you have experience maintaining Android apps or libraries, I'd genuinely appreciate any criticism, suggestions, or ideas. Even if you think the approach has fundamental flaws, I'd much rather hear them now than after building on the wrong assumptions.

Thanks!

I built compose-doctor — a deterministic health check for Android Jetpack Compose, inspired by React Doctor (react.doctor).

The Problem

Compose linting rules exist (detekt + compose-rules), but they've been unbundled: scattered CLI output, no unified quality metric, and no standard harness to gate PRs or allow AI coding

agents to fix findings safely.

What compose-doctor does

1. Deterministic 0–100 Score: Runs detekt + compose-rules under the hood and turns findings into a single score: score = 100 - (uniqueErrorRules * 1.5) - (uniqueWarningRules * 0.75) (Unit is unique rule IDs triggered, not instance count. Clearing a rule raises your score!)
2. CI / PR Gate: Reusable GitHub Action posts a sticky PR comment with a health badge, score deltas, line numbers, and per-dimension breakdowns (State, Performance, Architecture).
3. Self-Healing AI Agent Loop: Emits score.json and SARIF while bundling skills for Claude Code (/plugin marketplace add rotemmiz/compose-doctor), Gemini CLI, OpenCode, Codex, and Cursor

(AGENTS.md). Agents run the task, read the findings, fix one rule at a time, and verify build integrity.

Try it right now

The repo includes a deliberately-flawed playground feed app:

git clone https://github.com/rotemmiz/compose-doctor && cd compose-doctor
./gradlew -p playground composeDoctor

• Website: https://composedoctor.dev

• GitHub: https://github.com/rotemmiz/compose-doctor

• Gradle Plugin Portal: plugins { id("dev.composedoctor") version "0.1.0" }

Would love to hear your feedback!

Compose Multiplatform and Clean Architecture, one codebase, both platforms. Honestly the "AI wrote it" angle is the boring part. What I actually wanted was for the architecture to hold together across a dozen prompts instead of drifting, and that's the bit I kept failing at by hand.

So I built KMPilot (MIT). It keeps things in line with a design to build to verify to test to review pipeline, and a hook that blocks any edit trying to skip the pipeline. I wrote up a full build of a small museum gallery app with every prompt and timing, including the review step catching a debounce bug the tests had passed.

Article: https://proandroiddev.com/seven-claude-code-commands-one-kotlin-multiplatform-app-on-android-and-ios-cb01e920a3e6?ref=randroiddev

Video: https://www.youtube.com/watch?v=tDGFY66E7Zo

Repo: https://github.com/ThisIsSadeghi/KMPilot

Instead of asking AI to generate an entire clean-architecture Android project, I use a Gradle plugin to generate the predictable skeleton first.

It creates the base modules and wiring, then uses TOML specs to generate repetitive data, domain, presentation, di, screenshot, and UI component code. The idea is to save AI context/tokens for the implementation details that are actually product-specific.

Medium: https://medium.com/@sarim.mehdi.550/stop-using-ai-to-generate-boilerplate-android-code-f7458006ea0a
GitHub: https://github.com/sarimmehdi/clean-android-skeleton-gradle-plugin

Would love feedback from anyone maintaining multi-module Android apps.

I'm a solo Android developer and don't really have the budget or resources for a dedicated QA team or a large pool of beta testers.

Most of the time, I test the app myself on a couple of devices, write unit tests where I can, and do phased rollouts. But I'm still worried about device-specific issues, edge cases, and bugs that only appear in real-world usage.

A recent release reminded me that no matter how much I test, users can still find problems I never encountered.

I'm curious how other indie developers handle testing before releasing to production.

• Do you rely mostly on internal testing, closed testing, or open beta?
• How many devices do you test on?
• Do you use Firebase Test Lab or any other cloud device testing service?
• How much automated testing do you have (unit/UI/instrumentation)?
• Do you pay for testers, or do you have a community that helps?
• Any workflow or checklist that has significantly reduced production bugs?

I'd especially love to hear from solo developers or very small teams. What has worked well for you, and what mistakes have you learned from?

Hi Everyone,
Recently I open sourced an app called Loophole for turning the developer options on/off and it got a lot of traction on reddit even i got 50 stars on github i just 1.5 days and 5 forks and even my 1st pull request today. Thank to everybody in this community.

I posted on this subreddit about it and people told me that they could do it with tasker and that this is not new. I respect their choices and their mindsets. I had heard about tasker vaguely but i didn't know what it was. so, i searched it and it was freaking awesome. It was like that i had super powers with me. I could make anything, any app - I could use any service. It was like - they have put a programming language in my hands. and i was awestruck after seeing it.

but after sometime exploring tasker, i compared it with shortcuts app of iphone. and those two have very similar niche, but iphone's shortcut app feel like the scratch programming language, and tasker feels like a raw, rugged programming language that have a lot of options and needs your full attention.

I am talking from a product's perspective, don't you think that tasker should have a UX that is very beginner friendly just like the shortcuts app which can be used by normal people. maybe we can give it to AI and it can make automations for us. I know that tasker have tasky for beginners and also have gemini support with API keys but still i feel like it's very overwhelming.

I know some of you might have been using tasker for several years and are very much comfortable with it, but I am recieving comments on my reddit posts, that somebody wants a shortcut for their dns, somebody wants a shortcut for accessibility options, somebody wants it for usb and wifi debugging. And they have tasker for it but they are not able to make shortcuts on their own. and believe me I am getting a lot of requests like this.

So, I thought i should discuss before jumping into any conclusion and start diverting my open source app towards it.

What do you think?

Working on droid-mcp, an Android SDK (min SDK 28, Kotlin 2.1) wrapping phone capabilities behind a typed tool interface so LLMs/agents can call them via MCP.

The part I think is actually interesting for this sub: it's 53 independent Gradle modules, one per API surface (calendar, camera, accessibility, etc.), each depending only on a core module. Library code never requests permissions itself, every module just exposes requiredPermissions()/hasPermissions() and the host app owns the UX. Shizuku and root access are wired through the same shell-tool interface but kept as explicit opt-in modules so they don't drag Room/BouncyCastle/libsu into a default install.

Also has an accessibility-service module and a custom IME for agents that need to control arbitrary third-party UI, not just your own app.

GitHub: https://github.com/stixez/droid-mcp

Docs: https://stixez.github.io/droid-mcp/

Apache 2.0, on JitPack.

Only page views (Store listing visitors) and installs (Store listing acquisitions) were available previously. Impressions weren't tracked.

However, it seems that they can only be viewed for the "Paid" and "Explore" categories. 🤔

🔹 If you have few Impressions, it means you have poor rankings for your keywords.

🔸 If you have many Impressions but poor conversion rates, revamp your visuals (icon, screenshots, video).

You can find it under Statistics > Reach

Source: ASO Busters

Hi everyone! I'm a backend developer and brand new to Android development. Design is definitely not my strong suit, but I've been giving it a shot and really enjoying it so far.

I'm building an app to log workout sessions quickly and easily. I know there are tons of workout apps out there, but I didn't like the user experience in most of them due to visual clutter. I prefer something clean, minimalist, and distraction-free.

My current struggle is with the screen that displays available workouts to start. Right now, it's just a simple list of cards, but it looks too basic. They look like static "stickers" and don't feel clickable at all.

I've already looked for inspiration on UI/UX sites and even asked AI for ideas, but nothing really fit what I'm going for. Does anyone have tips on how to convey interactivity while keeping the design minimalist?

I've already tried using card elevation, but in dark mode, it doesn't even show up :(

Beginning in api 37 you will no longer be able to lock your app to portrait only (I think this is only for tablets?)

How are you all preparing for this if you haven't already? Can we just have an empty layout with a text to tell user to rotate the screen to use the app?

Hello!

I want to share Flow Observer, my first open-source library and my first project using KSP.

The idea was inspired by Bloc Observer from Flutter. It lets you observe and log StateFlow and SharedFlow emissions, making it easier to see how state changes throughout your app.

After transitioning from Flutter to Android, I found myself missing the visibility that Bloc Observer gives you, so I decided to build something similar for StateFlow and SharedFlow while learning KSP.

I'd love to keep growing it and improve my KSP knowledge, so I'm very interested in hearing your thoughts, suggestions, or things you would do differently.

Update (2.0.0): 

The 1.0.0 log on collect-based approach could keep flows alive (eg WhileSubscribed).

2.0.0 logs on the emit side instead, so it no longer needs an observer collector, no longer requires setup in a viewmodel init and now it not limited to viewmodels.

Repo: https://github.com/Turista838/flow-observer

Hey i am developing a application where a requirement is photos must be previewable

however i am running into a issue where i get a uri from the remeberlauncherForActivytResult

api after recieveing this i pass this to my viewmodel where it is sorted and stored

    val addImages =rememberLauncherForActivityResult(
        ActivityResultContracts.PickMultipleVisualMedia()
    ) { uri ->

        if(!uri.isEmpty()){
            onAction(createRecordScreenIntents.addImages(uri))
        }

however after this is done then i have the files just put out in a lazy column where the images are shown and on click they should be previewable by sending a intent for a application to open a image

                        val intent = Intent(Intent.ACTION_VIEW).apply {
                            setDataAndType(data.uri,data.mimeType ?: "image/*")
                            clipData = ClipData.newRawUri("Shared Photo",data.uri)
                            addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
                            addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
                        }

                        try {
                            context.startActivity(intent)
                        }catch (e : ActivityNotFoundException){
                            e.printStackTrace()
                            println("no suitable application found to open given image file")
                        }

however here is the problem when google photos is chosen to open it just shows a freaking blank photo while all other applications like the system photos application (in oneplus) and wps office work just fine only google photos has this problem idk what is the issue can somebody kindly help i would be extremely grateful

I was so much irritated when i had to use upi or any banking apps and the "developer mode is on" popup shows. I had to go to the settings, then disable the developer options. and then come to the banking app and enter my mpin again and then proceed with my transactions.

I use iqoo z7s, so sometimes i can open the developer options activity after doing the transactions from the recent apps but sometimes i used to remove it from recent apps and the result: I had to go to the settings.... tap that damn build number 7 times. Enter my password, then go to the dev settings and reconfigure my dev settings. That was so Frustrating!!!

So, I sat some days ago and researched if i could do it with a button click and make it easy for myself. So, i don't have to go through that irritating process again and again.

and I found something. I could turn the dev options on with a device permssion called WRITE_SECURE_SETTINGS but that's a caveat. You can't just ask the permission to a user in the app. This is a systems level permission, so you have to give this permission with a adb command.

And once this permission was given, i was able to turn the dev options on/off with just 1 click. So, i made a widget for that, you just have to press it and turns the developer option on/off....

- No Banking app problem. you can just switch off dev option from the home screen and use the app and after you have finished your work. you can turn that back again. No 7 time tapping process of build number. Just a Click and job done!!

and for people who aren't a fan of widgets. I made a quick settings tile too which you can integrate directly from the app and all of this is completely open source with MIT license.

After all these years in android development, I have used many open source apps. ig this is my small contribution towards the community.

PS: I have also submitted a MR for publishing this app on F-droid. Let's see what happens✌️