147b17975b8e5e5575edd998cf6de15914a93557
[android/platform/packages/apps/Phone.git] / src / com / android / phone / PhoneApp.java
1 /*
2  * Copyright (C) 2006 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.phone;
18
19
20
21 import android.app.Activity;
22 import android.app.Application;
23 import android.app.KeyguardManager;
24 import android.app.ProgressDialog;
25 import android.bluetooth.BluetoothHeadset;
26 import android.bluetooth.BluetoothIntent;
27 import android.content.BroadcastReceiver;
28 import android.content.ContentResolver;
29 import android.content.Context;
30 import android.content.Intent;
31 import android.content.IntentFilter;
32 import android.media.AudioManager;
33 import android.net.Uri;
34 import android.os.AsyncResult;
35 import android.os.Binder;
36 import android.os.Handler;
37 import android.os.IBinder;
38 import android.os.IPowerManager;
39 import android.os.LocalPowerManager;
40 import android.os.Message;
41 import android.os.PowerManager;
42 import android.os.RemoteException;
43 import android.os.ServiceManager;
44 import android.os.SystemClock;
45 import android.os.SystemProperties;
46 import android.preference.PreferenceManager;
47 import android.provider.Settings.System;
48 import android.util.Config;
49 import android.util.Log;
50 import android.view.KeyEvent;
51 import android.widget.Toast;
52
53 import com.android.internal.telephony.IccCard;
54 import com.android.internal.telephony.MmiCode;
55 import com.android.internal.telephony.Phone;
56 import com.android.internal.telephony.PhoneFactory;
57 import com.android.internal.telephony.TelephonyIntents;
58
59 /**
60  * Top-level Application class for the Phone app.
61  */
62 public class PhoneApp extends Application {
63     /* package */ static final String LOG_TAG = "PhoneApp";
64
65     /**
66      * Phone app-wide debug level:
67      *   0 - no debug logging
68      *   1 - normal debug logging if ro.debuggable is set (which is true in
69      *       "eng" and "userdebug" builds but not "user" builds)
70      *   2 - ultra-verbose debug logging
71      *
72      * Most individual classes in the phone app have a local DBG constant,
73      * typically set to
74      *   (PhoneApp.DBG_LEVEL >= 1) && (SystemProperties.getInt("ro.debuggable", 0) == 1)
75      * or else
76      *   (PhoneApp.DBG_LEVEL >= 2)
77      * depending on the desired verbosity.
78      */
79     /* package */ static final int DBG_LEVEL = 1;
80
81     private static final boolean DBG =
82             (PhoneApp.DBG_LEVEL >= 1) && (SystemProperties.getInt("ro.debuggable", 0) == 1);
83     private static final boolean VDBG = (PhoneApp.DBG_LEVEL >= 2);
84
85     // Message codes; see mHandler below.
86     private static final int EVENT_SIM_ABSENT = 1;
87     private static final int EVENT_SIM_LOCKED = 2;
88     private static final int EVENT_SIM_NETWORK_LOCKED = 3;
89     private static final int EVENT_WIRED_HEADSET_PLUG = 7;
90     private static final int EVENT_SIM_STATE_CHANGED = 8;
91     private static final int EVENT_UPDATE_INCALL_NOTIFICATION = 9;
92     private static final int EVENT_DATA_ROAMING_DISCONNECTED = 10;
93     private static final int EVENT_DATA_ROAMING_OK = 11;
94
95     // The MMI codes are also used by the InCallScreen.
96     public static final int MMI_INITIATE = 51;
97     public static final int MMI_COMPLETE = 52;
98     public static final int MMI_CANCEL = 53;
99     // Don't use message codes larger than 99 here; those are reserved for
100     // the individual Activities of the Phone UI.
101
102     /**
103      * Allowable values for the poke lock code (timeout between a user activity and the
104      * going to sleep), please refer to {@link com.android.server.PowerManagerService}
105      * for additional reference.
106      *   SHORT uses the short delay for the timeout (SHORT_KEYLIGHT_DELAY, 6 sec)
107      *   MEDIUM uses the medium delay for the timeout (MEDIUM_KEYLIGHT_DELAY, 15 sec)
108      *   DEFAULT is the system-wide default delay for the timeout (1 min)
109      */
110     public enum ScreenTimeoutDuration {
111         SHORT,
112         MEDIUM,
113         DEFAULT
114     }
115
116     /**
117      * Allowable values for the wake lock code.
118      *   SLEEP means the device can be put to sleep.
119      *   PARTIAL means wake the processor, but we display can be kept off.
120      *   FULL means wake both the processor and the display.
121      */
122     public enum WakeState {
123         SLEEP,
124         PARTIAL,
125         FULL
126     }
127
128     private static PhoneApp sMe;
129
130     // A few important fields we expose to the rest of the package
131     // directly (rather than thru set/get methods) for efficiency.
132     Phone phone;
133     CallNotifier notifier;
134     Ringer ringer;
135     BluetoothHandsfree mBtHandsfree;
136     PhoneInterfaceManager phoneMgr;
137     int mBluetoothHeadsetState = BluetoothHeadset.STATE_ERROR;
138     int mBluetoothHeadsetAudioState = BluetoothHeadset.STATE_ERROR;
139     boolean mShowBluetoothIndication = false;
140
141     // The InCallScreen instance (or null if the InCallScreen hasn't been
142     // created yet.)
143     private InCallScreen mInCallScreen;
144
145     // The currently-active PUK entry activity and progress dialog.
146     // Normally, these are the Emergency Dialer and the subsequent
147     // progress dialog.  null if there is are no such objects in
148     // the foreground.
149     private Activity mPUKEntryActivity;
150     private ProgressDialog mPUKEntryProgressDialog;
151
152     private boolean mIsSimPinEnabled;
153     private String mCachedSimPin;
154
155     // True if a wired headset is currently plugged in, based on the state
156     // from the latest Intent.ACTION_HEADSET_PLUG broadcast we received in
157     // mReceiver.onReceive().
158     private boolean mIsHeadsetPlugged;
159
160     private WakeState mWakeState = WakeState.SLEEP;
161     private ScreenTimeoutDuration mScreenTimeoutDuration = ScreenTimeoutDuration.DEFAULT;
162     private boolean mIgnoreTouchUserActivity = false;
163     private IBinder mPokeLockToken = new Binder();
164     private IPowerManager mPowerManagerService;
165     private PowerManager.WakeLock mWakeLock;
166     private PowerManager.WakeLock mPartialWakeLock;
167     private KeyguardManager mKeyguardManager;
168     private KeyguardManager.KeyguardLock mKeyguardLock;
169
170     // Broadcast receiver for various intent broadcasts (see onCreate())
171     private final BroadcastReceiver mReceiver = new PhoneAppBroadcastReceiver();
172
173     // Broadcast receiver purely for ACTION_MEDIA_BUTTON broadcasts
174     private final BroadcastReceiver mMediaButtonReceiver = new MediaButtonBroadcastReceiver();
175
176     /** boolean indicating restoring mute state on InCallScreen.onResume() */
177     private boolean mShouldRestoreMuteOnInCallResume;
178
179     /**
180      * Set the restore mute state flag. Used when we are setting the mute state
181      * OUTSIDE of user interaction {@link PhoneUtils#startNewCall(Phone)}
182      */
183     /*package*/void setRestoreMuteOnInCallResume (boolean mode) {
184         mShouldRestoreMuteOnInCallResume = mode;
185     }
186
187     /**
188      * Get the restore mute state flag.
189      * This is used by the InCallScreen {@link InCallScreen#onResume()} to figure
190      * out if we need to restore the mute state for the current active call.
191      */
192     /*package*/boolean getRestoreMuteOnInCallResume () {
193         return mShouldRestoreMuteOnInCallResume;
194     }
195
196     Handler mHandler = new Handler() {
197         @Override
198         public void handleMessage(Message msg) {
199             switch (msg.what) {
200                 case EVENT_SIM_LOCKED:
201 //                    mIsSimPinEnabled = true;
202 //
203 //                    if (Config.LOGV) Log.v(LOG_TAG, "show sim unlock panel");
204 //                    SimPinUnlockPanel pinUnlockPanel = new SimPinUnlockPanel(
205 //                            PhoneApp.getInstance());
206 //                    pinUnlockPanel.show();
207                     break;
208
209                 case EVENT_SIM_ABSENT:
210 // Don't need this now that the lock screen handles this case
211 //                    if (Config.LOGV) Log.v(LOG_TAG, "show sim missing panel");
212 //                    SimMissingPanel missingPanel = new SimMissingPanel(
213 //                            PhoneApp.getInstance());
214 //                    missingPanel.show();
215                     break;
216
217                 case EVENT_SIM_NETWORK_LOCKED:
218                     if (getResources().getBoolean(R.bool.ignore_sim_network_locked_events)) {
219                         // Some products don't have the concept of a "SIM network lock"
220                         Log.i(LOG_TAG, "Ignoring EVENT_SIM_NETWORK_LOCKED event; "
221                               + "not showing 'SIM network unlock' PIN entry screen");
222                     } else {
223                         // Normal case: show the "SIM network unlock" PIN entry screen.
224                         // The user won't be able to do anything else until
225                         // they enter a valid SIM network PIN.
226                         Log.i(LOG_TAG, "show sim depersonal panel");
227                         IccNetworkDepersonalizationPanel ndpPanel =
228                                 new IccNetworkDepersonalizationPanel(PhoneApp.getInstance());
229                         ndpPanel.show();
230                     }
231                     break;
232
233                 case EVENT_UPDATE_INCALL_NOTIFICATION:
234                     // Tell the NotificationMgr to update the "ongoing
235                     // call" icon in the status bar, if necessary.
236                     // Currently, this is triggered by a bluetooth headset
237                     // state change (since the status bar icon needs to
238                     // turn blue when bluetooth is active.)
239                     NotificationMgr.getDefault().updateInCallNotification();
240                     break;
241
242                 case EVENT_DATA_ROAMING_DISCONNECTED:
243                     NotificationMgr.getDefault().showDataDisconnectedRoaming();
244                     break;
245
246                 case EVENT_DATA_ROAMING_OK:
247                     NotificationMgr.getDefault().hideDataDisconnectedRoaming();
248                     break;
249
250                 case MMI_COMPLETE:
251                     onMMIComplete((AsyncResult) msg.obj);
252                     break;
253
254                 case MMI_CANCEL:
255                     PhoneUtils.cancelMmiCode(phone);
256                     break;
257
258                 case EVENT_WIRED_HEADSET_PLUG:
259                     // Since the presence of a wired headset or bluetooth affects the
260                     // speakerphone, update the "speaker" state.  We ONLY want to do
261                     // this on the wired headset connect / disconnect events for now
262                     // though, so we're only triggering on EVENT_WIRED_HEADSET_PLUG.
263                     if (!isHeadsetPlugged() &&
264                             (mBtHandsfree == null || !mBtHandsfree.isAudioOn())) {
265                         // is the state is "not connected", restore the speaker state.
266                         PhoneUtils.restoreSpeakerMode(getApplicationContext());
267                     }
268                     NotificationMgr.getDefault().updateSpeakerNotification();
269                     break;
270
271                 case EVENT_SIM_STATE_CHANGED:
272                     // Marks the event where the SIM goes into ready state.
273                     // Right now, this is only used for the PUK-unlocking
274                     // process.
275                     if (msg.obj.equals(IccCard.INTENT_VALUE_ICC_READY)) {
276                         // when the right event is triggered and there
277                         // are UI objects in the foreground, we close
278                         // them to display the lock panel.
279                         if (mPUKEntryActivity != null) {
280                             mPUKEntryActivity.finish();
281                             mPUKEntryActivity = null;
282                         }
283                         if (mPUKEntryProgressDialog != null) {
284                             mPUKEntryProgressDialog.dismiss();
285                             mPUKEntryProgressDialog = null;
286                         }
287                     }
288                     break;
289             }
290         }
291     };
292
293     public PhoneApp() {
294         sMe = this;
295     }
296
297     @Override
298     public void onCreate() {
299         if (Config.LOGV) Log.v(LOG_TAG, "onCreate()...");
300
301         ContentResolver resolver = getContentResolver();
302
303         if (phone == null) {
304             // Initialize the telephony framework
305             PhoneFactory.makeDefaultPhones(this);
306
307             // Get the default phone
308             phone = PhoneFactory.getDefaultPhone();
309
310             NotificationMgr.init(this);
311
312             phoneMgr = new PhoneInterfaceManager(this, phone);
313             if (getSystemService(Context.BLUETOOTH_SERVICE) != null) {
314                 mBtHandsfree = new BluetoothHandsfree(this, phone);
315                 startService(new Intent(this, BluetoothHeadsetService.class));
316             } else {
317                 // Device is not bluetooth capable
318                 mBtHandsfree = null;
319             }
320
321             ringer = new Ringer(phone);
322
323             // before registering for phone state changes
324             PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE);
325             mWakeLock = pm.newWakeLock(PowerManager.FULL_WAKE_LOCK
326                     | PowerManager.ACQUIRE_CAUSES_WAKEUP
327                     | PowerManager.ON_AFTER_RELEASE, LOG_TAG);
328             // lock used to keep the processor awake, when we don't care for the display.
329             mPartialWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK
330                     | PowerManager.ON_AFTER_RELEASE, LOG_TAG);
331             mKeyguardManager = (KeyguardManager) getSystemService(Context.KEYGUARD_SERVICE);
332             mKeyguardLock = mKeyguardManager.newKeyguardLock(LOG_TAG);
333
334             // get a handle to the service so that we can use it later when we
335             // want to set the poke lock.
336             mPowerManagerService = IPowerManager.Stub.asInterface(
337                     ServiceManager.getService("power"));
338
339             notifier = new CallNotifier(this, phone, ringer, mBtHandsfree);
340
341             // register for ICC status
342             IccCard sim = phone.getIccCard();
343             if (sim != null) {
344                 if (Config.LOGV) Log.v(LOG_TAG, "register for ICC status");
345                 sim.registerForAbsent(mHandler, EVENT_SIM_ABSENT, null);
346                 sim.registerForLocked(mHandler, EVENT_SIM_LOCKED, null);
347                 sim.registerForNetworkLocked(mHandler, EVENT_SIM_NETWORK_LOCKED, null);
348             }
349
350             // register for MMI/USSD
351             phone.registerForMmiComplete(mHandler, MMI_COMPLETE, null);
352
353             // register connection tracking to PhoneUtils
354             PhoneUtils.initializeConnectionHandler(phone);
355
356             // Register for misc other intent broadcasts.
357             IntentFilter intentFilter =
358                     new IntentFilter(Intent.ACTION_AIRPLANE_MODE_CHANGED);
359             intentFilter.addAction(BluetoothIntent.HEADSET_STATE_CHANGED_ACTION);
360             intentFilter.addAction(BluetoothIntent.HEADSET_AUDIO_STATE_CHANGED_ACTION);
361             intentFilter.addAction(TelephonyIntents.ACTION_ANY_DATA_CONNECTION_STATE_CHANGED);
362             intentFilter.addAction(Intent.ACTION_HEADSET_PLUG);
363             intentFilter.addAction(Intent.ACTION_BATTERY_LOW);
364             intentFilter.addAction(TelephonyIntents.ACTION_SIM_STATE_CHANGED);
365             intentFilter.addAction(TelephonyIntents.ACTION_RADIO_TECHNOLOGY_CHANGED);
366             registerReceiver(mReceiver, intentFilter);
367
368             // Use a separate receiver for ACTION_MEDIA_BUTTON broadcasts,
369             // since we need to manually adjust its priority (to make sure
370             // we get these intents *before* the media player.)
371             IntentFilter mediaButtonIntentFilter =
372                     new IntentFilter(Intent.ACTION_MEDIA_BUTTON);
373             //
374             // Make sure we're higher priority than the media player's
375             // MediaButtonIntentReceiver (which currently has the default
376             // priority of zero; see apps/Music/AndroidManifest.xml.)
377             mediaButtonIntentFilter.setPriority(1);
378             //
379             registerReceiver(mMediaButtonReceiver, mediaButtonIntentFilter);
380
381             //set the default values for the preferences in the phone.
382             PreferenceManager.setDefaultValues(this, R.xml.network_setting, false);
383             PreferenceManager.setDefaultValues(this, R.xml.call_feature_setting, false);
384
385             // Make sure the audio mode (along with some
386             // audio-mode-related state of our own) is initialized
387             // correctly, given the current state of the phone.
388             switch (phone.getState()) {
389                 case IDLE:
390                     if (DBG) Log.d(LOG_TAG, "Resetting audio state/mode: IDLE");
391                     PhoneUtils.setAudioControlState(PhoneUtils.AUDIO_IDLE);
392                     PhoneUtils.setAudioMode(this, AudioManager.MODE_NORMAL);
393                     break;
394                 case RINGING:
395                     if (DBG) Log.d(LOG_TAG, "Resetting audio state/mode: RINGING");
396                     PhoneUtils.setAudioControlState(PhoneUtils.AUDIO_RINGING);
397                     PhoneUtils.setAudioMode(this, AudioManager.MODE_RINGTONE);
398                     break;
399                 case OFFHOOK:
400                     if (DBG) Log.d(LOG_TAG, "Resetting audio state/mode: OFFHOOK");
401                     PhoneUtils.setAudioControlState(PhoneUtils.AUDIO_OFFHOOK);
402                     PhoneUtils.setAudioMode(this, AudioManager.MODE_IN_CALL);
403                     break;
404             }
405         }
406
407         // XXX pre-load the SimProvider so that it's ready
408         resolver.getType(Uri.parse("content://icc/adn"));
409
410         // start with the default value to set the mute state.
411         mShouldRestoreMuteOnInCallResume = false;
412    }
413
414     /**
415      * Returns the singleton instance of the PhoneApp.
416      */
417     static PhoneApp getInstance() {
418         return sMe;
419     }
420
421     Ringer getRinger() {
422         return ringer;
423     }
424
425     BluetoothHandsfree getBluetoothHandsfree() {
426         return mBtHandsfree;
427     }
428
429     static Intent createCallLogIntent() {
430         Intent  intent = new Intent(Intent.ACTION_VIEW, null);
431         intent.setType("vnd.android.cursor.dir/calls");
432         return intent;
433     }
434
435     /**
436      * Return an Intent that can be used to bring up the in-call screen.
437      *
438      * This intent can only be used from within the Phone app, since the
439      * InCallScreen is not exported from our AndroidManifest.
440      */
441     /* package */ static Intent createInCallIntent() {
442         Intent intent = new Intent(Intent.ACTION_MAIN, null);
443         intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK
444                 | Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS
445                 | Intent.FLAG_ACTIVITY_NO_USER_ACTION);
446         intent.setClassName("com.android.phone", getCallScreenClassName());
447         return intent;
448     }
449
450     /**
451      * Variation of createInCallIntent() that also specifies whether the
452      * DTMF dialpad should be initially visible when the InCallScreen
453      * comes up.
454      */
455     /* package */ static Intent createInCallIntent(boolean showDialpad) {
456         Intent intent = createInCallIntent();
457         intent.putExtra(InCallScreen.SHOW_DIALPAD_EXTRA, showDialpad);
458         return intent;
459     }
460
461     static String getCallScreenClassName() {
462         return InCallScreen.class.getName();
463     }
464
465     /**
466      * Starts the InCallScreen Activity.
467      */
468     void displayCallScreen() {
469         if (VDBG) Log.d(LOG_TAG, "displayCallScreen()...");
470         startActivity(createInCallIntent());
471         Profiler.callScreenRequested();
472     }
473
474     /**
475      * Helper function to check for one special feature of the CALL key:
476      * Normally, when the phone is idle, CALL takes you to the call log
477      * (see the handler for KEYCODE_CALL in PhoneWindow.onKeyUp().)
478      * But if the phone is in use (either off-hook or ringing) we instead
479      * handle the CALL button by taking you to the in-call UI.
480      *
481      * @return true if we intercepted the CALL keypress (i.e. the phone
482      *              was in use)
483      *
484      * @see DialerActivity#onCreate
485      */
486     boolean handleInCallOrRinging() {
487         if (phone.getState() != Phone.State.IDLE) {
488             // Phone is OFFHOOK or RINGING.
489             if (DBG) Log.v(LOG_TAG,
490                            "handleInCallOrRinging: show call screen");
491             displayCallScreen();
492             return true;
493         }
494         return false;
495     }
496
497     boolean isSimPinEnabled() {
498         return mIsSimPinEnabled;
499     }
500
501     boolean authenticateAgainstCachedSimPin(String pin) {
502         return (mCachedSimPin != null && mCachedSimPin.equals(pin));
503     }
504
505     void setCachedSimPin(String pin) {
506         mCachedSimPin = pin;
507     }
508
509     void setInCallScreenInstance(InCallScreen inCallScreen) {
510         mInCallScreen = inCallScreen;
511     }
512
513     /**
514      * @return true if the in-call UI is running as the foreground
515      * activity.  (In other words, from the perspective of the
516      * InCallScreen activity, return true between onResume() and
517      * onPause().)
518      *
519      * Note this method will return false if the screen is currently off,
520      * even if the InCallScreen *was* in the foreground just before the
521      * screen turned off.  (This is because the foreground activity is
522      * always "paused" while the screen is off.)
523      */
524     boolean isShowingCallScreen() {
525         if (mInCallScreen == null) return false;
526         return mInCallScreen.isForegroundActivity();
527     }
528
529     /**
530      * Dismisses the in-call UI.
531      *
532      * This also ensures that you won't be able to get back to the in-call
533      * UI via the BACK button (since this call removes the InCallScreen
534      * from the activity history.)
535      */
536     void dismissCallScreen() {
537         if (mInCallScreen != null) {
538             mInCallScreen.finish();
539         }
540     }
541
542     /**
543      * Sets the activity responsible for un-PUK-blocking the device
544      * so that we may close it when we receive a positive result.
545      * mPUKEntryActivity is also used to indicate to the device that
546      * we are trying to un-PUK-lock the phone. In other words, iff
547      * it is NOT null, then we are trying to unlock and waiting for
548      * the SIM to move to READY state.
549      *
550      * @param activity is the activity to close when PUK has
551      * finished unlocking. Can be set to null to indicate the unlock
552      * or SIM READYing process is over.
553      */
554     void setPukEntryActivity(Activity activity) {
555         mPUKEntryActivity = activity;
556     }
557
558     Activity getPUKEntryActivity() {
559         return mPUKEntryActivity;
560     }
561
562     /**
563      * Sets the dialog responsible for notifying the user of un-PUK-
564      * blocking - SIM READYing progress, so that we may dismiss it
565      * when we receive a positive result.
566      *
567      * @param dialog indicates the progress dialog informing the user
568      * of the state of the device.  Dismissed upon completion of
569      * READYing process
570      */
571     void setPukEntryProgressDialog(ProgressDialog dialog) {
572         mPUKEntryProgressDialog = dialog;
573     }
574
575     ProgressDialog getPUKEntryProgressDialog() {
576         return mPUKEntryProgressDialog;
577     }
578
579     /**
580      * Disables the keyguard.  This is used by the phone app to allow
581      * interaction with the Phone UI when the keyguard would otherwise be
582      * active (like receiving an incoming call while the device is
583      * locked.)
584      *
585      * Any call to this method MUST be followed (eventually)
586      * by a corresponding reenableKeyguard() call.
587      */
588     /* package */ void disableKeyguard() {
589         if (DBG) Log.d(LOG_TAG, "disable keyguard");
590         // if (DBG) Log.d(LOG_TAG, "disableKeyguard()...", new Throwable("stack dump"));
591         mKeyguardLock.disableKeyguard();
592     }
593
594     /**
595      * Re-enables the keyguard after a previous disableKeyguard() call.
596      *
597      * Any call to this method MUST correspond to (i.e. be balanced with)
598      * a previous disableKeyguard() call.
599      */
600     /* package */ void reenableKeyguard() {
601         if (DBG) Log.d(LOG_TAG, "re-enable keyguard");
602         // if (DBG) Log.d(LOG_TAG, "reenableKeyguard()...", new Throwable("stack dump"));
603         mKeyguardLock.reenableKeyguard();
604     }
605
606     /**
607      * Controls how quickly the screen times out.
608      *
609      * The poke lock controls how long it takes before the screen powers
610      * down, and therefore has no immediate effect when the current
611      * WakeState (see {@link PhoneApp#requestWakeState}) is FULL.
612      * If we're in a state where the screen *is* allowed to turn off,
613      * though, the poke lock will determine the timeout interval (long or
614      * short).
615      *
616      * @param shortPokeLock tells the device the timeout duration to use
617      * before going to sleep
618      * {@link com.android.server.PowerManagerService#SHORT_KEYLIGHT_DELAY}.
619      */
620     /* package */ void setScreenTimeout(ScreenTimeoutDuration duration) {
621         if (VDBG) Log.d(LOG_TAG, "setScreenTimeout(" + duration + ")...");
622
623         // make sure we don't set the poke lock repeatedly so that we
624         // avoid triggering the userActivity calls in
625         // PowerManagerService.setPokeLock().
626         if (duration == mScreenTimeoutDuration) {
627             return;
628         }
629         mScreenTimeoutDuration = duration;
630         updatePokeLock();
631     }
632
633     /**
634      * Update the state of the poke lock held by the phone app,
635      * based on the current desired screen timeout and the
636      * current "ignore user activity on touch" flag.
637      */
638     private void updatePokeLock() {
639         // This is kind of convoluted, but the basic thing to remember is
640         // that the poke lock just sends a message to the screen to tell
641         // it to stay on for a while.
642         // The default is 0, for a long timeout and should be set that way
643         // when we are heading back into a the keyguard / screen off
644         // state, and also when we're trying to keep the screen alive
645         // while ringing.  We'll also want to ignore the cheek events
646         // regardless of the timeout duration.
647         // The short timeout is really used whenever we want to give up
648         // the screen lock, such as when we're in call.
649         int pokeLockSetting = LocalPowerManager.POKE_LOCK_IGNORE_CHEEK_EVENTS;
650         switch (mScreenTimeoutDuration) {
651             case SHORT:
652                 // Set the poke lock to timeout the display after a short
653                 // timeout (5s). This ensures that the screen goes to sleep
654                 // as soon as acceptably possible after we the wake lock
655                 // has been released.
656                 pokeLockSetting |= LocalPowerManager.POKE_LOCK_SHORT_TIMEOUT;
657                 break;
658
659             case MEDIUM:
660                 // Set the poke lock to timeout the display after a medium
661                 // timeout (15s). This ensures that the screen goes to sleep
662                 // as soon as acceptably possible after we the wake lock
663                 // has been released.
664                 pokeLockSetting |= LocalPowerManager.POKE_LOCK_MEDIUM_TIMEOUT;
665                 break;
666
667             case DEFAULT:
668             default:
669                 // set the poke lock to timeout the display after a long
670                 // delay by default.
671                 // TODO: it may be nice to be able to disable cheek presses
672                 // for long poke locks (emergency dialer, for instance).
673                 break;
674         }
675
676         if (mIgnoreTouchUserActivity) {
677             pokeLockSetting |= LocalPowerManager.POKE_LOCK_IGNORE_TOUCH_AND_CHEEK_EVENTS;
678         }
679
680         // Send the request
681         try {
682             mPowerManagerService.setPokeLock(pokeLockSetting, mPokeLockToken, LOG_TAG);
683         } catch (RemoteException e) {
684             Log.w(LOG_TAG, "mPowerManagerService.setPokeLock() failed: " + e);
685         }
686     }
687
688     /**
689      * Controls whether or not the screen is allowed to sleep.
690      *
691      * Once sleep is allowed (WakeState is SLEEP), it will rely on the
692      * settings for the poke lock to determine when to timeout and let
693      * the device sleep {@link PhoneApp#setScreenTimeout}.
694      *
695      * @param ws tells the device to how to wake.
696      */
697     /* package */ void requestWakeState(WakeState ws) {
698         if (VDBG) Log.d(LOG_TAG, "requestWakeState(" + ws + ")...");
699         if (mWakeState != ws) {
700             switch (ws) {
701                 case PARTIAL:
702                     // acquire the processor wake lock, and release the FULL
703                     // lock if it is being held.
704                     mPartialWakeLock.acquire();
705                     if (mWakeLock.isHeld()) {
706                         mWakeLock.release();
707                     }
708                     break;
709                 case FULL:
710                     // acquire the full wake lock, and release the PARTIAL
711                     // lock if it is being held.
712                     mWakeLock.acquire();
713                     if (mPartialWakeLock.isHeld()) {
714                         mPartialWakeLock.release();
715                     }
716                     break;
717                 case SLEEP:
718                 default:
719                     // release both the PARTIAL and FULL locks.
720                     if (mWakeLock.isHeld()) {
721                         mWakeLock.release();
722                     }
723                     if (mPartialWakeLock.isHeld()) {
724                         mPartialWakeLock.release();
725                     }
726                     break;
727             }
728             mWakeState = ws;
729         }
730     }
731
732     /**
733      * If we are not currently keeping the screen on, then poke the power
734      * manager to wake up the screen for the user activity timeout duration.
735      */
736     /* package */ void wakeUpScreen() {
737         if (mWakeState == WakeState.SLEEP) {
738             if (DBG) Log.d(LOG_TAG, "pulse screen lock");
739             try {
740                 mPowerManagerService.userActivityWithForce(SystemClock.uptimeMillis(), false, true);
741             } catch (RemoteException ex) {
742                 // Ignore -- the system process is dead.
743             }
744         }
745     }
746
747     /**
748      * Sets the wake state and screen timeout based on the current state
749      * of the phone, and the current state of the in-call UI.
750      *
751      * This method is a "UI Policy" wrapper around
752      * {@link PhoneApp#requestWakeState} and {@link PhoneApp#setScreenTimeout}.
753      *
754      * It's safe to call this method regardless of the state of the Phone
755      * (e.g. whether or not it's idle), and regardless of the state of the
756      * Phone UI (e.g. whether or not the InCallScreen is active.)
757      */
758     /* package */ void updateWakeState() {
759         Phone.State state = phone.getState();
760
761         // True if the in-call UI is the foreground activity.
762         // (Note this will be false if the screen is currently off,
763         // since in that case *no* activity is in the foreground.)
764         boolean isShowingCallScreen = isShowingCallScreen();
765
766         // True if the InCallScreen's DTMF dialer is currently opened.
767         // (Note this does NOT imply whether or not the InCallScreen
768         // itself is visible.)
769         boolean isDialerOpened = (mInCallScreen != null) && mInCallScreen.isDialerOpened();
770
771         // True if the speakerphone is in use.  (If so, we *always* use
772         // the default timeout.  Since the user is obviously not holding
773         // the phone up to his/her face, we don't need to worry about
774         // false touches, and thus don't need to turn the screen off so
775         // aggressively.)
776         // Note that we need to make a fresh call to this method any
777         // time the speaker state changes.  (That happens in
778         // PhoneUtils.turnOnSpeaker().)
779         boolean isSpeakerInUse = (state == Phone.State.OFFHOOK) && PhoneUtils.isSpeakerOn(this);
780
781         // TODO (bug 1440854): The screen timeout *might* also need to
782         // depend on the bluetooth state, but this isn't as clear-cut as
783         // the speaker state (since while using BT it's common for the
784         // user to put the phone straight into a pocket, in which case the
785         // timeout should probably still be short.)
786
787         if (DBG) Log.d(LOG_TAG, "updateWakeState: callscreen " + isShowingCallScreen
788                        + ", dialer " + isDialerOpened
789                        + ", speaker " + isSpeakerInUse + "...");
790
791         //
792         // (1) Set the screen timeout.
793         //
794         // Note that the "screen timeout" value we determine here is
795         // meaningless if the screen is forced on (see (2) below.)
796         //
797         if (!isShowingCallScreen || isSpeakerInUse) {
798             // Use the system-wide default timeout.
799             setScreenTimeout(ScreenTimeoutDuration.DEFAULT);
800         } else {
801             // We're on the in-call screen, and *not* using the speakerphone.
802             if (isDialerOpened) {
803                 // The DTMF dialpad is up.  This case is special because
804                 // the in-call UI has its own "touch lock" mechanism to
805                 // disable the dialpad after a very short amount of idle
806                 // time (to avoid false touches from the user's face while
807                 // in-call.)
808                 //
809                 // In this case the *physical* screen just uses the
810                 // system-wide default timeout.
811                 setScreenTimeout(ScreenTimeoutDuration.DEFAULT);
812             } else {
813                 // We're on the in-call screen, and not using the DTMF dialpad.
814                 // There's actually no touchable UI onscreen at all in
815                 // this state.  Also, the user is (most likely) not
816                 // looking at the screen at all, since they're probably
817                 // holding the phone up to their face.  Here we use a
818                 // special screen timeout value specific to the in-call
819                 // screen, purely to save battery life.
820                 setScreenTimeout(ScreenTimeoutDuration.MEDIUM);
821             }
822         }
823
824         //
825         // (2) Decide whether to force the screen on or not.
826         //
827         // Force the screen to be on if the phone is ringing, or if we're
828         // displaying the "Call ended" UI for a connection in the
829         // "disconnected" state.
830         //
831         boolean isRinging = (state == Phone.State.RINGING);
832         boolean showingDisconnectedConnection =
833                 PhoneUtils.hasDisconnectedConnections(phone) && isShowingCallScreen;
834         boolean keepScreenOn = isRinging || showingDisconnectedConnection;
835         if (DBG) Log.d(LOG_TAG, "updateWakeState: keepScreenOn = " + keepScreenOn
836                        + " (isRinging " + isRinging
837                        + ", showingDisc " + showingDisconnectedConnection + ")");
838         // keepScreenOn == true means we'll hold a full wake lock:
839         requestWakeState(keepScreenOn ? WakeState.FULL : WakeState.SLEEP);
840     }
841
842     /**
843      * Wrapper around the PowerManagerService.preventScreenOn() API.
844      * This allows the in-call UI to prevent the screen from turning on
845      * even if a subsequent call to updateWakeState() causes us to acquire
846      * a full wake lock.
847      */
848     /* package */ void preventScreenOn(boolean prevent) {
849         if (VDBG) Log.d(LOG_TAG, "- preventScreenOn(" + prevent + ")...");
850         try {
851             mPowerManagerService.preventScreenOn(prevent);
852         } catch (RemoteException e) {
853             Log.w(LOG_TAG, "mPowerManagerService.preventScreenOn() failed: " + e);
854         }
855     }
856
857     /**
858      * Sets or clears the flag that tells the PowerManager that touch
859      * (and cheek) events should NOT be considered "user activity".
860      *
861      * Since the in-call UI is totally insensitive to touch in most
862      * states, we set this flag whenever the InCallScreen is in the
863      * foreground.  (Otherwise, repeated unintentional touches could
864      * prevent the device from going to sleep.)
865      *
866      * There *are* some some touch events that really do count as user
867      * activity, though.  For those, we need to manually poke the
868      * PowerManager's userActivity method; see pokeUserActivity().
869      */
870     /* package */ void setIgnoreTouchUserActivity(boolean ignore) {
871         if (VDBG) Log.d(LOG_TAG, "setIgnoreTouchUserActivity(" + ignore + ")...");
872         mIgnoreTouchUserActivity = ignore;
873         updatePokeLock();
874     }
875
876     /**
877      * Manually pokes the PowerManager's userActivity method.  Since we
878      * hold the POKE_LOCK_IGNORE_TOUCH_AND_CHEEK_EVENTS poke lock while
879      * the InCallScreen is active, we need to do this for touch events
880      * that really do count as user activity (like DTMF key presses, or
881      * unlocking the "touch lock" overlay.)
882      */
883     /* package */ void pokeUserActivity() {
884         if (VDBG) Log.d(LOG_TAG, "pokeUserActivity()...");
885         try {
886             mPowerManagerService.userActivity(SystemClock.uptimeMillis(), false);
887         } catch (RemoteException e) {
888             Log.w(LOG_TAG, "mPowerManagerService.userActivity() failed: " + e);
889         }
890     }
891
892     KeyguardManager getKeyguardManager() {
893         return mKeyguardManager;
894     }
895
896     private void onMMIComplete(AsyncResult r) {
897         if (VDBG) Log.d(LOG_TAG, "onMMIComplete()...");
898         MmiCode mmiCode = (MmiCode) r.result;
899         PhoneUtils.displayMMIComplete(phone, getInstance(), mmiCode, null, null);
900     }
901
902     private void initForNewRadioTechnology() {
903         if(DBG) Log.d(LOG_TAG, "initForNewRadioTechnology...");
904
905         ringer.updateRingerContextAfterRadioTechnologyChange(this.phone);
906         notifier.updateCallNotifierRegistrationsAfterRadioTechnologyChange();
907         if(mBtHandsfree != null) {
908             mBtHandsfree.updateBtHandsfreeAfterRadioTechnologyChange();
909         }
910
911         //Update registration for ICC status after radio technology change
912         IccCard sim = phone.getIccCard();
913         if (sim != null) {
914             if(DBG) Log.d(LOG_TAG, "Update registration for ICC status...");
915
916             //Register all events new to the new active phone
917             sim.registerForAbsent(mHandler, EVENT_SIM_ABSENT, null);
918             sim.registerForLocked(mHandler, EVENT_SIM_LOCKED, null);
919             sim.registerForNetworkLocked(mHandler, EVENT_SIM_NETWORK_LOCKED, null);
920         }
921     }
922
923     /**
924      * @return true if a wired headset is currently plugged in.
925      *
926      * @see Intent.ACTION_HEADSET_PLUG (which we listen for in mReceiver.onReceive())
927      */
928     boolean isHeadsetPlugged() {
929         return mIsHeadsetPlugged;
930     }
931
932     /**
933      * @return true if the onscreen UI should currently be showing the
934      * special "bluetooth is active" indication in a couple of places (in
935      * which UI elements turn blue and/or show the bluetooth logo.)
936      *
937      * This depends on the BluetoothHeadset state *and* the current
938      * telephony state; see shouldShowBluetoothIndication().
939      *
940      * @see CallCard
941      * @see NotificationMgr.updateInCallNotification
942      */
943     /* package */ boolean showBluetoothIndication() {
944         return mShowBluetoothIndication;
945     }
946
947     /**
948      * Recomputes the mShowBluetoothIndication flag based on the current
949      * bluetooth state and current telephony state.
950      *
951      * This needs to be called any time the bluetooth headset state or the
952      * telephony state changes.
953      *
954      * @param forceUiUpdate if true, force the UI elements that care
955      *                      about this flag to update themselves.
956      */
957     /* package */ void updateBluetoothIndication(boolean forceUiUpdate) {
958         mShowBluetoothIndication = shouldShowBluetoothIndication(mBluetoothHeadsetState,
959                                                                  mBluetoothHeadsetAudioState,
960                                                                  phone);
961         if (forceUiUpdate) {
962             // Post Handler messages to the various components that might
963             // need to be refreshed based on the new state.
964             if (isShowingCallScreen()) mInCallScreen.updateBluetoothIndication();
965             mHandler.sendEmptyMessage(EVENT_UPDATE_INCALL_NOTIFICATION);
966         }
967     }
968
969     /**
970      * UI policy helper function for the couple of places in the UI that
971      * have some way of indicating that "bluetooth is in use."
972      *
973      * @return true if the onscreen UI should indicate that "bluetooth is in use",
974      *         based on the specified bluetooth headset state, and the
975      *         current state of the phone.
976      * @see showBluetoothIndication()
977      */
978     private static boolean shouldShowBluetoothIndication(int bluetoothState,
979                                                          int bluetoothAudioState,
980                                                          Phone phone) {
981         // We want the UI to indicate that "bluetooth is in use" in two
982         // slightly different cases:
983         //
984         // (a) The obvious case: if a bluetooth headset is currently in
985         //     use for an ongoing call.
986         //
987         // (b) The not-so-obvious case: if an incoming call is ringing,
988         //     and we expect that audio *will* be routed to a bluetooth
989         //     headset once the call is answered.
990
991         switch (phone.getState()) {
992             case OFFHOOK:
993                 // This covers normal active calls, and also the case if
994                 // the foreground call is DIALING or ALERTING.  In this
995                 // case, bluetooth is considered "active" if a headset
996                 // is connected *and* audio is being routed to it.
997                 return ((bluetoothState == BluetoothHeadset.STATE_CONNECTED)
998                         && (bluetoothAudioState == BluetoothHeadset.AUDIO_STATE_CONNECTED));
999
1000             case RINGING:
1001                 // If an incoming call is ringing, we're *not* yet routing
1002                 // audio to the headset (since there's no in-call audio
1003                 // yet!)  In this case, if a bluetooth headset is
1004                 // connected at all, we assume that it'll become active
1005                 // once the user answers the phone.
1006                 return (bluetoothState == BluetoothHeadset.STATE_CONNECTED);
1007
1008             default:  // Presumably IDLE
1009                 return false;
1010         }
1011     }
1012
1013
1014     /**
1015      * Receiver for misc intent broadcasts the Phone app cares about.
1016      */
1017     private class PhoneAppBroadcastReceiver extends BroadcastReceiver {
1018         @Override
1019         public void onReceive(Context context, Intent intent) {
1020             String action = intent.getAction();
1021             if (action.equals(Intent.ACTION_AIRPLANE_MODE_CHANGED)) {
1022                 boolean enabled = System.getInt(getContentResolver(),
1023                         System.AIRPLANE_MODE_ON, 0) == 0;
1024                 phone.setRadioPower(enabled);
1025             } else if (action.equals(BluetoothIntent.HEADSET_STATE_CHANGED_ACTION)) {
1026                 mBluetoothHeadsetState = intent.getIntExtra(BluetoothIntent.HEADSET_STATE,
1027                                                             BluetoothHeadset.STATE_ERROR);
1028                 if (VDBG) Log.d(LOG_TAG, "mReceiver: HEADSET_STATE_CHANGED_ACTION");
1029                 if (VDBG) Log.d(LOG_TAG, "==> new state: " + mBluetoothHeadsetState);
1030                 updateBluetoothIndication(true);  // Also update any visible UI if necessary
1031             } else if (action.equals(BluetoothIntent.HEADSET_AUDIO_STATE_CHANGED_ACTION)) {
1032                 mBluetoothHeadsetAudioState =
1033                         intent.getIntExtra(BluetoothIntent.HEADSET_AUDIO_STATE,
1034                                            BluetoothHeadset.STATE_ERROR);
1035                 if (VDBG) Log.d(LOG_TAG, "mReceiver: HEADSET_AUDIO_STATE_CHANGED_ACTION");
1036                 if (VDBG) Log.d(LOG_TAG, "==> new state: " + mBluetoothHeadsetAudioState);
1037                 updateBluetoothIndication(true);  // Also update any visible UI if necessary
1038             } else if (action.equals(TelephonyIntents.ACTION_ANY_DATA_CONNECTION_STATE_CHANGED)) {
1039                 // if (DBG) Log.d(LOG_TAG, "mReceiver: ACTION_ANY_DATA_CONNECTION_STATE_CHANGED");
1040                 // if (DBG) Log.d(LOG_TAG, "- state: " + intent.getStringExtra(Phone.STATE_KEY));
1041                 // if (DBG) Log.d(LOG_TAG, "- reason: "
1042                 //                + intent.getStringExtra(Phone.STATE_CHANGE_REASON_KEY));
1043
1044                 // The "data disconnected due to roaming" notification is
1045                 // visible if you've lost data connectivity because you're
1046                 // roaming and you have the "data roaming" feature turned off.
1047                 boolean disconnectedDueToRoaming = false;
1048                 if ("DISCONNECTED".equals(intent.getStringExtra(Phone.STATE_KEY))) {
1049                     String reason = intent.getStringExtra(Phone.STATE_CHANGE_REASON_KEY);
1050                     if (Phone.REASON_ROAMING_ON.equals(reason)) {
1051                         // We just lost our data connection, and the reason
1052                         // is that we started roaming.  This implies that
1053                         // the user has data roaming turned off.
1054                         disconnectedDueToRoaming = true;
1055                     }
1056                 }
1057                 mHandler.sendEmptyMessage(disconnectedDueToRoaming
1058                                           ? EVENT_DATA_ROAMING_DISCONNECTED
1059                                           : EVENT_DATA_ROAMING_OK);
1060             } else if (action.equals(Intent.ACTION_HEADSET_PLUG)) {
1061                 if (VDBG) Log.d(LOG_TAG, "mReceiver: ACTION_HEADSET_PLUG");
1062                 if (VDBG) Log.d(LOG_TAG, "    state: " + intent.getIntExtra("state", 0));
1063                 if (VDBG) Log.d(LOG_TAG, "    name: " + intent.getStringExtra("name"));
1064                 mIsHeadsetPlugged = (intent.getIntExtra("state", 0) == 1);
1065                 mHandler.sendMessage(mHandler.obtainMessage(EVENT_WIRED_HEADSET_PLUG, 0));
1066             } else if (action.equals(Intent.ACTION_BATTERY_LOW)) {
1067                 if (VDBG) Log.d(LOG_TAG, "mReceiver: ACTION_BATTERY_LOW");
1068                 notifier.sendBatteryLow();  // Play a warning tone if in-call
1069             } else if ((action.equals(TelephonyIntents.ACTION_SIM_STATE_CHANGED)) &&
1070                     (mPUKEntryActivity != null)) {
1071                 // if an attempt to un-PUK-lock the device was made, while we're
1072                 // receiving this state change notification, notify the handler.
1073                 // NOTE: This is ONLY triggered if an attempt to un-PUK-lock has
1074                 // been attempted.
1075                 mHandler.sendMessage(mHandler.obtainMessage(EVENT_SIM_STATE_CHANGED,
1076                         intent.getStringExtra(IccCard.INTENT_KEY_ICC_STATE)));
1077             } else if (action.equals(TelephonyIntents.ACTION_RADIO_TECHNOLOGY_CHANGED)) {
1078                 String newPhone = intent.getStringExtra(Phone.PHONE_NAME_KEY);
1079                 Log.d(LOG_TAG, "Radio technology switched. Now " + newPhone + " is active.");
1080                 initForNewRadioTechnology();
1081             }
1082         }
1083     }
1084
1085     /**
1086      * Broadcast receiver for the ACTION_MEDIA_BUTTON broadcast intent.
1087      *
1088      * This functionality isn't lumped in with the other intents in
1089      * PhoneAppBroadcastReceiver because we instantiate this as a totally
1090      * separate BroadcastReceiver instance, since we need to manually
1091      * adjust its IntentFilter's priority (to make sure we get these
1092      * intents *before* the media player.)
1093      */
1094     private class MediaButtonBroadcastReceiver extends BroadcastReceiver {
1095         @Override
1096         public void onReceive(Context context, Intent intent) {
1097             KeyEvent event = (KeyEvent) intent.getParcelableExtra(Intent.EXTRA_KEY_EVENT);
1098             if (VDBG) Log.d(LOG_TAG,
1099                            "MediaButtonBroadcastReceiver.onReceive()...  event = " + event);
1100             if ((event != null)
1101                 && (event.getKeyCode() == KeyEvent.KEYCODE_HEADSETHOOK)
1102                 && (event.getAction() == KeyEvent.ACTION_DOWN)) {
1103
1104                 if (event.getRepeatCount() == 0) {
1105                     // Mute ONLY on the initial keypress.
1106                     if (VDBG) Log.d(LOG_TAG, "MediaButtonBroadcastReceiver: HEADSETHOOK down!");
1107                     boolean consumed = PhoneUtils.handleHeadsetHook(phone);
1108                     if (VDBG) Log.d(LOG_TAG, "==> handleHeadsetHook(): consumed = " + consumed);
1109                     if (consumed) {
1110                         abortBroadcast();
1111                     }
1112                 } else if (phone.getState() != Phone.State.IDLE) {
1113                     // As for any DOWN events other than the initial press, we consume
1114                     // (and ignore) those too if the phone is in use.  (Otherwise the
1115                     // music player will handle them, which would be confusing.)
1116                     abortBroadcast();
1117                 }
1118             }
1119         }
1120     }
1121 }