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/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();
+}