📚 Articles & References

Google — “Android 17 Beta 4: The Last Scheduled Beta”: Beta 4 is the final scheduled beta of the Android 17 release cycle — a critical milestone for app compatibility and platform stability testing. New items in Beta 4: app memory limits (targeted at extreme outliers), profiling triggers for anomaly detection, and Post-Quantum Cryptography (ML-DSA) in Android Keystore. SDK and game engine developers are urged to publish compatibility updates now.

Jaewoong Eum — “How Compose Hot Reload Works on Real Devices”: A detailed technical breakdown of the hot reload pipeline: incremental recompilation of the changed composable → class-file patching → ADB push → Compose’s ReloadScope API triggers re-execution. Supported changes: lambda bodies, string literals, numeric literals, and Color values. Unsupported: structural changes (adding/removing parameters, changing function signatures).

Thomas Ezan — “Experimental Hybrid Inference and New Gemini Models for Android”: Google introduced hybrid inference for Android — a mode where the inference request is evaluated on-device first (via Gemini Nano) and falls back to cloud (Gemini Pro/Flash) if the on-device model can’t handle the request. The switching is transparent to the app; you use the same GenerativeModel API for both paths.

“Android 17 Beta 4: Memory Limits and What They Mean for Your App”: A practical guide to Android 17’s new app memory limits. The limits are set conservatively in the initial release, targeting apps that exceed ~2GB of resident memory. The ApplicationExitInfo.description field will contain “MemoryLimiter” for affected exits. The recommended tool: LeakCanary’s new Android Studio Profiler integration.

“Post-Quantum Cryptography in Android Keystore”: Google’s security blog explains the new ML-DSA (Module-Lattice-Based Digital Signature Algorithm) support in Android Keystore. This is the NIST-standardized post-quantum signature algorithm. On supported devices, keys are generated and signatures computed entirely in secure hardware.

“Compose Recomposition as Test Expectations — A New Library”: An overview of a test-only library that turns Compose recomposition behavior into assertable, automatable test expectations. You can write assertions like assertThat(MyScreen).recomposedExactly(1).whenStateChanges(...) — precise recomposition testing without manual slot table inspection.

🛠️ Releases & Version Updates

Android 17 Beta 4: Available on all Pixel 6+ devices and the emulator. This is the near-final environment for testing. Key new APIs:

// Post-Quantum Cryptography — ML-DSA in Android Keystore
val keyPairGenerator = KeyPairGenerator.getInstance("ML-DSA-65", "AndroidKeyStore")
keyPairGenerator.initialize(
    KeyGenParameterSpec.Builder(
        "pqc-signing-key",
        KeyProperties.PURPOSE_SIGN or KeyProperties.PURPOSE_VERIFY
    ).build()
)
val keyPair = keyPairGenerator.generateKeyPair()

// Sign data with the quantum-safe key
val signature = Signature.getInstance("ML-DSA-65")
signature.initSign(keyPair.private)
signature.update(dataToSign)
val signatureBytes = signature.sign()

// Verify signature
val verifySignature = Signature.getInstance("ML-DSA-65")
verifySignature.initVerify(keyPair.public)
verifySignature.update(dataToSign)
val isValid = verifySignature.verify(signatureBytes)

Gemini SDK for Android — Hybrid Inference (Experimental):

// Hybrid inference — on-device first, cloud fallback
dependencies {
    implementation("com.google.ai.edge.aicore:aicore:1.0.0-alpha05")
}

// Single API, transparent on-device/cloud routing
val generativeModel = GenerativeModel(
    modelName = "gemini-nano",
    inferenceMode = InferenceMode.HYBRID, // NEW — tries on-device, falls back to cloud
    apiKey = BuildConfig.GEMINI_API_KEY
)

val prompt = content { text("Summarize this in one sentence: $text") }
val response = generativeModel.generateContent(prompt)
println(response.text)

Compose 1.9.0-alpha03: Adds BasicHtmlText to stable (moved from experimental), improved SelectionContainer for multi-touch selection, and a new Modifier.onFocusedBoundsChanged for accessibility tools.

Koin 4.1.0-alpha04: The Koin Compiler Plugin stability improves — the alpha04 build handles circular dependency detection at compile time (previously only detected at runtime).

LeakCanary 3.0.0-alpha05: First alpha with Android Studio Profiler integration. LeakCanary detects heap leaks on-device and surfaces them directly in the Profiler’s LeakCanary task view, with source-code linkage.

Anomaly Detection with Android 17 ProfilingTrigger

// Register for anomaly-triggered profiling
val profilingManager = applicationContext.getSystemService(ProfilingManager::class.java)

val triggers = listOf(
    ProfilingTrigger.Builder(ProfilingTrigger.TRIGGER_TYPE_ANOMALY).build()
)

val executor = Executors.newSingleThreadExecutor()
profilingManager.registerForAllProfilingResults(executor) { profilingResult ->
    if (profilingResult.errorCode == ProfilingResult.ERROR_NONE) {
        // Heap dump collected automatically when memory limit is approached
        uploadHeapDumpForAnalysis(profilingResult.resultFilePath)
    }
}

profilingManager.addProfilingTriggers(triggers)

📱 Android Platform Updates

Android 17 — App Memory Limits

Android 17 introduces per-app memory limits based on device RAM. The conservative initial limits target extreme cases:

The best practices: use ActivityManager.isLowRamDevice() for adaptive resource allocation, use the new ProfilingTrigger.TRIGGER_TYPE_ANOMALY for pre-crash heap dumps, and integrate LeakCanary in debug builds.

Compose Hot Reload — What Works, What Doesn’t

// ✅ Hot reload supported — immediate preview update on device
@Composable
fun WelcomeMessage() {
    Text(
        text = "Hello, Android 17!",  // change text → hot reload
        color = Color(0xFF6650A4),    // change color → hot reload
        fontSize = 24.sp              // change size → hot reload
    )
}

// ❌ Hot reload NOT supported — requires full recompile/redeploy
@Composable
fun WelcomeMessage(
    name: String,          // adding a parameter → not supported
    modifier: Modifier = Modifier  // adding modifier param → not supported
) {
    // Structural changes require full recompile
}

🔒 Security & Vulnerability Alerts

Post-Quantum Cryptography Timeline: Google’s security team announced a roadmap to require PQC for high-value Android Keystore operations in a future Android release. Apps handling financial transactions, health data, or identity credentials should begin evaluating ML-DSA migration now. The hardware support is available on Pixel 9+ devices in the field today.

Certificate Transparency — Android 17 Default Behavior: CT is enabled by default for apps targeting Android 17. Before targeting API 37:

1. Verify your server certificates are CT-logged (check with crt.sh)
2. Test with android:networkSecurityConfig pointing to a debug config that enables CT validation
3. Ensure any certificate-pinned connections use CAs that participate in CT

🎤 Conferences & Videos

Android Studio Profiler LeakCanary Integration Demo: Google published a demo video showing the new LeakCanary integration in Android Studio Panda’s profiler. You can trigger a heap analysis, see the leak tree, and jump directly to the leaking object’s creation site in your source code.

“Hybrid AI Inference for Android” — Google Developer Talk: Thomas Ezan’s talk explaining the hybrid inference architecture — how the SDK selects between on-device and cloud inference, how latency is managed, and the privacy model (on-device inference never leaves the device, cloud falls back with user-visible consent for sensitive requests).

💡 Quick Tip of the Week

Use ProfilingManager in debug builds to proactively capture performance data before issues are reported:

// In your Application class — debug builds only
if (BuildConfig.DEBUG) {
    val profilingManager = getSystemService(ProfilingManager::class.java) ?: return
    val executor = Executors.newSingleThreadExecutor()

    profilingManager.requestProfiling(
        ProfilingRequest.Builder(ProfilingType.JAVA_HEAP_DUMP)
            .setSamplingIntervalBytes(512 * 1024) // 512KB
            .build(),
        executor
    ) { result ->
        if (result.errorCode == ProfilingResult.ERROR_NONE) {
            Log.d("Profiler", "Heap dump: ${result.resultFilePath}")
        }
    }
}

On Android 17, you can also register TRIGGER_TYPE_ANOMALY triggers to get automatic heap dumps when your app approaches memory limits — without waiting for a crash.

🧠 Did You Know?

Android’s new hybrid inference system doesn’t just route between on-device and cloud — it can split a single inference request. In some model architectures, the embedding computation can run on-device (cheap, private) while the decoding step runs in the cloud (powerful, higher quality). This split-inference approach is still experimental but represents a fundamentally different way to think about mobile AI:

// Hybrid inference modes (experimental)
val hybridModel = GenerativeModel(
    modelName = "gemini-nano-hybrid",
    inferenceMode = InferenceMode.HYBRID,
    hybridConfig = HybridInferenceConfig.Builder()
        .setOnDeviceFirst(true)        // prefer on-device
        .setCloudFallbackEnabled(true) // fall back to cloud for unsupported requests
        .setMaxOnDeviceLatencyMs(500)  // fall back if on-device takes >500ms
        .build()
)

// The SDK handles routing transparently — same API call regardless of which path runs
val result = hybridModel.generateContent("What is the capital of France?")

The privacy model is clear: any request routed to cloud is flagged in the response metadata, so apps can show users when their data leaves the device.

❓ Weekly Quiz

Q1: What is the Compose Hot Reload pipeline on real devices, and which types of changes are supported?

A: The pipeline: incremental recompilation → class-file patching → ADB push → Compose ReloadScope re-execution. Supported changes: lambda bodies, string literals, numeric literals, color values. Unsupported: structural changes like adding/removing function parameters.

Q2: What is Post-Quantum Cryptography (ML-DSA), and why is it appearing in Android Keystore now?

A: ML-DSA (Module-Lattice-Based Digital Signature Algorithm) is a NIST-standardized digital signature algorithm resistant to quantum computer attacks. It’s being added to Android Keystore now because current RSA/ECDSA keys are theoretically vulnerable to “harvest now, decrypt later” attacks using future quantum computers. Sensitive key material should start migrating.

Q3: What does hybrid inference in the Gemini SDK for Android do, and how is it configured?

A: Hybrid inference uses on-device Gemini Nano first and falls back to cloud (Gemini Pro/Flash) when the on-device model can’t handle the request. Set InferenceMode.HYBRID in GenerativeModel. The routing is transparent to the app — the same API call works regardless of which path executes.

That’s a wrap for this week! See you in the next issue. 🐝

📚 Articles & References

Google — “Media3 1.10 Is Out”: The Media3 1.10 release adds Material 3 Compose playback widgets, a new Player composable combining video frame and controls, a ProgressSlider composable, PlaybackSpeedControl, and improved Transformer export speed. The media3-ui-compose-material3 module is maturing into a production-ready Compose media UI toolkit.

Jake Wharton — “Android KTX Libraries Are Being Retired”: Jake announced that the androidx.core:core-ktx, androidx.fragment:fragment-ktx, and related KTX libraries are being soft-retired. The Kotlin extensions they provided have been merged directly into their respective AndroidX libraries. core-ktx will continue to work as a shim but won’t receive new extensions.

Jaewoong Eum — “Compose Hot Reload on Real Devices: How It Works”: A detailed look at how Compose hot reload — which until recently only worked reliably on emulators — now works on physical Android devices. The article covers the compilation pipeline, the ADB-based class replacement mechanism, and the supported change types (lambda body changes, string literals, colors, dimensions).

“Media3 1.10: Building a Complete Media Player in Compose”: A tutorial building a full-featured video player using the new Player composable, ProgressSlider, and PlaybackSpeedToggleButton. The tutorial also covers handling MediaSessionService with LifecycleService (new in 1.10).

“Lottie Compose 6.6 — Multiplatform Animations”: With Lottie Compose 6.6 adding KMP support, the same Lottie animation files can now run on Android, iOS, and Desktop. The article benchmarks rendering performance across platforms and discusses strategies for reducing bundle size.

“KMP Network Inspector — Intercepting HTTP Without a Proxy”: An overview of a new KMP library that intercepts HTTP and WebSocket traffic without requiring a proxy setup. Works via OkHttp interceptors on Android and URLProtocol on iOS. Mock responses, throttle requests, and inspect headers in real time.

🛠️ Releases & Version Updates

Media3 1.10.0: The headline release. Here’s the new Player composable:

// Media3 1.10 — complete Player composable
dependencies {
    implementation("androidx.media3:media3-ui-compose-material3:1.10.0")
    implementation("androidx.media3:media3-exoplayer:1.10.0")
    implementation("androidx.media3:media3-session:1.10.0")
}

@Composable
fun VideoPlayerScreen(videoUri: Uri) {
    val context = LocalContext.current
    val player = remember {
        ExoPlayer.Builder(context)
            .setHandleAudioBecomingNoisy(true)
            .build()
            .apply {
                setMediaItem(MediaItem.fromUri(videoUri))
                prepare()
                playWhenReady = true
            }
    }

    DisposableEffect(player) {
        onDispose { player.release() }
    }

    // New in Media3 1.10 — single composable with built-in Material3 controls
    Player(
        player = player,
        modifier = Modifier
            .fillMaxWidth()
            .aspectRatio(16f / 9f),
        showControls = true
    )
}

// ProgressSlider — for custom player UIs
@Composable
fun CustomPlayerControls(player: Player) {
    Column {
        ProgressSlider(
            player = player,
            modifier = Modifier.fillMaxWidth()
        )
        Row(
            modifier = Modifier.fillMaxWidth(),
            horizontalArrangement = Arrangement.SpaceBetween
        ) {
            PlaybackSpeedToggleButton(player = player)
            PlayPauseButton(player = player)
            SeekForwardButton(player = player)
        }
    }
}

AndroidX Core 1.16.0: Replaces core-ktx as the canonical library. All extension functions previously in core-ktx are now in core directly. The core-ktx artifact becomes a dependency shim that simply depends on core:

// Migration: remove -ktx suffix
// Old:
implementation("androidx.core:core-ktx:1.15.0")
// New (functionally identical — same extensions, same API):
implementation("androidx.core:core:1.16.0")

// Same for other KTX libraries:
// androidx.fragment:fragment-ktx → androidx.fragment:fragment
// androidx.activity:activity-ktx → androidx.activity:activity
// androidx.collection:collection-ktx → androidx.collection:collection

Coil 3.3.0: Adds AsyncImage support for BlurTransformation and GrayscaleTransformation without requiring custom ImageRequest.Builder modifications. Also adds a CoilPainter.isLoading property for driving loading indicator state.

Detekt 1.24.1: Hotfix for a false positive in ComposeRememberMissing that flagged rememberSaveable incorrectly. If you’re on 1.24.0, upgrade.

Media3 1.10 — MediaSessionService with LifecycleService

// Media3 1.10 — MediaSessionService now extends LifecycleService
class PlaybackService : MediaSessionService() {
    private var mediaSession: MediaSession? = null

    override fun onCreate() {
        super.onCreate()
        val player = ExoPlayer.Builder(this).build()

        // Access lifecycle scope — new in 1.10
        lifecycleScope.launch {
            lifecycle.repeatOnLifecycle(Lifecycle.State.STARTED) {
                // Collect from flows tied to service lifecycle
                userPreferences.repeatMode.collect { mode ->
                    player.repeatMode = mode
                }
            }
        }

        mediaSession = MediaSession.Builder(this, player).build()
    }

