| /* | |
| * Copyright (C) 2008 The Android Open Source Project | |
| * | |
| * Licensed under the Apache License, Version 2.0 (the "License"); | |
| * you may not use this file except in compliance with the License. | |
| * You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, software | |
| * distributed under the License is distributed on an "AS IS" BASIS, | |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| * See the License for the specific language governing permissions and | |
| * limitations under the License. | |
| */ | |
| package com.android.settings; | |
| import static android.app.admin.DevicePolicyResources.Strings.Settings.PERSONAL_CATEGORY_HEADER; | |
| import static android.app.admin.DevicePolicyResources.Strings.Settings.PRIVATE_CATEGORY_HEADER; | |
| import static android.app.admin.DevicePolicyResources.Strings.Settings.WORK_CATEGORY_HEADER; | |
| import static com.android.settingslib.RestrictedLockUtils.EnforcedAdmin; | |
| import android.accounts.Account; | |
| import android.accounts.AccountManager; | |
| import android.accounts.AuthenticatorDescription; | |
| import android.app.ActionBar; | |
| import android.app.Activity; | |
| import android.app.AlertDialog; | |
| import android.app.admin.DevicePolicyManager; | |
| import android.app.settings.SettingsEnums; | |
| import android.content.ComponentName; | |
| import android.content.ContentResolver; | |
| import android.content.Context; | |
| import android.content.DialogInterface; | |
| import android.content.Intent; | |
| import android.content.pm.PackageManager; | |
| import android.content.pm.ResolveInfo; | |
| import android.content.pm.UserInfo; | |
| import android.content.res.Resources; | |
| import android.graphics.Color; | |
| import android.graphics.drawable.Drawable; | |
| import android.os.Bundle; | |
| import android.os.Environment; | |
| import android.os.SystemProperties; | |
| import android.os.UserHandle; | |
| import android.os.UserManager; | |
| import android.os.image.DynamicSystemManager; | |
| import android.provider.Settings; | |
| import android.telephony.euicc.EuiccManager; | |
| import android.text.TextUtils; | |
| import android.util.Log; | |
| import android.view.LayoutInflater; | |
| import android.view.View; | |
| import android.view.View.OnScrollChangeListener; | |
| import android.view.ViewGroup; | |
| import android.view.ViewTreeObserver.OnGlobalLayoutListener; | |
| import android.widget.Button; | |
| import android.widget.CheckBox; | |
| import android.widget.ImageView; | |
| import android.widget.LinearLayout; | |
| import android.widget.ScrollView; | |
| import android.widget.TextView; | |
| import androidx.annotation.VisibleForTesting; | |
| import com.android.settings.biometrics.IdentityCheckBiometricErrorDialog; | |
| import com.android.settings.core.InstrumentedFragment; | |
| import com.android.settings.enterprise.ActionDisabledByAdminDialogHelper; | |
| import com.android.settings.flags.Flags; | |
| import com.android.settings.network.SubscriptionUtil; | |
| import com.android.settings.password.ChooseLockSettingsHelper; | |
| import com.android.settings.password.ConfirmDeviceCredentialActivity; | |
| import com.android.settings.password.ConfirmLockPattern; | |
| import com.android.settingslib.RestrictedLockUtilsInternal; | |
| import com.android.settingslib.core.instrumentation.MetricsFeatureProvider; | |
| import com.android.settingslib.development.DevelopmentSettingsEnabler; | |
| import com.google.android.setupcompat.template.FooterBarMixin; | |
| import com.google.android.setupcompat.template.FooterButton; | |
| import com.google.android.setupcompat.template.FooterButton.ButtonType; | |
| import com.google.android.setupdesign.GlifLayout; | |
| import com.google.android.setupdesign.util.ThemeHelper; | |
| import java.util.List; | |
| /** | |
| * Confirm and execute a reset of the device to a clean "just out of the box" | |
| * state. Multiple confirmations are required: first, a general "are you sure | |
| * you want to do this?" prompt, followed by a keyguard pattern trace if the user | |
| * has defined one, followed by a final strongly-worded "THIS WILL ERASE EVERYTHING | |
| * ON THE PHONE" prompt. If at any time the phone is allowed to go to sleep, is | |
| * locked, et cetera, then the confirmation sequence is abandoned. | |
| * | |
| * This is the initial screen. | |
| */ | |
| public class MainClear extends InstrumentedFragment implements OnGlobalLayoutListener { | |
| private static final String TAG = "MainClear"; | |
| @VisibleForTesting | |
| static final int KEYGUARD_REQUEST = 55; | |
| @VisibleForTesting | |
| static final int CREDENTIAL_CONFIRM_REQUEST = 56; | |
| static final int BIOMETRICS_REQUEST = 57; | |
| private static final String KEY_SHOW_ESIM_RESET_CHECKBOX = | |
| "masterclear.allow_retain_esim_profiles_after_fdr"; | |
| static final String ERASE_EXTERNAL_EXTRA = "erase_sd"; | |
| static final String ERASE_ESIMS_EXTRA = "erase_esim"; | |
| private View mContentView; | |
| @VisibleForTesting | |
| FooterButton mInitiateButton; | |
| private View mExternalStorageContainer; | |
| @VisibleForTesting | |
| CheckBox mExternalStorage; | |
| @VisibleForTesting | |
| View mEsimStorageContainer; | |
| @VisibleForTesting | |
| CheckBox mEsimStorage; | |
| @VisibleForTesting | |
| ScrollView mScrollView; | |
| @Override | |
| public void onGlobalLayout() { | |
| mInitiateButton.setEnabled(hasReachedBottom(mScrollView)); | |
| } | |
| private void setUpActionBarAndTitle() { | |
| final Activity activity = getActivity(); | |
| if (activity == null) { | |
| Log.e(TAG, "No activity attached, skipping setUpActionBarAndTitle"); | |
| return; | |
| } | |
| final ActionBar actionBar = activity.getActionBar(); | |
| if (actionBar == null) { | |
| Log.e(TAG, "No actionbar, skipping setUpActionBarAndTitle"); | |
| return; | |
| } | |
| actionBar.hide(); | |
| activity.getWindow().setStatusBarColor(Color.TRANSPARENT); | |
| } | |
| /** | |
| * Keyguard validation is run using the standard {@link ConfirmLockPattern} | |
| * component as a subactivity | |
| * | |
| * @param request the request code to be returned once confirmation finishes | |
| * @return true if confirmation launched | |
| */ | |
| private boolean runKeyguardConfirmation(int request) { | |
| Resources res = getActivity().getResources(); | |
| final ChooseLockSettingsHelper.Builder builder = | |
| new ChooseLockSettingsHelper.Builder(getActivity(), this); | |
| return builder.setRequestCode(request) | |
| .setTitle(res.getText(R.string.main_clear_short_title)) | |
| .show(); | |
| } | |
| @VisibleForTesting | |
| boolean isValidRequestCode(int requestCode) { | |
| return !((requestCode != KEYGUARD_REQUEST) && (requestCode != CREDENTIAL_CONFIRM_REQUEST) | |
| && (requestCode != BIOMETRICS_REQUEST)); | |
| } | |
| @Override | |
| public void onActivityResult(int requestCode, int resultCode, Intent data) { | |
| super.onActivityResult(requestCode, resultCode, data); | |
| onActivityResultInternal(requestCode, resultCode, data); | |
| } | |
| /* | |
| * Internal method that allows easy testing without dealing with super references. | |
| */ | |
| @VisibleForTesting | |
| void onActivityResultInternal(int requestCode, int resultCode, Intent data) { | |
| if (!isValidRequestCode(requestCode)) { | |
| return; | |
| } | |
| if (resultCode != Activity.RESULT_OK) { | |
| establishInitialState(); | |
| if (requestCode == BIOMETRICS_REQUEST) { | |
| if (resultCode == ConfirmDeviceCredentialActivity.BIOMETRIC_LOCKOUT_ERROR_RESULT) { | |
| IdentityCheckBiometricErrorDialog.showBiometricErrorDialog(getActivity(), | |
| Utils.BiometricStatus.LOCKOUT, true /* twoFactorAuthentication */); | |
| } | |
| } | |
| return; | |
| } | |
| if (requestCode == KEYGUARD_REQUEST) { | |
| final int userId = getActivity().getUserId(); | |
| final Utils.BiometricStatus biometricAuthStatus = | |
| Utils.requestBiometricAuthenticationForMandatoryBiometrics(getActivity(), | |
| false /* biometricsAuthenticationRequested */, | |
| userId); | |
| if (biometricAuthStatus == Utils.BiometricStatus.OK) { | |
| Utils.launchBiometricPromptForMandatoryBiometrics(this, BIOMETRICS_REQUEST, | |
| userId, false /* hideBackground */); | |
| return; | |
| } else if (biometricAuthStatus != Utils.BiometricStatus.NOT_ACTIVE) { | |
| IdentityCheckBiometricErrorDialog.showBiometricErrorDialog(getActivity(), | |
| biometricAuthStatus, true /* twoFactorAuthentication */); | |
| return; | |
| } | |
| } | |
| Intent intent = null; | |
| // If returning from a Keyguard request, try to show an account confirmation request if | |
| // applicable. | |
| if (CREDENTIAL_CONFIRM_REQUEST != requestCode | |
| && (intent = getAccountConfirmationIntent()) != null) { | |
| showAccountCredentialConfirmation(intent); | |
| } else { | |
| showFinalConfirmation(); | |
| } | |
| } | |
| @VisibleForTesting | |
| void showFinalConfirmation() { | |
| final Bundle args = new Bundle(); | |
| args.putBoolean(ERASE_EXTERNAL_EXTRA, mExternalStorage.isChecked()); | |
| args.putBoolean(ERASE_ESIMS_EXTRA, mEsimStorage.isChecked()); | |
| final Intent intent = new Intent(); | |
| intent.setClass(getContext(), | |
| com.android.settings.Settings.FactoryResetConfirmActivity.class); | |
| intent.putExtra(SettingsActivity.EXTRA_SHOW_FRAGMENT, MainClearConfirm.class.getName()); | |
| intent.putExtra(SettingsActivity.EXTRA_SHOW_FRAGMENT_ARGUMENTS, args); | |
| intent.putExtra(SettingsActivity.EXTRA_SHOW_FRAGMENT_TITLE_RESID, | |
| R.string.main_clear_confirm_title); | |
| intent.putExtra(MetricsFeatureProvider.EXTRA_SOURCE_METRICS_CATEGORY, getMetricsCategory()); | |
| getContext().startActivity(intent); | |
| } | |
| @VisibleForTesting | |
| void showAccountCredentialConfirmation(Intent intent) { | |
| startActivityForResult(intent, CREDENTIAL_CONFIRM_REQUEST); | |
| } | |
| @VisibleForTesting | |
| Intent getAccountConfirmationIntent() { | |
| final Context context = getActivity(); | |
| final String accountType = context.getString(R.string.account_type); | |
| final String packageName = context.getString(R.string.account_confirmation_package); | |
| final String className = context.getString(R.string.account_confirmation_class); | |
| if (TextUtils.isEmpty(accountType) | |
| || TextUtils.isEmpty(packageName) | |
| || TextUtils.isEmpty(className)) { | |
| Log.i(TAG, "Resources not set for account confirmation."); | |
| return null; | |
| } | |
| final AccountManager am = AccountManager.get(context); | |
| Account[] accounts = am.getAccountsByType(accountType); | |
| if (accounts != null && accounts.length > 0) { | |
| final Intent requestAccountConfirmation = new Intent() | |
| .setPackage(packageName) | |
| .setComponent(new ComponentName(packageName, className)); | |
| // Check to make sure that the intent is supported. | |
| final PackageManager pm = context.getPackageManager(); | |
| final ResolveInfo resolution = pm.resolveActivity(requestAccountConfirmation, 0); | |
| if (resolution != null | |
| && resolution.activityInfo != null | |
| && packageName.equals(resolution.activityInfo.packageName)) { | |
| // Note that we need to check the packagename to make sure that an Activity resolver | |
| // wasn't returned. | |
| return requestAccountConfirmation; | |
| } else { | |
| Log.i(TAG, "Unable to resolve Activity: " + packageName + "/" + className); | |
| } | |
| } else { | |
| Log.d(TAG, "No " + accountType + " accounts installed!"); | |
| } | |
| return null; | |
| } | |
| /** | |
| * If the user clicks to begin the reset sequence, we next require a | |
| * keyguard confirmation if the user has currently enabled one. If there | |
| * is no keyguard available, we simply go to the final confirmation prompt. | |
| * | |
| * If the user is in demo mode, route to the demo mode app for confirmation. | |
| */ | |
| @VisibleForTesting | |
| protected final Button.OnClickListener mInitiateListener = new Button.OnClickListener() { | |
| public void onClick(View view) { | |
| final Context context = view.getContext(); | |
| if (Utils.isDemoUser(context)) { | |
| final ComponentName componentName = Utils.getDeviceOwnerComponent(context); | |
| if (componentName != null) { | |
| final Intent requestFactoryReset = new Intent() | |
| .setPackage(componentName.getPackageName()) | |
| .setAction(Intent.ACTION_FACTORY_RESET); | |
| context.startActivity(requestFactoryReset); | |
| } | |
| return; | |
| } | |
| final DynamicSystemManager dsuManager = (DynamicSystemManager) | |
| getActivity().getSystemService(Context.DYNAMIC_SYSTEM_SERVICE); | |
| if (dsuManager.isInUse()) { | |
| AlertDialog.Builder builder = new AlertDialog.Builder(getActivity()); | |
| builder.setTitle(R.string.dsu_is_running); | |
| builder.setPositiveButton(R.string.okay, new DialogInterface.OnClickListener() { | |
| public void onClick(DialogInterface dialog, int id) {} | |
| }); | |
| AlertDialog dsuAlertdialog = builder.create(); | |
| dsuAlertdialog.show(); | |
| return; | |
| } | |
| if (runKeyguardConfirmation(KEYGUARD_REQUEST)) { | |
| return; | |
| } | |
| Intent intent = getAccountConfirmationIntent(); | |
| if (intent != null) { | |
| showAccountCredentialConfirmation(intent); | |
| } else { | |
| showFinalConfirmation(); | |
| } | |
| } | |
| }; | |
| /** | |
| * In its initial state, the activity presents a button for the user to | |
| * click in order to initiate a confirmation sequence. This method is | |
| * called from various other points in the code to reset the activity to | |
| * this base state. | |
| * | |
| * <p>Reinflating views from resources is expensive and prevents us from | |
| * caching widget pointers, so we use a single-inflate pattern: we lazy- | |
| * inflate each view, caching all of the widget pointers we'll need at the | |
| * time, then simply reuse the inflated views directly whenever we need | |
| * to change contents. | |
| */ | |
| @VisibleForTesting | |
| void establishInitialState() { | |
| setUpActionBarAndTitle(); | |
| setUpInitiateButton(); | |
| mExternalStorageContainer = mContentView.findViewById(R.id.erase_external_container); | |
| mExternalStorage = mContentView.findViewById(R.id.erase_external); | |
| mEsimStorageContainer = mContentView.findViewById(R.id.erase_esim_container); | |
| mEsimStorage = mContentView.findViewById(R.id.erase_esim); | |
| if (mScrollView != null) { | |
| mScrollView.getViewTreeObserver().removeOnGlobalLayoutListener(this); | |
| } | |
| mScrollView = mContentView.findViewById(R.id.main_clear_scrollview); | |
| /* | |
| * If the external storage is emulated, it will be erased with a factory | |
| * reset at any rate. There is no need to have a separate option until | |
| * we have a factory reset that only erases some directories and not | |
| * others. | |
| */ | |
| if (Environment.isExternalStorageEmulated()) { | |
| mExternalStorageContainer.setVisibility(View.GONE); | |
| final View externalOption = mContentView.findViewById(R.id.erase_external_option_text); | |
| externalOption.setVisibility(View.GONE); | |
| final View externalAlsoErased = mContentView.findViewById(R.id.also_erases_external); | |
| externalAlsoErased.setVisibility(View.VISIBLE); | |
| mExternalStorage.setChecked(false); | |
| } else { | |
| mExternalStorageContainer.setOnClickListener(new View.OnClickListener() { | |
| @Override | |
| public void onClick(View v) { | |
| mExternalStorage.toggle(); | |
| } | |
| }); | |
| } | |
| if (showWipeEuicc()) { | |
| if (showWipeEuiccCheckbox()) { | |
| mEsimStorageContainer.setVisibility(View.VISIBLE); | |
| mEsimStorageContainer.setOnClickListener(new View.OnClickListener() { | |
| @Override | |
| public void onClick(View v) { | |
| mEsimStorage.toggle(); | |
| } | |
| }); | |
| } else { | |
| final View esimAlsoErased = mContentView.findViewById(R.id.also_erases_esim); | |
| esimAlsoErased.setVisibility(View.VISIBLE); | |
| final View noCancelMobilePlan = mContentView.findViewById( | |
| R.id.no_cancel_mobile_plan); | |
| noCancelMobilePlan.setVisibility(View.VISIBLE); | |
| mEsimStorage.setChecked(true /* checked */); | |
| } | |
| } else { | |
| mEsimStorage.setChecked(false /* checked */); | |
| } | |
| final UserManager um = (UserManager) getActivity().getSystemService(Context.USER_SERVICE); | |
| loadAccountList(um); | |
| final StringBuffer contentDescription = new StringBuffer(); | |
| final View mainClearContainer = mContentView.findViewById(R.id.main_clear_container); | |
| getContentDescription(mainClearContainer, contentDescription); | |
| mainClearContainer.setContentDescription(contentDescription); | |
| // Set the status of initiateButton based on scrollview | |
| mScrollView.setOnScrollChangeListener(new OnScrollChangeListener() { | |
| @Override | |
| public void onScrollChange(View v, int scrollX, int scrollY, int oldScrollX, | |
| int oldScrollY) { | |
| if (v instanceof ScrollView && hasReachedBottom((ScrollView) v)) { | |
| mInitiateButton.setEnabled(true); | |
| mScrollView.setOnScrollChangeListener(null); | |
| } | |
| } | |
| }); | |
| // Set the initial state of the initiateButton | |
| mScrollView.getViewTreeObserver().addOnGlobalLayoutListener(this); | |
| } | |
| /** | |
| * Whether to show any UI which is SIM related. | |
| */ | |
| @VisibleForTesting | |
| boolean showAnySubscriptionInfo(Context context) { | |
| return (context != null) && SubscriptionUtil.isSimHardwareVisible(context); | |
| } | |
| /** | |
| * Whether to show strings indicating that the eUICC will be wiped. | |
| * | |
| * <p>We show the strings on any device which supports eUICC as long as the eUICC was ever | |
| * provisioned (that is, at least one profile was ever downloaded onto it). | |
| */ | |
| @VisibleForTesting | |
| boolean showWipeEuicc() { | |
| Context context = getContext(); | |
| if (!showAnySubscriptionInfo(context) || !isEuiccEnabled(context)) { | |
| return false; | |
| } | |
| ContentResolver cr = context.getContentResolver(); | |
| return Settings.Global.getInt(cr, Settings.Global.EUICC_PROVISIONED, 0) != 0 | |
| || DevelopmentSettingsEnabler.isDevelopmentSettingsEnabled(context); | |
| } | |
| @VisibleForTesting | |
| boolean showWipeEuiccCheckbox() { | |
| return SystemProperties | |
| .getBoolean(KEY_SHOW_ESIM_RESET_CHECKBOX, false /* def */); | |
| } | |
| @VisibleForTesting | |
| protected boolean isEuiccEnabled(Context context) { | |
| EuiccManager euiccManager = (EuiccManager) context.getSystemService(Context.EUICC_SERVICE); | |
| return euiccManager != null && euiccManager.isEnabled(); | |
| } | |
| @VisibleForTesting | |
| boolean hasReachedBottom(final ScrollView scrollView) { | |
| if (scrollView.getChildCount() < 1) { | |
| return true; | |
| } | |
| final View view = scrollView.getChildAt(0); | |
| final int diff = view.getBottom() - (scrollView.getHeight() + scrollView.getScrollY()); | |
| return diff <= 0; | |
| } | |
| private void setUpInitiateButton() { | |
| if (mInitiateButton != null) { | |
| return; | |
| } | |
| final GlifLayout layout = mContentView.findViewById(R.id.setup_wizard_layout); | |
| final FooterBarMixin mixin = layout.getMixin(FooterBarMixin.class); | |
| final Activity activity = getActivity(); | |
| mixin.setPrimaryButton( | |
| new FooterButton.Builder(activity) | |
| .setText(R.string.main_clear_button_text) | |
| .setListener(mInitiateListener) | |
| .setButtonType(ButtonType.OTHER) | |
| .build()); | |
| if (Flags.showFactoryResetCancelButton()) { | |
| mixin.setSecondaryButton( | |
| new FooterButton.Builder(activity) | |
| .setText(android.R.string.cancel) | |
| .setListener(view -> activity.onBackPressed()) | |
| .setButtonType(ButtonType.CANCEL) | |
| .build()); | |
| } | |
| mInitiateButton = mixin.getPrimaryButton(); | |
| } | |
| private void getContentDescription(View v, StringBuffer description) { | |
| if (v.getVisibility() != View.VISIBLE) { | |
| return; | |
| } | |
| if (v instanceof ViewGroup) { | |
| ViewGroup vGroup = (ViewGroup) v; | |
| for (int i = 0; i < vGroup.getChildCount(); i++) { | |
| View nextChild = vGroup.getChildAt(i); | |
| getContentDescription(nextChild, description); | |
| } | |
| } else if (v instanceof TextView) { | |
| TextView vText = (TextView) v; | |
| description.append(vText.getText()); | |
| description.append(","); // Allow Talkback to pause between sections. | |
| } | |
| } | |
| private void loadAccountList(final UserManager um) { | |
| View accountsLabel = mContentView.findViewById(R.id.accounts_label); | |
| LinearLayout contents = (LinearLayout) mContentView.findViewById(R.id.accounts); | |
| contents.removeAllViews(); | |
| Context context = getActivity(); | |
| final List<UserInfo> profiles = um.getProfiles(UserHandle.myUserId()); | |
| final int profilesSize = profiles.size(); | |
| AccountManager mgr = AccountManager.get(context); | |
| LayoutInflater inflater = (LayoutInflater) context.getSystemService( | |
| Context.LAYOUT_INFLATER_SERVICE); | |
| int accountsCount = 0; | |
| for (int profileIndex = 0; profileIndex < profilesSize; profileIndex++) { | |
| final UserInfo userInfo = profiles.get(profileIndex); | |
| final int profileId = userInfo.id; | |
| final UserHandle userHandle = new UserHandle(profileId); | |
| if (Utils.shouldHideUser(userHandle, um)) { | |
| continue; | |
| } | |
| Account[] accounts = mgr.getAccountsAsUser(profileId); | |
| final int accountLength = accounts.length; | |
| if (accountLength == 0) { | |
| continue; | |
| } | |
| accountsCount += accountLength; | |
| AuthenticatorDescription[] descs = AccountManager.get(context) | |
| .getAuthenticatorTypesAsUser(profileId); | |
| final int descLength = descs.length; | |
| if (profilesSize > 1) { | |
| View titleView = Utils.inflateCategoryHeader(inflater, contents); | |
| titleView.setPadding(0 /* left */, titleView.getPaddingTop(), | |
| 0 /* right */, titleView.getPaddingBottom()); | |
| final TextView titleText = (TextView) titleView.findViewById(android.R.id.title); | |
| DevicePolicyManager devicePolicyManager = | |
| context.getSystemService(DevicePolicyManager.class); | |
| if (userInfo.isManagedProfile()) { | |
| titleText.setText(devicePolicyManager.getResources().getString( | |
| WORK_CATEGORY_HEADER, () -> getString( | |
| com.android.settingslib.R.string.category_work))); | |
| } else if (android.os.Flags.allowPrivateProfile() | |
| && android.multiuser.Flags.enablePrivateSpaceFeatures() | |
| && android.multiuser.Flags.handleInterleavedSettingsForPrivateSpace() | |
| && userInfo.isPrivateProfile()) { | |
| titleText.setText(devicePolicyManager.getResources().getString( | |
| PRIVATE_CATEGORY_HEADER, () -> getString( | |
| com.android.settingslib.R.string.category_private))); | |
| } else { | |
| titleText.setText(devicePolicyManager.getResources().getString( | |
| PERSONAL_CATEGORY_HEADER, () -> getString( | |
| com.android.settingslib.R.string.category_personal))); | |
| } | |
| contents.addView(titleView); | |
| } | |
| for (int i = 0; i < accountLength; i++) { | |
| Account account = accounts[i]; | |
| AuthenticatorDescription desc = null; | |
| for (int j = 0; j < descLength; j++) { | |
| if (account.type.equals(descs[j].type)) { | |
| desc = descs[j]; | |
| break; | |
| } | |
| } | |
| if (desc == null) { | |
| Log.w(TAG, "No descriptor for account name=" + account.name | |
| + " type=" + account.type); | |
| continue; | |
| } | |
| Drawable icon = null; | |
| try { | |
| if (desc.iconId != 0) { | |
| Context authContext = context.createPackageContextAsUser(desc.packageName, | |
| 0, userHandle); | |
| icon = context.getPackageManager().getUserBadgedIcon( | |
| authContext.getDrawable(desc.iconId), userHandle); | |
| } | |
| } catch (PackageManager.NameNotFoundException e) { | |
| Log.w(TAG, "Bad package name for account type " + desc.type); | |
| } catch (Resources.NotFoundException e) { | |
| Log.w(TAG, "Invalid icon id for account type " + desc.type, e); | |
| } | |
| if (icon == null) { | |
| icon = context.getPackageManager().getDefaultActivityIcon(); | |
| } | |
| View child = inflater.inflate(R.layout.main_clear_account, contents, false); | |
| ((ImageView) child.findViewById(android.R.id.icon)).setImageDrawable(icon); | |
| ((TextView) child.findViewById(android.R.id.title)).setText(account.name); | |
| contents.addView(child); | |
| } | |
| } | |
| if (accountsCount > 0) { | |
| accountsLabel.setVisibility(View.VISIBLE); | |
| contents.setVisibility(View.VISIBLE); | |
| } | |
| // Checking for all other users and their profiles if any. | |
| View otherUsers = mContentView.findViewById(R.id.other_users_present); | |
| final boolean hasOtherUsers = (um.getUserCount() - profilesSize) > 0; | |
| otherUsers.setVisibility(hasOtherUsers ? View.VISIBLE : View.GONE); | |
| } | |
| @Override | |
| public View onCreateView(LayoutInflater inflater, ViewGroup container, | |
| Bundle savedInstanceState) { | |
| final Context context = getContext(); | |
| ThemeHelper.trySetSuwTheme(context); | |
| final EnforcedAdmin admin = RestrictedLockUtilsInternal.checkIfRestrictionEnforced(context, | |
| UserManager.DISALLOW_FACTORY_RESET, UserHandle.myUserId()); | |
| final UserManager um = UserManager.get(context); | |
| final boolean disallow = !um.isAdminUser() || RestrictedLockUtilsInternal | |
| .hasBaseUserRestriction(context, UserManager.DISALLOW_FACTORY_RESET, | |
| UserHandle.myUserId()); | |
| if (disallow && !Utils.isDemoUser(context)) { | |
| return inflater.inflate(R.layout.main_clear_disallowed_screen, null); | |
| } else if (admin != null && !Utils.isDemoUser(context)) { | |
| new ActionDisabledByAdminDialogHelper(getActivity()) | |
| .prepareDialogBuilder(UserManager.DISALLOW_FACTORY_RESET, admin) | |
| .setOnDismissListener(__ -> getActivity().finish()) | |
| .show(); | |
| return new View(getContext()); | |
| } | |
| mContentView = inflater.inflate(R.layout.main_clear, null); | |
| establishInitialState(); | |
| return mContentView; | |
| } | |
| @Override | |
| public int getMetricsCategory() { | |
| return SettingsEnums.MASTER_CLEAR; | |
| } | |
| } |