uiautodev 0.7.2__tar.gz → 0.9.0__tar.gz

{uiautodev-0.7.2 → uiautodev-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: uiautodev
-Version: 0.7.2
+Version: 0.9.0
 Summary: Mobile UI Automation, include UI hierarchy inspector, script recorder
 License: MIT
 Author: codeskyblue
@@ -38,15 +38,21 @@ Description-Content-Type: text/markdown
 
 https://uiauto.dev
 
-> backup site: https://uiauto.devsleep.com
+> In China visit: https://uiauto.devsleep.com
 
-UI Inspector for Android and iOS, help inspector element properties, and auto generate XPath, script.
+UI Inspector for Android, iOS and Harmony help inspector element properties, and auto generate XPath, script.
 
 # Install
 ```bash
 pip install uiautodev
 ```
 
+To enable Harmony support, run the following command to install its dependencies:
+
+```sh
+uiautodev install-harmony
+```
+
 # Usage
 ```bash
 Usage: uiauto.dev [OPTIONS] COMMAND [ARGS]...

{uiautodev-0.7.2 → uiautodev-0.9.0}/README.md

@@ -4,15 +4,21 @@
 
 https://uiauto.dev
 
-> backup site: https://uiauto.devsleep.com
+> In China visit: https://uiauto.devsleep.com
 
-UI Inspector for Android and iOS, help inspector element properties, and auto generate XPath, script.
+UI Inspector for Android, iOS and Harmony help inspector element properties, and auto generate XPath, script.
 
 # Install
 ```bash
 pip install uiautodev
 ```
 
+To enable Harmony support, run the following command to install its dependencies:
+
+```sh
+uiautodev install-harmony
+```
+
 # Usage
 ```bash
 Usage: uiauto.dev [OPTIONS] COMMAND [ARGS]...

{uiautodev-0.7.2 → uiautodev-0.9.0}/pyproject.toml

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

{uiautodev-0.7.2 → uiautodev-0.9.0}/uiautodev/__init__.py

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

{uiautodev-0.7.2 → uiautodev-0.9.0}/uiautodev/app.py

@@ -9,7 +9,7 @@ import os
 import platform
 import signal
 from pathlib import Path
-from typing import List
+from typing import Dict, List
 
 import adbutils
 import uvicorn
@@ -25,6 +25,7 @@ from uiautodev.common import convert_bytes_to_image, get_webpage_url, ocr_image
 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.xml import router as xml_router
 from uiautodev.utils.envutils import Environment
@@ -68,6 +69,23 @@ else:
     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.get('/api/{platform}/features')
+def get_features(platform: str) -> Dict[str, bool]:
+    """Get features supported by the specified platform"""
+    features = {}
+    # 获取所有带有指定平台tag的路由
+    for route in app.routes:
+        if hasattr(route, 'tags') and platform in route.tags:
+            if route.path.startswith(f"/api/{platform}/{{serial}}/"):
+                # 提取特性名称
+                parts = route.path.split('/')
+                feature_name = parts[-1]
+                if not feature_name.startswith('{'):
+                    features[feature_name] = True
+    return features
 
 
 class InfoResponse(BaseModel):
@@ -123,15 +141,41 @@ def index_redirect():
     return RedirectResponse(url)
 
 
-def get_scrcpy_server(serial: str):
-    # 这里主要是为了避免两次websocket建立建立，启动两个scrcpy进程
-    logger.info("create scrcpy server for %s", serial)
-    device = adbutils.device(serial)
-    return ScrcpyServer(device)
+@app.websocket("/ws/android/scrcpy/{serial}")
+async def handle_android_ws(websocket: WebSocket, serial: str):
+    """
+    Args:
+        serial: device serial
+        websocket: WebSocket
+    """
+    await websocket.accept()
 
+    try:
+        logger.info(f"WebSocket serial: {serial}")
+        device = adbutils.device(serial)
+        server = ScrcpyServer(device)
+        await server.handle_unified_websocket(websocket, serial)
+    except WebSocketDisconnect:
+        logger.info(f"WebSocket disconnected by client.")
+    except Exception as e:
+        logger.exception(f"WebSocket error for serial={serial}: {e}")
+        await websocket.close(code=1000, reason=str(e))
+    finally:
+        logger.info(f"WebSocket closed for serial={serial}")
 
-@app.websocket("/ws/android/scrcpy/{serial}")
-async def unified_ws(websocket: WebSocket, serial: str):
+
+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()}')
+    return HarmonyMjpegServer(driver)
+
+
+@app.websocket("/ws/harmony/mjpeg/{serial}")
+async def unified_harmony_ws(websocket: WebSocket, serial: str):
     """
     Args:
         serial: device serial
@@ -142,9 +186,13 @@ async def unified_ws(websocket: WebSocket, serial: str):
     try:
         logger.info(f"WebSocket serial: {serial}")
 
-        # 获取 ScrcpyServer 实例
-        server = get_scrcpy_server(serial)
-        await server.handle_unified_websocket(websocket, serial)
+        # 获取 HarmonyScrcpyServer 实例
+        server = get_harmony_mjpeg_server(serial)
+        server.start()
+        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]\"")
     except WebSocketDisconnect:
         logger.info(f"WebSocket disconnected by client.")
     except Exception as e:

{uiautodev-0.7.2 → uiautodev-0.9.0}/uiautodev/cli.py

@@ -19,6 +19,7 @@ import click
 import httpx
 import pydantic
 import uvicorn
+from retry import retry
 
 from uiautodev import __version__, command_proxy
 from uiautodev.command_types import Command
@@ -29,7 +30,13 @@ from uiautodev.utils.common import convert_params_to_model, print_json
 logger = logging.getLogger(__name__)
 
 CONTEXT_SETTINGS = dict(help_option_names=['-h', '--help'])
-
+HARMONY_PACKAGES = [
+    "setuptools",
+    "https://public.uiauto.devsleep.com/harmony/xdevice-5.0.7.200.tar.gz",
+    "https://public.uiauto.devsleep.com/harmony/xdevice-devicetest-5.0.7.200.tar.gz",
+    "https://public.uiauto.devsleep.com/harmony/xdevice-ohos-5.0.7.200.tar.gz",
+    "https://public.uiauto.devsleep.com/harmony/hypium-5.0.7.200.tar.gz",
+]
 
 @click.group(context_settings=CONTEXT_SETTINGS)
 @click.option("--verbose", "-v", is_flag=True, default=False, help="verbose mode")
@@ -116,6 +123,19 @@ def self_update():
     subprocess.run([sys.executable, '-m', "pip", "install", "--upgrade", "uiautodev"])
 
 
+@cli.command('install-harmony')
+def install_harmony():
+    for lib_url in HARMONY_PACKAGES:
+        click.echo(f"Installing {lib_url} ...")
+        pip_install(lib_url)
+
+@retry(tries=2, delay=3, backoff=2)
+def pip_install(package: str):
+    """Install a package using pip."""
+    subprocess.run([sys.executable, '-m', "pip", "install", package], check=True)
+    click.echo(f"Successfully installed {package}")
+
+
 @cli.command(help="start uiauto.dev local server [Default]")
 @click.option("--port", default=20242, help="port number", show_default=True)
 @click.option("--host", default="127.0.0.1", help="host", show_default=True)
@@ -123,7 +143,7 @@ def self_update():
 @click.option("-f", "--force", is_flag=True, default=False, help="shutdown alrealy runningserver")
 @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):
-    print("uiautodev version:", __version__)
+    click.echo(f"uiautodev version: {__version__}")
     if force:
         try:
             httpx.get(f"http://{host}:{port}/shutdown", timeout=3)

{uiautodev-0.7.2 → uiautodev-0.9.0}/uiautodev/driver/android.py

@@ -31,6 +31,15 @@ class AndroidDriver(BaseDriver):
     @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 的行
+        match = re.search(r"mResumedActivity:.*? ([\w\.]+\/[\w\.]+)", ret.output)
+        if match:
+            return match.group(1)  # 返回包名/类名，例如 com.example/.MainActivity
+        else:
+            return ""
     
     def screenshot(self, id: int) -> Image.Image:
         if id > 0:
@@ -117,13 +126,48 @@ class AndroidDriver(BaseDriver):
     
     def volume_mute(self):
         self.adb_device.keyevent("VOLUME_MUTE")
-    
+
+    def get_app_version(self, package_name: str) -> Optional[dict]:
+        """
+        Get the version information of an app, including mainVersion and subVersion.
+
+        Args:
+            package_name (str): The package name of the app.
+
+        Returns:
+            dict: A dictionary containing mainVersion and subVersion.
+        """
+        output = self.adb_device.shell(["dumpsys", "package", package_name])
+
+        # versionName
+        m = re.search(r"versionName=(?P<name>[^\s]+)", output)
+        version_name = m.group("name") if m else ""
+        if version_name == "null":  # Java dumps "null" for null values
+            version_name = None
+
+        # versionCode
+        m = re.search(r"versionCode=(?P<code>\d+)", output)
+        version_code = m.group("code") if m else ""
+        version_code = int(version_code) if version_code.isdigit() else None
+
+        return {
+            "versionName": version_name,
+            "versionCode": version_code
+        }
+
     def app_list(self) -> List[AppInfo]:
         results = []
         output = self.adb_device.shell(["pm", "list", "packages", '-3'])
         for m in re.finditer(r"^package:([^\s]+)\r?$", output, re.M):
             packageName = m.group(1)
-            results.append(AppInfo(packageName=packageName))
+            # get version
+            version_info = self.get_app_version(packageName)
+            app_info = AppInfo(
+                packageName=packageName,
+                versionName=version_info.get("versionName"),
+                versionCode=version_info.get("versionCode")
+            )
+            results.append(app_info)
         return results
 
     def open_app_file(self, package: str) -> Iterator[bytes]:

uiautodev-0.9.0/uiautodev/exceptions.py

@@ -0,0 +1,26 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""Created on Tue Mar 05 2024 11:16:29 by codeskyblue
+"""
+
+class UiautoException(Exception):
+    pass
+
+
+class DriverException(UiautoException):
+    """Base class for all driver-related exceptions."""
+    pass
+
+class IOSDriverException(DriverException): ...
+class AndroidDriverException(DriverException): ...
+class HarmonyDriverException(DriverException): ...
+class AppiumDriverException(DriverException): ...
+
+
+class MethodError(UiautoException):
+    pass
+
+
+class ElementNotFoundError(MethodError): ...
+class RequestError(UiautoException): ...

