2 * Copyright (C) 2011 The Android Open Source Project
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
17 package com.android.settings;
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;
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;
70 import java.util.List;
73 * Settings screens to show the UI flows for encrypting/decrypting the device.
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.
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
85 public class CryptKeeper extends Activity implements TextView.OnEditorActionListener,
86 OnKeyListener, OnTouchListener, TextWatcher {
87 private static final String TAG = "CryptKeeper";
89 private static final String DECRYPT_STATE = "trigger_restart_framework";
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;
96 // Constants used to control policy.
97 private static final int MAX_FAILED_ATTEMPTS = 30;
98 private static final int COOL_DOWN_ATTEMPTS = 10;
100 // Intent action for launching the Emergency Dialer activity.
101 static final String ACTION_EMERGENCY_DIAL = "com.android.phone.EmergencyDialer.DIAL";
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";
110 private static final String STATE_COOLDOWN = "cooldown";
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;
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;
133 // how long we wait to clear a wrong pattern
134 private static final int WRONG_PATTERN_CLEAR_TIMEOUT_MS = 1500;
136 // how long we wait to clear a right pattern
137 private static final int RIGHT_PATTERN_CLEAR_TIMEOUT_MS = 500;
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() {
144 handleBadAttempt(1 /* failedAttempt */);
148 // TODO: this should be tuned to match minimum decryption timeout
149 private static final int FAKE_ATTEMPT_DELAY = 1000;
151 private final Runnable mClearPatternRunnable = new Runnable() {
154 mLockPatternView.clearPattern();
159 * Used to propagate state through configuration changes (e.g. screen rotation)
161 private static class NonConfigurationInstanceState {
162 final PowerManager.WakeLock wakelock;
164 NonConfigurationInstanceState(PowerManager.WakeLock _wakelock) {
165 wakelock = _wakelock;
169 private class DecryptTask extends AsyncTask<String, Void, Integer> {
170 private void hide(int id) {
171 View view = findViewById(id);
173 view.setVisibility(View.GONE);
178 protected void onPreExecute() {
179 super.onPreExecute();
184 protected Integer doInBackground(String... params) {
185 final IStorageManager service = getStorageManager();
187 return service.decryptStorage(params[0]);
188 } catch (Exception e) {
189 Log.e(TAG, "Error while decrypting...", e);
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);
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);
223 handleBadAttempt(failedAttempts);
228 private void beginAttempt() {
229 final TextView status = (TextView) findViewById(R.id.status);
230 status.setText(R.string.checking_decryption);
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);
240 if ((failedAttempts % COOL_DOWN_ATTEMPTS) == 0) {
242 // No need to setBackFunctionality(false) - it's already done
246 final TextView status = (TextView) findViewById(R.id.status);
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);
255 int passwordType = StorageManager.CRYPT_TYPE_PASSWORD;
257 final IStorageManager service = getStorageManager();
258 passwordType = service.getPasswordType();
259 } catch (Exception e) {
260 Log.e(TAG, "Error calling mount service " + e);
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);
268 status.setText(R.string.cryptkeeper_wrong_password);
272 if (mLockPatternView != null) {
273 mLockPatternView.setDisplayMode(DisplayMode.Wrong);
274 mLockPatternView.setEnabled(true);
277 // Reenable the password entry
278 if (mPasswordEntry != null) {
279 mPasswordEntry.setEnabled(true);
280 mPasswordEntry.scheduleShowSoftInput();
281 setBackFunctionality(true);
286 private class ValidationTask extends AsyncTask<Void, Void, Boolean> {
290 protected Boolean doInBackground(Void... params) {
291 final IStorageManager service = getStorageManager();
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...
299 return state == StorageManager.ENCRYPTION_STATE_OK;
300 } catch (RemoteException e) {
301 Log.w(TAG, "Unable to get encryption state properly");
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;
314 Log.d(TAG, "Encryption state validated. Proceeding to configure UI");
320 private final Handler mHandler = new Handler() {
322 public void handleMessage(Message msg) {
324 case MESSAGE_UPDATE_PROGRESS:
335 private AudioManager mAudioManager;
336 /** The status bar where back/home/recent buttons are shown. */
337 private StatusBarManager mStatusBar;
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;
347 protected static final int MIN_LENGTH_BEFORE_REPORT = LockPatternUtils.MIN_LOCK_PATTERN_SIZE;
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);
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));
360 * Notify the user that we are awaiting input. Currently this sends an audio alert.
362 private void notifyUser() {
363 if (mNotificationCountdown > 0) {
364 --mNotificationCountdown;
365 } else if (mAudioManager != null) {
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);
377 // Notify the user again in 5 seconds.
378 mHandler.removeMessages(MESSAGE_NOTIFY);
379 mHandler.sendEmptyMessageDelayed(MESSAGE_NOTIFY, 5 * 1000);
381 if (mWakeLock.isHeld()) {
382 if (mReleaseWakeLockCountdown > 0) {
383 --mReleaseWakeLockCountdown;
391 * Ignore back events from this activity always - there's nowhere to go back
395 public void onBackPressed() {
399 public void onCreate(Bundle savedInstanceState) {
400 super.onCreate(savedInstanceState);
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
418 if (getResources().getBoolean(R.bool.crypt_keeper_allow_rotation)) {
419 setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED);
421 } catch (NotFoundException e) {
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);
429 if (savedInstanceState != null) {
430 mCooldown = savedInstanceState.getBoolean(STATE_COOLDOWN);
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");
445 public void onSaveInstanceState(Bundle savedInstanceState) {
446 savedInstanceState.putBoolean(STATE_COOLDOWN, mCooldown);
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.
455 public void onStart() {
461 * Initializes the UI based on the current state of encryption.
462 * This is idempotent - calling repeatedly will simply re-initialize the UI.
464 private void setupUi() {
465 if (mEncryptionGoneBad || isDebugView(FORCE_VIEW_ERROR)) {
466 setContentView(R.layout.crypt_keeper_progress);
467 showFactoryReset(mCorrupt);
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;
479 boolean pattern_visible;
480 boolean password_visible;
483 public Void doInBackground(Void... v) {
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);
498 public void onPostExecute(java.lang.Void v) {
499 Settings.System.putInt(getContentResolver(), Settings.System.TEXT_SHOW_PASSWORD,
500 password_visible ? 1 : 0);
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;
510 setContentView(R.layout.crypt_keeper_password_entry);
511 mStatusString = R.string.enter_password;
513 final TextView status = (TextView) findViewById(R.id.status);
514 status.setText(mStatusString);
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
522 findViewById(android.R.id.content).setSystemUiVisibility(View.STATUS_BAR_DISABLE_BACK);
524 if (mLockPatternView != null) {
525 mLockPatternView.setInStealthMode(!pattern_visible);
528 // in case we are cooling down and coming back from emergency dialler
529 setBackFunctionality(false);
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;
543 public void onStop() {
545 mHandler.removeMessages(MESSAGE_UPDATE_PROGRESS);
546 mHandler.removeMessages(MESSAGE_NOTIFY);
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.
555 public Object onRetainNonConfigurationInstance() {
556 NonConfigurationInstanceState state = new NonConfigurationInstanceState(mWakeLock);
557 Log.d(TAG, "Handing wakelock off to NonConfigurationInstanceState");
563 public void onDestroy() {
566 if (mWakeLock != null) {
567 Log.d(TAG, "Releasing and destroying wakelock");
574 * Start encrypting the device.
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
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);
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.
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
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);
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() {
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);
622 // Alert the user of the failure.
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);
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);
631 final View view = findViewById(R.id.bottom_divider);
632 // TODO(viki): Why would the bottom divider be missing in certain layouts? Investigate.
634 view.setVisibility(View.VISIBLE);
638 private void updateProgress() {
639 final String state = SystemProperties.get("vold.encrypt_progress");
641 if ("error_partially_encrypted".equals(state)) {
642 showFactoryReset(false);
646 // Get status as percentage first
647 CharSequence status = getText(R.string.crypt_keeper_setup_description);
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());
655 String progress = Integer.toString(percent);
657 // Now try to get status as time remaining and replace as appropriate
658 Log.v(TAG, "Encryption progress: " + progress);
660 final String timeProperty = SystemProperties.get("vold.encrypt_time_remaining");
661 int time = Integer.parseInt(timeProperty);
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);
668 } catch (Exception e) {
669 // Will happen if no time etc - show percentage
672 final TextView tv = (TextView) findViewById(R.id.status);
674 tv.setText(TextUtils.expandTemplate(status, progress));
677 // Check the progress every 1 seconds
678 mHandler.removeMessages(MESSAGE_UPDATE_PROGRESS);
679 mHandler.sendEmptyMessageDelayed(MESSAGE_UPDATE_PROGRESS, 1000);
682 /** Insist on a power cycle to force the user to waste time between retries.
684 * Call setBackFunctionality(false) before calling this. */
685 private void cooldown() {
686 // Disable the password entry.
687 if (mPasswordEntry != null) {
688 mPasswordEntry.setEnabled(false);
690 if (mLockPatternView != null) {
691 mLockPatternView.setEnabled(false);
694 final TextView status = (TextView) findViewById(R.id.status);
695 status.setText(R.string.crypt_keeper_force_power_cycle);
699 * Sets the back status: enabled or disabled according to the parameter.
700 * @param isEnabled true if back is enabled, false otherwise.
702 private final void setBackFunctionality(boolean isEnabled) {
704 mStatusBar.disable(sWidgetsToDisable);
706 mStatusBar.disable(sWidgetsToDisable | StatusBarManager.DISABLE_BACK);
710 private void fakeUnlockAttempt(View postingView) {
712 postingView.postDelayed(mFakeUnlockAttemptRunnable, FAKE_ATTEMPT_DELAY);
715 protected LockPatternView.OnPatternListener mChooseNewLockPatternListener =
716 new LockPatternView.OnPatternListener() {
719 public void onPatternStart() {
720 mLockPatternView.removeCallbacks(mClearPatternRunnable);
724 public void onPatternCleared() {
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));
733 // Allow user to make as many of these as they want.
734 fakeUnlockAttempt(mLockPatternView);
739 public void onPatternCellAdded(List<Cell> pattern) {
743 private void passwordEntryInit() {
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);
756 mLockPatternView = (LockPatternView) findViewById(R.id.lockPattern);
757 if (mLockPatternView != null) {
758 mLockPatternView.setOnPatternListener(mChooseNewLockPatternListener);
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);
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() {
777 public void onClick(View v) {
778 imm.showInputMethodPicker(false /* showAuxiliarySubtypes */);
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
786 if (mWakeLock == null) {
787 Log.d(TAG, "Acquiring wakelock.");
788 final PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE);
790 mWakeLock = pm.newWakeLock(PowerManager.FULL_WAKE_LOCK, TAG);
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
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();
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);
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);
818 * Method adapted from com.android.inputmethod.latin.Utils
820 * @param imm The input method manager
821 * @param shouldIncludeAuxiliarySubtypes
822 * @return true if we have multiple IMEs to choose from
824 private boolean hasMultipleEnabledIMEsOrSubtypes(InputMethodManager imm,
825 final boolean shouldIncludeAuxiliarySubtypes) {
826 final List<InputMethodInfo> enabledImis = imm.getEnabledInputMethodList();
828 // Number of the filtered IMEs
829 int filteredImisCount = 0;
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()) {
843 for (InputMethodSubtype subtype : subtypes) {
844 if (subtype.isAuxiliary()) {
848 final int nonAuxCount = subtypes.size() - auxCount;
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)) {
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;
865 private IStorageManager getStorageManager() {
866 final IBinder service = ServiceManager.getService("mount");
867 if (service != null) {
868 return IStorageManager.Stub.asInterface(service);
874 public boolean onEditorAction(TextView v, int actionId, KeyEvent event) {
875 if (actionId == EditorInfo.IME_NULL || actionId == EditorInfo.IME_ACTION_DONE) {
877 final String password = v.getText().toString();
879 if (TextUtils.isEmpty(password)) {
883 // Now that we have the password clear the password field.
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);
891 if (password.length() >= LockPatternUtils.MIN_LOCK_PASSWORD_SIZE) {
892 new DecryptTask().execute(password);
894 // Allow user to make as many of these as they want.
895 fakeUnlockAttempt(mPasswordEntry);
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.
918 private final void setAirplaneModeIfNecessary() {
919 final boolean isLteDevice =
920 getTelephonyManager().getLteOnCdmaMode() == PhoneConstants.LTE_ON_CDMA_TRUE;
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);
931 * Code to update the state of, and handle clicks from, the "Emergency call" button.
933 * This code is mostly duplicated from the corresponding code in
934 * LockPatternUtils and LockPatternKeyguardView under frameworks/base.
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)
942 if (isEmergencyCallCapable()) {
943 emergencyCall.setVisibility(View.VISIBLE);
944 emergencyCall.setOnClickListener(new View.OnClickListener() {
947 public void onClick(View v) {
948 takeEmergencyCallAction();
952 emergencyCall.setVisibility(View.GONE);
957 if (getTelecomManager().isInCall()) {
958 // Show "return to call"
959 textId = R.string.cryptkeeper_return_to_call;
961 textId = R.string.cryptkeeper_emergency_call;
963 emergencyCall.setText(textId);
966 private boolean isEmergencyCallCapable() {
967 return getResources().getBoolean(com.android.internal.R.bool.config_voice_capable);
970 private void takeEmergencyCallAction() {
971 TelecomManager telecomManager = getTelecomManager();
972 if (telecomManager.isInCall()) {
973 telecomManager.showInCallScreen(false /* showDialpad */);
975 launchEmergencyDialer();
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);
988 private TelephonyManager getTelephonyManager() {
989 return (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);
992 private TelecomManager getTelecomManager() {
993 return (TelecomManager) getSystemService(Context.TELECOM_SERVICE);
997 * Listen to key events so we can disable sounds when we get a keyinput in EditText.
999 private void delayAudioNotification() {
1000 mNotificationCountdown = 20;
1004 public boolean onKey(View v, int keyCode, KeyEvent event) {
1005 delayAudioNotification();
1010 public boolean onTouch(View v, MotionEvent event) {
1011 delayAudioNotification();
1016 public void beforeTextChanged(CharSequence s, int start, int count, int after) {
1021 public void onTextChanged(CharSequence s, int start, int before, int count) {
1022 delayAudioNotification();
1026 public void afterTextChanged(Editable s) {
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);