Enable night style when inside tunnel

CHANGELOG.md

@@ -8,6 +8,7 @@
 * Exposes `PollyVoiceController.speak(_:)` which would allow custom subclass of PollyVoiceController to override this method and pass a modified SpokenInstruction to our superclass implementation.
 * Added a `NavigationMapView.localizeLabels()` method that should be called within `MGLMapViewDelegate.mapView(_:didFinishLoading:)` for standalone `NavigationMapView`s to ensure that map labels are in the correct language. (#1111)
 * Changed the heuristics needed for a the users location to unsnap from the route line. (#1110)
+* Added delegate method `(routeController:didEnterTunnelAt:)` which is useful for enabling dark mode when a commuter enters a tunnel.
 
 ## v0.13.1 (February 7, 2018)
 

MapboxCoreNavigation/RouteController.swift

@@ -77,7 +77,7 @@ public protocol RouteControllerDelegate: class {
     optional func routeController(_ routeController: RouteController, willRerouteFrom location: CLLocation)
 
     /**
-     Called when a location has been idenetified as unqualified to navigate on.
+     Called when a location has been identified as unqualified to navigate on.
 
      See `CLLocation.isQualified` for more information about what qualifies a location.
 
@@ -134,6 +134,17 @@ public protocol RouteControllerDelegate: class {
     */
     @objc(routeController:didArriveAtWaypoint:)
     optional func routeController(_ routeController: RouteController, didArriveAt waypoint: Waypoint) -> Bool
+
+    /**
+     Called when a location is detected within a tunnel.
+
+     Implement this method to enable dark mode when a commuter enters a tunnel.
+
+     - parameter routeController: The route controller that detects the location within a tunnel route.
+     - parameter location: The location that falls within the identified tunnel.
+     */
+    @objc(routeController:didEnterTunnelAt:)
+    optional func routeController(_ routeController: RouteController, didEnterTunnelAt location: CLLocation?)
 }
 
 /**
@@ -634,6 +645,7 @@ extension RouteController: CLLocationManagerDelegate {
         updateDistanceToIntersection(from: location)
         updateRouteStepProgress(for: location)
         updateRouteLegProgress(for: location)
+        detectRouteStepInTunnel(for: location)
 
         guard userIsOnRoute(location) || !(delegate?.routeController?(self, shouldRerouteFrom: location) ?? true) else {
             reroute(from: location)
@@ -651,6 +663,28 @@ extension RouteController: CLLocationManagerDelegate {
         checkForFasterRoute(from: location)
     }
 
+    func detectRouteStepInTunnel(for location: CLLocation) {
+        guard routeProgress.currentLegProgress.currentStep.containsTunnel else { return }
+        guard let tunnelDistance = routeProgress.currentLegProgress.currentStep.tunnelDistance, let tunnelSlice = routeProgress.currentLegProgress.currentStep.tunnelSlice else { return }
+        guard let tunnelStartCoordinate = tunnelSlice.coordinates.first, let tunnelEndCoordinate = tunnelSlice.coordinates.last else { return }
+
+        // Calculated distances from current location to tunnel entrance and exit
+        let currentLocation = CLLocationCoordinate2D(latitude: location.coordinate.latitude, longitude: location.coordinate.longitude)
+        let distanceToEntrance = currentLocation.distance(to: tunnelStartCoordinate)
+        let distanceToExit = currentLocation.distance(to: tunnelEndCoordinate)
+
+        // Capute any location which lies within the tunnel route.
+        // Pre-conditions:
+        //   - Current location to exit must be greater than zero meters.
+        //   - Distance to tunnel entrance must be less than tunnel distance.
+        //   - Distance to tunnel exit must also be less than tunnel distance.
+        if (tunnelDistance - distanceToExit) > 0 && distanceToEntrance <= tunnelDistance && distanceToExit <= tunnelDistance {
+            delegate?.routeController?(self, didEnterTunnelAt: location)
+        } else {
+            delegate?.routeController?(self, didEnterTunnelAt: nil)
+        }
+    }
+
     func updateRouteLegProgress(for location: CLLocation) {
         let currentDestination = routeProgress.currentLeg.destination
         let legDurationRemaining = routeProgress.currentLegProgress.durationRemaining

MapboxCoreNavigation/RouteStep.swift

@@ -1,4 +1,5 @@
 import MapboxDirections
+import Turf
 
 extension RouteStep {
     static func ==(left: RouteStep, right: RouteStep) -> Bool {
@@ -38,4 +39,46 @@ extension RouteStep {
     open var lastInstruction: SpokenInstruction? {
         return instructionsSpokenAlongStep?.last
     }
+
+    /**
+     Returns true if the current route step contains a tunnel.
+     */
+    var containsTunnel: Bool {
+        guard let intersections = intersections else { return false }
+        for intersection in intersections {
+            if intersection.outletRoadClasses?.contains(.tunnel) == true {
+                return true
+            }
+        }
+        return false
+    }
+
+    /**
+     Returns a tunnel slice for the current route step coordinates
+     */
+    var tunnelSlice: Polyline? {
+        guard let coordinates = coordinates, let tunnelIntersection = tunnelIntersectionBounds else { return nil }
+        return Polyline(coordinates).sliced(from: tunnelIntersection.entry.location, to: tunnelIntersection.exit.location)
+    }
+
+    /**
+     Returns the distance of a tunnel slice for the current route step
+     */
+    var tunnelDistance: CLLocationDistance? {
+        guard let tunnelSlice = tunnelSlice else { return nil }
+        return tunnelSlice.distance()
+    }
+
+    /**
+     Returns the entry and exit intersection bounss of the tunnel on the current route step
+     */
+    var tunnelIntersectionBounds: (entry: Intersection, exit: Intersection)? {
+        guard let intersections = intersections, containsTunnel else { return nil }
+        for i in 0..<(intersections.count) where intersections.count > 1 {
+            if intersections[i].outletRoadClasses == .tunnel {
+                return (entry: intersections[i], exit: intersections[i+1])
+            }
+        }
+        return nil
+    }
 }

MapboxNavigation/NavigationViewController.swift

@@ -561,6 +561,14 @@ extension NavigationViewController: RouteControllerDelegate {
         }
         return advancesToNextLeg
     }
+
+    @objc public func routeController(_ routeController: RouteController, didEnterTunnelAt location: CLLocation?) {
+        if let _ = location {
+            self.styleManager.applyStyle(NightStyle())
+        } else {
+            self.styleManager.applyStyle()
+        }
+    }
 }
 
 extension NavigationViewController: StyleManagerDelegate {

MapboxNavigation/StyleManager.swift

@@ -96,7 +96,7 @@ open class StyleManager: NSObject {
         resetTimeOfDayTimer()
     }
 
-    func applyStyle() {
+    func applyStyle(_ newStyle: Style? = nil) {
         guard let location = delegate?.locationFor(styleManager: self) else {
             // We can't calculate sunset or sunrise w/o a location so just apply the first style
             if let style = styles.first {
@@ -106,6 +106,15 @@ open class StyleManager: NSObject {
             return
         }
 
+        // Custom style usage
+        if let customStyle = newStyle {
+            if styles.count == 1 && !styles.contains(customStyle) || styles.count > 1 && styles.first != customStyle {
+                customStyle.apply()
+                delegate?.styleManager?(self, didApply: customStyle)
+            }
+            return
+        }
+
         // Single style usage
         guard styles.count > 1 else {
             if let style = styles.first {