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,15 @@ -(void)prepareForSegue:(UIStoryboardSegue *)segue sender:(id)sender {
     if ([segue.identifier isEqualToString:@"StartNavigation"]) {
         MBNavigationViewController *controller = (MBNavigationViewController *)[segue destinationViewController];
 
+        MBSimulatedLocationManager *locationManager = [[MBSimulatedLocationManager alloc] initWithRoute:self.route];
+
+        MBEventsManager *events = [[MBEventsManager alloc] initWithAccessToken:self.route.accessToken];
+
         controller.directions = [MBDirections sharedDirections];
         controller.route = self.route;
+        controller.navigationService = [[MBNavigationService alloc] initWithRoute:self.route directions:controller.directions locationSource:locationManager eventsManager:events];
 
-        controller.routeController.locationManager = [[MBSimulatedLocationManager alloc] initWithRoute:self.route];
+
     }
 }
 

MapboxCoreNavigation/RouteController.swift

@@ -489,7 +489,7 @@ extension RouteController: CLLocationManagerDelegate {
         }
     }
 
-    func reroute(from location: CLLocation, along progress: RouteProgress) {
+    public func reroute(from location: CLLocation, along progress: RouteProgress) {
         if let lastRerouteLocation = lastRerouteLocation {
             guard location.distance(from: lastRerouteLocation) >= RouteControllerMaximumDistanceBeforeRecalculating else {
                 return

MapboxCoreNavigation/Router.swift

@@ -15,5 +15,7 @@ public typealias RouterDelegate = RouteControllerDelegate
     var route: Route { get set }
     func endNavigation(feedback: EndOfRouteFeedback?)
 
+    @objc func userIsOnRoute(_ location: CLLocation) -> Bool
+    @objc func reroute(from: CLLocation, along: RouteProgress)
     @objc var location: CLLocation? { get }
 }

MapboxCoreNavigationTests/MapboxCoreNavigationTests.swift

@@ -15,23 +15,23 @@ let waitForInterval: TimeInterval = 5
 
 class MapboxCoreNavigationTests: XCTestCase {
 
-    var navigation: RouteController!
+    var navigation: MapboxNavigationService!
 
     func testDepart() {
         route.accessToken = "foo"
-        navigation = RouteController(along: route, directions: directions)
+        navigation = MapboxNavigationService(route: route, directions: directions)
         let depart = CLLocation(coordinate: CLLocationCoordinate2D(latitude: 37.795042, longitude: -122.413165), altitude: 1, horizontalAccuracy: 1, verticalAccuracy: 1, course: 0, speed: 10, timestamp: Date())
 
-        expectation(forNotification: .routeControllerDidPassSpokenInstructionPoint, object: navigation) { (notification) -> Bool in
+        expectation(forNotification: .routeControllerDidPassSpokenInstructionPoint, object: navigation.router) { (notification) -> Bool in
             XCTAssertEqual(notification.userInfo?.count, 1)
 
             let routeProgress = notification.userInfo![RouteControllerNotificationUserInfoKey.routeProgressKey] as? RouteProgress
 
             return routeProgress != nil && routeProgress?.currentLegProgress.userHasArrivedAtWaypoint == false
         }
 
-        navigation.resume()
-        navigation.locationManager(navigation.locationManager, didUpdateLocations: [depart])
+        navigation.start()
+        navigation.locationManager(navigation.locationSource, didUpdateLocations: [depart])
 
         waitForExpectations(timeout: waitForInterval) { (error) in
             XCTAssertNil(error)
@@ -42,17 +42,17 @@ class MapboxCoreNavigationTests: XCTestCase {
         route.accessToken = "foo"
         let location = CLLocation(coordinate: CLLocationCoordinate2D(latitude: 37.78895, longitude: -122.42543), altitude: 1, horizontalAccuracy: 1, verticalAccuracy: 1, course: 171, speed: 10, timestamp: Date())
         let locationManager = ReplayLocationManager(locations: [location, location])
-        navigation = RouteController(along: route, directions: directions, locationManager: locationManager)
+        navigation = MapboxNavigationService(route: route, directions: directions, locationSource: locationManager)
 
-        expectation(forNotification: .routeControllerDidPassSpokenInstructionPoint, object: navigation) { (notification) -> Bool in
+        expectation(forNotification: .routeControllerDidPassSpokenInstructionPoint, object: navigation.router) { (notification) -> Bool in
             XCTAssertEqual(notification.userInfo?.count, 1)
 
             let routeProgress = notification.userInfo![RouteControllerNotificationUserInfoKey.routeProgressKey] as? RouteProgress
 
             return routeProgress?.currentLegProgress.stepIndex == 2
         }
 
-        navigation.resume()
+        navigation.start()
 
         waitForExpectations(timeout: waitForInterval) { (error) in
             XCTAssertNil(error)
@@ -64,17 +64,17 @@ class MapboxCoreNavigationTests: XCTestCase {
         let location = CLLocation(coordinate: CLLocationCoordinate2D(latitude: 37.77386, longitude: -122.43085), altitude: 1, horizontalAccuracy: 1, verticalAccuracy: 1, course: 171, speed: 10, timestamp: Date())
 
         let locationManager = ReplayLocationManager(locations: [location, location])
-        navigation = RouteController(along: route, directions: directions, locationManager: locationManager)
+        navigation = MapboxNavigationService(route: route, directions: directions, locationSource: locationManager)
 
-        expectation(forNotification: .routeControllerDidPassSpokenInstructionPoint, object: navigation) { (notification) -> Bool in
+        expectation(forNotification: .routeControllerDidPassSpokenInstructionPoint, object: navigation.router) { (notification) -> Bool in
             XCTAssertEqual(notification.userInfo?.count, 1)
 
             let routeProgress = notification.userInfo![RouteControllerNotificationUserInfoKey.routeProgressKey] as? RouteProgress
 
             return routeProgress?.currentLegProgress.stepIndex == 6
         }
 
-        navigation.resume()
+        navigation.start()
 
         waitForExpectations(timeout: waitForInterval) { (error) in
             XCTAssertNil(error)
@@ -92,16 +92,16 @@ class MapboxCoreNavigationTests: XCTestCase {
                                         timestamp: Date(timeIntervalSinceNow: 1))
 
         let locationManager = ReplayLocationManager(locations: [firstLocation, secondLocation])
-        navigation = RouteController(along: route, directions: directions, locationManager: locationManager)
+        navigation = MapboxNavigationService(route: route, directions: directions, locationSource: locationManager)
 
-        expectation(forNotification: .routeControllerWillReroute, object: navigation) { (notification) -> Bool in
+        expectation(forNotification: .routeControllerWillReroute, object: navigation.router) { (notification) -> Bool in
             XCTAssertEqual(notification.userInfo?.count, 1)
 
             let location = notification.userInfo![RouteControllerNotificationUserInfoKey.locationKey] as? CLLocation
             return location?.coordinate == secondLocation.coordinate
         }
 
-        navigation.resume()
+        navigation.start()
 
         waitForExpectations(timeout: waitForInterval) { (error) in
             XCTAssertNil(error)
@@ -114,14 +114,14 @@ class MapboxCoreNavigationTests: XCTestCase {
         let locationManager = ReplayLocationManager(locations: locations)
         locationManager.speedMultiplier = 20
 
-        navigation = RouteController(along: route, directions: directions, locationManager: locationManager)
+        navigation = MapboxNavigationService(route: route, directions: directions, locationSource: locationManager)
 
-        expectation(forNotification: .routeControllerProgressDidChange, object: navigation) { (notification) -> Bool in
+        expectation(forNotification: .routeControllerProgressDidChange, object: navigation.router) { (notification) -> Bool in
             let routeProgress = notification.userInfo![RouteControllerNotificationUserInfoKey.routeProgressKey] as? RouteProgress
             return routeProgress != nil
         }
 
-        navigation.resume()
+        navigation.start()
 
         let timeout = locations.last!.timestamp.timeIntervalSince(locations.first!.timestamp) / locationManager.speedMultiplier
         waitForExpectations(timeout: timeout + 2) { (error) in
@@ -130,20 +130,23 @@ class MapboxCoreNavigationTests: XCTestCase {
     }
 
     func testFailToReroute() {
+        enum TestError: Error {
+            case test
+        }
         route.accessToken = "foo"
         let directionsClientSpy = DirectionsSpy(accessToken: "garbage", host: nil)
-        navigation = RouteController(along: route, directions: directionsClientSpy)
+        navigation = MapboxNavigationService(route: route, directions: directionsClientSpy)
 
-        expectation(forNotification: .routeControllerWillReroute, object: navigation) { (notification) -> Bool in
+        expectation(forNotification: .routeControllerWillReroute, object: navigation.router) { (notification) -> Bool in
             return true
         }
 
-        expectation(forNotification: .routeControllerDidFailToReroute, object: navigation) { (notification) -> Bool in
+        expectation(forNotification: .routeControllerDidFailToReroute, object: navigation.router) { (notification) -> Bool in
             return true
         }
-
-        navigation.reroute(from: CLLocation(latitude: 0, longitude: 0), along: navigation.routeProgress)
-        directionsClientSpy.fireLastCalculateCompletion(with: nil, routes: nil, error: NSError())
+        let routeController = navigation.router as! RouteController
+        routeController.reroute(from: CLLocation(latitude: 0, longitude: 0), along: navigation.router.routeProgress)
+        directionsClientSpy.fireLastCalculateCompletion(with: nil, routes: nil, error: TestError.test as NSError)
 
         waitForExpectations(timeout: 2) { (error) in
             XCTAssertNil(error)