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 * 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 */ 61 public 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. onClick(DialogInterface dialog, int which)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 onDismiss(DialogInterface dialog)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 onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference)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 onCreate(Bundle icicle)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 onResume()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 onPause()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 */ onPreferenceChange(Preference preference, Object objValue)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 handleMessage(Message msg)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 handleGetPreferredNetworkTypeResponse(Message msg)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 handleSetPreferredNetworkTypeResponse(Message msg)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 resetNetworkModeToDefault()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 UpdatePreferredNetworkModeSummary(int NetworkMode)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 onActivityResult(int requestCode, int resultCode, Intent data)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 log(String msg)567 private static void log(String msg) { 568 Log.d(LOG_TAG, msg); 569 } 570 571 @Override onOptionsItemSelected(MenuItem item)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