Changeset 2167

Timestamp:

06/15/07 06:50:54 (1 year ago)

Author:

abaumann

Message:

Implement support for extended calendar format in new models (ticket #425)
This is untested (because I don't have the hardware) but probably also
breaks things on older models. It'll need revising.

Also some minor changes to XML-related code to correct for
inconsistencies with the vformat converters.

Files:

• plugins/moto-sync/motosync.py (modified) (39 diffs)

plugins/moto-sync/motosync.py

@@ -44 +44 @@
-SUPPORTED_OBJTYPES = ['event', 'contact']
-
-CAPABILITIES = """<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<capabilities>
-    <contact>
-        <Address />
-        <Birthday />
-        <Categories />
-        <EMail />
-        <FormattedName />
-        <Name />
-        <Nickname />
-        <Telephone />
-    </contact>
-    <event>
-        <Alarm />
-        <DateEnd />
-        <DateStarted />
-        <Duration />
-        <ExceptionDateTime />
-        <RecurrenceRule />
-        <Summary />
-    </event>
-</capabilities>
-"""
-
-# my phone doesn't like it if you read more than this many entries at a time
-ENTRIES_PER_READ = 15
@@ -84 +60 @@
-
-# repeat types in the calendar
+# XXX FIXME: check order of DATE/DAY for monthly and yearly, my values disagree
-MOTO_REPEAT_NONE = 0
-MOTO_REPEAT_DAILY = 1
-MOTO_REPEAT_WEEKLY = 2
-
-
-
+
+
+
+
-
-# features we require; these refer to the bits returned by the AT+MAID? command
@@ -108 +86 @@
-    4: 'Fax',
-    5: 'Pager',
+    8: 'Cellular', # shows up as "Mobile 2", seen on a V3c
-    11: 'Voice' # shows up as "other", seen on a RAZR V3x
-}
@@ -142 +121 @@
-}
-
+# mapping from phone's event type value to category strings
+MOTO_EVENT_TYPES = {
+    0: None,
+    1: "Private",
+    2: "Discussion",
+    3: "Meeting",
+    4: "Birthday",
+    5: "Anniversary",
+    6: "Telephone Call",
+    7: "Vacation",
+    8: "Holiday",
+    9: "Entertainment",
+    10: "Breakfast",
+    11: "Lunch",
+    12: "Dinner",
+    13: "Education",
+    14: "Travel",
+    15: "Party",
+}
+
+# reverse of above
+REVERSE_MOTO_EVENT_TYPES = {}
+for (k, v) in MOTO_EVENT_TYPES.items():
+    if v:
+        REVERSE_MOTO_EVENT_TYPES[v.lower()] = k
+
+MOTO_EVENT_TYPE_NONE = 0
+
-# if not one of the above, we use:
-MOTO_CONTACT_DEFAULT = 2 # "Main"
@@ -159 +166 @@
-# various fields use 255 as an invalid value
-MOTO_INVALID = 255
+MOTO_INVALID_DATE = '00-00-2000'
+MOTO_INVALID_TIME = '00:00'
-
-# number of quick-dial entries in the phonebook; we avoid allocating these
@@ -205 +214 @@
-    return ''.join([n.data for n in el.childNodes if n.nodeType == n.TEXT_NODE])
-
-Child
+Tag
-    """Append a child tag with supplied text content to the parent node."""
-    if text and text != '':
@@ -211 +220 @@
-        e.appendChild(doc.createTextNode(text.encode('utf8')))
-        parent.appendChild(e)
+
+def insertXMLNode(parent, newnode):
+    """Insert a new node into a parent's list of children, maintaining sort order."""
+    for node in parent.childNodes:
+        if newnode.nodeName < node.nodeName:
+            parent.insertBefore(newnode, node)
+            return
+    parent.appendChild(newnode)
+
+def insertXMLTag(doc, parent, tag, text):
+    """Append a child tag with supplied text content to the parent node."""
+    if text and text != '':
+        e = doc.createElement(tag)
+        e.appendChild(doc.createTextNode(text.encode('utf8')))
+        insertXMLNode(parent, e)
-
-def parse_moto_time(datestr, timestr=None):
@@ -265 +289 @@
-        return dt.strftime(format)
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
-    if freqstr == 'daily':
-        freq = rrule.DAILY
@@ -296 +305 @@
-        assert(False, "invalid frequency %s" % freqstr)
-
-rule
+xml
-    if until:
-        until = parse_ical_time(until)
-
+
+
-    if count:
-        count = int(count)
-
+
+
-    if interval:
-        interval = int(interval)
-
-
-
-
-
+
+
+
+
+
+
-            return None
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
-    byweekday = []
-    for bydaystr in byday:
@@ -376 +340 @@
-            byweekday.append(day)
-
+    # done!
+    return rrule.rrule(freq, dtstart=eventdt, interval=interval, count=count,
+                       until=until, bymonth=bymonth, bymonthday=bymonthday,
+                       byweekday=byweekday, byyearday=byyearday)
+
+def moto_repeat_day_to_weekdays(repeat_day,  eventday):
+    """For a weekly repeat, return the list of days the event repeats on.
+
+    repeat_day is field 19 (repeat on day) in the extended event format
+    eventday is the 0-based weekday on which the event occurs
+
+    This is based on the following description:
+
+    The weekday of the event (the one that gets repeated of course) gets the
+    value 2^6 = 64, the following weekday gets the value 2^5, the after that one
+    gets 2^4, etc.
+    Field 19 contains the sum of the binary encoded weekdays.
+
+    For example: lets assume we have an event on Thursday, 04-12-2007
+    As the starting weekday is the day of the first event (Thursday), this day
+    gets encoded with 2^6, so the encoding for the whole week is as follows:
+    thursday 2^6 (1000000), friday 2^5 (0100000), saturday 2^4 (0010000),
+    sunday 2^3 (0001000), monday 2^2 (0000100), tuesday 2^1 (0000010),
+    wednesday 2^0 (0000001)
+    lets say we want to repeat that event every thursday and monday on a weekly basis.
+    Field 19 would then contain 2^6 + 2^2 = 68 or in binary form 1000100
+    """
+
+    if repeat_day == 0:
+        return []
+    else:
+        eventday = (eventday - 1) % 7
+        rest = moto_repeat_day_to_weekdays(repeat_day / 2, eventday)
+        if repeat_day % 2:
+            return rest + [eventday]
+        else:
+            return rest
+
+def moto_weekdays_to_repeat_day(weekdays, eventday):
+    """Returns the repeat_day value given a set of days on which a weekly event repeats."""
+
+    return sum([2 ** (6 - (day - eventday) % 7) for day in weekdays])
+
+def moto_repeat_day_to_monthday(repeat_day):
+    """For a monthly or yearly by day repeat, return the day the event repeats on.
+
+    repeat_day is field 19 (repeat on day) in the extended event format
+    returns a tuple (nth, day)
+    nth is the Nth time the day occurs in the month
+    day is the weekday number (0=monday)
+
+    This is based on the following description:
+
+    The weekdays get the following basis encodings :
+    sunday = 0
+    monday = 8
+    tuesday = 16
+    wednesday = 24
+    thursday = 32
+    friday = 40
+    saturday = 48
+
+    The above values are NEVER the value of field 19. Instead the field contains
+    a value computed as follows:
+    WEEKDAYCODE + 1 = first WEEKDAY of month
+    WEEKDAYCODE + 2 = second WEEKDAY of month
+    WEEKDAYCODE + 3 = third WEEKDAY of month
+    WEEKDAYCODE + 4 = fourth WEEKDAY of month
+    WEEKDAYCODE + 5 = last WEEKDAY of month
+    """
+
+    daynum = (repeat_day / 8 - 1) % 7
+    nth = repeat_day % 8
+    if nth > 4:
+        nth = 4 - nth
+    return (nth, daynum)
+
+# reverse of the above function
+def moto_monthday_to_repeat_day(nth, daynum):
+    """For a monthly or yearly by day repeat, returns the repeat_day value given
+    the Nth time a day occurs in a montyh, and the day of the week number.
+    """
+    if nth < 0:
+        nth = 4 - nth
+    return ((daynum + 1) % 7) * 8 + nth
+
+def xml_rrule_to_moto(rulenodes, exdates, exrules, eventdt):
+    """Process XML recursion rules, converting them to the closest-possible
+    matching recursion specifier supported by the phone.
+
+    Arguments:
+      rulenodes: list of RecurrenceRule nodes
+      exdates:   list of exception dates
+      exrules:   list of exception rules
+      eventdt:   event's date (and time if set)
+
+    Returns a dict containing the following fields:
+      repeat_type:  Motorola repeat type (always present)
+      repeat_every: repeat every Nth time (valid for the extended format only)
+      repeat_day:   bitfield showing which days/weeks to repeat on (extended)
+      repeat_end:   end date of the repeat (extended)
+      exceptions:   list of exceptions (always present)
+
+    The general approach we take is: if the recursion can be represented
+    by the phone's data structure, we convert it, otherwise we ignore the
+    rule completely (to avoid the event showing up at incorrect times) by
+    raising an UnsupportedDataError exception.
+    """
+
+    # default return values
+    ret = {}
+    ret['repeat_type'] = MOTO_REPEAT_NONE
+    ret['repeat_every'] = 0
+    ret['repeat_day'] = 0
+    ret['repeat_end'] = None
+    ret['exceptions'] = []
+
+    # can't support multiple rules
+    if len(rulenodes) != 1:
+        raise UnsupportedDataError('Unhandled recursion: too many rules')
+    rulenode = rulenodes[0]
+
+    freq = getXMLField(rulenode, 'Frequency').upper()
+
+    interval = getXMLField(rulenode, 'Interval')
+    if interval:
+        ret['repeat_every'] = int(interval)
+
+    def getSet(name, convfunc=int):
+        """Convenience function, get a comma-separated set of values from XML."""
+        val = getXMLField(rulenode, name)
+        if not val:
+            return None
+        return set(map(convfunc, val.split(',')))
+
+    bymonth = getSet('ByMonth')
+    byyearday = getSet('ByYearDay')
+    bymonthday = getSet('ByMonthDay')
+    byday = getSet('ByDay', lambda s: s.upper())
+
+    # convert byday strings to a list of tuples
+    # first tuple elem is the "Nth" part, second is the day number
+    # if no int part is present, the "Nth" value is 0
+    if byday:
+        byday_pairs = [(int(s[:-2] or "0"), VCAL_DAYS.index(s[-2:])) for s in byday]
+        if len(byday) == 1:
+            (byday_nth, byday_daynum) = byday_pairs[0]
+
+    # compute the day and week number that the event falls in
+    if eventdt.day % 7 == 0:
+        eventweek = eventdt.day / 7
+    else:
+        eventweek = eventdt.day / 7 + 1
+
+    # convenience variable for the tests below
+    byallmonths = set(range(1, 12))
+
+    # now test if the rule matches what we can represent
+    if (freq == 'DAILY' and not byday and not bymonthday and not byyearday and not bymonth):
+        ret['repeat_type'] = MOTO_REPEAT_DAILY
+    elif (freq == 'WEEKLY' and not bymonthday and not byyearday and not bymonth):
+        ret['repeat_type'] = MOTO_REPEAT_WEEKLY
+        if byday:
+            # the Nth specifier doesn't make sense on a byday value in a weekly rule
+            # so we can ignore them
+            byday_nums = [daynum for (_, daynum) in byday_pairs]
+            if byday_nums != [eventdt.day]:
+                ret['repeat_day'] = moto_weekdays_to_repeat_day(byday_nums, eventdt.day)
+    elif (freq == 'MONTHLY' and not byday and (not bymonthday or bymonthday == set([eventdt.day]))
+            and not byyearday and (not bymonth or bymonth == byallmonths)):
+        ret['repeat_type'] = MOTO_REPEAT_MONTHLY_DATE
+    elif (freq == 'MONTHLY' and byday and len(byday) == 1 and not bymonthday
+            and not byyearday and (not bymonth or bymonth == byallmonths)):
+        ret['repeat_type'] = MOTO_REPEAT_MONTHLY_DAY
+        if not (byday_daynum == eventdt.weekday() and byday_nth == eventweek):
+            ret['repeat_day'] = moto_monthday_to_repeat_day(byday_nth, byday_daynum)
+    elif (freq == 'YEARLY' and not byday and (not bymonthday or bymonthday == set([eventdt.day]))
+            and not byyearday and (not bymonth or bymonth == set([eventdt.month]))):
+        ret['repeat_type'] = MOTO_REPEAT_YEARLY_DATE
+    elif (freq == 'YEARLY' and byday and len(byday == 1)
+            and (not bymonthday or bymonthday == set([eventdt.day]))
+            and not byyearday and (not bymonth or bymonth == set([eventdt.month]))):
+        ret['repeat_type'] = MOTO_REPEAT_YEARLY_DAY
+        if not (byday_daynum == eventdt.weekday() and byday_nth == eventweek):
+            ret['repeat_day'] = moto_monthday_to_repeat_day(byday_nth, byday_daynum)
+    else:
+        raise UnsupportedDataError('Unhandled recursion: cannot represent rule')
+
+    # phew, looks like we have something the phone can represent
+    # now we need to work out the exceptions and see if this event still occurs
+
-    # create an rrule object for this rule, and an rrule set
-    ruleobj = rrule.rrule(freq, dtstart=eventdt, count=count, until=until,
-                          bymonth=list(bymonth), bymonthday=list(bymonthday),
-                          byweekday=byweekday, byyearday=list(byyearday),
-                          byweekno=list(byweekno))
-    ruleset = rrule.rruleset()
-
-
-
+
+
+
+
+
+
+
-    now = datetime.now()
-    if ruleset.after(now) == None:
-        return (MOTO_REPEAT_NONE, [])
-
-    # what events would happen if there were no exceptions?
-    all_occurrences = ruleset.between(now, now + RRULE_FUTURE)
-
@@ -397 +548 @@
-            ruleset.exdate(dateutil.parser.parse(getXMLText(e)))
-
-
-
-
+
+
-
-    # are there any future occurrences of this event if we consider exceptions?
-datetime.now()
-eturn (MOTO_REPEAT_NONE, []
+now
+aise UnsupportedDataError('Unhandled recursion: no future occurrence'
-
-    # what events will happen with exceptions
@@ -409 +559 @@
-
-    # work out which events don't happen
-    exceptions = []
-    for num in range(all_occurrences):
-        if all_occurrences[num] not in excepted_occurrences:
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-
@@ -444 +740 @@
-        self.contact_data_len = None
-        self.contact_name_len = None
+        self.extended_events_supported = None
-
-    def connect(self):
@@ -488 +785 @@
-        self.__do_cmd('AT+CSCS="UCS2"')
-
-
+, extended
-        self.max_events = maxevs
-        self.num_events = numevs
-        self.event_name_len = namelen
-        self.event_max_exceptions = max_except
+        self.extended_events_supported = extended
-
-        (minpos, maxpos, contactlen, namelen) = self.read_contact_params()
@@ -562 +860 @@
-                 length of title/name field,
-                 maximum number of event exceptions
+                 true/false if extended event format is supported
-        """
-        self.open_calendar()
-        data = self.__do_cmd('AT+MDBR=?') # read event parameters
-
+
+
-
-    def read_events(self):
@@ -743 +1043 @@
-
-    def __parse_results(self, restype, lines):
-
+
+
+
+
+
+
+
+
-        ret = []
-        prefix = '+' + restype + ': '
@@ -864 +1171 @@
-
-
-
+Simple
-    """Class representing the events roughly as stored in the phone.
- PhoneEventMoto
-or PhoneEvent
+
+PhoneEventSimpleMoto or PhoneEventSimple
-
-    class members:
@@ -885 +1192 @@
-        self.exceptions = []
-
+    @staticmethod
+    def capabilities():
+        """Return the OpenSync XML capabilities supported by this object."""
+        caps = """
+            <event>
+                <Alarm />
+                <DateEnd />
+                <DateStarted />
+                <Duration />
+                <ExceptionDateTime />
+                <RecurrenceRule />
+                <Summary />
+            </event>
+        """
+        return caps
+
-    def get_objtype(self):
-        """return the opensync object type string"""
@@ -914 +1237 @@
-        """given an instance of PhoneComms, write this entry to the phone"""
-        self.__truncate_fields(comms)
-__
+
-
-    def hash_data(self):
-        """return a list of entry data in a predictable format, for hashing"""
-__
+
-
-    def __truncate_fields(self, comms):
@@ -925 +1248 @@
-        self.exceptions = self.exceptions[:comms.event_max_exceptions]
-
-__
+
-        """generate motorola event-data list"""
-        if isinstance(self.eventdt, datetime):
@@ -934 +1257 @@
-            timeflag = 0
-            datestr = self.eventdt.strftime(PHONE_DATE)
-'00:00'
+MOTO_INVALID_TIME
-        if self.alarmdt:
-            alarmflag = 1
@@ -941 +1264 @@
-        else:
-            alarmflag = 0
-'00-00-2000'
-'00:00'
+MOTO_INVALID_DATE
+MOTO_INVALID_TIME
-
-        duration = int(self.duration.days) * 24 * 60
-        duration += int(self.duration.seconds) / 60
-
-
-
-
-
+
+
+
+
+
+
+
+
+
-        impl = xml.dom.minidom.getDOMImplementation()
-        doc = impl.createDocument(None, 'event', None)
-        top = doc.documentElement
-
-        # compute the week number that the event falls in
-        if self.eventdt.day % 7 == 0:
-            weeknum = self.eventdt.day / 7
-        else:
-            weeknum = self.eventdt.day / 7 + 1
-
-        if self.alarmdt:
-            alarm = doc.createElement('Alarm')
-Child
+Tag
-            e = doc.createElement('AlarmDescription')
-Child
+Tag
-            alarm.appendChild(e)
-            alarmtime = self.alarmdt.strftime(VCAL_DATETIME)
-Child
+Tag
-            top.appendChild(alarm)
-
@@ -978 +1299 @@
-            dtend = endtime.strftime(VCAL_DATE)
-            e.setAttribute('Value', 'DATE')
-Child
+Tag
-        top.appendChild(e)
-
@@ -987 +1308 @@
-            dtstart = self.eventdt.strftime(VCAL_DATE)
-            e.setAttribute('Value', 'DATE')
-Child
+Tag
-        top.appendChild(e)
-
-        if self.exceptions != []:
-            assert(self.repeat_type != MOTO_REPEAT_NONE)
-
-            # create an rrule object for this recurrence
-            if self.repeat_type == MOTO_REPEAT_MONTHLY_DATE:
-                rule = rrule.rrule(rrule.MONTHLY, bymonthday=self.eventdt.day,
-                                   dtstart=self.eventdt)
-            elif self.repeat_type == MOTO_REPEAT_MONTHLY_DAY:
-                weekday = rrule.weekdays[self.eventdt.weekday()]
-                rule = rrule.rrule(rrule.MONTHLY, byweekday=weekday(+weeknum),
-                                   dtstart=self.eventdt)
-            else:
-                if self.repeat_type == MOTO_REPEAT_DAILY:
-                    freq = rrule.DAILY
-                elif self.repeat_type == MOTO_REPEAT_WEEKLY:
-                    freq = rrule.WEEKLY
-                elif self.repeat_type == MOTO_REPEAT_YEARLY:
-                    freq = rrule.YEARLY
-                rule = rrule.rrule(freq, dtstart=self.eventdt)
-
-            # work out which dates the exceptions correspond to and
-            # generate ExceptionDate nodes for them
-            e = doc.createElement('ExceptionDateTime')
-            e.setAttribute('Value', 'DATE')
-            for exnum in self.exceptions:
-                appendXMLChild(doc, e, 'Content', format_time(rule[exnum], VCAL_DATE))
-            if e.hasChildNodes():
-                top.appendChild(e)
-
-        e = doc.createElement('RecurrenceRule')
-        if self.repeat_type == MOTO_REPEAT_DAILY:
-            appendXMLChild(doc, e, 'Frequency', 'DAILY')
-        elif self.repeat_type == MOTO_REPEAT_WEEKLY:
-            appendXMLChild(doc, e, 'Frequency', 'WEEKLY')
-        elif self.repeat_type == MOTO_REPEAT_MONTHLY_DATE:
-            appendXMLChild(doc, e, 'Frequency', 'MONTHLY')
-            appendXMLChild(doc, e, 'ByMonthDay', str(self.eventdt.day))
-        elif self.repeat_type == MOTO_REPEAT_MONTHLY_DAY:
-            appendXMLChild(doc, e, 'Frequency', 'MONTHLY')
-            day = VCAL_DAYS[self.eventdt.weekday()]
-            appendXMLChild(doc, e, 'ByDay', '%d%s' % (weeknum, day))
-        elif self.repeat_type == MOTO_REPEAT_YEARLY:
-            appendXMLChild(doc, e, 'Frequency', 'YEARLY')
-            appendXMLChild(doc, e, 'ByMonth', str(self.eventdt.month))
-            appendXMLChild(doc, e, 'ByMonthDay', str(self.eventdt.day))
-
-        if e.hasChildNodes():
-            top.appendChild(e)
-
-        e = doc.createElement('Summary')
-Child
+Tag
-        top.appendChild(e)
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
-    def __init__(self, data, exceptions):
-        """grab stuff out of the list of values from the phone"""
-
-=
+Simple
+>
-        self.pos = data[0]
-        self.name = data[1]
@@ -1076 +1353 @@
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        """
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-