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关键字冲突
714 lines
24 KiB
Python
714 lines
24 KiB
Python
"""
|
|
Android Telephony CDMA 组件 — CdmaCellLocation, SignalStrength (CDMA)
|
|
方法签名完全对齐 Android SDK (android.telephony.cdma 包)
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import time
|
|
from typing import Any, Callable, Dict, List, Optional, Set, Tuple
|
|
|
|
from .._core import Stub, AndroidOnlyError
|
|
from ..java.lang import RuntimeException
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# CdmaCellLocation
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
class CdmaCellLocation(Stub):
|
|
"""CdmaCellLocation — CDMA 小区位置"""
|
|
|
|
INVALID = -1
|
|
|
|
def __init__(self):
|
|
super().__init__()
|
|
self._base_station_id: int = CdmaCellLocation.INVALID
|
|
self._base_station_latitude: int = CdmaCellLocation.INVALID
|
|
self._base_station_longitude: int = CdmaCellLocation.INVALID
|
|
self._system_id: int = CdmaCellLocation.INVALID
|
|
self._network_id: int = CdmaCellLocation.INVALID
|
|
self._pseudo_network_id: int = CdmaCellLocation.INVALID
|
|
self._pseudo_base_station_id: int = CdmaCellLocation.INVALID
|
|
self._lac: int = CdmaCellLocation.INVALID
|
|
self._cid: int = CdmaCellLocation.INVALID
|
|
|
|
def getBaseStationId(self) -> int:
|
|
return self._base_station_id
|
|
|
|
def setBaseStationId(self, bsid: int):
|
|
self._base_station_id = bsid
|
|
|
|
def getBaseStationLatitude(self) -> int:
|
|
return self._base_station_latitude
|
|
|
|
def setBaseStationLatitude(self, latitude: int):
|
|
self._base_station_latitude = latitude
|
|
|
|
def getBaseStationLongitude(self) -> int:
|
|
return self._base_station_longitude
|
|
|
|
def setBaseStationLongitude(self, longitude: int):
|
|
self._base_station_longitude = longitude
|
|
|
|
def getSystemId(self) -> int:
|
|
return self._system_id
|
|
|
|
def setSystemId(self, sid: int):
|
|
self._system_id = sid
|
|
|
|
def getNetworkId(self) -> int:
|
|
return self._network_id
|
|
|
|
def setNetworkId(self, nid: int):
|
|
self._network_id = nid
|
|
|
|
def getLac(self) -> int:
|
|
"""获取位置区码 (仅 1xRTT)"""
|
|
return self._lac
|
|
|
|
def setLac(self, lac: int):
|
|
self._lac = lac
|
|
|
|
def getCid(self) -> int:
|
|
"""获取小区 ID (仅 1xRTT)"""
|
|
return self._cid
|
|
|
|
def setCid(self, cid: int):
|
|
self._cid = cid
|
|
|
|
def isEmpty(self) -> bool:
|
|
"""检查位置是否为空"""
|
|
return (self._base_station_id == CdmaCellLocation.INVALID
|
|
and self._base_station_latitude == CdmaCellLocation.INVALID
|
|
and self._base_station_longitude == CdmaCellLocation.INVALID
|
|
and self._system_id == CdmaCellLocation.INVALID
|
|
and self._network_id == CdmaCellLocation.INVALID)
|
|
|
|
def equals(self, other: Any) -> bool:
|
|
if isinstance(other, CdmaCellLocation):
|
|
return (self._base_station_id == other._base_station_id
|
|
and self._base_station_latitude == other._base_station_latitude
|
|
and self._base_station_longitude == other._base_station_longitude
|
|
and self._system_id == other._system_id
|
|
and self._network_id == other._network_id)
|
|
return False
|
|
|
|
def hashCode(self) -> int:
|
|
return hash((self._base_station_id, self._base_station_latitude,
|
|
self._base_station_longitude, self._system_id,
|
|
self._network_id)) & 0x7FFFFFFF
|
|
|
|
def fillInNotifierBundle(self, bundle: Any):
|
|
"""填充通知包"""
|
|
if bundle is not None:
|
|
bundle.putInt("base_station_id", self._base_station_id)
|
|
bundle.putInt("base_station_latitude", self._base_station_latitude)
|
|
bundle.putInt("base_station_longitude", self._base_station_longitude)
|
|
bundle.putInt("system_id", self._system_id)
|
|
bundle.putInt("network_id", self._network_id)
|
|
|
|
def toString(self) -> str:
|
|
return f"CdmaCellLocation(bsid={self._base_station_id}, sid={self._system_id}, nid={self._network_id})"
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# SignalStrength — CDMA
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
class SignalStrength(Stub):
|
|
"""SignalStrength — CDMA 信号强度"""
|
|
|
|
SIGNAL_STRENGTH_NONE_OR_UNKNOWN = 0
|
|
SIGNAL_STRENGTH_POOR = 1
|
|
SIGNAL_STRENGTH_MODERATE = 2
|
|
SIGNAL_STRENGTH_GOOD = 3
|
|
SIGNAL_STRENGTH_GREAT = 4
|
|
|
|
INVALID = -1
|
|
MAX_DBM = -25
|
|
MIN_DBM = -120
|
|
|
|
CDMA_RSSI_MAX = -75
|
|
CDMA_RSSI_MIN = -120
|
|
CDMA_ECIO_MAX = 0
|
|
CDMA_ECIO_MIN = -30
|
|
EVDO_DBM_MAX = -60
|
|
EVDO_DBM_MIN = -120
|
|
EVDO_ECIO_MAX = 0
|
|
EVDO_ECIO_MIN = -20
|
|
EVDO_SNR_MAX = 10
|
|
EVDO_SNR_MIN = 0
|
|
|
|
def __init__(self, cdma_dbm: int = 0, cdma_ecio: int = 0,
|
|
evdo_dbm: int = 0, evdo_ecio: int = 0, evdo_snr: int = 0):
|
|
super().__init__()
|
|
self._cdma_dbm = cdma_dbm
|
|
self._cdma_ecio = cdma_ecio
|
|
self._evdo_dbm = evdo_dbm
|
|
self._evdo_ecio = evdo_ecio
|
|
self._evdo_snr = evdo_snr
|
|
self._is_gsm: bool = False
|
|
self._lte_rssi: int = 0
|
|
self._lte_rsrp: int = 0
|
|
self._lte_rsrq: int = 0
|
|
self._lte_rssnr: int = 0
|
|
self._td_scdma_rscp: int = 0
|
|
self._wcdma_rscp: int = 0
|
|
self._wcdma_ecno: int = 0
|
|
|
|
def getCdmaDbm(self) -> int:
|
|
"""获取 CDMA dBm"""
|
|
return self._cdma_dbm
|
|
|
|
def setCdmaDbm(self, dbm: int):
|
|
self._cdma_dbm = dbm
|
|
|
|
def getCdmaEcio(self) -> int:
|
|
"""获取 CDMA Ec/Io (0.5 dB 单位)"""
|
|
return self._cdma_ecio
|
|
|
|
def setCdmaEcio(self, ecio: int):
|
|
self._cdma_ecio = ecio
|
|
|
|
def getEvdoDbm(self) -> int:
|
|
"""获取 EVDO dBm"""
|
|
return self._evdo_dbm
|
|
|
|
def setEvdoDbm(self, dbm: int):
|
|
self._evdo_dbm = dbm
|
|
|
|
def getEvdoEcio(self) -> int:
|
|
"""获取 EVDO Ec/Io (0.5 dB 单位)"""
|
|
return self._evdo_ecio
|
|
|
|
def setEvdoEcio(self, ecio: int):
|
|
self._evdo_ecio = ecio
|
|
|
|
def getEvdoSnr(self) -> int:
|
|
"""获取 EVDO SNR"""
|
|
return self._evdo_snr
|
|
|
|
def setEvdoSnr(self, snr: int):
|
|
self._evdo_snr = snr
|
|
|
|
def getDbm(self) -> int:
|
|
"""获取整体 dBm"""
|
|
if self._evdo_dbm > 0:
|
|
return self._evdo_dbm
|
|
return self._cdma_dbm
|
|
|
|
def getLevel(self) -> int:
|
|
"""获取信号等级 (0-4)"""
|
|
dbm = self.getDbm()
|
|
if dbm >= -85:
|
|
return SignalStrength.SIGNAL_STRENGTH_GREAT
|
|
elif dbm >= -95:
|
|
return SignalStrength.SIGNAL_STRENGTH_GOOD
|
|
elif dbm >= -105:
|
|
return SignalStrength.SIGNAL_STRENGTH_MODERATE
|
|
elif dbm >= -115:
|
|
return SignalStrength.SIGNAL_STRENGTH_POOR
|
|
else:
|
|
return SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN
|
|
|
|
def getAsuLevel(self) -> int:
|
|
"""获取 ASU 等级"""
|
|
dbm = self.getDbm()
|
|
if dbm <= -120:
|
|
return 0
|
|
if dbm >= -25:
|
|
return 96
|
|
return int((dbm + 120) * (96.0 / 95.0))
|
|
|
|
def getEvdoLevel(self) -> int:
|
|
"""获取 EVDO 等级"""
|
|
evdo_dbm = self._evdo_dbm
|
|
if evdo_dbm >= -65:
|
|
return SignalStrength.SIGNAL_STRENGTH_GREAT
|
|
elif evdo_dbm >= -75:
|
|
return SignalStrength.SIGNAL_STRENGTH_GOOD
|
|
elif evdo_dbm >= -90:
|
|
return SignalStrength.SIGNAL_STRENGTH_MODERATE
|
|
elif evdo_dbm >= -105:
|
|
return SignalStrength.SIGNAL_STRENGTH_POOR
|
|
else:
|
|
return SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN
|
|
|
|
def getCdmaLevel(self) -> int:
|
|
"""获取 CDMA 等级"""
|
|
cdma_dbm = self._cdma_dbm
|
|
if cdma_dbm >= -75:
|
|
return SignalStrength.SIGNAL_STRENGTH_GREAT
|
|
elif cdma_dbm >= -85:
|
|
return SignalStrength.SIGNAL_STRENGTH_GOOD
|
|
elif cdma_dbm >= -95:
|
|
return SignalStrength.SIGNAL_STRENGTH_MODERATE
|
|
elif cdma_dbm >= -105:
|
|
return SignalStrength.SIGNAL_STRENGTH_POOR
|
|
else:
|
|
return SignalStrength.SIGNAL_STRENGTH_NONE_OR_UNKNOWN
|
|
|
|
def isGsm(self) -> bool:
|
|
return self._is_gsm
|
|
|
|
def setGsm(self, gsm: bool):
|
|
self._is_gsm = gsm
|
|
|
|
def getCdmaRssi(self) -> int:
|
|
"""获取 CDMA RSSI (dBm)"""
|
|
return self._cdma_dbm
|
|
|
|
def getCdmaEcioDb(self) -> float:
|
|
"""获取 CDMA Ec/Io (dB)"""
|
|
return self._cdma_ecio / 2.0
|
|
|
|
def getEvdoEcioDb(self) -> float:
|
|
"""获取 EVDO Ec/Io (dB)"""
|
|
return self._evdo_ecio / 2.0
|
|
|
|
def isValid(self) -> bool:
|
|
"""检查是否有效"""
|
|
return self._cdma_dbm > SignalStrength.INVALID
|
|
|
|
def toString(self) -> str:
|
|
return f"CDMA_SignalStrength(cdmaDbm={self._cdma_dbm}, evdoDbm={self._evdo_dbm})"
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# CDMA SMS
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
class CdmaSmsMessage(Stub):
|
|
"""CdmaSmsMessage — CDMA 短信"""
|
|
|
|
ENCODING_7BIT_ASCII = 2
|
|
ENCODING_UNICODE = 4
|
|
ENCODING_SHIFT_JIS = 5
|
|
ENCODING_KOREAN = 6
|
|
ENCODING_LATIN = 8
|
|
ENCODING_LATIN_HEBREW = 9
|
|
ENCODING_GSM_7BIT = 10
|
|
ENCODING_GSM_DCS = 11
|
|
|
|
PRIORITY_NORMAL = 0
|
|
PRIORITY_INTERACTIVE = 1
|
|
PRIORITY_URGENT = 2
|
|
PRIORITY_EMERGENCY = 3
|
|
|
|
PRIVACY_NORMAL = 0
|
|
PRIVACY_RESTRICTED = 1
|
|
PRIVACY_CONFIDENTIAL = 2
|
|
PRIVACY_SECRET = 3
|
|
|
|
def __init__(self):
|
|
super().__init__()
|
|
self._message_body: str = ""
|
|
self._originating_address: str = ""
|
|
self._destination_address: str = ""
|
|
self._encoding: int = CdmaSmsMessage.ENCODING_7BIT_ASCII
|
|
self._priority: int = CdmaSmsMessage.PRIORITY_NORMAL
|
|
self._privacy: int = CdmaSmsMessage.PRIVACY_NORMAL
|
|
self._timestamp: int = 0
|
|
self._bearer_data: bytes = b""
|
|
self._service_category: int = 0
|
|
self._language: str = ""
|
|
self._is_urgent: bool = False
|
|
|
|
def getMessageBody(self) -> str:
|
|
return self._message_body
|
|
|
|
def setMessageBody(self, body: str):
|
|
self._message_body = body
|
|
|
|
def getOriginatingAddress(self) -> str:
|
|
return self._originating_address
|
|
|
|
def setOriginatingAddress(self, addr: str):
|
|
self._originating_address = addr
|
|
|
|
def getDestinationAddress(self) -> str:
|
|
return self._destination_address
|
|
|
|
def setDestinationAddress(self, addr: str):
|
|
self._destination_address = addr
|
|
|
|
def getEncoding(self) -> int:
|
|
return self._encoding
|
|
|
|
def setEncoding(self, encoding: int):
|
|
self._encoding = encoding
|
|
|
|
def getPriority(self) -> int:
|
|
return self._priority
|
|
|
|
def setPriority(self, priority: int):
|
|
self._priority = priority
|
|
|
|
def getPrivacy(self) -> int:
|
|
return self._privacy
|
|
|
|
def setPrivacy(self, privacy: int):
|
|
self._privacy = privacy
|
|
|
|
def getTimestamp(self) -> int:
|
|
return self._timestamp
|
|
|
|
def setTimestamp(self, ts: int):
|
|
self._timestamp = ts
|
|
|
|
def getBearerData(self) -> bytes:
|
|
return self._bearer_data
|
|
|
|
def setBearerData(self, data: bytes):
|
|
self._bearer_data = data
|
|
|
|
def toString(self) -> str:
|
|
return f"CdmaSmsMessage(from={self._originating_address}, body={self._message_body[:20]})"
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# CDMA 网络常量
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
class CdmaNetworkType(Stub):
|
|
"""CdmaNetworkType — CDMA 网络类型常量"""
|
|
|
|
NETWORK_TYPE_CDMA = 4
|
|
NETWORK_TYPE_EVDO_0 = 5
|
|
NETWORK_TYPE_EVDO_A = 6
|
|
NETWORK_TYPE_1xRTT = 7
|
|
NETWORK_TYPE_EVDO_B = 12
|
|
NETWORK_TYPE_EHRPD = 14
|
|
|
|
@staticmethod
|
|
def isCdma(network_type: int) -> bool:
|
|
return network_type in (CdmaNetworkType.NETWORK_TYPE_CDMA,
|
|
CdmaNetworkType.NETWORK_TYPE_EVDO_0,
|
|
CdmaNetworkType.NETWORK_TYPE_EVDO_A,
|
|
CdmaNetworkType.NETWORK_TYPE_1xRTT,
|
|
CdmaNetworkType.NETWORK_TYPE_EVDO_B,
|
|
CdmaNetworkType.NETWORK_TYPE_EHRPD)
|
|
|
|
@staticmethod
|
|
def toString(network_type: int) -> str:
|
|
names = {
|
|
CdmaNetworkType.NETWORK_TYPE_CDMA: "CDMA",
|
|
CdmaNetworkType.NETWORK_TYPE_EVDO_0: "EVDO rev.0",
|
|
CdmaNetworkType.NETWORK_TYPE_EVDO_A: "EVDO rev.A",
|
|
CdmaNetworkType.NETWORK_TYPE_1xRTT: "1xRTT",
|
|
CdmaNetworkType.NETWORK_TYPE_EVDO_B: "EVDO rev.B",
|
|
CdmaNetworkType.NETWORK_TYPE_EHRPD: "eHRPD",
|
|
}
|
|
return names.get(network_type, f"UNKNOWN({network_type})")
|
|
|
|
@staticmethod
|
|
def getRatName(network_type: int) -> str:
|
|
return CdmaNetworkType.toString(network_type)
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# CDMA 补充业务
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
class CdmaServiceState(Stub):
|
|
"""CdmaServiceState — CDMA 服务状态"""
|
|
|
|
STATE_IN_SERVICE = 0
|
|
STATE_OUT_OF_SERVICE = 1
|
|
STATE_EMERGENCY_ONLY = 2
|
|
STATE_POWER_OFF = 3
|
|
|
|
def __init__(self):
|
|
super().__init__()
|
|
self._state: int = CdmaServiceState.STATE_OUT_OF_SERVICE
|
|
self._is_roaming: bool = False
|
|
self._cdma_default_roaming_indicator: int = -1
|
|
self._cdma_eri_icon_index: int = -1
|
|
self._cdma_eri_icon_mode: int = -1
|
|
self._cdma_roaming_indicator: int = -1
|
|
self._system_id: int = -1
|
|
self._network_id: int = -1
|
|
self._base_station_id: int = -1
|
|
self._base_station_latitude: int = -1
|
|
self._base_station_longitude: int = -1
|
|
self._operator_alpha_long: str = ""
|
|
self._operator_alpha_short: str = ""
|
|
self._operator_numeric: str = ""
|
|
self._is_manual_selection: bool = False
|
|
|
|
def getState(self) -> int:
|
|
return self._state
|
|
|
|
def setState(self, state: int):
|
|
self._state = state
|
|
|
|
def getRoaming(self) -> bool:
|
|
return self._is_roaming
|
|
|
|
def setRoaming(self, roaming: bool):
|
|
self._is_roaming = roaming
|
|
|
|
def getCdmaDefaultRoamingIndicator(self) -> int:
|
|
return self._cdma_default_roaming_indicator
|
|
|
|
def setCdmaDefaultRoamingIndicator(self, indicator: int):
|
|
self._cdma_default_roaming_indicator = indicator
|
|
|
|
def getCdmaEriIconIndex(self) -> int:
|
|
return self._cdma_eri_icon_index
|
|
|
|
def setCdmaEriIconIndex(self, index: int):
|
|
self._cdma_eri_icon_index = index
|
|
|
|
def getCdmaEriIconMode(self) -> int:
|
|
return self._cdma_eri_icon_mode
|
|
|
|
def setCdmaEriIconMode(self, mode: int):
|
|
self._cdma_eri_icon_mode = mode
|
|
|
|
def getCdmaRoamingIndicator(self) -> int:
|
|
return self._cdma_roaming_indicator
|
|
|
|
def setCdmaRoamingIndicator(self, indicator: int):
|
|
self._cdma_roaming_indicator = indicator
|
|
|
|
def getSystemId(self) -> int:
|
|
return self._system_id
|
|
|
|
def setSystemId(self, sid: int):
|
|
self._system_id = sid
|
|
|
|
def getNetworkId(self) -> int:
|
|
return self._network_id
|
|
|
|
def setNetworkId(self, nid: int):
|
|
self._network_id = nid
|
|
|
|
def getOperatorAlphaLong(self) -> str:
|
|
return self._operator_alpha_long
|
|
|
|
def setOperatorAlphaLong(self, op: str):
|
|
self._operator_alpha_long = op
|
|
|
|
def getOperatorAlphaShort(self) -> str:
|
|
return self._operator_alpha_short
|
|
|
|
def setOperatorAlphaShort(self, op: str):
|
|
self._operator_alpha_short = op
|
|
|
|
def getOperatorNumeric(self) -> str:
|
|
return self._operator_numeric
|
|
|
|
def setOperatorNumeric(self, op: str):
|
|
self._operator_numeric = op
|
|
|
|
def toString(self) -> str:
|
|
return f"CdmaServiceState(state={self._state}, roaming={self._is_roaming})"
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# CDMA ERI (Enhanced Roaming Indicator)
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
class CdmaEriInfo(Stub):
|
|
"""CdmaEriInfo — CDMA ERI 信息"""
|
|
|
|
ERI_ON = 0
|
|
ERI_OFF = 1
|
|
ERI_FLASH = 2
|
|
|
|
ROAMING_INDICATOR_NOT_ROAMING = 0
|
|
ROAMING_INDICATOR_ROAMING = 1
|
|
ROAMING_INDICATOR_SAMPLING = 2
|
|
ROAMING_INDICATOR_AFFILIATED = 3
|
|
ROAMING_INDICATOR_NOT_AFFILIATED = 4
|
|
ROAMING_INDICATOR_FLASH = 5
|
|
|
|
def __init__(self):
|
|
super().__init__()
|
|
self._icon_index: int = -1
|
|
self._icon_mode: int = CdmaEriInfo.ERI_OFF
|
|
self._roaming_indicator: int = CdmaEriInfo.ROAMING_INDICATOR_NOT_ROAMING
|
|
self._eri_text: str = ""
|
|
self._alert_show: bool = False
|
|
self._call_guard: bool = False
|
|
|
|
def getIconIndex(self) -> int:
|
|
return self._icon_index
|
|
|
|
def setIconIndex(self, index: int):
|
|
self._icon_index = index
|
|
|
|
def getIconMode(self) -> int:
|
|
return self._icon_mode
|
|
|
|
def setIconMode(self, mode: int):
|
|
self._icon_mode = mode
|
|
|
|
def getRoamingIndicator(self) -> int:
|
|
return self._roaming_indicator
|
|
|
|
def setRoamingIndicator(self, indicator: int):
|
|
self._roaming_indicator = indicator
|
|
|
|
def getEriText(self) -> str:
|
|
return self._eri_text
|
|
|
|
def setEriText(self, text: str):
|
|
self._eri_text = text
|
|
|
|
def isAlertShow(self) -> bool:
|
|
return self._alert_show
|
|
|
|
def setAlertShow(self, show: bool):
|
|
self._alert_show = show
|
|
|
|
def isCallGuard(self) -> bool:
|
|
return self._call_guard
|
|
|
|
def setCallGuard(self, guard: bool):
|
|
self._call_guard = guard
|
|
|
|
def isRoaming(self) -> bool:
|
|
return self._roaming_indicator != CdmaEriInfo.ROAMING_INDICATOR_NOT_ROAMING
|
|
|
|
def toString(self) -> str:
|
|
return f"CdmaEriInfo(icon={self._icon_index}, roaming={self._roaming_indicator})"
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# CDMA 语音/数据状态
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
class CdmaCallState(Stub):
|
|
"""CdmaCallState — CDMA 通话状态"""
|
|
|
|
CALL_STATE_IDLE = 0
|
|
CALL_STATE_ACTIVE = 1
|
|
CALL_STATE_ALERTING = 2
|
|
CALL_STATE_DIALING = 3
|
|
CALL_STATE_INCOMING = 4
|
|
CALL_STATE_HOLDING = 5
|
|
CALL_STATE_DISCONNECTING = 6
|
|
CALL_STATE_DISCONNECTED = 7
|
|
CALL_STATE_CONFERENCE = 8
|
|
|
|
CALL_TYPE_VOICE = 0
|
|
CALL_TYPE_DATA = 1
|
|
CALL_TYPE_FAX = 2
|
|
CALL_TYPE_UNKNOWN = 3
|
|
|
|
@staticmethod
|
|
def toString(state: int) -> str:
|
|
names = {
|
|
CdmaCallState.CALL_STATE_IDLE: "IDLE",
|
|
CdmaCallState.CALL_STATE_ACTIVE: "ACTIVE",
|
|
CdmaCallState.CALL_STATE_ALERTING: "ALERTING",
|
|
CdmaCallState.CALL_STATE_DIALING: "DIALING",
|
|
CdmaCallState.CALL_STATE_INCOMING: "INCOMING",
|
|
CdmaCallState.CALL_STATE_DISCONNECTED: "DISCONNECTED",
|
|
}
|
|
return names.get(state, f"UNKNOWN({state})")
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# CDMA Data Connection
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
class CdmaDataConnectionState(Stub):
|
|
"""CdmaDataConnectionState — CDMA 数据连接状态"""
|
|
|
|
DATA_STATE_DISCONNECTED = 0
|
|
DATA_STATE_CONNECTING = 1
|
|
DATA_STATE_CONNECTED = 2
|
|
DATA_STATE_SUSPENDED = 3
|
|
DATA_STATE_DORMANT = 4
|
|
DATA_STATE_AUTHENTICATING = 5
|
|
|
|
DATA_ACTIVITY_NONE = 0
|
|
DATA_ACTIVITY_IN = 1
|
|
DATA_ACTIVITY_OUT = 2
|
|
DATA_ACTIVITY_INOUT = 3
|
|
DATA_ACTIVITY_DORMANT = 4
|
|
|
|
@staticmethod
|
|
def toString(state: int) -> str:
|
|
names = {
|
|
CdmaDataConnectionState.DATA_STATE_DISCONNECTED: "DISCONNECTED",
|
|
CdmaDataConnectionState.DATA_STATE_CONNECTING: "CONNECTING",
|
|
CdmaDataConnectionState.DATA_STATE_CONNECTED: "CONNECTED",
|
|
CdmaDataConnectionState.DATA_STATE_SUSPENDED: "SUSPENDED",
|
|
CdmaDataConnectionState.DATA_STATE_DORMANT: "DORMANT",
|
|
}
|
|
return names.get(state, f"UNKNOWN({state})")
|
|
|
|
@staticmethod
|
|
def dataActivityToString(activity: int) -> str:
|
|
names = {
|
|
CdmaDataConnectionState.DATA_ACTIVITY_NONE: "NONE",
|
|
CdmaDataConnectionState.DATA_ACTIVITY_IN: "IN",
|
|
CdmaDataConnectionState.DATA_ACTIVITY_OUT: "OUT",
|
|
CdmaDataConnectionState.DATA_ACTIVITY_INOUT: "INOUT",
|
|
CdmaDataConnectionState.DATA_ACTIVITY_DORMANT: "DORMANT",
|
|
}
|
|
return names.get(activity, f"UNKNOWN({activity})")
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# CDMA 网络注册
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
class CdmaRegistrationState(Stub):
|
|
"""CdmaRegistrationState — CDMA 注册状态"""
|
|
|
|
REG_STATE_NOT_REGISTERED = 0
|
|
REG_STATE_REGISTERED = 1
|
|
REG_STATE_REGISTERING = 2
|
|
REG_STATE_DENIED = 3
|
|
REG_STATE_UNKNOWN = 4
|
|
REG_STATE_ROAMING = 5
|
|
REG_STATE_HOME = 6
|
|
|
|
def __init__(self, state: int = REG_STATE_UNKNOWN):
|
|
super().__init__()
|
|
self._state = state
|
|
self._system_id: int = -1
|
|
self._network_id: int = -1
|
|
self._base_id: int = -1
|
|
self._zone_id: int = -1
|
|
|
|
def getState(self) -> int:
|
|
return self._state
|
|
|
|
def setState(self, state: int):
|
|
self._state = state
|
|
|
|
def getSystemId(self) -> int:
|
|
return self._system_id
|
|
|
|
def setSystemId(self, sid: int):
|
|
self._system_id = sid
|
|
|
|
def getNetworkId(self) -> int:
|
|
return self._network_id
|
|
|
|
def setNetworkId(self, nid: int):
|
|
self._network_id = nid
|
|
|
|
def getBaseId(self) -> int:
|
|
return self._base_id
|
|
|
|
def setBaseId(self, base_id: int):
|
|
self._base_id = base_id
|
|
|
|
def isRegistered(self) -> bool:
|
|
return self._state in (CdmaRegistrationState.REG_STATE_REGISTERED,
|
|
CdmaRegistrationState.REG_STATE_HOME,
|
|
CdmaRegistrationState.REG_STATE_ROAMING)
|
|
|
|
def isRoaming(self) -> bool:
|
|
return self._state == CdmaRegistrationState.REG_STATE_ROAMING
|
|
|
|
def toString(self) -> str:
|
|
return f"CdmaRegistrationState(state={self._state})" |