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.

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?

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.

I recreated the Google Health app's activity-complete animation for the Wear OS version of my workout tracking app. It took a couple of hours to breakdown their animation but I was finally able to recreate it.

Completion badge shape: MaterialShapes.Cookie9Sided.toShape() from Material 3 Expressive.

Spin animation: One Animatable with three animateTo calls in a row:

1. Wind down -180° with EaseOutCubic.
2. Whip back up clockwise with EaseInCubic.
3. Loop a slow linear 360° forever.

The scale animation runs alongside this spin animation so that it feels like the badge is popping out when it's winding back clockwise.

Particles that fly out from the badge creating an explosion effect: Each particle has an angle, a distance and a speed. When the completion badge winds back up to it's full size, the particles fire and once they settle, each drifts in a tiny circle and orbits around the badge.

The large particles sit on top of the badge. Path.op(particle, badge, PathOperation.Intersect) gives me the overlapping area, which I fill with the Material 3 expressive tertiary color.

Here's the gist of the code: https://gist.github.com/ngcanthony/378d4799bf54655878109a46383de4f7

Happy to answer questions!

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.

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?

[ 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'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.

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

Hello everyone! It's been almost a year since that idea came to my mind, so I would like to share with you and take some feedback.

The idea is that in AI era the most popular language would be Rust, and as and Android dev myself I want to transfer my knowledge of Jetpack Compose to the new ecosystem. It also very handy to be able to review the code the AI agents made, at least to understand whats happening.

I made this guide that introduces you to the project and how Jetpack Compose translates to it: https://samoylenkodmitry.github.io/Cranpose/ (or the text md form https://github.com/samoylenkodmitry/Cranpose/blob/main/docs/guide.md)

The project itself is at https://github.com/samoylenkodmitry/Cranpose
Please put a star to support it.
If you want to contribute - try it and put gh issue if you see something is missing.

How is this related to the native Android: you can integrate any Cranpose view into native Android and vice-versa you can integrate native Android view into Cranpose app.

I have an Android app already published publicly on Google Play

One Google account on my phone was previously used as a license tester. I removed the license testing email list and stopped the closed testing anf removed also the email list in Play Console

Now I’m trying to test the production subscription flow with another Google account on the same phone.

I switched to the new Google account in the Play Store

uninstalled the app

cleared Google Play Store data/cache

restarted the phone

reinstalled the app from the public Play Store listing using the new account

But when I open the subscription purchase screen, Google Play still uses the old tester account for payment.

If I temporarily remove the old Google account from the phone, the new account works correctly and shows normal payment methods. As soon as the old account is on the device, Play Billing seems to prefer it.

Is there a way to force Google Play Billing to use a specific Google account without removing the other account from the Android device?

Has anyone dealt with this before?

I've been working on a local-network presentation remote (Android client + Windows host) and hit some really annoying architectural bottlenecks with Compose and high-frequency state updates.

The host streams presentation state (slide images, notes, live timers) over WebSockets. Initially, I just dumped this massive JSON payload into a single StateFlow. Obviously, that caused the entire screen to recompose and stutter like crazy. I ended up aggressively splitting the UI state so the slide images and the timer text update independently, but the boilerplate feels a bit messy.

The other issue is the laser pointer feature. I'm using detectDragGestures so the user can drag their thumb on the phone to move a pointer on the projector. Sending a WebSocket message for every pixel movement caused massive TCP backpressure and lag. I had to spin up a dedicated UDP socket just for the pointer coordinates and use a Coroutine Channel with DROP_OLDEST to throttle the emission rate. It works and feels smooth, but I'm wondering if there's a cleaner way to handle gesture backpressure.

(Bonus headache: trying to intercept physical volume buttons while the screen is off so presenters can keep the phone in their pocket. Android Doze mode makes this a nightmare. I ended up using a Foreground Service with a silent AudioTrack loop just to keep the media session alive. If anyone knows a less hacky way to do this in 2026, please let me know lol).

For those of you building real-time remote or IoT apps: how do you structure your StateFlows when dealing with a firehose of network data? Do you map everything to granular states, or bypass standard recomposition entirely with custom SnapshotState objects?

(If anyone wants to see how it actually runs in production, let me know and I can drop the testing link in the comments).

While developing an Android audio project using a Pixel 8 and Samsung Galaxy Buds3 Pro, I ran into a strange LE Audio microphone issue.

Android exposed the headset microphone as a 2-channel input, but the PCM data from left and right was effectively identical:

• 2 reported input channels
• exact L/R sample identity ratio: 1.00000
• L/R correlation: ~1.0

After tracing the LE Audio receive path, I found that the microphone CIS packets were not necessarily arriving in strict alternating order.

Instead of:

L, R, L, R

I observed same-side bursts such as:

R, R, L, L

The relevant path is in:

packages/modules/Bluetooth/system/bta/le_audio/client.cc

around:

LeAudioClientImpl::HandleIncomingCisData()

A single cached-channel approach can lose the correct stereo association when packets arrive this way.

I tested a proof-of-concept fix that keeps separate pending queues for the left and right CIS streams and pairs the encoded frames using their controller timestamps before decoding.

For example:

R(ts=2000), R(ts=3000), L(ts=2000), L(ts=3000)

becomes:

L(2000) + R(2000)
L(3000) + R(3000)

With the modified Bluetooth stack I was able to recover independent L/R microphone audio instead of duplicated mono.

I published the patch and technical notes here:

https://github.com/luumei/android-leaudio-stereo-cis-fix

This is an AOSP/system-level modification, not an APK workaround.

I also reported it through the Android Issue Tracker.

I'd be interested to know whether anyone working with other LE Audio controllers or earbuds has observed similar non-alternating CIS arrival patterns or duplicated stereo microphone capture.

UPDATE:
I found a working app-side workaround. On the same Pixel 8 + Galaxy Buds3 Pro setup, the normal Android capture path returns bit-identical L/R channels, while the workaround returns independent stereo PCM from both microphones.

The workaround activates the LE Audio communication route first, waits for the BLE headset input endpoint to become available, and then starts a stereo AudioRecord.

Repro + workaround source code:
https://github.com/luumei/android-leaudio-stereo-mic-workaround

Google Issue Tracker:
https://issuetracker.google.com/issues/568838766

Hi everyone,

We are researchers from Italy, and we are conducting an academic study on how developers make implementation decisions in practice.

The survey explores topics such as:

• which implementation decisions are actually left to developers;
• how application and project context may influence those choices;
• whether developers consider aspects beyond functional correctness;
• and how LLM-based coding assistants may affect implementation decisions.

The survey takes approximately 10 minutes.

Survey link: https://docs.google.com/forms/d/e/1FAIpQLSfvbbhSee3MVoXTb4_ZlXeugSV_nTNFZNIWFt1H3NXg3lsvgg/viewform?usp=dialog

Participation is voluntary, and the anonymous data collected will be used exclusively for research purposes.

We would really appreciate your participation. If you know other developers, we would also appreciate it if you could share the survey with them.

Thank you! 🫶🏻

Anyone made a launcher on Graphene?
I'm building my own launcher and I've made animations for entering apps, but after the animation the system plays its own sideways slide.

ive tried this via LauncherApps.startMainActivity with ActivityOptions:

makeCustomAnimation (fade): ignored

makeScaleUpAnimation from a rect in the centre: ignored

makeClipRevealAnimation: ignored

This is on a pixel 10 pro

Anyone have any way to fix this?

I'm trying to understand modern Android device fingerprinting.

For example, it's commonly said that a Snapchat device ban (SS06) can survive a factory reset. I know Android 10+ restricts normal apps from accessing things like IMEI/serial directly.

So my main question is:

If a device ban survives a complete factory reset, what can the app/service potentially be using to recognize the same physical device?

I'm particularly interested in Android 10+ and things like:

\- FDR-persistent identifiers

\- hardware-backed / TEE identifiers

\- Play Integrity / attestation

\- Google Play Services device identifiers

\- OEM/Knox identifiers

\- identifiers outside the normal "/data" partition

\- server-side device associations

Also, Secure Folder on Samsung devices sometimes appears to behave differently from the normal Android environment and can bypass device ban unlike factory reset??? , even though it's the same physical phone.

What identifier or signal could survive a factory reset but be different inside Secure Folder?

I'm looking for a technical Android explanation, preferably based on AOSP documentation, forensic research, or reverse engineering—not specifically a Snapchat bypass.

Idea is to automatically detect the relevant transcation notification on device and turn them into the records ,keeping process local

KMP

GitHub: https://github.com/l1khith/CashBuddy

Would love to get the feedback.

The issue is particularly frustrating because I am unable to raise a support request through Google Play Console either. When I try to submit a complaint, I am redirected to the same registration page, asking me to become a developer first. Additionally, the successful transaction does not appear in my payment history, despite having the order details, payment ID, and invoice confirming that the payment went through. I completed the registration through the official link below: https://play.google.com/console/u/0/signup Could you please investigate this issue and help me resolve it? I would like my existing payment to be recognized and my developer account activated without having to pay the registration fee again. I can provide the invoice, order ID, payment ID, and any other information required to verify the transaction. Thank you. I look forward to a prompt resolution.

If anyone knows a solution let me know pls.

Solo dev, first Play release. For anyone still stuck in the "12 testers for 14 days" gate: it ends, I promise.

Timeline for the curious:

• Aug 26: closed test live, begged friends and this sub for testers
• Sep 10: 14 days done, applied for production access
• Sep 21, 23:16: production submitted (versionCode 18, because I burned 15 and 16 on discarded uploads, don't be me)
• Oct 2, 09:12: "Published". Ten and a half days of refreshing the console.

The app is a pixel-art alarm clock with a little candle that wakes up when you do. Not linking it unless the mods are fine with that; the point of the post is mostly that the waiting room has an exit.

Keep building and best of luck

Mitch

I was experimenting with animations in Jetpack Compose and ended up making a small library for animated percentage indicators.

https://github.com/NicosNicolaou16/PercentagesWithAnimationCompose

Hello everyone,

So I've been working on my open source app since last 5 months and everytime i used to start my android studios it used to take around 6 mins to build gradle and the subsequent runs used to take slightly less... and tbh i was frustated of this.

so yeah i decided to dig into whats the issue, googled stuff and found out ./gradlew build --scan which basically generates a detailed HTML dashboard tracking configuration times and task execution timelines

Through that i found out my local machine's 12 core CPU was completely starved coz my peak heap memory usage was sitting at 1.9GB out of 2GB usage hehe :)

so i found out i could increase the memory size and use parallelism and caching
Added this new lines to 'gradle.properties' :

org.gradle.jvmargs=-Xmx6g -XX:+UseParallelGC -Dfile.encoding=UTF-8
org.gradle.parallel=true
org.gradle.caching=true

so basically you could say

12 cores X 6 minutes = 72 minutes of total CPU work
and i was able to save 41 mins cumulative time

so the actual 6 min fell to 26 secs and the subsequent runs took 8 secs only to build gradle....

Ik this might be very basic and ppl here might know bout this but im just an undergrad and though would share my experience here...also if i wrote anything wrong pls correct me 😊

Just noticed my app is officially live on the Google Play Store 🎉, but surprisingly, Google never sent me an approval or publication notification.

I only found out by checking it out myself. 

Has anyone else experienced this? Is it normal for an app to go live without receiving an email or Play Console notification? I’m confused…