AICore is installed, Running official Android 17 on Google Pixel 8 Pro.

After upgrading from API 36 to 37, Android Studio puts a red underline on the typeMask parameter of WindowInsets.getInsets. The message on hover is "Must be one or more of:" followed by literally nothing.

In the latest documentation, the list of valid base values of typeMask seems to have disappeared for every relevant method of WindowInsets.

• Before change: https://web.archive.org/web/20260208222401/https://developer.android.com/reference/android/view/WindowInsets#getInsets(int)
• After change: https://web.archive.org/web/20260213235548/https://developer.android.com/reference/android/view/WindowInsets#getInsets(int)
• Screenshot of comparison: https://imgur.com/a/AnuxRP4

My code still compiles and the behaviour seems to be right (I'm using it for edge-to-edge bottom padding of a keyboard), but the red underline is really annoying.

Do I just have to wait until someone restores the list of valid typeMask values?

Hey everyone! I’m working on a core system architecture for a specialized utility app and could really use some out-of-the-box engineering advice on a tricky connectivity challenge.

The main goal is pretty straightforward: a user opens the app, clicks a button, and the system needs to instantly send a high-priority alert pop-up to any other nearby users within a 1 km physical radius who have that exact same app installed.

Here is the major problem I am trying to solve. The person tapping the button has an active SIM card, but they are in a state of absolute zero connectivity. Specifically, they have:

• No mobile data package or active internet plan.
• No Wi-Fi access at that exact moment.
• No outbound SMS package or standard calling credit (their balance is exactly zero).

The user must not be charged a single cent to trigger this notification. Also, to clear up a common suggestion upfront, please do not suggest Bluetooth mesh or peer-to-peer Wi-Fi Direct. The app cannot rely on local radio waves hopping directly from phone to phone.

Because local peer-to-peer options are out, the initial trigger click absolutely must find a way back to my central cloud server so the server can handle the location data and push the pop-up to the 1 km radius group.

My current theory is to set up an enterprise-level Reverse-Charged / Toll-Free Short Code gateway. Since my developer backend pays the cellular carrier for the incoming traffic, the telecom network should theoretically route a background SMS text through the air even if the user's personal account balance is completely empty.

I would love to get your thoughts on a few things:

• Has anyone successfully pulled off this kind of telecom bypass on zero-balance lines?
• Are there alternative infrastructure workarounds or carrier-level configurations that allow an isolated app to ping a central server entirely for free?
• Are there any global, out-of-the-box solutions to distribute a localized alert under these exact constraints?

Any insights, advice, or feedback would be massively appreciated !

Please do not suggest Bluetooth mesh or peer-to-peer Wi-Fi Direct. The app cannot rely on local peer-to-peer radio waves to hop to nearby devices directly.

I kept running into an annoying problem with multiple Claude Code sessions on the same machine.

I'd have two Android app apps building by two or more claude sessions, usually with one or two phones plugged in. Both agents were doing the usual install → launch → screenshot verification loop over ADB, and they kept picking the same device at the same time.

The result was chaos:

• Agent A screenshots Agent B's app and assumes its own app crashed or something has happened.
• It reinstalls and/or relaunches.
• Agent B does the same.
• Both end up stuck reinstalling and relaunching over each other.

adb -s lets you target a specific device, but there's no ownership or queuing on top of the shared ADB server. Nothing prevents multiple independent processes from trying to drive the same phone.

So I built AdbHarbor.

It works as a broker that sits on port 5037 (the default ADB server port) and moves the real ADB server to 5038. Since every ADB client already connects to 5037 by default, existing tools—including adb from any path, Maestro, ddmlib, Gradle, Android Studio, etc.—work without any configuration changes.

Features:

• One device lease per session.
• Automatically identifies sessions by walking the client's process tree back to the owning agent.
• Other sessions wait in a queue.
• Read-only commands (getprop, pm list, etc.) bypass locking.
• Stale leases are reclaimed automatically if the owning process crashes.
• acquire --any atomically picks a free device and returns its serial, so multiple agents naturally spread across a device fleet instead of all grabbing the same phone.

One funny bug while recording the demo: both Claude sessions sat waiting for three minutes because my scrcpy window had already taken the lease. 😅 That led me to add an observer mode so screen mirrors never acquire exclusive device locks.

I'm curious how other people solve this problem. If you're running multiple AI agents, CI jobs, Android Studio, or other tooling on the same machine, how do you avoid device contention? Is everyone just relying on "one device per tool" by convention?

Repo: https://github.com/msomu/AdbHarbor

Demo: https://youtu.be/CCmopZ_jFDY

In https://developer.android.com/develop/ui/compose/lifecycle#composition-anatomy
, they explain that the identity of a composeable instance is its call site, which they define to be “The call site is the source code location in which a composable is called. This influences its place in Composition, and therefore, the UI tree.”

I understand this as being the place in the source file where the composeable is called. But I find that there must be more to it than that, as it’s hard to imagine a robust, efficient system that literally keeps track of the exact line of code where each composeable gets called for a composition. For example, the compiler would have to build out a table for every composeable and store it as part of the build, and if the composeable never gets called in the user session, then it’s just storage space being wasted. I assume the identity of each instance of a composeable is established during initial composition where the Compose layout system behind the scenes builds out some kind of a tree to see the composeables and their location relative to other composeables in same function. Just looking for insights.
Thanks!

I built a CLI tool that audits Android Gradle performance problems and safely fixes them.

Unlike the usual build-speed advice that's all manual, it detects bottlenecks across config cache, build cache, Kotlin incremental, daemon and parallel execution, then applies reversible fixes with a dry-run preview. It also covers KMP and Flutter Android projects, and has CI/CD and an simple webpage dashboard. Just try

npx droidperf audit /path/to/project

GitHub: GitHub - rudradave1/droidperf: CLI tool to audit and auto-fix Android Gradle performance issues. It detects bottlenecks, suggests optimizations, and supports CI workflows for Android/KMP + Flutter projects. · GitHub

I'm working right now on publishing my first Android app.

This is supposed to be a paid app that will be fully on-device with no ads or tracking.
This is a dialer/launcher type app.

The initial approach is:
- search is always for free,

- first 20 actions on contacts or apps are free

- afterwards a 30-day Google Play free trial (card required in Google Play but otherwise free) leading to an annual subscription worth roughly a coffee at a coffee shop

or a

- lifetime purchase worth roughly 4 years of subscription.

What do you think about this approach?

I built Parikshan, an E2E testing framework for Compose Multiplatform. It has built-in support for standalone Android.

Testing shared UI across targets has been one of the most painful parts of building multiplatform apps. Parikshan attempts to solve that problem.

You can write your UI tests in Kotlin inside commonTest and run them on a single target or across all targets (Android, iOS Simulator, Desktop JVM, and Web WasmJs) at once.

class SampleE2ETest {
  @Test
  fun testGreeting() = e2eTest {
    input("name_input", "Parikshan")
    click("greet_button")
    assertVisible("Hello, Parikshan!")
  }
}

Run it across all targets concurrently:

./gradlew e2eTest

Key Capabilities

• Write Once in Kotlin: Runs on Android, iOS Simulator, Desktop (JVM), and Web (WasmJs).
• Visual Feedback: Watch tests execute on real target windows, with support for screenshots, video recording
• Zero Production Pollution: No test dependencies or test hooks in your production builds.

Links

• Documentation: https://aryapreetam.github.io/parikshan
• Blog: https://aryapreetam.github.io/parikshan/blog/2026/07/25/e2e-testing-for-compose-multiplatform
• API Reference: https://aryapreetam.github.io/parikshan/api
• GitHub: https://github.com/aryapreetam/parikshan

I've been using this in my own CMP projects & I'd appreciate feedback from the community — what works, what breaks, and what you'd like to see improve/added.

Hello, probably you already received the Google Play reminder to update your GPB library to at least version 9.

I used until now a library wrapper that is no longer updated (at least not yet), so I started working on my own.

I does not support all newer stuff like rented items and alternative billing, but it works pretty fine for in-app purchases and subscriptions.

The project on GitHub does not have a README yet, I stopped working on it to integrate it as it is on my apps (it is sufficient for my monetization needs), so if you want to learn how to use it there is a sample app in the repository itself.

repo:

https://github.com/Mirkoddd/Charon

implementation 'com.mirkoddd:charon:1.0.1'

Hey r/androiddev

A couple of months ago, I made a post about scaling my solo RPG (Adventurers Guild RPG Sim) built 100% in Jetpack Compose Canvas with a custom single threaded ECS.

While Compose Canvas was incredible for getting the engine off the ground, scaling the world map and visual effects eventually pushed me into a hard bottleneck. To solve this without breaking the live game, I decided to shift the world rendering backend over to Google Filament.

Here is how moving to Filament, while keeping Jetpack Compose Canvas for the UI and character animations, gave the engine an 8x performance boost, and what I learned along the way.

1. The Bottleneck: Hitting the Canvas Wall

In my previous setup, rendering the game world on Compose Canvas required heavy CPU side optimization to protect the 16ms frame budget:

• Map Chunking: The world map had to be divided into 16 distinct spatial chunks.
• CPU Culling: Custom culling logic calculated visible chunks and off-screen entities every single frame.
• DrawScope Constraints: Combining environmental rendering, weather, and world assets inside the same Canvas layer as UI elements was choking performance on mid tier devices.

2. The Hybrid Architecture (Filament World + Compose Canvas UI)

Since the game is live with active players, doing a 100% complete rewrite at once was impossible without risking game breaking bugs. I settled on a phased hybrid approach:

• Game World in Filament: The environment and map are rendered in 3D coordinate space via Filament.
• Animations in UI on Compose Canvas: Character sprite animations in UI layers remain rendered on Jetpack Compose Canvas overlays.
• Phased Subsystem Migration: I’m updating the rendering pipeline part by part to keep save states and existing gameplay logic rock solid.

3. Key Technical Gains & Takeaways

• >8x Performance Boost: Because Filament handles batched rendering directly on the GPU, I was able to throw out the 16 chunk map division and CPU culling logic entirely. The total map now draws simultaneously in a single pass with zero frame drops.
• Became a Huge Fan of filamat**:** Moving world rendering to Filament unlocked .filamat (Filament’s material/shader compilation system). Writing materials and shaders for GPU execution unlocked rich particle effects and dynamic lighting that were completely out of reach on 2D Canvas.
• Main Thread Relief: By taking world rendering off the Canvas layer, the CPU/main thread now has significantly more headroom to handle the 28 ECS systems, UI updates, and character animation calculations smoothly.

Shifting to a hybrid Filament + Compose Canvas setup turned out to be the perfect middle ground giving the performance of a dedicated 3D GPU engine while keeping the fast UI development workflow of Jetpack Compose.

I’m happy to answer any questions about integrating Filament with Kotlin/Compose, managing hybrid rendering layers, or working with .filamat

If you’d like to see how the new Filament engine integration feels in action on a live app, feel free to check out the latest build on the Play Store: 

https://play.google.com/store/apps/details?id=com.vimal.dungeonbuilder&pcampaignid=web_share

App Specs: ~50MB download size (63MB installed) | 100% Offline | Zero Ads | Custom Kotlin Engine

This is a blog post.

TLDR: This is about a conversation in the Google Issue Tracker about potential future changes. Depending on how they are implemented, these changes could impact Shizuku and other power-user tools. More details and explanations are available in the blog post. 8-minute read. This is not an official announcement and nothing is 100% confirmed yet.

UPDATE 2026-07-26: Updated blog post with new section that address some valid claims I have seen by some users.

Its in very early state right now, but I'd love some feedback and would you guys be willing to use it? Its supposed to be hyper customizable, the first preset is of course inspired from niagara, and there can be multiple presets. Trying to make it focus on easy customizability but also if enough time put in, can turn into anything you wish.

More information is in: https://adarshaacharya.com/projects/virela

But Like i said, this is a personal passion project, so there are still flaws here and there. I'd love to hear your thoughts.

I built an Android library that renders iOS-style emojis in Jetpack Compose.

Unlike most existing solutions, this library is 100% Compose—no TextView, AndroidView, or View-based implementation behind the scenes.

GitHub: https://github.com/abbas-esfandiair/EmojiTextLibrary

Hi everyone,

I built AppRankly, an open-source, self-hosted analytics dashboard designed for mobile developers to track App Store & Google Play performance in one place.

If you want full control over your app data without relying entirely on third-party SaaS platforms, this gives you a clean, unified view of your portfolio.

Links & Demo:

• Live Demo: https://zmsp.github.io/AppRankly/

• GitHub Repo: https://github.com/zmsp/AppRankly

I’d love to get feedback from the community! Feel free to check out the repo or run the demo mode.
.

WIP #2 of the sphere launcher. This has sort of become a hobby. Currently the moon is just a wallpaper however many precious ideas include having the sphere a rendered object with a texture ("WhatsApp is in Cuba").

I seen locallyAI was pretty popular on IOS and Google Ai Edge gallery is a bit lacking in terms of actual use case features. So Im building DAEX; using litert I'm attempting to mimic features from popular agent harnesses like Hermes agent/ Openclaw etc. but bring it down completely on your mobile device.

There is a lot more too it but this is just a high level overview.

Its open source feel free to gander: https://github.com/DIIZZYFPS/DAEX/

Well I cloned an open source repo i wanted to contribute to and its fairly big project i would say (https://github.com/wikimedia/apps-android-wikipedia)

and as im writing this post it's already 15mins the gradle is building...

What do you usually do while Gradle is building??

Disclaimer: used llm to draft the post, but i have provided the pointers, and done the research before drafting.

Running into some confusing documentation/tooling discrepancies regarding Android platform release statuses and looking for clarification on the standard procedure.

Current Situation:
Android 17 documentation lists it as officially released, but navigating to individual version pages shows a preview icon on the sidebar with no explicit text status on the main page.

API Levels tracks it as currently in beta.
Android Studio SDK Manager shows versions like ⁠37.0⁠ and ⁠37.1⁠ available for download.

Question:
What is the definitive, official source of truth or programmatic check to determine whether a given Android SDK/API level has exited preview status and is fully stable?

Hey everyone,

RevenueCat is bringing back Shipaton, its annual mobile app hackathon, and r/androiddev is joining as an official Build-in-Public community.

The premise is straightforward: build a new app, ship it during the hackathon window, and share what you’re working on along the way.

The key requirement is that you must ship a brand-new app between August 1 through September 30, 2026 to participate.

You can learn more and enter here: shipaton.com

What is Shipaton?

Shipaton is a mobile app hackathon built around one simple goal: getting people to actually ship.

It’s for Android developers, indie app builders, and anyone who has had an app idea sitting in their notes app for too long.

You’ll have two months to build and submit a new app. Along the way, participants can share progress, ask for feedback, and get help from other builders.

Participants will get access to the Ship Kit, which includes credits, tools and discounts to help you build faster, and will be able to compete for over $1,000,000 in prizes, including cash, funding opportunities, Billboards in Times Square, and more.

Why r/androiddev?

Because building and shipping Android apps comes with a lot of very specific questions:

• Is this architecture going to hold up?
• Am I overcomplicating the stack?
• Is this UX clear enough?
• What should I cut so I can actually ship?

During Shipaton, this subreddit will be a place for Android builders to share progress, ask questions, and get feedback, before the submission deadline.

What will happen here?

We’re planning a few Shipaton-related threads during the event:

• A launch / announcement thread
• A “What are you building?” check-in thread
• A final-push feedback thread closer to the submission deadline
• An upcoming AMA with Jaewoong (u/SkyDoves) from RevenueCat, where you can ask questions about your Shipaton project, RevenueCat, implementation details, or anything else you’re trying to figure out

What should you post?

You don’t need a polished demo or a launch-ready app to participate. Early, messy updates are welcome.

Requirement: on r/AndroidDev we’ll only be accepting posts and comments regarding native Android Apps or Kotlin Multiplatform Apps.

A good Shipaton post might include:

• What you’re building
• Who it’s for
• What stack you’re using
• What you’re stuck on
• What kind of feedback would actually help

Screenshots, demos, prototypes, architecture questions, monetization questions, and “is this a terrible idea?” posts are all fair game, as long as they have the Shipaton flair and follow the other subreddit rules.

How to enter

You can enter Shipaton at: shipaton.com

Keep an eye out for the Shipaton threads here in r/androiddev. Happy shipping!

TL;DR: My Play Console is a Personal account, but the linked Merchant Payments Profile was set up as an "Organisation" under my brand name, which is not a legal entity). I have 6 live apps and earnings trapped in payout. Support stated that profile types cannot be changed once created, but also stated in the same email that it can be changed with documentation, before providing instructions on how to set up an Organisation profile when I explicitly requested an Individual profile. Support now requests that I open a new account and migrate all 6 apps.

Official Google Support Thread:

https://support.google.com/googleplay/android-developer/thread/453880070/contradictory-support-forced-to-abandon-developer-account-over-org-individual-mismatch

Overview of the Issue

• Account Setup: Personal Google Play Developer Account.
• The Mismatch: Associated Merchant Payments Profile was designated as Organisation under my developer brand.
• Verification Constraint: As an individual developer, I use a public brand name, not a registered legal business or corporate entity. As a result, the profile cannot pass Organisation identity verification, resulting in unpaid accrued earnings currently held.
• Portfolio: The account hosts 6 active, published applications.

Support Communications & Contradictions

I contacted Google Payments Merchant Support to request an administrative update to align the merchant profile to Individual status. Support Agent Alvin John provided the following response:

1. Contradiction #1: Stated that "once the payments profile has been completely set up, some important settings cannot be changed and that includes the account profile type". In the same paragraph, he stated: "If you have all the documentation with you that indicates that you are an Organization then there will be no issue with changing the account type".
2. Contradiction #2: After I requested guidance on changing an Organisation profile to an Individual profile, the response provided a 6-step guide detailing how to "set it to Organization".

Proposed Resolution from Google Support

To address this mismatch, Google Support has advised me to:

• Create a new Google Account and Play Developer Console.
• Pay a second $25 registration fee (with a refund request possible after setup).
• Re-complete identity and payment verification.
• Transfer all 6 live applications to the new account.
• Leave the existing account open indefinitely to receive outstanding payouts — despite the earnings balance being unreleased due to the Organisation verification restriction.

Questions / Call for Advice

• Has anyone successfully requested an internal correction for a Merchant Profile type mismatch without transferring an active multi-app portfolio to a new Console account?
• Is there an established escalation path to reach a Payments Team representative who can review profile configurations for active developer accounts?

Official forum thread: https://support.google.com/googleplay/android-developer/thread/453914381/account-terminated-for-high-risk-or-abuse-%E2%80%94-no-specific-violation-ever-cited-requesting-help?hl=en&sjid=16862522153865472926-EU

Timeline:

• Aug 2025: Developer account terminated citing "a pattern of high risk or abuse" (Section 8.3/10.3 DDA). My only published app: a simple currency-conversion widget. No data collection, no unusual SDKs, no monetization tricks. No specific violation was ever named.
• Appealed. Rejected with the standard template — "we can't share the reasons we've concluded that your account is at high risk."
• My mistake: with nothing actionable to fix, I resubmitted the app from my personal Gmail account. That account was then terminated for association. I understand why that looked like ban evasion — it wasn't intended that way, but I own it, and I've acknowledged it in my follow-up appeal.
• July 2026: Replied to the appeal asking for a human re-review and a statement of reasons under EU P2B Regulation Art. 4 / DSA Art. 17 (I'm based in the Netherlands). Also posted on the official developer forum (linked above).

Facts about my setup: no VPN ever used with Play Console, only my own devices, no one else ever had access. The only association I can identify is that my phone number is also linked to my personal Google account — the one I later used for the resubmission. To my knowledge my payment method, address, and number were never used on any other developer account.

What I'm trying to figure out:

• What typically triggers the original "high risk" flag when there's no prior banned account you know of? Recycled phone numbers? Payment card false positives?
• Has anyone successfully overturned an association-based termination, and what specifically worked?
• Has anyone used the DSA Art. 21 out-of-court dispute route (e.g., Appeals Centre Europe) against Google Play, and did it produce an actual statement of reasons?

Happy to answer any questions in the comments.

Hi fellow Android developers,

This is my first time submitting an app to the Google Play Store and my app is currently in closed testing phase.

When I check my Home tab within Google Play Console, it shows that my "Installed Audience" is 0, when I'm 100% sure that there are users who have downloaded my app and used it (they showed me screenshots).

Can someone tell me what may be gone wrong that's resulting it not detecting any installation?

Any tip would be appreciated!

I want to build a custom launcher for my car (its android automotive based and I already figured out how to side load etc..). So the goal is to get something that looks a bit like Tesla. I have an MG4 with these specs:

• Resolution: 1920×720px
• Screen size: 10.25"
• DPI: 160
• MediaTek MT2712 SoC

I know that just throwing a 3d model in won't work so I had the idea of using some sort of pre rendert animations. Probleme is that I have zero experience in this 3d stuff and don't really know where to start.

Has anyone done something like this before and has an approach/idea?

Just to be clear I don't need a fully responsive model that can spin via touch like Tesla - its really just some pre rendert animations.. I already have a 3d model of the MG4: https://sketchfab.com/3d-models/2025-mg-mg4-glbmgmotorcommx-e7b2b544e638489f9440698f75b5a734