src/com/android/settings/MasterClear.java - platform/packages/apps/Settings - Git at Google

 /*
  * 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 android.accounts.Account;
 import android.accounts.AccountManager;
 import android.accounts.AuthenticatorDescription;
 import android.app.Activity;
 import android.app.Fragment;
 import android.content.Context;
 import android.content.Intent;
 import android.content.pm.PackageManager;
 import android.content.res.Resources;
 import android.graphics.drawable.Drawable;
 import android.os.Bundle;
 import android.os.Environment;
 import android.os.SystemProperties;
 import android.os.UserManager;
 import android.preference.Preference;
 import android.preference.PreferenceActivity;
 import android.util.Log;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
 import android.widget.Button;
 import android.widget.CheckBox;
 import android.widget.LinearLayout;
 import android.widget.TextView;

 /**
  * 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 MasterClear extends Fragment {
     private static final String TAG = "MasterClear";

     private static final int KEYGUARD_REQUEST = 55;
     private static final int PIN_REQUEST = 56;

     static final String ERASE_EXTERNAL_EXTRA = "erase_sd";

     private View mContentView;
     private Button mInitiateButton;
     private View mExternalStorageContainer;
     private CheckBox mExternalStorage;
     private boolean mPinConfirmed;

     /**
      * 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();
         return new ChooseLockSettingsHelper(getActivity(), this)
                 .launchConfirmationActivity(request,
                         res.getText(R.string.master_clear_gesture_prompt),
                         res.getText(R.string.master_clear_gesture_explanation));
     }

     private boolean runRestrictionsChallenge() {
         if (UserManager.get(getActivity()).hasRestrictionsChallenge()) {
             startActivityForResult(
                     new Intent(Intent.ACTION_RESTRICTIONS_CHALLENGE), PIN_REQUEST);
             return true;
         }
         return false;
     }

     @Override
     public void onActivityResult(int requestCode, int resultCode, Intent data) {
         super.onActivityResult(requestCode, resultCode, data);

         if (requestCode == PIN_REQUEST) {
             if (resultCode == Activity.RESULT_OK) {
                 mPinConfirmed = true;
             }
             return;
         } else if (requestCode != KEYGUARD_REQUEST) {
             return;
         }

         // If the user entered a valid keyguard trace, present the final
         // confirmation prompt; otherwise, go back to the initial state.
         if (resultCode == Activity.RESULT_OK) {
             showFinalConfirmation();
         } else {
             establishInitialState();
         }
     }

     private void showFinalConfirmation() {
         Preference preference = new Preference(getActivity());
         preference.setFragment(MasterClearConfirm.class.getName());
         preference.setTitle(R.string.master_clear_confirm_title);
         preference.getExtras().putBoolean(ERASE_EXTERNAL_EXTRA, mExternalStorage.isChecked());
         ((PreferenceActivity) getActivity()).onPreferenceStartFragment(null, preference);
     }

     /**
      * 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.
      */
     private final Button.OnClickListener mInitiateListener = new Button.OnClickListener() {

         public void onClick(View v) {
             mPinConfirmed = false;
             if (runRestrictionsChallenge()) {
                 return;
             }
             if (!runKeyguardConfirmation(KEYGUARD_REQUEST)) {
                 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.
      */
     private void establishInitialState() {
         mInitiateButton = (Button) mContentView.findViewById(R.id.initiate_master_clear);
         mInitiateButton.setOnClickListener(mInitiateListener);
         mExternalStorageContainer = mContentView.findViewById(R.id.erase_external_container);
         mExternalStorage = (CheckBox) mContentView.findViewById(R.id.erase_external);

         /*
          * 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. Likewise, if it's non-removable storage, it could potentially have been
          * encrypted, and will also need to be wiped.
          */
         boolean isExtStorageEmulated = Environment.isExternalStorageEmulated();
         if (isExtStorageEmulated
                 || (!Environment.isExternalStorageRemovable() && isExtStorageEncrypted())) {
             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);

             // If it's not emulated, it is on a separate partition but it means we're doing
             // a force wipe due to encryption.
             mExternalStorage.setChecked(!isExtStorageEmulated);
         } else {
             mExternalStorageContainer.setOnClickListener(new View.OnClickListener() {

                 @Override
                 public void onClick(View v) {
                     mExternalStorage.toggle();
                 }
             });
         }

         loadAccountList();
     }

     private boolean isExtStorageEncrypted() {
         String state = SystemProperties.get("vold.decrypt");
         return !"".equals(state);
     }

     private void loadAccountList() {
         View accountsLabel = mContentView.findViewById(R.id.accounts_label);
         LinearLayout contents = (LinearLayout)mContentView.findViewById(R.id.accounts);
         contents.removeAllViews();

         Context context = getActivity();

         AccountManager mgr = AccountManager.get(context);
         Account[] accounts = mgr.getAccounts();
         final int N = accounts.length;
         if (N == 0) {
             accountsLabel.setVisibility(View.GONE);
             contents.setVisibility(View.GONE);
             return;
         }

         LayoutInflater inflater = (LayoutInflater)context.getSystemService(
                 Context.LAYOUT_INFLATER_SERVICE);

         AuthenticatorDescription[] descs = AccountManager.get(context).getAuthenticatorTypes();
         final int M = descs.length;

         for (int i=0; i<N; i++) {
             Account account = accounts[i];
             AuthenticatorDescription desc = null;
             for (int j=0; j<M; 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.createPackageContext(desc.packageName, 0);
                     icon = authContext.getResources().getDrawable(desc.iconId);
                 }
             } catch (PackageManager.NameNotFoundException e) {
                 Log.w(TAG, "No icon for account type " + desc.type);
             }

             TextView child = (TextView)inflater.inflate(R.layout.master_clear_account,
                     contents, false);
             child.setText(account.name);
             if (icon != null) {
                 child.setCompoundDrawablesWithIntrinsicBounds(icon, null, null, null);
             }
             contents.addView(child);
         }

         accountsLabel.setVisibility(View.VISIBLE);
         contents.setVisibility(View.VISIBLE);
     }

     @Override
     public View onCreateView(LayoutInflater inflater, ViewGroup container,
             Bundle savedInstanceState) {
         mContentView = inflater.inflate(R.layout.master_clear, null);

         establishInitialState();
         return mContentView;
     }

     @Override
     public void onResume() {
         super.onResume();

         // If this is the second step after restrictions pin challenge
         if (mPinConfirmed) {
             mPinConfirmed = false;
             if (!runKeyguardConfirmation(KEYGUARD_REQUEST)) {
                 showFinalConfirmation();
             }
         }
     }
 }
	/*
	* 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 android.accounts.Account;
	import android.accounts.AccountManager;
	import android.accounts.AuthenticatorDescription;
	import android.app.Activity;
	import android.app.Fragment;
	import android.content.Context;
	import android.content.Intent;
	import android.content.pm.PackageManager;
	import android.content.res.Resources;
	import android.graphics.drawable.Drawable;
	import android.os.Bundle;
	import android.os.Environment;
	import android.os.SystemProperties;
	import android.os.UserManager;
	import android.preference.Preference;
	import android.preference.PreferenceActivity;
	import android.util.Log;
	import android.view.LayoutInflater;
	import android.view.View;
	import android.view.ViewGroup;
	import android.widget.Button;
	import android.widget.CheckBox;
	import android.widget.LinearLayout;
	import android.widget.TextView;

	/**
	* 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 MasterClear extends Fragment {
	private static final String TAG = "MasterClear";

	private static final int KEYGUARD_REQUEST = 55;
	private static final int PIN_REQUEST = 56;

	static final String ERASE_EXTERNAL_EXTRA = "erase_sd";

	private View mContentView;
	private Button mInitiateButton;
	private View mExternalStorageContainer;
	private CheckBox mExternalStorage;
	private boolean mPinConfirmed;

	/**
	* 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();
	return new ChooseLockSettingsHelper(getActivity(), this)
	.launchConfirmationActivity(request,
	res.getText(R.string.master_clear_gesture_prompt),
	res.getText(R.string.master_clear_gesture_explanation));
	}

	private boolean runRestrictionsChallenge() {
	if (UserManager.get(getActivity()).hasRestrictionsChallenge()) {
	startActivityForResult(
	new Intent(Intent.ACTION_RESTRICTIONS_CHALLENGE), PIN_REQUEST);
	return true;
	}
	return false;
	}

	@Override
	public void onActivityResult(int requestCode, int resultCode, Intent data) {
	super.onActivityResult(requestCode, resultCode, data);

	if (requestCode == PIN_REQUEST) {
	if (resultCode == Activity.RESULT_OK) {
	mPinConfirmed = true;
	}
	return;
	} else if (requestCode != KEYGUARD_REQUEST) {
	return;
	}

	// If the user entered a valid keyguard trace, present the final
	// confirmation prompt; otherwise, go back to the initial state.
	if (resultCode == Activity.RESULT_OK) {
	showFinalConfirmation();
	} else {
	establishInitialState();
	}
	}

	private void showFinalConfirmation() {
	Preference preference = new Preference(getActivity());
	preference.setFragment(MasterClearConfirm.class.getName());
	preference.setTitle(R.string.master_clear_confirm_title);
	preference.getExtras().putBoolean(ERASE_EXTERNAL_EXTRA, mExternalStorage.isChecked());
	((PreferenceActivity) getActivity()).onPreferenceStartFragment(null, preference);
	}

	/**
	* 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.
	*/
	private final Button.OnClickListener mInitiateListener = new Button.OnClickListener() {

	public void onClick(View v) {
	mPinConfirmed = false;
	if (runRestrictionsChallenge()) {
	return;
	}
	if (!runKeyguardConfirmation(KEYGUARD_REQUEST)) {
	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.
	*/
	private void establishInitialState() {
	mInitiateButton = (Button) mContentView.findViewById(R.id.initiate_master_clear);
	mInitiateButton.setOnClickListener(mInitiateListener);
	mExternalStorageContainer = mContentView.findViewById(R.id.erase_external_container);
	mExternalStorage = (CheckBox) mContentView.findViewById(R.id.erase_external);

	/*
	* 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. Likewise, if it's non-removable storage, it could potentially have been
	* encrypted, and will also need to be wiped.
	*/
	boolean isExtStorageEmulated = Environment.isExternalStorageEmulated();
	if (isExtStorageEmulated
	\|\| (!Environment.isExternalStorageRemovable() && isExtStorageEncrypted())) {
	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);

	// If it's not emulated, it is on a separate partition but it means we're doing
	// a force wipe due to encryption.
	mExternalStorage.setChecked(!isExtStorageEmulated);
	} else {
	mExternalStorageContainer.setOnClickListener(new View.OnClickListener() {

	@Override
	public void onClick(View v) {
	mExternalStorage.toggle();
	}
	});
	}

	loadAccountList();
	}

	private boolean isExtStorageEncrypted() {
	String state = SystemProperties.get("vold.decrypt");
	return !"".equals(state);
	}

	private void loadAccountList() {
	View accountsLabel = mContentView.findViewById(R.id.accounts_label);
	LinearLayout contents = (LinearLayout)mContentView.findViewById(R.id.accounts);
	contents.removeAllViews();

	Context context = getActivity();

	AccountManager mgr = AccountManager.get(context);
	Account[] accounts = mgr.getAccounts();
	final int N = accounts.length;
	if (N == 0) {
	accountsLabel.setVisibility(View.GONE);
	contents.setVisibility(View.GONE);
	return;
	}

	LayoutInflater inflater = (LayoutInflater)context.getSystemService(
	Context.LAYOUT_INFLATER_SERVICE);

	AuthenticatorDescription[] descs = AccountManager.get(context).getAuthenticatorTypes();
	final int M = descs.length;

	for (int i=0; i<N; i++) {
	Account account = accounts[i];
	AuthenticatorDescription desc = null;
	for (int j=0; j<M; 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.createPackageContext(desc.packageName, 0);
	icon = authContext.getResources().getDrawable(desc.iconId);
	}
	} catch (PackageManager.NameNotFoundException e) {
	Log.w(TAG, "No icon for account type " + desc.type);
	}

	TextView child = (TextView)inflater.inflate(R.layout.master_clear_account,
	contents, false);
	child.setText(account.name);
	if (icon != null) {
	child.setCompoundDrawablesWithIntrinsicBounds(icon, null, null, null);
	}
	contents.addView(child);
	}

	accountsLabel.setVisibility(View.VISIBLE);
	contents.setVisibility(View.VISIBLE);
	}

	@Override
	public View onCreateView(LayoutInflater inflater, ViewGroup container,
	Bundle savedInstanceState) {
	mContentView = inflater.inflate(R.layout.master_clear, null);

	establishInitialState();
	return mContentView;
	}

	@Override
	public void onResume() {
	super.onResume();

	// If this is the second step after restrictions pin challenge
	if (mPinConfirmed) {
	mPinConfirmed = false;
	if (!runKeyguardConfirmation(KEYGUARD_REQUEST)) {
	showFinalConfirmation();
	}
	}
	}
	}