Émettre des certifications numériques

L'API Credential Manager vous permet d'émettre des identifiants pour les applications de portefeuille Android. Ce guide explique comment émettre des identifiants pour le titulaire préféré d'un utilisateur.

Implémentation

Cette section détaille les étapes requises pour émettre des identifiants numériques.

Ajouter des dépendances

Ajoutez les dépendances suivantes à votre script de compilation 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"
}

Initialiser Credential Manager

Initialisez une instance de la classe CredentialManager.

val credentialManager = CredentialManager.create(context)

Créer une demande d'émission

La requête de création d'un justificatif numérique doit contenir une chaîne JSON conforme au protocole standard OpenID4VCI. Voici un exemple de requête 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": "..."
        }
      }
    }
  }
]

Créez un fichier CreateDigitalCredentialRequest contenant la demande d'émission.

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

Envoyer la demande d'émission

Émettez l'identifiant pour le titulaire de l'utilisateur à l'aide de la fonction createCredential. Cette fonction lance le sélecteur de bottom sheet du Credential Manager, qui permet à l'utilisateur de sélectionner l'application de stockage dans laquelle il souhaite enregistrer l'identifiant.

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

Gérer la réponse

Une fois la demande d'émission effectuée, un CreateDigitalCredentialResponse est renvoyé. Cette réponse contient une chaîne responseJson, qui décrit le résultat de l'émission.

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

Gérer les exceptions

Si le flux d'émission échoue, createCredential génère une exception CreateCredentialException, que votre application doit gérer :

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