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

   final void performStop() {
        mDoReportFullyDrawn = false;
        if (mLoadersStarted) {
            mLoadersStarted = false;
            if (mLoaderManager != null) {
                if (!mChangingConfigurations) {
                    mLoaderManager.doStop();
                } else {
                    mLoaderManager.doRetain();
                }
            }
        }

 final void performDestroy() {
        mDestroyed = true;
        mWindow.destroy();
        mFragments.dispatchDestroy();
        onDestroy();
        if (mLoaderManager != null) {
            mLoaderManager.doDestroy();
        }
        if (mVoiceInteractor != null) {
            mVoiceInteractor.detachActivity();
        }
    }

	 @Override
	  public Loader<List<ApplicationInfo>> onCreateLoader(int id, Bundle args) {

	    //args 是getSupportLoaderManager().initLoader传过来的数据
	    Log.e("branch", "onCreateLoader");

	    return new AppListLoader(this);
	  }

	  @Override
	  public void onLoadFinished(Loader<List<ApplicationInfo>> loader, List<ApplicationInfo> data) {


	    Log.e("branch", "onLoadFinished-》 " + data);

	    mListApps = data;

	    mApplistAdapter.notifyDataSetChanged();

	    if (progressDialog != null) {
	      progressDialog.dismiss();
	    }
	  }

	  @Override
	  public void onLoaderReset(Loader<List<ApplicationInfo>> loader) {

	    Log.e("branch", "onLoaderReset");
	    if (progressDialog != null) {
	      progressDialog.dismiss();
	    }

	    mListApps = null;
	    mApplistAdapter.notifyDataSetChanged();

	  }

	  @Override
	  protected void onCreate(Bundle savedInstanceState) {
	    super.onCreate(savedInstanceState);
	    setContentView(R.layout.activity_main);

	    startLoad();
	  }

	 
	  private void startLoad() {

	    progressDialog = new ProgressDialog(this);
	    progressDialog.show();

	    getSupportLoaderManager().initLoader(1, null, this);
	    

	  }

	public boolean onTextChanged(String newText) {
	    // Called when the action bar search text has changed.  Update
	    // the search filter, and restart the loader to do a new query
	    // with this filter.
	    getLoaderManager().restartLoader(0, null, this);
	    return true;
	}

	public class AppListLoader extends AsyncTaskLoader<List<ApplicationInfo>> {

	  List<ApplicationInfo> mApps;

	  PackageManager mPm;

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

	  /**
	   * This is where the bulk of our work is done.  This function is called in a background thread and
	   * should generate a new set of data to be published by the loader.
	   */
	  @Override
	  public List<ApplicationInfo> loadInBackground() {
	    // Retrieve all known applications.
	    List<ApplicationInfo> apps = mPm.getInstalledApplications(
	        PackageManager.GET_UNINSTALLED_PACKAGES | PackageManager.GET_DISABLED_COMPONENTS | PackageManager.GET_META_DATA);
	    if (apps == null) {
	      apps = new ArrayList<ApplicationInfo>();
	    }

	    // Done!
	    return apps;
	  }

	  /**
	   * 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<ApplicationInfo> 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<ApplicationInfo> 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);
	    }

	    if (takeContentChanged() || mApps == null) {
	      // 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<ApplicationInfo> 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;
	    }

	  }

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

	}