Optimize app startup and Jetpack Compose performance

- Implement asynchronous SDK initialization using AndroidX Startup and Kotlin coroutines to move blocking work off the main thread.
- Introduce `CrashReportingInitializer`, `AnalyticsInitializer`, `PerfMonitorInitializer`, `FeatureFlagsInitializer`, and `RemoteConfigInitializer` to manage SDK lifecycles.
- Optimize `FeedScreen` and `DetailScreen` by applying `remember`, `derivedStateOf`, and stable `key` to prevent unnecessary recompositions and allocations.
- Mark `FeedItem` as `@Immutable` to improve Compose compiler optimization.
- Add `AppStartupBenchmark` to measure and verify cold and warm start performance improvements.
- Update Gradle dependencies to include `androidx.startup` and `kotlinx-coroutines-android`.

Author: mohdaquib

ui/src/main/java/com/aquib/androidperflab/ui/AnimatedListScreen.kt

@@ -1,11 +1,15 @@
 package com.aquib.androidperflab.ui
 
-import androidx.compose.animation.animateContentSize
+import androidx.compose.animation.core.DeferredTargetAnimation
+import androidx.compose.animation.core.ExperimentalAnimatableApi
 import androidx.compose.animation.core.LinearEasing
 import androidx.compose.animation.core.RepeatMode
+import androidx.compose.animation.core.Spring
+import androidx.compose.animation.core.VectorConverter
 import androidx.compose.animation.core.animateFloat
 import androidx.compose.animation.core.infiniteRepeatable
 import androidx.compose.animation.core.rememberInfiniteTransition
+import androidx.compose.animation.core.spring
 import androidx.compose.animation.core.tween
 import androidx.compose.foundation.background
 import androidx.compose.foundation.clickable
@@ -24,19 +28,27 @@ import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Text
 import androidx.compose.material3.TextButton
 import androidx.compose.runtime.Composable
+import androidx.compose.runtime.Immutable
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
 import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.alpha
+import androidx.compose.ui.draw.clipToBounds
 import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.graphicsLayer
+import androidx.compose.ui.layout.layout
 import androidx.compose.ui.platform.testTag
 import androidx.compose.ui.semantics.contentDescription
 import androidx.compose.ui.semantics.semantics
 import androidx.compose.ui.unit.dp
+import kotlin.math.roundToInt
 
+// @Immutable: all fields are val and all types are immutable, so the Compose compiler
+// can skip any composable whose AnimatedItem argument has not changed reference.
+@Immutable
 private data class AnimatedItem(
     val id: Int,
     val title: String,
@@ -49,9 +61,9 @@ private fun generateAnimatedItems(count: Int = 80): List<AnimatedItem> = List(co
         id = i,
         title = "Animation Demo Item #$i",
         subtitle = "Tap to expand · item ${i + 1} of $count",
-        body = "This card has animateContentSize applied, an alpha that reads State<Float> " +
-            "in composition scope (not inside a graphicsLayer lambda), and a Color " +
-            "constructed inline on every recomposition. All intentionally unoptimized.",
+        body = "Alpha pulse runs via graphicsLayer (draw phase — zero recomposition). " +
+            "Expand/collapse uses DeferredTargetAnimation inside Modifier.layout — " +
+            "height changes are layout-phase only. No recomposition during animation frames.",
     )
 }
 
@@ -69,103 +81,150 @@ fun AnimatedListScreen(
             modifier = Modifier
                 .fillMaxSize()
                 .testTag("animated_list")
-                .semantics { contentDescription = "animated_list" }
+                .semantics { contentDescription = "animated_list" },
         ) {
-            // BAD: no key lambda — Compose cannot track item identity across recompositions,
-            // so any structural change causes it to diff by position rather than by id.
-            items(items) { item ->
+            // FIX — stable key: pins each slot to a specific AnimatedItem by id so
+            // Compose can reuse existing nodes on structural changes instead of
+            // destroying and recreating items by position.
+            items(items, key = { it.id }) { item ->
                 AnimatedListCard(item = item)
                 HorizontalDivider()
             }
         }
     }
 }
 
