Android 异步加载神器Loader全解析
在之前呢，我们经常会有这种需求，比如在某个activity，或者某个fragment里面，我们需要查找某个数据源，并且显示出来，当数据源自己更新的时候，界面也要及时响应。
当然咯，查找数据这个过程可能很短，但是也可能很漫长，为了避免anr，我们都是开启一个子线程去查找，然后通过handler来更新我们的ui界面。但是，考虑到activity和
fragment 复杂的生命周期，上述的方法 使用起来会很不方便，毕竟你要考虑到保存现场 还原现场 等等复杂的工作来保证你的app无懈可击。所以后来呢谷歌就帮我们推出了一个
新的东西---Loader。他可以帮我们完成上述所有功能！实在是很强大。
如果你有阅读英文技术文档的习惯 那么谷歌官方的文档 也许比我所说的更加完美。具体可以参考如下：
http://developer.android.com/intl/zh-cn/reference/android/app/LoaderManager.html
http://developer.android.com/intl/zh-cn/reference/android/content/AsyncTaskLoader.html
http://developer.android.com/intl/zh-cn/guide/components/loaders.html
我所述的内容也是主要基于上述三篇文档。
首先呢，我们来看第一个例子，这个例子也是官方的推荐了，我给简化了一下，主要是监听手机里 联系人这个数据源。当数据源改变的时候 自动update 我们的ui。
1 package com.example.administrator.modifytestview; 2 3 import android.app.Activity; 4 import android.app.FragmentManager; 5 import android.app.ListFragment; 6 import android.app.LoaderManager; 7 import android.content.CursorLoader; 8 import android.content.Loader; 9 import android.database.Cursor; 10 import android.net.Uri; 11 import android.os.Bundle; 12 import android.provider.ContactsContract.Contacts; 13 import android.util.Log; 14 import android.view.View; 15 import android.widget.ListView; 16 import android.widget.SimpleCursorAdapter; 17 18 public class MainActivity extends Activity { 19 20 21 @Override 22 protected void onCreate(Bundle savedInstanceState) { 23 super.onCreate(savedInstanceState); 24 setContentView(R.layout.activity_main); 25 FragmentManager fm = getFragmentManager(); 26 CursorLoaderListFragment list = new CursorLoaderListFragment(); 27 fm.beginTransaction().replace(R.id.root, list).commit(); 28 29 } 30 31 32 33 public static class CursorLoaderListFragment extends ListFragment 34 implements LoaderManager.LoaderCallbacks<Cursor> { 35 36 // This is the Adapter being used to display the list's data. 37 SimpleCursorAdapter mAdapter; 38 39 // If non-null, this is the current filter the user has provided. 40 String mCurFilter; 41 42 @Override 43 public void onActivityCreated(Bundle savedInstanceState) { 44 45 46 mAdapter = new SimpleCursorAdapter(getActivity(), 47 android.R.layout.simple_list_item_2, null, 48 new String[]{Contacts.DISPLAY_NAME, Contacts.CONTACT_STATUS}, 49 new int[]{android.R.id.text1, android.R.id.text2}, 0); 50 setListAdapter(mAdapter); 51 52 //这个地方初始化了我们的loader 53 getLoaderManager().initLoader(0, null, this); 54 55 super.onActivityCreated(savedInstanceState); 56 } 57 58 59 @Override 60 public void onListItemClick(ListView l, View v, int position, long id) { 61 // Insert desired behavior here. 62 Log.i("FragmentComplexList", "Item clicked: " + id); 63 } 64 65 // These are the Contacts rows that we will retrieve. 66 static final String[] CONTACTS_SUMMARY_PROJECTION = new String[]{ 67 Contacts._ID, 68 Contacts.DISPLAY_NAME, 69 Contacts.CONTACT_STATUS, 70 Contacts.CONTACT_PRESENCE, 71 Contacts.PHOTO_ID, 72 Contacts.LOOKUP_KEY, 73 }; 74 75 //只会调用一次 76 public Loader<Cursor> onCreateLoader(int id, Bundle args) { 77 // This is called when a new Loader needs to be created. This 78 // sample only has one Loader, so we don't care about the ID. 79 // First, pick the base URI to use depending on whether we are 80 // currently filtering. 81 Uri baseUri; 82 if (mCurFilter != null) { 83 baseUri = Uri.withAppendedPath(Contacts.CONTENT_FILTER_URI, 84 Uri.encode(mCurFilter)); 85 } else { 86 baseUri = Contacts.CONTENT_URI; 87 } 88 89 // Now create and return a CursorLoader that will take care of 90 // creating a Cursor for the data being displayed. 91 String select = "((" + Contacts.DISPLAY_NAME + " NOTNULL) AND (" 92 + Contacts.HAS_PHONE_NUMBER + "=1) AND (" 93 + Contacts.DISPLAY_NAME + " != '' ))"; 94 //返回的是对这个数据源的监控 95 return new CursorLoader(getActivity(), baseUri, 96 CONTACTS_SUMMARY_PROJECTION, select, null, 97 Contacts.DISPLAY_NAME + " COLLATE LOCALIZED ASC"); 98 } 99 100 //每次数据源都有更新的时候，就会回调这个方法，然后update 我们的ui了。 101 public void onLoadFinished(Loader<Cursor> loader, Cursor data) { 103 104 // Swap the new cursor in. (The framework will take care of closing the 105 // old cursor once we return.) 106 mAdapter.swapCursor(data); 107 108 // The list should now be shown. 109 if (isResumed()) { 110 setListShown(true); 111 } else { 112 setListShownNoAnimation(true); 113 } 114 } 115 116 public void onLoaderReset(Loader<Cursor> loader) { 117 // This is called when the last Cursor provided to onLoadFinished() 118 // above is about to be closed. We need to make sure we are no 119 // longer using it. 120 mAdapter.swapCursor(null); 121 } 122 } 123 124 }
可以仔细的观察一下这个代码，我们能发现 使用loader所需要的一些步骤：
1.需要一个activity或者是fragment，当然在上述的例子里 我们使用的是fragment。
2.一个LoaderManger的实例，注意看53行，我们get了一个loadermanager。这个地方就是获取实例了。
3.需要一个CursorLoader，并且从contentProvider获取数据源，90-97行 就是这么做的。
4.需要实现一个LoaderCallBack的这个接口，然后在几个回调方法里 写上我们自己业务的逻辑 即可。你看34行就是继承的接口。
还有3个回调方法在那，我们都在里面实现了自己的逻辑。
到这，其实一看，思路还是很清晰的。那到这里 有人肯定要说了。你这个没用啊，要实现contentprovider，我们的app不需要做
数据共享的，能否直接操作数据库呢？答案是可以的。在这里我们也可以构造出一个场景。假设有一张学生表。我们点击add
按钮，就自动往这个表里面增加一个数据，然后下面有个listview 会自动捕捉到 这个数据源的变化，然后自动更新列表。
我们可以知道 上面那个demo里面 CursorLoader的定义是这样的
1 public class CursorLoader extends AsyncTaskLoader<Cursor> {
我们现在要实现一个不用contentProvider的Loader 也是基于AsyncTaskLoader来的。
先给出一个抽象类：
1 package com.example.administrator.activeandroidtest3; 2 3 4 import android.content.AsyncTaskLoader; 5 import android.content.Context; 6 import android.database.Cursor; 7 8 9 public abstract class SimpleCursorLoader extends AsyncTaskLoader<Cursor> { 10 private Cursor mCursor; 11 12 public SimpleCursorLoader(Context context) { 13 super(context); 14 } 15 16 /* 在子线程里运作 */ 17 @Override 18 public abstract Cursor loadInBackground(); 19 20 /* 在ui 线程里运作 */ 21 @Override 22 public void deliverResult(Cursor cursor) { 23 if (isReset()) { 24 // An async query came in while the loader is stopped 25 if (cursor != null) { 26 cursor.close(); 27 } 28 return; 29 } 30 Cursor oldCursor = mCursor; 31 mCursor = cursor; 32 33 if (isStarted()) { 34 super.deliverResult(cursor); 35 } 36 37 if (oldCursor != null && oldCursor != cursor && !oldCursor.isClosed()) { 38 oldCursor.close(); 39 } 40 } 41 42 @Override 43 protected void onStartLoading() { 44 if (mCursor != null) { 45 deliverResult(mCursor); 46 } 47 if (takeContentChanged() || mCursor == null) { 48 forceLoad(); 49 } 50 } 51 52 @Override 53 protected void onStopLoading() { 54 cancelLoad(); 55 } 56 57 @Override 58 public void onCanceled(Cursor cursor) { 59 if (cursor != null && !cursor.isClosed()) { 60 cursor.close(); 61 } 62 } 63 64 @Override 65 protected void onReset() { 66 super.onReset(); 67 68 onStopLoading(); 69 70 if (mCursor != null && !mCursor.isClosed()) { 71 mCursor.close(); 72 } 73 mCursor = null; 74 } 75 }
然后我们再接着定义我们最终的 不需要provider的loader实现类(注意你如果想写的比较完美的话 cursor记得用抽象类的，抽象类的那个就不要写成private的了，我这里为了图简单 直接用自己构造的)。
1 package com.example.administrator.activeandroidtest3; 2 3 import android.content.Context; 4 import android.database.Cursor; 5 import android.database.sqlite.SQLiteDatabase; 6 7 /** 8 * Created by Administrator on 2015/10/7. 9 */ 10 public class SpecialLoader extends SimpleCursorLoader { 11 12 ForceLoadContentObserver mObserver = new ForceLoadContentObserver(); 13 private Context context; 14 15 public SpecialLoader(Context context) { 16 super(context); 17 this.context = context; 18 19 } 20 21 @Override 22 public Cursor loadInBackground() { 23 DatabaseHelper dh = new DatabaseHelper(context, "Test.db"); 24 SQLiteDatabase database = dh.getReadableDatabase(); 25 String table = "Student"; 26 String[] columns = new String[]{"Name", "No"}; 27 //这个地方因为我用的是activeandroid 的orm 框架，所以默认的自增长主键是Id，但是SimpleCursorAdapter 28 //需要的是_id 否则会报错，所以这里要重命名一下 29 Cursor cursor = database.rawQuery("SELECT Id AS _id,Name,No FROM Student", null); 30 if (database != null) { 31 if (cursor != null) { 32 //注册一下这个观察者 33 cursor.registerContentObserver(mObserver); 34 //这边也要注意 一定要监听这个uri的变化。但是如果你这个uri没有对应的provider的话 35 //记得在你操作数据库的时候 通知一下这个uri 36 cursor.setNotificationUri(context.getContentResolver(), MainActivity.uri); 37 } 38 39 } 40 return cursor; 41 } 42 }
然后我们在简单看下activity 主类里的代码：
1 package com.example.administrator.activeandroidtest3; 2 3 import android.app.Activity; 4 import android.app.LoaderManager; 5 import android.content.Loader; 6 import android.database.Cursor; 7 import android.net.Uri; 8 import android.os.Bundle; 9 import android.util.Log; 10 import android.view.Menu; 11 import android.view.MenuItem; 12 import android.view.View; 13 import android.widget.ListView; 14 import android.widget.SimpleCursorAdapter; 15 import android.widget.TextView; 16 17 import com.activeandroid.query.Select; 18 19 import java.util.List; 20 import java.util.Random; 21 22 public class MainActivity extends Activity implements LoaderManager.LoaderCallbacks { 23 24 public static final Uri uri = Uri.parse("content://com.example.student"); 25 private TextView addTv; 26 private ListView lv; 27 private SimpleCursorAdapter adapter; 28 29 @Override 30 protected void onCreate(Bundle savedInstanceState) { 31 super.onCreate(savedInstanceState); 32 setContentView(R.layout.activity_main); 33 addTv = (TextView) this.findViewById(R.id.add); 34 addTv.setOnClickListener(new View.OnClickListener() { 35 @Override 36 public void onClick(View v) { 37 Student student = new Student(); 38 student.name = getRandomString(5); 39 student.no = (int) (Math.random() * 1000) + ""; 40 student.sex = (int) (Math.random() * 1); 41 student.save(); 42 //操作完数据库要notify 不然loader那边收不到哦 43 getContentResolver().notifyChange(uri, null); 44 45 } 46 }); 47 lv = (ListView) this.findViewById(R.id.lv); 48 adapter = new SimpleCursorAdapter(MainActivity.this, 49 android.R.layout.simple_list_item_2, null, 50 new String[]{"Name", "No"}, 51 new int[]{android.R.id.text1, android.R.id.text2}, 0); 52 lv.setAdapter(adapter); 53 getLoaderManager().initLoader(0, null, this); 54 } 55 56 @Override 57 public boolean onCreateOptionsMenu(Menu menu) { 58 // Inflate the menu; this adds items to the action bar if it is present. 59 getMenuInflater().inflate(R.menu.menu_main, menu); 60 return true; 61 } 62 63 @Override 64 public boolean onOptionsItemSelected(MenuItem item) { 65 // Handle action bar item clicks here. The action bar will 66 // automatically handle clicks on the Home/Up button, so long 67 // as you specify a parent activity in AndroidManifest.xml. 68 int id = item.getItemId(); 69 70 //noinspection SimplifiableIfStatement 71 if (id == R.id.action_settings) { 72 return true; 73 } 74 75 return super.onOptionsItemSelected(item); 76 } 77 78 79 public static String getRandomString(int length) { //length表示生成字符串的长度 80 String base = "abcdefghijklmnopqrstuvwxyz0123456789"; 81 Random random = new Random(); 82 StringBuffer sb = new StringBuffer(); 83 for (int i = 0; i < length; i++) { 84 int number = random.nextInt(base.length()); 85 sb.append(base.charAt(number)); 86 } 87 return sb.toString(); 88 } 89 90 91 @Override 92 public Loader onCreateLoader(int id, Bundle args) { 93 SpecialLoader loader = new SpecialLoader(MainActivity.this); 94 return loader; 95 } 96 97 @Override 98 public void onLoadFinished(Loader loader, Object data) { 99 adapter.swapCursor((Cursor) data); 100 } 101 102 @Override 103 public void onLoaderReset(Loader loader) { 104 105 } 106 }
最后我们看下运行的效果：
好，那到这里 又有人要说了，你这个说来说去 还不是只能支持provider或者db类型的数据源吗？好 接着往下，
我们给出另外一个例子，不过这个例子是谷歌官方的例子，我就取其中重要的部分给予注释讲解。
http://developer.android.com/intl/zh-cn/reference/android/content/AsyncTaskLoader.html
首先说一下 这个例子是干嘛的，他主要是监听手机里app list的变化，比如你删除了一个应用
安装了一个应用，马上就能捕捉到你的手机里app list的变化 并显示在界面，大家都知道 监听app list
是通过监听系统广播来完成的。 我就主要讲一下 这个官方demo里 是如何在监听到系统广播以后和loader结合起来
然后自动回调方法的。
1 /** 2 * Helper class to look for interesting changes to the installed apps 3 * so that the loader can be updated. 4 */ 5 public static class PackageIntentReceiver extends BroadcastReceiver { 6 final AppListLoader mLoader; 7 8 //这个构造函数是很重要的 他接收的 就是自定义的loader 9 public PackageIntentReceiver(AppListLoader loader) { 10 mLoader = loader; 11 IntentFilter filter = new IntentFilter(Intent.ACTION_PACKAGE_ADDED); 12 filter.addAction(Intent.ACTION_PACKAGE_REMOVED); 13 filter.addAction(Intent.ACTION_PACKAGE_CHANGED); 14 filter.addDataScheme("package"); 15 mLoader.getContext().registerReceiver(this, filter); 16 // Register for events related to sdcard installation. 17 IntentFilter sdFilter = new IntentFilter(); 18 sdFilter.addAction(Intent.ACTION_EXTERNAL_APPLICATIONS_AVAILABLE); 19 sdFilter.addAction(Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE); 20 //在这个地方 直接用loader来注册这个广播接收器 21 mLoader.getContext().registerReceiver(this, sdFilter); 22 } 23 24 //在收到广播以后 什么事情都没有做，而是调用了loader的onContentChanged方法 25 @Override public void onReceive(Context context, Intent intent) { 26 // Tell the loader about the change. 27 mLoader.onContentChanged(); 28 } 29 }
你看这里的25-26行 调用了 loader的onContentChanged方法。继续看下面的loader
1 /** 2 * A custom Loader that loads all of the installed applications. 3 */ 4 public static class AppListLoader extends AsyncTaskLoader<List<AppEntry>> { 5 final InterestingConfigChanges mLastConfig = new InterestingConfigChanges(); 6 final PackageManager mPm; 7 8 List<AppEntry> mApps; 9 PackageIntentReceiver mPackageObserver; 10 11 public AppListLoader(Context context) { 12 super(context); 13 14 // Retrieve the package manager for later use; note we don't 15 // use 'context' directly but instead the save global application 16 // context returned by getContext(). 17 mPm = getContext().getPackageManager(); 18 } 19 20 //实际上最重要的就是这个方法了，每当这个回调方法被调用的时候 就去取applist 然后将结果返回到 21 //onLoadFinished 这个回调方法里面！ 22 @Override public List<AppEntry> loadInBackground() { 23 // Retrieve all known applications. 24 List<ApplicationInfo> apps = mPm.getInstalledApplications( 25 PackageManager.GET_UNINSTALLED_PACKAGES | 26 PackageManager.GET_DISABLED_COMPONENTS); 27 if (apps == null) { 28 apps = new ArrayList<ApplicationInfo>(); 29 } 30 31 final Context context = getContext(); 32 33 // Create corresponding array of entries and load their labels. 34 List<AppEntry> entries = new ArrayList<AppEntry>(apps.size()); 35 for (int i=0; i<apps.size(); i++) { 36 AppEntry entry = new AppEntry(this, apps.get(i)); 37 entry.loadLabel(context); 38 entries.add(entry); 39 } 40 41 // Sort the list. 42 Collections.sort(entries, ALPHA_COMPARATOR); 43 44 // Done! 45 return entries; 46 } 47 48 /** 49 * Called when there is new data to deliver to the client. The 50 * super class will take care of delivering it; the implementation 51 * here just adds a little more logic. 52 */ 53 @Override public void deliverResult(List<AppEntry> apps) { 54 if (isReset()) { 55 // An async query came in while the loader is stopped. We 56 // don't need the result. 57 if (apps != null) { 58 onReleaseResources(apps); 59 } 60 } 61 List<AppEntry> oldApps = mApps; 62 mApps = apps; 63 64 if (isStarted()) { 65 // If the Loader is currently started, we can immediately 66 // deliver its results. 67 super.deliverResult(apps); 68 } 69 70 // At this point we can release the resources associated with 71 // 'oldApps' if needed; now that the new result is delivered we 72 // know that it is no longer in use. 73 if (oldApps != null) { 74 onReleaseResources(oldApps); 75 } 76 } 77 78 /** 79 * Handles a request to start the Loader. 80 */ 81 @Override protected void onStartLoading() { 82 if (mApps != null) { 83 // If we currently have a result available, deliver it 84 // immediately. 85 deliverResult(mApps); 86 } 87 88 // Start watching for changes in the app data. 89 if (mPackageObserver == null) { 90 mPackageObserver = new PackageIntentReceiver(this); 91 } 92 93 // Has something interesting in the configuration changed since we 94 // last built the app list? 95 boolean configChange = mLastConfig.applyNewConfig(getContext().getResources()); 96 97 if (takeContentChanged() || mApps == null || configChange) { 98 // If the data has changed since the last time it was loaded 99 // or is not currently available, start a load. 100 forceLoad(); 101 } 102 } 103 104 /** 105 * Handles a request to stop the Loader. 106 */ 107 @Override protected void onStopLoading() { 108 // Attempt to cancel the current load task if possible. 109 cancelLoad(); 110 } 111 112 /** 113 * Handles a request to cancel a load. 114 */ 115 @Override public void onCanceled(List<AppEntry> apps) { 116 super.onCanceled(apps); 117 118 // At this point we can release the resources associated with 'apps' 119 // if needed. 120 onReleaseResources(apps); 121 } 122 123 /** 124 * Handles a request to completely reset the Loader. 125 */ 126 @Override protected void onReset() { 127 super.onReset(); 128 129 // Ensure the loader is stopped 130 onStopLoading(); 131 132 // At this point we can release the resources associated with 'apps' 133 // if needed. 134 if (mApps != null) { 135 onReleaseResources(mApps); 136 mApps = null; 137 } 138 139 // Stop monitoring for changes. 140 if (mPackageObserver != null) { 141 getContext().unregisterReceiver(mPackageObserver); 142 mPackageObserver = null; 143 } 144 } 145 146 /** 147 * Helper function to take care of releasing resources associated 148 * with an actively loaded data set. 149 */ 150 protected void onReleaseResources(List<AppEntry> apps) { 151 // For a simple List<> there is nothing to do. For something 152 // like a Cursor, we would close it here. 153 } 154 }
好，到这里流程就很明显了，在loader里 注册广播接收器，当广播接收器 收到广播以后 就调用loader的onContentChanged方法，
这个方法一调用 AppListLoader里的loadInBackGround就会被调用，然后当loadInBackGround执行完毕以后 就会把结果
传递给onLoadFinished方法了。 搞清楚这个流程 你就真正学会了使用loader这个大杀器了。当然了，我们并不满足于此，loader
还有一个特性就是可以自动管理他自己的生命周期 等等。我们现在就去看看他的源码，是如何完成这一点的。 并且上述几个方法
之间是如何相互调用的，顺序如何。
首先 我们要搞清楚几个类之间的关系：
1 public class CursorLoader extends AsyncTaskLoader<Cursor> { 2 3 4 public abstract class AsyncTaskLoader<D> extends Loader<D> { 5 6 public class Loader<D> {
这样就很清晰。首先由一个实体类作为最基础的基类，Loader 注意他可以接受一个泛型为参数，然后有一个抽象类：AsyncTaskLoader 也是泛型作为参数。
最后实际调用运作的类就是CursorLoader类了，这里就可以看出来 传进去的泛型是一个Cursor。你在自定义Loader的时候，这个泛型参数 当然是可以自己决定的，
比如官方demo里 传的就是一个List。
搞清楚 他们三者之间的关系，剩下的就简单多了。可以逐步分析了。
在前面的3个demo里，我们分别演示了在fragment和activity里 调用loader的方法。 那我们就看看 这两者之间有什么异同点。先来看fragment。
fragment里 我们是这样调用的：
1 //这个地方初始化了我们的loader 2 getLoaderManager().initLoader(0, null, this);
直接get了一个manager 然后init他。我们进去看fragment的源码：
1 //这边就能看出来一个fragment只能有一个loadermanager了。 2 public LoaderManager getLoaderManager() { 3 4 if (mLoaderManager != null) { 5 return mLoaderManager; 6 } 7 //mHost很好理解 就是fragment的宿主，也就是跟fragment 相关联的activity。 8 if (mHost == null) { 9 throw new IllegalStateException("Fragment " + this + " not attached to Activity"); 10 } 11 mCheckedForLoaderManager = true; 12 mLoaderManager = mHost.getLoaderManager(mWho, mLoadersStarted, true); 13 return mLoaderManager; 14 }
既然 我们知道 fragment的getLoaderManager也是通过activity的getLoader去调用的，那我们就去activity里的源码看看 ：
1 //在activty中最终实际上调用的就是他了 是这个方法 2 LoaderManagerImpl getLoaderManagerImpl() { 3 if (mLoaderManager != null) { 4 return mLoaderManager; 5 } 6 mCheckedForLoaderManager = true; 7 mLoaderManager = getLoaderManager("(root)", mLoadersStarted, true /*create*/); 8 return mLoaderManager; 9 } 10 11 //这个地方就能看到 主要的第一个参数 who，你到这就能发现 如果是activity自己调用的话，传进去的who的值就是root 12 //也就是说一个actvity 只能有一个loadermanger 但是我们可以发现在fragment里 传进去的值是下面这个： 13 // Internal unique name for this fragment; 14 //String mWho; 15 //也就是说每一个fragment的mWho的值都是唯一的，而在activty中，是维护了一个map，一个key 对应一个loadermanager 16 //key就是fragment的那个唯一的标示，或者是activity自己，activity自己的标示就是（root)了 17 LoaderManagerImpl getLoaderManager(String who, boolean started, boolean create) { 18 if (mAllLoaderManagers == null) { 19 mAllLoaderManagers = new ArrayMap<String, LoaderManager>(); 20 } 21 LoaderManagerImpl lm = (LoaderManagerImpl) mAllLoaderManagers.get(who); 22 if (lm == null) { 23 if (create) { 24 lm = new LoaderManagerImpl(who, this, started); 25 mAllLoaderManagers.put(who, lm); 26 } 27 } else { 28 lm.updateHostController(this); 29 } 30 return lm; 31 }
好 一直到这里 ，我们就可以下一个结论了，真正的loadermanager都是存储在activity中的，包括fragment的loadermanager也是，通过一个map来保证 get的时候
取的manager是自己对应的，并且全局唯一。继续往下看：
1 public abstract class LoaderManager { 2 /** 3 * Callback interface for a client to interact with the manager. 4 */ 5 public interface LoaderCallbacks<D> { 6 /** 7 * Instantiate and return a new Loader for the given ID. 8 * 9 * @param id The ID whose loader is to be created. 10 * @param args Any arguments supplied by the caller. 11 * @return Return a new Loader instance that is ready to start loading. 12 */ 13 public Loader<D> onCreateLoader(int id, Bundle args); 14 15 /** 16 * Called when a previously created loader has finished its load. Note 17 * that normally an application is <em>not</em> allowed to commit fragment 18 * transactions while in this call, since it can happen after an 19 * activity's state is saved. See {@link FragmentManager#beginTransaction() 20 * FragmentManager.openTransaction()} for further discussion on this. 21 * 22 * <p>This function is guaranteed to be called prior to the release of 23 * the last data that was supplied for this Loader. At this point 24 * you should remove all use of the old data (since it will be released 25 * soon), but should not do your own release of the data since its Loader 26 * owns it and will take care of that. The Loader will take care of 27 * management of its data so you don't have to. In particular: 28 * 29 * <ul> 30 * <li> <p>The Loader will monitor for changes to the data, and report 31 * them to you through new calls here. You should not monitor the 32 * data yourself. For example, if the data is a {@link android.database.Cursor} 33 * and you place it in a {@link android.widget.CursorAdapter}, use 34 * the {@link android.widget.CursorAdapter#CursorAdapter(android.content.Context, 35 * android.database.Cursor, int)} constructor <em>without</em> passing 36 * in either {@link android.widget.CursorAdapter#FLAG_AUTO_REQUERY} 37 * or {@link android.widget.CursorAdapter#FLAG_REGISTER_CONTENT_OBSERVER} 38 * (that is, use 0 for the flags argument). This prevents the CursorAdapter 39 * from doing its own observing of the Cursor, which is not needed since 40 * when a change happens you will get a new Cursor throw another call 41 * here. 42 * <li> The Loader will release the data once it knows the application 43 * is no longer using it. For example, if the data is 44 * a {@link android.database.Cursor} from a {@link android.content.CursorLoader}, 45 * you should not call close() on it yourself. If the Cursor is being placed in a 46 * {@link android.widget.CursorAdapter}, you should use the 47 * {@link android.widget.CursorAdapter#swapCursor(android.database.Cursor)} 48 * method so that the old Cursor is not closed. 49 * </ul> 50 * 51 * @param loader The Loader that has finished. 52 * @param data The data generated by the Loader. 53 */ 54 public void onLoadFinished(Loader<D> loader, D data); 55 56 /** 57 * Called when a previously created loader is being reset, and thus 58 * making its data unavailable. The application should at this point 59 * remove any references it has to the Loader's data. 60 * 61 * @param loader The Loader that is being reset. 62 */ 63 public void onLoaderReset(Loader<D> loader); 64 }
一看就知道 loadermanger 其实是一个抽象类。就是定义了一些 我们需要的接口而已，这些接口方法的含义和用法 在那3个demo里 相信大家都有了解，不多说。
我们去看看这个抽象类的实现类，为什么要看他，因为你在get到这个maganger以后 马上就去调用了他的init方法 我们就看看这部分的逻辑是怎么样的：
1 public <D> Loader<D> initLoader(int id, Bundle args, LoaderManager.LoaderCallbacks<D> callback) { 2 if (mCreatingLoader) { 3 throw new IllegalStateException("Called while creating a loader"); 4 } 5 6 //这个就是先看看是否有活动的loader 有的话就取出来 没有的话 就创建一个 7 LoaderInfo info = mLoaders.get(id); 8 9 if (DEBUG) Log.v(TAG, "initLoader in " + this + ": args=" + args); 10 11 if (info == null) { 12 // Loader doesn't already exist; create. 13 info = createAndInstallLoader(id, args, (LoaderManager.LoaderCallbacks<Object>)callback); 14 if (DEBUG) Log.v(TAG, " Created new loader " + info); 15 } else { 16 if (DEBUG) Log.v(TAG, " Re-using existing loader " + info); 17 info.mCallbacks = (LoaderManager.LoaderCallbacks<Object>)callback; 18 } 19 20 if (info.mHaveData && mStarted) { 21 // If the loader has already generated its data, report it now. 22 info.callOnLoadFinished(info.mLoader, info.mData); 23 } 24 25 return (Loader<D>)info.mLoader; 26 } 27 28 //这个就是现在存活的loader 29 final SparseArray<LoaderInfo> mLoaders = new SparseArray<LoaderInfo>(0); 30 31 //这个是已经运行结束的loader 32 final SparseArray<LoaderInfo> mInactiveLoaders = new SparseArray<LoaderInfo>(0); 33 34 //其实这个创建loader的过程特别简单，我们主要看第三个参数，callback 这个参数 35 //一想就明白，在前面3个demo里我们是直接在fragemet和activity里实现的callback 36 //所以传进去的就是this，也就是说 回调就是在这个函数里 真正的和loader 发生了关联了 37 private LoaderInfo createAndInstallLoader(int id, Bundle args, 38 LoaderManager.LoaderCallbacks<Object> callback) { 39 try { 40 mCreatingLoader = true; 41 LoaderInfo info = createLoader(id, args, callback); 42 installLoader(info); 43 return info; 44 } finally { 45 mCreatingLoader = false; 46 } 47 }
你看 一直到这里，我们就明白了 callback是怎么和loadermageer本身发生关联的。 我们继续往下看。这次我们要搞明白
当数据源发生变化的时候 是怎么一步步回调我们子类loader的方法的。
我们先看Loader这个基类的主要方法：
1 2 3 //这个是一个观察者 当发生变化的时候 他调用了onContentChanged方法 4 public final class ForceLoadContentObserver extends ContentObserver { 5 public ForceLoadContentObserver() { 6 super(new Handler()); 7 } 8 9 @Override 10 public boolean deliverSelfNotifications() { 11 return true; 12 } 13 14 @Override 15 public void onChange(boolean selfChange) { 16 onContentChanged(); 17 } 18 } 19 20 //下面这2个方法一看就明白 最终当数据源发生变化的时候 会通知这个观察者，然后这个观察者会最终调用 21 //onForceLoad这个方法 而onForceLoad是交给子类去实现的 也就是AsyncTaskLoader的onForceLoad方法了 22 public void onContentChanged() { 23 if (mStarted) { 24 forceLoad(); 25 } else { 26 // This loader has been stopped, so we don't want to load 27 // new data right now... but keep track of it changing to 28 // refresh later if we start again. 29 mContentChanged = true; 30 } 31 } 32 33 public void forceLoad() { 34 onForceLoad(); 35 } 36 37 /** 38 * Subclasses must implement this to take care of requests to {@link #forceLoad()}. 39 * This will always be called from the process's main thread. 40 */ 41 protected void onForceLoad() { 42 }
然后看看AsyncTaskLoader的几个主要方法：
1 //这边一目了然 asynacTaskLoader 里面 正好是有一个AsyncTask对象的！实现了runnabele接口 2 //注意着参数d 这个d是干嘛的，这个d就是用来传递参数的一个泛型，可以是系统实现的loader里的cursor 3 //也可以是我们自己实现的loader里的list类型 4 final class LoadTask extends AsyncTask<Void, Void, D> implements Runnable { 5 private final CountDownLatch mDone = new CountDownLatch(1); 6 7 // Set to true to indicate that the task has been posted to a handler for 8 // execution at a later time. Used to throttle updates. 9 boolean waiting; 10 11 /* Runs on a worker thread */ 12 @Override 13 protected D doInBackground(Void... params) { 14 if (DEBUG) Log.v(TAG, this + " >>> doInBackground"); 15 try { 16 //这个地方就很明显了，他调用了自己的onLoadInBackGround方法 17 D data = AsyncTaskLoader.this.onLoadInBackground(); 18 if (DEBUG) Log.v(TAG, this + " <<< doInBackground"); 19 return data; 20 } catch (OperationCanceledException ex) { 21 if (!isCancelled()) { 22 // onLoadInBackground threw a canceled exception spuriously. 23 // This is problematic because it means that the LoaderManager did not 24 // cancel the Loader itself and still expects to receive a result. 25 // Additionally, the Loader's own state will not have been updated to 26 // reflect the fact that the task was being canceled. 27 // So we treat this case as an unhandled exception. 28 throw ex; 29 } 30 if (DEBUG) Log.v(TAG, this + " <<< doInBackground (was canceled)", ex); 31 return null; 32 } 33 } 34 //后面还有很多代码 略过 35 } 36 37 //你看这里下面的2个函数 一看就明白了 最终task里调用的是这个抽象方法，那这个抽象方法 38 //就是留给我们子类自己去实现的，我们在自定义loader的时候最重要的就是重写这个方法。 39 protected D onLoadInBackground() { 40 return loadInBackground(); 41 } 42 43 public abstract D loadInBackground(); 44 45 //你看这个地方 就是当数据源发生变化的时候 就会调用这个方法了，启动了我们的laodtask 46 //也是最终调用子类 也就是CursorLoader这样的子类的loadInBackground方法了 47 @Override 48 protected void onForceLoad() { 49 super.onForceLoad(); 50 cancelLoad(); 51 mTask = new LoadTask(); 52 if (DEBUG) Log.v(TAG, "Preparing load: mTask=" + mTask); 53 executePendingTask(); 54 }
相信到这里 大家一定能搞明白数据源变化的时候 是怎么一步步调用我们的loader里的回调方法的，那有人肯定要继续问
当你这个方法调用完毕的时候 是怎么通知最后updateUI呢，也就是当你background方法结束以后是怎么调用的
onLoadFinished方法的呢？
我们继续看AsyncTaskLoader这个类
1 2 //在那个asynctask里面 走完是肯定要走这个方法的 相信大家都能理解。 3 @Override 4 protected void onPostExecute(D data) { 5 if (DEBUG) Log.v(TAG, this + " onPostExecute"); 6 try { 7 AsyncTaskLoader.this.dispatchOnLoadComplete(this, data); 8 } finally { 9 mDone.countDown(); 10 } 11 } 12 //实际上走的就是这个方法。看26行- 13 void dispatchOnLoadComplete(LoadTask task, D data) { 14 if (mTask != task) { 15 if (DEBUG) Log.v(TAG, "Load complete of old task, trying to cancel"); 16 dispatchOnCancelled(task, data); 17 } else { 18 if (isAbandoned()) { 19 // This cursor has been abandoned; just cancel the new data. 20 onCanceled(data); 21 } else { 22 commitContentChanged(); 23 mLastLoadCompleteTime = SystemClock.uptimeMillis(); 24 mTask = null; 25 if (DEBUG) Log.v(TAG, "Delivering result"); 26 deliverResult(data); 27 } 28 } 29 } 30 31 //这边一下就看出来是调用的mListtenr的回调方法 32 public void deliverResult(D data) { 33 if (mListener != null) { 34 mListener.onLoadComplete(this, data); 35 } 36 }
实际上这个Listener就是在Loader这个基类里：
1 OnLoadCompleteListener<D> mListener; 2 3 public interface OnLoadCompleteListener<D> { 4 /** 5 * Called on the thread that created the Loader when the load is complete. 6 * 7 * @param loader the loader that completed the load 8 * @param data the result of the load 9 */ 10 public void onLoadComplete(Loader<D> loader, D data); 11 } 12 13 //并且通过这个注册 14 public void registerListener(int id, OnLoadCompleteListener<D> listener) { 15 if (mListener != null) { 16 throw new IllegalStateException("There is already a listener registered"); 17 } 18 mListener = listener; 19 mId = id; 20 }
那就好了 我们就是要看一下 是在哪个地方调用的registerlistener这个方法 注册他的
1 2 //回到initLoader的这个方法 注意这个方法是在LoaderManger里面 3 public <D> Loader<D> initLoader(int id, Bundle args, LoaderManager.LoaderCallbacks<D> callback) { 4 if (mCreatingLoader) { 5 throw new IllegalStateException("Called while creating a loader"); 6 } 7 8 LoaderInfo info = mLoaders.get(id); 9 10 if (DEBUG) Log.v(TAG, "initLoader in " + this + ": args=" + args); 11 12 if (info == null) { 13 //下面的代码跳转到30行 14 info = createAndInstallLoader(id, args, (LoaderManager.LoaderCallbacks<Object>)callback); 15 if (DEBUG) Log.v(TAG, " Created new loader " + info); 16 } else { 17 if (DEBUG) Log.v(TAG, " Re-using existing loader " + info); 18 info.mCallbacks = (LoaderManager.LoaderCallbacks<Object>)callback; 19 } 20 21 if (info.mHaveData && mStarted) { 22 // If the loader has already generated its data, report it now. 23 info.callOnLoadFinished(info.mLoader, info.mData); 24 } 25 26 return (Loader<D>)info.mLoader; 27 } 28 29 30 private LoaderInfo createAndInstallLoader(int id, Bundle args, 31 LoaderManager.LoaderCallbacks<Object> callback) { 32 try { 33 mCreatingLoader = true; 34 LoaderInfo info = createLoader(id, args, callback); 35 //这里跳转到43行 36 installLoader(info); 37 return info; 38 } finally { 39 mCreatingLoader = false; 40 } 41 } 42 43 void installLoader(LoaderInfo info) { 44 mLoaders.put(info.mId, info); 45 if (mStarted) { 46 //跳转到51行 47 info.start(); 48 } 49 } 50 51 void start() { 52 if (mRetaining && mRetainingStarted) { 53 // Our owner is started, but we were being retained from a 54 // previous instance in the started state... so there is really 55 // nothing to do here, since the loaders are still started. 56 mStarted = true; 57 return; 58 } 59 60 if (mStarted) { 61 // If loader already started, don't restart. 62 return; 63 } 64 65 mStarted = true; 66 67 if (DEBUG) Log.v(TAG, " Starting: " + this); 68 if (mLoader == null && mCallbacks != null) { 69 mLoader = mCallbacks.onCreateLoader(mId, mArgs); 70 } 71 if (mLoader != null) { 72 if (mLoader.getClass().isMemberClass() 73 && !Modifier.isStatic(mLoader.getClass().getModifiers())) { 74 throw new IllegalArgumentException( 75 "Object returned from onCreateLoader must not be a non-static inner member class: " 76 + mLoader); 77 } 78 if (!mListenerRegistered) { 79 //就是在这里注册的mloader里的回调了，注意这里的参数是this 也就是loaderInfo这个类 注意这个类就是loadermanger里的内部类了 再继续往下看 80 //我们前面说到 在asynctask里面最终调用的是mLoader里的onLoadComplete方法 所以我们就看看loaderInfo这个类里的这个方法做了什么看91行 81 mLoader.registerListener(mId, this); 82 mLoader.registerOnLoadCanceledListener(this); 83 mListenerRegistered = true; 84 } 85 mLoader.startLoading(); 86 } 87 } 88 89 90 91 @Override 92 public void onLoadComplete(Loader<Object> loader, Object data) { 93 if (DEBUG) Log.v(TAG, "onLoadComplete: " + this); 94 95 if (mDestroyed) { 96 if (DEBUG) Log.v(TAG, " Ignoring load complete -- destroyed"); 97 return; 98 } 99 100 if (mLoaders.get(mId) != this) { 101 // This data is not coming from the current active loader. 102 // We don't care about it. 103 if (DEBUG) Log.v(TAG, " Ignoring load complete -- not active"); 104 return; 105 } 106 107 LoaderInfo pending = mPendingLoader; 108 if (pending != null) { 109 // There is a new request pending and we were just 110 // waiting for the old one to complete before starting 111 // it. So now it is time, switch over to the new loader. 112 if (DEBUG) Log.v(TAG, " Switching to pending loader: " + pending); 113 mPendingLoader = null; 114 mLoaders.put(mId, null); 115 destroy(); 116 installLoader(pending); 117 return; 118 } 119 120 // Notify of the new data so the app can switch out the old data before 121 // we try to destroy it. 122 if (mData != data || !mHaveData) { 123 mData = data; 124 mHaveData = true; 125 if (mStarted) { 126 //继续往下 看第149行 127 callOnLoadFinished(loader, data); 128 } 129 } 130 131 //if (DEBUG) Log.v(TAG, " onLoadFinished returned: " + this); 132 133 // We have now given the application the new loader with its 134 // loaded data, so it should have stopped using the previous 135 // loader. If there is a previous loader on the inactive list, 136 // clean it up. 137 LoaderInfo info = mInactiveLoaders.get(mId); 138 if (info != null && info != this) { 139 info.mDeliveredData = false; 140 info.destroy(); 141 mInactiveLoaders.remove(mId); 142 } 143 144 if (mHost != null && !hasRunningLoaders()) { 145 mHost.mFragmentManager.startPendingDeferredFragments(); 146 } 147 } 148 149 void callOnLoadFinished(Loader<Object> loader, Object data) { 150 if (mCallbacks != null) { 151 String lastBecause = null; 152 if (mHost != null) { 153 lastBecause = mHost.mFragmentManager.mNoTransactionsBecause; 154 mHost.mFragmentManager.mNoTransactionsBecause = "onLoadFinished"; 155 } 156 try { 157 if (DEBUG) Log.v(TAG, " onLoadFinished in " + loader + ": " 158 + loader.dataToString(data)); 159 //到这里就真相大白了，最终callback是在这里调用的onLoadFinished方法也就是我们经常重写的方法 160 mCallbacks.onLoadFinished(loader, data); 161 } finally { 162 if (mHost != null) { 163 mHost.mFragmentManager.mNoTransactionsBecause = lastBecause; 164 } 165 } 166 mDeliveredData = true; 167 } 168 }
好，到这里 我们就把Loader框架中的 数据传递 整个流程给摸清楚了。最后我们再来看看 他的生命周期是如何管理的吧。
我们可以先看看activity的：
1 //看activity的onStart方法 2 protected void onStart() { 3 if (DEBUG_LIFECYCLE) Slog.v(TAG, "onStart " + this); 4 mCalled = true; 5 //继续看12行 这个地方mFragements 你就理解成activity本身即可，不多做解释 这个地方要搞清楚 又是另外一块了 有兴趣的可以自行谷歌activity和fragment如何建立关系 6 mFragments.doLoaderStart(); 7 8 getApplication().dispatchActivityStarted(this); 9 } 10 11 //这个函数就很明显了 调用了manager的dostart函数 12 void doLoaderStart() { 13 if (mLoadersStarted) { 14 return; 15 } 16 mLoadersStarted = true; 17 18 if (mLoaderManager != null) { 19 //跳转到30行 20 mLoaderManager.doStart(); 21 } else if (!mCheckedForLoaderManager) { 22 mLoaderManager = getLoaderManager("(root)", mLoadersStarted, false); 23 } 24 mCheckedForLoaderManager = true; 25 } 26 27 //------------------注意上面的代码都在activity里，下面的开始 都在LoaderManger类里了 28 29 void doStart() { 30 if (DEBUG) Log.v(TAG, "Starting in " + this); 31 if (mStarted) { 32 RuntimeException e = new RuntimeException("here"); 33 e.fillInStackTrace(); 34 Log.w(TAG, "Called doStart when already started: " + this, e); 35 return; 36 } 37 38 mStarted = true; 39 40 // Call out to sub classes so they can start their loaders 41 // Let the existing loaders know that we want to be notified when a load is complete 42 for (int i = mLoaders.size()-1; i >= 0; i--) { 43 //跳转到50行 44 mLoaders.valueAt(i).start(); 45 } 46 } 47 48 49 void start() { 50 if (mRetaining && mRetainingStarted) { 51 // Our owner is started, but we were being retained from a 52 // previous instance in the started state... so there is really 53 // nothing to do here, since the loaders are still started. 54 mStarted = true; 55 return; 56 } 57 58 if (mStarted) { 59 // If loader already started, don't restart. 60 return; 61 } 62 63 mStarted = true; 64 65 if (DEBUG) Log.v(TAG, " Starting: " + this); 66 if (mLoader == null && mCallbacks != null) { 67 //原来onCreateLoader这个回调方法 是在这里调用的 怪不得谷歌说这个方法是必定会被执行并且只会被执行一次的方法！ 68 mLoader = mCallbacks.onCreateLoader(mId, mArgs); 69 } 70 if (mLoader != null) { 71 if (mLoader.getClass().isMemberClass() 72 && !Modifier.isStatic(mLoader.getClass().getModifiers())) { 73 throw new IllegalArgumentException( 74 "Object returned from onCreateLoader must not be a non-static inner member class: " 75 + mLoader); 76 } 77 if (!mListenerRegistered) { 78 mLoader.registerListener(mId, this); 79 mLoader.registerOnLoadCanceledListener(this); 80 mListenerRegistered = true; 81 } 82 //你看这里调用了startLoading方法 这个方法是属于mLoader的 跳转到88行 83 mLoader.startLoading(); 84 } 85 } 86 87 //88- 98行是loader这个类里的 88 public final void startLoading() { 89 mStarted = true; 90 mReset = false; 91 mAbandoned = false; 92 onStartLoading(); 93 } 94 95 //你看最终是调用的这个方法，注意他是空方法 是交给子类去实现的，我们去看看cursorloader这个子类是怎么实现的吧。 96 protected void onStartLoading() { 97 } 98 //99- 112行 是cursorLoader这个类的代码 99 100 //你看这个地方 直接调用了forceload方法 这个方法大家前面肯定有印象 他最终会启动那个asynctask 去执行background方法 101 //这也就解释了 第一次我们的数据是怎么来的，比如说 假设我们的数据源还没有被更新的时候，为什么会自动去查找数据源 并返回数据 102 //到这里就明白了，原来是activity的onStart函数为开端 一步步走到Loader的子类的onStartLoading方法里的，当然你如果觉得 103 //Loader不需要初始加载 只要在有变化的时候再加载 那这个方法你就可以保持为空了。 104 protected void onStartLoading() { 105 if (mCursor != null) { 106 deliverResult(mCursor); 107 } 108 if (takeContentChanged() || mCursor == null) { 109 forceLoad(); 110 } 111 } 112 113 //114-139行 为 http://developer.android.com/intl/zh-cn/reference/android/content/AsyncTaskLoader.html 这个里面 AppListLoader 的一段源码 114 //你看138行 也是直接调用的forceLoad 这样当我们的applist没有变化的时候 第一次也能显示出列表 115 /** 116 * Handles a request to start the Loader. 117 */ 118 @Override protected void onStartLoading() { 119 if (mApps != null) { 120 // If we currently have a result available, deliver it 121 // immediately. 122 deliverResult(mApps); 123 } 124 125 // Start watching for changes in the app data. 126 if (mPackageObserver == null) { 127 mPackageObserver = new PackageIntentReceiver(this); 128 } 129 130 // Has something interesting in the configuration changed since we 131 // last built the app list? 132 boolean configChange = mLastConfig.applyNewConfig(getContext().getResources()); 133 134 if (takeContentChanged() || mApps == null || configChange) { 135 // If the data has changed since the last time it was loaded 136 // or is not currently available, start a load. 137 forceLoad(); 138 } 139 }
start流程 我们分析完毕了 最后我们再看看stop流程吧 看完这个 其他生命周期 我们就不分析了留给读者自己感兴趣的话自己分析试试看。
1 //我们来看看fragment的onDestroy方法 都做了什么 2 public void onDestroy() { 3 mCalled = true; 4 //Log.v("foo", "onDestroy: mCheckedForLoaderManager=" + mCheckedForLoaderManager 5 // + " mLoaderManager=" + mLoaderManager); 6 if (!mCheckedForLoaderManager) { 7 mCheckedForLoaderManager = true; 8 mLoaderManager = mHost.getLoaderManager(mWho, mLoadersStarted, false); 9 } 10 if (mLoaderManager != null) { 11 //跳转到16行 12 mLoaderManager.doDestroy(); 13 } 14 } 15 //上面的代码 是在fragment里 下面的代码在loadermanger里 16 void doDestroy() { 17 if (!mRetaining) { 18 if (DEBUG) Log.v(TAG, "Destroying Active in " + this); 19 for (int i = mLoaders.size()-1; i >= 0; i--) { 20 mLoaders.valueAt(i).destroy(); 21 } 22 mLoaders.clear(); 23 } 24 25 if (DEBUG) Log.v(TAG, "Destroying Inactive in " + this); 26 for (int i = mInactiveLoaders.size()-1; i >= 0; i--) { 27 mInactiveLoaders.valueAt(i).destroy(); 28 } 29 mInactiveLoaders.clear(); 30 } 31 //下面这个destroy流程 可以清晰的看到很多东西 包括clear所有回调等 32 void destroy() { 33 if (DEBUG) Log.v(TAG, " Destroying: " + this); 34 mDestroyed = true; 35 boolean needReset = mDeliveredData; 36 mDeliveredData = false; 37 if (mCallbacks != null && mLoader != null && mHaveData && needReset) { 38 if (DEBUG) Log.v(TAG, " Reseting: " + this); 39 String lastBecause = null; 40 if (mHost != null) { 41 lastBecause = mHost.mFragmentManager.mNoTransactionsBecause; 42 mHost.mFragmentManager.mNoTransactionsBecause = "onLoaderReset"; 43 } 44 try { 45 mCallbacks.onLoaderReset(mLoader); 46 } finally { 47 if (mHost != null) { 48 mHost.mFragmentManager.mNoTransactionsBecause = lastBecause; 49 } 50 } 51 } 52 mCallbacks = null; 53 mData = null; 54 mHaveData = false; 55 if (mLoader != null) { 56 if (mListenerRegistered) { 57 mListenerRegistered = false; 58 mLoader.unregisterListener(this); 59 mLoader.unregisterOnLoadCanceledListener(this); 60 } 61 //在这调用了rest 62 mLoader.reset(); 63 } 64 if (mPendingLoader != null) { 65 mPendingLoader.destroy(); 66 } 67 } 68 //最后我们来看看loader里的代码 就能明白了 当fragement destroy的时候最终的调用来到了子类的onReset方法 69 public void reset() { 70 onReset(); 71 mReset = true; 72 mStarted = false; 73 mAbandoned = false; 74 mContentChanged = false; 75 mProcessingChange = false; 76 } 77 78 /** 79 * Subclasses must implement this to take care of resetting their loader, 80 * as per {@link #reset()}. This is not called by clients directly, 81 * but as a result of a call to {@link #reset()}. 82 * This will always be called from the process's main thread. 83 */ 84 protected void onReset() { 85 } 86 87 //这里是cURSORLOADER的代码了 你看这里关闭了cursor 88 @Override 89 protected void onReset() { 90 super.onReset(); 91 92 // Ensure the loader is stopped 93 onStopLoading(); 94 95 if (mCursor != null && !mCursor.isClosed()) { 96 mCursor.close(); 97 } 98 mCursor = null; 99 } 100 101 //同样的 我们也能看到applistloader源码里面 也是在这个函数里清除了广播接收器。 102 //所以读到这里 我们就知道 loader的强大了。你只需要搞清楚这些生命周期的函数的意义 103 //就可以重写他们，至于什么时候调用 loader都帮你做好了 你只需要在里面实现你自己的逻辑即可！非常强大 非常好用 104 @Override protected void onReset() { 105 super.onReset(); 106 107 // Ensure the loader is stopped 108 onStopLoading(); 109 110 // At this point we can release the resources associated with 'apps' 111 // if needed. 112 if (mApps != null) { 113 onReleaseResources(mApps); 114 mApps = null; 115 } 116 117 // Stop monitoring for changes. 118 if (mPackageObserver != null) { 119 getContext().unregisterReceiver(mPackageObserver); 120 mPackageObserver = null; 121 } 122 }
---恢复内容结束---
正文到此结束
- 本文标签： 删除 mina 线程 Menu HTML XML final http db 学生 IDE App Collections 参数 ask tab 数据库 数据 CTO 实例 REST src 源码 find UI 注释 Select onchange client ldap swap 安装 需求 DOM 谷歌 example root tar map 代码 parse list update sql 管理 解析 value Developer 生命 java struct cat NSA Android key provider
- 版权声明： 本文为互联网转载文章，出处已在文章中说明(部分除外)。如果侵权，请联系本站长删除，谢谢。
- 本文海报： 生成海报一 生成海报二
热门推荐
相关文章
Loading...
![[HBLOG]公众号](http://www.liuhaihua.cn/img/qrcode_gzh.jpg)
