Saturday, September 29, 2012

Android http/https connection sample code

Http/Https connection is necessary to build a Android application for interact with web server. To make http connection, I made 2 simple java classes.
It is working well and tested on android SDK 15 version and it will probably work the other version as well. I hope it can save your time.

You can call "doPostRequestNgetResponseBody" method or similar in your android Activity class. you can find more method from "HttpClientUtil" class.

String url = "https://yoursite";
ArrayList<BasicNameValuePair> arrayList = new ArrayList<BasicNameValuePair>();
  
arrayList.add(new BasicNameValuePair("your param name", "your param value"));

String responseBody = HttpRequestUtil.doPostRequestNgetResponseBody(context, url, arrayList);


To call the method, you need to have below 2 classes. HttpClientUtil.java : return http/https connection client.
package com.jackapps.http;

import org.apache.http.HttpVersion;
import org.apache.http.client.HttpClient;
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.impl.client.DefaultHttpClient;
import org.apache.http.impl.conn.tsccm.ThreadSafeClientConnManager;
import org.apache.http.params.BasicHttpParams;
import org.apache.http.params.HttpConnectionParams;
import org.apache.http.params.HttpParams;
import org.apache.http.params.HttpProtocolParams;

import android.content.Context;
import android.net.SSLCertificateSocketFactory;
import android.net.SSLSessionCache;

public class HttpClientUtil {

 private static final int CONNECTION_TIMEOUT = 5000;
 private static final int SOCKET_TIMEOUT = 20000;
 

 /**
  * @param context
  * @return
  */
 static HttpClient getHttpClient(Context context) {
  return getHttpClient(context, CONNECTION_TIMEOUT, SOCKET_TIMEOUT);
 }
 
 /**
  * @param context
  * @param connectionTimeOut
  * @param sockeTimeOut
  * @return
  */
 static synchronized HttpClient getHttpClient(Context context, int connectionTimeOut, int sockeTimeOut) {
  
  // Use a session cache for SSL sockets
  SSLSessionCache sessionCache = context == null ? null : new SSLSessionCache(context);

  // sets up parameters
  HttpParams httpParams = new BasicHttpParams();
  
  setHttpProtocolParams(httpParams);
  setHttpConnectionParams(httpParams, connectionTimeOut, sockeTimeOut);
  
  httpParams.setBooleanParameter("http.protocol.expect-continue", false);

  // registers schemes for both http and https
  SchemeRegistry registry = new SchemeRegistry();
  registry.register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));
  
  final SSLSocketFactory sslSocketFactory = SSLCertificateSocketFactory.getHttpSocketFactory(sockeTimeOut,
    sessionCache);

  // sslSocketFactory.setHostnameVerifier(SSLSocketFactory.BROWSER_COMPATIBLE_HOSTNAME_VERIFIER);
  sslSocketFactory.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);

  registry.register(new Scheme("https", sslSocketFactory, 443));

  ThreadSafeClientConnManager manager = new ThreadSafeClientConnManager(httpParams, registry);
  
  return new DefaultHttpClient(manager, httpParams);
 }
 
 /**
  * @param httpParams
  */
 private static void setHttpProtocolParams(HttpParams httpParams){
  HttpProtocolParams.setVersion(httpParams, HttpVersion.HTTP_1_1);
  HttpProtocolParams.setContentCharset(httpParams, "utf-8");
 }
 
 /**
  * @param httpParams
  * @param connectionTimeOut
  * @param sockeTimeOut
  */
 private static void setHttpConnectionParams(HttpParams httpParams, int connectionTimeOut, int sockeTimeOut){
  HttpConnectionParams.setConnectionTimeout(httpParams, connectionTimeOut);
  HttpConnectionParams.setSoTimeout(httpParams, sockeTimeOut);
 }
 
}


HttpRequestUtil.java : return response body, headers
package com.jackapps.http;

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

import org.apache.http.Header;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.ParseException;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpRequestBase;
import org.apache.http.entity.StringEntity;
import org.apache.http.message.BasicHeader;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.protocol.HTTP;
import org.apache.http.util.EntityUtils;
import org.json.JSONObject;
import android.content.Context;

import com.jackapps.model.AccessTokenInfo;

public class HttpRequestUtil {

