// Get notification distances for road sign alerts from visual navigator.
var warningNotificationDistances = visualNavigator.getWarningNotificationDistances(warningType: WarningType.roadSign)

// The distance in meters for emitting warnings when the speed limit or current speed is fast. Defaults to 1500.
warningNotificationDistances.fastSpeedDistanceInMeters = 1600;
// The distance in meters for emitting warnings when the speed limit or current speed is regular. Defaults to 750.
warningNotificationDistances.regularSpeedDistanceInMeters = 800;
// The distance in meters for emitting warnings when the speed limit or current speed is slow. Defaults to 500.
warningNotificationDistances.slowSpeedDistanceInMeters = 600;

// Set the warning distances for road signs.
visualNavigator.setWarningNotificationDistances(warningType: WarningType.roadSign, warningNotificationDistances: warningNotificationDistances)

// Conform to SpeedLimitDelegate.
// Notifies on the current speed limit valid on the current road.
func onSpeedLimitUpdated(_ speedLimit: SpeedLimit) {
    let speedLimit = getCurrentSpeedLimit(speedLimit)

    if speedLimit == nil {
        print("Warning: Speed limits unknown, data could not be retrieved.")
    } else if speedLimit == 0 {
        print("No speed limits on this road! Drive as fast as you feel safe ...")
    } else {
        print("Current speed limit (m/s): \(String(describing: speedLimit))")
    }
}

private func getCurrentSpeedLimit(_ speedLimit: SpeedLimit) -> Double? {
    // Note that all values can be nil if no data is available.

    // The regular speed limit if available. In case of unbounded speed limit, the value is zero.
    print("speedLimitInMetersPerSecond: \(String(describing: speedLimit.speedLimitInMetersPerSecond))")

    // A conditional school zone speed limit as indicated on the local road signs.
    print("schoolZoneSpeedLimitInMetersPerSecond: \(String(describing: speedLimit.schoolZoneSpeedLimitInMetersPerSecond))")

    // A conditional time-dependent speed limit as indicated on the local road signs.
    // It is in effect considering the current local time provided by the device's clock.
    print("timeDependentSpeedLimitInMetersPerSecond: \(String(describing: speedLimit.timeDependentSpeedLimitInMetersPerSecond))")

    // A conditional non-legal speed limit that recommends a lower speed,
    // for example, due to bad road conditions.
    print("advisorySpeedLimitInMetersPerSecond: \(String(describing: speedLimit.advisorySpeedLimitInMetersPerSecond))")

    // A weather-dependent speed limit as indicated on the local road signs.
    // The HERE SDK cannot detect the current weather condition, so a driver must decide
    // based on the situation if this speed limit applies.
    print("fogSpeedLimitInMetersPerSecond: \(String(describing: speedLimit.fogSpeedLimitInMetersPerSecond))")
    print("rainSpeedLimitInMetersPerSecond: \(String(describing: speedLimit.rainSpeedLimitInMetersPerSecond))")
    print("snowSpeedLimitInMetersPerSecond: \(String(describing: speedLimit.snowSpeedLimitInMetersPerSecond))")

    // For convenience, this returns the effective (lowest) speed limit between
    // - speedLimitInMetersPerSecond
    // - schoolZoneSpeedLimitInMetersPerSecond
    // - timeDependentSpeedLimitInMetersPerSecond
    return speedLimit.effectiveSpeedLimitInMetersPerSecond()
}

// Conform to SpeedWarningDelegate.
// Notifies when the current speed limit is exceeded.
func onSpeedWarningStatusChanged(_ status: SpeedWarningStatus) {
    if status == SpeedWarningStatus.speedLimitExceeded {
        // Driver is faster than current speed limit (plus an optional offset).
        // Play a notification sound to alert the driver.
        // Note that this may not include temporary special speed limits, see SpeedLimitDelegate.
        AudioServicesPlaySystemSound(SystemSoundID(1016))
    }

    if status == SpeedWarningStatus.speedLimitRestored {
        print("Driver is again slower than current speed limit (plus an optional offset).")
    }
}

