try {
    visualNavigator = new VisualNavigator();
} catch (InstantiationErrorException e) {
    throw new RuntimeException("Initialization of VisualNavigator failed: " + e.error.name());
}

try {
    visualNavigator = VisualNavigator()
} catch (e: InstantiationErrorException) {
    throw RuntimeException("Initialization of VisualNavigator failed: " + e.error.name)
}

private void startGuidance(Route route) {
    try {
        // Without a route set, this starts tracking mode.
        visualNavigator = new VisualNavigator();
    } catch (InstantiationErrorException e) {
        throw new RuntimeException("Initialization of VisualNavigator failed: " + e.error.name());
    }

    // This enables a navigation view including a rendered navigation arrow.
    visualNavigator.startRendering(mapView);

    // Hook in one of the many listeners. Here we set up a listener to get instructions on the maneuvers to take while driving.
    // For more details, please check the "Navigation" example app and the Developer Guide.
    visualNavigator.setEventTextListener((EventText eventText) -> {
        Log.d("ManeuverNotifications", eventText.text);
    });

    // Set a route to follow. This leaves tracking mode.
    visualNavigator.setRoute(route);

    // VisualNavigator acts as LocationListener to receive location updates directly from a location provider.
    // Any progress along the route is a result of getting a new location fed into the VisualNavigator.
    setupLocationSource(visualNavigator, route);
}

private void setupLocationSource(LocationListener locationListener, Route route) {
    try {
        // Provides fake GPS signals based on the route geometry.
        locationSimulator = new LocationSimulator(route, new LocationSimulatorOptions());
    } catch (InstantiationErrorException e) {
        throw new RuntimeException("Initialization of LocationSimulator failed: " + e.error.name());
    }

    locationSimulator.setListener(locationListener);
    locationSimulator.start();
}

private fun startGuidance(route: Route?) {
    try {
        // Without a route set, this starts tracking mode.
        visualNavigator = VisualNavigator()
    } catch (e: InstantiationErrorException) {
        throw RuntimeException("Initialization of VisualNavigator failed: " + e.error.name)
    }

    // This enables a navigation view including a rendered navigation arrow.
    visualNavigator!!.startRendering(mapView!!)

    // Hook in one of the many listeners. Here we set up a listener to get instructions on the maneuvers to take while driving.
    // For more details, please check the "Navigation" example app and the Developer's Guide.
    visualNavigator!!.eventTextListener = EventTextListener { eventText: EventText -> Log.d("Maneuver text", eventText.text) }

    // Set a route to follow. This leaves tracking mode.
    visualNavigator!!.route = route

    // VisualNavigator acts as LocationListener to receive location updates directly from a location provider.
    // Any progress along the route is a result of getting a new location fed into the VisualNavigator.
    setupLocationSource(visualNavigator!!, route)
}

private fun setupLocationSource(locationListener: LocationListener, route: Route?) {
    try {
        // Provides fake GPS signals based on the route geometry.
        locationSimulator = LocationSimulator(route!!, LocationSimulatorOptions())
    } catch (e: InstantiationErrorException) {
        throw RuntimeException("Initialization of LocationSimulator failed: " + e.error.name)
    }

    locationSimulator!!.listener = locationListener
    locationSimulator!!.start()
}

// Now visualNavigator will receive locations from the HEREPositioningProvider.
// Choose a suitable accuracy for the navigation use case.
herePositioningProvider.startLocating(visualNavigator, LocationAccuracy.NAVIGATION);

// Now visualNavigator will receive locations from the HEREPositioningProvider.
// Choose a suitable accuracy for the navigation use case.
herePositioningProvider.startLocating(visualNavigator, LocationAccuracy.NAVIGATION)

visualNavigator.setRoute(route);

visualNavigator.route = route

visualNavigator.setRoute(null);
herePositioningProvider.startLocating(visualNavigator, LocationAccuracy.NAVIGATION)

visualNavigator.route = route
herePositioningProvider.startLocating(visualNavigator, LocationAccuracy.NAVIGATION)

visualNavigator.setCameraBehavior(new SpeedBasedCameraBehavior());

