Android Performance Mastery

// Define your performance budgets as constants
object PerformanceBudget {
    const val COLD_START_MAX_MS = 500L
    const val WARM_START_MAX_MS = 200L
    const val FRAME_BUDGET_60FPS_MS = 16.67
    const val FRAME_BUDGET_90FPS_MS = 11.11
    const val TOUCH_RESPONSE_MAX_MS = 100L
    const val NETWORK_FIRST_CONTENT_MAX_MS = 2000L
    const val APK_SIZE_MAX_MB = 15

    fun isFrameDropped(renderTimeMs: Double, targetFps: Int = 60): Boolean {
        val budget = 1000.0 / targetFps
        return renderTimeMs > budget
    }
}

// In AndroidManifest.xml — make release builds profileable
// <application>
//     <profileable android:shell="true"
//         tools:targetApi="29" />
// </application>

// Custom trace sections for profiling specific code paths
import android.os.Trace

fun loadUserProfile(userId: String): UserProfile {
    Trace.beginSection("loadUserProfile")
    try {
        Trace.beginSection("fetchFromCache")
        val cached = cache.get(userId)
        Trace.endSection() // fetchFromCache

        if (cached != null) return cached

        Trace.beginSection("fetchFromNetwork")
        val profile = api.fetchProfile(userId)
        Trace.endSection() // fetchFromNetwork

        Trace.beginSection("saveToCache")
        cache.put(userId, profile)
        Trace.endSection() // saveToCache

        return profile
    } finally {
        Trace.endSection() // loadUserProfile
    }
}

// Adding custom trace points that appear in Perfetto
import androidx.tracing.Trace as AndroidXTrace

// Simple inline tracing
inline fun <T> trace(label: String, block: () -> T): T {
    AndroidXTrace.beginSection(label)
    try {
        return block()
    } finally {
        AndroidXTrace.endSection()
    }
}

// Usage — these sections appear in Perfetto timeline
fun initializeApp() {
    trace("App.initDagger") {
        daggerComponent = DaggerAppComponent.create()
    }

    trace("App.initDatabase") {
        database = Room.databaseBuilder(
            context,
            AppDatabase::class.java,
            "app.db"
        ).build()
    }

    trace("App.initNetworking") {
        retrofit = Retrofit.Builder()
            .baseUrl(BASE_URL)
            .client(okHttpClient)
            .build()
    }
}

// Macrobenchmark — measure cold startup time
@RunWith(AndroidJUnit4::class)
class StartupBenchmark {

    @get:Rule
    val benchmarkRule = MacrobenchmarkRule()

    @Test
    fun startupColdCompilation() {
        benchmarkRule.measureRepeated(
            packageName = "com.example.myapp",
            metrics = listOf(StartupTimingMetric()),
            compilationMode = CompilationMode.None(), // worst case
            iterations = 5,
            startupMode = StartupMode.COLD,
            setupBlock = {
                pressHome()
                dropKernelPageCache()
            }
        ) {
            startActivityAndWait()
        }
    }

    @Test
    fun scrollPerformance() {
        benchmarkRule.measureRepeated(
            packageName = "com.example.myapp",
            metrics = listOf(FrameTimingMetric()),
            compilationMode = CompilationMode.Partial(),
            iterations = 5,
            startupMode = StartupMode.WARM
        ) {
            startActivityAndWait()
            val list = device.findObject(By.res("feed_list"))
            list.setGestureMargin(device.displayWidth / 5)
            list.fling(Direction.DOWN)
            list.fling(Direction.DOWN)
            list.fling(Direction.UP)
        }
    }
}

// Microbenchmark — measure function execution time
@RunWith(AndroidJUnit4::class)
class JsonParsingBenchmark {

    @get:Rule
    val benchmarkRule = BenchmarkRule()

    @Test
    fun benchmarkMoshiParsing() {
        val json = loadTestJson()
        val adapter = moshi.adapter(UserResponse::class.java)

        benchmarkRule.measureRepeated {
            val result = adapter.fromJson(json)
        }
    }

    @Test
    fun benchmarkKotlinxSerializationParsing() {
        val json = loadTestJson()

        benchmarkRule.measureRepeated {
            val result = Json.decodeFromString<UserResponse>(json)
        }
    }
}

// BaselineProfileGenerator.kt — generates baseline profiles
@RunWith(AndroidJUnit4::class)
class BaselineProfileGenerator {

    @get:Rule
    val rule = BaselineProfileRule()

    @Test
    fun generateBaselineProfile() {
        rule.collect(
            packageName = "com.example.myapp",
            maxIterations = 5,
            stableIterations = 3
        ) {
            // Cold start
            pressHome()
            startActivityAndWait()

            // Navigate to key screens
            device.findObject(By.text("Feed")).click()
            device.waitForIdle()

            // Scroll the main list
            val list = device.findObject(By.res("feed_list"))
            list.fling(Direction.DOWN)
            list.fling(Direction.DOWN)

            // Navigate to detail
            device.findObject(By.res("item_card")).click()
            device.waitForIdle()

            // Navigate to search
            device.findObject(By.res("search_button")).click()
            device.waitForIdle()
            device.findObject(By.res("search_input")).text = "test"
            device.waitForIdle()
        }
    }
}

// build.gradle.kts — configure baseline profiles
plugins {
    id("com.android.application")
    id("androidx.baselineprofile")
}

android {
    defaultConfig {
        // Enable profile-guided optimization
        baselineProfile {
            automaticGenerationDuringBuild = true
            dexLayoutOptimization = true // Startup Profile
        }
    }
}

dependencies {
    baselineProfile(project(":baselineprofile"))
}

// Challenge: Implement a PerformanceTracker that:
// 1. Tracks method execution time with custom trace sections
// 2. Detects when execution exceeds a specified budget
// 3. Logs warnings for budget violations
// 4. Supports nested tracking
// 5. Reports statistics (min, max, average) for tracked sections

import android.os.SystemClock
import android.os.Trace
import android.util.Log
import java.util.concurrent.ConcurrentHashMap

class PerformanceTracker private constructor() {

    private val metrics = ConcurrentHashMap<String, MutableList<Long>>()
    private val activeTraces = ThreadLocal<ArrayDeque<TraceEntry>>()

    data class TraceEntry(
        val label: String,
        val startTimeNs: Long,
        val budgetMs: Long
    )

    data class Stats(
        val label: String,
        val count: Int,
        val minMs: Double,
        val maxMs: Double,
        val avgMs: Double,
        val p95Ms: Double
    )

    fun beginSection(label: String, budgetMs: Long = Long.MAX_VALUE) {
        Trace.beginSection(label)
        val stack = activeTraces.get() ?: ArrayDeque<TraceEntry>().also {
            activeTraces.set(it)
        }
        stack.addLast(TraceEntry(label, System.nanoTime(), budgetMs))
    }

