""" Android Power API — PowerManager, PowerProfile, BatteryStats, BatteryManager, BatterySaverController, etc. 方法签名完全对齐 Android SDK """ from __future__ import annotations import os import sys import time import json import platform import threading from datetime import datetime, timedelta from typing import Any, Dict, List, Optional, Set, Tuple, Callable from .._core import Stub, AndroidOnlyError, _app_data_dir from ..java.lang import RuntimeException # Linux 真实实现导入 try: from .._linux_impl import IS_LINUX, LinuxPower, LinuxProcess, HAS_PSUTIL as _HAS_PSUTIL _USE_LINUX = IS_LINUX except ImportError: _USE_LINUX = False IllegalArgumentException = type("IllegalArgumentException", (RuntimeException,), {}) # ═══════════════════════════════════════════════════════════════ # 常量 # ═══════════════════════════════════════════════════════════════ # BATTERY_* 常量 BATTERY_STATUS_UNKNOWN = 1 BATTERY_STATUS_CHARGING = 2 BATTERY_STATUS_DISCHARGING = 3 BATTERY_STATUS_NOT_CHARGING = 4 BATTERY_STATUS_FULL = 5 BATTERY_STATUS_INVALID = 6 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 BATTERY_PLUGGED_AC = 1 BATTERY_PLUGGED_USB = 2 BATTERY_PLUGGED_WIRELESS = 4 BATTERY_PLUGGED_DOCK = 8 BATTERY_PROPERTY_CAPACITY = 0 BATTERY_PROPERTY_CHARGE_COUNTER = 1 BATTERY_PROPERTY_CURRENT_NOW = 2 BATTERY_PROPERTY_CURRENT_AVERAGE = 3 BATTERY_PROPERTY_ENERGY_COUNTER = 4 BATTERY_PROPERTY_STATUS = 5 BATTERY_PROPERTY_TEMPERATURE = 6 BATTERY_PROPERTY_VOLTAGE = 7 BATTERY_PROPERTY_CHARGE_TIME_REMAINING = 8 BATTERY_PROPERTY_DISCHARGE_TIME_REMAINING = 9 # POWER_* 常量 POWER_SAVE_MODE_INIT_TRIGGER_TIMEOUT = 0 POWER_SAVE_MODE_INIT_TRIGGER_DYNAMIC = 1 POWER_SAVE_MODE_INIT_TRIGGER_PERCENTAGE = 2 POWER_SAVE_MODE_INIT_TRIGGER_MANUAL = 3 SCREEN_BRIGHT_MODE_AUTOMATIC = 1 SCREEN_BRIGHT_MODE_MANUAL = 0 # THERMAL_STATUS 常量 THERMAL_STATUS_NONE = 0 THERMAL_STATUS_LIGHT = 1 THERMAL_STATUS_MODERATE = 2 THERMAL_STATUS_SEVERE = 3 THERMAL_STATUS_CRITICAL = 4 THERMAL_STATUS_EMERGENCY = 5 THERMAL_STATUS_SHUTDOWN = 6 # WAKE_LOCK 级别 PARTIAL_WAKE_LOCK = 1 FULL_WAKE_LOCK = 26 SCREEN_DIM_WAKE_LOCK = 6 SCREEN_BRIGHT_WAKE_LOCK = 10 PROXIMITY_SCREEN_OFF_WAKE_LOCK = 32 DOZE_WAKE_LOCK = 64 DRAW_WAKE_LOCK = 128 # ACQUIRE 标志 ACQUIRE_CAUSES_WAKEUP = 0x10000000 ON_AFTER_RELEASE = 0x20000000 WAKE_LOCK_LEVEL_MASK = 0x0000FFFF # ═══════════════════════════════════════════════════════════════ # PowerSaveState # ═══════════════════════════════════════════════════════════════ class PowerSaveState(Stub): """PowerSaveState — 省电状态""" def __init__(self): super().__init__() self._global_battery_saver_enabled = False self._location_mode = 0 self._sound_trigger_mode = 0 self._brightness_factor = 0.0 self._is_interactive = True self._screen_brightness_mode = SCREEN_BRIGHT_MODE_MANUAL self._screen_dim_enabled = False self._power_save_mode = False self._dynamic_power_save_enabled = False self._full_backup_enabled = True self._data_saver_enabled = False def getGlobalBatterySaverEnabled(self) -> bool: return self._global_battery_saver_enabled def getLocationMode(self) -> int: return self._location_mode def getSoundTriggerMode(self) -> int: return self._sound_trigger_mode def getBrightnessFactor(self) -> float: return self._brightness_factor def isInteractive(self) -> bool: return self._is_interactive def getScreenBrightnessMode(self) -> int: return self._screen_brightness_mode def isScreenDimEnabled(self) -> bool: return self._screen_dim_enabled def isPowerSaveMode(self) -> bool: return self._power_save_mode def isDynamicPowerSaveEnabled(self) -> bool: return self._dynamic_power_save_enabled def isFullBackupEnabled(self) -> bool: return self._full_backup_enabled def isDataSaverEnabled(self) -> bool: return self._data_saver_enabled def toString(self) -> str: return ( f"PowerSaveState(battery_saver={self._power_save_mode}, " f"interactive={self._is_interactive})" ) # ═══════════════════════════════════════════════════════════════ # PowerProfile # ═══════════════════════════════════════════════════════════════ class PowerProfile(Stub): """PowerProfile — 电源配置""" POWER_WIFI_ON = "wifi.on" POWER_WIFI_SCAN = "wifi.scan" POWER_WIFI_ACTIVE = "wifi.active" POWER_BLUETOOTH_ON = "bluetooth.on" POWER_BLUETOOTH_ACTIVE = "bluetooth.active" POWER_BLUETOOTH_AT_CMD = "bluetooth.at" POWER_SCREEN_ON = "screen.on" POWER_SCREEN_FULL = "screen.full" POWER_CPU_IDLE = "cpu.idle" POWER_CPU_AWAKE = "cpu.awake" POWER_CPU_ACTIVE = "cpu.active" POWER_AMBIENT_DISPLAY = "ambient.on" POWER_GPS_ON = "gps.on" POWER_CAMERA_ON = "camera.on" POWER_FLASHLIGHT_ON = "flashlight.on" POWER_MICROPHONE_ON = "microphone.on" POWER_RADIO_ON = "radio.on" POWER_RADIO_SCANNING = "radio.scanning" POWER_RADIO_ACTIVE = "radio.active" POWER_AUDIO_ON = "audio.on" POWER_VIDEO_ON = "video.on" POWER_VIBRATION_ON = "vibration.on" POWER_NFC_ON = "nfc.on" POWER_NFC_ACTIVE = "nfc.active" POWER_USB_ON = "usb.on" POWER_MODEM_CONTROLLER_SLEEP = "modem.controller.sleep" POWER_MODEM_CONTROLLER_IDLE = "modem.controller.idle" POWER_MODEM_CONTROLLER_RX = "modem.controller.rx" POWER_MODEM_CONTROLLER_TX = "modem.controller.tx" def __init__(self, context: Any = None): super().__init__() self._context = context self._profile_data: Dict[str, float] = { PowerProfile.POWER_WIFI_ON: 0.1, PowerProfile.POWER_WIFI_SCAN: 0.5, PowerProfile.POWER_WIFI_ACTIVE: 1.0, PowerProfile.POWER_SCREEN_ON: 0.5, PowerProfile.POWER_SCREEN_FULL: 2.0, PowerProfile.POWER_CPU_IDLE: 0.01, PowerProfile.POWER_CPU_AWAKE: 0.1, PowerProfile.POWER_CPU_ACTIVE: 1.0, PowerProfile.POWER_GPS_ON: 1.5, PowerProfile.POWER_BLUETOOTH_ON: 0.2, PowerProfile.POWER_BLUETOOTH_ACTIVE: 0.5, } self._battery_capacity = 4000.0 self._average_battery_lifespan = 24.0 def getAveragePower(self, type_: str) -> float: return self._profile_data.get(type_, 0.0) def getAveragePowerOrDefault(self, type_: str, defaultValue: float) -> float: return self._profile_data.get(type_, defaultValue) def getBatteryCapacity(self) -> float: return self._battery_capacity def setBatteryCapacity(self, capacityMah: float) -> None: self._battery_capacity = capacityMah def getAverageBatteryLifespan(self) -> float: return self._average_battery_lifespan def toString(self) -> str: return f"PowerProfile(battery={self._battery_capacity}mAh)" # ═══════════════════════════════════════════════════════════════ # BatteryStats # ═══════════════════════════════════════════════════════════════ class BatteryStats(Stub): """BatteryStats — 电池统计数据""" # 统计常量 STATS_CURRENT = 0 STATS_SINCE_CHARGED = 1 STATS_SINCE_UNPLUGGED = 2 STATS_UNPLUGGED = 3 # 电源使用者的类型 AUDIO = 0 VIDEO = 1 CAMERA = 2 FLASHLIGHT = 3 GPS = 4 WIFI = 5 BLUETOOTH = 6 PHONE = 7 SCREEN = 8 CPU = 9 IDLE = 10 WAKELOCK = 11 DATA = 12 AMBIENT_DISPLAY = 13 NFC = 14 RADIO = 15 MODEM = 16 SENSORS = 17 VIBRATION = 18 def __init__(self): super().__init__() self._start_time = time.time() self._stats: Dict[int, float] = {} self._charge_counter = 0 self._discharge_counter = 0 self._charge_time_remaining = -1 self._discharge_time_remaining = -1 self._is_charging = False self._battery_level = 100 self._temperature = 25.0 self._voltage = 3800 self._capacity = 4000 self._screen_on_time = 0 self._wifi_on_time = 0 self._bluetooth_on_time = 0 self._gps_on_time = 0 self._cpu_time = 0 self._wake_lock_time = 0 self._mobile_data_time = 0 self._audio_time = 0 self._video_time = 0 self._camera_time = 0 self._flashlight_time = 0 self._ambient_display_time = 0 self._nfc_time = 0 self._radio_time = 0 self._modem_time = 0 self._sensors_time = 0 self._vibration_time = 0 self._full_wake_lock_time = 0 self._partial_wake_lock_time = 0 def getBatteryLevel(self) -> int: return self._battery_level def setBatteryLevel(self, level: int) -> None: self._battery_level = max(0, min(100, level)) def isCharging(self) -> bool: return self._is_charging def getTemperature(self) -> float: return self._temperature def getVoltage(self) -> int: return self._voltage def getCapacity(self) -> int: return self._capacity def getScreenOnTime(self) -> int: return self._screen_on_time def getWifiOnTime(self) -> int: return self._wifi_on_time def getBluetoothOnTime(self) -> int: return self._bluetooth_on_time def getGpsOnTime(self) -> int: return self._gps_on_time def getCpuTime(self) -> int: return self._cpu_time def getWakeLockTime(self) -> int: return self._wake_lock_time def getMobileDataTime(self) -> int: return self._mobile_data_time def getAudioTime(self) -> int: return self._audio_time def getVideoTime(self) -> int: return self._video_time def getCameraTime(self) -> int: return self._camera_time def getFlashlightTime(self) -> int: return self._flashlight_time def getAmbientDisplayTime(self) -> int: return self._ambient_display_time def getNfcTime(self) -> int: return self._nfc_time def getRadioTime(self) -> int: return self._radio_time def getModemTime(self) -> int: return self._modem_time def getSensorsTime(self) -> int: return self._sensors_time def getVibrationTime(self) -> int: return self._vibration_time def getUptime(self) -> int: return int(time.time() - self._start_time) def getChargeTimeRemaining(self) -> int: return self._charge_time_remaining def getDischargeTimeRemaining(self) -> int: return self._discharge_time_remaining def computeBatteryLevelRemaining(self) -> float: return float(self._battery_level) def getChargeCounter(self) -> int: return self._charge_counter def getDischargeCounter(self) -> int: return self._discharge_counter def toString(self) -> str: return f"BatteryStats(level={self._battery_level}%, charging={self._is_charging})" # ═══════════════════════════════════════════════════════════════ # BatteryStatsManager # ═══════════════════════════════════════════════════════════════ class BatteryStatsManager(Stub): """BatteryStatsManager — 电池统计管理器""" def __init__(self, context: Any = None): super().__init__() self._context = context self._battery_stats = BatteryStats() self._lock = threading.Lock() def getBatteryStats(self) -> BatteryStats: with self._lock: return self._battery_stats def reportCharge(self, chargeMah: int) -> None: with self._lock: self._battery_stats._charge_counter += chargeMah def reportDischarge(self, dischargeMah: int) -> None: with self._lock: self._battery_stats._discharge_counter += dischargeMah def resetStatistics(self) -> None: with self._lock: self._battery_stats = BatteryStats() def toString(self) -> str: return f"BatteryStatsManager(stats={self._battery_stats})" # ═══════════════════════════════════════════════════════════════ # BatteryManager (扩展) # ═══════════════════════════════════════════════════════════════ class BatteryManager(Stub): """BatteryManager (扩展) — 电池管理器""" EXTRA_STATUS = "status" EXTRA_HEALTH = "health" EXTRA_PRESENT = "present" EXTRA_LEVEL = "level" EXTRA_SCALE = "scale" EXTRA_ICON_SMALL = "icon-small" EXTRA_PLUGGED = "plugged" EXTRA_TEMPERATURE = "temperature" EXTRA_VOLTAGE = "voltage" EXTRA_TECHNOLOGY = "technology" EXTRA_CHARGE_COUNTER = "charge_counter" EXTRA_CURRENT_NOW = "current_now" EXTRA_CURRENT_AVERAGE = "current_average" EXTRA_ENERGY_COUNTER = "energy_counter" EXTRA_SEQUENCE = "sequence" EXTRA_BATTERY_LOW = "battery_low" EXTRA_MAX_CHARGING_CURRENT = "max_charging_current" EXTRA_MAX_CHARGING_VOLTAGE = "max_charging_voltage" EXTRA_CHARGE_TIME_REMAINING = "charge_time_remaining" EXTRA_DISCHARGE_TIME_REMAINING = "discharge_time_remaining" EXTRA_IS_CAPACITY_ESTIMATED = "is_capacity_estimated" EXTRA_CAPACITY_PERCENTAGE = "capacity_percentage" ACTION_BATTERY_CHANGED = "android.intent.action.BATTERY_CHANGED" ACTION_BATTERY_LOW = "android.intent.action.BATTERY_LOW" ACTION_BATTERY_OKAY = "android.intent.action.BATTERY_OKAY" ACTION_POWER_CONNECTED = "android.intent.action.ACTION_POWER_CONNECTED" ACTION_POWER_DISCONNECTED = "android.intent.action.ACTION_POWER_DISCONNECTED" ACTION_CHARGING = "android.intent.action.CHARGING" ACTION_DISCHARGING = "android.intent.action.DISCHARGING" BATTERY_STATUS_UNKNOWN = BATTERY_STATUS_UNKNOWN BATTERY_STATUS_CHARGING = BATTERY_STATUS_CHARGING BATTERY_STATUS_DISCHARGING = BATTERY_STATUS_DISCHARGING BATTERY_STATUS_NOT_CHARGING = BATTERY_STATUS_NOT_CHARGING BATTERY_STATUS_FULL = BATTERY_STATUS_FULL BATTERY_HEALTH_UNKNOWN = BATTERY_HEALTH_UNKNOWN BATTERY_HEALTH_GOOD = BATTERY_HEALTH_GOOD BATTERY_HEALTH_OVERHEAT = BATTERY_HEALTH_OVERHEAT BATTERY_HEALTH_DEAD = BATTERY_HEALTH_DEAD BATTERY_HEALTH_OVER_VOLTAGE = BATTERY_HEALTH_OVER_VOLTAGE BATTERY_HEALTH_UNSPECIFIED_FAILURE = BATTERY_HEALTH_UNSPECIFIED_FAILURE BATTERY_HEALTH_COLD = BATTERY_HEALTH_COLD BATTERY_PLUGGED_AC = BATTERY_PLUGGED_AC BATTERY_PLUGGED_USB = BATTERY_PLUGGED_USB BATTERY_PLUGGED_WIRELESS = BATTERY_PLUGGED_WIRELESS BATTERY_PROPERTY_CAPACITY = BATTERY_PROPERTY_CAPACITY BATTERY_PROPERTY_CHARGE_COUNTER = BATTERY_PROPERTY_CHARGE_COUNTER BATTERY_PROPERTY_CURRENT_NOW = BATTERY_PROPERTY_CURRENT_NOW BATTERY_PROPERTY_CURRENT_AVERAGE = BATTERY_PROPERTY_CURRENT_AVERAGE BATTERY_PROPERTY_ENERGY_COUNTER = BATTERY_PROPERTY_ENERGY_COUNTER BATTERY_PROPERTY_CHARGE_TIME_REMAINING = BATTERY_PROPERTY_CHARGE_TIME_REMAINING BATTERY_PROPERTY_DISCHARGE_TIME_REMAINING = BATTERY_PROPERTY_DISCHARGE_TIME_REMAINING _instance: Optional["BatteryManager"] = None def __init__(self, context: Any = None): super().__init__() self._context = context self._battery_level = 100 self._status = BATTERY_STATUS_FULL self._health = BATTERY_HEALTH_GOOD self._present = True self._plugged = BATTERY_PLUGGED_AC self._temperature = 25 self._voltage = 3800 self._technology = "Li-ion" self._capacity = 4000 self._charge_counter = 0 self._current_now = 0 self._current_average = 0 self._energy_counter = 0 self._max_charging_current = 3000 self._max_charging_voltage = 4500 self._charge_time_remaining = 0 self._discharge_time_remaining = -1 self._is_capacity_estimated = False self._capacity_percentage = 100.0 if _USE_LINUX: self._refresh_from_linux() _LINUX_STATUS_MAP = { "charging": BATTERY_STATUS_CHARGING, "discharging": BATTERY_STATUS_DISCHARGING, "not charging": BATTERY_STATUS_NOT_CHARGING, "full": BATTERY_STATUS_FULL, "unknown": BATTERY_STATUS_UNKNOWN, } def _get_linux_battery_info(self) -> dict: """从 LinuxPower 获取真实电池信息""" try: return LinuxPower.get_battery_info() or {} except Exception: return {} def _refresh_from_linux(self): """用 Linux 真实电池信息刷新内部状态""" info = self._get_linux_battery_info() if not info: return self._present = bool(info.get("present", False)) level = info.get("level", -1) if self._present and isinstance(level, (int, float)) and level >= 0: self._battery_level = int(level) self._capacity_percentage = float(level) # BATTERY_PROPERTY_CAPACITY 在 Android 中返回百分比 (0-100) self._capacity = int(level) else: # 无电池或电量未知 self._battery_level = -1 self._capacity_percentage = 0.0 self._capacity = -1 status_str = str(info.get("status", "unknown")).lower() self._status = self._LINUX_STATUS_MAP.get(status_str, BATTERY_STATUS_UNKNOWN) voltage = info.get("voltage", 0) if isinstance(voltage, (int, float)): self._voltage = int(voltage * 1000) # V -> mV temperature = info.get("temperature", 0) if isinstance(temperature, (int, float)): self._temperature = temperature # 摄氏度 self._technology = info.get("technology", "") or "Li-ion" if self._status == BATTERY_STATUS_CHARGING: self._plugged = BATTERY_PLUGGED_AC else: self._plugged = 0 @staticmethod def getInstance(context: Any) -> "BatteryManager": if BatteryManager._instance is None: BatteryManager._instance = BatteryManager(context) return BatteryManager._instance def getIntProperty(self, id: int) -> int: if _USE_LINUX: self._refresh_from_linux() properties = { BATTERY_PROPERTY_CAPACITY: self._capacity, BATTERY_PROPERTY_CHARGE_COUNTER: self._charge_counter, BATTERY_PROPERTY_CURRENT_NOW: self._current_now, BATTERY_PROPERTY_CURRENT_AVERAGE: self._current_average, BATTERY_PROPERTY_ENERGY_COUNTER: self._energy_counter, BATTERY_PROPERTY_CHARGE_TIME_REMAINING: self._charge_time_remaining, BATTERY_PROPERTY_DISCHARGE_TIME_REMAINING: self._discharge_time_remaining, BATTERY_PROPERTY_STATUS: self._status, BATTERY_PROPERTY_TEMPERATURE: int(self._temperature), BATTERY_PROPERTY_VOLTAGE: self._voltage, } return properties.get(id, 0) def getLongProperty(self, id: int) -> int: return self.getIntProperty(id) def isCharging(self) -> bool: if _USE_LINUX: self._refresh_from_linux() return self._status == BATTERY_STATUS_CHARGING or self._status == BATTERY_STATUS_FULL def getBatteryLevel(self) -> int: if _USE_LINUX: self._refresh_from_linux() return self._battery_level def getInt(intent: Any, key: str, defaultValue: int) -> int: return defaultValue def toString(self) -> str: return ( f"BatteryManager(level={self._battery_level}%, " f"status={self._status}, " f"charging={self.isCharging()})" ) # ═══════════════════════════════════════════════════════════════ # BatterySaverController # ═══════════════════════════════════════════════════════════════ class BatterySaverController(Stub): """BatterySaverController — 电池节能控制器""" POLICY_MANUAL = 0 POLICY_AUTOMATIC = 1 POLICY_DYNAMIC = 2 POLICY_PERCENTAGE = 3 POLICY_TIMEOUT = 4 POLICY_FULL = 5 POLICY_ADAPTIVE = 6 STATE_OFF = 0 STATE_ON = 1 STATE_AUTO = 2 STATE_MANUAL_ON = 3 STATE_DYNAMIC_ON = 4 def __init__(self, context: Any = None): super().__init__() self._context = context self._state = BatterySaverController.STATE_OFF self._policy = BatterySaverController.POLICY_MANUAL self._threshold = 15 self._last_trigger_time: Optional[float] = None self._trigger_reason = "" self._listeners: List[Callable] = [] def setEnabled(self, enabled: bool) -> None: self._state = BatterySaverController.STATE_ON if enabled else BatterySaverController.STATE_OFF for listener in self._listeners: try: listener(enabled) except Exception: pass def isEnabled(self) -> bool: return self._state == BatterySaverController.STATE_ON def getPolicy(self) -> int: return self._policy def setPolicy(self, policy: int) -> None: self._policy = policy def getThreshold(self) -> int: return self._threshold def setThreshold(self, threshold: int) -> None: self._threshold = max(0, min(100, threshold)) def getTriggerReason(self) -> str: return self._trigger_reason def addListener(self, listener: Callable) -> None: if listener not in self._listeners: self._listeners.append(listener) def removeListener(self, listener: Callable) -> None: if listener in self._listeners: self._listeners.remove(listener) def toString(self) -> str: return f"BatterySaverController(enabled={self.isEnabled()}, threshold={self._threshold}%)" # ═══════════════════════════════════════════════════════════════ # PowerManager (扩展) # ═══════════════════════════════════════════════════════════════ class PowerManager(Stub): """PowerManager — 电源管理器 (扩展)""" PARTIAL_WAKE_LOCK = PARTIAL_WAKE_LOCK FULL_WAKE_LOCK = FULL_WAKE_LOCK SCREEN_DIM_WAKE_LOCK = SCREEN_DIM_WAKE_LOCK SCREEN_BRIGHT_WAKE_LOCK = SCREEN_BRIGHT_WAKE_LOCK PROXIMITY_SCREEN_OFF_WAKE_LOCK = PROXIMITY_SCREEN_OFF_WAKE_LOCK DOZE_WAKE_LOCK = DOZE_WAKE_LOCK DRAW_WAKE_LOCK = DRAW_WAKE_LOCK ACQUIRE_CAUSES_WAKEUP = ACQUIRE_CAUSES_WAKEUP ON_AFTER_RELEASE = ON_AFTER_RELEASE LOCATION_MODE_NO_CHANGE = 0 LOCATION_MODE_GPS_DISABLED = 1 LOCATION_MODE_FOREGROUND_ONLY = 2 LOCATION_MODE_THROTTLE_REQUESTS_WHEN_SCREEN_OFF = 3 LOCATION_MODE_ALL_DISABLED_WHEN_SCREEN_OFF = 4 SOUND_TRIGGER_MODE_NO_CHANGE = 0 SOUND_TRIGGER_MODE_ALL_DISABLED = 1 SOUND_TRIGGER_MODE_CRITICAL_ONLY = 2 SOUND_TRIGGER_MODE_NEVER = 3 GO_TO_SLEEP_REASON_APPLICATION = 0 GO_TO_SLEEP_REASON_DEVICE_ADMIN = 1 GO_TO_SLEEP_REASON_TIMEOUT = 2 GO_TO_SLEEP_REASON_LID_SWITCH = 3 GO_TO_SLEEP_REASON_POWER_BUTTON = 4 GO_TO_SLEEP_REASON_HDMI = 5 GO_TO_SLEEP_REASON_SLEEP_GESTURE = 6 GO_TO_SLEEP_REASON_ACCESSIBILITY = 7 GO_TO_SLEEP_REASON_FORCE_SUSPEND = 8 WAKE_REASON_UNKNOWN = 0 WAKE_REASON_POWER_BUTTON = 1 WAKE_REASON_APPLICATION = 2 WAKE_REASON_PLUGGED_IN = 3 WAKE_REASON_GESTURE = 4 WAKE_REASON_CAMERA_LAUNCH = 5 WAKE_REASON_WAKE_KEY = 6 WAKE_REASON_WAKE_MOTION = 7 WAKE_REASON_HDMI = 8 WAKE_REASON_DISPLAY_GROUP_REMOVED = 9 WAKE_REASON_DREAM_MANAGER = 10 WAKE_REASON_LID = 11 WAKE_REASON_UNLOCK = 12 WAKE_REASON_TAP = 13 WAKE_REASON_LIFT = 14 WAKE_REASON_PICK_UP = 15 WAKE_REASON_DOUBLE_TAP = 16 WAKE_REASON_SWIPE = 17 WAKE_REASON_BACK_GESTURE = 18 def __init__(self, context: Any = None): super().__init__() self._context = context self._is_interactive = True self._is_power_save_mode = False self._is_device_idle_mode = False self._is_light_device_idle_mode = False self._is_screen_on = True self._screen_brightness = 255 self._screen_brightness_mode = SCREEN_BRIGHT_MODE_AUTOMATIC self._wake_locks: Dict[str, "PowerManager.WakeLock"] = {} self._is_rebooting = False self._shutdown_requested = False self._thermal_status = THERMAL_STATUS_NONE self._power_save_state = PowerSaveState() self._current_wake_up_reason = PowerManager.WAKE_REASON_UNKNOWN def isInteractive(self) -> bool: if _USE_LINUX: return self.isScreenOn() return self._is_interactive def isPowerSaveMode(self) -> bool: return self._is_power_save_mode def isDeviceIdleMode(self) -> bool: return self._is_device_idle_mode def isLightDeviceIdleMode(self) -> bool: return self._is_light_device_idle_mode def isRebootingUserspaceSupported(self) -> bool: return True def isScreenOn(self) -> bool: if _USE_LINUX: import os as _os_mod display = _os_mod.environ.get("DISPLAY", "") if display: return True wayland = _os_mod.environ.get("WAYLAND_DISPLAY", "") return bool(wayland) return self._is_screen_on def isWakeLockLevelSupported(self, level: int) -> bool: return level in [ PARTIAL_WAKE_LOCK, FULL_WAKE_LOCK, SCREEN_DIM_WAKE_LOCK, SCREEN_BRIGHT_WAKE_LOCK, PROXIMITY_SCREEN_OFF_WAKE_LOCK, DOZE_WAKE_LOCK, DRAW_WAKE_LOCK, ] def newWakeLock(self, levelAndFlags: int, tag: str) -> "PowerManager.WakeLock": wl = PowerManager.WakeLock(self, levelAndFlags, tag) self._wake_locks[tag] = wl return wl def goToSleep(self, time: int, reason: int, flags: int = 0) -> None: self._is_interactive = False self._is_screen_on = False def wakeUp(self, time: int, reason: int = WAKE_REASON_UNKNOWN) -> None: self._is_interactive = True self._is_screen_on = True self._current_wake_up_reason = reason def userActivity(self, when: int, noChangeLights: bool) -> None: pass def userActivity(self, when: int, event: int, flags: int = 0) -> None: pass def getCurrentWakeUpReason(self) -> int: return self._current_wake_up_reason def getThermalStatus(self) -> int: return self._thermal_status def setThermalStatus(self, status: int) -> None: self._thermal_status = status def getPowerSaveState(self, serviceType: int) -> PowerSaveState: return self._power_save_state def reboot(self, reason: Optional[str] = None) -> None: self._is_rebooting = True raise AndroidOnlyError("PowerManager.reboot() 仅在 Android 设备上可用") def shutdown(self, reason: Optional[str] = None) -> None: self._shutdown_requested = True raise AndroidOnlyError("PowerManager.shutdown() 仅在 Android 设备上可用") def getCurrentBrightness(self) -> int: return self._screen_brightness def setCurrentBrightness(self, brightness: int) -> None: self._screen_brightness = max(0, min(255, brightness)) def getDefaultScreenBrightnessSetting(self) -> int: return 127 def getMinimumBrightnessSetting(self) -> int: return 1 def getMaximumBrightnessSetting(self) -> int: return 255 def toString(self) -> str: return ( f"PowerManager(interactive={self._is_interactive}, " f"powersave={self._is_power_save_mode}, " f"screen_on={self._is_screen_on})" ) # ═══════════════════════════════════════════════════════════ # PowerManager.WakeLock # ═══════════════════════════════════════════════════════════ class WakeLock(Stub): """PowerManager.WakeLock — 唤醒锁""" def __init__(self, manager: "PowerManager", levelAndFlags: int, tag: str): super().__init__() self._manager = manager self._level_and_flags = levelAndFlags self._tag = tag self._is_held = False self._reference_counted = True self._work_source: Optional[Any] = None self._history_tag: Optional[str] = None self._acquire_time: Optional[float] = None def acquire(self, timeoutMillis: int = -1) -> None: self._is_held = True self._acquire_time = time.time() def acquire(self, timeOut: int) -> None: self._is_held = True self._acquire_time = time.time() def release(self, flags: int = 0) -> None: self._is_held = False def isHeld(self) -> bool: return self._is_held def setReferenceCounted(self, value: bool) -> None: self._reference_counted = value def setWorkSource(self, ws: Any) -> None: self._work_source = ws def setHistoryTag(self, tag: str) -> None: self._history_tag = tag def getTag(self) -> str: return self._tag def getLevelAndFlags(self) -> int: return self._level_and_flags def toString(self) -> str: return f"WakeLock(tag={self._tag}, held={self._is_held})"