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

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

visualNavigator.setCameraBehavior(null);

visualNavigator.cameraBehavior = null

// Alternatively, use DynamicCameraBehavior to auto-zoom the camera during guidance.
visualNavigator.setCameraBehavior(new FixedCameraBehavior());

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

visualNavigator.setGuidanceFrameRate(60);

visualNavigator.guidanceFrameRate = 60

visualNavigator.setRouteProgressVisible​(false);

visualNavigator.setRouteProgressVisible​(false)

private void customizeVisualNavigatorColors() {
    Color routeAheadColor =  Color.valueOf(android.graphics.Color.BLUE);
    Color routeBehindColor = Color.valueOf(android.graphics.Color.RED);
    Color routeAheadOutlineColor = Color.valueOf(android.graphics.Color.YELLOW);
    Color routeBehindOutlineColor = Color.valueOf(android.graphics.Color.DKGRAY);
    Color maneuverArrowColor = Color.valueOf(android.graphics.Color.GREEN);

    VisualNavigatorColors visualNavigatorColors = VisualNavigatorColors.dayColors();
    RouteProgressColors routeProgressColors = new RouteProgressColors(
            routeAheadColor,
            routeBehindColor,
            routeAheadOutlineColor,
            routeBehindOutlineColor);

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

private fun customizeVisualNavigatorColors() {
    val routeAheadColor: Color = Color.valueOf(android.graphics.Color.BLUE)
    val routeBehindColor: Color = Color.valueOf(android.graphics.Color.RED)
    val routeAheadOutlineColor: Color = Color.valueOf(android.graphics.Color.YELLOW)
    val routeBehindOutlineColor: Color = Color.valueOf(android.graphics.Color.DKGRAY)
    val maneuverArrowColor: Color = Color.valueOf(android.graphics.Color.GREEN)

    val visualNavigatorColors = VisualNavigatorColors.dayColors()
    val routeProgressColors = RouteProgressColors(
        routeAheadColor,
        routeBehindColor,
        routeAheadOutlineColor,
        routeBehindOutlineColor
    )

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

// Notifies when the destination of the route is reached.
visualNavigator.setDestinationReachedListener(new DestinationReachedListener() {
    @Override
    public void onDestinationReached() {
        String message = "Destination reached.";
        messageView.setText(message);
        // Guidance has stopped. Now consider to, for example,
        // switch to tracking mode or stop rendering or locating or do anything else that may
        // be useful to support your app flow.
        // If the DynamicRoutingEngine was started before, consider to stop it now.
    }
});

// Notifies when a waypoint on the route is reached or missed
visualNavigator.setMilestoneStatusListener(new MilestoneStatusListener() {
    @Override
    public void onMilestoneStatusUpdated(@NonNull Milestone milestone, @NonNull MilestoneStatus milestoneStatus) {
      if (milestone.waypointIndex != null && milestoneStatus == MilestoneStatus.REACHED) {
          Log.d(TAG, "A user-defined waypoint was reached, index of waypoint: " + milestone.waypointIndex);
          Log.d(TAG,"Original coordinates: " + milestone.originalCoordinates);
      }
      else if (milestone.waypointIndex != null && milestoneStatus == MilestoneStatus.MISSED) {
          Log.d(TAG, "A user-defined waypoint was missed, index of waypoint: " + milestone.waypointIndex);
          Log.d(TAG,"Original coordinates: " + milestone.originalCoordinates);
      }
      else if (milestone.waypointIndex == null && milestoneStatus == MilestoneStatus.REACHED) {
          // For example, when transport mode changes due to a ferry a system-defined waypoint may have been added.
          Log.d(TAG, "A system-defined waypoint was reached, index of waypoint: " + milestone.mapMatchedCoordinates);
      }
     else if (milestone.waypointIndex == null && milestoneStatus == MilestoneStatus.MISSED) {
          // For example, when transport mode changes due to a ferry a system-defined waypoint may have been added.
          Log.d(TAG, "A system-defined waypoint was missed, index of waypoint: " + milestone.mapMatchedCoordinates);
      }
}
});

// Notifies when the destination of the route is reached.
visualNavigator.destinationReachedListener = DestinationReachedListener {
    val message = "Destination reached."
    messageView.updateText(message)
    // Guidance has stopped. Now consider to, for example,
    // switch to tracking mode or stop rendering or locating or do anything else that may
    // be useful to support your app flow.
    // If the DynamicRoutingEngine was started before, consider to stop it now.
}
// Notifies when a waypoint on the route is reached or missed.
visualNavigator.milestoneStatusListener =
    MilestoneStatusListener { milestone: Milestone, milestoneStatus: MilestoneStatus ->
    if (milestone.waypointIndex != null && milestoneStatus == MilestoneStatus.REACHED) {
        Log.d(TAG, "A user-defined waypoint was reached, index of waypoint: " + milestone.waypointIndex)
        Log.d(TAG, "Original coordinates: " + milestone.originalCoordinates)
    } else if (milestone.waypointIndex != null && milestoneStatus == MilestoneStatus.MISSED) {
        Log.d(TAG, "A user-defined waypoint was missed, index of waypoint: " + milestone.waypointIndex)
        Log.d(TAG, "Original coordinates: " + milestone.originalCoordinates)
    } else if (milestone.waypointIndex == null && milestoneStatus == MilestoneStatus.REACHED) {
        // For example, when transport mode changes due to a ferry a system-defined waypoint may have been added.
        Log.d(TAG, "A system-defined waypoint was reached at: " + milestone.mapMatchedCoordinates)
    } else if (milestone.waypointIndex == null && milestoneStatus == MilestoneStatus.MISSED) {
        // For example, when transport mode changes due to a ferry a system-defined waypoint may have been added.
        Log.d(TAG, "A system-defined waypoint was missed at: " + milestone.mapMatchedCoordinates)
    }
}

visualNavigator.setRouteProgressListener(new RouteProgressListener() {
    @Override
    public void onRouteProgressUpdated(@NonNull RouteProgress routeProgress) {
        List<ManeuverProgress> maneuverProgressList = routeProgress.maneuverProgress;
        ManeuverProgress nextManeuverProgress = maneuverProgressList.get(0);
        if (nextManeuverProgress == null) {
            Log.d(TAG, "No next maneuver available.");
            return;
        }

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

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

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

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

        Span maneuverSpan = getSpanForManeuver(visualNavigator.getRoute(), nextManeuver);
        if (maneuverSpan != null) {
            // Asynchronously create the icon and show it.
            createRoadShieldIconForSpan(maneuverSpan);
        }
    }
});

@Nullable
private Span getSpanForManeuver(Route route, Maneuver maneuver) {
    Section sectionOfManeuver = route.getSections().get(maneuver.getSectionIndex());
    List<Span> spansInSection = sectionOfManeuver.getSpans();

    // The last maneuver is located on the last span.
    // Note: Its offset points to the last GeoCoordinates of the route's polyline:
    // maneuver.getOffset() = sectionOfManeuver.getGeometry().vertices.size() - 1.
    if (maneuver.getAction() == ManeuverAction.ARRIVE) {
        return spansInSection.get(spansInSection.size() - 1);
    }

    int indexOfManeuverInSection = maneuver.getOffset();
    for (Span span : spansInSection) {
        // A maneuver always lies on the first point of a span. Except for the
        // the destination that is located somewhere on the last span (see above).
        int firstIndexOfSpanInSection = span.getSectionPolylineOffset();
        if (firstIndexOfSpanInSection >= indexOfManeuverInSection) {
            return span;
        }
    }

    // Should never happen.
    return null;
}

private void createRoadShieldIconForSpan(Span span) {
    if (span.getRoadNumbers().items.isEmpty()) {
        // Road shields are only provided for roads that have route numbers such as US-101 or A100.
        // Many streets in a city like "Invalidenstr." have no route number.
        return;
    }

    // For simplicity, we use the first item as fallback. There can be more numbers you can pick per desired language.
    LocalizedRoadNumber localizedRoadNumber = span.getRoadNumbers().items.get(0);
    Locale desiredLocale = Locale.US;
    for (LocalizedRoadNumber roadNumber : span.getRoadNumbers().items) {
        if (localizedRoadNumber.localizedNumber.locale == desiredLocale) {
            localizedRoadNumber = roadNumber;
        }
    }

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

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

    lastRoadShieldText = shieldText;

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

    RoadShieldIconProperties roadShieldIconProperties =
            new RoadShieldIconProperties(routeType, countryCode, stateCode, routeNumberName, shieldText);

    // Set the desired constraints. The icon will fit in while preserving its aspect ratio.
    long widthConstraintInPixels = ManeuverView.ROAD_SHIELD_DIM_CONSTRAINTS_IN_PIXELS;
    long heightConstraintInPixels = ManeuverView.ROAD_SHIELD_DIM_CONSTRAINTS_IN_PIXELS;

    // Create the icon offline. Several icons could be created in parallel, but in reality, the road shield
    // will not change very quickly, so that a previous icon will not be overwritten by a parallel call.
    iconProvider.createRoadShieldIcon(
            roadShieldIconProperties,
            // A road shield icon can be created to match visually the currently selected map scheme.
            MapScheme.NORMAL_DAY,
            IconProviderAssetType.UI,
            widthConstraintInPixels,
            heightConstraintInPixels, new IconProvider.IconCallback() {
                @Override
                public void onCreateIconReply(@Nullable Bitmap bitmap,
                                              @Nullable String description,
                                              @Nullable IconProviderError iconProviderError) {
                    if (iconProviderError != null) {
                        Log.d(TAG, "Cannot create road shield icon: " + iconProviderError.name());
                        return;
                    }

                    // If iconProviderError is null, it is guaranteed that bitmap and description are not null.
                    Bitmap roadShieldIcon = bitmap;

                    // A further description of the generated icon, such as "Federal" or "Autobahn".
                    String shieldDescription = description;
                    Log.d(TAG, "New road shield icon: " + shieldDescription);

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

try {
    mapMatcher = new MapMatcher(sdkNativeEngine, useRenderingLayers);
} catch (InstantiationErrorException e) {
    throw new RuntimeException("MapMatcher initialization failed." + e.getMessage());
}

public void matchLocation(GeoCoordinates geoCoordinates) {
    Location location = new Location(geoCoordinates);
    location.time = new Date();
    MapMatchedLocation mapMatchedLocation = mapMatcher.match(location);

    // A null mapMatchedLocation indicates that the location could not be matched to the road network.
    // This means the location is offroad or the data is not in the cache.
    if (mapMatchedLocation != null) {
        Toast.makeText(context,"Map-matched location is highlighted with red dot on the map. Check logs for more information on matched location.", Toast.LENGTH_LONG).show();

        // Show the map-matched location on the map.
        MapMarker mapMatchedMapMarker = addMapMarker(mapMatchedLocation.coordinates, R.drawable.map_matched_location_dot);

        // Fetch IDs from mapMatchedLocation and convert them into OCMSegmentID required by loadSegmentData method.
        OCMSegmentId mapMatchedSegmentId = new OCMSegmentId();
        mapMatchedSegmentId.localId = Math.toIntExact(mapMatchedLocation.segmentReference.localId);
        mapMatchedSegmentId.tilePartitionId = Math.toIntExact(mapMatchedLocation.segmentReference.tilePartitionId);

        loadSegmentData(mapMatchedSegmentId);
    } else {
        Log.d(TAG,"Location could not be map-matched. Check if the picked location is within 50-meter radius of a road.");
    }
}

// Notifies on the current map-matched location and other useful information while driving or walking.
visualNavigator.setNavigableLocationListener(new NavigableLocationListener() {
    @Override
    public void onNavigableLocationUpdated(@NonNull NavigableLocation currentNavigableLocation) {
        MapMatchedLocation mapMatchedLocation = currentNavigableLocation.mapMatchedLocation;
        if (mapMatchedLocation == null) {
            Log.d(TAG, "The currentNavigableLocation could not be map-matched. Are you off-road?");
            return;
        }

        Log.d(TAG, "MapMatchedLocation - Lat: " + lastMapMatchedLocation.coordinates.latitude + ", Lon: " + lastMapMatchedLocation.coordinates.longitude);

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

        Double speed = currentNavigableLocation.originalLocation.speedInMetersPerSecond;
        Double accuracy = currentNavigableLocation.originalLocation.speedAccuracyInMetersPerSecond;
        Log.d(TAG, "Driving speed (m/s): " + speed + "plus/minus an accuracy of: " +accuracy);
    }
});

// Notifies on the current map-matched location and other useful information while driving or walking.
visualNavigator.navigableLocationListener =
    NavigableLocationListener { currentNavigableLocation: NavigableLocation ->
        lastMapMatchedLocation = currentNavigableLocation.mapMatchedLocation
        if (lastMapMatchedLocation == null) {
            Log.d(TAG, "The currentNavigableLocation could not be map-matched. Are you off-road?")
            return@NavigableLocationListener
        }

        Log.d(
            TAG,
            "MapMatchedLocation - Lat: ${lastMapMatchedLocation!!.coordinates.latitude}, " +
            "Lon: ${lastMapMatchedLocation!!.coordinates.longitude}"
        )

        if (lastMapMatchedLocation!!.isDrivingInTheWrongWay) {
            // For two-way streets, this value is always false. This feature is supported in tracking mode and when deviating from a route.
            Log.d(
                TAG,
                "This is a one way road. User is driving against the allowed traffic direction."
            )
        }

        val speed = currentNavigableLocation.originalLocation.speedInMetersPerSecond
        val accuracy =
            currentNavigableLocation.originalLocation.speedAccuracyInMetersPerSecond
        Log.d(
            TAG,
            "Driving speed (m/s): " + speed + "plus/minus an accuracy of: " + accuracy
        )
    }

// Notifies when the destination of the route is reached.
visualNavigator.setDestinationReachedListener(new DestinationReachedListener() {
    @Override
    public void onDestinationReached() {
        Section lastSection = lastCalculatedRoute.getSections().get(lastCalculatedRoute.getSections().size() - 1);
        if (lastSection.getArrivalPlace().isOffRoad()) {
            Log.d(TAG, "End of navigable route reached.");
            String message1 = "Your destination is off-road.";
            String message2 = "Follow the dashed line with caution.";
            // Note that for this example we inform the user via UI.
            uiCallback.onManeuverEvent(ManeuverAction.ARRIVE, message1, message2);
        } else {
            Log.d(TAG, "Destination reached.");
            String distanceText = "0 m";
            String message = "You have reached your destination.";
            uiCallback.onManeuverEvent(ManeuverAction.ARRIVE, distanceText, message);
        }
    }
});

// Notifies on the progress when heading towards an off-road destination.
// Off-road progress events will be sent only after the user has reached
// the map-matched destination and the original destination is off-road.
// Note that when a location cannot be map-matched to a road, then it is considered
// to be off-road.
visualNavigator.setOffRoadProgressListener(new OffRoadProgressListener() {
    @Override
    public void onOffRoadProgressUpdated(@NonNull OffRoadProgress offRoadProgress) {
        String distanceText = convertDistance(offRoadProgress.remainingDistanceInMeters);
        // Bearing of the destination compared to the user's current position.
        // The bearing angle indicates the direction into which the user should walk in order
        // to reach the off-road destination - when the device is held up in north-up direction.
        // For example, when the top of the screen points to true north, then 180° means that
        // the destination lies in south direction. 315° would mean the user has to head north-west, and so on.
        String message = "Direction of your destination: " + Math.round(offRoadProgress.bearingInDegrees) + "°";
        uiCallback.onManeuverEvent(ManeuverAction.ARRIVE, distanceText, message);
    }
});

// Notifies when the off-road destination of the route has been reached (if any).
visualNavigator.setOffRoadDestinationReachedListener(new OffRoadDestinationReachedListener() {
    @Override
    public void onOffRoadDestinationReached() {
        Log.d(TAG, "Off-road destination reached.");
        String distanceText = "0 m";
        String message = "You have reached your off-road destination.";
        uiCallback.onManeuverEvent(ManeuverAction.ARRIVE, distanceText, message);
    }
});

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

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

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

private void createDynamicRoutingEngine() {
    DynamicRoutingEngineOptions dynamicRoutingOptions = new DynamicRoutingEngineOptions();
    // Both, minTimeDifference and minTimeDifferencePercentage, will be checked:
    // When the poll interval is reached, the smaller difference will win.
    dynamicRoutingOptions.minTimeDifference = Duration.ofSeconds(1);
    dynamicRoutingOptions.minTimeDifferencePercentage = 0.1;
    // Below, we use 10 minutes. A common range is between 5 and 15 minutes.
    dynamicRoutingOptions.pollInterval = Duration.ofMinutes(10);

    try {
        // With the dynamic routing engine you can poll the HERE backend services to search for routes with less traffic.
        // This can happen during guidance - or you can periodically update a route that is shown in a route planner.
        //
        // Make sure to call dynamicRoutingEngine.updateCurrentLocation(...) to trigger execution. If this is not called,
        // no events will be delivered even if the next poll interval has been reached.
        dynamicRoutingEngine = new DynamicRoutingEngine(dynamicRoutingOptions);
    } catch (InstantiationErrorException e) {
        throw new RuntimeException("Initialization of DynamicRoutingEngine failed: " + e.error.name());
    }
}

private fun createDynamicRoutingEngine() {
    val dynamicRoutingOptions = DynamicRoutingEngineOptions()
    // Both, minTimeDifference and minTimeDifferencePercentage, will be checked:
    // When the poll interval is reached, the smaller difference will win.
    dynamicRoutingOptions.minTimeDifference = Duration.ofSeconds(1)
    dynamicRoutingOptions.minTimeDifferencePercentage = 0.1
    // Below, we use 10 minutes. A common range is between 5 and 15 minutes.
    dynamicRoutingOptions.pollInterval = Duration.ofMinutes(10)

    try {
        // With the dynamic routing engine you can poll the HERE backend services to search for routes with less traffic.
        // This can happen during guidance - or you can periodically update a route that is shown in a route planner.
        //
        // Make sure to call dynamicRoutingEngine.updateCurrentLocation(...) to trigger execution. If this is not called,
        // no events will be delivered even if the next poll interval has been reached.
        dynamicRoutingEngine = DynamicRoutingEngine(dynamicRoutingOptions)
    } catch (e: InstantiationErrorException) {
        throw RuntimeException("Initialization of DynamicRoutingEngine failed: " + e.error.name)
    }
}

private void startDynamicSearchForBetterRoutes(Route route) {
    try {
        // Note that the engine will be internally stopped, if it was started before.
        // Therefore, it is not necessary to stop the engine before starting it again.
        dynamicRoutingEngine.start(route, new DynamicRoutingListener() {
            // Notifies on traffic-optimized routes that are considered better than the current route.
            @Override
            public void onBetterRouteFound(@NonNull Route newRoute, int etaDifferenceInSeconds, int distanceDifferenceInMeters) {
                Log.d(TAG, "DynamicRoutingEngine: Calculated a new route.");
                Log.d(TAG, "DynamicRoutingEngine: etaDifferenceInSeconds: " + etaDifferenceInSeconds + ".");
                Log.d(TAG, "DynamicRoutingEngine: distanceDifferenceInMeters: " + distanceDifferenceInMeters + ".");

                String logMessage = "Calculated a new route. etaDifferenceInSeconds: " + etaDifferenceInSeconds +
                        " distanceDifferenceInMeters: " + distanceDifferenceInMeters;
                messageView.setText("DynamicRoutingEngine update: " + logMessage);

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

            @Override
            public void onRoutingError(@NonNull RoutingError routingError) {
                Log.d(TAG,"Error while dynamically searching for a better route: " + routingError.name());
            }
        });
    } catch (DynamicRoutingEngine.StartException e) {
        throw new RuntimeException("Start of DynamicRoutingEngine failed. Is the RouteHandle missing?");
    }
}

private fun startDynamicSearchForBetterRoutes(route: Route) {
    try {
        // Note that the engine will be internally stopped, if it was started before.
        // Therefore, it is not necessary to stop the engine before starting it again.
        dynamicRoutingEngine!!.start(route, object : DynamicRoutingListener {
            // Notifies on traffic-optimized routes that are considered better than the current route.
            override fun onBetterRouteFound(
                newRoute: Route,
                etaDifferenceInSeconds: Int,
                distanceDifferenceInMeters: Int
            ) {
                Log.d(TAG, "DynamicRoutingEngine: Calculated a new route.")
                Log.d(
                    TAG,
                    "DynamicRoutingEngine: etaDifferenceInSeconds: $etaDifferenceInSeconds."
                )
                Log.d(
                    TAG,
                    "DynamicRoutingEngine: distanceDifferenceInMeters: $distanceDifferenceInMeters."
                )

                val logMessage =
                    "Calculated a new route. etaDifferenceInSeconds: " + etaDifferenceInSeconds +
                            " distanceDifferenceInMeters: " + distanceDifferenceInMeters
                messageView.updateText("DynamicRoutingEngine update: $logMessage")

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

            override fun onRoutingError(routingError: RoutingError) {
                Log.d(
                    TAG,
                    "Error while dynamically searching for a better route: " + routingError.name
                )
            }
        })
    } catch (e: StartException) {
        throw RuntimeException("Start of DynamicRoutingEngine failed. Is the RouteHandle missing?")
    }
}

dynamicRoutingEngine.updateCurrentLocation(lastMapMatchedLocation, routeProgress.routeMatchedLocation.sectionIndex);

dynamicRoutingEngine.updateCurrentLocation(lastMapMatchedLocation, routeProgress.routeMatchedLocation.sectionIndex);