Pokaż okno uwierzytelniania biometrycznego

Jedną ze metod ochrony informacji poufnych lub płatnych treści w aplikacji jest żądanie uwierzytelniania biometrycznego, np. rozpoznawania twarzy lub odcisku palca. Z tego przewodnika dowiesz się, jak obsługiwać w aplikacji procesy logowania biometrycznego.

Uwaga: biblioteka biometryczna rozszerza możliwości wycofanego interfejsu API FingerprintManager.

Deklarowanie typów uwierzytelniania obsługiwanych przez aplikację

Aby określić typy uwierzytelniania obsługiwane przez Twoją aplikację, użyj interfejsu BiometricManager.Authenticators. System umożliwia zadeklarowanie tych typów uwierzytelniania:

BIOMETRIC_STRONG

Uwierzytelnianie przy użyciu biometrii klasy 3, zgodnie z definicją na stronie definicji zgodności z Androidem.

BIOMETRIC_WEAK

Uwierzytelnianie przy użyciu biometrii klasy 2, zgodnie z definicją na stronie definicji zgodności z Androidem.

DEVICE_CREDENTIAL

Uwierzytelnianie przy użyciu danych logowania blokady ekranu – kodu PIN, wzoru lub hasła użytkownika.

Aby zacząć korzystać z mechanizmu uwierzytelniającego, użytkownik musi utworzyć kod PIN, wzór lub hasło. Jeśli użytkownik nie ma takiego identyfikatora, zostanie wyświetlony monit o jego utworzenie.

Aby określić rodzaje uwierzytelniania biometrycznego akceptowane przez Twoją aplikację, przekaż typ uwierzytelniania lub bitową kombinację typów do metody setAllowedAuthenticators(). Poniższy fragment kodu pokazuje, jak obsługiwać uwierzytelnianie przy użyciu danych biometrycznych klasy 3 lub danych logowania do blokady ekranu.

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

Uwaga: nie możesz jednocześnie wywołać metody setNegativeButtonText() i setAllowedAuthenticators(... or DEVICE_CREDENTIAL) w instancji BiometricPrompt.PromptInfo.Builder.

Te kombinacje typów uwierzytelniania nie są obsługiwane na Androidzie 10 (poziom interfejsu API 29) i starszych: DEVICE_CREDENTIAL i BIOMETRIC_STRONG | DEVICE_CREDENTIAL. Aby sprawdzić dostępność kodu PIN, wzoru lub hasła na Androidzie 10 i starszych wersjach, użyj metody KeyguardManager.isDeviceSecure().

Sprawdź, czy jest dostępne uwierzytelnianie biometryczne

Gdy określisz, które elementy uwierzytelniania obsługuje Twoja aplikacja, sprawdź, czy są one dostępne. Aby to zrobić, przekaż do metody canAuthenticate() tę samą bitową kombinację typów, która została zadeklarowana za pomocą metody setAllowedAuthenticators(). W razie potrzeby wywołaj działanie intencji ACTION_BIOMETRIC_ENROLL. W dodatkowym intencji podaj zestaw mechanizmów uwierzytelniających, które akceptuje Twoja aplikacja. Ta intencja wymaga od użytkownika zarejestrowania danych logowania na potrzeby uwierzytelniania akceptowanego przez Twoją aplikację.

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

Określanie sposobu uwierzytelniania użytkownika

Po uwierzytelnieniu użytkownika możesz sprawdzić, czy został uwierzytelniony za pomocą danych logowania urządzenia lub danych biometrycznych, wywołując metodę getAuthenticationType().

Wyświetl prośbę o zalogowanie

Aby wyświetlić komunikat systemowy, który prosi użytkownika o uwierzytelnienie przy użyciu biometrycznych danych logowania, skorzystaj z biblioteki biometrycznej. Wyświetlane przez system okno dialogowe jest spójne we wszystkich aplikacjach, które z niego korzystają, co zwiększa zaufanie użytkowników. Przykładowe okno dialogowe widać na rys. 1.

Rysunek 1. Okno systemu z żądaniem uwierzytelniania biometrycznego.

Aby dodać uwierzytelnianie biometryczne do aplikacji za pomocą biblioteki biometrycznej:

1. W pliku build.gradle modułu aplikacji dodaj zależność do biblioteki androidx.biometric.

2. W aktywności lub fragmencie, który hostuje okno logowania biometrycznego, wyświetl je zgodnie z logiką widoczną w tym fragmencie kodu:

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

Używanie rozwiązania kryptograficznego, które zależy od uwierzytelniania

Aby jeszcze lepiej chronić informacje poufne w swojej aplikacji, możesz włączyć kryptografię w procesie uwierzytelniania biometrycznego za pomocą instancji CryptoObject. Platforma obsługuje te obiekty kryptograficzne: Signature, Cipher i Mac.

Gdy użytkownik uwierzytelni się za pomocą promptu biometrycznego, aplikacja może wykonać operację kryptograficzną. Jeśli na przykład do uwierzytelniania korzystasz z obiektu Cipher, aplikacja może szyfrować i odszyfrowywać dane za pomocą obiektu SecretKey.

W sekcjach poniżej znajdziesz przykłady użycia obiektu Cipher i obiektu SecretKey do szyfrowania danych. W każdym przykładzie stosujemy te metody:

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

Uwierzytelniaj tylko przy użyciu danych logowania biometrycznego

