@unrulysystems/rn-playwright-driver-instrumentation-companion 0.1.1

package/CHANGELOG.md

@@ -0,0 +1,10 @@
+# @unrulysystems/rn-playwright-driver-instrumentation-companion
+
+## 0.1.1
+
+### Patch Changes
+
+- Publish the Android instrumentation companion package.
+  - Add Expo config plugin packaging that copies the companion runner and writes the androidTest manifest/dependencies.
+  - Add auth-token handling for the HTTP companion protocol.
+  - Document manual Android instrumentation setup for consumers that cannot use the config plugin.

package/README.md

@@ -0,0 +1,141 @@
+# RN Driver Touch Instrumentation Companion
+
+Android instrumentation sidecar for `@unrulysystems/rn-playwright-driver`.
+It starts a small HTTP server in a separate instrumentation process and injects
+OS-level touch events through `UiAutomation.injectInputEvent`.
+
+## Consumption
+
+Install the package in the app under test and add the config plugin:
+
+```json
+{
+  "expo": {
+    "plugins": ["@unrulysystems/rn-playwright-driver-instrumentation-companion"]
+  }
+}
+```
+
+During `expo prebuild`, the plugin:
+
+- copies `RNDriverTouchCompanion.kt` into `android/app/src/androidTest/java`;
+- writes `android/app/src/androidTest/AndroidManifest.xml` with the
+  instrumentation registration;
+- adds `androidx.test:runner` and `androidx.test:core` as `androidTestImplementation`
+  dependencies.
+
+The plugin requires `expo.android.package` so the androidTest manifest can target
+the app package. The packaged Android manifest uses `${applicationId}` as the
+target package placeholder; if a consuming build cannot resolve that placeholder,
+copy the manifest below and replace it with the app id.
+
+## Manual Device Flow
+
+Regenerate the native project:
+
+```bash
+npx expo prebuild --platform android
+```
+
+Build the app APK and the androidTest instrumentation APK:
+
+```bash
+cd android
+./gradlew :app:assembleDebug :app:assembleDebugAndroidTest
+```
+
+Install both APKs:
+
+```bash
+adb install -r app/build/outputs/apk/debug/app-debug.apk
+adb install -r app/build/outputs/apk/androidTest/debug/app-debug-androidTest.apk
+```
+
+Forward the companion port and launch the instrumentation:
+
+```bash
+RN_TOUCH_INSTRUMENTATION_TOKEN="$(openssl rand -hex 16)"
+export RN_TOUCH_INSTRUMENTATION_TOKEN_FILE="$(mktemp -t rn-driver-touch-token.XXXXXX)"
+chmod 600 "$RN_TOUCH_INSTRUMENTATION_TOKEN_FILE"
+printf '%s' "$RN_TOUCH_INSTRUMENTATION_TOKEN" >"$RN_TOUCH_INSTRUMENTATION_TOKEN_FILE"
+adb forward tcp:9999 tcp:9999
+adb shell am instrument -e rnDriverAuthToken "$RN_TOUCH_INSTRUMENTATION_TOKEN" -w <app>.test/com.rndriver.touchcompanion.RNDriverTouchCompanion
+```
+
+Configure the driver to force the instrumentation backend:
+
+```ts
+import fs from 'node:fs'
+
+const authToken = fs.readFileSync(process.env.RN_TOUCH_INSTRUMENTATION_TOKEN_FILE!, 'utf8').trim()
+const device = createDevice({
+  touch: {
+    mode: 'force',
+    backend: 'instrumentation',
+    instrumentation: { port: 9999, authToken },
+  },
+})
+```
+
+The test fixture also accepts `RN_TOUCH_INSTRUMENTATION_TOKEN_FILE` directly
+when `RN_TOUCH_BACKEND=instrumentation`. Prefer the file form for local scripts
+so the Playwright process environment carries only a path. The value is still a
+local capability token rather than a durable secret: Android instrumentation
+requires passing it as the `rnDriverAuthToken` argument to `adb shell am
+instrument`.
+
+## Raw Assets
+
+If the config plugin cannot be used, copy these assets after `expo prebuild`:
+
+- `android/src/main/java/com/rndriver/touchcompanion/RNDriverTouchCompanion.kt`
+  to `android/app/src/androidTest/java/com/rndriver/touchcompanion/RNDriverTouchCompanion.kt`;
+- the manifest below to `android/app/src/androidTest/AndroidManifest.xml`;
+- the Gradle dependency snippet below into `android/app/build.gradle`.
+
+```xml
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+  package="<app>.test">
+  <uses-permission android:name="android.permission.INTERNET" />
+  <instrumentation
+    android:name="com.rndriver.touchcompanion.RNDriverTouchCompanion"
+    android:targetPackage="<app>"
+    android:functionalTest="false"
+    android:handleProfiling="false"
+    android:label="RN Driver Touch Companion" />
+</manifest>
+```
+
+```gradle
+dependencies {
+  androidTestImplementation "androidx.test:runner:1.6.2"
+  androidTestImplementation "androidx.test:core:1.6.1"
+}
+```
+
+## Protocol
+
+POST `/command` with a JSON body and the `x-rn-driver-auth` header matching
+the `rnDriverAuthToken` instrumentation argument.
+
+| Command     | Body                                                                                                 |
+| ----------- | ---------------------------------------------------------------------------------------------------- |
+| `hello`     | `{ "type": "hello" }`                                                                                |
+| `tap`       | `{ "type": "tap", "x": 10, "y": 20 }`                                                                |
+| `down`      | `{ "type": "down", "x": 10, "y": 20 }`                                                               |
+| `move`      | `{ "type": "move", "x": 15, "y": 25 }`                                                               |
+| `up`        | `{ "type": "up" }`                                                                                   |
+| `swipe`     | `{ "type": "swipe", "from": { "x": 10, "y": 20 }, "to": { "x": 100, "y": 200 }, "durationMs": 300 }` |
+| `longPress` | `{ "type": "longPress", "x": 10, "y": 20, "durationMs": 500 }`                                       |
+| `typeText`  | `{ "type": "typeText", "text": "hello" }`                                                            |
+
+Responses are JSON envelopes:
+
+```ts
+type TouchCompanionResponse =
+  | { ok: true; result?: unknown }
+  | { ok: false; error: { message: string; code?: string } }
+```
+
+Coordinates are logical points (dp). The companion converts them to pixels using
+the target display density before injecting motion events.