    override fun onGetSession(controllerInfo: MediaSession.ControllerInfo) = mediaSession
}

📱 Android Platform Updates

Android KTX Deprecation — What It Means Practically

The KTX libraries aren’t being removed — they’ll continue working as dependency shims. But they won’t receive new Kotlin extensions. The reason: as Jetpack libraries have become Kotlin-first, the “Kotlin extensions” layer is now redundant. The AndroidX libraries themselves are written in Kotlin and expose idiomatic Kotlin APIs directly.

Timeline:

• Now: KTX libraries are shims pointing to their base library
• Future: KTX artifacts may be removed entirely from new project templates
• Never (likely): The -ktx artifacts will remain on Maven for backward compatibility

Android 17 — Background Audio Hardening Details

Google clarified the Android 17 background audio restrictions following developer feedback:

• Audio focus requests from background apps require an active foreground service
• Volume change APIs (adjustStreamVolume) blocked for background apps without active audio session
• Exemptions: alarm audio, system audio, apps with active MediaSession
• targetSdk gating: enforcement only for apps targeting API 37+

⚠️ Deprecation & Migration Alerts

-ktx Libraries — Migration Timeline: No immediate action required. The -ktx libraries continue to work. When starting new modules or updating existing dependencies, prefer the base library directly (core instead of core-ktx). Gradle will warn you when you depend on a deprecated KTX shim in AGP 9.0+.

Media3 FrameExtractor Moved: FrameExtractor moved from media3-inspector to the new media3-inspector-frame module. Update your imports:

// Old:
import androidx.media3.inspector.FrameExtractor
// New:
import androidx.media3.inspector.frame.FrameExtractor

// build.gradle.kts
implementation("androidx.media3:media3-inspector-frame:1.10.0")

💡 Quick Tip of the Week

Use MediaItem.ClippingConfiguration in Media3 to play only a portion of a media file:

// Play only seconds 30–90 of a video
val clippedMediaItem = MediaItem.Builder()
    .setUri(videoUri)
    .setClippingConfiguration(
        MediaItem.ClippingConfiguration.Builder()
            .setStartPositionMs(30_000L)
            .setEndPositionMs(90_000L)
            .setRelativeToDefaultPosition(false)
            .build()
    )
    .build()

player.setMediaItem(clippedMediaItem)
player.prepare()
player.play()

This works on any ExoPlayer-supported format and doesn’t require pre-processing the file. Great for video trim previews and audio clip players.

🧠 Did You Know?

core-ktx is over 5 years old and has been providing Kotlin extension functions since before Jetpack libraries were written in Kotlin. When Jake Wharton announced the KTX retirement, many developers were surprised to learn that the extensions were so widely used. Looking at adoption metrics, core-ktx was imported by more than 85% of all published Android apps. The most used extensions: Bundle.putString, Context.systemService<T>(), View.doOnLayout, and String.toUri(). All of these are now in core directly — no migration needed beyond the dependency declaration.

// These still work exactly the same — just from core instead of core-ktx
val notificationManager = context.getSystemService<NotificationManager>()
val uri = "https://mukuljangra.com".toUri()

view.doOnLayout { view ->
    val height = view.measuredHeight
}

val bundle = bundleOf(
    "userId" to userId,
    "source" to "notification"
)

❓ Weekly Quiz

Q1: What is the new Player composable in Media3 1.10, and what does it combine?

A: The Player composable combines a ContentFrame (renders video) with customizable Material 3 playback controls. It’s an out-of-the-box player widget with a modern UI that replaces the older PlayerView (View-based) for Compose apps.

Q2: Why did Jake Wharton announce the Android KTX libraries are being retired?

A: Because Jetpack libraries themselves are now written in Kotlin and provide idiomatic Kotlin APIs directly. The KTX “extension” layer has become redundant — there’s no longer a need for separate extension functions on top of Java-based libraries. KTX continues to work as a shim but won’t receive new extensions.

Q3: What change does Media3 1.10 make to MediaSessionService that enables better lifecycle management?

A: MediaSessionService now extends LifecycleService, giving the service access to lifecycleScope and repeatOnLifecycle. This allows the service to collect from Flows and tie async work to the service’s lifecycle, replacing manual lifecycle management.

That’s a wrap for this week! See you in the next issue. 🐝

📚 Articles & References

Google — “Android 17 Beta 3: Platform Stability Reached”: Beta 3 marks the API lock milestone for Android 17. All SDK and NDK APIs are now final. Apps can target compileSdk = 37 and publish to Google Play immediately. Google confirmed the behavior changes that will be enforced for apps targeting API 37: large screen resizability restrictions, safer dynamic code loading extension to native libs, and Certificate Transparency by default.

CommonsWare — “The March 25 Jetpack Artifact Wave”: Mark Murphy documents the massive Jetpack release wave from March 25. Highlights: Room 3.0 gains Android TV and Automotive OS targets, a new wear-compose-remote artifact enables phone-rendered Compose on watches, and several AndroidX alpha libraries bumped to beta. The Room multiplatform expansion is the most significant.

“Android 17 App Compatibility Checklist — Resizability on Large Screens”: Once an app targets API 37, it can no longer opt out of maintaining orientation, resizability, and aspect ratio constraints on large screens. This affects apps that use android:screenOrientation="portrait" — on tablets and foldables, the system will ignore this constraint.

“Certificate Transparency in Android 17 — What Changes”: CT is enabled by default in Android 17 (opt-in in Android 16). Apps pinning certificates via Network Security Config need to verify their CA chains are CT-logged. The article explains how to test CT compliance with curl and openssl before targeting API 37.

“Building with Navigation 3 in Production”: A case study from a mid-size app team that migrated from Navigation 2 to Navigation 3. The migration took 2 sprints. The wins: type-safe routes, predictive back integration, and shared element transitions. The challenges: bottom tab state preservation required custom back stack management.

“Kotlin Multiplatform Statistics Toolkit”: A new KMP library (kotlin-statistics) covering distributions, hypothesis testing, descriptive statistics, sampling, and correlation analysis. Useful for apps doing on-device analytics, health metric calculations, or recommendation engine features.

🛠️ Releases & Version Updates

AndroidX Compose BOM 2026.04.00-alpha01: First alpha of the April BOM cycle includes Compose 1.9.0-alpha02 with improved LazyColumn prefetch that accounts for scroll velocity, reducing visible item pop-in on fast flings.

Room 3.0.0-alpha02: New multiplatform targets and fixes for the initial alpha:

// Room 3.0 — expanded KMP targets
kotlin {
    androidTarget()
    iosArm64()
    iosSimulatorArm64()
    macosArm64()
    tvosArm64()        // NEW in alpha02
    watchosArm64()     // NEW in alpha02
    jvm("desktop")     // NEW in alpha02

    sourceSets {
        commonMain.dependencies {
            implementation("androidx.room:room-runtime:3.0.0-alpha02")
            implementation("androidx.sqlite:sqlite-bundled:2.5.0")
        }
        androidMain.dependencies {
            implementation("androidx.sqlite:sqlite-android:2.5.0")
        }
    }
}

// Same DAO, works on all targets
@Dao
interface ProductDao {
    @Query("SELECT * FROM products WHERE category = :category")
    fun getByCategory(category: String): Flow<List<Product>>

    @Upsert
    suspend fun upsert(product: Product)
}

Hilt 2.56.1: Fixes a crash when using @HiltViewModel with Navigation 3’s BackStackEntry as the ViewModelStoreOwner.

Accompanist 0.37.0 (Final): This is it — the last release. If you still have Accompanist dependencies, now is the time to migrate:

// Migration guide — common Accompanist → AndroidX mappings

// Pager
// ❌ com.google.accompanist:accompanist-pager
// ✅ androidx.compose.foundation:foundation (HorizontalPager, VerticalPager)

// SystemUIController
// ❌ com.google.accompanist:accompanist-systemuicontroller
// ✅ enableEdgeToEdge() in ComponentActivity

// FlowLayout
// ❌ com.google.accompanist:accompanist-flowlayout
// ✅ androidx.compose.foundation:foundation (FlowRow, FlowColumn)

// Placeholder
// ❌ com.google.accompanist:accompanist-placeholder
// ✅ Custom shimmer effect (see below)

// Shimmer placeholder without Accompanist
@Composable
fun ShimmerPlaceholder(
    isLoading: Boolean,
    content: @Composable () -> Unit
) {
    if (isLoading) {
        val shimmerColors = listOf(
            MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.6f),
            MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.2f),
            MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.6f),
        )
        val transition = rememberInfiniteTransition(label = "shimmer")
        val translateAnim by transition.animateFloat(
            initialValue = 0f, targetValue = 1000f,
            animationSpec = infiniteRepeatable(tween(1200), RepeatMode.Restart),
            label = "shimmer_translate"
        )
        Box(
            modifier = Modifier
                .background(Brush.linearGradient(shimmerColors, start = Offset(translateAnim - 200f, 0f), end = Offset(translateAnim, 0f)))
        )
    } else {
        content()
    }
}

Android 17 Beta 3 — Behavior Changes Summary

// 1. Dynamic code loading restriction — native libs must be read-only
// This WILL throw UnsatisfiedLinkError in Android 17+ if lib is writable:
System.load("/data/data/com.example/files/myplugin.so")
// Fix: load only from read-only paths (installed APK paths are fine)

// 2. Local network permission — required for LAN discovery
// Declare in manifest:
// <uses-permission android:name="android.permission.ACCESS_LOCAL_NETWORK" />
// Request at runtime like any other permission
val granted = ActivityCompat.checkSelfPermission(
    context, "android.permission.ACCESS_LOCAL_NETWORK"
) == PackageManager.PERMISSION_GRANTED

// 3. Large screen resizability — can no longer opt out on API 37+
// Remove or stop relying on these:
// android:screenOrientation="portrait"  // Ignored on large screens
// android:resizeableActivity="false"    // Ignored on large screens

📱 Android Platform Updates

Memory Limits in Android 17

Android 17 introduces per-app memory limits based on device RAM. The limits are conservative in the initial release — targeting only extreme outliers. Apps can detect if they hit a limit via ApplicationExitInfo:

fun checkForMemoryLimitExits(context: Context) {
    val activityManager = context.getSystemService(ActivityManager::class.java)
    val exitReasons = activityManager.getHistoricalProcessExitReasons(
        context.packageName,
        0, // most recent
        5  // last 5 exits
    )

    exitReasons.filter { exitInfo ->
        exitInfo.description?.contains("MemoryLimiter") == true
    }.forEach { exitInfo ->
        // App was killed due to memory limit — log for crash reporting
        analytics.logEvent("memory_limit_exit", mapOf(
            "process" to exitInfo.processName,
            "timestamp" to exitInfo.timestamp
        ))
    }
}

⚠️ Deprecation & Migration Alerts

Accompanist is officially retired. All APIs have been migrated to official AndroidX libraries. Check your build.gradle.kts files for any remaining com.google.accompanist: dependencies and migrate them before the library is removed from repositories.

Navigation 2.x — No New Features: Google confirmed that Navigation 2 will continue to receive bug fixes but no new features. Navigation 3 is the active development branch. Migration guides are available at developer.android.com.

💡 Quick Tip of the Week

Use Modifier.composed {} when you need to read Compose state inside a Modifier:

// ❌ Reading state inside a regular Modifier is not stable
fun Modifier.dynamicBorder(colorState: State<Color>): Modifier =
    border(2.dp, colorState.value) // colorState.value read outside composition

// ✅ Modifier.composed — reads state inside composition safely
fun Modifier.dynamicBorder(colorState: State<Color>): Modifier =
    composed {
        val color by colorState
        border(2.dp, color, RoundedCornerShape(8.dp))
    }

// Even better: use a @Composable function to create the modifier
@Composable
fun Modifier.highlightWhenFocused(): Modifier {
    val isFocused by remember { mutableStateOf(false) }
    return this.then(
        if (isFocused) Modifier.border(2.dp, MaterialTheme.colorScheme.primary)
        else Modifier
    )
}

🧠 Did You Know?

Flow.flatMapLatest cancels the previous inner flow, but Flow.flatMapMerge doesn’t — and this difference causes silent data loss in search features. Most search implementations want flatMapLatest (cancel the old search when the user types again), but many developers accidentally use flatMapConcat or flatMapMerge:

class SearchViewModel : ViewModel() {
    private val queryFlow = MutableStateFlow("")

    // ❌ flatMapConcat: queues every keystroke — old results arrive after new ones
    val results1 = queryFlow.flatMapConcat { query -> searchApi.search(query) }

    // ❌ flatMapMerge: all searches run in parallel — results arrive out of order
    val results2 = queryFlow.flatMapMerge { query -> searchApi.search(query) }

    // ✅ flatMapLatest: cancels previous search when a new query arrives
    val results3 = queryFlow.flatMapLatest { query ->
        if (query.isEmpty()) flowOf(emptyList())
        else searchApi.search(query)
    }
}

flatMapLatest is the correct operator for any “latest value wins” scenario: search, location tracking with debounce, and live filter inputs.

❓ Weekly Quiz

Q1: What does Android 17 Beta 3’s “platform stability” milestone mean in practical terms for app developers who want to publish to Google Play?

A: Apps can now target compileSdk = 37 and publish to Google Play immediately. The API surface is final — no more breaking changes. Developers can complete their API 37 compatibility testing with confidence that the APIs they’re testing against are production-ready.

Q2: Why does targeting Android 17 (API 37) change behavior on large screens regarding android:screenOrientation="portrait"?

A: Apps targeting API 37 can no longer opt out of maintaining orientation, resizability, and aspect ratio constraints on large screens. The system ignores screenOrientation and resizeableActivity="false" on tablets, foldables, and other large-screen devices to ensure a consistent, adaptive user experience.

Q3: What is the difference between flatMapLatest, flatMapConcat, and flatMapMerge in Kotlin Flow for a search feature?

A: flatMapLatest cancels the previous search when a new query arrives (correct for search). flatMapConcat queues searches sequentially (results can arrive out of order, old results block new ones). flatMapMerge runs all searches in parallel (results arrive out of order, no cancellation).

That’s a wrap for this week! See you in the next issue. 🐝

📚 Articles & References

JetBrains — “Kotlin 2.3.20 Released”: The 2.3.20 maintenance release ships Gradle 9.3 compatibility, name-based destructuring declarations, a new C/Objective-C interop mode for Kotlin/Native, and improved Maven setup for KMP projects. The Gradle 9.3 compatibility is the most operationally urgent change — teams on Gradle 9.3+ will need this version.

Google — “Get Inspired and Take Your Apps to Desktop”: Google published extensive desktop design guidance and launched the Android Design Gallery. This accompanies a separate announcement that Android apps can now extend to external monitors via DisplayLink on Android 14+ devices. Apps in desktop mode run at full display resolution with keyboard and mouse support.

“Kotlin 2.3.20: Name-Based Destructuring in Practice”: A deep-dive into the new name-based destructuring declaration, which lets you destructure by property name rather than position. The key improvement: data classes with many fields no longer require you to count positions, and adding a field in the middle no longer silently shifts all destructuring assignments.

“CommonsWare: March 25 Jetpack Artifact Wave”: Mark Murphy (CommonsWare) documents the unusually large March 25 Jetpack release wave — Room 3.0 new multiplatform targets, Wear Compose Remote, and several AndroidX alpha bumps. The Room 3.0 multiplatform additions are the highlight.

