如何为Android AsyncTask类建模？

Question

I have decided to learn Scala / Play (Server side) and decided to learn Android (Client) game development at the same time to spice up the development.
I have a question regarding how to do a nice design for HTTP Request in Android.
From what I have understood the best way is to delegate the HTTP Request to an class extending the abstract AsyncTask class.
Do you have to do a new extension of the AsyncTask for each different logic in the doInBackground method you override?
For me it doesn't fell natural to have a class for each request logic but rather encapsulate several coherent methods in one class.

I have just started to play a little but I'm not satisfied with the design as I don't like my design of an varargs Object in doInBackground(Object... params) .
With this design I loose the type safety and the params object is far from intuitive and intuitive is something I strive for in my code.

Here is the code which I want to improve on.

public class GameActivity extends Activity {

    private class MyCellListener implements ICellListener {
        public void onCellSelected() {
            ServerProxy.postSelectedCell(row, col, player.getUser());    
            ...
            // ServerProxy.other();

public class ServerProxy extends AsyncTask<Object, Void, Void>{

    private static final String TAG = ServerProxy.class.getSimpleName();
    private static final String SERVER_ADDRESS = "http://127.0.0.1";

    // Prevent external instantiation
    private ServerProxy(){};

    public static void postSelectedCell(int row, int cell, User user){
         List<NameValuePair> postParameters = new ArrayList<NameValuePair>(3);
         postParameters.add(new BasicNameValuePair("row", String.valueOf(row)));
         postParameters.add(new BasicNameValuePair("cell", String.valueOf(cell)));
         postParameters.add(new BasicNameValuePair("userName", user.getUserName()));
         new ServerProxy().doInBackground("setSelectedCell" , postParameters);
    }

//    public static void postOther() {
//      new ServerProxy().doInBackground("other" , //some parameters); 
//    }

    /**
     * @param postParameters First object URL postfix<br/>
     * Second parameter is post parameters inform of {@code List<NameValuePair>}
     * @return null
     */
    @SuppressWarnings("unchecked")
    @Override
    protected Void doInBackground(Object... params) {

        HttpClient httpclient = new DefaultHttpClient();
        HttpPost httppost = new HttpPost(SERVER_ADDRESS +"/" + params[0]);
        httppost.getParams().setBooleanParameter(CoreProtocolPNames.USE_EXPECT_CONTINUE, false);

        try {
            httppost.setEntity(new UrlEncodedFormEntity((List<NameValuePair>) params[1]));
            httpclient.execute(httppost);
        } catch (ClientProtocolException e) {
         Log.e(TAG,e.toString());
        } catch (IOException e) {
         Log.e(TAG,e.toString());
        }
        return null;
    }
}

Answer 1

I think you don't understand what AsyncTask does. You can't define methods like postLastName, postFirstName, postWhatever on a single AsyncTask subclass and have it execute that method call off the UI thread. AsyncTask is meant to make it easier to do background jobs that need to update the UI without forcing you to handling threading directly.

In order to communicate with the server you're using HttpClient, and the call HttpClient.execute() will block until the server's response comes back. That could take a long time, especially if the server is busy, dies, or the cell radio goes down. When that call takes too long you don't want your UI to stop responding to the user. You want to show a spinner spinning to let the user know something is happening. If you used the code you provided YOUR UI WOULD CEASE TO PAINT UNTIL THE HttpClient.execute() call returned because you're calling it on the UI thread.

The work around to this problem is move this call OFF the UI Thread onto another Thread. Let that thread wait for a response, then have it notify the UI thread it's done and use the UI thread to update the UI with the new data. Why can't you let that background thread update the UI? Because that would violate Android's threading rule which says ONLY the UI thread can update the UI.

AsyncTask allows you to run something OFF the UI thread (doInBackground()), and post the return value onto the UI Thread (onPostExecute()) so it can update the UI safely without violating Android's rule. You don't call doInBackground() or onPostExecute() directly instead you call AsyncTask.execute() and the code in AsyncTask will call doInBackground() on a background Thread, and when it finishes it will call onPostExecute() on the UI Thread. That way you don't get tangled up with doing all of the Threading yourself.

Now your idea of having multiple requests run through a single subclass isn't going to work because AsyncTask ties together two parts of making service calls: the details of executing a service call to get a response, and what to do with that response to update the UI. If called postFirstName() method what you do after it returns that response is probably different that if you called postLastName(). And because it's different means you can't just define ONE AsyncTask for all these different calls. You could share code either through composition or subclassing a base class, but you'll have to create a subclass for each unique operation you want to perform on the server. So think Class instead of Method for each call.

You don't have to use the parameters passed to the doInBackground(). If you have multiple types of parameters to pass to the AsyncTask. Pass them in the constructor. Since you can't reuse AsyncTask instances (ie can't call AsyncTask.execute() more than once per instance). Their lifecycle MUST be instantiate, execute(), and toss. That means passing input in the constructor won't hurt your ability to use the AsyncTask.

I've written my own version of AsyncTask that separates out three callback methods: success() for handling the result returned from doInBackground(); handleException() called when any exception is thrown from the doInBackground(); and doFinally() called regardless of doInBackground() returns something or throws an exception. In default AsyncTask onPostExecute() is called regardless of error or success. It would look something like this:

public class MyTask extends EnhancedAsyncTask<Param,Integer,MyResult> {
    MyParam1 param1;
    MyParam2 param2;

    public MyTask( MyParam1 param1, MyParam2 param2 ) {
        this.param1 = param;
        this.param2 = param2;
    }

    protected MyResult doInBackground( Param... params ) {
        // do server work here
        server.send( param1, param2 );
    }

    protected void success( MyResult result ) {
        // do Update of the UI
    }

    protected void handleException( Exception ex ) {
       // show an error here
    }
}

// Now to use this AsyncTask you would do something like this:

MyTask task = new MyTask( param1, param2 ).execute();

Often I'll do this as an anonymous inner class so passing references to the UI isn't needed, but again if you don't do Anon classes you can just pass those to the constructor. You just have to be careful to not touch the UI should the Activity be destroyed (like the user flips the screen).

Answer 2

Prior to design thing, there are somethings that looks like you are doing wrong.

• You should not be calling doInBackground directly as you are doing here

  new ServerProxy().doInBackground("setSelectedCell" , postParameters);

  instead it should be calling any version of execute

As for the design, you can try this

• You can create a ServerProxy class and dont extend it from AsyncTask . Just use it to have your logic encapsulated.
• And now you can create a ServerProxyAsync which will take ServerProxy as composition.

• Now one option you can do is

  public class ServerProxy extends AsyncTask

  Here String could be the method name you want to call on ServerProxy instance and you can use reflection for that.

NOTE: There could be other soln to this prob, this is just the first attempt to the problem