package/android/build.gradle

@@ -0,0 +1,95 @@
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+apply plugin: 'maven-publish'
+
+group = 'com.rndriver.touchcompanion'
+version = '0.1.1'
+
+buildscript {
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:1.9.24"
+  }
+}
+
+afterEvaluate {
+  publishing {
+    publications {
+      release(MavenPublication) {
+        from components.release
+      }
+    }
+    repositories {
+      maven {
+        url = mavenLocal().url
+      }
+    }
+  }
+}
+
+android {
+  namespace "com.rndriver.touchcompanion"
+  compileSdkVersion safeExtGet("compileSdkVersion", 34)
+
+  defaultConfig {
+    minSdkVersion safeExtGet("minSdkVersion", 23)
+    targetSdkVersion safeExtGet("targetSdkVersion", 34)
+    testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+    manifestPlaceholders = [
+      applicationId: safeExtGet("applicationId", "com.rndriver.touchcompanion.target")
+    ]
+  }
+
+  publishing {
+    singleVariant("release") {
+      withSourcesJar()
+    }
+  }
+
+  lintOptions {
+    abortOnError false
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_17
+    targetCompatibility JavaVersion.VERSION_17
+  }
+
+  kotlinOptions {
+    jvmTarget = JavaVersion.VERSION_17.majorVersion
+  }
+}
+
+repositories {
+  google()
+  mavenCentral()
+}
+
+dependencies {
+  implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:${getKotlinVersion()}"
+  implementation "androidx.test:runner:${getAndroidXTestRunnerVersion()}"
+  implementation "androidx.test:core:${getAndroidXTestCoreVersion()}"
+}
+
+def getKotlinVersion() {
+  def kotlin_version = rootProject.ext.has("kotlinVersion") ? rootProject.ext.get("kotlinVersion") : project.properties["kotlinVersion"]
+  return kotlin_version ?: "1.9.24"
+}
+
+def getAndroidXTestRunnerVersion() {
+  def version = rootProject.ext.has("androidXTestRunnerVersion") ? rootProject.ext.get("androidXTestRunnerVersion") : project.properties["androidXTestRunnerVersion"]
+  return version ?: "1.6.2"
+}
+
+def getAndroidXTestCoreVersion() {
+  def version = rootProject.ext.has("androidXTestCoreVersion") ? rootProject.ext.get("androidXTestCoreVersion") : project.properties["androidXTestCoreVersion"]
+  return version ?: "1.6.1"
+}
+
+def safeExtGet(prop, fallback) {
+  rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,10 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+  package="com.rndriver.touchcompanion">
+  <uses-permission android:name="android.permission.INTERNET" />
+  <instrumentation
+    android:name="com.rndriver.touchcompanion.RNDriverTouchCompanion"
+    android:targetPackage="${applicationId}"
+    android:functionalTest="false"
+    android:handleProfiling="false"
+    android:label="RN Driver Touch Companion" />
+</manifest>

package/android/src/main/java/com/rndriver/touchcompanion/RNDriverTouchCompanion.kt

@@ -0,0 +1,341 @@
+package com.rndriver.touchcompanion
+
+import android.app.Instrumentation
+import android.os.Bundle
+import android.os.SystemClock
+import android.util.Log
+import android.view.MotionEvent
+import org.json.JSONObject
+import java.io.BufferedInputStream
+import java.io.BufferedOutputStream
+import java.io.ByteArrayOutputStream
+import java.io.InputStream
+import java.net.InetAddress
+import java.net.InetSocketAddress
+import java.net.ServerSocket
+import java.net.Socket
+import java.nio.charset.StandardCharsets
+import java.util.concurrent.CountDownLatch
+import kotlin.concurrent.thread
+
+private const val DEFAULT_PORT = 9999
+private const val TAG = "RNDriverTouchCompanion"
+private const val ARG_AUTH_TOKEN = "rnDriverAuthToken"
+private const val AUTH_HEADER = "x-rn-driver-auth"
+private const val SOCKET_TIMEOUT_MS = 2_000
+private const val MAX_HEADER_BYTES = 16 * 1024
+private const val MAX_BODY_BYTES = 1024 * 1024
+
+class RNDriverTouchCompanion : Instrumentation() {
+  private var server: TouchCompanionServer? = null
+  private var authToken: String? = null
+  private val keepAlive = CountDownLatch(1)
+
+  override fun onCreate(arguments: Bundle?) {
+    super.onCreate(arguments)
+    authToken = arguments?.getString(ARG_AUTH_TOKEN)?.takeIf { it.isNotBlank() }
+    start()
+  }
+
+  override fun onStart() {
+    super.onStart()
+    val token = checkNotNull(authToken) {
+      "RNDriverTouchCompanion requires -e $ARG_AUTH_TOKEN <token>"
+    }
+    server = TouchCompanionServer(this, authToken = token)
+    server?.start()
+    keepAlive.await()
+  }
+}
+
+private class TouchCompanionServer(
+  private val instrumentation: Instrumentation,
+  private val port: Int = DEFAULT_PORT,
+  private val authToken: String,
+) {
+  private var serverThread: Thread? = null
+  private val density: Float = instrumentation.targetContext.resources.displayMetrics.density
+
+  fun start() {
+    if (serverThread != null) return
+    serverThread = thread(name = "rn-driver-touch-server", isDaemon = true) {
+      ServerSocket().use { serverSocket ->
+        serverSocket.bind(InetSocketAddress(InetAddress.getLoopbackAddress(), port))
+        Log.i(TAG, "Touch companion listening on 127.0.0.1:$port")
+        while (!Thread.currentThread().isInterrupted) {
+          val socket = serverSocket.accept()
+          try {
+            handleClient(socket)
+          } catch (error: Exception) {
+            Log.w(TAG, "Touch companion request failed", error)
+          }
+        }
+      }
+    }
+  }
+
+  private fun handleClient(socket: Socket) {
+    socket.use { client ->
+      val input = BufferedInputStream(client.getInputStream())
+      val output = BufferedOutputStream(client.getOutputStream())
+      client.soTimeout = SOCKET_TIMEOUT_MS
+
+      val request = readHttpRequest(input) ?: return
+      val response = handleCommand(request)
+
+      output.write(response.toByteArray(StandardCharsets.UTF_8))
+      output.flush()
+    }
+  }
+
+  private data class HttpRequest(
+    val headers: Map<String, String>,
+    val body: String,
+  )
+
+  private fun readHttpRequest(input: InputStream): HttpRequest? {
+    val headerBuffer = ByteArrayOutputStream()
+    val delimiter = "\r\n\r\n".toByteArray(StandardCharsets.UTF_8)
+    val temp = ByteArray(1024)
+
+    while (true) {
+      val read = input.read(temp)
+      if (read <= 0) return null
+      headerBuffer.write(temp, 0, read)
+      if (headerBuffer.size() > MAX_HEADER_BYTES) {
+        throw IllegalArgumentException("HTTP headers exceed ${MAX_HEADER_BYTES} bytes")
+      }
+      val bytes = headerBuffer.toByteArray()
+      val index = indexOf(bytes, delimiter)
+      if (index >= 0) {
+        val headerText = String(bytes, 0, index + delimiter.size, StandardCharsets.UTF_8)
+        val headers = parseHeaders(headerText)
+        val contentLength = parseContentLength(headers)
+        if (contentLength > MAX_BODY_BYTES) {
+          throw IllegalArgumentException("HTTP body exceeds ${MAX_BODY_BYTES} bytes")
+        }
+        val remainingStart = index + delimiter.size
+        val remaining = bytes.size - remainingStart
+
+        val body = ByteArrayOutputStream()
+        if (remaining > 0) {
+          body.write(bytes, remainingStart, remaining)
+        }
+
+        while (body.size() < contentLength) {
+          val count = input.read(temp)
+          if (count <= 0) break
+          body.write(temp, 0, count)
+        }
+        return HttpRequest(headers, String(body.toByteArray(), StandardCharsets.UTF_8))
+      }
+    }
+  }
+
+  private fun handleCommand(request: HttpRequest): String {
+    if (request.headers[AUTH_HEADER] != authToken) {
+      return errorResponse("Unauthorized instrumentation companion request", "UNAUTHORIZED", 401)
+    }
+
+    return try {
+      val payload = JSONObject(request.body)
+      val type = payload.optString("type", "")
+
+      when (type) {
+        "hello" -> okResponse(JSONObject().apply {
+          put("platform", "android")
+          put("density", density)
+        })
+        "tap" -> {
+          val (x, y) = parsePoint(payload)
+          injectTap(x, y)
+          okResponse()
+        }
+        "down" -> {
+          val (x, y) = parsePoint(payload)
+          injectDown(x, y)
+          okResponse()
+        }
+        "move" -> {
+          val (x, y) = parsePoint(payload)
+          injectMove(x, y)
+          okResponse()
+        }
+        "up" -> {
+          injectUp()
+          okResponse()
+        }
+        "swipe" -> {
+          val from = payload.getJSONObject("from")
+          val to = payload.getJSONObject("to")
+          val durationMs = payload.optLong("durationMs", 300)
+          injectSwipe(
+            from.getDouble("x"),
+            from.getDouble("y"),
+            to.getDouble("x"),
+            to.getDouble("y"),
+            durationMs,
+          )
+          okResponse()
+        }
+        "longPress" -> {
+          val (x, y) = parsePoint(payload)
+          val durationMs = payload.optLong("durationMs", 500)
+          injectLongPress(x, y, durationMs)
+          okResponse()
+        }
+        "typeText" -> {
+          val text = payload.optString("text", "")
+          instrumentation.sendStringSync(text)
+          okResponse()
+        }
+        else -> errorResponse("Unsupported command: $type", "UNSUPPORTED_COMMAND")
+      }
+    } catch (error: Exception) {
+      errorResponse(error.message ?: "Command failed")
+    }
+  }
+
+  private fun parsePoint(payload: JSONObject): Pair<Double, Double> {
+    val x = payload.getDouble("x")
+    val y = payload.getDouble("y")
+    return Pair(x, y)
+  }
+
+  private fun injectTap(x: Double, y: Double) {
+    val downTime = SystemClock.uptimeMillis()
+    val xPx = (x * density).toFloat()
+    val yPx = (y * density).toFloat()
+    injectEvent(MotionEvent.obtain(downTime, downTime, MotionEvent.ACTION_DOWN, xPx, yPx, 0))
+    injectEvent(MotionEvent.obtain(downTime, downTime + 50, MotionEvent.ACTION_UP, xPx, yPx, 0))
+  }
+
+  private var activeDownTime: Long? = null
+  private var lastX: Float = 0f
+  private var lastY: Float = 0f
+
+  private fun injectDown(x: Double, y: Double) {
+    val downTime = SystemClock.uptimeMillis()
+    val xPx = (x * density).toFloat()
+    val yPx = (y * density).toFloat()
+    activeDownTime = downTime
+    lastX = xPx
+    lastY = yPx
+    injectEvent(MotionEvent.obtain(downTime, downTime, MotionEvent.ACTION_DOWN, xPx, yPx, 0))
+  }
+
+  private fun injectMove(x: Double, y: Double) {
+    val downTime = activeDownTime ?: return
+    val eventTime = SystemClock.uptimeMillis()
+    val xPx = (x * density).toFloat()
+    val yPx = (y * density).toFloat()
+    lastX = xPx
+    lastY = yPx
+    injectEvent(MotionEvent.obtain(downTime, eventTime, MotionEvent.ACTION_MOVE, xPx, yPx, 0))
+  }
+
+  private fun injectUp() {
+    val downTime = activeDownTime ?: return
+    val eventTime = SystemClock.uptimeMillis()
+    injectEvent(MotionEvent.obtain(downTime, eventTime, MotionEvent.ACTION_UP, lastX, lastY, 0))
+    activeDownTime = null
+  }
+
+  private fun injectSwipe(
+    fromX: Double,
+    fromY: Double,
+    toX: Double,
+    toY: Double,
+    durationMs: Long,
+  ) {
+    val steps = maxOf(10, (durationMs / 16).toInt())
+    val downTime = SystemClock.uptimeMillis()
+    val startX = (fromX * density).toFloat()
+    val startY = (fromY * density).toFloat()
+    val endX = (toX * density).toFloat()
+    val endY = (toY * density).toFloat()
+
+    injectEvent(MotionEvent.obtain(downTime, downTime, MotionEvent.ACTION_DOWN, startX, startY, 0))
+
+    for (i in 1..steps) {
+      val t = i.toFloat() / steps
+      val x = startX + (endX - startX) * t
+      val y = startY + (endY - startY) * t
+      val eventTime = downTime + (durationMs * t).toLong()
+      injectEvent(MotionEvent.obtain(downTime, eventTime, MotionEvent.ACTION_MOVE, x, y, 0))
+    }
+
+    val endTime = downTime + durationMs
+    injectEvent(MotionEvent.obtain(downTime, endTime, MotionEvent.ACTION_UP, endX, endY, 0))
+  }
+
+  private fun injectLongPress(x: Double, y: Double, durationMs: Long) {
+    val downTime = SystemClock.uptimeMillis()
+    val xPx = (x * density).toFloat()
+    val yPx = (y * density).toFloat()
+    injectEvent(MotionEvent.obtain(downTime, downTime, MotionEvent.ACTION_DOWN, xPx, yPx, 0))
+    SystemClock.sleep(durationMs)
+    val upTime = SystemClock.uptimeMillis()
+    injectEvent(MotionEvent.obtain(downTime, upTime, MotionEvent.ACTION_UP, xPx, yPx, 0))
+  }
+
+  private fun injectEvent(event: MotionEvent) {
+    val uiAutomation = instrumentation.uiAutomation
+    uiAutomation.injectInputEvent(event, true)
+    event.recycle()
+  }
+
+  private fun okResponse(result: JSONObject? = null): String {
+    val payload = JSONObject()
+    payload.put("ok", true)
+    if (result != null) {
+      payload.put("result", result)
+    }
+    return httpResponse(payload.toString())
+  }
+
+  private fun errorResponse(message: String, code: String = "INTERNAL", status: Int = 500): String {
+    val payload = JSONObject()
+    payload.put("ok", false)
+    payload.put("error", JSONObject().apply {
+      put("message", message)
+      put("code", code)
+    })
+    return httpResponse(payload.toString(), status)
+  }
+
+  private fun httpResponse(body: String, status: Int = 200): String {
+    return "HTTP/1.1 $status OK\r\n" +
+      "Content-Type: application/json\r\n" +
+      "Content-Length: ${body.toByteArray(StandardCharsets.UTF_8).size}\r\n" +
+      "Connection: close\r\n\r\n" +
+      body
+  }
+
+  private fun parseHeaders(headerText: String): Map<String, String> {
+    return headerText.split("\r\n")
+      .drop(1)
+      .mapNotNull { line ->
+        val separator = line.indexOf(':')
+        if (separator <= 0) return@mapNotNull null
+        val name = line.substring(0, separator).trim().lowercase()
+        val value = line.substring(separator + 1).trim()
+        name to value
+      }
+      .toMap()
+  }
+
+  private fun parseContentLength(headers: Map<String, String>): Int {
+    return headers["content-length"]?.toIntOrNull() ?: 0
+  }
+
+  private fun indexOf(haystack: ByteArray, needle: ByteArray): Int {
+    outer@ for (i in 0..haystack.size - needle.size) {
+      for (j in needle.indices) {
+        if (haystack[i + j] != needle[j]) continue@outer
+      }
+      return i
+    }
+    return -1
+  }
+}

package/app.plugin.js

@@ -0,0 +1,3 @@
+const withRNDriverTouchCompanion = require('./plugin/withRNDriverTouchCompanion')
+
+module.exports = withRNDriverTouchCompanion

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@unrulysystems/rn-playwright-driver-instrumentation-companion",
+  "version": "0.1.1",
+  "description": "Android Instrumentation HTTP companion for RN Playwright driver touch injection",
+  "keywords": [
+    "android",
+    "config-plugin",
+    "expo",
+    "instrumentation",
+    "react-native"
+  ],
+  "homepage": "https://github.com/unrulysystems/rn-playwright-driver#readme",
+  "license": "MIT",
+  "author": "0xbigboss",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/unrulysystems/rn-playwright-driver.git",
+    "directory": "packages/instrumentation-companion"
+  },
+  "files": [
+    "CHANGELOG.md",
+    "README.md",
+    "android/build.gradle",
+    "android/src",
+    "app.plugin.js",
+    "plugin/withRNDriverTouchCompanion.js"
+  ],
+  "main": "app.plugin.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "echo 'Android instrumentation companion - no JS build needed'",
+    "clean": "echo 'Android instrumentation companion - no JS build artifacts'",
+    "test": "bun test plugin/withRNDriverTouchCompanion.test.js"
+  },
+  "dependencies": {
+    "@expo/config-plugins": "~54.0.4"
+  },
+  "peerDependencies": {
+    "expo": "*",
+    "react-native": "*"
+  },
+  "expo": {
+    "plugins": [
+      "./app.plugin.js"
+    ]
+  },
+  "plugin": "app.plugin.js"
+}

