src/com/android/settings/MasterClear.java

   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
  19 import android.accounts.Account;
  20 import android.accounts.AccountManager;
  21 import android.accounts.AuthenticatorDescription;
  22 import android.app.Activity;
  23 import android.content.Context;
  24 import android.content.Intent;
  25 import android.content.pm.PackageManager;
  26 import android.content.pm.UserInfo;
  27 import android.content.res.Resources;
  28 import android.graphics.drawable.Drawable;
  29 import android.os.Bundle;
  30 import android.os.Environment;
  31 import android.os.SystemProperties;
  32 import android.os.UserHandle;
  33 import android.os.UserManager;
  34 import android.util.Log;
  35 import android.view.LayoutInflater;
  36 import android.view.View;
  37 import android.view.ViewGroup;
  38 import android.widget.Button;
  39 import android.widget.CheckBox;
  40 import android.widget.ImageView;
  41 import android.widget.LinearLayout;
  42 import android.widget.TextView;
  43
  44 import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
  45 import com.android.settingslib.RestrictedLockUtils;
  46
  47 import java.util.List;
  48
  49 import static com.android.settingslib.RestrictedLockUtils.EnforcedAdmin;
  50
  51 /**
  52  * Confirm and execute a reset of the device to a clean "just out of the box"
  53  * state.  Multiple confirmations are required: first, a general "are you sure
  54  * you want to do this?" prompt, followed by a keyguard pattern trace if the user
  55  * has defined one, followed by a final strongly-worded "THIS WILL ERASE EVERYTHING
  56  * ON THE PHONE" prompt.  If at any time the phone is allowed to go to sleep, is
  57  * locked, et cetera, then the confirmation sequence is abandoned.
  58  *
  59  * This is the initial screen.
  60  */
  61 public class MasterClear extends OptionsMenuFragment {
  62     private static final String TAG = "MasterClear";
  63
  64     private static final int KEYGUARD_REQUEST = 55;
  65
  66     static final String ERASE_EXTERNAL_EXTRA = "erase_sd";
  67
  68     private View mContentView;
  69     private Button mInitiateButton;
  70     private View mExternalStorageContainer;
  71     private CheckBox mExternalStorage;
  72
  73     /**
  74      * Keyguard validation is run using the standard {@link ConfirmLockPattern}
  75      * component as a subactivity
  76      * @param request the request code to be returned once confirmation finishes
  77      * @return true if confirmation launched
  78      */
  79     private boolean runKeyguardConfirmation(int request) {
  80         Resources res = getActivity().getResources();
  81         return new ChooseLockSettingsHelper(getActivity(), this).launchConfirmationActivity(
  82                 request, res.getText(R.string.master_clear_title));
  83     }
  84
  85     @Override
  86     public void onActivityResult(int requestCode, int resultCode, Intent data) {
  87         super.onActivityResult(requestCode, resultCode, data);
  88
  89         if (requestCode != KEYGUARD_REQUEST) {
  90             return;
  91         }
  92
  93         // If the user entered a valid keyguard trace, present the final
  94         // confirmation prompt; otherwise, go back to the initial state.
  95         if (resultCode == Activity.RESULT_OK) {
  96             showFinalConfirmation();
  97         } else {
  98             establishInitialState();
  99         }
 100     }
 101
 102     private void showFinalConfirmation() {
 103         Bundle args = new Bundle();
 104         args.putBoolean(ERASE_EXTERNAL_EXTRA, mExternalStorage.isChecked());
 105         ((SettingsActivity) getActivity()).startPreferencePanel(MasterClearConfirm.class.getName(),
 106                 args, R.string.master_clear_confirm_title, null, null, 0);
 107     }
 108
 109     /**
 110      * If the user clicks to begin the reset sequence, we next require a
 111      * keyguard confirmation if the user has currently enabled one.  If there
 112      * is no keyguard available, we simply go to the final confirmation prompt.
 113      */
 114     private final Button.OnClickListener mInitiateListener = new Button.OnClickListener() {
 115
 116         public void onClick(View v) {
 117             if (!runKeyguardConfirmation(KEYGUARD_REQUEST)) {
 118                 showFinalConfirmation();
 119             }
 120         }
 121     };
 122
 123     /**
 124      * In its initial state, the activity presents a button for the user to
 125      * click in order to initiate a confirmation sequence.  This method is
 126      * called from various other points in the code to reset the activity to
 127      * this base state.
 128      *
 129      * <p>Reinflating views from resources is expensive and prevents us from
 130      * caching widget pointers, so we use a single-inflate pattern:  we lazy-
 131      * inflate each view, caching all of the widget pointers we'll need at the
 132      * time, then simply reuse the inflated views directly whenever we need
 133      * to change contents.
 134      */
 135     private void establishInitialState() {
 136         mInitiateButton = (Button) mContentView.findViewById(R.id.initiate_master_clear);
 137         mInitiateButton.setOnClickListener(mInitiateListener);
 138         mExternalStorageContainer = mContentView.findViewById(R.id.erase_external_container);
 139         mExternalStorage = (CheckBox) mContentView.findViewById(R.id.erase_external);
 140
 141         /*
 142          * If the external storage is emulated, it will be erased with a factory
 143          * reset at any rate. There is no need to have a separate option until
 144          * we have a factory reset that only erases some directories and not
 145          * others. Likewise, if it's non-removable storage, it could potentially have been
 146          * encrypted, and will also need to be wiped.
 147          */
 148         boolean isExtStorageEmulated = Environment.isExternalStorageEmulated();
 149         if (isExtStorageEmulated
 150                 || (!Environment.isExternalStorageRemovable() && isExtStorageEncrypted())) {
 151             mExternalStorageContainer.setVisibility(View.GONE);
 152
 153             final View externalOption = mContentView.findViewById(R.id.erase_external_option_text);
 154             externalOption.setVisibility(View.GONE);
 155
 156             final View externalAlsoErased = mContentView.findViewById(R.id.also_erases_external);
 157             externalAlsoErased.setVisibility(View.VISIBLE);
 158
 159             // If it's not emulated, it is on a separate partition but it means we're doing
 160             // a force wipe due to encryption.
 161             mExternalStorage.setChecked(!isExtStorageEmulated);
 162         } else {
 163             mExternalStorageContainer.setOnClickListener(new View.OnClickListener() {
 164
 165                 @Override
 166                 public void onClick(View v) {
 167                     mExternalStorage.toggle();
 168                 }
 169             });
 170         }
 171
 172         final UserManager um = (UserManager) getActivity().getSystemService(Context.USER_SERVICE);
 173         loadAccountList(um);
 174         StringBuffer contentDescription = new StringBuffer();
 175         View masterClearContainer = mContentView.findViewById(R.id.master_clear_container);
 176         getContentDescription(masterClearContainer, contentDescription);
 177         masterClearContainer.setContentDescription(contentDescription);
 178     }
 179
 180     private void getContentDescription(View v, StringBuffer description) {
 181        if (v.getVisibility() != View.VISIBLE) {
 182            return;
 183        }
 184        if (v instanceof ViewGroup) {
 185            ViewGroup vGroup = (ViewGroup) v;
 186            for (int i = 0; i < vGroup.getChildCount(); i++) {
 187                View nextChild = vGroup.getChildAt(i);
 188                getContentDescription(nextChild, description);
 189            }
 190        } else if (v instanceof TextView) {
 191            TextView vText = (TextView) v;
 192            description.append(vText.getText());
 193            description.append(","); // Allow Talkback to pause between sections.
 194        }
 195     }
 196
 197     private boolean isExtStorageEncrypted() {
 198         String state = SystemProperties.get("vold.decrypt");
 199         return !"".equals(state);
 200     }
 201
 202     private void loadAccountList(final UserManager um) {
 203         View accountsLabel = mContentView.findViewById(R.id.accounts_label);
 204         LinearLayout contents = (LinearLayout)mContentView.findViewById(R.id.accounts);
 205         contents.removeAllViews();
 206
 207         Context context = getActivity();
 208         final List<UserInfo> profiles = um.getProfiles(UserHandle.myUserId());
 209         final int profilesSize = profiles.size();
 210
 211         AccountManager mgr = AccountManager.get(context);
 212
 213         LayoutInflater inflater = (LayoutInflater)context.getSystemService(
 214                 Context.LAYOUT_INFLATER_SERVICE);
 215
 216         int accountsCount = 0;
 217         for (int profileIndex = 0; profileIndex < profilesSize; profileIndex++) {
 218             final UserInfo userInfo = profiles.get(profileIndex);
 219             final int profileId = userInfo.id;
 220             final UserHandle userHandle = new UserHandle(profileId);
 221             Account[] accounts = mgr.getAccountsAsUser(profileId);
 222             final int N = accounts.length;
 223             if (N == 0) {
 224                 continue;
 225             }
 226             accountsCount += N;
 227
 228             AuthenticatorDescription[] descs = AccountManager.get(context)
 229                     .getAuthenticatorTypesAsUser(profileId);
 230             final int M = descs.length;
 231
 232             View titleView = Utils.inflateCategoryHeader(inflater, contents);
 233             final TextView titleText = (TextView) titleView.findViewById(android.R.id.title);
 234             titleText.setText(userInfo.isManagedProfile() ? R.string.category_work
 235                     : R.string.category_personal);
 236             contents.addView(titleView);
 237
 238             for (int i = 0; i < N; i++) {
 239                 Account account = accounts[i];
 240                 AuthenticatorDescription desc = null;
 241                 for (int j = 0; j < M; j++) {
 242                     if (account.type.equals(descs[j].type)) {
 243                         desc = descs[j];
 244                         break;
 245                     }
 246                 }
 247                 if (desc == null) {
 248                     Log.w(TAG, "No descriptor for account name=" + account.name
 249                             + " type=" + account.type);
 250                     continue;
 251                 }
 252                 Drawable icon = null;
 253                 try {
 254                     if (desc.iconId != 0) {
 255                         Context authContext = context.createPackageContextAsUser(desc.packageName,
 256                                 0, userHandle);
 257                         icon = context.getPackageManager().getUserBadgedIcon(
 258                                 authContext.getDrawable(desc.iconId), userHandle);
 259                     }
 260                 } catch (PackageManager.NameNotFoundException e) {
 261                     Log.w(TAG, "Bad package name for account type " + desc.type);
 262                 } catch (Resources.NotFoundException e) {
 263                     Log.w(TAG, "Invalid icon id for account type " + desc.type, e);
 264                 }
 265                 if (icon == null) {
 266                     icon = context.getPackageManager().getDefaultActivityIcon();
 267                 }
 268
 269                 View child = inflater.inflate(R.layout.master_clear_account, contents, false);
 270                 ((ImageView) child.findViewById(android.R.id.icon)).setImageDrawable(icon);
 271                 ((TextView) child.findViewById(android.R.id.title)).setText(account.name);
 272                 contents.addView(child);
 273             }
 274         }
 275
 276         if (accountsCount > 0) {
 277             accountsLabel.setVisibility(View.VISIBLE);
 278             contents.setVisibility(View.VISIBLE);
 279         }
 280         // Checking for all other users and their profiles if any.
 281         View otherUsers = mContentView.findViewById(R.id.other_users_present);
 282         final boolean hasOtherUsers = (um.getUserCount() - profilesSize) > 0;
 283         otherUsers.setVisibility(hasOtherUsers ? View.VISIBLE : View.GONE);
 284     }
 285
 286     @Override
 287     public View onCreateView(LayoutInflater inflater, ViewGroup container,
 288             Bundle savedInstanceState) {
 289         final EnforcedAdmin admin = RestrictedLockUtils.checkIfRestrictionEnforced(
 290                 getActivity(), UserManager.DISALLOW_FACTORY_RESET, UserHandle.myUserId());
 291         final UserManager um = UserManager.get(getActivity());
 292         if (!um.isAdminUser() || RestrictedLockUtils.hasBaseUserRestriction(getActivity(),
 293                 UserManager.DISALLOW_FACTORY_RESET, UserHandle.myUserId())) {
 294             return inflater.inflate(R.layout.master_clear_disallowed_screen, null);
 295         } else if (admin != null) {
 296             View view = inflater.inflate(R.layout.admin_support_details_empty_view, null);
 297             ShowAdminSupportDetailsDialog.setAdminSupportDetails(getActivity(), view, admin, false);
 298             view.setVisibility(View.VISIBLE);
 299             return view;
 300         }
 301
 302         mContentView = inflater.inflate(R.layout.master_clear, null);
 303
 304         establishInitialState();
 305         return mContentView;
 306     }
 307
 308     @Override
 309     public int getMetricsCategory() {
 310         return MetricsEvent.MASTER_CLEAR;
 311     }
 312 }