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