// You can use this information to visualize all directions of a lane with a set of image overlays.
for (LaneDirection laneDirection: lane.directions) {
    boolean isLaneDirectionOnRoute = isLaneDirectionOnRoute(lane, laneDirection);
    Log.d(TAG, "LaneDirection for this lane: " + laneDirection.name());
    Log.d(TAG, "This LaneDirection is on the route: " + isLaneDirectionOnRoute);
}

// You can use this information to visualize all directions of a lane with a set of image overlays.
for (laneDirection in lane.directions) {
    val isLaneDirectionOnRoute = isLaneDirectionOnRoute(lane, laneDirection)
    Log.d(TAG, "LaneDirection for this lane: " + laneDirection.name)
    Log.d(TAG, "This LaneDirection is on the route: $isLaneDirectionOnRoute")
}

// Notifies which lane(s) lead to the next (next) maneuvers.
visualNavigator.setManeuverViewLaneAssistanceListener(new ManeuverViewLaneAssistanceListener() {
    @Override
    public void onLaneAssistanceUpdated(@NonNull ManeuverViewLaneAssistance maneuverViewLaneAssistance) {
        // This lane list is guaranteed to be non-empty.
        List<Lane> lanes = maneuverViewLaneAssistance.lanesForNextManeuver;
        logLaneRecommendations(lanes);

        List<Lane> nextLanes = maneuverViewLaneAssistance.lanesForNextNextManeuver;
        if (!nextLanes.isEmpty()) {
            Log.d(TAG, "Attention, the next next maneuver is very close.");
            Log.d(TAG, "Please take the following lane(s) after the next maneuver: ");
            logLaneRecommendations(nextLanes);
        }
    }
});

...

private void logLaneRecommendations(List<Lane> 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 (Lane lane : lanes) {
        // This state is only possible if maneuverViewLaneAssistance.lanesForNextNextManeuver is not empty.
        // For example, when two lanes go left, this lanes leads only to the next maneuver,
        // but not to the maneuver after the next maneuver, while the highly recommended lane also leads
        // to this next next maneuver.
        if (lane.recommendationState == LaneRecommendationState.RECOMMENDED) {
            Log.d(TAG,"Lane " + laneNumber + " leads to next maneuver, but not to the next next maneuver.");
        }

        // If laneAssistance.lanesForNextNextManeuver is not empty, this lane leads also to the
        // maneuver after the next maneuver.
        if (lane.recommendationState == LaneRecommendationState.HIGHLY_RECOMMENDED) {
            Log.d(TAG,"Lane " + laneNumber + " leads to next maneuver and eventually to the next next maneuver.");
        }

        if (lane.recommendationState == LaneRecommendationState.NOT_RECOMMENDED) {
            Log.d(TAG,"Do not take lane " + laneNumber + " to follow the route.");
        }

        logLaneDetails(laneNumber, lane);

        laneNumber++;
    }
}

private void logLaneDetails(int laneNumber, Lane lane) {
    // All directions can be true or false at the same time.
    // The possible lane directions are valid independent of a route.
    // If a lane leads to multiple directions and is recommended, then all directions lead to
    // the next maneuver.
    // You can use this information like in a bitmask to visualize the possible directions
    // with a set of image overlays.
    LaneDirectionCategory laneDirectionCategory = lane.directionCategory;
    Log.d(TAG,"Directions for lane " + laneNumber);
    Log.d(TAG,"laneDirectionCategory.straight: " + laneDirectionCategory.straight);
    Log.d(TAG,"laneDirectionCategory.slightlyLeft: " + laneDirectionCategory.slightlyLeft);
    Log.d(TAG,"laneDirectionCategory.quiteLeft: " + laneDirectionCategory.quiteLeft);
    Log.d(TAG,"laneDirectionCategory.hardLeft: " + laneDirectionCategory.hardLeft);
    Log.d(TAG,"laneDirectionCategory.uTurnLeft: " + laneDirectionCategory.uTurnLeft);
    Log.d(TAG,"laneDirectionCategory.slightlyRight: " + laneDirectionCategory.slightlyRight);
    Log.d(TAG,"laneDirectionCategory.quiteRight: " + laneDirectionCategory.quiteRight);
    Log.d(TAG,"laneDirectionCategory.hardRight: " + laneDirectionCategory.hardRight);
    Log.d(TAG,"laneDirectionCategory.uTurnRight: " + laneDirectionCategory.uTurnRight);

    // More information on each lane is available in these bitmasks (boolean):
    // LaneType provides lane properties such as if parking is allowed.
    LaneType laneType = lane.type;
    // LaneAccess provides which vehicle type(s) are allowed to access this lane.
    LaneAccess laneAccess = lane.access;
}

