1 /* 2 * Copyright (C) 2006 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package com.android.phone; 18 19 import android.app.ActionBar; 20 import android.app.Activity; 21 import android.app.DialogFragment; 22 import android.app.Fragment; 23 import android.app.FragmentManager; 24 import android.content.BroadcastReceiver; 25 import android.content.ComponentName; 26 import android.content.ContentResolver; 27 import android.content.Context; 28 import android.content.Intent; 29 import android.content.IntentFilter; 30 import android.content.ServiceConnection; 31 import android.content.pm.PackageManager; 32 import android.content.pm.ResolveInfo; 33 import android.net.Uri; 34 import android.os.AsyncResult; 35 import android.os.Bundle; 36 import android.os.Handler; 37 import android.os.IBinder; 38 import android.os.Message; 39 import android.os.PersistableBundle; 40 import android.os.UserHandle; 41 import android.os.UserManager; 42 import android.preference.ListPreference; 43 import android.preference.Preference; 44 import android.preference.PreferenceCategory; 45 import android.preference.PreferenceFragment; 46 import android.preference.PreferenceScreen; 47 import android.preference.SwitchPreference; 48 import android.provider.Settings; 49 import android.telecom.PhoneAccountHandle; 50 import android.telecom.TelecomManager; 51 import android.telephony.CarrierConfigManager; 52 import android.telephony.PhoneStateListener; 53 import android.telephony.ServiceState; 54 import android.telephony.SubscriptionInfo; 55 import android.telephony.SubscriptionManager; 56 import android.telephony.TelephonyManager; 57 import android.telephony.euicc.EuiccManager; 58 import android.text.TextUtils; 59 import android.util.Log; 60 import android.view.LayoutInflater; 61 import android.view.MenuItem; 62 import android.view.View; 63 import android.view.ViewGroup; 64 import android.widget.TabHost; 65 66 import com.android.ims.ImsConfig; 67 import com.android.ims.ImsManager; 68 import com.android.internal.logging.MetricsLogger; 69 import com.android.internal.logging.nano.MetricsProto.MetricsEvent; 70 import com.android.internal.telephony.Phone; 71 import com.android.internal.telephony.PhoneConstants; 72 import com.android.internal.telephony.PhoneFactory; 73 import com.android.internal.telephony.TelephonyIntents; 74 import com.android.phone.settings.PhoneAccountSettingsFragment; 75 import com.android.settingslib.RestrictedLockUtils; 76 77 78 import java.util.ArrayList; 79 import java.util.Iterator; 80 import java.util.List; 81 82 /** 83 * "Mobile network settings" screen. This screen lets you 84 * enable/disable mobile data, and control data roaming and other 85 * network-specific mobile data features. It's used on non-voice-capable 86 * tablets as well as regular phone devices. 87 * 88 * Note that this Activity is part of the phone app, even though 89 * you reach it from the "Wireless & Networks" section of the main 90 * Settings app. It's not part of the "Call settings" hierarchy that's 91 * available from the Phone app (see CallFeaturesSetting for that.) 92 */ 93 94 public class MobileNetworkSettings extends Activity { 95 96 private enum TabState { 97 NO_TABS, UPDATE, DO_NOTHING 98 } 99 100 @Override 101 public void onCreate(Bundle savedInstanceState) { 102 super.onCreate(savedInstanceState); 103 setContentView(R.layout.network_setting); 104 105 FragmentManager fragmentManager = getFragmentManager(); 106 Fragment fragment = fragmentManager.findFragmentById(R.id.network_setting_content); 107 if (fragment == null) { 108 fragmentManager.beginTransaction() 109 .add(R.id.network_setting_content, new MobileNetworkFragment()) 110 .commit(); 111 } 112 } 113 114 @Override 115 public boolean onOptionsItemSelected(final MenuItem item) { 116 final int itemId = item.getItemId(); 117 switch (itemId) { 118 // Respond to the action bar's Up/Home button 119 case android.R.id.home: 120 finish(); 121 return true; 122 } 123 return super.onOptionsItemSelected(item); 124 } 125 126 127 /** 128 * Whether to show the entry point to eUICC settings. 129 * 130 * <p>We show the entry point on any device which supports eUICC as long as either the eUICC 131 * was ever provisioned (that is, at least one profile was ever downloaded onto it), or if 132 * the user has enabled development mode. 133 */ 134 public static boolean showEuiccSettings(Context context) { 135 EuiccManager euiccManager = 136 (EuiccManager) context.getSystemService(Context.EUICC_SERVICE); 137 if (!euiccManager.isEnabled()) { 138 return false; 139 } 140 ContentResolver cr = context.getContentResolver(); 141 return Settings.Global.getInt(cr, Settings.Global.EUICC_PROVISIONED, 0) != 0 142 || Settings.Global.getInt( 143 cr, Settings.Global.DEVELOPMENT_SETTINGS_ENABLED, 0) != 0; 144 } 145 146 /** 147 * Whether to show the Enhanced 4G LTE settings. 148 * 149 * <p>We show this settings if the VoLTE can be enabled by this device and the carrier app 150 * doesn't set {@link CarrierConfigManager.KEY_HIDE_ENHANCED_4G_LTE_BOOL} to false. 151 */ 152 public static boolean hideEnhanced4gLteSettings(Context context, 153 PersistableBundle carrierConfig) { 154 return !(ImsManager.isVolteEnabledByPlatform(context) 155 && ImsManager.isVolteProvisionedOnDevice(context)) 156 || carrierConfig.getBoolean( 157 CarrierConfigManager.KEY_HIDE_ENHANCED_4G_LTE_BOOL); 158 159 } 160 161 public static class MobileNetworkFragment extends PreferenceFragment implements 162 Preference.OnPreferenceChangeListener, RoamingDialogFragment.RoamingDialogListener { 163 164 // debug data 165 private static final String LOG_TAG = "NetworkSettings"; 166 private static final boolean DBG = true; 167 public static final int REQUEST_CODE_EXIT_ECM = 17; 168 169 // Number of active Subscriptions to show tabs 170 private static final int TAB_THRESHOLD = 2; 171 172 // Number of last phone number digits shown in Euicc Setting tab 173 private static final int NUM_LAST_PHONE_DIGITS = 4; 174 175 // fragment tag for roaming data dialog 176 private static final String ROAMING_TAG = "RoamingDialogFragment"; 177 178 //String keys for preference lookup 179 private static final String BUTTON_PREFERED_NETWORK_MODE = "preferred_network_mode_key"; 180 private static final String BUTTON_ROAMING_KEY = "button_roaming_key"; 181 private static final String BUTTON_CDMA_LTE_DATA_SERVICE_KEY = "cdma_lte_data_service_key"; 182 private static final String BUTTON_ENABLED_NETWORKS_KEY = "enabled_networks_key"; 183 private static final String BUTTON_4G_LTE_KEY = "enhanced_4g_lte"; 184 private static final String BUTTON_CELL_BROADCAST_SETTINGS = "cell_broadcast_settings"; 185 private static final String BUTTON_CARRIER_SETTINGS_KEY = "carrier_settings_key"; 186 private static final String BUTTON_CDMA_SYSTEM_SELECT_KEY = "cdma_system_select_key"; 187 private static final String BUTTON_CARRIER_SETTINGS_EUICC_KEY = 188 "carrier_settings_euicc_key"; 189 private static final String BUTTON_WIFI_CALLING_KEY = "wifi_calling_key"; 190 private static final String BUTTON_VIDEO_CALLING_KEY = "video_calling_key"; 191 private static final String BUTTON_MOBILE_DATA_ENABLE_KEY = "mobile_data_enable"; 192 private static final String BUTTON_DATA_USAGE_KEY = "data_usage_summary"; 193 private static final String BUTTON_ADVANCED_OPTIONS_KEY = "advanced_options"; 194 private static final String CATEGORY_CALLING_KEY = "calling"; 195 private static final String CATEGORY_GSM_APN_EXPAND_KEY = "category_gsm_apn_key"; 196 private static final String CATEGORY_CDMA_APN_EXPAND_KEY = "category_cdma_apn_key"; 197 198 private final BroadcastReceiver mPhoneChangeReceiver = new PhoneChangeReceiver(); 199 200 static final int preferredNetworkMode = Phone.PREFERRED_NT_MODE; 201 202 //Information about logical "up" Activity 203 private static final String UP_ACTIVITY_PACKAGE = "com.android.settings"; 204 private static final String UP_ACTIVITY_CLASS = 205 "com.android.settings.Settings$WirelessSettingsActivity"; 206 207 //Information that needs to save into Bundle. 208 private static final String EXPAND_ADVANCED_FIELDS = "expand_advanced_fields"; 209 210 private SubscriptionManager mSubscriptionManager; 211 private TelephonyManager mTelephonyManager; 212 213 //UI objects 214 private AdvancedOptionsPreference mAdvancedOptions; 215 private ListPreference mButtonPreferredNetworkMode; 216 private ListPreference mButtonEnabledNetworks; 217 private RestrictedSwitchPreference mButtonDataRoam; 218 private SwitchPreference mButton4glte; 219 private Preference mLteDataServicePref; 220 private Preference mEuiccSettingsPref; 221 private PreferenceCategory mCallingCategory; 222 private Preference mWiFiCallingPref; 223 private SwitchPreference mVideoCallingPref; 224 private NetworkSelectListPreference mButtonNetworkSelect; 225 private MobileDataPreference mMobileDataPref; 226 private DataUsagePreference mDataUsagePref; 227 228 private static final String iface = "rmnet0"; //TODO: this will go away 229 private List<SubscriptionInfo> mActiveSubInfos; 230 231 private UserManager mUm; 232 private Phone mPhone; 233 private MyHandler mHandler; 234 private boolean mOkClicked; 235 private boolean mExpandAdvancedFields; 236 237 // We assume the the value returned by mTabHost.getCurrentTab() == slotId 238 private TabHost mTabHost; 239 240 //GsmUmts options and Cdma options 241 GsmUmtsOptions mGsmUmtsOptions; 242 CdmaOptions mCdmaOptions; 243 244 private Preference mClickedPreference; 245 private boolean mShow4GForLTE; 246 private boolean mIsGlobalCdma; 247 private boolean mUnavailable; 248 249 private final PhoneStateListener mPhoneStateListener = new PhoneStateListener() { 250 /* 251 * Enable/disable the 'Enhanced 4G LTE Mode' when in/out of a call 252 * and depending on TTY mode and TTY support over VoLTE. 253 * @see android.telephony.PhoneStateListener#onCallStateChanged(int, 254 * java.lang.String) 255 */ 256 @Override 257 public void onCallStateChanged(int state, String incomingNumber) { 258 if (DBG) log("PhoneStateListener.onCallStateChanged: state=" + state); 259 260 Activity activity = getActivity(); 261 if (activity == null) { 262 return; 263 } 264 265 int subId = mPhone != null 266 ? mPhone.getSubId() : SubscriptionManager.INVALID_SUBSCRIPTION_ID; 267 PersistableBundle carrierConfig = 268 PhoneGlobals.getInstance().getCarrierConfigForSubId(subId); 269 boolean enabled = is4gLtePrefEnabled(activity.getApplicationContext(), 270 carrierConfig); 271 Preference pref = getPreferenceScreen().findPreference(BUTTON_4G_LTE_KEY); 272 if (pref != null) pref.setEnabled(enabled && hasActiveSubscriptions()); 273 274 } 275 }; 276 277 /** 278 * Service connection code for the NetworkQueryService. 279 * Handles the work of binding to a local object so that we can make 280 * the appropriate service calls. 281 */ 282 283 /** Local service interface */ 284 private INetworkQueryService mNetworkQueryService = null; 285 286 private void setNetworkQueryService() { 287 mButtonNetworkSelect = (NetworkSelectListPreference) getPreferenceScreen() 288 .findPreference(NetworkOperators.BUTTON_NETWORK_SELECT_KEY); 289 if (mButtonNetworkSelect != null) { 290 mButtonNetworkSelect.setNetworkQueryService(mNetworkQueryService); 291 } 292 293 } 294 /** Service connection */ 295 private final ServiceConnection mNetworkQueryServiceConnection = new ServiceConnection() { 296 297 /** Handle the task of binding the local object to the service */ 298 public void onServiceConnected(ComponentName className, IBinder service) { 299 if (DBG) log("connection created, binding local service."); 300 mNetworkQueryService = ((NetworkQueryService.LocalBinder) service).getService(); 301 setNetworkQueryService(); 302 } 303 304 /** Handle the task of cleaning up the local binding */ 305 public void onServiceDisconnected(ComponentName className) { 306 if (DBG) log("connection disconnected, cleaning local binding."); 307 mNetworkQueryService = null; 308 setNetworkQueryService(); 309 } 310 }; 311 312 private void bindNetworkQueryService() { 313 getContext().startService(new Intent(getContext(), NetworkQueryService.class)); 314 getContext().bindService(new Intent(getContext(), NetworkQueryService.class).setAction( 315 NetworkQueryService.ACTION_LOCAL_BINDER), 316 mNetworkQueryServiceConnection, Context.BIND_AUTO_CREATE); 317 } 318 319 private void unbindNetworkQueryService() { 320 // unbind the service. 321 getContext().unbindService(mNetworkQueryServiceConnection); 322 } 323 324 @Override 325 public void onPositiveButtonClick(DialogFragment dialog) { 326 mPhone.setDataRoamingEnabled(true); 327 mButtonDataRoam.setChecked(true); 328 } 329 330 @Override 331 public void onViewCreated(View view, Bundle savedInstanceState) { 332 if (getListView() != null) { 333 getListView().setDivider(null); 334 } 335 } 336 337 /** 338 * Invoked on each preference click in this hierarchy, overrides 339 * PreferenceActivity's implementation. Used to make sure we track the 340 * preference click events. 341 */ 342 @Override 343 public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen, 344 Preference preference) { 345 sendMetricsEventPreferenceClicked(preferenceScreen, preference); 346 347 /** TODO: Refactor and get rid of the if's using subclasses */ 348 final int phoneSubId = mPhone.getSubId(); 349 if (preference.getKey().equals(BUTTON_4G_LTE_KEY)) { 350 return true; 351 } else if (mGsmUmtsOptions != null && 352 mGsmUmtsOptions.preferenceTreeClick(preference) == true) { 353 return true; 354 } else if (mCdmaOptions != null && 355 mCdmaOptions.preferenceTreeClick(preference) == true) { 356 if (mPhone.isInEcm()) { 357 358 mClickedPreference = preference; 359 360 // In ECM mode launch ECM app dialog 361 startActivityForResult( 362 new Intent(TelephonyIntents.ACTION_SHOW_NOTICE_ECM_BLOCK_OTHERS, null), 363 REQUEST_CODE_EXIT_ECM); 364 } 365 return true; 366 } else if (preference == mButtonPreferredNetworkMode) { 367 //displays the value taken from the Settings.System 368 int settingsNetworkMode = android.provider.Settings.Global.getInt( 369 mPhone.getContext().getContentResolver(), 370 android.provider.Settings.Global.PREFERRED_NETWORK_MODE + phoneSubId, 371 preferredNetworkMode); 372 mButtonPreferredNetworkMode.setValue(Integer.toString(settingsNetworkMode)); 373 return true; 374 } else if (preference == mLteDataServicePref) { 375 String tmpl = android.provider.Settings.Global.getString( 376 getActivity().getContentResolver(), 377 android.provider.Settings.Global.SETUP_PREPAID_DATA_SERVICE_URL); 378 if (!TextUtils.isEmpty(tmpl)) { 379 String imsi = mTelephonyManager.getSubscriberId(); 380 if (imsi == null) { 381 imsi = ""; 382 } 383 final String url = TextUtils.isEmpty(tmpl) ? null 384 : TextUtils.expandTemplate(tmpl, imsi).toString(); 385 Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(url)); 386 startActivity(intent); 387 } else { 388 android.util.Log.e(LOG_TAG, "Missing SETUP_PREPAID_DATA_SERVICE_URL"); 389 } 390 return true; 391 } else if (preference == mButtonEnabledNetworks) { 392 int settingsNetworkMode = android.provider.Settings.Global.getInt( 393 mPhone.getContext().getContentResolver(), 394 android.provider.Settings.Global.PREFERRED_NETWORK_MODE + phoneSubId, 395 preferredNetworkMode); 396 mButtonEnabledNetworks.setValue(Integer.toString(settingsNetworkMode)); 397 return true; 398 } else if (preference == mButtonDataRoam) { 399 // Do not disable the preference screen if the user clicks Data roaming. 400 return true; 401 } else if (preference == mEuiccSettingsPref) { 402 Intent intent = new Intent(EuiccManager.ACTION_MANAGE_EMBEDDED_SUBSCRIPTIONS); 403 startActivity(intent); 404 return true; 405 } else if (preference == mWiFiCallingPref || preference == mVideoCallingPref 406 || preference == mMobileDataPref || preference == mDataUsagePref) { 407 return false; 408 } else if (preference == mAdvancedOptions) { 409 mExpandAdvancedFields = true; 410 updateBody(); 411 return true; 412 } else { 413 // if the button is anything but the simple toggle preference, 414 // we'll need to disable all preferences to reject all click 415 // events until the sub-activity's UI comes up. 416 preferenceScreen.setEnabled(false); 417 // Let the intents be launched by the Preference manager 418 return false; 419 } 420 } 421 422 private final SubscriptionManager.OnSubscriptionsChangedListener 423 mOnSubscriptionsChangeListener 424 = new SubscriptionManager.OnSubscriptionsChangedListener() { 425 @Override 426 public void onSubscriptionsChanged() { 427 if (DBG) log("onSubscriptionsChanged:"); 428 initializeSubscriptions(); 429 } 430 }; 431 432 private void initializeSubscriptions() { 433 final Activity activity = getActivity(); 434 if (activity == null || activity.isDestroyed()) { 435 // Process preferences in activity only if its not destroyed 436 return; 437 } 438 int currentTab = 0; 439 if (DBG) log("initializeSubscriptions:+"); 440 441 // Before updating the the active subscription list check 442 // if tab updating is needed as the list is changing. 443 List<SubscriptionInfo> sil = mSubscriptionManager.getActiveSubscriptionInfoList(); 444 MobileNetworkSettings.TabState state = isUpdateTabsNeeded(sil); 445 446 // Update to the active subscription list 447 mActiveSubInfos.clear(); 448 if (sil != null) { 449 mActiveSubInfos.addAll(sil); 450 // If there is only 1 sim then currenTab should represent slot no. of the sim. 451 if (sil.size() == 1) { 452 currentTab = sil.get(0).getSimSlotIndex(); 453 } 454 } 455 456 switch (state) { 457 case UPDATE: { 458 if (DBG) log("initializeSubscriptions: UPDATE"); 459 currentTab = mTabHost != null ? mTabHost.getCurrentTab() : 0; 460 461 mTabHost = (TabHost) getActivity().findViewById(android.R.id.tabhost); 462 mTabHost.setup(); 463 464 // Update the tabName. Since the mActiveSubInfos are in slot order 465 // we can iterate though the tabs and subscription info in one loop. But 466 // we need to handle the case where a slot may be empty. 467 468 Iterator<SubscriptionInfo> siIterator = mActiveSubInfos.listIterator(); 469 SubscriptionInfo si = siIterator.hasNext() ? siIterator.next() : null; 470 for (int simSlotIndex = 0; simSlotIndex < mActiveSubInfos.size(); 471 simSlotIndex++) { 472 String tabName; 473 if (si != null && si.getSimSlotIndex() == simSlotIndex) { 474 // Slot is not empty and we match 475 tabName = String.valueOf(si.getDisplayName()); 476 si = siIterator.hasNext() ? siIterator.next() : null; 477 } else { 478 // Slot is empty, set name to unknown 479 tabName = getResources().getString(R.string.unknown); 480 } 481 if (DBG) { 482 log("initializeSubscriptions:tab=" + simSlotIndex + " name=" + tabName); 483 } 484 485 mTabHost.addTab(buildTabSpec(String.valueOf(simSlotIndex), tabName)); 486 } 487 488 mTabHost.setOnTabChangedListener(mTabListener); 489 mTabHost.setCurrentTab(currentTab); 490 break; 491 } 492 case NO_TABS: { 493 if (DBG) log("initializeSubscriptions: NO_TABS"); 494 495 if (mTabHost != null) { 496 mTabHost.clearAllTabs(); 497 mTabHost = null; 498 } 499 break; 500 } 501 case DO_NOTHING: { 502 if (DBG) log("initializeSubscriptions: DO_NOTHING"); 503 if (mTabHost != null) { 504 currentTab = mTabHost.getCurrentTab(); 505 } 506 break; 507 } 508 } 509 updatePhone(currentTab); 510 updateBody(); 511 if (DBG) log("initializeSubscriptions:-"); 512 } 513 514 private MobileNetworkSettings.TabState isUpdateTabsNeeded(List<SubscriptionInfo> newSil) { 515 TabState state = MobileNetworkSettings.TabState.DO_NOTHING; 516 if (newSil == null) { 517 if (mActiveSubInfos.size() >= TAB_THRESHOLD) { 518 if (DBG) log("isUpdateTabsNeeded: NO_TABS, size unknown and was tabbed"); 519 state = MobileNetworkSettings.TabState.NO_TABS; 520 } 521 } else if (newSil.size() < TAB_THRESHOLD && mActiveSubInfos.size() >= TAB_THRESHOLD) { 522 if (DBG) log("isUpdateTabsNeeded: NO_TABS, size went to small"); 523 state = MobileNetworkSettings.TabState.NO_TABS; 524 } else if (newSil.size() >= TAB_THRESHOLD && mActiveSubInfos.size() < TAB_THRESHOLD) { 525 if (DBG) log("isUpdateTabsNeeded: UPDATE, size changed"); 526 state = MobileNetworkSettings.TabState.UPDATE; 527 } else if (newSil.size() >= TAB_THRESHOLD) { 528 Iterator<SubscriptionInfo> siIterator = mActiveSubInfos.iterator(); 529 for(SubscriptionInfo newSi : newSil) { 530 SubscriptionInfo curSi = siIterator.next(); 531 if (!newSi.getDisplayName().equals(curSi.getDisplayName())) { 532 if (DBG) log("isUpdateTabsNeeded: UPDATE, new name=" 533 + newSi.getDisplayName()); 534 state = MobileNetworkSettings.TabState.UPDATE; 535 break; 536 } 537 } 538 } 539 if (DBG) { 540 Log.i(LOG_TAG, "isUpdateTabsNeeded:- " + state 541 + " newSil.size()=" + ((newSil != null) ? newSil.size() : 0) 542 + " mActiveSubInfos.size()=" + mActiveSubInfos.size()); 543 } 544 return state; 545 } 546 547 private TabHost.OnTabChangeListener mTabListener = new TabHost.OnTabChangeListener() { 548 @Override 549 public void onTabChanged(String tabId) { 550 if (DBG) log("onTabChanged:"); 551 // The User has changed tab; update the body. 552 updatePhone(Integer.parseInt(tabId)); 553 updateBody(); 554 } 555 }; 556 557 private void updatePhone(int slotId) { 558 final SubscriptionInfo sir = mSubscriptionManager 559 .getActiveSubscriptionInfoForSimSlotIndex(slotId); 560 if (sir != null) { 561 mPhone = PhoneFactory.getPhone( 562 SubscriptionManager.getPhoneId(sir.getSubscriptionId())); 563 } 564 if (mPhone == null) { 565 // Do the best we can 566 mPhone = PhoneGlobals.getPhone(); 567 } 568 Log.i(LOG_TAG, "updatePhone:- slotId=" + slotId + " sir=" + sir); 569 } 570 571 private TabHost.TabContentFactory mEmptyTabContent = new TabHost.TabContentFactory() { 572 @Override 573 public View createTabContent(String tag) { 574 return new View(mTabHost.getContext()); 575 } 576 }; 577 578 private TabHost.TabSpec buildTabSpec(String tag, String title) { 579 return mTabHost.newTabSpec(tag).setIndicator(title).setContent( 580 mEmptyTabContent); 581 } 582 583 @Override 584 public void onSaveInstanceState(Bundle outState) { 585 super.onSaveInstanceState(outState); 586 587 // If advanced fields are already expanded, we save it and expand it 588 // when it's re-created. 589 outState.putBoolean(EXPAND_ADVANCED_FIELDS, mExpandAdvancedFields); 590 } 591 592 @Override 593 public void onCreate(Bundle icicle) { 594 Log.i(LOG_TAG, "onCreate:+"); 595 super.onCreate(icicle); 596 597 final Activity activity = getActivity(); 598 if (activity == null || activity.isDestroyed()) { 599 Log.e(LOG_TAG, "onCreate:- with no valid activity."); 600 return; 601 } 602 603 mHandler = new MyHandler(); 604 mUm = (UserManager) activity.getSystemService(Context.USER_SERVICE); 605 mSubscriptionManager = SubscriptionManager.from(activity); 606 mTelephonyManager = (TelephonyManager) activity.getSystemService( 607 Context.TELEPHONY_SERVICE); 608 609 if (icicle != null) { 610 mExpandAdvancedFields = icicle.getBoolean(EXPAND_ADVANCED_FIELDS, false); 611 } 612 613 bindNetworkQueryService(); 614 615 if (mUm.hasUserRestriction(UserManager.DISALLOW_CONFIG_MOBILE_NETWORKS)) { 616 mUnavailable = true; 617 activity.setContentView(R.layout.telephony_disallowed_preference_screen); 618 return; 619 } 620 621 addPreferencesFromResource(R.xml.network_setting_fragment); 622 623 mButton4glte = (SwitchPreference)findPreference(BUTTON_4G_LTE_KEY); 624 mButton4glte.setOnPreferenceChangeListener(this); 625 626 mCallingCategory = (PreferenceCategory) findPreference(CATEGORY_CALLING_KEY); 627 mWiFiCallingPref = findPreference(BUTTON_WIFI_CALLING_KEY); 628 mVideoCallingPref = (SwitchPreference) findPreference(BUTTON_VIDEO_CALLING_KEY); 629 mMobileDataPref = (MobileDataPreference) findPreference(BUTTON_MOBILE_DATA_ENABLE_KEY); 630 mDataUsagePref = (DataUsagePreference) findPreference(BUTTON_DATA_USAGE_KEY); 631 632 try { 633 Context con = activity.createPackageContext("com.android.systemui", 0); 634 int id = con.getResources().getIdentifier("config_show4GForLTE", 635 "bool", "com.android.systemui"); 636 mShow4GForLTE = con.getResources().getBoolean(id); 637 } catch (PackageManager.NameNotFoundException e) { 638 Log.e(LOG_TAG, "NameNotFoundException for show4GFotLTE"); 639 mShow4GForLTE = false; 640 } 641 642 //get UI object references 643 PreferenceScreen prefSet = getPreferenceScreen(); 644 645 mButtonDataRoam = (RestrictedSwitchPreference) prefSet.findPreference( 646 BUTTON_ROAMING_KEY); 647 mButtonPreferredNetworkMode = (ListPreference) prefSet.findPreference( 648 BUTTON_PREFERED_NETWORK_MODE); 649 mButtonEnabledNetworks = (ListPreference) prefSet.findPreference( 650 BUTTON_ENABLED_NETWORKS_KEY); 651 mAdvancedOptions = (AdvancedOptionsPreference) prefSet.findPreference( 652 BUTTON_ADVANCED_OPTIONS_KEY); 653 mButtonDataRoam.setOnPreferenceChangeListener(this); 654 655 mLteDataServicePref = prefSet.findPreference(BUTTON_CDMA_LTE_DATA_SERVICE_KEY); 656 657 mEuiccSettingsPref = prefSet.findPreference(BUTTON_CARRIER_SETTINGS_EUICC_KEY); 658 mEuiccSettingsPref.setOnPreferenceChangeListener(this); 659 660 // Initialize mActiveSubInfo 661 int max = mSubscriptionManager.getActiveSubscriptionInfoCountMax(); 662 mActiveSubInfos = new ArrayList<SubscriptionInfo>(max); 663 664 IntentFilter intentFilter = new IntentFilter( 665 TelephonyIntents.ACTION_RADIO_TECHNOLOGY_CHANGED); 666 activity.registerReceiver(mPhoneChangeReceiver, intentFilter); 667 668 Log.i(LOG_TAG, "onCreate:-"); 669 } 670 671 @Override 672 public View onCreateView(LayoutInflater inflater, ViewGroup container, 673 Bundle savedInstanceState) { 674 return inflater.inflate(com.android.internal.R.layout.common_tab_settings, 675 container, false); 676 } 677 678 @Override 679 public void onActivityCreated(Bundle savedInstanceState) { 680 super.onActivityCreated(savedInstanceState); 681 initializeSubscriptions(); 682 } 683 684 private class PhoneChangeReceiver extends BroadcastReceiver { 685 @Override 686 public void onReceive(Context context, Intent intent) { 687 Log.i(LOG_TAG, "onReceive:"); 688 // When the radio changes (ex: CDMA->GSM), refresh all options. 689 updateBody(); 690 } 691 } 692 693 @Override 694 public void onDestroy() { 695 unbindNetworkQueryService(); 696 super.onDestroy(); 697 if (getActivity() != null) { 698 getActivity().unregisterReceiver(mPhoneChangeReceiver); 699 } 700 } 701 702 @Override 703 public void onResume() { 704 super.onResume(); 705 Log.i(LOG_TAG, "onResume:+"); 706 707 if (mUnavailable) { 708 Log.i(LOG_TAG, "onResume:- ignore mUnavailable == false"); 709 return; 710 } 711 712 final Activity activity = getActivity(); 713 if (activity == null || activity.isDestroyed()) { 714 Log.e(LOG_TAG, "onResume:- with no valid activity."); 715 return; 716 } 717 // upon resumption from the sub-activity, make sure we re-enable the 718 // preferences. 719 getPreferenceScreen().setEnabled(true); 720 721 // Set UI state in onResume because a user could go home, launch some 722 // app to change this setting's backend, and re-launch this settings app 723 // and the UI state would be inconsistent with actual state 724 mButtonDataRoam.setChecked(mPhone.getDataRoamingEnabled()); 725 726 if (getPreferenceScreen().findPreference(BUTTON_PREFERED_NETWORK_MODE) != null 727 || getPreferenceScreen().findPreference(BUTTON_ENABLED_NETWORKS_KEY) != null) { 728 updatePreferredNetworkUIFromDb(); 729 } 730 731 if (ImsManager.isVolteEnabledByPlatform(activity) 732 && ImsManager.isVolteProvisionedOnDevice(activity)) { 733 mTelephonyManager.listen(mPhoneStateListener, PhoneStateListener.LISTEN_CALL_STATE); 734 } 735 736 // NOTE: Buttons will be enabled/disabled in mPhoneStateListener 737 boolean enh4glteMode = ImsManager.isEnhanced4gLteModeSettingEnabledByUser(activity) 738 && ImsManager.isNonTtyOrTtyOnVolteEnabled(activity); 739 mButton4glte.setChecked(enh4glteMode); 740 741 // Video calling and WiFi calling state might have changed. 742 updateCallingCategory(); 743 744 mSubscriptionManager.addOnSubscriptionsChangedListener(mOnSubscriptionsChangeListener); 745 746 Log.i(LOG_TAG, "onResume:-"); 747 748 } 749 750 private boolean hasActiveSubscriptions() { 751 return mActiveSubInfos.size() > 0; 752 } 753 754 private void updateBodyBasicFields(Activity activity, PreferenceScreen prefSet, 755 int phoneSubId, boolean hasActiveSubscriptions) { 756 Context context = activity.getApplicationContext(); 757 758 ActionBar actionBar = activity.getActionBar(); 759 if (actionBar != null) { 760 // android.R.id.home will be triggered in onOptionsItemSelected() 761 actionBar.setDisplayHomeAsUpEnabled(true); 762 } 763 764 prefSet.addPreference(mMobileDataPref); 765 prefSet.addPreference(mButtonDataRoam); 766 prefSet.addPreference(mDataUsagePref); 767 768 // Customized preferences needs to be initialized with subId. 769 mMobileDataPref.initialize(phoneSubId); 770 mDataUsagePref.initialize(phoneSubId); 771 772 mMobileDataPref.setEnabled(hasActiveSubscriptions); 773 mButtonDataRoam.setEnabled(hasActiveSubscriptions); 774 mDataUsagePref.setEnabled(hasActiveSubscriptions); 775 776 // Initialize states of mButtonDataRoam. 777 mButtonDataRoam.setChecked(mPhone.getDataRoamingEnabled()); 778 mButtonDataRoam.setDisabledByAdmin(false); 779 if (mButtonDataRoam.isEnabled()) { 780 if (RestrictedLockUtils.hasBaseUserRestriction(context, 781 UserManager.DISALLOW_DATA_ROAMING, UserHandle.myUserId())) { 782 mButtonDataRoam.setEnabled(false); 783 } else { 784 mButtonDataRoam.checkRestrictionAndSetDisabled( 785 UserManager.DISALLOW_DATA_ROAMING); 786 } 787 } 788 } 789 790 private void updateBody() { 791 final Activity activity = getActivity(); 792 final PreferenceScreen prefSet = getPreferenceScreen(); 793 final int phoneSubId = mPhone.getSubId(); 794 final boolean hasActiveSubscriptions = hasActiveSubscriptions(); 795 796 if (activity == null || activity.isDestroyed()) { 797 Log.e(LOG_TAG, "updateBody with no valid activity."); 798 return; 799 } 800 801 if (prefSet == null) { 802 Log.e(LOG_TAG, "updateBody with no null prefSet."); 803 return; 804 } 805 806 prefSet.removeAll(); 807 808 updateBodyBasicFields(activity, prefSet, phoneSubId, hasActiveSubscriptions); 809 810 if (mExpandAdvancedFields) { 811 updateBodyAdvancedFields(activity, prefSet, phoneSubId, hasActiveSubscriptions); 812 } else { 813 prefSet.addPreference(mAdvancedOptions); 814 } 815 } 816 817 private void updateBodyAdvancedFields(Activity activity, PreferenceScreen prefSet, 818 int phoneSubId, boolean hasActiveSubscriptions) { 819 boolean isLteOnCdma = mPhone.getLteOnCdmaMode() == PhoneConstants.LTE_ON_CDMA_TRUE; 820 821 if (DBG) { 822 log("updateBody: isLteOnCdma=" + isLteOnCdma + " phoneSubId=" + phoneSubId); 823 } 824 825 prefSet.addPreference(mButtonPreferredNetworkMode); 826 prefSet.addPreference(mButtonEnabledNetworks); 827 prefSet.addPreference(mButton4glte); 828 829 if (showEuiccSettings(getActivity())) { 830 prefSet.addPreference(mEuiccSettingsPref); 831 String spn = mTelephonyManager.getSimOperatorName(); 832 if (TextUtils.isEmpty(spn)) { 833 mEuiccSettingsPref.setSummary(null); 834 } else { 835 mEuiccSettingsPref.setSummary(spn); 836 } 837 } 838 839 int settingsNetworkMode = android.provider.Settings.Global.getInt( 840 mPhone.getContext().getContentResolver(), 841 android.provider.Settings.Global.PREFERRED_NETWORK_MODE + phoneSubId, 842 preferredNetworkMode); 843 844 PersistableBundle carrierConfig = 845 PhoneGlobals.getInstance().getCarrierConfigForSubId(mPhone.getSubId()); 846 mIsGlobalCdma = isLteOnCdma 847 && carrierConfig.getBoolean(CarrierConfigManager.KEY_SHOW_CDMA_CHOICES_BOOL); 848 if (carrierConfig.getBoolean( 849 CarrierConfigManager.KEY_HIDE_CARRIER_NETWORK_SETTINGS_BOOL)) { 850 prefSet.removePreference(mButtonPreferredNetworkMode); 851 prefSet.removePreference(mButtonEnabledNetworks); 852 prefSet.removePreference(mLteDataServicePref); 853 } else if (carrierConfig.getBoolean(CarrierConfigManager 854 .KEY_HIDE_PREFERRED_NETWORK_TYPE_BOOL) 855 && !mPhone.getServiceState().getRoaming() 856 && mPhone.getServiceState().getDataRegState() 857 == ServiceState.STATE_IN_SERVICE) { 858 prefSet.removePreference(mButtonPreferredNetworkMode); 859 prefSet.removePreference(mButtonEnabledNetworks); 860 861 final int phoneType = mPhone.getPhoneType(); 862 if (phoneType == PhoneConstants.PHONE_TYPE_CDMA) { 863 updateCdmaOptions(this, prefSet, mPhone); 864 } else if (phoneType == PhoneConstants.PHONE_TYPE_GSM) { 865 updateGsmUmtsOptions(this, prefSet, phoneSubId, mNetworkQueryService); 866 } else { 867 throw new IllegalStateException("Unexpected phone type: " + phoneType); 868 } 869 // Since pref is being hidden from user, set network mode to default 870 // in case it is currently something else. That is possible if user 871 // changed the setting while roaming and is now back to home network. 872 settingsNetworkMode = preferredNetworkMode; 873 } else if (carrierConfig.getBoolean( 874 CarrierConfigManager.KEY_WORLD_PHONE_BOOL) == true) { 875 prefSet.removePreference(mButtonEnabledNetworks); 876 // set the listener for the mButtonPreferredNetworkMode list preference so we can issue 877 // change Preferred Network Mode. 878 mButtonPreferredNetworkMode.setOnPreferenceChangeListener(this); 879 880 updateCdmaOptions(this, prefSet, mPhone); 881 updateGsmUmtsOptions(this, prefSet, phoneSubId, mNetworkQueryService); 882 } else { 883 prefSet.removePreference(mButtonPreferredNetworkMode); 884 final int phoneType = mPhone.getPhoneType(); 885 if (phoneType == PhoneConstants.PHONE_TYPE_CDMA) { 886 int lteForced = android.provider.Settings.Global.getInt( 887 mPhone.getContext().getContentResolver(), 888 android.provider.Settings.Global.LTE_SERVICE_FORCED + mPhone.getSubId(), 889 0); 890 891 if (isLteOnCdma) { 892 if (lteForced == 0) { 893 mButtonEnabledNetworks.setEntries( 894 R.array.enabled_networks_cdma_choices); 895 mButtonEnabledNetworks.setEntryValues( 896 R.array.enabled_networks_cdma_values); 897 } else { 898 switch (settingsNetworkMode) { 899 case Phone.NT_MODE_CDMA: 900 case Phone.NT_MODE_CDMA_NO_EVDO: 901 case Phone.NT_MODE_EVDO_NO_CDMA: 902 mButtonEnabledNetworks.setEntries( 903 R.array.enabled_networks_cdma_no_lte_choices); 904 mButtonEnabledNetworks.setEntryValues( 905 R.array.enabled_networks_cdma_no_lte_values); 906 break; 907 case Phone.NT_MODE_GLOBAL: 908 case Phone.NT_MODE_LTE_CDMA_AND_EVDO: 909 case Phone.NT_MODE_LTE_CDMA_EVDO_GSM_WCDMA: 910 case Phone.NT_MODE_LTE_ONLY: 911 mButtonEnabledNetworks.setEntries( 912 R.array.enabled_networks_cdma_only_lte_choices); 913 mButtonEnabledNetworks.setEntryValues( 914 R.array.enabled_networks_cdma_only_lte_values); 915 break; 916 default: 917 mButtonEnabledNetworks.setEntries( 918 R.array.enabled_networks_cdma_choices); 919 mButtonEnabledNetworks.setEntryValues( 920 R.array.enabled_networks_cdma_values); 921 break; 922 } 923 } 924 } 925 updateCdmaOptions(this, prefSet, mPhone); 926 927 } else if (phoneType == PhoneConstants.PHONE_TYPE_GSM) { 928 if (isSupportTdscdma()) { 929 mButtonEnabledNetworks.setEntries( 930 R.array.enabled_networks_tdscdma_choices); 931 mButtonEnabledNetworks.setEntryValues( 932 R.array.enabled_networks_tdscdma_values); 933 } else if (!carrierConfig.getBoolean(CarrierConfigManager.KEY_PREFER_2G_BOOL) 934 && !getResources().getBoolean(R.bool.config_enabled_lte)) { 935 mButtonEnabledNetworks.setEntries( 936 R.array.enabled_networks_except_gsm_lte_choices); 937 mButtonEnabledNetworks.setEntryValues( 938 R.array.enabled_networks_except_gsm_lte_values); 939 } else if (!carrierConfig.getBoolean(CarrierConfigManager.KEY_PREFER_2G_BOOL)) { 940 int select = (mShow4GForLTE == true) ? 941 R.array.enabled_networks_except_gsm_4g_choices 942 : R.array.enabled_networks_except_gsm_choices; 943 mButtonEnabledNetworks.setEntries(select); 944 mButtonEnabledNetworks.setEntryValues( 945 R.array.enabled_networks_except_gsm_values); 946 } else if (!getResources().getBoolean(R.bool.config_enabled_lte)) { 947 mButtonEnabledNetworks.setEntries( 948 R.array.enabled_networks_except_lte_choices); 949 mButtonEnabledNetworks.setEntryValues( 950 R.array.enabled_networks_except_lte_values); 951 } else if (mIsGlobalCdma) { 952 mButtonEnabledNetworks.setEntries( 953 R.array.enabled_networks_cdma_choices); 954 mButtonEnabledNetworks.setEntryValues( 955 R.array.enabled_networks_cdma_values); 956 } else { 957 int select = (mShow4GForLTE == true) ? R.array.enabled_networks_4g_choices 958 : R.array.enabled_networks_choices; 959 mButtonEnabledNetworks.setEntries(select); 960 mButtonEnabledNetworks.setEntryValues( 961 R.array.enabled_networks_values); 962 } 963 updateGsmUmtsOptions(this, prefSet, phoneSubId, mNetworkQueryService); 964 } else { 965 throw new IllegalStateException("Unexpected phone type: " + phoneType); 966 } 967 if (isWorldMode()) { 968 mButtonEnabledNetworks.setEntries( 969 R.array.preferred_network_mode_choices_world_mode); 970 mButtonEnabledNetworks.setEntryValues( 971 R.array.preferred_network_mode_values_world_mode); 972 } 973 mButtonEnabledNetworks.setOnPreferenceChangeListener(this); 974 if (DBG) log("settingsNetworkMode: " + settingsNetworkMode); 975 } 976 977 final boolean missingDataServiceUrl = TextUtils.isEmpty( 978 android.provider.Settings.Global.getString(activity.getContentResolver(), 979 android.provider.Settings.Global.SETUP_PREPAID_DATA_SERVICE_URL)); 980 if (!isLteOnCdma || missingDataServiceUrl) { 981 prefSet.removePreference(mLteDataServicePref); 982 } else { 983 android.util.Log.d(LOG_TAG, "keep ltePref"); 984 } 985 986 if (hideEnhanced4gLteSettings(getActivity(), carrierConfig)) { 987 Preference pref = prefSet.findPreference(BUTTON_4G_LTE_KEY); 988 if (pref != null) { 989 prefSet.removePreference(pref); 990 } 991 } 992 993 updateCallingCategory(); 994 995 // Enable link to CMAS app settings depending on the value in config.xml. 996 final boolean isCellBroadcastAppLinkEnabled = activity.getResources().getBoolean( 997 com.android.internal.R.bool.config_cellBroadcastAppLinks); 998 if (!mUm.isAdminUser() || !isCellBroadcastAppLinkEnabled 999 || mUm.hasUserRestriction(UserManager.DISALLOW_CONFIG_CELL_BROADCASTS)) { 1000 PreferenceScreen root = getPreferenceScreen(); 1001 Preference ps = findPreference(BUTTON_CELL_BROADCAST_SETTINGS); 1002 if (ps != null) { 1003 root.removePreference(ps); 1004 } 1005 } 1006 1007 // Get the networkMode from Settings.System and displays it 1008 mButtonEnabledNetworks.setValue(Integer.toString(settingsNetworkMode)); 1009 mButtonPreferredNetworkMode.setValue(Integer.toString(settingsNetworkMode)); 1010 UpdatePreferredNetworkModeSummary(settingsNetworkMode); 1011 UpdateEnabledNetworksValueAndSummary(settingsNetworkMode); 1012 // Display preferred network type based on what modem returns b/18676277 1013 mPhone.setPreferredNetworkType(settingsNetworkMode, mHandler 1014 .obtainMessage(MyHandler.MESSAGE_SET_PREFERRED_NETWORK_TYPE)); 1015 1016 /** 1017 * Enable/disable depending upon if there are any active subscriptions. 1018 * 1019 * I've decided to put this enable/disable code at the bottom as the 1020 * code above works even when there are no active subscriptions, thus 1021 * putting it afterwards is a smaller change. This can be refined later, 1022 * but you do need to remember that this all needs to work when subscriptions 1023 * change dynamically such as when hot swapping sims. 1024 */ 1025 boolean canChange4glte = is4gLtePrefEnabled(activity.getApplicationContext(), 1026 carrierConfig); 1027 boolean useVariant4glteTitle = carrierConfig.getBoolean( 1028 CarrierConfigManager.KEY_ENHANCED_4G_LTE_TITLE_VARIANT_BOOL); 1029 int enhanced4glteModeTitleId = useVariant4glteTitle ? 1030 R.string.enhanced_4g_lte_mode_title_variant : 1031 R.string.enhanced_4g_lte_mode_title; 1032 1033 mButtonPreferredNetworkMode.setEnabled(hasActiveSubscriptions); 1034 mButtonEnabledNetworks.setEnabled(hasActiveSubscriptions); 1035 mButton4glte.setTitle(enhanced4glteModeTitleId); 1036 mButton4glte.setEnabled(hasActiveSubscriptions && canChange4glte); 1037 mLteDataServicePref.setEnabled(hasActiveSubscriptions); 1038 Preference ps; 1039 PreferenceScreen root = getPreferenceScreen(); 1040 ps = findPreference(BUTTON_CELL_BROADCAST_SETTINGS); 1041 if (ps != null) { 1042 ps.setEnabled(hasActiveSubscriptions); 1043 } 1044 ps = findPreference(CATEGORY_GSM_APN_EXPAND_KEY); 1045 if (ps != null) { 1046 ps.setEnabled(hasActiveSubscriptions); 1047 } 1048 ps = findPreference(CATEGORY_CDMA_APN_EXPAND_KEY); 1049 if (ps != null) { 1050 ps.setEnabled(hasActiveSubscriptions); 1051 } 1052 ps = findPreference(NetworkOperators.CATEGORY_NETWORK_OPERATORS_KEY); 1053 if (ps != null) { 1054 ps.setEnabled(hasActiveSubscriptions); 1055 } 1056 ps = findPreference(BUTTON_CARRIER_SETTINGS_KEY); 1057 if (ps != null) { 1058 ps.setEnabled(hasActiveSubscriptions); 1059 } 1060 ps = findPreference(BUTTON_CDMA_SYSTEM_SELECT_KEY); 1061 if (ps != null) { 1062 ps.setEnabled(hasActiveSubscriptions); 1063 } 1064 ps = findPreference(CATEGORY_CALLING_KEY); 1065 if (ps != null) { 1066 ps.setEnabled(hasActiveSubscriptions); 1067 } 1068 } 1069 1070 @Override 1071 public void onPause() { 1072 super.onPause(); 1073 if (DBG) log("onPause:+"); 1074 1075 mTelephonyManager.listen(mPhoneStateListener, PhoneStateListener.LISTEN_NONE); 1076 1077 mSubscriptionManager 1078 .removeOnSubscriptionsChangedListener(mOnSubscriptionsChangeListener); 1079 if (DBG) log("onPause:-"); 1080 } 1081 1082 /** 1083 * Implemented to support onPreferenceChangeListener to look for preference 1084 * changes specifically on CLIR. 1085 * 1086 * @param preference is the preference to be changed, should be mButtonCLIR. 1087 * @param objValue should be the value of the selection, NOT its localized 1088 * display value. 1089 */ 1090 public boolean onPreferenceChange(Preference preference, Object objValue) { 1091 final int phoneSubId = mPhone.getSubId(); 1092 if (preference == mButtonPreferredNetworkMode) { 1093 //NOTE onPreferenceChange seems to be called even if there is no change 1094 //Check if the button value is changed from the System.Setting 1095 mButtonPreferredNetworkMode.setValue((String) objValue); 1096 int buttonNetworkMode; 1097 buttonNetworkMode = Integer.parseInt((String) objValue); 1098 int settingsNetworkMode = android.provider.Settings.Global.getInt( 1099 mPhone.getContext().getContentResolver(), 1100 android.provider.Settings.Global.PREFERRED_NETWORK_MODE + phoneSubId, 1101 preferredNetworkMode); 1102 if (buttonNetworkMode != settingsNetworkMode) { 1103 int modemNetworkMode; 1104 // if new mode is invalid ignore it 1105 switch (buttonNetworkMode) { 1106 case Phone.NT_MODE_WCDMA_PREF: 1107 case Phone.NT_MODE_GSM_ONLY: 1108 case Phone.NT_MODE_WCDMA_ONLY: 1109 case Phone.NT_MODE_GSM_UMTS: 1110 case Phone.NT_MODE_CDMA: 1111 case Phone.NT_MODE_CDMA_NO_EVDO: 1112 case Phone.NT_MODE_EVDO_NO_CDMA: 1113 case Phone.NT_MODE_GLOBAL: 1114 case Phone.NT_MODE_LTE_CDMA_AND_EVDO: 1115 case Phone.NT_MODE_LTE_GSM_WCDMA: 1116 case Phone.NT_MODE_LTE_CDMA_EVDO_GSM_WCDMA: 1117 case Phone.NT_MODE_LTE_ONLY: 1118 case Phone.NT_MODE_LTE_WCDMA: 1119 case Phone.NT_MODE_TDSCDMA_ONLY: 1120 case Phone.NT_MODE_TDSCDMA_WCDMA: 1121 case Phone.NT_MODE_LTE_TDSCDMA: 1122 case Phone.NT_MODE_TDSCDMA_GSM: 1123 case Phone.NT_MODE_LTE_TDSCDMA_GSM: 1124 case Phone.NT_MODE_TDSCDMA_GSM_WCDMA: 1125 case Phone.NT_MODE_LTE_TDSCDMA_WCDMA: 1126 case Phone.NT_MODE_LTE_TDSCDMA_GSM_WCDMA: 1127 case Phone.NT_MODE_TDSCDMA_CDMA_EVDO_GSM_WCDMA: 1128 case Phone.NT_MODE_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA: 1129 // This is one of the modes we recognize 1130 modemNetworkMode = buttonNetworkMode; 1131 break; 1132 default: 1133 loge("Invalid Network Mode (" +buttonNetworkMode+ ") chosen. Ignore."); 1134 return true; 1135 } 1136 1137 android.provider.Settings.Global.putInt( 1138 mPhone.getContext().getContentResolver(), 1139 android.provider.Settings.Global.PREFERRED_NETWORK_MODE + phoneSubId, 1140 buttonNetworkMode ); 1141 //Set the modem network mode 1142 mPhone.setPreferredNetworkType(modemNetworkMode, mHandler 1143 .obtainMessage(MyHandler.MESSAGE_SET_PREFERRED_NETWORK_TYPE)); 1144 } 1145 } else if (preference == mButtonEnabledNetworks) { 1146 mButtonEnabledNetworks.setValue((String) objValue); 1147 int buttonNetworkMode; 1148 buttonNetworkMode = Integer.parseInt((String) objValue); 1149 if (DBG) log("buttonNetworkMode: " + buttonNetworkMode); 1150 int settingsNetworkMode = android.provider.Settings.Global.getInt( 1151 mPhone.getContext().getContentResolver(), 1152 android.provider.Settings.Global.PREFERRED_NETWORK_MODE + phoneSubId, 1153 preferredNetworkMode); 1154 if (buttonNetworkMode != settingsNetworkMode) { 1155 int modemNetworkMode; 1156 // if new mode is invalid ignore it 1157 switch (buttonNetworkMode) { 1158 case Phone.NT_MODE_WCDMA_PREF: 1159 case Phone.NT_MODE_GSM_ONLY: 1160 case Phone.NT_MODE_LTE_GSM_WCDMA: 1161 case Phone.NT_MODE_LTE_CDMA_EVDO_GSM_WCDMA: 1162 case Phone.NT_MODE_CDMA: 1163 case Phone.NT_MODE_CDMA_NO_EVDO: 1164 case Phone.NT_MODE_LTE_CDMA_AND_EVDO: 1165 case Phone.NT_MODE_TDSCDMA_ONLY: 1166 case Phone.NT_MODE_TDSCDMA_WCDMA: 1167 case Phone.NT_MODE_LTE_TDSCDMA: 1168 case Phone.NT_MODE_TDSCDMA_GSM: 1169 case Phone.NT_MODE_LTE_TDSCDMA_GSM: 1170 case Phone.NT_MODE_TDSCDMA_GSM_WCDMA: 1171 case Phone.NT_MODE_LTE_TDSCDMA_WCDMA: 1172 case Phone.NT_MODE_LTE_TDSCDMA_GSM_WCDMA: 1173 case Phone.NT_MODE_TDSCDMA_CDMA_EVDO_GSM_WCDMA: 1174 case Phone.NT_MODE_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA: 1175 // This is one of the modes we recognize 1176 modemNetworkMode = buttonNetworkMode; 1177 break; 1178 default: 1179 loge("Invalid Network Mode (" +buttonNetworkMode+ ") chosen. Ignore."); 1180 return true; 1181 } 1182 1183 UpdateEnabledNetworksValueAndSummary(buttonNetworkMode); 1184 1185 android.provider.Settings.Global.putInt( 1186 mPhone.getContext().getContentResolver(), 1187 android.provider.Settings.Global.PREFERRED_NETWORK_MODE + phoneSubId, 1188 buttonNetworkMode ); 1189 //Set the modem network mode 1190 mPhone.setPreferredNetworkType(modemNetworkMode, mHandler 1191 .obtainMessage(MyHandler.MESSAGE_SET_PREFERRED_NETWORK_TYPE)); 1192 } 1193 } else if (preference == mButton4glte) { 1194 SwitchPreference enhanced4gModePref = (SwitchPreference) preference; 1195 boolean enhanced4gMode = !enhanced4gModePref.isChecked(); 1196 enhanced4gModePref.setChecked(enhanced4gMode); 1197 ImsManager.setEnhanced4gLteModeSetting(getActivity(), 1198 enhanced4gModePref.isChecked()); 1199 } else if (preference == mButtonDataRoam) { 1200 if (DBG) log("onPreferenceTreeClick: preference == mButtonDataRoam."); 1201 1202 //normally called on the toggle click 1203 if (!mButtonDataRoam.isChecked()) { 1204 // First confirm with a warning dialog about charges 1205 mOkClicked = false; 1206 RoamingDialogFragment fragment = new RoamingDialogFragment(); 1207 fragment.show(getFragmentManager(), ROAMING_TAG); 1208 // Don't update the toggle unless the confirm button is actually pressed. 1209 return false; 1210 } else { 1211 mPhone.setDataRoamingEnabled(false); 1212 } 1213 return true; 1214 } else if (preference == mVideoCallingPref) { 1215 // If mButton4glte is not checked, mVideoCallingPref should be disabled. 1216 // So it only makes sense to call phoneMgr.enableVideoCalling if it's checked. 1217 if (mButton4glte.isChecked()) { 1218 PhoneGlobals.getInstance().phoneMgr.enableVideoCalling((boolean) objValue); 1219 return true; 1220 } else { 1221 loge("mVideoCallingPref should be disabled if mButton4glte is not checked."); 1222 mVideoCallingPref.setEnabled(false); 1223 return false; 1224 } 1225 } 1226 1227 updateBody(); 1228 // always let the preference setting proceed. 1229 return true; 1230 } 1231 1232 private boolean is4gLtePrefEnabled(Context context, PersistableBundle carrierConfig) { 1233 return (mTelephonyManager.getCallState() == TelephonyManager.CALL_STATE_IDLE) 1234 && ImsManager.isNonTtyOrTtyOnVolteEnabled(context) 1235 && carrierConfig.getBoolean( 1236 CarrierConfigManager.KEY_EDITABLE_ENHANCED_4G_LTE_BOOL); 1237 } 1238 1239 private class MyHandler extends Handler { 1240 1241 static final int MESSAGE_SET_PREFERRED_NETWORK_TYPE = 0; 1242 1243 @Override 1244 public void handleMessage(Message msg) { 1245 switch (msg.what) { 1246 case MESSAGE_SET_PREFERRED_NETWORK_TYPE: 1247 handleSetPreferredNetworkTypeResponse(msg); 1248 break; 1249 } 1250 } 1251 1252 private void handleSetPreferredNetworkTypeResponse(Message msg) { 1253 final Activity activity = getActivity(); 1254 if (activity == null || activity.isDestroyed()) { 1255 // Access preferences of activity only if it is not destroyed 1256 // or if fragment is not attached to an activity. 1257 return; 1258 } 1259 1260 AsyncResult ar = (AsyncResult) msg.obj; 1261 final int phoneSubId = mPhone.getSubId(); 1262 1263 if (ar.exception == null) { 1264 int networkMode; 1265 if (getPreferenceScreen().findPreference( 1266 BUTTON_PREFERED_NETWORK_MODE) != null) { 1267 networkMode = Integer.parseInt(mButtonPreferredNetworkMode.getValue()); 1268 android.provider.Settings.Global.putInt( 1269 mPhone.getContext().getContentResolver(), 1270 android.provider.Settings.Global.PREFERRED_NETWORK_MODE 1271 + phoneSubId, 1272 networkMode ); 1273 } 1274 if (getPreferenceScreen().findPreference(BUTTON_ENABLED_NETWORKS_KEY) != null) { 1275 networkMode = Integer.parseInt(mButtonEnabledNetworks.getValue()); 1276 android.provider.Settings.Global.putInt( 1277 mPhone.getContext().getContentResolver(), 1278 android.provider.Settings.Global.PREFERRED_NETWORK_MODE 1279 + phoneSubId, 1280 networkMode ); 1281 } 1282 } else { 1283 Log.i(LOG_TAG, "handleSetPreferredNetworkTypeResponse:" + 1284 "exception in setting network mode."); 1285 updatePreferredNetworkUIFromDb(); 1286 } 1287 } 1288 } 1289 1290 private void updatePreferredNetworkUIFromDb() { 1291 final int phoneSubId = mPhone.getSubId(); 1292 1293 int settingsNetworkMode = android.provider.Settings.Global.getInt( 1294 mPhone.getContext().getContentResolver(), 1295 android.provider.Settings.Global.PREFERRED_NETWORK_MODE + phoneSubId, 1296 preferredNetworkMode); 1297 1298 if (DBG) { 1299 log("updatePreferredNetworkUIFromDb: settingsNetworkMode = " + 1300 settingsNetworkMode); 1301 } 1302 1303 UpdatePreferredNetworkModeSummary(settingsNetworkMode); 1304 UpdateEnabledNetworksValueAndSummary(settingsNetworkMode); 1305 // changes the mButtonPreferredNetworkMode accordingly to settingsNetworkMode 1306 mButtonPreferredNetworkMode.setValue(Integer.toString(settingsNetworkMode)); 1307 } 1308 1309 private void UpdatePreferredNetworkModeSummary(int NetworkMode) { 1310 switch(NetworkMode) { 1311 case Phone.NT_MODE_TDSCDMA_GSM_WCDMA: 1312 case Phone.NT_MODE_TDSCDMA_GSM: 1313 case Phone.NT_MODE_WCDMA_PREF: 1314 mButtonPreferredNetworkMode.setSummary( 1315 R.string.preferred_network_mode_wcdma_perf_summary); 1316 break; 1317 case Phone.NT_MODE_GSM_ONLY: 1318 mButtonPreferredNetworkMode.setSummary( 1319 R.string.preferred_network_mode_gsm_only_summary); 1320 break; 1321 case Phone.NT_MODE_TDSCDMA_WCDMA: 1322 case Phone.NT_MODE_WCDMA_ONLY: 1323 mButtonPreferredNetworkMode.setSummary( 1324 R.string.preferred_network_mode_wcdma_only_summary); 1325 break; 1326 case Phone.NT_MODE_GSM_UMTS: 1327 mButtonPreferredNetworkMode.setSummary( 1328 R.string.preferred_network_mode_gsm_wcdma_summary); 1329 break; 1330 case Phone.NT_MODE_CDMA: 1331 switch (mPhone.getLteOnCdmaMode()) { 1332 case PhoneConstants.LTE_ON_CDMA_TRUE: 1333 mButtonPreferredNetworkMode.setSummary( 1334 R.string.preferred_network_mode_cdma_summary); 1335 break; 1336 case PhoneConstants.LTE_ON_CDMA_FALSE: 1337 default: 1338 mButtonPreferredNetworkMode.setSummary( 1339 R.string.preferred_network_mode_cdma_evdo_summary); 1340 break; 1341 } 1342 break; 1343 case Phone.NT_MODE_CDMA_NO_EVDO: 1344 mButtonPreferredNetworkMode.setSummary( 1345 R.string.preferred_network_mode_cdma_only_summary); 1346 break; 1347 case Phone.NT_MODE_EVDO_NO_CDMA: 1348 mButtonPreferredNetworkMode.setSummary( 1349 R.string.preferred_network_mode_evdo_only_summary); 1350 break; 1351 case Phone.NT_MODE_LTE_TDSCDMA: 1352 case Phone.NT_MODE_LTE_ONLY: 1353 mButtonPreferredNetworkMode.setSummary( 1354 R.string.preferred_network_mode_lte_summary); 1355 break; 1356 case Phone.NT_MODE_LTE_TDSCDMA_GSM: 1357 case Phone.NT_MODE_LTE_TDSCDMA_GSM_WCDMA: 1358 case Phone.NT_MODE_LTE_GSM_WCDMA: 1359 mButtonPreferredNetworkMode.setSummary( 1360 R.string.preferred_network_mode_lte_gsm_wcdma_summary); 1361 break; 1362 case Phone.NT_MODE_LTE_CDMA_AND_EVDO: 1363 mButtonPreferredNetworkMode.setSummary( 1364 R.string.preferred_network_mode_lte_cdma_evdo_summary); 1365 break; 1366 case Phone.NT_MODE_TDSCDMA_ONLY: 1367 mButtonPreferredNetworkMode.setSummary( 1368 R.string.preferred_network_mode_tdscdma_summary); 1369 break; 1370 case Phone.NT_MODE_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA: 1371 case Phone.NT_MODE_LTE_CDMA_EVDO_GSM_WCDMA: 1372 if (mPhone.getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA || 1373 mIsGlobalCdma || 1374 isWorldMode()) { 1375 mButtonPreferredNetworkMode.setSummary( 1376 R.string.preferred_network_mode_global_summary); 1377 } else { 1378 mButtonPreferredNetworkMode.setSummary( 1379 R.string.preferred_network_mode_lte_summary); 1380 } 1381 break; 1382 case Phone.NT_MODE_TDSCDMA_CDMA_EVDO_GSM_WCDMA: 1383 case Phone.NT_MODE_GLOBAL: 1384 mButtonPreferredNetworkMode.setSummary( 1385 R.string.preferred_network_mode_cdma_evdo_gsm_wcdma_summary); 1386 break; 1387 case Phone.NT_MODE_LTE_TDSCDMA_WCDMA: 1388 case Phone.NT_MODE_LTE_WCDMA: 1389 mButtonPreferredNetworkMode.setSummary( 1390 R.string.preferred_network_mode_lte_wcdma_summary); 1391 break; 1392 default: 1393 mButtonPreferredNetworkMode.setSummary( 1394 R.string.preferred_network_mode_global_summary); 1395 } 1396 } 1397 1398 private void UpdateEnabledNetworksValueAndSummary(int NetworkMode) { 1399 switch (NetworkMode) { 1400 case Phone.NT_MODE_TDSCDMA_WCDMA: 1401 case Phone.NT_MODE_TDSCDMA_GSM_WCDMA: 1402 case Phone.NT_MODE_TDSCDMA_GSM: 1403 mButtonEnabledNetworks.setValue( 1404 Integer.toString(Phone.NT_MODE_TDSCDMA_GSM_WCDMA)); 1405 mButtonEnabledNetworks.setSummary(R.string.network_3G); 1406 break; 1407 case Phone.NT_MODE_WCDMA_ONLY: 1408 case Phone.NT_MODE_GSM_UMTS: 1409 case Phone.NT_MODE_WCDMA_PREF: 1410 if (!mIsGlobalCdma) { 1411 mButtonEnabledNetworks.setValue( 1412 Integer.toString(Phone.NT_MODE_WCDMA_PREF)); 1413 mButtonEnabledNetworks.setSummary(R.string.network_3G); 1414 } else { 1415 mButtonEnabledNetworks.setValue( 1416 Integer.toString(Phone.NT_MODE_LTE_CDMA_EVDO_GSM_WCDMA)); 1417 mButtonEnabledNetworks.setSummary(R.string.network_global); 1418 } 1419 break; 1420 case Phone.NT_MODE_GSM_ONLY: 1421 if (!mIsGlobalCdma) { 1422 mButtonEnabledNetworks.setValue( 1423 Integer.toString(Phone.NT_MODE_GSM_ONLY)); 1424 mButtonEnabledNetworks.setSummary(R.string.network_2G); 1425 } else { 1426 mButtonEnabledNetworks.setValue( 1427 Integer.toString(Phone.NT_MODE_LTE_CDMA_EVDO_GSM_WCDMA)); 1428 mButtonEnabledNetworks.setSummary(R.string.network_global); 1429 } 1430 break; 1431 case Phone.NT_MODE_LTE_GSM_WCDMA: 1432 if (isWorldMode()) { 1433 mButtonEnabledNetworks.setSummary( 1434 R.string.preferred_network_mode_lte_gsm_umts_summary); 1435 controlCdmaOptions(false); 1436 controlGsmOptions(true); 1437 break; 1438 } 1439 case Phone.NT_MODE_LTE_ONLY: 1440 case Phone.NT_MODE_LTE_WCDMA: 1441 if (!mIsGlobalCdma) { 1442 mButtonEnabledNetworks.setValue( 1443 Integer.toString(Phone.NT_MODE_LTE_GSM_WCDMA)); 1444 mButtonEnabledNetworks.setSummary((mShow4GForLTE == true) 1445 ? R.string.network_4G : R.string.network_lte); 1446 } else { 1447 mButtonEnabledNetworks.setValue( 1448 Integer.toString(Phone.NT_MODE_LTE_CDMA_EVDO_GSM_WCDMA)); 1449 mButtonEnabledNetworks.setSummary(R.string.network_global); 1450 } 1451 break; 1452 case Phone.NT_MODE_LTE_CDMA_AND_EVDO: 1453 if (isWorldMode()) { 1454 mButtonEnabledNetworks.setSummary( 1455 R.string.preferred_network_mode_lte_cdma_summary); 1456 controlCdmaOptions(true); 1457 controlGsmOptions(false); 1458 } else { 1459 mButtonEnabledNetworks.setValue( 1460 Integer.toString(Phone.NT_MODE_LTE_CDMA_AND_EVDO)); 1461 mButtonEnabledNetworks.setSummary(R.string.network_lte); 1462 } 1463 break; 1464 case Phone.NT_MODE_TDSCDMA_CDMA_EVDO_GSM_WCDMA: 1465 mButtonEnabledNetworks.setValue( 1466 Integer.toString(Phone.NT_MODE_TDSCDMA_CDMA_EVDO_GSM_WCDMA)); 1467 mButtonEnabledNetworks.setSummary(R.string.network_3G); 1468 break; 1469 case Phone.NT_MODE_CDMA: 1470 case Phone.NT_MODE_EVDO_NO_CDMA: 1471 case Phone.NT_MODE_GLOBAL: 1472 mButtonEnabledNetworks.setValue( 1473 Integer.toString(Phone.NT_MODE_CDMA)); 1474 mButtonEnabledNetworks.setSummary(R.string.network_3G); 1475 break; 1476 case Phone.NT_MODE_CDMA_NO_EVDO: 1477 mButtonEnabledNetworks.setValue( 1478 Integer.toString(Phone.NT_MODE_CDMA_NO_EVDO)); 1479 mButtonEnabledNetworks.setSummary(R.string.network_1x); 1480 break; 1481 case Phone.NT_MODE_TDSCDMA_ONLY: 1482 mButtonEnabledNetworks.setValue( 1483 Integer.toString(Phone.NT_MODE_TDSCDMA_ONLY)); 1484 mButtonEnabledNetworks.setSummary(R.string.network_3G); 1485 break; 1486 case Phone.NT_MODE_LTE_TDSCDMA_GSM: 1487 case Phone.NT_MODE_LTE_TDSCDMA_GSM_WCDMA: 1488 case Phone.NT_MODE_LTE_TDSCDMA: 1489 case Phone.NT_MODE_LTE_TDSCDMA_WCDMA: 1490 case Phone.NT_MODE_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA: 1491 case Phone.NT_MODE_LTE_CDMA_EVDO_GSM_WCDMA: 1492 if (isSupportTdscdma()) { 1493 mButtonEnabledNetworks.setValue( 1494 Integer.toString(Phone.NT_MODE_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA)); 1495 mButtonEnabledNetworks.setSummary(R.string.network_lte); 1496 } else { 1497 if (isWorldMode()) { 1498 controlCdmaOptions(true); 1499 controlGsmOptions(false); 1500 } 1501 mButtonEnabledNetworks.setValue( 1502 Integer.toString(Phone.NT_MODE_LTE_CDMA_EVDO_GSM_WCDMA)); 1503 if (mPhone.getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA || 1504 mIsGlobalCdma || 1505 isWorldMode()) { 1506 mButtonEnabledNetworks.setSummary(R.string.network_global); 1507 } else { 1508 mButtonEnabledNetworks.setSummary((mShow4GForLTE == true) 1509 ? R.string.network_4G : R.string.network_lte); 1510 } 1511 } 1512 break; 1513 default: 1514 String errMsg = "Invalid Network Mode (" + NetworkMode + "). Ignore."; 1515 loge(errMsg); 1516 mButtonEnabledNetworks.setSummary(errMsg); 1517 } 1518 } 1519 1520 @Override 1521 public void onActivityResult(int requestCode, int resultCode, Intent data) { 1522 switch(requestCode) { 1523 case REQUEST_CODE_EXIT_ECM: 1524 Boolean isChoiceYes = data.getBooleanExtra( 1525 EmergencyCallbackModeExitDialog.EXTRA_EXIT_ECM_RESULT, false); 1526 if (isChoiceYes) { 1527 // If the phone exits from ECM mode, show the CDMA Options 1528 mCdmaOptions.showDialog(mClickedPreference); 1529 } else { 1530 // do nothing 1531 } 1532 break; 1533 1534 default: 1535 break; 1536 } 1537 } 1538 1539 private void updateWiFiCallState() { 1540 if (mWiFiCallingPref == null || mCallingCategory == null) { 1541 return; 1542 } 1543 1544 boolean removePref = false; 1545 final PhoneAccountHandle simCallManager = 1546 TelecomManager.from(getContext()).getSimCallManager(); 1547 1548 if (simCallManager != null) { 1549 Intent intent = PhoneAccountSettingsFragment.buildPhoneAccountConfigureIntent( 1550 getContext(), simCallManager); 1551 if (intent != null) { 1552 PackageManager pm = mPhone.getContext().getPackageManager(); 1553 List<ResolveInfo> resolutions = pm.queryIntentActivities(intent, 0); 1554 if (!resolutions.isEmpty()) { 1555 mWiFiCallingPref.setTitle(resolutions.get(0).loadLabel(pm)); 1556 mWiFiCallingPref.setSummary(null); 1557 mWiFiCallingPref.setIntent(intent); 1558 } else { 1559 removePref = true; 1560 } 1561 } else { 1562 removePref = true; 1563 } 1564 } else if (!ImsManager.isWfcEnabledByPlatform(mPhone.getContext()) 1565 || !ImsManager.isWfcProvisionedOnDevice(mPhone.getContext())) { 1566 removePref = true; 1567 } else { 1568 int resId = com.android.internal.R.string.wifi_calling_off_summary; 1569 if (ImsManager.isWfcEnabledByUser(mPhone.getContext())) { 1570 boolean isRoaming = mButtonDataRoam.isChecked(); 1571 int wfcMode = ImsManager.getWfcMode(mPhone.getContext(), isRoaming); 1572 switch (wfcMode) { 1573 case ImsConfig.WfcModeFeatureValueConstants.WIFI_ONLY: 1574 resId = com.android.internal.R.string.wfc_mode_wifi_only_summary; 1575 break; 1576 case ImsConfig.WfcModeFeatureValueConstants.CELLULAR_PREFERRED: 1577 resId = com.android.internal.R.string 1578 .wfc_mode_cellular_preferred_summary; 1579 break; 1580 case ImsConfig.WfcModeFeatureValueConstants.WIFI_PREFERRED: 1581 resId = com.android.internal.R.string.wfc_mode_wifi_preferred_summary; 1582 break; 1583 default: 1584 if (DBG) log("Unexpected WFC mode value: " + wfcMode); 1585 } 1586 } 1587 mWiFiCallingPref.setSummary(resId); 1588 } 1589 1590 if (removePref) { 1591 mCallingCategory.removePreference(mWiFiCallingPref); 1592 } else { 1593 mCallingCategory.addPreference(mWiFiCallingPref); 1594 } 1595 } 1596 1597 private void updateVideoCallState() { 1598 if (mVideoCallingPref == null || mCallingCategory == null) { 1599 return; 1600 } 1601 1602 PersistableBundle carrierConfig = PhoneGlobals.getInstance() 1603 .getCarrierConfigForSubId(mPhone.getSubId()); 1604 1605 boolean removePref = false; 1606 1607 if (ImsManager.isVtEnabledByPlatform(mPhone.getContext()) 1608 && ImsManager.isVtProvisionedOnDevice(mPhone.getContext()) 1609 && (carrierConfig.getBoolean( 1610 CarrierConfigManager.KEY_IGNORE_DATA_ENABLED_CHANGED_FOR_VIDEO_CALLS) 1611 || mPhone.mDcTracker.isDataEnabled())) { 1612 boolean enhanced4gLteEnabled = mButton4glte.isChecked(); 1613 mVideoCallingPref.setEnabled(enhanced4gLteEnabled); 1614 boolean currentValue = enhanced4gLteEnabled 1615 ? PhoneGlobals.getInstance().phoneMgr.isVideoCallingEnabled( 1616 getContext().getOpPackageName()) : false; 1617 mVideoCallingPref.setChecked(currentValue); 1618 if (enhanced4gLteEnabled) { 1619 mVideoCallingPref.setOnPreferenceChangeListener(this); 1620 } 1621 } else { 1622 removePref = true; 1623 } 1624 1625 if (removePref) { 1626 mCallingCategory.removePreference(mVideoCallingPref); 1627 } else { 1628 mCallingCategory.addPreference(mVideoCallingPref); 1629 } 1630 } 1631 1632 private void updateCallingCategory() { 1633 if (mCallingCategory == null) { 1634 return; 1635 } 1636 1637 updateWiFiCallState(); 1638 updateVideoCallState(); 1639 1640 // If all items in calling category is removed, we remove it from 1641 // the screen. Otherwise we'll see title of the category but nothing 1642 // is in there. 1643 if (mCallingCategory.getPreferenceCount() == 0) { 1644 getPreferenceScreen().removePreference(mCallingCategory); 1645 } else { 1646 getPreferenceScreen().addPreference(mCallingCategory); 1647 } 1648 } 1649 1650 private static void log(String msg) { 1651 Log.d(LOG_TAG, msg); 1652 } 1653 1654 private static void loge(String msg) { 1655 Log.e(LOG_TAG, msg); 1656 } 1657 1658 @Override 1659 public boolean onOptionsItemSelected(MenuItem item) { 1660 final int itemId = item.getItemId(); 1661 if (itemId == android.R.id.home) { // See ActionBar#setDisplayHomeAsUpEnabled() 1662 // Commenting out "logical up" capability. This is a workaround for issue 5278083. 1663 // 1664 // Settings app may not launch this activity via UP_ACTIVITY_CLASS but the other 1665 // Activity that looks exactly same as UP_ACTIVITY_CLASS ("SubSettings" Activity). 1666 // At that moment, this Activity launches UP_ACTIVITY_CLASS on top of the Activity. 1667 // which confuses users. 1668 // TODO: introduce better mechanism for "up" capability here. 1669 /*Intent intent = new Intent(Intent.ACTION_MAIN); 1670 intent.setClassName(UP_ACTIVITY_PACKAGE, UP_ACTIVITY_CLASS); 1671 intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP); 1672 startActivity(intent);*/ 1673 getActivity().finish(); 1674 return true; 1675 } 1676 return super.onOptionsItemSelected(item); 1677 } 1678 1679 private boolean isWorldMode() { 1680 boolean worldModeOn = false; 1681 final String configString = getResources().getString(R.string.config_world_mode); 1682 1683 if (!TextUtils.isEmpty(configString)) { 1684 String[] configArray = configString.split(";"); 1685 // Check if we have World mode configuration set to True only or config is set to True 1686 // and SIM GID value is also set and matches to the current SIM GID. 1687 if (configArray != null && 1688 ((configArray.length == 1 && configArray[0].equalsIgnoreCase("true")) 1689 || (configArray.length == 2 && !TextUtils.isEmpty(configArray[1]) 1690 && mTelephonyManager != null 1691 && configArray[1].equalsIgnoreCase( 1692 mTelephonyManager.getGroupIdLevel1())))) { 1693 worldModeOn = true; 1694 } 1695 } 1696 1697 Log.d(LOG_TAG, "isWorldMode=" + worldModeOn); 1698 1699 return worldModeOn; 1700 } 1701 1702 private void controlGsmOptions(boolean enable) { 1703 PreferenceScreen prefSet = getPreferenceScreen(); 1704 if (prefSet == null) { 1705 return; 1706 } 1707 1708 updateGsmUmtsOptions(this, prefSet, mPhone.getSubId(), mNetworkQueryService); 1709 1710 PreferenceCategory apnExpand = 1711 (PreferenceCategory) prefSet.findPreference(CATEGORY_GSM_APN_EXPAND_KEY); 1712 PreferenceCategory networkOperatorCategory = 1713 (PreferenceCategory) prefSet.findPreference( 1714 NetworkOperators.CATEGORY_NETWORK_OPERATORS_KEY); 1715 Preference carrierSettings = prefSet.findPreference(BUTTON_CARRIER_SETTINGS_KEY); 1716 if (apnExpand != null) { 1717 apnExpand.setEnabled(isWorldMode() || enable); 1718 } 1719 if (networkOperatorCategory != null) { 1720 if (enable) { 1721 networkOperatorCategory.setEnabled(true); 1722 } else { 1723 prefSet.removePreference(networkOperatorCategory); 1724 } 1725 } 1726 if (carrierSettings != null) { 1727 prefSet.removePreference(carrierSettings); 1728 } 1729 } 1730 1731 private void controlCdmaOptions(boolean enable) { 1732 PreferenceScreen prefSet = getPreferenceScreen(); 1733 if (prefSet == null) { 1734 return; 1735 } 1736 updateCdmaOptions(this, prefSet, mPhone); 1737 CdmaSystemSelectListPreference systemSelect = 1738 (CdmaSystemSelectListPreference)prefSet.findPreference 1739 (BUTTON_CDMA_SYSTEM_SELECT_KEY); 1740 if (systemSelect != null) { 1741 systemSelect.setEnabled(enable); 1742 } 1743 } 1744 1745 private boolean isSupportTdscdma() { 1746 if (getResources().getBoolean(R.bool.config_support_tdscdma)) { 1747 return true; 1748 } 1749 1750 String operatorNumeric = mPhone.getServiceState().getOperatorNumeric(); 1751 String[] numericArray = getResources().getStringArray( 1752 R.array.config_support_tdscdma_roaming_on_networks); 1753 if (numericArray.length == 0 || operatorNumeric == null) { 1754 return false; 1755 } 1756 for (String numeric : numericArray) { 1757 if (operatorNumeric.equals(numeric)) { 1758 return true; 1759 } 1760 } 1761 return false; 1762 } 1763 1764 private void sendMetricsEventPreferenceClicked( 1765 PreferenceScreen preferenceScreen, Preference preference) { 1766 if (preference == mMobileDataPref) { 1767 MetricsLogger.action(getContext(), 1768 MetricsEvent.ACTION_MOBILE_NETWORK_MOBILE_DATA_TOGGLE, 1769 ((MobileDataPreference) preference).mChecked); 1770 } else if (preference == mDataUsagePref) { 1771 MetricsLogger.action(getContext(), 1772 MetricsEvent.ACTION_MOBILE_NETWORK_DATA_USAGE); 1773 } 1774 // TODO: add Metrics constants for other preferences and send events here accordingly. 1775 } 1776 1777 private void updateGsmUmtsOptions(PreferenceFragment prefFragment, 1778 PreferenceScreen prefScreen, final int subId, INetworkQueryService queryService) { 1779 // We don't want to re-create GsmUmtsOptions if already exists. Otherwise, the 1780 // preferences inside it will also be re-created which causes unexpected behavior. 1781 // For example, the open dialog gets dismissed or detached after pause / resume. 1782 if (mGsmUmtsOptions == null) { 1783 mGsmUmtsOptions = new GsmUmtsOptions(prefFragment, prefScreen, subId, queryService); 1784 } else { 1785 mGsmUmtsOptions.update(subId, queryService); 1786 } 1787 } 1788 1789 private void updateCdmaOptions(PreferenceFragment prefFragment, PreferenceScreen prefScreen, 1790 Phone phone) { 1791 // We don't want to re-create CdmaOptions if already exists. Otherwise, the preferences 1792 // inside it will also be re-created which causes unexpected behavior. For example, 1793 // the open dialog gets dismissed or detached after pause / resume. 1794 if (mCdmaOptions == null) { 1795 mCdmaOptions = new CdmaOptions(prefFragment, prefScreen, phone); 1796 } else { 1797 mCdmaOptions.update(phone); 1798 } 1799 } 1800 } 1801 } 1802 1803