“Tracey — Compose Flight Recorder for Android, iOS, and Desktop”: The open-source KMP library for recording app sessions as structured event logs, with a browser-based replay viewer. The library hooks into Compose’s accessibility tree to capture interactions without requiring manual instrumentation.

“Navigating the Compose Navigation 3 Alpha with Pure Reducers”: A walkthrough of a community navigation library built around immutable state and pure reducers. The approach: navigation state is a plain List<Screen>, every navigation action is a pure function, and the library handles the NavHost rendering. Highly testable, predictable, and debuggable.

🛠️ Releases & Version Updates

Kotlin 2.3.20: Key changes for Android developers:

// New: Name-based destructuring declarations
data class User(val id: String, val name: String, val email: String, val age: Int)

// Old positional destructuring — fragile when fields are added/reordered
val (id, name, _, age) = user  // What is _? You have to count.

// New: Name-based — explicit and refactoring-safe
val (id, name, age) by user  // Uses property names, order doesn't matter
// email is simply not destructured — no placeholder needed

// Gradle 9.3 compatibility — update your Kotlin version
// build.gradle.kts
plugins {
    kotlin("android") version "2.3.20"
    // Gradle 9.3 compatibility requires 2.3.20+
}

Compose BOM 2026.03.00: Stable release including Compose Runtime 1.8.0 stable, Compose UI 1.8.0 stable, and Material3 1.4.0 stable. The runtime stable release means all @Stable compiler analysis improvements are now production-ready.

Koin 4.0.4: Maintenance release fixing koinApplication {} builder thread-safety in multi-threaded initialization scenarios (affects apps that initialize Koin from background threads via WorkManager).

AGP 8.9.0-beta01: Beta release with R8 Full Mode enabled by default for new modules. Existing modules need to opt in via isMinifyEnabled = true + proguardFiles(...). The beta also fixes a long-standing issue where Compose preview rendering in Studio would fail if any KSP-generated code was in the dependency graph.

Kotlinx.coroutines 1.10.2: Adds Flow.onEmpty {} operator — fires when a Flow completes without emitting any values. Useful for showing empty state UI in collectLatest patterns:

viewModel.items
    .onEmpty { showEmptyState() }
    .onEach { items -> showContent(items) }
    .launchIn(lifecycleScope)

Kotlin 2.3.20 — C/Objective-C Interop Mode

For KMP projects targeting iOS/macOS, the new cinterop mode improves type bridging:

// Kotlin/Native interop with Objective-C — improved in 2.3.20
// cinterop generates cleaner Kotlin stubs for Objective-C generics

// Previously: ObjC NSArray<NSString *> became Array<Any?>
// Now: NSArray<NSString *> becomes Array<String>
fun processStrings(array: NSArray<NSString>) {
    array.forEach { str ->
        println(str) // str is now String, not Any?
    }
}

📱 Android Platform Updates

Android 17 Beta 3 — Platform Stability Milestone

Android 17 Beta 3 is expected this week, marking the API lock. From this point:

• No new APIs will be added to the Android 17 SDK
• Apps can target compileSdk = 37 and publish to Google Play for early feedback
• The focus shifts to stability, performance, and behavior change validation

Apps should prioritize testing these Android 17 behavior changes:

1. ACCESS_LOCAL_NETWORK permission required for LAN device discovery
2. Background audio focus restrictions
3. Dynamic code loading restrictions (native libraries must be read-only)
4. Certificate Transparency enabled by default

Android Apps on External Monitors

The DisplayLink integration in Android 14+ (QPR1) is now officially supported for production use. Apps that support android:resizeableActivity="true" get external monitor support automatically. Apps that want to optimize for desktop mode should implement:

// Detect external display mode
val displayManager = context.getSystemService(DisplayManager::class.java)
val displays = displayManager.getDisplays(DisplayManager.DISPLAY_CATEGORY_PRESENTATION)

if (displays.isNotEmpty()) {
    // App is on an external display — optimize for desktop
    enableDesktopFeatures()
}

// Observe display changes
displayManager.registerDisplayListener(object : DisplayManager.DisplayListener {
    override fun onDisplayAdded(displayId: Int) { checkDisplayMode() }
    override fun onDisplayRemoved(displayId: Int) { checkDisplayMode() }
    override fun onDisplayChanged(displayId: Int) { checkDisplayMode() }
}, null)

🌟 Community Spotlight

Tracey: An open-source Compose flight recorder for Android, iOS, and Desktop. Records gestures, breadcrumbs, screen views, and crashes with timestamps. The data is stored locally and can be exported as structured JSON or replayed in the browser-based viewer. It’s the closest thing to Amplitude’s session replay for native apps. GitHub: hi-manshu/tracey.

A Browser-Based Android Lint Playground: A community-built tool that lets you write, test, and share custom Android Lint rules with live SARIF output — no local Android Studio required. Useful for developing lint rules for your design system or architecture guidelines.

🧰 Tool of the Week

Android Virtual Device Menu Bar App (macOS): A macOS menu bar app for quickly launching and managing Android Virtual Devices without opening Android Studio. Supports filtering by API level, starting/stopping devices, and deep-linking directly into running emulators. Available on GitHub. If you run multiple emulators daily, the time savings add up.

💡 Quick Tip of the Week

Kotlin’s buildString is faster than string concatenation for multi-step string construction:

// ❌ String concatenation — allocates intermediate String objects
fun formatUserInfo(user: User): String {
    var result = "Name: ${user.name}"
    result += "\nEmail: ${user.email}"
    result += "\nJoined: ${user.joinDate}"
    if (user.isPremium) result += "\n⭐ Premium member"
    return result
}

// ✅ buildString — single StringBuilder, zero intermediate allocations
fun formatUserInfo(user: User): String = buildString {
    append("Name: ").appendLine(user.name)
    append("Email: ").appendLine(user.email)
    append("Joined: ").appendLine(user.joinDate)
    if (user.isPremium) appendLine("⭐ Premium member")
}

buildString uses a StringBuilder internally, so it’s particularly valuable in hot paths like RecyclerView adapters, list formatters, or logging utilities.

🧠 Did You Know?

Kotlin’s by keyword in destructuring and delegation look identical but are completely different features. Name-based destructuring (new in 2.3.20) uses val (name, age) by user, where by invokes the component() functions by name. Class delegation (class A : B by b) uses by to forward interface implementation. Property delegation (val x by lazy { }) uses by to invoke the getValue/setValue operators. All three share the same keyword but have zero semantic overlap:

// 1. Property delegation — operator overloading (getValue/setValue)
val config by lazy { loadConfig() }
var count by mutableStateOf(0)

// 2. Class delegation — interface forwarding
class LoggingList<T>(private val delegate: List<T>) : List<T> by delegate {
    override fun get(index: Int): T {
        println("get($index)")
        return delegate[index]
    }
}

// 3. Name-based destructuring — component functions by name (NEW in 2.3.20)
data class Point(val x: Int, val y: Int, val z: Int)
val (x, z) by Point(1, 2, 3)  // y is not destructured — no placeholder

❓ Weekly Quiz

Q1: What is the primary operational advantage of name-based destructuring over positional destructuring in Kotlin?

A: Name-based destructuring is refactoring-safe. Adding a field to a data class in the middle no longer silently shifts all positional destructuring assignments, preventing subtle bugs. Unused fields don’t require placeholder underscores.

Q2: What does Android 17 Beta 3’s “platform stability” milestone mean for app developers?

A: The SDK/NDK API surface is locked. No new APIs will be added. Apps can now target compileSdk = 37, publish to Google Play for testing, and complete their compatibility validation knowing the APIs they test against are final.

Q3: What is Flow.onEmpty {} in kotlinx.coroutines 1.10.2 useful for in Android development?

A: It fires when a Flow completes without emitting any values. This is useful for showing an empty state in UI — when a database query returns no rows or an API returns an empty list, onEmpty lets you show the empty state view without a special null or empty list check.

That’s a wrap for this week! See you in the next issue. 🐝

📚 Articles & References

Marcello Galhardo — “New Lifecycle ViewModel APIs: Scoping Beyond Navigation”: The stable Lifecycle 2.9 release formalizes the ability to scope ViewModels to arbitrary positions in the Compose hierarchy. The article shows three patterns: screen-level scoping (traditional), component-level scoping (new), and subtree scoping for feature modules. The key API: viewModel(viewModelStoreOwner = LocalViewModelStoreOwner.current) with a custom ViewModelStoreOwner provider.

Thomas Künneth — “KMP Navigation: Decompose, Circuit, and Compose Multiplatform”: A thorough comparison of navigation approaches for Kotlin Multiplatform apps. Decompose favors a component model with explicit back-stack management; Circuit (Slack) favors a unidirectional data flow with presenter-based navigation; Compose Multiplatform’s built-in navigation is the simplest but least powerful. The article recommends Circuit for greenfield KMP projects.

“Android Desktop Experience Design Guidance Published”: Google published comprehensive design guidance for “desktop mode” on Android — when apps run on external monitors via DisplayLink or on ChromeOS in windowed mode. Key principles: higher information density, keyboard/mouse input handling, window resizing to arbitrary sizes, and taskbar integration. A new Android Design Gallery was launched alongside.

“Compose Recomposition Monitoring in Production”: A look at using Compose’s RecompositionTracker API in debug builds to establish recomposition baselines and flag regressions in CI. The article shows how to pipe recomposition stats into a custom analytics dashboard.

“Kotlin Multiplatform for Ticket Validation — A Masabi Case Study”: Paweł Kwieciński from Masabi explains how they brought a 10-year-old Java codebase to KMP, powering ticket validation across mobile apps, embedded devices, and backend systems. The key challenge: Kotlin/Native performance on resource-constrained embedded devices. Their solution: @OptIn(ExperimentalNativeApi::class) carefully applied, with native memory management annotations.

“R8 Full Mode in AGP 8.9 — A Complete Migration Guide”: AGP 8.9 enables R8 Full Mode by default for new projects. The guide covers common breakage patterns: reflection-based serialization, class name-based routing, Gson model classes, and Retrofit interface implementation. The fix toolkit: @Keep, -keepclassmembers, and @JsonClass(generateAdapter = true) for Moshi.

🛠️ Releases & Version Updates

Lifecycle 2.9.0 Stable: The viewModel() composable in lifecycle-viewmodel-compose now accepts a custom viewModelStoreOwner and factory parameter:

// Create a custom ViewModelStoreOwner for fine-grained ViewModel scoping
class CompositionViewModelStoreOwner : ViewModelStoreOwner {
    override val viewModelStore = ViewModelStore()
    fun clear() = viewModelStore.clear()
}

// Scope a ViewModel to a specific composable subtree
@Composable
fun ProductFeature(productId: String) {
    // ViewModelStoreOwner lives as long as this composable is in the tree
    val vmStoreOwner = remember(productId) { CompositionViewModelStoreOwner() }
    DisposableEffect(productId) {
        onDispose { vmStoreOwner.clear() }
    }

    val vm = viewModel<ProductViewModel>(
        viewModelStoreOwner = vmStoreOwner,
        factory = ProductViewModel.Factory(productId)
    )

    ProductContent(vm.uiState.collectAsStateWithLifecycle().value)
}

Compose Multiplatform 1.8.0: Adds iOS-native text input handling (first-class IMEOptions on iOS), improved Modifier.pointerInput on Desktop, and a new LocalWindowInfo.current.isKeyboardVisible API shared across platforms:

// Shared Compose Multiplatform code — keyboard visibility across platforms
@Composable
fun AdaptiveForm() {
    val keyboardVisible = LocalWindowInfo.current.isKeyboardVisible
    val scrollState = rememberScrollState()

    Column(
        modifier = Modifier
            .fillMaxSize()
            .verticalScroll(scrollState)
            .padding(bottom = if (keyboardVisible) 300.dp else 16.dp)
    ) {
        FormFields()
    }
}

Detekt 1.24.0: Adds new rules for Compose — ComposeComposableModifier (enforces that modifier parameters use Modifier = Modifier default), ComposeNamingUppercase (enforces @Composable functions start with uppercase), and ComposeRememberMissing (flags state creation without remember).

OkHttp 5.0.0-alpha17: Continues the alpha series with improved HTTP/3 (QUIC) support and a new EventListener API that reports request/response timing at the frame level for HTTP/2 and HTTP/3.

Android Desktop Design — Key Patterns

// Detect if app is in desktop/windowed mode
@Composable
fun adaptToWindowMode(): WindowMode {
    val windowSizeClass = currentWindowAdaptiveInfo().windowSizeClass
    val configuration = LocalConfiguration.current

    return when {
        configuration.isLayoutSizeAtLeast(Configuration.SCREENLAYOUT_SIZE_LARGE) &&
        windowSizeClass.windowWidthSizeClass == WindowWidthSizeClass.EXPANDED ->
            WindowMode.Desktop

        windowSizeClass.windowWidthSizeClass == WindowWidthSizeClass.EXPANDED ->
            WindowMode.Tablet

        else -> WindowMode.Phone
    }
}

@Composable
fun AppLayout() {
    when (adaptToWindowMode()) {
        WindowMode.Desktop -> DesktopLayout()   // High density, menu bar
        WindowMode.Tablet -> TabletLayout()      // Navigation rail
        WindowMode.Phone -> PhoneLayout()        // Bottom navigation
    }
}

📱 Android Platform Updates

Android 17 — API Lock Approaching

Beta 3 is expected this week or next, marking platform stability. After platform stability:

• Final SDK/NDK APIs are locked
• Apps can target SDK 37 and publish to Google Play
• No more breaking API changes in remaining betas

ChromeOS + Android Desktop Mode

Google announced that Android apps can seamlessly extend to external monitors via DisplayLink, enabling a true desktop-class experience. The new guidance covers:

• Window resizing to arbitrary dimensions
• Keyboard shortcut registration via KeyboardShortcutGroup
• Context menu support for right-click events
• Drag-and-drop between apps

// Register keyboard shortcuts for desktop mode
override fun onProvideKeyboardShortcuts(
    data: MutableList<KeyboardShortcutGroup>,
    menu: Menu?,
    deviceId: Int
) {
    val shortcuts = KeyboardShortcutGroup(
        "File operations",
        listOf(
            KeyboardShortcutInfo("Save", KeyEvent.KEYCODE_S, KeyEvent.META_CTRL_ON),
            KeyboardShortcutInfo("New", KeyEvent.KEYCODE_N, KeyEvent.META_CTRL_ON),
            KeyboardShortcutInfo("Open", KeyEvent.KEYCODE_O, KeyEvent.META_CTRL_ON)
        )
    )
    data.add(shortcuts)
}

🎤 Conferences & Videos

“R8 Deep Dive” — The Modern Android Development Podcast: Hosts Tor and Romain sit with Søren Gjesse, Chris Craik, and Shai Barack to discuss how R8 differs from ProGuard, what Full Mode enables, and the performance implications of different optimization strategies. Essential listening before enabling R8 Full Mode in your project.

Talking Kotlin — “KMP in Production: Masabi’s Journey”: Paweł Kwieciński discusses the Masabi KMP migration in podcast form. The most interesting segment: how they handle Kotlin/Native memory management on embedded ticket validators with ~128MB RAM.

💡 Quick Tip of the Week

