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 } 1038