{uiautodev-0.7.2 → uiautodev-0.9.0}/uiautodev/model.py

@@ -33,7 +33,7 @@ class Rect(BaseModel):
 
 class Node(BaseModel):
     key: str
-    name: str # can be seen as description
+    name: str  # can be seen as description
     bounds: Optional[Tuple[float, float, float, float]] = None
     rect: Optional[Rect] = None
     properties: Dict[str, Union[str, bool]] = {}
@@ -50,4 +50,6 @@ class WindowSize(typing.NamedTuple):
 
 
 class AppInfo(BaseModel):
-    packageName: str
+    packageName: str
+    versionName: Optional[str] = None  # Allow None values
+    versionCode: Optional[int] = None

uiautodev-0.9.0/uiautodev/remote/harmony_mjpeg.py

@@ -0,0 +1,199 @@
+import asyncio
+import json
+import logging
+import socket
+from datetime import datetime
+from threading import Thread
+
+from fastapi import WebSocket
+from hypium import KeyCode
+
+from uiautodev.exceptions import HarmonyDriverException
+
+logger = logging.getLogger(__name__)
+
+
+class HarmonyMjpegServer:
+    """
+    HarmonyMjpegServer is responsible for handling screen streaming functionality
+    for HarmonyOS devices that support ABC proxy (a communication interface).
+
+    It manages WebSocket clients, communicates with the ABC server over gRPC, and streams
+    the device's screen data in real-time to connected clients.
+
+    This server is specifically designed for devices running in 'abc mode' and requires that
+    the target device expose an `abc_proxy` attribute for communication.
+
+    Attributes:
+        device: The HarmonyOS device object.
+        driver: The controlling driver which may wrap the device.
+        abc_rpc_addr: Tuple containing the IP and port used to communicate with abc_proxy.
+        channel: The gRPC communication channel (initialized later).
+        clients: A set of connected WebSocket clients.
+        loop: Asyncio event loop used to run asynchronous tasks.
+        is_running: Boolean flag indicating if the streaming service is active.
+
+    Raises:
+        RuntimeError: If the connected device does not support abc_proxy.
+
+    References:
+        - Huawei HarmonyOS Python Guidelines:
+          https://developer.huawei.com/consumer/cn/doc/harmonyos-guides/hypium-python-guidelines
+    """
+
+    def __init__(self, driver):
+        if hasattr(driver, "_device"):
+            device = driver._device
+        else:
+            device = driver
+        logger.info(f'device: {device}')
+        if not hasattr(device, "abc_proxy") or device.abc_proxy is None:
+            raise HarmonyDriverException("Only abc mode can support screen recorder")
+        self.device = device
+        self.driver = driver
+        self.abc_rpc_addr = ("127.0.0.1", device.abc_proxy.port)
+        self.channel = None
+        self.clients = set()
+        self.loop = asyncio.get_event_loop()
+        self.is_running = False
+
+    def connect(self):
+        self.channel = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self.channel.connect(self.abc_rpc_addr)
+
+    def start(self, timeout=3600):
+        if self.channel is None:
+            self.connect()
+        self.is_running = True
+        self.timeout = timeout
+        self.stop_capture_if_running()
+        msg_json = {'api': "startCaptureScreen", 'args': []}
+        full_msg = {
+            "module": "com.ohos.devicetest.hypiumApiHelper",
+            "method": "Captures", 
+            "params": msg_json,
+            "request_id": datetime.now().strftime("%Y%m%d%H%M%S%f")
+        }
+        full_msg_str = json.dumps(full_msg, ensure_ascii=False, separators=(',', ':'))
+        self.channel.sendall(full_msg_str.encode("utf-8") + b'\n')
+        reply = self.channel.recv(1024)
+        logger.info(f'reply: {reply}')
+        if b"true" in reply:
+            thread_record = Thread(target=self._record_worker)
+            thread_record.start()
+        else:
+            raise RuntimeError("Fail to start screen capture")
+
+    def stop_capture_if_running(self):
+        msg_json = {'api': "stopCaptureScreen", 'args': []}
+        full_msg = {
+            "module": "com.ohos.devicetest.hypiumApiHelper",
+            "method": "Captures", 
+            "params": msg_json,
+            "request_id": datetime.now().strftime("%Y%m%d%H%M%S%f")
+        }
+        full_msg_str = json.dumps(full_msg, ensure_ascii=False, separators=(',', ':'))
+        self.channel.sendall(full_msg_str.encode("utf-8") + b'\n')
+        reply = self.channel.recv(1024)
+        logger.info(f'stop reply: {reply}')
+
+    async def handle_ws(self, websocket: WebSocket):
+        self.clients.add(websocket)
+        serial = getattr(self.device, "device_sn", "unknown")
+        logger.info(f"[{serial}] WebSocket connected")
+
+        try:
+            while True:
+                message = await websocket.receive_text()
+                logger.info(f"Received message: {message}")
+                try:
+                    data = json.loads(message)
+                    if data.get('type') == 'touch':
+                        action = data.get('action')
+                        x, y = data.get('x'), data.get('y')
+                        if action == 'normal':
+                            self.driver.touch((x, y))
+                        elif action == 'long':
+                            self.driver.touch(target=(x, y), mode='long')
+                        elif action == 'double':
+                            self.driver.touch(target=(x, y), mode='double')
+                        elif action == 'move':
+                            self.driver.slide(
+                                start=(data.get('x1'), data.get('y1')),
+                                end=(data.get('x2'), data.get('y2')),
+                                slide_time=0.1
+                            )
+                    elif data.get('type') == 'keyEvent':
+                        event_number = data['eventNumber']
+                        if event_number == 187:
+                            self.driver.swipe_to_recent_task()
+                        elif event_number == 3:
+                            self.driver.go_home()
+                        elif event_number == 4:
+                            self.driver.go_back()
+                        elif event_number == 224:
+                            self.driver.wake_up_display()
+                    elif data.get('type') == 'text':
+                        detail = data.get('detail')
+                        if detail == 'CODE_AC_BACK':
+                            self.driver.press_key(KeyCode.DEL)
+                        elif detail == 'CODE_AC_ENTER':
+                            self.driver.press_key(KeyCode.ENTER)
+                        else:
+                            self.driver.shell(
+                                f"uitest uiInput inputText {data.get('x')} {data.get('y')} {detail}")
+                except Exception as e:
+                    logger.warning(f"Failed to handle message: {e}")
+        except Exception as e:
+            logger.info(f"WebSocket closed: {e}")
+        finally:
+            self.clients.discard(websocket)
+
+    def _record_worker(self):
+        tmp_data = b''
+        start_flag = b'\xff\xd8'
+        end_flag = b'\xff\xd9'
+        while self.is_running:
+            try:
+                result = self.channel.recv(4096 * 1024)
+                tmp_data += result
+                while start_flag in tmp_data and end_flag in tmp_data:
+                    start_index = tmp_data.index(start_flag)
+                    end_index = tmp_data.index(end_flag) + 2
+                    frame = tmp_data[start_index:end_index]
+                    tmp_data = tmp_data[end_index:]
+                    asyncio.run_coroutine_threadsafe(self._broadcast(frame), self.loop)
+            except Exception as e:
+                logger.warning(f"Record worker error: {e}")
+                self.is_running = False
+                self.channel = None
+                break
+
+    async def _broadcast(self, data):
+        for client in self.clients.copy():
+            try:
+                await client.send_bytes(data)
+            except Exception as e:
+                logger.info(f"Send error, removing client: {e}")
+                self.clients.discard(client)
+
+    def stop(self):
+        self.is_running = False
+        if self.channel is None:
+            return
+        msg_json = {'api': "stopCaptureScreen", 'args': []}
+        full_msg = {
+            "module": "com.ohos.devicetest.hypiumApiHelper",
+            "method": "Captures",
+            "params": msg_json,
+            "request_id": datetime.now().strftime("%Y%m%d%H%M%S%f")
+        }
+        full_msg_str = json.dumps(full_msg, ensure_ascii=False, separators=(',', ':'))
+        self.channel.sendall(full_msg_str.encode("utf-8") + b'\n')
+        reply = self.channel.recv(1024)
+        if b"true" not in reply:
+            logger.info("Fail to stop capture")
+        self.channel.close()
+        self.channel = None
+        for client in self.clients:
+            asyncio.run_coroutine_threadsafe(client.close(), self.loop)

