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