Android-pyApi/android_pyapi/android/net_vpn.py

"""
Android net.vpn 包 — VpnManager, VpnService, VpnService.Builder
方法签名完全对齐 Android SDK
"""

from __future__ import annotations

import sys
from typing import Any, Dict, List, Optional, Tuple

from .._core import Stub, AndroidOnlyError
from ..java.lang import RuntimeException

IllegalArgumentException = type("IllegalArgumentException", (RuntimeException,), {})

__all__ = [
    "VpnManager",
    "VpnService",
    "VpnServiceBuilder",
]


# ═══════════════════════════════════════════════════════════════
# VpnManager
# ═══════════════════════════════════════════════════════════════

class VpnManager(Stub):
    """VpnManager — VPN 管理器 (桌面存根)"""

    def __init__(self, context: Any = None):
        super().__init__()
        self._context = context
        self._package = ""
        self._addresses: List[str] = []
        self._routes: List[str] = []
        self._mtu = 1500
        self._session = ""
        self._configured_packages: List[str] = []
        self._blocking = False
        self._blocking_packages: List[str] = []
        self._network: Optional[Any] = None
        self._http_proxy: Optional[Any] = None
        self._underlying_networks: Optional[List[Any]] = None

    def setPackage(self, package_name: str) -> "VpnManager":
        """设置包名"""
        self._package = package_name
        return self

    def addAddress(self, address: str, prefix_length: int) -> "VpnManager":
        """添加地址"""
        self._addresses.append(f"{address}/{prefix_length}")
        return self

    def removeAddress(self, address: str, prefix_length: int) -> "VpnManager":
        """移除地址"""
        addr = f"{address}/{prefix_length}"
        if addr in self._addresses:
            self._addresses.remove(addr)
        return self

    def setRoute(self, address: str, prefix_length: int) -> "VpnManager":
        """设置路由"""
        self._routes.append(f"{address}/{prefix_length}")
        return self

    def setMtu(self, mtu: int) -> "VpnManager":
        """设置 MTU"""
        self._mtu = mtu
        return self

    def setSession(self, session: str) -> "VpnManager":
        """设置会话名称"""
        self._session = session
        return self

    def setConfiguredPackages(self, packages: List[str]) -> "VpnManager":
        """设置已配置的包"""
        self._configured_packages = packages
        return self

    def setBlocking(self, blocking: bool) -> "VpnManager":
        """设置阻塞模式"""
        self._blocking = blocking
        return self

    def setBlockingPackages(self, packages: List[str]) -> "VpnManager":
        """设置阻塞包"""
        self._blocking_packages = packages
        return self

    def establish(self) -> Optional["VpnService"]:
        """建立 VPN"""
        return VpnService(self._context)

    def prepare(self, context: Any) -> Optional[Any]:
        """准备 VPN"""
        return None

    def getNetwork(self) -> Optional[Any]:
        """获取网络"""
        return self._network

    def setHttpProxy(self, proxy: Any) -> "VpnManager":
        """设置 HTTP 代理"""
        self._http_proxy = proxy
        return self

    def setUnderlyingNetworks(self, networks: Optional[List[Any]]) -> "VpnManager":
        """设置底层网络"""
        self._underlying_networks = networks
        return self

    @staticmethod
    def isAlwaysOnVpnSupported(context: Any) -> bool:
        """检查是否支持始终开启 VPN"""
        return False

    @staticmethod
    def setAlwaysOnVpn(context: Any, vpn_component: Any, lockdown: bool) -> None:
        """设置始终开启 VPN"""
        raise AndroidOnlyError("setAlwaysOnVpn 仅在 Android 设备上可用")

    @staticmethod
    def getAlwaysOnVpnPackage(context: Any) -> Optional[str]:
        """获取始终开启 VPN 包名"""
        return None


# ═══════════════════════════════════════════════════════════════
# VpnService
# ═══════════════════════════════════════════════════════════════

