// Copyright 2007 The Android Open Source Project
package com.google.wireless.gdata.calendar.parser.xml;
import com.google.wireless.gdata.calendar.data.EventEntry;
import com.google.wireless.gdata.calendar.data.EventsFeed;
import com.google.wireless.gdata.calendar.data.When;
import com.google.wireless.gdata.calendar.data.Reminder;
import com.google.wireless.gdata.calendar.data.Who;
import com.google.wireless.gdata.data.Entry;
import com.google.wireless.gdata.data.Feed;
import com.google.wireless.gdata.data.StringUtils;
import com.google.wireless.gdata.data.XmlUtils;
import com.google.wireless.gdata.parser.ParseException;
import com.google.wireless.gdata.parser.xml.XmlGDataParser;
import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserException;
import java.io.IOException;
import java.io.InputStream;
/**
* GDataParser for an events feed containing events in a calendar.
*/
public class XmlEventsGDataParser extends XmlGDataParser {
// whether or not we've seen reminders directly under the entry.
// the calendar feed sends duplicate <reminder> entries in case of
// recurrences, if the recurrences are expanded.
// if the <reminder> elements precede the <when> elements, we'll only
// process the <reminder> elements directly under the entry and ignore
// the <reminder> elements within a <when>.
// if the <when> elements precede the <reminder> elements, we'll first
// process reminders under the when, and then we'll clear them and process
// the reminders directly under the entry (which should take precedence).
// if we only see <reminder> as direct children of the entry or only see
// <reminder> as children of <when> elements, there is no conflict.
private boolean hasSeenReminder = false;
/**
* Creates a new XmlEventsGDataParser.
* @param is The InputStream that should be parsed.
* @throws ParseException Thrown if a parser cannot be created.
*/
public XmlEventsGDataParser(InputStream is, XmlPullParser parser)
throws ParseException {
super(is, parser);
}
/*
* (non-Javadoc)
* @see com.google.wireless.gdata.parser.xml.XmlGDataParser#createFeed()
*/
protected Feed createFeed() {
return new EventsFeed();
}
/*
* (non-Javadoc)
* @see com.google.wireless.gdata.parser.xml.XmlGDataParser#createEntry()
*/
protected Entry createEntry() {
return new EventEntry();
}
@Override
protected void handleEntry(Entry entry) throws XmlPullParserException,
IOException, ParseException {
hasSeenReminder = false; // Reset the state for the new entry
super.handleEntry(entry);
}
protected void handleExtraElementInFeed(Feed feed)
throws XmlPullParserException, IOException {
XmlPullParser parser = getParser();
if (!(feed instanceof EventsFeed)) {
throw new IllegalArgumentException("Expected EventsFeed!");
}
EventsFeed eventsFeed = (EventsFeed) feed;
String name = parser.getName();
if ("timezone".equals(name)) {
String timezone = parser.getAttributeValue(null /* ns */, "value");
if (!StringUtils.isEmpty(timezone)) {
eventsFeed.setTimezone(timezone);
}
}
}
/*
* (non-Javadoc)
* @see XmlGDataParser#handleExtraElementInEntry
*/
protected void handleExtraElementInEntry(Entry entry)
throws XmlPullParserException, IOException, ParseException {
XmlPullParser parser = getParser();
if (!(entry instanceof EventEntry)) {
throw new IllegalArgumentException("Expected EventEntry!");
}
EventEntry eventEntry = (EventEntry) entry;
// NOTE: all of these names are assumed to be in the "gd" namespace.
// we do not bother checking that here.
String name = parser.getName();
if ("eventStatus".equals(name)) {
String eventStatusStr = parser.getAttributeValue(null, "value");
byte eventStatus = EventEntry.STATUS_TENTATIVE;
if ("http://schemas.google.com/g/2005#event.canceled".
equals(eventStatusStr)) {
eventStatus = EventEntry.STATUS_CANCELED;
} else if ("http://schemas.google.com/g/2005#event.confirmed".
equals(eventStatusStr)) {
eventStatus = EventEntry.STATUS_CONFIRMED;
} else if ("http://schemas.google.com/g/2005#event.tentative".
equals(eventStatusStr)) {
eventStatus = EventEntry.STATUS_TENTATIVE;
}
eventEntry.setStatus(eventStatus);
} else if ("recurrence".equals(name)) {
String recurrence = XmlUtils.extractChildText(parser);
eventEntry.setRecurrence(recurrence);
} else if ("transparency".equals(name)) {
String transparencyStr = parser.getAttributeValue(null, "value");
byte transparency = EventEntry.TRANSPARENCY_OPAQUE;
if ("http://schemas.google.com/g/2005#event.opaque".
equals(transparencyStr)) {
transparency = EventEntry.TRANSPARENCY_OPAQUE;
} else if ("http://schemas.google.com/g/2005#event.transparent".
equals(transparencyStr)) {
transparency = EventEntry.TRANSPARENCY_TRANSPARENT;
}
eventEntry.setTransparency(transparency);
} else if ("visibility".equals(name)) {
String visibilityStr = parser.getAttributeValue(null, "value");
byte visibility = EventEntry.VISIBILITY_DEFAULT;
if ("http://schemas.google.com/g/2005#event.confidential".
equals(visibilityStr)) {
visibility = EventEntry.VISIBILITY_CONFIDENTIAL;
} else if ("http://schemas.google.com/g/2005#event.default"
.equals(visibilityStr)) {
visibility = EventEntry.VISIBILITY_DEFAULT;
} else if ("http://schemas.google.com/g/2005#event.private"
.equals(visibilityStr)) {
visibility = EventEntry.VISIBILITY_PRIVATE;
} else if ("http://schemas.google.com/g/2005#event.public"
.equals(visibilityStr)) {
visibility = EventEntry.VISIBILITY_PUBLIC;
}
eventEntry.setVisibility(visibility);
} else if ("who".equals(name)) {
handleWho(eventEntry);
} else if ("when".equals(name)) {
handleWhen(eventEntry);
} else if ("reminder".equals(name)) {
if (!hasSeenReminder) {
// if this is the first <reminder> we've seen directly under the
// entry, clear any previously seen reminders (under <when>s)
eventEntry.clearReminders();
hasSeenReminder = true;
}
handleReminder(eventEntry);
} else if ("originalEvent".equals(name)) {
handleOriginalEvent(eventEntry);
} else if ("where".equals(name)) {
String where = parser.getAttributeValue(null /* ns */,
"valueString");
String rel = parser.getAttributeValue(null /* ns */,
"rel");
if (StringUtils.isEmpty(rel) ||
"http://schemas.google.com/g/2005#event".equals(rel)) {
eventEntry.setWhere(where);
}
// TODO: handle entryLink?
} else if ("feedLink".equals(name)) {
// TODO: check that the parent is a gd:comments
String commentsUri = parser.getAttributeValue(null /* ns */, "href");
eventEntry.setCommentsUri(commentsUri);
} else if ("extendedProperty".equals(name)) {
String propertyName = parser.getAttributeValue(null /* ns */, "name");
String propertyValue = parser.getAttributeValue(null /* ns */, "value");
eventEntry.addExtendedProperty(propertyName, propertyValue);
}
}
private void handleWho(EventEntry eventEntry)
throws XmlPullParserException, IOException, ParseException {
XmlPullParser parser = getParser();
int eventType = parser.getEventType();
String name = parser.getName();
if (eventType != XmlPullParser.START_TAG ||
(!"who".equals(parser.getName()))) {
// should not happen.
throw new
IllegalStateException("Expected <who>: Actual "
+ "element: <"
+ name + ">");
}
String email =
parser.getAttributeValue(null /* ns */, "email");
String relString =
parser.getAttributeValue(null /* ns */, "rel");
String value =
parser.getAttributeValue(null /* ns */, "valueString");
Who who = new Who();
who.setEmail(email);
who.setValue(value);
byte rel = Who.RELATIONSHIP_NONE;
if ("http://schemas.google.com/g/2005#event.attendee".equals(relString)) {
rel = Who.RELATIONSHIP_ATTENDEE;
} else if ("http://schemas.google.com/g/2005#event.organizer".equals(relString)) {
rel = Who.RELATIONSHIP_ORGANIZER;
} else if ("http://schemas.google.com/g/2005#event.performer".equals(relString)) {
rel = Who.RELATIONSHIP_PERFORMER;
} else if ("http://schemas.google.com/g/2005#event.speaker".equals(relString)) {
rel = Who.RELATIONSHIP_SPEAKER;
} else if (StringUtils.isEmpty(relString)) {
rel = Who.RELATIONSHIP_ATTENDEE;
} else {
throw new ParseException("Unexpected rel: " + relString);
}
who.setRelationship(rel);
eventEntry.addAttendee(who);
while (eventType != XmlPullParser.END_DOCUMENT) {
switch (eventType) {
case XmlPullParser.START_TAG:
name = parser.getName();
if ("attendeeStatus".equals(name)) {
String statusString =
parser.getAttributeValue(null /* ns */, "value");
byte status = Who.STATUS_NONE;
if ("http://schemas.google.com/g/2005#event.accepted".
equals(statusString)) {
status = Who.STATUS_ACCEPTED;
} else if ("http://schemas.google.com/g/2005#event.declined".
equals(statusString)) {
status = Who.STATUS_DECLINED;
} else if ("http://schemas.google.com/g/2005#event.invited".
equals(statusString)) {
status = Who.STATUS_INVITED;
} else if ("http://schemas.google.com/g/2005#event.tentative".
equals(statusString)) {
status = Who.STATUS_TENTATIVE;
} else if (StringUtils.isEmpty(statusString)) {
status = Who.STATUS_TENTATIVE;
} else {
throw new ParseException("Unexpected status: " + statusString);
}
who.setStatus(status);
} else if ("attendeeType".equals(name)) {
String typeString= XmlUtils.extractChildText(parser);
byte type = Who.TYPE_NONE;
if ("http://schemas.google.com/g/2005#event.optional".equals(typeString)) {
type = Who.TYPE_OPTIONAL;
} else if ("http://schemas.google.com/g/2005#event.required".
equals(typeString)) {
type = Who.TYPE_REQUIRED;
} else if (StringUtils.isEmpty(typeString)) {
type = Who.TYPE_REQUIRED;
} else {
throw new ParseException("Unexpected type: " + typeString);
}
who.setType(type);
}
break;
case XmlPullParser.END_TAG:
name = parser.getName();
if ("who".equals(name)) {
return;
}
default:
// ignore
}
eventType = parser.next();
}
}
private void handleWhen(EventEntry eventEntry)
throws XmlPullParserException, IOException {
XmlPullParser parser = getParser();
int eventType = parser.getEventType();
String name = parser.getName();
if (eventType != XmlPullParser.START_TAG ||
(!"when".equals(parser.getName()))) {
// should not happen.
throw new
IllegalStateException("Expected <when>: Actual "
+ "element: <"
+ name + ">");
}
String startTime =
parser.getAttributeValue(null /* ns */, "startTime");
String endTime =
parser.getAttributeValue(null /* ns */, "endTime");
When when = new When(startTime, endTime);
eventEntry.addWhen(when);
boolean firstWhen = eventEntry.getWhens().size() == 1;
// we only parse reminders under the when if reminders have not already
// been handled (directly under the entry, or in a previous when for
// this entry)
boolean handleReminders = firstWhen && !hasSeenReminder;
eventType = parser.next();
while (eventType != XmlPullParser.END_DOCUMENT) {
switch (eventType) {
case XmlPullParser.START_TAG:
name = parser.getName();
if ("reminder".equals(name)) {
// only want to store reminders on the first when. they
// should have the same values for all other instances.
if (handleReminders) {
handleReminder(eventEntry);
}
}
break;
case XmlPullParser.END_TAG:
name = parser.getName();
if ("when".equals(name)) {
return;
}
default:
// ignore
}
eventType = parser.next();
}
}
private void handleReminder(EventEntry eventEntry) {
XmlPullParser parser = getParser();
Reminder reminder = new Reminder();
eventEntry.addReminder(reminder);
String methodStr = parser.getAttributeValue(null /* ns */,
"method");
String minutesStr = parser.getAttributeValue(null /* ns */,
"minutes");
String hoursStr = parser.getAttributeValue(null /* ns */,
"hours");
String daysStr = parser.getAttributeValue(null /* ns */,
"days");
if (!StringUtils.isEmpty(methodStr)) {
if ("alert".equals(methodStr)) {
reminder.setMethod(Reminder.METHOD_ALERT);
} else if ("email".equals(methodStr)) {
reminder.setMethod(Reminder.METHOD_EMAIL);
} else if ("sms".equals(methodStr)) {
reminder.setMethod(Reminder.METHOD_SMS);
}
}
int minutes = Reminder.MINUTES_DEFAULT;
if (!StringUtils.isEmpty(minutesStr)) {
minutes = StringUtils.parseInt(minutesStr, minutes);
} else if (!StringUtils.isEmpty(hoursStr)) {
minutes = 60*StringUtils.parseInt(hoursStr, minutes);
} else if (!StringUtils.isEmpty(daysStr)) {
minutes = 24*60*StringUtils.parseInt(daysStr, minutes);
}
// TODO: support absolute times?
if (minutes < 0) {
minutes = Reminder.MINUTES_DEFAULT;
}
reminder.setMinutes(minutes);
}
private void handleOriginalEvent(EventEntry eventEntry)
throws XmlPullParserException, IOException {
XmlPullParser parser = getParser();
int eventType = parser.getEventType();
String name = parser.getName();
if (eventType != XmlPullParser.START_TAG ||
(!"originalEvent".equals(parser.getName()))) {
// should not happen.
throw new
IllegalStateException("Expected <originalEvent>: Actual "
+ "element: <"
+ name + ">");
}
eventEntry.setOriginalEventId(
parser.getAttributeValue(null /* ns */, "href"));
eventType = parser.next();
while (eventType != XmlPullParser.END_DOCUMENT) {
switch (eventType) {
case XmlPullParser.START_TAG:
name = parser.getName();
if ("when".equals(name)) {
eventEntry.setOriginalEventStartTime(
parser.getAttributeValue(null/*ns*/, "startTime"));
}
break;
case XmlPullParser.END_TAG:
name = parser.getName();
if ("originalEvent".equals(name)) {
return;
}
default:
// ignore
}
eventType = parser.next();
}
}
}
|
