码迷，mamicode.com
首页 > 移动开发 > 详细

android之LoaderManager原理分析

时间：2016-04-19 12:28:33      阅读：321      评论：0      收藏：0      [点我收藏+]

标签：

一.    LoaderManager的使用
    LoaderManager用于异步加载数据，当然，它异步的实现依赖于AsyncTask的原理。如果不深究它的实现原理，这个LoaderManager的使用还是很简单的。我们只需要实现LoaderCallbacks类，然后调用getLoaderManager().initLoader()就可以了，执行加载数据的语句写在LoaderCallbacks类的onCreateLoader()方法中，如果加载完毕，我们可以在onLoadFinished()方法中获取相关的数据结果。具体代码如下：

public class MainActivity extends Activity {

	private String TAG = "LoaderManager";
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.activity_main);
		
		getLoaderManager().initLoader(0, null, mCallback);
	}
	private final LoaderManager.LoaderCallbacks<Cursor> mCallback = new LoaderCallbacks<Cursor>() {

		@Override
		public Loader<Cursor> onCreateLoader(int id, Bundle args) {
			// TODO Auto-generated method stub
			android.util.Log.v(TAG, "LoaderCallbacks-------onCreateLoader");
			return new CursorLoader(getApplicationContext(), Telephony.MmsSms.CONTENT_CONVERSATIONS_URI, null, null, null, null);
			//return null;
		}

		@Override
		public void onLoadFinished(Loader<Cursor> loader, Cursor data) {
			// TODO Auto-generated method stub
			android.util.Log.v(TAG, "LoaderCallbacks-------onLoadFinished----count:"+data.getCount());
            while(data.moveToNext()){
            	android.util.Log.v(TAG,":"+data.getString(data.getColumnIndex("address")));
            	android.util.Log.v(TAG,":"+data.getString(data.getColumnIndex("body")));
            }
		}

		@Override
		public void onLoaderReset(Loader<Cursor> loader) {
			// TODO Auto-generated method stub
			android.util.Log.v(TAG, "LoaderCallbacks-------onCreateLoader");

		}
	};
}

以上代码的功能是从Mms数据库中读取所有短信信息并打印。

二.    LoaderManager源代码分析


1.LoaderManager

那么为什么要实现LoaderCallbacks类呢（回调机制），我们等会再说。先来看看怎么获取LoaderManage对象----getLoaderManager()：我们可以看到，Activity.java和Fragment.java中都有这个方法，说明我们在创建每一个Activity和Fragment的时候，都会生成一个相对应的LoaderManager对象。当然，在显式的调用getLoaderManager()的时候，如果先前没有创建过LoaderManager对象，它会直接new LoaderManagerImpl()并返回这个对象。如果先前已经创建过LoaderManager对象，那么就会直接使用以前的LoaderManager对象。

public LoaderManager getLoaderManager() {
        if (mLoaderManager != null) {
            return mLoaderManager;
        }
        mCheckedForLoaderManager = true;
        mLoaderManager = getLoaderManager(null, mLoadersStarted, true);
        return mLoaderManager;
    }
    
    LoaderManagerImpl getLoaderManager(String who, boolean started, boolean create) {
        if (mAllLoaderManagers == null) {
            mAllLoaderManagers = new HashMap<String, LoaderManagerImpl>();
        }
        LoaderManagerImpl lm = mAllLoaderManagers.get(who);
        if (lm == null) {
            if (create) {
                lm = new LoaderManagerImpl(who, this, started);
                mAllLoaderManagers.put(who, lm);
            }
        } else {
            lm.updateActivity(this);
        }
        return lm;
}

其实在Activity.java和Fragment.java的onStart()方法中，也有初始化这个LoaderManager对象，只是它并不会创建新对象，只会使用旧的对象进行赋值，如下：
protected void onStart() {
        if (DEBUG_LIFECYCLE) Slog.v(TAG, "onStart " + this);
        mCalled = true;
        
        if (!mLoadersStarted) {
            mLoadersStarted = true;
            if (mLoaderManager != null) {
                mLoaderManager.doStart();
            } else if (!mCheckedForLoaderManager) {
                mLoaderManager = getLoaderManager(null, mLoadersStarted, false);
            }
            mCheckedForLoaderManager = true;
        }

        getApplication().dispatchActivityStarted(this);
    }

