Performance Optimization

Performance Optimization

Overview

"Performance optimization without measurement is guessing." Measure first, identify bottlenecks with data, fix with targeted changes, verify the improvement, and guard against regressions. Never optimize based on assumptions.

When to Use

• App startup exceeds 500ms (cold) or 200ms (warm)
• UI jank (dropped frames, janky scrolling)
• ANR (Application Not Responding) reports
• APK/AAB size exceeds budget
• Before a release (performance regression check)
• Users report slowness or battery drain

Skip when: No performance issue is observed or measured.

Android Vitals Targets

Core Process

Step 1: Measure

1. Baseline Profiles (startup and scrolling):

// benchmark/src/main/java/BaselineProfileGenerator.kt
@RunWith(AndroidJUnit4::class)
class BaselineProfileGenerator {
    @get:Rule
    val rule = BaselineProfileRule()

    @Test
    fun generateBaselineProfile() {
        rule.collect(packageName = "com.example.app") {
            // Cold start
            pressHome()
            startActivityAndWait()

            // Critical user journeys
            device.findObject(By.text("Tasks")).click()
            device.waitForIdle()

            // Scroll the list
            val list = device.findObject(By.res("task_list"))
            list.setGestureMargin(device.displayWidth / 5)
            list.fling(Direction.DOWN)
            device.waitForIdle()
        }
    }
}

2. Macrobenchmark (startup timing):

@RunWith(AndroidJUnit4::class)
class StartupBenchmark {
    @get:Rule
    val rule = MacrobenchmarkRule()

    @Test
    fun coldStartup() {
        rule.measureRepeated(
            packageName = "com.example.app",
            metrics = listOf(StartupTimingMetric()),
            startupMode = StartupMode.COLD,
            iterations = 5,
        ) {
            pressHome()
            startActivityAndWait()
        }
    }
}

3. Android Studio Profiler:
   • CPU Profiler: Record method traces, identify hot methods
   • Memory Profiler: Track allocations, find leaks, heap dumps
   • Network Profiler: Inspect API calls, timing, payload sizes
   • Energy Profiler: CPU, network, and GPS wake lock usage

Step 2: Identify Bottlenecks

4. Common performance anti-patterns:

Step 3: Fix

5. Startup optimization:

// Use App Startup library for lazy initialization
class AnalyticsInitializer : Initializer<Analytics> {
    override fun create(context: Context): Analytics {
        return Analytics.init(context)
    }
    override fun dependencies(): List<Class<out Initializer<*>>> = emptyList()
}

// Defer non-critical work
class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // Critical path only — show UI immediately
        setContent { AppTheme { AppNavigation() } }

        // Defer non-critical initialization
        lifecycleScope.launch {
            lifecycle.repeatOnLifecycle(Lifecycle.State.STARTED) {
                initializeAnalytics()
                prefetchUserData()
            }
        }
    }
}

6. Compose recomposition optimization:

// Use key() for list items
LazyColumn {
    items(tasks, key = { it.id }) { task ->
        TaskItem(task = task)
    }
}

// Use derivedStateOf for computed values
val showScrollToTop by remember {
    derivedStateOf { listState.firstVisibleItemIndex > 5 }
}

// Use ImmutableList for stable parameters
@Composable
fun TaskList(
    tasks: ImmutableList<Task>, // from kotlinx.collections.immutable
    onToggle: (String) -> Unit,
)

// Avoid lambda allocations in loops
items(tasks, key = { it.id }) { task ->
    // BAD: new lambda per recomposition
    TaskItem(onToggle = { viewModel.toggle(task.id) })
    // GOOD: method reference
    TaskItem(onToggle = viewModel::toggleTask)
}

7. APK size reduction:

// build.gradle.kts
android {
    buildTypes {
        release {
            isMinifyEnabled = true     // R8 code shrinking
            isShrinkResources = true   // Remove unused resources
            proguardFiles(
                getDefaultProguardFile("proguard-android-optimize.txt"),
                "proguard-rules.pro"
            )
        }
    }
}

// Use WebP for images, vector drawables where possible
// Use dynamic feature modules for large optional features
// Analyze APK: Build → Analyze APK in Android Studio

8. Image loading optimization:

// Coil with size constraints — request only the pixels you render.
// Size.ORIGINAL decodes the full bitmap and defeats the point.
AsyncImage(
    model = ImageRequest.Builder(LocalContext.current)
        .data(task.imageUrl)
        .size(200, 200)  // match the display size; never Size.ORIGINAL for thumbnails
        .crossfade(true)
        .build(),
    contentDescription = task.title,
    modifier = Modifier.size(64.dp),
)

Step 4: Verify

9. Confirm improvement with measurements:
   • Re-run Macrobenchmark — compare before/after
   • Check frame metrics in Android Studio Profiler
   • Verify APK size: ./gradlew assembleRelease → Analyze APK
   • Run on lower-end devices (not just your development device)

Step 5: Guard

10. Prevent regressions:
    • Baseline Profiles generated in CI
    • Macrobenchmark tests run on pre-release builds
    • APK size budget checked in CI
    • Performance monitoring in production (Firebase Performance)

Common Rationalizations

Red Flags

• No Baseline Profiles
• No Macrobenchmark tests
• APK size growing without tracking
• Thread.sleep or busy-wait patterns
• Unbounded list loading (no Paging3)
• Heavy computation on main thread
• Images loaded at full resolution
• Profiling only done on debug builds

Verification

• Startup time measured (cold and warm)
• Frame rendering metrics checked (slow frames < 5%)
• APK size within budget
• Baseline Profiles generated and included
• No N+1 query patterns
• Images loaded with proper sizing
• Heavy work off main thread
• Macrobenchmark tests guard critical paths
• Performance tested on low-end devices