Add decompiled APK source code (JADX)

- 28,932 files
- Full Java source code
- Smali files
- Resources

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

decompiled/sources/androidx/loader/R.java

@@ -0,0 +1,203 @@
+package androidx.loader;
+
+/* loaded from: classes.dex */
+public final class R {
+
+    public static final class attr {
+        public static int alpha = 0x7f040055;
+        public static int font = 0x7f0400d8;
+        public static int fontProviderAuthority = 0x7f0400da;
+        public static int fontProviderCerts = 0x7f0400db;
+        public static int fontProviderFetchStrategy = 0x7f0400dd;
+        public static int fontProviderFetchTimeout = 0x7f0400de;
+        public static int fontProviderPackage = 0x7f0400df;
+        public static int fontProviderQuery = 0x7f0400e0;
+        public static int fontStyle = 0x7f0400e2;
+        public static int fontVariationSettings = 0x7f0400e3;
+        public static int fontWeight = 0x7f0400e4;
+        public static int ttcIndex = 0x7f04019c;
+
+        private attr() {
+        }
+    }
+
+    public static final class color {
+        public static int notification_action_color_filter = 0x7f0600e7;
+        public static int notification_icon_bg_color = 0x7f0600e8;
+        public static int ripple_material_light = 0x7f0600f3;
+        public static int secondary_text_default_material_light = 0x7f0600f5;
+
+        private color() {
+        }
+    }
+
+    public static final class dimen {
+        public static int compat_button_inset_horizontal_material = 0x7f070095;
+        public static int compat_button_inset_vertical_material = 0x7f070096;
+        public static int compat_button_padding_horizontal_material = 0x7f070097;
+        public static int compat_button_padding_vertical_material = 0x7f070098;
+        public static int compat_control_corner_material = 0x7f070099;
+        public static int compat_notification_large_icon_max_height = 0x7f07009a;
+        public static int compat_notification_large_icon_max_width = 0x7f07009b;
+        public static int notification_action_icon_size = 0x7f070105;
+        public static int notification_action_text_size = 0x7f070106;
+        public static int notification_big_circle_margin = 0x7f070107;
+        public static int notification_content_margin_start = 0x7f070108;
+        public static int notification_large_icon_height = 0x7f070109;
+        public static int notification_large_icon_width = 0x7f07010a;
+        public static int notification_main_column_padding_top = 0x7f07010b;
+        public static int notification_media_narrow_margin = 0x7f07010c;
+        public static int notification_right_icon_size = 0x7f07010d;
+        public static int notification_right_side_padding_top = 0x7f07010e;
+        public static int notification_small_icon_background_padding = 0x7f07010f;
+        public static int notification_small_icon_size_as_large = 0x7f070110;
+        public static int notification_subtext_size = 0x7f070111;
+        public static int notification_top_pad = 0x7f070112;
+        public static int notification_top_pad_large_text = 0x7f070113;
+
+        private dimen() {
+        }
+    }
+
+    public static final class drawable {
+        public static int notification_action_background = 0x7f080241;
+        public static int notification_bg = 0x7f080242;
+        public static int notification_bg_low = 0x7f080243;
+        public static int notification_bg_low_normal = 0x7f080244;
+        public static int notification_bg_low_pressed = 0x7f080245;
+        public static int notification_bg_normal = 0x7f080246;
+        public static int notification_bg_normal_pressed = 0x7f080247;
+        public static int notification_icon_background = 0x7f080248;
+        public static int notification_template_icon_bg = 0x7f08024a;
+        public static int notification_template_icon_low_bg = 0x7f08024b;
+        public static int notification_tile_bg = 0x7f08024c;
+        public static int notify_panel_notification_icon_bg = 0x7f08024d;
+
+        private drawable() {
+        }
+    }
+
+    public static final class id {
+        public static int action_container = 0x7f0a0032;
+        public static int action_divider = 0x7f0a0034;
+        public static int action_image = 0x7f0a0035;
+        public static int action_text = 0x7f0a003c;
+        public static int actions = 0x7f0a003d;
+        public static int async = 0x7f0a0088;
+        public static int blocking = 0x7f0a0091;
+        public static int chronometer = 0x7f0a00a6;
+        public static int forever = 0x7f0a0107;
+        public static int icon = 0x7f0a014a;
+        public static int icon_group = 0x7f0a014b;
+        public static int info = 0x7f0a0151;
+        public static int italic = 0x7f0a0156;
+        public static int line1 = 0x7f0a015d;
+        public static int line3 = 0x7f0a015e;
+        public static int normal = 0x7f0a022f;
+        public static int notification_background = 0x7f0a0230;
+        public static int notification_main_column = 0x7f0a0231;
+        public static int notification_main_column_container = 0x7f0a0232;
+        public static int right_icon = 0x7f0a0248;
+        public static int right_side = 0x7f0a0249;
+        public static int tag_transition_group = 0x7f0a0279;
+        public static int tag_unhandled_key_event_manager = 0x7f0a027a;
+        public static int tag_unhandled_key_listeners = 0x7f0a027b;
+        public static int text = 0x7f0a027d;
+        public static int text2 = 0x7f0a027e;
+        public static int time = 0x7f0a0283;
+        public static int title = 0x7f0a0284;
+
+        private id() {
+        }
+    }
+
+    public static final class integer {
+        public static int status_bar_notification_info_maxnum = 0x7f0b0014;
+
+        private integer() {
+        }
+    }
+
+    public static final class layout {
+        public static int notification_action = 0x7f0d009f;
+        public static int notification_action_tombstone = 0x7f0d00a0;
+        public static int notification_template_custom_big = 0x7f0d00a7;
+        public static int notification_template_icon_group = 0x7f0d00a8;
+        public static int notification_template_part_chronometer = 0x7f0d00ac;
+        public static int notification_template_part_time = 0x7f0d00ad;
+
+        private layout() {
+        }
+    }
+
+    public static final class string {
+        public static int status_bar_notification_info_overflow = 0x7f120187;
+
+        private string() {
+        }
+    }
+
+    public static final class style {
+        public static int TextAppearance_Compat_Notification = 0x7f130147;
+        public static int TextAppearance_Compat_Notification_Info = 0x7f130148;
+        public static int TextAppearance_Compat_Notification_Line2 = 0x7f13014a;
+        public static int TextAppearance_Compat_Notification_Time = 0x7f13014d;
+        public static int TextAppearance_Compat_Notification_Title = 0x7f13014f;
+        public static int Widget_Compat_NotificationActionContainer = 0x7f1301c1;
+        public static int Widget_Compat_NotificationActionText = 0x7f1301c2;
+
+        private style() {
+        }
+    }
+
+    public static final class styleable {
+        public static int ColorStateListItem_alpha = 0x00000003;
+        public static int ColorStateListItem_android_alpha = 0x00000001;
+        public static int ColorStateListItem_android_color = 0x00000000;
+        public static int ColorStateListItem_android_lStar = 0x00000002;
+        public static int ColorStateListItem_lStar = 0x00000004;
+        public static int FontFamilyFont_android_font = 0x00000000;
+        public static int FontFamilyFont_android_fontStyle = 0x00000002;
+        public static int FontFamilyFont_android_fontVariationSettings = 0x00000004;
+        public static int FontFamilyFont_android_fontWeight = 0x00000001;
+        public static int FontFamilyFont_android_ttcIndex = 0x00000003;
+        public static int FontFamilyFont_font = 0x00000005;
+        public static int FontFamilyFont_fontStyle = 0x00000006;
+        public static int FontFamilyFont_fontVariationSettings = 0x00000007;
+        public static int FontFamilyFont_fontWeight = 0x00000008;
+        public static int FontFamilyFont_ttcIndex = 0x00000009;
+        public static int FontFamily_fontProviderAuthority = 0x00000000;
+        public static int FontFamily_fontProviderCerts = 0x00000001;
+        public static int FontFamily_fontProviderFallbackQuery = 0x00000002;
+        public static int FontFamily_fontProviderFetchStrategy = 0x00000003;
+        public static int FontFamily_fontProviderFetchTimeout = 0x00000004;
+        public static int FontFamily_fontProviderPackage = 0x00000005;
+        public static int FontFamily_fontProviderQuery = 0x00000006;
+        public static int FontFamily_fontProviderSystemFontFamily = 0x00000007;
+        public static int GradientColorItem_android_color = 0x00000000;
+        public static int GradientColorItem_android_offset = 0x00000001;
+        public static int GradientColor_android_centerColor = 0x00000007;
+        public static int GradientColor_android_centerX = 0x00000003;
+        public static int GradientColor_android_centerY = 0x00000004;
+        public static int GradientColor_android_endColor = 0x00000001;
+        public static int GradientColor_android_endX = 0x0000000a;
+        public static int GradientColor_android_endY = 0x0000000b;
+        public static int GradientColor_android_gradientRadius = 0x00000005;
+        public static int GradientColor_android_startColor = 0x00000000;
+        public static int GradientColor_android_startX = 0x00000008;
+        public static int GradientColor_android_startY = 0x00000009;
+        public static int GradientColor_android_tileMode = 0x00000006;
+        public static int GradientColor_android_type = 0x00000002;
+        public static int[] ColorStateListItem = {android.R.attr.color, android.R.attr.alpha, android.R.attr.lStar, com.ea.games.r3_row.R.attr.alpha, com.ea.games.r3_row.R.attr.lStar};
+        public static int[] FontFamily = {com.ea.games.r3_row.R.attr.fontProviderAuthority, com.ea.games.r3_row.R.attr.fontProviderCerts, com.ea.games.r3_row.R.attr.fontProviderFallbackQuery, com.ea.games.r3_row.R.attr.fontProviderFetchStrategy, com.ea.games.r3_row.R.attr.fontProviderFetchTimeout, com.ea.games.r3_row.R.attr.fontProviderPackage, com.ea.games.r3_row.R.attr.fontProviderQuery, com.ea.games.r3_row.R.attr.fontProviderSystemFontFamily};
+        public static int[] FontFamilyFont = {android.R.attr.font, android.R.attr.fontWeight, android.R.attr.fontStyle, android.R.attr.ttcIndex, android.R.attr.fontVariationSettings, com.ea.games.r3_row.R.attr.font, com.ea.games.r3_row.R.attr.fontStyle, com.ea.games.r3_row.R.attr.fontVariationSettings, com.ea.games.r3_row.R.attr.fontWeight, com.ea.games.r3_row.R.attr.ttcIndex};
+        public static int[] GradientColor = {android.R.attr.startColor, android.R.attr.endColor, android.R.attr.type, android.R.attr.centerX, android.R.attr.centerY, android.R.attr.gradientRadius, android.R.attr.tileMode, android.R.attr.centerColor, android.R.attr.startX, android.R.attr.startY, android.R.attr.endX, android.R.attr.endY};
+        public static int[] GradientColorItem = {android.R.attr.color, android.R.attr.offset};
+
+        private styleable() {
+        }
+    }
+
+    private R() {
+    }
+}

