core/java/android/service/notification/ScheduleCalendar.java - platform/frameworks/base - Git at Google

 /*
  * 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;
     }
 }
	/*
	* 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;
	}
	}