Emitir credenciales digitales

La API de Credential Manager te permite emitir credenciales para apps de titular de Android (también llamadas "billetera"). En esta guía, se explica cómo guardar credenciales en el titular preferido de un usuario.

Implementación

En esta sección, se detallan los pasos necesarios para emitir credenciales digitales.

Cómo agregar dependencias

Agrega las siguientes dependencias a tu secuencia de comandos de compilación de 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"
}

Inicializa el Administrador de credenciales

Inicializa una instancia de la clase CredentialManager.

val credentialManager = CredentialManager.create(context)

Crea una solicitud de emisión

La solicitud de creación de credenciales digitales debe contener una cadena JSON que siga el protocolo estándar de OpenID4VCI. Este es un ejemplo de cómo se ve una solicitud de OpenID4VCI:

"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": "..."
        }
      }
    }
  }
]

Crea un objeto CreateDigitalCredentialRequest que contenga la solicitud de emisión.

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

Realiza la solicitud de emisión

Emite la credencial al titular del usuario con la función createCredential. Esta función inicia el selector de hoja inferior del Administrador de credenciales que permite al usuario seleccionar la app de titular en la que desea que se almacene la credencial.

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

Cómo controlar la respuesta

Después de que realices la solicitud de emisión, se devolverá un CreateDigitalCredentialResponse. Esta respuesta contiene una cadena responseJson, que describe el resultado de la emisión.

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

Cómo controlar excepciones

Si falla el flujo de emisión, createCredential arroja un CreateCredentialException, que tu app debería controlar:

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
        }
    }
}