码迷,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
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!