Dialogfeld für biometrische Authentifizierung anzeigen

Eine Möglichkeit, vertrauliche Informationen oder Premium-Inhalte in Ihrer App zu schützen, besteht darin, eine biometrische Authentifizierung anzufordern, z. B. mithilfe der Gesichts- oder Fingerabdruckerkennung. In dieser Anleitung wird erläutert, wie Sie biometrische Anmeldeabläufe in Ihrer App unterstützen.

Im Allgemeinen sollten Sie Credential Manager für die Erstanmeldung auf einem Gerät verwenden. Die erneute Autorisierung kann entweder mit dem Biometric Prompt oder mit dem Credential Manager erfolgen. Der Vorteil der Verwendung von „Biometric Prompt“ besteht darin, dass es mehr Anpassungsoptionen bietet. „Credential Manager“ bietet dagegen eine einzige Implementierung für beide Abläufe.

Hinweis: Die Biometric Library bietet mehr Funktionen als die eingestellte FingerprintManager API.

Authentifizierungstypen deklarieren, die von Ihrer App unterstützt werden

Mit der Schnittstelle BiometricManager.Authenticators können Sie die von Ihrer App unterstützten Authentifizierungstypen definieren. Im System können Sie die folgenden Arten der Authentifizierung deklarieren:

BIOMETRIC_STRONG

Authentifizierung mit einem biometrischen Verfahren der Klasse 3, wie auf der Seite Android-Kompatibilitätsdefinition definiert.

BIOMETRIC_WEAK

Authentifizierung mit einem biometrischen Verfahren der Klasse 2, wie auf der Seite Android-Kompatibilitätsdefinition definiert.

DEVICE_CREDENTIAL

Authentifizierung mit Anmeldedaten für die Displaysperre – die PIN, das Muster oder das Passwort des Nutzers.

Bevor ein Nutzer einen Authenticator verwenden kann, muss er eine PIN, ein Muster oder ein Passwort erstellen. Wenn der Nutzer noch keine biometrische Authentifizierung eingerichtet hat, wird er im Registrierungsprozess dazu aufgefordert.

Wenn Sie die Arten der biometrischen Authentifizierung definieren möchten, die Ihre App akzeptiert, übergeben Sie einen Authentifizierungstyp oder eine bitweise Kombination von Typen an die Methode setAllowedAuthenticators(). Das folgende Code-Snippet zeigt, wie die Authentifizierung mit einem biometrischen Verfahren der Klasse 3 oder mit Anmeldedaten für die Displaysperre unterstützt wird.

Kotlin

// Lets the user authenticate using either a Class 3 biometric or
// their lock screen credential (PIN, pattern, or password).
promptInfo = BiometricPrompt.PromptInfo.Builder()
        .setTitle("Biometric login for my app")
        .setSubtitle("Log in using your biometric credential")
        .setAllowedAuthenticators(BIOMETRIC_STRONG or DEVICE_CREDENTIAL)
        .build()

Java

// Lets user authenticate using either a Class 3 biometric or
// their lock screen credential (PIN, pattern, or password).
promptInfo = new BiometricPrompt.PromptInfo.Builder()
        .setTitle("Biometric login for my app")
        .setSubtitle("Log in using your biometric credential")
        .setAllowedAuthenticators(BIOMETRIC_STRONG | DEVICE_CREDENTIAL)
        .build();

Hinweis :Sie können setNegativeButtonText() und setAllowedAuthenticators(... or DEVICE_CREDENTIAL) nicht gleichzeitig auf einer BiometricPrompt.PromptInfo.Builder-Instanz aufrufen.

Die folgenden Kombinationen von Authentifikatortypen werden unter Android 10 (API-Level 29) und niedriger nicht unterstützt: DEVICE_CREDENTIAL und BIOMETRIC_STRONG | DEVICE_CREDENTIAL. Wenn Sie prüfen möchten, ob auf einem Gerät mit Android 10 oder niedriger eine PIN, ein Muster oder ein Passwort vorhanden ist, verwenden Sie die Methode KeyguardManager.isDeviceSecure().

Prüfen, ob die biometrische Authentifizierung verfügbar ist

