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/b0/AbstractC0261f.java

@@ -0,0 +1,6 @@
+package b0;
+
+/* renamed from: b0.f, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public abstract class AbstractC0261f {
+}

apk_decompiled/sources/b0/AbstractC0262g.java

@@ -0,0 +1,7 @@
+package b0;
+
+/* renamed from: b0.g, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public abstract class AbstractC0262g {
+    public abstract Object a(C0260e c0260e);
+}

apk_decompiled/sources/b0/AbstractC0264i.java

@@ -0,0 +1,24 @@
+package b0;
+
+import u.AbstractC0629f;
+
+/* renamed from: b0.i, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public abstract /* synthetic */ class AbstractC0264i {
+    public static final /* synthetic */ int[] $EnumSwitchMapping$0;
+
+    static {
+        int[] iArr = new int[8];
+        System.arraycopy(AbstractC0629f.f8583a, 0, iArr, 0, 8);
+        int[] iArr2 = new int[iArr.length];
+        iArr2[0] = 1;
+        iArr2[1] = 2;
+        iArr2[6] = 3;
+        iArr2[2] = 4;
+        iArr2[3] = 5;
+        iArr2[4] = 6;
+        iArr2[5] = 7;
+        iArr2[7] = 8;
+        $EnumSwitchMapping$0 = iArr2;
+    }
+}

apk_decompiled/sources/b0/C0256a.java

@@ -0,0 +1,21 @@
+package b0;
+
+import java.util.Map;
+import kotlin.jvm.functions.Function1;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.Lambda;
+
+/* renamed from: b0.a, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0256a extends Lambda implements Function1 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public static final C0256a f4152a = new Lambda(1);
+
+    @Override // kotlin.jvm.functions.Function1
+    public final Object invoke(Object obj) {
+        Map.Entry entry = (Map.Entry) obj;
+        Intrinsics.checkNotNullParameter(entry, "entry");
+        return "  " + ((C0260e) entry.getKey()).f4159a + " = " + entry.getValue();
+    }
+}

apk_decompiled/sources/b0/C0257b.java

@@ -0,0 +1,79 @@
+package b0;
+
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicBoolean;
+import kotlin.collections.CollectionsKt;
+import kotlin.collections.CollectionsKt___CollectionsKt;
+import kotlin.jvm.internal.Intrinsics;
+
+/* renamed from: b0.b, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0257b extends AbstractC0262g {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final Map f4153a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final AtomicBoolean f4154b;
+
+    public C0257b(Map preferencesMap, boolean z3) {
+        Intrinsics.checkNotNullParameter(preferencesMap, "preferencesMap");
+        this.f4153a = preferencesMap;
+        this.f4154b = new AtomicBoolean(z3);
+    }
+
+    @Override // b0.AbstractC0262g
+    public final Object a(C0260e key) {
+        Intrinsics.checkNotNullParameter(key, "key");
+        return this.f4153a.get(key);
+    }
+
+    public final void b() {
+        if (this.f4154b.get()) {
+            throw new IllegalStateException("Do mutate preferences once returned to DataStore.");
+        }
+    }
+
+    public final void c(C0260e key, Object obj) {
+        Intrinsics.checkNotNullParameter(key, "key");
+        b();
+        Map map = this.f4153a;
+        if (obj == null) {
+            Intrinsics.checkNotNullParameter(key, "key");
+            b();
+            map.remove(key);
+        } else {
+            if (!(obj instanceof Set)) {
+                map.put(key, obj);
+                return;
+            }
+            Set unmodifiableSet = Collections.unmodifiableSet(CollectionsKt.toSet((Iterable) obj));
+            Intrinsics.checkNotNullExpressionValue(unmodifiableSet, "unmodifiableSet(value.toSet())");
+            map.put(key, unmodifiableSet);
+        }
+    }
+
+    public final boolean equals(Object obj) {
+        if (!(obj instanceof C0257b)) {
+            return false;
+        }
+        return Intrinsics.areEqual(this.f4153a, ((C0257b) obj).f4153a);
+    }
+
+    public final int hashCode() {
+        return this.f4153a.hashCode();
+    }
+
+    public final String toString() {
+        String joinToString$default;
+        joinToString$default = CollectionsKt___CollectionsKt.joinToString$default(this.f4153a.entrySet(), ",\n", "{\n", "\n}", 0, null, C0256a.f4152a, 24, null);
+        return joinToString$default;
+    }
+
+    public /* synthetic */ C0257b(boolean z3) {
+        this(new LinkedHashMap(), z3);
+    }
+}

