Initial import of ADIF API reverse-engineering toolkit

apk_decompiled/sources/d/AbstractC0294c.java

@@ -0,0 +1,7 @@
+package d;
+
+/* renamed from: d.c, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public abstract class AbstractC0294c {
+    public abstract void a(Object obj);
+}

apk_decompiled/sources/d/AbstractC0300i.java

@@ -0,0 +1,198 @@
+package d;
+
+import a.AbstractC0105a;
+import android.content.Intent;
+import android.os.Bundle;
+import android.util.Log;
+import androidx.lifecycle.A;
+import androidx.lifecycle.B;
+import androidx.lifecycle.C;
+import androidx.lifecycle.H;
+import androidx.lifecycle.J;
+import e.AbstractC0311a;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.NoSuchElementException;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.sequences.SequencesKt;
+
+/* renamed from: d.i, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public abstract class AbstractC0300i {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final LinkedHashMap f6104a = new LinkedHashMap();
+
+    /* renamed from: b, reason: collision with root package name */
+    public final LinkedHashMap f6105b = new LinkedHashMap();
+
+    /* renamed from: c, reason: collision with root package name */
+    public final LinkedHashMap f6106c = new LinkedHashMap();
+
+    /* renamed from: d, reason: collision with root package name */
+    public final ArrayList f6107d = new ArrayList();
+
+    /* renamed from: e, reason: collision with root package name */
+    public final transient LinkedHashMap f6108e = new LinkedHashMap();
+
+    /* renamed from: f, reason: collision with root package name */
+    public final LinkedHashMap f6109f = new LinkedHashMap();
+
+    /* renamed from: g, reason: collision with root package name */
+    public final Bundle f6110g = new Bundle();
+
+    public final boolean a(int i, int i4, Intent intent) {
+        String str = (String) this.f6104a.get(Integer.valueOf(i));
+        if (str == null) {
+            return false;
+        }
+        C0296e c0296e = (C0296e) this.f6108e.get(str);
+        if ((c0296e != null ? c0296e.f6095a : null) != null) {
+            ArrayList arrayList = this.f6107d;
+            if (arrayList.contains(str)) {
+                c0296e.f6095a.a(c0296e.f6096b.c(i4, intent));
+                arrayList.remove(str);
+                return true;
+            }
+        }
+        this.f6109f.remove(str);
+        this.f6110g.putParcelable(str, new C0292a(i4, intent));
+        return true;
+    }
+
+    public abstract void b(int i, AbstractC0311a abstractC0311a, Object obj);
+
+    public final C0299h c(final String key, J lifecycleOwner, final AbstractC0311a contract, final InterfaceC0293b callback) {
+        Intrinsics.checkNotNullParameter(key, "key");
+        Intrinsics.checkNotNullParameter(lifecycleOwner, "lifecycleOwner");
+        Intrinsics.checkNotNullParameter(contract, "contract");
+        Intrinsics.checkNotNullParameter(callback, "callback");
+        C lifecycle = lifecycleOwner.getLifecycle();
+        if (lifecycle.b().a(B.f3283d)) {
+            throw new IllegalStateException(("LifecycleOwner " + lifecycleOwner + " is attempting to register while current state is " + lifecycle.b() + ". LifecycleOwners must call register before they are STARTED.").toString());
+        }
+        e(key);
+        LinkedHashMap linkedHashMap = this.f6106c;
+        C0297f c0297f = (C0297f) linkedHashMap.get(key);
+        if (c0297f == null) {
+            c0297f = new C0297f(lifecycle);
+        }
+        H observer = new H() { // from class: d.d
+            @Override // androidx.lifecycle.H
+            public final void onStateChanged(J j4, A event) {
+                AbstractC0300i this$0 = AbstractC0300i.this;
+                Intrinsics.checkNotNullParameter(this$0, "this$0");
+                String key2 = key;
+                Intrinsics.checkNotNullParameter(key2, "$key");
+                InterfaceC0293b callback2 = callback;
+                Intrinsics.checkNotNullParameter(callback2, "$callback");
+                AbstractC0311a contract2 = contract;
+                Intrinsics.checkNotNullParameter(contract2, "$contract");
+                Intrinsics.checkNotNullParameter(j4, "<anonymous parameter 0>");
+                Intrinsics.checkNotNullParameter(event, "event");
+                if (A.ON_START != event) {
+                    if (A.ON_STOP == event) {
+                        this$0.f6108e.remove(key2);
+                        return;
+                    } else {
+                        if (A.ON_DESTROY == event) {
+                            this$0.f(key2);
+                            return;
+                        }
+                        return;
+                    }
+                }
+                this$0.f6108e.put(key2, new C0296e(contract2, callback2));
+                LinkedHashMap linkedHashMap2 = this$0.f6109f;
+                if (linkedHashMap2.containsKey(key2)) {
+                    Object obj = linkedHashMap2.get(key2);
+                    linkedHashMap2.remove(key2);
+                    callback2.a(obj);
+                }
+                Bundle bundle = this$0.f6110g;
+                C0292a c0292a = (C0292a) AbstractC0105a.B(bundle, key2);
+                if (c0292a != null) {
+                    bundle.remove(key2);
+                    callback2.a(contract2.c(c0292a.f6089a, c0292a.f6090b));
+                }
+            }
+        };
+        Intrinsics.checkNotNullParameter(observer, "observer");
+        c0297f.f6097a.a(observer);
+        c0297f.f6098b.add(observer);
+        linkedHashMap.put(key, c0297f);
+        return new C0299h(this, key, contract, 0);
+    }
+
+    public final C0299h d(String key, AbstractC0311a contract, InterfaceC0293b callback) {
+        Intrinsics.checkNotNullParameter(key, "key");
+        Intrinsics.checkNotNullParameter(contract, "contract");
+        Intrinsics.checkNotNullParameter(callback, "callback");
+        e(key);
+        this.f6108e.put(key, new C0296e(contract, callback));
+        LinkedHashMap linkedHashMap = this.f6109f;
+        if (linkedHashMap.containsKey(key)) {
+            Object obj = linkedHashMap.get(key);
+            linkedHashMap.remove(key);
+            callback.a(obj);
+        }
+        Bundle bundle = this.f6110g;
+        C0292a c0292a = (C0292a) AbstractC0105a.B(bundle, key);
+        if (c0292a != null) {
+            bundle.remove(key);
+            callback.a(contract.c(c0292a.f6089a, c0292a.f6090b));
+        }
+        return new C0299h(this, key, contract, 1);
+    }
+
+    public final void e(String str) {
+        LinkedHashMap linkedHashMap = this.f6105b;
+        if (((Integer) linkedHashMap.get(str)) != null) {
+            return;
+        }
+        for (Number number : SequencesKt.generateSequence(C0298g.f6099a)) {
+            int intValue = number.intValue();
+            LinkedHashMap linkedHashMap2 = this.f6104a;
+            if (!linkedHashMap2.containsKey(Integer.valueOf(intValue))) {
+                int intValue2 = number.intValue();
+                linkedHashMap2.put(Integer.valueOf(intValue2), str);
+                linkedHashMap.put(str, Integer.valueOf(intValue2));
+                return;
+            }
+        }
+        throw new NoSuchElementException("Sequence contains no element matching the predicate.");
+    }
+
+    public final void f(String key) {
+        Integer num;
+        Intrinsics.checkNotNullParameter(key, "key");
+        if (!this.f6107d.contains(key) && (num = (Integer) this.f6105b.remove(key)) != null) {
+            this.f6104a.remove(num);
+        }
+        this.f6108e.remove(key);
+        LinkedHashMap linkedHashMap = this.f6109f;
+        if (linkedHashMap.containsKey(key)) {
+            StringBuilder p = com.google.android.gms.measurement.internal.a.p("Dropping pending result for request ", key, ": ");
+            p.append(linkedHashMap.get(key));
+            Log.w("ActivityResultRegistry", p.toString());
+            linkedHashMap.remove(key);
+        }
+        Bundle bundle = this.f6110g;
+        if (bundle.containsKey(key)) {
+            Log.w("ActivityResultRegistry", "Dropping pending result for request " + key + ": " + ((C0292a) AbstractC0105a.B(bundle, key)));
+            bundle.remove(key);
+        }
+        LinkedHashMap linkedHashMap2 = this.f6106c;
+        C0297f c0297f = (C0297f) linkedHashMap2.get(key);
+        if (c0297f != null) {
+            ArrayList arrayList = c0297f.f6098b;
+            Iterator it = arrayList.iterator();
+            while (it.hasNext()) {
+                c0297f.f6097a.c((H) it.next());
+            }
+            arrayList.clear();
+            linkedHashMap2.remove(key);
+        }
+    }
+}

