shuiyuPyLab/Android-pyApi
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: Android-pyApi v1.0 - 全面翻译 Android SDK API 为 Python

Browse Source 
52 个模块覆盖 Android + Java + org.json 标准库
This commit is contained in:
shuiyu1123 committed 2026-06-24 11:16:16 +00:00
commit bfe27fdc08
104 files changed
+58750
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

android_pyapi/android/hardware.py
+533
View File
@@ -0,0 +1,533 @@
"""
Android Hardware 组件 — Sensor, SensorManager, SensorEvent, 等
方法签名完全对齐 Android SDK
"""
import math
import time
import random
from typing import Any, Callable, Dict, List, Optional, Tuple
from .._core import Stub, AndroidOnlyError, android_context, HAS_PIL
# ═══════════════════════════════════════════════════════════════
# Sensor
# ═══════════════════════════════════════════════════════════════
class Sensor(Stub):
"""Sensor — 传感器"""
TYPE_ACCELEROMETER = 1
TYPE_MAGNETIC_FIELD = 2
TYPE_ORIENTATION = 3
TYPE_GYROSCOPE = 4
TYPE_LIGHT = 5
TYPE_PRESSURE = 6
TYPE_PROXIMITY = 8
TYPE_GRAVITY = 9
TYPE_LINEAR_ACCELERATION = 10
TYPE_ROTATION_VECTOR = 11
TYPE_RELATIVE_HUMIDITY = 12
TYPE_AMBIENT_TEMPERATURE = 13
TYPE_STEP_COUNTER = 19
TYPE_STEP_DETECTOR = 18
TYPE_HEART_RATE = 21
TYPE_LOW_LATENCY_OFFBODY_DETECT = 34
TYPE_ACCELEROMETER_LIMITED_AXES = 35
TYPE_DEVICE_ORIENTATION = 27
TYPE_STATIONARY_DETECT = 28
REPORTING_MODE_CONTINUOUS = 0
REPORTING_MODE_ON_CHANGE = 1
REPORTING_MODE_ONE_SHOT = 2
REPORTING_MODE_SPECIAL_TRIGGER = 3
def __init__(self, type_: int, name: str = "Simulated Sensor",
vendor: str = "Android-pyApi", version: int = 1,
resolution: float = 1.0, max_range: float = 100.0,
power: float = 0.5, min_delay: int = 10000):
super().__init__()
self._type = type_
self._name = name
self._vendor = vendor
self._version = version
self._resolution = resolution
self._max_range = max_range
self._power = power
self._min_delay = min_delay
# Assign default values based on sensor type
type_defaults = {
Sensor.TYPE_ACCELEROMETER: ("Accelerometer", 0.01, 39.24, 3.0, 10000),
Sensor.TYPE_GYROSCOPE: ("Gyroscope", 0.001, 34.91, 6.1, 10000),
Sensor.TYPE_MAGNETIC_FIELD: ("Magnetic Field", 0.01, 2000.0, 4.0, 10000),
Sensor.TYPE_LIGHT: ("Light", 1.0, 40000.0, 0.5, 10000),
Sensor.TYPE_PROXIMITY: ("Proximity", 1.0, 10.0, 0.5, 10000),
Sensor.TYPE_PRESSURE: ("Pressure", 0.01, 1100.0, 1.0, 10000),
Sensor.TYPE_GRAVITY: ("Gravity", 0.01, 39.24, 3.0, 10000),
Sensor.TYPE_LINEAR_ACCELERATION: ("Linear Acceleration", 0.01, 39.24, 3.0, 10000),
Sensor.TYPE_ROTATION_VECTOR: ("Rotation Vector", 0.0001, 1.0, 5.0, 10000),
Sensor.TYPE_RELATIVE_HUMIDITY: ("Relative Humidity", 0.1, 100.0, 0.5, 10000),
Sensor.TYPE_AMBIENT_TEMPERATURE: ("Ambient Temperature", 0.01, 80.0, 0.5, 10000),
Sensor.TYPE_STEP_COUNTER: ("Step Counter", 1.0, 100000.0, 0.1, 100000),
Sensor.TYPE_STEP_DETECTOR: ("Step Detector", 1.0, 1.0, 0.1, 100000),
Sensor.TYPE_HEART_RATE: ("Heart Rate", 1.0, 220.0, 0.5, 100000),
}
if type_ in type_defaults:
n, res, mr, p, md = type_defaults[type_]
self._name = name if name != "Simulated Sensor" else n
self._resolution = resolution if resolution != 1.0 else res
self._max_range = max_range if max_range != 100.0 else mr
self._power = power if power != 0.5 else p
self._min_delay = min_delay if min_delay != 10000 else md
def getType(self) -> int:
return self._type
def getName(self) -> str:
return self._name
def getVendor(self) -> str:
return self._vendor
def getVersion(self) -> int:
return self._version
def getMaximumRange(self) -> float:
return self._max_range
def getMinDelay(self) -> int:
return self._min_delay
def getPower(self) -> float:
return self._power
def getResolution(self) -> float:
return self._resolution
def getFifoMaxEventCount(self) -> int:
return 0
def getFifoReservedEventCount(self) -> int:
return 0
def getReportingMode(self) -> int:
return Sensor.REPORTING_MODE_CONTINUOUS
def isWakeUpSensor(self) -> bool:
return False
def getStringType(self) -> str:
type_names = {
Sensor.TYPE_ACCELEROMETER: "android.sensor.accelerometer",
Sensor.TYPE_MAGNETIC_FIELD: "android.sensor.magnetic_field",
Sensor.TYPE_GYROSCOPE: "android.sensor.gyroscope",
Sensor.TYPE_LIGHT: "android.sensor.light",
Sensor.TYPE_PRESSURE: "android.sensor.pressure",
Sensor.TYPE_PROXIMITY: "android.sensor.proximity",
Sensor.TYPE_GRAVITY: "android.sensor.gravity",
Sensor.TYPE_LINEAR_ACCELERATION: "android.sensor.linear_acceleration",
Sensor.TYPE_ROTATION_VECTOR: "android.sensor.rotation_vector",
Sensor.TYPE_RELATIVE_HUMIDITY: "android.sensor.relative_humidity",
Sensor.TYPE_AMBIENT_TEMPERATURE: "android.sensor.ambient_temperature",
Sensor.TYPE_STEP_COUNTER: "android.sensor.step_counter",
Sensor.TYPE_STEP_DETECTOR: "android.sensor.step_detector",
Sensor.TYPE_HEART_RATE: "android.sensor.heart_rate",
}
return type_names.get(self._type, "android.sensor.unknown")
def toString(self) -> str:
return f"{self._name} (type={self._type}, vendor={self._vendor}, ver={self._version})"
# ═══════════════════════════════════════════════════════════════
# SensorEvent
# ═══════════════════════════════════════════════════════════════
class SensorEvent(Stub):
"""SensorEvent — 传感器事件"""
def __init__(self, sensor: Sensor, accuracy: int = 3):
super().__init__()
self.sensor = sensor
self.accuracy = accuracy
self.timestamp = int(time.time() * 1_000_000_000) # nanoseconds
self.values: List[float] = []
# Generate appropriate values based on sensor type
if sensor.getType() == Sensor.TYPE_ACCELEROMETER:
self.values = [random.uniform(-1, 1), random.uniform(-1, 1),
9.8 + random.uniform(-0.5, 0.5)]
elif sensor.getType() == Sensor.TYPE_GYROSCOPE:
self.values = [random.uniform(-0.1, 0.1)] * 3
elif sensor.getType() == Sensor.TYPE_MAGNETIC_FIELD:
self.values = [random.uniform(-50, 50)] * 3
elif sensor.getType() == Sensor.TYPE_LIGHT:
self.values = [random.uniform(100, 1000)]
elif sensor.getType() == Sensor.TYPE_PROXIMITY:
self.values = [5.0 if random.random() > 0.5 else 0.0]
elif sensor.getType() == Sensor.TYPE_PRESSURE:
self.values = [random.uniform(980, 1050)]
elif sensor.getType() in (Sensor.TYPE_GRAVITY, Sensor.TYPE_LINEAR_ACCELERATION):
self.values = [random.uniform(-1, 1)] * 3
elif sensor.getType() == Sensor.TYPE_ROTATION_VECTOR:
self.values = [random.uniform(-1, 1)] * 5
elif sensor.getType() == Sensor.TYPE_RELATIVE_HUMIDITY:
self.values = [random.uniform(30, 70)]
elif sensor.getType() == Sensor.TYPE_AMBIENT_TEMPERATURE:
self.values = [random.uniform(15, 35)]
elif sensor.getType() == Sensor.TYPE_STEP_COUNTER:
self.values = [float(random.randint(0, 10000))]
elif sensor.getType() == Sensor.TYPE_STEP_DETECTOR:
self.values = [1.0 if random.random() > 0.95 else 0.0]
elif sensor.getType() == Sensor.TYPE_HEART_RATE:
self.values = [random.uniform(60, 100)]
else:
self.values = [0.0]
# ═══════════════════════════════════════════════════════════════
# SensorEventListener
# ═══════════════════════════════════════════════════════════════
class SensorEventListener(Stub):
"""SensorEventListener — 传感器事件监听器"""
def onSensorChanged(self, event: SensorEvent):
pass
def onAccuracyChanged(self, sensor: Sensor, accuracy: int):
pass
# ═══════════════════════════════════════════════════════════════
# SensorDelay
# ═══════════════════════════════════════════════════════════════
class SensorDelay(Stub):
"""SensorDelay — 传感器采样延迟常量"""
FASTEST = 0
GAME = 1
UI = 2
NORMAL = 3
# ═══════════════════════════════════════════════════════════════
# SensorManager
# ═══════════════════════════════════════════════════════════════
class SensorManager(Stub):
"""SensorManager — 传感器管理器"""
SENSOR_DELAY_FASTEST = 0
SENSOR_DELAY_GAME = 1
SENSOR_DELAY_UI = 2
SENSOR_DELAY_NORMAL = 3
AXIS_X = 1
AXIS_Y = 2
AXIS_Z = 3
AXIS_MINUS_X = 129
AXIS_MINUS_Y = 130
AXIS_MINUS_Z = 131
def __init__(self):
super().__init__()
self._sensors: Dict[int, Sensor] = {}
self._listeners: Dict[int, List[Tuple[SensorEventListener, Sensor, int]]] = {}
# Create default sensors
for type_ in [
Sensor.TYPE_ACCELEROMETER, Sensor.TYPE_GYROSCOPE,
Sensor.TYPE_MAGNETIC_FIELD, Sensor.TYPE_LIGHT,
Sensor.TYPE_PROXIMITY, Sensor.TYPE_PRESSURE,
Sensor.TYPE_GRAVITY, Sensor.TYPE_LINEAR_ACCELERATION,
Sensor.TYPE_ROTATION_VECTOR, Sensor.TYPE_RELATIVE_HUMIDITY,
Sensor.TYPE_AMBIENT_TEMPERATURE, Sensor.TYPE_STEP_COUNTER,
Sensor.TYPE_STEP_DETECTOR, Sensor.TYPE_HEART_RATE,
]:
self._sensors[type_] = Sensor(type_)
def getDefaultSensor(self, type_: int) -> Optional[Sensor]:
return self._sensors.get(type_)
def getSensorList(self, type_: int) -> List[Sensor]:
if type_ == -1: # ALL
return list(self._sensors.values())
sensor = self._sensors.get(type_)
return [sensor] if sensor else []
def getSensors(self) -> List[Sensor]:
return list(self._sensors.values())
def registerListener(self, listener: SensorEventListener, sensor: Sensor,
samplingPeriodUs: int, maxReportLatencyUs: int = 0) -> bool:
if sensor.getType() not in self._sensors:
return False
if listener not in self._listeners:
self._listeners[id(listener)] = []
self._listeners[id(listener)].append((listener, sensor, samplingPeriodUs))
return True
def unregisterListener(self, listener: SensorEventListener, sensor: Sensor = None) -> bool:
lid = id(listener)
if lid in self._listeners:
if sensor:
self._listeners[lid] = [
(l, s, d) for l, s, d in self._listeners[lid]
if s.getType() != sensor.getType()
]
if not self._listeners[lid]:
del self._listeners[lid]
else:
del self._listeners[lid]
return True
return False
@staticmethod
def getOrientation(R: List[float], values: List[float]) -> List[float]:
if len(R) >= 9 and len(values) >= 3:
values[0] = math.degrees(math.atan2(R[1], R[4])) # azimuth
values[1] = math.degrees(math.asin(-R[7])) # pitch
values[2] = math.degrees(math.atan2(-R[6], R[8])) # roll
return values
@staticmethod
def getRotationMatrix(R: List[float], I: List[float],
gravity: List[float], geomagnetic: List[float]) -> bool:
if len(R) < 9:
R.extend([0] * (9 - len(R)))
if len(R) >= 9:
R[0] = 1.0
R[1] = 0.0
R[2] = 0.0
R[3] = 0.0
R[4] = 1.0
R[5] = 0.0
R[6] = 0.0
R[7] = 0.0
R[8] = 1.0
return True
@staticmethod
def getAltitude(p0: float, p: float) -> float:
return 44330.0 * (1.0 - math.pow(p / p0, 1.0 / 5.255))
@staticmethod
def getInclination(I: List[float]) -> float:
return 0.0
@staticmethod
def remapCoordinateSystem(inR: List[float], X: int, Y: int,
outR: List[float]) -> bool:
if len(inR) >= 9 and len(outR) >= 9:
for i in range(9):
outR[i] = inR[i]
return True
def getDeviceId(self) -> str:
return "sensor_hub_0"
# ═══════════════════════════════════════════════════════════════
# HardwareBuffer
# ═══════════════════════════════════════════════════════════════
class HardwareBuffer(Stub):
"""HardwareBuffer — 硬件缓冲 (API 26+)"""
USAGE_CPU_READ_OFTEN = 0x00000003
USAGE_CPU_WRITE_OFTEN = 0x00000030
USAGE_GPU_SAMPLED_IMAGE = 0x00000100
USAGE_GPU_COLOR_OUTPUT = 0x00000200
USAGE_GPU_DATA_BUFFER = 0x00001000
USAGE_SENSOR_DIRECT_DATA = 0x00400000
USAGE_PROTECTED_CONTENT = 0x00004000
USAGE_VIDEO_ENCODE = 0x00010000
USAGE_GPU_FRAMEBUFFER = 0x00020000
USAGE_COMPOSER_OVERLAY = 0x00000800
USAGE_FRONT_BUFFER_QUEUE = 0x00008000
BLOB = 0x21
RGBA_8888 = 1
RGBA_FP16 = 22
RGBA_1010102 = 43
RGBX_8888 = 2
RGB_888 = 3
RGB_565 = 4
YCBCR_420_888 = 35
def __init__(self, width: int, height: int, format: int, layers: int,
usage: int, buffer_size: int = 0):
super().__init__()
self._width = width
self._height = height
self._format = format
self._layers = layers
self._usage = usage
self._buffer_size = buffer_size
self._closed = False
@property
def width(self) -> int:
return self._width
@property
def height(self) -> int:
return self._height
@property
def format(self) -> int:
return self._format
@property
def layers(self) -> int:
return self._layers
@property
def usage(self) -> int:
return self._usage
def destroy(self):
self.close()
def close(self):
self._closed = True
def isClosed(self) -> bool:
return self._closed
def isEmpty(self) -> bool:
return self._width == 0 or self._height == 0
def getWidth(self) -> int:
return self._width
def getHeight(self) -> int:
return self._height
def getFormat(self) -> int:
return self._format
def getLayers(self) -> int:
return self._layers
def getUsage(self) -> int:
return self._usage
def getStride(self) -> int:
return self._width
# ═══════════════════════════════════════════════════════════════
# BatteryManager (Constants)
# ═══════════════════════════════════════════════════════════════
class BatteryManager(Stub):
"""BatteryManager — 电池管理器常量 (实际实现在 android.os)"""
BATTERY_PROPERTY_CHARGE_COUNTER = 1
BATTERY_PROPERTY_CURRENT_NOW = 2
BATTERY_PROPERTY_CURRENT_AVERAGE = 3
BATTERY_PROPERTY_CAPACITY = 4
BATTERY_PROPERTY_STATUS = 5
BATTERY_PROPERTY_ENERGY_COUNTER = 6
BATTERY_STATUS_UNKNOWN = 1
BATTERY_STATUS_CHARGING = 2
BATTERY_STATUS_DISCHARGING = 3
BATTERY_STATUS_NOT_CHARGING = 4
BATTERY_STATUS_FULL = 5
BATTERY_HEALTH_UNKNOWN = 1
BATTERY_HEALTH_GOOD = 2
BATTERY_HEALTH_OVERHEAT = 3
BATTERY_HEALTH_DEAD = 4
BATTERY_HEALTH_OVER_VOLTAGE = 5
BATTERY_HEALTH_UNSPECIFIED_FAILURE = 6
BATTERY_HEALTH_COLD = 7
BATTERY_PLUGGED_AC = 1
BATTERY_PLUGGED_USB = 2
BATTERY_PLUGGED_WIRELESS = 4
ACTION_CHARGING = "android.intent.action.ACTION_CHARGING"
ACTION_DISCHARGING = "android.intent.action.ACTION_DISCHARGING"
EXTRA_STATUS = "status"
EXTRA_HEALTH = "health"
EXTRA_LEVEL = "level"
EXTRA_SCALE = "scale"
EXTRA_PLUGGED = "plugged"
EXTRA_TEMPERATURE = "temperature"
EXTRA_VOLTAGE = "voltage"
EXTRA_TECHNOLOGY = "technology"
EXTRA_CHARGE_COUNTER = "charge_counter"
EXTRA_PRESENT = "present"
def __init__(self):
super().__init__()
def getIntProperty(self, id: int) -> int:
id_values = {
BatteryManager.BATTERY_PROPERTY_CHARGE_COUNTER: 3500,
BatteryManager.BATTERY_PROPERTY_CAPACITY: 85,
BatteryManager.BATTERY_PROPERTY_STATUS: BatteryManager.BATTERY_STATUS_DISCHARGING,
}
return id_values.get(id, 0)
def getLongProperty(self, id: int) -> int:
return 0
# ═══════════════════════════════════════════════════════════════
# BiometricManager (lightweight)
# ═══════════════════════════════════════════════════════════════
class BiometricManager(Stub):
"""BiometricManager — 生物识别管理器 (轻量)"""
BIOMETRIC_SUCCESS = 0
BIOMETRIC_ERROR_HW_UNAVAILABLE = 1
BIOMETRIC_ERROR_NONE_ENROLLED = 11
BIOMETRIC_ERROR_NO_HARDWARE = 12
BIOMETRIC_ERROR_SECURITY_UPDATE_REQUIRED = 15
def __init__(self):
super().__init__()
def canAuthenticate(self) -> int:
return BiometricManager.BIOMETRIC_ERROR_NO_HARDWARE
# ═══════════════════════════════════════════════════════════════
# Flashlight support
# ═══════════════════════════════════════════════════════════════
class CameraFlashlight(Stub):
"""CameraFlashlight — 手电筒支持"""
def __init__(self):
super().__init__()
self._on = False
def setTorchMode(self, cameraId: str, enabled: bool):
self._on = enabled
def isTorchModeEnabled(self, cameraId: str) -> bool:
return self._on
# ═══════════════════════════════════════════════════════════════
# __all__
# ═══════════════════════════════════════════════════════════════
__all__ = [
"Sensor", "SensorManager", "SensorEvent", "SensorEventListener",
"SensorDelay",
"HardwareBuffer",
"BatteryManager",
"BiometricManager",
"CameraFlashlight",
]