fix: wrong transfer time calculation and transfer time inconsistencies

Author: Bnyro

app/src/main/java/net/youapps/transport/components/directions/IndividualTripCard.kt

@@ -20,5 +20,5 @@ val individualIcons = mapOf(
 
 @Composable
 fun IndividualTripCard(leg: TripLeg.Individual) {
-    CardWithIcon(individualIcons[leg.type], TextUtils.formatDistance(leg.distance))
+    CardWithIcon(individualIcons[leg.type], leg.distance?.let { TextUtils.formatDistance(it) })
 }

app/src/main/java/net/youapps/transport/data/transport/PTETransportProvider.kt

@@ -20,7 +20,9 @@ import net.youapps.transport.data.transport.model.TripLeg
 import net.youapps.transport.toJavaDate
 import net.youapps.transport.toZonedDateTime
 import java.time.ZonedDateTime
+import java.time.temporal.ChronoUnit
 import java.util.Date
+import kotlin.collections.orEmpty
 
 class PTETransportProvider(private val network: NetworkProvider) : TransportProvider {
     override suspend fun queryStations(query: String): List<Location> {
@@ -97,38 +99,15 @@ class PTETransportProvider(private val network: NetworkProvider) : TransportProv
             )
         }
         val trips = response.trips.orEmpty().map { trip ->
+            val legs = trip.legs.map { it.toTripLeg() }.toMutableList()
+            fillWithAndFixTransferLegs(legs)
+
             Trip(
                 id = trip.id,
                 from = trip.from.toLocation(),
                 to = trip.to.toLocation(),
                 duration = trip.duration,
-                legs = trip.legs.map { leg ->
-                    return@map when (leg) {
-                        is de.schildbach.pte.dto.Trip.Public -> {
-                            TripLeg.Public(
-                                line = leg.line.toTransportLine(leg.destination),
-                                arrival = leg.arrivalStop.toStop(),
-                                departure = leg.departureStop.toStop(),
-                                intermediateStops = leg.intermediateStops?.map { it.toStop() }
-                                    .orEmpty(),
-                                path = leg.toCoordinateList(),
-                                message = leg.message
-                            )
-                        }
-
-                        is de.schildbach.pte.dto.Trip.Individual -> {
-                            TripLeg.Individual(
-                                path = leg.toCoordinateList(),
-                                distance = leg.distance,
-                                arrival = leg.arrival.toStop(leg.arrivalTime),
-                                departure = leg.departure.toStop(leg.departureTime),
-                                type = IndividualType.valueOf(leg.type.name)
-                            )
-                        }
-
-                        else -> throw IllegalArgumentException("unsupported trip leg")
-                    }
-                }
+                legs = legs
             )
         }
 
@@ -139,6 +118,79 @@ class PTETransportProvider(private val network: NetworkProvider) : TransportProv
         )
     }
 
