Start IntentService from Activity and refresh Activity when IntentService is finished

Question

In my Android application, I have a simple list view with adapter. There's a heavy query which is to fill the list view with data. So I put it to an IntentService that runs in another thread.

The IntentService is normally running separately, on its own, just to query some data and insert it into the SQLite database.

But now I would like to have the following possibility:

1. The activity starts the IntentService with startService().
2. The IntentService does its heavy work.
3. When the IntentService is finished, it should inform the activity about the result so that the activity can be refreshed to show the new data.

Is this possible? I read a lot of questions here on Stack Overflow on this topic. But in every question, there was another solution. So I want to ask you all: Which solution is the best for my purpose?

• Binding the IntentService to the Activity does not seem to be the best solution as there might be conflicts with configuration changes of the activity etc. Correct?
• This blog post suggests using AIDL with Parcelables - which sounds very complex to me. There is an easier way, isn't it?
• One could set up a broadcast receiver in the activity and fire this broadcast in the IntentService when it is finished.
• Some people say you should use createPendingResult() to pass a PendingIntent to the IntentService. If the IntentService finds that PendingIntent in its extras, it uses this to trigger off onActivityResult() in the Activity. Is this the way to choose?

Solution 1

As an example, I use a ResultReceiver to call notifyDataSetChanged() on the adapter of my Activity (which extends ListActivity). It can be adapted to do whatever you need.

ResultReceiver code:

public class MyResultReceiver extends ResultReceiver {

    private Context context = null;

    protected void setParentContext (Context context) {
        this.context = context;
    }

    public MyResultReceiver(Handler handler) {
        super(handler);
    }

    @Override
    protected void onReceiveResult (int resultCode, Bundle resultData) {

        // Code to process resultData here

        ((BaseAdapter) ((ListActivity)context).getListAdapter()).notifyDataSetChanged();
    }
}

MyActivity code:

public class MyActivity extends ListActivity {

    private MyResultReceiver theReceiver = null;

    ...

    private void callService () {
        theReceiver = new MyResultReceiver(new Handler());
        theReceiver.setParentContext(this);
        Intent i = new Intent("com.mycompany.ACTION_DO_SOMETHING");

        // Code to define and initialize myData here

        i.putExtra("someData", myData);
        i.putExtra("resReceiver", theReceiver);
        startService(i);

    }
}

IntentService code:

Bundle resultBundle = new Bundle();
ResultReceiver resRec = intent.getParcelableExtra("resReceiver");

// Do some work then put some stuff in resultBundle here

resRec.send(12345, resultBundle);

Solution 2

When the IntentService completes, it should use LocalBroadcastManager to send an intent to any registered activity.

The IntentService will contain code like this:

private void sendBroadcast() {
    Intent intent = new Intent("myBroadcastIntent");
    intent.putExtra("someName", someValue);
    LocalBroadcastManager.getInstance(this).sendBroadcast(intent);
}

The activity receiving the notification will contain code like this:

@Override
protected void onCreate(Bundle savedInstanceState) {
    // ...
    BroadcastReceiver receiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            String someValue = intent.getStringExtra("someName");
            // ... do something ...
        }
    };
    LocalBroadcastManager.getInstance(this)
        .registerReceiver(receiver, new IntentFilter("myBroadcastIntent"));
}

For more depth, see the blog post Using LocalBroadcastManager In Service To Activity Communications.

Solution 3

None of the other answers references the official android documentation

https://developer.android.com/training/run-background-service/report-status.html

that states clearly that for the Activity-IntentService communication "The recommended way to send and receive status is to use a LocalBroadcastManager, which limits broadcast Intent objects to components in your own app"!

Solution 4

I would suggest using a Broadcast Receiver in the The Activity waiting for the result. Your Service would just use sendBroadcast with a custom Intent.

Solution 5

I think the event bus is the way to go. Simple and effective interprocess communication.

• http://square.github.io/otto/
• https://github.com/greenrobot/EventBus

View more solutions