Posting to wordpress from android app

[Kirill Varivoda]

Hi, guys. Is there is a way to post comments (or even posts) in Wordpress blog using Json, for example?
Now I know how to retrieve data using json, but not to post.

Can't find any useful example.

[Paul Clapham]

Well, there's a WordPress app for Android so it must be possible. I don't know if it has a published API though.

I also haven't tried the app.

[Kirill Varivoda]

Paul Clapham wrote:Well, there's a WordPress app for Android so it must be possible. I don't know if it has a published API though.

I also haven't tried the app.

Oh, there is. There is a source code too, but it's really messy as for beginner.

[ibrahim yener]

Could you give a shot following code.

try
{
	//	SET HTML FORM FIELD NAMES HERE
	List<NameValuePair> value = new ArrayList<NameValuePair>();
	value.add(new BasicNameValuePair("form_field_name", "form_field_value"));
	value.add(new BasicNameValuePair("form_field_name", "form_field_value"));
	value.add(new BasicNameValuePair("form_field_name", "form_field_value"));
	value.add(new BasicNameValuePair("form_field_name", "form_field_value"));
	
	//	IF YOU ARE NOT USING HTTPS
	DefaultHttpClient httpclient = new DefaultHttpClient();
	Credentials credentials = new UsernamePasswordCredentials("admin_ID", "admin_PASS");
	// Does not get Authentication if do not use AuthScope.ANY
	httpclient.getCredentialsProvider().setCredentials(AuthScope.ANY, credentials);
	HttpPost post = new HttpPost("http://some_url.com");
	httpPost.setHeader("Content-Type", "application/json");

	post.setEntity(new UrlEncodedFormEntity(value));
	httpclient.execute(post);
	
	//	IF YOU ARE USING HTTPS
	DefaultHttpClient client = HttpsClientBuilder.getBelieverHttpsClient();
	ResponseHandler<String> handler = new BasicResponseHandler();
	HttpPost httpPost = new HttpPost("http://some_url.com");
	httpPost.setHeader("Content-Type", "application/json");
	httpPost.setHeader("Authorization", authorizationString);
	httpPost.setEntity(new UrlEncodedFormEntity(value));

	result = client.execute(httpPost, handler);
}
catch(Exception e)
{
	System.out.println(e.toString());
}

And this is HttpsClientBuilder class for HTTPS web sites (Note: This code is not belong to me. I found somewhere else)

public class HttpsClientBuilder
{
	public static DefaultHttpClient getBelieverHttpsClient()
	{
		DefaultHttpClient client = null;

		SchemeRegistry Current_Scheme = new SchemeRegistry();
		Current_Scheme.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
		try
		{
			Current_Scheme.register(new Scheme("https", new Naive_SSLSocketFactory(), 443));
		}
		catch (Exception e)
		{
			e.printStackTrace();
		}

		HttpParams Current_Params = new BasicHttpParams();
		HttpConnectionParams.setConnectionTimeout(Current_Params, 5000);
//		HttpConnectionParams.setSoTimeout(Current_Params, 10000);
		ThreadSafeClientConnManager Current_Manager = new ThreadSafeClientConnManager(Current_Params, Current_Scheme);
		client = new DefaultHttpClient(Current_Manager, Current_Params);

		return client;
	}

	public static class Naive_SSLSocketFactory extends SSLSocketFactory
	{
		protected SSLContext	Cur_SSL_Context	= SSLContext.getInstance("TLS");

		public Naive_SSLSocketFactory() throws NoSuchAlgorithmException, KeyManagementException, KeyStoreException, UnrecoverableKeyException
		{
			super(null);
			Cur_SSL_Context.init(null, new TrustManager[]{new X509_Trust_Manager()}, null);
		}

		@Override
		public Socket createSocket(Socket socket, String host, int port, boolean autoClose) throws IOException
		{
			return Cur_SSL_Context.getSocketFactory().createSocket(socket, host, port, autoClose);
		}

		@Override
		public Socket createSocket() throws IOException
		{
			return Cur_SSL_Context.getSocketFactory().createSocket();
		}
	}

	private static class X509_Trust_Manager implements X509TrustManager
	{
		public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException
		{
		}

		public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException
		{
		}

