Tambah pengesahan cap jari ke aplikasi anda, menggunakan BiometricPrompt

Kandungan

Tambah perpustakaan Biometrik
Tambah kebenaran ASE_BIOMETRIC
Buat susun atur aplikasi anda
Mengesahkan identiti pengguna
Buat contoh cepat biometrik
Mengendalikan panggilan balik pengesahan
1. onAuthenticationSceeded ()
2. onAuthenticationFailed ()
3. onAuthenticationError
4. onAuthenticationHelp
Melaksanakan autentikasi biometrik Android Pie
Menguji projek anda
Mengakhiri

Mari kita gunakan API BiometricPrompt untuk membuat aplikasi yang akan membolehkan pengguna mengesahkan identiti mereka menggunakan cap jari.

Buka Android Studio dan buat projek baru, menggunakan templat "Tindakan Kosong". Apabila digesa, tetapkan SDK minimum projek anda ke 28 atau lebih tinggi, kerana ini akan menghalang aplikasi anda daripada dipasang pada sesuatu yang lebih awal daripada Android Pie.

Sekiranya anda mahu menjadikan aplikasi anda dapat diakses oleh pelbagai peranti Android yang lebih luas, maka anda perlu menyemak versi Android aplikasi yang sedang dipasang pada anda, dan kemudian mengendalikan pengesahan biometrik secara berbeza, bergantung pada tahap API peranti.

Tambah perpustakaan Biometrik

Untuk memulakan, buka fail build.gradle tingkat modul anda, dan tambahkan versi terkini perpustakaan Biometrik sebagai kebergantungan projek:

