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/k1/C0416a.java

@@ -0,0 +1,56 @@
+package k1;
+
+import com.adif.elcanomovil.domain.entities.utils.AsyncResult;
+import kotlin.ResultKt;
+import kotlin.Unit;
+import kotlin.collections.CollectionsKt;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.intrinsics.IntrinsicsKt;
+import kotlin.coroutines.jvm.internal.SuspendLambda;
+import kotlin.jvm.functions.Function2;
+import kotlinx.coroutines.flow.FlowCollector;
+
+/* renamed from: k1.a, reason: case insensitive filesystem */
+/* loaded from: classes.dex */
+public final class C0416a extends SuspendLambda implements Function2 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public int f7017a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public /* synthetic */ Object f7018b;
+
+    /* JADX WARN: Type inference failed for: r1v1, types: [kotlin.coroutines.Continuation, kotlin.coroutines.jvm.internal.SuspendLambda, k1.a] */
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        ?? suspendLambda = new SuspendLambda(2, continuation);
+        suspendLambda.f7018b = obj;
+        return suspendLambda;
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(Object obj, Object obj2) {
+        return ((C0416a) create((FlowCollector) obj, (Continuation) obj2)).invokeSuspend(Unit.INSTANCE);
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        Object coroutine_suspended = IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        int i = this.f7017a;
+        if (i == 0) {
+            ResultKt.throwOnFailure(obj);
+            FlowCollector flowCollector = (FlowCollector) this.f7018b;
+            AsyncResult success = AsyncResult.INSTANCE.success(CollectionsKt.emptyList());
+            this.f7017a = 1;
+            if (flowCollector.emit(success, this) == coroutine_suspended) {
+                return coroutine_suspended;
+            }
+        } else {
+            if (i != 1) {
+                throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
+            }
+            ResultKt.throwOnFailure(obj);
+        }
+        return Unit.INSTANCE;
+    }
+}

apk_decompiled/sources/k1/b.java

@@ -0,0 +1,85 @@
+package k1;
+
+import com.adif.elcanomovil.domain.repositories.compositions.CompositionsRepository;
+import com.adif.elcanomovil.domain.usecases.circulation.GetCompositionsUseCase;
+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;
+import kotlinx.coroutines.CoroutineScope;
+import kotlinx.coroutines.flow.Flow;
+import kotlinx.coroutines.flow.FlowKt;
+
+/* loaded from: classes.dex */
+public final class b extends SuspendLambda implements Function2 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public int f7019a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final /* synthetic */ boolean f7020b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final /* synthetic */ GetCompositionsUseCase f7021c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public final /* synthetic */ String f7022d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public final /* synthetic */ String f7023e;
+
+    /* renamed from: f, reason: collision with root package name */
+    public final /* synthetic */ long f7024f;
+
+    /* renamed from: g, reason: collision with root package name */
+    public final /* synthetic */ String f7025g;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public b(boolean z3, GetCompositionsUseCase getCompositionsUseCase, String str, String str2, long j4, String str3, Continuation continuation) {
+        super(2, continuation);
+        this.f7020b = z3;
+        this.f7021c = getCompositionsUseCase;
+        this.f7022d = str;
+        this.f7023e = str2;
+        this.f7024f = j4;
+        this.f7025g = str3;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        return new b(this.f7020b, this.f7021c, this.f7022d, this.f7023e, this.f7024f, this.f7025g, continuation);
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(Object obj, Object obj2) {
+        return ((b) create((CoroutineScope) obj, (Continuation) obj2)).invokeSuspend(Unit.INSTANCE);
+    }
+
+    /* JADX WARN: Type inference failed for: r10v1, types: [kotlin.coroutines.jvm.internal.SuspendLambda, kotlin.jvm.functions.Function2] */
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        CompositionsRepository compositionsRepository;
+        Object coroutine_suspended = IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        int i = this.f7019a;
+        if (i == 0) {
+            ResultKt.throwOnFailure(obj);
+            if (!this.f7020b) {
+                return FlowKt.flow(new SuspendLambda(2, null));
+            }
+            compositionsRepository = this.f7021c.compositionsRepository;
+            this.f7019a = 1;
+            obj = compositionsRepository.compositions(this.f7022d, this.f7023e, this.f7024f, this.f7025g, 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);
+        }
+        return (Flow) obj;
+    }
+}

apk_decompiled/sources/k1/c.java

@@ -0,0 +1,60 @@
+package k1;
+
+import com.adif.elcanomovil.domain.usecases.circulation.GetDepartureCirculationsUseCase;
+import java.util.Collection;
+import java.util.List;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.jvm.internal.ContinuationImpl;
+import kotlin.jvm.internal.IntCompanionObject;
+
+/* loaded from: classes.dex */
+public final class c extends ContinuationImpl {
+
+    /* renamed from: a, reason: collision with root package name */
+    public GetDepartureCirculationsUseCase f7026a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public Object f7027b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public Object f7028c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public Object f7029d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public Object f7030e;
+
+    /* renamed from: f, reason: collision with root package name */
+    public Collection f7031f;
+
+    /* renamed from: g, reason: collision with root package name */
+    public List f7032g;
+    public int h;
+    public int i;
+
+    /* renamed from: j, reason: collision with root package name */
+    public boolean f7033j;
+
+    /* renamed from: k, reason: collision with root package name */
+    public /* synthetic */ Object f7034k;
+
+    /* renamed from: l, reason: collision with root package name */
+    public final /* synthetic */ GetDepartureCirculationsUseCase f7035l;
+
+    /* renamed from: m, reason: collision with root package name */
+    public int f7036m;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public c(GetDepartureCirculationsUseCase getDepartureCirculationsUseCase, Continuation continuation) {
+        super(continuation);
+        this.f7035l = getDepartureCirculationsUseCase;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        this.f7034k = obj;
+        this.f7036m |= IntCompanionObject.MIN_VALUE;
+        return this.f7035l.invoke(null, null, null, null, 0, false, false, this);
+    }
+}