private func setupSpeedWarnings() {
    let speedLimitOffset = SpeedLimitOffset(lowSpeedOffsetInMetersPerSecond: 2,
                                            highSpeedOffsetInMetersPerSecond: 4,
                                            highSpeedBoundaryInMetersPerSecond: 25)
    visualNavigator.speedWarningOptions = SpeedWarningOptions(speedLimitOffset: speedLimitOffset)
}

private func setupRoadSignWarnings() {
    var roadSignWarningOptions = RoadSignWarningOptions()
    // Set a filter to get only road signs relevant for trucks and heavyTrucks.
    roadSignWarningOptions.vehicleTypesFilter = [RoadSignVehicleType.trucks, RoadSignVehicleType.heavyTrucks]
    visualNavigator.roadSignWarningOptions = roadSignWarningOptions
}

...

// Conform to the RoadSignWarningDelegate.
// Notifies on road signs as they appear along the road.
func onRoadSignWarningUpdated(_ roadSignWarning: RoadSignWarning) {
    let roadSignType: RoadSignType = roadSignWarning.type
    if (roadSignWarning.distanceType == DistanceType.ahead) {
        print("A RoadSignWarning of road sign type: \(roadSignType) ahead in (m): \(roadSignWarning.distanceToRoadSignInMeters)")
    } else if (roadSignWarning.distanceType == DistanceType.passed) {
        print("A RoadSignWarning of road sign type: \(roadSignType) just passed.")
    }

    if let signValue = roadSignWarning.signValue {
        // Optional text as it is printed on the local road sign.
        print("Road sign text: " + signValue.text)
    }

    // For more road sign attributes, please check the API Reference.
}

// Conform to TollStopWarningDelegate.
// Notifies on upcoming toll stops. Uses the same notification
// thresholds as other warners and provides events with or without a route to follow.
func onTollStopWarning(_ tollStop: TollStop) {
    let lanes = tollStop.lanes

    // The lane at index 0 is the leftmost lane adjacent to the middle of the road.
    // The lane at the last index is the rightmost lane.
    let laneNumber = 0
    for tollBoothLane in lanes {
        // Log which vehicles types are allowed on this lane that leads to the toll booth.
        logLaneAccess(laneNumber, tollBoothLane.access)
        let tollBooth = tollBoothLane.booth
        let tollCollectionMethods = tollBooth.tollCollectionMethods
        let paymentMethods = tollBooth.paymentMethods
        // The supported collection methods like ticket or automatic / electronic.
        for collectionMethod in tollCollectionMethods {
            print("This toll stop supports collection via: \(collectionMethod).")
        }
        // The supported payment methods like cash or credit card.
        for paymentMethod in paymentMethods {
            print("This toll stop supports payment via: \(paymentMethod).")
        }
        laneNumber += 1
    }
}

func logLaneAccess(_ laneNumber: Int, _ laneAccess: LaneAccess) {
    print("Lane access for lane \(laneNumber).")
    print("Automobiles are allowed on this lane: \(laneAccess.automobiles).")
    print("Buses are allowed on this lane: \(laneAccess.buses).")
    print("Taxis are allowed on this lane: \(laneAccess.taxis).")
    print("Carpools are allowed on this lane: \(laneAccess.carpools).")
    print("Pedestrians are allowed on this lane: \(laneAccess.pedestrians).")
    print("Trucks are allowed on this lane: \(laneAccess.trucks).")
    print("ThroughTraffic is allowed on this lane: \(laneAccess.throughTraffic).")
    print("DeliveryVehicles are allowed on this lane: \(laneAccess.deliveryVehicles).")
    print("EmergencyVehicles are allowed on this lane: \(laneAccess.emergencyVehicles).")
    print("Motorcycles are allowed on this lane: \(laneAccess.motorcycles).")
}