apk_decompiled/sources/d/C0292a.java

@@ -0,0 +1,52 @@
+package d;
+
+import android.content.Intent;
+import android.os.Parcel;
+import android.os.Parcelable;
+import kotlin.jvm.JvmField;
+import kotlin.jvm.internal.Intrinsics;
+
+/* renamed from: d.a, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0292a implements Parcelable {
+
+    @JvmField
+    public static final Parcelable.Creator<C0292a> CREATOR = new D0.a(11);
+
+    /* renamed from: a, reason: collision with root package name */
+    public final int f6089a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final Intent f6090b;
+
+    public C0292a(int i, Intent intent) {
+        this.f6089a = i;
+        this.f6090b = intent;
+    }
+
+    @Override // android.os.Parcelable
+    public final int describeContents() {
+        return 0;
+    }
+
+    public final String toString() {
+        StringBuilder sb = new StringBuilder("ActivityResult{resultCode=");
+        int i = this.f6089a;
+        sb.append(i != -1 ? i != 0 ? String.valueOf(i) : "RESULT_CANCELED" : "RESULT_OK");
+        sb.append(", data=");
+        sb.append(this.f6090b);
+        sb.append('}');
+        return sb.toString();
+    }
+
+    @Override // android.os.Parcelable
+    public final void writeToParcel(Parcel dest, int i) {
+        Intrinsics.checkNotNullParameter(dest, "dest");
+        dest.writeInt(this.f6089a);
+        Intent intent = this.f6090b;
+        dest.writeInt(intent == null ? 0 : 1);
+        if (intent != null) {
+            intent.writeToParcel(dest, i);
+        }
+    }
+}

