Primer paso de la investigacion. Se aportan el .apk, las carpetas con el apk extraido y el apk descompilado. El archivo API_DOCUMENTATION.md es un archivo donde se anotaran los descubrimientos del funcionamiento de la API, y los .py son scripts para probar la funcionalidad de la API con los métodos que vayamos encontrando. Finalmente, los archivos .js son scripts de Frida para extraer informacion de la APP durante la ejecucion.

apk_decompiled/sources/h3/a.java

@@ -0,0 +1,32 @@
+package h3;
+
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes3.dex */
+public abstract class a {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final String f6778a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final boolean f6779b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public c f6780c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public long f6781d;
+
+    public a(String name, boolean z3) {
+        Intrinsics.checkNotNullParameter(name, "name");
+        this.f6778a = name;
+        this.f6779b = z3;
+        this.f6781d = -1L;
+    }
+
+    public abstract long a();
+
+    public final String toString() {
+        return this.f6778a;
+    }
+}

apk_decompiled/sources/h3/b.java

@@ -0,0 +1,106 @@
+package h3;
+
+import i3.m;
+import java.io.IOException;
+import java.net.Socket;
+import java.util.Iterator;
+import kotlin.Unit;
+import kotlin.jvm.internal.Intrinsics;
+import l3.l;
+import l3.q;
+
+/* loaded from: classes3.dex */
+public final class b extends a {
+
+    /* renamed from: e, reason: collision with root package name */
+    public final /* synthetic */ int f6782e;
+
+    /* renamed from: f, reason: collision with root package name */
+    public final /* synthetic */ Object f6783f;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public /* synthetic */ b(Object obj, int i, String str) {
+        super(str, true);
+        this.f6782e = i;
+        this.f6783f = obj;
+    }
+
+    @Override // h3.a
+    public final long a() {
+        int i = 0;
+        switch (this.f6782e) {
+            case 0:
+                ((l) this.f6783f).invoke();
+                return -1L;
+            case 1:
+                m mVar = (m) this.f6783f;
+                long nanoTime = System.nanoTime();
+                Iterator it = mVar.f6889d.iterator();
+                long j4 = Long.MIN_VALUE;
+                i3.l lVar = null;
+                int i4 = 0;
+                while (it.hasNext()) {
+                    i3.l connection = (i3.l) it.next();
+                    Intrinsics.checkNotNullExpressionValue(connection, "connection");
+                    synchronized (connection) {
+                        if (mVar.b(connection, nanoTime) > 0) {
+                            i4++;
+                        } else {
+                            i++;
+                            long j5 = nanoTime - connection.f6885q;
+                            if (j5 > j4) {
+                                lVar = connection;
+                                j4 = j5;
+                            }
+                            Unit unit = Unit.INSTANCE;
+                        }
+                    }
+                }
+                long j6 = mVar.f6886a;
+                if (j4 < j6 && i <= 5) {
+                    if (i > 0) {
+                        return j6 - j4;
+                    }
+                    if (i4 > 0) {
+                        return j6;
+                    }
+                    return -1L;
+                }
+                Intrinsics.checkNotNull(lVar);
+                synchronized (lVar) {
+                    if (!lVar.p.isEmpty()) {
+                        return 0L;
+                    }
+                    if (lVar.f6885q + j4 != nanoTime) {
+                        return 0L;
+                    }
+                    lVar.f6879j = true;
+                    mVar.f6889d.remove(lVar);
+                    Socket socket = lVar.f6875d;
+                    Intrinsics.checkNotNull(socket);
+                    f3.c.d(socket);
+                    if (!mVar.f6889d.isEmpty()) {
+                        return 0L;
+                    }
+                    mVar.f6887b.a();
+                    return 0L;
+                }
+            default:
+                q qVar = (q) this.f6783f;
+                qVar.getClass();
+                try {
+                    qVar.f7448w.Y(2, 0, false);
+                } catch (IOException e4) {
+                    qVar.e(e4);
+                }
+                return -1L;
+        }
+    }
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public b(m mVar, String str) {
+        super(str, true);
+        this.f6782e = 1;
+        this.f6783f = mVar;
+    }
+}

