Loader 知識梳理(3) 自定義Loader

1、概述

前面咱們比較關注的是LoaderManager的原理和使用，若是咱們只是須要經過LoaderManager來讀取ContentProvider封裝的數據，那麼採用系統已經定義好的CursorLoader就能夠了，可是有的時候，咱們的數據可能不是用ContentProvider封裝的，那麼這時候就要學會如何定義本身的Loader。

2、Loader<D>類

對於LoaderManager來講，它所看到的只是一個Loader類，並調用它對應的方法，這些方法分爲三類：

• 狀態標誌：isXXX
• 調用接口：startLoading/stopLoading/reset/cancelLoad/forceLoad/onReset
• 調用接口以後的回調：onXXX

public class Loader<D> {
    
    public void deliverResult(D data) {
        if (mListener != null) {
            mListener.onLoadComplete(this, data);
        }
    }

    public void deliverCancellation() {
        if (mOnLoadCanceledListener != null) {
            mOnLoadCanceledListener.onLoadCanceled(this);
        }
    }

    //在startLoading執行完，且沒有調用stopLoading或reset。
    public boolean isStarted() {
        return mStarted;
    }

    //在該狀態下，不該該上報新的數據，而且應該保持着最後一次上報的數據直到被reset。
    public boolean isAbandoned() {
        return mAbandoned;
    }

    //沒有啓動，或者調用了reset方法。
    public boolean isReset() {
        return mReset;
    }
    
    <!-- 開始任務相關 -->
    //開始任務。    
    public final void startLoading() {
        mStarted = true;
        mReset = false;
        mAbandoned = false;
        onStartLoading();
    }
    
    //開始任務後回調該方法，調用者重寫該方法來加載數據。
    protected void onStartLoading() {}

    <!-- 取消任務相關 -->   
   //取消任務。
   //1.返回 false 表示不能取消，有多是已經完成，或者 startLoading 尚未被調用。
   //2.這不是一個馬上的過程，由於加載是在後臺線程中運行的。
   public boolean cancelLoad() {
        return onCancelLoad();
    }
    
    //調用者重寫該方法來作取消後的操做。
    protected boolean onCancelLoad() {
        return false;
    }
 
    <!-- 強制刷新數據相關 -->   
    public void forceLoad() {
        onForceLoad();
    }

    protected void onForceLoad() {}

    <!-- 中止任務相關 --> 
    public void stopLoading() {
        mStarted = false;
        onStopLoading();
    }

    protected void onStopLoading() {}
  
   <!-- 廢棄任務相關 -->
    public void abandon() {
        mAbandoned = true;
        onAbandon();
    }

    protected void onAbandon() {}

    public void reset() {
        onReset();
        mReset = true;
        mStarted = false;
        mAbandoned = false;
        mContentChanged = false;
        mProcessingChange = false;
    }

    protected void onReset() {}
    
    //獲得mContentChanged的值，並把mContentChanged設爲false
    public boolean takeContentChanged() {
        boolean res = mContentChanged;
        mContentChanged = false;
        mProcessingChange |= res;
        return res;
    }
    
    //代表正在處理變化。
    public void commitContentChanged() {
        mProcessingChange = false;
    }
    
    //若是正在處理變化，那麼中止它，而且把mContentChanged設爲true。
    public void rollbackContentChanged() {
        if (mProcessingChange) {
            mContentChanged = true;
        }
    }

    //若是當前是start狀態，那麼收到變化的通知就當即從新加載，不然記錄下這個標誌mContentChanged。
    public void onContentChanged() {
        if (mStarted) {
            forceLoad();
        } else {
            mContentChanged = true;
        }
    }

}
複製代碼

能夠看到，在Loader<D>中，提供的是給LoaderManager調用的接口，可是它並無真正地執行操做，而是在startLoading等方法以後，提供了onStartLoading等回調，讓子類在這些回調中去執行對應的操做。

3、AsyncTaskLoader

對於Loader的使用者來講，它更加但願本身只用處理業務的邏輯，而不用再去關心如何把耗時的任務放到異步線程中。所以系統幫咱們實現了一個Loader的實現類AsyncTaskLoader<D>，裏面封裝了一個AsyncTask用來執行耗時操做。可是它也是一個抽象類，咱們並不能直接使用它，而是讓子類取實現它的loadInBackground方法去處理本身的業務邏輯。

public abstract class AsyncTaskLoader<D> extends Loader<D> {
    static final String TAG = "AsyncTaskLoader";
    static final boolean DEBUG = false;

    final class LoadTask extends ModernAsyncTask<Void, Void, D> implements Runnable {
        
