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