apk_decompiled/sources/b0/C0258c.java

@@ -0,0 +1,66 @@
+package b0;
+
+import kotlin.ResultKt;
+import kotlin.Unit;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.SuspendLambda;
+import kotlin.jvm.functions.Function2;
+
+/* renamed from: b0.c, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0258c extends SuspendLambda implements Function2 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public int f4155a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public /* synthetic */ Object f4156b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final /* synthetic */ SuspendLambda f4157c;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    /* JADX WARN: Multi-variable type inference failed */
+    public C0258c(Function2 function2, Continuation continuation) {
+        super(2, continuation);
+        this.f4157c = (SuspendLambda) function2;
+    }
+
+    /* JADX WARN: Type inference failed for: r1v1, types: [kotlin.coroutines.jvm.internal.SuspendLambda, kotlin.jvm.functions.Function2] */
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        C0258c c0258c = new C0258c(this.f4157c, continuation);
+        c0258c.f4156b = obj;
+        return c0258c;
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(Object obj, Object obj2) {
+        return ((C0258c) create((AbstractC0262g) obj, (Continuation) obj2)).invokeSuspend(Unit.INSTANCE);
+    }
+
+    /* JADX WARN: Type inference failed for: r1v1, types: [kotlin.coroutines.jvm.internal.SuspendLambda, kotlin.jvm.functions.Function2] */
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        Object coroutine_suspended = IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        int i = this.f4155a;
+        if (i == 0) {
+            ResultKt.throwOnFailure(obj);
+            AbstractC0262g abstractC0262g = (AbstractC0262g) this.f4156b;
+            this.f4155a = 1;
+            obj = this.f4157c.invoke(abstractC0262g, this);
+            if (obj == coroutine_suspended) {
+                return coroutine_suspended;
+            }
+        } else {
+            if (i != 1) {
+                throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
+            }
+            ResultKt.throwOnFailure(obj);
+        }
+        AbstractC0262g abstractC0262g2 = (AbstractC0262g) obj;
+        ((C0257b) abstractC0262g2).f4154b.set(true);
+        return abstractC0262g2;
+    }
+}

apk_decompiled/sources/b0/C0259d.java

@@ -0,0 +1,31 @@
+package b0;
+
+import Y.F;
+import Y.InterfaceC0091g;
+import kotlin.coroutines.Continuation;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.internal.Intrinsics;
+import kotlinx.coroutines.flow.Flow;
+
+/* renamed from: b0.d, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0259d implements InterfaceC0091g {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final F f4158a;
+
+    public C0259d(F delegate) {
+        Intrinsics.checkNotNullParameter(delegate, "delegate");
+        this.f4158a = delegate;
+    }
+
+    @Override // Y.InterfaceC0091g
+    public final Object a(Function2 function2, Continuation continuation) {
+        return this.f4158a.a(new C0258c(function2, null), continuation);
+    }
+
+    @Override // Y.InterfaceC0091g
+    public final Flow b() {
+        return this.f4158a.f2058d;
+    }
+}

apk_decompiled/sources/b0/C0260e.java

@@ -0,0 +1,31 @@
+package b0;
+
+import kotlin.jvm.internal.Intrinsics;
+
+/* renamed from: b0.e, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0260e {
+
+    /* renamed from: a, reason: collision with root package name */
+    public final String f4159a;
+
+    public C0260e(String name) {
+        Intrinsics.checkNotNullParameter(name, "name");
+        this.f4159a = name;
+    }
+
+    public final boolean equals(Object obj) {
+        if (!(obj instanceof C0260e)) {
+            return false;
+        }
+        return Intrinsics.areEqual(this.f4159a, ((C0260e) obj).f4159a);
+    }
+
+    public final int hashCode() {
+        return this.f4159a.hashCode();
+    }
+
+    public final String toString() {
+        return this.f4159a;
+    }
+}