class VpnService(Stub):
    """VpnService — VPN 服务 (桌面存根)"""

    SERVICE_INTERFACE = "android.net.VpnService"
    SERVICE_META_DATA_SUPPORTS_ALWAYS_ON = "android.net.VpnService.SUPPORTS_ALWAYS_ON"

    def __init__(self, context: Any = None):
        super().__init__()
        self._context = context
        self._underlying_networks: Optional[List[Any]] = None
        self._tunnel: Optional[Any] = None

    def onStartCommand(self, intent: Any, flags: int, start_id: int) -> int:
        """启动命令"""
        return 0

    def onBind(self, intent: Any) -> Optional[Any]:
        """绑定"""
        return None

    def onRevoke(self) -> None:
        """撤销"""
        pass

    @staticmethod
    def prepare(context: Any) -> Optional[Any]:
        """准备 VPN"""
        return None

    @staticmethod
    def protect(socket: Any) -> bool:
        """保护套接字免受 VPN 路由影响"""
        return True

    def setUnderlyingNetworks(self, networks: Optional[List[Any]]) -> None:
        """设置底层网络"""
        self._underlying_networks = networks

    def toString(self) -> str:
        return "VpnService"


# ═══════════════════════════════════════════════════════════════
# VpnService.Builder (aliased as VpnServiceBuilder)
# ═══════════════════════════════════════════════════════════════

class VpnServiceBuilder(Stub):
    """VpnService.Builder — VPN 服务构建器 (桌面存根)"""

    def __init__(self, vpn_service: Optional[VpnService] = None):
        super().__init__()
        self._vpn_service = vpn_service or VpnService()
        self._mtu = 1500
        self._addresses: List[Tuple[str, int]] = []
        self._routes: List[Tuple[str, int]] = []
        self._search_domains: List[str] = []
        self._dns_servers: List[str] = []
        self._session = ""
        self._configured_packages: List[str] = []
        self._allowed_applications: List[str] = []
        self._disallowed_applications: List[str] = []
        self._blocking = False
        self._http_proxy: Optional[Any] = None
        self._underlying_networks: Optional[List[Any]] = None
        self._metered = False

    def setMtu(self, mtu: int) -> "VpnServiceBuilder":
        """设置 MTU"""
        self._mtu = mtu
        return self

    def addAddress(self, address: str, prefix_length: int) -> "VpnServiceBuilder":
        """添加地址"""
        self._addresses.append((address, prefix_length))
        return self

    def addRoute(self, address: str, prefix_length: int) -> "VpnServiceBuilder":
        """添加路由"""
        self._routes.append((address, prefix_length))
        return self

    def addSearchDomain(self, domain: str) -> "VpnServiceBuilder":
        """添加搜索域"""
        self._search_domains.append(domain)
        return self

    def addDnsServer(self, address: str) -> "VpnServiceBuilder":
        """添加 DNS 服务器"""
        self._dns_servers.append(address)
        return self

    def setSession(self, session: str) -> "VpnServiceBuilder":
        """设置会话名称"""
        self._session = session
        return self

    def setConfiguredPackages(self, packages: List[str]) -> "VpnServiceBuilder":
        """设置已配置的包"""
        self._configured_packages = packages
        return self

    def setAllowedApplications(self, packages: List[str]) -> "VpnServiceBuilder":
        """设置允许的应用"""
        self._allowed_applications = packages
        return self

    def setDisallowedApplications(self, packages: List[str]) -> "VpnServiceBuilder":
        """设置不允许的应用"""
        self._disallowed_applications = packages
        return self

    def setBlocking(self, blocking: bool) -> "VpnServiceBuilder":
        """设置阻塞模式"""
        self._blocking = blocking
        return self

    def setHttpProxy(self, proxy: Any) -> "VpnServiceBuilder":
        """设置 HTTP 代理"""
        self._http_proxy = proxy
        return self

    def setUnderlyingNetworks(self, networks: Optional[List[Any]]) -> "VpnServiceBuilder":
        """设置底层网络"""
        self._underlying_networks = networks
        return self

    def establish(self) -> Optional[Any]:
        """建立 VPN 隧道"""
        return None

    def setMetered(self, metered: bool) -> "VpnServiceBuilder":
        """设置计量连接"""
        self._metered = metered
        return self

    def addAllowedApplication(self, package: str) -> "VpnServiceBuilder":
        """添加允许的应用"""
        if package not in self._allowed_applications:
            self._allowed_applications.append(package)
        return self

    def addDisallowedApplication(self, package: str) -> "VpnServiceBuilder":
        """添加不允许的应用"""
        if package not in self._disallowed_applications:
            self._disallowed_applications.append(package)
        return self