AsyncTask Archives - Truiton

Android Volley vs AsyncTask | Better Approach?

Mohit Gupt — Mon, 16 Feb 2015 19:17:01 +0000

Recently a new framework was introduced for Android in Google I/O called Android Volley. This new framework was introduced to reduce the complexity involved in fetching data over network. Being Android developers we all know that fetching data over network is one of the most common task that one has to perform in any Android app. Therefore this new Android Volley library could be a game changer in Android app development. This library pitches in a lot of new features, but the question here is, do we need all these features? Here in this sum up, we would discuss the features of Android Volley vs AsyncTask.

Whenever some new component or library is released, being a developer, first thoughts that come into my mind are:

Why should I use it in my current code base?
Would it ease my development?
Would it improve my app’s functionally?

In short, the answer to all these questions would be: Maybe. As its not always possible to adapt to something new in your current code base. Unless you are planning to refactor the code completely. Although if you see things from a different perspective, new is always better. Since android volley is just a framework on top of existing android framework. This framework is utilizing the power of android in best possible way. Therefore it may turn out to be very helpful for developers.

Android Volley vs AsyncTask

To start of we will discuss both the approaches individually. First lets begin with AsyncTask as its the older one.

AsyncTask

Usually in android, simply when one need to access a web API, an AsyncTask is used. Its the standard way to do it in android. You may have also observed that AsyncTask is used in many official code samples. Like whenever a new login activity is inserted through the ADT in eclipse, it gives you a stub AsyncTask where you are supposed to write the code for accessing the login API.

The basic code structure used to access data through the AsyncTask is:

public class MyAsyncTask extends AsyncTask {
    @Override
    protected void onPreExecute() {
        //UI Interaction
    }

    @Override
    protected Void doInBackground(Void... params) {
        //Background Task
        return null;
    }

    @Override
    protected void onPostExecute(Void aVoid) {
        //UI Interaction
    }
}

Main methods used to access the data from network by AsyncTask are:

onPreExecute() – Usually used to start the loading bar, as this method can interact with UI thread.
doInBackground(Void... params) – Main method in AsyncTask implementation where all the network access code is written. This method has a limitation that it cannot interact with UI thread.
onPostExecute(Void aVoid) – This is the method where result from doInBackground is passed as an argument. Since this method can interact with UI thread. It is used to update the screen with results.

A point to note here is that, in the implementation of doInBackground, one would have to write code to access network, and use classes like HttpURLConnection etc. Although if you are trying to access a completely custom implementation of web APIs this may serve your purpose better. Using AsyncTask to fetch data from network is not a bad approach at all, its just that you don’t get out of the box features like volley has.

Android Volley

Moving forward with this Android Volley vs AsyncTask sum up, let’s have an overview of Android volley.

As mentioned volley is a framework on top of android framework. It simply utilizes the power of android to access the network in best possible way. One of the many advantages of volley is that, you don’t need to write code for accessing network. All of this is managed by volley itself. Whenever a new network request is created, a background thread is spawned for network processing. Whose life-cycle is maintained by volley itself. In default implementation of volley, at a time 4 network threads can do processing simultaneously. To learn in detail about volley, please have a look at this Android Volley example.

With Volley you also get many more out of the box features like:

Retry Mechanism
Caching
Multiple Request Types
1. JsonObjectRequest
2. JsonArrayRequest
3. StringRequest
4. ImageRequest

Difference between Android Volley and AsyncTask

Like I have been saying new is always better. Using AsyncTask has been a good approach, but consider Android Volley as a 2.0 version of it. It has many improvements over AsyncTask, as volley is designed for the purpose of network access. A major advantage of Android Volley over AsyncTask is that you can do multiple requests simultaneously without the overhead of thread management. Also I believe retry mechanism is a great feature of volley which gives it an edge over AsynTask. Another advantage of volley over AsyncTask is that it provides you with multiple request types, through which complex requests can be made easily. On the other hand while using AsyncTasks one would have to create this type of request manually.

Although best approach differs from application to application. Like if you have less no of requests to make, you can use AsyncTask. As for volley, one has to import a library project which increases your project size. Hence pick wisely between volley and AsyncTask. Hope this Android Volley vs AsyncTask sum up helped you choose. Please like our Facebook and Google+ page for more updates.

Mohit Gupt

Born in New Delhi, India. A software engineer by profession, an android enthusiast and mobile development evangelist. My motive here is to create a group of skilled engineers, who can build better software. Reason being programming is my passion, and also it feels good to make a device do something you want. Professionally I have worked with many software engineering and product development firms. As of now too, I am employed as a senior engineer in a leading tech company. In total I may have worked on more than 20 projects professionally, but whenever I get spare time I share my thoughts here at Truiton.

www.truiton.com

The post Android Volley vs AsyncTask | Better Approach? appeared first on Truiton.

