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.

Apparently calling me an idiot does not violate Google Play comment posting policy.. good to know.

Is this normal or are you normally successful with such requests?

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 🙃

Hi everyone,

I wanted to share some technical takeaways and challenges from a native Android project I've been working on (AnvilAI — a fully offline, native LLM runner).

1. Handling C++ NDK & Vulkan Bindings with Compose: Bridging the C++ NDK inference layer with Vulkan GPU acceleration to Jetpack Compose required a clean asynchronous pipeline. I used Kotlin Coroutines and Flow to stream token outputs from the native side directly into the Compose UI without blocking the main thread or causing frame drops.

2. Encrypted Local Storage with SQLCipher: Since all model execution happens locally, keeping local chat histories encrypted on-device was a priority. Integrating SQLCipher alongside Room ensured encrypted persistent storage with minimal performance overhead during read/write operations.

3. Architecture & Tech Stack:

• UI: Jetpack Compose (Material 3)
• Core Engine: C++ NDK layer leveraging Vulkan for GPU acceleration
• Database: SQLCipher
• DI: Hilt

I’d love to discuss how others are approaching native C++ integration with Jetpack Compose or handling heavy GPU workloads on modern Android devices (Snapdragon vs Dimensity chips).

Source Code:https://github.com/denizaydogan1902/AnvilAI

Feedback on the architecture and PRs are always welcome!

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 got the standard Play Console warnings on my TWA (a Bubblewrap-generated Trusted Web Activity):

1. Must target Android 16 (API 36) by Aug 31, 2026

2. Must use Google Play Billing Library 8.0.0+ by Aug 31, 2026

   The target SDK one is trivial - one line in the app build.gradle (targetSdkVersion 36), compiles fine.

   The billing one is the problem, and it seems to be on Google's side, not mine. My TWA doesn't call the Billing Library directly. It uses the Digital Goods API + PaymentRequest (https://play.google.com/billing), which is bridged by com.google.androidbrowserhelper:billing. That bridge is what actually embeds the Play Billing Library.

   I checked the source, and the bridge is still on Billing 7:

   - Latest billing release is billing-1.1.0 (June 25, 2025), which explicitly says "BillingClient library updated to 7.1.1".

   - The main-branch version catalog (gradle/libs.versions.toml) still declares billing = "7.1.1".

   So Google is warning every TWA to move to Billing 8, but Google's own TWA billing library hasn't been updated to 8 (it's been sitting on 7.1.1 for over a year).

   Force-overriding com.android.billingclient:billing:8.x on top of the old bridge looks risky - Billing 8 removed deprecated APIs the old bridge relies on, and I've seen reports of queryProductDetails() silently breaking after the v8 jump on native/Flutter setups. Not something I want to ship blind on a live payment flow.

   Questions for anyone in the same boat:

   - Is there any known timeline for android-browser-helper billing to move to Billing 8?

   - Has anyone successfully forced Billing 8 into a TWA and confirmed purchases still work end to end?

   - Are you just requesting the extension to Nov 1, 2026 and waiting?

   For now I've requested the extension in Play Console (reason: "waiting on a new SDK version from an SDK provider"). Curious what everyone else is doing.

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’m seeing a strange issue on a Xiaomi device where Android Studio fails to install apps.

After debugging, it seems related to ADB reporting incorrect system properties.

Running:

adb shell getprop | grep version

returns a wrong Android version (the device is actually on Android 16).

I suspect this might be causing compatibility checks or install failures.

Has anyone run into something similar on Xiaomi / MIUI / HyperOS devices?

Hi all,

I’ve been experimenting with controlling Android devices directly from the browser using WebUSB + ADB.

The idea is to avoid installing native apps and instead manage devices through a web interface.

So far I’ve managed: - basic device connection via USB - sending ADB commands from the browser - handling multiple devices (still rough)

Some challenges I’m running into:

1. WebUSB stability across browsers
2. performance compared to tools like scrcpy
3. handling multiple devices efficiently
4. security / permission concerns

I’m curious if anyone here has tried something similar, or has thoughts on:

• limitations of WebUSB for this use case
• better approaches for browser-based device control
• whether this is even worth pursuing vs native tools

Would really appreciate any insights.

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.

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?

I've been studying Compose for a little while and finishing the 3rd chapter "Build beautiful apps". One thing that confuses me is their expected completion time. For instance, that particular chapter is supposed to take around 3 hours to finish. However, it basically requires us to build 3 projects, and it took me about 9-10 hours to get to the latest codelab (30-day app). Am I missing smth? Am I studying wrong and too slow? What should I pay more attention to? Considering I can spend ~2 hours daily on this course, how many days would it take (I understand that everyone is different and so on, so I ask for an approximate deadline)? How much time did it take for you to complete?

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.

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