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 `didEnterTunnel(_:)` 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,16 @@ public protocol RouteControllerDelegate: class {
     */
     @objc(routeController:didArriveAtWaypoint:)
     optional func routeController(_ routeController: RouteController, didArriveAt waypoint: Waypoint) -> Bool
+
+    /**
+     Called when a tunnel is detected on a route step.
+
+     Implement this method to enable dark mode when a commuter enters a tunnel.
+
+     - parameter darkModeEnabled: The darkModeEnabled flag determines whether a `DarkStyle` should apply.
+     */
+    @objc(didEnterTunnel:)
+    optional func didEnterTunnel(_ darkModeEnabled: Bool)
 }
 
 /**
@@ -634,6 +644,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 +662,27 @@ 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.
+        if (tunnelDistance - distanceToExit) > 0 && distanceToEntrance <= tunnelDistance {
+            delegate?.didEnterTunnel?(true)
+        } else {
+            delegate?.didEnterTunnel?(false)
+        }
+    }
+
     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 intersectionBounds = tunnelIntersectionBounds else { return nil }
+        return Polyline(coordinates).sliced(from: intersectionBounds.entry.location, to: intersectionBounds.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 bounds 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 didEnterTunnel(_ darkModeEnabled: Bool) {
+        if darkModeEnabled {
+            self.styleManager.applyStyle(type:.nightStyle)
+        } else {
+            self.styleManager.resetTimeOfDayTimer()
+        }
+    }
 }
 
 extension NavigationViewController: StyleManagerDelegate {

MapboxNavigation/StyleManager.swift

@@ -96,6 +96,21 @@ open class StyleManager: NSObject {
         resetTimeOfDayTimer()
     }
 
+    func applyStyle(type styleType: StyleType) {
+        guard currentStyleType != styleType else { return }
+
+        NSObject.cancelPreviousPerformRequests(withTarget: self, selector: #selector(timeOfDayChanged), object: nil)
+
+        for style in styles {
+            if style.styleType == styleType {
+                style.apply()
+                currentStyleType = styleType
+                delegate?.styleManager?(self, didApply: style)
+                break
+            }
+        }
+    }
+
     func applyStyle() {
         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