devhelmkit 0.1.0__py3-none-any.whl

devhelmkit/harmony/finder/__init__.py

@@ -0,0 +1,12 @@
+# !/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""鸿蒙控件查找后端。
+
+子模块：
+- selector_adapter：SelectorSpec → 设备端 On 查询条件转换
+- component_finder：ComponentFinder 统一查找门面
+- popup_handler：弹窗自动消除策略
+
+仅支持 HarmonyOS 5.0.0+（API 12+），设备端 uitest 服务统一使用
+api9+ 命名（Driver/Component/On）。
+"""

devhelmkit/harmony/finder/component_finder.py

@@ -0,0 +1,336 @@
+# !/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""ComponentFinder：鸿蒙控件查找统一门面。
+
+职责：
+- 将 SelectorSpec 转为设备端 By/On 链（通过 selector_adapter + RPC）
+- 调用 Driver.findComponent / Driver.waitForComponent 获取 Component 引用
+- 在 Component 引用上执行操作方法
+- 弹窗自动消除（配置开启时，查找失败自动尝试消除弹窗后重试）
+
+By/On 链构造流程：
+    On#seed (静态根)
+      → On.text("xx", pattern) → By#1
+      → On.id("yy")           → By#2 (this=By#1)
+      → On.within(parent_ref) → By#3 (this=By#2, args=[parent_ref])
+
+关系选择器递归处理：先构造 parent By 链，再在 child By 链末尾
+调用 On.within / On.isAfter / On.isBefore。
+"""
+from typing import Any, Dict, List, Optional, TYPE_CHECKING
+
+from devhelmkit.core.selector_spec import SelectorSpec, build_selector
+from devhelmkit.exceptions import ComponentNotFoundError, RpcError
+from devhelmkit.harmony.finder.selector_adapter import (
+    RELATION_API,
+    selector_to_by_chain,
+)
+from devhelmkit.harmony.finder.xpath_query import query_xpath
+from devhelmkit.harmony.finder.popup_handler import PopupHandler
+from devhelmkit.utils import logger
+
+if TYPE_CHECKING:
+    from devhelmkit.harmony.config import HarmonyDriverConfig
+    from devhelmkit.harmony.rpc.client import RpcClient
+
+# 设备端静态对象引用
+DRIVER_REF = "Driver#0"
+ON_SEED_REF = "On#seed"
+
+# 默认查找超时（秒）
+DEFAULT_FIND_TIMEOUT = 10.0
+
+
+class ComponentFinder:
+    """鸿蒙控件查找门面，统一对接设备端 uitest 服务。"""
+
+    def __init__(self, rpc: 'RpcClient', config: 'HarmonyDriverConfig'):
+        self._rpc = rpc
+        self._config = config
+        self._popup_handler = PopupHandler(
+            self.find_component, rpc, config
+        )
+
+    # ============================================================
+    # 控件查找
+    # ============================================================
+
+    def find_component(self, selector: SelectorSpec,
+                       timeout: float = DEFAULT_FIND_TIMEOUT) -> str:
+        """查找单个控件，返回 Component 对象引用。
+
+        Args:
+            selector: 控件定位条件
+            timeout: 查找超时（秒）
+
+        Returns:
+            设备端 Component 对象引用（如 "Component#3"）
+
+        Raises:
+            ComponentNotFoundError: 控件未找到
+            RpcError: RPC 通信异常
+        """
+        # xpath 选择器走客户端查询：dump 控件树 → 查询节点 → 降级 SelectorSpec → By 链
+        if selector.xpath is not None:
+            return self._find_by_xpath(selector, timeout)
+        by_ref = self._build_by_ref(selector)
+        timeout_ms = int(timeout * 1000)
+        try:
+            result = self._rpc.call(
+                "Driver.waitForComponent", DRIVER_REF, [by_ref, timeout_ms]
+            )
+        except RpcError as e:
+            if self._should_dismiss_popup():
+                logger.debug("控件查找失败，尝试消除弹窗后重试: %s",
+                             _format_selector(selector))
+                if self._popup_handler.dismiss_popups():
+                    result = self._rpc.call(
+                        "Driver.waitForComponent", DRIVER_REF,
+                        [by_ref, timeout_ms]
+                    )
+                else:
+                    raise ComponentNotFoundError(
+                        "控件未找到: %s" % _format_selector(selector)
+                    ) from e
+            else:
+                raise
+        if not result:
+            raise ComponentNotFoundError(
+                "控件未找到: %s" % _format_selector(selector)
+            )
+        return result
+
+    def find_components(self, selector: SelectorSpec) -> list:
+        """查找所有匹配控件，返回 Component 引用列表。
+
+        不等待，立即返回当前匹配结果。
+
+        Args:
+            selector: 控件定位条件
+
+        Returns:
+            Component 对象引用列表（可能为空）
+        """
+        if selector.xpath is not None:
+            return self._find_components_by_xpath(selector)
+        by_ref = self._build_by_ref(selector)
+        result = self._rpc.call("Driver.findComponents", DRIVER_REF, [by_ref])
+        return result if isinstance(result, list) else []
+
+    def component_exists(self, selector: SelectorSpec) -> bool:
+        """检查控件是否存在。
+
+        xpath 选择器直接在控件树上查询，无需构造 By 链。
+        """
+        if selector.xpath is not None:
+            return bool(self._query_xpath_nodes(selector))
+        return bool(self.find_components(selector))
+
+    def wait_component(self, selector: SelectorSpec,
+                       timeout: float) -> bool:
+        """等待控件出现，返回是否出现。"""
+        try:
+            self.find_component(selector, timeout)
+            return True
+        except ComponentNotFoundError:
+            return False
+
+    def wait_component_gone(self, selector: SelectorSpec,
+                            timeout: float) -> bool:
+        """等待控件消失，返回是否消失。"""
+        import time
+        deadline = time.monotonic() + timeout
+        while time.monotonic() < deadline:
+            if not self.component_exists(selector):
+                return True
+            time.sleep(0.5)
+        return not self.component_exists(selector)
+
+    # ============================================================
+    # 控件操作
+    # ============================================================
+
+    def call_component(self, selector: SelectorSpec, method: str,
+                       args: Optional[list] = None,
+                       timeout: float = DEFAULT_FIND_TIMEOUT) -> Any:
+        """查找控件并调用其方法。
+
+        Args:
+            selector: 控件定位条件
+            method: Component 方法名（如 "click"、"getText"）
+            args: 方法参数列表
+            timeout: 查找超时
+
+        Returns:
+            方法返回值
+        """
+        component_ref = self.find_component(selector, timeout)
+        return self._rpc.call("Component." + method, component_ref, args or [])
+
+    def call_component_by_ref(self, component_ref: str, method: str,
+                              args: Optional[list] = None) -> Any:
+        """直接在 Component 引用上调用方法（跳过查找）。
+
+        用于已持有 Component 引用的场景，避免重复查找。
+        """
+        return self._rpc.call("Component." + method, component_ref, args or [])
+
+    # ============================================================
+    # By/On 链构造
+    # ============================================================
+
+    def _build_by_ref(self, selector: SelectorSpec) -> str:
+        """通过 RPC 顺序调用构造 By/On 链，返回 By 对象引用。
+
+        递归处理关系选择器：先构造 parent By 链，再在 child By 链
+        末尾调用 On.within / On.isAfter / On.isBefore。
+        """
+        chain = selector_to_by_chain(selector)
+        by_ref = ON_SEED_REF
+        for api_name, args in chain:
+            by_ref = self._rpc.call(api_name, by_ref, args)
+
+        # 关系选择器：在 child By 链末尾追加关系调用
+        if selector.parent is not None and selector.relation:
+            parent_ref = self._build_by_ref(selector.parent)
+            relation_api = RELATION_API.get(selector.relation)
+            if relation_api is not None:
+                by_ref = self._rpc.call(relation_api, by_ref, [parent_ref])
+            elif selector.relation == 'sibling':
+                # TODO: sibling 无直接对应的 On API，需通过 parent + child 间接实现
+                pass
+
+        return by_ref
+
+    # ============================================================
+    # xpath 客户端查询
+    # 设备端 uitest 不支持 xpath，通过 Captures.captureLayout 获取
+    # 控件树 JSON 后，在客户端执行 xpath 查询，再将匹配节点降级为
+    # SelectorSpec 走正常 By 链，复用 Component 引用机制。
+    # ============================================================
+
+    def _dump_layout(self) -> Optional[Dict[str, Any]]:
+        """通过 uitest RPC (Captures.captureLayout) 获取控件树。
+
+        比 hdc shell dumpLayout 快，无需文件中转。
+        """
+        import json
+        from devhelmkit.harmony.rpc.proxy_v2 import rpc_captures
+
+        reply = rpc_captures(self._rpc.device, "captureLayout", {})
+        try:
+            data = json.loads(reply)
+        except json.JSONDecodeError as e:
+            logger.error("控件树响应解析失败: %s", e)
+            return None
+        if isinstance(data, dict):
+            if data.get('error'):
+                logger.warn("captureLayout 调用失败: %s", data['error'])
+                return None
+            if data.get('exception'):
+                msg = data['exception'].get('message', str(data['exception']))
+                logger.warn("captureLayout 调用异常: %s", msg)
+                return None
+            if 'result' in data:
+                data = data['result']
+        return data if isinstance(data, dict) else None
+
+    def _query_xpath_nodes(self, selector: SelectorSpec) -> List[Dict[str, Any]]:
+        """执行 xpath 查询，返回匹配节点列表。"""
+        if not selector.xpath:
+            return []
+        tree = self._dump_layout()
+        if tree is None:
+            return []
+        return query_xpath(tree, selector.xpath)
+
+    def _node_to_selector(self, node: Dict[str, Any]) -> SelectorSpec:
+        """从控件树节点提取定位条件，构造降级 SelectorSpec。
+
+        优先使用唯一性强的属性：key > resource_id > text > type。
+        """
+        attrs = node.get("attributes") or {}
+        kwargs: Dict[str, Any] = {}
+        # key 唯一性最强
+        key = attrs.get("key")
+        if key:
+            kwargs["key"] = key
+        else:
+            resource_id = attrs.get("id") or attrs.get("resource_id")
+            if resource_id:
+                kwargs["resource_id"] = resource_id
+        # text 辅助定位
+        text = attrs.get("text")
+        if text:
+            kwargs["text"] = text
+        # type 兜底
+        node_type = attrs.get("type")
+        if node_type:
+            kwargs["type"] = node_type
+        return build_selector(**kwargs)
+
+    def _find_by_xpath(self, selector: SelectorSpec,
+                       timeout: float) -> str:
+        """xpath 选择器查找单个控件。
+
+        dump 控件树 → 查询匹配节点 → 取第一个节点降级为 SelectorSpec → By 链。
+        """
+        nodes = self._query_xpath_nodes(selector)
+        if not nodes:
+            raise ComponentNotFoundError(
+                "xpath 未匹配控件: %s" % selector.xpath
+            )
+        degraded = self._node_to_selector(nodes[0])
+        # 递归走正常 By 链（degraded 无 xpath，不会再次进入 xpath 分支）
+        return self.find_component(degraded, timeout)
+
+    def _find_components_by_xpath(self, selector: SelectorSpec) -> list:
+        """xpath 选择器查找所有匹配控件。
+
+        对每个匹配节点降级为 SelectorSpec，按降级条件去重后逐个 findComponents，
+        收集所有 Component 引用。
+        """
+        nodes = self._query_xpath_nodes(selector)
+        refs: list = []
+        seen: set = set()
+        for node in nodes:
+            degraded = self._node_to_selector(node)
+            # 去重：相同降级条件只查一次
+            sig = (degraded.type, degraded.text,
+                   degraded.key, degraded.resource_id)
+            if sig in seen:
+                continue
+            seen.add(sig)
+            by_ref = self._build_by_ref(degraded)
+            result = self._rpc.call(
+                "Driver.findComponents", DRIVER_REF, [by_ref]
+            )
+            if isinstance(result, list):
+                refs.extend(result)
+        return refs
+
+    # ============================================================
+    # 弹窗处理
+    # ============================================================
+
+    def _should_dismiss_popup(self) -> bool:
+        """判断是否启用弹窗自动消除。"""
+        return self._config.pop_window_dismiss == "enable"
+
+
+def _format_selector(selector: SelectorSpec) -> str:
+    """格式化选择器为可读字符串，用于异常信息。"""
+    parts = []
+    if selector.text is not None:
+        parts.append("text=%r" % selector.text)
+    if selector.text_contains is not None:
+        parts.append("textContains=%r" % selector.text_contains)
+    if selector.resource_id is not None:
+        parts.append("resourceId=%r" % selector.resource_id)
+    if selector.key is not None:
+        parts.append("key=%r" % selector.key)
+    if selector.class_name is not None:
+        parts.append("className=%r" % selector.class_name)
+    if selector.xpath is not None:
+        parts.append("xpath=%r" % selector.xpath)
+    return ", ".join(parts) if parts else str(selector)

