235 lines
8.6 KiB
Java
235 lines
8.6 KiB
Java
|
/*
|
||
|
|
* Copyright (c) 2017 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 android.service.notification;
|
||
|
|
|
||
|
|
import android.service.notification.ZenModeConfig.ScheduleInfo;
|
||
|
|
import android.util.ArraySet;
|
||
|
|
import android.util.Log;
|
||
|
|
|
||
|
|
import com.android.internal.annotations.VisibleForTesting;
|
||
|
|
|
||
|
|
import java.util.Calendar;
|
||
|
|
import java.util.Objects;
|
||
|
|
import java.util.TimeZone;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
public class ScheduleCalendar {
|
||
|
|
public static final String TAG = "ScheduleCalendar";
|
||
|
|
public static final boolean DEBUG = Log.isLoggable("ConditionProviders", Log.DEBUG);
|
||
|
|
private final ArraySet<Integer> mDays = new ArraySet<Integer>();
|
||
|
|
private final Calendar mCalendar = Calendar.getInstance();
|
||
|
|
|
||
|
|
private ScheduleInfo mSchedule;
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public String toString() {
|
||
|
|
return "ScheduleCalendar[mDays=" + mDays + ", mSchedule=" + mSchedule + "]";
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @return true if schedule will exit on alarm, else false
|
||
|
|
*/
|
||
|
|
public boolean exitAtAlarm() {
|
||
|
|
return mSchedule.exitAtAlarm;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Sets schedule information
|
||
|
|
*/
|
||
|
|
public void setSchedule(ScheduleInfo schedule) {
|
||
|
|
if (Objects.equals(mSchedule, schedule)) return;
|
||
|
|
mSchedule = schedule;
|
||
|
|
updateDays();
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Sets next alarm of the schedule
|
||
|
|
* @param now current time in milliseconds
|
||
|
|
* @param nextAlarm time of next alarm in milliseconds
|
||
|
|
*/
|
||
|
|
public void maybeSetNextAlarm(long now, long nextAlarm) {
|
||
|
|
if (mSchedule != null && mSchedule.exitAtAlarm) {
|
||
|
|
if (nextAlarm == 0) {
|
||
|
|
// alarm canceled
|
||
|
|
mSchedule.nextAlarm = 0;
|
||
|
|
} else if (nextAlarm > now) {
|
||
|
|
// only allow alarms in the future
|
||
|
|
mSchedule.nextAlarm = nextAlarm;
|
||
|
|
} else if (mSchedule.nextAlarm < now) {
|
||
|
|
if (DEBUG) {
|
||
|
|
Log.d(TAG, "All alarms are in the past " + mSchedule.nextAlarm);
|
||
|
|
}
|
||
|
|
mSchedule.nextAlarm = 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Set calendar time zone to tz
|
||
|
|
* @param tz current time zone
|
||
|
|
*/
|
||
|
|
public void setTimeZone(TimeZone tz) {
|
||
|
|
mCalendar.setTimeZone(tz);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @param now current time in milliseconds
|
||
|
|
* @return next time this rule changes (starts or ends)
|
||
|
|
*/
|
||
|
|
public long getNextChangeTime(long now) {
|
||
|
|
if (mSchedule == null) return 0;
|
||
|
|
final long nextStart = getNextTime(now, mSchedule.startHour, mSchedule.startMinute, true);
|
||
|
|
final long nextEnd = getNextTime(now, mSchedule.endHour, mSchedule.endMinute, false);
|
||
|
|
long nextScheduleTime = Math.min(nextStart, nextEnd);
|
||
|
|
|
||
|
|
return nextScheduleTime;
|
||
|
|
}
|
||
|
|
|
||
|
|
private long getNextTime(long now, int hr, int min, boolean adjust) {
|
||
|
|
// The adjust parameter indicates whether to potentially adjust the time to the closest
|
||
|
|
// actual time if the indicated time is one skipped due to daylight time.
|
||
|
|
final long time = adjust ? getClosestActualTime(now, hr, min) : getTime(now, hr, min);
|
||
|
|
if (time <= now) {
|
||
|
|
final long tomorrow = addDays(time, 1);
|
||
|
|
return adjust ? getClosestActualTime(tomorrow, hr, min) : getTime(tomorrow, hr, min);
|
||
|
|
}
|
||
|
|
return time;
|
||
|
|
}
|
||
|
|
|
||
|
|
private long getTime(long millis, int hour, int min) {
|
||
|
|
mCalendar.setTimeInMillis(millis);
|
||
|
|
mCalendar.set(Calendar.HOUR_OF_DAY, hour);
|
||
|
|
mCalendar.set(Calendar.MINUTE, min);
|
||
|
|
mCalendar.set(Calendar.SECOND, 0);
|
||
|
|
mCalendar.set(Calendar.MILLISECOND, 0);
|
||
|
|
return mCalendar.getTimeInMillis();
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @param time milliseconds since Epoch
|
||
|
|
* @return true if time is within the schedule, else false
|
||
|
|
*/
|
||
|
|
public boolean isInSchedule(long time) {
|
||
|
|
if (mSchedule == null || mDays.size() == 0) return false;
|
||
|
|
final long start = getClosestActualTime(time, mSchedule.startHour, mSchedule.startMinute);
|
||
|
|
long end = getTime(time, mSchedule.endHour, mSchedule.endMinute);
|
||
|
|
if (end <= start) {
|
||
|
|
end = addDays(end, 1);
|
||
|
|
}
|
||
|
|
return isInSchedule(-1, time, start, end) || isInSchedule(0, time, start, end);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @param alarm milliseconds since Epoch
|
||
|
|
* @param now milliseconds since Epoch
|
||
|
|
* @return true if alarm and now is within the schedule, else false
|
||
|
|
*/
|
||
|
|
public boolean isAlarmInSchedule(long alarm, long now) {
|
||
|
|
if (mSchedule == null || mDays.size() == 0) return false;
|
||
|
|
final long start = getClosestActualTime(alarm, mSchedule.startHour, mSchedule.startMinute);
|
||
|
|
long end = getTime(alarm, mSchedule.endHour, mSchedule.endMinute);
|
||
|
|
if (end <= start) {
|
||
|
|
end = addDays(end, 1);
|
||
|
|
}
|
||
|
|
return (isInSchedule(-1, alarm, start, end)
|
||
|
|
&& isInSchedule(-1, now, start, end))
|
||
|
|
|| (isInSchedule(0, alarm, start, end)
|
||
|
|
&& isInSchedule(0, now, start, end));
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @param time milliseconds since Epoch
|
||
|
|
* @return true if should exit at time for next alarm, else false
|
||
|
|
*/
|
||
|
|
public boolean shouldExitForAlarm(long time) {
|
||
|
|
if (mSchedule == null) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
return mSchedule.exitAtAlarm
|
||
|
|
&& mSchedule.nextAlarm != 0
|
||
|
|
&& time >= mSchedule.nextAlarm
|
||
|
|
&& isAlarmInSchedule(mSchedule.nextAlarm, time);
|
||
|
|
}
|
||
|
|
|
||
|
|
private boolean isInSchedule(int daysOffset, long time, long start, long end) {
|
||
|
|
final int n = Calendar.SATURDAY;
|
||
|
|
final int day = ((getDayOfWeek(time) - 1) + (daysOffset % n) + n) % n + 1;
|
||
|
|
start = addDays(start, daysOffset);
|
||
|
|
end = addDays(end, daysOffset);
|
||
|
|
return mDays.contains(day) && time >= start && time < end;
|
||
|
|
}
|
||
|
|
|
||
|
|
private int getDayOfWeek(long time) {
|
||
|
|
mCalendar.setTimeInMillis(time);
|
||
|
|
return mCalendar.get(Calendar.DAY_OF_WEEK);
|
||
|
|
}
|
||
|
|
|
||
|
|
private void updateDays() {
|
||
|
|
mDays.clear();
|
||
|
|
if (mSchedule != null && mSchedule.days != null) {
|
||
|
|
for (int i = 0; i < mSchedule.days.length; i++) {
|
||
|
|
mDays.add(mSchedule.days[i]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private long addDays(long time, int days) {
|
||
|
|
mCalendar.setTimeInMillis(time);
|
||
|
|
mCalendar.add(Calendar.DATE, days);
|
||
|
|
return mCalendar.getTimeInMillis();
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* This function returns the closest "actual" time to the provided hour/minute relative to the
|
||
|
|
* reference time. For most times this will behave exactly the same as getTime, but for any time
|
||
|
|
* during the hour skipped forward for daylight savings time (for instance, 02:xx when the
|
||
|
|
* clock is set to 03:00 after 01:59), this method will return the time when the clock changes
|
||
|
|
* (in this example, 03:00).
|
||
|
|
*
|
||
|
|
* Assumptions made in this implementation:
|
||
|
|
* - Time is moved forward on an hour boundary (minute 0) by exactly 1hr when clocks shift
|
||
|
|
* - a lenient Calendar implementation will interpret 02:xx on a day when 2-3AM is skipped
|
||
|
|
* as 03:xx
|
||
|
|
* - The skipped hour is never 11PM / 23:00.
|
||
|
|
*
|
||
|
|
* @hide
|
||
|
|
*/
|
||
|
|
@VisibleForTesting
|
||
|
|
public long getClosestActualTime(long refTime, int hour, int min) {
|
||
|
|
long resTime = getTime(refTime, hour, min);
|
||
|
|
if (!mCalendar.getTimeZone().observesDaylightTime()) {
|
||
|
|
// Do nothing if the timezone doesn't observe daylight time at all.
|
||
|
|
return resTime;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Approach to identifying whether the time is "skipped": get the result from starting with
|
||
|
|
// refTime and setting hour and minute, then re-extract the hour and minute of the resulting
|
||
|
|
// moment in time. If the hour is exactly one more than the passed-in hour and the minute is
|
||
|
|
// the same, then the provided hour is likely a skipped one. If the time doesn't fall into
|
||
|
|
// this category, return the unmodified time instead.
|
||
|
|
mCalendar.setTimeInMillis(resTime);
|
||
|
|
int resHr = mCalendar.get(Calendar.HOUR_OF_DAY);
|
||
|
|
int resMin = mCalendar.get(Calendar.MINUTE);
|
||
|
|
if (resHr == hour + 1 && resMin == min) {
|
||
|
|
return getTime(refTime, resHr, 0);
|
||
|
|
}
|
||
|
|
return resTime;
|
||
|
|
}
|
||
|
|
}
|