7/N controllers for remaining Keyguard Password Views. (1d569867) · Commits · e / os / android_frameworks_base

packages/SystemUI/src/com/android/keyguard/KeyguardAbsKeyInputView.java

+16 −213

Original line number	Diff line number	Diff line
		@@ -16,45 +16,30 @@

		package com.android.keyguard;

		import static com.android.internal.util.LatencyTracker.ACTION_CHECK_CREDENTIAL;
		import static com.android.internal.util.LatencyTracker.ACTION_CHECK_CREDENTIAL_UNLOCKED;

		import android.content.Context;
		import android.content.res.ColorStateList;
		import android.os.AsyncTask;
		import android.os.CountDownTimer;
		import android.os.SystemClock;
		import android.util.AttributeSet;
		import android.view.HapticFeedbackConstants;
		import android.view.KeyEvent;
		import android.view.View;

		import com.android.internal.util.LatencyTracker;
		import com.android.internal.widget.LockPatternChecker;
		import com.android.internal.widget.LockPatternUtils;
		import com.android.internal.widget.LockscreenCredential;
		import com.android.systemui.Dependency;
		import com.android.systemui.R;

		/**
		* Base class for PIN and password unlock screens.
		*/
		public abstract class KeyguardAbsKeyInputView extends KeyguardInputView
		implements EmergencyButton.EmergencyButtonCallback {
		public abstract class KeyguardAbsKeyInputView extends KeyguardInputView {
		protected KeyguardSecurityCallback mCallback;
		protected LockPatternUtils mLockPatternUtils;
		protected AsyncTask<?, ?, ?> mPendingLockCheck;
		protected SecurityMessageDisplay mSecurityMessageDisplay;
		protected View mEcaView;
		protected boolean mEnableHaptics;
		private boolean mDismissing;
		protected boolean mResumed;
		private CountDownTimer mCountdownTimer = null;
		private final KeyguardUpdateMonitor mKeyguardUpdateMonitor;

		// To avoid accidental lockout due to events while the device in in the pocket, ignore
		// any passwords with length less than or equal to this length.
		protected static final int MINIMUM_PASSWORD_LENGTH_BEFORE_REPORT = 3;
		private KeyDownListener mKeyDownListener;

		public KeyguardAbsKeyInputView(Context context) {
		this(context, null);
		@@ -62,7 +47,10 @@ public abstract class KeyguardAbsKeyInputView extends KeyguardInputView

		public KeyguardAbsKeyInputView(Context context, AttributeSet attrs) {
		super(context, attrs);
		mKeyguardUpdateMonitor = Dependency.get(KeyguardUpdateMonitor.class);
		}

		void setEnableHaptics(boolean enableHaptics) {
		mEnableHaptics = enableHaptics;
		}

		@Override
		@@ -72,28 +60,10 @@ public abstract class KeyguardAbsKeyInputView extends KeyguardInputView

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

		@Override
		public void reset() {
		// start fresh
		mDismissing = false;
		resetPasswordText(false /* animate /, false / announce */);
		// if the user is currently locked out, enforce it.
		long deadline = mLockPatternUtils.getLockoutAttemptDeadline(
		KeyguardUpdateMonitor.getCurrentUser());
		if (shouldLockout(deadline)) {
		handleAttemptLockout(deadline);
		} else {
		resetState();
		}
		}

		// Allow subclasses to override this behavior
		protected boolean shouldLockout(long deadline) {
		return deadline != 0;
		}

		protected abstract int getPasswordTextViewId();
		@@ -101,24 +71,7 @@ public abstract class KeyguardAbsKeyInputView extends KeyguardInputView

		@Override
		protected void onFinishInflate() {
		mLockPatternUtils = new LockPatternUtils(mContext);
		mEcaView = findViewById(R.id.keyguard_selector_fade_container);

		EmergencyButton button = findViewById(R.id.emergency_call_button);
		if (button != null) {
		button.setCallback(this);
		}
		}

		@Override
		protected void onAttachedToWindow() {
		super.onAttachedToWindow();
		mSecurityMessageDisplay = KeyguardMessageArea.findSecurityMessageDisplay(this);
		}

		@Override
		public void onEmergencyButtonClickedWhenInCall() {
		mCallback.reset();
		}

		/*
		@@ -130,147 +83,14 @@ public abstract class KeyguardAbsKeyInputView extends KeyguardInputView
		return R.string.kg_wrong_password;
		}

		protected void verifyPasswordAndUnlock() {
		if (mDismissing) return; // already verified but haven't been dismissed; don't do it again.

		final LockscreenCredential password = getEnteredCredential();
		setPasswordEntryInputEnabled(false);
		if (mPendingLockCheck != null) {
		mPendingLockCheck.cancel(false);
		}

		final int userId = KeyguardUpdateMonitor.getCurrentUser();
		if (password.size() <= MINIMUM_PASSWORD_LENGTH_BEFORE_REPORT) {
		// to avoid accidental lockout, only count attempts that are long enough to be a
		// real password. This may require some tweaking.
		setPasswordEntryInputEnabled(true);
		onPasswordChecked(userId, false /* matched /, 0, false / not valid - too short */);
		password.zeroize();
		return;
		}

		if (LatencyTracker.isEnabled(mContext)) {
		LatencyTracker.getInstance(mContext).onActionStart(ACTION_CHECK_CREDENTIAL);
		LatencyTracker.getInstance(mContext).onActionStart(ACTION_CHECK_CREDENTIAL_UNLOCKED);
		}

		mKeyguardUpdateMonitor.setCredentialAttempted();
		mPendingLockCheck = LockPatternChecker.checkCredential(
		mLockPatternUtils,
		password,
		userId,
		new LockPatternChecker.OnCheckCallback() {

		@Override
		public void onEarlyMatched() {
		if (LatencyTracker.isEnabled(mContext)) {
		LatencyTracker.getInstance(mContext).onActionEnd(
		ACTION_CHECK_CREDENTIAL);
		}
		onPasswordChecked(userId, true /* matched /, 0 / timeoutMs */,
		true /* isValidPassword */);
		password.zeroize();
		}

		@Override
		public void onChecked(boolean matched, int timeoutMs) {
		if (LatencyTracker.isEnabled(mContext)) {
		LatencyTracker.getInstance(mContext).onActionEnd(
		ACTION_CHECK_CREDENTIAL_UNLOCKED);
		}
		setPasswordEntryInputEnabled(true);
		mPendingLockCheck = null;
		if (!matched) {
		onPasswordChecked(userId, false /* matched */, timeoutMs,
		true /* isValidPassword */);
		}
		password.zeroize();
		}

		@Override
		public void onCancelled() {
		// We already got dismissed with the early matched callback, so we cancelled
		// the check. However, we still need to note down the latency.
		if (LatencyTracker.isEnabled(mContext)) {
		LatencyTracker.getInstance(mContext).onActionEnd(
		ACTION_CHECK_CREDENTIAL_UNLOCKED);
		}
		password.zeroize();
		}
		});
		}

		private void onPasswordChecked(int userId, boolean matched, int timeoutMs,
		boolean isValidPassword) {
		boolean dismissKeyguard = KeyguardUpdateMonitor.getCurrentUser() == userId;
		if (matched) {
		mCallback.reportUnlockAttempt(userId, true, 0);
		if (dismissKeyguard) {
		mDismissing = true;
		mCallback.dismiss(true, userId);
		}
		} else {
		if (isValidPassword) {
		mCallback.reportUnlockAttempt(userId, false, timeoutMs);
		if (timeoutMs > 0) {
		long deadline = mLockPatternUtils.setLockoutAttemptDeadline(
		userId, timeoutMs);
		handleAttemptLockout(deadline);
		}
		}
		if (timeoutMs == 0) {
		mSecurityMessageDisplay.setMessage(getWrongPasswordStringId());
		}
		}
		resetPasswordText(true /* animate /, !matched / announce deletion if no match */);
		}

		protected abstract void resetPasswordText(boolean animate, boolean announce);
		protected abstract LockscreenCredential getEnteredCredential();
		protected abstract void setPasswordEntryEnabled(boolean enabled);
		protected abstract void setPasswordEntryInputEnabled(boolean enabled);

		// Prevent user from using the PIN/Password entry until scheduled deadline.
		protected void handleAttemptLockout(long elapsedRealtimeDeadline) {
		setPasswordEntryEnabled(false);
		long elapsedRealtime = SystemClock.elapsedRealtime();
		long secondsInFuture = (long) Math.ceil(
		(elapsedRealtimeDeadline - elapsedRealtime) / 1000.0);
		mCountdownTimer = new CountDownTimer(secondsInFuture * 1000, 1000) {

		@Override
		public void onTick(long millisUntilFinished) {
		int secondsRemaining = (int) Math.round(millisUntilFinished / 1000.0);
		mSecurityMessageDisplay.setMessage(mContext.getResources().getQuantityString(
		R.plurals.kg_too_many_failed_attempts_countdown,
		secondsRemaining, secondsRemaining));
		}

		@Override
		public void onFinish() {
		mSecurityMessageDisplay.setMessage("");
		resetState();
		}
		}.start();
		}

		protected void onUserInput() {
		if (mCallback != null) {
		mCallback.userActivity();
		mCallback.onUserInput();
		}
		mSecurityMessageDisplay.setMessage("");
		}

		@Override
		public boolean onKeyDown(int keyCode, KeyEvent event) {
		// Fingerprint sensor sends a KeyEvent.KEYCODE_UNKNOWN.
		// We don't want to consider it valid user input because the UI
		// will already respond to the event.
		if (keyCode != KeyEvent.KEYCODE_UNKNOWN) {
		onUserInput();
		}
		return false;
		return mKeyDownListener != null && mKeyDownListener.onKeyDown(keyCode, event);
		}

		@Override
		@@ -278,26 +98,6 @@ public abstract class KeyguardAbsKeyInputView extends KeyguardInputView
		return false;
		}

		@Override
		public void onPause() {
		mResumed = false;

		if (mCountdownTimer != null) {
		mCountdownTimer.cancel();
		mCountdownTimer = null;
		}
		if (mPendingLockCheck != null) {
		mPendingLockCheck.cancel(false);
		mPendingLockCheck = null;
		}
		reset();
		}

		@Override
		public void onResume(int reason) {
		mResumed = true;
		}

		@Override
		public KeyguardSecurityCallback getCallback() {
		return mCallback;
		@@ -305,12 +105,7 @@ public abstract class KeyguardAbsKeyInputView extends KeyguardInputView

		@Override
		public void showPromptReason(int reason) {
		if (reason != PROMPT_REASON_NONE) {
		int promtReasonStringRes = getPromptReasonStringRes(reason);
		if (promtReasonStringRes != 0) {
		mSecurityMessageDisplay.setMessage(promtReasonStringRes);
		}
		}

		}

		@Override
		@@ -336,5 +131,13 @@ public abstract class KeyguardAbsKeyInputView extends KeyguardInputView
		public boolean startDisappearAnimation(Runnable finishRunnable) {
		return false;
		}

		public void setKeyDownListener(KeyDownListener keyDownListener) {
		mKeyDownListener = keyDownListener;
		}

		public interface KeyDownListener {
		boolean onKeyDown(int keyCode, KeyEvent keyEvent);
		}
		}

