1660 lines
48 KiB
Python
1660 lines
48 KiB
Python
"""
|
|
Android OS 组件 — Bundle, Handler, Looper, Message, Build 等
|
|
方法签名完全对齐 Android SDK
|
|
"""
|
|
|
|
import asyncio
|
|
import functools
|
|
import heapq
|
|
import os as _os
|
|
import sys
|
|
import threading
|
|
import time as _time
|
|
from datetime import datetime
|
|
from typing import Any, Callable, Dict, List, Optional, Set, Tuple, TypeVar, Union
|
|
|
|
from .._core import (
|
|
Stub, AndroidOnlyError, android_context,
|
|
resolve_android_path, to_android_path,
|
|
_sdcard_root, _app_data_dir, _package_name,
|
|
HAS_PSUTIL,
|
|
)
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# Build
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
class Build(Stub):
|
|
"""Build — 设备信息"""
|
|
|
|
class VERSION(Stub):
|
|
"""版本信息"""
|
|
SDK_INT = 34 # Android 14
|
|
RELEASE = "14"
|
|
INCREMENTAL = "20240301"
|
|
CODENAME = "REL"
|
|
SECURITY_PATCH = "2024-03-05"
|
|
BASE_OS = ""
|
|
PREVIEW_SDK_INT = 0
|
|
RESOURCES_SDK_INT = 34
|
|
MEDIA_PERFORMANCE_CLASS = 0
|
|
|
|
class VERSION_CODES(Stub):
|
|
"""版本代码常量"""
|
|
BASE = 1
|
|
BASE_1_1 = 2
|
|
CUPCAKE = 3
|
|
DONUT = 4
|
|
ECLAIR = 5
|
|
ECLAIR_0_1 = 6
|
|
ECLAIR_MR1 = 7
|
|
FROYO = 8
|
|
GINGERBREAD = 9
|
|
GINGERBREAD_MR1 = 10
|
|
HONEYCOMB = 11
|
|
HONEYCOMB_MR1 = 12
|
|
HONEYCOMB_MR2 = 13
|
|
ICE_CREAM_SANDWICH = 14
|
|
ICE_CREAM_SANDWICH_MR1 = 15
|
|
JELLY_BEAN = 16
|
|
JELLY_BEAN_MR1 = 17
|
|
JELLY_BEAN_MR2 = 18
|
|
KITKAT = 19
|
|
KITKAT_WATCH = 20
|
|
LOLLIPOP = 21
|
|
LOLLIPOP_MR1 = 22
|
|
M = 23
|
|
N = 24
|
|
N_MR1 = 25
|
|
O = 26
|
|
O_MR1 = 27
|
|
P = 28
|
|
Q = 29
|
|
R = 30
|
|
S = 31
|
|
S_V2 = 32
|
|
TIRAMISU = 33
|
|
UPSIDE_DOWN_CAKE = 34
|
|
|
|
VERSION = VERSION()
|
|
BOARD = "redfin"
|
|
BOOTLOADER = "r7.0-12345"
|
|
BRAND = "google"
|
|
CPU_ABI = "arm64-v8a"
|
|
CPU_ABI2 = ""
|
|
DEVICE = "redfin"
|
|
DISPLAY = "AP1A.240305.001"
|
|
FINGERPRINT = "google/redfin/redfin:14/AP1A.240305.001/12345678:user/release-keys"
|
|
HARDWARE = "redfin"
|
|
HOST = "build-test-01"
|
|
ID = "AP1A.240305.001"
|
|
MANUFACTURER = "Google"
|
|
MODEL = "Pixel 5"
|
|
ODM_SKU = None
|
|
PRODUCT = "redfin"
|
|
RADIO = ""
|
|
SERIAL = "unknown"
|
|
SKU = None
|
|
SOC_MANUFACTURER = "Qualcomm"
|
|
SOC_MODEL = "Snapdragon 765G"
|
|
SUPPORTED_32_BIT_ABIS = ["armeabi-v7a", "armeabi"]
|
|
SUPPORTED_64_BIT_ABIS = ["arm64-v8a"]
|
|
SUPPORTED_ABIS = ["arm64-v8a", "armeabi-v7a", "armeabi"]
|
|
TAGS = "release-keys"
|
|
TIME = int(_time.time() * 1000)
|
|
TYPE = "user"
|
|
USER = "build-user"
|
|
|
|
@staticmethod
|
|
def getRadioVersion() -> str:
|
|
return ""
|
|
|
|
@staticmethod
|
|
def getSerial() -> str:
|
|
return "unknown"
|
|
|
|
@staticmethod
|
|
def getFingerprint() -> str:
|
|
return Build.FINGERPRINT
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# SystemClock
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
class SystemClock(Stub):
|
|
"""SystemClock — 系统时钟"""
|
|
|
|
@staticmethod
|
|
def elapsedRealtime() -> int:
|
|
"""返回自启动以来的毫秒数"""
|
|
return int(_time.monotonic() * 1000)
|
|
|
|
@staticmethod
|
|
def elapsedRealtimeNanos() -> int:
|
|
return int(_time.monotonic_ns())
|
|
|
|
@staticmethod
|
|
def uptimeMillis() -> int:
|
|
"""返回自启动以来（不含深度睡眠）的毫秒数"""
|
|
return int(_time.monotonic() * 1000)
|
|
|
|
@staticmethod
|
|
def currentThreadTimeMillis() -> int:
|
|
return int(_time.clock_gettime(_time.CLOCK_THREAD_CPUTIME_ID) * 1000)
|
|
|
|
@staticmethod
|
|
def sleep(ms: int):
|
|
_time.sleep(ms / 1000.0)
|
|
|
|
@staticmethod
|
|
def setCurrentTimeMillis(millis: int) -> bool:
|
|
return False
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# Environment
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
class Environment(Stub):
|
|
"""Environment — 环境目录"""
|
|
|
|
MEDIA_BAD_REMOVAL = "bad_removal"
|
|
MEDIA_CHECKING = "checking"
|
|
MEDIA_EJECTING = "ejecting"
|
|
MEDIA_MOUNTED = "mounted"
|
|
MEDIA_MOUNTED_READ_ONLY = "mounted_ro"
|
|
MEDIA_NOFS = "nofs"
|
|
MEDIA_REMOVED = "removed"
|
|
MEDIA_SHARED = "shared"
|
|
MEDIA_UNKNOWN = "unknown"
|
|
MEDIA_UNMOUNTABLE = "unmountable"
|
|
MEDIA_UNMOUNTED = "unmounted"
|
|
|
|
DIRECTORY_ALARMS = "Alarms"
|
|
DIRECTORY_DCIM = "DCIM"
|
|
DIRECTORY_DOCUMENTS = "Documents"
|
|
DIRECTORY_DOWNLOADS = "Download"
|
|
DIRECTORY_MOVIES = "Movies"
|
|
DIRECTORY_MUSIC = "Music"
|
|
DIRECTORY_NOTIFICATIONS = "Notifications"
|
|
DIRECTORY_PICTURES = "Pictures"
|
|
DIRECTORY_PODCASTS = "Podcasts"
|
|
DIRECTORY_RINGTONES = "Ringtones"
|
|
DIRECTORY_AUDIOBOOKS = "Audiobooks"
|
|
DIRECTORY_SCREENSHOTS = "Screenshots"
|
|
|
|
@staticmethod
|
|
def getExternalStorageDirectory() -> str:
|
|
return _sdcard_root
|
|
|
|
@staticmethod
|
|
def getExternalStoragePublicDirectory(type_: str) -> str:
|
|
path = _os.path.join(_sdcard_root, type_)
|
|
_os.makedirs(path, exist_ok=True)
|
|
return path
|
|
|
|
@staticmethod
|
|
def getDataDirectory() -> str:
|
|
return _os.path.join(_app_data_dir, "data")
|
|
|
|
@staticmethod
|
|
def getDownloadCacheDirectory() -> str:
|
|
return _os.path.join(_app_data_dir, "cache", "download")
|
|
|
|
@staticmethod
|
|
def getRootDirectory() -> str:
|
|
return _os.path.abspath(_os.sep)
|
|
|
|
@staticmethod
|
|
def getStorageDirectory(user_handle: Any = None) -> str:
|
|
return _sdcard_root
|
|
|
|
@staticmethod
|
|
def getExternalStorageState(path: Optional[str] = None) -> str:
|
|
return Environment.MEDIA_MOUNTED
|
|
|
|
@staticmethod
|
|
def isExternalStorageRemovable(path: Optional[str] = None) -> bool:
|
|
return False
|
|
|
|
@staticmethod
|
|
def isExternalStorageEmulated(path: Optional[str] = None) -> bool:
|
|
return True
|
|
|
|
@staticmethod
|
|
def isExternalStorageLegacy(path: Optional[str] = None) -> bool:
|
|
return True
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# Process
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
class Process(Stub):
|
|
"""Process — 进程信息"""
|
|
|
|
# 进程优先级
|
|
THREAD_PRIORITY_DEFAULT = 0
|
|
THREAD_PRIORITY_LOWEST = -19
|
|
THREAD_PRIORITY_BACKGROUND = 10
|
|
THREAD_PRIORITY_FOREGROUND = -2
|
|
THREAD_PRIORITY_DISPLAY = -4
|
|
THREAD_PRIORITY_URGENT_DISPLAY = -8
|
|
THREAD_PRIORITY_AUDIO = -16
|
|
THREAD_PRIORITY_URGENT_AUDIO = -19
|
|
THREAD_PRIORITY_MORE_FAVORABLE = -1
|
|
THREAD_PRIORITY_LESS_FAVORABLE = 1
|
|
|
|
SIGNAL_KILL = 9
|
|
SIGNAL_QUIT = 3
|
|
SIGNAL_USR1 = 10
|
|
SIGNAL_USR2 = 12
|
|
|
|
@staticmethod
|
|
def myTid() -> int:
|
|
return threading.get_ident()
|
|
|
|
@staticmethod
|
|
def myUid() -> int:
|
|
return 10001
|
|
|
|
@staticmethod
|
|
def myPid() -> int:
|
|
return _os.getpid()
|
|
|
|
@staticmethod
|
|
def killProcess(pid: int):
|
|
pass
|
|
|
|
@staticmethod
|
|
def sendSignal(pid: int, signal: int):
|
|
pass
|
|
|
|
@staticmethod
|
|
def setThreadPriority(priority: int):
|
|
pass
|
|
|
|
@staticmethod
|
|
def setThreadPriority(tid: int, priority: int):
|
|
pass
|
|
|
|
@staticmethod
|
|
def getElapsedCpuTime() -> int:
|
|
return int(_time.clock_gettime(_time.CLOCK_PROCESS_CPUTIME_ID) * 1000)
|
|
|
|
@staticmethod
|
|
def supportsProcesses() -> bool:
|
|
return True
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# BaseBundle / PersistableBundle
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
class BaseBundle(Stub):
|
|
"""BaseBundle — Bundle 基类"""
|
|
|
|
def __init__(self):
|
|
super().__init__()
|
|
self._map: Dict[str, Any] = {}
|
|
self._class_loader = None
|
|
|
|
def getString(self, key: str, default: Optional[str] = None) -> Optional[str]:
|
|
v = self._map.get(key, default)
|
|
return str(v) if v is not None else default
|
|
|
|
def getInt(self, key: str, default: int = 0) -> int:
|
|
v = self._map.get(key, default)
|
|
try:
|
|
return int(v) if v is not None else default
|
|
except (ValueError, TypeError):
|
|
return default
|
|
|
|
def getLong(self, key: str, default: int = 0) -> int:
|
|
return self.getInt(key, default)
|
|
|
|
def getFloat(self, key: str, default: float = 0.0) -> float:
|
|
v = self._map.get(key, default)
|
|
try:
|
|
return float(v) if v is not None else default
|
|
except (ValueError, TypeError):
|
|
return default
|
|
|
|
def getDouble(self, key: str, default: float = 0.0) -> float:
|
|
return self.getFloat(key, default)
|
|
|
|
def getBoolean(self, key: str, default: bool = False) -> bool:
|
|
v = self._map.get(key, default)
|
|
if isinstance(v, bool):
|
|
return v
|
|
if isinstance(v, str):
|
|
return v.lower() in ("true", "1", "yes")
|
|
return bool(v) if v is not None else default
|
|
|
|
def getByte(self, key: str, default: int = 0) -> int:
|
|
return self.getInt(key, default)
|
|
|
|
def getChar(self, key: str, default: str = "") -> str:
|
|
return str(self._map.get(key, default))
|
|
|
|
def getShort(self, key: str, default: int = 0) -> int:
|
|
return self.getInt(key, default)
|
|
|
|
def getCharSequence(self, key: str, default: Optional[str] = None) -> Optional[str]:
|
|
return self.getString(key, default)
|
|
|
|
def getSerializable(self, key: str, default: Any = None) -> Any:
|
|
return self._map.get(key, default)
|
|
|
|
def getStringArrayList(self, key: str) -> Optional[List[str]]:
|
|
v = self._map.get(key)
|
|
if isinstance(v, list):
|
|
return [str(x) for x in v]
|
|
return None
|
|
|
|
def getIntegerArrayList(self, key: str) -> Optional[List[int]]:
|
|
v = self._map.get(key)
|
|
if isinstance(v, list):
|
|
return [int(x) for x in v if isinstance(x, (int, float))]
|
|
return None
|
|
|
|
def containsKey(self, key: str) -> bool:
|
|
return key in self._map
|
|
|
|
def isEmpty(self) -> bool:
|
|
return len(self._map) == 0
|
|
|
|
def size(self) -> int:
|
|
return len(self._map)
|
|
|
|
def clear(self):
|
|
self._map.clear()
|
|
|
|
def keySet(self) -> Set[str]:
|
|
return set(self._map.keys())
|
|
|
|
def hasKey(self, key: str) -> bool:
|
|
return key in self._map
|
|
|
|
def toString(self) -> str:
|
|
return f"Bundle({self._map})"
|
|
|
|
def __len__(self) -> int:
|
|
return len(self._map)
|
|
|
|
def __contains__(self, key: str) -> bool:
|
|
return key in self._map
|
|
|
|
def __getitem__(self, key: str):
|
|
return self._map[key]
|
|
|
|
def __setitem__(self, key: str, value: Any):
|
|
self._map[key] = value
|
|
|
|
def __delitem__(self, key: str):
|
|
self._map.pop(key, None)
|
|
|
|
|
|
class PersistableBundle(BaseBundle):
|
|
"""PersistableBundle — 可持久化的 Bundle"""
|
|
|
|
def __init__(self, capacity: int = 0):
|
|
super().__init__()
|
|
|
|
def putPersistableBundle(self, key: str, value: "PersistableBundle"):
|
|
self._map[key] = value
|
|
|
|
def getPersistableBundle(self, key: str) -> Optional["PersistableBundle"]:
|
|
v = self._map.get(key)
|
|
return v if isinstance(v, PersistableBundle) else None
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# Bundle
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
class Bundle(BaseBundle):
|
|
"""Bundle — 键值对数据容器"""
|
|
|
|
EMPTY: "Bundle" = None # 在类加载后初始化
|
|
|
|
def __init__(self, capacity: int = 0):
|
|
super().__init__()
|
|
self._capacity = capacity
|
|
|
|
def putString(self, key: str, value: Optional[str]):
|
|
self._map[key] = value
|
|
|
|
def putInt(self, key: str, value: int):
|
|
self._map[key] = value
|
|
|
|
def putLong(self, key: str, value: int):
|
|
self._map[key] = value
|
|
|
|
def putFloat(self, key: str, value: float):
|
|
self._map[key] = value
|
|
|
|
def putDouble(self, key: str, value: float):
|
|
self._map[key] = value
|
|
|
|
def putBoolean(self, key: str, value: bool):
|
|
self._map[key] = value
|
|
|
|
def putByte(self, key: str, value: int):
|
|
self._map[key] = value
|
|
|
|
def putChar(self, key: str, value: str):
|
|
self._map[key] = value
|
|
|
|
def putShort(self, key: str, value: int):
|
|
self._map[key] = value
|
|
|
|
def putCharSequence(self, key: str, value: Optional[str]):
|
|
self._map[key] = value
|
|
|
|
def putSerializable(self, key: str, value: Any):
|
|
self._map[key] = value
|
|
|
|
def putParcelable(self, key: str, value: Any):
|
|
self._map[key] = value
|
|
|
|
def putStringArrayList(self, key: str, value: Optional[List[str]]):
|
|
self._map[key] = value
|
|
|
|
def putIntegerArrayList(self, key: str, value: Optional[List[int]]):
|
|
self._map[key] = value
|
|
|
|
def putAll(self, bundle: "Bundle"):
|
|
if bundle:
|
|
self._map.update(bundle._map)
|
|
|
|
def getParcelable(self, key: str, default: Any = None) -> Any:
|
|
return self._map.get(key, default)
|
|
|
|
def getBundle(self, key: str) -> Optional["Bundle"]:
|
|
v = self._map.get(key)
|
|
return v if isinstance(v, Bundle) else None
|
|
|
|
def putBundle(self, key: str, value: Optional["Bundle"]):
|
|
self._map[key] = value
|
|
|
|
def describeContents(self) -> int:
|
|
return 0
|
|
|
|
def clone(self) -> "Bundle":
|
|
b = Bundle()
|
|
b._map = dict(self._map)
|
|
return b
|
|
|
|
def deepCopy(self) -> "Bundle":
|
|
import copy
|
|
b = Bundle()
|
|
b._map = copy.deepcopy(self._map)
|
|
return b
|
|
|
|
def filterValues(self):
|
|
pass
|
|
|
|
def getPairValue(self) -> Optional[str]:
|
|
return None
|
|
|
|
def setClassLoader(self, loader: Any):
|
|
self._class_loader = loader
|
|
|
|
def getClassLoader(self) -> Any:
|
|
return self._class_loader
|
|
|
|
@staticmethod
|
|
def forPair(key: str, value: str) -> "Bundle":
|
|
b = Bundle()
|
|
b.putString(key, value)
|
|
return b
|
|
|
|
|
|
Bundle.EMPTY = Bundle()
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# Parcel / Parcelable
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
class Parcelable(Stub):
|
|
"""Parcelable 接口"""
|
|
|
|
CONTENTS_FILE_DESCRIPTOR = "CONTENTS_FILE_DESCRIPTOR"
|
|
PARCELABLE_WRITE_RETURN_VALUE = 1
|
|
PARCELABLE_ELIDE_DUPLICATES = 2
|
|
|
|
def describeContents(self) -> int:
|
|
return 0
|
|
|
|
def writeToParcel(self, dest: "Parcel", flags: int):
|
|
pass
|
|
|
|
class Creator:
|
|
def createFromParcel(self, source: "Parcel"):
|
|
return None
|
|
def newArray(self, size: int):
|
|
return [None] * size
|
|
|
|
class ClassLoaderCreator:
|
|
def createFromParcel(self, source: "Parcel", loader: Any):
|
|
return None
|
|
def newArray(self, size: int):
|
|
return [None] * size
|
|
|
|
|
|
class Parcel(Stub):
|
|
"""Parcel — 序列化数据容器"""
|
|
|
|
STRING_CREATOR = "STRING_CREATOR"
|
|
STRING_LIST_CREATOR = "STRING_LIST_CREATOR"
|
|
INT_CREATOR = "INT_CREATOR"
|
|
|
|
def __init__(self):
|
|
super().__init__()
|
|
self._data: Dict[str, Any] = {}
|
|
self._position = 0
|
|
self._size = 0
|
|
|
|
@staticmethod
|
|
def obtain() -> "Parcel":
|
|
return Parcel()
|
|
|
|
def recycle(self):
|
|
self._data.clear()
|
|
self._position = 0
|
|
self._size = 0
|
|
|
|
def writeInt(self, value: int):
|
|
self._data.setdefault("_ints", []).append(value)
|
|
self._size += 4
|
|
|
|
def writeLong(self, value: int):
|
|
self._data.setdefault("_longs", []).append(value)
|
|
self._size += 8
|
|
|
|
def writeFloat(self, value: float):
|
|
self._data.setdefault("_floats", []).append(value)
|
|
self._size += 4
|
|
|
|
def writeDouble(self, value: float):
|
|
self._data.setdefault("_doubles", []).append(value)
|
|
self._size += 8
|
|
|
|
def writeString(self, value: Optional[str]):
|
|
strs = self._data.setdefault("_strings", [])
|
|
strs.append(value)
|
|
self._size += len(value) + 4 if value else 4
|
|
|
|
def writeBoolean(self, value: bool):
|
|
self.writeInt(1 if value else 0)
|
|
|
|
def writeByte(self, value: int):
|
|
self.writeInt(value & 0xFF)
|
|
|
|
def writeParcelable(self, p: Parcelable, flags: int):
|
|
pass
|
|
|
|
def writeStringArray(self, values: Optional[List[str]]):
|
|
self._data["_string_array"] = values
|
|
|
|
def writeIntArray(self, values: Optional[List[int]]):
|
|
self._data["_int_array"] = values
|
|
|
|
def writeLongArray(self, values: Optional[List[int]]):
|
|
self._data["_long_array"] = values
|
|
|
|
def readInt(self) -> int:
|
|
ints = self._data.get("_ints", [])
|
|
if ints:
|
|
return ints.pop(0)
|
|
return 0
|
|
|
|
def readLong(self) -> int:
|
|
longs = self._data.get("_longs", [])
|
|
if longs:
|
|
return longs.pop(0)
|
|
return 0
|
|
|
|
def readFloat(self) -> float:
|
|
floats = self._data.get("_floats", [])
|
|
if floats:
|
|
return floats.pop(0)
|
|
return 0.0
|
|
|
|
def readDouble(self) -> float:
|
|
doubles = self._data.get("_doubles", [])
|
|
if doubles:
|
|
return doubles.pop(0)
|
|
return 0.0
|
|
|
|
def readString(self) -> Optional[str]:
|
|
strs = self._data.get("_strings", [])
|
|
if strs:
|
|
return strs.pop(0)
|
|
return None
|
|
|
|
def readBoolean(self) -> bool:
|
|
return self.readInt() != 0
|
|
|
|
def readByte(self) -> int:
|
|
return self.readInt() & 0xFF
|
|
|
|
def dataAvail(self) -> int:
|
|
return self._size - self._position
|
|
|
|
def dataPosition(self) -> int:
|
|
return self._position
|
|
|
|
def setDataPosition(self, pos: int):
|
|
self._position = pos
|
|
|
|
def dataSize(self) -> int:
|
|
return self._size
|
|
|
|
def dataCapacity(self) -> int:
|
|
return self._size
|
|
|
|
def setDataCapacity(self, capacity: int):
|
|
pass
|
|
|
|
def appendFrom(self, parcel: "Parcel", offset: int, length: int):
|
|
pass
|
|
|
|
def marshall(self) -> bytes:
|
|
import json
|
|
return json.dumps(self._data).encode("utf-8")
|
|
|
|
@staticmethod
|
|
def unmarshall(data: bytes) -> "Parcel":
|
|
import json
|
|
p = Parcel()
|
|
try:
|
|
p._data = json.loads(data.decode("utf-8"))
|
|
except Exception:
|
|
pass
|
|
return p
|
|
|
|
def writeValue(self, v: Any):
|
|
self._data["_value"] = v
|
|
|
|
def readValue(self) -> Any:
|
|
return self._data.get("_value")
|
|
|
|
def hasFileDescriptors(self) -> bool:
|
|
return False
|
|
|
|
def toString(self) -> str:
|
|
return f"Parcel({self._size} bytes)"
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# Message
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
class Message(Stub):
|
|
"""Message — Handler 消息"""
|
|
|
|
def __init__(self):
|
|
super().__init__()
|
|
self.what = 0
|
|
self.arg1 = 0
|
|
self.arg2 = 0
|
|
self.obj: Any = None
|
|
self.data: Optional[Bundle] = None
|
|
self.replyTo: Optional["Messenger"] = None
|
|
self._target: Optional["Handler"] = None
|
|
self._callback: Optional[Callable] = None
|
|
self.when: int = 0
|
|
self._sending = False
|
|
|
|
@staticmethod
|
|
def obtain(handler: Optional["Handler"] = None, what: int = 0) -> "Message":
|
|
msg = Message()
|
|
if handler:
|
|
msg._target = handler
|
|
msg.what = what
|
|
return msg
|
|
|
|
def sendToTarget(self):
|
|
if self._target:
|
|
self._target.sendMessage(self)
|
|
|
|
def getTarget(self) -> Optional["Handler"]:
|
|
return self._target
|
|
|
|
def setTarget(self, handler: "Handler"):
|
|
self._target = handler
|
|
|
|
def getCallback(self) -> Optional[Callable]:
|
|
return self._callback
|
|
|
|
def copyFrom(self, other: "Message"):
|
|
self.what = other.what
|
|
self.arg1 = other.arg1
|
|
self.arg2 = other.arg2
|
|
self.obj = other.obj
|
|
self.data = other.data
|
|
self.replyTo = other.replyTo
|
|
|
|
def recycle(self):
|
|
self.what = 0
|
|
self.arg1 = 0
|
|
self.arg2 = 0
|
|
self.obj = None
|
|
self.data = None
|
|
self._target = None
|
|
self._callback = None
|
|
|
|
def isAsynchronous(self) -> bool:
|
|
return False
|
|
|
|
def setAsynchronous(self, async_: bool):
|
|
pass
|
|
|
|
def toString(self) -> str:
|
|
return f"Message(what={self.what}, arg1={self.arg1}, arg2={self.arg2})"
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# Looper
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
class Looper(Stub):
|
|
"""Looper — 消息循环"""
|
|
|
|
_main_looper: Optional["Looper"] = None
|
|
_thread_local = threading.local()
|
|
|
|
def __init__(self):
|
|
super().__init__()
|
|
self._thread = threading.current_thread()
|
|
self._running = False
|
|
self._message_queue: List[Message] = []
|
|
self._quit_allowed = True
|
|
|
|
@staticmethod
|
|
def prepare():
|
|
looper = Looper()
|
|
Looper._thread_local.looper = looper
|
|
return looper
|
|
|
|
@staticmethod
|
|
def prepareMainLooper():
|
|
if Looper._main_looper is None:
|
|
Looper._main_looper = Looper.prepare()
|
|
|
|
@staticmethod
|
|
def getMainLooper() -> "Looper":
|
|
if Looper._main_looper is None:
|
|
Looper.prepareMainLooper()
|
|
return Looper._main_looper
|
|
|
|
@staticmethod
|
|
def myLooper() -> Optional["Looper"]:
|
|
return getattr(Looper._thread_local, "looper", None)
|
|
|
|
@staticmethod
|
|
def loop():
|
|
looper = Looper.myLooper()
|
|
if looper is None:
|
|
raise RuntimeError("No Looper prepared")
|
|
looper._running = True
|
|
|
|
def quit(self):
|
|
self._running = False
|
|
|
|
def quitSafely(self):
|
|
self._running = False
|
|
|
|
def isCurrentThread(self) -> bool:
|
|
return threading.current_thread() == self._thread
|
|
|
|
def getThread(self) -> threading.Thread:
|
|
return self._thread
|
|
|
|
def getQueue(self):
|
|
return self._message_queue
|
|
|
|
def dump(self, pw: Any, prefix: str):
|
|
pass
|
|
|
|
def toString(self) -> str:
|
|
return f"Looper({self._thread.name})"
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# Handler
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
class Handler(Stub):
|
|
"""Handler — 消息处理器"""
|
|
|
|
def __init__(self, looper: Optional[Looper] = None, callback: Optional[Callable] = None):
|
|
super().__init__()
|
|
self._looper = looper or Looper.getMainLooper()
|
|
self._callback = callback
|
|
self._async = False
|
|
|
|
def handleMessage(self, msg: Message):
|
|
pass
|
|
|
|
def dispatchMessage(self, msg: Message):
|
|
if msg._callback:
|
|
msg._callback()
|
|
elif self._callback:
|
|
self._callback(msg)
|
|
else:
|
|
self.handleMessage(msg)
|
|
|
|
def post(self, r: Callable) -> bool:
|
|
msg = Message.obtain(self)
|
|
msg._callback = r
|
|
return self.sendMessage(msg)
|
|
|
|
def postDelayed(self, r: Callable, delay_ms: int) -> bool:
|
|
msg = Message.obtain(self)
|
|
msg._callback = r
|
|
msg.when = int(_time.time() * 1000) + delay_ms
|
|
return self.sendMessageDelayed(msg, delay_ms)
|
|
|
|
def postAtTime(self, r: Callable, uptime_ms: int) -> bool:
|
|
msg = Message.obtain(self)
|
|
msg._callback = r
|
|
msg.when = uptime_ms
|
|
return self.sendMessageAtTime(msg, uptime_ms)
|
|
|
|
def sendMessage(self, msg: Message) -> bool:
|
|
msg._target = self
|
|
self.dispatchMessage(msg)
|
|
return True
|
|
|
|
def sendEmptyMessage(self, what: int) -> bool:
|
|
msg = Message.obtain(self, what)
|
|
return self.sendMessage(msg)
|
|
|
|
def sendMessageDelayed(self, msg: Message, delay_ms: int) -> bool:
|
|
msg._target = self
|
|
msg.when = int(_time.time() * 1000) + delay_ms
|
|
self.dispatchMessage(msg)
|
|
return True
|
|
|
|
def sendMessageAtTime(self, msg: Message, uptime_ms: int) -> bool:
|
|
msg._target = self
|
|
msg.when = uptime_ms
|
|
self.dispatchMessage(msg)
|
|
return True
|
|
|
|
def sendMessageAtFrontOfQueue(self, msg: Message) -> bool:
|
|
msg._target = self
|
|
self.dispatchMessage(msg)
|
|
return True
|
|
|
|
def removeCallbacks(self, r: Callable):
|
|
pass
|
|
|
|
def removeMessages(self, what: int):
|
|
pass
|
|
|
|
def obtainMessage(self, what: int = 0) -> Message:
|
|
return Message.obtain(self, what)
|
|
|
|
def hasMessages(self, what: int) -> bool:
|
|
return False
|
|
|
|
def getLooper(self) -> Looper:
|
|
return self._looper
|
|
|
|
def toString(self) -> str:
|
|
return f"Handler({self.__class__.__name__})"
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# HandlerThread
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
class HandlerThread(threading.Thread, Stub):
|
|
"""HandlerThread — 带 Looper 的工作线程"""
|
|
|
|
def __init__(self, name: str, priority: int = Process.THREAD_PRIORITY_DEFAULT):
|
|
super().__init__()
|
|
Stub.__init__(self)
|
|
self._name = name
|
|
self._priority = priority
|
|
self._looper: Optional[Looper] = None
|
|
self._started = threading.Event()
|
|
|
|
def run(self):
|
|
Looper.prepare()
|
|
self._looper = Looper.myLooper()
|
|
self._started.set()
|
|
Looper.loop()
|
|
|
|
def getLooper(self) -> Optional[Looper]:
|
|
self._started.wait()
|
|
return self._looper
|
|
|
|
def getThreadId(self) -> int:
|
|
return self.ident or 0
|
|
|
|
def quit(self) -> bool:
|
|
if self._looper:
|
|
self._looper.quit()
|
|
return True
|
|
return False
|
|
|
|
def quitSafely(self) -> bool:
|
|
return self.quit()
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# AsyncTask
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
class AsyncTask(Stub):
|
|
"""AsyncTask — 异步任务"""
|
|
|
|
Status = type("Status", (), {"PENDING": 0, "RUNNING": 1, "FINISHED": 2})
|
|
|
|
SERIAL_EXECUTOR = None
|
|
THREAD_POOL_EXECUTOR = None
|
|
|
|
def __init__(self):
|
|
super().__init__()
|
|
self._status = AsyncTask.Status.PENDING
|
|
self._result: Any = None
|
|
self._cancelled = False
|
|
|
|
def doInBackground(self, *params) -> Any:
|
|
raise NotImplementedError
|
|
|
|
def onPreExecute(self):
|
|
pass
|
|
|
|
def onPostExecute(self, result: Any):
|
|
pass
|
|
|
|
def onProgressUpdate(self, *values):
|
|
pass
|
|
|
|
def onCancelled(self, result: Any = None):
|
|
pass
|
|
|
|
def execute(self, *params) -> "AsyncTask":
|
|
self._status = AsyncTask.Status.RUNNING
|
|
self.onPreExecute()
|
|
try:
|
|
self._result = self.doInBackground(*params)
|
|
except Exception as e:
|
|
self._result = e
|
|
self._status = AsyncTask.Status.FINISHED
|
|
if not self._cancelled:
|
|
self.onPostExecute(self._result)
|
|
return self
|
|
|
|
def executeOnExecutor(self, exec: Any, *params) -> "AsyncTask":
|
|
return self.execute(*params)
|
|
|
|
def get(self) -> Any:
|
|
return self._result
|
|
|
|
def getStatus(self) -> int:
|
|
return self._status
|
|
|
|
def isCancelled(self) -> bool:
|
|
return self._cancelled
|
|
|
|
def cancel(self, may_interrupt_if_running: bool) -> bool:
|
|
self._cancelled = True
|
|
return True
|
|
|
|
def publishProgress(self, *values):
|
|
self.onProgressUpdate(*values)
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# CountDownTimer
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
class CountDownTimer(Stub):
|
|
"""CountDownTimer — 倒计时"""
|
|
|
|
def __init__(self, millis_in_future: int, count_down_interval: int):
|
|
super().__init__()
|
|
self._millis_in_future = millis_in_future
|
|
self._interval = count_down_interval
|
|
self._cancelled = False
|
|
|
|
def onTick(self, millis_until_finished: int):
|
|
pass
|
|
|
|
def onFinish(self):
|
|
pass
|
|
|
|
def start(self) -> "CountDownTimer":
|
|
self._cancelled = False
|
|
remaining = self._millis_in_future
|
|
while remaining > 0 and not self._cancelled:
|
|
self.onTick(remaining)
|
|
_time.sleep(self._interval / 1000.0)
|
|
remaining -= self._interval
|
|
if not self._cancelled:
|
|
self.onFinish()
|
|
return self
|
|
|
|
def cancel(self):
|
|
self._cancelled = True
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# Messenger
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
class Messenger(Stub):
|
|
"""Messenger — 跨进程消息传递"""
|
|
|
|
def __init__(self, handler: Handler):
|
|
super().__init__()
|
|
self._handler = handler
|
|
|
|
def send(self, message: Message):
|
|
self._handler.sendMessage(message)
|
|
|
|
def getBinder(self):
|
|
return None
|
|
|
|
@staticmethod
|
|
def obtain(handler: Handler) -> "Messenger":
|
|
return Messenger(handler)
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# PowerManager / PowerManagerWakeLock
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
class PowerManager(Stub):
|
|
"""PowerManager — 电源管理"""
|
|
|
|
ACQUIRE_CAUSES_WAKEUP = 0x10000000
|
|
DOZE_WAKE_LOCK = 0x00000040
|
|
DRAW_WAKE_LOCK = 0x00000080
|
|
FULL_WAKE_LOCK = 0x0000001A
|
|
LOCATION_HARDWARE_POWER_MODE = 0x00000080
|
|
ON_AFTER_RELEASE = 0x20000000
|
|
PARTIAL_WAKE_LOCK = 0x00000001
|
|
PROXIMITY_SCREEN_OFF_WAKE_LOCK = 0x00000020
|
|
SCREEN_BRIGHT_WAKE_LOCK = 0x0000000A
|
|
SCREEN_DIM_WAKE_LOCK = 0x00000006
|
|
WAKE_LOCK_LEVEL_MASK = 0x0000FFFF
|
|
|
|
def __init__(self):
|
|
super().__init__()
|
|
self._is_interactive = True
|
|
self._is_power_save = False
|
|
self._is_device_idle = False
|
|
|
|
def newWakeLock(self, level_and_flags: int, tag: str) -> "PowerManagerWakeLock":
|
|
return PowerManagerWakeLock(level_and_flags, tag)
|
|
|
|
def isInteractive(self) -> bool:
|
|
return self._is_interactive
|
|
|
|
def isPowerSaveMode(self) -> bool:
|
|
return self._is_power_save
|
|
|
|
def isDeviceIdleMode(self) -> bool:
|
|
return self._is_device_idle
|
|
|
|
def isIgnoringBatteryOptimizations(self, package_name: str) -> bool:
|
|
return True
|
|
|
|
def isSustainedPerformanceModeSupported(self) -> bool:
|
|
return False
|
|
|
|
def reboot(self, reason: Optional[str] = None):
|
|
pass
|
|
|
|
def goToSleep(self, time_ms: int):
|
|
pass
|
|
|
|
def wakeUp(self, time_ms: int):
|
|
pass
|
|
|
|
def userActivity(self, when: int, no_change_lights: bool = False):
|
|
pass
|
|
|
|
|
|
class PowerManagerWakeLock(Stub):
|
|
"""PowerManagerWakeLock — 唤醒锁"""
|
|
|
|
def __init__(self, level_and_flags: int, tag: str):
|
|
super().__init__()
|
|
self._level_and_flags = level_and_flags
|
|
self._tag = tag
|
|
self._held = False
|
|
self._work_source = None
|
|
self._history_tag = None
|
|
|
|
def acquire(self, timeout_ms: int = 0):
|
|
self._held = True
|
|
sys.stderr.write(f"[PowerManager] acquire wakelock: {self._tag}\n")
|
|
|
|
def acquireLocked(self):
|
|
self._held = True
|
|
|
|
def release(self, flags: int = 0):
|
|
self._held = False
|
|
sys.stderr.write(f"[PowerManager] release wakelock: {self._tag}\n")
|
|
|
|
def isHeld(self) -> bool:
|
|
return self._held
|
|
|
|
def setWorkSource(self, work_source: Any):
|
|
self._work_source = work_source
|
|
|
|
def setReferenceCounted(self, value: bool):
|
|
pass
|
|
|
|
def setHistoryTag(self, tag: str):
|
|
self._history_tag = tag
|
|
|
|
def toString(self) -> str:
|
|
return f"WakeLock({self._tag}, held={self._held})"
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# Vibrator / VibratorEffect
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
class Vibrator(Stub):
|
|
"""Vibrator — 振动器"""
|
|
|
|
def __init__(self):
|
|
super().__init__()
|
|
|
|
def vibrate(self, milliseconds: int):
|
|
sys.stderr.write(f"[Vibrator] vibrate: {milliseconds}ms\n")
|
|
|
|
def vibrate(self, pattern: List[int], repeat: int):
|
|
sys.stderr.write(f"[Vibrator] vibrate pattern: {pattern}, repeat={repeat}\n")
|
|
|
|
def cancel(self):
|
|
sys.stderr.write("[Vibrator] cancel\n")
|
|
|
|
def hasVibrator(self) -> bool:
|
|
return True
|
|
|
|
def hasAmplitudeControl(self) -> bool:
|
|
return False
|
|
|
|
def areEffectsSupported(self, effect_ids: List[int]) -> List[int]:
|
|
return [0] * len(effect_ids)
|
|
|
|
def areAllEffectsSupported(self, effect_ids: List[int]) -> List[int]:
|
|
return [0] * len(effect_ids)
|
|
|
|
|
|
class VibratorEffect(Stub):
|
|
"""VibratorEffect — 振动效果"""
|
|
|
|
def __init__(self, effect_id: int = 0):
|
|
super().__init__()
|
|
self._effect_id = effect_id
|
|
|
|
@staticmethod
|
|
def createOneShot(milliseconds: int, amplitude: int) -> "VibratorEffect":
|
|
return VibratorEffect(0)
|
|
|
|
@staticmethod
|
|
def createWaveform(pattern: List[int], repeat: int) -> "VibratorEffect":
|
|
return VibratorEffect(0)
|
|
|
|
@staticmethod
|
|
def createPredefined(effect_id: int) -> "VibratorEffect":
|
|
return VibratorEffect(effect_id)
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# BatteryManager
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
class BatteryManager(Stub):
|
|
"""BatteryManager — 电池管理"""
|
|
|
|
BATTERY_PROPERTY_CHARGE_COUNTER = 1
|
|
BATTERY_PROPERTY_CURRENT_NOW = 2
|
|
BATTERY_PROPERTY_CURRENT_AVERAGE = 3
|
|
BATTERY_PROPERTY_CAPACITY = 4
|
|
BATTERY_PROPERTY_STATUS = 5
|
|
BATTERY_PROPERTY_ENERGY_COUNTER = 6
|
|
BATTERY_PROPERTY_BATTERY_NOW = 7
|
|
BATTERY_PROPERTY_BATTERY_LOW = 8
|
|
|
|
BATTERY_STATUS_UNKNOWN = 1
|
|
BATTERY_STATUS_CHARGING = 2
|
|
BATTERY_STATUS_DISCHARGING = 3
|
|
BATTERY_STATUS_NOT_CHARGING = 4
|
|
BATTERY_STATUS_FULL = 5
|
|
|
|
BATTERY_HEALTH_UNKNOWN = 1
|
|
BATTERY_HEALTH_GOOD = 2
|
|
BATTERY_HEALTH_OVERHEAT = 3
|
|
BATTERY_HEALTH_DEAD = 4
|
|
BATTERY_HEALTH_OVER_VOLTAGE = 5
|
|
BATTERY_HEALTH_UNSPECIFIED_FAILURE = 6
|
|
BATTERY_HEALTH_COLD = 7
|
|
|
|
EXTRA_STATUS = "status"
|
|
EXTRA_HEALTH = "health"
|
|
EXTRA_PRESENT = "present"
|
|
EXTRA_LEVEL = "level"
|
|
EXTRA_SCALE = "scale"
|
|
EXTRA_ICON_SMALL = "icon-small"
|
|
EXTRA_PLUGGED = "plugged"
|
|
EXTRA_VOLTAGE = "voltage"
|
|
EXTRA_TEMPERATURE = "temperature"
|
|
EXTRA_TECHNOLOGY = "technology"
|
|
EXTRA_BATTERY_LOW = "battery_low"
|
|
EXTRA_CHARGE_COUNTER = "charge_counter"
|
|
|
|
BATTERY_PLUGGED_AC = 1
|
|
BATTERY_PLUGGED_USB = 2
|
|
BATTERY_PLUGGED_WIRELESS = 4
|
|
|
|
def __init__(self):
|
|
super().__init__()
|
|
self._capacity = 85
|
|
self._status = self.BATTERY_STATUS_CHARGING
|
|
self._health = self.BATTERY_HEALTH_GOOD
|
|
self._present = True
|
|
self._level = 85
|
|
self._plugged = self.BATTERY_PLUGGED_AC
|
|
self._voltage = 4200
|
|
self._temperature = 250
|
|
self._technology = "Li-ion"
|
|
self._charge_counter = 3500000
|
|
self._current_now = -500000
|
|
self._current_avg = -450000
|
|
self._energy_counter = 15000000
|
|
|
|
def getIntProperty(self, prop_id: int) -> int:
|
|
if prop_id == self.BATTERY_PROPERTY_CAPACITY:
|
|
return self._capacity
|
|
if prop_id == self.BATTERY_PROPERTY_STATUS:
|
|
return self._status
|
|
if prop_id == self.BATTERY_PROPERTY_CHARGE_COUNTER:
|
|
return self._charge_counter
|
|
if prop_id == self.BATTERY_PROPERTY_CURRENT_NOW:
|
|
return self._current_now
|
|
if prop_id == self.BATTERY_PROPERTY_CURRENT_AVERAGE:
|
|
return self._current_avg
|
|
if prop_id == self.BATTERY_PROPERTY_ENERGY_COUNTER:
|
|
return self._energy_counter
|
|
return -1
|
|
|
|
def getLongProperty(self, prop_id: int) -> int:
|
|
return self.getIntProperty(prop_id)
|
|
|
|
def isCharging(self) -> bool:
|
|
return self._status == self.BATTERY_STATUS_CHARGING
|
|
|
|
def computeChargeTimeRemaining(self) -> int:
|
|
return 1800000 # 30 minutes
|
|
|
|
def toString(self) -> str:
|
|
return f"BatteryManager(level={self._level}%, charging={self.isCharging()})"
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# 异常类
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
class NetworkOnMainThreadException(RuntimeError):
|
|
"""网络操作在主线程上执行"""
|
|
pass
|
|
|
|
|
|
class TransactionTooLargeException(RuntimeError):
|
|
"""事务数据太大"""
|
|
pass
|
|
|
|
|
|
class OperationCanceledException(RuntimeError):
|
|
"""操作被取消"""
|
|
pass
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# 其他工具类
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
class ConditionVariable(Stub):
|
|
"""ConditionVariable — 条件变量"""
|
|
|
|
def __init__(self):
|
|
super().__init__()
|
|
self._cond = threading.Condition()
|
|
self._open = False
|
|
|
|
def block(self, timeout_ms: int = 0):
|
|
with self._cond:
|
|
if timeout_ms <= 0:
|
|
while not self._open:
|
|
self._cond.wait()
|
|
else:
|
|
if not self._open:
|
|
self._cond.wait(timeout_ms / 1000.0)
|
|
|
|
def open(self):
|
|
with self._cond:
|
|
self._open = True
|
|
self._cond.notify_all()
|
|
|
|
def close(self):
|
|
with self._cond:
|
|
self._open = False
|
|
|
|
|
|
class Semaphore(Stub):
|
|
"""Semaphore — 信号量"""
|
|
|
|
def __init__(self, permits: int):
|
|
super().__init__()
|
|
self._sem = threading.Semaphore(permits)
|
|
|
|
def acquire(self):
|
|
self._sem.acquire()
|
|
|
|
def tryAcquire(self) -> bool:
|
|
return self._sem.acquire(blocking=False)
|
|
|
|
def release(self):
|
|
self._sem.release()
|
|
|
|
def availablePermits(self) -> int:
|
|
return self._sem._value
|
|
|
|
|
|
class TokenWatcher(Stub):
|
|
"""TokenWatcher — 令牌监视器"""
|
|
|
|
def __init__(self, handler: Handler, tag: str):
|
|
super().__init__()
|
|
|
|
def acquire(self, token: Any, tag: str):
|
|
pass
|
|
|
|
def release(self, token: Any):
|
|
pass
|
|
|
|
def isAcquired(self) -> bool:
|
|
return False
|
|
|
|
def dump(self):
|
|
pass
|
|
|
|
|
|
class WorkSource(Stub):
|
|
"""WorkSource — 工作来源"""
|
|
|
|
def __init__(self, uid: int = 0):
|
|
super().__init__()
|
|
self._uids: List[int] = [uid] if uid else []
|
|
|
|
def add(self, uid: int):
|
|
if uid not in self._uids:
|
|
self._uids.append(uid)
|
|
|
|
def remove(self, uid: int):
|
|
if uid in self._uids:
|
|
self._uids.remove(uid)
|
|
|
|
def get(self, index: int) -> int:
|
|
if 0 <= index < len(self._uids):
|
|
return self._uids[index]
|
|
return 0
|
|
|
|
def size(self) -> int:
|
|
return len(self._uids)
|
|
|
|
def clear(self):
|
|
self._uids.clear()
|
|
|
|
def set(self, ws: "WorkSource"):
|
|
if ws:
|
|
self._uids = list(ws._uids)
|
|
|
|
def toString(self) -> str:
|
|
return f"WorkSource({self._uids})"
|
|
|
|
|
|
class UserHandle(Stub):
|
|
"""UserHandle — 用户句柄"""
|
|
|
|
USER_ALL = -1
|
|
USER_CURRENT = -2
|
|
USER_CURRENT_OR_SELF = -3
|
|
USER_NULL = -10000
|
|
USER_OWNER = 0
|
|
USER_SYSTEM = 0
|
|
|
|
def __init__(self, user_id: int = 0):
|
|
super().__init__()
|
|
self._user_id = user_id
|
|
|
|
@staticmethod
|
|
def myUserId() -> int:
|
|
return 0
|
|
|
|
@staticmethod
|
|
def getUserHandleForUid(uid: int) -> "UserHandle":
|
|
return UserHandle(uid // 100000)
|
|
|
|
@staticmethod
|
|
def getUserId(uid: int) -> int:
|
|
return uid // 100000
|
|
|
|
@staticmethod
|
|
def getUid(user_id: int, app_id: int) -> int:
|
|
return user_id * 100000 + app_id
|
|
|
|
@staticmethod
|
|
def getAppId(uid: int) -> int:
|
|
return uid % 100000
|
|
|
|
def getIdentifier(self) -> int:
|
|
return self._user_id
|
|
|
|
def hashCode(self) -> int:
|
|
return self._user_id
|
|
|
|
def toString(self) -> str:
|
|
return f"UserHandle({self._user_id})"
|
|
|
|
|
|
class DropBoxManager(Stub):
|
|
"""DropBoxManager — 系统日志收集"""
|
|
|
|
IS_EMPTY = 0
|
|
IS_TEXT = 1
|
|
IS_GZIPPED = 2
|
|
|
|
class Entry(Stub):
|
|
def __init__(self, tag: str, milliseconds: int):
|
|
super().__init__()
|
|
self._tag = tag
|
|
self._millis = milliseconds
|
|
self._text = ""
|
|
|
|
def getTag(self) -> str:
|
|
return self._tag
|
|
|
|
def getTimeMillis(self) -> int:
|
|
return self._millis
|
|
|
|
def getText(self, max_bytes: int) -> Optional[str]:
|
|
return self._text
|
|
|
|
def getFlags(self, max_bytes: int) -> int:
|
|
return DropBoxManager.IS_TEXT
|
|
|
|
def close(self):
|
|
pass
|
|
|
|
def __init__(self):
|
|
super().__init__()
|
|
self._entries: List[DropBoxManager.Entry] = []
|
|
|
|
def addText(self, tag: str, text: str):
|
|
entry = DropBoxManager.Entry(tag, int(_time.time() * 1000))
|
|
entry._text = text
|
|
self._entries.append(entry)
|
|
|
|
def getNextEntry(self, tag: str, milliseconds: int) -> Optional[Entry]:
|
|
for entry in self._entries:
|
|
if entry.getTimeMillis() > milliseconds:
|
|
if not tag or entry.getTag() == tag:
|
|
return entry
|
|
return None
|
|
|
|
def dump(self, pw: Any, prefix: str):
|
|
pass
|
|
|
|
|
|
class FileObserver(Stub):
|
|
"""FileObserver — 文件监听"""
|
|
|
|
ACCESS = 0x00000001
|
|
MODIFY = 0x00000002
|
|
ATTRIB = 0x00000004
|
|
CLOSE_WRITE = 0x00000008
|
|
CLOSE_NOWRITE = 0x00000010
|
|
OPEN = 0x00000020
|
|
MOVED_FROM = 0x00000040
|
|
MOVED_TO = 0x00000080
|
|
CREATE = 0x00000100
|
|
DELETE = 0x00000200
|
|
DELETE_SELF = 0x00000400
|
|
MOVE_SELF = 0x00000800
|
|
ALL_EVENTS = 0x00000FFF
|
|
|
|
def __init__(self, path: str):
|
|
super().__init__()
|
|
self._path = path
|
|
self._watching = False
|
|
|
|
def startWatching(self):
|
|
self._watching = True
|
|
|
|
def stopWatching(self):
|
|
self._watching = False
|
|
|
|
def onEvent(self, event: int, path: Optional[str]):
|
|
pass
|
|
|
|
def finalize(self):
|
|
pass
|
|
|
|
|
|
class FileUtils(Stub):
|
|
"""FileUtils — 文件工具"""
|
|
|
|
@staticmethod
|
|
def readFileToString(file: Any) -> str:
|
|
return ""
|
|
|
|
@staticmethod
|
|
def stringToFile(file: Any, string: str):
|
|
pass
|
|
|
|
@staticmethod
|
|
def copyFile(src: Any, dest: Any) -> bool:
|
|
return True
|
|
|
|
@staticmethod
|
|
def deleteDirectory(dir_: Any) -> bool:
|
|
return True
|
|
|
|
@staticmethod
|
|
def deleteOlderFiles(dir_: Any, min_count: int, min_age_ms: int):
|
|
pass
|
|
|
|
|
|
class PatternMatcher(Stub):
|
|
"""PatternMatcher — 模式匹配器"""
|
|
|
|
PATTERN_LITERAL = 0
|
|
PATTERN_PREFIX = 1
|
|
PATTERN_SIMPLE_GLOB = 2
|
|
PATTERN_ADVANCED_GLOB = 3
|
|
PATTERN_SUFFIX = 4
|
|
|
|
def __init__(self, pattern: str, type_: int):
|
|
super().__init__()
|
|
self._pattern = pattern
|
|
self._type = type_
|
|
|
|
def getPath(self) -> str:
|
|
return self._pattern
|
|
|
|
def getType(self) -> int:
|
|
return self._type
|
|
|
|
def match(self, str_: str) -> bool:
|
|
if self._type == self.PATTERN_LITERAL:
|
|
return str_ == self._pattern
|
|
if self._type == self.PATTERN_PREFIX:
|
|
return str_.startswith(self._pattern)
|
|
if self._type == self.PATTERN_SUFFIX:
|
|
return str_.endswith(self._pattern)
|
|
if self._type == self.PATTERN_SIMPLE_GLOB:
|
|
import fnmatch
|
|
return fnmatch.fnmatch(str_, self._pattern)
|
|
return str_ == self._pattern
|
|
|
|
def toString(self) -> str:
|
|
return f"PatternMatcher({self._pattern}, type={self._type})"
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# __all__
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
__all__ = [
|
|
"Bundle",
|
|
"BaseBundle",
|
|
"PersistableBundle",
|
|
"Handler",
|
|
"Looper",
|
|
"Message",
|
|
"HandlerThread",
|
|
"PowerManager",
|
|
"PowerManagerWakeLock",
|
|
"Vibrator",
|
|
"VibratorEffect",
|
|
"Build",
|
|
"SystemClock",
|
|
"Environment",
|
|
"Parcel",
|
|
"Parcelable",
|
|
"Process",
|
|
"AsyncTask",
|
|
"CountDownTimer",
|
|
"Messenger",
|
|
"BatteryManager",
|
|
"PatternMatcher",
|
|
"ConditionVariable",
|
|
"Semaphore",
|
|
"TokenWatcher",
|
|
"WorkSource",
|
|
"UserHandle",
|
|
"DropBoxManager",
|
|
"FileObserver",
|
|
"FileUtils",
|
|
"NetworkOnMainThreadException",
|
|
"TransactionTooLargeException",
|
|
"OperationCanceledException",
|
|
] |