Android-pyApi/android_pyapi/android/credentials.py

"""
Android Credentials API — CredentialManager, CreateCredentialRequest, GetCredentialRequest 等
方法签名完全对齐 Android SDK
"""

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

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


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

__all__ = [
    "CredentialManager",
    "CreateCredentialRequest",
    "CreateCredentialResponse",
    "GetCredentialRequest",
    "GetCredentialResponse",
    "CredentialDescription",
    "CredentialManagerState",
    "PrepareGetCredentialResponse",
]


# ═══════════════════════════════════════════════════════════════
# CredentialManager
# ═══════════════════════════════════════════════════════════════

class CredentialManager(Stub):
    """CredentialManager — 凭据管理器 (桌面存根)"""

    ACTION_CREATE_CREDENTIAL = "android.credentials.action.CREATE_CREDENTIAL"
    ACTION_GET_CREDENTIAL = "android.credentials.action.GET_CREDENTIAL"
    ACTION_CLEAR_CREDENTIAL = "android.credentials.action.CLEAR_CREDENTIAL"

    def __init__(self, context: Any = None):
        super().__init__()
        self._context = context
        self._descriptions: List["CredentialDescription"] = []

    def createCredential(
        self,
        request: "CreateCredentialRequest",
        cancellationSignal: Any = None,
        executor: Any = None,
        callback: Callable = None,
    ):
        """创建凭据"""
        raise AndroidOnlyError("CredentialManager.createCredential() 仅在 Android 设备上可用")

    def getCredential(
        self,
        request: "GetCredentialRequest",
        cancellationSignal: Any = None,
        executor: Any = None,
        callback: Callable = None,
    ):
        """获取凭据"""
        raise AndroidOnlyError("CredentialManager.getCredential() 仅在 Android 设备上可用")

    def clearCredentialState(
        self,
        request: Any = None,
        cancellationSignal: Any = None,
        executor: Any = None,
        callback: Callable = None,
    ):
        """清除凭据状态"""
        raise AndroidOnlyError("CredentialManager.clearCredentialState() 仅在 Android 设备上可用")

    def registerCredentialDescription(
        self,
        credentialDescription: "CredentialDescription",
        cancellationSignal: Any = None,
        executor: Any = None,
        callback: Callable = None,
    ):
        """注册凭据描述"""
        if credentialDescription not in self._descriptions:
            self._descriptions.append(credentialDescription)

    def unregisterCredentialDescription(
        self,
        credentialDescription: "CredentialDescription",
    ):
        """注销凭据描述"""
        if credentialDescription in self._descriptions:
            self._descriptions.remove(credentialDescription)

    def getCredentialManagerState(self) -> "CredentialManagerState":
        """获取凭据管理器状态"""
        return CredentialManagerState()

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

    def equals(self, other) -> bool:
        return self is other

    def hashCode(self) -> int:
        return id(self) & 0x7FFFFFFF


# ═══════════════════════════════════════════════════════════════
# CreateCredentialRequest
# ═══════════════════════════════════════════════════════════════

class CreateCredentialRequest(Stub):
    """CreateCredentialRequest — 创建凭据请求"""

    class Builder(Stub):
        """CreateCredentialRequest.Builder — 创建凭据请求构建器"""

        def __init__(self, credentialType: str = ""):
            super().__init__()
            self._credential_type = credentialType
            self._credential_data = None
            self._candidate_query_data = None
            self._always_send_app_uri = False
            self._origin = ""

        def setCredentialData(self, data: Any) -> "CreateCredentialRequest.Builder":
            self._credential_data = data
            return self

        def setCandidateQueryData(
            self, data: Any
        ) -> "CreateCredentialRequest.Builder":
            self._candidate_query_data = data
            return self

        def setAlwaysSendAppUri(
            self, alwaysSend: bool
        ) -> "CreateCredentialRequest.Builder":
            self._always_send_app_uri = alwaysSend
            return self

        def setOrigin(self, origin: str) -> "CreateCredentialRequest.Builder":
            self._origin = origin
            return self

        def build(self) -> "CreateCredentialRequest":
            req = CreateCredentialRequest.__new__(CreateCredentialRequest)
            req._credential_type = self._credential_type
            req._credential_data = self._credential_data
            req._candidate_query_data = self._candidate_query_data
            req._always_send_app_uri = self._always_send_app_uri
            req._origin = self._origin
            return req

        def toString(self) -> str:
            return f"CreateCredentialRequest.Builder(type={self._credential_type})"

        def equals(self, other) -> bool:
            return self is other

        def hashCode(self) -> int:
            return id(self) & 0x7FFFFFFF

    def __init__(self):
        super().__init__()
        self._credential_type = ""
        self._credential_data = None
        self._candidate_query_data = None
        self._always_send_app_uri = False
        self._origin = ""

    def getCredentialData(self) -> Optional[Any]:
        return self._credential_data

    def getCredentialType(self) -> str:
        return self._credential_type

    def getCandidateQueryData(self) -> Optional[Any]:
        return self._candidate_query_data

    def alwaysSendAppUri(self) -> bool:
        return self._always_send_app_uri

    def getOrigin(self) -> str:
        return self._origin

    def toString(self) -> str:
        return f"CreateCredentialRequest(type={self._credential_type})"

    def equals(self, other) -> bool:
        if not isinstance(other, CreateCredentialRequest):
            return False
        return self._credential_type == other._credential_type

    def hashCode(self) -> int:
        return hash(self._credential_type) & 0x7FFFFFFF


# ═══════════════════════════════════════════════════════════════
# CreateCredentialResponse
# ═══════════════════════════════════════════════════════════════

