uiautodev 0.11.0__tar.gz → 0.11.1__tar.gz

{uiautodev-0.11.0 → uiautodev-0.11.1}/PKG-INFO

@@ -1,8 +1,9 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: uiautodev
-Version: 0.11.0
+Version: 0.11.1
 Summary: Mobile UI Automation, include UI hierarchy inspector, script recorder
 License: MIT
+License-File: LICENSE
 Author: codeskyblue
 Author-email: codeskyblue@gmail.com
 Requires-Python: >=3.8,<4.0
@@ -14,6 +15,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: Pillow
 Requires-Dist: adbutils (>=2.8.10,<3)
 Requires-Dist: click (>=8.1.7,<9.0.0)

{uiautodev-0.11.0 → uiautodev-0.11.1}/pyproject.toml

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

{uiautodev-0.11.0 → uiautodev-0.11.1}/uiautodev/__init__.py

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

{uiautodev-0.11.0 → uiautodev-0.11.1}/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
+from typing import List, Optional, Tuple, Union, final, Dict
 
 from PIL import Image
 
@@ -31,6 +31,7 @@ def run_command(command: str, timeout: int = 60) -> str:
             capture_output=True,
             timeout=timeout,
             text=True,
+            errors='ignore',
             input='' # this avoid stdout: "FreeChannelContinue handle->data is nullptr"
         )
         # the hdc shell stderr is (不仅没啥用，还没办法去掉)
@@ -50,10 +51,10 @@ class HDC:
     def __init__(self):
         self.hdc = 'hdc'
         self.tmpdir = tempfile.TemporaryDirectory()
-    
+
     def __del__(self):
         self.tmpdir.cleanup()
-    
+
     def list_device(self) -> List[str]:
         command = f"{self.hdc} list targets"
         result = run_command(command)
@@ -65,15 +66,48 @@ class HDC:
             return devices
         else:
             return []
-    
+
     def shell(self, serial: str, command: str) -> str:
         command = f"{self.hdc} -t {serial} shell \"{command}\""
         result = run_command(command)
         return result.strip()
-    
+
+    def __split_text(self, text: str) -> str:
+        return text.split("\n")[0].strip() if text else ""
+
     def get_model(self, serial: str) -> str:
         return self.shell(serial, "param get const.product.model")
-    
+
+    def get_name(self, serial: str) -> str:
+        data = self.shell(serial, "param get const.product.name")
+        return self.__split_text(data)
+
+    def wlan_ip(self, serial: str) -> str:
+        data = self.shell(serial, "ifconfig")
+        if not data or "not found" in data.lower() or "error" in data.lower():
+            logger.warning(f"ifconfig command failed or returned error for serial {serial}: {data!r}")
+            return ""
+        # Try multiple patterns for IP address
+        matches = re.findall(r'inet addr:(?!127)(\d+\.\d+\.\d+\.\d+)', data)
+        if not matches:
+            matches = re.findall(r'inet (?!127)(\d+\.\d+\.\d+\.\d+)', data)
+        if matches:
+            return matches[0]
+        logger.warning(f"No valid IP address found in ifconfig output for serial {serial}: {data!r}")
+        return ""
+
+    def sdk_version(self, serial: str) -> str:
+        data = self.shell(serial, "param get const.ohos.apiversion")
+        return self.__split_text(data)
+
+    def sys_version(self, serial: str) -> str:
+        data = self.shell(serial, "param get const.product.software.version")
+        return self.__split_text(data)
+
+    def brand(self, serial: str) -> str:
+        data = self.shell(serial, "param get const.product.brand")
+        return self.__split_text(data)
+
     def pull(self, serial: str, remote: StrOrPath, local: StrOrPath):
         if isinstance(remote, Path):
             remote = remote.as_posix()
@@ -81,13 +115,13 @@ class HDC:
         output = run_command(command)
         if not os.path.exists(local):
             raise HDCError(f"device file: {remote} not found", output)
-    
+
     def push(self, serial: str, local: StrOrPath, remote: StrOrPath) -> str:
         if isinstance(remote, Path):
             remote = remote.as_posix()
         command = f"{self.hdc} -t {serial} file send {local} {remote}"
         return run_command(command)
-    
+
     def screenshot(self, serial: str) -> Image.Image:
         device_path = f'/data/local/tmp/screenshot-{int(time.time()*1000)}.png'
         self.shell(serial, f"uitest screenCap -p {device_path}")
@@ -116,7 +150,7 @@ class HDC:
             raise HDCError(f"failed to dump layout: {output}")
         finally:
             self.shell(serial, f"rm {remote_path}")
-    
+
 
 class HarmonyDriver(BaseDriver):
     def __init__(self, hdc: HDC, serial: str):
@@ -164,6 +198,112 @@ class HarmonyDriver(BaseDriver):
         else:
             return None
 