    fun endSection(): Long {
        val stack = activeTraces.get()
            ?: throw IllegalStateException("No active trace section")
        val entry = stack.removeLast()
        Trace.endSection()

        val durationNs = System.nanoTime() - entry.startTimeNs
        val durationMs = durationNs / 1_000_000L

        metrics.getOrPut(entry.label) { mutableListOf() }.add(durationMs)

        if (durationMs > entry.budgetMs) {
            Log.w(
                TAG,
                "PERF VIOLATION: ${entry.label} took ${durationMs}ms " +
                    "(budget: ${entry.budgetMs}ms, exceeded by ${durationMs - entry.budgetMs}ms)"
            )
        }

        return durationMs
    }

    inline fun <T> track(
        label: String,
        budgetMs: Long = Long.MAX_VALUE,
        block: () -> T
    ): T {
        beginSection(label, budgetMs)
        try {
            return block()
        } finally {
            endSection()
        }
    }

    fun getStats(label: String): Stats? {
        val durations = metrics[label] ?: return null
        val sorted = durations.sorted()
        return Stats(
            label = label,
            count = sorted.size,
            minMs = sorted.first().toDouble(),
            maxMs = sorted.last().toDouble(),
            avgMs = sorted.average(),
            p95Ms = sorted[(sorted.size * 0.95).toInt().coerceAtMost(sorted.lastIndex)].toDouble()
        )
    }

    fun reportAll(): String = buildString {
        appendLine("=== Performance Report ===")
        metrics.keys.sorted().forEach { label ->
            getStats(label)?.let { stats ->
                appendLine(
                    "${stats.label}: count=${stats.count}, " +
                        "min=${stats.minMs}ms, max=${stats.maxMs}ms, " +
                        "avg=${"%.2f".format(stats.avgMs)}ms, " +
                        "p95=${stats.p95Ms}ms"
                )
            }
        }
    }

    fun clear() = metrics.clear()

    companion object {
        private const val TAG = "PerfTracker"
        val instance by lazy { PerformanceTracker() }
    }
}

// Reporting Time to Full Display manually
class MainActivity : ComponentActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // Tell the system to wait for reportFullyDrawn()
        // before considering startup complete
        setContentView(R.layout.activity_main)

        lifecycleScope.launch {
            val userData = loadUserData()
            val feedItems = loadFeedItems()

            displayContent(userData, feedItems)

            // Signal that the app is fully drawn and interactive
            reportFullyDrawn()
        }
    }
}

// Measure cold start from the command line:
// adb shell am force-stop com.example.myapp
// adb shell am start-activity -W -n com.example.myapp/.MainActivity
//
// Output:
// Status: ok
// LaunchState: COLD
// Activity: com.example.myapp/.MainActivity
// TotalTime: 487
// WaitTime: 489

class MyApplication : Application() {

    // ❌ Eager initialization — all of this runs during startup
    // val database = Room.databaseBuilder(this, AppDb::class.java, "app.db").build()
    // val retrofit = Retrofit.Builder().baseUrl(URL).build()
    // val analytics = Analytics.init(this)

    // ✅ Lazy initialization — runs only when first accessed
    val database by lazy {
        Room.databaseBuilder(this, AppDatabase::class.java, "app.db")
            .build()
    }

    val retrofit by lazy {
        Retrofit.Builder()
            .baseUrl(BASE_URL)
            .client(okHttpClient)
            .addConverterFactory(MoshiConverterFactory.create())
            .build()
    }

    val analytics by lazy(LazyThreadSafetyMode.NONE) {
        Analytics.Builder(this, ANALYTICS_KEY)
            .trackApplicationLifecycleEvents()
            .build()
    }

    override fun onCreate() {
        super.onCreate()
        // Only initialize what's absolutely required for first frame
        initCrashReporting() // Must be first to catch startup crashes
        initStrictMode()     // Debug-only, zero cost in release
    }
}

// App Startup library — consolidate ContentProvider initializations
class WorkManagerInitializer : Initializer<WorkManager> {
    override fun create(context: Context): WorkManager {
        val config = Configuration.Builder()
            .setMinimumLoggingLevel(Log.INFO)
            .build()
        WorkManager.initialize(context, config)
        return WorkManager.getInstance(context)
    }

    override fun dependencies(): List<Class<out Initializer<*>>> = emptyList()
}

class AnalyticsInitializer : Initializer<Analytics> {
    override fun create(context: Context): Analytics {
        return Analytics.Builder(context, BuildConfig.ANALYTICS_KEY)
            .build()
    }

    // Analytics depends on WorkManager being initialized first
    override fun dependencies(): List<Class<out Initializer<*>>> =
        listOf(WorkManagerInitializer::class.java)
}

class MainActivity : ComponentActivity() {

    private var isReady = false

    override fun onCreate(savedInstanceState: Bundle?) {
        val splashScreen = installSplashScreen()
        super.onCreate(savedInstanceState)

        // Keep the splash screen visible until data is loaded
        splashScreen.setKeepOnScreenCondition { !isReady }

        // Customize the exit animation
        splashScreen.setOnExitAnimationListener { splashScreenView ->
            val fadeOut = ObjectAnimator.ofFloat(
                splashScreenView.view,
                View.ALPHA,
                1f, 0f
            ).apply {
                duration = 300L
                interpolator = DecelerateInterpolator()
                doOnEnd { splashScreenView.remove() }
            }
            fadeOut.start()
        }

        setContent {
            val viewModel: MainViewModel = viewModel()
            val uiState by viewModel.uiState.collectAsStateWithLifecycle()

            LaunchedEffect(uiState) {
                if (uiState is UiState.Ready) {
                    isReady = true
                }
            }

            MyAppTheme {
                MainScreen(uiState)
            }
        }
    }
}

@HiltViewModel
class MainViewModel @Inject constructor(
    private val userRepository: UserRepository,
    private val feedRepository: FeedRepository
) : ViewModel() {

    private val _uiState = MutableStateFlow<UiState>(UiState.Loading)
    val uiState: StateFlow<UiState> = _uiState.asStateFlow()

    init {
        viewModelScope.launch {
            try {
                // Load cached data first for fast display
                val cachedUser = userRepository.getCachedUser()
                val cachedFeed = feedRepository.getCachedFeed()

                if (cachedUser != null && cachedFeed.isNotEmpty()) {
                    _uiState.value = UiState.Ready(cachedUser, cachedFeed)
                }

                // Then refresh from network in background
                val freshUser = userRepository.refreshUser()
                val freshFeed = feedRepository.refreshFeed()
                _uiState.value = UiState.Ready(freshUser, freshFeed)

            } catch (e: Exception) {
                _uiState.value = UiState.Error(e.message ?: "Unknown error")
            }
        }
    }
}

// res/values/themes.xml
// <style name="Theme.MyApp.Starting" parent="Theme.Material3.DayNight">
//     <item name="android:windowBackground">@drawable/starting_window</item>
//     <item name="android:windowDrawsSystemBarBackgrounds">true</item>
//     <item name="android:statusBarColor">@color/primary</item>
// </style>
//
// res/drawable/starting_window.xml
// <layer-list>
//     <item android:drawable="@color/surface" />
//     <item android:gravity="center"
//           android:width="48dp"
//           android:height="48dp"
//           android:drawable="@drawable/ic_app_logo" />
// </layer-list>

