visualNavigator.startRendering(mapView: mapView)

visualNavigator.cameraBehavior = nil

// Alternatively, use DynamicCameraBehavior to auto-zoom the camera during guidance.
visualNavigator.cameraBehavior = FixedCameraBehavior()

visualNavigator.guidanceFrameRate = 60

visualNavigator.isRouteProgressVisible = false

private func customizeVisualNavigatorColors() {
    let routeAheadColor = UIColor.blue
    let routeBehindColor = UIColor.red
    let routeAheadOutlineColor = UIColor.yellow
    let routeBehindOutlineColor = UIColor.gray
    let maneuverArrowColor = UIColor.green

    let visualNavigatorColors = VisualNavigatorColors.dayColors()
    let routeProgressColors = RouteProgressColors(
        ahead: routeAheadColor,
        behind: routeBehindColor,
        outlineAhead: routeAheadOutlineColor,
        outlineBehind: routeBehindOutlineColor
    )

    // Sets the color used to draw maneuver arrows.
    visualNavigatorColors.maneuverArrowColor = maneuverArrowColor
    // Sets route color for a single transport mode. Other modes are kept using defaults.
    visualNavigatorColors.setRouteProgressColors(sectionTransportMode: SectionTransportMode.car, routeProgressColors: routeProgressColors)
    // Sets the adjusted colors for route progress and maneuver arrows based on the day color scheme.
    visualNavigator?.colors = visualNavigatorColors
}

// Conform to DestinationReachedDelegate.
// Notifies when the destination of the route is reached.
func onDestinationReached() {
    showMessage("Destination reached.")
    // Guidance has stopped. Now consider to, for example,
    // switch to tracking mode or stop rendering or locating or do anything else that may
    // be useful to support your app flow.
    // If the DynamicRoutingEngine was started before, consider to stop it now.
}

// Conform to MilestoneStatusDelegate.
// Notifies when a waypoint on the route is reached or missed.
func onMilestoneStatusUpdated(milestone: Milestone, status: MilestoneStatus) {
    if milestone.waypointIndex != nil && status == MilestoneStatus.reached {
        print("A user-defined waypoint was reached, index of waypoint: \(String(describing: milestone.waypointIndex))")
        print("Original coordinates: \(String(describing: milestone.originalCoordinates))")
    } else if milestone.waypointIndex != nil && status == MilestoneStatus.missed {
        print("A user-defined waypoint was missed, index of waypoint: \(String(describing: milestone.waypointIndex))")
        print("Original coordinates: \(String(describing: milestone.originalCoordinates))")
    } else if milestone.waypointIndex == nil && status == MilestoneStatus.reached {
        // For example, when transport mode changes due to a ferry a system-defined waypoint may have been added.
        print("A system-defined waypoint was reached, index of waypoint: \(String(describing: milestone.mapMatchedCoordinates))")
    } else if milestone.waypointIndex == nil && status == MilestoneStatus.missed {
        // For example, when transport mode changes due to a ferry a system-defined waypoint may have been added.
        print("A system-defined waypoint was missed, index of waypoint: \(String(describing: milestone.mapMatchedCoordinates))")
    }
}

// Conform to RouteProgressDelegate.
func onRouteProgressUpdated(_ routeProgress: heresdk.RouteProgress) {
    let maneuverProgressList = routeProgress.maneuverProgress
    guard let nextManeuverProgress = maneuverProgressList.first else {
        print("No next maneuver available.")
        return
    }

    // ...
    // Here you can extract maneuver information from nextManeuverProgress.
    // ...

    let nextManeuverIndex = nextManeuverProgress.maneuverIndex
    let nextManeuver = visualNavigator.getManeuver(index: nextManeuverIndex)

    if previousManeuver == nextManeuver {
        // We are still trying to reach the next maneuver.
        return;
    }
    previousManeuver = nextManeuver;

    // A new maneuver takes places. Hide the existing road shield icon, if any.
    uiCallback?.onHideRoadShieldIcon()

    guard let maneuverSpan = getSpanForManeuver(route: visualNavigator.route!,
                                                maneuver: nextManeuver!) else {
        return
    }
    createRoadShieldIconForSpan(maneuverSpan)
}

