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