Émettre des certifications numériques

L'API Credential Manager vous permet d'émettre des identifiants pour les applications Android de détenteur (également appelées "portefeuille"). Ce guide explique comment enregistrer des identifiants dans le détenteur préféré d'un utilisateur.

Implémentation

Cette section décrit 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 le Gestionnaire d'identifiants

Initialisez une instance de la classe CredentialManager.

val credentialManager = CredentialManager.create(context)

Créer une demande d'émission

La demande de création d'identifiants numériques doit contenir une chaîne JSON qui suit le 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 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 détenteur de l'utilisateur à l'aide de la fonction createCredential. Cette fonction lance le sélecteur de feuille inférieure du Gestionnaire d'identifiants, qui permet à l'utilisateur de sélectionner l'application de détenteur dans laquelle il souhaite stocker 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 un 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
        }
    }
}