App Startup & Lazy Init

Copy code<!-- What WorkManager, Firebase, etc. used to do internally -->
<provider
    android:name="androidx.work.impl.WorkManagerInitializer"
    android:authorities="${applicationId}.workmanager-init"
    android:exported="false"
    android:multiprocess="true" />

Copy code// build.gradle.kts
implementation("androidx.startup:startup-runtime:1.1.1")

Copy code// TimberInitializer.kt
class TimberInitializer : Initializer<Unit> {

    override fun create(context: Context): Unit {
        if (BuildConfig.DEBUG) {
            Timber.plant(Timber.DebugTree())
        } else {
            Timber.plant(CrashReportingTree())
        }
        return Unit
    }

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

// AnalyticsInitializer depends on Timber being ready first
class AnalyticsInitializer : Initializer<AnalyticsTracker> {

    override fun create(context: Context): AnalyticsTracker {
        return AnalyticsTracker.init(context) // returns singleton
    }

    override fun dependencies(): List<Class<out Initializer<*>>> =
        listOf(TimberInitializer::class.java)  // runs after Timber
}

// WorkManagerInitializer (disable WorkManager's own ContentProvider)
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()
}

Copy code<!-- AndroidManifest.xml -->
<provider
    android:name="androidx.startup.InitializationProvider"
    android:authorities="${applicationId}.androidx-startup"
    android:exported="false"
    tools:node="merge">

    <!-- Auto-init: runs during ContentProvider creation -->
    <meta-data
        android:name="com.example.TimberInitializer"
        android:value="androidx.startup" />
    <meta-data
        android:name="com.example.AnalyticsInitializer"
        android:value="androidx.startup" />

    <!-- Disable WorkManager's own ContentProvider -->
    <meta-data
        android:name="androidx.work.WorkManagerInitializer"
        android:value="androidx.startup"
        tools:node="remove" />
</provider>

Copy code<!-- Mark as manual-only: remove from auto-init -->
<meta-data
    android:name="com.example.WorkManagerInitializer"
    android:value="androidx.startup"
    tools:node="remove" />

Copy code// Initialize later (e.g., after first screen is displayed)
class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // Show first screen immediately...

        // Defer non-critical initialization
        lifecycleScope.launch {
            delay(500) // or after onWindowFocusChanged
            AppInitializer.getInstance(this@MainActivity)
                .initializeComponent(WorkManagerInitializer::class.java)
        }
    }
}

Copy code// Thread-safe by default (LazyThreadSafetyMode.SYNCHRONIZED)
private val database: AppDatabase by lazy {
    Room.databaseBuilder(context, AppDatabase::class.java, "app_db").build()
}

// Main-thread-only singleton (no synchronization overhead)
private val adapter: ArticleAdapter by lazy(LazyThreadSafetyMode.NONE) {
    ArticleAdapter()
}

// Custom initialization mode
class HeavyFeatureManager private constructor() {

    companion object {
        // Double-checked locking equivalent
        val instance: HeavyFeatureManager by lazy { HeavyFeatureManager() }
    }

    private val expensiveResource by lazy {
        // Only initialized when first accessed — not at construction time
        DatabaseConnectionPool(size = 10)
    }
}

Copy codeclass MyApplication : Application() {

    // Initialized only when first accessed — not blocking onCreate()
    val imageLoader: ImageLoader by lazy {
        ImageLoader.Builder(this)
            .memoryCache { MemoryCache.Builder(this).maxSizePercent(0.25).build() }
            .diskCache { DiskCache.Builder().maxSizeBytes(50 * 1024 * 1024).build() }
            .build()
    }

    val analyticsTracker: AnalyticsTracker by lazy {
        AnalyticsTracker(apiKey = BuildConfig.ANALYTICS_KEY)
    }

    override fun onCreate() {
        super.onCreate()
        // onCreate() is lean — only critical init here
        // TimberInitializer handles Timber via App Startup
    }
}

Copy code// build.gradle.kts
plugins {
    id("androidx.baselineprofile")
}

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

Copy code// baselineprofile/src/main/kotlin/com/example/BaselineProfileGenerator.kt
@RunWith(AndroidJUnit4::class)
@LargeTest
class BaselineProfileGenerator {

    @get:Rule
    val rule = BaselineProfileRule()

    @Test
    fun generate() {
        rule.collect(packageName = "com.example.app") {
            // Simulate the startup journey
            pressHome()
            startActivityAndWait()

            // Navigate the critical paths you want compiled AOT
            device.findObject(By.text("Explore")).click()
            device.waitForIdle()
            device.findObject(By.text("Articles")).click()
            device.waitForIdle()
        }
    }
}

Copy codeimplementation("androidx.tracing:tracing-ktx:1.1.0")

class UserRepository {
    suspend fun loadUsers(): List<User> = withContext(Dispatchers.IO) {
        Trace.beginSection("UserRepository.loadUsers")
        try {
            api.getUsers()
        } finally {
            Trace.endSection()
        }
    }
}

// Kotlin extension
suspend fun <T> tracedSection(name: String, block: suspend () -> T): T =
    trace(name) { block() }

Copy code// Enable StrictMode in debug to catch main-thread violations early
class MyApplication : Application() {
    override fun onCreate() {
        if (BuildConfig.DEBUG) {
            StrictMode.setThreadPolicy(
                StrictMode.ThreadPolicy.Builder()
                    .detectDiskReads()
                    .detectDiskWrites()
                    .detectNetwork()
                    .penaltyLog()
                    .build()
            )
        }
        super.onCreate()
    }
}