Good design patterns for coding many HTTP requests in Android

Question

In my app, i have lots of GET,POST, PUT requests. Right now, i have a singleton class that holds my downloaded data and has many inner classes that extend AsyncTask. In my singleton class, i have also a few interfaces like this:

/**
* Handlers for notifying listeners when data is downloaded
* 
*/
public interface OnQuestionsLoadedListener {

    public void onDataLoadComplete();

    public void onDataLoadingError();       
}

Is there something wrong with this pattern (many inner classes that extend AsyncTask)? Could it be done more efficiently with maybe just 1 inner class for every HTTP call (1 for GET, 1 for POST, ...)? If so, how to decide what to do after e.g. GET request?

Answer 1

As a whole, you should get away from AsyncTasks while preforming network requests.

Your AsyncTasks are linked to your Activity. That means, if your Activity stops, your AsyncTask stops. This isn't the biggest problem when fetching data to show in that Activity, since you won't care that the fetching has stopped. But when you want to send some saved data to the server, and your user pressed 'back' or something like that before everything is sent, the data could be lost and not send.

What you want to have instead, is a Service which will keep running regardless of what happens to your Activities.

I'd advise you to take a look into RoboSpice. Even if you decide not to use it, reading what it does and why it does will give you a good insight on the pretty long list of reasons not to use AsyncTasks for network requests and why better to use Services. If you use this, the rest of your question about efficiently network requesting is obsolete too, since they'll handle it for you the best way possible.