        private final CountDownLatch mDone = new CountDownLatch(1);

        //表示該Task已經被post到了Handler當中，用來作延時操做。
        boolean waiting;

        /* Runs on a worker thread */
        @Override
        protected D doInBackground(Void... params) {
            try {
                //在後臺獲取數據。
                D data = AsyncTaskLoader.this.onLoadInBackground();
                return data;
            //onLoadInBackground代表要取消。
            } catch (OperationCanceledException ex) { 
                if (!isCancelled()) {
                    //LoaderManager仍然指望獲得結果，所以繼續拋出這個異常。
                    throw ex;
                }
                return null;
            }
        }

        //完成。
        @Override
        protected void onPostExecute(D data) {
            if (DEBUG) Log.v(TAG, this + " onPostExecute");
            try {
                AsyncTaskLoader.this.dispatchOnLoadComplete(this, data);
            } finally {
                mDone.countDown();
            }
        }

        //取消。
        @Override
        protected void onCancelled(D data) {
            if (DEBUG) Log.v(TAG, this + " onCancelled");
            try {
                AsyncTaskLoader.this.dispatchOnCancelled(this, data);
            } finally {
                mDone.countDown();
            }
        }

        //因爲實現了Runnable接口，在這裏執行executePendingTask。
        @Override
        public void run() {
            waiting = false;
            AsyncTaskLoader.this.executePendingTask();
        }

        //在計數達到0時，一直等待，也就是onPostExecute或onCancelled回調了。
        public void waitForLoader() {
            try {
                mDone.await();
            } catch (InterruptedException e) {
                // Ignore
            }
        }
    }

    private final Executor mExecutor;

    volatile LoadTask mTask;
    volatile LoadTask mCancellingTask;

    long mUpdateThrottle;
    long mLastLoadCompleteTime = -10000;
    Handler mHandler;

    public AsyncTaskLoader(Context context) {
        this(context, ModernAsyncTask.THREAD_POOL_EXECUTOR);
    }

    private AsyncTaskLoader(Context context, Executor executor) {
        super(context);
        mExecutor = executor;
    }

    //從上一次loadInBackground返回，到下次Task執行的時間。
    public void setUpdateThrottle(long delayMS) {
        mUpdateThrottle = delayMS;
        if (delayMS != 0) {
            mHandler = new Handler();
        }
    }

    @Override
    protected void onForceLoad() {
        super.onForceLoad();
        cancelLoad(); //這裏會回調onCancelLoad。
        mTask = new LoadTask(); //新建一個Task。
        executePendingTask(); //執行這個Task。
    }

    //cancelLoad後回調。
    @Override
    protected boolean onCancelLoad() {
        //當前沒有Task在執行。
        if (mTask != null) {
            //若是正在等待一個被取消的任務執行完畢，那麼先取消最後的那個任務。
            if (mCancellingTask != null) {
                if (mTask.waiting) {
                    mTask.waiting = false;
                    mHandler.removeCallbacks(mTask);
                }
                mTask = null;
                return false;
            } else if (mTask.waiting) { //若是當前的任務正在等待被執行，那麼直接取消它。
                mTask.waiting = false;
                mHandler.removeCallbacks(mTask);
                mTask = null;
                return false;
            } else {
                //若是當前的任務已經開始執行了，那麼先記錄下，賦值給mCancellingTask。
                boolean cancelled = mTask.cancel(false);
                if (cancelled) {
                    mCancellingTask = mTask;
                    cancelLoadInBackground();
                }
                mTask = null;
                return cancelled;
            }
        }
        return false;
    }
    
    //dispatchOnCancelled 或者在 dispatchOnLoadComplete 是判斷是 abandon 了。
    public void onCanceled(D data) {}

    void executePendingTask() {
        if (mCancellingTask == null && mTask != null) {
            //若是mTask正在等待被執行。
            if (mTask.waiting) {
                mTask.waiting = false; //那麼把它從隊列中移除。
                mHandler.removeCallbacks(mTask);
            }
            if (mUpdateThrottle > 0) {
                long now = SystemClock.uptimeMillis();
                if (now < (mLastLoadCompleteTime+mUpdateThrottle)) {
                    //放入等待隊列當中。
                    mTask.waiting = true;
                    mHandler.postAtTime(mTask, mLastLoadCompleteTime+mUpdateThrottle);
                    return;
                }
            }
            //執行這個任務。
            mTask.executeOnExecutor(mExecutor, (Void[]) null);
        }
    }

