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 android.app.Activity; 20 import android.app.KeyguardManager; 21 import android.app.ProgressDialog; 22 import android.content.BroadcastReceiver; 23 import android.content.ContentResolver; 24 import android.content.Context; 25 import android.content.ContextWrapper; 26 import android.content.Intent; 27 import android.content.IntentFilter; 28 import android.media.AudioManager; 29 import android.net.ConnectivityManager; 30 import android.net.Uri; 31 import android.os.AsyncResult; 32 import android.os.Bundle; 33 import android.os.Handler; 34 import android.os.Message; 35 import android.os.PersistableBundle; 36 import android.os.PowerManager; 37 import android.os.SystemClock; 38 import android.os.SystemProperties; 39 import android.os.UpdateLock; 40 import android.os.UserManager; 41 import android.preference.PreferenceManager; 42 import android.provider.Settings; 43 import android.telephony.CarrierConfigManager; 44 import android.telephony.ServiceState; 45 import android.telephony.SubscriptionManager; 46 import android.util.Log; 47 import android.widget.Toast; 48 49 import com.android.internal.telephony.Call; 50 import com.android.internal.telephony.CallManager; 51 import com.android.internal.telephony.IccCardConstants; 52 import com.android.internal.telephony.MmiCode; 53 import com.android.internal.telephony.Phone; 54 import com.android.internal.telephony.PhoneConstants; 55 import com.android.internal.telephony.PhoneFactory; 56 import com.android.internal.telephony.TelephonyCapabilities; 57 import com.android.internal.telephony.TelephonyIntents; 58 import com.android.phone.common.CallLogAsync; 59 import com.android.phone.settings.SettingsConstants; 60 import com.android.services.telephony.activation.SimActivationManager; 61 import com.android.services.telephony.sip.SipUtil; 62 63 /** 64 * Global state for the telephony subsystem when running in the primary 65 * phone process. 66 */ 67 public class PhoneGlobals extends ContextWrapper { 68 public static final String LOG_TAG = "PhoneApp"; 69 70 /** 71 * Phone app-wide debug level: 72 * 0 - no debug logging 73 * 1 - normal debug logging if ro.debuggable is set (which is true in 74 * "eng" and "userdebug" builds but not "user" builds) 75 * 2 - ultra-verbose debug logging 76 * 77 * Most individual classes in the phone app have a local DBG constant, 78 * typically set to 79 * (PhoneApp.DBG_LEVEL >= 1) && (SystemProperties.getInt("ro.debuggable", 0) == 1) 80 * or else 81 * (PhoneApp.DBG_LEVEL >= 2) 82 * depending on the desired verbosity. 83 * 84 * ***** DO NOT SUBMIT WITH DBG_LEVEL > 0 ************* 85 */ 86 public static final int DBG_LEVEL = 0; 87 88 private static final boolean DBG = 89 (PhoneGlobals.DBG_LEVEL >= 1) && (SystemProperties.getInt("ro.debuggable", 0) == 1); 90 private static final boolean VDBG = (PhoneGlobals.DBG_LEVEL >= 2); 91 92 // Message codes; see mHandler below. 93 private static final int EVENT_SIM_NETWORK_LOCKED = 3; 94 private static final int EVENT_SIM_STATE_CHANGED = 8; 95 private static final int EVENT_DATA_ROAMING_DISCONNECTED = 10; 96 private static final int EVENT_DATA_ROAMING_OK = 11; 97 private static final int EVENT_UNSOL_CDMA_INFO_RECORD = 12; 98 private static final int EVENT_RESTART_SIP = 13; 99 100 // The MMI codes are also used by the InCallScreen. 101 public static final int MMI_INITIATE = 51; 102 public static final int MMI_COMPLETE = 52; 103 public static final int MMI_CANCEL = 53; 104 // Don't use message codes larger than 99 here; those are reserved for 105 // the individual Activities of the Phone UI. 106 107 public static final int AIRPLANE_ON = 1; 108 public static final int AIRPLANE_OFF = 0; 109 110 /** 111 * Allowable values for the wake lock code. 112 * SLEEP means the device can be put to sleep. 113 * PARTIAL means wake the processor, but we display can be kept off. 114 * FULL means wake both the processor and the display. 115 */ 116 public enum WakeState { 117 SLEEP, 118 PARTIAL, 119 FULL 120 } 121 122 private static PhoneGlobals sMe; 123 124 // A few important fields we expose to the rest of the package 125 // directly (rather than thru set/get methods) for efficiency. 126 CallController callController; 127 CallManager mCM; 128 CallNotifier notifier; 129 CallerInfoCache callerInfoCache; 130 NotificationMgr notificationMgr; 131 public PhoneInterfaceManager phoneMgr; 132 public SimActivationManager simActivationManager; 133 CarrierConfigLoader configLoader; 134 135 private CallGatewayManager callGatewayManager; 136 private Phone phoneInEcm; 137 138 static boolean sVoiceCapable = true; 139 140 // TODO: Remove, no longer used. 141 CdmaPhoneCallState cdmaPhoneCallState; 142 143 // The currently-active PUK entry activity and progress dialog. 144 // Normally, these are the Emergency Dialer and the subsequent 145 // progress dialog. null if there is are no such objects in 146 // the foreground. 147 private Activity mPUKEntryActivity; 148 private ProgressDialog mPUKEntryProgressDialog; 149 150 private boolean mDataDisconnectedDueToRoaming = false; 151 152 private WakeState mWakeState = WakeState.SLEEP; 153 154 private PowerManager mPowerManager; 155 private PowerManager.WakeLock mWakeLock; 156 private PowerManager.WakeLock mPartialWakeLock; 157 private KeyguardManager mKeyguardManager; 158 159 private UpdateLock mUpdateLock; 160 161 // Broadcast receiver for various intent broadcasts (see onCreate()) 162 private final BroadcastReceiver mReceiver = new PhoneAppBroadcastReceiver(); 163 164 /** 165 * The singleton OtaUtils instance used for OTASP calls. 166 * 167 * The OtaUtils instance is created lazily the first time we need to 168 * make an OTASP call, regardless of whether it's an interactive or 169 * non-interactive OTASP call. 170 */ 171 public OtaUtils otaUtils; 172 173 // Following are the CDMA OTA information Objects used during OTA Call. 174 // cdmaOtaProvisionData object store static OTA information that needs 175 // to be maintained even during Slider open/close scenarios. 176 // cdmaOtaConfigData object stores configuration info to control visiblity 177 // of each OTA Screens. 178 // cdmaOtaScreenState object store OTA Screen State information. 179 public OtaUtils.CdmaOtaProvisionData cdmaOtaProvisionData; 180 public OtaUtils.CdmaOtaConfigData cdmaOtaConfigData; 181 public OtaUtils.CdmaOtaScreenState cdmaOtaScreenState; 182 public OtaUtils.CdmaOtaInCallScreenUiState cdmaOtaInCallScreenUiState; 183 184 Handler mHandler = new Handler() { 185 @Override 186 public void handleMessage(Message msg) { 187 PhoneConstants.State phoneState; 188 switch (msg.what) { 189 // TODO: This event should be handled by the lock screen, just 190 // like the "SIM missing" and "Sim locked" cases (bug 1804111). 191 case EVENT_SIM_NETWORK_LOCKED: 192 if (getCarrierConfig().getBoolean( 193 CarrierConfigManager.KEY_IGNORE_SIM_NETWORK_LOCKED_EVENTS_BOOL)) { 194 // Some products don't have the concept of a "SIM network lock" 195 Log.i(LOG_TAG, "Ignoring EVENT_SIM_NETWORK_LOCKED event; " 196 + "not showing 'SIM network unlock' PIN entry screen"); 197 } else { 198 // Normal case: show the "SIM network unlock" PIN entry screen. 199 // The user won't be able to do anything else until 200 // they enter a valid SIM network PIN. 201 Log.i(LOG_TAG, "show sim depersonal panel"); 202 IccNetworkDepersonalizationPanel.showDialog(); 203 } 204 break; 205 206 case EVENT_DATA_ROAMING_DISCONNECTED: 207 notificationMgr.showDataDisconnectedRoaming(); 208 break; 209 210 case EVENT_DATA_ROAMING_OK: 211 notificationMgr.hideDataDisconnectedRoaming(); 212 break; 213 214 case MMI_COMPLETE: 215 onMMIComplete((AsyncResult) msg.obj); 216 break; 217 218 case MMI_CANCEL: 219 PhoneUtils.cancelMmiCode(mCM.getFgPhone()); 220 break; 221 222 case EVENT_SIM_STATE_CHANGED: 223 // Marks the event where the SIM goes into ready state. 224 // Right now, this is only used for the PUK-unlocking 225 // process. 226 if (msg.obj.equals(IccCardConstants.INTENT_VALUE_ICC_READY)) { 227 // when the right event is triggered and there 228 // are UI objects in the foreground, we close 229 // them to display the lock panel. 230 if (mPUKEntryActivity != null) { 231 mPUKEntryActivity.finish(); 232 mPUKEntryActivity = null; 233 } 234 if (mPUKEntryProgressDialog != null) { 235 mPUKEntryProgressDialog.dismiss(); 236 mPUKEntryProgressDialog = null; 237 } 238 } 239 break; 240 241 case EVENT_UNSOL_CDMA_INFO_RECORD: 242 //TODO: handle message here; 243 break; 244 case EVENT_RESTART_SIP: 245 // This should only run if the Phone process crashed and was restarted. We do 246 // not want this running if the device is still in the FBE encrypted state. 247 // This is the same procedure that is triggered in the SipBroadcastReceiver 248 // upon BOOT_COMPLETED. 249 UserManager userManager = UserManager.get(sMe); 250 if (userManager != null && userManager.isUserUnlocked()) { 251 SipUtil.startSipService(); 252 } 253 break; 254 } 255 } 256 }; 257 258 public PhoneGlobals(Context context) { 259 super(context); 260 sMe = this; 261 } 262 263 public void onCreate() { 264 if (VDBG) Log.v(LOG_TAG, "onCreate()..."); 265 266 ContentResolver resolver = getContentResolver(); 267 268 // Cache the "voice capable" flag. 269 // This flag currently comes from a resource (which is 270 // overrideable on a per-product basis): 271 sVoiceCapable = 272 getResources().getBoolean(com.android.internal.R.bool.config_voice_capable); 273 // ...but this might eventually become a PackageManager "system 274 // feature" instead, in which case we'd do something like: 275 // sVoiceCapable = 276 // getPackageManager().hasSystemFeature(PackageManager.FEATURE_TELEPHONY_VOICE_CALLS); 277 278 if (mCM == null) { 279 // Initialize the telephony framework 280 PhoneFactory.makeDefaultPhones(this); 281 282 // Start TelephonyDebugService After the default phone is created. 283 Intent intent = new Intent(this, TelephonyDebugService.class); 284 startService(intent); 285 286 mCM = CallManager.getInstance(); 287 for (Phone phone : PhoneFactory.getPhones()) { 288 mCM.registerPhone(phone); 289 } 290 291 // Create the NotificationMgr singleton, which is used to display 292 // status bar icons and control other status bar behavior. 293 notificationMgr = NotificationMgr.init(this); 294 295 // If PhoneGlobals has crashed and is being restarted, then restart. 296 mHandler.sendEmptyMessage(EVENT_RESTART_SIP); 297 298 // Create an instance of CdmaPhoneCallState and initialize it to IDLE 299 cdmaPhoneCallState = new CdmaPhoneCallState(); 300 cdmaPhoneCallState.CdmaPhoneCallStateInit(); 301 302 // before registering for phone state changes 303 mPowerManager = (PowerManager) getSystemService(Context.POWER_SERVICE); 304 mWakeLock = mPowerManager.newWakeLock(PowerManager.FULL_WAKE_LOCK, LOG_TAG); 305 // lock used to keep the processor awake, when we don't care for the display. 306 mPartialWakeLock = mPowerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK 307 | PowerManager.ON_AFTER_RELEASE, LOG_TAG); 308 309 mKeyguardManager = (KeyguardManager) getSystemService(Context.KEYGUARD_SERVICE); 310 311 // Get UpdateLock to suppress system-update related events (e.g. dialog show-up) 312 // during phone calls. 313 mUpdateLock = new UpdateLock("phone"); 314 315 if (DBG) Log.d(LOG_TAG, "onCreate: mUpdateLock: " + mUpdateLock); 316 317 CallLogger callLogger = new CallLogger(this, new CallLogAsync()); 318 319 callGatewayManager = CallGatewayManager.getInstance(); 320 321 // Create the CallController singleton, which is the interface 322 // to the telephony layer for user-initiated telephony functionality 323 // (like making outgoing calls.) 324 callController = CallController.init(this, callLogger, callGatewayManager); 325 326 // Create the CallerInfoCache singleton, which remembers custom ring tone and 327 // send-to-voicemail settings. 328 // 329 // The asynchronous caching will start just after this call. 330 callerInfoCache = CallerInfoCache.init(this); 331 332 phoneMgr = PhoneInterfaceManager.init(this, PhoneFactory.getDefaultPhone()); 333 334 configLoader = CarrierConfigLoader.init(this); 335 336 // Create the CallNotifer singleton, which handles 337 // asynchronous events from the telephony layer (like 338 // launching the incoming-call UI when an incoming call comes 339 // in.) 340 notifier = CallNotifier.init(this); 341 342 PhoneUtils.registerIccStatus(mHandler, EVENT_SIM_NETWORK_LOCKED); 343 344 // register for MMI/USSD 345 mCM.registerForMmiComplete(mHandler, MMI_COMPLETE, null); 346 347 // register connection tracking to PhoneUtils 348 PhoneUtils.initializeConnectionHandler(mCM); 349 350 // Register for misc other intent broadcasts. 351 IntentFilter intentFilter = 352 new IntentFilter(Intent.ACTION_AIRPLANE_MODE_CHANGED); 353 intentFilter.addAction(TelephonyIntents.ACTION_ANY_DATA_CONNECTION_STATE_CHANGED); 354 intentFilter.addAction(TelephonyIntents.ACTION_SIM_STATE_CHANGED); 355 intentFilter.addAction(TelephonyIntents.ACTION_RADIO_TECHNOLOGY_CHANGED); 356 intentFilter.addAction(TelephonyIntents.ACTION_SERVICE_STATE_CHANGED); 357 intentFilter.addAction(TelephonyIntents.ACTION_EMERGENCY_CALLBACK_MODE_CHANGED); 358 registerReceiver(mReceiver, intentFilter); 359 360 //set the default values for the preferences in the phone. 361 PreferenceManager.setDefaultValues(this, R.xml.network_setting, false); 362 363 PreferenceManager.setDefaultValues(this, R.xml.call_feature_setting, false); 364 365 // Make sure the audio mode (along with some 366 // audio-mode-related state of our own) is initialized 367 // correctly, given the current state of the phone. 368 PhoneUtils.setAudioMode(mCM); 369 } 370 371 cdmaOtaProvisionData = new OtaUtils.CdmaOtaProvisionData(); 372 cdmaOtaConfigData = new OtaUtils.CdmaOtaConfigData(); 373 cdmaOtaScreenState = new OtaUtils.CdmaOtaScreenState(); 374 cdmaOtaInCallScreenUiState = new OtaUtils.CdmaOtaInCallScreenUiState(); 375 376 simActivationManager = new SimActivationManager(); 377 378 // XXX pre-load the SimProvider so that it's ready 379 resolver.getType(Uri.parse("content://icc/adn")); 380 381 // TODO: Register for Cdma Information Records 382 // phone.registerCdmaInformationRecord(mHandler, EVENT_UNSOL_CDMA_INFO_RECORD, null); 383 384 // Read HAC settings and configure audio hardware 385 if (getResources().getBoolean(R.bool.hac_enabled)) { 386 int hac = android.provider.Settings.System.getInt( 387 getContentResolver(), 388 android.provider.Settings.System.HEARING_AID, 389 0); 390 AudioManager audioManager = (AudioManager) getSystemService(Context.AUDIO_SERVICE); 391 audioManager.setParameter(SettingsConstants.HAC_KEY, 392 hac == SettingsConstants.HAC_ENABLED 393 ? SettingsConstants.HAC_VAL_ON : SettingsConstants.HAC_VAL_OFF); 394 } 395 } 396 397 /** 398 * Returns the singleton instance of the PhoneApp. 399 */ 400 public static PhoneGlobals getInstance() { 401 if (sMe == null) { 402 throw new IllegalStateException("No PhoneGlobals here!"); 403 } 404 return sMe; 405 } 406 407 /** 408 * Returns the singleton instance of the PhoneApp if running as the 409 * primary user, otherwise null. 410 */ 411 static PhoneGlobals getInstanceIfPrimary() { 412 return sMe; 413 } 414 415 /** 416 * Returns the default phone. 417 * 418 * WARNING: This method should be used carefully, now that there may be multiple phones. 419 */ 420 public static Phone getPhone() { 421 return PhoneFactory.getDefaultPhone(); 422 } 423 424 public static Phone getPhone(int subId) { 425 return PhoneFactory.getPhone(SubscriptionManager.getPhoneId(subId)); 426 } 427 428 /* package */ CallManager getCallManager() { 429 return mCM; 430 } 431 432 public PersistableBundle getCarrierConfig() { 433 return getCarrierConfigForSubId(SubscriptionManager.getDefaultSubscriptionId()); 434 } 435 436 public PersistableBundle getCarrierConfigForSubId(int subId) { 437 return configLoader.getConfigForSubId(subId); 438 } 439 440 /** 441 * Handles OTASP-related events from the telephony layer. 442 * 443 * While an OTASP call is active, the CallNotifier forwards 444 * OTASP-related telephony events to this method. 445 */ 446 void handleOtaspEvent(Message msg) { 447 if (DBG) Log.d(LOG_TAG, "handleOtaspEvent(message " + msg + ")..."); 448 449 if (otaUtils == null) { 450 // We shouldn't be getting OTASP events without ever 451 // having started the OTASP call in the first place! 452 Log.w(LOG_TAG, "handleOtaEvents: got an event but otaUtils is null! " 453 + "message = " + msg); 454 return; 455 } 456 457 otaUtils.onOtaProvisionStatusChanged((AsyncResult) msg.obj); 458 } 459 460 /** 461 * Similarly, handle the disconnect event of an OTASP call 462 * by forwarding it to the OtaUtils instance. 463 */ 464 /* package */ void handleOtaspDisconnect() { 465 if (DBG) Log.d(LOG_TAG, "handleOtaspDisconnect()..."); 466 467 if (otaUtils == null) { 468 // We shouldn't be getting OTASP events without ever 469 // having started the OTASP call in the first place! 470 Log.w(LOG_TAG, "handleOtaspDisconnect: otaUtils is null!"); 471 return; 472 } 473 474 otaUtils.onOtaspDisconnect(); 475 } 476 477 /** 478 * Sets the activity responsible for un-PUK-blocking the device 479 * so that we may close it when we receive a positive result. 480 * mPUKEntryActivity is also used to indicate to the device that 481 * we are trying to un-PUK-lock the phone. In other words, iff 482 * it is NOT null, then we are trying to unlock and waiting for 483 * the SIM to move to READY state. 484 * 485 * @param activity is the activity to close when PUK has 486 * finished unlocking. Can be set to null to indicate the unlock 487 * or SIM READYing process is over. 488 */ 489 void setPukEntryActivity(Activity activity) { 490 mPUKEntryActivity = activity; 491 } 492 493 Activity getPUKEntryActivity() { 494 return mPUKEntryActivity; 495 } 496 497 /** 498 * Sets the dialog responsible for notifying the user of un-PUK- 499 * blocking - SIM READYing progress, so that we may dismiss it 500 * when we receive a positive result. 501 * 502 * @param dialog indicates the progress dialog informing the user 503 * of the state of the device. Dismissed upon completion of 504 * READYing process 505 */ 506 void setPukEntryProgressDialog(ProgressDialog dialog) { 507 mPUKEntryProgressDialog = dialog; 508 } 509 510 /** 511 * Controls whether or not the screen is allowed to sleep. 512 * 513 * Once sleep is allowed (WakeState is SLEEP), it will rely on the 514 * settings for the poke lock to determine when to timeout and let 515 * the device sleep {@link PhoneGlobals#setScreenTimeout}. 516 * 517 * @param ws tells the device to how to wake. 518 */ 519 /* package */ void requestWakeState(WakeState ws) { 520 if (VDBG) Log.d(LOG_TAG, "requestWakeState(" + ws + ")..."); 521 synchronized (this) { 522 if (mWakeState != ws) { 523 switch (ws) { 524 case PARTIAL: 525 // acquire the processor wake lock, and release the FULL 526 // lock if it is being held. 527 mPartialWakeLock.acquire(); 528 if (mWakeLock.isHeld()) { 529 mWakeLock.release(); 530 } 531 break; 532 case FULL: 533 // acquire the full wake lock, and release the PARTIAL 534 // lock if it is being held. 535 mWakeLock.acquire(); 536 if (mPartialWakeLock.isHeld()) { 537 mPartialWakeLock.release(); 538 } 539 break; 540 case SLEEP: 541 default: 542 // release both the PARTIAL and FULL locks. 543 if (mWakeLock.isHeld()) { 544 mWakeLock.release(); 545 } 546 if (mPartialWakeLock.isHeld()) { 547 mPartialWakeLock.release(); 548 } 549 break; 550 } 551 mWakeState = ws; 552 } 553 } 554 } 555 556 /** 557 * If we are not currently keeping the screen on, then poke the power 558 * manager to wake up the screen for the user activity timeout duration. 559 */ 560 /* package */ void wakeUpScreen() { 561 synchronized (this) { 562 if (mWakeState == WakeState.SLEEP) { 563 if (DBG) Log.d(LOG_TAG, "pulse screen lock"); 564 mPowerManager.wakeUp(SystemClock.uptimeMillis(), "android.phone:WAKE"); 565 } 566 } 567 } 568 569 /** 570 * Sets the wake state and screen timeout based on the current state 571 * of the phone, and the current state of the in-call UI. 572 * 573 * This method is a "UI Policy" wrapper around 574 * {@link PhoneGlobals#requestWakeState} and {@link PhoneGlobals#setScreenTimeout}. 575 * 576 * It's safe to call this method regardless of the state of the Phone 577 * (e.g. whether or not it's idle), and regardless of the state of the 578 * Phone UI (e.g. whether or not the InCallScreen is active.) 579 */ 580 /* package */ void updateWakeState() { 581 PhoneConstants.State state = mCM.getState(); 582 583 // True if the speakerphone is in use. (If so, we *always* use 584 // the default timeout. Since the user is obviously not holding 585 // the phone up to his/her face, we don't need to worry about 586 // false touches, and thus don't need to turn the screen off so 587 // aggressively.) 588 // Note that we need to make a fresh call to this method any 589 // time the speaker state changes. (That happens in 590 // PhoneUtils.turnOnSpeaker().) 591 boolean isSpeakerInUse = (state == PhoneConstants.State.OFFHOOK) && PhoneUtils.isSpeakerOn(this); 592 593 // TODO (bug 1440854): The screen timeout *might* also need to 594 // depend on the bluetooth state, but this isn't as clear-cut as 595 // the speaker state (since while using BT it's common for the 596 // user to put the phone straight into a pocket, in which case the 597 // timeout should probably still be short.) 598 599 // Decide whether to force the screen on or not. 600 // 601 // Force the screen to be on if the phone is ringing or dialing, 602 // or if we're displaying the "Call ended" UI for a connection in 603 // the "disconnected" state. 604 // However, if the phone is disconnected while the user is in the 605 // middle of selecting a quick response message, we should not force 606 // the screen to be on. 607 // 608 boolean isRinging = (state == PhoneConstants.State.RINGING); 609 boolean isDialing = (mCM.getFgPhone().getForegroundCall().getState() == Call.State.DIALING); 610 boolean keepScreenOn = isRinging || isDialing; 611 // keepScreenOn == true means we'll hold a full wake lock: 612 requestWakeState(keepScreenOn ? WakeState.FULL : WakeState.SLEEP); 613 } 614 615 KeyguardManager getKeyguardManager() { 616 return mKeyguardManager; 617 } 618 619 private void onMMIComplete(AsyncResult r) { 620 if (VDBG) Log.d(LOG_TAG, "onMMIComplete()..."); 621 MmiCode mmiCode = (MmiCode) r.result; 622 PhoneUtils.displayMMIComplete(mmiCode.getPhone(), getInstance(), mmiCode, null, null); 623 } 624 625 private void initForNewRadioTechnology(int phoneId) { 626 if (DBG) Log.d(LOG_TAG, "initForNewRadioTechnology..."); 627 628 final Phone phone = PhoneFactory.getPhone(phoneId); 629 if (phone == null || !TelephonyCapabilities.supportsOtasp(phone)) { 630 // Clean up OTA for non-CDMA since it is only valid for CDMA. 631 clearOtaState(); 632 } 633 634 notifier.updateCallNotifierRegistrationsAfterRadioTechnologyChange(); 635 } 636 637 private void handleAirplaneModeChange(Context context, int newMode) { 638 int cellState = Settings.Global.getInt(context.getContentResolver(), 639 Settings.Global.CELL_ON, PhoneConstants.CELL_ON_FLAG); 640 boolean isAirplaneNewlyOn = (newMode == 1); 641 switch (cellState) { 642 case PhoneConstants.CELL_OFF_FLAG: 643 // Airplane mode does not affect the cell radio if user 644 // has turned it off. 645 break; 646 case PhoneConstants.CELL_ON_FLAG: 647 maybeTurnCellOff(context, isAirplaneNewlyOn); 648 break; 649 case PhoneConstants.CELL_OFF_DUE_TO_AIRPLANE_MODE_FLAG: 650 maybeTurnCellOn(context, isAirplaneNewlyOn); 651 break; 652 } 653 } 654 655 /* 656 * Returns true if the radio must be turned off when entering airplane mode. 657 */ 658 private boolean isCellOffInAirplaneMode(Context context) { 659 String airplaneModeRadios = Settings.Global.getString(context.getContentResolver(), 660 Settings.Global.AIRPLANE_MODE_RADIOS); 661 return airplaneModeRadios == null 662 || airplaneModeRadios.contains(Settings.Global.RADIO_CELL); 663 } 664 665 private void setRadioPowerOff(Context context) { 666 Log.i(LOG_TAG, "Turning radio off - airplane"); 667 Settings.Global.putInt(context.getContentResolver(), Settings.Global.CELL_ON, 668 PhoneConstants.CELL_OFF_DUE_TO_AIRPLANE_MODE_FLAG); 669 Settings.Global.putInt(getContentResolver(), Settings.Global.ENABLE_CELLULAR_ON_BOOT, 0); 670 PhoneUtils.setRadioPower(false); 671 } 672 673 private void setRadioPowerOn(Context context) { 674 Log.i(LOG_TAG, "Turning radio on - airplane"); 675 Settings.Global.putInt(context.getContentResolver(), Settings.Global.CELL_ON, 676 PhoneConstants.CELL_ON_FLAG); 677 Settings.Global.putInt(getContentResolver(), Settings.Global.ENABLE_CELLULAR_ON_BOOT, 678 1); 679 PhoneUtils.setRadioPower(true); 680 } 681 682 private void maybeTurnCellOff(Context context, boolean isAirplaneNewlyOn) { 683 if (isAirplaneNewlyOn) { 684 // If we are trying to turn off the radio, make sure there are no active 685 // emergency calls. If there are, switch airplane mode back to off. 686 if (PhoneUtils.isInEmergencyCall(mCM)) { 687 // Switch airplane mode back to off. 688 ConnectivityManager.from(this).setAirplaneMode(false); 689 Toast.makeText(this, R.string.radio_off_during_emergency_call, Toast.LENGTH_LONG) 690 .show(); 691 Log.i(LOG_TAG, "Ignoring airplane mode: emergency call. Turning airplane off"); 692 } else if (isCellOffInAirplaneMode(context)) { 693 setRadioPowerOff(context); 694 } else { 695 Log.i(LOG_TAG, "Ignoring airplane mode: settings prevent cell radio power off"); 696 } 697 } 698 } 699 700 private void maybeTurnCellOn(Context context, boolean isAirplaneNewlyOn) { 701 if (!isAirplaneNewlyOn) { 702 setRadioPowerOn(context); 703 } 704 } 705 706 /** 707 * Receiver for misc intent broadcasts the Phone app cares about. 708 */ 709 private class PhoneAppBroadcastReceiver extends BroadcastReceiver { 710 @Override 711 public void onReceive(Context context, Intent intent) { 712 String action = intent.getAction(); 713 if (action.equals(Intent.ACTION_AIRPLANE_MODE_CHANGED)) { 714 int airplaneMode = Settings.Global.getInt(getContentResolver(), 715 Settings.Global.AIRPLANE_MODE_ON, AIRPLANE_OFF); 716 // Treat any non-OFF values as ON. 717 if (airplaneMode != AIRPLANE_OFF) { 718 airplaneMode = AIRPLANE_ON; 719 } 720 handleAirplaneModeChange(context, airplaneMode); 721 } else if (action.equals(TelephonyIntents.ACTION_ANY_DATA_CONNECTION_STATE_CHANGED)) { 722 int subId = intent.getIntExtra(PhoneConstants.SUBSCRIPTION_KEY, 723 SubscriptionManager.INVALID_SUBSCRIPTION_ID); 724 int phoneId = SubscriptionManager.getPhoneId(subId); 725 String state = intent.getStringExtra(PhoneConstants.STATE_KEY); 726 if (VDBG) { 727 Log.d(LOG_TAG, "mReceiver: ACTION_ANY_DATA_CONNECTION_STATE_CHANGED"); 728 Log.d(LOG_TAG, "- state: " + state); 729 Log.d(LOG_TAG, "- reason: " 730 + intent.getStringExtra(PhoneConstants.STATE_CHANGE_REASON_KEY)); 731 Log.d(LOG_TAG, "- subId: " + subId); 732 Log.d(LOG_TAG, "- phoneId: " + phoneId); 733 } 734 Phone phone = SubscriptionManager.isValidPhoneId(phoneId) ? 735 PhoneFactory.getPhone(phoneId) : PhoneFactory.getDefaultPhone(); 736 737 // The "data disconnected due to roaming" notification is shown 738 // if (a) you have the "data roaming" feature turned off, and 739 // (b) you just lost data connectivity because you're roaming. 740 boolean disconnectedDueToRoaming = 741 !phone.getDataRoamingEnabled() 742 && PhoneConstants.DataState.DISCONNECTED.equals(state) 743 && Phone.REASON_ROAMING_ON.equals( 744 intent.getStringExtra(PhoneConstants.STATE_CHANGE_REASON_KEY)); 745 if (mDataDisconnectedDueToRoaming != disconnectedDueToRoaming) { 746 mDataDisconnectedDueToRoaming = disconnectedDueToRoaming; 747 mHandler.sendEmptyMessage(disconnectedDueToRoaming 748 ? EVENT_DATA_ROAMING_DISCONNECTED : EVENT_DATA_ROAMING_OK); 749 } 750 } else if ((action.equals(TelephonyIntents.ACTION_SIM_STATE_CHANGED)) && 751 (mPUKEntryActivity != null)) { 752 // if an attempt to un-PUK-lock the device was made, while we're 753 // receiving this state change notification, notify the handler. 754 // NOTE: This is ONLY triggered if an attempt to un-PUK-lock has 755 // been attempted. 756 mHandler.sendMessage(mHandler.obtainMessage(EVENT_SIM_STATE_CHANGED, 757 intent.getStringExtra(IccCardConstants.INTENT_KEY_ICC_STATE))); 758 } else if (action.equals(TelephonyIntents.ACTION_RADIO_TECHNOLOGY_CHANGED)) { 759 String newPhone = intent.getStringExtra(PhoneConstants.PHONE_NAME_KEY); 760 int phoneId = intent.getIntExtra(PhoneConstants.PHONE_KEY, 761 SubscriptionManager.INVALID_PHONE_INDEX); 762 Log.d(LOG_TAG, "Radio technology switched. Now " + newPhone + " (" + phoneId 763 + ") is active."); 764 initForNewRadioTechnology(phoneId); 765 } else if (action.equals(TelephonyIntents.ACTION_SERVICE_STATE_CHANGED)) { 766 handleServiceStateChanged(intent); 767 } else if (action.equals(TelephonyIntents.ACTION_EMERGENCY_CALLBACK_MODE_CHANGED)) { 768 int phoneId = intent.getIntExtra(PhoneConstants.PHONE_KEY, 0); 769 phoneInEcm = getPhone(phoneId); 770 Log.d(LOG_TAG, "Emergency Callback Mode. phoneId:" + phoneId); 771 if (phoneInEcm != null) { 772 if (TelephonyCapabilities.supportsEcm(phoneInEcm)) { 773 Log.d(LOG_TAG, "Emergency Callback Mode arrived in PhoneApp."); 774 // Start Emergency Callback Mode service 775 if (intent.getBooleanExtra("phoneinECMState", false)) { 776 context.startService(new Intent(context, 777 EmergencyCallbackModeService.class)); 778 } else { 779 phoneInEcm = null; 780 } 781 } else { 782 // It doesn't make sense to get ACTION_EMERGENCY_CALLBACK_MODE_CHANGED 783 // on a device that doesn't support ECM in the first place. 784 Log.e(LOG_TAG, "Got ACTION_EMERGENCY_CALLBACK_MODE_CHANGED, but " 785 + "ECM isn't supported for phone: " + phoneInEcm.getPhoneName()); 786 phoneInEcm = null; 787 } 788 } else { 789 Log.w(LOG_TAG, "phoneInEcm is null."); 790 } 791 } 792 } 793 } 794 795 private void handleServiceStateChanged(Intent intent) { 796 /** 797 * This used to handle updating EriTextWidgetProvider this routine 798 * and and listening for ACTION_SERVICE_STATE_CHANGED intents could 799 * be removed. But leaving just in case it might be needed in the near 800 * future. 801 */ 802 803 // If service just returned, start sending out the queued messages 804 Bundle extras = intent.getExtras(); 805 if (extras != null) { 806 ServiceState ss = ServiceState.newFromBundle(extras); 807 if (ss != null) { 808 int state = ss.getState(); 809 notificationMgr.updateNetworkSelection(state); 810 } 811 } 812 } 813 814 // it is safe to call clearOtaState() even if the InCallScreen isn't active 815 public void clearOtaState() { 816 if (DBG) Log.d(LOG_TAG, "- clearOtaState ..."); 817 if (otaUtils != null) { 818 otaUtils.cleanOtaScreen(true); 819 if (DBG) Log.d(LOG_TAG, " - clearOtaState clears OTA screen"); 820 } 821 } 822 823 // it is safe to call dismissOtaDialogs() even if the InCallScreen isn't active 824 public void dismissOtaDialogs() { 825 if (DBG) Log.d(LOG_TAG, "- dismissOtaDialogs ..."); 826 if (otaUtils != null) { 827 otaUtils.dismissAllOtaDialogs(); 828 if (DBG) Log.d(LOG_TAG, " - dismissOtaDialogs clears OTA dialogs"); 829 } 830 } 831 832 public Phone getPhoneInEcm() { 833 return phoneInEcm; 834 } 835 836 /** 837 * Triggers a refresh of the message waiting (voicemail) indicator. 838 * 839 * @param subId the subscription id we should refresh the notification for. 840 */ 841 public void refreshMwiIndicator(int subId) { 842 notificationMgr.refreshMwi(subId); 843 } 844 845 /** 846 * Dismisses the message waiting (voicemail) indicator. 847 * 848 * @param subId the subscription id we should dismiss the notification for. 849 */ 850 public void clearMwiIndicator(int subId) { 851 // Setting voiceMessageCount to 0 will remove the current notification and clear the system 852 // cached value. 853 Phone phone = getPhone(subId); 854 if (phone == null) { 855 Log.w(LOG_TAG, "clearMwiIndicator on null phone, subId:" + subId); 856 } else { 857 phone.setVoiceMessageCount(0); 858 } 859 } 860 861 /** 862 * Enables or disables the visual voicemail check for message waiting indicator. Default value 863 * is true. MWI is the traditional voicemail notification which should be suppressed if visual 864 * voicemail is active. {@link NotificationMgr#updateMwi(int, boolean, boolean)} currently 865 * checks the {@link android.provider.VoicemailContract.Status#CONFIGURATION_STATE} to suppress 866 * the MWI, but there are several issues. b/31229016 is a bug that when the device boots the 867 * configuration state will be cleared and the MWI for voicemail that arrives when the device 868 * is offline will be cleared, even if the account cannot be activated. A full solution will be 869 * adding a setMwiEnabled() method and stop checking the configuration state, but that is too 870 * risky at this moment. This is a temporary workaround to shut down the configuration state 871 * check if visual voicemail cannot be activated. 872 * <p>TODO(twyen): implement the setMwiEnabled() mentioned above. 873 * 874 * @param subId the account to set the enabled state 875 */ 876 public void setShouldCheckVisualVoicemailConfigurationForMwi(int subId, boolean enabled) { 877 notificationMgr.setShouldCheckVisualVoicemailConfigurationForMwi(subId, enabled); 878 } 879 } 880
