Dialogfeld für biometrische Authentifizierung anzeigen

Eine Methode zum Schutz vertraulicher Informationen oder Premiuminhalte innerhalb Ihrer Anwendung besteht darin, eine biometrische Authentifizierung anzufordern, z. B. die Gesichtserkennung oder die Fingerabdruckerkennung. In diesem Leitfaden wird erläutert, wie du biometrische Anmeldeabläufe in deiner App unterstützt.

Authentifizierungstypen angeben, die deine App unterstützt

Über die Schnittstelle BiometricManager.Authenticators können Sie die von Ihrer Anwendung unterstützten Authentifizierungstypen definieren. Im System können Sie die folgenden Authentifizierungstypen deklarieren:

BIOMETRIC_STRONG
Authentifizierung mit einem biometrischen Verfahren der Klasse 3, wie auf der Seite Definition der Android-Kompatibilität definiert.
BIOMETRIC_WEAK
Authentifizierung mit einem biometrischen Verfahren der Klasse 2, wie auf der Seite Definition der Android-Kompatibilität definiert.
DEVICE_CREDENTIAL
Authentifizierung mit Anmeldedaten für die Displaysperre – PIN, Muster oder Passwort des Nutzers

Um einen Authenticator verwenden zu können, muss der Nutzer eine PIN, ein Muster oder ein Passwort erstellen. Wenn der Nutzer noch keines hat, wird er im Rahmen des biometrischen Registrierungsvorgangs aufgefordert, eines zu erstellen.

Um die Arten der biometrischen Authentifizierung zu definieren, 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 biometrischen Klasse 3- oder Displaysperre-Anmeldedaten 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();

Die folgenden Kombinationen von Authenticator-Typen werden unter Android 10 (API-Level 29) und niedriger nicht unterstützt: DEVICE_CREDENTIAL und BIOMETRIC_STRONG | DEVICE_CREDENTIAL. Mit der Methode KeyguardManager.isDeviceSecure() kannst du prüfen, ob unter Android 10 und niedriger eine PIN, ein Muster oder ein Passwort vorhanden ist.

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. Dazu übergeben Sie 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. Gib im Intent-Extra die Gruppe von Authenticatoren an, die von deiner App akzeptiert werden. Dieser Intent fordert den Nutzer auf, Anmeldedaten für eine Authentifizierungs-App zu registrieren, die Ihre App akzeptiert.

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;
}

Authentifizierungsmethode des Nutzers ermitteln

Nach der Authentifizierung des Nutzers können Sie prüfen, ob er sich mit Geräte- oder biometrischen Anmeldedaten authentifiziert hat. Dazu rufen Sie getAuthenticationType() auf.

Anmeldeaufforderung anzeigen

Verwenden Sie die biometrische Bibliothek, um eine Systemaufforderung anzuzeigen, in der der Nutzer zur Authentifizierung mit biometrischen Anmeldedaten aufgefordert wird. Dieses vom System bereitgestellte Dialogfeld ist für alle Anwendungen, die es verwenden, einheitlich und sorgt so für eine vertrauenswürdigere Nutzererfahrung. In Abbildung 1 wird ein Beispieldialogfeld angezeigt.

Screenshot mit Dialogfeld
Abbildung 1: Systemdialogfeld zur Anforderung der biometrischen Authentifizierung.

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

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

  2. Rufen Sie das Dialogfeld in der Aktivität oder dem Fragment, das das Dialogfeld für die biometrische Anmeldung hostet, mit der im folgenden Code-Snippet gezeigten Logik auf:

    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);
    });
}

Kryptografische Lösung verwenden, die auf Authentifizierung angewiesen ist

Um vertrauliche Informationen in Ihrer Anwendung noch besser zu schützen, können Sie Kryptografie mithilfe einer Instanz von CryptoObject 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 mit einer biometrischen Aufforderung erfolgreich authentifiziert hat, kann Ihre App einen kryptografischen Vorgang ausführen. Wenn Sie sich beispielsweise mit einem Cipher-Objekt authentifizieren, kann Ihre Anwendung die Verschlüsselung und Entschlüsselung mithilfe eines SecretKey-Objekts vornehmen.

