Navigation camera viewport API.

Example/AppDelegate+CarPlay.swift

@@ -57,7 +57,7 @@ extension AppDelegate: CarPlayManagerDelegate {
 
     // MARK: CarPlayManagerDelegate
     func carPlayManager(_ carPlayManager: CarPlayManager, didBeginNavigationWith service: NavigationService) {
-        currentAppRootViewController?.beginNavigationWithCarplay(navigationService: service)
+        currentAppRootViewController?.beginNavigationWithCarPlay(navigationService: service)
         carPlayManager.currentNavigator?.compassView.isHidden = false
 
         // Render part of the route that has been traversed with full transparency, to give the illusion of a disappearing route.

Example/CustomCameraStateTransition.swift

@@ -0,0 +1,47 @@
+import MapboxMaps
+import MapboxNavigation
+
+class CustomCameraStateTransition: CameraStateTransition {
+
+    weak var mapView: MapView?
+
+    required init(_ mapView: MapView) {
+        self.mapView = mapView
+    }
+
+    func transitionToFollowing(_ cameraOptions: CameraOptions, completion: @escaping (() -> Void)) {
+        mapView?.cameraManager.setCamera(to: cameraOptions,
+                                         animated: true,
+                                         duration: 0.5,
+                                         completion: { _ in
+                                            completion()
+                                         })
+    }
+
+    func transitionToOverview(_ cameraOptions: CameraOptions, completion: @escaping (() -> Void)) {
+        mapView?.cameraManager.setCamera(to: cameraOptions,
+                                         animated: true,
+                                         duration: 0.5,
+                                         completion: { _ in
+                                            completion()
+                                         })
+    }
+
+    func updateForFollowing(_ cameraOptions: CameraOptions) {
+        mapView?.cameraManager.setCamera(to: cameraOptions,
+                                         animated: true,
+                                         duration: 0.5,
+                                         completion: nil)
+    }
+
+    func updateForOverview(_ cameraOptions: CameraOptions) {
+        mapView?.cameraManager.setCamera(to: cameraOptions,
+                                         animated: true,
+                                         duration: 0.5,
+                                         completion: nil)
+    }
+
+    func cancelPendingTransition() {
+        mapView?.cameraManager.cancelTransitions()
+    }
+}

Example/CustomViewController.swift

@@ -4,10 +4,16 @@ import MapboxNavigation
 import MapboxDirections
 import MapboxMaps
 
-// FIXME: Currently if `MapView` is created using storyboard crash occurs.
 class CustomViewController: UIViewController {
 
+    var destinationAnnotation: PointAnnotation! {
+        didSet {
+            navigationMapView.mapView.annotationManager.addAnnotation(destinationAnnotation)
+        }
+    }
+
     var navigationService: NavigationService!
+
     var simulateLocation = false
 
     var userIndexedRoute: IndexedRoute?
@@ -34,6 +40,7 @@ class CustomViewController: UIViewController {
         super.viewDidLoad()
 
         navigationMapView.mapView.style.styleURL = .custom(url: URL(string: "mapbox://styles/mapbox-map-design/ckd6dqf981hi71iqlyn3e896y")!)
+        navigationMapView.userCourseView.isHidden = false
 
         let locationManager = simulateLocation ? SimulatedLocationManager(route: userIndexedRoute!.0) : NavigationLocationManager()
         navigationService = MapboxNavigationService(route: userIndexedRoute!.0, routeIndex: userIndexedRoute!.1, routeOptions: userRouteOptions!, locationSource: locationManager, simulating: simulateLocation ? .always : .onPoorGPS)
@@ -51,9 +58,6 @@ class CustomViewController: UIViewController {
         // Start navigation
         navigationService.start()
 
-        // Center map on user
-        navigationMapView.recenterMap()
-
         navigationMapView.mapView.on(.styleLoaded, handler: { [weak self] _ in
             guard let route = self?.navigationService.route else { return }
             self?.navigationMapView.show([route])
@@ -101,8 +105,8 @@ class CustomViewController: UIViewController {
         instructionsBannerView.updateDistance(for: routeProgress.currentLegProgress.currentStepProgress)
         instructionsBannerView.isHidden = false
 
-        // Update the user puck
-        navigationMapView.updateCourseTracking(location: location, animated: true)
+        // Update `UserCourseView` to be placed on the most recent location.
+        navigationMapView.updateUserCourseView(location, animated: true)
     }
 
     @objc func updateInstructionsBanner(notification: NSNotification) {
@@ -122,7 +126,7 @@ class CustomViewController: UIViewController {
     }
 
     @IBAction func recenterMap(_ sender: Any) {
-        navigationMapView.recenterMap()
+        navigationMapView.navigationCamera.requestNavigationCameraToFollowing()
     }
 
     @IBAction func showFeedback(_ sender: Any) {
@@ -172,8 +176,7 @@ class CustomViewController: UIViewController {
         updatePreviewBannerWith(step: step, maneuverStep: maneuverStep)
 
         // stop tracking user, and move camera to step location
-        navigationMapView.tracksUserCourse = false
-        navigationMapView.enableFrameByFrameCourseViewTracking(for: 1)
+        navigationMapView.navigationCamera.requestNavigationCameraToIdle()
         navigationMapView.mapView.cameraManager.setCamera(centerCoordinate: maneuverStep.maneuverLocation,
                                                           bearing: maneuverStep.initialHeading!,
                                                           animated: true)

Example/CustomViewportDataSource.swift

@@ -0,0 +1,94 @@
+import MapboxMaps
+import MapboxNavigation
+import MapboxCoreNavigation
+
+class CustomViewportDataSource: ViewportDataSource {
+
+    public var delegate: ViewportDataSourceDelegate?
+
+    public var followingMobileCamera: CameraOptions = CameraOptions()
+
+    public var followingHeadUnitCamera: CameraOptions = CameraOptions()
+
+    public var overviewMobileCamera: CameraOptions = CameraOptions()
+
+    public var overviewHeadUnitCamera: CameraOptions = CameraOptions()
+
+    weak var mapView: MapView?
+
+    // MARK: - Initializer methods
+
+    public required init(_ mapView: MapView) {
+        self.mapView = mapView
+        self.mapView?.locationManager.addLocationConsumer(newConsumer: self)
+
+        subscribeForNotifications()
+    }
+
+    deinit {
+        unsubscribeFromNotifications()
+    }
+
+    // MARK: - Notifications observer methods
+
+    func subscribeForNotifications() {
+        NotificationCenter.default.addObserver(self,
+                                               selector: #selector(progressDidChange(_:)),
+                                               name: .routeControllerProgressDidChange,
+                                               object: nil)
+    }
+
+    func unsubscribeFromNotifications() {
+        NotificationCenter.default.removeObserver(self,
+                                                  name: .routeControllerProgressDidChange,
+                                                  object: nil)
+    }
+
+    @objc func progressDidChange(_ notification: NSNotification) {
+        let location = notification.userInfo?[RouteController.NotificationUserInfoKey.locationKey] as? CLLocation
+        let routeProgress = notification.userInfo?[RouteController.NotificationUserInfoKey.routeProgressKey] as? RouteProgress
+        let cameraOptions = self.cameraOptions(location, routeProgress: routeProgress)
+
+        delegate?.viewportDataSource(self, didUpdate: cameraOptions)
+    }
+
+    func cameraOptions(_ location: CLLocation?, routeProgress: RouteProgress? = nil) -> [String: CameraOptions] {
+        followingMobileCamera.center = location?.coordinate
+        followingMobileCamera.bearing = location?.course
+        followingMobileCamera.padding = .zero
+        followingMobileCamera.zoom = 14.0
+        followingMobileCamera.pitch = 0.0
+
+        overviewMobileCamera.center = location?.coordinate
+        overviewMobileCamera.bearing = 0.0
+        overviewMobileCamera.padding = .zero
+        overviewMobileCamera.zoom = 10.0
+        overviewMobileCamera.pitch = 0.0
+
+        let cameraOptions = [
+            CameraOptions.followingMobileCameraKey: followingMobileCamera,
+            CameraOptions.overviewMobileCameraKey: overviewMobileCamera
+        ]
+
+        return cameraOptions
+    }
+}
+
+// MARK: - LocationConsumer delegate
+
+extension CustomViewportDataSource: LocationConsumer {
+
+    var shouldTrackLocation: Bool {
+        get {
+            return true
+        }
+        set(newValue) {
+            // No-op
+        }
+    }
+
+    func locationUpdate(newLocation: Location) {
+        let cameraOptions = self.cameraOptions(newLocation.internalLocation)
+        delegate?.viewportDataSource(self, didUpdate: cameraOptions)
+    }
+}

Example/NavigationCameraDebugView.swift

@@ -0,0 +1,151 @@
+import UIKit
+import MapboxMaps
+import MapboxNavigation
+
+class NavigationCameraDebugView: UIView {
+
+    weak var mapView: MapView?
+
+    var viewportLayer = CALayer()
+    var anchorLayer = CALayer()
+    var anchorTextLayer = CATextLayer()
+    var centerLayer = CALayer()
+    var centerTextLayer = CATextLayer()
+    var pitchTextLayer = CATextLayer()
+    var zoomTextLayer = CATextLayer()
+    var bearingTextLayer = CATextLayer()
+
+    required init(_ mapView: MapView, frame: CGRect) {
+        self.mapView = mapView
+
+        super.init(frame: frame)
+
+        isUserInteractionEnabled = false
+        backgroundColor = .clear
+        subscribeForNotifications()
+
+        viewportLayer.borderWidth = 3.0
+        viewportLayer.borderColor = UIColor.green.cgColor
+        layer.addSublayer(viewportLayer)
+
+        anchorLayer.backgroundColor = UIColor.red.cgColor
+        anchorLayer.frame = .init(x: 0.0, y: 0.0, width: 6.0, height: 6.0)
+        anchorLayer.cornerRadius = 3.0
+        layer.addSublayer(anchorLayer)
+
+        anchorTextLayer = CATextLayer()
+        anchorTextLayer.string = "Anchor"
+        anchorTextLayer.fontSize = UIFont.systemFontSize
+        anchorTextLayer.backgroundColor = UIColor.clear.cgColor
+        anchorTextLayer.foregroundColor = UIColor.red.cgColor
+        anchorTextLayer.frame = .zero
+        layer.addSublayer(anchorTextLayer)
+
+        centerLayer.backgroundColor = UIColor.blue.cgColor
+        centerLayer.frame = .init(x: 0.0, y: 0.0, width: 6.0, height: 6.0)
+        centerLayer.cornerRadius = 3.0
+        layer.addSublayer(centerLayer)
+
+        centerTextLayer = CATextLayer()
+        centerTextLayer.string = "Center"
+        centerTextLayer.fontSize = UIFont.systemFontSize
+        centerTextLayer.backgroundColor = UIColor.clear.cgColor
+        centerTextLayer.foregroundColor = UIColor.blue.cgColor
+        centerTextLayer.frame = .zero
+        layer.addSublayer(centerTextLayer)
+
+        pitchTextLayer = createDefaultTextLayer()
+        layer.addSublayer(pitchTextLayer)
+
+        zoomTextLayer = createDefaultTextLayer()
+        layer.addSublayer(zoomTextLayer)
+
+        bearingTextLayer = createDefaultTextLayer()
+        layer.addSublayer(bearingTextLayer)
+    }
+
+    func createDefaultTextLayer() -> CATextLayer {
+        let textLayer = CATextLayer()
+        textLayer.string = ""
+        textLayer.fontSize = UIFont.systemFontSize
+        textLayer.backgroundColor = UIColor.clear.cgColor
+        textLayer.foregroundColor = UIColor.black.cgColor
+        textLayer.frame = .zero
+
+        return textLayer
+    }
+
+    required init?(coder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+
+    deinit {
+        unsubscribeFromNotifications()
+    }
+
+    func subscribeForNotifications() {
+        NotificationCenter.default.addObserver(self,
+                                               selector: #selector(navigationCameraViewportDidChange(_:)),
+                                               name: .navigationCameraViewportDidChange,
+                                               object: nil)
+    }
+
+    func unsubscribeFromNotifications() {
+        NotificationCenter.default.removeObserver(self,
+                                                  name: .navigationCameraViewportDidChange,
+                                                  object: nil)
+    }
+
+    @objc func navigationCameraViewportDidChange(_ notification: NSNotification) {
+        guard let mapView = mapView,
+              let cameraOptions = notification.userInfo?[NavigationCamera.NotificationUserInfoKey.cameraOptionsKey] as? Dictionary<String, CameraOptions>,
+              let followingMobileCamera = cameraOptions[CameraOptions.followingMobileCameraKey] else { return }
+
+        if let edgeInsets = followingMobileCamera.padding {
+            viewportLayer.frame = CGRect(x: edgeInsets.left,
+                                         y: edgeInsets.top,
+                                         width: mapView.frame.width - edgeInsets.left - edgeInsets.right,
+                                         height: mapView.frame.height - edgeInsets.top - edgeInsets.bottom)
+        }
+
+        if let anchorPosition = followingMobileCamera.anchor {
+            anchorLayer.position = anchorPosition
+            anchorTextLayer.frame = .init(x: anchorLayer.frame.origin.x + 5.0,
+                                          y: anchorLayer.frame.origin.y + 5.0,
+                                          width: 80.0,
+                                          height: 20.0)
+        }
+
+        if let centerCoordinate = followingMobileCamera.center {
+            centerLayer.position = mapView.point(for: centerCoordinate)
+            centerTextLayer.frame = .init(x: centerLayer.frame.origin.x + 5.0,
+                                          y: centerLayer.frame.origin.y + 5.0,
+                                          width: 80.0,
+                                          height: 20.0)
+        }
+
+        if let pitch = followingMobileCamera.pitch {
+            pitchTextLayer.frame = .init(x: viewportLayer.frame.origin.x + 5.0,
+                                         y: viewportLayer.frame.origin.y + 5.0,
+                                         width: viewportLayer.frame.size.width - 10.0,
+                                         height: 20.0)
+            pitchTextLayer.string = "Pitch: \(pitch)"
+        }
+
+        if let zoom = followingMobileCamera.zoom {
+            zoomTextLayer.frame = .init(x: viewportLayer.frame.origin.x + 5.0,
+                                        y: viewportLayer.frame.origin.y + 30.0,
+                                        width: viewportLayer.frame.size.width - 10.0,
+                                        height: 20.0)
+            zoomTextLayer.string = "Zoom: \(zoom)"
+        }
+
+        if let bearing = followingMobileCamera.bearing {
+            bearingTextLayer.frame = .init(x: viewportLayer.frame.origin.x + 5.0,
+                                           y: viewportLayer.frame.origin.y + 55.0,
+                                           width: viewportLayer.frame.size.width - 10.0,
+                                           height: 20.0)
+            bearingTextLayer.string = "Bearing: \(bearing)º"
+        }
+    }
+}