Dialogfeld für biometrische Authentifizierung anzeigen

Eine Möglichkeit, vertrauliche Informationen oder Premiuminhalte in Ihrer App zu schützen, ist die biometrische Authentifizierung, z. B. mithilfe der Gesichts- oder Fingerabdruckerkennung. In diesem Leitfaden wird erläutert, wie Sie biometrische Anmeldeabläufe in Ihrer App unterstützen.

Im Allgemeinen sollten Sie den Credential Manager für die Erstanmeldung auf einem Gerät verwenden. Die anschließende Reaktivierung kann entweder über die biometrische Aufforderung oder den Anmeldedaten-Manager erfolgen. Der Vorteil der Verwendung von biometrischen Aufforderungen besteht darin, dass sie mehr Anpassungsoptionen bieten, während der Anmeldedaten-Manager eine einzige Implementierung für beide Abläufe bietet.

Hinweis: Die Biometriebibliothek erweitert die Funktionen der eingestellten FingerprintManager API.

Authentifizierungstypen für Ihre App angeben

Verwenden Sie die Schnittstelle BiometricManager.Authenticators, um die von Ihrer Anwendung unterstützten Authentifizierungstypen zu definieren. Das System bietet die Möglichkeit, die folgenden Authentifizierungstypen zu 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 beschrieben.

DEVICE_CREDENTIAL

Authentifizierung mit Anmeldedaten für die Displaysperre, also mit PIN, Muster oder Passwort des Nutzers

Bevor ein Nutzer einen Authentifikator verwenden kann, muss er eine PIN, ein Muster oder ein Passwort erstellen. Wenn der Nutzer noch keines hat, wird er während der biometrischen Registrierung aufgefordert, eines zu erstellen.

Wenn Sie die Arten der biometrischen Authentifizierung definieren möchten, die in Ihrer App zulässig sind, übergeben Sie einen Authentifizierungstyp oder eine binäre Kombination von Typen an die Methode setAllowedAuthenticators(). Im folgenden Code-Snippet wird gezeigt, wie die Authentifizierung mithilfe eines biometrischen Geräts der Klasse 3 oder eines Anmeldedatensatzes für die Bildschirmsperre 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 für eine BiometricPrompt.PromptInfo.Builder-Instanz aufrufen.

Die folgenden Kombinationen von Authentifizierungstypen werden unter Android 10 (API-Level 29) und niedriger nicht unterstützt: DEVICE_CREDENTIAL und BIOMETRIC_STRONG | DEVICE_CREDENTIAL. Wenn Sie unter Android 10 oder niedriger prüfen möchten, ob 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 gegebenenfalls die Intent-Aktion ACTION_BIOMETRIC_ENROLL auf. Geben Sie im Intent-Extra die Authenticator an, die von Ihrer App akzeptiert werden. Bei diesem Intent wird der Nutzer aufgefordert, Anmeldedaten für einen Authenticator 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;
}

Authentifizierung des Nutzers ermitteln

Nachdem sich der Nutzer authentifiziert hat, kannst du mit getAuthenticationType() prüfen, ob er sich mit Geräte- oder biometrischen Anmeldedaten authentifiziert hat.

Anmeldeaufforderung anzeigen

Wenn Sie eine Systemaufforderung anzeigen lassen möchten, in der der Nutzer aufgefordert wird, sich mit biometrischen Anmeldedaten zu authentifizieren, verwenden Sie die Biometriebibliothek. Dieser vom System bereitgestellte Dialog ist in allen Apps, in denen er verwendet wird, einheitlich. Das schafft Vertrauen bei den Nutzern. Abbildung 1 zeigt ein Beispiel für ein Dialogfeld.

Abbildung 1: Systemdialog, in dem eine biometrische Authentifizierung angefordert wird

So fügen Sie Ihrer App mithilfe der Biometriebibliothek eine biometrische Authentifizierung hinzu:

1. Füge in der Datei build.gradle deines App-Moduls eine Abhängigkeit für die Bibliothek androidx.biometric hinzu.

2. Zeigen Sie in der Aktivität oder dem Fragment, in dem sich das Dialogfeld für die biometrische Anmeldung befindet, das Dialogfeld mit der Logik aus dem folgenden Code-Snippet an:

   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 Daten in Ihrer App weiter zu schützen, können Sie mithilfe einer Instanz von CryptoObject Kryptografie in Ihren Workflow für die biometrische Authentifizierung einbinden. Das Framework unterstützt die folgenden kryptografischen Objekte: Signature, Cipher und Mac.

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