var safetyCameraWarningOptions = SafetyCameraWarningOptions()
safetyCameraWarningOptions.enableTextNotification = true
visualNavigator.safetyCameraWarningOptions = safetyCameraWarningOptions

// Notifies on safety camera warnings as they appear along the road.
func onSafetyCameraWarningUpdated(_ safetyCameraWarning: SafetyCameraWarning) {
  // Safety camera warning GeoCoordinates can only be fetched in non-tracking mode.
  guard let currentRoute = visualNavigator.route else {
      fatalError("Route cannot be nil")
  }

  let safetyCameraGeoCoordinates: GeoCoordinates = getGeocoordinatesForRemainingDistance(
      routeProgress: currentRouteProgress!,
      remainingObjectDistanceInMeters: safetyCameraWarning.distanceToCameraInMeters,
      currentRoute: currentRoute
  )

  if safetyCameraWarning.distanceType == .ahead {
      print("Safety camera warning \(safetyCameraWarning.type) ahead in: " +
            "\(safetyCameraWarning.distanceToCameraInMeters) m " +
            "with speed limit = \(safetyCameraWarning.speedLimitInMetersPerSecond) m/s " +
            "at geo-coordinates: \(geoCoordinatesToString(safetyCameraGeoCoordinates))")
  } else if safetyCameraWarning.distanceType == .passed {
      print("Safety camera warning \(safetyCameraWarning.type) passed: \(safetyCameraWarning.distanceToCameraInMeters) with speed limit = \(safetyCameraWarning.speedLimitInMetersPerSecond)m/s")
  } else if safetyCameraWarning.distanceType == .reached {
      print("Safety camera warning \(safetyCameraWarning.type) reached at: \(safetyCameraWarning.distanceToCameraInMeters) with speed limit = \(safetyCameraWarning.speedLimitInMetersPerSecond)m/s")
  }
}

// Returns the GeoCoordinates for an object located at the end of the remaining distance.
private func getGeocoordinatesForRemainingDistance(
    routeProgress: RouteProgress,
    remainingObjectDistanceInMeters: Double,
    currentRoute: Route
) -> GeoCoordinates {
    let currentCCPOffsetInMeters = getOffsetOfCCPOnRouteInMeters(routeProgress: routeProgress, currentRoute: currentRoute)

    // Calculate the offset along the route for the given object.
    let remainingDistanceOffsetInMeters = currentCCPOffsetInMeters + remainingObjectDistanceInMeters

    return getGeoCoordinatesFromOffsetInMeters(
        geoPolyline: currentRoute.geometry,
        offsetInMeters: remainingDistanceOffsetInMeters
    )
}

// Returns the offset of the current camera position (CCP) on the route in meters.
private func getOffsetOfCCPOnRouteInMeters(
    routeProgress: RouteProgress,
    currentRoute: Route
) -> Double {
    let totalLength = Double(currentRoute.lengthInMeters)

    // SectionProgress is guaranteed to be non-empty.
    guard let lastSectionProgress = routeProgress.sectionProgress.last else {
        return 0.0
    }

    let remainingDistance = Double(lastSectionProgress.remainingDistanceInMeters)
    return totalLength - remainingDistance
}

// Converts an offset in meters along a GeoPolyline to GeoCoordinates using HERE SDK's coordinatesAtOffsetInMeters.
private func getGeoCoordinatesFromOffsetInMeters(
    geoPolyline: GeoPolyline,
    offsetInMeters: Double
) -> GeoCoordinates {
    return geoPolyline.coordinatesAt(offsetInMeters: offsetInMeters, direction: .fromBeginning)
}

private func setupManeuverNotificationOptions() {
        var maneuverNotificationOptions = ManeuverNotificationOptions()

        maneuverNotificationOptions.enableLaneRecommendation = true
        visualNavigator.maneuverNotificationOptions = maneuverNotificationOptions
    }

