Android 6.0指纹识别App开发案例

// Using the Android Support Library v4
fingerprintManager = FingerprintManagerCompat.from(this);
// Using API level 23:
fingerprintManager = (FingerprintManager)getSystemService(Context.FINGERPRINT_SERVICE);

if (!fingerprintManager.isHardwareDetected()) {
 // no fingerprint sensor is detected, show dialog to tell user.
 AlertDialog.Builder builder = new AlertDialog.Builder(this);
 builder.setTitle(R.string.no_sensor_dialog_title);
 builder.setMessage(R.string.no_sensor_dialog_message);
 builder.setIcon(android.R.drawable.stat_sys_warning);
 builder.setCancelable(false);
 builder.setNegativeButton(R.string.cancel_btn_dialog, new DialogInterface.OnClickListener() {
 @Override
 public void onClick(DialogInterface dialog, int which) {
  finish();
 }
 });
 // show this dialog.
 builder.create().show();
}

KeyguardManager keyguardManager =(KeyguardManager)getSystemService(Context.KEYGUARD_SERVICE);
if (keyguardManager.isKeyguardSecure()) {
 // this device is secure.
}

if (!fingerprintManager.hasEnrolledFingerprints()) {
 // no fingerprint image has been enrolled.
 AlertDialog.Builder builder = new AlertDialog.Builder(this);
 builder.setTitle(R.string.no_fingerprint_enrolled_dialog_title);
 builder.setMessage(R.string.no_fingerprint_enrolled_dialog_message);
 builder.setIcon(android.R.drawable.stat_sys_warning);
 builder.setCancelable(false);
 builder.setNegativeButton(R.string.cancel_btn_dialog, new DialogInterface.OnClickListener() {
 @Override
 public void onClick(DialogInterface dialog, int which) {
  finish();
 }
 });
 // show this dialog
 builder.create().show();
}

<activity android:name=".fingerprint.FingerprintSettings" android:exported="false"/>
<activity android:name=".fingerprint.FingerprintEnrollOnboard" android:exported="false"/>
<activity android:name=".fingerprint.FingerprintEnrollFindSensor" android:exported="false"/>
<activity android:name=".fingerprint.FingerprintEnrollEnrolling" android:exported="false"/>
<activity android:name=".fingerprint.FingerprintEnrollFinish" android:exported="false"/>
<activity android:name=".fingerprint.FingerprintEnrollIntroduction" android:exported="false" />

<activity android:name=".fingerprint.SetupFingerprintEnrollOnboard" android:exported="false"/>
<activity android:name=".fingerprint.SetupFingerprintEnrollFindSensor" android:exported="false"/>
<activity android:name=".fingerprint.SetupFingerprintEnrollEnrolling" android:exported="false"/>
<activity android:name=".fingerprint.SetupFingerprintEnrollFinish" android:exported="false"/>
<activity android:name=".fingerprint.SetupFingerprintEnrollIntroduction"
 android:exported="true"
 android:permission="android.permission.MANAGE_FINGERPRINT"
 android:theme="@style/SetupWizardDisableAppStartingTheme">
 <intent-filter>
 <action android:name="android.settings.FINGERPRINT_SETUP" />
 <category android:name="android.intent.category.DEFAULT" />
 </intent-filter>
</activity>

public class CryptoObjectHelper
{
 // This can be key name you want. Should be unique for the app.
 static final String KEY_NAME = "com.createchance.android.sample.fingerprint_authentication_key";

 // We always use this keystore on Android.
 static final String KEYSTORE_NAME = "AndroidKeyStore";

 // Should be no need to change these values.
 static final String KEY_ALGORITHM = KeyProperties.KEY_ALGORITHM_AES;
 static final String BLOCK_MODE = KeyProperties.BLOCK_MODE_CBC;
 static final String ENCRYPTION_PADDING = KeyProperties.ENCRYPTION_PADDING_PKCS7;
 static final String TRANSFORMATION = KEY_ALGORITHM + "/" +
 BLOCK_MODE + "/" +
 ENCRYPTION_PADDING;
 final KeyStore _keystore;

 public CryptoObjectHelper() throws Exception
 {
 _keystore = KeyStore.getInstance(KEYSTORE_NAME);
 _keystore.load(null);
 }

 public FingerprintManagerCompat.CryptoObject buildCryptoObject() throws Exception
 {
 Cipher cipher = createCipher(true);
 return new FingerprintManagerCompat.CryptoObject(cipher);
 }

 Cipher createCipher(boolean retry) throws Exception
 {
 Key key = GetKey();
 Cipher cipher = Cipher.getInstance(TRANSFORMATION);
 try
 {
  cipher.init(Cipher.ENCRYPT_MODE | Cipher.DECRYPT_MODE, key);
 } catch(KeyPermanentlyInvalidatedException e)
 {
  _keystore.deleteEntry(KEY_NAME);
  if(retry)
  {
  createCipher(false);
  } else
  {
  throw new Exception("Could not create the cipher for fingerprint authentication.", e);
  }
 }
 return cipher;
 }

 Key GetKey() throws Exception
 {
 Key secretKey;
 if(!_keystore.isKeyEntry(KEY_NAME))
 {
  CreateKey();
 }

 secretKey = _keystore.getKey(KEY_NAME, null);
 return secretKey;
 }

