Home | History | Annotate | Download | only in security 
      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.security;
     18 
     19 import android.app.Activity;
     20 import android.app.AlertDialog;
     21 import android.app.admin.DevicePolicyManager;
     22 import android.content.BroadcastReceiver;
     23 import android.content.Context;
     24 import android.content.Intent;
     25 import android.content.IntentFilter;
     26 import android.content.res.Resources;
     27 import android.os.BatteryManager;
     28 import android.os.Bundle;
     29 import android.os.UserHandle;
     30 import android.os.storage.StorageManager;
     31 import android.support.v7.preference.Preference;
     32 import android.text.TextUtils;
     33 import android.view.LayoutInflater;
     34 import android.view.View;
     35 import android.view.ViewGroup;
     36 import android.widget.Button;
     37 
     38 import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
     39 import com.android.settings.CryptKeeperConfirm;
     40 import com.android.settings.R;
     41 import com.android.settings.SettingsActivity;
     42 import com.android.settings.core.InstrumentedPreferenceFragment;
     43 import com.android.settings.password.ChooseLockSettingsHelper;
     44 import com.android.settings.password.ConfirmLockPattern;
     45 
     46 public class CryptKeeperSettings extends InstrumentedPreferenceFragment {
     47     private static final String TAG = "CryptKeeper";
     48     private static final String TYPE = "type";
     49     private static final String PASSWORD = "password";
     50 
     51     private static final int KEYGUARD_REQUEST = 55;
     52 
     53     // Minimum battery charge level (in percent) to launch encryption.  If the battery charge is
     54     // lower than this, encryption should not be activated.
     55     private static final int MIN_BATTERY_LEVEL = 80;
     56 
     57     private View mContentView;
     58     private Button mInitiateButton;
     59     private View mPowerWarning;
     60     private View mBatteryWarning;
     61     private IntentFilter mIntentFilter;
     62 
     63     private BroadcastReceiver mIntentReceiver = new BroadcastReceiver() {
     64         @Override
     65         public void onReceive(Context context, Intent intent) {
     66             String action = intent.getAction();
     67             if (action.equals(Intent.ACTION_BATTERY_CHANGED)) {
     68                 final int level = intent.getIntExtra(BatteryManager.EXTRA_LEVEL, 0);
     69                 final int plugged = intent.getIntExtra(BatteryManager.EXTRA_PLUGGED, 0);
     70                 final int invalidCharger = intent.getIntExtra(
     71                     BatteryManager.EXTRA_INVALID_CHARGER, 0);
     72 
     73                 final boolean levelOk = level >= MIN_BATTERY_LEVEL;
     74                 final boolean pluggedOk =
     75                     ((plugged & BatteryManager.BATTERY_PLUGGED_ANY) != 0) &&
     76                      invalidCharger == 0;
     77 
     78                 // Update UI elements based on power/battery status
     79                 mInitiateButton.setEnabled(levelOk && pluggedOk);
     80                 mPowerWarning.setVisibility(pluggedOk ? View.GONE : View.VISIBLE );
     81                 mBatteryWarning.setVisibility(levelOk ? View.GONE : View.VISIBLE);
     82             }
     83         }
     84     };
     85 
     86     /**
     87      * If the user clicks to begin the reset sequence, we next require a
     88      * keyguard confirmation if the user has currently enabled one.  If there
     89      * is no keyguard available, we prompt the user to set a password.
     90      */
     91     private Button.OnClickListener mInitiateListener = new Button.OnClickListener() {
     92         @Override
     93         public void onClick(View v) {
     94             if (!runKeyguardConfirmation(KEYGUARD_REQUEST)) {
     95                 // TODO replace (or follow) this dialog with an explicit launch into password UI
     96                 new AlertDialog.Builder(getActivity())
     97                     .setTitle(R.string.crypt_keeper_dialog_need_password_title)
     98                     .setMessage(R.string.crypt_keeper_dialog_need_password_message)
     99                     .setPositiveButton(android.R.string.ok, null)
    100                     .create()
    101                     .show();
    102             }
    103         }
    104     };
    105 
    106     @Override
    107     public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedState) {
    108         mContentView = inflater.inflate(R.layout.crypt_keeper_settings, null);
    109 
    110         mIntentFilter = new IntentFilter();
    111         mIntentFilter.addAction(Intent.ACTION_BATTERY_CHANGED);
    112 
    113         mInitiateButton = (Button) mContentView.findViewById(R.id.initiate_encrypt);
    114         mInitiateButton.setOnClickListener(mInitiateListener);
    115         mInitiateButton.setEnabled(false);
    116 
    117         mPowerWarning = mContentView.findViewById(R.id.warning_unplugged);
    118         mBatteryWarning = mContentView.findViewById(R.id.warning_low_charge);
    119 
    120         return mContentView;
    121     }
    122 
    123     @Override
    124     public int getMetricsCategory() {
    125         return MetricsEvent.CRYPT_KEEPER;
    126     }
    127 
    128     @Override
    129     public void onResume() {
    130         super.onResume();
    131         getActivity().registerReceiver(mIntentReceiver, mIntentFilter);
    132     }
    133 
    134     @Override
    135     public void onPause() {
    136         super.onPause();
    137         getActivity().unregisterReceiver(mIntentReceiver);
    138     }
    139 
    140     /**
    141      * If encryption is already started, and this launched via a "start encryption" intent,
    142      * then exit immediately - it's already up and running, so there's no point in "starting" it.
    143      */
    144     @Override
    145     public void onActivityCreated(Bundle savedInstanceState) {
    146         super.onActivityCreated(savedInstanceState);
    147         Activity activity = getActivity();
    148         Intent intent = activity.getIntent();
    149         if (DevicePolicyManager.ACTION_START_ENCRYPTION.equals(intent.getAction())) {
    150             DevicePolicyManager dpm = (DevicePolicyManager)
    151                     activity.getSystemService(Context.DEVICE_POLICY_SERVICE);
    152             if (dpm != null) {
    153                 int status = dpm.getStorageEncryptionStatus();
    154                 if (status != DevicePolicyManager.ENCRYPTION_STATUS_INACTIVE) {
    155                     // There is nothing to do here, so simply finish() (which returns to caller)
    156                     activity.finish();
    157                 }
    158             }
    159         }
    160         activity.setTitle(R.string.crypt_keeper_encrypt_title);
    161     }
    162 
    163     /**
    164      * Keyguard validation is run using the standard {@link ConfirmLockPattern}
    165      * component as a subactivity
    166      * @param request the request code to be returned once confirmation finishes
    167      * @return true if confirmation launched
    168      */
    169     private boolean runKeyguardConfirmation(int request) {
    170         Resources res = getActivity().getResources();
    171         ChooseLockSettingsHelper helper = new ChooseLockSettingsHelper(getActivity(), this);
    172 
    173         if (helper.utils().getKeyguardStoredPasswordQuality(UserHandle.myUserId())
    174                 == DevicePolicyManager.PASSWORD_QUALITY_UNSPECIFIED) {
    175             showFinalConfirmation(StorageManager.CRYPT_TYPE_DEFAULT, "");
    176             return true;
    177         }
    178 
    179         return helper.launchConfirmationActivity(request,
    180                 res.getText(R.string.crypt_keeper_encrypt_title), true);
    181     }
    182 
    183     @Override
    184     public void onActivityResult(int requestCode, int resultCode, Intent data) {
    185         super.onActivityResult(requestCode, resultCode, data);
    186 
    187         if (requestCode != KEYGUARD_REQUEST) {
    188             return;
    189         }
    190 
    191         // If the user entered a valid keyguard trace, present the final
    192         // confirmation prompt; otherwise, go back to the initial state.
    193         if (resultCode == Activity.RESULT_OK && data != null) {
    194             int type = data.getIntExtra(ChooseLockSettingsHelper.EXTRA_KEY_TYPE, -1);
    195             String password = data.getStringExtra(ChooseLockSettingsHelper.EXTRA_KEY_PASSWORD);
    196             if (!TextUtils.isEmpty(password)) {
    197                 showFinalConfirmation(type, password);
    198             }
    199         }
    200     }
    201 
    202     private void showFinalConfirmation(int type, String password) {
    203         Preference preference = new Preference(getPreferenceManager().getContext());
    204         preference.setFragment(CryptKeeperConfirm.class.getName());
    205         preference.setTitle(R.string.crypt_keeper_confirm_title);
    206         addEncryptionInfoToPreference(preference, type, password);
    207         ((SettingsActivity) getActivity()).onPreferenceStartFragment(null, preference);
    208     }
    209 
    210     private void addEncryptionInfoToPreference(Preference preference, int type, String password) {
    211         Activity activity = getActivity();
    212         DevicePolicyManager dpm = (DevicePolicyManager)
    213                 activity.getSystemService(Context.DEVICE_POLICY_SERVICE);
    214         if (dpm.getDoNotAskCredentialsOnBoot()) {
    215             preference.getExtras().putInt(TYPE, StorageManager.CRYPT_TYPE_DEFAULT);
    216             preference.getExtras().putString(PASSWORD, "");
    217         } else {
    218             preference.getExtras().putInt(TYPE, type);
    219             preference.getExtras().putString(PASSWORD, password);
    220         }
    221     }
    222 }
    223