apk_decompiled/sources/h3/c.java

@@ -0,0 +1,169 @@
+package h3;
+
+import f0.C0338b;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.concurrent.RejectedExecutionException;
+import java.util.logging.Level;
+import kotlin.Unit;
+import kotlin.jvm.internal.Intrinsics;
+
+/* loaded from: classes3.dex */
+public final class c {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final e f6784a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final String f6785b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public boolean f6786c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public a f6787d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public final ArrayList f6788e;
+
+    /* renamed from: f, reason: collision with root package name */
+    public boolean f6789f;
+
+    public c(e taskRunner, String name) {
+        Intrinsics.checkNotNullParameter(taskRunner, "taskRunner");
+        Intrinsics.checkNotNullParameter(name, "name");
+        this.f6784a = taskRunner;
+        this.f6785b = name;
+        this.f6788e = new ArrayList();
+    }
+
+    public final void a() {
+        byte[] bArr = f3.c.f6469a;
+        synchronized (this.f6784a) {
+            try {
+                if (b()) {
+                    this.f6784a.d(this);
+                }
+                Unit unit = Unit.INSTANCE;
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    public final boolean b() {
+        a aVar = this.f6787d;
+        if (aVar != null) {
+            Intrinsics.checkNotNull(aVar);
+            if (aVar.f6779b) {
+                this.f6789f = true;
+            }
+        }
+        ArrayList arrayList = this.f6788e;
+        boolean z3 = false;
+        for (int size = arrayList.size() - 1; -1 < size; size--) {
+            if (((a) arrayList.get(size)).f6779b) {
+                a aVar2 = (a) arrayList.get(size);
+                C0338b c0338b = e.h;
+                if (e.f6792j.isLoggable(Level.FINE)) {
+                    m3.d.b(aVar2, this, "canceled");
+                }
+                arrayList.remove(size);
+                z3 = true;
+            }
+        }
+        return z3;
+    }
+
+    public final void c(a task, long j4) {
+        Intrinsics.checkNotNullParameter(task, "task");
+        synchronized (this.f6784a) {
+            if (!this.f6786c) {
+                if (d(task, j4, false)) {
+                    this.f6784a.d(this);
+                }
+                Unit unit = Unit.INSTANCE;
+            } else if (task.f6779b) {
+                C0338b c0338b = e.h;
+                if (e.f6792j.isLoggable(Level.FINE)) {
+                    m3.d.b(task, this, "schedule canceled (queue is shutdown)");
+                }
+            } else {
+                C0338b c0338b2 = e.h;
+                if (e.f6792j.isLoggable(Level.FINE)) {
+                    m3.d.b(task, this, "schedule failed (queue is shutdown)");
+                }
+                throw new RejectedExecutionException();
+            }
+        }
+    }
+
+    public final boolean d(a task, long j4, boolean z3) {
+        Intrinsics.checkNotNullParameter(task, "task");
+        task.getClass();
+        Intrinsics.checkNotNullParameter(this, "queue");
+        c cVar = task.f6780c;
+        if (cVar != this) {
+            if (cVar != null) {
+                throw new IllegalStateException("task is in multiple queues");
+            }
+            task.f6780c = this;
+        }
+        d dVar = this.f6784a.f6793a;
+        long nanoTime = System.nanoTime();
+        long j5 = nanoTime + j4;
+        ArrayList arrayList = this.f6788e;
+        int indexOf = arrayList.indexOf(task);
+        if (indexOf != -1) {
+            if (task.f6781d <= j5) {
+                C0338b c0338b = e.h;
+                if (e.f6792j.isLoggable(Level.FINE)) {
+                    m3.d.b(task, this, "already scheduled");
+                    return false;
+                }
+            }
+            arrayList.remove(indexOf);
+        }
+        task.f6781d = j5;
+        C0338b c0338b2 = e.h;
+        if (e.f6792j.isLoggable(Level.FINE)) {
+            m3.d.b(task, this, z3 ? "run again after ".concat(m3.d.q(j5 - nanoTime)) : "scheduled after ".concat(m3.d.q(j5 - nanoTime)));
+        }
+        Iterator it = arrayList.iterator();
+        int i = 0;
+        while (true) {
+            if (!it.hasNext()) {
+                i = -1;
+                break;
+            }
+            if (((a) it.next()).f6781d - nanoTime > j4) {
+                break;
+            }
+            i++;
+        }
+        if (i == -1) {
+            i = arrayList.size();
+        }
+        arrayList.add(i, task);
+        return i == 0;
+    }
+
+    public final void e() {
+        byte[] bArr = f3.c.f6469a;
+        synchronized (this.f6784a) {
+            try {
+                this.f6786c = true;
+                if (b()) {
+                    this.f6784a.d(this);
+                }
+                Unit unit = Unit.INSTANCE;
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+    }
+
+    public final String toString() {
+        return this.f6785b;
+    }
+}

apk_decompiled/sources/h3/d.java

@@ -0,0 +1,319 @@
+package h3;
+
+import G2.f;
+import I2.k;
+import O.D0;
+import O.InterfaceC0080v;
+import O.X;
+import P.t;
+import a.AbstractC0106b;
+import android.os.SystemClock;
+import android.util.Log;
+import android.view.MenuItem;
+import android.view.View;
+import androidx.appcompat.widget.ActionMenuView;
+import androidx.appcompat.widget.Toolbar;
+import androidx.profileinstaller.ProfileInstallReceiver;
+import com.adif.elcanomovil.R;
+import com.adif.elcanomovil.main.BottomNavFragment;
+import com.google.android.gms.maps.model.BitmapDescriptorFactory;
+import com.google.android.material.behavior.SwipeDismissBehavior;
+import com.google.android.material.bottomnavigation.BottomNavigationView;
+import com.google.android.material.bottomsheet.BottomSheetBehavior;
+import g.M;
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.LinkedHashSet;
+import java.util.WeakHashMap;
+import java.util.concurrent.SynchronousQueue;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+import kotlin.jvm.internal.Intrinsics;
+import l.C0428f;
+import l.InterfaceC0433k;
+import l.RunnableC0427e;
+import l.SubMenuC0422E;
+import l.ViewOnKeyListenerC0429g;
+import l.m;
+import l.o;
+import l.x;
+import m.C0472l;
+import m.InterfaceC0478o;
+import m.InterfaceC0498y0;
+import m.O0;
+import m.S0;
+import o0.AbstractC0544v;
+import o0.C0525b;
+import o0.E;
+import o0.H;
+import o0.K;
+import p2.InterfaceC0552a;
+import s0.InterfaceC0584c;
+import z2.InterfaceC0679i;
+
+/* loaded from: classes3.dex */
+public final class d implements InterfaceC0498y0, t, x, InterfaceC0433k, InterfaceC0080v, InterfaceC0552a, InterfaceC0584c {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final /* synthetic */ int f6790a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final Object f6791b;
+
+    public /* synthetic */ d(Object obj, int i) {
+        this.f6790a = i;
+        this.f6791b = obj;
+    }
+
+    private final void j(m mVar) {
+    }
+
+    @Override // s0.InterfaceC0584c
+    public void a(int i, Serializable serializable) {
+        String str;
+        switch (i) {
+            case 1:
+                str = "RESULT_INSTALL_SUCCESS";
+                break;
+            case 2:
+                str = "RESULT_ALREADY_INSTALLED";
+                break;
+            case 3:
+                str = "RESULT_UNSUPPORTED_ART_VERSION";
+                break;
+            case 4:
+                str = "RESULT_NOT_WRITABLE";
+                break;
+            case 5:
+                str = "RESULT_DESIRED_FORMAT_UNSUPPORTED";
+                break;
+            case 6:
+                str = "RESULT_BASELINE_PROFILE_NOT_FOUND";
+                break;
+            case 7:
+                str = "RESULT_IO_EXCEPTION";
+                break;
+            case 8:
+                str = "RESULT_PARSE_EXCEPTION";
+                break;
+            case 9:
+            default:
+                str = "";
+                break;
+            case 10:
+                str = "RESULT_INSTALL_SKIP_FILE_SUCCESS";
+                break;
+            case 11:
+                str = "RESULT_DELETE_SKIP_FILE_SUCCESS";
+                break;
+        }
+        if (i == 6 || i == 7 || i == 8) {
+            Log.e("ProfileInstaller", str, (Throwable) serializable);
+        } else {
+            Log.d("ProfileInstaller", str);
+        }
+        ((ProfileInstallReceiver) this.f6791b).setResultCode(i);
+    }
+
+    @Override // l.x
+    public void b(m mVar, boolean z3) {
+        if (mVar instanceof SubMenuC0422E) {
+            ((SubMenuC0422E) mVar).f7179z.k().c(false);
+        }
+        x xVar = ((C0472l) this.f6791b).f7680e;
+        if (xVar != null) {
+            xVar.b(mVar, z3);
+        }
+    }
+
+    @Override // l.InterfaceC0433k
+    public boolean c(m mVar, MenuItem item) {
+        boolean onMenuItemSelected;
+        int i;
+        int i4;
+        int i5;
+        int i6;
+        int i7;
+        boolean z3;
+        Object obj = this.f6791b;
+        switch (this.f6790a) {
+            case 6:
+                InterfaceC0478o interfaceC0478o = ((ActionMenuView) obj).f2412A;
+                if (interfaceC0478o == null) {
+                    return false;
+                }
+                Toolbar toolbar = ((O0) interfaceC0478o).f7602a;
+                if (toolbar.f2467G.a(item)) {
+                    onMenuItemSelected = true;
+                } else {
+                    S0 s02 = toolbar.f2469I;
+                    onMenuItemSelected = s02 != null ? ((M) s02).f6555a.f6557b.f6671a.onMenuItemSelected(0, item) : false;
+                }
+                return onMenuItemSelected;
+            default:
+                BottomNavigationView bottomNavigationView = (BottomNavigationView) obj;
+                if (bottomNavigationView.f9093f == null || item.getItemId() != bottomNavigationView.getSelectedItemId()) {
+                    InterfaceC0679i interfaceC0679i = bottomNavigationView.f9092e;
+                    if (interfaceC0679i == null) {
+                        return false;
+                    }
+                    AbstractC0544v navController = (AbstractC0544v) ((k) interfaceC0679i).f823b;
+                    Intrinsics.checkNotNullParameter(navController, "$navController");
+                    Intrinsics.checkNotNullParameter(item, "item");
+                    Intrinsics.checkNotNullParameter(item, "item");
+                    Intrinsics.checkNotNullParameter(navController, "navController");
+                    E g4 = navController.g();
+                    Intrinsics.checkNotNull(g4);
+                    H h = g4.f7921b;
+                    Intrinsics.checkNotNull(h);
+                    if (h.j(item.getItemId(), true) instanceof C0525b) {
+                        i = R.anim.nav_default_enter_anim;
+                        i4 = R.anim.nav_default_exit_anim;
+                        i5 = R.anim.nav_default_pop_enter_anim;
+                        i6 = R.anim.nav_default_pop_exit_anim;
+                    } else {
+                        i = R.animator.nav_default_enter_anim;
+                        i4 = R.animator.nav_default_exit_anim;
+                        i5 = R.animator.nav_default_pop_enter_anim;
+                        i6 = R.animator.nav_default_pop_exit_anim;
+                    }
+                    int i8 = i;
+                    int i9 = i4;
+                    int i10 = i5;
+                    int i11 = i6;
+                    if ((item.getOrder() & 196608) == 0) {
+                        int i12 = H.f7930n;
+                        i7 = AbstractC0106b.h(navController.i()).h;
+                        z3 = true;
+                    } else {
+                        i7 = -1;
+                        z3 = false;
+                    }
+                    try {
+                        navController.m(item.getItemId(), null, new K(true, true, i7, false, z3, i8, i9, i10, i11));
+                        E g5 = navController.g();
+                        if (g5 != null) {
+                            if (AbstractC0106b.u(g5, item.getItemId())) {
+                                return false;
+                            }
+                        }
+                    } catch (IllegalArgumentException unused) {
+                    }
+                } else {
+                    BottomNavFragment.f((BottomNavFragment) ((k) bottomNavigationView.f9093f).f823b, item);
+                }
+                return true;
+        }
+    }
+
+    @Override // P.t
+    public boolean d(View view) {
+        SwipeDismissBehavior swipeDismissBehavior = (SwipeDismissBehavior) this.f6791b;
+        if (!swipeDismissBehavior.v(view)) {
+            return false;
+        }
+        WeakHashMap weakHashMap = X.f1226a;
+        boolean z3 = view.getLayoutDirection() == 1;
+        int i = swipeDismissBehavior.f5534e;
+        view.offsetLeftAndRight((!(i == 0 && z3) && (i != 1 || z3)) ? view.getWidth() : -view.getWidth());
+        view.setAlpha(BitmapDescriptorFactory.HUE_RED);
+        f fVar = swipeDismissBehavior.f5531b;
+        if (fVar != null) {
+            fVar.a(view);
+        }
+        return true;
+    }
+
+    @Override // m.InterfaceC0498y0
+    public void e(m mVar, o oVar) {
+        ((ViewOnKeyListenerC0429g) this.f6791b).f7208f.removeCallbacksAndMessages(mVar);
+    }
+
+    @Override // l.x
+    public boolean f(m mVar) {
+        C0472l c0472l = (C0472l) this.f6791b;
+        if (mVar == c0472l.f7678c) {
+            return false;
+        }
+        c0472l.f7697y = ((SubMenuC0422E) mVar).f7178A.f7268a;
+        x xVar = c0472l.f7680e;
+        if (xVar != null) {
+            return xVar.f(mVar);
+        }
+        return false;
+    }
+
+    @Override // O.InterfaceC0080v
+    public D0 g(View view, D0 d02) {
+        o2.e eVar = (o2.e) this.f6791b;
+        o2.d dVar = eVar.f8097m;
+        if (dVar != null) {
+            eVar.f8092f.f5558W.remove(dVar);
+        }
+        o2.d dVar2 = new o2.d(eVar.i, d02);
+        eVar.f8097m = dVar2;
+        dVar2.b(eVar.getWindow());
+        BottomSheetBehavior bottomSheetBehavior = eVar.f8092f;
+        o2.d dVar3 = eVar.f8097m;
+        ArrayList arrayList = bottomSheetBehavior.f5558W;
+        if (!arrayList.contains(dVar3)) {
+            arrayList.add(dVar3);
+        }
+        return d02;
+    }
+
+    @Override // s0.InterfaceC0584c
+    public void h() {
+        Log.d("ProfileInstaller", "DIAGNOSTIC_PROFILE_IS_COMPRESSED");
+    }
+
+    @Override // l.InterfaceC0433k
+    public void i(m mVar) {
+        switch (this.f6790a) {
+            case 6:
+                InterfaceC0433k interfaceC0433k = ((ActionMenuView) this.f6791b).f2418v;
+                if (interfaceC0433k != null) {
+                    interfaceC0433k.i(mVar);
+                    return;
+                }
+                return;
+            default:
+                return;
+        }
+    }
+
+    @Override // m.InterfaceC0498y0
+    public void m(m mVar, o oVar) {
+        ViewOnKeyListenerC0429g viewOnKeyListenerC0429g = (ViewOnKeyListenerC0429g) this.f6791b;
+        viewOnKeyListenerC0429g.f7208f.removeCallbacksAndMessages(null);
+        ArrayList arrayList = viewOnKeyListenerC0429g.h;
+        int size = arrayList.size();
+        int i = 0;
+        while (true) {
+            if (i >= size) {
+                i = -1;
+                break;
+            } else if (mVar == ((C0428f) arrayList.get(i)).f7202b) {
+                break;
+            } else {
+                i++;
+            }
+        }
+        if (i == -1) {
+            return;
+        }
+        int i4 = i + 1;
+        viewOnKeyListenerC0429g.f7208f.postAtTime(new RunnableC0427e(this, i4 < arrayList.size() ? (C0428f) arrayList.get(i4) : null, oVar, mVar), mVar, SystemClock.uptimeMillis() + 200);
+    }
+
+    public d() {
+        this.f6790a = 1;
+        this.f6791b = new LinkedHashSet();
+    }
+
+    public d(f3.b threadFactory) {
+        this.f6790a = 0;
+        Intrinsics.checkNotNullParameter(threadFactory, "threadFactory");
+        this.f6791b = new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue(), threadFactory);
+    }
+}

apk_decompiled/sources/h3/e.java

@@ -0,0 +1,227 @@
+package h3;
+
+import f0.C0338b;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.logging.Logger;
+import kotlin.Unit;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.LongCompanionObject;
+
+/* loaded from: classes3.dex */
+public final class e {
+    public static final C0338b h = new C0338b(5);
+    public static final e i;
+
+    /* renamed from: j, reason: collision with root package name */
+    public static final Logger f6792j;
+
+    /* renamed from: a, reason: collision with root package name */
+    public final d f6793a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public int f6794b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public boolean f6795c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public long f6796d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public final ArrayList f6797e;
+
+    /* renamed from: f, reason: collision with root package name */
+    public final ArrayList f6798f;
+
+    /* renamed from: g, reason: collision with root package name */
+    public final F0.c f6799g;
+
+    static {
+        String name = f3.c.f6475g + " TaskRunner";
+        Intrinsics.checkNotNullParameter(name, "name");
+        i = new e(new d(new f3.b(name, true)));
+        Logger logger = Logger.getLogger(e.class.getName());
+        Intrinsics.checkNotNullExpressionValue(logger, "getLogger(TaskRunner::class.java.name)");
+        f6792j = logger;
+    }
+
+    public e(d backend) {
+        Intrinsics.checkNotNullParameter(backend, "backend");
+        this.f6793a = backend;
+        this.f6794b = 10000;
+        this.f6797e = new ArrayList();
+        this.f6798f = new ArrayList();
+        this.f6799g = new F0.c(this, 8);
+    }
+
+    public static final void a(e eVar, a aVar) {
+        eVar.getClass();
+        byte[] bArr = f3.c.f6469a;
+        Thread currentThread = Thread.currentThread();
+        String name = currentThread.getName();
+        currentThread.setName(aVar.f6778a);
+        try {
+            long a2 = aVar.a();
+            synchronized (eVar) {
+                eVar.b(aVar, a2);
+                Unit unit = Unit.INSTANCE;
+            }
+            currentThread.setName(name);
+        } catch (Throwable th) {
+            synchronized (eVar) {
+                eVar.b(aVar, -1L);
+                Unit unit2 = Unit.INSTANCE;
+                currentThread.setName(name);
+                throw th;
+            }
+        }
+    }
+
+    public final void b(a aVar, long j4) {
+        byte[] bArr = f3.c.f6469a;
+        c cVar = aVar.f6780c;
+        Intrinsics.checkNotNull(cVar);
+        if (cVar.f6787d != aVar) {
+            throw new IllegalStateException("Check failed.");
+        }
+        boolean z3 = cVar.f6789f;
+        cVar.f6789f = false;
+        cVar.f6787d = null;
+        this.f6797e.remove(cVar);
+        if (j4 != -1 && !z3 && !cVar.f6786c) {
+            cVar.d(aVar, j4, true);
+        }
+        if (cVar.f6788e.isEmpty()) {
+            return;
+        }
+        this.f6798f.add(cVar);
+    }
+
+    public final a c() {
+        long j4;
+        a aVar;
+        boolean z3;
+        byte[] bArr = f3.c.f6469a;
+        while (true) {
+            ArrayList arrayList = this.f6798f;
+            if (arrayList.isEmpty()) {
+                return null;
+            }
+            d dVar = this.f6793a;
+            long nanoTime = System.nanoTime();
+            Iterator it = arrayList.iterator();
+            long j5 = LongCompanionObject.MAX_VALUE;
+            a aVar2 = null;
+            while (true) {
+                if (!it.hasNext()) {
+                    j4 = nanoTime;
+                    aVar = null;
+                    z3 = false;
+                    break;
+                }
+                a aVar3 = (a) ((c) it.next()).f6788e.get(0);
+                j4 = nanoTime;
+                aVar = null;
+                long max = Math.max(0L, aVar3.f6781d - j4);
+                if (max > 0) {
+                    j5 = Math.min(max, j5);
+                } else {
+                    if (aVar2 != null) {
+                        z3 = true;
+                        break;
+                    }
+                    aVar2 = aVar3;
+                }
+                nanoTime = j4;
+            }
+            ArrayList arrayList2 = this.f6797e;
+            if (aVar2 != null) {
+                byte[] bArr2 = f3.c.f6469a;
+                aVar2.f6781d = -1L;
+                c cVar = aVar2.f6780c;
+                Intrinsics.checkNotNull(cVar);
+                cVar.f6788e.remove(aVar2);
+                arrayList.remove(cVar);
+                cVar.f6787d = aVar2;
+                arrayList2.add(cVar);
+                if (z3 || (!this.f6795c && !arrayList.isEmpty())) {
+                    F0.c runnable = this.f6799g;
+                    Intrinsics.checkNotNullParameter(runnable, "runnable");
+                    ((ThreadPoolExecutor) dVar.f6791b).execute(runnable);
+                }
+                return aVar2;
+            }
+            if (this.f6795c) {
+                if (j5 >= this.f6796d - j4) {
+                    return aVar;
+                }
+                Intrinsics.checkNotNullParameter(this, "taskRunner");
+                notify();
+                return aVar;
+            }
+            this.f6795c = true;
+            this.f6796d = j4 + j5;
+            try {
+                try {
+                    Intrinsics.checkNotNullParameter(this, "taskRunner");
+                    long j6 = j5 / 1000000;
+                    long j7 = j5 - (1000000 * j6);
+                    if (j6 > 0 || j5 > 0) {
+                        wait(j6, (int) j7);
+                    }
+                } catch (InterruptedException unused) {
+                    for (int size = arrayList2.size() - 1; -1 < size; size--) {
+                        ((c) arrayList2.get(size)).b();
+                    }
+                    for (int size2 = arrayList.size() - 1; -1 < size2; size2--) {
+                        c cVar2 = (c) arrayList.get(size2);
+                        cVar2.b();
+                        if (cVar2.f6788e.isEmpty()) {
+                            arrayList.remove(size2);
+                        }
+                    }
+                }
+            } finally {
+                this.f6795c = false;
+            }
+        }
+    }
+
+    public final void d(c taskQueue) {
+        Intrinsics.checkNotNullParameter(taskQueue, "taskQueue");
+        byte[] bArr = f3.c.f6469a;
+        if (taskQueue.f6787d == null) {
+            boolean isEmpty = taskQueue.f6788e.isEmpty();
+            ArrayList arrayList = this.f6798f;
+            if (isEmpty) {
+                arrayList.remove(taskQueue);
+            } else {
+                Intrinsics.checkNotNullParameter(arrayList, "<this>");
+                if (!arrayList.contains(taskQueue)) {
+                    arrayList.add(taskQueue);
+                }
+            }
+        }
+        boolean z3 = this.f6795c;
+        d dVar = this.f6793a;
+        if (z3) {
+            Intrinsics.checkNotNullParameter(this, "taskRunner");
+            notify();
+        } else {
+            F0.c runnable = this.f6799g;
+            Intrinsics.checkNotNullParameter(runnable, "runnable");
+            ((ThreadPoolExecutor) dVar.f6791b).execute(runnable);
+        }
+    }
+
+    public final c e() {
+        int i4;
+        synchronized (this) {
+            i4 = this.f6794b;
+            this.f6794b = i4 + 1;
+        }
+        return new c(this, com.google.android.gms.measurement.internal.a.l(i4, "Q"));
+    }
+}