Scale computer-use 2.0 with open-source drivers, cross-OS sandboxes, and benchmarks for training, evaluation, and data generation.
Rust agentai-agentapplecomputer-usecomputer-use-agentcontainerizationcuadesktop-automationhacktoberfestlumemacosmanusoperatorswiftvirtualizationvirtualization-frameworkwindowswindows-sandbox
"""Android Emulator runtime — uses the official Android SDK emulator.
Follows the docker-android pattern:
1. Auto-installs Android command-line tools + SDK if needed
2. Creates an AVD (Android Virtual Device)
3. Launches the emulator with `-no-boot-anim -no-window -no-snapshot`
4. Waits for `sys.boot_completed == 1` via ADB
5. Supports APK installation via ADB
On Apple Silicon Macs, uses ARM64 system images with HVF acceleration.
On x86_64 hosts, uses x86_64 system images with KVM/HAXM.
"""
from __future__ import annotations
import asyncio
import logging
import os
import platform as _plat
import shutil
import socket
import subprocess
from pathlib import Path
from typing import Optional
from cua_sandbox._paths import cua_home
from cua_sandbox.image import Image
from cua_sandbox.runtime.base import Runtime, RuntimeInfo
logger = logging.getLogger(__name__)
# ── SDK paths ────────────────────────────────────────────────────────────────
_SDK_ROOT = cua_home() / "android-sdk"
_AVD_HOME = cua_home() / "android-avd"
_CMDLINE_TOOLS_VERSION = "11076708" # Latest as of 2024
def _java_env() -> dict:
"""Return env dict with JAVA_HOME set if needed."""
env = os.environ.copy()
if env.get("JAVA_HOME"):
return env
# Try Homebrew OpenJDK (macOS)
brew_jdk = Path("/opt/homebrew/opt/openjdk/libexec/openjdk.jdk/Contents/Home")
if not brew_jdk.exists():
# Intel Mac
brew_jdk = Path("/usr/local/opt/openjdk/libexec/openjdk.jdk/Contents/Home")
if brew_jdk.exists():
env["JAVA_HOME"] = str(brew_jdk)
env["PATH"] = f"{brew_jdk / 'bin'}:{env.get('PATH', '')}"
return env
# Check if java works without JAVA_HOME
try:
result = subprocess.run(["java", "-version"], capture_output=True, timeout=5)
if result.returncode == 0:
return env
except (subprocess.SubprocessError, FileNotFoundError):
pass
raise RuntimeError("Java not found. Install via: brew install openjdk")
def _sdk_path() -> Path:
"""Return the Android SDK root, preferring existing installations."""
for env in ("ANDROID_HOME", "ANDROID_SDK_ROOT"):
val = os.environ.get(env)
if val and Path(val).exists():
return Path(val)
# Check common install locations
common = [
Path.home() / "Library" / "Android" / "sdk", # Android Studio (macOS)
Path("/opt/android"), # docker-android
Path.home() / "Android" / "Sdk", # Linux
Path(os.environ.get("LOCALAPPDATA", "")) / "Android" / "Sdk", # Android Studio (Windows)
Path.home() / "AppData" / "Local" / "Android" / "Sdk", # Windows fallback
]
for p in common:
if (p / "emulator").exists():
return p
return _SDK_ROOT
def _ensure_sdk() -> Path:
"""Ensure Android SDK command-line tools, emulator, and platform-tools are installed."""
sdk = _sdk_path()
_win = _plat.system().lower() == "windows"
_ext = ".exe" if _win else ""
_bat = ".bat" if _win else ""
emulator_bin = sdk / "emulator" / f"emulator{_ext}"
sdkmanager_bin = sdk / "cmdline-tools" / "latest" / "bin" / f"sdkmanager{_bat}"
adb_bin = sdk / "platform-tools" / f"adb{_ext}"
if emulator_bin.exists() and adb_bin.exists():
return sdk
logger.info(f"Android SDK not found. Installing to {sdk} ...")
sdk.mkdir(parents=True, exist_ok=True)
# Download command-line tools
if not sdkmanager_bin.exists():
system = _plat.system().lower()
if system == "darwin":
tools_url = f"https://dl.google.com/android/repository/commandlinetools-mac-{_CMDLINE_TOOLS_VERSION}_latest.zip"
elif system == "linux":
tools_url = f"https://dl.google.com/android/repository/commandlinetools-linux-{_CMDLINE_TOOLS_VERSION}_latest.zip"
elif system == "windows":
tools_url = f"https://dl.google.com/android/repository/commandlinetools-win-{_CMDLINE_TOOLS_VERSION}_latest.zip"
else:
raise RuntimeError(f"Android SDK auto-install not supported on {system}.")
import urllib.request
import zipfile
zip_path = sdk / "cmdline-tools.zip"
logger.info("Downloading Android command-line tools ...")
urllib.request.urlretrieve(tools_url, str(zip_path))
with zipfile.ZipFile(zip_path) as zf:
zf.extractall(sdk / "cmdline-tools")
# Move to expected path
extracted = sdk / "cmdline-tools" / "cmdline-tools"
dest = sdk / "cmdline-tools" / "latest"
if extracted.exists() and not dest.exists():
extracted.rename(dest)
zip_path.unlink()
# Ensure scripts are executable
for f in (sdk / "cmdline-tools" / "latest" / "bin").iterdir():
f.chmod(0o755)
sdkmanager_bin = sdk / "cmdline-tools" / "latest" / "bin" / f"sdkmanager{_bat}"
if not sdkmanager_bin.exists():
raise RuntimeError(f"sdkmanager not found at {sdkmanager_bin}")
env = _java_env()
# Accept licenses
logger.info("Accepting Android SDK licenses ...")
subprocess.run(
[str(sdkmanager_bin), f"--sdk_root={sdk}", "--licenses"],
input=b"y\ny\ny\ny\ny\ny\ny\ny\n",
capture_output=True,
timeout=120,
env=env,
)
# Install emulator, platform-tools, and system image
arch = "arm64-v8a" if _plat.machine() in ("arm64", "aarch64") else "x86_64"
api_level = "34"
img_type = "google_apis"
package = f"system-images;android-{api_level};{img_type};{arch}"
platform = f"platforms;android-{api_level}"
logger.info(f"Installing Android SDK packages: {package} ...")
result = subprocess.run(
[
str(sdkmanager_bin),
f"--sdk_root={sdk}",
"--install",
package,
platform,
"platform-tools",
"emulator",
],
capture_output=True,
text=True,
timeout=600,
env=env,
)
if result.returncode != 0:
raise RuntimeError(f"sdkmanager install failed: {result.stderr}")
logger.info("Android SDK installation complete.")
return sdk
def _find_free_emulator_port() -> int:
"""Return a free odd adb_port (console_port = adb_port - 1, must be even).
Scans even console ports 5554–5682; returns the first pair where both
console_port and adb_port are not in use (TCP bind check).
"""
for console_port in range(5554, 5684, 2): # 5554, 5556, ..., 5682
adb_port = console_port + 1
free = True
for port in (console_port, adb_port):
try:
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.bind(("127.0.0.1", port))
except OSError:
free = False
break
if free:
return adb_port
raise RuntimeError("No free Android emulator port pair found in range 5554–5682")
def _find_bin(sdk: Path, name: str) -> str:
"""Find a binary in the SDK, handling .exe/.bat on Windows."""
exts = ["", ".exe", ".bat"] if _plat.system().lower() == "windows" else [""]
dirs = [
sdk / "emulator",
sdk / "platform-tools",
sdk / "cmdline-tools" / "latest" / "bin",
]
for d in dirs:
for ext in exts:
c = d / f"{name}{ext}"
if c.exists():
return str(c)
# Fall back to PATH
found = shutil.which(name)
if found:
return found
raise FileNotFoundError(f"{name} not found in SDK at {sdk}")
class AndroidEmulatorRuntime(Runtime):
"""Android emulator runtime using the official Android SDK.
Creates an AVD and launches the Android emulator, following the
docker-android pattern. Uses ADB for boot detection, APK install,
and shell commands.
"""
def __init__(
self,
*,
api_level: int = 34,
img_type: str = "google_apis",
device_id: str = "pixel",
memory_mb: int = 4096,
cpu_count: int = 4,
adb_port: Optional[int] = None,
no_boot_anim: bool = True,
gpu_mode: str = "swiftshader_indirect",
headless: bool = True,
grpc_port: Optional[int] = None,
):
self.api_level = api_level
self.img_type = img_type
self.device_id = device_id
self.memory_mb = memory_mb
self.cpu_count = cpu_count
self.adb_port = adb_port
self.no_boot_anim = no_boot_anim
self.gpu_mode = gpu_mode
self.headless = headless
self.grpc_port = grpc_port
self._proc: Optional[subprocess.Popen] = None
self._avd_name: Optional[str] = None
self._sdk: Optional[Path] = None
async def start(self, image: Image, name: str, **opts) -> RuntimeInfo:
self._sdk = _ensure_sdk()
self._avd_name = name
# Resolve port lazily so callers don't need to pick one
if self.adb_port is None:
self.adb_port = _find_free_emulator_port()
logger.info(
f"Auto-selected emulator port: console={self.adb_port - 1}, adb={self.adb_port}"
)
arch = "arm64-v8a" if _plat.machine() in ("arm64", "aarch64") else "x86_64"
package = f"system-images;android-{self.api_level};{self.img_type};{arch}"
abi = f"{self.img_type}/{arch}"
avdmanager = _find_bin(self._sdk, "avdmanager")
emulator = _find_bin(self._sdk, "emulator")
adb = _find_bin(self._sdk, "adb")
# Set AVD home
_AVD_HOME.mkdir(parents=True, exist_ok=True)
env = _java_env()
env["ANDROID_SDK_ROOT"] = str(self._sdk)
env["ANDROID_AVD_HOME"] = str(_AVD_HOME)
env["ANDROID_EMULATOR_WAIT_TIME_BEFORE_KILL"] = "10"
# Create AVD if it doesn't exist
avd_dir = _AVD_HOME / f"{name}.avd"
if not avd_dir.exists():
logger.info(f"Creating AVD '{name}' with {package} ...")
result = subprocess.run(
[
avdmanager,
"create",
"avd",
"--force",
"--name",
name,
"--abi",
abi,
"--package",
package,
"--device",
self.device_id,
],
input="no\n",
capture_output=True,
text=True,
env=env,
timeout=60,
)
if result.returncode != 0:
raise RuntimeError(f"AVD creation failed: {result.stderr}\n{result.stdout}")
logger.info(f"AVD '{name}' created.")
# Start ADB server
subprocess.run([adb, "start-server"], capture_output=True, env=env)
# Launch emulator
cmd = [
emulator,
"-avd",
name,
"-gpu",
self.gpu_mode,
"-memory",
str(self.memory_mb),
"-cores",
str(self.cpu_count),
*(["-no-window"] if self.headless else []),
"-no-snapshot",
"-skip-adb-auth",
"-port",
str(self.adb_port - 1), # console port = adb_port - 1
]
if self.no_boot_anim:
cmd.append("-no-boot-anim")
# gRPC service: defaults to console_port+3000 if not specified
resolved_grpc_port = self.grpc_port or (self.adb_port - 1 + 3000)
cmd += ["-grpc", str(resolved_grpc_port)]
logger.info(f"Starting Android emulator: {' '.join(cmd)}")
self._proc = subprocess.Popen(
cmd,
stdout=subprocess.DEVNULL,
stderr=subprocess.PIPE,
env=env,
)
# Brief check that it didn't crash immediately
await asyncio.sleep(3)
if self._proc.poll() is not None:
stderr = self._proc.stderr.read().decode() if self._proc.stderr else ""
raise RuntimeError(f"Emulator crashed on launch: {stderr}")
info = RuntimeInfo(
host="localhost",
api_port=self.adb_port,
name=name,
environment="android",
grpc_port=resolved_grpc_port,
)
# Install APKs from image layers
await self.is_ready(info)
await self._apply_layers(image, adb, env)
return info
async def _apply_layers(self, image: Image, adb: str, env: dict) -> None:
"""Apply image layers post-boot (APK installs, shell commands, etc.)."""
serial = f"emulator-{self.adb_port - 1}"
# Write image env vars to a persistent file so every subsequent
# adb shell command (including those from the transport) can source it.
if image._env:
import re
import shlex
import tempfile
lines = []
for k, v in image._env:
if not re.fullmatch(r"[A-Za-z_][A-Za-z0-9_]*", k):
raise ValueError(f"Invalid environment variable name: {k!r}")
lines.append(f"export {k}={shlex.quote(v)}")
exports = "\n".join(lines) + "\n"
with tempfile.NamedTemporaryFile(mode="w", suffix=".sh", delete=False) as f:
f.write(exports)
tmp_path = f.name
subprocess.run(
[adb, "-s", serial, "push", tmp_path, "/data/local/tmp/.cua_env"],
capture_output=True,
env=env,
timeout=10,
)
Path(tmp_path).unlink(missing_ok=True)
for layer in image._layers:
lt = layer["type"]
if lt == "apk_install":
for apk in layer["packages"]:
# Download URL-based APKs
local_apk = await self._resolve_apk(apk)
logger.info(f"Installing APK: {local_apk}")
result = subprocess.run(
[adb, "-s", serial, "install", "-r", str(local_apk)],
capture_output=True,
text=True,
env=env,
timeout=120,
)
if result.returncode != 0:
logger.warning(f"APK install failed: {result.stderr}")
else:
logger.info(f"APK installed: {result.stdout.strip()}")
elif lt == "pwa_install":
manifest_url = layer["manifest_url"]
pkg = layer.get("package_name")
ks = Path(layer["keystore"]) if layer.get("keystore") else None
ks_alias = layer.get("keystore_alias", "android")
ks_pass = layer.get("keystore_password", "android")
builder = layer.get("builder", "pwa2apk")
if builder == "pwa2apk":
from cua_sandbox.builder.pwa2apk import build_pwa2apk
apk_path, fingerprint = await build_pwa2apk(
manifest_url, pkg, ks, ks_alias, ks_pass
)
else:
apk_path, fingerprint = await self._build_pwa_apk(
manifest_url, pkg, ks, ks_alias, ks_pass
)
logger.info(
f"PWA APK built ({builder}): {apk_path}\n"
f" SHA-256 fingerprint: {fingerprint}"
)
logger.info(f"Installing PWA APK: {apk_path}")
result = subprocess.run(
[adb, "-s", serial, "install", "-r", str(apk_path)],
capture_output=True,
text=True,
env=env,
timeout=120,
)
if result.returncode != 0:
logger.warning(f"PWA APK install failed: {result.stderr}")
else:
logger.info(f"PWA APK installed: {result.stdout.strip()}")
# For bubblewrap TWA, set Chrome flags. pwa2apk doesn't need this.
if builder == "bubblewrap":
from urllib.parse import urlparse
origin = f"{urlparse(manifest_url).scheme}://{urlparse(manifest_url).netloc}"
for cmd in [
"am set-debug-app --persistent com.android.chrome",
"mkdir -p /data/local/tmp && "
"echo 'chrome --no-first-run --disable-fre "
"--no-default-browser-check "
f'--disable-digital-asset-link-verification-for-url="{origin}"\' '
"> /data/local/tmp/chrome-command-line",
]:
subprocess.run(
[adb, "-s", serial, "shell", cmd],
capture_output=True,
env=env,
timeout=10,
)
elif lt == "run":
cmd = layer["command"]
logger.info(f"Running: {cmd}")
subprocess.run(
[adb, "-s", serial, "shell", cmd],
capture_output=True,
text=True,
env=env,
timeout=60,
)
elif lt == "pip_install":
# pip install via termux or similar — skip for now
logger.warning("pip_install not supported on Android emulator, skipping")
@staticmethod
async def _build_pwa_apk(
manifest_url: str,
package_name: Optional[str] = None,
keystore_path: Optional[Path] = None,
keystore_alias: str = "android",
keystore_password: str = "android",
) -> tuple[Path, str]:
"""Build a signed APK from a PWA manifest URL using Bubblewrap.
Auto-installs bubblewrap if not on PATH and auto-configures
``~/.bubblewrap/config.json`` from the already-known JDK and SDK paths,
so no manual interactive setup is required.
Returns ``(apk_path, sha256_fingerprint)`` where ``sha256_fingerprint``
is the colon-separated hex digest of the signing certificate — ready to
embed in the server's ``/.well-known/assetlinks.json``.
"""
import hashlib
import json as _json
from urllib.parse import urlparse
env = _java_env()
java_home = env.get("JAVA_HOME", "")
# Prefer Java 21 for Gradle compatibility (bubblewrap uses Gradle 8.x)
for _j21 in (
Path("/opt/homebrew/opt/openjdk@21/libexec/openjdk.jdk/Contents/Home"),
Path("/usr/local/opt/openjdk@21/libexec/openjdk.jdk/Contents/Home"),
):
if _j21.exists():
java_home = str(_j21)
env["JAVA_HOME"] = java_home
env["PATH"] = f"{_j21 / 'bin'}:{env.get('PATH', '')}"
break
jdk_bin = Path(java_home) / "bin" if java_home else Path(".")
keytool = str(jdk_bin / "keytool") if (jdk_bin / "keytool").exists() else "keytool"
# ── 1. Ensure bubblewrap CLI is on PATH ──────────────────────────────
# Augment PATH with common Homebrew node locations so shutil.which finds them
# even when the process was launched without a login shell.
extra_node_paths = ["/opt/homebrew/bin", "/usr/local/bin"]
augmented_path = os.pathsep.join(extra_node_paths) + os.pathsep + env.get("PATH", "")
env["PATH"] = augmented_path
bw = shutil.which("bubblewrap", path=augmented_path)
if not bw:
node = shutil.which("node", path=augmented_path)
npm = shutil.which("npm", path=augmented_path)
if not node or not npm:
raise RuntimeError(
"node/npm not found on PATH; required for pwa_install.\n"
"Install Node.js: https://nodejs.org/"
)
logger.info("Installing @bubblewrap/cli …")
subprocess.run(
[npm, "install", "-g", "@bubblewrap/cli"],
check=True,
capture_output=True,
timeout=300,
)
bw = shutil.which("bubblewrap")
if not bw:
raise RuntimeError(
"bubblewrap still not found after npm install -g @bubblewrap/cli.\n"
"Ensure npm global bin is on PATH."
)
# ── 2. Auto-configure ~/.bubblewrap/config.json ──────────────────────
# bubblewrap expects jdkPath to be the .jdk bundle root on macOS
# (it appends Contents/Home internally). Gradle also requires Java ≤ 21.
def _bubblewrap_jdk_path() -> str:
"""Return the .jdk bundle path suitable for bubblewrap's jdkPath.
Prefers openjdk@21 (Gradle-compatible) over newer versions.
On macOS returns the .jdk bundle root; elsewhere the JDK home.
"""
candidates = [
# Prefer Java 21 — Gradle 8.x supports up to Java 21
Path("/opt/homebrew/opt/openjdk@21/libexec/openjdk.jdk"),
Path("/usr/local/opt/openjdk@21/libexec/openjdk.jdk"),
Path("/opt/homebrew/opt/openjdk@17/libexec/openjdk.jdk"),
# Fall back to whatever _java_env() found
Path(java_home).parent.parent if java_home.endswith("Contents/Home") else None,
Path(java_home) if java_home else None,
]
for c in candidates:
if c and c.exists():
return str(c)
return java_home # last resort
bw_config = Path.home() / ".bubblewrap" / "config.json"
bw_config.parent.mkdir(parents=True, exist_ok=True)
if not bw_config.exists() or not _json.loads(bw_config.read_text()).get("jdkPath"):
sdk = _sdk_path()
cfg = {
"jdkPath": _bubblewrap_jdk_path(),
"androidSdkPath": str(sdk),
}
bw_config.write_text(_json.dumps(cfg, indent=2))
logger.info(f"Wrote ~/.bubblewrap/config.json: jdkPath={cfg['jdkPath']}")
else:
cfg = _json.loads(bw_config.read_text())
# Patch androidSdkPath if it no longer exists
if not Path(cfg.get("androidSdkPath", "")).exists():
cfg["androidSdkPath"] = str(_sdk_path())
bw_config.write_text(_json.dumps(cfg, indent=2))
# ── 2b. Ensure build-tools + tools stub (both required by bubblewrap) ─
sdk = Path(cfg["androidSdkPath"])
sdkmanager = sdk / "cmdline-tools" / "latest" / "bin" / "sdkmanager"
if sdkmanager.exists() and not any(
(sdk / "build-tools").iterdir() if (sdk / "build-tools").exists() else []
):
logger.info("Installing Android build-tools (required by bubblewrap) …")
subprocess.run(
[str(sdkmanager), f"--sdk_root={sdk}", "build-tools;34.0.0"],
input=b"y\n",
capture_output=True,
timeout=300,
env=env,
)
# bubblewrap validates SDK by checking for tools/ or bin/ at sdk root
(sdk / "tools").mkdir(exist_ok=True)
# ── 3. Determine package ID and cache directory ──────────────────────
if not package_name:
import re
host = urlparse(manifest_url).hostname or ""
parts = [p for p in reversed(host.split(".")) if p]
# Sanitize each part: replace non-alphanumeric/underscore chars with _,
# prefix with _ if starts with a digit (invalid Java identifier start).
sanitized = []
for part in parts:
part = re.sub(r"[^a-zA-Z0-9_]", "_", part)
if part and part[0].isdigit():
part = "_" + part
if part:
sanitized.append(part)
package_name = ".".join(sanitized) if sanitized else "com.cua.pwa"
cache_key = hashlib.sha256(f"{manifest_url}|{package_name}".encode()).hexdigest()[:12]
cache_dir = cua_home() / "cua-sandbox" / "pwa-cache" / cache_key
fingerprint_file = cache_dir / "sha256.fingerprint"
signed_apk = cache_dir / "app-release-signed.apk"
if signed_apk.exists() and fingerprint_file.exists():
fingerprint = fingerprint_file.read_text().strip()
logger.info(f"Using cached PWA APK: {signed_apk} fingerprint: {fingerprint}")
return signed_apk, fingerprint
cache_dir.mkdir(parents=True, exist_ok=True)
# ── 4. Resolve keystore ──────────────────────────────────────────────
if keystore_path:
keystore = Path(keystore_path)
if not keystore.exists():
raise RuntimeError(f"Keystore not found: {keystore}")
else:
keystore = cache_dir / "android.keystore"
if not keystore.exists():
logger.info("Generating signing keystore …")
subprocess.run(
[
keytool,
"-genkeypair",
"-v",
"-keystore",
str(keystore),
"-alias",
keystore_alias,
"-keyalg",
"RSA",
"-keysize",
"2048",
"-validity",
"10000",
"-storepass",
keystore_password,
"-keypass",
keystore_password,
"-dname",
"CN=CUA PWA, OU=Dev, O=CUA, L=SF, S=CA, C=US",
],
check=True,
capture_output=True,
timeout=30,
)
# ── 5. Extract SHA-256 fingerprint from the keystore ─────────────────
fp_result = subprocess.run(
[
keytool,
"-list",
"-v",
"-keystore",
str(keystore),
"-alias",
keystore_alias,
"-storepass",
keystore_password,
],
capture_output=True,
text=True,
timeout=15,
)
fingerprint = ""
for line in fp_result.stdout.splitlines():
if "SHA256:" in line:
fingerprint = line.split("SHA256:", 1)[1].strip()
break
if not fingerprint:
raise RuntimeError(
f"Could not extract SHA-256 fingerprint from keystore.\nkeytool output:\n{fp_result.stdout}"
)
fingerprint_file.write_text(fingerprint)
logger.info(f"Keystore SHA-256 fingerprint: {fingerprint}")
# ── 6. Generate twa-manifest.json via _bw_init.js ────────────────────
bw_init_js = Path(__file__).parent / "_bw_init.js"
node = shutil.which("node", path=augmented_path)
if not node:
raise RuntimeError("node not found on PATH; required for pwa_install")
logger.info(f"Generating twa-manifest.json for {manifest_url} …")
init_result = subprocess.run(
[
node,
str(bw_init_js),
manifest_url,
str(cache_dir),
package_name,
str(keystore),
keystore_alias,
keystore_password,
],
capture_output=True,
text=True,
env=env,
timeout=60,
)
if init_result.returncode != 0:
raise RuntimeError(f"_bw_init.js failed for {manifest_url}:\n{init_result.stderr}")
# ── 7. bubblewrap update → Android project ───────────────────────────
logger.info("Running bubblewrap update (generates Android project) …")
update_result = subprocess.run(
[bw, "update", "--skipPwaValidation"],
capture_output=True,
text=True,
cwd=str(cache_dir),
env=env,
timeout=300,
)
if update_result.returncode != 0:
raise RuntimeError(f"bubblewrap update failed:\n{update_result.stderr}")
# ── 8. bubblewrap build → signed APK ─────────────────────────────────
# JAVA_HOME for gradle must point to Contents/Home, not the .jdk bundle.
jdk_bundle = Path(cfg.get("jdkPath", java_home))
contents_home = jdk_bundle / "Contents" / "Home"
gradle_java_home = str(contents_home) if contents_home.exists() else str(jdk_bundle)
bw_env = {
**env,
"JAVA_HOME": gradle_java_home,
"BUBBLEWRAP_KEYSTORE_PASSWORD": keystore_password,
"BUBBLEWRAP_KEY_PASSWORD": keystore_password,
}
logger.info("Running bubblewrap build …")
build_result = subprocess.run(
[bw, "build"],
capture_output=True,
text=True,
cwd=str(cache_dir),
env=bw_env,
timeout=600,
)
if build_result.returncode != 0:
raise RuntimeError(f"bubblewrap build failed:\n{build_result.stderr}")
apks = list(cache_dir.rglob("*.apk"))
if not apks:
raise RuntimeError(
f"bubblewrap build succeeded but no .apk found in {cache_dir}\n"
f"stdout: {build_result.stdout}"
)
logger.info(f"PWA APK built: {apks[0]}")
return apks[0], fingerprint
@staticmethod
async def _resolve_apk(apk_path: str) -> Path:
"""If apk_path is a URL, download it. Otherwise return as-is."""
if apk_path.startswith(("http://", "https://")):
import hashlib
import urllib.request
cache = cua_home() / "cua-sandbox" / "apk-cache"
cache.mkdir(parents=True, exist_ok=True)
filename = apk_path.rsplit("/", 1)[-1].split("?")[0]
url_hash = hashlib.sha256(apk_path.encode()).hexdigest()[:8]
local = cache / f"{url_hash}_{filename}"
if not local.exists():
logger.info(f"Downloading APK: {apk_path}")
urllib.request.urlretrieve(apk_path, str(local))
return local
return Path(apk_path)
async def is_ready(self, info: RuntimeInfo, timeout: float = 300) -> bool:
"""Wait for `sys.boot_completed == 1` via ADB, like docker-android."""
sdk = self._sdk or _sdk_path()
adb = _find_bin(sdk, "adb")
serial = f"emulator-{self.adb_port - 1}"
env = os.environ.copy()
env["ANDROID_SDK_ROOT"] = str(sdk)
logger.info(f"Waiting for Android boot (timeout={timeout}s) ...")
# First wait for ADB device
deadline = asyncio.get_event_loop().time() + timeout
while asyncio.get_event_loop().time() < deadline:
result = subprocess.run(
[adb, "-s", serial, "shell", "getprop", "sys.boot_completed"],
capture_output=True,
text=True,
env=env,
timeout=10,
)
value = result.stdout.strip()
if value == "1":
logger.info(f"Android emulator {info.name} boot completed.")
# Disable animations for faster interaction (docker-android pattern)
for prop in [
"settings put global window_animation_scale 0.0",
"settings put global transition_animation_scale 0.0",
"settings put global animator_duration_scale 0.0",
]:
subprocess.run(
[adb, "-s", serial, "shell", prop],
capture_output=True,
env=env,
)
return True
await asyncio.sleep(5)
raise TimeoutError(f"Android emulator {info.name} did not boot within {timeout}s")
async def list(self) -> list[dict]:
"""List known Android emulator sandboxes from state files, checking if alive."""
import subprocess
from cua_sandbox import sandbox_state
states = [s for s in sandbox_state.list_all() if s.get("runtime_type") == "androidemulator"]
result = []
for s in states:
name = s["name"]
status = s.get("status", "unknown")
if status == "running":
try:
alive = (
subprocess.run(
["pgrep", "-f", f"qemu.*-avd {name}"],
capture_output=True,
).returncode
== 0
)
if not alive:
status = "stopped"
sandbox_state.update(name, status="stopped")
except FileNotFoundError:
pass
result.append(
{
"name": name,
"status": status,
"runtime_type": "androidemulator",
"host": s.get("host"),
"api_port": s.get("api_port"),
"os_type": s.get("os_type"),
}
)
return result
async def stop(self, name: str) -> None:
if self._proc and self._proc.poll() is None:
self._proc.terminate()
try:
self._proc.wait(timeout=15)
except subprocess.TimeoutExpired:
self._proc.kill()
self._proc = None
# Also try ADB kill
try:
sdk = self._sdk or _sdk_path()
adb = _find_bin(sdk, "adb")
subprocess.run(
[adb, "-s", f"emulator-{self.adb_port - 1}", "emu", "kill"],
capture_output=True,
timeout=10,
)
except Exception:
pass
async def take_screenshot(self) -> bytes:
"""Take a screenshot via ADB screencap."""
sdk = self._sdk or _sdk_path()
adb = _find_bin(sdk, "adb")
serial = f"emulator-{self.adb_port - 1}"
# screencap to file, then pull
subprocess.run(
[adb, "-s", serial, "shell", "screencap", "-p", "/sdcard/screenshot.png"],
capture_output=True,
timeout=15,
)
result = subprocess.run(
[adb, "-s", serial, "exec-out", "cat", "/sdcard/screenshot.png"],
capture_output=True,
timeout=15,
)
if result.returncode == 0 and result.stdout[:4] == b"\x89PNG":
return result.stdout
raise RuntimeError("Failed to take screenshot via ADB")