loader机制

loader机制

一. 概述

• 对每个activity或者fragment都有效
• 提供了异步加载数据的能力
• 监视数据源并在内容改变的时候传递新的结果
• 在Activity配置发生变化（如横竖屏切换）时不重复加载数据
• Loader一般用在Activity和fragment异步加载数据，无需重新启动一个线程来执行数据加载，异步加载可以用asyncTask, 但是loader自带数据结果监听机制，可以方便优雅的进行UI更新

相关类

LoaderManager
每个activity或者fragment都只有一个LoaderManager，但是一个LoaderManager可以管理多个Loader

LoaderCallbacks
客户端用于和LoaderManager交互的回调接口

Loader
加载器的基类

AyncTaskLoader
提供一个AsyncTask来执行异步任务的抽象类

CursorLoader
AyncTaskLoader的子类，它查询ContentResolver然后返回一个Cursor，是从一个ContentProvider异步加载数据的最好方式。

二. 启动Loader

getLoaderManager().initLoader(id,args, callback);  

• id:用来标志loader
• args：可选参数，用于loader的初始化
• callback：回调
  initLoader保证一个loader被激活，它可能有两种结果
  一种是：id所指示的loader已经存在，那么这个loader将被重用
  另一种是：loader不存在，会触发callback的onCreateLoader方法。

三.重启和回调

重启

 getLoaderManager().restartLoader(id, args, callback);  

回调

onCreateLoader
onLoadFinished
onLoaderReset

四. 应用

public static class CursorLoaderListFragment extends ListFragment
        implements OnQueryTextListener, LoaderManager.LoaderCallbacks {

    // 这是用于显示列表数据的Adapter
    SimpleCursorAdapter mAdapter;

    // 如果非null，这是当前的搜索过虑器
    String mCurFilter;

    @Override public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);

        // 如果列表中没有数据，就给控件一些文字去显示．在一个真正的应用
        // 中这应用资源中取得．
        setEmptyText("No phone numbers");

        // 我们在动作栏中有一个菜单项．
        setHasOptionsMenu(true);

        // 创建一个空的adapter，我们将用它显示加载后的数据
        mAdapter = new SimpleCursorAdapter(getActivity(),
                android.R.layout.simple_list_item_2, null,
                new String[] { Contacts.DISPLAY_NAME, Contacts.CONTACT_STATUS },
                new int[] { android.R.id.text1, android.R.id.text2 }, 0);
        setListAdapter(mAdapter);

        // 准备loader.可能是重连到一个已存在的或开始一个新的
        getLoaderManager().initLoader(0, null, this);
    }

    @Override public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
        // 放置一个动作栏项用于搜索．
        MenuItem item = menu.add("Search");
        item.setIcon(android.R.drawable.ic_menu_search);
        item.setShowAsAction(MenuItem.SHOW_AS_ACTION_IF_ROOM);
        SearchView sv = new SearchView(getActivity());
        sv.setOnQueryTextListener(this);
        item.setActionView(sv);
    }

    public boolean onQueryTextChange(String newText) {
        // 在动作栏上的搜索字串改变时被调用．更新
        //搜索过滤器，并重启loader来执行一个新的查询
        mCurFilter = !TextUtils.isEmpty(newText) ? newText : null;
        getLoaderManager().restartLoader(0, null, this);
        return true;
    }

    @Override public boolean onQueryTextSubmit(String query) {
        // 我们不关心这个方法
        return true;
    }

    @Override public void onListItemClick(ListView l, View v, int position, long id) {
        // 写入你想写的代码
        Log.i("FragmentComplexList", "Item clicked: " + id);
    }

    // 这是我们想获取的联系人中一行的数据．
    static final String[] CONTACTS_SUMMARY_PROJECTION = new String[] {
        Contacts._ID,
        Contacts.DISPLAY_NAME,
        Contacts.CONTACT_STATUS,
        Contacts.CONTACT_PRESENCE,
        Contacts.PHOTO_ID,
        Contacts.LOOKUP_KEY,
    };
    public Loader onCreateLoader(int id, Bundle args) {
        // 当一个新的loader需被创建时调用．本例仅有一个Loader，
        //所以我们不需关心ID．首先设置base URI，URI指向的是联系人
        Uri baseUri;
        if (mCurFilter != null) {
            baseUri = Uri.withAppendedPath(Contacts.CONTENT_FILTER_URI,
                    Uri.encode(mCurFilter));
        } else {
            baseUri = Contacts.CONTENT_URI;
        }

        // 现在创建并返回一个CursorLoader，它将负责创建一个
        // Cursor用于显示数据
        String select = "((" + Contacts.DISPLAY_NAME + " NOTNULL) AND ("
                + Contacts.HAS_PHONE_NUMBER + "=1) AND ("
                + Contacts.DISPLAY_NAME + " != '' ))";
        return new CursorLoader(getActivity(), baseUri,
                CONTACTS_SUMMARY_PROJECTION, select, null,
                Contacts.DISPLAY_NAME + " COLLATE LOCALIZED ASC");
    }

    public void onLoadFinished(Loader loader, Cursor data) {
        // 将新的cursor换进来．(框架将在我们返回时关心一下旧cursor的关闭)
        mAdapter.swapCursor(data);
    }

    public void onLoaderReset(Loader loader) {
        //在最后一个Cursor准备进入上面的onLoadFinished()之前．
        // Cursor要被关闭了，我们需要确保不再使用它．
        mAdapter.swapCursor(null);
    }
}

