Home | History | Annotate | Download | only in phone 
      1 /*
      2  * Copyright (C) 2006 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 package com.android.phone;
     18 
     19 import android.app.AlertDialog;
     20 import android.content.Context;
     21 import android.content.DialogInterface;
     22 import android.content.Intent;
     23 import android.net.ConnectivityManager;
     24 import android.net.ThrottleManager;
     25 import android.os.AsyncResult;
     26 import android.os.Bundle;
     27 import android.os.Handler;
     28 import android.os.Message;
     29 import android.os.SystemProperties;
     30 import android.preference.CheckBoxPreference;
     31 import android.preference.ListPreference;
     32 import android.preference.Preference;
     33 import android.preference.PreferenceActivity;
     34 import android.preference.PreferenceScreen;
     35 import android.util.Log;
     36 
     37 import com.android.internal.telephony.Phone;
     38 import com.android.internal.telephony.PhoneFactory;
     39 import com.android.internal.telephony.TelephonyIntents;
     40 import com.android.internal.telephony.TelephonyProperties;
     41 
     42 /**
     43  * List of Phone-specific settings screens.
     44  */
     45 public class Settings extends PreferenceActivity implements DialogInterface.OnClickListener,
     46         DialogInterface.OnDismissListener, Preference.OnPreferenceChangeListener{
     47 
     48     // debug data
     49     private static final String LOG_TAG = "NetworkSettings";
     50     private static final boolean DBG = true;
     51     public static final int REQUEST_CODE_EXIT_ECM = 17;
     52 
     53     //String keys for preference lookup
     54     private static final String BUTTON_DATA_ENABLED_KEY = "button_data_enabled_key";
     55     private static final String BUTTON_DATA_USAGE_KEY = "button_data_usage_key";
     56     private static final String BUTTON_PREFERED_NETWORK_MODE = "preferred_network_mode_key";
     57     private static final String BUTTON_ROAMING_KEY = "button_roaming_key";
     58 
     59     static final int preferredNetworkMode = Phone.PREFERRED_NT_MODE;
     60 
     61     //UI objects
     62     private ListPreference mButtonPreferredNetworkMode;
     63     private CheckBoxPreference mButtonDataRoam;
     64     private CheckBoxPreference mButtonDataEnabled;
     65 
     66     private Preference mButtonDataUsage;
     67     private DataUsageListener mDataUsageListener;
     68     private static final String iface = "rmnet0"; //TODO: this will go away
     69 
     70     private Phone mPhone;
     71     private MyHandler mHandler;
     72     private boolean mOkClicked;
     73 
     74     //GsmUmts options and Cdma options
     75     GsmUmtsOptions mGsmUmtsOptions;
     76     CdmaOptions mCdmaOptions;
     77 
     78     private Preference mClickedPreference;
     79 
     80 
     81     //This is a method implemented for DialogInterface.OnClickListener.
     82     //  Used to dismiss the dialogs when they come up.
     83     public void onClick(DialogInterface dialog, int which) {
     84         if (which == DialogInterface.BUTTON_POSITIVE) {
     85             mPhone.setDataRoamingEnabled(true);
     86             mOkClicked = true;
     87         } else {
     88             // Reset the toggle
     89             mButtonDataRoam.setChecked(false);
     90         }
     91     }
     92 
     93     public void onDismiss(DialogInterface dialog) {
     94         // Assuming that onClick gets called first
     95         if (!mOkClicked) {
     96             mButtonDataRoam.setChecked(false);
     97         }
     98     }
     99 
    100     /**
    101      * Invoked on each preference click in this hierarchy, overrides
    102      * PreferenceActivity's implementation.  Used to make sure we track the
    103      * preference click events.
    104      */
    105     @Override
    106     public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference) {
    107         /** TODO: Refactor and get rid of the if's using subclasses */
    108         if (mGsmUmtsOptions != null &&
    109                 mGsmUmtsOptions.preferenceTreeClick(preference) == true) {
    110             return true;
    111         } else if (mCdmaOptions != null &&
    112                    mCdmaOptions.preferenceTreeClick(preference) == true) {
    113             if (Boolean.parseBoolean(
    114                     SystemProperties.get(TelephonyProperties.PROPERTY_INECM_MODE))) {
    115 
    116                 mClickedPreference = preference;
    117 
    118                 // In ECM mode launch ECM app dialog
    119                 startActivityForResult(
    120                     new Intent(TelephonyIntents.ACTION_SHOW_NOTICE_ECM_BLOCK_OTHERS, null),
    121                     REQUEST_CODE_EXIT_ECM);
    122             }
    123             return true;
    124         } else if (preference == mButtonPreferredNetworkMode) {
    125             //displays the value taken from the Settings.System
    126             int settingsNetworkMode = android.provider.Settings.Secure.getInt(mPhone.getContext().
    127                     getContentResolver(), android.provider.Settings.Secure.PREFERRED_NETWORK_MODE,
    128                     preferredNetworkMode);
    129             mButtonPreferredNetworkMode.setValue(Integer.toString(settingsNetworkMode));
    130             return true;
    131         } else if (preference == mButtonDataRoam) {
    132             if (DBG) log("onPreferenceTreeClick: preference == mButtonDataRoam.");
    133 
    134             //normally called on the toggle click
    135             if (mButtonDataRoam.isChecked()) {
    136                 // First confirm with a warning dialog about charges
    137                 mOkClicked = false;
    138                 new AlertDialog.Builder(this).setMessage(
    139                         getResources().getString(R.string.roaming_warning))
    140                         .setTitle(android.R.string.dialog_alert_title)
    141                         .setIcon(android.R.drawable.ic_dialog_alert)
    142                         .setPositiveButton(android.R.string.yes, this)
    143                         .setNegativeButton(android.R.string.no, this)
    144                         .show()
    145                         .setOnDismissListener(this);
    146             } else {
    147                 mPhone.setDataRoamingEnabled(false);
    148             }
    149             return true;
    150         } else if (preference == mButtonDataEnabled) {
    151             if (DBG) log("onPreferenceTreeClick: preference == mButtonDataEnabled.");
    152             ConnectivityManager cm =
    153                     (ConnectivityManager)getSystemService(Context.CONNECTIVITY_SERVICE);
    154 
    155             cm.setMobileDataEnabled(mButtonDataEnabled.isChecked());
    156             return true;
    157         } else {
    158             // if the button is anything but the simple toggle preference,
    159             // we'll need to disable all preferences to reject all click
    160             // events until the sub-activity's UI comes up.
    161             preferenceScreen.setEnabled(false);
    162             // Let the intents be launched by the Preference manager
    163             return false;
    164         }
    165     }
    166 
    167     @Override
    168     protected void onCreate(Bundle icicle) {
    169         super.onCreate(icicle);
    170 
    171         addPreferencesFromResource(R.xml.network_setting);
    172 
    173         mPhone = PhoneFactory.getDefaultPhone();
    174         mHandler = new MyHandler();
    175 
    176         //get UI object references
    177         PreferenceScreen prefSet = getPreferenceScreen();
    178 
    179         mButtonDataEnabled = (CheckBoxPreference) prefSet.findPreference(BUTTON_DATA_ENABLED_KEY);
    180         mButtonDataRoam = (CheckBoxPreference) prefSet.findPreference(BUTTON_ROAMING_KEY);
    181         mButtonPreferredNetworkMode = (ListPreference) prefSet.findPreference(
    182                 BUTTON_PREFERED_NETWORK_MODE);
    183         mButtonDataUsage = prefSet.findPreference(BUTTON_DATA_USAGE_KEY);
    184 
    185         if (getResources().getBoolean(R.bool.world_phone) == true) {
    186             // set the listener for the mButtonPreferredNetworkMode list preference so we can issue
    187             // change Preferred Network Mode.
    188             mButtonPreferredNetworkMode.setOnPreferenceChangeListener(this);
    189 
    190             //Get the networkMode from Settings.System and displays it
    191             int settingsNetworkMode = android.provider.Settings.Secure.getInt(mPhone.getContext().
    192                     getContentResolver(),android.provider.Settings.Secure.PREFERRED_NETWORK_MODE,
    193                     preferredNetworkMode);
    194             mButtonPreferredNetworkMode.setValue(Integer.toString(settingsNetworkMode));
    195             mCdmaOptions = new CdmaOptions(this, prefSet);
    196             mGsmUmtsOptions = new GsmUmtsOptions(this, prefSet);
    197         } else {
    198             prefSet.removePreference(mButtonPreferredNetworkMode);
    199             int phoneType = mPhone.getPhoneType();
    200             if (phoneType == Phone.PHONE_TYPE_CDMA) {
    201                 mCdmaOptions = new CdmaOptions(this, prefSet);
    202             } else if (phoneType == Phone.PHONE_TYPE_GSM) {
    203                 mGsmUmtsOptions = new GsmUmtsOptions(this, prefSet);
    204             } else {
    205                 throw new IllegalStateException("Unexpected phone type: " + phoneType);
    206             }
    207         }
    208         ThrottleManager tm = (ThrottleManager) getSystemService(Context.THROTTLE_SERVICE);
    209         mDataUsageListener = new DataUsageListener(this, mButtonDataUsage, prefSet);
    210     }
    211 
    212     @Override
    213     protected void onResume() {
    214         super.onResume();
    215 
    216         // upon resumption from the sub-activity, make sure we re-enable the
    217         // preferences.
    218         getPreferenceScreen().setEnabled(true);
    219 
    220         ConnectivityManager cm =
    221                 (ConnectivityManager)getSystemService(Context.CONNECTIVITY_SERVICE);
    222         mButtonDataEnabled.setChecked(cm.getMobileDataEnabled());
    223 
    224         // Set UI state in onResume because a user could go home, launch some
    225         // app to change this setting's backend, and re-launch this settings app
    226         // and the UI state would be inconsistent with actual state
    227         mButtonDataRoam.setChecked(mPhone.getDataRoamingEnabled());
    228 
    229         if (getPreferenceScreen().findPreference(BUTTON_PREFERED_NETWORK_MODE) != null)  {
    230             mPhone.getPreferredNetworkType(mHandler.obtainMessage(
    231                     MyHandler.MESSAGE_GET_PREFERRED_NETWORK_TYPE));
    232         }
    233         mDataUsageListener.resume();
    234     }
    235 
    236     @Override
    237     protected void onPause() {
    238         super.onPause();
    239         mDataUsageListener.pause();
    240     }
    241 
    242     /**
    243      * Implemented to support onPreferenceChangeListener to look for preference
    244      * changes specifically on CLIR.
    245      *
    246      * @param preference is the preference to be changed, should be mButtonCLIR.
    247      * @param objValue should be the value of the selection, NOT its localized
    248      * display value.
    249      */
    250     public boolean onPreferenceChange(Preference preference, Object objValue) {
    251         if (preference == mButtonPreferredNetworkMode) {
    252             //NOTE onPreferenceChange seems to be called even if there is no change
    253             //Check if the button value is changed from the System.Setting
    254             mButtonPreferredNetworkMode.setValue((String) objValue);
    255             int buttonNetworkMode;
    256             buttonNetworkMode = Integer.valueOf((String) objValue).intValue();
    257             int settingsNetworkMode = android.provider.Settings.Secure.getInt(
    258                     mPhone.getContext().getContentResolver(),
    259                     android.provider.Settings.Secure.PREFERRED_NETWORK_MODE, preferredNetworkMode);
    260             if (buttonNetworkMode != settingsNetworkMode) {
    261                 int modemNetworkMode;
    262                 switch(buttonNetworkMode) {
    263                     case Phone.NT_MODE_GLOBAL:
    264                         modemNetworkMode = Phone.NT_MODE_GLOBAL;
    265                         break;
    266                     case Phone.NT_MODE_EVDO_NO_CDMA:
    267                         modemNetworkMode = Phone.NT_MODE_EVDO_NO_CDMA;
    268                         break;
    269                     case Phone.NT_MODE_CDMA_NO_EVDO:
    270                         modemNetworkMode = Phone.NT_MODE_CDMA_NO_EVDO;
    271                         break;
    272                     case Phone.NT_MODE_CDMA:
    273                         modemNetworkMode = Phone.NT_MODE_CDMA;
    274                         break;
    275                     case Phone.NT_MODE_GSM_UMTS:
    276                         modemNetworkMode = Phone.NT_MODE_GSM_UMTS;
    277                         break;
    278                     case Phone.NT_MODE_WCDMA_ONLY:
    279                         modemNetworkMode = Phone.NT_MODE_WCDMA_ONLY;
    280                         break;
    281                     case Phone.NT_MODE_GSM_ONLY:
    282                         modemNetworkMode = Phone.NT_MODE_GSM_ONLY;
    283                         break;
    284                     case Phone.NT_MODE_WCDMA_PREF:
    285                         modemNetworkMode = Phone.NT_MODE_WCDMA_PREF;
    286                         break;
    287                     default:
    288                         modemNetworkMode = Phone.PREFERRED_NT_MODE;
    289                 }
    290                 UpdatePreferredNetworkModeSummary(buttonNetworkMode);
    291 
    292                 android.provider.Settings.Secure.putInt(mPhone.getContext().getContentResolver(),
    293                         android.provider.Settings.Secure.PREFERRED_NETWORK_MODE,
    294                         buttonNetworkMode );
    295                 //Set the modem network mode
    296                 mPhone.setPreferredNetworkType(modemNetworkMode, mHandler
    297                         .obtainMessage(MyHandler.MESSAGE_SET_PREFERRED_NETWORK_TYPE));
    298             }
    299         }
    300 
    301         // always let the preference setting proceed.
    302         return true;
    303     }
    304 
    305     private class MyHandler extends Handler {
    306 
    307         private static final int MESSAGE_GET_PREFERRED_NETWORK_TYPE = 0;
    308         private static final int MESSAGE_SET_PREFERRED_NETWORK_TYPE = 1;
    309 
    310         @Override
    311         public void handleMessage(Message msg) {
    312             switch (msg.what) {
    313                 case MESSAGE_GET_PREFERRED_NETWORK_TYPE:
    314                     handleGetPreferredNetworkTypeResponse(msg);
    315                     break;
    316 
    317                 case MESSAGE_SET_PREFERRED_NETWORK_TYPE:
    318                     handleSetPreferredNetworkTypeResponse(msg);
    319                     break;
    320             }
    321         }
    322 
    323         private void handleGetPreferredNetworkTypeResponse(Message msg) {
    324             AsyncResult ar = (AsyncResult) msg.obj;
    325 
    326             if (ar.exception == null) {
    327                 int modemNetworkMode = ((int[])ar.result)[0];
    328 
    329                 if (DBG) {
    330                     log ("handleGetPreferredNetworkTypeResponse: modemNetworkMode = " +
    331                             modemNetworkMode);
    332                 }
    333 
    334                 int settingsNetworkMode = android.provider.Settings.Secure.getInt(
    335                         mPhone.getContext().getContentResolver(),
    336                         android.provider.Settings.Secure.PREFERRED_NETWORK_MODE,
    337                         preferredNetworkMode);
    338 
    339                 if (DBG) {
    340                     log("handleGetPreferredNetworkTypeReponse: settingsNetworkMode = " +
    341                             settingsNetworkMode);
    342                 }
    343 
    344                 //check that modemNetworkMode is from an accepted value
    345                 if (modemNetworkMode == Phone.NT_MODE_WCDMA_PREF ||
    346                         modemNetworkMode == Phone.NT_MODE_GSM_ONLY ||
    347                         modemNetworkMode == Phone.NT_MODE_WCDMA_ONLY ||
    348                         modemNetworkMode == Phone.NT_MODE_GSM_UMTS ||
    349                         modemNetworkMode == Phone.NT_MODE_CDMA ||
    350                         modemNetworkMode == Phone.NT_MODE_CDMA_NO_EVDO ||
    351                         modemNetworkMode == Phone.NT_MODE_EVDO_NO_CDMA ||
    352                         modemNetworkMode == Phone.NT_MODE_GLOBAL ) {
    353                     if (DBG) {
    354                         log("handleGetPreferredNetworkTypeResponse: if 1: modemNetworkMode = " +
    355                                 modemNetworkMode);
    356                     }
    357 
    358                     //check changes in modemNetworkMode and updates settingsNetworkMode
    359                     if (modemNetworkMode != settingsNetworkMode) {
    360                         if (DBG) {
    361                             log("handleGetPreferredNetworkTypeResponse: if 2: " +
    362                                     "modemNetworkMode != settingsNetworkMode");
    363                         }
    364 
    365                         settingsNetworkMode = modemNetworkMode;
    366 
    367                         if (DBG) { log("handleGetPreferredNetworkTypeResponse: if 2: " +
    368                                 "settingsNetworkMode = " + settingsNetworkMode);
    369                         }
    370 
    371                         //changes the Settings.System accordingly to modemNetworkMode
    372                         android.provider.Settings.Secure.putInt(
    373                                 mPhone.getContext().getContentResolver(),
    374                                 android.provider.Settings.Secure.PREFERRED_NETWORK_MODE,
    375                                 settingsNetworkMode );
    376                     }
    377 
    378                     UpdatePreferredNetworkModeSummary(modemNetworkMode);
    379                     // changes the mButtonPreferredNetworkMode accordingly to modemNetworkMode
    380                     mButtonPreferredNetworkMode.setValue(Integer.toString(modemNetworkMode));
    381                 } else {
    382                     if (DBG) log("handleGetPreferredNetworkTypeResponse: else: reset to default");
    383                     resetNetworkModeToDefault();
    384                 }
    385             }
    386         }
    387 
    388         private void handleSetPreferredNetworkTypeResponse(Message msg) {
    389             AsyncResult ar = (AsyncResult) msg.obj;
    390 
    391             if (ar.exception == null) {
    392                 int networkMode = Integer.valueOf(
    393                         mButtonPreferredNetworkMode.getValue()).intValue();
    394                 android.provider.Settings.Secure.putInt(mPhone.getContext().getContentResolver(),
    395                         android.provider.Settings.Secure.PREFERRED_NETWORK_MODE,
    396                         networkMode );
    397             } else {
    398                 mPhone.getPreferredNetworkType(obtainMessage(MESSAGE_GET_PREFERRED_NETWORK_TYPE));
    399             }
    400         }
    401 
    402         private void resetNetworkModeToDefault() {
    403             //set the mButtonPreferredNetworkMode
    404             mButtonPreferredNetworkMode.setValue(Integer.toString(preferredNetworkMode));
    405             //set the Settings.System
    406             android.provider.Settings.Secure.putInt(mPhone.getContext().getContentResolver(),
    407                         android.provider.Settings.Secure.PREFERRED_NETWORK_MODE,
    408                         preferredNetworkMode );
    409             //Set the Modem
    410             mPhone.setPreferredNetworkType(preferredNetworkMode,
    411                     this.obtainMessage(MyHandler.MESSAGE_SET_PREFERRED_NETWORK_TYPE));
    412         }
    413     }
    414 
    415     private void UpdatePreferredNetworkModeSummary(int NetworkMode) {
    416         switch(NetworkMode) {
    417             case Phone.NT_MODE_WCDMA_PREF:
    418                 // TODO T: Make all of these strings come from res/values/strings.xml.
    419                 mButtonPreferredNetworkMode.setSummary("Preferred network mode: WCDMA pref");
    420                 break;
    421             case Phone.NT_MODE_GSM_ONLY:
    422                 mButtonPreferredNetworkMode.setSummary("Preferred network mode: GSM only");
    423                 break;
    424             case Phone.NT_MODE_WCDMA_ONLY:
    425                 mButtonPreferredNetworkMode.setSummary("Preferred network mode: WCDMA only");
    426                 break;
    427             case Phone.NT_MODE_GSM_UMTS:
    428                 mButtonPreferredNetworkMode.setSummary("Preferred network mode: GSM/WCDMA");
    429                 break;
    430             case Phone.NT_MODE_CDMA:
    431                 mButtonPreferredNetworkMode.setSummary("Preferred network mode: CDMA / EvDo");
    432                 break;
    433             case Phone.NT_MODE_CDMA_NO_EVDO:
    434                 mButtonPreferredNetworkMode.setSummary("Preferred network mode: CDMA only");
    435                 break;
    436             case Phone.NT_MODE_EVDO_NO_CDMA:
    437                 mButtonPreferredNetworkMode.setSummary("Preferred network mode: EvDo only");
    438                 break;
    439             case Phone.NT_MODE_GLOBAL:
    440             default:
    441                 mButtonPreferredNetworkMode.setSummary("Preferred network mode: Global");
    442         }
    443     }
    444 
    445     @Override
    446     protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    447         switch(requestCode) {
    448         case REQUEST_CODE_EXIT_ECM:
    449             Boolean isChoiceYes =
    450                 data.getBooleanExtra(EmergencyCallbackModeExitDialog.EXTRA_EXIT_ECM_RESULT, false);
    451             if (isChoiceYes) {
    452                 // If the phone exits from ECM mode, show the CDMA Options
    453                 mCdmaOptions.showDialog(mClickedPreference);
    454             } else {
    455                 // do nothing
    456             }
    457             break;
    458 
    459         default:
    460             break;
    461         }
    462     }
    463 
    464     private static void log(String msg) {
    465         Log.d(LOG_TAG, msg);
    466     }
    467 }
    468