visualNavigator.cameraBehavior = SpeedBasedCameraBehavior()

visualNavigator.setCameraBehavior(null);

visualNavigator.cameraBehavior = null

// Notifies on the progress along the route including maneuver instructions.
visualNavigator.setRouteProgressListener(new RouteProgressListener() {
    @Override
    public void onRouteProgressUpdated(@NonNull RouteProgress routeProgress) {
        List<SectionProgress> sectionProgressList = routeProgress.sectionProgress;
        // sectionProgressList is guaranteed to be non-empty.
        SectionProgress lastSectionProgress = sectionProgressList.get(sectionProgressList.size() - 1);
        Log.d(TAG, "Distance to destination in meters: " + lastSectionProgress.remainingDistanceInMeters);
        Log.d(TAG, "Traffic delay ahead in seconds: " + lastSectionProgress.trafficDelay.getSeconds());

        // Contains the progress for the next maneuver ahead and the next-next maneuvers, if any.
        List<ManeuverProgress> nextManeuverList = routeProgress.maneuverProgress;

        ManeuverProgress nextManeuverProgress = nextManeuverList.get(0);
        if (nextManeuverProgress == null) {
            Log.d(TAG, "No next maneuver available.");
            return;
        }

        int nextManeuverIndex = nextManeuverProgress.maneuverIndex;
        Maneuver nextManeuver = visualNavigator.getManeuver(nextManeuverIndex);
        if (nextManeuver == null) {
            // Should never happen as we retrieved the next maneuver progress above.
            return;
        }

        ManeuverAction action = nextManeuver.getAction();
        String roadName = getRoadName(nextManeuver, visualNavigator.getRoute());
        String logMessage = action.name() + " on " + roadName +
                " in " + nextManeuverProgress.remainingDistanceInMeters + " meters.";

        // Angle is null for some maneuvers like Depart, Arrive and Roundabout.
        Double turnAngle = nextManeuver.getTurnAngleInDegrees();
        if (turnAngle != null) {
            if (turnAngle > 10) {
                Log.d(TAG, "At the next maneuver: Make a right turn of " + turnAngle + " degrees.");
            } else if (turnAngle < -10) {
                Log.d(TAG, "At the next maneuver: Make a left turn of " + turnAngle + " degrees.");
            } else {
                Log.d(TAG, "At the next maneuver: Go straight.");
            }
        }

        // Angle is null when the roundabout maneuver is not an enter, exit or keep maneuver.
        Double roundaboutAngle = nextManeuver.getRoundaboutAngleInDegrees();
        if (roundaboutAngle != null) {
            // Note that the value is negative only for left-driving countries such as UK.
            Log.d(TAG, "At the next maneuver: Follow the roundabout for " +
                    roundaboutAngle + " degrees to reach the exit.");
        }

        if (previousManeuverIndex != nextManeuverIndex) {
            messageView.setText("New maneuver: " + logMessage);
        } else {
            // A maneuver update contains a different distance to reach the next maneuver.
            messageView.setText("Maneuver update: " + logMessage);
        }

        previousManeuverIndex = nextManeuverIndex;
    }
});