apk_decompiled/sources/k1/d.java

@@ -0,0 +1,71 @@
+package k1;
+
+import com.adif.elcanomovil.domain.entities.CirculationType;
+import com.adif.elcanomovil.domain.entities.TrainType;
+import com.adif.elcanomovil.domain.usecases.circulation.GetDepartureCirculationsUseCase;
+import java.util.List;
+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;
+
+/* loaded from: classes.dex */
+public final class d extends SuspendLambda implements Function2 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public int f7037a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public /* synthetic */ Object f7038b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final /* synthetic */ GetDepartureCirculationsUseCase f7039c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public final /* synthetic */ CirculationType f7040d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public final /* synthetic */ TrainType f7041e;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public d(GetDepartureCirculationsUseCase getDepartureCirculationsUseCase, CirculationType circulationType, TrainType trainType, Continuation continuation) {
+        super(2, continuation);
+        this.f7039c = getDepartureCirculationsUseCase;
+        this.f7040d = circulationType;
+        this.f7041e = trainType;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        d dVar = new d(this.f7039c, this.f7040d, this.f7041e, continuation);
+        dVar.f7038b = obj;
+        return dVar;
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(Object obj, Object obj2) {
+        return ((d) create((List) obj, (Continuation) obj2)).invokeSuspend(Unit.INSTANCE);
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        Object mapToCirculation;
+        Object coroutine_suspended = IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        int i = this.f7037a;
+        if (i != 0) {
+            if (i != 1) {
+                throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
+            }
+            ResultKt.throwOnFailure(obj);
+            return obj;
+        }
+        ResultKt.throwOnFailure(obj);
+        List list = (List) this.f7038b;
+        boolean z3 = this.f7040d == CirculationType.DEPARTURE;
+        this.f7037a = 1;
+        mapToCirculation = this.f7039c.mapToCirculation(list, z3, this.f7041e, this);
+        return mapToCirculation == coroutine_suspended ? coroutine_suspended : mapToCirculation;
+    }
+}

apk_decompiled/sources/k1/e.java

@@ -0,0 +1,37 @@
+package k1;
+
+import com.adif.elcanomovil.domain.usecases.circulation.GetDepartureCirculationsUseCase;
+import kotlin.coroutines.Continuation;
+import kotlin.coroutines.jvm.internal.ContinuationImpl;
+import kotlin.jvm.internal.IntCompanionObject;
+
+/* loaded from: classes.dex */
+public final class e extends ContinuationImpl {
+
+    /* renamed from: a, reason: collision with root package name */
+    public GetDepartureCirculationsUseCase f7042a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public /* synthetic */ Object f7043b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final /* synthetic */ GetDepartureCirculationsUseCase f7044c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public int f7045d;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public e(GetDepartureCirculationsUseCase getDepartureCirculationsUseCase, Continuation continuation) {
+        super(continuation);
+        this.f7044c = getDepartureCirculationsUseCase;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        Object mapToCirculation;
+        this.f7043b = obj;
+        this.f7045d |= IntCompanionObject.MIN_VALUE;
+        mapToCirculation = this.f7044c.mapToCirculation(null, false, null, this);
+        return mapToCirculation;
+    }
+}

apk_decompiled/sources/k1/f.java

@@ -0,0 +1,64 @@
+package k1;
+
+import com.adif.elcanomovil.domain.repositories.circulation.CirculationRepository;
+import com.adif.elcanomovil.domain.usecases.circulation.GetSeveralPathsUseCase;
+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;
+import kotlinx.coroutines.CoroutineScope;
+
+/* loaded from: classes.dex */
+public final class f extends SuspendLambda implements Function2 {
+
+    /* renamed from: a, reason: collision with root package name */
+    public int f7046a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public final /* synthetic */ GetSeveralPathsUseCase f7047b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public final /* synthetic */ String f7048c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public final /* synthetic */ boolean f7049d;
+
+    /* JADX WARN: 'super' call moved to the top of the method (can break code semantics) */
+    public f(GetSeveralPathsUseCase getSeveralPathsUseCase, String str, boolean z3, Continuation continuation) {
+        super(2, continuation);
+        this.f7047b = getSeveralPathsUseCase;
+        this.f7048c = str;
+        this.f7049d = z3;
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Continuation create(Object obj, Continuation continuation) {
+        return new f(this.f7047b, this.f7048c, this.f7049d, continuation);
+    }
+
+    @Override // kotlin.jvm.functions.Function2
+    public final Object invoke(Object obj, Object obj2) {
+        return ((f) create((CoroutineScope) obj, (Continuation) obj2)).invokeSuspend(Unit.INSTANCE);
+    }
+
+    @Override // kotlin.coroutines.jvm.internal.BaseContinuationImpl
+    public final Object invokeSuspend(Object obj) {
+        CirculationRepository circulationRepository;
+        Object coroutine_suspended = IntrinsicsKt.getCOROUTINE_SUSPENDED();
+        int i = this.f7046a;
+        if (i != 0) {
+            if (i != 1) {
+                throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
+            }
+            ResultKt.throwOnFailure(obj);
+            return obj;
+        }
+        ResultKt.throwOnFailure(obj);
+        circulationRepository = this.f7047b.circulationRepository;
+        this.f7046a = 1;
+        Object severalPaths = circulationRepository.severalPaths(this.f7048c, this.f7049d, this);
+        return severalPaths == coroutine_suspended ? coroutine_suspended : severalPaths;
+    }
+}