Android程序设计：一个用于同步远程数据库数据Thread类模仿AsyncTask

一个用于同步远程数据库数据Thread类，模仿AsyncTask。

缘由：

由于同步远程数据库数据，需要共享某些信息，比如连接信息或对象。
前文：一个用于同步远程数据库数据异步类AsyncTask
在执行过程中：一般只可以执行一次，除非重新new一个类出来，感觉不大爽。
于是根据AsyncTask思路，模仿出这个Thread类。
这样，在UI线程中可以多次调用执行run方法，当然要修改的同步对象也就是某些java bean。

代码：

SyncCaseThread 类：将本地数据同步到远程数据库中。
备注：Case是一个java bean对象。代码不考虑其他异常的处理。
三个接口，实现事件：
1.执行同步任务完成时，触发事件：onSyncCompleted 。
2.执行任务被取消时，触发事件：onSyncCancelled 。
3.某个java bean执行完同步数据后，触发事件：setOnSyncCase2Server。

//...
import java.util.ArrayList;
import java.util.List;

public class SyncCaseThread extends Thread {

    public interface onSyncCompleted {
        public void SyncCompleted();
    }

    public interface onSyncCancelled {
        public void SyncCancelled();
    }

    public interface onCaseSync2Server {
        public void SyncCase2Server(Case cs);
    }

    private List<Case>      listCases           = new ArrayList<Case>();
    private Connection      conn                = null;

    private onSyncCompleted     mOnSyncCompleted    = null;
    private onSyncCancelled     mOnSyncCancelled    = null;
    private onCaseSync2Server   mOnCaseSync2Server  = null;

    public SyncCaseThread() {

    }

    public void addCase(String strCaseGUID) {
        //...
    }

    public void addCase(Case cs) {
        //...
    }

    public void clear() {
        listCases.clear();
    }

    public void setOnSyncCompleted(onSyncCompleted onSyncCompletedEventHandler) {
        mOnSyncCompleted = onSyncCompletedEventHandler;
    }

    public void setOnSyncCancelled(onSyncCancelled onSyncCancelledEventHandler) {
        mOnSyncCancelled = onSyncCancelledEventHandler;
    }

    public void setOnSyncCase2Server(onCaseSync2Server onCaseSync2ServerEventHandler) {
        mOnCaseSync2Server = onCaseSync2ServerEventHandler;
    }

    private boolean checkIsExist(String strCaseGUID) {
        boolean rtn = false;
        //...
        return rtn;
    }

    @Override
    public void run() {
        super.run();
        if (listCases.size() > 0) {
            if (this.isCancelled) {
                onRunCancelled();
                return;
            }
            // ...
            for (Case cs : listCases) {
                if (this.isCancelled) {
                    onRunCancelled();
                    break;
                }
                //...
                // --save and update to server
                updateCase2Server(cs);
            }
            //...
            onRunCompleted();
        }
    }

    private void updateCase2Server(Case cs) {
        if (cs != null) {
            //...update         
            if (mOnCaseSync2Server != null) mOnCaseSync2Server.SyncCase2Server(cs);
        }
    }

    private void onRunCompleted() {
        if (mOnSyncCompleted != null) mOnSyncCompleted.SyncCompleted();
    }

    private void onRunCancelled() {
        if (mOnSyncCompleted != null) mOnSyncCancelled.SyncCancelled();
    }

    private boolean isCancelled = false;

    public void cancel(boolean isCancelled) {
        this.isCancelled = isCancelled;
    }

}