LoaderManager对象得到后，接下来会调用initLoader()方法。接下来的东西就跟LoaderManager.java有关了。先来了解一下LoaderManager.java这个类都有哪些方法和内部类。
abstract class LoaderManager：
    一个接口：interface LoaderCallbacks<D>
           方法：initLoader(int id, Bundle args,LoaderManager.LoaderCallbacks<D> callback)
                     restartLoader(int id, Bundle args,LoaderManager.LoaderCallbacks<D> callback)
                     destroyLoader(int id);
        内部类：class LoaderManagerImpl extends LoaderManager {…}
             内部类的内部类：final class LoaderInfo implements Loader.OnLoadCompleteListener<Object>,
                                      Loader.OnLoadCanceledListener<Object> {

由于LoaderManager是一个抽象类，所以它的子类LoaderManagerImpl必须要实现它的几个抽象方法。而这几个抽象方法使用了LoaderCallbacks类型的变量作为形参，所以，我们要自己实现LoaderCallbacks这个接口。那么，initLoader和restartLoader这两个方法是干嘛用的呢？要了解这个，我们必须先得了解Loader.java这个类。


2. Loader
public class Loader<D>
     内部类：public final class ForceLoadContentObserver extends ContentObserver
     内部接口：public interface OnLoadCompleteListener<D>
               public interface OnLoadCanceledListener<D>
     方法：deliverResult(D data)
           registerListener(int id, OnLoadCompleteListener<D> listener)
           startLoading()
Loader的继承关系如下：
Loader
AsyncTaskLoader
     CursorLoader，ContactLoader……..
先来看看Loader的两个内部接口，这两个内部接口是用来干嘛的呢？ 要想知道它的作用，那么先得找到是谁实现了它，又是谁调用了它。我们看到在deliverResult()方法中，接口的方法onLoadComplete被调用了。

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

而这个接口的实现对象mListener是被registerListener()传进来的。

public void registerListener(int id, OnLoadCompleteListener<D> listener) {
        if (mListener != null) {
            throw new IllegalStateException("There is already a listener registered");
        }
        mListener = listener;
        mId = id;
    }
再来看看实现它的地方，是在LoaderManager的内部实现类LoaderManagerImpl中，如下： 

final class LoaderInfo implements Loader.OnLoadCompleteListener<Object>,Loader.OnLoadCanceledListener<Object>

这里也使用了回调机制，如果有谁调用了deliverResult()方法，就通过回调机制通知LoaderInfo的onLoadComplete()方法，通过字眼可知，到了deliverResult被调用的时候，需要加载的数据也就得到了，当然得通知LoaderInfo方法进行数据处理，再由LoaderManager统一部署，最后也是通过回调机制回到LoaderCallbacks的实现方法onLoadFinished()中。那么Loader的作用也就出来了:
1. 检测数据源，如果有变化则通知(ForceLoadContentObserver)。
2.定义Loader的状态，根据状态的不同，执行不同的操作，状态有：mStarted，mAbandoned，mReset
3.回调机制：OnLoadCompleteListener，OnLoadCanceledListener
3. AsyncTaskLoader
关于异步的过程并不是在Loader实现，而是在它的子类AsyncTaskLoader中实现。来看看AsyncTaskLoader中的方法及内部类：

volatile LoadTask mTask;
final class LoadTask extends AsyncTask<Void, Void, D> implements Runnable
onForceLoad()：重载
在上一节有关于AsyncTask的介绍中，我们知道使用AsyncTask进行异步时，只需要创建一个AsyncTask的对象，并调用execute()方法就可以了。所以可以看看都有哪个方法执行了异步的开始方法：

@Override
    protected void onForceLoad() {
        super.onForceLoad();
        cancelLoad();
        mTask = new LoadTask();
        if (DEBUG) Slog.v(TAG, "Preparing load: mTask=" + mTask);
        executePendingTask();
}
    void dispatchOnCancelled(LoadTask task, D data) {
        onCanceled(data);
        if (mCancellingTask == task) {
            if (DEBUG) Slog.v(TAG, "Cancelled task is now canceled!");
            mLastLoadCompleteTime = SystemClock.uptimeMillis();
            mCancellingTask = null;
            if (DEBUG) Slog.v(TAG, "Delivering cancellation");
            deliverCancellation();
            executePendingTask();
        }
    }

dispatchOnCancelled()方法不是很明确它到底要干什么，我的理解是：大概在加载数据时（LoadTask），时间比较长，等结果出来时，新的Loader任务来了（new LoadTask()），所以放弃掉旧数据，重新开始加载。有待再研究。
      毫无疑问，onForceLoad()方法创建了AsyncTask对象，并开启了异步线程的任务。任务开始后，后台的执行方法是doInBackground()：详细的看上一节AsyncTask介绍。 

protected D doInBackground(Void... params) {
            if (DEBUG) Slog.v(TAG, this + " >>> doInBackground");
            try {
                D data = AsyncTaskLoader.this.onLoadInBackground();
                if (DEBUG) Slog.v(TAG, this + "  <<< doInBackground");
                return data;
            } catch (OperationCanceledException ex) {
                if (!isCancelled()) {
                    throw ex;
                }
                if (DEBUG) Slog.v(TAG, this + "  <<< doInBackground (was canceled)");
                return null;
            }
        }
    protected D onLoadInBackground() {
        return loadInBackground();
}
public abstract D loadInBackground();

很明显，最后执行的将是AsyncTaskLoader子类中的实现方法loadInBackground()，我们拿一个它的子类CursorLoader来看看，执行了什么语句： 

public Cursor loadInBackground() {
        Cursor cursor = getContext().getContentResolver().query(mUri, mProjection, mSelection,
                mSelectionArgs, mSortOrder);
        if (cursor != null) {
            // Ensure the cursor window is filled
            cursor.getCount();
            cursor.registerContentObserver(mObserver);
        }
        return cursor;
}

查询数据库数据并且把结果cursor返回到AsyncTaskLoader中。好了，这样异步加载的线程就结束了，得到的结果将在onPostExecute()中进行下一步的处理： 

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

    void dispatchOnLoadComplete(LoadTask task, D data) {
        if (mTask != task) {
            if (DEBUG) Slog.v(TAG, "Load complete of old task, trying to cancel");
            dispatchOnCancelled(task, data);
        } else {
            if (isAbandoned()) {
                // This cursor has been abandoned; just cancel the new data.
                onCanceled(data);
            } else {
                mLastLoadCompleteTime = SystemClock.uptimeMillis();
                mTask = null;
                if (DEBUG) Slog.v(TAG, "Delivering result");
                deliverResult(data);
            }
        }
}

是不是感觉这个deliverResult(data)很熟悉，没错，我们在Loader中见过它的身影，但是这里执行的却并不是Loader中的deliverResult(data)，而是CursorLoader中的deliverResult(data)，看看它又干了什么： 

public void deliverResult(Cursor cursor) {
        if (isReset()) {
            // An async query came in while the loader is stopped
            if (cursor != null) {
                cursor.close();
            }
            return;
        }
        Cursor oldCursor = mCursor;
        mCursor = cursor;

        if (isStarted()) {
            super.deliverResult(cursor);
        }

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

这个isStarted()是Loader中的方法，判断当前Loader的状态是mStarted，则调用Loader中的deliverResult()方法，执行它后，会回调LoaderManager中的onLoadComplete()，然后再回调一次，这个数据就回到LoaderCallbacks的实现方法onLoadFinished()中，这样我们就可以随心所欲的操作最后的数据结果了。如果当前Loader状态是mAbandoned，mReset，那么说明当前的Loader已经不需要加载数据了，放弃数据并释放资源。
那么，这里还有一个问题。到底谁调用onForceLoad()方法开启异步任务呢？

 

Loader.java
    public void forceLoad() {
        onForceLoad(); 
}

在Loader的子类CursorLoader中，有调用这个forceLoad()方法： 

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

谁调用CursorLoader中的onStartLoading()? 

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

最后发现其实是在LoaderManager中的start()方法调用了startLoading(),由此，数据加载开始了，LoaderManager在其中起了一个Loader大管家的作用，它决定了什么时候启动、停止、保持、重启、关闭它的Loaders。
刚开始时，我们是从LoaderManager的initLoader()方法中开始入手研究的，其中涉及到了Loader，AsyncTaskLoader ，CursorLoader以及它们相关的内部类和接口，它们主要解决了异步的问题，并提供了单个数据加载的模板。统筹调度与管理主要还是在LoaderManager中。
开始研究LoaderManager之前，我们先记住单个数据的加载工作是在Loader的startLoading()中开始的。LoaderInfo实现了Loader内部的两个接口，数据加载结束后，Loader会回调LoaderInfo中的方法。了解了这两点，我们可以着手看LoaderManager了。
LoaderInfo的几个变量：
LoaderManager.LoaderCallbacks<Object> mCallbacks;
        Loader<Object> mLoader;
        public LoaderInfo(int id, Bundle args, LoaderManager.LoaderCallbacks<Object> callbacks) {
            mId = id;
            mArgs = args;
            mCallbacks = callbacks;
        }

如上，LoaderInfo用mLoader来保存当前Loader，我们可以认为LoaderInfo是对Loader的进一步封装，除此之外，它的实例化还需要一个LoaderCallbacks对象，从我们的例子来看，这个LoaderCallbacks对象其实就是new CursorLoader()，为什么是这个呢，后面会讲到。
LoaderManager的几个变量：
<span style="font-size:14px;">final SparseArray<LoaderInfo> mLoaders = new SparseArray<LoaderInfo>();
final SparseArray<LoaderInfo> mInactiveLoaders = new SparseArray<LoaderInfo>();
</span>
mLoaders是一个数据集合，它保存了所有的LoaderInfo对象（封装了Loader），也就是保存了所有的Loader对象。
了解了这几个变量，那来看看initLoader()方法吧：

 

public <D> Loader<D> initLoader(int id, Bundle args, LoaderManager.LoaderCallbacks<D> callback) {
        if (mCreatingLoader) {
            throw new IllegalStateException("Called while creating a loader");
        }
        
        LoaderInfo info = mLoaders.get(id);
        
        if (DEBUG) Log.v(TAG, "initLoader in " + this + ": args=" + args);

        if (info == null) {
            // Loader doesn't already exist; create.
            info = createAndInstallLoader(id, args,  (LoaderManager.LoaderCallbacks<Object>)callback);
            if (DEBUG) Log.v(TAG, "  Created new loader " + info);
        } else {
            if (DEBUG) Log.v(TAG, "  Re-using existing loader " + info);
            info.mCallbacks = (LoaderManager.LoaderCallbacks<Object>)callback;
        }
        
        if (info.mHaveData && mStarted) {
            // If the loader has already generated its data, report it now.
            info.callOnLoadFinished(info.mLoader, info.mData);
        }
        
        return (Loader<D>)info.mLoader;
    }

试图从集合mLoaders中加载已经存在的LoaderInfo对象，如果有，则直接返回LoaderInfo中保存的Loader对象。如果没有，则新创建一个LoaderInfo用来封装Loader，并把此LoaderInfo对象保存在集合中。 

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;
        }
}

