1 /* 2 * Copyright (C) 2008 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.ActionBar; 20 import android.app.Activity; 21 import android.app.ActivityOptions; 22 import android.app.AlertDialog; 23 import android.app.Dialog; 24 import android.content.ContentResolver; 25 import android.content.Context; 26 import android.content.DialogInterface; 27 import android.content.Intent; 28 import android.content.pm.PackageManager; 29 import android.content.pm.ResolveInfo; 30 import android.os.Bundle; 31 import android.os.PersistableBundle; 32 import android.os.UserHandle; 33 import android.os.UserManager; 34 import android.preference.CheckBoxPreference; 35 import android.preference.ListPreference; 36 import android.preference.Preference; 37 import android.preference.PreferenceActivity; 38 import android.preference.PreferenceScreen; 39 import android.provider.Settings; 40 import android.telecom.PhoneAccountHandle; 41 import android.telecom.TelecomManager; 42 import android.telephony.CarrierConfigManager; 43 import android.telephony.PhoneStateListener; 44 import android.telephony.TelephonyManager; 45 import android.text.TextUtils; 46 import android.util.Log; 47 import android.view.MenuItem; 48 import android.widget.Toast; 49 50 import com.android.ims.ImsConfig; 51 import com.android.ims.ImsManager; 52 import com.android.internal.telephony.CallForwardInfo; 53 import com.android.internal.telephony.Phone; 54 import com.android.internal.telephony.PhoneConstants; 55 import com.android.phone.common.util.SettingsUtil; 56 import com.android.phone.settings.AccountSelectionPreference; 57 import com.android.phone.settings.PhoneAccountSettingsFragment; 58 import com.android.phone.settings.VoicemailSettingsActivity; 59 import com.android.phone.settings.fdn.FdnSetting; 60 import com.android.services.telephony.sip.SipUtil; 61 62 import java.lang.String; 63 import java.util.ArrayList; 64 import java.util.List; 65 66 /** 67 * Top level "Call settings" UI; see res/xml/call_feature_setting.xml 68 * 69 * This preference screen is the root of the "Call settings" hierarchy available from the Phone 70 * app; the settings here let you control various features related to phone calls (including 71 * voicemail settings, the "Respond via SMS" feature, and others.) It's used only on 72 * voice-capable phone devices. 73 * 74 * Note that this activity is part of the package com.android.phone, even 75 * though you reach it from the "Phone" app (i.e. DialtactsActivity) which 76 * is from the package com.android.contacts. 77 * 78 * For the "Mobile network settings" screen under the main Settings app, 79 * See {@link MobileNetworkSettings}. 80 * 81 * @see com.android.phone.MobileNetworkSettings 82 */ 83 public class CallFeaturesSetting extends PreferenceActivity 84 implements Preference.OnPreferenceChangeListener { 85 private static final String LOG_TAG = "CallFeaturesSetting"; 86 private static final boolean DBG = (PhoneGlobals.DBG_LEVEL >= 2); 87 88 // String keys for preference lookup 89 // TODO: Naming these "BUTTON_*" is confusing since they're not actually buttons(!) 90 // TODO: Consider moving these strings to strings.xml, so that they are not duplicated here and 91 // in the layout files. These strings need to be treated carefully; if the setting is 92 // persistent, they are used as the key to store shared preferences and the name should not be 93 // changed unless the settings are also migrated. 94 private static final String VOICEMAIL_SETTING_SCREEN_PREF_KEY = "button_voicemail_category_key"; 95 private static final String BUTTON_FDN_KEY = "button_fdn_key"; 96 private static final String BUTTON_RETRY_KEY = "button_auto_retry_key"; 97 private static final String BUTTON_GSM_UMTS_OPTIONS = "button_gsm_more_expand_key"; 98 private static final String BUTTON_CDMA_OPTIONS = "button_cdma_more_expand_key"; 99 100 private static final String PHONE_ACCOUNT_SETTINGS_KEY = 101 "phone_account_settings_preference_screen"; 102 103 private static final String ENABLE_VIDEO_CALLING_KEY = "button_enable_video_calling"; 104 105 private Phone mPhone; 106 private SubscriptionInfoHelper mSubscriptionInfoHelper; 107 private TelecomManager mTelecomManager; 108 109 private CheckBoxPreference mButtonAutoRetry; 110 private PreferenceScreen mVoicemailSettingsScreen; 111 private CheckBoxPreference mEnableVideoCalling; 112 113 /* 114 * Click Listeners, handle click based on objects attached to UI. 115 */ 116 117 // Click listener for all toggle events 118 @Override onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference)119 public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference) { 120 if (preference == mButtonAutoRetry) { 121 android.provider.Settings.Global.putInt(mPhone.getContext().getContentResolver(), 122 android.provider.Settings.Global.CALL_AUTO_RETRY, 123 mButtonAutoRetry.isChecked() ? 1 : 0); 124 return true; 125 } 126 return false; 127 } 128 129 /** 130 * Implemented to support onPreferenceChangeListener to look for preference 131 * changes. 132 * 133 * @param preference is the preference to be changed 134 * @param objValue should be the value of the selection, NOT its localized 135 * display value. 136 */ 137 @Override onPreferenceChange(Preference preference, Object objValue)138 public boolean onPreferenceChange(Preference preference, Object objValue) { 139 if (DBG) log("onPreferenceChange: \"" + preference + "\" changed to \"" + objValue + "\""); 140 141 if (preference == mEnableVideoCalling) { 142 if (ImsManager.isEnhanced4gLteModeSettingEnabledByUser(mPhone.getContext())) { 143 PhoneGlobals.getInstance().phoneMgr.enableVideoCalling((boolean) objValue); 144 } else { 145 AlertDialog.Builder builder = new AlertDialog.Builder(this); 146 DialogInterface.OnClickListener networkSettingsClickListener = 147 new Dialog.OnClickListener() { 148 @Override 149 public void onClick(DialogInterface dialog, int which) { 150 startActivity(new Intent(mPhone.getContext(), 151 com.android.phone.MobileNetworkSettings.class)); 152 } 153 }; 154 builder.setMessage(getResources().getString( 155 R.string.enable_video_calling_dialog_msg)) 156 .setNeutralButton(getResources().getString( 157 R.string.enable_video_calling_dialog_settings), 158 networkSettingsClickListener) 159 .setPositiveButton(android.R.string.ok, null) 160 .show(); 161 return false; 162 } 163 } 164 165 // Always let the preference setting proceed. 166 return true; 167 } 168 169 @Override onCreate(Bundle icicle)170 protected void onCreate(Bundle icicle) { 171 super.onCreate(icicle); 172 if (DBG) log("onCreate: Intent is " + getIntent()); 173 174 // Make sure we are running as an admin user. 175 if (!UserManager.get(this).isAdminUser()) { 176 Toast.makeText(this, R.string.call_settings_admin_user_only, 177 Toast.LENGTH_SHORT).show(); 178 finish(); 179 return; 180 } 181 182 mSubscriptionInfoHelper = new SubscriptionInfoHelper(this, getIntent()); 183 mSubscriptionInfoHelper.setActionBarTitle( 184 getActionBar(), getResources(), R.string.call_settings_with_label); 185 mPhone = mSubscriptionInfoHelper.getPhone(); 186 mTelecomManager = TelecomManager.from(this); 187 } 188 189 private final PhoneStateListener mPhoneStateListener = new PhoneStateListener() { 190 @Override 191 public void onCallStateChanged(int state, String incomingNumber) { 192 if (DBG) log("PhoneStateListener onCallStateChanged: state is " + state); 193 if (mEnableVideoCalling != null) { 194 mEnableVideoCalling.setEnabled(state == TelephonyManager.CALL_STATE_IDLE); 195 } 196 } 197 }; 198 199 @Override onPause()200 protected void onPause() { 201 super.onPause(); 202 TelephonyManager telephonyManager = 203 (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE); 204 telephonyManager.listen(mPhoneStateListener, PhoneStateListener.LISTEN_NONE); 205 } 206 207 @Override onResume()208 protected void onResume() { 209 super.onResume(); 210 211 PreferenceScreen preferenceScreen = getPreferenceScreen(); 212 if (preferenceScreen != null) { 213 preferenceScreen.removeAll(); 214 } 215 216 addPreferencesFromResource(R.xml.call_feature_setting); 217 218 TelephonyManager telephonyManager = 219 (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE); 220 telephonyManager.listen(mPhoneStateListener, PhoneStateListener.LISTEN_CALL_STATE); 221 222 Preference phoneAccountSettingsPreference = findPreference(PHONE_ACCOUNT_SETTINGS_KEY); 223 if (telephonyManager.isMultiSimEnabled() || !SipUtil.isVoipSupported(mPhone.getContext())) { 224 getPreferenceScreen().removePreference(phoneAccountSettingsPreference); 225 } 226 227 PreferenceScreen prefSet = getPreferenceScreen(); 228 mVoicemailSettingsScreen = 229 (PreferenceScreen) findPreference(VOICEMAIL_SETTING_SCREEN_PREF_KEY); 230 mVoicemailSettingsScreen.setIntent(mSubscriptionInfoHelper.getIntent( 231 VoicemailSettingsActivity.class)); 232 233 mButtonAutoRetry = (CheckBoxPreference) findPreference(BUTTON_RETRY_KEY); 234 235 mEnableVideoCalling = (CheckBoxPreference) findPreference(ENABLE_VIDEO_CALLING_KEY); 236 237 PersistableBundle carrierConfig = 238 PhoneGlobals.getInstance().getCarrierConfigForSubId(mPhone.getSubId()); 239 240 if (carrierConfig.getBoolean(CarrierConfigManager.KEY_AUTO_RETRY_ENABLED_BOOL)) { 241 mButtonAutoRetry.setOnPreferenceChangeListener(this); 242 int autoretry = Settings.Global.getInt( 243 getContentResolver(), Settings.Global.CALL_AUTO_RETRY, 0); 244 mButtonAutoRetry.setChecked(autoretry != 0); 245 } else { 246 prefSet.removePreference(mButtonAutoRetry); 247 mButtonAutoRetry = null; 248 } 249 250 Preference cdmaOptions = prefSet.findPreference(BUTTON_CDMA_OPTIONS); 251 Preference gsmOptions = prefSet.findPreference(BUTTON_GSM_UMTS_OPTIONS); 252 if (carrierConfig.getBoolean(CarrierConfigManager.KEY_WORLD_PHONE_BOOL)) { 253 cdmaOptions.setIntent(mSubscriptionInfoHelper.getIntent(CdmaCallOptions.class)); 254 gsmOptions.setIntent(mSubscriptionInfoHelper.getIntent(GsmUmtsCallOptions.class)); 255 } else { 256 prefSet.removePreference(cdmaOptions); 257 prefSet.removePreference(gsmOptions); 258 259 int phoneType = mPhone.getPhoneType(); 260 Preference fdnButton = prefSet.findPreference(BUTTON_FDN_KEY); 261 if (carrierConfig.getBoolean(CarrierConfigManager.KEY_HIDE_CARRIER_NETWORK_SETTINGS_BOOL)) { 262 prefSet.removePreference(fdnButton); 263 } else { 264 if (phoneType == PhoneConstants.PHONE_TYPE_CDMA) { 265 prefSet.removePreference(fdnButton); 266 267 if (!carrierConfig.getBoolean( 268 CarrierConfigManager.KEY_VOICE_PRIVACY_DISABLE_UI_BOOL)) { 269 addPreferencesFromResource(R.xml.cdma_call_privacy); 270 } 271 } else if (phoneType == PhoneConstants.PHONE_TYPE_GSM) { 272 fdnButton.setIntent(mSubscriptionInfoHelper.getIntent(FdnSetting.class)); 273 274 if (carrierConfig.getBoolean( 275 CarrierConfigManager.KEY_ADDITIONAL_CALL_SETTING_BOOL)) { 276 addPreferencesFromResource(R.xml.gsm_umts_call_options); 277 GsmUmtsCallOptions.init(prefSet, mSubscriptionInfoHelper); 278 } 279 } else { 280 throw new IllegalStateException("Unexpected phone type: " + phoneType); 281 } 282 } 283 } 284 285 if (ImsManager.isVtEnabledByPlatform(mPhone.getContext()) && 286 ImsManager.isVtProvisionedOnDevice(mPhone.getContext()) && 287 (carrierConfig.getBoolean( 288 CarrierConfigManager.KEY_IGNORE_DATA_ENABLED_CHANGED_FOR_VIDEO_CALLS) 289 || mPhone.mDcTracker.isDataEnabled(true))) { 290 boolean currentValue = 291 ImsManager.isEnhanced4gLteModeSettingEnabledByUser(mPhone.getContext()) 292 ? PhoneGlobals.getInstance().phoneMgr.isVideoCallingEnabled( 293 getOpPackageName()) : false; 294 mEnableVideoCalling.setChecked(currentValue); 295 mEnableVideoCalling.setOnPreferenceChangeListener(this); 296 } else { 297 prefSet.removePreference(mEnableVideoCalling); 298 } 299 300 if (ImsManager.isVolteEnabledByPlatform(this) && 301 !carrierConfig.getBoolean( 302 CarrierConfigManager.KEY_CARRIER_VOLTE_TTY_SUPPORTED_BOOL)) { 303 TelephonyManager tm = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE); 304 /* tm.listen(mPhoneStateListener, PhoneStateListener.LISTEN_CALL_STATE); */ 305 } 306 307 Preference wifiCallingSettings = findPreference( 308 getResources().getString(R.string.wifi_calling_settings_key)); 309 310 final PhoneAccountHandle simCallManager = mTelecomManager.getSimCallManager(); 311 if (simCallManager != null) { 312 Intent intent = PhoneAccountSettingsFragment.buildPhoneAccountConfigureIntent( 313 this, simCallManager); 314 if (intent != null) { 315 PackageManager pm = mPhone.getContext().getPackageManager(); 316 List<ResolveInfo> resolutions = pm.queryIntentActivities(intent, 0); 317 if (!resolutions.isEmpty()) { 318 wifiCallingSettings.setTitle(resolutions.get(0).loadLabel(pm)); 319 wifiCallingSettings.setSummary(null); 320 wifiCallingSettings.setIntent(intent); 321 } else { 322 prefSet.removePreference(wifiCallingSettings); 323 } 324 } else { 325 prefSet.removePreference(wifiCallingSettings); 326 } 327 } else if (!ImsManager.isWfcEnabledByPlatform(mPhone.getContext()) || 328 !ImsManager.isWfcProvisionedOnDevice(mPhone.getContext())) { 329 prefSet.removePreference(wifiCallingSettings); 330 } else { 331 int resId = com.android.internal.R.string.wifi_calling_off_summary; 332 if (ImsManager.isWfcEnabledByUser(mPhone.getContext())) { 333 boolean isRoaming = telephonyManager.isNetworkRoaming(); 334 int wfcMode = ImsManager.getWfcMode(mPhone.getContext(), isRoaming); 335 switch (wfcMode) { 336 case ImsConfig.WfcModeFeatureValueConstants.WIFI_ONLY: 337 resId = com.android.internal.R.string.wfc_mode_wifi_only_summary; 338 break; 339 case ImsConfig.WfcModeFeatureValueConstants.CELLULAR_PREFERRED: 340 resId = com.android.internal.R.string.wfc_mode_cellular_preferred_summary; 341 break; 342 case ImsConfig.WfcModeFeatureValueConstants.WIFI_PREFERRED: 343 resId = com.android.internal.R.string.wfc_mode_wifi_preferred_summary; 344 break; 345 default: 346 if (DBG) log("Unexpected WFC mode value: " + wfcMode); 347 } 348 } 349 wifiCallingSettings.setSummary(resId); 350 } 351 } 352 353 @Override onNewIntent(Intent newIntent)354 protected void onNewIntent(Intent newIntent) { 355 setIntent(newIntent); 356 357 mSubscriptionInfoHelper = new SubscriptionInfoHelper(this, getIntent()); 358 mSubscriptionInfoHelper.setActionBarTitle( 359 getActionBar(), getResources(), R.string.call_settings_with_label); 360 mPhone = mSubscriptionInfoHelper.getPhone(); 361 } 362 log(String msg)363 private static void log(String msg) { 364 Log.d(LOG_TAG, msg); 365 } 366 367 @Override onOptionsItemSelected(MenuItem item)368 public boolean onOptionsItemSelected(MenuItem item) { 369 final int itemId = item.getItemId(); 370 if (itemId == android.R.id.home) { // See ActionBar#setDisplayHomeAsUpEnabled() 371 onBackPressed(); 372 return true; 373 } 374 return super.onOptionsItemSelected(item); 375 } 376 377 /** 378 * Finish current Activity and go up to the top level Settings ({@link CallFeaturesSetting}). 379 * This is useful for implementing "HomeAsUp" capability for second-level Settings. 380 */ goUpToTopLevelSetting( Activity activity, SubscriptionInfoHelper subscriptionInfoHelper)381 public static void goUpToTopLevelSetting( 382 Activity activity, SubscriptionInfoHelper subscriptionInfoHelper) { 383 Intent intent = subscriptionInfoHelper.getIntent(CallFeaturesSetting.class); 384 intent.setAction(Intent.ACTION_MAIN); 385 intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP); 386 activity.startActivity(intent); 387 activity.finish(); 388 } 389 } 390