com/android/systemui/biometrics/BiometricDialogImpl.java - platform/prebuilts/fullsdk/sources/android-29 - Git at Google

 /*
  * Copyright (C) 2018 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License
  */

 package com.android.systemui.biometrics;

 import android.content.Context;
 import android.content.pm.PackageManager;
 import android.content.res.Configuration;
 import android.hardware.biometrics.BiometricAuthenticator;
 import android.hardware.biometrics.BiometricPrompt;
 import android.hardware.biometrics.IBiometricServiceReceiverInternal;
 import android.os.Bundle;
 import android.os.Handler;
 import android.os.Looper;
 import android.os.Message;
 import android.os.RemoteException;
 import android.util.Log;
 import android.view.WindowManager;

 import com.android.internal.os.SomeArgs;
 import com.android.systemui.Dependency;
 import com.android.systemui.SystemUI;
 import com.android.systemui.keyguard.WakefulnessLifecycle;
 import com.android.systemui.statusbar.CommandQueue;

 /**
  * Receives messages sent from AuthenticationClient and shows the appropriate biometric UI (e.g.
  * BiometricDialogView).
  */
 public class BiometricDialogImpl extends SystemUI implements CommandQueue.Callbacks {
     private static final String TAG = "BiometricDialogImpl";
     private static final boolean DEBUG = true;

     private static final int MSG_SHOW_DIALOG = 1;
     private static final int MSG_BIOMETRIC_AUTHENTICATED = 2;
     private static final int MSG_BIOMETRIC_HELP = 3;
     private static final int MSG_BIOMETRIC_ERROR = 4;
     private static final int MSG_HIDE_DIALOG = 5;
     private static final int MSG_BUTTON_NEGATIVE = 6;
     private static final int MSG_USER_CANCELED = 7;
     private static final int MSG_BUTTON_POSITIVE = 8;
     private static final int MSG_TRY_AGAIN_PRESSED = 9;

     private SomeArgs mCurrentDialogArgs;
     private BiometricDialogView mCurrentDialog;
     private WindowManager mWindowManager;
     private IBiometricServiceReceiverInternal mReceiver;
     private boolean mDialogShowing;
     private Callback mCallback = new Callback();
     private WakefulnessLifecycle mWakefulnessLifecycle;

     private Handler mHandler = new Handler(Looper.getMainLooper()) {
         @Override
         public void handleMessage(Message msg) {
             switch(msg.what) {
                 case MSG_SHOW_DIALOG:
                     handleShowDialog((SomeArgs) msg.obj, false /* skipAnimation */,
                             null /* savedState */);
                     break;
                 case MSG_BIOMETRIC_AUTHENTICATED: {
                     SomeArgs args = (SomeArgs) msg.obj;
                     handleBiometricAuthenticated((boolean) args.arg1 /* authenticated */,
                             (String) args.arg2 /* failureReason */);
                     args.recycle();
                     break;
                 }
                 case MSG_BIOMETRIC_HELP: {
                     SomeArgs args = (SomeArgs) msg.obj;
                     handleBiometricHelp((String) args.arg1 /* message */);
                     args.recycle();
                     break;
                 }
                 case MSG_BIOMETRIC_ERROR:
                     handleBiometricError((String) msg.obj);
                     break;
                 case MSG_HIDE_DIALOG:
                     handleHideDialog((Boolean) msg.obj);
                     break;
                 case MSG_BUTTON_NEGATIVE:
                     handleButtonNegative();
                     break;
                 case MSG_USER_CANCELED:
                     handleUserCanceled();
                     break;
                 case MSG_BUTTON_POSITIVE:
                     handleButtonPositive();
                     break;
                 case MSG_TRY_AGAIN_PRESSED:
                     handleTryAgainPressed();
                     break;
                 default:
                     Log.w(TAG, "Unknown message: " + msg.what);
                     break;
             }
         }
     };

     private class Callback implements DialogViewCallback {
         @Override
         public void onUserCanceled() {
             mHandler.obtainMessage(MSG_USER_CANCELED).sendToTarget();
         }

         @Override
         public void onErrorShown() {
             mHandler.sendMessageDelayed(mHandler.obtainMessage(MSG_HIDE_DIALOG,
                     false /* userCanceled */), BiometricPrompt.HIDE_DIALOG_DELAY);
         }

         @Override
         public void onNegativePressed() {
             mHandler.obtainMessage(MSG_BUTTON_NEGATIVE).sendToTarget();
         }

         @Override
         public void onPositivePressed() {
             mHandler.obtainMessage(MSG_BUTTON_POSITIVE).sendToTarget();
         }

         @Override
         public void onTryAgainPressed() {
             mHandler.obtainMessage(MSG_TRY_AGAIN_PRESSED).sendToTarget();
         }
     }

     final WakefulnessLifecycle.Observer mWakefulnessObserver = new WakefulnessLifecycle.Observer() {
         @Override
         public void onStartedGoingToSleep() {
             if (mDialogShowing) {
                 if (DEBUG) Log.d(TAG, "User canceled due to screen off");
                 mHandler.obtainMessage(MSG_USER_CANCELED).sendToTarget();
             }
         }
     };

     @Override
     public void start() {
         final PackageManager pm = mContext.getPackageManager();
         if (pm.hasSystemFeature(PackageManager.FEATURE_FINGERPRINT)
                 || pm.hasSystemFeature(PackageManager.FEATURE_FACE)
                 || pm.hasSystemFeature(PackageManager.FEATURE_IRIS)) {
             getComponent(CommandQueue.class).addCallback(this);
             mWindowManager = (WindowManager) mContext.getSystemService(Context.WINDOW_SERVICE);
             mWakefulnessLifecycle = Dependency.get(WakefulnessLifecycle.class);
             mWakefulnessLifecycle.addObserver(mWakefulnessObserver);
         }
     }

     @Override
     public void showBiometricDialog(Bundle bundle, IBiometricServiceReceiverInternal receiver,
             int type, boolean requireConfirmation, int userId) {
         if (DEBUG) {
             Log.d(TAG, "showBiometricDialog, type: " + type
                     + ", requireConfirmation: " + requireConfirmation);
         }
         // Remove these messages as they are part of the previous client
         mHandler.removeMessages(MSG_BIOMETRIC_ERROR);
         mHandler.removeMessages(MSG_BIOMETRIC_HELP);
         mHandler.removeMessages(MSG_BIOMETRIC_AUTHENTICATED);
         mHandler.removeMessages(MSG_HIDE_DIALOG);
         SomeArgs args = SomeArgs.obtain();
         args.arg1 = bundle;
         args.arg2 = receiver;
         args.argi1 = type;
         args.arg3 = requireConfirmation;
         args.argi2 = userId;
         mHandler.obtainMessage(MSG_SHOW_DIALOG, args).sendToTarget();
     }

     @Override
     public void onBiometricAuthenticated(boolean authenticated, String failureReason) {
         if (DEBUG) Log.d(TAG, "onBiometricAuthenticated: " + authenticated
                 + " reason: " + failureReason);

         SomeArgs args = SomeArgs.obtain();
         args.arg1 = authenticated;
         args.arg2 = failureReason;
         mHandler.obtainMessage(MSG_BIOMETRIC_AUTHENTICATED, args).sendToTarget();
     }

     @Override
     public void onBiometricHelp(String message) {
         if (DEBUG) Log.d(TAG, "onBiometricHelp: " + message);
         SomeArgs args = SomeArgs.obtain();
         args.arg1 = message;
         mHandler.obtainMessage(MSG_BIOMETRIC_HELP, args).sendToTarget();
     }

     @Override
     public void onBiometricError(String error) {
         if (DEBUG) Log.d(TAG, "onBiometricError: " + error);
         mHandler.obtainMessage(MSG_BIOMETRIC_ERROR, error).sendToTarget();
     }

     @Override
     public void hideBiometricDialog() {
         if (DEBUG) Log.d(TAG, "hideBiometricDialog");
         mHandler.obtainMessage(MSG_HIDE_DIALOG, false /* userCanceled */).sendToTarget();
     }

     private void handleShowDialog(SomeArgs args, boolean skipAnimation, Bundle savedState) {
         mCurrentDialogArgs = args;
         final int type = args.argi1;

         // Create a new dialog but do not replace the current one yet.
         BiometricDialogView newDialog;
         if (type == BiometricAuthenticator.TYPE_FINGERPRINT) {
             newDialog = new FingerprintDialogView(mContext, mCallback);
         } else if (type == BiometricAuthenticator.TYPE_FACE) {
             newDialog = new FaceDialogView(mContext, mCallback);
         } else {
             Log.e(TAG, "Unsupported type: " + type);
             return;
         }

         if (DEBUG) Log.d(TAG, "handleShowDialog, "
                 + " savedState: " + savedState
                 + " mCurrentDialog: " + mCurrentDialog
                 + " newDialog: " + newDialog
                 + " type: " + type);

         if (savedState != null) {
             // SavedState is only non-null if it's from onConfigurationChanged. Restore the state
             // even though it may be removed / re-created again
             newDialog.restoreState(savedState);
         } else if (mCurrentDialog != null && mDialogShowing) {
             // If somehow we're asked to show a dialog, the old one doesn't need to be animated
             // away. This can happen if the app cancels and re-starts auth during configuration
             // change. This is ugly because we also have to do things on onConfigurationChanged
             // here.
             mCurrentDialog.forceRemove();
         }

         mReceiver = (IBiometricServiceReceiverInternal) args.arg2;
         newDialog.setBundle((Bundle) args.arg1);
         newDialog.setRequireConfirmation((boolean) args.arg3);
         newDialog.setUserId(args.argi2);
         newDialog.setSkipIntro(skipAnimation);
         mCurrentDialog = newDialog;
         mWindowManager.addView(mCurrentDialog, mCurrentDialog.getLayoutParams());
         mDialogShowing = true;
     }

     private void handleBiometricAuthenticated(boolean authenticated, String failureReason) {
         if (DEBUG) Log.d(TAG, "handleBiometricAuthenticated: " + authenticated);

         if (authenticated) {
             mCurrentDialog.announceForAccessibility(
                     mContext.getResources()
                             .getText(mCurrentDialog.getAuthenticatedAccessibilityResourceId()));
             if (mCurrentDialog.requiresConfirmation()) {
                 mCurrentDialog.updateState(BiometricDialogView.STATE_PENDING_CONFIRMATION);
             } else {
                 mCurrentDialog.updateState(BiometricDialogView.STATE_AUTHENTICATED);
                 mHandler.postDelayed(() -> {
                     handleHideDialog(false /* userCanceled */);
                 }, mCurrentDialog.getDelayAfterAuthenticatedDurationMs());
             }
         } else {
             mCurrentDialog.onAuthenticationFailed(failureReason);
         }
     }

     private void handleBiometricHelp(String message) {
         if (DEBUG) Log.d(TAG, "handleBiometricHelp: " + message);
         mCurrentDialog.onHelpReceived(message);
     }

     private void handleBiometricError(String error) {
         if (DEBUG) Log.d(TAG, "handleBiometricError: " + error);
         if (!mDialogShowing) {
             if (DEBUG) Log.d(TAG, "Dialog already dismissed");
             return;
         }
         mCurrentDialog.onErrorReceived(error);
     }

     private void handleHideDialog(boolean userCanceled) {
         if (DEBUG) Log.d(TAG, "handleHideDialog, userCanceled: " + userCanceled);
         if (!mDialogShowing) {
             // This can happen if there's a race and we get called from both
             // onAuthenticated and onError, etc.
             Log.w(TAG, "Dialog already dismissed, userCanceled: " + userCanceled);
             return;
         }
         if (userCanceled) {
             try {
                 mReceiver.onDialogDismissed(BiometricPrompt.DISMISSED_REASON_USER_CANCEL);
             } catch (RemoteException e) {
                 Log.e(TAG, "RemoteException when hiding dialog", e);
             }
         }
         mReceiver = null;
         mDialogShowing = false;
         mCurrentDialog.startDismiss();
     }

     private void handleButtonNegative() {
         if (mReceiver == null) {
             Log.e(TAG, "Receiver is null");
             return;
         }
         try {
             mReceiver.onDialogDismissed(BiometricPrompt.DISMISSED_REASON_NEGATIVE);
         } catch (RemoteException e) {
             Log.e(TAG, "Remote exception when handling negative button", e);
         }
         handleHideDialog(false /* userCanceled */);
     }

     private void handleButtonPositive() {
         if (mReceiver == null) {
             Log.e(TAG, "Receiver is null");
             return;
         }
         try {
             mReceiver.onDialogDismissed(BiometricPrompt.DISMISSED_REASON_POSITIVE);
         } catch (RemoteException e) {
             Log.e(TAG, "Remote exception when handling positive button", e);
         }
         handleHideDialog(false /* userCanceled */);
     }

     private void handleUserCanceled() {
         handleHideDialog(true /* userCanceled */);
     }

     private void handleTryAgainPressed() {
         try {
             mReceiver.onTryAgainPressed();
         } catch (RemoteException e) {
             Log.e(TAG, "RemoteException when handling try again", e);
         }
     }

     @Override
     protected void onConfigurationChanged(Configuration newConfig) {
         super.onConfigurationChanged(newConfig);
         final boolean wasShowing = mDialogShowing;

         // Save the state of the current dialog (buttons showing, etc)
         final Bundle savedState = new Bundle();
         if (mCurrentDialog != null) {
             mCurrentDialog.onSaveState(savedState);
         }

         if (mDialogShowing) {
             mCurrentDialog.forceRemove();
             mDialogShowing = false;
         }

         if (wasShowing) {
             handleShowDialog(mCurrentDialogArgs, true /* skipAnimation */, savedState);
         }
     }
 }
	/*
	* Copyright (C) 2018 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License
	*/

	package com.android.systemui.biometrics;

	import android.content.Context;
	import android.content.pm.PackageManager;
	import android.content.res.Configuration;
	import android.hardware.biometrics.BiometricAuthenticator;
	import android.hardware.biometrics.BiometricPrompt;
	import android.hardware.biometrics.IBiometricServiceReceiverInternal;
	import android.os.Bundle;
	import android.os.Handler;
	import android.os.Looper;
	import android.os.Message;
	import android.os.RemoteException;
	import android.util.Log;
	import android.view.WindowManager;

	import com.android.internal.os.SomeArgs;
	import com.android.systemui.Dependency;
	import com.android.systemui.SystemUI;
	import com.android.systemui.keyguard.WakefulnessLifecycle;
	import com.android.systemui.statusbar.CommandQueue;

	/**
	* Receives messages sent from AuthenticationClient and shows the appropriate biometric UI (e.g.
	* BiometricDialogView).
	*/
	public class BiometricDialogImpl extends SystemUI implements CommandQueue.Callbacks {
	private static final String TAG = "BiometricDialogImpl";
	private static final boolean DEBUG = true;

	private static final int MSG_SHOW_DIALOG = 1;
	private static final int MSG_BIOMETRIC_AUTHENTICATED = 2;
	private static final int MSG_BIOMETRIC_HELP = 3;
	private static final int MSG_BIOMETRIC_ERROR = 4;
	private static final int MSG_HIDE_DIALOG = 5;
	private static final int MSG_BUTTON_NEGATIVE = 6;
	private static final int MSG_USER_CANCELED = 7;
	private static final int MSG_BUTTON_POSITIVE = 8;
	private static final int MSG_TRY_AGAIN_PRESSED = 9;

	private SomeArgs mCurrentDialogArgs;
	private BiometricDialogView mCurrentDialog;
	private WindowManager mWindowManager;
	private IBiometricServiceReceiverInternal mReceiver;
	private boolean mDialogShowing;
	private Callback mCallback = new Callback();
	private WakefulnessLifecycle mWakefulnessLifecycle;

	private Handler mHandler = new Handler(Looper.getMainLooper()) {
	@Override
	public void handleMessage(Message msg) {
	switch(msg.what) {
	case MSG_SHOW_DIALOG:
	handleShowDialog((SomeArgs) msg.obj, false /* skipAnimation */,
	null /* savedState */);
	break;
	case MSG_BIOMETRIC_AUTHENTICATED: {
	SomeArgs args = (SomeArgs) msg.obj;
	handleBiometricAuthenticated((boolean) args.arg1 /* authenticated */,
	(String) args.arg2 /* failureReason */);
	args.recycle();
	break;
	}
	case MSG_BIOMETRIC_HELP: {
	SomeArgs args = (SomeArgs) msg.obj;
	handleBiometricHelp((String) args.arg1 /* message */);
	args.recycle();
	break;
	}
	case MSG_BIOMETRIC_ERROR:
	handleBiometricError((String) msg.obj);
	break;
	case MSG_HIDE_DIALOG:
	handleHideDialog((Boolean) msg.obj);
	break;
	case MSG_BUTTON_NEGATIVE:
	handleButtonNegative();
	break;
	case MSG_USER_CANCELED:
	handleUserCanceled();
	break;
	case MSG_BUTTON_POSITIVE:
	handleButtonPositive();
	break;
	case MSG_TRY_AGAIN_PRESSED:
	handleTryAgainPressed();
	break;
	default:
	Log.w(TAG, "Unknown message: " + msg.what);
	break;
	}
	}
	};

	private class Callback implements DialogViewCallback {
	@Override
	public void onUserCanceled() {
	mHandler.obtainMessage(MSG_USER_CANCELED).sendToTarget();
	}

	@Override
	public void onErrorShown() {
	mHandler.sendMessageDelayed(mHandler.obtainMessage(MSG_HIDE_DIALOG,
	false /* userCanceled */), BiometricPrompt.HIDE_DIALOG_DELAY);
	}

	@Override
	public void onNegativePressed() {
	mHandler.obtainMessage(MSG_BUTTON_NEGATIVE).sendToTarget();
	}

	@Override
	public void onPositivePressed() {
	mHandler.obtainMessage(MSG_BUTTON_POSITIVE).sendToTarget();
	}

	@Override
	public void onTryAgainPressed() {
	mHandler.obtainMessage(MSG_TRY_AGAIN_PRESSED).sendToTarget();
	}
	}

	final WakefulnessLifecycle.Observer mWakefulnessObserver = new WakefulnessLifecycle.Observer() {
	@Override
	public void onStartedGoingToSleep() {
	if (mDialogShowing) {
	if (DEBUG) Log.d(TAG, "User canceled due to screen off");
	mHandler.obtainMessage(MSG_USER_CANCELED).sendToTarget();
	}
	}
	};

	@Override
	public void start() {
	final PackageManager pm = mContext.getPackageManager();
	if (pm.hasSystemFeature(PackageManager.FEATURE_FINGERPRINT)
	\|\| pm.hasSystemFeature(PackageManager.FEATURE_FACE)
	\|\| pm.hasSystemFeature(PackageManager.FEATURE_IRIS)) {
	getComponent(CommandQueue.class).addCallback(this);
	mWindowManager = (WindowManager) mContext.getSystemService(Context.WINDOW_SERVICE);
	mWakefulnessLifecycle = Dependency.get(WakefulnessLifecycle.class);
	mWakefulnessLifecycle.addObserver(mWakefulnessObserver);
	}
	}

	@Override
	public void showBiometricDialog(Bundle bundle, IBiometricServiceReceiverInternal receiver,
	int type, boolean requireConfirmation, int userId) {
	if (DEBUG) {
	Log.d(TAG, "showBiometricDialog, type: " + type
	+ ", requireConfirmation: " + requireConfirmation);
	}
	// Remove these messages as they are part of the previous client
	mHandler.removeMessages(MSG_BIOMETRIC_ERROR);
	mHandler.removeMessages(MSG_BIOMETRIC_HELP);
	mHandler.removeMessages(MSG_BIOMETRIC_AUTHENTICATED);
	mHandler.removeMessages(MSG_HIDE_DIALOG);
	SomeArgs args = SomeArgs.obtain();
	args.arg1 = bundle;
	args.arg2 = receiver;
	args.argi1 = type;
	args.arg3 = requireConfirmation;
	args.argi2 = userId;
	mHandler.obtainMessage(MSG_SHOW_DIALOG, args).sendToTarget();
	}

	@Override
	public void onBiometricAuthenticated(boolean authenticated, String failureReason) {
	if (DEBUG) Log.d(TAG, "onBiometricAuthenticated: " + authenticated
	+ " reason: " + failureReason);

	SomeArgs args = SomeArgs.obtain();
	args.arg1 = authenticated;
	args.arg2 = failureReason;
	mHandler.obtainMessage(MSG_BIOMETRIC_AUTHENTICATED, args).sendToTarget();
	}

	@Override
	public void onBiometricHelp(String message) {
	if (DEBUG) Log.d(TAG, "onBiometricHelp: " + message);
	SomeArgs args = SomeArgs.obtain();
	args.arg1 = message;
	mHandler.obtainMessage(MSG_BIOMETRIC_HELP, args).sendToTarget();
	}

	@Override
	public void onBiometricError(String error) {
	if (DEBUG) Log.d(TAG, "onBiometricError: " + error);
	mHandler.obtainMessage(MSG_BIOMETRIC_ERROR, error).sendToTarget();
	}

	@Override
	public void hideBiometricDialog() {
	if (DEBUG) Log.d(TAG, "hideBiometricDialog");
	mHandler.obtainMessage(MSG_HIDE_DIALOG, false /* userCanceled */).sendToTarget();
	}

	private void handleShowDialog(SomeArgs args, boolean skipAnimation, Bundle savedState) {
	mCurrentDialogArgs = args;
	final int type = args.argi1;

	// Create a new dialog but do not replace the current one yet.
	BiometricDialogView newDialog;
	if (type == BiometricAuthenticator.TYPE_FINGERPRINT) {
	newDialog = new FingerprintDialogView(mContext, mCallback);
	} else if (type == BiometricAuthenticator.TYPE_FACE) {
	newDialog = new FaceDialogView(mContext, mCallback);
	} else {
	Log.e(TAG, "Unsupported type: " + type);
	return;
	}

	if (DEBUG) Log.d(TAG, "handleShowDialog, "
	+ " savedState: " + savedState
	+ " mCurrentDialog: " + mCurrentDialog
	+ " newDialog: " + newDialog
	+ " type: " + type);

	if (savedState != null) {
	// SavedState is only non-null if it's from onConfigurationChanged. Restore the state
	// even though it may be removed / re-created again
	newDialog.restoreState(savedState);
	} else if (mCurrentDialog != null && mDialogShowing) {
	// If somehow we're asked to show a dialog, the old one doesn't need to be animated
	// away. This can happen if the app cancels and re-starts auth during configuration
	// change. This is ugly because we also have to do things on onConfigurationChanged
	// here.
	mCurrentDialog.forceRemove();
	}

	mReceiver = (IBiometricServiceReceiverInternal) args.arg2;
	newDialog.setBundle((Bundle) args.arg1);
	newDialog.setRequireConfirmation((boolean) args.arg3);
	newDialog.setUserId(args.argi2);
	newDialog.setSkipIntro(skipAnimation);
	mCurrentDialog = newDialog;
	mWindowManager.addView(mCurrentDialog, mCurrentDialog.getLayoutParams());
	mDialogShowing = true;
	}

	private void handleBiometricAuthenticated(boolean authenticated, String failureReason) {
	if (DEBUG) Log.d(TAG, "handleBiometricAuthenticated: " + authenticated);

	if (authenticated) {
	mCurrentDialog.announceForAccessibility(
	mContext.getResources()
	.getText(mCurrentDialog.getAuthenticatedAccessibilityResourceId()));
	if (mCurrentDialog.requiresConfirmation()) {
	mCurrentDialog.updateState(BiometricDialogView.STATE_PENDING_CONFIRMATION);
	} else {
	mCurrentDialog.updateState(BiometricDialogView.STATE_AUTHENTICATED);
	mHandler.postDelayed(() -> {
	handleHideDialog(false /* userCanceled */);
	}, mCurrentDialog.getDelayAfterAuthenticatedDurationMs());
	}
	} else {
	mCurrentDialog.onAuthenticationFailed(failureReason);
	}
	}

	private void handleBiometricHelp(String message) {
	if (DEBUG) Log.d(TAG, "handleBiometricHelp: " + message);
	mCurrentDialog.onHelpReceived(message);
	}

	private void handleBiometricError(String error) {
	if (DEBUG) Log.d(TAG, "handleBiometricError: " + error);
	if (!mDialogShowing) {
	if (DEBUG) Log.d(TAG, "Dialog already dismissed");
	return;
	}
	mCurrentDialog.onErrorReceived(error);
	}

	private void handleHideDialog(boolean userCanceled) {
	if (DEBUG) Log.d(TAG, "handleHideDialog, userCanceled: " + userCanceled);
	if (!mDialogShowing) {
	// This can happen if there's a race and we get called from both
	// onAuthenticated and onError, etc.
	Log.w(TAG, "Dialog already dismissed, userCanceled: " + userCanceled);
	return;
	}
	if (userCanceled) {
	try {
	mReceiver.onDialogDismissed(BiometricPrompt.DISMISSED_REASON_USER_CANCEL);
	} catch (RemoteException e) {
	Log.e(TAG, "RemoteException when hiding dialog", e);
	}
	}
	mReceiver = null;
	mDialogShowing = false;
	mCurrentDialog.startDismiss();
	}

	private void handleButtonNegative() {
	if (mReceiver == null) {
	Log.e(TAG, "Receiver is null");
	return;
	}
	try {
	mReceiver.onDialogDismissed(BiometricPrompt.DISMISSED_REASON_NEGATIVE);
	} catch (RemoteException e) {
	Log.e(TAG, "Remote exception when handling negative button", e);
	}
	handleHideDialog(false /* userCanceled */);
	}

	private void handleButtonPositive() {
	if (mReceiver == null) {
	Log.e(TAG, "Receiver is null");
	return;
	}
	try {
	mReceiver.onDialogDismissed(BiometricPrompt.DISMISSED_REASON_POSITIVE);
	} catch (RemoteException e) {
	Log.e(TAG, "Remote exception when handling positive button", e);
	}
	handleHideDialog(false /* userCanceled */);
	}

	private void handleUserCanceled() {
	handleHideDialog(true /* userCanceled */);
	}

	private void handleTryAgainPressed() {
	try {
	mReceiver.onTryAgainPressed();
	} catch (RemoteException e) {
	Log.e(TAG, "RemoteException when handling try again", e);
	}
	}

	@Override
	protected void onConfigurationChanged(Configuration newConfig) {
	super.onConfigurationChanged(newConfig);
	final boolean wasShowing = mDialogShowing;

	// Save the state of the current dialog (buttons showing, etc)
	final Bundle savedState = new Bundle();
	if (mCurrentDialog != null) {
	mCurrentDialog.onSaveState(savedState);
	}

	if (mDialogShowing) {
	mCurrentDialog.forceRemove();
	mDialogShowing = false;
	}

	if (wasShowing) {
	handleShowDialog(mCurrentDialogArgs, true /* skipAnimation */, savedState);
	}
	}
	}