linphone编译源码

What is aXMLRPC? ================ aXMLRPC is a Java library with a leightweight XML-RPC client. XML-RPC is a specification for making remote procedure calls over the HTTP protocol in an XML format. The specificationc an be found under http://www.xmlrpc.com/spec. The library was developed for the use with Android. Since it has no dependencies to any Android library or any other 3rd-party library, it is fully functional in any common java virtual machine (not only on Android). You can control the client with some flags to extend its functionality. See the section about flags. How to include it? ================== How to include the aXMLRPC client into your project? There are four different ways to do that: ### Include the source code You can just include all the source code from the `src` directory into the sourcecode of your project. If you use git yourself, you can use submodules to include the code as a module to yours. So you will always stay up to date with the library. ### Compile it as library The library itself is a NetBeans project and can be compiled either with NetBeans or with `ant`. The resulting JAR file can be used as a dependency in your project. If you use NetBeans you can make a dependency directly to the project. ### Use Maven The library is also a valid Maven project. So you can use Maven to compile it. If you want to use it as a Maven project in NetBeans, you will have to delete the `nbproject` folder. Afterwards NetBeans will detect it as a Maven project (NetBeans restart required). To use it on your Maven project, add it as a dependency on your pom.xml file: ```xml <dependency> <groupId>de.timroes</groupId> <artifactId>aXMLRPC</artifactId> <version>X.Y.Z</version> </dependency> ``` where X.Y.Z is the current aXMLRPC version and install it on your local Maven repository (since it's not available on the Maven repositories): ```console $ cd /path/to/aXMLRPC/ $ mvn clean install ``` ### Download the JAR library You can download a compiled jar file from the below list and use it as a library for your project. [aXMLRPC v1.4.0](https://dl.dropbox.com/u/56970236/aXMLRPC/aXMLRPC_v1.4.0.jar) * Added FLAGS_IGNORE_NAMESPACE, FLAGS_DEFAULT_TYPE_STRING [aXMLRPC v1.3.5](https://dl.dropbox.com/u/56970236/aXMLRPC/aXMLRPC_v1.3.5.jar) * Fixed bug in canceling async calls [aXMLRPC v1.3.4](https://dl.dropbox.com/u/56970236/aXMLRPC/aXMLRPC_v1.3.4.jar) * Added getURL-method * Added FLAGS_IGNORE_SSL_ERRORS * Removed debugging information from JAR [aXMLRPC v1.3.3](https://dl.dropbox.com/u/56970236/aXMLRPC/aXMLRPC_v1.3.3.jar) * Improved handling of 40X http errors [aXMLRPC v1.3.2](https://dl.dropbox.com/u/56970236/aXMLRPC/aXMLRPC_v1.3.2.jar) * Fixed handling of 40x http errors [aXMLRPC v1.3.1](https://dl.dropbox.com/u/56970236/aXMLRPC/aXMLRPC_v1.3.1.jar) * Fixed bug in XML struct creation * Method to clear HTTP basic auth login data [aXMLRPC v1.3.0](https://dl.dropbox.com/u/56970236/aXMLRPC/aXMLRPC_v1.3.0.jar) * Flags to ignore SSL warnings * HTTP forwarding * Improved code quality **Real old versions:** * [aXMLRPC v1.2.0](https://dl.dropbox.com/u/56970236/aXMLRPC/aXMLRPC_v1.2.0.jar) * [aXMLRPC v1.1.0](https://dl.dropbox.com/u/56970236/aXMLRPC/aXMLRPC_v1.1.0.jar) * [aXMLRPC v1.0.3](https://dl.dropbox.com/u/56970236/aXMLRPC/aXMLRPC_v1.0.3.jar) * [aXMLRPC v1.0.2](https://dl.dropbox.com/u/56970236/aXMLRPC/aXMLRPC_v1.0.2.jar) * [aXMLRPC v1.0.1](https://dl.dropbox.com/u/56970236/aXMLRPC/aXMLRPC_v1.0.1.jar) How to use the library? ======================= You can use the library by initiating an `XMLRPCClient` and make calls over it: ```java try { XMLRPCClient client = new XMLRPCClient(new URL("http://example.com/xmlrpc")); Boolean b = (Boolean)client.call("isServerOk"); Integer i = (Integer)client.call("add", 5, 10); } catch(XMLRPCServerException ex) { // The server throw an error. } catch(XMLRPCException ex) { // An error occured in the client. } catch(Exception ex) { // Any other exception } ``` Instead of passing the parameters as seperated values, you can also pack them in an array and pass the array to the method, like in the following example: ```java // ... The try-catch has been ommited for clarity. XMLRPCClient client = new XMLRPCClient(url, "MyUserAgentString"); client.call("someMethod", new Object[]{ o1, o2, o3 }); // ... ``` #### Asynchronous Calls The above method calls are synchronous. So the method `call` will return when the server responded or an error occured. There is also a possibility for asynchronous server calls. You need to implement an XMLRPCCallback that will get noticed about the respone (or error) from the server. The `callAsync` method can be used to make asynchronous calls. It returns an identifier that will also be send to the XMLRPCCallback instance with the response of the server, so your application can make multiple calls concurrently and use one listener for them, that distinguish between the different request by their ids. ```java XMLRPCCallback listener = new XMLRPCCallback() { public void onResponse(long id, Object result) { // Handling the servers response } public void onError(long id, XMLRPCException error) { // Handling any error in the library } public void onServerError(long id, XMLRPCServerException error) { // Handling an error response from the server } }; XMLRPCClient client = new XMLRPCClient(url); long id = client.callAsync(listener, "add", 5, 10); ``` You will be also able to cancel an asynchonous call. Just use the `cancel` method on the `XMLRPCClient` instance, like in the following example. The listener will not be notified, if the call is canceled. ```java XMLRPCClient client = new XMLRPCClient(url); long id = client.callAsync(listener, "method", params); // ... client.cancel(id); ``` The data types -------------- The specification give some data tags for the server response. If you want to work on the type you must cast the returning `Object` from the `call` method to its specific type. Which type to cast which XML server response, tells the following list: `i4`,`int` => `Integer` `boolean` => `Boolean` `string` => `String` `double` => `Double` `dateTime.iso8601` => `Date` `base64` => `byte[]` (`Byte[]` won't work) `array` => `Object[]` `struct` => `Map<String,Object>` `i8` => `Long` (see Flags) Flags ----- The client takes as second parameter (or third if an user agent is given) a combination of multiple flags. It could work like the following example: ```java // ... XMLRPCClient client = new XMLRPCClient(url, XMLRPCClient.FLAGS_STRICT | XMLRPCClient.FLAGS_8BYTE_INT); // ... ``` The following flags are implemented: #### FLAGS_STRICT The client should parse responses strict to specification. It will check if the given content-type is right. The method name in a call must only contain of A-Z, a-z, 0-9, _, ., :, / Normally this is not needed. #### FLAGS_8BYTE_INT The client will be able to handle 8 byte integer values (longs). The xml type tag `<i8>` will be used. This is not in the specification but some libraries and servers support this behaviour. If this isn't enabled you cannot recieve 8 byte integers and if you try to send a long, the value must be within the 4 byte integer range. #### FLAGS_ENABLE_COOKIES With this flag, the client will be able to handle cookies, meaning saving cookies from the server and sending it with every other request again. This is needed for some XML-RPC interfaces that support login. #### FLAGS_NIL The client will be able to send `null` values. A `null` value will be send as `<nil/>`. This extension is described under: http://ontosys.com/xml-rpc/extensions.php #### FLAGS_IGNORE_STATUSCODE With this flag enabled, the XML-RPC client will ignore the HTTP status code of the response from the server. According to specification the status code must be 200. This flag is only needed for the use with not standard compliant servers