// Conform to SchoolZoneWarningDelegate.
// Notifies on school zones ahead.
func onSchoolZoneWarningUpdated(_ schoolZoneWarnings: [heresdk.SchoolZoneWarning]) {
    // The list is guaranteed to be non-empty.
    for schoolZoneWarning in schoolZoneWarnings {
      if schoolZoneWarning.distanceType == DistanceType.ahead {
        print("A school zone ahead in: \(schoolZoneWarning.distanceToSchoolZoneInMeters) meters.")
        // Note that this will be the same speed limit as indicated by SpeedLimitDelegate, unless
        // already a lower speed limit applies, for example, because of a heavy truck load.
        print("Speed limit restriction for this school zone: \(schoolZoneWarning.speedLimitInMetersPerSecond) m/s.")
          if let timeRule = schoolZoneWarning.timeRule {
              if timeRule.appliesTo(dateTime: Date()) {
              // For example, during night sometimes a school zone warning does not apply.
              // If schoolZoneWarning.timeRule is nil, the warning applies at anytime.
              print("Note that this school zone warning currently does not apply.")
          }
        }
      } else if schoolZoneWarning.distanceType == DistanceType.reached {
        print("A school zone has been reached.")
      } else if schoolZoneWarning.distanceType == DistanceType.passed {
        print("A school zone has been passed.")
      }
    }
}

private func setupSchoolZoneWarnings() {
    var schoolZoneWarningOptions = SchoolZoneWarningOptions()
    schoolZoneWarningOptions.filterOutInactiveTimeDependentWarnings = true
    schoolZoneWarningOptions.warningDistanceInMeters = 150
    visualNavigator.schoolZoneWarningOptions = schoolZoneWarningOptions
}

// Conform to BorderCrossingWarningDelegate.
// Notifies whenever a country border is crossed and optionally, by default, also when
// a state borders are crossed within a country.
func onBorderCrossingWarningUpdated(_ borderCrossingWarning: BorderCrossingWarning) {
    // Since the border crossing warning is given relative to a single location,
    // the .reached case will never be given for this warning.
    if borderCrossingWarning.distanceType == .ahead {
        print("BorderCrossing: A border is ahead in: \(borderCrossingWarning.distanceToBorderCrossingInMeters) meters.")
        print("BorderCrossing: Type (such as country or state): \(borderCrossingWarning.type)")
        print("BorderCrossing: Country code: \(borderCrossingWarning.countryCode)")

        // The state code after the border crossing. It represents the state / province code.
        // It is a 1 to 3 upper-case characters string that follows the ISO 3166-2 standard,
        // but without the preceding country code (e.g., for Texas, the state code will be TX).
        // It will be nil for countries without states or countries in which the states have very
        // similar regulations (e.g., for Germany, there will be no state borders).
        if let stateCode = borderCrossingWarning.stateCode {
            print("BorderCrossing: State code: \(stateCode)")
        }

        // The general speed limits that apply in the country / state after border crossing.
        let generalVehicleSpeedLimits = borderCrossingWarning.speedLimits
        print("BorderCrossing: Speed limit in cities (m/s): \(String(describing: generalVehicleSpeedLimits.maxSpeedUrbanInMetersPerSecond))")
        print("BorderCrossing: Speed limit outside cities (m/s): \(String(describing: generalVehicleSpeedLimits.maxSpeedRuralInMetersPerSecond))")
        print("BorderCrossing: Speed limit on highways (m/s): \(String(describing: generalVehicleSpeedLimits.maxSpeedHighwaysInMetersPerSecond))")
    } else if borderCrossingWarning.distanceType == .passed {
        print("BorderCrossing: A border has been passed.")
    }
}

private func setupBorderCrossingWarnings() {
    var borderCrossingWarningOptions = BorderCrossingWarningOptions()
    // If set to true, all the state border crossing notifications will not be given.
    // If the value is false, all border crossing notifications will be given for both
    // country borders and state borders. Defaults to false
    borderCrossingWarningOptions.filterOutStateBorderWarnings = true
    visualNavigator.borderCrossingWarningOptions = borderCrossingWarningOptions
}

