Pridajte do aplikácie autentifikáciu odtlačkom prsta pomocou aplikácie BiometricPrompt

Obsah

Pridajte biometrickú knižnicu
Pridajte povolenie USE_BIOMETRIC
Vytvorte rozloženie svojej aplikácie
Overenie totožnosti používateľa
Vytvorte biometrickú rýchlu inštanciu
Spracujte spätné volania na autentifikáciu
1. onAuthenticationSucceeded ()
2. onAuthenticationFailed ()
3. onAuthenticationError
4. onAuthenticationHelp
Implementácia biometrickej autentifikácie pre Android Pie
Testovanie vášho projektu
Zabalenie

Použime rozhranie BiometricPrompt API na vytvorenie aplikácie, ktorá umožní používateľovi potvrdiť svoju totožnosť pomocou odtlačku prsta.

Otvorte Android Studio a vytvorte nový projekt pomocou šablóny „Empty Activity“. Po zobrazení výzvy nastavte minimálnu súpravu SDK vo svojom projekte na 28 alebo vyššiu, pretože to zabráni inštalácii vašej aplikácie na čokoľvek iné ako Android Pie.

Ak chcete svoju aplikáciu sprístupniť širšiemu okruhu zariadení s Androidom, musíte skontrolovať, na ktorej verzii aplikácie Android je momentálne vaša aplikácia nainštalovaná, a potom biometrickú autentifikáciu spracovať inak, v závislosti od úrovne rozhrania API zariadenia.

Pridajte biometrickú knižnicu

Ak chcete začať, otvorte súbor build.gradle na úrovni modulu a podľa závislosti od projektu pridajte najnovšiu verziu biometrickej knižnice:

závislosti {implementácia androidx.biometrická: biometrická: 1.0.0-alfa03

Pridajte povolenie USE_BIOMETRIC

Rozhranie BiometricPrompt API vám umožňuje prostredníctvom jediného povolenia využívať všetky rôzne metódy biometrickej autentifikácie, ktoré zariadenie podporuje.

Otvorte manifest projektu a pridajte povolenie „USE_BIOMETRIC“:

Vytvorte rozloženie svojej aplikácie

Potom vytvorme rozloženie našej aplikácie. Chystám sa pridať jedno tlačidlo, ktoré po klepnutí spustí dialógové okno autentifikácie odtlačkov prstov:

Otvorte súbor strings.xml projektu a pridajte zdroj reťazca „auth“:

BiometricPromptSample Autentifikácia pomocou odtlačku prsta

Overenie totožnosti používateľa

Teraz sa pozrime na to, ako overíte totožnosť používateľa pomocou BiometricPrompt.

Vytvorte biometrickú rýchlu inštanciu

Trieda BiometricPrompt obsahuje sprievodnú triedu Builder (), ktorú môžete použiť na vytvorenie inštancie BiometricPrompt a spustenie autentifikácie:

final BiometricPrompt.PromptInfo promptInfo = new BiometricPrompt.PromptInfo.Builder ()

Pri vytváraní inštancie BiometricPrompt musíte definovať text, ktorý by sa mal objaviť v dialógovom okne overenia, a prispôsobiť „negatívne tlačidlo“, čo je tlačidlo, ktoré umožňuje používateľovi zrušiť overenie.

Ak chcete nakonfigurovať dialógové okno overenia, musíte zadať nasledujúce:

setTitle. Názov výzvy na overenie odtlačkov prstov. (Požadovaný)
setSubtitle. Podnadpis výzvy na autentifikáciu odtlačkom prsta. (Voliteľne)
Popis_skladu. Ďalší popis, ktorý sa zobrazí v dialógovom okne autentifikácie. (Voliteľne)
setNegativeButton (text, exekútor, poslucháč). Toto je označenie negatívneho tlačidla, napríklad „Zrušiť“ alebo „Ukončiť“. Pri konfigurácii záporného tlačidla musíte tiež poskytnúť inštanciu Exekútora a OnClickListener, aby užívateľ mohol zamietnuť dialógové okno autentifikácie.

V čase písania nebolo možné prispôsobiť ikonu alebo chybu, ktorá sa používa v dialógovom okne overenia.

Nakoniec budete musieť zavolať build (). Toto nám dáva nasledovné:

final BiometricPrompt.PromptInfo promptInfo = new BiometricPrompt.PromptInfo.Builder () .setTitle („Titulok tu ide“) .setSubtitle („Titulky tu chodí“) .setDescription („Toto je popis“) .setNegativeButtonText („Cancel“) .build ();

Spracujte spätné volania na autentifikáciu

Inštitúcii BiometricPrompt je priradená sada metód spätného volania na autentifikáciu, ktoré informujú vašu aplikáciu o výsledkoch procesu autentifikácie.

Všetky tieto spätné volania budete musieť zabaliť do triedy BiometricPrompt.AuthenticationCallback:

final BiometricPrompt myBiometricPrompt = new BiometricPrompt (activity, newExecutor, new BiometricPrompt.AuthenticationCallback () {

Ďalším krokom je implementácia niektorých alebo všetkých nasledujúcich metód spätného volania:

1. onAuthenticationSucceeded ()

Táto metóda sa nazýva, keď sa odtlačok prsta úspešne zhoduje s jedným z odtlačkov prstov zaregistrovaných v zariadení. V tomto scenári je objekt AuthenticationResult odovzdaný na spätné volanie onAuthenticationSucceeded a vaša aplikácia potom vykoná úlohu ako odpoveď na túto úspešnú autentifikáciu.

Aby sme vám veci uľahčili, odpovie naša aplikácia vytlačením logcat aplikácie Android Studio:

@Override public void onAuthenticationSucceeded (@NonNull BiometricPrompt.AuthenticationVýsledok výsledku) {super.onAuthenticationSucceeded (result); Log.d (TAG, „Odtlačok prsta bol úspešne rozpoznaný“); }

2. onAuthenticationFailed ()

Táto metóda sa spustí po úspešnom dokončení skenovania, ale odtlačok prsta sa nezhoduje so žiadnymi výtlačkami zaregistrovanými v zariadení. Naša aplikácia bude znova reagovať na túto autentifikačnú udalosť vytlačením protokolu Logcat:

@Override public void onAuthenticationFailed () {super.onAuthenticationFailed (); Log.d (TAG, „odtlačok prsta nebol rozpoznaný“); }

3. onAuthenticationError

Toto spätné volanie sa spustí vždy, keď dôjde k neodstrániteľnej chybe a autentizáciu nemožno úspešne dokončiť. Napríklad dotykový senzor zariadenia je pravdepodobne znečistený špinou alebo mastnotou, používateľ nezaregistroval na tomto zariadení žiadne odtlačky prstov alebo nie je k dispozícii dostatok pamäte na vykonanie úplného biometrického skenovania.

Tu je kód, ktorý budem používať vo svojej aplikácii:

@Override public void onAuthenticationError (int errorCode, @NonNull CharSequence errString) {super.onAuthenticationError (errorCode, errString); if (errorCode == BiometricPrompt.ERROR_NEGATIVE_BUTTON) {} else {Log.d (TAG, "Vyskytla sa neodstrániteľná chyba"); }}

4. onAuthenticationHelp

Metóda onAuthenticationHelp sa volá vždy, keď sa vyskytne závažná chyba, a obsahuje kód pomoci a kód, ktorý poskytuje ďalšie informácie o chybe.

Aby sme zaistili jednoduchosť nášho kódu, v našej aplikácii nebudem používať funkciu onAuthenticationHelp, ale implementácia bude vyzerať asi takto:

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

Nakoniec musíme zavolať metódu autentify () inštancie BiometricPrompt:

myBiometricPrompt.authenticate (promptInfo);

Implementácia biometrickej autentifikácie pre Android Pie

Po dokončení všetkých vyššie uvedených krokov by mala vaša MainActivity vyzerať asi takto:

import androidx.appcompat.app.AppCompatActivity; import androidx.biometric.BiometricPrompt; import android.os.Bundle; importovať java.util.concurrent.Executor; import java.util.concurrent.Executori; import androidx.fragment.app.FragmentActivity; import android.util.Log; import android.view.View; import androidx.annotation.NonNull; public class MainActivity rozširuje AppCompatActivity {private static final String TAG = MainActivity.class.getName (); @Override chránené void onCreate (Bundle uloženéInstanceState) {super.onCreate (uloženéInstanceState); setContentView (R.layout.activity_main); // Vytvorenie oblasti vlákien s jedným vláknom // Executor newExecutor = Executor.newSingleThreadExecutor (); FractActivity activity = this; // Začať počúvať autentifikačné udalosti // final BiometricPrompt myBiometricPrompt = new BiometricPrompt (activity, newExecutor, new BiometricPrompt.AuthenticationCallback () {@Override // onAuthenticationError sa nazýva, keď dôjde k závažnej chybe // public void onAuthenticationError (int errorNode @ intonCull @ intonCull, int errorNode @ intonCull @ intonCull @ intonCull) CharSequence errString) {super.onAuthenticationError (errorCode, errString); if (errorCode == BiometricPrompt.ERROR_NEGATIVE_BUTTON) {} else {// Vytlačiť do Logcat // Log.d (TAG, "Došlo k neodstrániteľnej chybe");}} // onAuthenticationSucceeded sa volá, keď je odtlačok prsta úspešne uzavretý // @Override public void onAuthenticationSucceeded (@NonNull BiometricPrompt.AuthenticationResult result); // Vytlačiť na Logcat // Log.d (TAG, "Fingerprint" "onAuthenticationFailed () {super.onAuthenticationFailed (); // Vytlačiť do protokolu cat // Log.d (TAG, „Fingerprint nerozpoznal“); }}); // Vytvorenie inštancie BiometricPrompt // final BiometricPrompt.PromptInfo promptInfo = new BiometricPrompt.PromptInfo.Builder () // Do dialógového okna pridajte nejaký text // .setTitle ("Titulný text ide sem") .setSubtitle ("Titulky sem ísť") ) .setDescription ("Toto je popis") .setNegativeButtonText ("Cancel") // Zostavte dialógové okno // .build (); // Priraďte onClickListener k tlačidlu „Authentication“ // findViewById (R.id.launchAuthentication) .setOnClickListener (nové zobrazenie.OnClickListener () {@Override public void onClick (View v) {myBiometricPrompt.authenticate (promptInfo);} }); }}

Testovanie vášho projektu

Teraz ste svoj projekt vytvorili, je čas ho otestovať a zistiť, či skutočne do vašej aplikácie pridáva overenie odtlačkom prsta!

Na spustenie tohto projektu budete potrebovať buď fyzický smartphone alebo tablet so systémom Android Pie, alebo virtuálne zariadenie Android (AVD), ktoré používa ukážku systému Android P alebo vyššiu.

Na svojom zariadení musíte tiež zaregistrovať aspoň jeden odtlačok prsta. Ak používate fyzické zariadenie s Androidom, postupujte takto:

Ak ste tak ešte neurobili, zabezpečte si obrazovku zámku pomocou kódu PIN, hesla alebo vzoru (prejdite na „Nastavenia> Uzamknúť obrazovku a zabezpečenie> Typ uzamknutia obrazovky> Vzor / Pin / Heslo“ a potom postupujte podľa pokynov na obrazovke).
Spustite v zariadení aplikáciu „Nastavenia“.
Vyberte možnosť „Uzamknúť obrazovku a zabezpečenie“.
Vyberte „Skener odtlačkov prstov“.
Podľa pokynov zaregistrujte jeden alebo viac odtlačkov prstov.

Virtuálne zariadenia s Androidom nemajú fyzický dotykový senzor, takže musíte simulovať dotykovú udalosť:

Ak ste tak ešte neurobili, spustite AVD.
Popri AVD uvidíte pruh tlačidiel. Nájdite tlačidlo s tromi bodkami „Viac“ (kde je kurzor umiestnený na nasledujúcom obrázku) a kliknite naň. Týmto sa otvorí okno „Rozšírené ovládacie prvky“.

V okne rozšírených ovládacích prvkov vyberte možnosť „Odtlačok prsta“. Týmto sa otvorí sada ovládacích prvkov, pomocou ktorých môžete emulovať rôzne dotykové udalosti.
Otvorte rozbaľovaciu ponuku a vyberte odtlačok prsta, ktorý chcete zaregistrovať na tomto zariadení; Používam „prst 1.“
Teraz sa pozrime na emulované zariadenie. Spustite aplikáciu AVD „Settings“ a vyberte možnosť „Security & location“.
Ak ste ešte nenastavili kód PIN, heslo ani vzor, vyberte možnosť „Zámok obrazovky“ a podľa pokynov na obrazovke zabezpečte uzamknutú obrazovku. Potom prejdite späť na hlavnú obrazovku „Nastavenia> Zabezpečenie a umiestnenie“.
Vyberte možnosť „Fingerprint“ a potom „Add fingerprint“.
Zobrazí sa výzva na stlačenie prstu k dotykovému senzoru. Namiesto toho kliknite na tlačidlo „Dotknite sa senzora“, až kým sa nezobrazí „Pridaný odtlačok prsta“.

Kliknite na tlačidlo Hotovo.
Ak chcete zaregistrovať ďalšie odtlačky prstov, vypláchnite a zopakujte vyššie uvedené kroky.

Po zaregistrovaní aspoň jedného odtlačku prsta ste pripravení otestovať svoju žiadosť. Budem testovať, ako naša aplikácia zvláda tri rôzne scenáre:

Používateľ sa pokúša autentifikovať pomocou zaregistrovaného odtlačku prsta.
Používateľ sa pokúša autentifikovať pomocou odtlačku prsta, ktorý nie je zaregistrovaný na tomto zariadení.
Používateľ sa pokúša autentifikovať pomocou neregistrovaných odtlačkov prstov, niekoľkokrát a rýchlo za sebou.

Pokúsme sa autentifikovať pomocou odtlačku prsta, ktorý sme práve zaregistrovali na našom zariadení:

Uistite sa, že sledujete program Logcat Monitor pre Android Studio, pretože tu sa zobrazia rôzne aplikácie.

Nainštalujte svoju aplikáciu na testovacie zariadenie.
Klepnite na tlačidlo „Overiť pomocou odtlačku prsta“ vašej aplikácie. Zobrazí sa dialógové okno autentifikácie odtlačkov prstov.
Ak používate fyzické zariadenie, stlačte a podržte prst na dotykovom senzore zariadenia. Ak používate AVD, simulujte dotykovú udalosť pomocou tlačidla „Dotknite sa senzora“.
Skontrolujte monitor Logcat. Ak bola autentifikácia úspešná, mali by ste vidieť toto: „Fingerprint úspešne rozpoznaný“

Ďalej sa pozrime, čo sa stane, keď sa pokúsime autentifikovať pomocou odtlačku prsta, ktorý nie je zaregistrovaný na tomto zariadení:

Znova klepnite na tlačidlo „Overiť pomocou odtlačku prsta“ v aplikácii.
Ak používate AVD, pomocou okna „Extended Controls“ (Rozšírené ovládacie prvky) vyberte odtlačok prsta nie je registrované na tomto zariadení; Používam „prst 2.“ Kliknutie na tlačidlo „Dotknite sa senzora“.
Ak používate fyzický smartphone alebo tablet s Androidom, stlačte a podržte prst na dotykovom senzore zariadenia - uistite sa, že používate prst, ktorý nie je v tomto zariadení zaregistrovaný!
Skontrolujte protokol Logcat pre Android Studio, teraz by mal byť zobrazený „odtlačok prsta nebol rozpoznaný“.

Ako už bolo uvedené, rozhranie BiometricPrompt API automaticky spracováva nadmerné neúspešné pokusy o overenie. Ak chcete otestovať túto funkciu:

Klepnite na tlačidlo „Overiť pomocou odtlačku prsta“ vašej aplikácie.
Pokus o autentizáciu viackrát v rýchlom slede pomocou neregistrovaného odtlačku prsta.
Po niekoľkých pokusoch by sa dialógové okno malo automaticky zatvoriť. Skontrolujte aplikáciu Logcat pre Android Studio a mali by ste vidieť nasledujúce: „Vyskytla sa neodstrániteľná chyba.“

Kompletnú aplikáciu si môžete stiahnuť z GitHubu.

Zabalenie

V tomto článku sme preskúmali nové rozhranie BiometricPrompt API pre Android Pie, ktoré vám umožňuje ľahko pridať overenie odtlačkov prstov do vašej aplikácie. Myslíte si, že BiometricPrompt je vylepšením predchádzajúcich metód overovania odtlačkov prstov v systéme Android? Dajte nám vedieť v komentároch nižšie!