shuiyu1123
a51854455b
- android/ 167个模块 (app/content/os/view/widget/graphics/media/hardware/net/telephony/provider等) - java/ 35个模块 (lang/io/util/net/nio/security/crypto/sql/beans/rmi/awt等) - javax/ 4个模块 (net/crypto/security/sql) - org/ 5个模块 (json/w3c_dom/xml_sax/xml_pull/apache_http) - dalvik/ 1个模块 (system) - ~3053个类/接口，方法签名完全对齐Android SDK - 桌面跨平台运行 (Windows/macOS/Linux) - 修复所有导入错误和Python关键字冲突
827 lines
28 KiB
Python
827 lines
28 KiB
Python
"""
|
|
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
|
|
|
|
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
|
|
|
|
@staticmethod
|
|
def getInstance(context: Any) -> "BatteryManager":
|
|
if BatteryManager._instance is None:
|
|
BatteryManager._instance = BatteryManager(context)
|
|
return BatteryManager._instance
|
|
|
|
def getIntProperty(self, id: int) -> int:
|
|
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,
|
|
}
|
|
return properties.get(id, 0)
|
|
|
|
def getLongProperty(self, id: int) -> int:
|
|
return self.getIntProperty(id)
|
|
|
|
def isCharging(self) -> bool:
|
|
return self._status == BATTERY_STATUS_CHARGING or self._status == BATTERY_STATUS_FULL
|
|
|
|
def getBatteryLevel(self) -> int:
|
|
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 = WAKE_REASON_UNKNOWN
|
|
|
|
def isInteractive(self) -> bool:
|
|
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:
|
|
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})" |