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/com/google/android/gms/tasks/CancellationToken.java

@@ -0,0 +1,11 @@
+package com.google.android.gms.tasks;
+
+import androidx.annotation.NonNull;
+
+/* loaded from: classes3.dex */
+public abstract class CancellationToken {
+    public abstract boolean isCancellationRequested();
+
+    @NonNull
+    public abstract CancellationToken onCanceledRequested(@NonNull OnTokenCanceledListener onTokenCanceledListener);
+}

decompiled/sources/com/google/android/gms/tasks/CancellationTokenSource.java

@@ -0,0 +1,17 @@
+package com.google.android.gms.tasks;
+
+import androidx.annotation.NonNull;
+
+/* loaded from: classes3.dex */
+public class CancellationTokenSource {
+    private final zzb zza = new zzb();
+
+    public void cancel() {
+        this.zza.zza();
+    }
+
+    @NonNull
+    public CancellationToken getToken() {
+        return this.zza;
+    }
+}

decompiled/sources/com/google/android/gms/tasks/Continuation.java

@@ -0,0 +1,8 @@
+package com.google.android.gms.tasks;
+
+import androidx.annotation.NonNull;
+
+/* loaded from: classes3.dex */
+public interface Continuation<TResult, TContinuationResult> {
+    TContinuationResult then(@NonNull Task<TResult> task) throws Exception;
+}

decompiled/sources/com/google/android/gms/tasks/DuplicateTaskCompletionException.java

@@ -0,0 +1,21 @@
+package com.google.android.gms.tasks;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.facebook.login.LoginLogger;
+
+/* loaded from: classes3.dex */
+public final class DuplicateTaskCompletionException extends IllegalStateException {
+    private DuplicateTaskCompletionException(String str, @Nullable Throwable th) {
+        super(str, th);
+    }
+
+    @NonNull
+    public static IllegalStateException of(@NonNull Task<?> task) {
+        if (!task.isComplete()) {
+            return new IllegalStateException("DuplicateTaskCompletionException can only be created from completed Task.");
+        }
+        Exception exception = task.getException();
+        return new DuplicateTaskCompletionException("Complete with: ".concat(exception != null ? LoginLogger.EVENT_EXTRAS_FAILURE : task.isSuccessful() ? "result ".concat(String.valueOf(task.getResult())) : task.isCanceled() ? "cancellation" : "unknown issue"), exception);
+    }
+}

decompiled/sources/com/google/android/gms/tasks/NativeOnCompleteListener.java

@@ -0,0 +1,43 @@
+package com.google.android.gms.tasks;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.annotation.KeepForSdk;
+
+@KeepForSdk
+/* loaded from: classes3.dex */
+public class NativeOnCompleteListener implements OnCompleteListener<Object> {
+    private final long zza;
+
+    @KeepForSdk
+    public NativeOnCompleteListener(long j) {
+        this.zza = j;
+    }
+
+    @KeepForSdk
+    public static void createAndAddCallback(@NonNull Task<Object> task, long j) {
+        task.addOnCompleteListener(new NativeOnCompleteListener(j));
+    }
+
+    @KeepForSdk
+    public native void nativeOnComplete(long j, @Nullable Object obj, boolean z, boolean z2, @Nullable String str);
+
+    @Override // com.google.android.gms.tasks.OnCompleteListener
+    @KeepForSdk
+    public void onComplete(@NonNull Task<Object> task) {
+        Object obj;
+        String str;
+        Exception exception;
+        if (task.isSuccessful()) {
+            obj = task.getResult();
+            str = null;
+        } else if (task.isCanceled() || (exception = task.getException()) == null) {
+            obj = null;
+            str = null;
+        } else {
+            str = exception.getMessage();
+            obj = null;
+        }
+        nativeOnComplete(this.zza, obj, task.isSuccessful(), task.isCanceled(), str);
+    }
+}

decompiled/sources/com/google/android/gms/tasks/OnCanceledListener.java

@@ -0,0 +1,6 @@
+package com.google.android.gms.tasks;
+
+/* loaded from: classes3.dex */
+public interface OnCanceledListener {
+    void onCanceled();
+}

decompiled/sources/com/google/android/gms/tasks/OnCompleteListener.java

@@ -0,0 +1,8 @@
+package com.google.android.gms.tasks;
+
+import androidx.annotation.NonNull;
+
+/* loaded from: classes3.dex */
+public interface OnCompleteListener<TResult> {
+    void onComplete(@NonNull Task<TResult> task);
+}

decompiled/sources/com/google/android/gms/tasks/OnFailureListener.java

@@ -0,0 +1,8 @@
+package com.google.android.gms.tasks;
+
+import androidx.annotation.NonNull;
+
+/* loaded from: classes3.dex */
+public interface OnFailureListener {
+    void onFailure(@NonNull Exception exc);
+}

decompiled/sources/com/google/android/gms/tasks/OnSuccessListener.java

@@ -0,0 +1,6 @@
+package com.google.android.gms.tasks;
+
+/* loaded from: classes3.dex */
+public interface OnSuccessListener<TResult> {
+    void onSuccess(TResult tresult);
+}

decompiled/sources/com/google/android/gms/tasks/OnTokenCanceledListener.java

@@ -0,0 +1,6 @@
+package com.google.android.gms.tasks;
+
+/* loaded from: classes3.dex */
+public interface OnTokenCanceledListener {
+    void onCanceled();
+}

decompiled/sources/com/google/android/gms/tasks/R.java

@@ -0,0 +1,7 @@
+package com.google.android.gms.tasks;
+
+/* loaded from: classes3.dex */
+public final class R {
+    private R() {
+    }
+}

decompiled/sources/com/google/android/gms/tasks/RuntimeExecutionException.java

@@ -0,0 +1,10 @@
+package com.google.android.gms.tasks;
+
+import androidx.annotation.NonNull;
+
+/* loaded from: classes3.dex */
+public class RuntimeExecutionException extends RuntimeException {
+    public RuntimeExecutionException(@NonNull Throwable th) {
+        super(th);
+    }
+}

decompiled/sources/com/google/android/gms/tasks/SuccessContinuation.java

@@ -0,0 +1,9 @@
+package com.google.android.gms.tasks;
+
+import androidx.annotation.NonNull;
+
+/* loaded from: classes3.dex */
+public interface SuccessContinuation<TResult, TContinuationResult> {
+    @NonNull
+    Task<TContinuationResult> then(TResult tresult) throws Exception;
+}

decompiled/sources/com/google/android/gms/tasks/Task.java

