AsyncTask makes Threading fun

Threading can be a hard issue for developers and whenever you have to implement some threading yourself it’s always a hard job and the code you produce will never look great! So if we can avoid to implement Runnable and all the stuff we probably will. However I implemented some threading myself in an Android application and it didn’t look nice at all!

Threading in an Android application? Indeed, and here’s why. In Android if you want to show a loading dialog while you are loading some data from let’s say a web service (which can take some time to finish as you are not entirely sure what kind of internet connection is available on the device) you have to start using threading. The reason why you have to use threading for it is because the loading dialog needs to be updated all the time (with a percentage, some graphical circle that goes around etc) and at the exact same time you want to get your data from your service.So here is how I originally implemented it in the MyEpisodes Manager project:

public class EpisodesWatchListActivity extends Activity {
        private Runnable viewEpisodes;

        @Override
        public void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.watchlist);
            //Do some other stuff on creation
            reloadEpisodes();
            //Do some other stuff on creation
        }

        private void reloadEpisodes() {
		showDialog(EPISODE_LOADING_DIALOG);
		viewEpisodes = new Runnable() {
			@Override
			public void run() {
				getEpisodes();
			}
		};

		Thread thread =  new Thread(null, viewEpisodes, "EpisodeRetrievalBackground");
		thread.start();
        }

	private void getEpisodes() {
		try {
			episodes = myEpisodesService.retrieveEpisodes(episodesType, user);
		} catch (InternetConnectivityException e) {
			String message = "Could not connect to host";
			Log.e(LOG_TAG, message, e);
			exceptionMessageResId = R.string.internetConnectionFailureReload;
		} catch(FeedUrlParsingException e) {
			String message = "Exception occured:";
			Log.e(LOG_TAG, message, e);
			exceptionMessageResId = R.string.watchListUnableToReadFeed;
		} catch (Exception e) {
			String message = "Exception occured:";
			Log.e(LOG_TAG, message, e);
			exceptionMessageResId = R.string.defaultExceptionMessage;
		}
		runOnUiThread(returnEpisodes);
	}

	private Runnable returnEpisodes = new Runnable() {
            //Update the view (input fields, lists,...)
            dismissDialog(EPISODE_LOADING_DIALOG);
        }
}

A little explanation of what will happen and why:

• On creation of the activity the method to (re)load the data is called.
• Next the dialog is started on the current thread (which is also known as the UI-thread).
• Now we’ll create a Thread in which the actual data will be retrieved, to make things a bit more understandable we created a separate method for purpose.
• After the data is loaded in the application we still have two things left to do, first of all the view must be updated with the new data loaded, next the loading dialog should be hidden. And here happens a little magic.  In your entire application there will be only one thread which you can use to update the view, this thread we call the UI-thread. Therefore we can use the runOnUiThread(Runnable runnable) method available in the Activity super class.
• In this runnable-instance we should first update the view and when it’s all done we should dismiss the dialog (or in other words just close the dialog)

Now because this looks like one big mess Android came up with a simple solution, called AsyncTasks. I’ve re-written the previous example to fit in with the AsyncTasks and suddenly it looks a lot more clean. See the example here:

public class EpisodesWatchListActivity extends Activity {
        @Override
        public void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.watchlist);
            //Do some other stuff on creation
            reloadEpisodes();
            //Do some other stuff on creation
        }

        private void reloadEpisodes() {
            AsyncTask asyncTask = new AsyncTask() {
                @Override
                protected void onPreExecute() {
                    showDialog(EPISODE_LOADING_DIALOG);
                }

                @Override
                protected Object doInBackground(Object... objects) {
                    getEpisodes();
                    return 100L; //In my case I do not need a return value so I return some default value!
                }

                @Override
                protected void onPostExecute(Object o) {
                    updateView();
                    dismissDialog(EPISODE_LOADING_DIALOG);
                }
            };
            asyncTask.execute();
        }

	private void getEpisodes() {
		try {
			episodes = myEpisodesService.retrieveEpisodes(episodesType, user);
		} catch (InternetConnectivityException e) {
			String message = "Could not connect to host";
			Log.e(LOG_TAG, message, e);
			exceptionMessageResId = R.string.internetConnectionFailureReload;
		} catch(FeedUrlParsingException e) {
			String message = "Exception occured:";
			Log.e(LOG_TAG, message, e);
			exceptionMessageResId = R.string.watchListUnableToReadFeed;
		} catch (Exception e) {
			String message = "Exception occured:";
			Log.e(LOG_TAG, message, e);
			exceptionMessageResId = R.string.defaultExceptionMessage;
		}
	}

	private void updateView() {
            //Update the view (input fields, lists,...)
        }
}

I hope you notice that this code is a lot more easier to read than the previous. What it does:

• First of all a new AsyncTask gets instantiated and implemented.
• The method doInBackground(Object… objects) is the only that must be implemented. So the name already tells you that this is the method that will start a new thread and execute some stuff you define in that thread. In our case the data gets loaded from a web service.
• Next we also have to implement the onPreExecute() method in order to be able to start the loading dialog.
• And off course the onPostExecute(Object e) method which will hide the loading dialog when the data is loaded.
• As you see the runOnUiThread(Runnable runnable) has been removed from the getEpisodes() method but everything done in this method has been moved the onPostExecute(Object e) method as this last mentioned method will not run in a seperate thread but on the UI-thread itself!

I also created a sample Android project called ‘LoadingDialogsAndThreading’ which you can find it on Google Code in the my-android-samples project.
It’s easy, not a lot of work to change your code and it makes it lot more readable for other developers. So definitely something to look into!