Biyometrik kimlik doğrulama iletişim kutusu göster

Uygulamanızdaki hassas bilgileri veya premium içeriği korumanın bir yöntemi, yüz tanıma veya parmak izi tanıma gibi özellikler kullanarak biyometrik kimlik doğrulama istemektir. Bu kılavuzda, uygulamanızda biyometrik giriş akışlarının nasıl destekleneceği açıklanmaktadır.

Uygulamanızın desteklediği kimlik doğrulama türlerini belirtin

Uygulamanızın desteklediği kimlik doğrulama türlerini tanımlamak için BiometricManager.Authenticators arayüzünü kullanın. Sistem aşağıdaki kimlik doğrulama türlerini tanımlamanıza olanak tanır:

BIOMETRIC_STRONG
Android uyumluluk tanımı sayfasında tanımlandığı şekilde 3. Sınıf biyometri kullanarak kimlik doğrulama.
BIOMETRIC_WEAK
Android uyumluluk tanımı sayfasında tanımlandığı şekilde 2. Sınıf biyometri kullanarak kimlik doğrulama.
DEVICE_CREDENTIAL
Ekran kilidi kimlik bilgilerini (kullanıcının PIN'i, deseni veya şifresi) kullanarak kimlik doğrulama.

Kimlik doğrulayıcıyı kullanmaya başlamak için kullanıcının bir PIN, desen veya şifre oluşturması gerekir. Kullanıcının bir profili yoksa biyometrik kayıt akışı kullanıcıdan bir hesap oluşturmasını ister.

Uygulamanızın kabul ettiği biyometrik kimlik doğrulama türlerini tanımlamak için setAllowedAuthenticators() yöntemine bir kimlik doğrulama türü veya bit tabanlı bir tür kombinasyonu iletin. Aşağıdaki kod snippet'i, 3. Sınıf biyometri veya ekran kilidi kimlik bilgisi kullanılarak kimlik doğrulamanın nasıl destekleneceğini gösterir.

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

Aşağıdaki kimlik doğrulayıcı türü kombinasyonları Android 10 (API düzeyi 29) ve önceki sürümlerde desteklenmez: DEVICE_CREDENTIAL ve BIOMETRIC_STRONG | DEVICE_CREDENTIAL. Android 10 ve önceki sürümlerde PIN, desen veya şifre olup olmadığını kontrol etmek için KeyguardManager.isDeviceSecure() yöntemini kullanın.

Biyometrik kimlik doğrulamanın kullanılabilir olup olmadığını kontrol etme

Uygulamanızın hangi kimlik doğrulama öğelerini desteklediğine karar verdikten sonra bu öğelerin kullanılabilir olup olmadığını kontrol edin. Bunu yapmak için setAllowedAuthenticators() yöntemini kullanarak tanımladığınız bit tabanlı tür kombinasyonunu canAuthenticate() yöntemine geçirin. Gerekirse ACTION_BIOMETRIC_ENROLL intent işlemini çağırın. Niyet ekstrasında, uygulamanızın kabul ettiği kimlik doğrulayıcı grubunu sağlayın. Bu niyet, kullanıcıdan uygulamanızın kabul ettiği bir kimlik doğrulayıcı için kimlik bilgilerini kaydetmesini ister.

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

Kullanıcının kimlik doğrulamasının nasıl yapıldığını belirleme

Kullanıcı kimlik doğrulaması yaptıktan sonra, getAuthenticationType() çağrısı yaparak kullanıcının kimliğinin cihaz kimlik bilgisi veya biyometrik kimlik bilgisi kullanılarak doğrulanıp doğrulanmadığını kontrol edebilirsiniz.

Giriş istemini görüntüle

Kullanıcının biyometrik kimlik bilgilerini kullanarak kimlik doğrulaması yapmasını isteyen bir sistem istemini görüntülemek için Biyometrik kitaplığı kullanın. Sistem tarafından sağlanan bu iletişim kutusu, onu kullanan uygulamalar arasında tutarlı olduğundan daha güvenilir bir kullanıcı deneyimi oluşturur. Şekil 1'de örnek bir iletişim kutusu görüntülenmektedir.

İletişim kutusunu gösteren ekran görüntüsü
Şekil 1. Biyometrik kimlik doğrulama isteyen sistem iletişim kutusu.

Biyometrik kitaplığı kullanarak uygulamanıza biyometrik kimlik doğrulama eklemek için aşağıdaki adımları tamamlayın:

  1. Uygulama modülünüzün build.gradle dosyasında, androidx.biometric kitaplığına bağımlılık ekleyin.

  2. Biyometrik giriş iletişim kutusunu barındıran etkinlik veya parçada, aşağıdaki kod snippet'inde gösterilen mantığı kullanarak iletişim kutusunu görüntüleyin:

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

Kimlik doğrulamaya bağlı bir şifreleme çözümü kullanın

Uygulamanızdaki hassas bilgileri daha iyi korumak için bir CryptoObject örneği kullanarak biyometrik kimlik doğrulama iş akışınıza kriptografi dahil edebilirsiniz. Çerçeve şu şifreleme nesnelerini destekler: Signature, Cipher ve Mac.

Kullanıcı, biyometrik istem kullanarak kimlik doğrulamasını başarıyla yaptıktan sonra uygulamanız şifreleme işlemi gerçekleştirebilir. Örneğin, Cipher nesnesi kullanarak kimlik doğrularsanız uygulamanız bir SecretKey nesnesi kullanarak şifreleme ve şifre çözme işlemleri gerçekleştirebilir.

Aşağıdaki bölümlerde, verileri şifrelemek için Cipher ve SecretKey nesnesi kullanımına dair örnekler yer almaktadır. Her örnek aşağıdaki yöntemleri kullanır:

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

Yalnızca biyometrik kimlik bilgilerini kullanarak kimlik doğrulayın

Uygulamanız, kilidi açmak için biyometrik kimlik bilgileri gerektiren bir gizli anahtar kullanıyorsa bu anahtara erişmeden önce kullanıcının her seferinde biyometrik kimlik bilgilerini doğrulaması gerekir.

Hassas bilgileri yalnızca kullanıcı biyometrik kimlik bilgilerini kullanarak kimlik doğruladıktan sonra şifrelemek için aşağıdaki adımları tamamlayın:

  1. Aşağıdaki KeyGenParameterSpec yapılandırmasını kullanan bir anahtar oluşturun:

    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. Şifre içeren bir biyometrik kimlik doğrulama iş akışı başlatın:

    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. Biyometrik kimlik doğrulama geri çağırmalarınızın içinde hassas bilgileri şifrelemek için gizli anahtarı kullanın:

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

Biyometrik veya kilit ekranı kimlik bilgilerini kullanarak kimlik doğrulayın

Biyometrik kimlik bilgileri veya kilit ekranı kimlik bilgileri (PIN, desen veya şifre) kullanarak kimlik doğrulamaya olanak tanıyan gizli bir anahtar kullanabilirsiniz. Bu anahtarı yapılandırırken bir geçerlilik süresi belirtin. Bu süre zarfında uygulamanız, kullanıcının yeniden kimlik doğrulaması yapmasına gerek kalmadan birden fazla şifreleme işlemi gerçekleştirebilir.

Kullanıcı biyometrik kimlik bilgileri veya kilit ekranı kimlik bilgilerini kullanarak kimlik doğruladıktan sonra hassas bilgileri şifrelemek için aşağıdaki adımları tamamlayın:

  1. Aşağıdaki KeyGenParameterSpec yapılandırmasını kullanan bir anahtar oluşturun:

    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. Kullanıcının kimliğini doğrulamasının ardından VALIDITY_DURATION_SECONDS boyunca hassas bilgileri şifreleyin:

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

Kullanım başına kimlik doğrulama anahtarlarını kullanarak kimlik doğrulayın

BiometricPrompt örneğiniz içinde kullanım başına kimlik doğrulama anahtarları için destek sağlayabilirsiniz. Böyle bir anahtar, uygulamanızın bu anahtarla korunan verilere her erişmesi gerektiğinde kullanıcının biyometrik kimlik bilgisi veya cihaz kimlik bilgisi sunmasını gerektirir. Kullanım başına kimlik doğrulama anahtarları, yüksek tutarda ödeme yapma veya bir kişinin sağlık kayıtlarını güncelleme gibi yüksek değerli işlemler için yararlı olabilir.

BiometricPrompt nesnesini kullanım başına kimlik doğrulama anahtarıyla ilişkilendirmek için aşağıdakine benzer bir kod ekleyin:

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

Uygunsuz kullanıcı işlemi olmadan kimlik doğrula

Varsayılan olarak sistem, kullanıcıların biyometrik kimlik bilgileri kabul edildikten sonra bir düğmeye basmak gibi belirli bir işlem gerçekleştirmesini gerektirir. Uygulamanızda, satın alma gibi hassas veya yüksek riskli bir işlemi onaylayabileceğiniz bir iletişim kutusu gösteriliyorsa bu yapılandırma tercih edilir.

Ancak uygulamanız, daha düşük riskli bir işlem için biyometrik kimlik doğrulama iletişim kutusu gösterirse sisteme, kullanıcının kimlik doğrulamayı onaylaması gerekmeyeceğine dair bir ipucu sağlayabilirsiniz. Bu ipucu, kullanıcının yüz veya iris tabanlı tanıma gibi pasif bir yöntem kullanarak yeniden kimlik doğrulaması yaptıktan sonra uygulamanızdaki içeriği daha hızlı görüntülemesine olanak sağlayabilir. Bu ipucunu sağlamak için false yöntemini setConfirmationRequired() yöntemine geçirin.

Şekil 2'de aynı iletişim kutusunun iki sürümü gösterilmektedir. Bir sürüm açık bir kullanıcı işlemi gerektirirken diğer sürüm bunu gerektirmez.

İletişim kutusunun ekran görüntüsü İletişim kutusunun ekran görüntüsü
Şekil 2. Kullanıcı onayı olmadan (üstte) ve kullanıcı onayıyla (altta) yüz kimlik doğrulaması.

Aşağıdaki kod snippet'i, kimlik doğrulama işlemini tamamlamak için açık bir kullanıcı işlemi gerektirmeyen bir iletişim kutusunun nasıl sunulacağını göstermektedir:

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

Biyometrik olmayan kimlik bilgilerinin yedeklenmesine izin ver

Uygulamanızın biyometrik veya cihaz kimlik bilgilerini kullanarak kimlik doğrulamaya izin vermesini istiyorsanız setAllowedAuthenticators()'e geçirdiğiniz değer grubuna DEVICE_CREDENTIAL ekleyerek uygulamanızın cihaz kimlik bilgilerini desteklediğini beyan edebilirsiniz.

Uygulamanız bu özelliği sağlamak için şu anda createConfirmDeviceCredentialIntent() veya setDeviceCredentialAllowed() kullanıyorsa setAllowedAuthenticators() kullanmaya geçiş yapın.

Ek kaynaklar

Android'de biyometrik kimlik doğrulama hakkında daha fazla bilgi edinmek için aşağıdaki kaynaklara başvurun.

Blog yayınları