@@ -0,0 +1,100 @@
+package com.google.android.gms.tasks;
+
+import android.app.Activity;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import java.util.concurrent.Executor;
+
+/* loaded from: classes3.dex */
+public abstract class Task<TResult> {
+    @NonNull
+    public Task<TResult> addOnCanceledListener(@NonNull Activity activity, @NonNull OnCanceledListener onCanceledListener) {
+        throw new UnsupportedOperationException("addOnCanceledListener is not implemented.");
+    }
+
+    @NonNull
+    public Task<TResult> addOnCompleteListener(@NonNull Activity activity, @NonNull OnCompleteListener<TResult> onCompleteListener) {
+        throw new UnsupportedOperationException("addOnCompleteListener is not implemented");
+    }
+
+    @NonNull
+    public abstract Task<TResult> addOnFailureListener(@NonNull Activity activity, @NonNull OnFailureListener onFailureListener);
+
+    @NonNull
+    public abstract Task<TResult> addOnFailureListener(@NonNull OnFailureListener onFailureListener);
+
+    @NonNull
+    public abstract Task<TResult> addOnFailureListener(@NonNull Executor executor, @NonNull OnFailureListener onFailureListener);
+
+    @NonNull
+    public abstract Task<TResult> addOnSuccessListener(@NonNull Activity activity, @NonNull OnSuccessListener<? super TResult> onSuccessListener);
+
+    @NonNull
+    public abstract Task<TResult> addOnSuccessListener(@NonNull OnSuccessListener<? super TResult> onSuccessListener);
+
+    @NonNull
+    public abstract Task<TResult> addOnSuccessListener(@NonNull Executor executor, @NonNull OnSuccessListener<? super TResult> onSuccessListener);
+
+    @NonNull
+    public <TContinuationResult> Task<TContinuationResult> continueWith(@NonNull Continuation<TResult, TContinuationResult> continuation) {
+        throw new UnsupportedOperationException("continueWith is not implemented");
+    }
+
+    @NonNull
+    public <TContinuationResult> Task<TContinuationResult> continueWithTask(@NonNull Continuation<TResult, Task<TContinuationResult>> continuation) {
+        throw new UnsupportedOperationException("continueWithTask is not implemented");
+    }
+
+    @Nullable
+    public abstract Exception getException();
+
+    public abstract TResult getResult();
+
+    public abstract <X extends Throwable> TResult getResult(@NonNull Class<X> cls) throws Throwable;
+
+    public abstract boolean isCanceled();
+
+    public abstract boolean isComplete();
+
+    public abstract boolean isSuccessful();
+
+    @NonNull
+    public <TContinuationResult> Task<TContinuationResult> onSuccessTask(@NonNull SuccessContinuation<TResult, TContinuationResult> successContinuation) {
+        throw new UnsupportedOperationException("onSuccessTask is not implemented");
+    }
+
+    @NonNull
+    public Task<TResult> addOnCanceledListener(@NonNull OnCanceledListener onCanceledListener) {
+        throw new UnsupportedOperationException("addOnCanceledListener is not implemented.");
+    }
+
+    @NonNull
+    public Task<TResult> addOnCompleteListener(@NonNull OnCompleteListener<TResult> onCompleteListener) {
+        throw new UnsupportedOperationException("addOnCompleteListener is not implemented");
+    }
+
+    @NonNull
+    public <TContinuationResult> Task<TContinuationResult> continueWith(@NonNull Executor executor, @NonNull Continuation<TResult, TContinuationResult> continuation) {
+        throw new UnsupportedOperationException("continueWith is not implemented");
+    }
+
+    @NonNull
+    public <TContinuationResult> Task<TContinuationResult> continueWithTask(@NonNull Executor executor, @NonNull Continuation<TResult, Task<TContinuationResult>> continuation) {
+        throw new UnsupportedOperationException("continueWithTask is not implemented");
+    }
+
+    @NonNull
+    public <TContinuationResult> Task<TContinuationResult> onSuccessTask(@NonNull Executor executor, @NonNull SuccessContinuation<TResult, TContinuationResult> successContinuation) {
+        throw new UnsupportedOperationException("onSuccessTask is not implemented");
+    }
+
+    @NonNull
+    public Task<TResult> addOnCanceledListener(@NonNull Executor executor, @NonNull OnCanceledListener onCanceledListener) {
+        throw new UnsupportedOperationException("addOnCanceledListener is not implemented");
+    }
+
+    @NonNull
+    public Task<TResult> addOnCompleteListener(@NonNull Executor executor, @NonNull OnCompleteListener<TResult> onCompleteListener) {
+        throw new UnsupportedOperationException("addOnCompleteListener is not implemented");
+    }
+}

decompiled/sources/com/google/android/gms/tasks/TaskCompletionSource.java

@@ -0,0 +1,37 @@
+package com.google.android.gms.tasks;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+/* loaded from: classes3.dex */
+public class TaskCompletionSource<TResult> {
+    private final zzw zza = new zzw();
+
+    public TaskCompletionSource() {
+    }
+
+    public TaskCompletionSource(@NonNull CancellationToken cancellationToken) {
+        cancellationToken.onCanceledRequested(new zzs(this));
+    }
+
+    @NonNull
+    public Task<TResult> getTask() {
+        return this.zza;
+    }
+
+    public void setException(@NonNull Exception exc) {
+        this.zza.zza(exc);
+    }
+
+    public void setResult(@Nullable TResult tresult) {
+        this.zza.zzb(tresult);
+    }
+
+    public boolean trySetException(@NonNull Exception exc) {
+        return this.zza.zzd(exc);
+    }
+
+    public boolean trySetResult(@Nullable TResult tresult) {
+        return this.zza.zze(tresult);
+    }
+}

decompiled/sources/com/google/android/gms/tasks/TaskExecutors.java

@@ -0,0 +1,15 @@
+package com.google.android.gms.tasks;
+
+import androidx.annotation.NonNull;
+import java.util.concurrent.Executor;
+
+/* loaded from: classes3.dex */
+public final class TaskExecutors {
+
+    @NonNull
+    public static final Executor MAIN_THREAD = new zzu();
+    static final Executor zza = new zzt();
+
+    private TaskExecutors() {
+    }
+}

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

