Android HTTP Client: GET, POST, Download, Upload, Multipart Request

Often Android apps have to exchange information with a remote server using Android HTTP client. The easiest way is to use the HTTP protocol as a base to transfer information. There are several scenarios where the HTTP protocol is very useful like downloading an image from a remote server or uploading some binary data to the server. Android app performs GET or POST request to send data. In this post, we want to investigate how to use HttpURLConnection to communicate with a remote server.

As a server, we will use three simple Servlet running inside Tomcat 7.0. We won’t cover how to create a Servlet using API 3.0, you can find the source code here.

You can download the tutorial source code here:

 

android_handle_http_connection_tutorial

GET and POST requests in Android HTTP Client

When developing Android HTTP client, GET and POST requests are the base blocks in HTTP protocol. To make this kind of requests we need first to open a connection toward the remote server:

[java] HttpURLConnection con = (HttpURLConnection) ( new URL(url)).openConnection();
con.setRequestMethod("POST");
con.setDoInput(true);
con.setDoOutput(true);
con.connect();
[/java]

In the first line we get the HttpURLConnection, while in line 2, we set the method and at the end we connect to the server.
Once we have opened the connection we can write on it using the OutputStream.

con.getOutputStream().write( ("name=" + name).getBytes());

As we already know parameters are written using key-value pair.
The last step is reading the response, using the InputStream:

[java]InputStream is = con.getInputStream();
byte[] b = new byte[1024];
while ( is.read(b) != -1)
buffer.append(new String(b));
con.disconnect();[/java]

Everything is very simple by now, but we have to remember one thing: when android HTTP client makes an HTTP connection, this operation is a time- consuming operation that could require a long time, sometime so we can’t run it on the main thread otherwise we could get a ANR problem. To solve it we can use an AsyncTask.

[java] private class SendHttpRequestTask extends AsyncTask<String, Void, String>{
@Override
protected String doInBackground(String… params) {
String url = params[0];
String name = params[1];
String data = sendHttpRequest(url, name);
return data;
}

@Override
protected void onPostExecute(String result) {
edtResp.setText(result);
item.setActionView(null);
}
}[/java]

Running the app we get:

android http client post get android_http client post get

As we can see we post a name to the server and it responds with the classic ‘Hello….’. On the server side we can check that the server received correctly our post parameter:

android_tomcat_post_log

Are you looking for other free HTTP libraries for your Android app that can help you developing your app faster? Give a look at Android HTTP libraries.

Download data from server  to Android app

One of the most common scenario when developing Android HTTP client is when an Android App has to download some data from a remote server. We can suppose that we want to download an image from the server. In this case we have always to use an AsyncTask to complete our operation, the code is shown below:

[java]public byte[] downloadImage(String imgName) {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
try {
System.out.println("URL ["+url+"] – Name ["+imgName+"]");

HttpURLConnection con = (HttpURLConnection) ( new URL(url)).openConnection();
con.setRequestMethod("POST");
con.setDoInput(true);
con.setDoOutput(true);
con.connect();
con.getOutputStream().write( ("name=" + imgName).getBytes());

InputStream is = con.getInputStream();
byte[] b = new byte[1024];

while ( is.read(b) != -1)
baos.write(b);

con.disconnect();
}
catch(Throwable t) {
t.printStackTrace();
}

return baos.toByteArray();
}[/java]

This method is called in this way:

[java] private class SendHttpRequestTask extends AsyncTask&amp;amp;amp;amp;amp;lt;String, Void, byte[]&amp;amp;amp;amp;amp;gt; {

@Override
protected byte[] doInBackground(String… params) {
String url = params[0];
String name = params[1];

HttpClient client = new HttpClient(url);
byte[] data = client.downloadImage(name);

return data;
}

@Override
protected void onPostExecute(byte[] result) {
Bitmap img = BitmapFactory.decodeByteArray(result, 0, result.length);
imgView.setImageBitmap(img);
item.setActionView(null);
}
}
[/java]

What HTTP library are you using for your Android app? Check this post about Android HTTP library to know the best one to use.

Running the app we have:

android http client post download

 

Upload data to the server using MultipartRequest

This the most complex part in developing Android HTTP client is handling HTTP connection. Natively HttpURLConnection doesn’t handle this type of request. It can happen that an Android App has to upload some binary data to the server. It can be that an app has to upload an image for example. In this case,the request gets more complex, because a “normal” request isn’t enough. We have to create a MultipartRequest.

A MultipartRequest is a request that is made by different parts as parameters and binary data. How can we handle this request?

