src/org/xmlrpc/android/XMLRPCSerializer.java

   1 package org.xmlrpc.android;
   2
   3 import java.io.BufferedReader;
   4 import java.io.IOException;
   5 import java.io.StringReader;
   6 import java.text.ParseException;
   7 import java.text.SimpleDateFormat;
   8 import java.util.ArrayList;
   9 import java.util.Calendar;
  10 import java.util.Date;
  11 import java.util.HashMap;
  12 import java.util.Iterator;
  13 import java.util.List;
  14 import java.util.Map;
  15 import java.util.Map.Entry;
  16
  17 import org.xmlpull.v1.XmlPullParser;
  18 import org.xmlpull.v1.XmlPullParserException;
  19 import org.xmlpull.v1.XmlSerializer;
  20
  21 import de.ub0r.android.websms.connector.common.Utils;
  22
  23 /**
  24  * original source code from http://code.google.com/p/android-xmlrpc/ released
  25  * under apache licence 2.0 http://www.apache.org/licenses/LICENSE-2.0
  26  */
  27 class XMLRPCSerializer implements IXMLRPCSerializer {
  28         static SimpleDateFormat dateFormat = new SimpleDateFormat(DATETIME_FORMAT);
  29
  30         public void serialize(final XmlSerializer serializer, final Object object)
  31                         throws IOException {
  32                 // check for scalar types:
  33                 if (object instanceof Integer || object instanceof Short
  34                                 || object instanceof Byte) {
  35                         serializer.startTag(null, TYPE_I4).text(object.toString()).endTag(
  36                                         null, TYPE_I4);
  37                 } else if (object instanceof Long) {
  38                         serializer.startTag(null, TYPE_I8).text(object.toString()).endTag(
  39                                         null, TYPE_I8);
  40                 } else if (object instanceof Double || object instanceof Float) {
  41                         serializer.startTag(null, TYPE_DOUBLE).text(object.toString())
  42                                         .endTag(null, TYPE_DOUBLE);
  43                 } else if (object instanceof Boolean) {
  44                         Boolean bool = (Boolean) object;
  45                         String boolStr = bool.booleanValue() ? "1" : "0";
  46                         serializer.startTag(null, TYPE_BOOLEAN).text(boolStr).endTag(null,
  47                                         TYPE_BOOLEAN);
  48                 } else if (object instanceof String) {
  49                         serializer.startTag(null, TYPE_STRING).text(object.toString())
  50                                         .endTag(null, TYPE_STRING);
  51                 } else if (object instanceof Date || object instanceof Calendar) {
  52                         String dateStr = dateFormat.format(object);
  53                         serializer.startTag(null, TYPE_DATE_TIME_ISO8601).text(dateStr)
  54                                         .endTag(null, TYPE_DATE_TIME_ISO8601);
  55                 } else if (object instanceof byte[]) {
  56                         String value = new String(Base64Coder.encode((byte[]) object));
  57                         serializer.startTag(null, TYPE_BASE64).text(value).endTag(null,
  58                                         TYPE_BASE64);
  59                 } else if (object instanceof List) {
  60                         serializer.startTag(null, TYPE_ARRAY).startTag(null, TAG_DATA);
  61                         List<Object> list = (List<Object>) object;
  62                         Iterator<Object> iter = list.iterator();
  63                         while (iter.hasNext()) {
  64                                 Object o = iter.next();
  65                                 serializer.startTag(null, TAG_VALUE);
  66                                 this.serialize(serializer, o);
  67                                 serializer.endTag(null, TAG_VALUE);
  68                         }
  69                         serializer.endTag(null, TAG_DATA).endTag(null, TYPE_ARRAY);
  70                 } else if (object instanceof Object[]) {
  71                         serializer.startTag(null, TYPE_ARRAY).startTag(null, TAG_DATA);
  72                         Object[] objects = (Object[]) object;
  73                         for (int i = 0; i < objects.length; i++) {
  74                                 Object o = objects[i];
  75                                 serializer.startTag(null, TAG_VALUE);
  76                                 this.serialize(serializer, o);
  77                                 serializer.endTag(null, TAG_VALUE);
  78                         }
  79                         serializer.endTag(null, TAG_DATA).endTag(null, TYPE_ARRAY);
  80                 } else if (object instanceof Map) {
  81                         serializer.startTag(null, TYPE_STRUCT);
  82                         Map<String, Object> map = (Map<String, Object>) object;
  83                         Iterator<Entry<String, Object>> iter = map.entrySet().iterator();
  84                         while (iter.hasNext()) {
  85                                 Entry<String, Object> entry = iter.next();
  86                                 String key = entry.getKey();
  87                                 Object value = entry.getValue();
  88
  89                                 serializer.startTag(null, TAG_MEMBER);
  90                                 serializer.startTag(null, TAG_NAME).text(key).endTag(null,
  91                                                 TAG_NAME);
  92                                 serializer.startTag(null, TAG_VALUE);
  93                                 this.serialize(serializer, value);
  94                                 serializer.endTag(null, TAG_VALUE);
  95                                 serializer.endTag(null, TAG_MEMBER);
  96                         }
  97                         serializer.endTag(null, TYPE_STRUCT);
  98                 } else if (object instanceof XMLRPCSerializable) {
  99                         XMLRPCSerializable serializable = (XMLRPCSerializable) object;
 100                         this.serialize(serializer, serializable.getSerializable());
 101                 } else {
 102                         throw new IOException("Cannot serialize " + object);
 103                 }
 104         }
 105
 106         public Object deserialize(final XmlPullParser parser)
 107                         throws XmlPullParserException, IOException {
 108                 parser.require(XmlPullParser.START_TAG, null, TAG_VALUE);
 109
 110                 if (parser.isEmptyElementTag()) {
 111                         // degenerated <value />, return empty string
 112                         return "";
 113                 }
 114
 115                 Object obj;
 116                 boolean hasType = true;
 117                 String typeNodeName = null;
 118                 try {
 119                         parser.nextTag();
 120                         typeNodeName = parser.getName();
 121                         if (typeNodeName.equals(TAG_VALUE)
 122                                         && parser.getEventType() == XmlPullParser.END_TAG) {
 123                                 // empty <value></value>, return empty string
 124                                 return "";
 125                         }
 126                 } catch (XmlPullParserException e) {
 127                         hasType = false;
 128                 }
 129                 if (hasType) {
 130                         if (typeNodeName.equals(TYPE_INT) || typeNodeName.equals(TYPE_I4)) {
 131                                 String value = parser.nextText();
 132                                 obj = Integer.parseInt(value);
 133                         } else if (typeNodeName.equals(TYPE_I8)) {
 134                                 String value = parser.nextText();
 135                                 obj = Long.parseLong(value);
 136                         } else if (typeNodeName.equals(TYPE_DOUBLE)) {
 137                                 String value = parser.nextText();
 138                                 obj = Double.parseDouble(value);
 139                         } else if (typeNodeName.equals(TYPE_BOOLEAN)) {
 140                                 String value = parser.nextText();
 141                                 obj = value.equals("1") ? Boolean.TRUE : Boolean.FALSE;
 142                         } else if (typeNodeName.equals(TYPE_STRING)) {
 143                                 obj = parser.nextText();
 144                         } else if (typeNodeName.equals(TYPE_DATE_TIME_ISO8601)) {
 145                                 String value = parser.nextText();
 146                                 try {
 147                                         obj = dateFormat.parseObject(value);
 148                                 } catch (ParseException e) {
 149                                         throw new IOException("Cannot deserialize dateTime "
 150                                                         + value);
 151                                 }
 152                         } else if (typeNodeName.equals(TYPE_BASE64)) {
 153                                 String value = parser.nextText();
 154                                 BufferedReader reader = new BufferedReader(new StringReader(
 155                                                 value), Utils.BUFSIZE);
 156                                 String line;
 157                                 StringBuffer sb = new StringBuffer();
 158                                 while ((line = reader.readLine()) != null) {
 159                                         sb.append(line);
 160                                 }
 161                                 obj = Base64Coder.decode(sb.toString());
 162                         } else if (typeNodeName.equals(TYPE_ARRAY)) {
 163                                 parser.nextTag(); // TAG_DATA (<data>)
 164                                 parser.require(XmlPullParser.START_TAG, null, TAG_DATA);
 165
 166                                 parser.nextTag();
 167                                 List<Object> list = new ArrayList<Object>();
 168                                 while (parser.getName().equals(TAG_VALUE)) {
 169                                         list.add(this.deserialize(parser));
 170                                         parser.nextTag();
 171                                 }
 172                                 parser.require(XmlPullParser.END_TAG, null, TAG_DATA);
 173                                 parser.nextTag(); // TAG_ARRAY (</array>)
 174                                 parser.require(XmlPullParser.END_TAG, null, TYPE_ARRAY);
 175                                 obj = list.toArray();
 176                         } else if (typeNodeName.equals(TYPE_STRUCT)) {
 177                                 parser.nextTag();
 178                                 Map<String, Object> map = new HashMap<String, Object>();
 179                                 while (parser.getName().equals(TAG_MEMBER)) {
 180                                         String memberName = null;
 181                                         Object memberValue = null;
 182                                         while (true) {
 183                                                 parser.nextTag();
 184                                                 String name = parser.getName();
 185                                                 if (name.equals(TAG_NAME)) {
 186                                                         memberName = parser.nextText();
 187                                                 } else if (name.equals(TAG_VALUE)) {
 188                                                         memberValue = this.deserialize(parser);
 189                                                 } else {
 190                                                         break;
 191                                                 }
 192                                         }
 193                                         if (memberName != null && memberValue != null) {
 194                                                 map.put(memberName, memberValue);
 195                                         }
 196                                         parser.require(XmlPullParser.END_TAG, null, TAG_MEMBER);
 197                                         parser.nextTag();
 198                                 }
 199                                 parser.require(XmlPullParser.END_TAG, null, TYPE_STRUCT);
 200                                 obj = map;
 201                         } else {
 202                                 throw new IOException("Cannot deserialize " + parser.getName());
 203                         }
 204                 } else {
 205                         // TYPE_STRING (<string>) is not required
 206                         obj = parser.getText();
 207                 }
 208                 parser.nextTag(); // TAG_VALUE (</value>)
 209                 parser.require(XmlPullParser.END_TAG, null, TAG_VALUE);
 210                 return obj;
 211         }
 212 }