blob: 655d8ad26ca9ced4d36672a454d19563aa761535 [file] [log] [blame]
Jason parks8fd5bc92011-01-12 16:03:31 -06001/*
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
17package com.android.settings;
18
Jason parks8fd5bc92011-01-12 16:03:31 -060019import android.app.Activity;
20import android.app.StatusBarManager;
21import android.content.ComponentName;
22import android.content.Context;
Jason parksec5a45e2011-01-18 15:28:36 -060023import android.content.Intent;
Jason parks8fd5bc92011-01-12 16:03:31 -060024import android.content.pm.PackageManager;
Jason parks06c5ff42011-03-01 10:17:40 -060025import android.os.AsyncTask;
Jason parks8fd5bc92011-01-12 16:03:31 -060026import android.os.Bundle;
Jason parksec5a45e2011-01-18 15:28:36 -060027import android.os.Handler;
Jason parks8fd5bc92011-01-12 16:03:31 -060028import android.os.IBinder;
Jason parksec5a45e2011-01-18 15:28:36 -060029import android.os.Message;
Jason parks35933812011-01-21 15:48:20 -060030import android.os.PowerManager;
David Brown8373b452011-06-20 12:38:45 -070031import android.os.RemoteException;
Jason parks8fd5bc92011-01-12 16:03:31 -060032import android.os.ServiceManager;
33import android.os.SystemProperties;
34import android.os.storage.IMountService;
David Brown8373b452011-06-20 12:38:45 -070035import android.telephony.TelephonyManager;
Jason parksec5a45e2011-01-18 15:28:36 -060036import android.text.TextUtils;
Jason parks8fd5bc92011-01-12 16:03:31 -060037import android.util.Log;
38import android.view.KeyEvent;
Andy Stadler13d62042011-01-31 19:21:37 -080039import android.view.View;
40import android.view.View.OnClickListener;
Jason parks8fd5bc92011-01-12 16:03:31 -060041import android.view.inputmethod.EditorInfo;
Ben Komalo9fcb6a72011-08-26 14:40:18 -070042import android.view.inputmethod.InputMethodInfo;
Jason parks75c085e2011-02-10 14:03:47 -060043import android.view.inputmethod.InputMethodManager;
Ben Komalo9fcb6a72011-08-26 14:40:18 -070044import android.view.inputmethod.InputMethodSubtype;
Andy Stadler13d62042011-01-31 19:21:37 -080045import android.widget.Button;
Jason parksec5a45e2011-01-18 15:28:36 -060046import android.widget.EditText;
47import android.widget.ProgressBar;
Jason parks8fd5bc92011-01-12 16:03:31 -060048import android.widget.TextView;
49
Ben Komalo91a2f052011-08-16 17:48:25 -070050import com.android.internal.telephony.ITelephony;
Ben Komalo9fcb6a72011-08-26 14:40:18 -070051
52import java.util.List;
Ben Komalo91a2f052011-08-16 17:48:25 -070053
54/**
55 * Settings screens to show the UI flows for encrypting/decrypting the device.
56 *
57 * This may be started via adb for debugging the UI layout, without having to go through
58 * encryption flows everytime. It should be noted that starting the activity in this manner
59 * is only useful for verifying UI-correctness - the behavior will not be identical.
60 * <pre>
61 * $ adb shell pm enable com.android.settings/.CryptKeeper
62 * $ adb shell am start \
63 * -e "com.android.settings.CryptKeeper.DEBUG_FORCE_VIEW" "progress" \
64 * -n com.android.settings/.CryptKeeper
65 * </pre>
66 */
Jason parks8fd5bc92011-01-12 16:03:31 -060067public class CryptKeeper extends Activity implements TextView.OnEditorActionListener {
Jason parksec5a45e2011-01-18 15:28:36 -060068 private static final String TAG = "CryptKeeper";
Jason parks35933812011-01-21 15:48:20 -060069
Jason parks8fd5bc92011-01-12 16:03:31 -060070 private static final String DECRYPT_STATE = "trigger_restart_framework";
Jason parksec5a45e2011-01-18 15:28:36 -060071
72 private static final int UPDATE_PROGRESS = 1;
73 private static final int COOLDOWN = 2;
74
75 private static final int MAX_FAILED_ATTEMPTS = 30;
76 private static final int COOL_DOWN_ATTEMPTS = 10;
77 private static final int COOL_DOWN_INTERVAL = 30; // 30 seconds
78
David Brown8373b452011-06-20 12:38:45 -070079 // Intent action for launching the Emergency Dialer activity.
80 static final String ACTION_EMERGENCY_DIAL = "com.android.phone.EmergencyDialer.DIAL";
81
Ben Komalo91a2f052011-08-16 17:48:25 -070082 // Debug Intent extras so that this Activity may be started via adb for debugging UI layouts
83 private static final String EXTRA_FORCE_VIEW =
84 "com.android.settings.CryptKeeper.DEBUG_FORCE_VIEW";
85 private static final String FORCE_VIEW_PROGRESS = "progress";
86 private static final String FORCE_VIEW_ENTRY = "entry";
87 private static final String FORCE_VIEW_ERROR = "error";
88
Ben Komalo0e666092011-09-01 15:42:00 -070089 /** When encryption is detected, this flag indivates whether or not we've checked for erros. */
90 private boolean mValidationComplete;
Ben Komalod4758ef2011-09-08 14:36:08 -070091 private boolean mValidationRequested;
Ben Komalo0e666092011-09-01 15:42:00 -070092 /** A flag to indicate that the volume is in a bad state (e.g. partially encrypted). */
93 private boolean mEncryptionGoneBad;
94
Andy Stadler14997402011-02-01 15:34:59 -080095 private int mCooldown;
96 PowerManager.WakeLock mWakeLock;
Jason parks06c5ff42011-03-01 10:17:40 -060097 private EditText mPasswordEntry;
Andy Stadler14997402011-02-01 15:34:59 -080098
99 /**
100 * Used to propagate state through configuration changes (e.g. screen rotation)
101 */
102 private static class NonConfigurationInstanceState {
103 final PowerManager.WakeLock wakelock;
104
105 NonConfigurationInstanceState(PowerManager.WakeLock _wakelock) {
106 wakelock = _wakelock;
107 }
108 }
109
Jason parksf1dbf552011-01-24 16:19:28 -0600110 // This activity is used to fade the screen to black after the password is entered.
111 public static class Blank extends Activity {
Andy Stadler13d62042011-01-31 19:21:37 -0800112 @Override
113 public void onCreate(Bundle savedInstanceState) {
114 super.onCreate(savedInstanceState);
115 setContentView(R.layout.crypt_keeper_blank);
116 }
Jason parksf1dbf552011-01-24 16:19:28 -0600117 }
Jason parksec5a45e2011-01-18 15:28:36 -0600118
Jason parks06c5ff42011-03-01 10:17:40 -0600119 private class DecryptTask extends AsyncTask<String, Void, Integer> {
120 @Override
121 protected Integer doInBackground(String... params) {
122 IMountService service = getMountService();
123 try {
124 return service.decryptStorage(params[0]);
125 } catch (Exception e) {
126 Log.e(TAG, "Error while decrypting...", e);
127 return -1;
128 }
129 }
130
131 @Override
132 protected void onPostExecute(Integer failedAttempts) {
133 if (failedAttempts == 0) {
134 // The password was entered successfully. Start the Blank activity
135 // so this activity animates to black before the devices starts. Note
136 // It has 1 second to complete the animation or it will be frozen
137 // until the boot animation comes back up.
138 Intent intent = new Intent(CryptKeeper.this, Blank.class);
139 finish();
140 startActivity(intent);
141 } else if (failedAttempts == MAX_FAILED_ATTEMPTS) {
142 // Factory reset the device.
143 sendBroadcast(new Intent("android.intent.action.MASTER_CLEAR"));
144 } else if ((failedAttempts % COOL_DOWN_ATTEMPTS) == 0) {
145 mCooldown = COOL_DOWN_INTERVAL;
146 cooldown();
147 } else {
148 TextView tv = (TextView) findViewById(R.id.status);
149 tv.setText(R.string.try_again);
150 tv.setVisibility(View.VISIBLE);
151
152 // Reenable the password entry
153 mPasswordEntry.setEnabled(true);
154 }
155 }
156 }
Jason parks75c085e2011-02-10 14:03:47 -0600157
Ben Komalo0e666092011-09-01 15:42:00 -0700158 private class ValidationTask extends AsyncTask<Void, Void, Boolean> {
159 @Override
160 protected Boolean doInBackground(Void... params) {
161 IMountService service = getMountService();
162 try {
Ben Komalod4758ef2011-09-08 14:36:08 -0700163 Log.d(TAG, "Validating encryption state.");
Ben Komalo0e666092011-09-01 15:42:00 -0700164 int state = service.getEncryptionState();
165 if (state == IMountService.ENCRYPTION_STATE_NONE) {
166 Log.w(TAG, "Unexpectedly in CryptKeeper even though there is no encryption.");
167 return true; // Unexpected, but fine, I guess...
168 }
169 return state == IMountService.ENCRYPTION_STATE_OK;
170 } catch (RemoteException e) {
171 Log.w(TAG, "Unable to get encryption state properly");
172 return true;
173 }
174 }
175
176 @Override
177 protected void onPostExecute(Boolean result) {
178 mValidationComplete = true;
179 if (Boolean.FALSE.equals(result)) {
180 Log.w(TAG, "Incomplete, or corrupted encryption detected. Prompting user to wipe.");
181 mEncryptionGoneBad = true;
Ben Komalod4758ef2011-09-08 14:36:08 -0700182 } else {
183 Log.d(TAG, "Encryption state validated. Proceeding to configure UI");
Ben Komalo0e666092011-09-01 15:42:00 -0700184 }
185 setupUi();
186 }
187 }
188
Ben Komalo91a2f052011-08-16 17:48:25 -0700189 private final Handler mHandler = new Handler() {
Jason parksec5a45e2011-01-18 15:28:36 -0600190 @Override
191 public void handleMessage(Message msg) {
Jason parksec5a45e2011-01-18 15:28:36 -0600192 switch (msg.what) {
Jason parksec5a45e2011-01-18 15:28:36 -0600193 case UPDATE_PROGRESS:
Jason parksf8217302011-01-26 13:11:42 -0600194 updateProgress();
Jason parksec5a45e2011-01-18 15:28:36 -0600195 break;
Jason parks35933812011-01-21 15:48:20 -0600196
Jason parksec5a45e2011-01-18 15:28:36 -0600197 case COOLDOWN:
Jason parksf8217302011-01-26 13:11:42 -0600198 cooldown();
Jason parksec5a45e2011-01-18 15:28:36 -0600199 break;
200 }
201 }
202 };
Jason parks35933812011-01-21 15:48:20 -0600203
Ben Komalo91a2f052011-08-16 17:48:25 -0700204 /** @return whether or not this Activity was started for debugging the UI only. */
205 private boolean isDebugView() {
206 return getIntent().hasExtra(EXTRA_FORCE_VIEW);
207 }
208
209 /** @return whether or not this Activity was started for debugging the specific UI view only. */
210 private boolean isDebugView(String viewType /* non-nullable */) {
211 return viewType.equals(getIntent().getStringExtra(EXTRA_FORCE_VIEW));
212 }
213
Jason parks8fd5bc92011-01-12 16:03:31 -0600214 @Override
215 public void onCreate(Bundle savedInstanceState) {
216 super.onCreate(savedInstanceState);
Jason parks35933812011-01-21 15:48:20 -0600217
Andy Stadler95974062011-02-01 17:35:20 -0800218 // If we are not encrypted or encrypting, get out quickly.
Jason parks8fd5bc92011-01-12 16:03:31 -0600219 String state = SystemProperties.get("vold.decrypt");
Ben Komalo91a2f052011-08-16 17:48:25 -0700220 if (!isDebugView() && ("".equals(state) || DECRYPT_STATE.equals(state))) {
Jason parks35933812011-01-21 15:48:20 -0600221 // Disable the crypt keeper.
Jason parks8fd5bc92011-01-12 16:03:31 -0600222 PackageManager pm = getPackageManager();
223 ComponentName name = new ComponentName(this, CryptKeeper.class);
Dianne Hackborn140f6c62011-10-16 11:49:00 -0700224 pm.setComponentEnabledSetting(name, PackageManager.COMPONENT_ENABLED_STATE_DISABLED,
225 PackageManager.DONT_KILL_APP);
226 // Typically CryptKeeper is launched as the home app. We didn't
Dianne Hackborn644fa422011-10-18 13:38:03 -0700227 // want to be running, so need to finish this activity. We can count
228 // on the activity manager re-launching the new home app upon finishing
229 // this one, since this will leave the activity stack empty.
Dianne Hackborn140f6c62011-10-16 11:49:00 -0700230 // NOTE: This is really grungy. I think it would be better for the
231 // activity manager to explicitly launch the crypt keeper instead of
232 // home in the situation where we need to decrypt the device
233 finish();
Jason parks8fd5bc92011-01-12 16:03:31 -0600234 return;
235 }
Jason parks35933812011-01-21 15:48:20 -0600236
Jason parks39f1e042011-01-20 23:29:28 -0600237 // Disable the status bar
238 StatusBarManager sbm = (StatusBarManager) getSystemService(Context.STATUS_BAR_SERVICE);
Andy Stadler13d62042011-01-31 19:21:37 -0800239 sbm.disable(StatusBarManager.DISABLE_EXPAND
240 | StatusBarManager.DISABLE_NOTIFICATION_ICONS
Jason parks39f1e042011-01-20 23:29:28 -0600241 | StatusBarManager.DISABLE_NOTIFICATION_ALERTS
Andy Stadler13d62042011-01-31 19:21:37 -0800242 | StatusBarManager.DISABLE_SYSTEM_INFO
Daniel Sandler4d2bfd12011-10-12 15:34:23 -0400243 | StatusBarManager.DISABLE_HOME
244 | StatusBarManager.DISABLE_RECENT
Andy Stadler13d62042011-01-31 19:21:37 -0800245 | StatusBarManager.DISABLE_BACK);
Andy Stadler14997402011-02-01 15:34:59 -0800246
247 // Check for (and recover) retained instance data
248 Object lastInstance = getLastNonConfigurationInstance();
249 if (lastInstance instanceof NonConfigurationInstanceState) {
250 NonConfigurationInstanceState retained = (NonConfigurationInstanceState) lastInstance;
251 mWakeLock = retained.wakelock;
Ben Komalo04606752011-08-18 14:50:26 -0700252 Log.d(TAG, "Restoring wakelock from NonConfigurationInstanceState");
Andy Stadler14997402011-02-01 15:34:59 -0800253 }
Jason parksec5a45e2011-01-18 15:28:36 -0600254 }
Jason parks35933812011-01-21 15:48:20 -0600255
Andy Stadler95974062011-02-01 17:35:20 -0800256 /**
257 * Note, we defer the state check and screen setup to onStart() because this will be
258 * re-run if the user clicks the power button (sleeping/waking the screen), and this is
259 * especially important if we were to lose the wakelock for any reason.
260 */
261 @Override
262 public void onStart() {
263 super.onStart();
264
Ben Komalod4758ef2011-09-08 14:36:08 -0700265 setupUi();
Ben Komalo0e666092011-09-01 15:42:00 -0700266 }
267
268 /**
269 * Initializes the UI based on the current state of encryption.
270 * This is idempotent - calling repeatedly will simply re-initialize the UI.
271 */
272 private void setupUi() {
273 if (mEncryptionGoneBad || isDebugView(FORCE_VIEW_ERROR)) {
274 setContentView(R.layout.crypt_keeper_progress);
275 showFactoryReset();
276 return;
277 }
278
Andy Stadler95974062011-02-01 17:35:20 -0800279 String progress = SystemProperties.get("vold.encrypt_progress");
Ben Komalo0e666092011-09-01 15:42:00 -0700280 if (!"".equals(progress) || isDebugView(FORCE_VIEW_PROGRESS)) {
Andy Stadler95974062011-02-01 17:35:20 -0800281 setContentView(R.layout.crypt_keeper_progress);
282 encryptionProgressInit();
Ben Komalod4758ef2011-09-08 14:36:08 -0700283 } else if (mValidationComplete) {
Andy Stadler95974062011-02-01 17:35:20 -0800284 setContentView(R.layout.crypt_keeper_password_entry);
285 passwordEntryInit();
Ben Komalod4758ef2011-09-08 14:36:08 -0700286 } else if (!mValidationRequested) {
287 // We're supposed to be encrypted, but no validation has been done.
288 new ValidationTask().execute((Void[]) null);
289 mValidationRequested = true;
Andy Stadler95974062011-02-01 17:35:20 -0800290 }
291 }
292
Jason parksf8217302011-01-26 13:11:42 -0600293 @Override
294 public void onStop() {
295 super.onStop();
296
297 mHandler.removeMessages(COOLDOWN);
298 mHandler.removeMessages(UPDATE_PROGRESS);
Andy Stadler14997402011-02-01 15:34:59 -0800299 }
300
301 /**
302 * Reconfiguring, so propagate the wakelock to the next instance. This runs between onStop()
303 * and onDestroy() and only if we are changing configuration (e.g. rotation). Also clears
304 * mWakeLock so the subsequent call to onDestroy does not release it.
305 */
306 @Override
307 public Object onRetainNonConfigurationInstance() {
308 NonConfigurationInstanceState state = new NonConfigurationInstanceState(mWakeLock);
Ben Komalo04606752011-08-18 14:50:26 -0700309 Log.d(TAG, "Handing wakelock off to NonConfigurationInstanceState");
Andy Stadler14997402011-02-01 15:34:59 -0800310 mWakeLock = null;
311 return state;
312 }
313
314 @Override
315 public void onDestroy() {
316 super.onDestroy();
Jason parksf8217302011-01-26 13:11:42 -0600317
318 if (mWakeLock != null) {
Ben Komalo04606752011-08-18 14:50:26 -0700319 Log.d(TAG, "Releasing and destroying wakelock");
Jason parksf8217302011-01-26 13:11:42 -0600320 mWakeLock.release();
321 mWakeLock = null;
322 }
323 }
324
Jason parksec5a45e2011-01-18 15:28:36 -0600325 private void encryptionProgressInit() {
Jason parks35933812011-01-21 15:48:20 -0600326 // Accquire a partial wakelock to prevent the device from sleeping. Note
327 // we never release this wakelock as we will be restarted after the device
328 // is encrypted.
329
Ben Komalo04606752011-08-18 14:50:26 -0700330 Log.d(TAG, "Encryption progress screen initializing.");
Ben Komalo9ee164f2011-09-21 10:40:50 -0700331 if (mWakeLock == null) {
Ben Komalo04606752011-08-18 14:50:26 -0700332 Log.d(TAG, "Acquiring wakelock.");
333 PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE);
334 mWakeLock = pm.newWakeLock(PowerManager.FULL_WAKE_LOCK, TAG);
335 mWakeLock.acquire();
336 }
Jason parks35933812011-01-21 15:48:20 -0600337
Jason parksf8217302011-01-26 13:11:42 -0600338 ProgressBar progressBar = (ProgressBar) findViewById(R.id.progress_bar);
339 progressBar.setIndeterminate(true);
340
341 updateProgress();
342 }
343
Andy Stadler13d62042011-01-31 19:21:37 -0800344 private void showFactoryReset() {
345 // Hide the encryption-bot to make room for the "factory reset" button
346 findViewById(R.id.encroid).setVisibility(View.GONE);
347
348 // Show the reset button, failure text, and a divider
349 Button button = (Button) findViewById(R.id.factory_reset);
350 button.setVisibility(View.VISIBLE);
351 button.setOnClickListener(new OnClickListener() {
352 public void onClick(View v) {
353 // Factory reset the device.
354 sendBroadcast(new Intent("android.intent.action.MASTER_CLEAR"));
355 }
356 });
357
358 TextView tv = (TextView) findViewById(R.id.title);
359 tv.setText(R.string.crypt_keeper_failed_title);
360
361 tv = (TextView) findViewById(R.id.status);
362 tv.setText(R.string.crypt_keeper_failed_summary);
363
364 View view = findViewById(R.id.bottom_divider);
Ben Komalof0104df2011-08-16 17:48:42 -0700365 if (view != null) {
366 view.setVisibility(View.VISIBLE);
367 }
Andy Stadler13d62042011-01-31 19:21:37 -0800368 }
369
Jason parksf8217302011-01-26 13:11:42 -0600370 private void updateProgress() {
371 String state = SystemProperties.get("vold.encrypt_progress");
372
Ben Komalo0e666092011-09-01 15:42:00 -0700373 if ("error_partially_encrypted".equals(state)) {
Andy Stadler13d62042011-01-31 19:21:37 -0800374 showFactoryReset();
375 return;
376 }
377
Jason parksf8217302011-01-26 13:11:42 -0600378 int progress = 0;
379 try {
Ben Komalo91a2f052011-08-16 17:48:25 -0700380 // Force a 50% progress state when debugging the view.
381 progress = isDebugView() ? 50 : Integer.parseInt(state);
Jason parksf8217302011-01-26 13:11:42 -0600382 } catch (Exception e) {
383 Log.w(TAG, "Error parsing progress: " + e.toString());
384 }
385
386 CharSequence status = getText(R.string.crypt_keeper_setup_description);
Ben Komalo04606752011-08-18 14:50:26 -0700387 Log.v(TAG, "Encryption progress: " + progress);
Jason parksf8217302011-01-26 13:11:42 -0600388 TextView tv = (TextView) findViewById(R.id.status);
389 tv.setText(TextUtils.expandTemplate(status, Integer.toString(progress)));
390
391 // Check the progress every 5 seconds
392 mHandler.removeMessages(UPDATE_PROGRESS);
393 mHandler.sendEmptyMessageDelayed(UPDATE_PROGRESS, 5000);
394 }
395
396 private void cooldown() {
397 TextView tv = (TextView) findViewById(R.id.status);
Andy Stadler13d62042011-01-31 19:21:37 -0800398
Jason parksf8217302011-01-26 13:11:42 -0600399 if (mCooldown <= 0) {
400 // Re-enable the password entry
Jason parks06c5ff42011-03-01 10:17:40 -0600401 mPasswordEntry.setEnabled(true);
Jason parksf8217302011-01-26 13:11:42 -0600402
Andy Stadler13d62042011-01-31 19:21:37 -0800403 tv.setVisibility(View.GONE);
Jason parksf8217302011-01-26 13:11:42 -0600404 } else {
Andy Stadler13d62042011-01-31 19:21:37 -0800405 CharSequence template = getText(R.string.crypt_keeper_cooldown);
406 tv.setText(TextUtils.expandTemplate(template, Integer.toString(mCooldown)));
407
408 tv.setVisibility(View.VISIBLE);
Jason parksf8217302011-01-26 13:11:42 -0600409
410 mCooldown--;
411 mHandler.removeMessages(COOLDOWN);
412 mHandler.sendEmptyMessageDelayed(COOLDOWN, 1000); // Tick every second
413 }
Jason parksec5a45e2011-01-18 15:28:36 -0600414 }
Jason parks35933812011-01-21 15:48:20 -0600415
Jason parksec5a45e2011-01-18 15:28:36 -0600416 private void passwordEntryInit() {
Jason parks06c5ff42011-03-01 10:17:40 -0600417 mPasswordEntry = (EditText) findViewById(R.id.passwordEntry);
418 mPasswordEntry.setOnEditorActionListener(this);
Ben Komalo9fcb6a72011-08-26 14:40:18 -0700419 mPasswordEntry.requestFocus();
Jason parks35933812011-01-21 15:48:20 -0600420
Ben Komalo9fcb6a72011-08-26 14:40:18 -0700421 View imeSwitcher = findViewById(R.id.switch_ime_button);
422 final InputMethodManager imm = (InputMethodManager) getSystemService(
423 Context.INPUT_METHOD_SERVICE);
424 if (imeSwitcher != null && hasMultipleEnabledIMEsOrSubtypes(imm, false)) {
425 imeSwitcher.setVisibility(View.VISIBLE);
426 imeSwitcher.setOnClickListener(new OnClickListener() {
427 public void onClick(View v) {
428 imm.showInputMethodPicker();
429 }
430 });
Jason parks00046d62011-06-13 17:38:45 -0500431 }
David Brown8373b452011-06-20 12:38:45 -0700432
Ben Komalo9fcb6a72011-08-26 14:40:18 -0700433 // Asynchronously throw up the IME, since there are issues with requesting it to be shown
434 // immediately.
435 mHandler.postDelayed(new Runnable() {
436 @Override public void run() {
437 imm.showSoftInputUnchecked(0, null);
438 }
439 }, 0);
440
David Brown8373b452011-06-20 12:38:45 -0700441 updateEmergencyCallButtonState();
Jason parks8fd5bc92011-01-12 16:03:31 -0600442 }
443
Ben Komalo9fcb6a72011-08-26 14:40:18 -0700444 /**
445 * Method adapted from com.android.inputmethod.latin.Utils
446 *
447 * @param imm The input method manager
448 * @param shouldIncludeAuxiliarySubtypes
449 * @return true if we have multiple IMEs to choose from
450 */
451 private boolean hasMultipleEnabledIMEsOrSubtypes(InputMethodManager imm,
452 final boolean shouldIncludeAuxiliarySubtypes) {
453 final List<InputMethodInfo> enabledImis = imm.getEnabledInputMethodList();
454
455 // Number of the filtered IMEs
456 int filteredImisCount = 0;
457
458 for (InputMethodInfo imi : enabledImis) {
459 // We can return true immediately after we find two or more filtered IMEs.
460 if (filteredImisCount > 1) return true;
461 final List<InputMethodSubtype> subtypes =
462 imm.getEnabledInputMethodSubtypeList(imi, true);
463 // IMEs that have no subtypes should be counted.
464 if (subtypes.isEmpty()) {
465 ++filteredImisCount;
466 continue;
467 }
468
469 int auxCount = 0;
470 for (InputMethodSubtype subtype : subtypes) {
471 if (subtype.isAuxiliary()) {
472 ++auxCount;
473 }
474 }
475 final int nonAuxCount = subtypes.size() - auxCount;
476
477 // IMEs that have one or more non-auxiliary subtypes should be counted.
478 // If shouldIncludeAuxiliarySubtypes is true, IMEs that have two or more auxiliary
479 // subtypes should be counted as well.
480 if (nonAuxCount > 0 || (shouldIncludeAuxiliarySubtypes && auxCount > 1)) {
481 ++filteredImisCount;
482 continue;
483 }
484 }
485
486 return filteredImisCount > 1
487 // imm.getEnabledInputMethodSubtypeList(null, false) will return the current IME's enabled
488 // input method subtype (The current IME should be LatinIME.)
489 || imm.getEnabledInputMethodSubtypeList(null, false).size() > 1;
490 }
491
Jason parks8fd5bc92011-01-12 16:03:31 -0600492 private IMountService getMountService() {
493 IBinder service = ServiceManager.getService("mount");
494 if (service != null) {
495 return IMountService.Stub.asInterface(service);
496 }
497 return null;
498 }
499
500 @Override
501 public boolean onEditorAction(TextView v, int actionId, KeyEvent event) {
Jason parks00046d62011-06-13 17:38:45 -0500502 if (actionId == EditorInfo.IME_NULL || actionId == EditorInfo.IME_ACTION_DONE) {
Jason parks8fd5bc92011-01-12 16:03:31 -0600503 // Get the password
504 String password = v.getText().toString();
505
Jason parksec5a45e2011-01-18 15:28:36 -0600506 if (TextUtils.isEmpty(password)) {
507 return true;
508 }
Jason parks35933812011-01-21 15:48:20 -0600509
Jason parks8fd5bc92011-01-12 16:03:31 -0600510 // Now that we have the password clear the password field.
511 v.setText(null);
512
Jason parks06c5ff42011-03-01 10:17:40 -0600513 // Disable the password entry while checking the password. This
514 // we either be reenabled if the password was wrong or after the
515 // cooldown period.
516 mPasswordEntry.setEnabled(false);
Jason parks8fd5bc92011-01-12 16:03:31 -0600517
Ben Komalo04606752011-08-18 14:50:26 -0700518 Log.d(TAG, "Attempting to send command to decrypt");
Jason parks06c5ff42011-03-01 10:17:40 -0600519 new DecryptTask().execute(password);
Jason parks35933812011-01-21 15:48:20 -0600520
Jason parks8fd5bc92011-01-12 16:03:31 -0600521 return true;
522 }
523 return false;
524 }
David Brown8373b452011-06-20 12:38:45 -0700525
526 //
527 // Code to update the state of, and handle clicks from, the "Emergency call" button.
528 //
529 // This code is mostly duplicated from the corresponding code in
530 // LockPatternUtils and LockPatternKeyguardView under frameworks/base.
531 //
532
533 private void updateEmergencyCallButtonState() {
534 Button button = (Button) findViewById(R.id.emergencyCallButton);
535 // The button isn't present at all in some configurations.
536 if (button == null) return;
537
538 if (isEmergencyCallCapable()) {
539 button.setVisibility(View.VISIBLE);
540 button.setOnClickListener(new View.OnClickListener() {
541 public void onClick(View v) {
542 takeEmergencyCallAction();
543 }
544 });
545 } else {
546 button.setVisibility(View.GONE);
547 return;
548 }
549
550 int newState = TelephonyManager.getDefault().getCallState();
551 int textId;
552 if (newState == TelephonyManager.CALL_STATE_OFFHOOK) {
553 // show "return to call" text and show phone icon
554 textId = R.string.cryptkeeper_return_to_call;
555 int phoneCallIcon = R.drawable.stat_sys_phone_call;
556 button.setCompoundDrawablesWithIntrinsicBounds(phoneCallIcon, 0, 0, 0);
557 } else {
558 textId = R.string.cryptkeeper_emergency_call;
559 int emergencyIcon = R.drawable.ic_emergency;
560 button.setCompoundDrawablesWithIntrinsicBounds(emergencyIcon, 0, 0, 0);
561 }
562 button.setText(textId);
563 }
564
565 private boolean isEmergencyCallCapable() {
566 return getResources().getBoolean(com.android.internal.R.bool.config_voice_capable);
567 }
568
569 private void takeEmergencyCallAction() {
570 if (TelephonyManager.getDefault().getCallState() == TelephonyManager.CALL_STATE_OFFHOOK) {
571 resumeCall();
572 } else {
573 launchEmergencyDialer();
574 }
575 }
576
577 private void resumeCall() {
578 ITelephony phone = ITelephony.Stub.asInterface(ServiceManager.checkService("phone"));
579 if (phone != null) {
580 try {
581 phone.showCallScreen();
582 } catch (RemoteException e) {
583 Log.e(TAG, "Error calling ITelephony service: " + e);
584 }
585 }
586 }
587
588 private void launchEmergencyDialer() {
589 Intent intent = new Intent(ACTION_EMERGENCY_DIAL);
590 intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK
591 | Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS);
592 startActivity(intent);
593 }
594}