How to manage multiple Async Tasks efficiently in Android

Question

I have scenario where I will have to make six http calls to my server to get the data for six different items. These server calls cant be combined and they are meant to be that way. Eg: If you need quote info for GOOGLE then send a request to server requesting for google's quote info. Next if you need yahoo's then you initiate another http call and so on.

Here is the situation:

1. Now my end user wants to compare 6 different companies.
2. As I mentioned its un-avoidable for me to make 6 http calls for which I do using 6 Async Tasks.
3. As I get each one of the Async task response I will refresh the UI with new data.
4. Its a bad UI experience if I refresh the UI 6 times in a very short period of time.
5. Its give a flickering effect to my UI which is not desired.

My Question:

1. How can I hold-off from refreshing the UI until I get all the 6 Async Task responses?
2. I understand each task is independent of each other. Should I run a while loop and wait until I get all the responses?
3. Is there a better way to do this rather than a while loop because if any one of the call doesn't respond then I will stuck waiting forever.

Note: I guess Android 1.6+ do execute Async tasks in parallel.

This is more of a design question and I would appreciate any help on this.

Thanks in advance

Answer 1

You could make a AsyncTask pool object that allows you to spoof a 'batch' http call.

1. create an Observable collection of AsyncTasks, i'll refer to this collection as your Pool
2. your Activity creates the AsyncTasks (but not execute yet) and adds them to the Pool
3. Activity registers itself as an observer of the Pool
4. Activity tells Pool to execute, Pool in turn calls execute on each of its Tasks
5. When tasks complete (for both success and fail), they store the response data in the Pool, and the Pool marks the Task as being 'complete'
6. Once all Tasks are marked as complete, Pool notifies the listening Activity

General idea is for the Pool to know how many Tasks and pending, and to store the aggregate data of completed calls. Once all are finished, notify the observing Activity and pass back all the data.

You'll have to work out how the AsyncTasks tell the Pool that they are finished. Maybe simply have an implementation of AsyncTask that takes a Pool on its constructor so that the Tasks have a reference to the Pool.