@@ -0,0 +1,221 @@
+package com.google.android.gms.tasks;
+
+import android.os.Looper;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+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(@NonNull Task<TResult> task) throws ExecutionException, InterruptedException {
+        Preconditions.checkNotMainThread();
+        Preconditions.checkNotGoogleApiHandlerThread();
+        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);
+    }
+
+    @NonNull
+    @Deprecated
+    public static <TResult> Task<TResult> call(@NonNull Callable<TResult> callable) {
+        return call(TaskExecutors.MAIN_THREAD, callable);
+    }
+
+    @NonNull
+    public static <TResult> Task<TResult> forCanceled() {
+        zzw zzwVar = new zzw();
+        zzwVar.zzc();
+        return zzwVar;
+    }
+
+    @NonNull
+    public static <TResult> Task<TResult> forException(@NonNull Exception exc) {
+        zzw zzwVar = new zzw();
+        zzwVar.zza(exc);
+        return zzwVar;
+    }
+
+    @NonNull
+    public static <TResult> Task<TResult> forResult(TResult tresult) {
+        zzw zzwVar = new zzw();
+        zzwVar.zzb(tresult);
+        return zzwVar;
+    }
+
+    @NonNull
+    public static Task<Void> whenAll(@Nullable Collection<? extends Task<?>> collection) {
+        if (collection == null || collection.isEmpty()) {
+            return forResult(null);
+        }
+        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;
+    }
+
+    @NonNull
+    public static Task<List<Task<?>>> whenAllComplete(@Nullable Collection<? extends Task<?>> collection) {
+        return whenAllComplete(TaskExecutors.MAIN_THREAD, collection);
+    }
+
+    @NonNull
+    public static <TResult> Task<List<TResult>> whenAllSuccess(@Nullable Collection<? extends Task> collection) {
+        return whenAllSuccess(TaskExecutors.MAIN_THREAD, collection);
+    }
+
+    @NonNull
+    public static <T> Task<T> withTimeout(@NonNull Task<T> task, long j, @NonNull TimeUnit timeUnit) {
+        Preconditions.checkNotNull(task, "Task must not be null");
+        Preconditions.checkArgument(j > 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(j));
+        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.this.removeCallbacksAndMessages(null);
+                TaskCompletionSource taskCompletionSource2 = taskCompletionSource;
+                if (task2.isSuccessful()) {
+                    taskCompletionSource2.trySetResult(task2.getResult());
+                } else {
+                    if (task2.isCanceled()) {
+                        zzbVar.zza();
+                        return;
+                    }
+                    Exception exception = task2.getException();
+                    exception.getClass();
+                    taskCompletionSource2.trySetException(exception);
+                }
+            }
+        });
+        return taskCompletionSource.getTask();
+    }
+
+    private static Object zza(@NonNull 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);
+    }
+
+    @NonNull
+    @Deprecated
+    public static <TResult> Task<TResult> call(@NonNull Executor executor, @NonNull 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;
+    }
+
+    @NonNull
+    public static Task<List<Task<?>>> whenAllComplete(@NonNull Executor executor, @Nullable Collection<? extends Task<?>> collection) {
+        return (collection == null || collection.isEmpty()) ? forResult(Collections.emptyList()) : whenAll(collection).continueWithTask(executor, new zzab(collection));
+    }
+
+    @NonNull
+    public static <TResult> Task<List<TResult>> whenAllSuccess(@NonNull Executor executor, @Nullable Collection<? extends Task> collection) {
+        return (collection == null || collection.isEmpty()) ? forResult(Collections.emptyList()) : (Task<List<TResult>>) whenAll((Collection<? extends Task<?>>) collection).continueWith(executor, new zzaa(collection));
+    }
+
+    @NonNull
+    public static Task<List<Task<?>>> whenAllComplete(@NonNull Executor executor, @Nullable Task<?>... taskArr) {
+        if (taskArr == null || taskArr.length == 0) {
+            return forResult(Collections.emptyList());
+        }
+        return whenAllComplete(executor, Arrays.asList(taskArr));
+    }
+
+    @NonNull
+    public static <TResult> Task<List<TResult>> whenAllSuccess(@NonNull Executor executor, @Nullable Task... taskArr) {
+        if (taskArr == null || taskArr.length == 0) {
+            return forResult(Collections.emptyList());
+        }
+        return whenAllSuccess(executor, Arrays.asList(taskArr));
+    }
+
+    @NonNull
+    public static Task<List<Task<?>>> whenAllComplete(@Nullable Task<?>... taskArr) {
+        if (taskArr == null || taskArr.length == 0) {
+            return forResult(Collections.emptyList());
+        }
+        return whenAllComplete(Arrays.asList(taskArr));
+    }
+
+    @NonNull
+    public static <TResult> Task<List<TResult>> whenAllSuccess(@Nullable Task... taskArr) {
+        if (taskArr == null || taskArr.length == 0) {
+            return forResult(Collections.emptyList());
+        }
+        return whenAllSuccess(Arrays.asList(taskArr));
+    }
+
+    public static <TResult> TResult await(@NonNull Task<TResult> task, long j, @NonNull TimeUnit timeUnit) throws ExecutionException, InterruptedException, TimeoutException {
+        Preconditions.checkNotMainThread();
+        Preconditions.checkNotGoogleApiHandlerThread();
+        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(j, timeUnit)) {
+            throw new TimeoutException("Timed out waiting for Task");
+        }
+        return (TResult) zza(task);
+    }
+
+    @NonNull
+    public static Task<Void> whenAll(@Nullable Task<?>... taskArr) {
+        if (taskArr == null || taskArr.length == 0) {
+            return forResult(null);
+        }
+        return whenAll(Arrays.asList(taskArr));
+    }
+}

decompiled/sources/com/google/android/gms/tasks/zza.java

@@ -0,0 +1,15 @@
+package com.google.android.gms.tasks;
+
+/* loaded from: classes3.dex */
+final class zza implements OnSuccessListener {
+    final /* synthetic */ OnTokenCanceledListener zza;
+
+    public zza(zzb zzbVar, OnTokenCanceledListener onTokenCanceledListener) {
+        this.zza = onTokenCanceledListener;
+    }
+
+    @Override // com.google.android.gms.tasks.OnSuccessListener
+    public final /* bridge */ /* synthetic */ void onSuccess(Object obj) {
+        this.zza.onCanceled();
+    }
+}

decompiled/sources/com/google/android/gms/tasks/zzaa.java

@@ -0,0 +1,25 @@
+package com.google.android.gms.tasks;
+
+import androidx.annotation.NonNull;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+
+/* loaded from: classes3.dex */
+final class zzaa implements Continuation {
+    final /* synthetic */ Collection zza;
+
+    public zzaa(Collection collection) {
+        this.zza = collection;
+    }
+
+    @Override // com.google.android.gms.tasks.Continuation
+    public final /* bridge */ /* synthetic */ Object then(@NonNull Task task) throws Exception {
+        ArrayList arrayList = new ArrayList();
+        Iterator it = this.zza.iterator();
+        while (it.hasNext()) {
+            arrayList.add(((Task) it.next()).getResult());
+        }
+        return arrayList;
+    }
+}

decompiled/sources/com/google/android/gms/tasks/zzab.java

@@ -0,0 +1,21 @@
+package com.google.android.gms.tasks;
+
+import androidx.annotation.NonNull;
+import java.util.ArrayList;
+import java.util.Collection;
+
+/* loaded from: classes3.dex */
+final class zzab implements Continuation {
+    final /* synthetic */ Collection zza;
+
+    public zzab(Collection collection) {
+        this.zza = collection;
+    }
+
+    @Override // com.google.android.gms.tasks.Continuation
+    public final /* bridge */ /* synthetic */ Object then(@NonNull Task task) throws Exception {
+        ArrayList arrayList = new ArrayList();
+        arrayList.addAll(this.zza);
+        return Tasks.forResult(arrayList);
+    }
+}

decompiled/sources/com/google/android/gms/tasks/zzad.java

@@ -0,0 +1,39 @@
+package com.google.android.gms.tasks;
+
+import androidx.annotation.NonNull;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+/* loaded from: classes3.dex */
+final class zzad<T> implements zzae<T> {
+    private final CountDownLatch zza = new CountDownLatch(1);
+
+    private zzad() {
+    }
+
+    @Override // com.google.android.gms.tasks.OnCanceledListener
+    public final void onCanceled() {
+        this.zza.countDown();
+    }
+
+    @Override // com.google.android.gms.tasks.OnFailureListener
+    public final void onFailure(@NonNull Exception exc) {
+        this.zza.countDown();
+    }
+
+    @Override // com.google.android.gms.tasks.OnSuccessListener
+    public final void onSuccess(T t) {
+        this.zza.countDown();
+    }
+
+    public final void zza() throws InterruptedException {
+        this.zza.await();
+    }
+
+    public final boolean zzb(long j, TimeUnit timeUnit) throws InterruptedException {
+        return this.zza.await(j, timeUnit);
+    }
+
+    public /* synthetic */ zzad(zzac zzacVar) {
+    }
+}

decompiled/sources/com/google/android/gms/tasks/zzae.java

@@ -0,0 +1,5 @@
+package com.google.android.gms.tasks;
+
+/* loaded from: classes3.dex */
+interface zzae<T> extends OnSuccessListener<T>, OnFailureListener, OnCanceledListener {
+}

decompiled/sources/com/google/android/gms/tasks/zzaf.java

