android-emulator
Control and interact with Android emulators using the `andy` CLI to launch apps, tap UI elements, take screenshots, and read accessibility trees for automated testing and UI verification.
About this skill
The `android-emulator` skill provides AI agents with the ability to programmatically interact with an Android emulator through the `andy` command-line interface. This skill enables a broad range of actions including launching applications, navigating UI by tapping on text labels or coordinates, performing swipe gestures, and sending key events. Crucially, it allows agents to capture screenshots and read the full accessibility tree of the current screen, which is vital for understanding the UI state. This skill is designed for automating tasks that typically require manual interaction with an Android device. Its primary use cases involve automated testing, continuous integration for mobile apps, and detailed UI/UX verification. By combining actions like `andy tap` with verification steps like `andy a11y` (accessibility tree) and `andy screenshot`, agents can build robust workflows to test user flows, identify UI regressions, and ensure application responsiveness. An agent can leverage this skill to simulate user interactions, verify the visual and logical state of an application, and record evidence of its operation. The skill's focus on `a11y` trees helps agents understand UI elements structurally, while screenshots provide visual context, making it a powerful tool for comprehensive Android app automation in an emulated environment.
Best use case
The primary use case for this skill is automated testing and verification of Android applications within an emulated environment. Developers, QA engineers, and AI agents tasked with ensuring the quality, functionality, and user experience of Android apps benefit most, as it enables them to programmatically interact with the app, perform actions, and validate outcomes without manual intervention.
Control and interact with Android emulators using the `andy` CLI to launch apps, tap UI elements, take screenshots, and read accessibility trees for automated testing and UI verification.
A successfully controlled Android emulator performing specified actions, with clear feedback on UI element interaction, visual state via screenshots, and structural information from accessibility trees.
Practical example
Example input
Launch the Android emulator, open the 'Settings' app, tap on 'About phone', and capture a screenshot. Then, read the accessibility tree of the 'About phone' screen.
Example output
Emulator launched and 'Settings' app opened. Successfully tapped 'About phone'. Screenshot saved to `/tmp/about_phone_screen.png`. Accessibility tree for 'About phone' screen: (0,0,1080,24) TITLE 'About phone' (0,90,1080,180) TEXT 'Android version' ...
When to use this skill
- Automating UI tests for Android applications in a continuous integration/delivery pipeline.
- Verifying application behavior, layout, and functionality after code changes.
- Debugging UI issues or recreating user-reported bugs within a controlled emulator environment.
- Generating visual and accessibility documentation of Android app screens and user flows.
When not to use this skill
- For tasks not involving Android applications or emulators.
- When deep code-level debugging requiring an IDE is necessary.
- If interaction with a physical Android device is strictly required (as this skill focuses on emulators).
- For tasks that require direct filesystem access or low-level system interaction beyond what the `andy` CLI offers.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/android-emulator/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How android-emulator Compares
| Feature / Agent | android-emulator | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | easy | N/A |
Frequently Asked Questions
What does this skill do?
Control and interact with Android emulators using the `andy` CLI to launch apps, tap UI elements, take screenshots, and read accessibility trees for automated testing and UI verification.
How difficult is it to install?
The installation complexity is rated as easy. You can find the installation instructions above.
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
Related Guides
AI Agents for Coding
Browse AI agent skills for coding, debugging, testing, refactoring, code review, and developer workflows across Claude, Cursor, and Codex.
Top AI Agents for Productivity
See the top AI agent skills for productivity, workflow automation, operational systems, documentation, and everyday task execution.
Best AI Skills for Claude
Explore the best AI skills for Claude and Claude Code across coding, research, workflow automation, documentation, and agent operations.
SKILL.md Source
# Andy - android automation - Andy is a CLI for controlling and viewing android apps. - Use Andy to verify your work. - Screens are auto-created with defaults (1080x1920, 240dpi). ## Quick start ```bash # Launch app and verify andy launch && andy a11y && andy screenshot /tmp/s.png # Use Read tool on screenshot only if a11y is ambiguous or visual verification needed. # Tap by text and verify andy tap "Get started" && andy a11y && andy screenshot /tmp/s.png # Tap unlabeled element by coordinates (from a11y bounds) andy tap 945,80 && andy a11y && andy screenshot /tmp/s.png # Scroll down to find more elements andy swipe 540 1400 540 400 && andy a11y && andy screenshot /tmp/s.png # Dismiss dialog and go back andy key 4 && andy a11y && andy screenshot /tmp/s.png ``` ## Workflow tips - **screenshot and a11y auto-wait for idle.** You do NOT need `wait-for-idle` or `sleep` before them — auto-wait is more efficient than fixed sleeps. They print `note: waited Xms for idle` when they wait. - **Chain commands with `&&`** for tap-then-verify workflows: `andy tap "OK" && andy screenshot /tmp/s.png` - **Always check `a11y` on unfamiliar screens** before tapping by text. Many elements (tab bars, icon buttons, header icons) have NO text labels and require coordinate taps. - **a11y bounds are `(left,top,right,bottom)`**. To tap center: `((left+right)/2, (top+bottom)/2)`. - **When to read screenshots vs rely on a11y:** - **Navigate/automate** → a11y only (save tokens) - **Verify/check/test a flow** → ALWAYS read screenshots at each step - **Verify a non-UI bug fix** → a11y only is fine - **Created/modified UI** → ALWAYS read screenshots to check layout and styling - **`tap "text"` errors if text is not in the a11y tree.** It does NOT do fuzzy matching. Use exact text from a11y output. - **Andy runs in a sandbox.** Explore freely. - **Overlays/bottom sheets hide elements underneath** from the a11y tree. Dismiss them first (tap or key 4 BACK). - **Key 4 (BACK)** is essential: dismisses dialogs, closes overlays, navigates back. - **Scroll with swipe.** Elements off-screen won't appear in a11y. Swipe to scroll: `andy swipe 540 1400 540 400` (scroll down) or `andy swipe 540 400 540 1400` (scroll up). Screen is 1080x1920. ## Reference ```bash andy info # screen info (JSON) andy screenshot [--no-wait] /tmp/s.png # save screenshot (auto-waits for idle) andy a11y [--no-wait] # human-readable accessibility tree (auto-waits for idle) andy tap "Button text" # tap by a11y text or content_desc andy tap 500,300 # tap by coordinates andy swipe 500 1500 500 500 # swipe (optional 5th arg: duration_ms, default 300) andy type "hello" # type text andy key 4 # send keycode (3=HOME, 4=BACK, 66=ENTER) andy launch # launch ANDY_PACKAGE andy stop # force-stop ANDY_PACKAGE (rarely needed — launch auto-closes existing) andy reset # clear app data & stop (pm clear ANDY_PACKAGE) andy open-url https://example.com # open URL in ANDY_PACKAGE andy wait-for-idle # explicit idle wait (rarely needed) andy screens # list all screens (debug) ``` Use `--screen <name>` for non-default screens.
Related Skills
android-clean-architecture
适用于Android和Kotlin多平台项目的Clean Architecture模式——模块结构、依赖规则、用例、仓库以及数据层模式。
android-order
Order food/drinks (点餐) on an Android device paired as an OpenClaw node. Uses in-app menu and cart; add goods, view cart, submit order (demo, no real payment).
android_ui_verification
Automated end-to-end UI testing and verification on an Android Emulator using ADB.
android-jetpack-compose-expert
Expert guidance for building modern Android UIs with Jetpack Compose, covering state management, navigation, performance, and Material Design 3.
android-native-dev
Android native application development and UI design guide. Covers Material Design 3, Kotlin/Compose development, project configuration, accessibility, and build troubleshooting. Read this before Android native application development.
testing-android-intents-for-vulnerabilities
Tests Android inter-process communication (IPC) through intents for vulnerabilities including intent injection, unauthorized component access, broadcast sniffing, pending intent hijacking, and content provider data leakage. Use when assessing Android app attack surface through exported components, testing intent-based data flows, or evaluating IPC security. Activates for requests involving Android intent security, IPC testing, exported component analysis, or Drozer assessment.
reverse-engineering-android-malware-with-jadx
Reverse engineers malicious Android APK files using JADX decompiler to analyze Java/Kotlin source code, identify malicious functionality including data theft, C2 communication, privilege escalation, and overlay attacks. Examines manifest permissions, receivers, services, and native libraries. Activates for requests involving Android malware analysis, APK reverse engineering, mobile malware investigation, or Android threat analysis.
performing-dynamic-analysis-of-android-app
Performs runtime dynamic analysis of Android applications using Frida, Objection, and Android Debug Bridge to observe application behavior during execution, intercept function calls, modify runtime values, and identify vulnerabilities that static analysis misses. Use when testing Android apps for runtime security flaws, hooking sensitive methods, bypassing client-side protections, or analyzing obfuscated applications. Activates for requests involving Android dynamic analysis, runtime hooking, Frida Android instrumentation, or live app behavior analysis.
performing-android-app-static-analysis-with-mobsf
Performs automated static analysis of Android applications using Mobile Security Framework (MobSF) to identify hardcoded secrets, insecure permissions, vulnerable components, weak cryptography, and code-level security flaws without executing the application. Use when assessing Android APK/AAB files for security vulnerabilities before deployment, during penetration testing, or as part of CI/CD security gates. Activates for requests involving Android static analysis, MobSF scanning, APK security assessment, or mobile application code review.
analyzing-android-malware-with-apktool
Perform static analysis of Android APK malware samples using apktool for decompilation, jadx for Java source recovery, and androguard for permission analysis, manifest inspection, and suspicious API call detection.
Pocket Alert – Push Notifications for iOS and Android
The Pocket Alert (pocketalert.app) skill for OpenClaw enables OpenClaw agents and workflows to send push notifications to iOS and Android devices. It is used to deliver alerts and updates from automated tasks, workflows, and background processes.
android-transfer-secure
Securely transfers files from macOS to Android with checksum verification and path validation.