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