利用loader查询通讯录

public class MainActivity extends ListActivity implements LoaderManager.LoaderCallbacks, SearchView.OnQueryTextListener {
private  SimpleCursorAdapter cursorAdapter;
    private String filterName=null;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        TextView tv= (TextView) findViewById(android.R.id.empty);
        tv.setText("请稍后");
 
        cursorAdapter=new SimpleCursorAdapter(this,
                android.R.layout.simple_list_item_2,
                null,
                new String[]{ContactsContract.Contacts.DISPLAY_NAME},
                new int[]{android.R.id.text1},0);
         setListAdapter(cursorAdapter);
        //初始化Loader
          getLoaderManager().initLoader(0,null,this);
    }
 
 
    @Override
    public Loader onCreateLoader(int id, Bundle args) {
        Uri uri;
        String[] pro=new String[]{ ContactsContract.Contacts.DISPLAY_NAME,ContactsContract.Contacts._ID};
        if(TextUtils.isEmpty(filterName)){
            uri= ContactsContract.Contacts.CONTENT_URI;
        }else{
            uri=Uri.withAppendedPath(ContactsContract.Contacts.CONTENT_FILTER_URI,Uri.encode(filterName));
        }
        //创建Loader对象，开始异步加载数据
        return new CursorLoader(this,uri,pro, null, null,null);
    }
 
    @Override
    public void onLoadFinished(Loader loader, Cursor data) {
        //得到异步加载数据，更新Adapter
        cursorAdapter.swapCursor(data);
    }
 
    @Override
    public void onLoaderReset(Loader loader) {
        //移除adapter使用的Loader，系统会释放不再使用的Loader
        cursorAdapter.swapCursor(null);
    }
 
 
    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        getMenuInflater().inflate(R.menu.menu_main,menu);
        SearchView v= (SearchView) menu.findItem(R.id.menu_search).getActionView();
        v.setOnQueryTextListener(this);
        return true;
    }
 
    @Override
    public boolean onQueryTextSubmit(String query) {
        return true;
    }
 
    @Override
    public boolean onQueryTextChange(String newText) {
        filterName=newText;
        //使用新的Loader(清空旧的数据)
        getLoaderManager().restartLoader(0,null,this);
        return false;
    }
}

---

应用列表的获取

public static class PackageIntentReceiver extends BroadcastReceiver {
    final AppListLoader mLoader;

