Problem with Android HTTP POST

Question

I am using the below code to execute a HTTP POST request. The PostData is in the form of a String

Sample of PostData:

urn:marlin:broad band:1-1:registr ation-service:li nkAcquisitionurn: marlin:organizat ion:testpdc:devi ce-maker-x:clien tnemo:aa08a1:59e a7e8cfa7a8582http://docs.oasi s-open.org/wss/2 004/01/oasis-200 401-wss-wssecuri ty-utility-1.0.x sd" URI="urn:mar lin:core:1.0:nem o:protocol:profi le:1" wsu:Id="si gid0003" nemosec :Usage="http://n emo.intertrust.c om/2005/10/secur ity/profile"/>< /SOAP-ENV:Envelo pe>

We are expecting a xml/soap response, instead we are getting an xml file as the response. Can anyone tell me if the procedure to do an HTTP POST is correct (as in the below code)

Note: The same postData when used with cuRL for performing a POST is working fine.

public byte [] sendRecv(String PostData, long postDataSize){

  try{
   if(!(PostData.equals("empty"))){
    isPost = true;
    //InputStream postDataInputStream = new ByteArrayInputStream(postData);
    //BasicHttpEntity httpPostEntity = new BasicHttpEntity();
    //httpPostEntity.setContent(postDataInputStream);
    StringEntity httpPostEntity = new StringEntity(PostData, HTTP.UTF_8);
    //httpPostEntity.setContentLength(postData.length);
    //httpPostEntity.setContentType("application/x-www-form-urlencoded");
    httpPost.setEntity(httpPostEntity);
    httpPost.setHeader("Content-Length", new Integer(PostData.length()).toString());
    httpPost.setHeader("Content-Type", "application/x-www-form-urlencoded");
    httpPost.setHeader("Expect", "100-continue");

   }
  }catch(Exception e) {
   e.printStackTrace();
  }

  try {
   if(isPost == true){
    response = mAndroidHttpClient.execute(httpPost);
    isPost = false;
   }
   else {
    response = mAndroidHttpClient.execute(httpGet);
   }
   statusCode = response.getStatusLine().getStatusCode();

   if(statusCode != 200 ){
    if(statusCode == 404) {
     //System.out.println("error in http connection : 404");

     //return ERR_HTTP_NOTFOUND 
    } else if(statusCode == 500){
     //System.out.println("error in http connection : 500");
     //return ERR_HTTP_INTERNALSEVERERROR
    } else {
     //System.out.println("error in http connection : error unknown");
     //return ERR_HTTP_FATAL
    }
   }

   HttpEntity entity = response.getEntity();
   InputStream is = entity.getContent();

   ByteArrayOutputStream bos = new ByteArrayOutputStream();
   for (int next = is.read(); next != ENDOFSTREAM; next = is.read()) {
    bos.write(next);
   }
   responseBuffer = bos.toByteArray();
   bos.flush();
   bos.close();

   }catch (IOException e) {
    e.printStackTrace();
    }

   return responseBuffer;
 }  

Answer 1

