alexandroid/decompiled/jadx/sources/androidx/loader/content/ModernAsyncTask.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

155 lines
5.6 KiB
Java

package androidx.loader.content;
import ai.onnxruntime.OnnxMap$$ExternalSyntheticBUOutline0;
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;
import rx.Single$$ExternalSyntheticBUOutline0;
/* compiled from: r8-map-id-b9432e0f623b4a4bff4ba50a8a24c4aafad2c1e11092747b9fb5e6a22af5a940 */
/* loaded from: classes14.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) {
OnnxMap$$ExternalSyntheticBUOutline0.m("An error occurred while executing doInBackground()", e2.getCause());
} catch (Throwable th) {
OnnxMap$$ExternalSyntheticBUOutline0.m("An error occurred while executing doInBackground()", th);
}
}
};
/* compiled from: r8-map-id-b9432e0f623b4a4bff4ba50a8a24c4aafad2c1e11092747b9fb5e6a22af5a940 */
/* 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) {
}
}
}
/* compiled from: r8-map-id-b9432e0f623b4a4bff4ba50a8a24c4aafad2c1e11092747b9fb5e6a22af5a940 */
public enum Status {
PENDING,
RUNNING,
FINISHED
}
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 final boolean cancel(boolean z) {
this.mCancelled.set(true);
return this.mFuture.cancel(z);
}
public abstract Result doInBackground();
public final void executeOnExecutor(@NonNull Executor executor) {
if (this.mStatus == Status.PENDING) {
this.mStatus = Status.RUNNING;
executor.execute(this.mFuture);
return;
}
int i = AnonymousClass4.$SwitchMap$androidx$loader$content$ModernAsyncTask$Status[this.mStatus.ordinal()];
if (i == 1) {
Single$$ExternalSyntheticBUOutline0.m$2("Cannot execute task: the task is already running.");
} else if (i != 2) {
Single$$ExternalSyntheticBUOutline0.m$2("We should never reach this state");
} else {
Single$$ExternalSyntheticBUOutline0.m$2("Cannot execute task: the task has already been executed (a task can be executed only once)");
}
}
public void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
this.mStatus = Status.FINISHED;
}
public final boolean isCancelled() {
return this.mCancelled.get();
}
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 void postResultIfNotInvoked(Result result) {
if (this.mTaskInvoked.get()) {
return;
}
postResult(result);
}
public void onCancelled(Result result) {
}
public void onPostExecute(Result result) {
}
}