xiaoli-cli/android_compat.py

"""
Android API → Python 跨平台兼容层
====================================
将 Android 特有的 Java/Kotlin API 全面翻译为 Python 实现，
使 Operit 脚本可无需修改地在 Windows/macOS/Linux 上运行。

覆盖的 Android API 领域:
  - android.content (Intent, Context, ContentResolver, ContentValues)
  - android.net (Uri)
  - android.os (Environment, Build, PowerManager, VibrationEffect)
  - android.app (ActivityManager, NotificationManager, AlarmManager)
  - android.graphics (Bitmap, Canvas, Color, Paint, Rect)
  - android.graphics.pdf (PdfRenderer)
  - android.provider (Settings, MediaStore, ContactsContract, CalendarContract)
  - android.view (View, ViewGroup, accessibility/UIAutomation)
  - android.bluetooth (BluetoothAdapter, BLE)
  - android.location (LocationManager, Geocoder)
  - android.telephony (TelephonyManager)
  - android.hardware (Camera, SensorManager)
  - android.media (MediaPlayer, AudioRecord, TtsEngine)
  - android.widget (Toast)
  - android.print (PrintManager)
  - android.accounts (AccountManager)
  - android.hardware.display (DisplayManager)
  - java.io (File, FileInputStream/OutputStream, BufferedReader)
  - android.hardware.biometrics (BiometricPrompt)
"""

import os
import sys
import re
import io
import json
import time
import math
import random
import base64
import hashlib
import struct
import shutil
import tempfile
import subprocess
import platform
import webbrowser
import urllib.parse
import urllib.request
import socket
import xml.etree.ElementTree as ET
from pathlib import Path
from datetime import datetime, timedelta
from typing import Any, Dict, List, Optional, Tuple, Union, Callable
from collections import OrderedDict

try:
    from PIL import Image, ImageDraw, ImageFont, ImageFilter, ImageChops
    HAS_PIL = True
except ImportError:
    HAS_PIL = False

try:
    import psutil
    HAS_PSUTIL = True
except ImportError:
    HAS_PSUTIL = False

try:
    import requests
    HAS_REQUESTS = True
except ImportError:
    HAS_REQUESTS = False

try:
    import pyautogui
    HAS_PYAUTOGUI = True
except ImportError:
    HAS_PYAUTOGUI = False

try:
    import screeninfo
    HAS_SCREENINFO = True
except ImportError:
    HAS_SCREENINFO = False

# ============================================================
#  GLOBAL STATE - 模拟 Android Application 上下文
# ============================================================

_sdcard_root = os.path.join(os.path.expanduser("~"), "Android-compat", "sdcard")
_app_data_dir = os.path.join(os.path.expanduser("~"), "Android-compat", "app-data")
_download_dir = os.path.join(os.path.expanduser("~"), "Downloads")
_package_name = "com.ai.assistance.operit"
_app_version = "1.0.0"

def _ensure_sdcard():
    """确保模拟的 sdcard 目录结构存在"""
    for d in [_sdcard_root, os.path.join(_sdcard_root, "Download"),
              os.path.join(_sdcard_root, "DCIM"), os.path.join(_sdcard_root, "DCIM", "Screenshots"),
              os.path.join(_sdcard_root, "Android", "data"),
              os.path.join(_sdcard_root, "Android", "data", _package_name, "files"),
              os.path.join(_sdcard_root, "Android", "data", _package_name, "files", "packages"),
              os.path.join(_sdcard_root, "Android", "data", _package_name, "js_temp"),
              _app_data_dir]:
        os.makedirs(d, exist_ok=True)

_ensure_sdcard()


# ============================================================
#  android.net.Uri
# ============================================================

class Uri:
    """模拟 android.net.Uri"""

    @staticmethod
    def parse(uri_string: str) -> "Uri":
        return Uri(uri_string)

    @staticmethod
    def fromFile(path: str) -> "Uri":
        return Uri(f"file://{path}")

    @staticmethod
    def withAppendedPath(base: "Uri", segment: str) -> "Uri":
        return Uri(f"{base._uri}/{segment}")

    def __init__(self, uri_string: str):
        self._uri = uri_string
        self._parsed = urllib.parse.urlparse(uri_string)

    def getScheme(self) -> str:
        """content, file, http, https"""
        return self._parsed.scheme or ""

    def getPath(self) -> str:
        p = self._parsed.path
        if p.startswith("/sdcard"):
            return _sdcard_root + p
        return p

    def getLastPathSegment(self) -> str:
        return os.path.basename(self._parsed.path) or ""

    def toString(self) -> str:
        return self._uri

    def __str__(self):
        return self._uri


# ============================================================
#  android.content.ContentValues
# ============================================================

class ContentValues:
    """模拟 android.content.ContentValues"""

    def __init__(self):
        self._values: Dict[str, Any] = {}

    def put(self, key: str, value: Any) -> None:
        self._values[key] = value

    def get(self, key: str) -> Any:
        return self._values.get(key)

    def getAsString(self, key: str) -> Optional[str]:
        v = self._values.get(key)
        return str(v) if v is not None else None

    def getAsLong(self, key: str) -> Optional[int]:
        v = self._values.get(key)
        return int(v) if v is not None else None

    def remove(self, key: str) -> None:
        self._values.pop(key, None)

    def containsKey(self, key: str) -> bool:
        return key in self._values

    def valueSet(self) -> Dict[str, Any]:
        return dict(self._values)

    def size(self) -> int:
        return len(self._values)

    def clear(self) -> None:
        self._values.clear()


# ============================================================
#  android.content.ContentResolver
# ============================================================

class ContentResolver:
    """模拟 android.content.ContentResolver"""

    def __init__(self, context: "Context" = None):
        self._context = context

    def query(self, uri: Uri, projection: List[str] = None,
              selection: str = None, selectionArgs: List[str] = None,
              sortOrder: str = None) -> "Cursor":
        """模拟 ContentResolver.query - 有限实现"""
        cursor = Cursor()
        scheme = uri.getScheme()

        # file:// URI → 读文件
        if scheme == "file":
            path = uri.getPath()
            if os.path.isfile(path):
                try:
                    with open(path, "r", encoding="utf-8") as f:
                        cursor._data = [{"_data": path, "_size": os.path.getsize(path)}]
                except Exception:
                    pass

        # content:// URI → 模拟
        path = uri._parsed.path
        if "calendar" in path:
            cursor._data = [{
                "_id": "1", "title": "Calendar Event",
                "dtstart": str(int(time.time()) * 1000),
                "dtend": str(int(time.time() + 3600) * 1000)
            }]
        elif "contacts" in path:
            cursor._data = [{"_id": "1", "display_name": "Test Contact", "has_phone_number": "1"}]
        elif "media" in path or "images" in path or "downloads" in path:
            cursor._data = self._scan_media()
        elif "settings" in path:
            cursor._data = [{"name": "default", "value": ""}]

        return cursor

    def _scan_media(self) -> List[Dict]:
        """扫描本地文件系统中的媒体文件"""
        results = []
        media_dirs = [
            os.path.expanduser("~/Pictures"),
            os.path.expanduser("~/Downloads"),
            os.path.join(_sdcard_root, "DCIM"),
            os.path.join(_sdcard_root, "Download"),
        ]
        for d in media_dirs:
            if not os.path.isdir(d):
                continue
            for root, dirs, files in os.walk(d):
                for f in files[:50]:  # limit
                    ext = os.path.splitext(f)[1].lower()
                    if ext in (".jpg", ".jpeg", ".png", ".gif", ".mp4", ".mp3"):
                        results.append({
                            "_data": os.path.join(root, f),
                            "_size": os.path.getsize(os.path.join(root, f)),
                            "title": os.path.splitext(f)[0],
                            "mime_type": f"image/{ext[1:]}" if ext in (".jpg", ".jpeg", ".png") else "video/mp4"
                        })
        return results

    def insert(self, uri: Uri, values: ContentValues) -> Uri:
        """模拟插入"""
        return Uri(f"content://media/external/images/media/{int(time.time())}")

    def update(self, uri: Uri, values: ContentValues, where: str = None,
               selectionArgs: List[str] = None) -> int:
        """模拟更新"""
        return 1

    def delete(self, uri: Uri, where: str = None, selectionArgs: List[str] = None) -> int:
        return 0

    def openInputStream(self, uri: Uri) -> io.BytesIO:
        path = uri.getPath()
        if os.path.isfile(path):
            with open(path, "rb") as f:
                return io.BytesIO(f.read())
        return io.BytesIO()

    def openOutputStream(self, uri: Uri) -> io.BytesIO:
        return io.BytesIO()

    def getType(self, uri: Uri) -> str:
        path = uri.getPath()
        ext = os.path.splitext(path)[1].lower()
        if ext == ".jpg" or ext == ".jpeg": return "image/jpeg"
        if ext == ".png": return "image/png"
        if ext == ".mp4": return "video/mp4"
        if ext == ".mp3": return "audio/mpeg"
        return "application/octet-stream"


class Cursor:
    """模拟 android.database.Cursor"""

    def __init__(self):
        self._data: List[Dict] = []
        self._pos = -1

    def moveToFirst(self) -> bool:
        if self._data:
            self._pos = 0
            return True
        return False

    def moveToNext(self) -> bool:
        if self._pos + 1 < len(self._data):
            self._pos += 1
            return True
        return False

    def moveToPosition(self, pos: int) -> bool:
        if 0 <= pos < len(self._data):
            self._pos = pos
            return True
        return False

    def getCount(self) -> int:
        return len(self._data)

    def getColumnIndex(self, columnName: str) -> int:
        if self._pos >= 0 and self._pos < len(self._data):
            keys = list(self._data[self._pos].keys())
            return keys.index(columnName) if columnName in keys else -1
        return -1

    def getString(self, columnIndex: int) -> Optional[str]:
        if self._pos >= 0 and self._pos < len(self._data):
            keys = list(self._data[self._pos].keys())
            if 0 <= columnIndex < len(keys):
                return str(self._data[self._pos].get(keys[columnIndex], ""))
        return None

    def getInt(self, columnIndex: int) -> int:
        val = self.getString(columnIndex)
        return int(val) if val else 0

    def getLong(self, columnIndex: int) -> int:
        return self.getInt(columnIndex)

    def close(self) -> None:
        self._data = []

    def isClosed(self) -> bool:
        return len(self._data) == 0

    def getPosition(self) -> int:
        return self._pos

    def __iter__(self):
        for item in self._data:
            yield item


# ============================================================
#  android.content.Intent
# ============================================================

class IntentAction:
    """常用 Intent Action 常量"""
    ACTION_MAIN = "android.intent.action.MAIN"
    ACTION_VIEW = "android.intent.action.VIEW"
    ACTION_SEND = "android.intent.action.SEND"
    ACTION_SENDTO = "android.intent.action.SENDTO"
    ACTION_DIAL = "android.intent.action.DIAL"
    ACTION_CALL = "android.intent.action.CALL"
    ACTION_CALL_EMERGENCY = "android.intent.action.CALL_EMERGENCY"
    ACTION_INSERT = "android.intent.action.INSERT"
    ACTION_EDIT = "android.intent.action.EDIT"
    ACTION_DELETE = "android.intent.action.DELETE"
    ACTION_WEB_SEARCH = "android.intent.action.WEB_SEARCH"
    ACTION_SET_ALARM = "android.intent.action.SET_ALARM"
    ACTION_IMAGE_CAPTURE = "android.media.action.IMAGE_CAPTURE"
    ACTION_VIDEO_CAPTURE = "android.media.action.VIDEO_CAPTURE"
    ACTION_BATTERY_LOW = "android.intent.action.BATTERY_LOW"
    ACTION_BOOT_COMPLETED = "android.intent.action.BOOT_COMPLETED"
    ACTION_PICK = "android.intent.action.PICK"
    ACTION_GET_CONTENT = "android.intent.action.GET_CONTENT"
    ACTION_OPEN_DOCUMENT = "android.intent.action.OPEN_DOCUMENT"
    ACTION_CREATE_DOCUMENT = "android.intent.action.CREATE_DOCUMENT"
    ACTION_PACKAGE_ADDED = "android.intent.action.PACKAGE_ADDED"
    ACTION_POWER_CONNECTED = "android.intent.action.POWER_CONNECTED"
    ACTION_POWER_DISCONNECTED = "android.intent.action.POWER_DISCONNECTED"
    ACTION_SCREEN_ON = "android.intent.action.SCREEN_ON"
    ACTION_SCREEN_OFF = "android.intent.action.SCREEN_OFF"
    ACTION_TIME_TICK = "android.intent.action.TIME_TICK"
    ACTION_USER_PRESENT = "android.intent.action.USER_PRESENT"