//Creating xml file

          DocumentBuilderFactory dbfac = DocumentBuilderFactory.newInstance();
         dbfac.setNamespaceAware(true);
         DocumentBuilder docBuilder = null;
         try {
            docBuilder = dbfac.newDocumentBuilder();
        } catch (ParserConfigurationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
         DOMImplementation domImpl = docBuilder.getDOMImplementation();
         Document doc = domImpl.createDocument("http://coggl.com/InsertTrack","TrackEntry", null);
         doc.setXmlVersion("1.0");
         doc.setXmlStandalone(true);

         Element trackElement = doc.getDocumentElement();

         Element CompanyId = doc.createElement("CompanyId");
         CompanyId.appendChild(doc.createTextNode("1"));
         trackElement.appendChild(CompanyId);

         Element CreatedBy = doc.createElement("CreatedBy");
         CreatedBy.appendChild(doc.createTextNode("6"));
         trackElement.appendChild(CreatedBy);

         Element DepartmentId = doc.createElement("DepartmentId");
         DepartmentId.appendChild(doc.createTextNode("4"));
         trackElement.appendChild(DepartmentId);

         Element IsBillable = doc.createElement("IsBillable");
         IsBillable.appendChild(doc.createTextNode("1"));
         trackElement.appendChild(IsBillable);

         Element ProjectId = doc.createElement("ProjectId");
         ProjectId.appendChild(doc.createTextNode("1"));
         trackElement.appendChild(ProjectId);

         Element StartTime = doc.createElement("StartTime");
         StartTime.appendChild(doc.createTextNode("2012-03-14 10:44:45"));
         trackElement.appendChild(StartTime);

         Element StopTime = doc.createElement("StopTime");
         StopTime.appendChild(doc.createTextNode("2012-03-14 11:44:45"));
         trackElement.appendChild(StopTime);

         Element TaskId = doc.createElement("TaskId");
         TaskId.appendChild(doc.createTextNode("3"));
         trackElement.appendChild(TaskId);

         Element TotalTime = doc.createElement("TotalTime");
         TotalTime.appendChild(doc.createTextNode("1"));
         trackElement.appendChild(TotalTime);

         Element TrackDesc = doc.createElement("TrackDesc");
         TrackDesc.appendChild(doc.createTextNode("dello testing"));
         trackElement.appendChild(TrackDesc);

         Element TrackId = doc.createElement("TrackId");
         TrackId.appendChild(doc.createTextNode("0"));
         trackElement.appendChild(TrackId);

         TransformerFactory transfac = TransformerFactory.newInstance();
         Transformer trans = null;
        try {
            trans = transfac.newTransformer();
        } catch (TransformerConfigurationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
         trans.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "yes");
         trans.setOutputProperty(OutputKeys.INDENT, "yes");

         //create string from xml tree
         StringWriter sw = new StringWriter();
         StreamResult result = new StreamResult(sw);
         DOMSource source = new DOMSource(doc);
         try {
            trans.transform(source, result);
        } catch (TransformerException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
         String xmlString = sw.toString();

//posting xml file to server

         DefaultHttpClient httpClient = new DefaultHttpClient();

         HttpPost httppost = new HttpPost("http://192.168.0.19:3334/cogglrestservice.svc/InsertTrack");     
         // Make sure the server knows what kind of a response we will accept
         httppost.addHeader("Accept", "text/xml");
         // Also be sure to tell the server what kind of content we are sending
         httppost.addHeader("Content-Type", "application/xml");

         try
         {
         StringEntity entity = new StringEntity(xmlString, "UTF-8");
         entity.setContentType("application/xml");
         httppost.setEntity(entity);

         // execute is a blocking call, it's best to call this code in a thread separate from the ui's
         HttpResponse response = httpClient.execute(httppost);

         BasicResponseHandler responseHandler = new BasicResponseHandler();
            String strResponse = null;
            if (response != null) {
                try {
                    strResponse = responseHandler.handleResponse(response);
                } catch (HttpResponseException e) {
                    e.printStackTrace();  
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            Log.e("WCFTEST", "WCFTEST ********** Response" + strResponse);    


         }
         catch (Exception ex)
         {
         ex.printStackTrace();
         }
         Toast.makeText(EditTask.this, "Xml posted succesfully.",Toast.LENGTH_SHORT).show(); 

Answer 2

Here is my implementation and it works for post and get. You can compare the setup with yours.

/**
 * Allows you to easily make URL requests
 * 
 * 
 * @author Jack Matthews
 * 
 */
class HttpUrlRequest extends Thread {

    private static final String TAG = "HttpUrlRequest";
    private static final HttpClient httpClient;



    static {
        HttpParams params = new BasicHttpParams();
        HttpProtocolParams.setVersion(params, HttpVersion.HTTP_1_1);
        HttpProtocolParams.setContentCharset(params, HTTP.UTF_8);
        HttpProtocolParams.setUseExpectContinue(params, false);  
        HttpConnectionParams.setConnectionTimeout(params, 10000);
        HttpConnectionParams.setSoTimeout(params, 10000);
        ConnManagerParams.setMaxTotalConnections(params, 100);
        ConnManagerParams.setTimeout(params, 30000);

        SchemeRegistry registry = new SchemeRegistry();
        registry.register(new Scheme("http",PlainSocketFactory.getSocketFactory(), 80));
        registry.register(new Scheme("https",PlainSocketFactory.getSocketFactory(), 80));
        ThreadSafeClientConnManager manager = new ThreadSafeClientConnManager(params, registry);
        httpClient = new DefaultHttpClient(manager, params);
        //httpClient.getParams().setParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, 30000);
    }


    //user supplied variables
    private String host = null;
    private int port = 80;
    private String path = null;
    private List<NameValuePair> query = null;
    private List<NameValuePair> post = null;
    private Handler handler = null;
    private HttpResponseWrapper callbackWrapper = null;
    private String scheme = "http";


    /**
     * Used to setup a request to a url
     * 
     * @param host
     * @param port
     * @param path
     * @param query
     * @param post
     * @param handler
     * @param callbackWrapper
     */
    private HttpUrlRequest(String scheme, String host, int port, String path, List<NameValuePair> query,  List<NameValuePair> post, Handler handler, HttpResponseWrapper callbackWrapper) {
        this.scheme = scheme;
        this.host = host;
        this.port = port;
        this.path = path;
        this.query = query;
        this.post = post;
        this.handler = handler;
        this.callbackWrapper = callbackWrapper;
    }




    /**
     * Use this class if your class is implementing HttpResponseListener.
     * Creates the request inside it's own Thread automatically.
     * <b>run() is called automatically</b>
     * 
     * @param host
     * @param port
     * @param path
     * @param queryString
     * @param postData
     * @param requestCode
     * @param callback
     * 
     * @see HttpResponseListener
     */
    public static void sendRequest(String scheme, String host, int port, String path, List<NameValuePair> queryString, List<NameValuePair> postData, int requestCode, HttpResponseListener callback) {
        (new HttpUrlRequest(scheme, host, port, path, queryString, postData, new Handler(),new HttpResponseWrapper(callback,requestCode))).start();
    }


    /**
     * Use this method if you want to control the Threading yourself.
     * 
     * @param host
     * @param port
     * @param path
     * @param queryString
     * @param postData
     * @return
     */
    public static HttpResponse sendRequestForImmediateResponse(String scheme,String host, int port, String path, List<NameValuePair> queryString, List<NameValuePair> postData) {
        HttpUrlRequest req = new HttpUrlRequest(scheme, host, port, path, queryString, postData, null, null);
        return req.runInCurrentThread();
    }



    /**
     * Runs the request in the current Thread, use this if you
     * want to mananage Threading yourself through a thread pool etc.
     * 
     * @return HttpResponse
     */
    private HttpResponse runInCurrentThread() {
        if(post==null) {
            return simpleGetRequest();
        } else {
            return simplePostRequest();
        }
    }




    @Override
    public void run() {
        //Determine the appropriate method to use
        if(post==null) {
            callbackWrapper.setResponse(simpleGetRequest());
            handler.post(callbackWrapper);
        } else {
            callbackWrapper.setResponse(simplePostRequest());
            handler.post(callbackWrapper);
        }
    }





    /**
     * Send a GET request
     * 
     * @return HttpResponse or null if an exception occurred
     * 
     */
    private HttpResponse simpleGetRequest() {
        try {
            //Add lang to query string
            query.add(new BasicNameValuePair("lang", getLanguageInJoomlaFormat()));
            URI uri = URIUtils.createURI(scheme, host, port, path, URLEncodedUtils.format(query, HTTP.UTF_8), null);

            if(Logging.DEBUG) Log.d(TAG, uri.toString());

            //GET method
            HttpGet method = new HttpGet(uri);
            HttpResponse response = httpClient.execute(method);
            //HttpEntity entity = response.getEntity();

            if(response==null)
                return NullHttpResponse.INSTANCE;
            else
                return response;

        } catch (ClientProtocolException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (URISyntaxException e) {
            e.printStackTrace();
        }

        return NullHttpResponse.INSTANCE;
    }





    /**
     * Send a POST request
     * 
     * 
     * @return HttpResponse or null if an exception occurred
     * 
     */
    private HttpResponse simplePostRequest() {
        try {
            //Add lang to query string
            query.add(new BasicNameValuePair("lang", getLanguageInJoomlaFormat() ));

            URI uri = URIUtils.createURI(scheme, host, port, path, URLEncodedUtils.format(query, HTTP.UTF_8), null);

            if(Logging.DEBUG) Log.d(TAG, uri.toString());

            //POST method
            HttpPost postMethod=new HttpPost(uri);      
            postMethod.setEntity(new UrlEncodedFormEntity(post, HTTP.UTF_8));
            HttpResponse response = httpClient.execute(postMethod);
            //HttpEntity entity = response.getEntity();

            if(response==null)
                return NullHttpResponse.INSTANCE;
            else
                return response;

        } catch (UnsupportedEncodingException e) {
            if(Logging.ERROR) Log.e(TAG, "UnsupportedEncodingException", e);
        } catch (ClientProtocolException e) {
            if(Logging.ERROR) Log.e(TAG, "UnsupportedEncodingException", e);
        } catch (IOException e) {
            if(Logging.ERROR) Log.e(TAG, "UnsupportedEncodingException", e);
        } catch (URISyntaxException e) {
            if(Logging.ERROR) Log.e(TAG, "UnsupportedEncodingException", e);
        }

        return NullHttpResponse.INSTANCE;
    }




    /**
     * Converts the language code to correct Joomla format
     * 
     * @return language in the (en-GB)
     */
    public static String getLanguageInJoomlaFormat() {
        String joomlaName;
        String[] tokens = Locale.getDefault().toString().split("_");
        if (tokens.length >= 2 && tokens[1].length() == 2) {
            joomlaName = tokens[0]+"-"+tokens[1];
        } else {
            joomlaName = tokens[0]+"-"+tokens[0].toUpperCase();
        }
        return joomlaName;
    }





    /**
     * Creates a null http response
     * 
     * @author Jack Matthews
     *
     */
    private enum NullHttpResponse implements HttpResponse {
        INSTANCE;

        @Override
        public HttpEntity getEntity() {
            return null;
        }

        @Override
        public Locale getLocale() {
            return null;
        }

        @Override
        public StatusLine getStatusLine() {
            return null;
        }

        @Override
        public void setEntity(HttpEntity entity) {

        }

        @Override
        public void setLocale(Locale loc) {

        }

        @Override
        public void setReasonPhrase(String reason) throws IllegalStateException {

        }

        @Override
        public void setStatusCode(int code) throws IllegalStateException {

        }

        @Override
        public void setStatusLine(StatusLine statusline) {

        }

        @Override
        public void setStatusLine(ProtocolVersion ver, int code) {

        }

        @Override
        public void setStatusLine(ProtocolVersion ver, int code, String reason) {

        }

        @Override
        public void addHeader(Header header) {

        }

        @Override
        public void addHeader(String name, String value) {

        }

        @Override
        public boolean containsHeader(String name) {
            return false;
        }

        @Override
        public Header[] getAllHeaders() {
            return null;
        }

        @Override
        public Header getFirstHeader(String name) {
            return null;
        }

        @Override
        public Header[] getHeaders(String name) {
            return null;
        }

        @Override
        public Header getLastHeader(String name) {
            return null;
        }

        @Override
        public HttpParams getParams() {
            return null;
        }

        @Override
        public ProtocolVersion getProtocolVersion() {
            return null;
        }

        @Override
        public HeaderIterator headerIterator() {
            return null;
        }

        @Override
        public HeaderIterator headerIterator(String name) {
            return null;
        }

        @Override
        public void removeHeader(Header header) {

        }

        @Override
        public void removeHeaders(String name) {

        }

        @Override
        public void setHeader(Header header) {

        }

        @Override
        public void setHeader(String name, String value) {

        }

        @Override
        public void setHeaders(Header[] headers) {

        }

        @Override
        public void setParams(HttpParams params) {

        }
    }

}