Use WindowInsets.are APIs to handle system bars in Compose without manual insets calculation:

// ❌ Manual insets calculation — fragile across API levels
@Composable
fun Screen() {
    val insets = WindowInsetsCompat.toWindowInsetsCompat(
        LocalView.current.rootWindowInsets
    )
    val topPadding = insets.getInsets(WindowInsetsCompat.Type.statusBars()).top
    Box(modifier = Modifier.padding(top = topPadding.dp)) { Content() }
}

// ✅ WindowInsets DSL — handles all edge cases automatically
@Composable
fun Screen() {
    Scaffold(
        // Scaffold handles status bar and navigation bar padding
        topBar = { TopAppBar(title = { Text("Title") }) },
        content = { padding ->
            Content(modifier = Modifier.padding(padding))
        }
    )
}

// For custom layouts without Scaffold:
Box(
    modifier = Modifier
        .fillMaxSize()
        .windowInsetsPadding(WindowInsets.systemBars)
) { Content() }

🧠 Did You Know?

Compose Modifier.pointerInput has a subtle restart behavior that causes animation glitches. When any key passed to pointerInput changes, the gesture detector is restarted — cancelling any in-progress gestures. This means passing a lambda as a key (which creates a new instance every recomposition) restarts gesture detection on every recomposition:

// ❌ Lambda as key — pointerInput restarts on every recomposition
Modifier.pointerInput(onSwipe) {  // onSwipe is a lambda — new instance each time
    detectHorizontalDragGestures { _, dragAmount -> onSwipe(dragAmount) }
}

// ✅ Unit as key with rememberUpdatedState — stable key, always-fresh callback
@Composable
fun SwipeableBox(onSwipe: (Float) -> Unit, content: @Composable () -> Unit) {
    val currentOnSwipe by rememberUpdatedState(onSwipe)
    Box(
        modifier = Modifier.pointerInput(Unit) {  // Unit = never restart
            detectHorizontalDragGestures { _, dragAmount -> currentOnSwipe(dragAmount) }
        }
    ) { content() }
}

This is a well-known footgun for developers moving from Compose basics to gesture-heavy UIs.

❓ Weekly Quiz

Q1: In Lifecycle 2.9, what is the recommended way to scope a ViewModel to a specific Compose subtree rather than the entire Activity?

A: Create a custom ViewModelStoreOwner (e.g., CompositionViewModelStoreOwner) backed by a ViewModelStore, pass it to viewModel(viewModelStoreOwner = ...), and clear it in a DisposableEffect. This scopes the ViewModel lifetime to the composable’s presence in the composition tree.

Q2: What is the risk of passing a lambda as a key to Modifier.pointerInput?

A: Lambda instances are new objects on every recomposition, so pointerInput with a lambda key restarts on every recomposition — cancelling any in-progress gestures. Use Unit as the key combined with rememberUpdatedState to keep the callback fresh without restarting.

Q3: When designing for Android desktop mode, what input states require special consideration beyond touch interactions?

A: Keyboard shortcuts (registered via onProvideKeyboardShortcuts), mouse hover states, right-click context menus, pointer cursor icon changes, and drag-and-drop between apps. Touch-first designs assume tap targets — desktop mode requires handling keyboard and mouse precision inputs that have no touch equivalent.

That’s a wrap for this week! See you in the next issue. 🐝

📚 Articles & References

Google — “Room 3.0 Alpha: Kotlin Multiplatform, Coroutines-First”: Room 3.0 drops Java annotation-based code generation in favor of a pure Kotlin KSP pipeline and adds Kotlin Multiplatform targets (iOS, macOS, Windows). The biggest architectural change: all DAO methods must be suspend or return Flow — no blocking Room operations in 3.0. Java LiveData-returning DAOs are removed entirely.

Kirill Rozov — “Detekt Rules for Koin: Enforcing DI Best Practices”: A ready-to-use Detekt plugin with rules for Koin usage: detecting module declarations with too many bindings, get() calls in constructors (which bypass constructor injection), and missing @KoinInternalApi annotations on internal Koin utilities. The plugin runs in CI and integrates with the existing Detekt config.

“Remote Compose — Serving UI From a Server Without JSON or WebViews”: Arman Chatikyan’s deep dive into Google’s Remote Compose protocol. The system serializes Compose layout descriptions to a binary format, sends them over the network, and renders them on-device using real Compose. Current limitations: no arbitrary lambdas in server-rendered composables, event handling requires pre-registered interaction IDs.

“ViewModel Scoping to Compose UI Hierarchy in Lifecycle 2.9”: Marcello Galhardo’s follow-up article with code examples from the stable Lifecycle 2.9 APIs. The viewModel() composable now accepts a viewModelStoreOwner parameter to scope ViewModel lifetime to any level of the Compose hierarchy.

“A Gradle Plugin for Deep Link Routing”: An open-source Gradle plugin that matches URL patterns to Navigation destinations at build time, generating type-safe deep link handlers instead of manual intent-filter XML + NavDeepLinkBuilder combinations.

“Compose Recomposition — Budget-Based Monitoring with Zero Config”: An overview of a new debug library that tracks recomposition rates and flags composables exceeding platform-appropriate budgets (3/s for screens, 120/s for animations). The library is debug-only and uses Compose’s RecompositionTracker API.

🛠️ Releases & Version Updates

Room 3.0.0-alpha01: The first alpha of the multiplatform Room rewrite. Here’s what the migration looks like:

// Room 3.0 — pure KSP, no Java codegen
// build.gradle.kts
plugins {
    id("com.google.devtools.ksp")
}
dependencies {
    implementation("androidx.room:room-runtime:3.0.0-alpha01")
    implementation("androidx.room:room-ktx:3.0.0-alpha01")
    ksp("androidx.room:room-compiler:3.0.0-alpha01")
}

// All DAO methods must be suspend or Flow — no blocking operations
@Dao
interface UserDao {
    @Query("SELECT * FROM users WHERE id = :id")
    suspend fun getUserById(id: String): User?

    @Query("SELECT * FROM users")
    fun observeAllUsers(): Flow<List<User>>

    @Insert(onConflict = OnConflictStrategy.REPLACE)
    suspend fun insertUser(user: User)

    @Transaction
    suspend fun updateUserWithHistory(user: User, history: UserHistory) {
        insertUser(user)
        insertHistory(history)
    }
}

Room 3.0 — KMP Targets:

// shared/build.gradle.kts — Room 3.0 KMP configuration
kotlin {
    androidTarget()
    iosArm64()
    iosSimulatorArm64()
    macosArm64()

    sourceSets {
        commonMain.dependencies {
            implementation("androidx.room:room-runtime:3.0.0-alpha01")
        }
        androidMain.dependencies {
            implementation("androidx.sqlite:sqlite-android:2.5.0")
        }
        iosMain.dependencies {
            implementation("androidx.sqlite:sqlite-bundled:2.5.0")
        }
    }
}

Hilt 2.56: Adds support for @HiltViewModel with Lifecycle 2.9’s new scoped ViewModel APIs. ViewModels scoped to Compose subtrees can now receive Hilt injection.

Navigation 3.0.0-alpha07: Adds NavHost support for predictiveBack — the gesture-based back navigation animation introduced in Android 14 now works with Navigation 3’s back stack model.

Lottie Compose 6.6.0: Adds LottieAnimation support for Compose Multiplatform (Android + iOS + Desktop). The animation files are shared; rendering uses platform-native compositing.

Room 3.0 — What Breaks

Key breaking changes to be aware of:

// ❌ Room 3.0 — these patterns no longer compile

// Blocking DAO method — not allowed
@Query("SELECT * FROM users")
fun getAllUsersBlocking(): List<User> // Compile error: must be suspend or Flow

// LiveData return — removed
@Query("SELECT * FROM users")
fun observeUsers(): LiveData<List<User>> // Compile error: LiveData not supported

// Java annotation processing — no longer works
// kapt("androidx.room:room-compiler:3.0.0-alpha01") // Use ksp() instead

// ✅ Room 3.0 — correct patterns
@Query("SELECT * FROM users")
suspend fun getAllUsers(): List<User> // OK

@Query("SELECT * FROM users")
fun observeUsers(): Flow<List<User>> // OK

📱 Android Platform Updates

Android 17 — Platform Stability Approaching

With Beta 2 out, Google is targeting API lock for Beta 3 in late March. Now is the time to:

1. Update compileSdk to 37 in a test branch
2. Run your full test suite
3. Verify background audio playback behavior (new restrictions in Android 17)
4. Check any Network permission usage for ACCESS_LOCAL_NETWORK impacts

Wear Compose Remote — Cross-Device Compose

The new wear-compose-remote artifact (from the Jetpack March wave) allows rendering Compose UI on a paired Wear OS watch from the phone companion app. The watch acts as a display surface — the Compose tree runs on the phone:

// Phone app — renders UI on the paired watch
val wearRemote = WearComposeRemote.getInstance(context)

wearRemote.setContent {
    // This composable renders on the watch
    WearTheme {
        TimeDisplay(currentTime = remember { mutableStateOf(LocalTime.now()) })
    }
}

🌟 Community Spotlight

Tracey — Flight Recorder for Compose: Open-source KMP library that records gestures, screen views, breadcrumbs, and crashes for later replay. Think Bugsnag’s session replay but built entirely on Compose’s accessibility tree and gesture tracking. Works on Android, iOS, and Desktop. The replay viewer runs in the browser.

Compose LazyLayout Adaptive Grid: A library providing a LazyAdaptiveGrid composable that automatically adjusts column count based on available width. Less opinionated than LazyVerticalGrid(GridCells.Adaptive()) — handles non-uniform item sizes cleanly.

💡 Quick Tip of the Week

Use @Transaction in Room for operations that span multiple DAO calls:

@Dao
interface OrderDao {
    // ❌ Not atomic — if insertItems fails, the order header was still inserted
    suspend fun createOrder(order: Order, items: List<OrderItem>) {
        insertOrder(order)   // Call 1
        insertItems(items)   // Call 2 — could fail
    }

    // ✅ Wrapped in @Transaction — all-or-nothing
    @Transaction
    suspend fun createOrderAtomic(order: Order, items: List<OrderItem>) {
        insertOrder(order)
        insertItems(items)
    }

    @Insert suspend fun insertOrder(order: Order)
    @Insert suspend fun insertItems(items: List<OrderItem>)
}

@Transaction wraps the entire function body in a database transaction. If any operation throws, the entire transaction is rolled back. This is one of the most commonly missed Room patterns in real apps.

🧠 Did You Know?

Room’s @Relation annotation fetches related entities in a SEPARATE query, not a SQL JOIN. This means a @Transaction is required to get a consistent snapshot when fetching parent + related entities:

data class UserWithOrders(
    @Embedded val user: User,
    @Relation(
        parentColumn = "id",
        entityColumn = "userId"
    )
    val orders: List<Order>
)

@Dao
interface UserDao {
    // ❌ Without @Transaction: user and orders could be from different DB states
    @Query("SELECT * FROM users")
    fun getUsersWithOrders(): Flow<List<UserWithOrders>>

    // ✅ With @Transaction: consistent snapshot guaranteed
    @Transaction
    @Query("SELECT * FROM users")
    fun getUsersWithOrders(): Flow<List<UserWithOrders>>
}

Room will actually warn you (not error) if you use @Relation without @Transaction. The warning is easy to miss, but the consequence is real: in high-write apps, you can read a user that no longer has the orders that were present a millisecond earlier.

❓ Weekly Quiz

Q1: What are the two breaking changes in Room 3.0 that affect the most existing codebases?

A: (1) All DAO methods must be suspend or return Flow — blocking Room operations are removed. (2) LiveData as a return type from DAO methods is no longer supported.

Q2: Why does Room’s @Relation require @Transaction for correct behavior?

A: @Relation fetches related entities in a separate query from the parent entity query. Without @Transaction, the two queries could read from different database states if a write occurs between them. @Transaction ensures both queries see a consistent snapshot.

Q3: What Kotlin tooling change does Room 3.0 require, compared to Room 2.x?

A: Room 3.0 requires KSP (Kotlin Symbol Processing) instead of KAPT. The ksp() dependency declaration replaces kapt() in build.gradle.kts. Java annotation processing is no longer supported.

That’s a wrap for this week! See you in the next issue. 🐝

📚 Articles & References

Google — “Android 17 Beta 2: EyeDropper, Contacts Picker, Cross-Device Handoff”: Beta 2 introduces the full complement of new Android 17 user-facing APIs. The standout: EyeDropper API for system-level color picking (no screen capture permission required), ACTION_PICK_CONTACTS for session-based contact data access, and cross-device app handoff via CompanionDeviceManager. Platform stability (API lock) is targeted for late March with Beta 3.

JetBrains — “KotlinConf ‘26 Full Agenda Published”: The KotlinConf ‘26 schedule is live. June 3 is workshop day, June 4 is the main conference in Copenhagen. Keynote topics include Kotlin 2.3 improvements, Kotlin Multiplatform production stories, and the future of Kotlin/Wasm. Featured speakers: Márton Braun (JetBrains), Arkadii Ivanov (xAI), and Roman Elizarov.

Dave Leeds — “Flows for Sequence Developers”: A gentle introduction to Kotlin Flows using sequences as the mental model. Sequences are synchronous and lazy; Flows are asynchronous and lazy. The transformation APIs (map, filter, flatMap) are nearly identical. This framing removes a lot of the intimidation factor for developers coming from Sequence-heavy codebases.

“Android 17 Beta 2 — What Every Developer Needs to Test”: A community checklist for Beta 2 compatibility testing. Priority items: local network access blocks (requires ACCESS_LOCAL_NETWORK), audio focus behavior changes, and the new resizability requirements for apps targeting API 37.

“Dependency Guard by Dropbox — Preventing Accidental Dependency Bumps in CI”: An updated tutorial on using Dropbox’s Dependency Guard plugin to prevent accidental transitive dependency changes from slipping into production. Particularly useful for apps with strict security or compliance requirements.

“Kotlin Flows in Practice: Cold vs. Hot, StateFlow vs. SharedFlow”: A practical guide to choosing between Flow, StateFlow, and SharedFlow. The decision tree: use Flow for one-shot data operations; StateFlow for UI state that should replay the last value; SharedFlow for events that should be received by multiple collectors but not replayed.

🛠️ Releases & Version Updates

Android 17 Beta 2: Available on Pixel 6+ devices and emulator images. Final API surface is expected to lock with Beta 3 at platform stability. Apps can now target compileSdk = 37 for beta testing.

Compose BOM 2026.03.00-alpha01: Includes Compose 1.9.0-alpha01 with the new BasicHtmlText composable for rendering basic HTML (bold, italic, links) without a full WebView.

Ktor 3.1.1: Patches a memory leak in HttpClient when the response body is discarded without reading. Affects long-running apps that make many requests to endpoints that return large bodies (file downloads, large JSON responses).

SQLDelight 2.1.0: Adds incremental compilation support for KSP. Previously, any schema change caused a full regeneration of all generated Kotlin types. With 2.1.0, only affected tables are regenerated, cutting incremental build times by 50–70% for large schemas.

Gradle 9.3: Compatibility verified with Kotlin 2.3.x (coming next week). Key change: buildSrc no longer inherits settings from the root project’s settings.gradle.kts. If you use buildSrc with shared plugin declarations, migration is needed.