// In Activity — switch to the real theme before setContentView
class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        // Switch from starting window theme to actual app theme
        setTheme(R.style.Theme_MyApp)
        super.onCreate(savedInstanceState)
        setContent { MyApp() }
    }
}

// ViewStub — defer inflation of non-essential UI
class ProfileActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_profile)

        // Main profile info loads immediately
        displayBasicProfile(user)

        // Error view only inflates if needed
        if (hasError) {
            val errorStub = findViewById<ViewStub>(R.id.error_stub)
            val errorView = errorStub.inflate()
            errorView.findViewById<TextView>(R.id.error_message).text = errorMsg
        }
    }
}

class MyApplication : Application() {

    override fun onCreate() {
        super.onCreate()

        when (getProcessName()) {
            packageName -> initMainProcess()
            "$packageName:sync" -> initSyncProcess()
            "$packageName:notification" -> initNotificationProcess()
            else -> initMinimal()
        }
    }

    private fun initMainProcess() {
        // Full initialization for UI process
        initCrashReporting()
        initDependencyInjection()
        initAnalytics()
        initImageLoading()
    }

    private fun initSyncProcess() {
        // Minimal initialization for sync worker
        initCrashReporting()
        initDatabase()
        initNetworking()
    }

    private fun initNotificationProcess() {
        // Notification handling only
        initCrashReporting()
        initNotificationChannels()
    }

    private fun initMinimal() {
        initCrashReporting()
    }

    private fun getProcessName(): String {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
            return Application.getProcessName()
        }
        val pid = android.os.Process.myPid()
        val manager = getSystemService(ACTIVITY_SERVICE) as ActivityManager
        return manager.runningAppProcesses
            ?.firstOrNull { it.pid == pid }
            ?.processName ?: packageName
    }
}

class MyApplication : Application() {

    override fun onCreate() {
        super.onCreate()

        val startupScope = CoroutineScope(
            Dispatchers.Default + SupervisorJob()
        )

        // Launch independent initializations in parallel
        startupScope.launch {
            val dbJob = async { initDatabase() }
            val networkJob = async { initNetworking() }
            val analyticsJob = async { initAnalytics() }
            val imageJob = async { initImageLoading() }

            // Wait for critical path only
            dbJob.await()
            networkJob.await()

            // Non-critical can complete whenever
            // analyticsJob and imageJob continue in background
        }
    }
}

class MainActivity : ComponentActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // Track startup phases with custom trace points
        val startupTracer = StartupTracer()

        setContent {
            val viewModel: MainViewModel = viewModel()
            val uiState by viewModel.uiState.collectAsStateWithLifecycle()

            LaunchedEffect(uiState) {
                when (uiState) {
                    is UiState.Ready -> {
                        startupTracer.markFullyDrawn()
                        reportFullyDrawn()
                    }
                    else -> {}
                }
            }

            MyApp(uiState)
        }
    }
}

class StartupTracer {
    private val processStartTime = getProcessStartTime()
    private val phases = mutableMapOf<String, Long>()

    fun markPhase(name: String) {
        phases[name] = SystemClock.elapsedRealtime()
    }

    fun markFullyDrawn() {
        val totalTime = SystemClock.elapsedRealtime() - processStartTime
        Log.i(TAG, "Startup completed in ${totalTime}ms")
        phases.forEach { (name, time) ->
            Log.i(TAG, "  Phase $name: ${time - processStartTime}ms")
        }
        // Report to your analytics backend
        Analytics.trackStartup(totalTime, phases)
    }

    private fun getProcessStartTime(): Long {
        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
            val uptimeMs = SystemClock.elapsedRealtime()
            val processStartMs = android.os.Process.getStartElapsedRealtime()
            processStartMs
        } else {
            SystemClock.elapsedRealtime()
        }
    }

    companion object {
        private const val TAG = "StartupTracer"
    }
}

// Challenge: Build a StartupInitializer that:
// 1. Registers initialization tasks with dependencies
// 2. Runs independent tasks in parallel
// 3. Respects dependency ordering
// 4. Measures and reports timing for each task
// 5. Supports lazy (on-demand) vs eager initialization

class StartupInitializer(
    private val scope: CoroutineScope = CoroutineScope(Dispatchers.Default)
) {
    private val tasks = mutableMapOf<String, InitTask>()
    private val results = ConcurrentHashMap<String, Deferred<Any?>>()
    private val timings = ConcurrentHashMap<String, Long>()

    data class InitTask(
        val name: String,
        val dependencies: List<String> = emptyList(),
        val isLazy: Boolean = false,
        val block: suspend () -> Any?
    )

    fun register(
        name: String,
        dependencies: List<String> = emptyList(),
        lazy: Boolean = false,
        block: suspend () -> Any?
    ) {
        tasks[name] = InitTask(name, dependencies, lazy, block)
    }

    suspend fun initialize(): Map<String, Long> {
        val eagerTasks = tasks.filter { !it.value.isLazy }

        eagerTasks.forEach { (name, _) ->
            ensureStarted(name)
        }

        // Wait for all eager tasks
        eagerTasks.forEach { (name, _) ->
            results[name]?.await()
        }

        return timings.toMap()
    }

    private fun ensureStarted(name: String): Deferred<Any?> {
        return results.getOrPut(name) {
            val task = tasks[name]
                ?: throw IllegalArgumentException("Unknown task: $name")

            scope.async {
                // Wait for dependencies first
                task.dependencies.forEach { dep ->
                    ensureStarted(dep).await()
                }

                val startTime = SystemClock.elapsedRealtime()
                val result = task.block()
                timings[name] = SystemClock.elapsedRealtime() - startTime
                Log.d("Startup", "$name completed in ${timings[name]}ms")
                result
            }
        }
    }

    @Suppress("UNCHECKED_CAST")
    suspend fun <T> get(name: String): T {
        val deferred = ensureStarted(name)
        return deferred.await() as T
    }

    fun reportTimings(): String = buildString {
        appendLine("=== Startup Timing Report ===")
        timings.entries.sortedBy { it.value }.forEach { (name, time) ->
            appendLine("  $name: ${time}ms")
        }
        appendLine("  Total wall time: ${timings.values.maxOrNull() ?: 0}ms")
        appendLine("  Total CPU time: ${timings.values.sum()}ms")
    }
}

// Usage
class MyApplication : Application() {
    val initializer = StartupInitializer()

    override fun onCreate() {
        super.onCreate()

        initializer.register("crashReporting") {
            CrashReporter.init(this@MyApplication)
        }

        initializer.register("database") {
            Room.databaseBuilder(this@MyApplication, AppDb::class.java, "app.db").build()
        }

        initializer.register("networking", dependencies = listOf("crashReporting")) {
            OkHttpClient.Builder().build()
        }

        initializer.register("analytics", lazy = true) {
            Analytics.init(this@MyApplication)
        }

        CoroutineScope(Dispatchers.Main.immediate).launch {
            val timings = initializer.initialize()
            Log.i("Startup", initializer.reportTimings())
        }
    }
}

