| // Copyright 2007 The Android Open Source Project |
| |
| package com.google.wireless.gdata.serializer.xml; |
| |
| import com.google.wireless.gdata.data.Entry; |
| import com.google.wireless.gdata.data.ExtendedProperty; |
| import com.google.wireless.gdata.data.StringUtils; |
| import com.google.wireless.gdata.parser.ParseException; |
| import com.google.wireless.gdata.parser.xml.XmlGDataParser; |
| import com.google.wireless.gdata.parser.xml.XmlParserFactory; |
| import com.google.wireless.gdata.serializer.GDataSerializer; |
| |
| import org.xmlpull.v1.XmlPullParserException; |
| import org.xmlpull.v1.XmlSerializer; |
| |
| import java.io.IOException; |
| import java.io.OutputStream; |
| |
| /** |
| * Serializes GData entries to the Atom XML format. |
| */ |
| public class XmlEntryGDataSerializer implements GDataSerializer { |
| |
| /** The XmlParserFactory that is used to create the XmlSerializer */ |
| private final XmlParserFactory factory; |
| |
| /** The entry being serialized. */ |
| private final Entry entry; |
| |
| /** |
| * Creates a new XmlEntryGDataSerializer that will serialize the provided |
| * entry. |
| * |
| * @param entry The entry that should be serialized. |
| */ |
| public XmlEntryGDataSerializer(XmlParserFactory factory, |
| Entry entry) { |
| this.factory = factory; |
| this.entry = entry; |
| } |
| |
| /** |
| * Returns the entry being serialized. |
| * @return The entry being serialized. |
| */ |
| protected Entry getEntry() { |
| return entry; |
| } |
| |
| /* (non-Javadoc) |
| * @see GDataSerializer#getContentType() |
| */ |
| public String getContentType() { |
| return "application/atom+xml"; |
| } |
| |
| /* (non-Javadoc) |
| * @see GDataSerializer#serialize(java.io.OutputStream) |
| */ |
| public void serialize(OutputStream out, int format) |
| throws IOException, ParseException { |
| XmlSerializer serializer = null; |
| try { |
| serializer = factory.createSerializer(); |
| } catch (XmlPullParserException e) { |
| throw new ParseException("Unable to create XmlSerializer.", e); |
| } |
| // TODO: make the output compact |
| |
| serializer.setOutput(out, "UTF-8"); |
| serializer.startDocument("UTF-8", new Boolean(false)); |
| |
| declareEntryNamespaces(serializer); |
| serializer.startTag(XmlGDataParser.NAMESPACE_ATOM_URI, "entry"); |
| |
| serializeEntryContents(serializer, format); |
| |
| serializer.endTag(XmlGDataParser.NAMESPACE_ATOM_URI, "entry"); |
| serializer.endDocument(); |
| serializer.flush(); |
| } |
| |
| private final void declareEntryNamespaces(XmlSerializer serializer) |
| throws IOException { |
| serializer.setPrefix("" /* default ns */, |
| XmlGDataParser.NAMESPACE_ATOM_URI); |
| serializer.setPrefix(XmlGDataParser.NAMESPACE_GD, |
| XmlGDataParser.NAMESPACE_GD_URI); |
| declareExtraEntryNamespaces(serializer); |
| } |
| |
| protected void declareExtraEntryNamespaces(XmlSerializer serializer) |
| throws IOException { |
| // no-op in this class |
| } |
| |
| /** |
| * @param serializer |
| * @throws IOException |
| */ |
| private final void serializeEntryContents(XmlSerializer serializer, |
| int format) |
| throws ParseException, IOException { |
| |
| if (format != FORMAT_CREATE) { |
| serializeId(serializer, entry.getId()); |
| } |
| |
| serializeTitle(serializer, entry.getTitle()); |
| |
| if (format != FORMAT_CREATE) { |
| serializeLink(serializer, "edit" /* rel */, entry.getEditUri(), null /* type */); |
| serializeLink(serializer, "alternate" /* rel */, entry.getHtmlUri(), "text/html" /* type */); |
| } |
| |
| serializeSummary(serializer, entry.getSummary()); |
| |
| serializeContent(serializer, entry.getContent()); |
| |
| serializeAuthor(serializer, entry.getAuthor(), entry.getEmail()); |
| |
| serializeCategory(serializer, |
| entry.getCategory(), entry.getCategoryScheme()); |
| |
| if (format == FORMAT_FULL) { |
| serializePublicationDate(serializer, |
| entry.getPublicationDate()); |
| } |
| |
| if (format != FORMAT_CREATE) { |
| serializeUpdateDate(serializer, |
| entry.getUpdateDate()); |
| } |
| |
| serializeExtraEntryContents(serializer, format); |
| } |
| |
| /** |
| * Hook for subclasses to serialize extra fields within the entry. |
| * @param serializer The XmlSerializer being used to serialize the entry. |
| * @param format The serialization format for the entry. |
| * @throws ParseException Thrown if the entry cannot be serialized. |
| * @throws IOException Thrown if the entry cannot be written to the |
| * underlying {@link OutputStream}. |
| */ |
| protected void serializeExtraEntryContents(XmlSerializer serializer, |
| int format) |
| throws ParseException, IOException { |
| // no-op in this class. |
| } |
| |
| // TODO: make these helper methods protected so sublcasses can use them? |
| |
| private static void serializeId(XmlSerializer serializer, |
| String id) throws IOException { |
| if (StringUtils.isEmpty(id)) { |
| return; |
| } |
| serializer.startTag(null /* ns */, "id"); |
| serializer.text(id); |
| serializer.endTag(null /* ns */, "id"); |
| } |
| |
| private static void serializeTitle(XmlSerializer serializer, |
| String title) |
| throws IOException { |
| if (StringUtils.isEmpty(title)) { |
| return; |
| } |
| serializer.startTag(null /* ns */, "title"); |
| serializer.text(title); |
| serializer.endTag(null /* ns */, "title"); |
| } |
| |
| public static void serializeLink(XmlSerializer serializer, String rel, String href, String type) |
| throws IOException { |
| if (StringUtils.isEmpty(href)) { |
| return; |
| } |
| serializer.startTag(null /* ns */, "link"); |
| serializer.attribute(null /* ns */, "rel", rel); |
| serializer.attribute(null /* ns */, "href", href); |
| if (!StringUtils.isEmpty(type)) serializer.attribute(null /* ns */, "type", type); |
| serializer.endTag(null /* ns */, "link"); |
| } |
| |
| private static void serializeSummary(XmlSerializer serializer, |
| String summary) |
| throws IOException { |
| if (StringUtils.isEmpty(summary)) { |
| return; |
| } |
| serializer.startTag(null /* ns */, "summary"); |
| serializer.text(summary); |
| serializer.endTag(null /* ns */, "summary"); |
| } |
| |
| private static void serializeContent(XmlSerializer serializer, |
| String content) |
| throws IOException { |
| if (content == null) { |
| return; |
| } |
| serializer.startTag(null /* ns */, "content"); |
| serializer.attribute(null /* ns */, "type", "text"); |
| serializer.text(content); |
| serializer.endTag(null /* ns */, "content"); |
| } |
| |
| private static void serializeAuthor(XmlSerializer serializer, |
| String author, |
| String email) |
| throws IOException { |
| if (StringUtils.isEmpty(author) || StringUtils.isEmpty(email)) { |
| return; |
| } |
| serializer.startTag(null /* ns */, "author"); |
| serializer.startTag(null /* ns */, "name"); |
| serializer.text(author); |
| serializer.endTag(null /* ns */, "name"); |
| serializer.startTag(null /* ns */, "email"); |
| serializer.text(email); |
| serializer.endTag(null /* ns */, "email"); |
| serializer.endTag(null /* ns */, "author"); |
| } |
| |
| private static void serializeCategory(XmlSerializer serializer, |
| String category, |
| String categoryScheme) |
| throws IOException { |
| if (StringUtils.isEmpty(category) && |
| StringUtils.isEmpty(categoryScheme)) { |
| return; |
| } |
| serializer.startTag(null /* ns */, "category"); |
| if (!StringUtils.isEmpty(category)) { |
| serializer.attribute(null /* ns */, "term", category); |
| } |
| if (!StringUtils.isEmpty(categoryScheme)) { |
| serializer.attribute(null /* ns */, "scheme", categoryScheme); |
| } |
| serializer.endTag(null /* ns */, "category"); |
| } |
| |
| private static void |
| serializePublicationDate(XmlSerializer serializer, |
| String publicationDate) |
| throws IOException { |
| if (StringUtils.isEmpty(publicationDate)) { |
| return; |
| } |
| serializer.startTag(null /* ns */, "published"); |
| serializer.text(publicationDate); |
| serializer.endTag(null /* ns */, "published"); |
| } |
| |
| private static void |
| serializeUpdateDate(XmlSerializer serializer, |
| String updateDate) |
| throws IOException { |
| if (StringUtils.isEmpty(updateDate)) { |
| return; |
| } |
| serializer.startTag(null /* ns */, "updated"); |
| serializer.text(updateDate); |
| serializer.endTag(null /* ns */, "updated"); |
| } |
| } |