Android 17 Beta 2 — EyeDropper API

The new system-level color picker requires no permissions:

@Composable
fun ColorPickerButton(onColorSelected: (Color) -> Unit) {
    val context = LocalContext.current
    val eyeDropperLauncher = rememberLauncherForActivityResult(
        contract = ActivityResultContracts.StartActivityForResult()
    ) { result ->
        if (result.resultCode == Activity.RESULT_OK) {
            val colorInt = result.data?.getIntExtra(Intent.EXTRA_COLOR, Color.Black.toArgb())
            colorInt?.let { onColorSelected(Color(it)) }
        }
    }

    Button(onClick = {
        val intent = Intent(Intent.ACTION_OPEN_EYE_DROPPER)
        eyeDropperLauncher.launch(intent)
    }) {
        Icon(Icons.Default.Colorize, contentDescription = "Pick color")
        Spacer(Modifier.width(8.dp))
        Text("Pick Color from Screen")
    }
}

Kotlin Flows — Cold vs. Hot

// Cold Flow — producer code runs for each collector independently
val coldFlow: Flow<Int> = flow {
    println("Starting emission") // runs ONCE per collector
    (1..5).forEach { emit(it) }
}

// Hot StateFlow — single producer, all collectors see same stream
val hotFlow: StateFlow<Int> = MutableStateFlow(0)

// Cold flows: good for one-shot data loading
// Hot flows: good for shared UI state, event buses

// Converting cold to hot — use shareIn
val sharedColdFlow = coldFlow
    .shareIn(
        scope = viewModelScope,
        started = SharingStarted.WhileSubscribed(5000),
        replay = 1
    )

📱 Android Platform Updates

Android 17 — Bubbles Windowing Mode

The Bubbles API (distinct from messaging bubbles) allows apps to appear as floating bubbles that users can drag, minimize, and expand. This is a windowing mode, similar to Picture-in-Picture but more general:

// Opt into bubbles support in your manifest
// <activity
//     android:name=".BubbleActivity"
//     android:allowEmbedded="true"
//     android:documentLaunchMode="always"
//     android:resizeableActivity="true" />

// Create a bubble notification
val bubbleIntent = PendingIntent.getActivity(
    context, 0,
    Intent(context, BubbleActivity::class.java),
    PendingIntent.FLAG_MUTABLE
)

val bubbleMetadata = NotificationCompat.BubbleMetadata.Builder(
    bubbleIntent,
    IconCompat.createWithAdaptiveBitmap(bubbleBitmap)
)
    .setDesiredHeight(600)
    .setSuppressNotification(true)
    .setAutoExpandBubble(false)
    .build()

Advanced UWB Ranging — Indoor Navigation

Android 17 adds UWB DL-TDOA support for privacy-preserving indoor navigation. The key: the device can navigate via UWB anchors without the anchors being able to track the device’s identity:

// UWB ranging with Android 17's DL-TDOA support
val uwbManager = context.getSystemService(UwbManager::class.java)
val controllerSession = uwbManager.controllerSessionScope()

// Build ranging parameters
val rangingParams = RangingParameters.Builder()
    .setUwbConfigType(RangingParameters.UWB_CONFIG_ID_3)
    .setSessionId(Random.nextInt())
    .setRangingUpdateRate(RangingParameters.RANGING_UPDATE_RATE_FREQUENT)
    .build()

🎤 Conferences & Videos

KotlinConf ‘26 — June 4, Copenhagen: The full agenda is live. Workshop day is June 3. Grab the community ticket (179€ + VAT) before they sell out. The festival vibe format from previous years continues — outdoor stages, live demos, and late evening sessions.

“Flows in Android Development” (Android Developers YouTube): Dave Leeds’ talk translated into a YouTube walkthrough, covering the full Flow API surface with real Android examples: database observation, network polling, and combining multiple data sources with combine.

🧰 Tool of the Week

Dependency Guard (Dropbox): Catches accidental dependency changes in CI. Zero configuration to start:

// build.gradle.kts (root)
plugins {
    id("com.dropbox.dependency-guard") version "0.5.0"
}

dependencyGuard {
    configuration("releaseRuntimeClasspath") {
        tree = true   // include transitive deps in baseline
        modules = true
    }
}

# Generate baseline — commit this file
./gradlew dependencyGuard

# Check for changes in CI — fails if any dependency changed
./gradlew dependencyGuardCheck

💡 Quick Tip of the Week

Use flowOf and emptyFlow for static or absent data in tests and previews:

// In tests — no need for a real repository
class UserViewModelTest {
    @Test
    fun `shows user name when loaded`() = runTest {
        val fakeRepo = object : UserRepository {
            override fun observeUser(): Flow<User?> =
                flowOf(User(id = "1", name = "Mukul"))
        }
        val vm = UserViewModel(fakeRepo)
        vm.uiState.test {
            val state = awaitItem()
            assertEquals("Mukul", (state as UserState.Success).user.name)
        }
    }
}

// In Compose Previews — use empty flow for no-data states
@Preview
@Composable
fun UserCardPreview() {
    val previewVm = object : UserViewModel(
        object : UserRepository {
            override fun observeUser() = emptyFlow<User?>()
        }
    ) {}
    UserCard(previewVm)
}

🧠 Did You Know?

SharedFlow with replay = 0 is a true event bus — but it has a subtle flaw that replay = 1 doesn’t. If no collector is active when an event is emitted, the event is lost permanently. This is intentional for UI events (you don’t want to re-process a button click after returning from the back stack), but it catches developers off guard:

class EventViewModel : ViewModel() {
    // replay = 0: events not collected are LOST
    private val _events = MutableSharedFlow<UiEvent>()
    val events = _events.asSharedFlow()

    // replay = 1: last event replayed to new collector
    private val _state = MutableStateFlow<UiState>(UiState.Loading)
    val state = _state.asStateFlow()

    fun triggerNavigation(destination: String) {
        viewModelScope.launch {
            _events.emit(UiEvent.Navigate(destination)) // lost if no collector active
        }
    }
}

// Collect events only while the lifecycle is STARTED
// This prevents collecting stale navigation events from before the screen was visible
LaunchedEffect(Unit) {
    viewModel.events.collectLatest { event ->
        when (event) {
            is UiEvent.Navigate -> navController.navigate(event.destination)
        }
    }
}

The modern recommendation: use Channel with Channel.BUFFERED for one-time events, and SharedFlow(replay=0) for fire-and-forget broadcasts to many collectors simultaneously.

❓ Weekly Quiz

Q1: What is the Android 17 EyeDropper API used for, and what permission is required?

A: The EyeDropper API allows apps to request a color from any pixel on the display. No special permission is required — the system handles the screen capture internally and returns only the selected color to the requesting app.

Q2: What is the key difference between SharedFlow(replay=0) and StateFlow for event handling?

A: SharedFlow(replay=0) is a “hot” flow where events emitted when no collector is active are lost. StateFlow always has a value and replays the last value to new collectors. Use SharedFlow(replay=0) for UI events (navigate, show snackbar), StateFlow for persistent UI state.

Q3: What changed in SQLDelight 2.1.0 that improves incremental build performance?

A: SQLDelight 2.1.0 adds incremental compilation support for KSP — only the Kotlin types for modified tables are regenerated on schema changes, instead of regenerating all types. This typically cuts incremental build times by 50–70% for large database schemas.

That’s a wrap for this week! See you in the next issue. 🐝

📚 Articles & References

Jesse Wilson — “Oppose Google’s Developer Verification Mandate”: Jesse raises the alarm about Google’s proposed 2026 developer verification requirement — a paid, identity-verified registration system that would be required to distribute apps outside the Play Store. His argument: this is anti-competitive, would prevent developers in many regions from building Android apps, and undermines Android’s openness as a platform. The post generated significant community debate.

Zac Sweers — “The Real DI Tradeoff: Compile-Time vs. Runtime”: Zac reframes the dependency injection debate not as “Dagger vs. Koin vs. Hilt” but as a fundamental question: compile-time graph construction versus runtime service lookup. Compile-time (Dagger/Hilt/Metro) catches errors at build time, produces optimized code, but has higher build cost. Runtime (Koin, Kodein) trades correctness guarantees for faster incremental builds and simpler setup. Neither is universally better — but the tradeoffs are often misunderstood.

Andrius Semionovas & Heorhii Popov — “Migrating a Large Codebase from Dagger/Anvil to Metro”: A case study of migrating an enterprise Android app from Dagger + Anvil to Metro (JetBrains’ newer DI framework for Kotlin). The result: K2 compiler compatibility unlocked, incremental build times improved by ~40%, and the codebase dropped significant amounts of boilerplate. The migration wasn’t painless — particularly around component scoping and multi-module setups.

“Keep Android Open: What the 2026 Verification Mandate Would Mean”: A detailed breakdown of the technical and geopolitical implications of mandatory developer identity verification for Android app distribution. Worth reading regardless of your stance on the policy question.

“Five Common Compose Performance Anti-Patterns”: Philipp Lackner identifies five patterns that reliably cause performance problems in Compose apps: (1) reading mutable state inside measure phases, (2) using State in draw callbacks, (3) unstable lambda captures in LazyColumn, (4) excessive use of derivedStateOf with no key logic, and (5) painting overdraw with opaque backgrounds on transparent containers.

“Building a Modular Android Debug Toolkit with Compose”: A walkthrough of building a production-safe debugging overlay using Compose, with a clean architecture that compiles to a no-op in release builds. The trick: an expect/actual declaration where the debug implementation shows the overlay and the release implementation is empty.

🛠️ Releases & Version Updates

Kotlin 2.2.0-Beta2: JetBrains continues the Kotlin 2.2 beta cycle. This build improves K2 compiler diagnostics — error messages now include the full resolution path when an overload can’t be resolved, making “None of the following candidates is applicable” errors dramatically more useful.

Metro 1.0.0-beta01 (JetBrains DI): Metro is JetBrains’ Kotlin-first DI framework — think Dagger with K2 support from the ground up. The beta adds Anvil-compatible component scoping syntax:

// Metro — Kotlin-first DI with K2 support
@ContributesTo(AppScope::class)
@Module
interface UserModule {
    @Binds
    fun bindUserRepository(impl: UserRepositoryImpl): UserRepository
}

@ContributesBinding(AppScope::class)
class UserRepositoryImpl @Inject constructor(
    private val api: UserApi,
    private val db: UserDatabase
) : UserRepository

// Component — generated at compile time, no reflection
@Component(scope = AppScope::class)
interface AppComponent {
    val userRepository: UserRepository
    val userViewModel: UserViewModel
}

WorkManager 2.10.1: Fixes a regression where PeriodicWorkRequest could be delayed indefinitely on devices with aggressive Doze mode when no constraint network was required.

AndroidX DataStore 1.1.2: Improves migration from SharedPreferences to DataStore with a new SharedPreferencesMigration that handles Long values correctly (a regression introduced in 1.1.0).

Metro vs. Dagger — The Build Time Story

The key benchmark from the Andrius/Heorhii migration:

// Dagger/Anvil (K1 compiler):
// Clean build: ~4.2 min
// Incremental build (single file change): ~1.8 min
// K2 support: partial (via kapt compatibility mode)

// Metro (K2 compiler):
// Clean build: ~3.8 min  (9% faster)
// Incremental build (single file change): ~1.1 min (39% faster)
// K2 support: native

The incremental build improvement is where Metro shines — it leverages the K2 compiler’s better incremental compilation support.

📱 Android Platform Updates

Android 17 — SMS OTP Protection Hardening

One behavior change that will affect authentication flows: Android 17 extends OTP SMS protection. For apps targeting API 37, SMS messages containing OTP codes are delayed by 3 hours for most apps, preventing OTP hijacking:

// The RIGHT way to handle SMS OTPs — works on all Android versions
// Step 1: Generate app-specific hash
// Step 2: Include hash in SMS message from your server
// Step 3: Use SMS Retriever API — exempt from the 3-hour delay

class SmsRetrieverReceiver : BroadcastReceiver() {
    override fun onReceive(context: Context, intent: Intent) {
        if (SmsRetriever.SMS_RETRIEVED_ACTION == intent.action) {
            val extras = intent.extras
            val status = extras?.get(SmsRetriever.EXTRA_STATUS) as? Status

            if (status?.statusCode == CommonStatusCodes.SUCCESS) {
                val message = extras.get(SmsRetriever.EXTRA_SMS_MESSAGE) as? String
                val otp = extractOtpFromMessage(message)
                onOtpReceived(otp)
            }
        }
    }
}

// Register and start retriever
val client = SmsRetriever.getClient(context)
val task = client.startSmsRetriever()

Apps that use READ_SMS for OTP extraction should migrate to SMS Retriever or SMS User Consent APIs before Android 17 ships.

Background Audio Changes (Android 17 Preview)

Android 17 will restrict background audio interactions. Apps in the background that attempt to request audio focus or adjust volume will require FOREGROUND_SERVICE_MEDIA_PLAYBACK or active media session ownership. Start testing your audio playback flows now.

⚠️ Deprecation & Migration Alerts

kapt Soft Deprecation in AGP 9.x: AGP 9.0 (expected mid-2026) will require explicit opt-in to use KAPT. All annotation processors should be migrated to KSP. Key libraries with KSP support: Room (2.6+), Hilt (2.49+), Glide (4.16+), Moshi (1.15+). Libraries that don’t yet support KSP need kaptToKspMapping workaround in AGP 8.x.

SharedPreferences — Performance Deprecation Warning: SharedPreferences continues to work but the documentation now explicitly states that DataStore is the recommended alternative. The apply() vs commit() confusion and main-thread blocking risks are the primary motivations.

🌟 Community Spotlight

“Android Verification Push Back Movement”: The Android developer community organized quickly around Jesse Wilson’s post, with hundreds of developers filing feedback on the Android issue tracker. As of this writing, Google has not responded publicly, but the volume of developer concern is significant.

💡 Quick Tip of the Week

Use derivedStateOf to compute derived state only when dependencies change — not on every recomposition:

// ❌ Recomputes on every recomposition, even if items didn't change
@Composable
fun ShoppingCart(items: List<CartItem>) {
    val total = items.sumOf { it.price * it.quantity } // recalculates every time
    Text("Total: $$total")
}

// ✅ Only recomputes when items reference changes
@Composable
fun ShoppingCart(items: List<CartItem>) {
    val total by remember(items) {
        derivedStateOf { items.sumOf { it.price * it.quantity } }
    }
    Text("Total: $$total")
}

derivedStateOf is particularly valuable when the derived computation is expensive (sorting, filtering, aggregation) and the source list changes frequently via mutableStateListOf.

🧠 Did You Know?

Kotlin’s inline functions have a compile-time cost that most developers underestimate. Every call site of an inline function causes the function’s bytecode to be copied to that call site. This is great for lambdas (eliminates object allocation) but terrible for large functions called in many places:

// ❌ Inline a large function called in 100 places = 100x bytecode copies
inline fun <T> processWithRetry(action: () -> T): T {
    var attempts = 0
    while (attempts < 3) {
        try {
            return action()
        } catch (e: IOException) {
            attempts++
            delay(1000L * attempts) // Bytecode for all of this copied to each call site
        }
    }
    throw IOException("Failed after 3 attempts")
}

