""" Android System Manager API — 所有剩余系统 Manager 类集合 方法签名完全对齐 Android SDK """ from __future__ import annotations import os import sys import time import json import random import socket import uuid import threading from datetime import datetime, timedelta from typing import Any, Dict, List, Optional, Set, Tuple, Callable, BinaryIO from .._core import Stub, AndroidOnlyError, _app_data_dir, _sdcard_root from ..java.lang import RuntimeException IllegalArgumentException = type("IllegalArgumentException", (RuntimeException,), {}) # ═══════════════════════════════════════════════════════════════ # 全局常量 # ═══════════════════════════════════════════════════════════════ INVALID_ID = -1 MATCH_ALL = -1 # ═══════════════════════════════════════════════════════════════ # AccessibilityManager # ═══════════════════════════════════════════════════════════════ class AccessibilityManager(Stub): """AccessibilityManager — 无障碍管理器 (桌面存根)""" FLAG_CONTENT_CONTROLS = 0x00000001 FLAG_CONTENT_ICONS = 0x00000002 FLAG_CONTENT_TEXT = 0x00000004 FLAG_CONTENT_CONTENT_DESCRIPTION = 0x00000008 def __init__(self, context: Any = None): super().__init__() self._context = context self._enabled = False self._touch_exploration_enabled = False self._high_text_contrast_enabled = False self._animator_duration_scale = 1.0 self._display_magnification_enabled = False self._accessibility_volume = 0 self._speech_rate = 1.0 self._listeners: List[Any] = [] def isEnabled(self) -> bool: return self._enabled def addAccessibilityStateChangeListener(self, listener: Any) -> bool: if listener not in self._listeners: self._listeners.append(listener) return True def removeAccessibilityStateChangeListener(self, listener: Any) -> bool: if listener in self._listeners: self._listeners.remove(listener) return True def isTouchExplorationEnabled(self) -> bool: return self._touch_exploration_enabled def isHighTextContrastEnabled(self) -> bool: return self._high_text_contrast_enabled def getAccessibilityServiceList(self) -> List[Any]: return [] def addTouchExplorationStateChangeListener(self, listener: Any) -> None: pass def removeTouchExplorationStateChangeListener(self, listener: Any) -> None: pass def sendAccessibilityEvent(self, event: Any) -> None: pass def interrupt(self) -> None: pass def getEnabledAccessibilityServiceList(self, feedbackTypeFlags: int) -> List[Any]: return [] def getInstalledAccessibilityServiceList(self) -> List[Any]: return [] def toString(self) -> str: return f"AccessibilityManager(enabled={self._enabled})" # ═══════════════════════════════════════════════════════════════ # AccountManager (扩展) # ═══════════════════════════════════════════════════════════════ class AccountManager(Stub): """AccountManager — 账户管理器 (扩展)""" KEY_ACCOUNTS = "accounts" KEY_ACCOUNT_NAME = "accountName" KEY_ACCOUNT_TYPE = "accountType" KEY_AUTHTOKEN = "authtoken" KEY_AUTH_FAILED_MESSAGE = "authFailedMessage" KEY_AUTH_TOKEN_LABEL = "authTokenLabelKey" KEY_BOOLEAN_RESULT = "booleanResult" KEY_ERROR_CODE = "errorCode" KEY_ERROR_MESSAGE = "errorMessage" KEY_INTENT = "intent" KEY_PASSWORD = "password" KEY_USERDATA = "userdata" KEY_CUSTOM_TOKEN_EXPIRY = "customTokenExpiry" KEY_ACCOUNT_ACCESS_ID = "accountAccessId" ERROR_CODE_NETWORK_ERROR = 1 ERROR_CODE_UNSUPPORTED_OPERATION = 2 ERROR_CODE_INVALID_RESPONSE = 3 ERROR_CODE_REMOTE_EXCEPTION = 4 ERROR_CODE_MANAGEMENT_DISABLED = 5 ERROR_CODE_BAD_ARGUMENTS = 6 ERROR_CODE_BAD_REQUEST = 7 ERROR_CODE_DENIED = 8 ERROR_CODE_CANCELED = 9 ERROR_CODE_INVALID_CREDENTIALS = 10 ERROR_CODE_SESSION_EXPIRED = 11 ERROR_CODE_USER_RESTRICTION = 12 _instance: Optional["AccountManager"] = None def __init__(self, context: Any = None): super().__init__() self._context = context self._accounts: List[Any] = [] self._auth_tokens: Dict[str, str] = {} self._user_data: Dict[str, Dict[str, str]] = {} self._password_data: Dict[str, str] = {} self._account_visibility: Dict[str, bool] = {} self._lock = threading.Lock() @staticmethod def get(context: Any) -> "AccountManager": if AccountManager._instance is None: AccountManager._instance = AccountManager(context) return AccountManager._instance def getAccounts(self) -> List[Any]: with self._lock: return list(self._accounts) def getAccountsByType(self, type_: str) -> List[Any]: with self._lock: return [a for a in self._accounts if getattr(a, "type", None) == type_] def addAccountExplicitly(self, account: Any, password: Optional[str], userdata: Optional[Dict]) -> bool: with self._lock: if account not in self._accounts: self._accounts.append(account) name = getattr(account, "name", str(account)) if password is not None: self._password_data[name] = password if userdata: self._user_data[name] = dict(userdata) return True return False def removeAccountExplicitly(self, account: Any) -> bool: with self._lock: if account in self._accounts: self._accounts.remove(account) name = getattr(account, "name", str(account)) self._password_data.pop(name, None) self._user_data.pop(name, None) return True return False def getUserData(self, account: Any, key: str) -> Optional[str]: with self._lock: name = getattr(account, "name", str(account)) return self._user_data.get(name, {}).get(key) def setUserData(self, account: Any, key: str, value: str) -> None: with self._lock: name = getattr(account, "name", str(account)) if name not in self._user_data: self._user_data[name] = {} self._user_data[name][key] = value def getPassword(self, account: Any) -> Optional[str]: with self._lock: name = getattr(account, "name", str(account)) return self._password_data.get(name) def setPassword(self, account: Any, password: str) -> None: with self._lock: name = getattr(account, "name", str(account)) self._password_data[name] = password def clearPassword(self, account: Any) -> None: with self._lock: name = getattr(account, "name", str(account)) self._password_data.pop(name, None) def getAuthToken(self, account: Any, authTokenType: str) -> Optional[str]: with self._lock: name = getattr(account, "name", str(account)) return self._auth_tokens.get(f"{name}:{authTokenType}") def setAuthToken(self, account: Any, authTokenType: str, authToken: str) -> None: with self._lock: name = getattr(account, "name", str(account)) self._auth_tokens[f"{name}:{authTokenType}"] = authToken def invalidateAuthToken(self, accountType: str, authToken: str) -> None: with self._lock: to_remove = [k for k, v in self._auth_tokens.items() if v == authToken] for k in to_remove: del self._auth_tokens[k] def hasFeatures(self, account: Any, features: List[str], callback: Any, handler: Any = None) -> None: pass def getAccountVisibility(self, account: Any, packageName: str) -> int: return 1 def toString(self) -> str: return f"AccountManager(accounts={len(self._accounts)})" # ═══════════════════════════════════════════════════════════════ # AlarmManager # ═══════════════════════════════════════════════════════════════ class AlarmManager(Stub): """AlarmManager — 闹钟管理器""" RTC_WAKEUP = 0 RTC = 1 ELAPSED_REALTIME_WAKEUP = 2 ELAPSED_REALTIME = 3 INTERVAL_FIFTEEN_MINUTES = 900000 INTERVAL_HALF_HOUR = 1800000 INTERVAL_HOUR = 3600000 INTERVAL_DAY = 86400000 FLAG_ALLOW_WHILE_IDLE_UNSCREEN_ON = 0x00000008 FLAG_ALLOW_WHILE_IDLE = 0x00000004 FLAG_STANDALONE = 0x00000002 FLAG_WAKE_FROM_IDLE = 0x00000001 def __init__(self, context: Any = None): super().__init__() self._context = context self._alarms: List[Dict[str, Any]] = [] self._lock = threading.Lock() self._next_id = 1 self._worker: Optional[threading.Thread] = None self._running = True def set(self, type_: int, triggerAtMillis: int, operation: Any) -> None: with self._lock: self._alarms.append({ "id": self._next_id, "type": type_, "trigger": triggerAtMillis, "operation": operation, "interval": 0, "repeat": False, "window": 0, "allow_while_idle": False, }) self._next_id += 1 def setRepeating(self, type_: int, triggerAtMillis: int, intervalMillis: int, operation: Any) -> None: with self._lock: self._alarms.append({ "id": self._next_id, "type": type_, "trigger": triggerAtMillis, "operation": operation, "interval": intervalMillis, "repeat": True, "window": 0, "allow_while_idle": False, }) self._next_id += 1 def setWindow(self, type_: int, windowStartMillis: int, windowLengthMillis: int, operation: Any) -> None: with self._lock: self._alarms.append({ "id": self._next_id, "type": type_, "trigger": windowStartMillis, "operation": operation, "interval": 0, "repeat": False, "window": windowLengthMillis, "allow_while_idle": False, }) self._next_id += 1 def setExact(self, type_: int, triggerAtMillis: int, operation: Any) -> None: self.set(type_, triggerAtMillis, operation) def setExactAndAllowWhileIdle(self, type_: int, triggerAtMillis: int, operation: Any) -> None: self.set(type_, triggerAtMillis, operation) def setAlarmClock(self, info: Any, triggerAtMillis: int, operation: Any) -> None: pass def cancel(self, operation: Any) -> None: with self._lock: self._alarms = [a for a in self._alarms if a.get("operation") != operation] def getNextAlarmClock(self) -> Optional[Any]: return None def canScheduleExactAlarms(self) -> bool: return True def toString(self) -> str: return f"AlarmManager(alarms={len(self._alarms)})" # ═══════════════════════════════════════════════════════════════ # AppOpsManager # ═══════════════════════════════════════════════════════════════ class AppOpsManager(Stub): """AppOpsManager — 应用操作管理器""" MODE_ALLOWED = 0 MODE_IGNORED = 1 MODE_ERRORED = 2 MODE_DEFAULT = 3 MODE_FOREGROUND = 4 OPSTR_COARSE_LOCATION = "android:coarse_location" OPSTR_FINE_LOCATION = "android:fine_location" OPSTR_CAMERA = "android:camera" OPSTR_RECORD_AUDIO = "android:record_audio" OPSTR_READ_CONTACTS = "android:read_contacts" OPSTR_WRITE_CONTACTS = "android:write_contacts" OPSTR_READ_EXTERNAL_STORAGE = "android:read_external_storage" OPSTR_WRITE_EXTERNAL_STORAGE = "android:write_external_storage" OPSTR_ACCESS_NOTIFICATIONS = "android:access_notifications" OPSTR_POST_NOTIFICATIONS = "android:post_notifications" OPSTR_VIBRATE = "android:vibrate" OPSTR_CALL_PHONE = "android:call_phone" OPSTR_READ_SMS = "android:read_sms" OPSTR_SEND_SMS = "android:send_sms" OPSTR_RECEIVE_SMS = "android:receive_sms" OPSTR_SYSTEM_ALERT_WINDOW = "android:system_alert_window" OPSTR_REQUEST_INSTALL_PACKAGES = "android:request_install_packages" OPSTR_BLUETOOTH = "android:bluetooth" OPSTR_BLUETOOTH_SCAN = "android:bluetooth_scan" OPSTR_BLUETOOTH_ADVERTISE = "android:bluetooth_advertise" OPSTR_BLUETOOTH_CONNECT = "android:bluetooth_connect" OPSTR_NFC = "android:nfc" OPSTR_NFC_PREFERRED_PAYMENT = "android:nfc_preferred_payment" OPSTR_PICTURE_IN_PICTURE = "android:picture_in_picture" OPSTR_FOREGROUND_SERVICE = "android:foreground_service" OPSTR_MANAGE_EXTERNAL_STORAGE = "android:manage_external_storage" OPSTR_BODY_SENSORS = "android:body_sensors" OPSTR_ACTIVITY_RECOGNITION = "android:activity_recognition" OPSTR_USE_BIOMETRIC = "android:use_biometric" OPSTR_USE_FINGERPRINT = "android:use_fingerprint" def __init__(self, context: Any = None): super().__init__() self._context = context self._op_modes: Dict[str, Dict[str, int]] = {} self._lock = threading.Lock() def checkOp(self, op: str, uid: int, packageName: str) -> int: with self._lock: if packageName not in self._op_modes: return AppOpsManager.MODE_ALLOWED return self._op_modes[packageName].get(op, AppOpsManager.MODE_ALLOWED) def noteOp(self, op: str, uid: int, packageName: str) -> int: return self.checkOp(op, uid, packageName) def startOp(self, op: str, uid: int, packageName: str) -> int: return self.checkOp(op, uid, packageName) def finishOp(self, op: str, uid: int, packageName: str) -> None: pass def setMode(self, code: int, uid: int, packageName: str, mode: int) -> None: with self._lock: if packageName not in self._op_modes: self._op_modes[packageName] = {} self._op_modes[packageName][str(code)] = mode def toString(self) -> str: return f"AppOpsManager(packages={len(self._op_modes)})" # ═══════════════════════════════════════════════════════════════ # ClipboardManager # ═══════════════════════════════════════════════════════════════ class ClipboardManager(Stub): """ClipboardManager — 剪贴板管理器""" def __init__(self, context: Any = None): super().__init__() self._context = context self._primary_clip: Optional[Any] = None self._listeners: List[Callable] = [] self._has_clipboard = True self._clipboard_history: List[Any] = [] self._max_history = 10 def setPrimaryClip(self, clip: Any) -> None: self._primary_clip = clip if clip is not None: self._clipboard_history.append(clip) if len(self._clipboard_history) > self._max_history: self._clipboard_history.pop(0) for listener in self._listeners: try: listener(clip) except Exception: pass def clearPrimaryClip(self) -> None: if self._primary_clip is not None: self._clipboard_history.append(None) self._primary_clip = None def getPrimaryClip(self) -> Optional[Any]: return self._primary_clip def hasPrimaryClip(self) -> bool: return self._primary_clip is not None def hasClipboardText(self) -> bool: if self._primary_clip is None: return False try: return hasattr(self._primary_clip, "getText") and self._primary_clip.getText() is not None except Exception: return False def getText(self) -> Optional[str]: if self._primary_clip is not None: try: return self._primary_clip.getText() except Exception: pass return None def addPrimaryClipChangedListener(self, listener: Callable) -> None: if listener not in self._listeners: self._listeners.append(listener) def removePrimaryClipChangedListener(self, listener: Callable) -> None: if listener in self._listeners: self._listeners.remove(listener) def getClipboardHistory(self) -> List[Any]: return list(self._clipboard_history) def toString(self) -> str: return f"ClipboardManager(has_clip={self.hasPrimaryClip()})" # ═══════════════════════════════════════════════════════════════ # ConnectivityManager (扩展) # ═══════════════════════════════════════════════════════════════ class ConnectivityManager(Stub): """ConnectivityManager — 连接管理器 (扩展)""" TYPE_NONE = -1 TYPE_MOBILE = 0 TYPE_WIFI = 1 TYPE_MOBILE_MMS = 2 TYPE_MOBILE_SUPL = 3 TYPE_MOBILE_DUN = 4 TYPE_MOBILE_HIPRI = 5 TYPE_WIMAX = 6 TYPE_BLUETOOTH = 7 TYPE_DUMMY = 8 TYPE_ETHERNET = 9 TYPE_VPN = 17 TYPE_WIFI_P2P = 13 EXTRA_NETWORK_TYPE = "networkType" EXTRA_IS_FAILOVER = "isFailover" EXTRA_OTHER_NETWORK_INFO = "otherNetwork" EXTRA_NO_CONNECTIVITY = "noConnectivity" EXTRA_REASON = "reason" EXTRA_EXTRA_INFO = "extraInfo" EXTRA_NETWORK_INFO = "networkInfo" EXTRA_NETWORK_REQUEST = "networkRequest" EXTRA_NETWORK = "network" CONNECTIVITY_ACTION = "android.net.conn.CONNECTIVITY_CHANGE" def __init__(self, context: Any = None): super().__init__() self._context = context self._active_network_info: Optional[Any] = None self._network_preference = ConnectivityManager.TYPE_WIFI self._background_data_setting = True self._network_callbacks: List[Any] = [] self._active_network: Optional[Any] = None self._all_networks: List[Any] = [] def getActiveNetworkInfo(self) -> Optional[Any]: return self._active_network_info def getNetworkInfo(self, networkType: int) -> Optional[Any]: return None def getNetworkInfo(self, network: Any) -> Optional[Any]: return None def getAllNetworkInfo(self) -> List[Any]: return self._all_networks def isActiveNetworkMetered(self) -> bool: return True def getActiveNetwork(self) -> Optional[Any]: return self._active_network def getAllNetworks(self) -> List[Any]: return list(self._all_networks) def requestNetwork(self, request: Any, callback: Any) -> None: pass def registerNetworkCallback(self, request: Any, callback: Any) -> None: if callback not in self._network_callbacks: self._network_callbacks.append(callback) def unregisterNetworkCallback(self, callback: Any) -> None: if callback in self._network_callbacks: self._network_callbacks.remove(callback) def getNetworkCapabilities(self, network: Any) -> Optional[Any]: return None def getLinkProperties(self, network: Any) -> Optional[Any]: return None def setNetworkPreference(self, preference: int) -> None: self._network_preference = preference def getBackgroundDataSetting(self) -> bool: return self._background_data_setting def setBackgroundDataSetting(self, allow: bool) -> None: self._background_data_setting = allow def reportBadNetwork(self, network: Any) -> None: pass def toString(self) -> str: return f"ConnectivityManager(active={self._active_network_info is not None})" # ═══════════════════════════════════════════════════════════════ # DevicePolicyManager (扩展) # ═══════════════════════════════════════════════════════════════ class DevicePolicyManager(Stub): """DevicePolicyManager — 设备策略管理器 (扩展)""" ACTION_ADD_DEVICE_ADMIN = "android.app.action.ADD_DEVICE_ADMIN" ACTION_DEVICE_ADMIN_ENABLED = "android.app.action.DEVICE_ADMIN_ENABLED" ACTION_DEVICE_ADMIN_DISABLED = "android.app.action.DEVICE_ADMIN_DISABLED" ACTION_SET_NEW_PASSWORD = "android.app.action.SET_NEW_PASSWORD" ACTION_START_ENCRYPTION = "android.app.action.START_ENCRYPTION" ACTION_PROVISION_MANAGED_PROFILE = "android.app.action.PROVISION_MANAGED_PROFILE" ACTION_SYSTEM_UPDATE_POLICY = "android.app.action.SYSTEM_UPDATE_POLICY" KEYGUARD_DISABLE_FEATURES_NONE = 0 KEYGUARD_DISABLE_FEATURES_ALL = 0x7FFFFFFF KEYGUARD_DISABLE_SECURE_CAMERA = 2 KEYGUARD_DISABLE_FINGERPRINT = 32 KEYGUARD_DISABLE_REMOTE_INPUT = 64 KEYGUARD_DISABLE_FACE = 128 KEYGUARD_DISABLE_IRIS = 256 KEYGUARD_DISABLE_BIOMETRICS = 32 | 128 | 256 KEYGUARD_DISABLE_SHORTCUTS = 512 KEYGUARD_DISABLE_WIDGETS_ALL = 1048576 PASSWORD_QUALITY_UNSPECIFIED = 0 PASSWORD_QUALITY_SOMETHING = 0x10000 PASSWORD_QUALITY_NUMERIC = 0x20000 PASSWORD_QUALITY_NUMERIC_COMPLEX = 0x30000 PASSWORD_QUALITY_ALPHABETIC = 0x40000 PASSWORD_QUALITY_ALPHANUMERIC = 0x50000 PASSWORD_QUALITY_COMPLEX = 0x60000 PASSWORD_QUALITY_MANAGED = 0x80000 PASSWORD_QUALITY_BIOMETRIC_WEAK = 0x8000 RESET_PASSWORD_REQUIRE_ENTRY = 0x0001 RESET_PASSWORD_DO_NOT_ASK_CREDENTIALS_ON_BOOT = 0x0002 def __init__(self, context: Any = None): super().__init__() self._context = context self._admin_receivers: List[Any] = [] self._password_quality = DevicePolicyManager.PASSWORD_QUALITY_UNSPECIFIED self._password_length = 0 self._maximum_failed_passwords_for_wipe = 0 self._maximum_time_to_lock = 0 self._storage_encryption = False self._camera_disabled = False self._screen_capture_disabled = False self._keyguard_disabled_features = DevicePolicyManager.KEYGUARD_DISABLE_FEATURES_NONE self._lock_task_packages: List[str] = [] def isDeviceOwnerApp(self, packageName: str) -> bool: return False def isProfileOwnerApp(self, packageName: str) -> bool: return False def getDeviceOwner(self) -> Optional[str]: return None def getProfileOwner(self) -> Optional[Any]: return None def setPasswordQuality(self, admin: Any, quality: int) -> None: self._password_quality = quality def getPasswordQuality(self, admin: Any = None) -> int: return self._password_quality def setPasswordMinimumLength(self, admin: Any, length: int) -> None: self._password_length = length def getPasswordMinimumLength(self, admin: Any = None) -> int: return self._password_length def resetPassword(self, password: str, flags: int = 0) -> bool: return True def setMaximumFailedPasswordsForWipe(self, admin: Any, num: int) -> None: self._maximum_failed_passwords_for_wipe = num def getMaximumFailedPasswordsForWipe(self, admin: Any = None) -> int: return self._maximum_failed_passwords_for_wipe def setMaximumTimeToLock(self, admin: Any, timeMs: int) -> None: self._maximum_time_to_lock = timeMs def getMaximumTimeToLock(self, admin: Any = None) -> int: return self._maximum_time_to_lock def lockNow(self) -> None: pass def wipeData(self, flags: int = 0) -> None: raise RuntimeError("wipeData() would wipe device data") def setStorageEncryption(self, admin: Any, encrypt: bool) -> int: self._storage_encryption = encrypt return 1 def getStorageEncryption(self, admin: Any = None) -> bool: return self._storage_encryption def setCameraDisabled(self, admin: Any, disabled: bool) -> None: self._camera_disabled = disabled def getCameraDisabled(self, admin: Any = None) -> bool: return self._camera_disabled def setScreenCaptureDisabled(self, admin: Any, disabled: bool) -> None: self._screen_capture_disabled = disabled def getScreenCaptureDisabled(self, admin: Any = None) -> bool: return self._screen_capture_disabled def setKeyguardDisabledFeatures(self, admin: Any, features: int) -> None: self._keyguard_disabled_features = features def getKeyguardDisabledFeatures(self, admin: Any = None) -> int: return self._keyguard_disabled_features def setLockTaskPackages(self, admin: Any, packages: List[str]) -> None: self._lock_task_packages = list(packages) def getLockTaskPackages(self, admin: Any = None) -> List[str]: return list(self._lock_task_packages) def isLockTaskPermitted(self, pkg: str) -> bool: return pkg in self._lock_task_packages def toString(self) -> str: return f"DevicePolicyManager(password_quality=0x{self._password_quality:x})" # ═══════════════════════════════════════════════════════════════ # DisplayManager (扩展) # ═══════════════════════════════════════════════════════════════ class DisplayManager(Stub): """DisplayManager — 显示管理器 (扩展)""" DISPLAY_CATEGORY_PRESENTATION = "android.hardware.display.category.PRESENTATION" VIRTUAL_DISPLAY_FLAG_AUTO_MIRROR = 0x00000001 VIRTUAL_DISPLAY_FLAG_OWN_CONTENT_ONLY = 0x00000002 VIRTUAL_DISPLAY_FLAG_PRESENTATION = 0x00000004 VIRTUAL_DISPLAY_FLAG_SECURE = 0x00000008 VIRTUAL_DISPLAY_FLAG_PUBLIC = 0x00000010 VIRTUAL_DISPLAY_FLAG_SUPPORTS_TOUCH = 0x00000020 VIRTUAL_DISPLAY_FLAG_ROTATES_WITH_CONTENT = 0x00000040 VIRTUAL_DISPLAY_FLAG_DESTROY_CONTENT_ON_SURFACE = 0x00000080 def __init__(self, context: Any = None): super().__init__() self._context = context self._displays: Dict[int, Any] = {} self._display_listeners: List[Any] = [] self._default_display: Optional[Any] = None self._virtual_displays: Dict[str, Any] = {} def getDisplay(self, displayId: int) -> Optional[Any]: return self._displays.get(displayId) def getDisplays(self, category: Optional[str] = None) -> List[Any]: if category: return [d for d in self._displays.values()] return list(self._displays.values()) def getDefaultDisplay(self) -> Optional[Any]: return self._default_display def registerDisplayListener(self, listener: Any, handler: Any = None) -> None: if listener not in self._display_listeners: self._display_listeners.append(listener) def unregisterDisplayListener(self, listener: Any) -> None: if listener in self._display_listeners: self._display_listeners.remove(listener) def createVirtualDisplay( self, name: str, width: int, height: int, densityDpi: int, surface: Any, flags: int = 0 ) -> Optional[Any]: return None def toString(self) -> str: return f"DisplayManager(displays={len(self._displays)})" # ═══════════════════════════════════════════════════════════════ # DownloadManager # ═══════════════════════════════════════════════════════════════ class DownloadManager(Stub): """DownloadManager — 下载管理器""" ACTION_DOWNLOAD_COMPLETE = "android.intent.action.DOWNLOAD_COMPLETE" ACTION_NOTIFICATION_CLICKED = "android.intent.action.DOWNLOAD_NOTIFICATION_CLICKED" ACTION_VIEW_DOWNLOADS = "android.intent.action.VIEW_DOWNLOADS" EXTRA_DOWNLOAD_ID = "extraDownloadId" EXTRA_NOTIFICATION_CLICK_DOWNLOAD_IDS = "extraNotificationClickDownloadIds" INTENT_EXTRAS_SORT_BY_SIZE = "android.app.DownloadManager.extraSortBySize" COLUMN_ID = "_id" COLUMN_TITLE = "title" COLUMN_DESCRIPTION = "description" COLUMN_URI = "uri" COLUMN_STATUS = "status" COLUMN_REASON = "reason" COLUMN_TOTAL_SIZE_BYTES = "total_size" COLUMN_BYTES_DOWNLOADED_SO_FAR = "bytes_so_far" COLUMN_MEDIA_TYPE = "media_type" COLUMN_LOCAL_FILENAME = "local_filename" COLUMN_LOCAL_URI = "local_uri" COLUMN_LAST_MODIFIED_TIMESTAMP = "last_modified_timestamp" STATUS_PENDING = 1 STATUS_RUNNING = 2 STATUS_PAUSED = 3 STATUS_SUCCESSFUL = 4 STATUS_FAILED = 5 STATUS_QUEUED = 6 STATUS_WAITING = 7 STATUS_WAITING_FOR_NETWORK = 8 STATUS_WAITING_FOR_WIFI = 9 ERROR_UNKNOWN = 1000 ERROR_DEVICE_NOT_FOUND = 1001 ERROR_CANNOT_RESUME = 1002 ERROR_FILE_ALREADY_EXISTS = 1003 ERROR_FILE_ERROR = 1004 ERROR_HTTP_DATA_ERROR = 1005 ERROR_INSUFFICIENT_SPACE = 1006 ERROR_TOO_MANY_REDIRECTS = 1007 ERROR_UNHANDLED_HTTP_CODE = 1008 ERROR_HTTP_406 = 1009 PAUSED_QUEUED_FOR_WIFI = 1 PAUSED_WAITING_TO_RETRY = 2 PAUSED_WAITING_FOR_NETWORK = 3 PAUSED_UNKNOWN = 4 def __init__(self, context: Any = None): super().__init__() self._context = context self._downloads: Dict[int, Dict[str, Any]] = {} self._next_id = 1 self._lock = threading.Lock() def enqueue(self, request: Any) -> int: with self._lock: download_id = self._next_id self._next_id += 1 self._downloads[download_id] = { "id": download_id, "status": DownloadManager.STATUS_PENDING, "reason": 0, "title": "", "description": "", "uri": "", "total_size": -1, "bytes_so_far": 0, "local_filename": "", } return download_id def query(self, query: Any) -> Any: return None def remove(self, varargs: List[int]) -> int: removed = 0 with self._lock: for download_id in varargs: if download_id in self._downloads: del self._downloads[download_id] removed += 1 return removed def getUriForDownloadedFile(self, downloadId: int) -> Optional[str]: return None def getMimeTypeForDownloadedFile(self, downloadId: int) -> Optional[str]: return None def restartDownload(self, downloadId: int) -> bool: return False def toString(self) -> str: return f"DownloadManager(downloads={len(self._downloads)})" # ═══════════════════════════════════════════════════════════════ # DropBoxManager # ═══════════════════════════════════════════════════════════════ class DropBoxManager(Stub): """DropBoxManager — 日志收集管理器""" IS_EMPTY = 0 IS_TEXT = 1 IS_GZIPPED = 2 IS_ENCRYPTED = 4 def __init__(self, context: Any = None): super().__init__() self._entries: Dict[str, List[Any]] = {} self._max_entries = 100 def addText(self, tag: str, data: str) -> None: if tag not in self._entries: self._entries[tag] = [] self._entries[tag].append(("text", data, time.time())) if len(self._entries[tag]) > self._max_entries: self._entries[tag].pop(0) def addData(self, tag: str, data: bytes, flags: int = 0) -> None: if tag not in self._entries: self._entries[tag] = [] self._entries[tag].append(("data", data, time.time(), flags)) if len(self._entries[tag]) > self._max_entries: self._entries[tag].pop(0) def getNextEntry(self, tag: str, msec: int) -> Optional[Any]: return None def isTagEnabled(self, tag: str) -> bool: return True def dump(self, pw: Any) -> None: pass def toString(self) -> str: return f"DropBoxManager(entries={sum(len(v) for v in self._entries.values())})" # ═══════════════════════════════════════════════════════════════ # FocusManager # ═══════════════════════════════════════════════════════════════ class FocusManager(Stub): """FocusManager — 焦点管理器""" def __init__(self, context: Any = None): super().__init__() self._context = context self._focused_view: Optional[Any] = None self._focus_cycle_enabled = True self._focus_search_enabled = True def getFocusedView(self) -> Optional[Any]: return self._focused_view def setFocusedView(self, view: Any) -> None: self._focused_view = view def clearFocus(self) -> None: self._focused_view = None def isFocusCycleEnabled(self) -> bool: return self._focus_cycle_enabled def setFocusCycleEnabled(self, enabled: bool) -> None: self._focus_cycle_enabled = enabled def requestFocus(self, view: Any, direction: int = 0) -> bool: self._focused_view = view return True def toString(self) -> str: return f"FocusManager(focused={self._focused_view is not None})" # ═══════════════════════════════════════════════════════════════ # LauncherApps # ═══════════════════════════════════════════════════════════════ class LauncherApps(Stub): """LauncherApps — 启动器应用管理器""" def __init__(self, context: Any = None): super().__init__() self._context = context self._callbacks: List[Any] = [] self._shortcuts: Dict[str, List[Any]] = {} def getActivityList(self, packageName: str, user: Any) -> List[Any]: return [] def getApplicationList(self, user: Any) -> List[Any]: return [] def startAppDetails(self, component: Any, user: Any, sourceBounds: Any, opts: Any) -> None: pass def startMainActivity(self, component: Any, user: Any, sourceBounds: Any, opts: Any) -> None: pass def getShortcutConfigActivityList(self, packageName: str, user: Any) -> List[Any]: return [] def hasShortcutHostPermission(self) -> bool: return True def getShortcuts(self, filter_: Any, user: Any) -> List[Any]: return [] def pinShortcuts(self, packageName: str, shortcutIds: List[str], user: Any) -> bool: return True def registerCallback(self, callback: Any) -> None: if callback not in self._callbacks: self._callbacks.append(callback) def unregisterCallback(self, callback: Any) -> None: if callback in self._callbacks: self._callbacks.remove(callback) def toString(self) -> str: return f"LauncherApps(callbacks={len(self._callbacks)})" # ═══════════════════════════════════════════════════════════════ # MediaRouter # ═══════════════════════════════════════════════════════════════ class MediaRouter(Stub): """MediaRouter — 媒体路由管理器""" ROUTE_TYPE_LIVE_AUDIO = 1 ROUTE_TYPE_LIVE_VIDEO = 2 ROUTE_TYPE_REMOTE_DISPLAY = 4 ROUTE_TYPE_USER = 8 ROUTE_TYPE_ANY = 0x800000 UNSELECT_REASON_UNKNOWN = 0 UNSELECT_REASON_ROUTE_CHANGED = 1 UNSELECT_REASON_DISCONNECTED = 2 UNSELECT_REASON_STOPPED = 3 def __init__(self, context: Any = None): super().__init__() self._context = context self._routes: List[Any] = [] self._selected_route: Optional[Any] = None self._default_route: Optional[Any] = None self._callbacks: List[Any] = [] def getDefaultRoute(self) -> Optional[Any]: return self._default_route def getSelectedRoute(self, type_: int) -> Optional[Any]: return self._selected_route def selectRoute(self, type_: int, route: Any) -> None: self._selected_route = route def addCallback(self, types: int, cb: Any) -> None: if cb not in self._callbacks: self._callbacks.append(cb) def removeCallback(self, cb: Any) -> None: if cb in self._callbacks: self._callbacks.remove(cb) def getRoutes(self) -> List[Any]: return list(self._routes) def isUserRouteAllowed(self) -> bool: return True def toString(self) -> str: return f"MediaRouter(routes={len(self._routes)})" # ═══════════════════════════════════════════════════════════════ # NetworkPolicyManager # ═══════════════════════════════════════════════════════════════ class NetworkPolicyManager(Stub): """NetworkPolicyManager — 网络策略管理器""" POLICY_NONE = 0 POLICY_REJECT_METERED_BACKGROUND = 1 POLICY_ALLOW_METERED_BACKGROUND = 4 RULE_ALLOW_ALL = 0 RULE_REJECT_METERED = 1 RULE_REJECT_ALL = 2 RULE_TEMPORARY_ALLOW_METERED = 3 def __init__(self, context: Any = None): super().__init__() self._context = context self._uid_policies: Dict[int, int] = {} self._uid_rules: Dict[int, int] = {} self._restrict_background = False def getUidPolicy(self, uid: int) -> int: return self._uid_policies.get(uid, NetworkPolicyManager.POLICY_NONE) def setUidPolicy(self, uid: int, policy: int) -> None: self._uid_policies[uid] = policy def getUidsWithPolicy(self, policy: int) -> List[int]: return [uid for uid, p in self._uid_policies.items() if p == policy] def isUidNetworkingBlocked(self, uid: int, metered: bool) -> bool: return False def registerListener(self, listener: Any) -> None: pass def unregisterListener(self, listener: Any) -> None: pass def toString(self) -> str: return f"NetworkPolicyManager(uids={len(self._uid_policies)})" # ═══════════════════════════════════════════════════════════════ # NotificationManager (扩展) # ═══════════════════════════════════════════════════════════════ class NotificationManagerExt(Stub): """NotificationManager (Extension) — 额外通知管理器功能""" def __init__(self, context: Any = None): super().__init__() self._context = context def getSnoozeIntentForChannel(self, channelId: str) -> Optional[Any]: return None def matchesCallFilter(self, address: Any) -> bool: return True def getActiveNotificationsFromBinder(self) -> List[Any]: return [] def getHistoricalNotifications(self) -> List[Any]: return [] def canNotifyAsPackage(self, pkg: str) -> bool: return True def setNotificationDelegate(self, delegate: str) -> None: pass def getNotificationDelegate(self) -> Optional[str]: return None def updateNotificationChannelGroup(self, group: Any) -> None: pass def toString(self) -> str: return "NotificationManager(Extension)" # ═══════════════════════════════════════════════════════════════ # NsdManager (quick reference for net_nsd 模块) # ═══════════════════════════════════════════════════════════════ class NsdManagerQuick(Stub): """NsdManager (Quick Reference)""" PROTOCOL_DNS_SD = 0 FAILURE_ALREADY_ACTIVE = 3 FAILURE_INTERNAL_ERROR = 0 FAILURE_MAX_LIMIT = 4 FAILURE_SERVICE_NOT_FOUND = 1 FAILURE_SERVICE_NOT_RUNNING = 2 def __init__(self, context: Any = None): super().__init__() self._context = context def discoverServices(self, serviceType: str, protocolType: int, listener: Any) -> None: pass def stopServiceDiscovery(self, listener: Any) -> None: pass def registerService(self, serviceInfo: Any, protocolType: int, listener: Any) -> None: pass def unregisterService(self, listener: Any) -> None: pass def resolveService(self, serviceInfo: Any, listener: Any) -> None: pass def toString(self) -> str: return "NsdManager" # ═══════════════════════════════════════════════════════════════ # RestrictionManager # ═══════════════════════════════════════════════════════════════ class RestrictionManager(Stub): """RestrictionManager — 限制管理器""" def __init__(self, context: Any = None): super().__init__() self._context = context self._restrictions: Dict[str, Any] = {} self._lock = threading.Lock() def getApplicationRestrictions(self, packageName: str) -> Any: return None def setApplicationRestrictions(self, packageName: str, restrictions: Any) -> None: pass def hasRestrictionProvider(self) -> bool: return False def getManifestRestrictions(self, packageName: str) -> List[Any]: return [] def getRestrictionsProvider(self, packageName: str) -> Optional[Any]: return None def notifyPermissionResponse(self, packageName: str, response: Any) -> None: pass def toString(self) -> str: return "RestrictionManager" # ═══════════════════════════════════════════════════════════════ # SubscriptionManager # ═══════════════════════════════════════════════════════════════ class SubscriptionManager(Stub): """SubscriptionManager — 订阅管理器""" DEFAULT_SUBSCRIPTION_ID = -1 INVALID_SUBSCRIPTION_ID = -2 ACTIVE_DATA_SUBSCRIPTION_ID = -3 EXTRA_SUBSCRIPTION_INDEX = "android.telephony.extra.SUBSCRIPTION_INDEX" EXTRA_SLOT_INDEX = "android.telephony.extra.SLOT_INDEX" def __init__(self, context: Any = None): super().__init__() self._context = context self._subscriptions: List[Any] = [] def getActiveSubscriptionInfoList(self) -> List[Any]: return list(self._subscriptions) def getActiveSubscriptionInfo(self, subId: int) -> Optional[Any]: for sub in self._subscriptions: if getattr(sub, "subscriptionId", None) == subId: return sub return None def getActiveSubscriptionInfoForSimSlotIndex(self, slotIndex: int) -> Optional[Any]: for sub in self._subscriptions: if getattr(sub, "simSlotIndex", None) == slotIndex: return sub return None def getDefaultSubscriptionId(self) -> int: return SubscriptionManager.DEFAULT_SUBSCRIPTION_ID def setDefaultSubscriptionId(self, subId: int) -> None: pass def addOnSubscriptionsChangedListener(self, listener: Any) -> None: pass def removeOnSubscriptionsChangedListener(self, listener: Any) -> None: pass def getSlotIndex(self, subscriptionId: int) -> int: return -1 def toString(self) -> str: return f"SubscriptionManager(subscriptions={len(self._subscriptions)})" # ═══════════════════════════════════════════════════════════════ # WallpaperManager (扩展) # ═══════════════════════════════════════════════════════════════ class WallpaperManagerExt(Stub): """WallpaperManager (Extension)""" def __init__(self, context: Any = None): super().__init__() self._context = context def getWallpaperIdForWhom(self, which: int) -> int: return -1 def getWallpaperUserId(self) -> int: return 0 def setWallpaperOffsets(self, windowToken: Any, xOffset: float, yOffset: float) -> None: pass def clearWallpaperOffsets(self, windowToken: Any) -> None: pass def hasResourceWallpaper(self, resid: int) -> bool: return False def toString(self) -> str: return "WallpaperManager(Extension)" # ═══════════════════════════════════════════════════════════════ # WifiP2pManager / WifiP2pDevice / WifiP2pGroup / WifiP2pConfig # ═══════════════════════════════════════════════════════════════ class WifiP2pDevice(Stub): """WifiP2pDevice — WiFi P2P 设备""" CONNECTED = 0 INVITED = 1 FAILED = 2 AVAILABLE = 3 UNAVAILABLE = 4 def __init__(self): super().__init__() self.deviceName: Optional[str] = None self.deviceAddress: Optional[str] = None self.primaryDeviceType: Optional[str] = None self.secondaryDeviceType: Optional[str] = None self.status = WifiP2pDevice.AVAILABLE self.wpsConfigMethodsSupported = 0 self.groupCapabilityFlags = 0 self.deviceCapabilityFlags = 0 self.serviceDiscoveryCapable = False self.isGroupOwner = False self._supports_wfd = False self._interface_address: Optional[str] = None def isGroupOwner(self) -> bool: return self.isGroupOwner def wpsDisplaySupported(self) -> bool: return (self.wpsConfigMethodsSupported & 0x1000) != 0 def wpsKeypadSupported(self) -> bool: return (self.wpsConfigMethodsSupported & 0x0100) != 0 def wpsPbcSupported(self) -> bool: return (self.wpsConfigMethodsSupported & 0x0040) != 0 def equals(self, other: Any) -> bool: if isinstance(other, WifiP2pDevice): return self.deviceAddress == other.deviceAddress return False def hashCode(self) -> int: return hash(self.deviceAddress) & 0x7FFFFFFF def toString(self) -> str: return f"WifiP2pDevice(name={self.deviceName}, addr={self.deviceAddress}, status={self.status})" class WifiP2pGroup(Stub): """WifiP2pGroup — WiFi P2P 组""" def __init__(self): super().__init__() self._network_name: Optional[str] = None self._owner: Optional[WifiP2pDevice] = None self._is_group_owner = False self._passphrase: Optional[str] = None self._interface: Optional[str] = None self._clients: List[WifiP2pDevice] = [] self._frequency = 0 def getNetworkName(self) -> Optional[str]: return self._network_name def isGroupOwner(self) -> bool: return self._is_group_owner def getOwner(self) -> Optional[WifiP2pDevice]: return self._owner def getPassphrase(self) -> Optional[str]: return self._passphrase def getInterface(self) -> Optional[str]: return self._interface def getClientList(self) -> List[WifiP2pDevice]: return list(self._clients) def getFrequency(self) -> int: return self._frequency def addClient(self, device: WifiP2pDevice) -> None: if device not in self._clients: self._clients.append(device) def removeClient(self, device: WifiP2pDevice) -> None: if device in self._clients: self._clients.remove(device) def toString(self) -> str: return f"WifiP2pGroup(net={self._network_name}, clients={len(self._clients)})" class WifiP2pConfig(Stub): """WifiP2pConfig — WiFi P2P 配置""" class Builder(Stub): """WifiP2pConfig.Builder — 构建器""" def __init__(self): super().__init__() self._config = WifiP2pConfig() def setDeviceAddress(self, address: str) -> "WifiP2pConfig.Builder": self._config._device_address = address return self def setDeviceName(self, name: str) -> "WifiP2pConfig.Builder": self._config._device_name = name return self def setGroupOwnerIntent(self, intent: int) -> "WifiP2pConfig.Builder": self._config._group_owner_intent = intent return self def setNetworkName(self, name: str) -> "WifiP2pConfig.Builder": self._config._network_name = name return self def setPassphrase(self, passphrase: str) -> "WifiP2pConfig.Builder": self._config._passphrase = passphrase return self def enablePersistentMode(self, enabled: bool) -> "WifiP2pConfig.Builder": self._config._persistent_mode = enabled return self def build(self) -> "WifiP2pConfig": return self._config def __init__(self): super().__init__() self._device_address: Optional[str] = None self._device_name: Optional[str] = None self._group_owner_intent = -1 self._network_name: Optional[str] = None self._passphrase: Optional[str] = None self._persistent_mode = False self._wps_config = 0 self._net_id = -1 def getDeviceAddress(self) -> Optional[str]: return self._device_address def getDeviceName(self) -> Optional[str]: return self._device_name def getGroupOwnerIntent(self) -> int: return self._group_owner_intent def isPersistentMode(self) -> bool: return self._persistent_mode def toString(self) -> str: return f"WifiP2pConfig(addr={self._device_address}, name={self._device_name})" class WifiP2pManager(Stub): """WifiP2pManager — WiFi P2P 管理器""" WIFI_P2P_STATE_ENABLED = 2 WIFI_P2P_STATE_DISABLED = 1 WIFI_P2P_PEERS_CHANGED_ACTION = "android.net.wifi.p2p.PEERS_CHANGED" WIFI_P2P_STATE_CHANGED_ACTION = "android.net.wifi.p2p.STATE_CHANGED" WIFI_P2P_CONNECTION_CHANGED_ACTION = "android.net.wifi.p2p.CONNECTION_STATE_CHANGE" WIFI_P2P_THIS_DEVICE_CHANGED_ACTION = "android.net.wifi.p2p.THIS_DEVICE_CHANGED" WIFI_P2P_DISCOVERY_CHANGED_ACTION = "android.net.wifi.p2p.DISCOVERY_STATE_CHANGE" WIFI_P2P_PERSISTENT_GROUPS_CHANGED_ACTION = "android.net.wifi.p2p.PERSISTENT_GROUPS_CHANGED" BUSY = 2 ERROR = 0 P2P_UNSUPPORTED = 1 NO_SERVICE_REQUESTS = 3 def __init__(self, context: Any = None): super().__init__() self._context = context self._peers: List[WifiP2pDevice] = [] self._services: List[Any] = [] self._discovery_running = False self._this_device: Optional[WifiP2pDevice] = None self._groups: List[WifiP2pGroup] = [] self._listeners: Dict[str, List[Any]] = {} def initialize(self, context: Any, looper: Any, listener: Any) -> "WifiP2pManager": return self def discoverPeers(self, channel: Any, listener: Any) -> None: self._discovery_running = True if listener: listener.onSuccess() def stopPeerDiscovery(self, channel: Any, listener: Any) -> None: self._discovery_running = False if listener: listener.onSuccess() def requestPeers(self, channel: Any, listener: Any) -> None: if listener: listener.onPeersAvailable(self._peers) def connect(self, channel: Any, config: WifiP2pConfig, listener: Any) -> None: if listener: listener.onSuccess() def cancelConnect(self, channel: Any, listener: Any) -> None: if listener: listener.onSuccess() def createGroup(self, channel: Any, listener: Any) -> None: if listener: listener.onSuccess() def removeGroup(self, channel: Any, listener: Any) -> None: if listener: listener.onSuccess() def requestGroupInfo(self, channel: Any, listener: Any) -> None: if listener and self._groups: listener.onGroupInfoAvailable(self._groups[0] if self._groups else None) def requestConnectionInfo(self, channel: Any, listener: Any) -> None: if listener: listener.onConnectionInfoAvailable(None) def setDeviceName(self, channel: Any, deviceName: str, listener: Any) -> None: if listener: listener.onSuccess() def setWpsPbc(self, channel: Any, iface: str, listener: Any) -> None: if listener: listener.onSuccess() def setWpsPin(self, channel: Any, iface: str, pin: str, listener: Any) -> None: if listener: listener.onSuccess() def getAvailableServiceInfo(self, device: WifiP2pDevice) -> Optional[Any]: return None def addServiceRequest(self, channel: Any, req: Any, listener: Any) -> None: if listener: listener.onSuccess() def removeServiceRequest(self, channel: Any, req: Any, listener: Any) -> None: if listener: listener.onSuccess() def setServiceResponseListener(self, channel: Any, listener: Any) -> None: pass def clearServiceResponses(self, channel: Any, listener: Any) -> None: if listener: listener.onSuccess() def clearLocalServices(self, channel: Any, listener: Any) -> None: if listener: listener.onSuccess() def requestServiceInfo(self, channel: Any, device: WifiP2pDevice, listener: Any) -> None: if listener: listener.onServiceInfoAvailable(None) def getWifiP2pDeviceList(self) -> List[WifiP2pDevice]: return list(self._peers) def isDiscoveryRunning(self) -> bool: return self._discovery_running def toString(self) -> str: return f"WifiP2pManager(peers={len(self._peers)}, discovery={self._discovery_running})" # ═══════════════════════════════════════════════════════════════ # WindowManager # ═══════════════════════════════════════════════════════════════ class WindowManager(Stub): """WindowManager — 窗口管理器""" # LayoutParams 类型 TYPE_BASE_APPLICATION = 1 TYPE_APPLICATION = 2 TYPE_APPLICATION_STARTING = 3 TYPE_APPLICATION_PANEL = 1000 TYPE_APPLICATION_MEDIA = 1001 TYPE_APPLICATION_SUB_PANEL = 1002 TYPE_APPLICATION_ATTACHED_DIALOG = 1003 TYPE_APPLICATION_OVERLAY = 1004 TYPE_STATUS_BAR = 2000 TYPE_SYSTEM_ALERT = 2003 TYPE_SYSTEM_OVERLAY = 2006 TYPE_TOAST = 2005 TYPE_PHONE = 2002 TYPE_PRIORITY_PHONE = 2007 TYPE_SYSTEM_DIALOG = 2008 TYPE_KEYGUARD = 2004 TYPE_INPUT_METHOD = 2011 TYPE_INPUT_METHOD_DIALOG = 2012 TYPE_WALLPAPER = 2013 TYPE_NAVIGATION_BAR = 2019 TYPE_DREAM = 2024 TYPE_ACCESSIBILITY_OVERLAY = 2032 TYPE_VOLUME_OVERLAY = 2033 TYPE_SECURE_SYSTEM_OVERLAY = 2034 # LayoutParams 标志 FLAG_ALLOW_LOCK_WHILE_SCREEN_ON = 0x00000001 FLAG_DIM_BEHIND = 0x00000002 FLAG_BLUR_BEHIND = 0x00000004 FLAG_NOT_FOCUSABLE = 0x00000008 FLAG_NOT_TOUCHABLE = 0x00000010 FLAG_NOT_TOUCH_MODAL = 0x00000020 FLAG_TOUCHABLE_WHEN_WAKING = 0x00000040 FLAG_KEEP_SCREEN_ON = 0x00000080 FLAG_LAYOUT_IN_SCREEN = 0x00000100 FLAG_LAYOUT_NO_LIMITS = 0x00000200 FLAG_FULLSCREEN = 0x00000400 FLAG_FORCE_NOT_FULLSCREEN = 0x00000800 FLAG_DITHER = 0x00001000 FLAG_SECURE = 0x00002000 FLAG_SCALED = 0x00004000 FLAG_IGNORE_CHEEK_PRESSES = 0x00008000 FLAG_LAYOUT_INSET_DECOR = 0x00010000 FLAG_ALT_FOCUSABLE_IM = 0x00020000 FLAG_WATCH_OUTSIDE_TOUCH = 0x00040000 FLAG_SHOW_WHEN_LOCKED = 0x00080000 FLAG_SHOW_WALLPAPER = 0x00100000 FLAG_TURN_SCREEN_ON = 0x00200000 FLAG_DISMISS_KEYGUARD = 0x00400000 FLAG_SPLIT_TOUCH = 0x00800000 FLAG_HARDWARE_ACCELERATED = 0x01000000 FLAG_LOCAL_FOCUS_MODE = 0x10000000 FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS = 0x20000000 FLAG_TRANSLUCENT_STATUS = 0x04000000 FLAG_TRANSLUCENT_NAVIGATION = 0x08000000 # 软输入模式 SOFT_INPUT_STATE_UNSPECIFIED = 0 SOFT_INPUT_STATE_UNCHANGED = 1 SOFT_INPUT_STATE_HIDDEN = 2 SOFT_INPUT_STATE_ALWAYS_HIDDEN = 3 SOFT_INPUT_STATE_VISIBLE = 4 SOFT_INPUT_STATE_ALWAYS_VISIBLE = 5 SOFT_INPUT_ADJUST_RESIZE = 0x10 SOFT_INPUT_ADJUST_PAN = 0x20 SOFT_INPUT_ADJUST_NOTHING = 0x30 SOFT_INPUT_ADJUST_UNSPECIFIED = 0x00 SOFT_INPUT_IS_FORWARD_NAVIGATION = 0x100 INVALID_DISPLAY = -1 DOCKED_INVALID = -1 DOCKED_LEFT = 1 DOCKED_TOP = 2 DOCKED_RIGHT = 3 DOCKED_BOTTOM = 4 class LayoutParams(Stub): """WindowManager.LayoutParams — 窗口布局参数""" MATCH_PARENT = -1 WRAP_CONTENT = -2 def __init__(self, w: int = -1, h: int = -1, type_: int = 2, flags: int = 0): super().__init__() self.width = w self.height = h self.type = type_ self.flags = flags self.x = 0 self.y = 0 self.horizontalWeight = 0.0 self.verticalWeight = 0.0 self.horizontalMargin = 0.0 self.verticalMargin = 0.0 self.gravity = 0 self.softInputMode = WindowManager.SOFT_INPUT_STATE_UNSPECIFIED self.windowAnimations = -1 self.alpha = 1.0 self.dimAmount = 0.0 self.screenOrientation = -1 self.screenBrightness = -1.0 self.buttonBrightness = -1.0 self.token: Optional[Any] = None self.packageName: Optional[str] = None self.format = -1 self.systemUiVisibility = 0 self.subtreeSystemUiVisibility = 0 self.preferredRefreshRate: float = 0.0 self.colorMode = 0 def toString(self) -> str: return f"LayoutParams({self.width}x{self.height}, type={self.type}, flags=0x{self.flags:x})" def __init__(self, context: Any = None): super().__init__() self._context = context self._default_display: Optional[Any] = None self._current_window_focus: Optional[Any] = None self._window_views: List[Any] = [] def getDefaultDisplay(self) -> Optional[Any]: return self._default_display def getCurrentWindowFocus(self) -> Optional[Any]: return self._current_window_focus def addView(self, view: Any, params: "WindowManager.LayoutParams") -> None: self._window_views.append((view, params)) def updateViewLayout(self, view: Any, params: "WindowManager.LayoutParams") -> None: for i, (v, p) in enumerate(self._window_views): if v is view: self._window_views[i] = (view, params) break def removeView(self, view: Any) -> None: self._window_views = [(v, p) for v, p in self._window_views if v is not view] def removeViewImmediate(self, view: Any) -> None: self.removeView(view) def getWindowViews(self) -> List[Any]: return [v for v, _ in self._window_views] def toString(self) -> str: return f"WindowManager(views={len(self._window_views)})" WindowManager_LayoutParams = WindowManager.LayoutParams