Check the Android development environment: SDK location, adb, emulator, avdmanager, Java, and connected devices. Run this first if any other tool fails with a missing-binary error.

Set default projectDir/module/variant/serial/appId used by other tools when the corresponding argument is omitted. Set these once after discovering the project.

Show the current session defaults.

Clear all session defaults, or only the listed keys.

Find Android/Gradle projects (directories with settings.gradle[.kts]) under a path. Use the result to session_set_defaults projectDir.

List modules declared in settings.gradle(.kts) of the project.

List build variants of a module by inspecting its Gradle assemble tasks (runs './gradlew :tasks').

Get the applicationId (package name) of a module, parsed from its build.gradle(.kts). Needed by install/launch/log tools.

Show toolchain versions: Gradle (from wrapper properties) and everything in the version catalog (AGP, Kotlin, Compose, ...).

Build an APK with Gradle (assemble). On failure returns compact compiler errors with file:line. On success returns the APK path.

Build the APK, install it on a device/emulator (adb install -r), and launch the app. Needs appId (session default or argument) to launch.

Run local JVM unit tests (testUnitTest) and return a parsed pass/fail summary with failure messages.

Run instrumented tests on a connected device/emulator (connectedAndroidTest) and return a parsed summary. Requires a booted device.

Run Android Lint (lint) and return the textual report summary.

Run gradle clean for the project.

Locate the most recent built APK for a module/variant without building.

Stop the project's Gradle daemons (use when a build hangs or to free memory).

List connected devices and emulators with serial, state, model, Android version and API level.

Install an APK on a device/emulator (adb install -r).

Launch an app by application id (resolves the launcher activity automatically).

Force-stop a running app (am force-stop).

Uninstall an app from a device/emulator.

Clear all data of an app (pm clear) — resets it to a fresh-install state.

Get installed-app info from the device: version, target/min SDK, install path, running PID.

List available Android Virtual Devices and which ones are currently running.

Boot an AVD in the background and wait until Android finishes booting. Returns the adb serial. Set wipeData to factory-reset the AVD on boot.

Shut down a running emulator (adb emu kill).

Create an AVD from an installed system image (e.g. 'system-images;android-35;google_apis;arm64-v8a'). If systemImage is omitted, lists the installed images to choose from.

Delete an AVD permanently.

Set the GPS location of a running emulator.

Switch a device/emulator between dark and light mode (cmd uimode night).

Enable clean status bar for screenshots (fixed clock, full battery, full signal) or disable it.

Start recording the device screen (adb screenrecord, max 3 minutes). Returns a recordingId for record_video_stop.

Stop a screen recording and pull the MP4 to the local machine.

Start capturing logcat to a file in the background. Filter by app (via its pid) and/or tag. Returns a sessionId for stop_log_capture. The app must be running to filter by appId.

Stop a log capture session and return the file path plus the last lines.

One-shot dump of recent logcat lines, optionally filtered by app (must be running) and/or tag.

Dump the crash log buffer (Java exceptions, native crashes, ANRs).

Take a screenshot of the device/emulator screen and return it as an image. With annotate: true (needs the Google android CLI), UI elements get numbered bounding boxes — including text inside images/WebViews that snapshot_ui cannot see.

Dump the current UI as a compact list of actionable elements (text, id, content-desc, tap coordinates). Use the @(x,y) centers with tap/long_press. Text-heavy screens are capped; pass 'filter' to search within them.

Tap the screen. Coordinates from snapshot_ui are exact device pixels — prefer them over estimating positions by looking at a screenshot image. Instead of pixels you can pass screen percentages (0-1): safer when estimating positions from a screenshot image.

Tap element #N from the most recent screenshot { annotate: true } capture — no coordinate math needed. The mapping is exact even if your client displays the image scaled. Re-capture after the UI changes: element numbers go stale.

Scroll the screen in a direction (computes a safe swipe in the middle of the screen, avoiding the status bar and navigation areas). Prefer this over raw swipe for scrolling.

Long-press the screen at coordinates. Instead of pixels you can pass screen percentages (0-1): safer when estimating positions from a screenshot image.

Swipe from one point to another (scrolling, dismissing). For drag-and-drop use drag instead. Instead of pixels you can pass screen percentages (0-1): safer when estimating positions from a screenshot image.

Drag an element from one point to another (input draganddrop). Instead of pixels you can pass screen percentages (0-1): safer when estimating positions from a screenshot image.

Type ASCII text into the focused field. Waits for the soft keyboard first, so it is safe to call right after tapping a field. Options: clear the field first, press ENTER after. Non-ASCII characters are not supported by adb input.

Press a hardware/navigation key: BACK, HOME, ENTER, TAB, DELETE, ESCAPE, MENU, APP_SWITCH, DPAD_*, or any KEYCODE_ name.

Press several keys in order (same names as key_press).

Poll the UI until an element containing the given text / content-desc / resource-id appears. Returns its tap coordinates.

Run a coverage Gradle task (Kover or Jacoco) and summarize line coverage per package. Tries koverXmlReport by default; pass 'task' for a custom one (e.g. jacocoTestReport). The project must apply a coverage plugin.

Show covered/uncovered line numbers of one source file from the latest coverage report (run get_coverage_report first).

Create a new minimal Jetpack Compose app project (single module, version catalog, Gradle wrapper included) ready to build with build_app.