 void CreateKey() throws Exception
 {
 KeyGenerator keyGen = KeyGenerator.getInstance(KEY_ALGORITHM, KEYSTORE_NAME);
 KeyGenParameterSpec keyGenSpec =
  new KeyGenParameterSpec.Builder(KEY_NAME, KeyProperties.PURPOSE_ENCRYPT | KeyProperties.PURPOSE_DECRYPT)
   .setBlockModes(BLOCK_MODE)
   .setEncryptionPaddings(ENCRYPTION_PADDING)
   .setUserAuthenticationRequired(true)
   .build();
 keyGen.init(keyGenSpec);
 keyGen.generateKey();
 }
}

CryptoObjectHelper cryptoObjectHelper = new CryptoObjectHelper();
fingerprintManager.authenticate(cryptoObjectHelper.buildCryptoObject(), 0,
    cancellationSignal, myAuthCallback, null);

package com.createchance.fingerprintdemo;

import android.os.Handler;
import android.support.v4.hardware.fingerprint.FingerprintManagerCompat;

import javax.crypto.BadPaddingException;
import javax.crypto.IllegalBlockSizeException;

/**
 * Created by baniel on 7/21/16.
 */
public class MyAuthCallback extends FingerprintManagerCompat.AuthenticationCallback {

 private Handler handler = null;

 public MyAuthCallback(Handler handler) {
 super();

 this.handler = handler;
 }

 @Override
 public void onAuthenticationError(int errMsgId, CharSequence errString) {
 super.onAuthenticationError(errMsgId, errString);

 if (handler != null) {
  handler.obtainMessage(MainActivity.MSG_AUTH_ERROR, errMsgId, 0).sendToTarget();
 }
 }

 @Override
 public void onAuthenticationHelp(int helpMsgId, CharSequence helpString) {
 super.onAuthenticationHelp(helpMsgId, helpString);

 if (handler != null) {
  handler.obtainMessage(MainActivity.MSG_AUTH_HELP, helpMsgId, 0).sendToTarget();
 }
 }

 @Override
 public void onAuthenticationSucceeded(FingerprintManagerCompat.AuthenticationResult result) {
 super.onAuthenticationSucceeded(result);

 try {
  result.getCryptoObject().getCipher().doFinal();

  if (handler != null) {
  handler.obtainMessage(MainActivity.MSG_AUTH_SUCCESS).sendToTarget();
  }
 } catch (IllegalBlockSizeException e) {
  e.printStackTrace();
 } catch (BadPaddingException e) {
  e.printStackTrace();
 }
 }

 @Override
 public void onAuthenticationFailed() {
 super.onAuthenticationFailed();

 if (handler != null) {
  handler.obtainMessage(MainActivity.MSG_AUTH_FAILED).sendToTarget();
 }
 }
}

handler = new Handler() {
 @Override
 public void handleMessage(Message msg) {
 super.handleMessage(msg);

 Log.d(TAG, "msg: " + msg.what + " ,arg1: " + msg.arg1);
 switch (msg.what) {
  case MSG_AUTH_SUCCESS:
  setResultInfo(R.string.fingerprint_success);
  mCancelBtn.setEnabled(false);
  mStartBtn.setEnabled(true);
  cancellationSignal = null;
  break;
  case MSG_AUTH_FAILED:
  setResultInfo(R.string.fingerprint_not_recognized);
  mCancelBtn.setEnabled(false);
  mStartBtn.setEnabled(true);
  cancellationSignal = null;
  break;
  case MSG_AUTH_ERROR:
  handleErrorCode(msg.arg1);
  break;
  case MSG_AUTH_HELP:
  handleHelpCode(msg.arg1);
  break;
 }
 }
};

private void handleErrorCode(int code) {
 switch (code) {
 case FingerprintManager.FINGERPRINT_ERROR_CANCELED:
  setResultInfo(R.string.ErrorCanceled_warning);
  break;
 case FingerprintManager.FINGERPRINT_ERROR_HW_UNAVAILABLE:
  setResultInfo(R.string.ErrorHwUnavailable_warning);
  break;
 case FingerprintManager.FINGERPRINT_ERROR_LOCKOUT:
  setResultInfo(R.string.ErrorLockout_warning);
  break;
 case FingerprintManager.FINGERPRINT_ERROR_NO_SPACE:
  setResultInfo(R.string.ErrorNoSpace_warning);
  break;
 case FingerprintManager.FINGERPRINT_ERROR_TIMEOUT:
  setResultInfo(R.string.ErrorTimeout_warning);
  break;
 case FingerprintManager.FINGERPRINT_ERROR_UNABLE_TO_PROCESS:
  setResultInfo(R.string.ErrorUnableToProcess_warning);
  break;
 }
}

private void handleHelpCode(int code) {
 switch (code) {
 case FingerprintManager.FINGERPRINT_ACQUIRED_GOOD:
  setResultInfo(R.string.AcquiredGood_warning);
  break;
 case FingerprintManager.FINGERPRINT_ACQUIRED_IMAGER_DIRTY:
  setResultInfo(R.string.AcquiredImageDirty_warning);
  break;
 case FingerprintManager.FINGERPRINT_ACQUIRED_INSUFFICIENT:
  setResultInfo(R.string.AcquiredInsufficient_warning);
  break;
 case FingerprintManager.FINGERPRINT_ACQUIRED_PARTIAL:
  setResultInfo(R.string.AcquiredPartial_warning);
  break;
 case FingerprintManager.FINGERPRINT_ACQUIRED_TOO_FAST:
  setResultInfo(R.string.AcquiredTooFast_warning);
  break;
 case FingerprintManager.FINGERPRINT_ACQUIRED_TOO_SLOW:
  setResultInfo(R.string.AcquiredToSlow_warning);
  break;
 }
}