// Notifies on the progress along the route including maneuver instructions.
visualNavigator.routeProgressListener =
    RouteProgressListener { routeProgress: RouteProgress ->
        // Contains the progress for the next maneuver ahead and the next-next maneuvers, if any.
        val nextManeuverList = routeProgress.maneuverProgress

        val nextManeuverProgress = nextManeuverList[0]
        if (nextManeuverProgress == null) {
            Log.d(TAG, "No next maneuver available.")
            return@RouteProgressListener
        }

        val nextManeuverIndex = nextManeuverProgress.maneuverIndex
        val nextManeuver = visualNavigator.getManeuver(nextManeuverIndex)
            ?: // Should never happen as we retrieved the next maneuver progress above.
            return@RouteProgressListener

        val action = nextManeuver.action
        val roadName = getRoadName(nextManeuver, visualNavigator.route)
        val logMessage = action.name + " on " + roadName + " in " + nextManeuverProgress.remainingDistanceInMeters + " meters."

        // Angle is null for some maneuvers like Depart, Arrive and Roundabout.
        val turnAngle = nextManeuver.turnAngleInDegrees
        if (turnAngle != null) {
            if (turnAngle > 10) {
                Log.d(TAG, "At the next maneuver: Make a right turn of $turnAngle degrees.")
            } else if (turnAngle < -10) {
                Log.d(TAG, "At the next maneuver: Make a left turn of $turnAngle degrees.")
            } else {
                Log.d(TAG, "At the next maneuver: Go straight.")
            }
        }

        // Angle is null when the roundabout maneuver is not an enter, exit or keep maneuver.
        val roundaboutAngle = nextManeuver.roundaboutAngleInDegrees
        if (roundaboutAngle != null) {
            // Note that the value is negative only for left-driving countries such as UK.
            Log.d(TAG, "At the next maneuver: Follow the roundabout for " + roundaboutAngle + " degrees to reach the exit."
            )
        }

        previousManeuverIndex = nextManeuverIndex
    }

// Contains the progress for the next maneuver ahead and the next-next maneuvers, if any.
List<ManeuverProgress> nextManeuverList = routeProgress.maneuverProgress;

ManeuverProgress nextManeuverProgress = nextManeuverList.get(0);
if (nextManeuverProgress == null) {
    Log.d(TAG, "No next maneuver available.");
    return;
}

int nextManeuverIndex = nextManeuverProgress.maneuverIndex;
Maneuver nextManeuver = visualNavigator.getManeuver(nextManeuverIndex);

// Contains the progress for the next maneuver ahead and the next-next maneuvers, if any.
val nextManeuverList = routeProgress.maneuverProgress

val nextManeuverProgress = nextManeuverList[0]
if (nextManeuverProgress == null) {
    Log.d(TAG, "No next maneuver available.")
    return@RouteProgressListener
}

val nextManeuverIndex = nextManeuverProgress.maneuverIndex
val nextManeuver = visualNavigator.getManeuver(nextManeuverIndex)

// Helper enum to classify road types.
public enum RoadType {
    HIGHWAY,
    RURAL,
    URBAN
}

private String getRoadName(Maneuver maneuver, Route route) {
    RoadTexts currentRoadTexts = maneuver.getRoadTexts();
    RoadTexts nextRoadTexts = maneuver.getNextRoadTexts();

    String currentRoadName = currentRoadTexts.names.getDefaultValue();
    String currentRoadNumber = currentRoadTexts.numbersWithDirection.getDefaultValue();
    String nextRoadName = nextRoadTexts.names.getDefaultValue();
    String nextRoadNumber = nextRoadTexts.numbersWithDirection.getDefaultValue();

    String roadName = nextRoadName == null ? nextRoadNumber : nextRoadName;

    // On highways, we want to show the highway number instead of a possible road name,
    // while for inner city and urban areas road names are preferred over road numbers.
    if (getRoadType(maneuver, route) == RoadType.HIGHWAY) {
        roadName = nextRoadNumber == null ? nextRoadName : nextRoadNumber;
    }

    if (maneuver.getAction() == ManeuverAction.ARRIVE) {
        // We are approaching the destination, so there's no next road.
        roadName = currentRoadName == null ? currentRoadNumber : currentRoadName;
    }

    if (roadName == null) {
        // Happens only in rare cases, when also the fallback is null.
        roadName = "unnamed road";
    }

    return roadName;
}

