commit bf138b01b5b0deeac09b29ee636c2ade9e5427e9
parent 21c498f05e4d31334314a7468eb67595fefa0646
Author: Jan Dankert <devnull@localhost>
Date: Tue, 7 Feb 2012 04:36:26 +0100
XMLRPC-Methode loggen.
Diffstat:
1 file changed, 496 insertions(+), 257 deletions(-)
diff --git a/src/org/xmlrpc/android/XMLRPCClient.java b/src/org/xmlrpc/android/XMLRPCClient.java
@@ -1,12 +1,9 @@
package org.xmlrpc.android;
import java.io.BufferedInputStream;
-import java.io.BufferedReader;
import java.io.IOException;
-import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
-import java.io.StringReader;
import java.io.StringWriter;
import java.net.URI;
import java.net.URL;
@@ -18,17 +15,22 @@ import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
+import org.apache.http.client.CookieStore;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpPost;
+import org.apache.http.client.protocol.ClientContext;
import org.apache.http.conn.scheme.PlainSocketFactory;
import org.apache.http.conn.scheme.Scheme;
import org.apache.http.conn.scheme.SchemeRegistry;
import org.apache.http.conn.ssl.SSLSocketFactory;
import org.apache.http.entity.StringEntity;
+import org.apache.http.impl.client.BasicCookieStore;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.impl.conn.tsccm.ThreadSafeClientConnManager;
import org.apache.http.params.HttpParams;
import org.apache.http.params.HttpProtocolParams;
+import org.apache.http.protocol.BasicHttpContext;
+import org.apache.http.protocol.HttpContext;
import org.xmlpull.v1.XmlPullParser;
import org.xmlpull.v1.XmlPullParserFactory;
@@ -38,256 +40,403 @@ import android.util.Log;
* XMLRPCClient allows to call remote XMLRPC method.
*
* <p>
- * The following table shows how XML-RPC types are mapped to java call parameters/response values.
+ * The following table shows how XML-RPC types are mapped to java call
+ * parameters/response values.
* </p>
*
* <p>
* <table border="2" align="center" cellpadding="5">
- * <thead><tr><th>XML-RPC Type</th><th>Call Parameters</th><th>Call Response</th></tr></thead>
+ * <thead>
+ * <tr>
+ * <th>XML-RPC Type</th>
+ * <th>Call Parameters</th>
+ * <th>Call Response</th>
+ * </tr>
+ * </thead>
*
* <tbody>
- * <td>int, i4</td><td>byte<br />Byte<br />short<br />Short<br />int<br />Integer</td><td>int<br />Integer</td>
+ * <td>int, i4</td>
+ * <td>byte<br />
+ * Byte<br />
+ * short<br />
+ * Short<br />
+ * int<br />
+ * Integer</td>
+ * <td>int<br />
+ * Integer</td>
* </tr>
* <tr>
- * <td>i8</td><td>long<br />Long</td><td>long<br />Long</td>
+ * <td>i8</td>
+ * <td>long<br />
+ * Long</td>
+ * <td>long<br />
+ * Long</td>
* </tr>
* <tr>
- * <td>double</td><td>float<br />Float<br />double<br />Double</td><td>double<br />Double</td>
+ * <td>double</td>
+ * <td>float<br />
+ * Float<br />
+ * double<br />
+ * Double</td>
+ * <td>double<br />
+ * Double</td>
* </tr>
* <tr>
- * <td>string</td><td>String</td><td>String</td>
+ * <td>string</td>
+ * <td>String</td>
+ * <td>String</td>
* </tr>
* <tr>
- * <td>boolean</td><td>boolean<br />Boolean</td><td>boolean<br />Boolean</td>
+ * <td>boolean</td>
+ * <td>boolean<br />
+ * Boolean</td>
+ * <td>boolean<br />
+ * Boolean</td>
* </tr>
* <tr>
- * <td>dateTime.iso8601</td><td>java.util.Date<br />java.util.Calendar</td><td>java.util.Date</td>
+ * <td>dateTime.iso8601</td>
+ * <td>java.util.Date<br />
+ * java.util.Calendar</td>
+ * <td>java.util.Date</td>
* </tr>
* <tr>
- * <td>base64</td><td>byte[]</td><td>byte[]</td>
+ * <td>base64</td>
+ * <td>byte[]</td>
+ * <td>byte[]</td>
* </tr>
* <tr>
- * <td>array</td><td>java.util.List<Object><br />Object[]</td><td>Object[]</td>
+ * <td>array</td>
+ * <td>java.util.List<Object><br />
+ * Object[]</td>
+ * <td>Object[]</td>
* </tr>
* <tr>
- * <td>struct</td><td>java.util.Map<String, Object></td><td>java.util.Map<String, Object></td>
+ * <td>struct</td>
+ * <td>java.util.Map<String, Object></td>
+ * <td>java.util.Map<String, Object></td>
* </tr>
* </tbody>
* </table>
* </p>
* <p>
- * You can also pass as a parameter any object implementing XMLRPCSerializable interface. In this
- * case your object overrides getSerializable() telling how to serialize to XMLRPC protocol
+ * You can also pass as a parameter any object implementing XMLRPCSerializable
+ * interface. In this case your object overrides getSerializable() telling how
+ * to serialize to XMLRPC protocol
* </p>
*/
-public class XMLRPCClient extends XMLRPCCommon {
+public class XMLRPCClient extends XMLRPCCommon
+{
private HttpClient client;
private HttpPost postMethod;
private HttpParams httpParams;
- // These variables used in the code inspired by erickok in issue #6
+ // These variables used in the code inspired by erickok in issue #6
private boolean httpPreAuth = false;
private String username = "";
private String password = "";
-
+
+ public CookieStore cookieStore = new BasicCookieStore();
+ HttpContext localContext = new BasicHttpContext();
+
/**
- * XMLRPCClient constructor. Creates new instance based on server URI
- * (Code contributed by sgayda2 from issue #17, and by erickok from ticket #10)
+ * XMLRPCClient constructor. Creates new instance based on server URI (Code
+ * contributed by sgayda2 from issue #17, and by erickok from ticket #10)
*
- * @param XMLRPC server URI
+ * @param XMLRPC
+ * server URI
*/
- public XMLRPCClient(URI uri) {
+ public XMLRPCClient(URI uri)
+ {
+
+ localContext.setAttribute(ClientContext.COOKIE_STORE, cookieStore);
+
SchemeRegistry registry = new SchemeRegistry();
registry.register(new Scheme("http", new PlainSocketFactory(), 80));
- registry.register(new Scheme("https", SSLSocketFactory.getSocketFactory(), 443));
-
+ registry.register(new Scheme("https", SSLSocketFactory
+ .getSocketFactory(), 443));
+
postMethod = new HttpPost(uri);
postMethod.addHeader("Content-Type", "text/xml");
-
+
// WARNING
- // I had to disable "Expect: 100-Continue" header since I had
- // two second delay between sending http POST request and POST body
+ // I had to disable "Expect: 100-Continue" header since I had
+ // two second delay between sending http POST request and POST body
httpParams = postMethod.getParams();
HttpProtocolParams.setUseExpectContinue(httpParams, false);
- this.client = new DefaultHttpClient(new ThreadSafeClientConnManager(httpParams, registry), httpParams);
+ this.client = new DefaultHttpClient(new ThreadSafeClientConnManager(
+ httpParams, registry), httpParams);
}
-
+
/**
- * XMLRPCClient constructor. Creates new instance based on server URI
- * (Code contributed by sgayda2 from issue #17)
+ * XMLRPCClient constructor. Creates new instance based on server URI (Code
+ * contributed by sgayda2 from issue #17)
*
- * @param XMLRPC server URI
- * @param HttpClient to use
+ * @param XMLRPC
+ * server URI
+ * @param HttpClient
+ * to use
*/
-
- public XMLRPCClient(URI uri, HttpClient client) {
+
+ public XMLRPCClient(URI uri, HttpClient client)
+ {
postMethod = new HttpPost(uri);
postMethod.addHeader("Content-Type", "text/xml");
-
+
// WARNING
- // I had to disable "Expect: 100-Continue" header since I had
- // two second delay between sending http POST request and POST body
+ // I had to disable "Expect: 100-Continue" header since I had
+ // two second delay between sending http POST request and POST body
httpParams = postMethod.getParams();
HttpProtocolParams.setUseExpectContinue(httpParams, false);
this.client = client;
}
/**
- * Amends user agent
- * (Code contributed by mortenholdflod from issue #28)
+ * Amends user agent (Code contributed by mortenholdflod from issue #28)
*
- * @param userAgent defining the new User Agent string
+ * @param userAgent
+ * defining the new User Agent string
*/
- public void setUserAgent(String userAgent) {
+ public void setUserAgent(String userAgent)
+ {
postMethod.removeHeaders("User-Agent");
postMethod.addHeader("User-Agent", userAgent);
}
-
+
/**
- * Convenience constructor. Creates new instance based on server String address
- * @param XMLRPC server address
+ * Convenience constructor. Creates new instance based on server String
+ * address
+ *
+ * @param XMLRPC
+ * server address
*/
- public XMLRPCClient(String url) {
+ public XMLRPCClient(String url)
+ {
this(URI.create(url));
}
/**
- * Convenience constructor. Creates new instance based on server String address
- * @param XMLRPC server address
- * @param HttpClient to use
+ * Convenience constructor. Creates new instance based on server String
+ * address
+ *
+ * @param XMLRPC
+ * server address
+ * @param HttpClient
+ * to use
*/
- public XMLRPCClient(String url, HttpClient client) {
+ public XMLRPCClient(String url, HttpClient client)
+ {
this(URI.create(url), client);
}
-
/**
- * Convenience XMLRPCClient constructor. Creates new instance based on server URL
- * @param XMLRPC server URL
+ * Convenience XMLRPCClient constructor. Creates new instance based on
+ * server URL
+ *
+ * @param XMLRPC
+ * server URL
*/
- public XMLRPCClient(URL url) {
+ public XMLRPCClient(URL url)
+ {
this(URI.create(url.toExternalForm()));
}
/**
- * Convenience XMLRPCClient constructor. Creates new instance based on server URL
- * @param XMLRPC server URL
- * @param HttpClient to use
+ * Convenience XMLRPCClient constructor. Creates new instance based on
+ * server URL
+ *
+ * @param XMLRPC
+ * server URL
+ * @param HttpClient
+ * to use
*/
- public XMLRPCClient(URL url, HttpClient client) {
+ public XMLRPCClient(URL url, HttpClient client)
+ {
this(URI.create(url.toExternalForm()), client);
}
-
+
/**
- * Convenience constructor. Creates new instance based on server String address
- * @param XMLRPC server address
- * @param HTTP Server - Basic Authentication - Username
- * @param HTTP Server - Basic Authentication - Password
- */
- public XMLRPCClient(URI uri, String username, String password) {
- this(uri);
-
- ((DefaultHttpClient) client).getCredentialsProvider().setCredentials(
- new AuthScope(uri.getHost(), uri.getPort(),AuthScope.ANY_REALM),
- new UsernamePasswordCredentials(username, password));
- }
+ * Convenience constructor. Creates new instance based on server String
+ * address
+ *
+ * @param XMLRPC
+ * server address
+ * @param HTTP
+ * Server - Basic Authentication - Username
+ * @param HTTP
+ * Server - Basic Authentication - Password
+ */
+ public XMLRPCClient(URI uri, String username, String password)
+ {
+ this(uri);
+
+ ((DefaultHttpClient) client).getCredentialsProvider()
+ .setCredentials(
+ new AuthScope(uri.getHost(), uri.getPort(),
+ AuthScope.ANY_REALM),
+ new UsernamePasswordCredentials(username, password));
+ }
/**
- * Convenience constructor. Creates new instance based on server String address
- * @param XMLRPC server address
- * @param HTTP Server - Basic Authentication - Username
- * @param HTTP Server - Basic Authentication - Password
- * @param HttpClient to use
- */
- public XMLRPCClient(URI uri, String username, String password, HttpClient client) {
- this(uri, client);
-
- ((DefaultHttpClient) this.client).getCredentialsProvider().setCredentials(
- new AuthScope(uri.getHost(), uri.getPort(),AuthScope.ANY_REALM),
- new UsernamePasswordCredentials(username, password));
- }
+ * Convenience constructor. Creates new instance based on server String
+ * address
+ *
+ * @param XMLRPC
+ * server address
+ * @param HTTP
+ * Server - Basic Authentication - Username
+ * @param HTTP
+ * Server - Basic Authentication - Password
+ * @param HttpClient
+ * to use
+ */
+ public XMLRPCClient(URI uri, String username, String password,
+ HttpClient client)
+ {
+ this(uri, client);
+
+ ((DefaultHttpClient) this.client).getCredentialsProvider()
+ .setCredentials(
+ new AuthScope(uri.getHost(), uri.getPort(),
+ AuthScope.ANY_REALM),
+ new UsernamePasswordCredentials(username, password));
+ }
/**
- * Convenience constructor. Creates new instance based on server String address
- * @param XMLRPC server address
- * @param HTTP Server - Basic Authentication - Username
- * @param HTTP Server - Basic Authentication - Password
+ * Convenience constructor. Creates new instance based on server String
+ * address
+ *
+ * @param XMLRPC
+ * server address
+ * @param HTTP
+ * Server - Basic Authentication - Username
+ * @param HTTP
+ * Server - Basic Authentication - Password
*/
- public XMLRPCClient(String url, String username, String password) {
+ public XMLRPCClient(String url, String username, String password)
+ {
this(URI.create(url), username, password);
}
/**
- * Convenience constructor. Creates new instance based on server String address
- * @param XMLRPC server address
- * @param HTTP Server - Basic Authentication - Username
- * @param HTTP Server - Basic Authentication - Password
- * @param HttpClient to use
+ * Convenience constructor. Creates new instance based on server String
+ * address
+ *
+ * @param XMLRPC
+ * server address
+ * @param HTTP
+ * Server - Basic Authentication - Username
+ * @param HTTP
+ * Server - Basic Authentication - Password
+ * @param HttpClient
+ * to use
*/
- public XMLRPCClient(String url, String username, String password, HttpClient client) {
+ public XMLRPCClient(String url, String username, String password,
+ HttpClient client)
+ {
this(URI.create(url), username, password, client);
}
/**
- * Convenience constructor. Creates new instance based on server String address
- * @param XMLRPC server url
- * @param HTTP Server - Basic Authentication - Username
- * @param HTTP Server - Basic Authentication - Password
+ * Convenience constructor. Creates new instance based on server String
+ * address
+ *
+ * @param XMLRPC
+ * server url
+ * @param HTTP
+ * Server - Basic Authentication - Username
+ * @param HTTP
+ * Server - Basic Authentication - Password
*/
- public XMLRPCClient(URL url, String username, String password) {
+ public XMLRPCClient(URL url, String username, String password)
+ {
this(URI.create(url.toExternalForm()), username, password);
}
/**
- * Convenience constructor. Creates new instance based on server String address
- * @param XMLRPC server url
- * @param HTTP Server - Basic Authentication - Username
- * @param HTTP Server - Basic Authentication - Password
- * @param HttpClient to use
+ * Convenience constructor. Creates new instance based on server String
+ * address
+ *
+ * @param XMLRPC
+ * server url
+ * @param HTTP
+ * Server - Basic Authentication - Username
+ * @param HTTP
+ * Server - Basic Authentication - Password
+ * @param HttpClient
+ * to use
*/
- public XMLRPCClient(URL url, String username, String password, HttpClient client) {
+ public XMLRPCClient(URL url, String username, String password,
+ HttpClient client)
+ {
this(URI.create(url.toExternalForm()), username, password, client);
}
/**
* Sets basic authentication on web request using plain credentials
- * @param username The plain text username
- * @param password The plain text password
- * @param doPreemptiveAuth Select here whether to authenticate without it being requested first by the server.
+ *
+ * @param username
+ * The plain text username
+ * @param password
+ * The plain text password
+ * @param doPreemptiveAuth
+ * Select here whether to authenticate without it being requested
+ * first by the server.
*/
- public void setBasicAuthentication(String username, String password, boolean doPreemptiveAuth) {
- // This code required to trigger the patch created by erickok in issue #6
- if(doPreemptiveAuth = true) {
+ public void setBasicAuthentication(String username, String password,
+ boolean doPreemptiveAuth)
+ {
+ // This code required to trigger the patch created by erickok in issue
+ // #6
+ if (doPreemptiveAuth = true)
+ {
this.httpPreAuth = doPreemptiveAuth;
this.username = username;
this.password = password;
- } else {
- ((DefaultHttpClient) client).getCredentialsProvider().setCredentials(new AuthScope(postMethod.getURI().getHost(), postMethod.getURI().getPort(), AuthScope.ANY_REALM), new UsernamePasswordCredentials(username, password));
+ }
+ else
+ {
+ ((DefaultHttpClient) client)
+ .getCredentialsProvider()
+ .setCredentials(
+ new AuthScope(postMethod.getURI().getHost(),
+ postMethod.getURI().getPort(),
+ AuthScope.ANY_REALM),
+ new UsernamePasswordCredentials(username, password));
}
}
/**
- * Convenience Constructor: Sets basic authentication on web request using plain credentials
- * @param username The plain text username
- * @param password The plain text password
+ * Convenience Constructor: Sets basic authentication on web request using
+ * plain credentials
+ *
+ * @param username
+ * The plain text username
+ * @param password
+ * The plain text password
*/
- public void setBasicAuthentication(String username, String password) {
+ public void setBasicAuthentication(String username, String password)
+ {
setBasicAuthentication(username, password, false);
}
-
+
/**
- * Call method with optional parameters. This is general method.
- * If you want to call your method with 0-8 parameters, you can use more
- * convenience call() methods
+ * Call method with optional parameters. This is general method. If you want
+ * to call your method with 0-8 parameters, you can use more convenience
+ * call() methods
*
- * @param method name of method to call
- * @param params parameters to pass to method (may be null if method has no parameters)
+ * @param method
+ * name of method to call
+ * @param params
+ * parameters to pass to method (may be null if method has no
+ * parameters)
* @return deserialized method return value
* @throws XMLRPCException
*/
@SuppressWarnings("unchecked")
- public Object callEx(String method, Object[] params) throws XMLRPCException {
- try {
+ public Object callEx(String method, Object[] params) throws XMLRPCException
+ {
+ try
+ {
// prepare POST body
String body = methodCall(method, params);
@@ -297,92 +446,131 @@ public class XMLRPCClient extends XMLRPCCommon {
// This code slightly tweaked from the code by erickok in issue #6
// Force preemptive authentication
- // This makes sure there is an 'Authentication: ' header being send before trying and failing and retrying
+ // This makes sure there is an 'Authentication: ' header being send
+ // before trying and failing and retrying
// by the basic authentication mechanism of DefaultHttpClient
- if(this.httpPreAuth == true) {
+ if (this.httpPreAuth == true)
+ {
String auth = this.username + ":" + this.password;
- postMethod.addHeader("Authorization", "Basic " + Base64Coder.encode(auth.getBytes()).toString());
+ postMethod.addHeader("Authorization", "Basic "
+ + Base64Coder.encode(auth.getBytes()).toString());
}
-
- //Log.d(Tag.LOG, "ros HTTP POST");
+
+ // Log.d(Tag.LOG, "ros HTTP POST");
// execute HTTP POST request
- HttpResponse response = client.execute(postMethod);
- //Log.d(Tag.LOG, "ros HTTP POSTed");
+
+ Log.d("IBC", "XMLRPC method: " + method);
+ // for (Cookie cookie : cookieStore.getCookies())
+ // {
+ // Log.d("IBC", cookie.toString());
+ // }
+
+ HttpResponse response = client.execute(postMethod, localContext);
+ // Log.d(Tag.LOG, "ros HTTP POSTed");
// check status code
int statusCode = response.getStatusLine().getStatusCode();
- //Log.d(Tag.LOG, "ros status code:" + statusCode);
- if (statusCode != HttpStatus.SC_OK) {
- throw new XMLRPCException("HTTP status code: " + statusCode + " != " + HttpStatus.SC_OK, statusCode);
- }
+
+ // Log.d("IBC", "Status: " + statusCode);
+ // for (Cookie cookie : cookieStore.getCookies())
+ // {
+ // Log.d("IBC", cookie.toString());
+ // }
+ // Log.d("IBC", "");
+
+ // Log.d(Tag.LOG, "ros status code:" + statusCode);
+ if (statusCode != HttpStatus.SC_OK)
+ {
+ throw new XMLRPCException("HTTP status code: " + statusCode
+ + " != " + HttpStatus.SC_OK, statusCode);
+ }
// parse response stuff
//
// setup pull parser
- XmlPullParser pullParser = XmlPullParserFactory.newInstance().newPullParser();
+ XmlPullParser pullParser = XmlPullParserFactory.newInstance()
+ .newPullParser();
entity = response.getEntity();
- Reader reader = new InputStreamReader(new BufferedInputStream(entity.getContent(),250));
-// for testing purposes only
-// reader = new StringReader("<?xml version='1.0'?><methodResponse><params><param><value>\n\n\n</value></param></params></methodResponse>");
+ Reader reader = new InputStreamReader(new BufferedInputStream(
+ entity.getContent(), 250));
+ // for testing purposes only
+ // reader = new
+ // StringReader("<?xml version='1.0'?><methodResponse><params><param><value>\n\n\n</value></param></params></methodResponse>");
pullParser.setInput(reader);
-
+
// lets start pulling...
pullParser.nextTag();
-
- //Log.d("XMLRPC response",this.inputStreamToString(entity.getContent()));
- //entity.getContent().reset();
-
- pullParser.require(XmlPullParser.START_TAG, null, Tag.METHOD_RESPONSE);
-
- pullParser.nextTag(); // either Tag.PARAMS (<params>) or Tag.FAULT (<fault>)
+
+ // Log.d("XMLRPC response",this.inputStreamToString(entity.getContent()));
+ // entity.getContent().reset();
+
+ pullParser.require(XmlPullParser.START_TAG, null,
+ Tag.METHOD_RESPONSE);
+
+ pullParser.nextTag(); // either Tag.PARAMS (<params>) or Tag.FAULT
+ // (<fault>)
String tag = pullParser.getName();
-
- if (tag.equals(Tag.PARAMS)) {
+
+ if (tag.equals(Tag.PARAMS))
+ {
// normal response
pullParser.nextTag(); // Tag.PARAM (<param>)
pullParser.require(XmlPullParser.START_TAG, null, Tag.PARAM);
pullParser.nextTag(); // Tag.VALUE (<value>)
- // no parser.require() here since its called in XMLRPCSerializer.deserialize() below
-
+ // no parser.require() here since its called in
+ // XMLRPCSerializer.deserialize() below
+
// deserialize result
Object obj = iXMLRPCSerializer.deserialize(pullParser);
entity.consumeContent();
return obj;
- } else
- if (tag.equals(Tag.FAULT)) {
+ }
+ else if (tag.equals(Tag.FAULT))
+ {
// fault response
pullParser.nextTag(); // Tag.VALUE (<value>)
- // no parser.require() here since its called in XMLRPCSerializer.deserialize() below
+ // no parser.require() here since its called in
+ // XMLRPCSerializer.deserialize() below
// deserialize fault result
- Map<String, Object> map = (Map<String, Object>) iXMLRPCSerializer.deserialize(pullParser);
+ Map<String, Object> map = (Map<String, Object>) iXMLRPCSerializer
+ .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 {
+ }
+ else
+ {
entity.consumeContent();
- throw new XMLRPCException("Bad tag <" + tag + "> in XMLRPC response - neither <params> nor <fault>");
+ throw new XMLRPCException("Bad tag <" + tag
+ + "> in XMLRPC response - neither <params> nor <fault>");
}
- } catch (XMLRPCException e) {
+ }
+ catch (XMLRPCException e)
+ {
// catch & propagate XMLRPCException/XMLRPCFault
throw e;
- } catch (Exception e) {
+ }
+ catch (Exception e)
+ {
e.printStackTrace();
// wrap any other Exception(s) around XMLRPCException
throw new XMLRPCException(e);
}
}
-
+
private String methodCall(String method, Object[] params)
- throws IllegalArgumentException, IllegalStateException, IOException {
+ throws IllegalArgumentException, IllegalStateException, IOException
+ {
StringWriter bodyWriter = new StringWriter();
serializer.setOutput(bodyWriter);
serializer.startDocument(null, null);
serializer.startTag(null, Tag.METHOD_CALL);
// set method name
- serializer.startTag(null, Tag.METHOD_NAME).text(method).endTag(null, Tag.METHOD_NAME);
-
+ serializer.startTag(null, Tag.METHOD_NAME).text(method).endTag(null,
+ Tag.METHOD_NAME);
+
serializeParams(params);
serializer.endTag(null, Tag.METHOD_CALL);
@@ -394,176 +582,227 @@ public class XMLRPCClient extends XMLRPCCommon {
/**
* Convenience method call with no parameters
*
- * @param method name of method to call
+ * @param method
+ * name of method to call
* @return deserialized method return value
* @throws XMLRPCException
*/
- public Object call(String method) throws XMLRPCException {
+ public Object call(String method) throws XMLRPCException
+ {
return callEx(method, null);
}
-
+
/**
- * Convenience method call with a vectorized parameter
- * (Code contributed by jahbromo from issue #14)
- * @param method name of method to call
- * @param paramsv vector of method's parameter
+ * Convenience method call with a vectorized parameter (Code contributed by
+ * jahbromo from issue #14)
+ *
+ * @param method
+ * name of method to call
+ * @param paramsv
+ * vector of method's parameter
* @return deserialized method return value
* @throws XMLRPCException
*/
-
- public Object call(String method, Vector paramsv) throws XMLRPCException {
- Object[] params = new Object [paramsv.size()];
- for (int i=0; i<paramsv.size(); i++) {
- params[i]=paramsv.elementAt(i);
+
+ public Object call(String method, Vector paramsv) throws XMLRPCException
+ {
+ Object[] params = new Object[paramsv.size()];
+ for (int i = 0; i < paramsv.size(); i++)
+ {
+ params[i] = paramsv.elementAt(i);
}
return callEx(method, params);
}
-
+
/**
* Convenience method call with one parameter
*
- * @param method name of method to call
- * @param p0 method's parameter
+ * @param method
+ * name of method to call
+ * @param p0
+ * method's parameter
* @return deserialized method return value
* @throws XMLRPCException
*/
- public Object call(String method, Object p0) throws XMLRPCException {
- Object[] params = {
- p0,
- };
+ public Object call(String method, Object p0) throws XMLRPCException
+ {
+ Object[] params = { p0, };
return callEx(method, params);
}
-
+
/**
* Convenience method call with two parameters
*
- * @param method name of method to call
- * @param p0 method's 1st parameter
- * @param p1 method's 2nd parameter
+ * @param method
+ * name of method to call
+ * @param p0
+ * method's 1st parameter
+ * @param p1
+ * method's 2nd parameter
* @return deserialized method return value
* @throws XMLRPCException
*/
- public Object call(String method, Object p0, Object p1) throws XMLRPCException {
- Object[] params = {
- p0, p1,
- };
+ public Object call(String method, Object p0, Object p1)
+ throws XMLRPCException
+ {
+ Object[] params = { p0, p1, };
return callEx(method, params);
}
-
+
/**
* Convenience method call with three parameters
*
- * @param method name of method to call
- * @param p0 method's 1st parameter
- * @param p1 method's 2nd parameter
- * @param p2 method's 3rd parameter
+ * @param method
+ * name of method to call
+ * @param p0
+ * method's 1st parameter
+ * @param p1
+ * method's 2nd parameter
+ * @param p2
+ * method's 3rd parameter
* @return deserialized method return value
* @throws XMLRPCException
*/
- public Object call(String method, Object p0, Object p1, Object p2) throws XMLRPCException {
- Object[] params = {
- p0, p1, p2,
- };
+ public Object call(String method, Object p0, Object p1, Object p2)
+ throws XMLRPCException
+ {
+ Object[] params = { p0, p1, p2, };
return callEx(method, params);
}
/**
* Convenience method call with four parameters
*
- * @param method name of method to call
- * @param p0 method's 1st parameter
- * @param p1 method's 2nd parameter
- * @param p2 method's 3rd parameter
- * @param p3 method's 4th parameter
+ * @param method
+ * name of method to call
+ * @param p0
+ * method's 1st parameter
+ * @param p1
+ * method's 2nd parameter
+ * @param p2
+ * method's 3rd parameter
+ * @param p3
+ * method's 4th parameter
* @return deserialized method return value
* @throws XMLRPCException
*/
- public Object call(String method, Object p0, Object p1, Object p2, Object p3) throws XMLRPCException {
- Object[] params = {
- p0, p1, p2, p3,
- };
+ public Object call(String method, Object p0, Object p1, Object p2, Object p3)
+ throws XMLRPCException
+ {
+ Object[] params = { p0, p1, p2, p3, };
return callEx(method, params);
}
/**
* Convenience method call with five parameters
*
- * @param method name of method to call
- * @param p0 method's 1st parameter
- * @param p1 method's 2nd parameter
- * @param p2 method's 3rd parameter
- * @param p3 method's 4th parameter
- * @param p4 method's 5th parameter
+ * @param method
+ * name of method to call
+ * @param p0
+ * method's 1st parameter
+ * @param p1
+ * method's 2nd parameter
+ * @param p2
+ * method's 3rd parameter
+ * @param p3
+ * method's 4th parameter
+ * @param p4
+ * method's 5th parameter
* @return deserialized method return value
* @throws XMLRPCException
*/
- public Object call(String method, Object p0, Object p1, Object p2, Object p3, Object p4) throws XMLRPCException {
- Object[] params = {
- p0, p1, p2, p3, p4,
- };
+ public Object call(String method, Object p0, Object p1, Object p2,
+ Object p3, Object p4) throws XMLRPCException
+ {
+ Object[] params = { p0, p1, p2, p3, p4, };
return callEx(method, params);
}
/**
* Convenience method call with six parameters
*
- * @param method name of method to call
- * @param p0 method's 1st parameter
- * @param p1 method's 2nd parameter
- * @param p2 method's 3rd parameter
- * @param p3 method's 4th parameter
- * @param p4 method's 5th parameter
- * @param p5 method's 6th parameter
+ * @param method
+ * name of method to call
+ * @param p0
+ * method's 1st parameter
+ * @param p1
+ * method's 2nd parameter
+ * @param p2
+ * method's 3rd parameter
+ * @param p3
+ * method's 4th parameter
+ * @param p4
+ * method's 5th parameter
+ * @param p5
+ * method's 6th parameter
* @return deserialized method return value
* @throws XMLRPCException
*/
- public Object call(String method, Object p0, Object p1, Object p2, Object p3, Object p4, Object p5) throws XMLRPCException {
- Object[] params = {
- p0, p1, p2, p3, p4, p5,
- };
+ public Object call(String method, Object p0, Object p1, Object p2,
+ Object p3, Object p4, Object p5) throws XMLRPCException
+ {
+ Object[] params = { p0, p1, p2, p3, p4, p5, };
return callEx(method, params);
}
/**
* Convenience method call with seven parameters
*
- * @param method name of method to call
- * @param p0 method's 1st parameter
- * @param p1 method's 2nd parameter
- * @param p2 method's 3rd parameter
- * @param p3 method's 4th parameter
- * @param p4 method's 5th parameter
- * @param p5 method's 6th parameter
- * @param p6 method's 7th parameter
+ * @param method
+ * name of method to call
+ * @param p0
+ * method's 1st parameter
+ * @param p1
+ * method's 2nd parameter
+ * @param p2
+ * method's 3rd parameter
+ * @param p3
+ * method's 4th parameter
+ * @param p4
+ * method's 5th parameter
+ * @param p5
+ * method's 6th parameter
+ * @param p6
+ * method's 7th parameter
* @return deserialized method return value
* @throws XMLRPCException
*/
- public Object call(String method, Object p0, Object p1, Object p2, Object p3, Object p4, Object p5, Object p6) throws XMLRPCException {
- Object[] params = {
- p0, p1, p2, p3, p4, p5, p6,
- };
+ public Object call(String method, Object p0, Object p1, Object p2,
+ Object p3, Object p4, Object p5, Object p6) throws XMLRPCException
+ {
+ Object[] params = { p0, p1, p2, p3, p4, p5, p6, };
return callEx(method, params);
}
/**
* Convenience method call with eight parameters
*
- * @param method name of method to call
- * @param p0 method's 1st parameter
- * @param p1 method's 2nd parameter
- * @param p2 method's 3rd parameter
- * @param p3 method's 4th parameter
- * @param p4 method's 5th parameter
- * @param p5 method's 6th parameter
- * @param p6 method's 7th parameter
- * @param p7 method's 8th parameter
+ * @param method
+ * name of method to call
+ * @param p0
+ * method's 1st parameter
+ * @param p1
+ * method's 2nd parameter
+ * @param p2
+ * method's 3rd parameter
+ * @param p3
+ * method's 4th parameter
+ * @param p4
+ * method's 5th parameter
+ * @param p5
+ * method's 6th parameter
+ * @param p6
+ * method's 7th parameter
+ * @param p7
+ * method's 8th parameter
* @return deserialized method return value
* @throws XMLRPCException
*/
- public Object call(String method, Object p0, Object p1, Object p2, Object p3, Object p4, Object p5, Object p6, Object p7) throws XMLRPCException {
- Object[] params = {
- p0, p1, p2, p3, p4, p5, p6, p7,
- };
+ public Object call(String method, Object p0, Object p1, Object p2,
+ Object p3, Object p4, Object p5, Object p6, Object p7)
+ throws XMLRPCException
+ {
+ Object[] params = { p0, p1, p2, p3, p4, p5, p6, p7, };
return callEx(method, params);
}
}
