# ProAndroidDev

The latest posts from Android Professionals and Google Developer Experts. - Medium

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## Koko, KMP Starter Kit -- Part 4: Monetization and Growth

DevFeed: [Koko, KMP Starter Kit -- Part 4: Monetization and Growth](<https://devfeed.tech/articles/koko-kmp-starter-kit-part-4-monetization-and-growth-144054.md>)

Original publisher: [Read original article](<https://proandroiddev.com/koko-kmp-starter-kit-part-4-monetization-and-growth-f0030fe32f5a?source=rss----c72404660798---4>)

Author: Mirzamehdi Karimov

Published: 2026-11-19T16:14:57Z

Content type: tutorial

Language: en

Sources: [ProAndroidDev](<https://devfeed.tech/sources/proandroiddev-medium.md>)

Topics: [feature flags](<https://devfeed.tech/topics/feature-flags.md>), [AdMob](<https://devfeed.tech/topics/admob.md>), [firebase-remote-config](<https://devfeed.tech/topics/firebase-remote-config.md>)

Tags: [ads](<https://devfeed.tech/tags/ads.md>), [analytics](<https://devfeed.tech/tags/analytics.md>), [android-app-development](<https://devfeed.tech/tags/android-app-development.md>), [compose-multiplatform](<https://devfeed.tech/tags/compose-multiplatform.md>), [feature-flags](<https://devfeed.tech/tags/feature-flags.md>), [firebase](<https://devfeed.tech/tags/firebase.md>), [growth](<https://devfeed.tech/tags/growth.md>), [ios-app-development](<https://devfeed.tech/tags/ios-app-development.md>), [kmp](<https://devfeed.tech/tags/kmp.md>), [kotlin-multiplatform](<https://devfeed.tech/tags/kotlin-multiplatform.md>), [monetization](<https://devfeed.tech/tags/monetization.md>), [notifications](<https://devfeed.tech/tags/notifications.md>)

### AI overview

The starter kit keeps paid features off by default; enabling `PREMIUM_FEATURES_ENABLED` turns on subscriptions, the paywall and credits. Before configuring billing, developers define prices, trials and credit packs in `paywall.md`; a demo provider supports testing purchases without real money until store keys are added. Real subscriptions use Adapty or RevenueCat, with matching products configured in both stores. Credits can grant bonuses and recurring allowances, but balances are stored only on the device unless moved to a server. AdMob is optional and requires ad setup and privacy disclosures. For growth, the kit uses Firebase for crash reports, analytics and Remote Config flags, while KMPNotifier supports local and push notifications; iOS push requires APNs setup. The article also covers review prompts and referral credits, and recommends adding phases as needed.

### Source excerpt

Part 4 of 4: the last two phases of the KMP contest starter kit. Subscriptions, credits and ads, then analytics, feature flags and notifications. New here? Part 1 introduces the kit and gets your app running on your machine. Part 2 connects it to Firebase, sign in and a backend. Part 3 publishes it to the stores. Your app is in the stores and people are installing it. Two questions are left: should it make money, and how do you keep people using it? These are the kit's last two phases, monetization and growth, and this post covers both. Free or paid By default the kit has no paid features. In AppConfiguration.kt: PREMIUM_FEATURES_ENABLED = false With false there is no paywall, no upgrade buttons, billing is never initialized, and credits are off, so everything in the app is free. If your app should stay free, leave it and go to the growth part below. To add paid features, set it to true. The paywall, the subscriptions screen and the credit system all turn on. Decide the offer first Before opening any billing dashboard, decide what you sell. The kit keeps this in one file: AiGuidelines/project/paywall.md. What is premium was already decided in phase 1. What's left is marked TODO(monetization): prices, trial length, credit pack sizes. Ask your assistant to "design the paywall" and it asks you about each one: Agent: Your paywall has a weekly and a yearly plan. What should the yearly price be? Weekly at $4.99 adds up to about $260 a year, so a yearly price under $60 shows as a big saving. And how long should the free trial be, 3 days or 7? The kit's paywall guide has three rules: Write the terms clearly: "7 days free, then $39.99 a year. Cancel anytime." No fake countdowns and no hidden cancel button. Show the paywall at the end of onboarding, not on first open. The paywall text lives in strings.xml, with a paywall_ prefix on every string, so you change the copy without touching code. To see the result, ask "show me the paywall" and the kit renders it to an image: Demo

## Android UI thread vs. RenderThread: what actually happens when a frame is drawn

DevFeed: [Android UI thread vs. RenderThread: what actually happens when a frame is drawn](<https://devfeed.tech/articles/android-ui-thread-vs-renderthread-what-actually-happens-when-a-frame-is-drawn-140454.md>)

Original publisher: [Read original article](<https://proandroiddev.com/android-ui-thread-vs-renderthread-3f54bb74340f?source=rss----c72404660798---4>)

Author: Ravi Rawal

Published: 2026-11-17T19:50:28Z

Content type: article

Language: en

Sources: [ProAndroidDev](<https://devfeed.tech/sources/proandroiddev-medium.md>)

Topics: [Android](<https://devfeed.tech/topics/android.md>), [jank](<https://devfeed.tech/topics/jank.md>), [real-time rendering](<https://devfeed.tech/topics/real-time-rendering.md>), [Jetpack](<https://devfeed.tech/topics/jetpack.md>)

Tags: [accelerated](<https://devfeed.tech/tags/accelerated.md>), [acceleration](<https://devfeed.tech/tags/acceleration.md>), [also](<https://devfeed.tech/tags/also.md>), [android](<https://devfeed.tech/tags/android.md>), [android-app-development](<https://devfeed.tech/tags/android-app-development.md>), [animation](<https://devfeed.tech/tags/animation.md>), [app](<https://devfeed.tech/tags/app.md>), [application](<https://devfeed.tech/tags/application.md>), [apps](<https://devfeed.tech/tags/apps.md>), [background](<https://devfeed.tech/tags/background.md>), [blocking](<https://devfeed.tech/tags/blocking.md>), [buffer](<https://devfeed.tech/tags/buffer.md>), [but](<https://devfeed.tech/tags/but.md>), [can](<https://devfeed.tech/tags/can.md>), [canvas](<https://devfeed.tech/tags/canvas.md>), [cause](<https://devfeed.tech/tags/cause.md>), [changes](<https://devfeed.tech/tags/changes.md>), [frame](<https://devfeed.tech/tags/frame.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [performance](<https://devfeed.tech/tags/performance.md>), [software-engineering](<https://devfeed.tech/tags/software-engineering.md>), [thread](<https://devfeed.tech/tags/thread.md>), [ui](<https://devfeed.tech/tags/ui.md>), [vs](<https://devfeed.tech/tags/vs.md>)

### AI overview

Frame drops can persist even when app code is off the main thread because frame preparation, command rendering, GPU execution, and display composition are separate stages. The UI thread handles callbacks, layout and drawing; with hardware acceleration, onDraw() records commands into display lists rather than rasterizing them. RenderThread replays those lists and submits graphics work, the GPU executes it, and SurfaceFlinger composes the app buffer. Diagnose the slow stage with a system trace: inspect main-thread Choreographer work, RenderThread DrawFrame, GPU completion, and presentation timing. Heavy onDraw() calculations can delay submission; costly paths or clips can make RenderThread slow; textures, overdraw, or shaders can saturate the GPU. Cache geometry or simplify commands according to the bottleneck. Compose uses the same graphics pipeline, though state reads can be placed in different stages to limit which work reruns. The supplied text is an excerpt and does not establish full-document coverage.

### Source excerpt

An Android app with a non-blocking main thread in your application can still get frame drops. This seems odd as we know that drawing a frame involves several components. Our code will only run in the first component. The UI thread will handle the app-side of things and records the drawing commands. A Native thread (RenderThread) will take these recordings and do the actual rendering. The GPU will then execute the graphics commands and SurfaceFlinger will compose your apps buffer with everything else on screen. This can be confusing when trying to solve dropped frames. Slowness in your onDraw() and an overloaded GPU will look the same to your users, but need different solutions. Moving your code to a background thread will only help with one of these issues. To find out which issue you have, follow your frame through the pipeline. What the UI thread does Every app has a main thread, usually called the UI thread. It owns the main message queue and runs lifecycle callbacks, input events and anything posted to the main looper. For the View system it also applies property changes, measures and lays out the hierarchy, runs animation callbacks, calls View.draw() and your onDraw(), and records drawing operations for hardware-accelerated rendering. The last job is easy to overlook. With hardware acceleration, onDraw() does not rasterize anything. Your Canvas calls are recorded into a display list, and each View keeps its own (a RenderNode). Here is a simple custom View: class ProgressView(context: Context) : View(context) { private val paint = Paint(Paint.ANTI_ALIAS_FLAG) private var progress = 0.5f override fun onDraw(canvas: Canvas) { super.onDraw(canvas) canvas.drawCircle(width / 2f, height / 2f, width * progress / 2f, paint) } } When invalidate() schedules a redraw, the framework calls onDraw() during the next frame traversal, on the UI thread, and the circle is recorded rather than painted. That is why a custom View can cause jank while the GPU is almost idle. If onDraw

## Migrating a Real Android App to Kotlin Multiplatform 4/4 -- Shipping WebAssembly to Productio

DevFeed: [Migrating a Real Android App to Kotlin Multiplatform 4/4 -- Shipping WebAssembly to Productio](<https://devfeed.tech/articles/migrating-a-real-android-app-to-kotlin-multiplatform-4-4-shipping-webassembly-to-productio-140455.md>)

Original publisher: [Read original article](<https://proandroiddev.com/migrating-a-real-android-app-to-kotlin-multiplatform-4-4-shipping-webassembly-to-productio-e863738a8151?source=rss----c72404660798---4>)

Author: Daniel Voko

Published: 2026-11-17T19:49:30Z

Content type: article

Language: en

Sources: [ProAndroidDev](<https://devfeed.tech/sources/proandroiddev-medium.md>)

Topics: [compose-multiplatform](<https://devfeed.tech/topics/compose-multiplatform.md>), [multiplatform](<https://devfeed.tech/topics/multiplatform.md>), [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [compose-for-web](<https://devfeed.tech/topics/compose-for-web.md>), [performance-optimization](<https://devfeed.tech/topics/performance-optimization.md>), [Gradle](<https://devfeed.tech/topics/gradle.md>), [sqldelight](<https://devfeed.tech/topics/sqldelight.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [android-app-development](<https://devfeed.tech/tags/android-app-development.md>), [androiddev](<https://devfeed.tech/tags/androiddev.md>), [compose-multiplatform](<https://devfeed.tech/tags/compose-multiplatform.md>), [jetpack-compose](<https://devfeed.tech/tags/jetpack-compose.md>), [kmp](<https://devfeed.tech/tags/kmp.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [kotlin-multiplatform](<https://devfeed.tech/tags/kotlin-multiplatform.md>), [multiplatform](<https://devfeed.tech/tags/multiplatform.md>), [production](<https://devfeed.tech/tags/production.md>), [splash-screen](<https://devfeed.tech/tags/splash-screen.md>), [the-web](<https://devfeed.tech/tags/the-web.md>), [webassembly](<https://devfeed.tech/tags/webassembly.md>)

### AI overview

A Kotlin Multiplatform app that builds for WebAssembly still needs browser-specific production work. The excerpt describes an inline HTML splash screen for a roughly 19 MB bundle, a spinner with visible timeout and error states instead of a misleading byte-based progress bar, and browser-history navigation whose fragment routes must stay synchronized with backend redirects. It also covers a server-side image proxy needed because Strava's CDN lacks CORS headers, with requests tagged by client so native apps keep using original URLs. In the browser, SQLDelight uses sql.js with a hand-maintained schema mirror, creating a risk that schema changes break web only. A deployed-origin `blob:` media issue required a custom Coil mapper and fetcher. These examples show how browser loading, routing, security, storage and media behavior can affect architecture and maintenance.

### Source excerpt

The wasm build runs locally in minutes. ./gradlew wasmJsBrowserDevelopmentRun, a browser tab opens, the app is there. It feels finished. It isn't, and the reason is the subject of this article. The browser isn't a fourth target that happens to render the same Compose code. It's a host with its own rules about what paints when, who owns navigation, what a page is allowed to fetch, and what a database even is. Compose Multiplatform hides none of that -- it just gets your UI onto the canvas, and then you're in someone else's house. Getting a multiplatform app to build is different from making it production-ready. Everything below is a thing that worked locally and didn't work for users. Nothing paints until the bundle arrives On Android, the launcher draws your icon the instant the user taps it. The OS owns that moment, and you get it for free. On the web you get nothing. A blank page, for as long as it takes to fetch a wasm bundle -- around 19MB -- uncompressed, and around 6.5MB Brotli transfer size -- and compile it. Users don't read that as "loading", they read it as broken, and they leave before the first frame. So the first thing I had to write for the web was something Android had given me for a decade: a splash screen. It lives inline in index.html, CSS and all, specifically so it costs no request of its own -- a splash that waits on a stylesheet defeats the purpose. The color values are a hand-copied duplicate of the theme tokens in core:designsystem, so the canvas takes over without a colour change. It's duplication I'd normally reject, and here there's no alternative: the theme lives in Kotlin inside the bundle that hasn't downloaded yet. It also has a known flaw I decided to keep. The splash follows the OS colour scheme, while the app also honours a theme the user picked by hand in settings. Someone who forced the theme against their OS gets one flash at the handover. Reading their choice would mean parsing the stored settings JSON from plain JavaScript, and coup

## Kotlin Multiplatform Networking with Native Android and iOS ViewModels

DevFeed: [Kotlin Multiplatform Networking with Native Android and iOS ViewModels](<https://devfeed.tech/articles/kotlin-multiplatform-networking-with-native-android-and-ios-viewmodels-134271.md>)

Original publisher: [Read original article](<https://proandroiddev.com/kmp-networking-native-viewmodels-cf6fb357b012?source=rss----c72404660798---4>)

Author: Ravi Rawal

Published: 2026-11-14T14:49:33Z

Content type: tutorial

Language: en

Sources: [ProAndroidDev](<https://devfeed.tech/sources/proandroiddev-medium.md>)

Topics: [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [Ktor](<https://devfeed.tech/topics/ktor.md>), [business logic](<https://devfeed.tech/topics/business-logic.md>), [Jetpack](<https://devfeed.tech/topics/jetpack.md>), [REST API](<https://devfeed.tech/topics/rest-api.md>), [coroutine-testing](<https://devfeed.tech/topics/coroutine-testing.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [api](<https://devfeed.tech/tags/api.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [business-logic](<https://devfeed.tech/tags/business-logic.md>), [cancellation](<https://devfeed.tech/tags/cancellation.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [coroutine](<https://devfeed.tech/tags/coroutine.md>), [domain](<https://devfeed.tech/tags/domain.md>), [error](<https://devfeed.tech/tags/error.md>), [http](<https://devfeed.tech/tags/http.md>), [http-client](<https://devfeed.tech/tags/http-client.md>), [ios](<https://devfeed.tech/tags/ios.md>), [jetpack](<https://devfeed.tech/tags/jetpack.md>), [kmp](<https://devfeed.tech/tags/kmp.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [kotlin-multiplatform](<https://devfeed.tech/tags/kotlin-multiplatform.md>), [multiplatform](<https://devfeed.tech/tags/multiplatform.md>), [native](<https://devfeed.tech/tags/native.md>), [networking](<https://devfeed.tech/tags/networking.md>), [published](<https://devfeed.tech/tags/published.md>), [software-architecture](<https://devfeed.tech/tags/software-architecture.md>)

### AI overview

The article recommends sharing Ktor networking, serialization, repositories, domain models, and meaningful use cases in Kotlin Multiplatform while Android and iOS retain native ViewModels and presentation state. Callers own coroutine or task lifecycles: Android can launch through `viewModelScope`; iOS can bridge Kotlin suspend functions to Swift `async`/`await` with KMP-NativeCoroutines or SKIE and cancel its Swift `Task`. Ktor requests are suspending and need no automatic dispatcher switch when they are main-safe; truly blocking or CPU-heavy work should use an appropriate injected dispatcher. Preserve cancellation, reuse the HTTP client, and keep DTO-to-domain and domain-to-UI mapping at their respective boundaries. The article notes that Swift interop adds generated types and conversions, and shared unit tests do not verify platform HTTP engines or the Kotlin-to-Swift bridge.

### Source excerpt

Share Ktor networking, repositories, and use cases while Android and iOS keep control of their native ViewModels, UI state, threading, and cancellation. Kotlin Multiplatform allows us to share networking and business logic between Android and iOS. When an API call is made from the shared Kotlin module to the native app there are a number of things we need to make a decision on. Who creates the coroutine? Who handles where the work is executed? Will the ViewModel be the same for Android and iOS? How do we get the use cases from the shared module onto each platform? The decisions here are more important than the actual HTTP client. A good KMP architecture will not have all the layers shared between both platforms. We can leave the repositories and use cases in Kotlin, have Android use its Jetpack ViewModels and iOS use SwiftUI with its native Swift ViewModels. Both platforms will call the same business functions but each will have control over their own presentation lifecycle. It's important to make sure the work that needs to be consistent is shared. Let's look at how we can create this architecture using a simple example of fetching articles from a REST API. 1. Decide what belongs in shared code Lets start with two native applications and one shared KMP module. The Android and iOS applications will not need or have identical ViewModels. But they should access to the same business operation. The shared module can own: HTTP client configuration and API requests. DTOs and serialization. Repository implementations and data-to-domain mapping. Use cases that represent application operations. Shared validation, business rules, and error classification. Android can use using Jetpack ViewModel, viewModelScope, and StateFlow. iOS may use SwiftUI, ObservableObject, @Published, and Swift concurrency. This is one of the architecture options described in the Kotlin Multiplatform ViewModel documentation: sharing the repository and data layers while keeping platform-specific ViewMo

## Don't Just Create a Flow. Know Where to Create It.

DevFeed: [Don't Just Create a Flow. Know Where to Create It.](<https://devfeed.tech/articles/don-t-just-create-a-flow-know-where-to-create-it-134270.md>)

Original publisher: [Read original article](<https://proandroiddev.com/dont-just-create-a-flow-know-where-to-create-it-8184bd4cb6eb?source=rss----c72404660798---4>)

Author: chanzmao

Published: 2026-11-14T14:18:24Z

Content type: article

Language: en

Sources: [ProAndroidDev](<https://devfeed.tech/sources/proandroiddev-medium.md>)

Topics: [coroutines-flow](<https://devfeed.tech/topics/coroutines-flow.md>), [Dependency Inversion](<https://devfeed.tech/topics/dependency-inversion.md>), [Publish-subscribe pattern](<https://devfeed.tech/topics/pubsub.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [android-app-development](<https://devfeed.tech/tags/android-app-development.md>), [android-development](<https://devfeed.tech/tags/android-development.md>), [api](<https://devfeed.tech/tags/api.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [asynchronous](<https://devfeed.tech/tags/asynchronous.md>), [callback](<https://devfeed.tech/tags/callback.md>), [database](<https://devfeed.tech/tags/database.md>), [flow](<https://devfeed.tech/tags/flow.md>), [jetpack-compose](<https://devfeed.tech/tags/jetpack-compose.md>), [mobile-app-development](<https://devfeed.tech/tags/mobile-app-development.md>), [repository](<https://devfeed.tech/tags/repository.md>), [room](<https://devfeed.tech/tags/room.md>), [software-architecture](<https://devfeed.tech/tags/software-architecture.md>), [source](<https://devfeed.tech/tags/source.md>), [suspend](<https://devfeed.tech/tags/suspend.md>), [ui](<https://devfeed.tech/tags/ui.md>)

### AI overview

Use the data source's existing Flow directly for observable Room queries and DataStore values. Bridge callback or listener APIs with `callbackFlow` in the data source, where registration and cleanup via `awaitClose` belong. Keep one-time suspend operations as suspend functions unless a stream is actually needed; collecting a Flow wrapper would rerun the operation on each collection. Repositories can map, combine, or switch among existing streams, while ViewModels derive UI state and use `stateIn()` to expose it as `StateFlow`. The article's guiding division is to convert at the source, transform in the Repository, and derive UI state in the ViewModel; it presents this as a typical approach, not a rule that every operation must use Flow.

### Source excerpt

Understanding the Architectural Timing of Flow Conversion in Kotlin and Android. Image created by AI Kotlin Flow makes it easy to work with asynchronous data streams. We can use it to observe database changes, listen for network updates, combine multiple data sources, and expose reactive data to the UI. But there is a design question that often gets overlooked: Where should we actually convert data into Flow? It's easy to wrap an API in flow {}or callbackFlow and call it a day. But doing so in the wrong layer can make an architecture unnecessarily complicated. We may end up moving callback management into the Repository, wrapping one-time operations in streams, or creating Flow objects that serve no real purpose. A better approach is to introduce Flow close to the source of the data, then let higher layers work with that stream. Let's look at what this means in practice. Start with the Data Source Different data sources expose data in different ways. Some provide callbacks, others return values through suspend functions, and some already support Flow. The first step is to understand how the underlying API delivers data. Database: Use Flow Directly Room already supports observable queries. @Query("SELECT * FROM items") fun observeItems(): Flow<List<ItemEntity>> We don't need to create another Flow around this query. Room already handles change observation and emits updated results when the underlying data changes. The same principle applies to DataStore: val showAds: Flow<Boolean> = dataStore.data.map { preferences -> preferences[SHOW_ADS] ?: true } The data source already provides a stream of changes. We should use it directly rather than introducing another abstraction. Callback APIs: Use callbackFlow Android APIs often rely on callbacks or listeners to report changes. For example, consider a location API that delivers updates through a listener. fun observeLocation(): Flow<Location> = callbackFlow { val listener = LocationListener { location -> trySend(location) }

## Your Android APK Is Bigger Than It Needs to Be: 22 Smart Ways to Reduce Its Size

DevFeed: [Your Android APK Is Bigger Than It Needs to Be: 22 Smart Ways to Reduce Its Size](<https://devfeed.tech/articles/your-android-apk-is-bigger-than-it-needs-to-be-22-smart-ways-to-reduce-its-size-133647.md>)

Original publisher: [Read original article](<https://proandroiddev.com/your-android-apk-is-bigger-than-it-needs-to-be-22-smart-ways-to-reduce-its-size-d39f678e5b43?source=rss----c72404660798---4>)

Author: Swatiomar

Published: 2026-11-13T16:19:44Z

Content type: tutorial

Language: en

Sources: [ProAndroidDev](<https://devfeed.tech/sources/proandroiddev-medium.md>)

Topics: [APK](<https://devfeed.tech/topics/apk.md>), [Android](<https://devfeed.tech/topics/android.md>), [R8](<https://devfeed.tech/topics/r8.md>), [proguard](<https://devfeed.tech/topics/proguard.md>), [Android Studio](<https://devfeed.tech/topics/android-studio.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [android-apk](<https://devfeed.tech/tags/android-apk.md>), [android-app-development](<https://devfeed.tech/tags/android-app-development.md>), [android-development](<https://devfeed.tech/tags/android-development.md>), [apk](<https://devfeed.tech/tags/apk.md>), [dependencies](<https://devfeed.tech/tags/dependencies.md>), [fonts](<https://devfeed.tech/tags/fonts.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [libraries](<https://devfeed.tech/tags/libraries.md>), [mobile-app-development](<https://devfeed.tech/tags/mobile-app-development.md>), [native](<https://devfeed.tech/tags/native.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [r8](<https://devfeed.tech/tags/r8.md>), [reduce](<https://devfeed.tech/tags/reduce.md>), [resources](<https://devfeed.tech/tags/resources.md>), [size](<https://devfeed.tech/tags/size.md>)

### AI overview

An Android Studio APK Analyzer review found that the app package included libraries the author was not directly using, fonts with unnecessary characters, unsupported language translations, many unneeded dimension resources, and native libraries for multiple CPU architectures. The excerpt frames APK size optimization as examining what goes into the final build and removing unnecessary contents without removing useful features; it does not provide the specific optimization steps.

### Source excerpt

Discover 22 practical Android APK optimization tips, from R8 and unused dependencies to fonts, resources, and native libraries. Continue reading on ProAndroidDev "

## Inside Jetpack Compose's $changed Bit Field: Static Arguments and Fewer Runtime Comparisons

DevFeed: [Inside Jetpack Compose's $changed Bit Field: Static Arguments and Fewer Runtime Comparisons](<https://devfeed.tech/articles/inside-jetpack-compose-s-changed-bit-field-static-arguments-and-fewer-runtime-comparisons-129509.md>)

Original publisher: [Read original article](<https://proandroiddev.com/jetpack-compose-compiler-internals-24370c24a891?source=rss----c72404660798---4>)

Author: Ravi Rawal

Published: 2026-11-11T19:25:42Z

Content type: article

Language: en

Sources: [ProAndroidDev](<https://devfeed.tech/sources/proandroiddev-medium.md>)

Topics: [Compose Compiler](<https://devfeed.tech/topics/compose-compiler.md>), [Jetpack Compose](<https://devfeed.tech/topics/jetpack-compose.md>), [Parameter](<https://devfeed.tech/topics/parameter.md>), [Static code analysis](<https://devfeed.tech/topics/static-code-analysis.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [android-app-development](<https://devfeed.tech/tags/android-app-development.md>), [change-tracking](<https://devfeed.tech/tags/change-tracking.md>), [comparison](<https://devfeed.tech/tags/comparison.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [compose](<https://devfeed.tech/tags/compose.md>), [jetpack-compose](<https://devfeed.tech/tags/jetpack-compose.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [optimizations](<https://devfeed.tech/tags/optimizations.md>), [recomposition](<https://devfeed.tech/tags/recomposition.md>), [runtime](<https://devfeed.tech/tags/runtime.md>), [software-engineering](<https://devfeed.tech/tags/software-engineering.md>), [static](<https://devfeed.tech/tags/static.md>)

### AI overview

Jetpack Compose's compiler uses the synthetic `$changed` bitmask to reduce runtime parameter checks: it marks arguments proven static, such as literals, and propagates known change results from a parent composable to its child. Static arguments need neither a comparison nor a parameter-specific SlotTable entry for change detection; propagated results avoid repeating checks. Arguments whose state is uncertain still require `Composer.changed()` and prior-value bookkeeping. Staticness is distinct from stability and skippability: these optimizations reduce work involved in deciding whether to skip, but do not guarantee skipping or prevent recomposition triggered by state or other invalidations. Compiler metrics and reports can show static and certain arguments, though not every generated bit pattern. The described mask layout and implementation are internal and may vary by release.

### Source excerpt

A closer look at parameter-state encoding, compiler IR analysis, comparison propagation, SlotTable storage, and the optimizations that happen before recomposition decisions reach the runtime. Jetpack Compose doesn't need to compare every argument passed to every composable function. The compiler already knows that some arguments cannot change. Consider a simple composable: @Composable fun ProductCard( title: String, isAvailable: Boolean ) { ProductCardContent( title = title, isAvailable = isAvailable, maxLines = 2, showDivider = false ) } Four arguments are passed to ProductCardContent, but they don't all have the same characteristics. title and isAvailable originate from the parent composable's parameters. Their change status can potentially be inherited from the parent. maxLines and showDivider, on the other hand, are fixed expressions. There is no reason for the child composable to compare 2 against a previously stored 2, or false against a previously stored false. These expressions can be identified at compile-time by the Compose compiler and stored in a synthetic parameter of type integer called $changed. This means that the compiler doesn't just pass argument values. It passes information about those values. Understanding how this works will show us two very similar optimizations. Static argument elimination and comparison propagation. Both of which reduce the number of comparisons performed at runtime and the amount of storage space required in the SlotTable for detecting parameter changes. The implementation details below are based on the AndroidX Compose compiler source. The generated signatures and bit structure are an internal part of the compiler and therefore can vary between releases. 1. Why Compose needs a parameter change-tracking mechanism A composable function is not an ordinary function call from the runtime's perspective. Consider: @Composable fun UserProfile(name: String) { Text(text = name) } The compiler transforms composable functions to comm

## How to get 12 testers for Google Play closed testing (and actually pass)

DevFeed: [How to get 12 testers for Google Play closed testing (and actually pass)](<https://devfeed.tech/articles/how-to-get-12-testers-for-google-play-closed-testing-and-actually-pass-124796.md>)

Original publisher: [Read original article](<https://proandroiddev.com/how-to-get-12-testers-for-google-play-closed-testing-and-actually-pass-6a2ab52a0779?source=rss----c72404660798---4>)

Author: David Kirsch

Published: 2026-11-09T16:15:05Z

Content type: tutorial

Language: en

Sources: [ProAndroidDev](<https://devfeed.tech/sources/proandroiddev-medium.md>)

Topics: [Google Play](<https://devfeed.tech/topics/google-play.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [android-app-development](<https://devfeed.tech/tags/android-app-development.md>), [androiddev](<https://devfeed.tech/tags/androiddev.md>), [google](<https://devfeed.tech/tags/google.md>), [google-play](<https://devfeed.tech/tags/google-play.md>), [google-play-closed-testing](<https://devfeed.tech/tags/google-play-closed-testing.md>), [play](<https://devfeed.tech/tags/play.md>), [testing](<https://devfeed.tech/tags/testing.md>)

### AI overview

For personal Google Play Console accounts created after November 13, 2023, the excerpt says production access requires a closed test with at least 12 testers continuously opted in for 14 consecutive days; early departures or opting out and back in restart a tester's count. Google also asks about tester engagement, feedback, and changes made, so reaching the numeric threshold alone may not suffice. The author recommends recruiting 15-20 from the outset, using a Google Group, enabling availability in all countries, sharing the web opt-in link, and waiting for closed-track review before inviting testers. To support meaningful feedback, assign brief daily tasks, request short notes, ship an update, monitor Play Console's tester count, and record what was tested and changed. The author notes organization accounts are exempt and advises checking Google's current rules. The supplied text is an excerpt.

### Source excerpt

When I finished my app SnapReturn this fall, I hit the same wall a lot of indie Android developers hit: Google wouldn't let me publish to production until I ran a closed test with at least 12 testers for 14 days. I'm an Android developer by day, so I figured this part would be easy. It wasn't. I got one friend and three family members. My Reddit posts got a few replies, and some of those people disappeared after a day or two. What finally got me through was a group of developers testing each other's apps. Here's everything I learned along the way. The rule, in 30 seconds If your personal Play Console account was created after November 13, 2023, you need to run a closed test before you can publish to production. It needs at least 12 testers who stay opted in continuously for at least 14 days. Then you answer a set of questions about your test and wait for Google to review your application. The 14 days must be consecutive, and testers who leave early don't count. A tester who opts out and back in starts their count again. Organization accounts don't have this rule. Google's rules can change, so check Google's help page for the latest. Why "12 opted in" isn't enough The number is the easy part to understand. The part that trips people up is engagement. When you apply for production, Google asks how engaged your testers were, what feedback they gave, and what you changed because of it. Developers regularly report being asked to keep testing even after reaching 12, because their testers barely opened the app. So the real goal isn't 12 names on a list. It's 12+ people who actually use your app, often enough that your answers to Google are true and specific. Where to find testers Recruit 15-20, not 12. Someone always drops out, and a spare tester only helps if they opted in from the start. Set up your test so nobody gets stuck Use a Google Group for testers. Anyone can join it, and you add the group to your closed track once, instead of collecting everyone's email. Make th

## AI Coding for Android: Reflections and Building Self-Verification

DevFeed: [AI Coding for Android: Reflections and Building Self-Verification](<https://devfeed.tech/articles/ai-coding-for-android-reflections-and-building-self-verification-124795.md>)

Original publisher: [Read original article](<https://proandroiddev.com/ai-coding-for-android-reflections-and-building-self-verification-2ca1d2f598a7?source=rss----c72404660798---4>)

Author: rayford

Published: 2026-11-09T14:54:49Z

Content type: article

Language: en

Sources: [ProAndroidDev](<https://devfeed.tech/sources/proandroiddev-medium.md>)

Topics: [agentic-coding](<https://devfeed.tech/topics/agentic-coding.md>), [Android](<https://devfeed.tech/topics/android.md>), [AI-assisted coding](<https://devfeed.tech/topics/ai-assisted-coding.md>), [Test automation](<https://devfeed.tech/topics/test-automation.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [agent-tools](<https://devfeed.tech/tags/agent-tools.md>), [agentic](<https://devfeed.tech/tags/agentic.md>), [agentic-engineering](<https://devfeed.tech/tags/agentic-engineering.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-coding](<https://devfeed.tech/tags/ai-coding.md>), [android](<https://devfeed.tech/tags/android.md>), [android-app-development](<https://devfeed.tech/tags/android-app-development.md>), [android-development](<https://devfeed.tech/tags/android-development.md>), [androiddev](<https://devfeed.tech/tags/androiddev.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [business](<https://devfeed.tech/tags/business.md>), [business-context](<https://devfeed.tech/tags/business-context.md>), [code](<https://devfeed.tech/tags/code.md>), [coding](<https://devfeed.tech/tags/coding.md>), [coding-agent](<https://devfeed.tech/tags/coding-agent.md>), [context](<https://devfeed.tech/tags/context.md>), [context-engineering](<https://devfeed.tech/tags/context-engineering.md>), [development](<https://devfeed.tech/tags/development.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [engineers](<https://devfeed.tech/tags/engineers.md>), [environment](<https://devfeed.tech/tags/environment.md>), [harness-engineering](<https://devfeed.tech/tags/harness-engineering.md>), [verification](<https://devfeed.tech/tags/verification.md>)

### AI overview

Reliable Android AI coding depends on giving agents project-specific context and executable ways to verify their work, with people reviewing requirements, plans, architecture, and final changes. The excerpt recommends layered project guides, iterative research and planning, staged implementation, and checks such as Gradle builds, lint, unit tests, device tests, and integration flows. Dependency injection can make legacy logic easier to test by isolating external services. Device agents can use UI hierarchies and accessibility data, with screenshots and OCR as fallbacks. Automated checks can catch functional failures, but maintainability, subtle visual quality, performance, and other judgment-heavy risks still need human review.

### Source excerpt

AI Coding is rapidly evolving from code completion into an end-to-end development workflow spanning requirements analysis, solution planning, implementation, testing, and bug fixing. For Android development, this is not simply a matter of replacing an IDE autocomplete tool with a Coding Agent. It means redesigning the engineering environment in which an Agent can work reliably: it must understand the business context, respect client architecture boundaries, run builds and tests, and correct itself when something fails. Although AI can do more and more for engineers, it will not replace them. Coding has always been only one part of software development, and engineers are more likely to evolve from people who implement code into people who use AI to build the entire development system. Rather than panic, we can keep learning and evolve alongside AI. What Agentic Engineering Does (Figure from Harness engineering for coding agent users) An AI Coding system usually has three components: a foundation model, a Coding Agent tool, and the context, skills, and verification system supplied by the engineering team. All three affect the quality of the final deliverable. The foundation model sets the upper bound for reasoning, code comprehension, and generation. As models such as Claude, GPT, and Gemini improve, their first-pass success rate on complex tasks generally rises, but so does the cost. In practice, teams trade off cost, response time, and reliability. Even with a top-tier model, complex business requirements, cross-module refactoring, and performance investigations cannot be completed reliably in a single generation pass. This is especially true in Android projects: Gradle builds, build variants, resource and manifest merging, Jetpack component lifecycles, JNI/NDK, R8 obfuscation, app startup paths, and UI rendering all increase the Agent's comprehension burden. Coding Agent tools organize model capabilities into an executable development loop. Tools such as Claude Cod

## Migrating a Real Android App to Kotlin Multiplatform 3/4 -- Sharing the UI without losing safety net

DevFeed: [Migrating a Real Android App to Kotlin Multiplatform 3/4 -- Sharing the UI without losing safety net](<https://devfeed.tech/articles/migrating-a-real-android-app-to-kotlin-multiplatform-3-4-sharing-the-ui-without-losing-safety-net-124797.md>)

Original publisher: [Read original article](<https://proandroiddev.com/migrating-a-real-android-app-to-kotlin-multiplatform-3-4-sharing-the-ui-without-losing-safety-net-f74a6bf408ae?source=rss----c72404660798---4>)

Author: Daniel Voko

Published: 2026-11-09T14:53:26Z

Content type: article

Language: en

Sources: [ProAndroidDev](<https://devfeed.tech/sources/proandroiddev-medium.md>)

Topics: [compose-multiplatform](<https://devfeed.tech/topics/compose-multiplatform.md>), [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [robolectric](<https://devfeed.tech/topics/robolectric.md>), [Android](<https://devfeed.tech/topics/android.md>)

Tags: [2](<https://devfeed.tech/tags/2.md>), [about](<https://devfeed.tech/tags/about.md>), [all](<https://devfeed.tech/tags/all.md>), [android](<https://devfeed.tech/tags/android.md>), [android-app-development](<https://devfeed.tech/tags/android-app-development.md>), [android-library](<https://devfeed.tech/tags/android-library.md>), [androiddev](<https://devfeed.tech/tags/androiddev.md>), [animation](<https://devfeed.tech/tags/animation.md>), [app](<https://devfeed.tech/tags/app.md>), [application](<https://devfeed.tech/tags/application.md>), [article](<https://devfeed.tech/tags/article.md>), [away](<https://devfeed.tech/tags/away.md>), [build](<https://devfeed.tech/tags/build.md>), [classes](<https://devfeed.tech/tags/classes.md>), [code](<https://devfeed.tech/tags/code.md>), [code-smell](<https://devfeed.tech/tags/code-smell.md>), [compose-multiplatform](<https://devfeed.tech/tags/compose-multiplatform.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [kotlin-multiplatform](<https://devfeed.tech/tags/kotlin-multiplatform.md>), [multiplatform](<https://devfeed.tech/tags/multiplatform.md>), [safety](<https://devfeed.tech/tags/safety.md>), [sharing](<https://devfeed.tech/tags/sharing.md>), [ui](<https://devfeed.tech/tags/ui.md>)

### AI overview

Most BikeHub composables moved to Kotlin Multiplatform's commonMain with few code changes; the harder work was adapting Android-centered tooling. The author had first moved UI state and logic into plain Kotlin through Ouroboros-Compose, avoiding Android ViewModel dependencies across 38 feature modules. Android-specific seams were limited and isolated behind expect/actual or an ExternalNavigator interface. Of 13,843 androidMain lines, 9,653 were previews; Compose Preview Screenshot Testing did not work in a KMP module, so the project uses Roborazzi under Robolectric in androidHostTest. A convention plugin enables screenshot tests across 40 modules and copies centralized Compose Multiplatform resources into host-test assets, relying on a reflective workaround to expose their generated location. The setup checks Android rendering only, leaves iOS and web unverified, and stores 55 MB of PNG baselines; half-scale captures limit their size. The account emphasizes auditing previews, resources, plugins and tests before changing module types.

### Source excerpt

Migrating a Real Android App to Kotlin MultiplatformPart 3: Sharing the UI without losing the safety net Part 2 ended on a pattern: the code that moved most easily was the code that knew nothing about Android. By that logic the UI layer should have been the worst part of the migration. It touches the screen, the system bars, the keyboard, the back gesture -- everything that is unmistakably a platform. And, much to my amazement, it wasn't. The composables moved about as easily as the domain models did. What didn't move was everything around them. The resource system, the build plugins, the preview tooling and the screenshot tests were all built on the assumption that a Compose module is an Android library module. Once that stopped being true, the application code was fine and the ecosystem around it wasn't. Sharing application code turned out to be easier than sharing the ecosystem around it. That's the whole article. What moved easily Most composables moved to commonMain unchanged. Layout, state, theming, animation -- Compose Multiplatform covers the surface BikeHub uses, and the diff for a typical screen was mostly imports. Two things made this smoother than it would otherwise have been. The UDF layer went first. Every feature module in BikeHub uses Ouroboros-Compose, a small unidirectional-data-flow library (influenced by Spotify's Mobius, that I used back then, when views and fragments ruled the android UI). It abstracts the ViewModel away and keeps the UI logic in plain, testable classes. I refactored it to KMP as step 0 of the whole migration, before touching a single feature module. That ordering mattered more than it looks. Because the UI logic doesn't sit inside an Android ViewModel, there was no androidx.lifecycle dependency threaded through 38 feature modules waiting to be unpicked. The state holders were already just Kotlin. Android platform code in the UI layer was already a code smell. I'd treated it that way for years, so there wasn't much of it to find.

## AI by lazy: R8 Shrinking and Obfuscation Handled by Your Agent

DevFeed: [AI by lazy: R8 Shrinking and Obfuscation Handled by Your Agent](<https://devfeed.tech/articles/ai-by-lazy-r8-shrinking-and-obfuscation-handled-by-your-agent-124794.md>)

Original publisher: [Read original article](<https://proandroiddev.com/ai-by-lazy-r8-shrinking-and-obfuscation-handled-by-your-agent-e7cb3e124520?source=rss----c72404660798---4>)

Author: Eury Pérez Beltré

Published: 2026-11-09T14:51:30Z

Content type: article

Language: en

Sources: [ProAndroidDev](<https://devfeed.tech/sources/proandroiddev-medium.md>)

Topics: [R8](<https://devfeed.tech/topics/r8.md>), [AI Agent](<https://devfeed.tech/topics/ai-agent.md>), [mobile devops](<https://devfeed.tech/topics/mobile-devops.md>), [To-Do](<https://devfeed.tech/topics/todo.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [ai](<https://devfeed.tech/tags/ai.md>), [android](<https://devfeed.tech/tags/android.md>), [android-app-development](<https://devfeed.tech/tags/android-app-development.md>), [androiddev](<https://devfeed.tech/tags/androiddev.md>), [artificial-intelligence](<https://devfeed.tech/tags/artificial-intelligence.md>), [company](<https://devfeed.tech/tags/company.md>), [confluence](<https://devfeed.tech/tags/confluence.md>), [demo](<https://devfeed.tech/tags/demo.md>), [flag](<https://devfeed.tech/tags/flag.md>), [gradle](<https://devfeed.tech/tags/gradle.md>), [keep](<https://devfeed.tech/tags/keep.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [lazy](<https://devfeed.tech/tags/lazy.md>), [obfuscation](<https://devfeed.tech/tags/obfuscation.md>), [problems](<https://devfeed.tech/tags/problems.md>), [r8](<https://devfeed.tech/tags/r8.md>), [technical-debt](<https://devfeed.tech/tags/technical-debt.md>)

### AI overview

Three agent runs enabled R8 for the Later Android app, found Gson's reflection-related risk, added narrowly scoped fixes, and verified release sync on a Pixel 7. The article's central finding is that plausible fixes and green builds are not proof: none of the agents first reproduced the crash, and follow-up checks exposed unsupported claims and a wrong comment. Its final setup uses AGP's optimization DSL, Gson's `@SerializedName`, and default constructor values so Gson's bundled rules preserve the needed fields and no-args constructor without hand-written keep rules. The author recommends reproducing failures before fixing them, labeling inference separately from verified results, and defining completion by a device-checkable outcome. These results are limited to the demo app; reflection hidden in third-party libraries may require runtime testing to discover. The article also notes code-generating JSON libraries as a longer-term alternative to Gson on Android.

### Source excerpt

I gave R8 to an agent three times. The work was delegable. The evidence wasn't. Hello! 👋 Welcome to the first episode of AI by lazy, a series about the Android chores we keep postponing, handed to an AI agent and then checked by a human who is slightly less lazy than the title suggests. We start with a classic. Open the build.gradle.kts of a mature Android app and there is a decent chance you'll find this in the release block: isMinifyEnabled = false Nobody on the team remembers why. Somebody tried once, something broke, and the flag has been guarding the release build ever since, like a "do not touch" sign that outlived the person who wrote it. Turning R8 on is one line. Making it safe is the chore. So I gave that chore to an agent three times, with different context and different tools, and checked everything it did on a real device. Here is the route: Why R8 stays off, and what that costs R8 in one minute, and why reflection breaks How I delegated it What each run did What I checked, and what I found Which keep rule is right, and why this result doesn't generalize The rule to take away, and the verdict One disclosure before we start. The demo app, Later, was generated with AI for this series, and its technical debt was planted on purpose. Later is a to-do app for procrastinators: every task has a "Later" button that pushes it to tomorrow and increments a counter. Yes, a series about postponed chores runs on an app about postponing. I couldn't resist. 😅 The results below are real and reproducible on that app, but its debt is cleaner than the debt in a product with years of history, and I'll come back to that. Why R8 stays off At a previous job, the team had tried to enable R8, ran into problems, wrote it down in Confluence and moved on. A year later I joined that company, enabled it by hand, with no AI to help, and it went fine. I don't tell that story to look clever. Whatever broke the first time was real at that moment. What interests me is what happened next: a

## Compose Multiplatform: Why You Shouldn't Build Your Whole iOS App in Compose

DevFeed: [Compose Multiplatform: Why You Shouldn't Build Your Whole iOS App in Compose](<https://devfeed.tech/articles/compose-multiplatform-why-you-shouldn-t-build-your-whole-ios-app-in-compose-122709.md>)

Original publisher: [Read original article](<https://proandroiddev.com/compose-multiplatform-why-you-shouldnt-build-your-whole-ios-app-in-compose-9e1e8c978a5b?source=rss----c72404660798---4>)

Author: Anatolii Frolov

Published: 2026-11-09T00:22:32Z

Content type: article

Language: en

Sources: [ProAndroidDev](<https://devfeed.tech/sources/proandroiddev-medium.md>)

Topics: [compose-multiplatform](<https://devfeed.tech/topics/compose-multiplatform.md>), [iOS](<https://devfeed.tech/topics/ios.md>), [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [Swift](<https://devfeed.tech/topics/swift.md>), [liquid glass](<https://devfeed.tech/topics/liquid-glass.md>), [bottom-navigation](<https://devfeed.tech/topics/bottom-navigation.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [android-app-development](<https://devfeed.tech/tags/android-app-development.md>), [androiddev](<https://devfeed.tech/tags/androiddev.md>), [compose](<https://devfeed.tech/tags/compose.md>), [compose-multiplatform](<https://devfeed.tech/tags/compose-multiplatform.md>), [ios](<https://devfeed.tech/tags/ios.md>), [ios-app-development](<https://devfeed.tech/tags/ios-app-development.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [liquid-glass](<https://devfeed.tech/tags/liquid-glass.md>), [navigation](<https://devfeed.tech/tags/navigation.md>), [operating-system](<https://devfeed.tech/tags/operating-system.md>), [reuse](<https://devfeed.tech/tags/reuse.md>), [swiftui](<https://devfeed.tech/tags/swiftui.md>), [uikit](<https://devfeed.tech/tags/uikit.md>)

### AI overview

The article's ClariMeal example keeps product screens and business logic shared in Kotlin and Compose while UIKit owns iOS navigation and system controls. A UIKit tab bar can adopt Apple's appearance changes, including the iOS 26 detached Add control; on iOS 17-25, the app draws the Add circle itself. Compose screens are hosted in native view controllers, and navigation events go to the native stack, avoiding a competing Compose back stack. Android uses Compose for screens, navigation, and its bottom bar. Product-specific cards and charts remain shared, while copied iOS measurements in Compose design tokens still require review as iOS changes. Native integration still involves SDK updates, integration work, and testing; a full SwiftUI rewrite is presented as unnecessary for this app's goals.

### Source excerpt

How to keep your screens shared while letting iOS handle navigation and system controls. Compose Multiplatform lets Android developers reuse Kotlin and Compose screen code on iOS. You keep the language and the UI toolkit you already know, and the same screens run on an iPhone. But a screen that runs on iOS does not automatically follow iOS. You can build the whole app in Compose, including the tab bar and navigation, and Compose Multiplatform supports the back gesture and iOS-style transitions. What it cannot do is redraw your own tab bar when Apple redesigns the system one. A Compose copy of a system control stays the way you drew it. I faced this choice while building ClariMeal, a calorie tracker for iOS and Android. I wanted the product screens shared, and I wanted the navigation and system controls to come from iOS itself. The reason was maintenance. Liquid Glass in iOS 26 is a system material, and Compose cannot draw it. On Android, ClariMeal has its own glass tab bar built in Compose, and it looks good there. On iOS it would still be an imitation: it looks different and does not behave like the system bar. Only the system bar follows iOS when Apple changes it. That did not require a SwiftUI rewrite. Screen content stayed in Compose and the logic stayed in Kotlin, while native iOS components took over navigation and system interactions. This article explains which parts of your iOS app are better left to the system when you want them to follow iOS, where I drew that boundary, and what it still cost. 1. The tab bar belongs to the operating system Start with one comparison: the same tab bar on Android, iOS 18 and iOS 26. On Android, Compose draws the whole bar, including the + button in the middle. On iOS, the tab bar comes from UIKit, and the + button shows where the line between the system and the app runs. The app supports iOS 17 and later. Before iOS 26, the + button is a circle in the middle of the system tab bar, and that circle is my code. On iOS 26, I rep

## Android Dev Summit 2026

DevFeed: [Android Dev Summit 2026](<https://devfeed.tech/articles/android-dev-summit-2026-122708.md>)

Original publisher: [Read original article](<https://proandroiddev.com/android-dev-summit-2026-6b6cdf59cbe0?source=rss----c72404660798---4>)

Author: Jonathon Reid

Published: 2026-11-08T14:47:09Z

Content type: opinion

Language: en

Sources: [ProAndroidDev](<https://devfeed.tech/sources/proandroiddev-medium.md>)

Topics: [agentic-coding](<https://devfeed.tech/topics/agentic-coding.md>), [agentic workflows](<https://devfeed.tech/topics/agentic-workflows.md>), [Android](<https://devfeed.tech/topics/android.md>), [Loop Engineering](<https://devfeed.tech/topics/loop-engineering.md>), [Android Studio](<https://devfeed.tech/topics/android-studio.md>), [User Interfaces](<https://devfeed.tech/topics/user-interfaces.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>), [Developer Events](<https://devfeed.tech/topics/developer-events.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [a2ui](<https://devfeed.tech/tags/a2ui.md>), [agentic](<https://devfeed.tech/tags/agentic.md>), [agentic-ai](<https://devfeed.tech/tags/agentic-ai.md>), [agentic-coding](<https://devfeed.tech/tags/agentic-coding.md>), [agentic-development](<https://devfeed.tech/tags/agentic-development.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [android](<https://devfeed.tech/tags/android.md>), [android-app-development](<https://devfeed.tech/tags/android-app-development.md>), [android-dev-summit](<https://devfeed.tech/tags/android-dev-summit.md>), [android-studio](<https://devfeed.tech/tags/android-studio.md>), [androiddev](<https://devfeed.tech/tags/androiddev.md>), [automation](<https://devfeed.tech/tags/automation.md>), [autonomous](<https://devfeed.tech/tags/autonomous.md>), [autonomous-ai-agents](<https://devfeed.tech/tags/autonomous-ai-agents.md>), [build](<https://devfeed.tech/tags/build.md>), [cli](<https://devfeed.tech/tags/cli.md>), [cloud-next](<https://devfeed.tech/tags/cloud-next.md>), [code](<https://devfeed.tech/tags/code.md>), [coding](<https://devfeed.tech/tags/coding.md>), [dev](<https://devfeed.tech/tags/dev.md>)

### AI overview

The summit's main engineering theme was support for agentic Android development. The Android CLI is presented as a terminal-based way for agents to edit code, build, test, and verify requirements, with lower execution overhead and context use. The author recommends writing repository agents.md guidance by hand, resolving ambiguities up front with a "grill me" prompt, and having agents demonstrate that requirements are met; verification adds runtime but may reduce rework. Google also announced more than 30 Android Skills for newer features, complex implementations, and security or Play Store requirements. An unnamed emulator prototype is described as faster and lighter than traditional emulators, potentially helping automated development and testing loops. XR workshops highlighted glasses paired with an external computing puck for screen mirroring and multi-window productivity, while adoption remains uncertain. The author interprets Android Studio's smaller role at the event as a possible shift in Google's preferred developer experience.

### Source excerpt

Insights on XR, Android CLI, Compose and everything in betweenSource: Photo by Jonathon ReidOverview Attending the Google Android Dev Summit in Mountain View was an exciting experience given it was my first time attending an official event at Google HQ. Compared to massive, spectacle-rich conferences like Google I/O, and Cloud Next, the scale here was noticeably more intimate, allowing direct technical conversations with Google's core platform team and offering unique insight into shifting engineering priorities at Google -- more on that to come. The primary focus centered on enabling agentic coding paradigms, by introducing BYO model capabilities in Android Studio, and expanding command-line tooling via the Android CLI, while also enabling richer and more performant user interfaces with Compose/A2UI improvements. Being there in person was insightful as it provided additional context on upcoming architectural and cultural shifts in the Android ecosystem, revealed by what was said, but more importantly, by what was left unsaid. This was particularly evident with Android Studio: while it received a minor update, it clearly took a back seat to the Android CLI updates and seems to be falling out of favor with Google as the preferred developer experience. Google leaning heavily into adding agentic support. Source: Android Developers YoutubeAndroid CLI & Agentic WorkflowsThe agentic development roundtable to wrap up ADS. Source: Photo by Jonathon Reid The introduction of extended command-line interface (CLI) support for Android represents a major cultural shift towards agentic automation. Built specifically to improve execution performance and minimise context token usage, Android CLI allows autonomous AI agents to execute code development, build tasks, run tests, and confirm they have satisfied the requirements in a verification loop, with the simplicity and performance of the terminal. A key insight emphasised during the sessions was the importance of hand-crafting your

## Clean Up Your Conditional Logic: Exploring Kotlin 2.5.0-Beta2's New Boolean & Nullable Utilities

DevFeed: [Clean Up Your Conditional Logic: Exploring Kotlin 2.5.0-Beta2's New Boolean & Nullable Utilities](<https://devfeed.tech/articles/clean-up-your-conditional-logic-exploring-kotlin-2-5-0-beta2-s-new-boolean-nullable-utilities-122284.md>)

Original publisher: [Read original article](<https://proandroiddev.com/clean-up-your-conditional-logic-exploring-kotlin-2-5-0-beta2s-new-boolean-nullable-utilities-7854207156ea?source=rss----c72404660798---4>)

Author: Nav Singh

Published: 2026-11-07T16:39:54Z

Content type: tutorial

Language: en

Sources: [ProAndroidDev](<https://devfeed.tech/sources/proandroiddev-medium.md>)

Topics: [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [conditionals](<https://devfeed.tech/topics/conditionals.md>), [Boilerplate](<https://devfeed.tech/topics/boilerplate.md>), [if statement](<https://devfeed.tech/topics/if-statement.md>), [Null-Safety](<https://devfeed.tech/topics/null-safety.md>), [Gradle](<https://devfeed.tech/topics/gradle.md>), [scope function](<https://devfeed.tech/topics/scope-function.md>)

Tags: [also](<https://devfeed.tech/tags/also.md>), [android](<https://devfeed.tech/tags/android.md>), [android-app-development](<https://devfeed.tech/tags/android-app-development.md>), [androiddev](<https://devfeed.tech/tags/androiddev.md>), [annotation](<https://devfeed.tech/tags/annotation.md>), [api](<https://devfeed.tech/tags/api.md>), [apis](<https://devfeed.tech/tags/apis.md>), [apply](<https://devfeed.tech/tags/apply.md>), [boilerplate](<https://devfeed.tech/tags/boilerplate.md>), [boolean](<https://devfeed.tech/tags/boolean.md>), [chaining](<https://devfeed.tech/tags/chaining.md>), [clean-code](<https://devfeed.tech/tags/clean-code.md>), [condition](<https://devfeed.tech/tags/condition.md>), [data-class](<https://devfeed.tech/tags/data-class.md>), [experimental](<https://devfeed.tech/tags/experimental.md>), [functions](<https://devfeed.tech/tags/functions.md>), [gradle](<https://devfeed.tech/tags/gradle.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [kotlin-2](<https://devfeed.tech/tags/kotlin-2.md>), [lambda](<https://devfeed.tech/tags/lambda.md>), [let](<https://devfeed.tech/tags/let.md>), [receiver](<https://devfeed.tech/tags/receiver.md>), [scope-functions](<https://devfeed.tech/tags/scope-functions.md>), [standard-library](<https://devfeed.tech/tags/standard-library.md>)

### AI overview

Kotlin 2.5.0-Beta2 introduces experimental standard-library helpers for conditional work: `onTrue` and `onFalse` run a supplied block when a Boolean matches, then return that Boolean unchanged; `ifOrNull` lazily computes and returns a value when its condition is true, or returns null when false. The excerpt shows using the Boolean helpers for authentication side effects and `ifOrNull` to produce a phone number only when contact information is available. Use requires opting in to `ExperimentalStdlibApi`, either at the function or file level or through Gradle language settings. The excerpt does not establish broader API availability or stability.

### Source excerpt

AI generated image Ditch redundant if-else boilerplate and awkward scope chaining with the newly introduced onTrue(), onFalse(), and ifOrNull() functions. Kotlin has always excelled at eliminating boilerplate. From concise data classes and standard scope functions (apply, also, let, takeIf) to smart casting, the language consistently seeks ways to make everyday idioms more expressive. Kotlin 2.5.0-Beta2 adds standard library functions that let us inspect a value before returning it, or return a nullable result based on that value. https://kotlinlang.org/docs/whatsnew-eap.html?utm_campaign=kotlin-releases&utm_content=2-5-0-beta2 Boolean.onTrue(action: () -> Unit): Boolean Boolean.onFalse(action: () -> Unit): Boolean ifOrNull(condition: Boolean, action: () -> T): T? Implementation Because these functions are introduced as experimental APIs in the standard library, we need to opt in to use them. File/Function Annotation OptIn(ExperimentalStdlibApi::class) Module-wide via Gradle config kotlin { sourceSets.all { languageSettings.optIn("kotlin.ExperimentalStdlibApi") } }onTrue() & onFalse() Both functions invoke a supplied block when the receiver matches the condition and return the original boolean unmodified. Example data class User(val id: String, val email: String) class AuthService() { // Before: fun authenticateLegacy(user: User, token: String): Boolean { val isValid = verifyToken(user.email, token) if (isValid) { "Auth.success" } else { "Auth.failure" } return isValid } // Now: @OptIn(ExperimentalStdlibApi::class) fun authenticate(user: User, token: String): Boolean = verifyToken(user.email, token) .onTrue { "Auth.success" } .onFalse { "Auth.failure" } }ifOrNull() When shaping API responses or DTOs, we may return one computed value if a flag is true and another if false. Traditionally, this looks like 👇 val phoneNumber = if (user.hasContactInfo) user.phoneNumber else nullThe New Way: ifOrNull() ifOrNull(condition) { //.. } lazily evaluates the lambda block only if

## How to Connect ESP32 to Wi-Fi on Android (The Right Way) | EasyEsp

DevFeed: [How to Connect ESP32 to Wi-Fi on Android (The Right Way) | EasyEsp](<https://devfeed.tech/articles/how-to-connect-esp32-to-wi-fi-on-android-the-right-way-easyesp-121955.md>)

Original publisher: [Read original article](<https://proandroiddev.com/how-to-connect-esp32-to-wi-fi-on-android-the-right-way-easyesp-b110317a5a41?source=rss----c72404660798---4>)

Author: Arul mani

Published: 2026-11-06T15:14:25Z

Content type: tutorial

Language: en

Sources: [ProAndroidDev](<https://devfeed.tech/sources/proandroiddev-medium.md>)

Topics: [Jetpack Compose](<https://devfeed.tech/topics/jetpack-compose.md>), [smartdevices](<https://devfeed.tech/topics/smartdevices.md>), [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [Library](<https://devfeed.tech/topics/library.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [android-app-development](<https://devfeed.tech/tags/android-app-development.md>), [androiddev](<https://devfeed.tech/tags/androiddev.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [automated](<https://devfeed.tech/tags/automated.md>), [build](<https://devfeed.tech/tags/build.md>), [esp32](<https://devfeed.tech/tags/esp32.md>), [firmware](<https://devfeed.tech/tags/firmware.md>), [flow](<https://devfeed.tech/tags/flow.md>), [hotspot](<https://devfeed.tech/tags/hotspot.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [http](<https://devfeed.tech/tags/http.md>), [iot](<https://devfeed.tech/tags/iot.md>), [jetpack-compose](<https://devfeed.tech/tags/jetpack-compose.md>), [kmm](<https://devfeed.tech/tags/kmm.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [kotlin-multiplatform](<https://devfeed.tech/tags/kotlin-multiplatform.md>), [ktor](<https://devfeed.tech/tags/ktor.md>), [mvi](<https://devfeed.tech/tags/mvi.md>), [network](<https://devfeed.tech/tags/network.md>), [networking](<https://devfeed.tech/tags/networking.md>), [wi-fi](<https://devfeed.tech/tags/wi-fi.md>)

### AI overview

EasyESP Connect is presented as a way to provision an ESP32 from an Android app without sending users through phone Wi-Fi settings. The excerpt says Android 9+ may route requests from an internet-free ESP32 hotspot over cellular; on Android 10+, the library uses WifiNetworkSpecifier and binds the app process to that Wi-Fi network. It can discover setup SSIDs, fall back to guided manual connection if automatic connection is blocked, and pair with ESP32 firmware in WIFI_AP_STA mode. Developers can use a prebuilt Jetpack Compose UI, launch the flow through Activity Result API from XML or Fragment apps, or build a custom UI around its MVI session and state. The Arduino library exposes GET /networks for nearby networks and POST /credentials to receive Wi-Fi details, stop the temporary hotspot, and connect to the home router.

### Source excerpt

Photo by Vishnu Mohanan on Unsplash Stop frustrating your IoT users. Build a seamless ESP32 Wi-Fi provisioning flow using Jetpack Compose, Ktor, and MVI Architecture. The Painless Way to Connect ESP32 Devices to Wi-Fi on Android 📱⚡ How to build seamless IoT provisioning flows using Jetpack Compose, Ktor, and MVI Architecture. If you've ever built an IoT product, you know the biggest hurdle isn't writing the firmware or building the cloud backend -- it's the onboarding process. Getting a screenless microcontroller (like an ESP32) connected to a user's home Wi-Fi network is notoriously frustrating. Users have to leave your app, go to their phone's Wi-Fi settings, connect to a temporary hotspot, ignore the "Internet may not be available" warnings, go back to the app, enter their credentials, and pray it works. As Android developers, we can do better. Today, I am open-sourcing EasyESP Connect -- a battle-tested Kotlin Multiplatform (KMM) Library, Android App, and companion ESP32 firmware that makes provisioning ESP32 devices incredibly simple, resilient, and fully automated. The Android IoT Routing Problem 🚧 Before diving into the solution, let's talk about why Android makes IoT provisioning so hard. When your phone connects to an ESP32's temporary Wi-Fi hotspot, that hotspot doesn't have internet access. Modern Android versions (Android 9+) are smart -- if they detect a Wi-Fi network has no internet, they will silently route all HTTP requests through the user's Cellular Data instead. This means when your app tries to send the Wi-Fi password to http://192.168.4.1, the request goes to the cellular tower, times out, and the setup fails. The Solution: EasyESP Connect ✨ EasyESP Connect solves this (and many other edge cases) by taking full control of the Android Networking stack and providing a beautiful, state-driven Jetpack Compose UI. Key Features: * Automated Device Discovery: Passively scans for local ESP32 devices broadcasting setup SSIDs using Android's WifiManager. * P

## Android 17 on a 4.9 Kernel: LineageOS 24.0 on the Pixel 3a

DevFeed: [Android 17 on a 4.9 Kernel: LineageOS 24.0 on the Pixel 3a](<https://devfeed.tech/articles/android-17-on-a-4-9-kernel-lineageos-24-0-on-the-pixel-3a-121954.md>)

Original publisher: [Read original article](<https://proandroiddev.com/android-17-on-a-4-9-kernel-lineageos-24-0-on-the-pixel-3a-afdbeff25203?source=rss----c72404660798---4>)

Author: xbill

Published: 2026-11-06T15:13:25Z

Content type: tutorial

Language: en

Sources: [ProAndroidDev](<https://devfeed.tech/sources/proandroiddev-medium.md>)

Topics: [LineageOS](<https://devfeed.tech/topics/lineageos.md>), [Android](<https://devfeed.tech/topics/android.md>), [Linux Kernel](<https://devfeed.tech/topics/linux-kernel.md>), [SELinux](<https://devfeed.tech/topics/selinux.md>), [Linux](<https://devfeed.tech/topics/linux.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [android-17](<https://devfeed.tech/tags/android-17.md>), [android-app-development](<https://devfeed.tech/tags/android-app-development.md>), [android-rom](<https://devfeed.tech/tags/android-rom.md>), [androiddev](<https://devfeed.tech/tags/androiddev.md>), [backporting](<https://devfeed.tech/tags/backporting.md>), [bluetooth](<https://devfeed.tech/tags/bluetooth.md>), [boot](<https://devfeed.tech/tags/boot.md>), [build](<https://devfeed.tech/tags/build.md>), [chrome](<https://devfeed.tech/tags/chrome.md>), [connectivity](<https://devfeed.tech/tags/connectivity.md>), [device-tree](<https://devfeed.tech/tags/device-tree.md>), [google-play-services](<https://devfeed.tech/tags/google-play-services.md>), [init](<https://devfeed.tech/tags/init.md>), [ion](<https://devfeed.tech/tags/ion.md>), [kernel](<https://devfeed.tech/tags/kernel.md>), [keys](<https://devfeed.tech/tags/keys.md>), [lineageos](<https://devfeed.tech/tags/lineageos.md>), [linux](<https://devfeed.tech/tags/linux.md>), [linux-kernel](<https://devfeed.tech/tags/linux-kernel.md>), [loader](<https://devfeed.tech/tags/loader.md>), [logger](<https://devfeed.tech/tags/logger.md>), [pixel](<https://devfeed.tech/tags/pixel.md>)

### AI overview

The article reports a working LineageOS 24.0 (Android 17) port for the Pixel 3a on its original Linux 4.9.337 kernel: it boots with SELinux enforcing in 83 seconds, supports Wi-Fi, Bluetooth, sensors and Chrome, and can update without erasing user data. Android 17 expects newer kernel features, so the port combines a cgroup BPF reference-count fix, five platform-code forks for fscrypt, BPF/network handling and the native app zygote, plus device-tree changes. A /init logger that records kernel and system logs helped identify boot failures. Google Play Services required repackaging because its EROFS APEX cannot mount on kernel 4.9. Active Edge remains disabled; calls, SMS, audio, photos, fingerprint enrollment, NFC payments and satellite GPS are untested. Builds use test keys and trigger a recovery signature warning; first installation wipes the phone.

### Source excerpt

This article provides a step by step guide to running LineageOS 24.0, which is Android 17, on a Google Pixel 3a and its original 4.9 Linux kernel. It continues the LineageOS 23.2 port on the same phone. Every patch, script and build is published. https://github.com/xbill9/android_kernel_google_msm-4.9/releases/tag/lineage-24.0-sargo-20261027 The Pixel 3a boots LineageOS 24.0 on kernel 4.9.337 with SELinux enforcing in 83 s, with Wi-Fi, Bluetooth, the sensors, Chrome and Google Play Services working, and updates that keep user data. Android 17 assumes a kernel of at least 5.10 in more places than Android 16 did. The port needed one kernel fix, for a cgroup BPF reference count the 4.9 backport had missed, five forks of platform code (fscrypt keys, the BPF loader, netd and Connectivity, and the native app zygote), and device-tree changes for ueventd, gralloc and the ION memory allocator. The /init logger from the 23.2 port found each one. What is this project trying to Do? The Pixel 3a (codename sargo) has a Snapdragon 670 and a 4.9 kernel. Its last Google build is Android 12. LineageOS carries it officially to 22.2, and the previous article in this series brought it to 23.2, Android 16, by backporting three kernel features. The goal here: keep the phone current and out of a landfill by running the newest LineageOS release, 24.0, on the kernel it already has. The kernel carries a BPF backport that reports itself to Android as 5.4. The NetBpfLoad lines from the first 24.0 boot show the version Android reads, 0x504012e, against the 5.10 it asks for: NetBpfLoad: skipping map sk_storage which requires kernel version 0x504012e >= 0x50a0000 NetBpfLoad: skipping map packet_trace_ringbuf which requires kernel version 0x504012e >= 0x50a0000At This Point You Should Have... A Google Pixel 3a (sargo), bootloader unlocked The LineageOS 24.0 source with the local manifest from the release A build machine with room for the tree; the 24.0 tree here is 266 GB, and the home machine is an

## Why a 1B On-Device LLM Needs a Harness

DevFeed: [Why a 1B On-Device LLM Needs a Harness](<https://devfeed.tech/articles/why-a-1b-on-device-llm-needs-a-harness-116551.md>)

Original publisher: [Read original article](<https://proandroiddev.com/why-a-1b-on-device-llm-needs-a-harness-4068cf22e818?source=rss----c72404660798---4>)

Author: Matias Rodriguez Ovejero

Published: 2026-11-04T14:48:14Z

Content type: article

Language: en

Sources: [ProAndroidDev](<https://devfeed.tech/sources/proandroiddev-medium.md>)

Topics: [Large Language Model](<https://devfeed.tech/topics/llm.md>), [Hallucination detection](<https://devfeed.tech/topics/hallucination-detection.md>), [Android](<https://devfeed.tech/topics/android.md>), [text-generation](<https://devfeed.tech/topics/text-generation.md>), [AI Chat](<https://devfeed.tech/topics/ai-chat.md>), [LLM evaluation / benchmarking](<https://devfeed.tech/topics/llm-evaluation-benchmarking.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [android-app-development](<https://devfeed.tech/tags/android-app-development.md>), [androiddev](<https://devfeed.tech/tags/androiddev.md>), [artificial-intelligence](<https://devfeed.tech/tags/artificial-intelligence.md>), [context](<https://devfeed.tech/tags/context.md>), [coverage](<https://devfeed.tech/tags/coverage.md>), [data](<https://devfeed.tech/tags/data.md>), [feature](<https://devfeed.tech/tags/feature.md>), [gemma](<https://devfeed.tech/tags/gemma.md>), [gemma-3](<https://devfeed.tech/tags/gemma-3.md>), [generation](<https://devfeed.tech/tags/generation.md>), [grounding](<https://devfeed.tech/tags/grounding.md>), [hallucinations](<https://devfeed.tech/tags/hallucinations.md>), [harness](<https://devfeed.tech/tags/harness.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [language-model](<https://devfeed.tech/tags/language-model.md>), [limits](<https://devfeed.tech/tags/limits.md>), [llm](<https://devfeed.tech/tags/llm.md>), [mobile](<https://devfeed.tech/tags/mobile.md>), [model](<https://devfeed.tech/tags/model.md>), [natural-language](<https://devfeed.tech/tags/natural-language.md>), [on-device](<https://devfeed.tech/tags/on-device.md>), [phone](<https://devfeed.tech/tags/phone.md>), [running](<https://devfeed.tech/tags/running.md>)

### AI overview

A 1B on-device model can generate fluent text, but the application must verify its claims and manage the runtime. The article proposes a harness that routes questions, prepares selected typed facts with scope and coverage, bounds the model's writing task, validates its output, preserves verified facts for fallback, and controls initialization, timeouts, and overlapping native calls. In the WalletMind example, Kotlin prepares Room data for Gemma 3 1B INT4 through LiteRT-LM; deterministic checks cover numbers, categories, and some trend or causal claims, with no second LLM judge. Rejected text falls back to verified data. These rules cannot catch every misleading phrasing, and tests make known failures reproducible without proving future outputs correct.

### Source excerpt

A small model makes text generation possible on a phone. A harness turns that capability into a feature that can work with real data, time limits, and checkable answers.Cover image generated by the author using AI Running a language model on Android is no longer just a technical demo. Models such as Gemma 3 1B Instruction Tuned, quantized for mobile devices, make it possible to build chats that generate text on the phone. The harder question begins after the first response arrives: how much of what the model wrote may the application treat as true? A 1B model can produce a convincing explanation from a short context. It can also miss an important condition, connect unrelated facts, or fill a gap with an assumption. These failures are not exclusive to small models. But when we choose a model to fit a phone's constraints, we have less room to ask it to select data, calculate, interpret exceptions, and write correctly in one operation. The official Gemma 3 model card reports differences between its instruction-tuned 1B and larger variants on grounding evaluations. Those benchmarks do not predict the results of any particular app. They reinforce an important distinction: the ability to produce natural language is not the ability to verify it. That is where a harness becomes useful. Three problems a prompt cannot solve on its own1. Hallucinations can use correct data An invented amount is relatively easy to catch. A sentence using two real amounts to assert a false trend is harder. A model can assign a value to the wrong period, compare records with different coverage, or infer a cause absent from the source data. A validator that checks only for unknown numbers will miss these relational errors. A prompt can ask the model to be careful. It cannot independently verify each claim against the original source. That responsibility belongs to the application. 2. More context is not necessarily better context A tempting solution is to send every available record. On a phone, t

## Migrating a Real Android App to Kotlin Multiplatform 2/4 -- What Moved for Free, and What Hurt

DevFeed: [Migrating a Real Android App to Kotlin Multiplatform 2/4 -- What Moved for Free, and What Hurt](<https://devfeed.tech/articles/migrating-a-real-android-app-to-kotlin-multiplatform-2-4-what-moved-for-free-and-what-hurt-113141.md>)

Original publisher: [Read original article](<https://proandroiddev.com/migrating-a-real-android-app-to-kotlin-multiplatform-2-4-what-moved-for-free-and-what-hurt-7ec973002f01?source=rss----c72404660798---4>)

Author: Daniel Voko

Published: 2026-11-02T14:51:13Z

Content type: article

Language: en

Sources: [ProAndroidDev](<https://devfeed.tech/sources/proandroiddev-medium.md>)

Topics: [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [koin](<https://devfeed.tech/topics/koin.md>), [Ktor](<https://devfeed.tech/topics/ktor.md>), [sqldelight](<https://devfeed.tech/topics/sqldelight.md>), [Android](<https://devfeed.tech/topics/android.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [android-app-development](<https://devfeed.tech/tags/android-app-development.md>), [androiddev](<https://devfeed.tech/tags/androiddev.md>), [apis](<https://devfeed.tech/tags/apis.md>), [app](<https://devfeed.tech/tags/app.md>), [code](<https://devfeed.tech/tags/code.md>), [compose-multiplatform](<https://devfeed.tech/tags/compose-multiplatform.md>), [constructor](<https://devfeed.tech/tags/constructor.md>), [context](<https://devfeed.tech/tags/context.md>), [coupling](<https://devfeed.tech/tags/coupling.md>), [dependencies](<https://devfeed.tech/tags/dependencies.md>), [dependency](<https://devfeed.tech/tags/dependency.md>), [dependency-injection](<https://devfeed.tech/tags/dependency-injection.md>), [di](<https://devfeed.tech/tags/di.md>), [files](<https://devfeed.tech/tags/files.md>), [implementation](<https://devfeed.tech/tags/implementation.md>), [init](<https://devfeed.tech/tags/init.md>), [interface](<https://devfeed.tech/tags/interface.md>), [kmp](<https://devfeed.tech/tags/kmp.md>), [koin](<https://devfeed.tech/tags/koin.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [kotlin-multiplatform](<https://devfeed.tech/tags/kotlin-multiplatform.md>), [multiplatform](<https://devfeed.tech/tags/multiplatform.md>)

### AI overview

The author reports that roughly 84% of the app's Kotlin code moved to commonMain, but migration effort depended more on the app's platform coupling than on library support. Ktor's client configuration and request logic moved unchanged; SQLDelight's schema and queries were already platform agnostic, though its web WebWorkerDriver stores data only in memory. Koin modules bind platform implementations to shared interfaces when construction needs platform dependencies; this avoids some expect/actual constraints but makes missing bindings runtime failures. The excerpt recommends building a second target in CI early because Android builds can miss Android-only dependencies leaking into shared code. Replacing pervasive java.time usage was the hardest work: kotlinx-datetime helped, while locale-aware date formatting needed custom implementations using java.time on Android, Intl.DateTimeFormat on wasm, and NSDate on iOS. File uploads use a lazy, repeatable byte-source boundary; Android and iOS can stream, while the web implementation buffers chunks because browser reads are asynchronous and kotlinx-io's RawSource is synchronous. Multiplatform Settings with kotlinx.serialization handles key-

### Source excerpt

Migrating a Real Android App to Kotlin Multiplatform 2/4 -- What Moved for Free, and What HurtPart 2: What Moved for Free, and What Hurt In Part 1 I described the foundations: a modular Android codebase with Ktor, Koin and SQLDelight already in place, and a rule that the Android app must stay shippable after every step. The result is that around 84% of the Kotlin code now lives in commonMain. What that number hides is how unevenly the work was distributed. Some layers moved almost mechanically, in an afternoon, with a plugin swap and a few imports. Others took weeks and touched code I hadn't looked at in years. The pattern turned out to be simple, and in hindsight obvious: multiplatform support in your libraries matters far less than how tightly your own code is coupled to platform APIs. A library either supports KMP or it doesn't, and you find out in minutes. Your own platform coupling is spread across hundreds of files and you find out gradually, for weeks. What moved for freeKoin Dependency injection is the piece I'd underrate if I were writing this list from memory, and it deserves more credit than that. Koin ended up being the mechanism that keeps platform code out of shared code. Instead of reaching for expect / actual every time a component needs a platform implementation, the shared code depends on an interface, and each platform contributes a module that binds it: https://medium.com/media/a9ac7c95779230353cc1e3f0943e48b7/href expect/actual works well for small, self-contained things: a platform name, a formatter, a UUID generator. It gets awkward as soon as a platform implementation needs its own dependencies. The declaration in commonMain fixes the constructor signature for every target, so an Android implementation that needs a Context has to get it some other way, usually through an init step the platform has to remember to call. With a DI module, shared code depends on an interface and nothing else. Each platform binds its own implementation, with whatev

## Inside Android Layoutlib: How View and Compose Previews Reach the Canvas

DevFeed: [Inside Android Layoutlib: How View and Compose Previews Reach the Canvas](<https://devfeed.tech/articles/inside-android-layoutlib-how-view-and-compose-previews-reach-the-canvas-113140.md>)

Original publisher: [Read original article](<https://proandroiddev.com/inside-android-layoutlib-view-compose-rendering-pipeline-dc5d7f8ac21c?source=rss----c72404660798---4>)

Author: Ravi Rawal

Published: 2026-11-02T14:47:44Z

Content type: article

Language: en

Sources: [ProAndroidDev](<https://devfeed.tech/sources/proandroiddev-medium.md>)

Topics: [Jetpack Compose](<https://devfeed.tech/topics/jetpack-compose.md>), [Android](<https://devfeed.tech/topics/android.md>), [aosp](<https://devfeed.tech/topics/aosp.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [android-app-development](<https://devfeed.tech/tags/android-app-development.md>), [android-framework](<https://devfeed.tech/tags/android-framework.md>), [android-open-source-project](<https://devfeed.tech/tags/android-open-source-project.md>), [android-studio](<https://devfeed.tech/tags/android-studio.md>), [androiddev](<https://devfeed.tech/tags/androiddev.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [bridge](<https://devfeed.tech/tags/bridge.md>), [canvas](<https://devfeed.tech/tags/canvas.md>), [compose](<https://devfeed.tech/tags/compose.md>), [device](<https://devfeed.tech/tags/device.md>), [drawing](<https://devfeed.tech/tags/drawing.md>), [emulator](<https://devfeed.tech/tags/emulator.md>), [framework](<https://devfeed.tech/tags/framework.md>), [image](<https://devfeed.tech/tags/image.md>), [implementation](<https://devfeed.tech/tags/implementation.md>), [inflation](<https://devfeed.tech/tags/inflation.md>), [jetpack](<https://devfeed.tech/tags/jetpack.md>), [jetpack-compose](<https://devfeed.tech/tags/jetpack-compose.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [layout](<https://devfeed.tech/tags/layout.md>), [layouts](<https://devfeed.tech/tags/layouts.md>), [view](<https://devfeed.tech/tags/view.md>)

### AI overview

Android Studio previews share Layoutlib's host rendering session, but Views and Compose keep different UI representations. For XML, Layoutlib inflates framework Views, resolves resources, then measures, lays out, and draws the hierarchy. For Compose, tooling invokes compiled composable code through a Compose host: a ComposeView sits in the View hierarchy, while Compose owns its internal layout tree. Layoutlib adapts selected framework behavior for desktop rendering; it does not boot Android or guarantee device behavior. A successful preview validates drawing under a selected configuration, not production data loading, lifecycle, window insets, platform services, or every device. The text recommends passing explicit UI state to presentation composables for representative previews, diagnosing failures at the construction, composition, or layout boundary, and using an emulator or device for OS-specific behavior.

### Source excerpt

Trace the rendering pipeline from XML inflation and compiled composables to measurement, drawing, and the final preview image and understand where Layoutlib's responsibilities end. Android Studio can render an XML layout or a Jetpack Compose screen without launching an emulator. The two types are rendered within the same preview window but are rendered differently, i.e. the rendering pipeline in the same way. When you have a view based layout, Android Studio will inflate your Android Viewshierarchy. When using compose, the compose tools will invokes the compiled composable code using the compose host. The Compose runtime will then build its own compose tree. Layoutlib connects these different UI models to a host-side rendering environment. It will not convert compose to views or emulate an entire Android device. That distinction explains the architecture behind Android previews, the role of classes such as Bridge and RenderSessionImpl . It also means that just because you successfully render your preview, it doesn't mean it will behave the same on a real device. The implementation can be found in the Layoutlib repo inside the Android Open Source Project's Layoutlib repository. You can look at the rendering bridge and compose tools source code to see how it all fits together. 1. What Layoutlib actually is Layoutlib is a part of the Android framework that has been adapted and ported to work outside of Android devices. It is used by Android Studio to render layouts. However, it is not a screenshot tool that parses XML and tries to mimic how Android widgets would look. It can instantiate Android framework views, resolve resources, perform layout measurement, and execute drawing operations through the adapted framework. This is important because a lot of how a layout looks is down to how the framework behavior. Text measurement, drawable rendering, padding, resource resolution, and parent-child layout rules all influence the resulting pixels. A renderer that merely appro

## Android Developer Roadmap 2027: What to Learn, What Interviews Ask, and Where AI Fits

DevFeed: [Android Developer Roadmap 2027: What to Learn, What Interviews Ask, and Where AI Fits](<https://devfeed.tech/articles/android-developer-roadmap-2027-what-to-learn-what-interviews-ask-and-where-ai-fits-109956.md>)

Original publisher: [Read original article](<https://proandroiddev.com/android-developer-roadmap-2027-what-to-learn-what-interviews-ask-and-where-ai-fits-240ba695584a?source=rss----c72404660798---4>)

Author: Mayank Kumar

Published: 2026-10-31T14:36:42Z

Content type: article

Language: en

Sources: [ProAndroidDev](<https://devfeed.tech/sources/proandroiddev-medium.md>)

Topics: [Android](<https://devfeed.tech/topics/android.md>), [Learning](<https://devfeed.tech/topics/learning.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>), [AI Chat](<https://devfeed.tech/topics/ai-chat.md>), [MSP MCP](<https://devfeed.tech/topics/msp-mcp.md>), [Google Play](<https://devfeed.tech/topics/google-play.md>), [Gradle](<https://devfeed.tech/topics/gradle.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [android](<https://devfeed.tech/tags/android.md>), [android-16](<https://devfeed.tech/tags/android-16.md>), [android-app-development](<https://devfeed.tech/tags/android-app-development.md>), [android-apps](<https://devfeed.tech/tags/android-apps.md>), [androiddev](<https://devfeed.tech/tags/androiddev.md>), [api](<https://devfeed.tech/tags/api.md>), [app](<https://devfeed.tech/tags/app.md>), [app-updates](<https://devfeed.tech/tags/app-updates.md>), [apps](<https://devfeed.tech/tags/apps.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [artificial-intelligence](<https://devfeed.tech/tags/artificial-intelligence.md>), [bug](<https://devfeed.tech/tags/bug.md>), [bug-fixes](<https://devfeed.tech/tags/bug-fixes.md>), [build](<https://devfeed.tech/tags/build.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [developer](<https://devfeed.tech/tags/developer.md>), [interviews](<https://devfeed.tech/tags/interviews.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [learn](<https://devfeed.tech/tags/learn.md>), [roadmap](<https://devfeed.tech/tags/roadmap.md>)

### AI overview

The roadmap recommends learning Kotlin and Android fundamentals first, followed by coroutines and Flow, Compose, architecture, data and offline behavior, testing, production engineering, and system design. It ties each stage to practical skills, interview topics, and project exercises, and advises using one app to build and demonstrate those skills. AI is presented as a tool to use throughout the process, with code checked through tests, documentation, or profiling; the article highlights that swallowing coroutine cancellation can make otherwise plausible code wrong. For app AI features, it distinguishes on-device options (privacy, offline use, no per-request cost, but limited device support and short-text focus), cloud options (larger models and richer inputs, with network, latency, cost, and data-sharing concerns), and hybrid implementations (fallback flexibility at the cost of two paths to build and test). Interview preparation also includes DSA, Android deep dives, machine coding, design, and, where offered, AI-assisted code review. The source frames this as the author's roadmap, based on documentation, public interview accounts, and work experience.

### Source excerpt

Image by the author If you are an Android developer right now, you are probably asking three questions: What should I learn next? Does any of it still matter, now that AI writes code? What will interviews actually ask me? The last year did not make this easier. In May 2026, Google said Android UI is now Compose-first and moved the View components that Compose replaces into maintenance mode: critical bug fixes only, no new features, but no plan to remove them. The same day, Android CLI 1.0 went stable so AI agents can build and run Android apps. And Google was reported to be piloting coding interviews where candidates use Gemini. This post answers all three questions. It is a complete roadmap for 2027: what to learn, in what order, how deep to go, what interviewers ask at each stage, and where AI fits. Short answer: Learn Kotlin and the Android platform first, then coroutines, Compose and architecture, then data, testing, production and system design. Use AI at every stage, but only as fast as you can check what it gives you. Interviews test the same things, plus coding problems and design. I built this from the official Android Developers and Kotlin documentation, recent interview write-ups that developers posted publicly, and what I have seen in production Android work. It is my own roadmap, not one published by Google or JetBrains. What changed for Android developers going into 2027? A roadmap is only useful if it matches the platform you will ship on. These changes from the last year affect what you should learn, newest first. Feb 1, 2027: Play blocks app updates that don't support 16 KB memory pages (apps targeting Android 15+). For your learning: Know how native libraries and your build affect this, even if you never write C++. 2027: Developer verification expands to all apps on certified Android devices. For your learning: Even apps shipped outside Play will need a verified developer. Aug 31, 2026: New apps and updates must target Android 16 (API 36). For your

## AI Can Write My Kotlin. Who's Going to Debug It at 2 AM?

DevFeed: [AI Can Write My Kotlin. Who's Going to Debug It at 2 AM?](<https://devfeed.tech/articles/ai-can-write-my-kotlin-who-s-going-to-debug-it-at-2-am-108418.md>)

Original publisher: [Read original article](<https://proandroiddev.com/ai-can-write-my-kotlin-whos-going-to-debug-it-at-2-am-a329bd3d7978?source=rss----c72404660798---4>)

Author: Mayank Kumar

Published: 2026-10-30T13:51:50Z

Content type: article

Language: en

Sources: [ProAndroidDev](<https://devfeed.tech/sources/proandroiddev-medium.md>)

Topics: [AI tools for developers](<https://devfeed.tech/topics/ai-tools-for-developers.md>), [human review](<https://devfeed.tech/topics/human-review.md>), [Code review](<https://devfeed.tech/topics/code-review.md>), [ai slop pull requests](<https://devfeed.tech/topics/ai-slop-pull-requests.md>), [Multi-step AI processes](<https://devfeed.tech/topics/multi-step-ai-processes.md>), [adb](<https://devfeed.tech/topics/adb.md>), [Crashlytics](<https://devfeed.tech/topics/crashlytics.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-tools](<https://devfeed.tech/tags/ai-tools.md>), [android](<https://devfeed.tech/tags/android.md>), [android-app-development](<https://devfeed.tech/tags/android-app-development.md>), [android-bench](<https://devfeed.tech/tags/android-bench.md>), [android-studio](<https://devfeed.tech/tags/android-studio.md>), [androiddev](<https://devfeed.tech/tags/androiddev.md>), [app-quality](<https://devfeed.tech/tags/app-quality.md>), [artificial-intelligence](<https://devfeed.tech/tags/artificial-intelligence.md>), [code](<https://devfeed.tech/tags/code.md>), [crashlytics](<https://devfeed.tech/tags/crashlytics.md>), [death](<https://devfeed.tech/tags/death.md>), [delivery](<https://devfeed.tech/tags/delivery.md>), [dora](<https://devfeed.tech/tags/dora.md>), [emulator](<https://devfeed.tech/tags/emulator.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [main-thread](<https://devfeed.tech/tags/main-thread.md>), [models](<https://devfeed.tech/tags/models.md>), [oem](<https://devfeed.tech/tags/oem.md>), [process](<https://devfeed.tech/tags/process.md>), [r8](<https://devfeed.tech/tags/r8.md>), [recomposition](<https://devfeed.tech/tags/recomposition.md>), [release](<https://devfeed.tech/tags/release.md>)

### AI overview

AI tools can write and debug Android code, but passing repository tests does not establish that a change works on a device. Android failures can depend on process death, OEM battery management, release-build R8, recomposition, or low-memory performance; benchmarks and tests cover only what they check. The article recommends making verification routine: test process death by killing and reopening the app, smoke-test critical flows on a minified release build, use a Macrobenchmark for startup or scrolling, keep agent changes small and inspect edited tests, and read Perfetto traces or heap dumps to check causes. Agents can speed up diagnosis, but developers remain responsible for validating fixes and owning releases. It also notes that Android 16's experimental AppFunctions lets apps expose agent-callable functions, whose KDoc descriptions and inputs require careful treatment.

### Source excerpt

Image by the author It's 2:07 AM, and Crashlytics has opinions. The crash is in a ViewModel that git blame says you wrote. You didn't. An agent did, and its pull request said "all tests pass." They do. The agent updated the expected values to match its new behaviour. That's a composite, not a confession. But it points at a real shift in Android work. This post covers what AI tools can do on Android today, why "the tests pass" is not the same as "it works" on a phone, and what to get better at. Short answer: AI can now write and fix Android code, but proving it works on a real device is still your job. What can AI tools do on Android today? Quite a lot. Android Studio's May 2026 release includes an agent that plans multi-step work and fixes its own build errors, "Fix with AI" for crashes in App Quality Insights, and an option to hand LeakCanary traces to an agent. Google also runs Android Bench, which gives models real issues from public Android repos and checks each fix with tests. At its March 2026 launch, models solved between 16% and 72% of tasks. So writing Android code is no longer the slow part. Checking it is. Why is "almost right" the expensive part? Because it compiles, looks fine in review, and fails later. In Stack Overflow's 2025 survey, 66% of developers named "AI solutions that are almost right, but not quite" as their top frustration. Google's DORA 2025 report found that AI adoption goes with higher delivery throughput, but it's still linked to less stable delivery. When changes get cheap to produce, teams produce more of them. The limit becomes how much change you can verify. Why is this harder on Android? Because an agent works on the repository, but Android correctness depends on the device at runtime. Image by the author Process death, OEM battery managers, R8 in release builds, unexpected recomposition, and main-thread work on low-memory devices rarely show up in a diff. Most don't show up on a flagship emulator either. Here's what "almost right"

## Beyond Default Claude: Running DeepSeek, MiniMax and GLM in Claude Code and Android Studio

DevFeed: [Beyond Default Claude: Running DeepSeek, MiniMax and GLM in Claude Code and Android Studio](<https://devfeed.tech/articles/beyond-default-claude-running-deepseek-minimax-and-glm-in-claude-code-and-android-studio-108419.md>)

Original publisher: [Read original article](<https://proandroiddev.com/beyond-default-claude-running-deepseek-minimax-and-glm-in-claude-code-and-android-studio-02a4f8117790?source=rss----c72404660798---4>)

Author: Subhankar Bag

Published: 2026-10-30T13:50:26Z

Content type: tutorial

Language: en

Sources: [ProAndroidDev](<https://devfeed.tech/sources/proandroiddev-medium.md>)

Topics: [Claude Code](<https://devfeed.tech/topics/claude-code.md>), [Android Studio](<https://devfeed.tech/topics/android-studio.md>)

Tags: [acp](<https://devfeed.tech/tags/acp.md>), [android](<https://devfeed.tech/tags/android.md>), [android-app-development](<https://devfeed.tech/tags/android-app-development.md>), [android-studio](<https://devfeed.tech/tags/android-studio.md>), [androiddev](<https://devfeed.tech/tags/androiddev.md>), [anthropic](<https://devfeed.tech/tags/anthropic.md>), [api-keys](<https://devfeed.tech/tags/api-keys.md>), [cc](<https://devfeed.tech/tags/cc.md>), [claude](<https://devfeed.tech/tags/claude.md>), [claude-code](<https://devfeed.tech/tags/claude-code.md>), [deepseek](<https://devfeed.tech/tags/deepseek.md>), [glm](<https://devfeed.tech/tags/glm.md>), [gradle](<https://devfeed.tech/tags/gradle.md>), [ide](<https://devfeed.tech/tags/ide.md>), [json](<https://devfeed.tech/tags/json.md>), [llm](<https://devfeed.tech/tags/llm.md>), [minimax](<https://devfeed.tech/tags/minimax.md>), [room](<https://devfeed.tech/tags/room.md>), [shell](<https://devfeed.tech/tags/shell.md>)

### AI overview

The article's central fix for provider settings leaking across Claude Code sessions is to give each provider its own `CLAUDE_CONFIG_DIR` profile and keep named API keys in a permission-restricted `credentials.env`, injected at launch. A shared `cc` launcher selects provider endpoints, models and keys for both terminal sessions and Android Studio's ACP agent. The ACP command requires an explicit provider, sends logs to stderr to protect its JSON-RPC stream, and checks that `npx` is available; Android Studio may need a full `npx` path and sign-out from Anthropic Console authentication. Separate profiles isolate configuration and history but still share project files and provider quotas, and start without the existing profile's history, plugins or `/config` choices. The author says model IDs and context limits change, and notes that some adapter versions may require `ANTHROPIC_API_KEY` instead of `ANTHROPIC_AUTH_TOKEN`. The setup was tested on Ubuntu.

### Source excerpt

One launcher, isolated profiles, named API keys, and a working ACP bridge for Android Studio. Tested on Ubuntu. I had a MiniMax session forty minutes into a Room migration refactor. In a second terminal I ran my little provider-switcher script to ask DeepSeek a quick question about a Gradle error. The switcher did what it always did: it copied settings.deepseek.json over ~/.claude/settings.json. The MiniMax session kept running, so I thought nothing of it. Then I restarted it the next morning with claude --resume, and it came back up talking to DeepSeek, with a model name DeepSeek had never heard of. The session was fine. My setup was the bug. This article is the fix: a single cc launcher that gives every provider its own Claude Code profile, keeps API keys out of every settings file, and plugs the same providers into Android Studio's ACP agent panel. TL;DR Problem Root cause Fix Providers overwrite each other Every launch shares ~/.claude/settings.json One CLAUDE_CONFIG_DIR profile per provider API keys scattered across JSON files Settings files were used as the key store Keys live only in credentials.env, injected as env vars at launch Switching keys means editing files No concept of a named key cc key use minimax backup Android Studio agent ignores your setup The IDE spawns the agent with its own environment, not your shell's cc acp <provider> as the agent command Two scripts drift apart The terminal launcher and IDE bridge each resolved keys their own way One script, two entry points Part 1: The TerminalRoot cause: one config directory, many providers Claude Code reads its settings, history, sessions and auth state from one directory, ~/.claude by default. Point it at an Anthropic-compatible provider and that choice lives in the same place as everything else. The common first attempt copies a provider file into place: Before # Every terminal shares ~/.claude. The last copy wins. case "$1" in minimax) cp settings.minimax.json ~/.claude/settings.json ;; glm) cp se

## Under the Hood: How Room 3.0 and SQLDelight 2.x Detect Database Changes

DevFeed: [Under the Hood: How Room 3.0 and SQLDelight 2.x Detect Database Changes](<https://devfeed.tech/articles/under-the-hood-how-room-3-0-and-sqldelight-2-x-detect-database-changes-107102.md>)

Original publisher: [Read original article](<https://proandroiddev.com/under-the-hood-how-room-3-0-and-sqldelight-2-x-detect-database-changes-51e7a9b716dc?source=rss----c72404660798---4>)

Author: chanzmao

Published: 2026-10-29T17:35:32Z

Content type: comparison

Language: en

Sources: [ProAndroidDev](<https://devfeed.tech/sources/proandroiddev-medium.md>)

Topics: [sqldelight](<https://devfeed.tech/topics/sqldelight.md>), [Query (disambiguation)](<https://devfeed.tech/topics/query.md>)

Tags: [android-app-development](<https://devfeed.tech/tags/android-app-development.md>), [android-development](<https://devfeed.tech/tags/android-development.md>), [changes](<https://devfeed.tech/tags/changes.md>), [database](<https://devfeed.tech/tags/database.md>), [flow](<https://devfeed.tech/tags/flow.md>), [kotlin-coroutines](<https://devfeed.tech/tags/kotlin-coroutines.md>), [mobile-app-development](<https://devfeed.tech/tags/mobile-app-development.md>), [notifications](<https://devfeed.tech/tags/notifications.md>), [query](<https://devfeed.tech/tags/query.md>), [room](<https://devfeed.tech/tags/room.md>), [software-architecture](<https://devfeed.tech/tags/software-architecture.md>), [sqldelight](<https://devfeed.tech/tags/sqldelight.md>), [tables](<https://devfeed.tech/tags/tables.md>)

### AI overview

Room 3.0 observes table invalidations: its Flow runs the query when collection starts, then reruns it after a relevant table change. This can rerun a query even when its result is unchanged; cancellation stops the observation. SQLDelight 2.x attaches a listener to a Query. `Query.asFlow()` emits the query as a notification, while downstream operators such as `mapToList()` execute SQL and fetch rows; listener cleanup occurs when collection closes or is cancelled. Neither mechanism avoids reading from the database after a relevant notification. The text cautions that SQLDelight's query-level listener does not guarantee fewer executions or prove that only affected queries are notified; behavior depends on notification and driver implementation details.

### Source excerpt

Room and SQLDelight both let us observe database queries as Kotlin Flows. When the underlying data changes, the Flow emits an update, allowing the UI to react without manually refreshing the data. Image created by AI The result looks similar from the outside, but the two libraries handle change notifications differently. Room relies on InvalidationTracker to monitor database tables. SQLDelight uses listeners attached to individual Query objects. Let's look at how these mechanisms work internally and what the differences mean in practice. How Room 3.0 Monitors Database Changes Room uses InvalidationTracker to keep track of changes to database tables. When a DAO query returns a Flow, Room uses this mechanism to determine when the query should run again. The important detail is that Room tracks which tables a query depends on, rather than tracking changes to the query result itself. What happens behind the scenes? The following example illustrates the basic idea. It is simplified pseudocode, not Room's actual implementation. fun <T> createRoomQueryFlow( tracker: InvalidationTracker, tables: Array<String>, queryBlock: suspend () -> T ): Flow<T> = flow { emit(queryBlock()) tracker.createFlow(*tables).collect { emit(queryBlock()) } } There are two things worth noting here. The query runs before change monitoring begins. When collection starts, queryBlock() fetches the current data and emits the result. The Flow then observes invalidation events from InvalidationTracker. A table change can trigger another query execution. Suppose a query reads from the users table. When Room detects a relevant change to that table, the Flow can emit another result by executing the query again. Room does not need to compare the old and new query results. It uses table invalidation as a signal that the result may have changed. This approach keeps the mechanism straightforward, but it has a trade-off: a change to a table can trigger re-execution even when the actual result of a particular que

## Migrating a Real Android App to Kotlin Multiplatform 1/4 -- Before the Migration

DevFeed: [Migrating a Real Android App to Kotlin Multiplatform 1/4 -- Before the Migration](<https://devfeed.tech/articles/migrating-a-real-android-app-to-kotlin-multiplatform-1-4-before-the-migration-107101.md>)

Original publisher: [Read original article](<https://proandroiddev.com/migrating-a-real-android-app-to-kotlin-multiplatform-1-4-before-the-migration-8b1d16f68747?source=rss----c72404660798---4>)

Author: Daniel Voko

Published: 2026-10-29T17:33:38Z

Content type: article

Language: en

Sources: [ProAndroidDev](<https://devfeed.tech/sources/proandroiddev-medium.md>)

Topics: [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [Android](<https://devfeed.tech/topics/android.md>), [Jetpack Compose](<https://devfeed.tech/topics/jetpack-compose.md>), [compose-multiplatform](<https://devfeed.tech/topics/compose-multiplatform.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [android-app-development](<https://devfeed.tech/tags/android-app-development.md>), [androiddev](<https://devfeed.tech/tags/androiddev.md>), [app](<https://devfeed.tech/tags/app.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [best-practices](<https://devfeed.tech/tags/best-practices.md>), [bike](<https://devfeed.tech/tags/bike.md>), [browser](<https://devfeed.tech/tags/browser.md>), [case-study](<https://devfeed.tech/tags/case-study.md>), [code](<https://devfeed.tech/tags/code.md>), [compose](<https://devfeed.tech/tags/compose.md>), [compose-multiplatform](<https://devfeed.tech/tags/compose-multiplatform.md>), [core](<https://devfeed.tech/tags/core.md>), [dagger](<https://devfeed.tech/tags/dagger.md>), [data](<https://devfeed.tech/tags/data.md>), [domain](<https://devfeed.tech/tags/domain.md>), [feature](<https://devfeed.tech/tags/feature.md>), [ios](<https://devfeed.tech/tags/ios.md>), [jetpack](<https://devfeed.tech/tags/jetpack.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [kotlin-multiplatform](<https://devfeed.tech/tags/kotlin-multiplatform.md>), [migration](<https://devfeed.tech/tags/migration.md>), [multiplatform](<https://devfeed.tech/tags/multiplatform.md>)

### AI overview

BikeHub moved from native Android to Kotlin Multiplatform while keeping Android releasable at every step; about 84% of its Kotlin now lives in commonMain, with Android, iOS and WebAssembly targets. The migration benefited from early choices of KMP-compatible Ktor Client, Koin and SQLDelight, so networking, dependency injection and persistence mostly moved rather than needing replacement. Modularization provided a module-by-module migration order, limited failures to individual modules and made it practical to pause between releases. Android-specific code was pushed behind interfaces at platform boundaries, and the iOS app was kept to a thin Swift entry point and platform wiring. The author says they would add another target to CI as soon as the first module is converted, since Android-only code can compile in commonMain while still failing on other platforms; smaller, single-responsibility core modules would also have saved time.

### Source excerpt

BikeHub is KMP app that runs on Android, on iOS and in the browser via WebAssembly. It started as native Android. Around 84 percent of its Kotlin code lives in commonMain. At no point during the migration did the Android app stop being releasable. This isn't a story about a heroic rewrite. The real story is less dramatic and, I think, more useful: the migration was easier than it could have been because of choices made long before it started. How much a platform shift hurts is decided largely by architectural decisions made years earlier, often for entirely different reasons. This series isn't a KMP tutorial either. This is a case study of a real app that already had users, history and assumptions baked into its code: what moved easily, what hurt, and what I'd do differently. Part 1 covers the foundations. Where it started BikeHub is a bike maintenance tracker. It pulls your mileage from Strava, tracks wear on parts like chains, cassettes and brake pads, and tells you when something is due for a service. It is a side project, that has its own story. Initially started to try out new libraries and best practices and was for an audience of one. Later it turned into something I wanted to release to wider audiences. It started as a native Android app, split into 24 feature modules and 14 core modules (before the start of the migration). Today it has both more feature modules and more granularized core modules: Where it started Kotlin, Jetpack Compose, a layered architecture, UDF in the presentation layer, and a reasonable number of modules make it a fairly standard modern Android stack. What made the difference later wasn't how modern each piece was, but how portable it turned out to be. Choices made before the migration Ktor Client and Koin were in the app from day one, and both already supported Kotlin Multiplatform. Ktor Client is something I prefer over Retrofit, and Koin is something I prefer over Dagger. When the data and domain layers moved to shared code, the net

[Next page](<https://devfeed.tech/sources/proandroiddev-medium.md?cursor=WyIyMDI2LTEwLTI5VDE3OjMzOjM4KzAwOjAwIiwgImZkNmYzNGY3LTk1YmItNDcxOC1iZDdiLTJlMTI4ZDVhODIyMSJd>)