In den folgenden Abschnitten werden Beispiele für die Verwendung eines Cipher-Objekts und eines SecretKey-Objekts zum Verschlüsseln von Daten aufgeführt. 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);
}

Nur mit biometrischen Anmeldedaten authentifizieren

Wenn Ihre App einen geheimen Schlüssel verwendet, der zum Entsperren biometrische Anmeldedaten erfordert, muss sich der Nutzer jeweils mit seinen biometrischen Anmeldedaten authentifizieren, bevor Ihre App auf den Schlüssel zugreift.

Wenn Sie vertrauliche Daten erst verschlüsseln möchten, nachdem sich der Nutzer mit biometrischen Anmeldedaten authentifiziert hat, führen Sie die folgenden Schritte aus:

1. Generieren Sie einen Schlüssel, der die folgende KeyGenParameterSpec-Konfiguration verwendet:

   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 Workflow für die biometrische Authentifizierung, der eine 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. Verschlüsseln Sie in Ihren Rückrufen für die biometrische Authentifizierung die vertraulichen Daten mit dem geheimen Schlüssel:

   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 Daten oder Anmeldedaten für die Sperrbildschirmsperre

Sie können einen geheimen Schlüssel verwenden, der die Authentifizierung entweder mit biometrischen Anmeldedaten oder mit Anmeldedaten für den Sperrbildschirm (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 sich der Nutzer noch einmal authentifizieren muss.

Hinweis :Wenn Sie diese Art von Schlüssel verwenden möchten, müssen Sie einen Fallback auf nicht biometrische Anmeldedaten zulassen. Das bedeutet, dass Sie keine Instanz von CryptoObject an die authenticate()-Methode Ihres BiometricPrompt-Objekts übergeben können.

So verschlüsseln Sie vertrauliche Daten, nachdem sich der Nutzer mit biometrischen Anmeldedaten oder Anmeldedaten für den Sperrbildschirm authentifiziert hat:

1. Generieren Sie einen Schlüssel, der die folgende KeyGenParameterSpec-Konfiguration verwendet:

   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 von VALIDITY_DURATION_SECONDS Stunden nach der Nutzerauthentifizierung:

   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 Einmalschlüsseln authentifizieren

Sie können in Ihrer Instanz von BiometricPrompt Unterstützung für Schlüssel zur Authentifizierung bereitstellen. Bei einem 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 vorlegen. Authentifizierungsschlüssel zur einmaligen Verwendung 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 du ein BiometricPrompt-Objekt mit einem Authentifizierungsschlüssel für die einmalige Verwendung verknüpfen möchtest, füge Code ähnlich dem 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();

Ohne explizite Nutzeraktion authentifizieren

Standardmäßig müssen Nutzer eine bestimmte Aktion ausführen, z. B. eine Taste drücken, nachdem ihre biometrischen Anmeldedaten akzeptiert wurden. Diese Konfiguration ist vorzuziehen, wenn in Ihrer App das Dialogfeld zur Bestätigung einer sensiblen Aktion oder einer Aktion mit hohem Risiko angezeigt wird, z. B. ein Kauf.

Wenn Ihre App jedoch für eine Aktion mit geringerem Risiko ein Dialogfeld für die biometrische Authentifizierung anzeigt, können Sie dem System mitteilen, dass der Nutzer die Authentifizierung nicht bestätigen muss. So können Nutzer nach der erneuten Authentifizierung mit einer passiven Modalität wie der Gesichts- oder Iriserkennung schneller auf Inhalte in Ihrer App zugreifen. Um diesen Hinweis zu geben, übergeben Sie false an die Methode setConfirmationRequired().

Abbildung 2 zeigt zwei Versionen desselben Dialogfelds. Eine Version erfordert eine explizite Nutzeraktion, die andere Version nicht.

Achtung: Da dieses Flag als Hinweis an das System übergeben wird, wird der Wert möglicherweise ignoriert, 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 ein Dialogfeld eingeblendet wird, das keine explizite Nutzeraktion zum Abschließen des Authentifizierungsvorgangs erfordert:

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 Ihre App die Authentifizierung mit biometrischen oder Geräteanmeldedaten zulassen soll, können Sie erklären, dass Ihre App Anmeldedaten von Geräten unterstützt, indem Sie DEVICE_CREDENTIAL in den Satz von Werten aufnehmen, die Sie an setAllowedAuthenticators() übergeben.

Wenn in Ihrer App derzeit createConfirmDeviceCredentialIntent() oder setDeviceCredentialAllowed() für diese Funktion verwendet wird, wechseln Sie zu setAllowedAuthenticators().

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

Weitere Informationen

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

Blogposts

• Von FingerprintManager zu BiometricPrompt migrieren