| /* |
| * Copyright (C) 2007 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.calendarcommon2; |
| |
| import android.content.ContentValues; |
| import android.database.Cursor; |
| import android.provider.CalendarContract; |
| import android.text.TextUtils; |
| import android.text.format.Time; |
| import android.util.Log; |
| import android.util.TimeFormatException; |
| |
| import java.util.ArrayList; |
| import java.util.List; |
| import java.util.regex.Pattern; |
| |
| /** |
| * Basic information about a recurrence, following RFC 2445 Section 4.8.5. |
| * Contains the RRULEs, RDATE, EXRULEs, and EXDATE properties. |
| */ |
| public class RecurrenceSet { |
| |
| private final static String TAG = "RecurrenceSet"; |
| |
| private final static String RULE_SEPARATOR = "\n"; |
| private final static String FOLDING_SEPARATOR = "\n "; |
| |
| // TODO: make these final? |
| public EventRecurrence[] rrules = null; |
| public long[] rdates = null; |
| public EventRecurrence[] exrules = null; |
| public long[] exdates = null; |
| |
| /** |
| * Creates a new RecurrenceSet from information stored in the |
| * events table in the CalendarProvider. |
| * @param values The values retrieved from the Events table. |
| */ |
| public RecurrenceSet(ContentValues values) |
| throws EventRecurrence.InvalidFormatException { |
| String rruleStr = values.getAsString(CalendarContract.Events.RRULE); |
| String rdateStr = values.getAsString(CalendarContract.Events.RDATE); |
| String exruleStr = values.getAsString(CalendarContract.Events.EXRULE); |
| String exdateStr = values.getAsString(CalendarContract.Events.EXDATE); |
| init(rruleStr, rdateStr, exruleStr, exdateStr); |
| } |
| |
| /** |
| * Creates a new RecurrenceSet from information stored in a database |
| * {@link Cursor} pointing to the events table in the |
| * CalendarProvider. The cursor must contain the RRULE, RDATE, EXRULE, |
| * and EXDATE columns. |
| * |
| * @param cursor The cursor containing the RRULE, RDATE, EXRULE, and EXDATE |
| * columns. |
| */ |
| public RecurrenceSet(Cursor cursor) |
| throws EventRecurrence.InvalidFormatException { |
| int rruleColumn = cursor.getColumnIndex(CalendarContract.Events.RRULE); |
| int rdateColumn = cursor.getColumnIndex(CalendarContract.Events.RDATE); |
| int exruleColumn = cursor.getColumnIndex(CalendarContract.Events.EXRULE); |
| int exdateColumn = cursor.getColumnIndex(CalendarContract.Events.EXDATE); |
| String rruleStr = cursor.getString(rruleColumn); |
| String rdateStr = cursor.getString(rdateColumn); |
| String exruleStr = cursor.getString(exruleColumn); |
| String exdateStr = cursor.getString(exdateColumn); |
| init(rruleStr, rdateStr, exruleStr, exdateStr); |
| } |
| |
| public RecurrenceSet(String rruleStr, String rdateStr, |
| String exruleStr, String exdateStr) |
| throws EventRecurrence.InvalidFormatException { |
| init(rruleStr, rdateStr, exruleStr, exdateStr); |
| } |
| |
| private void init(String rruleStr, String rdateStr, |
| String exruleStr, String exdateStr) |
| throws EventRecurrence.InvalidFormatException { |
| if (!TextUtils.isEmpty(rruleStr) || !TextUtils.isEmpty(rdateStr)) { |
| |
| if (!TextUtils.isEmpty(rruleStr)) { |
| String[] rruleStrs = rruleStr.split(RULE_SEPARATOR); |
| rrules = new EventRecurrence[rruleStrs.length]; |
| for (int i = 0; i < rruleStrs.length; ++i) { |
| EventRecurrence rrule = new EventRecurrence(); |
| rrule.parse(rruleStrs[i]); |
| rrules[i] = rrule; |
| } |
| } |
| |
| if (!TextUtils.isEmpty(rdateStr)) { |
| rdates = parseRecurrenceDates(rdateStr); |
| } |
| |
| if (!TextUtils.isEmpty(exruleStr)) { |
| String[] exruleStrs = exruleStr.split(RULE_SEPARATOR); |
| exrules = new EventRecurrence[exruleStrs.length]; |
| for (int i = 0; i < exruleStrs.length; ++i) { |
| EventRecurrence exrule = new EventRecurrence(); |
| exrule.parse(exruleStr); |
| exrules[i] = exrule; |
| } |
| } |
| |
| if (!TextUtils.isEmpty(exdateStr)) { |
| final List<Long> list = new ArrayList<Long>(); |
| for (String exdate : exdateStr.split(RULE_SEPARATOR)) { |
| final long[] dates = parseRecurrenceDates(exdate); |
| for (long date : dates) { |
| list.add(date); |
| } |
| } |
| exdates = new long[list.size()]; |
| for (int i = 0, n = list.size(); i < n; i++) { |
| exdates[i] = list.get(i); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Returns whether or not a recurrence is defined in this RecurrenceSet. |
| * @return Whether or not a recurrence is defined in this RecurrenceSet. |
| */ |
| public boolean hasRecurrence() { |
| return (rrules != null || rdates != null); |
| } |
| |
| /** |
| * Parses the provided RDATE or EXDATE string into an array of longs |
| * representing each date/time in the recurrence. |
| * @param recurrence The recurrence to be parsed. |
| * @return The list of date/times. |
| */ |
| public static long[] parseRecurrenceDates(String recurrence) |
| throws EventRecurrence.InvalidFormatException{ |
| // TODO: use "local" time as the default. will need to handle times |
| // that end in "z" (UTC time) explicitly at that point. |
| String tz = Time.TIMEZONE_UTC; |
| int tzidx = recurrence.indexOf(";"); |
| if (tzidx != -1) { |
| tz = recurrence.substring(0, tzidx); |
| recurrence = recurrence.substring(tzidx + 1); |
| } |
| Time time = new Time(tz); |
| String[] rawDates = recurrence.split(","); |
| int n = rawDates.length; |
| long[] dates = new long[n]; |
| for (int i = 0; i<n; ++i) { |
| // The timezone is updated to UTC if the time string specified 'Z'. |
| try { |
| time.parse(rawDates[i]); |
| } catch (TimeFormatException e) { |
| throw new EventRecurrence.InvalidFormatException( |
| "TimeFormatException thrown when parsing time " + rawDates[i] |
| + " in recurrence " + recurrence); |
| |
| } |
| dates[i] = time.toMillis(false /* use isDst */); |
| time.timezone = tz; |
| } |
| return dates; |
| } |
| |
| /** |
| * Populates the database map of values with the appropriate RRULE, RDATE, |
| * EXRULE, and EXDATE values extracted from the parsed iCalendar component. |
| * @param component The iCalendar component containing the desired |
| * recurrence specification. |
| * @param values The db values that should be updated. |
| * @return true if the component contained the necessary information |
| * to specify a recurrence. The required fields are DTSTART, |
| * one of DTEND/DURATION, and one of RRULE/RDATE. Returns false if |
| * there was an error, including if the date is out of range. |
| */ |
| public static boolean populateContentValues(ICalendar.Component component, |
| ContentValues values) { |
| try { |
| ICalendar.Property dtstartProperty = |
| component.getFirstProperty("DTSTART"); |
| String dtstart = dtstartProperty.getValue(); |
| ICalendar.Parameter tzidParam = |
| dtstartProperty.getFirstParameter("TZID"); |
| // NOTE: the timezone may be null, if this is a floating time. |
| String tzid = tzidParam == null ? null : tzidParam.value; |
| Time start = new Time(tzidParam == null ? Time.TIMEZONE_UTC : tzid); |
| boolean inUtc = start.parse(dtstart); |
| boolean allDay = start.allDay; |
| |
| // We force TimeZone to UTC for "all day recurring events" as the server is sending no |
| // TimeZone in DTSTART for them |
| if (inUtc || allDay) { |
| tzid = Time.TIMEZONE_UTC; |
| } |
| |
| String duration = computeDuration(start, component); |
| String rrule = flattenProperties(component, "RRULE"); |
| String rdate = extractDates(component.getFirstProperty("RDATE")); |
| String exrule = flattenProperties(component, "EXRULE"); |
| String exdate = extractDates(component.getFirstProperty("EXDATE")); |
| |
| if ((TextUtils.isEmpty(dtstart))|| |
| (TextUtils.isEmpty(duration))|| |
| ((TextUtils.isEmpty(rrule))&& |
| (TextUtils.isEmpty(rdate)))) { |
| if (false) { |
| Log.d(TAG, "Recurrence missing DTSTART, DTEND/DURATION, " |
| + "or RRULE/RDATE: " |
| + component.toString()); |
| } |
| return false; |
| } |
| |
| if (allDay) { |
| start.timezone = Time.TIMEZONE_UTC; |
| } |
| long millis = start.toMillis(false /* use isDst */); |
| values.put(CalendarContract.Events.DTSTART, millis); |
| if (millis == -1) { |
| if (false) { |
| Log.d(TAG, "DTSTART is out of range: " + component.toString()); |
| } |
| return false; |
| } |
| |
| values.put(CalendarContract.Events.RRULE, rrule); |
| values.put(CalendarContract.Events.RDATE, rdate); |
| values.put(CalendarContract.Events.EXRULE, exrule); |
| values.put(CalendarContract.Events.EXDATE, exdate); |
| values.put(CalendarContract.Events.EVENT_TIMEZONE, tzid); |
| values.put(CalendarContract.Events.DURATION, duration); |
| values.put(CalendarContract.Events.ALL_DAY, allDay ? 1 : 0); |
| return true; |
| } catch (TimeFormatException e) { |
| // Something is wrong with the format of this event |
| Log.i(TAG,"Failed to parse event: " + component.toString()); |
| return false; |
| } |
| } |
| |
| // This can be removed when the old CalendarSyncAdapter is removed. |
| public static boolean populateComponent(Cursor cursor, |
| ICalendar.Component component) { |
| |
| int dtstartColumn = cursor.getColumnIndex(CalendarContract.Events.DTSTART); |
| int durationColumn = cursor.getColumnIndex(CalendarContract.Events.DURATION); |
| int tzidColumn = cursor.getColumnIndex(CalendarContract.Events.EVENT_TIMEZONE); |
| int rruleColumn = cursor.getColumnIndex(CalendarContract.Events.RRULE); |
| int rdateColumn = cursor.getColumnIndex(CalendarContract.Events.RDATE); |
| int exruleColumn = cursor.getColumnIndex(CalendarContract.Events.EXRULE); |
| int exdateColumn = cursor.getColumnIndex(CalendarContract.Events.EXDATE); |
| int allDayColumn = cursor.getColumnIndex(CalendarContract.Events.ALL_DAY); |
| |
| |
| long dtstart = -1; |
| if (!cursor.isNull(dtstartColumn)) { |
| dtstart = cursor.getLong(dtstartColumn); |
| } |
| String duration = cursor.getString(durationColumn); |
| String tzid = cursor.getString(tzidColumn); |
| String rruleStr = cursor.getString(rruleColumn); |
| String rdateStr = cursor.getString(rdateColumn); |
| String exruleStr = cursor.getString(exruleColumn); |
| String exdateStr = cursor.getString(exdateColumn); |
| boolean allDay = cursor.getInt(allDayColumn) == 1; |
| |
| if ((dtstart == -1) || |
| (TextUtils.isEmpty(duration))|| |
| ((TextUtils.isEmpty(rruleStr))&& |
| (TextUtils.isEmpty(rdateStr)))) { |
| // no recurrence. |
| return false; |
| } |
| |
| ICalendar.Property dtstartProp = new ICalendar.Property("DTSTART"); |
| Time dtstartTime = null; |
| if (!TextUtils.isEmpty(tzid)) { |
| if (!allDay) { |
| dtstartProp.addParameter(new ICalendar.Parameter("TZID", tzid)); |
| } |
| dtstartTime = new Time(tzid); |
| } else { |
| // use the "floating" timezone |
| dtstartTime = new Time(Time.TIMEZONE_UTC); |
| } |
| |
| dtstartTime.set(dtstart); |
| // make sure the time is printed just as a date, if all day. |
| // TODO: android.pim.Time really should take care of this for us. |
| if (allDay) { |
| dtstartProp.addParameter(new ICalendar.Parameter("VALUE", "DATE")); |
| dtstartTime.allDay = true; |
| dtstartTime.hour = 0; |
| dtstartTime.minute = 0; |
| dtstartTime.second = 0; |
| } |
| |
| dtstartProp.setValue(dtstartTime.format2445()); |
| component.addProperty(dtstartProp); |
| ICalendar.Property durationProp = new ICalendar.Property("DURATION"); |
| durationProp.setValue(duration); |
| component.addProperty(durationProp); |
| |
| addPropertiesForRuleStr(component, "RRULE", rruleStr); |
| addPropertyForDateStr(component, "RDATE", rdateStr); |
| addPropertiesForRuleStr(component, "EXRULE", exruleStr); |
| addPropertyForDateStr(component, "EXDATE", exdateStr); |
| return true; |
| } |
| |
| public static boolean populateComponent(ContentValues values, |
| ICalendar.Component component) { |
| long dtstart = -1; |
| if (values.containsKey(CalendarContract.Events.DTSTART)) { |
| dtstart = values.getAsLong(CalendarContract.Events.DTSTART); |
| } |
| final String duration = values.getAsString(CalendarContract.Events.DURATION); |
| final String tzid = values.getAsString(CalendarContract.Events.EVENT_TIMEZONE); |
| final String rruleStr = values.getAsString(CalendarContract.Events.RRULE); |
| final String rdateStr = values.getAsString(CalendarContract.Events.RDATE); |
| final String exruleStr = values.getAsString(CalendarContract.Events.EXRULE); |
| final String exdateStr = values.getAsString(CalendarContract.Events.EXDATE); |
| final Integer allDayInteger = values.getAsInteger(CalendarContract.Events.ALL_DAY); |
| final boolean allDay = (null != allDayInteger) ? (allDayInteger == 1) : false; |
| |
| if ((dtstart == -1) || |
| (TextUtils.isEmpty(duration))|| |
| ((TextUtils.isEmpty(rruleStr))&& |
| (TextUtils.isEmpty(rdateStr)))) { |
| // no recurrence. |
| return false; |
| } |
| |
| ICalendar.Property dtstartProp = new ICalendar.Property("DTSTART"); |
| Time dtstartTime = null; |
| if (!TextUtils.isEmpty(tzid)) { |
| if (!allDay) { |
| dtstartProp.addParameter(new ICalendar.Parameter("TZID", tzid)); |
| } |
| dtstartTime = new Time(tzid); |
| } else { |
| // use the "floating" timezone |
| dtstartTime = new Time(Time.TIMEZONE_UTC); |
| } |
| |
| dtstartTime.set(dtstart); |
| // make sure the time is printed just as a date, if all day. |
| // TODO: android.pim.Time really should take care of this for us. |
| if (allDay) { |
| dtstartProp.addParameter(new ICalendar.Parameter("VALUE", "DATE")); |
| dtstartTime.allDay = true; |
| dtstartTime.hour = 0; |
| dtstartTime.minute = 0; |
| dtstartTime.second = 0; |
| } |
| |
| dtstartProp.setValue(dtstartTime.format2445()); |
| component.addProperty(dtstartProp); |
| ICalendar.Property durationProp = new ICalendar.Property("DURATION"); |
| durationProp.setValue(duration); |
| component.addProperty(durationProp); |
| |
| addPropertiesForRuleStr(component, "RRULE", rruleStr); |
| addPropertyForDateStr(component, "RDATE", rdateStr); |
| addPropertiesForRuleStr(component, "EXRULE", exruleStr); |
| addPropertyForDateStr(component, "EXDATE", exdateStr); |
| return true; |
| } |
| |
| public static void addPropertiesForRuleStr(ICalendar.Component component, |
| String propertyName, |
| String ruleStr) { |
| if (TextUtils.isEmpty(ruleStr)) { |
| return; |
| } |
| String[] rrules = getRuleStrings(ruleStr); |
| for (String rrule : rrules) { |
| ICalendar.Property prop = new ICalendar.Property(propertyName); |
| prop.setValue(rrule); |
| component.addProperty(prop); |
| } |
| } |
| |
| private static String[] getRuleStrings(String ruleStr) { |
| if (null == ruleStr) { |
| return new String[0]; |
| } |
| String unfoldedRuleStr = unfold(ruleStr); |
| String[] split = unfoldedRuleStr.split(RULE_SEPARATOR); |
| int count = split.length; |
| for (int n = 0; n < count; n++) { |
| split[n] = fold(split[n]); |
| } |
| return split; |
| } |
| |
| |
| private static final Pattern IGNORABLE_ICAL_WHITESPACE_RE = |
| Pattern.compile("(?:\\r\\n?|\\n)[ \t]"); |
| |
| private static final Pattern FOLD_RE = Pattern.compile(".{75}"); |
| |
| /** |
| * fold and unfolds ical content lines as per RFC 2445 section 4.1. |
| * |
| * <h3>4.1 Content Lines</h3> |
| * |
| * <p>The iCalendar object is organized into individual lines of text, called |
| * content lines. Content lines are delimited by a line break, which is a CRLF |
| * sequence (US-ASCII decimal 13, followed by US-ASCII decimal 10). |
| * |
| * <p>Lines of text SHOULD NOT be longer than 75 octets, excluding the line |
| * break. Long content lines SHOULD be split into a multiple line |
| * representations using a line "folding" technique. That is, a long line can |
| * be split between any two characters by inserting a CRLF immediately |
| * followed by a single linear white space character (i.e., SPACE, US-ASCII |
| * decimal 32 or HTAB, US-ASCII decimal 9). Any sequence of CRLF followed |
| * immediately by a single linear white space character is ignored (i.e., |
| * removed) when processing the content type. |
| */ |
| public static String fold(String unfoldedIcalContent) { |
| return FOLD_RE.matcher(unfoldedIcalContent).replaceAll("$0\r\n "); |
| } |
| |
| public static String unfold(String foldedIcalContent) { |
| return IGNORABLE_ICAL_WHITESPACE_RE.matcher( |
| foldedIcalContent).replaceAll(""); |
| } |
| |
| public static void addPropertyForDateStr(ICalendar.Component component, |
| String propertyName, |
| String dateStr) { |
| if (TextUtils.isEmpty(dateStr)) { |
| return; |
| } |
| |
| ICalendar.Property prop = new ICalendar.Property(propertyName); |
| String tz = null; |
| int tzidx = dateStr.indexOf(";"); |
| if (tzidx != -1) { |
| tz = dateStr.substring(0, tzidx); |
| dateStr = dateStr.substring(tzidx + 1); |
| } |
| if (!TextUtils.isEmpty(tz)) { |
| prop.addParameter(new ICalendar.Parameter("TZID", tz)); |
| } |
| prop.setValue(dateStr); |
| component.addProperty(prop); |
| } |
| |
| private static String computeDuration(Time start, |
| ICalendar.Component component) { |
| // see if a duration is defined |
| ICalendar.Property durationProperty = |
| component.getFirstProperty("DURATION"); |
| if (durationProperty != null) { |
| // just return the duration |
| return durationProperty.getValue(); |
| } |
| |
| // must compute a duration from the DTEND |
| ICalendar.Property dtendProperty = |
| component.getFirstProperty("DTEND"); |
| if (dtendProperty == null) { |
| // no DURATION, no DTEND: 0 second duration |
| return "+P0S"; |
| } |
| ICalendar.Parameter endTzidParameter = |
| dtendProperty.getFirstParameter("TZID"); |
| String endTzid = (endTzidParameter == null) |
| ? start.timezone : endTzidParameter.value; |
| |
| Time end = new Time(endTzid); |
| end.parse(dtendProperty.getValue()); |
| long durationMillis = end.toMillis(false /* use isDst */) |
| - start.toMillis(false /* use isDst */); |
| long durationSeconds = (durationMillis / 1000); |
| if (start.allDay && (durationSeconds % 86400) == 0) { |
| return "P" + (durationSeconds / 86400) + "D"; // Server wants this instead of P86400S |
| } else { |
| return "P" + durationSeconds + "S"; |
| } |
| } |
| |
| private static String flattenProperties(ICalendar.Component component, |
| String name) { |
| List<ICalendar.Property> properties = component.getProperties(name); |
| if (properties == null || properties.isEmpty()) { |
| return null; |
| } |
| |
| if (properties.size() == 1) { |
| return properties.get(0).getValue(); |
| } |
| |
| StringBuilder sb = new StringBuilder(); |
| |
| boolean first = true; |
| for (ICalendar.Property property : component.getProperties(name)) { |
| if (first) { |
| first = false; |
| } else { |
| // TODO: use commas. our RECUR parsing should handle that |
| // anyway. |
| sb.append(RULE_SEPARATOR); |
| } |
| sb.append(property.getValue()); |
| } |
| return sb.toString(); |
| } |
| |
| private static String extractDates(ICalendar.Property recurrence) { |
| if (recurrence == null) { |
| return null; |
| } |
| ICalendar.Parameter tzidParam = |
| recurrence.getFirstParameter("TZID"); |
| if (tzidParam != null) { |
| return tzidParam.value + ";" + recurrence.getValue(); |
| } |
| return recurrence.getValue(); |
| } |
| } |
