Comment vérifier la préférence bio-métrique de l'utilisateur via une API biométrique?

Il n'y a aucun moyen de connaître ce type d'informations pour le moment, un numéro avait été ouvert l'année dernière pour les demander ( https://issuetracker.google.com/issues/111315641 ). Alors qu'Android tentait de simplifier le chemin pour que les développeurs implémentent l'authentification dans leurs applications, il y a un manque d'options dans l'implémentation BiometricPrompt (voir le document Android pour l'implémentation BiometricPrompt).

Dans votre cas, vous pouvez simplement changer votre chaîne de titre en "Authentification biométrique", et ainsi avec les autres chaînes. Pour un exemple, voir les articles de blog mentionnés ci-dessous.

Votre code peut ressembler à ceci. Mais je vous recommande également d'utiliser le strings.xml ressources strings.xml au lieu de coder en dur vos chaînes dans le code. Par exemple, à l'avenir, vous voudrez peut-être des services de traduction.

biometricPrompt = new BiometricPrompt.Builder(context)
        .setTitle("Biometric Authentication")
        .setSubtitle("Login via biometrics")
        .setDescription("Use the Biometrics Sensor")
        .setNegativeButton("Cancel", context.getMainExecutor(),
                new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialogInterface, int i) {
                        Log.d(TAG,"Cancelled");
                    }
                })
        .build();

Plus généralement, les implications en matière de confidentialité doivent être évaluées avant que l'équipe API ne décide si les développeurs doivent connaître les préférences biométriques d'un utilisateur. On ne sait vraiment pas pourquoi un développeur devrait avoir besoin de ces informations. Deux articles de blog ont été publiés sur le sujet de la biométrie Strong vs Weak et comment les mettre en œuvre ( blog un , blog deux ). Au-delà de cette distinction (c'est-à-dire fort vs faible), les facteurs de forme qu'un utilisateur préfère ou finit par utiliser ne semblent pas pertinents.

Dans Android R a été ajouté une méthode appelée setAllowedAuthenticators

public BiometricPrompt.Builder setAllowedAuthenticators (int authenticators)

Facultatif: spécifie le ou les types d'authentificateurs pouvant être appelés par BiometricPrompt pour authentifier l'utilisateur. Les types d'authentificateur disponibles sont définis dans Authenticators et peuvent être combinés via OU au niveau du bit. Par défaut:

• Authenticators # BIOMETRIC_WEAK pour l'authentification non cryptographique, ou
• Authenticators # BIOMETRIC_STRONG pour l'authentification cryptée.

Si cette méthode est utilisée et qu'aucun authentificateur de l'un des types spécifiés n'est disponible au moment où BiometricPrompt # authenticate (...) est appelé, l'authentification sera annulée et AuthenticationCallback # onAuthenticationError (int, CharSequence) sera invoqué avec une erreur appropriée code.

Cette méthode doit être préférée à setDeviceCredentialAllowed (boolean) et remplace cette dernière si les deux sont utilisés. L'utilisation de cette méthode pour activer l'authentification des informations d'identification de l'appareil (avec Authenticators # DEVICE_CREDENTIAL) remplacera le bouton négatif de l'invite, ce qui entraînera une erreur d'appeler également setNegativeButton (java.lang.CharSequence, java.util.concurrent.Executor, android.content. DialogInterface.OnClickListener).

authentificateurs

Un champ de bits représentant tous les types d'authentificateur valides qui peuvent être appelés par l'invite. La valeur est 0 ou une combinaison de BiometricManager.Authenticators.BIOMETRIC_STRONG, BiometricManager.Authenticators.BIOMETRIC_WEAK et BiometricManager.Authenticators.DEVICE_CREDENTIAL

Bien que ce ne soit pas une solution parfaite, vous pouvez utiliser l'API PackageManager pour déterminer si un appareil dispose du matériel d'authentification, par exemple:

class BiometricAuthenticator
{
 public enum BiometricType
 {
  FINGERPRINT,
  FACE, 
  IRIS,
  NONE
 }

 public static boolean hasBiometricAuthenticator(Context context)
 {
    int biometry = BiometricManager.BIOMETRIC_ERROR_UNSUPPORTED;
    if (VERSION.SDK_INT >= 30)
        biometry = BiometricManager.from(context).canAuthenticate(Authenticators.BIOMETRIC_STRONG | Authenticators.BIOMETRIC_WEAK);
    else
        biometry = BiometricManager.from(context).canAuthenticate();

    switch (biometry)
    {
        case BiometricManager.BIOMETRIC_ERROR_HW_UNAVAILABLE:
        case BiometricManager.BIOMETRIC_ERROR_NONE_ENROLLED:
        case BiometricManager.BIOMETRIC_ERROR_NO_HARDWARE:
             return (false);
        case BiometricManager.BIOMETRIC_SUCCESS:
             return true;
    }
    return (false);
 }

 /**
  * biometricType()
  *
  * returns type of biometry supported
  */
 public static BiometricType biometricType(Context context)
 {
    if (VERSION.SDK_INT < 23)
        return BiometricType.NONE;

    PackageManager packageManager = context.getPackageManager();

    // SDK 29 adds FACE and IRIS authentication
    if (VERSION.SDK_INT >= 29)
    {
        if (packageManager.hasSystemFeature(PackageManager.FEATURE_FACE))
            return BiometricType.FACE;
        if (packageManager.hasSystemFeature(PackageManager.FEATURE_IRIS))
            return BiometricType.IRIS;
        if (packageManager.hasSystemFeature(PackageManager.FEATURE_FINGERPRINT))
            return BiometricType.FINGERPRINT;
        return BiometricType.NONE;
    }

    // SDK 23-28 offer FINGERPRINT only
    return (packageManager.hasSystemFeature(PackageManager.FEATURE_FINGERPRINT) ? BiometricType.FINGERPRINT : BiometricType.NONE);
 }
}

J'ai créé une classe d'assistance comme suit:

if (context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_FACE))
{
}

Cela vous permet de déterminer si un authentificateur biométrique est présent ( hasBiometricAuthenticator ) et, le cas échéant, de renvoyer le type d'authentificateur sous forme d'énumération BiometricType .

Un appareil pourrait théoriquement avoir plusieurs authentifiants, et biometricType() renverra FACE, IRIS, puis FINGERPRINT dans cet ordre de préférence sur les appareils API30 +.

Espérons que Google exposera une meilleure API à l'avenir, mais ces astuces aideront au moins à obtenir les invites appropriées dans la boîte de dialogue