{uiautodev-0.7.2 → uiautodev-0.9.0}/uiautodev/remote/scrcpy.py

@@ -16,6 +16,7 @@ from uiautodev.remote.touch_controller import ScrcpyTouchController
 
 logger = logging.getLogger(__name__)
 
+
 class ScrcpyServer:
     """
     ScrcpyServer class is responsible for managing the scrcpy server on Android devices.
@@ -30,17 +31,18 @@ class ScrcpyServer:
         Args:
             scrcpy_jar_path (str, optional): Path to the scrcpy server JAR file. Defaults to None.
         """
-        self.scrcpy_jar_path = scrcpy_jar_path or os.path.join(os.path.dirname(__file__), '../binaries/scrcpy_server.jar')
+        self.scrcpy_jar_path = scrcpy_jar_path or os.path.join(os.path.dirname(__file__),
+                                                               '../binaries/scrcpy_server.jar')
         self.device = device
         self.resolution_width = 0  # scrcpy 投屏转换宽度
         self.resolution_height = 0  # scrcpy 投屏转换高度
-        
+
         self._shell_conn: AdbConnection
         self._video_conn: socket.socket
         self._control_conn: socket.socket
 
         self._setup_connection()
-    
+
     def _setup_connection(self):
         self._shell_conn = self._start_scrcpy_server(control=True)
         self._video_conn = self._connect_scrcpy(self.device)
