The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2007 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 | */ |
| 16 | |
Maurice Lam | 2eb170c | 2017-04-28 16:18:47 -0700 | [diff] [blame] | 17 | package com.android.settings.password; |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 18 | |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 19 | import android.app.Activity; |
Fan Zhang | 31b2100 | 2019-01-16 13:49:47 -0800 | [diff] [blame] | 20 | import android.app.settings.SettingsEnums; |
Jim Miller | 0698a21 | 2014-10-16 19:49:07 -0700 | [diff] [blame] | 21 | import android.content.Context; |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 22 | import android.content.Intent; |
Jyun LuoLai | 11960ce | 2018-03-15 14:11:30 +0800 | [diff] [blame] | 23 | import android.content.res.ColorStateList; |
Maurice Lam | 9990f39 | 2017-06-28 15:06:09 -0700 | [diff] [blame] | 24 | import android.content.res.Resources.Theme; |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 25 | import android.os.Bundle; |
Andres Morales | 91e6c49 | 2015-05-15 15:20:33 -0700 | [diff] [blame] | 26 | import android.util.Log; |
Irina Dumitrescu | 4b96dc3 | 2019-02-28 15:35:36 +0000 | [diff] [blame] | 27 | import android.util.Pair; |
Jyun LuoLai | 11960ce | 2018-03-15 14:11:30 +0800 | [diff] [blame] | 28 | import android.util.TypedValue; |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 29 | import android.view.KeyEvent; |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 30 | import android.view.LayoutInflater; |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 31 | import android.view.View; |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 32 | import android.view.ViewGroup; |
jackqdyulei | 011f0db | 2016-10-21 10:50:34 -0700 | [diff] [blame] | 33 | import android.widget.ScrollView; |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 34 | import android.widget.TextView; |
| 35 | |
Fan Zhang | 23f8d59 | 2018-08-28 15:11:40 -0700 | [diff] [blame] | 36 | import androidx.fragment.app.Fragment; |
| 37 | |
Rubin Xu | 010116a | 2019-09-11 17:36:37 +0100 | [diff] [blame] | 38 | import com.android.internal.annotations.VisibleForTesting; |
Jason Monk | 39b4674 | 2015-09-10 15:52:51 -0400 | [diff] [blame] | 39 | import com.android.internal.widget.LinearLayoutWithDefaultTouchRecepient; |
| 40 | import com.android.internal.widget.LockPatternUtils; |
| 41 | import com.android.internal.widget.LockPatternUtils.RequestThrottledException; |
| 42 | import com.android.internal.widget.LockPatternView; |
| 43 | import com.android.internal.widget.LockPatternView.Cell; |
| 44 | import com.android.internal.widget.LockPatternView.DisplayMode; |
Rubin Xu | 010116a | 2019-09-11 17:36:37 +0100 | [diff] [blame] | 45 | import com.android.internal.widget.LockscreenCredential; |
Maurice Lam | 2eb170c | 2017-04-28 16:18:47 -0700 | [diff] [blame] | 46 | import com.android.settings.EncryptionInterstitial; |
| 47 | import com.android.settings.R; |
| 48 | import com.android.settings.SettingsActivity; |
Maurice Lam | 9990f39 | 2017-06-28 15:06:09 -0700 | [diff] [blame] | 49 | import com.android.settings.SetupWizardUtils; |
Maurice Lam | 2eb170c | 2017-04-28 16:18:47 -0700 | [diff] [blame] | 50 | import com.android.settings.Utils; |
Doris Ling | 7248972 | 2017-11-16 11:03:40 -0800 | [diff] [blame] | 51 | import com.android.settings.core.InstrumentedFragment; |
Jason Monk | 39b4674 | 2015-09-10 15:52:51 -0400 | [diff] [blame] | 52 | import com.android.settings.notification.RedactionInterstitial; |
Maurice Lam | 2eb170c | 2017-04-28 16:18:47 -0700 | [diff] [blame] | 53 | |
Jason Monk | 39b4674 | 2015-09-10 15:52:51 -0400 | [diff] [blame] | 54 | import com.google.android.collect.Lists; |
pastychang | 9bdb59a | 2019-01-21 09:49:15 +0800 | [diff] [blame] | 55 | import com.google.android.setupcompat.template.FooterBarMixin; |
| 56 | import com.google.android.setupcompat.template.FooterButton; |
Pasty Chang | c1f8600 | 2018-12-11 02:22:55 +0000 | [diff] [blame] | 57 | import com.google.android.setupdesign.GlifLayout; |
Jason Monk | 39b4674 | 2015-09-10 15:52:51 -0400 | [diff] [blame] | 58 | |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 59 | import java.util.Collections; |
| 60 | import java.util.List; |
| 61 | |
| 62 | /** |
| 63 | * If the user has a lock pattern set already, makes them confirm the existing one. |
| 64 | * |
| 65 | * Then, prompts the user to choose a lock pattern: |
| 66 | * - prompts for initial pattern |
| 67 | * - asks for confirmation / restart |
| 68 | * - saves chosen password when confirmed |
| 69 | */ |
Fabrice Di Meglio | 263bcc8 | 2014-01-17 19:17:58 -0800 | [diff] [blame] | 70 | public class ChooseLockPattern extends SettingsActivity { |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 71 | /** |
| 72 | * Used by the choose lock pattern wizard to indicate the wizard is |
| 73 | * finished, and each activity in the wizard should finish. |
| 74 | * <p> |
| 75 | * Previously, each activity in the wizard would finish itself after |
| 76 | * starting the next activity. However, this leads to broken 'Back' |
| 77 | * behavior. So, now an activity does not finish itself until it gets this |
| 78 | * result. |
| 79 | */ |
| 80 | static final int RESULT_FINISHED = RESULT_FIRST_USER; |
Jim Miller | 00d2476 | 2009-12-22 19:04:57 -0800 | [diff] [blame] | 81 | |
Andres Morales | 91e6c49 | 2015-05-15 15:20:33 -0700 | [diff] [blame] | 82 | private static final String TAG = "ChooseLockPattern"; |
| 83 | |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 84 | @Override |
| 85 | public Intent getIntent() { |
| 86 | Intent modIntent = new Intent(super.getIntent()); |
Maurice Lam | 6b19fa9 | 2014-11-25 19:25:56 -0800 | [diff] [blame] | 87 | modIntent.putExtra(EXTRA_SHOW_FRAGMENT, getFragmentClass().getName()); |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 88 | return modIntent; |
| 89 | } |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 90 | |
Maurice Lam | 9990f39 | 2017-06-28 15:06:09 -0700 | [diff] [blame] | 91 | @Override |
| 92 | protected void onApplyThemeResource(Theme theme, int resid, boolean first) { |
| 93 | resid = SetupWizardUtils.getTheme(getIntent()); |
| 94 | super.onApplyThemeResource(theme, resid, first); |
| 95 | } |
| 96 | |
Maurice Lam | 2eb170c | 2017-04-28 16:18:47 -0700 | [diff] [blame] | 97 | public static class IntentBuilder { |
| 98 | private final Intent mIntent; |
Jim Miller | 0698a21 | 2014-10-16 19:49:07 -0700 | [diff] [blame] | 99 | |
Maurice Lam | 2eb170c | 2017-04-28 16:18:47 -0700 | [diff] [blame] | 100 | public IntentBuilder(Context context) { |
| 101 | mIntent = new Intent(context, ChooseLockPattern.class); |
| 102 | mIntent.putExtra(EncryptionInterstitial.EXTRA_REQUIRE_PASSWORD, false); |
| 103 | mIntent.putExtra(ChooseLockGeneric.CONFIRM_CREDENTIALS, false); |
Pavel Grafov | 40e187b | 2017-10-11 22:57:09 +0100 | [diff] [blame] | 104 | mIntent.putExtra(ChooseLockSettingsHelper.EXTRA_KEY_HAS_CHALLENGE, false); |
Maurice Lam | 2eb170c | 2017-04-28 16:18:47 -0700 | [diff] [blame] | 105 | } |
Andres Morales | a0e1236 | 2015-04-02 09:00:41 -0700 | [diff] [blame] | 106 | |
Maurice Lam | 2eb170c | 2017-04-28 16:18:47 -0700 | [diff] [blame] | 107 | public IntentBuilder setUserId(int userId) { |
| 108 | mIntent.putExtra(Intent.EXTRA_USER_ID, userId); |
| 109 | return this; |
| 110 | } |
| 111 | |
| 112 | public IntentBuilder setChallenge(long challenge) { |
| 113 | mIntent.putExtra(ChooseLockSettingsHelper.EXTRA_KEY_HAS_CHALLENGE, true); |
| 114 | mIntent.putExtra(ChooseLockSettingsHelper.EXTRA_KEY_CHALLENGE, challenge); |
| 115 | return this; |
| 116 | } |
| 117 | |
Rubin Xu | 010116a | 2019-09-11 17:36:37 +0100 | [diff] [blame] | 118 | public IntentBuilder setPattern(LockscreenCredential pattern) { |
Maurice Lam | 2eb170c | 2017-04-28 16:18:47 -0700 | [diff] [blame] | 119 | mIntent.putExtra(ChooseLockSettingsHelper.EXTRA_KEY_PASSWORD, pattern); |
| 120 | return this; |
| 121 | } |
| 122 | |
Maurice Lam | b49526e | 2017-05-31 17:55:43 -0700 | [diff] [blame] | 123 | public IntentBuilder setForFingerprint(boolean forFingerprint) { |
| 124 | mIntent.putExtra(ChooseLockSettingsHelper.EXTRA_KEY_FOR_FINGERPRINT, forFingerprint); |
| 125 | return this; |
| 126 | } |
| 127 | |
Kevin Chyn | 81dc029 | 2018-06-28 14:59:38 -0700 | [diff] [blame] | 128 | public IntentBuilder setForFace(boolean forFace) { |
| 129 | mIntent.putExtra(ChooseLockSettingsHelper.EXTRA_KEY_FOR_FACE, forFace); |
| 130 | return this; |
| 131 | } |
| 132 | |
Maurice Lam | 2eb170c | 2017-04-28 16:18:47 -0700 | [diff] [blame] | 133 | public Intent build() { |
| 134 | return mIntent; |
| 135 | } |
Andres Morales | 6609b0c | 2015-04-12 15:38:25 -0700 | [diff] [blame] | 136 | } |
| 137 | |
Jim Miller | 00d2476 | 2009-12-22 19:04:57 -0800 | [diff] [blame] | 138 | @Override |
Amith Yamasani | a677ee2 | 2013-07-26 13:38:41 -0700 | [diff] [blame] | 139 | protected boolean isValidFragment(String fragmentName) { |
| 140 | if (ChooseLockPatternFragment.class.getName().equals(fragmentName)) return true; |
| 141 | return false; |
| 142 | } |
| 143 | |
Maurice Lam | 6b19fa9 | 2014-11-25 19:25:56 -0800 | [diff] [blame] | 144 | /* package */ Class<? extends Fragment> getFragmentClass() { |
| 145 | return ChooseLockPatternFragment.class; |
| 146 | } |
| 147 | |
Amith Yamasani | a677ee2 | 2013-07-26 13:38:41 -0700 | [diff] [blame] | 148 | @Override |
Udam Saini | 71fde52 | 2016-03-30 13:38:05 -0700 | [diff] [blame] | 149 | protected void onCreate(Bundle savedInstanceState) { |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 150 | // requestWindowFeature(Window.FEATURE_NO_TITLE); |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 151 | super.onCreate(savedInstanceState); |
Kevin Chyn | 81dc029 | 2018-06-28 14:59:38 -0700 | [diff] [blame] | 152 | final boolean forFingerprint = getIntent() |
Maurice Lam | b49526e | 2017-05-31 17:55:43 -0700 | [diff] [blame] | 153 | .getBooleanExtra(ChooseLockSettingsHelper.EXTRA_KEY_FOR_FINGERPRINT, false); |
Kevin Chyn | 81dc029 | 2018-06-28 14:59:38 -0700 | [diff] [blame] | 154 | final boolean forFace = getIntent() |
| 155 | .getBooleanExtra(ChooseLockSettingsHelper.EXTRA_KEY_FOR_FACE, false); |
| 156 | |
| 157 | int msg = R.string.lockpassword_choose_your_screen_lock_header; |
| 158 | if (forFingerprint) { |
| 159 | msg = R.string.lockpassword_choose_your_pattern_header_for_fingerprint; |
| 160 | } else if (forFace) { |
| 161 | msg = R.string.lockpassword_choose_your_pattern_header_for_face; |
| 162 | } |
| 163 | |
| 164 | setTitle(msg); |
Fan Zhang | 9db66a5 | 2019-05-10 14:18:33 -0700 | [diff] [blame] | 165 | findViewById(R.id.content_parent).setFitsSystemWindows(false); |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 166 | } |
| 167 | |
| 168 | @Override |
| 169 | public boolean onKeyDown(int keyCode, KeyEvent event) { |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 170 | // *** TODO *** |
| 171 | // chooseLockPatternFragment.onKeyDown(keyCode, event); |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 172 | return super.onKeyDown(keyCode, event); |
| 173 | } |
| 174 | |
Doris Ling | 7248972 | 2017-11-16 11:03:40 -0800 | [diff] [blame] | 175 | public static class ChooseLockPatternFragment extends InstrumentedFragment |
pastychang | c3c5a5c | 2019-01-17 15:44:08 +0800 | [diff] [blame] | 176 | implements SaveAndFinishWorker.Listener { |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 177 | |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 178 | public static final int CONFIRM_EXISTING_REQUEST = 55; |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 179 | |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 180 | // how long after a confirmation message is shown before moving on |
| 181 | static final int INFORMATION_MSG_TIMEOUT_MS = 3000; |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 182 | |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 183 | // how long we wait to clear a wrong pattern |
| 184 | private static final int WRONG_PATTERN_CLEAR_TIMEOUT_MS = 2000; |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 185 | |
pastychang | 7a083f8 | 2019-03-26 16:09:34 +0800 | [diff] [blame] | 186 | protected static final int ID_EMPTY_MESSAGE = -1; |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 187 | |
Xiyuan Xia | 3e7e3d6 | 2015-08-25 15:04:57 -0700 | [diff] [blame] | 188 | private static final String FRAGMENT_TAG_SAVE_AND_FINISH = "save_and_finish_worker"; |
| 189 | |
Rubin Xu | 010116a | 2019-09-11 17:36:37 +0100 | [diff] [blame] | 190 | private LockscreenCredential mCurrentCredential; |
Andres Morales | 6609b0c | 2015-04-12 15:38:25 -0700 | [diff] [blame] | 191 | private boolean mHasChallenge; |
| 192 | private long mChallenge; |
Jyun LuoLai | 11960ce | 2018-03-15 14:11:30 +0800 | [diff] [blame] | 193 | protected TextView mTitleText; |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 194 | protected TextView mHeaderText; |
Maurice Lam | 7f5e196 | 2017-09-08 17:51:58 -0700 | [diff] [blame] | 195 | protected TextView mMessageText; |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 196 | protected LockPatternView mLockPatternView; |
| 197 | protected TextView mFooterText; |
pastychang | c3c5a5c | 2019-01-17 15:44:08 +0800 | [diff] [blame] | 198 | protected FooterButton mSkipOrClearButton; |
| 199 | private FooterButton mNextButton; |
Rubin Xu | 010116a | 2019-09-11 17:36:37 +0100 | [diff] [blame] | 200 | @VisibleForTesting protected LockscreenCredential mChosenPattern; |
Jyun LuoLai | 11960ce | 2018-03-15 14:11:30 +0800 | [diff] [blame] | 201 | private ColorStateList mDefaultHeaderColorList; |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 202 | |
jackqdyulei | 011f0db | 2016-10-21 10:50:34 -0700 | [diff] [blame] | 203 | // ScrollView that contains title and header, only exist in land mode |
| 204 | private ScrollView mTitleHeaderScrollView; |
| 205 | |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 206 | /** |
| 207 | * The patten used during the help screen to show how to draw a pattern. |
| 208 | */ |
| 209 | private final List<LockPatternView.Cell> mAnimatePattern = |
| 210 | Collections.unmodifiableList(Lists.newArrayList( |
| 211 | LockPatternView.Cell.of(0, 0), |
| 212 | LockPatternView.Cell.of(0, 1), |
| 213 | LockPatternView.Cell.of(1, 1), |
| 214 | LockPatternView.Cell.of(2, 1) |
| 215 | )); |
| 216 | |
| 217 | @Override |
| 218 | public void onActivityResult(int requestCode, int resultCode, |
| 219 | Intent data) { |
| 220 | super.onActivityResult(requestCode, resultCode, data); |
| 221 | switch (requestCode) { |
| 222 | case CONFIRM_EXISTING_REQUEST: |
| 223 | if (resultCode != Activity.RESULT_OK) { |
| 224 | getActivity().setResult(RESULT_FINISHED); |
| 225 | getActivity().finish(); |
Andres Morales | a0e1236 | 2015-04-02 09:00:41 -0700 | [diff] [blame] | 226 | } else { |
Rubin Xu | 010116a | 2019-09-11 17:36:37 +0100 | [diff] [blame] | 227 | mCurrentCredential = data.getParcelableExtra( |
Andres Morales | a0e1236 | 2015-04-02 09:00:41 -0700 | [diff] [blame] | 228 | ChooseLockSettingsHelper.EXTRA_KEY_PASSWORD); |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 229 | } |
Andres Morales | a0e1236 | 2015-04-02 09:00:41 -0700 | [diff] [blame] | 230 | |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 231 | updateStage(Stage.Introduction); |
| 232 | break; |
| 233 | } |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 234 | } |
| 235 | |
Maurice Lam | af103b4 | 2014-12-03 15:17:46 -0800 | [diff] [blame] | 236 | protected void setRightButtonEnabled(boolean enabled) { |
pastychang | c3c5a5c | 2019-01-17 15:44:08 +0800 | [diff] [blame] | 237 | mNextButton.setEnabled(enabled); |
Maurice Lam | af103b4 | 2014-12-03 15:17:46 -0800 | [diff] [blame] | 238 | } |
| 239 | |
| 240 | protected void setRightButtonText(int text) { |
pastychang | c3c5a5c | 2019-01-17 15:44:08 +0800 | [diff] [blame] | 241 | mNextButton.setText(getActivity(), text); |
Maurice Lam | af103b4 | 2014-12-03 15:17:46 -0800 | [diff] [blame] | 242 | } |
| 243 | |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 244 | /** |
| 245 | * The pattern listener that responds according to a user choosing a new |
| 246 | * lock pattern. |
| 247 | */ |
| 248 | protected LockPatternView.OnPatternListener mChooseNewLockPatternListener = |
| 249 | new LockPatternView.OnPatternListener() { |
| 250 | |
| 251 | public void onPatternStart() { |
| 252 | mLockPatternView.removeCallbacks(mClearPatternRunnable); |
| 253 | patternInProgress(); |
| 254 | } |
| 255 | |
| 256 | public void onPatternCleared() { |
| 257 | mLockPatternView.removeCallbacks(mClearPatternRunnable); |
| 258 | } |
| 259 | |
| 260 | public void onPatternDetected(List<LockPatternView.Cell> pattern) { |
| 261 | if (mUiStage == Stage.NeedToConfirm || mUiStage == Stage.ConfirmWrong) { |
| 262 | if (mChosenPattern == null) throw new IllegalStateException( |
| 263 | "null chosen pattern in stage 'need to confirm"); |
Rubin Xu | 010116a | 2019-09-11 17:36:37 +0100 | [diff] [blame] | 264 | try (LockscreenCredential confirmPattern = |
| 265 | LockscreenCredential.createPattern(pattern)) { |
| 266 | if (mChosenPattern.equals(confirmPattern)) { |
| 267 | updateStage(Stage.ChoiceConfirmed); |
| 268 | } else { |
| 269 | updateStage(Stage.ConfirmWrong); |
| 270 | } |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 271 | } |
| 272 | } else if (mUiStage == Stage.Introduction || mUiStage == Stage.ChoiceTooShort){ |
| 273 | if (pattern.size() < LockPatternUtils.MIN_LOCK_PATTERN_SIZE) { |
| 274 | updateStage(Stage.ChoiceTooShort); |
| 275 | } else { |
Rubin Xu | 010116a | 2019-09-11 17:36:37 +0100 | [diff] [blame] | 276 | mChosenPattern = LockscreenCredential.createPattern(pattern); |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 277 | updateStage(Stage.FirstChoiceValid); |
| 278 | } |
| 279 | } else { |
| 280 | throw new IllegalStateException("Unexpected stage " + mUiStage + " when " |
| 281 | + "entering the pattern."); |
| 282 | } |
| 283 | } |
| 284 | |
| 285 | public void onPatternCellAdded(List<Cell> pattern) { |
| 286 | |
| 287 | } |
| 288 | |
| 289 | private void patternInProgress() { |
| 290 | mHeaderText.setText(R.string.lockpattern_recording_inprogress); |
Jyun LuoLai | 11960ce | 2018-03-15 14:11:30 +0800 | [diff] [blame] | 291 | if (mDefaultHeaderColorList != null) { |
| 292 | mHeaderText.setTextColor(mDefaultHeaderColorList); |
| 293 | } |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 294 | mFooterText.setText(""); |
pastychang | c3c5a5c | 2019-01-17 15:44:08 +0800 | [diff] [blame] | 295 | mNextButton.setEnabled(false); |
jackqdyulei | 011f0db | 2016-10-21 10:50:34 -0700 | [diff] [blame] | 296 | |
| 297 | if (mTitleHeaderScrollView != null) { |
| 298 | mTitleHeaderScrollView.post(new Runnable() { |
| 299 | @Override |
| 300 | public void run() { |
| 301 | mTitleHeaderScrollView.fullScroll(ScrollView.FOCUS_DOWN); |
| 302 | } |
| 303 | }); |
| 304 | } |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 305 | } |
| 306 | }; |
| 307 | |
Chris Wren | 8a963ba | 2015-03-20 10:29:14 -0400 | [diff] [blame] | 308 | @Override |
Fan Zhang | 6507613 | 2016-08-08 10:25:13 -0700 | [diff] [blame] | 309 | public int getMetricsCategory() { |
Fan Zhang | 31b2100 | 2019-01-16 13:49:47 -0800 | [diff] [blame] | 310 | return SettingsEnums.CHOOSE_LOCK_PATTERN; |
Chris Wren | 8a963ba | 2015-03-20 10:29:14 -0400 | [diff] [blame] | 311 | } |
| 312 | |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 313 | |
| 314 | /** |
| 315 | * The states of the left footer button. |
| 316 | */ |
| 317 | enum LeftButtonMode { |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 318 | Retry(R.string.lockpattern_retry_button_text, true), |
| 319 | RetryDisabled(R.string.lockpattern_retry_button_text, false), |
| 320 | Gone(ID_EMPTY_MESSAGE, false); |
| 321 | |
| 322 | |
| 323 | /** |
| 324 | * @param text The displayed text for this mode. |
| 325 | * @param enabled Whether the button should be enabled. |
| 326 | */ |
| 327 | LeftButtonMode(int text, boolean enabled) { |
| 328 | this.text = text; |
| 329 | this.enabled = enabled; |
| 330 | } |
| 331 | |
| 332 | final int text; |
| 333 | final boolean enabled; |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 334 | } |
| 335 | |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 336 | /** |
| 337 | * The states of the right button. |
| 338 | */ |
| 339 | enum RightButtonMode { |
Maurice Lam | c57b19d | 2017-06-23 19:15:06 -0700 | [diff] [blame] | 340 | Continue(R.string.next_label, true), |
| 341 | ContinueDisabled(R.string.next_label, false), |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 342 | Confirm(R.string.lockpattern_confirm_button_text, true), |
| 343 | ConfirmDisabled(R.string.lockpattern_confirm_button_text, false), |
| 344 | Ok(android.R.string.ok, true); |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 345 | |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 346 | /** |
| 347 | * @param text The displayed text for this mode. |
| 348 | * @param enabled Whether the button should be enabled. |
| 349 | */ |
| 350 | RightButtonMode(int text, boolean enabled) { |
| 351 | this.text = text; |
| 352 | this.enabled = enabled; |
| 353 | } |
| 354 | |
| 355 | final int text; |
| 356 | final boolean enabled; |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 357 | } |
| 358 | |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 359 | /** |
| 360 | * Keep track internally of where the user is in choosing a pattern. |
| 361 | */ |
| 362 | protected enum Stage { |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 363 | |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 364 | Introduction( |
Kevin Chyn | 81dc029 | 2018-06-28 14:59:38 -0700 | [diff] [blame] | 365 | R.string.lock_settings_picker_biometrics_added_security_message, |
Maurice Lam | 7f5e196 | 2017-09-08 17:51:58 -0700 | [diff] [blame] | 366 | R.string.lockpassword_choose_your_pattern_message, |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 367 | R.string.lockpattern_recording_intro_header, |
Ajay Nadathur | a1314df | 2018-01-04 13:06:46 -0800 | [diff] [blame] | 368 | LeftButtonMode.Gone, RightButtonMode.ContinueDisabled, |
Jim Miller | 63cf89a | 2011-08-07 16:06:13 -0700 | [diff] [blame] | 369 | ID_EMPTY_MESSAGE, true), |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 370 | HelpScreen( |
Maurice Lam | 7f5e196 | 2017-09-08 17:51:58 -0700 | [diff] [blame] | 371 | ID_EMPTY_MESSAGE, ID_EMPTY_MESSAGE, R.string.lockpattern_settings_help_how_to_record, |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 372 | LeftButtonMode.Gone, RightButtonMode.Ok, ID_EMPTY_MESSAGE, false), |
| 373 | ChoiceTooShort( |
Kevin Chyn | 81dc029 | 2018-06-28 14:59:38 -0700 | [diff] [blame] | 374 | R.string.lock_settings_picker_biometrics_added_security_message, |
Maurice Lam | 7f5e196 | 2017-09-08 17:51:58 -0700 | [diff] [blame] | 375 | R.string.lockpassword_choose_your_pattern_message, |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 376 | R.string.lockpattern_recording_incorrect_too_short, |
| 377 | LeftButtonMode.Retry, RightButtonMode.ContinueDisabled, |
| 378 | ID_EMPTY_MESSAGE, true), |
| 379 | FirstChoiceValid( |
Kevin Chyn | 81dc029 | 2018-06-28 14:59:38 -0700 | [diff] [blame] | 380 | R.string.lock_settings_picker_biometrics_added_security_message, |
Maurice Lam | 7f5e196 | 2017-09-08 17:51:58 -0700 | [diff] [blame] | 381 | R.string.lockpassword_choose_your_pattern_message, |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 382 | R.string.lockpattern_pattern_entered_header, |
| 383 | LeftButtonMode.Retry, RightButtonMode.Continue, ID_EMPTY_MESSAGE, false), |
| 384 | NeedToConfirm( |
Maurice Lam | 7f5e196 | 2017-09-08 17:51:58 -0700 | [diff] [blame] | 385 | ID_EMPTY_MESSAGE, ID_EMPTY_MESSAGE, R.string.lockpattern_need_to_confirm, |
Ajay Nadathur | a1314df | 2018-01-04 13:06:46 -0800 | [diff] [blame] | 386 | LeftButtonMode.Gone, RightButtonMode.ConfirmDisabled, |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 387 | ID_EMPTY_MESSAGE, true), |
| 388 | ConfirmWrong( |
Maurice Lam | 7f5e196 | 2017-09-08 17:51:58 -0700 | [diff] [blame] | 389 | ID_EMPTY_MESSAGE, ID_EMPTY_MESSAGE, R.string.lockpattern_need_to_unlock_wrong, |
Ajay Nadathur | a1314df | 2018-01-04 13:06:46 -0800 | [diff] [blame] | 390 | LeftButtonMode.Gone, RightButtonMode.ConfirmDisabled, |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 391 | ID_EMPTY_MESSAGE, true), |
| 392 | ChoiceConfirmed( |
Maurice Lam | 7f5e196 | 2017-09-08 17:51:58 -0700 | [diff] [blame] | 393 | ID_EMPTY_MESSAGE, ID_EMPTY_MESSAGE, R.string.lockpattern_pattern_confirmed_header, |
Ajay Nadathur | a1314df | 2018-01-04 13:06:46 -0800 | [diff] [blame] | 394 | LeftButtonMode.Gone, RightButtonMode.Confirm, ID_EMPTY_MESSAGE, false); |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 395 | |
| 396 | |
| 397 | /** |
Kevin Chyn | 81dc029 | 2018-06-28 14:59:38 -0700 | [diff] [blame] | 398 | * @param messageForBiometrics The message displayed at the top, above header for |
Maurice Lam | 7f5e196 | 2017-09-08 17:51:58 -0700 | [diff] [blame] | 399 | * fingerprint flow. |
| 400 | * @param message The message displayed at the top. |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 401 | * @param headerMessage The message displayed at the top. |
| 402 | * @param leftMode The mode of the left button. |
| 403 | * @param rightMode The mode of the right button. |
| 404 | * @param footerMessage The footer message. |
| 405 | * @param patternEnabled Whether the pattern widget is enabled. |
| 406 | */ |
Kevin Chyn | 81dc029 | 2018-06-28 14:59:38 -0700 | [diff] [blame] | 407 | Stage(int messageForBiometrics, int message, int headerMessage, |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 408 | LeftButtonMode leftMode, |
| 409 | RightButtonMode rightMode, |
| 410 | int footerMessage, boolean patternEnabled) { |
| 411 | this.headerMessage = headerMessage; |
Kevin Chyn | 81dc029 | 2018-06-28 14:59:38 -0700 | [diff] [blame] | 412 | this.messageForBiometrics = messageForBiometrics; |
Maurice Lam | 7f5e196 | 2017-09-08 17:51:58 -0700 | [diff] [blame] | 413 | this.message = message; |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 414 | this.leftMode = leftMode; |
| 415 | this.rightMode = rightMode; |
| 416 | this.footerMessage = footerMessage; |
| 417 | this.patternEnabled = patternEnabled; |
| 418 | } |
| 419 | |
| 420 | final int headerMessage; |
Kevin Chyn | 81dc029 | 2018-06-28 14:59:38 -0700 | [diff] [blame] | 421 | final int messageForBiometrics; |
Maurice Lam | 7f5e196 | 2017-09-08 17:51:58 -0700 | [diff] [blame] | 422 | final int message; |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 423 | final LeftButtonMode leftMode; |
| 424 | final RightButtonMode rightMode; |
| 425 | final int footerMessage; |
| 426 | final boolean patternEnabled; |
| 427 | } |
| 428 | |
| 429 | private Stage mUiStage = Stage.Introduction; |
| 430 | |
| 431 | private Runnable mClearPatternRunnable = new Runnable() { |
| 432 | public void run() { |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 433 | mLockPatternView.clearPattern(); |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 434 | } |
| 435 | }; |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 436 | |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 437 | private ChooseLockSettingsHelper mChooseLockSettingsHelper; |
Xiyuan Xia | 3e7e3d6 | 2015-08-25 15:04:57 -0700 | [diff] [blame] | 438 | private SaveAndFinishWorker mSaveAndFinishWorker; |
Ajay Nadathur | a1314df | 2018-01-04 13:06:46 -0800 | [diff] [blame] | 439 | protected int mUserId; |
Ajay Nadathur | 7b1d96a | 2018-01-11 13:25:26 -0800 | [diff] [blame] | 440 | protected boolean mForFingerprint; |
Kevin Chyn | 81dc029 | 2018-06-28 14:59:38 -0700 | [diff] [blame] | 441 | protected boolean mForFace; |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 442 | |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 443 | private static final String KEY_UI_STAGE = "uiStage"; |
| 444 | private static final String KEY_PATTERN_CHOICE = "chosenPattern"; |
Andres Morales | a0e1236 | 2015-04-02 09:00:41 -0700 | [diff] [blame] | 445 | private static final String KEY_CURRENT_PATTERN = "currentPattern"; |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 446 | |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 447 | @Override |
| 448 | public void onCreate(Bundle savedInstanceState) { |
| 449 | super.onCreate(savedInstanceState); |
| 450 | mChooseLockSettingsHelper = new ChooseLockSettingsHelper(getActivity()); |
Amith Yamasani | 6602677 | 2013-09-25 14:05:33 -0700 | [diff] [blame] | 451 | if (!(getActivity() instanceof ChooseLockPattern)) { |
| 452 | throw new SecurityException("Fragment contained in wrong activity"); |
| 453 | } |
Clara Bayarri | fe432e8 | 2015-10-12 12:07:02 +0100 | [diff] [blame] | 454 | Intent intent = getActivity().getIntent(); |
| 455 | // Only take this argument into account if it belongs to the current profile. |
Benjamin Franz | 194300d | 2016-01-13 12:16:25 +0000 | [diff] [blame] | 456 | mUserId = Utils.getUserIdFromBundle(getActivity(), intent.getExtras()); |
Adrian Roos | 62775bf | 2016-01-28 13:23:53 -0800 | [diff] [blame] | 457 | |
| 458 | if (intent.getBooleanExtra( |
| 459 | ChooseLockSettingsHelper.EXTRA_KEY_FOR_CHANGE_CRED_REQUIRED_FOR_BOOT, false)) { |
| 460 | SaveAndFinishWorker w = new SaveAndFinishWorker(); |
| 461 | final boolean required = getActivity().getIntent().getBooleanExtra( |
| 462 | EncryptionInterstitial.EXTRA_REQUIRE_PASSWORD, true); |
Rubin Xu | 010116a | 2019-09-11 17:36:37 +0100 | [diff] [blame] | 463 | LockscreenCredential current = intent.getParcelableExtra( |
Adrian Roos | 62775bf | 2016-01-28 13:23:53 -0800 | [diff] [blame] | 464 | ChooseLockSettingsHelper.EXTRA_KEY_PASSWORD); |
| 465 | w.setBlocking(true); |
| 466 | w.setListener(this); |
| 467 | w.start(mChooseLockSettingsHelper.utils(), required, |
Rubin Xu | 010116a | 2019-09-11 17:36:37 +0100 | [diff] [blame] | 468 | false, 0, current, current, mUserId); |
Adrian Roos | 62775bf | 2016-01-28 13:23:53 -0800 | [diff] [blame] | 469 | } |
Ajay Nadathur | 7af28ec | 2017-07-21 15:11:21 -0700 | [diff] [blame] | 470 | mForFingerprint = intent.getBooleanExtra( |
| 471 | ChooseLockSettingsHelper.EXTRA_KEY_FOR_FINGERPRINT, false); |
Kevin Chyn | 81dc029 | 2018-06-28 14:59:38 -0700 | [diff] [blame] | 472 | mForFace = intent.getBooleanExtra( |
| 473 | ChooseLockSettingsHelper.EXTRA_KEY_FOR_FACE, false); |
The Android Open Source Project | e6dd1fa | 2009-03-18 17:39:48 -0700 | [diff] [blame] | 474 | } |
Jim Miller | 00d2476 | 2009-12-22 19:04:57 -0800 | [diff] [blame] | 475 | |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 476 | @Override |
| 477 | public View onCreateView(LayoutInflater inflater, ViewGroup container, |
| 478 | Bundle savedInstanceState) { |
Maurice Lam | d189ac5 | 2016-06-15 13:39:34 -0700 | [diff] [blame] | 479 | final GlifLayout layout = (GlifLayout) inflater.inflate( |
| 480 | R.layout.choose_lock_pattern, container, false); |
| 481 | layout.setHeaderText(getActivity().getTitle()); |
Maurice Lam | 212dd95 | 2018-02-14 16:02:33 -0800 | [diff] [blame] | 482 | if (getResources().getBoolean(R.bool.config_lock_pattern_minimal_ui)) { |
Maurice Lam | 9c2fae8 | 2019-03-26 18:50:21 -0700 | [diff] [blame] | 483 | View iconView = layout.findViewById(R.id.sud_layout_icon); |
Maurice Lam | 212dd95 | 2018-02-14 16:02:33 -0800 | [diff] [blame] | 484 | if (iconView != null) { |
| 485 | iconView.setVisibility(View.GONE); |
| 486 | } |
| 487 | } else { |
| 488 | if (mForFingerprint) { |
| 489 | layout.setIcon(getActivity().getDrawable(R.drawable.ic_fingerprint_header)); |
Kevin Chyn | 81dc029 | 2018-06-28 14:59:38 -0700 | [diff] [blame] | 490 | } else if (mForFace) { |
| 491 | layout.setIcon(getActivity().getDrawable(R.drawable.ic_face_header)); |
Maurice Lam | 212dd95 | 2018-02-14 16:02:33 -0800 | [diff] [blame] | 492 | } |
Ajay Nadathur | 7af28ec | 2017-07-21 15:11:21 -0700 | [diff] [blame] | 493 | } |
pastychang | c3c5a5c | 2019-01-17 15:44:08 +0800 | [diff] [blame] | 494 | |
pastychang | 9bdb59a | 2019-01-21 09:49:15 +0800 | [diff] [blame] | 495 | final FooterBarMixin mixin = layout.getMixin(FooterBarMixin.class); |
pastychang | c3c5a5c | 2019-01-17 15:44:08 +0800 | [diff] [blame] | 496 | mixin.setSecondaryButton( |
| 497 | new FooterButton.Builder(getActivity()) |
| 498 | .setText(R.string.lockpattern_tutorial_cancel_label) |
| 499 | .setListener(this::onSkipOrClearButtonClick) |
| 500 | .setButtonType(FooterButton.ButtonType.OTHER) |
| 501 | .setTheme(R.style.SudGlifButton_Secondary) |
| 502 | .build() |
| 503 | ); |
| 504 | mixin.setPrimaryButton( |
| 505 | new FooterButton.Builder(getActivity()) |
| 506 | .setText(R.string.lockpattern_tutorial_continue_label) |
| 507 | .setListener(this::onNextButtonClick) |
| 508 | .setButtonType(FooterButton.ButtonType.NEXT) |
| 509 | .setTheme(R.style.SudGlifButton_Primary) |
| 510 | .build() |
| 511 | ); |
| 512 | mSkipOrClearButton = mixin.getSecondaryButton(); |
| 513 | mNextButton = mixin.getPrimaryButton(); |
| 514 | |
Maurice Lam | d189ac5 | 2016-06-15 13:39:34 -0700 | [diff] [blame] | 515 | return layout; |
Maurice Lam | 6b19fa9 | 2014-11-25 19:25:56 -0800 | [diff] [blame] | 516 | } |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 517 | |
Maurice Lam | 6b19fa9 | 2014-11-25 19:25:56 -0800 | [diff] [blame] | 518 | @Override |
| 519 | public void onViewCreated(View view, Bundle savedInstanceState) { |
| 520 | super.onViewCreated(view, savedInstanceState); |
pastychang | 7961482 | 2019-01-03 10:12:54 +0800 | [diff] [blame] | 521 | mTitleText = view.findViewById(R.id.suc_layout_title); |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 522 | mHeaderText = (TextView) view.findViewById(R.id.headerText); |
Jyun LuoLai | 11960ce | 2018-03-15 14:11:30 +0800 | [diff] [blame] | 523 | mDefaultHeaderColorList = mHeaderText.getTextColors(); |
pastychang | fa68ec4 | 2019-04-12 16:22:17 +0800 | [diff] [blame] | 524 | mMessageText = view.findViewById(R.id.sud_layout_description); |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 525 | mLockPatternView = (LockPatternView) view.findViewById(R.id.lockPattern); |
| 526 | mLockPatternView.setOnPatternListener(mChooseNewLockPatternListener); |
| 527 | mLockPatternView.setTactileFeedbackEnabled( |
| 528 | mChooseLockSettingsHelper.utils().isTactileFeedbackEnabled()); |
Vishwath Mohan | 670c252 | 2018-02-16 12:22:57 -0800 | [diff] [blame] | 529 | mLockPatternView.setFadePattern(false); |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 530 | |
| 531 | mFooterText = (TextView) view.findViewById(R.id.footerText); |
| 532 | |
jackqdyulei | 011f0db | 2016-10-21 10:50:34 -0700 | [diff] [blame] | 533 | mTitleHeaderScrollView = (ScrollView) view.findViewById(R.id |
| 534 | .scroll_layout_title_header); |
| 535 | |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 536 | // make it so unhandled touch events within the unlock screen go to the |
| 537 | // lock pattern view. |
| 538 | final LinearLayoutWithDefaultTouchRecepient topLayout |
| 539 | = (LinearLayoutWithDefaultTouchRecepient) view.findViewById( |
| 540 | R.id.topLayout); |
| 541 | topLayout.setDefaultTouchRecepient(mLockPatternView); |
| 542 | |
| 543 | final boolean confirmCredentials = getActivity().getIntent() |
Maurice Lam | 2eb170c | 2017-04-28 16:18:47 -0700 | [diff] [blame] | 544 | .getBooleanExtra(ChooseLockGeneric.CONFIRM_CREDENTIALS, true); |
Andres Morales | 6609b0c | 2015-04-12 15:38:25 -0700 | [diff] [blame] | 545 | Intent intent = getActivity().getIntent(); |
Rubin Xu | 010116a | 2019-09-11 17:36:37 +0100 | [diff] [blame] | 546 | mCurrentCredential = |
| 547 | intent.getParcelableExtra(ChooseLockSettingsHelper.EXTRA_KEY_PASSWORD); |
Andres Morales | 6609b0c | 2015-04-12 15:38:25 -0700 | [diff] [blame] | 548 | mHasChallenge = intent.getBooleanExtra( |
| 549 | ChooseLockSettingsHelper.EXTRA_KEY_HAS_CHALLENGE, false); |
| 550 | mChallenge = intent.getLongExtra(ChooseLockSettingsHelper.EXTRA_KEY_CHALLENGE, 0); |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 551 | |
| 552 | if (savedInstanceState == null) { |
| 553 | if (confirmCredentials) { |
| 554 | // first launch. As a security measure, we're in NeedToConfirm mode until we |
| 555 | // know there isn't an existing password or the user confirms their password. |
| 556 | updateStage(Stage.NeedToConfirm); |
| 557 | boolean launchedConfirmationActivity = |
| 558 | mChooseLockSettingsHelper.launchConfirmationActivity( |
Jorim Jaggi | 8a09b61 | 2015-04-06 17:47:18 -0700 | [diff] [blame] | 559 | CONFIRM_EXISTING_REQUEST, |
Clara Bayarri | fe432e8 | 2015-10-12 12:07:02 +0100 | [diff] [blame] | 560 | getString(R.string.unlock_set_unlock_launch_picker_title), true, |
| 561 | mUserId); |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 562 | if (!launchedConfirmationActivity) { |
| 563 | updateStage(Stage.Introduction); |
| 564 | } |
| 565 | } else { |
| 566 | updateStage(Stage.Introduction); |
| 567 | } |
| 568 | } else { |
| 569 | // restore from previous state |
Rubin Xu | 010116a | 2019-09-11 17:36:37 +0100 | [diff] [blame] | 570 | mChosenPattern = savedInstanceState.getParcelable(KEY_PATTERN_CHOICE); |
Andres Morales | a0e1236 | 2015-04-02 09:00:41 -0700 | [diff] [blame] | 571 | |
Rubin Xu | 010116a | 2019-09-11 17:36:37 +0100 | [diff] [blame] | 572 | if (mCurrentCredential == null) { |
| 573 | mCurrentCredential = savedInstanceState.getParcelable(KEY_CURRENT_PATTERN); |
Andres Morales | a0e1236 | 2015-04-02 09:00:41 -0700 | [diff] [blame] | 574 | } |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 575 | updateStage(Stage.values()[savedInstanceState.getInt(KEY_UI_STAGE)]); |
Xiyuan Xia | 3e7e3d6 | 2015-08-25 15:04:57 -0700 | [diff] [blame] | 576 | |
| 577 | // Re-attach to the exiting worker if there is one. |
| 578 | mSaveAndFinishWorker = (SaveAndFinishWorker) getFragmentManager().findFragmentByTag( |
| 579 | FRAGMENT_TAG_SAVE_AND_FINISH); |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 580 | } |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 581 | } |
| 582 | |
Xiyuan Xia | bf9ac6b | 2015-05-05 16:04:00 -0700 | [diff] [blame] | 583 | @Override |
| 584 | public void onResume() { |
| 585 | super.onResume(); |
Xiyuan Xia | e47a2ab | 2015-09-01 11:29:36 -0700 | [diff] [blame] | 586 | updateStage(mUiStage); |
| 587 | |
Xiyuan Xia | 3e7e3d6 | 2015-08-25 15:04:57 -0700 | [diff] [blame] | 588 | if (mSaveAndFinishWorker != null) { |
| 589 | setRightButtonEnabled(false); |
| 590 | mSaveAndFinishWorker.setListener(this); |
Xiyuan Xia | 3e7e3d6 | 2015-08-25 15:04:57 -0700 | [diff] [blame] | 591 | } |
Xiyuan Xia | bf9ac6b | 2015-05-05 16:04:00 -0700 | [diff] [blame] | 592 | } |
| 593 | |
| 594 | @Override |
| 595 | public void onPause() { |
| 596 | super.onPause(); |
Xiyuan Xia | 3e7e3d6 | 2015-08-25 15:04:57 -0700 | [diff] [blame] | 597 | if (mSaveAndFinishWorker != null) { |
| 598 | mSaveAndFinishWorker.setListener(null); |
Xiyuan Xia | bf9ac6b | 2015-05-05 16:04:00 -0700 | [diff] [blame] | 599 | } |
| 600 | } |
| 601 | |
Maurice Lam | ecd2b7b | 2014-12-01 10:41:49 -0800 | [diff] [blame] | 602 | protected Intent getRedactionInterstitialIntent(Context context) { |
Clara Bayarri | f6077f4 | 2016-01-25 17:21:24 +0000 | [diff] [blame] | 603 | return RedactionInterstitial.createStartIntent(context, mUserId); |
Maurice Lam | ecd2b7b | 2014-12-01 10:41:49 -0800 | [diff] [blame] | 604 | } |
| 605 | |
Maurice Lam | af103b4 | 2014-12-03 15:17:46 -0800 | [diff] [blame] | 606 | public void handleLeftButton() { |
| 607 | if (mUiStage.leftMode == LeftButtonMode.Retry) { |
Rubin Xu | 0008986 | 2019-11-14 10:51:29 +0000 | [diff] [blame] | 608 | if (mChosenPattern != null) { |
| 609 | mChosenPattern.zeroize(); |
| 610 | mChosenPattern = null; |
| 611 | } |
Maurice Lam | af103b4 | 2014-12-03 15:17:46 -0800 | [diff] [blame] | 612 | mLockPatternView.clearPattern(); |
| 613 | updateStage(Stage.Introduction); |
Maurice Lam | af103b4 | 2014-12-03 15:17:46 -0800 | [diff] [blame] | 614 | } else { |
| 615 | throw new IllegalStateException("left footer button pressed, but stage of " + |
| 616 | mUiStage + " doesn't make sense"); |
| 617 | } |
| 618 | } |
| 619 | |
| 620 | public void handleRightButton() { |
| 621 | if (mUiStage.rightMode == RightButtonMode.Continue) { |
| 622 | if (mUiStage != Stage.FirstChoiceValid) { |
| 623 | throw new IllegalStateException("expected ui stage " |
| 624 | + Stage.FirstChoiceValid + " when button is " |
| 625 | + RightButtonMode.Continue); |
| 626 | } |
| 627 | updateStage(Stage.NeedToConfirm); |
| 628 | } else if (mUiStage.rightMode == RightButtonMode.Confirm) { |
| 629 | if (mUiStage != Stage.ChoiceConfirmed) { |
| 630 | throw new IllegalStateException("expected ui stage " + Stage.ChoiceConfirmed |
| 631 | + " when button is " + RightButtonMode.Confirm); |
| 632 | } |
Xiyuan Xia | 3e7e3d6 | 2015-08-25 15:04:57 -0700 | [diff] [blame] | 633 | startSaveAndFinish(); |
Maurice Lam | af103b4 | 2014-12-03 15:17:46 -0800 | [diff] [blame] | 634 | } else if (mUiStage.rightMode == RightButtonMode.Ok) { |
| 635 | if (mUiStage != Stage.HelpScreen) { |
| 636 | throw new IllegalStateException("Help screen is only mode with ok button, " |
| 637 | + "but stage is " + mUiStage); |
| 638 | } |
| 639 | mLockPatternView.clearPattern(); |
| 640 | mLockPatternView.setDisplayMode(DisplayMode.Correct); |
| 641 | updateStage(Stage.Introduction); |
| 642 | } |
| 643 | } |
| 644 | |
pastychang | c3c5a5c | 2019-01-17 15:44:08 +0800 | [diff] [blame] | 645 | protected void onSkipOrClearButtonClick(View view) { |
| 646 | handleLeftButton(); |
| 647 | } |
| 648 | |
| 649 | protected void onNextButtonClick(View view) { |
| 650 | handleRightButton(); |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 651 | } |
| 652 | |
| 653 | public boolean onKeyDown(int keyCode, KeyEvent event) { |
| 654 | if (keyCode == KeyEvent.KEYCODE_BACK && event.getRepeatCount() == 0) { |
| 655 | if (mUiStage == Stage.HelpScreen) { |
| 656 | updateStage(Stage.Introduction); |
| 657 | return true; |
| 658 | } |
| 659 | } |
| 660 | if (keyCode == KeyEvent.KEYCODE_MENU && mUiStage == Stage.Introduction) { |
| 661 | updateStage(Stage.HelpScreen); |
| 662 | return true; |
| 663 | } |
| 664 | return false; |
| 665 | } |
| 666 | |
| 667 | public void onSaveInstanceState(Bundle outState) { |
| 668 | super.onSaveInstanceState(outState); |
| 669 | |
| 670 | outState.putInt(KEY_UI_STAGE, mUiStage.ordinal()); |
| 671 | if (mChosenPattern != null) { |
Rubin Xu | 010116a | 2019-09-11 17:36:37 +0100 | [diff] [blame] | 672 | outState.putParcelable(KEY_PATTERN_CHOICE, mChosenPattern); |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 673 | } |
Andres Morales | a0e1236 | 2015-04-02 09:00:41 -0700 | [diff] [blame] | 674 | |
Rubin Xu | 010116a | 2019-09-11 17:36:37 +0100 | [diff] [blame] | 675 | if (mCurrentCredential != null) { |
| 676 | outState.putParcelable(KEY_CURRENT_PATTERN, mCurrentCredential); |
Andres Morales | a0e1236 | 2015-04-02 09:00:41 -0700 | [diff] [blame] | 677 | } |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 678 | } |
| 679 | |
| 680 | /** |
| 681 | * Updates the messages and buttons appropriate to what stage the user |
| 682 | * is at in choosing a view. This doesn't handle clearing out the pattern; |
| 683 | * the pattern is expected to be in the right state. |
| 684 | * @param stage |
| 685 | */ |
| 686 | protected void updateStage(Stage stage) { |
alanv | eef72c3 | 2012-10-03 17:10:50 -0700 | [diff] [blame] | 687 | final Stage previousStage = mUiStage; |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 688 | |
| 689 | mUiStage = stage; |
| 690 | |
| 691 | // header text, footer text, visibility and |
| 692 | // enabled state all known from the stage |
| 693 | if (stage == Stage.ChoiceTooShort) { |
| 694 | mHeaderText.setText( |
| 695 | getResources().getString( |
| 696 | stage.headerMessage, |
| 697 | LockPatternUtils.MIN_LOCK_PATTERN_SIZE)); |
| 698 | } else { |
| 699 | mHeaderText.setText(stage.headerMessage); |
| 700 | } |
Kevin Chyn | 81dc029 | 2018-06-28 14:59:38 -0700 | [diff] [blame] | 701 | final boolean forBiometrics = mForFingerprint || mForFace; |
| 702 | int message = forBiometrics ? stage.messageForBiometrics : stage.message; |
Maurice Lam | 7f5e196 | 2017-09-08 17:51:58 -0700 | [diff] [blame] | 703 | if (message == ID_EMPTY_MESSAGE) { |
| 704 | mMessageText.setText(""); |
| 705 | } else { |
| 706 | mMessageText.setText(message); |
| 707 | } |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 708 | if (stage.footerMessage == ID_EMPTY_MESSAGE) { |
| 709 | mFooterText.setText(""); |
| 710 | } else { |
| 711 | mFooterText.setText(stage.footerMessage); |
| 712 | } |
| 713 | |
Jyun LuoLai | 11960ce | 2018-03-15 14:11:30 +0800 | [diff] [blame] | 714 | if (stage == Stage.ConfirmWrong || stage == Stage.ChoiceTooShort) { |
| 715 | TypedValue typedValue = new TypedValue(); |
| 716 | Theme theme = getActivity().getTheme(); |
| 717 | theme.resolveAttribute(R.attr.colorError, typedValue, true); |
| 718 | mHeaderText.setTextColor(typedValue.data); |
| 719 | |
| 720 | } else { |
| 721 | if (mDefaultHeaderColorList != null) { |
| 722 | mHeaderText.setTextColor(mDefaultHeaderColorList); |
| 723 | } |
| 724 | |
Kevin Chyn | 81dc029 | 2018-06-28 14:59:38 -0700 | [diff] [blame] | 725 | if (stage == Stage.NeedToConfirm && forBiometrics) { |
Jyun LuoLai | 11960ce | 2018-03-15 14:11:30 +0800 | [diff] [blame] | 726 | mHeaderText.setText(""); |
| 727 | mTitleText.setText(R.string.lockpassword_draw_your_pattern_again_header); |
| 728 | } |
| 729 | } |
| 730 | |
pastychang | c3c5a5c | 2019-01-17 15:44:08 +0800 | [diff] [blame] | 731 | updateFooterLeftButton(stage); |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 732 | |
Maurice Lam | af103b4 | 2014-12-03 15:17:46 -0800 | [diff] [blame] | 733 | setRightButtonText(stage.rightMode.text); |
| 734 | setRightButtonEnabled(stage.rightMode.enabled); |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 735 | |
Xiyuan Xia | 3e7e3d6 | 2015-08-25 15:04:57 -0700 | [diff] [blame] | 736 | // same for whether the pattern is enabled |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 737 | if (stage.patternEnabled) { |
| 738 | mLockPatternView.enableInput(); |
| 739 | } else { |
| 740 | mLockPatternView.disableInput(); |
| 741 | } |
| 742 | |
| 743 | // the rest of the stuff varies enough that it is easier just to handle |
| 744 | // on a case by case basis. |
| 745 | mLockPatternView.setDisplayMode(DisplayMode.Correct); |
Selim Cinek | 00da4f6 | 2015-06-25 17:42:58 -0400 | [diff] [blame] | 746 | boolean announceAlways = false; |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 747 | |
| 748 | switch (mUiStage) { |
| 749 | case Introduction: |
| 750 | mLockPatternView.clearPattern(); |
| 751 | break; |
| 752 | case HelpScreen: |
| 753 | mLockPatternView.setPattern(DisplayMode.Animate, mAnimatePattern); |
| 754 | break; |
| 755 | case ChoiceTooShort: |
| 756 | mLockPatternView.setDisplayMode(DisplayMode.Wrong); |
| 757 | postClearPatternRunnable(); |
Selim Cinek | 00da4f6 | 2015-06-25 17:42:58 -0400 | [diff] [blame] | 758 | announceAlways = true; |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 759 | break; |
| 760 | case FirstChoiceValid: |
| 761 | break; |
| 762 | case NeedToConfirm: |
| 763 | mLockPatternView.clearPattern(); |
| 764 | break; |
| 765 | case ConfirmWrong: |
| 766 | mLockPatternView.setDisplayMode(DisplayMode.Wrong); |
| 767 | postClearPatternRunnable(); |
Selim Cinek | 00da4f6 | 2015-06-25 17:42:58 -0400 | [diff] [blame] | 768 | announceAlways = true; |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 769 | break; |
| 770 | case ChoiceConfirmed: |
| 771 | break; |
| 772 | } |
alanv | eef72c3 | 2012-10-03 17:10:50 -0700 | [diff] [blame] | 773 | |
| 774 | // If the stage changed, announce the header for accessibility. This |
| 775 | // is a no-op when accessibility is disabled. |
Selim Cinek | 00da4f6 | 2015-06-25 17:42:58 -0400 | [diff] [blame] | 776 | if (previousStage != stage || announceAlways) { |
alanv | eef72c3 | 2012-10-03 17:10:50 -0700 | [diff] [blame] | 777 | mHeaderText.announceForAccessibility(mHeaderText.getText()); |
| 778 | } |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 779 | } |
| 780 | |
pastychang | c3c5a5c | 2019-01-17 15:44:08 +0800 | [diff] [blame] | 781 | protected void updateFooterLeftButton(Stage stage) { |
Ajay Nadathur | 7b1d96a | 2018-01-11 13:25:26 -0800 | [diff] [blame] | 782 | if (stage.leftMode == LeftButtonMode.Gone) { |
pastychang | c3c5a5c | 2019-01-17 15:44:08 +0800 | [diff] [blame] | 783 | mSkipOrClearButton.setVisibility(View.GONE); |
Ajay Nadathur | 7b1d96a | 2018-01-11 13:25:26 -0800 | [diff] [blame] | 784 | } else { |
pastychang | c3c5a5c | 2019-01-17 15:44:08 +0800 | [diff] [blame] | 785 | mSkipOrClearButton.setVisibility(View.VISIBLE); |
| 786 | mSkipOrClearButton.setText(getActivity(), stage.leftMode.text); |
| 787 | mSkipOrClearButton.setEnabled(stage.leftMode.enabled); |
Ajay Nadathur | 7b1d96a | 2018-01-11 13:25:26 -0800 | [diff] [blame] | 788 | } |
| 789 | } |
| 790 | |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 791 | // clear the wrong pattern unless they have started a new one |
| 792 | // already |
| 793 | private void postClearPatternRunnable() { |
| 794 | mLockPatternView.removeCallbacks(mClearPatternRunnable); |
| 795 | mLockPatternView.postDelayed(mClearPatternRunnable, WRONG_PATTERN_CLEAR_TIMEOUT_MS); |
| 796 | } |
| 797 | |
Xiyuan Xia | 3e7e3d6 | 2015-08-25 15:04:57 -0700 | [diff] [blame] | 798 | private void startSaveAndFinish() { |
| 799 | if (mSaveAndFinishWorker != null) { |
| 800 | Log.w(TAG, "startSaveAndFinish with an existing SaveAndFinishWorker."); |
| 801 | return; |
| 802 | } |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 803 | |
Xiyuan Xia | 3e7e3d6 | 2015-08-25 15:04:57 -0700 | [diff] [blame] | 804 | setRightButtonEnabled(false); |
Adrian Roos | 90d6c56 | 2014-11-24 17:17:13 +0100 | [diff] [blame] | 805 | |
Xiyuan Xia | 3e7e3d6 | 2015-08-25 15:04:57 -0700 | [diff] [blame] | 806 | mSaveAndFinishWorker = new SaveAndFinishWorker(); |
Robin Lee | 5bb1e4f | 2016-01-27 17:21:00 +0000 | [diff] [blame] | 807 | mSaveAndFinishWorker.setListener(this); |
| 808 | |
Xiyuan Xia | 3e7e3d6 | 2015-08-25 15:04:57 -0700 | [diff] [blame] | 809 | getFragmentManager().beginTransaction().add(mSaveAndFinishWorker, |
| 810 | FRAGMENT_TAG_SAVE_AND_FINISH).commit(); |
Robin Lee | 5bb1e4f | 2016-01-27 17:21:00 +0000 | [diff] [blame] | 811 | getFragmentManager().executePendingTransactions(); |
Paul Lawrence | cff37ec | 2015-08-03 09:44:23 -0700 | [diff] [blame] | 812 | |
Xiyuan Xia | 3e7e3d6 | 2015-08-25 15:04:57 -0700 | [diff] [blame] | 813 | final boolean required = getActivity().getIntent().getBooleanExtra( |
Jim Miller | 0698a21 | 2014-10-16 19:49:07 -0700 | [diff] [blame] | 814 | EncryptionInterstitial.EXTRA_REQUIRE_PASSWORD, true); |
Xiyuan Xia | 3e7e3d6 | 2015-08-25 15:04:57 -0700 | [diff] [blame] | 815 | mSaveAndFinishWorker.start(mChooseLockSettingsHelper.utils(), required, |
Rubin Xu | 010116a | 2019-09-11 17:36:37 +0100 | [diff] [blame] | 816 | mHasChallenge, mChallenge, mChosenPattern, mCurrentCredential, mUserId); |
Xiyuan Xia | bf9ac6b | 2015-05-05 16:04:00 -0700 | [diff] [blame] | 817 | } |
| 818 | |
Xiyuan Xia | 3e7e3d6 | 2015-08-25 15:04:57 -0700 | [diff] [blame] | 819 | @Override |
| 820 | public void onChosenLockSaveFinished(boolean wasSecureBefore, Intent resultData) { |
| 821 | getActivity().setResult(RESULT_FINISHED, resultData); |
Xiyuan Xia | 3e7e3d6 | 2015-08-25 15:04:57 -0700 | [diff] [blame] | 822 | |
Rubin Xu | 010116a | 2019-09-11 17:36:37 +0100 | [diff] [blame] | 823 | if (mChosenPattern != null) { |
| 824 | mChosenPattern.zeroize(); |
| 825 | } |
| 826 | if (mCurrentCredential != null) { |
| 827 | mCurrentCredential.zeroize(); |
Rich Cannings | b27c430 | 2019-02-19 13:15:30 -0800 | [diff] [blame] | 828 | } |
| 829 | |
Xiyuan Xia | 3e7e3d6 | 2015-08-25 15:04:57 -0700 | [diff] [blame] | 830 | if (!wasSecureBefore) { |
| 831 | Intent intent = getRedactionInterstitialIntent(getActivity()); |
| 832 | if (intent != null) { |
| 833 | startActivity(intent); |
| 834 | } |
| 835 | } |
Udam Saini | 686ae49 | 2016-02-02 17:02:29 -0800 | [diff] [blame] | 836 | getActivity().finish(); |
Xiyuan Xia | 3e7e3d6 | 2015-08-25 15:04:57 -0700 | [diff] [blame] | 837 | } |
| 838 | } |
| 839 | |
Clara Bayarri | 77c4345 | 2016-06-23 11:11:42 +0100 | [diff] [blame] | 840 | public static class SaveAndFinishWorker extends SaveChosenLockWorkerBase { |
Xiyuan Xia | 3e7e3d6 | 2015-08-25 15:04:57 -0700 | [diff] [blame] | 841 | |
Rubin Xu | 010116a | 2019-09-11 17:36:37 +0100 | [diff] [blame] | 842 | private LockscreenCredential mChosenPattern; |
| 843 | private LockscreenCredential mCurrentCredential; |
Xiyuan Xia | 3e7e3d6 | 2015-08-25 15:04:57 -0700 | [diff] [blame] | 844 | private boolean mLockVirgin; |
| 845 | |
Rubin Xu | 010116a | 2019-09-11 17:36:37 +0100 | [diff] [blame] | 846 | public void start(LockPatternUtils utils, boolean credentialRequired, boolean hasChallenge, |
| 847 | long challenge, LockscreenCredential chosenPattern, |
| 848 | LockscreenCredential currentCredential, int userId) { |
Clara Bayarri | b8a22e4 | 2015-12-18 16:40:18 +0000 | [diff] [blame] | 849 | prepare(utils, credentialRequired, hasChallenge, challenge, userId); |
Xiyuan Xia | 3e7e3d6 | 2015-08-25 15:04:57 -0700 | [diff] [blame] | 850 | |
Rubin Xu | 010116a | 2019-09-11 17:36:37 +0100 | [diff] [blame] | 851 | mCurrentCredential = currentCredential != null ? currentCredential |
| 852 | : LockscreenCredential.createNone(); |
Xiyuan Xia | 3e7e3d6 | 2015-08-25 15:04:57 -0700 | [diff] [blame] | 853 | mChosenPattern = chosenPattern; |
Clara Bayarri | fe432e8 | 2015-10-12 12:07:02 +0100 | [diff] [blame] | 854 | mUserId = userId; |
Xiyuan Xia | 3e7e3d6 | 2015-08-25 15:04:57 -0700 | [diff] [blame] | 855 | |
Clara Bayarri | fe432e8 | 2015-10-12 12:07:02 +0100 | [diff] [blame] | 856 | mLockVirgin = !mUtils.isPatternEverChosen(mUserId); |
Xiyuan Xia | 3e7e3d6 | 2015-08-25 15:04:57 -0700 | [diff] [blame] | 857 | |
| 858 | start(); |
| 859 | } |
| 860 | |
| 861 | @Override |
Irina Dumitrescu | 4b96dc3 | 2019-02-28 15:35:36 +0000 | [diff] [blame] | 862 | protected Pair<Boolean, Intent> saveAndVerifyInBackground() { |
Clara Bayarri | fe432e8 | 2015-10-12 12:07:02 +0100 | [diff] [blame] | 863 | final int userId = mUserId; |
Rubin Xu | 010116a | 2019-09-11 17:36:37 +0100 | [diff] [blame] | 864 | final boolean success = mUtils.setLockCredential(mChosenPattern, mCurrentCredential, |
| 865 | userId); |
Irina Dumitrescu | 4b96dc3 | 2019-02-28 15:35:36 +0000 | [diff] [blame] | 866 | Intent result = null; |
| 867 | if (success && mHasChallenge) { |
Xiyuan Xia | 3e7e3d6 | 2015-08-25 15:04:57 -0700 | [diff] [blame] | 868 | byte[] token; |
| 869 | try { |
Rubin Xu | 010116a | 2019-09-11 17:36:37 +0100 | [diff] [blame] | 870 | token = mUtils.verifyCredential(mChosenPattern, mChallenge, userId); |
Xiyuan Xia | 3e7e3d6 | 2015-08-25 15:04:57 -0700 | [diff] [blame] | 871 | } catch (RequestThrottledException e) { |
| 872 | token = null; |
| 873 | } |
| 874 | |
| 875 | if (token == null) { |
| 876 | Log.e(TAG, "critical: no token returned for known good pattern"); |
| 877 | } |
| 878 | |
| 879 | result = new Intent(); |
| 880 | result.putExtra(ChooseLockSettingsHelper.EXTRA_KEY_CHALLENGE_TOKEN, token); |
| 881 | } |
Irina Dumitrescu | 4b96dc3 | 2019-02-28 15:35:36 +0000 | [diff] [blame] | 882 | return Pair.create(success, result); |
Xiyuan Xia | 3e7e3d6 | 2015-08-25 15:04:57 -0700 | [diff] [blame] | 883 | } |
| 884 | |
| 885 | @Override |
| 886 | protected void finish(Intent resultData) { |
| 887 | if (mLockVirgin) { |
Clara Bayarri | fe432e8 | 2015-10-12 12:07:02 +0100 | [diff] [blame] | 888 | mUtils.setVisiblePatternEnabled(true, mUserId); |
Xiyuan Xia | 3e7e3d6 | 2015-08-25 15:04:57 -0700 | [diff] [blame] | 889 | } |
| 890 | |
| 891 | super.finish(resultData); |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 892 | } |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 893 | } |
| 894 | } |