feat: little change

codematrixer · codematrixer · commit d94fa0bf9b73 · 2024-10-06T20:36:33.000+08:00
diff --git a/uiviewer/__init__.py b/uiviewer/__init__.py
@@ -1 +1,19 @@
 # -*- coding: utf-8 -*-
+
+import logging
+
+formatter = logging.Formatter('[%(asctime)s] %(filename)15s[line:%(lineno)4d] \
+                              [%(levelname)s] %(message)s',
+                              datefmt='%Y-%m-%d %H:%M:%S')
+
+logger = logging.getLogger('hmdriver2')
+logger.setLevel(logging.DEBUG)
+
+console_handler = logging.StreamHandler()
+console_handler.setLevel(logging.DEBUG)
+console_handler.setFormatter(formatter)
+
+logger.addHandler(console_handler)
+
+
+__all__ = ['logger']
diff --git a/uiviewer/_device.py b/uiviewer/_device.py
@@ -1,11 +1,13 @@
 # -*- coding: utf-8 -*-
 
 import abc
+import traceback
 import tempfile
 from typing import List, Dict, Union, Tuple
 from functools import cached_property  # python3.8+
 
 from PIL import Image
+from requests import request
 import tidevice
 import adbutils
 import wda
@@ -27,10 +29,8 @@ def list_serials(platform: str) -> List[str]:
     elif platform == Platform.IOS:
         raw = tidevice.Usbmux().device_list()
         devices = [d.udid for d in raw]
-    elif platform == Platform.HARMONY:
-        devices = hdc.list_devices()
     else:
-        raise HTTPException(status_code=200, detail="Unsupported platform")
+        devices = hdc.list_devices()
 
     return devices
 
@@ -51,7 +51,7 @@ def __init__(self, serial: str):
         self.client = Driver(serial)
 
     @cached_property
-    def display_size(self) -> Tuple:
+    def _display_size(self) -> Tuple:
         return self.client.display_size
 
     def take_screenshot(self) -> str:
@@ -68,18 +68,19 @@ def dump_hierarchy(self) -> BaseHierarchy:
             jsonHierarchy=hierarchy,
             activityName=pageName,
             packageName=packageName,
-            windowSize=self.display_size,
+            windowSize=self._display_size,
             scale=1
         )
 
 
 class AndroidDevice(DeviceMeta):
     def __init__(self, serial: str):
         self.serial = serial
+        adbutils.AdbClient()
         self.d: u2.Device = u2.connect(serial)
 
     @cached_property
-    def window_size(self) -> Tuple:
+    def _window_size(self) -> Tuple:
         return self.d.window_size()
 
     def take_screenshot(self) -> str:
@@ -94,58 +95,79 @@ def dump_hierarchy(self) -> BaseHierarchy:
             jsonHierarchy=page_json,
             activityName=current['activity'],
             packageName=current['package'],
-            windowSize=self.window_size,
+            windowSize=self._window_size,
             scale=1
         )
 
 
 class IosDevice(DeviceMeta):
-    def __init__(self, udid: str, wda_url: str) -> None:
+    def __init__(self, udid: str, wda_url: str, max_depth: int) -> None:
         self.udid = udid
+        self.wda_url = wda_url
+        self.max_depth = max_depth
         self.client = wda.Client(wda_url)
 
     @cached_property
     def scale(self) -> int:
         return self.client.scale
 
     @cached_property
-    def window_size(self) -> Tuple:
+    def _window_size(self) -> Tuple:
         return self.client.window_size()
 
     def take_screenshot(self) -> str:
         img: Image.Image = self.client.screenshot()
         return image_to_base64(img)
 
+    def _current_bundle_id(self) -> str:
+        resp = request("GET", f"{self.wda_url}/wda/activeAppInfo", timeout=10).json()
+        bundleId = resp.get("value", {}).get("bundleId", None)
+        return bundleId
+
     def dump_hierarchy(self) -> BaseHierarchy:
+        self.client.appium_settings({"snapshotMaxDepth": self.max_depth})
         data: Dict = self.client.source(format="json")
         hierarchy: Dict = ios_hierarchy.convert_ios_hierarchy(data, self.scale)
         return BaseHierarchy(
             jsonHierarchy=hierarchy,
             activityName=None,
-            packageName=self.client.bundle_id,
-            windowSize=self.window_size,
+            packageName=self._current_bundle_id(),
+            windowSize=self._window_size,
             scale=self.scale
         )
 
+    def wda_health(self) -> bool:
+        resp = request("GET", f"{self.wda_url}/status", timeout=5).json()
+        state = resp.get("value", {}).get("state")
+        return state == "success"
 
