Android Loader(三) 结合CursorLoader分析Loader相关源码

Android Loader(二) CursorLoader

Android Loader(四) 自定义Loader从网络中获取文本数据

首先从加载数据的过程开始分析。

初始化Loader的方法是：getLoaderManager().initLoader(0, null, this);当这个方法调用之后，Loader就在后台进行初始化，以及数据加载的工作了。

先看一下LoaderManager代码，LoaderManager是一个抽象类，LoaderCallbacks是其内部类，LoaderCallbacks有onCreateLoader，onLoadFinished，onLoaderReset三个方法。

LoaderManager的关键抽象方法有：initLoader，restartLoader，destroyLoader，getLoader，他们都是通过LoaderManager的子类LoaderManagerImpl实现的。

class LoaderManagerImpl extends LoaderManager

LoaderManagerImpl的内部类LoaderInfo：

final class LoaderInfo implements Loader.OnLoadCompleteListener<Object>,

Loader.OnLoadCanceledListener<Object> {

LoaderManagerImpl有2个全局变量SparseArray<LoaderInfo> mLoaders和SparseArray<LoaderInfo> mInactiveLoaders，mLoaders中存放着当前活动的Loader，mInactiveLoaders存放着以前运行的Loader。

下面从初始化Loader开始分析：

先看getLoaderManager().方法， 实际调用的是Activity的LoaderManagerImpl getLoaderManager(String who, boolean started, boolean create) ，返回一个LoaderManagerImpl，

LoaderManagerImpl的initLoader中的关键代码：

LoaderInfo info = mLoaders.get(id);

if (info == null) {

info = createAndInstallLoader(id, args,  (LoaderManager.LoaderCallbacks<Object>)callback);

}

createAndInstallLoader：

private LoaderInfo createAndInstallLoader(int id, Bundle args,
LoaderManager.LoaderCallbacks<Object> callback) {
try {
mCreatingLoader = true;
LoaderInfo info = createLoader(id, args, callback);
installLoader(info);
return info;
} finally {
mCreatingLoader = false;
}
}

createLoader：

private LoaderInfo createLoader(int id, Bundle args,
LoaderManager.LoaderCallbacks<Object> callback) {
LoaderInfo info = new LoaderInfo(id, args,  (LoaderManager.LoaderCallbacks<Object>)callback);
Loader<Object> loader = callback.onCreateLoader(id, args);
info.mLoader = (Loader<Object>)loader;
return info;
}

可以看到， LoaderInfo通过 createLoader实例化，并且在createLoader中，调用LoaderCallbacks的onCreateLoader创建Loader，onCreateLoader在实现了LoaderCallbacks的Fragment或Activity中实现，这样就完成了Loader的创建。再看 installLoader方法：

void installLoader(LoaderInfo info) {
mLoaders.put(info.mId, info);
if (mStarted) {
info.start();
}
}

mStarted的值为true，赋值过程如下：

LoaderManagerImpl构造方法：

LoaderManagerImpl(String who, Activity activity, boolean started) {
mWho = who;
mActivity = activity;
mStarted = started;
}

这是在Activity的 getLoaderManager中调用的：

lm = new LoaderManagerImpl(who, this, started);

started的值在Fragment的getLoaderManager调用中赋值

mLoaderManager = mActivity.getLoaderManager(mWho, mLoadersStarted, true);

这个 mLoadersStarted是全局变量，在Fragment的onStart方法中赋值

Fragment.onStart()：

protected void onStart() {
......

if (!mLoadersStarted) {
mLoadersStarted = true;
if (mLoaderManager != null) {
mLoaderManager.doStart();
} else if (!mCheckedForLoaderManager) {
mLoaderManager = getLoaderManager("(root)", mLoadersStarted, false);
}
mCheckedForLoaderManager = true;
}
getApplication().dispatchActivityStarted(this);
}

再回到installLoader方法，info.start()被调用，start方法：

......
mStarted = true;
......
if (!mListenerRegistered) {
mLoader.registerListener(mId, this);
mLoader.registerOnLoadCanceledListener(this);
mListenerRegistered = true;
}
mLoader.startLoading();

Loader.startLoading():

public final void startLoading() {
mStarted = true;
mReset = false;
mAbandoned = false;
onStartLoading();
}

查看Loader类的说明：

Subclasses generally must implement at least onStartLoading()，onStopLoading(), onForceLoad(), onReset()

onStartLoading方法是需要Loader的子类重写的，以CursorLoader为例：

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

deliverResult():

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

从以上代码可以看出， 如果mCursor不为空，则说明数据查询已经结束， 直接调用onLoadComplete， mListener对象是 Loader内部接口 OnLoadCompleteListener的实例：

OnLoadCompleteListener<D> mListener;
public interface OnLoadCompleteListener<D> {
public void onLoadComplete(Loader<D> loader, D data);
}

onLoadComplete中调用了 callOnLoadFinished方法，callOnLoadFinished中调用了 onLoadFinished：

mCallbacks.onLoadFinished(loader, data);

onLoadFinished也是需要重写的方法，一般在使用CursorLoader的类中， LoaderCallbacks的onLoadFinished方法都这样实现：

@Override
public void onLoadFinished(Loader<Cursor> loader, Cursor data) {
mAdapter.swapCursor(data);
}

再来看onStartLoading中的另外一个判断语句：

if (takeContentChanged() || mCursor == null) {
forceLoad();
}

forceLoad:

public void forceLoad() {
onForceLoad();
}

onForceLoad在CursorLoader的父类 AsyncTaskLoader中已经重写，一般自定义的Loader不直接继承Loader，而是继承 AsyncTaskLoader，CursorLoader也是如此。

@Override
protected void onForceLoad() {
super.onForceLoad();
cancelLoad();
mTask = new LoadTask();
if (DEBUG) Slog.v(TAG, "Preparing load: mTask=" + mTask);
executePendingTask();
}

Loader.cancelLoad:

public boolean cancelLoad() {
return onCancelLoad();
}

AsyncTaskLoader.onCancelLoad:

@Override
protected boolean onCancelLoad() {
if (DEBUG) Slog.v(TAG, "onCancelLoad: mTask=" + mTask);
if (mTask != null) {
if (mCancellingTask != null) {
// There was a pending task already waiting for a previous
// one being canceled; just drop it.
if (DEBUG) Slog.v(TAG,
"cancelLoad: still waiting for cancelled task; dropping next");
if (mTask.waiting) {
mTask.waiting = false;
mHandler.removeCallbacks(mTask);
}
mTask = null;
return false;
} else if (mTask.waiting) {
// There is a task, but it is waiting for the time it should
// execute.  We can just toss it.
if (DEBUG) Slog.v(TAG, "cancelLoad: task is waiting, dropping it");
mTask.waiting = false;
mHandler.removeCallbacks(mTask);
mTask = null;
return false;
} else {
boolean cancelled = mTask.cancel(false);
if (DEBUG) Slog.v(TAG, "cancelLoad: cancelled=" + cancelled);
if (cancelled) {
mCancellingTask = mTask;
cancelLoadInBackground();
}
mTask = null;
return cancelled;
}
}
return false;
}

这个方法的作用是取消之前没有或者正在执行的 mTask， mTask是一个AsyncTask。

之前提到，Loader的子类必须实现的方法之一是onStopLoading,CursorLoader中的onStopLoading实际上就间接调用了onCancelLoad：

@Override
protected void onStopLoading() {
// Attempt to cancel the current load task if possible.
cancelLoad();
}

继续看onForceLoad的代码：

mTask = new LoadTask();
executePendingTask();

LoadTask就是个AsyncTask, LoadTask的doInBackground中：

D data = AsyncTaskLoader.this.onLoadInBackground();
return data;

protected D onLoadInBackground() {
return loadInBackground();
}

Loader异步的特性就是通过这个AsyncTask实现的，executePendingTask方法启动这个task，Loader的子类重写LoadInBackground完成数据的异步加载。这个方法在CursorLoader的实现如下：

@Override
public Cursor loadInBackground() {
synchronized (this) {
if (isLoadInBackgroundCanceled()) {
throw new OperationCanceledException();
}
mCancellationSignal = new CancellationSignal();
}
try {
Cursor cursor = getContext().getContentResolver().query(mUri, mProjection, mSelection,
mSelectionArgs, mSortOrder, mCancellationSignal);
if (cursor != null) {
try {
// Ensure the cursor window is filled.
cursor.getCount();
cursor.registerContentObserver(mObserver);
} catch (RuntimeException ex) {
cursor.close();
throw ex;
}
}
return cursor;
} finally {
synchronized (this) {
mCancellationSignal = null;
}
}
}

在这段代码中，对指定URI的查询结果放入Cursor对象，然后在 LoadTask的onPostExecute中处理：

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

dispatchOnLoadComplete中，调用了deliverResult，这样，在onLoadFinished中就能获取Cursor数据。

以上是一个Loader从创建到初始化到加载并传递数据的过程。

Loader的onReset也是需要子类重写的方法，AsyncTaskLoader没有实现这个方法，CursorLoader的实现如下：

@Override
protected void onReset() {
super.onReset();

// Ensure the loader is stopped
onStopLoading();

if (mCursor != null && !mCursor.isClosed()) {
mCursor.close();
}
mCursor = null;
}

onReset方法做了2件事，调用onStopLoading和关闭cursor， onRest方法在Loader的reset中被调用，而reset在LoaderManagerImpl的destroy() 调用, destroy()这个方法是在Loader需要销毁时调用的，所以onReset中应该实现停止加载数据和释放资源的逻辑。

Loader可以探测到数据源的变化并且自动加载，这个特性，用CursorLoader的代码来解读：

先看CursorLoader的构造方法：

public CursorLoader(Context context) {
super(context);
mObserver = new ForceLoadContentObserver();
}

ForceLoadContentObserver是Loader的内部类，它是ContentObserver的子类，在Cursor的loadInBackground() 中，向这个Observer进行了注册:

cursor.registerContentObserver(mObserver);

这里使用了观察者模式， ForceLoadContentObserver是Obeserver，Cursor是Subject，当Cursor内容改变时，ForceLoadContentObserver的onChange方法会被调用，进而调用onContentChanged()：

@Override
public void onChange(boolean selfChange) {
onContentChanged();
}

onContentChanged：

public void onContentChanged() {
if (mStarted) {
forceLoad();
} else {
// This loader has been stopped, so we don't want to load
// new data right now...  but keep track of it changing to
// refresh later if we start again.
mContentChanged = true;
}
}

内部调用了 forceLoad对数据进行重新加载，所以CursorLoader在数据源发生变化时可以重新加载数据。

最后来看一下为什么CursorLoader可以在configuration change时重新连接Cursor：
在 configuration change时，Activity会被销毁并重建，不论Fragment还是Activity都会调用onStart这个回调 ，onStart中的 mLoaderManager.doStart()，调用了LoaderManager的doStart();

void doStart() {
if (DEBUG) Log.v(TAG, "Starting in " + this);
if (mStarted) {
RuntimeException e = new RuntimeException("here");
e.fillInStackTrace();
Log.w(TAG, "Called doStart when already started: " + this, e);
return;
}

mStarted = true;

// Call out to sub classes so they can start their loaders
// Let the existing loaders know that we want to be notified when a load is complete
for (int i = mLoaders.size()-1; i >= 0; i--) {
mLoaders.valueAt(i).start();
}
}

mLoader中的Loader是在 installLoader方法中添加的：mLoaders.put(info.mId, info);
for循环中，从 mLoaders中获取正在运行的Loader，重新调用它们的 start方法，在start中有以下判断：

if (mRetaining && mRetainingStarted) {
// Our owner is started, but we were being retained from a
// previous instance in the started state...  so there is really
// nothing to do here, since the loaders are still started.
mStarted = true;
return;
}

if (mStarted) {
// If loader already started, don't restart.
return;
}

这样就达到了重新连接并且不需要再次查询的目的。