Initial Contribution
[android/platform/packages/apps/Calendar.git] / src / com / android / calendar / AlertService.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.calendar;
18
19 import android.app.AlarmManager;
20 import android.app.Notification;
21 import android.app.NotificationManager;
22 import android.app.Service;
23 import android.content.ContentResolver;
24 import android.content.Context;
25 import android.content.Intent;
26 import android.content.SharedPreferences;
27 import android.database.Cursor;
28 import android.net.Uri;
29 import android.os.Bundle;
30 import android.os.Handler;
31 import android.os.HandlerThread;
32 import android.os.IBinder;
33 import android.os.Looper;
34 import android.os.Message;
35 import android.os.Process;
36 import android.pim.DateUtils;
37 import android.preference.PreferenceManager;
38 import android.provider.Calendar;
39 import android.provider.Calendar.Attendees;
40 import android.provider.Calendar.CalendarAlerts;
41 import android.provider.Calendar.Instances;
42 import android.provider.Calendar.Reminders;
43 import android.text.TextUtils;
44 import android.util.Config;
45 import android.util.Log;
46 import android.view.LayoutInflater;
47 import android.view.View;
48
49 /**
50  * This service is used to handle calendar event reminders.
51  */
52 public class AlertService extends Service {
53     private static final String TAG = "AlertService";
54     private static final boolean localLOGV = false || Config.LOGV;
55     
56     private volatile Looper mServiceLooper;
57     private volatile ServiceHandler mServiceHandler;
58     
59     private static final String[] ALERT_PROJECTION = new String[] { 
60         CalendarAlerts._ID,                     // 0
61         CalendarAlerts.EVENT_ID,                // 1
62         CalendarAlerts.STATE,                   // 2
63         CalendarAlerts.TITLE,                   // 3
64         CalendarAlerts.EVENT_LOCATION,          // 4
65         CalendarAlerts.SELF_ATTENDEE_STATUS,    // 5
66         CalendarAlerts.ALL_DAY,                 // 6
67         CalendarAlerts.ALARM_TIME,              // 7
68         CalendarAlerts.MINUTES,                 // 8
69         CalendarAlerts.BEGIN,                   // 9
70     };
71
72     // We just need a simple projection that returns any column
73     private static final String[] ALERT_PROJECTION_SMALL = new String[] { 
74         CalendarAlerts._ID,                     // 0
75     };
76     
77     private static final int ALERT_INDEX_ID = 0;
78     private static final int ALERT_INDEX_EVENT_ID = 1;
79     private static final int ALERT_INDEX_STATE = 2;
80     private static final int ALERT_INDEX_TITLE = 3;
81     private static final int ALERT_INDEX_EVENT_LOCATION = 4;
82     private static final int ALERT_INDEX_SELF_ATTENDEE_STATUS = 5;
83     private static final int ALERT_INDEX_ALL_DAY = 6;
84     private static final int ALERT_INDEX_ALARM_TIME = 7;
85     private static final int ALERT_INDEX_MINUTES = 8;
86     private static final int ALERT_INDEX_BEGIN = 9;
87
88     private String[] INSTANCE_PROJECTION = { Instances.BEGIN, Instances.END };
89     private static final int INSTANCES_INDEX_BEGIN = 0;
90     private static final int INSTANCES_INDEX_END = 1;
91
92     // We just need a simple projection that returns any column
93     private static final String[] REMINDER_PROJECTION_SMALL = new String[] { 
94         Reminders._ID,                     // 0
95     };
96     
97     private void processMessage(Message msg) {
98         Bundle bundle = (Bundle) msg.obj;
99         
100         // On reboot, update the notification bar with the contents of the
101         // CalendarAlerts table.
102         String action = bundle.getString("action");
103         if (action.equals(Intent.ACTION_BOOT_COMPLETED)
104                 || action.equals(Intent.ACTION_TIME_CHANGED)) {
105             doTimeChanged();
106             return;
107         }
108
109         // The Uri specifies an entry in the CalendarAlerts table
110         Uri alertUri = Uri.parse(bundle.getString("uri"));
111         if (localLOGV) Log.v(TAG, "uri: " + alertUri);
112
113         ContentResolver cr = getContentResolver();
114         Cursor alertCursor = cr.query(alertUri, ALERT_PROJECTION,
115                 null /* selection */, null, null /* sort order */);
116         
117         long alertId, eventId, instanceId, alarmTime;
118         int minutes;
119         String eventName;
120         String location;
121         boolean allDay;
122         boolean declined = false;
123         try {
124             if (alertCursor == null || !alertCursor.moveToFirst()) {
125                 // This can happen if the event was deleted.
126                 if (localLOGV) Log.v(TAG, "alert not found");
127                 return;
128             }
129             alertId = alertCursor.getLong(ALERT_INDEX_ID);
130             eventId = alertCursor.getLong(ALERT_INDEX_EVENT_ID);
131             minutes = alertCursor.getInt(ALERT_INDEX_MINUTES);
132             eventName = alertCursor.getString(ALERT_INDEX_TITLE);
133             location = alertCursor.getString(ALERT_INDEX_EVENT_LOCATION);
134             allDay = alertCursor.getInt(ALERT_INDEX_ALL_DAY) != 0;
135             alarmTime = alertCursor.getLong(ALERT_INDEX_ALARM_TIME);
136             declined = alertCursor.getInt(ALERT_INDEX_SELF_ATTENDEE_STATUS) == 
137                     Attendees.ATTENDEE_STATUS_DECLINED;
138             
139             // If the event was declined, then mark the alarm DISMISSED,
140             // otherwise, mark the alarm FIRED.
141             int newState = CalendarAlerts.FIRED;
142             if (declined) {
143                 newState = CalendarAlerts.DISMISSED;
144             }
145             alertCursor.updateInt(ALERT_INDEX_STATE, newState);
146             alertCursor.commitUpdates();
147         } finally {
148             if (alertCursor != null) {
149                 alertCursor.close();
150             }
151         }
152         
153         // Do not show an alert if the event was declined
154         if (declined) {
155             if (localLOGV) Log.v(TAG, "event declined, alert cancelled");
156             return;
157         }
158         
159         long beginTime = bundle.getLong(Calendar.EVENT_BEGIN_TIME, 0);
160         long endTime = bundle.getLong(Calendar.EVENT_END_TIME, 0);
161         
162         // Check if this alarm is still valid.  The time of the event may
163         // have been changed, or the reminder may have been changed since
164         // this alarm was set. First, search for an instance in the Instances
165         // that has the same event id and the same begin and end time.
166         // Then check for a reminder in the Reminders table to ensure that
167         // the reminder minutes is consistent with this alarm.
168         String selection = Instances.EVENT_ID + "=" + eventId;
169         Cursor instanceCursor = Instances.query(cr, INSTANCE_PROJECTION,
170                 beginTime, endTime, selection, Instances.DEFAULT_SORT_ORDER);
171         long instanceBegin = 0, instanceEnd = 0;
172         try {
173             if (instanceCursor == null || !instanceCursor.moveToFirst()) {
174                 // Delete this alarm from the CalendarAlerts table
175                 cr.delete(alertUri, null /* selection */, null /* selection args */);
176                 if (localLOGV) Log.v(TAG, "instance not found, alert cancelled");
177                 return;
178             }
179             instanceBegin = instanceCursor.getLong(INSTANCES_INDEX_BEGIN);
180             instanceEnd = instanceCursor.getLong(INSTANCES_INDEX_END);
181         } finally {
182             if (instanceCursor != null) {
183                 instanceCursor.close();
184             }
185         }
186         
187         // Check that a reminder for this event exists with the same number
188         // of minutes.  But snoozed alarms have minutes = 0, so don't do this
189         // check for snoozed alarms.
190         if (minutes > 0) {
191             selection = Reminders.EVENT_ID + "=" + eventId
192                 + " AND " + Reminders.MINUTES + "=" + minutes;
193             Cursor reminderCursor = cr.query(Reminders.CONTENT_URI, REMINDER_PROJECTION_SMALL,
194                     selection, null /* selection args */, null /* sort order */);
195             try {
196                 if (reminderCursor == null || reminderCursor.getCount() == 0) {
197                     // Delete this alarm from the CalendarAlerts table
198                     cr.delete(alertUri, null /* selection */, null /* selection args */);
199                     if (localLOGV) Log.v(TAG, "reminder not found, alert cancelled");
200                     return;
201                 }
202             } finally {
203                 if (reminderCursor != null) {
204                     reminderCursor.close();
205                 }
206             }
207         }
208         
209         // If the event time was changed and the event has already ended,
210         // then don't sound the alarm.
211         if (alarmTime > instanceEnd) {
212             // Delete this alarm from the CalendarAlerts table
213             cr.delete(alertUri, null /* selection */, null /* selection args */);
214             if (localLOGV) Log.v(TAG, "event ended, alert cancelled");
215             return;
216         }
217
218         // If minutes > 0, then this is a normal alarm (not a snoozed alarm)
219         // so check for duplicate alarms.  A duplicate alarm can occur when
220         // the start time of an event is changed to an earlier time.  The
221         // later alarm (that was first scheduled for the later event time)
222         // should be discarded.
223         long computedAlarmTime = instanceBegin - minutes * DateUtils.MINUTE_IN_MILLIS;
224         if (minutes > 0 && computedAlarmTime != alarmTime) {
225             // If the event time was changed to a later time, then the computed
226             // alarm time is in the future and we shouldn't sound this alarm.
227             if (computedAlarmTime > alarmTime) {
228                 // Delete this alarm from the CalendarAlerts table
229                 cr.delete(alertUri, null /* selection */, null /* selection args */);
230                 if (localLOGV) Log.v(TAG, "event postponed, alert cancelled");
231                 return;
232             }
233             
234             // Check for another alarm in the CalendarAlerts table that has the
235             // same event id and the same "minutes".  This can occur
236             // if the event start time was changed to an earlier time and the
237             // alarm for the later time goes off.  To avoid discarding alarms
238             // for repeating events (that have the same event id), we check
239             // that the other alarm fired recently (within an hour of this one).
240             long recently = alarmTime - 60 * DateUtils.MINUTE_IN_MILLIS;
241             selection = CalendarAlerts.EVENT_ID + "=" + eventId
242                     + " AND " + CalendarAlerts.TABLE_NAME + "." + CalendarAlerts._ID
243                     + "!=" + alertId
244                     + " AND " + CalendarAlerts.MINUTES + "=" + minutes
245                     + " AND " + CalendarAlerts.ALARM_TIME + ">" + recently
246                     + " AND " + CalendarAlerts.ALARM_TIME + "<=" + alarmTime;
247             alertCursor = CalendarAlerts.query(cr, ALERT_PROJECTION_SMALL, selection, null);
248             if (alertCursor != null) {
249                 try {
250                     if (alertCursor.getCount() > 0) {
251                         // Delete this alarm from the CalendarAlerts table
252                         cr.delete(alertUri, null /* selection */, null /* selection args */);
253                         if (localLOGV) Log.v(TAG, "duplicate alarm, alert cancelled");
254                         return;
255                     }
256                 } finally {
257                     alertCursor.close();
258                 }
259             }
260         }
261         
262         // Find all the alerts that have fired but have not been dismissed
263         selection = CalendarAlerts.STATE + "=" + CalendarAlerts.FIRED;
264         alertCursor = CalendarAlerts.query(cr, ALERT_PROJECTION, selection, null);
265         
266         if (alertCursor == null || alertCursor.getCount() == 0) {
267             if (localLOGV) Log.v(TAG, "no fired alarms found");
268             return;
269         }
270
271         int numReminders = alertCursor.getCount();
272         try {
273             while (alertCursor.moveToNext()) {
274                 long otherEventId = alertCursor.getLong(ALERT_INDEX_EVENT_ID);
275                 long otherAlertId = alertCursor.getLong(ALERT_INDEX_ID);
276                 int otherAlarmState = alertCursor.getInt(ALERT_INDEX_STATE);
277                 long otherBeginTime = alertCursor.getLong(ALERT_INDEX_BEGIN);
278                 if (otherEventId == eventId && otherAlertId != alertId
279                         && otherAlarmState == CalendarAlerts.FIRED
280                         && otherBeginTime == beginTime) {
281                     // This event already has an alert that fired and has not
282                     // been dismissed.  This can happen if an event has
283                     // multiple reminders.  Do not count this as a separate
284                     // reminder.  But we do want to sound the alarm and vibrate
285                     // the phone, if necessary.
286                     if (localLOGV) Log.v(TAG, "multiple alarms for this event");
287                     numReminders -= 1;
288                 }
289             }
290         } finally {
291             alertCursor.close();
292         }
293         
294         if (localLOGV) Log.v(TAG, "creating new alarm notification, numReminders: " + numReminders);
295         Notification notification = AlertReceiver.makeNewAlertNotification(this, eventName,
296                 location, numReminders);
297         
298         // Generate either a pop-up dialog, status bar notification, or
299         // neither. Pop-up dialog and status bar notification may include a
300         // sound, an alert, or both. A status bar notification also includes
301         // a toast.
302         SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
303         String reminderType = prefs.getString(CalendarPreferenceActivity.KEY_ALERTS_TYPE,
304                 CalendarPreferenceActivity.ALERT_TYPE_STATUS_BAR);
305         
306         if (reminderType.equals(CalendarPreferenceActivity.ALERT_TYPE_OFF)) {
307             if (localLOGV) Log.v(TAG, "alert preference is OFF");
308             return;
309         }
310         
311         NotificationManager nm = 
312             (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
313         boolean reminderVibrate = 
314                 prefs.getBoolean(CalendarPreferenceActivity.KEY_ALERTS_VIBRATE, false);
315         String reminderRingtone =
316                 prefs.getString(CalendarPreferenceActivity.KEY_ALERTS_RINGTONE, null);
317
318         // Possibly generate a vibration
319         if (reminderVibrate) {
320             notification.defaults |= Notification.DEFAULT_VIBRATE;
321         }
322         
323         // Possibly generate a sound.  If 'Silent' is chosen, the ringtone string will be empty.
324         notification.sound = TextUtils.isEmpty(reminderRingtone) ? null : Uri
325                 .parse(reminderRingtone);
326         
327         if (reminderType.equals(CalendarPreferenceActivity.ALERT_TYPE_ALERTS)) {
328             Intent alertIntent = new Intent();
329             alertIntent.setClass(this, AlertActivity.class);
330             alertIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
331             startActivity(alertIntent);
332         } else {
333             LayoutInflater inflater;
334             inflater = (LayoutInflater) getSystemService(Context.LAYOUT_INFLATER_SERVICE);
335             View view = inflater.inflate(R.layout.alert_toast, null);
336             
337             AlertAdapter.updateView(this, view, eventName, location, beginTime, endTime, allDay);
338         }
339         nm.notify(0, notification);
340     }
341     
342     private void doTimeChanged() {
343         ContentResolver cr = getContentResolver();
344         Object service = getSystemService(Context.ALARM_SERVICE);
345         AlarmManager manager = (AlarmManager) service;
346         CalendarAlerts.rescheduleMissedAlarms(cr, this, manager);
347         AlertReceiver.updateAlertNotification(this);
348     }
349     
350     private final class ServiceHandler extends Handler {
351         public ServiceHandler(Looper looper) {
352             super(looper);
353         }
354         
355         @Override
356         public void handleMessage(Message msg) {
357             processMessage(msg);
358             // NOTE: We MUST not call stopSelf() directly, since we need to
359             // make sure the wake lock acquired by AlertReceiver is released.
360             AlertReceiver.finishStartingService(AlertService.this, msg.arg1);
361         } 
362     };
363
364     @Override
365     public void onCreate() {
366         HandlerThread thread = new HandlerThread("AlertService",
367                 Process.THREAD_PRIORITY_BACKGROUND);
368         thread.start();
369         
370         mServiceLooper = thread.getLooper();
371         mServiceHandler = new ServiceHandler(mServiceLooper);
372     }
373
374     @Override
375     public void onStart(Intent intent, int startId) {
376         Message msg = mServiceHandler.obtainMessage();
377         msg.arg1 = startId;
378         msg.obj = intent.getExtras();
379         mServiceHandler.sendMessage(msg);
380     }
381
382     @Override
383     public void onDestroy() {
384         mServiceLooper.quit();
385     }
386
387     @Override
388     public IBinder onBind(Intent intent) {
389         return null;
390     }
391 }