1 /** 2 * Copyright (C) 2014 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.settings; 18 19 import android.app.Dialog; 20 import android.content.ContentProvider; 21 import android.content.DialogInterface; 22 import android.content.Intent; 23 import android.database.Cursor; 24 import android.os.AsyncResult; 25 import android.os.Bundle; 26 import android.os.Handler; 27 import android.os.Message; 28 import android.os.PersistableBundle; 29 import android.os.Process; 30 import android.os.UserHandle; 31 import android.os.UserManager; 32 import android.preference.Preference; 33 import android.preference.PreferenceActivity; 34 import android.preference.PreferenceScreen; 35 import android.provider.ContactsContract.CommonDataKinds; 36 import android.provider.Settings; 37 import android.telecom.PhoneAccountHandle; 38 import android.telephony.CarrierConfigManager; 39 import android.telephony.TelephonyManager; 40 import android.text.BidiFormatter; 41 import android.text.TextDirectionHeuristics; 42 import android.text.TextUtils; 43 import android.util.Log; 44 import android.view.MenuItem; 45 import android.widget.ListAdapter; 46 import android.widget.Toast; 47 48 import com.android.internal.telephony.CallForwardInfo; 49 import com.android.internal.telephony.CommandsInterface; 50 import com.android.internal.telephony.Phone; 51 import com.android.internal.telephony.PhoneConstants; 52 import com.android.internal.telephony.flags.Flags; 53 import com.android.internal.telephony.util.NotificationChannelController; 54 import com.android.phone.EditPhoneNumberPreference; 55 import com.android.phone.PhoneGlobals; 56 import com.android.phone.PhoneUtils; 57 import com.android.phone.R; 58 import com.android.phone.SubscriptionInfoHelper; 59 60 import java.util.Collection; 61 import java.util.HashMap; 62 import java.util.HashSet; 63 import java.util.Iterator; 64 import java.util.Map; 65 66 public class VoicemailSettingsActivity extends PreferenceActivity 67 implements DialogInterface.OnClickListener, 68 Preference.OnPreferenceChangeListener, 69 EditPhoneNumberPreference.OnDialogClosedListener, 70 EditPhoneNumberPreference.GetDefaultNumberListener{ 71 private static final String LOG_TAG = VoicemailSettingsActivity.class.getSimpleName(); 72 private static final boolean DBG = (PhoneGlobals.DBG_LEVEL >= 2); 73 74 /** 75 * Intent action to bring up Voicemail Provider settings 76 * DO NOT RENAME. There are existing apps which use this intent value. 77 */ 78 public static final String ACTION_ADD_VOICEMAIL = 79 "com.android.phone.CallFeaturesSetting.ADD_VOICEMAIL"; 80 81 /** 82 * Intent action to bring up the {@code VoicemailSettingsActivity}. 83 * DO NOT RENAME. There are existing apps which use this intent value. 84 */ 85 public static final String ACTION_CONFIGURE_VOICEMAIL = 86 "com.android.phone.CallFeaturesSetting.CONFIGURE_VOICEMAIL"; 87 88 // Extra put in the return from VM provider config containing voicemail number to set 89 public static final String VM_NUMBER_EXTRA = "com.android.phone.VoicemailNumber"; 90 // Extra put in the return from VM provider config containing call forwarding number to set 91 public static final String FWD_NUMBER_EXTRA = "com.android.phone.ForwardingNumber"; 92 // Extra put in the return from VM provider config containing call forwarding number to set 93 public static final String FWD_NUMBER_TIME_EXTRA = "com.android.phone.ForwardingNumberTime"; 94 // If the VM provider returns non null value in this extra we will force the user to 95 // choose another VM provider 96 public static final String SIGNOUT_EXTRA = "com.android.phone.Signout"; 97 98 /** 99 * String Extra put into ACTION_ADD_VOICEMAIL call to indicate which provider should be hidden 100 * in the list of providers presented to the user. This allows a provider which is being 101 * disabled (e.g. GV user logging out) to force the user to pick some other provider. 102 */ 103 public static final String IGNORE_PROVIDER_EXTRA = "com.android.phone.ProviderToIgnore"; 104 105 /** 106 * String Extra put into ACTION_ADD_VOICEMAIL to indicate that the voicemail setup screen should 107 * be opened. 108 */ 109 public static final String SETUP_VOICEMAIL_EXTRA = "com.android.phone.SetupVoicemail"; 110 111 // TODO: Define these preference keys in XML. 112 private static final String BUTTON_VOICEMAIL_KEY = "button_voicemail_key"; 113 private static final String BUTTON_VOICEMAIL_PROVIDER_KEY = "button_voicemail_provider_key"; 114 private static final String BUTTON_VOICEMAIL_SETTING_KEY = "button_voicemail_setting_key"; 115 116 /** Event for Async voicemail change call */ 117 private static final int EVENT_VOICEMAIL_CHANGED = 500; 118 private static final int EVENT_FORWARDING_CHANGED = 501; 119 private static final int EVENT_FORWARDING_GET_COMPLETED = 502; 120 121 /** Handle to voicemail pref */ 122 private static final int VOICEMAIL_PREF_ID = 1; 123 private static final int VOICEMAIL_PROVIDER_CFG_ID = 2; 124 125 /** 126 * Results of reading forwarding settings 127 */ 128 private CallForwardInfo[] mForwardingReadResults = null; 129 130 /** 131 * Result of forwarding number change. 132 * Keys are reasons (eg. unconditional forwarding). 133 */ 134 private Map<Integer, AsyncResult> mForwardingChangeResults = null; 135 136 /** 137 * Expected CF read result types. 138 * This set keeps track of the CF types for which we've issued change 139 * commands so we can tell when we've received all of the responses. 140 */ 141 private Collection<Integer> mExpectedChangeResultReasons = null; 142 143 /** 144 * Result of vm number change 145 */ 146 private AsyncResult mVoicemailChangeResult = null; 147 148 /** 149 * Previous VM provider setting so we can return to it in case of failure. 150 */ 151 private String mPreviousVMProviderKey = null; 152 153 /** 154 * Id of the dialog being currently shown. 155 */ 156 private int mCurrentDialogId = 0; 157 158 /** 159 * Flag indicating that we are invoking settings for the voicemail provider programmatically 160 * due to vm provider change. 161 */ 162 private boolean mVMProviderSettingsForced = false; 163 164 /** 165 * Flag indicating that we are making changes to vm or fwd numbers 166 * due to vm provider change. 167 */ 168 private boolean mChangingVMorFwdDueToProviderChange = false; 169 170 /** 171 * True if we are in the process of vm & fwd number change and vm has already been changed. 172 * This is used to decide what to do in case of rollback. 173 */ 174 private boolean mVMChangeCompletedSuccessfully = false; 175 176 /** 177 * True if we had full or partial failure setting forwarding numbers and so need to roll them 178 * back. 179 */ 180 private boolean mFwdChangesRequireRollback = false; 181 182 /** 183 * Id of error msg to display to user once we are done reverting the VM provider to the previous 184 * one. 185 */ 186 private int mVMOrFwdSetError = 0; 187 188 /** string to hold old voicemail number as it is being updated. */ 189 private String mOldVmNumber; 190 191 // New call forwarding settings and vm number we will be setting 192 // Need to save these since before we get to saving we need to asynchronously 193 // query the existing forwarding settings. 194 private CallForwardInfo[] mNewFwdSettings; 195 private String mNewVMNumber; 196 197 /** 198 * Used to indicate that the voicemail preference should be shown. 199 */ 200 private boolean mShowVoicemailPreference = false; 201 202 private boolean mForeground; 203 private boolean mDisallowedConfig = false; 204 private Phone mPhone; 205 private SubscriptionInfoHelper mSubscriptionInfoHelper; 206 207 private EditPhoneNumberPreference mSubMenuVoicemailSettings = null; 208 private VoicemailProviderListPreference mVoicemailProviders; 209 private PreferenceScreen mVoicemailSettings; 210 private Preference mVoicemailNotificationPreference; 211 212 //********************************************************************************************* 213 // Preference Activity Methods 214 //********************************************************************************************* 215 216 @Override onCreate(Bundle icicle)217 protected void onCreate(Bundle icicle) { 218 super.onCreate(icicle); 219 getWindow().addSystemFlags( 220 android.view.WindowManager.LayoutParams 221 .SYSTEM_FLAG_HIDE_NON_SYSTEM_OVERLAY_WINDOWS); 222 // Make sure we are running as the primary user only 223 UserManager userManager = getApplicationContext().getSystemService(UserManager.class); 224 if (!userManager.isPrimaryUser()) { 225 Toast.makeText(this, R.string.voice_number_setting_primary_user_only, 226 Toast.LENGTH_SHORT).show(); 227 finish(); 228 return; 229 } 230 231 // Check if mobile network configs are restricted. 232 if (Flags.ensureAccessToCallSettingsIsRestricted() && 233 userManager.hasUserRestriction(UserManager.DISALLOW_CONFIG_MOBILE_NETWORKS)) { 234 mDisallowedConfig = true; 235 Log.i(LOG_TAG, "Mobile network configs are restricted, disabling voicemail " 236 + "settings"); 237 } 238 239 // Show the voicemail preference in onResume if the calling intent specifies the 240 // ACTION_ADD_VOICEMAIL action. 241 mShowVoicemailPreference = (icicle == null) && 242 TextUtils.equals(getIntent().getAction(), ACTION_ADD_VOICEMAIL); 243 244 PhoneAccountHandle phoneAccountHandle = (PhoneAccountHandle) 245 getIntent().getParcelableExtra(TelephonyManager.EXTRA_PHONE_ACCOUNT_HANDLE); 246 if (phoneAccountHandle != null) { 247 getIntent().putExtra(SubscriptionInfoHelper.SUB_ID_EXTRA, 248 PhoneUtils.getSubIdForPhoneAccountHandle(phoneAccountHandle)); 249 } 250 mSubscriptionInfoHelper = new SubscriptionInfoHelper(this, getIntent()); 251 mSubscriptionInfoHelper.setActionBarTitle( 252 getActionBar(), getResources(), R.string.voicemail_settings_with_label); 253 mPhone = mSubscriptionInfoHelper.getPhone(); 254 addPreferencesFromResource(R.xml.voicemail_settings); 255 256 mVoicemailNotificationPreference = 257 findPreference(getString(R.string.voicemail_notifications_key)); 258 if (mSubMenuVoicemailSettings == null) { 259 mSubMenuVoicemailSettings = 260 (EditPhoneNumberPreference) findPreference(BUTTON_VOICEMAIL_KEY); 261 } 262 final Intent intent = new Intent(Settings.ACTION_CHANNEL_NOTIFICATION_SETTINGS); 263 intent.putExtra(Settings.EXTRA_CHANNEL_ID, 264 NotificationChannelController.CHANNEL_ID_VOICE_MAIL); 265 intent.putExtra(Settings.EXTRA_APP_PACKAGE, mPhone.getContext().getPackageName()); 266 mVoicemailNotificationPreference.setIntent(intent); 267 268 SettingsConstants.setupEdgeToEdge(this); 269 } 270 271 @Override onResume()272 protected void onResume() { 273 super.onResume(); 274 mForeground = true; 275 276 if (mSubMenuVoicemailSettings != null) { 277 mSubMenuVoicemailSettings.setParentActivity(this, VOICEMAIL_PREF_ID, this); 278 mSubMenuVoicemailSettings.setDialogOnClosedListener(this); 279 mSubMenuVoicemailSettings.setDialogTitle(R.string.voicemail_settings_number_label); 280 if (!getBooleanCarrierConfig( 281 CarrierConfigManager.KEY_EDITABLE_VOICEMAIL_NUMBER_SETTING_BOOL) || 282 mDisallowedConfig) { 283 mSubMenuVoicemailSettings.setEnabled(false); 284 } 285 } 286 287 mVoicemailProviders = (VoicemailProviderListPreference) findPreference( 288 BUTTON_VOICEMAIL_PROVIDER_KEY); 289 mVoicemailProviders.init(mPhone, getIntent()); 290 mVoicemailProviders.setOnPreferenceChangeListener(this); 291 mPreviousVMProviderKey = mVoicemailProviders.getValue(); 292 293 mVoicemailSettings = (PreferenceScreen) findPreference(BUTTON_VOICEMAIL_SETTING_KEY); 294 // ���� the legacy PreferenceScreen displays a dialog in its onClick. Set a property on the 295 // PreferenceScreen to ensure that it will fit system windows to accommodate for edge to 296 // edge. 297 mVoicemailSettings.setDialogFitsSystemWindows(true); 298 299 maybeHidePublicSettings(); 300 301 updateVMPreferenceWidgets(mVoicemailProviders.getValue()); 302 303 // check the intent that started this activity and pop up the voicemail 304 // dialog if we've been asked to. 305 // If we have at least one non default VM provider registered then bring up 306 // the selection for the VM provider, otherwise bring up a VM number dialog. 307 // We only bring up the dialog the first time we are called (not after orientation change) 308 if (mShowVoicemailPreference) { 309 if (DBG) log("ACTION_ADD_VOICEMAIL Intent is thrown"); 310 if (mVoicemailProviders.hasMoreThanOneVoicemailProvider()) { 311 if (DBG) log("Voicemail data has more than one provider."); 312 simulatePreferenceClick(mVoicemailProviders); 313 } else { 314 onPreferenceChange(mVoicemailProviders, VoicemailProviderListPreference.DEFAULT_KEY); 315 mVoicemailProviders.setValue(VoicemailProviderListPreference.DEFAULT_KEY); 316 } 317 mShowVoicemailPreference = false; 318 } 319 320 updateVoiceNumberField(); 321 mVMProviderSettingsForced = false; 322 } 323 324 /** 325 * Hides a subset of voicemail settings if required by the intent extra. This is used by the 326 * default dialer to show "advanced" voicemail settings from its own custom voicemail settings 327 * UI. 328 */ maybeHidePublicSettings()329 private void maybeHidePublicSettings() { 330 if(!getIntent().getBooleanExtra(TelephonyManager.EXTRA_HIDE_PUBLIC_SETTINGS, false)){ 331 return; 332 } 333 if (DBG) { 334 log("maybeHidePublicSettings: settings hidden by EXTRA_HIDE_PUBLIC_SETTINGS"); 335 } 336 PreferenceScreen preferenceScreen = getPreferenceScreen(); 337 preferenceScreen.removePreference(mVoicemailNotificationPreference); 338 } 339 340 @Override onPause()341 public void onPause() { 342 super.onPause(); 343 mForeground = false; 344 } 345 346 @Override onOptionsItemSelected(MenuItem item)347 public boolean onOptionsItemSelected(MenuItem item) { 348 if (item.getItemId() == android.R.id.home) { 349 onBackPressed(); 350 return true; 351 } 352 return super.onOptionsItemSelected(item); 353 } 354 355 @Override onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference)356 public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference) { 357 if (preference == mSubMenuVoicemailSettings) { 358 return true; 359 } else if (preference.getKey().equals(mVoicemailSettings.getKey())) { 360 // Check key instead of comparing reference because closing the voicemail notification 361 // ringtone dialog invokes onResume(), but leaves the old preference screen up, 362 // TODO: Revert to checking reference after migrating voicemail to its own activity. 363 if (DBG) log("onPreferenceTreeClick: Voicemail Settings Preference is clicked."); 364 365 final Dialog dialog = ((PreferenceScreen) preference).getDialog(); 366 if (dialog != null) { 367 dialog.getActionBar().setDisplayHomeAsUpEnabled(false); 368 } 369 370 mSubMenuVoicemailSettings = 371 (EditPhoneNumberPreference) findPreference(BUTTON_VOICEMAIL_KEY); 372 mSubMenuVoicemailSettings.setParentActivity(this, VOICEMAIL_PREF_ID, this); 373 mSubMenuVoicemailSettings.setDialogOnClosedListener(this); 374 mSubMenuVoicemailSettings.setDialogTitle(R.string.voicemail_settings_number_label); 375 updateVoiceNumberField(); 376 377 if (preference.getIntent() != null) { 378 if (DBG) log("Invoking cfg intent " + preference.getIntent().getPackage()); 379 380 // onActivityResult() will be responsible for resetting some of variables. 381 this.startActivityForResult(preference.getIntent(), VOICEMAIL_PROVIDER_CFG_ID); 382 return true; 383 } else { 384 if (DBG) log("onPreferenceTreeClick(). No intent; use default behavior in xml."); 385 386 // onActivityResult() will not be called, so reset variables here. 387 mPreviousVMProviderKey = VoicemailProviderListPreference.DEFAULT_KEY; 388 mVMProviderSettingsForced = false; 389 return false; 390 } 391 } 392 return false; 393 } 394 395 /** 396 * Implemented to support onPreferenceChangeListener to look for preference changes. 397 * 398 * @param preference is the preference to be changed 399 * @param objValue should be the value of the selection, NOT its localized 400 * display value. 401 */ 402 @Override onPreferenceChange(Preference preference, Object objValue)403 public boolean onPreferenceChange(Preference preference, Object objValue) { 404 if (DBG) log("onPreferenceChange: \"" + preference + "\" changed to \"" + objValue + "\""); 405 406 if (preference == mVoicemailProviders) { 407 final String newProviderKey = (String) objValue; 408 409 // If previous provider key and the new one is same, we don't need to handle it. 410 if (mPreviousVMProviderKey.equals(newProviderKey)) { 411 if (DBG) log("No change is made to the VM provider setting."); 412 return true; 413 } 414 updateVMPreferenceWidgets(newProviderKey); 415 416 final VoicemailProviderSettings newProviderSettings = 417 VoicemailProviderSettingsUtil.load(this, newProviderKey); 418 419 // If the user switches to a voice mail provider and we have numbers stored for it we 420 // will automatically change the phone's voice mail and forwarding number to the stored 421 // ones. Otherwise we will bring up provider's configuration UI. 422 if (newProviderSettings == null) { 423 // Force the user into a configuration of the chosen provider 424 Log.w(LOG_TAG, "Saved preferences not found - invoking config"); 425 mVMProviderSettingsForced = true; 426 simulatePreferenceClick(mVoicemailSettings); 427 } else { 428 if (DBG) log("Saved preferences found - switching to them"); 429 // Set this flag so if we get a failure we revert to previous provider 430 mChangingVMorFwdDueToProviderChange = true; 431 saveVoiceMailAndForwardingNumber(newProviderKey, newProviderSettings); 432 } 433 } 434 // Always let the preference setting proceed. 435 return true; 436 } 437 438 /** 439 * Implemented for EditPhoneNumberPreference.GetDefaultNumberListener. 440 * This method set the default values for the various 441 * EditPhoneNumberPreference dialogs. 442 */ 443 @Override onGetDefaultNumber(EditPhoneNumberPreference preference)444 public String onGetDefaultNumber(EditPhoneNumberPreference preference) { 445 if (preference == mSubMenuVoicemailSettings) { 446 // update the voicemail number field, which takes care of the 447 // mSubMenuVoicemailSettings itself, so we should return null. 448 if (DBG) log("updating default for voicemail dialog"); 449 updateVoiceNumberField(); 450 return null; 451 } 452 453 String vmDisplay = mPhone.getVoiceMailNumber(); 454 if (TextUtils.isEmpty(vmDisplay)) { 455 // if there is no voicemail number, we just return null to 456 // indicate no contribution. 457 return null; 458 } 459 460 // Return the voicemail number prepended with "VM: " 461 if (DBG) log("updating default for call forwarding dialogs"); 462 return getString(R.string.voicemail_abbreviated) + " " + vmDisplay; 463 } 464 465 @Override onActivityResult(int requestCode, int resultCode, Intent data)466 protected void onActivityResult(int requestCode, int resultCode, Intent data) { 467 if (DBG) { 468 log("onActivityResult: requestCode: " + requestCode 469 + ", resultCode: " + resultCode 470 + ", data: " + data); 471 } 472 473 // there are cases where the contact picker may end up sending us more than one 474 // request. We want to ignore the request if we're not in the correct state. 475 if (requestCode == VOICEMAIL_PROVIDER_CFG_ID) { 476 boolean failure = false; 477 478 // No matter how the processing of result goes lets clear the flag 479 if (DBG) log("mVMProviderSettingsForced: " + mVMProviderSettingsForced); 480 final boolean isVMProviderSettingsForced = mVMProviderSettingsForced; 481 mVMProviderSettingsForced = false; 482 483 String vmNum = null; 484 if (resultCode != RESULT_OK) { 485 if (DBG) log("onActivityResult: vm provider cfg result not OK."); 486 failure = true; 487 } else { 488 if (data == null) { 489 if (DBG) log("onActivityResult: vm provider cfg result has no data"); 490 failure = true; 491 } else { 492 if (data.getBooleanExtra(SIGNOUT_EXTRA, false)) { 493 if (DBG) log("Provider requested signout"); 494 if (isVMProviderSettingsForced) { 495 if (DBG) log("Going back to previous provider on signout"); 496 switchToPreviousVoicemailProvider(); 497 } else { 498 final String victim = mVoicemailProviders.getKey(); 499 if (DBG) log("Relaunching activity and ignoring " + victim); 500 Intent i = new Intent(ACTION_ADD_VOICEMAIL); 501 i.putExtra(IGNORE_PROVIDER_EXTRA, victim); 502 i.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP); 503 this.startActivityAsUser(i, UserHandle.CURRENT); 504 } 505 return; 506 } 507 vmNum = data.getStringExtra(VM_NUMBER_EXTRA); 508 if (vmNum == null || vmNum.length() == 0) { 509 if (DBG) log("onActivityResult: vm provider cfg result has no vmnum"); 510 failure = true; 511 } 512 } 513 } 514 if (failure) { 515 if (DBG) log("Failure in return from voicemail provider."); 516 if (isVMProviderSettingsForced) { 517 switchToPreviousVoicemailProvider(); 518 } 519 520 return; 521 } 522 mChangingVMorFwdDueToProviderChange = isVMProviderSettingsForced; 523 final String fwdNum = data.getStringExtra(FWD_NUMBER_EXTRA); 524 525 // TODO: It would be nice to load the current network setting for this and 526 // send it to the provider when it's config is invoked so it can use this as default 527 final int fwdNumTime = data.getIntExtra(FWD_NUMBER_TIME_EXTRA, 20); 528 529 if (DBG) log("onActivityResult: cfg result has forwarding number " + fwdNum); 530 saveVoiceMailAndForwardingNumber(mVoicemailProviders.getKey(), 531 new VoicemailProviderSettings(vmNum, fwdNum, fwdNumTime)); 532 return; 533 } 534 535 if (requestCode == VOICEMAIL_PREF_ID) { 536 if (resultCode != RESULT_OK) { 537 if (DBG) log("onActivityResult: contact picker result not OK."); 538 return; 539 } 540 541 Cursor cursor = null; 542 try { 543 // check if the URI returned by the user belongs to the user 544 final int currentUser = UserHandle.getUserId(Process.myUid()); 545 if (currentUser 546 != ContentProvider.getUserIdFromUri(data.getData(), currentUser)) { 547 548 if (DBG) { 549 log("onActivityResult: Contact data of different user, " 550 + "cannot access"); 551 } 552 return; 553 } 554 cursor = getContentResolver().query(data.getData(), 555 new String[] { CommonDataKinds.Phone.NUMBER }, null, null, null); 556 if ((cursor == null) || (!cursor.moveToFirst())) { 557 if (DBG) log("onActivityResult: bad contact data, no results found."); 558 return; 559 } 560 if (mSubMenuVoicemailSettings != null) { 561 mSubMenuVoicemailSettings.onPickActivityResult(cursor.getString(0)); 562 } else { 563 Log.w(LOG_TAG, "VoicemailSettingsActivity destroyed while setting contacts."); 564 } 565 return; 566 } finally { 567 if (cursor != null) { 568 cursor.close(); 569 } 570 } 571 } 572 573 super.onActivityResult(requestCode, resultCode, data); 574 } 575 576 /** 577 * Simulates user clicking on a passed preference. 578 * Usually needed when the preference is a dialog preference and we want to invoke 579 * a dialog for this preference programmatically. 580 * TODO: figure out if there is a cleaner way to cause preference dlg to come up 581 */ simulatePreferenceClick(Preference preference)582 private void simulatePreferenceClick(Preference preference) { 583 // Go through settings until we find our setting 584 // and then simulate a click on it to bring up the dialog 585 final ListAdapter adapter = getPreferenceScreen().getRootAdapter(); 586 for (int idx = 0; idx < adapter.getCount(); idx++) { 587 if (adapter.getItem(idx) == preference) { 588 getPreferenceScreen().onItemClick(this.getListView(), 589 null, idx, adapter.getItemId(idx)); 590 break; 591 } 592 } 593 } 594 595 /** 596 * Get the boolean config from carrier config manager. 597 * 598 * @param key config key defined in CarrierConfigManager 599 * @return boolean value of corresponding key. 600 */ getBooleanCarrierConfig(String key)601 private boolean getBooleanCarrierConfig(String key) { 602 PersistableBundle b = PhoneGlobals.getInstance() 603 .getCarrierConfigForSubId(mPhone.getSubId()); 604 605 if (b == null) { 606 b = PhoneGlobals.getInstance().getCarrierConfig(); 607 } 608 609 return b.getBoolean(key); 610 } 611 612 613 //********************************************************************************************* 614 // Activity Dialog Methods 615 //********************************************************************************************* 616 617 @Override onPrepareDialog(int id, Dialog dialog)618 protected void onPrepareDialog(int id, Dialog dialog) { 619 super.onPrepareDialog(id, dialog); 620 mCurrentDialogId = id; 621 } 622 623 // dialog creation method, called by showDialog() 624 @Override onCreateDialog(int dialogId)625 protected Dialog onCreateDialog(int dialogId) { 626 return VoicemailDialogUtil.getDialog(this, dialogId); 627 } 628 629 @Override onDialogClosed(EditPhoneNumberPreference preference, int buttonClicked)630 public void onDialogClosed(EditPhoneNumberPreference preference, int buttonClicked) { 631 if (DBG) log("onDialogClosed: Button clicked is " + buttonClicked); 632 633 if (buttonClicked == DialogInterface.BUTTON_NEGATIVE) { 634 return; 635 } 636 637 if (preference == mSubMenuVoicemailSettings) { 638 VoicemailProviderSettings newSettings = new VoicemailProviderSettings( 639 mSubMenuVoicemailSettings.getPhoneNumber(), 640 VoicemailProviderSettings.NO_FORWARDING); 641 saveVoiceMailAndForwardingNumber(mVoicemailProviders.getKey(), newSettings); 642 } 643 } 644 645 /** 646 * Wrapper around showDialog() that will silently do nothing if we're 647 * not in the foreground. 648 * 649 * This is useful here because most of the dialogs we display from 650 * this class are triggered by asynchronous events (like 651 * success/failure messages from the telephony layer) and it's 652 * possible for those events to come in even after the user has gone 653 * to a different screen. 654 */ 655 // TODO: this is too brittle: it's still easy to accidentally add new 656 // code here that calls showDialog() directly (which will result in a 657 // WindowManager$BadTokenException if called after the activity has 658 // been stopped.) 659 // 660 // It would be cleaner to do the "if (mForeground)" check in one 661 // central place, maybe by using a single Handler for all asynchronous 662 // events (and have *that* discard events if we're not in the 663 // foreground.) 664 // 665 // Unfortunately it's not that simple, since we sometimes need to do 666 // actual work to handle these events whether or not we're in the 667 // foreground (see the Handler code in mSetOptionComplete for 668 // example.) 669 // 670 // TODO: It's a bit worrisome that we don't do anything in error cases when we're not in the 671 // foreground. Consider displaying a toast instead. showDialogIfForeground(int id)672 private void showDialogIfForeground(int id) { 673 if (mForeground) { 674 showDialog(id); 675 } 676 } 677 dismissDialogSafely(int id)678 private void dismissDialogSafely(int id) { 679 try { 680 dismissDialog(id); 681 } catch (IllegalArgumentException e) { 682 // This is expected in the case where we were in the background 683 // at the time we would normally have shown the dialog, so we didn't 684 // show it. 685 } 686 } 687 688 // This is a method implemented for DialogInterface.OnClickListener. 689 // Used with the error dialog to close the app, voicemail dialog to just dismiss. 690 // Close button is mapped to BUTTON_POSITIVE for the errors that close the activity, 691 // while those that are mapped to BUTTON_NEUTRAL only move the preference focus. onClick(DialogInterface dialog, int which)692 public void onClick(DialogInterface dialog, int which) { 693 if (DBG) log("onClick: button clicked is " + which); 694 695 dialog.dismiss(); 696 switch (which){ 697 case DialogInterface.BUTTON_NEGATIVE: 698 if (mCurrentDialogId == VoicemailDialogUtil.FWD_GET_RESPONSE_ERROR_DIALOG) { 699 // We failed to get current forwarding settings and the user 700 // does not wish to continue. 701 switchToPreviousVoicemailProvider(); 702 } 703 break; 704 case DialogInterface.BUTTON_POSITIVE: 705 if (mCurrentDialogId == VoicemailDialogUtil.FWD_GET_RESPONSE_ERROR_DIALOG) { 706 // We failed to get current forwarding settings but the user 707 // wishes to continue changing settings to the new vm provider 708 setVoicemailNumberWithCarrier(); 709 } else { 710 finish(); 711 } 712 return; 713 default: 714 // just let the dialog close and go back to the input 715 } 716 717 // In all dialogs, all buttons except BUTTON_POSITIVE lead to the end of user interaction 718 // with settings UI. If we were called to explicitly configure voice mail then 719 // we finish the settings activity here to come back to whatever the user was doing. 720 final String action = getIntent() != null ? getIntent().getAction() : null; 721 if (ACTION_ADD_VOICEMAIL.equals(action)) { 722 finish(); 723 } 724 } 725 726 727 //********************************************************************************************* 728 // Voicemail Methods 729 //********************************************************************************************* 730 731 /** 732 * TODO: Refactor to make it easier to understand what's done in the different stages. 733 */ saveVoiceMailAndForwardingNumber( String key, VoicemailProviderSettings newSettings)734 private void saveVoiceMailAndForwardingNumber( 735 String key, VoicemailProviderSettings newSettings) { 736 if (DBG) log("saveVoiceMailAndForwardingNumber: " + newSettings.toString()); 737 mNewVMNumber = newSettings.getVoicemailNumber(); 738 mNewVMNumber = (mNewVMNumber == null) ? "" : mNewVMNumber; 739 mNewFwdSettings = newSettings.getForwardingSettings(); 740 741 // Call forwarding is not suppported on CDMA. 742 if (mPhone.getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA) { 743 if (DBG) log("Ignoring forwarding setting since this is CDMA phone"); 744 mNewFwdSettings = VoicemailProviderSettings.NO_FORWARDING; 745 } 746 747 // Throw a warning if the voicemail is the same and we did not change forwarding. 748 if (mNewVMNumber.equals(mOldVmNumber) 749 && mNewFwdSettings == VoicemailProviderSettings.NO_FORWARDING) { 750 showDialogIfForeground(VoicemailDialogUtil.VM_NOCHANGE_ERROR_DIALOG); 751 return; 752 } 753 754 VoicemailProviderSettingsUtil.save(this, key, newSettings); 755 mVMChangeCompletedSuccessfully = false; 756 mFwdChangesRequireRollback = false; 757 mVMOrFwdSetError = 0; 758 759 if (mNewFwdSettings == VoicemailProviderSettings.NO_FORWARDING 760 || key.equals(mPreviousVMProviderKey)) { 761 if (DBG) log("Set voicemail number. No changes to forwarding number."); 762 setVoicemailNumberWithCarrier(); 763 } else { 764 if (DBG) log("Reading current forwarding settings."); 765 int numSettingsReasons = VoicemailProviderSettings.FORWARDING_SETTINGS_REASONS.length; 766 mForwardingReadResults = new CallForwardInfo[numSettingsReasons]; 767 for (int i = 0; i < mForwardingReadResults.length; i++) { 768 mPhone.getCallForwardingOption( 769 VoicemailProviderSettings.FORWARDING_SETTINGS_REASONS[i], 770 CommandsInterface.SERVICE_CLASS_VOICE, 771 mGetOptionComplete.obtainMessage(EVENT_FORWARDING_GET_COMPLETED, i, 0)); 772 } 773 showDialogIfForeground(VoicemailDialogUtil.VM_FWD_READING_DIALOG); 774 } 775 } 776 777 private final Handler mGetOptionComplete = new Handler() { 778 @Override 779 public void handleMessage(Message msg) { 780 AsyncResult result = (AsyncResult) msg.obj; 781 switch (msg.what) { 782 case EVENT_FORWARDING_GET_COMPLETED: 783 handleForwardingSettingsReadResult(result, msg.arg1); 784 break; 785 } 786 } 787 }; 788 handleForwardingSettingsReadResult(AsyncResult ar, int idx)789 private void handleForwardingSettingsReadResult(AsyncResult ar, int idx) { 790 if (DBG) Log.d(LOG_TAG, "handleForwardingSettingsReadResult: " + idx); 791 792 Throwable error = null; 793 if (ar.exception != null) { 794 error = ar.exception; 795 if (DBG) Log.d(LOG_TAG, "FwdRead: ar.exception=" + error.getMessage()); 796 } 797 if (ar.userObj instanceof Throwable) { 798 error = (Throwable) ar.userObj; 799 if (DBG) Log.d(LOG_TAG, "FwdRead: userObj=" + error.getMessage()); 800 } 801 802 // We may have already gotten an error and decided to ignore the other results. 803 if (mForwardingReadResults == null) { 804 if (DBG) Log.d(LOG_TAG, "Ignoring fwd reading result: " + idx); 805 return; 806 } 807 808 // In case of error ignore other results, show an error dialog 809 if (error != null) { 810 if (DBG) Log.d(LOG_TAG, "Error discovered for fwd read : " + idx); 811 mForwardingReadResults = null; 812 dismissDialogSafely(VoicemailDialogUtil.VM_FWD_READING_DIALOG); 813 showDialogIfForeground(VoicemailDialogUtil.FWD_GET_RESPONSE_ERROR_DIALOG); 814 return; 815 } 816 817 // Get the forwarding info. 818 mForwardingReadResults[idx] = CallForwardInfoUtil.getCallForwardInfo( 819 (CallForwardInfo[]) ar.result, 820 VoicemailProviderSettings.FORWARDING_SETTINGS_REASONS[idx]); 821 822 // Check if we got all the results already 823 boolean done = true; 824 for (int i = 0; i < mForwardingReadResults.length; i++) { 825 if (mForwardingReadResults[i] == null) { 826 done = false; 827 break; 828 } 829 } 830 831 if (done) { 832 if (DBG) Log.d(LOG_TAG, "Done receiving fwd info"); 833 dismissDialogSafely(VoicemailDialogUtil.VM_FWD_READING_DIALOG); 834 835 if (mPreviousVMProviderKey.equals(VoicemailProviderListPreference.DEFAULT_KEY)) { 836 VoicemailProviderSettingsUtil.save(mPhone.getContext(), 837 VoicemailProviderListPreference.DEFAULT_KEY, 838 new VoicemailProviderSettings(mOldVmNumber, mForwardingReadResults)); 839 } 840 saveVoiceMailAndForwardingNumberStage2(); 841 } 842 } 843 resetForwardingChangeState()844 private void resetForwardingChangeState() { 845 mForwardingChangeResults = new HashMap<Integer, AsyncResult>(); 846 mExpectedChangeResultReasons = new HashSet<Integer>(); 847 } 848 849 // Called after we are done saving the previous forwarding settings if we needed. saveVoiceMailAndForwardingNumberStage2()850 private void saveVoiceMailAndForwardingNumberStage2() { 851 mForwardingChangeResults = null; 852 mVoicemailChangeResult = null; 853 854 resetForwardingChangeState(); 855 for (int i = 0; i < mNewFwdSettings.length; i++) { 856 CallForwardInfo fi = mNewFwdSettings[i]; 857 CallForwardInfo fiForReason = 858 CallForwardInfoUtil.infoForReason(mForwardingReadResults, fi.reason); 859 final boolean doUpdate = CallForwardInfoUtil.isUpdateRequired(fiForReason, fi); 860 861 if (doUpdate) { 862 if (DBG) log("Setting fwd #: " + i + ": " + fi.toString()); 863 mExpectedChangeResultReasons.add(i); 864 865 CallForwardInfoUtil.setCallForwardingOption(mPhone, fi, 866 mSetOptionComplete.obtainMessage( 867 EVENT_FORWARDING_CHANGED, fi.reason, 0)); 868 } 869 } 870 showDialogIfForeground(VoicemailDialogUtil.VM_FWD_SAVING_DIALOG); 871 } 872 873 874 /** 875 * Callback to handle option update completions 876 */ 877 private final Handler mSetOptionComplete = new Handler() { 878 @Override 879 public void handleMessage(Message msg) { 880 AsyncResult result = (AsyncResult) msg.obj; 881 boolean done = false; 882 switch (msg.what) { 883 case EVENT_VOICEMAIL_CHANGED: 884 mVoicemailChangeResult = result; 885 mVMChangeCompletedSuccessfully = isVmChangeSuccess(); 886 PhoneGlobals.getInstance().refreshMwiIndicator( 887 mSubscriptionInfoHelper.getSubId()); 888 done = true; 889 break; 890 case EVENT_FORWARDING_CHANGED: 891 mForwardingChangeResults.put(msg.arg1, result); 892 if (result.exception != null) { 893 Log.w(LOG_TAG, "Error in setting fwd# " + msg.arg1 + ": " + 894 result.exception.getMessage()); 895 } 896 if (isForwardingCompleted()) { 897 if (isFwdChangeSuccess()) { 898 if (DBG) log("Overall fwd changes completed ok, starting vm change"); 899 setVoicemailNumberWithCarrier(); 900 } else { 901 Log.w(LOG_TAG, "Overall fwd changes completed in failure. " + 902 "Check if we need to try rollback for some settings."); 903 mFwdChangesRequireRollback = false; 904 Iterator<Map.Entry<Integer,AsyncResult>> it = 905 mForwardingChangeResults.entrySet().iterator(); 906 while (it.hasNext()) { 907 Map.Entry<Integer,AsyncResult> entry = it.next(); 908 if (entry.getValue().exception == null) { 909 // If at least one succeeded we have to revert 910 Log.i(LOG_TAG, "Rollback will be required"); 911 mFwdChangesRequireRollback = true; 912 break; 913 } 914 } 915 if (!mFwdChangesRequireRollback) { 916 Log.i(LOG_TAG, "No rollback needed."); 917 } 918 done = true; 919 } 920 } 921 break; 922 default: 923 // TODO: should never reach this, may want to throw exception 924 } 925 926 if (done) { 927 if (DBG) log("All VM provider related changes done"); 928 if (mForwardingChangeResults != null) { 929 dismissDialogSafely(VoicemailDialogUtil.VM_FWD_SAVING_DIALOG); 930 } 931 handleSetVmOrFwdMessage(); 932 } 933 } 934 }; 935 936 /** 937 * Callback to handle option revert completions 938 */ 939 private final Handler mRevertOptionComplete = new Handler() { 940 @Override 941 public void handleMessage(Message msg) { 942 AsyncResult result = (AsyncResult) msg.obj; 943 switch (msg.what) { 944 case EVENT_VOICEMAIL_CHANGED: 945 if (DBG) log("VM revert complete msg"); 946 mVoicemailChangeResult = result; 947 break; 948 949 case EVENT_FORWARDING_CHANGED: 950 if (DBG) log("FWD revert complete msg "); 951 mForwardingChangeResults.put(msg.arg1, result); 952 if (result.exception != null) { 953 if (DBG) log("Error in reverting fwd# " + msg.arg1 + ": " + 954 result.exception.getMessage()); 955 } 956 break; 957 958 default: 959 // TODO: should never reach this, may want to throw exception 960 } 961 962 final boolean done = (!mVMChangeCompletedSuccessfully || mVoicemailChangeResult != null) 963 && (!mFwdChangesRequireRollback || isForwardingCompleted()); 964 if (done) { 965 if (DBG) log("All VM reverts done"); 966 dismissDialogSafely(VoicemailDialogUtil.VM_REVERTING_DIALOG); 967 onRevertDone(); 968 } 969 } 970 }; 971 setVoicemailNumberWithCarrier()972 private void setVoicemailNumberWithCarrier() { 973 if (DBG) log("save voicemail #: " + mNewVMNumber); 974 975 mVoicemailChangeResult = null; 976 mPhone.setVoiceMailNumber( 977 mPhone.getVoiceMailAlphaTag().toString(), 978 mNewVMNumber, 979 Message.obtain(mSetOptionComplete, EVENT_VOICEMAIL_CHANGED)); 980 } 981 switchToPreviousVoicemailProvider()982 private void switchToPreviousVoicemailProvider() { 983 if (DBG) log("switchToPreviousVoicemailProvider " + mPreviousVMProviderKey); 984 985 if (mPreviousVMProviderKey == null) { 986 return; 987 } 988 989 if (mVMChangeCompletedSuccessfully || mFwdChangesRequireRollback) { 990 showDialogIfForeground(VoicemailDialogUtil.VM_REVERTING_DIALOG); 991 final VoicemailProviderSettings prevSettings = 992 VoicemailProviderSettingsUtil.load(this, mPreviousVMProviderKey); 993 if (prevSettings == null) { 994 Log.e(LOG_TAG, "VoicemailProviderSettings for the key \"" 995 + mPreviousVMProviderKey + "\" is null but should be loaded."); 996 return; 997 } 998 999 if (mVMChangeCompletedSuccessfully) { 1000 mNewVMNumber = prevSettings.getVoicemailNumber(); 1001 Log.i(LOG_TAG, "VM change is already completed successfully." 1002 + "Have to revert VM back to " + mNewVMNumber + " again."); 1003 mPhone.setVoiceMailNumber( 1004 mPhone.getVoiceMailAlphaTag().toString(), 1005 mNewVMNumber, 1006 Message.obtain(mRevertOptionComplete, EVENT_VOICEMAIL_CHANGED)); 1007 } 1008 1009 if (mFwdChangesRequireRollback) { 1010 Log.i(LOG_TAG, "Requested to rollback forwarding changes."); 1011 1012 final CallForwardInfo[] prevFwdSettings = prevSettings.getForwardingSettings(); 1013 if (prevFwdSettings != null) { 1014 Map<Integer, AsyncResult> results = mForwardingChangeResults; 1015 resetForwardingChangeState(); 1016 for (int i = 0; i < prevFwdSettings.length; i++) { 1017 CallForwardInfo fi = prevFwdSettings[i]; 1018 if (DBG) log("Reverting fwd #: " + i + ": " + fi.toString()); 1019 // Only revert the settings for which the update succeeded. 1020 AsyncResult result = results.get(fi.reason); 1021 if (result != null && result.exception == null) { 1022 mExpectedChangeResultReasons.add(fi.reason); 1023 CallForwardInfoUtil.setCallForwardingOption(mPhone, fi, 1024 mRevertOptionComplete.obtainMessage( 1025 EVENT_FORWARDING_CHANGED, i, 0)); 1026 } 1027 } 1028 } 1029 } 1030 } else { 1031 if (DBG) log("No need to revert"); 1032 onRevertDone(); 1033 } 1034 } 1035 1036 1037 //********************************************************************************************* 1038 // Voicemail Handler Helpers 1039 //********************************************************************************************* 1040 1041 /** 1042 * Updates the look of the VM preference widgets based on current VM provider settings. 1043 * Note that the provider name is loaded fxrorm the found activity via loadLabel in 1044 * {@link VoicemailProviderListPreference#initVoiceMailProviders()} in order for it to be 1045 * localizable. 1046 */ updateVMPreferenceWidgets(String currentProviderSetting)1047 private void updateVMPreferenceWidgets(String currentProviderSetting) { 1048 final String key = currentProviderSetting; 1049 final VoicemailProviderListPreference.VoicemailProvider provider = 1050 mVoicemailProviders.getVoicemailProvider(key); 1051 1052 /* This is the case when we are coming up on a freshly wiped phone and there is no 1053 persisted value for the list preference mVoicemailProviders. 1054 In this case we want to show the UI asking the user to select a voicemail provider as 1055 opposed to silently falling back to default one. */ 1056 if (provider == null) { 1057 if (DBG) log("updateVMPreferenceWidget: key: " + key + " -> null."); 1058 1059 mVoicemailProviders.setSummary(getString(R.string.sum_voicemail_choose_provider)); 1060 mVoicemailSettings.setEnabled(false); 1061 mVoicemailSettings.setIntent(null); 1062 } else { 1063 if (DBG) log("updateVMPreferenceWidget: key: " + key + " -> " + provider.toString()); 1064 1065 final String providerName = provider.name; 1066 mVoicemailProviders.setSummary(providerName); 1067 mVoicemailSettings.setEnabled(true); 1068 mVoicemailSettings.setIntent(provider.intent); 1069 } 1070 } 1071 1072 /** 1073 * Update the voicemail number from what we've recorded on the sim. 1074 */ updateVoiceNumberField()1075 private void updateVoiceNumberField() { 1076 if (DBG) log("updateVoiceNumberField()"); 1077 1078 mOldVmNumber = mPhone.getVoiceMailNumber(); 1079 if (TextUtils.isEmpty(mOldVmNumber)) { 1080 mSubMenuVoicemailSettings.setPhoneNumber(""); 1081 mSubMenuVoicemailSettings.setSummary(getString(R.string.voicemail_number_not_set)); 1082 } else { 1083 mSubMenuVoicemailSettings.setPhoneNumber(mOldVmNumber); 1084 mSubMenuVoicemailSettings.setSummary(BidiFormatter.getInstance().unicodeWrap( 1085 mOldVmNumber, TextDirectionHeuristics.LTR)); 1086 } 1087 } 1088 handleSetVmOrFwdMessage()1089 private void handleSetVmOrFwdMessage() { 1090 if (DBG) log("handleSetVMMessage: set VM request complete"); 1091 1092 if (!isFwdChangeSuccess()) { 1093 handleVmOrFwdSetError(VoicemailDialogUtil.FWD_SET_RESPONSE_ERROR_DIALOG); 1094 } else if (!isVmChangeSuccess()) { 1095 handleVmOrFwdSetError(VoicemailDialogUtil.VM_RESPONSE_ERROR_DIALOG); 1096 } else { 1097 handleVmAndFwdSetSuccess(VoicemailDialogUtil.VM_CONFIRM_DIALOG); 1098 } 1099 } 1100 1101 /** 1102 * Called when Voicemail Provider or its forwarding settings failed. Rolls back partly made 1103 * changes to those settings and show "failure" dialog. 1104 * 1105 * @param dialogId ID of the dialog to show for the specific error case. Either 1106 * {@link #FWD_SET_RESPONSE_ERROR_DIALOG} or {@link #VM_RESPONSE_ERROR_DIALOG} 1107 */ handleVmOrFwdSetError(int dialogId)1108 private void handleVmOrFwdSetError(int dialogId) { 1109 if (mChangingVMorFwdDueToProviderChange) { 1110 mVMOrFwdSetError = dialogId; 1111 mChangingVMorFwdDueToProviderChange = false; 1112 switchToPreviousVoicemailProvider(); 1113 return; 1114 } 1115 mChangingVMorFwdDueToProviderChange = false; 1116 showDialogIfForeground(dialogId); 1117 updateVoiceNumberField(); 1118 } 1119 1120 /** 1121 * Called when Voicemail Provider and its forwarding settings were successfully finished. 1122 * This updates a bunch of variables and show "success" dialog. 1123 */ handleVmAndFwdSetSuccess(int dialogId)1124 private void handleVmAndFwdSetSuccess(int dialogId) { 1125 if (DBG) log("handleVmAndFwdSetSuccess: key is " + mVoicemailProviders.getKey()); 1126 1127 mPreviousVMProviderKey = mVoicemailProviders.getKey(); 1128 mChangingVMorFwdDueToProviderChange = false; 1129 showDialogIfForeground(dialogId); 1130 updateVoiceNumberField(); 1131 } 1132 onRevertDone()1133 private void onRevertDone() { 1134 if (DBG) log("onRevertDone: Changing provider key back to " + mPreviousVMProviderKey); 1135 1136 updateVMPreferenceWidgets(mPreviousVMProviderKey); 1137 updateVoiceNumberField(); 1138 if (mVMOrFwdSetError != 0) { 1139 showDialogIfForeground(mVMOrFwdSetError); 1140 mVMOrFwdSetError = 0; 1141 } 1142 } 1143 1144 1145 //********************************************************************************************* 1146 // Voicemail State Helpers 1147 //********************************************************************************************* 1148 1149 /** 1150 * Return true if there is a change result for every reason for which we expect a result. 1151 */ isForwardingCompleted()1152 private boolean isForwardingCompleted() { 1153 if (mForwardingChangeResults == null) { 1154 return true; 1155 } 1156 1157 for (Integer reason : mExpectedChangeResultReasons) { 1158 if (mForwardingChangeResults.get(reason) == null) { 1159 return false; 1160 } 1161 } 1162 1163 return true; 1164 } 1165 isFwdChangeSuccess()1166 private boolean isFwdChangeSuccess() { 1167 if (mForwardingChangeResults == null) { 1168 return true; 1169 } 1170 1171 for (AsyncResult result : mForwardingChangeResults.values()) { 1172 Throwable exception = result.exception; 1173 if (exception != null) { 1174 String msg = exception.getMessage(); 1175 msg = (msg != null) ? msg : ""; 1176 Log.w(LOG_TAG, "Failed to change forwarding setting. Reason: " + msg); 1177 return false; 1178 } 1179 } 1180 return true; 1181 } 1182 isVmChangeSuccess()1183 private boolean isVmChangeSuccess() { 1184 if (mVoicemailChangeResult.exception != null) { 1185 String msg = mVoicemailChangeResult.exception.getMessage(); 1186 msg = (msg != null) ? msg : ""; 1187 Log.w(LOG_TAG, "Failed to change voicemail. Reason: " + msg); 1188 return false; 1189 } 1190 return true; 1191 } 1192 log(String msg)1193 private static void log(String msg) { 1194 Log.d(LOG_TAG, msg); 1195 } 1196 } 1197