import java.io.File;
import java.io.FileWriter;
import java.io.PushbackInputStream;
import java.io.StringWriter;
import java.net.URI;
import java.net.URL;
import java.security.KeyManagementException;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.UnrecoverableKeyException;
import java.util.Map;

import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.FileEntity;
import org.apache.http.entity.StringEntity;
import org.apache.http.params.CoreConnectionPNames;
import org.apache.http.params.HttpParams;
import org.apache.http.params.HttpProtocolParams;
import org.wordpress.android.util.ConnectionClient;
import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserFactory;
import org.xmlpull.v1.XmlSerializer;

// deserialize fault result
Map<String, Object> map = (Map<String, Object>) XMLRPCSerializer
.deserialize(pullParser);
String faultString = (String) map.get(TAG_FAULT_STRING);
int faultCode = (Integer) map.get(TAG_FAULT_CODE);
entity.consumeContent();
throw new XMLRPCFault(faultString, faultCode);
} else {
entity.consumeContent();
throw new XMLRPCException("Bad tag <" + tag
+ "> in XMLRPC response - neither <params> nor <fault>");
}
} catch (XMLRPCException e) {
// catch & propagate XMLRPCException/XMLRPCFault
throw e;
} catch (Exception e) {
// wrap any other Exception(s) around XMLRPCException
throw new XMLRPCException(e);
}
}
}

其他工具类的实现，比如错误，异常的实现类和Base64的编码和解码请参照：android_rpc

XML-RPC 之 Android实现（下），首发于润物无声。

主要XML的封装和解封代码实现如下， 实现了将Java的数据类型封装成xml-rpc请求格式的xml数据和解析xml格式的返回数据来转换成java的数据类型：

package org.xmlrpc.android;

import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.StringReader;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.TimeZone;
import java.util.Map.Entry;

 
import org.wordpress.android.models.MediaFile;
import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserException;
import org.xmlpull.v1.XmlSerializer;

class XMLRPCSerializer {
 static final String TAG_NAME = "name";
 static final String TAG_MEMBER = "member";
 static final String TAG_VALUE = "value";
 static final String TAG_DATA = "data";

 static final String TYPE_INT = "int";
 static final String TYPE_I4 = "i4";
 static final String TYPE_I8 = "i8";
 static final String TYPE_DOUBLE = "double";
 static final String TYPE_BOOLEAN = "boolean";
 static final String TYPE_STRING = "string";
 static final String TYPE_DATE_TIME_ISO8601 = "dateTime.iso8601";
 static final String TYPE_BASE64 = "base64";
 static final String TYPE_ARRAY = "array";
 static final String TYPE_STRUCT = "struct";

 static SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMdd'T'HH:mm:ss");