// Monitor memory usage in your app
fun logMemoryState() {
    val runtime = Runtime.getRuntime()
    val maxMemory = runtime.maxMemory() / 1024 / 1024 // MB
    val totalMemory = runtime.totalMemory() / 1024 / 1024
    val freeMemory = runtime.freeMemory() / 1024 / 1024
    val usedMemory = totalMemory - freeMemory

    Log.d("Memory", buildString {
        appendLine("Max heap: ${maxMemory}MB")
        appendLine("Allocated: ${totalMemory}MB")
        appendLine("Used: ${usedMemory}MB")
        appendLine("Free: ${freeMemory}MB")
        appendLine("Usage: ${usedMemory * 100 / maxMemory}%")
    })
}

// React to system memory pressure
class MyApplication : Application() {
    override fun onTrimMemory(level: Int) {
        super.onTrimMemory(level)
        when (level) {
            TRIM_MEMORY_RUNNING_LOW -> {
                // App is running but system is low on memory
                imageCache.trimToSize(imageCache.size() / 2)
            }
            TRIM_MEMORY_RUNNING_CRITICAL -> {
                // System is critically low — release everything possible
                imageCache.evictAll()
                dataCache.clear()
            }
            TRIM_MEMORY_UI_HIDDEN -> {
                // App went to background — release UI resources
                imageCache.trimToSize(imageCache.size() / 4)
            }
        }
    }
}

// ❌ Memory leak — anonymous Runnable holds reference to Activity
class LeakyActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // This Runnable holds an implicit reference to LeakyActivity
        // If the Activity is destroyed before 10 seconds, it leaks
        Handler(Looper.getMainLooper()).postDelayed({
            updateUI() // 'this' reference to Activity
        }, 10_000)
    }
}

// ✅ Fixed — use lifecycleScope which cancels with Activity
class SafeActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        lifecycleScope.launch {
            delay(10_000)
            updateUI() // Automatically cancelled if Activity is destroyed
        }
    }
}

// ❌ Memory leak — singleton holds Activity reference
object ImageLoader {
    private var context: Context? = null // Holds Activity context!

    fun init(context: Context) {
        this.context = context // If Activity context, it leaks
    }
}

// ✅ Fixed — use Application context for singletons
object ImageLoader {
    private var context: Context? = null

    fun init(context: Context) {
        this.context = context.applicationContext // Never leaks
    }
}

// build.gradle.kts
dependencies {
    debugImplementation("com.squareup.leakcanary:leakcanary-android:2.14")
}

// LeakCanary starts automatically — no code needed
// It watches:
// - Activities after onDestroy()
// - Fragments after onDestroyView() and onDestroy()
// - ViewModels after onCleared()
// - Views after they're removed from the window

// Custom object watching — for objects you know should be GC'd
class SessionManager {
    fun logout() {
        val currentSession = session
        session = null

        // Tell LeakCanary to watch this object
        AppWatcher.objectWatcher.expectWeaklyReachable(
            currentSession,
            "Session should be GC'd after logout"
        )
    }
}

// Calculate the optimal sample size for a target view size
fun decodeSampledBitmap(
    resources: Resources,
    resId: Int,
    reqWidth: Int,
    reqHeight: Int
): Bitmap {
    // First, decode bounds only (no memory allocation)
    val options = BitmapFactory.Options().apply {
        inJustDecodeBounds = true
    }
    BitmapFactory.decodeResource(resources, resId, options)

    // Calculate inSampleSize
    options.apply {
        inSampleSize = calculateInSampleSize(this, reqWidth, reqHeight)
        inJustDecodeBounds = false
        inPreferredConfig = Bitmap.Config.RGB_565 // Half memory if no alpha
    }

    return BitmapFactory.decodeResource(resources, resId, options)
}

fun calculateInSampleSize(
    options: BitmapFactory.Options,
    reqWidth: Int,
    reqHeight: Int
): Int {
    val (height, width) = options.outHeight to options.outWidth
    var inSampleSize = 1

    if (height > reqHeight || width > reqWidth) {
        val halfHeight = height / 2
        val halfWidth = width / 2

        while (halfHeight / inSampleSize >= reqHeight &&
               halfWidth / inSampleSize >= reqWidth) {
            inSampleSize *= 2
        }
    }

    return inSampleSize
}

// Coil — modern Kotlin-first image loading
// In Compose
@Composable
fun UserAvatar(imageUrl: String) {
    AsyncImage(
        model = ImageRequest.Builder(LocalContext.current)
            .data(imageUrl)
            .crossfade(true)
            .size(Size(200, 200)) // Request exact size
            .memoryCachePolicy(CachePolicy.ENABLED)
            .diskCachePolicy(CachePolicy.ENABLED)
            .build(),
        contentDescription = "User avatar",
        modifier = Modifier
            .size(48.dp)
            .clip(CircleShape),
        contentScale = ContentScale.Crop
    )
}

// Coil with custom memory cache size
class MyApplication : Application(), ImageLoaderFactory {
    override fun newImageLoader(): ImageLoader {
        return ImageLoader.Builder(this)
            .memoryCache {
                MemoryCache.Builder(this)
                    .maxSizePercent(0.20) // 20% of available memory
                    .build()
            }
            .diskCache {
                DiskCache.Builder()
                    .directory(cacheDir.resolve("image_cache"))
                    .maxSizeBytes(100L * 1024 * 1024) // 100MB
                    .build()
            }
            .build()
    }
}

// ❌ Allocations inside onDraw — creates GC pressure
class CustomView(context: Context) : View(context) {
    override fun onDraw(canvas: Canvas) {
        val paint = Paint()  // New allocation every frame
        val rect = RectF()   // New allocation every frame
        val path = Path()    // New allocation every frame

        paint.color = Color.BLUE
        rect.set(0f, 0f, width.toFloat(), height.toFloat())
        canvas.drawRect(rect, paint)
    }
}

// ✅ Pre-allocate and reuse objects
class CustomView(context: Context) : View(context) {
    private val paint = Paint().apply { color = Color.BLUE }
    private val rect = RectF()
    private val path = Path()

    override fun onDraw(canvas: Canvas) {
        rect.set(0f, 0f, width.toFloat(), height.toFloat())
        path.reset() // Reuse by resetting
        canvas.drawRect(rect, paint)
    }
}

