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