Well the first step is opening a connection informing the server we want to send some binary info:

[java] public void connectForMultipart() throws Exception {
con = (HttpURLConnection) ( new URL(url)).openConnection();
con.setRequestMethod("POST");
con.setDoInput(true);
con.setDoOutput(true);
con.setRequestProperty("Connection", "Keep-Alive");
con.setRequestProperty("Content-Type", "multipart/form-data; boundary=" + boundary);
con.connect();
os = con.getOutputStream();
}[/java]

In lines 6 and 7, we specify the request content-type and another field called boundary. This field is a char sequence used to separate different parts.

For each part, we want to add we need to specify if it is text part like post parameter or it is a file (so binary data).

[java] public void addFormPart(String paramName, String value) throws Exception {
writeParamData(paramName, value);
}

private void writeParamData(String paramName, String value) throws Exception {
os.write( (delimiter + boundary + "rn").getBytes());
os.write( "Content-Type: text/plainrn".getBytes());
os.write( ("Content-Disposition: form-data; name="" + paramName + ""rn").getBytes());;
os.write( ("rn" + value + "rn").getBytes());
}[/java]

where

[java]private String delimiter = "–";
private String boundary = "SwA"+Long.toString(System.currentTimeMillis())+"SwA";
[/java]

To add a file part we can use:

[java] public void addFilePart(String paramName, String fileName, byte[] data) throws Exception {
os.write( (delimiter + boundary + "rn").getBytes());
os.write( ("Content-Disposition: form-data; name="" + paramName + ""; filename="" + fileName + ""rn" ).getBytes());
os.write( ("Content-Type: application/octet-streamrn" ).getBytes());
os.write( ("Content-Transfer-Encoding: binaryrn" ).getBytes());
os.write("rn".getBytes());

os.write(data);
os.write("\r\n".getBytes());
}
[/java]

So in our app we have:

[java] private class SendHttpRequestTask extends AsyncTask&amp;amp;amp;amp;amp;lt;String, Void, String&amp;amp;amp;amp;amp;gt; {
@Override
protected String doInBackground(String… params) {
String url = params[0];
String param1 = params[1];
String param2 = params[2];
Bitmap b = BitmapFactory.decodeResource(UploadActivity.this.getResources(), R.drawable.logo);

ByteArrayOutputStream baos = new ByteArrayOutputStream();
b.compress(CompressFormat.PNG, 0, baos);

try {
HttpClient client = new HttpClient(url);
client.connectForMultipart();
client.addFormPart("param1", param1);
client.addFormPart("param2", param2);
client.addFilePart("file", "logo.png", baos.toByteArray());
client.finishMultipart();
String data = client.getResponse();
}
catch(Throwable t) {
t.printStackTrace();
}

return null;
}

@Override
protected void onPostExecute(String data) {
item.setActionView(null);
}

}[/java]

Running it we have:

 

android_tomcat_post_upload_log android http client post upload

 

At the end of this post, you know how to handle HTTP connections using Android and how to send and retrieve data using standard HTTP library shipped with Android.

    1. Rajul Bhatnagar May 19, 2013
    2. simone June 19, 2013
    3. survivingwithandroid June 19, 2013
    4. Rameshbabu Palanisamy July 25, 2013
    5. kaushal September 6, 2013
    6. survivingwithandroid September 6, 2013
    7. kaushal September 7, 2013
    8. Andrea Cani November 5, 2013
    9. survivingwithandroid November 7, 2013
    10. Andrea Cani November 7, 2013
    11. survivingwithandroid December 4, 2013
    12. Fred . February 24, 2014
    13. Fred . February 24, 2014
    14. Arya March 8, 2014
    15. survivingwithandroid March 13, 2014
    16. Audhil April 5, 2014
    17. Ajay Adkar April 11, 2014
    18. Çağrı Çakır April 17, 2014
    19. survivingwithandroid April 17, 2014
    20. Chang June 27, 2014
    21. Guest September 4, 2014
    22. Davide Effe September 4, 2014
    23. Davide Effe September 4, 2014
    24. Davide Effe September 4, 2014
    25. prachi September 13, 2014
    26. SH June 4, 2015
    27. Ashish Kharangate September 13, 2015
    28. sepehr November 26, 2015
    29. domain April 5, 2016
    30. Mor September 14, 2016
    31. Yasser Zantour March 12, 2017
      • Francesco Azzola March 15, 2017
    32. livescore August 30, 2018
    33. Bokserice October 16, 2018
    34. Aditi May 15, 2019

    Add Your Comment