class Intent:
    """模拟 android.content.Intent - 桌面端映射到 webbrowser+subprocess"""

    CATEGORY_DEFAULT = "android.intent.category.DEFAULT"
    FLAG_ACTIVITY_NEW_TASK = 0x10000000
    FLAG_ACTIVITY_CLEAR_TOP = 0x04000000
    FLAG_GRANT_READ_URI_PERMISSION = 0x00000001

    def __init__(self, action_or_params=None, uri_or_params=None):
        self._action = ""
        self._data: Optional[Uri] = None
        self._type = ""
        self._flags = 0
        self._categories: List[str] = []
        self._extras: Dict[str, Any] = {}
        self._component: Optional[tuple] = None
        self._package: Optional[str] = None

        if isinstance(action_or_params, str):
            self._action = action_or_params
        elif isinstance(action_or_params, dict):
            self._from_dict(action_or_params)

        if isinstance(uri_or_params, str):
            self._data = Uri.parse(uri_or_params)
        elif isinstance(uri_or_params, Uri):
            self._data = uri_or_params

    def _from_dict(self, params: dict):
        self._action = params.get("action", params.get("intentAction", ""))
        d = params.get("data", params.get("uri", params.get("uriString", "")))
        if d:
            self._data = Uri.parse(d) if isinstance(d, str) else d
        self._type = params.get("type", "")
        self._extras = params.get("extras", {})

    def setAction(self, action: str) -> "Intent":
        self._action = action
        return self

    def setData(self, data: str) -> "Intent":
        self._data = Uri.parse(data)
        return self

    def setType(self, type_: str) -> "Intent":
        self._type = type_
        return self

    def setDataAndType(self, data: str, type_: str) -> "Intent":
        self._data = Uri.parse(data)
        self._type = type_
        return self

    def putExtra(self, name: str, value: Any) -> "Intent":
        self._extras[name] = value
        return self

    def getStringExtra(self, name: str) -> Optional[str]:
        v = self._extras.get(name)
        return str(v) if v is not None else None

    def getIntExtra(self, name: str, default: int = 0) -> int:
        return int(self._extras.get(name, default))

    def getBooleanExtra(self, name: str, default: bool = False) -> bool:
        return bool(self._extras.get(name, default))

    def getLongExtra(self, name: str, default: int = 0) -> int:
        return int(self._extras.get(name, default))

    def getStringArrayListExtra(self, name: str) -> List[str]:
        val = self._extras.get(name, [])
        return [str(v) for v in val] if isinstance(val, list) else []

    def addCategory(self, category: str) -> "Intent":
        if category not in self._categories:
            self._categories.append(category)
        return self

    def setFlags(self, flags: int) -> "Intent":
        self._flags = flags
        return self

    def addFlags(self, flags: int) -> "Intent":
        self._flags |= flags
        return self

    def setComponent(self, package: str, cls: str) -> "Intent":
        self._component = (package, cls)
        self._package = package
        return self

    def setPackage(self, package: str) -> "Intent":
        self._package = package
        return self

    def getAction(self) -> str:
        return self._action

    def getData(self) -> Optional[Uri]:
        return self._data

    def getScheme(self) -> str:
        return self._data.getScheme() if self._data else ""

    def resolveActivity(self, pm: "PackageManager") -> str:
        """解析 Activity 名称"""
        action_map = {
            IntentAction.ACTION_VIEW: "com.android.browser/.BrowserActivity",
            IntentAction.ACTION_DIAL: "com.android.dialer/.DialtactsActivity",
            IntentAction.ACTION_SEND: "com.android.mms/.ui.ConversationList",
            IntentAction.ACTION_IMAGE_CAPTURE: "com.android.camera/.CameraActivity",
        }
        return action_map.get(self._action, "unknown")

    def to_dict(self) -> dict:
        return {
            "action": self._action,
            "data": str(self._data) if self._data else None,
            "type": self._type,
            "extras": self._extras,
            "package": self._package,
            "categories": self._categories,
            "flags": self._flags,
        }


# ============================================================
#  android.content.Context
# ============================================================

class Context:
    """模拟 android.content.Context"""

    MODE_PRIVATE = 0
    MODE_APPEND = 32768

    def __init__(self, package_name: str = None):
        self._package_name = package_name or _package_name
        self._package_manager = PackageManager()
        self._content_resolver = ContentResolver(self)
        self._files_dir = os.path.join(_app_data_dir, "files")
        self._cache_dir = os.path.join(_app_data_dir, "cache")
        self._preferences: Dict[str, Any] = {}
        self._resources = Resources()
        os.makedirs(self._files_dir, exist_ok=True)
        os.makedirs(self._cache_dir, exist_ok=True)

    def getPackageName(self) -> str:
        return self._package_name

    def getPackageManager(self) -> "PackageManager":
        return self._package_manager

    def getContentResolver(self) -> ContentResolver:
        return self._content_resolver

    def getFilesDir(self) -> str:
        return self._files_dir

    def getCacheDir(self) -> str:
        return self._cache_dir

    def getDir(self, name: str, mode: int = 0) -> str:
        d = os.path.join(_app_data_dir, name)
        os.makedirs(d, exist_ok=True)
        return d

    def getExternalFilesDir(self, type_: str = None) -> str:
        path = os.path.join(_sdcard_root, "Android", "data", self._package_name, "files")
        if type_:
            path = os.path.join(path, type_)
        os.makedirs(path, exist_ok=True)
        return path

    def getExternalCacheDir(self) -> str:
        path = os.path.join(_sdcard_root, "Android", "data", self._package_name, "cache")
        os.makedirs(path, exist_ok=True)
        return path

    def getExternalStorageDirectory(self) -> str:
        return _sdcard_root

    def getResources(self) -> "Resources":
        return self._resources

    def getSystemService(self, name: str) -> Any:
        """返回模拟的系统服务"""
        services = {
            "activity": ActivityManager(),
            "power": PowerManager(),
            "notification": NotificationManager(),
            "alarm": AlarmManager(),
            "location": LocationManager(),
            "sensor": SensorManager(),
            "audio": AudioManager(),
            "connectivity": ConnectivityManager(),
            "display": DisplayManager(),
            "window": WindowManager(),
            "input": InputManager(),
            "layout_inflater": LayoutInflater(),
            "storage": StorageManager(),
            "clipboard": ClipboardManager(),
            "download": DownloadManager(),
            "telephony": TelephonyManager(),
        }
        return services.get(name)

    def startActivity(self, intent: Intent) -> bool:
        """启动 Activity - 映射到桌面操作"""
        action = intent.getAction()

        # ACTION_VIEW: 打开 URL
        if action == IntentAction.ACTION_VIEW:
            data = intent.getData()
            if data:
                url = data.toString()
                if url.startswith("http"):
                    webbrowser.open(url)
                    return True
                return True

        # ACTION_DIAL: 拨号
        elif action == IntentAction.ACTION_DIAL:
            data = intent.getData()
            if data:
                console.log(f"[AndroidCompat] 模拟拨号: {data.toString()}")
            return True

        # ACTION_SEND: 分享
        elif action == IntentAction.ACTION_SEND:
            text = intent.getStringExtra("android.intent.extra.TEXT")
            if text:
                console.log(f"[AndroidCompat] 模拟分享文本: {text[:100]}")
            return True

        # ACTION_SET_ALARM: 设置闹钟
        elif action == IntentAction.ACTION_SET_ALARM:
            alarm_data = intent.to_dict()
            console.log(f"[AndroidCompat] 模拟设置闹钟: {alarm_data['extras']}")
            return True

        # ACTION_IMAGE_CAPTURE: 拍照
        elif action == IntentAction.ACTION_IMAGE_CAPTURE:
            console.log("[AndroidCompat] 模拟拍照")
            return True

        # ACTION_INSERT: 插入日历事件
        elif action == IntentAction.ACTION_INSERT:
            console.log(f"[AndroidCompat] 模拟插入日历事件")
            return True

        console.log(f"[AndroidCompat] 未映射的 Intent: {intent.getAction()}")
        return False

    def sendBroadcast(self, intent: Intent) -> None:
        """广播 - 桌面端模拟"""
        console.log(f"[AndroidCompat] 模拟广播: {intent.getAction()}")
        self._broadcast_receivers = getattr(self, "_broadcast_receivers", {})
        action = intent.getAction()
        if action in self._broadcast_receivers:
            for receiver in self._broadcast_receivers[action]:
                receiver.onReceive(self, intent)

    def registerReceiver(self, receiver: "BroadcastReceiver", filter_: "IntentFilter") -> Intent:
        self._broadcast_receivers = getattr(self, "_broadcast_receivers", {})
        action = filter_._action
        if action not in self._broadcast_receivers:
            self._broadcast_receivers[action] = []
        self._broadcast_receivers[action].append(receiver)
        return None

    def unregisterReceiver(self, receiver: "BroadcastReceiver") -> None:
        self._broadcast_receivers = getattr(self, "_broadcast_receivers", {})
        for action, receivers in list(self._broadcast_receivers.items()):
            self._broadcast_receivers[action] = [r for r in receivers if r != receiver]

    def getSharedPreferences(self, name: str, mode: int = 0) -> "SharedPreferences":
        return SharedPreferences(self, name)

    def checkSelfPermission(self, permission: str) -> int:
        """模拟权限检查 - 默认有所有权限"""
        return 0  # PERMISSION_GRANTED

    def getPackageCodePath(self) -> str:
        return __file__

    def getApplicationInfo(self) -> "ApplicationInfo":
        return ApplicationInfo()


class ApplicationInfo:
    """模拟 android.content.pm.ApplicationInfo"""
    def __init__(self):
        self.sourceDir = __file__
        self.dataDir = _app_data_dir
        self.nativeLibraryDir = os.path.join(os.path.dirname(sys.executable), "lib")


class Resources:
    """模拟 android.content.res.Resources"""
    def getString(self, id_or_name) -> str:
        return f"resource_string_{id_or_name}"
    def getDrawable(self, id_or_name) -> Any:
        return None
    def getColor(self, id_or_name) -> int:
        return 0xFF000000
    def getDimension(self, id_or_name) -> float:
        return 0.0
    def getIdentifier(self, name: str, defType: str, defPackage: str) -> int:
        return hash(name) % 0x7FFFFFFF


class SharedPreferences:
    """模拟 android.content.SharedPreferences"""
    def __init__(self, context: Context, name: str):
        self._path = os.path.join(_app_data_dir, f"prefs_{name}.json")
        self._data = {}
        if os.path.isfile(self._path):
            try:
                with open(self._path, "r") as f:
                    self._data = json.load(f)
            except Exception:
                self._data = {}

    def getString(self, key: str, default: str = "") -> str:
        return str(self._data.get(key, default))

    def getInt(self, key: str, default: int = 0) -> int:
        return int(self._data.get(key, default))

    def getBoolean(self, key: str, default: bool = False) -> bool:
        return bool(self._data.get(key, default))

    def getFloat(self, key: str, default: float = 0.0) -> float:
        return float(self._data.get(key, default))

    def getLong(self, key: str, default: int = 0) -> int:
        return int(self._data.get(key, default))

    def contains(self, key: str) -> bool:
        return key in self._data

    def edit(self) -> "SharedPreferencesEditor":
        return SharedPreferencesEditor(self)

    def getAll(self) -> Dict:
        return dict(self._data)


class SharedPreferencesEditor:
    """SharedPreferences.Editor"""
    def __init__(self, prefs: SharedPreferences):
        self._prefs = prefs
        self._changes = {}

    def putString(self, key: str, value: str) -> "SharedPreferencesEditor":
        self._changes[key] = value
        return self

    def putInt(self, key: str, value: int) -> "SharedPreferencesEditor":
        self._changes[key] = value
        return self

    def putBoolean(self, key: str, value: bool) -> "SharedPreferencesEditor":
        self._changes[key] = value
        return self

    def putLong(self, key: str, value: int) -> "SharedPreferencesEditor":
        self._changes[key] = value
        return self

    def remove(self, key: str) -> "SharedPreferencesEditor":
        self._changes[key] = None
        return self

    def clear(self) -> "SharedPreferencesEditor":
        self._changes = {}
        self._prefs._data = {}
        return self

    def apply(self) -> None:
        self.commit()

    def commit(self) -> bool:
        for k, v in self._changes.items():
            if v is None:
                self._prefs._data.pop(k, None)
            else:
                self._prefs._data[k] = v
        try:
            os.makedirs(os.path.dirname(self._prefs._path), exist_ok=True)
            with open(self._prefs._path, "w", encoding="utf-8") as f:
                json.dump(self._prefs._data, f, indent=2, ensure_ascii=False)
            return True
        except Exception:
            return False


# ============================================================
#  android.content.BroadcastReceiver + IntentFilter
# ============================================================

class BroadcastReceiver:
    """模拟 android.content.BroadcastReceiver"""
    def onReceive(self, context: Context, intent: Intent) -> None:
        pass


class IntentFilter:
    """模拟 android.content.IntentFilter"""
    def __init__(self, action: str = None):
        self._action = action
        self._actions: List[str] = []
        if action:
            self._actions.append(action)

    def addAction(self, action: str) -> None:
        if action not in self._actions:
            self._actions.append(action)


# ============================================================
#  android.os (Build, Environment, PowerManager, Vibration)
# ============================================================

class Build:
    """模拟 android.os.Build"""

    class VERSION:
        SDK_INT = 33  # Android 13
        RELEASE = "13"
        CODENAME = "Tiramisu"
        INCREMENTAL = "2026.06"
        SDK_NAME = "Tiramisu"

    BOARD = "generic"
    BRAND = "OperitCompat"
    DEVICE = "pc"
    DISPLAY = "OP1.230607.001"
    FINGERPRINT = "generic/OperitCompat/pc:13/TP1A.220624.014/12345678:user/release-keys"
    HARDWARE = "x86_64"
    HOST = "localhost"
    ID = "TP1A.220624.014"
    MANUFACTURER = "OperitCompat"
    MODEL = platform.node()
    PRODUCT = "operit_compat_pc"
    SERIAL = "0123456789ABCDEF"
    SUPPORTED_ABIS = [platform.machine()]
    TAGS = "release-keys"
    TIME = int(time.time())
    TYPE = "user"
    USER = os.environ.get("USER", "user")

    @staticmethod
    def getRadioVersion() -> str:
        return "unknown"

    @staticmethod
    def getSerial() -> str:
        return Build.SERIAL


class Environment:
    """模拟 android.os.Environment"""

    MEDIA_MOUNTED = "mounted"
    MEDIA_UNMOUNTED = "unmounted"

    @staticmethod
    def getExternalStorageDirectory() -> str:
        return _sdcard_root

    @staticmethod
    def getExternalStoragePublicDirectory(type_: str) -> str:
        mapping = {
            "DCIM": "DCIM",
            "Download": "Download",
            "Documents": "Documents",
            "Music": "Music",
            "Movies": "Movies",
            "Pictures": "Pictures",
            "Alarms": "Alarms",
            "Notifications": "Notifications",
            "Ringtones": "Ringtones",
        }
        subdir = mapping.get(type_, type_)
        path = os.path.join(_sdcard_root, subdir)
        os.makedirs(path, exist_ok=True)
        return path

    @staticmethod
    def getDataDirectory() -> str:
        return _app_data_dir

    @staticmethod
    def getDownloadCacheDirectory() -> str:
        return os.path.join(_app_data_dir, "cache", "downloads")

    @staticmethod
    def getExternalStorageState() -> str:
        return Environment.MEDIA_MOUNTED


class PowerManager:
    """模拟 android.os.PowerManager"""
    PARTIAL_WAKE_LOCK = 1
    SCREEN_BRIGHT_WAKE_LOCK = 10
    FULL_WAKE_LOCK = 26
    ACQUIRE_CAUSES_WAKEUP = 0x10000000
    ON_AFTER_RELEASE = 0x20000000

    def newWakeLock(self, levelAndFlags: int, tag: str) -> "WakeLock":
        return WakeLock()

    def isScreenOn(self) -> bool:
        return True

    def isInteractive(self) -> bool:
        return True

    def isPowerSaveMode(self) -> bool:
        return False

    def isDeviceIdleMode(self) -> bool:
        return False

    def reboot(self, reason: str = None) -> None:
        console.log(f"[AndroidCompat] 模拟重启: {reason}")

    def goToSleep(self, timeMs: int) -> None:
        pass


class WakeLock:
    """模拟 android.os.PowerManager.WakeLock"""
    def acquire(self, timeoutMs: int = None) -> None:
        pass
    def release(self, flags: int = 0) -> None:
        pass
    def isHeld(self) -> bool:
        return False
    def setReferenceCounted(self, value: bool) -> None:
        pass


class VibrationEffect:
    """模拟 android.os.VibrationEffect"""
    DEFAULT_AMPLITUDE = -1

    @staticmethod
    def createOneShot(milliseconds: int, amplitude: int = DEFAULT_AMPLITUDE) -> "VibrationEffect":
        return VibrationEffect()

    @staticmethod
    def createWaveform(timings: List[int], amplitudes: List[int], repeat: int) -> "VibrationEffect":
        return VibrationEffect()


class Vibrator:
    """模拟 android.os.Vibrator"""
    def vibrate(self, effect_or_ms) -> None:
        pass
    def hasVibrator(self) -> bool:
        return False
    def cancel(self) -> None:
        pass


# ============================================================
#  android.app services
# ============================================================

class ActivityManager:
    """模拟 android.app.ActivityManager"""
    def getRunningAppProcesses(self) -> List:
        if HAS_PSUTIL:
            return [{"processName": p.name(), "pid": p.pid,
                     "importance": 100} for p in psutil.process_iter()[:10]]
        return [{"processName": "python", "pid": os.getpid(), "importance": 100}]

    def getMemoryInfo(self) -> "MemoryInfo":
        return ActivityManager.MemoryInfo()

    def killBackgroundProcesses(self, packageName: str) -> None:
        console.log(f"[AndroidCompat] 模拟结束进程: {packageName}")

    class MemoryInfo:
        def __init__(self):
            self.availMem = 8 * 1024 * 1024 * 1024  # 8GB
            self.totalMem = 16 * 1024 * 1024 * 1024  # 16GB
            self.threshold = 256 * 1024 * 1024       # 256MB
            self.lowMemory = False

    def getAppTasks(self) -> List:
        return []


class PackageManager:
    """模拟 android.content.pm.PackageManager"""

    def getInstalledPackages(self, flags: int = 0) -> List["PackageInfo"]:
        """返回已安装的应用列表"""
        packages = []
        system_packages = [
            "com.android.settings", "com.android.systemui",
            "com.android.launcher3", "com.google.android.gms",
            "com.google.android.gsf", "com.android.documentsui",
            "com.android.providers.downloads", "com.android.vending",
        ]
        for pkg in system_packages:
            packages.append(PackageInfo(pkg, "13", True))
        packages.append(PackageInfo(_package_name, "1.0.0", False))
        return packages

    def getPackageInfo(self, packageName: str, flags: int = 0) -> Optional["PackageInfo"]:
        for pkg in self.getInstalledPackages():
            if pkg.packageName == packageName:
                return pkg
        return PackageInfo(packageName, "0.0.0", False)

    def getApplicationLabel(self, info: "ApplicationInfo") -> str:
        return info.packageName if hasattr(info, 'packageName') else _package_name

    def queryIntentActivities(self, intent: Intent, flags: int = 0) -> List:
        return [ResolveInfo()]

    def resolveActivity(self, intent: Intent, flags: int = 0) -> Optional["ResolveInfo"]:
        return ResolveInfo()

    def checkPermission(self, permission: str, pid: int, uid: int) -> int:
        return 0  # PERMISSION_GRANTED

    def getPackagesForUid(self, uid: int) -> List[str]:
        return [_package_name]

    @staticmethod
    def getPermission(permission: str) -> str:
        return f"android.permission.{permission}"


class PackageInfo:
    def __init__(self, pkg_name: str, version: str = "1.0", is_system: bool = False):
        self.packageName = pkg_name
        self.versionName = version
        self.versionCode = int(version.replace(".", ""))
        self.applicationInfo = ApplicationInfo()
        self.applicationInfo.packageName = pkg_name
        self.firstInstallTime = int(time.time())
        self.lastUpdateTime = int(time.time())
        self.sharedUserId = None
        self.requestedPermissions = []
        self.gids = []


class ResolveInfo:
    def __init__(self):
        self.activityInfo = ActivityInfo()
        self.resolvePackageName = "com.android.browser"
        self.priority = 0

    def loadLabel(self, pm: PackageManager) -> str:
        return self.resolvePackageName


class ActivityInfo:
    def __init__(self):
        self.packageName = _package_name
        self.name = "MainActivity"
        self.processName = _package_name
        self.taskAffinity = _package_name
        self.launchMode = 0
        self.flags = 0
        self.screenOrientation = 1
        self.configChanges = 0
        self.exported = True
        self.theme = 0


class NotificationManager:
    """模拟 android.app.NotificationManager"""
    IMPORTANCE_HIGH = 4
    IMPORTANCE_DEFAULT = 3
    IMPORTANCE_LOW = 2
    IMPORTANCE_MIN = 1
    IMPORTANCE_NONE = 0

    def notify(self, id_or_tag, notification_or_id=None) -> None:
        console.log(f"[AndroidCompat] 模拟通知: id={id_or_tag}")

    def cancel(self, id_or_tag, notification_id=None) -> None:
        pass

    def cancelAll(self) -> None:
        pass

    def createNotificationChannel(self, channel) -> None:
        pass

    def getNotificationChannel(self, channelId: str) -> Optional["NotificationChannel"]:
        return NotificationChannel(channelId, "Default", self.IMPORTANCE_DEFAULT)


class NotificationChannel:
    def __init__(self, id_: str, name: str, importance: int):
        self.id = id_
        self.name = name
        self.importance = importance
        self.description = ""
        self.enableVibration = True
        self.enableLights = True


class AlarmManager:
    """模拟 android.app.AlarmManager"""
    RTC = 0
    RTC_WAKEUP = 1
    ELAPSED_REALTIME = 2
    ELAPSED_REALTIME_WAKEUP = 3
    INTERVAL_FIFTEEN_MINUTES = 900000
    INTERVAL_HALF_HOUR = 1800000
    INTERVAL_HOUR = 3600000
    INTERVAL_DAY = 86400000

    def set(self, type_: int, triggerAtMillis: int, operation: Any) -> None:
        console.log(f"[AndroidCompat] 模拟闹钟: type={type_}, trigger={triggerAtMillis}")

    def setRepeating(self, type_: int, triggerAtMillis: int, intervalMillis: int, operation: Any) -> None:
        console.log(f"[AndroidCompat] 模拟重复闹钟: trigger={triggerAtMillis}, interval={intervalMillis}")

    def setExact(self, type_: int, triggerAtMillis: int, operation: Any) -> None:
        self.set(type_, triggerAtMillis, operation)

    def cancel(self, operation: Any) -> None:
        pass

    def setAlarmClock(self, info: "AlarmClockInfo", operation: Any) -> None:
        pass


# ============================================================
#  android.graphics
# ============================================================

class Color:
    """模拟 android.graphics.Color"""
    BLACK = 0xFF000000
    WHITE = 0xFFFFFFFF
    RED = 0xFFFF0000
    GREEN = 0xFF00FF00
    BLUE = 0xFF0000FF
    YELLOW = 0xFFFFFF00
    CYAN = 0xFF00FFFF
    MAGENTA = 0xFFFF00FF
    GRAY = 0xFF808080
    TRANSPARENT = 0x00000000

    @staticmethod
    def argb(alpha: int, red: int, green: int, blue: int) -> int:
        return (alpha << 24) | (red << 16) | (green << 8) | blue

    @staticmethod
    def alpha(color: int) -> int:
        return (color >> 24) & 0xFF

    @staticmethod
    def red(color: int) -> int:
        return (color >> 16) & 0xFF

    @staticmethod
    def green(color: int) -> int:
        return (color >> 8) & 0xFF

    @staticmethod
    def blue(color: int) -> int:
        return color & 0xFF

    @staticmethod
    def parseColor(colorString: str) -> int:
        colorString = colorString.strip()
        if colorString.startswith("#"):
            hex_str = colorString[1:]
            if len(hex_str) == 6:
                return 0xFF000000 | int(hex_str, 16)
            elif len(hex_str) == 8:
                return int(hex_str, 16)
        return Color.BLACK

    @staticmethod
    def rgb(red: int, green: int, blue: int) -> int:
        return 0xFF000000 | (red << 16) | (green << 8) | blue

    @staticmethod
    def toArgb(color: int) -> int:
        return color

    @staticmethod
    def toColor(c):
        return c


class Rect:
    """模拟 android.graphics.Rect"""
    def __init__(self, left: int = 0, top: int = 0, right: int = 0, bottom: int = 0):
        self.left = left
        self.top = top
        self.right = right
        self.bottom = bottom

    def width(self) -> int:
        return self.right - self.left

    def height(self) -> int:
        return self.bottom - self.top

    def centerX(self) -> int:
        return (self.left + self.right) // 2

    def centerY(self) -> int:
        return (self.top + self.bottom) // 2

    def contains(self, x: int, y: int) -> bool:
        return self.left <= x <= self.right and self.top <= y <= self.bottom

    def isEmpty(self) -> bool:
        return self.width() <= 0 or self.height() <= 0

    def inset(self, dx: int, dy: int) -> None:
        self.left += dx
        self.right -= dx
        self.top += dy
        self.bottom -= dy

    def offset(self, dx: int, dy: int) -> None:
        self.left += dx
        self.right += dx
        self.top += dy
        self.bottom += dy

    def toShortString(self) -> str:
        return f"[{self.left},{self.top}][{self.right},{self.bottom}]"

    def __repr__(self):
        return self.toShortString()


class Paint:
    """模拟 android.graphics.Paint"""
    ANTI_ALIAS_FLAG = 0x01
    FILL = 0
    STROKE = 1
    FILL_AND_STROKE = 2

    def __init__(self, flags: int = 0):
        self._flags = flags
        self._color = Color.BLACK
        self._strokeWidth = 0.0
        self._textSize = 16.0
        self._style = self.FILL
        self._alpha = 255
        self._typeface = None

    def setColor(self, color: int) -> None:
        self._color = color

    def getColor(self) -> int:
        return self._color

    def setStrokeWidth(self, width: float) -> None:
        self._strokeWidth = width

    def setTextSize(self, size: float) -> None:
        self._textSize = size

    def setStyle(self, style: int) -> None:
        self._style = style

    def setAlpha(self, alpha: int) -> None:
        self._alpha = alpha

    def setTypeface(self, typeface) -> None:
        self._typeface = typeface

    def measureText(self, text: str) -> float:
        return len(text) * self._textSize * 0.6


class Bitmap:
    """模拟 android.graphics.Bitmap - 基于 PIL"""

    class Config:
        ARGB_8888 = "ARGB_8888"
        RGB_565 = "RGB_565"
        ALPHA_8 = "ALPHA_8"

    @staticmethod
    def createBitmap(width: int, height: int, config: str = Config.ARGB_8888) -> "Bitmap":
        return Bitmap(width, height, config)

    @staticmethod
    def createScaledBitmap(src: "Bitmap", dstWidth: int, dstHeight: int, filter: bool) -> "Bitmap":
        if HAS_PIL:
            pil_img = src._pil.resize((dstWidth, dstHeight), Image.LANCZOS if filter else Image.NEAREST)
            result = Bitmap(dstWidth, dstHeight, src._config)
            result._pil = pil_img
            return result
        return Bitmap(dstWidth, dstHeight, src._config)

    @staticmethod
    def decodeFile(path: str) -> Optional["Bitmap"]:
        if HAS_PIL:
            try:
                pil_img = Image.open(path)
                bmp = Bitmap(pil_img.width, pil_img.height)
                bmp._pil = pil_img
                return bmp
            except Exception:
                return None
        return None

    @staticmethod
    def decodeByteArray(data: bytes, offset: int, length: int) -> Optional["Bitmap"]:
        if HAS_PIL:
            try:
                pil_img = Image.open(io.BytesIO(data[offset:offset + length]))
                bmp = Bitmap(pil_img.width, pil_img.height)
                bmp._pil = pil_img
                return bmp
            except Exception:
                return None
        return None

    def __init__(self, width: int, height: int, config: str = Config.ARGB_8888):
        self._width = width
        self._height = height
        self._config = config
        if HAS_PIL:
            self._pil = Image.new("RGBA", (width, height), (0, 0, 0, 0))
        else:
            self._pil = None
        self._recycled = False

    def getWidth(self) -> int:
        return self._width

    def getHeight(self) -> int:
        return self._height

    def getConfig(self) -> str:
        return self._config

    def getPixel(self, x: int, y: int) -> int:
        if HAS_PIL and self._pil:
            try:
                r, g, b, a = self._pil.getpixel((x, y))
                return Color.argb(a, r, g, b)
            except Exception:
                pass
        return 0

    def setPixel(self, x: int, y: int, color: int) -> None:
        if HAS_PIL and self._pil:
            a = Color.alpha(color)
            r = Color.red(color)
            g = Color.green(color)
            b = Color.blue(color)
            self._pil.putpixel((x, y), (r, g, b, a))

    def eraseColor(self, color: int) -> None:
        if HAS_PIL and self._pil:
            r, g, b, a = Color.red(color), Color.green(color), Color.blue(color), Color.alpha(color)
            self._pil = Image.new("RGBA", (self._width, self._height), (r, g, b, a))

    def compress(self, format_: "Bitmap.CompressFormat", quality: int, stream: io.BytesIO) -> bool:
        if HAS_PIL and self._pil:
            pil_fmt = "JPEG" if format_ == Bitmap.CompressFormat.JPEG else "PNG"
            if self._pil.mode == "RGBA":
                self._pil = self._pil.convert("RGB") if pil_fmt == "JPEG" else self._pil
            self._pil.save(stream, format=pil_fmt, quality=quality)
            return True
        return False

    def copy(self, config: str, isMutable: bool) -> "Bitmap":
        result = Bitmap(self._width, self._height, config)
        if HAS_PIL and self._pil:
            result._pil = self._pil.copy()
        return result

    def recycle(self) -> None:
        self._recycled = True
        self._pil = None

    def isRecycled(self) -> bool:
        return self._recycled

    class CompressFormat:
        JPEG = "JPEG"
        PNG = "PNG"
        WEBP = "WEBP"


class Canvas:
    """模拟 android.graphics.Canvas - 基于 PIL"""

    def __init__(self, bitmap: Bitmap = None):
        self._bitmap = bitmap
        self._draw = ImageDraw.Draw(bitmap._pil) if HAS_PIL and bitmap and bitmap._pil else None

    def drawColor(self, color: int) -> None:
        if self._bitmap:
            self._bitmap.eraseColor(color)

    def drawPoint(self, x: float, y: float, paint: Paint) -> None:
        if self._draw:
            c = Color.toArgb(paint._color)
            self._draw.point([(x, y)], fill=(Color.red(c), Color.green(c), Color.blue(c), Color.alpha(c)))

    def drawLine(self, startX: float, startY: float, stopX: float, stopY: float, paint: Paint) -> None:
        if self._draw:
            c = Color.toArgb(paint._color)
            self._draw.line([(startX, startY), (stopX, stopY)],
                           fill=(Color.red(c), Color.green(c), Color.blue(c), Color.alpha(c)),
                           width=max(1, int(paint._strokeWidth)))

    def drawRect(self, rect: Rect, paint: Paint) -> None:
        if self._draw:
            c = Color.toArgb(paint._color)
            self._draw.rectangle([rect.left, rect.top, rect.right, rect.bottom],
                                fill=(Color.red(c), Color.green(c), Color.blue(c), Color.alpha(c)))

    def drawCircle(self, cx: float, cy: float, radius: float, paint: Paint) -> None:
        if self._draw:
            c = Color.toArgb(paint._color)
            self._draw.ellipse([cx - radius, cy - radius, cx + radius, cy + radius],
                              fill=(Color.red(c), Color.green(c), Color.blue(c), Color.alpha(c)))

    def drawText(self, text: str, x: float, y: float, paint: Paint) -> None:
        if self._draw:
            c = Color.toArgb(paint._color)
            self._draw.text((x, y), text, fill=(Color.red(c), Color.green(c), Color.blue(c), Color.alpha(c)))

    def drawBitmap(self, bitmap: Bitmap, left: float, top: float, paint: Paint = None) -> None:
        if HAS_PIL and self._bitmap and self._bitmap._pil and bitmap._pil:
            self._bitmap._pil.paste(bitmap._pil, (int(left), int(top)))

    def getWidth(self) -> int:
        return self._bitmap._width if self._bitmap else 0

    def getHeight(self) -> int:
        return self._bitmap._height if self._bitmap else 0

    def save(self) -> int:
        return 1

    def restore(self) -> None:
        pass


class Typeface:
    """模拟 android.graphics.Typeface"""
    DEFAULT = "DEFAULT"
    BOLD = "BOLD"
    ITALIC = "ITALIC"
    BOLD_ITALIC = "BOLD_ITALIC"
    MONOSPACE = "MONOSPACE"
    SANS_SERIF = "SANS_SERIF"
    SERIF = "SERIF"

    @staticmethod
    def defaultFromStyle(style: int) -> "Typeface":
        return Typeface()

    @staticmethod
    def create(name: str, style: int) -> "Typeface":
        return Typeface()


class BitmapFactory:
    """模拟 android.graphics.BitmapFactory"""

    @staticmethod
    def decodeFile(path: str, opts: dict = None) -> Optional[Bitmap]:
        return Bitmap.decodeFile(path)

    @staticmethod
    def decodeByteArray(data: bytes, offset: int, length: int, opts: dict = None) -> Optional[Bitmap]:
        return Bitmap.decodeByteArray(data, offset, length)

    @staticmethod
    def decodeResource(res: Resources, id_: int) -> Optional[Bitmap]:
        return Bitmap.createBitmap(100, 100)

    class Options:
        def __init__(self):
            self.inSampleSize = 1
            self.inPreferredConfig = Bitmap.Config.ARGB_8888
            self.inJustDecodeBounds = False
            self.outWidth = 0
            self.outHeight = 0
            self.inMutable = False


class Matrix:
    """模拟 android.graphics.Matrix"""
    def __init__(self):
        self._values = [1, 0, 0, 0, 1, 0, 0, 0, 1]

    def setScale(self, sx: float, sy: float) -> None:
        self._values[0] = sx
        self._values[4] = sy

    def setTranslate(self, dx: float, dy: float) -> None:
        self._values[2] = dx
        self._values[5] = dy

    def setRotate(self, degrees: float) -> None:
        rad = math.radians(degrees)
        self._values[0] = math.cos(rad)
        self._values[1] = -math.sin(rad)
        self._values[3] = math.sin(rad)
        self._values[4] = math.cos(rad)

    def postScale(self, sx: float, sy: float) -> None:
        self._values[0] *= sx
        self._values[4] *= sy

    def postTranslate(self, dx: float, dy: float) -> None:
        self._values[2] += dx
        self._values[5] += dy

    def mapRect(self, rect: Rect) -> Rect:
        return rect


# ============================================================
#  android.graphics.pdf.PdfRenderer
# ============================================================

class PdfRenderer:
    """模拟 android.graphics.pdf.PdfRenderer - 基于 PyMuPDF"""

    def __init__(self, input: Any, renderMode: int = 0):
        self._pageCount = 0
        self._currentPage = None
        self._closed = False
        try:
            import fitz
            self._doc = fitz.open(input)
            self._pageCount = len(self._doc)
        except ImportError:
            console.log("[PdfRenderer] PyMuPDF 未安装，使用 pdf2image 降级")
            self._pageCount = 0
            try:
                from pdf2image import convert_from_path
                self._images = convert_from_path(input if isinstance(input, str) else "temp.pdf")
                self._pageCount = len(self._images)
            except ImportError:
                console.log("[PdfRenderer] pdf2image 也未安装，使用空回退")
                self._images = []

    def getPageCount(self) -> int:
        return self._pageCount

    def openPage(self, index: int) -> "PdfRenderer.Page":
        self._currentPage = PdfRenderer.Page(index)
        try:
            if hasattr(self, '_doc'):
                fitz_page = self._doc[index]
                pix = fitz_page.get_pixmap()
                pil_img = Image.frombytes("RGB", [pix.width, pix.height], pix.samples)
                bmp = Bitmap(pix.width, pix.height)
                bmp._pil = pil_img
                self._currentPage._render = bmp
                self._currentPage._width = pix.width
                self._currentPage._height = pix.height
            elif hasattr(self, '_images') and index < len(self._images):
                pil_img = self._images[index]
                bmp = Bitmap(pil_img.width, pil_img.height)
                bmp._pil = pil_img
                self._currentPage._render = bmp
                self._currentPage._width = pil_img.width
                self._currentPage._height = pil_img.height
        except Exception as e:
            console.log(f"[PdfRenderer] 渲染第 {index} 页出错: {e}")
        return self._currentPage

    def close(self) -> None:
        self._closed = True
        if hasattr(self, '_doc'):
            self._doc.close()

    class Page:
        RENDER_MODE_FOR_DISPLAY = 1
        RENDER_MODE_FOR_PRINT = 2

        def __init__(self, index: int):
            self._index = index
            self._render = None
            self._width = 0
            self._height = 0

        def getWidth(self) -> int:
            return self._width

        def getHeight(self) -> int:
            return self._height

        def render(self, bitmap: Bitmap, left: int, top: int, right: int, bottom: int,
                   paintFlags: int, renderMode: int = RENDER_MODE_FOR_DISPLAY) -> None:
            if self._render and self._render._pil and bitmap._pil:
                bitmap._pil.paste(self._render._pil.resize((right - left, bottom - top)))

        def close(self) -> None:
            pass


# ============================================================
#  android.view / accessibility 体系 (UINode)
# ============================================================

class View:
    """模拟 android.view.View"""
    def __init__(self, context: Context = None):
        self._context = context
        self._x = 0
        self._y = 0
        self._width = 0
        self._height = 0
        self._visible = True
        self._enabled = True
        self._clickable = False
        self._text = ""
        self._contentDescription = ""
        self._children: List[View] = []
        self._parent: Optional[View] = None
        self._backgroundColor = Color.TRANSPARENT
        self._alpha = 1.0
        self._rotation = 0.0
        self._scaleX = 1.0
        self._scaleY = 1.0
        self._tag = None
        self._id = -1
        self._onClickListener = None
        self._elevation = 0.0

    def getX(self) -> float: return float(self._x)
    def getY(self) -> float: return float(self._y)
    def getWidth(self) -> int: return self._width
    def getHeight(self) -> int: return self._height
    def getVisibility(self) -> int: return 0 if self._visible else 8
    def isEnabled(self) -> bool: return self._enabled
    def isClickable(self) -> bool: return self._clickable
    def isShown(self) -> bool: return self._visible

    def setVisibility(self, visibility: int) -> None:
        self._visible = (visibility != 8)
    def setEnabled(self, enabled: bool) -> None: self._enabled = enabled
    def setClickable(self, clickable: bool) -> None: self._clickable = clickable
    def setBackgroundColor(self, color: int) -> None: self._backgroundColor = color
    def setAlpha(self, alpha: float) -> None: self._alpha = alpha
    def setRotation(self, rotation: float) -> None: self._rotation = rotation
    def setScaleX(self, sx: float) -> None: self._scaleX = sx
    def setScaleY(self, sy: float) -> None: self._scaleY = sy
    def setTag(self, tag: Any) -> None: self._tag = tag
    def setId(self, id_: int) -> None: self._id = id_

    def getText(self) -> str: return self._text
    def setText(self, text: str) -> None: self._text = text
    def getContentDescription(self) -> str: return self._contentDescription
    def setContentDescription(self, desc: str) -> None: self._contentDescription = desc

    def getParent(self) -> Optional["View"]: return self._parent
    def getChildCount(self) -> int: return len(self._children)
    def getChildAt(self, index: int) -> Optional["View"]:
        return self._children[index] if 0 <= index < len(self._children) else None
    def addView(self, child: "View") -> None:
        self._children.append(child)
        child._parent = self
    def removeView(self, child: "View") -> None:
        if child in self._children:
            self._children.remove(child)
            child._parent = None
    def removeAllViews(self) -> None:
        for child in self._children:
            child._parent = None
        self._children.clear()

    def findViewById(self, id_: int) -> Optional["View"]:
        if self._id == id_: return self
        for child in self._children:
            result = child.findViewById(id_)
            if result: return result
        return None

    def getGlobalVisibleRect(self, rect: Rect) -> bool:
        r = Rect(self._x, self._y, self._x + self._width, self._y + self._height)
        rect.left, rect.top, rect.right, rect.bottom = r.left, r.top, r.right, r.bottom
        return self._visible

    def performClick(self) -> bool:
        if self._onClickListener:
            self._onClickListener.onClick(self)
            return True
        if HAS_PYAUTOGUI:
            pyautogui.click(self._x + self._width // 2, self._y + self._height // 2)
            return True
        return False

    def setOnClickListener(self, listener) -> None:
        self._onClickListener = listener

    def post(self, action: Callable) -> bool:
        action()
        return True

    def postDelayed(self, action: Callable, delayMs: int) -> bool:
        import threading
        timer = threading.Timer(delayMs / 1000, action)
        timer.start()
        return True

    def invalidate(self) -> None: pass


class TextView(View):
    """模拟 android.widget.TextView"""
    def __init__(self, context: Context = None):
        super().__init__(context)
        self._text = ""
        self._textSize = 16.0
        self._textColor = Color.BLACK
        self._gravity = 0
        self._lines = 1
        self._typeface = None
        self._inputType = 0
        self._hint = ""
        self._maxLines = 1
        self._ellipsize = None

    def setTextSize(self, size: float) -> None: self._textSize = size
    def setTextColor(self, color: int) -> None: self._textColor = color
    def setGravity(self, gravity: int) -> None: self._gravity = gravity
    def setLines(self, lines: int) -> None: self._lines = lines
    def setHint(self, hint: str) -> None: self._hint = hint
    def setInputType(self, type_: int) -> None: self._inputType = type_
    def setMaxLines(self, maxLines: int) -> None: self._maxLines = maxLines
    def setEllipsize(self, where: str) -> None: self._ellipsize = where
    def getText(self) -> str: return self._text
    def setText(self, text: str) -> None: self._text = text
    def getTextSize(self) -> float: return self._textSize
    def getCurrentTextColor(self) -> int: return self._textColor
    def getHint(self) -> str: return self._hint


class EditText(TextView):
    """模拟 android.widget.EditText"""
    def __init__(self, context: Context = None):
        super().__init__(context)
        self._selectionStart = 0
        self._selectionEnd = 0

    def getSelectionStart(self) -> int: return self._selectionStart
    def getSelectionEnd(self) -> int: return self._selectionEnd
    def setSelection(self, start: int, stop: int = None) -> None:
        self._selectionStart = start
        self._selectionEnd = stop if stop is not None else start

    def selectAll(self) -> None:
        self._selectionStart = 0
        self._selectionEnd = len(self._text)

    def append(self, text: str) -> None:
        self._text += text


class Button(TextView):
    """模拟 android.widget.Button"""
    def __init__(self, context: Context = None):
        super().__init__(context)
        self._clickable = True


class ImageView(View):
    """模拟 android.widget.ImageView"""
    ScaleType = type("ScaleType", (), {"FIT_XY": "FIT_XY", "CENTER_CROP": "CENTER_CROP",
                                        "CENTER_INSIDE": "CENTER_INSIDE", "MATRIX": "MATRIX"})

    def __init__(self, context: Context = None):
        super().__init__(context)
        self._imageBitmap = None
        self._scaleType = ImageView.ScaleType.FIT_CENTER

    def setImageBitmap(self, bmp: Bitmap) -> None: self._imageBitmap = bmp
    def setImageResource(self, resId: int) -> None: pass
    def setScaleType(self, scaleType: str) -> None: self._scaleType = scaleType
    def getDrawable(self) -> Any: return self._imageBitmap


class ScrollView(View):
    """模拟 android.widget.ScrollView"""
    def __init__(self, context: Context = None):
        super().__init__(context)
        self._scrollX = 0
        self._scrollY = 0

    def scrollTo(self, x: int, y: int) -> None:
        self._scrollX = x
        self._scrollY = y

    def scrollBy(self, dx: int, dy: int) -> None:
        self._scrollX += dx
        self._scrollY += dy

    def fullScroll(self, direction: int) -> bool: return True

    def getScrollX(self) -> int: return self._scrollX
    def getScrollY(self) -> int: return self._scrollY


class RecyclerView(View):
    """模拟 androidx.recyclerview.widget.RecyclerView"""
    def smoothScrollToPosition(self, position: int) -> None: pass


class ViewGroup(View):
    """模拟 android.view.ViewGroup"""
    def __init__(self, context: Context = None):
        super().__init__(context)

    def addView(self, child: View) -> None:
        self._children.append(child)
        child._parent = self

    def removeView(self, child: View) -> None:
        self._children.remove(child)
        child._parent = None

    def removeAllViews(self) -> None:
        self._children.clear()

    def getChildCount(self) -> int:
        return len(self._children)

    def getChildAt(self, index: int) -> Optional[View]:
        return self._children[index] if 0 <= index < len(self._children) else None

    def findViewById(self, id_: int) -> Optional[View]:
        return super().findViewById(id_)

    def indexOfChild(self, child: View) -> int:
        return self._children.index(child) if child in self._children else -1


class LinearLayout(ViewGroup):
    """模拟 android.widget.LinearLayout"""
    HORIZONTAL = 0
    VERTICAL = 1

    def __init__(self, context: Context = None):
        super().__init__(context)
        self._orientation = self.VERTICAL
        self._gravity = 0

    def setOrientation(self, orientation: int) -> None:
        self._orientation = orientation

    def getOrientation(self) -> int:
        return self._orientation

    def setGravity(self, gravity: int) -> None:
        self._gravity = gravity


class FrameLayout(ViewGroup):
    """模拟 android.widget.FrameLayout"""
    def __init__(self, context: Context = None):
        super().__init__(context)


class RelativeLayout(ViewGroup):
    """模拟 android.widget.RelativeLayout"""
    def __init__(self, context: Context = None):
        super().__init__(context)


# ============================================================
#  UINode - Android UI 自动化核心
# ============================================================

class UINode:
    """模拟 Android 无障碍 UI 节点树 - 基于 pyautogui / Playwright"""

    def __init__(self):
        self._nodes: List[dict] = []
        self._focused_node = None

    @staticmethod
    async def getCurrentPage() -> "AccessibilityPage":
        """获取当前页面无障碍树"""
        return AccessibilityPage()


class AccessibilityNodeInfo:
    """模拟 android.view.accessibility.AccessibilityNodeInfo"""
    def __init__(self):
        self._node_id = hash(str(time.time() + random.random()))
        self.packageName = _package_name
        self.className = "android.view.View"
        self.text = ""
        self.contentDescription = ""
        self.viewId = ""
        self.resourceName = ""
        self.boundsInScreen = Rect(0, 0, 1920, 1080)
        self.visibleToUser = True
        self.enabled = True
        self.clickable = False
        self.longClickable = False
        self.focusable = False
        self.focused = False
        self.scrollable = False
        self.checkable = False
        self.checked = False
        self.selected = False
        self.password = False
        self._children: List["AccessibilityNodeInfo"] = []
        self._parent = None
        self.childCount = 0
        self.row = -1
        self.column = -1
        self.rowCount = -1
        self.columnCount = -1
        self.inputType = 0
        self.hintText = ""
        self.errorText = ""
        self.depth = 0

    def getChild(self, index: int) -> Optional["AccessibilityNodeInfo"]:
        return self._children[index] if 0 <= index < len(self._children) else None

    def getChildCount(self) -> int:
        return len(self._children)

    def getParent(self) -> Optional["AccessibilityNodeInfo"]:
        return self._parent

    def addChild(self, child: "AccessibilityNodeInfo") -> None:
        self._children.append(child)
        child._parent = self
        self.childCount = len(self._children)
        child.depth = self.depth + 1

    def findByText(self, text: str) -> Optional["AccessibilityNodeInfo"]:
        if text in (self.text or "") or text in (self.contentDescription or ""):
            return self
        for child in self._children:
            result = child.findByText(text)
            if result:
                return result
        return None

    def findById(self, id_: str) -> Optional["AccessibilityNodeInfo"]:
        if self.viewId == id_ or self.resourceName == id_:
            return self
        for child in self._children:
            result = child.findById(id_)
            if result:
                return result
        return None

    def findAccessibilityFocus(self) -> Optional["AccessibilityNodeInfo"]:
        if self.focused:
            return self
        for child in self._children:
            result = child.findAccessibilityFocus()
            if result:
                return result
        return None

    def performAction(self, action: int) -> bool:
        if action == 16:  # CLICK
            if HAS_PYAUTOGUI:
                x = self.boundsInScreen.centerX()
                y = self.boundsInScreen.centerY()
                pyautogui.click(x, y)
                return True
        elif action == 1:  # FOCUS
            self.focused = True
            return True
        elif action == 64:  # ACCESSIBILITY_FOCUS
            self.focused = True
            return True
        elif action == 4096:  # SCROLL_FORWARD
            if HAS_PYAUTOGUI:
                pyautogui.scroll(-5)
            return True
        elif action == 8192:  # SCROLL_BACKWARD
            if HAS_PYAUTOGUI:
                pyautogui.scroll(5)
            return True
        elif action == 128:  # CLEAR_ACCESSIBILITY_FOCUS
            self.focused = False
            return True
        return False

    def recycle(self) -> None:
        pass


class AccessibilityPage:
    """模拟当前页面的无障碍信息"""

    CLICK = 16
    LONG_CLICK = 32
    FOCUS = 1
    SCROLL_FORWARD = 4096
    SCROLL_BACKWARD = 8192
    ACCESSIBILITY_FOCUS = 64
    CLEAR_ACCESSIBILITY_FOCUS = 128

    def __init__(self):
        self._root = AccessibilityNodeInfo()
        self._build_fake_tree()

    def _build_fake_tree(self):
        """构建模拟的 UI 树"""
        self._root.className = "android.widget.FrameLayout"
        self._root.packageName = _package_name
        self._root.resourceName = f"{_package_name}:id/content"
        self._root.boundsInScreen = Rect(0, 0, 1920, 1080)
        self._root.depth = 0

        # 状态栏
        status_bar = AccessibilityNodeInfo()
        status_bar.className = "android.widget.LinearLayout"
        status_bar.resourceName = f"{_package_name}:id/statusBar"
        status_bar.boundsInScreen = Rect(0, 0, 1920, 80)
        self._root.addChild(status_bar)

        # 主内容区域
        content = AccessibilityNodeInfo()
        content.className = "android.widget.ScrollView"
        content.resourceName = f"{_package_name}:id/contentArea"
        content.boundsInScreen = Rect(0, 80, 1920, 1000)
        content.contentDescription = "主内容区域"
        self._root.addChild(content)

        # 底部导航
        nav = AccessibilityNodeInfo()
        nav.className = "android.widget.LinearLayout"
        nav.resourceName = f"{_package_name}:id/navigation"
        nav.boundsInScreen = Rect(0, 1000, 1920, 1080)
        self._root.addChild(nav)

        btn_home = AccessibilityNodeInfo()
        btn_home.className = "android.widget.Button"
        btn_home.text = "首页"
        btn_home.clickable = True
        btn_home.boundsInScreen = Rect(0, 1000, 640, 1080)
        nav.addChild(btn_home)

        btn_search = AccessibilityNodeInfo()
        btn_search.className = "android.widget.Button"
        btn_search.text = "搜索"
        btn_search.clickable = True
        btn_search.boundsInScreen = Rect(640, 1000, 1280, 1080)
        nav.addChild(btn_search)

        btn_profile = AccessibilityNodeInfo()
        btn_profile.className = "android.widget.Button"
        btn_profile.text = "我的"
        btn_profile.clickable = True
        btn_profile.boundsInScreen = Rect(1280, 1000, 1920, 1080)
        nav.addChild(btn_profile)

    def getRoot(self) -> AccessibilityNodeInfo:
        return self._root

    def findByText(self, text: str) -> Optional[AccessibilityNodeInfo]:
        return self._root.findByText(text)

    def findById(self, id_: str) -> Optional[AccessibilityNodeInfo]:
        return self._root.findById(id_)

    def refresh(self) -> bool:
        self._build_fake_tree()
        return True

    def getSystemWindows(self) -> List:
        return [self._root]

    def getWindows(self) -> List:
        return [self._root]


# ============================================================
#  android.hardware services
# ============================================================

class SensorManager:
    """模拟 android.hardware.SensorManager"""
    TYPE_ACCELEROMETER = 1
    TYPE_GYROSCOPE = 4
    TYPE_LIGHT = 5
    TYPE_PRESSURE = 6
    TYPE_PROXIMITY = 8
    TYPE_MAGNETIC_FIELD = 2

    def getDefaultSensor(self, type_: int):
        return Sensor(type_)

    def getSensorList(self, type_: int) -> List:
        if type_ == -1:
            return [Sensor(t) for t in range(1, 13)]
        return [Sensor(type_)] if type_ >= 1 else []

    def registerListener(self, listener, sensor, rate: int = 3) -> bool:
        return True

    def unregisterListener(self, listener, sensor=None) -> None:
        pass


class Sensor:
    def __init__(self, type_: int):
        self.type = type_
        self.name = {
            1: "Accelerometer", 4: "Gyroscope", 5: "Light",
            6: "Pressure", 8: "Proximity", 2: "Magnetic Field"
        }.get(type_, f"Sensor_{type_}")
        self.vendor = "OperitCompat"
        self.version = 1
        self.resolution = 0.01
        self.maximumRange = 100.0
        self.minDelay = 10000
        self.power = 0.1


class SensorEvent:
    def __init__(self, sensor: Sensor, values: List[float]):
        self.sensor = sensor
        self.values = values
        self.timestamp = int(time.time() * 1000000)
        self.accuracy = 3


class CameraManager:
    """模拟 android.hardware.camera2.CameraManager"""
    def getCameraIdList(self) -> List[str]:
        return ["0"]

    def getCameraCharacteristics(self, cameraId: str) -> "CameraCharacteristics":
        return CameraCharacteristics()

    def openCamera(self, cameraId: str, stateCallback, handler) -> None:
        pass


class CameraCharacteristics:
    def get(self, key: Any) -> Any:
        return None


# ============================================================
#  android.location
# ============================================================

class LocationManager:
    """模拟 android.location.LocationManager"""
    GPS_PROVIDER = "gps"
    NETWORK_PROVIDER = "network"
    PASSIVE_PROVIDER = "passive"

    def getLastKnownLocation(self, provider: str) -> Optional["Location"]:
        return self._get_fake_location()

    def getCurrentLocation(self, provider: str, result: Any = None, executor: Any = None) -> Optional["Location"]:
        return self._get_fake_location()

    def requestLocationUpdates(self, provider: str, minTimeMs: int,
                                minDistanceM: float, listener: Any) -> None:
        pass

    def removeUpdates(self, listener: Any) -> None:
        pass

    def isProviderEnabled(self, provider: str) -> bool:
        return True

    def getAllProviders(self) -> List[str]:
        return [self.GPS_PROVIDER, self.NETWORK_PROVIDER, self.PASSIVE_PROVIDER]

    def _get_fake_location(self) -> "Location":
        loc = Location("gps")
        loc._latitude = 39.9042 + random.random() * 0.01
        loc._longitude = 116.4074 + random.random() * 0.01
        loc._altitude = 43.0
        loc._accuracy = 10.0
        loc._time = int(time.time())
        loc._speed = 0.0
        loc._bearing = 0.0
        return loc


class Location:
    def __init__(self, provider: str = "gps"):
        self._provider = provider
        self._latitude = 0.0
        self._longitude = 0.0
        self._altitude = 0.0
        self._accuracy = 0.0
        self._time = 0
        self._speed = 0.0
        self._bearing = 0.0

    def getLatitude(self) -> float: return self._latitude
    def getLongitude(self) -> float: return self._longitude
    def getAltitude(self) -> float: return self._altitude
    def getAccuracy(self) -> float: return self._accuracy
    def getTime(self) -> int: return self._time
    def getSpeed(self) -> float: return self._speed
    def getBearing(self) -> float: return self._bearing
    def getProvider(self) -> str: return self._provider
    def distanceTo(self, dest: "Location") -> float:
        """Haversine 公式计算距离"""
        lat1, lon1 = math.radians(self._latitude), math.radians(self._longitude)
        lat2, lon2 = math.radians(dest._latitude), math.radians(dest._longitude)
        dlat, dlon = lat2 - lat1, lon2 - lon1
        a = math.sin(dlat/2)**2 + math.cos(lat1)*math.cos(lat2)*math.sin(dlon/2)**2
        return 2 * 6371000 * math.asin(math.sqrt(a))


class Geocoder:
    """模拟 android.location.Geocoder"""
    @staticmethod
    def getFromLocation(latitude: float, longitude: float, maxResults: int) -> List["Address"]:
        return [Address(latitude, longitude)]

    @staticmethod
    def getFromLocationName(locationName: str, maxResults: int) -> List["Address"]:
        return [Address(39.9042, 116.4074)]


class Address:
    def __init__(self, lat: float, lng: float):
        self.featureName = ""
        self.thoroughfare = ""
        self.locality = "Beijing"
        self.adminArea = "Beijing"
        self.countryName = "China"
        self.countryCode = "CN"
        self.postalCode = "100000"
        self.subAdminArea = ""
        self.subLocality = ""
        self.latitude = lat
        self.longitude = lng

    def getMaxAddressLineIndex(self) -> int:
        return 1

    def getAddressLine(self, index: int) -> str:
        return f"{self.locality}, {self.adminArea}, {self.countryName}"

    def getLocality(self) -> str: return self.locality
    def getAdminArea(self) -> str: return self.adminArea
    def getCountryName(self) -> str: return self.countryName


# ============================================================
#  android.media
# ============================================================

class MediaPlayer:
    """模拟 android.media.MediaPlayer"""
    def __init__(self):
        self._source = None
        self._volume = 1.0
        self._looping = False

    def setDataSource(self, path_or_uri) -> None: self._source = path_or_uri
    def setVolume(self, left: float, right: float) -> None: self._volume = (left + right) / 2
    def setLooping(self, looping: bool) -> None: self._looping = looping
    def prepare(self) -> None: pass
    def prepareAsync(self) -> None: pass
    def start(self) -> None:
        console.log(f"[MediaPlayer] 模拟播放: {self._source}")
    def stop(self) -> None: pass
    def pause(self) -> None: pass
    def release(self) -> None: pass
    def isPlaying(self) -> bool: return False
    def getDuration(self) -> int: return 0
    def getCurrentPosition(self) -> int: return 0
    def seekTo(self, msec: int) -> None: pass
    def reset(self) -> None: pass

    @staticmethod
    def create(context: Context, uri: Any) -> "MediaPlayer":
        return MediaPlayer()


class AudioRecord:
    """模拟 android.media.AudioRecord"""
    def __init__(self, audioSource, sampleRate, channelConfig, audioFormat, bufferSize):
        pass
    def startRecording(self) -> None: pass
    def stop(self) -> None: pass
    def read(self, audioData, offsetInBytes, sizeInBytes) -> int:
        return sizeInBytes
    def release(self) -> None: pass
    def getRecordingState(self) -> int: return 3  # RECORDSTATE_RECORDING
    def getState(self) -> int: return 1  # STATE_INITIALIZED


class AudioManager:
    """模拟 android.media.AudioManager"""
    RINGER_MODE_NORMAL = 2
    RINGER_MODE_SILENT = 0
    RINGER_MODE_VIBRATE = 1
    STREAM_MUSIC = 3
    STREAM_RING = 2
    STREAM_ALARM = 4
    STREAM_NOTIFICATION = 5

    def getStreamVolume(self, streamType: int) -> int:
        return 7
    def setStreamVolume(self, streamType: int, volume: int, flags: int) -> None: pass
    def getRingerMode(self) -> int: return self.RINGER_MODE_NORMAL
    def setRingerMode(self, mode: int) -> None: pass
    def adjustVolume(self, direction: int, flags: int) -> None: pass
    def isMusicActive(self) -> bool: return False


# ============================================================
#  android.telephony
# ============================================================

class TelephonyManager:
    """模拟 android.telephony.TelephonyManager"""
    def getDeviceId(self) -> str: return "000000000000000"
    def getImei(self) -> str: return "000000000000000"
    def getSimSerialNumber(self) -> str: return "000000000000000"
    def getNetworkOperatorName(self) -> str: return "Network"
    def getNetworkCountryIso(self) -> str: return "CN"
    def getPhoneType(self) -> int: return 0  # PHONE_TYPE_NONE
    def getDataState(self) -> int: return 2  # DATA_CONNECTED
    def getCallState(self) -> int: return 0  # CALL_STATE_IDLE
    def getSimState(self) -> int: return 5  # SIM_STATE_READY
    def hasIccCard(self) -> bool: return False
    def isNetworkRoaming(self) -> bool: return False
    def getNetworkType(self) -> int: return 13  # NETWORK_TYPE_LTE
    def getSignalStrength(self) -> int: return 4
    def listen(self, listener, events: int) -> None: pass


# ============================================================
#  android.provider 合约
# ============================================================

class Settings:
    """模拟 android.provider.Settings"""

    class System:
        @staticmethod
        def getString(cr: ContentResolver, name: str) -> str:
            return ""
        @staticmethod
        def putString(cr: ContentResolver, name: str, value: str) -> bool:
            return True
        @staticmethod
        def getInt(cr: ContentResolver, name: str, default: int = 0) -> int:
            return default

    class Secure:
        ANDROID_ID = "android_id"
        @staticmethod
        def getString(cr: ContentResolver, name: str) -> str:
            return hashlib.md5(b"operit_compat").hexdigest()[:16]

    class Global:
        @staticmethod
        def getString(cr: ContentResolver, name: str) -> str:
            return ""
        @staticmethod
        def putString(cr: ContentResolver, name: str, value: str) -> bool:
            return True


class MediaStore:
    """模拟 android.provider.MediaStore"""

    class Images:
        class Media:
            EXTERNAL_CONTENT_URI = Uri.parse("content://media/external/images/media")
            INTERNAL_CONTENT_URI = Uri.parse("content://media/internal/images/media")
            DATA = "_data"
            DISPLAY_NAME = "_display_name"
            SIZE = "_size"
            MIME_TYPE = "mime_type"
            TITLE = "title"
            DATE_ADDED = "date_added"
            DATE_MODIFIED = "date_modified"
            WIDTH = "width"
            HEIGHT = "height"
            ORIENTATION = "orientation"
            BUCKET_DISPLAY_NAME = "bucket_display_name"
            BUCKET_ID = "bucket_id"

    class Video:
        class Media:
            EXTERNAL_CONTENT_URI = Uri.parse("content://media/external/video/media")
            DATA = "_data"
            DISPLAY_NAME = "_display_name"
            SIZE = "_size"
            TITLE = "title"
            DURATION = "duration"
            DATE_ADDED = "date_added"

    class Audio:
        class Media:
            EXTERNAL_CONTENT_URI = Uri.parse("content://media/external/audio/media")
            DATA = "_data"
            TITLE = "title"
            ARTIST = "artist"
            ALBUM = "album"
            DURATION = "duration"

    class Files:
        class Media:
            EXTERNAL_CONTENT_URI = Uri.parse("content://media/external/files/media")


class CalendarContract:
    """模拟 android.provider.CalendarContract"""

    class Events:
        CONTENT_URI = Uri.parse("content://com.android.calendar/events")
        TITLE = "title"
        DESCRIPTION = "description"
        DTSTART = "dtstart"
        DTEND = "dtend"
        ALL_DAY = "allDay"
        EVENT_TIMEZONE = "eventTimezone"
        CALENDAR_ID = "calendar_id"
        RRULE = "rrule"
        DURATION = "duration"


class ContactsContract:
    """模拟 android.provider.ContactsContract"""

    class Contacts:
        CONTENT_URI = Uri.parse("content://com.android.contacts/contacts")
        DISPLAY_NAME = "display_name"
        HAS_PHONE_NUMBER = "has_phone_number"
        _ID = "_id"

    class CommonDataKinds:
        class Phone:
            CONTENT_URI = Uri.parse("content://com.android.contacts/data/phones")
            NUMBER = "data1"
            TYPE = "data2"
            LABEL = "data3"
            TYPE_HOME = 1
            TYPE_MOBILE = 2
            TYPE_WORK = 3

        class Email:
            CONTENT_URI = Uri.parse("content://com.android.contacts/data/emails")
            ADDRESS = "data1"
            TYPE = "data2"
            TYPE_HOME = 1
            TYPE_WORK = 2


# ============================================================
#  android.os.BatteryManager
# ============================================================

class BatteryManager:
    """模拟 android.os.BatteryManager"""
    BATTERY_PROPERTY_CAPACITY = 0
    BATTERY_PROPERTY_STATUS = 1
    STATUS_CHARGING = 2
    STATUS_DISCHARGING = 3
    STATUS_FULL = 5
    STATUS_NOT_CHARGING = 4

    def getIntProperty(self, id_: int) -> int:
        if id_ == self.BATTERY_PROPERTY_CAPACITY:
            return 85
        return self.STATUS_DISCHARGING

    def getLongProperty(self, id_: int) -> int:
        return 0


# ============================================================
#  android.net services
# ============================================================

class ConnectivityManager:
    """模拟 android.net.ConnectivityManager"""
    TYPE_WIFI = 1
    TYPE_MOBILE = 0
    TYPE_ETHERNET = 9
    TYPE_BLUETOOTH = 7

    def getActiveNetworkInfo(self) -> Optional["NetworkInfo"]:
        return NetworkInfo()

    def getAllNetworkInfo(self) -> List["NetworkInfo"]:
        return [NetworkInfo()]

    def isActiveNetworkMetered(self) -> bool:
        return False

    def getNetworkCapabilities(self, network) -> Optional["NetworkCapabilities"]:
        return NetworkCapabilities()


class NetworkInfo:
    def __init__(self):
        self._type = ConnectivityManager.TYPE_ETHERNET
        self._subtype = 0
        self._isConnected = True
        self._isAvailable = True
        self._typeName = "ETHERNET"
        self._subtypeName = ""
        self._state = "CONNECTED"
        self._reason = ""

    def getType(self) -> int: return self._type
    def getSubtype(self) -> int: return self._subtype
    def isConnected(self) -> bool: return self._isConnected
    def isConnectedOrConnecting(self) -> bool: return True
    def isAvailable(self) -> bool: return self._isAvailable
    def getTypeName(self) -> str: return self._typeName
    def getState(self) -> str: return self._state
    def getExtraInfo(self) -> str: return ""


class NetworkCapabilities:
    def hasCapability(self, cap: int) -> bool:
        return True
    def hasTransport(self, transport: int) -> bool:
        return True


class WifiManager:
    """模拟 android.net.wifi.WifiManager"""
    def getConnectionInfo(self) -> "WifiInfo":
        return WifiInfo()

    def startScan(self) -> bool:
        return True

    def getScanResults(self) -> List:
        return []

    def isWifiEnabled(self) -> bool:
        return True

    def setWifiEnabled(self, enabled: bool) -> bool:
        return True

    def isWifiEnabled(self) -> bool:
        return True


class WifiInfo:
    def __init__(self):
        self._ssid = "OperitCompat_Network"
        self._bssid = "00:00:00:00:00:00"
        self._rssi = -50
        self._linkSpeed = 300
        self._ipAddress = int.from_bytes(socket.inet_aton("192.168.1.100"), "big")
        self._networkId = 1

    def getSSID(self) -> str: return self._ssid
    def getBSSID(self) -> str: return self._bssid
    def getRssi(self) -> int: return self._rssi
    def getLinkSpeed(self) -> int: return self._linkSpeed
    def getIpAddress(self) -> int: return self._ipAddress
    def getNetworkId(self) -> int: return self._networkId
    def getSupplicantState(self) -> str: return "COMPLETED"

    def getMacAddress(self) -> str:
        import uuid
        return ":".join(f"{(uuid.getnode() >> (8 * i)) & 0xFF:02X}" for i in range(6))


# ============================================================
#  android.os.storage
# ============================================================

class StorageManager:
    """模拟 android.os.storage.StorageManager"""
    def getStorageVolumes(self) -> List:
        volumes = []
        vol = StorageVolume("Internal shared storage", _sdcard_root, True, False)
        volumes.append(vol)
        return volumes

    def getPrimaryStorageVolume(self) -> "StorageVolume":
        return StorageVolume("Internal shared storage", _sdcard_root, True, False)

    def getVolumeList(self) -> List:
        return self.getStorageVolumes()


class StorageVolume:
    def __init__(self, desc: str, path: str, primary: bool, removable: bool):
        self._description = desc
        self._path = path
        self._primary = primary
        self._removable = removable
        self._state = "mounted"
        self._uuid = hashlib.md5(path.encode()).hexdigest()
        self._maxFileSize = 4 * 1024 * 1024 * 1024 * 1024  # 4TB

    def getDescription(self, context: Context = None) -> str: return self._description
    def getPath(self) -> str: return self._path
    def isPrimary(self) -> bool: return self._primary
    def isRemovable(self) -> bool: return self._removable
    def getState(self) -> str: return self._state
    def getUuid(self) -> str: return self._uuid
    def getMaxFileSize(self) -> int: return self._maxFileSize
    def getUserLabel(self) -> str: return os.path.basename(self._path)


# ============================================================
#  android.view services
# ============================================================

class WindowManager:
    """模拟 android.view.WindowManager"""
    def getDefaultDisplay(self) -> "Display":
        return self._get_display()

    def _get_display(self) -> "Display":
        w, h = 1920, 1080
        if HAS_SCREENINFO:
            try:
                monitor = screeninfo.get_monitors()[0]
                w, h = monitor.width, monitor.height
            except Exception:
                pass
        return Display(w, h)

    def getCurrentWindowMetrics(self) -> "WindowMetrics":
        display = self._get_display()
        return WindowMetrics(Rect(0, 0, display._width, display._height))


class Display:
    def __init__(self, w: int = 1920, h: int = 1080):
        self._width = w
        self._height = h
        self._refreshRate = 60.0
        self._density = 2.0
        self._densityDpi = 320
        self._rotation = 0

    def getWidth(self) -> int: return self._width
    def getHeight(self) -> int: return self._height
    def getRefreshRate(self) -> float: return self._refreshRate
    def getRotation(self) -> int: return self._rotation
    def getRealSize(self, size: "Point") -> None:
        size.x, size.y = self._width, self._height
    def getSize(self, size: "Point") -> None:
        size.x, size.y = self._width, self._height

    class Metrics:
        def __init__(self):
            self.widthPixels = 1080
            self.heightPixels = 1920
            self.density = 2.0
            self.densityDpi = 320
            self.scaledDensity = 2.0
            self.xdpi = 320.0
            self.ydpi = 320.0

    def getMetrics(self, metrics: Metrics) -> None:
        metrics.widthPixels = self._width
        metrics.heightPixels = self._height
        metrics.density = self._density
        metrics.densityDpi = self._densityDpi


class WindowMetrics:
    def __init__(self, bounds: Rect):
        self._bounds = bounds

    def getBounds(self) -> Rect:
        return self._bounds


class Point:
    def __init__(self, x: int = 0, y: int = 0):
        self.x = x
        self.y = y

    def set(self, x: int, y: int) -> None:
        self.x = x
        self.y = y


class DisplayManager:
    def getDisplay(self, displayId: int) -> Optional[Display]:
        return Display()

    def getDisplays(self) -> List[Display]:
        return [Display()]

    def getDisplayByName(self, name: str) -> Optional[Display]:
        return Display()


class InputManager:
    """模拟 android.hardware.input.InputManager"""
    def injectInputEvent(self, event: Any, mode: int) -> bool:
        return True


class LayoutInflater:
    def inflate(self, resource, root: View) -> View:
        return View()


class ClipboardManager:
    """模拟 android.content.ClipboardManager"""

    def __init__(self):
        self._text = ""

    def setText(self, text: str) -> None:
        self._text = text
        import pyperclip as _pc
        _pc.copy(text)

    def getText(self) -> str:
        try:
            import pyperclip as _pc
            return _pc.paste()
        except Exception:
            return self._text

    def hasText(self) -> bool:
        return bool(self.getText())


class DownloadManager:
    """模拟 android.app.DownloadManager"""
    def enqueue(self, request: "DownloadManager.Request") -> int:
        return int(time.time())

    def query(self, query: "DownloadManager.Query") -> Cursor:
        return Cursor()

    class Request:
        def __init__(self, uri: Uri):
            self._uri = uri
            self._title = ""
            self._description = ""
            self._destination = ""
            self._allowedOverMetered = False
            self._allowedOverRoaming = False

        def setTitle(self, title: str) -> None: self._title = title
        def setDescription(self, desc: str) -> None: self._description = desc
        def setDestinationInExternalFilesDir(self, context: Context, dirType: str, subPath: str) -> None:
            self._destination = os.path.join(context.getExternalFilesDir(dirType), subPath)
        def setAllowedOverMetered(self, allow: bool) -> None: self._allowedOverMetered = allow
        def setAllowedOverRoaming(self, allow: bool) -> None: self._allowedOverRoaming = allow

    class Query:
        def setFilterById(self, *ids: int) -> None: pass


class Toast:
    """模拟 android.widget.Toast"""
    LENGTH_SHORT = 0
    LENGTH_LONG = 1

    @staticmethod
    def makeText(context: Context, text: str, duration: int) -> "Toast":
        return Toast(text)

    def __init__(self, text: str):
        self._text = text

    def show(self) -> None:
        console.log(f"[Toast] {self._text}")


# ============================================================
#  android.print
# ============================================================

class PrintManager:
    def print(self, jobName: str, documentAdapter: Any, attributes: Any = None) -> bool:
        return True


# ============================================================
#  android.accounts
# ============================================================

class AccountManager:
    """模拟 android.accounts.AccountManager"""
    def getAccounts(self) -> List:
        return [Account("user@operit.com", "com.google")]

    def getAccountsByType(self, type_: str) -> List:
        return [Account("user@operit.com", type_)]

    def addAccount(self, accountType: str, authTokenType: str, requiredFeatures: List,
                   addAccountAuthTokenType: str, options: Dict, activity: Any,
                   callback: Callable, handler: Any) -> "AccountManagerFuture":
        return AccountManagerFuture()


class Account:
    def __init__(self, name: str, type_: str):
        self.name = name
        self.type = type_

    def toString(self) -> str:
        return f"Account{{name={self.name}, type={self.type}}}"


class AccountManagerFuture:
    def getResult(self) -> Any:
        return None


# ============================================================
#  android.hardware.biometrics
# ============================================================

class BiometricPrompt:
    """模拟 android.hardware.biometrics.BiometricPrompt"""
    BIOMETRIC_STRONG = 15
    BIOMETRIC_WEAK = 255

    def authenticate(self, crypto: Any = None, cancel: Any = None) -> None:
        console.log("[BiometricPrompt] 模拟生物识别认证")
        if self._callback:
            self._callback.onAuthenticationSucceeded(
                BiometricPrompt.AuthenticationResult()
            )

    def setCallback(self, callback: "AuthenticationCallback") -> None:
        self._callback = callback

    class AuthenticationResult:
        def getAuthenticationType(self) -> int:
            return BiometricPrompt.BIOMETRIC_STRONG

    class AuthenticationCallback:
        def onAuthenticationError(self, errorCode: int, errString: str) -> None: pass
        def onAuthenticationSucceeded(self, result: "AuthenticationResult") -> None: pass
        def onAuthenticationFailed(self) -> None: pass


# ============================================================
#  DisplayMetrics 辅助类
# ============================================================

class DisplayMetrics:
    """辅助类"""
    def __init__(self):
        self.widthPixels = 1080
        self.heightPixels = 1920
        self.density = 2.0
        self.densityDpi = 320
        self.scaledDensity = 2.0
        self.xdpi = 320.0
        self.ydpi = 320.0


# ============================================================
#  java.io 兼容
# ============================================================

class File:
    """跨平台文件操作"""
    separator = os.sep

    def __init__(self, *args):
        self._path = ""
        if len(args) == 1:
            self._path = self._normalize(args[0])
        elif len(args) >= 2:
            self._path = self._normalize(os.path.join(args[0], *args[1:]))

    @staticmethod
    def _normalize(p: str) -> str:
        if p.startswith("/sdcard"):
            return os.path.join(_sdcard_root, p[7:].lstrip("/"))
        return p

    def getAbsolutePath(self) -> str:
        return os.path.abspath(self._path)

    def getName(self) -> str:
        return os.path.basename(self._path)

    def getParent(self) -> str:
        return os.path.dirname(self._path)

    def exists(self) -> bool:
        return os.path.exists(self._path)

    def isFile(self) -> bool:
        return os.path.isfile(self._path)

    def isDirectory(self) -> bool:
        return os.path.isdir(self._path)

    def length(self) -> int:
        return os.path.getsize(self._path) if os.path.isfile(self._path) else 0

    def list(self) -> List[str]:
        return os.listdir(self._path) if os.path.isdir(self._path) else []

    def listFiles(self) -> List["File"]:
        return [File(p) for p in (os.listdir(self._path) if os.path.isdir(self._path) else [])]

    def mkdir(self) -> bool:
        try:
            os.mkdir(self._path)
            return True
        except Exception:
            return False

    def mkdirs(self) -> bool:
        try:
            os.makedirs(self._path, exist_ok=True)
            return True
        except Exception:
            return False

    def delete(self) -> bool:
        try:
            if os.path.isfile(self._path):
                os.remove(self._path)
            elif os.path.isdir(self._path):
                os.rmdir(self._path)
            return True
        except Exception:
            return False

    def renameTo(self, dest: "File") -> bool:
        try:
            os.rename(self._path, dest._path)
            return True
        except Exception:
            return False

    def lastModified(self) -> int:
        return int(os.path.getmtime(self._path) * 1000) if os.path.exists(self._path) else 0

    def canRead(self) -> bool:
        return os.access(self._path, os.R_OK)

    def canWrite(self) -> bool:
        return os.access(self._path, os.W_OK)

    def canExecute(self) -> bool:
        return os.access(self._path, os.X_OK)

    def getFreeSpace(self) -> int:
        stat = os.statvfs(self._path) if hasattr(os, "statvfs") else None
        if stat:
            return stat.f_bavail * stat.f_frsize
        return 1024 * 1024 * 1024 * 50  # 50GB

    def getTotalSpace(self) -> int:
        return 1024 * 1024 * 1024 * 256  # 256GB

    def toPath(self) -> str:
        return self._path

    def toURI(self) -> str:
        return Uri.fromFile(self._path).toString()

    def __str__(self):
        return self._path

    @staticmethod
    def createTempFile(prefix: str, suffix: str) -> "File":
        fd, path = tempfile.mkstemp(suffix=suffix, prefix=prefix)
        os.close(fd)
        return File(path)


class FileInputStream:
    def __init__(self, file_or_path):
        if isinstance(file_or_path, File):
            self._path = file_or_path._path
        else:
            self._path = str(file_or_path)
        self._file = open(self._path, "rb")

    def read(self, length: int = -1) -> bytes:
        return self._file.read(length) if length >= 0 else self._file.read()

    def available(self) -> int:
        import stat
        return os.stat(self._path).st_size - self._file.tell()

    def close(self) -> None:
        self._file.close()


class FileOutputStream:
    def __init__(self, file_or_path, append: bool = False):
        if isinstance(file_or_path, File):
            self._path = file_or_path._path
        else:
            self._path = str(file_or_path)
        self._file = open(self._path, "ab" if append else "wb")

    def write(self, data) -> None:
        if isinstance(data, bytes):
            self._file.write(data)
        elif isinstance(data, str):
            self._file.write(data.encode("utf-8"))
        else:
            self._file.write(bytes([data]))

    def flush(self) -> None:
        self._file.flush()

    def close(self) -> None:
        self._file.close()


class BufferedReader:
    def __init__(self, reader, buffer_size: int = 8192):
        self._reader = reader
        self._buffer = ""

    def readLine(self) -> Optional[str]:
        lines = self._reader.read().split("\n")
        if lines:
            return lines[0]
        return None

    def read(self) -> str:
        return self._reader.read()

    def close(self) -> None:
        self._reader.close()


class InputStreamReader:
    def __init__(self, stream, charset: str = "UTF-8"):
        self._stream = stream
        self._charset = charset

    def read(self, length: int = -1) -> str:
        data = self._stream.read(length)
        return data.decode(self._charset) if isinstance(data, bytes) else data

    def close(self) -> None:
        self._stream.close()


class OutputStreamWriter:
    def __init__(self, stream, charset: str = "UTF-8"):
        self._stream = stream
        self._charset = charset

    def write(self, text: str) -> None:
        self._stream.write(text.encode(self._charset))

    def flush(self) -> None:
        self._stream.flush()

    def close(self) -> None:
        self._stream.close()


class BufferedWriter:
    def __init__(self, writer, buffer_size: int = 8192):
        self._writer = writer
        self._buffer = ""

    def write(self, text: str) -> None:
        self._writer.write(text)

    def newLine(self) -> None:
        self._writer.write("\n")

    def flush(self) -> None:
        self._writer.flush()

    def close(self) -> None:
        self._writer.close()


# ============================================================
#  通用辅助工具
# ============================================================

class Log:
    """android.util.Log"""
    ASSERT = 7
    DEBUG = 3
    ERROR = 6
    INFO = 4
    VERBOSE = 2
    WARN = 5

    @staticmethod
    def d(tag: str, msg: str) -> int:
        print(f"DEBUG/{tag}: {msg}")
        return 0

    @staticmethod
    def e(tag: str, msg: str) -> int:
        print(f"ERROR/{tag}: {msg}", file=sys.stderr)
        return 0

    @staticmethod
    def i(tag: str, msg: str) -> int:
        print(f"INFO/{tag}: {msg}")
        return 0

    @staticmethod
    def w(tag: str, msg: str) -> int:
        print(f"WARN/{tag}: {msg}")
        return 0

    @staticmethod
    def v(tag: str, msg: str) -> int:
        print(f"VERBOSE/{tag}: {msg}")
        return 0

    @staticmethod
    def wtf(tag: str, msg: str) -> int:
        print(f"WTF/{tag}: {msg}", file=sys.stderr)
        return 0


class Bundle:
    """android.os.Bundle"""
    def __init__(self):
        self._data: Dict[str, Any] = {}

    def getString(self, key: str, default: str = None) -> Optional[str]:
        return str(self._data.get(key, default)) if default or key in self._data else self._data.get(key)

    def getInt(self, key: str, default: int = 0) -> int:
        return int(self._data.get(key, default))

    def getBoolean(self, key: str, default: bool = False) -> bool:
        return bool(self._data.get(key, default))

    def putString(self, key: str, value: str) -> None:
        self._data[key] = value

    def putInt(self, key: str, value: int) -> None:
        self._data[key] = value

    def putBoolean(self, key: str, value: bool) -> None:
        self._data[key] = value

    def containsKey(self, key: str) -> bool:
        return key in self._data

    def isEmpty(self) -> bool:
        return len(self._data) == 0

    def size(self) -> int:
        return len(self._data)

    def keySet(self) -> set:
        return set(self._data.keys())


class Handler:
    """android.os.Handler"""
    def __init__(self, callback: Callable = None):
        self._callback = callback

    def post(self, action: Callable) -> bool:
        action()
        return True

    def postDelayed(self, action: Callable, delayMs: int) -> bool:
        import threading
        timer = threading.Timer(delayMs / 1000, action)
        timer.start()
        return True

    def removeCallbacks(self, action: Callable = None) -> None:
        pass

    def obtainMessage(self, what: int = 0, arg1: int = 0, arg2: int = 0, obj: Any = None) -> "Message":
        return Message(what, arg1, arg2, obj)


class Message:
    def __init__(self, what: int = 0, arg1: int = 0, arg2: int = 0, obj: Any = None):
        self.what = what
        self.arg1 = arg1
        self.arg2 = arg2
        self.obj = obj

    def sendToTarget(self) -> None:
        pass


class Looper:
    """android.os.Looper"""
    @staticmethod
    def getMainLooper() -> "Looper":
        return Looper()

    @staticmethod
    def myLooper() -> Optional["Looper"]:
        return Looper()

    @staticmethod
    def prepare() -> None:
        pass

    @staticmethod
    def loop() -> None:
        pass

    def quit(self) -> None:
        pass


class ParcelFileDescriptor:
    """android.os.ParcelFileDescriptor"""
    MODE_READ_ONLY = 0x10000000
    MODE_WRITE_ONLY = 0x20000000
    MODE_READ_WRITE = 0x30000000

    @staticmethod
    def open(file: File, mode: int) -> "ParcelFileDescriptor":
        return ParcelFileDescriptor(file)

    def __init__(self, file: File = None):
        self._file = file

    def getFileDescriptor(self) -> Any:
        return None

    def close(self) -> None:
        pass

    @staticmethod
    def parseUri(uri: Uri, mode: int) -> "ParcelFileDescriptor":
        return ParcelFileDescriptor()


# ============================================================
#  AndroidUtil - 常用工具函数桥接
# ============================================================

class AndroidUtil:
    """将 Android 路径映射到桌面路径的工具类"""

    @staticmethod
    def resolve_path(path: str) -> str:
        """解析 Android 路径到桌面路径"""
        if path.startswith("/sdcard"):
            return os.path.join(_sdcard_root, path[7:].lstrip("/"))
        if path.startswith("content://"):
            uri = Uri.parse(path)
            return uri.getPath()
        if path.startswith("file://"):
            return urllib.parse.unquote(path[7:])
        return path

    @staticmethod
    def to_android_path(desktop_path: str) -> str:
        """将桌面路径映射回 Android 路径"""
        if desktop_path.startswith(_sdcard_root):
            return desktop_path.replace(_sdcard_root, "/sdcard")
        return desktop_path

    @staticmethod
    def get_app_draw_dir(name: str) -> str:
        """获取应用绘图输出目录（桌面版）"""
        path = os.path.join(_sdcard_root, "Download", "Operit", "plugins", "draw", name, "draws")
        os.makedirs(path, exist_ok=True)
        return path

    @staticmethod
    def save_image_to_draw_dir(script_name: str, data: bytes, ext: str = "png") -> str:
        """保存图片到绘图目录"""
        dir_path = AndroidUtil.get_app_draw_dir(script_name)
        filename = f"{int(time.time() * 1000)}_{random.randint(1000,9999)}.{ext}"
        filepath = os.path.join(dir_path, filename)
        with open(filepath, "wb") as f:
            f.write(data)
        return filepath


# ═══════════════════════════════════════════════════════════════
#  GLOBAL INSTANCE - 单例上下文
# ═══════════════════════════════════════════════════════════════

# 全局应用上下文
application_context = Context(_package_name)

# 全局 Java.type 桥接（只在 jpype 可用时有效）
_jpype_available = False
try:
    import jpype
    import jpype.imports
    _jpype_available = True
except ImportError:
    pass


def java_type(class_name: str) -> Any:
    """
    模拟 Java.type() 调用。
    如果安装了 jpype，则尝试真实加载 Java 类；
    否则返回 AndroidUnsupportedStub。
    """
    if _jpype_available and jpype.isJVMStarted():
        try:
            return jpype.JClass(class_name)
        except Exception:
            pass
    return AndroidUnsupportedStub


class AndroidUnsupportedStub:
    """
    通用 Android 不支持存根。
    替换所有无法在桌面端实现的 Java 类。
    任何方法调用都返回自身，支持链式调用。
    """
    def __init__(self, *args, **kwargs):
        self._name = self.__class__.__name__

    def __getattr__(self, name: str) -> "AndroidUnsupportedStub":
        if name.startswith("_"):
            raise AttributeError(name)
        return AndroidUnsupportedStub()

    def __call__(self, *args, **kwargs) -> "AndroidUnsupportedStub":
        return self

    def __repr__(self) -> str:
        return f"<AndroidUnsupportedStub: {self._name}>"

    def __str__(self) -> str:
        return f"[Android-only]"

    # 模拟常见返回类型
    def toString(self) -> str:
        return f"[Android-only: {self._name}]"

    def intValue(self) -> int:
        return 0

    def longValue(self) -> int:
        return 0

    def booleanValue(self) -> bool:
        return False

    def doubleValue(self) -> float:
        return 0.0

    def get(self, *args) -> "AndroidUnsupportedStub":
        return self

    def length(self) -> int:
        return 0

    def size(self) -> int:
        return 0

    def isEmpty(self) -> bool:
        return True

    def close(self) -> None:
        pass

    def release(self) -> None:
        pass

    def recycle(self) -> None:
        pass


# 全局别名 - 让脚本中的 `Java.type("xxx")` 可以直接调用
Java = type("Java", (), {"type": staticmethod(java_type)})


# ═══════════════════════════════════════════════════════════════
#  导出给 operit_runtime.py 的重要对象
# ═══════════════════════════════════════════════════════════════

def get_android_compat_globals() -> dict:
    """返回要注入到脚本命名空间的 Android 兼容对象"""
    return {
        # android 核心包
        "Context": Context,
        "Intent": Intent,
        "IntentAction": IntentAction,
        "BroadcastReceiver": BroadcastReceiver,
        "IntentFilter": IntentFilter,
        "ContentValues": ContentValues,
        "ContentResolver": ContentResolver,
        "Cursor": Cursor,
        "Uri": Uri,
        "Uri_parse": Uri.parse,
        "Uri_fromFile": Uri.fromFile,

        # android.os
        "Build": Build,
        "Environment": Environment,
        "BatteryManager": BatteryManager,
        "PowerManager": PowerManager,
        "WakeLock": WakeLock,
        "VibrationEffect": VibrationEffect,
        "Vibrator": Vibrator,
        "Bundle": Bundle,
        "Handler": Handler,
        "Message": Message,
        "Looper": Looper,
        "ParcelFileDescriptor": ParcelFileDescriptor,

        # android.graphics
        "Bitmap": Bitmap,
        "BitmapFactory": BitmapFactory,
        "Bitmap_Config": Bitmap.Config,
        "Canvas": Canvas,
        "Color": Color,
        "Paint": Paint,
        "Rect": Rect,
        "Matrix": Matrix,
        "Typeface": Typeface,

        # android.graphics.pdf
        "PdfRenderer": PdfRenderer,

        # android.app
        "ActivityManager": ActivityManager,
        "NotificationManager": NotificationManager,
        "NotificationChannel": NotificationChannel,
        "AlarmManager": AlarmManager,
        "DownloadManager": DownloadManager,

        # android.view
        "View": View,
        "TextView": TextView,
        "EditText": EditText,
        "Button": Button,
        "ImageView": ImageView,
        "ScrollView": ScrollView,
        "RecyclerView": RecyclerView,
        "ViewGroup": ViewGroup,
        "LinearLayout": LinearLayout,
        "FrameLayout": FrameLayout,
        "RelativeLayout": RelativeLayout,
        "WindowManager": WindowManager,
        "Display": Display,
        "DisplayMetrics": DisplayMetrics,
        "Point": Point,
        "InputManager": InputManager,
        "LayoutInflater": LayoutInflater,
        "ClipboardManager": ClipboardManager,
        "WindowMetrics": WindowMetrics,

        # android.content.pm
        "PackageManager": PackageManager,
        "PackageInfo": PackageInfo,
        "ResolveInfo": ResolveInfo,
        "ActivityInfo": ActivityInfo,
        "ApplicationInfo": ApplicationInfo,
        "SharedPreferences": SharedPreferences,

        # android.provider
        "Settings": Settings,
        "MediaStore": MediaStore,
        "CalendarContract": CalendarContract,
        "ContactsContract": ContactsContract,

        # android.location
        "LocationManager": LocationManager,
        "Location": Location,
        "Geocoder": Geocoder,

        # android.media
        "MediaPlayer": MediaPlayer,
        "AudioRecord": AudioRecord,
        "AudioManager": AudioManager,

        # android.hardware
        "SensorManager": SensorManager,
        "Sensor": Sensor,
        "SensorEvent": SensorEvent,
        "CameraManager": CameraManager,
        "BiometricPrompt": BiometricPrompt,

        # android.net
        "ConnectivityManager": ConnectivityManager,
        "NetworkInfo": NetworkInfo,
        "NetworkCapabilities": NetworkCapabilities,
        "WifiManager": WifiManager,
        "WifiInfo": WifiInfo,

        # android.os.storage
        "StorageManager": StorageManager,
        "StorageVolume": StorageVolume,

        # android.telephony
        "TelephonyManager": TelephonyManager,

        # android.widget
        "Toast": Toast,

        # android.print
        "PrintManager": PrintManager,

        # android.accounts
        "AccountManager": AccountManager,
        "Account": Account,

        # android.util
        "Log": Log,

        # java.io
        "File": File,
        "FileInputStream": FileInputStream,
        "FileOutputStream": FileOutputStream,
        "BufferedReader": BufferedReader,
        "BufferedWriter": BufferedWriter,
        "InputStreamReader": InputStreamReader,
        "OutputStreamWriter": OutputStreamWriter,

        # 辅助工具
        "AndroidUtil": AndroidUtil,
        "AndroidUnsupportedStub": AndroidUnsupportedStub,

        # Java 桥接
        "Java": Java,

        # UINode 自动化
        "UINode": UINode,
        "AccessibilityNodeInfo": AccessibilityNodeInfo,
        "AccessibilityPage": AccessibilityPage,

        # 运行时对象
        "androidContext": application_context,

        # Android 路径常量
        "SANDBOX_EXTERNAL_PACKAGES_DIR": os.path.join(_sdcard_root, "Android", "data",
                                                        _package_name, "files", "packages"),
        "SDCARD_ROOT": _sdcard_root,
        "EXTERNAL_STORAGE": _sdcard_root,
    }