// ✅ Only inline the lambda, keep the rest as a regular function
fun <T> processWithRetry(action: suspend () -> T): T {
    // Regular function body — called at one location
    return retryLogic(action)
}

// Or make it suspend and non-inline — coroutines handle the lambda efficiently
suspend fun <T> retryWithBackoff(action: suspend () -> T): T { ... }

The rule of thumb: inline when your function takes a lambda parameter and the function body is small (5–15 lines). For larger functions or functions called from many places, inline is often a net negative.

❓ Weekly Quiz

Q1: What is the primary build-time advantage of Metro over Dagger when both are used with the K2 compiler?

A: Metro was designed for K2 from the ground up, enabling better incremental compilation support. The case study in this issue showed ~39% faster incremental builds compared to Dagger/Anvil with K2 compatibility mode.

Q2: What happens to SMS OTP messages for apps targeting Android 17 that don’t use SMS Retriever format?

A: They are delayed by 3 hours before becoming accessible via the SMS provider or SMS_RECEIVED_ACTION. Apps should migrate to SMS Retriever or SMS User Consent APIs to maintain immediate OTP access.

Q3: When is derivedStateOf preferable to a plain remember(key) block in Compose?

A: derivedStateOf is preferable when the derived value is read from multiple state objects that update at different rates. derivedStateOf only re-executes when the actual result of the computation would change, whereas remember(key) re-executes whenever any listed key changes reference.

That’s a wrap for this week! See you in the next issue. 🐝

📚 Articles & References

Google — “Android 17 Beta 1: Adaptability, Media, and Connectivity”: The first beta of Android 17 drops with a focus on large screen adaptability, improved companion device tooling, and media improvements. The headline API additions: cross-device app handoff, advanced UWB ranging for indoor navigation, and the new ACCESS_LOCAL_NETWORK runtime permission. Google confirmed the annual release cadence continues, with platform stability targeted for late March.

Costa Fotiadis — “Replacing ViewModel with Compose’s Retain API”: An exploration of rememberRetained() (from Slack’s Circuit library) and the new built-in retainedStateHolder() in Compose — APIs that let you retain state through recomposition and configuration changes without the overhead of a full ViewModel. The key difference: retained objects are scoped to the composition tree, not the Activity lifecycle.

Arman Chatikyan — “Remote Compose: Server-Driven UI Without WebViews”: Google’s Remote Compose enables defining and rendering Android UI from a server using a serialized Compose description format. No WebViews, no custom JSON schemas — the server sends a composable layout description, and the client renders it using real Compose. The article shows the current API limitations and where it’s currently viable.

“Jetpack Stack on KMP: A Complete Migration Guide”: Thomas Künneth expanded his earlier article into a full guide with migration checklists for ViewModel → circuit/molecule, Room → SQLDelight, DataStore → multiplatform-settings, and Navigation → decompose or circuit. The guide includes an honest assessment of KMP readiness for production apps.

“Android 17 Beta 1 Feature Deep Dive”: A community deep-dive into the Android 17 Beta 1 release notes. Highlights: the Bubbles windowing API (for app bubbles, not messaging), the ACTION_PICK_CONTACTS privacy-preserving contacts picker, and the new time zone offset broadcast ACTION_TIMEZONE_OFFSET_CHANGED.

“Compose retain vs ViewModel: When to Use Each”: A pragmatic comparison. TL;DR: use ViewModel for data that outlives configuration changes in non-Compose architectures or when you need SavedStateHandle / dependency injection. Use retain APIs for Compose-scoped state that should survive recomposition but doesn’t need to persist across process death.

🛠️ Releases & Version Updates

Android 17 Beta 1: Available on Pixel 6+ devices and the Android Emulator. This beta introduces new APIs but does not yet lock the final API surface — use it for early compatibility testing, not final targetSdk bumps.

Compose BOM 2026.02.00: Stable release with Compose UI 1.8.0, Material3 1.4.0 stable, and Compose Animation 1.8.0. The AnimatedContent API receives a new SizeTransform that handles layout bounds changes during transitions.

// Compose 1.8.0 — AnimatedContent with SizeTransform
AnimatedContent(
    targetState = isExpanded,
    transitionSpec = {
        fadeIn(animationSpec = tween(300)) togetherWith
            fadeOut(animationSpec = tween(300)) using
            SizeTransform { initialSize, targetSize ->
                if (targetState) {
                    keyframes {
                        IntSize(targetSize.width, initialSize.height) at 150
                        durationMillis = 300
                    }
                } else {
                    keyframes {
                        IntSize(initialSize.width, targetSize.height) at 150
                        durationMillis = 300
                    }
                }
            }
    }
) { expanded ->
    if (expanded) ExpandedContent() else CollapsedContent()
}

Circuit 0.25.0 (Slack): The Compose-first architecture library adds rememberRetained() support for arbitrary objects and improves the Presenter lifecycle integration with Activity result handling.

Accompanist 0.37.0 — Final Release: This is explicitly the last Accompanist release. All remaining useful APIs (Pager, FlowLayout) have been migrated to Compose Foundation. The library will not receive further updates.

Android 17 Beta 1 — Cross-Device Handoff API

The Handoff API lets your app specify state that can be resumed on another nearby Android device:

class MainActivity : ComponentActivity() {
    override fun onResume() {
        super.onResume()
        // Opt into cross-device handoff
        setHandoffEnabled(true)
    }

    // Provide the state to hand off — called by the system before suggesting handoff
    override fun onProvideHandoffUserActivityState(extras: Bundle) {
        extras.putString("current_screen", currentScreen)
        extras.putString("scroll_position", scrollPosition.toString())
    }

    // Receive handoff from another device
    override fun onNewIntent(intent: Intent) {
        super.onNewIntent(intent)
        if (intent.hasExtra("handoff_extras")) {
            val screen = intent.getStringExtra("current_screen")
            navigateTo(screen)
        }
    }
}

📱 Android Platform Updates

Android 17 — New Privacy APIs

Privacy-Preserving Contacts Picker: Instead of requesting READ_CONTACTS, apps can now use ACTION_PICK_CONTACTS with explicit data field requests. The user grants temporary session-based access only to the fields they choose to share:

val contactPicker = rememberLauncherForActivityResult(
    contract = ActivityResultContracts.StartActivityForResult()
) { result ->
    if (result.resultCode == RESULT_OK) {
        val contactUri = result.data?.data ?: return@rememberLauncherForActivityResult
        processContactData(contactUri)
    }
}

val intent = Intent(ContactsPickerSessionContract.ACTION_PICK_CONTACTS).apply {
    putStringArrayListExtra(
        EXTRA_PICK_CONTACTS_REQUESTED_DATA_FIELDS,
        arrayListOf(Email.CONTENT_ITEM_TYPE, Phone.CONTENT_ITEM_TYPE)
    )
    putExtra(EXTRA_ALLOW_MULTIPLE, true)
}
contactPicker.launch(intent)

Local Network Access Permission: Apps targeting Android 17 must declare ACCESS_LOCAL_NETWORK to discover devices on the local network (smart home, casting receivers). Apps that have previously been granted NEARBY_DEVICES group permissions won’t be prompted again.

🎤 Conferences & Videos

Android Developers YouTube — “What’s New in Android 17 Beta 1”: The official walkthrough of Beta 1 APIs. The cross-device handoff demo is particularly compelling — you can see a user switching from phone to tablet and picking up exactly where they left off.

“Remote Compose at Google”: A talk from Android engineers explaining the motivation behind Remote Compose. The primary use case: Wear OS watch faces served from a phone without requiring the watch app to be updated. Secondary: server-driven home screen widgets.

🌟 Community Spotlight

Circuit 0.25.0 rememberRetained(): Slack’s open-source architecture library continues to be ahead of the curve. rememberRetained() is the prototype for what will eventually land in core Compose — state that survives configuration changes without ViewModel overhead. Worth following the Circuit project closely.

💡 Quick Tip of the Week

Use rememberUpdatedState to safely capture the latest lambda in long-lived effects:

// ❌ Bug: onTimeout captures the initial lambda, never updates
@Composable
fun TimeoutEffect(onTimeout: () -> Unit) {
    LaunchedEffect(Unit) {
        delay(5000)
        onTimeout() // Always calls the FIRST onTimeout — even if it changed
    }
}

// ✅ Correct: rememberUpdatedState always reads the latest value
@Composable
fun TimeoutEffect(onTimeout: () -> Unit) {
    val currentOnTimeout by rememberUpdatedState(onTimeout)
    LaunchedEffect(Unit) {
        delay(5000)
        currentOnTimeout() // Always calls the CURRENT onTimeout
    }
}

This pattern is essential in LaunchedEffect(Unit) — effects that run once but need to call the latest version of a callback. The effect doesn’t restart, but the lambda stays fresh.

🧠 Did You Know?

Accompanist was born because Google’s Compose API surface was still evolving too quickly for AndroidX to ship stable implementations. Libraries like SwipeRefresh, Pager, and SystemUIController in Accompanist were explicit bridge APIs — they existed to fill gaps that Google planned to fill in the official libraries. Now that HorizontalPager is in Compose Foundation and enableEdgeToEdge() handles system bar coloring, Accompanist has fulfilled its purpose. The final 0.37.0 release marks the end of one of the most successful “community bridge” libraries in the Android ecosystem.

// Old Accompanist pattern (now removed)
// val systemUiController = rememberSystemUiController()
// systemUiController.setStatusBarColor(MaterialTheme.colorScheme.primary)

// New way — single call in onCreate, zero compose dependency
class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        enableEdgeToEdge() // handles everything
        super.onCreate(savedInstanceState)
        setContent { AppTheme { AppContent() } }
    }
}

❓ Weekly Quiz

Q1: What is the key difference between the ACCESS_LOCAL_NETWORK permission introduced in Android 17 and older network access?

A: Previously, apps could freely access local network devices (LAN) without any permission. Android 17 requires declaring ACCESS_LOCAL_NETWORK at runtime to discover or connect to LAN devices. Apps that already hold other NEARBY_DEVICES group permissions won’t be re-prompted.

Q2: What specific advantage does rememberRetained() have over ViewModel in a Compose-first architecture?

A: rememberRetained() is scoped to the composition tree, not to the Activity/Fragment lifecycle. This means you can have multiple independent retained state holders at different levels of the UI hierarchy without requiring a ViewModelStoreOwner for each one.

Q3: What did Accompanist’s final 0.37.0 release signal about the state of Compose’s official API surface?

A: That Compose’s core APIs are now mature enough to handle everything Accompanist was bridging. All key Accompanist components (Pager, FlowLayout, edge-to-edge) have landed in official AndroidX libraries, making the bridge library unnecessary.

That’s a wrap for this week! See you in the next issue. 🐝

📚 Articles & References

Arnaud Giuliani — “Koin Compiler Plugin: Auto-wiring Kotlin DI”: The official announcement of the Koin Compiler Plugin for Koin 4.1. The plugin works as a Kotlin Compiler Plugin (not just a Gradle plugin) — it scans your annotated classes at compile time, builds the dependency graph, and generates the Koin module declarations. The result: zero runtime reflection, earlier error detection, and ~30% fewer lines of DI boilerplate.

Marcello Galhardo — “Scoping ViewModels to Compose UI Hierarchy with New Lifecycle APIs”: New Lifecycle ViewModel APIs arriving in the 2.9.x series allow scoping ViewModels to arbitrary Compose UI subtrees, not just navigation destinations or Activities. This enables component-level state survival without global singletons or nav graph hacks. The article shows the full API surface with before/after comparisons.

“Walk Through an LLM Pipeline: Tokenization to Inference”: Not Android-specific, but essential reading if you’re integrating on-device AI. The article walks through tokenization, embeddings, attention, and inference in plain language with diagrams. Understanding this pipeline lets you make informed decisions about model size, quantization, and caching strategies for Android.

Stevdza-San — “Koin Compiler Plugin in Practice”: A practical walkthrough building a feature module with the Koin Compiler Plugin from scratch. Covers auto-detect constructor injection, the @Module and @ComponentScan annotations, and how the plugin integrates with existing manually-declared Koin modules.

“Retrofit vs OkHttp: What Android Developers Actually Need to Know”: Amit Shekhar’s comparative guide to Retrofit and OkHttp, explained from the perspective of what each one is actually for. The short answer: OkHttp is the HTTP client, Retrofit is the type-safe API layer on top. You almost always want both, and the article explains when and why to customize each independently.

Peter Friese — “Porting a To-Do App from iOS to Android Using AI Agents”: Peter and Marina Coelho used AI coding agents (Antigravity and Stitch) to port their SwiftUI “Make It So” app to Compose. The honest assessment: AI handles boilerplate and API mapping well but struggles with architectural decisions and Compose-specific idioms like remember and state hoisting.

🛠️ Releases & Version Updates

Koin 4.1.0-alpha01 with Compiler Plugin: The alpha release of Koin 4.1 with the new compiler plugin. Here’s the full setup:

// build.gradle.kts
plugins {
    id("com.google.devtools.ksp") version "2.1.10-1.0.30"
}

dependencies {
    implementation("io.insert-koin:koin-android:4.1.0-alpha01")
    implementation("io.insert-koin:koin-androidx-compose:4.1.0-alpha01")
    ksp("io.insert-koin:koin-ksp-compiler:4.1.0-alpha01")
}

// Annotate your classes — the compiler generates the module
@Single
class UserRepositoryImpl(
    private val api: UserApi,
    private val prefs: UserPreferences
) : UserRepository

@KoinViewModel
class UserProfileViewModel(
    private val repository: UserRepository,
    savedStateHandle: SavedStateHandle
) : ViewModel()

// Your Application class — no manual module list needed
@KoinApplication
class App : Application() {
    override fun onCreate() {
        super.onCreate()
        startKoin {
            androidContext(this@App)
            // Compiler plugin generates UserModule.module automatically
        }
    }
}

Lifecycle 2.9.0-alpha03: The new ViewModelProvider.Factory extensions that allow ViewModel scoping to Compose subtrees:

// Scope a ViewModel to a specific part of the Compose tree
@Composable
fun ProductCard(productId: String) {
    // This ViewModel lives as long as ProductCard is in the composition
    // NOT tied to the nav back stack or Activity lifecycle
    val viewModel = viewModel<ProductCardViewModel>(
        key = productId,
        factory = ProductCardViewModel.Factory(productId)
    )
    ProductContent(viewModel.uiState)
}

Compose 1.8.0-beta03: In this build, LazyColumn and LazyGrid get smarter content padding handling that respects window insets automatically when contentPadding is set via WindowInsets.asPaddingValues():

LazyColumn(
    contentPadding = WindowInsets.navigationBars.asPaddingValues() +
        PaddingValues(horizontal = 16.dp, vertical = 8.dp)
) {
    items(items) { item ->
        ItemCard(item)
    }
}

AGP 8.9.0-alpha05: Adds support for Gradle configuration caching for all BuildConfig generation tasks, shaving 10–30 seconds off clean builds in large projects.

Koin Compiler Plugin — What It Actually Generates

The compiler plugin generates a KoinApplication extension at compile time. You can inspect the generated code in your build directory:

// Generated by Koin KSP compiler — UserModule.kt (build/generated/ksp/...)
val userModule = module {
    single<UserRepository> { UserRepositoryImpl(get(), get()) }
}
fun Application.userModule() = koin.loadModules(listOf(userModule))

