---
title: Mobile apps: walk Android and iOS screens like web pages
description: Kaloko drives Android emulators and phones over adb and the iOS Simulator, captures each screen with its UI tree on every device you name, in light and dark mode, checks labels, touch targets and crashes, and lays the app flow out on the same canvas as your web pages.
seo_description: Android emulators and phones over adb, the iOS Simulator and real iPhones: each screen with its UI tree on every device, light and dark, on one canvas.
query: QA of mobile apps with an AI agent
kind: use-case
order: 5
demo: false
---
Your web flows get reviewed on a canvas. The app ships the same features and nobody sees its screens side by side until the store review. Kaloko walks the app too, so both are reviewed in one place.

## The problem

Mobile end-to-end suites prove that a button can be tapped. They do not show whether the screen reads well in Czech, whether a label is cut off on a small phone, whether dark mode leaves grey text on a black background, or whether the icon button has a label for VoiceOver. Screenshots end up in a chat thread, detached from the criteria.

## What changes with Kaloko

The scenario says `platform: android` or `platform: ios`. Steps are reached by deep links or by a short step script. Every step becomes a screenshot and a **UI tree**, criteria are checked against that tree, and the canvas shows the flow with device frames. List several devices (`devices: [pixel-8-api-34, iphone-se-ios-18]`) and add `color_schemes: [light, dark]`, and every screen is captured on each device in both modes. Reviewers accept or return steps exactly as they do for web runs.

## How it works

1. **Name the app** in `kaloko.config.yml` for each environment: the Android package (and an APK to install), or the iOS bundle and simulator. Phones over Wi-Fi and real iPhones get an entry under `devices`.
2. **Describe the flow**: screens with deep links (`shop://product/42`) or scripts such as `app.tap('button[text="Do košíku"]')`. Each locale starts the app fresh in that language.
3. **Walk**: `npx kaloko walk` goes through the flow on each device. An emulator that is not running is started, a phone is woken up and gets a clean status bar. Kaloko captures each screen: `adb screencap` with the uiautomator tree on Android, and `simctl` with the idb tree on iOS (text recognition without idb). It also reads the Android app log for crashes.
4. **Dark mode and motion**: for each capture Kaloko switches the device to dark mode or reduced motion (`cmd uimode` on Android, `simctl ui` on the Simulator) and back afterwards.
5. **Check**: the `app` pack checks labels on every control, touch targets (48 dp / 44 pt), truncated texts and crashes. Your own criteria use CSS-like selectors on the tree. Semantic questions read the screen as an outline. A screen that is a WebView in an Android app can be captured as a web page with every web check.
6. **Anything else**: Maestro, Appium, Detox or XCUITest take the screenshot, and `kaloko capture --image shot.png --tree hierarchy.xml` brings it in with its UI dump.

## Skills and prompts

```
Walk the checkout of our Android app in cs and en on the small and the large emulator, in light and dark mode: product detail by deep link, add to cart, cart. Use the app pack and check the price format.
```

```
Our Maestro flow already walks the iOS onboarding. After each screen, capture it into Kaloko with the hierarchy, then share the run for design review.
```

Expected outcome: a canvas of app screens in phone frames per locale, device and mode. Each has its UI tree, highlighted elements for failing criteria (a 30×30 icon button without a label, say) and a crash stamp if the app died.

## What you get

- One review surface for web and app: the same canvas, verdicts, comments and history.
- Accessibility basics that are hard to see in screenshots: missing labels and small touch targets, found from the UI tree.
- Language and dark-mode checks: truncated translations, wrong formats and unreadable dark screens are caught on the screen where they happen.

## FAQ

### Do I need Appium?

No. Android needs `adb` and an emulator or a device. iOS needs Xcode's Simulator; `idb` adds the full UI tree and taps. If you already use Appium, Maestro or XCUITest, keep them and import their screens. `npx kaloko doctor` says what is missing on your machine and how to install it.

### Does it work with Flutter or React Native?

Yes, as long as the platform's UI tree exposes the widgets (Flutter with semantics, React Native with `testID` and accessibility labels). Otherwise Kaloko falls back to text recognition on the screenshot.

### Can it run on a real iPhone?

Yes, for launching the app, opening deep links and taking screenshots: Kaloko uses Xcode's `devicectl` and `idevicescreenshot` or `pymobiledevice3`, and reads the text on the screen. It does not tap on a real iPhone; let XCUITest, Maestro or Appium do that and import each screen with `kaloko capture --image`. Real Android phones work fully over USB or Wi-Fi.

### What about a WebView inside the app?

On Android, a debuggable WebView is a Chromium page: a step script gets it with `await webview()`, and the capture holds its DOM with the web checks. On iOS, capture the screen as an app screen and test the web content itself in WebKit with an iPhone preset.