decompiled/sources/androidx/loader/app/LoaderManager.java

@@ -0,0 +1,59 @@
+package androidx.loader.app;
+
+import android.os.Bundle;
+import androidx.annotation.MainThread;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.lifecycle.LifecycleOwner;
+import androidx.lifecycle.ViewModelStoreOwner;
+import androidx.loader.content.Loader;
+import java.io.FileDescriptor;
+import java.io.PrintWriter;
+
+/* loaded from: classes.dex */
+public abstract class LoaderManager {
+
+    public interface LoaderCallbacks<D> {
+        @NonNull
+        @MainThread
+        Loader<D> onCreateLoader(int i, @Nullable Bundle bundle);
+
+        @MainThread
+        void onLoadFinished(@NonNull Loader<D> loader, D d);
+
+        @MainThread
+        void onLoaderReset(@NonNull Loader<D> loader);
+    }
+
+    @MainThread
+    public abstract void destroyLoader(int i);
+
+    @Deprecated
+    public abstract void dump(String str, FileDescriptor fileDescriptor, PrintWriter printWriter, String[] strArr);
+
+    @Nullable
+    public abstract <D> Loader<D> getLoader(int i);
+
+    public boolean hasRunningLoaders() {
+        return false;
+    }
+
+    @NonNull
+    @MainThread
+    public abstract <D> Loader<D> initLoader(int i, @Nullable Bundle bundle, @NonNull LoaderCallbacks<D> loaderCallbacks);
+
+    public abstract void markForRedelivery();
+
+    @NonNull
+    @MainThread
+    public abstract <D> Loader<D> restartLoader(int i, @Nullable Bundle bundle, @NonNull LoaderCallbacks<D> loaderCallbacks);
+
+    @NonNull
+    public static <T extends LifecycleOwner & ViewModelStoreOwner> LoaderManager getInstance(@NonNull T t) {
+        return new LoaderManagerImpl(t, t.getViewModelStore());
+    }
+
+    public static void enableDebugLogging(boolean z) {
+        LoaderManagerImpl.DEBUG = z;
+    }
+}

