uiautodev 0.3.3__py3-none-any.whl

uiautodev/driver/mock.py

@@ -0,0 +1,74 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""Created on Mon Mar 04 2024 14:10:00 by codeskyblue
+"""
+
+from PIL import Image, ImageDraw
+
+from uiautodev.driver.base_driver import BaseDriver
+from uiautodev.model import Node, ShellResponse, WindowSize
+
+
+class MockDriver(BaseDriver):
+    def screenshot(self, id: int):
+        im = Image.new("RGB", (500, 800), "gray")
+        draw = ImageDraw.Draw(im)
+        draw.text((10, 10), "mock", fill="white")
+        draw.rectangle([100, 100, 200, 200], outline="red", fill="blue")
+        del draw
+        return im
+
+    def dump_hierarchy(self):
+        return "", Node(
+            key="0",
+            name="root",
+            bounds=(0, 0, 1, 1),
+            properties={
+                "class": "android.view.View",
+            },
+            children=[
+                Node(
+                    key="0-0",
+                    name="mock1",
+                    bounds=(0.1, 0.1, 0.5, 0.5),
+                    properties={
+                        "class": "android.widget.FrameLayout",
+                        "text": "mock1",
+                        "accessible": "true",
+                    },
+                ),
+                Node(
+                    key="0-1",
+                    name="mock2",
+                    bounds=(0.4, 0.4, 0.6, 0.6),
+                    properties={
+                        "class": "android.widget.ImageView",
+                        "text": "mock2",
+                        "accessible": "true",
+                    },
+                    children=[
+                        Node(
+                            key="0-1-0",
+                            name="mock2-1",
+                            bounds=(0.42, 0.42, 0.45, 0.45),
+                            properties={
+                                "class": "android.widget.ImageView",
+                                "text": "mock2-1",
+                                "visible": "true",
+                            },
+                        ),
+                    ]
+                ),
+                Node(
+                    key="0-2",
+                    name="mock-should-not-show",
+                    bounds=(0.4, 0.4, 0.6, 0.6),
+                    properties={
+                        "class": "android.widget.ImageView",
+                        "text": "mock3",
+                        "visible": "false",
+                    },
+                ),
+            ],
+        )

uiautodev/driver/udt/udt.py

@@ -0,0 +1,259 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""Created on Sun Apr 21 2024 21:15:15 by codeskyblue
+"""
+
+
+import atexit
+from base64 import b64decode
+import enum
+import io
+import json
+import logging
+from pprint import pprint
+import threading
+import time
+from pathlib import Path
+from typing import Any, Optional
+
+from PIL import Image
+import adbutils
+import requests
+from pydantic import BaseModel
+
+"""
+shell steps:
+adb push appium-uiautomator2-v5.12.4.apk /data/local/tmp/udt.jar
+adb shell CLASSPATH=/data/local/tmp/udt.jar app_process / "com.wetest.uia2.Main"
+adb forward tcp:6790 tcp:6790
+# 创建session
+echo '{"capabilities": {}}' | http POST :6790/session
+# 获取当前所有session
+http GET :6790/sessions
+# 获取pageSource
+http GET :6790/session/{session_id}/source
+
+# TODO
+# /appium/settins 中waitForIdleTimeout需要调整，其他的再看看
+"""
+
+logger = logging.getLogger(__name__)
+
+class UDTError(Exception):
+    pass
+
+
+class HTTPError(UDTError):
+    pass
+
+
+class AppiumErrorEnum(str, enum.Enum):
+    InvalidSessionID = 'invalid session id'
+
+
+class AppiumError(UDTError):
+    def __init__(self, error: str, message):
+        self.error = error
+        self.message = message
+
+
+class AppiumResponseValue(BaseModel):
+    error: Optional[str] = None
+    message: Optional[str] = None
+    stacktrace: Optional[str] = None
+
+
+class AppiumResponse(BaseModel):
+    sessionId: Optional[str] = None
+    value: Any = None
+
+
+class MockAdbProcess:
+    def __init__(self, conn: adbutils.AdbConnection) -> None:
+        self._conn = conn
+        self._event = threading.Event()
+        
+        def wait_finished():
+            try:
+                self._conn.read_until_close()
+            except:
+                pass
+            self._event.set()
+        
+        t = threading.Thread(target=wait_finished)
+        t.daemon = True
+        t.name = "wait_adb_conn"
+        t.start()
+
+    def wait(self) -> int:
+        self._event.wait()
+        return 0
+
+    def pool(self) -> Optional[int]:
+        if self._event.is_set():
+            return 0
+        return None
+
+    def kill(self):
+        self._conn.close()
+
+
+class UDT:
+    def __init__(self, device: adbutils.AdbDevice):
+        self._device = device
+        self._lport = None
+        self._process = None
+        self._lock = threading.Lock()
+        self._session_id = None
+        atexit.register(self.release)
+
+    def get_session_id(self) -> str:
+        if self._session_id:
+            return self._session_id
+        self._session_id = self._new_session()
+        logger.debug("update waitForIdleTimeout to 0ms")
+        self._dev_request("POST", f"/session/{self._session_id}/appium/settings", payload={
+            "settings": {
+                "waitForIdleTimeout": 10,
+                "waitForSelectorTimeout": 10,
+                "actionAcknowledgmentTimeout": 10,
+                "scrollAcknowledgmentTimeout": 10,
+                "trackScrollEvents": False,
+            }
+        })
+        result = self._dev_request("GET", f"/session/{self._session_id}/appium/settings")
+        return self._session_id
+    
+    def dev_request(self, method: str, path: str, **kwargs) -> AppiumResponse:
+        """send http request to device
+        :param method: GET, POST, DELETE, PUT
+        :param path: url path, path start with @ means with_session=True
+
+        :return: response json
+        """
+        try:
+            if path.startswith("@"):
+                path = path[1:]
+                kwargs['with_session'] = True
+            return self._dev_request(method, path, **kwargs)
+        except HTTPError:
+            self.launch_server()
+            return self._dev_request(method, path, **kwargs)
+        except AppiumError as e:
+            if e.error == AppiumErrorEnum.InvalidSessionID:
+                self._session_id = self._new_session()
+                return self._dev_request(method, path, **kwargs)
+            raise
+
+    def _dev_request(self, method: str, path: str, payload=None, timeout: float = 10.0, with_session: bool = False) -> AppiumResponse:
+        try:
+            if with_session:
+                sid = self.get_session_id()
+                path = f"/session/{sid}{path}"
+            url = f"http://localhost:{self._lport}{path}"
+            logger.debug("request %s %s", method, url)
+            r = requests.request(method, url, json=payload, timeout=timeout)
+            response_json = r.json()
+            resp = AppiumResponse.model_validate(response_json)
+            if isinstance(resp.value, dict):
+                value = AppiumResponseValue.model_validate(resp.value)
+                if value.error:
+                    raise AppiumError(value.error, value.message)
+            return resp
+        except requests.RequestException as e:
+            raise HTTPError(f"{method} to {path!r} error", payload)
+        except json.JSONDecodeError as e:
+            raise HTTPError("JSON decode error", e.msg)
+        
+    def _new_session(self) -> str:
+        resp = self._dev_request("POST", "/session", payload={"capabilities": {}})
+        value = resp.value
+        if not isinstance(value, dict) and 'sessionId' not in value:
+            raise UDTError("session create failed", resp)
+        sid = value['sessionId']
+        if not sid:
+            raise UDTError("session create failed", resp)
+        return sid
+
+    def post(self, path: str, payload=None) -> AppiumResponse:
+        return self.dev_request("POST", path, payload=payload)
+
+    def get(self, path: str, ) -> AppiumResponse:
+        return self.dev_request("GET", path)
+
+    def _update_process_status(self):
+        if self._process:
+            if self._process.pool() is not None:
+                self._process = None
+
+    def release(self):
+        logger.debug("Releasing")
+        with self._lock:
+            if self._process is not None:
+                logger.debug("Killing process")
+                self._process.kill()
+                self._process.wait()
+                self._process = None
+
+    def launch_server(self):
+        try:
+            self._launch_server()
+            self._device.keyevent("WAKEUP")
+        except adbutils.AdbError as e:
+            raise UDTError("fail to start udt", str(e))
+        self._wait_ready()
+
+    def _launch_server(self):
+        with self._lock:
+            self._update_process_status()
+            if self._process:
+                logger.debug("Process already running")
+                return
+            logger.debug("Launching process")
+            dex_local_path = Path(__file__).parent.joinpath("appium-uiautomator2-v5.12.4-light.apk")
+            logger.debug("dex_local_path: %s", dex_local_path)
+            dex_remote_path = "/data/local/tmp/udt/udt-5.12.4-light.dex"
+            info = self._device.sync.stat(dex_remote_path)
+            if info.size == dex_local_path.stat().st_size:
+                logger.debug("%s already exists", dex_remote_path)
+            else:
+                logger.debug("push dex(%d) to %s", dex_local_path.stat().st_size, dex_remote_path)
+                self._device.shell("mkdir -p /data/local/tmp/udt")
+                self._device.sync.push(dex_local_path, dex_remote_path, 0o644)
+            logger.debug("CLASSPATH=%s app_process / com.wetest.uia2.Main", dex_remote_path)
+            conn = self._device.shell(f"CLASSPATH={dex_remote_path} app_process / com.wetest.uia2.Main", stream=True)
+            self._process = MockAdbProcess(conn)
+
+            self._lport = self._device.forward_port(6790)
+            logger.debug("forward tcp:6790 -> tcp:%d", self._lport)
+
+    def _wait_ready(self):
+        deadline = time.time() + 10
+        while time.time() < deadline:
+            try:
+                self._dev_request("GET", "/status", timeout=1)
+                return
+            except HTTPError:
+                time.sleep(0.5)
+        raise UDTError("Service not ready")
+
+    def dump_hierarchy(self) -> str:
+        resp = self.get(f"@/source")
+        return resp.value
+    
+    def status(self):
+        return self.get("/status")
+    
+    def screenshot(self) -> Image.Image:
+        resp = self.get(f"@/screenshot")
+        raw = b64decode(resp.value)
+        return Image.open(io.BytesIO(raw))
+
+
+
+if __name__ == '__main__':
+    logging.basicConfig(level=logging.DEBUG)
+    r = UDT(adbutils.device())
+    print(r.status())
+    r.dump_hierarchy()