+    private fun de.schildbach.pte.dto.Trip.Leg.toTripLeg() = when (this) {
+        is de.schildbach.pte.dto.Trip.Public -> {
+            TripLeg.Public(
+                line = line.toTransportLine(destination),
+                arrival = arrivalStop.toStop(),
+                departure = departureStop.toStop(),
+                intermediateStops = intermediateStops?.map { it.toStop() }
+                    .orEmpty(),
+                path = toCoordinateList(),
+                message = message
+            )
+        }
+
+        is de.schildbach.pte.dto.Trip.Individual -> {
+            TripLeg.Individual(
+                path = toCoordinateList(),
+                distance = distance,
+                arrival = arrival.toStop(arrivalTime),
+                departure = departure.toStop(departureTime),
+                type = IndividualType.valueOf(type.name)
+            )
+        }
+
+        else -> throw IllegalArgumentException("unsupported trip leg")
+    }
+
+    /**
+     * Add individual trip legs for each platform change.
+     *
+     * E.g., if there's a trip leg that arrives at platform 8 at 18:30, and the next trip leg starts
+     * at platform 3 at 18:52, this inserts a individual trip leg with a duration of 22min.
+     */
+    private fun fillWithAndFixTransferLegs(legs: MutableList<TripLeg>) {
+        var i = 0
+        // we have to move by index here because we modify `legs` inside the loop
+        // i.e., otherwise we would modify the iterator while reading it, which would cause undefined
+        // behavior
+        while (i < legs.size - 1) {
+            val leg = legs[i]
+            val nextLeg = legs[i + 1]
+
+            if (leg is TripLeg.Public && nextLeg is TripLeg.Public) {
+                legs.add(
+                    i + 1, TripLeg.Individual(
+                        departure = leg.arrival,
+                        arrival = nextLeg.departure,
+                        type = IndividualType.TRANSFER
+                    )
+                )
+                i++
+            } else if (leg is TripLeg.Individual) {
+                // calculate approximated duration of this transfer (= end - start)
+                // and set start and end time to the ones of the previous/next trip leg
+                // needed because otherwise durationMillis would always equal approxDurationMillis
+                val approxDuration = ChronoUnit.MILLIS.between(
+                    leg.departure.departureTime.predictedOrPlanned,
+                    leg.arrival.arrivalTime.predictedOrPlanned,
+                )
+                val startTime =
+                    legs.getOrNull(i - 1)?.arrival?.arrivalTime ?: leg.departure.departureTime
+                val endTime = nextLeg.departure.departureTime
+
+                legs[i] = leg.copy(
+                    approxDurationMillis = approxDuration,
+                    departure = leg.departure.copy(departureTime = startTime),
+                    arrival = leg.arrival.copy(arrivalTime = endTime)
+                )
+            }
+
+            i++
+        }
+    }
+
     private fun de.schildbach.pte.dto.Location.toLocation() = Location(
         id = id,
         name = uniqueShortName(),

app/src/main/java/net/youapps/transport/data/transport/model/Trip.kt

@@ -39,11 +39,12 @@ sealed class TripLeg {
     ): TripLeg()
 
     data class Individual(
+        val type: IndividualType,
         override val departure: Stop,
         override val arrival: Stop,
-        val distance: Int,
-        override val path: List<GeoCoordinate>?,
-        val type: IndividualType
+        val distance: Int? = null,
+        override val path: List<GeoCoordinate>? = null,
+        val approxDurationMillis: Long? = null
     ): TripLeg()
 
     abstract val departure: Stop

app/src/main/java/net/youapps/transport/screens/TripDetailsScreen.kt

@@ -100,49 +100,17 @@ fun TripDetailsScreen(
                             TripLegPublic(leg) { location ->
                                 navController.navigate(NavRoutes.DeparturesFromLocation(location))
                             }
-
-                            // display change time between current and next trip leg
-                            tripLegs.getOrNull(index + 1)?.let { nextLeg ->
-                                if (nextLeg is TripLeg.Public) {
-                                    HorizontalDivider()
-
-                                    val changeTimeMillis = remember {
-                                        TextUtils.dateDifferenceMillis(
-                                            leg.arrival.arrivalTime.predictedOrPlanned
-                                                ?: return@remember null,
-                                            nextLeg.departure.departureTime.predictedOrPlanned
-                                                ?: return@remember null
-                                        )
-                                    }
-
-                                    TripTransfer(changeTimeMillis)
-                                }
-                            }
                         }
 
                         is TripLeg.Individual -> {
                             val isTransferLeg =
                                 leg.type !in arrayOf(IndividualType.BIKE, IndividualType.CAR)
-                            if (!isTransferLeg) {
+                            if (isTransferLeg) {
+                                TripTransfer(leg.durationMillis, leg.distance, leg.approxDurationMillis)
+                            } else {
                                 TripLegIndividual(leg) { location ->
                                     navController.navigate(NavRoutes.DeparturesFromLocation(location))
                                 }
-                            } else {
-                                // display change time between current and next trip leg
-                                tripLegs.getOrNull(index + 1)?.let { nextLeg ->
-                                    HorizontalDivider()
-
-                                    val changeTimeMillis = remember {
-                                        TextUtils.dateDifferenceMillis(
-                                            leg.arrival.arrivalTime.predictedOrPlanned
-                                                ?: return@remember null,
-                                            nextLeg.departure.departureTime.predictedOrPlanned
-                                                ?: return@remember null
-                                        )
-                                    }
-
-                                    TripTransfer(changeTimeMillis, leg.distance, leg.durationMillis)
-                                }
                             }
                         }
                     }