@@ -73,7 +75,7 @@ class ScrcpyServer:
             self._shell_conn.close()
         except:
             pass
-    
+
     def __del__(self):
         self.close()
 
@@ -108,14 +110,14 @@ class ScrcpyServer:
         )
         conn = device.shell(start_command, stream=True)
         logger.debug("scrcpy output: %s", conn.conn.recv(100))
-        return conn # type: ignore
+        return conn  # type: ignore
 
     async def handle_unified_websocket(self, websocket: WebSocket, serial=''):
         logger.info(f"[Unified] WebSocket connection from {websocket} for serial: {serial}")
 
         video_task = asyncio.create_task(self._stream_video_to_websocket(self._video_conn, websocket))
-        control_task  = asyncio.create_task(self._handle_control_websocket(websocket))
-        
+        control_task = asyncio.create_task(self._handle_control_websocket(websocket))
+
         try:
             # 不使用 return_exceptions=True，让异常能够正确传播
             await asyncio.gather(video_task, control_task)
@@ -129,14 +131,14 @@ class ScrcpyServer:
     async def _stream_video_to_websocket(self, conn: socket.socket, ws: WebSocket):
         # Set socket to non-blocking mode
         conn.setblocking(False)
-        
+
         while True:
             # check if ws closed
             if ws.client_state.name != "CONNECTED":
                 logger.info('WebSocket no longer connected. Exiting video stream.')
                 break
             # Use asyncio to read data asynchronously
