Home | History | Annotate | Download | only in settings 
      1 /*
      2  * Copyright (C) 2007 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 
     20 import java.util.Observable;
     21 import java.util.Observer;
     22 
     23 import android.app.Activity;
     24 import android.app.AlertDialog;
     25 import android.app.Dialog;
     26 import android.app.admin.DevicePolicyManager;
     27 import android.content.ContentQueryMap;
     28 import android.content.ContentResolver;
     29 import android.content.Context;
     30 import android.content.DialogInterface;
     31 import android.content.Intent;
     32 import android.database.Cursor;
     33 import android.location.LocationManager;
     34 import android.os.Bundle;
     35 import android.os.SystemProperties;
     36 import android.preference.CheckBoxPreference;
     37 import android.preference.ListPreference;
     38 import android.preference.Preference;
     39 import android.preference.PreferenceActivity;
     40 import android.preference.PreferenceCategory;
     41 import android.preference.PreferenceManager;
     42 import android.preference.PreferenceScreen;
     43 import android.preference.Preference.OnPreferenceChangeListener;
     44 import android.provider.Settings;
     45 import android.security.Credentials;
     46 import android.security.KeyStore;
     47 import android.telephony.TelephonyManager;
     48 import android.util.Log;
     49 import android.view.View;
     50 import android.widget.TextView;
     51 import android.widget.Toast;
     52 
     53 import com.android.internal.widget.LockPatternUtils;
     54 
     55 /**
     56  * Gesture lock pattern settings.
     57  */
     58 public class SecuritySettings extends PreferenceActivity {
     59     private static final String KEY_UNLOCK_SET_OR_CHANGE = "unlock_set_or_change";
     60 
     61     // Lock Settings
     62     private static final String PACKAGE = "com.android.settings";
     63     private static final String ICC_LOCK_SETTINGS = PACKAGE + ".IccLockSettings";
     64 
     65     private static final String KEY_LOCK_ENABLED = "lockenabled";
     66     private static final String KEY_VISIBLE_PATTERN = "visiblepattern";
     67     private static final String KEY_TACTILE_FEEDBACK_ENABLED = "unlock_tactile_feedback";
     68 
     69     // Encrypted File Systems constants
     70     private static final String PROPERTY_EFS_ENABLED = "persist.security.efs.enabled";
     71     private static final String PROPERTY_EFS_TRANSITION = "persist.security.efs.trans";
     72 
     73     private CheckBoxPreference mVisiblePattern;
     74     private CheckBoxPreference mTactileFeedback;
     75 
     76     private CheckBoxPreference mShowPassword;
     77 
     78     // Location Settings
     79     private static final String LOCATION_NETWORK = "location_network";
     80     private static final String LOCATION_GPS = "location_gps";
     81     private static final String ASSISTED_GPS = "assisted_gps";
     82     private static final int SET_OR_CHANGE_LOCK_METHOD_REQUEST = 123;
     83 
     84     // Credential storage
     85     private CredentialStorage mCredentialStorage = new CredentialStorage();
     86 
     87     // Encrypted file system
     88     private  CheckBoxPreference mEncryptedFSEnabled;
     89 
     90     private CheckBoxPreference mNetwork;
     91     private CheckBoxPreference mGps;
     92     private CheckBoxPreference mAssistedGps;
     93 
     94     DevicePolicyManager mDPM;
     95 
     96     // These provide support for receiving notification when Location Manager settings change.
     97     // This is necessary because the Network Location Provider can change settings
     98     // if the user does not confirm enabling the provider.
     99     private ContentQueryMap mContentQueryMap;
    100     private ChooseLockSettingsHelper mChooseLockSettingsHelper;
    101     private LockPatternUtils mLockPatternUtils;
    102     private final class SettingsObserver implements Observer {
    103         public void update(Observable o, Object arg) {
    104             updateToggles();
    105         }
    106     }
    107 
    108     @Override
    109     protected void onCreate(Bundle savedInstanceState) {
    110         super.onCreate(savedInstanceState);
    111 
    112         mLockPatternUtils = new LockPatternUtils(this);
    113 
    114         mDPM = (DevicePolicyManager)getSystemService(Context.DEVICE_POLICY_SERVICE);
    115 
    116         mChooseLockSettingsHelper = new ChooseLockSettingsHelper(this);
    117 
    118         createPreferenceHierarchy();
    119 
    120         updateToggles();
    121 
    122         // listen for Location Manager settings changes
    123         Cursor settingsCursor = getContentResolver().query(Settings.Secure.CONTENT_URI, null,
    124                 "(" + Settings.System.NAME + "=?)",
    125                 new String[]{Settings.Secure.LOCATION_PROVIDERS_ALLOWED},
    126                 null);
    127         mContentQueryMap = new ContentQueryMap(settingsCursor, Settings.System.NAME, true, null);
    128         mContentQueryMap.addObserver(new SettingsObserver());
    129     }
    130 
    131     private PreferenceScreen createPreferenceHierarchy() {
    132         PreferenceScreen root = this.getPreferenceScreen();
    133         if (root != null) {
    134             root.removeAll();
    135         }
    136         addPreferencesFromResource(R.xml.security_settings);
    137         root = this.getPreferenceScreen();
    138 
    139         mNetwork = (CheckBoxPreference) getPreferenceScreen().findPreference(LOCATION_NETWORK);
    140         mGps = (CheckBoxPreference) getPreferenceScreen().findPreference(LOCATION_GPS);
    141         mAssistedGps = (CheckBoxPreference) getPreferenceScreen().findPreference(ASSISTED_GPS);
    142 
    143         PreferenceManager pm = getPreferenceManager();
    144 
    145         // Lock screen
    146         if (!mLockPatternUtils.isSecure()) {
    147             addPreferencesFromResource(R.xml.security_settings_chooser);
    148         } else {
    149             switch (mLockPatternUtils.getKeyguardStoredPasswordQuality()) {
    150                 case DevicePolicyManager.PASSWORD_QUALITY_SOMETHING:
    151                     addPreferencesFromResource(R.xml.security_settings_pattern);
    152                     break;
    153                 case DevicePolicyManager.PASSWORD_QUALITY_NUMERIC:
    154                     addPreferencesFromResource(R.xml.security_settings_pin);
    155                     break;
    156                 case DevicePolicyManager.PASSWORD_QUALITY_ALPHABETIC:
    157                 case DevicePolicyManager.PASSWORD_QUALITY_ALPHANUMERIC:
    158                     addPreferencesFromResource(R.xml.security_settings_password);
    159                     break;
    160             }
    161         }
    162 
    163         // set or change current. Should be common to all unlock preference screens
    164         // mSetOrChange = (PreferenceScreen) pm.findPreference(KEY_UNLOCK_SET_OR_CHANGE);
    165 
    166         // visible pattern
    167         mVisiblePattern = (CheckBoxPreference) pm.findPreference(KEY_VISIBLE_PATTERN);
    168 
    169         // tactile feedback. Should be common to all unlock preference screens.
    170         mTactileFeedback = (CheckBoxPreference) pm.findPreference(KEY_TACTILE_FEEDBACK_ENABLED);
    171 
    172         int activePhoneType = TelephonyManager.getDefault().getPhoneType();
    173 
    174         // do not display SIM lock for CDMA phone
    175         if (TelephonyManager.PHONE_TYPE_CDMA != activePhoneType)
    176         {
    177             PreferenceScreen simLockPreferences = getPreferenceManager()
    178                     .createPreferenceScreen(this);
    179             simLockPreferences.setTitle(R.string.sim_lock_settings_category);
    180             // Intent to launch SIM lock settings
    181             simLockPreferences.setIntent(new Intent().setClassName(PACKAGE, ICC_LOCK_SETTINGS));
    182             PreferenceCategory simLockCat = new PreferenceCategory(this);
    183             simLockCat.setTitle(R.string.sim_lock_settings_title);
    184             root.addPreference(simLockCat);
    185             simLockCat.addPreference(simLockPreferences);
    186         }
    187 
    188         // Passwords
    189         PreferenceCategory passwordsCat = new PreferenceCategory(this);
    190         passwordsCat.setTitle(R.string.security_passwords_title);
    191         root.addPreference(passwordsCat);
    192 
    193         CheckBoxPreference showPassword = mShowPassword = new CheckBoxPreference(this);
    194         showPassword.setKey("show_password");
    195         showPassword.setTitle(R.string.show_password);
    196         showPassword.setSummary(R.string.show_password_summary);
    197         showPassword.setPersistent(false);
    198         passwordsCat.addPreference(showPassword);
    199 
    200         // Device policies
    201         PreferenceCategory devicePoliciesCat = new PreferenceCategory(this);
    202         devicePoliciesCat.setTitle(R.string.device_admin_title);
    203         root.addPreference(devicePoliciesCat);
    204 
    205         Preference deviceAdminButton = new Preference(this);
    206         deviceAdminButton.setTitle(R.string.manage_device_admin);
    207         deviceAdminButton.setSummary(R.string.manage_device_admin_summary);
    208         Intent deviceAdminIntent = new Intent();
    209         deviceAdminIntent.setClass(this, DeviceAdminSettings.class);
    210         deviceAdminButton.setIntent(deviceAdminIntent);
    211         devicePoliciesCat.addPreference(deviceAdminButton);
    212 
    213         // Credential storage
    214         PreferenceCategory credentialsCat = new PreferenceCategory(this);
    215         credentialsCat.setTitle(R.string.credentials_category);
    216         root.addPreference(credentialsCat);
    217         mCredentialStorage.createPreferences(credentialsCat, CredentialStorage.TYPE_KEYSTORE);
    218 
    219         // File System Encryption
    220         PreferenceCategory encryptedfsCat = new PreferenceCategory(this);
    221         encryptedfsCat.setTitle(R.string.encrypted_fs_category);
    222         //root.addPreference(encryptedfsCat);
    223         mCredentialStorage.createPreferences(encryptedfsCat, CredentialStorage.TYPE_ENCRYPTEDFS);
    224         return root;
    225     }
    226 
    227     @Override
    228     protected void onResume() {
    229         super.onResume();
    230 
    231         final LockPatternUtils lockPatternUtils = mChooseLockSettingsHelper.utils();
    232         if (mVisiblePattern != null) {
    233             mVisiblePattern.setChecked(lockPatternUtils.isVisiblePatternEnabled());
    234         }
    235         if (mTactileFeedback != null) {
    236             mTactileFeedback.setChecked(lockPatternUtils.isTactileFeedbackEnabled());
    237         }
    238 
    239         mShowPassword.setChecked(Settings.System.getInt(getContentResolver(),
    240                 Settings.System.TEXT_SHOW_PASSWORD, 1) != 0);
    241 
    242         mCredentialStorage.resume();
    243     }
    244 
    245     @Override
    246     public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen,
    247             Preference preference) {
    248         final String key = preference.getKey();
    249 
    250         final LockPatternUtils lockPatternUtils = mChooseLockSettingsHelper.utils();
    251         if (KEY_UNLOCK_SET_OR_CHANGE.equals(key)) {
    252             Intent intent = new Intent(this, ChooseLockGeneric.class);
    253             startActivityForResult(intent, SET_OR_CHANGE_LOCK_METHOD_REQUEST);
    254         } else if (KEY_LOCK_ENABLED.equals(key)) {
    255             lockPatternUtils.setLockPatternEnabled(isToggled(preference));
    256         } else if (KEY_VISIBLE_PATTERN.equals(key)) {
    257             lockPatternUtils.setVisiblePatternEnabled(isToggled(preference));
    258         } else if (KEY_TACTILE_FEEDBACK_ENABLED.equals(key)) {
    259             lockPatternUtils.setTactileFeedbackEnabled(isToggled(preference));
    260         } else if (preference == mShowPassword) {
    261             Settings.System.putInt(getContentResolver(), Settings.System.TEXT_SHOW_PASSWORD,
    262                     mShowPassword.isChecked() ? 1 : 0);
    263         } else if (preference == mNetwork) {
    264             Settings.Secure.setLocationProviderEnabled(getContentResolver(),
    265                     LocationManager.NETWORK_PROVIDER, mNetwork.isChecked());
    266         } else if (preference == mGps) {
    267             boolean enabled = mGps.isChecked();
    268             Settings.Secure.setLocationProviderEnabled(getContentResolver(),
    269                     LocationManager.GPS_PROVIDER, enabled);
    270             if (mAssistedGps != null) {
    271                 mAssistedGps.setEnabled(enabled);
    272             }
    273         } else if (preference == mAssistedGps) {
    274             Settings.Secure.putInt(getContentResolver(), Settings.Secure.ASSISTED_GPS_ENABLED,
    275                     mAssistedGps.isChecked() ? 1 : 0);
    276         }
    277 
    278         return false;
    279     }
    280 
    281     /*
    282      * Creates toggles for each available location provider
    283      */
    284     private void updateToggles() {
    285         ContentResolver res = getContentResolver();
    286         boolean gpsEnabled = Settings.Secure.isLocationProviderEnabled(
    287                 res, LocationManager.GPS_PROVIDER);
    288         mNetwork.setChecked(Settings.Secure.isLocationProviderEnabled(
    289                 res, LocationManager.NETWORK_PROVIDER));
    290         mGps.setChecked(gpsEnabled);
    291         if (mAssistedGps != null) {
    292             mAssistedGps.setChecked(Settings.Secure.getInt(res,
    293                     Settings.Secure.ASSISTED_GPS_ENABLED, 2) == 1);
    294             mAssistedGps.setEnabled(gpsEnabled);
    295         }
    296     }
    297 
    298     private boolean isToggled(Preference pref) {
    299         return ((CheckBoxPreference) pref).isChecked();
    300     }
    301 
    302     /**
    303      * @see #confirmPatternThenDisableAndClear
    304      */
    305     @Override
    306     protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    307         super.onActivityResult(requestCode, resultCode, data);
    308         createPreferenceHierarchy();
    309     }
    310 
    311     private class CredentialStorage implements DialogInterface.OnClickListener,
    312             DialogInterface.OnDismissListener, Preference.OnPreferenceChangeListener,
    313             Preference.OnPreferenceClickListener {
    314         private static final int MINIMUM_PASSWORD_LENGTH = 8;
    315 
    316         private static final int TYPE_KEYSTORE = 0;
    317         private static final int TYPE_ENCRYPTEDFS = 1;
    318 
    319         // Dialog identifiers
    320         private static final int DLG_BASE = 0;
    321         private static final int DLG_UNLOCK = DLG_BASE + 1;
    322         private static final int DLG_PASSWORD = DLG_UNLOCK + 1;
    323         private static final int DLG_RESET = DLG_PASSWORD + 1;
    324         private static final int DLG_ENABLE_EFS = DLG_RESET + 1;
    325 
    326         private KeyStore mKeyStore = KeyStore.getInstance();
    327         private int mState;
    328         private boolean mSubmit = false;
    329         private boolean mExternal = false;
    330 
    331         private boolean mWillEnableEncryptedFS;
    332         private int mShowingDialog = 0;
    333 
    334         // Key Store controls
    335         private CheckBoxPreference mAccessCheckBox;
    336         private Preference mInstallButton;
    337         private Preference mPasswordButton;
    338         private Preference mResetButton;
    339 
    340 
    341         // Encrypted file system controls
    342         private  CheckBoxPreference mEncryptedFSEnabled;
    343 
    344         void resume() {
    345             mState = mKeyStore.test();
    346             updatePreferences(mState);
    347 
    348             Intent intent = getIntent();
    349             if (!mExternal && intent != null &&
    350                     Credentials.UNLOCK_ACTION.equals(intent.getAction())) {
    351                 mExternal = true;
    352                 if (mState == KeyStore.UNINITIALIZED) {
    353                     showPasswordDialog();
    354                 } else if (mState == KeyStore.LOCKED) {
    355                     showUnlockDialog();
    356                 } else {
    357                     finish();
    358                 }
    359             }
    360         }
    361 
    362         private void initialize(String password) {
    363             mKeyStore.password(password);
    364             updatePreferences(KeyStore.NO_ERROR);
    365         }
    366 
    367         private void reset() {
    368             mKeyStore.reset();
    369             updatePreferences(KeyStore.UNINITIALIZED);
    370         }
    371 
    372         private void lock() {
    373             mKeyStore.lock();
    374             updatePreferences(KeyStore.LOCKED);
    375         }
    376 
    377         private int unlock(String password) {
    378             mKeyStore.unlock(password);
    379             return mKeyStore.getLastError();
    380         }
    381 
    382         private int changePassword(String oldPassword, String newPassword) {
    383             mKeyStore.password(oldPassword, newPassword);
    384             return mKeyStore.getLastError();
    385         }
    386 
    387         public boolean onPreferenceChange(Preference preference, Object value) {
    388             if (preference == mAccessCheckBox) {
    389                 if ((Boolean) value) {
    390                     showUnlockDialog();
    391                 } else {
    392                     lock();
    393                 }
    394                 return true;
    395             } else if (preference == mEncryptedFSEnabled) {
    396                 Boolean bval = (Boolean)value;
    397                 mWillEnableEncryptedFS = bval.booleanValue();
    398                 showSwitchEncryptedFSDialog();
    399             }
    400             return true;
    401         }
    402 
    403         public boolean onPreferenceClick(Preference preference) {
    404             if (preference == mInstallButton) {
    405                 Credentials.getInstance().installFromSdCard(SecuritySettings.this);
    406             } else if (preference == mPasswordButton) {
    407                 showPasswordDialog();
    408             } else if (preference == mResetButton) {
    409                 showResetDialog();
    410             } else {
    411                 return false;
    412             }
    413             return true;
    414         }
    415 
    416         public void onClick(DialogInterface dialog, int button) {
    417             if (mShowingDialog != DLG_ENABLE_EFS) {
    418                 mSubmit = (button == DialogInterface.BUTTON_POSITIVE);
    419                 if (button == DialogInterface.BUTTON_NEUTRAL) {
    420                     reset();
    421                 }
    422             } else {
    423                 if (button == DialogInterface.BUTTON_POSITIVE) {
    424                     Intent intent = new Intent("android.intent.action.MASTER_CLEAR");
    425                     intent.putExtra("enableEFS", mWillEnableEncryptedFS);
    426                     sendBroadcast(intent);
    427                     updatePreferences(mState);
    428                 } else if (button == DialogInterface.BUTTON_NEGATIVE) {
    429                     // Cancel action
    430                     Toast.makeText(SecuritySettings.this, R.string.encrypted_fs_cancel_confirm,
    431                             Toast.LENGTH_SHORT).show();
    432                     updatePreferences(mState);
    433                 } else {
    434                     // Unknown - should not happen
    435                     return;
    436                 }
    437             }
    438         }
    439 
    440         public void onDismiss(DialogInterface dialog) {
    441             if (mSubmit && !isFinishing()) {
    442                 mSubmit = false;
    443                 if (!checkPassword((Dialog) dialog)) {
    444                     ((Dialog) dialog).show();
    445                     return;
    446                 }
    447             }
    448             updatePreferences(mState);
    449             if (mExternal) {
    450                 finish();
    451             }
    452         }
    453 
    454         // Return true if there is no error.
    455         private boolean checkPassword(Dialog dialog) {
    456             String oldPassword = getText(dialog, R.id.old_password);
    457             String newPassword = getText(dialog, R.id.new_password);
    458             String confirmPassword = getText(dialog, R.id.confirm_password);
    459 
    460             if (oldPassword != null && oldPassword.length() == 0) {
    461                 showError(dialog, R.string.credentials_password_empty);
    462                 return false;
    463             } else if (newPassword == null) {
    464                 return !checkError(dialog, unlock(oldPassword));
    465             } else if (newPassword.length() == 0 || confirmPassword.length() == 0) {
    466                 showError(dialog, R.string.credentials_passwords_empty);
    467             } else if (newPassword.length() < MINIMUM_PASSWORD_LENGTH) {
    468                 showError(dialog, R.string.credentials_password_too_short);
    469             } else if (!newPassword.equals(confirmPassword)) {
    470                 showError(dialog, R.string.credentials_passwords_mismatch);
    471             } else if (oldPassword == null) {
    472                 initialize(newPassword);
    473                 return true;
    474             } else {
    475                 return !checkError(dialog, changePassword(oldPassword, newPassword));
    476             }
    477             return false;
    478         }
    479 
    480         // Return false if there is no error.
    481         private boolean checkError(Dialog dialog, int error) {
    482             if (error == KeyStore.NO_ERROR) {
    483                 updatePreferences(KeyStore.NO_ERROR);
    484                 return false;
    485             }
    486             if (error == KeyStore.UNINITIALIZED) {
    487                 updatePreferences(KeyStore.UNINITIALIZED);
    488                 return false;
    489             }
    490             if (error < KeyStore.WRONG_PASSWORD) {
    491                 return false;
    492             }
    493             int count = error - KeyStore.WRONG_PASSWORD + 1;
    494             if (count > 3) {
    495                 showError(dialog, R.string.credentials_wrong_password);
    496             } else if (count == 1) {
    497                 showError(dialog, R.string.credentials_reset_warning);
    498             } else {
    499                 showError(dialog, R.string.credentials_reset_warning_plural, count);
    500             }
    501             return true;
    502         }
    503 
    504         private String getText(Dialog dialog, int viewId) {
    505             TextView view = (TextView) dialog.findViewById(viewId);
    506             return (view == null || view.getVisibility() == View.GONE) ? null :
    507                             view.getText().toString();
    508         }
    509 
    510         private void showError(Dialog dialog, int stringId, Object... formatArgs) {
    511             TextView view = (TextView) dialog.findViewById(R.id.error);
    512             if (view != null) {
    513                 if (formatArgs == null || formatArgs.length == 0) {
    514                     view.setText(stringId);
    515                 } else {
    516                     view.setText(dialog.getContext().getString(stringId, formatArgs));
    517                 }
    518                 view.setVisibility(View.VISIBLE);
    519             }
    520         }
    521 
    522         private void createPreferences(PreferenceCategory category, int type) {
    523             switch(type) {
    524             case TYPE_KEYSTORE:
    525                 mAccessCheckBox = new CheckBoxPreference(SecuritySettings.this);
    526                 mAccessCheckBox.setTitle(R.string.credentials_access);
    527                 mAccessCheckBox.setSummary(R.string.credentials_access_summary);
    528                 mAccessCheckBox.setOnPreferenceChangeListener(this);
    529                 category.addPreference(mAccessCheckBox);
    530 
    531                 mInstallButton = new Preference(SecuritySettings.this);
    532                 mInstallButton.setTitle(R.string.credentials_install_certificates);
    533                 mInstallButton.setSummary(R.string.credentials_install_certificates_summary);
    534                 mInstallButton.setOnPreferenceClickListener(this);
    535                 category.addPreference(mInstallButton);
    536 
    537                 mPasswordButton = new Preference(SecuritySettings.this);
    538                 mPasswordButton.setTitle(R.string.credentials_set_password);
    539                 mPasswordButton.setSummary(R.string.credentials_set_password_summary);
    540                 mPasswordButton.setOnPreferenceClickListener(this);
    541                 category.addPreference(mPasswordButton);
    542 
    543                 mResetButton = new Preference(SecuritySettings.this);
    544                 mResetButton.setTitle(R.string.credentials_reset);
    545                 mResetButton.setSummary(R.string.credentials_reset_summary);
    546                 mResetButton.setOnPreferenceClickListener(this);
    547                 category.addPreference(mResetButton);
    548                 break;
    549 
    550             case TYPE_ENCRYPTEDFS:
    551                 mEncryptedFSEnabled = new CheckBoxPreference(SecuritySettings.this);
    552                 mEncryptedFSEnabled.setTitle(R.string.encrypted_fs_enable);
    553                 mEncryptedFSEnabled.setSummary(R.string.encrypted_fs_enable_summary);
    554                 mEncryptedFSEnabled.setOnPreferenceChangeListener(this);
    555                 // category.addPreference(mEncryptedFSEnabled);
    556                 break;
    557             }
    558         }
    559 
    560         private void updatePreferences(int state) {
    561             mAccessCheckBox.setChecked(state == KeyStore.NO_ERROR);
    562             boolean encFSEnabled = SystemProperties.getBoolean(PROPERTY_EFS_ENABLED,
    563                     false);
    564             mResetButton.setEnabled((!encFSEnabled) && (state != KeyStore.UNINITIALIZED));
    565             mAccessCheckBox.setEnabled((state != KeyStore.UNINITIALIZED) && (!encFSEnabled));
    566 
    567             // Encrypted File system preferences
    568             mEncryptedFSEnabled.setChecked(encFSEnabled);
    569 
    570             // Show a toast message if the state is changed.
    571             if (mState == state) {
    572                 return;
    573             } else if (state == KeyStore.NO_ERROR) {
    574                 Toast.makeText(SecuritySettings.this, R.string.credentials_enabled,
    575                         Toast.LENGTH_SHORT).show();
    576             } else if (state == KeyStore.UNINITIALIZED) {
    577                 Toast.makeText(SecuritySettings.this, R.string.credentials_erased,
    578                         Toast.LENGTH_SHORT).show();
    579             } else if (state == KeyStore.LOCKED) {
    580                 Toast.makeText(SecuritySettings.this, R.string.credentials_disabled,
    581                         Toast.LENGTH_SHORT).show();
    582             }
    583             mState = state;
    584         }
    585 
    586         private void showUnlockDialog() {
    587             View view = View.inflate(SecuritySettings.this,
    588                     R.layout.credentials_unlock_dialog, null);
    589 
    590             // Show extra hint only when the action comes from outside.
    591             if (mExternal) {
    592                 view.findViewById(R.id.hint).setVisibility(View.VISIBLE);
    593             }
    594 
    595             Dialog dialog = new AlertDialog.Builder(SecuritySettings.this)
    596                     .setView(view)
    597                     .setTitle(R.string.credentials_unlock)
    598                     .setPositiveButton(android.R.string.ok, this)
    599                     .setNegativeButton(android.R.string.cancel, this)
    600                     .create();
    601             dialog.setOnDismissListener(this);
    602             mShowingDialog = DLG_UNLOCK;
    603             dialog.show();
    604         }
    605 
    606         private void showPasswordDialog() {
    607             View view = View.inflate(SecuritySettings.this,
    608                     R.layout.credentials_password_dialog, null);
    609 
    610             if (mState == KeyStore.UNINITIALIZED) {
    611                 view.findViewById(R.id.hint).setVisibility(View.VISIBLE);
    612             } else {
    613                 view.findViewById(R.id.old_password_prompt).setVisibility(View.VISIBLE);
    614                 view.findViewById(R.id.old_password).setVisibility(View.VISIBLE);
    615             }
    616 
    617             Dialog dialog = new AlertDialog.Builder(SecuritySettings.this)
    618                     .setView(view)
    619                     .setTitle(R.string.credentials_set_password)
    620                     .setPositiveButton(android.R.string.ok, this)
    621                     .setNegativeButton(android.R.string.cancel, this)
    622                     .create();
    623             dialog.setOnDismissListener(this);
    624             mShowingDialog = DLG_PASSWORD;
    625             dialog.show();
    626         }
    627 
    628         private void showResetDialog() {
    629             mShowingDialog = DLG_RESET;
    630             new AlertDialog.Builder(SecuritySettings.this)
    631                     .setTitle(android.R.string.dialog_alert_title)
    632                     .setIcon(android.R.drawable.ic_dialog_alert)
    633                     .setMessage(R.string.credentials_reset_hint)
    634                     .setNeutralButton(getString(android.R.string.ok), this)
    635                     .setNegativeButton(getString(android.R.string.cancel), this)
    636                     .create().show();
    637         }
    638 
    639         private void showSwitchEncryptedFSDialog() {
    640             AlertDialog.Builder builder = new AlertDialog.Builder(SecuritySettings.this)
    641                     .setCancelable(false)
    642                     .setTitle(R.string.encrypted_fs_alert_dialog_title);
    643 
    644             mShowingDialog = DLG_ENABLE_EFS;
    645             if (mWillEnableEncryptedFS) {
    646                  builder.setMessage(R.string.encrypted_fs_enable_dialog)
    647                          .setPositiveButton(R.string.encrypted_fs_enable_button, this)
    648                          .setNegativeButton(R.string.encrypted_fs_cancel_button, this)
    649                          .create().show();
    650             } else {
    651                 builder.setMessage(R.string.encrypted_fs_disable_dialog)
    652                         .setPositiveButton(R.string.encrypted_fs_disable_button, this)
    653                         .setNegativeButton(R.string.encrypted_fs_cancel_button, this)
    654                         .create().show();
    655             }
    656         }
    657     }
    658 }
    659