// Generic object pool implementation
class ObjectPool<T>(
    private val maxSize: Int = 20,
    private val factory: () -> T,
    private val reset: (T) -> Unit = {}
) {
    private val pool = ArrayDeque<T>(maxSize)

    fun obtain(): T {
        return synchronized(pool) {
            pool.removeLastOrNull()
        } ?: factory()
    }

    fun recycle(obj: T) {
        reset(obj)
        synchronized(pool) {
            if (pool.size < maxSize) {
                pool.addLast(obj)
            }
        }
    }

    inline fun <R> use(block: (T) -> R): R {
        val obj = obtain()
        try {
            return block(obj)
        } finally {
            recycle(obj)
        }
    }
}

// Usage — pool of Rect objects for drawing
class ChartView(context: Context) : View(context) {
    private val rectPool = ObjectPool(
        maxSize = 50,
        factory = { RectF() },
        reset = { it.setEmpty() }
    )

    override fun onDraw(canvas: Canvas) {
        for (bar in chartData) {
            rectPool.use { rect ->
                rect.set(bar.left, bar.top, bar.right, bar.bottom)
                canvas.drawRect(rect, barPaint)
            }
        }
    }
}

// WeakReference — useful for breaking reference cycles and caches
// that shouldn't prevent GC
class EventBus {
    // Listeners are held weakly — if the subscriber is GC'd,
    // the reference becomes null automatically
    private val listeners = mutableListOf<WeakReference<EventListener>>()

    fun subscribe(listener: EventListener) {
        listeners.add(WeakReference(listener))
    }

    fun publish(event: Event) {
        val iterator = listeners.iterator()
        while (iterator.hasNext()) {
            val ref = iterator.next()
            val listener = ref.get()
            if (listener != null) {
                listener.onEvent(event)
            } else {
                iterator.remove() // Clean up dead references
            }
        }
    }
}

// SoftReference — useful for memory-sensitive caches
class BitmapCache(private val maxEntries: Int = 100) {
    private val cache = LinkedHashMap<String, SoftReference<Bitmap>>(
        maxEntries, 0.75f, true // accessOrder = true for LRU
    )

    fun put(key: String, bitmap: Bitmap) {
        cache[key] = SoftReference(bitmap)
        if (cache.size > maxEntries) {
            val eldest = cache.entries.first()
            cache.remove(eldest.key)
        }
    }

    fun get(key: String): Bitmap? {
        val ref = cache[key] ?: return null
        val bitmap = ref.get()
        if (bitmap == null) {
            cache.remove(key) // Referent was GC'd
        }
        return bitmap
    }
}

// LruCache — predictable memory-bounded cache
class ThumbnailCache : LruCache<String, Bitmap>(calculateMaxSize()) {

    override fun sizeOf(key: String, bitmap: Bitmap): Int {
        return bitmap.byteCount // Size in bytes
    }

    override fun entryRemoved(
        evicted: Boolean,
        key: String,
        oldValue: Bitmap,
        newValue: Bitmap?
    ) {
        // Optionally move evicted entries to a disk cache
        if (evicted) {
            diskCache.put(key, oldValue)
        }
    }

    companion object {
        private fun calculateMaxSize(): Int {
            val maxMemory = Runtime.getRuntime().maxMemory() / 1024
            return (maxMemory / 8).toInt() // 1/8th of available memory
        }
    }
}

// Using Debug class for programmatic heap analysis
fun analyzeHeapHealth(): HeapReport {
    // Force GC before analysis to get accurate numbers
    Runtime.getRuntime().gc()
    Thread.sleep(100) // Give GC time to complete

    val runtime = Runtime.getRuntime()
    val nativeHeap = Debug.getNativeHeapSize()
    val nativeAllocated = Debug.getNativeHeapAllocatedSize()

    return HeapReport(
        javaHeapMax = runtime.maxMemory(),
        javaHeapAllocated = runtime.totalMemory(),
        javaHeapUsed = runtime.totalMemory() - runtime.freeMemory(),
        nativeHeapTotal = nativeHeap,
        nativeHeapUsed = nativeAllocated,
        gcCount = Debug.getRuntimeStat("art.gc.gc-count")?.toLongOrNull() ?: 0,
        gcTime = Debug.getRuntimeStat("art.gc.gc-time")?.toLongOrNull() ?: 0
    )
}

data class HeapReport(
    val javaHeapMax: Long,
    val javaHeapAllocated: Long,
    val javaHeapUsed: Long,
    val nativeHeapTotal: Long,
    val nativeHeapUsed: Long,
    val gcCount: Long,
    val gcTime: Long
) {
    val javaUsagePercent: Int
        get() = ((javaHeapUsed * 100) / javaHeapMax).toInt()

    val isUnderPressure: Boolean
        get() = javaUsagePercent > 80

    override fun toString(): String = buildString {
        appendLine("Java Heap: ${javaHeapUsed / 1024 / 1024}MB / ${javaHeapMax / 1024 / 1024}MB (${javaUsagePercent}%)")
        appendLine("Native Heap: ${nativeHeapUsed / 1024 / 1024}MB / ${nativeHeapTotal / 1024 / 1024}MB")
        appendLine("GC Count: $gcCount, Total GC Time: ${gcTime}ms")
        if (isUnderPressure) appendLine("⚠️ Memory pressure detected!")
    }
}

// Challenge: Implement a TwoLevelImageCache that:
// 1. Stores bitmaps in an LruCache (memory) with configurable size
// 2. Falls back to disk cache on memory miss
// 3. Responds to system memory pressure by evicting entries
// 4. Tracks hit/miss statistics
// 5. Supports async loading with coroutines

