alexandroid/decompiled/jadx/sources/androidx/loader/app/LoaderManagerImpl.java
KaKi87 a47fad5135 📦 Add decompiled Alexa 2.2.730155.0 (jadx, apktool, Hermes strings)
Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-07 00:04:16 +01:00

488 lines
18 KiB
Java

package androidx.loader.app;
import android.os.Bundle;
import android.os.Looper;
import android.util.Log;
import androidx.annotation.MainThread;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.collection.SparseArrayCompat;
import androidx.compose.runtime.BitVector$$ExternalSyntheticOutline0;
import androidx.core.os.ParcelCompat$$ExternalSyntheticOutline0;
import androidx.lifecycle.LifecycleOwner;
import androidx.lifecycle.MutableLiveData;
import androidx.lifecycle.Observer;
import androidx.lifecycle.ViewModel;
import androidx.lifecycle.ViewModelProvider;
import androidx.lifecycle.ViewModelStore;
import androidx.loader.app.LoaderManager;
import androidx.loader.content.Loader;
import dagger.internal.codegen.base.Formatter;
import java.io.FileDescriptor;
import java.io.PrintWriter;
import java.lang.reflect.Modifier;
import java.util.Objects;
import rx.Single$$ExternalSyntheticBUOutline0;
/* compiled from: r8-map-id-b9432e0f623b4a4bff4ba50a8a24c4aafad2c1e11092747b9fb5e6a22af5a940 */
/* loaded from: classes14.dex */
class LoaderManagerImpl extends LoaderManager {
static boolean DEBUG = false;
private static final String TAG = "LoaderManager";
@NonNull
private final LifecycleOwner mLifecycleOwner;
@NonNull
private final LoaderViewModel mLoaderViewModel;
/* compiled from: r8-map-id-b9432e0f623b4a4bff4ba50a8a24c4aafad2c1e11092747b9fb5e6a22af5a940 */
public static class LoaderInfo<D> extends MutableLiveData<D> implements Loader.OnLoadCompleteListener<D> {
@Nullable
private final Bundle mArgs;
private final int mId;
private LifecycleOwner mLifecycleOwner;
@NonNull
private final Loader<D> mLoader;
private LoaderObserver<D> mObserver;
private Loader<D> mPriorLoader;
public LoaderInfo(int i, @Nullable Bundle bundle, @NonNull Loader<D> loader, @Nullable Loader<D> loader2) {
this.mId = i;
this.mArgs = bundle;
this.mLoader = loader;
this.mPriorLoader = loader2;
loader.registerListener(i, this);
}
@MainThread
public Loader<D> destroy(boolean z) {
if (LoaderManagerImpl.DEBUG) {
toString();
}
this.mLoader.cancelLoad();
this.mLoader.abandon();
LoaderObserver<D> loaderObserver = this.mObserver;
if (loaderObserver != null) {
removeObserver(loaderObserver);
if (z) {
loaderObserver.reset();
}
}
this.mLoader.unregisterListener(this);
if ((loaderObserver == null || loaderObserver.hasDeliveredData()) && !z) {
return this.mLoader;
}
this.mLoader.reset();
return this.mPriorLoader;
}
public void dump(String str, FileDescriptor fileDescriptor, PrintWriter printWriter, String[] strArr) {
printWriter.print(str);
printWriter.print("mId=");
printWriter.print(this.mId);
printWriter.print(" mArgs=");
printWriter.println(this.mArgs);
printWriter.print(str);
printWriter.print("mLoader=");
printWriter.println(this.mLoader);
this.mLoader.dump(BitVector$$ExternalSyntheticOutline0.m(str, " "), fileDescriptor, printWriter, strArr);
if (this.mObserver != null) {
printWriter.print(str);
printWriter.print("mCallbacks=");
printWriter.println(this.mObserver);
this.mObserver.dump(BitVector$$ExternalSyntheticOutline0.m(str, " "), printWriter);
}
printWriter.print(str);
printWriter.print("mData=");
printWriter.println(getLoader().dataToString(getValue()));
printWriter.print(str);
printWriter.print("mStarted=");
printWriter.println(hasActiveObservers());
}
@NonNull
public Loader<D> getLoader() {
return this.mLoader;
}
public boolean isCallbackWaitingForData() {
LoaderObserver<D> loaderObserver;
return (!hasActiveObservers() || (loaderObserver = this.mObserver) == null || loaderObserver.hasDeliveredData()) ? false : true;
}
public void markForRedelivery() {
LifecycleOwner lifecycleOwner = this.mLifecycleOwner;
LoaderObserver<D> loaderObserver = this.mObserver;
if (lifecycleOwner == null || loaderObserver == null) {
return;
}
super.removeObserver(loaderObserver);
observe(lifecycleOwner, loaderObserver);
}
@Override // androidx.lifecycle.LiveData
public void onActive() {
if (LoaderManagerImpl.DEBUG) {
toString();
}
this.mLoader.startLoading();
}
@Override // androidx.lifecycle.LiveData
public void onInactive() {
if (LoaderManagerImpl.DEBUG) {
toString();
}
this.mLoader.stopLoading();
}
@Override // androidx.loader.content.Loader.OnLoadCompleteListener
public void onLoadComplete(@NonNull Loader<D> loader, @Nullable D d) {
if (LoaderManagerImpl.DEBUG) {
toString();
}
if (Looper.myLooper() == Looper.getMainLooper()) {
setValue(d);
return;
}
if (LoaderManagerImpl.DEBUG) {
Log.w(LoaderManagerImpl.TAG, "onLoadComplete was incorrectly called on a background thread");
}
postValue(d);
}
/* JADX WARN: Multi-variable type inference failed */
@Override // androidx.lifecycle.LiveData
public void removeObserver(@NonNull Observer<? super D> observer) {
super.removeObserver(observer);
this.mLifecycleOwner = null;
this.mObserver = null;
}
@NonNull
@MainThread
public Loader<D> setCallback(@NonNull LifecycleOwner lifecycleOwner, @NonNull LoaderManager.LoaderCallbacks<D> loaderCallbacks) {
LoaderObserver<D> loaderObserver = new LoaderObserver<>(this.mLoader, loaderCallbacks);
observe(lifecycleOwner, loaderObserver);
LoaderObserver<D> loaderObserver2 = this.mObserver;
if (loaderObserver2 != null) {
removeObserver(loaderObserver2);
}
this.mLifecycleOwner = lifecycleOwner;
this.mObserver = loaderObserver;
return this.mLoader;
}
@Override // androidx.lifecycle.MutableLiveData, androidx.lifecycle.LiveData
public void setValue(D d) {
super.setValue(d);
Loader<D> loader = this.mPriorLoader;
if (loader != null) {
loader.reset();
this.mPriorLoader = null;
}
}
@NonNull
public String toString() {
StringBuilder m = ParcelCompat$$ExternalSyntheticOutline0.m(64, "LoaderInfo{");
m.append(Integer.toHexString(System.identityHashCode(this)));
m.append(" #");
m.append(this.mId);
m.append(" : ");
Class<?> cls = this.mLoader.getClass();
m.append(cls.getSimpleName());
m.append("{");
m.append(Integer.toHexString(System.identityHashCode(cls)));
m.append("}}");
return m.toString();
}
}
/* compiled from: r8-map-id-b9432e0f623b4a4bff4ba50a8a24c4aafad2c1e11092747b9fb5e6a22af5a940 */
public static class LoaderObserver<D> implements Observer<D> {
@NonNull
private final LoaderManager.LoaderCallbacks<D> mCallback;
private boolean mDeliveredData = false;
@NonNull
private final Loader<D> mLoader;
public LoaderObserver(@NonNull Loader<D> loader, @NonNull LoaderManager.LoaderCallbacks<D> loaderCallbacks) {
this.mLoader = loader;
this.mCallback = loaderCallbacks;
}
public void dump(String str, PrintWriter printWriter) {
printWriter.print(str);
printWriter.print("mDeliveredData=");
printWriter.println(this.mDeliveredData);
}
public boolean hasDeliveredData() {
return this.mDeliveredData;
}
@Override // androidx.lifecycle.Observer
public void onChanged(@Nullable D d) {
if (LoaderManagerImpl.DEBUG) {
Objects.toString(this.mLoader);
this.mLoader.dataToString(d);
}
this.mDeliveredData = true;
this.mCallback.onLoadFinished(this.mLoader, d);
}
@MainThread
public void reset() {
if (this.mDeliveredData) {
if (LoaderManagerImpl.DEBUG) {
Objects.toString(this.mLoader);
}
this.mCallback.onLoaderReset(this.mLoader);
}
}
@NonNull
public String toString() {
return this.mCallback.toString();
}
}
/* compiled from: r8-map-id-b9432e0f623b4a4bff4ba50a8a24c4aafad2c1e11092747b9fb5e6a22af5a940 */
public static class LoaderViewModel extends ViewModel {
private static final ViewModelProvider.Factory FACTORY = new ViewModelProvider.Factory() { // from class: androidx.loader.app.LoaderManagerImpl.LoaderViewModel.1
@Override // androidx.lifecycle.ViewModelProvider.Factory
@NonNull
public <T extends ViewModel> T create(@NonNull Class<T> cls) {
return new LoaderViewModel();
}
};
private SparseArrayCompat<LoaderInfo> mLoaders = new SparseArrayCompat<>();
private boolean mCreatingLoader = false;
@NonNull
public static LoaderViewModel getInstance(ViewModelStore viewModelStore) {
return (LoaderViewModel) new ViewModelProvider(viewModelStore, FACTORY).get(LoaderViewModel.class);
}
public void dump(String str, FileDescriptor fileDescriptor, PrintWriter printWriter, String[] strArr) {
if (this.mLoaders.size() > 0) {
printWriter.print(str);
printWriter.println("Loaders:");
String str2 = str + Formatter.INDENT;
for (int i = 0; i < this.mLoaders.size(); i++) {
LoaderInfo valueAt = this.mLoaders.valueAt(i);
printWriter.print(str);
printWriter.print(" #");
printWriter.print(this.mLoaders.keyAt(i));
printWriter.print(": ");
printWriter.println(valueAt.toString());
valueAt.dump(str2, fileDescriptor, printWriter, strArr);
}
}
}
public void finishCreatingLoader() {
this.mCreatingLoader = false;
}
public <D> LoaderInfo<D> getLoader(int i) {
return this.mLoaders.get(i);
}
public boolean hasRunningLoaders() {
int size = this.mLoaders.size();
for (int i = 0; i < size; i++) {
if (this.mLoaders.valueAt(i).isCallbackWaitingForData()) {
return true;
}
}
return false;
}
public boolean isCreatingLoader() {
return this.mCreatingLoader;
}
public void markForRedelivery() {
int size = this.mLoaders.size();
for (int i = 0; i < size; i++) {
this.mLoaders.valueAt(i).markForRedelivery();
}
}
@Override // androidx.lifecycle.ViewModel
public void onCleared() {
super.onCleared();
int size = this.mLoaders.size();
int i = 0;
while (true) {
SparseArrayCompat<LoaderInfo> sparseArrayCompat = this.mLoaders;
if (i >= size) {
sparseArrayCompat.clear();
return;
} else {
sparseArrayCompat.valueAt(i).destroy(true);
i++;
}
}
}
public void putLoader(int i, @NonNull LoaderInfo loaderInfo) {
this.mLoaders.put(i, loaderInfo);
}
public void removeLoader(int i) {
this.mLoaders.remove(i);
}
public void startCreatingLoader() {
this.mCreatingLoader = true;
}
}
public LoaderManagerImpl(@NonNull LifecycleOwner lifecycleOwner, @NonNull ViewModelStore viewModelStore) {
this.mLifecycleOwner = lifecycleOwner;
this.mLoaderViewModel = LoaderViewModel.getInstance(viewModelStore);
}
@NonNull
@MainThread
private <D> Loader<D> createAndInstallLoader(int i, @Nullable Bundle bundle, @NonNull LoaderManager.LoaderCallbacks<D> loaderCallbacks, @Nullable Loader<D> loader) {
try {
this.mLoaderViewModel.startCreatingLoader();
Loader<D> onCreateLoader = loaderCallbacks.onCreateLoader(i, bundle);
if (onCreateLoader == null) {
throw new IllegalArgumentException("Object returned from onCreateLoader must not be null");
}
if (onCreateLoader.getClass().isMemberClass() && !Modifier.isStatic(onCreateLoader.getClass().getModifiers())) {
throw new IllegalArgumentException("Object returned from onCreateLoader must not be a non-static inner member class: " + onCreateLoader);
}
LoaderInfo loaderInfo = new LoaderInfo(i, bundle, onCreateLoader, loader);
if (DEBUG) {
loaderInfo.toString();
}
this.mLoaderViewModel.putLoader(i, loaderInfo);
this.mLoaderViewModel.finishCreatingLoader();
return loaderInfo.setCallback(this.mLifecycleOwner, loaderCallbacks);
} catch (Throwable th) {
this.mLoaderViewModel.finishCreatingLoader();
throw th;
}
}
@Override // androidx.loader.app.LoaderManager
@MainThread
public void destroyLoader(int i) {
if (this.mLoaderViewModel.isCreatingLoader()) {
Single$$ExternalSyntheticBUOutline0.m$2("Called while creating a loader");
return;
}
if (Looper.getMainLooper() != Looper.myLooper()) {
Single$$ExternalSyntheticBUOutline0.m$2("destroyLoader must be called on the main thread");
return;
}
if (DEBUG) {
toString();
}
LoaderInfo loader = this.mLoaderViewModel.getLoader(i);
if (loader != null) {
loader.destroy(true);
this.mLoaderViewModel.removeLoader(i);
}
}
@Override // androidx.loader.app.LoaderManager
@Deprecated
public void dump(String str, FileDescriptor fileDescriptor, PrintWriter printWriter, String[] strArr) {
this.mLoaderViewModel.dump(str, fileDescriptor, printWriter, strArr);
}
@Override // androidx.loader.app.LoaderManager
@Nullable
public <D> Loader<D> getLoader(int i) {
if (this.mLoaderViewModel.isCreatingLoader()) {
Single$$ExternalSyntheticBUOutline0.m$2("Called while creating a loader");
return null;
}
LoaderInfo<D> loader = this.mLoaderViewModel.getLoader(i);
if (loader != null) {
return loader.getLoader();
}
return null;
}
@Override // androidx.loader.app.LoaderManager
public boolean hasRunningLoaders() {
return this.mLoaderViewModel.hasRunningLoaders();
}
@Override // androidx.loader.app.LoaderManager
@NonNull
@MainThread
public <D> Loader<D> initLoader(int i, @Nullable Bundle bundle, @NonNull LoaderManager.LoaderCallbacks<D> loaderCallbacks) {
if (this.mLoaderViewModel.isCreatingLoader()) {
Single$$ExternalSyntheticBUOutline0.m$2("Called while creating a loader");
return null;
}
if (Looper.getMainLooper() != Looper.myLooper()) {
Single$$ExternalSyntheticBUOutline0.m$2("initLoader must be called on the main thread");
return null;
}
LoaderInfo<D> loader = this.mLoaderViewModel.getLoader(i);
if (DEBUG) {
toString();
Objects.toString(bundle);
}
if (loader == null) {
return createAndInstallLoader(i, bundle, loaderCallbacks, null);
}
if (DEBUG) {
loader.toString();
}
return loader.setCallback(this.mLifecycleOwner, loaderCallbacks);
}
@Override // androidx.loader.app.LoaderManager
public void markForRedelivery() {
this.mLoaderViewModel.markForRedelivery();
}
@Override // androidx.loader.app.LoaderManager
@NonNull
@MainThread
public <D> Loader<D> restartLoader(int i, @Nullable Bundle bundle, @NonNull LoaderManager.LoaderCallbacks<D> loaderCallbacks) {
if (this.mLoaderViewModel.isCreatingLoader()) {
Single$$ExternalSyntheticBUOutline0.m$2("Called while creating a loader");
return null;
}
if (Looper.getMainLooper() != Looper.myLooper()) {
Single$$ExternalSyntheticBUOutline0.m$2("restartLoader must be called on the main thread");
return null;
}
if (DEBUG) {
toString();
Objects.toString(bundle);
}
LoaderInfo<D> loader = this.mLoaderViewModel.getLoader(i);
return createAndInstallLoader(i, bundle, loaderCallbacks, loader != null ? loader.destroy(false) : null);
}
@NonNull
public String toString() {
StringBuilder m = ParcelCompat$$ExternalSyntheticOutline0.m(128, "LoaderManager{");
m.append(Integer.toHexString(System.identityHashCode(this)));
m.append(" in ");
Class<?> cls = this.mLifecycleOwner.getClass();
m.append(cls.getSimpleName());
m.append("{");
m.append(Integer.toHexString(System.identityHashCode(cls)));
m.append("}}");
return m.toString();
}
}