Baseline and Startup Profiles

.gitignore

@@ -6,6 +6,7 @@
 .idea/copilot
 .idea/libraries
 .idea/inspectionProfiles
+.idea/runConfigurations
 .idea/sonarlint
 .idea/*.xml
 .DS_Store

baselineprofile/.gitignore

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

baselineprofile/build.gradle

@@ -0,0 +1,75 @@
+import com.android.build.api.dsl.ManagedVirtualDevice
+
+plugins {
+    id 'com.android.test'
+    id 'org.jetbrains.kotlin.android'
+    id 'androidx.baselineprofile'
+}
+
+android {
+    namespace 'im.vector.app.baselineprofile'
+    compileSdk versions.compileSdk
+
+    compileOptions {
+        sourceCompatibility versions.sourceCompat
+        targetCompatibility versions.targetCompat
+    }
+
+    kotlinOptions {
+        jvmTarget = versions.jvmTarget
+    }
+
+    defaultConfig {
+        minSdk 28
+        targetSdk versions.targetSdk
+
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+    }
+
+    targetProjectPath = ":vector-app"
+
+    flavorDimensions += ["store"]
+    productFlavors {
+        gplay { dimension = "store" }
+        fdroid { dimension = "store" }
+    }
+
+    // This code creates the gradle managed device used to generate baseline profiles.
+    // To use GMD please invoke generation through the command line:
+    // ./gradlew :vector-app:generateBaselineProfile
+    testOptions.managedDevices.devices {
+        pixel6Api34(ManagedVirtualDevice) {
+            device = "Pixel 6"
+            apiLevel = versions.targetSdk
+            // Since play services are used for gplay build, using a google image
+            systemImageSource = "google"
+        }
+    }
+}
+
+// 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 {
+    // Option 1: A Gradle Managed Device for profile generating
+    managedDevices += "pixel6Api34"
+    useConnectedDevices = false
+    // Option 2: For benchmarking the app with and without the profiles applied on a real device
+//    useConnectedDevices = true
+}
+
+dependencies {
+    implementation libs.androidx.junit
+    implementation libs.androidx.testRunner
+    implementation libs.androidx.testUiAutomator
+    implementation libs.androidx.benchmarkMacroJunit
+}
+
+androidComponents {
+    onVariants(selector().all()) { v ->
+        def artifactsLoader = v.artifacts.getBuiltArtifactsLoader()
+        v.instrumentationRunnerArguments.put(
+                "targetAppId",
+                v.testedApks.map { artifactsLoader.load(it)?.applicationId }
+        )
+    }
+}

baselineprofile/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest />

baselineprofile/src/main/java/im/vector/app/baselineprofile/BaselineProfileGenerator.kt

@@ -0,0 +1,68 @@
+package im.vector.app.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 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 in Android Studio or
+ * the equivalent `generateBaselineProfile` gradle task:
+ * ```
+ * ./gradlew :vector-app:generateReleaseBaselineProfile
+ * ```
+ * 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.
+ *
+ * When using this class to generate a baseline profile, only API 33+ or rooted API 28+ are supported.
+ *
+ * The minimum required version of androidx.benchmark to generate a baseline profile is 1.2.0.
+ **/
+@RunWith(AndroidJUnit4::class)
+@LargeTest
+class BaselineProfileGenerator {
+
+    @get:Rule
+    val rule = BaselineProfileRule()
+
+    @Test
+    fun generate() {
+        // The application id for the running build variant is read from the instrumentation arguments.
+        rule.collect(
+                packageName = InstrumentationRegistry.getArguments().getString("targetAppId")
+                        ?: throw Exception("targetAppId not passed as instrumentation runner arg"),
+
+                // See: https://d.android.com/topic/performance/baselineprofiles/dex-layout-optimizations
+                includeInStartupProfile = true
+        ) {
+            // 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/im/vector/app/baselineprofile/StartupBenchmarks.kt

@@ -0,0 +1,78 @@
+package im.vector.app.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
+
+/**
+ * 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 for a variant, for example benchmarkRelease,
+ * with this Gradle task:
+ * ```
+ * ./gradlew :baselineprofile:connectedBenchmarkReleaseAndroidTest
+ * ```
+ *
+ * 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).
+ *
+ * Before starting the benchmarks from Android Studio's gutter, select the *BenchmarkRelease or release variants in Build Variants panel.
+ **/
+@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) {
+        // The application id for the running build variant is read from the instrumentation arguments.
+        rule.measureRepeated(
+                packageName = InstrumentationRegistry.getArguments().getString("targetAppId")
+                        ?: throw Exception("targetAppId not passed as instrumentation runner arg"),
+                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

@@ -24,6 +24,7 @@ buildscript {
         classpath libs.gradle.gradlePlugin
         classpath libs.gradle.kotlinPlugin
         classpath libs.gradle.hiltPlugin
+        classpath libs.gradle.baselineProfilePlugin
         classpath 'com.google.firebase:firebase-appdistribution-gradle:4.0.0'
         classpath 'com.google.gms:google-services:4.3.15'
         classpath 'org.sonarsource.scanner.gradle:sonarqube-gradle-plugin:4.0.0.2929'

changelog.d/8884.feature

@@ -0,0 +1 @@
+Adding Baseline and Startup profiles

dependencies.gradle

@@ -32,14 +32,17 @@ def fragment = "1.8.1"
 def mockk = "1.13.11"
 def espresso = "3.6.1"
 def androidxTest = "1.6.1"
+def benchmark = "1.2.4"
+def uiAutomator = "2.3.0"
 def androidxOrchestrator = "1.5.0"
 def paparazzi = "1.3.4"
 
 ext.libs = [
         gradle      : [
                 'gradlePlugin'            : "com.android.tools.build:gradle:$gradle",
                 'kotlinPlugin'            : "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin",
-                'hiltPlugin'              : "com.google.dagger:hilt-android-gradle-plugin:$dagger"
+                'hiltPlugin'              : "com.google.dagger:hilt-android-gradle-plugin:$dagger",
+                'baselineProfilePlugin'   : "androidx.baselineprofile:androidx.baselineprofile.gradle.plugin:$benchmark"
         ],
         jetbrains   : [
                 'coroutinesCore'          : "org.jetbrains.kotlinx:kotlinx-coroutines-core:$kotlinCoroutines",
@@ -49,6 +52,7 @@ ext.libs = [
         androidx    : [
                 'activity'                : "androidx.activity:activity-ktx:1.9.0",
                 'appCompat'               : "androidx.appcompat:appcompat:1.7.0",
+                'benchmarkMacroJunit'     : "androidx.benchmark:benchmark-macro-junit4:$benchmark",
                 'biometric'               : "androidx.biometric:biometric:1.1.0",
                 'core'                    : "androidx.core:core-ktx:1.10.1",
                 'recyclerview'            : "androidx.recyclerview:recyclerview:1.3.0",
@@ -68,11 +72,13 @@ ext.libs = [
                 'datastore'               : "androidx.datastore:datastore:1.0.0",
                 'datastorepreferences'    : "androidx.datastore:datastore-preferences:1.0.0",
                 'pagingRuntimeKtx'        : "androidx.paging:paging-runtime-ktx:2.1.2",
+                'profileinstaller'        : "androidx.profileinstaller:profileinstaller:1.3.1",
                 'coreTesting'             : "androidx.arch.core:core-testing:2.2.0",
                 'testCore'                : "androidx.test:core:$androidxTest",
                 'orchestrator'            : "androidx.test:orchestrator:$androidxOrchestrator",
                 'testRunner'              : "androidx.test:runner:$androidxTest",
                 'testRules'               : "androidx.test:rules:$androidxTest",
+                'testUiAutomator'         : "androidx.test.uiautomator:uiautomator:$uiAutomator",
                 'espressoCore'            : "androidx.test.espresso:espresso-core:$espresso",
                 'espressoContrib'         : "androidx.test.espresso:espresso-contrib:$espresso",
                 'espressoIntents'         : "androidx.test.espresso:espresso-intents:$espresso",
@@ -175,5 +181,3 @@ ext.libs = [
                 'robolectric'            : "org.robolectric:robolectric:4.13",
         ]
 ]
-
-

dependencies_groups.gradle

@@ -131,6 +131,7 @@ ext.groups = [
                         'com.squareup.okhttp3',
                         'com.squareup.okio',
                         'com.squareup.retrofit2',
+                        'com.squareup.wire',
                         'com.sun.activation',
                         'com.sun.istack',
                         'com.sun.xml.bind',

settings.gradle

@@ -21,3 +21,5 @@ include ':library:external:barcodescanner:zxing'
 include ':library:rustCrypto'
 include ':matrix-sdk-android'
 include ':matrix-sdk-android-flow'
+
+include ':baselineprofile'

vector-app/build.gradle

@@ -10,6 +10,7 @@ apply plugin: 'com.google.devtools.ksp'
 apply plugin: 'dagger.hilt.android.plugin'
 apply plugin: 'kotlinx-knit'
 apply plugin: 'com.likethesalad.stem'
+apply plugin: 'androidx.baselineprofile'
 
 if (project.hasProperty("coverage")) {
     apply plugin: 'jacoco'
@@ -179,6 +180,13 @@ android {
             abi {
                 // Enables building multiple APKs per ABI.
                 enable true
+                // Workaround for splits/baseline profile issue until AGP 8.5.1
+                // https://issuetracker.google.com/issues/341266993#comment3
+                gradle.startParameter.getTaskNames().each { task ->
+                    if (task.endsWith("BaselineProfile")) {
+                        enable false
+                    }
+                }
 
                 // By default all ABIs are included, so use reset() and include to specify that we only
                 // want APKs for armeabi-v7a, x86, arm64-v8a and x86_64.
@@ -299,6 +307,36 @@ android {
                 appId = "${getFirebaseAppId()}"
             }
         }
+
+        // Used for baseline and startup profile generating.
+        nonMinifiedRelease {
+            // Picking appId, name and signing key.
+            // Mainly because the google-services.json is copied from debug build type.
+            initWith debug
+            // Baseline profiles should be in non-minified format, so falling back to 'debug' build types of dependencies
+            matchingFallbacks = ['debug']
+        }
+
+        // Used for measuring the performance of the app with and without baseline profiles applied
+        benchmarkRelease {
+            initWith release
+            // The postprocessing seems to be ignored when 'initWith' is used.
+            // Specifically, proguardFiles is ignored, so duplicating the whole thing.
+            postprocessing {
+                // FIXME Set to true.
+                removeUnusedCode false
+                removeUnusedResources true
+                // We do not activate obfuscation as it makes it hard then to read crash reports, and it's a bit useless on an open source project :)
+                obfuscate false
+                optimizeCode true
+                proguardFiles 'proguard-rules.pro'
+            }
+            // Mimicking the debug build type, as google-services.json was copied from it
+            applicationIdSuffix ".debug"
+            signingConfig signingConfigs.debug
+            // For the rest the app should be as 'release' as possible
+            matchingFallbacks = ['release']
+        }
     }
 
     sourceSets {
@@ -391,6 +429,9 @@ dependencies {
     implementation 'androidx.multidex:multidex:2.0.1'
     implementation "androidx.sharetarget:sharetarget:1.2.0"
 
+    baselineProfile project(':baselineprofile')
+    implementation libs.androidx.profileinstaller
+
     // Flipper, debug builds only
     debugImplementation(libs.flipper.flipper) {
         exclude group: 'com.facebook.fbjni', module: 'fbjni'