Consuming WCF SVC XML Web Service with Attributes in Android

Mohit Gupt — Fri, 19 Apr 2013 13:59:28 +0000

In today’s ingeniously connected world, no Android app is complete without internet access. Being a mobile app consultant at Truiton, sometimes I feel, I keep doing stuff that no one else has done ever before, for e.g. take topic of this tutorial Consuming WCF SVC XML Web Service with Attributes in Android. I searched internet for hours, hoping to find some info about how to invoke a DotNet based WCF SOAP web service with attributes in XML, but found nothing. Eventually I figured out a way and thought to share it with the community by means of this Consuming WCF SVC XML Web Service with Attributes in Android tutorial.

While searching for ways on how to consume WCF SOAP web service, I found an open source project for Android named Ksoap2. This comes in a form of .jar file which can be included in any Android app project, this is a lightweight and efficient SOAP client library, at least this is what it’s page claims. I found various tutorials explaining on how to consume XML soap web services but none of them explains how to send attributes with input request data. In fact, I looked up the wiki for ksoap2, hoping to find a way to add attributes to request XML, but found nothing. While searching for an answer, I started to think why should I include a third party library for such a small task of consuming a WCF SVC XML web service with attributes in Android. Hence I dropped searching in that direction.

Finally I found another way through which I could invoke a WCF SVC XML web service with attributes in Android, i.e. via HttpClient, HttpPost, HttpResponse, and HttpEntity classes of org.apache.http package. This way we can create a simple http request and send it to the desired url. Now since we are not using Ksoap2 library, there is still a question to be answered i.e. how will we parse the response? Answer to that is simple XML SAX parser, with document builder class. The main advantage of this approach is that we can send and parse attributes in request and response respectively. Lets have a look at my request for Soap xml web service:

Since we are not using any library to consume DotNet WCF soap web service with attributes in request, you need to create this request manually, which is quite simple to do. Have a look at the request above, in this request we are invoking Login method of SVC XML web service on Andorid. Here have a look at the highlighted part, i.e. the CREDENTIALS tag, it has three attributes. One of the main reasons we are using this HttpPost class is because of the attributes.

Lets have a look at the class which is consuming WCF SVC XML web service with attributes in Android:

package com.truiton.wcfconnect;

import java.io.StringReader;
import java.util.HashMap;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;

import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.protocol.HTTP;
import org.apache.http.util.EntityUtils;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.InputSource;

import android.os.AsyncTask;
import android.os.Bundle;
import android.app.Activity;
import android.util.Log;
import android.view.Menu;

public class TruitonMainActivity extends Activity {
 String LOG_TAG = "TruitonMainActivity";
 private UserLoginTask mAuthTask = null;