 /**
  * @param context
  * @param url
  * @param headerList
  * @return
  */
 public static String doGetRequestNgetResponseBody(Context context, String url, List
headerList) { URI uri = null; try { uri = new URI(url); } catch (URISyntaxException e) { e.printStackTrace(); } HttpGet get = new HttpGet(uri); for (Header header : headerList) { get.addHeader(header); } return getResponseBody(context, get); } /** * @param context * @param url * @param headerList * @return */ public static HttpResponse doGetRequestNgetResponse(Context context, String url, List
headerList) { URI uri = null; try { uri = new URI(url); } catch (URISyntaxException e) { e.printStackTrace(); } HttpGet get = new HttpGet(uri); for (Header header : headerList) { get.addHeader(header); } return getResponse(context, get); } /** * @param context * @param url * @param params * @return */ public static String doPostRequestNgetResponseBody(Context context, String url, List params) { HttpPost post = new HttpPost(url); UrlEncodedFormEntity ent = null; try { ent = new UrlEncodedFormEntity(params, HTTP.UTF_8); } catch (UnsupportedEncodingException e) { e.printStackTrace(); } if (ent != null) post.setEntity(ent); return getResponseBody(context, post); } /** * @param context * @param url * @param params * @return */ public static HttpResponse doPostRequestNgetResponse(Context context, String url, List params) { HttpPost post = new HttpPost(url); UrlEncodedFormEntity ent = null; try { ent = new UrlEncodedFormEntity(params, HTTP.UTF_8); } catch (UnsupportedEncodingException e) { e.printStackTrace(); } if (ent != null) post.setEntity(ent); return getResponse(context, post); } /** * @param context * @param url * @param jsonParams * @return */ public static String doPostRequestNgetResponseBody(Context context, String url, JSONObject jsonParams) { HttpPost post = new HttpPost(url); StringEntity ent = null; try { ent = new StringEntity(jsonParams.toString(), HTTP.UTF_8); ent.setContentType("application/json"); } catch (UnsupportedEncodingException e) { e.printStackTrace(); } if (ent != null) post.setEntity(ent); return getResponseBody(context, post); } /** * @param context * @param url * @param jsonParams * @return */ public static HttpResponse doPostRequestNgetResponse(Context context, String url, JSONObject jsonParams) { HttpPost post = new HttpPost(url); StringEntity ent = null; try { ent = new StringEntity(jsonParams.toString(), HTTP.UTF_8); ent.setContentType("application/json"); } catch (UnsupportedEncodingException e) { e.printStackTrace(); } if (ent != null) post.setEntity(ent); return getResponse(context, post); } /** * @param context * @param httpRequest * @return */ private static String getResponseBody(Context context, HttpRequestBase httpRequest) { HttpResponse response = getResponse( context, httpRequest); return getResponseBody(response); } /** * It returns response body string * @param response * @return */ public static String getResponseBody(HttpResponse response) { HttpEntity resEntity = null; if (response != null) resEntity = response.getEntity(); if (resEntity != null) { try { return EntityUtils.toString(resEntity); } catch (ParseException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } } return ""; } /** * @param context * @param url * @param headerList * @return */ public static HashMap doGetRequestNgetResponseHeader(Context context, String url, List
headerList) { URI uri = null; try { uri = new URI(url); } catch (URISyntaxException e) { e.printStackTrace(); } HttpGet get = new HttpGet(uri); for (Header header : headerList) { get.addHeader(header); } return getResponseHeader(context, get); } /** * @param context * @param url * @param params * @return */ public static HashMap doPostRequestNgetResponseHeader(Context context, String url, List params) { HttpPost post = new HttpPost(url); UrlEncodedFormEntity ent = null; try { ent = new UrlEncodedFormEntity(params, HTTP.UTF_8); } catch (UnsupportedEncodingException e) { e.printStackTrace(); } if (ent != null) post.setEntity(ent); return getResponseHeader(context, post); } /** * @param context * @param url * @param jsonParams * @return */ public static HashMap doPostRequestNgetResponseHeader(Context context, String url, JSONObject jsonParams) { HttpPost post = new HttpPost(url); StringEntity ent = null; try { ent = new StringEntity(jsonParams.toString(), HTTP.UTF_8); ent.setContentType("application/json"); } catch (UnsupportedEncodingException e) { e.printStackTrace(); } if (ent != null) post.setEntity(ent); return getResponseHeader(context, post); } /** * @param context * @param httpRequest * @return */ private static HashMap getResponseHeader(Context context, HttpRequestBase httpRequest) { HttpResponse response = getResponse( context, httpRequest); return getResponseHeader(response); } /** * @param response * @param headerName * @return */ public static String getResponseHeaderValue(HttpResponse response, String headerName){ HashMap header = getResponseHeader(response); return (String)header.get(headerName); } /** * @param response * @return */ public static HashMap getResponseHeader(HttpResponse response) { if (response != null){ Header[] headers = response.getAllHeaders(); return converHeaders2Map(headers); }else{ return new HashMap(); } } /** * when response parameter is null, it will return 410 Gone status. * @param response * @return */ public static int getResponseCode(HttpResponse response) { if (response != null){ return response.getStatusLine().getStatusCode(); }else{ return HttpStatus.SC_GONE; } } /** * @param headers * @return */ private static HashMap converHeaders2Map(Header[] headers){ HashMap hashMap = new HashMap(); for(Header header: headers){ hashMap.put(header.getName(), header.getValue()); } return hashMap; } /** * @param context * @param httpRequest * @return */ public static HttpResponse getResponse(Context context, HttpRequestBase httpRequest) { HttpClient httpClient = HttpClientUtil.getHttpClient(context); HttpResponse response = null; try { response = httpClient.execute(httpRequest); } catch (ClientProtocolException e1) { e1.printStackTrace(); } catch (IOException e1) { e1.printStackTrace(); } return response; } }

2 comments: