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