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