private func getSpanForManeuver(route: Route, maneuver: Maneuver) -> Span? {
    let index = Int(maneuver.sectionIndex)
    let sectionOfManeuver = route.sections[index]
    let spansInSection = sectionOfManeuver.spans

    // The last maneuver is located on the last span.
    // Note: Its offset points to the last GeoCoordinates of the route's polyline:
    // maneuver.offset = sectionOfManeuver.geometry.vertices.last.
    if maneuver.action == ManeuverAction.arrive {
        return spansInSection.last
    }

    let indexOfManeuverInSection = maneuver.offset
    for span in spansInSection {
        // A maneuver always lies on the first point of a span. Except for the
        // the destination that is located somewhere on the last span (see above).
        let firstIndexOfSpanInSection = span.sectionPolylineOffset
        if firstIndexOfSpanInSection >= indexOfManeuverInSection {
            return span
        }
    }

    // Should never happen.
    return nil
}

private func createRoadShieldIconForSpan(_ span: Span) {
    guard !span.roadNumbers.items.isEmpty else {
        // Road shields are only provided for roads that have route numbers such as US-101 or A100.
        // Many streets in a city like "Invalidenstr." have no route number.
        return
    }

    // For simplicity, we use the first item as fallback. There can be more numbers you can pick per desired language.
    guard var localizedRoadNumber = span.roadNumbers.items.first else {
        // First time should not be nil when list is not empty.
        return
    }

    // Desired locale identifier for the road shield text.
    let desiredLocale = Locale(identifier: "en_US")
    for roadNumber in span.roadNumbers.items {
        if roadNumber.localizedNumber.locale == desiredLocale {
            localizedRoadNumber = roadNumber
            break
        }
    }

    // The route type indicates if this is a major road or not.
    let routeType = localizedRoadNumber.routeType
    // The text that should be shown on the road shield.
    let shieldText = span.getShieldText(roadNumber: localizedRoadNumber)
    // This text is used to additionally determine the road shield's visuals.
    let routeNumberName = localizedRoadNumber.localizedNumber.text

    if lastRoadShieldText == shieldText {
        // It looks like this shield was already created before, so we opt out.
        return
    }

    lastRoadShieldText = shieldText

    // Most icons can be created even if some properties are empty.
    // If countryCode is empty, then this will result in an IconProviderError.ICON_NOT_FOUND. Practically,
    // the country code should never be null, unless when there is a very rare data issue.
    let countryCode = span.countryCode ?? ""
    let stateCode = span.countryCode ?? ""

    let roadShieldIconProperties = RoadShieldIconProperties(
        routeType: routeType,
        countryCode: countryCode,
        stateCode: stateCode,
        routeNumberName: routeNumberName,
        shieldText: shieldText
    )

    // Set the desired constraints. The icon will fit in while preserving its aspect ratio.
    let widthConstraintInPixels: UInt32 = ManeuverView.roadShieldDimConstraints
    let heightConstraintInPixels: UInt32 = ManeuverView.roadShieldDimConstraints

    // Create the icon offline. Several icons could be created in parallel, but in reality, the road shield
    // will not change very quickly, so that a previous icon will not be overwritten by a parallel call.
    iconProvider.createRoadShieldIcon(properties: roadShieldIconProperties,
                                      mapScheme: MapScheme.normalDay,
                                      assetType: IconProviderAssetType.ui,
                                      widthConstraintInPixels: widthConstraintInPixels,
                                      heightConstraintInPixels: heightConstraintInPixels,
                                      callback: handleIconProviderCallback)
}

private func handleIconProviderCallback(image: UIImage?,
                                        description: String?,
                                        error: IconProviderError?) {
    if let iconProviderError = error {
        print("Cannot create road shield icon: \(iconProviderError.rawValue)")
        return
    }

    // If iconProviderError is nil, it is guaranteed that bitmap and description are not nil.
    guard let roadShieldIcon = image else {
        return
    }

    // A further description of the generated icon, such as "Federal" or "Autobahn".
    let shieldDescription = description ?? ""
    print("New road shield icon: \(shieldDescription)")

    // An implementation can now decide to show the icon, for example, together with the
    // next maneuver actions.
    uiCallback?.onRoadShieldEvent(roadShieldIcon: roadShieldIcon)
}

