Add shape index parameter to route refresh (#4111)

* Add shape index parameter to route refresh

* Pass through leg shape index

* Use refresh with current geometry index

* pad-geometry-index: Added RouteProgress tests; Code docs appended.

* pad-geometry-index: CHANGELOG updated; Podfile.lock committed.

* pad-geometry-indexL unit tests compilation  fixed

* pad-geometry-index: build warning fixed.

* Adjust naming

* Add more docs

Co-authored-by: udumft <[email protected]>

Author: chezzdev

CHANGELOG.md

@@ -21,6 +21,11 @@
 * `NavigationMapView.removeAlternativeRoutes()` and `NavigationMapView.removeContinuousAlternativeRoutesDurations()` were made public to provide a way to remove previously shown alternative routes and alternative routes duration annotations, respectively. ([#4134](https://github.com/mapbox/mapbox-navigation-ios/pull/4134))
 * Fixed an issue where tapping on a route duration annotation that overlaps a different route would cause the wrong route to be passed into `NavigationMapViewDelegate.navigationMapView(_:didSelect:)` or `NavigationMapViewDelegate.navigationMapView(_:didSelect:)`. ([#4133](https://github.com/mapbox/mapbox-navigation-ios/pull/4133))
 
+### Routing
+
+* Route refreshing now respects current user progress on a leg to reduce update size and improve updating longer routes. ([#4111](https://github.com/mapbox/mapbox-navigation-ios/pull/4111))
+* Added `RoutingProvider.refreshRoute(indexedRouteResponse:fromLegAtIndex:routeShapeIndex:legShapeIndex:completionHandler:)` to request a refresh starting from specified shape index. Updated `RouteLegProgress` and `RouteProgress` initializers to include shape indices, and added `RouteProgress.refreshRoute(with:at:legIndex:legShapeIndex:)` to apply partial route refresh. ([#4111](https://github.com/mapbox/mapbox-navigation-ios/pull/4111))
+
 ### Banners and guidance instructions
 
 * Added replacement for `VisualInstruction.maneuverImageSet(side:)` method to generate a maneuver image on iOS 13 and above. ([#4161](https://github.com/mapbox/mapbox-navigation-ios/pull/4161))

Sources/MapboxCoreNavigation/Directions+RoutingProvider.swift

@@ -31,8 +31,24 @@ extension Directions: RoutingProvider {
     @discardableResult public func calculateRoutes(options: MatchOptions, completionHandler: @escaping MatchCompletionHandler) -> NavigationProviderRequest? {
         return calculate(options, completionHandler: completionHandler)
     }
-    
+
     @discardableResult public func refreshRoute(indexedRouteResponse: IndexedRouteResponse, fromLegAtIndex: UInt32, completionHandler: @escaping RouteCompletionHandler) -> NavigationProviderRequest? {
+        _refreshRoute(indexedRouteResponse: indexedRouteResponse,
+                      fromLegAtIndex: Int(fromLegAtIndex),
+                      currentRouteShapeIndex: nil,
+                      currentLegShapeIndex: nil,
+                      completionHandler: completionHandler)
+    }
+
+    @discardableResult public func refreshRoute(indexedRouteResponse: IndexedRouteResponse, fromLegAtIndex: UInt32, currentRouteShapeIndex: Int, currentLegShapeIndex: Int, completionHandler: @escaping RouteCompletionHandler) -> NavigationProviderRequest? {
+        _refreshRoute(indexedRouteResponse: indexedRouteResponse,
+                      fromLegAtIndex: Int(fromLegAtIndex),
+                      currentRouteShapeIndex: currentRouteShapeIndex,
+                      currentLegShapeIndex: currentLegShapeIndex,
+                      completionHandler: completionHandler)
+    }
+    
+    private func _refreshRoute(indexedRouteResponse: IndexedRouteResponse, fromLegAtIndex startLegIndex: Int, currentRouteShapeIndex: Int?, currentLegShapeIndex: Int?, completionHandler: @escaping RouteCompletionHandler) -> NavigationProviderRequest? {
         guard case let .route(routeOptions) = indexedRouteResponse.routeResponse.options else {
             preconditionFailure("Invalid route data passed for refreshing. Expected `RouteResponse` containing `.route` `ResponseOptions` but got `.match`.")
         }
@@ -46,33 +62,54 @@ extension Directions: RoutingProvider {
             }
             return nil
         }
-        
-        return refreshRoute(responseIdentifier: responseIdentifier,
-                            routeIndex: indexedRouteResponse.routeIndex,
-                            fromLegAtIndex: Int(fromLegAtIndex),
-                            completionHandler: { credentials, result in
-                                switch result {
-                                case .failure(let error):
-                                    DispatchQueue.main.async {
-                                        completionHandler(session, .failure(error))
-                                    }
-                                case .success(let routeRefreshResponse):
-                                    DispatchQueue.global().async {
-                                        do {
-                                            let routeResponse = try indexedRouteResponse.routeResponse.copy(with: routeOptions)
-                                            routeResponse.routes?[indexedRouteResponse.routeIndex].refreshLegAttributes(from: routeRefreshResponse.route)
-                                            routeResponse.routes?[indexedRouteResponse.routeIndex].refreshLegIncidents(from: routeRefreshResponse.route)
-                                            DispatchQueue.main.async {
-                                                completionHandler(session, .success(routeResponse))
-                                            }
-                                        } catch {
-                                            DispatchQueue.main.async {
-                                                completionHandler(session, .failure(.unknown(response: nil, underlying: error, code: nil, message: nil)))
-                                            }
-                                        }
-                                    }
-                                }
-                            })
+
+        let completionHandler: RouteRefreshCompletionHandler = { credentials, result in
+            switch result {
+            case .failure(let error):
+                DispatchQueue.main.async {
+                    completionHandler(session, .failure(error))
+                }
+            case .success(let routeRefreshResponse):
+                DispatchQueue.global().async {
+                    do {
+                        let routeResponse = try indexedRouteResponse.routeResponse.copy(with: routeOptions)
+                        let route = routeResponse.routes?[indexedRouteResponse.routeIndex]
+                        if let currentLegShapeIndex = currentLegShapeIndex {
+                            route?.refreshLegAttributes(from: routeRefreshResponse.route,
+                                                        legIndex: startLegIndex,
+                                                        legShapeIndex: currentLegShapeIndex)
+                            route?.refreshLegIncidents(from: routeRefreshResponse.route,
+                                                       legIndex: startLegIndex,
+                                                       legShapeIndex: currentLegShapeIndex)
+                        } else {
+                            route?.refreshLegAttributes(from: routeRefreshResponse.route)
+                            route?.refreshLegIncidents(from: routeRefreshResponse.route)
+                        }
+
+                        DispatchQueue.main.async {
+                            completionHandler(session, .success(routeResponse))
+                        }
+                    } catch {
+                        DispatchQueue.main.async {
+                            completionHandler(session, .failure(.unknown(response: nil, underlying: error, code: nil, message: nil)))
+                        }
+                    }
+                }
+            }
+        }
+
+        if let currentRouteShapeIndex = currentRouteShapeIndex {
+            return refreshRoute(responseIdentifier: responseIdentifier,
+                                routeIndex: indexedRouteResponse.routeIndex,
+                                fromLegAtIndex: startLegIndex,
+                                currentRouteShapeIndex: currentRouteShapeIndex,
+                                completionHandler: completionHandler)
+        } else {
+            return refreshRoute(responseIdentifier: responseIdentifier,
+                                routeIndex: indexedRouteResponse.routeIndex,
+                                fromLegAtIndex: startLegIndex,
+                                completionHandler: completionHandler)
+        }
     }
 }
 

Sources/MapboxCoreNavigation/MapboxRoutingProvider.swift

@@ -323,6 +323,30 @@ public class MapboxRoutingProvider: RoutingProvider {
     @discardableResult public func refreshRoute(indexedRouteResponse: IndexedRouteResponse,
                                                 fromLegAtIndex startLegIndex: UInt32 = 0,
                                                 completionHandler: @escaping Directions.RouteCompletionHandler) -> NavigationProviderRequest? {
+        _refreshRoute(indexedRouteResponse: indexedRouteResponse,
+                     fromLegAtIndex: startLegIndex,
+                     currentRouteShapeIndex: nil,
+                     currentLegShapeIndex: nil,
+                     completionHandler: completionHandler)
+    }
+
+    @discardableResult public func refreshRoute(indexedRouteResponse: IndexedRouteResponse,
+                                                fromLegAtIndex startLegIndex: UInt32,
+                                                currentRouteShapeIndex: Int,
+                                                currentLegShapeIndex: Int,
+                                                completionHandler: @escaping Directions.RouteCompletionHandler) -> NavigationProviderRequest? {
+        _refreshRoute(indexedRouteResponse: indexedRouteResponse,
+                     fromLegAtIndex: startLegIndex,
+                     currentRouteShapeIndex: currentRouteShapeIndex,
+                     currentLegShapeIndex: currentLegShapeIndex,
+                     completionHandler: completionHandler)
+    }
+
+    private func _refreshRoute(indexedRouteResponse: IndexedRouteResponse,
+                              fromLegAtIndex startLegIndex: UInt32,
+                              currentRouteShapeIndex: Int? = nil,
+                              currentLegShapeIndex: Int? = nil,
+                              completionHandler: @escaping Directions.RouteCompletionHandler) -> NavigationProviderRequest? {
         guard case let .route(routeOptions) = indexedRouteResponse.routeResponse.options else {
             preconditionFailure("Invalid route data passed for refreshing. Expected `RouteResponse` containing `.route` `ResponseOptions` but got `.match`.")
         }
@@ -344,8 +368,8 @@ public class MapboxRoutingProvider: RoutingProvider {
                                                  routeIndex: routeIndex,
                                                  legIndex: startLegIndex,
                                                  routingProfile: routeOptions.profileIdentifier.nativeProfile,
-                                                 currentRouteGeometryIndex: nil)
-        
+                                                 currentRouteGeometryIndex: currentRouteShapeIndex.map { NSNumber(value: $0) })
+
         requestId = router.getRouteRefresh(for: refreshOptions, callback: { [weak self] result, _ in
             guard let self = self else { return }
 
@@ -364,8 +388,19 @@ public class MapboxRoutingProvider: RoutingProvider {
                     DispatchQueue.global().async {
                         do {
                             let routeResponse = try indexedRouteResponse.routeResponse.copy(with: routeOptions)
-                            routeResponse.routes?[indexedRouteResponse.routeIndex].refreshLegAttributes(from: routeRefreshResponse.route)
-                            routeResponse.routes?[indexedRouteResponse.routeIndex].refreshLegIncidents(from: routeRefreshResponse.route)
+                            let route = routeResponse.routes?[indexedRouteResponse.routeIndex]
+                            if let currentLegShapeIndex = currentLegShapeIndex {
+                                route?.refreshLegAttributes(from: routeRefreshResponse.route,
+                                                            legIndex: Int(startLegIndex),
+                                                            legShapeIndex: currentLegShapeIndex)
+                                route?.refreshLegIncidents(from: routeRefreshResponse.route,
+                                                           legIndex: Int(startLegIndex),
+                                                           legShapeIndex: currentLegShapeIndex)
+                            } else {
+                                route?.refreshLegAttributes(from: routeRefreshResponse.route)
+                                route?.refreshLegIncidents(from: routeRefreshResponse.route)
+                            }
+
                             DispatchQueue.main.async {
                                 completionHandler(session, .success(routeResponse))
                             }

Sources/MapboxCoreNavigation/RouteController.swift

@@ -389,7 +389,8 @@ open class RouteController: NSObject {
                with: snappedLocation,
                rawLocation: rawLocation,
                upcomingRouteAlerts: status.upcomingRouteAlerts,
-               mapMatchingResult: MapMatchingResult(status: status))
+               mapMatchingResult: MapMatchingResult(status: status),
+               routeShapeIndex: Int(status.geometryIndex))
 
         updateIndexes(status: status, progress: routeProgress)
         updateRouteLegProgress(status: status)
@@ -520,6 +521,8 @@ open class RouteController: NSObject {
             preconditionFailure("Route legs used for navigation must have destinations")
         }
         let remainingVoiceInstructions = legProgress.currentStepProgress.remainingSpokenInstructions ?? []
+
+        legProgress.shapeIndex = Int(status.shapeIndex)
 
         // We are at least at the "You will arrive" instruction
         if legProgress.remainingSteps.count <= 2 && remainingVoiceInstructions.count <= 2 {
@@ -543,9 +546,10 @@ open class RouteController: NSObject {
         }
     }
 
-    private func update(progress: RouteProgress, with location: CLLocation, rawLocation: CLLocation, upcomingRouteAlerts routeAlerts: [UpcomingRouteAlert], mapMatchingResult: MapMatchingResult) {
+    private func update(progress: RouteProgress, with location: CLLocation, rawLocation: CLLocation, upcomingRouteAlerts routeAlerts: [UpcomingRouteAlert], mapMatchingResult: MapMatchingResult, routeShapeIndex: Int) {
         progress.updateDistanceTraveled(with: location)
         progress.upcomingRouteAlerts = routeAlerts.map { RouteAlert($0) }
+        progress.shapeIndex = routeShapeIndex
 
         //Fire the delegate method
         delegate?.router(self, didUpdate: progress, with: location, rawLocation: rawLocation)

Sources/MapboxCoreNavigation/RouteLegProgress.swift

@@ -175,18 +175,25 @@ open class RouteLegProgress: Codable {
             return speedLimit
         }
     }
+
+    /**
+     Index relative to leg shape, representing the point the user is currently located at.
+     */
+    public internal(set) var shapeIndex: Int
 
     /**
      Intializes a new `RouteLegProgress`.
 
      - parameter leg: Leg on a `Route`.
      - parameter stepIndex: Current step the user is on.
+     - parameter shapeIndex: Index relative to leg shape, representing the point the user is currently located at.
      */
-    public init(leg: RouteLeg, stepIndex: Int = 0, spokenInstructionIndex: Int = 0) {
+    public init(leg: RouteLeg, stepIndex: Int = 0, spokenInstructionIndex: Int = 0, shapeIndex: Int = 0) {
         precondition(leg.steps.indices.contains(stepIndex), "It's not possible to set the stepIndex: \(stepIndex) when it's higher than steps count \(leg.steps.count) or not included.")
 
         self.leg = leg
         self.stepIndex = stepIndex
+        self.shapeIndex = shapeIndex
 
         currentStepProgress = RouteStepProgress(step: leg.steps[stepIndex], spokenInstructionIndex: spokenInstructionIndex)
     }
@@ -247,5 +254,6 @@ open class RouteLegProgress: Codable {
         case stepIndex
         case userHasArrivedAtWaypoint
         case currentStepProgress
+        case shapeIndex
     }
 }

Sources/MapboxCoreNavigation/RouteProgress.swift

@@ -15,12 +15,15 @@ open class RouteProgress: Codable {
      - parameter route: The route to follow.
      - parameter options: The route options that were attached to the route request.
      - parameter legIndex: Zero-based index indicating the current leg the user is on.
+     - parameter routeShapeIndex: Index relative to route shape, representing the point the user is currently located at.
+     - parameter legShapeIndex: Index relative to leg shape, representing the point the user is currently located at.
      */
-    public init(route: Route, options: RouteOptions, legIndex: Int = 0, spokenInstructionIndex: Int = 0) {
+    public init(route: Route, options: RouteOptions, legIndex: Int = 0, spokenInstructionIndex: Int = 0, routeShapeIndex: Int = 0, legShapeIndex: Int = 0) {
         self.route = route
         self.routeOptions = options
         self.legIndex = legIndex
-        self.currentLegProgress = RouteLegProgress(leg: route.legs[legIndex], stepIndex: 0, spokenInstructionIndex: spokenInstructionIndex)
+        self.shapeIndex = routeShapeIndex
+        self.currentLegProgress = RouteLegProgress(leg: route.legs[legIndex], stepIndex: 0, spokenInstructionIndex: spokenInstructionIndex, shapeIndex: legShapeIndex)
 
         self.calculateLegsCongestion()
     }
@@ -144,13 +147,28 @@ open class RouteProgress: Codable {
     public func refreshRoute(with refreshedRoute: RouteRefreshSource, at location: CLLocation) {
         route.refreshLegAttributes(from: refreshedRoute)
         route.refreshLegIncidents(from: refreshedRoute)
+        commonRefreshRoute(at: location)
+    }
+
+    public func refreshRoute(with refreshedRoute: RouteRefreshSource, at location: CLLocation, legIndex: Int, legShapeIndex: Int) {
+        route.refreshLegAttributes(from: refreshedRoute, legIndex: legIndex, legShapeIndex: legShapeIndex)
+        route.refreshLegIncidents(from: refreshedRoute, legIndex: legIndex, legShapeIndex: legShapeIndex)
+        commonRefreshRoute(at: location)
+    }
+
+    private func commonRefreshRoute(at location: CLLocation) {
         currentLegProgress = RouteLegProgress(leg: route.legs[legIndex],
                                               stepIndex: currentLegProgress.stepIndex,
                                               spokenInstructionIndex: currentLegProgress.currentStepProgress.spokenInstructionIndex)
         calculateLegsCongestion()
         updateDistanceTraveled(with: location)
     }
-    
+
+    /**
+     Index relative to route shape, representing the point the user is currently located at.
+     */
+    public internal(set) var shapeIndex: Int
+
     /**
      Increments the progress according to new location specified.
      - parameter location: Updated user location.
@@ -353,6 +371,7 @@ open class RouteProgress: Codable {
         case routeOptions
         case legIndex
         case currentLegProgress
+        case shapeIndex
     }
 
     required public init(from decoder: Decoder) throws {
@@ -363,6 +382,7 @@ open class RouteProgress: Codable {
         self.routeOptions = try container.decode(RouteOptions.self, forKey: .routeOptions)
         self.legIndex = try container.decode(Int.self, forKey: .legIndex)
         self.currentLegProgress = try container.decode(RouteLegProgress.self, forKey: .currentLegProgress)
+        self.shapeIndex = try container.decode(Int.self, forKey: .shapeIndex)
 
         calculateLegsCongestion()
     }
@@ -374,5 +394,6 @@ open class RouteProgress: Codable {
         try container.encode(routeOptions, forKey: .routeOptions)
         try container.encode(legIndex, forKey: .legIndex)
         try container.encode(currentLegProgress, forKey: .currentLegProgress)
+        try container.encode(shapeIndex, forKey: .shapeIndex)
     }
 }