packages/SystemUI/src/com/android/keyguard/KeyguardAbsKeyInputViewController.java

0 → 100644

+257 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2020 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 static com.android.internal.util.LatencyTracker.ACTION_CHECK_CREDENTIAL;
		import static com.android.internal.util.LatencyTracker.ACTION_CHECK_CREDENTIAL_UNLOCKED;
		import static com.android.keyguard.KeyguardAbsKeyInputView.MINIMUM_PASSWORD_LENGTH_BEFORE_REPORT;

		import android.os.AsyncTask;
		import android.os.CountDownTimer;
		import android.os.SystemClock;
		import android.view.KeyEvent;

		import com.android.internal.util.LatencyTracker;
		import com.android.internal.widget.LockPatternChecker;
		import com.android.internal.widget.LockPatternUtils;
		import com.android.internal.widget.LockscreenCredential;
		import com.android.keyguard.EmergencyButton.EmergencyButtonCallback;
		import com.android.keyguard.KeyguardAbsKeyInputView.KeyDownListener;
		import com.android.keyguard.KeyguardSecurityModel.SecurityMode;
		import com.android.systemui.R;

		public abstract class KeyguardAbsKeyInputViewController<T extends KeyguardAbsKeyInputView>
		extends KeyguardInputViewController<T> {
		private final KeyguardUpdateMonitor mKeyguardUpdateMonitor;
		private final LockPatternUtils mLockPatternUtils;
		protected final KeyguardSecurityCallback mKeyguardSecurityCallback;
		private final LatencyTracker mLatencyTracker;
		private CountDownTimer mCountdownTimer;
		protected KeyguardMessageAreaController mMessageAreaController;
		private boolean mDismissing;
		protected AsyncTask<?, ?, ?> mPendingLockCheck;
		protected boolean mResumed;

		private final KeyDownListener mKeyDownListener = (keyCode, keyEvent) -> {
		// Fingerprint sensor sends a KeyEvent.KEYCODE_UNKNOWN.
		// We don't want to consider it valid user input because the UI
		// will already respond to the event.
		if (keyCode != KeyEvent.KEYCODE_UNKNOWN) {
		onUserInput();
		}
		return false;
		};

		private final EmergencyButtonCallback mEmergencyButtonCallback = new EmergencyButtonCallback() {
		@Override
		public void onEmergencyButtonClickedWhenInCall() {
		mKeyguardSecurityCallback.reset();
		}
		};

		protected KeyguardAbsKeyInputViewController(T view,
		KeyguardUpdateMonitor keyguardUpdateMonitor,
		SecurityMode securityMode,
		LockPatternUtils lockPatternUtils,
		KeyguardSecurityCallback keyguardSecurityCallback,
		KeyguardMessageAreaController.Factory messageAreaControllerFactory,
		LatencyTracker latencyTracker) {
		super(view, securityMode, keyguardSecurityCallback);
		mKeyguardUpdateMonitor = keyguardUpdateMonitor;
		mLockPatternUtils = lockPatternUtils;
		mKeyguardSecurityCallback = keyguardSecurityCallback;
		mLatencyTracker = latencyTracker;
		KeyguardMessageArea kma = KeyguardMessageArea.findSecurityMessageDisplay(mView);
		mMessageAreaController = messageAreaControllerFactory.create(kma);
		}

		abstract void resetState();

		@Override
		protected void onViewAttached() {
		mView.setKeyDownListener(mKeyDownListener);
		mView.setEnableHaptics(mLockPatternUtils.isTactileFeedbackEnabled());
		EmergencyButton button = mView.findViewById(R.id.emergency_call_button);
		if (button != null) {
		button.setCallback(mEmergencyButtonCallback);
		}
		}

		@Override
		public void reset() {
		// start fresh
		mDismissing = false;
		mView.resetPasswordText(false /* animate /, false / announce */);
		// if the user is currently locked out, enforce it.
		long deadline = mLockPatternUtils.getLockoutAttemptDeadline(
		KeyguardUpdateMonitor.getCurrentUser());
		if (shouldLockout(deadline)) {
		handleAttemptLockout(deadline);
		} else {
		mView.resetState();
		}
		}

		// Allow subclasses to override this behavior
		protected boolean shouldLockout(long deadline) {
		return deadline != 0;
		}

		// Prevent user from using the PIN/Password entry until scheduled deadline.
		protected void handleAttemptLockout(long elapsedRealtimeDeadline) {
		mView.setPasswordEntryEnabled(false);
		long elapsedRealtime = SystemClock.elapsedRealtime();
		long secondsInFuture = (long) Math.ceil(
		(elapsedRealtimeDeadline - elapsedRealtime) / 1000.0);
		mCountdownTimer = new CountDownTimer(secondsInFuture * 1000, 1000) {

		@Override
		public void onTick(long millisUntilFinished) {
		int secondsRemaining = (int) Math.round(millisUntilFinished / 1000.0);
		mMessageAreaController.setMessage(mView.getResources().getQuantityString(
		R.plurals.kg_too_many_failed_attempts_countdown,
		secondsRemaining, secondsRemaining));
		}

		@Override
		public void onFinish() {
		mMessageAreaController.setMessage("");
		resetState();
		}
		}.start();
		}

		void onPasswordChecked(int userId, boolean matched, int timeoutMs, boolean isValidPassword) {
		boolean dismissKeyguard = KeyguardUpdateMonitor.getCurrentUser() == userId;
		if (matched) {
		mKeyguardSecurityCallback.reportUnlockAttempt(userId, true, 0);
		if (dismissKeyguard) {
		mDismissing = true;
		mKeyguardSecurityCallback.dismiss(true, userId);
		}
		} else {
		if (isValidPassword) {
		mKeyguardSecurityCallback.reportUnlockAttempt(userId, false, timeoutMs);
		if (timeoutMs > 0) {
		long deadline = mLockPatternUtils.setLockoutAttemptDeadline(
		userId, timeoutMs);
		handleAttemptLockout(deadline);
		}
		}
		if (timeoutMs == 0) {
		mMessageAreaController.setMessage(mView.getWrongPasswordStringId());
		}
		}
		mView.resetPasswordText(true /* animate /, !matched / announce deletion if no match */);
		}

		protected void verifyPasswordAndUnlock() {
		if (mDismissing) return; // already verified but haven't been dismissed; don't do it again.

		final LockscreenCredential password = mView.getEnteredCredential();
		mView.setPasswordEntryInputEnabled(false);
		if (mPendingLockCheck != null) {
		mPendingLockCheck.cancel(false);
		}

		final int userId = KeyguardUpdateMonitor.getCurrentUser();
		if (password.size() <= MINIMUM_PASSWORD_LENGTH_BEFORE_REPORT) {
		// to avoid accidental lockout, only count attempts that are long enough to be a
		// real password. This may require some tweaking.
		mView.setPasswordEntryInputEnabled(true);
		onPasswordChecked(userId, false /* matched /, 0, false / not valid - too short */);
		password.zeroize();
		return;
		}

		mLatencyTracker.onActionStart(ACTION_CHECK_CREDENTIAL);
		mLatencyTracker.onActionStart(ACTION_CHECK_CREDENTIAL_UNLOCKED);

		mKeyguardUpdateMonitor.setCredentialAttempted();
		mPendingLockCheck = LockPatternChecker.checkCredential(
		mLockPatternUtils,
		password,
		userId,
		new LockPatternChecker.OnCheckCallback() {

		@Override
		public void onEarlyMatched() {
		mLatencyTracker.onActionEnd(ACTION_CHECK_CREDENTIAL);

		onPasswordChecked(userId, true /* matched /, 0 / timeoutMs */,
		true /* isValidPassword */);
		password.zeroize();
		}

		@Override
		public void onChecked(boolean matched, int timeoutMs) {
		mLatencyTracker.onActionEnd(ACTION_CHECK_CREDENTIAL_UNLOCKED);
		mView.setPasswordEntryInputEnabled(true);
		mPendingLockCheck = null;
		if (!matched) {
		onPasswordChecked(userId, false /* matched */, timeoutMs,
		true /* isValidPassword */);
		}
		password.zeroize();
		}

		@Override
		public void onCancelled() {
		// We already got dismissed with the early matched callback, so we cancelled
		// the check. However, we still need to note down the latency.
		mLatencyTracker.onActionEnd(ACTION_CHECK_CREDENTIAL_UNLOCKED);
		password.zeroize();
		}
		});
		}

		@Override
		public void showPromptReason(int reason) {
		if (reason != PROMPT_REASON_NONE) {
		int promtReasonStringRes = mView.getPromptReasonStringRes(reason);
		if (promtReasonStringRes != 0) {
		mMessageAreaController.setMessage(promtReasonStringRes);
		}
		}
		}

		protected void onUserInput() {
		mKeyguardSecurityCallback.userActivity();
		mKeyguardSecurityCallback.onUserInput();
		mMessageAreaController.setMessage("");
		}

		@Override
		public void onResume(int reason) {
		mResumed = true;
		}

		@Override
		public void onPause() {
		mResumed = false;

		if (mCountdownTimer != null) {
		mCountdownTimer.cancel();
		mCountdownTimer = null;
		}
		if (mPendingLockCheck != null) {
		mPendingLockCheck.cancel(false);
		mPendingLockCheck = null;
		}
		reset();
		}
		}

