Dianne Hackborn | abc3dc6 | 2010-01-20 13:40:19 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2010 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; |
Dianne Hackborn | abc3dc6 | 2010-01-20 13:40:19 -0800 | [diff] [blame] | 18 | |
Steven Ng | 4fdcec7 | 2016-09-26 22:13:08 +0100 | [diff] [blame] | 19 | import static android.app.admin.DevicePolicyManager.ACTION_SET_NEW_PARENT_PROFILE_PASSWORD; |
| 20 | import static android.app.admin.DevicePolicyManager.ACTION_SET_NEW_PASSWORD; |
Bernard Chau | 92db5bf | 2018-12-17 18:03:24 +0000 | [diff] [blame] | 21 | import static android.app.admin.DevicePolicyManager.PASSWORD_COMPLEXITY_HIGH; |
| 22 | import static android.app.admin.DevicePolicyManager.PASSWORD_COMPLEXITY_LOW; |
| 23 | import static android.app.admin.DevicePolicyManager.PASSWORD_COMPLEXITY_MEDIUM; |
| 24 | import static android.app.admin.DevicePolicyManager.PASSWORD_COMPLEXITY_NONE; |
Fan Zhang | 23f8d59 | 2018-08-28 15:11:40 -0700 | [diff] [blame] | 25 | |
Fan Zhang | 9864a70 | 2018-11-27 11:29:09 -0800 | [diff] [blame] | 26 | import static com.android.settings.password.ChooseLockPassword.ChooseLockPasswordFragment.RESULT_FINISHED; |
Bernard Chau | 92db5bf | 2018-12-17 18:03:24 +0000 | [diff] [blame] | 27 | import static com.android.settings.password.ChooseLockSettingsHelper.EXTRA_KEY_CALLER_APP_NAME; |
Alex Kershaw | 29d2bff | 2019-05-17 15:36:28 +0100 | [diff] [blame] | 28 | import static com.android.settings.password.ChooseLockSettingsHelper.EXTRA_KEY_IS_CALLING_APP_ADMIN; |
Bernard Chau | 92db5bf | 2018-12-17 18:03:24 +0000 | [diff] [blame] | 29 | import static com.android.settings.password.ChooseLockSettingsHelper.EXTRA_KEY_REQUESTED_MIN_COMPLEXITY; |
Steven Ng | 4fdcec7 | 2016-09-26 22:13:08 +0100 | [diff] [blame] | 30 | |
Svetoslav | 5244844 | 2014-09-29 18:15:45 -0700 | [diff] [blame] | 31 | import android.accessibilityservice.AccessibilityServiceInfo; |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 32 | import android.app.Activity; |
Lucky Zhang | 3bcea02 | 2014-11-25 18:22:14 -0800 | [diff] [blame] | 33 | import android.app.Dialog; |
Dianne Hackborn | 4037c7f | 2010-02-26 17:26:55 -0800 | [diff] [blame] | 34 | import android.app.admin.DevicePolicyManager; |
Bernard Chau | 92db5bf | 2018-12-17 18:03:24 +0000 | [diff] [blame] | 35 | import android.app.admin.DevicePolicyManager.PasswordComplexity; |
Fan Zhang | 31b2100 | 2019-01-16 13:49:47 -0800 | [diff] [blame] | 36 | import android.app.settings.SettingsEnums; |
Dianne Hackborn | abc3dc6 | 2010-01-20 13:40:19 -0800 | [diff] [blame] | 37 | import android.content.Context; |
| 38 | import android.content.Intent; |
Kevin Chyn | 0b95687 | 2018-06-29 13:09:32 -0700 | [diff] [blame] | 39 | import android.hardware.face.FaceManager; |
Jim Miller | 595982d | 2015-04-01 16:49:33 -0700 | [diff] [blame] | 40 | import android.hardware.fingerprint.FingerprintManager; |
Jason Monk | 39b4674 | 2015-09-10 15:52:51 -0400 | [diff] [blame] | 41 | import android.os.Bundle; |
Jason Monk | 39b4674 | 2015-09-10 15:52:51 -0400 | [diff] [blame] | 42 | import android.os.UserHandle; |
Xiaohui Chen | f9ee84d | 2015-10-21 11:25:35 -0700 | [diff] [blame] | 43 | import android.os.UserManager; |
Paul Lawrence | 23c2acf | 2016-03-10 13:54:56 -0800 | [diff] [blame] | 44 | import android.os.storage.StorageManager; |
Adrian Roos | 62775bf | 2016-01-28 13:23:53 -0800 | [diff] [blame] | 45 | import android.text.TextUtils; |
rich cannings | 27d6f8d | 2013-05-29 14:54:58 -0700 | [diff] [blame] | 46 | import android.util.EventLog; |
Lucky Zhang | 3bcea02 | 2014-11-25 18:22:14 -0800 | [diff] [blame] | 47 | import android.util.Log; |
Svetoslav | 5244844 | 2014-09-29 18:15:45 -0700 | [diff] [blame] | 48 | import android.view.accessibility.AccessibilityManager; |
Steven Ng | 4fdcec7 | 2016-09-26 22:13:08 +0100 | [diff] [blame] | 49 | import android.widget.TextView; |
Jim Miller | d16c9b7 | 2015-03-24 16:02:59 -0700 | [diff] [blame] | 50 | |
Fan Zhang | 23f8d59 | 2018-08-28 15:11:40 -0700 | [diff] [blame] | 51 | import androidx.annotation.StringRes; |
| 52 | import androidx.annotation.VisibleForTesting; |
| 53 | import androidx.appcompat.app.AlertDialog; |
| 54 | import androidx.fragment.app.Fragment; |
| 55 | import androidx.fragment.app.FragmentManager; |
| 56 | import androidx.preference.Preference; |
| 57 | import androidx.preference.PreferenceScreen; |
| 58 | |
Gilles Debunne | 6465054 | 2011-08-23 11:01:35 -0700 | [diff] [blame] | 59 | import com.android.internal.widget.LockPatternUtils; |
Rubin Xu | 010116a | 2019-09-11 17:36:37 +0100 | [diff] [blame] | 60 | import com.android.internal.widget.LockscreenCredential; |
Maurice Lam | 2eb170c | 2017-04-28 16:18:47 -0700 | [diff] [blame] | 61 | import com.android.settings.EncryptionInterstitial; |
| 62 | import com.android.settings.EventLogTags; |
| 63 | import com.android.settings.R; |
| 64 | import com.android.settings.SettingsActivity; |
| 65 | import com.android.settings.SettingsPreferenceFragment; |
| 66 | import com.android.settings.Utils; |
Kevin Chyn | 5ab064f | 2019-04-12 15:19:12 -0700 | [diff] [blame] | 67 | import com.android.settings.biometrics.BiometricEnrollActivity; |
Kevin Chyn | 4882e87 | 2018-06-25 17:58:31 -0700 | [diff] [blame] | 68 | import com.android.settings.biometrics.BiometricEnrollBase; |
Kevin Chyn | 81dc029 | 2018-06-28 14:59:38 -0700 | [diff] [blame] | 69 | import com.android.settings.core.instrumentation.InstrumentedDialogFragment; |
Raff Tsai | 4778a9a | 2018-08-29 23:22:12 +0800 | [diff] [blame] | 70 | import com.android.settings.search.SearchFeatureProvider; |
Maurice Lam | 2eb170c | 2017-04-28 16:18:47 -0700 | [diff] [blame] | 71 | import com.android.settingslib.RestrictedLockUtils.EnforcedAdmin; |
Philip P. Moltmann | e3f7211 | 2018-08-28 15:01:43 -0700 | [diff] [blame] | 72 | import com.android.settingslib.RestrictedLockUtilsInternal; |
Sudheer Shanka | 9c32468 | 2016-01-18 11:17:23 +0000 | [diff] [blame] | 73 | import com.android.settingslib.RestrictedPreference; |
| 74 | |
Raff Tsai | c898775 | 2019-10-18 09:57:49 +0800 | [diff] [blame] | 75 | import com.google.android.setupcompat.util.WizardManagerHelper; |
Ricky Wai | 751de37 | 2016-04-06 15:28:28 +0100 | [diff] [blame] | 76 | |
Fabrice Di Meglio | 263bcc8 | 2014-01-17 19:17:58 -0800 | [diff] [blame] | 77 | public class ChooseLockGeneric extends SettingsActivity { |
Jim Miller | 0698a21 | 2014-10-16 19:49:07 -0700 | [diff] [blame] | 78 | public static final String CONFIRM_CREDENTIALS = "confirm_credentials"; |
Dianne Hackborn | abc3dc6 | 2010-01-20 13:40:19 -0800 | [diff] [blame] | 79 | |
| 80 | @Override |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 81 | public Intent getIntent() { |
| 82 | Intent modIntent = new Intent(super.getIntent()); |
Maurice Lam | 52c75ba | 2014-11-25 14:06:38 -0800 | [diff] [blame] | 83 | modIntent.putExtra(EXTRA_SHOW_FRAGMENT, getFragmentClass().getName()); |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 84 | return modIntent; |
| 85 | } |
Jim Miller | bbb4afa | 2010-04-08 19:40:19 -0700 | [diff] [blame] | 86 | |
Amith Yamasani | a677ee2 | 2013-07-26 13:38:41 -0700 | [diff] [blame] | 87 | @Override |
| 88 | protected boolean isValidFragment(String fragmentName) { |
| 89 | if (ChooseLockGenericFragment.class.getName().equals(fragmentName)) return true; |
| 90 | return false; |
| 91 | } |
| 92 | |
Maurice Lam | 52c75ba | 2014-11-25 14:06:38 -0800 | [diff] [blame] | 93 | /* package */ Class<? extends Fragment> getFragmentClass() { |
| 94 | return ChooseLockGenericFragment.class; |
| 95 | } |
| 96 | |
Amith Yamasani | 6602677 | 2013-09-25 14:05:33 -0700 | [diff] [blame] | 97 | public static class InternalActivity extends ChooseLockGeneric { |
| 98 | } |
| 99 | |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 100 | public static class ChooseLockGenericFragment extends SettingsPreferenceFragment { |
Maurice Lam | edb3944 | 2017-04-27 18:54:33 -0700 | [diff] [blame] | 101 | |
Jim Miller | 3fb2fb8 | 2015-03-11 20:17:39 -0700 | [diff] [blame] | 102 | private static final String TAG = "ChooseLockGenericFragment"; |
Steven Ng | 4fdcec7 | 2016-09-26 22:13:08 +0100 | [diff] [blame] | 103 | private static final String KEY_SKIP_FINGERPRINT = "unlock_skip_fingerprint"; |
Kevin Chyn | 81dc029 | 2018-06-28 14:59:38 -0700 | [diff] [blame] | 104 | private static final String KEY_SKIP_FACE = "unlock_skip_face"; |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 105 | private static final String PASSWORD_CONFIRMED = "password_confirmed"; |
Jim Miller | 47f1cd4 | 2012-04-27 18:11:03 -0700 | [diff] [blame] | 106 | private static final String WAITING_FOR_CONFIRMATION = "waiting_for_confirmation"; |
Brian Carlstrom | d4023b7 | 2011-05-25 13:24:20 -0700 | [diff] [blame] | 107 | public static final String MINIMUM_QUALITY_KEY = "minimum_quality"; |
Jim Miller | 3fb2fb8 | 2015-03-11 20:17:39 -0700 | [diff] [blame] | 108 | public static final String HIDE_DISABLED_PREFS = "hide_disabled_prefs"; |
Lucky Zhang | 3bcea02 | 2014-11-25 18:22:14 -0800 | [diff] [blame] | 109 | public static final String TAG_FRP_WARNING_DIALOG = "frp_warning_dialog"; |
Sunny Shao | 1bebe19 | 2019-08-12 20:33:47 +0800 | [diff] [blame] | 110 | public static final String KEY_LOCK_SETTINGS_FOOTER ="lock_settings_footer"; |
Jim Miller | bbb4afa | 2010-04-08 19:40:19 -0700 | [diff] [blame] | 111 | |
Maurice Lam | edb3944 | 2017-04-27 18:54:33 -0700 | [diff] [blame] | 112 | /** |
| 113 | * Boolean extra determining whether a "screen lock options" button should be shown. This |
| 114 | * extra is both sent and received by ChooseLockGeneric. |
| 115 | * |
| 116 | * When this extra is false, nothing will be done. |
| 117 | * When ChooseLockGeneric receives this extra set as true, and if ChooseLockGeneric is |
| 118 | * starting ChooseLockPassword or ChooseLockPattern automatically without user interaction, |
| 119 | * ChooseLockGeneric will set this extra to true when starting ChooseLockPassword/Pattern. |
| 120 | * |
| 121 | * This gives the user the choice to select a different screen lock type, even if |
| 122 | * ChooseLockGeneric selected a default. |
| 123 | */ |
| 124 | public static final String EXTRA_SHOW_OPTIONS_BUTTON = "show_options_button"; |
| 125 | |
| 126 | /** |
| 127 | * Original intent extras used to start this activity. This is passed to ChooseLockPassword |
| 128 | * when the "screen lock options" button is shown, so that when that button is clicked, |
| 129 | * ChooseLockGeneric can be relaunched with the same extras. |
| 130 | */ |
| 131 | public static final String EXTRA_CHOOSE_LOCK_GENERIC_EXTRAS = "choose_lock_generic_extras"; |
| 132 | |
Doris Ling | 06d264d | 2018-06-12 16:33:05 -0700 | [diff] [blame] | 133 | @VisibleForTesting |
| 134 | static final int CONFIRM_EXISTING_REQUEST = 100; |
Raff Tsai | 4778a9a | 2018-08-29 23:22:12 +0800 | [diff] [blame] | 135 | @VisibleForTesting |
| 136 | static final int ENABLE_ENCRYPTION_REQUEST = 101; |
| 137 | @VisibleForTesting |
| 138 | static final int CHOOSE_LOCK_REQUEST = 102; |
| 139 | @VisibleForTesting |
Kevin Chyn | 5ab064f | 2019-04-12 15:19:12 -0700 | [diff] [blame] | 140 | static final int CHOOSE_LOCK_BEFORE_BIOMETRIC_REQUEST = 103; |
Raff Tsai | 4778a9a | 2018-08-29 23:22:12 +0800 | [diff] [blame] | 141 | @VisibleForTesting |
| 142 | static final int SKIP_FINGERPRINT_REQUEST = 104; |
Danielle Millett | 80412e7 | 2011-10-17 19:21:19 -0400 | [diff] [blame] | 143 | |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 144 | private ChooseLockSettingsHelper mChooseLockSettingsHelper; |
| 145 | private DevicePolicyManager mDPM; |
Andres Morales | 6609b0c | 2015-04-12 15:38:25 -0700 | [diff] [blame] | 146 | private boolean mHasChallenge = false; |
| 147 | private long mChallenge; |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 148 | private boolean mPasswordConfirmed = false; |
Jim Miller | 47f1cd4 | 2012-04-27 18:11:03 -0700 | [diff] [blame] | 149 | private boolean mWaitingForConfirmation = false; |
Adrian Roos | 62775bf | 2016-01-28 13:23:53 -0800 | [diff] [blame] | 150 | private boolean mForChangeCredRequiredForBoot = false; |
Rubin Xu | 010116a | 2019-09-11 17:36:37 +0100 | [diff] [blame] | 151 | private LockscreenCredential mUserPassword; |
Jim Miller | 0698a21 | 2014-10-16 19:49:07 -0700 | [diff] [blame] | 152 | private LockPatternUtils mLockPatternUtils; |
Jim Miller | 9218687 | 2015-03-04 18:07:32 -0800 | [diff] [blame] | 153 | private FingerprintManager mFingerprintManager; |
Kevin Chyn | 0b95687 | 2018-06-29 13:09:32 -0700 | [diff] [blame] | 154 | private FaceManager mFaceManager; |
Clara Bayarri | fe432e8 | 2015-10-12 12:07:02 +0100 | [diff] [blame] | 155 | private int mUserId; |
Toni Barzic | e7d6e4d | 2016-03-30 11:43:19 -0700 | [diff] [blame] | 156 | private ManagedLockPasswordProvider mManagedPasswordProvider; |
Steven Ng | 4fdcec7 | 2016-09-26 22:13:08 +0100 | [diff] [blame] | 157 | private boolean mIsSetNewPassword = false; |
Kevin Chyn | ae16e55 | 2017-04-14 13:33:21 -0700 | [diff] [blame] | 158 | private UserManager mUserManager; |
Maurice Lam | edb3944 | 2017-04-27 18:54:33 -0700 | [diff] [blame] | 159 | private ChooseLockGenericController mController; |
Jim Miller | bbb4afa | 2010-04-08 19:40:19 -0700 | [diff] [blame] | 160 | |
Bernard Chau | 92db5bf | 2018-12-17 18:03:24 +0000 | [diff] [blame] | 161 | /** |
| 162 | * From intent extra {@link ChooseLockSettingsHelper#EXTRA_KEY_REQUESTED_MIN_COMPLEXITY}. |
| 163 | */ |
| 164 | @PasswordComplexity private int mRequestedMinComplexity; |
| 165 | |
| 166 | /** From intent extra {@link ChooseLockSettingsHelper#EXTRA_KEY_CALLER_APP_NAME}. */ |
| 167 | private String mCallerAppName = null; |
| 168 | |
Alex Kershaw | 29d2bff | 2019-05-17 15:36:28 +0100 | [diff] [blame] | 169 | /** |
| 170 | * The value from the intent extra {@link |
| 171 | * ChooseLockSettingsHelper#EXTRA_KEY_IS_CALLING_APP_ADMIN}. |
| 172 | */ |
| 173 | private boolean mIsCallingAppAdmin; |
| 174 | |
Udam Saini | 8ef4c62 | 2016-02-03 17:31:11 -0800 | [diff] [blame] | 175 | protected boolean mForFingerprint = false; |
Kevin Chyn | 81dc029 | 2018-06-28 14:59:38 -0700 | [diff] [blame] | 176 | protected boolean mForFace = false; |
Udam Saini | 8ef4c62 | 2016-02-03 17:31:11 -0800 | [diff] [blame] | 177 | |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 178 | @Override |
Fan Zhang | 6507613 | 2016-08-08 10:25:13 -0700 | [diff] [blame] | 179 | public int getMetricsCategory() { |
Fan Zhang | 31b2100 | 2019-01-16 13:49:47 -0800 | [diff] [blame] | 180 | return SettingsEnums.CHOOSE_LOCK_GENERIC; |
Chris Wren | 8a963ba | 2015-03-20 10:29:14 -0400 | [diff] [blame] | 181 | } |
| 182 | |
| 183 | @Override |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 184 | public void onCreate(Bundle savedInstanceState) { |
| 185 | super.onCreate(savedInstanceState); |
Doris Ling | 882bef3 | 2018-07-31 14:04:44 -0700 | [diff] [blame] | 186 | final Activity activity = getActivity(); |
Raff Tsai | c898775 | 2019-10-18 09:57:49 +0800 | [diff] [blame] | 187 | if (!WizardManagerHelper.isDeviceProvisioned(activity) |
| 188 | && !canRunBeforeDeviceProvisioned()) { |
Maurice Lam | e7cad18 | 2019-03-29 10:58:54 -0700 | [diff] [blame] | 189 | Log.i(TAG, "Refusing to start because device is not provisioned"); |
Doris Ling | 882bef3 | 2018-07-31 14:04:44 -0700 | [diff] [blame] | 190 | activity.finish(); |
| 191 | return; |
| 192 | } |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 193 | |
Steven Ng | 4fdcec7 | 2016-09-26 22:13:08 +0100 | [diff] [blame] | 194 | String chooseLockAction = getActivity().getIntent().getAction(); |
Jeff Sharkey | ab50807 | 2016-10-11 14:25:22 -0600 | [diff] [blame] | 195 | mFingerprintManager = Utils.getFingerprintManagerOrNull(getActivity()); |
Kevin Chyn | 0b95687 | 2018-06-29 13:09:32 -0700 | [diff] [blame] | 196 | mFaceManager = Utils.getFaceManagerOrNull(getActivity()); |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 197 | mDPM = (DevicePolicyManager) getSystemService(Context.DEVICE_POLICY_SERVICE); |
| 198 | mChooseLockSettingsHelper = new ChooseLockSettingsHelper(this.getActivity()); |
Jim Miller | 0698a21 | 2014-10-16 19:49:07 -0700 | [diff] [blame] | 199 | mLockPatternUtils = new LockPatternUtils(getActivity()); |
Steven Ng | 4fdcec7 | 2016-09-26 22:13:08 +0100 | [diff] [blame] | 200 | mIsSetNewPassword = ACTION_SET_NEW_PARENT_PROFILE_PASSWORD.equals(chooseLockAction) |
| 201 | || ACTION_SET_NEW_PASSWORD.equals(chooseLockAction); |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 202 | |
Danielle Millett | c474a88 | 2011-09-14 11:42:06 -0400 | [diff] [blame] | 203 | // Defaults to needing to confirm credentials |
| 204 | final boolean confirmCredentials = getActivity().getIntent() |
| 205 | .getBooleanExtra(CONFIRM_CREDENTIALS, true); |
Amith Yamasani | 6602677 | 2013-09-25 14:05:33 -0700 | [diff] [blame] | 206 | if (getActivity() instanceof ChooseLockGeneric.InternalActivity) { |
| 207 | mPasswordConfirmed = !confirmCredentials; |
Rubin Xu | 010116a | 2019-09-11 17:36:37 +0100 | [diff] [blame] | 208 | mUserPassword = getActivity().getIntent().getParcelableExtra( |
Pavel Grafov | 40e187b | 2017-10-11 22:57:09 +0100 | [diff] [blame] | 209 | ChooseLockSettingsHelper.EXTRA_KEY_PASSWORD); |
Amith Yamasani | 6602677 | 2013-09-25 14:05:33 -0700 | [diff] [blame] | 210 | } |
Danielle Millett | c474a88 | 2011-09-14 11:42:06 -0400 | [diff] [blame] | 211 | |
Andres Morales | 6609b0c | 2015-04-12 15:38:25 -0700 | [diff] [blame] | 212 | mHasChallenge = getActivity().getIntent().getBooleanExtra( |
| 213 | ChooseLockSettingsHelper.EXTRA_KEY_HAS_CHALLENGE, false); |
| 214 | mChallenge = getActivity().getIntent().getLongExtra( |
| 215 | ChooseLockSettingsHelper.EXTRA_KEY_CHALLENGE, 0); |
Maurice Lam | c0e7879 | 2015-07-20 14:49:29 -0700 | [diff] [blame] | 216 | mForFingerprint = getActivity().getIntent().getBooleanExtra( |
| 217 | ChooseLockSettingsHelper.EXTRA_KEY_FOR_FINGERPRINT, false); |
Kevin Chyn | 81dc029 | 2018-06-28 14:59:38 -0700 | [diff] [blame] | 218 | mForFace = getActivity().getIntent().getBooleanExtra( |
| 219 | ChooseLockSettingsHelper.EXTRA_KEY_FOR_FACE, false); |
Bernard Chau | 92db5bf | 2018-12-17 18:03:24 +0000 | [diff] [blame] | 220 | mRequestedMinComplexity = getActivity().getIntent() |
| 221 | .getIntExtra(EXTRA_KEY_REQUESTED_MIN_COMPLEXITY, PASSWORD_COMPLEXITY_NONE); |
| 222 | mCallerAppName = |
| 223 | getActivity().getIntent().getStringExtra(EXTRA_KEY_CALLER_APP_NAME); |
Alex Kershaw | 29d2bff | 2019-05-17 15:36:28 +0100 | [diff] [blame] | 224 | mIsCallingAppAdmin = getActivity().getIntent() |
| 225 | .getBooleanExtra(EXTRA_KEY_IS_CALLING_APP_ADMIN, /* defValue= */ false); |
Adrian Roos | 62775bf | 2016-01-28 13:23:53 -0800 | [diff] [blame] | 226 | mForChangeCredRequiredForBoot = getArguments() != null && getArguments().getBoolean( |
| 227 | ChooseLockSettingsHelper.EXTRA_KEY_FOR_CHANGE_CRED_REQUIRED_FOR_BOOT); |
Kevin Chyn | ae16e55 | 2017-04-14 13:33:21 -0700 | [diff] [blame] | 228 | mUserManager = UserManager.get(getActivity()); |
Andres Morales | 6609b0c | 2015-04-12 15:38:25 -0700 | [diff] [blame] | 229 | |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 230 | if (savedInstanceState != null) { |
| 231 | mPasswordConfirmed = savedInstanceState.getBoolean(PASSWORD_CONFIRMED); |
Jim Miller | 47f1cd4 | 2012-04-27 18:11:03 -0700 | [diff] [blame] | 232 | mWaitingForConfirmation = savedInstanceState.getBoolean(WAITING_FOR_CONFIRMATION); |
Pavel Grafov | 40e187b | 2017-10-11 22:57:09 +0100 | [diff] [blame] | 233 | if (mUserPassword == null) { |
Rubin Xu | 010116a | 2019-09-11 17:36:37 +0100 | [diff] [blame] | 234 | mUserPassword = savedInstanceState.getParcelable( |
Pavel Grafov | 40e187b | 2017-10-11 22:57:09 +0100 | [diff] [blame] | 235 | ChooseLockSettingsHelper.EXTRA_KEY_PASSWORD); |
| 236 | } |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 237 | } |
| 238 | |
Tony Mak | 8f41b9b | 2016-11-23 11:36:18 +0000 | [diff] [blame] | 239 | // a) If this is started from other user, use that user id. |
| 240 | // b) If this is started from the same user, read the extra if this is launched |
| 241 | // from Settings app itself. |
| 242 | // c) Otherwise, use UserHandle.myUserId(). |
| 243 | mUserId = Utils.getSecureTargetUser( |
Benjamin Franz | ae07b50 | 2016-01-08 17:16:19 +0000 | [diff] [blame] | 244 | getActivity().getActivityToken(), |
| 245 | UserManager.get(getActivity()), |
Tony Mak | 8f41b9b | 2016-11-23 11:36:18 +0000 | [diff] [blame] | 246 | getArguments(), |
Benjamin Franz | ae07b50 | 2016-01-08 17:16:19 +0000 | [diff] [blame] | 247 | getActivity().getIntent().getExtras()).getIdentifier(); |
Lenka Trochtova | bb8e817 | 2019-01-25 17:21:54 +0100 | [diff] [blame] | 248 | mController = new ChooseLockGenericController( |
| 249 | getContext(), mUserId, mRequestedMinComplexity, mLockPatternUtils); |
Steven Ng | 4fdcec7 | 2016-09-26 22:13:08 +0100 | [diff] [blame] | 250 | if (ACTION_SET_NEW_PASSWORD.equals(chooseLockAction) |
Robin Lee | 7886716 | 2016-09-12 16:25:28 +0900 | [diff] [blame] | 251 | && UserManager.get(getActivity()).isManagedProfile(mUserId) |
Mahaver Chopra | bc18b40 | 2016-05-04 13:11:17 +0100 | [diff] [blame] | 252 | && mLockPatternUtils.isSeparateProfileChallengeEnabled(mUserId)) { |
| 253 | getActivity().setTitle(R.string.lock_settings_picker_title_profile); |
| 254 | } |
| 255 | |
Toni Barzic | e7d6e4d | 2016-03-30 11:43:19 -0700 | [diff] [blame] | 256 | mManagedPasswordProvider = ManagedLockPasswordProvider.get(getActivity(), mUserId); |
| 257 | |
Jim Miller | 47f1cd4 | 2012-04-27 18:11:03 -0700 | [diff] [blame] | 258 | if (mPasswordConfirmed) { |
Maurice Lam | 2bb6238 | 2017-08-15 16:26:05 -0700 | [diff] [blame] | 259 | updatePreferencesOrFinish(savedInstanceState != null); |
Adrian Roos | 62775bf | 2016-01-28 13:23:53 -0800 | [diff] [blame] | 260 | if (mForChangeCredRequiredForBoot) { |
| 261 | maybeEnableEncryption(mLockPatternUtils.getKeyguardStoredPasswordQuality( |
| 262 | mUserId), false); |
| 263 | } |
Jim Miller | 47f1cd4 | 2012-04-27 18:11:03 -0700 | [diff] [blame] | 264 | } else if (!mWaitingForConfirmation) { |
Andy Stadler | 6370c87 | 2011-01-21 16:25:22 -0800 | [diff] [blame] | 265 | ChooseLockSettingsHelper helper = |
| 266 | new ChooseLockSettingsHelper(this.getActivity(), this); |
Robin Lee | 7886716 | 2016-09-12 16:25:28 +0900 | [diff] [blame] | 267 | boolean managedProfileWithUnifiedLock = |
| 268 | UserManager.get(getActivity()).isManagedProfile(mUserId) |
Ricky Wai | 4bbf065 | 2016-04-01 16:31:56 +0100 | [diff] [blame] | 269 | && !mLockPatternUtils.isSeparateProfileChallengeEnabled(mUserId); |
Rubin Xu | c548977 | 2018-03-28 15:14:35 +0100 | [diff] [blame] | 270 | boolean skipConfirmation = managedProfileWithUnifiedLock && !mIsSetNewPassword; |
| 271 | if (skipConfirmation |
Ricky Wai | 4bbf065 | 2016-04-01 16:31:56 +0100 | [diff] [blame] | 272 | || !helper.launchConfirmationActivity(CONFIRM_EXISTING_REQUEST, |
Clara Bayarri | fe432e8 | 2015-10-12 12:07:02 +0100 | [diff] [blame] | 273 | getString(R.string.unlock_set_unlock_launch_picker_title), true, mUserId)) { |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 274 | mPasswordConfirmed = true; // no password set, so no need to confirm |
Maurice Lam | 2bb6238 | 2017-08-15 16:26:05 -0700 | [diff] [blame] | 275 | updatePreferencesOrFinish(savedInstanceState != null); |
Jim Miller | 47f1cd4 | 2012-04-27 18:11:03 -0700 | [diff] [blame] | 276 | } else { |
| 277 | mWaitingForConfirmation = true; |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 278 | } |
Jim Miller | bbb4afa | 2010-04-08 19:40:19 -0700 | [diff] [blame] | 279 | } |
Udam Saini | 8ef4c62 | 2016-02-03 17:31:11 -0800 | [diff] [blame] | 280 | addHeaderView(); |
| 281 | } |
| 282 | |
Doris Ling | 882bef3 | 2018-07-31 14:04:44 -0700 | [diff] [blame] | 283 | protected boolean canRunBeforeDeviceProvisioned() { |
| 284 | return false; |
| 285 | } |
| 286 | |
Doris Ling | 3e6d80c | 2018-10-16 17:11:54 -0700 | [diff] [blame] | 287 | protected Class<? extends ChooseLockGeneric.InternalActivity> getInternalActivityClass() { |
| 288 | return ChooseLockGeneric.InternalActivity.class; |
| 289 | } |
| 290 | |
Udam Saini | 8ef4c62 | 2016-02-03 17:31:11 -0800 | [diff] [blame] | 291 | protected void addHeaderView() { |
Maurice Lam | 87fadbe | 2015-08-03 15:33:25 -0700 | [diff] [blame] | 292 | if (mForFingerprint) { |
Jason Monk | 39b4674 | 2015-09-10 15:52:51 -0400 | [diff] [blame] | 293 | setHeaderView(R.layout.choose_lock_generic_fingerprint_header); |
Steven Ng | 4fdcec7 | 2016-09-26 22:13:08 +0100 | [diff] [blame] | 294 | if (mIsSetNewPassword) { |
| 295 | ((TextView) getHeaderView().findViewById(R.id.fingerprint_header_description)) |
| 296 | .setText(R.string.fingerprint_unlock_title); |
| 297 | } |
Kevin Chyn | 81dc029 | 2018-06-28 14:59:38 -0700 | [diff] [blame] | 298 | } else if (mForFace) { |
| 299 | setHeaderView(R.layout.choose_lock_generic_face_header); |
| 300 | if (mIsSetNewPassword) { |
| 301 | ((TextView) getHeaderView().findViewById(R.id.face_header_description)) |
| 302 | .setText(R.string.face_unlock_title); |
| 303 | } |
Maurice Lam | 87fadbe | 2015-08-03 15:33:25 -0700 | [diff] [blame] | 304 | } |
| 305 | } |
| 306 | |
| 307 | @Override |
Jason Monk | 39b4674 | 2015-09-10 15:52:51 -0400 | [diff] [blame] | 308 | public boolean onPreferenceTreeClick(Preference preference) { |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 309 | final String key = preference.getKey(); |
rich cannings | 27d6f8d | 2013-05-29 14:54:58 -0700 | [diff] [blame] | 310 | |
Clara Bayarri | fe432e8 | 2015-10-12 12:07:02 +0100 | [diff] [blame] | 311 | if (!isUnlockMethodSecure(key) && mLockPatternUtils.isSecure(mUserId)) { |
Lucky Zhang | 3bcea02 | 2014-11-25 18:22:14 -0800 | [diff] [blame] | 312 | // Show the disabling FRP warning only when the user is switching from a secure |
| 313 | // unlock method to an insecure one |
| 314 | showFactoryResetProtectionWarningDialog(key); |
| 315 | return true; |
Kevin Chyn | 81dc029 | 2018-06-28 14:59:38 -0700 | [diff] [blame] | 316 | } else if (KEY_SKIP_FINGERPRINT.equals(key) || KEY_SKIP_FACE.equals(key)) { |
Steven Ng | 436256c | 2017-02-23 10:34:28 +0000 | [diff] [blame] | 317 | Intent chooseLockGenericIntent = new Intent(getActivity(), |
Doris Ling | 3e6d80c | 2018-10-16 17:11:54 -0700 | [diff] [blame] | 318 | getInternalActivityClass()); |
Steven Ng | 4fdcec7 | 2016-09-26 22:13:08 +0100 | [diff] [blame] | 319 | chooseLockGenericIntent.setAction(getIntent().getAction()); |
Tony Mak | 8f41b9b | 2016-11-23 11:36:18 +0000 | [diff] [blame] | 320 | // Forward the target user id to ChooseLockGeneric. |
| 321 | chooseLockGenericIntent.putExtra(Intent.EXTRA_USER_ID, mUserId); |
Steven Ng | 436256c | 2017-02-23 10:34:28 +0000 | [diff] [blame] | 322 | chooseLockGenericIntent.putExtra(CONFIRM_CREDENTIALS, !mPasswordConfirmed); |
Bernard Chau | 92db5bf | 2018-12-17 18:03:24 +0000 | [diff] [blame] | 323 | chooseLockGenericIntent.putExtra(EXTRA_KEY_REQUESTED_MIN_COMPLEXITY, |
| 324 | mRequestedMinComplexity); |
| 325 | chooseLockGenericIntent.putExtra(EXTRA_KEY_CALLER_APP_NAME, mCallerAppName); |
Pavel Grafov | 40e187b | 2017-10-11 22:57:09 +0100 | [diff] [blame] | 326 | if (mUserPassword != null) { |
| 327 | chooseLockGenericIntent.putExtra(ChooseLockSettingsHelper.EXTRA_KEY_PASSWORD, |
| 328 | mUserPassword); |
| 329 | } |
Steven Ng | 4fdcec7 | 2016-09-26 22:13:08 +0100 | [diff] [blame] | 330 | startActivityForResult(chooseLockGenericIntent, SKIP_FINGERPRINT_REQUEST); |
| 331 | return true; |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 332 | } else { |
Lucky Zhang | 3bcea02 | 2014-11-25 18:22:14 -0800 | [diff] [blame] | 333 | return setUnlockMethod(key); |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 334 | } |
Jim Miller | bbb4afa | 2010-04-08 19:40:19 -0700 | [diff] [blame] | 335 | } |
Jim Miller | bbb4afa | 2010-04-08 19:40:19 -0700 | [diff] [blame] | 336 | |
Jim Miller | 46c7f6d | 2014-10-13 18:15:17 -0700 | [diff] [blame] | 337 | /** |
| 338 | * If the device has encryption already enabled, then ask the user if they |
| 339 | * also want to encrypt the phone with this password. |
| 340 | * |
| 341 | * @param quality |
| 342 | * @param disabled |
| 343 | */ |
Andres Morales | a0e1236 | 2015-04-02 09:00:41 -0700 | [diff] [blame] | 344 | // TODO: why does this take disabled, its always called with a quality higher than |
| 345 | // what makes sense with disabled == true |
Jim Miller | 46c7f6d | 2014-10-13 18:15:17 -0700 | [diff] [blame] | 346 | private void maybeEnableEncryption(int quality, boolean disabled) { |
Andrei Kapishnikov | 146fc11 | 2015-04-09 11:08:16 -0400 | [diff] [blame] | 347 | DevicePolicyManager dpm = (DevicePolicyManager) getSystemService(DEVICE_POLICY_SERVICE); |
Xiaohui Chen | f9ee84d | 2015-10-21 11:25:35 -0700 | [diff] [blame] | 348 | if (UserManager.get(getActivity()).isAdminUser() |
Clara Bayarri | 93bcfcb | 2015-10-16 12:36:57 +0100 | [diff] [blame] | 349 | && mUserId == UserHandle.myUserId() |
Xiaohui Chen | f9ee84d | 2015-10-21 11:25:35 -0700 | [diff] [blame] | 350 | && LockPatternUtils.isDeviceEncryptionEnabled() |
Paul Lawrence | fb4c583 | 2016-01-29 13:25:36 -0800 | [diff] [blame] | 351 | && !LockPatternUtils.isFileEncryptionEnabled() |
Andrei Kapishnikov | 146fc11 | 2015-04-09 11:08:16 -0400 | [diff] [blame] | 352 | && !dpm.getDoNotAskCredentialsOnBoot()) { |
Udam Saini | edac136 | 2015-12-08 17:28:19 -0800 | [diff] [blame] | 353 | // Get the intent that the encryption interstitial should start for creating |
| 354 | // the new unlock method. |
Maurice Lam | 2eb170c | 2017-04-28 16:18:47 -0700 | [diff] [blame] | 355 | Intent unlockMethodIntent = getIntentForUnlockMethod(quality); |
Adrian Roos | 62775bf | 2016-01-28 13:23:53 -0800 | [diff] [blame] | 356 | unlockMethodIntent.putExtra( |
| 357 | ChooseLockSettingsHelper.EXTRA_KEY_FOR_CHANGE_CRED_REQUIRED_FOR_BOOT, |
| 358 | mForChangeCredRequiredForBoot); |
Maurice Lam | ecd2b7b | 2014-12-01 10:41:49 -0800 | [diff] [blame] | 359 | final Context context = getActivity(); |
Jim Miller | 0698a21 | 2014-10-16 19:49:07 -0700 | [diff] [blame] | 360 | // If accessibility is enabled and the user hasn't seen this dialog before, set the |
| 361 | // default state to agree with that which is compatible with accessibility |
| 362 | // (password not required). |
Maurice Lam | ecd2b7b | 2014-12-01 10:41:49 -0800 | [diff] [blame] | 363 | final boolean accEn = AccessibilityManager.getInstance(context).isEnabled(); |
Jim Miller | 0698a21 | 2014-10-16 19:49:07 -0700 | [diff] [blame] | 364 | final boolean required = mLockPatternUtils.isCredentialRequiredToDecrypt(!accEn); |
Udam Saini | edac136 | 2015-12-08 17:28:19 -0800 | [diff] [blame] | 365 | Intent intent = getEncryptionInterstitialIntent(context, quality, required, |
| 366 | unlockMethodIntent); |
Maurice Lam | c0e7879 | 2015-07-20 14:49:29 -0700 | [diff] [blame] | 367 | intent.putExtra(ChooseLockSettingsHelper.EXTRA_KEY_FOR_FINGERPRINT, |
| 368 | mForFingerprint); |
Kevin Chyn | 81dc029 | 2018-06-28 14:59:38 -0700 | [diff] [blame] | 369 | intent.putExtra(ChooseLockSettingsHelper.EXTRA_KEY_FOR_FACE, |
| 370 | mForFace); |
Steven Ng | 378dec1 | 2016-10-25 17:23:30 +0100 | [diff] [blame] | 371 | startActivityForResult( |
| 372 | intent, |
| 373 | mIsSetNewPassword && mHasChallenge |
Kevin Chyn | 5ab064f | 2019-04-12 15:19:12 -0700 | [diff] [blame] | 374 | ? CHOOSE_LOCK_BEFORE_BIOMETRIC_REQUEST |
Steven Ng | 378dec1 | 2016-10-25 17:23:30 +0100 | [diff] [blame] | 375 | : ENABLE_ENCRYPTION_REQUEST); |
Jim Miller | 46c7f6d | 2014-10-13 18:15:17 -0700 | [diff] [blame] | 376 | } else { |
Adrian Roos | 62775bf | 2016-01-28 13:23:53 -0800 | [diff] [blame] | 377 | if (mForChangeCredRequiredForBoot) { |
| 378 | // Welp, couldn't change it. Oh well. |
| 379 | finish(); |
| 380 | return; |
| 381 | } |
Maurice Lam | edb3944 | 2017-04-27 18:54:33 -0700 | [diff] [blame] | 382 | updateUnlockMethodAndFinish(quality, disabled, false /* chooseLockSkipped */); |
Jim Miller | 46c7f6d | 2014-10-13 18:15:17 -0700 | [diff] [blame] | 383 | } |
| 384 | } |
| 385 | |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 386 | @Override |
| 387 | public void onActivityResult(int requestCode, int resultCode, Intent data) { |
| 388 | super.onActivityResult(requestCode, resultCode, data); |
Jim Miller | 47f1cd4 | 2012-04-27 18:11:03 -0700 | [diff] [blame] | 389 | mWaitingForConfirmation = false; |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 390 | if (requestCode == CONFIRM_EXISTING_REQUEST && resultCode == Activity.RESULT_OK) { |
| 391 | mPasswordConfirmed = true; |
Doris Ling | 06d264d | 2018-06-12 16:33:05 -0700 | [diff] [blame] | 392 | mUserPassword = data != null |
Rubin Xu | 010116a | 2019-09-11 17:36:37 +0100 | [diff] [blame] | 393 | ? data.getParcelableExtra(ChooseLockSettingsHelper.EXTRA_KEY_PASSWORD) |
Doris Ling | 06d264d | 2018-06-12 16:33:05 -0700 | [diff] [blame] | 394 | : null; |
Maurice Lam | 2bb6238 | 2017-08-15 16:26:05 -0700 | [diff] [blame] | 395 | updatePreferencesOrFinish(false /* isRecreatingActivity */); |
Adrian Roos | 62775bf | 2016-01-28 13:23:53 -0800 | [diff] [blame] | 396 | if (mForChangeCredRequiredForBoot) { |
Rubin Xu | 010116a | 2019-09-11 17:36:37 +0100 | [diff] [blame] | 397 | if (mUserPassword != null && !mUserPassword.isNone()) { |
Adrian Roos | 62775bf | 2016-01-28 13:23:53 -0800 | [diff] [blame] | 398 | maybeEnableEncryption( |
| 399 | mLockPatternUtils.getKeyguardStoredPasswordQuality(mUserId), false); |
| 400 | } else { |
| 401 | finish(); |
| 402 | } |
| 403 | } |
Maurice Lam | e9d2abc | 2015-12-14 18:03:54 -0800 | [diff] [blame] | 404 | } else if (requestCode == CHOOSE_LOCK_REQUEST |
| 405 | || requestCode == ENABLE_ENCRYPTION_REQUEST) { |
Adrian Roos | 77181e9 | 2016-02-25 15:43:24 -0800 | [diff] [blame] | 406 | if (resultCode != RESULT_CANCELED || mForChangeCredRequiredForBoot) { |
Maurice Lam | e9d2abc | 2015-12-14 18:03:54 -0800 | [diff] [blame] | 407 | getActivity().setResult(resultCode, data); |
| 408 | finish(); |
Maurice Lam | edb3944 | 2017-04-27 18:54:33 -0700 | [diff] [blame] | 409 | } else { |
| 410 | // If PASSWORD_TYPE_KEY is set, this activity is used as a trampoline to start |
| 411 | // the actual password enrollment. If the result is canceled, which means the |
| 412 | // user pressed back, finish the activity with result canceled. |
| 413 | int quality = getIntent().getIntExtra(LockPatternUtils.PASSWORD_TYPE_KEY, -1); |
| 414 | if (quality != -1) { |
| 415 | getActivity().setResult(RESULT_CANCELED, data); |
| 416 | finish(); |
| 417 | } |
Maurice Lam | e9d2abc | 2015-12-14 18:03:54 -0800 | [diff] [blame] | 418 | } |
Kevin Chyn | 5ab064f | 2019-04-12 15:19:12 -0700 | [diff] [blame] | 419 | } else if (requestCode == CHOOSE_LOCK_BEFORE_BIOMETRIC_REQUEST |
Kevin Chyn | 4882e87 | 2018-06-25 17:58:31 -0700 | [diff] [blame] | 420 | && resultCode == BiometricEnrollBase.RESULT_FINISHED) { |
Kevin Chyn | 5ab064f | 2019-04-12 15:19:12 -0700 | [diff] [blame] | 421 | Intent intent = getBiometricEnrollIntent(getActivity()); |
Steven Ng | 4fdcec7 | 2016-09-26 22:13:08 +0100 | [diff] [blame] | 422 | if (data != null) { |
| 423 | intent.putExtras(data.getExtras()); |
| 424 | } |
Tony Mak | 8f41b9b | 2016-11-23 11:36:18 +0000 | [diff] [blame] | 425 | // Forward the target user id to fingerprint setup page. |
| 426 | intent.putExtra(Intent.EXTRA_USER_ID, mUserId); |
Steven Ng | 4fdcec7 | 2016-09-26 22:13:08 +0100 | [diff] [blame] | 427 | startActivity(intent); |
| 428 | finish(); |
| 429 | } else if (requestCode == SKIP_FINGERPRINT_REQUEST) { |
| 430 | if (resultCode != RESULT_CANCELED) { |
| 431 | getActivity().setResult( |
| 432 | resultCode == RESULT_FINISHED ? RESULT_OK : resultCode, data); |
| 433 | finish(); |
| 434 | } |
Raff Tsai | 4778a9a | 2018-08-29 23:22:12 +0800 | [diff] [blame] | 435 | } else if (requestCode == SearchFeatureProvider.REQUEST_CODE) { |
| 436 | return; |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 437 | } else { |
| 438 | getActivity().setResult(Activity.RESULT_CANCELED); |
| 439 | finish(); |
| 440 | } |
Adrian Roos | 62775bf | 2016-01-28 13:23:53 -0800 | [diff] [blame] | 441 | if (requestCode == Activity.RESULT_CANCELED && mForChangeCredRequiredForBoot) { |
| 442 | finish(); |
| 443 | } |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 444 | } |
| 445 | |
Kevin Chyn | 5ab064f | 2019-04-12 15:19:12 -0700 | [diff] [blame] | 446 | protected Intent getBiometricEnrollIntent(Context context) { |
| 447 | final Intent intent = |
| 448 | new Intent(context, BiometricEnrollActivity.InternalActivity.class); |
| 449 | intent.putExtra(BiometricEnrollActivity.EXTRA_SKIP_INTRO, true); |
| 450 | return intent; |
Udam Saini | d6b1c66 | 2016-11-01 11:20:14 -0700 | [diff] [blame] | 451 | } |
| 452 | |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 453 | @Override |
| 454 | public void onSaveInstanceState(Bundle outState) { |
| 455 | super.onSaveInstanceState(outState); |
| 456 | // Saved so we don't force user to re-enter their password if configuration changes |
| 457 | outState.putBoolean(PASSWORD_CONFIRMED, mPasswordConfirmed); |
Jim Miller | 47f1cd4 | 2012-04-27 18:11:03 -0700 | [diff] [blame] | 458 | outState.putBoolean(WAITING_FOR_CONFIRMATION, mWaitingForConfirmation); |
Pavel Grafov | 40e187b | 2017-10-11 22:57:09 +0100 | [diff] [blame] | 459 | if (mUserPassword != null) { |
Rubin Xu | 010116a | 2019-09-11 17:36:37 +0100 | [diff] [blame] | 460 | outState.putParcelable(ChooseLockSettingsHelper.EXTRA_KEY_PASSWORD, mUserPassword); |
Pavel Grafov | 40e187b | 2017-10-11 22:57:09 +0100 | [diff] [blame] | 461 | } |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 462 | } |
| 463 | |
Doris Ling | 06d264d | 2018-06-12 16:33:05 -0700 | [diff] [blame] | 464 | @VisibleForTesting |
| 465 | void updatePreferencesOrFinish(boolean isRecreatingActivity) { |
Jim Miller | 5541a86 | 2011-09-02 17:33:53 -0700 | [diff] [blame] | 466 | Intent intent = getActivity().getIntent(); |
Maurice Lam | 446637e | 2018-10-04 19:49:08 -0700 | [diff] [blame] | 467 | int quality = -1; |
| 468 | if (StorageManager.isFileEncryptedNativeOrEmulated()) { |
| 469 | quality = intent.getIntExtra(LockPatternUtils.PASSWORD_TYPE_KEY, -1); |
| 470 | } else { |
| 471 | // For non-file encrypted devices we need to show encryption interstitial, so always |
| 472 | // show the lock type picker and ignore PASSWORD_TYPE_KEY. |
| 473 | Log.i(TAG, "Ignoring PASSWORD_TYPE_KEY because device is not file encrypted"); |
| 474 | } |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 475 | if (quality == -1) { |
Andy Stadler | 6370c87 | 2011-01-21 16:25:22 -0800 | [diff] [blame] | 476 | // If caller didn't specify password quality, show UI and allow the user to choose. |
Jim Miller | 5541a86 | 2011-09-02 17:33:53 -0700 | [diff] [blame] | 477 | quality = intent.getIntExtra(MINIMUM_QUALITY_KEY, -1); |
Maurice Lam | edb3944 | 2017-04-27 18:54:33 -0700 | [diff] [blame] | 478 | quality = mController.upgradeQuality(quality); |
Jim Miller | 3fb2fb8 | 2015-03-11 20:17:39 -0700 | [diff] [blame] | 479 | final boolean hideDisabledPrefs = intent.getBooleanExtra( |
| 480 | HIDE_DISABLED_PREFS, false); |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 481 | final PreferenceScreen prefScreen = getPreferenceScreen(); |
| 482 | if (prefScreen != null) { |
| 483 | prefScreen.removeAll(); |
| 484 | } |
Udam Saini | 8ef4c62 | 2016-02-03 17:31:11 -0800 | [diff] [blame] | 485 | addPreferences(); |
Jim Miller | 3fb2fb8 | 2015-03-11 20:17:39 -0700 | [diff] [blame] | 486 | disableUnusablePreferences(quality, hideDisabledPrefs); |
Udam Saini | bf1483c | 2016-01-25 08:06:57 -0800 | [diff] [blame] | 487 | updatePreferenceText(); |
Jason Monk | 9a64a42 | 2015-03-30 11:00:36 -0400 | [diff] [blame] | 488 | updateCurrentPreference(); |
Svetoslav | 5244844 | 2014-09-29 18:15:45 -0700 | [diff] [blame] | 489 | updatePreferenceSummaryIfNeeded(); |
Maurice Lam | 2bb6238 | 2017-08-15 16:26:05 -0700 | [diff] [blame] | 490 | } else if (!isRecreatingActivity) { |
| 491 | // Don't start the activity again if we are recreated for configuration change |
Maurice Lam | edb3944 | 2017-04-27 18:54:33 -0700 | [diff] [blame] | 492 | updateUnlockMethodAndFinish(quality, false, true /* chooseLockSkipped */); |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 493 | } |
| 494 | } |
| 495 | |
Udam Saini | 8ef4c62 | 2016-02-03 17:31:11 -0800 | [diff] [blame] | 496 | protected void addPreferences() { |
| 497 | addPreferencesFromResource(R.xml.security_settings_picker); |
Jeff Sharkey | a77652f | 2016-04-01 23:12:45 -0600 | [diff] [blame] | 498 | |
Sunny Shao | 1bebe19 | 2019-08-12 20:33:47 +0800 | [diff] [blame] | 499 | final Preference footer = findPreference(KEY_LOCK_SETTINGS_FOOTER); |
Alex Kershaw | 29d2bff | 2019-05-17 15:36:28 +0100 | [diff] [blame] | 500 | if (!TextUtils.isEmpty(mCallerAppName) && !mIsCallingAppAdmin) { |
Sunny Shao | 1bebe19 | 2019-08-12 20:33:47 +0800 | [diff] [blame] | 501 | footer.setVisible(true); |
Bernard Chau | 92db5bf | 2018-12-17 18:03:24 +0000 | [diff] [blame] | 502 | footer.setTitle(getFooterString()); |
Sunny Shao | 1bebe19 | 2019-08-12 20:33:47 +0800 | [diff] [blame] | 503 | } else { |
| 504 | footer.setVisible(false); |
Bernard Chau | 92db5bf | 2018-12-17 18:03:24 +0000 | [diff] [blame] | 505 | } |
| 506 | |
Jeff Sharkey | a77652f | 2016-04-01 23:12:45 -0600 | [diff] [blame] | 507 | // Used for testing purposes |
Maurice Lam | edb3944 | 2017-04-27 18:54:33 -0700 | [diff] [blame] | 508 | findPreference(ScreenLockType.NONE.preferenceKey).setViewId(R.id.lock_none); |
Jeff Sharkey | 159dff6 | 2016-10-04 13:43:35 -0600 | [diff] [blame] | 509 | findPreference(KEY_SKIP_FINGERPRINT).setViewId(R.id.lock_none); |
Kevin Chyn | 81dc029 | 2018-06-28 14:59:38 -0700 | [diff] [blame] | 510 | findPreference(KEY_SKIP_FACE).setViewId(R.id.lock_none); |
Maurice Lam | edb3944 | 2017-04-27 18:54:33 -0700 | [diff] [blame] | 511 | findPreference(ScreenLockType.PIN.preferenceKey).setViewId(R.id.lock_pin); |
| 512 | findPreference(ScreenLockType.PASSWORD.preferenceKey).setViewId(R.id.lock_password); |
Udam Saini | 8ef4c62 | 2016-02-03 17:31:11 -0800 | [diff] [blame] | 513 | } |
| 514 | |
Bernard Chau | 92db5bf | 2018-12-17 18:03:24 +0000 | [diff] [blame] | 515 | private String getFooterString() { |
| 516 | @StringRes int stringId; |
| 517 | switch (mRequestedMinComplexity) { |
| 518 | case PASSWORD_COMPLEXITY_HIGH: |
| 519 | stringId = R.string.unlock_footer_high_complexity_requested; |
| 520 | break; |
| 521 | case PASSWORD_COMPLEXITY_MEDIUM: |
| 522 | stringId = R.string.unlock_footer_medium_complexity_requested; |
| 523 | break; |
| 524 | case PASSWORD_COMPLEXITY_LOW: |
| 525 | stringId = R.string.unlock_footer_low_complexity_requested; |
| 526 | break; |
| 527 | case PASSWORD_COMPLEXITY_NONE: |
| 528 | default: |
| 529 | stringId = R.string.unlock_footer_none_complexity_requested; |
| 530 | break; |
| 531 | } |
| 532 | |
| 533 | return getResources().getString(stringId, mCallerAppName); |
| 534 | } |
| 535 | |
Udam Saini | bf1483c | 2016-01-25 08:06:57 -0800 | [diff] [blame] | 536 | private void updatePreferenceText() { |
| 537 | if (mForFingerprint) { |
Maurice Lam | edb3944 | 2017-04-27 18:54:33 -0700 | [diff] [blame] | 538 | setPreferenceTitle(ScreenLockType.PATTERN, |
| 539 | R.string.fingerprint_unlock_set_unlock_pattern); |
| 540 | setPreferenceTitle(ScreenLockType.PIN, R.string.fingerprint_unlock_set_unlock_pin); |
| 541 | setPreferenceTitle(ScreenLockType.PASSWORD, |
| 542 | R.string.fingerprint_unlock_set_unlock_password); |
Kevin Chyn | 81dc029 | 2018-06-28 14:59:38 -0700 | [diff] [blame] | 543 | } else if (mForFace) { |
| 544 | setPreferenceTitle(ScreenLockType.PATTERN, |
| 545 | R.string.face_unlock_set_unlock_pattern); |
| 546 | setPreferenceTitle(ScreenLockType.PIN, R.string.face_unlock_set_unlock_pin); |
| 547 | setPreferenceTitle(ScreenLockType.PASSWORD, |
| 548 | R.string.face_unlock_set_unlock_password); |
Udam Saini | bf1483c | 2016-01-25 08:06:57 -0800 | [diff] [blame] | 549 | } |
Toni Barzic | e7d6e4d | 2016-03-30 11:43:19 -0700 | [diff] [blame] | 550 | |
| 551 | if (mManagedPasswordProvider.isSettingManagedPasswordSupported()) { |
Maurice Lam | edb3944 | 2017-04-27 18:54:33 -0700 | [diff] [blame] | 552 | setPreferenceTitle(ScreenLockType.MANAGED, |
| 553 | mManagedPasswordProvider.getPickerOptionTitle(mForFingerprint)); |
Toni Barzic | e7d6e4d | 2016-03-30 11:43:19 -0700 | [diff] [blame] | 554 | } else { |
Maurice Lam | edb3944 | 2017-04-27 18:54:33 -0700 | [diff] [blame] | 555 | removePreference(ScreenLockType.MANAGED.preferenceKey); |
Toni Barzic | e7d6e4d | 2016-03-30 11:43:19 -0700 | [diff] [blame] | 556 | } |
Steven Ng | 4fdcec7 | 2016-09-26 22:13:08 +0100 | [diff] [blame] | 557 | |
| 558 | if (!(mForFingerprint && mIsSetNewPassword)) { |
| 559 | removePreference(KEY_SKIP_FINGERPRINT); |
| 560 | } |
Kevin Chyn | 81dc029 | 2018-06-28 14:59:38 -0700 | [diff] [blame] | 561 | if (!(mForFace && mIsSetNewPassword)) { |
| 562 | removePreference(KEY_SKIP_FACE); |
| 563 | } |
Udam Saini | bf1483c | 2016-01-25 08:06:57 -0800 | [diff] [blame] | 564 | } |
| 565 | |
Maurice Lam | edb3944 | 2017-04-27 18:54:33 -0700 | [diff] [blame] | 566 | private void setPreferenceTitle(ScreenLockType lock, @StringRes int title) { |
| 567 | Preference preference = findPreference(lock.preferenceKey); |
| 568 | if (preference != null) { |
| 569 | preference.setTitle(title); |
| 570 | } |
| 571 | } |
| 572 | |
| 573 | private void setPreferenceTitle(ScreenLockType lock, CharSequence title) { |
| 574 | Preference preference = findPreference(lock.preferenceKey); |
| 575 | if (preference != null) { |
| 576 | preference.setTitle(title); |
| 577 | } |
| 578 | } |
| 579 | |
| 580 | private void setPreferenceSummary(ScreenLockType lock, @StringRes int summary) { |
| 581 | Preference preference = findPreference(lock.preferenceKey); |
| 582 | if (preference != null) { |
| 583 | preference.setSummary(summary); |
| 584 | } |
| 585 | } |
| 586 | |
Jason Monk | 9a64a42 | 2015-03-30 11:00:36 -0400 | [diff] [blame] | 587 | private void updateCurrentPreference() { |
| 588 | String currentKey = getKeyForCurrent(); |
| 589 | Preference preference = findPreference(currentKey); |
| 590 | if (preference != null) { |
| 591 | preference.setSummary(R.string.current_screen_lock); |
| 592 | } |
| 593 | } |
| 594 | |
| 595 | private String getKeyForCurrent() { |
Jason Monk | e07c947e | 2016-01-21 14:15:46 -0500 | [diff] [blame] | 596 | final int credentialOwner = UserManager.get(getContext()) |
| 597 | .getCredentialOwnerProfile(mUserId); |
Clara Bayarri | 7402b25 | 2016-01-20 15:39:59 +0000 | [diff] [blame] | 598 | if (mLockPatternUtils.isLockScreenDisabled(credentialOwner)) { |
Maurice Lam | edb3944 | 2017-04-27 18:54:33 -0700 | [diff] [blame] | 599 | return ScreenLockType.NONE.preferenceKey; |
Jason Monk | 9a64a42 | 2015-03-30 11:00:36 -0400 | [diff] [blame] | 600 | } |
Maurice Lam | edb3944 | 2017-04-27 18:54:33 -0700 | [diff] [blame] | 601 | ScreenLockType lock = |
| 602 | ScreenLockType.fromQuality( |
| 603 | mLockPatternUtils.getKeyguardStoredPasswordQuality(credentialOwner)); |
| 604 | return lock != null ? lock.preferenceKey : null; |
Brian Carlstrom | d4023b7 | 2011-05-25 13:24:20 -0700 | [diff] [blame] | 605 | } |
| 606 | |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 607 | /*** |
Lucky Zhang | df8566a | 2014-12-05 15:00:20 -0800 | [diff] [blame] | 608 | * Disables preferences that are less secure than required quality. The actual |
| 609 | * implementation is in disableUnusablePreferenceImpl. |
| 610 | * |
| 611 | * @param quality the requested quality. |
Jim Miller | 3fb2fb8 | 2015-03-11 20:17:39 -0700 | [diff] [blame] | 612 | * @param hideDisabledPrefs if false preferences show why they were disabled; otherwise |
| 613 | * they're not shown at all. |
Lucky Zhang | df8566a | 2014-12-05 15:00:20 -0800 | [diff] [blame] | 614 | */ |
Jim Miller | 3fb2fb8 | 2015-03-11 20:17:39 -0700 | [diff] [blame] | 615 | protected void disableUnusablePreferences(final int quality, boolean hideDisabledPrefs) { |
| 616 | disableUnusablePreferencesImpl(quality, hideDisabledPrefs); |
Lucky Zhang | df8566a | 2014-12-05 15:00:20 -0800 | [diff] [blame] | 617 | } |
| 618 | |
| 619 | /*** |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 620 | * Disables preferences that are less secure than required quality. |
| 621 | * |
| 622 | * @param quality the requested quality. |
Lucky Zhang | df8566a | 2014-12-05 15:00:20 -0800 | [diff] [blame] | 623 | * @param hideDisabled whether to hide disable screen lock options. |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 624 | */ |
Lucky Zhang | df8566a | 2014-12-05 15:00:20 -0800 | [diff] [blame] | 625 | protected void disableUnusablePreferencesImpl(final int quality, |
Adrian Roos | f788718 | 2015-01-07 20:51:57 +0100 | [diff] [blame] | 626 | boolean hideDisabled) { |
Amith Yamasani | cf26bb2 | 2011-09-26 10:27:43 -0700 | [diff] [blame] | 627 | final PreferenceScreen entries = getPreferenceScreen(); |
Jim Miller | 783ea85 | 2012-11-01 19:39:21 -0700 | [diff] [blame] | 628 | |
Tony Mak | 25c3c54 | 2016-03-18 13:48:16 +0000 | [diff] [blame] | 629 | int adminEnforcedQuality = mDPM.getPasswordQuality(null, mUserId); |
Philip P. Moltmann | e3f7211 | 2018-08-28 15:01:43 -0700 | [diff] [blame] | 630 | EnforcedAdmin enforcedAdmin = RestrictedLockUtilsInternal.checkIfPasswordQualityIsSet( |
Sudheer Shanka | f755baf | 2016-01-29 22:12:30 +0000 | [diff] [blame] | 631 | getActivity(), mUserId); |
Maurice Lam | edb3944 | 2017-04-27 18:54:33 -0700 | [diff] [blame] | 632 | |
| 633 | for (ScreenLockType lock : ScreenLockType.values()) { |
| 634 | String key = lock.preferenceKey; |
| 635 | Preference pref = findPreference(key); |
Sudheer Shanka | 9c32468 | 2016-01-18 11:17:23 +0000 | [diff] [blame] | 636 | if (pref instanceof RestrictedPreference) { |
Maurice Lam | edb3944 | 2017-04-27 18:54:33 -0700 | [diff] [blame] | 637 | boolean visible = mController.isScreenLockVisible(lock); |
| 638 | boolean enabled = mController.isScreenLockEnabled(lock, quality); |
| 639 | boolean disabledByAdmin = |
| 640 | mController.isScreenLockDisabledByAdmin(lock, adminEnforcedQuality); |
Lucky Zhang | df8566a | 2014-12-05 15:00:20 -0800 | [diff] [blame] | 641 | if (hideDisabled) { |
Maurice Lam | edb3944 | 2017-04-27 18:54:33 -0700 | [diff] [blame] | 642 | visible = visible && enabled; |
Lucky Zhang | df8566a | 2014-12-05 15:00:20 -0800 | [diff] [blame] | 643 | } |
Adrian Roos | f788718 | 2015-01-07 20:51:57 +0100 | [diff] [blame] | 644 | if (!visible) { |
Amith Yamasani | cf26bb2 | 2011-09-26 10:27:43 -0700 | [diff] [blame] | 645 | entries.removePreference(pref); |
Sudheer Shanka | 9c32468 | 2016-01-18 11:17:23 +0000 | [diff] [blame] | 646 | } else if (disabledByAdmin && enforcedAdmin != null) { |
| 647 | ((RestrictedPreference) pref).setDisabledByAdmin(enforcedAdmin); |
Jim Miller | 5541a86 | 2011-09-02 17:33:53 -0700 | [diff] [blame] | 648 | } else if (!enabled) { |
Sudheer Shanka | 9c32468 | 2016-01-18 11:17:23 +0000 | [diff] [blame] | 649 | // we need to setDisabledByAdmin to null first to disable the padlock |
| 650 | // in case it was set earlier. |
| 651 | ((RestrictedPreference) pref).setDisabledByAdmin(null); |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 652 | pref.setSummary(R.string.unlock_set_unlock_disabled_summary); |
| 653 | pref.setEnabled(false); |
Sudheer Shanka | 9c32468 | 2016-01-18 11:17:23 +0000 | [diff] [blame] | 654 | } else { |
| 655 | ((RestrictedPreference) pref).setDisabledByAdmin(null); |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 656 | } |
| 657 | } |
| 658 | } |
| 659 | } |
| 660 | |
Svetoslav | 5244844 | 2014-09-29 18:15:45 -0700 | [diff] [blame] | 661 | private void updatePreferenceSummaryIfNeeded() { |
Paul Lawrence | 23c2acf | 2016-03-10 13:54:56 -0800 | [diff] [blame] | 662 | // On a default block encrypted device with accessibility, add a warning |
| 663 | // that your data is not credential encrypted |
| 664 | if (!StorageManager.isBlockEncrypted()) { |
| 665 | return; |
| 666 | } |
| 667 | |
| 668 | if (StorageManager.isNonDefaultBlockEncrypted()) { |
Svetoslav | 40ca78f | 2014-10-17 14:37:02 -0700 | [diff] [blame] | 669 | return; |
| 670 | } |
| 671 | |
Svetoslav | 5244844 | 2014-09-29 18:15:45 -0700 | [diff] [blame] | 672 | if (AccessibilityManager.getInstance(getActivity()).getEnabledAccessibilityServiceList( |
| 673 | AccessibilityServiceInfo.FEEDBACK_ALL_MASK).isEmpty()) { |
| 674 | return; |
| 675 | } |
| 676 | |
Maurice Lam | edb3944 | 2017-04-27 18:54:33 -0700 | [diff] [blame] | 677 | setPreferenceSummary(ScreenLockType.PATTERN, R.string.secure_lock_encryption_warning); |
| 678 | setPreferenceSummary(ScreenLockType.PIN, R.string.secure_lock_encryption_warning); |
| 679 | setPreferenceSummary(ScreenLockType.PASSWORD, R.string.secure_lock_encryption_warning); |
| 680 | setPreferenceSummary(ScreenLockType.MANAGED, R.string.secure_lock_encryption_warning); |
Svetoslav | 5244844 | 2014-09-29 18:15:45 -0700 | [diff] [blame] | 681 | } |
| 682 | |
Rubin Xu | 010116a | 2019-09-11 17:36:37 +0100 | [diff] [blame] | 683 | protected Intent getLockManagedPasswordIntent(LockscreenCredential password) { |
Maurice Lam | 2eb170c | 2017-04-28 16:18:47 -0700 | [diff] [blame] | 684 | return mManagedPasswordProvider.createIntent(false, password); |
Toni Barzic | e7d6e4d | 2016-03-30 11:43:19 -0700 | [diff] [blame] | 685 | } |
| 686 | |
Pavel Grafov | 5f13910 | 2018-05-04 17:09:28 +0100 | [diff] [blame] | 687 | protected Intent getLockPasswordIntent(int quality) { |
Maurice Lam | 2eb170c | 2017-04-28 16:18:47 -0700 | [diff] [blame] | 688 | ChooseLockPassword.IntentBuilder builder = |
| 689 | new ChooseLockPassword.IntentBuilder(getContext()) |
| 690 | .setPasswordQuality(quality) |
Bernard Chau | 92db5bf | 2018-12-17 18:03:24 +0000 | [diff] [blame] | 691 | .setRequestedMinComplexity(mRequestedMinComplexity) |
Maurice Lam | b49526e | 2017-05-31 17:55:43 -0700 | [diff] [blame] | 692 | .setForFingerprint(mForFingerprint) |
Kevin Chyn | 81dc029 | 2018-06-28 14:59:38 -0700 | [diff] [blame] | 693 | .setForFace(mForFace) |
Maurice Lam | 2eb170c | 2017-04-28 16:18:47 -0700 | [diff] [blame] | 694 | .setUserId(mUserId); |
| 695 | if (mHasChallenge) { |
| 696 | builder.setChallenge(mChallenge); |
Pavel Grafov | 40e187b | 2017-10-11 22:57:09 +0100 | [diff] [blame] | 697 | } |
| 698 | if (mUserPassword != null) { |
Maurice Lam | 2eb170c | 2017-04-28 16:18:47 -0700 | [diff] [blame] | 699 | builder.setPassword(mUserPassword); |
| 700 | } |
| 701 | return builder.build(); |
Maurice Lam | 6b19fa9 | 2014-11-25 19:25:56 -0800 | [diff] [blame] | 702 | } |
| 703 | |
Maurice Lam | 2eb170c | 2017-04-28 16:18:47 -0700 | [diff] [blame] | 704 | protected Intent getLockPatternIntent() { |
| 705 | ChooseLockPattern.IntentBuilder builder = |
| 706 | new ChooseLockPattern.IntentBuilder(getContext()) |
Maurice Lam | b49526e | 2017-05-31 17:55:43 -0700 | [diff] [blame] | 707 | .setForFingerprint(mForFingerprint) |
Kevin Chyn | 81dc029 | 2018-06-28 14:59:38 -0700 | [diff] [blame] | 708 | .setForFace(mForFace) |
Maurice Lam | 2eb170c | 2017-04-28 16:18:47 -0700 | [diff] [blame] | 709 | .setUserId(mUserId); |
| 710 | if (mHasChallenge) { |
| 711 | builder.setChallenge(mChallenge); |
Pavel Grafov | 40e187b | 2017-10-11 22:57:09 +0100 | [diff] [blame] | 712 | } |
| 713 | if (mUserPassword != null) { |
Maurice Lam | 2eb170c | 2017-04-28 16:18:47 -0700 | [diff] [blame] | 714 | builder.setPattern(mUserPassword); |
| 715 | } |
| 716 | return builder.build(); |
Andres Morales | a0e1236 | 2015-04-02 09:00:41 -0700 | [diff] [blame] | 717 | } |
| 718 | |
Maurice Lam | ecd2b7b | 2014-12-01 10:41:49 -0800 | [diff] [blame] | 719 | protected Intent getEncryptionInterstitialIntent(Context context, int quality, |
Udam Saini | edac136 | 2015-12-08 17:28:19 -0800 | [diff] [blame] | 720 | boolean required, Intent unlockMethodIntent) { |
| 721 | return EncryptionInterstitial.createStartIntent(context, quality, required, |
| 722 | unlockMethodIntent); |
Maurice Lam | ecd2b7b | 2014-12-01 10:41:49 -0800 | [diff] [blame] | 723 | } |
| 724 | |
Jim Miller | 5541a86 | 2011-09-02 17:33:53 -0700 | [diff] [blame] | 725 | /** |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 726 | * Invokes an activity to change the user's pattern, password or PIN based on given quality |
| 727 | * and minimum quality specified by DevicePolicyManager. If quality is |
| 728 | * {@link DevicePolicyManager#PASSWORD_QUALITY_UNSPECIFIED}, password is cleared. |
| 729 | * |
Andy Stadler | 6370c87 | 2011-01-21 16:25:22 -0800 | [diff] [blame] | 730 | * @param quality the desired quality. Ignored if DevicePolicyManager requires more security |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 731 | * @param disabled whether or not to show LockScreen at all. Only meaningful when quality is |
Maurice Lam | edb3944 | 2017-04-27 18:54:33 -0700 | [diff] [blame] | 732 | * @param chooseLockSkipped whether or not this activity is skipped. This is true when this |
| 733 | * activity was not shown to the user at all, instead automatically proceeding based on |
| 734 | * the given intent extras, typically {@link LockPatternUtils#PASSWORD_TYPE_KEY}. |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 735 | * {@link DevicePolicyManager#PASSWORD_QUALITY_UNSPECIFIED} |
| 736 | */ |
Maurice Lam | edb3944 | 2017-04-27 18:54:33 -0700 | [diff] [blame] | 737 | void updateUnlockMethodAndFinish(int quality, boolean disabled, boolean chooseLockSkipped) { |
Andy Stadler | 6370c87 | 2011-01-21 16:25:22 -0800 | [diff] [blame] | 738 | // Sanity check. We should never get here without confirming user's existing password. |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 739 | if (!mPasswordConfirmed) { |
Andy Stadler | 6370c87 | 2011-01-21 16:25:22 -0800 | [diff] [blame] | 740 | throw new IllegalStateException("Tried to update password without confirming it"); |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 741 | } |
| 742 | |
Maurice Lam | edb3944 | 2017-04-27 18:54:33 -0700 | [diff] [blame] | 743 | quality = mController.upgradeQuality(quality); |
Maurice Lam | 2eb170c | 2017-04-28 16:18:47 -0700 | [diff] [blame] | 744 | Intent intent = getIntentForUnlockMethod(quality); |
Udam Saini | edac136 | 2015-12-08 17:28:19 -0800 | [diff] [blame] | 745 | if (intent != null) { |
Maurice Lam | edb3944 | 2017-04-27 18:54:33 -0700 | [diff] [blame] | 746 | if (getIntent().getBooleanExtra(EXTRA_SHOW_OPTIONS_BUTTON, false)) { |
| 747 | intent.putExtra(EXTRA_SHOW_OPTIONS_BUTTON, chooseLockSkipped); |
| 748 | } |
| 749 | intent.putExtra(EXTRA_CHOOSE_LOCK_GENERIC_EXTRAS, getIntent().getExtras()); |
Steven Ng | 4fdcec7 | 2016-09-26 22:13:08 +0100 | [diff] [blame] | 750 | startActivityForResult(intent, |
| 751 | mIsSetNewPassword && mHasChallenge |
Kevin Chyn | 5ab064f | 2019-04-12 15:19:12 -0700 | [diff] [blame] | 752 | ? CHOOSE_LOCK_BEFORE_BIOMETRIC_REQUEST |
Steven Ng | 4fdcec7 | 2016-09-26 22:13:08 +0100 | [diff] [blame] | 753 | : CHOOSE_LOCK_REQUEST); |
Udam Saini | edac136 | 2015-12-08 17:28:19 -0800 | [diff] [blame] | 754 | return; |
| 755 | } |
Steven Ross | c620ba4 | 2011-09-28 15:43:41 -0400 | [diff] [blame] | 756 | |
Udam Saini | edac136 | 2015-12-08 17:28:19 -0800 | [diff] [blame] | 757 | if (quality == DevicePolicyManager.PASSWORD_QUALITY_UNSPECIFIED) { |
Alex Johnston | a0351e2 | 2019-10-03 16:02:41 +0100 | [diff] [blame] | 758 | // Clearing of user biometrics when screen lock is cleared is done at |
| 759 | // LockSettingsService.removeBiometricsForUser(). |
Rubin Xu | 3bf2e70 | 2019-10-15 23:51:10 +0100 | [diff] [blame] | 760 | if (mUserPassword != null) { |
| 761 | // No need to call setLockCredential if the user currently doesn't |
| 762 | // have a password |
| 763 | mChooseLockSettingsHelper.utils().setLockCredential( |
| 764 | LockscreenCredential.createNone(), mUserPassword, mUserId); |
| 765 | } |
Clara Bayarri | fe432e8 | 2015-10-12 12:07:02 +0100 | [diff] [blame] | 766 | mChooseLockSettingsHelper.utils().setLockScreenDisabled(disabled, mUserId); |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 767 | getActivity().setResult(Activity.RESULT_OK); |
Alex Johnston | a0351e2 | 2019-10-03 16:02:41 +0100 | [diff] [blame] | 768 | finish(); |
Jim Miller | 17e9e19 | 2010-12-07 20:41:41 -0800 | [diff] [blame] | 769 | } |
Jim Miller | bbb4afa | 2010-04-08 19:40:19 -0700 | [diff] [blame] | 770 | } |
Amith Yamasani | b0b37ae | 2012-04-23 15:35:36 -0700 | [diff] [blame] | 771 | |
Maurice Lam | 2eb170c | 2017-04-28 16:18:47 -0700 | [diff] [blame] | 772 | private Intent getIntentForUnlockMethod(int quality) { |
Udam Saini | edac136 | 2015-12-08 17:28:19 -0800 | [diff] [blame] | 773 | Intent intent = null; |
Toni Barzic | e7d6e4d | 2016-03-30 11:43:19 -0700 | [diff] [blame] | 774 | if (quality >= DevicePolicyManager.PASSWORD_QUALITY_MANAGED) { |
Maurice Lam | 2eb170c | 2017-04-28 16:18:47 -0700 | [diff] [blame] | 775 | intent = getLockManagedPasswordIntent(mUserPassword); |
Toni Barzic | e7d6e4d | 2016-03-30 11:43:19 -0700 | [diff] [blame] | 776 | } else if (quality >= DevicePolicyManager.PASSWORD_QUALITY_NUMERIC) { |
Pavel Grafov | 5f13910 | 2018-05-04 17:09:28 +0100 | [diff] [blame] | 777 | intent = getLockPasswordIntent(quality); |
Udam Saini | edac136 | 2015-12-08 17:28:19 -0800 | [diff] [blame] | 778 | } else if (quality == DevicePolicyManager.PASSWORD_QUALITY_SOMETHING) { |
Maurice Lam | 2eb170c | 2017-04-28 16:18:47 -0700 | [diff] [blame] | 779 | intent = getLockPatternIntent(); |
Udam Saini | edac136 | 2015-12-08 17:28:19 -0800 | [diff] [blame] | 780 | } |
| 781 | return intent; |
| 782 | } |
| 783 | |
Jim Miller | 9218687 | 2015-03-04 18:07:32 -0800 | [diff] [blame] | 784 | @Override |
| 785 | public void onDestroy() { |
| 786 | super.onDestroy(); |
Jim Miller | 9218687 | 2015-03-04 18:07:32 -0800 | [diff] [blame] | 787 | } |
| 788 | |
Amith Yamasani | b0b37ae | 2012-04-23 15:35:36 -0700 | [diff] [blame] | 789 | @Override |
Fan Zhang | e0b0e9f | 2017-11-29 14:55:59 -0800 | [diff] [blame] | 790 | public int getHelpResource() { |
Amith Yamasani | b0b37ae | 2012-04-23 15:35:36 -0700 | [diff] [blame] | 791 | return R.string.help_url_choose_lockscreen; |
| 792 | } |
| 793 | |
Clara Bayarri | 34ec5f9 | 2016-01-22 14:59:24 +0000 | [diff] [blame] | 794 | private int getResIdForFactoryResetProtectionWarningTitle() { |
Robin Lee | 7886716 | 2016-09-12 16:25:28 +0900 | [diff] [blame] | 795 | boolean isProfile = UserManager.get(getActivity()).isManagedProfile(mUserId); |
Clara Bayarri | 34ec5f9 | 2016-01-22 14:59:24 +0000 | [diff] [blame] | 796 | return isProfile ? R.string.unlock_disable_frp_warning_title_profile |
| 797 | : R.string.unlock_disable_frp_warning_title; |
| 798 | } |
| 799 | |
Adrian Roos | 38c9b9e | 2015-07-24 11:30:14 -0700 | [diff] [blame] | 800 | private int getResIdForFactoryResetProtectionWarningMessage() { |
Jeff Sharkey | 8d8bb6e | 2016-10-13 12:59:17 -0600 | [diff] [blame] | 801 | final boolean hasFingerprints; |
| 802 | if (mFingerprintManager != null && mFingerprintManager.isHardwareDetected()) { |
| 803 | hasFingerprints = mFingerprintManager.hasEnrolledFingerprints(mUserId); |
| 804 | } else { |
| 805 | hasFingerprints = false; |
| 806 | } |
Robin Lee | 7886716 | 2016-09-12 16:25:28 +0900 | [diff] [blame] | 807 | boolean isProfile = UserManager.get(getActivity()).isManagedProfile(mUserId); |
Clara Bayarri | fe432e8 | 2015-10-12 12:07:02 +0100 | [diff] [blame] | 808 | switch (mLockPatternUtils.getKeyguardStoredPasswordQuality(mUserId)) { |
Lucky Zhang | 3bcea02 | 2014-11-25 18:22:14 -0800 | [diff] [blame] | 809 | case DevicePolicyManager.PASSWORD_QUALITY_SOMETHING: |
Clara Bayarri | 34ec5f9 | 2016-01-22 14:59:24 +0000 | [diff] [blame] | 810 | if (hasFingerprints && isProfile) { |
| 811 | return R.string |
| 812 | .unlock_disable_frp_warning_content_pattern_fingerprint_profile; |
| 813 | } else if (hasFingerprints && !isProfile) { |
| 814 | return R.string.unlock_disable_frp_warning_content_pattern_fingerprint; |
| 815 | } else if (isProfile) { |
| 816 | return R.string.unlock_disable_frp_warning_content_pattern_profile; |
| 817 | } else { |
| 818 | return R.string.unlock_disable_frp_warning_content_pattern; |
| 819 | } |
Lucky Zhang | 3bcea02 | 2014-11-25 18:22:14 -0800 | [diff] [blame] | 820 | case DevicePolicyManager.PASSWORD_QUALITY_NUMERIC: |
| 821 | case DevicePolicyManager.PASSWORD_QUALITY_NUMERIC_COMPLEX: |
Clara Bayarri | 34ec5f9 | 2016-01-22 14:59:24 +0000 | [diff] [blame] | 822 | if (hasFingerprints && isProfile) { |
| 823 | return R.string.unlock_disable_frp_warning_content_pin_fingerprint_profile; |
| 824 | } else if (hasFingerprints && !isProfile) { |
| 825 | return R.string.unlock_disable_frp_warning_content_pin_fingerprint; |
| 826 | } else if (isProfile) { |
| 827 | return R.string.unlock_disable_frp_warning_content_pin_profile; |
| 828 | } else { |
| 829 | return R.string.unlock_disable_frp_warning_content_pin; |
| 830 | } |
Lucky Zhang | 3bcea02 | 2014-11-25 18:22:14 -0800 | [diff] [blame] | 831 | case DevicePolicyManager.PASSWORD_QUALITY_ALPHABETIC: |
| 832 | case DevicePolicyManager.PASSWORD_QUALITY_ALPHANUMERIC: |
| 833 | case DevicePolicyManager.PASSWORD_QUALITY_COMPLEX: |
Toni Barzic | e7d6e4d | 2016-03-30 11:43:19 -0700 | [diff] [blame] | 834 | case DevicePolicyManager.PASSWORD_QUALITY_MANAGED: |
Clara Bayarri | 34ec5f9 | 2016-01-22 14:59:24 +0000 | [diff] [blame] | 835 | if (hasFingerprints && isProfile) { |
| 836 | return R.string |
| 837 | .unlock_disable_frp_warning_content_password_fingerprint_profile; |
| 838 | } else if (hasFingerprints && !isProfile) { |
| 839 | return R.string.unlock_disable_frp_warning_content_password_fingerprint; |
| 840 | } else if (isProfile) { |
| 841 | return R.string.unlock_disable_frp_warning_content_password_profile; |
| 842 | } else { |
| 843 | return R.string.unlock_disable_frp_warning_content_password; |
| 844 | } |
Lucky Zhang | 3bcea02 | 2014-11-25 18:22:14 -0800 | [diff] [blame] | 845 | default: |
Clara Bayarri | 34ec5f9 | 2016-01-22 14:59:24 +0000 | [diff] [blame] | 846 | if (hasFingerprints && isProfile) { |
| 847 | return R.string |
| 848 | .unlock_disable_frp_warning_content_unknown_fingerprint_profile; |
| 849 | } else if (hasFingerprints && !isProfile) { |
| 850 | return R.string.unlock_disable_frp_warning_content_unknown_fingerprint; |
| 851 | } else if (isProfile) { |
| 852 | return R.string.unlock_disable_frp_warning_content_unknown_profile; |
| 853 | } else { |
| 854 | return R.string.unlock_disable_frp_warning_content_unknown; |
| 855 | } |
Lucky Zhang | 3bcea02 | 2014-11-25 18:22:14 -0800 | [diff] [blame] | 856 | } |
| 857 | } |
| 858 | |
| 859 | private boolean isUnlockMethodSecure(String unlockMethod) { |
Maurice Lam | edb3944 | 2017-04-27 18:54:33 -0700 | [diff] [blame] | 860 | return !(ScreenLockType.SWIPE.preferenceKey.equals(unlockMethod) || |
| 861 | ScreenLockType.NONE.preferenceKey.equals(unlockMethod)); |
Lucky Zhang | 3bcea02 | 2014-11-25 18:22:14 -0800 | [diff] [blame] | 862 | } |
| 863 | |
| 864 | private boolean setUnlockMethod(String unlockMethod) { |
| 865 | EventLog.writeEvent(EventLogTags.LOCK_SCREEN_TYPE, unlockMethod); |
| 866 | |
Maurice Lam | edb3944 | 2017-04-27 18:54:33 -0700 | [diff] [blame] | 867 | ScreenLockType lock = ScreenLockType.fromKey(unlockMethod); |
| 868 | if (lock != null) { |
| 869 | switch (lock) { |
| 870 | case NONE: |
| 871 | case SWIPE: |
| 872 | updateUnlockMethodAndFinish( |
| 873 | lock.defaultQuality, |
| 874 | lock == ScreenLockType.NONE, |
| 875 | false /* chooseLockSkipped */); |
| 876 | return true; |
| 877 | case PATTERN: |
| 878 | case PIN: |
| 879 | case PASSWORD: |
| 880 | case MANAGED: |
| 881 | maybeEnableEncryption(lock.defaultQuality, false); |
| 882 | return true; |
| 883 | } |
Lucky Zhang | 3bcea02 | 2014-11-25 18:22:14 -0800 | [diff] [blame] | 884 | } |
Maurice Lam | edb3944 | 2017-04-27 18:54:33 -0700 | [diff] [blame] | 885 | Log.e(TAG, "Encountered unknown unlock method to set: " + unlockMethod); |
| 886 | return false; |
Lucky Zhang | 3bcea02 | 2014-11-25 18:22:14 -0800 | [diff] [blame] | 887 | } |
| 888 | |
| 889 | private void showFactoryResetProtectionWarningDialog(String unlockMethodToSet) { |
Clara Bayarri | 34ec5f9 | 2016-01-22 14:59:24 +0000 | [diff] [blame] | 890 | int title = getResIdForFactoryResetProtectionWarningTitle(); |
Adrian Roos | 38c9b9e | 2015-07-24 11:30:14 -0700 | [diff] [blame] | 891 | int message = getResIdForFactoryResetProtectionWarningMessage(); |
Lucky Zhang | 3bcea02 | 2014-11-25 18:22:14 -0800 | [diff] [blame] | 892 | FactoryResetProtectionWarningDialog dialog = |
Clara Bayarri | 34ec5f9 | 2016-01-22 14:59:24 +0000 | [diff] [blame] | 893 | FactoryResetProtectionWarningDialog.newInstance( |
| 894 | title, message, unlockMethodToSet); |
Lucky Zhang | 3bcea02 | 2014-11-25 18:22:14 -0800 | [diff] [blame] | 895 | dialog.show(getChildFragmentManager(), TAG_FRP_WARNING_DIALOG); |
| 896 | } |
| 897 | |
Fan Zhang | ac5e593 | 2016-08-24 18:13:33 -0700 | [diff] [blame] | 898 | public static class FactoryResetProtectionWarningDialog extends InstrumentedDialogFragment { |
Lucky Zhang | 3bcea02 | 2014-11-25 18:22:14 -0800 | [diff] [blame] | 899 | |
Clara Bayarri | 34ec5f9 | 2016-01-22 14:59:24 +0000 | [diff] [blame] | 900 | private static final String ARG_TITLE_RES = "titleRes"; |
Adrian Roos | 38c9b9e | 2015-07-24 11:30:14 -0700 | [diff] [blame] | 901 | private static final String ARG_MESSAGE_RES = "messageRes"; |
Lucky Zhang | 3bcea02 | 2014-11-25 18:22:14 -0800 | [diff] [blame] | 902 | private static final String ARG_UNLOCK_METHOD_TO_SET = "unlockMethodToSet"; |
| 903 | |
Clara Bayarri | 34ec5f9 | 2016-01-22 14:59:24 +0000 | [diff] [blame] | 904 | public static FactoryResetProtectionWarningDialog newInstance( |
| 905 | int titleRes, int messageRes, String unlockMethodToSet) { |
Lucky Zhang | 3bcea02 | 2014-11-25 18:22:14 -0800 | [diff] [blame] | 906 | FactoryResetProtectionWarningDialog frag = |
| 907 | new FactoryResetProtectionWarningDialog(); |
| 908 | Bundle args = new Bundle(); |
Clara Bayarri | 34ec5f9 | 2016-01-22 14:59:24 +0000 | [diff] [blame] | 909 | args.putInt(ARG_TITLE_RES, titleRes); |
Adrian Roos | 38c9b9e | 2015-07-24 11:30:14 -0700 | [diff] [blame] | 910 | args.putInt(ARG_MESSAGE_RES, messageRes); |
Lucky Zhang | 3bcea02 | 2014-11-25 18:22:14 -0800 | [diff] [blame] | 911 | args.putString(ARG_UNLOCK_METHOD_TO_SET, unlockMethodToSet); |
| 912 | frag.setArguments(args); |
| 913 | return frag; |
| 914 | } |
| 915 | |
| 916 | @Override |
| 917 | public void show(FragmentManager manager, String tag) { |
| 918 | if (manager.findFragmentByTag(tag) == null) { |
| 919 | // Prevent opening multiple dialogs if tapped on button quickly |
| 920 | super.show(manager, tag); |
| 921 | } |
| 922 | } |
| 923 | |
| 924 | @Override |
| 925 | public Dialog onCreateDialog(Bundle savedInstanceState) { |
| 926 | final Bundle args = getArguments(); |
| 927 | |
| 928 | return new AlertDialog.Builder(getActivity()) |
Clara Bayarri | 34ec5f9 | 2016-01-22 14:59:24 +0000 | [diff] [blame] | 929 | .setTitle(args.getInt(ARG_TITLE_RES)) |
Adrian Roos | 38c9b9e | 2015-07-24 11:30:14 -0700 | [diff] [blame] | 930 | .setMessage(args.getInt(ARG_MESSAGE_RES)) |
| 931 | .setPositiveButton(R.string.unlock_disable_frp_warning_ok, |
Maurice Lam | edb3944 | 2017-04-27 18:54:33 -0700 | [diff] [blame] | 932 | (dialog, whichButton) -> { |
| 933 | String unlockMethod = args.getString(ARG_UNLOCK_METHOD_TO_SET); |
| 934 | ((ChooseLockGenericFragment) getParentFragment()) |
| 935 | .setUnlockMethod(unlockMethod); |
| 936 | }) |
| 937 | .setNegativeButton(R.string.cancel, (dialog, whichButton) -> dismiss()) |
Lucky Zhang | 3bcea02 | 2014-11-25 18:22:14 -0800 | [diff] [blame] | 938 | .create(); |
| 939 | } |
Fan Zhang | ac5e593 | 2016-08-24 18:13:33 -0700 | [diff] [blame] | 940 | |
| 941 | @Override |
| 942 | public int getMetricsCategory() { |
Fan Zhang | 31b2100 | 2019-01-16 13:49:47 -0800 | [diff] [blame] | 943 | return SettingsEnums.DIALOG_FRP; |
Fan Zhang | ac5e593 | 2016-08-24 18:13:33 -0700 | [diff] [blame] | 944 | } |
Lucky Zhang | 3bcea02 | 2014-11-25 18:22:14 -0800 | [diff] [blame] | 945 | } |
Jim Miller | bbb4afa | 2010-04-08 19:40:19 -0700 | [diff] [blame] | 946 | } |
Dianne Hackborn | abc3dc6 | 2010-01-20 13:40:19 -0800 | [diff] [blame] | 947 | } |