devhelmkit/harmony/finder/popup_handler.py

@@ -0,0 +1,81 @@
+# !/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""弹窗自动消除策略。
+
+在控件查找失败时，自动检测并消除常见系统弹窗（权限请求、更新提示、
+广告弹窗等），消除后重试查找。
+
+弹窗消除策略：遍历常见确认类按钮文本，查找并点击存在的弹窗按钮。
+仅点击确认类按钮（允许/确定/知道了），不点击取消类按钮。
+
+PopupHandler 不直接依赖 ComponentFinder，通过注入的 find_component
+回调查找弹窗按钮，避免循环依赖。
+"""
+from typing import Callable, TYPE_CHECKING
+
+from devhelmkit.core.selector_spec import SelectorSpec, build_selector
+from devhelmkit.exceptions import ComponentNotFoundError, RpcError
+from devhelmkit.utils import logger
+
+if TYPE_CHECKING:
+    from devhelmkit.harmony.config import HarmonyDriverConfig
+    from devhelmkit.harmony.rpc.client import RpcClient
+
+# 常见弹窗确认类按钮文本（按优先级排序）
+_POPUP_DISMISS_TEXTS = [
+    "允许",
+    "仅在使用中允许",
+    "始终允许",
+    "确定",
+    "我知道了",
+    "知道了",
+    "同意",
+    "继续",
+    "关闭",
+    "跳过",
+]
+
+
+class PopupHandler:
+    """弹窗自动消除处理器。
+
+    通过注入的 find_component 回调查找弹窗按钮，找到后通过 RPC
+    调用 Component.click 点击消除。
+    """
+
+    def __init__(self, find_component: Callable[[SelectorSpec, float], str],
+                 rpc: 'RpcClient', config: 'HarmonyDriverConfig'):
+        self._find_component = find_component
+        self._rpc = rpc
+        self._config = config
+
+    def dismiss_popups(self) -> bool:
+        """检测并消除弹窗，返回是否处理了弹窗。
+
+        遍历常见弹窗按钮文本，查找并点击存在的按钮。
+        最多处理 pop_window_handle_times 个弹窗。
+        """
+        handled = False
+        max_times = self._config.pop_window_handle_times
+        for _ in range(max_times):
+            if not self._dismiss_one_popup():
+                break
+            handled = True
+        return handled
+
+    def _dismiss_one_popup(self) -> bool:
+        """消除单个弹窗，返回是否找到并处理了弹窗。"""
+        for text in _POPUP_DISMISS_TEXTS:
+            try:
+                component_ref = self._find_component(
+                    build_selector(text=text), 1.0
+                )
+                self._rpc.call("Component.click", component_ref, [])
+                logger.info("已消除弹窗: %s", text)
+                return True
+            except ComponentNotFoundError:
+                continue
+            except RpcError as e:
+                logger.warn("消除弹窗时 RPC 异常: %s", e)
+                continue
+        return False

devhelmkit/harmony/finder/selector_adapter.py

@@ -0,0 +1,101 @@
+# !/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""SelectorSpec → 设备端 On 查询条件转换。
+
+将跨平台纯数据 SelectorSpec 转为设备端 By/On 链构造计划。
+本模块只做纯数据转换，不执行 RPC 调用，不依赖 RpcClient。
+
+By/On 链构造顺序：
+1. 从静态根 On#seed 开始
+2. 按 selector_to_by_chain 返回的 [(api_name, args), ...] 顺序 RPC 调用
+3. 每次调用返回新的 By 对象引用，作为下一次调用的 this
+
+关系选择器（parent/relation）不在本模块处理，由 ComponentFinder
+在构造 By 链时递归处理 parent 后调用 On.within / On.isAfter / On.isBefore。
+"""
+from typing import List, Tuple
+
+from devhelmkit.core.selector_spec import SelectorSpec
+from devhelmkit.model.match_pattern import MatchPattern
+
+
+def selector_to_by_chain(selector: SelectorSpec) -> List[Tuple[str, list]]:
+    """将叶子选择器转为 By/On 链构造计划。
+
+    不处理关系选择器（parent/relation），仅转换定位条件。
+
+    Args:
+        selector: 控件定位条件
+
+    Returns:
+        [(api_name, args), ...]，按顺序 RPC 调用构造 By 链。
+        api_name 为 api9+ 风格（On.text / On.id / On.type / On.description）。
+        空列表表示无定位条件（匹配所有控件）。
+    """
+    chain: List[Tuple[str, list]] = []
+
+    _append_text_chain(chain, selector)
+    _append_desc_chain(chain, selector)
+    _append_id_chain(chain, selector)
+    _append_type_chain(chain, selector)
+
+    return chain
+
+
+def _append_text_chain(chain: List[Tuple[str, list]],
+                       selector: SelectorSpec) -> None:
+    """文本匹配条件，同组互斥，按优先级取第一个非空字段。"""
+    if selector.text is not None:
+        chain.append(("On.text", [selector.text, int(MatchPattern.EQUALS)]))
+    elif selector.text_contains is not None:
+        chain.append(("On.text", [selector.text_contains, int(MatchPattern.CONTAINS)]))
+    elif selector.text_starts_with is not None:
+        chain.append(("On.text", [selector.text_starts_with, int(MatchPattern.STARTS_WITH)]))
+    elif selector.text_ends_with is not None:
+        chain.append(("On.text", [selector.text_ends_with, int(MatchPattern.ENDS_WITH)]))
+    elif selector.text_matches is not None:
+        chain.append(("On.text", [selector.text_matches, int(MatchPattern.REGEXP)]))
+
+
+def _append_desc_chain(chain: List[Tuple[str, list]],
+                       selector: SelectorSpec) -> None:
+    """描述匹配条件，同组互斥。"""
+    if selector.desc is not None:
+        chain.append(("On.description", [selector.desc, int(MatchPattern.EQUALS)]))
+    elif selector.desc_contains is not None:
+        chain.append(("On.description", [selector.desc_contains, int(MatchPattern.CONTAINS)]))
+    elif selector.desc_starts_with is not None:
+        chain.append(("On.description", [selector.desc_starts_with, int(MatchPattern.STARTS_WITH)]))
+    elif selector.desc_ends_with is not None:
+        chain.append(("On.description", [selector.desc_ends_with, int(MatchPattern.ENDS_WITH)]))
+    elif selector.desc_matches is not None:
+        chain.append(("On.description", [selector.desc_matches, int(MatchPattern.REGEXP)]))
+
+
+def _append_id_chain(chain: List[Tuple[str, list]],
+                     selector: SelectorSpec) -> None:
+    """ID/Key 定位，key 优先于 resource_id。
+
+    API 12+ 中 By.key 和 By.id 统一映射到 On.id。
+    """
+    if selector.key is not None:
+        chain.append(("On.id", [selector.key]))
+    elif selector.resource_id is not None:
+        chain.append(("On.id", [selector.resource_id]))
+
+
+def _append_type_chain(chain: List[Tuple[str, list]],
+                       selector: SelectorSpec) -> None:
+    """类型定位，class_name 优先于 type。"""
+    if selector.class_name is not None:
+        chain.append(("On.type", [selector.class_name]))
+    elif selector.type is not None:
+        chain.append(("On.type", [selector.type]))
+
+
+# 关系选择器 → 设备端 On API 映射
+RELATION_API = {
+    'child': 'On.within',
+    'after': 'On.isAfter',
+    'before': 'On.isBefore',
+}

