Question

My application has a refresh button on the main activity. When the user presses that button, a new thread is created which starts updating the SQLite database. When this thread started, user could possibly get into another activies of the application.

The problem is these other activities(ListActivity) should be updated according to the DB when that background thread is completed. How could I provide that. I tried getting current task with ActivityManager but It requires extra permission which I dont want.

Answer 1

Edit:

Sorry seems I misunderstood you. Please take a look at the following code, it is similar to Chinaski’s (you just use an interface for the callback methods) but I added a bit more to ensure you know how to use it in a way that will avoid memory leaks.

Note how the activity detaches during onDestroy — alternatively you could use a WeakReference, however these days you’d use a Fragment with setRetainInstance(true) and completely avoid the detaching/attaching as the fragment would be retained.

MyAsyncTask

public class MyAsyncTask extends AsyncTask<Void, Void, Void> {

    private Callback mCallback;

    private boolean mIsComplete = false;

    private boolean mHasCallbackBeenCalled = false;

    public MyBackgroundTask(Callback callback) {
        mCallback = callback;
    }

    /** Only safe to call this from the UI thread */
    public void attach(Callback callback) {
        mCallback = callback;

        if (mIsComplete && !mHasCallbackBeenCalled) {
            fireCallback();
        }
    }

    /** Only safe to call this from the UI thread */
    public void detach() {
        mCallback = callback;
    }

    @Override
    public void doInBackground() {
        // do the heavy stuff here
        return null;
    }

    @Override
    public void onPostExecute(Void result) {
        mIsComplete = true;
        fireCallback();
    }

    private void fireCallback() {
        if (mCallback != null) {
            mCallback.callbackMethod();
            mHasCallbackBeenCalled = true;
        }
    }

    public static interface Callback {

        public void callbackMethod();

    }
}

MyActivity

public class MyActivity extends Activity implements MyAsyncTask.Callback {

    private MyAsyncTask mTask;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        // Check for a retained task after a configuration change
        // e.g. a rotation
        if (getLastNonConfigurationInstance() != null) {
            mTask = (MyAsyncTask) getLastNonConfigurationInstance();
            // Re-attach the task
            mTask.attach(this);
        }
    }

    @Override
    public void onDestroy() {
        // Detach from task to avoid memory leak
        if (mTask != null) {
            mTask.detach();
        }

        super.onDestroy();
    }

    @Override
    public Object onRetainNonConfigurationInstance() {
        // Retain the async task duration a rotation
        return mTask;
    }

    /** Callback method */
    @Override
    public void callbackMethod() {
        // Do something here
    }

}