class TwoLevelImageCache(
    context: Context,
    memoryCacheSizeBytes: Int = calculateDefaultMemoryCacheSize(),
    private val diskCacheDir: File = File(context.cacheDir, "images"),
    private val diskCacheMaxBytes: Long = 50L * 1024 * 1024
) {
    private var memoryHits = 0L
    private var diskHits = 0L
    private var misses = 0L

    private val memoryCache = object : LruCache<String, Bitmap>(memoryCacheSizeBytes) {
        override fun sizeOf(key: String, value: Bitmap): Int = value.byteCount
    }

    init {
        diskCacheDir.mkdirs()
    }

    fun get(key: String): Bitmap? {
        // Level 1: Memory cache
        memoryCache.get(key)?.let {
            memoryHits++
            return it
        }

        // Level 2: Disk cache
        val diskFile = File(diskCacheDir, key.hashCode().toString())
        if (diskFile.exists()) {
            val bitmap = BitmapFactory.decodeFile(diskFile.absolutePath)
            if (bitmap != null) {
                diskHits++
                memoryCache.put(key, bitmap) // Promote to memory
                return bitmap
            }
        }

        misses++
        return null
    }

    suspend fun getOrLoad(
        key: String,
        loader: suspend () -> Bitmap
    ): Bitmap = withContext(Dispatchers.IO) {
        get(key) ?: loader().also { bitmap -> put(key, bitmap) }
    }

    fun put(key: String, bitmap: Bitmap) {
        memoryCache.put(key, bitmap)

        // Write to disk asynchronously
        CoroutineScope(Dispatchers.IO).launch {
            val diskFile = File(diskCacheDir, key.hashCode().toString())
            diskFile.outputStream().use { out ->
                bitmap.compress(Bitmap.CompressFormat.PNG, 90, out)
            }
            trimDiskCache()
        }
    }

    fun onTrimMemory(level: Int) {
        when {
            level >= ComponentCallbacks2.TRIM_MEMORY_MODERATE -> {
                memoryCache.evictAll()
            }
            level >= ComponentCallbacks2.TRIM_MEMORY_RUNNING_LOW -> {
                memoryCache.trimToSize(memoryCache.maxSize() / 2)
            }
            level >= ComponentCallbacks2.TRIM_MEMORY_BACKGROUND -> {
                memoryCache.trimToSize(memoryCache.maxSize() / 4)
            }
        }
    }

    private fun trimDiskCache() {
        val files = diskCacheDir.listFiles() ?: return
        val totalSize = files.sumOf { it.length() }
        if (totalSize > diskCacheMaxBytes) {
            files.sortedBy { it.lastModified() }
                .take(files.size / 4)
                .forEach { it.delete() }
        }
    }

    fun getStats(): String = buildString {
        val total = memoryHits + diskHits + misses
        appendLine("Cache Stats (total: $total)")
        appendLine("  Memory hits: $memoryHits (${percent(memoryHits, total)}%)")
        appendLine("  Disk hits: $diskHits (${percent(diskHits, total)}%)")
        appendLine("  Misses: $misses (${percent(misses, total)}%)")
        appendLine("  Memory size: ${memoryCache.size() / 1024}KB / ${memoryCache.maxSize() / 1024}KB")
    }

    private fun percent(value: Long, total: Long): Long =
        if (total > 0) value * 100 / total else 0

    companion object {
        private fun calculateDefaultMemoryCacheSize(): Int {
            val maxMemory = Runtime.getRuntime().maxMemory() / 1024
            return (maxMemory / 8).toInt() // 1/8th of available memory
        }
    }
}

// Monitoring frame timing with FrameMetrics (API 24+)
class PerformanceMonitorActivity : AppCompatActivity() {

    private val frameMetricsListener = Window.OnFrameMetricsAvailableListener {
        _, frameMetrics, _ ->
        val totalDurationMs = frameMetrics.getMetric(
            FrameMetrics.TOTAL_DURATION
        ) / 1_000_000.0 // Convert nanos to ms

        val layoutMeasureDuration = frameMetrics.getMetric(
            FrameMetrics.LAYOUT_MEASURE_DURATION
        ) / 1_000_000.0

        val drawDuration = frameMetrics.getMetric(
            FrameMetrics.DRAW_DURATION
        ) / 1_000_000.0

        val syncDuration = frameMetrics.getMetric(
            FrameMetrics.SYNC_DURATION
        ) / 1_000_000.0

        if (totalDurationMs > 16.67) {
            Log.w("FrameMetrics", buildString {
                append("Slow frame: ${totalDurationMs.format(2)}ms")
                append(" | Layout: ${layoutMeasureDuration.format(2)}ms")
                append(" | Draw: ${drawDuration.format(2)}ms")
                append(" | Sync: ${syncDuration.format(2)}ms")
            })
        }
    }

    override fun onResume() {
        super.onResume()
        window.addOnFrameMetricsAvailableListener(
            frameMetricsListener,
            Handler(Looper.getMainLooper())
        )
    }

    override fun onPause() {
        super.onPause()
        window.removeOnFrameMetricsAvailableListener(frameMetricsListener)
    }

    private fun Double.format(digits: Int) = "%.${digits}f".format(this)
}

// ❌ Unnecessary overdraw — window background + layout background
// <FrameLayout android:background="@color/white">
//     <CardView android:background="@color/white">
//         <TextView android:text="Hello" />
//     </CardView>
// </FrameLayout>

// ✅ Remove redundant backgrounds
// Set window background to match content and remove child backgrounds
// In theme: <item name="android:windowBackground">@color/white</item>
// <FrameLayout> <!-- No background needed, inherits window -->
//     <CardView> <!-- CardView has its own elevation drawing -->
//         <TextView android:text="Hello" />
//     </CardView>
// </FrameLayout>

// Programmatically remove window background when not needed
class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // Remove window background if your layout covers full screen
        window.setBackgroundDrawable(null)
    }
}

// ❌ Deep nesting — exponential measure cost
// <LinearLayout orientation="vertical">
//     <LinearLayout orientation="horizontal">
//         <ImageView />
//         <LinearLayout orientation="vertical">
//             <TextView /> <!-- Name -->
//             <LinearLayout orientation="horizontal">
//                 <TextView /> <!-- Date -->
//                 <TextView /> <!-- Time -->
//             </LinearLayout>
//         </LinearLayout>
//     </LinearLayout>
// </LinearLayout>

// ✅ Flat with ConstraintLayout — linear measure cost
// <ConstraintLayout>
//     <ImageView
//         app:layout_constraintStart_toStartOf="parent"
//         app:layout_constraintTop_toTopOf="parent" />
//     <TextView  <!-- Name -->
//         app:layout_constraintStart_toEndOf="@id/image"
//         app:layout_constraintTop_toTopOf="parent" />
//     <TextView  <!-- Date -->
//         app:layout_constraintStart_toEndOf="@id/image"
//         app:layout_constraintTop_toBottomOf="@id/name" />
//     <TextView  <!-- Time -->
//         app:layout_constraintStart_toEndOf="@id/date"
//         app:layout_constraintTop_toBottomOf="@id/name" />
// </ConstraintLayout>

// Use Layout Inspector to analyze hierarchy in real-time
// Android Studio → Layout Inspector → Select running process
// Examine: view count, hierarchy depth, measure/layout time per view

// ViewStub usage for deferred layouts
class ProductDetailActivity : AppCompatActivity() {

    private var reviewsInflated = false

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_product_detail)

        // Product info loads immediately — this is the critical path
        displayProductInfo(product)

        // Reviews section inflates only when user scrolls to it
        val scrollView = findViewById<NestedScrollView>(R.id.scroll_view)
        scrollView.setOnScrollChangeListener { _, _, scrollY, _, _ ->
            if (!reviewsInflated && scrollY > reviewsThreshold) {
                val stub = findViewById<ViewStub>(R.id.reviews_stub)
                val reviewsView = stub.inflate()
                populateReviews(reviewsView)
                reviewsInflated = true
            }
        }
    }
}

// RecyclerView performance configuration
class FeedFragment : Fragment() {

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        val recyclerView = view.findViewById<RecyclerView>(R.id.feed_list)

        recyclerView.apply {
            // Increase cache size for smoother reverse scrolling
            setItemViewCacheSize(10)

            // Share view pool across multiple RecyclerViews
            recycledViewPool = sharedViewPool

            // Fixed size optimization — skip unnecessary measure passes
            setHasFixedSize(true)

            // Prefetch items during scroll deceleration
            (layoutManager as LinearLayoutManager).apply {
                initialPrefetchItemCount = 4
            }
        }
    }

    companion object {
        // Share across RecyclerViews that use the same view types
        val sharedViewPool = RecyclerView.RecycledViewPool().apply {
            setMaxRecycledViews(VIEW_TYPE_CARD, 15)
            setMaxRecycledViews(VIEW_TYPE_HEADER, 5)
        }
    }
}