@@ -0,0 +1,62 @@
+package com.google.android.gms.tasks;
+
+import androidx.annotation.NonNull;
+import java.util.concurrent.ExecutionException;
+
+/* loaded from: classes3.dex */
+final class zzaf<T> implements zzae<T> {
+    private final Object zza = new Object();
+    private final int zzb;
+    private final zzw zzc;
+    private int zzd;
+    private int zze;
+    private int zzf;
+    private Exception zzg;
+    private boolean zzh;
+
+    public zzaf(int i, zzw zzwVar) {
+        this.zzb = i;
+        this.zzc = zzwVar;
+    }
+
+    private final void zza() {
+        if (this.zzd + this.zze + this.zzf == this.zzb) {
+            if (this.zzg == null) {
+                if (this.zzh) {
+                    this.zzc.zzc();
+                    return;
+                } else {
+                    this.zzc.zzb(null);
+                    return;
+                }
+            }
+            this.zzc.zza(new ExecutionException(this.zze + " out of " + this.zzb + " underlying tasks failed", this.zzg));
+        }
+    }
+
+    @Override // com.google.android.gms.tasks.OnCanceledListener
+    public final void onCanceled() {
+        synchronized (this.zza) {
+            this.zzf++;
+            this.zzh = true;
+            zza();
+        }
+    }
+
+    @Override // com.google.android.gms.tasks.OnFailureListener
+    public final void onFailure(@NonNull Exception exc) {
+        synchronized (this.zza) {
+            this.zze++;
+            this.zzg = exc;
+            zza();
+        }
+    }
+
+    @Override // com.google.android.gms.tasks.OnSuccessListener
+    public final void onSuccess(T t) {
+        synchronized (this.zza) {
+            this.zzd++;
+            zza();
+        }
+    }
+}

decompiled/sources/com/google/android/gms/tasks/zzb.java

@@ -0,0 +1,23 @@
+package com.google.android.gms.tasks;
+
+import androidx.annotation.NonNull;
+
+/* loaded from: classes3.dex */
+final class zzb extends CancellationToken {
+    private final zzw zza = new zzw();
+
+    @Override // com.google.android.gms.tasks.CancellationToken
+    public final boolean isCancellationRequested() {
+        return this.zza.isComplete();
+    }
+
+    @Override // com.google.android.gms.tasks.CancellationToken
+    public final CancellationToken onCanceledRequested(@NonNull OnTokenCanceledListener onTokenCanceledListener) {
+        this.zza.addOnSuccessListener(TaskExecutors.MAIN_THREAD, new zza(this, onTokenCanceledListener));
+        return this;
+    }
+
+    public final void zza() {
+        this.zza.zze(null);
+    }
+}

decompiled/sources/com/google/android/gms/tasks/zzc.java

@@ -0,0 +1,44 @@
+package com.google.android.gms.tasks;
+
+/* loaded from: classes3.dex */
+final class zzc implements Runnable {
+    final /* synthetic */ Task zza;
+    final /* synthetic */ zzd zzb;
+
+    public zzc(zzd zzdVar, Task task) {
+        this.zzb = zzdVar;
+        this.zza = task;
+    }
+
+    @Override // java.lang.Runnable
+    public final void run() {
+        zzw zzwVar;
+        zzw zzwVar2;
+        zzw zzwVar3;
+        Continuation continuation;
+        zzw zzwVar4;
+        zzw zzwVar5;
+        if (this.zza.isCanceled()) {
+            zzwVar5 = this.zzb.zzc;
+            zzwVar5.zzc();
+            return;
+        }
+        try {
+            continuation = this.zzb.zzb;
+            Object then = continuation.then(this.zza);
+            zzwVar4 = this.zzb.zzc;
+            zzwVar4.zzb(then);
+        } catch (RuntimeExecutionException e) {
+            if (e.getCause() instanceof Exception) {
+                zzwVar3 = this.zzb.zzc;
+                zzwVar3.zza((Exception) e.getCause());
+            } else {
+                zzwVar2 = this.zzb.zzc;
+                zzwVar2.zza(e);
+            }
+        } catch (Exception e2) {
+            zzwVar = this.zzb.zzc;
+            zzwVar.zza(e2);
+        }
+    }
+}

decompiled/sources/com/google/android/gms/tasks/zzd.java

@@ -0,0 +1,27 @@
+package com.google.android.gms.tasks;
+
+import androidx.annotation.NonNull;
+import java.util.concurrent.Executor;
+
+/* loaded from: classes3.dex */
+final class zzd implements zzq {
+    private final Executor zza;
+    private final Continuation zzb;
+    private final zzw zzc;
+
+    public zzd(@NonNull Executor executor, @NonNull Continuation continuation, @NonNull zzw zzwVar) {
+        this.zza = executor;
+        this.zzb = continuation;
+        this.zzc = zzwVar;
+    }
+
+    @Override // com.google.android.gms.tasks.zzq
+    public final void zzc() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override // com.google.android.gms.tasks.zzq
+    public final void zzd(@NonNull Task task) {
+        this.zza.execute(new zzc(this, task));
+    }
+}

decompiled/sources/com/google/android/gms/tasks/zze.java

@@ -0,0 +1,46 @@
+package com.google.android.gms.tasks;
+
+import java.util.concurrent.Executor;
+
+/* loaded from: classes3.dex */
+final class zze implements Runnable {
+    final /* synthetic */ Task zza;
+    final /* synthetic */ zzf zzb;
+
+    public zze(zzf zzfVar, Task task) {
+        this.zzb = zzfVar;
+        this.zza = task;
+    }
+
+    @Override // java.lang.Runnable
+    public final void run() {
+        zzw zzwVar;
+        zzw zzwVar2;
+        zzw zzwVar3;
+        Continuation continuation;
+        try {
+            continuation = this.zzb.zzb;
+            Task task = (Task) continuation.then(this.zza);
+            if (task == null) {
+                this.zzb.onFailure(new NullPointerException("Continuation returned null"));
+                return;
+            }
+            zzf zzfVar = this.zzb;
+            Executor executor = TaskExecutors.zza;
+            task.addOnSuccessListener(executor, zzfVar);
+            task.addOnFailureListener(executor, this.zzb);
+            task.addOnCanceledListener(executor, this.zzb);
+        } catch (RuntimeExecutionException e) {
+            if (e.getCause() instanceof Exception) {
+                zzwVar3 = this.zzb.zzc;
+                zzwVar3.zza((Exception) e.getCause());
+            } else {
+                zzwVar2 = this.zzb.zzc;
+                zzwVar2.zza(e);
+            }
+        } catch (Exception e2) {
+            zzwVar = this.zzb.zzc;
+            zzwVar.zza(e2);
+        }
+    }
+}

decompiled/sources/com/google/android/gms/tasks/zzf.java