    // 这个构造函数是很重要的 他接收的 就是自定义的loader
    public PackageIntentReceiver(AppListLoader loader) {
        mLoader = loader;
        IntentFilter filter = new IntentFilter(Intent.ACTION_PACKAGE_ADDED);
        filter.addAction(Intent.ACTION_PACKAGE_REMOVED);
        filter.addAction(Intent.ACTION_PACKAGE_CHANGED);
        filter.addDataScheme("package");
        mLoader.getContext().registerReceiver(this, filter);
        // Register for events related to sdcard installation.
        IntentFilter sdFilter = new IntentFilter();
        sdFilter.addAction(Intent.ACTION_EXTERNAL_APPLICATIONS_AVAILABLE);
        sdFilter.addAction(Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE);
        // 在这个地方 直接用loader来注册这个广播接收器
        mLoader.getContext().registerReceiver(this, sdFilter);
    }

    // 在收到广播以后 什么事情都没有做，而是调用了loader的onContentChanged方法
    @Override
    public void onReceive(Context context, Intent intent) {
        // Tell the loader about the change.
        mLoader.onContentChanged();
    }
}

public static class AppListLoader extends AsyncTaskLoader> {
    final InterestingConfigChanges mLastConfig = new InterestingConfigChanges();
    final PackageManager mPm;

    List mApps;
    PackageIntentReceiver mPackageObserver;

    public AppListLoader(Context context) {
        super(context);

        // Retrieve the package manager for later use; note we don't
        // use 'context' directly but instead the save global application
        // context returned by getContext().
        mPm = getContext().getPackageManager();
    }

    // 实际上最重要的就是这个方法了，每当这个回调方法被调用的时候 就去取applist 然后将结果返回到
    // onLoadFinished 这个回调方法里面！
    @Override
    public List loadInBackground() {
        // Retrieve all known applications.
        List apps = mPm
                .getInstalledApplications(PackageManager.GET_UNINSTALLED_PACKAGES
                        | PackageManager.GET_DISABLED_COMPONENTS);
        if (apps == null) {
            apps = new ArrayList();
        }

        final Context context = getContext();

        // Create corresponding array of entries and load their labels.
        List entries = new ArrayList(apps.size());
        for (int i = 0; i < apps.size(); i++) {
            AppEntry entry = new AppEntry(this, apps.get(i));
            entry.loadLabel(context);
            entries.add(entry);
        }

        // Sort the list.
        Collections.sort(entries, ALPHA_COMPARATOR);

        // Done!
        return entries;
    }

    /**
     * Called when there is new data to deliver to the client. The super class
     * will take care of delivering it; the implementation here just adds a
     * little more logic.
     */
    @Override
    public void deliverResult(List apps) {
        if (isReset()) {
            // An async query came in while the loader is stopped. We
            // don't need the result.
            if (apps != null) {
                onReleaseResources(apps);
            }
        }
        List oldApps = mApps;
        mApps = apps;

        if (isStarted()) {
            // If the Loader is currently started, we can immediately
            // deliver its results.
            super.deliverResult(apps);
        }

        // At this point we can release the resources associated with
        // 'oldApps' if needed; now that the new result is delivered we
        // know that it is no longer in use.
        if (oldApps != null) {
            onReleaseResources(oldApps);
        }
    }

    /**
     * Handles a request to start the Loader.
     */
    @Override
    protected void onStartLoading() {
        if (mApps != null) {
            // If we currently have a result available, deliver it
            // immediately.
            deliverResult(mApps);
        }

        // Start watching for changes in the app data.
        if (mPackageObserver == null) {
            mPackageObserver = new PackageIntentReceiver(this);
        }

        // Has something interesting in the configuration changed since we
        // last built the app list?
        boolean configChange = mLastConfig.applyNewConfig(getContext()
                .getResources());

        if (takeContentChanged() || mApps == null || configChange) {
            // If the data has changed since the last time it was loaded
            // or is not currently available, start a load.
            forceLoad();
        }
    }

    /**
     * Handles a request to stop the Loader.
     */
    @Override
    protected void onStopLoading() {
        // Attempt to cancel the current load task if possible.
        cancelLoad();
    }

    /**
     * Handles a request to cancel a load.
     */
    @Override
    public void onCanceled(List apps) {
        super.onCanceled(apps);

        // At this point we can release the resources associated with 'apps'
        // if needed.
        onReleaseResources(apps);
    }

