packages/Keyguard/src/com/android/keyguard/KeyguardFaceUnlockView.java - platform/frameworks/base - Git at Google

 /*
  * Copyright (C) 2012 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.keyguard;

 import android.content.Context;
 import android.graphics.drawable.Drawable;
 import android.os.RemoteException;
 import android.os.ServiceManager;
 import android.telephony.TelephonyManager;
 import android.util.AttributeSet;
 import android.util.Log;
 import android.view.IRotationWatcher;
 import android.view.IWindowManager;
 import android.view.View;
 import android.widget.ImageButton;
 import android.widget.LinearLayout;

 import com.android.internal.widget.LockPatternUtils;

 import java.lang.Math;

 public class KeyguardFaceUnlockView extends LinearLayout implements KeyguardSecurityView {

     private static final String TAG = "FULKeyguardFaceUnlockView";
     private static final boolean DEBUG = KeyguardConstants.DEBUG;
     private KeyguardSecurityCallback mKeyguardSecurityCallback;
     private LockPatternUtils mLockPatternUtils;
     private BiometricSensorUnlock mBiometricUnlock;
     private View mFaceUnlockAreaView;
     private ImageButton mCancelButton;
     private SecurityMessageDisplay mSecurityMessageDisplay;
     private View mEcaView;
     private Drawable mBouncerFrame;

     private boolean mIsBouncerVisibleToUser = false;
     private final Object mIsBouncerVisibleToUserLock = new Object();

     private int mLastRotation;
     private boolean mWatchingRotation;
     private final IWindowManager mWindowManager =
             IWindowManager.Stub.asInterface(ServiceManager.getService("window"));

     private final IRotationWatcher mRotationWatcher = new IRotationWatcher.Stub() {
         public void onRotationChanged(int rotation) {
             if (DEBUG) Log.d(TAG, "onRotationChanged(): " + mLastRotation + "->" + rotation);

             // If the difference between the new rotation value and the previous rotation value is
             // equal to 2, the rotation change was 180 degrees.  This stops the biometric unlock
             // and starts it in the new position.  This is not performed for 90 degree rotations
             // since a 90 degree rotation is a configuration change, which takes care of this for
             // us.
             if (Math.abs(rotation - mLastRotation) == 2) {
                 if (mBiometricUnlock != null) {
                     mBiometricUnlock.stop();
                     maybeStartBiometricUnlock();
                 }
             }
             mLastRotation = rotation;
         }
     };

     public KeyguardFaceUnlockView(Context context) {
         this(context, null);
     }

     public KeyguardFaceUnlockView(Context context, AttributeSet attrs) {
         super(context, attrs);
     }

     @Override
     protected void onFinishInflate() {
         super.onFinishInflate();

         initializeBiometricUnlockView();

         mSecurityMessageDisplay = new KeyguardMessageArea.Helper(this);
         mEcaView = findViewById(R.id.keyguard_selector_fade_container);
         View bouncerFrameView = findViewById(R.id.keyguard_bouncer_frame);
         if (bouncerFrameView != null) {
             mBouncerFrame = bouncerFrameView.getBackground();
         }
     }

     @Override
     public void setKeyguardCallback(KeyguardSecurityCallback callback) {
         mKeyguardSecurityCallback = callback;
         // TODO: formalize this in the interface or factor it out
         ((FaceUnlock)mBiometricUnlock).setKeyguardCallback(callback);
     }

     @Override
     public void setLockPatternUtils(LockPatternUtils utils) {
         mLockPatternUtils = utils;
     }

     @Override
     public void reset() {

     }

     @Override
     public void onDetachedFromWindow() {
         if (DEBUG) Log.d(TAG, "onDetachedFromWindow()");
         if (mBiometricUnlock != null) {
             mBiometricUnlock.stop();
         }
         KeyguardUpdateMonitor.getInstance(mContext).removeCallback(mUpdateCallback);
         if (mWatchingRotation) {
             try {
                 mWindowManager.removeRotationWatcher(mRotationWatcher);
                 mWatchingRotation = false;
             } catch (RemoteException e) {
                 Log.e(TAG, "Remote exception when removing rotation watcher");
             }
         }
     }

     @Override
     public void onPause() {
         if (DEBUG) Log.d(TAG, "onPause()");
         if (mBiometricUnlock != null) {
             mBiometricUnlock.stop();
         }
         KeyguardUpdateMonitor.getInstance(mContext).removeCallback(mUpdateCallback);
         if (mWatchingRotation) {
             try {
                 mWindowManager.removeRotationWatcher(mRotationWatcher);
                 mWatchingRotation = false;
             } catch (RemoteException e) {
                 Log.e(TAG, "Remote exception when removing rotation watcher");
             }
         }
     }

     @Override
     public void onResume(int reason) {
         if (DEBUG) Log.d(TAG, "onResume()");
         synchronized (mIsBouncerVisibleToUserLock) {
             mIsBouncerVisibleToUser = isBouncerVisibleToUser();
         }
         KeyguardUpdateMonitor.getInstance(mContext).registerCallback(mUpdateCallback);

         // Registers a callback which handles stopping the biometric unlock and restarting it in
         // the new position for a 180 degree rotation change.
         if (!mWatchingRotation) {
             try {
                 mLastRotation = mWindowManager.watchRotation(mRotationWatcher);
                 mWatchingRotation = true;
             } catch (RemoteException e) {
                 Log.e(TAG, "Remote exception when adding rotation watcher");
             }
         }
     }

     @Override
     public boolean needsInput() {
         return false;
     }

     @Override
     public KeyguardSecurityCallback getCallback() {
         return mKeyguardSecurityCallback;
     }

     @Override
     protected void onLayout(boolean changed, int l, int t, int r, int b) {
         super.onLayout(changed, l, t, r, b);
         mBiometricUnlock.initializeView(mFaceUnlockAreaView);
     }

     private void initializeBiometricUnlockView() {
         if (DEBUG) Log.d(TAG, "initializeBiometricUnlockView()");
         mFaceUnlockAreaView = findViewById(R.id.face_unlock_area_view);
         if (mFaceUnlockAreaView != null) {
             mBiometricUnlock = new FaceUnlock(mContext);

             mCancelButton = (ImageButton) findViewById(R.id.face_unlock_cancel_button);
             mCancelButton.setOnClickListener(new OnClickListener() {
                 @Override
                 public void onClick(View v) {
                     mBiometricUnlock.stopAndShowBackup();
                 }
             });
         } else {
             Log.w(TAG, "Couldn't find biometric unlock view");
         }
     }

     /**
      * Starts the biometric unlock if it should be started based on a number of factors.  If it
      * should not be started, it either goes to the back up, or remains showing to prepare for
      * it being started later.
      */
     private void maybeStartBiometricUnlock() {
         if (DEBUG) Log.d(TAG, "maybeStartBiometricUnlock()");
         if (mBiometricUnlock != null) {
             KeyguardUpdateMonitor monitor = KeyguardUpdateMonitor.getInstance(mContext);
             final boolean backupIsTimedOut = (
                     monitor.getFailedUnlockAttempts() >=
                     LockPatternUtils.FAILED_ATTEMPTS_BEFORE_TIMEOUT);

             boolean isBouncerVisibleToUser;
             synchronized(mIsBouncerVisibleToUserLock) {
                 isBouncerVisibleToUser = mIsBouncerVisibleToUser;
             }

             // Don't start it if the bouncer is not showing, but keep this view up because we want
             // it here and ready for when the bouncer does show.
             if (!isBouncerVisibleToUser) {
                 mBiometricUnlock.stop(); // It shouldn't be running but calling this can't hurt.
                 return;
             }

             // Although these same conditions are handled in KeyguardSecurityModel, they are still
             // necessary here.  When a tablet is rotated 90 degrees, a configuration change is
             // triggered and everything is torn down and reconstructed.  That means
             // KeyguardSecurityModel gets a chance to take care of the logic and doesn't even
             // reconstruct KeyguardFaceUnlockView if the biometric unlock should be suppressed.
             // However, for a 180 degree rotation, no configuration change is triggered, so only
             // the logic here is capable of suppressing Face Unlock.
             if (monitor.getPhoneState() == TelephonyManager.CALL_STATE_IDLE
                     && monitor.isAlternateUnlockEnabled()
                     && !monitor.getMaxBiometricUnlockAttemptsReached()
                     && !backupIsTimedOut) {
                 mBiometricUnlock.start();
             } else {
                 mBiometricUnlock.stopAndShowBackup();
             }
         }
     }

     // Returns true if the device is currently in a state where the user is seeing the bouncer.
     // This requires isKeyguardBouncer() to be true, but that doesn't imply that the screen is on or
     // the keyguard visibility is set to true, so we must check those conditions as well.
     private boolean isBouncerVisibleToUser() {
         KeyguardUpdateMonitor updateMonitor = KeyguardUpdateMonitor.getInstance(mContext);
         return updateMonitor.isKeyguardBouncer() && updateMonitor.isKeyguardVisible() &&
                 updateMonitor.isScreenOn();
     }

     // Starts the biometric unlock if the bouncer was not previously visible to the user, but is now
     // visibile to the user.  Stops the biometric unlock if the bouncer was previously visible to
     // the user, but is no longer visible to the user.
     private void handleBouncerUserVisibilityChanged() {
         boolean wasBouncerVisibleToUser;
         synchronized(mIsBouncerVisibleToUserLock) {
             wasBouncerVisibleToUser = mIsBouncerVisibleToUser;
             mIsBouncerVisibleToUser = isBouncerVisibleToUser();
         }

         if (mBiometricUnlock != null) {
             if (wasBouncerVisibleToUser && !mIsBouncerVisibleToUser) {
                 mBiometricUnlock.stop();
             } else if (!wasBouncerVisibleToUser && mIsBouncerVisibleToUser) {
                 maybeStartBiometricUnlock();
             }
         }
     }

     KeyguardUpdateMonitorCallback mUpdateCallback = new KeyguardUpdateMonitorCallback() {
         // We need to stop the biometric unlock when a phone call comes in
         @Override
         public void onPhoneStateChanged(int phoneState) {
             if (DEBUG) Log.d(TAG, "onPhoneStateChanged(" + phoneState + ")");
             if (phoneState == TelephonyManager.CALL_STATE_RINGING) {
                 if (mBiometricUnlock != null) {
                     mBiometricUnlock.stopAndShowBackup();
                 }
             }
         }

         @Override
         public void onUserSwitching(int userId) {
             if (DEBUG) Log.d(TAG, "onUserSwitched(" + userId + ")");
             if (mBiometricUnlock != null) {
                 mBiometricUnlock.stop();
             }
             // No longer required; static value set by KeyguardViewMediator
             // mLockPatternUtils.setCurrentUser(userId);
         }

         @Override
         public void onUserSwitchComplete(int userId) {
             if (DEBUG) Log.d(TAG, "onUserSwitchComplete(" + userId + ")");
             if (mBiometricUnlock != null) {
                 maybeStartBiometricUnlock();
             }
         }

         @Override
         public void onKeyguardVisibilityChanged(boolean showing) {
             if (DEBUG) Log.d(TAG, "onKeyguardVisibilityChanged(" + showing + ")");
             handleBouncerUserVisibilityChanged();
         }

         @Override
         public void onKeyguardBouncerChanged(boolean bouncer) {
             if (DEBUG) Log.d(TAG, "onKeyguardBouncerChanged(" + bouncer + ")");
             handleBouncerUserVisibilityChanged();
         }

         @Override
         public void onScreenTurnedOn() {
             if (DEBUG) Log.d(TAG, "onScreenTurnedOn()");
             handleBouncerUserVisibilityChanged();
         }

         @Override
         public void onScreenTurnedOff(int why) {
             if (DEBUG) Log.d(TAG, "onScreenTurnedOff()");
             handleBouncerUserVisibilityChanged();
         }

         @Override
         public void onEmergencyCallAction() {
             if (mBiometricUnlock != null) {
                 mBiometricUnlock.stop();
             }
         }
     };

     @Override
     public void showUsabilityHint() {
     }

     @Override
     public void showBouncer(int duration) {
         KeyguardSecurityViewHelper.
                 showBouncer(mSecurityMessageDisplay, mEcaView, mBouncerFrame, duration);
     }

     @Override
     public void hideBouncer(int duration) {
         KeyguardSecurityViewHelper.
                 hideBouncer(mSecurityMessageDisplay, mEcaView, mBouncerFrame, duration);
     }

     @Override
     public void startAppearAnimation() {
         // TODO.
     }

     @Override
     public boolean startDisappearAnimation(Runnable finishRunnable) {
         return false;
     }
 }
	/*
	* Copyright (C) 2012 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.keyguard;

	import android.content.Context;
	import android.graphics.drawable.Drawable;
	import android.os.RemoteException;
	import android.os.ServiceManager;
	import android.telephony.TelephonyManager;
	import android.util.AttributeSet;
	import android.util.Log;
	import android.view.IRotationWatcher;
	import android.view.IWindowManager;
	import android.view.View;
	import android.widget.ImageButton;
	import android.widget.LinearLayout;

	import com.android.internal.widget.LockPatternUtils;

	import java.lang.Math;

	public class KeyguardFaceUnlockView extends LinearLayout implements KeyguardSecurityView {

	private static final String TAG = "FULKeyguardFaceUnlockView";
	private static final boolean DEBUG = KeyguardConstants.DEBUG;
	private KeyguardSecurityCallback mKeyguardSecurityCallback;
	private LockPatternUtils mLockPatternUtils;
	private BiometricSensorUnlock mBiometricUnlock;
	private View mFaceUnlockAreaView;
	private ImageButton mCancelButton;
	private SecurityMessageDisplay mSecurityMessageDisplay;
	private View mEcaView;
	private Drawable mBouncerFrame;

	private boolean mIsBouncerVisibleToUser = false;
	private final Object mIsBouncerVisibleToUserLock = new Object();

	private int mLastRotation;
	private boolean mWatchingRotation;
	private final IWindowManager mWindowManager =
	IWindowManager.Stub.asInterface(ServiceManager.getService("window"));

	private final IRotationWatcher mRotationWatcher = new IRotationWatcher.Stub() {
	public void onRotationChanged(int rotation) {
	if (DEBUG) Log.d(TAG, "onRotationChanged(): " + mLastRotation + "->" + rotation);

	// If the difference between the new rotation value and the previous rotation value is
	// equal to 2, the rotation change was 180 degrees. This stops the biometric unlock
	// and starts it in the new position. This is not performed for 90 degree rotations
	// since a 90 degree rotation is a configuration change, which takes care of this for
	// us.
	if (Math.abs(rotation - mLastRotation) == 2) {
	if (mBiometricUnlock != null) {
	mBiometricUnlock.stop();
	maybeStartBiometricUnlock();
	}
	}
	mLastRotation = rotation;
	}
	};

	public KeyguardFaceUnlockView(Context context) {
	this(context, null);
	}

	public KeyguardFaceUnlockView(Context context, AttributeSet attrs) {
	super(context, attrs);
	}

	@Override
	protected void onFinishInflate() {
	super.onFinishInflate();

	initializeBiometricUnlockView();

	mSecurityMessageDisplay = new KeyguardMessageArea.Helper(this);
	mEcaView = findViewById(R.id.keyguard_selector_fade_container);
	View bouncerFrameView = findViewById(R.id.keyguard_bouncer_frame);
	if (bouncerFrameView != null) {
	mBouncerFrame = bouncerFrameView.getBackground();
	}
	}

	@Override
	public void setKeyguardCallback(KeyguardSecurityCallback callback) {
	mKeyguardSecurityCallback = callback;
	// TODO: formalize this in the interface or factor it out
	((FaceUnlock)mBiometricUnlock).setKeyguardCallback(callback);
	}

	@Override
	public void setLockPatternUtils(LockPatternUtils utils) {
	mLockPatternUtils = utils;
	}

	@Override
	public void reset() {

	}

	@Override
	public void onDetachedFromWindow() {
	if (DEBUG) Log.d(TAG, "onDetachedFromWindow()");
	if (mBiometricUnlock != null) {
	mBiometricUnlock.stop();
	}
	KeyguardUpdateMonitor.getInstance(mContext).removeCallback(mUpdateCallback);
	if (mWatchingRotation) {
	try {
	mWindowManager.removeRotationWatcher(mRotationWatcher);
	mWatchingRotation = false;
	} catch (RemoteException e) {
	Log.e(TAG, "Remote exception when removing rotation watcher");
	}
	}
	}

	@Override
	public void onPause() {
	if (DEBUG) Log.d(TAG, "onPause()");
	if (mBiometricUnlock != null) {
	mBiometricUnlock.stop();
	}
	KeyguardUpdateMonitor.getInstance(mContext).removeCallback(mUpdateCallback);
	if (mWatchingRotation) {
	try {
	mWindowManager.removeRotationWatcher(mRotationWatcher);
	mWatchingRotation = false;
	} catch (RemoteException e) {
	Log.e(TAG, "Remote exception when removing rotation watcher");
	}
	}
	}

	@Override
	public void onResume(int reason) {
	if (DEBUG) Log.d(TAG, "onResume()");
	synchronized (mIsBouncerVisibleToUserLock) {
	mIsBouncerVisibleToUser = isBouncerVisibleToUser();
	}
	KeyguardUpdateMonitor.getInstance(mContext).registerCallback(mUpdateCallback);

	// Registers a callback which handles stopping the biometric unlock and restarting it in
	// the new position for a 180 degree rotation change.
	if (!mWatchingRotation) {
	try {
	mLastRotation = mWindowManager.watchRotation(mRotationWatcher);
	mWatchingRotation = true;
	} catch (RemoteException e) {
	Log.e(TAG, "Remote exception when adding rotation watcher");
	}
	}
	}

	@Override
	public boolean needsInput() {
	return false;
	}

	@Override
	public KeyguardSecurityCallback getCallback() {
	return mKeyguardSecurityCallback;
	}

	@Override
	protected void onLayout(boolean changed, int l, int t, int r, int b) {
	super.onLayout(changed, l, t, r, b);
	mBiometricUnlock.initializeView(mFaceUnlockAreaView);
	}

	private void initializeBiometricUnlockView() {
	if (DEBUG) Log.d(TAG, "initializeBiometricUnlockView()");
	mFaceUnlockAreaView = findViewById(R.id.face_unlock_area_view);
	if (mFaceUnlockAreaView != null) {
	mBiometricUnlock = new FaceUnlock(mContext);

	mCancelButton = (ImageButton) findViewById(R.id.face_unlock_cancel_button);
	mCancelButton.setOnClickListener(new OnClickListener() {
	@Override
	public void onClick(View v) {
	mBiometricUnlock.stopAndShowBackup();
	}
	});
	} else {
	Log.w(TAG, "Couldn't find biometric unlock view");
	}
	}

	/**
	* Starts the biometric unlock if it should be started based on a number of factors. If it
	* should not be started, it either goes to the back up, or remains showing to prepare for
	* it being started later.
	*/
	private void maybeStartBiometricUnlock() {
	if (DEBUG) Log.d(TAG, "maybeStartBiometricUnlock()");
	if (mBiometricUnlock != null) {
	KeyguardUpdateMonitor monitor = KeyguardUpdateMonitor.getInstance(mContext);
	final boolean backupIsTimedOut = (
	monitor.getFailedUnlockAttempts() >=
	LockPatternUtils.FAILED_ATTEMPTS_BEFORE_TIMEOUT);

	boolean isBouncerVisibleToUser;
	synchronized(mIsBouncerVisibleToUserLock) {
	isBouncerVisibleToUser = mIsBouncerVisibleToUser;
	}

	// Don't start it if the bouncer is not showing, but keep this view up because we want
	// it here and ready for when the bouncer does show.
	if (!isBouncerVisibleToUser) {
	mBiometricUnlock.stop(); // It shouldn't be running but calling this can't hurt.
	return;
	}

	// Although these same conditions are handled in KeyguardSecurityModel, they are still
	// necessary here. When a tablet is rotated 90 degrees, a configuration change is
	// triggered and everything is torn down and reconstructed. That means
	// KeyguardSecurityModel gets a chance to take care of the logic and doesn't even
	// reconstruct KeyguardFaceUnlockView if the biometric unlock should be suppressed.
	// However, for a 180 degree rotation, no configuration change is triggered, so only
	// the logic here is capable of suppressing Face Unlock.
	if (monitor.getPhoneState() == TelephonyManager.CALL_STATE_IDLE
	&& monitor.isAlternateUnlockEnabled()
	&& !monitor.getMaxBiometricUnlockAttemptsReached()
	&& !backupIsTimedOut) {
	mBiometricUnlock.start();
	} else {
	mBiometricUnlock.stopAndShowBackup();
	}
	}
	}

	// Returns true if the device is currently in a state where the user is seeing the bouncer.
	// This requires isKeyguardBouncer() to be true, but that doesn't imply that the screen is on or
	// the keyguard visibility is set to true, so we must check those conditions as well.
	private boolean isBouncerVisibleToUser() {
	KeyguardUpdateMonitor updateMonitor = KeyguardUpdateMonitor.getInstance(mContext);
	return updateMonitor.isKeyguardBouncer() && updateMonitor.isKeyguardVisible() &&
	updateMonitor.isScreenOn();
	}

	// Starts the biometric unlock if the bouncer was not previously visible to the user, but is now
	// visibile to the user. Stops the biometric unlock if the bouncer was previously visible to
	// the user, but is no longer visible to the user.
	private void handleBouncerUserVisibilityChanged() {
	boolean wasBouncerVisibleToUser;
	synchronized(mIsBouncerVisibleToUserLock) {
	wasBouncerVisibleToUser = mIsBouncerVisibleToUser;
	mIsBouncerVisibleToUser = isBouncerVisibleToUser();
	}

	if (mBiometricUnlock != null) {
	if (wasBouncerVisibleToUser && !mIsBouncerVisibleToUser) {
	mBiometricUnlock.stop();
	} else if (!wasBouncerVisibleToUser && mIsBouncerVisibleToUser) {
	maybeStartBiometricUnlock();
	}
	}
	}

	KeyguardUpdateMonitorCallback mUpdateCallback = new KeyguardUpdateMonitorCallback() {
	// We need to stop the biometric unlock when a phone call comes in
	@Override
	public void onPhoneStateChanged(int phoneState) {
	if (DEBUG) Log.d(TAG, "onPhoneStateChanged(" + phoneState + ")");
	if (phoneState == TelephonyManager.CALL_STATE_RINGING) {
	if (mBiometricUnlock != null) {
	mBiometricUnlock.stopAndShowBackup();
	}
	}
	}

	@Override
	public void onUserSwitching(int userId) {
	if (DEBUG) Log.d(TAG, "onUserSwitched(" + userId + ")");
	if (mBiometricUnlock != null) {
	mBiometricUnlock.stop();
	}
	// No longer required; static value set by KeyguardViewMediator
	// mLockPatternUtils.setCurrentUser(userId);
	}

	@Override
	public void onUserSwitchComplete(int userId) {
	if (DEBUG) Log.d(TAG, "onUserSwitchComplete(" + userId + ")");
	if (mBiometricUnlock != null) {
	maybeStartBiometricUnlock();
	}
	}

	@Override
	public void onKeyguardVisibilityChanged(boolean showing) {
	if (DEBUG) Log.d(TAG, "onKeyguardVisibilityChanged(" + showing + ")");
	handleBouncerUserVisibilityChanged();
	}

	@Override
	public void onKeyguardBouncerChanged(boolean bouncer) {
	if (DEBUG) Log.d(TAG, "onKeyguardBouncerChanged(" + bouncer + ")");
	handleBouncerUserVisibilityChanged();
	}

	@Override
	public void onScreenTurnedOn() {
	if (DEBUG) Log.d(TAG, "onScreenTurnedOn()");
	handleBouncerUserVisibilityChanged();
	}

	@Override
	public void onScreenTurnedOff(int why) {
	if (DEBUG) Log.d(TAG, "onScreenTurnedOff()");
	handleBouncerUserVisibilityChanged();
	}

	@Override
	public void onEmergencyCallAction() {
	if (mBiometricUnlock != null) {
	mBiometricUnlock.stop();
	}
	}
	};

	@Override
	public void showUsabilityHint() {
	}

	@Override
	public void showBouncer(int duration) {
	KeyguardSecurityViewHelper.
	showBouncer(mSecurityMessageDisplay, mEcaView, mBouncerFrame, duration);
	}

	@Override
	public void hideBouncer(int duration) {
	KeyguardSecurityViewHelper.
	hideBouncer(mSecurityMessageDisplay, mEcaView, mBouncerFrame, duration);
	}

	@Override
	public void startAppearAnimation() {
	// TODO.
	}

	@Override
	public boolean startDisappearAnimation(Runnable finishRunnable) {
	return false;
	}
	}