do {
    try mapMatcher = MapMatcher(sdkEngine: sdkNativeEngineInstance, useRenderingLayers: useRenderingLayers)
} catch let InstantiationError {
    fatalError("Initialization failed. Cause: \(InstantiationError)")
}

private func matchLocation(geoCoordinates: GeoCoordinates) {
      let location = Location(coordinates: geoCoordinates, time: Date())

      guard let mapMatcher = mapMatcher else {
          print("MapMatcher is not available")
          return
      }

      let mapMatchedLocation = mapMatcher.match(location: location)

      // A null mapMatchedLocation indicates that the location could not be matched to the road network.
      // This means the location is offroad or the data is not in the cache.
      if let matchedLocation = mapMatchedLocation {
          showDialog(title: "MapMatcher", message: "Map-matched location is highlighted with red dot on the map. Check logs for more information on matched location.")

          // Show the map-matched location on the map.
          if let marker = addMapMarker(geoCoordinates: matchedLocation.coordinates, imageName: "map_matched_location_dot.png") {
              mapMatcherMapMarker = marker
          }

          // Fetch IDs from mapMatchedLocation and convert them into OCMSegmentID required by loadSegmentData method.
          let mapMatchedSegmentId: OCMSegmentId = OCMSegmentId(tilePartitionId: Int32(matchedLocation.segmentReference.tilePartitionId), localId: Int32(matchedLocation.segmentReference.localId!))

          loadSegmentData(ocmSegmentId: mapMatchedSegmentId)
      } else {
          print("Location could not be map-matched. Check if the picked location is within 50-meter radius of a road.")
      }
  }

visualNavigator.navigableLocationDelegate = self

...

// Conform to NavigableLocationDelegate.
// Notifies on the current map-matched location and other useful information while driving or walking.
func onNavigableLocationUpdated(_ navigableLocation: NavigableLocation) {
    guard navigableLocation.mapMatchedLocation != nil else {
        print("The currentNavigableLocation could not be map-matched. Are you off-road?")
        return
    }

    lastMapMatchedLocation = navigableLocation.mapMatchedLocation!

    let latitude = mapMatchedLocation.coordinates.latitude
    let longitude = mapMatchedLocation.coordinates.longitude
    print("MapMatchedLocation - Lat: \(latitude), Lon: \(longitude)")

    if (navigableLocation.mapMatchedLocation?.isDrivingInTheWrongWay == true) {
        // For two-way streets, this value is always false. This feature is supported in tracking mode and when deviating from a route.
        print("This is a one way road. User is driving against the allowed traffic direction.");
    }

    let speed = navigableLocation.originalLocation.speedInMetersPerSecond
    let accuracy = navigableLocation.originalLocation.speedAccuracyInMetersPerSecond
    print("Driving speed: \(String(describing: speed)) plus/minus accuracy of \(String(describing: accuracy)).")
}

// Conform to DestinationReachedDelegate.
// Notifies when the destination of the route is reached.
func onDestinationReached() {
    guard let lastSection = lastCalculatedRoute?.sections.last else {
        // A new route is calculated, drop out.
        return
    }
    if lastSection.arrivalPlace.isOffRoad() {
        print("End of navigable route reached.")
        let message1 = "Your destination is off-road."
        let message2 = "Follow the dashed line with caution."
        // Note that for this example we inform the user via UI.
        uiCallback?.onManeuverEvent(action: ManeuverAction.arrive,
                                   message1: message1,
                                   message2: message2)
    } else {
        print("Destination reached.")
        let distanceText = "0 m"
        let message = "You have reached your destination."
        uiCallback?.onManeuverEvent(action: ManeuverAction.arrive,
                                   message1: distanceText,
                                   message2: message)
    }
}