    /**
     * Handles a request to completely reset the Loader.
     */
    @Override
    protected void onReset() {
        super.onReset();

        // Ensure the loader is stopped
        onStopLoading();

        // At this point we can release the resources associated with 'apps'
        // if needed.
        if (mApps != null) {
            onReleaseResources(mApps);
            mApps = null;
        }

        // Stop monitoring for changes.
        if (mPackageObserver != null) {
            getContext().unregisterReceiver(mPackageObserver);
            mPackageObserver = null;
        }
    }

    /**
     * Helper function to take care of releasing resources associated with an
     * actively loaded data set.
     */
    protected void onReleaseResources(List apps) {
        // For a simple List<> there is nothing to do. For something
        // like a Cursor, we would close it here.
    }
}

在loader里 注册广播接收器，当广播接收器 收到广播以后 就调用loader的onContentChanged方法，这个方法一调用 AppListLoader里的loadInBackGround就会被调用，然后当loadInBackGround执行完毕以后 就会把结果传递给onLoadFinished方法了

五.源码分析

5.1 getLoaderManager的源码：每个activity和fragment都对应一个LoaderManager。

fragment getLoaderManager的源码

fragment的getLoaderManager也是通过activity的getLoader去调用的

//这边就能看出来一个fragment只能有一个loadermanager了。
public LoaderManager getLoaderManager() {

        if (mLoaderManager != null) {
            return mLoaderManager;
        }
        //mHost很好理解 就是fragment的宿主，也就是跟fragment 相关联的activity。
        if (mHost == null) {
            throw new IllegalStateException("Fragment " + this + " not attached to Activity");
        }
        mCheckedForLoaderManager = true;
        mLoaderManager = mHost.getLoaderManager(mWho, mLoadersStarted, true);
        return mLoaderManager;
}

activity中getLoaderManager的源码

**结论：
**真正的loadermanager都是存储在activity中的，包括fragment的loadermanager也是，通过一个map来保证 get的时候取的manager是自己对应的，并且全局唯一

//在activty中最终实际上调用的就是他了 是这个方法
  LoaderManagerImpl getLoaderManagerImpl() {
        if (mLoaderManager != null) {
            return mLoaderManager;
        }
        mCheckedForLoaderManager = true;
        mLoaderManager = getLoaderManager("(root)", mLoadersStarted, true /*create*/);
        return mLoaderManager;
    }

//这个地方就能看到 主要的第一个参数 who，你到这就能发现 如果是activity自己调用的话，传进去的who的值就是root
//也就是说一个actvity 只能有一个loadermanger 但是我们可以发现在fragment里 传进去的值是下面这个：
// Internal unique name for this fragment;
//String mWho;
//也就是说每一个fragment的mWho的值都是唯一的，而在activty中，是维护了一个map，一个key 对应一个loadermanager
//key就是fragment的那个唯一的标示，或者是activity自己，activity自己的标示就是（root)了
    LoaderManagerImpl getLoaderManager(String who, boolean started, boolean create) {
        if (mAllLoaderManagers == null) {
            mAllLoaderManagers = new ArrayMap();
        }
        LoaderManagerImpl lm = (LoaderManagerImpl) mAllLoaderManagers.get(who);
        if (lm == null) {
            if (create) {
                lm = new LoaderManagerImpl(who, this, started);
                mAllLoaderManagers.put(who, lm);
            }
        } else {
            lm.updateHostController(this);
        }
        return lm;
    }

5.2 回调发生关系的源码（LoaderManger与LoaderCallback的联系）

//这个就是现在存活的loader
final SparseArray mLoaders = new SparseArray(0);

//这个是已经运行结束的loader
final SparseArray mInactiveLoaders = new SparseArray(0);

public  Loader initLoader(int id, Bundle args, LoaderManager.LoaderCallbacks callback) {
        if (mCreatingLoader) {
            throw new IllegalStateException("Called while creating a loader");
        } 
        //这个就是先看看是否有活动的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