-def get_device(platform: str, serial: str, wda_url: str = None) -> Union[HarmonyDevice, AndroidDevice]:
-    if serial not in list_serials(platform):
-        raise HTTPException(status_code=200, detail="Device not found")
+
+def get_device(platform: str, serial: str, wda_url: str, max_depth: int) -> Union[HarmonyDevice, AndroidDevice]:
     if platform == Platform.HARMONY:
         return HarmonyDevice(serial)
     elif platform == Platform.ANDROID:
         return AndroidDevice(serial)
-    elif platform == Platform.IOS:
-        return IosDevice(serial, wda_url)
     else:
-        raise HTTPException(status_code=200, detail="Unsupported platform")
+        return IosDevice(serial, wda_url, max_depth)
 
 
 # Global cache for devices
 cached_devices = {}
 
 
-def init_device(platform: str, serial: str, wda_url: str = None):
-    device = get_device(platform, serial, wda_url)
-    cached_devices[(platform, serial)] = device
-    return platform, serial
+def init_device(platform: str, serial: str, wda_url: str = None, max_depth: int = 30) -> bool:
+
+    if serial not in list_serials(platform):
+        raise HTTPException(status_code=500, detail=f"Device<{serial}> not found")
+
+    try:
+        device: Union[HarmonyDevice, AndroidDevice] = get_device(platform, serial, wda_url, max_depth)
+        cached_devices[(platform, serial)] = device
+
+        if isinstance(device, IosDevice):
+            return device.wda_health()
+    except Exception:
+        error = traceback.format_exc()
+        raise HTTPException(status_code=500, detail=error)
+
+    return True
diff --git a/uiviewer/_utils.py b/uiviewer/_utils.py
@@ -18,5 +18,3 @@ def image_to_base64(image: Image.Image, format: str = "PNG") -> str:
     buffered = BytesIO()
     image.save(buffered, format=format)
     return base64.b64encode(buffered.getvalue()).decode('utf-8')
-
-
diff --git a/uiviewer/app.py b/uiviewer/app.py
@@ -3,7 +3,8 @@
 import os
 import webbrowser
 import uvicorn
-from typing import Union,Optional
+import threading
+from typing import Union, Optional
 
 from fastapi import FastAPI, Request, Query, HTTPException
 from fastapi.staticfiles import StaticFiles
@@ -30,15 +31,15 @@
 
 
 @app.exception_handler(Exception)
-async def global_exception_handler(request: Request, exc: Exception):
+def global_exception_handler(request: Request, exc: Exception):
     return JSONResponse(
         status_code=500,
         content=ApiResponse(success=False, message=str(exc)).dict()
     )
 
 
 @app.exception_handler(HTTPException)
