NAVIOS-2134: Keep billing session at reroutes (#8628)

* NAVIOS-2134: Keep billing session at reroutes

* Add billing session tests for setRoutes during active guidance

* Move API check inside shouldStartNewBillingSession

Author: roopepal

Sources/MapboxNavigationCore/Billing/BillingHandler.swift

@@ -413,8 +413,27 @@ final class BillingHandler: @unchecked Sendable {
         }
     }
 
-    func shouldStartNewBillingSession(for newRoute: Route, remainingWaypoints: [Waypoint]) -> Bool {
-        let newRouteWaypoints = newRoute.legs.compactMap(\.destination)
+    func shouldStartNewBillingSession(
+        for newNavigationRoutes: NavigationRoutes,
+        currentRouteProgress: RouteProgressState?,
+        reason: MapboxNavigator.SetRouteReason
+    ) -> Bool {
+        var newRouteWaypoints = newNavigationRoutes.mainRoute.route.legs.compactMap(\.destination)
+        var remainingWaypoints = currentRouteProgress?.routeProgress.remainingWaypoints ?? []
+
+        // Reroutes with RerouteStrategyForMatchRoute.navigateToFinalDestination may cause
+        // the number of waypoints to change, but should not start a new billing session
+        // as long as the final destination stays the same
+        let oldApi = currentRouteProgress?.routeProgress.navigationRoutes.mapboxApi
+        let newApi = newNavigationRoutes.mapboxApi
+        let checkOnlyLastWaypoint = reason == .reroute
+            && oldApi == .mapMatching
+            && newApi == .directions
+
+        if checkOnlyLastWaypoint {
+            newRouteWaypoints = newRouteWaypoints.suffix(1)
+            remainingWaypoints = remainingWaypoints.suffix(1)
+        }
 
         guard !newRouteWaypoints.isEmpty else {
             return false // Don't need to bil for routes without waypoints

Sources/MapboxNavigationCore/Navigator/MapboxNavigator.swift

@@ -221,7 +221,7 @@ final class MapboxNavigator: @unchecked Sendable {
 
     @MainActor
     func setRoutes(navigationRoutes: NavigationRoutes, startLegIndex: Int, reason: SetRouteReason) {
-        verifyActiveGuidanceBillingSession(for: navigationRoutes)
+        verifyActiveGuidanceBillingSession(for: navigationRoutes, reason: reason)
 
         guard let sessionUUID else {
             Log.error(
@@ -518,7 +518,10 @@ final class MapboxNavigator: @unchecked Sendable {
     }
 
     @MainActor
-    private func verifyActiveGuidanceBillingSession(for navigationRoutes: NavigationRoutes) {
+    private func verifyActiveGuidanceBillingSession(
+        for navigationRoutes: NavigationRoutes,
+        reason: SetRouteReason
+    ) {
         if let sessionUUID,
            let sessionType = billingHandler.sessionType(uuid: sessionUUID)
         {
@@ -528,8 +531,9 @@ final class MapboxNavigator: @unchecked Sendable {
                 beginNewSession(of: .activeGuidance)
             case .activeGuidance:
                 if billingHandler.shouldStartNewBillingSession(
-                    for: navigationRoutes.mainRoute.route,
-                    remainingWaypoints: currentRouteProgress?.routeProgress.remainingWaypoints ?? []
+                    for: navigationRoutes,
+                    currentRouteProgress: currentRouteProgress,
+                    reason: reason
                 ) {
                     billingHandler.stopBillingSession(with: sessionUUID)
                     beginNewSession(of: .activeGuidance)

Sources/MapboxNavigationCore/Navigator/NavigationRoutes.swift

@@ -33,6 +33,10 @@ public struct NavigationRoutes: Equatable, @unchecked Sendable {
         mainRoute.nativeRoute.getRouterOrigin() == .customExternal
     }
 
+    var mapboxApi: MapboxAPI {
+        mainRoute.nativeRoute.getMapboxAPI()
+    }
+
     init(routesData: RoutesData) async throws {
         let routeResponse = try await routesData.primaryRoute().convertToDirectionsRouteResponse()
         try self.init(routesData: routesData, routeResponse: routeResponse)

Tests/MapboxNavigationCoreTests/Navigator/MapboxNavigatorTests.swift

@@ -13,6 +13,8 @@ final class MapboxNavigatorTests: TestCase {
     var routeRefreshResult: RouteRefreshResult!
     let timeout: TimeInterval = 0.5
 
+    var routeProgressExpectation: XCTestExpectation?
+
     override func setUp() async throws {
         try? await super.setUp()
 
@@ -44,6 +46,14 @@ final class MapboxNavigatorTests: TestCase {
             movementMonitor: .init()
         )
         navigator = await MapboxNavigator(configuration: coonfiguration)
+
+        routeProgressExpectation = nil
+        navigator.routeProgress
+            .dropFirst()
+            .sink(receiveValue: { [weak self] _ in
+                self?.routeProgressExpectation?.fulfill()
+            })
+            .store(in: &subscriptions)
     }
 
     @MainActor
@@ -258,4 +268,119 @@ final class MapboxNavigatorTests: TestCase {
         await navigator.updateMapMatching(status: status)
         await fulfillment(of: [expectation], timeout: timeout)
     }
+
+    @MainActor
+    func testSetRoutesSimilarNewRouteKeepsSession() async {
+        await startActiveGuidanceAndWaitForRouteProgress(with: oneLegNavigationRoutes())
+        await setRoutesAndWaitForRouteProgress(with: oneLegNavigationRoutes(), reason: .newRoute)
+
+        billingServiceMock.assertEvents([.beginBillingSession(.activeGuidance)])
+    }
+
+    @MainActor
+    func testSetRoutesSimilarRerouteKeepsSession() async {
+        await startActiveGuidanceAndWaitForRouteProgress(with: oneLegNavigationRoutes())
+        await setRoutesAndWaitForRouteProgress(with: oneLegNavigationRoutes(), reason: .reroute)
+
+        billingServiceMock.assertEvents([.beginBillingSession(.activeGuidance)])
+    }
+
+    @MainActor
+    func testSetRoutesDifferentNewRouteBeginsNewSession() async {
+        await startActiveGuidanceAndWaitForRouteProgress(with: twoLegNavigationRoutes())
+        await setRoutesAndWaitForRouteProgress(with: oneLegNavigationRoutes(), reason: .newRoute)
+
+        billingServiceMock.assertEvents([
+            .beginBillingSession(.activeGuidance),
+            .stopBillingSession(.activeGuidance),
+            .beginBillingSession(.activeGuidance),
+        ])
+    }
+
+    @MainActor
+    func testSetRoutesDifferentRerouteBeginsNewSession() async {
+        await startActiveGuidanceAndWaitForRouteProgress(with: twoLegNavigationRoutes())
+        await setRoutesAndWaitForRouteProgress(with: oneLegNavigationRoutes(), reason: .reroute)
+
+        billingServiceMock.assertEvents([
+            .beginBillingSession(.activeGuidance),
+            .stopBillingSession(.activeGuidance),
+            .beginBillingSession(.activeGuidance),
+        ])
+    }
+
+    @MainActor
+    func testSetRoutesMapMatchingRerouteToDirectionsWithSameDestinationKeepsSession() async {
+        // This scenario happens with RerouteStrategyForMatchRoute.navigateToFinalDestination
+        // when there were more than one waypoint remaining before reroute
+        await startActiveGuidanceAndWaitForRouteProgress(with: twoLegNavigationRoutes(mapboxApi: .mapMatching))
+        await setRoutesAndWaitForRouteProgress(with: oneLegNavigationRoutes(mapboxApi: .directions), reason: .reroute)
+
+        billingServiceMock.assertEvents([.beginBillingSession(.activeGuidance)])
+    }
+
+    // MARK: - Helpers
+
+    private func startActiveGuidanceAndWaitForRouteProgress(
+        with navigationRoutes: NavigationRoutes
+    ) async {
+        await navigator.startActiveGuidance(with: navigationRoutes, startLegIndex: 0)
+        routeProgressExpectation = XCTestExpectation(description: "route progress after startActiveGuidance")
+        await fulfillment(of: [routeProgressExpectation!], timeout: timeout)
+    }
+
+    private func setRoutesAndWaitForRouteProgress(
+        with navigationRoutes: NavigationRoutes,
+        reason: MapboxNavigator.SetRouteReason
+    ) async {
+        await navigator.setRoutes(navigationRoutes: navigationRoutes, startLegIndex: 0, reason: reason)
+        routeProgressExpectation = XCTestExpectation(description: "route progress after setRoutes")
+        await fulfillment(of: [routeProgressExpectation!], timeout: timeout)
+    }
+
+    // Three points along California St in San Fransisco
+    private let coordinateA = CLLocationCoordinate2D(latitude: 37.785832, longitude: -122.458148)
+    private let coordinateB = CLLocationCoordinate2D(latitude: 37.787594, longitude: -122.444172)
+    private let coordinateC = CLLocationCoordinate2D(latitude: 37.78927, longitude: -122.430577)
+
+    private func oneLegNavigationRoutes(
+        mapboxApi: MapboxAPI = .directions
+    ) async -> NavigationRoutes {
+        await mockNavigationRoutes(
+            with: [mockLeg(from: coordinateA, to: coordinateC)],
+            mapboxApi: mapboxApi
+        )
+    }
+
+    private func twoLegNavigationRoutes(
+        mapboxApi: MapboxAPI = .directions
+    ) async -> NavigationRoutes {
+        await mockNavigationRoutes(
+            with: [
+                mockLeg(from: coordinateA, to: coordinateB),
+                mockLeg(from: coordinateB, to: coordinateC),
+            ],
+            mapboxApi: mapboxApi
+        )
+    }
+
+    private func mockNavigationRoutes(
+        with legs: [RouteLeg],
+        mapboxApi: MapboxAPI = .directions
+    ) async -> NavigationRoutes {
+        await NavigationRoutes.mock(mainRoute: .mock(
+            route: .mock(legs: legs),
+            nativeRoute: RouteInterfaceMock(mapboxApi: mapboxApi)
+        ))
+    }
+
+    private func mockLeg(
+        from source: CLLocationCoordinate2D,
+        to destination: CLLocationCoordinate2D
+    ) -> RouteLeg {
+        var leg = RouteLeg.mock()
+        leg.source = Waypoint(coordinate: source)
+        leg.destination = Waypoint(coordinate: destination)
+        return leg
+    }
 }