apk_decompiled/sources/b0/C0263h.java

@@ -0,0 +1,68 @@
+package b0;
+
+import java.util.Collections;
+import java.util.Map;
+import kotlin.ResultKt;
+import kotlin.Unit;
+import kotlin.collections.MapsKt;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.SuspendLambda;
+import kotlin.jvm.functions.Function2;
+import kotlin.jvm.internal.Intrinsics;
+
+/* renamed from: b0.h, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0263h extends SuspendLambda implements Function2 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public int f4160a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public /* synthetic */ Object f4161b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final /* synthetic */ SuspendLambda f4162c;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    /* JADX WARN: Multi-variable type inference failed */
+    public C0263h(Function2 function2, Continuation continuation) {
+        super(2, continuation);
+        this.f4162c = (SuspendLambda) function2;
+    }
+
+    /* JADX WARN: Type inference failed for: r1v1, types: [kotlin.coroutines.jvm.internal.SuspendLambda, kotlin.jvm.functions.Function2] */
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        C0263h c0263h = new C0263h(this.f4162c, continuation);
+        c0263h.f4161b = obj;
+        return c0263h;
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(Object obj, Object obj2) {
+        return ((C0263h) create((AbstractC0262g) obj, (Continuation) obj2)).invokeSuspend(Unit.INSTANCE);
+    }
+
+    /* JADX WARN: Type inference failed for: r5v7, types: [kotlin.coroutines.jvm.internal.SuspendLambda, kotlin.jvm.functions.Function2] */
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        Object coroutine_suspended = IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        int i = this.f4160a;
+        if (i != 0) {
+            if (i != 1) {
+                throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
+            }
+            C0257b c0257b = (C0257b) this.f4161b;
+            ResultKt.throwOnFailure(obj);
+            return c0257b;
+        }
+        ResultKt.throwOnFailure(obj);
+        Map unmodifiableMap = Collections.unmodifiableMap(((C0257b) ((AbstractC0262g) this.f4161b)).f4153a);
+        Intrinsics.checkNotNullExpressionValue(unmodifiableMap, "unmodifiableMap(preferencesMap)");
+        C0257b c0257b2 = new C0257b(MapsKt.toMutableMap(unmodifiableMap), false);
+        this.f4161b = c0257b2;
+        this.f4160a = 1;
+        return this.f4162c.invoke(c0257b2, this) == coroutine_suspended ? coroutine_suspended : c0257b2;
+    }
+}

apk_decompiled/sources/b0/C0265j.java

