Device - High-level representation of an Android device.

​
Device

class Device()

High-level representation of an Android device.

​
Device.__init__

def __init__(serial: str, adb: ADBWrapper)

Initialize device.

Arguments:

  • serial - Device serial number
  • adb - ADB wrapper instance

​
Device.serial

def serial() -> str

Get device serial number.

​
Device.get_properties

async def get_properties() -> Dict[str, str]

Get all device properties.

​
Device.get_property

async def get_property(name: str) -> str

Get a specific device property.

​
Device.model

async def model() -> str

Get device model.

​
Device.brand

async def brand() -> str

Get device brand.

​
Device.android_version

async def android_version() -> str

Get Android version.

​
Device.sdk_level

async def sdk_level() -> str

Get SDK level.

​
Device.shell

async def shell(command: str, timeout: float | None = None) -> str

Execute a shell command on the device.

​
Device.tap

async def tap(x: int, y: int) -> None

Tap at coordinates.

Arguments:

  • x - X coordinate
  • y - Y coordinate

​
Device.swipe

async def swipe(
    start_x: int,
    start_y: int,
    end_x: int,
    end_y: int,
    duration_ms: int = 300
) -> None

Perform swipe gesture.

Arguments:

  • start_x - Starting X coordinate
  • start_y - Starting Y coordinate
  • end_x - Ending X coordinate
  • end_y - Ending Y coordinate
  • duration_ms - Swipe duration in milliseconds

​
Device.input_text

async def input_text(text: str) -> None

Input text.

Arguments:

  • text - Text to input

​
Device.press_key

async def press_key(keycode: int) -> None

Press a key.

Arguments:

  • keycode - Android keycode to press

​
Device.start_activity

async def start_activity(
    package: str,
    activity: str = ".MainActivity",
    extras: Optional[Dict[str, str]] = None
) -> None

Start an app activity.

Arguments:

  • package - Package name
  • activity - Activity name
  • extras - Intent extras

​
Device.start_app

async def start_app(package: str, activity: str = "") -> str

Start an app on the device.

Arguments:

  • package - Package name
  • activity - Optional activity name (if empty, launches default activity)

Returns:

Result message

​
Device.install_app

async def install_app(
    apk_path: str,
    reinstall: bool = False,
    grant_permissions: bool = True
) -> str

Install an APK on the device.

Arguments:

  • apk_path - Path to the APK file
  • reinstall - Whether to reinstall if app exists
  • grant_permissions - Whether to grant all requested permissions

Returns:

Installation result

​
Device.uninstall_app

async def uninstall_app(package: str, keep_data: bool = False) -> str

Uninstall an app from the device.

Arguments:

  • package - Package name to uninstall
  • keep_data - Whether to keep app data and cache directories

Returns:

Uninstallation result

​
Device.take_screenshot

async def take_screenshot(quality: int = 75) -> Tuple[str, bytes]

Take a screenshot of the device and compress it.

Arguments:

  • quality - JPEG quality (1-100, lower means smaller file size)

Returns:

Tuple of (local file path, screenshot data as bytes)

​
Device.list_packages

async def list_packages(include_system_apps: bool = False) -> List[str]

List installed packages on the device.

Arguments:

  • include_system_apps - Whether to include system apps (default: False)

Returns:

List of package names

Device Manager - Manages Android device connections.

​
DeviceManager

class DeviceManager()

Manages Android device connections.

​
DeviceManager.__init__

def __init__(adb_path: Optional[str] = None)

Initialize device manager.

Arguments:

  • adb_path - Path to ADB binary

​
DeviceManager.list_devices

async def list_devices() -> List[Device]

List connected devices.

Returns:

List of connected devices

​
DeviceManager.get_device

async def get_device(serial: str | None = None) -> Optional[Device]

Get a specific device.

Arguments:

  • serial - Device serial number

Returns:

Device instance if found, None otherwise

​
DeviceManager.connect

async def connect(host: str, port: int = 5555) -> Optional[Device]

Connect to a device over TCP/IP.

Arguments:

  • host - Device IP address
  • port - Device port

Returns:

Connected device instance

​
DeviceManager.disconnect

async def disconnect(serial: str) -> bool

Disconnect from a device.

Arguments:

  • serial - Device serial number

Returns:

True if disconnected successfully