[feature/DroidKaigi#719] Add baselineprofile module

[feature/DroidKaigi#719] Add baseline-prof when variant is dev


[feature/DroidKaigi#719] Delete baseline-prof

app-android/build.gradle.kts

@@ -11,6 +11,7 @@ plugins {
     id("droidkaigi.primitive.android.roborazzi")
     id("droidkaigi.primitive.kover")
     id("droidkaigi.primitive.osslicenses")
+    alias(libs.plugins.androidx.baselineprofile)
 }
 
 val keystorePropertiesFile = file("keystore.properties")
@@ -118,6 +119,8 @@ dependencies {
 // Dependency configuration to aggregate Kover coverage reports
 // TODO: extract report aggregation to build-logic
 dependencies {
+    baselineProfile(projects.baselineprofile)
+    implementation(libs.profileinstaller)
     kover(projects.appIosShared)
 
     kover(projects.feature.about)

baselineprofile/.gitignore

@@ -0,0 +1 @@
+/build

baselineprofile/build.gradle.kts

@@ -0,0 +1,64 @@
+import com.android.build.api.dsl.ManagedVirtualDevice
+
+@Suppress("DSL_SCOPE_VIOLATION") // TODO: Remove once KTIJ-19369 is fixed
+plugins {
+    alias(libs.plugins.androidTest)
+    alias(libs.plugins.kotlinGradlePlugin)
+    alias(libs.plugins.androidx.baselineprofile)
+}
+
+android {
+    namespace = "io.github.droidkaigi.confsched2023"
+    compileSdk = 34
+
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_11
+        targetCompatibility = JavaVersion.VERSION_11
+    }
+
+    kotlinOptions {
+        jvmTarget = "11"
+    }
+
+    defaultConfig {
+        minSdk = 28
+        targetSdk = 34
+
+        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
+        testInstrumentationRunnerArguments["androidx.benchmark.suppressErrors"] = "EMULATOR"
+    }
+
+    targetProjectPath = ":app-android"
+
+    flavorDimensions += listOf("network")
+    productFlavors {
+        create("dev") { dimension = "network" }
+        create("prod") { dimension = "network" }
+    }
+
+    testOptions.managedDevices.devices {
+        create<ManagedVirtualDevice>("pixel6Api34") {
+            device = "Pixel 6"
+            apiLevel = 34
+            systemImageSource = "google"
+        }
+    }
+
+    buildFeatures {
+        buildConfig = true
+    }
+}
+
+// This is the configuration block for the Baseline Profile plugin.
+// You can specify to run the generators on a managed devices or connected devices.
+baselineProfile {
+    managedDevices += "pixel6Api34"
+    useConnectedDevices = false
+}
+
+dependencies {
+    implementation(libs.androidxTestExtJunit)
+    implementation(libs.androidxTestEspressoEspressoCore)
+    implementation(libs.uiautomator)
+    implementation(libs.benchmark.macro.junit4)
+}

baselineprofile/src/main/AndroidManifest.xml

@@ -0,0 +1,5 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <queries>
+        <package android:name="io.github.droidkaigi.confsched2023" />
+    </queries>
+</manifest>

baselineprofile/src/main/java/io/github/droidkaigi/confsched2023/BaselineProfileGenerator.kt

@@ -0,0 +1,57 @@
+package io.github.droidkaigi.confsched2023
+
+import androidx.benchmark.macro.junit4.BaselineProfileRule
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.filters.LargeTest
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+
+/**
+ * This test class generates a basic startup baseline profile for the target package.
+ *
+ * We recommend you start with this but add important user flows to the profile to improve their performance.
+ * Refer to the [baseline profile documentation](https://d.android.com/topic/performance/baselineprofiles)
+ * for more information.
+ *
+ * You can run the generator with the Generate Baseline Profile run configuration,
+ * or directly with `generateBaselineProfile` Gradle task:
+ * ```
+ * ./gradlew :app-android:generateReleaseBaselineProfile -Pandroid.testInstrumentationRunnerArguments.androidx.benchmark.enabledRules=BaselineProfile
+ * ```
+ * The run configuration runs the Gradle task and applies filtering to run only the generators.
+ *
+ * Check [documentation](https://d.android.com/topic/performance/benchmarking/macrobenchmark-instrumentation-args)
+ * for more information about available instrumentation arguments.
+ *
+ * After you run the generator, you can verify the improvements running the [StartupBenchmarks] benchmark.
+ **/
+@RunWith(AndroidJUnit4::class)
+@LargeTest
+class BaselineProfileGenerator {
+
+    @get:Rule
+    val rule = BaselineProfileRule()
+
+    @Test
+    fun generate() {
+        rule.collect(PACKAGE_NAME) {
+            // This block defines the app's critical user journey. Here we are interested in
+            // optimizing for app startup. But you can also navigate and scroll
+            // through your most important UI.
+
+            // Start default activity for your app
+            pressHome()
+            startActivityAndWait()
+
+            // TODO Write more interactions to optimize advanced journeys of your app.
+            // For example:
+            // 1. Wait until the content is asynchronously loaded
+            // 2. Scroll the feed content
+            // 3. Navigate to detail screen
+
+            // Check UiAutomator documentation for more information how to interact with the app.
+            // https://d.android.com/training/testing/other-components/ui-automator
+        }
+    }
+}

baselineprofile/src/main/java/io/github/droidkaigi/confsched2023/Constant.kt

@@ -0,0 +1,6 @@
+package io.github.droidkaigi.confsched2023
+
+val PACKAGE_NAME = buildString {
+    append("io.github.droidkaigi.confsched2023")
+    append(if (BuildConfig.FLAVOR == "dev") ".dev" else "")
+}

baselineprofile/src/main/java/io/github/droidkaigi/confsched2023/StartupBenchmarks.kt

@@ -0,0 +1,72 @@
+package io.github.droidkaigi.confsched2023
+
+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 org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+
+/**
+ * This test class benchmarks the speed of app startup.
+ * Run this benchmark to verify how effective a Baseline Profile is.
+ * It does this by comparing [CompilationMode.None], which represents the app with no Baseline
+ * Profiles optimizations, and [CompilationMode.Partial], which uses Baseline Profiles.
+ *
+ * Run this benchmark to see startup measurements and captured system traces for verifying
+ * the effectiveness of your Baseline Profiles. You can run it directly from Android
+ * Studio as an instrumentation test, or run all benchmarks with this Gradle task:
+ * ```
+ * ./gradlew :baselineprofile:connectedAndroidTest -Pandroid.testInstrumentationRunnerArguments.androidx.benchmark.enabledRules=Macrobenchmark
+ * ```
+ *
+ * You should run the benchmarks on a physical device, not an Android emulator, because the
+ * emulator doesn't represent real world performance and shares system resources with its host.
+ *
+ * For more information, see the [Macrobenchmark documentation](https://d.android.com/macrobenchmark#create-macrobenchmark)
+ * and the [instrumentation arguments documentation](https://d.android.com/topic/performance/benchmarking/macrobenchmark-instrumentation-args).
+ **/
+@RunWith(AndroidJUnit4::class)
+@LargeTest
+class StartupBenchmarks {
+
+    @get:Rule
+    val rule = MacrobenchmarkRule()
+
+    @Test
+    fun startupCompilationNone() =
+        benchmark(CompilationMode.None())
+
+    @Test
+    fun startupCompilationBaselineProfiles() =
+        benchmark(CompilationMode.Partial(BaselineProfileMode.Require))
+
+    private fun benchmark(compilationMode: CompilationMode) {
+        rule.measureRepeated(
+            packageName = PACKAGE_NAME,
+            metrics = listOf(StartupTimingMetric()),
+            compilationMode = compilationMode,
+            startupMode = StartupMode.COLD,
+            iterations = 10,
+            setupBlock = {
+                pressHome()
+            },
+            measureBlock = {
+                startActivityAndWait()
+
+                // TODO Add interactions to wait for when your app is fully drawn.
+                // The app is fully drawn when Activity.reportFullyDrawn is called.
+                // For Jetpack Compose, you can use ReportDrawn, ReportDrawnWhen and ReportDrawnAfter
+                // from the AndroidX Activity library.
+
+                // Check the UiAutomator documentation for more information on how to
+                // interact with the app.
+                // https://d.android.com/training/testing/other-components/ui-automator
+            }
+        )
+    }
+}

build.gradle.kts

@@ -5,6 +5,8 @@ plugins {
     alias(libs.plugins.androidGradleLibraryPlugin) apply false
     alias(libs.plugins.kotlinGradlePlugin) apply false
     alias(libs.plugins.kotlinxKover) apply false
+    alias(libs.plugins.androidTest) apply false
+    alias(libs.plugins.androidx.baselineprofile) apply false
 }
 
 tasks.register("clean", Delete::class) {
@@ -19,4 +21,4 @@ buildscript {
             }
         }
     }
-}
+}

gradle/libs.versions.toml

@@ -38,6 +38,10 @@ detekt = "1.23.1"
 twitterComposeRule = "0.0.26"
 lottie = "6.1.0"
 kover = "0.7.3"
+uiautomator = "2.2.0"
+benchmark-macro-junit4 = "1.2.0-beta01"
+androidx-baselineprofile = "1.2.0-beta01"
+profileinstaller = "1.3.1"
 
 [libraries]
 androidGradlePlugin = { group = "com.android.tools.build", name = "gradle", version.ref = "androidGradlePlugin" }
@@ -141,6 +145,9 @@ roborazziCompose = { module = "io.github.takahirom.roborazzi:roborazzi-compose",
 roborazziRule = { module = "io.github.takahirom.roborazzi:roborazzi-junit-rule", version.ref = "roborazzi" }
 showkaseRuntime = { group = "com.airbnb.android", name = "showkase", version.ref = "showkase" }
 showkaseProcessor = { group = "com.airbnb.android", name = "showkase-processor", version.ref = "showkase" }
+uiautomator = { group = "androidx.test.uiautomator", name = "uiautomator", version.ref = "uiautomator" }
+benchmark-macro-junit4 = { group = "androidx.benchmark", name = "benchmark-macro-junit4", version.ref = "benchmark-macro-junit4" }
+profileinstaller = { group = "androidx.profileinstaller", name = "profileinstaller", version.ref = "profileinstaller" }
 
 [plugins]
 androidGradlePlugin = { id = "com.android.application", version.ref = "androidGradlePlugin" }
@@ -152,6 +159,8 @@ kspGradlePlugin = { id = "com.google.devtools.ksp", version.ref = "ksp" }
 kotlinxKover = { id = "org.jetbrains.kotlinx.kover", version.ref = "kover" }
 detektGradlePlugin = { id = "io.gitlab.arturbosch.detekt", version.ref = "detekt" }
 ossLicensesPlugin = { id = "com.google.android.gms.oss-licenses-plugin", version.ref = "ossLicensesPlugin" }
+androidTest = { id = "com.android.test", version.ref = "androidGradlePlugin" }
+androidx-baselineprofile = { id = "androidx.baselineprofile", version.ref = "androidx-baselineprofile" }
 
 [bundles]
 plugins = [

settings.gradle.kts

@@ -33,3 +33,4 @@ include(
     ":core:testing",
     ":core:common",
 )
+include(":baselineprofile")