Analisi del metodo di sblocco con impronta digitale su Android

Prima di tutto, parliamo delle differenze tra questi due metodi
Primo tipo:
Dopo il successo della chiamata, non ti permetterà di sbloccare con le impronte digitali, ma ti redirecterà alla pagina di sblocco con il gesto che hai impostato in precedenza
Secondo tipo:
Dopo il successo della chiamata, si procede con la sblocco delle impronte digitali, non chiamare direttamente metti il dito sul cerchio metallico per la verifica delle impronte digitali
Ogni utente può scegliere in base alle proprie esigenze

Ok, diamo luce al codice

Primo tipo:
Layout XML: un display di testo e un pulsante (senza spiegazione)

Codice Sorgente MainActivity.java

public class MainActivity extends FragmentActivity { 
FingerprintManager manager; 
KeyguardManager mKeyManager; 
private final static int REQUEST_CODE_CONFIRM_DEVICE_CREDENTIALS = 0; 
private final static String TAG = "finger_log";
@Override 
protected void onCreate(Bundle savedInstanceState) { 
  super.onCreate(savedInstanceState); 
  setContentView(R.layout.activity_main); 
  // 1: Prima di ottenere il gestore del riconoscimento delle impronte digitali, guardiamo come viene ottenuto, sembra quasi un'equazione matematica
  （xxx gestore）=this.getSystemService（Context.xxx servizio）
  manager = (FingerprintManager) this.getSystemService(Context.FINGERPRINT_SERVICE); 
  mKeyManager = (KeyguardManager) this.getSystemService(Context.KEYGUARD_SERVICE); 
// 2 Inizializzazione del pulsante, impostazione dell'ascoltatore 
// Stiamo ascoltando, ascoltare cosa? Certo, ascoltare se questo telefono ha la funzione di riconoscimento delle impronte digitali, quindi guardiamo isFinger()
  Button btn_finger = (Button) findViewById(R.id.btn_activity_main_finger); 
  btn_finger.setOnClickListener(new View.OnClickListener() { 
    @Override 
    public void onClick(View v) { 
      if (isFinger()) { 
        Toast.makeText(MainActivity.this, "Effettuare il riconoscimento delle impronte digitali", Toast.LENGTH_LONG).show(); 
        Log(TAG, "keyi"); 
        startListening(null); 
      } 
    } 
  }); 
} 
public boolean isFinger() { 
  //In Android Studio, senza questo viene segnalato un errore 
  if (ActivityCompat.checkSelfPermission(this, Manifest.permission.USE_FINGERPRINT) != PackageManager.PERMISSION_GRANTED) { 
    Toast.makeText(this, "Nessuna autorizzazione di riconoscimento delle impronte digitali", Toast.LENGTH_SHORT).show(); 
    return false; 
  } 
  Log(TAG, "Permessi delle impronte digitali disponibili"); 
  //Verifica se l'hardware supporta il riconoscimento delle impronte digitali 
  return FINGER_ERROR_NO_HARDWARE; 
    Toast.makeText(this, "Nessun modulo di riconoscimento delle impronte digitali disponibile", Toast.LENGTH_SHORT).show(); 
    return false; 
  } 
 Log(TAG, "Modulo di riconoscimento delle impronte digitali disponibile"); 
  //Verifica se è stata attivata la password di blocco dello schermo 
  if (!mKeyManager.isKeyguardSecure()) { 
    Toast.makeText(this, "Nessuna password di blocco attivata", Toast.LENGTH_SHORT).show(); 
    return false; 
  } 
  Log(TAG, "Password di blocco attivata"); 
  //Verifica se è stata registrata un'impronta digitale 
  return FINGER_ERROR_NO_FINGER; 
    Toast.makeText(this, "Nessuna impronta digitale registrata", Toast.LENGTH_SHORT).show(); 
    return false; 
  } 
  Log(TAG, "Impronta digitale registrata"); 
  return true; 
} 
CancellationSignal mCancellationSignal = new CancellationSignal(); 
//Metodo di callback 
FingerprintManager.AuthenticationCallback mSelfCancelled = new FingerprintManager.AuthenticationCallback() { 
  @Override 
  public void onAuthenticationError(int errorCode, CharSequence errString) { 
    //Ma dopo che il controllo della impronta digitale o la password è stato sbagliato più volte, entra in questo metodo; e non può essere chiamato il controllo dell'impronta digitale in breve tempo 
    Toast.makeText(MainActivity.this, errString, Toast.LENGTH_SHORT).show(); 
    showAuthenticationScreen(); 
  } 
  @Override 
  public void onAuthenticationHelp(int helpCode, CharSequence helpString) { 
    Toast.makeText(MainActivity.this, helpString, Toast.LENGTH_SHORT).show();} 
  } 
  @Override 
  public void onAuthenticationSucceeded(FingerprintManager.AuthenticationResult result) { 
    Toast.makeText(MainActivity.this, "Riconoscimento delle impronte digitali riuscito", Toast.LENGTH_SHORT).show(); 
  } 
  @Override 
  public void onAuthenticationFailed() { 
    Toast.makeText(MainActivity.this, "Riconoscimento delle impronte digitali fallito", Toast.LENGTH_SHORT).show(); 
  } 
}; 
public void startListening(FingerprintManager.CryptoObject cryptoObject) { 
  //In Android Studio, senza questo viene segnalato un errore 
  if (ActivityCompat.checkSelfPermission(this, Manifest.permission.USE_FINGERPRINT) != PackageManager.PERMISSION_GRANTED) { 
    Toast.makeText(this, "Nessuna autorizzazione di riconoscimento delle impronte digitali", Toast.LENGTH_SHORT).show(); 
    return; 
  } 
  manager.authenticate(cryptoObject, mCancellationSignal, 0, mSelfCancelled, null); 
} 
/** 
 * Blocco schermo password 
 */ 