// ❌ Expensive operations in onBindViewHolder
class SlowAdapter : RecyclerView.Adapter<SlowAdapter.ViewHolder>() {
    override fun onBindViewHolder(holder: ViewHolder, position: Int) {
        val item = items[position]

        // ❌ Date formatting on main thread
        val dateFormat = SimpleDateFormat("MMM dd, yyyy", Locale.getDefault())
        holder.dateText.text = dateFormat.format(item.date)

        // ❌ Image loading synchronously
        val bitmap = BitmapFactory.decodeFile(item.imagePath)
        holder.image.setImageBitmap(bitmap)

        // ❌ Complex text processing
        holder.description.text = HtmlCompat.fromHtml(
            item.htmlDescription, HtmlCompat.FROM_HTML_MODE_COMPACT
        )
    }
}

// ✅ Minimal work in onBindViewHolder
class FastAdapter : ListAdapter<UiItem, FastAdapter.ViewHolder>(UiItemDiff) {

    override fun onBindViewHolder(holder: ViewHolder, position: Int) {
        val item = getItem(position)

        // Pre-computed values — just assign
        holder.dateText.text = item.formattedDate
        holder.description.text = item.processedDescription

        // Async image loading
        Coil.imageLoader(holder.itemView.context)
            .enqueue(
                ImageRequest.Builder(holder.itemView.context)
                    .data(item.imageUrl)
                    .target(holder.image)
                    .size(THUMBNAIL_SIZE)
                    .build()
            )
    }
}

// Pre-compute in the mapping layer
fun Post.toUiItem(): UiItem {
    val dateFormatter = DateTimeFormatter.ofPattern("MMM dd, yyyy")
    return UiItem(
        id = id,
        formattedDate = dateFormatter.format(createdAt),
        processedDescription = HtmlCompat.fromHtml(
            htmlDescription, HtmlCompat.FROM_HTML_MODE_COMPACT
        ),
        imageUrl = thumbnailUrl
    )
}

class ProgressRingView(
    context: Context,
    attrs: AttributeSet? = null
) : View(context, attrs) {

    // Pre-allocate all drawing objects
    private val backgroundPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
        style = Paint.Style.STROKE
        strokeWidth = 12f.dpToPx()
        color = Color.parseColor("#E0E0E0")
        strokeCap = Paint.Cap.ROUND
    }

    private val progressPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
        style = Paint.Style.STROKE
        strokeWidth = 12f.dpToPx()
        color = Color.parseColor("#2196F3")
        strokeCap = Paint.Cap.ROUND
    }

    private val textPaint = Paint(Paint.ANTI_ALIAS_FLAG).apply {
        textSize = 32f.dpToPx()
        textAlign = Paint.Align.CENTER
        color = Color.BLACK
    }

    private val arcRect = RectF()
    private val textBounds = Rect()

    var progress: Float = 0f
        set(value) {
            field = value.coerceIn(0f, 1f)
            invalidate() // Only invalidate when value changes
        }

    override fun onSizeChanged(w: Int, h: Int, oldw: Int, oldh: Int) {
        val padding = progressPaint.strokeWidth / 2
        arcRect.set(padding, padding, w - padding, h - padding)
    }

    override fun onDraw(canvas: Canvas) {
        // Background ring
        canvas.drawArc(arcRect, 0f, 360f, false, backgroundPaint)

        // Progress arc
        val sweepAngle = progress * 360f
        canvas.drawArc(arcRect, -90f, sweepAngle, false, progressPaint)

        // Percentage text
        val text = "${(progress * 100).toInt()}%"
        textPaint.getTextBounds(text, 0, text.length, textBounds)
        canvas.drawText(
            text,
            arcRect.centerX(),
            arcRect.centerY() + textBounds.height() / 2f,
            textPaint
        )
    }

    private fun Float.dpToPx(): Float =
        this * resources.displayMetrics.density
}

// Using hardware layers for smooth animation
fun animateCardExit(cardView: View) {
    // Enable hardware layer before animation
    cardView.setLayerType(View.LAYER_TYPE_HARDWARE, null)

    cardView.animate()
        .translationX(cardView.width.toFloat())
        .alpha(0f)
        .setDuration(300)
        .setInterpolator(AccelerateInterpolator())
        .withEndAction {
            // Remove hardware layer after animation
            cardView.setLayerType(View.LAYER_TYPE_NONE, null)
            cardView.visibility = View.GONE
        }
        .start()
}

// ✅ Smooth animation with ObjectAnimator
fun pulseAnimation(view: View) {
    val scaleX = PropertyValuesHolder.ofFloat(View.SCALE_X, 1f, 1.1f, 1f)
    val scaleY = PropertyValuesHolder.ofFloat(View.SCALE_Y, 1f, 1.1f, 1f)

    ObjectAnimator.ofPropertyValuesHolder(view, scaleX, scaleY).apply {
        duration = 600
        interpolator = OvershootInterpolator()
        repeatCount = ValueAnimator.INFINITE
        repeatMode = ValueAnimator.RESTART
        start()
    }
}

// ✅ Complex animation with AnimatorSet
fun enterAnimation(
    title: View,
    subtitle: View,
    content: View,
    button: View
) {
    val views = listOf(title, subtitle, content, button)
    views.forEach { it.alpha = 0f; it.translationY = 50f.dpToPx() }

    val animators = views.mapIndexed { index, view ->
        AnimatorSet().apply {
            playTogether(
                ObjectAnimator.ofFloat(view, View.ALPHA, 0f, 1f),
                ObjectAnimator.ofFloat(view, View.TRANSLATION_Y, 50f.dpToPx(), 0f)
            )
            startDelay = index * 100L
            duration = 400
            interpolator = DecelerateInterpolator(2f)
        }
    }

    AnimatorSet().apply {
        playTogether(animators)
        start()
    }
}

// ❌ Animating layout properties — triggers layout every frame
ObjectAnimator.ofInt(view, "width", startWidth, endWidth).apply {
    duration = 300
    addUpdateListener { view.requestLayout() } // Layout every frame!
    start()
}

// ✅ Animating render properties — GPU only, no layout pass
ObjectAnimator.ofFloat(view, View.SCALE_X, 1f, 0.5f).apply {
    duration = 300
    start()
}

// ✅ If you must animate size, use scaleX/scaleY with pivotX/pivotY
fun collapseAnimation(view: View) {
    view.pivotY = 0f // Scale from top
    ObjectAnimator.ofFloat(view, View.SCALE_Y, 1f, 0f).apply {
        duration = 300
        interpolator = FastOutSlowInInterpolator()
        doOnEnd { view.visibility = View.GONE }
        start()
    }
}

