Emitir credenciais digitais

A API Credential Manager permite emitir credenciais para apps de detentor (também chamados de "carteira") do Android. Este guia explica como salvar credenciais no detentor preferido de um usuário.

Implementação

Esta seção detalha as etapas necessárias para emitir credenciais digitais.

Adicionar dependências

Adicione as seguintes dependências ao script de build do Gradle:

Kotlin

dependencies {
    implementation("androidx.credentials:credentials:1.7.0-alpha02")
    implementation("androidx.credentials:credentials-play-services-auth:1.7.0-alpha02")
}

Groovy

dependencies {
    implementation "androidx.credentials:credentials:1.7.0-alpha02"
    implementation "androidx.credentials:credentials-play-services-auth:1.7.0-alpha02"
}

Inicializar o Credential Manager

Inicialize uma instância da classe CredentialManager.

val credentialManager = CredentialManager.create(context)

Criar uma solicitação de emissão

A solicitação de criação de credencial digital precisa conter uma string JSON que siga o protocolo padrão OpenID4VCI. Confira um exemplo de como uma solicitação OpenID4VCI aparece:

"requests": [
  {
    "protocol": "openid4vci-v1",
    "data": {
      "credential_issuer": "https://digital-credentials.dev",
      "credential_configuration_ids": [
        "com.emvco.payment_card"
      ],
      "grants": {
        "urn:ietf:params:oauth:grant-type:pre-authorized_code": {
          "pre-authorized_code": "..."
        }
      }
    }
  }
]

Crie um CreateDigitalCredentialRequest que contenha a solicitação de emissão.

val issuanceRequestJson = "{ ... }" // Your issuance JSON
val createRequest = CreateDigitalCredentialRequest(
    requestJson = issuanceRequestJson,
    origin = null
)

Fazer a solicitação de emissão

Emita a credencial para o detentor do usuário usando a função createCredential. Essa função inicia o seletor de página inferior do Credential Manager, que permite ao usuário selecionar o app de detentor em que a credencial será armazenada.

try {
    val response = credentialManager.createCredential(
        context = context,
        request = createRequest
    )
    handleSuccess(response as CreateDigitalCredentialResponse)
} catch (e: CreateCredentialException) {
    handleCreateException(e)
}

Processar a resposta

Depois de fazer a solicitação de emissão, um CreateDigitalCredentialResponse será retornado. Essa resposta contém uma string responseJson, que descreve o resultado da emissão.

fun handleSuccess(response: CreateDigitalCredentialResponse) {
    val responseJson = response.responseJson
    // Parse responseJson according to your protocol (e.g. OpenID4VCI)
}

Tratar exceções

Se o fluxo de emissão falhar, createCredential vai gerar uma CreateCredentialException, que seu app precisa processar:

fun handleCreateException(e: CreateCredentialException) {
    when (e) {
        is CreateCredentialCancellationException -> {
            // The user canceled the flow
        }
        is CreateCredentialInterruptedException -> {
            // The flow was interrupted (e.g. by another UI element)
        }
        is CreateCredentialNoCreateOptionException -> {
            // No wallet application is available to handle the request
        }
        is CreateCredentialUnsupportedException -> {
            // The device or the system doesn't support this request
        }
        is CreateCredentialProviderConfigurationException -> {
            // There is a configuration issue with the wallet provider
        }
        is CreateCredentialCustomException -> {
            // A protocol-specific error occurred
            val errorType = e.type
            val errorMessage = e.message
        }
        is CreateCredentialUnknownException -> {
            // An unknown error occurred
        }
        else -> {
            // Generic error handling
        }
    }
}