Home | History | Annotate | Download | only in calendar
      1 /*
      2  * Copyright (C) 2011 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.providers.calendar;
     18 
     19 import com.android.calendarcommon2.DateException;
     20 import com.android.calendarcommon2.Duration;
     21 import com.android.calendarcommon2.EventRecurrence;
     22 import com.android.calendarcommon2.RecurrenceProcessor;
     23 import com.android.calendarcommon2.RecurrenceSet;
     24 import com.android.providers.calendar.CalendarDatabaseHelper.Tables;
     25 
     26 import android.content.ContentValues;
     27 import android.database.Cursor;
     28 import android.database.DatabaseUtils;
     29 import android.database.sqlite.SQLiteDatabase;
     30 import android.database.sqlite.SQLiteQueryBuilder;
     31 import android.os.Debug;
     32 import android.provider.CalendarContract.Calendars;
     33 import android.provider.CalendarContract.Events;
     34 import android.provider.CalendarContract.Instances;
     35 import android.text.TextUtils;
     36 import android.text.format.Time;
     37 import android.util.Log;
     38 import android.util.TimeFormatException;
     39 
     40 import java.util.ArrayList;
     41 import java.util.HashMap;
     42 import java.util.Set;
     43 
     44 public class CalendarInstancesHelper {
     45     public static final class EventInstancesMap extends
     46             HashMap<String, CalendarInstancesHelper.InstancesList> {
     47         public void add(String syncIdKey, ContentValues values) {
     48             CalendarInstancesHelper.InstancesList instances = get(syncIdKey);
     49             if (instances == null) {
     50                 instances = new CalendarInstancesHelper.InstancesList();
     51                 put(syncIdKey, instances);
     52             }
     53             instances.add(values);
     54         }
     55     }
     56 
     57     public static final class InstancesList extends ArrayList<ContentValues> {
     58     }
     59 
     60     private static final String TAG = "CalInstances";
     61     private CalendarDatabaseHelper mDbHelper;
     62     private MetaData mMetaData;
     63     private CalendarCache mCalendarCache;
     64 
     65     private static final String SQL_WHERE_GET_EVENTS_ENTRIES =
     66             "((" + Events.DTSTART + " <= ? AND "
     67                     + "(" + Events.LAST_DATE + " IS NULL OR " + Events.LAST_DATE + " >= ?)) OR "
     68             + "(" + Events.ORIGINAL_INSTANCE_TIME + " IS NOT NULL AND "
     69                     + Events.ORIGINAL_INSTANCE_TIME
     70                     + " <= ? AND " + Events.ORIGINAL_INSTANCE_TIME + " >= ?)) AND "
     71             + "(" + Calendars.SYNC_EVENTS + " != ?) AND "
     72             + "(" + Events.LAST_SYNCED + " = ?)";
     73 
     74     /**
     75      * Determines the set of Events where the _id matches the first query argument, or the
     76      * originalId matches the second argument.  Returns the _id field from the set of
     77      * Instances whose event_id field matches one of those events.
     78      */
     79     private static final String SQL_WHERE_ID_FROM_INSTANCES_NOT_SYNCED =
     80             Instances._ID + " IN " +
     81             "(SELECT " + Tables.INSTANCES + "." + Instances._ID + " as _id" +
     82             " FROM " + Tables.INSTANCES +
     83             " INNER JOIN " + Tables.EVENTS +
     84             " ON (" +
     85             Tables.EVENTS + "." + Events._ID + "=" + Tables.INSTANCES + "." + Instances.EVENT_ID +
     86             ")" +
     87             " WHERE " + Tables.EVENTS + "." + Events._ID + "=? OR " +
     88                     Tables.EVENTS + "." + Events.ORIGINAL_ID + "=?)";
     89 
     90     /**
     91      * Determines the set of Events where the _sync_id matches the first query argument, or the
     92      * originalSyncId matches the second argument.  Returns the _id field from the set of
     93      * Instances whose event_id field matches one of those events.
     94      */
     95     private static final String SQL_WHERE_ID_FROM_INSTANCES_SYNCED =
     96             Instances._ID + " IN " +
     97             "(SELECT " + Tables.INSTANCES + "." + Instances._ID + " as _id" +
     98             " FROM " + Tables.INSTANCES +
     99             " INNER JOIN " + Tables.EVENTS +
    100             " ON (" +
    101             Tables.EVENTS + "." + Events._ID + "=" + Tables.INSTANCES + "." + Instances.EVENT_ID +
    102             ")" +
    103             " WHERE " + Tables.EVENTS + "." + Events._SYNC_ID + "=?" + " OR " +
    104                     Tables.EVENTS + "." + Events.ORIGINAL_SYNC_ID + "=?)";
    105 
    106     private static final String[] EXPAND_COLUMNS = new String[] {
    107             Events._ID,
    108             Events._SYNC_ID,
    109             Events.STATUS,
    110             Events.DTSTART,
    111             Events.DTEND,
    112             Events.EVENT_TIMEZONE,
    113             Events.RRULE,
    114             Events.RDATE,
    115             Events.EXRULE,
    116             Events.EXDATE,
    117             Events.DURATION,
    118             Events.ALL_DAY,
    119             Events.ORIGINAL_SYNC_ID,
    120             Events.ORIGINAL_INSTANCE_TIME,
    121             Events.CALENDAR_ID,
    122             Events.DELETED
    123     };
    124 
    125     // To determine if a recurrence exception originally overlapped the
    126     // window, we need to assume a maximum duration, since we only know
    127     // the original start time.
    128     private static final int MAX_ASSUMED_DURATION = 7 * 24 * 60 * 60 * 1000;
    129 
    130     public CalendarInstancesHelper(CalendarDatabaseHelper calendarDbHelper, MetaData metaData) {
    131         mDbHelper = calendarDbHelper;
    132         mMetaData = metaData;
    133         mCalendarCache = new CalendarCache(mDbHelper);
    134     }
    135 
    136     /**
    137      * Extract the value from the specifed row and column of the Events table.
    138      *
    139      * @param db The database to access.
    140      * @param rowId The Event's _id.
    141      * @param columnName The name of the column to access.
    142      * @return The value in string form.
    143      */
    144     private static String getEventValue(SQLiteDatabase db, long rowId, String columnName) {
    145         String where = "SELECT " + columnName + " FROM " + Tables.EVENTS +
    146             " WHERE " + Events._ID + "=?";
    147         return DatabaseUtils.stringForQuery(db, where,
    148                 new String[] { String.valueOf(rowId) });
    149     }
    150 
    151     /**
    152      * Perform instance expansion on the given entries.
    153      *
    154      * @param begin Window start (ms).
    155      * @param end Window end (ms).
    156      * @param localTimezone
    157      * @param entries The entries to process.
    158      */
    159     protected void performInstanceExpansion(long begin, long end, String localTimezone,
    160             Cursor entries) {
    161         // TODO: this only knows how to work with events that have been synced with the server
    162         RecurrenceProcessor rp = new RecurrenceProcessor();
    163 
    164         // Key into the instance values to hold the original event concatenated
    165         // with calendar id.
    166         final String ORIGINAL_EVENT_AND_CALENDAR = "ORIGINAL_EVENT_AND_CALENDAR";
    167 
    168         int statusColumn = entries.getColumnIndex(Events.STATUS);
    169         int dtstartColumn = entries.getColumnIndex(Events.DTSTART);
    170         int dtendColumn = entries.getColumnIndex(Events.DTEND);
    171         int eventTimezoneColumn = entries.getColumnIndex(Events.EVENT_TIMEZONE);
    172         int durationColumn = entries.getColumnIndex(Events.DURATION);
    173         int rruleColumn = entries.getColumnIndex(Events.RRULE);
    174         int rdateColumn = entries.getColumnIndex(Events.RDATE);
    175         int exruleColumn = entries.getColumnIndex(Events.EXRULE);
    176         int exdateColumn = entries.getColumnIndex(Events.EXDATE);
    177         int allDayColumn = entries.getColumnIndex(Events.ALL_DAY);
    178         int idColumn = entries.getColumnIndex(Events._ID);
    179         int syncIdColumn = entries.getColumnIndex(Events._SYNC_ID);
    180         int originalEventColumn = entries.getColumnIndex(Events.ORIGINAL_SYNC_ID);
    181         int originalInstanceTimeColumn = entries.getColumnIndex(Events.ORIGINAL_INSTANCE_TIME);
    182         int calendarIdColumn = entries.getColumnIndex(Events.CALENDAR_ID);
    183         int deletedColumn = entries.getColumnIndex(Events.DELETED);
    184 
    185         ContentValues initialValues;
    186         CalendarInstancesHelper.EventInstancesMap instancesMap =
    187             new CalendarInstancesHelper.EventInstancesMap();
    188 
    189         Duration duration = new Duration();
    190         Time eventTime = new Time();
    191 
    192         // Invariant: entries contains all events that affect the current
    193         // window.  It consists of:
    194         // a) Individual events that fall in the window.  These will be
    195         //    displayed.
    196         // b) Recurrences that included the window.  These will be displayed
    197         //    if not canceled.
    198         // c) Recurrence exceptions that fall in the window.  These will be
    199         //    displayed if not cancellations.
    200         // d) Recurrence exceptions that modify an instance inside the
    201         //    window (subject to 1 week assumption above), but are outside
    202         //    the window.  These will not be displayed.  Cases c and d are
    203         //    distinguished by the start / end time.
    204 
    205         while (entries.moveToNext()) {
    206             try {
    207                 initialValues = null;
    208 
    209                 boolean allDay = entries.getInt(allDayColumn) != 0;
    210 
    211                 String eventTimezone = entries.getString(eventTimezoneColumn);
    212                 if (allDay || TextUtils.isEmpty(eventTimezone)) {
    213                     // in the events table, allDay events start at midnight.
    214                     // this forces them to stay at midnight for all day events
    215                     // TODO: check that this actually does the right thing.
    216                     eventTimezone = Time.TIMEZONE_UTC;
    217                 }
    218 
    219                 long dtstartMillis = entries.getLong(dtstartColumn);
    220                 Long eventId = Long.valueOf(entries.getLong(idColumn));
    221 
    222                 String durationStr = entries.getString(durationColumn);
    223                 if (durationStr != null) {
    224                     try {
    225                         duration.parse(durationStr);
    226                     }
    227                     catch (DateException e) {
    228                         if (Log.isLoggable(CalendarProvider2.TAG, Log.ERROR)) {
    229                             Log.w(CalendarProvider2.TAG, "error parsing duration for event "
    230                                     + eventId + "'" + durationStr + "'", e);
    231                         }
    232                         duration.sign = 1;
    233                         duration.weeks = 0;
    234                         duration.days = 0;
    235                         duration.hours = 0;
    236                         duration.minutes = 0;
    237                         duration.seconds = 0;
    238                         durationStr = "+P0S";
    239                     }
    240                 }
    241 
    242                 String syncId = entries.getString(syncIdColumn);
    243                 String originalEvent = entries.getString(originalEventColumn);
    244 
    245                 long originalInstanceTimeMillis = -1;
    246                 if (!entries.isNull(originalInstanceTimeColumn)) {
    247                     originalInstanceTimeMillis= entries.getLong(originalInstanceTimeColumn);
    248                 }
    249                 int status = entries.getInt(statusColumn);
    250                 boolean deleted = (entries.getInt(deletedColumn) != 0);
    251 
    252                 String rruleStr = entries.getString(rruleColumn);
    253                 String rdateStr = entries.getString(rdateColumn);
    254                 String exruleStr = entries.getString(exruleColumn);
    255                 String exdateStr = entries.getString(exdateColumn);
    256                 long calendarId = entries.getLong(calendarIdColumn);
    257                 // key into instancesMap
    258                 String syncIdKey = CalendarInstancesHelper.getSyncIdKey(syncId, calendarId);
    259 
    260                 RecurrenceSet recur = null;
    261                 try {
    262                     recur = new RecurrenceSet(rruleStr, rdateStr, exruleStr, exdateStr);
    263                 } catch (EventRecurrence.InvalidFormatException e) {
    264                     if (Log.isLoggable(CalendarProvider2.TAG, Log.ERROR)) {
    265                         Log.w(CalendarProvider2.TAG, "Could not parse RRULE recurrence string: "
    266                                 + rruleStr, e);
    267                     }
    268                     continue;
    269                 }
    270 
    271                 if (null != recur && recur.hasRecurrence()) {
    272                     // the event is repeating
    273 
    274                     if (status == Events.STATUS_CANCELED) {
    275                         // should not happen!
    276                         if (Log.isLoggable(CalendarProvider2.TAG, Log.ERROR)) {
    277                             Log.e(CalendarProvider2.TAG, "Found canceled recurring event in "
    278                                     + "Events table.  Ignoring.");
    279                         }
    280                         continue;
    281                     }
    282                     if (deleted) {
    283                         if (Log.isLoggable(CalendarProvider2.TAG, Log.DEBUG)) {
    284                             Log.d(CalendarProvider2.TAG, "Found deleted recurring event in "
    285                                     + "Events table.  Ignoring.");
    286                         }
    287                         continue;
    288                     }
    289 
    290                     // need to parse the event into a local calendar.
    291                     eventTime.timezone = eventTimezone;
    292                     eventTime.set(dtstartMillis);
    293                     eventTime.allDay = allDay;
    294 
    295                     if (durationStr == null) {
    296                         // should not happen.
    297                         if (Log.isLoggable(CalendarProvider2.TAG, Log.ERROR)) {
    298                             Log.e(CalendarProvider2.TAG, "Repeating event has no duration -- "
    299                                     + "should not happen.");
    300                         }
    301                         if (allDay) {
    302                             // set to one day.
    303                             duration.sign = 1;
    304                             duration.weeks = 0;
    305                             duration.days = 1;
    306                             duration.hours = 0;
    307                             duration.minutes = 0;
    308                             duration.seconds = 0;
    309                             durationStr = "+P1D";
    310                         } else {
    311                             // compute the duration from dtend, if we can.
    312                             // otherwise, use 0s.
    313                             duration.sign = 1;
    314                             duration.weeks = 0;
    315                             duration.days = 0;
    316                             duration.hours = 0;
    317                             duration.minutes = 0;
    318                             if (!entries.isNull(dtendColumn)) {
    319                                 long dtendMillis = entries.getLong(dtendColumn);
    320                                 duration.seconds = (int) ((dtendMillis - dtstartMillis) / 1000);
    321                                 durationStr = "+P" + duration.seconds + "S";
    322                             } else {
    323                                 duration.seconds = 0;
    324                                 durationStr = "+P0S";
    325                             }
    326                         }
    327                     }
    328 
    329                     long[] dates;
    330                     dates = rp.expand(eventTime, recur, begin, end);
    331 
    332                     // Initialize the "eventTime" timezone outside the loop.
    333                     // This is used in computeTimezoneDependentFields().
    334                     if (allDay) {
    335                         eventTime.timezone = Time.TIMEZONE_UTC;
    336                     } else {
    337                         eventTime.timezone = localTimezone;
    338                     }
    339 
    340                     long durationMillis = duration.getMillis();
    341                     for (long date : dates) {
    342                         initialValues = new ContentValues();
    343                         initialValues.put(Instances.EVENT_ID, eventId);
    344 
    345                         initialValues.put(Instances.BEGIN, date);
    346                         long dtendMillis = date + durationMillis;
    347                         initialValues.put(Instances.END, dtendMillis);
    348 
    349                         CalendarInstancesHelper.computeTimezoneDependentFields(date, dtendMillis,
    350                                 eventTime, initialValues);
    351                         instancesMap.add(syncIdKey, initialValues);
    352                     }
    353                 } else {
    354                     // the event is not repeating
    355                     initialValues = new ContentValues();
    356 
    357                     // if this event has an "original" field, then record
    358                     // that we need to cancel the original event (we can't
    359                     // do that here because the order of this loop isn't
    360                     // defined)
    361                     if (originalEvent != null && originalInstanceTimeMillis != -1) {
    362                         // The ORIGINAL_EVENT_AND_CALENDAR holds the
    363                         // calendar id concatenated with the ORIGINAL_EVENT to form
    364                         // a unique key, matching the keys for instancesMap.
    365                         initialValues.put(ORIGINAL_EVENT_AND_CALENDAR,
    366                                 CalendarInstancesHelper.getSyncIdKey(originalEvent, calendarId));
    367                         initialValues.put(Events.ORIGINAL_INSTANCE_TIME,
    368                                 originalInstanceTimeMillis);
    369                         initialValues.put(Events.STATUS, status);
    370                     }
    371 
    372                     long dtendMillis = dtstartMillis;
    373                     if (durationStr == null) {
    374                         if (!entries.isNull(dtendColumn)) {
    375                             dtendMillis = entries.getLong(dtendColumn);
    376                         }
    377                     } else {
    378                         dtendMillis = duration.addTo(dtstartMillis);
    379                     }
    380 
    381                     // this non-recurring event might be a recurrence exception that doesn't
    382                     // actually fall within our expansion window, but instead was selected
    383                     // so we can correctly cancel expanded recurrence instances below.  do not
    384                     // add events to the instances map if they don't actually fall within our
    385                     // expansion window.
    386                     if ((dtendMillis < begin) || (dtstartMillis > end)) {
    387                         if (originalEvent != null && originalInstanceTimeMillis != -1) {
    388                             initialValues.put(Events.STATUS, Events.STATUS_CANCELED);
    389                         } else {
    390                             if (Log.isLoggable(CalendarProvider2.TAG, Log.ERROR)) {
    391                                 Log.w(CalendarProvider2.TAG, "Unexpected event outside window: "
    392                                         + syncId);
    393                             }
    394                             continue;
    395                         }
    396                     }
    397 
    398                     initialValues.put(Instances.EVENT_ID, eventId);
    399 
    400                     initialValues.put(Instances.BEGIN, dtstartMillis);
    401                     initialValues.put(Instances.END, dtendMillis);
    402 
    403                     // we temporarily store the DELETED status (will be cleaned later)
    404                     initialValues.put(Events.DELETED, deleted);
    405 
    406                     if (allDay) {
    407                         eventTime.timezone = Time.TIMEZONE_UTC;
    408                     } else {
    409                         eventTime.timezone = localTimezone;
    410                     }
    411                     CalendarInstancesHelper.computeTimezoneDependentFields(dtstartMillis,
    412                             dtendMillis, eventTime, initialValues);
    413 
    414                     instancesMap.add(syncIdKey, initialValues);
    415                 }
    416             } catch (DateException e) {
    417                 if (Log.isLoggable(CalendarProvider2.TAG, Log.ERROR)) {
    418                     Log.w(CalendarProvider2.TAG, "RecurrenceProcessor error ", e);
    419                 }
    420             } catch (TimeFormatException e) {
    421                 if (Log.isLoggable(CalendarProvider2.TAG, Log.ERROR)) {
    422                     Log.w(CalendarProvider2.TAG, "RecurrenceProcessor error ", e);
    423                 }
    424             }
    425         }
    426 
    427         // Invariant: instancesMap contains all instances that affect the
    428         // window, indexed by original sync id concatenated with calendar id.
    429         // It consists of:
    430         // a) Individual events that fall in the window.  They have:
    431         //   EVENT_ID, BEGIN, END
    432         // b) Instances of recurrences that fall in the window.  They may
    433         //   be subject to exceptions.  They have:
    434         //   EVENT_ID, BEGIN, END
    435         // c) Exceptions that fall in the window.  They have:
    436         //   ORIGINAL_EVENT_AND_CALENDAR, ORIGINAL_INSTANCE_TIME, STATUS (since they can
    437         //   be a modification or cancellation), EVENT_ID, BEGIN, END
    438         // d) Recurrence exceptions that modify an instance inside the
    439         //   window but fall outside the window.  They have:
    440         //   ORIGINAL_EVENT_AND_CALENDAR, ORIGINAL_INSTANCE_TIME, STATUS =
    441         //   STATUS_CANCELED, EVENT_ID, BEGIN, END
    442 
    443         // First, delete the original instances corresponding to recurrence
    444         // exceptions.  We do this by iterating over the list and for each
    445         // recurrence exception, we search the list for an instance with a
    446         // matching "original instance time".  If we find such an instance,
    447         // we remove it from the list.  If we don't find such an instance
    448         // then we cancel the recurrence exception.
    449         Set<String> keys = instancesMap.keySet();
    450         for (String syncIdKey : keys) {
    451             CalendarInstancesHelper.InstancesList list = instancesMap.get(syncIdKey);
    452             for (ContentValues values : list) {
    453 
    454                 // If this instance is not a recurrence exception, then
    455                 // skip it.
    456                 if (!values.containsKey(ORIGINAL_EVENT_AND_CALENDAR)) {
    457                     continue;
    458                 }
    459 
    460                 String originalEventPlusCalendar = values.getAsString(ORIGINAL_EVENT_AND_CALENDAR);
    461                 long originalTime = values.getAsLong(Events.ORIGINAL_INSTANCE_TIME);
    462                 CalendarInstancesHelper.InstancesList originalList = instancesMap
    463                         .get(originalEventPlusCalendar);
    464                 if (originalList == null) {
    465                     // The original recurrence is not present, so don't try canceling it.
    466                     continue;
    467                 }
    468 
    469                 // Search the original event for a matching original
    470                 // instance time.  If there is a matching one, then remove
    471                 // the original one.  We do this both for exceptions that
    472                 // change the original instance as well as for exceptions
    473                 // that delete the original instance.
    474                 for (int num = originalList.size() - 1; num >= 0; num--) {
    475                     ContentValues originalValues = originalList.get(num);
    476                     long beginTime = originalValues.getAsLong(Instances.BEGIN);
    477                     if (beginTime == originalTime) {
    478                         // We found the original instance, so remove it.
    479                         originalList.remove(num);
    480                     }
    481                 }
    482             }
    483         }
    484 
    485         // Invariant: instancesMap contains filtered instances.
    486         // It consists of:
    487         // a) Individual events that fall in the window.
    488         // b) Instances of recurrences that fall in the window and have not
    489         //   been subject to exceptions.
    490         // c) Exceptions that fall in the window.  They will have
    491         //   STATUS_CANCELED if they are cancellations.
    492         // d) Recurrence exceptions that modify an instance inside the
    493         //   window but fall outside the window.  These are STATUS_CANCELED.
    494 
    495         // Now do the inserts.  Since the db lock is held when this method is executed,
    496         // this will be done in a transaction.
    497         // NOTE: if there is lock contention (e.g., a sync is trying to merge into the db
    498         // while the calendar app is trying to query the db (expanding instances)), we will
    499         // not be "polite" and yield the lock until we're done.  This will favor local query
    500         // operations over sync/write operations.
    501         for (String syncIdKey : keys) {
    502             CalendarInstancesHelper.InstancesList list = instancesMap.get(syncIdKey);
    503             for (ContentValues values : list) {
    504 
    505                 // If this instance was cancelled or deleted then don't create a new
    506                 // instance.
    507                 Integer status = values.getAsInteger(Events.STATUS);
    508                 boolean deleted = values.containsKey(Events.DELETED) ?
    509                         values.getAsBoolean(Events.DELETED) : false;
    510                 if ((status != null && status == Events.STATUS_CANCELED) || deleted) {
    511                     continue;
    512                 }
    513 
    514                 // We remove this useless key (not valid in the context of Instances table)
    515                 values.remove(Events.DELETED);
    516 
    517                 // Remove these fields before inserting a new instance
    518                 values.remove(ORIGINAL_EVENT_AND_CALENDAR);
    519                 values.remove(Events.ORIGINAL_INSTANCE_TIME);
    520                 values.remove(Events.STATUS);
    521 
    522                 mDbHelper.instancesReplace(values);
    523             }
    524         }
    525     }
    526 
    527     /**
    528      * Make instances for the given range.
    529      */
    530     protected void expandInstanceRangeLocked(long begin, long end, String localTimezone) {
    531 
    532         if (CalendarProvider2.PROFILE) {
    533             Debug.startMethodTracing("expandInstanceRangeLocked");
    534         }
    535 
    536         if (Log.isLoggable(TAG, Log.VERBOSE)) {
    537             Log.v(TAG, "Expanding events between " + begin + " and " + end);
    538         }
    539 
    540         Cursor entries = getEntries(begin, end);
    541         try {
    542             performInstanceExpansion(begin, end, localTimezone, entries);
    543         } finally {
    544             if (entries != null) {
    545                 entries.close();
    546             }
    547         }
    548         if (CalendarProvider2.PROFILE) {
    549             Debug.stopMethodTracing();
    550         }
    551     }
    552 
    553     /**
    554      * Get all entries affecting the given window.
    555      *
    556      * @param begin Window start (ms).
    557      * @param end Window end (ms).
    558      * @return Cursor for the entries; caller must close it.
    559      */
    560     private Cursor getEntries(long begin, long end) {
    561         SQLiteQueryBuilder qb = new SQLiteQueryBuilder();
    562         qb.setTables(CalendarDatabaseHelper.Views.EVENTS);
    563         qb.setProjectionMap(CalendarProvider2.sEventsProjectionMap);
    564 
    565         String beginString = String.valueOf(begin);
    566         String endString = String.valueOf(end);
    567 
    568         // grab recurrence exceptions that fall outside our expansion window but
    569         // modify
    570         // recurrences that do fall within our window. we won't insert these
    571         // into the output
    572         // set of instances, but instead will just add them to our cancellations
    573         // list, so we
    574         // can cancel the correct recurrence expansion instances.
    575         // we don't have originalInstanceDuration or end time. for now, assume
    576         // the original
    577         // instance lasts no longer than 1 week.
    578         // also filter with syncable state (we dont want the entries from a non
    579         // syncable account)
    580         // also filter with last_synced=0 so we don't expand events that were
    581         // dup'ed for partial updates.
    582         // TODO: compute the originalInstanceEndTime or get this from the
    583         // server.
    584         qb.appendWhere(SQL_WHERE_GET_EVENTS_ENTRIES);
    585         String selectionArgs[] = new String[] {
    586                 endString,
    587                 beginString,
    588                 endString,
    589                 String.valueOf(begin - MAX_ASSUMED_DURATION),
    590                 "0", // Calendars.SYNC_EVENTS
    591                 "0", // Events.LAST_SYNCED
    592         };
    593         final SQLiteDatabase db = mDbHelper.getReadableDatabase();
    594         Cursor c = qb.query(db, EXPAND_COLUMNS, null /* selection */, selectionArgs,
    595                 null /* groupBy */, null /* having */, null /* sortOrder */);
    596         if (Log.isLoggable(TAG, Log.VERBOSE)) {
    597             Log.v(TAG, "Instance expansion:  got " + c.getCount() + " entries");
    598         }
    599         return c;
    600     }
    601 
    602     /**
    603      * Updates the instances table when an event is added or updated.
    604      *
    605      * @param values The new values of the event.
    606      * @param rowId The database row id of the event.
    607      * @param newEvent true if the event is new.
    608      * @param db The database
    609      */
    610     public void updateInstancesLocked(ContentValues values, long rowId, boolean newEvent,
    611             SQLiteDatabase db) {
    612         /*
    613          * This may be a recurring event (has an RRULE or RDATE), an exception to a recurring
    614          * event (has ORIGINAL_ID or ORIGINAL_SYNC_ID), or a regular event.  Recurring events
    615          * and exceptions require additional handling.
    616          *
    617          * If this is not a new event, it may already have entries in Instances, so we want
    618          * to delete those before we do any additional work.
    619          */
    620 
    621         // If there are no expanded Instances, then return.
    622         MetaData.Fields fields = mMetaData.getFieldsLocked();
    623         if (fields.maxInstance == 0) {
    624             return;
    625         }
    626 
    627         Long dtstartMillis = values.getAsLong(Events.DTSTART);
    628         if (dtstartMillis == null) {
    629             if (newEvent) {
    630                 // must be present for a new event.
    631                 throw new RuntimeException("DTSTART missing.");
    632             }
    633             if (Log.isLoggable(TAG, Log.VERBOSE)) {
    634                 Log.v(TAG, "Missing DTSTART.  No need to update instance.");
    635             }
    636             return;
    637         }
    638 
    639         if (!newEvent) {
    640             // Want to do this for regular event, recurrence, or exception.
    641             // For recurrence or exception, more deletion may happen below if we
    642             // do an instance expansion. This deletion will suffice if the
    643             // exception
    644             // is moved outside the window, for instance.
    645             db.delete(Tables.INSTANCES, Instances.EVENT_ID + "=?", new String[] {
    646                 String.valueOf(rowId)
    647             });
    648         }
    649 
    650         String rrule = values.getAsString(Events.RRULE);
    651         String rdate = values.getAsString(Events.RDATE);
    652         String originalId = values.getAsString(Events.ORIGINAL_ID);
    653         String originalSyncId = values.getAsString(Events.ORIGINAL_SYNC_ID);
    654         if (CalendarProvider2.isRecurrenceEvent(rrule, rdate, originalId, originalSyncId)) {
    655             Long lastDateMillis = values.getAsLong(Events.LAST_DATE);
    656             Long originalInstanceTime = values.getAsLong(Events.ORIGINAL_INSTANCE_TIME);
    657 
    658             // The recurrence or exception needs to be (re-)expanded if:
    659             // a) Exception or recurrence that falls inside window
    660             boolean insideWindow = dtstartMillis <= fields.maxInstance
    661                     && (lastDateMillis == null || lastDateMillis >= fields.minInstance);
    662             // b) Exception that affects instance inside window
    663             // These conditions match the query in getEntries
    664             // See getEntries comment for explanation of subtracting 1 week.
    665             boolean affectsWindow = originalInstanceTime != null
    666                     && originalInstanceTime <= fields.maxInstance
    667                     && originalInstanceTime >= fields.minInstance - MAX_ASSUMED_DURATION;
    668             if (CalendarProvider2.DEBUG_INSTANCES) {
    669                 Log.d(TAG + "-i", "Recurrence: inside=" + insideWindow +
    670                         ", affects=" + affectsWindow);
    671             }
    672             if (insideWindow || affectsWindow) {
    673                 updateRecurrenceInstancesLocked(values, rowId, db);
    674             }
    675             // TODO: an exception creation or update could be optimized by
    676             // updating just the affected instances, instead of regenerating
    677             // the recurrence.
    678             return;
    679         }
    680 
    681         Long dtendMillis = values.getAsLong(Events.DTEND);
    682         if (dtendMillis == null) {
    683             dtendMillis = dtstartMillis;
    684         }
    685 
    686         // if the event is in the expanded range, insert
    687         // into the instances table.
    688         // TODO: deal with durations. currently, durations are only used in
    689         // recurrences.
    690 
    691         if (dtstartMillis <= fields.maxInstance && dtendMillis >= fields.minInstance) {
    692             ContentValues instanceValues = new ContentValues();
    693             instanceValues.put(Instances.EVENT_ID, rowId);
    694             instanceValues.put(Instances.BEGIN, dtstartMillis);
    695             instanceValues.put(Instances.END, dtendMillis);
    696 
    697             boolean allDay = false;
    698             Integer allDayInteger = values.getAsInteger(Events.ALL_DAY);
    699             if (allDayInteger != null) {
    700                 allDay = allDayInteger != 0;
    701             }
    702 
    703             // Update the timezone-dependent fields.
    704             Time local = new Time();
    705             if (allDay) {
    706                 local.timezone = Time.TIMEZONE_UTC;
    707             } else {
    708                 local.timezone = fields.timezone;
    709             }
    710 
    711             CalendarInstancesHelper.computeTimezoneDependentFields(dtstartMillis, dtendMillis,
    712                     local, instanceValues);
    713             mDbHelper.instancesInsert(instanceValues);
    714         }
    715     }
    716 
    717     /**
    718      * Do incremental Instances update of a recurrence or recurrence exception.
    719      * This method does performInstanceExpansion on just the modified
    720      * recurrence, to avoid the overhead of recomputing the entire instance
    721      * table.
    722      *
    723      * @param values The new values of the event.
    724      * @param rowId The database row id of the event.
    725      * @param db The database
    726      */
    727     private void updateRecurrenceInstancesLocked(ContentValues values, long rowId,
    728             SQLiteDatabase db) {
    729         /*
    730          *  There are two categories of event that "rowId" may refer to:
    731          *  (1) Recurrence event.
    732          *  (2) Exception to recurrence event.  Has non-empty originalId (if it originated
    733          *      locally), originalSyncId (if it originated from the server), or both (if
    734          *      it's fully synchronized).
    735          *
    736          * Exceptions may arrive from the server before the recurrence event, which means:
    737          *  - We could find an originalSyncId but a lookup on originalSyncId could fail (in
    738          *    which case we can just ignore the exception for now).
    739          *  - There may be a brief period between the time we receive a recurrence and the
    740          *    time we set originalId in related exceptions where originalSyncId is the only
    741          *    way to find exceptions for a recurrence.  Thus, an empty originalId field may
    742          *    not be used to decide if an event is an exception.
    743          */
    744 
    745         MetaData.Fields fields = mMetaData.getFieldsLocked();
    746         String instancesTimezone = mCalendarCache.readTimezoneInstances();
    747 
    748         // Get the originalSyncId.  If it's not in "values", check the database.
    749         String originalSyncId = values.getAsString(Events.ORIGINAL_SYNC_ID);
    750         if (originalSyncId == null) {
    751             originalSyncId = getEventValue(db, rowId, Events.ORIGINAL_SYNC_ID);
    752         }
    753 
    754         String recurrenceSyncId;
    755         if (originalSyncId != null) {
    756             // This event is an exception; set recurrenceSyncId to the original.
    757             recurrenceSyncId = originalSyncId;
    758         } else {
    759             // This could be a recurrence or an exception.  If it has been synced with the
    760             // server we can get the _sync_id and know for certain that it's a recurrence.
    761             // If not, we'll deal with it below.
    762             recurrenceSyncId = values.getAsString(Events._SYNC_ID);
    763             if (recurrenceSyncId == null) {
    764                 // Not in "values", check the database.
    765                 recurrenceSyncId = getEventValue(db, rowId, Events._SYNC_ID);
    766             }
    767         }
    768 
    769         // Clear out old instances
    770         int delCount;
    771         if (recurrenceSyncId == null) {
    772             // We're creating or updating a recurrence or exception that hasn't been to the
    773             // server.  If this is a recurrence event, the event ID is simply the rowId.  If
    774             // it's an exception, we will find the value in the originalId field.
    775             String originalId = values.getAsString(Events.ORIGINAL_ID);
    776             if (originalId == null) {
    777                 // Not in "values", check the database.
    778                 originalId = getEventValue(db, rowId, Events.ORIGINAL_ID);
    779             }
    780             String recurrenceId;
    781             if (originalId != null) {
    782                 // This event is an exception; set recurrenceId to the original.
    783                 recurrenceId = originalId;
    784             } else {
    785                 // This event is a recurrence, so we just use the ID that was passed in.
    786                 recurrenceId = String.valueOf(rowId);
    787             }
    788 
    789             // Delete Instances entries for this Event (_id == recurrenceId) and for exceptions
    790             // to this Event (originalId == recurrenceId).
    791             String where = SQL_WHERE_ID_FROM_INSTANCES_NOT_SYNCED;
    792             delCount = db.delete(Tables.INSTANCES, where, new String[] {
    793                     recurrenceId, recurrenceId
    794             });
    795         } else {
    796             // We're creating or updating a recurrence or exception that has been synced with
    797             // the server.  Delete Instances entries for this Event (_sync_id == recurrenceSyncId)
    798             // and for exceptions to this Event (originalSyncId == recurrenceSyncId).
    799             String where = SQL_WHERE_ID_FROM_INSTANCES_SYNCED;
    800             delCount = db.delete(Tables.INSTANCES, where, new String[] {
    801                     recurrenceSyncId, recurrenceSyncId
    802             });
    803         }
    804 
    805         //Log.d(TAG, "Recurrence: deleted " + delCount + " instances");
    806         //dumpInstancesTable(db);
    807 
    808         // Now do instance expansion
    809         // TODO: passing "rowId" is wrong if this is an exception - need originalId then
    810         Cursor entries = getRelevantRecurrenceEntries(recurrenceSyncId, rowId);
    811         try {
    812             performInstanceExpansion(fields.minInstance, fields.maxInstance,
    813                     instancesTimezone, entries);
    814         } finally {
    815             if (entries != null) {
    816                 entries.close();
    817             }
    818         }
    819     }
    820 
    821     /**
    822      * Determines the recurrence entries associated with a particular
    823      * recurrence. This set is the base recurrence and any exception. Normally
    824      * the entries are indicated by the sync id of the base recurrence (which is
    825      * the originalSyncId in the exceptions). However, a complication is that a
    826      * recurrence may not yet have a sync id. In that case, the recurrence is
    827      * specified by the rowId.
    828      *
    829      * @param recurrenceSyncId The sync id of the base recurrence, or null.
    830      * @param rowId The row id of the base recurrence.
    831      * @return the relevant entries.
    832      */
    833     private Cursor getRelevantRecurrenceEntries(String recurrenceSyncId, long rowId) {
    834         SQLiteQueryBuilder qb = new SQLiteQueryBuilder();
    835 
    836         qb.setTables(CalendarDatabaseHelper.Views.EVENTS);
    837         qb.setProjectionMap(CalendarProvider2.sEventsProjectionMap);
    838         String selectionArgs[];
    839         if (recurrenceSyncId == null) {
    840             String where = CalendarProvider2.SQL_WHERE_ID;
    841             qb.appendWhere(where);
    842             selectionArgs = new String[] {
    843                 String.valueOf(rowId)
    844             };
    845         } else {
    846             // don't expand events that were dup'ed for partial updates
    847             String where = "(" + Events._SYNC_ID + "=? OR " + Events.ORIGINAL_SYNC_ID + "=?) AND "
    848                     + Events.LAST_SYNCED + " = ?";
    849             qb.appendWhere(where);
    850             selectionArgs = new String[] {
    851                     recurrenceSyncId,
    852                     recurrenceSyncId,
    853                     "0", // Events.LAST_SYNCED
    854             };
    855         }
    856         if (Log.isLoggable(TAG, Log.VERBOSE)) {
    857             Log.v(TAG, "Retrieving events to expand: " + qb.toString());
    858         }
    859 
    860         final SQLiteDatabase db = mDbHelper.getReadableDatabase();
    861         return qb.query(db, EXPAND_COLUMNS, null /* selection */, selectionArgs,
    862                 null /* groupBy */, null /* having */, null /* sortOrder */);
    863     }
    864 
    865     /**
    866      * Generates a unique key from the syncId and calendarId. The purpose of
    867      * this is to prevent collisions if two different calendars use the same
    868      * sync id. This can happen if a Google calendar is accessed by two
    869      * different accounts, or with Exchange, where ids are not unique between
    870      * calendars.
    871      *
    872      * @param syncId Id for the event
    873      * @param calendarId Id for the calendar
    874      * @return key
    875      */
    876     static String getSyncIdKey(String syncId, long calendarId) {
    877         return calendarId + ":" + syncId;
    878     }
    879 
    880     /**
    881      * Computes the timezone-dependent fields of an instance of an event and
    882      * updates the "values" map to contain those fields.
    883      *
    884      * @param begin the start time of the instance (in UTC milliseconds)
    885      * @param end the end time of the instance (in UTC milliseconds)
    886      * @param local a Time object with the timezone set to the local timezone
    887      * @param values a map that will contain the timezone-dependent fields
    888      */
    889     static void computeTimezoneDependentFields(long begin, long end,
    890             Time local, ContentValues values) {
    891         local.set(begin);
    892         int startDay = Time.getJulianDay(begin, local.gmtoff);
    893         int startMinute = local.hour * 60 + local.minute;
    894 
    895         local.set(end);
    896         int endDay = Time.getJulianDay(end, local.gmtoff);
    897         int endMinute = local.hour * 60 + local.minute;
    898 
    899         // Special case for midnight, which has endMinute == 0.  Change
    900         // that to +24 hours on the previous day to make everything simpler.
    901         // Exception: if start and end minute are both 0 on the same day,
    902         // then leave endMinute alone.
    903         if (endMinute == 0 && endDay > startDay) {
    904             endMinute = 24 * 60;
    905             endDay -= 1;
    906         }
    907 
    908         values.put(Instances.START_DAY, startDay);
    909         values.put(Instances.END_DAY, endDay);
    910         values.put(Instances.START_MINUTE, startMinute);
    911         values.put(Instances.END_MINUTE, endMinute);
    912     }
    913 
    914     /**
    915      * Dumps the contents of the Instances table to the log file.
    916      */
    917     private static void dumpInstancesTable(SQLiteDatabase db) {
    918         Cursor cursor = db.query(Tables.INSTANCES, null, null, null, null, null, null);
    919         DatabaseUtils.dumpCursor(cursor);
    920         if (cursor != null) {
    921             cursor.close();
    922         }
    923     }
    924 }
    925