/**
* 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;
}
public <D> Loader<D> initLoader(
int paramInt, Bundle paramBundle, LoaderManager.LoaderCallbacks<D> paramLoaderCallbacks) {
if (this.mCreatingLoader) {
throw new IllegalStateException("Called while creating a loader");
}
LoaderInfo localLoaderInfo = (LoaderInfo) this.mLoaders.get(paramInt);
if (DEBUG) {
Log.v("LoaderManager", "initLoader in " + this + ": args=" + paramBundle);
}
if (localLoaderInfo == null) {
paramLoaderCallbacks = createAndInstallLoader(paramInt, paramBundle, paramLoaderCallbacks);
paramBundle = paramLoaderCallbacks;
if (DEBUG) {
Log.v("LoaderManager", " Created new loader " + paramLoaderCallbacks);
}
}
for (paramBundle = paramLoaderCallbacks; ; paramBundle = localLoaderInfo) {
if ((paramBundle.mHaveData) && (this.mStarted)) {
paramBundle.callOnLoadFinished(paramBundle.mLoader, paramBundle.mData);
}
return paramBundle.mLoader;
if (DEBUG) {
Log.v("LoaderManager", " Re-using existing loader " + localLoaderInfo);
}
localLoaderInfo.mCallbacks = paramLoaderCallbacks;
}
}
public void destroyLoader(int paramInt)
{
if (this.mCreatingLoader)
throw new IllegalStateException("Called while creating a loader");
if (DEBUG)
{
String str = "destroyLoader in " + this + " of " + paramInt;
int i = Log.v("LoaderManager", str);
}
int j = this.mLoaders.indexOfKey(paramInt);
if (j >= 0)
{
LoaderInfo localLoaderInfo1 = (LoaderInfo)this.mLoaders.valueAt(j);
this.mLoaders.removeAt(j);
localLoaderInfo1.destroy();
}
int k = this.mInactiveLoaders.indexOfKey(paramInt);
if (k >= 0)
{
LoaderInfo localLoaderInfo2 = (LoaderInfo)this.mInactiveLoaders.valueAt(k);
this.mInactiveLoaders.removeAt(k);
localLoaderInfo2.destroy();
}
if (this.mActivity == null)
return;
if (hasRunningLoaders())
return;
this.mActivity.mFragments.startPendingDeferredFragments();
}
private LoaderInfo createLoader(int paramInt, Bundle paramBundle, LoaderManager.LoaderCallbacks<Object> paramLoaderCallbacks)
{
LoaderInfo localLoaderInfo = new LoaderInfo(paramInt, paramBundle, paramLoaderCallbacks);
Loader localLoader = paramLoaderCallbacks.onCreateLoader(paramInt, paramBundle);
localLoaderInfo.mLoader = localLoader;
return localLoaderInfo;
}
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;
}
@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);
}
}
public <D> Loader<D> restartLoader(
int paramInt, Bundle paramBundle, LoaderManager.LoaderCallbacks<D> paramLoaderCallbacks) {
if (this.mCreatingLoader) {
throw new IllegalStateException("Called while creating a loader");
}
LoaderInfo localLoaderInfo1 = (LoaderInfo) this.mLoaders.get(paramInt);
if (DEBUG) {
Log.v("LoaderManager", "restartLoader in " + this + ": args=" + paramBundle);
}
if (localLoaderInfo1 != null) {
LoaderInfo localLoaderInfo2 = (LoaderInfo) this.mInactiveLoaders.get(paramInt);
if (localLoaderInfo2 == null) {
break label329;
}
if (!localLoaderInfo1.mHaveData) {
break label175;
}
if (DEBUG) {
Log.v("LoaderManager", " Removing last inactive loader: " + localLoaderInfo1);
}
localLoaderInfo2.mDeliveredData = false;
localLoaderInfo2.destroy();
localLoaderInfo1.mLoader.abandon();
this.mInactiveLoaders.put(paramInt, localLoaderInfo1);
}
for (; ; ) {
return createAndInstallLoader(paramInt, paramBundle, paramLoaderCallbacks).mLoader;
label175:
if (!localLoaderInfo1.mStarted) {
if (DEBUG) {
Log.v("LoaderManager", " Current loader is stopped; replacing");
}
this.mLoaders.put(paramInt, null);
localLoaderInfo1.destroy();
} else {
if (DEBUG) {
Log.v("LoaderManager", " Current loader is running; attempting to cancel");
}
localLoaderInfo1.cancel();
if (localLoaderInfo1.mPendingLoader != null) {
if (DEBUG) {
Log.v("LoaderManager", " Removing pending loader: " + localLoaderInfo1.mPendingLoader);
}
localLoaderInfo1.mPendingLoader.destroy();
localLoaderInfo1.mPendingLoader = null;
}
if (DEBUG) {
Log.v("LoaderManager", " Enqueuing as new pending loader");
}
localLoaderInfo1.mPendingLoader = createLoader(paramInt, paramBundle, paramLoaderCallbacks);
return localLoaderInfo1.mPendingLoader.mLoader;
label329:
if (DEBUG) {
Log.v("LoaderManager", " Making last loader inactive: " + localLoaderInfo1);
}
localLoaderInfo1.mLoader.abandon();
this.mInactiveLoaders.put(paramInt, localLoaderInfo1);
}
}
}
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 (mActivity != null) {
lastBecause = mActivity.mFragments.mNoTransactionsBecause;
mActivity.mFragments.mNoTransactionsBecause = "onLoaderReset";
}
try {
mCallbacks.onLoaderReset(mLoader);
} finally {
if (mActivity != null) {
mActivity.mFragments.mNoTransactionsBecause = lastBecause;
}
}
}
mCallbacks = null;
mData = null;
mHaveData = false;
if (mLoader != null) {
if (mListenerRegistered) {
mListenerRegistered = false;
mLoader.unregisterListener(this);
}
mLoader.reset();
}
if (mPendingLoader != null) {
mPendingLoader.destroy();
}
}
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();
}
}
void installLoader(LoaderInfo paramLoaderInfo)
{
SparseArrayCompat localSparseArrayCompat = this.mLoaders;
int i = paramLoaderInfo.mId;
localSparseArrayCompat.put(i, paramLoaderInfo);
if (!this.mStarted)
return;
paramLoaderInfo.start();
}
/**
* 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! What to do, what to do...
if (!info.mStarted) {
// The current Loader has not been started... we thus
// have no reason to keep it around, so bam, slam,
// thank-you-ma'am.
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 (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();
}
}
public void dump(
String paramString,
FileDescriptor paramFileDescriptor,
PrintWriter paramPrintWriter,
String[] paramArrayOfString) {
String str;
int i;
LoaderInfo localLoaderInfo;
if (this.mLoaders.size() > 0) {
paramPrintWriter.print(paramString);
paramPrintWriter.println("Active Loaders:");
str = paramString + " ";
i = 0;
while (i < this.mLoaders.size()) {
localLoaderInfo = (LoaderInfo) this.mLoaders.valueAt(i);
paramPrintWriter.print(paramString);
paramPrintWriter.print(" #");
paramPrintWriter.print(this.mLoaders.keyAt(i));
paramPrintWriter.print(": ");
paramPrintWriter.println(localLoaderInfo.toString());
localLoaderInfo.dump(str, paramFileDescriptor, paramPrintWriter, paramArrayOfString);
i += 1;
}
}
if (this.mInactiveLoaders.size() > 0) {
paramPrintWriter.print(paramString);
paramPrintWriter.println("Inactive Loaders:");
str = paramString + " ";
i = 0;
while (i < this.mInactiveLoaders.size()) {
localLoaderInfo = (LoaderInfo) this.mInactiveLoaders.valueAt(i);
paramPrintWriter.print(paramString);
paramPrintWriter.print(" #");
paramPrintWriter.print(this.mInactiveLoaders.keyAt(i));
paramPrintWriter.print(": ");
paramPrintWriter.println(localLoaderInfo.toString());
localLoaderInfo.dump(str, paramFileDescriptor, paramPrintWriter, paramArrayOfString);
i += 1;
}
}
}
@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 <D> Loader<D> initLoader(int paramInt, Bundle paramBundle, LoaderManager.LoaderCallbacks<D> paramLoaderCallbacks)
{
if (this.mCreatingLoader)
throw new IllegalStateException("Called while creating a loader");
LoaderInfo localLoaderInfo = (LoaderInfo)this.mLoaders.get(paramInt);
if (DEBUG)
{
String str1 = "initLoader in " + this + ": args=" + paramBundle;
int i = Log.v("LoaderManager", str1);
}
if (localLoaderInfo == null)
{
localLoaderInfo = createAndInstallLoader(paramInt, paramBundle, paramLoaderCallbacks);
if (DEBUG)
{
String str2 = " Created new loader " + localLoaderInfo;
int j = Log.v("LoaderManager", str2);
}
}
while (true)
{
if ((localLoaderInfo.mHaveData) && (this.mStarted))
{
Loader localLoader = localLoaderInfo.mLoader;
Object localObject = localLoaderInfo.mData;
localLoaderInfo.callOnLoadFinished(localLoader, localObject);
}
return localLoaderInfo.mLoader;
if (DEBUG)
{
String str3 = " Re-using existing loader " + localLoaderInfo;
int k = Log.v("LoaderManager", str3);
}
localLoaderInfo.mCallbacks = paramLoaderCallbacks;
}
}
public void destroyLoader(int paramInt) {
if (this.mCreatingLoader) {
throw new IllegalStateException("Called while creating a loader");
}
if (DEBUG) {
Log.v("LoaderManager", "destroyLoader in " + this + " of " + paramInt);
}
int i = this.mLoaders.indexOfKey(paramInt);
LoaderInfo localLoaderInfo;
if (i >= 0) {
localLoaderInfo = (LoaderInfo) this.mLoaders.valueAt(i);
this.mLoaders.removeAt(i);
localLoaderInfo.destroy();
}
paramInt = this.mInactiveLoaders.indexOfKey(paramInt);
if (paramInt >= 0) {
localLoaderInfo = (LoaderInfo) this.mInactiveLoaders.valueAt(paramInt);
this.mInactiveLoaders.removeAt(paramInt);
localLoaderInfo.destroy();
}
if ((this.mHost != null) && (!hasRunningLoaders())) {
this.mHost.mFragmentManager.startPendingDeferredFragments();
}
}
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(" mRetaining=");
writer.print(mRetaining);
writer.print(" mDestroyed=");
writer.println(mDestroyed);
writer.print(prefix);
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);
}
}
public void dump(String paramString, FileDescriptor paramFileDescriptor, PrintWriter paramPrintWriter, String[] paramArrayOfString)
{
if (this.mLoaders.size() > 0)
{
paramPrintWriter.print(paramString);
paramPrintWriter.println("Active Loaders:");
str1 = paramString + " ";
i = 0;
while (true)
{
int j = this.mLoaders.size();
if (i >= j)
break;
LoaderInfo localLoaderInfo1 = (LoaderInfo)this.mLoaders.valueAt(i);
paramPrintWriter.print(paramString);
paramPrintWriter.print(" #");
int k = this.mLoaders.keyAt(i);
paramPrintWriter.print(k);
paramPrintWriter.print(": ");
String str2 = localLoaderInfo1.toString();
paramPrintWriter.println(str2);
localLoaderInfo1.dump(str1, paramFileDescriptor, paramPrintWriter, paramArrayOfString);
i += 1;
}
}
if (this.mInactiveLoaders.size() <= 0)
return;
paramPrintWriter.print(paramString);
paramPrintWriter.println("Inactive Loaders:");
String str1 = paramString + " ";
int i = 0;
while (true)
{
int m = this.mInactiveLoaders.size();
if (i >= m)
return;
LoaderInfo localLoaderInfo2 = (LoaderInfo)this.mInactiveLoaders.valueAt(i);
paramPrintWriter.print(paramString);
paramPrintWriter.print(" #");
int n = this.mInactiveLoaders.keyAt(i);
paramPrintWriter.print(n);
paramPrintWriter.print(": ");
String str3 = localLoaderInfo2.toString();
paramPrintWriter.println(str3);
localLoaderInfo2.dump(str1, paramFileDescriptor, paramPrintWriter, paramArrayOfString);
i += 1;
}
}
public <D> Loader<D> restartLoader(int paramInt, Bundle paramBundle, LoaderManager.LoaderCallbacks<D> paramLoaderCallbacks)
{
if (this.mCreatingLoader)
throw new IllegalStateException("Called while creating a loader");
LoaderInfo localLoaderInfo1 = (LoaderInfo)this.mLoaders.get(paramInt);
if (DEBUG)
{
String str1 = "restartLoader in " + this + ": args=" + paramBundle;
int i = Log.v("LoaderManager", str1);
}
if (localLoaderInfo1 != null)
{
LoaderInfo localLoaderInfo2 = (LoaderInfo)this.mInactiveLoaders.get(paramInt);
if (localLoaderInfo2 == null)
break label346;
if (!localLoaderInfo1.mHaveData)
break label189;
if (DEBUG)
{
String str2 = " Removing last inactive loader: " + localLoaderInfo1;
int j = Log.v("LoaderManager", str2);
}
localLoaderInfo2.mDeliveredData = false;
localLoaderInfo2.destroy();
localLoaderInfo1.mLoader.abandon();
this.mInactiveLoaders.put(paramInt, localLoaderInfo1);
}
while (true)
{
for (Loader localLoader = createAndInstallLoader(paramInt, paramBundle, paramLoaderCallbacks).mLoader; ; localLoader = localLoaderInfo1.mPendingLoader.mLoader)
{
return localLoader;
label189: if (!localLoaderInfo1.mStarted)
{
if (DEBUG)
int k = Log.v("LoaderManager", " Current loader is stopped; replacing");
this.mLoaders.put(paramInt, null);
localLoaderInfo1.destroy();
break;
}
if (localLoaderInfo1.mPendingLoader != null)
{
if (DEBUG)
{
StringBuilder localStringBuilder = new StringBuilder().append(" Removing pending loader: ");
LoaderInfo localLoaderInfo3 = localLoaderInfo1.mPendingLoader;
String str3 = localLoaderInfo3;
int m = Log.v("LoaderManager", str3);
}
localLoaderInfo1.mPendingLoader.destroy();
localLoaderInfo1.mPendingLoader = null;
}
if (DEBUG)
int n = Log.v("LoaderManager", " Enqueuing as new pending loader");
LoaderInfo localLoaderInfo4 = createLoader(paramInt, paramBundle, paramLoaderCallbacks);
localLoaderInfo1.mPendingLoader = localLoaderInfo4;
}
label346: if (DEBUG)
{
String str4 = " Making last loader inactive: " + localLoaderInfo1;
int i1 = Log.v("LoaderManager", str4);
}
localLoaderInfo1.mLoader.abandon();
this.mInactiveLoaders.put(paramInt, localLoaderInfo1);
}
}
void installLoader(LoaderInfo paramLoaderInfo) {
this.mLoaders.put(paramLoaderInfo.mId, paramLoaderInfo);
if (this.mStarted) {
paramLoaderInfo.start();
}
}
public void dump(String paramString, FileDescriptor paramFileDescriptor, PrintWriter paramPrintWriter, String[] paramArrayOfString)
{
paramPrintWriter.print(paramString);
paramPrintWriter.print("mId=");
int i = this.mId;
paramPrintWriter.print(i);
paramPrintWriter.print(" mArgs=");
Bundle localBundle = this.mArgs;
paramPrintWriter.println(localBundle);
paramPrintWriter.print(paramString);
paramPrintWriter.print("mCallbacks=");
LoaderManager.LoaderCallbacks localLoaderCallbacks = this.mCallbacks;
paramPrintWriter.println(localLoaderCallbacks);
paramPrintWriter.print(paramString);
paramPrintWriter.print("mLoader=");
Loader localLoader1 = this.mLoader;
paramPrintWriter.println(localLoader1);
if (this.mLoader != null)
{
Loader localLoader2 = this.mLoader;
String str1 = paramString + " ";
localLoader2.dump(str1, paramFileDescriptor, paramPrintWriter, paramArrayOfString);
}
if ((this.mHaveData) || (this.mDeliveredData))
{
paramPrintWriter.print(paramString);
paramPrintWriter.print("mHaveData=");
boolean bool1 = this.mHaveData;
paramPrintWriter.print(bool1);
paramPrintWriter.print(" mDeliveredData=");
boolean bool2 = this.mDeliveredData;
paramPrintWriter.println(bool2);
paramPrintWriter.print(paramString);
paramPrintWriter.print("mData=");
Object localObject = this.mData;
paramPrintWriter.println(localObject);
}
paramPrintWriter.print(paramString);
paramPrintWriter.print("mStarted=");
boolean bool3 = this.mStarted;
paramPrintWriter.print(bool3);
paramPrintWriter.print(" mReportNextStart=");
boolean bool4 = this.mReportNextStart;
paramPrintWriter.print(bool4);
paramPrintWriter.print(" mDestroyed=");
boolean bool5 = this.mDestroyed;
paramPrintWriter.println(bool5);
paramPrintWriter.print(paramString);
paramPrintWriter.print("mRetaining=");
boolean bool6 = this.mRetaining;
paramPrintWriter.print(bool6);
paramPrintWriter.print(" mRetainingStarted=");
boolean bool7 = this.mRetainingStarted;
paramPrintWriter.print(bool7);
paramPrintWriter.print(" mListenerRegistered=");
boolean bool8 = this.mListenerRegistered;
paramPrintWriter.println(bool8);
if (this.mPendingLoader == null)
return;
paramPrintWriter.print(paramString);
paramPrintWriter.println("Pending Loader ");
LoaderInfo localLoaderInfo1 = this.mPendingLoader;
paramPrintWriter.print(localLoaderInfo1);
paramPrintWriter.println(":");
LoaderInfo localLoaderInfo2 = this.mPendingLoader;
String str2 = paramString + " ";
localLoaderInfo2.dump(str2, paramFileDescriptor, paramPrintWriter, paramArrayOfString);
}
public void onLoadComplete(Loader<Object> paramLoader, Object paramObject)
{
if (LoaderManagerImpl.DEBUG)
{
String str1 = "onLoadComplete: " + this;
int i = Log.v("LoaderManager", str1);
}
if (this.mDestroyed)
{
if (!LoaderManagerImpl.DEBUG)
return;
int j = Log.v("LoaderManager", " Ignoring load complete -- destroyed");
return;
}
SparseArrayCompat localSparseArrayCompat1 = LoaderManagerImpl.this.mLoaders;
int k = this.mId;
if (localSparseArrayCompat1.get(k) != this)
{
if (!LoaderManagerImpl.DEBUG)
return;
int m = Log.v("LoaderManager", " Ignoring load complete -- not active");
return;
}
LoaderInfo localLoaderInfo1 = this.mPendingLoader;
if (localLoaderInfo1 != null)
{
if (LoaderManagerImpl.DEBUG)
{
String str2 = " Switching to pending loader: " + localLoaderInfo1;
int n = Log.v("LoaderManager", str2);
}
this.mPendingLoader = null;
SparseArrayCompat localSparseArrayCompat2 = LoaderManagerImpl.this.mLoaders;
int i1 = this.mId;
localSparseArrayCompat2.put(i1, null);
destroy();
LoaderManagerImpl.this.installLoader(localLoaderInfo1);
return;
}
if ((this.mData != paramObject) || (!this.mHaveData))
{
this.mData = paramObject;
this.mHaveData = true;
if (this.mStarted)
callOnLoadFinished(paramLoader, paramObject);
}
SparseArrayCompat localSparseArrayCompat3 = LoaderManagerImpl.this.mInactiveLoaders;
int i2 = this.mId;
LoaderInfo localLoaderInfo2 = (LoaderInfo)localSparseArrayCompat3.get(i2);
if ((localLoaderInfo2 != null) && (localLoaderInfo2 != this))
{
localLoaderInfo2.mDeliveredData = false;
localLoaderInfo2.destroy();
SparseArrayCompat localSparseArrayCompat4 = LoaderManagerImpl.this.mInactiveLoaders;
int i3 = this.mId;
localSparseArrayCompat4.remove(i3);
}
if (LoaderManagerImpl.this.mActivity == null)
return;
if (LoaderManagerImpl.this.hasRunningLoaders())
return;
LoaderManagerImpl.this.mActivity.mFragments.startPendingDeferredFragments();
}