uiautodev/exceptions.py

@@ -0,0 +1,32 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""Created on Tue Mar 05 2024 11:16:29 by codeskyblue
+"""
+
+class UiautoException(Exception):
+    pass
+
+
+class IOSDriverException(UiautoException):
+    pass
+
+
+class AndroidDriverException(UiautoException):
+    pass
+
+
+class AppiumDriverException(UiautoException):
+    pass
+
+
+class MethodError(UiautoException):
+    pass
+
+
+class ElementNotFoundError(MethodError):
+    pass
+
+
+class RequestError(UiautoException):
+    pass

uiautodev/model.py

@@ -0,0 +1,37 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""Created on Sun Feb 18 2024 11:12:33 by codeskyblue
+"""
+from __future__ import annotations
+
+import typing
+from typing import Dict, List, Optional, Tuple, Union
+
+from pydantic import BaseModel
+
+
+class DeviceInfo(BaseModel):
+    serial: str
+    model: str = ""
+    name: str = ""
+    status: str = ""
+    enabled: bool = True
+
+
+class ShellResponse(BaseModel):
+    output: str
+    error: Optional[str] = ""
+
+
+class Node(BaseModel):
+    key: str
+    name: str
+    bounds: Optional[Tuple[float, float, float, float]] = None
+    properties: Dict[str, Union[str, bool]] = []
+    children: List[Node] = []
+
+
+class WindowSize(typing.NamedTuple):
+    width: int
+    height: int