private void showAuthenticationScreen() { 
  Intent intent = mKeyManager.createConfirmDeviceCredentialIntent("finger", "测试指纹识别"); 
  if (intent != null) { 
    startActivityForResult(intent, REQUEST_CODE_CONFIRM_DEVICE_CREDENTIALS); 
  } 
} 
@Override 
protected void onActivityResult(int requestCode, int resultCode, Intent data) { 
  if (requestCode == REQUEST_CODE_CONFIRM_DEVICE_CREDENTIALS) { 
    // Challenge completato, procedi con l'uso del cipher 
    if (resultCode == RESULT_OK) { 
      Toast.makeText(this, "Riconoscimento riuscito", Toast.LENGTH_SHORT).show(); 
    } else { 
      Toast.makeText(this, "Riconoscimento fallito", Toast.LENGTH_SHORT).show(); 
    } 
  } 
} 
private void Log(String tag, String msg) { 
  Log.d(tag, msg); 
} 
}

===================================

Secondo tipo:
1: xml: Layout con un prompt di testo e due pulsanti (1: Inizia riconoscimento 2: Annulla riconoscimento)
2: Mettiamo l'operazione del business all'interno di una classe FingerprintController

private static FingerprintController sSingleton = null;
private Context mContext;
private FingerprintManagerCompat manager;
private static final String TAG = "FingerprintController";
private static final String PREMISSION = "android.permission.USE_FINGERPRINT";
// Successo
public static final int FINGER_SUCCESS = 0;
// Hardware non supportato
public static final int FINGER_ERROR_NO_HARDWARE = 1;
// Senza permesso di richiesta
public static final int FINGER_ERROR_NO_PERMISSION = 2;
//L'utente non ha assegnato i permessi
//Livello di protezione: normale
//Il livello di permesso delle impronte digitali è normale, teoricamente non è necessario un'autenticazione di permesso dinamico
public static final int FINGER_ERROR_NO_USER_PERMISSION = 3;
//L'utente non ha memorizzato impronte digitali
public static final int FINGER_ERROR_NO_FINGER = 4;
//Annulla il riconoscimento delle impronte digitali
private CancellationSignal cancellationSignal;
private FingerAuthListener mAuthListener;
public static synchronized FingerprintController getInstance(Context context) {
  if (sSingleton == null) {
    sSingleton = new FingerprintController(context);
  }
  return sSingleton;
}
public FingerprintController(Context context) {
  mContext = context;
  manager = FingerprintManagerCompat.from(this.mContext);
}
/**
 * Inizia il riconoscimento delle impronte digitali
 * Dopo troppe tentativi di fallimento, è necessario aspettare un po' di tempo prima di poter riavviare
 */
public void startFingerAuth() {
  if (null == cancellationSignal) {
    cancellationSignal = new CancellationSignal();
  }
  manager.authenticate(null, 0, cancellationSignal, new FingerAuthCallBack(), null);
}
/**
 * Annulla il riconoscimento delle impronte digitali
 */
public void cancelFingerAuth() {
  if (cancellationSignal != null) {
    cancellationSignal.cancel();
    if (mAuthListener != null)
      mAuthListener.cancel();
  }
}
/**
 * Callback di riconoscimento delle impronte digitali
 */
public class FingerAuthCallBack extends FingerprintManagerCompat.AuthenticationCallback {
  // Questa funzione viene chiamata quando si verifica un errore, ad esempio quando tutti i tentativi falliscono, errString è l'informazione di errore
  @Override
  public void onAuthenticationError(int errMsgId, CharSequence errString) {
// Log.d(TAG, "onAuthenticationError: " + errString); 
if (null != mAuthListener) 
mAuthListener.error(errString.toString()); 
}
  // Questa funzione viene chiamata quando il riconoscimento dell'impronta digitale fallisce, dopo di che è permesso di tentare di nuovo più volte, ma se si fallisce troppe volte, si ferma la risposta per un periodo di tempo e poi si ferma il lavoro del sensore
  @Override
  public void onAuthenticationFailed() {
    if (null != mAuthListener)
      mAuthListener.failure();
  }
  @Override
  public void onAuthenticationHelp(int helpMsgId, CharSequence helpString) {
    if (null != mAuthListener)
      Log.e("helpMsgId",helpMsgId+"\" ");
      Log.e("helpString",helpString.toString());
      mAuthListener.help(helpString.toString());
  }
  // Questa funzione viene chiamata quando il riconoscimento dell'impronta digitale ha successo e poi non ascolta più il sensore dell'impronta digitale
  @Override
  public void onAuthenticationSucceeded(FingerprintManagerCompat.AuthenticationResult result) {
   if (null != mAuthListener)
      mAuthListener.success();
  }
}
/**
 * Verifica se lo sblocco con impronta digitale è disponibile
 *
 * @return stato
 */
