src/com/android/settings/DateTimeSettings.java

   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.settings;
  18
  19 import android.app.Activity;
  20 import android.app.DatePickerDialog;
  21 import android.app.Dialog;
  22 import android.app.TimePickerDialog;
  23 import android.content.BroadcastReceiver;
  24 import android.content.Context;
  25 import android.content.Intent;
  26 import android.content.IntentFilter;
  27 import android.content.SharedPreferences;
  28 import android.content.SharedPreferences.OnSharedPreferenceChangeListener;
  29 import android.os.Bundle;
  30 import android.os.SystemClock;
  31 import android.preference.CheckBoxPreference;
  32 import android.preference.ListPreference;
  33 import android.preference.Preference;
  34 import android.preference.PreferenceScreen;
  35 import android.provider.Settings;
  36 import android.provider.Settings.SettingNotFoundException;
  37 import android.text.format.DateFormat;
  38 import android.widget.DatePicker;
  39 import android.widget.TimePicker;
  40
  41 import java.util.Calendar;
  42 import java.util.Date;
  43 import java.util.TimeZone;
  44
  45 public class DateTimeSettings extends SettingsPreferenceFragment
  46         implements OnSharedPreferenceChangeListener,
  47                 TimePickerDialog.OnTimeSetListener, DatePickerDialog.OnDateSetListener {
  48
  49     private static final String HOURS_12 = "12";
  50     private static final String HOURS_24 = "24";
  51
  52     // Used for showing the current date format, which looks like "12/31/2010", "2010/12/13", etc.
  53     // The date value is dummy (independent of actual date).
  54     private Calendar mDummyDate;
  55
  56     private static final String KEY_DATE_FORMAT = "date_format";
  57     private static final String KEY_AUTO_TIME = "auto_time";
  58     private static final String KEY_AUTO_TIME_ZONE = "auto_zone";
  59
  60     private static final int DIALOG_DATEPICKER = 0;
  61     private static final int DIALOG_TIMEPICKER = 1;
  62
  63     private CheckBoxPreference mAutoTimePref;
  64     private Preference mTimePref;
  65     private Preference mTime24Pref;
  66     private CheckBoxPreference mAutoTimeZonePref;
  67     private Preference mTimeZone;
  68     private Preference mDatePref;
  69     private ListPreference mDateFormat;
  70
  71     @Override
  72     public void onCreate(Bundle icicle) {
  73         super.onCreate(icicle);
  74
  75         addPreferencesFromResource(R.xml.date_time_prefs);
  76
  77         initUI();
  78     }
  79
  80     private void initUI() {
  81         boolean autoTimeEnabled = getAutoState(Settings.System.AUTO_TIME);
  82         boolean autoTimeZoneEnabled = getAutoState(Settings.System.AUTO_TIME_ZONE);
  83
  84         mDummyDate = Calendar.getInstance();
  85         mDummyDate.set(mDummyDate.get(Calendar.YEAR), 11, 31, 13, 0, 0);
  86
  87         mAutoTimePref = (CheckBoxPreference) findPreference(KEY_AUTO_TIME);
  88         mAutoTimePref.setChecked(autoTimeEnabled);
  89         mTimePref = findPreference("time");
  90         mTime24Pref = findPreference("24 hour");
  91         mTimeZone = findPreference("timezone");
  92         mDatePref = findPreference("date");
  93         mDateFormat = (ListPreference) findPreference(KEY_DATE_FORMAT);
  94
  95         String [] dateFormats = getResources().getStringArray(R.array.date_format_values);
  96         String [] formattedDates = new String[dateFormats.length];
  97         String currentFormat = getDateFormat();
  98         // Initialize if DATE_FORMAT is not set in the system settings
  99         // This can happen after a factory reset (or data wipe)
 100         if (currentFormat == null) {
 101             currentFormat = "";
 102         }
 103         for (int i = 0; i < formattedDates.length; i++) {
 104             String formatted =
 105                     DateFormat.getDateFormatForSetting(getActivity(), dateFormats[i])
 106                     .format(mDummyDate.getTime());
 107
 108             if (dateFormats[i].length() == 0) {
 109                 formattedDates[i] = getResources().
 110                     getString(R.string.normal_date_format, formatted);
 111             } else {
 112                 formattedDates[i] = formatted;
 113             }
 114         }
 115
 116         mDateFormat.setEntries(formattedDates);
 117         mDateFormat.setEntryValues(R.array.date_format_values);
 118         mDateFormat.setValue(currentFormat);
 119
 120         mTimePref.setEnabled(!autoTimeEnabled);
 121         mDatePref.setEnabled(!autoTimeEnabled);
 122         mTimeZone.setEnabled(!autoTimeZoneEnabled);
 123     }
 124
 125
 126     @Override
 127     public void onResume() {
 128         super.onResume();
 129
 130         getPreferenceScreen().getSharedPreferences()
 131                 .registerOnSharedPreferenceChangeListener(this);
 132
 133         ((CheckBoxPreference)mTime24Pref).setChecked(is24Hour());
 134
 135         // Register for time ticks and other reasons for time change
 136         IntentFilter filter = new IntentFilter();
 137         filter.addAction(Intent.ACTION_TIME_TICK);
 138         filter.addAction(Intent.ACTION_TIME_CHANGED);
 139         filter.addAction(Intent.ACTION_TIMEZONE_CHANGED);
 140         getActivity().registerReceiver(mIntentReceiver, filter, null, null);
 141
 142         updateTimeAndDateDisplay(getActivity());
 143     }
 144
 145     @Override
 146     public void onPause() {
 147         super.onPause();
 148         getActivity().unregisterReceiver(mIntentReceiver);
 149         getPreferenceScreen().getSharedPreferences()
 150                 .unregisterOnSharedPreferenceChangeListener(this);
 151     }
 152
 153     private void updateTimeAndDateDisplay(Context context) {
 154         java.text.DateFormat shortDateFormat = DateFormat.getDateFormat(context);
 155         final Calendar now = Calendar.getInstance();
 156         Date dummyDate = mDummyDate.getTime();
 157         mTimePref.setSummary(DateFormat.getTimeFormat(getActivity()).format(now.getTime()));
 158         mTimeZone.setSummary(getTimeZoneText(now.getTimeZone()));
 159         mDatePref.setSummary(shortDateFormat.format(now.getTime()));
 160         mDateFormat.setSummary(shortDateFormat.format(dummyDate));
 161     }
 162
 163     @Override
 164     public void onDateSet(DatePicker view, int year, int month, int day) {
 165         setDate(year, month, day);
 166         final Activity activity = getActivity();
 167         if (activity != null) {
 168             updateTimeAndDateDisplay(activity);
 169         }
 170     }
 171
 172     @Override
 173     public void onTimeSet(TimePicker view, int hourOfDay, int minute) {
 174         setTime(hourOfDay, minute);
 175         final Activity activity = getActivity();
 176         if (activity != null) {
 177             updateTimeAndDateDisplay(activity);
 178         }
 179
 180         // We don't need to call timeUpdated() here because the TIME_CHANGED
 181         // broadcast is sent by the AlarmManager as a side effect of setting the
 182         // SystemClock time.
 183     }
 184
 185     @Override
 186     public void onSharedPreferenceChanged(SharedPreferences preferences, String key) {
 187         if (key.equals(KEY_DATE_FORMAT)) {
 188             String format = preferences.getString(key,
 189                     getResources().getString(R.string.default_date_format));
 190             Settings.System.putString(getContentResolver(),
 191                     Settings.System.DATE_FORMAT, format);
 192             updateTimeAndDateDisplay(getActivity());
 193         } else if (key.equals(KEY_AUTO_TIME)) {
 194             boolean autoEnabled = preferences.getBoolean(key, true);
 195             Settings.System.putInt(getContentResolver(), Settings.System.AUTO_TIME,
 196                     autoEnabled ? 1 : 0);
 197             mTimePref.setEnabled(!autoEnabled);
 198             mDatePref.setEnabled(!autoEnabled);
 199         } else if (key.equals(KEY_AUTO_TIME_ZONE)) {
 200             boolean autoZoneEnabled = preferences.getBoolean(key, true);
 201             Settings.System.putInt(
 202                     getContentResolver(), Settings.System.AUTO_TIME_ZONE, autoZoneEnabled ? 1 : 0);
 203             mTimeZone.setEnabled(!autoZoneEnabled);
 204         }
 205     }
 206
 207     @Override
 208     public Dialog onCreateDialog(int id) {
 209         Dialog d;
 210
 211         switch (id) {
 212         case DIALOG_DATEPICKER: {
 213             final Calendar calendar = Calendar.getInstance();
 214             d = new DatePickerDialog(
 215                 getActivity(),
 216                 this,
 217                 calendar.get(Calendar.YEAR),
 218                 calendar.get(Calendar.MONTH),
 219                 calendar.get(Calendar.DAY_OF_MONTH));
 220             d.setTitle(getResources().getString(R.string.date_time_changeDate_text));
 221             break;
 222         }
 223         case DIALOG_TIMEPICKER: {
 224             final Calendar calendar = Calendar.getInstance();
 225             d = new TimePickerDialog(
 226                     getActivity(),
 227                     this,
 228                     calendar.get(Calendar.HOUR_OF_DAY),
 229                     calendar.get(Calendar.MINUTE),
 230                     DateFormat.is24HourFormat(getActivity()));
 231             d.setTitle(getResources().getString(R.string.date_time_changeTime_text));
 232             break;
 233         }
 234         default:
 235             d = null;
 236             break;
 237         }
 238
 239         return d;
 240     }
 241
 242     /*
 243     @Override
 244     public void onPrepareDialog(int id, Dialog d) {
 245         switch (id) {
 246         case DIALOG_DATEPICKER: {
 247             DatePickerDialog datePicker = (DatePickerDialog)d;
 248             final Calendar calendar = Calendar.getInstance();
 249             datePicker.updateDate(
 250                     calendar.get(Calendar.YEAR),
 251                     calendar.get(Calendar.MONTH),
 252                     calendar.get(Calendar.DAY_OF_MONTH));
 253             break;
 254         }
 255         case DIALOG_TIMEPICKER: {
 256             TimePickerDialog timePicker = (TimePickerDialog)d;
 257             final Calendar calendar = Calendar.getInstance();
 258             timePicker.updateTime(
 259                     calendar.get(Calendar.HOUR_OF_DAY),
 260                     calendar.get(Calendar.MINUTE));
 261             break;
 262         }
 263         default:
 264             break;
 265         }
 266     }
 267     */
 268     @Override
 269     public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference) {
 270         if (preference == mDatePref) {
 271             showDialog(DIALOG_DATEPICKER);
 272         } else if (preference == mTimePref) {
 273             // The 24-hour mode may have changed, so recreate the dialog
 274             removeDialog(DIALOG_TIMEPICKER);
 275             showDialog(DIALOG_TIMEPICKER);
 276         } else if (preference == mTime24Pref) {
 277             set24Hour(((CheckBoxPreference)mTime24Pref).isChecked());
 278             updateTimeAndDateDisplay(getActivity());
 279             timeUpdated();
 280         }
 281         return super.onPreferenceTreeClick(preferenceScreen, preference);
 282     }
 283
 284     @Override
 285     public void onActivityResult(int requestCode, int resultCode,
 286             Intent data) {
 287         updateTimeAndDateDisplay(getActivity());
 288     }
 289
 290     private void timeUpdated() {
 291         Intent timeChanged = new Intent(Intent.ACTION_TIME_CHANGED);
 292         getActivity().sendBroadcast(timeChanged);
 293     }
 294
 295     /*  Get & Set values from the system settings  */
 296
 297     private boolean is24Hour() {
 298         return DateFormat.is24HourFormat(getActivity());
 299     }
 300
 301     private void set24Hour(boolean is24Hour) {
 302         Settings.System.putString(getContentResolver(),
 303                 Settings.System.TIME_12_24,
 304                 is24Hour? HOURS_24 : HOURS_12);
 305     }
 306
 307     private String getDateFormat() {
 308         return Settings.System.getString(getContentResolver(),
 309                 Settings.System.DATE_FORMAT);
 310     }
 311
 312     private boolean getAutoState(String name) {
 313         try {
 314             return Settings.System.getInt(getContentResolver(), name) > 0;
 315         } catch (SettingNotFoundException snfe) {
 316             return true;
 317         }
 318     }
 319
 320     /*  Helper routines to format timezone */
 321
 322     /* package */ static void setDate(int year, int month, int day) {
 323         Calendar c = Calendar.getInstance();
 324
 325         c.set(Calendar.YEAR, year);
 326         c.set(Calendar.MONTH, month);
 327         c.set(Calendar.DAY_OF_MONTH, day);
 328         long when = c.getTimeInMillis();
 329
 330         if (when / 1000 < Integer.MAX_VALUE) {
 331             SystemClock.setCurrentTimeMillis(when);
 332         }
 333     }
 334
 335     /* package */ static void setTime(int hourOfDay, int minute) {
 336         Calendar c = Calendar.getInstance();
 337
 338         c.set(Calendar.HOUR_OF_DAY, hourOfDay);
 339         c.set(Calendar.MINUTE, minute);
 340         long when = c.getTimeInMillis();
 341
 342         if (when / 1000 < Integer.MAX_VALUE) {
 343             SystemClock.setCurrentTimeMillis(when);
 344         }
 345     }
 346
 347     /* package */ static String getTimeZoneText(TimeZone tz) {
 348         boolean daylight = tz.inDaylightTime(new Date());
 349         StringBuilder sb = new StringBuilder();
 350
 351         sb.append(formatOffset(tz.getRawOffset() +
 352                                (daylight ? tz.getDSTSavings() : 0))).
 353             append(", ").
 354             append(tz.getDisplayName(daylight, TimeZone.LONG));
 355
 356         return sb.toString();
 357     }
 358
 359     private static char[] formatOffset(int off) {
 360         off = off / 1000 / 60;
 361
 362         char[] buf = new char[9];
 363         buf[0] = 'G';
 364         buf[1] = 'M';
 365         buf[2] = 'T';
 366
 367         if (off < 0) {
 368             buf[3] = '-';
 369             off = -off;
 370         } else {
 371             buf[3] = '+';
 372         }
 373
 374         int hours = off / 60;
 375         int minutes = off % 60;
 376
 377         buf[4] = (char) ('0' + hours / 10);
 378         buf[5] = (char) ('0' + hours % 10);
 379
 380         buf[6] = ':';
 381
 382         buf[7] = (char) ('0' + minutes / 10);
 383         buf[8] = (char) ('0' + minutes % 10);
 384
 385         return buf;
 386     }
 387
 388     private BroadcastReceiver mIntentReceiver = new BroadcastReceiver() {
 389         @Override
 390         public void onReceive(Context context, Intent intent) {
 391             final Activity activity = getActivity();
 392             if (activity != null) {
 393                 updateTimeAndDateDisplay(activity);
 394             }
 395         }
 396     };
 397 }