vk-1024-hybrid-router: added thread safety to NavigationRouter. Update route refresh callbacks to match outcome RouteResponse object.

Author: Udumft

Sources/MapboxCoreNavigation/CacheHandlerFactory.swift

@@ -1,7 +1,7 @@
 
 import MapboxNavigationNative
 
-struct CacheHandlerFactory {
+enum CacheHandlerFactory {
 
     private static var key: (TilesConfig, ConfigHandle, HistoryRecorderHandle?)? = nil
     private static var cachedHandle: CacheHandle!

Sources/MapboxCoreNavigation/NavigationRouter.swift

@@ -35,9 +35,10 @@ public class NavigationRouter {
     }
 
     public private(set) var activeRequests: [RequestId : RoutingRequest] = [:]
-    public private(set) var source: RouterSource
-    private var router: RouterInterface
-    private var settings: NavigationSettings
+    private let requestsLock = NSLock()
+    public let source: RouterSource
+    private let router: RouterInterface
+    private let settings: NavigationSettings
 
     public init(_ source: RouterSource = .hybrid, settings: NavigationSettings = .shared) {
         self.source = source
@@ -55,15 +56,28 @@ public class NavigationRouter {
     }
 
     fileprivate func finish(request id: RequestId) {
+        requestsLock.lock(); defer {
+            requestsLock.unlock()
+        }
+        
         router.cancelRequest(forToken: id)
         activeRequests[id] = nil
         print(">>> finished id: \(id)")
     }
 
+    func complete(requestId: RequestId, with result: @escaping () -> Void) {
+        DispatchQueue.main.async {
+            result()
+            self.finish(request: requestId)
+        }
+    }
+
+    
     public func doRequest<ResponseType: Codable>(options: DirectionsOptions,
                                                  completion: @escaping (Result<ResponseType, DirectionsError>) -> Void) -> RequestId {
         let directionsUri = settings.directions.url(forCalculating: options).absoluteString
         var requestId: RequestId!
+        requestsLock.lock()
         requestId = router.getRouteForDirectionsUri(directionsUri) { [weak self] (result, _) in // mind exposing response origin?
             guard let self = self else { return }
 
@@ -75,22 +89,21 @@ public class NavigationRouter {
 
             if let jsonData = data,
                let response = try? decoder.decode(ResponseType.self, from: jsonData) {
-                DispatchQueue.main.async {
+                self.complete(requestId: requestId) {
                     completion(.success(response))
-                    self.finish(request: requestId)
                 }
             } else {
-                DispatchQueue.main.async {
+                self.complete(requestId: requestId) {
                     completion(.failure(.unknown(response: nil,
                                                  underlying: result.error as? Error,
                                                  code: nil,
                                                  message: nil)))
-                    self.finish(request: requestId)
                 }
             }
         }
         activeRequests[requestId] = .init(id: requestId,
                                           router: self)
+        requestsLock.unlock()
         print(">>> started id: \(requestId)")
         return requestId
     }
@@ -116,9 +129,8 @@ public class NavigationRouter {
 
     @discardableResult public func refreshRoute(indexedRouteResponse: IndexedRouteResponse,
                                                 fromLegAtIndex startLegIndex: UInt32 = 0,
-                                                completionHandler: @escaping Directions.RouteRefreshCompletionHandler) -> RequestId {
+                                                completionHandler: @escaping Directions.RouteCompletionHandler) -> RequestId {
         guard case let .route(routeOptions) = indexedRouteResponse.routeResponse.options,
-              let route = indexedRouteResponse.selectedRoute,
               let responseIdentifier = indexedRouteResponse.routeResponse.identifier else {
             preconditionFailure("Invalid route data passed for refreshing.")
         }
@@ -128,52 +140,73 @@ public class NavigationRouter {
 
         let routeIndex = UInt32(indexedRouteResponse.routeIndex)
 
-        guard let routeData = try? encoder.encode(route),
+        guard
+            let routeData = try? encoder.encode(indexedRouteResponse.routeResponse),
               let routeJSONString = String(data: routeData, encoding: .utf8) else {
             preconditionFailure("Could not serialize route data for refreshing.")
         }
 
         var requestId: RequestId!
-        requestId = router.getRouteRefresh(for: RouteRefreshOptions(requestId: responseIdentifier,
-                                                                    routeIndex: routeIndex,
-                                                                    legIndex: startLegIndex),
+        let refreshOptions = RouteRefreshOptions(requestId: responseIdentifier,
+                                                 routeIndex: routeIndex,
+                                                 legIndex: startLegIndex,
+                                                 routingProfile: routeOptions.profileIdentifier.nativeProfile)
+        requestsLock.lock()
+        requestId = router.getRouteRefresh(for: refreshOptions,
                                            route: routeJSONString) { [weak self] result, _ in
             guard let self = self else { return }
             // change to route deserialization
             do {
                 let json = result.value as? String
                 guard let data = json?.data(using: .utf8) else {
-                    DispatchQueue.main.async {
-                        completionHandler(self.settings.directions.credentials, .failure(.noData))
-                        self.finish(request: requestId)
+                    self.complete(requestId: requestId) {
+                        let session = (options: routeOptions as DirectionsOptions,
+                                       credentials: self.settings.directions.credentials)
+                        completionHandler(session, .failure(.noData))
                     }
                     return
                 }
                 let decoder = JSONDecoder()
-                decoder.userInfo = [
-                    .responseIdentifier: responseIdentifier,
-                    .routeIndex: routeIndex,
-                    .startLegIndex: startLegIndex,
-                    .credentials: self.settings.directions.credentials,
-                ]
+                decoder.userInfo = [.options: routeOptions,
+                                    .credentials: self.settings.directions.credentials]
 
-                let result = try decoder.decode(RouteRefreshResponse.self, from: data)
+                let result = try decoder.decode(RouteResponse.self, from: data)
 
-                DispatchQueue.main.async {
-                    completionHandler(self.settings.directions.credentials, .success(result))
-                    self.finish(request: requestId)
+                self.complete(requestId: requestId) {
+                    let session = (options: routeOptions as DirectionsOptions,
+                                   credentials: self.settings.directions.credentials)
+                    completionHandler(session, .success(result))
                 }
             } catch {
-                DispatchQueue.main.async {
+                self.complete(requestId: requestId) {
+                    let session = (options: routeOptions as DirectionsOptions,
+                                   credentials: self.settings.directions.credentials)
                     let bailError = DirectionsError(code: nil, message: nil, response: nil, underlyingError: error)
-                    completionHandler(self.settings.directions.credentials, .failure(bailError))
-                    self.finish(request: requestId)
+                    completionHandler(session, .failure(bailError))
                 }
             }
         }
         activeRequests[requestId] = .init(id: requestId,
                                           router: self)
+        requestsLock.unlock()
         print(">>> started refresh id: \(requestId)")
         return requestId
     }
 }
+
+extension DirectionsProfileIdentifier {
+    var nativeProfile: RoutingProfile {
+        switch self {
+        case .automobile:
+            return .driving
+        case .automobileAvoidingTraffic:
+            return .drivingTraffic
+        case .cycling:
+            return .cycling
+        case .walking:
+            return .walking
+        default:
+            return .driving
+        }
+    }
+}

Sources/MapboxCoreNavigation/RouteProgress.swift

@@ -290,10 +290,10 @@ open class RouteProgress: Codable {
     }
 
     /**
-     Updates the current route with attributes from the given skeletal route.
+     Updates the current route with a refreshed one.
      */
-    public func refreshRoute(with refreshedRoute: RefreshedRoute, at location: CLLocation) {
-        route.refreshLegAttributes(from: refreshedRoute)
+    func refreshRoute(with refreshedRoute: Route, at location: CLLocation) {
+        route = refreshedRoute
         currentLegProgress = RouteLegProgress(leg: route.legs[legIndex],
                                               stepIndex: currentLegProgress.stepIndex,
                                               spokenInstructionIndex: currentLegProgress.currentStepProgress.spokenInstructionIndex)

Sources/MapboxCoreNavigation/Router.swift

@@ -213,8 +213,8 @@ extension InternalRouter where Self: Router {
             guard case let .success(response) = result, let self = self else {
                 return
             }
-            
-            self.routeProgress.refreshRoute(with: response.route, at: location)
+            self.indexedRouteResponse = .init(routeResponse: response, routeIndex: self.indexedRouteResponse.routeIndex)
+            self.routeProgress.refreshRoute(with: self.indexedRouteResponse.selectedRoute!, at: location)
 
             var userInfo = [RouteController.NotificationUserInfoKey: Any]()
             userInfo[.routeProgressKey] = self.routeProgress