Jim Miller | dcb3d84 | 2012-08-23 19:18:12 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2012 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
Jim Miller | 5ecd811 | 2013-01-09 18:50:26 -0800 | [diff] [blame] | 16 | package com.android.keyguard; |
Jim Miller | dcb3d84 | 2012-08-23 19:18:12 -0700 | [diff] [blame] | 17 | |
Jason Monk | ea03be1 | 2017-12-04 11:08:41 -0500 | [diff] [blame] | 18 | import static com.android.internal.util.LatencyTracker.ACTION_CHECK_CREDENTIAL; |
| 19 | import static com.android.internal.util.LatencyTracker.ACTION_CHECK_CREDENTIAL_UNLOCKED; |
Jorim Jaggi | ed3032b | 2016-10-07 16:49:34 +0200 | [diff] [blame] | 20 | |
Jim Miller | dcb3d84 | 2012-08-23 19:18:12 -0700 | [diff] [blame] | 21 | import android.content.Context; |
Jason Chang | 1e4a4bd | 2018-05-22 17:30:19 +0800 | [diff] [blame] | 22 | import android.content.res.ColorStateList; |
Jim Miller | 5737534 | 2012-09-09 15:20:31 -0700 | [diff] [blame] | 23 | import android.graphics.Rect; |
Xiyuan Xia | 6e38058 | 2015-05-05 15:16:08 -0700 | [diff] [blame] | 24 | import android.os.AsyncTask; |
Jim Miller | dcb3d84 | 2012-08-23 19:18:12 -0700 | [diff] [blame] | 25 | import android.os.CountDownTimer; |
| 26 | import android.os.SystemClock; |
Selim Cinek | 3018197 | 2014-05-30 03:33:06 +0200 | [diff] [blame] | 27 | import android.text.TextUtils; |
Jim Miller | dcb3d84 | 2012-08-23 19:18:12 -0700 | [diff] [blame] | 28 | import android.util.AttributeSet; |
| 29 | import android.util.Log; |
| 30 | import android.view.MotionEvent; |
| 31 | import android.view.View; |
Selim Cinek | 3018197 | 2014-05-30 03:33:06 +0200 | [diff] [blame] | 32 | import android.view.ViewGroup; |
Jorim Jaggi | 98f8530 | 2014-08-07 17:45:04 +0200 | [diff] [blame] | 33 | import android.view.animation.AnimationUtils; |
Selim Cinek | 3018197 | 2014-05-30 03:33:06 +0200 | [diff] [blame] | 34 | import android.view.animation.Interpolator; |
Jim Miller | 3af630c | 2012-09-26 14:29:18 -0700 | [diff] [blame] | 35 | import android.widget.LinearLayout; |
Jim Miller | dcb3d84 | 2012-08-23 19:18:12 -0700 | [diff] [blame] | 36 | |
Lucas Dupin | 2e838ac | 2019-04-17 16:50:58 -0700 | [diff] [blame] | 37 | import com.android.internal.annotations.VisibleForTesting; |
Jason Monk | ea03be1 | 2017-12-04 11:08:41 -0500 | [diff] [blame] | 38 | import com.android.internal.util.LatencyTracker; |
Xiyuan Xia | 6e38058 | 2015-05-05 15:16:08 -0700 | [diff] [blame] | 39 | import com.android.internal.widget.LockPatternChecker; |
Jim Miller | dcb3d84 | 2012-08-23 19:18:12 -0700 | [diff] [blame] | 40 | import com.android.internal.widget.LockPatternUtils; |
| 41 | import com.android.internal.widget.LockPatternView; |
Jorim Jaggi | 5673353 | 2015-06-09 15:25:40 -0700 | [diff] [blame] | 42 | import com.android.settingslib.animation.AppearAnimationCreator; |
| 43 | import com.android.settingslib.animation.AppearAnimationUtils; |
| 44 | import com.android.settingslib.animation.DisappearAnimationUtils; |
Jim Miller | dcb3d84 | 2012-08-23 19:18:12 -0700 | [diff] [blame] | 45 | |
Jim Miller | dcb3d84 | 2012-08-23 19:18:12 -0700 | [diff] [blame] | 46 | import java.util.List; |
| 47 | |
Selim Cinek | 3018197 | 2014-05-30 03:33:06 +0200 | [diff] [blame] | 48 | public class KeyguardPatternView extends LinearLayout implements KeyguardSecurityView, |
Andrew Lee | 72b46d4 | 2015-01-30 13:23:21 -0800 | [diff] [blame] | 49 | AppearAnimationCreator<LockPatternView.CellState>, |
| 50 | EmergencyButton.EmergencyButtonCallback { |
Jim Miller | dcb3d84 | 2012-08-23 19:18:12 -0700 | [diff] [blame] | 51 | |
| 52 | private static final String TAG = "SecurityPatternView"; |
Jorim Jaggi | 5cf1787 | 2014-03-26 18:31:48 +0100 | [diff] [blame] | 53 | private static final boolean DEBUG = KeyguardConstants.DEBUG; |
Jim Miller | dcb3d84 | 2012-08-23 19:18:12 -0700 | [diff] [blame] | 54 | |
| 55 | // how long before we clear the wrong pattern |
| 56 | private static final int PATTERN_CLEAR_TIMEOUT_MS = 2000; |
| 57 | |
| 58 | // how long we stay awake after each key beyond MIN_PATTERN_BEFORE_POKE_WAKELOCK |
| 59 | private static final int UNLOCK_PATTERN_WAKE_INTERVAL_MS = 7000; |
| 60 | |
Jim Miller | dcb3d84 | 2012-08-23 19:18:12 -0700 | [diff] [blame] | 61 | // how many cells the user has to cross before we poke the wakelock |
| 62 | private static final int MIN_PATTERN_BEFORE_POKE_WAKELOCK = 2; |
| 63 | |
Jorim Jaggi | e8fde5d | 2016-06-30 23:41:37 -0700 | [diff] [blame] | 64 | // How much we scale up the duration of the disappear animation when the current user is locked |
| 65 | public static final float DISAPPEAR_MULTIPLIER_LOCKED = 1.5f; |
| 66 | |
Lucas Dupin | abb18f4 | 2019-05-20 19:10:22 -0700 | [diff] [blame] | 67 | // Extra padding, in pixels, that should eat touch events. |
| 68 | private static final int PATTERNS_TOUCH_AREA_EXTENSION = 40; |
| 69 | |
Adrian Roos | 7c11f8b | 2014-03-10 17:00:11 +0100 | [diff] [blame] | 70 | private final KeyguardUpdateMonitor mKeyguardUpdateMonitor; |
Selim Cinek | 3018197 | 2014-05-30 03:33:06 +0200 | [diff] [blame] | 71 | private final AppearAnimationUtils mAppearAnimationUtils; |
Selim Cinek | f9c0e8f | 2014-11-11 13:41:02 +0100 | [diff] [blame] | 72 | private final DisappearAnimationUtils mDisappearAnimationUtils; |
Jorim Jaggi | e8fde5d | 2016-06-30 23:41:37 -0700 | [diff] [blame] | 73 | private final DisappearAnimationUtils mDisappearAnimationUtilsLocked; |
Lucas Dupin | 727890f | 2019-05-15 14:32:50 -0700 | [diff] [blame] | 74 | private final int[] mTmpPosition = new int[2]; |
| 75 | private final Rect mTempRect = new Rect(); |
| 76 | private final Rect mLockPatternScreenBounds = new Rect(); |
Adrian Roos | 7c11f8b | 2014-03-10 17:00:11 +0100 | [diff] [blame] | 77 | |
Jim Miller | dcb3d84 | 2012-08-23 19:18:12 -0700 | [diff] [blame] | 78 | private CountDownTimer mCountdownTimer = null; |
| 79 | private LockPatternUtils mLockPatternUtils; |
Xiyuan Xia | 6e38058 | 2015-05-05 15:16:08 -0700 | [diff] [blame] | 80 | private AsyncTask<?, ?, ?> mPendingLockCheck; |
Jim Miller | dcb3d84 | 2012-08-23 19:18:12 -0700 | [diff] [blame] | 81 | private LockPatternView mLockPatternView; |
Jim Miller | dcb3d84 | 2012-08-23 19:18:12 -0700 | [diff] [blame] | 82 | private KeyguardSecurityCallback mCallback; |
Jim Miller | dcb3d84 | 2012-08-23 19:18:12 -0700 | [diff] [blame] | 83 | |
| 84 | /** |
| 85 | * Keeps track of the last time we poked the wake lock during dispatching of the touch event. |
| 86 | * Initialized to something guaranteed to make us poke the wakelock when the user starts |
| 87 | * drawing the pattern. |
| 88 | * @see #dispatchTouchEvent(android.view.MotionEvent) |
| 89 | */ |
| 90 | private long mLastPokeTime = -UNLOCK_PATTERN_WAKE_INTERVAL_MS; |
| 91 | |
| 92 | /** |
| 93 | * Useful for clearing out the wrong pattern after a delay |
| 94 | */ |
| 95 | private Runnable mCancelPatternRunnable = new Runnable() { |
Jim Miller | 51e3a67 | 2015-07-31 18:42:53 -0700 | [diff] [blame] | 96 | @Override |
Jim Miller | dcb3d84 | 2012-08-23 19:18:12 -0700 | [diff] [blame] | 97 | public void run() { |
| 98 | mLockPatternView.clearPattern(); |
| 99 | } |
| 100 | }; |
Lucas Dupin | 2e838ac | 2019-04-17 16:50:58 -0700 | [diff] [blame] | 101 | @VisibleForTesting |
| 102 | KeyguardMessageArea mSecurityMessageDisplay; |
Chris Wren | c0ae9e6 | 2012-11-05 13:16:31 -0500 | [diff] [blame] | 103 | private View mEcaView; |
Jorim Jaggi | 6b88cdf | 2014-12-22 20:56:50 +0100 | [diff] [blame] | 104 | private ViewGroup mContainer; |
Jorim Jaggi | 76a1623 | 2014-08-08 17:00:47 +0200 | [diff] [blame] | 105 | private int mDisappearYTranslation; |
Jim Miller | dcb3d84 | 2012-08-23 19:18:12 -0700 | [diff] [blame] | 106 | |
| 107 | enum FooterMode { |
| 108 | Normal, |
| 109 | ForgotLockPattern, |
| 110 | VerifyUnlocked |
| 111 | } |
| 112 | |
| 113 | public KeyguardPatternView(Context context) { |
| 114 | this(context, null); |
| 115 | } |
| 116 | |
| 117 | public KeyguardPatternView(Context context, AttributeSet attrs) { |
| 118 | super(context, attrs); |
Adrian Roos | 7c11f8b | 2014-03-10 17:00:11 +0100 | [diff] [blame] | 119 | mKeyguardUpdateMonitor = KeyguardUpdateMonitor.getInstance(mContext); |
Jorim Jaggi | 98f8530 | 2014-08-07 17:45:04 +0200 | [diff] [blame] | 120 | mAppearAnimationUtils = new AppearAnimationUtils(context, |
Selim Cinek | f9c0e8f | 2014-11-11 13:41:02 +0100 | [diff] [blame] | 121 | AppearAnimationUtils.DEFAULT_APPEAR_DURATION, 1.5f /* translationScale */, |
| 122 | 2.0f /* delayScale */, AnimationUtils.loadInterpolator( |
Jorim Jaggi | 98f8530 | 2014-08-07 17:45:04 +0200 | [diff] [blame] | 123 | mContext, android.R.interpolator.linear_out_slow_in)); |
Selim Cinek | f9c0e8f | 2014-11-11 13:41:02 +0100 | [diff] [blame] | 124 | mDisappearAnimationUtils = new DisappearAnimationUtils(context, |
| 125 | 125, 1.2f /* translationScale */, |
Jorim Jaggi | 94f6f061 | 2015-06-25 14:47:24 -0700 | [diff] [blame] | 126 | 0.6f /* delayScale */, AnimationUtils.loadInterpolator( |
Selim Cinek | f9c0e8f | 2014-11-11 13:41:02 +0100 | [diff] [blame] | 127 | mContext, android.R.interpolator.fast_out_linear_in)); |
Jorim Jaggi | e8fde5d | 2016-06-30 23:41:37 -0700 | [diff] [blame] | 128 | mDisappearAnimationUtilsLocked = new DisappearAnimationUtils(context, |
| 129 | (long) (125 * DISAPPEAR_MULTIPLIER_LOCKED), 1.2f /* translationScale */, |
| 130 | 0.6f /* delayScale */, AnimationUtils.loadInterpolator( |
| 131 | mContext, android.R.interpolator.fast_out_linear_in)); |
Jorim Jaggi | 76a1623 | 2014-08-08 17:00:47 +0200 | [diff] [blame] | 132 | mDisappearYTranslation = getResources().getDimensionPixelSize( |
| 133 | R.dimen.disappear_y_translation); |
Jim Miller | dcb3d84 | 2012-08-23 19:18:12 -0700 | [diff] [blame] | 134 | } |
| 135 | |
Jim Miller | 51e3a67 | 2015-07-31 18:42:53 -0700 | [diff] [blame] | 136 | @Override |
Jim Miller | dcb3d84 | 2012-08-23 19:18:12 -0700 | [diff] [blame] | 137 | public void setKeyguardCallback(KeyguardSecurityCallback callback) { |
| 138 | mCallback = callback; |
| 139 | } |
| 140 | |
Jim Miller | 51e3a67 | 2015-07-31 18:42:53 -0700 | [diff] [blame] | 141 | @Override |
Jim Miller | dcb3d84 | 2012-08-23 19:18:12 -0700 | [diff] [blame] | 142 | public void setLockPatternUtils(LockPatternUtils utils) { |
| 143 | mLockPatternUtils = utils; |
| 144 | } |
| 145 | |
| 146 | @Override |
| 147 | protected void onFinishInflate() { |
| 148 | super.onFinishInflate(); |
Jim Miller | dcb3d84 | 2012-08-23 19:18:12 -0700 | [diff] [blame] | 149 | mLockPatternUtils = mLockPatternUtils == null |
| 150 | ? new LockPatternUtils(mContext) : mLockPatternUtils; |
| 151 | |
Alan Viverette | 51efddb | 2017-04-05 10:00:01 -0400 | [diff] [blame] | 152 | mLockPatternView = findViewById(R.id.lockPatternView); |
Jim Miller | dcb3d84 | 2012-08-23 19:18:12 -0700 | [diff] [blame] | 153 | mLockPatternView.setSaveEnabled(false); |
Jim Miller | dcb3d84 | 2012-08-23 19:18:12 -0700 | [diff] [blame] | 154 | mLockPatternView.setOnPatternListener(new UnlockPatternListener()); |
Lucas Dupin | e173274 | 2018-08-23 18:26:49 -0700 | [diff] [blame] | 155 | mLockPatternView.setInStealthMode(!mLockPatternUtils.isVisiblePatternEnabled( |
| 156 | KeyguardUpdateMonitor.getCurrentUser())); |
Jim Miller | dcb3d84 | 2012-08-23 19:18:12 -0700 | [diff] [blame] | 157 | |
Jim Miller | dcb3d84 | 2012-08-23 19:18:12 -0700 | [diff] [blame] | 158 | // vibrate mode will be the same for the life of this screen |
| 159 | mLockPatternView.setTactileFeedbackEnabled(mLockPatternUtils.isTactileFeedbackEnabled()); |
| 160 | |
Chris Wren | c0ae9e6 | 2012-11-05 13:16:31 -0500 | [diff] [blame] | 161 | mEcaView = findViewById(R.id.keyguard_selector_fade_container); |
Alan Viverette | 51efddb | 2017-04-05 10:00:01 -0400 | [diff] [blame] | 162 | mContainer = findViewById(R.id.container); |
Andrew Lee | 72b46d4 | 2015-01-30 13:23:21 -0800 | [diff] [blame] | 163 | |
Alan Viverette | 51efddb | 2017-04-05 10:00:01 -0400 | [diff] [blame] | 164 | EmergencyButton button = findViewById(R.id.emergency_call_button); |
Andrew Lee | f98f7b9 | 2015-02-02 15:50:29 -0800 | [diff] [blame] | 165 | if (button != null) { |
| 166 | button.setCallback(this); |
| 167 | } |
Jian Jin | 44e4d82 | 2018-04-06 12:40:50 -0700 | [diff] [blame] | 168 | |
| 169 | View cancelBtn = findViewById(R.id.cancel_button); |
| 170 | if (cancelBtn != null) { |
| 171 | cancelBtn.setOnClickListener(view -> { |
| 172 | mCallback.reset(); |
Aarthi Balachander | 0a427ef | 2018-07-13 15:00:58 -0700 | [diff] [blame] | 173 | mCallback.onCancelClicked(); |
Jian Jin | 44e4d82 | 2018-04-06 12:40:50 -0700 | [diff] [blame] | 174 | }); |
| 175 | } |
Andrew Lee | 72b46d4 | 2015-01-30 13:23:21 -0800 | [diff] [blame] | 176 | } |
| 177 | |
Jim Miller | 51e3a67 | 2015-07-31 18:42:53 -0700 | [diff] [blame] | 178 | @Override |
Lucas Dupin | 2e838ac | 2019-04-17 16:50:58 -0700 | [diff] [blame] | 179 | protected void onAttachedToWindow() { |
| 180 | super.onAttachedToWindow(); |
| 181 | mSecurityMessageDisplay = KeyguardMessageArea.findSecurityMessageDisplay(this); |
| 182 | } |
| 183 | |
| 184 | @Override |
Andrew Lee | 72b46d4 | 2015-01-30 13:23:21 -0800 | [diff] [blame] | 185 | public void onEmergencyButtonClickedWhenInCall() { |
| 186 | mCallback.reset(); |
Jim Miller | dcb3d84 | 2012-08-23 19:18:12 -0700 | [diff] [blame] | 187 | } |
| 188 | |
Jim Miller | dcb3d84 | 2012-08-23 19:18:12 -0700 | [diff] [blame] | 189 | @Override |
Jim Miller | d2b82f7 | 2012-09-18 20:52:55 -0700 | [diff] [blame] | 190 | public boolean onTouchEvent(MotionEvent ev) { |
| 191 | boolean result = super.onTouchEvent(ev); |
Jim Miller | dcb3d84 | 2012-08-23 19:18:12 -0700 | [diff] [blame] | 192 | // as long as the user is entering a pattern (i.e sending a touch event that was handled |
| 193 | // by this screen), keep poking the wake lock so that the screen will stay on. |
| 194 | final long elapsed = SystemClock.elapsedRealtime() - mLastPokeTime; |
| 195 | if (result && (elapsed > (UNLOCK_PATTERN_WAKE_INTERVAL_MS - 100))) { |
| 196 | mLastPokeTime = SystemClock.elapsedRealtime(); |
| 197 | } |
Jim Miller | 5737534 | 2012-09-09 15:20:31 -0700 | [diff] [blame] | 198 | mTempRect.set(0, 0, 0, 0); |
| 199 | offsetRectIntoDescendantCoords(mLockPatternView, mTempRect); |
| 200 | ev.offsetLocation(mTempRect.left, mTempRect.top); |
| 201 | result = mLockPatternView.dispatchTouchEvent(ev) || result; |
| 202 | ev.offsetLocation(-mTempRect.left, -mTempRect.top); |
Jim Miller | dcb3d84 | 2012-08-23 19:18:12 -0700 | [diff] [blame] | 203 | return result; |
| 204 | } |
| 205 | |
Jim Miller | 51e3a67 | 2015-07-31 18:42:53 -0700 | [diff] [blame] | 206 | @Override |
Lucas Dupin | 727890f | 2019-05-15 14:32:50 -0700 | [diff] [blame] | 207 | protected void onLayout(boolean changed, int l, int t, int r, int b) { |
| 208 | super.onLayout(changed, l, t, r, b); |
| 209 | mLockPatternView.getLocationOnScreen(mTmpPosition); |
Lucas Dupin | abb18f4 | 2019-05-20 19:10:22 -0700 | [diff] [blame] | 210 | mLockPatternScreenBounds.set(mTmpPosition[0] - PATTERNS_TOUCH_AREA_EXTENSION, |
| 211 | mTmpPosition[1] - PATTERNS_TOUCH_AREA_EXTENSION, |
| 212 | mTmpPosition[0] + mLockPatternView.getWidth() + PATTERNS_TOUCH_AREA_EXTENSION, |
| 213 | mTmpPosition[1] + mLockPatternView.getHeight() + PATTERNS_TOUCH_AREA_EXTENSION); |
Lucas Dupin | 727890f | 2019-05-15 14:32:50 -0700 | [diff] [blame] | 214 | } |
| 215 | |
| 216 | @Override |
Jim Miller | dcb3d84 | 2012-08-23 19:18:12 -0700 | [diff] [blame] | 217 | public void reset() { |
| 218 | // reset lock pattern |
Toni Barzic | 17fdb13 | 2015-10-16 13:38:11 -0700 | [diff] [blame] | 219 | mLockPatternView.setInStealthMode(!mLockPatternUtils.isVisiblePatternEnabled( |
| 220 | KeyguardUpdateMonitor.getCurrentUser())); |
Jim Miller | dcb3d84 | 2012-08-23 19:18:12 -0700 | [diff] [blame] | 221 | mLockPatternView.enableInput(); |
| 222 | mLockPatternView.setEnabled(true); |
| 223 | mLockPatternView.clearPattern(); |
| 224 | |
Lucas Dupin | 2e838ac | 2019-04-17 16:50:58 -0700 | [diff] [blame] | 225 | if (mSecurityMessageDisplay == null) { |
| 226 | return; |
| 227 | } |
| 228 | |
Jim Miller | dcb3d84 | 2012-08-23 19:18:12 -0700 | [diff] [blame] | 229 | // if the user is currently locked out, enforce it. |
Adrian Roos | 8150d2a | 2015-04-16 17:11:20 -0700 | [diff] [blame] | 230 | long deadline = mLockPatternUtils.getLockoutAttemptDeadline( |
Adrian Roos | d6aa6cb | 2015-04-16 19:31:29 -0700 | [diff] [blame] | 231 | KeyguardUpdateMonitor.getCurrentUser()); |
Jim Miller | dcb3d84 | 2012-08-23 19:18:12 -0700 | [diff] [blame] | 232 | if (deadline != 0) { |
| 233 | handleAttemptLockout(deadline); |
| 234 | } else { |
Danielle Millett | 1625e87 | 2012-11-01 15:00:12 -0400 | [diff] [blame] | 235 | displayDefaultSecurityMessage(); |
Jim Miller | dcb3d84 | 2012-08-23 19:18:12 -0700 | [diff] [blame] | 236 | } |
Jim Miller | dcb3d84 | 2012-08-23 19:18:12 -0700 | [diff] [blame] | 237 | } |
| 238 | |
Danielle Millett | 1625e87 | 2012-11-01 15:00:12 -0400 | [diff] [blame] | 239 | private void displayDefaultSecurityMessage() { |
Lucas Dupin | 2e838ac | 2019-04-17 16:50:58 -0700 | [diff] [blame] | 240 | if (mSecurityMessageDisplay != null) { |
| 241 | mSecurityMessageDisplay.setMessage(""); |
| 242 | } |
Danielle Millett | 1625e87 | 2012-11-01 15:00:12 -0400 | [diff] [blame] | 243 | } |
| 244 | |
Adam Cohen | 6fb841f | 2012-10-24 13:15:38 -0700 | [diff] [blame] | 245 | @Override |
| 246 | public void showUsabilityHint() { |
| 247 | } |
| 248 | |
Lucas Dupin | 7156bc7 | 2019-05-03 19:37:39 -0700 | [diff] [blame] | 249 | @Override |
| 250 | public boolean disallowInterceptTouch(MotionEvent event) { |
Lucas Dupin | 727890f | 2019-05-15 14:32:50 -0700 | [diff] [blame] | 251 | return mLockPatternScreenBounds.contains((int) event.getRawX(), (int) event.getRawY()); |
Lucas Dupin | 7156bc7 | 2019-05-03 19:37:39 -0700 | [diff] [blame] | 252 | } |
| 253 | |
Jim Miller | dcb3d84 | 2012-08-23 19:18:12 -0700 | [diff] [blame] | 254 | /** TODO: hook this up */ |
| 255 | public void cleanUp() { |
| 256 | if (DEBUG) Log.v(TAG, "Cleanup() called on " + this); |
| 257 | mLockPatternUtils = null; |
| 258 | mLockPatternView.setOnPatternListener(null); |
| 259 | } |
| 260 | |
Jim Miller | dcb3d84 | 2012-08-23 19:18:12 -0700 | [diff] [blame] | 261 | private class UnlockPatternListener implements LockPatternView.OnPatternListener { |
| 262 | |
Jim Miller | 51e3a67 | 2015-07-31 18:42:53 -0700 | [diff] [blame] | 263 | @Override |
Jim Miller | dcb3d84 | 2012-08-23 19:18:12 -0700 | [diff] [blame] | 264 | public void onPatternStart() { |
| 265 | mLockPatternView.removeCallbacks(mCancelPatternRunnable); |
Adrian Roos | db327e9 | 2016-10-12 16:41:28 -0700 | [diff] [blame] | 266 | mSecurityMessageDisplay.setMessage(""); |
Jim Miller | dcb3d84 | 2012-08-23 19:18:12 -0700 | [diff] [blame] | 267 | } |
| 268 | |
Jim Miller | 51e3a67 | 2015-07-31 18:42:53 -0700 | [diff] [blame] | 269 | @Override |
Jim Miller | dcb3d84 | 2012-08-23 19:18:12 -0700 | [diff] [blame] | 270 | public void onPatternCleared() { |
| 271 | } |
| 272 | |
Jim Miller | 51e3a67 | 2015-07-31 18:42:53 -0700 | [diff] [blame] | 273 | @Override |
Jim Miller | dcb3d84 | 2012-08-23 19:18:12 -0700 | [diff] [blame] | 274 | public void onPatternCellAdded(List<LockPatternView.Cell> pattern) { |
Jorim Jaggi | b690f0d | 2014-07-03 23:25:44 +0200 | [diff] [blame] | 275 | mCallback.userActivity(); |
Jim Miller | dcb3d84 | 2012-08-23 19:18:12 -0700 | [diff] [blame] | 276 | } |
| 277 | |
Jim Miller | 51e3a67 | 2015-07-31 18:42:53 -0700 | [diff] [blame] | 278 | @Override |
Xiyuan Xia | 6e38058 | 2015-05-05 15:16:08 -0700 | [diff] [blame] | 279 | public void onPatternDetected(final List<LockPatternView.Cell> pattern) { |
| 280 | mLockPatternView.disableInput(); |
| 281 | if (mPendingLockCheck != null) { |
| 282 | mPendingLockCheck.cancel(false); |
| 283 | } |
| 284 | |
Xiyuan Xia | ce64cea | 2016-01-06 08:51:16 -0800 | [diff] [blame] | 285 | final int userId = KeyguardUpdateMonitor.getCurrentUser(); |
Andres Morales | 2397427 | 2015-05-14 22:42:26 -0700 | [diff] [blame] | 286 | if (pattern.size() < LockPatternUtils.MIN_PATTERN_REGISTER_FAIL) { |
| 287 | mLockPatternView.enableInput(); |
Xiyuan Xia | ce64cea | 2016-01-06 08:51:16 -0800 | [diff] [blame] | 288 | onPatternChecked(userId, false, 0, false /* not valid - too short */); |
Andres Morales | 2397427 | 2015-05-14 22:42:26 -0700 | [diff] [blame] | 289 | return; |
| 290 | } |
| 291 | |
Jorim Jaggi | ed3032b | 2016-10-07 16:49:34 +0200 | [diff] [blame] | 292 | if (LatencyTracker.isEnabled(mContext)) { |
| 293 | LatencyTracker.getInstance(mContext).onActionStart(ACTION_CHECK_CREDENTIAL); |
| 294 | LatencyTracker.getInstance(mContext).onActionStart(ACTION_CHECK_CREDENTIAL_UNLOCKED); |
| 295 | } |
Xiyuan Xia | 6e38058 | 2015-05-05 15:16:08 -0700 | [diff] [blame] | 296 | mPendingLockCheck = LockPatternChecker.checkPattern( |
| 297 | mLockPatternUtils, |
| 298 | pattern, |
Xiyuan Xia | ce64cea | 2016-01-06 08:51:16 -0800 | [diff] [blame] | 299 | userId, |
Xiyuan Xia | 6e38058 | 2015-05-05 15:16:08 -0700 | [diff] [blame] | 300 | new LockPatternChecker.OnCheckCallback() { |
Jorim Jaggi | e8fde5d | 2016-06-30 23:41:37 -0700 | [diff] [blame] | 301 | |
| 302 | @Override |
| 303 | public void onEarlyMatched() { |
Jorim Jaggi | ed3032b | 2016-10-07 16:49:34 +0200 | [diff] [blame] | 304 | if (LatencyTracker.isEnabled(mContext)) { |
| 305 | LatencyTracker.getInstance(mContext).onActionEnd( |
| 306 | ACTION_CHECK_CREDENTIAL); |
| 307 | } |
Jorim Jaggi | e8fde5d | 2016-06-30 23:41:37 -0700 | [diff] [blame] | 308 | onPatternChecked(userId, true /* matched */, 0 /* timeoutMs */, |
| 309 | true /* isValidPattern */); |
| 310 | } |
| 311 | |
Xiyuan Xia | 6e38058 | 2015-05-05 15:16:08 -0700 | [diff] [blame] | 312 | @Override |
Andres Morales | 2397427 | 2015-05-14 22:42:26 -0700 | [diff] [blame] | 313 | public void onChecked(boolean matched, int timeoutMs) { |
Jorim Jaggi | ed3032b | 2016-10-07 16:49:34 +0200 | [diff] [blame] | 314 | if (LatencyTracker.isEnabled(mContext)) { |
| 315 | LatencyTracker.getInstance(mContext).onActionEnd( |
| 316 | ACTION_CHECK_CREDENTIAL_UNLOCKED); |
| 317 | } |
Xiyuan Xia | 6e38058 | 2015-05-05 15:16:08 -0700 | [diff] [blame] | 318 | mLockPatternView.enableInput(); |
| 319 | mPendingLockCheck = null; |
Jorim Jaggi | e8fde5d | 2016-06-30 23:41:37 -0700 | [diff] [blame] | 320 | if (!matched) { |
| 321 | onPatternChecked(userId, false /* matched */, timeoutMs, |
| 322 | true /* isValidPattern */); |
| 323 | } |
Xiyuan Xia | 6e38058 | 2015-05-05 15:16:08 -0700 | [diff] [blame] | 324 | } |
Jorim Jaggi | ed3032b | 2016-10-07 16:49:34 +0200 | [diff] [blame] | 325 | |
| 326 | @Override |
| 327 | public void onCancelled() { |
| 328 | // We already got dismissed with the early matched callback, so we |
| 329 | // cancelled the check. However, we still need to note down the latency. |
| 330 | if (LatencyTracker.isEnabled(mContext)) { |
| 331 | LatencyTracker.getInstance(mContext).onActionEnd( |
| 332 | ACTION_CHECK_CREDENTIAL_UNLOCKED); |
| 333 | } |
| 334 | } |
Xiyuan Xia | 6e38058 | 2015-05-05 15:16:08 -0700 | [diff] [blame] | 335 | }); |
Jim Miller | 51e3a67 | 2015-07-31 18:42:53 -0700 | [diff] [blame] | 336 | if (pattern.size() > MIN_PATTERN_BEFORE_POKE_WAKELOCK) { |
| 337 | mCallback.userActivity(); |
| 338 | } |
Xiyuan Xia | 6e38058 | 2015-05-05 15:16:08 -0700 | [diff] [blame] | 339 | } |
| 340 | |
Xiyuan Xia | ce64cea | 2016-01-06 08:51:16 -0800 | [diff] [blame] | 341 | private void onPatternChecked(int userId, boolean matched, int timeoutMs, |
| 342 | boolean isValidPattern) { |
| 343 | boolean dismissKeyguard = KeyguardUpdateMonitor.getCurrentUser() == userId; |
Xiyuan Xia | 6e38058 | 2015-05-05 15:16:08 -0700 | [diff] [blame] | 344 | if (matched) { |
Xiyuan Xia | ce64cea | 2016-01-06 08:51:16 -0800 | [diff] [blame] | 345 | mCallback.reportUnlockAttempt(userId, true, 0); |
| 346 | if (dismissKeyguard) { |
| 347 | mLockPatternView.setDisplayMode(LockPatternView.DisplayMode.Correct); |
Vadim Tryshev | 8702ca7 | 2016-04-22 08:14:12 -0700 | [diff] [blame] | 348 | mCallback.dismiss(true, userId); |
Xiyuan Xia | ce64cea | 2016-01-06 08:51:16 -0800 | [diff] [blame] | 349 | } |
Jim Miller | dcb3d84 | 2012-08-23 19:18:12 -0700 | [diff] [blame] | 350 | } else { |
Jim Miller | dcb3d84 | 2012-08-23 19:18:12 -0700 | [diff] [blame] | 351 | mLockPatternView.setDisplayMode(LockPatternView.DisplayMode.Wrong); |
Jim Miller | 51e3a67 | 2015-07-31 18:42:53 -0700 | [diff] [blame] | 352 | if (isValidPattern) { |
Xiyuan Xia | ce64cea | 2016-01-06 08:51:16 -0800 | [diff] [blame] | 353 | mCallback.reportUnlockAttempt(userId, false, timeoutMs); |
Jim Miller | 51e3a67 | 2015-07-31 18:42:53 -0700 | [diff] [blame] | 354 | if (timeoutMs > 0) { |
| 355 | long deadline = mLockPatternUtils.setLockoutAttemptDeadline( |
Xiyuan Xia | ce64cea | 2016-01-06 08:51:16 -0800 | [diff] [blame] | 356 | userId, timeoutMs); |
Jim Miller | 51e3a67 | 2015-07-31 18:42:53 -0700 | [diff] [blame] | 357 | handleAttemptLockout(deadline); |
| 358 | } |
| 359 | } |
| 360 | if (timeoutMs == 0) { |
Adrian Roos | db327e9 | 2016-10-12 16:41:28 -0700 | [diff] [blame] | 361 | mSecurityMessageDisplay.setMessage(R.string.kg_wrong_pattern); |
Jim Miller | dcb3d84 | 2012-08-23 19:18:12 -0700 | [diff] [blame] | 362 | mLockPatternView.postDelayed(mCancelPatternRunnable, PATTERN_CLEAR_TIMEOUT_MS); |
| 363 | } |
| 364 | } |
| 365 | } |
| 366 | } |
| 367 | |
Jim Miller | dcb3d84 | 2012-08-23 19:18:12 -0700 | [diff] [blame] | 368 | private void handleAttemptLockout(long elapsedRealtimeDeadline) { |
| 369 | mLockPatternView.clearPattern(); |
| 370 | mLockPatternView.setEnabled(false); |
| 371 | final long elapsedRealtime = SystemClock.elapsedRealtime(); |
Hidenari Koshimae | 5be868c | 2014-08-21 11:27:33 +0200 | [diff] [blame] | 372 | final long secondsInFuture = (long) Math.ceil( |
| 373 | (elapsedRealtimeDeadline - elapsedRealtime) / 1000.0); |
| 374 | mCountdownTimer = new CountDownTimer(secondsInFuture * 1000, 1000) { |
Jim Miller | dcb3d84 | 2012-08-23 19:18:12 -0700 | [diff] [blame] | 375 | |
| 376 | @Override |
| 377 | public void onTick(long millisUntilFinished) { |
Hidenari Koshimae | 5be868c | 2014-08-21 11:27:33 +0200 | [diff] [blame] | 378 | final int secondsRemaining = (int) Math.round(millisUntilFinished / 1000.0); |
Kevin Chyn | e01c5e1 | 2017-08-29 19:04:25 -0700 | [diff] [blame] | 379 | mSecurityMessageDisplay.setMessage(mContext.getResources().getQuantityString( |
| 380 | R.plurals.kg_too_many_failed_attempts_countdown, |
| 381 | secondsRemaining, secondsRemaining)); |
Jim Miller | dcb3d84 | 2012-08-23 19:18:12 -0700 | [diff] [blame] | 382 | } |
| 383 | |
| 384 | @Override |
| 385 | public void onFinish() { |
| 386 | mLockPatternView.setEnabled(true); |
Danielle Millett | 1625e87 | 2012-11-01 15:00:12 -0400 | [diff] [blame] | 387 | displayDefaultSecurityMessage(); |
Jim Miller | dcb3d84 | 2012-08-23 19:18:12 -0700 | [diff] [blame] | 388 | } |
| 389 | |
| 390 | }.start(); |
| 391 | } |
| 392 | |
| 393 | @Override |
| 394 | public boolean needsInput() { |
| 395 | return false; |
| 396 | } |
| 397 | |
| 398 | @Override |
| 399 | public void onPause() { |
| 400 | if (mCountdownTimer != null) { |
| 401 | mCountdownTimer.cancel(); |
| 402 | mCountdownTimer = null; |
| 403 | } |
Xiyuan Xia | 6e38058 | 2015-05-05 15:16:08 -0700 | [diff] [blame] | 404 | if (mPendingLockCheck != null) { |
| 405 | mPendingLockCheck.cancel(false); |
| 406 | mPendingLockCheck = null; |
| 407 | } |
Lucas Dupin | c6b50c6 | 2018-10-09 20:00:35 -0700 | [diff] [blame] | 408 | displayDefaultSecurityMessage(); |
Jim Miller | dcb3d84 | 2012-08-23 19:18:12 -0700 | [diff] [blame] | 409 | } |
| 410 | |
| 411 | @Override |
Chris Wren | a042ac9 | 2012-11-07 11:37:06 -0500 | [diff] [blame] | 412 | public void onResume(int reason) { |
Jim Miller | dcb3d84 | 2012-08-23 19:18:12 -0700 | [diff] [blame] | 413 | } |
| 414 | |
| 415 | @Override |
| 416 | public KeyguardSecurityCallback getCallback() { |
| 417 | return mCallback; |
| 418 | } |
Chris Wren | c0ae9e6 | 2012-11-05 13:16:31 -0500 | [diff] [blame] | 419 | |
| 420 | @Override |
Selim Cinek | 3122fa8 | 2015-06-18 01:38:59 -0700 | [diff] [blame] | 421 | public void showPromptReason(int reason) { |
| 422 | switch (reason) { |
| 423 | case PROMPT_REASON_RESTART: |
Adrian Roos | db327e9 | 2016-10-12 16:41:28 -0700 | [diff] [blame] | 424 | mSecurityMessageDisplay.setMessage(R.string.kg_prompt_reason_restart_pattern); |
Selim Cinek | 3122fa8 | 2015-06-18 01:38:59 -0700 | [diff] [blame] | 425 | break; |
Jorim Jaggi | 25b4d4b | 2015-08-11 15:54:06 -0700 | [diff] [blame] | 426 | case PROMPT_REASON_TIMEOUT: |
Adrian Roos | db327e9 | 2016-10-12 16:41:28 -0700 | [diff] [blame] | 427 | mSecurityMessageDisplay.setMessage(R.string.kg_prompt_reason_timeout_pattern); |
Jorim Jaggi | 25b4d4b | 2015-08-11 15:54:06 -0700 | [diff] [blame] | 428 | break; |
Adrian Roos | d6d253a | 2016-04-13 13:06:21 -0700 | [diff] [blame] | 429 | case PROMPT_REASON_DEVICE_ADMIN: |
Adrian Roos | db327e9 | 2016-10-12 16:41:28 -0700 | [diff] [blame] | 430 | mSecurityMessageDisplay.setMessage(R.string.kg_prompt_reason_device_admin); |
Adrian Roos | d6d253a | 2016-04-13 13:06:21 -0700 | [diff] [blame] | 431 | break; |
| 432 | case PROMPT_REASON_USER_REQUEST: |
Adrian Roos | db327e9 | 2016-10-12 16:41:28 -0700 | [diff] [blame] | 433 | mSecurityMessageDisplay.setMessage(R.string.kg_prompt_reason_user_request); |
Adrian Roos | d6d253a | 2016-04-13 13:06:21 -0700 | [diff] [blame] | 434 | break; |
Adrian Roos | c13723f | 2016-01-12 20:29:03 +0100 | [diff] [blame] | 435 | case PROMPT_REASON_NONE: |
| 436 | break; |
Selim Cinek | 3122fa8 | 2015-06-18 01:38:59 -0700 | [diff] [blame] | 437 | default: |
Adrian Roos | db327e9 | 2016-10-12 16:41:28 -0700 | [diff] [blame] | 438 | mSecurityMessageDisplay.setMessage(R.string.kg_prompt_reason_timeout_pattern); |
Jorim Jaggi | 25b4d4b | 2015-08-11 15:54:06 -0700 | [diff] [blame] | 439 | break; |
Selim Cinek | 3122fa8 | 2015-06-18 01:38:59 -0700 | [diff] [blame] | 440 | } |
| 441 | } |
| 442 | |
| 443 | @Override |
Jason Chang | 1e4a4bd | 2018-05-22 17:30:19 +0800 | [diff] [blame] | 444 | public void showMessage(CharSequence message, ColorStateList colorState) { |
| 445 | mSecurityMessageDisplay.setNextMessageColor(colorState); |
Adrian Roos | db327e9 | 2016-10-12 16:41:28 -0700 | [diff] [blame] | 446 | mSecurityMessageDisplay.setMessage(message); |
Selim Cinek | cfafe4e | 2015-08-11 14:58:44 -0700 | [diff] [blame] | 447 | } |
| 448 | |
| 449 | @Override |
Jorim Jaggi | c14f829 | 2014-05-27 02:25:45 +0200 | [diff] [blame] | 450 | public void startAppearAnimation() { |
Selim Cinek | 3018197 | 2014-05-30 03:33:06 +0200 | [diff] [blame] | 451 | enableClipping(false); |
Jorim Jaggi | fb28c0e | 2014-08-22 16:28:42 +0200 | [diff] [blame] | 452 | setAlpha(1f); |
Jorim Jaggi | 76a1623 | 2014-08-08 17:00:47 +0200 | [diff] [blame] | 453 | setTranslationY(mAppearAnimationUtils.getStartTranslation()); |
Jorim Jaggi | 613f55f | 2015-07-16 15:30:10 -0700 | [diff] [blame] | 454 | AppearAnimationUtils.startTranslationYAnimation(this, 0 /* delay */, 500 /* duration */, |
| 455 | 0, mAppearAnimationUtils.getInterpolator()); |
Jorim Jaggi | 5673353 | 2015-06-09 15:25:40 -0700 | [diff] [blame] | 456 | mAppearAnimationUtils.startAnimation2d( |
Selim Cinek | 3018197 | 2014-05-30 03:33:06 +0200 | [diff] [blame] | 457 | mLockPatternView.getCellStates(), |
| 458 | new Runnable() { |
| 459 | @Override |
| 460 | public void run() { |
| 461 | enableClipping(true); |
| 462 | } |
| 463 | }, |
| 464 | this); |
Selim Cinek | 3122fa8 | 2015-06-18 01:38:59 -0700 | [diff] [blame] | 465 | if (!TextUtils.isEmpty(mSecurityMessageDisplay.getText())) { |
| 466 | mAppearAnimationUtils.createAnimation(mSecurityMessageDisplay, 0, |
Jorim Jaggi | 98f8530 | 2014-08-07 17:45:04 +0200 | [diff] [blame] | 467 | AppearAnimationUtils.DEFAULT_APPEAR_DURATION, |
Selim Cinek | 3018197 | 2014-05-30 03:33:06 +0200 | [diff] [blame] | 468 | mAppearAnimationUtils.getStartTranslation(), |
Selim Cinek | f9c0e8f | 2014-11-11 13:41:02 +0100 | [diff] [blame] | 469 | true /* appearing */, |
Selim Cinek | 3018197 | 2014-05-30 03:33:06 +0200 | [diff] [blame] | 470 | mAppearAnimationUtils.getInterpolator(), |
| 471 | null /* finishRunnable */); |
| 472 | } |
| 473 | } |
| 474 | |
Jorim Jaggi | 76a1623 | 2014-08-08 17:00:47 +0200 | [diff] [blame] | 475 | @Override |
Selim Cinek | f9c0e8f | 2014-11-11 13:41:02 +0100 | [diff] [blame] | 476 | public boolean startDisappearAnimation(final Runnable finishRunnable) { |
Jorim Jaggi | 031f795 | 2016-09-01 16:39:26 -0700 | [diff] [blame] | 477 | float durationMultiplier = mKeyguardUpdateMonitor.needsSlowUnlockTransition() |
| 478 | ? DISAPPEAR_MULTIPLIER_LOCKED |
| 479 | : 1f; |
Jorim Jaggi | 76a1623 | 2014-08-08 17:00:47 +0200 | [diff] [blame] | 480 | mLockPatternView.clearPattern(); |
Selim Cinek | f9c0e8f | 2014-11-11 13:41:02 +0100 | [diff] [blame] | 481 | enableClipping(false); |
| 482 | setTranslationY(0); |
Jorim Jaggi | e8fde5d | 2016-06-30 23:41:37 -0700 | [diff] [blame] | 483 | AppearAnimationUtils.startTranslationYAnimation(this, 0 /* delay */, |
| 484 | (long) (300 * durationMultiplier), |
Jorim Jaggi | 613f55f | 2015-07-16 15:30:10 -0700 | [diff] [blame] | 485 | -mDisappearAnimationUtils.getStartTranslation(), |
| 486 | mDisappearAnimationUtils.getInterpolator()); |
Jorim Jaggi | e8fde5d | 2016-06-30 23:41:37 -0700 | [diff] [blame] | 487 | |
Jorim Jaggi | 031f795 | 2016-09-01 16:39:26 -0700 | [diff] [blame] | 488 | DisappearAnimationUtils disappearAnimationUtils = mKeyguardUpdateMonitor |
| 489 | .needsSlowUnlockTransition() |
| 490 | ? mDisappearAnimationUtilsLocked |
| 491 | : mDisappearAnimationUtils; |
Jorim Jaggi | e8fde5d | 2016-06-30 23:41:37 -0700 | [diff] [blame] | 492 | disappearAnimationUtils.startAnimation2d(mLockPatternView.getCellStates(), |
| 493 | () -> { |
| 494 | enableClipping(true); |
| 495 | if (finishRunnable != null) { |
| 496 | finishRunnable.run(); |
Selim Cinek | f9c0e8f | 2014-11-11 13:41:02 +0100 | [diff] [blame] | 497 | } |
| 498 | }, KeyguardPatternView.this); |
Selim Cinek | 3122fa8 | 2015-06-18 01:38:59 -0700 | [diff] [blame] | 499 | if (!TextUtils.isEmpty(mSecurityMessageDisplay.getText())) { |
| 500 | mDisappearAnimationUtils.createAnimation(mSecurityMessageDisplay, 0, |
Jorim Jaggi | e8fde5d | 2016-06-30 23:41:37 -0700 | [diff] [blame] | 501 | (long) (200 * durationMultiplier), |
Selim Cinek | f9c0e8f | 2014-11-11 13:41:02 +0100 | [diff] [blame] | 502 | - mDisappearAnimationUtils.getStartTranslation() * 3, |
| 503 | false /* appearing */, |
| 504 | mDisappearAnimationUtils.getInterpolator(), |
| 505 | null /* finishRunnable */); |
| 506 | } |
Jorim Jaggi | 76a1623 | 2014-08-08 17:00:47 +0200 | [diff] [blame] | 507 | return true; |
| 508 | } |
| 509 | |
Selim Cinek | 3018197 | 2014-05-30 03:33:06 +0200 | [diff] [blame] | 510 | private void enableClipping(boolean enable) { |
| 511 | setClipChildren(enable); |
Jorim Jaggi | 6b88cdf | 2014-12-22 20:56:50 +0100 | [diff] [blame] | 512 | mContainer.setClipToPadding(enable); |
| 513 | mContainer.setClipChildren(enable); |
Selim Cinek | 3018197 | 2014-05-30 03:33:06 +0200 | [diff] [blame] | 514 | } |
| 515 | |
| 516 | @Override |
| 517 | public void createAnimation(final LockPatternView.CellState animatedCell, long delay, |
Selim Cinek | f9c0e8f | 2014-11-11 13:41:02 +0100 | [diff] [blame] | 518 | long duration, float translationY, final boolean appearing, |
| 519 | Interpolator interpolator, |
Selim Cinek | 3018197 | 2014-05-30 03:33:06 +0200 | [diff] [blame] | 520 | final Runnable finishListener) { |
Jorim Jaggi | 613f55f | 2015-07-16 15:30:10 -0700 | [diff] [blame] | 521 | mLockPatternView.startCellStateAnimation(animatedCell, |
| 522 | 1f, appearing ? 1f : 0f, /* alpha */ |
| 523 | appearing ? translationY : 0f, appearing ? 0f : translationY, /* translation */ |
| 524 | appearing ? 0f : 1f, 1f /* scale */, |
| 525 | delay, duration, interpolator, finishListener); |
Selim Cinek | 3018197 | 2014-05-30 03:33:06 +0200 | [diff] [blame] | 526 | if (finishListener != null) { |
Selim Cinek | 3018197 | 2014-05-30 03:33:06 +0200 | [diff] [blame] | 527 | // Also animate the Emergency call |
Selim Cinek | f9c0e8f | 2014-11-11 13:41:02 +0100 | [diff] [blame] | 528 | mAppearAnimationUtils.createAnimation(mEcaView, delay, duration, translationY, |
| 529 | appearing, interpolator, null); |
Selim Cinek | 3018197 | 2014-05-30 03:33:06 +0200 | [diff] [blame] | 530 | } |
Jorim Jaggi | c14f829 | 2014-05-27 02:25:45 +0200 | [diff] [blame] | 531 | } |
Jorim Jaggi | 76a1623 | 2014-08-08 17:00:47 +0200 | [diff] [blame] | 532 | |
| 533 | @Override |
| 534 | public boolean hasOverlappingRendering() { |
| 535 | return false; |
| 536 | } |
Phil Weaver | 7d847b0 | 2018-02-13 16:02:35 -0800 | [diff] [blame] | 537 | |
| 538 | @Override |
| 539 | public CharSequence getTitle() { |
| 540 | return getContext().getString( |
| 541 | com.android.internal.R.string.keyguard_accessibility_pattern_unlock); |
| 542 | } |
Jim Miller | dcb3d84 | 2012-08-23 19:18:12 -0700 | [diff] [blame] | 543 | } |