Innehåll

• Lägg till biometriska biblioteket
• Lägg till USE_BIOMETRIC tillstånd
• Skapa din applikations layout
• Autentisera användarens identitet
• Skapa en biometrisk snabbinstans
• Hantera återuppringningar för autentisering
• 1. onAuthenticationSucceeded ()
• 2. onAuthenticationFailed ()
• 3. onAuthenticationError
• 4. onAuthenticationHelp
• Implementera Android Pies biometriska autentisering
• Testa ditt projekt
• Avslutar

Låt oss använda BiometricPrompt API för att skapa en app som gör att användaren kan bekräfta sin identitet med ett fingeravtryck.

Öppna Android Studio och skapa ett nytt projekt med hjälp av "Tom Activity" -mallen. När du uppmanas ställer du in projektets minsta SDK till 28 eller högre, eftersom detta kommer att förhindra att din applikation installeras på något tidigare än Android Pie.

Om du ville göra din app tillgänglig för ett större utbud av Android-enheter, måste du kontrollera vilken version av Android din applikation är installerad på och sedan hantera biometrisk autentisering på olika sätt, beroende på enhetens API-nivå.

Lägg till biometriska biblioteket

För att starta, öppna din modulnivå build.gradle-fil och lägg till den senaste versionen av Biometric-biblioteket som ett projektberoende:

beroenden {implementering androidx.biometric: biometric: 1.0.0-alpha03

Lägg till USE_BIOMETRIC tillstånd

Med BiometricPrompt API kan du använda alla de olika biometriska autentiseringsmetoder som enheten stöder via en enda tillåtelse.

Öppna projektets manifest och lägg till tillståndet "USE_BIOMETRIC":

Skapa din applikations layout

Låt oss nu skapa vår applikationslayout. Jag kommer att lägga till en enda knapp som, när du trycker på den, kommer att starta dialogrutan för fingeravtrycksautentisering:

Öppna projektets strings.xml-fil och lägg till "autor" -strängaresursen:

BiometricPromptSample Autentisera med fingeravtryck

Autentisera användarens identitet

Låt oss nu titta på hur du autentiserar användarens identitet med hjälp av BiometricPrompt.

Skapa en biometrisk snabbinstans

Klassen BiometricPrompt innehåller en ledsagare Builder () -klass, som du kan använda för att skapa en BiometricPrompt-instans och initiera autentiseringen:

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

När du bygger din BiometricPrompt-instans måste du definiera texten som ska visas i autentiseringsdialogen och anpassa den "negativa knappen", som är den knapp som gör det möjligt för användaren att avbryta autentiseringen.

För att konfigurera autentiseringsdialogen måste du ange följande:

• setTitle. Titeln på fingeravtrycksautentiseringsprompt. (Nödvändig)
• setSubtitle. Undertexten på fingeravtrycksautentiseringsprompt. (Valfri)
• setDescription. En ytterligare beskrivning som visas i din autentiseringsdialogruta. (Valfri)
• setNegativeButton (text, exekutiv, lyssnare). Det här är den negativa knappens etikett, till exempel "Avbryt" eller "Avsluta". När du konfigurerar den negativa knappen måste du också ange en Executor-instans och en OnClickListener så att användaren kan avbryta autentiseringsdialogen.

I skrivande stund var det inte möjligt att anpassa ikonen eller felet som användes i autentiseringsdialogen.

Slutligen måste du ringa build (). Detta ger oss följande:

final BiometricPrompt.PromptInfo promptInfo = new BiometricPrompt.PromptInfo.Builder () .setTitle ("Titelteksten går här") .setSubtitle ("Undertexten går här") .setDescription ("Detta är beskrivningen") .setNegativeButtonText ("Avbryt") .bygga();

Hantera återuppringningar för autentisering

BiometricPrompt-instansen tilldelas en uppsättning autentiseringsåteruppringningsmetoder som kommer att meddela din app om resultatet av autentiseringsprocessen.

Du måste packa in alla dessa återuppringningar i en BiometricPrompt.AuthenticationCallback-klassinstans:

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

Nästa steg är att implementera några eller alla följande återuppringningsmetoder:

1. onAuthenticationSucceeded ()

Den här metoden kallas när fingeravtrycket matchas med ett av fingeravtryck som är registrerat på enheten. I det här scenariot överförs ett AuthenticationResult-objekt till återuppringningen onAuthenticationSucceeded och din app utför sedan en uppgift som svar på den framgångsrika autentiseringen.

För att hjälpa till att hålla sakerna enkla svarar vår app genom att skriva ut en till Android Studio's Logcat:

@Override public void onAuthenticationSucceeded (@NonNull BiometricPrompt.AuthenticationResult result) {super.onAuthenticationSucceeded (resultat); Log.d (TAG, "Fingeravtryck erkänns framgångsrikt"); }

2. onAuthenticationFailed ()

Den här metoden utlöses när skanningen är klar men fingeravtrycket stämmer inte överens med någon av de utskrifter som registrerats på enheten. Återigen kommer vår app att svara på denna autentiseringshändelse genom att skriva ut en till Logcat:

@Override public void onAuthenticationFailed () {super.onAuthenticationFailed (); Log.d (TAG, "Fingeravtryck är inte igenkänt"); }

3. onAuthenticationError

Denna återuppringning utlöses när ett fel som inte kan återvinnas inträffar och autentiseringen inte kan slutföras. Till exempel täcker enhetens beröringssensor av smuts eller fett, användaren har inte registrerat några fingeravtryck på den här enheten, eller det finns inte tillräckligt med minne tillgängligt för att utföra en fullständig biometrisk skanning.

Här är koden som jag kommer att använda i min app:

@Override public void onAuthenticationError (int errorCode, @NonNull CharSequence errString) {super.onAuthenticationError (errorCode, errString); if (errorCode == BiometricPrompt.ERROR_NEGATIVE_BUTTON) {} annars {Log.d (TAG, "Ett oåterkalleligt fel inträffade"); }}

4. onAuthenticationHelp

Metoden onAuthenticationHelp kallas varje gång ett icke-dödligt fel inträffar och innehåller en hjälpkod och en som ger ytterligare information om felet.

För att hålla vår kod okomplicerad använder jag inte onAuthenticationHelp i vår app, men en implementering skulle se ut så här:

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

Slutligen måste vi kalla autentiseringsmetoden () i instansen BiometricPrompt:

myBiometricPrompt.authenticate (promptInfo);

Implementera Android Pies biometriska autentisering

När du har slutfört alla ovanstående steg bör din MainActivity se ut så här:

import androidx.appcompat.app.AppCompatActivity; import androidx.biometric.BiometricPrompt; import android.os.Bundle; importera java.util.concurrent.Executor; importera java.util.concurrent.Executors; import androidx.fragment.app.FragmentActivity; import android.util.Log; import android.view.View; import androidx.annotation.NonNull; public class MainActivity utökar AppCompatActivity {privat statisk final String TAG = MainActivity.class.getName (); @Override skyddat tomrum onCreate (Bundle SavedInstanceState) {super.onCreate (SavedInstanceState); setContentView (R.layout.activity_main); // Skapa en trådpool med en enda tråd // Executor newExecutor = Executors.newSingleThreadExecutor (); FragmentActivity-aktivitet = detta; // Börja lyssna på autentiseringshändelser // slutlig BiometricPrompt myBiometricPrompt = new BiometricPrompt (aktivitet, newExecutor, new BiometricPrompt.AuthenticationCallback () {@Override // onAuthenticationError kallas när ett dödligt fel inträffar // public void onAuthenticationError int errorCon CharSequence errString) {super.onAuthenticationError (errorCode, errString); if (errorCode == BiometricPrompt.ERROR_NEGATIVE_BUTTON) {} annars {// Skriv ut en till Logcat // Log.d (TAG, "Ett oåterkallbart fel inträffade");}} // onAuthenticationSucceeded kallas när ett fingeravtryck matchas med framgång // @Override public void onAuthenticationSucceeded (@NonNull BiometricPrompt.AuthenticationResult result) {super.onAuthenticationSucceeded (resultat); // Skriv ut till Logcat // Log.d (TAG, "Fingerprint" erkänd framgångsrikt ");} // onAuthenticationFailed kallas när fingeravtrycket inte matchar // @Override public void onAuthenticationFailed () {super.onAuthenticationFailed (); // Skriv ut en till logg cat // Log.d (TAG, "Fingeravtryck inte igenkänt"); }}); // Skapa BiometricPrompt-instansen // final BiometricPrompt.PromptInfo promptInfo = new BiometricPrompt.PromptInfo.Builder () // Lägg till text i dialogrutan // .setTitle ("Titelteksten går här") .setSubtitle ("Undertexten går här" ) .setDescript ("Det här är beskrivningen") .setNegativeButtonText ("Avbryt") // Bygg dialogrutan //. bygga (); // Tilldela en onClickListener till appens “Autentisering” -knapp // findViewById (R.id.launchAuthentication) .setOnClickListener (ny View.OnClickListener () {@Override public void onClick (View v) {myBiometricPrompt.authenticate (promptInfo); }); }}

Testa ditt projekt

Nu har du skapat ditt projekt, det är dags att testa det och se om det faktiskt lägger till fingeravtrycksautentisering i din app!

För att köra det här projektet behöver du antingen en fysisk smartphone eller surfplatta som kör Android Pie eller en Android Virtual Device (AVD) som använder förhandsgranskningen av Android P eller senare.

Du måste också registrera minst ett fingeravtryck på din enhet. Om du använder en fysisk Android-enhet:

• Säkra din låsskärm med en PIN-kod, lösenord eller mönster om du inte redan har gjort det (genom att navigera till "Inställningar> Låsskärm och säkerhet> Skärmlåstyp> Mönster / stift / lösenord" och sedan följa instruktionerna på skärmen).
• Starta enhetens app "Inställningar".
• Välj "Lås skärm och säkerhet."
• Välj "Fingerprint scanner."
• Följ instruktionerna för att registrera en eller flera fingeravtryck.

Virtuella Android-enheter har ingen fysisk beröringssensor, så du måste simulera en beröringshändelse:

• Starta din AVD om du inte redan har gjort det.
• Vid sidan av AVD ser du en knappremsa. Hitta den tre-prickade "More" -knappen (där markören är placerad i följande skärmdump) och ge den ett klick. Detta startar fönstret "Utökade kontroller".

• I fönstret Utökade kontroller väljer du "Fingeravtryck." Detta öppnar en uppsättning kontroller, där du kan emulera olika beröringshändelser.
• Öppna rullgardinsmenyn och välj det fingeravtryck som du vill registrera på den här enheten. Jag använder "Finger 1."
• Låt oss nu växla uppmärksamheten på den emulerade enheten. Starta AVD: s "Inställningar" -applikation och välj "Säkerhet & plats."
• Om du inte redan har konfigurerat en PIN-kod, lösenord eller mönster, välj sedan "Skärmlås" och följ instruktionerna på skärmen för att säkra din låsskärm och navigera sedan tillbaka till huvudskärmen "Inställningar> Säkerhet & plats".
• Välj "Fingeravtryck" följt av "Lägg till fingeravtryck."
• Du kommer nu att bli ombedd att trycka fingret mot beröringssensorn. Istället fortsätter du att klicka på "Tryck på sensorn" tills du ser ett "Fingeravtryck lagt till".

• Klicka på "Klar."
• Om du vill registrera ytterligare fingeravtryck, skölj och upprepa stegen ovan.

När du har registrerat minst ett fingeravtryck är du redo att testa din ansökan. Jag ska testa hur vår applikation hanterar tre olika scenarier:

• Användaren försöker verifiera med ett registrerat fingeravtryck.
• Användaren försöker verifiera med ett fingeravtryck som inte är registrerat på den här enheten.
• Användaren försöker autentisera med oregistrerade fingeravtryck, flera gånger och i snabb följd.

Låt oss försöka verifiera med det fingeravtryck vi just registrerat på vår enhet:

• Se till att du tittar på Android Studios Logcat Monitor, eftersom det är där dina applikations olika s visas.

• Installera din applikation på testenheten.
• Tryck på applikationens knapp "Autentisera med fingeravtryck". Dialogrutan för fingeravtrycksautentisering visas.
• Om du använder en fysisk enhet trycker du och håller fingerspetsen mot enhetens beröringssensor. Om du använder en AVD använder du knappen "Tryck på sensorn" för att simulera en pekhändelse.
• Kontrollera Logcat Monitor. Om autentiseringen var en framgång bör du se följande: "Fingeravtryck erkänns framgångsrikt"

Låt oss därefter se vad som händer om vi försöker verifiera med ett fingeravtryck som inte är registrerat på den här enheten:

• Klicka på appens "Autentisera med fingeravtryck" -knappen igen.
• Om du använder en AVD använder du fönstret "Utökade kontroller" för att välja ett fingeravtryck som är inte registrerad på den här enheten; Jag använder "Finger 2." Ge "Tryck på sensorn" -knappen ett klick.
• Om du använder en fysisk Android-smarttelefon eller surfplatta trycker du och håller fingerspetsen mot enhetens beröringssensor - se till att du använder ett finger som inte är registrerat på den här enheten!
• Kolla in Android Studio's Logcat, den ska nu visa ett "Fingeravtryck inte igenkänt".

Som redan nämnts hanterar BiometricPrompt API automatiskt överdrivna misslyckade autentiseringsförsök. Så här testar du denna funktion:

• Klicka på appens knapp "Autentisera med fingeravtryck".
• Försök att autentisera flera gånger i snabb följd med ett oregistrerat fingeravtryck.
• Efter några försök bör dialogrutan stängas automatiskt. Kolla in Android Studio's Logcat så ser du följande: "Ett oåterkalleligt fel inträffade."

Du kan ladda ner hela applikationen från GitHub.

Avslutar

I den här artikeln utforskade vi Android Pies nya BiometricPrompt API, som låter dig enkelt lägga till fingeravtrycksautentisering i din app. Tror du att BiometricPrompt är en förbättring av Android: s tidigare fingeravtrycksautentiseringsmetoder? Låt oss veta i kommentarerna nedan!