apk_decompiled/sources/d/C0296e.java

@@ -0,0 +1,22 @@
+package d;
+
+import e.AbstractC0311a;
+import kotlin.jvm.internal.Intrinsics;
+
+/* renamed from: d.e, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0296e {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final InterfaceC0293b f6095a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final AbstractC0311a f6096b;
+
+    public C0296e(AbstractC0311a contract, InterfaceC0293b callback) {
+        Intrinsics.checkNotNullParameter(callback, "callback");
+        Intrinsics.checkNotNullParameter(contract, "contract");
+        this.f6095a = callback;
+        this.f6096b = contract;
+    }
+}

apk_decompiled/sources/d/C0297f.java

@@ -0,0 +1,22 @@
+package d;
+
+import androidx.lifecycle.C;
+import java.util.ArrayList;
+import kotlin.jvm.internal.Intrinsics;
+
+/* renamed from: d.f, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0297f {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final C f6097a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final ArrayList f6098b;
+
+    public C0297f(C lifecycle) {
+        Intrinsics.checkNotNullParameter(lifecycle, "lifecycle");
+        this.f6097a = lifecycle;
+        this.f6098b = new ArrayList();
+    }
+}

apk_decompiled/sources/d/C0298g.java

@@ -0,0 +1,18 @@
+package d;
+
+import kotlin.jvm.functions.Function0;
+import kotlin.jvm.internal.Lambda;
+import kotlin.random.Random;
+
+/* renamed from: d.g, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0298g extends Lambda implements Function0 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public static final C0298g f6099a = new Lambda(0);
+
+    @Override // kotlin.jvm.functions.Function0
+    public final Object invoke() {
+        return Integer.valueOf(Random.INSTANCE.nextInt(2147418112) + 65536);
+    }
+}

apk_decompiled/sources/d/C0299h.java

@@ -0,0 +1,77 @@
+package d;
+
+import e.AbstractC0311a;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+
+/* renamed from: d.h, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0299h extends AbstractC0294c {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final /* synthetic */ int f6100a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final /* synthetic */ AbstractC0300i f6101b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final /* synthetic */ String f6102c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public final /* synthetic */ AbstractC0311a f6103d;
+
+    public /* synthetic */ C0299h(AbstractC0300i abstractC0300i, String str, AbstractC0311a abstractC0311a, int i) {
+        this.f6100a = i;
+        this.f6101b = abstractC0300i;
+        this.f6102c = str;
+        this.f6103d = abstractC0311a;
+    }
+
+    @Override // d.AbstractC0294c
+    public final void a(Object obj) {
+        switch (this.f6100a) {
+            case 0:
+                AbstractC0300i abstractC0300i = this.f6101b;
+                LinkedHashMap linkedHashMap = abstractC0300i.f6105b;
+                String str = this.f6102c;
+                Object obj2 = linkedHashMap.get(str);
+                AbstractC0311a abstractC0311a = this.f6103d;
+                if (obj2 == null) {
+                    throw new IllegalStateException(("Attempting to launch an unregistered ActivityResultLauncher with contract " + abstractC0311a + " and input " + obj + ". You must ensure the ActivityResultLauncher is registered before calling launch().").toString());
+                }
+                int intValue = ((Number) obj2).intValue();
+                ArrayList arrayList = abstractC0300i.f6107d;
+                arrayList.add(str);
+                try {
+                    abstractC0300i.b(intValue, abstractC0311a, obj);
+                    return;
+                } catch (Exception e4) {
+                    arrayList.remove(str);
+                    throw e4;
+                }
+            default:
+                AbstractC0300i abstractC0300i2 = this.f6101b;
+                LinkedHashMap linkedHashMap2 = abstractC0300i2.f6105b;
+                String str2 = this.f6102c;
+                Object obj3 = linkedHashMap2.get(str2);
+                AbstractC0311a abstractC0311a2 = this.f6103d;
+                if (obj3 == null) {
+                    throw new IllegalStateException(("Attempting to launch an unregistered ActivityResultLauncher with contract " + abstractC0311a2 + " and input " + obj + ". You must ensure the ActivityResultLauncher is registered before calling launch().").toString());
+                }
+                int intValue2 = ((Number) obj3).intValue();
+                ArrayList arrayList2 = abstractC0300i2.f6107d;
+                arrayList2.add(str2);
+                try {
+                    abstractC0300i2.b(intValue2, abstractC0311a2, obj);
+                    return;
+                } catch (Exception e5) {
+                    arrayList2.remove(str2);
+                    throw e5;
+                }
+        }
+    }
+
+    public void b() {
+        this.f6101b.f(this.f6102c);
+    }
+}

