Implementation of a state machine for a long running background task in Android

In the below example I will show how we can break a long-running background task running in a service into different states of a state machine and notify the front end UI about each and every stage as they occur in the service. Here I have used a service called LongRunningService which actually (theoretically) does the task of downloading a big file from a network server (however, for simplicity I have just stubbed out the actual download code with a thread having a delay of 1000 ms). This background task has been split into different states according to the state machine like “Start Connection”, “Connection Completed”, “Start Downloading” and “Stop Downloading”. This application also showcases the concept of communicating with a background service to the frontend UI through Android messenger framework.

So let's start digging into the source code of the application.

First of all the main Activity class. 

As it is clear from the code that the main activity has a messenger whose message handling part has been defined by a class called MessageHandler (derived from Handler). This is the messenger object through which the background service notifies the UI thread.

The UI has a button. Upon clicking it, it starts the service and as soon as it starts the service the service starts notifying about the different states of the Service through the messenger.

This is pretty simple. Right!!!

The class MainActivity.Java

package com.somitsolutions.android.example.statepatterninservice;

import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.os.Messenger;
import android.view.Menu;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.Toast;

public class MainActivity extends Activity implements OnClickListener{
private static final int CONNECTING = 1;
private static final int CONNECTED = 2;
private static final int DOWNLOADSTARTED = 3;
private static final int DOWNLOADFINISHED = 4;

Button startButton;
private MessageHandler handler;
private static MainActivity mMainActivity;

public Messenger mMessenger = new Messenger(new MessageHandler(this));
private class MessageHandler extends Handler{
private Context c;

MessageHandler(Context c){
this.c = c;
}
@Override
       public void handleMessage(Message msg) {
switch(msg.what){
case CONNECTING:
Toast.makeText(getApplicationContext(), "Connecting", Toast.LENGTH_LONG).show();
break;
case CONNECTED:
Toast.makeText(getApplicationContext(), "Connected", Toast.LENGTH_LONG).show();
break;
case DOWNLOADSTARTED:
Toast.makeText(getApplicationContext(), "Download Started", Toast.LENGTH_LONG).show();
break;
case DOWNLOADFINISHED:
Toast.makeText(getApplicationContext(), "Download Finished", Toast.LENGTH_LONG).show();
break;
default:
super.handleMessage(msg);

}
}
}
   @Override
   protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.activity_main);
       mMainActivity = this;
       startButton = (Button)findViewById(R.id.button1);
       
       startButton.setOnClickListener(this);
   }


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


@Override
public void onClick(View arg0) {
// TODO Auto-generated method stub
Intent serv = new Intent(MainActivity.this, LongRunningService.class);
       startService(serv);
}
}

Now, let's start digging the LongrunningServivce class.

As we know that a service usually runs in the main thread. Hence the UI thread may seem to be frozen in case of a long background service. To overcome that a background thread is being created the moment one starts the service and the task is executed in that thread. This is clear from the following piece of code.

@Override
 public void onCreate() {
   // Start up the thread running the service.  Note that we create a
   // separate thread because the service normally runs in the process's
   // main thread, which we don't want to block.  We also make it