1 /* 2 * Copyright (C) 2007-2008 Esmertec AG. 3 * Copyright (C) 2007-2008 The Android Open Source Project 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 */ 17 18 package com.android.mms.ui; 19 20 import android.app.ActionBar; 21 import android.app.Activity; 22 import android.app.AlertDialog; 23 import android.app.Dialog; 24 import android.content.Context; 25 import android.content.DialogInterface; 26 import android.content.Intent; 27 import android.content.SharedPreferences; 28 import android.media.Ringtone; 29 import android.media.RingtoneManager; 30 import android.net.Uri; 31 import android.os.Bundle; 32 import android.preference.CheckBoxPreference; 33 import android.preference.ListPreference; 34 import android.preference.Preference; 35 import android.preference.Preference.OnPreferenceChangeListener; 36 import android.preference.PreferenceActivity; 37 import android.preference.PreferenceCategory; 38 import android.preference.PreferenceManager; 39 import android.preference.PreferenceScreen; 40 import android.preference.RingtonePreference; 41 import android.provider.SearchRecentSuggestions; 42 import android.text.TextUtils; 43 import android.view.Menu; 44 import android.view.MenuItem; 45 46 import com.android.mms.MmsApp; 47 import com.android.mms.MmsConfig; 48 import com.android.mms.R; 49 import com.android.mms.transaction.TransactionService; 50 import com.android.mms.util.Recycler; 51 52 /** 53 * With this activity, users can set preferences for MMS and SMS and 54 * can access and manipulate SMS messages stored on the SIM. 55 */ 56 public class MessagingPreferenceActivity extends PreferenceActivity 57 implements OnPreferenceChangeListener { 58 // Symbolic names for the keys used for preference lookup 59 public static final String MMS_DELIVERY_REPORT_MODE = "pref_key_mms_delivery_reports"; 60 public static final String EXPIRY_TIME = "pref_key_mms_expiry"; 61 public static final String PRIORITY = "pref_key_mms_priority"; 62 public static final String READ_REPORT_MODE = "pref_key_mms_read_reports"; 63 public static final String SMS_DELIVERY_REPORT_MODE = "pref_key_sms_delivery_reports"; 64 public static final String NOTIFICATION_ENABLED = "pref_key_enable_notifications"; 65 public static final String NOTIFICATION_VIBRATE = "pref_key_vibrate"; 66 public static final String NOTIFICATION_VIBRATE_WHEN= "pref_key_vibrateWhen"; 67 public static final String NOTIFICATION_RINGTONE = "pref_key_ringtone"; 68 public static final String AUTO_RETRIEVAL = "pref_key_mms_auto_retrieval"; 69 public static final String RETRIEVAL_DURING_ROAMING = "pref_key_mms_retrieval_during_roaming"; 70 public static final String AUTO_DELETE = "pref_key_auto_delete"; 71 public static final String GROUP_MMS_MODE = "pref_key_mms_group_mms"; 72 73 // Menu entries 74 private static final int MENU_RESTORE_DEFAULTS = 1; 75 76 private Preference mSmsLimitPref; 77 private Preference mSmsDeliveryReportPref; 78 private Preference mMmsLimitPref; 79 private Preference mMmsDeliveryReportPref; 80 private Preference mMmsGroupMmsPref; 81 private Preference mMmsReadReportPref; 82 private Preference mManageSimPref; 83 private Preference mClearHistoryPref; 84 private CheckBoxPreference mVibratePref; 85 private CheckBoxPreference mEnableNotificationsPref; 86 private CheckBoxPreference mMmsAutoRetrievialPref; 87 private RingtonePreference mRingtonePref; 88 private Recycler mSmsRecycler; 89 private Recycler mMmsRecycler; 90 private static final int CONFIRM_CLEAR_SEARCH_HISTORY_DIALOG = 3; 91 92 @Override onCreate(Bundle icicle)93 protected void onCreate(Bundle icicle) { 94 super.onCreate(icicle); 95 96 loadPrefs(); 97 98 ActionBar actionBar = getActionBar(); 99 actionBar.setDisplayHomeAsUpEnabled(true); 100 } 101 102 @Override onResume()103 protected void onResume() { 104 super.onResume(); 105 106 // Since the enabled notifications pref can be changed outside of this activity, 107 // we have to reload it whenever we resume. 108 setEnabledNotificationsPref(); 109 registerListeners(); 110 } 111 loadPrefs()112 private void loadPrefs() { 113 addPreferencesFromResource(R.xml.preferences); 114 115 mManageSimPref = findPreference("pref_key_manage_sim_messages"); 116 mSmsLimitPref = findPreference("pref_key_sms_delete_limit"); 117 mSmsDeliveryReportPref = findPreference("pref_key_sms_delivery_reports"); 118 mMmsDeliveryReportPref = findPreference("pref_key_mms_delivery_reports"); 119 mMmsGroupMmsPref = findPreference("pref_key_mms_group_mms"); 120 mMmsReadReportPref = findPreference("pref_key_mms_read_reports"); 121 mMmsLimitPref = findPreference("pref_key_mms_delete_limit"); 122 mClearHistoryPref = findPreference("pref_key_mms_clear_history"); 123 mEnableNotificationsPref = (CheckBoxPreference) findPreference(NOTIFICATION_ENABLED); 124 mMmsAutoRetrievialPref = (CheckBoxPreference) findPreference(AUTO_RETRIEVAL); 125 mVibratePref = (CheckBoxPreference) findPreference(NOTIFICATION_VIBRATE); 126 mRingtonePref = (RingtonePreference) findPreference(NOTIFICATION_RINGTONE); 127 128 setMessagePreferences(); 129 } 130 restoreDefaultPreferences()131 private void restoreDefaultPreferences() { 132 PreferenceManager.getDefaultSharedPreferences(this).edit().clear().apply(); 133 setPreferenceScreen(null); 134 loadPrefs(); 135 136 // NOTE: After restoring preferences, the auto delete function (i.e. message recycler) 137 // will be turned off by default. However, we really want the default to be turned on. 138 // Because all the prefs are cleared, that'll cause: 139 // ConversationList.runOneTimeStorageLimitCheckForLegacyMessages to get executed the 140 // next time the user runs the Messaging app and it will either turn on the setting 141 // by default, or if the user is over the limits, encourage them to turn on the setting 142 // manually. 143 } 144 setMessagePreferences()145 private void setMessagePreferences() { 146 if (!MmsApp.getApplication().getTelephonyManager().hasIccCard()) { 147 // No SIM card, remove the SIM-related prefs 148 PreferenceCategory smsCategory = 149 (PreferenceCategory)findPreference("pref_key_sms_settings"); 150 smsCategory.removePreference(mManageSimPref); 151 } 152 153 if (!MmsConfig.getSMSDeliveryReportsEnabled()) { 154 PreferenceCategory smsCategory = 155 (PreferenceCategory)findPreference("pref_key_sms_settings"); 156 smsCategory.removePreference(mSmsDeliveryReportPref); 157 if (!MmsApp.getApplication().getTelephonyManager().hasIccCard()) { 158 getPreferenceScreen().removePreference(smsCategory); 159 } 160 } 161 162 if (!MmsConfig.getMmsEnabled()) { 163 // No Mms, remove all the mms-related preferences 164 PreferenceCategory mmsOptions = 165 (PreferenceCategory)findPreference("pref_key_mms_settings"); 166 getPreferenceScreen().removePreference(mmsOptions); 167 168 PreferenceCategory storageOptions = 169 (PreferenceCategory)findPreference("pref_key_storage_settings"); 170 storageOptions.removePreference(findPreference("pref_key_mms_delete_limit")); 171 } else { 172 PreferenceCategory mmsOptions = 173 (PreferenceCategory)findPreference("pref_key_mms_settings"); 174 if (!MmsConfig.getMMSDeliveryReportsEnabled()) { 175 mmsOptions.removePreference(mMmsDeliveryReportPref); 176 } 177 if (!MmsConfig.getMMSReadReportsEnabled()) { 178 mmsOptions.removePreference(mMmsReadReportPref); 179 } 180 // If the phone's SIM doesn't know it's own number, disable group mms. 181 if (!MmsConfig.getGroupMmsEnabled() || 182 TextUtils.isEmpty(MessageUtils.getLocalNumber())) { 183 mmsOptions.removePreference(mMmsGroupMmsPref); 184 } 185 } 186 187 setEnabledNotificationsPref(); 188 189 // If needed, migrate vibration setting from the previous tri-state setting stored in 190 // NOTIFICATION_VIBRATE_WHEN to the boolean setting stored in NOTIFICATION_VIBRATE. 191 SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(this); 192 if (sharedPreferences.contains(NOTIFICATION_VIBRATE_WHEN)) { 193 String vibrateWhen = sharedPreferences. 194 getString(MessagingPreferenceActivity.NOTIFICATION_VIBRATE_WHEN, null); 195 boolean vibrate = "always".equals(vibrateWhen); 196 SharedPreferences.Editor prefsEditor = sharedPreferences.edit(); 197 prefsEditor.putBoolean(NOTIFICATION_VIBRATE, vibrate); 198 prefsEditor.remove(NOTIFICATION_VIBRATE_WHEN); // remove obsolete setting 199 prefsEditor.apply(); 200 mVibratePref.setChecked(vibrate); 201 } 202 203 mSmsRecycler = Recycler.getSmsRecycler(); 204 mMmsRecycler = Recycler.getMmsRecycler(); 205 206 // Fix up the recycler's summary with the correct values 207 setSmsDisplayLimit(); 208 setMmsDisplayLimit(); 209 210 String soundValue = sharedPreferences.getString(NOTIFICATION_RINGTONE, null); 211 setRingtoneSummary(soundValue); 212 } 213 setRingtoneSummary(String soundValue)214 private void setRingtoneSummary(String soundValue) { 215 Uri soundUri = TextUtils.isEmpty(soundValue) ? null : Uri.parse(soundValue); 216 Ringtone tone = soundUri != null ? RingtoneManager.getRingtone(this, soundUri) : null; 217 mRingtonePref.setSummary(tone != null ? tone.getTitle(this) 218 : getResources().getString(R.string.silent_ringtone)); 219 } 220 setEnabledNotificationsPref()221 private void setEnabledNotificationsPref() { 222 // The "enable notifications" setting is really stored in our own prefs. Read the 223 // current value and set the checkbox to match. 224 mEnableNotificationsPref.setChecked(getNotificationEnabled(this)); 225 } 226 setSmsDisplayLimit()227 private void setSmsDisplayLimit() { 228 mSmsLimitPref.setSummary( 229 getString(R.string.pref_summary_delete_limit, 230 mSmsRecycler.getMessageLimit(this))); 231 } 232 setMmsDisplayLimit()233 private void setMmsDisplayLimit() { 234 mMmsLimitPref.setSummary( 235 getString(R.string.pref_summary_delete_limit, 236 mMmsRecycler.getMessageLimit(this))); 237 } 238 onCreateOptionsMenu(Menu menu)239 public boolean onCreateOptionsMenu(Menu menu) { 240 super.onCreateOptionsMenu(menu); 241 menu.clear(); 242 menu.add(0, MENU_RESTORE_DEFAULTS, 0, R.string.restore_default); 243 return true; 244 } 245 246 @Override onOptionsItemSelected(MenuItem item)247 public boolean onOptionsItemSelected(MenuItem item) { 248 switch (item.getItemId()) { 249 case MENU_RESTORE_DEFAULTS: 250 restoreDefaultPreferences(); 251 return true; 252 253 case android.R.id.home: 254 // The user clicked on the Messaging icon in the action bar. Take them back from 255 // wherever they came from 256 finish(); 257 return true; 258 } 259 return false; 260 } 261 262 @Override onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference)263 public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen, 264 Preference preference) { 265 if (preference == mSmsLimitPref) { 266 new NumberPickerDialog(this, 267 mSmsLimitListener, 268 mSmsRecycler.getMessageLimit(this), 269 mSmsRecycler.getMessageMinLimit(), 270 mSmsRecycler.getMessageMaxLimit(), 271 R.string.pref_title_sms_delete).show(); 272 } else if (preference == mMmsLimitPref) { 273 new NumberPickerDialog(this, 274 mMmsLimitListener, 275 mMmsRecycler.getMessageLimit(this), 276 mMmsRecycler.getMessageMinLimit(), 277 mMmsRecycler.getMessageMaxLimit(), 278 R.string.pref_title_mms_delete).show(); 279 } else if (preference == mManageSimPref) { 280 startActivity(new Intent(this, ManageSimMessages.class)); 281 } else if (preference == mClearHistoryPref) { 282 showDialog(CONFIRM_CLEAR_SEARCH_HISTORY_DIALOG); 283 return true; 284 } else if (preference == mEnableNotificationsPref) { 285 // Update the actual "enable notifications" value that is stored in secure settings. 286 enableNotifications(mEnableNotificationsPref.isChecked(), this); 287 } else if (preference == mMmsAutoRetrievialPref) { 288 if (mMmsAutoRetrievialPref.isChecked()) { 289 startMmsDownload(); 290 } 291 } 292 293 return super.onPreferenceTreeClick(preferenceScreen, preference); 294 } 295 296 /** 297 * Trigger the TransactionService to download any outstanding messages. 298 */ startMmsDownload()299 private void startMmsDownload() { 300 startService(new Intent(TransactionService.ACTION_ENABLE_AUTO_RETRIEVE, null, this, 301 TransactionService.class)); 302 } 303 304 NumberPickerDialog.OnNumberSetListener mSmsLimitListener = 305 new NumberPickerDialog.OnNumberSetListener() { 306 public void onNumberSet(int limit) { 307 mSmsRecycler.setMessageLimit(MessagingPreferenceActivity.this, limit); 308 setSmsDisplayLimit(); 309 } 310 }; 311 312 NumberPickerDialog.OnNumberSetListener mMmsLimitListener = 313 new NumberPickerDialog.OnNumberSetListener() { 314 public void onNumberSet(int limit) { 315 mMmsRecycler.setMessageLimit(MessagingPreferenceActivity.this, limit); 316 setMmsDisplayLimit(); 317 } 318 }; 319 320 @Override onCreateDialog(int id)321 protected Dialog onCreateDialog(int id) { 322 switch (id) { 323 case CONFIRM_CLEAR_SEARCH_HISTORY_DIALOG: 324 return new AlertDialog.Builder(MessagingPreferenceActivity.this) 325 .setTitle(R.string.confirm_clear_search_title) 326 .setMessage(R.string.confirm_clear_search_text) 327 .setPositiveButton(android.R.string.ok, new AlertDialog.OnClickListener() { 328 public void onClick(DialogInterface dialog, int which) { 329 SearchRecentSuggestions recent = 330 ((MmsApp)getApplication()).getRecentSuggestions(); 331 if (recent != null) { 332 recent.clearHistory(); 333 } 334 dialog.dismiss(); 335 } 336 }) 337 .setNegativeButton(android.R.string.cancel, null) 338 .setIconAttribute(android.R.attr.alertDialogIcon) 339 .create(); 340 } 341 return super.onCreateDialog(id); 342 } 343 344 public static boolean getNotificationEnabled(Context context) { 345 SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context); 346 boolean notificationsEnabled = 347 prefs.getBoolean(MessagingPreferenceActivity.NOTIFICATION_ENABLED, true); 348 return notificationsEnabled; 349 } 350 351 public static void enableNotifications(boolean enabled, Context context) { 352 // Store the value of notifications in SharedPreferences 353 SharedPreferences.Editor editor = 354 PreferenceManager.getDefaultSharedPreferences(context).edit(); 355 356 editor.putBoolean(MessagingPreferenceActivity.NOTIFICATION_ENABLED, enabled); 357 358 editor.apply(); 359 } 360 361 private void registerListeners() { 362 mRingtonePref.setOnPreferenceChangeListener(this); 363 } 364 365 public boolean onPreferenceChange(Preference preference, Object newValue) { 366 boolean result = false; 367 if (preference == mRingtonePref) { 368 setRingtoneSummary((String)newValue); 369 result = true; 370 } 371 return result; 372 } 373 374 // For the group mms feature to be enabled, the following must be true: 375 // 1. the feature is enabled in mms_config.xml (currently on by default) 376 // 2. the feature is enabled in the mms settings page 377 // 3. the SIM knows its own phone number 378 public static boolean getIsGroupMmsEnabled(Context context) { 379 SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context); 380 boolean groupMmsPrefOn = prefs.getBoolean( 381 MessagingPreferenceActivity.GROUP_MMS_MODE, true); 382 return MmsConfig.getGroupMmsEnabled() && 383 groupMmsPrefOn && 384 !TextUtils.isEmpty(MessageUtils.getLocalNumber()); 385 } 386 } 387