Choose a capture mode for your app
Compare Ansight capture modes, evidence, and requirements across physical and virtual Android and iOS devices.
External capture needs no app changes. An SDK connection adds evidence from inside the app.
Physical Android external capture requires an explicitly selected, authorized ADB device.
iOS capture comparison
| Capture mode | Data richness | Developer Mode | Integration | Info |
|---|---|---|---|---|
| External · physical iPhone | LimitedScreens, replay, UI automation | Yes | None in app | |
| External · iOS simulator | BroaderScreens, logs, metrics, files | Not applicable | None in app | |
| SDK · physical or simulator | RichestApp and host evidence | No | In-app SDK |
Android capture comparison
| Capture mode | Data richness | Developer options | Integration | Info |
|---|---|---|---|---|
| External · physical Android | BroaderScreens, replay, UI automation, Logcat, available metrics | USB debugging | None in app | |
| External · Android emulator | BroaderScreens, logs, metrics, files | Not applicable | None in app | |
| SDK · physical or emulator | RichestApp and host evidence | No | In-app SDK |
All three modes create sessions you can review in the local player. The exact evidence depends on the platform, permissions, and enabled features. External automation can send taps and gestures, but only an SDK integration can record the user’s touches as app evidence.
External app watches cover explicitly selected physical iOS and Android devices, iOS simulators, and Android emulators. Virtual devices are discovered automatically; physical devices require an exact device ID.
External app on a physical device
This mode supports physical iOS and Android devices. Choose it when you need to inspect an installed app without changing its code, including a non-debug store build. Ansight follows the app while it is in the foreground. On iOS it uses Appium/WebDriverAgent for screenshots and accessibility-based UI input; on Android it uses ADB and UIAutomator. You can review the visible flow and run UI automation against it. An optional Xcode Instruments attach can add a native trace and CPU or memory channels for an iPhone when its process table exports.
For an iPhone, this mode needs a Mac with Xcode, Appium and its XCUITest driver, a paired and trusted iPhone with Developer Mode and UI Automation enabled, and an Apple development signing setup for WebDriverAgent. Keep the phone unlocked and select its exact device ID when creating the monitor. Backgrounding the app ends this recording. App process logs, third-party sandbox files, touch recording, and app-internal tools are unavailable through this external watch.
For a physical Android device, enable USB debugging, authorize the host in
ADB, and select its exact serial with --platform android --device-id. Ansight
uses ADB for screenshots, accessibility-based input, Logcat, and available
process metrics while the watched app is foreground. Appium is not required.
Private files require run-as or an already provisioned root ADB daemon.
Set up physical-device monitoring.
External app on an iOS simulator or Android emulator
Choose this for quick capture without an SDK or app rebuild. Install the app, boot the virtual device, start the Ansight host, and monitor its bundle or package ID. The host discovers matching virtual devices and records while the app process runs. Sessions can include screenshots, native logs, available process telemetry, and sandbox files when platform access allows it. Visible UI automation and source-controlled workspace tests can use the session.
Platform tools determine what can be read. iOS simulator file access uses its
containers; Android private files need a debuggable app with run-as or an
already provisioned root ADB daemon. iOS simulator FPS is currently
unavailable; Android emulator FPS depends on renderer support. Touch recording,
instrumented network requests, and app-internal tools still require the SDK.
Set up external monitoring or review its evidence matrix.
SDK integrated app
Choose this when you own the app build and need evidence from inside the app. Add the SDK for your framework, initialize it in a trusted development or QA build, and connect it to the resident host. Simulators and emulators register over local loopback automatically; physical devices use a one-time pairing QR. SDK capture also works on supported physical Android and iOS devices. Physical iPhone SDK capture does not need Appium.
For a physical Android phone, install an SDK-enabled build and pair it with a one-time QR. The SDK connection does not require Android Developer options or USB debugging. USB debugging is a separate requirement if you use ADB to install, control, or profile the device. Likewise, deploying an iOS development build or attaching optional Instruments may have its own device requirements; the Ansight SDK session itself does not require Developer Mode. Start with the Android SDK setup guide.
The SDK can align screenshots with touches, screen views, app logs, lifecycle events, and telemetry. Enable the relevant packages and policies for network capture, crash evidence, visual trees, artifacts, and guarded tools that inspect app-owned state such as files or databases. Availability varies by framework and configuration. On simulators and emulators, the host may supply screenshots while the SDK still provides the richer app evidence.
Choose an SDK and follow its setup guide or compare SDK features by platform.