// Conform to OffRoadProgressDelegate.
// Notifies on the progress when heading towards an off-road destination.
// Off-road progress events will be sent only after the user has reached
// the map-matched destination and the original destination is off-road.
// Note that when a location cannot be map-matched to a road, then it is considered
// to be off-road.
func onOffRoadProgressUpdated(_ offRoadProgress: heresdk.OffRoadProgress) {
    let distanceText = convertDistance(meters: offRoadProgress.remainingDistanceInMeters)
    // Bearing of the destination compared to the user's current position.
    // The bearing angle indicates the direction into which the user should walk in order
    // to reach the off-road destination - when the device is held up in north-up direction.
    // For example, when the top of the screen points to true north, then 180° means that
    // the destination lies in south direction. 315° would mean the user has to head north-west, and so on.
    let message = "Direction of your destination: \(round(offRoadProgress.bearingInDegrees))°"
    uiCallback?.onManeuverEvent(action: ManeuverAction.arrive,
                                message1: distanceText,
                                message2: message)
}

// Conform to OffRoadDestinationReachedDelegate.
// Notifies when the off-road destination of the route has been reached (if any).
func onOffRoadDestinationReached() {
    print("Off-road destination reached.")
    let distanceText = "0 m"
    let message = "You have reached your off-road destination."
    uiCallback?.onManeuverEvent(action: ManeuverAction.arrive,
                                message1: distanceText,
                                message2: message)
}

// Enable off-road visualization (if any) with a dotted straight-line
// between the map-matched and the original destination (which is off-road).
// Note that the color of the dashed line can be customized, if desired.
// The line will not be rendered if the destination is not off-road.
// By default, this is enabled.
visualNavigator.isOffRoadDestinationVisible = true

// Enable route handle.
var routingOptions = RoutingOptions()
routingOptions.routeOptions.enableRouteHandle = true

private class func createDynamicRoutingEngine() -> DynamicRoutingEngine {
    // Both, minTimeDifference and minTimeDifferencePercentage, will be checked:
    // When the poll interval is reached, the smaller difference will win.
    let minTimeDifferencePercentage = 0.1
    let minTimeDifferenceInSeconds: TimeInterval = 1
    // Below, we use 10 minutes. A common range is between 5 and 15 minutes.
    let pollIntervalInSeconds: TimeInterval = 10 * 60

    let dynamicRoutingOptions =
        DynamicRoutingEngineOptions(minTimeDifferencePercentage: minTimeDifferencePercentage,
                                    minTimeDifference: minTimeDifferenceInSeconds,
                                    pollInterval: pollIntervalInSeconds)

    do {
        // With the dynamic routing engine you can poll the HERE backend services to search for routes with less traffic.
        // This can happen during guidance - or you can periodically update a route that is shown in a route planner.
        //
        // Make sure to call dynamicRoutingEngine.updateCurrentLocation(...) to trigger execution. If this is not called,
        // no events will be delivered even if the next poll interval has been reached.
        return try DynamicRoutingEngine(options: dynamicRoutingOptions)
    } catch let engineInstantiationError {
        fatalError("Failed to initialize DynamicRoutingEngine. Cause: \(engineInstantiationError)")
    }
}

private func startDynamicSearchForBetterRoutes(_ route: Route) {
    do {
        // Note that the engine will be internally stopped, if it was started before.
        // Therefore, it is not necessary to stop the engine before starting it again.
        try dynamicRoutingEngine.start(route: route, delegate: self)
    } catch let instantiationError {
        fatalError("Start of DynamicRoutingEngine failed: \(instantiationError). Is the RouteHandle missing?")
    }
}

// Conform to the DynamicRoutingDelegate.
// Notifies on traffic-optimized routes that are considered better than the current route.
func onBetterRouteFound(newRoute: Route,
                        etaDifferenceInSeconds: Int32,
                        distanceDifferenceInMeters: Int32) {
    print("DynamicRoutingEngine: Calculated a new route.")
    print("DynamicRoutingEngine: etaDifferenceInSeconds: \(etaDifferenceInSeconds).")
    print("DynamicRoutingEngine: distanceDifferenceInMeters: \(distanceDifferenceInMeters).")

    // An implementation needs to decide when to switch to the new route based
    // on above criteria.
}

// Conform to the DynamicRoutingDelegate.
func onRoutingError(routingError: RoutingError) {
    print("Error while dynamically searching for a better route: \(routingError).")
}

dynamicRoutingEngine.updateCurrentLocation(mapMatchedLocation: lastMapMatchedLocation,
                                           sectionIndex: routeProgress.routeMatchedLocation.sectionIndex)