class CreateCredentialResponse(Stub):
    """CreateCredentialResponse — 创建凭据响应"""

    def __init__(self):
        super().__init__()
        self._credential_data = None
        self._credential_data_result = None

    def getCredentialData(self) -> Optional[Any]:
        return self._credential_data

    def getCredentialDataResult(self) -> Optional[Any]:
        return self._credential_data_result

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

    def equals(self, other) -> bool:
        return self is other

    def hashCode(self) -> int:
        return id(self) & 0x7FFFFFFF


# ═══════════════════════════════════════════════════════════════
# GetCredentialRequest
# ═══════════════════════════════════════════════════════════════

class GetCredentialRequest(Stub):
    """GetCredentialRequest — 获取凭据请求"""

    class Builder(Stub):
        """GetCredentialRequest.Builder — 获取凭据请求构建器"""

        def __init__(self):
            super().__init__()
            self._credential_data = None
            self._origin = ""
            self._always_send_app_uri = False
            self._candidate_query_data = None

        def setCredentialData(
            self, data: Any
        ) -> "GetCredentialRequest.Builder":
            self._credential_data = data
            return self

        def setOrigin(self, origin: str) -> "GetCredentialRequest.Builder":
            self._origin = origin
            return self

        def setAlwaysSendAppUri(
            self, alwaysSend: bool
        ) -> "GetCredentialRequest.Builder":
            self._always_send_app_uri = alwaysSend
            return self

        def setCandidateQueryData(
            self, data: Any
        ) -> "GetCredentialRequest.Builder":
            self._candidate_query_data = data
            return self

        def build(self) -> "GetCredentialRequest":
            req = GetCredentialRequest.__new__(GetCredentialRequest)
            req._credential_data = self._credential_data
            req._origin = self._origin
            req._always_send_app_uri = self._always_send_app_uri
            req._candidate_query_data = self._candidate_query_data
            return req

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

        def equals(self, other) -> bool:
            return self is other

        def hashCode(self) -> int:
            return id(self) & 0x7FFFFFFF

    def __init__(self):
        super().__init__()
        self._credential_data = None
        self._origin = ""
        self._always_send_app_uri = False
        self._candidate_query_data = None

    def getCredentialData(self) -> Optional[Any]:
        return self._credential_data

    def getOrigin(self) -> str:
        return self._origin

    def alwaysSendAppUri(self) -> bool:
        return self._always_send_app_uri

    def getCandidateQueryData(self) -> Optional[Any]:
        return self._candidate_query_data

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

    def equals(self, other) -> bool:
        return self is other

    def hashCode(self) -> int:
        return id(self) & 0x7FFFFFFF


# ═══════════════════════════════════════════════════════════════
# GetCredentialResponse
# ═══════════════════════════════════════════════════════════════

class GetCredentialResponse(Stub):
    """GetCredentialResponse — 获取凭据响应"""

    def __init__(self):
        super().__init__()
        self._credential_data_results: List[Any] = []

    def getCredentialDataResults(self) -> List[Any]:
        return list(self._credential_data_results)

    def toString(self) -> str:
        return f"GetCredentialResponse(results={len(self._credential_data_results)})"

    def equals(self, other) -> bool:
        return self is other

    def hashCode(self) -> int:
        return id(self) & 0x7FFFFFFF


# ═══════════════════════════════════════════════════════════════
# CredentialDescription
# ═══════════════════════════════════════════════════════════════

class CredentialDescription(Stub):
    """CredentialDescription — 凭据描述"""

    def __init__(self, credentialType: str = "", origin: str = ""):
        super().__init__()
        self._credential_type = credentialType
        self._origin = origin

    def getCredentialType(self) -> str:
        return self._credential_type

    def getOrigin(self) -> str:
        return self._origin

    def toString(self) -> str:
        return f"CredentialDescription(type={self._credential_type})"

    def equals(self, other) -> bool:
        if not isinstance(other, CredentialDescription):
            return False
        return (self._credential_type == other._credential_type
                and self._origin == other._origin)

    def hashCode(self) -> int:
        return hash((self._credential_type, self._origin)) & 0x7FFFFFFF


# ═══════════════════════════════════════════════════════════════
# CredentialManagerState
# ═══════════════════════════════════════════════════════════════

class CredentialManagerState(Stub):
    """CredentialManagerState — 凭据管理器状态"""

    def __init__(self):
        super().__init__()
        self._registered_descriptions: List["CredentialDescription"] = []
        self._is_enabled = True

    def getRegisteredCredentialDescriptions(self) -> List["CredentialDescription"]:
        return list(self._registered_descriptions)

    def isEnabled(self) -> bool:
        return self._is_enabled

    def toString(self) -> str:
        return f"CredentialManagerState(enabled={self._is_enabled})"

    def equals(self, other) -> bool:
        return self is other

    def hashCode(self) -> int:
        return id(self) & 0x7FFFFFFF


# ═══════════════════════════════════════════════════════════════
# PrepareGetCredentialResponse
# ═══════════════════════════════════════════════════════════════

class PrepareGetCredentialResponse(Stub):
    """PrepareGetCredentialResponse — 预备获取凭据响应"""

    def __init__(self):
        super().__init__()
        self._has_results = False
        self._pending_credential = None

    def hasResults(self) -> bool:
        return self._has_results

    def getPendingGetCredentialResponse(self) -> Optional["GetCredentialResponse"]:
        return self._pending_credential

    def toString(self) -> str:
        return f"PrepareGetCredentialResponse(hasResults={self._has_results})"

    def equals(self, other) -> bool:
        return self is other

    def hashCode(self) -> int:
        return id(self) & 0x7FFFFFFF