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