feat: setup Baseline profiles

AnkiDroid/build.gradle

@@ -2,6 +2,7 @@ plugins {
     // Gradle plugin portal
     alias(libs.plugins.tripletPlay)
     alias(libs.plugins.android.application)
+    alias(libs.plugins.androidx.baselineprofile)
     alias(libs.plugins.kotlin.parcelize)
     alias(libs.plugins.kotlin.serialization)
     alias(libs.plugins.keeper)
@@ -22,6 +23,14 @@ keeper {
     }
 }
 
+baselineProfile {
+    // Write generated profiles to `src/main/baselineProfiles/` instead of the
+    // default per-variant `src/playRelease/generated/baselineProfiles/`. This
+    // ensures the profile is consumed by ALL variants (play, amazon, full) and
+    // ALL buildTypes (release, benchmark), not just `playRelease`.
+    mergeIntoMain = true
+}
+
 idea {
     module {
         downloadJavadoc = System.getenv("CI") != "true"
@@ -178,6 +187,13 @@ android {
             resValue 'color', 'anki_foreground_icon_color_0', "#FF29B6F6"
             resValue 'color', 'anki_foreground_icon_color_1', "#FF0288D1"
         }
+
+        create('benchmark') {
+            initWith release
+            signingConfig signingConfigs.debug
+            matchingFallbacks = ['release']
+            debuggable false
+        }
     }
 
     /**
@@ -401,6 +417,7 @@ dependencies {
     implementation project(":compat")
     implementation project(":libanki")
     implementation project(":vbpd")
+    "baselineProfile" project(":baselineprofile")
 
     implementation libs.androidx.activity
     implementation libs.androidx.annotation
@@ -413,6 +430,7 @@ dependencies {
     implementation libs.androidx.lifecycle.process
     implementation libs.androidx.media
     implementation libs.androidx.preference.ktx
+    implementation libs.androidx.profileinstaller
     implementation libs.androidx.recyclerview
     implementation libs.androidx.sqlite.framework
     implementation libs.androidx.swiperefreshlayout

AnkiDroid/src/benchmark/AndroidManifest.xml

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  Benchmark-only manifest overlay. Merged into the benchmark buildType only.
+  Keeps <profileable> out of production release APKs.
+-->
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools">
+
+    <application>
+        <!--
+            Allows Macrobenchmark / Perfetto to attach via adb shell.
+            Required by the :baselineprofile module to collect baseline
+            profiles and run StartupBenchmark. `android:shell="true"`
+            restricts attachment to shell-initiated profiling only.
+        -->
+        <profileable
+            android:shell="true"
+            tools:targetApi="29" />
+    </application>
+
+</manifest>

baselineprofile/README.md

@@ -0,0 +1,54 @@
+# `:baselineprofile`
+
+This module generates AnkiDroid's **baseline profile** - a list of classes
+and methods ART pre-compiles at install time so cold start is faster.
+
+It has two classes:
+
+- **`BaselineProfileGenerator`** captures a cold-start trace and writes
+  `baseline-prof.txt` into `:AnkiDroid`.
+- **`StartupBenchmark`** measures cold-start time with vs without the
+  profile so you can see the impact.
+
+For results to be valid for comparisons and real-world impact, they must
+be run on real hardware devices ideally the same device over time and
+representative of typical user hardware. So this is currently not
+intended to be used in CI unless CI is connected to real devices (e.g.
+Firebase Test Lab or similar).
+
+## Requirements
+
+- Physical Android device, API 28+ (emulators aren't trustworthy)
+- USB debugging on, device plugged in
+
+## Regenerate the profile
+
+Run with `-PcustomSuffix` and `-PcustomName` so the benchmarked APK installs
+alongside your real AnkiDroid (`com.ichi2.anki.bp`) instead of replacing it.
+Without these flags the build targets `com.ichi2.anki`, the production app
+ID — installing it would clobber your real collection or fail with a
+signing-key mismatch.
+
+```sh
+./gradlew :AnkiDroid:generateBaselineProfile \
+  -PcustomSuffix=".bp" \
+  -PcustomName="AnkiDroid Baseline"
+```
+
+Takes a few minutes. The plugin installs a non-minified build, runs the
+cold-start journey (launch app -> dismiss intro screen if present -> wait
+for DeckPicker), and writes the result to `baseline-prof.txt`.
+
+## When to regenerate
+
+When the startup path changes meaningfully — new init work in
+`AnkiDroidApp.onCreate`, a refactor to `IntentHandler` or `DeckPicker`,
+a new dependency wired into `Application`. Otherwise, leave it alone;
+the profile is device- and OS-agnostic, one commit covers everyone.
+
+## Config notes
+
+See comments in [`build.gradle.kts`](build.gradle.kts) for the rationale
+behind `minSdk`, `missingDimensionStrategy`, the `benchmark` buildType,
+and `self-instrumenting`. The KDoc on each class explains the journey
+and the measurement modes.

baselineprofile/build.gradle.kts

@@ -0,0 +1,93 @@
+import com.android.build.api.dsl.TestExtension
+
+plugins {
+    alias(libs.plugins.android.test)
+    alias(libs.plugins.androidx.baselineprofile)
+}
+
+configure<TestExtension> {
+    namespace = "com.ichi2.anki.baselineprofile"
+
+    compileSdk =
+        libs.versions.compileSdk
+            .get()
+            .toInt()
+
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_17
+        targetCompatibility = JavaVersion.VERSION_17
+    }
+
+    defaultConfig {
+        // Macrobenchmark + baseline profile generation require API 28+
+        // even though the app may support a lower version. If the app's
+        // minSdk ever rises above 28, follow it automatically.
+        minSdk =
+            maxOf(
+                28,
+                libs.versions.minSdk
+                    .get()
+                    .toInt(),
+            )
+        targetSdk =
+            libs.versions.targetSdk
+                .get()
+                .toInt()
+
+        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
+
+        // AnkiDroid defines three product flavors (play, amazon, full) in the
+        // `appStore` dimension. Rather than duplicate them here we target the
+        // `play` flavor via `missingDimensionStrategy`, which keeps this module
+        // flavor-free but still able to resolve `:AnkiDroid` variants.
+        missingDimensionStrategy("appStore", "play")
+    }
+
+    buildTypes {
+        create("benchmark") {
+            isDebuggable = true
+            signingConfig = signingConfigs.getByName("debug")
+            matchingFallbacks += listOf("release")
+        }
+    }
+
+    targetProjectPath = ":AnkiDroid"
+
+    @Suppress("UnstableApiUsage")
+    experimentalProperties["android.experimental.self-instrumenting"] = true
+}
+
+baselineProfile {
+    useConnectedDevices = true
+}
+
+apply(from = "../lint.gradle")
+
+dependencies {
+    implementation(libs.androidx.test.junit)
+    implementation(libs.androidx.espresso.core)
+    implementation(libs.androidx.uiautomator)
+    implementation(libs.androidx.benchmark.macro.junit4)
+}
+
+androidComponents {
+    onVariants { v ->
+        val artifactsLoader = v.artifacts.getBuiltArtifactsLoader()
+        // Pull the applicationId from the actual built APK instead of
+        // hardcoding `com.ichi2.anki`. Most of us build with something like
+        // `-PcustomSuffix=".bp"` so the benchmark APK installs next to our
+        // real AnkiDroid (`com.ichi2.anki.bp`) rather than replacing it.
+        // If we hardcoded the fallback, the benchmark would happily target
+        // the production app and nuke your actual collection.
+        v.instrumentationRunnerArguments.put(
+            "targetAppId",
+            v.testedApks.map {
+                artifactsLoader.load(it)?.applicationId
+                    ?: error(
+                        "Could not resolve targetAppId from testedApks. " +
+                            "Refusing to fall back to a default to avoid clobbering the production install.",
+                    )
+            },
+        )
+    }
+}

baselineprofile/src/main/AndroidManifest.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest>
+
+</manifest>

baselineprofile/src/main/kotlin/com/ichi2/anki/baselineprofile/BaselineProfileGenerator.kt

@@ -0,0 +1,82 @@
+/*
+ *  Copyright (c) 2026 Ashish Yadav <mailtoashish693@gmail.com>
+ *
+ *  This program is free software; you can redistribute it and/or modify it under
+ *  the terms of the GNU General Public License as published by the Free Software
+ *  Foundation; either version 3 of the License, or (at your option) any later
+ *  version.
+ *
+ *  This program is distributed in the hope that it will be useful, but WITHOUT ANY
+ *  WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+ *  PARTICULAR PURPOSE. See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with
+ *  this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.ichi2.anki.baselineprofile
+
+import androidx.benchmark.macro.junit4.BaselineProfileRule
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.filters.LargeTest
+import androidx.test.platform.app.InstrumentationRegistry
+import androidx.test.uiautomator.By
+import androidx.test.uiautomator.Until
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+
+/**
+ * Generates a baseline profile that captures the critical user journey for AnkiDroid's
+ * cold start: launching the app and reaching the main [com.ichi2.anki.DeckPicker] screen.
+ *
+ * The captured launch path is:
+ * 1. [com.ichi2.anki.IntentHandler] — the MAIN/LAUNCHER activity declared in
+ *    the manifest. `startActivityAndWait()` launches this.
+ * 2. [com.ichi2.anki.DeckPicker] — IntentHandler.onCreate() immediately
+ *    creates an intent for DeckPicker and calls `launchDeckPickerIfNoOtherTasks()`.
+ * 3. The `device.wait` + `device.waitForIdle()` calls wait for DeckPicker to
+ *    fully render before the trace window closes.
+ *
+ * On a fresh install, [com.ichi2.anki.IntroductionActivity] appears before
+ * DeckPicker. The journey handles this by tapping the "Get Started" button
+ * (resource id `get_started`) if it is present, so the profile captures the
+ * full path to DeckPicker regardless of device state.
+ *
+ * Run on a connected API 28+ physical device with:
+ * ```
+ * ./gradlew :AnkiDroid:generateBaselineProfile
+ * ```
+ * The generated profile is committed to
+ * `AnkiDroid/src/main/baselineProfiles/baseline-prof.txt` by the
+ * [androidx.baselineprofile] plugin and is automatically embedded in subsequent
+ * app builds.
+ */
+@LargeTest
+@RunWith(AndroidJUnit4::class)
+class BaselineProfileGenerator {
+    @get:Rule
+    val rule = BaselineProfileRule()
+
+    @Test
+    fun generate() {
+        val targetPackage =
+            InstrumentationRegistry.getArguments().getString("targetAppId")
+                ?: throw IllegalStateException("targetAppId not passed as instrumentation runner arg")
+
+        rule.collect(packageName = targetPackage) {
+            pressHome()
+            // Launches IntentHandler (MAIN/LAUNCHER), which routes to DeckPicker.
+            startActivityAndWait()
+
+            // On a fresh install, IntroductionActivity appears before DeckPicker.
+            // Dismiss it by tapping "Get Started" so the profile always captures
+            // the full path through to DeckPicker, regardless of device state.
+            device.findObject(By.res(targetPackage, "get_started"))?.click()
+
+            // Wait for DeckPicker to fully render so all startup classes are captured.
+            device.wait(Until.hasObject(By.pkg(targetPackage).depth(0)), 5_000)
+            device.waitForIdle()
+        }
+    }
+}

baselineprofile/src/main/kotlin/com/ichi2/anki/baselineprofile/StartupBenchmark.kt

@@ -0,0 +1,80 @@
+/*
+ *  Copyright (c) 2026 Ashish Yadav <mailtoashish693@gmail.com>
+ *
+ *  This program is free software; you can redistribute it and/or modify it under
+ *  the terms of the GNU General Public License as published by the Free Software
+ *  Foundation; either version 3 of the License, or (at your option) any later
+ *  version.
+ *
+ *  This program is distributed in the hope that it will be useful, but WITHOUT ANY
+ *  WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+ *  PARTICULAR PURPOSE. See the GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along with
+ *  this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.ichi2.anki.baselineprofile
+
+import androidx.benchmark.macro.BaselineProfileMode
+import androidx.benchmark.macro.CompilationMode
+import androidx.benchmark.macro.StartupMode
+import androidx.benchmark.macro.StartupTimingMetric
+import androidx.benchmark.macro.junit4.MacrobenchmarkRule
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.filters.LargeTest
+import androidx.test.platform.app.InstrumentationRegistry
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+
+/**
+ * Measures AnkiDroid cold-startup time in two configurations so the
+ * before/after impact of the baseline profile is visible in a single run:
+ *
+ * - [startupCompilationNone] — [CompilationMode.None]: no AOT compilation,
+ *   all code is JIT'd on the fly. This is the "before" baseline.
+ * - [startupCompilationBaselineProfile] — [CompilationMode.Partial] with
+ *   [BaselineProfileMode.Require]: AOT-compiles exactly the methods listed
+ *   in `baseline-prof.txt`. `Require` fails the test if the profile isn't
+ *   installed, so any improvement is guaranteed to come from the profile.
+ *
+ * Both methods run [StartupMode.COLD] with 10 iterations. Compare the
+ * median of `timeToInitialDisplayMs` across the two methods.
+ *
+ * **This benchmark is for local, manual use only.** It requires a connected
+ * physical device, has no pass/fail assertions, and should not be included
+ * in CI test suites. Run with:
+ * ```
+ * ./gradlew :baselineprofile:connectedBenchmarkBenchmarkAndroidTest
+ * ```
+ */
+@LargeTest
+@RunWith(AndroidJUnit4::class)
+class StartupBenchmark {
+    @get:Rule
+    val rule = MacrobenchmarkRule()
+
+    @Test
+    fun startupCompilationNone() = startup(CompilationMode.None())
+
+    @Test
+    fun startupCompilationBaselineProfile() = startup(CompilationMode.Partial(baselineProfileMode = BaselineProfileMode.Require))
+
+    private fun startup(mode: CompilationMode) {
+        val targetPackage =
+            InstrumentationRegistry.getArguments().getString("targetAppId")
+                ?: throw IllegalStateException("targetAppId not passed as instrumentation runner arg")
+
+        rule.measureRepeated(
+            packageName = targetPackage,
+            metrics = listOf(StartupTimingMetric()),
+            iterations = 10,
+            startupMode = StartupMode.COLD,
+            compilationMode = mode,
+        ) {
+            pressHome()
+            startActivityAndWait()
+        }
+    }
+}