1 /* 2 * Copyright (C) 2008 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package com.android.keyguard; 18 19 import android.app.ActivityManagerNative; 20 import android.app.AlarmManager; 21 import android.app.IUserSwitchObserver; 22 import android.app.PendingIntent; 23 import android.app.admin.DevicePolicyManager; 24 import android.app.trust.TrustManager; 25 import android.content.BroadcastReceiver; 26 import android.content.ContentResolver; 27 import android.content.Context; 28 import android.content.Intent; 29 import android.content.IntentFilter; 30 import android.content.pm.UserInfo; 31 import android.database.ContentObserver; 32 import android.graphics.Bitmap; 33 34 import static android.os.BatteryManager.BATTERY_STATUS_FULL; 35 import static android.os.BatteryManager.BATTERY_STATUS_UNKNOWN; 36 import static android.os.BatteryManager.BATTERY_HEALTH_UNKNOWN; 37 import static android.os.BatteryManager.EXTRA_STATUS; 38 import static android.os.BatteryManager.EXTRA_PLUGGED; 39 import static android.os.BatteryManager.EXTRA_LEVEL; 40 import static android.os.BatteryManager.EXTRA_HEALTH; 41 42 import android.media.AudioManager; 43 import android.media.IRemoteControlDisplay; 44 import android.os.BatteryManager; 45 import android.os.Bundle; 46 import android.os.Handler; 47 import android.os.IRemoteCallback; 48 import android.os.Message; 49 import android.os.RemoteException; 50 import android.os.UserHandle; 51 import android.provider.Settings; 52 53 import com.android.internal.telephony.IccCardConstants; 54 import com.android.internal.telephony.TelephonyIntents; 55 56 import android.service.fingerprint.FingerprintManager; 57 import android.service.fingerprint.FingerprintManagerReceiver; 58 import android.service.fingerprint.FingerprintUtils; 59 import android.telephony.TelephonyManager; 60 import android.util.Log; 61 import android.util.SparseBooleanArray; 62 63 import com.google.android.collect.Lists; 64 65 import java.lang.ref.WeakReference; 66 import java.util.ArrayList; 67 68 /** 69 * Watches for updates that may be interesting to the keyguard, and provides 70 * the up to date information as well as a registration for callbacks that care 71 * to be updated. 72 * 73 * Note: under time crunch, this has been extended to include some stuff that 74 * doesn't really belong here. see {@link #handleBatteryUpdate} where it shutdowns 75 * the device, and {@link #getFailedUnlockAttempts()}, {@link #reportFailedAttempt()} 76 * and {@link #clearFailedUnlockAttempts()}. Maybe we should rename this 'KeyguardContext'... 77 */ 78 public class KeyguardUpdateMonitor implements TrustManager.TrustListener { 79 80 private static final String TAG = "KeyguardUpdateMonitor"; 81 private static final boolean DEBUG = KeyguardConstants.DEBUG; 82 private static final boolean DEBUG_SIM_STATES = DEBUG || false; 83 private static final int FAILED_BIOMETRIC_UNLOCK_ATTEMPTS_BEFORE_BACKUP = 3; 84 private static final int LOW_BATTERY_THRESHOLD = 20; 85 86 private static final String ACTION_FACE_UNLOCK_STARTED 87 = "com.android.facelock.FACE_UNLOCK_STARTED"; 88 private static final String ACTION_FACE_UNLOCK_STOPPED 89 = "com.android.facelock.FACE_UNLOCK_STOPPED"; 90 91 // Callback messages 92 private static final int MSG_TIME_UPDATE = 301; 93 private static final int MSG_BATTERY_UPDATE = 302; 94 private static final int MSG_CARRIER_INFO_UPDATE = 303; 95 private static final int MSG_SIM_STATE_CHANGE = 304; 96 private static final int MSG_RINGER_MODE_CHANGED = 305; 97 private static final int MSG_PHONE_STATE_CHANGED = 306; 98 private static final int MSG_CLOCK_VISIBILITY_CHANGED = 307; 99 private static final int MSG_DEVICE_PROVISIONED = 308; 100 private static final int MSG_DPM_STATE_CHANGED = 309; 101 private static final int MSG_USER_SWITCHING = 310; 102 private static final int MSG_USER_REMOVED = 311; 103 private static final int MSG_KEYGUARD_VISIBILITY_CHANGED = 312; 104 private static final int MSG_BOOT_COMPLETED = 313; 105 private static final int MSG_USER_SWITCH_COMPLETE = 314; 106 private static final int MSG_SET_CURRENT_CLIENT_ID = 315; 107 private static final int MSG_SET_PLAYBACK_STATE = 316; 108 private static final int MSG_USER_INFO_CHANGED = 317; 109 private static final int MSG_REPORT_EMERGENCY_CALL_ACTION = 318; 110 private static final int MSG_SCREEN_TURNED_ON = 319; 111 private static final int MSG_SCREEN_TURNED_OFF = 320; 112 private static final int MSG_KEYGUARD_BOUNCER_CHANGED = 322; 113 private static final int MSG_FINGERPRINT_PROCESSED = 323; 114 private static final int MSG_FINGERPRINT_ACQUIRED = 324; 115 private static final int MSG_FACE_UNLOCK_STATE_CHANGED = 325; 116 117 private static KeyguardUpdateMonitor sInstance; 118 119 private final Context mContext; 120 121 // Telephony state 122 private IccCardConstants.State mSimState = IccCardConstants.State.READY; 123 private CharSequence mTelephonyPlmn; 124 private CharSequence mTelephonySpn; 125 private int mRingMode; 126 private int mPhoneState; 127 private boolean mKeyguardIsVisible; 128 private boolean mBouncer; 129 private boolean mBootCompleted; 130 131 // Device provisioning state 132 private boolean mDeviceProvisioned; 133 134 // Battery status 135 private BatteryStatus mBatteryStatus; 136 137 // Password attempts 138 private int mFailedAttempts = 0; 139 private int mFailedBiometricUnlockAttempts = 0; 140 141 private boolean mAlternateUnlockEnabled; 142 143 private boolean mClockVisible; 144 145 private final ArrayList<WeakReference<KeyguardUpdateMonitorCallback>> 146 mCallbacks = Lists.newArrayList(); 147 private ContentObserver mDeviceProvisionedObserver; 148 149 private boolean mSwitchingUser; 150 151 private boolean mScreenOn; 152 153 private final Handler mHandler = new Handler() { 154 @Override 155 public void handleMessage(Message msg) { 156 switch (msg.what) { 157 case MSG_TIME_UPDATE: 158 handleTimeUpdate(); 159 break; 160 case MSG_BATTERY_UPDATE: 161 handleBatteryUpdate((BatteryStatus) msg.obj); 162 break; 163 case MSG_CARRIER_INFO_UPDATE: 164 handleCarrierInfoUpdate(); 165 break; 166 case MSG_SIM_STATE_CHANGE: 167 handleSimStateChange((SimArgs) msg.obj); 168 break; 169 case MSG_RINGER_MODE_CHANGED: 170 handleRingerModeChange(msg.arg1); 171 break; 172 case MSG_PHONE_STATE_CHANGED: 173 handlePhoneStateChanged((String) msg.obj); 174 break; 175 case MSG_CLOCK_VISIBILITY_CHANGED: 176 handleClockVisibilityChanged(); 177 break; 178 case MSG_DEVICE_PROVISIONED: 179 handleDeviceProvisioned(); 180 break; 181 case MSG_DPM_STATE_CHANGED: 182 handleDevicePolicyManagerStateChanged(); 183 break; 184 case MSG_USER_SWITCHING: 185 handleUserSwitching(msg.arg1, (IRemoteCallback) msg.obj); 186 break; 187 case MSG_USER_SWITCH_COMPLETE: 188 handleUserSwitchComplete(msg.arg1); 189 break; 190 case MSG_USER_REMOVED: 191 handleUserRemoved(msg.arg1); 192 break; 193 case MSG_KEYGUARD_VISIBILITY_CHANGED: 194 handleKeyguardVisibilityChanged(msg.arg1); 195 break; 196 case MSG_KEYGUARD_BOUNCER_CHANGED: 197 handleKeyguardBouncerChanged(msg.arg1); 198 break; 199 case MSG_BOOT_COMPLETED: 200 handleBootCompleted(); 201 break; 202 case MSG_USER_INFO_CHANGED: 203 handleUserInfoChanged(msg.arg1); 204 break; 205 case MSG_REPORT_EMERGENCY_CALL_ACTION: 206 handleReportEmergencyCallAction(); 207 break; 208 case MSG_SCREEN_TURNED_OFF: 209 handleScreenTurnedOff(msg.arg1); 210 break; 211 case MSG_SCREEN_TURNED_ON: 212 handleScreenTurnedOn(); 213 break; 214 case MSG_FINGERPRINT_ACQUIRED: 215 handleFingerprintAcquired(msg.arg1); 216 break; 217 case MSG_FINGERPRINT_PROCESSED: 218 handleFingerprintProcessed(msg.arg1); 219 break; 220 case MSG_FACE_UNLOCK_STATE_CHANGED: 221 handleFaceUnlockStateChanged(msg.arg1 != 0, msg.arg2); 222 break; 223 } 224 } 225 }; 226 227 private SparseBooleanArray mUserHasTrust = new SparseBooleanArray(); 228 private SparseBooleanArray mUserTrustIsManaged = new SparseBooleanArray(); 229 private SparseBooleanArray mUserFingerprintRecognized = new SparseBooleanArray(); 230 private SparseBooleanArray mUserFaceUnlockRunning = new SparseBooleanArray(); 231 232 @Override 233 public void onTrustChanged(boolean enabled, int userId, boolean initiatedByUser) { 234 mUserHasTrust.put(userId, enabled); 235 236 for (int i = 0; i < mCallbacks.size(); i++) { 237 KeyguardUpdateMonitorCallback cb = mCallbacks.get(i).get(); 238 if (cb != null) { 239 cb.onTrustChanged(userId); 240 if (enabled && initiatedByUser) { 241 cb.onTrustInitiatedByUser(userId); 242 } 243 } 244 } 245 } 246 247 @Override 248 public void onTrustManagedChanged(boolean managed, int userId) { 249 mUserTrustIsManaged.put(userId, managed); 250 251 for (int i = 0; i < mCallbacks.size(); i++) { 252 KeyguardUpdateMonitorCallback cb = mCallbacks.get(i).get(); 253 if (cb != null) { 254 cb.onTrustManagedChanged(userId); 255 } 256 } 257 } 258 259 private void onFingerprintRecognized(int userId) { 260 mUserFingerprintRecognized.put(userId, true); 261 for (int i = 0; i < mCallbacks.size(); i++) { 262 KeyguardUpdateMonitorCallback cb = mCallbacks.get(i).get(); 263 if (cb != null) { 264 cb.onFingerprintRecognized(userId); 265 } 266 } 267 } 268 269 private void handleFingerprintProcessed(int fingerprintId) { 270 if (fingerprintId == 0) return; // not a valid fingerprint 271 272 final int userId; 273 try { 274 userId = ActivityManagerNative.getDefault().getCurrentUser().id; 275 } catch (RemoteException e) { 276 Log.e(TAG, "Failed to get current user id: ", e); 277 return; 278 } 279 if (isFingerprintDisabled(userId)) { 280 Log.d(TAG, "Fingerprint disabled by DPM for userId: " + userId); 281 return; 282 } 283 final ContentResolver res = mContext.getContentResolver(); 284 final int ids[] = FingerprintUtils.getFingerprintIdsForUser(res, userId); 285 for (int i = 0; i < ids.length; i++) { 286 if (ids[i] == fingerprintId) { 287 onFingerprintRecognized(userId); 288 } 289 } 290 } 291 292 private void handleFingerprintAcquired(int info) { 293 for (int i = 0; i < mCallbacks.size(); i++) { 294 KeyguardUpdateMonitorCallback cb = mCallbacks.get(i).get(); 295 if (cb != null) { 296 cb.onFingerprintAcquired(info); 297 } 298 } 299 } 300 301 private void handleFaceUnlockStateChanged(boolean running, int userId) { 302 mUserFaceUnlockRunning.put(userId, running); 303 for (int i = 0; i < mCallbacks.size(); i++) { 304 KeyguardUpdateMonitorCallback cb = mCallbacks.get(i).get(); 305 if (cb != null) { 306 cb.onFaceUnlockStateChanged(running, userId); 307 } 308 } 309 } 310 311 public boolean isFaceUnlockRunning(int userId) { 312 return mUserFaceUnlockRunning.get(userId); 313 } 314 315 private boolean isTrustDisabled(int userId) { 316 final DevicePolicyManager dpm = 317 (DevicePolicyManager) mContext.getSystemService(Context.DEVICE_POLICY_SERVICE); 318 if (dpm != null) { 319 // TODO once UI is finalized 320 final boolean disabledByGlobalActions = false; 321 final boolean disabledBySettings = false; 322 323 // Don't allow trust agent if device is secured with a SIM PIN. This is here 324 // mainly because there's no other way to prompt the user to enter their SIM PIN 325 // once they get past the keyguard screen. 326 final boolean disabledBySimPin = isSimPinSecure(); 327 328 final boolean disabledByDpm = (dpm.getKeyguardDisabledFeatures(null, userId) 329 & DevicePolicyManager.KEYGUARD_DISABLE_TRUST_AGENTS) != 0; 330 return disabledByDpm || disabledByGlobalActions || disabledBySettings 331 || disabledBySimPin; 332 } 333 return false; 334 } 335 336 private boolean isFingerprintDisabled(int userId) { 337 final DevicePolicyManager dpm = 338 (DevicePolicyManager) mContext.getSystemService(Context.DEVICE_POLICY_SERVICE); 339 return dpm != null && (dpm.getKeyguardDisabledFeatures(null, userId) 340 & DevicePolicyManager.KEYGUARD_DISABLE_FINGERPRINT) != 0; 341 } 342 343 public boolean getUserHasTrust(int userId) { 344 return !isTrustDisabled(userId) && mUserHasTrust.get(userId) 345 || mUserFingerprintRecognized.get(userId); 346 } 347 348 public boolean getUserTrustIsManaged(int userId) { 349 return mUserTrustIsManaged.get(userId) && !isTrustDisabled(userId); 350 } 351 352 static class DisplayClientState { 353 public int clientGeneration; 354 public boolean clearing; 355 public PendingIntent intent; 356 public int playbackState; 357 public long playbackEventTime; 358 } 359 360 private DisplayClientState mDisplayClientState = new DisplayClientState(); 361 362 private final BroadcastReceiver mBroadcastReceiver = new BroadcastReceiver() { 363 364 public void onReceive(Context context, Intent intent) { 365 final String action = intent.getAction(); 366 if (DEBUG) Log.d(TAG, "received broadcast " + action); 367 368 if (Intent.ACTION_TIME_TICK.equals(action) 369 || Intent.ACTION_TIME_CHANGED.equals(action) 370 || Intent.ACTION_TIMEZONE_CHANGED.equals(action)) { 371 mHandler.sendEmptyMessage(MSG_TIME_UPDATE); 372 } else if (TelephonyIntents.SPN_STRINGS_UPDATED_ACTION.equals(action)) { 373 mTelephonyPlmn = getTelephonyPlmnFrom(intent); 374 mTelephonySpn = getTelephonySpnFrom(intent); 375 mHandler.sendEmptyMessage(MSG_CARRIER_INFO_UPDATE); 376 } else if (Intent.ACTION_BATTERY_CHANGED.equals(action)) { 377 final int status = intent.getIntExtra(EXTRA_STATUS, BATTERY_STATUS_UNKNOWN); 378 final int plugged = intent.getIntExtra(EXTRA_PLUGGED, 0); 379 final int level = intent.getIntExtra(EXTRA_LEVEL, 0); 380 final int health = intent.getIntExtra(EXTRA_HEALTH, BATTERY_HEALTH_UNKNOWN); 381 final Message msg = mHandler.obtainMessage( 382 MSG_BATTERY_UPDATE, new BatteryStatus(status, level, plugged, health)); 383 mHandler.sendMessage(msg); 384 } else if (TelephonyIntents.ACTION_SIM_STATE_CHANGED.equals(action)) { 385 if (DEBUG_SIM_STATES) { 386 Log.v(TAG, "action " + action + " state" + 387 intent.getStringExtra(IccCardConstants.INTENT_KEY_ICC_STATE)); 388 } 389 mHandler.sendMessage(mHandler.obtainMessage( 390 MSG_SIM_STATE_CHANGE, SimArgs.fromIntent(intent))); 391 } else if (AudioManager.RINGER_MODE_CHANGED_ACTION.equals(action)) { 392 mHandler.sendMessage(mHandler.obtainMessage(MSG_RINGER_MODE_CHANGED, 393 intent.getIntExtra(AudioManager.EXTRA_RINGER_MODE, -1), 0)); 394 } else if (TelephonyManager.ACTION_PHONE_STATE_CHANGED.equals(action)) { 395 String state = intent.getStringExtra(TelephonyManager.EXTRA_STATE); 396 mHandler.sendMessage(mHandler.obtainMessage(MSG_PHONE_STATE_CHANGED, state)); 397 } else if (Intent.ACTION_USER_REMOVED.equals(action)) { 398 mHandler.sendMessage(mHandler.obtainMessage(MSG_USER_REMOVED, 399 intent.getIntExtra(Intent.EXTRA_USER_HANDLE, 0), 0)); 400 } else if (Intent.ACTION_BOOT_COMPLETED.equals(action)) { 401 dispatchBootCompleted(); 402 } 403 } 404 }; 405 406 private final BroadcastReceiver mBroadcastAllReceiver = new BroadcastReceiver() { 407 408 public void onReceive(Context context, Intent intent) { 409 final String action = intent.getAction(); 410 if (AlarmManager.ACTION_NEXT_ALARM_CLOCK_CHANGED.equals(action)) { 411 mHandler.sendEmptyMessage(MSG_TIME_UPDATE); 412 } else if (Intent.ACTION_USER_INFO_CHANGED.equals(action)) { 413 mHandler.sendMessage(mHandler.obtainMessage(MSG_USER_INFO_CHANGED, 414 intent.getIntExtra(Intent.EXTRA_USER_HANDLE, getSendingUserId()), 0)); 415 } else if (ACTION_FACE_UNLOCK_STARTED.equals(action)) { 416 mHandler.sendMessage(mHandler.obtainMessage(MSG_FACE_UNLOCK_STATE_CHANGED, 1, 417 getSendingUserId())); 418 } else if (ACTION_FACE_UNLOCK_STOPPED.equals(action)) { 419 mHandler.sendMessage(mHandler.obtainMessage(MSG_FACE_UNLOCK_STATE_CHANGED, 0, 420 getSendingUserId())); 421 } else if (DevicePolicyManager.ACTION_DEVICE_POLICY_MANAGER_STATE_CHANGED 422 .equals(action)) { 423 mHandler.sendEmptyMessage(MSG_DPM_STATE_CHANGED); 424 } 425 } 426 }; 427 private FingerprintManagerReceiver mFingerprintManagerReceiver = 428 new FingerprintManagerReceiver() { 429 @Override 430 public void onProcessed(int fingerprintId) { 431 mHandler.obtainMessage(MSG_FINGERPRINT_PROCESSED, fingerprintId, 0).sendToTarget(); 432 }; 433 434 @Override 435 public void onAcquired(int info) { 436 mHandler.obtainMessage(MSG_FINGERPRINT_ACQUIRED, info, 0).sendToTarget(); 437 } 438 439 @Override 440 public void onError(int error) { 441 if (DEBUG) Log.w(TAG, "FingerprintManager reported error: " + error); 442 } 443 }; 444 445 /** 446 * When we receive a 447 * {@link com.android.internal.telephony.TelephonyIntents#ACTION_SIM_STATE_CHANGED} broadcast, 448 * and then pass a result via our handler to {@link KeyguardUpdateMonitor#handleSimStateChange}, 449 * we need a single object to pass to the handler. This class helps decode 450 * the intent and provide a {@link SimCard.State} result. 451 */ 452 private static class SimArgs { 453 public final IccCardConstants.State simState; 454 455 SimArgs(IccCardConstants.State state) { 456 simState = state; 457 } 458 459 static SimArgs fromIntent(Intent intent) { 460 IccCardConstants.State state; 461 if (!TelephonyIntents.ACTION_SIM_STATE_CHANGED.equals(intent.getAction())) { 462 throw new IllegalArgumentException("only handles intent ACTION_SIM_STATE_CHANGED"); 463 } 464 String stateExtra = intent.getStringExtra(IccCardConstants.INTENT_KEY_ICC_STATE); 465 if (IccCardConstants.INTENT_VALUE_ICC_ABSENT.equals(stateExtra)) { 466 final String absentReason = intent 467 .getStringExtra(IccCardConstants.INTENT_KEY_LOCKED_REASON); 468 469 if (IccCardConstants.INTENT_VALUE_ABSENT_ON_PERM_DISABLED.equals( 470 absentReason)) { 471 state = IccCardConstants.State.PERM_DISABLED; 472 } else { 473 state = IccCardConstants.State.ABSENT; 474 } 475 } else if (IccCardConstants.INTENT_VALUE_ICC_READY.equals(stateExtra)) { 476 state = IccCardConstants.State.READY; 477 } else if (IccCardConstants.INTENT_VALUE_ICC_LOCKED.equals(stateExtra)) { 478 final String lockedReason = intent 479 .getStringExtra(IccCardConstants.INTENT_KEY_LOCKED_REASON); 480 if (IccCardConstants.INTENT_VALUE_LOCKED_ON_PIN.equals(lockedReason)) { 481 state = IccCardConstants.State.PIN_REQUIRED; 482 } else if (IccCardConstants.INTENT_VALUE_LOCKED_ON_PUK.equals(lockedReason)) { 483 state = IccCardConstants.State.PUK_REQUIRED; 484 } else { 485 state = IccCardConstants.State.UNKNOWN; 486 } 487 } else if (IccCardConstants.INTENT_VALUE_LOCKED_NETWORK.equals(stateExtra)) { 488 state = IccCardConstants.State.NETWORK_LOCKED; 489 } else if (IccCardConstants.INTENT_VALUE_ICC_LOADED.equals(stateExtra) 490 || IccCardConstants.INTENT_VALUE_ICC_IMSI.equals(stateExtra)) { 491 // This is required because telephony doesn't return to "READY" after 492 // these state transitions. See bug 7197471. 493 state = IccCardConstants.State.READY; 494 } else { 495 state = IccCardConstants.State.UNKNOWN; 496 } 497 return new SimArgs(state); 498 } 499 500 public String toString() { 501 return simState.toString(); 502 } 503 } 504 505 public static class BatteryStatus { 506 public final int status; 507 public final int level; 508 public final int plugged; 509 public final int health; 510 public BatteryStatus(int status, int level, int plugged, int health) { 511 this.status = status; 512 this.level = level; 513 this.plugged = plugged; 514 this.health = health; 515 } 516 517 /** 518 * Determine whether the device is plugged in (USB, power, or wireless). 519 * @return true if the device is plugged in. 520 */ 521 boolean isPluggedIn() { 522 return plugged == BatteryManager.BATTERY_PLUGGED_AC 523 || plugged == BatteryManager.BATTERY_PLUGGED_USB 524 || plugged == BatteryManager.BATTERY_PLUGGED_WIRELESS; 525 } 526 527 /** 528 * Whether or not the device is charged. Note that some devices never return 100% for 529 * battery level, so this allows either battery level or status to determine if the 530 * battery is charged. 531 * @return true if the device is charged 532 */ 533 public boolean isCharged() { 534 return status == BATTERY_STATUS_FULL || level >= 100; 535 } 536 537 /** 538 * Whether battery is low and needs to be charged. 539 * @return true if battery is low 540 */ 541 public boolean isBatteryLow() { 542 return level < LOW_BATTERY_THRESHOLD; 543 } 544 545 } 546 547 public static KeyguardUpdateMonitor getInstance(Context context) { 548 if (sInstance == null) { 549 sInstance = new KeyguardUpdateMonitor(context); 550 } 551 return sInstance; 552 } 553 554 protected void handleScreenTurnedOn() { 555 final int count = mCallbacks.size(); 556 for (int i = 0; i < count; i++) { 557 KeyguardUpdateMonitorCallback cb = mCallbacks.get(i).get(); 558 if (cb != null) { 559 cb.onScreenTurnedOn(); 560 } 561 } 562 } 563 564 protected void handleScreenTurnedOff(int arg1) { 565 clearFingerprintRecognized(); 566 final int count = mCallbacks.size(); 567 for (int i = 0; i < count; i++) { 568 KeyguardUpdateMonitorCallback cb = mCallbacks.get(i).get(); 569 if (cb != null) { 570 cb.onScreenTurnedOff(arg1); 571 } 572 } 573 } 574 575 /** 576 * IMPORTANT: Must be called from UI thread. 577 */ 578 public void dispatchSetBackground(Bitmap bmp) { 579 if (DEBUG) Log.d(TAG, "dispatchSetBackground"); 580 final int count = mCallbacks.size(); 581 for (int i = 0; i < count; i++) { 582 KeyguardUpdateMonitorCallback cb = mCallbacks.get(i).get(); 583 if (cb != null) { 584 cb.onSetBackground(bmp); 585 } 586 } 587 } 588 589 private void handleUserInfoChanged(int userId) { 590 for (int i = 0; i < mCallbacks.size(); i++) { 591 KeyguardUpdateMonitorCallback cb = mCallbacks.get(i).get(); 592 if (cb != null) { 593 cb.onUserInfoChanged(userId); 594 } 595 } 596 } 597 598 private KeyguardUpdateMonitor(Context context) { 599 mContext = context; 600 mDeviceProvisioned = isDeviceProvisionedInSettingsDb(); 601 // Since device can't be un-provisioned, we only need to register a content observer 602 // to update mDeviceProvisioned when we are... 603 if (!mDeviceProvisioned) { 604 watchForDeviceProvisioning(); 605 } 606 607 // Take a guess at initial SIM state, battery status and PLMN until we get an update 608 mSimState = IccCardConstants.State.NOT_READY; 609 mBatteryStatus = new BatteryStatus(BATTERY_STATUS_UNKNOWN, 100, 0, 0); 610 mTelephonyPlmn = getDefaultPlmn(); 611 612 // Watch for interesting updates 613 final IntentFilter filter = new IntentFilter(); 614 filter.addAction(Intent.ACTION_TIME_TICK); 615 filter.addAction(Intent.ACTION_TIME_CHANGED); 616 filter.addAction(Intent.ACTION_BATTERY_CHANGED); 617 filter.addAction(Intent.ACTION_TIMEZONE_CHANGED); 618 filter.addAction(TelephonyIntents.ACTION_SIM_STATE_CHANGED); 619 filter.addAction(TelephonyManager.ACTION_PHONE_STATE_CHANGED); 620 filter.addAction(TelephonyIntents.SPN_STRINGS_UPDATED_ACTION); 621 filter.addAction(AudioManager.RINGER_MODE_CHANGED_ACTION); 622 filter.addAction(Intent.ACTION_USER_REMOVED); 623 context.registerReceiver(mBroadcastReceiver, filter); 624 625 final IntentFilter bootCompleteFilter = new IntentFilter(); 626 bootCompleteFilter.setPriority(IntentFilter.SYSTEM_HIGH_PRIORITY); 627 bootCompleteFilter.addAction(Intent.ACTION_BOOT_COMPLETED); 628 context.registerReceiver(mBroadcastReceiver, bootCompleteFilter); 629 630 final IntentFilter allUserFilter = new IntentFilter(); 631 allUserFilter.addAction(Intent.ACTION_USER_INFO_CHANGED); 632 allUserFilter.addAction(AlarmManager.ACTION_NEXT_ALARM_CLOCK_CHANGED); 633 allUserFilter.addAction(ACTION_FACE_UNLOCK_STARTED); 634 allUserFilter.addAction(ACTION_FACE_UNLOCK_STOPPED); 635 allUserFilter.addAction(DevicePolicyManager.ACTION_DEVICE_POLICY_MANAGER_STATE_CHANGED); 636 context.registerReceiverAsUser(mBroadcastAllReceiver, UserHandle.ALL, allUserFilter, 637 null, null); 638 639 try { 640 ActivityManagerNative.getDefault().registerUserSwitchObserver( 641 new IUserSwitchObserver.Stub() { 642 @Override 643 public void onUserSwitching(int newUserId, IRemoteCallback reply) { 644 mHandler.sendMessage(mHandler.obtainMessage(MSG_USER_SWITCHING, 645 newUserId, 0, reply)); 646 mSwitchingUser = true; 647 } 648 @Override 649 public void onUserSwitchComplete(int newUserId) throws RemoteException { 650 mHandler.sendMessage(mHandler.obtainMessage(MSG_USER_SWITCH_COMPLETE, 651 newUserId, 0)); 652 mSwitchingUser = false; 653 } 654 }); 655 } catch (RemoteException e) { 656 // TODO Auto-generated catch block 657 e.printStackTrace(); 658 } 659 660 TrustManager trustManager = (TrustManager) context.getSystemService(Context.TRUST_SERVICE); 661 trustManager.registerTrustListener(this); 662 663 FingerprintManager fpm; 664 fpm = (FingerprintManager) context.getSystemService(Context.FINGERPRINT_SERVICE); 665 fpm.startListening(mFingerprintManagerReceiver); 666 } 667 668 private boolean isDeviceProvisionedInSettingsDb() { 669 return Settings.Global.getInt(mContext.getContentResolver(), 670 Settings.Global.DEVICE_PROVISIONED, 0) != 0; 671 } 672 673 private void watchForDeviceProvisioning() { 674 mDeviceProvisionedObserver = new ContentObserver(mHandler) { 675 @Override 676 public void onChange(boolean selfChange) { 677 super.onChange(selfChange); 678 mDeviceProvisioned = isDeviceProvisionedInSettingsDb(); 679 if (mDeviceProvisioned) { 680 mHandler.sendEmptyMessage(MSG_DEVICE_PROVISIONED); 681 } 682 if (DEBUG) Log.d(TAG, "DEVICE_PROVISIONED state = " + mDeviceProvisioned); 683 } 684 }; 685 686 mContext.getContentResolver().registerContentObserver( 687 Settings.Global.getUriFor(Settings.Global.DEVICE_PROVISIONED), 688 false, mDeviceProvisionedObserver); 689 690 // prevent a race condition between where we check the flag and where we register the 691 // observer by grabbing the value once again... 692 boolean provisioned = isDeviceProvisionedInSettingsDb(); 693 if (provisioned != mDeviceProvisioned) { 694 mDeviceProvisioned = provisioned; 695 if (mDeviceProvisioned) { 696 mHandler.sendEmptyMessage(MSG_DEVICE_PROVISIONED); 697 } 698 } 699 } 700 701 /** 702 * Handle {@link #MSG_DPM_STATE_CHANGED} 703 */ 704 protected void handleDevicePolicyManagerStateChanged() { 705 for (int i = mCallbacks.size() - 1; i >= 0; i--) { 706 KeyguardUpdateMonitorCallback cb = mCallbacks.get(i).get(); 707 if (cb != null) { 708 cb.onDevicePolicyManagerStateChanged(); 709 } 710 } 711 } 712 713 /** 714 * Handle {@link #MSG_USER_SWITCHING} 715 */ 716 protected void handleUserSwitching(int userId, IRemoteCallback reply) { 717 for (int i = 0; i < mCallbacks.size(); i++) { 718 KeyguardUpdateMonitorCallback cb = mCallbacks.get(i).get(); 719 if (cb != null) { 720 cb.onUserSwitching(userId); 721 } 722 } 723 try { 724 reply.sendResult(null); 725 } catch (RemoteException e) { 726 } 727 } 728 729 /** 730 * Handle {@link #MSG_USER_SWITCH_COMPLETE} 731 */ 732 protected void handleUserSwitchComplete(int userId) { 733 for (int i = 0; i < mCallbacks.size(); i++) { 734 KeyguardUpdateMonitorCallback cb = mCallbacks.get(i).get(); 735 if (cb != null) { 736 cb.onUserSwitchComplete(userId); 737 } 738 } 739 } 740 741 /** 742 * This is exposed since {@link Intent#ACTION_BOOT_COMPLETED} is not sticky. If 743 * keyguard crashes sometime after boot, then it will never receive this 744 * broadcast and hence not handle the event. This method is ultimately called by 745 * PhoneWindowManager in this case. 746 */ 747 public void dispatchBootCompleted() { 748 mHandler.sendEmptyMessage(MSG_BOOT_COMPLETED); 749 } 750 751 /** 752 * Handle {@link #MSG_BOOT_COMPLETED} 753 */ 754 protected void handleBootCompleted() { 755 if (mBootCompleted) return; 756 mBootCompleted = true; 757 for (int i = 0; i < mCallbacks.size(); i++) { 758 KeyguardUpdateMonitorCallback cb = mCallbacks.get(i).get(); 759 if (cb != null) { 760 cb.onBootCompleted(); 761 } 762 } 763 } 764 765 /** 766 * We need to store this state in the KeyguardUpdateMonitor since this class will not be 767 * destroyed. 768 */ 769 public boolean hasBootCompleted() { 770 return mBootCompleted; 771 } 772 773 /** 774 * Handle {@link #MSG_USER_REMOVED} 775 */ 776 protected void handleUserRemoved(int userId) { 777 for (int i = 0; i < mCallbacks.size(); i++) { 778 KeyguardUpdateMonitorCallback cb = mCallbacks.get(i).get(); 779 if (cb != null) { 780 cb.onUserRemoved(userId); 781 } 782 } 783 } 784 785 /** 786 * Handle {@link #MSG_DEVICE_PROVISIONED} 787 */ 788 protected void handleDeviceProvisioned() { 789 for (int i = 0; i < mCallbacks.size(); i++) { 790 KeyguardUpdateMonitorCallback cb = mCallbacks.get(i).get(); 791 if (cb != null) { 792 cb.onDeviceProvisioned(); 793 } 794 } 795 if (mDeviceProvisionedObserver != null) { 796 // We don't need the observer anymore... 797 mContext.getContentResolver().unregisterContentObserver(mDeviceProvisionedObserver); 798 mDeviceProvisionedObserver = null; 799 } 800 } 801 802 /** 803 * Handle {@link #MSG_PHONE_STATE_CHANGED} 804 */ 805 protected void handlePhoneStateChanged(String newState) { 806 if (DEBUG) Log.d(TAG, "handlePhoneStateChanged(" + newState + ")"); 807 if (TelephonyManager.EXTRA_STATE_IDLE.equals(newState)) { 808 mPhoneState = TelephonyManager.CALL_STATE_IDLE; 809 } else if (TelephonyManager.EXTRA_STATE_OFFHOOK.equals(newState)) { 810 mPhoneState = TelephonyManager.CALL_STATE_OFFHOOK; 811 } else if (TelephonyManager.EXTRA_STATE_RINGING.equals(newState)) { 812 mPhoneState = TelephonyManager.CALL_STATE_RINGING; 813 } 814 for (int i = 0; i < mCallbacks.size(); i++) { 815 KeyguardUpdateMonitorCallback cb = mCallbacks.get(i).get(); 816 if (cb != null) { 817 cb.onPhoneStateChanged(mPhoneState); 818 } 819 } 820 } 821 822 /** 823 * Handle {@link #MSG_RINGER_MODE_CHANGED} 824 */ 825 protected void handleRingerModeChange(int mode) { 826 if (DEBUG) Log.d(TAG, "handleRingerModeChange(" + mode + ")"); 827 mRingMode = mode; 828 for (int i = 0; i < mCallbacks.size(); i++) { 829 KeyguardUpdateMonitorCallback cb = mCallbacks.get(i).get(); 830 if (cb != null) { 831 cb.onRingerModeChanged(mode); 832 } 833 } 834 } 835 836 /** 837 * Handle {@link #MSG_TIME_UPDATE} 838 */ 839 private void handleTimeUpdate() { 840 if (DEBUG) Log.d(TAG, "handleTimeUpdate"); 841 for (int i = 0; i < mCallbacks.size(); i++) { 842 KeyguardUpdateMonitorCallback cb = mCallbacks.get(i).get(); 843 if (cb != null) { 844 cb.onTimeChanged(); 845 } 846 } 847 } 848 849 /** 850 * Handle {@link #MSG_BATTERY_UPDATE} 851 */ 852 private void handleBatteryUpdate(BatteryStatus status) { 853 if (DEBUG) Log.d(TAG, "handleBatteryUpdate"); 854 final boolean batteryUpdateInteresting = isBatteryUpdateInteresting(mBatteryStatus, status); 855 mBatteryStatus = status; 856 if (batteryUpdateInteresting) { 857 for (int i = 0; i < mCallbacks.size(); i++) { 858 KeyguardUpdateMonitorCallback cb = mCallbacks.get(i).get(); 859 if (cb != null) { 860 cb.onRefreshBatteryInfo(status); 861 } 862 } 863 } 864 } 865 866 /** 867 * Handle {@link #MSG_CARRIER_INFO_UPDATE} 868 */ 869 private void handleCarrierInfoUpdate() { 870 if (DEBUG) Log.d(TAG, "handleCarrierInfoUpdate: plmn = " + mTelephonyPlmn 871 + ", spn = " + mTelephonySpn); 872 873 for (int i = 0; i < mCallbacks.size(); i++) { 874 KeyguardUpdateMonitorCallback cb = mCallbacks.get(i).get(); 875 if (cb != null) { 876 cb.onRefreshCarrierInfo(mTelephonyPlmn, mTelephonySpn); 877 } 878 } 879 } 880 881 /** 882 * Handle {@link #MSG_SIM_STATE_CHANGE} 883 */ 884 private void handleSimStateChange(SimArgs simArgs) { 885 final IccCardConstants.State state = simArgs.simState; 886 887 if (DEBUG) { 888 Log.d(TAG, "handleSimStateChange: intentValue = " + simArgs + " " 889 + "state resolved to " + state.toString()); 890 } 891 892 if (state != IccCardConstants.State.UNKNOWN && state != mSimState) { 893 mSimState = state; 894 for (int i = 0; i < mCallbacks.size(); i++) { 895 KeyguardUpdateMonitorCallback cb = mCallbacks.get(i).get(); 896 if (cb != null) { 897 cb.onSimStateChanged(state); 898 } 899 } 900 } 901 } 902 903 /** 904 * Handle {@link #MSG_CLOCK_VISIBILITY_CHANGED} 905 */ 906 private void handleClockVisibilityChanged() { 907 if (DEBUG) Log.d(TAG, "handleClockVisibilityChanged()"); 908 for (int i = 0; i < mCallbacks.size(); i++) { 909 KeyguardUpdateMonitorCallback cb = mCallbacks.get(i).get(); 910 if (cb != null) { 911 cb.onClockVisibilityChanged(); 912 } 913 } 914 } 915 916 /** 917 * Handle {@link #MSG_KEYGUARD_VISIBILITY_CHANGED} 918 */ 919 private void handleKeyguardVisibilityChanged(int showing) { 920 if (DEBUG) Log.d(TAG, "handleKeyguardVisibilityChanged(" + showing + ")"); 921 boolean isShowing = (showing == 1); 922 mKeyguardIsVisible = isShowing; 923 for (int i = 0; i < mCallbacks.size(); i++) { 924 KeyguardUpdateMonitorCallback cb = mCallbacks.get(i).get(); 925 if (cb != null) { 926 cb.onKeyguardVisibilityChangedRaw(isShowing); 927 } 928 } 929 } 930 931 /** 932 * Handle {@link #MSG_KEYGUARD_BOUNCER_CHANGED} 933 * @see #sendKeyguardBouncerChanged(boolean) 934 */ 935 private void handleKeyguardBouncerChanged(int bouncer) { 936 if (DEBUG) Log.d(TAG, "handleKeyguardBouncerChanged(" + bouncer + ")"); 937 boolean isBouncer = (bouncer == 1); 938 mBouncer = isBouncer; 939 for (int i = 0; i < mCallbacks.size(); i++) { 940 KeyguardUpdateMonitorCallback cb = mCallbacks.get(i).get(); 941 if (cb != null) { 942 cb.onKeyguardBouncerChanged(isBouncer); 943 } 944 } 945 } 946 947 /** 948 * Handle {@link #MSG_REPORT_EMERGENCY_CALL_ACTION} 949 */ 950 private void handleReportEmergencyCallAction() { 951 for (int i = 0; i < mCallbacks.size(); i++) { 952 KeyguardUpdateMonitorCallback cb = mCallbacks.get(i).get(); 953 if (cb != null) { 954 cb.onEmergencyCallAction(); 955 } 956 } 957 } 958 959 public boolean isKeyguardVisible() { 960 return mKeyguardIsVisible; 961 } 962 963 /** 964 * @return if the keyguard is currently in bouncer mode. 965 */ 966 public boolean isKeyguardBouncer() { 967 return mBouncer; 968 } 969 970 public boolean isSwitchingUser() { 971 return mSwitchingUser; 972 } 973 974 private static boolean isBatteryUpdateInteresting(BatteryStatus old, BatteryStatus current) { 975 final boolean nowPluggedIn = current.isPluggedIn(); 976 final boolean wasPluggedIn = old.isPluggedIn(); 977 final boolean stateChangedWhilePluggedIn = 978 wasPluggedIn == true && nowPluggedIn == true 979 && (old.status != current.status); 980 981 // change in plug state is always interesting 982 if (wasPluggedIn != nowPluggedIn || stateChangedWhilePluggedIn) { 983 return true; 984 } 985 986 // change in battery level while plugged in 987 if (nowPluggedIn && old.level != current.level) { 988 return true; 989 } 990 991 // change where battery needs charging 992 if (!nowPluggedIn && current.isBatteryLow() && current.level != old.level) { 993 return true; 994 } 995 return false; 996 } 997 998 /** 999 * @param intent The intent with action {@link TelephonyIntents#SPN_STRINGS_UPDATED_ACTION} 1000 * @return The string to use for the plmn, or null if it should not be shown. 1001 */ 1002 private CharSequence getTelephonyPlmnFrom(Intent intent) { 1003 if (intent.getBooleanExtra(TelephonyIntents.EXTRA_SHOW_PLMN, false)) { 1004 final String plmn = intent.getStringExtra(TelephonyIntents.EXTRA_PLMN); 1005 return (plmn != null) ? plmn : getDefaultPlmn(); 1006 } 1007 return null; 1008 } 1009 1010 /** 1011 * @return The default plmn (no service) 1012 */ 1013 private CharSequence getDefaultPlmn() { 1014 return mContext.getResources().getText(R.string.keyguard_carrier_default); 1015 } 1016 1017 /** 1018 * @param intent The intent with action {@link Telephony.Intents#SPN_STRINGS_UPDATED_ACTION} 1019 * @return The string to use for the plmn, or null if it should not be shown. 1020 */ 1021 private CharSequence getTelephonySpnFrom(Intent intent) { 1022 if (intent.getBooleanExtra(TelephonyIntents.EXTRA_SHOW_SPN, false)) { 1023 final String spn = intent.getStringExtra(TelephonyIntents.EXTRA_SPN); 1024 if (spn != null) { 1025 return spn; 1026 } 1027 } 1028 return null; 1029 } 1030 1031 /** 1032 * Remove the given observer's callback. 1033 * 1034 * @param callback The callback to remove 1035 */ 1036 public void removeCallback(KeyguardUpdateMonitorCallback callback) { 1037 if (DEBUG) Log.v(TAG, "*** unregister callback for " + callback); 1038 for (int i = mCallbacks.size() - 1; i >= 0; i--) { 1039 if (mCallbacks.get(i).get() == callback) { 1040 mCallbacks.remove(i); 1041 } 1042 } 1043 } 1044 1045 /** 1046 * Register to receive notifications about general keyguard information 1047 * (see {@link InfoCallback}. 1048 * @param callback The callback to register 1049 */ 1050 public void registerCallback(KeyguardUpdateMonitorCallback callback) { 1051 if (DEBUG) Log.v(TAG, "*** register callback for " + callback); 1052 // Prevent adding duplicate callbacks 1053 for (int i = 0; i < mCallbacks.size(); i++) { 1054 if (mCallbacks.get(i).get() == callback) { 1055 if (DEBUG) Log.e(TAG, "Object tried to add another callback", 1056 new Exception("Called by")); 1057 return; 1058 } 1059 } 1060 mCallbacks.add(new WeakReference<KeyguardUpdateMonitorCallback>(callback)); 1061 removeCallback(null); // remove unused references 1062 sendUpdates(callback); 1063 } 1064 1065 private void sendUpdates(KeyguardUpdateMonitorCallback callback) { 1066 // Notify listener of the current state 1067 callback.onRefreshBatteryInfo(mBatteryStatus); 1068 callback.onTimeChanged(); 1069 callback.onRingerModeChanged(mRingMode); 1070 callback.onPhoneStateChanged(mPhoneState); 1071 callback.onRefreshCarrierInfo(mTelephonyPlmn, mTelephonySpn); 1072 callback.onClockVisibilityChanged(); 1073 callback.onSimStateChanged(mSimState); 1074 } 1075 1076 public void sendKeyguardVisibilityChanged(boolean showing) { 1077 if (DEBUG) Log.d(TAG, "sendKeyguardVisibilityChanged(" + showing + ")"); 1078 Message message = mHandler.obtainMessage(MSG_KEYGUARD_VISIBILITY_CHANGED); 1079 message.arg1 = showing ? 1 : 0; 1080 message.sendToTarget(); 1081 } 1082 1083 /** 1084 * @see #handleKeyguardBouncerChanged(int) 1085 */ 1086 public void sendKeyguardBouncerChanged(boolean showingBouncer) { 1087 if (DEBUG) Log.d(TAG, "sendKeyguardBouncerChanged(" + showingBouncer + ")"); 1088 Message message = mHandler.obtainMessage(MSG_KEYGUARD_BOUNCER_CHANGED); 1089 message.arg1 = showingBouncer ? 1 : 0; 1090 message.sendToTarget(); 1091 } 1092 1093 public void reportClockVisible(boolean visible) { 1094 mClockVisible = visible; 1095 mHandler.obtainMessage(MSG_CLOCK_VISIBILITY_CHANGED).sendToTarget(); 1096 } 1097 1098 public IccCardConstants.State getSimState() { 1099 return mSimState; 1100 } 1101 1102 /** 1103 * Report that the user successfully entered the SIM PIN or PUK/SIM PIN so we 1104 * have the information earlier than waiting for the intent 1105 * broadcast from the telephony code. 1106 * 1107 * NOTE: Because handleSimStateChange() invokes callbacks immediately without going 1108 * through mHandler, this *must* be called from the UI thread. 1109 */ 1110 public void reportSimUnlocked() { 1111 handleSimStateChange(new SimArgs(IccCardConstants.State.READY)); 1112 } 1113 1114 /** 1115 * Report that the emergency call button has been pressed and the emergency dialer is 1116 * about to be displayed. 1117 * 1118 * @param bypassHandler runs immediately. 1119 * 1120 * NOTE: Must be called from UI thread if bypassHandler == true. 1121 */ 1122 public void reportEmergencyCallAction(boolean bypassHandler) { 1123 if (!bypassHandler) { 1124 mHandler.obtainMessage(MSG_REPORT_EMERGENCY_CALL_ACTION).sendToTarget(); 1125 } else { 1126 handleReportEmergencyCallAction(); 1127 } 1128 } 1129 1130 public CharSequence getTelephonyPlmn() { 1131 return mTelephonyPlmn; 1132 } 1133 1134 public CharSequence getTelephonySpn() { 1135 return mTelephonySpn; 1136 } 1137 1138 /** 1139 * @return Whether the device is provisioned (whether they have gone through 1140 * the setup wizard) 1141 */ 1142 public boolean isDeviceProvisioned() { 1143 return mDeviceProvisioned; 1144 } 1145 1146 public int getFailedUnlockAttempts() { 1147 return mFailedAttempts; 1148 } 1149 1150 public void clearFailedUnlockAttempts() { 1151 mFailedAttempts = 0; 1152 mFailedBiometricUnlockAttempts = 0; 1153 } 1154 1155 public void clearFingerprintRecognized() { 1156 mUserFingerprintRecognized.clear(); 1157 } 1158 1159 public void reportFailedUnlockAttempt() { 1160 mFailedAttempts++; 1161 } 1162 1163 public boolean isClockVisible() { 1164 return mClockVisible; 1165 } 1166 1167 public int getPhoneState() { 1168 return mPhoneState; 1169 } 1170 1171 public void reportFailedBiometricUnlockAttempt() { 1172 mFailedBiometricUnlockAttempts++; 1173 } 1174 1175 public boolean getMaxBiometricUnlockAttemptsReached() { 1176 return mFailedBiometricUnlockAttempts >= FAILED_BIOMETRIC_UNLOCK_ATTEMPTS_BEFORE_BACKUP; 1177 } 1178 1179 public boolean isAlternateUnlockEnabled() { 1180 return mAlternateUnlockEnabled; 1181 } 1182 1183 public void setAlternateUnlockEnabled(boolean enabled) { 1184 mAlternateUnlockEnabled = enabled; 1185 } 1186 1187 public boolean isSimLocked() { 1188 return isSimLocked(mSimState); 1189 } 1190 1191 public static boolean isSimLocked(IccCardConstants.State state) { 1192 return state == IccCardConstants.State.PIN_REQUIRED 1193 || state == IccCardConstants.State.PUK_REQUIRED 1194 || state == IccCardConstants.State.PERM_DISABLED; 1195 } 1196 1197 public boolean isSimPinSecure() { 1198 return isSimPinSecure(mSimState); 1199 } 1200 1201 public static boolean isSimPinSecure(IccCardConstants.State state) { 1202 final IccCardConstants.State simState = state; 1203 return (simState == IccCardConstants.State.PIN_REQUIRED 1204 || simState == IccCardConstants.State.PUK_REQUIRED 1205 || simState == IccCardConstants.State.PERM_DISABLED); 1206 } 1207 1208 public DisplayClientState getCachedDisplayClientState() { 1209 return mDisplayClientState; 1210 } 1211 1212 // TODO: use these callbacks elsewhere in place of the existing notifyScreen*() 1213 // (KeyguardViewMediator, KeyguardHostView) 1214 public void dispatchScreenTurnedOn() { 1215 synchronized (this) { 1216 mScreenOn = true; 1217 } 1218 mHandler.sendEmptyMessage(MSG_SCREEN_TURNED_ON); 1219 } 1220 1221 public void dispatchScreenTurndOff(int why) { 1222 synchronized(this) { 1223 mScreenOn = false; 1224 } 1225 mHandler.sendMessage(mHandler.obtainMessage(MSG_SCREEN_TURNED_OFF, why, 0)); 1226 } 1227 1228 public boolean isScreenOn() { 1229 return mScreenOn; 1230 } 1231 } 1232
