Android : AsyncTask not reaching onPostExecute

Question

I am using AsyncTask to avoid networkonmainthreadexception on my Android Library Project, now what I want to do is to get the value to be returned to my variable and wait for it before executing the next line of code. I used CountDownLatch to do this.

The way I execute my request and call my AsyncTask is written below.. So I used CountDownLatch to wait for the response before returning the value that I want to return.

public MyObject getMyObject(){

    final String url = "http://[myip]:8080/retrieve";

    try{
        Response response = executeRequest(url);
        final MyObject myObject = om.readValue(response.body().string(),
                new TypeReference<MyObject>() {
                });
        return myObject;
    } catch (Exception e) {
        e.printStackTrace();
    }

    return null;

}



private Response executeRequest(String url){

    try {
      //Simplified please just ignore this..
      GenericAsyncParams genericAsyncParams = createParams(......);

      final CountDownLatch countDownLatch = new CountDownLatch(1);
      ResponseListener responseListener = new ResponseListener(countDownLatch);
      MyAsyncTask myAsyncTask = new AsyncTask(responseListener);
      myAsyncTask.execute(genericAsyncParams);
      countDownLatch.await();

      //get the response from the listener class.
      Response response = responseListener.getResponse();
      return response;
    } catch (InterruptedException e) {
      e.printStackTrace();
    }

    return null;
  }

I am also aware that asyncTask.execute(args).get() could cause the exception, so I used a listener to update the value from the caller, I call setResponse on onPostExecute of my AsyncTask.

public class ResponseListener {

    private static final String TAG = ResponseListener.class.getName();

    private Response response;
    private CountDownLatch countDownLatch;

    public ResponseListener(CountDownLatch countDownLatch) {
        this.response = null;
        this.countDownLatch = countDownLatch;
    }

    public void setResponse(Response response){
        this.response = response;   
        Log.e(TAG, "Executing countdown..");
        countDownLatch.countDown();
    }

    public Response getResponse() {
        return response;
    }

    public CountDownLatch getCountDownLatch() {
        return countDownLatch;
    }
}

Now this is my AsyncTask Note: requestProcessor is a wrapper class for okHttp.

public class MyAsynctask extends AsyncTask<GenericAsyncParams, Void, Response>{


    private static final String TAG = MyAsyncTask.class.getName();

    private ResponseListener listener;

    public MyAsynctask(ResponseListener listener) {
        this.listener = listener;
    }

    @Override
    protected Response doInBackground(GenericAsyncParams... genericAsyncParamses) {
        Response response = null;
        GenericAsyncParams genericAsyncParams = genericAsyncParamses[0];
        String url = genericAsyncParams.getUrl();
        String method = genericAsyncParams.getMethod();
        RequestProcessor requestProcessor = genericAsyncParams.getRequestProcessor();

        try {
            Request.Builder builder;
            if(method.equalsIgnoreCase("POST")){
                builder = new Request.Builder()
                        .post(genericAsyncParams.getRequestBody())
                        .url(url)
                        .headers(headers);
            } else  {
                builder = new Request.Builder()
                        .headers(headers)
                        .get()
                        .url(url);
            }
            final Request request = builder.build();
            response = requestProcessor.client().newCall(request).execute();
            Log.d(TAG, "returning okHttp response..");
            return response;
        } catch (Exception e){
            Log.e(TAG, String.format("ERROR.. %s", ExceptionUtils.getMessage(e)));
        }

        return response;
    }


    @Override
    protected void onPostExecute(Response response) {
        if(listener != null){
            Log.d(TAG, "Updating response : onPostExecute..");
            listener.setResponse(response);
        } else {
            super.onPostExecute(response);
        }
    }

}

The last line of my log is

07-10 23: 47:07.008 28409-28530/com.aaron.android.android.lib D/com.aaron.android.android.lib.api.tasks.MyAsyncTask: returning okHttp response..

It is a common code inside a Util class used throughout the project. — Aaron, Jul 10 '17 at 16:10
Please show that in your code and show an example of how it is called. — Code-Apprentice, Jul 10 '17 at 16:11
Are you expecting an Activity calling it? this is a library project by the way. — Aaron, Jul 10 '17 at 16:14
Yes, I am guessing that an Activity or Service calls `executeRequest()`. You need to show more code in order to clarify this. Please give a [mcve]. — Code-Apprentice, Jul 10 '17 at 16:15
I just updated it and I guess, it's the last part of code on which I could share. — Aaron, Jul 10 '17 at 16:16
Your current code is not complete. When I copy and paste it into Android Studio, I get compiler errors because there are methods outside of a class. Also, we need an example of how the methods are called. Everything in Android starts from a lifecycle method. You need to show an example of one of these. — Code-Apprentice, Jul 10 '17 at 16:19

Code-Apprentice · Accepted Answer · 2017-07-10T16:42:58.767

5

NetworkOnMainException reminds us to not block the main UI thread. However, you are still blocking it by using a CountDownLatch to wait for the response. Since onPostExecute() runs on the main thread, you have blocked it from executing. You cannot block the main thread while waiting for the network connection to finish. Instead, allow executeRequest() to return so that the UI can respond appropriately.

edited Jul 10 '17 at 16:42

answered Jul 10 '17 at 16:11

Code-Apprentice

81,660
23
145
268

I think this makes sense to me now, so I have to refactor my code because currently, the only Async part of it is the interface that I expose to the Application Project. Other components such as network calls are not asynchronous, and I wait for each return value on the services (not android services, but just services) that I use to collect the data that I need to be returned to the API (what my library is for) that I created. Anyway, this is very big help and I have a lot of refactoring to do. Thanks @Code-Apprentice ! – Aaron Jul 10 '17 at 16:38

Android : AsyncTask not reaching onPostExecute

1 Answers1