+    def get_app_info(self, package_name: str) -> Dict:
+        """
+        Get detailed information about a specific application.
+
+        Args:
+            package_name (str): The package name of the application to retrieve information for.
+
+        Returns:
+            Dict: A dictionary containing the application information. If an error occurs during parsing,
+                  an empty dictionary is returned.
+        """
+        app_info = {}
+        data = self.hdc.shell(self.serial, f"bm dump -n {package_name}")
+        output = data
+        try:
+            json_start = output.find("{")
+            json_end = output.rfind("}") + 1
+            json_output = output[json_start:json_end]
+
+            app_info = json.loads(json_output)
+        except Exception as e:
+            logger.error(f"An error occurred: {e}")
+        return app_info
+
+    def get_app_abilities(self, package_name: str) -> List[Dict]:
+        """
+        Get the abilities of an application.
+
+        Args:
+            package_name (str): The package name of the application.
+
+        Returns:
+            List[Dict]: A list of dictionaries containing the abilities of the application.
+        """
+        result = []
+        app_info = self.get_app_info(package_name)
+        hap_module_infos = app_info.get("hapModuleInfos")
+        main_entry = app_info.get("mainEntry")
+        for hap_module_info in hap_module_infos:
+            # 尝试读取moduleInfo
+            try:
+                ability_infos = hap_module_info.get("abilityInfos")
+                module_main = hap_module_info["mainAbility"]
+            except Exception as e:
+                logger.warning(f"Fail to parse moduleInfo item, {repr(e)}")
+                continue
+            # 尝试读取abilityInfo
+            for ability_info in ability_infos:
+                try:
+                    is_launcher_ability = False
+                    skills = ability_info['skills']
+                    if len(skills) > 0 and "action.system.home" in skills[0]["actions"]:
+                        is_launcher_ability = True
+                    icon_ability_info = {
+                        "name": ability_info["name"],
+                        "moduleName": ability_info["moduleName"],
+                        "moduleMainAbility": module_main,
+                        "mainModule": main_entry,
+                        "isLauncherAbility": is_launcher_ability
+                    }
+                    result.append(icon_ability_info)
+                except Exception as e:
+                    logger.warning(f"Fail to parse ability_info item, {repr(e)}")
+                    continue
+        logger.debug(f"all abilities: {result}")
+        return result
+
+    def get_app_main_ability(self, package_name: str) -> Dict:
+        """
+        Get the main ability of an application.
+
+        Args:
+            package_name (str): The package name of the application to retrieve information for.
+
+        Returns:
+            Dict: A dictionary containing the main ability of the application.
+
+        """
+        if not (abilities := self.get_app_abilities(package_name)):
+            return {}
+        for item in abilities:
+            score = 0
+            if (name := item["name"]) and name == item["moduleMainAbility"]:
+                score += 1
+            if (module_name := item["moduleName"]) and module_name == item["mainModule"]:
+                score += 1
+            item["score"] = score
+        abilities.sort(key=lambda x: (not x["isLauncherAbility"], -x["score"]))
+        logger.debug(f"main ability: {abilities[0]}")
+        return abilities[0]
+
+    def app_launch(self, package: str, page_name: Optional[str] = None):
+        """
+        Start an application on the device.
+        If the `page_name` is empty, it will retrieve the main ability using `get_app_main_ability`.
+        Args:
+            package (str): The package name of the application.
+            page_name (Optional[str]): Ability Name within the application to start. If not provided, the main ability will be used.
+        """
+        if not page_name:
+            page_name = self.get_app_main_ability(package).get('name', 'MainAbility')
+        self.shell(f"aa start -a {page_name} -b {package}")
+
+    def app_terminate(self, package: str):
+        self.shell(f"aa force-stop {package}")
+
     def shell(self, command: str) -> ShellResponse:
         result = self.hdc.shell(self.serial, command)
         return ShellResponse(output=result)

{uiautodev-0.11.0 → uiautodev-0.11.1}/uiautodev/model.py

@@ -14,6 +14,7 @@ from pydantic import BaseModel
 class DeviceInfo(BaseModel):
     serial: str
     model: str = ""
+    product: str = ""
     name: str = ""
     status: str = ""
     enabled: bool = True

{uiautodev-0.11.0 → uiautodev-0.11.1}/uiautodev/provider.py

@@ -46,12 +46,18 @@ class AndroidProvider(BaseProvider):
     def list_devices(self) -> list[DeviceInfo]:
         adb = adbutils.AdbClient()
         ret: list[DeviceInfo] = []
-        for d in adb.list():
+        for d in adb.list(extended=True):
             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))
+                ret.append(DeviceInfo(
+                    serial=d.serial,
+                    status=d.state,
+                    name=d.tags.get('device', ''),
+                    model=d.tags.get('model', ''),
+                    product=d.tags.get('product', ''),
+                    enabled=True
+                ))
         return ret
 
     @lru_cache
@@ -76,7 +82,7 @@ class HarmonyProvider(BaseProvider):
 
     def list_devices(self) -> list[DeviceInfo]:
         devices = self.hdc.list_device()
-        return [DeviceInfo(serial=d, model=self.hdc.get_model(d), name=self.hdc.get_model(d)) for d in devices]
+        return [DeviceInfo(serial=d, model=self.hdc.get_model(d), name=self.hdc.get_name(d)) for d in devices]
 
     @lru_cache
     def get_device_driver(self, serial: str) -> HarmonyDriver: