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