@@ -0,0 +1,205 @@
+package b0;
+
+import Y.C0085a;
+import Y.n;
+import androidx.datastore.preferences.protobuf.A;
+import androidx.datastore.preferences.protobuf.AbstractC0130v;
+import androidx.datastore.preferences.protobuf.C0119j;
+import androidx.datastore.preferences.protobuf.InterfaceC0132x;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Map;
+import java.util.Set;
+import java.util.logging.Logger;
+import kotlin.NoWhenBranchMatchedException;
+import kotlin.Unit;
+import kotlin.collections.CollectionsKt;
+import kotlin.collections.MapsKt;
+import kotlin.jvm.internal.Intrinsics;
+import u.AbstractC0629f;
+
+/* renamed from: b0.j, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0265j {
+
+    /* renamed from: a, reason: collision with root package name */
+    public static final C0265j f4163a = new Object();
+
+    public final C0257b a(FileInputStream input) {
+        Intrinsics.checkNotNullParameter(input, "input");
+        try {
+            a0.f l4 = a0.f.l(input);
+            Intrinsics.checkNotNullExpressionValue(l4, "{\n                PreferencesProto.PreferenceMap.parseFrom(input)\n            }");
+            AbstractC0261f[] pairs = new AbstractC0261f[0];
+            Intrinsics.checkNotNullParameter(pairs, "pairs");
+            C0257b c0257b = new C0257b(false);
+            AbstractC0261f[] pairs2 = (AbstractC0261f[]) Arrays.copyOf(pairs, 0);
+            Intrinsics.checkNotNullParameter(pairs2, "pairs");
+            c0257b.b();
+            if (pairs2.length > 0) {
+                AbstractC0261f abstractC0261f = pairs2[0];
+                throw null;
+            }
+            Map j4 = l4.j();
+            Intrinsics.checkNotNullExpressionValue(j4, "preferencesProto.preferencesMap");
+            for (Map.Entry entry : j4.entrySet()) {
+                String name = (String) entry.getKey();
+                a0.j value = (a0.j) entry.getValue();
+                Intrinsics.checkNotNullExpressionValue(name, "name");
+                Intrinsics.checkNotNullExpressionValue(value, "value");
+                int x3 = value.x();
+                switch (x3 == 0 ? -1 : AbstractC0264i.$EnumSwitchMapping$0[AbstractC0629f.b(x3)]) {
+                    case -1:
+                        throw new C0085a("Value case is null.", 0);
+                    case 0:
+                    default:
+                        throw new NoWhenBranchMatchedException();
+                    case 1:
+                        Intrinsics.checkNotNullParameter(name, "name");
+                        C0260e key = new C0260e(name);
+                        Boolean valueOf = Boolean.valueOf(value.p());
+                        Intrinsics.checkNotNullParameter(key, "key");
+                        c0257b.c(key, valueOf);
+                        break;
+                    case 2:
+                        Intrinsics.checkNotNullParameter(name, "name");
+                        C0260e key2 = new C0260e(name);
+                        Float valueOf2 = Float.valueOf(value.s());
+                        Intrinsics.checkNotNullParameter(key2, "key");
+                        c0257b.c(key2, valueOf2);
+                        break;
+                    case 3:
+                        Intrinsics.checkNotNullParameter(name, "name");
+                        C0260e key3 = new C0260e(name);
+                        Double valueOf3 = Double.valueOf(value.r());
+                        Intrinsics.checkNotNullParameter(key3, "key");
+                        c0257b.c(key3, valueOf3);
+                        break;
+                    case 4:
+                        Intrinsics.checkNotNullParameter(name, "name");
+                        C0260e key4 = new C0260e(name);
+                        Integer valueOf4 = Integer.valueOf(value.t());
+                        Intrinsics.checkNotNullParameter(key4, "key");
+                        c0257b.c(key4, valueOf4);
+                        break;
+                    case 5:
+                        Intrinsics.checkNotNullParameter(name, "name");
+                        C0260e key5 = new C0260e(name);
+                        Long valueOf5 = Long.valueOf(value.u());
+                        Intrinsics.checkNotNullParameter(key5, "key");
+                        c0257b.c(key5, valueOf5);
+                        break;
+                    case 6:
+                        Intrinsics.checkNotNullParameter(name, "name");
+                        C0260e key6 = new C0260e(name);
+                        String v3 = value.v();
+                        Intrinsics.checkNotNullExpressionValue(v3, "value.string");
+                        Intrinsics.checkNotNullParameter(key6, "key");
+                        c0257b.c(key6, v3);
+                        break;
+                    case 7:
+                        Intrinsics.checkNotNullParameter(name, "name");
+                        C0260e key7 = new C0260e(name);
+                        InterfaceC0132x k4 = value.w().k();
+                        Intrinsics.checkNotNullExpressionValue(k4, "value.stringSet.stringsList");
+                        Set set = CollectionsKt.toSet(k4);
+                        Intrinsics.checkNotNullParameter(key7, "key");
+                        c0257b.c(key7, set);
+                        break;
+                    case 8:
+                        throw new C0085a("Value not set.", 0);
+                }
+            }
+            Map unmodifiableMap = Collections.unmodifiableMap(c0257b.f4153a);
+            Intrinsics.checkNotNullExpressionValue(unmodifiableMap, "unmodifiableMap(preferencesMap)");
+            return new C0257b(MapsKt.toMutableMap(unmodifiableMap), true);
+        } catch (A e4) {
+            Intrinsics.checkNotNullParameter("Unable to parse preferences proto.", "message");
+            throw new IOException("Unable to parse preferences proto.", e4);
+        }
+    }
+
+    public final Unit b(Object obj, n nVar) {
+        AbstractC0130v a2;
+        Map unmodifiableMap = Collections.unmodifiableMap(((C0257b) ((AbstractC0262g) obj)).f4153a);
+        Intrinsics.checkNotNullExpressionValue(unmodifiableMap, "unmodifiableMap(preferencesMap)");
+        a0.d k4 = a0.f.k();
+        for (Map.Entry entry : unmodifiableMap.entrySet()) {
+            C0260e c0260e = (C0260e) entry.getKey();
+            Object value = entry.getValue();
+            String str = c0260e.f4159a;
+            if (value instanceof Boolean) {
+                a0.i y3 = a0.j.y();
+                boolean booleanValue = ((Boolean) value).booleanValue();
+                y3.c();
+                a0.j.m((a0.j) y3.f2971b, booleanValue);
+                a2 = y3.a();
+                Intrinsics.checkNotNullExpressionValue(a2, "newBuilder().setBoolean(value).build()");
+            } else if (value instanceof Float) {
+                a0.i y4 = a0.j.y();
+                float floatValue = ((Number) value).floatValue();
+                y4.c();
+                a0.j.n((a0.j) y4.f2971b, floatValue);
+                a2 = y4.a();
+                Intrinsics.checkNotNullExpressionValue(a2, "newBuilder().setFloat(value).build()");
+            } else if (value instanceof Double) {
+                a0.i y5 = a0.j.y();
+                double doubleValue = ((Number) value).doubleValue();
+                y5.c();
+                a0.j.l((a0.j) y5.f2971b, doubleValue);
+                a2 = y5.a();
+                Intrinsics.checkNotNullExpressionValue(a2, "newBuilder().setDouble(value).build()");
+            } else if (value instanceof Integer) {
+                a0.i y6 = a0.j.y();
+                int intValue = ((Number) value).intValue();
+                y6.c();
+                a0.j.o((a0.j) y6.f2971b, intValue);
+                a2 = y6.a();
+                Intrinsics.checkNotNullExpressionValue(a2, "newBuilder().setInteger(value).build()");
+            } else if (value instanceof Long) {
+                a0.i y7 = a0.j.y();
+                long longValue = ((Number) value).longValue();
+                y7.c();
+                a0.j.i((a0.j) y7.f2971b, longValue);
+                a2 = y7.a();
+                Intrinsics.checkNotNullExpressionValue(a2, "newBuilder().setLong(value).build()");
+            } else if (value instanceof String) {
+                a0.i y8 = a0.j.y();
+                y8.c();
+                a0.j.j((a0.j) y8.f2971b, (String) value);
+                a2 = y8.a();
+                Intrinsics.checkNotNullExpressionValue(a2, "newBuilder().setString(value).build()");
+            } else {
+                if (!(value instanceof Set)) {
+                    throw new IllegalStateException(Intrinsics.stringPlus("PreferencesSerializer does not support type: ", value.getClass().getName()));
+                }
+                a0.i y9 = a0.j.y();
+                a0.g l4 = a0.h.l();
+                l4.c();
+                a0.h.i((a0.h) l4.f2971b, (Set) value);
+                y9.c();
+                a0.j.k((a0.j) y9.f2971b, l4);
+                a2 = y9.a();
+                Intrinsics.checkNotNullExpressionValue(a2, "newBuilder().setStringSet(\n                    StringSet.newBuilder().addAllStrings(value as Set<String>)\n                ).build()");
+            }
+            k4.getClass();
+            str.getClass();
+            k4.c();
+            a0.f.i((a0.f) k4.f2971b).put(str, (a0.j) a2);
+        }
+        a0.f fVar = (a0.f) k4.a();
+        int a4 = fVar.a();
+        Logger logger = C0119j.h;
+        if (a4 > 4096) {
+            a4 = 4096;
+        }
+        C0119j c0119j = new C0119j(nVar, a4);
+        fVar.c(c0119j);
+        if (c0119j.f2933f > 0) {
+            c0119j.B();
+        }
+        return Unit.INSTANCE;
+    }
+}