uiautodev/provider.py

@@ -0,0 +1,76 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""Created on Sun Feb 18 2024 11:10:58 by codeskyblue
+"""
+from __future__ import annotations
+
+import abc
+from functools import lru_cache
+
+import adbutils
+
+from uiautodev.driver.android import AndroidDriver
+from uiautodev.driver.base_driver import BaseDriver
+from uiautodev.driver.ios import IOSDriver
+from uiautodev.driver.mock import MockDriver
+from uiautodev.exceptions import UiautoException
+from uiautodev.model import DeviceInfo
+from uiautodev.utils.usbmux import MuxDevice, list_devices
+
+
+class BaseProvider(abc.ABC):
+    @abc.abstractmethod
+    def list_devices(self) -> list[DeviceInfo]:
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def get_device_driver(self, serial: str) -> BaseDriver:
+        raise NotImplementedError()
+    
+    def get_single_device_driver(self) -> BaseDriver:
+        """ debug use """
+        devs = self.list_devices()
+        if len(devs) == 0:
+            raise UiautoException("No device found")
+        if len(devs) > 1:
+            raise UiautoException("More than one device found")
+        return self.get_device_driver(devs[0].serial)
+
+
+class AndroidProvider(BaseProvider):
+    def __init__(self):
+        pass
+
+    def list_devices(self) -> list[DeviceInfo]:
+        adb = adbutils.AdbClient()
+        ret: list[DeviceInfo] = []
+        for d in adb.list():
+            if d.state != "device":
+                ret.append(DeviceInfo(serial=d.serial, status=d.state, enabled=False))
+            else:
+                dev = adb.device(d.serial)
+                ret.append(DeviceInfo(serial=d.serial, model=dev.prop.model, name=dev.prop.name))
+        return ret
+
+    @lru_cache
+    def get_device_driver(self, serial: str) -> AndroidDriver:
+        return AndroidDriver(serial)
+
+
+class IOSProvider(BaseProvider):
+    def list_devices(self) -> list[DeviceInfo]:
+        devs = list_devices()
+        return [DeviceInfo(serial=d.serial, model="unknown", name="unknown") for d in devs]
+
+    @lru_cache
+    def get_device_driver(self, serial: str) -> BaseDriver:
+        return IOSDriver(serial)
+    
+
+class MockProvider(BaseProvider):
+    def list_devices(self) -> list[DeviceInfo]:
+        return [DeviceInfo(serial="mock-serial", model="mock-model", name="mock-name")]
+
+    def get_device_driver(self, serial: str) -> BaseDriver:
+        return MockDriver(serial)

uiautodev/router/device.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""Created on Fri Mar 01 2024 14:00:10 by codeskyblue
+"""
+
+import io
+from typing import Any, List
+
+from fastapi import APIRouter, Response
+from pydantic import BaseModel
+
+from uiautodev import command_proxy
+from uiautodev.command_types import Command, CurrentAppResponse, InstallAppRequest, InstallAppResponse, TapRequest
+from uiautodev.model import DeviceInfo, Node, ShellResponse
+from uiautodev.provider import BaseProvider
+
+
+class AndroidShellPayload(BaseModel):
+    command: str
+
+
+def make_router(provider: BaseProvider) -> APIRouter:
+    router = APIRouter()
+
+    @router.get("/list")
+    def _list() -> List[DeviceInfo]:
+        """List of Android devices"""
+        try:
+            return provider.list_devices()
+        except NotImplementedError as e:
+            return Response(content="list_devices not implemented", media_type="text/plain", status_code=501)
+        except Exception as e:
+            return Response(content=str(e), media_type="text/plain", status_code=500)
+
+    @router.post("/{serial}/shell")
+    def android_shell(serial: str, payload: AndroidShellPayload) -> ShellResponse:
+        """Run a shell command on an Android device"""
+        try:
+            driver = provider.get_device_driver(serial)
+            return driver.shell(payload.command)
+        except NotImplementedError as e:
+            return Response(content="shell not implemented", media_type="text/plain", status_code=501)
+        except Exception as e:
+            return ShellResponse(output="", error=str(e))
+
+    @router.get(
+        "/{serial}/screenshot/{id}",
+        responses={200: {"content": {"image/jpeg": {}}}},
+        response_class=Response,
+    )
+    def _screenshot(serial: str, id: int) -> Response:
+        """Take a screenshot of device"""
+        try:
+            driver = provider.get_device_driver(serial)
+            pil_img = driver.screenshot(id)
+            buf = io.BytesIO()
+            pil_img.save(buf, format="JPEG")
+            image_bytes = buf.getvalue()
+            return Response(content=image_bytes, media_type="image/jpeg")
+        except Exception as e:
+            return Response(content=str(e), media_type="text/plain", status_code=500)
+
+    @router.get("/{serial}/hierarchy")
+    def dump_hierarchy(serial: str) -> Node:
+        """Dump the view hierarchy of an Android device"""
+        try:
+            driver = provider.get_device_driver(serial)
+            xml_data, hierarchy = driver.dump_hierarchy()
+            return hierarchy
+        except Exception as e:
+            return Response(content=str(e), media_type="text/plain", status_code=500)
+    
+    @router.post('/{serial}/command/tap')
+    def command_tap(serial: str, params: TapRequest):
+        """Run a command on the device"""
+        driver = provider.get_device_driver(serial)
+        command_proxy.tap(driver, params)
+        return {"status": "ok"}
+    
+    @router.post('/{serial}/command/installApp')
+    def install_app(serial: str, params: InstallAppRequest) -> InstallAppResponse:
+        """Install app"""
+        driver = provider.get_device_driver(serial)
+        return command_proxy.app_install(driver, params)
+
+    @router.get('/{serial}/command/currentApp')
+    def current_app(serial: str) -> CurrentAppResponse:
+        """Get current app"""
+        driver = provider.get_device_driver(serial)
+        return command_proxy.app_current(driver)
+
+    @router.post('/{serial}/command/{command}')
+    def _command_proxy_other(serial: str, command: Command, params: Any = None):
+        """Run a command on the device"""
+        driver = provider.get_device_driver(serial)
+        func = command_proxy.COMMANDS[command]
+        if params is None:
+            response = func(driver)
+        else:
+            response = func(driver, params)
+        return response
+
+    return router

