Question

I have an activity class as below.

public class LoginActivity extends Activity implements OnClickListener {
   @Override
   public void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      setContentView(R.layout.main);
      button1 = (ImageView) findViewById(R.id.button1);
      button1.setOnClickListener(this);
   }
   @Override
   public void onClick(View v) {
       BackgroundRunner bgRunner = new BackgroundRunner(this);
       String[] params = new String[]{url};
       bgRunner.execute(params);
   }


}

And the AsyncTask is:

 public class BackgroundRunner extends AsyncTask<String, Void, Boolean>  {

@Override
protected Boolean doInBackground(String... params) {
    ServiceCaller serviceCaller = new ServiceCaller();
    boolean status = serviceCaller.checkLogin(params[0]);
    return status;
}

@Override
public void onPreExecute(){
    progressBar = (ProgressBar) currentContext.findViewById(R.id.loader);
    progressBar.setVisibility(View.VISIBLE);
     }

@Override
public void onPostExecute(final Boolean status){
    progressBar.setVisibility(View.INVISIBLE);
}

}

Here is the scenario. The main activity class creates a thread on a click. The then created thread fetches some data from the server. It is a time consuming task. So a progress bar is displayed on the UI. Currently I am using AsyncTask to accomplish server data retrieval. But the real challenge is wait for the background task to complete and get the value from it. What I am looking for is:

wait until server calls are made and get the results. Meanwhile show the progress bar. I think Handler would be an option. I am far less clear on that.

Any thoughts?

Answer 1

My solution was create my own asynctask class:

 import android.app.Activity;
import android.app.ProgressDialog;
import android.content.DialogInterface;
import android.content.DialogInterface.OnCancelListener;
import android.os.Handler;
import br.com.zcr.ezcrm.R;

public class AsyncTask implements Runnable {

    private Activity activity;
    private Handler handler;
    private Action action;
    private boolean showDialog = true;
    private boolean running = false;
    private boolean canceled = false;

    private Thread t;

    private ProgressDialog progress;

    public AsyncTask(Activity activity) {
        this.activity = activity;
        handler = new Handler();
    }

    public AsyncTask(Activity activity, Action action) {
        this.activity = activity;
        this.action = action;
        handler = new Handler();
    }

    private ProgressDialog getDialog() {
        if (progress != null)
            return progress;
        progress = ProgressDialog.show(activity, null, activity.getString(R.string.carregando), true, false);
        progress.setOnCancelListener(new OnCancelListener() {
            public void onCancel(DialogInterface dialog) {
                setCanceled(true);
            }
        });
        return progress;
    }

    private void showDialog() {
        if (showDialog)
            getDialog().show();
    }

    private void hideDialog() {
        if (showDialog)
            getDialog().dismiss();
    }

    public void execute(boolean showDialog) {

        this.showDialog = showDialog;
        execute();
    }

    public void execute() {

        if (running || action == null)
            return;

        running = true;

        // Utils.setFixedOrientation(activity);
        showDialog();
        t = new Thread(AsyncTask.this);
        t.start();
    }

    @Override
    public void run() {

        try {

            final Object o = action.run();

            if (canceled)
                return;

            handler.post(new Runnable() {
                public void run() {
                    action.onFinnish(o);
                }
            });

        } catch (final Exception e) {

            if (canceled)
                return;

            handler.post(new Runnable() {
                public void run() {
                    action.onError(e);
                }
            });

        } finally {

            canceled = false;
            hideDialog();
            // Utils.setUnfixedOrientation(activity);
            running = false;
        }

    }

    /*
     * public void stop() { running = false; }
     */
    public void setAction(Action a) {
        action = a;
    }

    public void setCanceled(boolean canceled) {
        if (canceled)
            t = null;
        this.canceled = canceled;
    }

    public interface Action {
        /** Acao a ser executada */
        public Object run() throws Exception;

        /** Chamado no fim de todas as execucoes */
        public void onFinnish(Object result);

        /** Para qualquer execucao e retorna o erro */
        public void onError(Exception e);
    }

}

And this is the implementation:

    AsyncTask task = new AsyncTask(this, new Action() {
        public Object run() throws Exception {
            return WebService.autenticate(login, pass);
        }
        public void onFinnish(Object result) {
//result was returned in run method
            verifyLogin((String) result);
        }
        public void onError(Exception e) {
            //error
        }
    });