@@ -0,0 +1,42 @@
+package com.google.android.gms.tasks;
+
+import androidx.annotation.NonNull;
+import java.util.concurrent.Executor;
+
+/* loaded from: classes3.dex */
+final class zzf<TResult, TContinuationResult> implements OnSuccessListener<TContinuationResult>, OnFailureListener, OnCanceledListener, zzq {
+    private final Executor zza;
+    private final Continuation zzb;
+    private final zzw zzc;
+
+    public zzf(@NonNull Executor executor, @NonNull Continuation continuation, @NonNull zzw zzwVar) {
+        this.zza = executor;
+        this.zzb = continuation;
+        this.zzc = zzwVar;
+    }
+
+    @Override // com.google.android.gms.tasks.OnCanceledListener
+    public final void onCanceled() {
+        this.zzc.zzc();
+    }
+
+    @Override // com.google.android.gms.tasks.OnFailureListener
+    public final void onFailure(@NonNull Exception exc) {
+        this.zzc.zza(exc);
+    }
+
+    @Override // com.google.android.gms.tasks.OnSuccessListener
+    public final void onSuccess(TContinuationResult tcontinuationresult) {
+        this.zzc.zzb(tcontinuationresult);
+    }
+
+    @Override // com.google.android.gms.tasks.zzq
+    public final void zzc() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override // com.google.android.gms.tasks.zzq
+    public final void zzd(@NonNull Task task) {
+        this.zza.execute(new zze(this, task));
+    }
+}

decompiled/sources/com/google/android/gms/tasks/zzg.java