Nachdem Sie entschieden haben, welche Authentifizierungselemente Ihre App unterstützt, prüfen Sie, ob diese Elemente verfügbar sind. Übergeben Sie dazu dieselbe bitweise Kombination von Typen, die Sie mit der Methode setAllowedAuthenticators() deklariert haben, an die Methode canAuthenticate(). Rufen Sie bei Bedarf die Intent-Aktion ACTION_BIOMETRIC_ENROLL auf. Geben Sie im Intent-Extra die Gruppe der Authentifikatoren an, die Ihre App akzeptiert. Mit diesem Intent wird der Nutzer aufgefordert, Anmeldedaten für einen Authentifikator zu registrieren, der von Ihrer App akzeptiert wird.

Kotlin

val biometricManager = BiometricManager.from(this)
when (biometricManager.canAuthenticate(BIOMETRIC_STRONG or DEVICE_CREDENTIAL)) {
    BiometricManager.BIOMETRIC_SUCCESS ->
        Log.d("MY_APP_TAG", "App can authenticate using biometrics.")
    BiometricManager.BIOMETRIC_ERROR_NO_HARDWARE ->
        Log.e("MY_APP_TAG", "No biometric features available on this device.")
    BiometricManager.BIOMETRIC_ERROR_HW_UNAVAILABLE ->
        Log.e("MY_APP_TAG", "Biometric features are currently unavailable.")
    BiometricManager.BIOMETRIC_ERROR_NONE_ENROLLED -> {
        // Prompts the user to create credentials that your app accepts.
        val enrollIntent = Intent(Settings.ACTION_BIOMETRIC_ENROLL).apply {
            putExtra(Settings.EXTRA_BIOMETRIC_AUTHENTICATORS_ALLOWED,
                BIOMETRIC_STRONG or DEVICE_CREDENTIAL)
        }
        startActivityForResult(enrollIntent, REQUEST_CODE)
    }
}

Java

BiometricManager biometricManager = BiometricManager.from(this);
switch (biometricManager.canAuthenticate(BIOMETRIC_STRONG | DEVICE_CREDENTIAL)) {
    case BiometricManager.BIOMETRIC_SUCCESS:
        Log.d("MY_APP_TAG", "App can authenticate using biometrics.");
        break;
    case BiometricManager.BIOMETRIC_ERROR_NO_HARDWARE:
        Log.e("MY_APP_TAG", "No biometric features available on this device.");
        break;
    case BiometricManager.BIOMETRIC_ERROR_HW_UNAVAILABLE:
        Log.e("MY_APP_TAG", "Biometric features are currently unavailable.");
        break;
    case BiometricManager.BIOMETRIC_ERROR_NONE_ENROLLED:
        // Prompts the user to create credentials that your app accepts.
        final Intent enrollIntent = new Intent(Settings.ACTION_BIOMETRIC_ENROLL);
        enrollIntent.putExtra(Settings.EXTRA_BIOMETRIC_AUTHENTICATORS_ALLOWED,
                BIOMETRIC_STRONG | DEVICE_CREDENTIAL);
        startActivityForResult(enrollIntent, REQUEST_CODE);
        break;
}

Feststellen, wie sich der Nutzer authentifiziert hat

Nachdem sich der Nutzer authentifiziert hat, können Sie prüfen, ob er sich mit einer Geräteberechtigung oder einer biometrischen Berechtigung authentifiziert hat, indem Sie getAuthenticationType() aufrufen.

Anmeldeaufforderung anzeigen

Wenn Sie einen System-Prompt anzeigen möchten, in dem der Nutzer aufgefordert wird, sich mit biometrischen Anmeldedaten zu authentifizieren, verwenden Sie die Biometric Library. Dieses vom System bereitgestellte Dialogfeld ist in allen Apps, die es verwenden, einheitlich und sorgt so für eine vertrauenswürdigere Nutzererfahrung. Ein Beispiel für ein Dialogfeld ist in Abbildung 1 zu sehen.

Abbildung 1: Systemdialogfeld, in dem die biometrische Authentifizierung angefordert wird.

So fügen Sie Ihrer App biometrische Authentifizierung mithilfe der Biometric-Bibliothek hinzu:

1. Fügen Sie in der build.gradle-Datei Ihres App-Moduls eine Abhängigkeit von der androidx.biometric-Bibliothek hinzu.

2. Zeigen Sie in der Aktivität oder dem Fragment, in dem das biometrische Anmeldedialogfeld gehostet wird, das Dialogfeld mit der Logik an, die im folgenden Code-Snippet gezeigt wird:

   Kotlin

   private lateinit var executor: Executor
   private lateinit var biometricPrompt: BiometricPrompt
   private lateinit var promptInfo: BiometricPrompt.PromptInfo
   
   override fun onCreate(savedInstanceState: Bundle?) {
       super.onCreate(savedInstanceState)
       setContentView(R.layout.activity_login)
       executor = ContextCompat.getMainExecutor(this)
       biometricPrompt = BiometricPrompt(this, executor,
               object : BiometricPrompt.AuthenticationCallback() {
           override fun onAuthenticationError(errorCode: Int,
                   errString: CharSequence) {
               super.onAuthenticationError(errorCode, errString)
               Toast.makeText(applicationContext,
                   "Authentication error: $errString", Toast.LENGTH_SHORT)
                   .show()
           }
   
           override fun onAuthenticationSucceeded(
                   result: BiometricPrompt.AuthenticationResult) {
               super.onAuthenticationSucceeded(result)
               Toast.makeText(applicationContext,
                   "Authentication succeeded!", Toast.LENGTH_SHORT)
                   .show()
           }
   
           override fun onAuthenticationFailed() {
               super.onAuthenticationFailed()
               Toast.makeText(applicationContext, "Authentication failed",
                   Toast.LENGTH_SHORT)
                   .show()
           }
       })
   
       promptInfo = BiometricPrompt.PromptInfo.Builder()
               .setTitle("Biometric login for my app")
               .setSubtitle("Log in using your biometric credential")
               .setNegativeButtonText("Use account password")
               .build()
   
       // Prompt appears when user clicks "Log in".
       // Consider integrating with the keystore to unlock cryptographic operations,
       // if needed by your app.
       val biometricLoginButton =
               findViewById<Button>(R.id.biometric_login)
       biometricLoginButton.setOnClickListener {
           biometricPrompt.authenticate(promptInfo)
       }
   }

   Java

   private Executor executor;
   private BiometricPrompt biometricPrompt;
   private BiometricPrompt.PromptInfo promptInfo;
   
   @Override
   protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.activity_login);
       executor = ContextCompat.getMainExecutor(this);
       biometricPrompt = new BiometricPrompt(MainActivity.this,
               executor, new BiometricPrompt.AuthenticationCallback() {
           @Override
           public void onAuthenticationError(int errorCode,
                   @NonNull CharSequence errString) {
               super.onAuthenticationError(errorCode, errString);
               Toast.makeText(getApplicationContext(),
                   "Authentication error: " + errString, Toast.LENGTH_SHORT)
                   .show();
           }
   
           @Override
           public void onAuthenticationSucceeded(
                   @NonNull BiometricPrompt.AuthenticationResult result) {
               super.onAuthenticationSucceeded(result);
               Toast.makeText(getApplicationContext(),
                   "Authentication succeeded!", Toast.LENGTH_SHORT).show();
           }
   
           @Override
           public void onAuthenticationFailed() {
               super.onAuthenticationFailed();
               Toast.makeText(getApplicationContext(), "Authentication failed",
                   Toast.LENGTH_SHORT)
                   .show();
           }
       });
   
       promptInfo = new BiometricPrompt.PromptInfo.Builder()
               .setTitle("Biometric login for my app")
               .setSubtitle("Log in using your biometric credential")
               .setNegativeButtonText("Use account password")
               .build();
   
       // Prompt appears when user clicks "Log in".
       // Consider integrating with the keystore to unlock cryptographic operations,
       // if needed by your app.
       Button biometricLoginButton = findViewById(R.id.biometric_login);
       biometricLoginButton.setOnClickListener(view -> {
               biometricPrompt.authenticate(promptInfo);
       });
   }

Eine kryptografische Lösung verwenden, die von der Authentifizierung abhängt