dependencies {implementation androidx.biometric: biometric: 1.0.0-alpha03

Tambah kebenaran ASE_BIOMETRIC

API BiometricPrompt membolehkan anda memanfaatkan semua kaedah pengesahan biometrik yang berbeza yang menyokong peranti, melalui satu kebenaran.

Buka Manifes projek anda, dan tambah kebenaran "USE_BIOMETRIC":

Buat susun atur aplikasi anda

Seterusnya, mari buat susun atur aplikasi kami. Saya akan menambah satu butang yang, apabila ditoreh, akan melancarkan dialog pengesahan cap jari:

Buka fail strings.xml projek anda, dan tambah sumber rentetan "auth":

BiometricPromptSample Pengesahan dengan cap jari

Mengesahkan identiti pengguna

Sekarang, mari kita melihat bagaimana anda mengesahkan identiti pengguna, menggunakan BiometricPrompt.

Buat contoh cepat biometrik

Kelas BiometrikPrompt termasuk kelas Pembina () pembina, yang anda boleh gunakan untuk membuat contoh BiometricPrompt dan memulakan pengesahan:

akhir BiometricPrompt.PromptInfo promptInfo = baru BiometricPrompt.PromptInfo.Builder ()

Apabila membina contoh BiometricPrompt anda, anda perlu menentukan teks yang sepatutnya muncul dalam dialog pengesahan dan menyesuaikan "butang negatif", iaitu butang yang membolehkan pengguna membatalkan pengesahan.

Untuk mengkonfigurasi dialog pengesahan, anda perlu memberikan yang berikut:

setTitle. Tajuk akuan pengesahan cap jari. (Diperlukan)
setSubtitle. Sarikata tanda pengesahan cap jari. (Pilihan)
setDescription. Penerangan tambahan yang akan dipaparkan dalam dialog pengesahan anda. (Pilihan)
setNegativeButton (teks, pelaksana, pendengar). Ini ialah label butang negatif, contohnya "Batal" atau "Keluar." Apabila mengkonfigurasikan butang negatif, anda juga perlu menyediakan contoh Executor dan OnClickListener supaya pengguna boleh menolak dialog pengesahan.

Pada masa penulisan, tidak mungkin untuk menyesuaikan ikon atau ralat yang digunakan dalam dialog pengesahan.

Akhirnya, anda perlu memanggil membina (). Ini memberi kami perkara berikut:

akhir BiometricPrompt.PromptInfo promptInfo = new BiometricPrompt.PromptInfo.Builder () .setTitle ("Teks tajuk pergi ke sini") .setSubtitle ("Sarikata pergi ke sini") .setDescription ("Ini adalah keterangan") .setNegativeButtonText ("Batal" .build ();

Mengendalikan panggilan balik pengesahan

Contoh BiometricPrompt diberikan satu set kaedah panggilan balik pengesahan yang akan memberitahu apl anda tentang hasil proses pengesahan.

Anda perlu membungkus semua panggilan balik dalam contoh kelas BiometricPrompt.AuthenticationCallback:

akhir BiometricPrompt myBiometricPrompt = baru BiometricPrompt (aktiviti, baruExecutor, baru BiometricPrompt.AuthenticationCallback () {

Langkah seterusnya adalah melaksanakan beberapa, atau semua kaedah panggilan balik berikut:

1. onAuthenticationSceeded ()

Kaedah ini dipanggil apabila cap jari berjaya dipadankan dengan salah satu cap jari yang didaftarkan pada peranti. Dalam senario ini, objek AuthenticationResult diluluskan pada panggilan balikAuthenticationUberbatkan dan aplikasi anda kemudian akan melaksanakan tugas sebagai tindak balas kepada pengesahan yang berjaya ini.

Untuk membantu memastikan perkara mudah, aplikasi kami akan bertindak balas dengan mencetak ke Logcat Android Studio:

@Override public void onAuthenticationSceeded (@NonNull BiometricPrompt.AuthenticationResult result) {super.onAuthenticationSceeded (result); Log.d (TAG, "cap jari diiktiraf dengan jayanya"); }

2. onAuthenticationFailed ()

Kaedah ini dicetuskan apabila imbasan selesai dengan jayanya tetapi cap jari tidak sepadan dengan mana-mana cetakan yang didaftarkan pada peranti. Sekali lagi, aplikasi kami akan bertindak balas terhadap acara pengesahan ini, dengan mencetak ke Logcat:

@Override public void onAuthenticationFailed () {super.onAuthenticationFailed (); Log.d (TAG, "cap jari tidak diiktiraf"); }

3. onAuthenticationError

Panggilan balik ini dicetuskan apabila ralat tidak dapat dipulihkan berlaku dan pengesahan tidak dapat diselesaikan dengan jayanya. Sebagai contoh, mungkin sensor sentuhan peranti dilindungi oleh kotoran atau gris, pengguna tidak mendaftarkan sebarang cap jari pada peranti ini, atau tidak ada memori yang cukup untuk melakukan imbasan biometrik penuh.

Berikut ialah kod yang saya akan gunakan dalam apl saya:

@Override public void onAuthenticationError (int errorCode, @NonNull CharSequence errString) {super.onAuthenticationError (errorCode, errString); jika (errorCode == BiometricPrompt.ERROR_NEGATIVE_BUTTON) {} else {Log.d (TAG, "Ralat yang tidak dapat dipulihkan telah berlaku"); }}

4. onAuthenticationHelp

Kaedah onAuthenticationHelp dipanggil setiap kali ralat tidak maut berlaku, dan termasuk kod bantuan dan yang memberikan maklumat lanjut tentang ralat.

Untuk membantu memastikan kod kami terus terang, saya tidak akan menggunakan onAuthenticationHelp dalam aplikasi kami, tetapi pelaksanaannya akan kelihatan seperti ini:

@Override public void onAuthenticationHelp (int helpCode, CharSequence helpString) {super.onAuthenticationHelp (helpCode, helpString); biometricCallback.onAuthenticationHelp (helpCode, helpString); }

Akhirnya, kita perlu memanggil kaedah authenticateate () contoh BiometricPrompt:

myBiometricPrompt.authenticate (promptInfo);

Melaksanakan autentikasi biometrik Android Pie

Sebaik sahaja anda telah menyelesaikan semua langkah di atas, MainActivity anda harus kelihatan seperti ini:

import androidx.appcompat.app.AppCompatActivity; import androidx.biometric.BiometricPrompt; import android.os.Bundle; import java.util.concurrent.Executor; import java.util.concurrent.Executors; import androidx.fragment.app.FragmentActivity; import android.util.Log; import android.view.View; import androidx.annotation.NonNull; MainActivity kelas awam meluaskan AppCompatActivity {private static String akhir TAG = MainActivity.class.getName (); @Override dilindungi tidak sah onCreate (Bundle savedInstanceState) {super.onCreate (savedInstanceState); setContentView (R.layout.activity_main); // Buat kolam thread dengan satu thread // Executor newExecutor = Executors.newSingleThreadExecutor (); Aktiviti FragmentActivity = ini; // Mula mendengar acara pengesahan // akhir BiometricPrompt myBiometricPrompt = baru BiometricPrompt (aktiviti, newExecutor, baru BiometricPrompt.AuthenticationCallback () {@Override // onAuthenticationError dipanggil apabila ralat fatal berlaku // public invalid onAuthenticationError (int errorCode, @NonNull } {} Else {// Print a to Logcat // Log.d (TAG, "Ralat tidak dapat dipulihkan telah berlaku");}} / / onAuthenticationSubsesan dipanggil apabila cap jari dipadankan dengan jayanya // @Override void public onAuthenticationSecuted (@NonNull BiometricPrompt.AuthenticationResult result) {super.onAuthenticationSceeded (result); // Print a to Logcat // Log.d (TAG, "Cap Jari }} // onAuthenticationFailed dipanggil apabila cap jari tidak sepadan // // @Override void public onAuthenticationFailed () {super.onAuthenticationFailed (); // Print a to Log kucing // Log.d (TAG, "cap jari tidak diiktiraf"); }}); // Buat contoh BiometricPrompt // akhir BiometricPrompt.PromptInfo promptInfo = BiometricPrompt.PromptInfo.Builder baru () // Tambah beberapa teks ke dialog // .setTitle ("Teks tajuk pergi ke sini") .setSubtitle ("Sari kata pergi disini" ) .setDescription ("Ini adalah keterangan") .setNegativeButtonText ("Batal") // Bina dialog // .build (); // Tetapkan onclickListener ke butang "Pengesahan" / // findViewById (R.id.launchAuthentication) .setOnClickListener (baru View.OnClickListener () {@Override public void onClick (Lihat v) {myBiometricPrompt.authenticate (promptInfo);} }); }}

Menguji projek anda

Sekarang anda telah mencipta projek anda, sudah tiba masanya untuk memasukkannya ke dalam ujian dan lihat jika ia benar-benar menambah pengesahan cap jari ke aplikasi anda!

Untuk menjalankan projek ini, anda perlu sama ada telefon pintar atau tablet fizikal yang menjalankan Android Pie, atau Peranti Maya Maya (AVD) yang menggunakan pratonton Android P atau yang lebih tinggi.

Anda juga perlu mendaftar sekurang-kurangnya satu cap jari pada peranti anda. Jika anda menggunakan peranti Android fizikal, maka:

Secure skrin kunci anda dengan PIN, kata laluan atau corak, jika anda belum (dengan menavigasi ke "Tetapan> Skrin dan keselamatan skrin> Jenis kunci skrin> Corak / Pin / Kata Laluan" dan kemudian mengikuti arahan pada skrin).
Lancarkan aplikasi "Tetapan" peranti anda.
Pilih "Kunci skrin dan keselamatan."
Pilih "Pengimbas cap jari."
Ikut arahan untuk mendaftarkan satu atau lebih cap jari.

Peranti maya Android tidak mempunyai sensor sentuhan fizikal, jadi anda perlu mensimulasikan acara sentuhan:

Lancarkan AVD anda, jika anda belum lagi.
Di samping AVD, anda akan melihat butang jalur. Cari butang "Lagi" yang bertitik (di mana kursor berada dalam tangkapan skrin berikut) dan berikan satu klik. Ini melancarkan tetingkap "Kawalan Lanjutan".

Dalam tetingkap Kawalan Diperluas, pilih "Cap Jari." Ini membuka satu set kawalan, di mana anda boleh mencontohi pelbagai acara sentuhan.
Buka menu lungsur turun dan pilih cap jari yang anda ingin daftarkan pada peranti ini; Saya menggunakan "Jari 1."
Sekarang, mari kita beralih perhatian kepada peranti yang ditiru itu. Lancarkan aplikasi "Tetapan" AVD, dan pilih "Keselamatan & lokasi."
Jika anda belum menyiapkan PIN, kata laluan atau corak, kemudian pilih "Kunci skrin" dan ikut arahan pada skrin untuk mengunci skrin kunci anda, kemudian navigasi semula ke skrin "Tetapan> Keselamatan & lokasi" utama.
Pilih "Sidik Jari," diikuti dengan "Tambah cap jari."
Anda kini akan diminta untuk menekan jari anda kepada sensor sentuhan. Sebaliknya, terus klik "Sentuh Sensor" sehingga anda melihat "Tambahan cap jari".

Klik "Selesai."
Jika anda ingin mendaftarkan cap jari tambahan, kemudian bilas dan ulangi langkah-langkah di atas.

Sebaik sahaja anda telah mendaftar sekurang-kurangnya satu cap jari, anda sudah bersedia untuk memasukkan aplikasi anda ke ujian. Saya akan menguji bagaimana aplikasi kami mengendalikan tiga senario yang berbeza:

Pengguna cuba mengesahkan menggunakan cap jari yang berdaftar.
Pengguna cuba mengesahkan menggunakan cap jari yang tidak didaftarkan pada peranti ini.
Pengguna cuba untuk mengesahkan menggunakan cap jari yang tidak berdaftar, berbilang kali dan berturut-turut.

Mari cuba pengesahan menggunakan cap jari yang baru saja didaftarkan pada peranti kami:

Pastikan anda melihat Monitor Logcat Android Studio, kerana ini adalah di mana pelbagai aplikasi anda akan muncul.

Pasang aplikasi anda pada peranti ujian.
Ketik butang "Mengesahkan dengan cap jari" aplikasi anda. Dialog pengesahan cap jari akan muncul.
Jika anda menggunakan peranti fizikal, tekan dan tahan hujung jari anda terhadap sensor sentuhan peranti. Jika anda menggunakan AVD, kemudian gunakan butang "Sentuh sensor" untuk mensimulasikan peristiwa sentuhan.
Semak Monitor Logcat. Sekiranya pengesahan itu berjaya, maka anda harus melihat perkara berikut: "cap jari diakui dengan jayanya"

Seterusnya, mari lihat apa yang berlaku jika kami cuba mengesahkan menggunakan cap jari yang tidak didaftarkan pada peranti ini:

Ketik butang "Mengesahkan dengan cap jari" apl sekali lagi.
Sekiranya anda menggunakan AVD, gunakan tetingkap "Kawalan Lanjutan" untuk memilih cap jari itu tidak didaftarkan pada peranti ini; Saya menggunakan "Jari 2." Berikan butang "Sentuh sensor" satu klik.
Jika anda menggunakan telefon pintar Android atau tablet fizikal maka tekan dan tahan hujung jari anda terhadap sensor sentuhan peranti - pastikan anda menggunakan jari yang tidak didaftarkan pada peranti ini!
Semak Android Studio's Logcat, ia kini seharusnya memaparkan "cap jari yang tidak dikenali".

Seperti yang telah disebutkan, API BiometricPrompt secara automatik mengendalikan percubaan pengesahan kegagalan yang berlebihan. Untuk menguji fungsi ini:

Ketik butang "Mengesahkan dengan cap jari" apl anda.
Cuba untuk mengesahkan beberapa kali secara berturut-turut, menggunakan cap jari yang tidak berdaftar.
Selepas beberapa percubaan, kotak dialog perlu ditutup secara automatik. Semak Logcat Android Studio, dan anda sepatutnya melihat perkara berikut: "Ralat yang tidak dapat dipulihkan telah berlaku."

Anda boleh memuat turun aplikasi lengkap dari GitHub.

Mengakhiri

Dalam artikel ini, kami meneroka API BiometricPrompt baru Android Pie, yang membolehkan anda dengan mudah menambah pengesahan cap jari ke apl anda. Adakah anda fikir BiometricPrompt adalah peningkatan pada kaedah pengesahan cap jari Android yang sebelumnya? Beritahu kami dalam komen di bawah!