AsyncTask-Android

AsyncTask made simpler.

Set up

Add the following to the dependencies section of your build.gradle:

compile 'com.label305:asynctask:x.x.x.'

SimpleAsyncTask

Use a SimpleAsyncTask when doing work that will not throw a checked Exception:

public class MyAsyncTask extends SimpleAsyncTask<String> {

  @Override
  protected String doInBackground() {
    return "Test";
  }

  @Override
  protected void onSuccess(final String result) {
    // Do something with the result
  }
}

AsyncTask

Use an AsyncTask when doing work that may throw a checked Exception:

public class MyAsyncTask extends AsyncTask<String, IOException> {

  @Override
  protected String doInBackground() throws IOException {
    return myWebservice.getSomeString();
  }

  @Override
  protected void onSuccess(final String result) {
    // Do something with the result
  }

  @Override
  protected void onException(final IOException e) {
    // Handle IOException
  }
}

Executing

Like Android's AsyncTask, you can call execute() on the AsyncTask instance to start it:

new MyAsyncTask().execute();

Alternatively, you can use an AsyncTaskExecutor to delegate the execution. A default implementation is available as AsyncTaskExecutor.DEFAULT_EXECUTOR, which is used by AsyncTask.execute().

AsyncTaskExecutor.DEFAULT_EXECUTOR.execute(new MyAsyncTask());

Testing

The AsyncTaskExecutor can come in handy while testing. When practicing dependency injection, you can inject a different implementation that executes the AsyncTask synchronously. TestAsyncTaskExecutor can be used for such tests. To access this class, add the following to your relevant build.gradle section:

testCompile 'com.label305:asynctask-test:x.x.x' // For unit tests
androidTestCompile 'com.label305:asynctask-test:x.x.x' // For instrumentation tests

For example, suppose we have the following class for asynchronously retrieving a User from some web service:

public class UserRetriever {

  private final WebService mWebService;

  private final AsyncTaskExecutor mExecutor;

  public UserRetriever(final WebService webService, final AsyncTaskExecutor executor) {
    mWebService = webService;
    mExecutor = executor;
  }

  /**
   * Retrieves the User asynchronously, and notifies given callback when the User is retrieved.
   */
  public void retrieveUser(final UserCallback callback) {
    mExecutor.execute(new RetrieveUserTask(callback));
  }

  public interface UserCallback {

    void onUserRetrieved(User user);
  }

  private class RetrieveUserTask extends SimpleAsyncTask<User> {

    private final UserCallback mCallback;

    private RetrieveUserTask(final UserCallback callback) {
      mCallback = callback;
    }

    @Override
    public User doInBackground() {
      return mWebService.retrieveUser();
    }

    @Override
    public void onSuccess(final User user) {
      mCallback.onUserRetrieved(user);
    }
  }
}

We can test this class using mock objects, in this case Mockito:

public class UserRetrieverTest {

  @Test
  public void retrieveUser_retrievesUser_andNotifiesCallback() {
    /* Given */
    User user = new User();

    WebService webService = mock(WebService.class);
    when(webService.retrieveUser()).thenReturn(user);

    UserCallback callback = mock(UserCallback.class);

    UserRetriever userRetriever = new UserRetriever(webService, TestAsyncTaskExecutor.instance());

    /* When */
    userRetriever.retrieveUser(callback);

    /* Then */
    verify(callback).onUserRetrieved(user);
  }
}

License

Copyright 2015 Label305 B.V.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.