Initial import of ADIF API reverse-engineering toolkit

apk_decompiled/sources/com/google/android/gms/tasks/Tasks.java

@@ -0,0 +1,187 @@
+package com.google.android.gms.tasks;
+
+import android.os.Looper;
+import com.google.android.gms.common.internal.Preconditions;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.concurrent.Callable;
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Executor;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+/* loaded from: classes3.dex */
+public final class Tasks {
+    private Tasks() {
+    }
+
+    public static <TResult> TResult await(Task<TResult> task) throws ExecutionException, InterruptedException {
+        Preconditions.checkNotMainThread();
+        Preconditions.checkNotNull(task, "Task must not be null");
+        if (task.isComplete()) {
+            return (TResult) zza(task);
+        }
+        zzad zzadVar = new zzad(null);
+        zzb(task, zzadVar);
+        zzadVar.zza();
+        return (TResult) zza(task);
+    }
+
+    @Deprecated
+    public static <TResult> Task<TResult> call(Callable<TResult> callable) {
+        return call(TaskExecutors.MAIN_THREAD, callable);
+    }
+
+    public static <TResult> Task<TResult> forCanceled() {
+        zzw zzwVar = new zzw();
+        zzwVar.zzc();
+        return zzwVar;
+    }
+
+    public static <TResult> Task<TResult> forException(Exception exc) {
+        zzw zzwVar = new zzw();
+        zzwVar.zza(exc);
+        return zzwVar;
+    }
+
+    public static <TResult> Task<TResult> forResult(TResult tresult) {
+        zzw zzwVar = new zzw();
+        zzwVar.zzb(tresult);
+        return zzwVar;
+    }
+
+    public static Task<Void> whenAll(Collection<? extends Task<?>> collection) {
+        if (collection != null && !collection.isEmpty()) {
+            Iterator<? extends Task<?>> it = collection.iterator();
+            while (it.hasNext()) {
+                if (it.next() == null) {
+                    throw new NullPointerException("null tasks are not accepted");
+                }
+            }
+            zzw zzwVar = new zzw();
+            zzaf zzafVar = new zzaf(collection.size(), zzwVar);
+            Iterator<? extends Task<?>> it2 = collection.iterator();
+            while (it2.hasNext()) {
+                zzb(it2.next(), zzafVar);
+            }
+            return zzwVar;
+        }
+        return forResult(null);
+    }
+
+    public static Task<List<Task<?>>> whenAllComplete(Collection<? extends Task<?>> collection) {
+        if (collection != null && !collection.isEmpty()) {
+            return whenAll(collection).continueWithTask(TaskExecutors.MAIN_THREAD, new zzab(collection));
+        }
+        return forResult(Collections.EMPTY_LIST);
+    }
+
+    public static <TResult> Task<List<TResult>> whenAllSuccess(Collection<? extends Task> collection) {
+        if (collection != null && !collection.isEmpty()) {
+            return (Task<List<TResult>>) whenAll((Collection<? extends Task<?>>) collection).continueWith(TaskExecutors.MAIN_THREAD, new zzaa(collection));
+        }
+        return forResult(Collections.EMPTY_LIST);
+    }
+
+    public static <T> Task<T> withTimeout(Task<T> task, long j4, TimeUnit timeUnit) {
+        Preconditions.checkNotNull(task, "Task must not be null");
+        Preconditions.checkArgument(j4 > 0, "Timeout must be positive");
+        Preconditions.checkNotNull(timeUnit, "TimeUnit must not be null");
+        final zzb zzbVar = new zzb();
+        final TaskCompletionSource taskCompletionSource = new TaskCompletionSource(zzbVar);
+        final com.google.android.gms.internal.tasks.zza zzaVar = new com.google.android.gms.internal.tasks.zza(Looper.getMainLooper());
+        zzaVar.postDelayed(new Runnable() { // from class: com.google.android.gms.tasks.zzx
+            @Override // java.lang.Runnable
+            public final void run() {
+                TaskCompletionSource.this.trySetException(new TimeoutException());
+            }
+        }, timeUnit.toMillis(j4));
+        task.addOnCompleteListener(new OnCompleteListener() { // from class: com.google.android.gms.tasks.zzy
+            @Override // com.google.android.gms.tasks.OnCompleteListener
+            public final void onComplete(Task task2) {
+                com.google.android.gms.internal.tasks.zza zzaVar2 = com.google.android.gms.internal.tasks.zza.this;
+                TaskCompletionSource taskCompletionSource2 = taskCompletionSource;
+                zzb zzbVar2 = zzbVar;
+                zzaVar2.removeCallbacksAndMessages(null);
+                if (task2.isSuccessful()) {
+                    taskCompletionSource2.trySetResult(task2.getResult());
+                } else {
+                    if (task2.isCanceled()) {
+                        zzbVar2.zza();
+                        return;
+                    }
+                    Exception exception = task2.getException();
+                    exception.getClass();
+                    taskCompletionSource2.trySetException(exception);
+                }
+            }
+        });
+        return taskCompletionSource.getTask();
+    }
+
+    private static Object zza(Task task) throws ExecutionException {
+        if (task.isSuccessful()) {
+            return task.getResult();
+        }
+        if (task.isCanceled()) {
+            throw new CancellationException("Task is already canceled");
+        }
+        throw new ExecutionException(task.getException());
+    }
+
+    private static void zzb(Task task, zzae zzaeVar) {
+        Executor executor = TaskExecutors.zza;
+        task.addOnSuccessListener(executor, zzaeVar);
+        task.addOnFailureListener(executor, zzaeVar);
+        task.addOnCanceledListener(executor, zzaeVar);
+    }
+
+    @Deprecated
+    public static <TResult> Task<TResult> call(Executor executor, Callable<TResult> callable) {
+        Preconditions.checkNotNull(executor, "Executor must not be null");
+        Preconditions.checkNotNull(callable, "Callback must not be null");
+        zzw zzwVar = new zzw();
+        executor.execute(new zzz(zzwVar, callable));
+        return zzwVar;
+    }
+
+    public static Task<List<Task<?>>> whenAllComplete(Task<?>... taskArr) {
+        if (taskArr != null && taskArr.length != 0) {
+            return whenAllComplete(Arrays.asList(taskArr));
+        }
+        return forResult(Collections.EMPTY_LIST);
+    }
+
+    public static <TResult> Task<List<TResult>> whenAllSuccess(Task... taskArr) {
+        if (taskArr != null && taskArr.length != 0) {
+            return whenAllSuccess(Arrays.asList(taskArr));
+        }
+        return forResult(Collections.EMPTY_LIST);
+    }
+
+    public static <TResult> TResult await(Task<TResult> task, long j4, TimeUnit timeUnit) throws ExecutionException, InterruptedException, TimeoutException {
+        Preconditions.checkNotMainThread();
+        Preconditions.checkNotNull(task, "Task must not be null");
+        Preconditions.checkNotNull(timeUnit, "TimeUnit must not be null");
+        if (task.isComplete()) {
+            return (TResult) zza(task);
+        }
+        zzad zzadVar = new zzad(null);
+        zzb(task, zzadVar);
+        if (zzadVar.zzb(j4, timeUnit)) {
+            return (TResult) zza(task);
+        }
+        throw new TimeoutException("Timed out waiting for Task");
+    }
+
+    public static Task<Void> whenAll(Task<?>... taskArr) {
+        if (taskArr != null && taskArr.length != 0) {
+            return whenAll(Arrays.asList(taskArr));
+        }
+        return forResult(null);
+    }
+}