Um sensible Informationen in Ihrer App zusätzlich zu schützen, können Sie in Ihren biometrischen Authentifizierungs-Workflow eine Verschlüsselung mit einer Instanz von CryptoObject einbauen. Das Framework unterstützt die folgenden kryptografischen Objekte: Signature, Cipher und Mac.

Nachdem sich der Nutzer über eine biometrische Aufforderung erfolgreich authentifiziert hat, kann Ihre App eine kryptografische Operation ausführen. Wenn Sie sich beispielsweise mit einem Cipher-Objekt authentifizieren, kann Ihre App die Ver- und Entschlüsselung mit einem SecretKey-Objekt durchführen.

In den folgenden Abschnitten werden Beispiele für die Verwendung eines Cipher-Objekts und eines SecretKey-Objekts zum Verschlüsseln von Daten beschrieben. In jedem Beispiel werden die folgenden Methoden verwendet:

Kotlin

private fun generateSecretKey(keyGenParameterSpec: KeyGenParameterSpec) {
    val keyGenerator = KeyGenerator.getInstance(
            KeyProperties.KEY_ALGORITHM_AES, "AndroidKeyStore")
    keyGenerator.init(keyGenParameterSpec)
    keyGenerator.generateKey()
}

private fun getSecretKey(): SecretKey {
    val keyStore = KeyStore.getInstance("AndroidKeyStore")

    // Before the keystore can be accessed, it must be loaded.
    keyStore.load(null)
    return keyStore.getKey(KEY_NAME, null) as SecretKey
}

private fun getCipher(): Cipher {
    return Cipher.getInstance(KeyProperties.KEY_ALGORITHM_AES + "/"
            + KeyProperties.BLOCK_MODE_CBC + "/"
            + KeyProperties.ENCRYPTION_PADDING_PKCS7)
}

Java

private void generateSecretKey(KeyGenParameterSpec keyGenParameterSpec) {
    KeyGenerator keyGenerator = KeyGenerator.getInstance(
            KeyProperties.KEY_ALGORITHM_AES, "AndroidKeyStore");
    keyGenerator.init(keyGenParameterSpec);
    keyGenerator.generateKey();
}

private SecretKey getSecretKey() {
    KeyStore keyStore = KeyStore.getInstance("AndroidKeyStore");

    // Before the keystore can be accessed, it must be loaded.
    keyStore.load(null);
    return ((SecretKey)keyStore.getKey(KEY_NAME, null));
}

private Cipher getCipher() {
    return Cipher.getInstance(KeyProperties.KEY_ALGORITHM_AES + "/"
            + KeyProperties.BLOCK_MODE_CBC + "/"
            + KeyProperties.ENCRYPTION_PADDING_PKCS7);
}

Authentifizierung nur mit biometrischen Anmeldedaten

Wenn Ihre App einen geheimen Schlüssel verwendet, für den biometrische Anmeldedaten zum Entsperren erforderlich sind, muss der Nutzer seine biometrischen Anmeldedaten jedes Mal authentifizieren, bevor Ihre App auf den Schlüssel zugreifen kann.

So verschlüsseln Sie vertrauliche Informationen erst, nachdem sich der Nutzer mit biometrischen Anmeldedaten authentifiziert hat:

1. Generieren Sie einen Schlüssel mit der folgenden KeyGenParameterSpec-Konfiguration:

   Kotlin

   generateSecretKey(KeyGenParameterSpec.Builder(
           KEY_NAME,
           KeyProperties.PURPOSE_ENCRYPT or KeyProperties.PURPOSE_DECRYPT)
           .setBlockModes(KeyProperties.BLOCK_MODE_CBC)
           .setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_PKCS7)
           .setUserAuthenticationRequired(true)
           // Invalidate the keys if the user has registered a new biometric
           // credential, such as a new fingerprint. Can call this method only
           // on Android 7.0 (API level 24) or higher. The variable
           // "invalidatedByBiometricEnrollment" is true by default.
           .setInvalidatedByBiometricEnrollment(true)
           .build())

   Java

   generateSecretKey(new KeyGenParameterSpec.Builder(
           KEY_NAME,
           KeyProperties.PURPOSE_ENCRYPT | KeyProperties.PURPOSE_DECRYPT)
           .setBlockModes(KeyProperties.BLOCK_MODE_CBC)
           .setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_PKCS7)
           .setUserAuthenticationRequired(true)
           // Invalidate the keys if the user has registered a new biometric
           // credential, such as a new fingerprint. Can call this method only
           // on Android 7.0 (API level 24) or higher. The variable
           // "invalidatedByBiometricEnrollment" is true by default.
           .setInvalidatedByBiometricEnrollment(true)
           .build());