 /**
 * 序列化请求数据，封装成对应的XML格式.
 *
 * 请求示例：
 *
 * <methodCall>
 *     <methodName>examples.getStateName</methodName>
 *       <params>
 *          <param>
 *             <value><i4>41</i4></value>
 *          </param>
 *        </params>
 *  </methodCall>
 *
 * 结构体：
 *  <struct>
 *     <member>
 *         <name>lowerBound</name>
 *         <value><i4>18</i4></value>
 *     </member>
 *     <member>
 *         <name>upperBound</name>
 *         <value><i4>139</i4></value>
 *     </member>
 *  </struct>
 *
 * 数组：
 *  <array>
 *     <data>
 *        <value><i4>12</i4></value>
 *        <value><string>Egypt</string></value>
 *        <value><boolean>0</boolean></value>
 *        <value><i4>-31</i4></value>
 *     </data>
 *  </array>
 * 
 * */
 static void serialize(XmlSerializer serializer, Object object,
 boolean convertToGMT) throws IOException {
 // check for scalar types:
 if (object instanceof Integer || object instanceof Short
 || object instanceof Byte) {
 // 基本类型： 整型
 serializer.startTag(null, TYPE_I4).text(object.toString()).endTag(null, TYPE_I4);
 } else if (object instanceof Long) {
 // 基本类型： 长整型
 serializer.startTag(null, TYPE_I8).text(object.toString()).endTag(null, TYPE_I8);
 } else if (object instanceof Double || object instanceof Float) {
 // 基本类型： 浮点型
 serializer.startTag(null, TYPE_DOUBLE).text(object.toString()).endTag(null, TYPE_DOUBLE);
 } else if (object instanceof Boolean) {
 // 基本类型： 布尔型
 Boolean bool = (Boolean) object;
 String boolStr = bool.booleanValue() ? "1" : "0";
 serializer.startTag(null, TYPE_BOOLEAN).text(boolStr).endTag(null, TYPE_BOOLEAN);
 } else if (object instanceof String) {
 // 基本类型： 字符串型
 serializer.startTag(null, TYPE_STRING).text(object.toString()).endTag(null, TYPE_STRING);
 } else if (object instanceof Date || object instanceof Calendar) {
 // 基本类型： 日期型
 Date date = (Date) object;
 SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMdd'T'HH:mm:ss");
 if (convertToGMT) {
 long pubDate = date.getTime();
 TimeZone tz = TimeZone.getDefault();
 long offset = tz.getOffset(pubDate);
 pubDate += offset * -1;
 date = new Date(pubDate);
 }
 String sDate = dateFormat.format(date);
 serializer.startTag(null, TYPE_DATE_TIME_ISO8601).text(sDate).endTag(null, TYPE_DATE_TIME_ISO8601);
 } else if (object instanceof byte[]) {
 // 基本类型： Base64编码型
 String value = new String(Base64Coder.encode((byte[]) object));
 serializer.startTag(null, TYPE_BASE64).text(value).endTag(null, TYPE_BASE64);
 } else if (object instanceof MediaFile) {
 // 基本类型： Base64编码型
 // convert media file binary to base64
 serializer.startTag(null, "base64");
 MediaFile videoFile = (MediaFile) object;
 InputStream inStream = new DataInputStream(new FileInputStream(videoFile.getFilePath()));
 byte[] buffer = new byte[3600];// you must use a 24bit multiple
 int length = -1;
 String chunk = null;
 // int ctr = 0;
 // Log.i("WordPress", "converting media file to base64");
 while ((length = inStream.read(buffer)) > 0) {
 chunk = Base64.encodeBytes(buffer, 0, length);
 serializer.text(chunk);
 // ctr+=3600;
 // Log.i("WordPress", "chunk " + ctr);
 }
 // Log.i("WordPress", "conversion done!");
 inStream.close();
 serializer.endTag(null, "base64");
 } else if (object instanceof List<?>) {
 // 复合类型： 数组型
 serializer.startTag(null, TYPE_ARRAY).startTag(null, TAG_DATA);
 List<Object> list = (List<Object>) object;
 Iterator<Object> iter = list.iterator();
 while (iter.hasNext()) {
 Object o = iter.next();
 serializer.startTag(null, TAG_VALUE);
 serialize(serializer, o, convertToGMT);
 serializer.endTag(null, TAG_VALUE);
 }
 serializer.endTag(null, TAG_DATA).endTag(null, TYPE_ARRAY);
 } else if (object instanceof Object[]) {
 // 复合类型： 数组型
 serializer.startTag(null, TYPE_ARRAY).startTag(null, TAG_DATA);
 Object[] objects = (Object[]) object;
 for (int i = 0; i < objects.length; i++) {
 Object o = objects[i];
 serializer.startTag(null, TAG_VALUE);
 serialize(serializer, o, convertToGMT);
 serializer.endTag(null, TAG_VALUE);
 }
 serializer.endTag(null, TAG_DATA).endTag(null, TYPE_ARRAY);
 } else if (object instanceof Map) {
 // 复合类型： 结构型
 serializer.startTag(null, TYPE_STRUCT);
 Map<String, Object> map = (Map<String, Object>) object;
 Iterator<Entry<String, Object>> iter = map.entrySet().iterator();
 while (iter.hasNext()) {
 Entry<String, Object> entry = iter.next();
 String key = entry.getKey();
 Object value = entry.getValue();

 serializer.startTag(null, TAG_MEMBER);
 serializer.startTag(null, TAG_NAME).text(key).endTag(null, TAG_NAME);
 serializer.startTag(null, TAG_VALUE);
 serialize(serializer, value, convertToGMT);
 serializer.endTag(null, TAG_VALUE);
 serializer.endTag(null, TAG_MEMBER);
 }
 serializer.endTag(null, TYPE_STRUCT);
 } else {
 throw new IOException("Cannot serialize " + object);
 }
 }