In den folgenden Abschnitten finden Sie Beispiele für die Verwendung eines Cipher- und eines SecretKey-Objekts zum Verschlüsseln von Daten. Bei 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 ausschließlich mit biometrischen Anmeldedaten

Falls Ihre Anwendung einen geheimen Schlüssel verwendet, für den zum Entsperren biometrische Anmeldedaten erforderlich sind, muss der Nutzer seine biometrischen Anmeldedaten jedes Mal authentifizieren, bevor die Anwendung auf den Schlüssel zugreift.

Wenn Sie vertrauliche Informationen 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 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 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. Verwenden Sie in Ihren Callbacks 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));
}

Mit biometrischen Anmeldedaten oder Anmeldedaten für den Sperrbildschirm authentifizieren

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

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 innerhalb eines Zeitraums von VALIDITY_DURATION_SECONDS nach der Authentifizierung des Nutzers die vertraulichen Informationen:

    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 Schlüssel für die Authentifizierung pro Nutzung innerhalb Ihrer BiometricPrompt-Instanz bereitstellen. Für einen solchen Schlüssel muss der Nutzer jedes Mal entweder biometrische Anmeldedaten oder Geräteanmeldedaten bereitstellen, wenn Ihre Anwendung auf Daten zugreifen muss, die durch diesen Schlüssel geschützt werden. Auth-Per-Use-Schlüssel können für Transaktionen mit hohem Wert nützlich sein, z. B. für eine hohe Zahlung oder das Aktualisieren der Gesundheitsdaten einer Person.

Um ein BiometricPrompt-Objekt mit einem Schlüssel für die Authentifizierung pro Nutzung zu verknüpfen, 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();

Ohne explizite Nutzeraktion authentifizieren

Standardmäßig müssen Nutzer eine bestimmte Aktion ausführen, z. B. eine Schaltfläche, nachdem ihre biometrischen Anmeldedaten akzeptiert wurden. Diese Konfiguration ist zu bevorzugen, wenn in Ihrer Anwendung das Dialogfeld zum Bestätigen einer sensiblen oder risikoreichen Aktion angezeigt wird, z. B. einem Kauf.

Wenn Ihre Anwendung jedoch ein Dialogfeld zur biometrischen Authentifizierung für eine Aktion mit geringerem Risiko anzeigt, können Sie dem System jedoch einen Hinweis darauf geben, dass der Nutzer die Authentifizierung nicht bestätigen muss. Dieser Hinweis kann dem Nutzer ermöglichen, Inhalte in Ihrer Anwendung nach der erneuten Authentifizierung mit einer passiven Modalität wie der Gesichtserkennung oder der Iris-basierten Erkennung schneller zu sehen. Für diesen Hinweis übergeben Sie false an die Methode setConfirmationRequired().

Abbildung 2 zeigt zwei Versionen desselben Dialogfelds. Bei der einen Version ist eine explizite Nutzeraktion erforderlich, bei der anderen nicht.

Screenshot des Dialogfelds Screenshot des Dialogfelds
Abbildung 2: Gesichtserkennung ohne Nutzerbestätigung (oben) und mit Nutzerbestätigung (unten).

Das folgende Code-Snippet zeigt, wie Sie ein Dialogfeld präsentieren, das keine explizite Nutzeraktion zum Abschluss der Authentifizierung 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 Sie möchten, dass Ihre App die Authentifizierung mithilfe biometrischer oder Geräteanmeldedaten zulässt, können Sie angeben, dass Ihre App Geräteanmeldedaten unterstützt. Dazu nehmen Sie DEVICE_CREDENTIAL in die Gruppe von Werten auf, die Sie an setAllowedAuthenticators() übergeben.

Wenn Ihre Anwendung derzeit createConfirmDeviceCredentialIntent() oder setDeviceCredentialAllowed() für diese Funktion verwendet, wechseln Sie zu setAllowedAuthenticators().

Weitere Informationen

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

Blogposts