Android-pyApi/android_pyapi/android/permission.py

"""
Android permission 组件 — PermissionManager, PermissionChecker 等
方法签名完全对齐 Android SDK
"""

from __future__ import annotations

import threading
from typing import Any, Callable, Dict, List, Optional, Set

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

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


# ═══════════════════════════════════════════════════════════════
# PermissionChecker
# ═══════════════════════════════════════════════════════════════

class PermissionChecker(Stub):
    """PermissionChecker — 权限检查器"""

    PERMISSION_GRANTED = 0
    PERMISSION_DENIED = -1
    PERMISSION_DENIED_APP_OP = -2
    PID_UNKNOWN = -1

    @staticmethod
    def checkPermission(context: Any, permission: str, pid: int, uid: int,
                        packageName: str) -> int:
        return PermissionChecker.PERMISSION_GRANTED

    @staticmethod
    def checkSelfPermission(context: Any, permission: str) -> int:
        return PermissionChecker.PERMISSION_GRANTED


# ═══════════════════════════════════════════════════════════════
# PermissionManager
# ═══════════════════════════════════════════════════════════════

class PermissionManager(Stub):
    """PermissionManager — 权限管理器"""

    PERMISSION_GRANTED = 0
    PERMISSION_DENIED = -1

    FLAG_PERMISSION_GRANTED_BY_DEFAULT = 1 << 5
    FLAG_PERMISSION_POLICY_FIXED = 1 << 4
    FLAG_PERMISSION_SYSTEM_FIXED = 1 << 3
    FLAG_PERMISSION_USER_FIXED = 1 << 2
    FLAG_PERMISSION_USER_SET = 1 << 0
    FLAG_PERMISSION_REVIEW_REQUIRED = 1 << 6
    FLAG_PERMISSION_REVOKE_WHEN_REQUESTED = 1 << 7
    FLAG_PERMISSION_REVOKED_COMPAT = 1 << 10
    FLAG_PERMISSION_ONE_TIME = 1 << 8
    FLAG_PERMISSION_USER_SENSITIVE_WHEN_GRANTED = 1 << 9
    FLAG_PERMISSION_USER_SENSITIVE_WHEN_DENIED = 1 << 11
    FLAG_PERMISSION_AUTO_REVOKED = 1 << 12
    FLAG_PERMISSION_SELECTED_LOCATION_ACCURACY = 1 << 13

    def __init__(self):
        super().__init__()
        self._lock = threading.Lock()
        self._granted_permissions: Dict[str, bool] = {}
        self._permission_flags: Dict[str, int] = {}
        self._listeners: List[Callable[[str], None]] = []

    # ── Check ──

    def checkPermission(self, permission: str, pid: int = -1, uid: int = -1) -> int:
        with self._lock:
            if self._granted_permissions.get(permission, True):
                return self.PERMISSION_GRANTED
            return self.PERMISSION_DENIED

    def isRuntimePermission(self, permission: str) -> bool:
        return True

    # ── Flags ──

    def getPermissionFlags(self, permission: str, packageName: str, user: Any = None) -> int:
        with self._lock:
            return self._permission_flags.get(permission, 0)

    def updatePermissionFlags(self, permission: str, packageName: str,
                              flagMask: int, flagValues: int,
                              user: Any = None) -> bool:
        with self._lock:
            current = self._permission_flags.get(permission, 0)
            current = (current & ~flagMask) | (flagValues & flagMask)
            self._permission_flags[permission] = current
            return True

    # ── Grant / Revoke ──

    def grantPermission(self, permission: str, packageName: str, user: Any = None):
        with self._lock:
            self._granted_permissions[permission] = True

    def revokePermission(self, permission: str, packageName: str, user: Any = None):
        with self._lock:
            self._granted_permissions[permission] = False

    # ── Rationale ──

    def shouldShowRequestPermissionRationale(self, permission: str) -> bool:
        return False

    # ── Listed ──

    def getGrantedPermissions(self) -> List[str]:
        with self._lock:
            return [p for p, g in self._granted_permissions.items() if g]

    def getDeniedPermissions(self) -> List[str]:
        with self._lock:
            return [p for p, g in self._granted_permissions.items() if not g]

    def getSplitPermissions(self) -> List[Any]:
        return []

    # ── Revocation ──

    def isPermissionRevokedByPolicy(self, permission: str, packageName: str) -> bool:
        return False

    # ── Listeners ──

    def addOnPermissionsChangeListener(self, listener: Callable[[str], None]):
        with self._lock:
            if listener not in self._listeners:
                self._listeners.append(listener)

    def removeOnPermissionsChangeListener(self, listener: Callable[[str], None]):
        with self._lock:
            if listener in self._listeners:
                self._listeners.remove(listener)

    def _notify_listeners(self, permission: str):
        with self._lock:
            for listener in self._listeners:
                listener(permission)

    # ── Misc ──

    def getPermissionControllerService(self) -> Any:
        return None

    def toString(self) -> str:
        return f"PermissionManager@{hex(id(self))}"


# ═══════════════════════════════════════════════════════════════
# __all__
# ═══════════════════════════════════════════════════════════════

__all__ = [
    "PermissionManager",
    "PermissionChecker",
]