Jeśli Twoja aplikacja używa tajnego klucza, który do odblokowywania wymaga danych biometrycznych, użytkownik musi uwierzytelnić swoje dane logowania biometryczne za każdym razem, zanim aplikacja uzyska dostęp do klucza.

Aby zaszyfrować informacje poufne dopiero po uwierzytelnieniu użytkownika przy użyciu biometrycznych danych logowania, wykonaj te czynności:

1. Wygeneruj klucz, który korzysta z tej konfiguracji KeyGenParameterSpec:

   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. Uruchom przepływ pracy uwierzytelniania biometrycznego, który obejmuje szyfr:

   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. W ramach wywołań zwrotnych uwierzytelniania biometrycznego użyj tajnego klucza do zaszyfrowania informacji poufnych:

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

Uwierzytelniaj za pomocą danych biometrycznych lub danych logowania na ekranie blokady

Możesz użyć tajnego klucza, który umożliwia uwierzytelnianie przy użyciu danych logowania biometrycznych lub danych logowania na ekran blokady (kodu PIN, wzoru lub hasła). Podczas konfigurowania tego klucza określ okres ważności. W tym czasie aplikacja może wykonywać wiele operacji kryptograficznych bez konieczności ponownego uwierzytelnienia użytkownika.

Uwaga: aby używać tego typu klucza, musisz zezwolić na zastępcze dane logowania niebiometryczne, co oznacza, że nie możesz przekazać wystąpienia CryptoObject do metody authenticate() obiektu BiometricPrompt.

Aby zaszyfrować informacje poufne po uwierzytelnieniu użytkownika za pomocą danych logowania biometrycznego lub danych logowania na ekranie blokady, wykonaj te czynności:

1. Wygeneruj klucz, który korzysta z tej konfiguracji KeyGenParameterSpec:

   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. W ciągu VALIDITY_DURATION_SECONDS od uwierzytelnienia użytkownika zaszyfruj informacje poufne:

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

Uwierzytelnianie za pomocą kluczy uwierzytelniania na podstawie użycia

Możesz zapewnić obsługę kluczy uwierzytelniania według użycia w swojej instancji BiometricPrompt. Taki klucz wymaga od użytkownika przedstawienia danych logowania biometrycznych lub danych logowania do urządzenia za każdym razem, gdy aplikacja chce uzyskać dostęp do danych chronionych przez ten klucz. Klucze uwierzytelniania na podstawie użycia mogą być przydatne w przypadku transakcji o wysokiej wartości, np. dokonywania dużych płatności czy aktualizowania danych zdrowotnych.

Aby powiązać obiekt BiometricPrompt z kluczem uwierzytelniania na podstawie użycia, dodaj kod podobny do tego:

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

Uwierzytelnij bez wyraźnego działania użytkownika

Domyślnie system wymaga od użytkownika wykonania określonej czynności, np. kliknięcia przycisku, po zaakceptowaniu danych logowania biometrycznego. Ta konfiguracja jest preferowana, jeśli aplikacja wyświetla okno z prośbą o potwierdzenie działania o charakterze wrażliwym lub bardzo wysokiego ryzyka, np. dokonanie zakupu.

Jeśli aplikacja wyświetla okno uwierzytelniania biometrycznego w przypadku działania o niższym ryzyku, możesz wskazać systemowi wskazówkę, że użytkownik nie musi potwierdzać uwierzytelniania. Ta wskazówka może umożliwić użytkownikowi szybsze wyświetlenie treści w aplikacji po ponownym uwierzytelnieniu za pomocą pasywnego rozpoznawania twarzy, np. rozpoznawania twarzy lub tęczówki. Aby podać tę wskazówkę, przekaż obiekt false do metody setConfirmationRequired().

Rysunek 2 przedstawia 2 wersje tego samego okna. Jedna wersja wymaga wyraźnego działania użytkownika, a druga nie.

Uwaga: ta flaga jest przekazywana do systemu jako wskazówka, więc system może ją zignorować, jeśli użytkownik zmieni ustawienia uwierzytelniania biometrycznego.

Rysunek 2. Uwierzytelnianie twarzą bez potwierdzenia przez użytkownika (u góry) i z potwierdzeniem przez użytkownika (u dołu).

Ten fragment kodu pokazuje, jak wyświetlić okno, które nie wymaga wyraźnego działania użytkownika w celu zakończenia procesu uwierzytelniania:

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

Zezwalaj na zastępcze dane logowania niebiometryczne

Jeśli chcesz, aby aplikacja zezwalała na uwierzytelnianie przy użyciu danych biometrycznych lub danych logowania urządzenia, możesz zadeklarować, że aplikacja obsługuje dane logowania do urządzenia, umieszczając DEVICE_CREDENTIAL w zbiorze wartości, które przekazujesz do setAllowedAuthenticators().

Jeśli Twoja aplikacja obecnie korzysta z tych funkcji: createConfirmDeviceCredentialIntent() lub setDeviceCredentialAllowed(), przejdź na setAllowedAuthenticators().

Uwaga: nie możesz przekazać klucza DEVICE_CREDENTIAL do setAllowedAuthenticators() ani wywołać setNegativeButtonText() dla tego samego wystąpienia BiometricPrompt.

Dodatkowe materiały

Więcej informacji o uwierzytelnianiu biometrycznym na Androidzie znajdziesz w tych materiałach.

Posty na blogu

• Migracja z odcisków cyfrowych do Biometrycznego promptu