uiautodev 0.12.0__tar.gz → 0.13.3__tar.gz

{uiautodev-0.12.0 → uiautodev-0.13.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uiautodev
-Version: 0.12.0
+Version: 0.13.3
 Summary: Mobile UI Automation, include UI hierarchy inspector, script recorder
 License: MIT
 License-File: LICENSE
@@ -64,12 +64,12 @@ Options:
   -h, --help     Show this message and exit.
 
 Commands:
+  server       start uiauto.dev local server [Default]
   android      COMMAND: tap, tapElement, installApp, currentApp,...
-  appium       COMMAND: tap, tapElement, installApp, currentApp,...
   ios          COMMAND: tap, tapElement, installApp, currentApp,...
   self-update  Update uiautodev to latest version
-  server       start uiauto.dev local server [Default]
   version      Print version
+  shutdown     Shutdown server
 ```
 
 ```bash
@@ -77,6 +77,29 @@ Commands:
 uiauto.dev
 ```
 
+# Environment
+
+```sh
+# Default driver is uiautomator2
+# Set the environment variable below to switch to adb driver
+export UIAUTODEV_USE_ADB_DRIVER=1
+```
+
+# Offline mode
+
+Start with
+
+```sh
+uiautodev server --offline
+
+# Specify server url (optional)
+uiautodev server --offline --server-url https://uiauto.dev
+```
+
+Visit <http://localhost:20242> once, and then disconnecting from the internet will not affect usage.
+
+> All frontend resources will be saved to cache/ dir.
+
 # DEVELOP
 
 see [DEVELOP.md](DEVELOP.md)
@@ -87,3 +110,4 @@ see [DEVELOP.md](DEVELOP.md)
 
 # LICENSE
 [MIT](LICENSE)
+

{uiautodev-0.12.0 → uiautodev-0.13.3}/README.md

@@ -28,12 +28,12 @@ Options:
   -h, --help     Show this message and exit.
 
 Commands:
+  server       start uiauto.dev local server [Default]
   android      COMMAND: tap, tapElement, installApp, currentApp,...
-  appium       COMMAND: tap, tapElement, installApp, currentApp,...
   ios          COMMAND: tap, tapElement, installApp, currentApp,...
   self-update  Update uiautodev to latest version
-  server       start uiauto.dev local server [Default]
   version      Print version
+  shutdown     Shutdown server
 ```
 
 ```bash
@@ -41,6 +41,29 @@ Commands:
 uiauto.dev
 ```
 
+# Environment
+
+```sh
+# Default driver is uiautomator2
+# Set the environment variable below to switch to adb driver
+export UIAUTODEV_USE_ADB_DRIVER=1
+```
+
+# Offline mode
+
+Start with
+
+```sh
+uiautodev server --offline
+
+# Specify server url (optional)
+uiautodev server --offline --server-url https://uiauto.dev
+```
+
+Visit <http://localhost:20242> once, and then disconnecting from the internet will not affect usage.
+
+> All frontend resources will be saved to cache/ dir.
+
 # DEVELOP
 
 see [DEVELOP.md](DEVELOP.md)
@@ -50,4 +73,4 @@ see [DEVELOP.md](DEVELOP.md)
 - https://docs.tangoapp.dev/scrcpy/video/web-codecs/ H264解码器
 
 # LICENSE
-[MIT](LICENSE)
+[MIT](LICENSE)

{uiautodev-0.12.0 → uiautodev-0.13.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "uiautodev"
-version = "0.12.0"
+version = "0.13.3"
 description = "Mobile UI Automation, include UI hierarchy inspector, script recorder"
 homepage = "https://uiauto.dev"
 authors = ["codeskyblue <codeskyblue@gmail.com>"]

{uiautodev-0.12.0 → uiautodev-0.13.3}/uiautodev/__init__.py

@@ -5,4 +5,4 @@
 """
 
 # version is auto managed by poetry
-__version__ = "0.12.0"
+__version__ = "0.13.3"

{uiautodev-0.12.0 → uiautodev-0.13.3}/uiautodev/app.py

@@ -1,8 +1,7 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 
-"""Created on Sun Feb 18 2024 13:48:55 by codeskyblue
-"""
+"""Created on Sun Feb 18 2024 13:48:55 by codeskyblue"""
 
 import logging
 import os
@@ -12,21 +11,23 @@ from pathlib import Path
 from typing import Dict, List
 
 import adbutils
+import httpx
 import uvicorn
-from fastapi import FastAPI, File, UploadFile, WebSocket
+from fastapi import FastAPI, File, Request, Response, UploadFile, WebSocket
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import FileResponse, JSONResponse, RedirectResponse
 from pydantic import BaseModel
-from rich.logging import RichHandler
 from starlette.websockets import WebSocketDisconnect
 
 from uiautodev import __version__
 from uiautodev.common import convert_bytes_to_image, get_webpage_url, ocr_image
+from uiautodev.driver.android import ADBAndroidDriver, U2AndroidDriver
 from uiautodev.model import Node
 from uiautodev.provider import AndroidProvider, HarmonyProvider, IOSProvider, MockProvider
 from uiautodev.remote.scrcpy import ScrcpyServer
 from uiautodev.router.android import router as android_device_router
 from uiautodev.router.device import make_router
+from uiautodev.router.proxy import make_reverse_proxy
 from uiautodev.router.proxy import router as proxy_router
 from uiautodev.router.xml import router as xml_router
 from uiautodev.utils.envutils import Environment
@@ -35,16 +36,6 @@ logger = logging.getLogger(__name__)
 
 app = FastAPI()
 
-
-def enable_logger_to_console():
-    _logger = logging.getLogger("uiautodev")
-    _logger.setLevel(logging.DEBUG)
-    _logger.addHandler(RichHandler(enable_link_path=False))
-
-
-if os.getenv("UIAUTODEV_DEBUG"):
-    enable_logger_to_console()
-
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
@@ -53,7 +44,12 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-android_router = make_router(AndroidProvider())
+android_default_driver = U2AndroidDriver
+if os.getenv("UIAUTODEV_USE_ADB_DRIVER") in ("1", "true", "True"):
+    android_default_driver = ADBAndroidDriver
+
+android_router = make_router(AndroidProvider(driver_class=android_default_driver))
+android_adb_router = make_router(AndroidProvider(driver_class=ADBAndroidDriver))
 ios_router = make_router(IOSProvider())
 harmony_router = make_router(HarmonyProvider())
 mock_router = make_router(MockProvider())
@@ -66,25 +62,30 @@ if Environment.UIAUTODEV_MOCK:
     app.include_router(mock_router, prefix="/api/harmony", tags=["mock"])
 else:
     app.include_router(android_router, prefix="/api/android", tags=["android"])
+    app.include_router(android_adb_router, prefix="/api/android_adb", tags=["android_adb"])
     app.include_router(ios_router, prefix="/api/ios", tags=["ios"])
     app.include_router(harmony_router, prefix="/api/harmony", tags=["harmony"])
 
 app.include_router(xml_router, prefix="/api/xml", tags=["xml"])
 app.include_router(android_device_router, prefix="/api/android", tags=["android"])
-app.include_router(proxy_router, prefix="/proxy", tags=["proxy"])
+app.include_router(proxy_router, tags=["proxy"])
 
-@app.get('/api/{platform}/features')
+
+@app.get("/api/{platform}/features")
 def get_features(platform: str) -> Dict[str, bool]:
     """Get features supported by the specified platform"""
     features = {}
     # 获取所有带有指定平台tag的路由
+    from starlette.routing import Route
+
     for route in app.routes:
-        if hasattr(route, 'tags') and platform in route.tags:
-            if route.path.startswith(f"/api/{platform}/{{serial}}/"):
+        _route: Route = route  # type: ignore
+        if hasattr(_route, "tags") and platform in _route.tags:
+            if _route.path.startswith(f"/api/{platform}/{{serial}}/"):
                 # 提取特性名称
-                parts = route.path.split('/')
+                parts = _route.path.split("/")
                 feature_name = parts[-1]
-                if not feature_name.startswith('{'):
+                if not feature_name.startswith("{"):
                     features[feature_name] = True
     return features
 
@@ -111,7 +112,7 @@ def info() -> InfoResponse:
     )
 
 
-@app.post('/api/ocr_image')
+@app.post("/api/ocr_image")
 async def _ocr_image(file: UploadFile = File(...)) -> List[Node]:
     """OCR an image"""
     image_data = await file.read()
@@ -134,14 +135,19 @@ def demo():
     return FileResponse(static_dir / "demo.html")
 
 
-@app.get("/")
+@app.get("/redirect")
 def index_redirect():
-    """ redirect to official homepage """
+    """redirect to official homepage"""
     url = get_webpage_url()
     logger.debug("redirect to %s", url)
     return RedirectResponse(url)
 
 
+@app.get("/api/auth/me")
+def mock_auth_me():
+    # 401 {"detail":"Authentication required"}
+    return JSONResponse(status_code=401, content={"detail": "Authentication required"})
+
 @app.websocket("/ws/android/scrcpy/{serial}")
 async def handle_android_ws(websocket: WebSocket, serial: str):
     """
@@ -169,9 +175,10 @@ def get_harmony_mjpeg_server(serial: str):
     from hypium import UiDriver
 
     from uiautodev.remote.harmony_mjpeg import HarmonyMjpegServer
+
     driver = UiDriver.connect(device_sn=serial)
     logger.info("create harmony mjpeg server for %s", serial)
-    logger.info(f'device wake_up_display: {driver.wake_up_display()}')
+    logger.info(f"device wake_up_display: {driver.wake_up_display()}")
     return HarmonyMjpegServer(driver)
 
 
@@ -193,7 +200,9 @@ async def unified_harmony_ws(websocket: WebSocket, serial: str):
         await server.handle_ws(websocket)
     except ImportError as e:
         logger.error(f"missing library for harmony: {e}")
-        await websocket.close(code=1000, reason="missing library, fix by \"pip install uiautodev[harmony]\"")
+        await websocket.close(
+            code=1000, reason='missing library, fix by "pip install uiautodev[harmony]"'
+        )
     except WebSocketDisconnect:
         logger.info(f"WebSocket disconnected by client.")
     except Exception as e:
@@ -203,5 +212,5 @@ async def unified_harmony_ws(websocket: WebSocket, serial: str):
         logger.info(f"WebSocket closed for serial={serial}")
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     uvicorn.run("uiautodev.app:app", port=4000, reload=True, use_colors=True)

{uiautodev-0.12.0 → uiautodev-0.13.3}/uiautodev/cli.py

@@ -20,6 +20,7 @@ import httpx
 import pydantic
 import uvicorn
 from retry import retry
+from rich.logging import RichHandler
 
 from uiautodev import __version__, command_proxy
 from uiautodev.command_types import Command
@@ -38,12 +39,21 @@ HARMONY_PACKAGES = [
     "https://public.uiauto.devsleep.com/harmony/hypium-5.0.7.200.tar.gz",
 ]
 
+
+def enable_logger_to_console(level):
+    _logger = logging.getLogger("uiautodev")
+    _logger.setLevel(level)
+    _logger.addHandler(RichHandler(enable_link_path=False))
+
+
 @click.group(context_settings=CONTEXT_SETTINGS)
 @click.option("--verbose", "-v", is_flag=True, default=False, help="verbose mode")
 def cli(verbose: bool):
     if verbose:
-        os.environ['UIAUTODEV_DEBUG'] = '1'
+        enable_logger_to_console(level=logging.DEBUG)
         logger.debug("Verbose mode enabled")
+    else:
+        enable_logger_to_console(level=logging.INFO)
 
 
 def run_driver_command(provider: BaseProvider, command: Command, params: list[str] = None):
@@ -140,9 +150,11 @@ def pip_install(package: str):
 @click.option("--port", default=20242, help="port number", show_default=True)
 @click.option("--host", default="127.0.0.1", help="host", show_default=True)
 @click.option("--reload", is_flag=True, default=False, help="auto reload, dev only")
-@click.option("-f", "--force", is_flag=True, default=False, help="shutdown alrealy runningserver")
+@click.option("-f", "--force", is_flag=True, default=False, help="shutdown already running server")
 @click.option("-s", "--no-browser", is_flag=True, default=False, help="silent mode, do not open browser")
-def server(port: int, host: str, reload: bool, force: bool, no_browser: bool):
+@click.option("--offline", is_flag=True, default=False, help="offline mode, do not use internet")
+@click.option("--server-url", default="https://uiauto.dev", help="uiauto.dev server url", show_default=True)
+def server(port: int, host: str, reload: bool, force: bool, no_browser: bool, offline: bool, server_url: str):
     click.echo(f"uiautodev version: {__version__}")
     if force:
         try:
@@ -154,32 +166,44 @@ def server(port: int, host: str, reload: bool, force: bool, no_browser: bool):
     if platform.system() == 'Windows':
         use_color = False
 
+    server_url = server_url.rstrip('/')
+    from uiautodev.router import proxy
+    proxy.base_url = server_url
+
+    if offline:
+        proxy.cache_dir.mkdir(parents=True, exist_ok=True)
+        logger.info("offline mode enabled, cache dir: %s, server url: %s", proxy.cache_dir, proxy.base_url)
+
     if not no_browser:
-        th = threading.Thread(target=open_browser_when_server_start, args=(f"http://{host}:{port}",))
+        th = threading.Thread(target=open_browser_when_server_start, args=(f"http://{host}:{port}", offline))
         th.daemon = True
         th.start()
     uvicorn.run("uiautodev.app:app", host=host, port=port, reload=reload, use_colors=use_color)
 
+@cli.command(help="shutdown uiauto.dev local server")
+@click.option("--port", default=20242, help="port number", show_default=True)
+def shutdown(port: int):
+    try:
+        httpx.get(f"http://127.0.0.1:{port}/shutdown", timeout=3)
+    except httpx.HTTPError:
+        pass
 
-def open_browser_when_server_start(server_url: str):
+
+def open_browser_when_server_start(local_server_url: str, offline: bool = False):
     deadline = time.time() + 10
     while time.time() < deadline:
         try:
-            httpx.get(f"{server_url}/api/info", timeout=1)
+            httpx.get(f"{local_server_url}/api/info", timeout=1)
             break
         except Exception as e:
             time.sleep(0.5)
     import webbrowser
-    web_url = get_webpage_url()
+    web_url = get_webpage_url(local_server_url if offline else None)
     logger.info("open browser: %s", web_url)
     webbrowser.open(web_url)
 
 
 def main():
-    # set logger level to INFO
-    # logging.basicConfig(level=logging.INFO)
-    logger.setLevel(logging.INFO)
-
     has_command = False
     for name in sys.argv[1:]:
         if not name.startswith("-"):

{uiautodev-0.12.0 → uiautodev-0.13.3}/uiautodev/command_proxy.py

@@ -13,8 +13,8 @@ from typing import Callable, Dict, List, Optional, Union
 from pydantic import BaseModel
 
 from uiautodev.command_types import AppLaunchRequest, AppTerminateRequest, By, Command, CurrentAppResponse, \
-    DumpResponse, FindElementRequest, FindElementResponse, InstallAppRequest, InstallAppResponse, SendKeysRequest, TapRequest, \
-    WindowSizeResponse
+    DumpResponse, FindElementRequest, FindElementResponse, InstallAppRequest, InstallAppResponse, SendKeysRequest, \
+    TapRequest, WindowSizeResponse
 from uiautodev.driver.base_driver import BaseDriver
 from uiautodev.exceptions import ElementNotFoundError
 from uiautodev.model import AppInfo, Node

{uiautodev-0.12.0 → uiautodev-0.13.3}/uiautodev/common.py

@@ -8,7 +8,7 @@
 import io
 import locale
 import logging
-from typing import List
+from typing import List, Optional
 
 from PIL import Image
 
@@ -26,8 +26,9 @@ def is_chinese_language() -> bool:
         return False
     
     
-def get_webpage_url() -> str:
-    web_url = "https://uiauto.dev"
+def get_webpage_url(web_url: Optional[str] = None) -> str:
+    if not web_url:
+        web_url = "https://uiauto.dev"
     # code will be enabled until uiauto.devsleep.com is ready
     # if is_chinese_language():
     #     web_url = "https://uiauto.devsleep.com"

uiautodev-0.13.3/uiautodev/driver/android/__init__.py

@@ -0,0 +1,2 @@
+from uiautodev.driver.android.adb_driver import ADBAndroidDriver, parse_xml
+from uiautodev.driver.android.u2_driver import U2AndroidDriver

uiautodev-0.12.0/uiautodev/driver/android.py → uiautodev-0.13.3/uiautodev/driver/android/adb_driver.py

@@ -7,31 +7,24 @@
 import logging
 import re
 import time
-from functools import cached_property, partial
 from typing import Iterator, List, Optional, Tuple
-from xml.etree import ElementTree
 
 import adbutils
-import uiautomator2 as u2
 from PIL import Image
 
 from uiautodev.command_types import CurrentAppResponse
+from uiautodev.driver.android.common import parse_xml
 from uiautodev.driver.base_driver import BaseDriver
-from uiautodev.exceptions import AndroidDriverException, RequestError
+from uiautodev.exceptions import AndroidDriverException
 from uiautodev.model import AppInfo, Node, Rect, ShellResponse, WindowSize
-from uiautodev.utils.common import fetch_through_socket
 
 logger = logging.getLogger(__name__)
 
-class AndroidDriver(BaseDriver):
+class ADBAndroidDriver(BaseDriver):
     def __init__(self, serial: str):
         super().__init__(serial)
         self.adb_device = adbutils.device(serial)
 
-    @cached_property
-    def ud(self) -> u2.Device:
-        return u2.connect_usb(self.serial)
-
     def get_current_activity(self) -> str:
         ret = self.adb_device.shell2(["dumpsys", "activity", "activities"], rstrip=True, timeout=5)
         # 使用正则查找包含前台 activity 的行
@@ -44,7 +37,7 @@ class AndroidDriver(BaseDriver):
     def screenshot(self, id: int) -> Image.Image:
         if id > 0:
             raise AndroidDriverException("multi-display is not supported yet for uiautomator2")
-        return self.ud.screenshot()
+        return self.adb_device.screenshot(display_id=id)
 
     def shell(self, command: str) -> ShellResponse:
         try:
@@ -61,8 +54,11 @@ class AndroidDriver(BaseDriver):
     def dump_hierarchy(self, display_id: Optional[int] = 0) -> Tuple[str, Node]:
         """returns xml string and hierarchy object"""
         start = time.time()
-        xml_data = self._dump_hierarchy_raw()
-        logger.debug("dump_hierarchy cost: %s", time.time() - start)
+        try:
+            xml_data = self._dump_hierarchy_raw()
+            logger.debug("dump_hierarchy cost: %s", time.time() - start)
+        except Exception as e:
+            raise AndroidDriverException(f"Failed to dump hierarchy: {str(e)}")
 
         wsize = self.adb_device.window_size()
         logger.debug("window size: %s", wsize)
@@ -78,10 +74,24 @@ class AndroidDriver(BaseDriver):
         - ERROR: could not get idle state.
         """
         try:
-            return self.ud.dump_hierarchy()
-        except Exception as e:
-            raise AndroidDriverException(f"Failed to dump hierarchy: {str(e)}")
+            return self.adb_device.dump_hierarchy()
+        except adbutils.AdbError as e:
+            if "Killed" in str(e):
+                self.kill_app_process()
+            return self.adb_device.dump_hierarchy()
     
+    def kill_app_process(self):
+        logger.debug("Killing app_process")
+        pids = []
+        for line in self.adb_device.shell("ps -A || ps").splitlines():
+            if "app_process" in line:
+                fields = line.split()
+                if len(fields) >= 2:
+                    pids.append(int(fields[1]))
+                    logger.debug(f"App process PID: {fields[1]}")
+        for pid in set(pids):
+            self.adb_device.shell(f"kill {pid}")
+
     def tap(self, x: int, y: int):
         self.adb_device.click(x, y)
 
@@ -179,61 +189,8 @@ class AndroidDriver(BaseDriver):
         yield from self.adb_device.sync.iter_content(remote_path)
     
     def send_keys(self, text: str):
-        self.ud.send_keys(text)
+        self.adb_device.send_keys(text)
     
     def clear_text(self):
-        self.ud.clear_text()
-
-
-def parse_xml(xml_data: str, wsize: WindowSize, display_id: Optional[int] = None) -> Node:
-    root = ElementTree.fromstring(xml_data)
-    node = parse_xml_element(root, wsize, display_id)
-    if node is None:
-        raise AndroidDriverException("Failed to parse xml")
-    return node
-
-
-def parse_xml_element(element, wsize: WindowSize, display_id: Optional[int], indexes: List[int] = [0]) -> Optional[Node]:
-    """
-    Recursively parse an XML element into a dictionary format.
-    """
-    name = element.tag
-    if name == "node":
-        name = element.attrib.get("class", "node")
-    if display_id is not None:
-        elem_display_id = int(element.attrib.get("display-id", display_id))
-        if elem_display_id != display_id:
-            return
-
-    bounds = None
-    rect = None
-    # eg: bounds="[883,2222][1008,2265]"
-    if "bounds" in element.attrib:
-        bounds = element.attrib["bounds"]
-        bounds = list(map(int, re.findall(r"\d+", bounds)))
-        assert len(bounds) == 4
-        rect = Rect(x=bounds[0], y=bounds[1], width=bounds[2] - bounds[0], height=bounds[3] - bounds[1])
-        bounds = (
-            bounds[0] / wsize.width,
-            bounds[1] / wsize.height,
-            bounds[2] / wsize.width,
-            bounds[3] / wsize.height,
-        )
-        bounds = map(partial(round, ndigits=4), bounds)
-        
-    elem = Node(
-        key="-".join(map(str, indexes)),
-        name=name,
-        bounds=bounds,
-        rect=rect,
-        properties={key: element.attrib[key] for key in element.attrib},
-        children=[],
-    )
-
-    # Construct xpath for children
-    for index, child in enumerate(element):
-        child_node = parse_xml_element(child, wsize, display_id, indexes + [index])
-        if child_node:
-            elem.children.append(child_node)
-
-    return elem
+        for _ in range(3):
+            self.adb_device.shell2("input keyevent DEL --longpress")

uiautodev-0.13.3/uiautodev/driver/android/common.py

@@ -0,0 +1,61 @@
+import re
+from functools import partial
+from typing import List, Optional, Tuple
+from xml.etree import ElementTree
+
+from uiautodev.exceptions import AndroidDriverException, RequestError
+from uiautodev.model import AppInfo, Node, Rect, ShellResponse, WindowSize
+
+
+def parse_xml(xml_data: str, wsize: WindowSize, display_id: Optional[int] = None) -> Node:
+    root = ElementTree.fromstring(xml_data)
+    node = parse_xml_element(root, wsize, display_id)
+    if node is None:
+        raise AndroidDriverException("Failed to parse xml")
+    return node
+
+
+def parse_xml_element(element, wsize: WindowSize, display_id: Optional[int], indexes: List[int] = [0]) -> Optional[Node]:
+    """
+    Recursively parse an XML element into a dictionary format.
+    """
+    name = element.tag
+    if name == "node":
+        name = element.attrib.get("class", "node")
+    if display_id is not None:
+        elem_display_id = int(element.attrib.get("display-id", display_id))
+        if elem_display_id != display_id:
+            return
+
+    bounds = None
+    rect = None
+    # eg: bounds="[883,2222][1008,2265]"
+    if "bounds" in element.attrib:
+        bounds = element.attrib["bounds"]
+        bounds = list(map(int, re.findall(r"\d+", bounds)))
+        assert len(bounds) == 4
+        rect = Rect(x=bounds[0], y=bounds[1], width=bounds[2] - bounds[0], height=bounds[3] - bounds[1])
+        bounds = (
+            bounds[0] / wsize.width,
+            bounds[1] / wsize.height,
+            bounds[2] / wsize.width,
+            bounds[3] / wsize.height,
+        )
+        bounds = map(partial(round, ndigits=4), bounds)
+        
+    elem = Node(
+        key="-".join(map(str, indexes)),
+        name=name,
+        bounds=bounds,
+        rect=rect,
+        properties={key: element.attrib[key] for key in element.attrib},
+        children=[],
+    )
+
+    # Construct xpath for children
+    for index, child in enumerate(element):
+        child_node = parse_xml_element(child, wsize, display_id, indexes + [index])
+        if child_node:
+            elem.children.append(child_node)
+
+    return elem

uiautodev-0.13.3/uiautodev/driver/android/u2_driver.py

@@ -0,0 +1,68 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""Created on Fri Mar 01 2024 14:19:29 by codeskyblue
+"""
+
+import logging
+import re
+import time
+from functools import cached_property
+from typing import Optional, Tuple
+
+import uiautomator2 as u2
+from PIL import Image
+
+from uiautodev.driver.android.adb_driver import ADBAndroidDriver
+from uiautodev.driver.android.common import parse_xml
+from uiautodev.exceptions import AndroidDriverException
+from uiautodev.model import AppInfo, Node, WindowSize
+
+logger = logging.getLogger(__name__)
+
+class U2AndroidDriver(ADBAndroidDriver):
+    def __init__(self, serial: str):
+        super().__init__(serial)
+
+    @cached_property
+    def ud(self) -> u2.Device:
+        return u2.connect_usb(self.serial)
+    
+    def screenshot(self, id: int) -> Image.Image:
+        if id > 0:
+            # u2 is not support multi-display yet
+            return super().screenshot(id)
+        return self.ud.screenshot()
+
+    def dump_hierarchy(self, display_id: Optional[int] = 0) -> Tuple[str, Node]:
+        """returns xml string and hierarchy object"""
+        start = time.time()
+        xml_data = self._dump_hierarchy_raw()
+        logger.debug("dump_hierarchy cost: %s", time.time() - start)
+
+        wsize = self.adb_device.window_size()
+        logger.debug("window size: %s", wsize)
+        return xml_data, parse_xml(
+            xml_data, WindowSize(width=wsize[0], height=wsize[1]), display_id
+        )
+
+    def _dump_hierarchy_raw(self) -> str:
+        """
+        uiautomator2 server is conflict with "uiautomator dump" command.
+
+        uiautomator dump errors:
+        - ERROR: could not get idle state.
+        """
+        try:
+            return self.ud.dump_hierarchy()
+        except Exception as e:
+            raise AndroidDriverException(f"Failed to dump hierarchy: {str(e)}")
+    
+    def tap(self, x: int, y: int):
+        self.ud.click(x, y)
+    
+    def send_keys(self, text: str):
+        self.ud.send_keys(text)
+    
+    def clear_text(self):
+        self.ud.clear_text()

{uiautodev-0.12.0 → uiautodev-0.13.3}/uiautodev/driver/base_driver.py

@@ -4,11 +4,9 @@
 """Created on Fri Mar 01 2024 14:18:30 by codeskyblue
 """
 import abc
-from io import FileIO
 from typing import Iterator, List, Tuple
 
 from PIL import Image
-from pydantic import BaseModel
 
 from uiautodev.command_types import CurrentAppResponse
 from uiautodev.model import AppInfo, Node, ShellResponse, WindowSize

{uiautodev-0.12.0 → uiautodev-0.13.3}/uiautodev/driver/harmony.py

@@ -10,7 +10,7 @@ import tempfile
 import time
 import uuid
 from pathlib import Path
-from typing import List, Optional, Tuple, Union, final, Dict
+from typing import Dict, List, Optional, Tuple, Union, final
 
 from PIL import Image
 

{uiautodev-0.12.0 → uiautodev-0.13.3}/uiautodev/provider.py

@@ -7,10 +7,11 @@ from __future__ import annotations
 
 import abc
 from functools import lru_cache
+from typing import Type
 
 import adbutils
 
-from uiautodev.driver.android import AndroidDriver
+from uiautodev.driver.android import ADBAndroidDriver, U2AndroidDriver
 from uiautodev.driver.base_driver import BaseDriver
 from uiautodev.driver.harmony import HDC, HarmonyDriver
 from uiautodev.driver.ios import IOSDriver
@@ -40,8 +41,8 @@ class BaseProvider(abc.ABC):
 
 
 class AndroidProvider(BaseProvider):
-    def __init__(self):
-        pass
+    def __init__(self, driver_class: Type[BaseDriver] = U2AndroidDriver):
+        self.driver_class = driver_class
 
     def list_devices(self) -> list[DeviceInfo]:
         adb = adbutils.AdbClient()
@@ -61,8 +62,9 @@ class AndroidProvider(BaseProvider):
         return ret
 
     @lru_cache
-    def get_device_driver(self, serial: str) -> AndroidDriver:
-        return AndroidDriver(serial)
+    def get_device_driver(self, serial: str) -> BaseDriver:
+        return self.driver_class(serial)
+        
 
 
 class IOSProvider(BaseProvider):

{uiautodev-0.12.0 → uiautodev-0.13.3}/uiautodev/router/android.py

@@ -6,7 +6,7 @@ from typing import Dict, Optional
 from fastapi import APIRouter, Request, Response
 from pydantic import BaseModel
 
-from uiautodev.driver.android import AndroidDriver
+from uiautodev.driver.android import ADBAndroidDriver, U2AndroidDriver
 from uiautodev.model import ShellResponse
 
 logger = logging.getLogger(__name__)
@@ -21,7 +21,7 @@ class AndroidShellPayload(BaseModel):
 def shell(serial: str, payload: AndroidShellPayload) -> ShellResponse:
     """Run a shell command on an Android device"""
     try:
-        driver = AndroidDriver(serial)
+        driver = ADBAndroidDriver(serial)
         return driver.shell(payload.command)
     except NotImplementedError as e:
         return Response(content="shell not implemented", media_type="text/plain", status_code=501)
@@ -34,7 +34,7 @@ def shell(serial: str, payload: AndroidShellPayload) -> ShellResponse:
 async def get_current_activity(serial: str) -> Response:
     """Get the current activity of the Android device"""
     try:
-        driver = AndroidDriver(serial)
+        driver = ADBAndroidDriver(serial)
         activity = driver.get_current_activity()
         return Response(content=activity, media_type="text/plain")
     except Exception as e:

{uiautodev-0.12.0 → uiautodev-0.13.3}/uiautodev/router/device.py

@@ -53,7 +53,7 @@ def make_router(provider: BaseProvider) -> APIRouter:
             return Response(content=str(e), media_type="text/plain", status_code=500)
 
     @router.get("/{serial}/hierarchy")
-    def dump_hierarchy(serial: str, format: str = "json") -> Node:
+    def dump_hierarchy(serial: str, format: str = "json"):
         """Dump the view hierarchy of an Android device"""
         try:
             driver = provider.get_device_driver(serial)

uiautodev-0.13.3/uiautodev/router/proxy.py

@@ -0,0 +1,178 @@
+import asyncio
+import hashlib
+import json
+import logging
+from pathlib import Path
+from typing import Optional
+
+import httpx
+import websockets
+from fastapi import APIRouter, Request, WebSocket, WebSocketDisconnect
+from fastapi.responses import Response, StreamingResponse
+from starlette.background import BackgroundTask
+
+logger = logging.getLogger(__name__)
+router = APIRouter()
+cache_dir = Path("./cache")
+base_url = 'https://uiauto.dev'
+
+@router.get("/")
+@router.get("/android/{path:path}")
+@router.get("/ios/{path:path}")
+@router.get("/demo/{path:path}")
+@router.get("/harmony/{path:path}")
+async def proxy_html(request: Request):
+    cache = HTTPCache(cache_dir, base_url, key='homepage')
+    response = await cache.proxy_request(request, update_cache=True)
+    return response
+    # update
+
+@router.get("/assets/{path:path}")
+@router.get('/favicon.ico')
+async def proxy_assets(request: Request, path: str = ""):
+    target_url = f"{base_url}{request.url.path}"
+    cache = HTTPCache(cache_dir, target_url)
+    return await cache.proxy_request(request)
+
+
+class HTTPCache:
+    def __init__(self, cache_dir: Path, target_url: str, key: Optional[str] = None):
+        self.cache_dir = cache_dir
+        self.target_url = target_url
+        self.key = key or hashlib.md5(target_url.encode()).hexdigest()
+        self.file_body = self.cache_dir / 'http' / (self.key + ".body")
+        self.file_headers = self.file_body.with_suffix(".headers")
+
+    async def proxy_request(self, request: Request, update_cache: bool = False):
+        response = await self.get_cached_response(request)
+        if not response:
+            response = await self.proxy_and_save_response(request)
+            return response
+        if update_cache:
+            # async update cache in background
+            asyncio.create_task(self.update_cache(request))
+        return response
+
+    async def get_cached_response(self, request: Request):
+        if request.method == 'GET' and self.file_body.exists():
+            logger.info(f"Cache hit: {self.file_body}")
+            headers = {}
+            if self.file_headers.exists():
+                with self.file_headers.open('rb') as f:
+                    headers = json.load(f)
+            body_fd = self.file_body.open("rb")
+            return StreamingResponse(
+                content=body_fd,
+                status_code=200,
+                headers=headers,
+                background=BackgroundTask(body_fd.close)
+            )
+        return None
+
+    async def update_cache(self, request: Request):
+        try:
+            await self.proxy_and_save_response(request)
+        except Exception as e:
+            logger.error("Update cache failed")
+
+    async def proxy_and_save_response(self, request: Request) -> Response:
+        logger.debug(f"Proxying request... {request.url.path}")
+        response = await proxy_http(request, self.target_url)
+        # save response to cache
+        if request.method == "GET" and response.status_code == 200 and self.cache_dir.exists():
+            self.file_body.parent.mkdir(parents=True, exist_ok=True)
+            with self.file_body.open("wb") as f:
+                f.write(response.body)
+            with self.file_headers.open("w", encoding="utf-8") as f:
+                headers = response.headers
+                headers['cache-status'] = 'HIT'
+                json.dump(dict(headers), f, indent=2, ensure_ascii=False)
+        return response
+
+
+# WebSocket 转发
+@router.websocket("/proxy/ws/{target_url:path}")
+async def proxy_ws(websocket: WebSocket, target_url: str):
+    await websocket.accept()
+    logger.info(f"WebSocket target_url: {target_url}")
+
+    try:
+        async with websockets.connect(target_url) as target_ws:
+            async def from_client():
+                while True:
+                    msg = await websocket.receive_text()
+                    await target_ws.send(msg)
+
+            async def from_server():
+                while True:
+                    msg = await target_ws.recv()
+                    if isinstance(msg, bytes):
+                        await websocket.send_bytes(msg)
+                    elif isinstance(msg, str):
+                        await websocket.send_text(msg)
+                    else:
+                        raise RuntimeError("Unknown message type", msg)
+
+            await asyncio.gather(from_client(), from_server())
+
+    except WebSocketDisconnect:
+        pass
+    except Exception as e:
+        logger.error(f"WS Error: {e}")
+        await websocket.close()
+
+# ref: https://stackoverflow.com/questions/74555102/how-to-forward-fastapi-requests-to-another-server
+def make_reverse_proxy(base_url: str, strip_prefix: str = ""):
+    async def _reverse_proxy(request: Request):
+        client = httpx.AsyncClient(base_url=base_url)
+        client.timeout = httpx.Timeout(30.0, read=300.0)
+        path = request.url.path
+        if strip_prefix and path.startswith(strip_prefix):
+            path = path[len(strip_prefix):]
+        target_url = httpx.URL(
+            path=path, query=request.url.query.encode("utf-8")
+        )
+        exclude_headers = [b"host", b"connection", b"accept-encoding"]
+        headers = [(k, v) for k, v in request.headers.raw if k not in exclude_headers]
+        headers.append((b'accept-encoding', b''))
+        
+        req = client.build_request(
+            request.method, target_url, headers=headers, content=request.stream()
+        )
+        r = await client.send(req, stream=True)#, follow_redirects=True)
+        
+        response_headers = {
+            k: v for k, v in r.headers.items()
+            if k.lower() not in {"transfer-encoding", "connection", "content-length"}
+        }
+        async def gen_content():
+            async for chunk in r.aiter_bytes(chunk_size=40960):
+                yield chunk
+        
+        async def aclose():
+            await client.aclose()
+        
+        return StreamingResponse(
+            content=gen_content(),
+            status_code=r.status_code,
+            headers=response_headers,
+            background=BackgroundTask(aclose),
+        )
+
+    return _reverse_proxy
+
+
+async def proxy_http(request: Request, target_url: str):
+    logger.info(f"HTTP target_url: {target_url}")
+
+    async with httpx.AsyncClient(timeout=httpx.Timeout(30.0)) as client:
+        body = await request.body() if request.method in {"POST", "PUT", "PATCH", "DELETE"} else None
+        headers = {k: v for k, v in request.headers.items() if k.lower() not in {"host", "x-target-url"}}
+        headers['accept-encoding'] = ''  # disable gzip
+        resp = await client.request(
+            request.method,
+            target_url,
+            content=body,
+            headers=headers,
+        )
+        return Response(content=resp.content, status_code=resp.status_code, headers=dict(resp.headers))

uiautodev-0.12.0/uiautodev/router/proxy.py

@@ -1,57 +0,0 @@
-import asyncio
-import logging
-
-import httpx
-import websockets
-from fastapi import APIRouter, HTTPException, Request, WebSocket, WebSocketDisconnect
-from fastapi.responses import Response
-
-logger = logging.getLogger(__name__)
-router = APIRouter()
-
-
-# HTTP 转发
-@router.api_route("/http/{target_url:path}", methods=["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"])
-async def proxy_http(request: Request, target_url: str):
-    logger.info(f"HTTP target_url: {target_url}")
-
-    async with httpx.AsyncClient(timeout=httpx.Timeout(30.0)) as client:
-        body = await request.body()
-        resp = await client.request(
-            request.method,
-            target_url,
-            content=body,
-            headers={k: v for k, v in request.headers.items() if k.lower() != "host" and k.lower() != "x-target-url"}
-        )
-        return Response(content=resp.content, status_code=resp.status_code, headers=dict(resp.headers))
-
-# WebSocket 转发
-@router.websocket("/ws/{target_url:path}")
-async def proxy_ws(websocket: WebSocket, target_url: str):
-    await websocket.accept()
-    logger.info(f"WebSocket target_url: {target_url}")
-
-    try:
-        async with websockets.connect(target_url) as target_ws:
-            async def from_client():
-                while True:
-                    msg = await websocket.receive_text()
-                    await target_ws.send(msg)
-
-            async def from_server():
-                while True:
-                    msg = await target_ws.recv()
-                    if isinstance(msg, bytes):
-                        await websocket.send_bytes(msg)
-                    elif isinstance(msg, str):
-                        await websocket.send_text(msg)
-                    else:
-                        raise RuntimeError("Unknown message type", msg)
-
-            await asyncio.gather(from_client(), from_server())
-
-    except WebSocketDisconnect:
-        pass
-    except Exception as e:
-        logger.error(f"WS Error: {e}")
-        await websocket.close()