devhelmkit/harmony/finder/xpath_query.py

@@ -0,0 +1,110 @@
+# !/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""XPath 查询引擎：在控件树 JSON 上执行 xpath 查询。
+
+设备端 uitest 不支持 xpath，通过 dumpLayout 获取控件树后，
+在客户端实现 xpath 查询。
+
+支持的 xpath 语法（子集）：
+    //TagName               查找所有指定类型的后代节点
+    //*                     查找所有节点
+    //TagName[@attr="val"]  属性等于
+    //TagName[contains(@attr, "val")]  属性包含
+    //TagName[@a="v1" and @b="v2"]     多属性 AND 匹配
+
+控件树节点结构：
+    {
+        "attributes": {"type": "Text", "text": "设置", ...},
+        "children": [...]
+    }
+"""
+import re
+from typing import Any, Dict, List, Optional
+
+# xpath 主模式：//Tag[predicate?]
+_XPATH_RE = re.compile(r'^//(\w+|\*)(?:\[(.+)\])?$')
+
+# 属性等于：@attr="value"
+_ATTR_EQ_RE = re.compile(r'@(\w+)\s*=\s*"([^"]*)"')
+
+# 属性包含：contains(@attr, "value")
+_ATTR_CONTAINS_RE = re.compile(r'contains\s*\(\s*@(\w+)\s*,\s*"([^"]*)"\s*\)')
+
+
+def parse_xpath(xpath: str) -> Optional[Dict[str, Any]]:
+    """解析 xpath 表达式，返回查询计划。
+
+    Returns:
+        {"tag": str, "conditions": [{"attr": str, "op": str, "value": str}]}
+        解析失败返回 None。
+    """
+    match = _XPATH_RE.match(xpath.strip())
+    if not match:
+        return None
+    tag = match.group(1)
+    predicate = match.group(2)
+    conditions = []
+    if predicate:
+        # 按 " and " 分割多条件
+        parts = re.split(r'\s+and\s+', predicate)
+        for part in parts:
+            part = part.strip()
+            m = _ATTR_CONTAINS_RE.match(part)
+            if m:
+                conditions.append({
+                    "attr": m.group(1), "op": "contains", "value": m.group(2)
+                })
+                continue
+            m = _ATTR_EQ_RE.match(part)
+            if m:
+                conditions.append({
+                    "attr": m.group(1), "op": "equals", "value": m.group(2)
+                })
+                continue
+            return None
+    return {"tag": tag, "conditions": conditions}
+
+
+def query_xpath(tree: Dict[str, Any], xpath: str) -> List[Dict[str, Any]]:
+    """在控件树上执行 xpath 查询，返回匹配的节点列表。"""
+    plan = parse_xpath(xpath)
+    if plan is None:
+        return []
+    results: List[Dict[str, Any]] = []
+    _traverse(tree, plan, results)
+    return results
+
+
+def _traverse(node: Dict[str, Any], plan: Dict[str, Any],
+              results: List[Dict[str, Any]]) -> None:
+    """深度优先遍历控件树，收集匹配节点。"""
+    attrs = node.get("attributes") or {}
+    tag = plan["tag"]
+    node_type = attrs.get("type", "")
+
+    # tag 匹配（* 匹配任意）
+    tag_matched = (tag == "*" or node_type == tag)
+    if tag_matched and _match_conditions(attrs, plan["conditions"]):
+        results.append(node)
+
+    for child in node.get("children") or []:
+        _traverse(child, plan, results)
+
+
+def _match_conditions(attrs: Dict[str, Any],
+                      conditions: List[Dict[str, Any]]) -> bool:
+    """检查节点属性是否满足全部条件。"""
+    for cond in conditions:
+        attr_name = cond["attr"]
+        expected = cond["value"]
+        actual = attrs.get(attr_name)
+        if actual is None:
+            return False
+        actual_str = str(actual) if not isinstance(actual, bool) else str(actual).lower()
+        if cond["op"] == "equals":
+            if actual_str != expected:
+                return False
+        elif cond["op"] == "contains":
+            if expected not in actual_str:
+                return False
+    return True

devhelmkit/harmony/rpc/__init__.py

@@ -0,0 +1,12 @@
+# !/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""鸿蒙 RPC 协议与远程对象管理。
+
+子模块：
+- proxy_v2：bin 模式 RPC 传输
+- remote_object：远程对象生命周期管理
+- client：RPC 客户端，设备端 API 调用与返回值处理
+
+仅支持 HarmonyOS 5.0.0+（API 12+），设备端 uitest 服务统一使用
+api9+ 命名（Driver/Component/On），不再兼容 api8 旧命名。
+"""