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. per Gesichts- oder Fingerabdruckerkennung. In dieser Anleitung wird erläutert, wie Sie biometrische Anmeldeabläufe in Ihrer App unterstützen.

In der Regel sollten Sie Credential Manager für die erste Anmeldung auf einem Gerät verwenden. Nachfolgende erneute Autorisierungen können entweder mit Biometric Prompt oder Credential Manager erfolgen. Der Vorteil von Biometric Prompt besteht darin, dass es mehr Anpassungsoptionen bietet, während Credential Manager eine einheitliche Implementierung für beide Abläufe bietet.

Die von Ihrer App unterstützten Authentifizierungstypen deklarieren

Verwenden Sie die BiometricManager.Authenticators Schnittstelle, um die von Ihrer App unterstützten Authentifizierungstypen zu definieren. Das System ermöglicht es Ihnen, die folgenden Authentifizierungstypen zu deklarieren:

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

Um einen Authentifikator verwenden zu können, muss der Nutzer eine PIN, ein Muster oder ein Passwort erstellen. Wenn der Nutzer noch keine PIN, kein Muster oder kein Passwort hat, wird er im biometrischen Registrierungsablauf aufgefordert, eines zu erstellen.

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 setAllowedAuthenticators() Methode. Das folgende Code-Snippet zeigt, wie die Authentifizierung mit einem biometrischen Verfahren der Klasse 3 oder 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();

Die folgenden Kombinationen von Authentifikatortypen werden unter Android 10 (API-Level 29) und niedriger nicht unterstützt: DEVICE_CREDENTIAL und BIOMETRIC_STRONG | DEVICE_CREDENTIAL. Verwenden Sie die KeyguardManager.isDeviceSecure() Methode, um unter Android 10 und niedriger nach einer PIN, einem Muster oder einem Passwort zu suchen.

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 canAuthenticate() Methode. Rufen Sie bei Bedarf die ACTION_BIOMETRIC_ENROLL Intent Aktion auf. Geben Sie im Intent-Extra die Authentifikatoren an, die Ihre App akzeptiert. Mit diesem Intent wird der Nutzer aufgefordert, Anmeldedaten für einen Authentifikator zu registrieren, den 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;
}

Ermitteln, wie sich der Nutzer authentifiziert hat

Nachdem sich der Nutzer authentifiziert hat, können Sie mit `getAuthenticationType()` prüfen, ob er sich mit Anmeldedaten für das Gerät oder biometrischen Anmeldedaten authentifiziert hat. getAuthenticationType()

Verwenden Sie die Biometric Library, um eine Systemaufforderung anzuzeigen, in der der Nutzer aufgefordert wird, sich mit biometrischen Anmeldedaten zu authentifizieren. Dieser vom System bereitgestellte Dialog ist in allen Apps einheitlich, die ihn verwenden, was zu einer vertrauenswürdigeren Nutzererfahrung führt. Ein Beispiel für einen solchen Dialog sehen Sie in Abbildung 1.

Abbildung 1 Systemdialog, in dem die biometrische Authentifizierung angefordert wird.

So fügen Sie Ihrer App mit der Biometric Library die biometrische Authentifizierung hinzu:

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

Zeigen Sie in der Aktivität oder dem Fragment, in dem sich der Dialog für die biometrische Anmeldung befindet, den Dialog mit der im folgenden Code-Snippet gezeigten Logik 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 vertrauliche Informationen in Ihrer App zusätzlich zu schützen, können Sie Kryptografie in Ihren biometrischen Authentifizierungsablauf einbinden, indem Sie eine Instanz von CryptoObjectverwenden. 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 eine kryptografische Operation ausführen. Wenn Sie sich beispielsweise mit einem Cipher Objekt authentifizieren, kann Ihre App dann mit einem SecretKey Objekt verschlüsseln und entschlüsseln.

In den folgenden Abschnitten finden Sie Beispiele für die Verwendung eines Cipher-Objekts und eines SecretKey-Objekts zum Verschlüsseln von Daten. 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 dessen Entsperrung biometrische Anmeldedaten 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:

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

Starten Sie einen biometrischen Authentifizierungsablauf, der eine Verschlüsselung 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));
});

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 Daten oder Anmeldedaten für den Sperrbildschirm

Sie können einen geheimen Schlüssel verwenden, der die Authentifizierung mit biometrischen Anmeldedaten oder 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 Operationen ausführen, ohne dass sich der Nutzer erneut authentifizieren muss.

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

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

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

Authentifizierung mit Schlüsseln für die einmalige Verwendung

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

Fügen Sie Code ähnlich dem folgenden hinzu, um ein BiometricPrompt-Objekt einem Schlüssel für die einmalige Verwendung zuzuordnen:

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 eine bestimmte Aktion ausführen, z. B. eine Schaltfläche drücken, nachdem ihre biometrischen Anmeldedaten akzeptiert wurden. Diese Konfiguration ist vorzuziehen, wenn Ihre App den Dialog anzeigt, um eine vertrauliche oder risikoreiche Aktion zu bestätigen, z. B. einen Kauf.

Wenn Ihre App jedoch einen Dialog zur biometrischen Authentifizierung für eine weniger risikoreiche Aktion anzeigt, können Sie dem System einen Hinweis geben, dass der Nutzer die Authentifizierung nicht bestätigen muss. Dieser Hinweis kann es dem Nutzer ermöglichen, Inhalte in Ihrer App schneller anzusehen, nachdem er sich mit einer passiven Methode wie der Gesichts- oder Iriserkennung erneut authentifiziert hat. Übergeben Sie false an die setConfirmationRequired() Methode, um diesen Hinweis zu geben.

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

Abbildung 2. Gesichtsauthentifizierung 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 Ihre App die Authentifizierung mit biometrischen Anmeldedaten oder Anmeldedaten für das Gerät zulassen soll, können Sie deklarieren, dass Ihre App Anmeldedaten für das Gerät unterstützt, indem Sie DEVICE_CREDENTIAL in die Menge der Werte aufnehmen, die Sie an setAllowedAuthenticators() übergeben.

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

Zusätzliche Ressourcen

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

Blog posts

Von FingerprintManager zu BiometricPrompt migrieren

Dialogfeld für biometrische Authentifizierung anzeigen Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Die von Ihrer App unterstützten Authentifizierungstypen deklarieren

Kotlin

Java

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

Kotlin

Java

Ermitteln, wie sich der Nutzer authentifiziert hat

Anmeldeaufforderung anzeigen

Kotlin

Java

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

Kotlin

Java

Authentifizierung nur mit biometrischen Anmeldedaten

Kotlin

Java

Kotlin

Java

Kotlin

Java

Authentifizierung mit biometrischen Daten oder Anmeldedaten für den Sperrbildschirm

Kotlin

Java

Kotlin

Java

Authentifizierung mit Schlüsseln für die einmalige Verwendung

Kotlin

Java

Authentifizierung ohne explizite Nutzeraktion

Kotlin

Java

Fallback auf nicht biometrische Anmeldedaten zulassen

Zusätzliche Ressourcen

Blog posts

Dialogfeld für biometrische Authentifizierung anzeigen