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