Navigation Service, Part 1

Examples/Objective-C/ViewController.m

@@ -13,7 +13,7 @@ @interface ViewController () <AVSpeechSynthesizerDelegate>
 @property (nonatomic, assign) CLLocationCoordinate2D destination;
 @property (nonatomic) MBDirections *directions;
 @property (nonatomic) MBRoute *route;
-@property (nonatomic) MBRouteController *navigation;
+@property (nonatomic) MBNavigationService *navigation;
 @property (nonatomic) NSLengthFormatter *lengthFormatter;
 @property (nonatomic) AVSpeechSynthesizer *speechSynth;
 @end
@@ -37,7 +37,7 @@ - (void)viewDidDisappear:(BOOL)animated {
     [super viewDidDisappear:animated];
 
     [self suspendNotifications];
-    [self.navigation suspendLocationUpdates];
+    [self.navigation stop];
 }
 
 - (IBAction)didLongPress:(UILongPressGestureRecognizer *)sender {
@@ -121,10 +121,13 @@ -(void)prepareForSegue:(UIStoryboardSegue *)segue sender:(id)sender {
     if ([segue.identifier isEqualToString:@"StartNavigation"]) {
         MBNavigationViewController *controller = (MBNavigationViewController *)[segue destinationViewController];
 
+        MBSimulatedLocationManager *locationManager = [[MBSimulatedLocationManager alloc] initWithRoute:self.route];
+
         controller.directions = [MBDirections sharedDirections];
         controller.route = self.route;
+        controller.navigationService = [[MBNavigationService alloc] initWithRoute:self.route directions:controller.directions locationSource:locationManager eventsManager:nil];
 
-        controller.routeController.locationManager = [[MBSimulatedLocationManager alloc] initWithRoute:self.route];
+
     }
 }
 

Examples/Swift/CustomViewController.swift

@@ -11,7 +11,7 @@ class CustomViewController: UIViewController, MGLMapViewDelegate {
 
     var destination: MGLPointAnnotation!
     let directions = Directions.shared
-    var routeController: RouteController!
+    var navigationService: NavigationService!
     var simulateLocation = false
 
     var userRoute: Route?
@@ -27,7 +27,8 @@ class CustomViewController: UIViewController, MGLMapViewDelegate {
         super.viewDidLoad()
 
         let locationManager = simulateLocation ? SimulatedLocationManager(route: userRoute!) : NavigationLocationManager()
-        routeController = RouteController(along: userRoute!, locationManager: locationManager)
+        navigationService = MapboxNavigationService(route: userRoute!, locationSource: locationManager)
+
 
         mapView.delegate = self
         mapView.compassView.isHidden = true
@@ -36,7 +37,7 @@ class CustomViewController: UIViewController, MGLMapViewDelegate {
         resumeNotifications()
 
         // Start navigation
-        routeController.resume()
+        navigationService.start()
 
         // Center map on user
         mapView.recenterMap()
@@ -55,7 +56,7 @@ class CustomViewController: UIViewController, MGLMapViewDelegate {
     func resumeNotifications() {
         NotificationCenter.default.addObserver(self, selector: #selector(progressDidChange(_ :)), name: .routeControllerProgressDidChange, object: nil)
         NotificationCenter.default.addObserver(self, selector: #selector(rerouted(_:)), name: .routeControllerDidReroute, object: nil)
-        NotificationCenter.default.addObserver(self, selector: #selector(updateInstructionsBanner(notification:)), name: .routeControllerDidPassVisualInstructionPoint, object: routeController)
+        NotificationCenter.default.addObserver(self, selector: #selector(updateInstructionsBanner(notification:)), name: .routeControllerDidPassVisualInstructionPoint, object: navigationService.router)
     }
 
     func suspendNotifications() {
@@ -65,7 +66,7 @@ class CustomViewController: UIViewController, MGLMapViewDelegate {
     }
 
     func mapView(_ mapView: MGLMapView, didFinishLoading style: MGLStyle) {
-        self.mapView.showRoutes([routeController.routeProgress.route])
+        self.mapView.showRoutes([navigationService.route])
     }
 
     // Notifications sent on all location updates
@@ -96,7 +97,7 @@ class CustomViewController: UIViewController, MGLMapViewDelegate {
     // Fired when the user is no longer on the route.
     // Update the route on the map.
     @objc func rerouted(_ notification: NSNotification) {
-        self.mapView.showRoutes([routeController.routeProgress.route])
+        self.mapView.showRoutes([navigationService.route])
     }
 
     @IBAction func cancelButtonPressed(_ sender: Any) {

Examples/Swift/ViewController.swift

@@ -329,11 +329,14 @@ extension ViewController: VoiceControllerDelegate {
 extension ViewController: WaypointConfirmationViewControllerDelegate {
     func confirmationControllerDidConfirm(_ confirmationController: WaypointConfirmationViewController) {
         confirmationController.dismiss(animated: true, completion: {
-            guard let navigationViewController = self.presentedViewController as? NavigationViewController else { return }
-
-            guard navigationViewController.routeController.routeProgress.route.legs.count > navigationViewController.routeController.routeProgress.legIndex + 1 else { return }
-            navigationViewController.routeController.routeProgress.legIndex += 1
-            navigationViewController.routeController.resume()
+            guard let navigationViewController = self.presentedViewController as? NavigationViewController,
+                  let navService = navigationViewController.navigationService else { return }
+
+            let router = navService.router
+            guard router.route.legs.count > router.routeProgress.legIndex + 1 else { return }
+
+            router.routeProgress.legIndex += 1
+            navService.start()
         })
     }
 }
@@ -349,7 +352,7 @@ extension ViewController: NavigationViewControllerDelegate {
         // This type of screen could show information about a destination, pickup/dropoff confirmation, instructions upon arrival, etc.
 
         //If we're not in a "Multiple Stops" demo, show the normal EORVC
-        if navigationViewController.routeController.routeProgress.isFinalLeg {
+        if navigationViewController.navigationService.router.routeProgress.isFinalLeg {
             return true
         }
 

MapboxCoreNavigation/EventDetails.swift

@@ -63,22 +63,21 @@ struct EventDetails: Encodable {
     var newDurationRemaining: TimeInterval?
     var newGeometry: String?
 
-    init(router: Router, session: SessionState) {
-
+    init(dataSource: EventsManagerDataSource, session: SessionState) {
+        coordinate = dataSource.location?.coordinate
         startTimestamp = session.departureTimestamp ?? nil
-        sdkIdentifier = router.usesDefaultUserInterface ? "mapbox-navigation-ui-ios" : "mapbox-navigation-ios"
-        profile = router.routeProgress.route.routeOptions.profileIdentifier.rawValue
-        simulation = router.locationManager is ReplayLocationManager || router.locationManager is SimulatedLocationManager ? true : false
+        sdkIdentifier = dataSource.usesDefaultUserInterface ? "mapbox-navigation-ui-ios" : "mapbox-navigation-ios"
+        profile = dataSource.routeProgress.route.routeOptions.profileIdentifier.rawValue
+        simulation = dataSource.locationSource.isSimulated
 
         sessionIdentifier = session.identifier.uuidString
         originalRequestIdentifier = session.originalRoute.routeIdentifier
-        requestIdentifier = router.routeProgress.route.routeIdentifier
-
-        let location = router.locationManager.location
-        coordinate = location?.coordinate ?? nil
-
-        if let coordinates = router.routeProgress.route.coordinates, let lastCoord = coordinates.last {
-            userAbsoluteDistanceToDestination = location?.distance(from: CLLocation(latitude: lastCoord.latitude, longitude: lastCoord.longitude)) ?? nil
+        requestIdentifier = dataSource.routeProgress.route.routeIdentifier
+
+        if let location = dataSource.location,
+           let coordinates = dataSource.routeProgress.route.coordinates,
+           let lastCoord = coordinates.last {
+            userAbsoluteDistanceToDestination = location.distance(from: CLLocation(latitude: lastCoord.latitude, longitude: lastCoord.longitude))
         } else {
             userAbsoluteDistanceToDestination = nil
         }
@@ -105,19 +104,15 @@ struct EventDetails: Encodable {
             estimatedDuration = nil
         }
 
-        distanceCompleted = round(session.totalDistanceCompleted + router.routeProgress.distanceTraveled)
-        distanceRemaining = round(router.routeProgress.distanceRemaining)
-        durationRemaining = round(router.routeProgress.durationRemaining)
+        distanceCompleted = round(session.totalDistanceCompleted + dataSource.routeProgress.distanceTraveled)
+        distanceRemaining = round(dataSource.routeProgress.distanceRemaining)
+        durationRemaining = round(dataSource.routeProgress.durationRemaining)
 
         rerouteCount = session.numberOfReroutes
 
-        if let manager = router.locationManager {
-            locationEngine = String(describing: manager)
-            locationManagerDesiredAccuracy = manager.desiredAccuracy
-        } else {
-            locationEngine = nil
-            locationManagerDesiredAccuracy = nil
-        }
+        locationEngine = dataSource.locationSource.description
+        locationManagerDesiredAccuracy = dataSource.desiredAccuracy
+
 
         var totalTimeInPortrait = session.timeSpentInPortrait
         var totalTimeInLandscape = session.timeSpentInLandscape
@@ -138,11 +133,11 @@ struct EventDetails: Encodable {
         percentTimeInForeground = totalTimeInPortrait + totalTimeInLandscape == 0 ? 100 : Int((totalTimeInPortrait / (totalTimeInPortrait + totalTimeInLandscape) * 100))
 
 
-        stepIndex = router.routeProgress.currentLegProgress.stepIndex
-        stepCount = router.routeProgress.currentLeg.steps.count
-        legIndex = router.routeProgress.legIndex
-        legCount = router.routeProgress.route.legs.count
-        totalStepCount = router.routeProgress.route.legs.map { $0.steps.count }.reduce(0, +)
+        stepIndex = dataSource.routeProgress.currentLegProgress.stepIndex
+        stepCount = dataSource.routeProgress.currentLeg.steps.count
+        legIndex = dataSource.routeProgress.legIndex
+        legCount = dataSource.routeProgress.route.legs.count
+        totalStepCount = dataSource.routeProgress.route.legs.map { $0.steps.count }.reduce(0, +)
     }
 
     private enum CodingKeys: String, CodingKey {
@@ -306,8 +301,8 @@ extension EventDetails {
         }
     }
 
-    static func defaultEvents(router: Router) -> EventDetails {
-        return EventDetails(router: router, session: router.eventsManager.sessionState)
+    static func defaultEvents(dataSource source: EventsManagerDataSource, session state: SessionState) -> EventDetails {
+        return EventDetails(dataSource: source, session: state)
     }
 }
 

MapboxCoreNavigation/EventsManager.swift

@@ -7,16 +7,41 @@ import MapboxDirections
 
  `SessionState` is a struct that stores all memoized statistics that we later send to the telemetry engine.
  */
+
+@objc public enum LocationSource: Int {
+    case device, simulated
+
+    var isSimulated: Bool { return self == .simulated }
+
+    var description: String {
+        switch self {
+        case .device:
+            return String(describing: CLLocationManager.self)
+        case .simulated:
+            return String(describing: SimulatedLocationManager.self)
+        }
+    }
+
+}
+@objc public protocol EventsManagerDataSource: class {
+    var routeProgress: RouteProgress { get }
+    var usesDefaultUserInterface: Bool { get set }
+    var location: CLLocation? { get }
+    var desiredAccuracy: CLLocationAccuracy { get }
+    var locationSource: LocationSource { get }
+    //todo: change MNS proto to `locationManager`
+}
+
 @objc(MBEventsManager)
 open class EventsManager: NSObject {
 
-    @objc public var manager = MMEEventsManager.shared()
+    @objc public var manager: MMEEventsManager = .shared()
 
     var sessionState: SessionState!
 
     var outstandingFeedbackEvents = [CoreFeedbackEvent]()
 
-    weak var routeController: Router!
+    unowned var dataSource: EventsManagerDataSource
 
     /// :nodoc: This is used internally when the navigation UI is being used
     var usesDefaultUserInterface = false
@@ -33,7 +58,8 @@ open class EventsManager: NSObject {
         return token
     }()
 
-    @objc public init(accessToken possibleToken: String? = nil) {
+    @objc public required init(dataSource source: EventsManagerDataSource, accessToken possibleToken: String? = nil) {
+        dataSource = source
         super.init()
         if let tokenOverride = possibleToken {
             accessToken = tokenOverride
@@ -76,7 +102,7 @@ open class EventsManager: NSObject {
 
     func navigationCancelEvent(rating potentialRating: Int? = nil, comment: String? = nil) -> EventDetails {
         let rating = potentialRating ?? MMEEventsManager.unrated
-        var event = EventDetails.defaultEvents(router: routeController)
+        var event = EventDetails.defaultEvents(dataSource: dataSource, session: sessionState)
         event.event = MMEEventTypeNavigationCancel
         event.arrivalTimestamp = sessionState.arrivalTimestamp
 
@@ -91,13 +117,13 @@ open class EventsManager: NSObject {
     }
 
     func navigationDepartEvent() -> EventDetails {
-        var event = EventDetails.defaultEvents(router: routeController)
+        var event = EventDetails.defaultEvents(dataSource: dataSource, session: sessionState)
         event.event = MMEEventTypeNavigationDepart
         return event
     }
 
     func navigationArriveEvent() -> EventDetails {
-        var event = EventDetails.defaultEvents(router: routeController)
+        var event = EventDetails.defaultEvents(dataSource: dataSource, session: sessionState)
         event.event = MMEEventTypeNavigationArrive
         return event
     }
@@ -111,7 +137,7 @@ open class EventsManager: NSObject {
     }
 
     func navigationFeedbackEvent(type: FeedbackType, description: String?) -> EventDetails {
-        var event = EventDetails.defaultEvents(router: routeController)
+        var event = EventDetails.defaultEvents(dataSource: dataSource, session: sessionState)
         event.event = MMEEventTypeNavigationFeedback
 
         event.userId = UIDevice.current.identifierForVendor?.uuidString
@@ -126,7 +152,7 @@ open class EventsManager: NSObject {
     func navigationRerouteEvent(eventType: String = MMEEventTypeNavigationReroute) -> EventDetails {
         let timestamp = Date()
 
-        var event = EventDetails.defaultEvents(router: routeController)
+        var event = EventDetails.defaultEvents(dataSource: dataSource, session: sessionState)
         event.event = eventType
         event.secondsSinceLastReroute = sessionState.lastRerouteDate != nil ? round(timestamp.timeIntervalSince(sessionState.lastRerouteDate!)) : -1
 
@@ -157,7 +183,6 @@ extension EventsManager {
     }
 
     func sendCancelEvent(rating: Int? = nil, comment: String? = nil) {
-        guard routeController != nil else { return }
         guard let attributes = try? navigationCancelEvent(rating: rating, comment: comment).asDictionary() else { return }
         manager.enqueueEvent(withName: MMEEventTypeNavigationCancel, attributes: attributes)
         manager.flush()
@@ -185,6 +210,7 @@ extension EventsManager {
         return event.id
     }
 
+    @discardableResult
     func enqueueRerouteEvent() -> String {
         let timestamp = Date()
         let eventDictionary = try! navigationRerouteEvent().asDictionary()
@@ -200,10 +226,11 @@ extension EventsManager {
     }
 
     func resetSession() {
-        let route = routeController.routeProgress.route
+        let route = dataSource.routeProgress.route
         sessionState = SessionState(currentRoute: route, originalRoute: route)
     }
 
+    @discardableResult
     func enqueueFoundFasterRouteEvent() -> String {
         let timestamp = Date()
         let eventDictionary = try! navigationRerouteEvent(eventType: FasterRouteFoundEvent).asDictionary()
@@ -291,12 +318,21 @@ extension EventsManager {
         sendOutstandingFeedbackEvents(forceAll: true)
     }
 
-    func reportReroute(newRoute: Route, proactive: Bool) {
+    func reportReroute(progress: RouteProgress, proactive: Bool) {
+        let route = progress.route
+
+        // if the user has already arrived and a new route has been set, restart the navigation session
+        if sessionState.arrivalTimestamp != nil {
+            resetSession()
+        } else {
+            sessionState.currentRoute = route
+        }
+
         if (proactive) {
-            _ = enqueueFoundFasterRouteEvent()
+            enqueueFoundFasterRouteEvent()
         }
         let latestReroute = outstandingFeedbackEvents.compactMap({ $0 as? RerouteEvent }).last
-        latestReroute?.update(newRoute: newRoute)
+        latestReroute?.update(newRoute: route)
     }
 
     @objc func update(progress: RouteProgress) {

MapboxCoreNavigation/NavigationLocationManager.swift

@@ -15,6 +15,14 @@ import UIKit
 open class NavigationLocationManager: CLLocationManager {
 
     var lastKnownLocation: CLLocation?
+    override open var delegate: CLLocationManagerDelegate? {
+        get {
+            return super.delegate
+        }
+        set {
+            super.delegate = newValue
+        }
+    }
 
     override public init() {
         super.init()