如何与多个AsyncTask同步应用

Question

I need To sync my app ( Sqlite to MySQL and Upload pics )

Basically, I have one AsyncTask class per Table, and one class to upload. each line of 1 table may include several pics to upload.

The thing is I can't find a way to control the state of the sync. There is several ways to do it, as far I can see, but none of them is good for me:

1.I could put all AsyncTask in one class, so each process go after the other, there is only one thread.

GOOD : It is easy to know when the process ends ( When entering in postExecute), so I can easily know if some process fails ( Checking in a global variable).

BAD: This is slower, and putting all my code in one file is kind of bad, specially if there is a lot of table in my project ( and it will be)

2.Several AsyncTask GOOD: This approach is better, faster, and easy to maintain. BAD: If I have 10 threads for instance, I can't know the moment when all the processes ends ( to check if there were errors in the processs.

Answer 1

You can use the getStatus() method on all your tasks to see their status.

In your AsyncTask class:

@Override
public void onPostExecute(Object result) {
    if (isSyncFinished()) {
        //Do whatever
    }
}    

In your Activity class:

ArrayList<AsyncTask> tasks;

private Boolean isSyncFinished() {
    for (AsyncTask task : tasks) {
        if (task.getStatus() == AsyncTask.Status.RUNNING)
            return false;
    }

    return true;
}

Answer 2

Here is an outline of what I would do:

public class SyncDatabase {

    public static final int RESULTCODE_SUCCESS = 1;
    public static final int RESULTCODE_FAIL_IO_FAILURE = 2;
    public static final int RESULTCODE_FAIL_NO_CONNECTION = 3;

    private interface SyncStatusCallback {
        public void success(String table);
        public void failed(String table, int resultCode);
    }

    private Context context;

    public SyncDatabase(Context context) {
        // application context to not rely on a single activity
        context = context.getApplicationContext();
    }

    public void sync() {
        StandardSyncStatusCallback syncCallback = new StandardSyncStatusCallback();
        new SyncTable1(syncCallback).execute();
        new SyncTable2(syncCallback).execute();
        new SyncTable3(syncCallback).execute();
        ...
    }

    private class StandardSyncStatusCallback implements SyncStatusCallback {

        @Override
        public void success(String table) {
            Intent intent = new Intent("DATABASE_SYNC_SUCCESS");
            intent.putExtra("table", table);
            context.sendBroadcast(intent);
        }

        @Override
        public void failed(String table, int resultCode) {
            Intent intent = new Intent("DATABASE_SYNC_FAILED");
            intent.putExtra("table", table);
            intent.putExtra("resultCode", resultCode);
            context.sendBroadcast(intent);
        }

    }


    private class SyncTable1 extends AsyncTask<Void, Void, Integer> {

        private final String tableName = "table1";

        private final SyncStatusCallback syncStatusCallback;

        public SyncTable1(SyncStatusCallback syncStatusCallback) {
            this.syncStatusCallback = syncStatusCallback;
        }

        @Override
        protected void onPreExecute() {

        }

        // The code to be executed in a background thread.
        @Override
        protected Integer doInBackground(Void... p) {
            // perform sync and return resultCode
            return 1;
        }

        // after executing the code in the thread
        @Override
        protected void onPostExecute(Integer resultCode) {
            if (resultCode == 1) {
                syncStatusCallback.success(tableName);
            } else {
                syncStatusCallback.failed(tableName, resultCode);
            }
        }
    }
}

The reason for sending broadcasts is that it is Activity independent. So, if the currently shown activity has interest in the status of the syncing process, it simply needs to register receivers for the two broadcasts.

Otherwise the sync will continue silently in the background.

There is of course a lot of changes that needs to be made in order for it to match your case but I hope it shows the general idea.