    void dispatchOnCancelled(LoadTask task, D data) {
        onCanceled(data); //回調onCanceled.
        if (mCancellingTask == task) { //若是被取消的task執行完了。
            rollbackContentChanged(); 
            mLastLoadCompleteTime = SystemClock.uptimeMillis();
            mCancellingTask = null;
            deliverCancellation(); //經過被取消的task執行完了。
            executePendingTask(); //執行當前的Task。
        }
    }

    void dispatchOnLoadComplete(LoadTask task, D data) {
        if (mTask != task) { //若是執行完的task不是最新的。
            dispatchOnCancelled(task, data);
        } else {
            if (isAbandoned()) { //若是被abandon了。
                onCanceled(data);
            } else {
                commitContentChanged();
                mLastLoadCompleteTime = SystemClock.uptimeMillis();
                mTask = null;
                deliverResult(data);
            }
        }
    }

    public abstract D loadInBackground();
    
    //mTask在後臺執行時回調這個方法。
    protected D onLoadInBackground() {
        return loadInBackground();
    }
    
    //mTask在執行過程當中被經過cancelLoad()取消了。
    public void cancelLoadInBackground() {}

    public boolean isLoadInBackgroundCanceled() {
        return mCancellingTask != null;
    }

    public void waitForLoader() {
        LoadTask task = mTask;
        if (task != null) {
            task.waitForLoader();
        }
    }

}
複製代碼

4、自定義Loader

關於如何實現AsyncTaskLoader，系統提供了一個很好的例子，那就是CursorLoader，它用來讀取ContentProvider中的數據，並支持傳入關於查詢的projection/selection/selectionArgs等條件，最終返回一個cursor，在返回以後負責cursor的關閉。 爲了更加靈活，咱們參照它的寫法，抽象出其中的關鍵代碼，讓使用者最多隻須要負責兩樣東西：

• 數據的加載
• 資源的釋放

BaseLoader的實現者只須要關注下面這三個方法：

//異步加載數據，這個Bundle就是onCreateLoader時傳入的Bundle，咱們能夠把查詢的關鍵詞放在其中，這個是子類必須實現的方法。
    protected abstract Result loadData(Bundle bundle);
    //下面兩個方法是用於結果資源的回收，例如cursor的關閉，當咱們的返回值只是一些基本數據類型時，並不須要實現它。
    protected void releaseResult(Result result) {}
    protected boolean isResultReleased(Result result) { return true; }
複製代碼

下面是所有的實現代碼：

public abstract class BaseDataLoader<Result> extends AsyncTaskLoader<Result> {

    Result mResult;
    Bundle mBundles;
    CancellationSignal mCancellationSignal;

    //全部的子類最多隻須要實現下面的三個方法，而不要回收資源的只用實現loadData就能夠了。
    protected abstract Result loadData(Bundle bundle);
    protected void releaseResult(Result result) {}
    protected boolean isResultReleased(Result result) { return true; }

    public BaseDataLoader(Context context, Bundle bundle) {
        super(context);
        mBundles = bundle;
    }

    @Override
    public Result loadInBackground() {
        synchronized (this) {
            if (isLoadInBackgroundCanceled()) {
                throw new OperationCanceledException();
            }
            mCancellationSignal = new CancellationSignal();
        }
        try {
            return loadData(mBundles);
        } finally {
            synchronized (this) {
                mCancellationSignal = null;
            }
        }
    }

    @Override
    public void cancelLoadInBackground() {
        super.cancelLoadInBackground();
        synchronized (this) {
            if (mCancellationSignal != null) {
                mCancellationSignal.cancel();
            }
        }
    }

    @Override
    public void deliverResult(Result result) {
        if (isReset()) {
            if (result != null && !isResultReleased(result)) {
                releaseResult(result);
            }
            return;
        }
        Result oldResult = mResult;
        mResult = result;
        if (isStarted()) {
            super.deliverResult(result);
        }
        if (oldResult != null && oldResult != result && !isResultReleased(oldResult)) {
            releaseResult(oldResult);
        }
    }

    @Override
    protected void onStartLoading() {
        if (mResult != null) {
            deliverResult(mResult);
        }
        if (takeContentChanged() || mResult == null) {
            forceLoad();
        }
    }

    @Override
    protected void onStopLoading() {
        cancelLoad();
    }

    @Override
    public void onCanceled(Result result) {
        if (result != null && !isResultReleased(result)) {
            releaseResult(result);
        }
    }

    @Override
    protected void onReset() {
        super.onReset();
        onStopLoading();
        if (mResult != null && !isResultReleased(mResult)) {
            releaseResult(mResult);
        }
        mResult = null;
    }

}
複製代碼