// Determines the road type for a given maneuver based on street attributes.
// Returns the road type classification (HIGHWAY, URBAN or RURAL).
private RoadType getRoadType(Maneuver maneuver, Route route) {
    Section sectionOfManeuver = route.getSections().get(maneuver.getSectionIndex());
    List<Span> spansInSection = sectionOfManeuver.getSpans();

    // If attributes list is empty then the road type is rural.
    if (spansInSection.isEmpty()) {
        return RoadType.RURAL;
    }

    Span maneuverSpan;

    // Arrive maneuvers are placed after the last span of the route
    // and the span index for them would be greater than the span's list size.
    if (maneuver.getAction() == ManeuverAction.ARRIVE) {
        maneuverSpan = spansInSection.get(spansInSection.size() - 1);
    } else {
        maneuverSpan = spansInSection.get(maneuver.getSpanIndex());
    }

    List<StreetAttributes> streetAttributes = maneuverSpan.getStreetAttributes();

    // If attributes list contains either CONTROLLED_ACCESS_HIGHWAY, or MOTORWAY or RAMP then the road type is highway.
    // Check for highway attributes.
    if (streetAttributes.contains(StreetAttributes.CONTROLLED_ACCESS_HIGHWAY)
            || streetAttributes.contains(StreetAttributes.MOTORWAY)
            || streetAttributes.contains(StreetAttributes.RAMP)) {
        return RoadType.HIGHWAY;
    }

    // If attributes list contains BUILT_UP_AREA then the road type is urban.
    // Check for urban attributes.
    if (streetAttributes.contains(StreetAttributes.BUILT_UP_AREA)) {
        return RoadType.URBAN;
    }

    // If the road type is neither urban nor highway, default to rural for all other cases.
    return RoadType.RURAL;
}

enum class RoadType { HIGHWAY, RURAL, URBAN }

private fun getRoadName(maneuver: Maneuver, route: Route?): String {
    val currentRoadTexts = maneuver.roadTexts
    val nextRoadTexts = maneuver.nextRoadTexts
    
    val currentRoadName = currentRoadTexts.names.getDefaultValue()
    val currentRoadNumber = currentRoadTexts.numbersWithDirection.getDefaultValue()
    val nextRoadName = nextRoadTexts.names.getDefaultValue()
    val nextRoadNumber = nextRoadTexts.numbersWithDirection.getDefaultValue()

    var roadName = nextRoadName ?: nextRoadNumber

    // On highways, we want to show the highway number instead of a possible road name,
    // while for inner city and urban areas road names are preferred over road numbers.
    route?.let {
        if (getRoadType(maneuver, it) == RoadType.HIGHWAY) {
            roadName = nextRoadNumber ?: nextRoadName
        }
    }

    if (maneuver.action == ManeuverAction.ARRIVE) {
        // We are approaching the destination, so there's no next road.
        roadName = currentRoadName ?: currentRoadNumber
    }

    if (roadName == null) {
        // Happens only in rare cases, when also the fallback is null.
        roadName = "unnamed road"
    }

    return roadName
}

// Determines the road type for a given maneuver based on street attributes.
// Returns the road type classification (HIGHWAY, URBAN or RURAL).
private fun getRoadType(maneuver: Maneuver, route: Route): RoadType {
    val sectionOfManeuver: Section = route.sections[maneuver.sectionIndex]
    val spansInSection: List<Span> = sectionOfManeuver.spans

    // If attributes list is empty then the road type is rural.
    if (spansInSection.isEmpty()) {
        return RoadType.RURAL
    }

    // Arrive maneuvers are placed after the last span of the route
    // and the span index for them would be greater than the span's list size.
    val maneuverSpan =
        if (maneuver.action == ManeuverAction.ARRIVE) {
            spansInSection.last()
        } else {
            spansInSection[maneuver.spanIndex]
        }

    val streetAttributes = maneuverSpan.streetAttributes

    // If attributes list contains either CONTROLLED_ACCESS_HIGHWAY, or MOTORWAY or RAMP then the road type is highway.
    // Check for highway attributes.
    if (streetAttributes.contains(StreetAttributes.CONTROLLED_ACCESS_HIGHWAY)
        || streetAttributes.contains(StreetAttributes.MOTORWAY)
        || streetAttributes.contains(StreetAttributes.RAMP)
    ) {
        return RoadType.HIGHWAY
    }

    // If attributes list contains BUILT_UP_AREA then the road type is urban.
    // Check for urban attributes.
    if (streetAttributes.contains(StreetAttributes.BUILT_UP_AREA)) {
        return RoadType.URBAN
    }

    // If the road type is neither urban nor highway, default to rural for all other cases.
    return RoadType.RURAL
}