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关键字冲突
428 lines
17 KiB
Python
428 lines
17 KiB
Python
"""
|
|
Android net.wifi.aware 组件 — WifiAwareManager, WifiAwareSession, PublishConfig, SubscribeConfig 等
|
|
方法签名完全对齐 Android SDK
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import threading
|
|
import uuid
|
|
from typing import Any, Callable, Dict, List, Optional, Set
|
|
|
|
from .._core import Stub, AndroidOnlyError
|
|
from ..java.lang import RuntimeException
|
|
|
|
IllegalArgumentException = type("IllegalArgumentException", (RuntimeException,), {})
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# Characteristics
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
class Characteristics(Stub):
|
|
"""Characteristics — Wi-Fi Aware 特性"""
|
|
|
|
def __init__(self):
|
|
super().__init__()
|
|
self._max_service_name_length: int = 255
|
|
self._max_service_specific_info_length: int = 255
|
|
self._max_match_filter_length: int = 255
|
|
self._max_number_of_publish_service_sessions: int = 10
|
|
self._max_number_of_subscribe_service_sessions: int = 10
|
|
self._max_message_length: int = 2048
|
|
self._max_peers: int = 10
|
|
|
|
def getMaxServiceNameLength(self) -> int:
|
|
return self._max_service_name_length
|
|
|
|
def getMaxServiceSpecificInfoLength(self) -> int:
|
|
return self._max_service_specific_info_length
|
|
|
|
def getMaxMatchFilterLength(self) -> int:
|
|
return self._max_match_filter_length
|
|
|
|
def getMaxNumberOfPublishServiceSessions(self) -> int:
|
|
return self._max_number_of_publish_service_sessions
|
|
|
|
def getMaxNumberOfSubscribeServiceSessions(self) -> int:
|
|
return self._max_number_of_subscribe_service_sessions
|
|
|
|
def getMaxMessageLength(self) -> int:
|
|
return self._max_message_length
|
|
|
|
def getMaxPeers(self) -> int:
|
|
return self._max_peers
|
|
|
|
def toString(self) -> str:
|
|
return f"Characteristics@{hex(id(self))}"
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# AttachCallback
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
class AttachCallback(Stub):
|
|
"""AttachCallback — 连接回调"""
|
|
|
|
def onAttached(self, session: "WifiAwareSession"):
|
|
pass
|
|
|
|
def onAttachFailed(self):
|
|
pass
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# IdentityChangedListener
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
class IdentityChangedListener(Stub):
|
|
"""IdentityChangedListener — 身份变更监听器"""
|
|
|
|
def onIdentityChanged(self, macAddress: bytes):
|
|
pass
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# DiscoverySessionCallback
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
class DiscoverySessionCallback(Stub):
|
|
"""DiscoverySessionCallback — 发现会话回调"""
|
|
|
|
def onServiceDiscovered(self, peerHandle: Any, serviceSpecificInfo: bytes,
|
|
matchFilter: bytes):
|
|
pass
|
|
|
|
def onServiceDiscoveredWithinRange(self, peerHandle: Any,
|
|
serviceSpecificInfo: bytes,
|
|
matchFilter: bytes, rangeMm: int):
|
|
pass
|
|
|
|
def onMessageReceived(self, peerHandle: Any, message: bytes):
|
|
pass
|
|
|
|
def onMessageSendSucceeded(self, messageId: int):
|
|
pass
|
|
|
|
def onMessageSendFailed(self, messageId: int):
|
|
pass
|
|
|
|
def onSessionConfigUpdated(self):
|
|
pass
|
|
|
|
def onSessionConfigFailed(self):
|
|
pass
|
|
|
|
def onSessionTerminated(self):
|
|
pass
|
|
|
|
def onMatch(self, peerHandle: Any, serviceSpecificInfo: bytes,
|
|
matchFilter: bytes, rangeMm: int):
|
|
pass
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# PublishConfig
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
class PublishConfig(Stub):
|
|
"""PublishConfig — 发布配置"""
|
|
|
|
PUBLISH_TYPE_UNSOLICITED = 0
|
|
PUBLISH_TYPE_SOLICITED = 1
|
|
|
|
def __init__(self, service_name: str = "", service_specific_info: bytes = b"",
|
|
match_filter: bytes = b"", terminate_notification_enabled: bool = True,
|
|
ranging_enabled: bool = False, publish_type: int = PUBLISH_TYPE_UNSOLICITED):
|
|
super().__init__()
|
|
self._service_name = service_name
|
|
self._service_specific_info = service_specific_info
|
|
self._match_filter = match_filter
|
|
self._terminate_notification_enabled = terminate_notification_enabled
|
|
self._ranging_enabled = ranging_enabled
|
|
self._publish_type = publish_type
|
|
|
|
class Builder(Stub):
|
|
"""PublishConfig.Builder — 构建器"""
|
|
|
|
def __init__(self):
|
|
super().__init__()
|
|
self._service_name: str = ""
|
|
self._service_specific_info: bytes = b""
|
|
self._match_filter: bytes = b""
|
|
self._terminate_notification_enabled: bool = True
|
|
self._ranging_enabled: bool = False
|
|
self._publish_type: int = PublishConfig.PUBLISH_TYPE_UNSOLICITED
|
|
|
|
def setServiceName(self, serviceName: str) -> "PublishConfig.Builder":
|
|
self._service_name = serviceName
|
|
return self
|
|
|
|
def setServiceSpecificInfo(self, info: bytes) -> "PublishConfig.Builder":
|
|
self._service_specific_info = info
|
|
return self
|
|
|
|
def setMatchFilter(self, matchFilter: bytes) -> "PublishConfig.Builder":
|
|
self._match_filter = matchFilter
|
|
return self
|
|
|
|
def setTerminateNotificationEnabled(self, enabled: bool) -> "PublishConfig.Builder":
|
|
self._terminate_notification_enabled = enabled
|
|
return self
|
|
|
|
def setRangingEnabled(self, enabled: bool) -> "PublishConfig.Builder":
|
|
self._ranging_enabled = enabled
|
|
return self
|
|
|
|
def setPublishType(self, publishType: int) -> "PublishConfig.Builder":
|
|
self._publish_type = publishType
|
|
return self
|
|
|
|
def build(self) -> "PublishConfig":
|
|
return PublishConfig(
|
|
self._service_name, self._service_specific_info,
|
|
self._match_filter, self._terminate_notification_enabled,
|
|
self._ranging_enabled, self._publish_type,
|
|
)
|
|
|
|
def toString(self) -> str:
|
|
return f"PublishConfig{{service={self._service_name}, type={self._publish_type}}}"
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# SubscribeConfig
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
class SubscribeConfig(Stub):
|
|
"""SubscribeConfig — 订阅配置"""
|
|
|
|
SUBSCRIBE_TYPE_PASSIVE = 0
|
|
SUBSCRIBE_TYPE_ACTIVE = 1
|
|
|
|
def __init__(self, service_name: str = "", service_specific_info: bytes = b"",
|
|
match_filter: bytes = b"", terminate_notification_enabled: bool = True,
|
|
ranging_enabled: bool = False, subscribe_type: int = SUBSCRIBE_TYPE_PASSIVE):
|
|
super().__init__()
|
|
self._service_name = service_name
|
|
self._service_specific_info = service_specific_info
|
|
self._match_filter = match_filter
|
|
self._terminate_notification_enabled = terminate_notification_enabled
|
|
self._ranging_enabled = ranging_enabled
|
|
self._subscribe_type = subscribe_type
|
|
|
|
class Builder(Stub):
|
|
"""SubscribeConfig.Builder — 构建器"""
|
|
|
|
def __init__(self):
|
|
super().__init__()
|
|
self._service_name: str = ""
|
|
self._service_specific_info: bytes = b""
|
|
self._match_filter: bytes = b""
|
|
self._terminate_notification_enabled: bool = True
|
|
self._ranging_enabled: bool = False
|
|
self._subscribe_type: int = SubscribeConfig.SUBSCRIBE_TYPE_PASSIVE
|
|
|
|
def setServiceName(self, serviceName: str) -> "SubscribeConfig.Builder":
|
|
self._service_name = serviceName
|
|
return self
|
|
|
|
def setServiceSpecificInfo(self, info: bytes) -> "SubscribeConfig.Builder":
|
|
self._service_specific_info = info
|
|
return self
|
|
|
|
def setMatchFilter(self, matchFilter: bytes) -> "SubscribeConfig.Builder":
|
|
self._match_filter = matchFilter
|
|
return self
|
|
|
|
def setTerminateNotificationEnabled(self, enabled: bool) -> "SubscribeConfig.Builder":
|
|
self._terminate_notification_enabled = enabled
|
|
return self
|
|
|
|
def setRangingEnabled(self, enabled: bool) -> "SubscribeConfig.Builder":
|
|
self._ranging_enabled = enabled
|
|
return self
|
|
|
|
def setSubscribeType(self, subscribeType: int) -> "SubscribeConfig.Builder":
|
|
self._subscribe_type = subscribeType
|
|
return self
|
|
|
|
def build(self) -> "SubscribeConfig":
|
|
return SubscribeConfig(
|
|
self._service_name, self._service_specific_info,
|
|
self._match_filter, self._terminate_notification_enabled,
|
|
self._ranging_enabled, self._subscribe_type,
|
|
)
|
|
|
|
def toString(self) -> str:
|
|
return f"SubscribeConfig{{service={self._service_name}, type={self._subscribe_type}}}"
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# DiscoverySession
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
class DiscoverySession(Stub):
|
|
"""DiscoverySession — 发现会话基类"""
|
|
|
|
def __init__(self, service_name: str = ""):
|
|
super().__init__()
|
|
self._service_name = service_name
|
|
self._terminate_notification_enabled: bool = True
|
|
self._open: bool = True
|
|
|
|
def sendMessage(self, peerHandle: Any, message: bytes, messageId: int):
|
|
pass
|
|
|
|
def close(self):
|
|
self._open = False
|
|
|
|
def setTerminateNotificationEnabled(self, enabled: bool):
|
|
self._terminate_notification_enabled = enabled
|
|
|
|
def toString(self) -> str:
|
|
return f"DiscoverySession{{service={self._service_name}}}"
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# PublishDiscoverySession
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
class PublishDiscoverySession(DiscoverySession):
|
|
"""PublishDiscoverySession — 发布发现会话"""
|
|
|
|
def __init__(self, service_name: str = ""):
|
|
super().__init__(service_name)
|
|
|
|
def updatePublishConfig(self, publishConfig: PublishConfig):
|
|
pass
|
|
|
|
def toString(self) -> str:
|
|
return f"PublishDiscoverySession{{service={self._service_name}}}"
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# SubscribeDiscoverySession
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
class SubscribeDiscoverySession(DiscoverySession):
|
|
"""SubscribeDiscoverySession — 订阅发现会话"""
|
|
|
|
def __init__(self, service_name: str = ""):
|
|
super().__init__(service_name)
|
|
|
|
def updateSubscribeConfig(self, subscribeConfig: SubscribeConfig):
|
|
pass
|
|
|
|
def toString(self) -> str:
|
|
return f"SubscribeDiscoverySession{{service={self._service_name}}}"
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# WifiAwareSession
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
class WifiAwareSession(Stub):
|
|
"""WifiAwareSession — Wi-Fi Aware 会话"""
|
|
|
|
def __init__(self):
|
|
super().__init__()
|
|
self._open: bool = True
|
|
self._publish_sessions: List[PublishDiscoverySession] = []
|
|
self._subscribe_sessions: List[SubscribeDiscoverySession] = []
|
|
|
|
def publish(self, publishConfig: PublishConfig,
|
|
callback: DiscoverySessionCallback,
|
|
handler: Any = None) -> PublishDiscoverySession:
|
|
session = PublishDiscoverySession(publishConfig._service_name)
|
|
self._publish_sessions.append(session)
|
|
return session
|
|
|
|
def subscribe(self, subscribeConfig: SubscribeConfig,
|
|
callback: DiscoverySessionCallback,
|
|
handler: Any = None) -> SubscribeDiscoverySession:
|
|
session = SubscribeDiscoverySession(subscribeConfig._service_name)
|
|
self._subscribe_sessions.append(session)
|
|
return session
|
|
|
|
def createNetworkSpecifier(self, role: int, service_name: str,
|
|
pmk: Optional[bytes] = None,
|
|
passphrase: Optional[str] = None) -> Any:
|
|
return None
|
|
|
|
def createNetworkSpecifier(self, role: int, service_name: str,
|
|
peer_handle: Any,
|
|
pmk: Optional[bytes] = None,
|
|
passphrase: Optional[str] = None) -> Any:
|
|
return None
|
|
|
|
def sendMessage(self, peerHandle: Any, message: bytes, messageId: int):
|
|
pass
|
|
|
|
def close(self):
|
|
self._open = False
|
|
|
|
def toString(self) -> str:
|
|
return f"WifiAwareSession@{hex(id(self))}"
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# WifiAwareManager
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
class WifiAwareManager(Stub):
|
|
"""WifiAwareManager — Wi-Fi Aware 管理器"""
|
|
|
|
WIFI_AWARE_DATA_PATH_ROLE_INITIATOR = 0
|
|
WIFI_AWARE_DATA_PATH_ROLE_RESPONDER = 1
|
|
ACTION_WIFI_AWARE_STATE_CHANGED = "android.net.wifi.aware.action.WIFI_AWARE_STATE_CHANGED"
|
|
|
|
def __init__(self):
|
|
super().__init__()
|
|
self._available: bool = True
|
|
self._sessions: List[WifiAwareSession] = []
|
|
|
|
# ── Attach ──
|
|
|
|
def attach(self, callback: AttachCallback, handler: Any = None) -> None:
|
|
session = WifiAwareSession()
|
|
self._sessions.append(session)
|
|
callback.onAttached(session)
|
|
|
|
def attach(self, attachCallback: AttachCallback,
|
|
identityChangedListener: IdentityChangedListener,
|
|
handler: Any = None) -> None:
|
|
session = WifiAwareSession()
|
|
self._sessions.append(session)
|
|
attachCallback.onAttached(session)
|
|
|
|
# ── Characteristics ──
|
|
|
|
def getCharacteristics(self) -> Characteristics:
|
|
return Characteristics()
|
|
|
|
# ── Available ──
|
|
|
|
def isAvailable(self) -> bool:
|
|
return self._available
|
|
|
|
def toString(self) -> str:
|
|
return f"WifiAwareManager{{available={self._available}}}"
|
|
|
|
|
|
# ═══════════════════════════════════════════════════════════════
|
|
# __all__
|
|
# ═══════════════════════════════════════════════════════════════
|
|
|
|
__all__ = [
|
|
"WifiAwareManager",
|
|
"WifiAwareSession",
|
|
"PublishConfig",
|
|
"SubscribeConfig",
|
|
"DiscoverySession",
|
|
"PublishDiscoverySession",
|
|
"SubscribeDiscoverySession",
|
|
"DiscoverySessionCallback",
|
|
"Characteristics",
|
|
"AttachCallback",
|
|
"IdentityChangedListener",
|
|
] |