 /**
 * 反序列化服务器的返回数据，解封成Java的数据类型.
 *
 * 回复示例：
 *
 * <methodResponse>
 *    <params>
 *       <param>
 *         <value><string>South Dakota</string></value>
 *       </param>
 *    </params>
 * </methodResponse>
 * */
 static Object deserialize(XmlPullParser parser)
 throws XmlPullParserException, IOException {
 parser.require(XmlPullParser.START_TAG, null, TAG_VALUE);

 parser.nextTag();
 String typeNodeName = parser.getName();

 Object obj;
 if (typeNodeName.equals(TYPE_INT) || typeNodeName.equals(TYPE_I4)) {
 String value = parser.nextText();
 obj = Integer.parseInt(value);
 } else if (typeNodeName.equals(TYPE_I8)) {
 String value = parser.nextText();
 obj = Long.parseLong(value);
 } else if (typeNodeName.equals(TYPE_DOUBLE)) {
 String value = parser.nextText();
 obj = Double.parseDouble(value);
 } else if (typeNodeName.equals(TYPE_BOOLEAN)) {
 String value = parser.nextText();
 obj = value.equals("1") ? Boolean.TRUE : Boolean.FALSE;
 } else if (typeNodeName.equals(TYPE_STRING)) {
 obj = parser.nextText();
 } else if (typeNodeName.equals(TYPE_DATE_TIME_ISO8601)) {
 String value = parser.nextText();
 try {
 obj = dateFormat.parseObject(value);
 } catch (ParseException e) {
 e.printStackTrace();
 obj = value;
 // throw new IOException("Cannot deserialize dateTime " + value);
 }
 } else if (typeNodeName.equals(TYPE_BASE64)) {
 String value = parser.nextText();
 BufferedReader reader = new BufferedReader(new StringReader(value));
 String line;
 StringBuffer sb = new StringBuffer();
 while ((line = reader.readLine()) != null) {
 sb.append(line);
 }
 obj = Base64Coder.decode(sb.toString());
 } else if (typeNodeName.equals(TYPE_ARRAY)) {
 parser.nextTag(); // TAG_DATA (<data>)
 parser.require(XmlPullParser.START_TAG, null, TAG_DATA);

 parser.nextTag();
 List<Object> list = new ArrayList<Object>();
 while (parser.getName().equals(TAG_VALUE)) {
 list.add(deserialize(parser));
 parser.nextTag();
 }
 parser.require(XmlPullParser.END_TAG, null, TAG_DATA);
 parser.nextTag(); // TAG_ARRAY (</array>)
 parser.require(XmlPullParser.END_TAG, null, TYPE_ARRAY);
 obj = list.toArray();
 } else if (typeNodeName.equals(TYPE_STRUCT)) {
 parser.nextTag();
 Map<String, Object> map = new HashMap<String, Object>();
 while (parser.getName().equals(TAG_MEMBER)) {
 String memberName = null;
 Object memberValue = null;
 while (true) {
 parser.nextTag();
 String name = parser.getName();
 if (name.equals(TAG_NAME)) {
 memberName = parser.nextText();
 } else if (name.equals(TAG_VALUE)) {
 memberValue = deserialize(parser);
 } else {
 break;
 }
 }
 if (memberName != null && memberValue != null) {
 map.put(memberName, memberValue);
 }
 parser.require(XmlPullParser.END_TAG, null, TAG_MEMBER);
 parser.nextTag();
 }
 parser.require(XmlPullParser.END_TAG, null, TYPE_STRUCT);
 obj = map;
 } else {
 throw new IOException("Cannot deserialize " + parser.getName());
 }
 parser.nextTag(); // TAG_VALUE (</value>)
 parser.require(XmlPullParser.END_TAG, null, TAG_VALUE);
 return obj;
 }
}

其他工具类的实现，比如错误，异常的实现类和Base64的编码和解码请参照：android_rpc

XML-RPC 之 Android实现（上），首发于润物无声。

XML-RPC is a Remote Procedure Calling protocol that works over the Internet.

An XML-RPC message is an HTTP-POST request. The body of the request is in XML. A procedure executes on the server and the value it returns is also formatted in XML.

Procedure parameters can be scalars, numbers, strings, dates, etc.; and can also be complex record and list structures.

工作机制：

Request example（请求示例）

