Native Android apps

danwo tests a native Android app, written with Jetpack Compose or Views, the same way it tests an Expo app. It builds your Gradle project, routes the emulator's traffic through its proxy, and runs your tests, invariants and fault matrix against it.

You don't change the app's code. It keeps calling its real hosts over HTTPS. Android apps trust only the system's certificates by default, so danwo's build adds a network security config that also trusts the one it installs on the emulator. Your project's files are not touched.

Build the appCopy Anchor Link

npx @danwo/cli build-android android

built android/.danwo/builds/56bf08b42328c942.apk (dev.danwo.examples.compose) in 108 s (log: android/.danwo/builds/build-android.log)

android is the folder with your Gradle settings file and gradlew. danwo:

1. runs your wrapper, ./gradlew assembleRelease, with Android Studio's JDK when JAVA_HOME is unset;
2. hands Gradle an init script that adds danwo's network config to the app module, for this build only;
3. signs an unsigned APK with the debug key, so it installs;
4. reads the package name from the APK.

Gradle runs with --no-daemon and compiles Kotlin in its own process, so no daemon is left running. An unchanged project isn't built again: the build is keyed by a hash of its sources.

What the build addsCopy Anchor Link

The network config trusts the system's certificates and the user-installed ones, where danwo puts each run's, and allows plain HTTP:

<network-security-config>
  <base-config cleartextTrafficPermitted="true">
    <trust-anchors>
      <certificates src="system" />
      <certificates src="user" />
    </trust-anchors>
  </base-config>
</network-security-config>

It replaces any networkSecurityConfig your app sets, in danwo's build only. The init script adds it through the Android Gradle plugin's variant API (sources.res and sources.manifests); it is checked with AGP 9.4.

Bind the emulator in the configCopy Anchor Link

buildAndroid from @danwo/mobile does the same build from your config. It returns the APK and its package for withAndroidDevice:

const build = await buildAndroid({ project: "android" })

return withAndroidDevice(backend, {
  avd: "danwo_spike",
  worker: workerIndex,
  app: { package: build.package ?? "dev.danwo.examples.compose", apk: build.apk },
})

Route your API's production host to the local copy, as on iOS, so the app calls the URL it ships with. The full config is in examples/with-compose.

Make the screen findableCopy Anchor Link

Compose reports a testTag to the accessibility tree only when the screen asks it to. Set testTagsAsResourceId once, at the root:

Surface(modifier = Modifier.fillMaxSize().semantics { testTagsAsResourceId = true }) {
    OutlinedTextField(
        value = email,
        onValueChange = { email = it },
        label = { Text("Work email") },          // getByLabel("Work email")
        modifier = Modifier.testTag("email"),    // getByTestId("email")
    )
}

In Views, the view's android:id is its test id and contentDescription its label.

What reaches the proxyCopy Anchor Link

NextCopy Anchor Link