// Notifies which lane(s) lead to the next (next) maneuvers.
visualNavigator.maneuverViewLaneAssistanceListener =
    ManeuverViewLaneAssistanceListener { maneuverViewLaneAssistance: ManeuverViewLaneAssistance ->
        // This lane list is guaranteed to be non-empty.
        val lanes = maneuverViewLaneAssistance.lanesForNextManeuver
        logLaneRecommendations(lanes)

        val nextLanes = maneuverViewLaneAssistance.lanesForNextNextManeuver
        if (nextLanes.isNotEmpty()) {
            Log.d(TAG, "Attention, the next next maneuver is very close.")
            Log.d(TAG, "Please take the following lane(s) after the next maneuver: ")
            logLaneRecommendations(nextLanes)
        }
    }

...

private fun logLaneRecommendations(lanes: List<Lane>) {
    // 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.
    for ((laneNumber, lane) in lanes.withIndex()) {
        // This state is only possible if maneuverViewLaneAssistance.lanesForNextNextManeuver is not empty.
        // For example, when two lanes go left, this lanes leads only to the next maneuver,
        // but not to the maneuver after the next maneuver, while the highly recommended lane also leads
        // to this next next maneuver.
        if (lane.recommendationState == LaneRecommendationState.RECOMMENDED) {
            Log.d(
                TAG,
                "Lane $laneNumber leads to next maneuver, but not to the next next maneuver."
            )
        }

        // If laneAssistance.lanesForNextNextManeuver is not empty, this lane leads also to the
        // maneuver after the next maneuver.
        if (lane.recommendationState == LaneRecommendationState.HIGHLY_RECOMMENDED) {
            Log.d(
                TAG,
                "Lane $laneNumber leads to next maneuver and eventually to the next next maneuver."
            )
        }

        if (lane.recommendationState == LaneRecommendationState.NOT_RECOMMENDED) {
            Log.d(
                TAG,
                "Do not take lane $laneNumber to follow the route."
            )
        }

        logLaneDetails(laneNumber, lane)

    }
}

private fun logLaneDetails(laneNumber: Int, lane: Lane) {
    Log.d(TAG, "Directions for lane $laneNumber")
    // The possible lane directions are valid independent of a route.
    // If a lane leads to multiple directions and is recommended, then all directions lead to
    // the next maneuver.
    // You can use this information to visualize all directions of a lane with a set of image overlays.
    for (laneDirection in lane.directions) {
        val isLaneDirectionOnRoute = isLaneDirectionOnRoute(lane, laneDirection)
        Log.d(TAG, "LaneDirection for this lane: " + laneDirection.name)
        Log.d(TAG, "This LaneDirection is on the route: $isLaneDirectionOnRoute")
    }

    // More information on each lane is available in these bitmasks (boolean):
    // LaneType provides lane properties such as if parking is allowed or is acceleration allowed or is express lane and many more.
    val laneType = lane.type

    // LaneAccess provides which vehicle type(s) are allowed to access this lane.
    val laneAccess = lane.access
    logLaneAccess(laneNumber, laneAccess)

    // LaneMarkings indicate the visual style of dividers between lanes as visible on a road.
    val laneMarkings = lane.laneMarkings
    logLaneMarkings(laneMarkings)
}

// See above code snippet for the RouteProgressListener.
if previousManeuverIndex != nextManeuverIndex {
    // A new maneuver: Remove stale lane assistance info.
}

// See above code snippet for the RouteProgressListener.
if previousManeuverIndex != nextManeuverIndex {
    // A new maneuver: Remove stale lane assistance info.
}