POST /RPC2 HTTP/1.0
User-Agent: Frontier/5.1.2 (WinNT)
Host: betty.userland.com
Content-Type: text/xml
Content-length: 181

<?xml version="1.0"?>
<methodCall>
   <methodName>examples.getStateName</methodName>
   <params>
      <param>
         <value><i4>41</i4></value>
      </param>
   </params>
</methodCall>

Header requirements（请求中需设置header的必要信息）

The format of the URI in the first line of the header is not specified. For example, it could be empty, a single slash, if the server is only handling XML-RPC calls. However, if the server is handling a mix of incoming HTTP requests, we allow the URI to help route the request to the code that handles XML-RPC requests. (In the example, the URI is /RPC2, telling the server to route the request to the "RPC2" responder.)

1. A User-Agent and Host must be specified.
2. The Content-Type is text/xml.
3. The Content-Length must be specified and must be correct.

Payload format（请求的数据格式）

The payload is in XML, a single <methodCall> structure.

The <methodCall> must contain a <methodName> sub-item, a string, containing the name of the method to be called. The string may only contain identifier characters, upper and lower-case A-Z, the numeric characters, 0-9, underscore, dot, colon and slash. It's entirely up to the server to decide how to interpret the characters in a methodName.

For example, the methodName could be the name of a file containing a script that executes on an incoming request. It could be the name of a cell in a database table. Or it could be a path to a file contained within a hierarchy of folders and files.

If the procedure call has parameters, the <methodCall> must contain a <params> sub-item. The <params> sub-item can contain any number of <param>s, each of which has a <value>.

Scalar <value>s （基本数据类型）

<value>s can be scalars, type is indicated by nesting the value inside one of the tags listed in this table:

If no type is indicated, the type is string.

<struct>s （结构体类型）

A value can also be of type <struct>.

A <struct> contains <member>s and each <member> contains a <name> and a <value>.

Here's an example of a two-element <struct>:

<struct>
   <member>
      <name>lowerBound</name>
      <value><i4>18</i4></value>
   </member>
   <member>
      <name>upperBound</name>
      <value><i4>139</i4></value>
   </member>
</struct>

<struct>s can be recursive, any <value> may contain a <struct> or any other type, including an <array>, described below.

<array>s （数组类型）

A value can also be of type <array>.

An <array> contains a single <data> element, which can contain any number of <value>s.

Here's an example of a four-element array:

<array>
   <data>
      <value><i4>12</i4></value>
      <value><string>Egypt</string></value>
      <value><boolean>0</boolean></value>
      <value><i4>-31</i4></value>
   </data>
 </array>

<array> elements do not have names.

You can mix types as the example above illustrates.

<arrays>s can be recursive, any value may contain an <array> or any other type, including a <struct>, described above.

Response example （回复示例）

HTTP/1.1 200 OK
Connection: close
Content-Length: 158
Content-Type: text/xml
Date: Fri, 17 Jul 1998 19:55:08 GMT
Server: UserLand Frontier/5.1.2-WinNT

<?xml version="1.0"?>
<methodResponse>
   <params>
      <param>
         <value><string>South Dakota</string></value>
      </param>
   </params>
 </methodResponse>

Response format （回复的数据格式）

Unless there's a lower-level error, always return 200 OK.

The Content-Type is text/xml. Content-Length must be present and correct.

The body of the response is a single XML structure, a <methodResponse>, which can contain a single <params> which contains a single <param> which contains a single <value>.

The <methodResponse> could also contain a <fault> which contains a <value> which is a <struct> containing two elements, one named <faultCode>, an <int> and one named <faultString>, a <string>.

A <methodResponse> can not contain both a <fault> and a <params>.

Fault example （请求出错时的回复示例）

HTTP/1.1 200 OK
Connection: close
Content-Length: 426
Content-Type: text/xml
Date: Fri, 17 Jul 1998 19:55:02 GMT
Server: UserLand Frontier/5.1.2-WinNT

<?xml version="1.0"?>
<methodResponse>
   <fault>
      <value>
         <struct>
            <member>
               <name>faultCode</name>
               <value><int>4</int></value>
            </member>
            <member>
               <name>faultString</name>
               <value><string>Too many parameters.</string></value>
            </member>
         </struct>
       </value>
   </fault>
</methodResponse>

官方spec: http://www.xmlrpc.com/spec

XML-RPC 规范，首发于润物无声。