Intégrer la création et la connexion avec une clé d'accès à un seul geste avec des invites biométriques

Sur Android 15, le Gestionnaire d'identifiants est compatible avec un flux à un seul appui pour la création et la récupération d'identifiants. Dans ce flux, les informations de l'identifiant créé ou utilisé s'affichent directement dans l'invite biométrique, ainsi qu'un point d'entrée vers d'autres options. Ce processus simplifié permet de créer et de récupérer des identifiants de manière plus efficace et rationalisée.

Exigences :

• Les données biométriques ont été configurées sur l'appareil de l'utilisateur, et celui-ci les autorise pour l'authentification dans les applications.
• Pour les flux de connexion, cette fonctionnalité n'est activée que pour les scénarios à compte unique, même si plusieurs identifiants (tels qu'une clé d'accès et un mot de passe) sont disponibles pour ce compte.

Activer l'appui unique dans les flux de création de clés d'accès

Les étapes de création de cette méthode correspondent au processus de création d'identifiants existant. Dans votre BeginCreatePublicKeyCredentialRequest, utilisez handleCreatePasskeyQuery() pour traiter la requête si elle concerne une clé d'accès.

is BeginCreatePublicKeyCredentialRequest -> {
    Log.i(TAG, "Request is passkey type")
    return handleCreatePasskeyQuery(request, passwordCount, passkeyCount)
}

Dans votre handleCreatePasskeyQuery(), incluez BiometricPromptData avec la classe CreateEntry :

val createEntry = CreateEntry(
    // Additional properties...
    biometricPromptData = BiometricPromptData(
        allowedAuthenticators = allowedAuthenticator
    ),
)

Les fournisseurs d'identifiants doivent définir explicitement la propriété allowedAuthenticator dans l'instance BiometricPromptData. Si cette propriété n'est pas définie, la valeur par défaut est DEVICE_WEAK. Définissez la propriété facultative cryptoObject si nécessaire pour votre cas d'utilisation.

Remarque : Si l'appareil est configuré pour utiliser DEVICE_CREDENTIALS afin d'exiger un code d'accès ou un code secret pour l'authentification, que les données biométriques soient disponibles ou activées, le flux standard du gestionnaire d'identifiants sera utilisé à la place du flux à un seul appui. Cela signifie que le fournisseur recevra toujours une valeur null pour biometricPromptResult dans ces scénarios.

Activer l'appui unique dans les flux de connexion par clé d'accès

Comme pour le flux de création de clés d'accès, cette méthode suivra la configuration existante pour la gestion de la connexion des utilisateurs. Sous BeginGetPublicKeyCredentialOption, utilisez populatePasskeyData() pour collecter les informations pertinentes sur la requête d'authentification :

is BeginGetPublicKeyCredentialOption -> {
    // ... other logic

    populatePasskeyData(
        origin,
        option,
        responseBuilder,
        autoSelectEnabled,
        allowedAuthenticator
    )

    // ... other logic as needed
}

Comme pour CreateEntry, une instance BiometricPromptData est définie sur l'instance PublicKeyCredentialEntry. Si elle n'est pas définie explicitement, allowedAuthenticator est défini par défaut sur BIOMETRIC_WEAK.

PublicKeyCredentialEntry(
    // other properties...

    biometricPromptData = BiometricPromptData(
        allowedAuthenticators = allowedAuthenticator
    )
)

Remarque : L'utilisateur dispose d'une option d'authentification biométrique si son appareil la prend en charge et qu'il a autorisé son utilisation. Le code est semblable à l'exemple précédent, avec l'ajout d'un cryptoObject.

Gérer la sélection des entrées d'identifiants

Lors de la gestion de la sélection des entrées d'identifiants pour la création de clés d'accès ou la sélection de clés d'accès lors de la connexion, appelez PendingIntentHandler's retrieveProviderCreateCredentialRequest ou retrieveProviderGetCredentialRequest, selon le cas. Ces objets renvoient les métadonnées nécessaires au fournisseur. Par exemple, lorsque vous gérez la sélection des entrées de création de clés d'accès, mettez à jour votre code comme suit :

val createRequest = PendingIntentHandler.retrieveProviderCreateCredentialRequest(intent)
if (createRequest == null) {
    Log.i(TAG, "request is null")
    setUpFailureResponseAndFinish("Unable to extract request from intent")
    return
}
// Other logic...

val biometricPromptResult = createRequest.biometricPromptResult

// Add your logic based on what needs to be done
// after getting biometrics

if (createRequest.callingRequest is CreatePublicKeyCredentialRequest) {
    val publicKeyRequest: CreatePublicKeyCredentialRequest =
        createRequest.callingRequest as CreatePublicKeyCredentialRequest

    if (biometricPromptResult == null) {
        // Do your own authentication flow, if needed
    } else if (biometricPromptResult.isSuccessful) {
        createPasskey(
            publicKeyRequest.requestJson,
            createRequest.callingAppInfo,
            publicKeyRequest.clientDataHash,
            accountId
        )
    } else {
        val error = biometricPromptResult.authenticationError
        // Process the error
    }

    // Other logic...
}

Cet exemple contient des informations sur la réussite du flux biométrique. Il contient également d'autres informations sur l'identifiant. Si le flux échoue, utilisez le code d'erreur sous biometricPromptResult.authenticationError pour prendre des décisions. Les codes d'erreur renvoyés dans biometricPromptResult.authenticationError.errorCode sont les mêmes que ceux définis dans la bibliothèque androidx.biometric, tels que androidx.biometric.BiometricPrompt.NO_SPACE, androidx.biometric.BiometricPrompt.UNABLE_TO_PROCESS, androidx.biometric.BiometricPrompt.ERROR_TIMEOUT, etc. authenticationError contient également un message d'erreur associé à errorCode, qui peut être affiché dans une interface utilisateur.

De même, extrayez les métadonnées lors de la retrieveProviderGetCredentialRequest. Vérifiez si votre flux biométrique est null. Si c'est le cas, configurez vos propres données biométriques pour vous authentifier. Cela ressemble à la façon dont l'opération get est instrumentée :

val getRequest =
    PendingIntentHandler.retrieveProviderGetCredentialRequest(intent)

if (getRequest == null) {
    Log.i(TAG, "request is null")
    setUpFailureResponseAndFinish("Unable to extract request from intent")
    return
}

// Other logic...

val biometricPromptResult = getRequest.biometricPromptResult

// Add your logic based on what needs to be done
// after getting biometrics

if (biometricPromptResult == null) {
    // Do your own authentication flow, if necessary
} else if (biometricPromptResult.isSuccessful) {

    Log.i(TAG, "The response from the biometricPromptResult was ${biometricPromptResult.authenticationResult?.authenticationType}")

    validatePasskey(
        publicKeyRequest.requestJson,
        origin,
        packageName,
        uid,
        passkey.username,
        credId,
        privateKey
    )
} else {
    val error = biometricPromptResult.authenticationError
    // Process the error
}

// Other logic...