-            data = await asyncio.get_event_loop().sock_recv(conn, 1024*1024)
+            data = await asyncio.get_event_loop().sock_recv(conn, 1024 * 1024)
             if not data:
                 logger.warning('No data received, connection may be closed.')
                 raise ConnectionError("Video stream ended unexpectedly")
@@ -174,4 +176,4 @@ class ScrcpyServer:
                     await ws.send_text(json.dumps({"type": "pong"}))
             except json.JSONDecodeError as e:
                 logger.error(f"Invalid JSON message: {e}")
-                continue
+                continue

uiautodev-0.9.0/uiautodev/router/android.py

@@ -0,0 +1,42 @@
+# prefix for /api/android/{serial}/shell
+
+import logging
+from typing import Dict, Optional
+
+from fastapi import APIRouter, Request, Response
+from pydantic import BaseModel
+
+from uiautodev.driver.android import AndroidDriver
+from uiautodev.model import ShellResponse
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter()
+
+
+class AndroidShellPayload(BaseModel):
+    command: str
+    
+@router.post("/{serial}/shell")
+def shell(serial: str, payload: AndroidShellPayload) -> ShellResponse:
+    """Run a shell command on an Android device"""
+    try:
+        driver = AndroidDriver(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:
+        logger.exception("shell failed")
+        return ShellResponse(output="", error=str(e))
+
+
+@router.get("/{serial}/current_activity")
+async def get_current_activity(serial: str) -> Response:
+    """Get the current activity of the Android device"""
+    try:
+        driver = AndroidDriver(serial)
+        activity = driver.get_current_activity()
+        return Response(content=activity, media_type="text/plain")
+    except Exception as e:
+        logger.exception("get_current_activity failed")
+        return Response(content="", media_type="text/plain")

{uiautodev-0.7.2 → uiautodev-0.9.0}/uiautodev/router/device.py

@@ -6,9 +6,9 @@
 
 import io
 import logging
-from typing import Any, Dict, List
+from typing import Any, Dict, List, Optional
 
-from fastapi import APIRouter, Response
+from fastapi import APIRouter, Query, Request, Response
 from fastapi.responses import StreamingResponse
 from pydantic import BaseModel
 
@@ -19,9 +19,6 @@ from uiautodev.provider import BaseProvider
 
 logger = logging.getLogger(__name__)
 
-class AndroidShellPayload(BaseModel):
-    command: str
-
 
 def make_router(provider: BaseProvider) -> APIRouter:
     router = APIRouter()
@@ -37,18 +34,6 @@ def make_router(provider: BaseProvider) -> APIRouter:
             logger.exception("list_devices failed")
             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:
-            logger.exception("shell failed")
-            return ShellResponse(output="", error=str(e))
-
     @router.get(
         "/{serial}/screenshot/{id}",
         responses={200: {"content": {"image/jpeg": {}}}},

uiautodev-0.7.2/uiautodev/exceptions.py

@@ -1,32 +0,0 @@
-#!/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