@@ -0,0 +1,30 @@
+package com.google.android.gms.tasks;
+
+/* loaded from: classes3.dex */
+final class zzg implements Runnable {
+    final /* synthetic */ zzh zza;
+
+    public zzg(zzh zzhVar) {
+        this.zza = zzhVar;
+    }
+
+    @Override // java.lang.Runnable
+    public final void run() {
+        Object obj;
+        OnCanceledListener onCanceledListener;
+        OnCanceledListener onCanceledListener2;
+        obj = this.zza.zzb;
+        synchronized (obj) {
+            try {
+                zzh zzhVar = this.zza;
+                onCanceledListener = zzhVar.zzc;
+                if (onCanceledListener != null) {
+                    onCanceledListener2 = zzhVar.zzc;
+                    onCanceledListener2.onCanceled();
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+}

decompiled/sources/com/google/android/gms/tasks/zzh.java

@@ -0,0 +1,39 @@
+package com.google.android.gms.tasks;
+
+import androidx.annotation.NonNull;
+import java.util.concurrent.Executor;
+
+/* loaded from: classes3.dex */
+final class zzh implements zzq {
+    private final Executor zza;
+    private final Object zzb = new Object();
+    private OnCanceledListener zzc;
+
+    public zzh(@NonNull Executor executor, @NonNull OnCanceledListener onCanceledListener) {
+        this.zza = executor;
+        this.zzc = onCanceledListener;
+    }
+
+    @Override // com.google.android.gms.tasks.zzq
+    public final void zzc() {
+        synchronized (this.zzb) {
+            this.zzc = null;
+        }
+    }
+
+    @Override // com.google.android.gms.tasks.zzq
+    public final void zzd(@NonNull Task task) {
+        if (task.isCanceled()) {
+            synchronized (this.zzb) {
+                try {
+                    if (this.zzc == null) {
+                        return;
+                    }
+                    this.zza.execute(new zzg(this));
+                } catch (Throwable th) {
+                    throw th;
+                }
+            }
+        }
+    }
+}

decompiled/sources/com/google/android/gms/tasks/zzi.java

@@ -0,0 +1,32 @@
+package com.google.android.gms.tasks;
+
+/* loaded from: classes3.dex */
+final class zzi implements Runnable {
+    final /* synthetic */ Task zza;
+    final /* synthetic */ zzj zzb;
+
+    public zzi(zzj zzjVar, Task task) {
+        this.zzb = zzjVar;
+        this.zza = task;
+    }
+
+    @Override // java.lang.Runnable
+    public final void run() {
+        Object obj;
+        OnCompleteListener onCompleteListener;
+        OnCompleteListener onCompleteListener2;
+        obj = this.zzb.zzb;
+        synchronized (obj) {
+            try {
+                zzj zzjVar = this.zzb;
+                onCompleteListener = zzjVar.zzc;
+                if (onCompleteListener != null) {
+                    onCompleteListener2 = zzjVar.zzc;
+                    onCompleteListener2.onComplete(this.zza);
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+}

decompiled/sources/com/google/android/gms/tasks/zzj.java

@@ -0,0 +1,37 @@
+package com.google.android.gms.tasks;
+
+import androidx.annotation.NonNull;
+import java.util.concurrent.Executor;
+
+/* loaded from: classes3.dex */
+final class zzj implements zzq {
+    private final Executor zza;
+    private final Object zzb = new Object();
+    private OnCompleteListener zzc;
+
+    public zzj(@NonNull Executor executor, @NonNull OnCompleteListener onCompleteListener) {
+        this.zza = executor;
+        this.zzc = onCompleteListener;
+    }
+
+    @Override // com.google.android.gms.tasks.zzq
+    public final void zzc() {
+        synchronized (this.zzb) {
+            this.zzc = null;
+        }
+    }
+
+    @Override // com.google.android.gms.tasks.zzq
+    public final void zzd(@NonNull Task task) {
+        synchronized (this.zzb) {
+            try {
+                if (this.zzc == null) {
+                    return;
+                }
+                this.zza.execute(new zzi(this, task));
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+}

decompiled/sources/com/google/android/gms/tasks/zzk.java

@@ -0,0 +1,34 @@
+package com.google.android.gms.tasks;
+
+import com.google.android.gms.common.internal.Preconditions;
+
+/* loaded from: classes3.dex */
+final class zzk implements Runnable {
+    final /* synthetic */ Task zza;
+    final /* synthetic */ zzl zzb;
+
+    public zzk(zzl zzlVar, Task task) {
+        this.zzb = zzlVar;
+        this.zza = task;
+    }
+
+    @Override // java.lang.Runnable
+    public final void run() {
+        Object obj;
+        OnFailureListener onFailureListener;
+        OnFailureListener onFailureListener2;
+        obj = this.zzb.zzb;
+        synchronized (obj) {
+            try {
+                zzl zzlVar = this.zzb;
+                onFailureListener = zzlVar.zzc;
+                if (onFailureListener != null) {
+                    onFailureListener2 = zzlVar.zzc;
+                    onFailureListener2.onFailure((Exception) Preconditions.checkNotNull(this.zza.getException()));
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+}

decompiled/sources/com/google/android/gms/tasks/zzl.java

@@ -0,0 +1,40 @@
+package com.google.android.gms.tasks;
+
+import androidx.annotation.NonNull;
+import java.util.concurrent.Executor;
+
+/* loaded from: classes3.dex */
+final class zzl implements zzq {
+    private final Executor zza;
+    private final Object zzb = new Object();
+    private OnFailureListener zzc;
+
+    public zzl(@NonNull Executor executor, @NonNull OnFailureListener onFailureListener) {
+        this.zza = executor;
+        this.zzc = onFailureListener;
+    }
+
+    @Override // com.google.android.gms.tasks.zzq
+    public final void zzc() {
+        synchronized (this.zzb) {
+            this.zzc = null;
+        }
+    }
+
+    @Override // com.google.android.gms.tasks.zzq
+    public final void zzd(@NonNull Task task) {
+        if (task.isSuccessful() || task.isCanceled()) {
+            return;
+        }
+        synchronized (this.zzb) {
+            try {
+                if (this.zzc == null) {
+                    return;
+                }
+                this.zza.execute(new zzk(this, task));
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+}

decompiled/sources/com/google/android/gms/tasks/zzm.java

@@ -0,0 +1,32 @@
+package com.google.android.gms.tasks;
+
+/* loaded from: classes3.dex */
+final class zzm implements Runnable {
+    final /* synthetic */ Task zza;
+    final /* synthetic */ zzn zzb;
+
+    public zzm(zzn zznVar, Task task) {
+        this.zzb = zznVar;
+        this.zza = task;
+    }
+
+    @Override // java.lang.Runnable
+    public final void run() {
+        Object obj;
+        OnSuccessListener onSuccessListener;
+        OnSuccessListener onSuccessListener2;
+        obj = this.zzb.zzb;
+        synchronized (obj) {
+            try {
+                zzn zznVar = this.zzb;
+                onSuccessListener = zznVar.zzc;
+                if (onSuccessListener != null) {
+                    onSuccessListener2 = zznVar.zzc;
+                    onSuccessListener2.onSuccess(this.zza.getResult());
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+}

decompiled/sources/com/google/android/gms/tasks/zzn.java

@@ -0,0 +1,39 @@
+package com.google.android.gms.tasks;
+
+import androidx.annotation.NonNull;
+import java.util.concurrent.Executor;
+
+/* loaded from: classes3.dex */
+final class zzn implements zzq {
+    private final Executor zza;
+    private final Object zzb = new Object();
+    private OnSuccessListener zzc;
+
+    public zzn(@NonNull Executor executor, @NonNull OnSuccessListener onSuccessListener) {
+        this.zza = executor;
+        this.zzc = onSuccessListener;
+    }
+
+    @Override // com.google.android.gms.tasks.zzq
+    public final void zzc() {
+        synchronized (this.zzb) {
+            this.zzc = null;
+        }
+    }
+
+    @Override // com.google.android.gms.tasks.zzq
+    public final void zzd(@NonNull Task task) {
+        if (task.isSuccessful()) {
+            synchronized (this.zzb) {
+                try {
+                    if (this.zzc == null) {
+                        return;
+                    }
+                    this.zza.execute(new zzm(this, task));
+                } catch (Throwable th) {
+                    throw th;
+                }
+            }
+        }
+    }
+}

decompiled/sources/com/google/android/gms/tasks/zzo.java

@@ -0,0 +1,43 @@
+package com.google.android.gms.tasks;
+
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.Executor;
+
+/* loaded from: classes3.dex */
+final class zzo implements Runnable {
+    final /* synthetic */ Task zza;
+    final /* synthetic */ zzp zzb;
+
+    public zzo(zzp zzpVar, Task task) {
+        this.zzb = zzpVar;
+        this.zza = task;
+    }
+
+    @Override // java.lang.Runnable
+    public final void run() {
+        SuccessContinuation successContinuation;
+        try {
+            successContinuation = this.zzb.zzb;
+            Task then = successContinuation.then(this.zza.getResult());
+            if (then == null) {
+                this.zzb.onFailure(new NullPointerException("Continuation returned null"));
+                return;
+            }
+            zzp zzpVar = this.zzb;
+            Executor executor = TaskExecutors.zza;
+            then.addOnSuccessListener(executor, zzpVar);
+            then.addOnFailureListener(executor, this.zzb);
+            then.addOnCanceledListener(executor, this.zzb);
+        } catch (RuntimeExecutionException e) {
+            if (e.getCause() instanceof Exception) {
+                this.zzb.onFailure((Exception) e.getCause());
+            } else {
+                this.zzb.onFailure(e);
+            }
+        } catch (CancellationException unused) {
+            this.zzb.onCanceled();
+        } catch (Exception e2) {
+            this.zzb.onFailure(e2);
+        }
+    }
+}

decompiled/sources/com/google/android/gms/tasks/zzp.java

@@ -0,0 +1,42 @@
+package com.google.android.gms.tasks;
+
+import androidx.annotation.NonNull;
+import java.util.concurrent.Executor;
+
+/* loaded from: classes3.dex */
+final class zzp<TResult, TContinuationResult> implements OnSuccessListener<TContinuationResult>, OnFailureListener, OnCanceledListener, zzq {
+    private final Executor zza;
+    private final SuccessContinuation zzb;
+    private final zzw zzc;
+
+    public zzp(@NonNull Executor executor, @NonNull SuccessContinuation successContinuation, @NonNull zzw zzwVar) {
+        this.zza = executor;
+        this.zzb = successContinuation;
+        this.zzc = zzwVar;
+    }
+
+    @Override // com.google.android.gms.tasks.OnCanceledListener
+    public final void onCanceled() {
+        this.zzc.zzc();
+    }
+
+    @Override // com.google.android.gms.tasks.OnFailureListener
+    public final void onFailure(@NonNull Exception exc) {
+        this.zzc.zza(exc);
+    }
+
+    @Override // com.google.android.gms.tasks.OnSuccessListener
+    public final void onSuccess(TContinuationResult tcontinuationresult) {
+        this.zzc.zzb(tcontinuationresult);
+    }
+
+    @Override // com.google.android.gms.tasks.zzq
+    public final void zzc() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override // com.google.android.gms.tasks.zzq
+    public final void zzd(@NonNull Task task) {
+        this.zza.execute(new zzo(this, task));
+    }
+}

decompiled/sources/com/google/android/gms/tasks/zzq.java

@@ -0,0 +1,10 @@
+package com.google.android.gms.tasks;
+
+import androidx.annotation.NonNull;
+
+/* loaded from: classes3.dex */
+interface zzq<TResult> {
+    void zzc();
+
+    void zzd(@NonNull Task task);
+}

decompiled/sources/com/google/android/gms/tasks/zzr.java

@@ -0,0 +1,47 @@
+package com.google.android.gms.tasks;
+
+import androidx.annotation.NonNull;
+import java.util.ArrayDeque;
+import java.util.Queue;
+
+/* loaded from: classes3.dex */
+final class zzr {
+    private final Object zza = new Object();
+    private Queue zzb;
+    private boolean zzc;
+
+    public final void zza(@NonNull zzq zzqVar) {
+        synchronized (this.zza) {
+            try {
+                if (this.zzb == null) {
+                    this.zzb = new ArrayDeque();
+                }
+                this.zzb.add(zzqVar);
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    public final void zzb(@NonNull Task task) {
+        zzq zzqVar;
+        synchronized (this.zza) {
+            if (this.zzb != null && !this.zzc) {
+                this.zzc = true;
+                while (true) {
+                    synchronized (this.zza) {
+                        try {
+                            zzqVar = (zzq) this.zzb.poll();
+                            if (zzqVar == null) {
+                                this.zzc = false;
+                                return;
+                            }
+                        } finally {
+                        }
+                    }
+                    zzqVar.zzd(task);
+                }
+            }
+        }
+    }
+}

decompiled/sources/com/google/android/gms/tasks/zzs.java

@@ -0,0 +1,17 @@
+package com.google.android.gms.tasks;
+
+/* loaded from: classes3.dex */
+final class zzs implements OnTokenCanceledListener {
+    final /* synthetic */ TaskCompletionSource zza;
+
+    public zzs(TaskCompletionSource taskCompletionSource) {
+        this.zza = taskCompletionSource;
+    }
+
+    @Override // com.google.android.gms.tasks.OnTokenCanceledListener
+    public final void onCanceled() {
+        zzw zzwVar;
+        zzwVar = this.zza.zza;
+        zzwVar.zzc();
+    }
+}

decompiled/sources/com/google/android/gms/tasks/zzt.java

@@ -0,0 +1,12 @@
+package com.google.android.gms.tasks;
+
+import androidx.annotation.NonNull;
+import java.util.concurrent.Executor;
+
+/* loaded from: classes3.dex */
+final class zzt implements Executor {
+    @Override // java.util.concurrent.Executor
+    public final void execute(@NonNull Runnable runnable) {
+        runnable.run();
+    }
+}

decompiled/sources/com/google/android/gms/tasks/zzu.java

@@ -0,0 +1,16 @@
+package com.google.android.gms.tasks;
+
+import android.os.Handler;
+import android.os.Looper;
+import androidx.annotation.NonNull;
+import java.util.concurrent.Executor;
+
+/* loaded from: classes3.dex */
+final class zzu implements Executor {
+    private final Handler zza = new com.google.android.gms.internal.tasks.zza(Looper.getMainLooper());
+
+    @Override // java.util.concurrent.Executor
+    public final void execute(@NonNull Runnable runnable) {
+        this.zza.post(runnable);
+    }
+}

decompiled/sources/com/google/android/gms/tasks/zzv.java

@@ -0,0 +1,62 @@
+package com.google.android.gms.tasks;
+
+import android.app.Activity;
+import androidx.annotation.MainThread;
+import com.google.android.gms.common.api.internal.LifecycleCallback;
+import com.google.android.gms.common.api.internal.LifecycleFragment;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+/* loaded from: classes3.dex */
+final class zzv extends LifecycleCallback {
+    private final List zza;
+
+    private zzv(LifecycleFragment lifecycleFragment) {
+        super(lifecycleFragment);
+        this.zza = new ArrayList();
+        this.mLifecycleFragment.addCallback("TaskOnStopCallback", this);
+    }
+
+    public static zzv zza(Activity activity) {
+        zzv zzvVar;
+        LifecycleFragment fragment = LifecycleCallback.getFragment(activity);
+        synchronized (fragment) {
+            try {
+                zzvVar = (zzv) fragment.getCallbackOrNull("TaskOnStopCallback", zzv.class);
+                if (zzvVar == null) {
+                    zzvVar = new zzv(fragment);
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        return zzvVar;
+    }
+
+    @Override // com.google.android.gms.common.api.internal.LifecycleCallback
+    @MainThread
+    public final void onStop() {
+        synchronized (this.zza) {
+            try {
+                Iterator it = this.zza.iterator();
+                while (it.hasNext()) {
+                    zzq zzqVar = (zzq) ((WeakReference) it.next()).get();
+                    if (zzqVar != null) {
+                        zzqVar.zzc();
+                    }
+                }
+                this.zza.clear();
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    public final void zzb(zzq zzqVar) {
+        synchronized (this.zza) {
+            this.zza.add(new WeakReference(zzqVar));
+        }
+    }
+}

decompiled/sources/com/google/android/gms/tasks/zzw.java

@@ -0,0 +1,346 @@
+package com.google.android.gms.tasks;
+
+import android.app.Activity;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.google.android.gms.common.internal.Preconditions;
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.Executor;
+
+/* loaded from: classes3.dex */
+final class zzw<TResult> extends Task<TResult> {
+    private final Object zza = new Object();
+    private final zzr zzb = new zzr();
+    private boolean zzc;
+    private volatile boolean zzd;
+
+    @Nullable
+    private Object zze;
+    private Exception zzf;
+
+    private final void zzf() {
+        Preconditions.checkState(this.zzc, "Task is not yet complete");
+    }
+
+    private final void zzg() {
+        if (this.zzd) {
+            throw new CancellationException("Task is already canceled.");
+        }
+    }
+
+    private final void zzh() {
+        if (this.zzc) {
+            throw DuplicateTaskCompletionException.of(this);
+        }
+    }
+
+    private final void zzi() {
+        synchronized (this.zza) {
+            try {
+                if (this.zzc) {
+                    this.zzb.zzb(this);
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    @Override // com.google.android.gms.tasks.Task
+    @NonNull
+    public final Task<TResult> addOnCanceledListener(@NonNull Activity activity, @NonNull OnCanceledListener onCanceledListener) {
+        zzh zzhVar = new zzh(TaskExecutors.MAIN_THREAD, onCanceledListener);
+        this.zzb.zza(zzhVar);
+        zzv.zza(activity).zzb(zzhVar);
+        zzi();
+        return this;
+    }
+
+    @Override // com.google.android.gms.tasks.Task
+    @NonNull
+    public final Task<TResult> addOnCompleteListener(@NonNull Activity activity, @NonNull OnCompleteListener<TResult> onCompleteListener) {
+        zzj zzjVar = new zzj(TaskExecutors.MAIN_THREAD, onCompleteListener);
+        this.zzb.zza(zzjVar);
+        zzv.zza(activity).zzb(zzjVar);
+        zzi();
+        return this;
+    }
+
+    @Override // com.google.android.gms.tasks.Task
+    @NonNull
+    public final Task<TResult> addOnFailureListener(@NonNull Activity activity, @NonNull OnFailureListener onFailureListener) {
+        zzl zzlVar = new zzl(TaskExecutors.MAIN_THREAD, onFailureListener);
+        this.zzb.zza(zzlVar);
+        zzv.zza(activity).zzb(zzlVar);
+        zzi();
+        return this;
+    }
+
+    @Override // com.google.android.gms.tasks.Task
+    @NonNull
+    public final Task<TResult> addOnSuccessListener(@NonNull Activity activity, @NonNull OnSuccessListener<? super TResult> onSuccessListener) {
+        zzn zznVar = new zzn(TaskExecutors.MAIN_THREAD, onSuccessListener);
+        this.zzb.zza(zznVar);
+        zzv.zza(activity).zzb(zznVar);
+        zzi();
+        return this;
+    }
+
+    @Override // com.google.android.gms.tasks.Task
+    @NonNull
+    public final <TContinuationResult> Task<TContinuationResult> continueWith(@NonNull Continuation<TResult, TContinuationResult> continuation) {
+        return continueWith(TaskExecutors.MAIN_THREAD, continuation);
+    }
+
+    @Override // com.google.android.gms.tasks.Task
+    @NonNull
+    public final <TContinuationResult> Task<TContinuationResult> continueWithTask(@NonNull Continuation<TResult, Task<TContinuationResult>> continuation) {
+        return continueWithTask(TaskExecutors.MAIN_THREAD, continuation);
+    }
+
+    @Override // com.google.android.gms.tasks.Task
+    @Nullable
+    public final Exception getException() {
+        Exception exc;
+        synchronized (this.zza) {
+            exc = this.zzf;
+        }
+        return exc;
+    }
+
+    @Override // com.google.android.gms.tasks.Task
+    public final TResult getResult() {
+        TResult tresult;
+        synchronized (this.zza) {
+            try {
+                zzf();
+                zzg();
+                Exception exc = this.zzf;
+                if (exc != null) {
+                    throw new RuntimeExecutionException(exc);
+                }
+                tresult = (TResult) this.zze;
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        return tresult;
+    }
+
+    @Override // com.google.android.gms.tasks.Task
+    public final boolean isCanceled() {
+        return this.zzd;
+    }
+
+    @Override // com.google.android.gms.tasks.Task
+    public final boolean isComplete() {
+        boolean z;
+        synchronized (this.zza) {
+            z = this.zzc;
+        }
+        return z;
+    }
+
+    @Override // com.google.android.gms.tasks.Task
+    public final boolean isSuccessful() {
+        boolean z;
+        synchronized (this.zza) {
+            try {
+                z = false;
+                if (this.zzc && !this.zzd && this.zzf == null) {
+                    z = true;
+                }
+            } finally {
+            }
+        }
+        return z;
+    }
+
+    @Override // com.google.android.gms.tasks.Task
+    @NonNull
+    public final <TContinuationResult> Task<TContinuationResult> onSuccessTask(@NonNull SuccessContinuation<TResult, TContinuationResult> successContinuation) {
+        Executor executor = TaskExecutors.MAIN_THREAD;
+        zzw zzwVar = new zzw();
+        this.zzb.zza(new zzp(executor, successContinuation, zzwVar));
+        zzi();
+        return zzwVar;
+    }
+
+    public final void zza(@NonNull Exception exc) {
+        Preconditions.checkNotNull(exc, "Exception must not be null");
+        synchronized (this.zza) {
+            zzh();
+            this.zzc = true;
+            this.zzf = exc;
+        }
+        this.zzb.zzb(this);
+    }
+
+    public final void zzb(@Nullable Object obj) {
+        synchronized (this.zza) {
+            zzh();
+            this.zzc = true;
+            this.zze = obj;
+        }
+        this.zzb.zzb(this);
+    }
+
+    public final boolean zzc() {
+        synchronized (this.zza) {
+            try {
+                if (this.zzc) {
+                    return false;
+                }
+                this.zzc = true;
+                this.zzd = true;
+                this.zzb.zzb(this);
+                return true;
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    public final boolean zzd(@NonNull Exception exc) {
+        Preconditions.checkNotNull(exc, "Exception must not be null");
+        synchronized (this.zza) {
+            try {
+                if (this.zzc) {
+                    return false;
+                }
+                this.zzc = true;
+                this.zzf = exc;
+                this.zzb.zzb(this);
+                return true;
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    public final boolean zze(@Nullable Object obj) {
+        synchronized (this.zza) {
+            try {
+                if (this.zzc) {
+                    return false;
+                }
+                this.zzc = true;
+                this.zze = obj;
+                this.zzb.zzb(this);
+                return true;
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    @Override // com.google.android.gms.tasks.Task
+    @NonNull
+    public final <TContinuationResult> Task<TContinuationResult> continueWith(@NonNull Executor executor, @NonNull Continuation<TResult, TContinuationResult> continuation) {
+        zzw zzwVar = new zzw();
+        this.zzb.zza(new zzd(executor, continuation, zzwVar));
+        zzi();
+        return zzwVar;
+    }
+
+    @Override // com.google.android.gms.tasks.Task
+    @NonNull
+    public final <TContinuationResult> Task<TContinuationResult> continueWithTask(@NonNull Executor executor, @NonNull Continuation<TResult, Task<TContinuationResult>> continuation) {
+        zzw zzwVar = new zzw();
+        this.zzb.zza(new zzf(executor, continuation, zzwVar));
+        zzi();
+        return zzwVar;
+    }
+
+    @Override // com.google.android.gms.tasks.Task
+    @NonNull
+    public final Task<TResult> addOnCanceledListener(@NonNull OnCanceledListener onCanceledListener) {
+        addOnCanceledListener(TaskExecutors.MAIN_THREAD, onCanceledListener);
+        return this;
+    }
+
+    @Override // com.google.android.gms.tasks.Task
+    @NonNull
+    public final Task<TResult> addOnCompleteListener(@NonNull OnCompleteListener<TResult> onCompleteListener) {
+        this.zzb.zza(new zzj(TaskExecutors.MAIN_THREAD, onCompleteListener));
+        zzi();
+        return this;
+    }
+
+    @Override // com.google.android.gms.tasks.Task
+    @NonNull
+    public final Task<TResult> addOnFailureListener(@NonNull OnFailureListener onFailureListener) {
+        addOnFailureListener(TaskExecutors.MAIN_THREAD, onFailureListener);
+        return this;
+    }
+
+    @Override // com.google.android.gms.tasks.Task
+    @NonNull
+    public final Task<TResult> addOnSuccessListener(@NonNull OnSuccessListener<? super TResult> onSuccessListener) {
+        addOnSuccessListener(TaskExecutors.MAIN_THREAD, onSuccessListener);
+        return this;
+    }
+
+    @Override // com.google.android.gms.tasks.Task
+    @NonNull
+    public final <TContinuationResult> Task<TContinuationResult> onSuccessTask(Executor executor, SuccessContinuation<TResult, TContinuationResult> successContinuation) {
+        zzw zzwVar = new zzw();
+        this.zzb.zza(new zzp(executor, successContinuation, zzwVar));
+        zzi();
+        return zzwVar;
+    }
+
+    @Override // com.google.android.gms.tasks.Task
+    @NonNull
+    public final Task<TResult> addOnCanceledListener(@NonNull Executor executor, @NonNull OnCanceledListener onCanceledListener) {
+        this.zzb.zza(new zzh(executor, onCanceledListener));
+        zzi();
+        return this;
+    }
+
+    @Override // com.google.android.gms.tasks.Task
+    @NonNull
+    public final Task<TResult> addOnFailureListener(@NonNull Executor executor, @NonNull OnFailureListener onFailureListener) {
+        this.zzb.zza(new zzl(executor, onFailureListener));
+        zzi();
+        return this;
+    }
+
+    @Override // com.google.android.gms.tasks.Task
+    @NonNull
+    public final Task<TResult> addOnSuccessListener(@NonNull Executor executor, @NonNull OnSuccessListener<? super TResult> onSuccessListener) {
+        this.zzb.zza(new zzn(executor, onSuccessListener));
+        zzi();
+        return this;
+    }
+
+    @Override // com.google.android.gms.tasks.Task
+    public final <X extends Throwable> TResult getResult(@NonNull Class<X> cls) throws Throwable {
+        TResult tresult;
+        synchronized (this.zza) {
+            try {
+                zzf();
+                zzg();
+                if (cls.isInstance(this.zzf)) {
+                    throw cls.cast(this.zzf);
+                }
+                Exception exc = this.zzf;
+                if (exc != null) {
+                    throw new RuntimeExecutionException(exc);
+                }
+                tresult = (TResult) this.zze;
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        return tresult;
+    }
+
+    @Override // com.google.android.gms.tasks.Task
+    @NonNull
+    public final Task<TResult> addOnCompleteListener(@NonNull Executor executor, @NonNull OnCompleteListener<TResult> onCompleteListener) {
+        this.zzb.zza(new zzj(executor, onCompleteListener));
+        zzi();
+        return this;
+    }
+}

decompiled/sources/com/google/android/gms/tasks/zzz.java

@@ -0,0 +1,25 @@
+package com.google.android.gms.tasks;
+
+import java.util.concurrent.Callable;
+
+/* loaded from: classes3.dex */
+final class zzz implements Runnable {
+    final /* synthetic */ zzw zza;
+    final /* synthetic */ Callable zzb;
+
+    public zzz(zzw zzwVar, Callable callable) {
+        this.zza = zzwVar;
+        this.zzb = callable;
+    }
+
+    @Override // java.lang.Runnable
+    public final void run() {
+        try {
+            this.zza.zzb(this.zzb.call());
+        } catch (Exception e) {
+            this.zza.zza(e);
+        } catch (Throwable th) {
+            this.zza.zza(new RuntimeException(th));
+        }
+    }
+}