// Get notification distances for road sign alerts from visual navigator.
WarningNotificationDistances warningNotificationDistances = visualNavigator.getWarningNotificationDistances(WarningType.ROAD_SIGN);
// 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 distance for road signs.
visualNavigator.setWarningNotificationDistances(WarningType.ROAD_SIGN, warningNotificationDistances);

// Get notification distances for road sign alerts from visual navigator.
val warningNotificationDistances = visualNavigator.getWarningNotificationDistances(WarningType.ROAD_SIGN)
// 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.ROAD_SIGN,
    warningNotificationDistances
)

// Notifies on the current speed limit valid on the current road.
visualNavigator.setSpeedLimitListener(new SpeedLimitListener() {
    @Override
    public void onSpeedLimitUpdated(@NonNull SpeedLimit speedLimit) {
        Double currentSpeedLimit = getCurrentSpeedLimit(speedLimit);

        if (currentSpeedLimit == null) {
            Log.d(TAG, "Warning: Speed limits unknown, data could not be retrieved.");
        } else if (currentSpeedLimit == 0) {
            Log.d(TAG, "No speed limits on this road! Drive as fast as you feel safe ...");
        } else {
            Log.d(TAG, "Current speed limit (m/s):" + currentSpeedLimit);
        }
    }
});

private Double getCurrentSpeedLimit(SpeedLimit speedLimit) {

    // Note that all values can be null if no data is available.

    // The regular speed limit if available. In case of unbounded speed limit, the value is zero.
    Log.d(TAG,"speedLimitInMetersPerSecond: " + speedLimit.speedLimitInMetersPerSecond);

    // A conditional school zone speed limit as indicated on the local road signs.
    Log.d(TAG,"schoolZoneSpeedLimitInMetersPerSecond: " + 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.
    Log.d(TAG,"timeDependentSpeedLimitInMetersPerSecond: " + speedLimit.timeDependentSpeedLimitInMetersPerSecond);

    // A conditional non-legal speed limit that recommends a lower speed,
    // for example, due to bad road conditions.
    Log.d(TAG,"advisorySpeedLimitInMetersPerSecond: " + 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.
    Log.d(TAG,"fogSpeedLimitInMetersPerSecond: " + speedLimit.fogSpeedLimitInMetersPerSecond);
    Log.d(TAG,"rainSpeedLimitInMetersPerSecond: " + speedLimit.rainSpeedLimitInMetersPerSecond);
    Log.d(TAG,"snowSpeedLimitInMetersPerSecond: " + speedLimit.snowSpeedLimitInMetersPerSecond);

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

// Notifies on the current speed limit valid on the current road.
// Notifies on the current speed limit valid on the current road.
visualNavigator.speedLimitListener = SpeedLimitListener { speedLimit: SpeedLimit ->
    val currentSpeedLimit = getCurrentSpeedLimit(speedLimit)
    if (currentSpeedLimit == null) {
        Log.d(TAG, "Warning: Speed limits unknown, data could not be retrieved.")
    } else if (currentSpeedLimit == 0.0) {
        Log.d(TAG, "No speed limits on this road! Drive as fast as you feel safe ...")
    } else {
        Log.d(TAG, "Current speed limit (m/s): $currentSpeedLimit")
    }
}

private fun getCurrentSpeedLimit(speedLimit: SpeedLimit): Double? {
    // Note that all values can be null if no data is available.

    // The regular speed limit if available. In case of unbounded speed limit, the value is zero.

    Log.d(TAG, "speedLimitInMetersPerSecond: " + speedLimit.speedLimitInMetersPerSecond)

    // A conditional school zone speed limit as indicated on the local road signs.
    Log.d(
        TAG,
        "schoolZoneSpeedLimitInMetersPerSecond: " + 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.
    Log.d(
        TAG,
        "timeDependentSpeedLimitInMetersPerSecond: " + speedLimit.timeDependentSpeedLimitInMetersPerSecond
    )

    // A conditional non-legal speed limit that recommends a lower speed,
    // for example, due to bad road conditions.
    Log.d(
        TAG,
        "advisorySpeedLimitInMetersPerSecond: " + 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.
    Log.d(TAG, "fogSpeedLimitInMetersPerSecond: " + speedLimit.fogSpeedLimitInMetersPerSecond)
    Log.d(TAG, "rainSpeedLimitInMetersPerSecond: " + speedLimit.rainSpeedLimitInMetersPerSecond)
    Log.d(TAG, "snowSpeedLimitInMetersPerSecond: " + speedLimit.snowSpeedLimitInMetersPerSecond)

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

// Notifies when the current speed limit is exceeded.
visualNavigator.setSpeedWarningListener(new SpeedWarningListener() {
    @Override
    public void onSpeedWarningStatusChanged(SpeedWarningStatus speedWarningStatus) {
        if (speedWarningStatus == SpeedWarningStatus.SPEED_LIMIT_EXCEEDED) {
            // 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 SpeedLimitListener.
            Uri ringtoneUri = RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION);
            Ringtone ringtone = RingtoneManager.getRingtone(context, ringtoneUri);
            ringtone.play();
        }

        if (speedWarningStatus == SpeedWarningStatus.SPEED_LIMIT_RESTORED) {
            Log.d(TAG, "Driver is again slower than current speed limit (plus an optional offset).");
        }
    }
});

// Notifies when the current speed limit is exceeded.
visualNavigator.speedWarningListener =
    SpeedWarningListener { speedWarningStatus: SpeedWarningStatus ->
    if (speedWarningStatus == SpeedWarningStatus.SPEED_LIMIT_EXCEEDED) {
        // 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 SpeedLimitListener.
        val ringtoneUri =
            RingtoneManager.getDefaultUri(RingtoneManager.TYPE_NOTIFICATION)
        val ringtone = RingtoneManager.getRingtone(context, ringtoneUri)
        ringtone.play()
    }
    if (speedWarningStatus == SpeedWarningStatus.SPEED_LIMIT_RESTORED) {
        Log.d(
            TAG,
            "Driver is again slower than current speed limit (plus an optional offset)."
        )
    }
}

private void setupSpeedWarnings() {
    SpeedLimitOffset speedLimitOffset = new SpeedLimitOffset();
    speedLimitOffset.lowSpeedOffsetInMetersPerSecond = 2;
    speedLimitOffset.highSpeedOffsetInMetersPerSecond = 4;
    speedLimitOffset.highSpeedBoundaryInMetersPerSecond = 25;

    visualNavigator.setSpeedWarningOptions(new SpeedWarningOptions(speedLimitOffset));
}

private fun setupSpeedWarnings(visualNavigator: VisualNavigator) {
    val speedLimitOffset = SpeedLimitOffset()
    speedLimitOffset.lowSpeedOffsetInMetersPerSecond = 2.0
    speedLimitOffset.highSpeedOffsetInMetersPerSecond = 4.0
    speedLimitOffset.highSpeedBoundaryInMetersPerSecond = 25.0

    visualNavigator.speedWarningOptions = SpeedWarningOptions(speedLimitOffset)
}

RoadSignWarningOptions roadSignWarningOptions = new RoadSignWarningOptions();
// Set a filter to get only road signs relevant for TRUCKS and HEAVY_TRUCKS.
roadSignWarningOptions.vehicleTypesFilter = Arrays.asList(RoadSignVehicleType.TRUCKS, RoadSignVehicleType.HEAVY_TRUCKS);
visualNavigator.setRoadSignWarningOptions(roadSignWarningOptions);

// Notifies on road signs as they appear along the road.
visualNavigator.setRoadSignWarningListener(new RoadSignWarningListener() {
    @Override
    public void onRoadSignWarningUpdated(@NonNull RoadSignWarning roadSignWarning) {
        RoadSignType roadSignType = roadSignWarning.type;
        if (roadSignWarning.distanceType == DistanceType.AHEAD) {
            Log.d(TAG, "A RoadSignWarning of road sign type: " + roadSignType.name()
            + " ahead in (m): " + roadSignWarning.distanceToRoadSignInMeters);
        } else if (roadSignWarning.distanceType == DistanceType.PASSED) {
            Log.d(TAG, "A RoadSignWarning of road sign type: " + roadSignType.name() + " just passed.");
        }

        if (roadSignWarning.signValue != null) {
            // Optional text as it is printed on the local road sign.
            Log.d(TAG, "Road sign text: " + roadSignWarning.signValue.text);
        }

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

val roadSignWarningOptions = RoadSignWarningOptions()
// Set a filter to get only road signs relevant for TRUCKS and HEAVY_TRUCKS.
roadSignWarningOptions.vehicleTypesFilter = listOf(RoadSignVehicleType.TRUCKS, RoadSignVehicleType.HEAVY_TRUCKS)

// Notifies on road signs as they appear along the road.
visualNavigator.roadSignWarningListener =
RoadSignWarningListener { roadSignWarning: RoadSignWarning ->
    val roadSignType: RoadSignType = roadSignWarning.type
    if (roadSignWarning.distanceType == DistanceType.AHEAD) {
        Log.d(TAG, "A RoadSignWarning of road sign type: ${roadSignType.name}" +
                   " ahead in (m): ${roadSignWarning.distanceToRoadSignInMeters}"
        )
    } else if (roadSignWarning.distanceType == DistanceType.PASSED) {
        Log.d(TAG, "A RoadSignWarning of road sign type: ${roadSignType.name} just passed.")
    }

    if (roadSignWarning.signValue != null) {
        // Optional text as it is printed on the local road sign.
        Log.d(TAG, "Road sign text: " + roadSignWarning.signValue!!.text)
    }
    // For more road sign attributes, please check the API Reference.
}

// Notifies on upcoming toll stops. Uses the same notification
// thresholds as other warners and provides events with or without a route to follow.
visualNavigator.setTollStopWarningListener(new TollStopWarningListener() {
    @Override
    public void onTollStopWarning(@NonNull TollStop tollStop) {
        List<TollBoothLane> 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.
        int laneNumber = 0;
        for (TollBoothLane tollBoothLane : lanes) {
            // Log which vehicles types are allowed on this lane that leads to the toll booth.
            logLaneAccess(laneNumber, tollBoothLane.access);
            TollBooth tollBooth = tollBoothLane.booth;
            List<TollCollectionMethod> tollCollectionMethods = tollBooth.tollCollectionMethods;
            List<PaymentMethod> paymentMethods = tollBooth.paymentMethods;
            // The supported collection methods like ticket or automatic / electronic.
            for (TollCollectionMethod collectionMethod : tollCollectionMethods) {
                Log.d(TAG,"This toll stop supports collection via: " + collectionMethod.name());
            }
            // The supported payment methods like cash or credit card.
            for (PaymentMethod paymentMethod : paymentMethods) {
                Log.d(TAG,"This toll stop supports payment via: " + paymentMethod.name());
            }
            laneNumber++;
        }
    }
});

private void logLaneAccess(int laneNumber, LaneAccess laneAccess) {
    Log.d(TAG,"Lane access for lane " + laneNumber);
    Log.d(TAG,"Automobiles are allowed on this lane: " + laneAccess.automobiles);
    Log.d(TAG,"Buses are allowed on this lane: " + laneAccess.buses);
    Log.d(TAG,"Taxis are allowed on this lane: " + laneAccess.taxis);
    Log.d(TAG,"Carpools are allowed on this lane: " + laneAccess.carpools);
    Log.d(TAG,"Pedestrians are allowed on this lane: " + laneAccess.pedestrians);
    Log.d(TAG,"Trucks are allowed on this lane: " + laneAccess.trucks);
    Log.d(TAG,"ThroughTraffic is allowed on this lane: " + laneAccess.throughTraffic);
    Log.d(TAG,"DeliveryVehicles are allowed on this lane: " + laneAccess.deliveryVehicles);
    Log.d(TAG,"EmergencyVehicles are allowed on this lane: " + laneAccess.emergencyVehicles);
    Log.d(TAG,"Motorcycles are allowed on this lane: " + laneAccess.motorcycles);
}

// Notifies on upcoming toll stops. Uses the same notification
// thresholds as other warners and provides events with or without a route to follow.
visualNavigator.tollStopWarningListener = TollStopWarningListener {
tollStop: TollStop ->
    val 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.
    var 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)
        val tollBooth = tollBoothLane.booth
        val tollCollectionMethods = tollBooth.tollCollectionMethods
        val paymentMethods = tollBooth.paymentMethods
        // The supported collection methods like ticket or automatic / electronic.
        for (collectionMethod in tollCollectionMethods) {
            Log.d(
                TAG,
                "This toll stop supports collection via: " + collectionMethod.name
            )
        }
        // The supported payment methods like cash or credit card.
        for (paymentMethod in paymentMethods) {
            Log.d(TAG, "This toll stop supports payment via: " + paymentMethod.name)
        }
        laneNumber++;
    }
}

private fun logLaneAccess(laneNumber: Int, laneAccess: LaneAccess) {
    Log.d(TAG, "Lane access for lane $laneNumber")
    Log.d(TAG, "Automobiles are allowed on this lane: " + laneAccess.automobiles)
    Log.d(TAG, "Buses are allowed on this lane: " + laneAccess.buses)
    Log.d(TAG, "Taxis are allowed on this lane: " + laneAccess.taxis)
    Log.d(TAG, "Carpools are allowed on this lane: " + laneAccess.carpools)
    Log.d(TAG, "Pedestrians are allowed on this lane: " + laneAccess.pedestrians)
    Log.d(TAG, "Trucks are allowed on this lane: " + laneAccess.trucks)
    Log.d(TAG, "ThroughTraffic is allowed on this lane: " + laneAccess.throughTraffic)
    Log.d(TAG, "DeliveryVehicles are allowed on this lane: " + laneAccess.deliveryVehicles)
    Log.d(TAG, "EmergencyVehicles are allowed on this lane: " + laneAccess.emergencyVehicles)
    Log.d(TAG, "Motorcycles are allowed on this lane: " + laneAccess.motorcycles)
}

    SafetyCameraWarningOptions safetyCameraWarningOptions = new SafetyCameraWarningOptions();
    safetyCameraWarningOptions.enableTextNotification = true;
    visualNavigator.setSafetyCameraWarningOptions(safetyCameraWarningOptions);

    val safetyCameraWarningOptions: SafetyCameraWarningOptions = SafetyCameraWarningOptions()
    safetyCameraWarningOptions.enableTextNotification = true
    visualNavigator.safetyCameraWarningOptions = safetyCameraWarningOptions

// Notifies on safety camera warnings as they appear along the road.
visualNavigator.setSafetyCameraWarningListener(new SafetyCameraWarningListener() {
    @Override
    public void onSafetyCameraWarningUpdated(@NonNull SafetyCameraWarning safetyCameraWarning) {
      // Safety camera warning geocoordinates can only be fetched in non-tracking mode.
      Route currentRoute = Objects.requireNonNull(visualNavigator.getRoute());
      GeoCoordinates safetyCameraGeoCoordinates  = getGeocordinatesForRemainingDistance(currentRouteProgress,
              safetyCameraWarning.distanceToCameraInMeters,
              currentRoute
      );

      if (safetyCameraWarning.distanceType == DistanceType.AHEAD) {
          Log.d(TAG, "Safety camera warning " + safetyCameraWarning.type.name() + " ahead in: "
                  + safetyCameraWarning.distanceToCameraInMeters + "with speed limit ="
                  + safetyCameraWarning.speedLimitInMetersPerSecond + "m/s"
                  + " at geo-coordinates: " + NavigationWarnersExample.toString(safetyCameraGeoCoordinates));
      } else if (safetyCameraWarning.distanceType == DistanceType.PASSED) {
          Log.d(TAG, "Safety camera warning " + safetyCameraWarning.type.name() + " passed: "
                  + safetyCameraWarning.distanceToCameraInMeters + "with speed limit ="
                  + safetyCameraWarning.speedLimitInMetersPerSecond + "m/s");
      } else if (safetyCameraWarning.distanceType == DistanceType.REACHED) {
          Log.d(TAG, "Safety camera warning " + safetyCameraWarning.type.name() + " reached at: "
                  + safetyCameraWarning.distanceToCameraInMeters + "with speed limit ="
                  + safetyCameraWarning.speedLimitInMetersPerSecond + "m/s");
      }
    }
});

// Notifies on safety camera warnings as they appear along the road.
visualNavigator.safetyCameraWarningListener =
    SafetyCameraWarningListener { safetyCameraWarning: SafetyCameraWarning ->
      // Safety camera warning geocoordinates can only be fetched in non-tracking mode.
        val currentRoute = Objects.requireNonNull<Route>(visualNavigator.route)
        val safetyCameraGeoCoordinates: GeoCoordinates =
            getGeocoordinatesForRemainingDistance(
                currentRouteProgress,
                safetyCameraWarning.distanceToCameraInMeters,
                currentRoute
            )

        if (safetyCameraWarning.distanceType == DistanceType.AHEAD) {
            Log.d(
                TAG,
                "Safety camera warning ${safetyCameraWarning.type.name} ahead in: " +
                        "${safetyCameraWarning.distanceToCameraInMeters} m " +
                        "with speed limit = ${safetyCameraWarning.speedLimitInMetersPerSecond} m/s " +
                        "at geo-coordinates: ${toString(safetyCameraGeoCoordinates)}"
            )
        } else if (safetyCameraWarning.distanceType == DistanceType.PASSED) {
            Log.d(
                TAG,
                "Safety camera warning ${safetyCameraWarning.type.name} passed: " +
                        "${safetyCameraWarning.distanceToCameraInMeters} with speed limit = " +
                        "${safetyCameraWarning.speedLimitInMetersPerSecond} m/s"
            )
        } else if (safetyCameraWarning.distanceType == DistanceType.REACHED) {
            Log.d(
                TAG,
                "Safety camera warning ${safetyCameraWarning.type.name} reached at: " +
                        "${safetyCameraWarning.distanceToCameraInMeters} with speed limit = " +
                        "${safetyCameraWarning.speedLimitInMetersPerSecond} m/s"
            )
        }
    }

// Returns the GeoCoordinates for an object that is located at the end of the remaining distance.
private GeoCoordinates getGeocordinatesForRemainingDistance(RouteProgress routeProgress,
                                                            double remainingObjectDistnaceInMetres,
                                                            Route currentRoute) {
    double currentCCPOffsetInMetrs = getOffsetOfCCPOnRouteInMeters(routeProgress, currentRoute);

    // Calculate the offset along the route for the given object.
    double remainingDistanceOffsetInMetres = currentCCPOffsetInMetrs + remainingObjectDistnaceInMetres;
    return getGeoCoordinatesFromOffsetInMeters(currentRoute.getGeometry(), remainingDistanceOffsetInMetres);
}

private Double getOffsetOfCCPOnRouteInMeters(RouteProgress routeProgress, Route currentRoute) {
    double totalLength = currentRoute.getLengthInMeters();
    // [SectionProgress] is guaranteed to be non-empty.
    double remainingDistance = routeProgress.sectionProgress.get(routeProgress.sectionProgress.size() - 1).remainingDistanceInMeters;
    return totalLength - remainingDistance;
}

// Convert an offset in meters along a GeoPolyline to GeoCoordinates using the HERE SDK's coordinatesAtOffsetInMeters.
public GeoCoordinates getGeoCoordinatesFromOffsetInMeters(GeoPolyline geoPolyline, double offsetInMeters) {
    return geoPolyline.coordinatesAtOffsetInMeters(offsetInMeters, GeoPolylineDirection.FROM_BEGINNING);
}

// Returns the GeoCoordinates for an object that is located at the end of the remaining distance.
private fun getGeocoordinatesForRemainingDistance(
    routeProgress: RouteProgress,
    remainingObjectDistnaceInMetres: Double,
    currentRoute: Route
): GeoCoordinates {
    val currentCCPOffsetInMetrs = getOffsetOfCCPOnRouteInMeters(routeProgress, currentRoute)

    // Calculate the offset along the route for the given object.
    val remainingDistanceOffsetInMetres =
        currentCCPOffsetInMetrs + remainingObjectDistnaceInMetres
    return getGeoCoordinatesFromOffsetInMeters(
        currentRoute.geometry,
        remainingDistanceOffsetInMetres
    )
}

private fun getOffsetOfCCPOnRouteInMeters(
    routeProgress: RouteProgress,
    currentRoute: Route
): Double {
    val totalLength = currentRoute.lengthInMeters.toDouble()
    // [SectionProgress] is guaranteed to be non-empty.
    val remainingDistance =
        routeProgress.sectionProgress[routeProgress.sectionProgress.size - 1].remainingDistanceInMeters.toDouble()
    return totalLength - remainingDistance
}

// Convert an offset in meters along a GeoPolyline to GeoCoordinates using the HERE SDK's coordinatesAtOffsetInMeters.
fun getGeoCoordinatesFromOffsetInMeters(
    geoPolyline: GeoPolyline,
    offsetInMeters: Double
): GeoCoordinates {
    return geoPolyline.coordinatesAtOffsetInMeters(
        offsetInMeters,
        GeoPolylineDirection.FROM_BEGINNING
    )
}

private void setupManeuverNotificationOptions(VisualNavigator visualNavigator) {
    ManeuverNotificationOptions maneuverNotificationOptions = new ManeuverNotificationOptions();

    maneuverNotificationOptions.enableLaneRecommendation = true;
    visualNavigator.setManeuverNotificationOptions(maneuverNotificationOptions);
}

// Notifies on school zones ahead.
visualNavigator.setSchoolZoneWarningListener(new SchoolZoneWarningListener() {
    @Override
    public void onSchoolZoneWarningUpdated(@NonNull List<SchoolZoneWarning> list) {
        // The list is guaranteed to be non-empty.
        for (SchoolZoneWarning schoolZoneWarning : list) {
            if (schoolZoneWarning.distanceType == DistanceType.AHEAD) {
                Log.d(TAG, "A school zone ahead in: " + schoolZoneWarning.distanceToSchoolZoneInMeters + " meters.");
                // Note that this will be the same speed limit as indicated by SpeedLimitListener, unless
                // already a lower speed limit applies, for example, because of a heavy truck load.
                Log.d(TAG, "Speed limit restriction for this school zone: " + schoolZoneWarning.speedLimitInMetersPerSecond + " m/s.");
                if (schoolZoneWarning.timeRule != null && !schoolZoneWarning.timeRule.appliesTo(new Date())) {
                    // For example, during night sometimes a school zone warning does not apply.
                    // If schoolZoneWarning.timeRule is null, the warning applies at anytime.
                    Log.d(TAG, "Note that this school zone warning currently does not apply.");
                }
            } else if (schoolZoneWarning.distanceType == DistanceType.REACHED) {
                Log.d(TAG, "A school zone has been reached.");
            } else if (schoolZoneWarning.distanceType == DistanceType.PASSED) {
                Log.d(TAG, "A school zone has been passed.");
            }
        }
    }
});

// Notifies on school zones ahead.
visualNavigator.schoolZoneWarningListener =
    SchoolZoneWarningListener { list: List<SchoolZoneWarning> ->
        // The list is guaranteed to be non-empty.
        for (schoolZoneWarning in list) {
            if (schoolZoneWarning.distanceType == DistanceType.AHEAD) {
                Log.d(TAG, "A school zone ahead in: " + schoolZoneWarning.distanceToSchoolZoneInMeters + " meters.")
                // Note that this will be the same speed limit as indicated by SpeedLimitListener, unless
                // already a lower speed limit applies, for example, because of a heavy truck load.
                Log.d(TAG, "Speed limit restriction for this school zone: " + schoolZoneWarning.speedLimitInMetersPerSecond + " m/s.")
                if (schoolZoneWarning.timeRule != null && !schoolZoneWarning.timeRule!!.appliesTo(Date())) {
                    // For example, during night sometimes a school zone warning does not apply.
                    // If schoolZoneWarning.timeRule is null, the warning applies at anytime.
                    Log.d(TAG, "Note that this school zone warning currently does not apply.")
                }
            } else if (schoolZoneWarning.distanceType == DistanceType.REACHED) {
                Log.d(TAG, "A school zone has been reached.")
            } else if (schoolZoneWarning.distanceType == DistanceType.PASSED) {
                Log.d(TAG, "A school zone has been passed.")
            }
        }
    }

SchoolZoneWarningOptions schoolZoneWarningOptions = new SchoolZoneWarningOptions();
schoolZoneWarningOptions.filterOutInactiveTimeDependentWarnings = true;
schoolZoneWarningOptions.warningDistanceInMeters = 150;
visualNavigator.setSchoolZoneWarningOptions(schoolZoneWarningOptions);

val schoolZoneWarningOptions = SchoolZoneWarningOptions()
schoolZoneWarningOptions.filterOutInactiveTimeDependentWarnings = true
schoolZoneWarningOptions.warningDistanceInMeters = 150
visualNavigator.schoolZoneWarningOptions = schoolZoneWarningOptions

visualNavigator.setBorderCrossingWarningListener(new BorderCrossingWarningListener() {
    @Override
    public void onBorderCrossingWarningUpdated(@NonNull BorderCrossingWarning borderCrossingWarning) {
        // Since the border crossing warning is given relative to a single location,
        // the DistanceType.REACHED will never be given for this warning.
        if (borderCrossingWarning.distanceType == DistanceType.AHEAD) {
            Log.d(TAG, "BorderCrossing: A border is ahead in: " + borderCrossingWarning.distanceToBorderCrossingInMeters + " meters.");
            Log.d(TAG, "BorderCrossing: Type (such as country or state): " + borderCrossingWarning.type.name());
            Log.d(TAG, "BorderCrossing: Country code: " + borderCrossingWarning.countryCode.name());

            // 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 null 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 (borderCrossingWarning.stateCode != null) {
                Log.d(TAG, "BorderCrossing: State code: " + borderCrossingWarning.stateCode);
            }

            // The general speed limits that apply in the country / state after border crossing.
            GeneralVehicleSpeedLimits generalVehicleSpeedLimits = borderCrossingWarning.speedLimits;
            Log.d(TAG, "BorderCrossing: Speed limit in cities (m/s): " + generalVehicleSpeedLimits.maxSpeedUrbanInMetersPerSecond);
            Log.d(TAG, "BorderCrossing: Speed limit outside cities (m/s): " + generalVehicleSpeedLimits.maxSpeedRuralInMetersPerSecond);
            Log.d(TAG, "BorderCrossing: Speed limit on highways (m/s): " + generalVehicleSpeedLimits.maxSpeedHighwaysInMetersPerSecond);
        } else if (borderCrossingWarning.distanceType == DistanceType.PASSED) {
            Log.d(TAG, "BorderCrossing: A border has been passed.");
        }
    }
});

// Notifies whenever a border is crossed of a country and optionally, by default, also when a state
// border of a country is crossed.
visualNavigator.borderCrossingWarningListener =
    BorderCrossingWarningListener { borderCrossingWarning: BorderCrossingWarning ->
        // Since the border crossing warning is given relative to a single location,
        // the DistanceType.REACHED will never be given for this warning.
        if (borderCrossingWarning.distanceType == DistanceType.AHEAD) {
            Log.d(
                TAG,
                "BorderCrossing: A border is ahead in: " + borderCrossingWarning.distanceToBorderCrossingInMeters + " meters."
            )
            Log.d(TAG, "BorderCrossing: Type (such as country or state): " + borderCrossingWarning.type.name)
            Log.d(TAG, "BorderCrossing: Country code: " + borderCrossingWarning.countryCode.name)

            // 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 null 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 (borderCrossingWarning.stateCode != null) {
                Log.d(TAG, "BorderCrossing: State code: " + borderCrossingWarning.stateCode)
            }

            // The general speed limits that apply in the country / state after border crossing.
            val generalVehicleSpeedLimits = borderCrossingWarning.speedLimits
            Log.d(
                TAG,
                "BorderCrossing: Speed limit in cities (m/s): " + generalVehicleSpeedLimits.maxSpeedUrbanInMetersPerSecond
            )
            Log.d(
                TAG,
                "BorderCrossing: Speed limit outside cities (m/s): " + generalVehicleSpeedLimits.maxSpeedRuralInMetersPerSecond
            )
            Log.d(
                TAG,
                "BorderCrossing: Speed limit on highways (m/s): " + generalVehicleSpeedLimits.maxSpeedHighwaysInMetersPerSecond
            )
        } else if (borderCrossingWarning.distanceType == DistanceType.PASSED) {
            Log.d(TAG, "BorderCrossing: A border has been passed.")
        }
    }

BorderCrossingWarningOptions borderCrossingWarningOptions = new 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.setBorderCrossingWarningOptions(borderCrossingWarningOptions);

val 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

// Notifies on danger zones.
visualNavigator.setDangerZoneWarningListener(new DangerZoneWarningListener() {
    @Override
    public void onDangerZoneWarningsUpdated(@NonNull DangerZoneWarning dangerZoneWarning) {
        if (dangerZoneWarning.distanceType == DistanceType.AHEAD) {
            Log.d(TAG, "A danger zone ahead in: " + dangerZoneWarning.distanceInMeters + " 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.
            Log.d(TAG, "isZoneStart: " + dangerZoneWarning.isZoneStart);
        } else if (dangerZoneWarning.distanceType == DistanceType.REACHED) {
            Log.d(TAG, "A danger zone has been reached. isZoneStart: " + dangerZoneWarning.isZoneStart);
        } else if (dangerZoneWarning.distanceType == DistanceType.PASSED) {
            Log.d(TAG, "A danger zone has been passed.");
        }
    }
});

visualNavigator.dangerZoneWarningListener =
    DangerZoneWarningListener { dangerZoneWarning: DangerZoneWarning ->
        if (dangerZoneWarning.distanceType == DistanceType.AHEAD) {
            Log.d(TAG, "A danger zone ahead in: ${dangerZoneWarning.distanceInMeters} 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.
            Log.d(TAG, "isZoneStart: ${dangerZoneWarning.isZoneStart}")
        } else if (dangerZoneWarning.distanceType == DistanceType.REACHED) {
            Log.d(
                TAG,
                "A danger zone has been reached. isZoneStart: ${dangerZoneWarning.isZoneStart}"
            )
        } else if (dangerZoneWarning.distanceType == DistanceType.PASSED) {
            Log.d(TAG, "A danger zone has been passed.")
        }
    }

// Notifies on low speed zones ahead - as indicated also on the map when MapFeatures.LOW_SPEED_ZONE is set.
visualNavigator.setLowSpeedZoneWarningListener(new LowSpeedZoneWarningListener() {
    @Override
    public void onLowSpeedZoneWarningUpdated(@NonNull LowSpeedZoneWarning lowSpeedZoneWarning) {
        if (lowSpeedZoneWarning.distanceType == DistanceType.AHEAD) {
            Log.d(TAG, "Low speed zone ahead in meters: " + lowSpeedZoneWarning.distanceToLowSpeedZoneInMeters);
            Log.d(TAG, "Speed limit in low speed zone (m/s): " + lowSpeedZoneWarning.speedLimitInMetersPerSecond);
        } else if (lowSpeedZoneWarning.distanceType == DistanceType.REACHED) {
            Log.d(TAG, "A low speed zone has been reached.");
            Log.d(TAG, "Speed limit in low speed zone (m/s): " + lowSpeedZoneWarning.speedLimitInMetersPerSecond);
        } else if (lowSpeedZoneWarning.distanceType == DistanceType.PASSED) {
            Log.d(TAG, "A low speed zone has been passed.");
        }
    }
});

// Notifies on low speed zones ahead - as indicated also on the map when MapFeatures.LOW_SPEED_ZONE is set.
visualNavigator.lowSpeedZoneWarningListener =
    LowSpeedZoneWarningListener { lowSpeedZoneWarning: LowSpeedZoneWarning ->
        if (lowSpeedZoneWarning.distanceType == DistanceType.AHEAD) {
            Log.d(
                TAG,
                "Low speed zone ahead in meters: ${lowSpeedZoneWarning.distanceToLowSpeedZoneInMeters}"
            )
            Log.d(
                TAG,
                "Speed limit in low speed zone (m/s): ${lowSpeedZoneWarning.speedLimitInMetersPerSecond}"
            )
        } else if (lowSpeedZoneWarning.distanceType == DistanceType.REACHED) {
            Log.d(TAG, "A low speed zone has been reached.")
            Log.d(
                TAG,
                "Speed limit in low speed zone (m/s): ${lowSpeedZoneWarning.speedLimitInMetersPerSecond}"
            )
        } else if (lowSpeedZoneWarning.distanceType == DistanceType.PASSED) {
            Log.d(TAG, "A low speed zone has been passed.")
        }
    }

// Notifies on the attributes of the current road including usage and physical characteristics.
visualNavigator.setRoadAttributesListener(new RoadAttributesListener() {
    @Override
    public void onRoadAttributesUpdated(@NonNull 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.

        Log.d(TAG, "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.
            Log.d(TAG, "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.
            Log.d(TAG, "Road attributes: This is a controlled access road.");
        }
        if (roadAttributes.isDirtRoad) {
            // Indicates whether the navigable segment is paved.
            Log.d(TAG, "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.
            Log.d(TAG, "Road attributes: This is a divided road.");
        }
        if (roadAttributes.isNoThrough) {
            // Identifies a no through road.
            Log.d(TAG, "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.
            Log.d(TAG, "Road attributes: This is a private road.");
        }
        if (roadAttributes.isRamp) {
            // Range is a ramp: connects roads that do not intersect at grade.
            Log.d(TAG, "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.
            Log.d(TAG, "Road attributes: isRightDrivingSide = " + roadAttributes.isRightDrivingSide);
        }
        if (roadAttributes.isRoundabout) {
            // Indicates the presence of a roundabout.
            Log.d(TAG, "Road attributes: This is a roundabout.");
        }
        if (roadAttributes.isTollway) {
            // Identifies a road for which a fee must be paid to use the road.
            Log.d(TAG, "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.
            Log.d(TAG, "Road attributes: This is a tunnel.");
        }
    }
});
}

// Notifies on the attributes of the current road including usage and physical characteristics.
visualNavigator.roadAttributesListener =
    RoadAttributesListener { 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.

        Log.d(TAG, "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.
            Log.d(TAG, "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.
            Log.d(TAG, "Road attributes: This is a controlled access road.")
        }
        if (roadAttributes.isDirtRoad) {
            // Indicates whether the navigable segment is paved.
            Log.d(TAG, "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.
            Log.d(TAG, "Road attributes: This is a divided road.")
        }
        if (roadAttributes.isNoThrough) {
            // Identifies a no through road.
            Log.d(TAG, "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.
            Log.d(TAG, "Road attributes: This is a private road.")
        }
        if (roadAttributes.isRamp) {
            // Range is a ramp: connects roads that do not intersect at grade.
            Log.d(TAG, "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.
            Log.d(
                TAG,
                "Road attributes: isRightDrivingSide = " + roadAttributes.isRightDrivingSide
            )
        }
        if (roadAttributes.isRoundabout) {
            // Indicates the presence of a roundabout.
            Log.d(TAG, "Road attributes: This is a roundabout.")
        }
        if (roadAttributes.isTollway) {
            // Identifies a road for which a fee must be paid to use the road.
            Log.d(TAG, "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.
            Log.d(TAG, "Road attributes: This is a tunnel.")
        }
    }

// Notifies about merging traffic to the current road.
visualNavigator.setTrafficMergeWarningListener(new TrafficMergeWarningListener() {
    @Override
    public void onTrafficMergeWarningUpdated(@NonNull TrafficMergeWarning trafficMergeWarning) {
        if (trafficMergeWarning.distanceType == DistanceType.AHEAD) {
            Log.d(TAG, "There is a merging " + trafficMergeWarning.roadType.name() + " ahead in: "
                    + trafficMergeWarning.distanceToTrafficMergeInMeters + "meters, merging from the "
                    + trafficMergeWarning.side.name() + "side, with lanes ="
                    + trafficMergeWarning.laneCount);
        } else if (trafficMergeWarning.distanceType == DistanceType.PASSED) {
            Log.d(TAG, "A merging " + trafficMergeWarning.roadType.name() + " passed: "
                    + trafficMergeWarning.distanceToTrafficMergeInMeters + "meters, merging from the "
                    + trafficMergeWarning.side.name() + "side, with lanes ="
                    + trafficMergeWarning.laneCount);
        } else if (trafficMergeWarning.distanceType == 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.
        }
    }
});

// Notifies about merging traffic to the current road.
visualNavigator.trafficMergeWarningListener =
    TrafficMergeWarningListener { trafficMergeWarning: TrafficMergeWarning ->
        if (trafficMergeWarning.distanceType == DistanceType.AHEAD) {
            Log.d(
                TAG,
                "There is a merging ${trafficMergeWarning.roadType.name} ahead in: " +
                        "${trafficMergeWarning.distanceToTrafficMergeInMeters} meters, merging from the " +
                        "${trafficMergeWarning.side.name} side, with lanes = ${trafficMergeWarning.laneCount}"
            )
        } else if (trafficMergeWarning.distanceType == DistanceType.PASSED) {
            Log.d(
                TAG,
                "A merging ${trafficMergeWarning.roadType.name} passed: " +
                        "${trafficMergeWarning.distanceToTrafficMergeInMeters} meters, merging from " +
                        "${trafficMergeWarning.side.name} side, with lanes = ${trafficMergeWarning.laneCount}"
            )
        } else if (trafficMergeWarning.distanceType == 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.
        }
    }

RealisticViewWarningOptions realisticViewWarningOptions = new RealisticViewWarningOptions();
realisticViewWarningOptions.aspectRatio = AspectRatio.ASPECT_RATIO_3_X_4;
realisticViewWarningOptions.darkTheme = false;
visualNavigator.setRealisticViewWarningOptions(realisticViewWarningOptions);

// 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.
visualNavigator.setRealisticViewWarningListener(new RealisticViewWarningListener() {
    @Override
    public void onRealisticViewWarningUpdated(@NonNull RealisticViewWarning realisticViewWarning) {
        double distance = realisticViewWarning.distanceToRealisticViewInMeters;
        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) {
            Log.d(TAG, "A RealisticView ahead in: "+ distance + " meters.");
        } else if (distanceType == DistanceType.PASSED) {
            Log.d(TAG, "A RealisticView just passed.");
        }

        RealisticViewVectorImage realisticView = realisticViewWarning.realisticViewVectorImage;
        if (realisticView == null) {
            Log.d(TAG, "A RealisticView just passed. No SVG data delivered.");
            return;
        }

        String signpostSvgImageContent = realisticView.signpostSvgImageContent;
        String junctionViewSvgImageContent = realisticView.junctionViewSvgImageContent;
        // 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.
        Log.d("signpostSvgImage", signpostSvgImageContent);
        Log.d("junctionViewSvgImage", junctionViewSvgImageContent);
    }
});

val realisticViewWarningOptions = RealisticViewWarningOptions()
realisticViewWarningOptions.aspectRatio = AspectRatio.ASPECT_RATIO_3_X_4
realisticViewWarningOptions.darkTheme = false
visualNavigator.realisticViewWarningOptions = realisticViewWarningOptions
// 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.
visualNavigator.realisticViewWarningListener =
    RealisticViewWarningListener { realisticViewWarning: RealisticViewWarning ->
        val distance = realisticViewWarning.distanceToRealisticViewInMeters
        val 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) {
            Log.d(
                TAG,
                "A RealisticView ahead in: $distance meters."
            )
        } else if (distanceType == DistanceType.PASSED) {
            Log.d(TAG, "A RealisticView just passed.")
        }

        val realisticView = realisticViewWarning.realisticViewVectorImage
        if (realisticView == null) {
            Log.d(TAG, "A RealisticView just passed. No SVG data delivered.")
            return@RealisticViewWarningListener
        }

        val signpostSvgImageContent = realisticView.signpostSvgImageContent
        val junctionViewSvgImageContent = realisticView.junctionViewSvgImageContent
        // 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.
        Log.d("signpostSvgImage", signpostSvgImageContent)
        Log.d("junctionViewSvgImage", junctionViewSvgImageContent)
    }

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.aar', '*.jar'], exclude : ['*mock*.jar'])
    implementation 'androidx.appcompat:appcompat:1.3.1'
    implementation 'androidx.constraintlayout:constraintlayout:2.1.1'

    // Needed for realistic views rendering that are provided as SVG strings.
    implementation 'com.caverock:androidsvg-aar:1.4'
}

import android.content.res.AssetManager;
import android.graphics.Typeface;
import android.util.Log;

import com.caverock.androidsvg.SVGExternalFileResolver;

// Needed by AndroidSVG plugin to render the provided fonts.
// Note: It has to be registered for use with the plugin.
public class FontResolver extends SVGExternalFileResolver {

    final private AssetManager assetManager;

    public FontResolver(AssetManager assetManager) {
        super();
        this.assetManager = assetManager;
    }

    @Override
    public Typeface resolveFont(String fontFamily, int fontWeight, String fontStyle) {
        try {
            return Typeface.createFromAsset(assetManager, getFontPath(fontFamily));
        } catch (RuntimeException exception) {
            Log.e("FontResolver", exception.getMessage());
        }

        return null;
    }

    private String getFontPath(String fontFamily) {
        switch (fontFamily) {
            case "FiraGO-Map":
                return "FiraGO_Map/FiraGO-Map.ttf";
            case "SignText-Bold":
                return "SignText/SignText-Bold.ttf";
            case "SignTextNarrow-Bold":
                return "SignTextNarrow/SignTextNarrow-Bold.ttf";
            case "SourceHanSansSC-Normal":
                return "SourceHanSansSC/TTF/SourceHanSansSC-Normal.ttf";

            default:
                Log.e("FontResolver", "Font not found: " + fontFamily);
                return "";
        }
    }
}

private void showRealisticViews(String signpostSvgImageContent, String junctionViewSvgImageContent) {
    ImageView signpostSvgImage = createImageView(signpostSvgImageContent);
    ImageView junctionViewSvgImage = createImageView(junctionViewSvgImageContent);

    if (signpostSvgImage == null || junctionViewSvgImage == null) {
        throw new RuntimeException("Unexpectedly, the SVG string could not be parsed.");
    }

    // Draw the signpost image on top of the junction view image.
    FrameLayout frameLayout = new FrameLayout(MainActivity.this);
    frameLayout.addView(junctionViewSvgImage);
    frameLayout.addView(signpostSvgImage);

    // 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.

    // ... now show the view.
}

private boolean registerFontResolver = true;

// Create a rendered bitmap from a raw SVG string.
// Requires com.caverock.androidsvg.SVG plugin.
@Nullable
private ImageView createImageView(String svgString) {
    // Register our font resolver with AndroidSVG.
    if (registerFontResolver) {
        registerFontResolver = false;
        SVG.registerExternalFileResolver(new FontResolver(getAssets()));
    }

    SVG svg;
    try {
        svg = SVG.getFromString(svgString);
    } catch (SVGParseException e) {
        e.printStackTrace();
        return null;
    }
    PictureDrawable pictureDrawable = new PictureDrawable(svg.renderToPicture());
    ImageView imageView = new ImageView(MainActivity.this);
    imageView.setImageDrawable(pictureDrawable);
    return imageView;
}

visualNavigator.setEnvironmentalZoneWarningListener(new EnvironmentalZoneWarningListener() {
    @Override
    public void onEnvironmentalZoneWarningsUpdated(@NonNull List<EnvironmentalZoneWarning> list) {
        // The list is guaranteed to be non-empty.
        for (EnvironmentalZoneWarning environmentalZoneWarning : list) {
            DistanceType distanceType = environmentalZoneWarning.distanceType;
            if (distanceType == DistanceType.AHEAD) {
                Log.d(TAG, "A EnvironmentalZone ahead in: "+ environmentalZoneWarning.distanceInMeters + " meters.");
            } else if (distanceType == DistanceType.REACHED) {
                Log.d(TAG, "A EnvironmentalZone has been reached.");
            } else if (distanceType == DistanceType.PASSED) {
                Log.d(TAG, "A EnvironmentalZone just passed.");
            }

            // The official name of the environmental zone (example: "Zone basse émission Bruxelles").
            String name = environmentalZoneWarning.name;
            // The description of the environmental zone for the default language.
            String description = environmentalZoneWarning.description.getDefaultValue();
            // The environmental zone ID - uniquely identifies the zone in the HERE map data.
            String zoneID = environmentalZoneWarning.zoneId;
            // The website of the environmental zone, if available - null otherwise.
            String websiteUrl = environmentalZoneWarning.websiteUrl;
            Log.d(TAG, "environmentalZoneWarning: description: " + description);
            Log.d(TAG, "environmentalZoneWarning: name: " + name);
            Log.d(TAG, "environmentalZoneWarning: zoneID: " + zoneID);
            Log.d(TAG, "environmentalZoneWarning: websiteUrl: " + websiteUrl);
        }
    }
});