📱 Android Platform Updates

Android 17 Development Preview — What’s Coming

While the first official beta is still a few weeks away, the Android 17 developer documentation has been updated with the planned API surface. Key areas to watch:

• Bubbles API — app windowing mode, not messaging bubbles
• Cross-device handoff — resuming app state on another Android device
• Local Network Access permission — new ACCESS_LOCAL_NETWORK runtime permission
• EyeDropper API — system-level color picker

Background Work — WorkManager 2.10.0

The latest WorkManager stable release adds PeriodicWorkRequest support for ExpeditedWork:

// WorkManager 2.10.0 — expedited periodic work
val periodicSyncRequest = PeriodicWorkRequestBuilder<SyncWorker>(
    repeatInterval = 15,
    repeatIntervalTimeUnit = TimeUnit.MINUTES
)
    .setExpedited(OutOfQuotaPolicy.RUN_AS_NON_EXPEDITED_WORK_REQUEST)
    .setConstraints(
        Constraints.Builder()
            .setRequiredNetworkType(NetworkType.CONNECTED)
            .build()
    )
    .build()

WorkManager.getInstance(context).enqueueUniquePeriodicWork(
    "periodic_sync",
    ExistingPeriodicWorkPolicy.UPDATE,
    periodicSyncRequest
)

🎤 Conferences & Videos

Android Developers YouTube — “Building with Gemini Nano on Android”: A hands-on video showing the ML Kit Prompt API for Gemini Nano integration. The demo builds a text summarization feature that runs entirely on-device on a Pixel 9 Pro. The cold-start latency is ~2 seconds; inference is ~50 tokens/second.

Fragmented Podcast — “AI Coding into Four Paradigms”: Kaushik Gopal and Iury Souza map AI-assisted coding into autocomplete, NL→code, test-driven generation, and agentic workflows. Worth listening to with your team to align on tooling expectations.

💡 Quick Tip of the Week

Use ViewModel.viewModelScope with SupervisorJob awareness for parallel operations:

class DashboardViewModel : ViewModel() {
    fun loadDashboard() {
        viewModelScope.launch {
            // These run in parallel — if one fails, the other continues
            // viewModelScope uses SupervisorJob internally
            val userDeferred = async { userRepository.getUser() }
            val feedDeferred = async { feedRepository.getFeed() }
            val notificationsDeferred = async { notifRepository.getCount() }

            // Collect results — errors propagate individually
            val user = runCatching { userDeferred.await() }.getOrNull()
            val feed = runCatching { feedDeferred.await() }.getOrElse { emptyList() }
            val notifCount = runCatching { notificationsDeferred.await() }.getOrDefault(0)

            _uiState.value = DashboardState(user, feed, notifCount)
        }
    }
}

viewModelScope uses a SupervisorJob — exceptions in one async block don’t cancel siblings. But you still need to handle them explicitly with runCatching or try/catch, otherwise they propagate to viewModelScope’s CoroutineExceptionHandler.

🧠 Did You Know?

The by viewModels() delegate in Compose creates the ViewModel in the nearest ViewModelStoreOwner — which might not be what you expect. In a Compose app using Navigation 3, each destination’s BackStackEntry is a ViewModelStoreOwner. So:

// In a NavHost destination composable:
@Composable
fun ProfileScreen() {
    // This ViewModel is scoped to the NavBackStackEntry — destroyed when you pop
    val vm: ProfileViewModel by viewModels()
}

// But if you call viewModel() outside a navigation context (e.g., in a top-level composable):
@Composable
fun ProfileScreen() {
    // This ViewModel is scoped to the Activity — survives navigation
    val vm: ProfileViewModel = viewModel()
}

The new Lifecycle 2.9.x APIs let you explicitly choose the ViewModelStoreOwner, which solves the “I want this ViewModel to live for this component only” problem cleanly.

❓ Weekly Quiz

Q1: What kind of errors does the Koin Compiler Plugin catch that the traditional Koin DSL cannot?

A: Missing dependency bindings. Without the compiler plugin, a missing single<>() or factory<>() declaration causes a NoBeanDefFoundException at runtime. The compiler plugin builds and validates the graph at build time.

Q2: In the new Lifecycle ViewModel scoping APIs, what is the default ViewModelStoreOwner when you call viewModel() inside a @Composable without specifying one?

A: The nearest LocalViewModelStoreOwner in the composition hierarchy — which for most Compose apps is the Activity. Inside Navigation 3, the nearest BackStackEntry takes priority.

Q3: What does SupervisorJob do inside viewModelScope, and why does it matter for parallel async operations?

A: SupervisorJob makes child coroutines independent — if one fails, the others continue running. This means parallel async operations in viewModelScope won’t cancel each other on failure, but you must still handle exceptions from each deferred.await() individually.

That’s a wrap for this week! See you in the next issue. 🐝

📚 Articles & References

Marcin Moskała — “Compose Stability in 2026: Strong Skipping Mode Explained”: A thorough walkthrough of how Compose’s stability system works under Strong Skipping Mode (now enabled by default since Compose 1.7). The core insight: with Strong Skipping Mode, all lambdas are automatically memoized, and Compose distinguishes between reference equality (identity) and structural equality (value) when deciding whether to skip recomposition. This makes @Stable and @Immutable annotations less critical for common cases, but understanding when they still matter is the point of the article.

Arnaud Giuliani — “Koin Compiler Plugin: Compile-Time Safety for DI”: A preview of the upcoming Koin Compiler Plugin that brings constructor auto-detection and compile-time graph validation to Koin. Catch missing bindings at build time instead of at runtime. The plugin is still alpha, but the API looks solid and the potential for faster build feedback is significant.

“On-Device LLM Inference for Android Developers — A Practical Overview”: A practical overview of the current state of on-device inference on Android: MediaPipe’s LlmInference API, the Gemini Nano integration via ML Kit, and the LiteRT (formerly TFLite) runtime. The article benchmarks several models on Pixel 8 Pro and includes guidance on when on-device inference makes sense versus cloud API calls.

“Compose Navigation 3 Alpha: Building Real Apps”: A hands-on walkthrough building a real app with Navigation 3’s NavHost API. Key differences from Navigation 2: the back stack is now a pure List<Any> that you manage yourself, type-safe routes are first-class, and the deep-link integration has been redesigned around URI templates.

“R8 Full Mode — Enabling It Without Breaking Your App”: A guide to enabling R8 Full Mode (the new default in AGP 8.x) without the string-matching failures that plague apps using reflection. The fix is usually @Keep annotations and -keep ProGuard rules, but the article explains how to use apksig to identify what’s failing.

“Detekt Rules for Koin: Enforcing Best Practices at Scale”: Kirill Rozov’s new Detekt plugin adds rules for Koin that catch common anti-patterns: injecting too many dependencies into a single module, calling get() instead of constructor injection, and declaring modules in test code that shadow production modules.

🛠️ Releases & Version Updates

Room 2.7.0 Stable: The current stable Room release brings improved Kotlin Symbol Processing (KSP) support and coroutines-first DAO generation. If you haven’t migrated from KAPT to KSP for Room yet, now is a good time — build speed improvements are typically 20–40%:

// build.gradle.kts — switch from kapt to ksp for Room
plugins {
    id("com.google.devtools.ksp") version "2.1.10-1.0.30"
}

dependencies {
    implementation("androidx.room:room-runtime:2.7.0")
    implementation("androidx.room:room-ktx:2.7.0")
    ksp("androidx.room:room-compiler:2.7.0") // was: kapt(...)
}

Hilt 2.55: Works correctly with Room’s new KSP compiler. The @HiltViewModel annotation processor no longer requires KAPT if all your other annotation processors support KSP.

Coil 3.2.1: Patch for a memory leak in AsyncImage when used inside LazyColumn with animated content. The leak was caused by a disk cache reference not being released when the composable left composition. Upgrade if you use Coil with animated GIFs or WebP.

kotlinx.datetime 0.7.0: Adds TimeZone.currentSystemDefault() caching (avoids repeated JNI calls), DateTimePeriod arithmetic, and an Instant.toLocalDateTime() extension function. The API is still experimental but stable in practice:

// kotlinx.datetime 0.7.0 — clean date formatting
import kotlinx.datetime.*

val now = Clock.System.now()
val localNow = now.toLocalDateTime(TimeZone.currentSystemDefault())

// Format: "Feb 7, 2026"
val formatted = "${localNow.month.name.take(3).lowercase().replaceFirstChar { it.uppercase() }} " +
    "${localNow.dayOfMonth}, ${localNow.year}"

Koin 4.1 — Compiler Plugin Preview

The compiler plugin turns Koin’s runtime DSL into compile-time graph construction:

// Before: Runtime declaration — errors caught at app startup
val userModule = module {
    single<UserRepository> { UserRepositoryImpl(get(), get()) }
    viewModel { UserViewModel(get()) } // crashes if UserRepository not bound
}

// After: Compiler plugin — errors caught at build time
@Module
@ComponentScan("com.example.user")
class UserModule

// Constructor injection auto-detected by the compiler plugin
@Single
class UserRepositoryImpl(
    private val api: UserApi,
    private val database: AppDatabase
) : UserRepository

@KoinViewModel
class UserViewModel(private val repository: UserRepository) : ViewModel()

📱 Android Platform Updates

On-Device AI — MediaPipe LLM Inference API

Google’s MediaPipe LlmInference API is the current recommended way to run Gemini Nano on-device. It requires Android 10+ and a device with sufficient RAM (typically 6+ GB for meaningful models):

// On-device LLM inference with MediaPipe
val inferenceOptions = LlmInference.LlmInferenceOptions.builder()
    .setModelPath("/data/local/tmp/gemma-2b-it-gpu-int4.bin")
    .setMaxTokens(1024)
    .setTopK(40)
    .setTemperature(0.8f)
    .setRandomSeed(101)
    .build()

val llmInference = LlmInference.createFromOptions(context, inferenceOptions)

// Streaming response
llmInference.generateResponseAsync(
    prompt = "Summarize this Android release note in one sentence: $releaseNote"
) { partialResult, done ->
    // partialResult arrives token by token
    if (done) finalizeResponse(partialResult)
    else appendToResponse(partialResult)
}

Freeform Window Mode Improvements (Android 16 QPR2)

Apps in freeform windowing mode on large screens can now opt into a minimum window size hint, preventing the system from resizing them below a usable threshold:

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    // Declare minimum freeform window size
    window.attributes = window.attributes.also {
        it.layoutInDisplayCutoutMode = WindowManager.LayoutParams.LAYOUT_IN_DISPLAY_CUTOUT_MODE_ALWAYS
    }
    WindowCompat.setDecorFitsSystemWindows(window, false)
}

🌟 Community Spotlight

“YARC — Compose Shorthand Generator”: The open-source tool that generates Compose layouts from shorthand syntax gained traction this week after being featured in the Android Weekly newsletter. If you build internal tooling or design systems, the shorthand approach is worth adapting.

Koin Detekt Rules (Kirill Rozov): Available on GitHub as detekt-koin-rules. The rules are composable with your existing Detekt configuration. The most useful rule: flagging Koin modules with more than 15 bindings (a sign of a module that should be split).

💡 Quick Tip of the Week

Avoid triggering recomposition from lambda captures — hoist state properly:

// ❌ Lambda captures mutable state — new lambda instance on every recomposition
@Composable
fun CounterButton(count: Int, onIncrement: () -> Unit) {
    var localMultiplier by remember { mutableStateOf(1) }

    Button(onClick = { repeat(localMultiplier) { onIncrement() } }) {
        Text("Add $localMultiplier")
    }
}

// ✅ Extract the callback computation to avoid capturing instability
@Composable
fun CounterButton(count: Int, onIncrement: (times: Int) -> Unit) {
    var localMultiplier by remember { mutableStateOf(1) }
    val onClickStable = remember(localMultiplier) {
        { onIncrement(localMultiplier) }
    }

    Button(onClick = onClickStable) {
        Text("Add $localMultiplier")
    }
}

With Strong Skipping Mode, this matters less for lambdas that don’t capture unstable state — but for lambda-heavy UI with many parameters, explicit remember(key) wrapping still buys you measurable recomposition reduction.

🧠 Did You Know?

Compose’s @Stable annotation doesn’t prevent recomposition — it tells the compiler to use structural equality for skip checks. An @Stable class will still recompose if any of its observed properties change; what changes is HOW the equality check is performed. Without @Stable, Compose uses reference equality (is it the same object in memory?). With @Stable, it calls equals(). This means:

// Without @Stable: recomposes every time UserProfile is recreated, even with same data
data class UserProfile(val name: String, val email: String)

// With @Stable: skips recomposition if equals() returns true
@Stable
data class UserProfile(val name: String, val email: String)

// In a ViewModel — emitting the same logical value triggers recomposition without @Stable
_uiState.update { it.copy() } // copy() creates new object — reference equality fails
// With @Stable data class, copy() with same values won't trigger recomposition

data class with @Stable is often the right choice for UI state objects. You get structural equality for free.

❓ Weekly Quiz

Q1: What does Compose Strong Skipping Mode change about how lambdas are handled?

A: All lambdas passed to composables are automatically memoized (wrapped in remember). This means a new lambda instance with the same captured values won’t trigger recomposition, reducing unnecessary UI updates.

Q2: What is the primary advantage of migrating Room’s annotation processing from KAPT to KSP?

A: KSP (Kotlin Symbol Processing) is faster — typically 20–40% reduction in incremental build times for annotation-heavy modules like Room. It also generates cleaner code and supports Kotlin Multiplatform natively.

Q3: In the Koin Compiler Plugin model, when are missing dependency bindings detected?

A: At build time (compile time). Without the compiler plugin, missing bindings in Koin cause NoBeanDefFoundException at runtime when the dependency is first requested.

That’s a wrap for this week! See you in the next issue. 🐝

📚 Articles & References

“Android’s Embedded Photo Picker — No More Permission Dialogs”: Google’s embedded photo picker is now the recommended way to let users select media from Android 14+ devices. Instead of requesting READ_MEDIA_IMAGES, you drop the picker in-place inside your own layout as a fragment, and the system grants scoped URI access. The article walks through the EmbeddedPhotoPicker API and its Activity Result contract wrapper.

JetBrains — “Qodana as CI-First Android Code Quality”: JetBrains frames Qodana as the CI-native counterpart to Android Lint — it runs Android Lint, Detekt, and its own inspections in a single pass, outputs SARIF, and integrates with GitHub Actions and TeamCity. The pitch: enforce code quality gates without adding per-developer tooling requirements.

sinasamaki — “ChromaDial: A Degree-Based Circular Dial in Compose”: A deep-dive into building a circular dial component with degree-based state, custom ranges, multi-turn visuals, and a snap callback that fires only when interaction ends (avoiding expensive recompositions on every degree change). The “finish callback” pattern is a great pattern for any gesture-heavy Compose UI.

“Kotlin Multiplatform for Android Developers: The Mental Shift”: A conversational piece aimed at Android developers approaching KMP for the first time. Key insight: expect/actual isn’t just for platform APIs — it’s the idiomatic way to provide different implementations of anything that doesn’t share a common abstraction across platforms.

“Flow vs. LiveData in 2026: The Final Word”: With Google’s @Discouraged annotation now on all LiveData APIs, this post makes the definitive migration argument. The migration path is StateFlow + collectAsStateWithLifecycle(), and the post provides before/after for every major LiveData use case including one-shot events.

