Java tutorial
/* * 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.DebugUtils; import android.util.Log; import android.util.SparseArray; import java.io.FileDescriptor; import java.io.PrintWriter; import java.lang.reflect.Modifier; /** * Interface associated with an {@link Activity} or {@link Fragment} for managing * one or more {@link android.content.Loader} instances associated with it. This * helps an application manage longer-running operations in conjunction with the * Activity or Fragment lifecycle; the most common use of this is with a * {@link android.content.CursorLoader}, however applications are free to write * their own loaders for loading other types of data. * * While the LoaderManager API was introduced in * {@link android.os.Build.VERSION_CODES#HONEYCOMB}, a version of the API * at is also available for use on older platforms through * {@link android.support.v4.app.FragmentActivity}. See the blog post * <a href="http://android-developers.blogspot.com/2011/03/fragments-for-all.html"> * Fragments For All</a> for more details. * * <p>As an example, here is the full implementation of a {@link Fragment} * that displays a {@link android.widget.ListView} containing the results of * a query against the contacts content provider. It uses a * {@link android.content.CursorLoader} to manage the query on the provider. * * {@sample development/samples/ApiDemos/src/com/example/android/apis/app/LoaderCursor.java * fragment_cursor} * * <div class="special reference"> * <h3>Developer Guides</h3> * <p>For more information about using loaders, read the * <a href="{@docRoot}guide/topics/fundamentals/loaders.html">Loaders</a> developer guide.</p> * </div> * * @deprecated Use the <a href="{@docRoot}tools/extras/support-library.html">Support Library</a> * {@link android.support.v4.app.LoaderManager} */ @Deprecated public abstract class LoaderManager { /** * Callback interface for a client to interact with the manager. * * @deprecated Use the <a href="{@docRoot}tools/extras/support-library.html"> * Support Library</a> {@link android.support.v4.app.LoaderManager.LoaderCallbacks} */ @Deprecated 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. Note * that normally an application is <em>not</em> allowed to commit fragment * transactions while in this call, since it can happen after an * activity's state is saved. See {@link FragmentManager#beginTransaction() * FragmentManager.openTransaction()} for further discussion on this. * * <p>This function is guaranteed to be called prior to the release of * the last data that was supplied for this Loader. At this point * you should remove all use of the old data (since it will be released * soon), but should not do your own release of the data since its Loader * owns it and will take care of that. The Loader will take care of * management of its data so you don't have to. In particular: * * <ul> * <li> <p>The Loader will monitor for changes to the data, and report * them to you through new calls here. You should not monitor the * data yourself. For example, if the data is a {@link android.database.Cursor} * and you place it in a {@link android.widget.CursorAdapter}, use * the {@link android.widget.CursorAdapter#CursorAdapter(android.content.Context, * android.database.Cursor, int)} constructor <em>without</em> passing * in either {@link android.widget.CursorAdapter#FLAG_AUTO_REQUERY} * or {@link android.widget.CursorAdapter#FLAG_REGISTER_CONTENT_OBSERVER} * (that is, use 0 for the flags argument). This prevents the CursorAdapter * from doing its own observing of the Cursor, which is not needed since * when a change happens you will get a new Cursor throw another call * here. * <li> The Loader will release the data once it knows the application * is no longer using it. For example, if the data is * a {@link android.database.Cursor} from a {@link android.content.CursorLoader}, * you should not call close() on it yourself. If the Cursor is being placed in a * {@link android.widget.CursorAdapter}, you should use the * {@link android.widget.CursorAdapter#swapCursor(android.database.Cursor)} * method so that the old Cursor is not closed. * </ul> * * @param loader The Loader that has finished. * @param data The data generated by the Loader. */ public void onLoadFinished(Loader<D> loader, D data); /** * Called when a previously created loader is being reset, and thus * making its data unavailable. The application should at this point * remove any references it has to the Loader's data. * * @param loader The Loader that is being reset. */ public void onLoaderReset(Loader<D> loader); } /** * 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. * * @param id A unique identifier for this loader. Can be whatever you want. * Identifiers are scoped to a particular LoaderManager instance. * @param args Optional arguments to supply to the loader at construction. * If a loader already exists (a new one does not need to be created), this * parameter will be ignored and the last arguments continue to be used. * @param callback Interface the LoaderManager will call to report about * changes in the state of the loader. Required. */ public abstract <D> Loader<D> initLoader(int id, Bundle args, LoaderManager.LoaderCallbacks<D> callback); /** * Starts a new or restarts an existing {@link android.content.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. * * @param id A unique identifier for this loader. Can be whatever you want. * Identifiers are scoped to a particular LoaderManager instance. * @param args Optional arguments to supply to the loader at construction. * @param callback Interface the LoaderManager will call to report about * changes in the state of the loader. Required. */ public abstract <D> Loader<D> restartLoader(int id, Bundle args, LoaderManager.LoaderCallbacks<D> callback); /** * Stops and removes the loader with the given ID. If this loader * had previously reported data to the client through * {@link LoaderCallbacks#onLoadFinished(Loader, Object)}, a call * will be made to {@link LoaderCallbacks#onLoaderReset(Loader)}. */ public abstract void destroyLoader(int id); /** * Return the Loader with the given id or null if no matching Loader * is found. */ public abstract <D> Loader<D> getLoader(int id); /** * Print the LoaderManager's state into the given stream. * * @param prefix Text to print at the front of each line. * @param fd The raw file descriptor that the dump is being sent to. * @param writer A PrintWriter to which the dump is to be set. * @param args Additional arguments to the dump request. */ public abstract void dump(String prefix, FileDescriptor fd, PrintWriter writer, String[] args); /** * Control whether the framework's internal loader manager debugging * logs are turned on. If enabled, you will see output in logcat as * the framework performs loader operations. */ public static void enableDebugLogging(boolean enabled) { LoaderManagerImpl.DEBUG = enabled; } /** @hide for internal testing only */ public FragmentHostCallback getFragmentHostCallback() { return null; } } class LoaderManagerImpl extends LoaderManager { static final String TAG = "LoaderManager"; static boolean DEBUG = false; // 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>(0); // 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>(0); final String mWho; boolean mStarted; boolean mRetaining; boolean mRetainingStarted; boolean mCreatingLoader; private FragmentHostCallback mHost; final class LoaderInfo implements Loader.OnLoadCompleteListener<Object>, Loader.OnLoadCanceledListener<Object> { final int mId; final Bundle mArgs; LoaderManager.LoaderCallbacks<Object> mCallbacks; Loader<Object> mLoader; boolean mHaveData; boolean mDeliveredData; Object mData; boolean mStarted; boolean mRetaining; boolean mRetainingStarted; boolean mReportNextStart; boolean mDestroyed; boolean mListenerRegistered; LoaderInfo mPendingLoader; 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; } 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(); } } 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 && mHaveData && !mReportNextStart) { // This loader has retained its data, either completely across // a configuration change or just whatever the last data set // was after being restarted from a stop, 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. callOnLoadFinished(mLoader, mData); } } void reportStart() { if (mStarted) { if (mReportNextStart) { mReportNextStart = false; if (mHaveData && !mRetaining) { callOnLoadFinished(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.unregisterOnLoadCanceledListener(this); mLoader.stopLoading(); } } } boolean cancel() { if (DEBUG) Log.v(TAG, " Canceling: " + this); if (mStarted && mLoader != null && mListenerRegistered) { final boolean cancelLoadResult = mLoader.cancelLoad(); if (!cancelLoadResult) { onLoadCanceled(mLoader); } return cancelLoadResult; } return false; } void destroy() { if (DEBUG) Log.v(TAG, " Destroying: " + this); mDestroyed = true; boolean needReset = mDeliveredData; mDeliveredData = false; if (mCallbacks != null && mLoader != null && mHaveData && needReset) { if (DEBUG) Log.v(TAG, " Reseting: " + this); String lastBecause = null; if (mHost != null) { lastBecause = mHost.mFragmentManager.mNoTransactionsBecause; mHost.mFragmentManager.mNoTransactionsBecause = "onLoaderReset"; } try { mCallbacks.onLoaderReset(mLoader); } finally { if (mHost != null) { mHost.mFragmentManager.mNoTransactionsBecause = lastBecause; } } } mCallbacks = null; mData = null; mHaveData = false; if (mLoader != null) { if (mListenerRegistered) { mListenerRegistered = false; mLoader.unregisterListener(this); mLoader.unregisterOnLoadCanceledListener(this); } mLoader.reset(); } if (mPendingLoader != null) { mPendingLoader.destroy(); } } @Override public void onLoadCanceled(Loader<Object> loader) { if (DEBUG) Log.v(TAG, "onLoadCanceled: " + this); if (mDestroyed) { if (DEBUG) Log.v(TAG, " Ignoring load canceled -- destroyed"); return; } if (mLoaders.get(mId) != this) { // This cancellation message is not coming from the current active loader. // We don't care about it. if (DEBUG) Log.v(TAG, " Ignoring load canceled -- not active"); return; } LoaderInfo pending = mPendingLoader; if (pending != null) { // There is a new request pending and we were just // waiting for the old one to cancel or complete before starting // it. So now it is time, switch over to the new loader. if (DEBUG) Log.v(TAG, " Switching to pending loader: " + pending); mPendingLoader = null; mLoaders.put(mId, null); destroy(); installLoader(pending); } } @Override public void onLoadComplete(Loader<Object> loader, Object data) { if (DEBUG) Log.v(TAG, "onLoadComplete: " + this); if (mDestroyed) { if (DEBUG) Log.v(TAG, " Ignoring load complete -- destroyed"); return; } if (mLoaders.get(mId) != this) { // This data is not coming from the current active loader. // We don't care about it. if (DEBUG) Log.v(TAG, " Ignoring load complete -- not active"); return; } LoaderInfo pending = mPendingLoader; if (pending != null) { // There is a new request pending and we were just // waiting for the old one to complete before starting // it. So now it is time, switch over to the new loader. if (DEBUG) Log.v(TAG, " Switching to pending loader: " + pending); mPendingLoader = null; mLoaders.put(mId, null); destroy(); installLoader(pending); return; } // Notify of the new data so the app can switch out the old data before // we try to destroy it. if (mData != data || !mHaveData) { mData = data; mHaveData = true; if (mStarted) { callOnLoadFinished(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.mDeliveredData = false; info.destroy(); mInactiveLoaders.remove(mId); } if (mHost != null && !hasRunningLoaders()) { mHost.mFragmentManager.startPendingDeferredFragments(); } } void callOnLoadFinished(Loader<Object> loader, Object data) { if (mCallbacks != null) { String lastBecause = null; if (mHost != null) { lastBecause = mHost.mFragmentManager.mNoTransactionsBecause; mHost.mFragmentManager.mNoTransactionsBecause = "onLoadFinished"; } try { if (DEBUG) Log.v(TAG, " onLoadFinished in " + loader + ": " + loader.dataToString(data)); mCallbacks.onLoadFinished(loader, data); } finally { if (mHost != null) { mHost.mFragmentManager.mNoTransactionsBecause = lastBecause; } } mDeliveredData = true; } } @Override public String toString() { StringBuilder sb = new StringBuilder(64); sb.append("LoaderInfo{"); sb.append(Integer.toHexString(System.identityHashCode(this))); sb.append(" #"); sb.append(mId); sb.append(" : "); DebugUtils.buildShortClassTag(mLoader, sb); sb.append("}}"); return sb.toString(); } public void dump(String prefix, FileDescriptor fd, PrintWriter writer, String[] args) { writer.print(prefix); writer.print("mId="); writer.print(mId); writer.print(" mArgs="); writer.println(mArgs); writer.print(prefix); writer.print("mCallbacks="); writer.println(mCallbacks); writer.print(prefix); writer.print("mLoader="); writer.println(mLoader); if (mLoader != null) { mLoader.dump(prefix + " ", fd, writer, args); } if (mHaveData || mDeliveredData) { writer.print(prefix); writer.print("mHaveData="); writer.print(mHaveData); writer.print(" mDeliveredData="); writer.println(mDeliveredData); writer.print(prefix); writer.print("mData="); writer.println(mData); } writer.print(prefix); writer.print("mStarted="); writer.print(mStarted); writer.print(" mReportNextStart="); writer.print(mReportNextStart); writer.print(" mDestroyed="); writer.println(mDestroyed); writer.print(prefix); writer.print("mRetaining="); writer.print(mRetaining); writer.print(" mRetainingStarted="); writer.print(mRetainingStarted); writer.print(" mListenerRegistered="); writer.println(mListenerRegistered); if (mPendingLoader != null) { writer.print(prefix); writer.println("Pending Loader "); writer.print(mPendingLoader); writer.println(":"); mPendingLoader.dump(prefix + " ", fd, writer, args); } } } LoaderManagerImpl(String who, FragmentHostCallback host, boolean started) { mWho = who; mHost = host; mStarted = started; } void updateHostController(FragmentHostCallback host) { mHost = host; } public FragmentHostCallback getFragmentHostCallback() { return mHost; } 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; } 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; } } 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(); } } /** * Call to initialize a particular ID with a Loader. If this ID already * has a Loader associated with it, it is left unchanged and any previous * callbacks replaced with the newly provided ones. If there is not currently * a Loader for the ID, a new one is created and started. * * <p>This function should generally be used when a component is initializing, * to ensure that a Loader it relies on is created. This allows it to re-use * an existing Loader's data if there already is one, so that for example * when an {@link Activity} is re-created after a configuration change it * does not need to re-create its loaders. * * <p>Note that in the case where an existing Loader is re-used, the * <var>args</var> given here <em>will be ignored</em> because you will * continue using the previous Loader. * * @param id A unique (to this LoaderManager instance) identifier under * which to manage the new Loader. * @param args Optional arguments that will be propagated to * {@link LoaderCallbacks#onCreateLoader(int, Bundle) LoaderCallbacks.onCreateLoader()}. * @param callback Interface implementing management of this Loader. Required. * Its onCreateLoader() method will be called while inside of the function to * instantiate the Loader object. */ @SuppressWarnings("unchecked") 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; } /** * Call to re-create the Loader associated with a particular ID. If there * is currently a Loader associated with this ID, it will be * canceled/stopped/destroyed as appropriate. A new Loader with the given * arguments will be created and its data delivered to you once available. * * <p>This function does some throttling of Loaders. If too many Loaders * have been created for the given ID but not yet generated their data, * new calls to this function will create and return a new Loader but not * actually start it until some previous loaders have completed. * * <p>After calling this function, any previous Loaders associated with * this ID will be considered invalid, and you will receive no further * data updates from them. * * @param id A unique (to this LoaderManager instance) identifier under * which to manage the new Loader. * @param args Optional arguments that will be propagated to * {@link LoaderCallbacks#onCreateLoader(int, Bundle) LoaderCallbacks.onCreateLoader()}. * @param callback Interface implementing management of this Loader. Required. * Its onCreateLoader() method will be called while inside of the function to * instantiate the Loader object. */ @SuppressWarnings("unchecked") public <D> Loader<D> restartLoader(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, "restartLoader in " + this + ": args=" + args); if (info != null) { LoaderInfo inactive = mInactiveLoaders.get(id); if (inactive != null) { if (info.mHaveData) { // 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: " + info); inactive.mDeliveredData = false; inactive.destroy(); info.mLoader.abandon(); mInactiveLoaders.put(id, info); } else { // We already have an inactive loader for this ID that we are // waiting for! Try to cancel; if this returns true then the task is still // running and we have more work to do. if (!info.cancel()) { // The current Loader has not been started or was successfully canceled, // we thus have no reason to keep it around. Remove it and a new // LoaderInfo will be created below. if (DEBUG) Log.v(TAG, " Current loader is stopped; replacing"); mLoaders.put(id, null); info.destroy(); } else { // Now we have three active loaders... we'll queue // up this request to be processed once one of the other loaders // finishes. if (DEBUG) Log.v(TAG, " Current loader is running; configuring pending loader"); if (info.mPendingLoader != null) { if (DEBUG) Log.v(TAG, " Removing pending loader: " + info.mPendingLoader); info.mPendingLoader.destroy(); info.mPendingLoader = null; } if (DEBUG) Log.v(TAG, " Enqueuing as new pending loader"); info.mPendingLoader = createLoader(id, args, (LoaderManager.LoaderCallbacks<Object>) callback); return (Loader<D>) info.mPendingLoader.mLoader; } } } 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 last loader inactive: " + info); info.mLoader.abandon(); mInactiveLoaders.put(id, info); } } info = createAndInstallLoader(id, args, (LoaderManager.LoaderCallbacks<Object>) callback); return (Loader<D>) info.mLoader; } /** * Rip down, tear apart, shred to pieces a current Loader ID. After returning * from this function, any Loader objects associated with this ID are * destroyed. Any data associated with them is destroyed. You better not * be using it when you do this. * @param id Identifier of the Loader to be destroyed. */ public void destroyLoader(int id) { if (mCreatingLoader) { throw new IllegalStateException("Called while creating a loader"); } if (DEBUG) Log.v(TAG, "destroyLoader in " + this + " of " + id); int idx = mLoaders.indexOfKey(id); if (idx >= 0) { LoaderInfo info = mLoaders.valueAt(idx); mLoaders.removeAt(idx); info.destroy(); } idx = mInactiveLoaders.indexOfKey(id); if (idx >= 0) { LoaderInfo info = mInactiveLoaders.valueAt(idx); mInactiveLoaders.removeAt(idx); info.destroy(); } if (mHost != null && !hasRunningLoaders()) { mHost.mFragmentManager.startPendingDeferredFragments(); } } /** * Return the most recent Loader object associated with the * given ID. */ @SuppressWarnings("unchecked") public <D> Loader<D> getLoader(int id) { if (mCreatingLoader) { throw new IllegalStateException("Called while creating a loader"); } LoaderInfo loaderInfo = mLoaders.get(id); if (loaderInfo != null) { if (loaderInfo.mPendingLoader != null) { return (Loader<D>) loaderInfo.mPendingLoader.mLoader; } return (Loader<D>) loaderInfo.mLoader; } return null; } 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(); } } void doStop() { if (DEBUG) Log.v(TAG, "Stopping in " + this); if (!mStarted) { RuntimeException e = new RuntimeException("here"); e.fillInStackTrace(); Log.w(TAG, "Called doStop when not started: " + this, e); return; } for (int i = mLoaders.size() - 1; i >= 0; i--) { mLoaders.valueAt(i).stop(); } mStarted = false; } void doRetain() { if (DEBUG) Log.v(TAG, "Retaining in " + this); if (!mStarted) { RuntimeException e = new RuntimeException("here"); e.fillInStackTrace(); Log.w(TAG, "Called doRetain when not started: " + this, e); return; } mRetaining = true; mStarted = false; for (int i = mLoaders.size() - 1; i >= 0; i--) { mLoaders.valueAt(i).retain(); } } void finishRetain() { if (mRetaining) { if (DEBUG) Log.v(TAG, "Finished Retaining in " + this); mRetaining = false; for (int i = mLoaders.size() - 1; i >= 0; i--) { mLoaders.valueAt(i).finishRetain(); } } } void doReportNextStart() { for (int i = mLoaders.size() - 1; i >= 0; i--) { mLoaders.valueAt(i).mReportNextStart = true; } } void doReportStart() { for (int i = mLoaders.size() - 1; i >= 0; i--) { mLoaders.valueAt(i).reportStart(); } } void doDestroy() { if (!mRetaining) { if (DEBUG) Log.v(TAG, "Destroying Active in " + this); for (int i = mLoaders.size() - 1; i >= 0; i--) { mLoaders.valueAt(i).destroy(); } mLoaders.clear(); } if (DEBUG) Log.v(TAG, "Destroying Inactive in " + this); for (int i = mInactiveLoaders.size() - 1; i >= 0; i--) { mInactiveLoaders.valueAt(i).destroy(); } mInactiveLoaders.clear(); mHost = null; } @Override public String toString() { StringBuilder sb = new StringBuilder(128); sb.append("LoaderManager{"); sb.append(Integer.toHexString(System.identityHashCode(this))); sb.append(" in "); DebugUtils.buildShortClassTag(mHost, sb); sb.append("}}"); return sb.toString(); } @Override public void dump(String prefix, FileDescriptor fd, PrintWriter writer, String[] args) { if (mLoaders.size() > 0) { writer.print(prefix); writer.println("Active Loaders:"); String innerPrefix = prefix + " "; for (int i = 0; i < mLoaders.size(); i++) { LoaderInfo li = mLoaders.valueAt(i); writer.print(prefix); writer.print(" #"); writer.print(mLoaders.keyAt(i)); writer.print(": "); writer.println(li.toString()); li.dump(innerPrefix, fd, writer, args); } } if (mInactiveLoaders.size() > 0) { writer.print(prefix); writer.println("Inactive Loaders:"); String innerPrefix = prefix + " "; for (int i = 0; i < mInactiveLoaders.size(); i++) { LoaderInfo li = mInactiveLoaders.valueAt(i); writer.print(prefix); writer.print(" #"); writer.print(mInactiveLoaders.keyAt(i)); writer.print(": "); writer.println(li.toString()); li.dump(innerPrefix, fd, writer, args); } } } public boolean hasRunningLoaders() { boolean loadersRunning = false; final int count = mLoaders.size(); for (int i = 0; i < count; i++) { final LoaderInfo li = mLoaders.valueAt(i); loadersRunning |= li.mStarted && !li.mDeliveredData; } return loadersRunning; } }