创建新的LoaderInfo对象，看看这个callback.onCreateLoader(id, args)，callback就是传进来的LoaderCallbacks对象，所以这个onCreateLoader()调用的是我们自己实现的LoaderCallbacks里面的方法，所以说这个Loader对象现在是new CursorLoader()。 

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对象加入到集合中，如果下次需要加载同样的数据的话，就从集合中查找并直接返回LoaderInfo中携带的数据，避免了重复查询。 

void installLoader(LoaderInfo info) {
        mLoaders.put(info.mId, info);
        if (mStarted) {
            // The activity will start all existing loaders in it's onStart(),
            // so only start them here if we're past that point of the activitiy's
            // life cycle
            info.start();
        }
}

在上面的方法中，每一个新创建的LoaderInfo都会执行info.start()，那这个方法是启动什么的呢： 

void 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;
            }

            mStarted = true;
            
            if (DEBUG) Log.v(TAG, "  Starting: " + this);
            if (mLoader == null && mCallbacks != null) {
               mLoader = mCallbacks.onCreateLoader(mId, mArgs);
            }
            if (mLoader != null) {
                if (mLoader.getClass().isMemberClass()
                        && !Modifier.isStatic(mLoader.getClass().getModifiers())) {
                    throw new IllegalArgumentException(
                            "Object returned from onCreateLoader must not be a non-static inner member class: "
                            + mLoader);
                }
                if (!mListenerRegistered) {
                    mLoader.registerListener(mId, this);
                    mLoader.registerOnLoadCanceledListener(this);
                    mListenerRegistered = true;
                }
                mLoader.startLoading();
            }
        }