+@OptIn(ExperimentalAnimatableApi::class)
 @Composable
 private fun AnimatedListCard(item: AnimatedItem) {
     var expanded by remember { mutableStateOf(false) }
 
-    // BAD: animatedAlpha is a State<Float> whose value changes every ~16 ms while the
-    // animation runs. Reading it here (via the `by` delegate) subscribes this composable
-    // to that state, so the ENTIRE composable — and every child inside it — recomposes
-    // on every single animation frame.
+    // rememberCoroutineScope() gives a scope tied to this composable's lifecycle.
+    // DeferredTargetAnimation uses it to launch the height-animation coroutine from
+    // inside the layout lambda — without ever touching the composition phase.
+    val scope = rememberCoroutineScope()
+
+    // FIX — remember(item.id): Color object allocated once per item.
+    // Previously a new Color was constructed on every recomposition.
+    val accentColor = remember(item.id) {
+        Color(
+            red   = (item.id * 37 % 200 + 55) / 255f,
+            green = (item.id * 71 % 180 + 50) / 255f,
+            blue  = (item.id * 13 % 220 + 35) / 255f,
+        )
+    }
+
+    // FIX — infinite alpha pulse via graphicsLayer:
+    // animateFloat() returns State<Float>. Assigning to a plain val (no `by`) means
+    // the value is NOT read here in the composition scope. The `by` delegate would call
+    // State.getValue() during composition, subscribing this entire composable to the
+    // animation and causing a full recompose on every 16 ms frame.
     //
-    // Correct fix: don't read the state here at all. Instead, pass it into a graphicsLayer
-    // lambda where only the draw phase is invalidated:
-    //   Modifier.graphicsLayer { alpha = animatedAlpha }
+    // Instead, alphaState.value is read only inside the graphicsLayer lambda below,
+    // which runs in the draw phase. Only the GPU layer is invalidated on each tick —
+    // composition and layout are never touched.
     val infiniteTransition = rememberInfiniteTransition(label = "pulse_${item.id}")
-    val animatedAlpha by infiniteTransition.animateFloat(
-        initialValue = 0.50f,
-        targetValue = 1.00f,
+    val alphaState = infiniteTransition.animateFloat(
+        initialValue = 0.5f,
+        targetValue  = 1.0f,
         animationSpec = infiniteRepeatable(
-            // Stagger durations slightly so items don't all flash in sync.
-            animation = tween(durationMillis = 600 + (item.id % 10) * 80, easing = LinearEasing),
+            animation  = tween(durationMillis = 600 + (item.id % 10) * 80, easing = LinearEasing),
             repeatMode = RepeatMode.Reverse,
         ),
         label = "alpha_${item.id}",
     )
 
-    // BAD: new Color object allocated on every recomposition — should be a top-level
-    // constant or wrapped in remember { Color(...) }.
-    val accentColor = Color(
-        red   = (item.id * 37 % 200 + 55) / 255f,
-        green = (item.id * 71 % 180 + 50) / 255f,
-        blue  = (item.id * 13 % 220 + 35) / 255f,
-    )
+    // FIX — DeferredTargetAnimation for expand/collapse:
+    // Drives the body's height from 0→full (expand) or full→0 (collapse) entirely
+    // from inside Modifier.layout. State reads in a layout lambda trigger a layout-phase
+    // re-run, not a recomposition — so the 80 frames of a spring animation produce
+    // 80 layout passes and zero recompositions.
+    val expandAnim = remember { DeferredTargetAnimation(Float.VectorConverter) }
 
     Column(
         modifier = Modifier
             .fillMaxWidth()
-            // BAD 1: animateContentSize on every item in the list.
-            // When any card expands, the LayoutModifier runs its size interpolation on
-            // every animation frame for every card that has this modifier — not just the
-            // one the user tapped.
-            .animateContentSize()
-            // BAD 2: Modifier.alpha() evaluates its argument during composition, so the
-            // state read above makes this whole subtree recompose every frame.
-            // Modifier.graphicsLayer { alpha = animatedAlpha } would confine the read to
-            // the draw phase and skip recomposition entirely.
-            .alpha(animatedAlpha)
+            // FIX — graphicsLayer for alpha: alphaState.value is read inside the
+            // lambda, scoped to the draw phase. The composable tree above this point
+            // is never invalidated by the animation.
+            .graphicsLayer { alpha = alphaState.value }
             .background(accentColor.copy(alpha = 0.07f))
-            .clickable { expanded = !expanded }
-            .padding(horizontal = 16.dp, vertical = 12.dp),
+            .clickable { expanded = !expanded },
     ) {
+        // ── Header (always visible) ───────────────────────────────────────────
         Row(
-            modifier = Modifier.fillMaxWidth(),
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(horizontal = 16.dp, vertical = 12.dp),
             horizontalArrangement = Arrangement.SpaceBetween,
-            verticalAlignment = Alignment.CenterVertically,
+            verticalAlignment     = Alignment.CenterVertically,
         ) {
             Column(modifier = Modifier.weight(1f)) {
                 Text(
-                    text = item.title,
+                    text  = item.title,
                     style = MaterialTheme.typography.titleSmall,
                     color = accentColor,
                 )
                 Text(
-                    text = item.subtitle,
+                    text  = item.subtitle,
                     style = MaterialTheme.typography.labelSmall,
                     color = MaterialTheme.colorScheme.outline,
                 )
             }
             Text(
-                text = if (expanded) "▲" else "▼",
+                text  = if (expanded) "▲" else "▼",
                 style = MaterialTheme.typography.labelMedium,
                 color = accentColor,
             )
         }
 
-        if (expanded) {
+        // ── Body (height animated via DeferredTargetAnimation) ────────────────
+        //
+        // The body is always present in the composition tree — no if/else branch.
+        // Removing the branch means tapping the card causes exactly ONE recomposition
+        // (to flip the chevron); thereafter the spring animation runs purely in the
+        // layout phase via DeferredTargetAnimation.
+        //
+        // Modifier.layout measures the full body height, then reports an animated
+        // fraction of that height to the parent. clipToBounds() hides content that
+        // extends beyond the currently animated bounds so nothing visually overflows.
+        Column(
+            modifier = Modifier
+                .fillMaxWidth()
+                .clipToBounds()
+                .layout { measurable, constraints ->
+                    val placeable = measurable.measure(constraints)
+
+                    // updateTarget() is called here (layout phase) — it starts or
+                    // redirects the animation coroutine when the target changes, and
+                    // returns the current interpolated progress value.
+                    // Reading it here causes layout-phase invalidation on each frame,
+                    // NOT a recomposition.
+                    val progress = expandAnim.updateTarget(
+                        target         = if (expanded) 1f else 0f,
+                        coroutineScope = scope,
+                        animationSpec  = spring(stiffness = Spring.StiffnessMediumLow),
+                    )
+                    val animatedHeight = (placeable.height * progress)
+                        .roundToInt()
+                        .coerceAtLeast(0)
+
+                    layout(placeable.width, animatedHeight) {
+                        placeable.place(0, 0)
+                    }
+                },
+        ) {
             Spacer(modifier = Modifier.height(8.dp))
             Text(text = item.body, style = MaterialTheme.typography.bodySmall)
             Spacer(modifier = Modifier.height(4.dp))
-            // Extra lines increase the layout cost when animateContentSize runs.
             repeat(4) { line ->
                 Text(
-                    text = "Detail line ${line + 1} — item #${item.id}",
+                    text  = "Detail line ${line + 1} — item #${item.id}",
                     style = MaterialTheme.typography.labelSmall,
                     color = MaterialTheme.colorScheme.outline,
                 )
             }
+            Spacer(modifier = Modifier.height(8.dp))
         }
     }
 }