packages/SystemUI/src/com/android/keyguard/KeyguardHostViewController.java

+5 −5

Original line number	Diff line number	Diff line
		@@ -178,18 +178,18 @@ public class KeyguardHostViewController extends ViewController<KeyguardHostView>
		/** Initialize the Controller. */
		public void init() {
		super.init();
		mView.setViewMediatorCallback(mViewMediatorCallback);
		// Update ViewMediator with the current input method requirements
		mViewMediatorCallback.setNeedsInput(mKeyguardSecurityContainerController.needsInput());
		mKeyguardSecurityContainerController.init();
		mKeyguardSecurityContainerController.setSecurityCallback(mSecurityCallback);
		mKeyguardSecurityContainerController.showPrimarySecurityScreen(false);
		}

		@Override
		protected void onViewAttached() {
		mView.setViewMediatorCallback(mViewMediatorCallback);
		// Update ViewMediator with the current input method requirements
		mViewMediatorCallback.setNeedsInput(mKeyguardSecurityContainerController.needsInput());
		mKeyguardUpdateMonitor.registerCallback(mUpdateCallback);
		mView.setOnKeyListener(mOnKeyListener);
		mKeyguardSecurityContainerController.setSecurityCallback(mSecurityCallback);
		mKeyguardSecurityContainerController.showPrimarySecurityScreen(false);
		}

		@Override

packages/SystemUI/src/com/android/keyguard/KeyguardInputViewController.java

+43 −11

File changed.

Preview size limit exceeded, changes collapsed.

packages/SystemUI/src/com/android/keyguard/KeyguardPINView.java

+21 −18

File changed.

Preview size limit exceeded, changes collapsed.