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.ims.ImsManager; 20 import com.android.internal.telephony.Phone; 21 import com.android.internal.telephony.PhoneConstants; 22 import com.android.internal.telephony.PhoneFactory; 23 import com.android.internal.telephony.TelephonyIntents; 24 import com.android.internal.telephony.TelephonyProperties; 25 26 import java.util.ArrayList; 27 import java.util.Iterator; 28 import java.util.List; 29 30 import android.app.ActionBar; 31 import android.app.AlertDialog; 32 import android.content.BroadcastReceiver; 33 import android.content.Context; 34 import android.content.DialogInterface; 35 import android.content.Intent; 36 import android.content.IntentFilter; 37 import android.content.pm.PackageManager.NameNotFoundException; 38 import android.net.Uri; 39 import android.os.AsyncResult; 40 import android.os.Bundle; 41 import android.os.Handler; 42 import android.os.Message; 43 import android.os.PersistableBundle; 44 import android.os.SystemProperties; 45 import android.os.UserHandle; 46 import android.os.UserManager; 47 import android.preference.ListPreference; 48 import android.preference.Preference; 49 import android.preference.PreferenceActivity; 50 import android.preference.PreferenceScreen; 51 import android.preference.SwitchPreference; 52 import android.telephony.CarrierConfigManager; 53 import android.telephony.PhoneStateListener; 54 import android.telephony.SubscriptionInfo; 55 import android.telephony.SubscriptionManager; 56 import android.telephony.TelephonyManager; 57 import android.text.TextUtils; 58 import android.util.Log; 59 import android.view.MenuItem; 60 import android.view.View; 61 import android.widget.TabHost.OnTabChangeListener; 62 import android.widget.TabHost.TabContentFactory; 63 import android.widget.TabHost.TabSpec; 64 import android.widget.TabHost; 65 66 /** 67 * "Mobile network settings" screen. This preference screen lets you 68 * enable/disable mobile data, and control data roaming and other 69 * network-specific mobile data features. It's used on non-voice-capable 70 * tablets as well as regular phone devices. 71 * 72 * Note that this PreferenceActivity is part of the phone app, even though 73 * you reach it from the "Wireless & Networks" section of the main 74 * Settings app. It's not part of the "Call settings" hierarchy that's 75 * available from the Phone app (see CallFeaturesSetting for that.) 76 */ 77 public class MobileNetworkSettings extends PreferenceActivity 78 implements DialogInterface.OnClickListener, 79 DialogInterface.OnDismissListener, Preference.OnPreferenceChangeListener{ 80 81 // debug data 82 private static final String LOG_TAG = "NetworkSettings"; 83 private static final boolean DBG = true; 84 public static final int REQUEST_CODE_EXIT_ECM = 17; 85 86 // Number of active Subscriptions to show tabs 87 private static final int TAB_THRESHOLD = 2; 88 89 //String keys for preference lookup 90 private static final String BUTTON_PREFERED_NETWORK_MODE = "preferred_network_mode_key"; 91 private static final String BUTTON_ROAMING_KEY = "button_roaming_key"; 92 private static final String BUTTON_CDMA_LTE_DATA_SERVICE_KEY = "cdma_lte_data_service_key"; 93 private static final String BUTTON_ENABLED_NETWORKS_KEY = "enabled_networks_key"; 94 private static final String BUTTON_4G_LTE_KEY = "enhanced_4g_lte"; 95 private static final String BUTTON_CELL_BROADCAST_SETTINGS = "cell_broadcast_settings"; 96 private static final String BUTTON_APN_EXPAND_KEY = "button_apn_key"; 97 private static final String BUTTON_OPERATOR_SELECTION_EXPAND_KEY = "button_carrier_sel_key"; 98 private static final String BUTTON_CARRIER_SETTINGS_KEY = "carrier_settings_key"; 99 private static final String BUTTON_CDMA_SYSTEM_SELECT_KEY = "cdma_system_select_key"; 100 101 static final int preferredNetworkMode = Phone.PREFERRED_NT_MODE; 102 103 //Information about logical "up" Activity 104 private static final String UP_ACTIVITY_PACKAGE = "com.android.settings"; 105 private static final String UP_ACTIVITY_CLASS = 106 "com.android.settings.Settings$WirelessSettingsActivity"; 107 108 private SubscriptionManager mSubscriptionManager; 109 110 //UI objects 111 private ListPreference mButtonPreferredNetworkMode; 112 private ListPreference mButtonEnabledNetworks; 113 private SwitchPreference mButtonDataRoam; 114 private SwitchPreference mButton4glte; 115 private Preference mLteDataServicePref; 116 117 private static final String iface = "rmnet0"; //TODO: this will go away 118 private List<SubscriptionInfo> mActiveSubInfos; 119 120 private UserManager mUm; 121 private Phone mPhone; 122 private MyHandler mHandler; 123 private boolean mOkClicked; 124 125 // We assume the the value returned by mTabHost.getCurrentTab() == slotId 126 private TabHost mTabHost; 127 128 //GsmUmts options and Cdma options 129 GsmUmtsOptions mGsmUmtsOptions; 130 CdmaOptions mCdmaOptions; 131 132 private Preference mClickedPreference; 133 private boolean mShow4GForLTE; 134 private boolean mIsGlobalCdma; 135 private boolean mUnavailable; 136 137 private final PhoneStateListener mPhoneStateListener = new PhoneStateListener() { 138 /* 139 * Enable/disable the 'Enhanced 4G LTE Mode' when in/out of a call 140 * and depending on TTY mode and TTY support over VoLTE. 141 * @see android.telephony.PhoneStateListener#onCallStateChanged(int, 142 * java.lang.String) 143 */ 144 @Override 145 public void onCallStateChanged(int state, String incomingNumber) { 146 if (DBG) log("PhoneStateListener.onCallStateChanged: state=" + state); 147 boolean enabled = (state == TelephonyManager.CALL_STATE_IDLE) && 148 ImsManager.isNonTtyOrTtyOnVolteEnabled(getApplicationContext()); 149 Preference pref = getPreferenceScreen().findPreference(BUTTON_4G_LTE_KEY); 150 if (pref != null) pref.setEnabled(enabled && hasActiveSubscriptions()); 151 } 152 }; 153 154 private final BroadcastReceiver mPhoneChangeReceiver = new PhoneChangeReceiver(); 155 156 private class PhoneChangeReceiver extends BroadcastReceiver { 157 @Override onReceive(Context context, Intent intent)158 public void onReceive(Context context, Intent intent) { 159 if (DBG) log("onReceive:"); 160 // When the radio changes (ex: CDMA->GSM), refresh all options. 161 mGsmUmtsOptions = null; 162 mCdmaOptions = null; 163 updateBody(); 164 } 165 } 166 167 //This is a method implemented for DialogInterface.OnClickListener. 168 // Used to dismiss the dialogs when they come up. onClick(DialogInterface dialog, int which)169 public void onClick(DialogInterface dialog, int which) { 170 if (which == DialogInterface.BUTTON_POSITIVE) { 171 mPhone.setDataRoamingEnabled(true); 172 mOkClicked = true; 173 } else { 174 // Reset the toggle 175 mButtonDataRoam.setChecked(false); 176 } 177 } 178 179 @Override onDismiss(DialogInterface dialog)180 public void onDismiss(DialogInterface dialog) { 181 // Assuming that onClick gets called first 182 mButtonDataRoam.setChecked(mOkClicked); 183 } 184 185 /** 186 * Invoked on each preference click in this hierarchy, overrides 187 * PreferenceActivity's implementation. Used to make sure we track the 188 * preference click events. 189 */ 190 @Override onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference)191 public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference) { 192 /** TODO: Refactor and get rid of the if's using subclasses */ 193 final int phoneSubId = mPhone.getSubId(); 194 if (preference.getKey().equals(BUTTON_4G_LTE_KEY)) { 195 return true; 196 } else if (mGsmUmtsOptions != null && 197 mGsmUmtsOptions.preferenceTreeClick(preference) == true) { 198 return true; 199 } else if (mCdmaOptions != null && 200 mCdmaOptions.preferenceTreeClick(preference) == true) { 201 if (Boolean.parseBoolean( 202 SystemProperties.get(TelephonyProperties.PROPERTY_INECM_MODE))) { 203 204 mClickedPreference = preference; 205 206 // In ECM mode launch ECM app dialog 207 startActivityForResult( 208 new Intent(TelephonyIntents.ACTION_SHOW_NOTICE_ECM_BLOCK_OTHERS, null), 209 REQUEST_CODE_EXIT_ECM); 210 } 211 return true; 212 } else if (preference == mButtonPreferredNetworkMode) { 213 //displays the value taken from the Settings.System 214 int settingsNetworkMode = android.provider.Settings.Global.getInt(mPhone.getContext(). 215 getContentResolver(), 216 android.provider.Settings.Global.PREFERRED_NETWORK_MODE + phoneSubId, 217 preferredNetworkMode); 218 mButtonPreferredNetworkMode.setValue(Integer.toString(settingsNetworkMode)); 219 return true; 220 } else if (preference == mLteDataServicePref) { 221 String tmpl = android.provider.Settings.Global.getString(getContentResolver(), 222 android.provider.Settings.Global.SETUP_PREPAID_DATA_SERVICE_URL); 223 if (!TextUtils.isEmpty(tmpl)) { 224 TelephonyManager tm = (TelephonyManager) getSystemService( 225 Context.TELEPHONY_SERVICE); 226 String imsi = tm.getSubscriberId(); 227 if (imsi == null) { 228 imsi = ""; 229 } 230 final String url = TextUtils.isEmpty(tmpl) ? null 231 : TextUtils.expandTemplate(tmpl, imsi).toString(); 232 Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(url)); 233 startActivity(intent); 234 } else { 235 android.util.Log.e(LOG_TAG, "Missing SETUP_PREPAID_DATA_SERVICE_URL"); 236 } 237 return true; 238 } else if (preference == mButtonEnabledNetworks) { 239 int settingsNetworkMode = android.provider.Settings.Global.getInt(mPhone.getContext(). 240 getContentResolver(), 241 android.provider.Settings.Global.PREFERRED_NETWORK_MODE + phoneSubId, 242 preferredNetworkMode); 243 mButtonEnabledNetworks.setValue(Integer.toString(settingsNetworkMode)); 244 return true; 245 } else if (preference == mButtonDataRoam) { 246 // Do not disable the preference screen if the user clicks Data roaming. 247 return true; 248 } else { 249 // if the button is anything but the simple toggle preference, 250 // we'll need to disable all preferences to reject all click 251 // events until the sub-activity's UI comes up. 252 preferenceScreen.setEnabled(false); 253 // Let the intents be launched by the Preference manager 254 return false; 255 } 256 } 257 258 private final SubscriptionManager.OnSubscriptionsChangedListener mOnSubscriptionsChangeListener 259 = new SubscriptionManager.OnSubscriptionsChangedListener() { 260 @Override 261 public void onSubscriptionsChanged() { 262 if (DBG) log("onSubscriptionsChanged:"); 263 initializeSubscriptions(); 264 } 265 }; 266 initializeSubscriptions()267 private void initializeSubscriptions() { 268 int currentTab = 0; 269 if (DBG) log("initializeSubscriptions:+"); 270 271 // Before updating the the active subscription list check 272 // if tab updating is needed as the list is changing. 273 List<SubscriptionInfo> sil = mSubscriptionManager.getActiveSubscriptionInfoList(); 274 TabState state = isUpdateTabsNeeded(sil); 275 276 // Update to the active subscription list 277 mActiveSubInfos.clear(); 278 if (sil != null) { 279 mActiveSubInfos.addAll(sil); 280 // If there is only 1 sim then currenTab should represent slot no. of the sim. 281 if (sil.size() == 1) { 282 currentTab = sil.get(0).getSimSlotIndex(); 283 } 284 } 285 286 switch (state) { 287 case UPDATE: { 288 if (DBG) log("initializeSubscriptions: UPDATE"); 289 currentTab = mTabHost != null ? mTabHost.getCurrentTab() : 0; 290 291 setContentView(com.android.internal.R.layout.common_tab_settings); 292 293 mTabHost = (TabHost) findViewById(android.R.id.tabhost); 294 mTabHost.setup(); 295 296 // Update the tabName. Since the mActiveSubInfos are in slot order 297 // we can iterate though the tabs and subscription info in one loop. But 298 // we need to handle the case where a slot may be empty. 299 300 Iterator<SubscriptionInfo> siIterator = mActiveSubInfos.listIterator(); 301 SubscriptionInfo si = siIterator.hasNext() ? siIterator.next() : null; 302 for (int simSlotIndex = 0; simSlotIndex < mActiveSubInfos.size(); simSlotIndex++) { 303 String tabName; 304 if (si != null && si.getSimSlotIndex() == simSlotIndex) { 305 // Slot is not empty and we match 306 tabName = String.valueOf(si.getDisplayName()); 307 si = siIterator.hasNext() ? siIterator.next() : null; 308 } else { 309 // Slot is empty, set name to unknown 310 tabName = getResources().getString(R.string.unknown); 311 } 312 if (DBG) { 313 log("initializeSubscriptions: tab=" + simSlotIndex + " name=" + tabName); 314 } 315 316 mTabHost.addTab(buildTabSpec(String.valueOf(simSlotIndex), tabName)); 317 } 318 319 mTabHost.setOnTabChangedListener(mTabListener); 320 mTabHost.setCurrentTab(currentTab); 321 break; 322 } 323 case NO_TABS: { 324 if (DBG) log("initializeSubscriptions: NO_TABS"); 325 326 if (mTabHost != null) { 327 mTabHost.clearAllTabs(); 328 mTabHost = null; 329 } 330 setContentView(com.android.internal.R.layout.common_tab_settings); 331 break; 332 } 333 case DO_NOTHING: { 334 if (DBG) log("initializeSubscriptions: DO_NOTHING"); 335 if (mTabHost != null) { 336 currentTab = mTabHost.getCurrentTab(); 337 } 338 break; 339 } 340 } 341 updatePhone(currentTab); 342 updateBody(); 343 if (DBG) log("initializeSubscriptions:-"); 344 } 345 346 private enum TabState { 347 NO_TABS, UPDATE, DO_NOTHING 348 } isUpdateTabsNeeded(List<SubscriptionInfo> newSil)349 private TabState isUpdateTabsNeeded(List<SubscriptionInfo> newSil) { 350 TabState state = TabState.DO_NOTHING; 351 if (newSil == null) { 352 if (mActiveSubInfos.size() >= TAB_THRESHOLD) { 353 if (DBG) log("isUpdateTabsNeeded: NO_TABS, size unknown and was tabbed"); 354 state = TabState.NO_TABS; 355 } 356 } else if (newSil.size() < TAB_THRESHOLD && mActiveSubInfos.size() >= TAB_THRESHOLD) { 357 if (DBG) log("isUpdateTabsNeeded: NO_TABS, size went to small"); 358 state = TabState.NO_TABS; 359 } else if (newSil.size() >= TAB_THRESHOLD && mActiveSubInfos.size() < TAB_THRESHOLD) { 360 if (DBG) log("isUpdateTabsNeeded: UPDATE, size changed"); 361 state = TabState.UPDATE; 362 } else if (newSil.size() >= TAB_THRESHOLD) { 363 Iterator<SubscriptionInfo> siIterator = mActiveSubInfos.iterator(); 364 for(SubscriptionInfo newSi : newSil) { 365 SubscriptionInfo curSi = siIterator.next(); 366 if (!newSi.getDisplayName().equals(curSi.getDisplayName())) { 367 if (DBG) log("isUpdateTabsNeeded: UPDATE, new name=" + newSi.getDisplayName()); 368 state = TabState.UPDATE; 369 break; 370 } 371 } 372 } 373 if (DBG) { 374 log("isUpdateTabsNeeded:- " + state 375 + " newSil.size()=" + ((newSil != null) ? newSil.size() : 0) 376 + " mActiveSubInfos.size()=" + mActiveSubInfos.size()); 377 } 378 return state; 379 } 380 381 private OnTabChangeListener mTabListener = new OnTabChangeListener() { 382 @Override 383 public void onTabChanged(String tabId) { 384 if (DBG) log("onTabChanged:"); 385 // The User has changed tab; update the body. 386 updatePhone(Integer.parseInt(tabId)); 387 updateBody(); 388 } 389 }; 390 updatePhone(int slotId)391 private void updatePhone(int slotId) { 392 final SubscriptionInfo sir = mSubscriptionManager 393 .getActiveSubscriptionInfoForSimSlotIndex(slotId); 394 if (sir != null) { 395 mPhone = PhoneFactory.getPhone( 396 SubscriptionManager.getPhoneId(sir.getSubscriptionId())); 397 } 398 if (mPhone == null) { 399 // Do the best we can 400 mPhone = PhoneGlobals.getPhone(); 401 } 402 if (DBG) log("updatePhone:- slotId=" + slotId + " sir=" + sir); 403 } 404 405 private TabContentFactory mEmptyTabContent = new TabContentFactory() { 406 @Override 407 public View createTabContent(String tag) { 408 return new View(mTabHost.getContext()); 409 } 410 }; 411 buildTabSpec(String tag, String title)412 private TabSpec buildTabSpec(String tag, String title) { 413 return mTabHost.newTabSpec(tag).setIndicator(title).setContent( 414 mEmptyTabContent); 415 } 416 417 @Override onCreate(Bundle icicle)418 protected void onCreate(Bundle icicle) { 419 if (DBG) log("onCreate:+"); 420 setTheme(R.style.Theme_Material_Settings); 421 super.onCreate(icicle); 422 423 mHandler = new MyHandler(); 424 mUm = (UserManager) getSystemService(Context.USER_SERVICE); 425 mSubscriptionManager = SubscriptionManager.from(this); 426 427 if (mUm.hasUserRestriction(UserManager.DISALLOW_CONFIG_MOBILE_NETWORKS)) { 428 mUnavailable = true; 429 setContentView(R.layout.telephony_disallowed_preference_screen); 430 return; 431 } 432 433 addPreferencesFromResource(R.xml.network_setting); 434 435 mButton4glte = (SwitchPreference)findPreference(BUTTON_4G_LTE_KEY); 436 mButton4glte.setOnPreferenceChangeListener(this); 437 438 try { 439 Context con = createPackageContext("com.android.systemui", 0); 440 int id = con.getResources().getIdentifier("config_show4GForLTE", 441 "bool", "com.android.systemui"); 442 mShow4GForLTE = con.getResources().getBoolean(id); 443 } catch (NameNotFoundException e) { 444 loge("NameNotFoundException for show4GFotLTE"); 445 mShow4GForLTE = false; 446 } 447 448 //get UI object references 449 PreferenceScreen prefSet = getPreferenceScreen(); 450 451 mButtonDataRoam = (SwitchPreference) prefSet.findPreference(BUTTON_ROAMING_KEY); 452 mButtonPreferredNetworkMode = (ListPreference) prefSet.findPreference( 453 BUTTON_PREFERED_NETWORK_MODE); 454 mButtonEnabledNetworks = (ListPreference) prefSet.findPreference( 455 BUTTON_ENABLED_NETWORKS_KEY); 456 mButtonDataRoam.setOnPreferenceChangeListener(this); 457 458 mLteDataServicePref = prefSet.findPreference(BUTTON_CDMA_LTE_DATA_SERVICE_KEY); 459 460 // Initialize mActiveSubInfo 461 int max = mSubscriptionManager.getActiveSubscriptionInfoCountMax(); 462 mActiveSubInfos = new ArrayList<SubscriptionInfo>(max); 463 464 initializeSubscriptions(); 465 466 IntentFilter intentFilter = new IntentFilter( 467 TelephonyIntents.ACTION_RADIO_TECHNOLOGY_CHANGED); 468 registerReceiver(mPhoneChangeReceiver, intentFilter); 469 if (DBG) log("onCreate:-"); 470 } 471 472 @Override onDestroy()473 protected void onDestroy() { 474 super.onDestroy(); 475 unregisterReceiver(mPhoneChangeReceiver); 476 } 477 478 @Override onResume()479 protected void onResume() { 480 super.onResume(); 481 if (DBG) log("onResume:+"); 482 483 if (mUnavailable) { 484 if (DBG) log("onResume:- ignore mUnavailable == false"); 485 return; 486 } 487 488 // upon resumption from the sub-activity, make sure we re-enable the 489 // preferences. 490 getPreferenceScreen().setEnabled(true); 491 492 // Set UI state in onResume because a user could go home, launch some 493 // app to change this setting's backend, and re-launch this settings app 494 // and the UI state would be inconsistent with actual state 495 mButtonDataRoam.setChecked(mPhone.getDataRoamingEnabled()); 496 497 if (getPreferenceScreen().findPreference(BUTTON_PREFERED_NETWORK_MODE) != null 498 || getPreferenceScreen().findPreference(BUTTON_ENABLED_NETWORKS_KEY) != null) { 499 updatePreferredNetworkUIFromDb(); 500 } 501 502 if (ImsManager.isVolteEnabledByPlatform(this) 503 && ImsManager.isVolteProvisionedOnDevice(this)) { 504 TelephonyManager tm = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE); 505 tm.listen(mPhoneStateListener, PhoneStateListener.LISTEN_CALL_STATE); 506 } 507 508 // NOTE: Buttons will be enabled/disabled in mPhoneStateListener 509 boolean enh4glteMode = ImsManager.isEnhanced4gLteModeSettingEnabledByUser(this) 510 && ImsManager.isNonTtyOrTtyOnVolteEnabled(this); 511 mButton4glte.setChecked(enh4glteMode); 512 513 mSubscriptionManager.addOnSubscriptionsChangedListener(mOnSubscriptionsChangeListener); 514 515 if (DBG) log("onResume:-"); 516 517 } 518 hasActiveSubscriptions()519 private boolean hasActiveSubscriptions() { 520 return mActiveSubInfos.size() > 0; 521 } 522 updateBody()523 private void updateBody() { 524 final Context context = getApplicationContext(); 525 PreferenceScreen prefSet = getPreferenceScreen(); 526 boolean isLteOnCdma = mPhone.getLteOnCdmaMode() == PhoneConstants.LTE_ON_CDMA_TRUE; 527 final int phoneSubId = mPhone.getSubId(); 528 529 if (DBG) { 530 log("updateBody: isLteOnCdma=" + isLteOnCdma + " phoneSubId=" + phoneSubId); 531 } 532 533 if (prefSet != null) { 534 prefSet.removeAll(); 535 prefSet.addPreference(mButtonDataRoam); 536 prefSet.addPreference(mButtonPreferredNetworkMode); 537 prefSet.addPreference(mButtonEnabledNetworks); 538 prefSet.addPreference(mButton4glte); 539 } 540 541 int settingsNetworkMode = android.provider.Settings.Global.getInt( 542 mPhone.getContext().getContentResolver(), 543 android.provider.Settings.Global.PREFERRED_NETWORK_MODE + phoneSubId, 544 preferredNetworkMode); 545 546 PersistableBundle carrierConfig = 547 PhoneGlobals.getInstance().getCarrierConfigForSubId(mPhone.getSubId()); 548 mIsGlobalCdma = isLteOnCdma 549 && carrierConfig.getBoolean(CarrierConfigManager.KEY_SHOW_CDMA_CHOICES_BOOL); 550 if (carrierConfig.getBoolean(CarrierConfigManager.KEY_HIDE_CARRIER_NETWORK_SETTINGS_BOOL)) { 551 prefSet.removePreference(mButtonPreferredNetworkMode); 552 prefSet.removePreference(mButtonEnabledNetworks); 553 prefSet.removePreference(mLteDataServicePref); 554 } else if (carrierConfig.getBoolean(CarrierConfigManager 555 .KEY_HIDE_PREFERRED_NETWORK_TYPE_BOOL) 556 && !mPhone.getServiceState().getRoaming()) { 557 prefSet.removePreference(mButtonPreferredNetworkMode); 558 prefSet.removePreference(mButtonEnabledNetworks); 559 560 final int phoneType = mPhone.getPhoneType(); 561 if (phoneType == PhoneConstants.PHONE_TYPE_CDMA) { 562 mCdmaOptions = new CdmaOptions(this, prefSet, mPhone); 563 // In World mode force a refresh of GSM Options. 564 if (isWorldMode()) { 565 mGsmUmtsOptions = null; 566 } 567 } else if (phoneType == PhoneConstants.PHONE_TYPE_GSM) { 568 mGsmUmtsOptions = new GsmUmtsOptions(this, prefSet, phoneSubId); 569 } else { 570 throw new IllegalStateException("Unexpected phone type: " + phoneType); 571 } 572 // Since pref is being hidden from user, set network mode to default 573 // in case it is currently something else. That is possible if user 574 // changed the setting while roaming and is now back to home network. 575 settingsNetworkMode = preferredNetworkMode; 576 } else if (carrierConfig.getBoolean(CarrierConfigManager.KEY_WORLD_PHONE_BOOL) == true) { 577 prefSet.removePreference(mButtonEnabledNetworks); 578 // set the listener for the mButtonPreferredNetworkMode list preference so we can issue 579 // change Preferred Network Mode. 580 mButtonPreferredNetworkMode.setOnPreferenceChangeListener(this); 581 582 mCdmaOptions = new CdmaOptions(this, prefSet, mPhone); 583 mGsmUmtsOptions = new GsmUmtsOptions(this, prefSet, phoneSubId); 584 } else { 585 prefSet.removePreference(mButtonPreferredNetworkMode); 586 final int phoneType = mPhone.getPhoneType(); 587 if (phoneType == PhoneConstants.PHONE_TYPE_CDMA) { 588 int lteForced = android.provider.Settings.Global.getInt( 589 mPhone.getContext().getContentResolver(), 590 android.provider.Settings.Global.LTE_SERVICE_FORCED + mPhone.getSubId(), 591 0); 592 593 if (isLteOnCdma) { 594 if (lteForced == 0) { 595 mButtonEnabledNetworks.setEntries( 596 R.array.enabled_networks_cdma_choices); 597 mButtonEnabledNetworks.setEntryValues( 598 R.array.enabled_networks_cdma_values); 599 } else { 600 switch (settingsNetworkMode) { 601 case Phone.NT_MODE_CDMA: 602 case Phone.NT_MODE_CDMA_NO_EVDO: 603 case Phone.NT_MODE_EVDO_NO_CDMA: 604 mButtonEnabledNetworks.setEntries( 605 R.array.enabled_networks_cdma_no_lte_choices); 606 mButtonEnabledNetworks.setEntryValues( 607 R.array.enabled_networks_cdma_no_lte_values); 608 break; 609 case Phone.NT_MODE_GLOBAL: 610 case Phone.NT_MODE_LTE_CDMA_AND_EVDO: 611 case Phone.NT_MODE_LTE_CDMA_EVDO_GSM_WCDMA: 612 case Phone.NT_MODE_LTE_ONLY: 613 mButtonEnabledNetworks.setEntries( 614 R.array.enabled_networks_cdma_only_lte_choices); 615 mButtonEnabledNetworks.setEntryValues( 616 R.array.enabled_networks_cdma_only_lte_values); 617 break; 618 default: 619 mButtonEnabledNetworks.setEntries( 620 R.array.enabled_networks_cdma_choices); 621 mButtonEnabledNetworks.setEntryValues( 622 R.array.enabled_networks_cdma_values); 623 break; 624 } 625 } 626 } 627 mCdmaOptions = new CdmaOptions(this, prefSet, mPhone); 628 629 // In World mode force a refresh of GSM Options. 630 if (isWorldMode()) { 631 mGsmUmtsOptions = null; 632 } 633 } else if (phoneType == PhoneConstants.PHONE_TYPE_GSM) { 634 if (isSupportTdscdma()) { 635 mButtonEnabledNetworks.setEntries( 636 R.array.enabled_networks_tdscdma_choices); 637 mButtonEnabledNetworks.setEntryValues( 638 R.array.enabled_networks_tdscdma_values); 639 } else if (!carrierConfig.getBoolean(CarrierConfigManager.KEY_PREFER_2G_BOOL) 640 && !getResources().getBoolean(R.bool.config_enabled_lte)) { 641 mButtonEnabledNetworks.setEntries( 642 R.array.enabled_networks_except_gsm_lte_choices); 643 mButtonEnabledNetworks.setEntryValues( 644 R.array.enabled_networks_except_gsm_lte_values); 645 } else if (!carrierConfig.getBoolean(CarrierConfigManager.KEY_PREFER_2G_BOOL)) { 646 int select = (mShow4GForLTE == true) ? 647 R.array.enabled_networks_except_gsm_4g_choices 648 : R.array.enabled_networks_except_gsm_choices; 649 mButtonEnabledNetworks.setEntries(select); 650 mButtonEnabledNetworks.setEntryValues( 651 R.array.enabled_networks_except_gsm_values); 652 } else if (!getResources().getBoolean(R.bool.config_enabled_lte)) { 653 mButtonEnabledNetworks.setEntries( 654 R.array.enabled_networks_except_lte_choices); 655 mButtonEnabledNetworks.setEntryValues( 656 R.array.enabled_networks_except_lte_values); 657 } else if (mIsGlobalCdma) { 658 mButtonEnabledNetworks.setEntries( 659 R.array.enabled_networks_cdma_choices); 660 mButtonEnabledNetworks.setEntryValues( 661 R.array.enabled_networks_cdma_values); 662 } else { 663 int select = (mShow4GForLTE == true) ? R.array.enabled_networks_4g_choices 664 : R.array.enabled_networks_choices; 665 mButtonEnabledNetworks.setEntries(select); 666 mButtonEnabledNetworks.setEntryValues( 667 R.array.enabled_networks_values); 668 } 669 mGsmUmtsOptions = new GsmUmtsOptions(this, prefSet, phoneSubId); 670 } else { 671 throw new IllegalStateException("Unexpected phone type: " + phoneType); 672 } 673 if (isWorldMode()) { 674 mButtonEnabledNetworks.setEntries( 675 R.array.preferred_network_mode_choices_world_mode); 676 mButtonEnabledNetworks.setEntryValues( 677 R.array.preferred_network_mode_values_world_mode); 678 } 679 mButtonEnabledNetworks.setOnPreferenceChangeListener(this); 680 if (DBG) log("settingsNetworkMode: " + settingsNetworkMode); 681 } 682 683 final boolean missingDataServiceUrl = TextUtils.isEmpty( 684 android.provider.Settings.Global.getString(getContentResolver(), 685 android.provider.Settings.Global.SETUP_PREPAID_DATA_SERVICE_URL)); 686 if (!isLteOnCdma || missingDataServiceUrl) { 687 prefSet.removePreference(mLteDataServicePref); 688 } else { 689 android.util.Log.d(LOG_TAG, "keep ltePref"); 690 } 691 692 // Enable enhanced 4G LTE mode settings depending on whether exists on platform 693 if (!(ImsManager.isVolteEnabledByPlatform(this) 694 && ImsManager.isVolteProvisionedOnDevice(this))) { 695 Preference pref = prefSet.findPreference(BUTTON_4G_LTE_KEY); 696 if (pref != null) { 697 prefSet.removePreference(pref); 698 } 699 } 700 701 ActionBar actionBar = getActionBar(); 702 if (actionBar != null) { 703 // android.R.id.home will be triggered in onOptionsItemSelected() 704 actionBar.setDisplayHomeAsUpEnabled(true); 705 } 706 707 final boolean isSecondaryUser = UserHandle.myUserId() != UserHandle.USER_OWNER; 708 // Enable link to CMAS app settings depending on the value in config.xml. 709 final boolean isCellBroadcastAppLinkEnabled = this.getResources().getBoolean( 710 com.android.internal.R.bool.config_cellBroadcastAppLinks); 711 if (isSecondaryUser || !isCellBroadcastAppLinkEnabled 712 || mUm.hasUserRestriction(UserManager.DISALLOW_CONFIG_CELL_BROADCASTS)) { 713 PreferenceScreen root = getPreferenceScreen(); 714 Preference ps = findPreference(BUTTON_CELL_BROADCAST_SETTINGS); 715 if (ps != null) { 716 root.removePreference(ps); 717 } 718 } 719 720 // Get the networkMode from Settings.System and displays it 721 mButtonDataRoam.setChecked(mPhone.getDataRoamingEnabled()); 722 mButtonEnabledNetworks.setValue(Integer.toString(settingsNetworkMode)); 723 mButtonPreferredNetworkMode.setValue(Integer.toString(settingsNetworkMode)); 724 UpdatePreferredNetworkModeSummary(settingsNetworkMode); 725 UpdateEnabledNetworksValueAndSummary(settingsNetworkMode); 726 // Display preferred network type based on what modem returns b/18676277 727 mPhone.setPreferredNetworkType(settingsNetworkMode, mHandler 728 .obtainMessage(MyHandler.MESSAGE_SET_PREFERRED_NETWORK_TYPE)); 729 730 /** 731 * Enable/disable depending upon if there are any active subscriptions. 732 * 733 * I've decided to put this enable/disable code at the bottom as the 734 * code above works even when there are no active subscriptions, thus 735 * putting it afterwards is a smaller change. This can be refined later, 736 * but you do need to remember that this all needs to work when subscriptions 737 * change dynamically such as when hot swapping sims. 738 */ 739 boolean hasActiveSubscriptions = hasActiveSubscriptions(); 740 TelephonyManager tm = (TelephonyManager) getSystemService( 741 Context.TELEPHONY_SERVICE); 742 boolean canChange4glte = (tm.getCallState() == TelephonyManager.CALL_STATE_IDLE) && 743 ImsManager.isNonTtyOrTtyOnVolteEnabled(getApplicationContext()) && 744 carrierConfig.getBoolean(CarrierConfigManager.KEY_EDITABLE_ENHANCED_4G_LTE_BOOL); 745 mButtonDataRoam.setEnabled(hasActiveSubscriptions); 746 mButtonPreferredNetworkMode.setEnabled(hasActiveSubscriptions); 747 mButtonEnabledNetworks.setEnabled(hasActiveSubscriptions); 748 mButton4glte.setEnabled(hasActiveSubscriptions && canChange4glte); 749 mLteDataServicePref.setEnabled(hasActiveSubscriptions); 750 Preference ps; 751 PreferenceScreen root = getPreferenceScreen(); 752 ps = findPreference(BUTTON_CELL_BROADCAST_SETTINGS); 753 if (ps != null) { 754 ps.setEnabled(hasActiveSubscriptions); 755 } 756 ps = findPreference(BUTTON_APN_EXPAND_KEY); 757 if (ps != null) { 758 ps.setEnabled(hasActiveSubscriptions); 759 } 760 ps = findPreference(BUTTON_OPERATOR_SELECTION_EXPAND_KEY); 761 if (ps != null) { 762 ps.setEnabled(hasActiveSubscriptions); 763 } 764 ps = findPreference(BUTTON_CARRIER_SETTINGS_KEY); 765 if (ps != null) { 766 ps.setEnabled(hasActiveSubscriptions); 767 } 768 ps = findPreference(BUTTON_CDMA_SYSTEM_SELECT_KEY); 769 if (ps != null) { 770 ps.setEnabled(hasActiveSubscriptions); 771 } 772 } 773 774 @Override onPause()775 protected void onPause() { 776 super.onPause(); 777 if (DBG) log("onPause:+"); 778 779 if (ImsManager.isVolteEnabledByPlatform(this) 780 && ImsManager.isVolteProvisionedOnDevice(this)) { 781 TelephonyManager tm = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE); 782 tm.listen(mPhoneStateListener, PhoneStateListener.LISTEN_NONE); 783 } 784 785 mSubscriptionManager 786 .removeOnSubscriptionsChangedListener(mOnSubscriptionsChangeListener); 787 if (DBG) log("onPause:-"); 788 } 789 790 /** 791 * Implemented to support onPreferenceChangeListener to look for preference 792 * changes specifically on CLIR. 793 * 794 * @param preference is the preference to be changed, should be mButtonCLIR. 795 * @param objValue should be the value of the selection, NOT its localized 796 * display value. 797 */ onPreferenceChange(Preference preference, Object objValue)798 public boolean onPreferenceChange(Preference preference, Object objValue) { 799 final int phoneSubId = mPhone.getSubId(); 800 if (preference == mButtonPreferredNetworkMode) { 801 //NOTE onPreferenceChange seems to be called even if there is no change 802 //Check if the button value is changed from the System.Setting 803 mButtonPreferredNetworkMode.setValue((String) objValue); 804 int buttonNetworkMode; 805 buttonNetworkMode = Integer.valueOf((String) objValue).intValue(); 806 int settingsNetworkMode = android.provider.Settings.Global.getInt( 807 mPhone.getContext().getContentResolver(), 808 android.provider.Settings.Global.PREFERRED_NETWORK_MODE + phoneSubId, 809 preferredNetworkMode); 810 if (buttonNetworkMode != settingsNetworkMode) { 811 int modemNetworkMode; 812 // if new mode is invalid ignore it 813 switch (buttonNetworkMode) { 814 case Phone.NT_MODE_WCDMA_PREF: 815 case Phone.NT_MODE_GSM_ONLY: 816 case Phone.NT_MODE_WCDMA_ONLY: 817 case Phone.NT_MODE_GSM_UMTS: 818 case Phone.NT_MODE_CDMA: 819 case Phone.NT_MODE_CDMA_NO_EVDO: 820 case Phone.NT_MODE_EVDO_NO_CDMA: 821 case Phone.NT_MODE_GLOBAL: 822 case Phone.NT_MODE_LTE_CDMA_AND_EVDO: 823 case Phone.NT_MODE_LTE_GSM_WCDMA: 824 case Phone.NT_MODE_LTE_CDMA_EVDO_GSM_WCDMA: 825 case Phone.NT_MODE_LTE_ONLY: 826 case Phone.NT_MODE_LTE_WCDMA: 827 case Phone.NT_MODE_TDSCDMA_ONLY: 828 case Phone.NT_MODE_TDSCDMA_WCDMA: 829 case Phone.NT_MODE_LTE_TDSCDMA: 830 case Phone.NT_MODE_TDSCDMA_GSM: 831 case Phone.NT_MODE_LTE_TDSCDMA_GSM: 832 case Phone.NT_MODE_TDSCDMA_GSM_WCDMA: 833 case Phone.NT_MODE_LTE_TDSCDMA_WCDMA: 834 case Phone.NT_MODE_LTE_TDSCDMA_GSM_WCDMA: 835 case Phone.NT_MODE_TDSCDMA_CDMA_EVDO_GSM_WCDMA: 836 case Phone.NT_MODE_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA: 837 // This is one of the modes we recognize 838 modemNetworkMode = buttonNetworkMode; 839 break; 840 default: 841 loge("Invalid Network Mode (" + buttonNetworkMode + ") chosen. Ignore."); 842 return true; 843 } 844 845 android.provider.Settings.Global.putInt(mPhone.getContext().getContentResolver(), 846 android.provider.Settings.Global.PREFERRED_NETWORK_MODE + phoneSubId, 847 buttonNetworkMode ); 848 //Set the modem network mode 849 mPhone.setPreferredNetworkType(modemNetworkMode, mHandler 850 .obtainMessage(MyHandler.MESSAGE_SET_PREFERRED_NETWORK_TYPE)); 851 } 852 } else if (preference == mButtonEnabledNetworks) { 853 mButtonEnabledNetworks.setValue((String) objValue); 854 int buttonNetworkMode; 855 buttonNetworkMode = Integer.valueOf((String) objValue).intValue(); 856 if (DBG) log("buttonNetworkMode: " + buttonNetworkMode); 857 int settingsNetworkMode = android.provider.Settings.Global.getInt( 858 mPhone.getContext().getContentResolver(), 859 android.provider.Settings.Global.PREFERRED_NETWORK_MODE + phoneSubId, 860 preferredNetworkMode); 861 if (buttonNetworkMode != settingsNetworkMode) { 862 int modemNetworkMode; 863 // if new mode is invalid ignore it 864 switch (buttonNetworkMode) { 865 case Phone.NT_MODE_WCDMA_PREF: 866 case Phone.NT_MODE_GSM_ONLY: 867 case Phone.NT_MODE_LTE_GSM_WCDMA: 868 case Phone.NT_MODE_LTE_CDMA_EVDO_GSM_WCDMA: 869 case Phone.NT_MODE_CDMA: 870 case Phone.NT_MODE_CDMA_NO_EVDO: 871 case Phone.NT_MODE_LTE_CDMA_AND_EVDO: 872 case Phone.NT_MODE_TDSCDMA_ONLY: 873 case Phone.NT_MODE_TDSCDMA_WCDMA: 874 case Phone.NT_MODE_LTE_TDSCDMA: 875 case Phone.NT_MODE_TDSCDMA_GSM: 876 case Phone.NT_MODE_LTE_TDSCDMA_GSM: 877 case Phone.NT_MODE_TDSCDMA_GSM_WCDMA: 878 case Phone.NT_MODE_LTE_TDSCDMA_WCDMA: 879 case Phone.NT_MODE_LTE_TDSCDMA_GSM_WCDMA: 880 case Phone.NT_MODE_TDSCDMA_CDMA_EVDO_GSM_WCDMA: 881 case Phone.NT_MODE_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA: 882 // This is one of the modes we recognize 883 modemNetworkMode = buttonNetworkMode; 884 break; 885 default: 886 loge("Invalid Network Mode (" + buttonNetworkMode + ") chosen. Ignore."); 887 return true; 888 } 889 890 UpdateEnabledNetworksValueAndSummary(buttonNetworkMode); 891 892 android.provider.Settings.Global.putInt(mPhone.getContext().getContentResolver(), 893 android.provider.Settings.Global.PREFERRED_NETWORK_MODE + phoneSubId, 894 buttonNetworkMode ); 895 //Set the modem network mode 896 mPhone.setPreferredNetworkType(modemNetworkMode, mHandler 897 .obtainMessage(MyHandler.MESSAGE_SET_PREFERRED_NETWORK_TYPE)); 898 } 899 } else if (preference == mButton4glte) { 900 SwitchPreference enhanced4gModePref = (SwitchPreference) preference; 901 boolean enhanced4gMode = !enhanced4gModePref.isChecked(); 902 enhanced4gModePref.setChecked(enhanced4gMode); 903 ImsManager.setEnhanced4gLteModeSetting(this, enhanced4gModePref.isChecked()); 904 } else if (preference == mButtonDataRoam) { 905 if (DBG) log("onPreferenceTreeClick: preference == mButtonDataRoam."); 906 907 //normally called on the toggle click 908 if (!mButtonDataRoam.isChecked()) { 909 // First confirm with a warning dialog about charges 910 mOkClicked = false; 911 new AlertDialog.Builder(this).setMessage( 912 getResources().getString(R.string.roaming_warning)) 913 .setTitle(R.string.roaming_alert_title) 914 .setIconAttribute(android.R.attr.alertDialogIcon) 915 .setPositiveButton(android.R.string.yes, this) 916 .setNegativeButton(android.R.string.no, this) 917 .show() 918 .setOnDismissListener(this); 919 } else { 920 mPhone.setDataRoamingEnabled(false); 921 } 922 return true; 923 } 924 925 updateBody(); 926 // always let the preference setting proceed. 927 return true; 928 } 929 930 private class MyHandler extends Handler { 931 932 static final int MESSAGE_SET_PREFERRED_NETWORK_TYPE = 0; 933 934 @Override handleMessage(Message msg)935 public void handleMessage(Message msg) { 936 switch (msg.what) { 937 case MESSAGE_SET_PREFERRED_NETWORK_TYPE: 938 handleSetPreferredNetworkTypeResponse(msg); 939 break; 940 } 941 } 942 handleSetPreferredNetworkTypeResponse(Message msg)943 private void handleSetPreferredNetworkTypeResponse(Message msg) { 944 AsyncResult ar = (AsyncResult) msg.obj; 945 final int phoneSubId = mPhone.getSubId(); 946 947 if (ar.exception == null) { 948 int networkMode; 949 if (getPreferenceScreen().findPreference(BUTTON_PREFERED_NETWORK_MODE) != null) { 950 networkMode = Integer.valueOf( 951 mButtonPreferredNetworkMode.getValue()).intValue(); 952 android.provider.Settings.Global.putInt(mPhone.getContext().getContentResolver(), 953 android.provider.Settings.Global.PREFERRED_NETWORK_MODE + phoneSubId, 954 networkMode ); 955 } 956 if (getPreferenceScreen().findPreference(BUTTON_ENABLED_NETWORKS_KEY) != null) { 957 networkMode = Integer.valueOf( 958 mButtonEnabledNetworks.getValue()).intValue(); 959 android.provider.Settings.Global.putInt(mPhone.getContext().getContentResolver(), 960 android.provider.Settings.Global.PREFERRED_NETWORK_MODE + phoneSubId, 961 networkMode ); 962 } 963 } else { 964 if (DBG) { 965 log("handleSetPreferredNetworkTypeResponse: exception in setting network mode."); 966 } 967 updatePreferredNetworkUIFromDb(); 968 } 969 } 970 } 971 updatePreferredNetworkUIFromDb()972 private void updatePreferredNetworkUIFromDb() { 973 final int phoneSubId = mPhone.getSubId(); 974 975 int settingsNetworkMode = android.provider.Settings.Global.getInt( 976 mPhone.getContext().getContentResolver(), 977 android.provider.Settings.Global.PREFERRED_NETWORK_MODE + phoneSubId, 978 preferredNetworkMode); 979 980 if (DBG) { 981 log("updatePreferredNetworkUIFromDb: settingsNetworkMode = " + 982 settingsNetworkMode); 983 } 984 985 UpdatePreferredNetworkModeSummary(settingsNetworkMode); 986 UpdateEnabledNetworksValueAndSummary(settingsNetworkMode); 987 // changes the mButtonPreferredNetworkMode accordingly to settingsNetworkMode 988 mButtonPreferredNetworkMode.setValue(Integer.toString(settingsNetworkMode)); 989 } 990 UpdatePreferredNetworkModeSummary(int NetworkMode)991 private void UpdatePreferredNetworkModeSummary(int NetworkMode) { 992 switch(NetworkMode) { 993 case Phone.NT_MODE_TDSCDMA_GSM_WCDMA: 994 case Phone.NT_MODE_TDSCDMA_GSM: 995 case Phone.NT_MODE_WCDMA_PREF: 996 mButtonPreferredNetworkMode.setSummary( 997 R.string.preferred_network_mode_wcdma_perf_summary); 998 break; 999 case Phone.NT_MODE_GSM_ONLY: 1000 mButtonPreferredNetworkMode.setSummary( 1001 R.string.preferred_network_mode_gsm_only_summary); 1002 break; 1003 case Phone.NT_MODE_TDSCDMA_WCDMA: 1004 case Phone.NT_MODE_WCDMA_ONLY: 1005 mButtonPreferredNetworkMode.setSummary( 1006 R.string.preferred_network_mode_wcdma_only_summary); 1007 break; 1008 case Phone.NT_MODE_GSM_UMTS: 1009 mButtonPreferredNetworkMode.setSummary( 1010 R.string.preferred_network_mode_gsm_wcdma_summary); 1011 break; 1012 case Phone.NT_MODE_CDMA: 1013 switch (mPhone.getLteOnCdmaMode()) { 1014 case PhoneConstants.LTE_ON_CDMA_TRUE: 1015 mButtonPreferredNetworkMode.setSummary( 1016 R.string.preferred_network_mode_cdma_summary); 1017 break; 1018 case PhoneConstants.LTE_ON_CDMA_FALSE: 1019 default: 1020 mButtonPreferredNetworkMode.setSummary( 1021 R.string.preferred_network_mode_cdma_evdo_summary); 1022 break; 1023 } 1024 break; 1025 case Phone.NT_MODE_CDMA_NO_EVDO: 1026 mButtonPreferredNetworkMode.setSummary( 1027 R.string.preferred_network_mode_cdma_only_summary); 1028 break; 1029 case Phone.NT_MODE_EVDO_NO_CDMA: 1030 mButtonPreferredNetworkMode.setSummary( 1031 R.string.preferred_network_mode_evdo_only_summary); 1032 break; 1033 case Phone.NT_MODE_LTE_TDSCDMA: 1034 case Phone.NT_MODE_LTE_ONLY: 1035 mButtonPreferredNetworkMode.setSummary( 1036 R.string.preferred_network_mode_lte_summary); 1037 break; 1038 case Phone.NT_MODE_LTE_TDSCDMA_GSM: 1039 case Phone.NT_MODE_LTE_TDSCDMA_GSM_WCDMA: 1040 case Phone.NT_MODE_LTE_GSM_WCDMA: 1041 mButtonPreferredNetworkMode.setSummary( 1042 R.string.preferred_network_mode_lte_gsm_wcdma_summary); 1043 break; 1044 case Phone.NT_MODE_LTE_CDMA_AND_EVDO: 1045 mButtonPreferredNetworkMode.setSummary( 1046 R.string.preferred_network_mode_lte_cdma_evdo_summary); 1047 break; 1048 case Phone.NT_MODE_TDSCDMA_ONLY: 1049 mButtonPreferredNetworkMode.setSummary( 1050 R.string.preferred_network_mode_tdscdma_summary); 1051 break; 1052 case Phone.NT_MODE_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA: 1053 case Phone.NT_MODE_LTE_CDMA_EVDO_GSM_WCDMA: 1054 if (mPhone.getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA || 1055 mIsGlobalCdma || 1056 isWorldMode()) { 1057 mButtonPreferredNetworkMode.setSummary( 1058 R.string.preferred_network_mode_global_summary); 1059 } else { 1060 mButtonPreferredNetworkMode.setSummary( 1061 R.string.preferred_network_mode_lte_summary); 1062 } 1063 break; 1064 case Phone.NT_MODE_TDSCDMA_CDMA_EVDO_GSM_WCDMA: 1065 case Phone.NT_MODE_GLOBAL: 1066 mButtonPreferredNetworkMode.setSummary( 1067 R.string.preferred_network_mode_cdma_evdo_gsm_wcdma_summary); 1068 break; 1069 case Phone.NT_MODE_LTE_TDSCDMA_WCDMA: 1070 case Phone.NT_MODE_LTE_WCDMA: 1071 mButtonPreferredNetworkMode.setSummary( 1072 R.string.preferred_network_mode_lte_wcdma_summary); 1073 break; 1074 default: 1075 mButtonPreferredNetworkMode.setSummary( 1076 R.string.preferred_network_mode_global_summary); 1077 } 1078 } 1079 UpdateEnabledNetworksValueAndSummary(int NetworkMode)1080 private void UpdateEnabledNetworksValueAndSummary(int NetworkMode) { 1081 switch (NetworkMode) { 1082 case Phone.NT_MODE_TDSCDMA_WCDMA: 1083 case Phone.NT_MODE_TDSCDMA_GSM_WCDMA: 1084 case Phone.NT_MODE_TDSCDMA_GSM: 1085 mButtonEnabledNetworks.setValue( 1086 Integer.toString(Phone.NT_MODE_TDSCDMA_GSM_WCDMA)); 1087 mButtonEnabledNetworks.setSummary(R.string.network_3G); 1088 break; 1089 case Phone.NT_MODE_WCDMA_ONLY: 1090 case Phone.NT_MODE_GSM_UMTS: 1091 case Phone.NT_MODE_WCDMA_PREF: 1092 if (!mIsGlobalCdma) { 1093 mButtonEnabledNetworks.setValue( 1094 Integer.toString(Phone.NT_MODE_WCDMA_PREF)); 1095 mButtonEnabledNetworks.setSummary(R.string.network_3G); 1096 } else { 1097 mButtonEnabledNetworks.setValue( 1098 Integer.toString(Phone.NT_MODE_LTE_CDMA_EVDO_GSM_WCDMA)); 1099 mButtonEnabledNetworks.setSummary(R.string.network_global); 1100 } 1101 break; 1102 case Phone.NT_MODE_GSM_ONLY: 1103 if (!mIsGlobalCdma) { 1104 mButtonEnabledNetworks.setValue( 1105 Integer.toString(Phone.NT_MODE_GSM_ONLY)); 1106 mButtonEnabledNetworks.setSummary(R.string.network_2G); 1107 } else { 1108 mButtonEnabledNetworks.setValue( 1109 Integer.toString(Phone.NT_MODE_LTE_CDMA_EVDO_GSM_WCDMA)); 1110 mButtonEnabledNetworks.setSummary(R.string.network_global); 1111 } 1112 break; 1113 case Phone.NT_MODE_LTE_GSM_WCDMA: 1114 if (isWorldMode()) { 1115 mButtonEnabledNetworks.setSummary( 1116 R.string.preferred_network_mode_lte_gsm_umts_summary); 1117 controlCdmaOptions(false); 1118 controlGsmOptions(true); 1119 break; 1120 } 1121 case Phone.NT_MODE_LTE_ONLY: 1122 case Phone.NT_MODE_LTE_WCDMA: 1123 if (!mIsGlobalCdma) { 1124 mButtonEnabledNetworks.setValue( 1125 Integer.toString(Phone.NT_MODE_LTE_GSM_WCDMA)); 1126 mButtonEnabledNetworks.setSummary((mShow4GForLTE == true) 1127 ? R.string.network_4G : R.string.network_lte); 1128 } else { 1129 mButtonEnabledNetworks.setValue( 1130 Integer.toString(Phone.NT_MODE_LTE_CDMA_EVDO_GSM_WCDMA)); 1131 mButtonEnabledNetworks.setSummary(R.string.network_global); 1132 } 1133 break; 1134 case Phone.NT_MODE_LTE_CDMA_AND_EVDO: 1135 if (isWorldMode()) { 1136 mButtonEnabledNetworks.setSummary( 1137 R.string.preferred_network_mode_lte_cdma_summary); 1138 controlCdmaOptions(true); 1139 controlGsmOptions(false); 1140 } else { 1141 mButtonEnabledNetworks.setValue( 1142 Integer.toString(Phone.NT_MODE_LTE_CDMA_AND_EVDO)); 1143 mButtonEnabledNetworks.setSummary(R.string.network_lte); 1144 } 1145 break; 1146 case Phone.NT_MODE_TDSCDMA_CDMA_EVDO_GSM_WCDMA: 1147 mButtonEnabledNetworks.setValue( 1148 Integer.toString(Phone.NT_MODE_TDSCDMA_CDMA_EVDO_GSM_WCDMA)); 1149 mButtonEnabledNetworks.setSummary(R.string.network_3G); 1150 break; 1151 case Phone.NT_MODE_CDMA: 1152 case Phone.NT_MODE_EVDO_NO_CDMA: 1153 case Phone.NT_MODE_GLOBAL: 1154 mButtonEnabledNetworks.setValue( 1155 Integer.toString(Phone.NT_MODE_CDMA)); 1156 mButtonEnabledNetworks.setSummary(R.string.network_3G); 1157 break; 1158 case Phone.NT_MODE_CDMA_NO_EVDO: 1159 mButtonEnabledNetworks.setValue( 1160 Integer.toString(Phone.NT_MODE_CDMA_NO_EVDO)); 1161 mButtonEnabledNetworks.setSummary(R.string.network_1x); 1162 break; 1163 case Phone.NT_MODE_TDSCDMA_ONLY: 1164 mButtonEnabledNetworks.setValue( 1165 Integer.toString(Phone.NT_MODE_TDSCDMA_ONLY)); 1166 mButtonEnabledNetworks.setSummary(R.string.network_tdscdma); 1167 break; 1168 case Phone.NT_MODE_LTE_TDSCDMA_GSM: 1169 case Phone.NT_MODE_LTE_TDSCDMA_GSM_WCDMA: 1170 case Phone.NT_MODE_LTE_TDSCDMA: 1171 case Phone.NT_MODE_LTE_TDSCDMA_WCDMA: 1172 case Phone.NT_MODE_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA: 1173 case Phone.NT_MODE_LTE_CDMA_EVDO_GSM_WCDMA: 1174 if (isSupportTdscdma()) { 1175 mButtonEnabledNetworks.setValue( 1176 Integer.toString(Phone.NT_MODE_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA)); 1177 mButtonEnabledNetworks.setSummary(R.string.network_lte); 1178 } else { 1179 if (isWorldMode()) { 1180 controlCdmaOptions(true); 1181 controlGsmOptions(false); 1182 } 1183 mButtonEnabledNetworks.setValue( 1184 Integer.toString(Phone.NT_MODE_LTE_CDMA_EVDO_GSM_WCDMA)); 1185 if (mPhone.getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA || 1186 mIsGlobalCdma || 1187 isWorldMode()) { 1188 mButtonEnabledNetworks.setSummary(R.string.network_global); 1189 } else { 1190 mButtonEnabledNetworks.setSummary((mShow4GForLTE == true) 1191 ? R.string.network_4G : R.string.network_lte); 1192 } 1193 } 1194 break; 1195 default: 1196 String errMsg = "Invalid Network Mode (" + NetworkMode + "). Ignore."; 1197 loge(errMsg); 1198 mButtonEnabledNetworks.setSummary(errMsg); 1199 } 1200 } 1201 1202 @Override onActivityResult(int requestCode, int resultCode, Intent data)1203 protected void onActivityResult(int requestCode, int resultCode, Intent data) { 1204 switch(requestCode) { 1205 case REQUEST_CODE_EXIT_ECM: 1206 Boolean isChoiceYes = 1207 data.getBooleanExtra(EmergencyCallbackModeExitDialog.EXTRA_EXIT_ECM_RESULT, false); 1208 if (isChoiceYes) { 1209 // If the phone exits from ECM mode, show the CDMA Options 1210 mCdmaOptions.showDialog(mClickedPreference); 1211 } else { 1212 // do nothing 1213 } 1214 break; 1215 1216 default: 1217 break; 1218 } 1219 } 1220 log(String msg)1221 private static void log(String msg) { 1222 Log.d(LOG_TAG, msg); 1223 } 1224 loge(String msg)1225 private static void loge(String msg) { 1226 Log.e(LOG_TAG, msg); 1227 } 1228 1229 @Override onOptionsItemSelected(MenuItem item)1230 public boolean onOptionsItemSelected(MenuItem item) { 1231 final int itemId = item.getItemId(); 1232 if (itemId == android.R.id.home) { // See ActionBar#setDisplayHomeAsUpEnabled() 1233 // Commenting out "logical up" capability. This is a workaround for issue 5278083. 1234 // 1235 // Settings app may not launch this activity via UP_ACTIVITY_CLASS but the other 1236 // Activity that looks exactly same as UP_ACTIVITY_CLASS ("SubSettings" Activity). 1237 // At that moment, this Activity launches UP_ACTIVITY_CLASS on top of the Activity. 1238 // which confuses users. 1239 // TODO: introduce better mechanism for "up" capability here. 1240 /*Intent intent = new Intent(Intent.ACTION_MAIN); 1241 intent.setClassName(UP_ACTIVITY_PACKAGE, UP_ACTIVITY_CLASS); 1242 intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP); 1243 startActivity(intent);*/ 1244 finish(); 1245 return true; 1246 } 1247 return super.onOptionsItemSelected(item); 1248 } 1249 isWorldMode()1250 private boolean isWorldMode() { 1251 boolean worldModeOn = false; 1252 final TelephonyManager tm = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE); 1253 final String configString = getResources().getString(R.string.config_world_mode); 1254 1255 if (!TextUtils.isEmpty(configString)) { 1256 String[] configArray = configString.split(";"); 1257 // Check if we have World mode configuration set to True only or config is set to True 1258 // and SIM GID value is also set and matches to the current SIM GID. 1259 if (configArray != null && 1260 ((configArray.length == 1 && configArray[0].equalsIgnoreCase("true")) || 1261 (configArray.length == 2 && !TextUtils.isEmpty(configArray[1]) && 1262 tm != null && configArray[1].equalsIgnoreCase(tm.getGroupIdLevel1())))) { 1263 worldModeOn = true; 1264 } 1265 } 1266 1267 if (DBG) { 1268 log("isWorldMode=" + worldModeOn); 1269 } 1270 1271 return worldModeOn; 1272 } 1273 controlGsmOptions(boolean enable)1274 private void controlGsmOptions(boolean enable) { 1275 PreferenceScreen prefSet = getPreferenceScreen(); 1276 if (prefSet == null) { 1277 return; 1278 } 1279 1280 if (mGsmUmtsOptions == null) { 1281 mGsmUmtsOptions = new GsmUmtsOptions(this, prefSet, mPhone.getSubId()); 1282 } 1283 PreferenceScreen apnExpand = 1284 (PreferenceScreen) prefSet.findPreference(BUTTON_APN_EXPAND_KEY); 1285 PreferenceScreen operatorSelectionExpand = 1286 (PreferenceScreen) prefSet.findPreference(BUTTON_OPERATOR_SELECTION_EXPAND_KEY); 1287 PreferenceScreen carrierSettings = 1288 (PreferenceScreen) prefSet.findPreference(BUTTON_CARRIER_SETTINGS_KEY); 1289 if (apnExpand != null) { 1290 apnExpand.setEnabled(isWorldMode() || enable); 1291 } 1292 if (operatorSelectionExpand != null) { 1293 if (enable) { 1294 operatorSelectionExpand.setEnabled(true); 1295 } else { 1296 prefSet.removePreference(operatorSelectionExpand); 1297 } 1298 } 1299 if (carrierSettings != null) { 1300 prefSet.removePreference(carrierSettings); 1301 } 1302 } 1303 controlCdmaOptions(boolean enable)1304 private void controlCdmaOptions(boolean enable) { 1305 PreferenceScreen prefSet = getPreferenceScreen(); 1306 if (prefSet == null) { 1307 return; 1308 } 1309 if (enable && mCdmaOptions == null) { 1310 mCdmaOptions = new CdmaOptions(this, prefSet, mPhone); 1311 } 1312 CdmaSystemSelectListPreference systemSelect = 1313 (CdmaSystemSelectListPreference)prefSet.findPreference 1314 (BUTTON_CDMA_SYSTEM_SELECT_KEY); 1315 if (systemSelect != null) { 1316 systemSelect.setEnabled(enable); 1317 } 1318 } 1319 isSupportTdscdma()1320 private boolean isSupportTdscdma() { 1321 if (getResources().getBoolean(R.bool.config_support_tdscdma)) { 1322 return true; 1323 } 1324 1325 String operatorNumeric = mPhone.getServiceState().getOperatorNumeric(); 1326 String[] numericArray = getResources().getStringArray( 1327 R.array.config_support_tdscdma_roaming_on_networks); 1328 if (numericArray.length == 0 || operatorNumeric == null) { 1329 return false; 1330 } 1331 for (String numeric : numericArray) { 1332 if (operatorNumeric.equals(numeric)) { 1333 return true; 1334 } 1335 } 1336 return false; 1337 } 1338 } 1339