apk_decompiled/sources/d/C0302k.java

@@ -0,0 +1,50 @@
+package d;
+
+import android.content.Intent;
+import android.content.IntentSender;
+import android.os.Parcel;
+import android.os.Parcelable;
+import kotlin.jvm.JvmField;
+import kotlin.jvm.internal.Intrinsics;
+
+/* renamed from: d.k, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0302k implements Parcelable {
+
+    @JvmField
+    public static final Parcelable.Creator<C0302k> CREATOR = new D0.a(12);
+
+    /* renamed from: a, reason: collision with root package name */
+    public final IntentSender f6111a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final Intent f6112b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final int f6113c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public final int f6114d;
+
+    public C0302k(IntentSender intentSender, Intent intent, int i, int i4) {
+        Intrinsics.checkNotNullParameter(intentSender, "intentSender");
+        this.f6111a = intentSender;
+        this.f6112b = intent;
+        this.f6113c = i;
+        this.f6114d = i4;
+    }
+
+    @Override // android.os.Parcelable
+    public final int describeContents() {
+        return 0;
+    }
+
+    @Override // android.os.Parcelable
+    public final void writeToParcel(Parcel dest, int i) {
+        Intrinsics.checkNotNullParameter(dest, "dest");
+        dest.writeParcelable(this.f6111a, i);
+        dest.writeParcelable(this.f6112b, i);
+        dest.writeInt(this.f6113c);
+        dest.writeInt(this.f6114d);
+    }
+}

apk_decompiled/sources/d/InterfaceC0293b.java

@@ -0,0 +1,7 @@
+package d;
+
+/* renamed from: d.b, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public interface InterfaceC0293b {
+    void a(Object obj);
+}

apk_decompiled/sources/d/InterfaceC0301j.java

@@ -0,0 +1,7 @@
+package d;
+
+/* renamed from: d.j, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public interface InterfaceC0301j {
+    AbstractC0300i getActivityResultRegistry();
+}