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