// notifies which lane(s) allow to follow the route.
visualNavigator.setJunctionViewLaneAssistanceListener(new JunctionViewLaneAssistanceListener() {
    @Override
    public void onLaneAssistanceUpdated(@NonNull JunctionViewLaneAssistance junctionViewLaneAssistance) {
        List<Lane> lanes = junctionViewLaneAssistance.lanesForNextJunction;
        if (lanes.isEmpty()) {
            Log.d(TAG, "You have passed the complex junction.");
        } else {
            Log.d(TAG, "Attention, a complex junction is ahead.");
            logLaneRecommendations(lanes);
        }
    }
});

// Notifies which lane(s) allow to follow the route.
visualNavigator.junctionViewLaneAssistanceListener =
    JunctionViewLaneAssistanceListener { junctionViewLaneAssistance: JunctionViewLaneAssistance ->
    val lanes = junctionViewLaneAssistance.lanesForNextJunction
    if (lanes.isEmpty()) {
        Log.d(TAG, "You have passed the complex junction.")
    } else {
        Log.d(TAG, "Attention, a complex junction is ahead.")
        logLaneRecommendations(lanes)
    }
}

// Provides lane information for the road a user is currently driving on.
// It's supported for turn-by-turn navigation and in tracking mode.
// It does not notify on which lane the user is currently driving on.
visualNavigator.setCurrentSituationLaneAssistanceViewListener(new CurrentSituationLaneAssistanceViewListener() {
    @Override
    public void onCurrentSituationLaneAssistanceViewUpdate(@NonNull CurrentSituationLaneAssistanceView currentSituationLaneAssistanceView) {
        // A list of lanes on the current road.
        List<CurrentSituationLaneView>  lanesList = currentSituationLaneAssistanceView.lanes;

        if (lanesList.isEmpty()) {
            Log.d("CurrentSituationLaneAssistanceView: ", "No data on lanes available.")
        } else {
            // The lanes are sorted from left to right:
            // 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.
            // This is valid for right-hand and left-hand driving countries.
            for (int i = 0; i < lanesList.size(); i++) {
                logCurrentSituationLaneViewDetails(i, lanesList.get(i));
            }
        }
    }
});

// Provides lane information for the road a user is currently driving on.
// It's supported for turn-by-turn navigation and in tracking mode.
// It does not notify on which lane the user is currently driving on.
visualNavigator.currentSituationLaneAssistanceViewListener =
    CurrentSituationLaneAssistanceViewListener { currentSituationLaneAssistanceView: CurrentSituationLaneAssistanceView ->
        // A list of lanes on the current road.
        val lanesList = currentSituationLaneAssistanceView.lanes
        if (lanesList.isEmpty()) {
            Log.d("CurrentSituationLaneAssistanceView: ", "No data on lanes available.")
        } else {
            // The lanes are sorted from left to right:
            // 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.
            // This is valid for right-hand and left-hand driving countries.
            for (i in 0..<lanesList.size()) {
                logCurrentSituationLaneViewDetails(i, lanesList.get(i))
            }
        }
    }

LaneMarkings laneMarkings = lane.laneMarkings;
logLaneMarkings(laneMarkings);

...

private void logLaneMarkings(LaneMarkings laneMarkings){
    if (laneMarkings.centerDividerMarker != null) {
        Log.d(TAG,"Center divider marker for lane " + laneMarkings.centerDividerMarker.value);
    } else if (laneMarkings.laneDividerMarker != null) {
        Log.d(TAG, "Lane divider marker for lane " + laneMarkings.laneDividerMarker.value);
    }
}

val laneMarkings = lane.laneMarkings
logLaneMarkings(laneMarkings)

...

private fun logLaneMarkings(laneMarkings: LaneMarkings) {
    if (laneMarkings.centerDividerMarker != null) {
        Log.d(TAG, "Center divider marker for lane " + laneMarkings.centerDividerMarker!!.value)
    } else if (laneMarkings.laneDividerMarker != null) {
        Log.d(TAG, "Lane divider marker for lane " + laneMarkings.laneDividerMarker!!.value)
    }
}