-async def http_exception_handler(request: Request, exc: HTTPException):
+def http_exception_handler(request: Request, exc: HTTPException):
     return JSONResponse(
         status_code=exc.status_code,
         content=ApiResponse(success=False, message=exc.detail).dict(),
@@ -50,42 +51,44 @@ def open_browser():
 
 
 @app.get("/")
-async def root():
+def root():
     return RedirectResponse(url="/static/index.html")
 
 
 @app.get("/health")
-async def health():
+def health():
     return "ok"
 
 
 @app.get("/{platform}/serials", response_model=ApiResponse)
-async def get_serials(platform: str):
+def get_serials(platform: str):
     serials = list_serials(platform)
     return ApiResponse.doSuccess(serials)
 
 
-@app.post("/{platform}/{serial}/init", response_model=ApiResponse)
-async def init(platform: str, serial: str, wdaUrl: Optional[str] = Query(None)):
-    device = init_device(platform, serial, wdaUrl)
-    return ApiResponse.doSuccess(device)
+@app.post("/{platform}/{serial}/connect", response_model=ApiResponse)
+def connect(platform: str, serial: str, wdaUrl: Optional[str] = Query(None), maxDepth: Optional[int] = Query(None)):
+    ret = init_device(platform, serial, wdaUrl, maxDepth)
+    return ApiResponse.doSuccess(ret)
 
 
 @app.get("/{platform}/{serial}/screenshot", response_model=ApiResponse)
-async def screenshot(platform: str, serial: str):
+def screenshot(platform: str, serial: str):
     device: Union[AndroidDevice, IosDevice, HarmonyDevice] = cached_devices.get((platform, serial))
     data = device.take_screenshot()
     return ApiResponse.doSuccess(data)
 
 
 @app.get("/{platform}/{serial}/hierarchy", response_model=ApiResponse)
-async def dump_hierarchy(platform: str, serial: str):
+def dump_hierarchy(platform: str, serial: str):
     device: Union[AndroidDevice, IosDevice, HarmonyDevice] = cached_devices.get((platform, serial))
     data = device.dump_hierarchy()
     return ApiResponse.doSuccess(data)
 
 
 if __name__ == "__main__":
-    import threading
-    threading.Timer(1.0, open_browser).start()
+    timer = threading.Timer(1.0, open_browser)
+    timer.daemon = True
+    timer.start()
+
     uvicorn.run(app, host="127.0.0.1", port=8000)
diff --git a/uiviewer/static/index.html b/uiviewer/static/index.html
@@ -8,7 +8,12 @@
     <link rel="stylesheet" type="text/css" href="/static/css/style.css">
 </head>
 <body>
-    <div id="app">
+    <div
+        id="app"
+        v-loading="isConnecting || isDumping"
+        element-loading-spinner="el-icon-loading"
+        element-loading-background="rgba(0, 0, 0, 0.7)">
+
         <div class="header">
             <div style="margin-right: 20px;">
                 <span style="font-weight: bold; font-size: 20px;">UI Viewer</span>
@@ -27,7 +32,7 @@
             <el-select
               v-model="serial"
               placeholder="Select Device"
-              style="margin-right: 20px;"
+              style="margin-right: 20px; width: 250px"
               @visible-change="listDevice">
               <el-option
                 v-for="d in devices"
@@ -37,13 +42,24 @@
               </el-option>
             </el-select>
 
-            <el-input
-              class="custom-input"
-              v-if="platform === 'ios'"
-              v-model="wdaUrl"
-              style="width: 250px; margin-right: 20px;"
-              placeholder="Please input WDA url">
-            </el-input>
+            <el-tooltip v-if="platform === 'ios'" content="Set WDA url, default value is http://localhost:8100" placement="top">
+              <el-input
+                class="custom-input"
+                v-model="wdaUrl"
+                style="width: 180px; margin-right: 20px;"
+                placeholder="WDA server url">
+              </el-input>
+            </el-tooltip>
+
+            <el-tooltip v-if="platform === 'ios'" content="Set the maximum depth for iOS dump hierarchy, default value is 30" placement="top">
+              <el-input
+                class="custom-input"
+                v-model="snapshotMaxDepth"
+                style="width: 100px; margin-right: 20px;"
+                placeholder="maxDepth">
+              </el-input>
+            </el-tooltip>
+
 
             <el-button 
               :disabled="isConnecting"
@@ -67,7 +83,7 @@
             <el-button 
               v-else :disabled="isDumping"
               style="margin-right: 10px; width: 160px;"
-              v-on:click="dumpHierarchyWithScreen">
+              v-on:click="screenshotAndDumpHierarchy">
               <span 
                 v-if="isDumping"
                 class="el-icon-loading">
@@ -84,12 +100,7 @@
             </el-link>
 
         </div>
-        <div 
-            class="main"
-            v-loading="isConnecting || isDumping"
-            element-loading-spinner="el-icon-loading"
-            element-loading-background="rgba(0, 0, 0, 0.7)">
-
+        <div class="main">
             <div class="left">
                 <canvas id="screenshotCanvas"></canvas>
                 <canvas id="hierarchyCanvas"></canvas>
diff --git a/uiviewer/static/js/api.js b/uiviewer/static/js/api.js
@@ -1,23 +1,30 @@
 import { API_HOST } from './config.js';
 
+async function checkResponse(response) {
+  if (response.status === 500) {
+    throw new Error('Server error: 500');
+  }
+  return response.json();
+}
+
 export async function listDevices(platform) {
   const response = await fetch(`${API_HOST}${platform}/serials`);
-  return response.json();
+  return checkResponse(response);
 }
 
-export async function connectDevice(platform, serial, wdaUrl) {
-  const response = await fetch(`${API_HOST}${platform}/${serial}/init?wdaUrl=${wdaUrl}`, {
+export async function connectDevice(platform, serial, wdaUrl, maxDepth) {
+  const response = await fetch(`${API_HOST}${platform}/${serial}/connect?wdaUrl=${wdaUrl}&maxDepth=${maxDepth}`, {
     method: 'POST'
   });
-  return response.json();
+  return checkResponse(response);
 }
 
 export async function fetchScreenshot(platform, serial) {
   const response = await fetch(`${API_HOST}${platform}/${serial}/screenshot`);
-  return response.json();
+  return checkResponse(response);
 }
 
 export async function fetchHierarchy(platform, serial) {
   const response = await fetch(`${API_HOST}${platform}/${serial}/hierarchy`);
-  return response.json();
+  return checkResponse(response);
 }
diff --git a/uiviewer/static/js/index.js b/uiviewer/static/js/index.js
