| /* |
| * Copyright (C) 2008 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 com.android.calendar.alerts; |
| |
| import android.app.Notification; |
| import android.app.NotificationManager; |
| import android.app.Service; |
| import android.content.ContentResolver; |
| import android.content.ContentUris; |
| import android.content.ContentValues; |
| import android.content.Context; |
| import android.content.Intent; |
| import android.content.SharedPreferences; |
| import android.database.Cursor; |
| import android.net.Uri; |
| import android.os.Bundle; |
| import android.os.Handler; |
| import android.os.HandlerThread; |
| import android.os.IBinder; |
| import android.os.Looper; |
| import android.os.Message; |
| import android.os.Process; |
| import android.provider.CalendarContract; |
| import android.provider.CalendarContract.Attendees; |
| import android.provider.CalendarContract.CalendarAlerts; |
| import android.text.TextUtils; |
| import android.text.format.DateUtils; |
| import android.text.format.Time; |
| import android.util.Log; |
| |
| import com.android.calendar.GeneralPreferences; |
| import com.android.calendar.OtherPreferences; |
| import com.android.calendar.R; |
| import com.android.calendar.Utils; |
| |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.TimeZone; |
| |
| /** |
| * This service is used to handle calendar event reminders. |
| */ |
| public class AlertService extends Service { |
| static final boolean DEBUG = true; |
| private static final String TAG = "AlertService"; |
| |
| private volatile Looper mServiceLooper; |
| private volatile ServiceHandler mServiceHandler; |
| |
| static final String[] ALERT_PROJECTION = new String[] { |
| CalendarAlerts._ID, // 0 |
| CalendarAlerts.EVENT_ID, // 1 |
| CalendarAlerts.STATE, // 2 |
| CalendarAlerts.TITLE, // 3 |
| CalendarAlerts.EVENT_LOCATION, // 4 |
| CalendarAlerts.SELF_ATTENDEE_STATUS, // 5 |
| CalendarAlerts.ALL_DAY, // 6 |
| CalendarAlerts.ALARM_TIME, // 7 |
| CalendarAlerts.MINUTES, // 8 |
| CalendarAlerts.BEGIN, // 9 |
| CalendarAlerts.END, // 10 |
| CalendarAlerts.DESCRIPTION, // 11 |
| }; |
| |
| private static final int ALERT_INDEX_ID = 0; |
| private static final int ALERT_INDEX_EVENT_ID = 1; |
| private static final int ALERT_INDEX_STATE = 2; |
| private static final int ALERT_INDEX_TITLE = 3; |
| private static final int ALERT_INDEX_EVENT_LOCATION = 4; |
| private static final int ALERT_INDEX_SELF_ATTENDEE_STATUS = 5; |
| private static final int ALERT_INDEX_ALL_DAY = 6; |
| private static final int ALERT_INDEX_ALARM_TIME = 7; |
| private static final int ALERT_INDEX_MINUTES = 8; |
| private static final int ALERT_INDEX_BEGIN = 9; |
| private static final int ALERT_INDEX_END = 10; |
| private static final int ALERT_INDEX_DESCRIPTION = 11; |
| |
| private static final String ACTIVE_ALERTS_SELECTION = "(" + CalendarAlerts.STATE + "=? OR " |
| + CalendarAlerts.STATE + "=?) AND " + CalendarAlerts.ALARM_TIME + "<="; |
| |
| private static final String[] ACTIVE_ALERTS_SELECTION_ARGS = new String[] { |
| Integer.toString(CalendarAlerts.STATE_FIRED), |
| Integer.toString(CalendarAlerts.STATE_SCHEDULED) |
| }; |
| |
| private static final String ACTIVE_ALERTS_SORT = "begin DESC, end DESC"; |
| |
| private static final String DISMISS_OLD_SELECTION = CalendarAlerts.END + "<? AND " |
| + CalendarAlerts.STATE + "=?"; |
| |
| private static final int MINUTE_MS = 60 * 1000; |
| |
| // The grace period before changing a notification's priority bucket. |
| private static final int MIN_DEPRIORITIZE_GRACE_PERIOD_MS = 15 * MINUTE_MS; |
| |
| // Hard limit to the number of notifications displayed. |
| public static final int MAX_NOTIFICATIONS = 20; |
| |
| // Shared prefs key for storing whether the EVENT_REMINDER event from the provider |
| // was ever received. Some OEMs modified this provider broadcast, so we had to |
| // do the alarm scheduling here in the app, for the unbundled app's reminders to work. |
| // If the EVENT_REMINDER event was ever received, we know we can skip our secondary |
| // alarm scheduling. |
| private static final String PROVIDER_REMINDER_PREF_KEY = |
| "preference_received_provider_reminder_broadcast"; |
| private static Boolean sReceivedProviderReminderBroadcast = null; |
| |
| // Added wrapper for testing |
| public static class NotificationWrapper { |
| Notification mNotification; |
| long mEventId; |
| long mBegin; |
| long mEnd; |
| ArrayList<NotificationWrapper> mNw; |
| |
| public NotificationWrapper(Notification n, int notificationId, long eventId, |
| long startMillis, long endMillis, boolean doPopup) { |
| mNotification = n; |
| mEventId = eventId; |
| mBegin = startMillis; |
| mEnd = endMillis; |
| |
| // popup? |
| // notification id? |
| } |
| |
| public NotificationWrapper(Notification n) { |
| mNotification = n; |
| } |
| |
| public void add(NotificationWrapper nw) { |
| if (mNw == null) { |
| mNw = new ArrayList<NotificationWrapper>(); |
| } |
| mNw.add(nw); |
| } |
| } |
| |
| // Added wrapper for testing |
| public static class NotificationMgrWrapper extends NotificationMgr { |
| NotificationManager mNm; |
| |
| public NotificationMgrWrapper(NotificationManager nm) { |
| mNm = nm; |
| } |
| |
| @Override |
| public void cancel(int id) { |
| mNm.cancel(id); |
| } |
| |
| @Override |
| public void notify(int id, NotificationWrapper nw) { |
| mNm.notify(id, nw.mNotification); |
| } |
| } |
| |
| void processMessage(Message msg) { |
| Bundle bundle = (Bundle) msg.obj; |
| |
| // On reboot, update the notification bar with the contents of the |
| // CalendarAlerts table. |
| String action = bundle.getString("action"); |
| if (DEBUG) { |
| Log.d(TAG, bundle.getLong(android.provider.CalendarContract.CalendarAlerts.ALARM_TIME) |
| + " Action = " + action); |
| } |
| |
| // Some OEMs had changed the provider's EVENT_REMINDER broadcast to their own event, |
| // which broke our unbundled app's reminders. So we added backup alarm scheduling to the |
| // app, but we know we can turn it off if we ever receive the EVENT_REMINDER broadcast. |
| boolean providerReminder = action.equals( |
| android.provider.CalendarContract.ACTION_EVENT_REMINDER); |
| if (providerReminder) { |
| if (sReceivedProviderReminderBroadcast == null) { |
| sReceivedProviderReminderBroadcast = Utils.getSharedPreference(this, |
| PROVIDER_REMINDER_PREF_KEY, false); |
| } |
| |
| if (!sReceivedProviderReminderBroadcast) { |
| sReceivedProviderReminderBroadcast = true; |
| Log.d(TAG, "Setting key " + PROVIDER_REMINDER_PREF_KEY + " to: true"); |
| Utils.setSharedPreference(this, PROVIDER_REMINDER_PREF_KEY, true); |
| } |
| } |
| |
| if (providerReminder || |
| action.equals(Intent.ACTION_PROVIDER_CHANGED) || |
| action.equals(android.provider.CalendarContract.ACTION_EVENT_REMINDER) || |
| action.equals(AlertReceiver.EVENT_REMINDER_APP_ACTION) || |
| action.equals(Intent.ACTION_LOCALE_CHANGED)) { |
| |
| // b/7652098: Add a delay after the provider-changed event before refreshing |
| // notifications to help issue with the unbundled app installed on HTC having |
| // stale notifications. |
| if (action.equals(Intent.ACTION_PROVIDER_CHANGED)) { |
| try { |
| Thread.sleep(5000); |
| } catch (Exception e) { |
| // Ignore. |
| } |
| } |
| |
| updateAlertNotification(this); |
| } else if (action.equals(Intent.ACTION_BOOT_COMPLETED)) { |
| // The provider usually initiates this setting up of alarms on startup, |
| // but there was a bug (b/7221716) where a race condition caused this step to be |
| // skipped, resulting in missed alarms. This is a stopgap to minimize this bug |
| // for devices that don't have the provider fix, by initiating this a 2nd time here. |
| // However, it would still theoretically be possible to hit the race condition |
| // the 2nd time and still miss alarms. |
| // |
| // TODO: Remove this when the provider fix is rolled out everywhere. |
| Intent intent = new Intent(); |
| intent.setClass(this, InitAlarmsService.class); |
| startService(intent); |
| } else if (action.equals(Intent.ACTION_TIME_CHANGED)) { |
| doTimeChanged(); |
| } else if (action.equals(AlertReceiver.ACTION_DISMISS_OLD_REMINDERS)) { |
| dismissOldAlerts(this); |
| } else { |
| Log.w(TAG, "Invalid action: " + action); |
| } |
| |
| // Schedule the alarm for the next upcoming reminder, if not done by the provider. |
| if (sReceivedProviderReminderBroadcast == null || !sReceivedProviderReminderBroadcast) { |
| Log.d(TAG, "Scheduling next alarm with AlarmScheduler. " |
| + "sEventReminderReceived: " + sReceivedProviderReminderBroadcast); |
| AlarmScheduler.scheduleNextAlarm(this); |
| } |
| } |
| |
| static void dismissOldAlerts(Context context) { |
| ContentResolver cr = context.getContentResolver(); |
| final long currentTime = System.currentTimeMillis(); |
| ContentValues vals = new ContentValues(); |
| vals.put(CalendarAlerts.STATE, CalendarAlerts.STATE_DISMISSED); |
| cr.update(CalendarAlerts.CONTENT_URI, vals, DISMISS_OLD_SELECTION, new String[] { |
| Long.toString(currentTime), Integer.toString(CalendarAlerts.STATE_SCHEDULED) |
| }); |
| } |
| |
| static boolean updateAlertNotification(Context context) { |
| ContentResolver cr = context.getContentResolver(); |
| NotificationMgr nm = new NotificationMgrWrapper( |
| (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE)); |
| final long currentTime = System.currentTimeMillis(); |
| SharedPreferences prefs = GeneralPreferences.getSharedPreferences(context); |
| |
| if (DEBUG) { |
| Log.d(TAG, "Beginning updateAlertNotification"); |
| } |
| |
| if (!prefs.getBoolean(GeneralPreferences.KEY_ALERTS, true)) { |
| if (DEBUG) { |
| Log.d(TAG, "alert preference is OFF"); |
| } |
| |
| // If we shouldn't be showing notifications cancel any existing ones |
| // and return. |
| nm.cancelAll(); |
| return true; |
| } |
| |
| Cursor alertCursor = cr.query(CalendarAlerts.CONTENT_URI, ALERT_PROJECTION, |
| (ACTIVE_ALERTS_SELECTION + currentTime), ACTIVE_ALERTS_SELECTION_ARGS, |
| ACTIVE_ALERTS_SORT); |
| |
| if (alertCursor == null || alertCursor.getCount() == 0) { |
| if (alertCursor != null) { |
| alertCursor.close(); |
| } |
| |
| if (DEBUG) Log.d(TAG, "No fired or scheduled alerts"); |
| nm.cancelAll(); |
| return false; |
| } |
| |
| return generateAlerts(context, nm, AlertUtils.createAlarmManager(context), prefs, |
| alertCursor, currentTime, MAX_NOTIFICATIONS); |
| } |
| |
| public static boolean generateAlerts(Context context, NotificationMgr nm, |
| AlarmManagerInterface alarmMgr, SharedPreferences prefs, Cursor alertCursor, |
| final long currentTime, final int maxNotifications) { |
| if (DEBUG) { |
| Log.d(TAG, "alertCursor count:" + alertCursor.getCount()); |
| } |
| |
| // Process the query results and bucketize events. |
| ArrayList<NotificationInfo> highPriorityEvents = new ArrayList<NotificationInfo>(); |
| ArrayList<NotificationInfo> mediumPriorityEvents = new ArrayList<NotificationInfo>(); |
| ArrayList<NotificationInfo> lowPriorityEvents = new ArrayList<NotificationInfo>(); |
| int numFired = processQuery(alertCursor, context, currentTime, highPriorityEvents, |
| mediumPriorityEvents, lowPriorityEvents); |
| |
| if (highPriorityEvents.size() + mediumPriorityEvents.size() |
| + lowPriorityEvents.size() == 0) { |
| nm.cancelAll(); |
| return true; |
| } |
| |
| long nextRefreshTime = Long.MAX_VALUE; |
| int currentNotificationId = 1; |
| NotificationPrefs notificationPrefs = new NotificationPrefs(context, prefs, |
| (numFired == 0)); |
| |
| // If there are more high/medium priority events than we can show, bump some to |
| // the low priority digest. |
| redistributeBuckets(highPriorityEvents, mediumPriorityEvents, lowPriorityEvents, |
| maxNotifications); |
| |
| // Post the individual higher priority events (future and recently started |
| // concurrent events). Order these so that earlier start times appear higher in |
| // the notification list. |
| for (int i = 0; i < highPriorityEvents.size(); i++) { |
| NotificationInfo info = highPriorityEvents.get(i); |
| String summaryText = AlertUtils.formatTimeLocation(context, info.startMillis, |
| info.allDay, info.location); |
| postNotification(info, summaryText, context, true, notificationPrefs, nm, |
| currentNotificationId++); |
| |
| // Keep concurrent events high priority (to appear higher in the notification list) |
| // until 15 minutes into the event. |
| nextRefreshTime = Math.min(nextRefreshTime, getNextRefreshTime(info, currentTime)); |
| } |
| |
| // Post the medium priority events (concurrent events that started a while ago). |
| // Order these so more recent start times appear higher in the notification list. |
| // |
| // TODO: Post these with the same notification priority level as the higher priority |
| // events, so that all notifications will be co-located together. |
| for (int i = mediumPriorityEvents.size() - 1; i >= 0; i--) { |
| NotificationInfo info = mediumPriorityEvents.get(i); |
| // TODO: Change to a relative time description like: "Started 40 minutes ago". |
| // This requires constant refreshing to the message as time goes. |
| String summaryText = AlertUtils.formatTimeLocation(context, info.startMillis, |
| info.allDay, info.location); |
| postNotification(info, summaryText, context, false, notificationPrefs, nm, |
| currentNotificationId++); |
| |
| // Refresh when concurrent event ends so it will drop into the expired digest. |
| nextRefreshTime = Math.min(nextRefreshTime, getNextRefreshTime(info, currentTime)); |
| } |
| |
| // Post the low priority events as 1 combined notification. |
| int numLowPriority = lowPriorityEvents.size(); |
| if (numLowPriority > 0) { |
| String expiredDigestTitle = getDigestTitle(lowPriorityEvents); |
| NotificationWrapper notification; |
| if (numLowPriority == 1) { |
| // If only 1 expired event, display an "old-style" basic alert. |
| NotificationInfo info = lowPriorityEvents.get(0); |
| String summaryText = AlertUtils.formatTimeLocation(context, info.startMillis, |
| info.allDay, info.location); |
| notification = AlertReceiver.makeBasicNotification(context, info.eventName, |
| summaryText, info.startMillis, info.endMillis, info.eventId, |
| AlertUtils.EXPIRED_GROUP_NOTIFICATION_ID, false, |
| Notification.PRIORITY_MIN); |
| } else { |
| // Multiple expired events are listed in a digest. |
| notification = AlertReceiver.makeDigestNotification(context, |
| lowPriorityEvents, expiredDigestTitle, false); |
| } |
| |
| // Add options for a quiet update. |
| addNotificationOptions(notification, true, expiredDigestTitle, |
| notificationPrefs.getDefaultVibrate(), |
| notificationPrefs.getRingtoneAndSilence(), |
| false); /* Do not show the LED for the expired events. */ |
| |
| if (DEBUG) { |
| Log.d(TAG, "Quietly posting digest alarm notification, numEvents:" + numLowPriority |
| + ", notificationId:" + AlertUtils.EXPIRED_GROUP_NOTIFICATION_ID); |
| } |
| |
| // Post the new notification for the group. |
| nm.notify(AlertUtils.EXPIRED_GROUP_NOTIFICATION_ID, notification); |
| } else { |
| nm.cancel(AlertUtils.EXPIRED_GROUP_NOTIFICATION_ID); |
| if (DEBUG) { |
| Log.d(TAG, "No low priority events, canceling the digest notification."); |
| } |
| } |
| |
| // Remove the notifications that are hanging around from the previous refresh. |
| if (currentNotificationId <= maxNotifications) { |
| nm.cancelAllBetween(currentNotificationId, maxNotifications); |
| if (DEBUG) { |
| Log.d(TAG, "Canceling leftover notification IDs " + currentNotificationId + "-" |
| + maxNotifications); |
| } |
| } |
| |
| // Schedule the next silent refresh time so notifications will change |
| // buckets (eg. drop into expired digest, etc). |
| if (nextRefreshTime < Long.MAX_VALUE && nextRefreshTime > currentTime) { |
| AlertUtils.scheduleNextNotificationRefresh(context, alarmMgr, nextRefreshTime); |
| if (DEBUG) { |
| long minutesBeforeRefresh = (nextRefreshTime - currentTime) / MINUTE_MS; |
| Time time = new Time(); |
| time.set(nextRefreshTime); |
| String msg = String.format("Scheduling next notification refresh in %d min at: " |
| + "%d:%02d", minutesBeforeRefresh, time.hour, time.minute); |
| Log.d(TAG, msg); |
| } |
| } else if (nextRefreshTime < currentTime) { |
| Log.e(TAG, "Illegal state: next notification refresh time found to be in the past."); |
| } |
| |
| // Flushes old fired alerts from internal storage, if needed. |
| AlertUtils.flushOldAlertsFromInternalStorage(context); |
| |
| return true; |
| } |
| |
| /** |
| * Redistributes events in the priority lists based on the max # of notifications we |
| * can show. |
| */ |
| static void redistributeBuckets(ArrayList<NotificationInfo> highPriorityEvents, |
| ArrayList<NotificationInfo> mediumPriorityEvents, |
| ArrayList<NotificationInfo> lowPriorityEvents, int maxNotifications) { |
| |
| // If too many high priority alerts, shift the remaining high priority and all the |
| // medium priority ones to the low priority bucket. Note that order is important |
| // here; these lists are sorted by descending start time. Maintain that ordering |
| // so posted notifications are in the expected order. |
| if (highPriorityEvents.size() > maxNotifications) { |
| // Move mid-priority to the digest. |
| lowPriorityEvents.addAll(0, mediumPriorityEvents); |
| |
| // Move the rest of the high priority ones (latest ones) to the digest. |
| List<NotificationInfo> itemsToMoveSublist = highPriorityEvents.subList( |
| 0, highPriorityEvents.size() - maxNotifications); |
| // TODO: What order for high priority in the digest? |
| lowPriorityEvents.addAll(0, itemsToMoveSublist); |
| if (DEBUG) { |
| logEventIdsBumped(mediumPriorityEvents, itemsToMoveSublist); |
| } |
| mediumPriorityEvents.clear(); |
| // Clearing the sublist view removes the items from the highPriorityEvents list. |
| itemsToMoveSublist.clear(); |
| } |
| |
| // Bump the medium priority events if necessary. |
| if (mediumPriorityEvents.size() + highPriorityEvents.size() > maxNotifications) { |
| int spaceRemaining = maxNotifications - highPriorityEvents.size(); |
| |
| // Reached our max, move the rest to the digest. Since these are concurrent |
| // events, we move the ones with the earlier start time first since they are |
| // further in the past and less important. |
| List<NotificationInfo> itemsToMoveSublist = mediumPriorityEvents.subList( |
| spaceRemaining, mediumPriorityEvents.size()); |
| lowPriorityEvents.addAll(0, itemsToMoveSublist); |
| if (DEBUG) { |
| logEventIdsBumped(itemsToMoveSublist, null); |
| } |
| |
| // Clearing the sublist view removes the items from the mediumPriorityEvents list. |
| itemsToMoveSublist.clear(); |
| } |
| } |
| |
| private static void logEventIdsBumped(List<NotificationInfo> list1, |
| List<NotificationInfo> list2) { |
| StringBuilder ids = new StringBuilder(); |
| if (list1 != null) { |
| for (NotificationInfo info : list1) { |
| ids.append(info.eventId); |
| ids.append(","); |
| } |
| } |
| if (list2 != null) { |
| for (NotificationInfo info : list2) { |
| ids.append(info.eventId); |
| ids.append(","); |
| } |
| } |
| if (ids.length() > 0 && ids.charAt(ids.length() - 1) == ',') { |
| ids.setLength(ids.length() - 1); |
| } |
| if (ids.length() > 0) { |
| Log.d(TAG, "Reached max postings, bumping event IDs {" + ids.toString() |
| + "} to digest."); |
| } |
| } |
| |
| private static long getNextRefreshTime(NotificationInfo info, long currentTime) { |
| long startAdjustedForAllDay = info.startMillis; |
| long endAdjustedForAllDay = info.endMillis; |
| if (info.allDay) { |
| Time t = new Time(); |
| startAdjustedForAllDay = Utils.convertAlldayUtcToLocal(t, info.startMillis, |
| Time.getCurrentTimezone()); |
| endAdjustedForAllDay = Utils.convertAlldayUtcToLocal(t, info.startMillis, |
| Time.getCurrentTimezone()); |
| } |
| |
| // We change an event's priority bucket at 15 minutes into the event or 1/4 event duration. |
| long nextRefreshTime = Long.MAX_VALUE; |
| long gracePeriodCutoff = startAdjustedForAllDay + |
| getGracePeriodMs(startAdjustedForAllDay, endAdjustedForAllDay, info.allDay); |
| if (gracePeriodCutoff > currentTime) { |
| nextRefreshTime = Math.min(nextRefreshTime, gracePeriodCutoff); |
| } |
| |
| // ... and at the end (so expiring ones drop into a digest). |
| if (endAdjustedForAllDay > currentTime && endAdjustedForAllDay > gracePeriodCutoff) { |
| nextRefreshTime = Math.min(nextRefreshTime, endAdjustedForAllDay); |
| } |
| return nextRefreshTime; |
| } |
| |
| /** |
| * Processes the query results and bucketizes the alerts. |
| * |
| * @param highPriorityEvents This will contain future events, and concurrent events |
| * that started recently (less than the interval DEPRIORITIZE_GRACE_PERIOD_MS). |
| * @param mediumPriorityEvents This will contain concurrent events that started |
| * more than DEPRIORITIZE_GRACE_PERIOD_MS ago. |
| * @param lowPriorityEvents Will contain events that have ended. |
| * @return Returns the number of new alerts to fire. If this is 0, it implies |
| * a quiet update. |
| */ |
| static int processQuery(final Cursor alertCursor, final Context context, |
| final long currentTime, ArrayList<NotificationInfo> highPriorityEvents, |
| ArrayList<NotificationInfo> mediumPriorityEvents, |
| ArrayList<NotificationInfo> lowPriorityEvents) { |
| // Experimental reminder setting to only remind for events that have |
| // been responded to with "yes" or "maybe". |
| String skipRemindersPref = Utils.getSharedPreference(context, |
| OtherPreferences.KEY_OTHER_REMINDERS_RESPONDED, ""); |
| // Skip no-response events if the "Skip Reminders" preference has the second option, |
| // "If declined or not responded", is selected. |
| // Note that by default, the first option will be selected, so this will be false. |
| boolean remindRespondedOnly = skipRemindersPref.equals(context.getResources(). |
| getStringArray(R.array.preferences_skip_reminders_values)[1]); |
| // Experimental reminder setting to silence reminders when they are |
| // during the pre-defined quiet hours. |
| boolean useQuietHours = Utils.getSharedPreference(context, |
| OtherPreferences.KEY_OTHER_QUIET_HOURS, false); |
| // Note that the start time may be either before or after the end time, |
| // depending on whether quiet hours cross through midnight. |
| int quietHoursStartHour = |
| OtherPreferences.QUIET_HOURS_DEFAULT_START_HOUR; |
| int quietHoursStartMinute = |
| OtherPreferences.QUIET_HOURS_DEFAULT_START_MINUTE; |
| int quietHoursEndHour = |
| OtherPreferences.QUIET_HOURS_DEFAULT_END_HOUR; |
| int quietHoursEndMinute = |
| OtherPreferences.QUIET_HOURS_DEFAULT_END_MINUTE; |
| if (useQuietHours) { |
| quietHoursStartHour = Utils.getSharedPreference(context, |
| OtherPreferences.KEY_OTHER_QUIET_HOURS_START_HOUR, |
| OtherPreferences.QUIET_HOURS_DEFAULT_START_HOUR); |
| quietHoursStartMinute = Utils.getSharedPreference(context, |
| OtherPreferences.KEY_OTHER_QUIET_HOURS_START_MINUTE, |
| OtherPreferences.QUIET_HOURS_DEFAULT_START_MINUTE); |
| quietHoursEndHour = Utils.getSharedPreference(context, |
| OtherPreferences.KEY_OTHER_QUIET_HOURS_END_HOUR, |
| OtherPreferences.QUIET_HOURS_DEFAULT_END_HOUR); |
| quietHoursEndMinute = Utils.getSharedPreference(context, |
| OtherPreferences.KEY_OTHER_QUIET_HOURS_END_MINUTE, |
| OtherPreferences.QUIET_HOURS_DEFAULT_END_MINUTE); |
| } |
| Time time = new Time(); |
| |
| ContentResolver cr = context.getContentResolver(); |
| HashMap<Long, NotificationInfo> eventIds = new HashMap<Long, NotificationInfo>(); |
| int numFired = 0; |
| try { |
| while (alertCursor.moveToNext()) { |
| final long alertId = alertCursor.getLong(ALERT_INDEX_ID); |
| final long eventId = alertCursor.getLong(ALERT_INDEX_EVENT_ID); |
| final int minutes = alertCursor.getInt(ALERT_INDEX_MINUTES); |
| final String eventName = alertCursor.getString(ALERT_INDEX_TITLE); |
| final String description = alertCursor.getString(ALERT_INDEX_DESCRIPTION); |
| final String location = alertCursor.getString(ALERT_INDEX_EVENT_LOCATION); |
| final int status = alertCursor.getInt(ALERT_INDEX_SELF_ATTENDEE_STATUS); |
| final boolean declined = status == Attendees.ATTENDEE_STATUS_DECLINED; |
| final boolean responded = status != Attendees.ATTENDEE_STATUS_NONE |
| && status != Attendees.ATTENDEE_STATUS_INVITED; |
| final long beginTime = alertCursor.getLong(ALERT_INDEX_BEGIN); |
| final long endTime = alertCursor.getLong(ALERT_INDEX_END); |
| final Uri alertUri = ContentUris |
| .withAppendedId(CalendarAlerts.CONTENT_URI, alertId); |
| final long alarmTime = alertCursor.getLong(ALERT_INDEX_ALARM_TIME); |
| boolean forceQuiet = false; |
| if (useQuietHours) { |
| // Quiet hours have been set. |
| time.set(alarmTime); |
| // Check whether the alarm will fire after the quiet hours |
| // start time and/or before the quiet hours end time. |
| boolean alarmAfterQuietHoursStart = |
| (time.hour > quietHoursStartHour || |
| (time.hour == quietHoursStartHour |
| && time.minute >= quietHoursStartMinute)); |
| boolean alarmBeforeQuietHoursEnd = |
| (time.hour < quietHoursEndHour || |
| (time.hour == quietHoursEndHour |
| && time.minute <= quietHoursEndMinute)); |
| // Check if quiet hours crosses through midnight, iff: |
| // start hour is after end hour, or |
| // start hour is equal to end hour, and start minute is |
| // after end minute. |
| // i.e. 22:30 - 06:45; 12:45 - 12:00 |
| // 01:05 - 10:30; 05:00 - 05:30 |
| boolean quietHoursCrossesMidnight = |
| quietHoursStartHour > quietHoursEndHour || |
| (quietHoursStartHour == quietHoursEndHour |
| && quietHoursStartMinute > quietHoursEndMinute); |
| if (quietHoursCrossesMidnight) { |
| // Quiet hours crosses midnight. Alarm should be quiet |
| // if it's after start time OR before end time. |
| if (alarmAfterQuietHoursStart || |
| alarmBeforeQuietHoursEnd) { |
| forceQuiet = true; |
| } |
| } else { |
| // Quiet hours doesn't cross midnight. Alarm should be |
| // quiet if it's after start time AND before end time. |
| if (alarmAfterQuietHoursStart && |
| alarmBeforeQuietHoursEnd) { |
| forceQuiet = true; |
| } |
| } |
| } |
| int state = alertCursor.getInt(ALERT_INDEX_STATE); |
| final boolean allDay = alertCursor.getInt(ALERT_INDEX_ALL_DAY) != 0; |
| |
| // Use app local storage to keep track of fired alerts to fix problem of multiple |
| // installed calendar apps potentially causing missed alarms. |
| boolean newAlertOverride = false; |
| if (AlertUtils.BYPASS_DB && ((currentTime - alarmTime) / MINUTE_MS < 1)) { |
| // To avoid re-firing alerts, only fire if alarmTime is very recent. Otherwise |
| // we can get refires for non-dismissed alerts after app installation, or if the |
| // SharedPrefs was cleared too early. This means alerts that were timed while |
| // the phone was off may show up silently in the notification bar. |
| boolean alreadyFired = AlertUtils.hasAlertFiredInSharedPrefs(context, eventId, |
| beginTime, alarmTime); |
| if (!alreadyFired) { |
| newAlertOverride = true; |
| } |
| } |
| |
| if (DEBUG) { |
| StringBuilder msgBuilder = new StringBuilder(); |
| msgBuilder.append("alertCursor result: alarmTime:").append(alarmTime) |
| .append(" alertId:").append(alertId) |
| .append(" eventId:").append(eventId) |
| .append(" state: ").append(state) |
| .append(" minutes:").append(minutes) |
| .append(" declined:").append(declined) |
| .append(" responded:").append(responded) |
| .append(" beginTime:").append(beginTime) |
| .append(" endTime:").append(endTime) |
| .append(" allDay:").append(allDay) |
| .append(" alarmTime:").append(alarmTime) |
| .append(" forceQuiet:").append(forceQuiet); |
| if (AlertUtils.BYPASS_DB) { |
| msgBuilder.append(" newAlertOverride: " + newAlertOverride); |
| } |
| Log.d(TAG, msgBuilder.toString()); |
| } |
| |
| ContentValues values = new ContentValues(); |
| int newState = -1; |
| boolean newAlert = false; |
| |
| // Uncomment for the behavior of clearing out alerts after the |
| // events ended. b/1880369 |
| // |
| // if (endTime < currentTime) { |
| // newState = CalendarAlerts.DISMISSED; |
| // } else |
| |
| // Remove declined events |
| boolean sendAlert = !declined; |
| // Check for experimental reminder settings. |
| if (remindRespondedOnly) { |
| // If the experimental setting is turned on, then only send |
| // the alert if you've responded to the event. |
| sendAlert = sendAlert && responded; |
| } |
| if (sendAlert) { |
| if (state == CalendarAlerts.STATE_SCHEDULED || newAlertOverride) { |
| newState = CalendarAlerts.STATE_FIRED; |
| numFired++; |
| // If quiet hours are forcing the alarm to be silent, |
| // keep newAlert as false so it will not make noise. |
| if (!forceQuiet) { |
| newAlert = true; |
| } |
| |
| // Record the received time in the CalendarAlerts table. |
| // This is useful for finding bugs that cause alarms to be |
| // missed or delayed. |
| values.put(CalendarAlerts.RECEIVED_TIME, currentTime); |
| } |
| } else { |
| newState = CalendarAlerts.STATE_DISMISSED; |
| } |
| |
| // Update row if state changed |
| if (newState != -1) { |
| values.put(CalendarAlerts.STATE, newState); |
| state = newState; |
| |
| if (AlertUtils.BYPASS_DB) { |
| AlertUtils.setAlertFiredInSharedPrefs(context, eventId, beginTime, |
| alarmTime); |
| } |
| } |
| |
| if (state == CalendarAlerts.STATE_FIRED) { |
| // Record the time posting to notification manager. |
| // This is used for debugging missed alarms. |
| values.put(CalendarAlerts.NOTIFY_TIME, currentTime); |
| } |
| |
| // Write row to if anything changed |
| if (values.size() > 0) cr.update(alertUri, values, null, null); |
| |
| if (state != CalendarAlerts.STATE_FIRED) { |
| continue; |
| } |
| |
| // TODO: Prefer accepted events in case of ties. |
| NotificationInfo newInfo = new NotificationInfo(eventName, location, |
| description, beginTime, endTime, eventId, allDay, newAlert); |
| |
| // Adjust for all day events to ensure the right bucket. Don't use the 1/4 event |
| // duration grace period for these. |
| long beginTimeAdjustedForAllDay = beginTime; |
| String tz = null; |
| if (allDay) { |
| tz = TimeZone.getDefault().getID(); |
| beginTimeAdjustedForAllDay = Utils.convertAlldayUtcToLocal(null, beginTime, |
| tz); |
| } |
| |
| // Handle multiple alerts for the same event ID. |
| if (eventIds.containsKey(eventId)) { |
| NotificationInfo oldInfo = eventIds.get(eventId); |
| long oldBeginTimeAdjustedForAllDay = oldInfo.startMillis; |
| if (allDay) { |
| oldBeginTimeAdjustedForAllDay = Utils.convertAlldayUtcToLocal(null, |
| oldInfo.startMillis, tz); |
| } |
| |
| // Determine whether to replace the previous reminder with this one. |
| // Query results are sorted so this one will always have a lower start time. |
| long oldStartInterval = oldBeginTimeAdjustedForAllDay - currentTime; |
| long newStartInterval = beginTimeAdjustedForAllDay - currentTime; |
| boolean dropOld; |
| if (newStartInterval < 0 && oldStartInterval > 0) { |
| // Use this reminder if this event started recently |
| dropOld = Math.abs(newStartInterval) < MIN_DEPRIORITIZE_GRACE_PERIOD_MS; |
| } else { |
| // ... or if this one has a closer start time. |
| dropOld = Math.abs(newStartInterval) < Math.abs(oldStartInterval); |
| } |
| |
| if (dropOld) { |
| // This is a recurring event that has a more relevant start time, |
| // drop other reminder in favor of this one. |
| // |
| // It will only be present in 1 of these buckets; just remove from |
| // multiple buckets since this occurrence is rare enough that the |
| // inefficiency of multiple removals shouldn't be a big deal to |
| // justify a more complicated data structure. Expired events don't |
| // have individual notifications so we don't need to clean that up. |
| highPriorityEvents.remove(oldInfo); |
| mediumPriorityEvents.remove(oldInfo); |
| if (DEBUG) { |
| Log.d(TAG, "Dropping alert for recurring event ID:" + oldInfo.eventId |
| + ", startTime:" + oldInfo.startMillis |
| + " in favor of startTime:" + newInfo.startMillis); |
| } |
| } else { |
| // Skip duplicate reminders for the same event instance. |
| continue; |
| } |
| } |
| |
| // TODO: Prioritize by "primary" calendar |
| eventIds.put(eventId, newInfo); |
| long highPriorityCutoff = currentTime - |
| getGracePeriodMs(beginTime, endTime, allDay); |
| |
| if (beginTimeAdjustedForAllDay > highPriorityCutoff) { |
| // High priority = future events or events that just started |
| highPriorityEvents.add(newInfo); |
| } else if (allDay && tz != null && DateUtils.isToday(beginTimeAdjustedForAllDay)) { |
| // Medium priority = in progress all day events |
| mediumPriorityEvents.add(newInfo); |
| } else { |
| lowPriorityEvents.add(newInfo); |
| } |
| } |
| // TODO(cwren) add beginTime/startTime |
| GlobalDismissManager.processEventIds(context, eventIds.keySet()); |
| } finally { |
| if (alertCursor != null) { |
| alertCursor.close(); |
| } |
| } |
| return numFired; |
| } |
| |
| /** |
| * High priority cutoff should be 1/4 event duration or 15 min, whichever is longer. |
| */ |
| private static long getGracePeriodMs(long beginTime, long endTime, boolean allDay) { |
| if (allDay) { |
| // We don't want all day events to be high priority for hours, so automatically |
| // demote these after 15 min. |
| return MIN_DEPRIORITIZE_GRACE_PERIOD_MS; |
| } else { |
| return Math.max(MIN_DEPRIORITIZE_GRACE_PERIOD_MS, ((endTime - beginTime) / 4)); |
| } |
| } |
| |
| private static String getDigestTitle(ArrayList<NotificationInfo> events) { |
| StringBuilder digestTitle = new StringBuilder(); |
| for (NotificationInfo eventInfo : events) { |
| if (!TextUtils.isEmpty(eventInfo.eventName)) { |
| if (digestTitle.length() > 0) { |
| digestTitle.append(", "); |
| } |
| digestTitle.append(eventInfo.eventName); |
| } |
| } |
| return digestTitle.toString(); |
| } |
| |
| private static void postNotification(NotificationInfo info, String summaryText, |
| Context context, boolean highPriority, NotificationPrefs prefs, |
| NotificationMgr notificationMgr, int notificationId) { |
| int priorityVal = Notification.PRIORITY_DEFAULT; |
| if (highPriority) { |
| priorityVal = Notification.PRIORITY_HIGH; |
| } |
| |
| String tickerText = getTickerText(info.eventName, info.location); |
| NotificationWrapper notification = AlertReceiver.makeExpandingNotification(context, |
| info.eventName, summaryText, info.description, info.startMillis, |
| info.endMillis, info.eventId, notificationId, prefs.getDoPopup(), priorityVal); |
| |
| boolean quietUpdate = true; |
| String ringtone = NotificationPrefs.EMPTY_RINGTONE; |
| if (info.newAlert) { |
| quietUpdate = prefs.quietUpdate; |
| |
| // If we've already played a ringtone, don't play any more sounds so only |
| // 1 sound per group of notifications. |
| ringtone = prefs.getRingtoneAndSilence(); |
| } |
| addNotificationOptions(notification, quietUpdate, tickerText, |
| prefs.getDefaultVibrate(), ringtone, |
| true); /* Show the LED for these non-expired events */ |
| |
| // Post the notification. |
| notificationMgr.notify(notificationId, notification); |
| |
| if (DEBUG) { |
| Log.d(TAG, "Posting individual alarm notification, eventId:" + info.eventId |
| + ", notificationId:" + notificationId |
| + (TextUtils.isEmpty(ringtone) ? ", quiet" : ", LOUD") |
| + (highPriority ? ", high-priority" : "")); |
| } |
| } |
| |
| private static String getTickerText(String eventName, String location) { |
| String tickerText = eventName; |
| if (!TextUtils.isEmpty(location)) { |
| tickerText = eventName + " - " + location; |
| } |
| return tickerText; |
| } |
| |
| static class NotificationInfo { |
| String eventName; |
| String location; |
| String description; |
| long startMillis; |
| long endMillis; |
| long eventId; |
| boolean allDay; |
| boolean newAlert; |
| |
| NotificationInfo(String eventName, String location, String description, long startMillis, |
| long endMillis, long eventId, boolean allDay, boolean newAlert) { |
| this.eventName = eventName; |
| this.location = location; |
| this.description = description; |
| this.startMillis = startMillis; |
| this.endMillis = endMillis; |
| this.eventId = eventId; |
| this.newAlert = newAlert; |
| this.allDay = allDay; |
| } |
| } |
| |
| private static void addNotificationOptions(NotificationWrapper nw, boolean quietUpdate, |
| String tickerText, boolean defaultVibrate, String reminderRingtone, |
| boolean showLights) { |
| Notification notification = nw.mNotification; |
| if (showLights) { |
| notification.flags |= Notification.FLAG_SHOW_LIGHTS; |
| notification.defaults |= Notification.DEFAULT_LIGHTS; |
| } |
| |
| // Quietly update notification bar. Nothing new. Maybe something just got deleted. |
| if (!quietUpdate) { |
| // Flash ticker in status bar |
| if (!TextUtils.isEmpty(tickerText)) { |
| notification.tickerText = tickerText; |
| } |
| |
| // Generate either a pop-up dialog, status bar notification, or |
| // neither. Pop-up dialog and status bar notification may include a |
| // sound, an alert, or both. A status bar notification also includes |
| // a toast. |
| if (defaultVibrate) { |
| notification.defaults |= Notification.DEFAULT_VIBRATE; |
| } |
| |
| // Possibly generate a sound. If 'Silent' is chosen, the ringtone |
| // string will be empty. |
| notification.sound = TextUtils.isEmpty(reminderRingtone) ? null : Uri |
| .parse(reminderRingtone); |
| } |
| } |
| |
| /* package */ static class NotificationPrefs { |
| boolean quietUpdate; |
| private Context context; |
| private SharedPreferences prefs; |
| |
| // These are lazily initialized, do not access any of the following directly; use getters. |
| private int doPopup = -1; |
| private int defaultVibrate = -1; |
| private String ringtone = null; |
| |
| private static final String EMPTY_RINGTONE = ""; |
| |
| NotificationPrefs(Context context, SharedPreferences prefs, boolean quietUpdate) { |
| this.context = context; |
| this.prefs = prefs; |
| this.quietUpdate = quietUpdate; |
| } |
| |
| private boolean getDoPopup() { |
| if (doPopup < 0) { |
| if (prefs.getBoolean(GeneralPreferences.KEY_ALERTS_POPUP, false)) { |
| doPopup = 1; |
| } else { |
| doPopup = 0; |
| } |
| } |
| return doPopup == 1; |
| } |
| |
| private boolean getDefaultVibrate() { |
| if (defaultVibrate < 0) { |
| defaultVibrate = Utils.getDefaultVibrate(context, prefs) ? 1 : 0; |
| } |
| return defaultVibrate == 1; |
| } |
| |
| private String getRingtoneAndSilence() { |
| if (ringtone == null) { |
| if (quietUpdate) { |
| ringtone = EMPTY_RINGTONE; |
| } else { |
| ringtone = Utils.getRingTonePreference(context); |
| } |
| } |
| String retVal = ringtone; |
| ringtone = EMPTY_RINGTONE; |
| return retVal; |
| } |
| } |
| |
| private void doTimeChanged() { |
| ContentResolver cr = getContentResolver(); |
| // TODO Move this into Provider |
| rescheduleMissedAlarms(cr, this, AlertUtils.createAlarmManager(this)); |
| updateAlertNotification(this); |
| } |
| |
| private static final String SORT_ORDER_ALARMTIME_ASC = |
| CalendarContract.CalendarAlerts.ALARM_TIME + " ASC"; |
| |
| private static final String WHERE_RESCHEDULE_MISSED_ALARMS = |
| CalendarContract.CalendarAlerts.STATE |
| + "=" |
| + CalendarContract.CalendarAlerts.STATE_SCHEDULED |
| + " AND " |
| + CalendarContract.CalendarAlerts.ALARM_TIME |
| + "<?" |
| + " AND " |
| + CalendarContract.CalendarAlerts.ALARM_TIME |
| + ">?" |
| + " AND " |
| + CalendarContract.CalendarAlerts.END + ">=?"; |
| |
| /** |
| * Searches the CalendarAlerts table for alarms that should have fired but |
| * have not and then reschedules them. This method can be called at boot |
| * time to restore alarms that may have been lost due to a phone reboot. |
| * |
| * @param cr the ContentResolver |
| * @param context the Context |
| * @param manager the AlarmManager |
| */ |
| private static final void rescheduleMissedAlarms(ContentResolver cr, Context context, |
| AlarmManagerInterface manager) { |
| // Get all the alerts that have been scheduled but have not fired |
| // and should have fired by now and are not too old. |
| long now = System.currentTimeMillis(); |
| long ancient = now - DateUtils.DAY_IN_MILLIS; |
| String[] projection = new String[] { |
| CalendarContract.CalendarAlerts.ALARM_TIME, |
| }; |
| |
| // TODO: construct an explicit SQL query so that we can add |
| // "GROUPBY" instead of doing a sort and de-dup |
| Cursor cursor = cr.query(CalendarAlerts.CONTENT_URI, projection, |
| WHERE_RESCHEDULE_MISSED_ALARMS, (new String[] { |
| Long.toString(now), Long.toString(ancient), Long.toString(now) |
| }), SORT_ORDER_ALARMTIME_ASC); |
| if (cursor == null) { |
| return; |
| } |
| |
| if (DEBUG) { |
| Log.d(TAG, "missed alarms found: " + cursor.getCount()); |
| } |
| |
| try { |
| long alarmTime = -1; |
| |
| while (cursor.moveToNext()) { |
| long newAlarmTime = cursor.getLong(0); |
| if (alarmTime != newAlarmTime) { |
| if (DEBUG) { |
| Log.w(TAG, "rescheduling missed alarm. alarmTime: " + newAlarmTime); |
| } |
| AlertUtils.scheduleAlarm(context, manager, newAlarmTime); |
| alarmTime = newAlarmTime; |
| } |
| } |
| } finally { |
| cursor.close(); |
| } |
| } |
| |
| private final class ServiceHandler extends Handler { |
| public ServiceHandler(Looper looper) { |
| super(looper); |
| } |
| |
| @Override |
| public void handleMessage(Message msg) { |
| processMessage(msg); |
| // NOTE: We MUST not call stopSelf() directly, since we need to |
| // make sure the wake lock acquired by AlertReceiver is released. |
| AlertReceiver.finishStartingService(AlertService.this, msg.arg1); |
| } |
| } |
| |
| @Override |
| public void onCreate() { |
| HandlerThread thread = new HandlerThread("AlertService", |
| Process.THREAD_PRIORITY_BACKGROUND); |
| thread.start(); |
| |
| mServiceLooper = thread.getLooper(); |
| mServiceHandler = new ServiceHandler(mServiceLooper); |
| |
| // Flushes old fired alerts from internal storage, if needed. |
| AlertUtils.flushOldAlertsFromInternalStorage(getApplication()); |
| } |
| |
| @Override |
| public int onStartCommand(Intent intent, int flags, int startId) { |
| if (intent != null) { |
| Message msg = mServiceHandler.obtainMessage(); |
| msg.arg1 = startId; |
| msg.obj = intent.getExtras(); |
| mServiceHandler.sendMessage(msg); |
| } |
| return START_REDELIVER_INTENT; |
| } |
| |
| @Override |
| public void onDestroy() { |
| mServiceLooper.quit(); |
| } |
| |
| @Override |
| public IBinder onBind(Intent intent) { |
| return null; |
| } |
| } |
