| /* |
| * Copyright (C) 2006 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package com.android.phone; |
| |
| import android.app.Activity; |
| import android.app.Application; |
| import android.app.KeyguardManager; |
| import android.app.ProgressDialog; |
| import android.app.StatusBarManager; |
| import android.bluetooth.BluetoothAdapter; |
| import android.bluetooth.BluetoothHeadset; |
| import android.content.BroadcastReceiver; |
| import android.content.ContentResolver; |
| import android.content.Context; |
| import android.content.Intent; |
| import android.content.IntentFilter; |
| import android.content.res.Configuration; |
| import android.media.AudioManager; |
| import android.net.Uri; |
| import android.os.AsyncResult; |
| import android.os.Binder; |
| import android.os.Handler; |
| import android.os.IBinder; |
| import android.os.IPowerManager; |
| import android.os.LocalPowerManager; |
| import android.os.Message; |
| import android.os.PowerManager; |
| import android.os.RemoteException; |
| import android.os.ServiceManager; |
| import android.os.SystemClock; |
| import android.os.SystemProperties; |
| import android.preference.PreferenceManager; |
| import android.provider.Settings.System; |
| import android.telephony.ServiceState; |
| import android.util.Config; |
| import android.util.Log; |
| import android.view.KeyEvent; |
| import android.widget.Toast; |
| |
| import com.android.internal.telephony.Call; |
| import com.android.internal.telephony.IccCard; |
| import com.android.internal.telephony.MmiCode; |
| import com.android.internal.telephony.Phone; |
| import com.android.internal.telephony.PhoneFactory; |
| import com.android.internal.telephony.TelephonyIntents; |
| import com.android.internal.telephony.cdma.EriInfo; |
| import com.android.phone.OtaUtils.CdmaOtaScreenState; |
| |
| /** |
| * Top-level Application class for the Phone app. |
| */ |
| public class PhoneApp extends Application { |
| /* package */ static final String LOG_TAG = "PhoneApp"; |
| |
| /** |
| * Phone app-wide debug level: |
| * 0 - no debug logging |
| * 1 - normal debug logging if ro.debuggable is set (which is true in |
| * "eng" and "userdebug" builds but not "user" builds) |
| * 2 - ultra-verbose debug logging |
| * |
| * Most individual classes in the phone app have a local DBG constant, |
| * typically set to |
| * (PhoneApp.DBG_LEVEL >= 1) && (SystemProperties.getInt("ro.debuggable", 0) == 1) |
| * or else |
| * (PhoneApp.DBG_LEVEL >= 2) |
| * depending on the desired verbosity. |
| */ |
| /* package */ static final int DBG_LEVEL = 1; |
| |
| private static final boolean DBG = |
| (PhoneApp.DBG_LEVEL >= 1) && (SystemProperties.getInt("ro.debuggable", 0) == 1); |
| private static final boolean VDBG = (PhoneApp.DBG_LEVEL >= 2); |
| |
| // Message codes; see mHandler below. |
| private static final int EVENT_SIM_ABSENT = 1; |
| private static final int EVENT_SIM_LOCKED = 2; |
| private static final int EVENT_SIM_NETWORK_LOCKED = 3; |
| private static final int EVENT_WIRED_HEADSET_PLUG = 7; |
| private static final int EVENT_SIM_STATE_CHANGED = 8; |
| private static final int EVENT_UPDATE_INCALL_NOTIFICATION = 9; |
| private static final int EVENT_DATA_ROAMING_DISCONNECTED = 10; |
| private static final int EVENT_DATA_ROAMING_OK = 11; |
| private static final int EVENT_UNSOL_CDMA_INFO_RECORD = 12; |
| |
| // The MMI codes are also used by the InCallScreen. |
| public static final int MMI_INITIATE = 51; |
| public static final int MMI_COMPLETE = 52; |
| public static final int MMI_CANCEL = 53; |
| // Don't use message codes larger than 99 here; those are reserved for |
| // the individual Activities of the Phone UI. |
| |
| /** |
| * Allowable values for the poke lock code (timeout between a user activity and the |
| * going to sleep), please refer to {@link com.android.server.PowerManagerService} |
| * for additional reference. |
| * SHORT uses the short delay for the timeout (SHORT_KEYLIGHT_DELAY, 6 sec) |
| * MEDIUM uses the medium delay for the timeout (MEDIUM_KEYLIGHT_DELAY, 15 sec) |
| * DEFAULT is the system-wide default delay for the timeout (1 min) |
| */ |
| public enum ScreenTimeoutDuration { |
| SHORT, |
| MEDIUM, |
| DEFAULT |
| } |
| |
| /** |
| * Allowable values for the wake lock code. |
| * SLEEP means the device can be put to sleep. |
| * PARTIAL means wake the processor, but we display can be kept off. |
| * FULL means wake both the processor and the display. |
| */ |
| public enum WakeState { |
| SLEEP, |
| PARTIAL, |
| FULL |
| } |
| |
| private static PhoneApp sMe; |
| |
| // A few important fields we expose to the rest of the package |
| // directly (rather than thru set/get methods) for efficiency. |
| Phone phone; |
| CallNotifier notifier; |
| Ringer ringer; |
| BluetoothHandsfree mBtHandsfree; |
| PhoneInterfaceManager phoneMgr; |
| int mBluetoothHeadsetState = BluetoothHeadset.STATE_ERROR; |
| int mBluetoothHeadsetAudioState = BluetoothHeadset.STATE_ERROR; |
| boolean mShowBluetoothIndication = false; |
| |
| // Internal PhoneApp Call state tracker |
| CdmaPhoneCallState cdmaPhoneCallState; |
| |
| // The InCallScreen instance (or null if the InCallScreen hasn't been |
| // created yet.) |
| private InCallScreen mInCallScreen; |
| |
| // The currently-active PUK entry activity and progress dialog. |
| // Normally, these are the Emergency Dialer and the subsequent |
| // progress dialog. null if there is are no such objects in |
| // the foreground. |
| private Activity mPUKEntryActivity; |
| private ProgressDialog mPUKEntryProgressDialog; |
| |
| private boolean mIsSimPinEnabled; |
| private String mCachedSimPin; |
| |
| // True if a wired headset is currently plugged in, based on the state |
| // from the latest Intent.ACTION_HEADSET_PLUG broadcast we received in |
| // mReceiver.onReceive(). |
| private boolean mIsHeadsetPlugged; |
| |
| // True if the keyboard is currently *not* hidden |
| // Gets updated whenever there is a Configuration change |
| private boolean mIsHardKeyboardOpen; |
| |
| // True if we are beginning a call, but the phone state has not changed yet |
| private boolean mBeginningCall; |
| |
| // Last phone state seen by updatePhoneState() |
| Phone.State mLastPhoneState = Phone.State.IDLE; |
| |
| private WakeState mWakeState = WakeState.SLEEP; |
| private ScreenTimeoutDuration mScreenTimeoutDuration = ScreenTimeoutDuration.DEFAULT; |
| private boolean mIgnoreTouchUserActivity = false; |
| private IBinder mPokeLockToken = new Binder(); |
| private IPowerManager mPowerManagerService; |
| private PowerManager.WakeLock mWakeLock; |
| private PowerManager.WakeLock mPartialWakeLock; |
| private PowerManager.WakeLock mProximityWakeLock; |
| private KeyguardManager mKeyguardManager; |
| private KeyguardManager.KeyguardLock mKeyguardLock; |
| private int mKeyguardDisableCount; |
| private StatusBarManager mStatusBarManager; |
| |
| // Broadcast receiver for various intent broadcasts (see onCreate()) |
| private final BroadcastReceiver mReceiver = new PhoneAppBroadcastReceiver(); |
| |
| // Broadcast receiver purely for ACTION_MEDIA_BUTTON broadcasts |
| private final BroadcastReceiver mMediaButtonReceiver = new MediaButtonBroadcastReceiver(); |
| |
| /** boolean indicating restoring mute state on InCallScreen.onResume() */ |
| private boolean mShouldRestoreMuteOnInCallResume; |
| |
| // Following are the CDMA OTA information Objects used during OTA Call. |
| // cdmaOtaProvisionData object store static OTA information that needs |
| // to be maintained even during Slider open/close scenarios. |
| // cdmaOtaConfigData object stores configuration info to control visiblity |
| // of each OTA Screens. |
| // cdmaOtaScreenState object store OTA Screen State information. |
| public OtaUtils.CdmaOtaProvisionData cdmaOtaProvisionData; |
| public OtaUtils.CdmaOtaConfigData cdmaOtaConfigData; |
| public OtaUtils.CdmaOtaScreenState cdmaOtaScreenState; |
| public OtaUtils.CdmaOtaInCallScreenUiState cdmaOtaInCallScreenUiState; |
| |
| /** |
| * Set the restore mute state flag. Used when we are setting the mute state |
| * OUTSIDE of user interaction {@link PhoneUtils#startNewCall(Phone)} |
| */ |
| /*package*/void setRestoreMuteOnInCallResume (boolean mode) { |
| mShouldRestoreMuteOnInCallResume = mode; |
| } |
| |
| /** |
| * Get the restore mute state flag. |
| * This is used by the InCallScreen {@link InCallScreen#onResume()} to figure |
| * out if we need to restore the mute state for the current active call. |
| */ |
| /*package*/boolean getRestoreMuteOnInCallResume () { |
| return mShouldRestoreMuteOnInCallResume; |
| } |
| |
| Handler mHandler = new Handler() { |
| @Override |
| public void handleMessage(Message msg) { |
| switch (msg.what) { |
| case EVENT_SIM_LOCKED: |
| // mIsSimPinEnabled = true; |
| // |
| // if (Config.LOGV) Log.v(LOG_TAG, "show sim unlock panel"); |
| // SimPinUnlockPanel pinUnlockPanel = new SimPinUnlockPanel( |
| // PhoneApp.getInstance()); |
| // pinUnlockPanel.show(); |
| break; |
| |
| case EVENT_SIM_ABSENT: |
| // Don't need this now that the lock screen handles this case |
| // if (Config.LOGV) Log.v(LOG_TAG, "show sim missing panel"); |
| // SimMissingPanel missingPanel = new SimMissingPanel( |
| // PhoneApp.getInstance()); |
| // missingPanel.show(); |
| break; |
| |
| case EVENT_SIM_NETWORK_LOCKED: |
| if (getResources().getBoolean(R.bool.ignore_sim_network_locked_events)) { |
| // Some products don't have the concept of a "SIM network lock" |
| Log.i(LOG_TAG, "Ignoring EVENT_SIM_NETWORK_LOCKED event; " |
| + "not showing 'SIM network unlock' PIN entry screen"); |
| } else { |
| // Normal case: show the "SIM network unlock" PIN entry screen. |
| // The user won't be able to do anything else until |
| // they enter a valid SIM network PIN. |
| Log.i(LOG_TAG, "show sim depersonal panel"); |
| IccNetworkDepersonalizationPanel ndpPanel = |
| new IccNetworkDepersonalizationPanel(PhoneApp.getInstance()); |
| ndpPanel.show(); |
| } |
| break; |
| |
| case EVENT_UPDATE_INCALL_NOTIFICATION: |
| // Tell the NotificationMgr to update the "ongoing |
| // call" icon in the status bar, if necessary. |
| // Currently, this is triggered by a bluetooth headset |
| // state change (since the status bar icon needs to |
| // turn blue when bluetooth is active.) |
| NotificationMgr.getDefault().updateInCallNotification(); |
| break; |
| |
| case EVENT_DATA_ROAMING_DISCONNECTED: |
| NotificationMgr.getDefault().showDataDisconnectedRoaming(); |
| break; |
| |
| case EVENT_DATA_ROAMING_OK: |
| NotificationMgr.getDefault().hideDataDisconnectedRoaming(); |
| break; |
| |
| case MMI_COMPLETE: |
| onMMIComplete((AsyncResult) msg.obj); |
| break; |
| |
| case MMI_CANCEL: |
| PhoneUtils.cancelMmiCode(phone); |
| break; |
| |
| case EVENT_WIRED_HEADSET_PLUG: |
| // Since the presence of a wired headset or bluetooth affects the |
| // speakerphone, update the "speaker" state. We ONLY want to do |
| // this on the wired headset connect / disconnect events for now |
| // though, so we're only triggering on EVENT_WIRED_HEADSET_PLUG. |
| // If in call screen is showing, let InCallScreen handle the speaker. |
| |
| Phone.State phoneState = phone.getState(); |
| // Do not change speaker state if phone is not off hook |
| if (phoneState == Phone.State.OFFHOOK) { |
| if (!isShowingCallScreen() && |
| (mBtHandsfree == null || !mBtHandsfree.isAudioOn())) { |
| if (!isHeadsetPlugged()) { |
| // if the state is "not connected", restore the speaker state. |
| PhoneUtils.restoreSpeakerMode(getApplicationContext()); |
| } else { |
| // if the state is "connected", force the speaker off without |
| // storing the state. |
| PhoneUtils.turnOnSpeaker(getApplicationContext(), false, false); |
| } |
| } |
| } |
| // Update the Proximity sensor based on headset state |
| updateProximitySensorMode(phoneState); |
| break; |
| |
| case EVENT_SIM_STATE_CHANGED: |
| // Marks the event where the SIM goes into ready state. |
| // Right now, this is only used for the PUK-unlocking |
| // process. |
| if (msg.obj.equals(IccCard.INTENT_VALUE_ICC_READY)) { |
| // when the right event is triggered and there |
| // are UI objects in the foreground, we close |
| // them to display the lock panel. |
| if (mPUKEntryActivity != null) { |
| mPUKEntryActivity.finish(); |
| mPUKEntryActivity = null; |
| } |
| if (mPUKEntryProgressDialog != null) { |
| mPUKEntryProgressDialog.dismiss(); |
| mPUKEntryProgressDialog = null; |
| } |
| } |
| break; |
| |
| case EVENT_UNSOL_CDMA_INFO_RECORD: |
| //TODO: handle message here; |
| break; |
| } |
| } |
| }; |
| |
| public PhoneApp() { |
| sMe = this; |
| } |
| |
| @Override |
| public void onCreate() { |
| if (Config.LOGV) Log.v(LOG_TAG, "onCreate()..."); |
| |
| ContentResolver resolver = getContentResolver(); |
| |
| if (phone == null) { |
| // Initialize the telephony framework |
| PhoneFactory.makeDefaultPhones(this); |
| |
| // Get the default phone |
| phone = PhoneFactory.getDefaultPhone(); |
| |
| NotificationMgr.init(this); |
| |
| phoneMgr = new PhoneInterfaceManager(this, phone); |
| |
| int phoneType = phone.getPhoneType(); |
| |
| if (phoneType == Phone.PHONE_TYPE_CDMA) { |
| // Create an instance of CdmaPhoneCallState and initialize it to IDLE |
| cdmaPhoneCallState = new CdmaPhoneCallState(); |
| cdmaPhoneCallState.CdmaPhoneCallStateInit(); |
| } |
| |
| if (BluetoothAdapter.getDefaultAdapter() != null) { |
| mBtHandsfree = new BluetoothHandsfree(this, phone); |
| startService(new Intent(this, BluetoothHeadsetService.class)); |
| } else { |
| // Device is not bluetooth capable |
| mBtHandsfree = null; |
| } |
| |
| ringer = new Ringer(phone); |
| |
| // before registering for phone state changes |
| PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE); |
| mWakeLock = pm.newWakeLock(PowerManager.FULL_WAKE_LOCK |
| | PowerManager.ACQUIRE_CAUSES_WAKEUP |
| | PowerManager.ON_AFTER_RELEASE, LOG_TAG); |
| // lock used to keep the processor awake, when we don't care for the display. |
| mPartialWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK |
| | PowerManager.ON_AFTER_RELEASE, LOG_TAG); |
| // Wake lock used to control proximity sensor behavior. |
| if ((pm.getSupportedWakeLockFlags() |
| & PowerManager.PROXIMITY_SCREEN_OFF_WAKE_LOCK) != 0x0) { |
| mProximityWakeLock = |
| pm.newWakeLock(PowerManager.PROXIMITY_SCREEN_OFF_WAKE_LOCK, LOG_TAG); |
| } |
| if (DBG) Log.d(LOG_TAG, "mProximityWakeLock: " + mProximityWakeLock); |
| |
| mKeyguardManager = (KeyguardManager) getSystemService(Context.KEYGUARD_SERVICE); |
| mKeyguardLock = mKeyguardManager.newKeyguardLock(LOG_TAG); |
| mStatusBarManager = (StatusBarManager) getSystemService(Context.STATUS_BAR_SERVICE); |
| |
| // get a handle to the service so that we can use it later when we |
| // want to set the poke lock. |
| mPowerManagerService = IPowerManager.Stub.asInterface( |
| ServiceManager.getService("power")); |
| |
| notifier = new CallNotifier(this, phone, ringer, mBtHandsfree); |
| |
| // register for ICC status |
| IccCard sim = phone.getIccCard(); |
| if (sim != null) { |
| if (Config.LOGV) Log.v(LOG_TAG, "register for ICC status"); |
| sim.registerForAbsent(mHandler, EVENT_SIM_ABSENT, null); |
| sim.registerForLocked(mHandler, EVENT_SIM_LOCKED, null); |
| sim.registerForNetworkLocked(mHandler, EVENT_SIM_NETWORK_LOCKED, null); |
| } |
| |
| // register for MMI/USSD |
| if (phoneType == Phone.PHONE_TYPE_GSM) { |
| phone.registerForMmiComplete(mHandler, MMI_COMPLETE, null); |
| } |
| |
| // register connection tracking to PhoneUtils |
| PhoneUtils.initializeConnectionHandler(phone); |
| |
| // Register for misc other intent broadcasts. |
| IntentFilter intentFilter = |
| new IntentFilter(Intent.ACTION_AIRPLANE_MODE_CHANGED); |
| intentFilter.addAction(BluetoothHeadset.ACTION_STATE_CHANGED); |
| intentFilter.addAction(BluetoothHeadset.ACTION_AUDIO_STATE_CHANGED); |
| intentFilter.addAction(TelephonyIntents.ACTION_ANY_DATA_CONNECTION_STATE_CHANGED); |
| intentFilter.addAction(Intent.ACTION_HEADSET_PLUG); |
| intentFilter.addAction(Intent.ACTION_BATTERY_LOW); |
| intentFilter.addAction(TelephonyIntents.ACTION_SIM_STATE_CHANGED); |
| intentFilter.addAction(TelephonyIntents.ACTION_RADIO_TECHNOLOGY_CHANGED); |
| intentFilter.addAction(TelephonyIntents.ACTION_SERVICE_STATE_CHANGED); |
| intentFilter.addAction(TelephonyIntents.ACTION_EMERGENCY_CALLBACK_MODE_CHANGED); |
| registerReceiver(mReceiver, intentFilter); |
| |
| // Use a separate receiver for ACTION_MEDIA_BUTTON broadcasts, |
| // since we need to manually adjust its priority (to make sure |
| // we get these intents *before* the media player.) |
| IntentFilter mediaButtonIntentFilter = |
| new IntentFilter(Intent.ACTION_MEDIA_BUTTON); |
| // |
| // Make sure we're higher priority than the media player's |
| // MediaButtonIntentReceiver (which currently has the default |
| // priority of zero; see apps/Music/AndroidManifest.xml.) |
| mediaButtonIntentFilter.setPriority(1); |
| // |
| registerReceiver(mMediaButtonReceiver, mediaButtonIntentFilter); |
| |
| //set the default values for the preferences in the phone. |
| PreferenceManager.setDefaultValues(this, R.xml.network_setting, false); |
| |
| PreferenceManager.setDefaultValues(this, R.xml.call_feature_setting, false); |
| |
| // Make sure the audio mode (along with some |
| // audio-mode-related state of our own) is initialized |
| // correctly, given the current state of the phone. |
| switch (phone.getState()) { |
| case IDLE: |
| if (DBG) Log.d(LOG_TAG, "Resetting audio state/mode: IDLE"); |
| PhoneUtils.setAudioControlState(PhoneUtils.AUDIO_IDLE); |
| PhoneUtils.setAudioMode(this, AudioManager.MODE_NORMAL); |
| break; |
| case RINGING: |
| if (DBG) Log.d(LOG_TAG, "Resetting audio state/mode: RINGING"); |
| PhoneUtils.setAudioControlState(PhoneUtils.AUDIO_RINGING); |
| PhoneUtils.setAudioMode(this, AudioManager.MODE_RINGTONE); |
| break; |
| case OFFHOOK: |
| if (DBG) Log.d(LOG_TAG, "Resetting audio state/mode: OFFHOOK"); |
| PhoneUtils.setAudioControlState(PhoneUtils.AUDIO_OFFHOOK); |
| PhoneUtils.setAudioMode(this, AudioManager.MODE_IN_CALL); |
| break; |
| } |
| } |
| |
| boolean phoneIsCdma = (phone.getPhoneType() == Phone.PHONE_TYPE_CDMA); |
| |
| if (phoneIsCdma) { |
| cdmaOtaProvisionData = new OtaUtils.CdmaOtaProvisionData(); |
| cdmaOtaConfigData = new OtaUtils.CdmaOtaConfigData(); |
| cdmaOtaScreenState = new OtaUtils.CdmaOtaScreenState(); |
| cdmaOtaInCallScreenUiState = new OtaUtils.CdmaOtaInCallScreenUiState(); |
| } |
| |
| // XXX pre-load the SimProvider so that it's ready |
| resolver.getType(Uri.parse("content://icc/adn")); |
| |
| // start with the default value to set the mute state. |
| mShouldRestoreMuteOnInCallResume = false; |
| |
| // Register for Cdma Information Records |
| // TODO(Moto): Merge |
| // phone.registerCdmaInformationRecord(mHandler, EVENT_UNSOL_CDMA_INFO_RECORD, null); |
| |
| // Read TTY settings and store it into BP NV. |
| // AP owns (i.e. stores) the TTY setting in AP settings database and pushes the setting |
| // to BP at power up (BP does not need to make the TTY setting persistent storage). |
| // This way, there is a single owner (i.e AP) for the TTY setting in the phone. |
| if (phoneIsCdma) { |
| int settingsTtyMode = android.provider.Settings.Secure.getInt( |
| phone.getContext().getContentResolver(), |
| android.provider.Settings.Secure.PREFERRED_TTY_MODE, |
| Phone.TTY_MODE_OFF); |
| phone.setTTYMode(settingsTtyMode, null); |
| } |
| } |
| |
| @Override |
| public void onConfigurationChanged(Configuration newConfig) { |
| if (newConfig.hardKeyboardHidden == Configuration.HARDKEYBOARDHIDDEN_NO) { |
| mIsHardKeyboardOpen = true; |
| } else { |
| mIsHardKeyboardOpen = false; |
| } |
| |
| // Update the Proximity sensor based on keyboard state |
| updateProximitySensorMode(phone.getState()); |
| super.onConfigurationChanged(newConfig); |
| } |
| |
| /** |
| * Returns the singleton instance of the PhoneApp. |
| */ |
| static PhoneApp getInstance() { |
| return sMe; |
| } |
| |
| Ringer getRinger() { |
| return ringer; |
| } |
| |
| BluetoothHandsfree getBluetoothHandsfree() { |
| return mBtHandsfree; |
| } |
| |
| static Intent createCallLogIntent() { |
| Intent intent = new Intent(Intent.ACTION_VIEW, null); |
| intent.setType("vnd.android.cursor.dir/calls"); |
| return intent; |
| } |
| |
| /** |
| * Return an Intent that can be used to bring up the in-call screen. |
| * |
| * This intent can only be used from within the Phone app, since the |
| * InCallScreen is not exported from our AndroidManifest. |
| */ |
| /* package */ static Intent createInCallIntent() { |
| Intent intent = new Intent(Intent.ACTION_MAIN, null); |
| intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK |
| | Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS |
| | Intent.FLAG_ACTIVITY_NO_USER_ACTION); |
| intent.setClassName("com.android.phone", getCallScreenClassName()); |
| return intent; |
| } |
| |
| /** |
| * Variation of createInCallIntent() that also specifies whether the |
| * DTMF dialpad should be initially visible when the InCallScreen |
| * comes up. |
| */ |
| /* package */ static Intent createInCallIntent(boolean showDialpad) { |
| Intent intent = createInCallIntent(); |
| intent.putExtra(InCallScreen.SHOW_DIALPAD_EXTRA, showDialpad); |
| return intent; |
| } |
| |
| static String getCallScreenClassName() { |
| return InCallScreen.class.getName(); |
| } |
| |
| /** |
| * Starts the InCallScreen Activity. |
| */ |
| void displayCallScreen() { |
| if (VDBG) Log.d(LOG_TAG, "displayCallScreen()..."); |
| startActivity(createInCallIntent()); |
| Profiler.callScreenRequested(); |
| } |
| |
| /** |
| * Helper function to check for one special feature of the CALL key: |
| * Normally, when the phone is idle, CALL takes you to the call log |
| * (see the handler for KEYCODE_CALL in PhoneWindow.onKeyUp().) |
| * But if the phone is in use (either off-hook or ringing) we instead |
| * handle the CALL button by taking you to the in-call UI. |
| * |
| * @return true if we intercepted the CALL keypress (i.e. the phone |
| * was in use) |
| * |
| * @see DialerActivity#onCreate |
| */ |
| boolean handleInCallOrRinging() { |
| if (phone.getState() != Phone.State.IDLE) { |
| // Phone is OFFHOOK or RINGING. |
| if (DBG) Log.v(LOG_TAG, |
| "handleInCallOrRinging: show call screen"); |
| displayCallScreen(); |
| return true; |
| } |
| return false; |
| } |
| |
| boolean isSimPinEnabled() { |
| return mIsSimPinEnabled; |
| } |
| |
| boolean authenticateAgainstCachedSimPin(String pin) { |
| return (mCachedSimPin != null && mCachedSimPin.equals(pin)); |
| } |
| |
| void setCachedSimPin(String pin) { |
| mCachedSimPin = pin; |
| } |
| |
| void setInCallScreenInstance(InCallScreen inCallScreen) { |
| mInCallScreen = inCallScreen; |
| } |
| |
| /** |
| * @return true if the in-call UI is running as the foreground |
| * activity. (In other words, from the perspective of the |
| * InCallScreen activity, return true between onResume() and |
| * onPause().) |
| * |
| * Note this method will return false if the screen is currently off, |
| * even if the InCallScreen *was* in the foreground just before the |
| * screen turned off. (This is because the foreground activity is |
| * always "paused" while the screen is off.) |
| */ |
| boolean isShowingCallScreen() { |
| if (mInCallScreen == null) return false; |
| return mInCallScreen.isForegroundActivity(); |
| } |
| |
| /** |
| * Dismisses the in-call UI. |
| * |
| * This also ensures that you won't be able to get back to the in-call |
| * UI via the BACK button (since this call removes the InCallScreen |
| * from the activity history.) |
| * For OTA Call, it call InCallScreen api to handle OTA Call End scenario |
| * to display OTA Call End screen. |
| */ |
| void dismissCallScreen() { |
| if (mInCallScreen != null) { |
| if (mInCallScreen.isOtaCallInActiveState() |
| || mInCallScreen.isOtaCallInEndState() |
| || ((cdmaOtaScreenState != null) |
| && (cdmaOtaScreenState.otaScreenState |
| != CdmaOtaScreenState.OtaScreenState.OTA_STATUS_UNDEFINED))) { |
| // TODO(Moto): During OTA Call, display should not become dark to |
| // allow user to see OTA UI update. Phone app needs to hold a SCREEN_DIM_WAKE_LOCK |
| // wake lock during the entire OTA call. |
| wakeUpScreen(); |
| // If InCallScreen is not in foreground we resume it to show the OTA call end screen |
| // Fire off the InCallScreen intent |
| displayCallScreen(); |
| |
| mInCallScreen.handleOtaCallEnd(); |
| return; |
| } else { |
| mInCallScreen.finish(); |
| } |
| } |
| } |
| |
| /** |
| * Handle OTA events |
| * |
| * When OTA call is active and display becomes dark, then CallNotifier will |
| * handle OTA Events by calling this api which then calls OtaUtil function. |
| */ |
| void handleOtaEvents(Message msg) { |
| |
| if (DBG) Log.d(LOG_TAG, "Enter handleOtaEvents"); |
| if ((mInCallScreen != null) && (!isShowingCallScreen())) { |
| if (mInCallScreen.otaUtils != null) { |
| mInCallScreen.otaUtils.onOtaProvisionStatusChanged((AsyncResult) msg.obj); |
| } |
| } |
| } |
| |
| |
| /** |
| * Sets the activity responsible for un-PUK-blocking the device |
| * so that we may close it when we receive a positive result. |
| * mPUKEntryActivity is also used to indicate to the device that |
| * we are trying to un-PUK-lock the phone. In other words, iff |
| * it is NOT null, then we are trying to unlock and waiting for |
| * the SIM to move to READY state. |
| * |
| * @param activity is the activity to close when PUK has |
| * finished unlocking. Can be set to null to indicate the unlock |
| * or SIM READYing process is over. |
| */ |
| void setPukEntryActivity(Activity activity) { |
| mPUKEntryActivity = activity; |
| } |
| |
| Activity getPUKEntryActivity() { |
| return mPUKEntryActivity; |
| } |
| |
| /** |
| * Sets the dialog responsible for notifying the user of un-PUK- |
| * blocking - SIM READYing progress, so that we may dismiss it |
| * when we receive a positive result. |
| * |
| * @param dialog indicates the progress dialog informing the user |
| * of the state of the device. Dismissed upon completion of |
| * READYing process |
| */ |
| void setPukEntryProgressDialog(ProgressDialog dialog) { |
| mPUKEntryProgressDialog = dialog; |
| } |
| |
| ProgressDialog getPUKEntryProgressDialog() { |
| return mPUKEntryProgressDialog; |
| } |
| |
| /** |
| * Disables the keyguard. This is used by the phone app to allow |
| * interaction with the Phone UI when the keyguard would otherwise be |
| * active (like receiving an incoming call while the device is |
| * locked.) |
| * |
| * Any call to this method MUST be followed (eventually) |
| * by a corresponding reenableKeyguard() call. |
| */ |
| /* package */ void disableKeyguard() { |
| if (DBG) Log.d(LOG_TAG, "disable keyguard"); |
| // if (DBG) Log.d(LOG_TAG, "disableKeyguard()...", new Throwable("stack dump")); |
| synchronized (mKeyguardLock) { |
| if (mKeyguardDisableCount++ == 0) { |
| mKeyguardLock.disableKeyguard(); |
| mStatusBarManager.disable(StatusBarManager.DISABLE_EXPAND); |
| } |
| } |
| } |
| |
| /** |
| * Re-enables the keyguard after a previous disableKeyguard() call. |
| * |
| * Any call to this method MUST correspond to (i.e. be balanced with) |
| * a previous disableKeyguard() call. |
| */ |
| /* package */ void reenableKeyguard() { |
| if (DBG) Log.d(LOG_TAG, "re-enable keyguard"); |
| // if (DBG) Log.d(LOG_TAG, "reenableKeyguard()...", new Throwable("stack dump")); |
| synchronized (mKeyguardLock) { |
| if (mKeyguardDisableCount > 0) { |
| if (--mKeyguardDisableCount == 0) { |
| mKeyguardLock.reenableKeyguard(); |
| mStatusBarManager.disable(StatusBarManager.DISABLE_NONE); |
| } |
| } else { |
| Log.e(LOG_TAG, "mKeyguardDisableCount is already zero"); |
| } |
| } |
| } |
| |
| /** |
| * Controls how quickly the screen times out. |
| * |
| * The poke lock controls how long it takes before the screen powers |
| * down, and therefore has no immediate effect when the current |
| * WakeState (see {@link PhoneApp#requestWakeState}) is FULL. |
| * If we're in a state where the screen *is* allowed to turn off, |
| * though, the poke lock will determine the timeout interval (long or |
| * short). |
| * |
| * @param shortPokeLock tells the device the timeout duration to use |
| * before going to sleep |
| * {@link com.android.server.PowerManagerService#SHORT_KEYLIGHT_DELAY}. |
| */ |
| /* package */ void setScreenTimeout(ScreenTimeoutDuration duration) { |
| if (VDBG) Log.d(LOG_TAG, "setScreenTimeout(" + duration + ")..."); |
| |
| // make sure we don't set the poke lock repeatedly so that we |
| // avoid triggering the userActivity calls in |
| // PowerManagerService.setPokeLock(). |
| if (duration == mScreenTimeoutDuration) { |
| return; |
| } |
| // stick with default timeout if we are using the proximity sensor |
| if (proximitySensorModeEnabled()) { |
| return; |
| } |
| mScreenTimeoutDuration = duration; |
| updatePokeLock(); |
| } |
| |
| /** |
| * Update the state of the poke lock held by the phone app, |
| * based on the current desired screen timeout and the |
| * current "ignore user activity on touch" flag. |
| */ |
| private void updatePokeLock() { |
| // This is kind of convoluted, but the basic thing to remember is |
| // that the poke lock just sends a message to the screen to tell |
| // it to stay on for a while. |
| // The default is 0, for a long timeout and should be set that way |
| // when we are heading back into a the keyguard / screen off |
| // state, and also when we're trying to keep the screen alive |
| // while ringing. We'll also want to ignore the cheek events |
| // regardless of the timeout duration. |
| // The short timeout is really used whenever we want to give up |
| // the screen lock, such as when we're in call. |
| int pokeLockSetting = LocalPowerManager.POKE_LOCK_IGNORE_CHEEK_EVENTS; |
| switch (mScreenTimeoutDuration) { |
| case SHORT: |
| // Set the poke lock to timeout the display after a short |
| // timeout (5s). This ensures that the screen goes to sleep |
| // as soon as acceptably possible after we the wake lock |
| // has been released. |
| pokeLockSetting |= LocalPowerManager.POKE_LOCK_SHORT_TIMEOUT; |
| break; |
| |
| case MEDIUM: |
| // Set the poke lock to timeout the display after a medium |
| // timeout (15s). This ensures that the screen goes to sleep |
| // as soon as acceptably possible after we the wake lock |
| // has been released. |
| pokeLockSetting |= LocalPowerManager.POKE_LOCK_MEDIUM_TIMEOUT; |
| break; |
| |
| case DEFAULT: |
| default: |
| // set the poke lock to timeout the display after a long |
| // delay by default. |
| // TODO: it may be nice to be able to disable cheek presses |
| // for long poke locks (emergency dialer, for instance). |
| break; |
| } |
| |
| if (mIgnoreTouchUserActivity) { |
| pokeLockSetting |= LocalPowerManager.POKE_LOCK_IGNORE_TOUCH_AND_CHEEK_EVENTS; |
| } |
| |
| // Send the request |
| try { |
| mPowerManagerService.setPokeLock(pokeLockSetting, mPokeLockToken, LOG_TAG); |
| } catch (RemoteException e) { |
| Log.w(LOG_TAG, "mPowerManagerService.setPokeLock() failed: " + e); |
| } |
| } |
| |
| /** |
| * Controls whether or not the screen is allowed to sleep. |
| * |
| * Once sleep is allowed (WakeState is SLEEP), it will rely on the |
| * settings for the poke lock to determine when to timeout and let |
| * the device sleep {@link PhoneApp#setScreenTimeout}. |
| * |
| * @param ws tells the device to how to wake. |
| */ |
| /* package */ void requestWakeState(WakeState ws) { |
| if (VDBG) Log.d(LOG_TAG, "requestWakeState(" + ws + ")..."); |
| if (mWakeState != ws) { |
| switch (ws) { |
| case PARTIAL: |
| // acquire the processor wake lock, and release the FULL |
| // lock if it is being held. |
| mPartialWakeLock.acquire(); |
| if (mWakeLock.isHeld()) { |
| mWakeLock.release(); |
| } |
| break; |
| case FULL: |
| // acquire the full wake lock, and release the PARTIAL |
| // lock if it is being held. |
| mWakeLock.acquire(); |
| if (mPartialWakeLock.isHeld()) { |
| mPartialWakeLock.release(); |
| } |
| break; |
| case SLEEP: |
| default: |
| // release both the PARTIAL and FULL locks. |
| if (mWakeLock.isHeld()) { |
| mWakeLock.release(); |
| } |
| if (mPartialWakeLock.isHeld()) { |
| mPartialWakeLock.release(); |
| } |
| break; |
| } |
| mWakeState = ws; |
| } |
| } |
| |
| /** |
| * If we are not currently keeping the screen on, then poke the power |
| * manager to wake up the screen for the user activity timeout duration. |
| */ |
| /* package */ void wakeUpScreen() { |
| if (mWakeState == WakeState.SLEEP) { |
| if (DBG) Log.d(LOG_TAG, "pulse screen lock"); |
| try { |
| mPowerManagerService.userActivityWithForce(SystemClock.uptimeMillis(), false, true); |
| } catch (RemoteException ex) { |
| // Ignore -- the system process is dead. |
| } |
| } |
| } |
| |
| /** |
| * Sets the wake state and screen timeout based on the current state |
| * of the phone, and the current state of the in-call UI. |
| * |
| * This method is a "UI Policy" wrapper around |
| * {@link PhoneApp#requestWakeState} and {@link PhoneApp#setScreenTimeout}. |
| * |
| * It's safe to call this method regardless of the state of the Phone |
| * (e.g. whether or not it's idle), and regardless of the state of the |
| * Phone UI (e.g. whether or not the InCallScreen is active.) |
| */ |
| /* package */ void updateWakeState() { |
| Phone.State state = phone.getState(); |
| |
| // True if the in-call UI is the foreground activity. |
| // (Note this will be false if the screen is currently off, |
| // since in that case *no* activity is in the foreground.) |
| boolean isShowingCallScreen = isShowingCallScreen(); |
| |
| // True if the InCallScreen's DTMF dialer is currently opened. |
| // (Note this does NOT imply whether or not the InCallScreen |
| // itself is visible.) |
| boolean isDialerOpened = (mInCallScreen != null) && mInCallScreen.isDialerOpened(); |
| |
| // True if the speakerphone is in use. (If so, we *always* use |
| // the default timeout. Since the user is obviously not holding |
| // the phone up to his/her face, we don't need to worry about |
| // false touches, and thus don't need to turn the screen off so |
| // aggressively.) |
| // Note that we need to make a fresh call to this method any |
| // time the speaker state changes. (That happens in |
| // PhoneUtils.turnOnSpeaker().) |
| boolean isSpeakerInUse = (state == Phone.State.OFFHOOK) && PhoneUtils.isSpeakerOn(this); |
| |
| // TODO (bug 1440854): The screen timeout *might* also need to |
| // depend on the bluetooth state, but this isn't as clear-cut as |
| // the speaker state (since while using BT it's common for the |
| // user to put the phone straight into a pocket, in which case the |
| // timeout should probably still be short.) |
| |
| if (DBG) Log.d(LOG_TAG, "updateWakeState: callscreen " + isShowingCallScreen |
| + ", dialer " + isDialerOpened |
| + ", speaker " + isSpeakerInUse + "..."); |
| |
| // |
| // (1) Set the screen timeout. |
| // |
| // Note that the "screen timeout" value we determine here is |
| // meaningless if the screen is forced on (see (2) below.) |
| // |
| if (!isShowingCallScreen || isSpeakerInUse) { |
| // Use the system-wide default timeout. |
| setScreenTimeout(ScreenTimeoutDuration.DEFAULT); |
| } else { |
| // We're on the in-call screen, and *not* using the speakerphone. |
| if (isDialerOpened) { |
| // The DTMF dialpad is up. This case is special because |
| // the in-call UI has its own "touch lock" mechanism to |
| // disable the dialpad after a very short amount of idle |
| // time (to avoid false touches from the user's face while |
| // in-call.) |
| // |
| // In this case the *physical* screen just uses the |
| // system-wide default timeout. |
| setScreenTimeout(ScreenTimeoutDuration.DEFAULT); |
| } else { |
| // We're on the in-call screen, and not using the DTMF dialpad. |
| // There's actually no touchable UI onscreen at all in |
| // this state. Also, the user is (most likely) not |
| // looking at the screen at all, since they're probably |
| // holding the phone up to their face. Here we use a |
| // special screen timeout value specific to the in-call |
| // screen, purely to save battery life. |
| setScreenTimeout(ScreenTimeoutDuration.MEDIUM); |
| } |
| } |
| |
| // |
| // (2) Decide whether to force the screen on or not. |
| // |
| // Force the screen to be on if the phone is ringing or dialing, |
| // or if we're displaying the "Call ended" UI for a connection in |
| // the "disconnected" state. |
| // |
| boolean isRinging = (state == Phone.State.RINGING); |
| boolean isDialing = (phone.getForegroundCall().getState() == Call.State.DIALING); |
| boolean showingDisconnectedConnection = |
| PhoneUtils.hasDisconnectedConnections(phone) && isShowingCallScreen; |
| boolean keepScreenOn = isRinging || isDialing || showingDisconnectedConnection; |
| if (DBG) Log.d(LOG_TAG, "updateWakeState: keepScreenOn = " + keepScreenOn |
| + " (isRinging " + isRinging |
| + ", isDialing " + isDialing |
| + ", showingDisc " + showingDisconnectedConnection + ")"); |
| // keepScreenOn == true means we'll hold a full wake lock: |
| requestWakeState(keepScreenOn ? WakeState.FULL : WakeState.SLEEP); |
| } |
| |
| /** |
| * Wrapper around the PowerManagerService.preventScreenOn() API. |
| * This allows the in-call UI to prevent the screen from turning on |
| * even if a subsequent call to updateWakeState() causes us to acquire |
| * a full wake lock. |
| */ |
| /* package */ void preventScreenOn(boolean prevent) { |
| if (VDBG) Log.d(LOG_TAG, "- preventScreenOn(" + prevent + ")..."); |
| try { |
| mPowerManagerService.preventScreenOn(prevent); |
| } catch (RemoteException e) { |
| Log.w(LOG_TAG, "mPowerManagerService.preventScreenOn() failed: " + e); |
| } |
| } |
| |
| /** |
| * Sets or clears the flag that tells the PowerManager that touch |
| * (and cheek) events should NOT be considered "user activity". |
| * |
| * Since the in-call UI is totally insensitive to touch in most |
| * states, we set this flag whenever the InCallScreen is in the |
| * foreground. (Otherwise, repeated unintentional touches could |
| * prevent the device from going to sleep.) |
| * |
| * There *are* some some touch events that really do count as user |
| * activity, though. For those, we need to manually poke the |
| * PowerManager's userActivity method; see pokeUserActivity(). |
| */ |
| /* package */ void setIgnoreTouchUserActivity(boolean ignore) { |
| if (VDBG) Log.d(LOG_TAG, "setIgnoreTouchUserActivity(" + ignore + ")..."); |
| mIgnoreTouchUserActivity = ignore; |
| updatePokeLock(); |
| } |
| |
| /** |
| * Manually pokes the PowerManager's userActivity method. Since we |
| * hold the POKE_LOCK_IGNORE_TOUCH_AND_CHEEK_EVENTS poke lock while |
| * the InCallScreen is active, we need to do this for touch events |
| * that really do count as user activity (like DTMF key presses, or |
| * unlocking the "touch lock" overlay.) |
| */ |
| /* package */ void pokeUserActivity() { |
| if (VDBG) Log.d(LOG_TAG, "pokeUserActivity()..."); |
| try { |
| mPowerManagerService.userActivity(SystemClock.uptimeMillis(), false); |
| } catch (RemoteException e) { |
| Log.w(LOG_TAG, "mPowerManagerService.userActivity() failed: " + e); |
| } |
| } |
| |
| /** |
| * Set when a new outgoing call is beginning, so we can update |
| * the proximity sensor state. |
| * Cleared when the InCallScreen is no longer in the foreground, |
| * in case the call fails without changing the telephony state. |
| */ |
| /* package */ void setBeginningCall(boolean beginning) { |
| // Note that we are beginning a new call, for proximity sensor support |
| mBeginningCall = beginning; |
| // Update the Proximity sensor based on mBeginningCall state |
| updateProximitySensorMode(phone.getState()); |
| } |
| |
| /** |
| * Updates the wake lock used to control proximity sensor behavior, |
| * based on the current state of the phone. This method is called |
| * from the CallNotifier on any phone state change. |
| * |
| * On devices that have a proximity sensor, to avoid false touches |
| * during a call, we hold a PROXIMITY_SCREEN_OFF_WAKE_LOCK wake lock |
| * whenever the phone is off hook. (When held, that wake lock causes |
| * the screen to turn off automatically when the sensor detects an |
| * object close to the screen.) |
| * |
| * This method is a no-op for devices that don't have a proximity |
| * sensor. |
| * |
| * Note this method doesn't care if the InCallScreen is the foreground |
| * activity or not. That's because we want the proximity sensor to be |
| * enabled any time the phone is in use, to avoid false cheek events |
| * for whatever app you happen to be running. |
| * |
| * Proximity wake lock will *not* be held if any one of the |
| * conditions is true while on a call: |
| * 1) If the audio is routed via Bluetooth |
| * 2) If a wired headset is connected |
| * 3) if the speaker is ON |
| * 4) If the slider is open(i.e. the hardkeyboard is *not* hidden) |
| * |
| * @param state current state of the phone (see {@link Phone#State}) |
| */ |
| /* package */ void updateProximitySensorMode(Phone.State state) { |
| if (VDBG) Log.d(LOG_TAG, "updateProximitySensorMode: state = " + state); |
| |
| if (proximitySensorModeEnabled()) { |
| if (((state == Phone.State.OFFHOOK) || mBeginningCall) |
| && !(isHeadsetPlugged() |
| || PhoneUtils.isSpeakerOn(this) |
| || ((mBtHandsfree != null) && mBtHandsfree.isAudioOn()) |
| || mIsHardKeyboardOpen)) { |
| // Phone is in use! Arrange for the screen to turn off |
| // automatically when the sensor detects a close object. |
| if (!mProximityWakeLock.isHeld()) { |
| if (DBG) Log.d(LOG_TAG, "updateProximitySensorMode: acquiring..."); |
| mProximityWakeLock.acquire(); |
| // disable keyguard while we are using the proximity sensor |
| disableKeyguard(); |
| } else { |
| if (VDBG) Log.d(LOG_TAG, "updateProximitySensorMode: lock already held."); |
| } |
| } else { |
| // Phone is either idle, or ringing. We don't want any |
| // special proximity sensor behavior in either case. |
| if (mProximityWakeLock.isHeld()) { |
| if (DBG) Log.d(LOG_TAG, "updateProximitySensorMode: releasing..."); |
| mProximityWakeLock.release(); |
| reenableKeyguard(); |
| } else { |
| if (VDBG) Log.d(LOG_TAG, "updateProximitySensorMode: lock already released."); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Notifies the phone app when the phone state changes. |
| * Currently used only for proximity sensor support. |
| */ |
| /* package */ void updatePhoneState(Phone.State state) { |
| if (state != mLastPhoneState) { |
| mLastPhoneState = state; |
| updateProximitySensorMode(state); |
| // clear our beginning call flag |
| mBeginningCall = false; |
| } |
| } |
| |
| /** |
| * @return true if this device supports the "proximity sensor |
| * auto-lock" feature while in-call (see updateProximitySensorMode()). |
| */ |
| /* package */ boolean proximitySensorModeEnabled() { |
| return (mProximityWakeLock != null); |
| } |
| |
| KeyguardManager getKeyguardManager() { |
| return mKeyguardManager; |
| } |
| |
| private void onMMIComplete(AsyncResult r) { |
| if (VDBG) Log.d(LOG_TAG, "onMMIComplete()..."); |
| MmiCode mmiCode = (MmiCode) r.result; |
| PhoneUtils.displayMMIComplete(phone, getInstance(), mmiCode, null, null); |
| } |
| |
| private void initForNewRadioTechnology() { |
| if (DBG) Log.d(LOG_TAG, "initForNewRadioTechnology..."); |
| |
| if (phone.getPhoneType() == Phone.PHONE_TYPE_CDMA) { |
| // Create an instance of CdmaPhoneCallState and initialize it to IDLE |
| cdmaPhoneCallState = new CdmaPhoneCallState(); |
| cdmaPhoneCallState.CdmaPhoneCallStateInit(); |
| |
| //create instances of CDMA OTA data classes |
| if (cdmaOtaProvisionData == null) { |
| cdmaOtaProvisionData = new OtaUtils.CdmaOtaProvisionData(); |
| } |
| if (cdmaOtaConfigData == null) { |
| cdmaOtaConfigData = new OtaUtils.CdmaOtaConfigData(); |
| } |
| if (cdmaOtaScreenState == null) { |
| cdmaOtaScreenState = new OtaUtils.CdmaOtaScreenState(); |
| } |
| } |
| |
| ringer.updateRingerContextAfterRadioTechnologyChange(this.phone); |
| notifier.updateCallNotifierRegistrationsAfterRadioTechnologyChange(); |
| if (mBtHandsfree != null) { |
| mBtHandsfree.updateBtHandsfreeAfterRadioTechnologyChange(); |
| } |
| if (mInCallScreen != null) { |
| mInCallScreen.updateAfterRadioTechnologyChange(); |
| } |
| |
| // Update registration for ICC status after radio technology change |
| IccCard sim = phone.getIccCard(); |
| if (sim != null) { |
| if (DBG) Log.d(LOG_TAG, "Update registration for ICC status..."); |
| |
| //Register all events new to the new active phone |
| sim.registerForAbsent(mHandler, EVENT_SIM_ABSENT, null); |
| sim.registerForLocked(mHandler, EVENT_SIM_LOCKED, null); |
| sim.registerForNetworkLocked(mHandler, EVENT_SIM_NETWORK_LOCKED, null); |
| } |
| } |
| |
| |
| /** |
| * @return true if a wired headset is currently plugged in. |
| * |
| * @see Intent.ACTION_HEADSET_PLUG (which we listen for in mReceiver.onReceive()) |
| */ |
| boolean isHeadsetPlugged() { |
| return mIsHeadsetPlugged; |
| } |
| |
| /** |
| * @return true if the onscreen UI should currently be showing the |
| * special "bluetooth is active" indication in a couple of places (in |
| * which UI elements turn blue and/or show the bluetooth logo.) |
| * |
| * This depends on the BluetoothHeadset state *and* the current |
| * telephony state; see shouldShowBluetoothIndication(). |
| * |
| * @see CallCard |
| * @see NotificationMgr.updateInCallNotification |
| */ |
| /* package */ boolean showBluetoothIndication() { |
| return mShowBluetoothIndication; |
| } |
| |
| /** |
| * Recomputes the mShowBluetoothIndication flag based on the current |
| * bluetooth state and current telephony state. |
| * |
| * This needs to be called any time the bluetooth headset state or the |
| * telephony state changes. |
| * |
| * @param forceUiUpdate if true, force the UI elements that care |
| * about this flag to update themselves. |
| */ |
| /* package */ void updateBluetoothIndication(boolean forceUiUpdate) { |
| mShowBluetoothIndication = shouldShowBluetoothIndication(mBluetoothHeadsetState, |
| mBluetoothHeadsetAudioState, |
| phone); |
| if (forceUiUpdate) { |
| // Post Handler messages to the various components that might |
| // need to be refreshed based on the new state. |
| if (isShowingCallScreen()) mInCallScreen.requestUpdateBluetoothIndication(); |
| mHandler.sendEmptyMessage(EVENT_UPDATE_INCALL_NOTIFICATION); |
| } |
| |
| // Update the Proximity sensor based on Bluetooth audio state |
| updateProximitySensorMode(phone.getState()); |
| } |
| |
| /** |
| * UI policy helper function for the couple of places in the UI that |
| * have some way of indicating that "bluetooth is in use." |
| * |
| * @return true if the onscreen UI should indicate that "bluetooth is in use", |
| * based on the specified bluetooth headset state, and the |
| * current state of the phone. |
| * @see showBluetoothIndication() |
| */ |
| private static boolean shouldShowBluetoothIndication(int bluetoothState, |
| int bluetoothAudioState, |
| Phone phone) { |
| // We want the UI to indicate that "bluetooth is in use" in two |
| // slightly different cases: |
| // |
| // (a) The obvious case: if a bluetooth headset is currently in |
| // use for an ongoing call. |
| // |
| // (b) The not-so-obvious case: if an incoming call is ringing, |
| // and we expect that audio *will* be routed to a bluetooth |
| // headset once the call is answered. |
| |
| switch (phone.getState()) { |
| case OFFHOOK: |
| // This covers normal active calls, and also the case if |
| // the foreground call is DIALING or ALERTING. In this |
| // case, bluetooth is considered "active" if a headset |
| // is connected *and* audio is being routed to it. |
| return ((bluetoothState == BluetoothHeadset.STATE_CONNECTED) |
| && (bluetoothAudioState == BluetoothHeadset.AUDIO_STATE_CONNECTED)); |
| |
| case RINGING: |
| // If an incoming call is ringing, we're *not* yet routing |
| // audio to the headset (since there's no in-call audio |
| // yet!) In this case, if a bluetooth headset is |
| // connected at all, we assume that it'll become active |
| // once the user answers the phone. |
| return (bluetoothState == BluetoothHeadset.STATE_CONNECTED); |
| |
| default: // Presumably IDLE |
| return false; |
| } |
| } |
| |
| |
| /** |
| * Receiver for misc intent broadcasts the Phone app cares about. |
| */ |
| private class PhoneAppBroadcastReceiver extends BroadcastReceiver { |
| @Override |
| public void onReceive(Context context, Intent intent) { |
| String action = intent.getAction(); |
| if (action.equals(Intent.ACTION_AIRPLANE_MODE_CHANGED)) { |
| boolean enabled = System.getInt(getContentResolver(), |
| System.AIRPLANE_MODE_ON, 0) == 0; |
| phone.setRadioPower(enabled); |
| } else if (action.equals(BluetoothHeadset.ACTION_STATE_CHANGED)) { |
| mBluetoothHeadsetState = intent.getIntExtra(BluetoothHeadset.EXTRA_STATE, |
| BluetoothHeadset.STATE_ERROR); |
| if (VDBG) Log.d(LOG_TAG, "mReceiver: HEADSET_STATE_CHANGED_ACTION"); |
| if (VDBG) Log.d(LOG_TAG, "==> new state: " + mBluetoothHeadsetState); |
| updateBluetoothIndication(true); // Also update any visible UI if necessary |
| } else if (action.equals(BluetoothHeadset.ACTION_AUDIO_STATE_CHANGED)) { |
| mBluetoothHeadsetAudioState = |
| intent.getIntExtra(BluetoothHeadset.EXTRA_AUDIO_STATE, |
| BluetoothHeadset.STATE_ERROR); |
| if (VDBG) Log.d(LOG_TAG, "mReceiver: HEADSET_AUDIO_STATE_CHANGED_ACTION"); |
| if (VDBG) Log.d(LOG_TAG, "==> new state: " + mBluetoothHeadsetAudioState); |
| updateBluetoothIndication(true); // Also update any visible UI if necessary |
| } else if (action.equals(TelephonyIntents.ACTION_ANY_DATA_CONNECTION_STATE_CHANGED)) { |
| if (VDBG) Log.d(LOG_TAG, "mReceiver: ACTION_ANY_DATA_CONNECTION_STATE_CHANGED"); |
| if (VDBG) Log.d(LOG_TAG, "- state: " + intent.getStringExtra(Phone.STATE_KEY)); |
| if (VDBG) Log.d(LOG_TAG, "- reason: " |
| + intent.getStringExtra(Phone.STATE_CHANGE_REASON_KEY)); |
| |
| // The "data disconnected due to roaming" notification is |
| // visible if you've lost data connectivity because you're |
| // roaming and you have the "data roaming" feature turned off. |
| boolean disconnectedDueToRoaming = false; |
| if ("DISCONNECTED".equals(intent.getStringExtra(Phone.STATE_KEY))) { |
| String reason = intent.getStringExtra(Phone.STATE_CHANGE_REASON_KEY); |
| if (Phone.REASON_ROAMING_ON.equals(reason)) { |
| // We just lost our data connection, and the reason |
| // is that we started roaming. This implies that |
| // the user has data roaming turned off. |
| disconnectedDueToRoaming = true; |
| } |
| } |
| mHandler.sendEmptyMessage(disconnectedDueToRoaming |
| ? EVENT_DATA_ROAMING_DISCONNECTED |
| : EVENT_DATA_ROAMING_OK); |
| } else if (action.equals(Intent.ACTION_HEADSET_PLUG)) { |
| if (VDBG) Log.d(LOG_TAG, "mReceiver: ACTION_HEADSET_PLUG"); |
| if (VDBG) Log.d(LOG_TAG, " state: " + intent.getIntExtra("state", 0)); |
| if (VDBG) Log.d(LOG_TAG, " name: " + intent.getStringExtra("name")); |
| mIsHeadsetPlugged = (intent.getIntExtra("state", 0) == 1); |
| mHandler.sendMessage(mHandler.obtainMessage(EVENT_WIRED_HEADSET_PLUG, 0)); |
| } else if (action.equals(Intent.ACTION_BATTERY_LOW)) { |
| if (VDBG) Log.d(LOG_TAG, "mReceiver: ACTION_BATTERY_LOW"); |
| notifier.sendBatteryLow(); // Play a warning tone if in-call |
| } else if ((action.equals(TelephonyIntents.ACTION_SIM_STATE_CHANGED)) && |
| (mPUKEntryActivity != null)) { |
| // if an attempt to un-PUK-lock the device was made, while we're |
| // receiving this state change notification, notify the handler. |
| // NOTE: This is ONLY triggered if an attempt to un-PUK-lock has |
| // been attempted. |
| mHandler.sendMessage(mHandler.obtainMessage(EVENT_SIM_STATE_CHANGED, |
| intent.getStringExtra(IccCard.INTENT_KEY_ICC_STATE))); |
| } else if (action.equals(TelephonyIntents.ACTION_RADIO_TECHNOLOGY_CHANGED)) { |
| String newPhone = intent.getStringExtra(Phone.PHONE_NAME_KEY); |
| Log.d(LOG_TAG, "Radio technology switched. Now " + newPhone + " is active."); |
| initForNewRadioTechnology(); |
| } else if (action.equals(TelephonyIntents.ACTION_SERVICE_STATE_CHANGED)) { |
| handleServiceStateChanged(intent); |
| } else if (action.equals(TelephonyIntents.ACTION_EMERGENCY_CALLBACK_MODE_CHANGED)) { |
| if (phone.getPhoneType() == Phone.PHONE_TYPE_CDMA) { |
| Log.d(LOG_TAG, "Emergency Callback Mode arrived in PhoneApp."); |
| // Start Emergency Callback Mode service |
| if (intent.getBooleanExtra("phoneinECMState", false)) { |
| context.startService(new Intent(context, |
| EmergencyCallbackModeService.class)); |
| } |
| } else { |
| Log.e(LOG_TAG, "Error! Emergency Callback Mode not supported for " + |
| phone.getPhoneName() + " phones"); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Broadcast receiver for the ACTION_MEDIA_BUTTON broadcast intent. |
| * |
| * This functionality isn't lumped in with the other intents in |
| * PhoneAppBroadcastReceiver because we instantiate this as a totally |
| * separate BroadcastReceiver instance, since we need to manually |
| * adjust its IntentFilter's priority (to make sure we get these |
| * intents *before* the media player.) |
| */ |
| private class MediaButtonBroadcastReceiver extends BroadcastReceiver { |
| @Override |
| public void onReceive(Context context, Intent intent) { |
| KeyEvent event = (KeyEvent) intent.getParcelableExtra(Intent.EXTRA_KEY_EVENT); |
| if (VDBG) Log.d(LOG_TAG, |
| "MediaButtonBroadcastReceiver.onReceive()... event = " + event); |
| if ((event != null) |
| && (event.getKeyCode() == KeyEvent.KEYCODE_HEADSETHOOK) |
| && (event.getAction() == KeyEvent.ACTION_DOWN)) { |
| |
| if (event.getRepeatCount() == 0) { |
| // Mute ONLY on the initial keypress. |
| if (VDBG) Log.d(LOG_TAG, "MediaButtonBroadcastReceiver: HEADSETHOOK down!"); |
| boolean consumed = PhoneUtils.handleHeadsetHook(phone); |
| if (VDBG) Log.d(LOG_TAG, "==> handleHeadsetHook(): consumed = " + consumed); |
| if (consumed) { |
| // If a headset is attached and the press is consumed, also update |
| // any UI items (such as an InCallScreen mute button) that may need to |
| // be updated if their state changed. |
| if (isShowingCallScreen()) { |
| mInCallScreen.requestUpdateTouchUi(); |
| } |
| abortBroadcast(); |
| } |
| } else if (phone.getState() != Phone.State.IDLE) { |
| // As for any DOWN events other than the initial press, we consume |
| // (and ignore) those too if the phone is in use. (Otherwise the |
| // music player will handle them, which would be confusing.) |
| abortBroadcast(); |
| } |
| } |
| } |
| } |
| |
| private void handleServiceStateChanged(Intent intent) { |
| /** |
| * This used to handle updating EriTextWidgetProvider this routine |
| * and and listening for ACTION_SERVICE_STATE_CHANGED intents could |
| * be removed. But leaving just in case it might be needed in the near |
| * future. |
| */ |
| |
| // If service just returned, start sending out the queued messages |
| ServiceState ss = ServiceState.newFromBundle(intent.getExtras()); |
| |
| boolean hasService = true; |
| boolean isCdma = false; |
| String eriText = ""; |
| |
| if (ss != null) { |
| int state = ss.getState(); |
| NotificationMgr.getDefault().updateNetworkSelection(state); |
| switch (state) { |
| case ServiceState.STATE_OUT_OF_SERVICE: |
| case ServiceState.STATE_POWER_OFF: |
| hasService = false; |
| break; |
| } |
| } else { |
| hasService = false; |
| } |
| } |
| |
| public boolean isOtaCallInActiveState() { |
| boolean otaCallActive = false; |
| if (mInCallScreen != null) { |
| otaCallActive = mInCallScreen.isOtaCallInActiveState(); |
| } |
| if (VDBG) Log.d(LOG_TAG, "- isOtaCallInActiveState " + otaCallActive); |
| return otaCallActive; |
| } |
| |
| public boolean isOtaCallInEndState() { |
| boolean otaCallEnded = false; |
| if (mInCallScreen != null) { |
| otaCallEnded = mInCallScreen.isOtaCallInEndState(); |
| } |
| if (VDBG) Log.d(LOG_TAG, "- isOtaCallInEndState " + otaCallEnded); |
| return otaCallEnded; |
| } |
| |
| // it is safe to call clearOtaState() even if the InCallScreen isn't active |
| public void clearOtaState() { |
| if (DBG) Log.d(LOG_TAG, "- clearOtaState ..."); |
| if ((mInCallScreen != null) |
| && (mInCallScreen.otaUtils != null)) { |
| mInCallScreen.otaUtils.cleanOtaScreen(true); |
| if (DBG) Log.d(LOG_TAG, " - clearOtaState clears OTA screen"); |
| } |
| } |
| |
| // it is safe to call dismissOtaDialogs() even if the InCallScreen isn't active |
| public void dismissOtaDialogs() { |
| if (DBG) Log.d(LOG_TAG, "- dismissOtaDialogs ..."); |
| if ((mInCallScreen != null) |
| && (mInCallScreen.otaUtils != null)) { |
| mInCallScreen.otaUtils.dismissAllOtaDialogs(); |
| if (DBG) Log.d(LOG_TAG, " - dismissOtaDialogs clears OTA dialogs"); |
| } |
| } |
| |
| // it is safe to call clearInCallScreenMode() even if the InCallScreen isn't active |
| public void clearInCallScreenMode() { |
| if (DBG) Log.d(LOG_TAG, "- clearInCallScreenMode ..."); |
| if (mInCallScreen != null) { |
| mInCallScreen.resetInCallScreenMode(); |
| } |
| } |
| } |