decompiled/sources/androidx/loader/app/LoaderManagerImpl.java

@@ -0,0 +1,494 @@
+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.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 java.io.FileDescriptor;
+import java.io.PrintWriter;
+import java.lang.reflect.Modifier;
+
+/* loaded from: classes.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;
+
+    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;
+
+        @NonNull
+        public Loader<D> getLoader() {
+            return this.mLoader;
+        }
+
+        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);
+        }
+
+        @Override // androidx.lifecycle.LiveData
+        public void onActive() {
+            if (LoaderManagerImpl.DEBUG) {
+                StringBuilder sb = new StringBuilder();
+                sb.append("  Starting: ");
+                sb.append(this);
+            }
+            this.mLoader.startLoading();
+        }
+
+        @Override // androidx.lifecycle.LiveData
+        public void onInactive() {
+            if (LoaderManagerImpl.DEBUG) {
+                StringBuilder sb = new StringBuilder();
+                sb.append("  Stopping: ");
+                sb.append(this);
+            }
+            this.mLoader.stopLoading();
+        }
+
+        @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;
+        }
+
+        public void markForRedelivery() {
+            LifecycleOwner lifecycleOwner = this.mLifecycleOwner;
+            LoaderObserver<D> loaderObserver = this.mObserver;
+            if (lifecycleOwner == null || loaderObserver == null) {
+                return;
+            }
+            super.removeObserver(loaderObserver);
+            observe(lifecycleOwner, loaderObserver);
+        }
+
+        public boolean isCallbackWaitingForData() {
+            LoaderObserver<D> loaderObserver;
+            return (!hasActiveObservers() || (loaderObserver = this.mObserver) == null || loaderObserver.hasDeliveredData()) ? false : true;
+        }
+
+        /* 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;
+        }
+
+        @MainThread
+        public Loader<D> destroy(boolean z) {
+            if (LoaderManagerImpl.DEBUG) {
+                StringBuilder sb = new StringBuilder();
+                sb.append("  Destroying: ");
+                sb.append(this);
+            }
+            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;
+        }
+
+        @Override // androidx.loader.content.Loader.OnLoadCompleteListener
+        public void onLoadComplete(@NonNull Loader<D> loader, @Nullable D d) {
+            if (LoaderManagerImpl.DEBUG) {
+                StringBuilder sb = new StringBuilder();
+                sb.append("onLoadComplete: ");
+                sb.append(this);
+            }
+            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);
+        }
+
+        @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 sb = new StringBuilder(64);
+            sb.append("LoaderInfo{");
+            sb.append(Integer.toHexString(System.identityHashCode(this)));
+            sb.append(" #");
+            sb.append(this.mId);
+            sb.append(" : ");
+            Class<?> cls = this.mLoader.getClass();
+            sb.append(cls.getSimpleName());
+            sb.append("{");
+            sb.append(Integer.toHexString(System.identityHashCode(cls)));
+            sb.append("}}");
+            return sb.toString();
+        }
+
+        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(str + "  ", fileDescriptor, printWriter, strArr);
+            if (this.mObserver != null) {
+                printWriter.print(str);
+                printWriter.print("mCallbacks=");
+                printWriter.println(this.mObserver);
+                this.mObserver.dump(str + "  ", printWriter);
+            }
+            printWriter.print(str);
+            printWriter.print("mData=");
+            printWriter.println(getLoader().dataToString(getValue()));
+            printWriter.print(str);
+            printWriter.print("mStarted=");
+            printWriter.println(hasActiveObservers());
+        }
+    }
+
+    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 boolean hasDeliveredData() {
+            return this.mDeliveredData;
+        }
+
+        public LoaderObserver(@NonNull Loader<D> loader, @NonNull LoaderManager.LoaderCallbacks<D> loaderCallbacks) {
+            this.mLoader = loader;
+            this.mCallback = loaderCallbacks;
+        }
+
+        @Override // androidx.lifecycle.Observer
+        public void onChanged(@Nullable D d) {
+            if (LoaderManagerImpl.DEBUG) {
+                StringBuilder sb = new StringBuilder();
+                sb.append("  onLoadFinished in ");
+                sb.append(this.mLoader);
+                sb.append(": ");
+                sb.append(this.mLoader.dataToString(d));
+            }
+            this.mDeliveredData = true;
+            this.mCallback.onLoadFinished(this.mLoader, d);
+        }
+
+        @MainThread
+        public void reset() {
+            if (this.mDeliveredData) {
+                if (LoaderManagerImpl.DEBUG) {
+                    StringBuilder sb = new StringBuilder();
+                    sb.append("  Resetting: ");
+                    sb.append(this.mLoader);
+                }
+                this.mCallback.onLoaderReset(this.mLoader);
+            }
+        }
+
+        @NonNull
+        public String toString() {
+            return this.mCallback.toString();
+        }
+
+        public void dump(String str, PrintWriter printWriter) {
+            printWriter.print(str);
+            printWriter.print("mDeliveredData=");
+            printWriter.println(this.mDeliveredData);
+        }
+    }
+
+    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;
+
+        public void finishCreatingLoader() {
+            this.mCreatingLoader = false;
+        }
+
+        public boolean isCreatingLoader() {
+            return this.mCreatingLoader;
+        }
+
+        public void startCreatingLoader() {
+            this.mCreatingLoader = true;
+        }
+
+        @NonNull
+        public static LoaderViewModel getInstance(ViewModelStore viewModelStore) {
+            return (LoaderViewModel) new ViewModelProvider(viewModelStore, FACTORY).get(LoaderViewModel.class);
+        }
+
+        public void putLoader(int i, @NonNull LoaderInfo loaderInfo) {
+            this.mLoaders.put(i, loaderInfo);
+        }
+
+        public <D> LoaderInfo<D> getLoader(int i) {
+            return this.mLoaders.get(i);
+        }
+
+        public void removeLoader(int i) {
+            this.mLoaders.remove(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 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();
+            for (int i = 0; i < size; i++) {
+                this.mLoaders.valueAt(i).destroy(true);
+            }
+            this.mLoaders.clear();
+        }
+
+        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 + "    ";
+                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 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) {
+                StringBuilder sb = new StringBuilder();
+                sb.append("  Created new loader ");
+                sb.append(loaderInfo);
+            }
+            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
+    @NonNull
+    @MainThread
+    public <D> Loader<D> initLoader(int i, @Nullable Bundle bundle, @NonNull LoaderManager.LoaderCallbacks<D> loaderCallbacks) {
+        if (this.mLoaderViewModel.isCreatingLoader()) {
+            throw new IllegalStateException("Called while creating a loader");
+        }
+        if (Looper.getMainLooper() != Looper.myLooper()) {
+            throw new IllegalStateException("initLoader must be called on the main thread");
+        }
+        LoaderInfo<D> loader = this.mLoaderViewModel.getLoader(i);
+        if (DEBUG) {
+            StringBuilder sb = new StringBuilder();
+            sb.append("initLoader in ");
+            sb.append(this);
+            sb.append(": args=");
+            sb.append(bundle);
+        }
+        if (loader == null) {
+            return createAndInstallLoader(i, bundle, loaderCallbacks, null);
+        }
+        if (DEBUG) {
+            StringBuilder sb2 = new StringBuilder();
+            sb2.append("  Re-using existing loader ");
+            sb2.append(loader);
+        }
+        return loader.setCallback(this.mLifecycleOwner, loaderCallbacks);
+    }
+
+    @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()) {
+            throw new IllegalStateException("Called while creating a loader");
+        }
+        if (Looper.getMainLooper() != Looper.myLooper()) {
+            throw new IllegalStateException("restartLoader must be called on the main thread");
+        }
+        if (DEBUG) {
+            StringBuilder sb = new StringBuilder();
+            sb.append("restartLoader in ");
+            sb.append(this);
+            sb.append(": args=");
+            sb.append(bundle);
+        }
+        LoaderInfo<D> loader = this.mLoaderViewModel.getLoader(i);
+        return createAndInstallLoader(i, bundle, loaderCallbacks, loader != null ? loader.destroy(false) : null);
+    }
+
+    @Override // androidx.loader.app.LoaderManager
+    @MainThread
+    public void destroyLoader(int i) {
+        if (this.mLoaderViewModel.isCreatingLoader()) {
+            throw new IllegalStateException("Called while creating a loader");
+        }
+        if (Looper.getMainLooper() != Looper.myLooper()) {
+            throw new IllegalStateException("destroyLoader must be called on the main thread");
+        }
+        if (DEBUG) {
+            StringBuilder sb = new StringBuilder();
+            sb.append("destroyLoader in ");
+            sb.append(this);
+            sb.append(" of ");
+            sb.append(i);
+        }
+        LoaderInfo loader = this.mLoaderViewModel.getLoader(i);
+        if (loader != null) {
+            loader.destroy(true);
+            this.mLoaderViewModel.removeLoader(i);
+        }
+    }
+
+    @Override // androidx.loader.app.LoaderManager
+    @Nullable
+    public <D> Loader<D> getLoader(int i) {
+        if (this.mLoaderViewModel.isCreatingLoader()) {
+            throw new IllegalStateException("Called while creating a loader");
+        }
+        LoaderInfo<D> loader = this.mLoaderViewModel.getLoader(i);
+        if (loader != null) {
+            return loader.getLoader();
+        }
+        return null;
+    }
+
+    @Override // androidx.loader.app.LoaderManager
+    public void markForRedelivery() {
+        this.mLoaderViewModel.markForRedelivery();
+    }
+
+    @NonNull
+    public String toString() {
+        StringBuilder sb = new StringBuilder(128);
+        sb.append("LoaderManager{");
+        sb.append(Integer.toHexString(System.identityHashCode(this)));
+        sb.append(" in ");
+        Class<?> cls = this.mLifecycleOwner.getClass();
+        sb.append(cls.getSimpleName());
+        sb.append("{");
+        sb.append(Integer.toHexString(System.identityHashCode(cls)));
+        sb.append("}}");
+        return sb.toString();
+    }
+
+    @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
+    public boolean hasRunningLoaders() {
+        return this.mLoaderViewModel.hasRunningLoaders();
+    }
+}

decompiled/sources/androidx/loader/content/AsyncTaskLoader.java

@@ -0,0 +1,215 @@
+package androidx.loader.content;
+
+import android.content.Context;
+import android.os.AsyncTask;
+import android.os.Handler;
+import android.os.SystemClock;
+import android.text.format.DateUtils;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.core.os.OperationCanceledException;
+import java.io.FileDescriptor;
+import java.io.PrintWriter;
+import java.util.concurrent.Executor;
+import java.util.concurrent.TimeUnit;
+
+/* loaded from: classes.dex */
+public abstract class AsyncTaskLoader<D> extends Loader<D> {
+    private static final boolean DEBUG = false;
+    private static final String TAG = "AsyncTaskLoader";
+    private volatile AsyncTaskLoader<D>.LoadTask mCancellingTask;
+    private Executor mExecutor;
+    private Handler mHandler;
+    private long mLastLoadCompleteTime;
+    private volatile AsyncTaskLoader<D>.LoadTask mTask;
+    private long mUpdateThrottle;
+
+    public void cancelLoadInBackground() {
+    }
+
+    public boolean isLoadInBackgroundCanceled() {
+        return this.mCancellingTask != null;
+    }
+
+    @Nullable
+    public abstract D loadInBackground();
+
+    public void onCanceled(@Nullable D d) {
+    }
+
+    public final class LoadTask extends ModernAsyncTask<D> implements Runnable {
+        boolean waiting;
+
+        public LoadTask() {
+        }
+
+        @Override // androidx.loader.content.ModernAsyncTask
+        public D doInBackground() {
+            try {
+                return (D) AsyncTaskLoader.this.onLoadInBackground();
+            } catch (OperationCanceledException e) {
+                if (isCancelled()) {
+                    return null;
+                }
+                throw e;
+            }
+        }
+
+        @Override // androidx.loader.content.ModernAsyncTask
+        public void onPostExecute(D d) {
+            AsyncTaskLoader.this.dispatchOnLoadComplete(this, d);
+        }
+
+        @Override // androidx.loader.content.ModernAsyncTask
+        public void onCancelled(D d) {
+            AsyncTaskLoader.this.dispatchOnCancelled(this, d);
+        }
+
+        @Override // java.lang.Runnable
+        public void run() {
+            this.waiting = false;
+            AsyncTaskLoader.this.executePendingTask();
+        }
+    }
+
+    public AsyncTaskLoader(@NonNull Context context) {
+        super(context);
+        this.mLastLoadCompleteTime = -10000L;
+    }
+
+    public void setUpdateThrottle(long j) {
+        this.mUpdateThrottle = j;
+        if (j != 0) {
+            this.mHandler = new Handler();
+        }
+    }
+
+    @Override // androidx.loader.content.Loader
+    public void onForceLoad() {
+        super.onForceLoad();
+        cancelLoad();
+        this.mTask = new LoadTask();
+        executePendingTask();
+    }
+
+    @Override // androidx.loader.content.Loader
+    public boolean onCancelLoad() {
+        if (this.mTask == null) {
+            return false;
+        }
+        if (!isStarted()) {
+            onContentChanged();
+        }
+        if (this.mCancellingTask != null) {
+            if (this.mTask.waiting) {
+                this.mTask.waiting = false;
+                this.mHandler.removeCallbacks(this.mTask);
+            }
+            this.mTask = null;
+            return false;
+        }
+        if (this.mTask.waiting) {
+            this.mTask.waiting = false;
+            this.mHandler.removeCallbacks(this.mTask);
+            this.mTask = null;
+            return false;
+        }
+        boolean cancel = this.mTask.cancel(false);
+        if (cancel) {
+            this.mCancellingTask = this.mTask;
+            cancelLoadInBackground();
+        }
+        this.mTask = null;
+        return cancel;
+    }
+
+    public void executePendingTask() {
+        if (this.mCancellingTask != null || this.mTask == null) {
+            return;
+        }
+        if (this.mTask.waiting) {
+            this.mTask.waiting = false;
+            this.mHandler.removeCallbacks(this.mTask);
+        }
+        if (this.mUpdateThrottle > 0 && SystemClock.uptimeMillis() < this.mLastLoadCompleteTime + this.mUpdateThrottle) {
+            this.mTask.waiting = true;
+            this.mHandler.postAtTime(this.mTask, this.mLastLoadCompleteTime + this.mUpdateThrottle);
+        } else {
+            if (this.mExecutor == null) {
+                this.mExecutor = getExecutor();
+            }
+            this.mTask.executeOnExecutor(this.mExecutor);
+        }
+    }
+
+    public void dispatchOnCancelled(AsyncTaskLoader<D>.LoadTask loadTask, D d) {
+        onCanceled(d);
+        if (this.mCancellingTask == loadTask) {
+            rollbackContentChanged();
+            this.mLastLoadCompleteTime = SystemClock.uptimeMillis();
+            this.mCancellingTask = null;
+            deliverCancellation();
+            executePendingTask();
+        }
+    }
+
+    public void dispatchOnLoadComplete(AsyncTaskLoader<D>.LoadTask loadTask, D d) {
+        if (this.mTask != loadTask) {
+            dispatchOnCancelled(loadTask, d);
+            return;
+        }
+        if (isAbandoned()) {
+            onCanceled(d);
+            return;
+        }
+        commitContentChanged();
+        this.mLastLoadCompleteTime = SystemClock.uptimeMillis();
+        this.mTask = null;
+        deliverResult(d);
+    }
+
+    @Nullable
+    public D onLoadInBackground() {
+        return loadInBackground();
+    }
+
+    @NonNull
+    public Executor getExecutor() {
+        return AsyncTask.THREAD_POOL_EXECUTOR;
+    }
+
+    @Override // androidx.loader.content.Loader
+    @Deprecated
+    public void dump(String str, FileDescriptor fileDescriptor, PrintWriter printWriter, String[] strArr) {
+        String str2;
+        super.dump(str, fileDescriptor, printWriter, strArr);
+        if (this.mTask != null) {
+            printWriter.print(str);
+            printWriter.print("mTask=");
+            printWriter.print(this.mTask);
+            printWriter.print(" waiting=");
+            printWriter.println(this.mTask.waiting);
+        }
+        if (this.mCancellingTask != null) {
+            printWriter.print(str);
+            printWriter.print("mCancellingTask=");
+            printWriter.print(this.mCancellingTask);
+            printWriter.print(" waiting=");
+            printWriter.println(this.mCancellingTask.waiting);
+        }
+        if (this.mUpdateThrottle != 0) {
+            printWriter.print(str);
+            printWriter.print("mUpdateThrottle=");
+            TimeUnit timeUnit = TimeUnit.MILLISECONDS;
+            printWriter.print(DateUtils.formatElapsedTime(timeUnit.toSeconds(this.mUpdateThrottle)));
+            printWriter.print(" mLastLoadCompleteTime=");
+            if (this.mLastLoadCompleteTime == -10000) {
+                str2 = "--";
+            } else {
+                str2 = "-" + DateUtils.formatElapsedTime(timeUnit.toSeconds(SystemClock.uptimeMillis() - this.mLastLoadCompleteTime));
+            }
+            printWriter.print(str2);
+            printWriter.println();
+        }
+    }
+}

