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