// Conform to DangerZoneWarningDelegate.
// Notifies on danger zones.
_visualNavigator.dangerZoneWarningListener = DangerZoneWarningListener((DangerZoneWarning dangerZoneWarning) {
  if (dangerZoneWarning.distanceType == DistanceType.ahead) {
    print("A danger zone ahead in: " + dangerZoneWarning.distanceInMeters.toString() + " meters.");
    // isZoneStart indicates if we enter the danger zone from the start.
    // It is false, when the danger zone is entered from a side street.
    // Based on the route path, the HERE SDK anticipates from where the danger zone will be entered.
    // In tracking mode, the most probable path will be used to anticipate from where
    // the danger zone is entered.
    print("isZoneStart: " + dangerZoneWarning.isZoneStart.toString());
  } else if (dangerZoneWarning.distanceType == DistanceType.reached) {
    print("A danger zone has been reached. isZoneStart: " + dangerZoneWarning.isZoneStart.toString());
  } else if (dangerZoneWarning.distanceType == DistanceType.passed) {
    print("A danger zone has been passed.");
  }
});

// Conform to LowSpeedZoneWarningDelegate.
// Notifies on low speed zones ahead - as indicated also on the map when
// MapFeatures.lowSpeedZones is set.
func onLowSpeedZoneWarningUpdated(_ lowSpeedZoneWarning: heresdk.LowSpeedZoneWarning) {
    if (lowSpeedZoneWarning.distanceType == DistanceType.ahead) {
        print("A low speed zone ahead in: \(lowSpeedZoneWarning.distanceToLowSpeedZoneInMeters) meters.")
        print("Speed limit in low speed zone (m/s):  \(lowSpeedZoneWarning.speedLimitInMetersPerSecond)")
    } else if (lowSpeedZoneWarning.distanceType == DistanceType.reached) {
        print("A low speed zone has been reached.")
        print("Speed limit in low speed zone (m/s):  \(lowSpeedZoneWarning.speedLimitInMetersPerSecond)")
    } else if (lowSpeedZoneWarning.distanceType == DistanceType.passed) {
        print("A low speed zone has been passed.")
    }
}

// Conform to the RoadAttributesDelegate.
// Notifies on the attributes of the current road including usage and physical characteristics.
func onRoadAttributesUpdated(_ roadAttributes: RoadAttributes) {
    // This is called whenever any road attribute has changed.
    // If all attributes are unchanged, no new event is fired.
    // Note that a road can have more than one attribute at the same time.
    print("Received road attributes update.")

    if (roadAttributes.isBridge) {
      // Identifies a structure that allows a road, railway, or walkway to pass over another road, railway,
      // waterway, or valley serving map display and route guidance functionalities.
        print("Road attributes: This is a bridge.")
    }
    if (roadAttributes.isControlledAccess) {
      // Controlled access roads are roads with limited entrances and exits that allow uninterrupted
      // high-speed traffic flow.
        print("Road attributes: This is a controlled access road.")
    }
    if (roadAttributes.isDirtRoad) {
      // Indicates whether the navigable segment is paved.
        print("Road attributes: This is a dirt road.")
    }
    if (roadAttributes.isDividedRoad) {
      // Indicates if there is a physical structure or painted road marking intended to legally prohibit
      // left turns in right-side driving countries, right turns in left-side driving countries,
      // and U-turns at divided intersections or in the middle of divided segments.
        print("Road attributes: This is a divided road.")
    }
    if (roadAttributes.isNoThrough) {
      // Identifies a no through road.
        print("Road attributes: This is a no through road.")
    }
    if (roadAttributes.isPrivate) {
      // Private identifies roads that are not maintained by an organization responsible for maintenance of
      // public roads.
        print("Road attributes: This is a private road.")
    }
    if (roadAttributes.isRamp) {
      // Range is a ramp: connects roads that do not intersect at grade.
        print("Road attributes: This is a ramp.")
    }
    if (roadAttributes.isRightDrivingSide) {
      // Indicates if vehicles have to drive on the right-hand side of the road or the left-hand side.
      // For example, in New York it is always true and in London always false as the United Kingdom is
      // a left-hand driving country.
        print("Road attributes: isRightDrivingSide = \(roadAttributes.isRightDrivingSide)")
    }
    if (roadAttributes.isRoundabout) {
      // Indicates the presence of a roundabout.
        print("Road attributes: This is a roundabout.")
    }
    if (roadAttributes.isTollway) {
      // Identifies a road for which a fee must be paid to use the road.
        print("Road attributes change: This is a road with toll costs.")
    }
    if (roadAttributes.isTunnel) {
      // Identifies an enclosed (on all sides) passageway through or under an obstruction.
        print("Road attributes: This is a tunnel.")
    }
}

// Conform to TrafficMergeWarningDelegate.
// Notifies about merging traffic to the current road.
func onTrafficMergeWarningUpdated(_ trafficMergeWarning: TrafficMergeWarning) {
    if trafficMergeWarning.distanceType == .ahead {
        print("There is a merging \(trafficMergeWarning.distanceType) ahead in: \(trafficMergeWarning.distanceToTrafficMergeInMeters) meters, merging from the \(trafficMergeWarning.side) side, with lanes = \(trafficMergeWarning.laneCount)")
    } else if trafficMergeWarning.distanceType == .passed {
        print("A merging \(trafficMergeWarning.distanceType) passed: \(trafficMergeWarning.distanceToTrafficMergeInMeters) meters, merging from the \(trafficMergeWarning.side) side, with lanes = \(trafficMergeWarning.laneCount)")
    } else if trafficMergeWarning.distanceType == .reached {
        // Since the traffic merge warning is given relative to a single position on the route,
        // DistanceType.reached will never be given for this warning.
    }
}

private func setupRealisticViewWarnings() {
    var realisticViewWarningOptions = RealisticViewWarningOptions(aspectRatio: AspectRatio.aspectRatio3X4, darkTheme: false)
    visualNavigator.realisticViewWarningOptions = realisticViewWarningOptions

    visualNavigator.realisticViewWarningDelegate = self
}

// Notifies on signposts together with complex junction views.
// Signposts are shown as they appear along a road on a shield to indicate the upcoming directions and
// destinations, such as cities or road names.
// Junction views appear as a 3D visualization (as a static image) to help the driver to orientate.
//
// Optionally, you can use a feature-configuration to preload the assets as part of a Region.
//
// The event matches the notification for complex junctions, see JunctionViewLaneAssistance.
// Note that the SVG data for junction view is composed out of several 3D elements,
// a horizon and the actual junction geometry.
func onRealisticViewWarningUpdated(_ realisticViewWarning: RealisticViewWarning) {
    let distance = realisticViewWarning.distanceToRealisticViewInMeters
    let distanceType: DistanceType = realisticViewWarning.distanceType

    // Note that DistanceType.reached is not used for Signposts and junction views
    // as a junction is identified through a location instead of an area.
    if distanceType == DistanceType.ahead {
        print("A RealisticView ahead in: " + String(distance) + " meters.")
    } else if distanceType == DistanceType.passed {
        print("A RealisticView just passed.")
    }

    let realisticView = realisticViewWarning.realisticViewVectorImage
    guard let signpostSvgImageContent = realisticView?.signpostSvgImageContent,
          let junctionViewSvgImageContent = realisticView?.junctionViewSvgImageContent
    else {
        print("A RealisticView just passed. No SVG data delivered.")
        return
    }

    // The resolution-independent SVG data can now be used in an application to visualize the image.
    // Use a SVG library of your choice to create an SVG image out of the SVG string.
    // Both SVGs contain the same dimension and the signpostSvgImageContent should be shown on top of
    // the junctionViewSvgImageContent.
    // The images can be quite detailed, therefore it is recommended to show them on a secondary display
    // in full size.
    print("signpostSvgImage: \(signpostSvgImageContent)")
    print("junctionViewSvgImage: \(junctionViewSvgImageContent)")
}

