/*
* Copyright (C) 2007 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.calendar;
import android.app.Activity;
import android.app.FragmentManager;
import android.app.backup.BackupManager;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.content.SharedPreferences.Editor;
import android.content.SharedPreferences.OnSharedPreferenceChangeListener;
import android.media.Ringtone;
import android.media.RingtoneManager;
import android.net.Uri;
import android.os.Bundle;
import android.os.Vibrator;
import android.preference.CheckBoxPreference;
import android.preference.ListPreference;
import android.preference.Preference;
import android.preference.Preference.OnPreferenceChangeListener;
import android.preference.Preference.OnPreferenceClickListener;
import android.preference.PreferenceCategory;
import android.preference.PreferenceFragment;
import android.preference.PreferenceManager;
import android.preference.PreferenceScreen;
import android.preference.RingtonePreference;
import android.provider.CalendarContract;
import android.provider.CalendarContract.CalendarCache;
import android.provider.SearchRecentSuggestions;
import android.text.TextUtils;
import android.text.format.Time;
import android.widget.Toast;
import com.android.calendar.alerts.AlertReceiver;
import com.android.timezonepicker.TimeZoneInfo;
import com.android.timezonepicker.TimeZonePickerDialog;
import com.android.timezonepicker.TimeZonePickerDialog.OnTimeZoneSetListener;
import com.android.timezonepicker.TimeZonePickerUtils;
public class GeneralPreferences extends PreferenceFragment implements
OnSharedPreferenceChangeListener, OnPreferenceChangeListener, OnTimeZoneSetListener {
// The name of the shared preferences file. This name must be maintained for historical
// reasons, as it's what PreferenceManager assigned the first time the file was created.
static final String SHARED_PREFS_NAME = "com.android.calendar_preferences";
static final String SHARED_PREFS_NAME_NO_BACKUP = "com.android.calendar_preferences_no_backup";
private static final String FRAG_TAG_TIME_ZONE_PICKER = "TimeZonePicker";
// Preference keys
public static final String KEY_HIDE_DECLINED = "preferences_hide_declined";
public static final String KEY_WEEK_START_DAY = "preferences_week_start_day";
public static final String KEY_SHOW_WEEK_NUM = "preferences_show_week_num";
public static final String KEY_DAYS_PER_WEEK = "preferences_days_per_week";
public static final String KEY_SKIP_SETUP = "preferences_skip_setup";
public static final String KEY_CLEAR_SEARCH_HISTORY = "preferences_clear_search_history";
public static final String KEY_ALERTS_CATEGORY = "preferences_alerts_category";
public static final String KEY_ALERTS = "preferences_alerts";
public static final String KEY_ALERTS_VIBRATE = "preferences_alerts_vibrate";
public static final String KEY_ALERTS_RINGTONE = "preferences_alerts_ringtone";
public static final String KEY_ALERTS_POPUP = "preferences_alerts_popup";
public static final String KEY_SHOW_CONTROLS = "preferences_show_controls";
public static final String KEY_DEFAULT_REMINDER = "preferences_default_reminder";
public static final int NO_REMINDER = -1;
public static final String NO_REMINDER_STRING = "-1";
public static final int REMINDER_DEFAULT_TIME = 10; // in minutes
public static final String KEY_DEFAULT_CELL_HEIGHT = "preferences_default_cell_height";
public static final String KEY_VERSION = "preferences_version";
/** Key to SharePreference for default view (CalendarController.ViewType) */
public static final String KEY_START_VIEW = "preferred_startView";
/**
* Key to SharePreference for default detail view (CalendarController.ViewType)
* Typically used by widget
*/
public static final String KEY_DETAILED_VIEW = "preferred_detailedView";
public static final String KEY_DEFAULT_CALENDAR = "preference_defaultCalendar";
// These must be in sync with the array preferences_week_start_day_values
public static final String WEEK_START_DEFAULT = "-1";
public static final String WEEK_START_SATURDAY = "7";
public static final String WEEK_START_SUNDAY = "1";
public static final String WEEK_START_MONDAY = "2";
// These keys are kept to enable migrating users from previous versions
private static final String KEY_ALERTS_TYPE = "preferences_alerts_type";
private static final String ALERT_TYPE_ALERTS = "0";
private static final String ALERT_TYPE_STATUS_BAR = "1";
private static final String ALERT_TYPE_OFF = "2";
static final String KEY_HOME_TZ_ENABLED = "preferences_home_tz_enabled";
static final String KEY_HOME_TZ = "preferences_home_tz";
// Default preference values
public static final int DEFAULT_START_VIEW = CalendarController.ViewType.WEEK;
public static final int DEFAULT_DETAILED_VIEW = CalendarController.ViewType.DAY;
public static final boolean DEFAULT_SHOW_WEEK_NUM = false;
// This should match the XML file.
public static final String DEFAULT_RINGTONE = "content://settings/system/notification_sound";
CheckBoxPreference mAlert;
CheckBoxPreference mVibrate;
RingtonePreference mRingtone;
CheckBoxPreference mPopup;
CheckBoxPreference mUseHomeTZ;
CheckBoxPreference mHideDeclined;
Preference mHomeTZ;
TimeZonePickerUtils mTzPickerUtils;
ListPreference mWeekStart;
ListPreference mDefaultReminder;
private String mTimeZoneId;
/** Return a properly configured SharedPreferences instance */
public static SharedPreferences getSharedPreferences(Context context) {
return context.getSharedPreferences(SHARED_PREFS_NAME, Context.MODE_PRIVATE);
}
/** Set the default shared preferences in the proper context */
public static void setDefaultValues(Context context) {
PreferenceManager.setDefaultValues(context, SHARED_PREFS_NAME, Context.MODE_PRIVATE,
R.xml.general_preferences, false);
}
@Override
public void onCreate(Bundle icicle) {
super.onCreate(icicle);
final Activity activity = getActivity();
// Make sure to always use the same preferences file regardless of the package name
// we're running under
final PreferenceManager preferenceManager = getPreferenceManager();
final SharedPreferences sharedPreferences = getSharedPreferences(activity);
preferenceManager.setSharedPreferencesName(SHARED_PREFS_NAME);
// Load the preferences from an XML resource
addPreferencesFromResource(R.xml.general_preferences);
final PreferenceScreen preferenceScreen = getPreferenceScreen();
mAlert = (CheckBoxPreference) preferenceScreen.findPreference(KEY_ALERTS);
mVibrate = (CheckBoxPreference) preferenceScreen.findPreference(KEY_ALERTS_VIBRATE);
Vibrator vibrator = (Vibrator) activity.getSystemService(Context.VIBRATOR_SERVICE);
if (vibrator == null || !vibrator.hasVibrator()) {
PreferenceCategory mAlertGroup = (PreferenceCategory) preferenceScreen
.findPreference(KEY_ALERTS_CATEGORY);
mAlertGroup.removePreference(mVibrate);
}
mRingtone = (RingtonePreference) preferenceScreen.findPreference(KEY_ALERTS_RINGTONE);
String ringToneUri = Utils.getRingTonePreference(activity);
// Set the ringToneUri to the backup-able shared pref only so that
// the Ringtone dialog will open up with the correct value.
final Editor editor = preferenceScreen.getEditor();
editor.putString(GeneralPreferences.KEY_ALERTS_RINGTONE, ringToneUri).apply();
String ringtoneDisplayString = getRingtoneTitleFromUri(activity, ringToneUri);
mRingtone.setSummary(ringtoneDisplayString == null ? "" : ringtoneDisplayString);
mPopup = (CheckBoxPreference) preferenceScreen.findPreference(KEY_ALERTS_POPUP);
mUseHomeTZ = (CheckBoxPreference) preferenceScreen.findPreference(KEY_HOME_TZ_ENABLED);
mHideDeclined = (CheckBoxPreference) preferenceScreen.findPreference(KEY_HIDE_DECLINED);
mWeekStart = (ListPreference) preferenceScreen.findPreference(KEY_WEEK_START_DAY);
mDefaultReminder = (ListPreference) preferenceScreen.findPreference(KEY_DEFAULT_REMINDER);
mHomeTZ = preferenceScreen.findPreference(KEY_HOME_TZ);
mWeekStart.setSummary(mWeekStart.getEntry());
mDefaultReminder.setSummary(mDefaultReminder.getEntry());
// This triggers an asynchronous call to the provider to refresh the data in shared pref
mTimeZoneId = Utils.getTimeZone(activity, null);
SharedPreferences prefs = CalendarUtils.getSharedPreferences(activity,
Utils.SHARED_PREFS_NAME);
// Utils.getTimeZone will return the currentTimeZone instead of the one
// in the shared_pref if home time zone is disabled. So if home tz is
// off, we will explicitly read it.
if (!prefs.getBoolean(KEY_HOME_TZ_ENABLED, false)) {
mTimeZoneId = prefs.getString(KEY_HOME_TZ, Time.getCurrentTimezone());
}
mHomeTZ.setOnPreferenceClickListener(new OnPreferenceClickListener() {
@Override
public boolean onPreferenceClick(Preference preference) {
showTimezoneDialog();
return true;
}
});
if (mTzPickerUtils == null) {
mTzPickerUtils = new TimeZonePickerUtils(getActivity());
}
CharSequence timezoneName = mTzPickerUtils.getGmtDisplayName(getActivity(), mTimeZoneId,
System.currentTimeMillis(), false);
mHomeTZ.setSummary(timezoneName != null ? timezoneName : mTimeZoneId);
TimeZonePickerDialog tzpd = (TimeZonePickerDialog) activity.getFragmentManager()
.findFragmentByTag(FRAG_TAG_TIME_ZONE_PICKER);
if (tzpd != null) {
tzpd.setOnTimeZoneSetListener(this);
}
migrateOldPreferences(sharedPreferences);
updateChildPreferences();
}
private void showTimezoneDialog() {
final Activity activity = getActivity();
if (activity == null) {
return;
}
Bundle b = new Bundle();
b.putLong(TimeZonePickerDialog.BUNDLE_START_TIME_MILLIS, System.currentTimeMillis());
b.putString(TimeZonePickerDialog.BUNDLE_TIME_ZONE, Utils.getTimeZone(activity, null));
FragmentManager fm = getActivity().getFragmentManager();
TimeZonePickerDialog tzpd = (TimeZonePickerDialog) fm
.findFragmentByTag(FRAG_TAG_TIME_ZONE_PICKER);
if (tzpd != null) {
tzpd.dismiss();
}
tzpd = new TimeZonePickerDialog();
tzpd.setArguments(b);
tzpd.setOnTimeZoneSetListener(this);
tzpd.show(fm, FRAG_TAG_TIME_ZONE_PICKER);
}
@Override
public void onStart() {
super.onStart();
getPreferenceScreen().getSharedPreferences()
.registerOnSharedPreferenceChangeListener(this);
setPreferenceListeners(this);
}
/**
* Sets up all the preference change listeners to use the specified
* listener.
*/
private void setPreferenceListeners(OnPreferenceChangeListener listener) {
mUseHomeTZ.setOnPreferenceChangeListener(listener);
mHomeTZ.setOnPreferenceChangeListener(listener);
mWeekStart.setOnPreferenceChangeListener(listener);
mDefaultReminder.setOnPreferenceChangeListener(listener);
mRingtone.setOnPreferenceChangeListener(listener);
mHideDeclined.setOnPreferenceChangeListener(listener);
mVibrate.setOnPreferenceChangeListener(listener);
}
@Override
public void onStop() {
getPreferenceScreen().getSharedPreferences()
.unregisterOnSharedPreferenceChangeListener(this);
setPreferenceListeners(null);
super.onStop();
}
@Override
public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {
Activity a = getActivity();
if (key.equals(KEY_ALERTS)) {
updateChildPreferences();
if (a != null) {
Intent intent = new Intent();
intent.setClass(a, AlertReceiver.class);
if (mAlert.isChecked()) {
intent.setAction(AlertReceiver.ACTION_DISMISS_OLD_REMINDERS);
} else {
intent.setAction(AlertReceiver.EVENT_REMINDER_APP_ACTION);
}
a.sendBroadcast(intent);
}
}
if (a != null) {
BackupManager.dataChanged(a.getPackageName());
}
}
/**
* Handles time zone preference changes
*/
@Override
public boolean onPreferenceChange(Preference preference, Object newValue) {
String tz;
final Activity activity = getActivity();
if (preference == mUseHomeTZ) {
if ((Boolean)newValue) {
tz = mTimeZoneId;
} else {
tz = CalendarCache.TIMEZONE_TYPE_AUTO;
}
Utils.setTimeZone(activity, tz);
return true;
} else if (preference == mHideDeclined) {
mHideDeclined.setChecked((Boolean) newValue);
Intent intent = new Intent(Utils.getWidgetScheduledUpdateAction(activity));
intent.setDataAndType(CalendarContract.CONTENT_URI, Utils.APPWIDGET_DATA_TYPE);
activity.sendBroadcast(intent);
return true;
} else if (preference == mWeekStart) {
mWeekStart.setValue((String) newValue);
mWeekStart.setSummary(mWeekStart.getEntry());
} else if (preference == mDefaultReminder) {
mDefaultReminder.setValue((String) newValue);
mDefaultReminder.setSummary(mDefaultReminder.getEntry());
} else if (preference == mRingtone) {
if (newValue instanceof String) {
Utils.setRingTonePreference(activity, (String) newValue);
String ringtone = getRingtoneTitleFromUri(activity, (String) newValue);
mRingtone.setSummary(ringtone == null ? "" : ringtone);
}
return true;
} else if (preference == mVibrate) {
mVibrate.setChecked((Boolean) newValue);
return true;
} else {
return true;
}
return false;
}
public String getRingtoneTitleFromUri(Context context, String uri) {
if (TextUtils.isEmpty(uri)) {
return null;
}
Ringtone ring = RingtoneManager.getRingtone(getActivity(), Uri.parse(uri));
if (ring != null) {
return ring.getTitle(context);
}
return null;
}
/**
* If necessary, upgrades previous versions of preferences to the current
* set of keys and values.
* @param prefs the preferences to upgrade
*/
private void migrateOldPreferences(SharedPreferences prefs) {
// If needed, migrate vibration setting from a previous version
mVibrate.setChecked(Utils.getDefaultVibrate(getActivity(), prefs));
// If needed, migrate the old alerts type settin
if (!prefs.contains(KEY_ALERTS) && prefs.contains(KEY_ALERTS_TYPE)) {
String type = prefs.getString(KEY_ALERTS_TYPE, ALERT_TYPE_STATUS_BAR);
if (type.equals(ALERT_TYPE_OFF)) {
mAlert.setChecked(false);
mPopup.setChecked(false);
mPopup.setEnabled(false);
} else if (type.equals(ALERT_TYPE_STATUS_BAR)) {
mAlert.setChecked(true);
mPopup.setChecked(false);
mPopup.setEnabled(true);
} else if (type.equals(ALERT_TYPE_ALERTS)) {
mAlert.setChecked(true);
mPopup.setChecked(true);
mPopup.setEnabled(true);
}
// clear out the old setting
prefs.edit().remove(KEY_ALERTS_TYPE).commit();
}
}
/**
* Keeps the dependent settings in sync with the parent preference, so for
* example, when notifications are turned off, we disable the preferences
* for configuring the exact notification behavior.
*/
private void updateChildPreferences() {
if (mAlert.isChecked()) {
mVibrate.setEnabled(true);
mRingtone.setEnabled(true);
mPopup.setEnabled(true);
} else {
mVibrate.setEnabled(false);
mRingtone.setEnabled(false);
mPopup.setEnabled(false);
}
}
@Override
public boolean onPreferenceTreeClick(
PreferenceScreen preferenceScreen, Preference preference) {
final String key = preference.getKey();
if (KEY_CLEAR_SEARCH_HISTORY.equals(key)) {
SearchRecentSuggestions suggestions = new SearchRecentSuggestions(getActivity(),
Utils.getSearchAuthority(getActivity()),
CalendarRecentSuggestionsProvider.MODE);
suggestions.clearHistory();
Toast.makeText(getActivity(), R.string.search_history_cleared,
Toast.LENGTH_SHORT).show();
return true;
} else {
return super.onPreferenceTreeClick(preferenceScreen, preference);
}
}
@Override
public void onTimeZoneSet(TimeZoneInfo tzi) {
if (mTzPickerUtils == null) {
mTzPickerUtils = new TimeZonePickerUtils(getActivity());
}
final CharSequence timezoneName = mTzPickerUtils.getGmtDisplayName(
getActivity(), tzi.mTzId, System.currentTimeMillis(), false);
mHomeTZ.setSummary(timezoneName);
Utils.setTimeZone(getActivity(), tzi.mTzId);
}
}