// StrictMode helps detect rendering violations in development
class DebugApplication : Application() {
    override fun onCreate() {
        super.onCreate()

        if (BuildConfig.DEBUG) {
            StrictMode.setThreadPolicy(
                StrictMode.ThreadPolicy.Builder()
                    .detectDiskReads()
                    .detectDiskWrites()
                    .detectNetwork()
                    .detectCustomSlowCalls()
                    .penaltyLog()
                    .penaltyFlashScreen() // Red flash on violations
                    .build()
            )

            StrictMode.setVmPolicy(
                StrictMode.VmPolicy.Builder()
                    .detectLeakedSqlLiteObjects()
                    .detectLeakedClosableObjects()
                    .detectActivityLeaks()
                    .penaltyLog()
                    .build()
            )
        }
    }
}

// JankStats API — detect jank in production
class JankMonitorActivity : AppCompatActivity() {

    private lateinit var jankStats: JankStats

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        jankStats = JankStats.createAndTrack(window) { frameData ->
            if (frameData.isJank) {
                val durationMs = frameData.frameDurationUiNanos / 1_000_000.0
                Log.w("Jank", buildString {
                    append("Jank detected: ${durationMs}ms")
                    frameData.states.forEach { state ->
                        append(" | ${state.key}=${state.value}")
                    }
                })

                // Report to analytics
                analytics.trackJank(durationMs, frameData.states)
            }
        }
    }

    override fun onResume() {
        super.onResume()
        jankStats.isTrackingEnabled = true
    }

    override fun onPause() {
        super.onPause()
        jankStats.isTrackingEnabled = false
    }
}

// Challenge: Build a JankDetector that:
// 1. Monitors frame times using Choreographer.FrameCallback
// 2. Detects dropped frames (> 16.67ms between callbacks)
// 3. Tracks jank frequency and severity
// 4. Identifies jank patterns (e.g., jank during scrolling vs idle)
// 5. Reports top jank causes with timestamps

class JankDetector(
    private val targetFps: Int = 60,
    private val onJankDetected: (JankEvent) -> Unit = {}
) : Choreographer.FrameCallback {

    private val framebudgetNs = 1_000_000_000L / targetFps
    private var previousFrameNs = 0L
    private var isRunning = false
    private val jankHistory = mutableListOf<JankEvent>()
    private var currentState = "idle"

    data class JankEvent(
        val timestamp: Long,
        val durationMs: Double,
        val droppedFrames: Int,
        val state: String
    )

    data class JankReport(
        val totalFrames: Long,
        val jankyFrames: Int,
        val jankPercentage: Double,
        val averageJankMs: Double,
        val worstJankMs: Double,
        val jankByState: Map<String, Int>
    )

    private var totalFrames = 0L

    fun start() {
        if (isRunning) return
        isRunning = true
        previousFrameNs = 0L
        Choreographer.getInstance().postFrameCallback(this)
    }

    fun stop() {
        isRunning = false
        Choreographer.getInstance().removeFrameCallback(this)
    }

    fun setState(state: String) {
        currentState = state
    }

    override fun doFrame(frameTimeNanos: Long) {
        if (!isRunning) return

        if (previousFrameNs > 0) {
            totalFrames++
            val frameDurationNs = frameTimeNanos - previousFrameNs
            val droppedFrames = ((frameDurationNs / framebudgetNs) - 1)
                .coerceAtLeast(0).toInt()

            if (droppedFrames > 0) {
                val durationMs = frameDurationNs / 1_000_000.0
                val event = JankEvent(
                    timestamp = System.currentTimeMillis(),
                    durationMs = durationMs,
                    droppedFrames = droppedFrames,
                    state = currentState
                )
                jankHistory.add(event)
                onJankDetected(event)
            }
        }

        previousFrameNs = frameTimeNanos
        Choreographer.getInstance().postFrameCallback(this)
    }

    fun getReport(): JankReport {
        val jankyFrames = jankHistory.size
        return JankReport(
            totalFrames = totalFrames,
            jankyFrames = jankyFrames,
            jankPercentage = if (totalFrames > 0)
                jankyFrames * 100.0 / totalFrames else 0.0,
            averageJankMs = if (jankyFrames > 0)
                jankHistory.map { it.durationMs }.average() else 0.0,
            worstJankMs = jankHistory.maxOfOrNull { it.durationMs } ?: 0.0,
            jankByState = jankHistory.groupBy { it.state }
                .mapValues { it.value.size }
        )
    }

    fun clearHistory() {
        jankHistory.clear()
        totalFrames = 0
    }
}

// ❌ Reading state during composition — recomposes on every change
@Composable
fun AnimatedBox(offset: State<Float>) {
    // Reading offset.value here means this composable recomposes
    // every time offset changes (every animation frame)
    Box(
        modifier = Modifier
            .offset(x = offset.value.dp) // Read during composition
            .size(50.dp)
            .background(Color.Blue)
    )
}

// ✅ Deferring state read to layout phase — skips recomposition
@Composable
fun AnimatedBox(offset: State<Float>) {
    Box(
        modifier = Modifier
            .offset { // Lambda — read deferred to layout phase
                IntOffset(offset.value.roundToInt(), 0)
            }
            .size(50.dp)
            .background(Color.Blue)
    )
}

// ✅ Reading state in draw phase — cheapest option
@Composable
fun AnimatedCircle(color: State<Color>) {
    Canvas(modifier = Modifier.size(100.dp)) {
        // Color is read during draw phase only
        drawCircle(color = color.value)
    }
}

// Layout Inspector in Android Studio shows recomposition counts
// Enable: Layout Inspector → Toggle "Show Recomposition Counts"
// Each composable shows how many times it recomposed and skipped

// Use Composition Local to pass data without recomposition propagation
val LocalThemeColors = compositionLocalOf { defaultColors }

@Composable
fun ThemedApp(isDarkMode: Boolean) {
    val colors = if (isDarkMode) darkColors else lightColors

    CompositionLocalProvider(LocalThemeColors provides colors) {
        // Child composables read colors from CompositionLocal
        // They don't recompose when isDarkMode changes —
        // only composables that actually READ LocalThemeColors recompose
        AppContent()
    }
}

// ❌ Unstable parameter — this composable can NEVER be skipped
@Composable
fun UserList(users: List<User>) { // List is unstable
    LazyColumn {
        items(users) { user ->
            UserRow(user)
        }
    }
}

// ✅ Stable — use ImmutableList from kotlinx.collections.immutable
@Composable
fun UserList(users: ImmutableList<User>) { // ImmutableList is stable
    LazyColumn {
        items(users) { user ->
            UserRow(user)
        }
    }
}

// Alternative: annotate with @Immutable
@Immutable
data class UserListState(
    val users: List<User>, // Now treated as stable
    val isLoading: Boolean,
    val error: String?
)

// Or use @Stable for types with identity-based equality
@Stable
class AnimationState {
    var progress by mutableFloatStateOf(0f)
    var isRunning by mutableStateOf(false)
}