package/plugin/withRNDriverTouchCompanion.js

@@ -0,0 +1,146 @@
+const {
+  withAndroidManifest,
+  withAppBuildGradle,
+  withDangerousMod,
+} = require('@expo/config-plugins')
+const fs = require('fs')
+const path = require('path')
+
+const COMPANION_CLASS = 'com.rndriver.touchcompanion.RNDriverTouchCompanion'
+const GENERATED_TAG = 'rn-driver-touch-companion'
+const TEST_RUNNER_DEP = 'androidTestImplementation "androidx.test:runner:1.6.2"'
+const TEST_CORE_DEP = 'androidTestImplementation "androidx.test:core:1.6.1"'
+
+function withRNDriverTouchCompanion(config) {
+  config = withAndroidManifest(config, (androidConfig) => {
+    const manifest = androidConfig.modResults.manifest
+    const applicationId = getAndroidPackage(androidConfig, manifest)
+    if (!applicationId) {
+      throw new Error(
+        'RN Driver Touch Companion requires expo.android.package so the androidTest instrumentation can target the app.',
+      )
+    }
+    return androidConfig
+  })
+
+  config = withAppBuildGradle(config, (gradleConfig) => {
+    gradleConfig.modResults.contents = addAndroidTestGradleConfig(gradleConfig.modResults.contents)
+    return gradleConfig
+  })
+
+  config = withDangerousMod(config, [
+    'android',
+    async (dangerousConfig) => {
+      const applicationId = getAndroidPackage(dangerousConfig)
+      if (!applicationId) {
+        throw new Error(
+          'RN Driver Touch Companion requires expo.android.package so the androidTest instrumentation can target the app.',
+        )
+      }
+
+      const projectRoot = dangerousConfig.modRequest.platformProjectRoot
+      const javaDest = path.join(
+        projectRoot,
+        'app/src/androidTest/java/com/rndriver/touchcompanion/RNDriverTouchCompanion.kt',
+      )
+      const manifestDest = path.join(projectRoot, 'app/src/androidTest/AndroidManifest.xml')
+      const source = path.join(
+        __dirname,
+        '../android/src/main/java/com/rndriver/touchcompanion/RNDriverTouchCompanion.kt',
+      )
+
+      await fs.promises.mkdir(path.dirname(javaDest), { recursive: true })
+      await fs.promises.mkdir(path.dirname(manifestDest), { recursive: true })
+      await fs.promises.copyFile(source, javaDest)
+      await fs.promises.writeFile(manifestDest, androidTestManifest(applicationId))
+
+      return dangerousConfig
+    },
+  ])
+
+  return config
+}
+
+function getAndroidPackage(config, manifest) {
+  return config.android?.package || manifest?.$?.package || null
+}
+
+function addAndroidTestGradleConfig(contents) {
+  let next = contents
+
+  if (!next.includes(TEST_RUNNER_DEP)) {
+    next = addToDependenciesBlock(next, TEST_RUNNER_DEP)
+  }
+  if (!next.includes(TEST_CORE_DEP)) {
+    next = addToDependenciesBlock(next, TEST_CORE_DEP)
+  }
+
+  return next
+}
+
+function addToDependenciesBlock(contents, line) {
+  return addToNamedBlock(contents, 'dependencies', generatedBlock(line, '  '))
+}
+
+function addToNamedBlock(contents, blockName, block) {
+  const blockRegex = new RegExp(`(^|\\n)(\\s*)${blockName}\\s*\\{`)
+  const match = blockRegex.exec(contents)
+
+  if (!match) {
+    return `${contents.trimEnd()}\n\n${blockName} {\n${block}\n}\n`
+  }
+
+  const openBraceIndex = match.index + match[0].lastIndexOf('{')
+  const closeBraceIndex = findMatchingBrace(contents, openBraceIndex)
+  if (closeBraceIndex < 0) {
+    throw new Error(
+      `Could not find closing brace for ${blockName} block in android/app/build.gradle`,
+    )
+  }
+
+  return `${contents.slice(0, closeBraceIndex).trimEnd()}\n${block}\n${contents.slice(closeBraceIndex)}`
+}
+
+function generatedBlock(line, indent) {
+  return [
+    `${indent}// @generated begin ${GENERATED_TAG}`,
+    `${indent}${line}`,
+    `${indent}// @generated end ${GENERATED_TAG}`,
+  ].join('\n')
+}
+
+function findMatchingBrace(contents, openBraceIndex) {
+  let depth = 0
+
+  for (let index = openBraceIndex; index < contents.length; index += 1) {
+    const char = contents[index]
+    if (char === '{') {
+      depth += 1
+    } else if (char === '}') {
+      depth -= 1
+      if (depth === 0) {
+        return index
+      }
+    }
+  }
+
+  return -1
+}
+
+function androidTestManifest(applicationId) {
+  return `<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+  package="${applicationId}.test">
+  <uses-permission android:name="android.permission.INTERNET" />
+  <instrumentation
+    android:name="${COMPANION_CLASS}"
+    android:targetPackage="${applicationId}"
+    android:functionalTest="false"
+    android:handleProfiling="false"
+    android:label="RN Driver Touch Companion" />
+</manifest>
+`
+}
+
+module.exports = withRNDriverTouchCompanion
+module.exports.addAndroidTestGradleConfig = addAndroidTestGradleConfig
+module.exports.androidTestManifest = androidTestManifest