mLoader.registerListener(mId, this);注册监听，其实就是完成了回调机制的布置。
mLoader.startLoading()，单个数据的加载工作开始。是不是有点熟悉，首尾相连了有没有。
好了，至此，LoaderManager的大致工作流程，我们已经跟踪一遍。现在我们简单再总结一下。
   从我们自己实现的LoaderManager.LoaderCallbacks开始，它有两个方法：
onCreateLoader()：生成Loader的子类对象，返回给LoaderManager进行集中管理。
onLoadFinished()：LoaderManager决定Loader对象的启动、停止、保持、重启、关闭，如果得到数据，这个方法就会被回调，我们只需要在这里操作得到的数据就ok了。
补充：

 

LoaderManager
    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();
        }
}

Activity
    protected void onStart() {
        if (DEBUG_LIFECYCLE) Slog.v(TAG, "onStart " + this);
        mCalled = true;
        
        if (!mLoadersStarted) {
            mLoadersStarted = true;
            if (mLoaderManager != null) {
                mLoaderManager.doStart();
            } else if (!mCheckedForLoaderManager) {
                mLoaderManager = getLoaderManager("(root)", mLoadersStarted, false);
            }
            mCheckedForLoaderManager = true;
        }

        getApplication().dispatchActivityStarted(this);
    }

每次Activity的生命周期到onStart时，都会重新加载LoaderInfo集合中的所有Loader数据，见mLoaderManager.doStart();




 


android之LoaderManager原理分析

标签：

原文地址：http://blog.csdn.net/sjz4860402/article/details/51182380
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！