android_ui_verification
Automated end-to-end UI testing and verification on an Android Emulator using ADB.
Best use case
android_ui_verification is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Automated end-to-end UI testing and verification on an Android Emulator using ADB.
Teams using android_ui_verification should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/android_ui_verification/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How android_ui_verification Compares
| Feature / Agent | android_ui_verification | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Automated end-to-end UI testing and verification on an Android Emulator using ADB.
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.
SKILL.md Source
# Android UI Verification Skill This skill provides a systematic approach to testing React Native applications on an Android emulator using ADB commands. It allows for autonomous interaction, state verification, and visual regression checking. ## When to Use - Verifying UI changes in React Native or Native Android apps. - Autonomous debugging of layout issues or interaction bugs. - Ensuring feature functionality when manual testing is too slow. - Capturing automated screenshots for PR documentation. ## 🛠 Prerequisites - Android Emulator running. - `adb` installed and in PATH. - Application in debug mode for logcat access. ## 🚀 Workflow ### 1. Device Calibration Before interacting, always verify the screen resolution to ensure tap coordinates are accurate. ```bash adb shell wm size ``` *Note: Layouts are often scaled. Use the physical size returned as the base for coordinate calculations.* ### 2. UI Inspection (State Discovery) Use the `uiautomator` dump to find the exact bounds of UI elements (buttons, inputs). ```bash adb shell uiautomator dump /sdcard/view.xml && adb pull /sdcard/view.xml ./artifacts/view.xml ``` Search the `view.xml` for `text`, `content-desc`, or `resource-id`. The `bounds` attribute `[x1,y1][x2,y2]` defines the clickable area. ### 3. Interaction Commands - **Tap**: `adb shell input tap <x> <y>` (Use the center of the element bounds). - **Swipe**: `adb shell input swipe <x1> <y1> <x2> <y2> <duration_ms>` (Used for scrolling). - **Text Input**: `adb shell input text "<message>"` (Note: Limited support for special characters). - **Key Events**: `adb shell input keyevent <code_id>` (e.g., 66 for Enter). ### 4. Verification & Reporting #### Visual Verification Capture a screenshot after interaction to confirm UI changes. ```bash adb shell screencap -p /sdcard/screen.png && adb pull /sdcard/screen.png ./artifacts/test_result.png ``` #### Analytical Verification Monitor the JS console logs in real-time to detect errors or log successes. ```bash adb logcat -d | grep "ReactNativeJS" | tail -n 20 ``` #### Cleanup Always store generated files in the `artifacts/` folder to satisfy project organization rules. ## 💡 Best Practices - **Wait for Animations**: Always add a short sleep (e.g., 1-2s) between interaction and verification. - **Center Taps**: Calculate the arithmetic mean of `[x1,y1][x2,y2]` for the most reliable tap target. - **Log Markers**: Use distinct log messages in the code (e.g., `✅ Action Successful`) to make `grep` verification easy. - **Fail Fast**: If a `uiautomator dump` fails or doesn't find the expected text, stop and troubleshoot rather than blind-tapping.
Related Skills
android-ux-flows
This skill is used to design Android user flows and screen structures that match the existing app patterns and keep forms, lists and navigation clear.
android-ui-design-guide
Apply Android/Jetpack Compose design principles following Material Design 3 when building any Android UI component. Only execute this when the current project is an Android project and involves UI-related work. Use this skill for Compose layouts, Material components, or Android app development. Ensures Material You compliance with Dynamic Color, expressive theming, 4dp grid spacing, Roboto typography with Type Scale, and native Android patterns. Prevents common anti-patterns like hardcoded colors, Dark Mode neglect, and touch target violations.
android-ui-compose
This skill is used to implement Android UI in Jetpack Compose based on an existing UX flow, focusing on clear hierarchy, list vs form separation and discoverable navigation.
android-jetpack-compose-expert
Expert guidance for building modern Android UIs with Jetpack Compose, covering state management, navigation, performance, and Material Design 3.
implementing-android-code
This skill should be used when implementing Android code in Bitwarden. Covers critical patterns, gotchas, and anti-patterns unique to this codebase. Triggered by "How do I implement a ViewModel?", "Create a new screen", "Add navigation", "Write a repository", "BaseViewModel pattern", "State-Action-Event", "type-safe navigation", "@Serializable route", "SavedStateHandle persistence", "process death recovery", "handleAction", "sendAction", "Hilt module", "Repository pattern", "implementing a screen", "adding a data source", "handling navigation", "encrypted storage", "security patterns", "Clock injection", "DataState", or any questions about implementing features, screens, ViewModels, data sources, or navigation in the Bitwarden Android app.
android-agent-skills
Production-ready Agent Skills framework for Android Kotlin development. Provides Clean Architecture patterns, Jetpack Compose best practices, validation DSL, MVI state management, error handling, and AI-powered code generation. Use when building Android apps with quality standards, generating ViewModels, Repositories, UseCases, Compose screens, or writing pure Kotlin Agent Skills.
Verification & Quality Assurance
Comprehensive truth scoring, code quality verification, and automatic rollback system with 0.95 accuracy threshold for ensuring high-quality agent outputs and codebase reliability.
android-workflow-beta
Generate GitHub Actions workflow for beta testing track deployment
android-screenshot-automation
Setup automated screenshot capture for Play Store using Fastlane Screengrab
android-playstore-publishing
Complete workflow generation - orchestrates internal, beta, and production deployment workflows
android-emulator-skill
Production-ready scripts for Android app testing, building, and automation. Provides semantic UI navigation, build automation, accessibility testing, and emulator lifecycle management. Optimized for AI agents with minimal token output. Android equivalent of ios-simulator-skill.
adb-android-control
Comprehensive Android device control via ADB (Android Debug Bridge). Use when user asks about: Android device management, app installation/uninstallation, APK operations, package management, file transfer (push/pull), screenshots, screen recording, input simulation (tap/swipe/text/keyevents), shell commands, logcat viewing, device info (battery/memory/storage), automation scripts, wireless ADB connection, scrcpy mirroring. Keywords: adb, android, phone, tablet, device, apk, install app, uninstall app, screenshot, screen record, tap, swipe, type text, keyevent, logcat, push file, pull file, shell, package, activity, intent, broadcast, dumpsys, getprop, settings, input, sendevent, monkey, am start, pm list, device info, battery status, wireless adb, connect device.