uiautodev/router/xml.py

@@ -0,0 +1,28 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""Created on Tue Mar 05 2024 16:59:19 by codeskyblue
+"""
+
+from fastapi import APIRouter, Form, Response
+from lxml import etree
+from typing_extensions import Annotated
+
+router = APIRouter()
+
+
+@router.post("/check/xpath")
+def check_xpath(xml: Annotated[str, Form()], xpath: Annotated[str, Form()]) -> Response:
+    """Check if the XPath expression is valid"""
+    try:
+        children = []
+        for child in etree.fromstring(xml).xpath(xpath):
+            children.append(child)
+        if len(children) > 0:
+            return Response(content=children[0].tag, media_type="text/plain")
+        else:
+            return Response(
+                content="XPath is valid but not node matches", media_type="text/plain"
+            )
+    except Exception as e:
+        return Response(content=str(e), media_type="text/plain", status_code=400)

uiautodev/static/demo.html

@@ -0,0 +1,34 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>AppInspector Demo</title>
+</head>
+<body>
+    <h1>App Inspector</h1>
+    <div id="message"></div>
+    <button id="test">Test</button>
+    <script>
+        window.onload = function() {
+            let message = "<span style='color: green'>App Inspector is installed.</span>"
+            if (chrome.runtime === undefined) {
+                message = "Please install the App Inspector Chrome Extension to use this feature.";
+            }
+            document.getElementById('message').innerHTML = `<span>${message}</span>`;
+        }
+
+        document.getElementById('test').addEventListener('click', function() {
+            const extensionId = "fjbboaelofjaabjmlphndicacmapbalm"
+            chrome.runtime.sendMessage(extensionId, {url: "/info"}, function(response) {
+                console.log(response);
+                if (response.error) {
+                    console.error(response.error)
+                } else {
+                    document.getElementById('message').innerHTML = response.data.description
+                }
+            });
+        });
+    </script>
+</body>
+</html>