“Compose Modifier Order: The Decorator Mental Model”: Marcin Moskała explains why modifier order matters by framing each modifier as a decorator. The insight: modifiers apply from outermost to innermost, which means padding().background() and background().padding() produce visually different results — and neither is “wrong,” they just mean different things.

🛠️ Releases & Version Updates

Compose Material3 1.4.0 Stable: The January stable release of Material3 brings SegmentedButton, SearchBar with suggestions support, and BottomAppBar with FAB docking. Dynamic color support is improved for Android 12+ devices:

@Composable
fun SortBar(
    selected: SortOrder,
    onSelected: (SortOrder) -> Unit
) {
    SingleChoiceSegmentedButtonRow {
        SortOrder.entries.forEachIndexed { index, order ->
            SegmentedButton(
                shape = SegmentedButtonDefaults.itemShape(index, SortOrder.entries.size),
                onClick = { onSelected(order) },
                selected = order == selected,
                label = { Text(order.label) }
            )
        }
    }
}

Ktor 3.1.0: The multiplatform HTTP framework adds ContentNegotiation improvements and a new WebSocketSession.convertAndSend() extension for type-safe WebSocket message sending. The Darwin (Apple) engine now supports background URL sessions.

Kotlinx.coroutines 1.10.1: Patch release fixing a regression in StateFlow where collectors on Dispatchers.Main.immediate could miss the first emission. If you upgraded to 1.10 in January, update to 1.10.1 now.

Navigation 3.0.0-alpha05: The alpha continues to evolve. This build adds NavHost support for SharedTransitionLayout — you can now do shared element transitions between destinations without any custom code:

SharedTransitionLayout {
    NavHost(navController = navController, startDestination = "home") {
        composable("home") {
            HomeScreen(
                onItemClick = { id -> navController.navigate("detail/$id") },
                sharedTransitionScope = this@SharedTransitionLayout,
                animatedVisibilityScope = this
            )
        }
        composable("detail/{id}") { backStackEntry ->
            DetailScreen(
                id = backStackEntry.arguments!!.getString("id")!!,
                sharedTransitionScope = this@SharedTransitionLayout,
                animatedVisibilityScope = this
            )
        }
    }
}

Android Embedded Photo Picker API

The API surface is cleaner than it looks. Here’s the core integration:

// Register the launcher — works exactly like ActivityResult contracts
val photoPickerLauncher = registerForActivityResult(
    PickVisualMedia()
) { uri ->
    uri?.let { displayPhoto(it) }
}

// Single photo pick — no READ_MEDIA_IMAGES permission needed on Android 14+
fun launchPhotoPicker() {
    photoPickerLauncher.launch(
        PickVisualMediaRequest(PickVisualMedia.ImageAndVideo)
    )
}

// Multiple photos — set a max selection limit
val multiPickerLauncher = registerForActivityResult(
    PickMultipleVisualMedia(maxItems = 5)
) { uris ->
    displaySelectedPhotos(uris)
}

📱 Android Platform Updates

Embedded Photo Picker — What It Means for Permission Architecture

The traditional permission flow for photo access has been fragmented: READ_MEDIA_IMAGES on API 33+, READ_EXTERNAL_STORAGE on older, and the visual media picker partial access on API 34+. The embedded picker consolidates all of this:

• API 30–33: Falls back to system photo picker (full-screen)
• API 34+: Renders inline within your layout using the EmbeddedPhotoPicker fragment
• No permission declaration needed for the inline picker path

This is the most significant permission architecture simplification since scoped storage.

ContentProvider Permission Hardening (Android 16+)

A less-publicized Android 16 change: apps can no longer grant URI permissions for FileProvider URIs to other apps unless the receiving app explicitly requests them. This affects apps that share files via Intent.FLAG_GRANT_READ_URI_PERMISSION and may require testing with existing file-sharing flows.

🧰 Tool of the Week

Qodana by JetBrains: If your team isn’t running automated code quality gates in CI, Qodana is worth trying. It bundles Android Lint, Detekt, and IntelliJ inspections into a single Docker image. The GitHub Action integration is straightforward:

# .github/workflows/code-quality.yml
- name: Run Qodana
  uses: JetBrains/qodana-action@v2025.3
  with:
    pr-mode: false
  env:
    QODANA_TOKEN: $

The SARIF output integrates with GitHub’s code scanning dashboard, so issues appear inline on pull requests. The free tier covers most open-source use cases.

💡 Quick Tip of the Week

Use collectAsStateWithLifecycle() instead of collectAsState() in Compose:

// ❌ collectAsState() — keeps collecting even when the app is in the background
@Composable
fun UserProfile(viewModel: UserViewModel = hiltViewModel()) {
    val user by viewModel.userState.collectAsState()
    UserContent(user)
}

// ✅ collectAsStateWithLifecycle() — pauses collection when lifecycle is below STARTED
@Composable
fun UserProfile(viewModel: UserViewModel = hiltViewModel()) {
    val user by viewModel.userState.collectAsStateWithLifecycle()
    UserContent(user)
}

collectAsStateWithLifecycle() respects the Android lifecycle — it stops collecting when your app goes to the background, reducing unnecessary work. Add the lifecycle-runtime-compose dependency to get it:

implementation("androidx.lifecycle:lifecycle-runtime-compose:2.8.7")

🧠 Did You Know?

Compose remember without keys is a potential bug trap. If you use remember { expensiveComputation(someParam) } without listing someParam as a key, the computation only runs once — even if someParam changes on recomposition. The Compose compiler won’t warn you by default:

// 🐛 Bug: sortedItems never updates when items or sortOrder change
@Composable
fun ItemList(items: List<Item>, sortOrder: SortOrder) {
    val sortedItems = remember { items.sortedBy { sortOrder.selector(it) } }
    LazyColumn {
        items(sortedItems) { ItemRow(it) }
    }
}

// ✅ Correct: keys listed — recomputes when either changes
@Composable
fun ItemList(items: List<Item>, sortOrder: SortOrder) {
    val sortedItems = remember(items, sortOrder) { items.sortedBy { sortOrder.selector(it) } }
    LazyColumn {
        items(sortedItems) { ItemRow(it) }
    }
}

Starting with the Compose BOM 2026.01, the compiler will emit a warning when remember {} captures unstable state without declaring it as a key. Worth enabling @Suppress("REMEMBER_WITHOUT_KEYS") in the short term while you audit your code.

❓ Weekly Quiz

Q1: When using the Android embedded photo picker, which permission do you need to declare in your manifest for Android 14+ devices?

A: None. The embedded photo picker grants scoped URI access automatically without requiring READ_MEDIA_IMAGES or any other storage permission on Android 14+ (API 34+).

Q2: What’s the difference between collectAsState() and collectAsStateWithLifecycle() in Jetpack Compose?

A: collectAsState() collects the Flow continuously regardless of the app’s lifecycle state. collectAsStateWithLifecycle() pauses collection when the lifecycle drops below STARTED (e.g., when the app is backgrounded), saving resources.

Q3: What is remember {} without keys a risk for in Compose?

A: The computation inside remember {} only runs once during the composable’s lifetime. If the block captures variables that change on recomposition, the result becomes stale. Always list captured variables as keys: remember(key1, key2) { ... }.

That’s a wrap for this week! See you in the next issue. 🐝

📚 Articles & References

Jesse Wilson — “Don’t Block Inside Suspend Functions”: Jesse makes the case for why blocking calls inside suspend functions are worse than regular blocking calls. The coroutine scheduler treats suspend functions as cheap, cooperative operations — call Thread.sleep() or do blocking I/O inside one and you’ve pinned a thread from the shared pool. The fix is always withContext(Dispatchers.IO) { }.

Simon Vergauwen — “Exposed 1.0: Stable at Last”: JetBrains-backed Kotlin SQL library Exposed reached 1.0, bringing a stable public API contract and a commitment of no breaking changes until 2.0. Highlights include R2DBC reactive database support, improved type-safe schema migration DSL, and the removal of several deprecated APIs that have been lingering since 0.x.

Thomas Künneth — “Mapping Android’s Jetpack Stack onto Kotlin Multiplatform”: A practical guide to how standard Android Jetpack libraries (ViewModel, Room, DataStore, Navigation) map to their KMP-compatible equivalents. The article is particularly useful for teams starting their first KMP migration — it gives you a mental map before you start changing code.

Fragmented Podcast — “AI Coding Paradigms for Android Developers”: Kaushik Gopal and Iury Souza organize AI-assisted coding into four paradigms: autocomplete, natural language to code, test-driven generation, and agentic workflows. The framing helps experienced Android developers figure out where to invest their tooling attention first.

“Yet Another Rapid Compose (YARC) — Compose Shorthand Generator”: A new tool that generates Jetpack Compose layout shorthand. Less interesting as a production tool and more interesting as a study in Compose’s composability — it shows just how much of Android UI can now be expressed as small, composable functions.

“The Case Against Blocking in Coroutines — A Deep Dive”: A follow-up to Jesse Wilson’s post, this goes into the mechanics: why Dispatchers.Main has only one thread, why blocking it causes UI jank, and how suspend fun without withContext gives you false safety.

🛠️ Releases & Version Updates

Exposed 1.0.0 (Stable): JetBrains’ Kotlin SQL framework hits stable. The 1.0 release finalizes the Table/Column DSL API and adds R2DBC support for reactive database access:

// Exposed 1.0 — Type-safe table definitions (stable API)
object Users : Table("users") {
    val id = integer("id").autoIncrement()
    val name = varchar("name", 128)
    val email = varchar("email", 256).uniqueIndex()
    val createdAt = datetime("created_at").defaultExpression(CurrentDateTime)
    override val primaryKey = PrimaryKey(id)
}

// Coroutine-safe transactions with suspendTransaction
suspend fun getUserByEmail(email: String): User? =
    suspendTransaction {
        Users.select { Users.email eq email }
            .singleOrNull()
            ?.toUser()
    }

Compose BOM 2026.01.00: The first BOM of 2026 ships with Compose UI 1.8.0-rc01, Material3 1.4.0-rc02, and Compose Runtime 1.8.0-rc01. The biggest runtime change: remember {} blocks with no keys now generate a compiler warning if the block captures mutable state.

// In build.gradle.kts — pin all Compose versions via BOM
implementation(platform("androidx.compose:compose-bom:2026.01.00"))
implementation("androidx.compose.ui:ui")
implementation("androidx.compose.material3:material3")
// No version numbers needed — BOM handles alignment

Kotlinx.serialization 1.8.0: Adds experimental support for @SerialName on type parameters and improved error messages when deserializing unexpected JSON keys. The Json { ignoreUnknownKeys = true } behavior is now configurable at the property level.

Hilt 2.55: Minor release fixing lifecycle-aware ViewModel injection in Compose navigation. The fix prevents double-initialization when a HiltViewModel is used inside a NavHost with a rememberNavController() that survives configuration changes.

Compose BOM 2026.01 — What’s Actually New

The most developer-visible change in this BOM cycle is in Compose Foundation — BasicTextField now supports cursor blinking animations and IME action forwarding out of the box:

@Composable
fun SearchField(query: String, onQueryChange: (String) -> Unit) {
    BasicTextField(
        value = query,
        onValueChange = onQueryChange,
        cursorBrush = SolidColor(MaterialTheme.colorScheme.primary),
        keyboardOptions = KeyboardOptions(imeAction = ImeAction.Search),
        keyboardActions = KeyboardActions(
            onSearch = { /* handle search */ }
        ),
        decorationBox = { innerTextField ->
            Box(
                modifier = Modifier
                    .background(MaterialTheme.colorScheme.surfaceVariant, RoundedCornerShape(8.dp))
                    .padding(horizontal = 16.dp, vertical = 12.dp)
            ) {
                if (query.isEmpty()) Text("Search…", color = MaterialTheme.colorScheme.onSurfaceVariant)
                innerTextField()
            }
        }
    )
}

📱 Android Platform Updates

Android 16 QPR2 — Minor SDK Versioning in Practice

The minor SDK versioning system introduced in Android 16 QPR2 is now live in the wild. The practical impact: apps can start checking for QPR-specific APIs without waiting for the annual SDK bump.

// New helper — reads both major and minor SDK version
fun isAndroid16QPR2OrHigher(): Boolean =
    Build.VERSION.SDK_INT >= 36 && Build.VERSION.SDK_INT_MINOR >= 1

// Use new QPR2 health background monitoring APIs
fun setupBackgroundHealthMonitoring(context: Context) {
    if (isAndroid16QPR2OrHigher()) {
        val healthManager = context.getSystemService(HealthServicesManager::class.java)
        // QPR2-specific API surface
        healthManager?.requestPassiveMonitoring(
            PassiveMonitoringRequest.Builder()
                .setDataTypes(setOf(DataType.HEART_RATE_BPM))
                .build()
        )
    }
}

Android Security Bulletin — January 2026

Google published the January 2026 security bulletin with patches for 38 vulnerabilities. Three critical RCE vulnerabilities in the media framework (CVE-2026-0112, CVE-2026-0113, CVE-2026-0114) affect apps that parse media from untrusted sources. Update your Pixel and test your media pipelines.

🌟 Community Spotlight

Exposed 1.0 adoption in KMP projects: With Exposed 1.0 out the door, several open-source KMP projects have already started migrating from SQLDelight. The main differentiator: Exposed’s DSL is closer to Kotlin idioms, while SQLDelight generates type-safe Kotlin from .sq files. Worth knowing both.

YARC — Yet Another Rapid Compose: A new open-source tool for generating Compose layouts from shorthand syntax. Still early, but the shorthand approach is interesting for teams building internal tooling or design systems. Worth starring on GitHub if you follow Compose tooling.

💡 Quick Tip of the Week

Use withContext instead of launch(Dispatchers.IO) for simple background work:

// ❌ Creates a new coroutine, can complete after the parent is cancelled
fun loadUser(id: String) {
    viewModelScope.launch(Dispatchers.IO) {
        val user = userRepository.getUser(id)
        _uiState.value = UiState.Success(user)
    }
}

// ✅ Switches context within the same coroutine — respects cancellation
fun loadUser(id: String) {
    viewModelScope.launch {
        val user = withContext(Dispatchers.IO) {
            userRepository.getUser(id)
        }
        _uiState.value = UiState.Success(user)
    }
}

The launch(Dispatchers.IO) version runs its body even after viewModelScope is cancelled (e.g., after the ViewModel is cleared). withContext is structured — cancellation propagates correctly.

🧠 Did You Know?

suspend functions are NOT automatically non-blocking. The suspend keyword only tells the compiler to allow calling other suspend functions and to pause execution. It does nothing to prevent blocking calls. This compiles without any warning:

// This LOOKS safe but blocks the coroutine dispatcher's thread
suspend fun getUserProfile(id: String): UserProfile {
    Thread.sleep(3000) // 🚫 blocks thread — violates cooperative scheduling
    return UserProfile(id, "Mukul")
}

// This IS safe — moves blocking work to an IO thread
suspend fun getUserProfile(id: String): UserProfile {
    return withContext(Dispatchers.IO) {
        Thread.sleep(3000) // ok here — IO dispatcher has many threads
        UserProfile(id, "Mukul")
    }
}