 @Override
 protected void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);
 setContentView(R.layout.activity_truiton_main);
 mAuthTask = new UserLoginTask();
 mAuthTask.execute((Void) null);
 }

 @Override
 public boolean onCreateOptionsMenu(Menu menu) {
 // Inflate the menu; this adds items to the action bar if it is present.
 getMenuInflater().inflate(R.menu.activity_truiton_main, menu);
 return true;
 }

 void doWhateverYouWant(){
 // TODO: Write here the code which needs to be executed after AsyncTask.
 }

 public class UserLoginTask extends AsyncTask {
 @Override
 protected Boolean doInBackground(Void... params) {
 // TODO: attempt authentication against a network service.

 String SOAP_ACTION = "http://tempuri.org/MyService/Login";
 String URL = getString(R.string.URL);
 //String URL = "http:// *your URL here*";
 String response = null;
 try {
 HttpClient httpClient = new DefaultHttpClient();
 HttpPost httpPost = new HttpPost(URL);
 String bodyOut = ""
 + "   "
 + "   "
 + "      "
 + "         "
 + "         "
 + "            "
 + "            "
 + "         "
 + "      "
 + "   " + "";

 StringEntity se = new StringEntity(bodyOut, HTTP.UTF_8);
 se.setContentType("text/xml");
 httpPost.addHeader("SOAPAction", SOAP_ACTION);
 httpPost.setEntity(se);

 HttpResponse httpResponse = httpClient.execute(httpPost);
 HttpEntity resEntity = httpResponse.getEntity();
 response = EntityUtils.toString(resEntity);
 DocumentBuilderFactory factory = DocumentBuilderFactory
 .newInstance();
 DocumentBuilder builder = factory.newDocumentBuilder();
 StringReader sr = new StringReader(response);
 InputSource is = new InputSource(sr);
 Document XMLResponse = builder.parse(is);
 NodeList elements = XMLResponse.getElementsByTagName("ERRORS");
 Boolean error = Boolean.valueOf(elements.item(0)
 .getAttributes().item(0).getNodeValue());
 HashMap Data = new HashMap();
 if (error) { // case of no error, value of error is returned
 // true in case of no error.
 elements = XMLResponse
 .getElementsByTagName(
 "AUTH_OUTPUT").item(0)
 .getChildNodes();

 for (int index = 0; index < elements.getLength(); index++) {
 String elemName = elements.item(index).getNodeName();
 if (elements.item(index).hasAttributes()) { // if has
 // Attributes
 int attLength = elements.item(index)
 .getAttributes().getLength();
 for (int attIndex = 0; attIndex < attLength; attIndex++) {
 String attName = elements.item(index)
 .getAttributes().item(attIndex)
 .getNodeName();
 String attValue = elements.item(index)
 .getAttributes().item(attIndex)
 .getNodeValue();
 Data.put(elemName + "_" + attName, attValue);
 }
 } else { // in case of no attributes
 Data.put(elemName, elements.item(index)
 .getTextContent());
 }
 }
 elements = XMLResponse.getElementsByTagName("METRO_CITY")
 .item(0).getChildNodes();
 String elemName = "METRO_CITY";
 int childNo = elements.getLength();
 for (int chIndex = 0; chIndex < childNo; chIndex++) {
 Node childNode = elements.item(chIndex);
 String chName = childNode.getNodeName();
 if (childNode.hasAttributes()) { // if has attributes
 int attLength = childNode.getAttributes()
 .getLength();
 for (int attIndex = 0; attIndex < attLength; attIndex++) {
 String attName = childNode.getAttributes()
 .item(attIndex).getNodeName();
 String attValue = childNode.getAttributes()
 .item(attIndex).getNodeValue();
 String val = Data.get(elemName + "_" + chName
 + "_" + attName);
 if (val == null) {
 Data.put(elemName + "_" + chName + "_"
 + attName, attValue);
 } else {
 Data.put(elemName + "_" + chName + "_"
 + attName, val + "," + attValue);
 }
 }
 }
 }
 } else {// In case of error
 String eCode = elements.item(0).getChildNodes().item(0)
 .getAttributes().item(0).getNodeValue();
 String eDesc = elements.item(0).getChildNodes().item(0)
 .getAttributes().item(1).getNodeValue();
 Exception e = new Exception("Server Response: Error Code- "
 + eCode + " -" + eDesc);
 throw e;
 }
 } catch (Exception e) {
 Log.e(LOG_TAG, e.getMessage());
 } finally {
 Log.v(LOG_TAG + " Response", response);
 }
 return true;
 }

 @Override
 protected void onPostExecute(final Boolean success) {
 mAuthTask = null;

 if (success) {
 Log.v(LOG_TAG + " AsyncTask", "Success");
 doWhateverYouWant();
 } else {
 Log.e(LOG_TAG + " AsyncTask", "Fail");
 }
 }

 @Override
 protected void onCancelled() {
 mAuthTask = null;
 }
 }
}

Since the release of Honeycomb we cannot use network on main thread, therefore I used AsyncTask to call the WCF SVC XML web service with attributes on Android. This tutorial can also be treated as a tutorial for AsyncTask.

As you can see the, the code above has SOAP_ACTION and URL variable, specifying the url and soap action for soap xml web service. After all the the variable instantiations we are creating a HttpPost request, which has soap xml attributes. When the request is sent, response is captured in a string type variable response. Then we use DocumentBuilderFactory methods with SAX parser InputSource class to create a xml document which is used to parse xml response with help from org.w3c.dom.node class. The response XML is stored iteratively in a HashMap called Data.

Next we can pass on this data to onPostExecute method and call method in class from it. Just to show the concept of AsyncTask, I have created a method doWhateverYouWant().

Have a look at the login method web service response:


   
      
         
            
               
               TR-UID33
               email@email.com
               Truiton
               0
               
               TR110004
               NYCP0034
               TRI98
               False
               
               
               
               
               USD
               1
               84
               
               
               51
               Truit Online
               NY
               New York
               US
               United States
               19750505
               000-0000-000000
               001-0000000000
               New York
               New York

One more thing don’t forget to add the internet access permission in the manifest, as while consuming WCF SVC XML web service with attributes on Android we will be interacting with internet.

Have a look at the log image:

With this I can conclude my tutorial on consuming WCF SVC XML web service with attributes on Android. Here we sent out a soap request with attributes in tags, which was not looking feasible by use of Ksoap2 library. Therefore we used HttpClient, HttpPost, HttpResponse, and HttpEntity classes of org.apache.http package to create and send the request to WCF SVC XML web service. Next we used DocumentBuilderFactory, DocumentBuilder, StringReader, InputSource, and NodeList classes to parse the data in XML format. Also this approach promotes the use of inbuilt functionality of Android and Java since we did not use any third party library. Hope this tutorial helps you, If it did please +1, like and share on Google+ and Facebook.

Mohit Gupt

www.truiton.com

The post Consuming WCF SVC XML Web Service with Attributes in Android appeared first on Truiton.