1 /*
2  * Copyright (C) 2015 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.notification;
18 
19 import android.app.AlertDialog;
20 import android.app.AutomaticZenRule;
21 import android.app.Dialog;
22 import android.app.DialogFragment;
23 import android.app.FragmentManager;
24 import android.app.TimePickerDialog;
25 import android.content.Context;
26 import android.content.DialogInterface;
27 import android.content.DialogInterface.OnDismissListener;
28 import android.os.Bundle;
29 import android.provider.Settings;
30 import android.service.notification.ZenModeConfig;
31 import android.service.notification.ZenModeConfig.ScheduleInfo;
32 import android.support.v14.preference.SwitchPreference;
33 import android.support.v7.preference.Preference;
34 import android.support.v7.preference.Preference.OnPreferenceClickListener;
35 import android.support.v7.preference.PreferenceScreen;
36 import android.text.format.DateFormat;
37 import android.util.Log;
38 import android.widget.TimePicker;
39 
40 import com.android.internal.logging.MetricsProto.MetricsEvent;
41 import com.android.settings.R;
42 
43 import java.text.SimpleDateFormat;
44 import java.util.Arrays;
45 import java.util.Calendar;
46 
47 import static com.android.settings.notification.ZenModeScheduleDaysSelection.DAYS;
48 
49 public class ZenModeScheduleRuleSettings extends ZenModeRuleSettingsBase {
50     private static final String KEY_DAYS = "days";
51     private static final String KEY_START_TIME = "start_time";
52     private static final String KEY_END_TIME = "end_time";
53     private static final String KEY_EXIT_AT_ALARM = "exit_at_alarm";
54 
55     public static final String ACTION = Settings.ACTION_ZEN_MODE_SCHEDULE_RULE_SETTINGS;
56 
57     // per-instance to ensure we're always using the current locale
58     private final SimpleDateFormat mDayFormat = new SimpleDateFormat("EEE");
59 
60     private Preference mDays;
61     private TimePickerPreference mStart;
62     private TimePickerPreference mEnd;
63     private SwitchPreference mExitAtAlarm;
64 
65     private ScheduleInfo mSchedule;
66 
67     @Override
setRule(AutomaticZenRule rule)68     protected boolean setRule(AutomaticZenRule rule) {
69         mSchedule = rule != null ? ZenModeConfig.tryParseScheduleConditionId(rule.getConditionId())
70                 : null;
71         return mSchedule != null;
72     }
73 
74     @Override
getZenModeDependency()75     protected String getZenModeDependency() {
76         return mDays.getKey();
77     }
78 
79     @Override
getEnabledToastText()80     protected int getEnabledToastText() {
81         return R.string.zen_schedule_rule_enabled_toast;
82     }
83 
84     @Override
onCreateInternal()85     protected void onCreateInternal() {
86         addPreferencesFromResource(R.xml.zen_mode_schedule_rule_settings);
87         final PreferenceScreen root = getPreferenceScreen();
88 
89         mDays = root.findPreference(KEY_DAYS);
90         mDays.setOnPreferenceClickListener(new OnPreferenceClickListener() {
91             @Override
92             public boolean onPreferenceClick(Preference preference) {
93                 showDaysDialog();
94                 return true;
95             }
96         });
97 
98         final FragmentManager mgr = getFragmentManager();
99 
100         mStart = new TimePickerPreference(getPrefContext(), mgr);
101         mStart.setKey(KEY_START_TIME);
102         mStart.setTitle(R.string.zen_mode_start_time);
103         mStart.setCallback(new TimePickerPreference.Callback() {
104             @Override
105             public boolean onSetTime(final int hour, final int minute) {
106                 if (mDisableListeners) return true;
107                 if (!ZenModeConfig.isValidHour(hour)) return false;
108                 if (!ZenModeConfig.isValidMinute(minute)) return false;
109                 if (hour == mSchedule.startHour && minute == mSchedule.startMinute) {
110                     return true;
111                 }
112                 if (DEBUG) Log.d(TAG, "onPrefChange start h=" + hour + " m=" + minute);
113                 mSchedule.startHour = hour;
114                 mSchedule.startMinute = minute;
115                 updateRule(ZenModeConfig.toScheduleConditionId(mSchedule));
116                 return true;
117             }
118         });
119         root.addPreference(mStart);
120         mStart.setDependency(mDays.getKey());
121 
122         mEnd = new TimePickerPreference(getPrefContext(), mgr);
123         mEnd.setKey(KEY_END_TIME);
124         mEnd.setTitle(R.string.zen_mode_end_time);
125         mEnd.setCallback(new TimePickerPreference.Callback() {
126             @Override
127             public boolean onSetTime(final int hour, final int minute) {
128                 if (mDisableListeners) return true;
129                 if (!ZenModeConfig.isValidHour(hour)) return false;
130                 if (!ZenModeConfig.isValidMinute(minute)) return false;
131                 if (hour == mSchedule.endHour && minute == mSchedule.endMinute) {
132                     return true;
133                 }
134                 if (DEBUG) Log.d(TAG, "onPrefChange end h=" + hour + " m=" + minute);
135                 mSchedule.endHour = hour;
136                 mSchedule.endMinute = minute;
137                 updateRule(ZenModeConfig.toScheduleConditionId(mSchedule));
138                 return true;
139             }
140         });
141         root.addPreference(mEnd);
142         mEnd.setDependency(mDays.getKey());
143 
144         mExitAtAlarm = (SwitchPreference) root.findPreference(KEY_EXIT_AT_ALARM);
145         mExitAtAlarm.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {
146             @Override
147             public boolean onPreferenceChange(Preference preference, Object o) {
148                 mSchedule.exitAtAlarm = (Boolean) o;
149                 updateRule(ZenModeConfig.toScheduleConditionId(mSchedule));
150                 return true;
151             }
152         });
153     }
154 
updateDays()155     private void updateDays() {
156         // Compute an ordered, delimited list of day names based on the persisted user config.
157         final int[] days = mSchedule.days;
158         if (days != null && days.length > 0) {
159             final StringBuilder sb = new StringBuilder();
160             final Calendar c = Calendar.getInstance();
161             for (int i = 0; i < DAYS.length; i++) {
162                 final int day = DAYS[i];
163                 for (int j = 0; j < days.length; j++) {
164                     if (day == days[j]) {
165                         c.set(Calendar.DAY_OF_WEEK, day);
166                         if (sb.length() > 0) {
167                             sb.append(mContext.getString(R.string.summary_divider_text));
168                         }
169                         sb.append(mDayFormat.format(c.getTime()));
170                         break;
171                     }
172                 }
173             }
174             if (sb.length() > 0) {
175                 mDays.setSummary(sb);
176                 mDays.notifyDependencyChange(false);
177                 return;
178             }
179         }
180         mDays.setSummary(R.string.zen_mode_schedule_rule_days_none);
181         mDays.notifyDependencyChange(true);
182     }
183 
updateEndSummary()184     private void updateEndSummary() {
185         final int startMin = 60 * mSchedule.startHour + mSchedule.startMinute;
186         final int endMin = 60 * mSchedule.endHour + mSchedule.endMinute;
187         final boolean nextDay = startMin >= endMin;
188         final int summaryFormat = nextDay ? R.string.zen_mode_end_time_next_day_summary_format : 0;
189         mEnd.setSummaryFormat(summaryFormat);
190     }
191 
192     @Override
updateControlsInternal()193     protected void updateControlsInternal() {
194         updateDays();
195         mStart.setTime(mSchedule.startHour, mSchedule.startMinute);
196         mEnd.setTime(mSchedule.endHour, mSchedule.endMinute);
197         mExitAtAlarm.setChecked(mSchedule.exitAtAlarm);
198         updateEndSummary();
199     }
200 
201     @Override
getMetricsCategory()202     protected int getMetricsCategory() {
203         return MetricsEvent.NOTIFICATION_ZEN_MODE_SCHEDULE_RULE;
204     }
205 
showDaysDialog()206     private void showDaysDialog() {
207         new AlertDialog.Builder(mContext)
208                 .setTitle(R.string.zen_mode_schedule_rule_days)
209                 .setView(new ZenModeScheduleDaysSelection(mContext, mSchedule.days) {
210                       @Override
211                       protected void onChanged(final int[] days) {
212                           if (mDisableListeners) return;
213                           if (Arrays.equals(days, mSchedule.days)) return;
214                           if (DEBUG) Log.d(TAG, "days.onChanged days=" + Arrays.asList(days));
215                           mSchedule.days = days;
216                           updateRule(ZenModeConfig.toScheduleConditionId(mSchedule));
217                       }
218                 })
219                 .setOnDismissListener(new OnDismissListener() {
220                     @Override
221                     public void onDismiss(DialogInterface dialog) {
222                         updateDays();
223                     }
224                 })
225                 .setPositiveButton(R.string.done_button, null)
226                 .show();
227     }
228 
229     private static class TimePickerPreference extends Preference {
230         private final Context mContext;
231 
232         private int mSummaryFormat;
233         private int mHourOfDay;
234         private int mMinute;
235         private Callback mCallback;
236 
TimePickerPreference(Context context, final FragmentManager mgr)237         public TimePickerPreference(Context context, final FragmentManager mgr) {
238             super(context);
239             mContext = context;
240             setPersistent(false);
241             setOnPreferenceClickListener(new OnPreferenceClickListener(){
242                 @Override
243                 public boolean onPreferenceClick(Preference preference) {
244                     final TimePickerFragment frag = new TimePickerFragment();
245                     frag.pref = TimePickerPreference.this;
246                     frag.show(mgr, TimePickerPreference.class.getName());
247                     return true;
248                 }
249             });
250         }
251 
setCallback(Callback callback)252         public void setCallback(Callback callback) {
253             mCallback = callback;
254         }
255 
setSummaryFormat(int resId)256         public void setSummaryFormat(int resId) {
257             mSummaryFormat = resId;
258             updateSummary();
259         }
260 
setTime(int hourOfDay, int minute)261         public void setTime(int hourOfDay, int minute) {
262             if (mCallback != null && !mCallback.onSetTime(hourOfDay, minute)) return;
263             mHourOfDay = hourOfDay;
264             mMinute = minute;
265             updateSummary();
266         }
267 
updateSummary()268         private void updateSummary() {
269             final Calendar c = Calendar.getInstance();
270             c.set(Calendar.HOUR_OF_DAY, mHourOfDay);
271             c.set(Calendar.MINUTE, mMinute);
272             String time = DateFormat.getTimeFormat(mContext).format(c.getTime());
273             if (mSummaryFormat != 0) {
274                 time = mContext.getResources().getString(mSummaryFormat, time);
275             }
276             setSummary(time);
277         }
278 
279         public static class TimePickerFragment extends DialogFragment implements
280                 TimePickerDialog.OnTimeSetListener {
281             public TimePickerPreference pref;
282 
283             @Override
onCreateDialog(Bundle savedInstanceState)284             public Dialog onCreateDialog(Bundle savedInstanceState) {
285                 final boolean usePref = pref != null && pref.mHourOfDay >= 0 && pref.mMinute >= 0;
286                 final Calendar c = Calendar.getInstance();
287                 final int hour = usePref ? pref.mHourOfDay : c.get(Calendar.HOUR_OF_DAY);
288                 final int minute = usePref ? pref.mMinute : c.get(Calendar.MINUTE);
289                 return new TimePickerDialog(getActivity(), this, hour, minute,
290                         DateFormat.is24HourFormat(getActivity()));
291             }
292 
onTimeSet(TimePicker view, int hourOfDay, int minute)293             public void onTimeSet(TimePicker view, int hourOfDay, int minute) {
294                 if (pref != null) {
295                     pref.setTime(hourOfDay, minute);
296                 }
297             }
298         }
299 
300         public interface Callback {
onSetTime(int hour, int minute)301             boolean onSetTime(int hour, int minute);
302         }
303     }
304 
305 }
306