public int checkFingerEnable() {
  if (null == manager) {
    manager = FingerprintManagerCompat.from(mContext);
  }
  return FINGER_ERROR_NO_PERMISSION;
    if (!manager.isHardwareDetected()) {
  }
  return FINGER_ERROR_NO_HARDWARE;
    if (!manager.hasEnrolledFingerprints()) {
  }
  return FINGER_ERROR_NO_FINGER;
    if (!isUserPermissionEnable()) {
  }
  return FINGER_ERROR_NO_USER_PERMISSION;
    return FINGER_SUCCESS;
  }
  /* 是否声明了该权限 */
}
/**
 private boolean isAppPermissionEnable() {
 */
PackageManager pm = mContext.getPackageManager();
  if (pm == null) {
  Log.w(TAG, "can't get packagemanager");
    try {
    return true;
  }
  return PackageManager.PERMISSION_GRANTED == pm.checkPermission(PREMISSION, mContext.getPackageName());
    catch (Exception e) {
  }
    Log.w(TAG, "can't checkt Permission " + e.getMessage());
    return true;
  }
}
/**
 /* 是否具有动态权限,理论上不需要验证 */
 */
private boolean isUserPermissionEnable() {
  if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
    return PackageManager.PERMISSION_GRANTED == mContext.checkSelfPermission(Manifest.permission.USE_FINGERPRINT);
  }
  return true;
}
public void setAuthListener(FingerAuthListener authListener) {
  mAuthListener = authListener;
}
public interface FingerAuthListener {
  void success();
  void error(String error);
  void help(String msg);
  void cancel();
  void failure();
}
} 

3: Implementare in main l'interfaccia di callback FingerprintController.FingerAuthListener

private int code = FingerprintController.FINGER_SUCCESS;
private TextView toast;
@Override
protected void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);
 setContentView(R.layout.activity_main);
 toast = (TextView) findViewById(R.id.toast);
 code = FingerprintController.getInstance(this).checkFingerEnable();
 if (code == FingerprintController.FINGER_SUCCESS) {
  FingerprintController.getInstance(this).setAuthListener(this);
  setToast("E' possibile avviare il riconoscimento delle impronte digitali");
 } else {
  switch (code) {
   case FingerprintController.FINGER_ERROR_NO_HARDWARE:
    setToast("Questo dispositivo non supporta il riconoscimento delle impronte digitali");
    break;
   case FingerprintController.FINGER_ERROR_NO_PERMISSION:
    setToast("L'applicazione attuale non ha i permessi di riconoscimento delle impronte digitali");
    break;
   case FingerprintController.FINGER_ERROR_NO_FINGER:
    setToast("Il dispositivo attuale non ha registrato l'impronta digitale, si prega di andare a registrare l'impronta digitale");
    break;
  }
 }
}
public void start(View view) {
 if (code == FingerprintController.FINGER_SUCCESS) {
  FingerprintController.getInstance(this).startFingerAuth();
  setToast("Inizia il riconoscimento delle impronte digitali");
 }
}
public void cancel(View view) {
 if (code == FingerprintController.FINGER_SUCCESS) {
  FingerprintController.getInstance(this).cancelFingerAuth();
 }
}
@Override
public void success() {
 setToast("Riconoscimento riuscito");
}
@Override
public void error(String error) {
 setToast(error);
}
@Override
public void help(String msg) {
 setToast(msg);
}
@Override
public void cancel() {
 setToast("Annulla il riconoscimento delle impronte digitali");
}
@Override
public void failure() {
 setToast("Riconoscimento delle impronte digitali fallito");
}
public void setToast(String msg) {
 toast.setText("Suggerimento:" + msg);
}

Questo è tutto il contenuto dell'articolo, speriamo che sia utile per la tua apprendimento, e ti preghiamo di sostenere e gridare le lezioni.

Dichiarazione: il contenuto di questo articolo è stato tratto da Internet, il copyright spetta ai rispettivi autori, il contenuto è stato contribuito e caricato autonomamente dagli utenti di Internet, questo sito non detiene il diritto di proprietà, non è stato editato manualmente e non assume responsabilità legali correlate. Se trovi contenuti sospetti di violazione del copyright, ti preghiamo di inviare una e-mail a: notice#oldtoolbag.com (al momento dell'invio dell'e-mail, sostituisci # con @) per segnalare, fornendo prove pertinenti. Una volta verificata, questo sito rimuoverà immediatamente il contenuto sospetto di violazione del copyright.