decompiled/sources/androidx/loader/content/CursorLoader.java

@@ -0,0 +1,212 @@
+package androidx.loader.content;
+
+import android.content.Context;
+import android.database.Cursor;
+import android.net.Uri;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.core.content.ContentResolverCompat;
+import androidx.core.os.CancellationSignal;
+import androidx.core.os.OperationCanceledException;
+import androidx.loader.content.Loader;
+import java.io.FileDescriptor;
+import java.io.PrintWriter;
+import java.util.Arrays;
+
+/* loaded from: classes.dex */
+public class CursorLoader extends AsyncTaskLoader<Cursor> {
+    private CancellationSignal mCancellationSignal;
+    private Cursor mCursor;
+    private final Loader<Cursor>.ForceLoadContentObserver mObserver;
+    private String[] mProjection;
+    private String mSelection;
+    private String[] mSelectionArgs;
+    private String mSortOrder;
+    private Uri mUri;
+
+    @Nullable
+    public String[] getProjection() {
+        return this.mProjection;
+    }
+
+    @Nullable
+    public String getSelection() {
+        return this.mSelection;
+    }
+
+    @Nullable
+    public String[] getSelectionArgs() {
+        return this.mSelectionArgs;
+    }
+
+    @Nullable
+    public String getSortOrder() {
+        return this.mSortOrder;
+    }
+
+    @NonNull
+    public Uri getUri() {
+        return this.mUri;
+    }
+
+    public void setProjection(@Nullable String[] strArr) {
+        this.mProjection = strArr;
+    }
+
+    public void setSelection(@Nullable String str) {
+        this.mSelection = str;
+    }
+
+    public void setSelectionArgs(@Nullable String[] strArr) {
+        this.mSelectionArgs = strArr;
+    }
+
+    public void setSortOrder(@Nullable String str) {
+        this.mSortOrder = str;
+    }
+
+    public void setUri(@NonNull Uri uri) {
+        this.mUri = uri;
+    }
+
+    /* JADX WARN: Can't rename method to resolve collision */
+    @Override // androidx.loader.content.AsyncTaskLoader
+    public Cursor loadInBackground() {
+        synchronized (this) {
+            if (isLoadInBackgroundCanceled()) {
+                throw new OperationCanceledException();
+            }
+            this.mCancellationSignal = new CancellationSignal();
+        }
+        try {
+            Cursor query = ContentResolverCompat.query(getContext().getContentResolver(), this.mUri, this.mProjection, this.mSelection, this.mSelectionArgs, this.mSortOrder, this.mCancellationSignal);
+            if (query != null) {
+                try {
+                    query.getCount();
+                    query.registerContentObserver(this.mObserver);
+                } catch (RuntimeException e) {
+                    query.close();
+                    throw e;
+                }
+            }
+            synchronized (this) {
+                this.mCancellationSignal = null;
+            }
+            return query;
+        } catch (Throwable th) {
+            synchronized (this) {
+                this.mCancellationSignal = null;
+                throw th;
+            }
+        }
+    }
+
+    @Override // androidx.loader.content.AsyncTaskLoader
+    public void cancelLoadInBackground() {
+        super.cancelLoadInBackground();
+        synchronized (this) {
+            try {
+                CancellationSignal cancellationSignal = this.mCancellationSignal;
+                if (cancellationSignal != null) {
+                    cancellationSignal.cancel();
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    @Override // androidx.loader.content.Loader
+    public void deliverResult(Cursor cursor) {
+        if (isReset()) {
+            if (cursor != null) {
+                cursor.close();
+                return;
+            }
+            return;
+        }
+        Cursor cursor2 = this.mCursor;
+        this.mCursor = cursor;
+        if (isStarted()) {
+            super.deliverResult((CursorLoader) cursor);
+        }
+        if (cursor2 == null || cursor2 == cursor || cursor2.isClosed()) {
+            return;
+        }
+        cursor2.close();
+    }
+
+    public CursorLoader(@NonNull Context context) {
+        super(context);
+        this.mObserver = new Loader.ForceLoadContentObserver();
+    }
+
+    public CursorLoader(@NonNull Context context, @NonNull Uri uri, @Nullable String[] strArr, @Nullable String str, @Nullable String[] strArr2, @Nullable String str2) {
+        super(context);
+        this.mObserver = new Loader.ForceLoadContentObserver();
+        this.mUri = uri;
+        this.mProjection = strArr;
+        this.mSelection = str;
+        this.mSelectionArgs = strArr2;
+        this.mSortOrder = str2;
+    }
+
+    @Override // androidx.loader.content.Loader
+    public void onStartLoading() {
+        Cursor cursor = this.mCursor;
+        if (cursor != null) {
+            deliverResult(cursor);
+        }
+        if (takeContentChanged() || this.mCursor == null) {
+            forceLoad();
+        }
+    }
+
+    @Override // androidx.loader.content.Loader
+    public void onStopLoading() {
+        cancelLoad();
+    }
+
+    @Override // androidx.loader.content.AsyncTaskLoader
+    public void onCanceled(Cursor cursor) {
+        if (cursor == null || cursor.isClosed()) {
+            return;
+        }
+        cursor.close();
+    }
+
+    @Override // androidx.loader.content.Loader
+    public void onReset() {
+        super.onReset();
+        onStopLoading();
+        Cursor cursor = this.mCursor;
+        if (cursor != null && !cursor.isClosed()) {
+            this.mCursor.close();
+        }
+        this.mCursor = null;
+    }
+
+    @Override // androidx.loader.content.AsyncTaskLoader, androidx.loader.content.Loader
+    @Deprecated
+    public void dump(String str, FileDescriptor fileDescriptor, PrintWriter printWriter, String[] strArr) {
+        super.dump(str, fileDescriptor, printWriter, strArr);
+        printWriter.print(str);
+        printWriter.print("mUri=");
+        printWriter.println(this.mUri);
+        printWriter.print(str);
+        printWriter.print("mProjection=");
+        printWriter.println(Arrays.toString(this.mProjection));
+        printWriter.print(str);
+        printWriter.print("mSelection=");
+        printWriter.println(this.mSelection);
+        printWriter.print(str);
+        printWriter.print("mSelectionArgs=");
+        printWriter.println(Arrays.toString(this.mSelectionArgs));
+        printWriter.print(str);
+        printWriter.print("mSortOrder=");
+        printWriter.println(this.mSortOrder);
+        printWriter.print(str);
+        printWriter.print("mCursor=");
+        printWriter.println(this.mCursor);
+    }
+}

decompiled/sources/androidx/loader/content/Loader.java

@@ -0,0 +1,273 @@
+package androidx.loader.content;
+
+import android.content.Context;
+import android.database.ContentObserver;
+import android.os.Handler;
+import androidx.annotation.MainThread;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import java.io.FileDescriptor;
+import java.io.PrintWriter;
+
+/* loaded from: classes.dex */
+public class Loader<D> {
+    private Context mContext;
+    private int mId;
+    private OnLoadCompleteListener<D> mListener;
+    private OnLoadCanceledListener<D> mOnLoadCanceledListener;
+    private boolean mStarted = false;
+    private boolean mAbandoned = false;
+    private boolean mReset = true;
+    private boolean mContentChanged = false;
+    private boolean mProcessingChange = false;
+
+    public interface OnLoadCanceledListener<D> {
+        void onLoadCanceled(@NonNull Loader<D> loader);
+    }
+
+    public interface OnLoadCompleteListener<D> {
+        void onLoadComplete(@NonNull Loader<D> loader, @Nullable D d);
+    }
+
+    public void commitContentChanged() {
+        this.mProcessingChange = false;
+    }
+
+    @NonNull
+    public Context getContext() {
+        return this.mContext;
+    }
+
+    public int getId() {
+        return this.mId;
+    }
+
+    public boolean isAbandoned() {
+        return this.mAbandoned;
+    }
+
+    public boolean isReset() {
+        return this.mReset;
+    }
+
+    public boolean isStarted() {
+        return this.mStarted;
+    }
+
+    @MainThread
+    public void onAbandon() {
+    }
+
+    @MainThread
+    public boolean onCancelLoad() {
+        return false;
+    }
+
+    @MainThread
+    public void onForceLoad() {
+    }
+
+    @MainThread
+    public void onReset() {
+    }
+
+    @MainThread
+    public void onStartLoading() {
+    }
+
+    @MainThread
+    public void onStopLoading() {
+    }
+
+    public boolean takeContentChanged() {
+        boolean z = this.mContentChanged;
+        this.mContentChanged = false;
+        this.mProcessingChange |= z;
+        return z;
+    }
+
+    public final class ForceLoadContentObserver extends ContentObserver {
+        @Override // android.database.ContentObserver
+        public boolean deliverSelfNotifications() {
+            return true;
+        }
+
+        public ForceLoadContentObserver() {
+            super(new Handler());
+        }
+
+        @Override // android.database.ContentObserver
+        public void onChange(boolean z) {
+            Loader.this.onContentChanged();
+        }
+    }
+
+    public Loader(@NonNull Context context) {
+        this.mContext = context.getApplicationContext();
+    }
+
+    @MainThread
+    public void deliverResult(@Nullable D d) {
+        OnLoadCompleteListener<D> onLoadCompleteListener = this.mListener;
+        if (onLoadCompleteListener != null) {
+            onLoadCompleteListener.onLoadComplete(this, d);
+        }
+    }
+
+    @MainThread
+    public void deliverCancellation() {
+        OnLoadCanceledListener<D> onLoadCanceledListener = this.mOnLoadCanceledListener;
+        if (onLoadCanceledListener != null) {
+            onLoadCanceledListener.onLoadCanceled(this);
+        }
+    }
+
+    @MainThread
+    public void registerListener(int i, @NonNull OnLoadCompleteListener<D> onLoadCompleteListener) {
+        if (this.mListener != null) {
+            throw new IllegalStateException("There is already a listener registered");
+        }
+        this.mListener = onLoadCompleteListener;
+        this.mId = i;
+    }
+
+    @MainThread
+    public void unregisterListener(@NonNull OnLoadCompleteListener<D> onLoadCompleteListener) {
+        OnLoadCompleteListener<D> onLoadCompleteListener2 = this.mListener;
+        if (onLoadCompleteListener2 == null) {
+            throw new IllegalStateException("No listener register");
+        }
+        if (onLoadCompleteListener2 != onLoadCompleteListener) {
+            throw new IllegalArgumentException("Attempting to unregister the wrong listener");
+        }
+        this.mListener = null;
+    }
+
+    @MainThread
+    public void registerOnLoadCanceledListener(@NonNull OnLoadCanceledListener<D> onLoadCanceledListener) {
+        if (this.mOnLoadCanceledListener != null) {
+            throw new IllegalStateException("There is already a listener registered");
+        }
+        this.mOnLoadCanceledListener = onLoadCanceledListener;
+    }
+
+    @MainThread
+    public void unregisterOnLoadCanceledListener(@NonNull OnLoadCanceledListener<D> onLoadCanceledListener) {
+        OnLoadCanceledListener<D> onLoadCanceledListener2 = this.mOnLoadCanceledListener;
+        if (onLoadCanceledListener2 == null) {
+            throw new IllegalStateException("No listener register");
+        }
+        if (onLoadCanceledListener2 != onLoadCanceledListener) {
+            throw new IllegalArgumentException("Attempting to unregister the wrong listener");
+        }
+        this.mOnLoadCanceledListener = null;
+    }
+
+    @MainThread
+    public final void startLoading() {
+        this.mStarted = true;
+        this.mReset = false;
+        this.mAbandoned = false;
+        onStartLoading();
+    }
+
+    @MainThread
+    public boolean cancelLoad() {
+        return onCancelLoad();
+    }
+
+    @MainThread
+    public void forceLoad() {
+        onForceLoad();
+    }
+
+    @MainThread
+    public void stopLoading() {
+        this.mStarted = false;
+        onStopLoading();
+    }
+
+    @MainThread
+    public void abandon() {
+        this.mAbandoned = true;
+        onAbandon();
+    }
+
+    @MainThread
+    public void reset() {
+        onReset();
+        this.mReset = true;
+        this.mStarted = false;
+        this.mAbandoned = false;
+        this.mContentChanged = false;
+        this.mProcessingChange = false;
+    }
+
+    public void rollbackContentChanged() {
+        if (this.mProcessingChange) {
+            onContentChanged();
+        }
+    }
+
+    @MainThread
+    public void onContentChanged() {
+        if (this.mStarted) {
+            forceLoad();
+        } else {
+            this.mContentChanged = true;
+        }
+    }
+
+    @NonNull
+    public String dataToString(@Nullable D d) {
+        StringBuilder sb = new StringBuilder(64);
+        if (d == null) {
+            sb.append("null");
+        } else {
+            Class<?> cls = d.getClass();
+            sb.append(cls.getSimpleName());
+            sb.append("{");
+            sb.append(Integer.toHexString(System.identityHashCode(cls)));
+            sb.append("}");
+        }
+        return sb.toString();
+    }
+
+    @NonNull
+    public String toString() {
+        StringBuilder sb = new StringBuilder(64);
+        Class<?> cls = getClass();
+        sb.append(cls.getSimpleName());
+        sb.append("{");
+        sb.append(Integer.toHexString(System.identityHashCode(cls)));
+        sb.append(" id=");
+        sb.append(this.mId);
+        sb.append("}");
+        return sb.toString();
+    }
+
+    @Deprecated
+    public void dump(String str, FileDescriptor fileDescriptor, PrintWriter printWriter, String[] strArr) {
+        printWriter.print(str);
+        printWriter.print("mId=");
+        printWriter.print(this.mId);
+        printWriter.print(" mListener=");
+        printWriter.println(this.mListener);
+        if (this.mStarted || this.mContentChanged || this.mProcessingChange) {
+            printWriter.print(str);
+            printWriter.print("mStarted=");
+            printWriter.print(this.mStarted);
+            printWriter.print(" mContentChanged=");
+            printWriter.print(this.mContentChanged);
+            printWriter.print(" mProcessingChange=");
+            printWriter.println(this.mProcessingChange);
+        }
+        if (this.mAbandoned || this.mReset) {
+            printWriter.print(str);
+            printWriter.print("mAbandoned=");
+            printWriter.print(this.mAbandoned);
+            printWriter.print(" mReset=");
+            printWriter.println(this.mReset);
+        }
+    }
+}

decompiled/sources/androidx/loader/content/ModernAsyncTask.java

@@ -0,0 +1,149 @@
+package androidx.loader.content;
+
+import android.os.Binder;
+import android.os.Handler;
+import android.os.Looper;
+import android.os.Process;
+import android.util.Log;
+import androidx.annotation.NonNull;
+import java.util.concurrent.Callable;
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Executor;
+import java.util.concurrent.FutureTask;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/* loaded from: classes.dex */
+abstract class ModernAsyncTask<Result> {
+    private static final String LOG_TAG = "AsyncTask";
+    private static Handler sHandler;
+    private volatile Status mStatus = Status.PENDING;
+    final AtomicBoolean mCancelled = new AtomicBoolean();
+    final AtomicBoolean mTaskInvoked = new AtomicBoolean();
+    private final FutureTask<Result> mFuture = new FutureTask<Result>(new Callable<Result>() { // from class: androidx.loader.content.ModernAsyncTask.1
+        @Override // java.util.concurrent.Callable
+        public Result call() {
+            ModernAsyncTask.this.mTaskInvoked.set(true);
+            Result result = null;
+            try {
+                Process.setThreadPriority(10);
+                result = (Result) ModernAsyncTask.this.doInBackground();
+                Binder.flushPendingCommands();
+                return result;
+            } finally {
+            }
+        }
+    }) { // from class: androidx.loader.content.ModernAsyncTask.2
+        @Override // java.util.concurrent.FutureTask
+        public void done() {
+            try {
+                ModernAsyncTask.this.postResultIfNotInvoked(get());
+            } catch (InterruptedException e) {
+                Log.w(ModernAsyncTask.LOG_TAG, e);
+            } catch (CancellationException unused) {
+                ModernAsyncTask.this.postResultIfNotInvoked(null);
+            } catch (ExecutionException e2) {
+                throw new RuntimeException("An error occurred while executing doInBackground()", e2.getCause());
+            } catch (Throwable th) {
+                throw new RuntimeException("An error occurred while executing doInBackground()", th);
+            }
+        }
+    };
+
+    public enum Status {
+        PENDING,
+        RUNNING,
+        FINISHED
+    }
+
+    public abstract Result doInBackground();
+
+    public void onCancelled(Result result) {
+    }
+
+    public void onPostExecute(Result result) {
+    }
+
+    private static Handler getHandler() {
+        Handler handler;
+        synchronized (ModernAsyncTask.class) {
+            try {
+                if (sHandler == null) {
+                    sHandler = new Handler(Looper.getMainLooper());
+                }
+                handler = sHandler;
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        return handler;
+    }
+
+    public void postResultIfNotInvoked(Result result) {
+        if (this.mTaskInvoked.get()) {
+            return;
+        }
+        postResult(result);
+    }
+
+    public void postResult(final Result result) {
+        getHandler().post(new Runnable() { // from class: androidx.loader.content.ModernAsyncTask.3
+            /* JADX WARN: Multi-variable type inference failed */
+            @Override // java.lang.Runnable
+            public void run() {
+                ModernAsyncTask.this.finish(result);
+            }
+        });
+    }
+
+    public final boolean isCancelled() {
+        return this.mCancelled.get();
+    }
+
+    public final boolean cancel(boolean z) {
+        this.mCancelled.set(true);
+        return this.mFuture.cancel(z);
+    }
+
+    /* renamed from: androidx.loader.content.ModernAsyncTask$4, reason: invalid class name */
+    public static /* synthetic */ class AnonymousClass4 {
+        static final /* synthetic */ int[] $SwitchMap$androidx$loader$content$ModernAsyncTask$Status;
+
+        static {
+            int[] iArr = new int[Status.values().length];
+            $SwitchMap$androidx$loader$content$ModernAsyncTask$Status = iArr;
+            try {
+                iArr[Status.RUNNING.ordinal()] = 1;
+            } catch (NoSuchFieldError unused) {
+            }
+            try {
+                $SwitchMap$androidx$loader$content$ModernAsyncTask$Status[Status.FINISHED.ordinal()] = 2;
+            } catch (NoSuchFieldError unused2) {
+            }
+        }
+    }
+
+    public final void executeOnExecutor(@NonNull Executor executor) {
+        if (this.mStatus != Status.PENDING) {
+            int i = AnonymousClass4.$SwitchMap$androidx$loader$content$ModernAsyncTask$Status[this.mStatus.ordinal()];
+            if (i == 1) {
+                throw new IllegalStateException("Cannot execute task: the task is already running.");
+            }
+            if (i == 2) {
+                throw new IllegalStateException("Cannot execute task: the task has already been executed (a task can be executed only once)");
+            }
+            throw new IllegalStateException("We should never reach this state");
+        }
+        this.mStatus = Status.RUNNING;
+        executor.execute(this.mFuture);
+    }
+
+    public void finish(Result result) {
+        if (isCancelled()) {
+            onCancelled(result);
+        } else {
+            onPostExecute(result);
+        }
+        this.mStatus = Status.FINISHED;
+    }
+}