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;
 }
}