		public X509Certificate[] getAcceptedIssuers()
		{
			return null;
		}
	};
}

[Karthik Shiraly]

Wordpress exposes an XML based API to post blogs or comments. This is inbuilt and does not need any plugins to support it.
A JSON interface would require some kind of 3rd party plugin (I had a quick look in Wordpress 4 source code, and I could find no inbuilt JSON API).

If XML is ok with you, then I can give you information on how to do so from Java, since I've written a java desktop application for my own use that does exactly that.

[Kirill Varivoda]

Ibrahim Yener, thank you! I'll try that.

[Kirill Varivoda]

Karthik Shiraly wrote:Wordpress exposes an XML based API to post blogs or comments. This is inbuilt and does not need any plugins to support it.
A JSON interface would require some kind of 3rd party plugin (I had a quick look in Wordpress 4 source code, and I could find no inbuilt JSON API).

If XML is ok with you, then I can give you information on how to do so from Java, since I've written a java desktop application for my own use that does exactly that.

Actually in my blog there is a Json plugin but if you can share how to do without it, it would be good!

[Karthik Shiraly]

Actually in my blog there is a Json plugin but if you can share how to do without it, it would be good!

The Wordpress official API is called XML-RPC API. It's documentated farely well on the wordpress developer site.

If you're not familiar with it, then XMLRPC is a somewhat outdated web service protocol. All the requests and responses are encoded as XML snippets.
The RPC in the name (RPC=Remote Procedure Call) hints at the contents of those XML requests and responses. Basically, the requests have a method name and a list of arguments.
The responses contain a return object or an exception object. Both requests and responses have to follow a particular XML schema mandated by the protocol.

IIRC, XMLRPC is enabled by default on all Wordpress sites above version 3, but used to be disabled by default in earlier versions. If it's disabled, enable it from your WP admin portal.

On the developer site, notice the 2 APIs "wp.newPost" and "wp.newComment" - those are the two you'd need to publish new posts or comments.

For forming schema compliant XMLs, download the Apache XMLRPC library.
In your project, add xmlrpc-client.jar, xmlrpc-common.jar, ws-common-util.jar and commons-logging.jar to classpath.

The XMLRPC endpoint is typically "http://[your-blog-url]/xmlrpc.php". However, some people (me!) change this to avoid spam bots. So if you're writing a general purpose tool that can be used by anybody, then you might want to provide a way for user to enter the endpoint URL.

Code for publishing a new post goes like this:

private static void publishPost() {
    try {
        XmlRpcClientConfigImpl config = new XmlRpcClientConfigImpl();
        config.setServerURL(new URL("http://yourblog.com/xmlrpc.php")); // or whatever is the actual XMLRPC endpoint.
        
        XmlRpcClient rpcClient = new XmlRpcClient();
        rpcClient.setConfig(config);
        
        // Create list of arguments for wp.newPost.
        // The Apache XMLRPC library expects the list to be a map of key-value pairs.
        // Refer http://codex.wordpress.org/XML-RPC_WordPress_API/Posts#wp.newPost and 
        // http://codex.wordpress.org/Function_Reference/wp_insert_post for explanation of all arguments.
        Map content = new Hashtable();
        content.put("post_type", "post");
        content.put("post_status", "publish"); // "draft" for draft posts.
        content.put("post_title", "XMLRPC draft post"); 
        content.put("post_content", "<b>This is a draft post</b><em>with some content</em>"); // The HTML content of the blog post.
        
        // Make the XMLRPC call.
        Object result = rpcClient.execute("wp.newPost", new Object[]{
            0, // Always 0. It's ignored by wordpress.
            "your_blog_username",
            "your_blog_password",
            content
        });
        
        // Print result - this is the new post's ID.
        System.out.println(result);
        
    } catch (XmlRpcException e) {
        System.out.println("Error code=" + e.code);
        if (e.code == UNSUPPORTED_METHOD_XMLRPC_ERROR_CODE && e.getMessage().contains("wp.newPost does not exist")) {
            System.out.println("This Wordpress is older than v3.4. Call blogger.newPost instead of wp.newPost");
        }
        e.printStackTrace();
        
    } catch (Exception e) {
        e.printStackTrace();
    }
}

Similar code for wp.newComment. Its arguments are documented here.