• 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.internal.telephony.Phone;
20 import com.android.internal.telephony.TelephonyIntents;
21 import com.android.internal.telephony.TelephonyProperties;
22 
23 import android.app.ActionBar;
24 import android.app.AlertDialog;
25 import android.content.Context;
26 import android.content.DialogInterface;
27 import android.content.Intent;
28 import android.net.ConnectivityManager;
29 import android.net.ThrottleManager;
30 import android.net.Uri;
31 import android.os.AsyncResult;
32 import android.os.Bundle;
33 import android.os.Handler;
34 import android.os.Message;
35 import android.os.SystemProperties;
36 import android.preference.CheckBoxPreference;
37 import android.preference.ListPreference;
38 import android.preference.Preference;
39 import android.preference.PreferenceActivity;
40 import android.preference.PreferenceScreen;
41 import android.telephony.TelephonyManager;
42 import android.text.TextUtils;
43 import android.util.Log;
44 import android.view.MenuItem;
45 
46 /**
47  * "Mobile network settings" screen.  This preference screen lets you
48  * enable/disable mobile data, and control data roaming and other
49  * network-specific mobile data features.  It's used on non-voice-capable
50  * tablets as well as regular phone devices.
51  *
52  * Note that this PreferenceActivity is part of the phone app, even though
53  * you reach it from the "Wireless & Networks" section of the main
54  * Settings app.  It's not part of the "Call settings" hierarchy that's
55  * available from the Phone app (see CallFeaturesSetting for that.)
56  */
57 public class MobileNetworkSettings extends PreferenceActivity
58         implements DialogInterface.OnClickListener,
59         DialogInterface.OnDismissListener, Preference.OnPreferenceChangeListener{
60 
61     // debug data
62     private static final String LOG_TAG = "NetworkSettings";
63     private static final boolean DBG = false;
64     public static final int REQUEST_CODE_EXIT_ECM = 17;
65 
66     //String keys for preference lookup
67     private static final String BUTTON_DATA_ENABLED_KEY = "button_data_enabled_key";
68     private static final String BUTTON_DATA_USAGE_KEY = "button_data_usage_key";
69     private static final String BUTTON_PREFERED_NETWORK_MODE = "preferred_network_mode_key";
70     private static final String BUTTON_ROAMING_KEY = "button_roaming_key";
71     private static final String BUTTON_CDMA_LTE_DATA_SERVICE_KEY = "cdma_lte_data_service_key";
72 
73     static final int preferredNetworkMode = Phone.PREFERRED_NT_MODE;
74 
75     //Information about logical "up" Activity
76     private static final String UP_ACTIVITY_PACKAGE = "com.android.settings";
77     private static final String UP_ACTIVITY_CLASS =
78             "com.android.settings.Settings$WirelessSettingsActivity";
79 
80     //UI objects
81     private ListPreference mButtonPreferredNetworkMode;
82     private CheckBoxPreference mButtonDataRoam;
83     private CheckBoxPreference mButtonDataEnabled;
84     private Preference mLteDataServicePref;
85 
86     private Preference mButtonDataUsage;
87     private DataUsageListener mDataUsageListener;
88     private static final String iface = "rmnet0"; //TODO: this will go away
89 
90     private Phone mPhone;
91     private MyHandler mHandler;
92     private boolean mOkClicked;
93 
94     //GsmUmts options and Cdma options
95     GsmUmtsOptions mGsmUmtsOptions;
96     CdmaOptions mCdmaOptions;
97 
98     private Preference mClickedPreference;
99 
100 
101     //This is a method implemented for DialogInterface.OnClickListener.
102     //  Used to dismiss the dialogs when they come up.
onClick(DialogInterface dialog, int which)103     public void onClick(DialogInterface dialog, int which) {
104         if (which == DialogInterface.BUTTON_POSITIVE) {
105             mPhone.setDataRoamingEnabled(true);
106             mOkClicked = true;
107         } else {
108             // Reset the toggle
109             mButtonDataRoam.setChecked(false);
110         }
111     }
112 
onDismiss(DialogInterface dialog)113     public void onDismiss(DialogInterface dialog) {
114         // Assuming that onClick gets called first
115         if (!mOkClicked) {
116             mButtonDataRoam.setChecked(false);
117         }
118     }
119 
120     /**
121      * Invoked on each preference click in this hierarchy, overrides
122      * PreferenceActivity's implementation.  Used to make sure we track the
123      * preference click events.
124      */
125     @Override
onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference)126     public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference) {
127         /** TODO: Refactor and get rid of the if's using subclasses */
128         if (mGsmUmtsOptions != null &&
129                 mGsmUmtsOptions.preferenceTreeClick(preference) == true) {
130             return true;
131         } else if (mCdmaOptions != null &&
132                    mCdmaOptions.preferenceTreeClick(preference) == true) {
133             if (Boolean.parseBoolean(
134                     SystemProperties.get(TelephonyProperties.PROPERTY_INECM_MODE))) {
135 
136                 mClickedPreference = preference;
137 
138                 // In ECM mode launch ECM app dialog
139                 startActivityForResult(
140                     new Intent(TelephonyIntents.ACTION_SHOW_NOTICE_ECM_BLOCK_OTHERS, null),
141                     REQUEST_CODE_EXIT_ECM);
142             }
143             return true;
144         } else if (preference == mButtonPreferredNetworkMode) {
145             //displays the value taken from the Settings.System
146             int settingsNetworkMode = android.provider.Settings.Secure.getInt(mPhone.getContext().
147                     getContentResolver(), android.provider.Settings.Secure.PREFERRED_NETWORK_MODE,
148                     preferredNetworkMode);
149             mButtonPreferredNetworkMode.setValue(Integer.toString(settingsNetworkMode));
150             return true;
151         } else if (preference == mButtonDataRoam) {
152             if (DBG) log("onPreferenceTreeClick: preference == mButtonDataRoam.");
153 
154             //normally called on the toggle click
155             if (mButtonDataRoam.isChecked()) {
156                 // First confirm with a warning dialog about charges
157                 mOkClicked = false;
158                 new AlertDialog.Builder(this).setMessage(
159                         getResources().getString(R.string.roaming_warning))
160                         .setTitle(android.R.string.dialog_alert_title)
161                         .setIconAttribute(android.R.attr.alertDialogIcon)
162                         .setPositiveButton(android.R.string.yes, this)
163                         .setNegativeButton(android.R.string.no, this)
164                         .show()
165                         .setOnDismissListener(this);
166             } else {
167                 mPhone.setDataRoamingEnabled(false);
168             }
169             return true;
170         } else if (preference == mButtonDataEnabled) {
171             if (DBG) log("onPreferenceTreeClick: preference == mButtonDataEnabled.");
172             ConnectivityManager cm =
173                     (ConnectivityManager)getSystemService(Context.CONNECTIVITY_SERVICE);
174 
175             cm.setMobileDataEnabled(mButtonDataEnabled.isChecked());
176             return true;
177         } else if (preference == mLteDataServicePref) {
178             String tmpl = android.provider.Settings.Secure.getString(getContentResolver(),
179                         android.provider.Settings.Secure.SETUP_PREPAID_DATA_SERVICE_URL);
180             if (!TextUtils.isEmpty(tmpl)) {
181                 TelephonyManager tm = (TelephonyManager) getSystemService(
182                         Context.TELEPHONY_SERVICE);
183                 String imsi = tm.getSubscriberId();
184                 if (imsi == null) {
185                     imsi = "";
186                 }
187                 final String url = TextUtils.isEmpty(tmpl) ? null
188                         : TextUtils.expandTemplate(tmpl, imsi).toString();
189                 Intent intent = new Intent(Intent.ACTION_VIEW, Uri.parse(url));
190                 startActivity(intent);
191             } else {
192                 android.util.Log.e(LOG_TAG, "Missing SETUP_PREPAID_DATA_SERVICE_URL");
193             }
194             return true;
195         } else {
196             // if the button is anything but the simple toggle preference,
197             // we'll need to disable all preferences to reject all click
198             // events until the sub-activity's UI comes up.
199             preferenceScreen.setEnabled(false);
200             // Let the intents be launched by the Preference manager
201             return false;
202         }
203     }
204 
205     @Override
onCreate(Bundle icicle)206     protected void onCreate(Bundle icicle) {
207         super.onCreate(icicle);
208 
209         addPreferencesFromResource(R.xml.network_setting);
210 
211         mPhone = PhoneApp.getPhone();
212         mHandler = new MyHandler();
213 
214         //get UI object references
215         PreferenceScreen prefSet = getPreferenceScreen();
216 
217         mButtonDataEnabled = (CheckBoxPreference) prefSet.findPreference(BUTTON_DATA_ENABLED_KEY);
218         mButtonDataRoam = (CheckBoxPreference) prefSet.findPreference(BUTTON_ROAMING_KEY);
219         mButtonPreferredNetworkMode = (ListPreference) prefSet.findPreference(
220                 BUTTON_PREFERED_NETWORK_MODE);
221         mButtonDataUsage = prefSet.findPreference(BUTTON_DATA_USAGE_KEY);
222         mLteDataServicePref = prefSet.findPreference(BUTTON_CDMA_LTE_DATA_SERVICE_KEY);
223 
224         boolean isLteOnCdma = mPhone.getLteOnCdmaMode() == Phone.LTE_ON_CDMA_TRUE;
225         if (getResources().getBoolean(R.bool.world_phone) == true) {
226             // set the listener for the mButtonPreferredNetworkMode list preference so we can issue
227             // change Preferred Network Mode.
228             mButtonPreferredNetworkMode.setOnPreferenceChangeListener(this);
229 
230             //Get the networkMode from Settings.System and displays it
231             int settingsNetworkMode = android.provider.Settings.Secure.getInt(mPhone.getContext().
232                     getContentResolver(),android.provider.Settings.Secure.PREFERRED_NETWORK_MODE,
233                     preferredNetworkMode);
234             mButtonPreferredNetworkMode.setValue(Integer.toString(settingsNetworkMode));
235             mCdmaOptions = new CdmaOptions(this, prefSet, mPhone);
236             mGsmUmtsOptions = new GsmUmtsOptions(this, prefSet);
237         } else {
238             if (!isLteOnCdma) {
239                 prefSet.removePreference(mButtonPreferredNetworkMode);
240             }
241             int phoneType = mPhone.getPhoneType();
242             if (phoneType == Phone.PHONE_TYPE_CDMA) {
243                 mCdmaOptions = new CdmaOptions(this, prefSet, mPhone);
244                 if (isLteOnCdma) {
245                     mButtonPreferredNetworkMode.setOnPreferenceChangeListener(this);
246                     mButtonPreferredNetworkMode.setEntries(
247                             R.array.preferred_network_mode_choices_lte);
248                     mButtonPreferredNetworkMode.setEntryValues(
249                             R.array.preferred_network_mode_values_lte);
250                     int settingsNetworkMode = android.provider.Settings.Secure.getInt(
251                             mPhone.getContext().getContentResolver(),
252                             android.provider.Settings.Secure.PREFERRED_NETWORK_MODE,
253                             preferredNetworkMode);
254                     mButtonPreferredNetworkMode.setValue(
255                             Integer.toString(settingsNetworkMode));
256                 }
257 
258             } else if (phoneType == Phone.PHONE_TYPE_GSM) {
259                 mGsmUmtsOptions = new GsmUmtsOptions(this, prefSet);
260             } else {
261                 throw new IllegalStateException("Unexpected phone type: " + phoneType);
262             }
263         }
264 
265         final boolean missingDataServiceUrl = TextUtils.isEmpty(
266                 android.provider.Settings.Secure.getString(getContentResolver(),
267                         android.provider.Settings.Secure.SETUP_PREPAID_DATA_SERVICE_URL));
268         if (!isLteOnCdma || missingDataServiceUrl) {
269             prefSet.removePreference(mLteDataServicePref);
270         } else {
271             android.util.Log.d(LOG_TAG, "keep ltePref");
272         }
273 
274         ThrottleManager tm = (ThrottleManager) getSystemService(Context.THROTTLE_SERVICE);
275         mDataUsageListener = new DataUsageListener(this, mButtonDataUsage, prefSet);
276 
277         ActionBar actionBar = getActionBar();
278         if (actionBar != null) {
279             // android.R.id.home will be triggered in onOptionsItemSelected()
280             actionBar.setDisplayHomeAsUpEnabled(true);
281         }
282     }
283 
284     @Override
onResume()285     protected void onResume() {
286         super.onResume();
287 
288         // upon resumption from the sub-activity, make sure we re-enable the
289         // preferences.
290         getPreferenceScreen().setEnabled(true);
291 
292         ConnectivityManager cm =
293                 (ConnectivityManager)getSystemService(Context.CONNECTIVITY_SERVICE);
294         mButtonDataEnabled.setChecked(cm.getMobileDataEnabled());
295 
296         // Set UI state in onResume because a user could go home, launch some
297         // app to change this setting's backend, and re-launch this settings app
298         // and the UI state would be inconsistent with actual state
299         mButtonDataRoam.setChecked(mPhone.getDataRoamingEnabled());
300 
301         if (getPreferenceScreen().findPreference(BUTTON_PREFERED_NETWORK_MODE) != null)  {
302             mPhone.getPreferredNetworkType(mHandler.obtainMessage(
303                     MyHandler.MESSAGE_GET_PREFERRED_NETWORK_TYPE));
304         }
305         mDataUsageListener.resume();
306     }
307 
308     @Override
onPause()309     protected void onPause() {
310         super.onPause();
311         mDataUsageListener.pause();
312     }
313 
314     /**
315      * Implemented to support onPreferenceChangeListener to look for preference
316      * changes specifically on CLIR.
317      *
318      * @param preference is the preference to be changed, should be mButtonCLIR.
319      * @param objValue should be the value of the selection, NOT its localized
320      * display value.
321      */
onPreferenceChange(Preference preference, Object objValue)322     public boolean onPreferenceChange(Preference preference, Object objValue) {
323         if (preference == mButtonPreferredNetworkMode) {
324             //NOTE onPreferenceChange seems to be called even if there is no change
325             //Check if the button value is changed from the System.Setting
326             mButtonPreferredNetworkMode.setValue((String) objValue);
327             int buttonNetworkMode;
328             buttonNetworkMode = Integer.valueOf((String) objValue).intValue();
329             int settingsNetworkMode = android.provider.Settings.Secure.getInt(
330                     mPhone.getContext().getContentResolver(),
331                     android.provider.Settings.Secure.PREFERRED_NETWORK_MODE, preferredNetworkMode);
332             if (buttonNetworkMode != settingsNetworkMode) {
333                 int modemNetworkMode;
334                 switch(buttonNetworkMode) {
335                     case Phone.NT_MODE_GLOBAL:
336                         modemNetworkMode = Phone.NT_MODE_GLOBAL;
337                         break;
338                     case Phone.NT_MODE_EVDO_NO_CDMA:
339                         modemNetworkMode = Phone.NT_MODE_EVDO_NO_CDMA;
340                         break;
341                     case Phone.NT_MODE_CDMA_NO_EVDO:
342                         modemNetworkMode = Phone.NT_MODE_CDMA_NO_EVDO;
343                         break;
344                     case Phone.NT_MODE_CDMA:
345                         modemNetworkMode = Phone.NT_MODE_CDMA;
346                         break;
347                     case Phone.NT_MODE_GSM_UMTS:
348                         modemNetworkMode = Phone.NT_MODE_GSM_UMTS;
349                         break;
350                     case Phone.NT_MODE_WCDMA_ONLY:
351                         modemNetworkMode = Phone.NT_MODE_WCDMA_ONLY;
352                         break;
353                     case Phone.NT_MODE_GSM_ONLY:
354                         modemNetworkMode = Phone.NT_MODE_GSM_ONLY;
355                         break;
356                     case Phone.NT_MODE_WCDMA_PREF:
357                         modemNetworkMode = Phone.NT_MODE_WCDMA_PREF;
358                         break;
359                     default:
360                         modemNetworkMode = Phone.PREFERRED_NT_MODE;
361                 }
362 
363                 // If button has no valid selection && setting is LTE ONLY
364                 // mode, let the setting stay in LTE ONLY mode. UI is not
365                 // supported but LTE ONLY mode could be used in testing.
366                 if ((modemNetworkMode == Phone.PREFERRED_NT_MODE) &&
367                     (settingsNetworkMode == Phone.NT_MODE_LTE_ONLY)) {
368                     return true;
369                 }
370 
371                 UpdatePreferredNetworkModeSummary(buttonNetworkMode);
372 
373                 android.provider.Settings.Secure.putInt(mPhone.getContext().getContentResolver(),
374                         android.provider.Settings.Secure.PREFERRED_NETWORK_MODE,
375                         buttonNetworkMode );
376                 //Set the modem network mode
377                 mPhone.setPreferredNetworkType(modemNetworkMode, mHandler
378                         .obtainMessage(MyHandler.MESSAGE_SET_PREFERRED_NETWORK_TYPE));
379             }
380         }
381 
382         // always let the preference setting proceed.
383         return true;
384     }
385 
386     private class MyHandler extends Handler {
387 
388         static final int MESSAGE_GET_PREFERRED_NETWORK_TYPE = 0;
389         static final int MESSAGE_SET_PREFERRED_NETWORK_TYPE = 1;
390 
391         @Override
handleMessage(Message msg)392         public void handleMessage(Message msg) {
393             switch (msg.what) {
394                 case MESSAGE_GET_PREFERRED_NETWORK_TYPE:
395                     handleGetPreferredNetworkTypeResponse(msg);
396                     break;
397 
398                 case MESSAGE_SET_PREFERRED_NETWORK_TYPE:
399                     handleSetPreferredNetworkTypeResponse(msg);
400                     break;
401             }
402         }
403 
handleGetPreferredNetworkTypeResponse(Message msg)404         private void handleGetPreferredNetworkTypeResponse(Message msg) {
405             AsyncResult ar = (AsyncResult) msg.obj;
406 
407             if (ar.exception == null) {
408                 int modemNetworkMode = ((int[])ar.result)[0];
409 
410                 if (DBG) {
411                     log ("handleGetPreferredNetworkTypeResponse: modemNetworkMode = " +
412                             modemNetworkMode);
413                 }
414 
415                 int settingsNetworkMode = android.provider.Settings.Secure.getInt(
416                         mPhone.getContext().getContentResolver(),
417                         android.provider.Settings.Secure.PREFERRED_NETWORK_MODE,
418                         preferredNetworkMode);
419 
420                 if (DBG) {
421                     log("handleGetPreferredNetworkTypeReponse: settingsNetworkMode = " +
422                             settingsNetworkMode);
423                 }
424 
425                 //check that modemNetworkMode is from an accepted value
426                 if (modemNetworkMode == Phone.NT_MODE_WCDMA_PREF ||
427                         modemNetworkMode == Phone.NT_MODE_GSM_ONLY ||
428                         modemNetworkMode == Phone.NT_MODE_WCDMA_ONLY ||
429                         modemNetworkMode == Phone.NT_MODE_GSM_UMTS ||
430                         modemNetworkMode == Phone.NT_MODE_CDMA ||
431                         modemNetworkMode == Phone.NT_MODE_CDMA_NO_EVDO ||
432                         modemNetworkMode == Phone.NT_MODE_EVDO_NO_CDMA ||
433                         modemNetworkMode == Phone.NT_MODE_GLOBAL ) {
434                     if (DBG) {
435                         log("handleGetPreferredNetworkTypeResponse: if 1: modemNetworkMode = " +
436                                 modemNetworkMode);
437                     }
438 
439                     //check changes in modemNetworkMode and updates settingsNetworkMode
440                     if (modemNetworkMode != settingsNetworkMode) {
441                         if (DBG) {
442                             log("handleGetPreferredNetworkTypeResponse: if 2: " +
443                                     "modemNetworkMode != settingsNetworkMode");
444                         }
445 
446                         settingsNetworkMode = modemNetworkMode;
447 
448                         if (DBG) { log("handleGetPreferredNetworkTypeResponse: if 2: " +
449                                 "settingsNetworkMode = " + settingsNetworkMode);
450                         }
451 
452                         //changes the Settings.System accordingly to modemNetworkMode
453                         android.provider.Settings.Secure.putInt(
454                                 mPhone.getContext().getContentResolver(),
455                                 android.provider.Settings.Secure.PREFERRED_NETWORK_MODE,
456                                 settingsNetworkMode );
457                     }
458 
459                     UpdatePreferredNetworkModeSummary(modemNetworkMode);
460                     // changes the mButtonPreferredNetworkMode accordingly to modemNetworkMode
461                     mButtonPreferredNetworkMode.setValue(Integer.toString(modemNetworkMode));
462                 } else if (modemNetworkMode == Phone.NT_MODE_LTE_ONLY) {
463                     // LTE Only mode not yet supported on UI, but could be used for testing
464                     if (DBG) log("handleGetPreferredNetworkTypeResponse: lte only: no action");
465                 } else {
466                     if (DBG) log("handleGetPreferredNetworkTypeResponse: else: reset to default");
467                     resetNetworkModeToDefault();
468                 }
469             }
470         }
471 
handleSetPreferredNetworkTypeResponse(Message msg)472         private void handleSetPreferredNetworkTypeResponse(Message msg) {
473             AsyncResult ar = (AsyncResult) msg.obj;
474 
475             if (ar.exception == null) {
476                 int networkMode = Integer.valueOf(
477                         mButtonPreferredNetworkMode.getValue()).intValue();
478                 android.provider.Settings.Secure.putInt(mPhone.getContext().getContentResolver(),
479                         android.provider.Settings.Secure.PREFERRED_NETWORK_MODE,
480                         networkMode );
481             } else {
482                 mPhone.getPreferredNetworkType(obtainMessage(MESSAGE_GET_PREFERRED_NETWORK_TYPE));
483             }
484         }
485 
resetNetworkModeToDefault()486         private void resetNetworkModeToDefault() {
487             //set the mButtonPreferredNetworkMode
488             mButtonPreferredNetworkMode.setValue(Integer.toString(preferredNetworkMode));
489             //set the Settings.System
490             android.provider.Settings.Secure.putInt(mPhone.getContext().getContentResolver(),
491                         android.provider.Settings.Secure.PREFERRED_NETWORK_MODE,
492                         preferredNetworkMode );
493             //Set the Modem
494             mPhone.setPreferredNetworkType(preferredNetworkMode,
495                     this.obtainMessage(MyHandler.MESSAGE_SET_PREFERRED_NETWORK_TYPE));
496         }
497     }
498 
UpdatePreferredNetworkModeSummary(int NetworkMode)499     private void UpdatePreferredNetworkModeSummary(int NetworkMode) {
500         switch(NetworkMode) {
501             case Phone.NT_MODE_WCDMA_PREF:
502                 mButtonPreferredNetworkMode.setSummary(
503                         R.string.preferred_network_mode_wcdma_perf_summary);
504                 break;
505             case Phone.NT_MODE_GSM_ONLY:
506                 mButtonPreferredNetworkMode.setSummary(
507                         R.string.preferred_network_mode_gsm_only_summary);
508                 break;
509             case Phone.NT_MODE_WCDMA_ONLY:
510                 mButtonPreferredNetworkMode.setSummary(
511                         R.string.preferred_network_mode_wcdma_only_summary);
512                 break;
513             case Phone.NT_MODE_GSM_UMTS:
514                 mButtonPreferredNetworkMode.setSummary(
515                         R.string.preferred_network_mode_gsm_wcdma_summary);
516                 break;
517             case Phone.NT_MODE_CDMA:
518                 switch (mPhone.getLteOnCdmaMode()) {
519                     case Phone.LTE_ON_CDMA_TRUE:
520                         mButtonPreferredNetworkMode.setSummary(
521                             R.string.preferred_network_mode_cdma_summary);
522                     break;
523                     case Phone.LTE_ON_CDMA_FALSE:
524                     default:
525                         mButtonPreferredNetworkMode.setSummary(
526                             R.string.preferred_network_mode_cdma_evdo_summary);
527                         break;
528                 }
529                 break;
530             case Phone.NT_MODE_CDMA_NO_EVDO:
531                 mButtonPreferredNetworkMode.setSummary(
532                         R.string.preferred_network_mode_cdma_only_summary);
533                 break;
534             case Phone.NT_MODE_EVDO_NO_CDMA:
535                 mButtonPreferredNetworkMode.setSummary(
536                         R.string.preferred_network_mode_evdo_only_summary);
537                 break;
538             case Phone.NT_MODE_GLOBAL:
539             default:
540                 mButtonPreferredNetworkMode.setSummary(
541                         R.string.preferred_network_mode_lte_cdma_summary);
542         }
543     }
544 
545     @Override
onActivityResult(int requestCode, int resultCode, Intent data)546     protected void onActivityResult(int requestCode, int resultCode, Intent data) {
547         switch(requestCode) {
548         case REQUEST_CODE_EXIT_ECM:
549             Boolean isChoiceYes =
550                 data.getBooleanExtra(EmergencyCallbackModeExitDialog.EXTRA_EXIT_ECM_RESULT, false);
551             if (isChoiceYes) {
552                 // If the phone exits from ECM mode, show the CDMA Options
553                 mCdmaOptions.showDialog(mClickedPreference);
554             } else {
555                 // do nothing
556             }
557             break;
558 
559         default:
560             break;
561         }
562     }
563 
log(String msg)564     private static void log(String msg) {
565         Log.d(LOG_TAG, msg);
566     }
567 
568     @Override
onOptionsItemSelected(MenuItem item)569     public boolean onOptionsItemSelected(MenuItem item) {
570         final int itemId = item.getItemId();
571         if (itemId == android.R.id.home) {  // See ActionBar#setDisplayHomeAsUpEnabled()
572             // Commenting out "logical up" capability. This is a workaround for issue 5278083.
573             //
574             // Settings app may not launch this activity via UP_ACTIVITY_CLASS but the other
575             // Activity that looks exactly same as UP_ACTIVITY_CLASS ("SubSettings" Activity).
576             // At that moment, this Activity launches UP_ACTIVITY_CLASS on top of the Activity.
577             // which confuses users.
578             // TODO: introduce better mechanism for "up" capability here.
579             /*Intent intent = new Intent(Intent.ACTION_MAIN);
580             intent.setClassName(UP_ACTIVITY_PACKAGE, UP_ACTIVITY_CLASS);
581             intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
582             startActivity(intent);*/
583             finish();
584             return true;
585         }
586         return super.onOptionsItemSelected(item);
587     }
588 }
589