src/com/android/settings/CryptKeeper.java

   1 /*
   2  * Copyright (C) 2011 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.app.Activity;
  20 import android.app.StatusBarManager;
  21 import android.content.ComponentName;
  22 import android.content.Context;
  23 import android.content.Intent;
  24 import android.content.pm.ActivityInfo;
  25 import android.content.pm.PackageManager;
  26 import android.content.res.Resources.NotFoundException;
  27 import android.media.AudioManager;
  28 import android.os.AsyncTask;
  29 import android.os.Bundle;
  30 import android.os.Handler;
  31 import android.os.IBinder;
  32 import android.os.Message;
  33 import android.os.PowerManager;
  34 import android.os.RemoteException;
  35 import android.os.ServiceManager;
  36 import android.os.SystemProperties;
  37 import android.os.UserHandle;
  38 import android.os.storage.IStorageManager;
  39 import android.os.storage.StorageManager;
  40 import android.provider.Settings;
  41 import android.telecom.TelecomManager;
  42 import android.telephony.TelephonyManager;
  43 import android.text.Editable;
  44 import android.text.TextUtils;
  45 import android.text.TextWatcher;
  46 import android.text.format.DateUtils;
  47 import android.util.Log;
  48 import android.view.KeyEvent;
  49 import android.view.MotionEvent;
  50 import android.view.View;
  51 import android.view.View.OnClickListener;
  52 import android.view.View.OnKeyListener;
  53 import android.view.View.OnTouchListener;
  54 import android.view.WindowManager;
  55 import android.view.inputmethod.EditorInfo;
  56 import android.view.inputmethod.InputMethodInfo;
  57 import android.view.inputmethod.InputMethodManager;
  58 import android.view.inputmethod.InputMethodSubtype;
  59 import android.widget.Button;
  60 import android.widget.ProgressBar;
  61 import android.widget.TextView;
  62
  63 import com.android.internal.telephony.PhoneConstants;
  64 import com.android.internal.widget.LockPatternUtils;
  65 import com.android.internal.widget.LockPatternView;
  66 import com.android.internal.widget.LockPatternView.Cell;
  67 import com.android.internal.widget.LockPatternView.DisplayMode;
  68 import com.android.settings.widget.ImeAwareEditText;
  69
  70 import java.util.List;
  71
  72 /**
  73  * Settings screens to show the UI flows for encrypting/decrypting the device.
  74  *
  75  * This may be started via adb for debugging the UI layout, without having to go through
  76  * encryption flows everytime. It should be noted that starting the activity in this manner
  77  * is only useful for verifying UI-correctness - the behavior will not be identical.
  78  * <pre>
  79  * $ adb shell pm enable com.android.settings/.CryptKeeper
  80  * $ adb shell am start \
  81  *     -e "com.android.settings.CryptKeeper.DEBUG_FORCE_VIEW" "progress" \
  82  *     -n com.android.settings/.CryptKeeper
  83  * </pre>
  84  */
  85 public class CryptKeeper extends Activity implements TextView.OnEditorActionListener,
  86         OnKeyListener, OnTouchListener, TextWatcher {
  87     private static final String TAG = "CryptKeeper";
  88
  89     private static final String DECRYPT_STATE = "trigger_restart_framework";
  90
  91     /** Message sent to us to indicate encryption update progress. */
  92     private static final int MESSAGE_UPDATE_PROGRESS = 1;
  93     /** Message sent to us to indicate alerting the user that we are waiting for password entry */
  94     private static final int MESSAGE_NOTIFY = 2;
  95
  96     // Constants used to control policy.
  97     private static final int MAX_FAILED_ATTEMPTS = 30;
  98     private static final int COOL_DOWN_ATTEMPTS = 10;
  99
 100     // Intent action for launching the Emergency Dialer activity.
 101     static final String ACTION_EMERGENCY_DIAL = "com.android.phone.EmergencyDialer.DIAL";
 102
 103     // Debug Intent extras so that this Activity may be started via adb for debugging UI layouts
 104     private static final String EXTRA_FORCE_VIEW =
 105             "com.android.settings.CryptKeeper.DEBUG_FORCE_VIEW";
 106     private static final String FORCE_VIEW_PROGRESS = "progress";
 107     private static final String FORCE_VIEW_ERROR = "error";
 108     private static final String FORCE_VIEW_PASSWORD = "password";
 109
 110     private static final String STATE_COOLDOWN = "cooldown";
 111
 112     /** When encryption is detected, this flag indicates whether or not we've checked for errors. */
 113     private boolean mValidationComplete;
 114     private boolean mValidationRequested;
 115     /** A flag to indicate that the volume is in a bad state (e.g. partially encrypted). */
 116     private boolean mEncryptionGoneBad;
 117     /** If gone bad, should we show encryption failed (false) or corrupt (true)*/
 118     private boolean mCorrupt;
 119     /** A flag to indicate when the back event should be ignored */
 120     /** When set, blocks unlocking. Set every COOL_DOWN_ATTEMPTS attempts, only cleared
 121         by power cycling phone. */
 122     private boolean mCooldown = false;
 123
 124     PowerManager.WakeLock mWakeLock;
 125     private ImeAwareEditText mPasswordEntry;
 126     private LockPatternView mLockPatternView;
 127     /** Number of calls to {@link #notifyUser()} to ignore before notifying. */
 128     private int mNotificationCountdown = 0;
 129     /** Number of calls to {@link #notifyUser()} before we release the wakelock */
 130     private int mReleaseWakeLockCountdown = 0;
 131     private int mStatusString = R.string.enter_password;
 132
 133     // how long we wait to clear a wrong pattern
 134     private static final int WRONG_PATTERN_CLEAR_TIMEOUT_MS = 1500;
 135
 136     // how long we wait to clear a right pattern
 137     private static final int RIGHT_PATTERN_CLEAR_TIMEOUT_MS = 500;
 138
 139     // When the user enters a short pin/password, run this to show an error,
 140     // but don't count it against attempts.
 141     private final Runnable mFakeUnlockAttemptRunnable = new Runnable() {
 142         @Override
 143         public void run() {
 144             handleBadAttempt(1 /* failedAttempt */);
 145         }
 146     };
 147
 148     // TODO: this should be tuned to match minimum decryption timeout
 149     private static final int FAKE_ATTEMPT_DELAY = 1000;
 150
 151     private final Runnable mClearPatternRunnable = new Runnable() {
 152         @Override
 153         public void run() {
 154             mLockPatternView.clearPattern();
 155         }
 156     };
 157
 158     /**
 159      * Used to propagate state through configuration changes (e.g. screen rotation)
 160      */
 161     private static class NonConfigurationInstanceState {
 162         final PowerManager.WakeLock wakelock;
 163
 164         NonConfigurationInstanceState(PowerManager.WakeLock _wakelock) {
 165             wakelock = _wakelock;
 166         }
 167     }
 168
 169     private class DecryptTask extends AsyncTask<String, Void, Integer> {
 170         private void hide(int id) {
 171             View view = findViewById(id);
 172             if (view != null) {
 173                 view.setVisibility(View.GONE);
 174             }
 175         }
 176
 177         @Override
 178         protected void onPreExecute() {
 179             super.onPreExecute();
 180             beginAttempt();
 181         }
 182
 183         @Override
 184         protected Integer doInBackground(String... params) {
 185             final IStorageManager service = getStorageManager();
 186             try {
 187                 return service.decryptStorage(params[0]);
 188             } catch (Exception e) {
 189                 Log.e(TAG, "Error while decrypting...", e);
 190                 return -1;
 191             }
 192         }
 193
 194         @Override
 195         protected void onPostExecute(Integer failedAttempts) {
 196             if (failedAttempts == 0) {
 197                 // The password was entered successfully. Simply do nothing
 198                 // and wait for the service restart to switch to surfacefligner
 199                 if (mLockPatternView != null) {
 200                     mLockPatternView.removeCallbacks(mClearPatternRunnable);
 201                     mLockPatternView.postDelayed(mClearPatternRunnable, RIGHT_PATTERN_CLEAR_TIMEOUT_MS);
 202                 }
 203                 final TextView status = (TextView) findViewById(R.id.status);
 204                 status.setText(R.string.starting_android);
 205                 hide(R.id.passwordEntry);
 206                 hide(R.id.switch_ime_button);
 207                 hide(R.id.lockPattern);
 208                 hide(R.id.owner_info);
 209                 hide(R.id.emergencyCallButton);
 210             } else if (failedAttempts == MAX_FAILED_ATTEMPTS) {
 211                 // Factory reset the device.
 212                 Intent intent = new Intent(Intent.ACTION_FACTORY_RESET);
 213                 intent.setPackage("android");
 214                 intent.addFlags(Intent.FLAG_RECEIVER_FOREGROUND);
 215                 intent.putExtra(Intent.EXTRA_REASON, "CryptKeeper.MAX_FAILED_ATTEMPTS");
 216                 sendBroadcast(intent);
 217             } else if (failedAttempts == -1) {
 218                 // Right password, but decryption failed. Tell user bad news ...
 219                 setContentView(R.layout.crypt_keeper_progress);
 220                 showFactoryReset(true);
 221                 return;
 222             } else {
 223                 handleBadAttempt(failedAttempts);
 224             }
 225         }
 226     }
 227
 228     private void beginAttempt() {
 229         final TextView status = (TextView) findViewById(R.id.status);
 230         status.setText(R.string.checking_decryption);
 231     }
 232
 233     private void handleBadAttempt(Integer failedAttempts) {
 234         // Wrong entry. Handle pattern case.
 235         if (mLockPatternView != null) {
 236             mLockPatternView.setDisplayMode(DisplayMode.Wrong);
 237             mLockPatternView.removeCallbacks(mClearPatternRunnable);
 238             mLockPatternView.postDelayed(mClearPatternRunnable, WRONG_PATTERN_CLEAR_TIMEOUT_MS);
 239         }
 240         if ((failedAttempts % COOL_DOWN_ATTEMPTS) == 0) {
 241             mCooldown = true;
 242             // No need to setBackFunctionality(false) - it's already done
 243             // at this point.
 244             cooldown();
 245         } else {
 246             final TextView status = (TextView) findViewById(R.id.status);
 247
 248             int remainingAttempts = MAX_FAILED_ATTEMPTS - failedAttempts;
 249             if (remainingAttempts < COOL_DOWN_ATTEMPTS) {
 250                 CharSequence warningTemplate = getText(R.string.crypt_keeper_warn_wipe);
 251                 CharSequence warning = TextUtils.expandTemplate(warningTemplate,
 252                         Integer.toString(remainingAttempts));
 253                 status.setText(warning);
 254             } else {
 255                 int passwordType = StorageManager.CRYPT_TYPE_PASSWORD;
 256                 try {
 257                     final IStorageManager service = getStorageManager();
 258                     passwordType = service.getPasswordType();
 259                 } catch (Exception e) {
 260                     Log.e(TAG, "Error calling mount service " + e);
 261                 }
 262
 263                 if (passwordType == StorageManager.CRYPT_TYPE_PIN) {
 264                     status.setText(R.string.cryptkeeper_wrong_pin);
 265                 } else if (passwordType == StorageManager.CRYPT_TYPE_PATTERN) {
 266                     status.setText(R.string.cryptkeeper_wrong_pattern);
 267                 } else {
 268                     status.setText(R.string.cryptkeeper_wrong_password);
 269                 }
 270             }
 271
 272             if (mLockPatternView != null) {
 273                 mLockPatternView.setDisplayMode(DisplayMode.Wrong);
 274                 mLockPatternView.setEnabled(true);
 275             }
 276
 277             // Reenable the password entry
 278             if (mPasswordEntry != null) {
 279                 mPasswordEntry.setEnabled(true);
 280                 mPasswordEntry.scheduleShowSoftInput();
 281                 setBackFunctionality(true);
 282             }
 283         }
 284     }
 285
 286     private class ValidationTask extends AsyncTask<Void, Void, Boolean> {
 287         int state;
 288
 289         @Override
 290         protected Boolean doInBackground(Void... params) {
 291             final IStorageManager service = getStorageManager();
 292             try {
 293                 Log.d(TAG, "Validating encryption state.");
 294                 state = service.getEncryptionState();
 295                 if (state == StorageManager.ENCRYPTION_STATE_NONE) {
 296                     Log.w(TAG, "Unexpectedly in CryptKeeper even though there is no encryption.");
 297                     return true; // Unexpected, but fine, I guess...
 298                 }
 299                 return state == StorageManager.ENCRYPTION_STATE_OK;
 300             } catch (RemoteException e) {
 301                 Log.w(TAG, "Unable to get encryption state properly");
 302                 return true;
 303             }
 304         }
 305
 306         @Override
 307         protected void onPostExecute(Boolean result) {
 308             mValidationComplete = true;
 309             if (Boolean.FALSE.equals(result)) {
 310                 Log.w(TAG, "Incomplete, or corrupted encryption detected. Prompting user to wipe.");
 311                 mEncryptionGoneBad = true;
 312                 mCorrupt = state == StorageManager.ENCRYPTION_STATE_ERROR_CORRUPT;
 313             } else {
 314                 Log.d(TAG, "Encryption state validated. Proceeding to configure UI");
 315             }
 316             setupUi();
 317         }
 318     }
 319
 320     private final Handler mHandler = new Handler() {
 321         @Override
 322         public void handleMessage(Message msg) {
 323             switch (msg.what) {
 324             case MESSAGE_UPDATE_PROGRESS:
 325                 updateProgress();
 326                 break;
 327
 328             case MESSAGE_NOTIFY:
 329                 notifyUser();
 330                 break;
 331             }
 332         }
 333     };
 334
 335     private AudioManager mAudioManager;
 336     /** The status bar where back/home/recent buttons are shown. */
 337     private StatusBarManager mStatusBar;
 338
 339     /** All the widgets to disable in the status bar */
 340     final private static int sWidgetsToDisable = StatusBarManager.DISABLE_EXPAND
 341             | StatusBarManager.DISABLE_NOTIFICATION_ICONS
 342             | StatusBarManager.DISABLE_NOTIFICATION_ALERTS
 343             | StatusBarManager.DISABLE_HOME
 344             | StatusBarManager.DISABLE_SEARCH
 345             | StatusBarManager.DISABLE_RECENT;
 346
 347     protected static final int MIN_LENGTH_BEFORE_REPORT = LockPatternUtils.MIN_LOCK_PATTERN_SIZE;
 348
 349     /** @return whether or not this Activity was started for debugging the UI only. */
 350     private boolean isDebugView() {
 351         return getIntent().hasExtra(EXTRA_FORCE_VIEW);
 352     }
 353
 354     /** @return whether or not this Activity was started for debugging the specific UI view only. */
 355     private boolean isDebugView(String viewType /* non-nullable */) {
 356         return viewType.equals(getIntent().getStringExtra(EXTRA_FORCE_VIEW));
 357     }
 358
 359     /**
 360      * Notify the user that we are awaiting input. Currently this sends an audio alert.
 361      */
 362     private void notifyUser() {
 363         if (mNotificationCountdown > 0) {
 364             --mNotificationCountdown;
 365         } else if (mAudioManager != null) {
 366             try {
 367                 // Play the standard keypress sound at full volume. This should be available on
 368                 // every device. We cannot play a ringtone here because media services aren't
 369                 // available yet. A DTMF-style tone is too soft to be noticed, and might not exist
 370                 // on tablet devices. The idea is to alert the user that something is needed: this
 371                 // does not have to be pleasing.
 372                 mAudioManager.playSoundEffect(AudioManager.FX_KEYPRESS_STANDARD, 100);
 373             } catch (Exception e) {
 374                 Log.w(TAG, "notifyUser: Exception while playing sound: " + e);
 375             }
 376         }
 377         // Notify the user again in 5 seconds.
 378         mHandler.removeMessages(MESSAGE_NOTIFY);
 379         mHandler.sendEmptyMessageDelayed(MESSAGE_NOTIFY, 5 * 1000);
 380
 381         if (mWakeLock.isHeld()) {
 382             if (mReleaseWakeLockCountdown > 0) {
 383                 --mReleaseWakeLockCountdown;
 384             } else {
 385                 mWakeLock.release();
 386             }
 387         }
 388     }
 389
 390     /**
 391      * Ignore back events from this activity always - there's nowhere to go back
 392      * to
 393      */
 394     @Override
 395     public void onBackPressed() {
 396     }
 397
 398     @Override
 399     public void onCreate(Bundle savedInstanceState) {
 400         super.onCreate(savedInstanceState);
 401
 402         // If we are not encrypted or encrypting, get out quickly.
 403         final String state = SystemProperties.get("vold.decrypt");
 404         if (!isDebugView() && ("".equals(state) || DECRYPT_STATE.equals(state))) {
 405             disableCryptKeeperComponent(this);
 406             // Typically CryptKeeper is launched as the home app.  We didn't
 407             // want to be running, so need to finish this activity.  We can count
 408             // on the activity manager re-launching the new home app upon finishing
 409             // this one, since this will leave the activity stack empty.
 410             // NOTE: This is really grungy.  I think it would be better for the
 411             // activity manager to explicitly launch the crypt keeper instead of
 412             // home in the situation where we need to decrypt the device
 413             finish();
 414             return;
 415         }
 416
 417         try {
 418             if (getResources().getBoolean(R.bool.crypt_keeper_allow_rotation)) {
 419                 setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED);
 420             }
 421         } catch (NotFoundException e) {
 422         }
 423
 424         // Disable the status bar, but do NOT disable back because the user needs a way to go
 425         // from keyboard settings and back to the password screen.
 426         mStatusBar = (StatusBarManager) getSystemService(Context.STATUS_BAR_SERVICE);
 427         mStatusBar.disable(sWidgetsToDisable);
 428
 429         if (savedInstanceState != null) {
 430             mCooldown = savedInstanceState.getBoolean(STATE_COOLDOWN);
 431         }
 432
 433         setAirplaneModeIfNecessary();
 434         mAudioManager = (AudioManager) getSystemService(Context.AUDIO_SERVICE);
 435         // Check for (and recover) retained instance data
 436         final Object lastInstance = getLastNonConfigurationInstance();
 437         if (lastInstance instanceof NonConfigurationInstanceState) {
 438             NonConfigurationInstanceState retained = (NonConfigurationInstanceState) lastInstance;
 439             mWakeLock = retained.wakelock;
 440             Log.d(TAG, "Restoring wakelock from NonConfigurationInstanceState");
 441         }
 442     }
 443
 444     @Override
 445     public void  onSaveInstanceState(Bundle savedInstanceState) {
 446         savedInstanceState.putBoolean(STATE_COOLDOWN, mCooldown);
 447     }
 448
 449     /**
 450      * Note, we defer the state check and screen setup to onStart() because this will be
 451      * re-run if the user clicks the power button (sleeping/waking the screen), and this is
 452      * especially important if we were to lose the wakelock for any reason.
 453      */
 454     @Override
 455     public void onStart() {
 456         super.onStart();
 457         setupUi();
 458     }
 459
 460     /**
 461      * Initializes the UI based on the current state of encryption.
 462      * This is idempotent - calling repeatedly will simply re-initialize the UI.
 463      */
 464     private void setupUi() {
 465         if (mEncryptionGoneBad || isDebugView(FORCE_VIEW_ERROR)) {
 466             setContentView(R.layout.crypt_keeper_progress);
 467             showFactoryReset(mCorrupt);
 468             return;
 469         }
 470
 471         final String progress = SystemProperties.get("vold.encrypt_progress");
 472         if (!"".equals(progress) || isDebugView(FORCE_VIEW_PROGRESS)) {
 473             setContentView(R.layout.crypt_keeper_progress);
 474             encryptionProgressInit();
 475         } else if (mValidationComplete || isDebugView(FORCE_VIEW_PASSWORD)) {
 476             new AsyncTask<Void, Void, Void>() {
 477                 int passwordType = StorageManager.CRYPT_TYPE_PASSWORD;
 478                 String owner_info;
 479                 boolean pattern_visible;
 480                 boolean password_visible;
 481
 482                 @Override
 483                 public Void doInBackground(Void... v) {
 484                     try {
 485                         final IStorageManager service = getStorageManager();
 486                         passwordType = service.getPasswordType();
 487                         owner_info = service.getField(StorageManager.OWNER_INFO_KEY);
 488                         pattern_visible = !("0".equals(service.getField(StorageManager.PATTERN_VISIBLE_KEY)));
 489                         password_visible = !("0".equals(service.getField(StorageManager.PASSWORD_VISIBLE_KEY)));
 490                     } catch (Exception e) {
 491                         Log.e(TAG, "Error calling mount service " + e);
 492                     }
 493
 494                     return null;
 495                 }
 496
 497                 @Override
 498                 public void onPostExecute(java.lang.Void v) {
 499                     Settings.System.putInt(getContentResolver(), Settings.System.TEXT_SHOW_PASSWORD,
 500                                   password_visible ? 1 : 0);
 501
 502                     if (passwordType == StorageManager.CRYPT_TYPE_PIN) {
 503                         setContentView(R.layout.crypt_keeper_pin_entry);
 504                         mStatusString = R.string.enter_pin;
 505                     } else if (passwordType == StorageManager.CRYPT_TYPE_PATTERN) {
 506                         setContentView(R.layout.crypt_keeper_pattern_entry);
 507                         setBackFunctionality(false);
 508                         mStatusString = R.string.enter_pattern;
 509                     } else {
 510                         setContentView(R.layout.crypt_keeper_password_entry);
 511                         mStatusString = R.string.enter_password;
 512                     }
 513                     final TextView status = (TextView) findViewById(R.id.status);
 514                     status.setText(mStatusString);
 515
 516                     final TextView ownerInfo = (TextView) findViewById(R.id.owner_info);
 517                     ownerInfo.setText(owner_info);
 518                     ownerInfo.setSelected(true); // Required for marquee'ing to work
 519
 520                     passwordEntryInit();
 521
 522                     findViewById(android.R.id.content).setSystemUiVisibility(View.STATUS_BAR_DISABLE_BACK);
 523
 524                     if (mLockPatternView != null) {
 525                         mLockPatternView.setInStealthMode(!pattern_visible);
 526                     }
 527                     if (mCooldown) {
 528                         // in case we are cooling down and coming back from emergency dialler
 529                         setBackFunctionality(false);
 530                         cooldown();
 531                     }
 532
 533                 }
 534             }.execute();
 535         } else if (!mValidationRequested) {
 536             // We're supposed to be encrypted, but no validation has been done.
 537             new ValidationTask().execute((Void[]) null);
 538             mValidationRequested = true;
 539         }
 540     }
 541
 542     @Override
 543     public void onStop() {
 544         super.onStop();
 545         mHandler.removeMessages(MESSAGE_UPDATE_PROGRESS);
 546         mHandler.removeMessages(MESSAGE_NOTIFY);
 547     }
 548
 549     /**
 550      * Reconfiguring, so propagate the wakelock to the next instance.  This runs between onStop()
 551      * and onDestroy() and only if we are changing configuration (e.g. rotation).  Also clears
 552      * mWakeLock so the subsequent call to onDestroy does not release it.
 553      */
 554     @Override
 555     public Object onRetainNonConfigurationInstance() {
 556         NonConfigurationInstanceState state = new NonConfigurationInstanceState(mWakeLock);
 557         Log.d(TAG, "Handing wakelock off to NonConfigurationInstanceState");
 558         mWakeLock = null;
 559         return state;
 560     }
 561
 562     @Override
 563     public void onDestroy() {
 564         super.onDestroy();
 565
 566         if (mWakeLock != null) {
 567             Log.d(TAG, "Releasing and destroying wakelock");
 568             mWakeLock.release();
 569             mWakeLock = null;
 570         }
 571     }
 572
 573     /**
 574      * Start encrypting the device.
 575      */
 576     private void encryptionProgressInit() {
 577         // Accquire a partial wakelock to prevent the device from sleeping. Note
 578         // we never release this wakelock as we will be restarted after the device
 579         // is encrypted.
 580         Log.d(TAG, "Encryption progress screen initializing.");
 581         if (mWakeLock == null) {
 582             Log.d(TAG, "Acquiring wakelock.");
 583             PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE);
 584             mWakeLock = pm.newWakeLock(PowerManager.FULL_WAKE_LOCK, TAG);
 585             mWakeLock.acquire();
 586         }
 587
 588         ((ProgressBar) findViewById(R.id.progress_bar)).setIndeterminate(true);
 589         // Ignore all back presses from now, both hard and soft keys.
 590         setBackFunctionality(false);
 591         // Start the first run of progress manually. This method sets up messages to occur at
 592         // repeated intervals.
 593         updateProgress();
 594     }
 595
 596     /**
 597      * Show factory reset screen allowing the user to reset their phone when
 598      * there is nothing else we can do
 599      * @param corrupt true if userdata is corrupt, false if encryption failed
 600      *        partway through
 601      */
 602     private void showFactoryReset(final boolean corrupt) {
 603         // Hide the encryption-bot to make room for the "factory reset" button
 604         findViewById(R.id.encroid).setVisibility(View.GONE);
 605
 606         // Show the reset button, failure text, and a divider
 607         final Button button = (Button) findViewById(R.id.factory_reset);
 608         button.setVisibility(View.VISIBLE);
 609         button.setOnClickListener(new OnClickListener() {
 610                 @Override
 611             public void onClick(View v) {
 612                 // Factory reset the device.
 613                 Intent intent = new Intent(Intent.ACTION_FACTORY_RESET);
 614                 intent.setPackage("android");
 615                 intent.addFlags(Intent.FLAG_RECEIVER_FOREGROUND);
 616                 intent.putExtra(Intent.EXTRA_REASON,
 617                         "CryptKeeper.showFactoryReset() corrupt=" + corrupt);
 618                 sendBroadcast(intent);
 619             }
 620         });
 621
 622         // Alert the user of the failure.
 623         if (corrupt) {
 624             ((TextView) findViewById(R.id.title)).setText(R.string.crypt_keeper_data_corrupt_title);
 625             ((TextView) findViewById(R.id.status)).setText(R.string.crypt_keeper_data_corrupt_summary);
 626         } else {
 627             ((TextView) findViewById(R.id.title)).setText(R.string.crypt_keeper_failed_title);
 628             ((TextView) findViewById(R.id.status)).setText(R.string.crypt_keeper_failed_summary);
 629         }
 630
 631         final View view = findViewById(R.id.bottom_divider);
 632         // TODO(viki): Why would the bottom divider be missing in certain layouts? Investigate.
 633         if (view != null) {
 634             view.setVisibility(View.VISIBLE);
 635         }
 636     }
 637
 638     private void updateProgress() {
 639         final String state = SystemProperties.get("vold.encrypt_progress");
 640
 641         if ("error_partially_encrypted".equals(state)) {
 642             showFactoryReset(false);
 643             return;
 644         }
 645
 646         // Get status as percentage first
 647         CharSequence status = getText(R.string.crypt_keeper_setup_description);
 648         int percent = 0;
 649         try {
 650             // Force a 50% progress state when debugging the view.
 651             percent = isDebugView() ? 50 : Integer.parseInt(state);
 652         } catch (Exception e) {
 653             Log.w(TAG, "Error parsing progress: " + e.toString());
 654         }
 655         String progress = Integer.toString(percent);
 656
 657         // Now try to get status as time remaining and replace as appropriate
 658         Log.v(TAG, "Encryption progress: " + progress);
 659         try {
 660             final String timeProperty = SystemProperties.get("vold.encrypt_time_remaining");
 661             int time = Integer.parseInt(timeProperty);
 662             if (time >= 0) {
 663                 // Round up to multiple of 10 - this way display is less jerky
 664                 time = (time + 9) / 10 * 10;
 665                 progress = DateUtils.formatElapsedTime(time);
 666                 status = getText(R.string.crypt_keeper_setup_time_remaining);
 667             }
 668         } catch (Exception e) {
 669             // Will happen if no time etc - show percentage
 670         }
 671
 672         final TextView tv = (TextView) findViewById(R.id.status);
 673         if (tv != null) {
 674             tv.setText(TextUtils.expandTemplate(status, progress));
 675         }
 676
 677         // Check the progress every 1 seconds
 678         mHandler.removeMessages(MESSAGE_UPDATE_PROGRESS);
 679         mHandler.sendEmptyMessageDelayed(MESSAGE_UPDATE_PROGRESS, 1000);
 680     }
 681
 682     /** Insist on a power cycle to force the user to waste time between retries.
 683      *
 684      * Call setBackFunctionality(false) before calling this. */
 685     private void cooldown() {
 686         // Disable the password entry.
 687         if (mPasswordEntry != null) {
 688             mPasswordEntry.setEnabled(false);
 689         }
 690         if (mLockPatternView != null) {
 691             mLockPatternView.setEnabled(false);
 692         }
 693
 694         final TextView status = (TextView) findViewById(R.id.status);
 695         status.setText(R.string.crypt_keeper_force_power_cycle);
 696     }
 697
 698     /**
 699      * Sets the back status: enabled or disabled according to the parameter.
 700      * @param isEnabled true if back is enabled, false otherwise.
 701      */
 702     private final void setBackFunctionality(boolean isEnabled) {
 703         if (isEnabled) {
 704             mStatusBar.disable(sWidgetsToDisable);
 705         } else {
 706             mStatusBar.disable(sWidgetsToDisable | StatusBarManager.DISABLE_BACK);
 707         }
 708     }
 709
 710     private void fakeUnlockAttempt(View postingView) {
 711         beginAttempt();
 712         postingView.postDelayed(mFakeUnlockAttemptRunnable, FAKE_ATTEMPT_DELAY);
 713     }
 714
 715     protected LockPatternView.OnPatternListener mChooseNewLockPatternListener =
 716         new LockPatternView.OnPatternListener() {
 717
 718         @Override
 719         public void onPatternStart() {
 720             mLockPatternView.removeCallbacks(mClearPatternRunnable);
 721         }
 722
 723         @Override
 724         public void onPatternCleared() {
 725         }
 726
 727         @Override
 728         public void onPatternDetected(List<LockPatternView.Cell> pattern) {
 729             mLockPatternView.setEnabled(false);
 730             if (pattern.size() >= MIN_LENGTH_BEFORE_REPORT) {
 731                 new DecryptTask().execute(LockPatternUtils.patternToString(pattern));
 732             } else {
 733                 // Allow user to make as many of these as they want.
 734                 fakeUnlockAttempt(mLockPatternView);
 735             }
 736         }
 737
 738         @Override
 739         public void onPatternCellAdded(List<Cell> pattern) {
 740         }
 741      };
 742
 743      private void passwordEntryInit() {
 744         // Password/pin case
 745         mPasswordEntry = (ImeAwareEditText) findViewById(R.id.passwordEntry);
 746         if (mPasswordEntry != null){
 747             mPasswordEntry.setOnEditorActionListener(this);
 748             mPasswordEntry.requestFocus();
 749             // Become quiet when the user interacts with the Edit text screen.
 750             mPasswordEntry.setOnKeyListener(this);
 751             mPasswordEntry.setOnTouchListener(this);
 752             mPasswordEntry.addTextChangedListener(this);
 753         }
 754
 755         // Pattern case
 756         mLockPatternView = (LockPatternView) findViewById(R.id.lockPattern);
 757         if (mLockPatternView != null) {
 758             mLockPatternView.setOnPatternListener(mChooseNewLockPatternListener);
 759         }
 760
 761         // Disable the Emergency call button if the device has no voice telephone capability
 762         if (!getTelephonyManager().isVoiceCapable()) {
 763             final View emergencyCall = findViewById(R.id.emergencyCallButton);
 764             if (emergencyCall != null) {
 765                 Log.d(TAG, "Removing the emergency Call button");
 766                 emergencyCall.setVisibility(View.GONE);
 767             }
 768         }
 769
 770         final View imeSwitcher = findViewById(R.id.switch_ime_button);
 771         final InputMethodManager imm = (InputMethodManager) getSystemService(
 772                 Context.INPUT_METHOD_SERVICE);
 773         if (imeSwitcher != null && hasMultipleEnabledIMEsOrSubtypes(imm, false)) {
 774             imeSwitcher.setVisibility(View.VISIBLE);
 775             imeSwitcher.setOnClickListener(new OnClickListener() {
 776                     @Override
 777                 public void onClick(View v) {
 778                     imm.showInputMethodPicker(false /* showAuxiliarySubtypes */);
 779                 }
 780             });
 781         }
 782
 783         // We want to keep the screen on while waiting for input. In minimal boot mode, the device
 784         // is completely non-functional, and we want the user to notice the device and enter a
 785         // password.
 786         if (mWakeLock == null) {
 787             Log.d(TAG, "Acquiring wakelock.");
 788             final PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE);
 789             if (pm != null) {
 790                 mWakeLock = pm.newWakeLock(PowerManager.FULL_WAKE_LOCK, TAG);
 791                 mWakeLock.acquire();
 792                 // Keep awake for 10 minutes - if the user hasn't been alerted by then
 793                 // best not to just drain their battery
 794                 mReleaseWakeLockCountdown = 96; // 96 * 5 secs per click + 120 secs before we show this = 600
 795             }
 796         }
 797
 798         // Make sure that the IME is shown when everything becomes ready.
 799         if (mLockPatternView == null && !mCooldown) {
 800             getWindow().setSoftInputMode(
 801                                 WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);
 802             if (mPasswordEntry != null) {
 803                 mPasswordEntry.scheduleShowSoftInput();
 804             }
 805         }
 806
 807         updateEmergencyCallButtonState();
 808         // Notify the user in 120 seconds that we are waiting for him to enter the password.
 809         mHandler.removeMessages(MESSAGE_NOTIFY);
 810         mHandler.sendEmptyMessageDelayed(MESSAGE_NOTIFY, 120 * 1000);
 811
 812         // Dismiss secure & non-secure keyguards while this screen is showing.
 813         getWindow().addFlags(WindowManager.LayoutParams.FLAG_DISMISS_KEYGUARD
 814                 | WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED);
 815     }
 816
 817     /**
 818      * Method adapted from com.android.inputmethod.latin.Utils
 819      *
 820      * @param imm The input method manager
 821      * @param shouldIncludeAuxiliarySubtypes
 822      * @return true if we have multiple IMEs to choose from
 823      */
 824     private boolean hasMultipleEnabledIMEsOrSubtypes(InputMethodManager imm,
 825             final boolean shouldIncludeAuxiliarySubtypes) {
 826         final List<InputMethodInfo> enabledImis = imm.getEnabledInputMethodList();
 827
 828         // Number of the filtered IMEs
 829         int filteredImisCount = 0;
 830
 831         for (InputMethodInfo imi : enabledImis) {
 832             // We can return true immediately after we find two or more filtered IMEs.
 833             if (filteredImisCount > 1) return true;
 834             final List<InputMethodSubtype> subtypes =
 835                     imm.getEnabledInputMethodSubtypeList(imi, true);
 836             // IMEs that have no subtypes should be counted.
 837             if (subtypes.isEmpty()) {
 838                 ++filteredImisCount;
 839                 continue;
 840             }
 841
 842             int auxCount = 0;
 843             for (InputMethodSubtype subtype : subtypes) {
 844                 if (subtype.isAuxiliary()) {
 845                     ++auxCount;
 846                 }
 847             }
 848             final int nonAuxCount = subtypes.size() - auxCount;
 849
 850             // IMEs that have one or more non-auxiliary subtypes should be counted.
 851             // If shouldIncludeAuxiliarySubtypes is true, IMEs that have two or more auxiliary
 852             // subtypes should be counted as well.
 853             if (nonAuxCount > 0 || (shouldIncludeAuxiliarySubtypes && auxCount > 1)) {
 854                 ++filteredImisCount;
 855                 continue;
 856             }
 857         }
 858
 859         return filteredImisCount > 1
 860         // imm.getEnabledInputMethodSubtypeList(null, false) will return the current IME's enabled
 861         // input method subtype (The current IME should be LatinIME.)
 862                 || imm.getEnabledInputMethodSubtypeList(null, false).size() > 1;
 863     }
 864
 865     private IStorageManager getStorageManager() {
 866         final IBinder service = ServiceManager.getService("mount");
 867         if (service != null) {
 868             return IStorageManager.Stub.asInterface(service);
 869         }
 870         return null;
 871     }
 872
 873     @Override
 874     public boolean onEditorAction(TextView v, int actionId, KeyEvent event) {
 875         if (actionId == EditorInfo.IME_NULL || actionId == EditorInfo.IME_ACTION_DONE) {
 876             // Get the password
 877             final String password = v.getText().toString();
 878
 879             if (TextUtils.isEmpty(password)) {
 880                 return true;
 881             }
 882
 883             // Now that we have the password clear the password field.
 884             v.setText(null);
 885
 886             // Disable the password entry and back keypress while checking the password. These
 887             // we either be re-enabled if the password was wrong or after the cooldown period.
 888             mPasswordEntry.setEnabled(false);
 889             setBackFunctionality(false);
 890
 891             if (password.length() >= LockPatternUtils.MIN_LOCK_PASSWORD_SIZE) {
 892                 new DecryptTask().execute(password);
 893             } else {
 894                 // Allow user to make as many of these as they want.
 895                 fakeUnlockAttempt(mPasswordEntry);
 896             }
 897
 898             return true;
 899         }
 900         return false;
 901     }
 902
 903     /**
 904      * Set airplane mode on the device if it isn't an LTE device.
 905      * Full story: In minimal boot mode, we cannot save any state. In particular, we cannot save
 906      * any incoming SMS's. So SMSs that are received here will be silently dropped to the floor.
 907      * That is bad. Also, we cannot receive any telephone calls in this state. So to avoid
 908      * both these problems, we turn the radio off. However, on certain networks turning on and
 909      * off the radio takes a long time. In such cases, we are better off leaving the radio
 910      * running so the latency of an E911 call is short.
 911      * The behavior after this is:
 912      * 1. Emergency dialing: the emergency dialer has logic to force the device out of
 913      *    airplane mode and restart the radio.
 914      * 2. Full boot: we read the persistent settings from the previous boot and restore the
 915      *    radio to whatever it was before it restarted. This also happens when rebooting a
 916      *    phone that has no encryption.
 917      */
 918     private final void setAirplaneModeIfNecessary() {
 919         final boolean isLteDevice =
 920                 getTelephonyManager().getLteOnCdmaMode() == PhoneConstants.LTE_ON_CDMA_TRUE;
 921         if (!isLteDevice) {
 922             Log.d(TAG, "Going into airplane mode.");
 923             Settings.Global.putInt(getContentResolver(), Settings.Global.AIRPLANE_MODE_ON, 1);
 924             final Intent intent = new Intent(Intent.ACTION_AIRPLANE_MODE_CHANGED);
 925             intent.putExtra("state", true);
 926             sendBroadcastAsUser(intent, UserHandle.ALL);
 927         }
 928     }
 929
 930     /**
 931      * Code to update the state of, and handle clicks from, the "Emergency call" button.
 932      *
 933      * This code is mostly duplicated from the corresponding code in
 934      * LockPatternUtils and LockPatternKeyguardView under frameworks/base.
 935      */
 936     private void updateEmergencyCallButtonState() {
 937         final Button emergencyCall = (Button) findViewById(R.id.emergencyCallButton);
 938         // The button isn't present at all in some configurations.
 939         if (emergencyCall == null)
 940             return;
 941
 942         if (isEmergencyCallCapable()) {
 943             emergencyCall.setVisibility(View.VISIBLE);
 944             emergencyCall.setOnClickListener(new View.OnClickListener() {
 945                     @Override
 946
 947                     public void onClick(View v) {
 948                         takeEmergencyCallAction();
 949                     }
 950                 });
 951         } else {
 952             emergencyCall.setVisibility(View.GONE);
 953             return;
 954         }
 955
 956         int textId;
 957         if (getTelecomManager().isInCall()) {
 958             // Show "return to call"
 959             textId = R.string.cryptkeeper_return_to_call;
 960         } else {
 961             textId = R.string.cryptkeeper_emergency_call;
 962         }
 963         emergencyCall.setText(textId);
 964     }
 965
 966     private boolean isEmergencyCallCapable() {
 967         return getResources().getBoolean(com.android.internal.R.bool.config_voice_capable);
 968     }
 969
 970     private void takeEmergencyCallAction() {
 971         TelecomManager telecomManager = getTelecomManager();
 972         if (telecomManager.isInCall()) {
 973             telecomManager.showInCallScreen(false /* showDialpad */);
 974         } else {
 975             launchEmergencyDialer();
 976         }
 977     }
 978
 979
 980     private void launchEmergencyDialer() {
 981         final Intent intent = new Intent(ACTION_EMERGENCY_DIAL);
 982         intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK
 983                         | Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS);
 984         setBackFunctionality(true);
 985         startActivity(intent);
 986     }
 987
 988     private TelephonyManager getTelephonyManager() {
 989         return (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);
 990     }
 991
 992     private TelecomManager getTelecomManager() {
 993         return (TelecomManager) getSystemService(Context.TELECOM_SERVICE);
 994     }
 995
 996     /**
 997      * Listen to key events so we can disable sounds when we get a keyinput in EditText.
 998      */
 999     private void delayAudioNotification() {
1000         mNotificationCountdown = 20;
1001     }
1002
1003     @Override
1004     public boolean onKey(View v, int keyCode, KeyEvent event) {
1005         delayAudioNotification();
1006         return false;
1007     }
1008
1009     @Override
1010     public boolean onTouch(View v, MotionEvent event) {
1011         delayAudioNotification();
1012         return false;
1013     }
1014
1015     @Override
1016     public void beforeTextChanged(CharSequence s, int start, int count, int after) {
1017         return;
1018     }
1019
1020     @Override
1021     public void onTextChanged(CharSequence s, int start, int before, int count) {
1022         delayAudioNotification();
1023     }
1024
1025     @Override
1026     public void afterTextChanged(Editable s) {
1027         return;
1028     }
1029
1030     private static void disableCryptKeeperComponent(Context context) {
1031         PackageManager pm = context.getPackageManager();
1032         ComponentName name = new ComponentName(context, CryptKeeper.class);
1033         Log.d(TAG, "Disabling component " + name);
1034         pm.setComponentEnabledSetting(name, PackageManager.COMPONENT_ENABLED_STATE_DISABLED,
1035                 PackageManager.DONT_KILL_APP);
1036     }
1037 }