core/java/android/app/LoaderManager.java - platform/frameworks/base - Gitiles

 /*
  * Copyright (C) 2010 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package android.app;

 import android.content.Loader;
 import android.os.Bundle;
 import android.util.Log;
 import android.util.SparseArray;

 /**
  * Interface associated with an {@link Activity} or {@link Fragment} for managing
  * one or more {@link android.content.Loader} instances associated with it.
  */
 public interface LoaderManager {
     /**
      * Callback interface for a client to interact with the manager.
      */
     public interface LoaderCallbacks<D> {
         /**
          * Instantiate and return a new Loader for the given ID.
          *
          * @param id The ID whose loader is to be created.
          * @param args Any arguments supplied by the caller.
          * @return Return a new Loader instance that is ready to start loading.
          */
         public Loader<D> onCreateLoader(int id, Bundle args);

         /**
          * Called when a previously created loader has finished its load.
          * @param loader The Loader that has finished.
          * @param data The data generated by the Loader.
          */
         public void onLoadFinished(Loader<D> loader, D data);
     }

     /**
      * Ensures a loader is initialized and active.  If the loader doesn't
      * already exist, one is created and (if the activity/fragment is currently
      * started) starts the loader.  Otherwise the last created
      * loader is re-used.
      *
      * <p>In either case, the given callback is associated with the loader, and
      * will be called as the loader state changes.  If at the point of call
      * the caller is in its started state, and the requested loader
      * already exists and has generated its data, then
      * callback. {@link LoaderCallbacks#onLoadFinished} will
      * be called immediately (inside of this function), so you must be prepared
      * for this to happen.
      */
     public <D> Loader<D> initLoader(int id, Bundle args,
             LoaderManager.LoaderCallbacks<D> callback);

     /**
      * Creates a new loader in this manager, registers the callbacks to it,
      * and (if the activity/fragment is currently started) starts loading it.
      * If a loader with the same id has previously been
      * started it will automatically be destroyed when the new loader completes
      * its work. The callback will be delivered before the old loader
      * is destroyed.
      */
     public <D> Loader<D> restartLoader(int id, Bundle args,
             LoaderManager.LoaderCallbacks<D> callback);

     /**
      * Stops and removes the loader with the given ID.
      */
     public void stopLoader(int id);

     /**
      * Return the Loader with the given id or null if no matching Loader
      * is found.
      */
     public <D> Loader<D> getLoader(int id);
 }

 class LoaderManagerImpl implements LoaderManager {
     static final String TAG = "LoaderManagerImpl";
     static final boolean DEBUG = true;

     // These are the currently active loaders.  A loader is here
     // from the time its load is started until it has been explicitly
     // stopped or restarted by the application.
     final SparseArray<LoaderInfo> mLoaders = new SparseArray<LoaderInfo>();

     // These are previously run loaders.  This list is maintained internally
     // to avoid destroying a loader while an application is still using it.
     // It allows an application to restart a loader, but continue using its
     // previously run loader until the new loader's data is available.
     final SparseArray<LoaderInfo> mInactiveLoaders = new SparseArray<LoaderInfo>();

     boolean mStarted;
     boolean mRetaining;
     boolean mRetainingStarted;

     final class LoaderInfo implements Loader.OnLoadCompleteListener<Object> {
         final int mId;
         final Bundle mArgs;
         LoaderManager.LoaderCallbacks<Object> mCallbacks;
         Loader<Object> mLoader;
         Object mData;
         boolean mStarted;
         boolean mRetaining;
         boolean mRetainingStarted;
         boolean mDestroyed;
         boolean mListenerRegistered;

         public LoaderInfo(int id, Bundle args, LoaderManager.LoaderCallbacks<Object> callbacks) {
             mId = id;
             mArgs = args;
             mCallbacks = callbacks;
         }

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

             if (DEBUG) Log.v(TAG, "  Starting: " + this);
             if (mLoader == null && mCallbacks != null) {
                mLoader = mCallbacks.onCreateLoader(mId, mArgs);
             }
             if (mLoader != null) {
                 if (!mListenerRegistered) {
                     mLoader.registerListener(mId, this);
                     mListenerRegistered = true;
                 }
                 mLoader.startLoading();
                 mStarted = true;
             }
         }

         void retain() {
             if (DEBUG) Log.v(TAG, "  Retaining: " + this);
             mRetaining = true;
             mRetainingStarted = mStarted;
             mStarted = false;
             mCallbacks = null;
         }

         void finishRetain() {
             if (mRetaining) {
                 if (DEBUG) Log.v(TAG, "  Finished Retaining: " + this);
                 mRetaining = false;
                 if (mStarted != mRetainingStarted) {
                     if (!mStarted) {
                         // This loader was retained in a started state, but
                         // at the end of retaining everything our owner is
                         // no longer started...  so make it stop.
                         stop();
                     }
                 }
                 if (mStarted && mData != null && mCallbacks != null) {
                     // This loader was retained, and now at the point of
                     // finishing the retain we find we remain started, have
                     // our data, and the owner has a new callback...  so
                     // let's deliver the data now.
                     mCallbacks.onLoadFinished(mLoader, mData);
                 }
             }
         }

         void stop() {
             if (DEBUG) Log.v(TAG, "  Stopping: " + this);
             mStarted = false;
             if (!mRetaining) {
                 if (mLoader != null && mListenerRegistered) {
                     // Let the loader know we're done with it
                     mListenerRegistered = false;
                     mLoader.unregisterListener(this);
                     mLoader.stopLoading();
                 }
                 mData = null;
             }
         }

         void destroy() {
             if (DEBUG) Log.v(TAG, "  Destroying: " + this);
             mDestroyed = true;
             mCallbacks = null;
             if (mLoader != null) {
                 if (mListenerRegistered) {
                     mListenerRegistered = false;
                     mLoader.unregisterListener(this);
                 }
                 mLoader.destroy();
             }
         }

         @Override public void onLoadComplete(Loader<Object> loader, Object data) {
             if (DEBUG) Log.v(TAG, "onLoadComplete: " + this + " mDestroyed=" + mDestroyed);

             if (mDestroyed) {
                 return;
             }

             // Notify of the new data so the app can switch out the old data before
             // we try to destroy it.
             mData = data;
             if (mCallbacks != null) {
                 mCallbacks.onLoadFinished(loader, data);
             }

             if (DEBUG) Log.v(TAG, "onLoadFinished returned: " + this);

             // We have now given the application the new loader with its
             // loaded data, so it should have stopped using the previous
             // loader.  If there is a previous loader on the inactive list,
             // clean it up.
             LoaderInfo info = mInactiveLoaders.get(mId);
             if (info != null && info != this) {
                 info.destroy();
                 mInactiveLoaders.remove(mId);
             }
         }

         @Override
         public String toString() {
             StringBuilder sb = new StringBuilder(64);
             sb.append("LoaderInfo{");
             sb.append(Integer.toHexString(System.identityHashCode(this)));
             sb.append(" #");
             sb.append(mId);
             if (mArgs != null) {
                 sb.append(" ");
                 sb.append(mArgs.toString());
             }
             sb.append("}");
             return sb.toString();
         }
     }

     LoaderManagerImpl(boolean started) {
         mStarted = started;
     }

     private LoaderInfo createLoader(int id, Bundle args,
             LoaderManager.LoaderCallbacks<Object> callback) {
         LoaderInfo info = new LoaderInfo(id, args,  (LoaderManager.LoaderCallbacks<Object>)callback);
         mLoaders.put(id, info);
         Loader<Object> loader = callback.onCreateLoader(id, args);
         info.mLoader = (Loader<Object>)loader;
         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();
         }
         return info;
     }

     @SuppressWarnings("unchecked")
     public <D> Loader<D> initLoader(int id, Bundle args, LoaderManager.LoaderCallbacks<D> callback) {
         LoaderInfo info = mLoaders.get(id);

         if (DEBUG) Log.v(TAG, "initLoader in " + this + ": cur=" + info);

         if (info == null) {
             // Loader doesn't already exist; create.
             info = createLoader(id, args,  (LoaderManager.LoaderCallbacks<Object>)callback);
         } else {
             info.mCallbacks = (LoaderManager.LoaderCallbacks<Object>)callback;
         }

         if (info.mData != null && mStarted) {
             // If the loader has already generated its data, report it now.
             info.mCallbacks.onLoadFinished(info.mLoader, info.mData);
         }

         return (Loader<D>)info.mLoader;
     }

     @SuppressWarnings("unchecked")
     public <D> Loader<D> restartLoader(int id, Bundle args, LoaderManager.LoaderCallbacks<D> callback) {
         LoaderInfo info = mLoaders.get(id);
         if (DEBUG) Log.v(TAG, "restartLoader in " + this + ": cur=" + info);
         if (info != null) {
             LoaderInfo inactive = mInactiveLoaders.get(id);
             if (inactive != null) {
                 if (info.mData != null) {
                     // This loader now has data...  we are probably being
                     // called from within onLoadComplete, where we haven't
                     // yet destroyed the last inactive loader.  So just do
                     // that now.
                     if (DEBUG) Log.v(TAG, "  Removing last inactive loader in " + this);
                     inactive.destroy();
                     mInactiveLoaders.put(id, info);
                 } else {
                     // We already have an inactive loader for this ID that we are
                     // waiting for!  Now we have three active loaders... let's just
                     // drop the one in the middle, since we are still waiting for
                     // its result but that result is already out of date.
                     if (DEBUG) Log.v(TAG, "  Removing intermediate loader in " + this);
                     info.destroy();
                 }
             } else {
                 // Keep track of the previous instance of this loader so we can destroy
                 // it when the new one completes.
                 if (DEBUG) Log.v(TAG, "  Making inactive: " + info);
                 mInactiveLoaders.put(id, info);
             }
         }

         info = createLoader(id, args,  (LoaderManager.LoaderCallbacks<Object>)callback);
         return (Loader<D>)info.mLoader;
     }

     public void stopLoader(int id) {
         if (DEBUG) Log.v(TAG, "stopLoader in " + this + " of " + id);
         int idx = mLoaders.indexOfKey(id);
         if (idx >= 0) {
             LoaderInfo info = mLoaders.valueAt(idx);
             mLoaders.removeAt(idx);
             info.destroy();
         }
     }

     @SuppressWarnings("unchecked")
     public <D> Loader<D> getLoader(int id) {
         LoaderInfo loaderInfo = mLoaders.get(id);
         if (loaderInfo != null) {
             return (Loader<D>)mLoaders.get(id).mLoader;
         }
         return null;
     }

     void doStart() {
         if (DEBUG) Log.v(TAG, "Starting: " + this);

         // 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();
         }
         mStarted = true;
     }

     void doStop() {
         if (DEBUG) Log.v(TAG, "Stopping: " + this);

         for (int i = mLoaders.size()-1; i >= 0; i--) {
             mLoaders.valueAt(i).stop();
         }
         mStarted = false;
     }

     void doRetain() {
         if (DEBUG) Log.v(TAG, "Retaining: " + this);

         mRetaining = true;
         mStarted = false;
         for (int i = mLoaders.size()-1; i >= 0; i--) {
             mLoaders.valueAt(i).retain();
         }
     }

     void finishRetain() {
         if (DEBUG) Log.v(TAG, "Finished Retaining: " + this);

         mRetaining = false;
         for (int i = mLoaders.size()-1; i >= 0; i--) {
             mLoaders.valueAt(i).finishRetain();
         }
     }

     void doDestroy() {
         if (!mRetaining) {
             if (DEBUG) Log.v(TAG, "Destroying Active: " + this);
             for (int i = mLoaders.size()-1; i >= 0; i--) {
                 mLoaders.valueAt(i).destroy();
             }
         }

         if (DEBUG) Log.v(TAG, "Destroying Inactive: " + this);
         for (int i = mInactiveLoaders.size()-1; i >= 0; i--) {
             mInactiveLoaders.valueAt(i).destroy();
         }
         mInactiveLoaders.clear();
     }
 }
	/*
	* Copyright (C) 2010 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package android.app;

	import android.content.Loader;
	import android.os.Bundle;
	import android.util.Log;
	import android.util.SparseArray;

	/**
	* Interface associated with an {@link Activity} or {@link Fragment} for managing
	* one or more {@link android.content.Loader} instances associated with it.
	*/
	public interface LoaderManager {
	/**
	* Callback interface for a client to interact with the manager.
	*/
	public interface LoaderCallbacks<D> {
	/**
	* Instantiate and return a new Loader for the given ID.
	*
	* @param id The ID whose loader is to be created.
	* @param args Any arguments supplied by the caller.
	* @return Return a new Loader instance that is ready to start loading.
	*/
	public Loader<D> onCreateLoader(int id, Bundle args);

	/**
	* Called when a previously created loader has finished its load.
	* @param loader The Loader that has finished.
	* @param data The data generated by the Loader.
	*/
	public void onLoadFinished(Loader<D> loader, D data);
	}

	/**
	* Ensures a loader is initialized and active. If the loader doesn't
	* already exist, one is created and (if the activity/fragment is currently
	* started) starts the loader. Otherwise the last created
	* loader is re-used.
	*
	* <p>In either case, the given callback is associated with the loader, and
	* will be called as the loader state changes. If at the point of call
	* the caller is in its started state, and the requested loader
	* already exists and has generated its data, then
	* callback. {@link LoaderCallbacks#onLoadFinished} will
	* be called immediately (inside of this function), so you must be prepared
	* for this to happen.
	*/
	public <D> Loader<D> initLoader(int id, Bundle args,
	LoaderManager.LoaderCallbacks<D> callback);

	/**
	* Creates a new loader in this manager, registers the callbacks to it,
	* and (if the activity/fragment is currently started) starts loading it.
	* If a loader with the same id has previously been
	* started it will automatically be destroyed when the new loader completes
	* its work. The callback will be delivered before the old loader
	* is destroyed.
	*/
	public <D> Loader<D> restartLoader(int id, Bundle args,
	LoaderManager.LoaderCallbacks<D> callback);

	/**
	* Stops and removes the loader with the given ID.
	*/
	public void stopLoader(int id);

	/**
	* Return the Loader with the given id or null if no matching Loader
	* is found.
	*/
	public <D> Loader<D> getLoader(int id);
	}

	class LoaderManagerImpl implements LoaderManager {
	static final String TAG = "LoaderManagerImpl";
	static final boolean DEBUG = true;

	// These are the currently active loaders. A loader is here
	// from the time its load is started until it has been explicitly
	// stopped or restarted by the application.
	final SparseArray<LoaderInfo> mLoaders = new SparseArray<LoaderInfo>();

	// These are previously run loaders. This list is maintained internally
	// to avoid destroying a loader while an application is still using it.
	// It allows an application to restart a loader, but continue using its
	// previously run loader until the new loader's data is available.
	final SparseArray<LoaderInfo> mInactiveLoaders = new SparseArray<LoaderInfo>();

	boolean mStarted;
	boolean mRetaining;
	boolean mRetainingStarted;

	final class LoaderInfo implements Loader.OnLoadCompleteListener<Object> {
	final int mId;
	final Bundle mArgs;
	LoaderManager.LoaderCallbacks<Object> mCallbacks;
	Loader<Object> mLoader;
	Object mData;
	boolean mStarted;
	boolean mRetaining;
	boolean mRetainingStarted;
	boolean mDestroyed;
	boolean mListenerRegistered;

	public LoaderInfo(int id, Bundle args, LoaderManager.LoaderCallbacks<Object> callbacks) {
	mId = id;
	mArgs = args;
	mCallbacks = callbacks;
	}

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

	if (DEBUG) Log.v(TAG, " Starting: " + this);
	if (mLoader == null && mCallbacks != null) {
	mLoader = mCallbacks.onCreateLoader(mId, mArgs);
	}
	if (mLoader != null) {
	if (!mListenerRegistered) {
	mLoader.registerListener(mId, this);
	mListenerRegistered = true;
	}
	mLoader.startLoading();
	mStarted = true;
	}
	}

	void retain() {
	if (DEBUG) Log.v(TAG, " Retaining: " + this);
	mRetaining = true;
	mRetainingStarted = mStarted;
	mStarted = false;
	mCallbacks = null;
	}

	void finishRetain() {
	if (mRetaining) {
	if (DEBUG) Log.v(TAG, " Finished Retaining: " + this);
	mRetaining = false;
	if (mStarted != mRetainingStarted) {
	if (!mStarted) {
	// This loader was retained in a started state, but
	// at the end of retaining everything our owner is
	// no longer started... so make it stop.
	stop();
	}
	}
	if (mStarted && mData != null && mCallbacks != null) {
	// This loader was retained, and now at the point of
	// finishing the retain we find we remain started, have
	// our data, and the owner has a new callback... so
	// let's deliver the data now.
	mCallbacks.onLoadFinished(mLoader, mData);
	}
	}
	}

	void stop() {
	if (DEBUG) Log.v(TAG, " Stopping: " + this);
	mStarted = false;
	if (!mRetaining) {
	if (mLoader != null && mListenerRegistered) {
	// Let the loader know we're done with it
	mListenerRegistered = false;
	mLoader.unregisterListener(this);
	mLoader.stopLoading();
	}
	mData = null;
	}
	}

	void destroy() {
	if (DEBUG) Log.v(TAG, " Destroying: " + this);
	mDestroyed = true;
	mCallbacks = null;
	if (mLoader != null) {
	if (mListenerRegistered) {
	mListenerRegistered = false;
	mLoader.unregisterListener(this);
	}
	mLoader.destroy();
	}
	}

	@Override public void onLoadComplete(Loader<Object> loader, Object data) {
	if (DEBUG) Log.v(TAG, "onLoadComplete: " + this + " mDestroyed=" + mDestroyed);

	if (mDestroyed) {
	return;
	}

	// Notify of the new data so the app can switch out the old data before
	// we try to destroy it.
	mData = data;
	if (mCallbacks != null) {
	mCallbacks.onLoadFinished(loader, data);
	}

	if (DEBUG) Log.v(TAG, "onLoadFinished returned: " + this);

	// We have now given the application the new loader with its
	// loaded data, so it should have stopped using the previous
	// loader. If there is a previous loader on the inactive list,
	// clean it up.
	LoaderInfo info = mInactiveLoaders.get(mId);
	if (info != null && info != this) {
	info.destroy();
	mInactiveLoaders.remove(mId);
	}
	}

	@Override
	public String toString() {
	StringBuilder sb = new StringBuilder(64);
	sb.append("LoaderInfo{");
	sb.append(Integer.toHexString(System.identityHashCode(this)));
	sb.append(" #");
	sb.append(mId);
	if (mArgs != null) {
	sb.append(" ");
	sb.append(mArgs.toString());
	}
	sb.append("}");
	return sb.toString();
	}
	}

	LoaderManagerImpl(boolean started) {
	mStarted = started;
	}

	private LoaderInfo createLoader(int id, Bundle args,
	LoaderManager.LoaderCallbacks<Object> callback) {
	LoaderInfo info = new LoaderInfo(id, args, (LoaderManager.LoaderCallbacks<Object>)callback);
	mLoaders.put(id, info);
	Loader<Object> loader = callback.onCreateLoader(id, args);
	info.mLoader = (Loader<Object>)loader;
	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();
	}
	return info;
	}

	@SuppressWarnings("unchecked")
	public <D> Loader<D> initLoader(int id, Bundle args, LoaderManager.LoaderCallbacks<D> callback) {
	LoaderInfo info = mLoaders.get(id);

	if (DEBUG) Log.v(TAG, "initLoader in " + this + ": cur=" + info);

	if (info == null) {
	// Loader doesn't already exist; create.
	info = createLoader(id, args, (LoaderManager.LoaderCallbacks<Object>)callback);
	} else {
	info.mCallbacks = (LoaderManager.LoaderCallbacks<Object>)callback;
	}

	if (info.mData != null && mStarted) {
	// If the loader has already generated its data, report it now.
	info.mCallbacks.onLoadFinished(info.mLoader, info.mData);
	}

	return (Loader<D>)info.mLoader;
	}

	@SuppressWarnings("unchecked")
	public <D> Loader<D> restartLoader(int id, Bundle args, LoaderManager.LoaderCallbacks<D> callback) {
	LoaderInfo info = mLoaders.get(id);
	if (DEBUG) Log.v(TAG, "restartLoader in " + this + ": cur=" + info);
	if (info != null) {
	LoaderInfo inactive = mInactiveLoaders.get(id);
	if (inactive != null) {
	if (info.mData != null) {
	// This loader now has data... we are probably being
	// called from within onLoadComplete, where we haven't
	// yet destroyed the last inactive loader. So just do
	// that now.
	if (DEBUG) Log.v(TAG, " Removing last inactive loader in " + this);
	inactive.destroy();
	mInactiveLoaders.put(id, info);
	} else {
	// We already have an inactive loader for this ID that we are
	// waiting for! Now we have three active loaders... let's just
	// drop the one in the middle, since we are still waiting for
	// its result but that result is already out of date.
	if (DEBUG) Log.v(TAG, " Removing intermediate loader in " + this);
	info.destroy();
	}
	} else {
	// Keep track of the previous instance of this loader so we can destroy
	// it when the new one completes.
	if (DEBUG) Log.v(TAG, " Making inactive: " + info);
	mInactiveLoaders.put(id, info);
	}
	}

	info = createLoader(id, args, (LoaderManager.LoaderCallbacks<Object>)callback);
	return (Loader<D>)info.mLoader;
	}

	public void stopLoader(int id) {
	if (DEBUG) Log.v(TAG, "stopLoader in " + this + " of " + id);
	int idx = mLoaders.indexOfKey(id);
	if (idx >= 0) {
	LoaderInfo info = mLoaders.valueAt(idx);
	mLoaders.removeAt(idx);
	info.destroy();
	}
	}

	@SuppressWarnings("unchecked")
	public <D> Loader<D> getLoader(int id) {
	LoaderInfo loaderInfo = mLoaders.get(id);
	if (loaderInfo != null) {
	return (Loader<D>)mLoaders.get(id).mLoader;
	}
	return null;
	}

	void doStart() {
	if (DEBUG) Log.v(TAG, "Starting: " + this);

	// 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();
	}
	mStarted = true;
	}

	void doStop() {
	if (DEBUG) Log.v(TAG, "Stopping: " + this);

	for (int i = mLoaders.size()-1; i >= 0; i--) {
	mLoaders.valueAt(i).stop();
	}
	mStarted = false;
	}

	void doRetain() {
	if (DEBUG) Log.v(TAG, "Retaining: " + this);

	mRetaining = true;
	mStarted = false;
	for (int i = mLoaders.size()-1; i >= 0; i--) {
	mLoaders.valueAt(i).retain();
	}
	}

	void finishRetain() {
	if (DEBUG) Log.v(TAG, "Finished Retaining: " + this);

	mRetaining = false;
	for (int i = mLoaders.size()-1; i >= 0; i--) {
	mLoaders.valueAt(i).finishRetain();
	}
	}

	void doDestroy() {
	if (!mRetaining) {
	if (DEBUG) Log.v(TAG, "Destroying Active: " + this);
	for (int i = mLoaders.size()-1; i >= 0; i--) {
	mLoaders.valueAt(i).destroy();
	}
	}

	if (DEBUG) Log.v(TAG, "Destroying Inactive: " + this);
	for (int i = mInactiveLoaders.size()-1; i >= 0; i--) {
	mInactiveLoaders.valueAt(i).destroy();
	}
	mInactiveLoaders.clear();
	}
	}