The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2008 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 | |
| 17 | package com.android.settings; |
| 18 | |
Maurice Lam | 2eb170c | 2017-04-28 16:18:47 -0700 | [diff] [blame] | 19 | import static com.android.settingslib.RestrictedLockUtils.EnforcedAdmin; |
| 20 | |
Joe Onorato | b51886d | 2010-11-08 18:25:51 -0800 | [diff] [blame] | 21 | import android.accounts.Account; |
| 22 | import android.accounts.AccountManager; |
| 23 | import android.accounts.AuthenticatorDescription; |
felkachang | a6cec47 | 2018-03-29 12:08:20 +0800 | [diff] [blame] | 24 | import android.app.ActionBar; |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 25 | import android.app.Activity; |
Fan Zhang | 31b2100 | 2019-01-16 13:49:47 -0800 | [diff] [blame] | 26 | import android.app.settings.SettingsEnums; |
Christine Franks | a09eb38 | 2017-06-23 14:28:21 -0700 | [diff] [blame] | 27 | import android.content.ComponentName; |
Jeff Davidson | f1c13fa | 2017-05-19 17:03:32 -0700 | [diff] [blame] | 28 | import android.content.ContentResolver; |
Joe Onorato | b51886d | 2010-11-08 18:25:51 -0800 | [diff] [blame] | 29 | import android.content.Context; |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 30 | import android.content.Intent; |
Joe Onorato | b51886d | 2010-11-08 18:25:51 -0800 | [diff] [blame] | 31 | import android.content.pm.PackageManager; |
Carlos Valdivia | a9736ed | 2018-01-16 13:59:31 -0800 | [diff] [blame] | 32 | import android.content.pm.ResolveInfo; |
Zoltan Szatmary-Ban | 7cc1b9e | 2014-10-24 18:03:18 +0100 | [diff] [blame] | 33 | import android.content.pm.UserInfo; |
Amith Yamasani | b14e1e0 | 2010-11-02 09:52:29 -0700 | [diff] [blame] | 34 | import android.content.res.Resources; |
felkachang | a6cec47 | 2018-03-29 12:08:20 +0800 | [diff] [blame] | 35 | import android.graphics.Color; |
Joe Onorato | b51886d | 2010-11-08 18:25:51 -0800 | [diff] [blame] | 36 | import android.graphics.drawable.Drawable; |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 37 | import android.os.Bundle; |
Kenny Root | 3785e39 | 2011-01-18 15:14:32 -0800 | [diff] [blame] | 38 | import android.os.Environment; |
Ben Komalo | 2a32192 | 2011-09-07 16:42:34 -0700 | [diff] [blame] | 39 | import android.os.SystemProperties; |
Zoltan Szatmary-Ban | 7cc1b9e | 2014-10-24 18:03:18 +0100 | [diff] [blame] | 40 | import android.os.UserHandle; |
Amith Yamasani | 7eedcf4 | 2013-07-02 14:15:29 -0700 | [diff] [blame] | 41 | import android.os.UserManager; |
Jeff Davidson | f1c13fa | 2017-05-19 17:03:32 -0700 | [diff] [blame] | 42 | import android.provider.Settings; |
Inseob Kim | a1aeeb2 | 2018-11-08 12:44:47 +0900 | [diff] [blame] | 43 | import android.sysprop.VoldProperties; |
qingxi | 072f286 | 2017-04-11 18:28:40 -0700 | [diff] [blame] | 44 | import android.telephony.euicc.EuiccManager; |
Carlos Valdivia | a9736ed | 2018-01-16 13:59:31 -0800 | [diff] [blame] | 45 | import android.text.TextUtils; |
Joe Onorato | b51886d | 2010-11-08 18:25:51 -0800 | [diff] [blame] | 46 | import android.util.Log; |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 47 | import android.view.LayoutInflater; |
| 48 | import android.view.View; |
jackqdyulei | 0b3edc7 | 2016-12-13 17:07:08 -0800 | [diff] [blame] | 49 | import android.view.View.OnScrollChangeListener; |
Amith Yamasani | b14e1e0 | 2010-11-02 09:52:29 -0700 | [diff] [blame] | 50 | import android.view.ViewGroup; |
jackqdyulei | 0b3edc7 | 2016-12-13 17:07:08 -0800 | [diff] [blame] | 51 | import android.view.ViewTreeObserver.OnGlobalLayoutListener; |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 52 | import android.widget.Button; |
Dianne Hackborn | 1337d0f | 2010-10-14 11:58:30 -0700 | [diff] [blame] | 53 | import android.widget.CheckBox; |
Fan Zhang | 6b2bb39 | 2016-09-28 09:07:44 -0700 | [diff] [blame] | 54 | import android.widget.ImageView; |
Joe Onorato | b51886d | 2010-11-08 18:25:51 -0800 | [diff] [blame] | 55 | import android.widget.LinearLayout; |
jackqdyulei | 0b3edc7 | 2016-12-13 17:07:08 -0800 | [diff] [blame] | 56 | import android.widget.ScrollView; |
Joe Onorato | b51886d | 2010-11-08 18:25:51 -0800 | [diff] [blame] | 57 | import android.widget.TextView; |
Jason Monk | 39b4674 | 2015-09-10 15:52:51 -0400 | [diff] [blame] | 58 | |
Fan Zhang | 23f8d59 | 2018-08-28 15:11:40 -0700 | [diff] [blame] | 59 | import androidx.annotation.VisibleForTesting; |
| 60 | |
Doris Ling | 7248972 | 2017-11-16 11:03:40 -0800 | [diff] [blame] | 61 | import com.android.settings.core.InstrumentedFragment; |
Fan Zhang | 7cf99f5 | 2018-02-16 10:37:37 -0800 | [diff] [blame] | 62 | import com.android.settings.core.SubSettingLauncher; |
arangelov | e35badd | 2017-10-27 13:51:28 +0100 | [diff] [blame] | 63 | import com.android.settings.enterprise.ActionDisabledByAdminDialogHelper; |
Maurice Lam | 2eb170c | 2017-04-28 16:18:47 -0700 | [diff] [blame] | 64 | import com.android.settings.password.ChooseLockSettingsHelper; |
| 65 | import com.android.settings.password.ConfirmLockPattern; |
Philip P. Moltmann | e3f7211 | 2018-08-28 15:01:43 -0700 | [diff] [blame] | 66 | import com.android.settingslib.RestrictedLockUtilsInternal; |
Taesu Lee | 39e4fbb | 2019-07-22 19:20:05 +0900 | [diff] [blame] | 67 | import com.android.settingslib.development.DevelopmentSettingsEnabler; |
Pasty Chang | c1f8600 | 2018-12-11 02:22:55 +0000 | [diff] [blame] | 68 | |
pastychang | 9bdb59a | 2019-01-21 09:49:15 +0800 | [diff] [blame] | 69 | import com.google.android.setupcompat.template.FooterBarMixin; |
| 70 | import com.google.android.setupcompat.template.FooterButton; |
| 71 | import com.google.android.setupcompat.template.FooterButton.ButtonType; |
Maurice Lam | 59f1c1a | 2019-02-14 22:04:30 +0000 | [diff] [blame] | 72 | import com.google.android.setupdesign.GlifLayout; |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 73 | |
Zoltan Szatmary-Ban | 7cc1b9e | 2014-10-24 18:03:18 +0100 | [diff] [blame] | 74 | import java.util.List; |
| 75 | |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 76 | /** |
| 77 | * Confirm and execute a reset of the device to a clean "just out of the box" |
| 78 | * state. Multiple confirmations are required: first, a general "are you sure |
| 79 | * you want to do this?" prompt, followed by a keyguard pattern trace if the user |
| 80 | * has defined one, followed by a final strongly-worded "THIS WILL ERASE EVERYTHING |
| 81 | * ON THE PHONE" prompt. If at any time the phone is allowed to go to sleep, is |
| 82 | * locked, et cetera, then the confirmation sequence is abandoned. |
Amith Yamasani | b14e1e0 | 2010-11-02 09:52:29 -0700 | [diff] [blame] | 83 | * |
| 84 | * This is the initial screen. |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 85 | */ |
Doris Ling | 1f49715 | 2018-02-22 16:33:07 -0800 | [diff] [blame] | 86 | public class MasterClear extends InstrumentedFragment implements OnGlobalLayoutListener { |
Joe Onorato | b51886d | 2010-11-08 18:25:51 -0800 | [diff] [blame] | 87 | private static final String TAG = "MasterClear"; |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 88 | |
felkachang | a6cec47 | 2018-03-29 12:08:20 +0800 | [diff] [blame] | 89 | @VisibleForTesting |
| 90 | static final int KEYGUARD_REQUEST = 55; |
| 91 | @VisibleForTesting |
| 92 | static final int CREDENTIAL_CONFIRM_REQUEST = 56; |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 93 | |
Qingxi Li | c8a2b04 | 2018-01-11 11:35:07 -0800 | [diff] [blame] | 94 | private static final String KEY_SHOW_ESIM_RESET_CHECKBOX |
| 95 | = "masterclear.allow_retain_esim_profiles_after_fdr"; |
| 96 | |
Amith Yamasani | b14e1e0 | 2010-11-02 09:52:29 -0700 | [diff] [blame] | 97 | static final String ERASE_EXTERNAL_EXTRA = "erase_sd"; |
qingxi | 072f286 | 2017-04-11 18:28:40 -0700 | [diff] [blame] | 98 | static final String ERASE_ESIMS_EXTRA = "erase_esim"; |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 99 | |
Amith Yamasani | b14e1e0 | 2010-11-02 09:52:29 -0700 | [diff] [blame] | 100 | private View mContentView; |
felkachang | a6cec47 | 2018-03-29 12:08:20 +0800 | [diff] [blame] | 101 | @VisibleForTesting |
pastychang | 103409b | 2018-12-13 23:00:17 +0800 | [diff] [blame] | 102 | FooterButton mInitiateButton; |
Dianne Hackborn | 1337d0f | 2010-10-14 11:58:30 -0700 | [diff] [blame] | 103 | private View mExternalStorageContainer; |
felkachang | a6cec47 | 2018-03-29 12:08:20 +0800 | [diff] [blame] | 104 | @VisibleForTesting |
| 105 | CheckBox mExternalStorage; |
Andrew Sapperstein | 88930e3 | 2019-03-07 14:18:15 -0800 | [diff] [blame] | 106 | @VisibleForTesting |
| 107 | View mEsimStorageContainer; |
felkachang | a6cec47 | 2018-03-29 12:08:20 +0800 | [diff] [blame] | 108 | @VisibleForTesting |
| 109 | CheckBox mEsimStorage; |
| 110 | @VisibleForTesting |
| 111 | ScrollView mScrollView; |
jackqdyulei | 0b3edc7 | 2016-12-13 17:07:08 -0800 | [diff] [blame] | 112 | |
Doris Ling | 1f49715 | 2018-02-22 16:33:07 -0800 | [diff] [blame] | 113 | @Override |
| 114 | public void onGlobalLayout() { |
| 115 | mInitiateButton.setEnabled(hasReachedBottom(mScrollView)); |
| 116 | } |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 117 | |
felkachang | a6cec47 | 2018-03-29 12:08:20 +0800 | [diff] [blame] | 118 | private void setUpActionBarAndTitle() { |
| 119 | final Activity activity = getActivity(); |
| 120 | if (activity == null) { |
| 121 | Log.e(TAG, "No activity attached, skipping setUpActionBarAndTitle"); |
| 122 | return; |
| 123 | } |
| 124 | final ActionBar actionBar = activity.getActionBar(); |
| 125 | if (actionBar == null) { |
| 126 | Log.e(TAG, "No actionbar, skipping setUpActionBarAndTitle"); |
| 127 | return; |
| 128 | } |
| 129 | actionBar.hide(); |
| 130 | activity.getWindow().setStatusBarColor(Color.TRANSPARENT); |
Doris Ling | 03a3b51 | 2017-10-18 14:25:01 -0700 | [diff] [blame] | 131 | } |
| 132 | |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 133 | /** |
Jim Miller | 2deec7e | 2010-04-13 17:43:36 -0700 | [diff] [blame] | 134 | * Keyguard validation is run using the standard {@link ConfirmLockPattern} |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 135 | * component as a subactivity |
felkachang | a6cec47 | 2018-03-29 12:08:20 +0800 | [diff] [blame] | 136 | * |
Jim Miller | 2deec7e | 2010-04-13 17:43:36 -0700 | [diff] [blame] | 137 | * @param request the request code to be returned once confirmation finishes |
| 138 | * @return true if confirmation launched |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 139 | */ |
Jim Miller | 2deec7e | 2010-04-13 17:43:36 -0700 | [diff] [blame] | 140 | private boolean runKeyguardConfirmation(int request) { |
Amith Yamasani | b14e1e0 | 2010-11-02 09:52:29 -0700 | [diff] [blame] | 141 | Resources res = getActivity().getResources(); |
Jorim Jaggi | 8a09b61 | 2015-04-06 17:47:18 -0700 | [diff] [blame] | 142 | return new ChooseLockSettingsHelper(getActivity(), this).launchConfirmationActivity( |
Fan Zhang | dc00efa | 2018-05-10 15:10:19 -0700 | [diff] [blame] | 143 | request, res.getText(R.string.master_clear_short_title)); |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 144 | } |
| 145 | |
Carlos Valdivia | 5dd6ed4 | 2018-01-23 09:12:59 -0800 | [diff] [blame] | 146 | @VisibleForTesting |
| 147 | boolean isValidRequestCode(int requestCode) { |
| 148 | return !((requestCode != KEYGUARD_REQUEST) && (requestCode != CREDENTIAL_CONFIRM_REQUEST)); |
| 149 | } |
| 150 | |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 151 | @Override |
Amith Yamasani | b14e1e0 | 2010-11-02 09:52:29 -0700 | [diff] [blame] | 152 | public void onActivityResult(int requestCode, int resultCode, Intent data) { |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 153 | super.onActivityResult(requestCode, resultCode, data); |
Carlos Valdivia | 4b34dad | 2018-01-29 18:30:33 -0800 | [diff] [blame] | 154 | onActivityResultInternal(requestCode, resultCode, data); |
| 155 | } |
| 156 | |
| 157 | /* |
| 158 | * Internal method that allows easy testing without dealing with super references. |
| 159 | */ |
| 160 | @VisibleForTesting |
| 161 | void onActivityResultInternal(int requestCode, int resultCode, Intent data) { |
Carlos Valdivia | 5dd6ed4 | 2018-01-23 09:12:59 -0800 | [diff] [blame] | 162 | if (!isValidRequestCode(requestCode)) { |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 163 | return; |
| 164 | } |
| 165 | |
Carlos Valdivia | 4b34dad | 2018-01-29 18:30:33 -0800 | [diff] [blame] | 166 | if (resultCode != Activity.RESULT_OK) { |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 167 | establishInitialState(); |
Carlos Valdivia | 4b34dad | 2018-01-29 18:30:33 -0800 | [diff] [blame] | 168 | return; |
| 169 | } |
| 170 | |
| 171 | Intent intent = null; |
| 172 | // If returning from a Keyguard request, try to show an account confirmation request if |
| 173 | // applciable. |
| 174 | if (CREDENTIAL_CONFIRM_REQUEST != requestCode |
| 175 | && (intent = getAccountConfirmationIntent()) != null) { |
| 176 | showAccountCredentialConfirmation(intent); |
| 177 | } else { |
| 178 | showFinalConfirmation(); |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 179 | } |
| 180 | } |
| 181 | |
qingxi | 072f286 | 2017-04-11 18:28:40 -0700 | [diff] [blame] | 182 | @VisibleForTesting |
| 183 | void showFinalConfirmation() { |
Fan Zhang | 7cf99f5 | 2018-02-16 10:37:37 -0800 | [diff] [blame] | 184 | final Bundle args = new Bundle(); |
Stuart Scott | be90341 | 2014-07-24 19:22:06 -0700 | [diff] [blame] | 185 | args.putBoolean(ERASE_EXTERNAL_EXTRA, mExternalStorage.isChecked()); |
Antony Sargent | 8d2baf6 | 2019-07-11 11:04:09 -0700 | [diff] [blame] | 186 | args.putBoolean(ERASE_ESIMS_EXTRA, mEsimStorage.isChecked()); |
Fan Zhang | 7cf99f5 | 2018-02-16 10:37:37 -0800 | [diff] [blame] | 187 | new SubSettingLauncher(getContext()) |
| 188 | .setDestination(MasterClearConfirm.class.getName()) |
| 189 | .setArguments(args) |
hjchangliao | e86eec0 | 2018-05-02 13:01:07 +0800 | [diff] [blame] | 190 | .setTitleRes(R.string.master_clear_confirm_title) |
Fan Zhang | 7cf99f5 | 2018-02-16 10:37:37 -0800 | [diff] [blame] | 191 | .setSourceMetricsCategory(getMetricsCategory()) |
| 192 | .launch(); |
Amith Yamasani | b14e1e0 | 2010-11-02 09:52:29 -0700 | [diff] [blame] | 193 | } |
| 194 | |
Carlos Valdivia | a9736ed | 2018-01-16 13:59:31 -0800 | [diff] [blame] | 195 | @VisibleForTesting |
Carlos Valdivia | 4b34dad | 2018-01-29 18:30:33 -0800 | [diff] [blame] | 196 | void showAccountCredentialConfirmation(Intent intent) { |
| 197 | startActivityForResult(intent, CREDENTIAL_CONFIRM_REQUEST); |
| 198 | } |
| 199 | |
| 200 | @VisibleForTesting |
| 201 | Intent getAccountConfirmationIntent() { |
Carlos Valdivia | a9736ed | 2018-01-16 13:59:31 -0800 | [diff] [blame] | 202 | final Context context = getActivity(); |
| 203 | final String accountType = context.getString(R.string.account_type); |
| 204 | final String packageName = context.getString(R.string.account_confirmation_package); |
Carlos Valdivia | 5114604 | 2018-01-23 17:17:56 -0800 | [diff] [blame] | 205 | final String className = context.getString(R.string.account_confirmation_class); |
| 206 | if (TextUtils.isEmpty(accountType) |
| 207 | || TextUtils.isEmpty(packageName) |
| 208 | || TextUtils.isEmpty(className)) { |
Carlos Valdivia | 4b34dad | 2018-01-29 18:30:33 -0800 | [diff] [blame] | 209 | Log.i(TAG, "Resources not set for account confirmation."); |
| 210 | return null; |
Carlos Valdivia | a9736ed | 2018-01-16 13:59:31 -0800 | [diff] [blame] | 211 | } |
| 212 | final AccountManager am = AccountManager.get(context); |
| 213 | Account[] accounts = am.getAccountsByType(accountType); |
| 214 | if (accounts != null && accounts.length > 0) { |
| 215 | final Intent requestAccountConfirmation = new Intent() |
felkachang | a6cec47 | 2018-03-29 12:08:20 +0800 | [diff] [blame] | 216 | .setPackage(packageName) |
| 217 | .setComponent(new ComponentName(packageName, className)); |
Carlos Valdivia | a9736ed | 2018-01-16 13:59:31 -0800 | [diff] [blame] | 218 | // Check to make sure that the intent is supported. |
| 219 | final PackageManager pm = context.getPackageManager(); |
Carlos Valdivia | 08c8820 | 2018-01-21 18:57:28 -0800 | [diff] [blame] | 220 | final ResolveInfo resolution = pm.resolveActivity(requestAccountConfirmation, 0); |
| 221 | if (resolution != null |
| 222 | && resolution.activityInfo != null |
| 223 | && packageName.equals(resolution.activityInfo.packageName)) { |
| 224 | // Note that we need to check the packagename to make sure that an Activity resolver |
| 225 | // wasn't returned. |
Carlos Valdivia | 4b34dad | 2018-01-29 18:30:33 -0800 | [diff] [blame] | 226 | return requestAccountConfirmation; |
| 227 | } else { |
| 228 | Log.i(TAG, "Unable to resolve Activity: " + packageName + "/" + className); |
Carlos Valdivia | a9736ed | 2018-01-16 13:59:31 -0800 | [diff] [blame] | 229 | } |
Carlos Valdivia | 4b34dad | 2018-01-29 18:30:33 -0800 | [diff] [blame] | 230 | } else { |
| 231 | Log.d(TAG, "No " + accountType + " accounts installed!"); |
Carlos Valdivia | a9736ed | 2018-01-16 13:59:31 -0800 | [diff] [blame] | 232 | } |
Carlos Valdivia | 4b34dad | 2018-01-29 18:30:33 -0800 | [diff] [blame] | 233 | return null; |
Carlos Valdivia | a9736ed | 2018-01-16 13:59:31 -0800 | [diff] [blame] | 234 | } |
| 235 | |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 236 | /** |
| 237 | * If the user clicks to begin the reset sequence, we next require a |
| 238 | * keyguard confirmation if the user has currently enabled one. If there |
| 239 | * is no keyguard available, we simply go to the final confirmation prompt. |
Christine Franks | a09eb38 | 2017-06-23 14:28:21 -0700 | [diff] [blame] | 240 | * |
| 241 | * If the user is in demo mode, route to the demo mode app for confirmation. |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 242 | */ |
Christine Franks | a09eb38 | 2017-06-23 14:28:21 -0700 | [diff] [blame] | 243 | @VisibleForTesting |
| 244 | protected final Button.OnClickListener mInitiateListener = new Button.OnClickListener() { |
Amith Yamasani | b14e1e0 | 2010-11-02 09:52:29 -0700 | [diff] [blame] | 245 | |
Christine Franks | a09eb38 | 2017-06-23 14:28:21 -0700 | [diff] [blame] | 246 | public void onClick(View view) { |
| 247 | final Context context = view.getContext(); |
| 248 | if (Utils.isDemoUser(context)) { |
Justin Klaassen | 3025727 | 2017-08-08 21:58:05 -0700 | [diff] [blame] | 249 | final ComponentName componentName = Utils.getDeviceOwnerComponent(context); |
| 250 | if (componentName != null) { |
Christine Franks | a09eb38 | 2017-06-23 14:28:21 -0700 | [diff] [blame] | 251 | final Intent requestFactoryReset = new Intent() |
Justin Klaassen | 3025727 | 2017-08-08 21:58:05 -0700 | [diff] [blame] | 252 | .setPackage(componentName.getPackageName()) |
Christine Franks | a09eb38 | 2017-06-23 14:28:21 -0700 | [diff] [blame] | 253 | .setAction(Intent.ACTION_FACTORY_RESET); |
| 254 | context.startActivity(requestFactoryReset); |
Christine Franks | d7713c9 | 2017-01-20 11:24:14 -0800 | [diff] [blame] | 255 | } |
Carlos Valdivia | a9736ed | 2018-01-16 13:59:31 -0800 | [diff] [blame] | 256 | return; |
| 257 | } |
| 258 | |
Carlos Valdivia | 4b34dad | 2018-01-29 18:30:33 -0800 | [diff] [blame] | 259 | if (runKeyguardConfirmation(KEYGUARD_REQUEST)) { |
| 260 | return; |
| 261 | } |
| 262 | |
| 263 | Intent intent = getAccountConfirmationIntent(); |
| 264 | if (intent != null) { |
| 265 | showAccountCredentialConfirmation(intent); |
| 266 | } else { |
Amith Yamasani | b14e1e0 | 2010-11-02 09:52:29 -0700 | [diff] [blame] | 267 | showFinalConfirmation(); |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 268 | } |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 269 | } |
Amith Yamasani | b14e1e0 | 2010-11-02 09:52:29 -0700 | [diff] [blame] | 270 | }; |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 271 | |
| 272 | /** |
| 273 | * In its initial state, the activity presents a button for the user to |
| 274 | * click in order to initiate a confirmation sequence. This method is |
| 275 | * called from various other points in the code to reset the activity to |
| 276 | * this base state. |
Jim Miller | 47d380f | 2010-01-20 13:37:14 -0800 | [diff] [blame] | 277 | * |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 278 | * <p>Reinflating views from resources is expensive and prevents us from |
| 279 | * caching widget pointers, so we use a single-inflate pattern: we lazy- |
| 280 | * inflate each view, caching all of the widget pointers we'll need at the |
| 281 | * time, then simply reuse the inflated views directly whenever we need |
| 282 | * to change contents. |
| 283 | */ |
Carlos Valdivia | 4b34dad | 2018-01-29 18:30:33 -0800 | [diff] [blame] | 284 | @VisibleForTesting |
| 285 | void establishInitialState() { |
felkachang | a6cec47 | 2018-03-29 12:08:20 +0800 | [diff] [blame] | 286 | setUpActionBarAndTitle(); |
| 287 | setUpInitiateButton(); |
| 288 | |
Amith Yamasani | b14e1e0 | 2010-11-02 09:52:29 -0700 | [diff] [blame] | 289 | mExternalStorageContainer = mContentView.findViewById(R.id.erase_external_container); |
Doris Ling | 1f49715 | 2018-02-22 16:33:07 -0800 | [diff] [blame] | 290 | mExternalStorage = mContentView.findViewById(R.id.erase_external); |
Qingxi Li | c8a2b04 | 2018-01-11 11:35:07 -0800 | [diff] [blame] | 291 | mEsimStorageContainer = mContentView.findViewById(R.id.erase_esim_container); |
Doris Ling | 1f49715 | 2018-02-22 16:33:07 -0800 | [diff] [blame] | 292 | mEsimStorage = mContentView.findViewById(R.id.erase_esim); |
| 293 | if (mScrollView != null) { |
| 294 | mScrollView.getViewTreeObserver().removeOnGlobalLayoutListener(this); |
| 295 | } |
| 296 | mScrollView = mContentView.findViewById(R.id.master_clear_scrollview); |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 297 | |
Kenny Root | 3785e39 | 2011-01-18 15:14:32 -0800 | [diff] [blame] | 298 | /* |
| 299 | * If the external storage is emulated, it will be erased with a factory |
| 300 | * reset at any rate. There is no need to have a separate option until |
| 301 | * we have a factory reset that only erases some directories and not |
Ben Komalo | 2a32192 | 2011-09-07 16:42:34 -0700 | [diff] [blame] | 302 | * others. Likewise, if it's non-removable storage, it could potentially have been |
| 303 | * encrypted, and will also need to be wiped. |
Kenny Root | 3785e39 | 2011-01-18 15:14:32 -0800 | [diff] [blame] | 304 | */ |
Ben Komalo | 2a32192 | 2011-09-07 16:42:34 -0700 | [diff] [blame] | 305 | boolean isExtStorageEmulated = Environment.isExternalStorageEmulated(); |
| 306 | if (isExtStorageEmulated |
| 307 | || (!Environment.isExternalStorageRemovable() && isExtStorageEncrypted())) { |
Kenny Root | 3785e39 | 2011-01-18 15:14:32 -0800 | [diff] [blame] | 308 | mExternalStorageContainer.setVisibility(View.GONE); |
Amith Yamasani | b14e1e0 | 2010-11-02 09:52:29 -0700 | [diff] [blame] | 309 | |
Kenny Root | 3785e39 | 2011-01-18 15:14:32 -0800 | [diff] [blame] | 310 | final View externalOption = mContentView.findViewById(R.id.erase_external_option_text); |
| 311 | externalOption.setVisibility(View.GONE); |
| 312 | |
| 313 | final View externalAlsoErased = mContentView.findViewById(R.id.also_erases_external); |
| 314 | externalAlsoErased.setVisibility(View.VISIBLE); |
Ben Komalo | 2a32192 | 2011-09-07 16:42:34 -0700 | [diff] [blame] | 315 | |
| 316 | // If it's not emulated, it is on a separate partition but it means we're doing |
| 317 | // a force wipe due to encryption. |
| 318 | mExternalStorage.setChecked(!isExtStorageEmulated); |
Kenny Root | 3785e39 | 2011-01-18 15:14:32 -0800 | [diff] [blame] | 319 | } else { |
| 320 | mExternalStorageContainer.setOnClickListener(new View.OnClickListener() { |
| 321 | |
| 322 | @Override |
| 323 | public void onClick(View v) { |
| 324 | mExternalStorage.toggle(); |
| 325 | } |
| 326 | }); |
| 327 | } |
Joe Onorato | b51886d | 2010-11-08 18:25:51 -0800 | [diff] [blame] | 328 | |
Jeff Davidson | f1c13fa | 2017-05-19 17:03:32 -0700 | [diff] [blame] | 329 | if (showWipeEuicc()) { |
Qingxi Li | c8a2b04 | 2018-01-11 11:35:07 -0800 | [diff] [blame] | 330 | if (showWipeEuiccCheckbox()) { |
Qingxi Li | c8a2b04 | 2018-01-11 11:35:07 -0800 | [diff] [blame] | 331 | mEsimStorageContainer.setVisibility(View.VISIBLE); |
| 332 | mEsimStorageContainer.setOnClickListener(new View.OnClickListener() { |
| 333 | @Override |
| 334 | public void onClick(View v) { |
| 335 | mEsimStorage.toggle(); |
| 336 | } |
| 337 | }); |
| 338 | } else { |
| 339 | final View esimAlsoErased = mContentView.findViewById(R.id.also_erases_esim); |
| 340 | esimAlsoErased.setVisibility(View.VISIBLE); |
qingxi | 072f286 | 2017-04-11 18:28:40 -0700 | [diff] [blame] | 341 | |
Qingxi Li | c8a2b04 | 2018-01-11 11:35:07 -0800 | [diff] [blame] | 342 | final View noCancelMobilePlan = mContentView.findViewById( |
| 343 | R.id.no_cancel_mobile_plan); |
| 344 | noCancelMobilePlan.setVisibility(View.VISIBLE); |
| 345 | mEsimStorage.setChecked(true /* checked */); |
| 346 | } |
Edgar Wang | 514d746 | 2020-03-25 16:17:40 +0800 | [diff] [blame] | 347 | } else { |
| 348 | mEsimStorage.setChecked(false /* checked */); |
qingxi | 072f286 | 2017-04-11 18:28:40 -0700 | [diff] [blame] | 349 | } |
| 350 | |
Zoltan Szatmary-Ban | 7cc1b9e | 2014-10-24 18:03:18 +0100 | [diff] [blame] | 351 | final UserManager um = (UserManager) getActivity().getSystemService(Context.USER_SERVICE); |
| 352 | loadAccountList(um); |
Doris Ling | 1f49715 | 2018-02-22 16:33:07 -0800 | [diff] [blame] | 353 | final StringBuffer contentDescription = new StringBuffer(); |
| 354 | final View masterClearContainer = mContentView.findViewById(R.id.master_clear_container); |
Julia Reynolds | ce25af4 | 2015-07-08 16:56:31 -0400 | [diff] [blame] | 355 | getContentDescription(masterClearContainer, contentDescription); |
| 356 | masterClearContainer.setContentDescription(contentDescription); |
jackqdyulei | 0b3edc7 | 2016-12-13 17:07:08 -0800 | [diff] [blame] | 357 | |
| 358 | // Set the status of initiateButton based on scrollview |
| 359 | mScrollView.setOnScrollChangeListener(new OnScrollChangeListener() { |
| 360 | @Override |
| 361 | public void onScrollChange(View v, int scrollX, int scrollY, int oldScrollX, |
felkachang | a6cec47 | 2018-03-29 12:08:20 +0800 | [diff] [blame] | 362 | int oldScrollY) { |
jackqdyulei | 0b3edc7 | 2016-12-13 17:07:08 -0800 | [diff] [blame] | 363 | if (v instanceof ScrollView && hasReachedBottom((ScrollView) v)) { |
| 364 | mInitiateButton.setEnabled(true); |
Doris Ling | 1f49715 | 2018-02-22 16:33:07 -0800 | [diff] [blame] | 365 | mScrollView.setOnScrollChangeListener(null); |
jackqdyulei | 0b3edc7 | 2016-12-13 17:07:08 -0800 | [diff] [blame] | 366 | } |
| 367 | } |
| 368 | }); |
| 369 | |
| 370 | // Set the initial state of the initiateButton |
Doris Ling | 1f49715 | 2018-02-22 16:33:07 -0800 | [diff] [blame] | 371 | mScrollView.getViewTreeObserver().addOnGlobalLayoutListener(this); |
jackqdyulei | 0b3edc7 | 2016-12-13 17:07:08 -0800 | [diff] [blame] | 372 | } |
| 373 | |
Jeff Davidson | f1c13fa | 2017-05-19 17:03:32 -0700 | [diff] [blame] | 374 | /** |
Jeff Davidson | a0b8472 | 2017-07-26 17:38:41 -0700 | [diff] [blame] | 375 | * Whether to show strings indicating that the eUICC will be wiped. |
Jeff Davidson | f1c13fa | 2017-05-19 17:03:32 -0700 | [diff] [blame] | 376 | * |
Jeff Davidson | a0b8472 | 2017-07-26 17:38:41 -0700 | [diff] [blame] | 377 | * <p>We show the strings on any device which supports eUICC as long as the eUICC was ever |
Jeff Davidson | 4ba7478 | 2017-06-30 18:02:13 -0700 | [diff] [blame] | 378 | * provisioned (that is, at least one profile was ever downloaded onto it). |
Jeff Davidson | f1c13fa | 2017-05-19 17:03:32 -0700 | [diff] [blame] | 379 | */ |
| 380 | @VisibleForTesting |
| 381 | boolean showWipeEuicc() { |
| 382 | Context context = getContext(); |
| 383 | if (!isEuiccEnabled(context)) { |
| 384 | return false; |
| 385 | } |
| 386 | ContentResolver cr = context.getContentResolver(); |
Qingxi Li | e0681db | 2018-03-14 16:00:47 -0700 | [diff] [blame] | 387 | return Settings.Global.getInt(cr, Settings.Global.EUICC_PROVISIONED, 0) != 0 |
Taesu Lee | 39e4fbb | 2019-07-22 19:20:05 +0900 | [diff] [blame] | 388 | || DevelopmentSettingsEnabler.isDevelopmentSettingsEnabled(context); |
Jeff Davidson | f1c13fa | 2017-05-19 17:03:32 -0700 | [diff] [blame] | 389 | } |
| 390 | |
| 391 | @VisibleForTesting |
Qingxi Li | c8a2b04 | 2018-01-11 11:35:07 -0800 | [diff] [blame] | 392 | boolean showWipeEuiccCheckbox() { |
| 393 | return SystemProperties |
| 394 | .getBoolean(KEY_SHOW_ESIM_RESET_CHECKBOX, false /* def */); |
| 395 | } |
| 396 | |
| 397 | @VisibleForTesting |
Jeff Davidson | f1c13fa | 2017-05-19 17:03:32 -0700 | [diff] [blame] | 398 | protected boolean isEuiccEnabled(Context context) { |
| 399 | EuiccManager euiccManager = (EuiccManager) context.getSystemService(Context.EUICC_SERVICE); |
| 400 | return euiccManager.isEnabled(); |
| 401 | } |
| 402 | |
jackqdyulei | 0b3edc7 | 2016-12-13 17:07:08 -0800 | [diff] [blame] | 403 | @VisibleForTesting |
| 404 | boolean hasReachedBottom(final ScrollView scrollView) { |
| 405 | if (scrollView.getChildCount() < 1) { |
| 406 | return true; |
| 407 | } |
| 408 | |
| 409 | final View view = scrollView.getChildAt(0); |
| 410 | final int diff = view.getBottom() - (scrollView.getHeight() + scrollView.getScrollY()); |
| 411 | |
| 412 | return diff <= 0; |
Julia Reynolds | ce25af4 | 2015-07-08 16:56:31 -0400 | [diff] [blame] | 413 | } |
| 414 | |
felkachang | a6cec47 | 2018-03-29 12:08:20 +0800 | [diff] [blame] | 415 | private void setUpInitiateButton() { |
| 416 | if (mInitiateButton != null) { |
| 417 | return; |
| 418 | } |
| 419 | |
Maurice Lam | 59f1c1a | 2019-02-14 22:04:30 +0000 | [diff] [blame] | 420 | final GlifLayout layout = mContentView.findViewById(R.id.setup_wizard_layout); |
pastychang | 9bdb59a | 2019-01-21 09:49:15 +0800 | [diff] [blame] | 421 | final FooterBarMixin mixin = layout.getMixin(FooterBarMixin.class); |
| 422 | mixin.setPrimaryButton( |
pastychang | 908501e | 2018-12-26 10:46:40 +0800 | [diff] [blame] | 423 | new FooterButton.Builder(getActivity()) |
| 424 | .setText(R.string.master_clear_button_text) |
| 425 | .setListener(mInitiateListener) |
| 426 | .setButtonType(ButtonType.OTHER) |
pastychang | 7961482 | 2019-01-03 10:12:54 +0800 | [diff] [blame] | 427 | .setTheme(R.style.SudGlifButton_Primary) |
pastychang | 908501e | 2018-12-26 10:46:40 +0800 | [diff] [blame] | 428 | .build() |
pastychang | 103409b | 2018-12-13 23:00:17 +0800 | [diff] [blame] | 429 | ); |
pastychang | 9bdb59a | 2019-01-21 09:49:15 +0800 | [diff] [blame] | 430 | mInitiateButton = mixin.getPrimaryButton(); |
felkachang | a6cec47 | 2018-03-29 12:08:20 +0800 | [diff] [blame] | 431 | } |
| 432 | |
Julia Reynolds | ce25af4 | 2015-07-08 16:56:31 -0400 | [diff] [blame] | 433 | private void getContentDescription(View v, StringBuffer description) { |
felkachang | a6cec47 | 2018-03-29 12:08:20 +0800 | [diff] [blame] | 434 | if (v.getVisibility() != View.VISIBLE) { |
| 435 | return; |
| 436 | } |
| 437 | if (v instanceof ViewGroup) { |
| 438 | ViewGroup vGroup = (ViewGroup) v; |
| 439 | for (int i = 0; i < vGroup.getChildCount(); i++) { |
| 440 | View nextChild = vGroup.getChildAt(i); |
| 441 | getContentDescription(nextChild, description); |
| 442 | } |
| 443 | } else if (v instanceof TextView) { |
| 444 | TextView vText = (TextView) v; |
| 445 | description.append(vText.getText()); |
| 446 | description.append(","); // Allow Talkback to pause between sections. |
| 447 | } |
Joe Onorato | b51886d | 2010-11-08 18:25:51 -0800 | [diff] [blame] | 448 | } |
| 449 | |
Ben Komalo | 2a32192 | 2011-09-07 16:42:34 -0700 | [diff] [blame] | 450 | private boolean isExtStorageEncrypted() { |
Inseob Kim | a1aeeb2 | 2018-11-08 12:44:47 +0900 | [diff] [blame] | 451 | String state = VoldProperties.decrypt().orElse(""); |
Ben Komalo | 2a32192 | 2011-09-07 16:42:34 -0700 | [diff] [blame] | 452 | return !"".equals(state); |
| 453 | } |
| 454 | |
Zoltan Szatmary-Ban | 7cc1b9e | 2014-10-24 18:03:18 +0100 | [diff] [blame] | 455 | private void loadAccountList(final UserManager um) { |
Joe Onorato | b51886d | 2010-11-08 18:25:51 -0800 | [diff] [blame] | 456 | View accountsLabel = mContentView.findViewById(R.id.accounts_label); |
felkachang | a6cec47 | 2018-03-29 12:08:20 +0800 | [diff] [blame] | 457 | LinearLayout contents = (LinearLayout) mContentView.findViewById(R.id.accounts); |
Amith Yamasani | 3f45de5 | 2011-09-22 14:34:17 -0700 | [diff] [blame] | 458 | contents.removeAllViews(); |
Joe Onorato | b51886d | 2010-11-08 18:25:51 -0800 | [diff] [blame] | 459 | |
| 460 | Context context = getActivity(); |
Zoltan Szatmary-Ban | 7cc1b9e | 2014-10-24 18:03:18 +0100 | [diff] [blame] | 461 | final List<UserInfo> profiles = um.getProfiles(UserHandle.myUserId()); |
| 462 | final int profilesSize = profiles.size(); |
Joe Onorato | b51886d | 2010-11-08 18:25:51 -0800 | [diff] [blame] | 463 | |
| 464 | AccountManager mgr = AccountManager.get(context); |
Joe Onorato | b51886d | 2010-11-08 18:25:51 -0800 | [diff] [blame] | 465 | |
felkachang | a6cec47 | 2018-03-29 12:08:20 +0800 | [diff] [blame] | 466 | LayoutInflater inflater = (LayoutInflater) context.getSystemService( |
Joe Onorato | b51886d | 2010-11-08 18:25:51 -0800 | [diff] [blame] | 467 | Context.LAYOUT_INFLATER_SERVICE); |
| 468 | |
Zoltan Szatmary-Ban | 7cc1b9e | 2014-10-24 18:03:18 +0100 | [diff] [blame] | 469 | int accountsCount = 0; |
| 470 | for (int profileIndex = 0; profileIndex < profilesSize; profileIndex++) { |
| 471 | final UserInfo userInfo = profiles.get(profileIndex); |
| 472 | final int profileId = userInfo.id; |
| 473 | final UserHandle userHandle = new UserHandle(profileId); |
| 474 | Account[] accounts = mgr.getAccountsAsUser(profileId); |
| 475 | final int N = accounts.length; |
| 476 | if (N == 0) { |
Joe Onorato | b51886d | 2010-11-08 18:25:51 -0800 | [diff] [blame] | 477 | continue; |
| 478 | } |
Zoltan Szatmary-Ban | 7cc1b9e | 2014-10-24 18:03:18 +0100 | [diff] [blame] | 479 | accountsCount += N; |
Joe Onorato | b51886d | 2010-11-08 18:25:51 -0800 | [diff] [blame] | 480 | |
Zoltan Szatmary-Ban | 7cc1b9e | 2014-10-24 18:03:18 +0100 | [diff] [blame] | 481 | AuthenticatorDescription[] descs = AccountManager.get(context) |
| 482 | .getAuthenticatorTypesAsUser(profileId); |
| 483 | final int M = descs.length; |
| 484 | |
Bartosz Fabianowski | 30ba868 | 2017-04-19 11:51:43 +0200 | [diff] [blame] | 485 | if (profilesSize > 1) { |
| 486 | View titleView = Utils.inflateCategoryHeader(inflater, contents); |
| 487 | final TextView titleText = (TextView) titleView.findViewById(android.R.id.title); |
| 488 | titleText.setText(userInfo.isManagedProfile() ? R.string.category_work |
| 489 | : R.string.category_personal); |
| 490 | contents.addView(titleView); |
| 491 | } |
Zoltan Szatmary-Ban | 7cc1b9e | 2014-10-24 18:03:18 +0100 | [diff] [blame] | 492 | |
| 493 | for (int i = 0; i < N; i++) { |
| 494 | Account account = accounts[i]; |
| 495 | AuthenticatorDescription desc = null; |
| 496 | for (int j = 0; j < M; j++) { |
| 497 | if (account.type.equals(descs[j].type)) { |
| 498 | desc = descs[j]; |
| 499 | break; |
| 500 | } |
| 501 | } |
| 502 | if (desc == null) { |
| 503 | Log.w(TAG, "No descriptor for account name=" + account.name |
| 504 | + " type=" + account.type); |
| 505 | continue; |
| 506 | } |
| 507 | Drawable icon = null; |
| 508 | try { |
| 509 | if (desc.iconId != 0) { |
Zoltan Szatmary-Ban | 546790c | 2014-12-02 17:22:10 +0000 | [diff] [blame] | 510 | Context authContext = context.createPackageContextAsUser(desc.packageName, |
| 511 | 0, userHandle); |
Zoltan Szatmary-Ban | 7cc1b9e | 2014-10-24 18:03:18 +0100 | [diff] [blame] | 512 | icon = context.getPackageManager().getUserBadgedIcon( |
| 513 | authContext.getDrawable(desc.iconId), userHandle); |
| 514 | } |
| 515 | } catch (PackageManager.NameNotFoundException e) { |
Rubin Xu | d1ce82a | 2015-06-08 17:21:19 +0100 | [diff] [blame] | 516 | Log.w(TAG, "Bad package name for account type " + desc.type); |
| 517 | } catch (Resources.NotFoundException e) { |
| 518 | Log.w(TAG, "Invalid icon id for account type " + desc.type, e); |
| 519 | } |
| 520 | if (icon == null) { |
| 521 | icon = context.getPackageManager().getDefaultActivityIcon(); |
Zoltan Szatmary-Ban | 7cc1b9e | 2014-10-24 18:03:18 +0100 | [diff] [blame] | 522 | } |
| 523 | |
Fan Zhang | 6b2bb39 | 2016-09-28 09:07:44 -0700 | [diff] [blame] | 524 | View child = inflater.inflate(R.layout.master_clear_account, contents, false); |
| 525 | ((ImageView) child.findViewById(android.R.id.icon)).setImageDrawable(icon); |
| 526 | ((TextView) child.findViewById(android.R.id.title)).setText(account.name); |
Zoltan Szatmary-Ban | 7cc1b9e | 2014-10-24 18:03:18 +0100 | [diff] [blame] | 527 | contents.addView(child); |
Joe Onorato | b51886d | 2010-11-08 18:25:51 -0800 | [diff] [blame] | 528 | } |
Joe Onorato | b51886d | 2010-11-08 18:25:51 -0800 | [diff] [blame] | 529 | } |
| 530 | |
Zoltan Szatmary-Ban | 7cc1b9e | 2014-10-24 18:03:18 +0100 | [diff] [blame] | 531 | if (accountsCount > 0) { |
| 532 | accountsLabel.setVisibility(View.VISIBLE); |
| 533 | contents.setVisibility(View.VISIBLE); |
| 534 | } |
| 535 | // Checking for all other users and their profiles if any. |
| 536 | View otherUsers = mContentView.findViewById(R.id.other_users_present); |
| 537 | final boolean hasOtherUsers = (um.getUserCount() - profilesSize) > 0; |
| 538 | otherUsers.setVisibility(hasOtherUsers ? View.VISIBLE : View.GONE); |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 539 | } |
| 540 | |
| 541 | @Override |
Amith Yamasani | b14e1e0 | 2010-11-02 09:52:29 -0700 | [diff] [blame] | 542 | public View onCreateView(LayoutInflater inflater, ViewGroup container, |
| 543 | Bundle savedInstanceState) { |
Christine Franks | 1478222 | 2017-01-23 16:44:02 -0800 | [diff] [blame] | 544 | final Context context = getContext(); |
Philip P. Moltmann | e3f7211 | 2018-08-28 15:01:43 -0700 | [diff] [blame] | 545 | final EnforcedAdmin admin = RestrictedLockUtilsInternal.checkIfRestrictionEnforced(context, |
Christine Franks | 1478222 | 2017-01-23 16:44:02 -0800 | [diff] [blame] | 546 | UserManager.DISALLOW_FACTORY_RESET, UserHandle.myUserId()); |
| 547 | final UserManager um = UserManager.get(context); |
Philip P. Moltmann | e3f7211 | 2018-08-28 15:01:43 -0700 | [diff] [blame] | 548 | final boolean disallow = !um.isAdminUser() || RestrictedLockUtilsInternal |
| 549 | .hasBaseUserRestriction(context, UserManager.DISALLOW_FACTORY_RESET, |
| 550 | UserHandle.myUserId()); |
Christine Franks | a09eb38 | 2017-06-23 14:28:21 -0700 | [diff] [blame] | 551 | if (disallow && !Utils.isDemoUser(context)) { |
Julia Reynolds | 2c53933 | 2014-06-11 12:56:02 -0400 | [diff] [blame] | 552 | return inflater.inflate(R.layout.master_clear_disallowed_screen, null); |
Sudheer Shanka | 7dbbe13 | 2016-02-16 14:19:32 +0000 | [diff] [blame] | 553 | } else if (admin != null) { |
arangelov | e35badd | 2017-10-27 13:51:28 +0100 | [diff] [blame] | 554 | new ActionDisabledByAdminDialogHelper(getActivity()) |
| 555 | .prepareDialogBuilder(UserManager.DISALLOW_FACTORY_RESET, admin) |
| 556 | .setOnDismissListener(__ -> getActivity().finish()) |
| 557 | .show(); |
| 558 | return new View(getContext()); |
Julia Reynolds | 2c53933 | 2014-06-11 12:56:02 -0400 | [diff] [blame] | 559 | } |
| 560 | |
Amith Yamasani | b14e1e0 | 2010-11-02 09:52:29 -0700 | [diff] [blame] | 561 | mContentView = inflater.inflate(R.layout.master_clear, null); |
Joe Onorato | b51886d | 2010-11-08 18:25:51 -0800 | [diff] [blame] | 562 | |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 563 | establishInitialState(); |
Amith Yamasani | b14e1e0 | 2010-11-02 09:52:29 -0700 | [diff] [blame] | 564 | return mContentView; |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 565 | } |
Chris Wren | 8a963ba | 2015-03-20 10:29:14 -0400 | [diff] [blame] | 566 | |
| 567 | @Override |
Fan Zhang | 6507613 | 2016-08-08 10:25:13 -0700 | [diff] [blame] | 568 | public int getMetricsCategory() { |
Fan Zhang | 31b2100 | 2019-01-16 13:49:47 -0800 | [diff] [blame] | 569 | return SettingsEnums.MASTER_CLEAR; |
Chris Wren | 8a963ba | 2015-03-20 10:29:14 -0400 | [diff] [blame] | 570 | } |
The Android Open Source Project | afc4ab2 | 2009-03-03 19:32:34 -0800 | [diff] [blame] | 571 | } |