Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit dc019300 authored by Dave Mankoff's avatar Dave Mankoff
Browse files

Revert^2 "7/N controllers for remaining Keyguard Password ..." 

Revert submission 12656261-revert-12585643-b166448040-keyguard-message-area-NUUJOVRYJS

This also fixes the original issue introduced in this CL.
KeyguardAbsKeyInputViewController#reset would call mView#resetState
instead of its own internal resetState method. However, all the logic
from the various resetState methods had been moved from the views to
their controllers. Simply calling resetState direclty resolves the
issue (line 105 of KeyguardAbsKeyInputViewController).

Reason for revert: Fixing http://b/169231892 and http://b/169145796
Reverted Changes:
I7683b2234:Revert "4/N Setup Controller fo KeyguardSecurityCo...
I5cbe04c0c:Revert "5/N Add KeyguardSecurityViewFlipperControl...
I11dff38ad:Revert "6/N Add Controller for KeyguardPatternView...
I55c250121:Revert "7/N controllers for remaining Keyguard Pas...
Ie84234cb8:Revert "8/N Remove View Injection from KeyguardMes...
Ic62f199a5:Revert "9/N Clean Up Keyguard Class Structure"

Change-Id: Ie3669e0c9a23ffd4443ced0fb08ec754f1df55db
Fixes: 169145796
parent 6350a9f1

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 {

            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.