src/com/android/calendar/AlertService.java - platform/packages/apps/Calendar - Git at Google

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

 import android.app.AlarmManager;
 import android.app.Notification;
 import android.app.NotificationManager;
 import android.app.Service;
 import android.content.ContentResolver;
 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.preference.PreferenceManager;
 import android.provider.Calendar;
 import android.provider.Calendar.Attendees;
 import android.provider.Calendar.CalendarAlerts;
 import android.provider.Calendar.Instances;
 import android.provider.Calendar.Reminders;
 import android.text.TextUtils;
 import android.text.format.DateUtils;
 import android.util.Log;
 import android.view.LayoutInflater;
 import android.view.View;

 /**
  * This service is used to handle calendar event reminders.
  */
 public class AlertService extends Service {
     private static final String TAG = "AlertService";

     private volatile Looper mServiceLooper;
     private volatile ServiceHandler mServiceHandler;

     private 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
     };

     // We just need a simple projection that returns any column
     private static final String[] ALERT_PROJECTION_SMALL = new String[] {
         CalendarAlerts._ID,                     // 0
     };

     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 String[] INSTANCE_PROJECTION = { Instances.BEGIN, Instances.END };
     private static final int INSTANCES_INDEX_BEGIN = 0;
     private static final int INSTANCES_INDEX_END = 1;

     // We just need a simple projection that returns any column
     private static final String[] REMINDER_PROJECTION_SMALL = new String[] {
         Reminders._ID,                     // 0
     };

     @SuppressWarnings("deprecation")
     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 (action.equals(Intent.ACTION_BOOT_COMPLETED)
                 || action.equals(Intent.ACTION_TIME_CHANGED)) {
             doTimeChanged();
             return;
         }

         // The Uri specifies an entry in the CalendarAlerts table
         Uri alertUri = Uri.parse(bundle.getString("uri"));
         if (Log.isLoggable(TAG, Log.DEBUG)) {
             Log.d(TAG, "uri: " + alertUri);
         }

         if (alertUri != null) {
             // Record the received time in the CalendarAlerts table.
             // This is useful for finding bugs that cause alarms to be
             // missed or delayed.
             ContentValues values = new ContentValues();
             values.put(CalendarAlerts.RECEIVED_TIME, System.currentTimeMillis());
             getContentResolver().update(alertUri, values, null /* where */, null /* args */);
         }

         ContentResolver cr = getContentResolver();
         Cursor alertCursor = cr.query(alertUri, ALERT_PROJECTION,
                 null /* selection */, null, null /* sort order */);

         long alertId, eventId, alarmTime;
         int minutes;
         String eventName;
         String location;
         boolean allDay;
         boolean declined = false;
         try {
             if (alertCursor == null || !alertCursor.moveToFirst()) {
                 // This can happen if the event was deleted.
                 if (Log.isLoggable(TAG, Log.DEBUG)) {
                     Log.d(TAG, "alert not found");
                 }
                 return;
             }
             alertId = alertCursor.getLong(ALERT_INDEX_ID);
             eventId = alertCursor.getLong(ALERT_INDEX_EVENT_ID);
             minutes = alertCursor.getInt(ALERT_INDEX_MINUTES);
             eventName = alertCursor.getString(ALERT_INDEX_TITLE);
             location = alertCursor.getString(ALERT_INDEX_EVENT_LOCATION);
             allDay = alertCursor.getInt(ALERT_INDEX_ALL_DAY) != 0;
             alarmTime = alertCursor.getLong(ALERT_INDEX_ALARM_TIME);
             declined = alertCursor.getInt(ALERT_INDEX_SELF_ATTENDEE_STATUS) ==
                     Attendees.ATTENDEE_STATUS_DECLINED;

             // If the event was declined, then mark the alarm DISMISSED,
             // otherwise, mark the alarm FIRED.
             int newState = CalendarAlerts.FIRED;
             if (declined) {
                 newState = CalendarAlerts.DISMISSED;
             }
             alertCursor.updateInt(ALERT_INDEX_STATE, newState);
             alertCursor.commitUpdates();
         } finally {
             if (alertCursor != null) {
                 alertCursor.close();
             }
         }

         // Do not show an alert if the event was declined
         if (declined) {
             if (Log.isLoggable(TAG, Log.DEBUG)) {
                 Log.d(TAG, "event declined, alert cancelled");
             }
             return;
         }

         long beginTime = bundle.getLong(Calendar.EVENT_BEGIN_TIME, 0);
         long endTime = bundle.getLong(Calendar.EVENT_END_TIME, 0);

         // Check if this alarm is still valid.  The time of the event may
         // have been changed, or the reminder may have been changed since
         // this alarm was set. First, search for an instance in the Instances
         // that has the same event id and the same begin and end time.
         // Then check for a reminder in the Reminders table to ensure that
         // the reminder minutes is consistent with this alarm.
         String selection = Instances.EVENT_ID + "=" + eventId;
         Cursor instanceCursor = Instances.query(cr, INSTANCE_PROJECTION,
                 beginTime, endTime, selection, Instances.DEFAULT_SORT_ORDER);
         long instanceBegin = 0, instanceEnd = 0;
         try {
             if (instanceCursor == null || !instanceCursor.moveToFirst()) {
                 // Delete this alarm from the CalendarAlerts table
                 cr.delete(alertUri, null /* selection */, null /* selection args */);
                 if (Log.isLoggable(TAG, Log.DEBUG)) {
                     Log.d(TAG, "instance not found, alert cancelled");
                 }
                 return;
             }
             instanceBegin = instanceCursor.getLong(INSTANCES_INDEX_BEGIN);
             instanceEnd = instanceCursor.getLong(INSTANCES_INDEX_END);
         } finally {
             if (instanceCursor != null) {
                 instanceCursor.close();
             }
         }

         // Check that a reminder for this event exists with the same number
         // of minutes.  But snoozed alarms have minutes = 0, so don't do this
         // check for snoozed alarms.
         if (minutes > 0) {
             selection = Reminders.EVENT_ID + "=" + eventId
                 + " AND " + Reminders.MINUTES + "=" + minutes;
             Cursor reminderCursor = cr.query(Reminders.CONTENT_URI, REMINDER_PROJECTION_SMALL,
                     selection, null /* selection args */, null /* sort order */);
             try {
                 if (reminderCursor == null || reminderCursor.getCount() == 0) {
                     // Delete this alarm from the CalendarAlerts table
                     cr.delete(alertUri, null /* selection */, null /* selection args */);
                     if (Log.isLoggable(TAG, Log.DEBUG)) {
                         Log.d(TAG, "reminder not found, alert cancelled");
                     }
                     return;
                 }
             } finally {
                 if (reminderCursor != null) {
                     reminderCursor.close();
                 }
             }
         }

         // If the event time was changed and the event has already ended,
         // then don't sound the alarm.
         if (alarmTime > instanceEnd) {
             // Delete this alarm from the CalendarAlerts table
             cr.delete(alertUri, null /* selection */, null /* selection args */);
             if (Log.isLoggable(TAG, Log.DEBUG)) {
                 Log.d(TAG, "event ended, alert cancelled");
             }
             return;
         }

         // If minutes > 0, then this is a normal alarm (not a snoozed alarm)
         // so check for duplicate alarms.  A duplicate alarm can occur when
         // the start time of an event is changed to an earlier time.  The
         // later alarm (that was first scheduled for the later event time)
         // should be discarded.
         long computedAlarmTime = instanceBegin - minutes * DateUtils.MINUTE_IN_MILLIS;
         if (minutes > 0 && computedAlarmTime != alarmTime) {
             // If the event time was changed to a later time, then the computed
             // alarm time is in the future and we shouldn't sound this alarm.
             if (computedAlarmTime > alarmTime) {
                 // Delete this alarm from the CalendarAlerts table
                 cr.delete(alertUri, null /* selection */, null /* selection args */);
                 if (Log.isLoggable(TAG, Log.DEBUG)) {
                     Log.d(TAG, "event postponed, alert cancelled");
                 }
                 return;
             }

             // Check for another alarm in the CalendarAlerts table that has the
             // same event id and the same "minutes".  This can occur
             // if the event start time was changed to an earlier time and the
             // alarm for the later time goes off.  To avoid discarding alarms
             // for repeating events (that have the same event id), we check
             // that the other alarm fired recently (within an hour of this one).
             long recently = alarmTime - 60 * DateUtils.MINUTE_IN_MILLIS;
             selection = CalendarAlerts.EVENT_ID + "=" + eventId
                     + " AND " + CalendarAlerts.TABLE_NAME + "." + CalendarAlerts._ID
                     + "!=" + alertId
                     + " AND " + CalendarAlerts.MINUTES + "=" + minutes
                     + " AND " + CalendarAlerts.ALARM_TIME + ">" + recently
                     + " AND " + CalendarAlerts.ALARM_TIME + "<=" + alarmTime;
             alertCursor = CalendarAlerts.query(cr, ALERT_PROJECTION_SMALL, selection, null);
             if (alertCursor != null) {
                 try {
                     if (alertCursor.getCount() > 0) {
                         // Delete this alarm from the CalendarAlerts table
                         cr.delete(alertUri, null /* selection */, null /* selection args */);
                         if (Log.isLoggable(TAG, Log.DEBUG)) {
                             Log.d(TAG, "duplicate alarm, alert cancelled");
                         }
                         return;
                     }
                 } finally {
                     alertCursor.close();
                 }
             }
         }

         // Find all the alerts that have fired but have not been dismissed
         selection = CalendarAlerts.STATE + "=" + CalendarAlerts.FIRED;
         alertCursor = CalendarAlerts.query(cr, ALERT_PROJECTION, selection, null);

         if (alertCursor == null || alertCursor.getCount() == 0) {
             if (Log.isLoggable(TAG, Log.DEBUG)) {
                 Log.d(TAG, "no fired alarms found");
             }
             return;
         }

         int numReminders = alertCursor.getCount();
         try {
             while (alertCursor.moveToNext()) {
                 long otherEventId = alertCursor.getLong(ALERT_INDEX_EVENT_ID);
                 long otherAlertId = alertCursor.getLong(ALERT_INDEX_ID);
                 int otherAlarmState = alertCursor.getInt(ALERT_INDEX_STATE);
                 long otherBeginTime = alertCursor.getLong(ALERT_INDEX_BEGIN);
                 if (otherEventId == eventId && otherAlertId != alertId
                         && otherAlarmState == CalendarAlerts.FIRED
                         && otherBeginTime == beginTime) {
                     // This event already has an alert that fired and has not
                     // been dismissed.  This can happen if an event has
                     // multiple reminders.  Do not count this as a separate
                     // reminder.  But we do want to sound the alarm and vibrate
                     // the phone, if necessary.
                     if (Log.isLoggable(TAG, Log.DEBUG)) {
                         Log.d(TAG, "multiple alarms for this event");
                     }
                     numReminders -= 1;
                 }
             }
         } finally {
             alertCursor.close();
         }

         if (Log.isLoggable(TAG, Log.DEBUG)) {
             Log.d(TAG, "creating new alarm notification, numReminders: " + numReminders);
         }
         Notification notification = AlertReceiver.makeNewAlertNotification(this, eventName,
                 location, numReminders);

         // 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.
         SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
         String reminderType = prefs.getString(CalendarPreferenceActivity.KEY_ALERTS_TYPE,
                 CalendarPreferenceActivity.ALERT_TYPE_STATUS_BAR);

         if (reminderType.equals(CalendarPreferenceActivity.ALERT_TYPE_OFF)) {
             if (Log.isLoggable(TAG, Log.DEBUG)) {
                 Log.d(TAG, "alert preference is OFF");
             }
             return;
         }

         NotificationManager nm =
             (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
         boolean reminderVibrate =
                 prefs.getBoolean(CalendarPreferenceActivity.KEY_ALERTS_VIBRATE, false);
         String reminderRingtone =
                 prefs.getString(CalendarPreferenceActivity.KEY_ALERTS_RINGTONE, null);

         // Possibly generate a vibration
         if (reminderVibrate) {
             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);

         if (reminderType.equals(CalendarPreferenceActivity.ALERT_TYPE_ALERTS)) {
             Intent alertIntent = new Intent();
             alertIntent.setClass(this, AlertActivity.class);
             alertIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
             startActivity(alertIntent);
         } else {
             LayoutInflater inflater;
             inflater = (LayoutInflater) getSystemService(Context.LAYOUT_INFLATER_SERVICE);
             View view = inflater.inflate(R.layout.alert_toast, null);

             AlertAdapter.updateView(this, view, eventName, location, beginTime, endTime, allDay);
         }

         // Record the notify time in the CalendarAlerts table.
         // This is used for debugging missed alarms.
         ContentValues values = new ContentValues();
         long currentTime = System.currentTimeMillis();
         values.put(CalendarAlerts.NOTIFY_TIME, currentTime);
         cr.update(alertUri, values, null /* where */, null /* args */);

         // The notification time should be pretty close to the reminder time
         // that the user set for this event.  If the notification is late, then
         // that's a bug and we should log an error.
         if (currentTime > alarmTime + DateUtils.MINUTE_IN_MILLIS) {
             long minutesLate = (currentTime - alarmTime) / DateUtils.MINUTE_IN_MILLIS;
             int flags = DateUtils.FORMAT_SHOW_YEAR | DateUtils.FORMAT_SHOW_TIME;
             String alarmTimeStr = DateUtils.formatDateTime(this, alarmTime, flags);
             String currentTimeStr = DateUtils.formatDateTime(this, currentTime, flags);
             Log.w(TAG, "Calendar reminder alarm for event id " + eventId
                     + " is " + minutesLate + " minute(s) late;"
                     + " expected alarm at: " + alarmTimeStr
                     + " but got it at: " + currentTimeStr);
         }

         nm.notify(0, notification);
     }

     private void doTimeChanged() {
         ContentResolver cr = getContentResolver();
         Object service = getSystemService(Context.ALARM_SERVICE);
         AlarmManager manager = (AlarmManager) service;
         CalendarAlerts.rescheduleMissedAlarms(cr, this, manager);
         AlertReceiver.updateAlertNotification(this);
     }

     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);
     }

     @Override
     public void onStart(Intent intent, int startId) {
         Message msg = mServiceHandler.obtainMessage();
         msg.arg1 = startId;
         msg.obj = intent.getExtras();
         mServiceHandler.sendMessage(msg);
     }

     @Override
     public void onDestroy() {
         mServiceLooper.quit();
     }

     @Override
     public IBinder onBind(Intent intent) {
         return null;
     }
 }
	/*
	* 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;

	import android.app.AlarmManager;
	import android.app.Notification;
	import android.app.NotificationManager;
	import android.app.Service;
	import android.content.ContentResolver;
	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.preference.PreferenceManager;
	import android.provider.Calendar;
	import android.provider.Calendar.Attendees;
	import android.provider.Calendar.CalendarAlerts;
	import android.provider.Calendar.Instances;
	import android.provider.Calendar.Reminders;
	import android.text.TextUtils;
	import android.text.format.DateUtils;
	import android.util.Log;
	import android.view.LayoutInflater;
	import android.view.View;

	/**
	* This service is used to handle calendar event reminders.
	*/
	public class AlertService extends Service {
	private static final String TAG = "AlertService";

	private volatile Looper mServiceLooper;
	private volatile ServiceHandler mServiceHandler;

	private 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
	};

	// We just need a simple projection that returns any column
	private static final String[] ALERT_PROJECTION_SMALL = new String[] {
	CalendarAlerts._ID, // 0
	};

	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 String[] INSTANCE_PROJECTION = { Instances.BEGIN, Instances.END };
	private static final int INSTANCES_INDEX_BEGIN = 0;
	private static final int INSTANCES_INDEX_END = 1;

	// We just need a simple projection that returns any column
	private static final String[] REMINDER_PROJECTION_SMALL = new String[] {
	Reminders._ID, // 0
	};

	@SuppressWarnings("deprecation")
	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 (action.equals(Intent.ACTION_BOOT_COMPLETED)
	\|\| action.equals(Intent.ACTION_TIME_CHANGED)) {
	doTimeChanged();
	return;
	}

	// The Uri specifies an entry in the CalendarAlerts table
	Uri alertUri = Uri.parse(bundle.getString("uri"));
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "uri: " + alertUri);
	}

	if (alertUri != null) {
	// Record the received time in the CalendarAlerts table.
	// This is useful for finding bugs that cause alarms to be
	// missed or delayed.
	ContentValues values = new ContentValues();
	values.put(CalendarAlerts.RECEIVED_TIME, System.currentTimeMillis());
	getContentResolver().update(alertUri, values, null /* where /, null / args */);
	}

	ContentResolver cr = getContentResolver();
	Cursor alertCursor = cr.query(alertUri, ALERT_PROJECTION,
	null /* selection /, null, null / sort order */);

	long alertId, eventId, alarmTime;
	int minutes;
	String eventName;
	String location;
	boolean allDay;
	boolean declined = false;
	try {
	if (alertCursor == null \|\| !alertCursor.moveToFirst()) {
	// This can happen if the event was deleted.
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "alert not found");
	}
	return;
	}
	alertId = alertCursor.getLong(ALERT_INDEX_ID);
	eventId = alertCursor.getLong(ALERT_INDEX_EVENT_ID);
	minutes = alertCursor.getInt(ALERT_INDEX_MINUTES);
	eventName = alertCursor.getString(ALERT_INDEX_TITLE);
	location = alertCursor.getString(ALERT_INDEX_EVENT_LOCATION);
	allDay = alertCursor.getInt(ALERT_INDEX_ALL_DAY) != 0;
	alarmTime = alertCursor.getLong(ALERT_INDEX_ALARM_TIME);
	declined = alertCursor.getInt(ALERT_INDEX_SELF_ATTENDEE_STATUS) ==
	Attendees.ATTENDEE_STATUS_DECLINED;

	// If the event was declined, then mark the alarm DISMISSED,
	// otherwise, mark the alarm FIRED.
	int newState = CalendarAlerts.FIRED;
	if (declined) {
	newState = CalendarAlerts.DISMISSED;
	}
	alertCursor.updateInt(ALERT_INDEX_STATE, newState);
	alertCursor.commitUpdates();
	} finally {
	if (alertCursor != null) {
	alertCursor.close();
	}
	}

	// Do not show an alert if the event was declined
	if (declined) {
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "event declined, alert cancelled");
	}
	return;
	}

	long beginTime = bundle.getLong(Calendar.EVENT_BEGIN_TIME, 0);
	long endTime = bundle.getLong(Calendar.EVENT_END_TIME, 0);

	// Check if this alarm is still valid. The time of the event may
	// have been changed, or the reminder may have been changed since
	// this alarm was set. First, search for an instance in the Instances
	// that has the same event id and the same begin and end time.
	// Then check for a reminder in the Reminders table to ensure that
	// the reminder minutes is consistent with this alarm.
	String selection = Instances.EVENT_ID + "=" + eventId;
	Cursor instanceCursor = Instances.query(cr, INSTANCE_PROJECTION,
	beginTime, endTime, selection, Instances.DEFAULT_SORT_ORDER);
	long instanceBegin = 0, instanceEnd = 0;
	try {
	if (instanceCursor == null \|\| !instanceCursor.moveToFirst()) {
	// Delete this alarm from the CalendarAlerts table
	cr.delete(alertUri, null /* selection /, null / selection args */);
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "instance not found, alert cancelled");
	}
	return;
	}
	instanceBegin = instanceCursor.getLong(INSTANCES_INDEX_BEGIN);
	instanceEnd = instanceCursor.getLong(INSTANCES_INDEX_END);
	} finally {
	if (instanceCursor != null) {
	instanceCursor.close();
	}
	}

	// Check that a reminder for this event exists with the same number
	// of minutes. But snoozed alarms have minutes = 0, so don't do this
	// check for snoozed alarms.
	if (minutes > 0) {
	selection = Reminders.EVENT_ID + "=" + eventId
	+ " AND " + Reminders.MINUTES + "=" + minutes;
	Cursor reminderCursor = cr.query(Reminders.CONTENT_URI, REMINDER_PROJECTION_SMALL,
	selection, null /* selection args /, null / sort order */);
	try {
	if (reminderCursor == null \|\| reminderCursor.getCount() == 0) {
	// Delete this alarm from the CalendarAlerts table
	cr.delete(alertUri, null /* selection /, null / selection args */);
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "reminder not found, alert cancelled");
	}
	return;
	}
	} finally {
	if (reminderCursor != null) {
	reminderCursor.close();
	}
	}
	}

	// If the event time was changed and the event has already ended,
	// then don't sound the alarm.
	if (alarmTime > instanceEnd) {
	// Delete this alarm from the CalendarAlerts table
	cr.delete(alertUri, null /* selection /, null / selection args */);
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "event ended, alert cancelled");
	}
	return;
	}

	// If minutes > 0, then this is a normal alarm (not a snoozed alarm)
	// so check for duplicate alarms. A duplicate alarm can occur when
	// the start time of an event is changed to an earlier time. The
	// later alarm (that was first scheduled for the later event time)
	// should be discarded.
	long computedAlarmTime = instanceBegin - minutes * DateUtils.MINUTE_IN_MILLIS;
	if (minutes > 0 && computedAlarmTime != alarmTime) {
	// If the event time was changed to a later time, then the computed
	// alarm time is in the future and we shouldn't sound this alarm.
	if (computedAlarmTime > alarmTime) {
	// Delete this alarm from the CalendarAlerts table
	cr.delete(alertUri, null /* selection /, null / selection args */);
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "event postponed, alert cancelled");
	}
	return;
	}

	// Check for another alarm in the CalendarAlerts table that has the
	// same event id and the same "minutes". This can occur
	// if the event start time was changed to an earlier time and the
	// alarm for the later time goes off. To avoid discarding alarms
	// for repeating events (that have the same event id), we check
	// that the other alarm fired recently (within an hour of this one).
	long recently = alarmTime - 60 * DateUtils.MINUTE_IN_MILLIS;
	selection = CalendarAlerts.EVENT_ID + "=" + eventId
	+ " AND " + CalendarAlerts.TABLE_NAME + "." + CalendarAlerts._ID
	+ "!=" + alertId
	+ " AND " + CalendarAlerts.MINUTES + "=" + minutes
	+ " AND " + CalendarAlerts.ALARM_TIME + ">" + recently
	+ " AND " + CalendarAlerts.ALARM_TIME + "<=" + alarmTime;
	alertCursor = CalendarAlerts.query(cr, ALERT_PROJECTION_SMALL, selection, null);
	if (alertCursor != null) {
	try {
	if (alertCursor.getCount() > 0) {
	// Delete this alarm from the CalendarAlerts table
	cr.delete(alertUri, null /* selection /, null / selection args */);
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "duplicate alarm, alert cancelled");
	}
	return;
	}
	} finally {
	alertCursor.close();
	}
	}
	}

	// Find all the alerts that have fired but have not been dismissed
	selection = CalendarAlerts.STATE + "=" + CalendarAlerts.FIRED;
	alertCursor = CalendarAlerts.query(cr, ALERT_PROJECTION, selection, null);

	if (alertCursor == null \|\| alertCursor.getCount() == 0) {
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "no fired alarms found");
	}
	return;
	}

	int numReminders = alertCursor.getCount();
	try {
	while (alertCursor.moveToNext()) {
	long otherEventId = alertCursor.getLong(ALERT_INDEX_EVENT_ID);
	long otherAlertId = alertCursor.getLong(ALERT_INDEX_ID);
	int otherAlarmState = alertCursor.getInt(ALERT_INDEX_STATE);
	long otherBeginTime = alertCursor.getLong(ALERT_INDEX_BEGIN);
	if (otherEventId == eventId && otherAlertId != alertId
	&& otherAlarmState == CalendarAlerts.FIRED
	&& otherBeginTime == beginTime) {
	// This event already has an alert that fired and has not
	// been dismissed. This can happen if an event has
	// multiple reminders. Do not count this as a separate
	// reminder. But we do want to sound the alarm and vibrate
	// the phone, if necessary.
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "multiple alarms for this event");
	}
	numReminders -= 1;
	}
	}
	} finally {
	alertCursor.close();
	}

	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "creating new alarm notification, numReminders: " + numReminders);
	}
	Notification notification = AlertReceiver.makeNewAlertNotification(this, eventName,
	location, numReminders);

	// 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.
	SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
	String reminderType = prefs.getString(CalendarPreferenceActivity.KEY_ALERTS_TYPE,
	CalendarPreferenceActivity.ALERT_TYPE_STATUS_BAR);

	if (reminderType.equals(CalendarPreferenceActivity.ALERT_TYPE_OFF)) {
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "alert preference is OFF");
	}
	return;
	}

	NotificationManager nm =
	(NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
	boolean reminderVibrate =
	prefs.getBoolean(CalendarPreferenceActivity.KEY_ALERTS_VIBRATE, false);
	String reminderRingtone =
	prefs.getString(CalendarPreferenceActivity.KEY_ALERTS_RINGTONE, null);

	// Possibly generate a vibration
	if (reminderVibrate) {
	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);

	if (reminderType.equals(CalendarPreferenceActivity.ALERT_TYPE_ALERTS)) {
	Intent alertIntent = new Intent();
	alertIntent.setClass(this, AlertActivity.class);
	alertIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
	startActivity(alertIntent);
	} else {
	LayoutInflater inflater;
	inflater = (LayoutInflater) getSystemService(Context.LAYOUT_INFLATER_SERVICE);
	View view = inflater.inflate(R.layout.alert_toast, null);

	AlertAdapter.updateView(this, view, eventName, location, beginTime, endTime, allDay);
	}

	// Record the notify time in the CalendarAlerts table.
	// This is used for debugging missed alarms.
	ContentValues values = new ContentValues();
	long currentTime = System.currentTimeMillis();
	values.put(CalendarAlerts.NOTIFY_TIME, currentTime);
	cr.update(alertUri, values, null /* where /, null / args */);

	// The notification time should be pretty close to the reminder time
	// that the user set for this event. If the notification is late, then
	// that's a bug and we should log an error.
	if (currentTime > alarmTime + DateUtils.MINUTE_IN_MILLIS) {
	long minutesLate = (currentTime - alarmTime) / DateUtils.MINUTE_IN_MILLIS;
	int flags = DateUtils.FORMAT_SHOW_YEAR \| DateUtils.FORMAT_SHOW_TIME;
	String alarmTimeStr = DateUtils.formatDateTime(this, alarmTime, flags);
	String currentTimeStr = DateUtils.formatDateTime(this, currentTime, flags);
	Log.w(TAG, "Calendar reminder alarm for event id " + eventId
	+ " is " + minutesLate + " minute(s) late;"
	+ " expected alarm at: " + alarmTimeStr
	+ " but got it at: " + currentTimeStr);
	}

	nm.notify(0, notification);
	}

	private void doTimeChanged() {
	ContentResolver cr = getContentResolver();
	Object service = getSystemService(Context.ALARM_SERVICE);
	AlarmManager manager = (AlarmManager) service;
	CalendarAlerts.rescheduleMissedAlarms(cr, this, manager);
	AlertReceiver.updateAlertNotification(this);
	}

	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);
	}

	@Override
	public void onStart(Intent intent, int startId) {
	Message msg = mServiceHandler.obtainMessage();
	msg.arg1 = startId;
	msg.obj = intent.getExtras();
	mServiceHandler.sendMessage(msg);
	}

	@Override
	public void onDestroy() {
	mServiceLooper.quit();
	}

	@Override
	public IBinder onBind(Intent intent) {
	return null;
	}
	}