<key>UIAppFonts</key>
<array>
    <string>FiraGO-Map.ttf</string>
    <string>SignText-Bold.ttf</string>
    <string>SignTextNarrow-Bold.ttf</string>
    <string>SourceHanSansSC-Normal.ttf</string>
</array>

private func showRealisticViews(signpostSvgImageContent: String,
                                junctionViewSvgImageContent: String) {
    var signpostSvgImageContent = signpostSvgImageContent

    // Create a View from the SVG strings with the SVGView library.
    let signpostSvgImage = SVGView(string: signpostSvgImageContent)
    let junctionViewSvgImage = SVGView(string: junctionViewSvgImageContent)

    if (signpostSvgImage.svg == nil || junctionViewSvgImage.svg == nil) {
        print("Unexpectedly, the SVG string could not be parsed.")
        return
    }

    // Define the layout for the realistic view.
    struct SVGUIView: View {
        var junctionViewSvgImage: SVGView?
        var signpostSvgImage: SVGView?
        var width: CGFloat = 0
        var height: CGFloat = 0
        var body: some View {
            ZStack {
                // Show the signpost image on top of the junction view image.
                junctionViewSvgImage
                signpostSvgImage
            }.frame(width: width, height: height)
        }
    }

    // Set the content for the realistic view.
    // We use the hosting view's frame to show the content fullscreen.
    //
    // Attention: In a production-app, be careful to not distract a driver.
    // It is recommended to show this on a secondary display that resets
    // automatically after some time or when the junction was passed.
    var realisticView = SVGUIView()
    realisticView.signpostSvgImage = signpostSvgImage
    realisticView.junctionViewSvgImage = junctionViewSvgImage
    realisticView.width = view.frame.size.width
    realisticView.height = view.frame.size.height

    // The SVGView library supports only iOS 14 and Swift UI:
    // Therefore, here we optionally need to convert the View to a UIView
    // by using a hosting controller.
    let uiView = UIHostingController(rootView: realisticView).view!

    // ... now show the view.
}

// Conform to EnvironmentalZoneWarningDelegate.
func onEnvironmentalZoneWarningsUpdated(_ environmentalZonesWarnings: [heresdk.EnvironmentalZoneWarning]) {
    // The list is guaranteed to be non-empty.
    environmentalZonesWarnings.forEach { environmentalZoneWarning in
        let distanceType = environmentalZoneWarning.distanceType
        if distanceType == .ahead {
            print("A EnvironmentalZone ahead in: \(environmentalZoneWarning.distanceInMeters) meters.")
        } else if distanceType == .reached {
            print("A EnvironmentalZone has been reached.")
        } else if distanceType == .passed {
            print("A EnvironmentalZone just passed.")
        }

        // The official name of the environmental zone (example: "Zone basse émission Bruxelles").
        let name = environmentalZoneWarning.name
        // The description of the environmental zone for the default language.
        let description = environmentalZoneWarning.description.defaultValue
        // The environmental zone ID - uniquely identifies the zone in the HERE map data.
        let zoneID = environmentalZoneWarning.zoneId
        // The website of the environmental zone, if available - nil otherwise.
        let websiteUrl = environmentalZoneWarning.websiteUrl
        print("environmentalZoneWarning: description: \(String(describing: description))")
        print("environmentalZoneWarning: name: \(name)")
        print("environmentalZoneWarning: zoneID: \(zoneID)")
        print("environmentalZoneWarning: websiteUrl: \(websiteUrl ?? "nil")")
    }
}