2. Starten Sie einen biometrischen Authentifizierungs-Workflow, der einen Chiffre enthält:

   Kotlin

   biometricLoginButton.setOnClickListener {
       // Exceptions are unhandled within this snippet.
       val cipher = getCipher()
       val secretKey = getSecretKey()
       cipher.init(Cipher.ENCRYPT_MODE, secretKey)
       biometricPrompt.authenticate(promptInfo,
               BiometricPrompt.CryptoObject(cipher))
   }

   Java

   biometricLoginButton.setOnClickListener(view -> {
       // Exceptions are unhandled within this snippet.
       Cipher cipher = getCipher();
       SecretKey secretKey = getSecretKey();
       cipher.init(Cipher.ENCRYPT_MODE, secretKey);
       biometricPrompt.authenticate(promptInfo,
               new BiometricPrompt.CryptoObject(cipher));
   });

3. Verwenden Sie in Ihren Rückrufen für die biometrische Authentifizierung den geheimen Schlüssel, um die vertraulichen Informationen zu verschlüsseln:

   Kotlin

   override fun onAuthenticationSucceeded(
           result: BiometricPrompt.AuthenticationResult) {
       val encryptedInfo: ByteArray = result.cryptoObject.cipher?.doFinal(
           // plaintext-string text is whatever data the developer would like
           // to encrypt. It happens to be plain-text in this example, but it
           // can be anything
               plaintext-string.toByteArray(Charset.defaultCharset())
       )
       Log.d("MY_APP_TAG", "Encrypted information: " +
               Arrays.toString(encryptedInfo))
   }

   Java

   @Override
   public void onAuthenticationSucceeded(
           @NonNull BiometricPrompt.AuthenticationResult result) {
       // NullPointerException is unhandled; use Objects.requireNonNull().
       byte[] encryptedInfo = result.getCryptoObject().getCipher().doFinal(
           // plaintext-string text is whatever data the developer would like
           // to encrypt. It happens to be plain-text in this example, but it
           // can be anything
               plaintext-string.getBytes(Charset.defaultCharset()));
       Log.d("MY_APP_TAG", "Encrypted information: " +
               Arrays.toString(encryptedInfo));
   }

Authentifizierung mit biometrischen Anmeldedaten oder Anmeldedaten für die Displaysperre

Sie können einen geheimen Schlüssel verwenden, der die Authentifizierung mit biometrischen Anmeldedaten oder Anmeldedaten für die Displaysperre (PIN, Muster oder Passwort) ermöglicht. Geben Sie beim Konfigurieren dieses Schlüssels einen Gültigkeitszeitraum an. Während dieses Zeitraums kann Ihre App mehrere kryptografische Vorgänge ausführen, ohne dass der Nutzer sich noch einmal authentifizieren muss.

Hinweis :Wenn Sie diesen Schlüsseltyp verwenden möchten, müssen Sie die Verwendung nicht biometrischer Anmeldedaten als Fallback zulassen. Das bedeutet, dass Sie keine Instanz von CryptoObject an die Methode authenticate() Ihres BiometricPrompt-Objekts übergeben können.

Führen Sie die folgenden Schritte aus, um vertrauliche Informationen zu verschlüsseln, nachdem sich der Nutzer mit biometrischen Anmeldedaten oder Anmeldedaten für den Sperrbildschirm authentifiziert hat:

1. Generieren Sie einen Schlüssel mit der folgenden KeyGenParameterSpec-Konfiguration:

   Kotlin

   generateSecretKey(KeyGenParameterSpec.Builder(
       KEY_NAME,
       KeyProperties.PURPOSE_ENCRYPT or KeyProperties.PURPOSE_DECRYPT)
       .setBlockModes(KeyProperties.BLOCK_MODE_CBC)
       .setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_PKCS7)
       .setUserAuthenticationRequired(true)
       .setUserAuthenticationParameters(VALIDITY_DURATION_SECONDS,
               ALLOWED_AUTHENTICATORS)
       .build())

   Java

   generateSecretKey(new KeyGenParameterSpec.Builder(
       KEY_NAME,
       KeyProperties.PURPOSE_ENCRYPT | KeyProperties.PURPOSE_DECRYPT)
       .setBlockModes(KeyProperties.BLOCK_MODE_CBC)
       .setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_PKCS7)
       .setUserAuthenticationRequired(true)
       .setUserAuthenticationParameters(VALIDITY_DURATION_SECONDS,
               ALLOWED_AUTHENTICATORS)
       .build());

2. Verschlüsseln Sie die vertraulichen Informationen innerhalb eines Zeitraums von VALIDITY_DURATION_SECONDS nach der Authentifizierung des Nutzers:

   Kotlin

   private fun encryptSecretInformation() {
       // Exceptions are unhandled for getCipher() and getSecretKey().
       val cipher = getCipher()
       val secretKey = getSecretKey()
       try {
           cipher.init(Cipher.ENCRYPT_MODE, secretKey)
           val encryptedInfo: ByteArray = cipher.doFinal(
               // plaintext-string text is whatever data the developer would
               // like to encrypt. It happens to be plain-text in this example,
               // but it can be anything
                   plaintext-string.toByteArray(Charset.defaultCharset()))
           Log.d("MY_APP_TAG", "Encrypted information: " +
                   Arrays.toString(encryptedInfo))
       } catch (e: InvalidKeyException) {
           Log.e("MY_APP_TAG", "Key is invalid.")
       } catch (e: UserNotAuthenticatedException) {
           Log.d("MY_APP_TAG", "The key's validity timed out.")
           biometricPrompt.authenticate(promptInfo)
       }

   Java

   private void encryptSecretInformation() {
       // Exceptions are unhandled for getCipher() and getSecretKey().
       Cipher cipher = getCipher();
       SecretKey secretKey = getSecretKey();
       try {
           // NullPointerException is unhandled; use Objects.requireNonNull().
           ciper.init(Cipher.ENCRYPT_MODE, secretKey);
           byte[] encryptedInfo = cipher.doFinal(
               // plaintext-string text is whatever data the developer would
               // like to encrypt. It happens to be plain-text in this example,
               // but it can be anything
                   plaintext-string.getBytes(Charset.defaultCharset()));
       } catch (InvalidKeyException e) {
           Log.e("MY_APP_TAG", "Key is invalid.");
       } catch (UserNotAuthenticatedException e) {
           Log.d("MY_APP_TAG", "The key's validity timed out.");
           biometricPrompt.authenticate(promptInfo);
       }
   }

Mit Auth-per-Use-Schlüsseln authentifizieren

Sie können die Unterstützung für Auth-per-Use-Schlüssel in Ihrer Instanz von BiometricPrompt bereitstellen. Für einen solchen Schlüssel muss der Nutzer jedes Mal, wenn Ihre App auf Daten zugreifen muss, die durch diesen Schlüssel geschützt sind, entweder biometrische Anmeldedaten oder Geräteanmeldedaten angeben. Schlüssel für die einmalige Authentifizierung können für Transaktionen mit hohem Wert nützlich sein, z. B. für eine große Zahlung oder die Aktualisierung der Gesundheitsdaten einer Person.

Wenn Sie ein BiometricPrompt-Objekt mit einem Auth-per-Use-Schlüssel verknüpfen möchten, fügen Sie Code wie den folgenden hinzu:

Kotlin

val authPerOpKeyGenParameterSpec =
        KeyGenParameterSpec.Builder("myKeystoreAlias", key-purpose)
    // Accept either a biometric credential or a device credential.
    // To accept only one type of credential, include only that type as the
    // second argument.
    .setUserAuthenticationParameters(0 /* duration */,
            KeyProperties.AUTH_BIOMETRIC_STRONG or
            KeyProperties.AUTH_DEVICE_CREDENTIAL)
    .build()

Java

KeyGenParameterSpec authPerOpKeyGenParameterSpec =
        new KeyGenParameterSpec.Builder("myKeystoreAlias", key-purpose)
    // Accept either a biometric credential or a device credential.
    // To accept only one type of credential, include only that type as the
    // second argument.
    .setUserAuthenticationParameters(0 /* duration */,
            KeyProperties.AUTH_BIOMETRIC_STRONG |
            KeyProperties.AUTH_DEVICE_CREDENTIAL)
    .build();

Authentifizierung ohne explizite Nutzeraktion

Standardmäßig müssen Nutzer nach der Akzeptanz ihrer biometrischen Anmeldedaten eine bestimmte Aktion ausführen, z. B. eine Schaltfläche drücken. Diese Konfiguration ist vorzuziehen, wenn in Ihrer App das Dialogfeld zur Bestätigung einer sensiblen oder risikoreichen Aktion wie eines Kaufs angezeigt wird.

Wenn in Ihrer App ein biometrisches Authentifizierungsdialogfeld für eine Aktion mit geringerem Risiko angezeigt wird, können Sie dem System einen Hinweis geben, dass der Nutzer die Authentifizierung nicht bestätigen muss. Mit diesem Hinweis kann der Nutzer Inhalte in Ihrer App schneller aufrufen, nachdem er sich mit einer passiven Methode wie der Gesichts- oder Iriserkennung neu authentifiziert hat. Um diesen Hinweis zu geben, übergeben Sie false an die Methode setConfirmationRequired().

Abbildung 2 zeigt zwei Versionen desselben Dialogfelds. Für eine Version ist eine explizite Nutzeraktion erforderlich, für die andere nicht.

Achtung :Da dieses Flag als Hinweis an das System übergeben wird, kann das System den Wert ignorieren, wenn der Nutzer seine Systemeinstellungen für die biometrische Authentifizierung geändert hat.

Abbildung 2: Gesichtserkennung ohne Nutzerbestätigung (oben) und mit Nutzerbestätigung (unten)

Das folgende Code-Snippet zeigt, wie Sie einen Dialog präsentieren, für den keine explizite Nutzeraktion erforderlich ist, um den Authentifizierungsprozess abzuschließen:

Kotlin

// Lets the user authenticate without performing an action, such as pressing a
// button, after their biometric credential is accepted.
promptInfo = BiometricPrompt.PromptInfo.Builder()
        .setTitle("Biometric login for my app")
        .setSubtitle("Log in using your biometric credential")
        .setNegativeButtonText("Use account password")
        .setConfirmationRequired(false)
        .build()

Java

// Lets the user authenticate without performing an action, such as pressing a
// button, after their biometric credential is accepted.
promptInfo = new BiometricPrompt.PromptInfo.Builder()
        .setTitle("Biometric login for my app")
        .setSubtitle("Log in using your biometric credential")
        .setNegativeButtonText("Use account password")
        .setConfirmationRequired(false)
        .build();

Fallback auf nicht biometrische Anmeldedaten zulassen

Wenn Sie möchten, dass Ihre App die Authentifizierung mit biometrischen Daten oder Geräteanmeldedaten zulässt, können Sie deklarieren, dass Ihre App Geräteanmeldedaten unterstützt, indem Sie DEVICE_CREDENTIAL in den Satz von Werten aufnehmen, die Sie an setAllowedAuthenticators() übergeben.

Wenn Ihre App derzeit createConfirmDeviceCredentialIntent() oder setDeviceCredentialAllowed() verwendet, um diese Funktion bereitzustellen, wechseln Sie zu setAllowedAuthenticators().

Achtung :Sie können DEVICE_CREDENTIAL nicht an setAllowedAuthenticators() übergeben und setNegativeButtonText() für dieselbe Instanz von BiometricPrompt aufrufen.

Zusätzliche Ressourcen

Weitere Informationen zur biometrischen Authentifizierung unter Android finden Sie in den folgenden Ressourcen.

Blogposts

• Von FingerprintManager zu BiometricPrompt migrieren