Turn-by-turn navigation

//mapbox sdk
  implementation('com.mapbox.mapboxsdk:mapbox-android-sdk:6.5.0') {
      exclude group: 'group_name', module: 'module_name'
  }
  implementation 'com.mapbox.mapboxsdk:mapbox-android-plugin-locationlayer:0.8.1'

    <com.mapbox.mapboxsdk.maps.MapView
        android:id="@+id/mapView"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        mapbox:mapbox_cameraTargetLat="27.7084"
        mapbox:mapbox_cameraTargetLng="85.3206"
        mapbox:mapbox_cameraZoom="13"
        />

mapView = findViewById(R.id.mapView);
    Mapbox.getInstance(this, getString(R.string.mapbox_token));
    mapView.onCreate(savedInstanceState);
    mapView.getMapAsync(mapboxMap ->
    {
        //remove mapbox attribute
        mapboxMap.getUiSettings().setAttributionEnabled(false);
        mapboxMap.getUiSettings().setLogoEnabled(false);
        mapboxMap.setStyle("https://api.baato.io/api/v1/styles/retro?key=" + getString(R.string.baato_access_token),
                style -> {
                    this.mapboxMap = mapboxMap;
                });
    });
}

private void initLocationLayer() {
        locationLayer = new LocationLayerPlugin(mapView, mapboxMap, locationEngine);
        locationLayer.setRenderMode(RenderMode.COMPASS);
    }

    private void initLocationEngine() {
        if (PermissionsManager.areLocationPermissionsGranted(this)) {
           getMyLocation();//initiate location engine on permission grant
        } else {
            permissionsManager = new PermissionsManager(this);
            permissionsManager.requestLocationPermissions(this);
        }
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        if (requestCode == Constants.PHONE_STATE_PERMISSION_REQUEST) {
            if (grantResults[0] != PackageManager.PERMISSION_GRANTED) {
                displayPhoneStateRequiredDialog(this);
            } else
                callTurnByTurnNavigationActivity();
        } else
            permissionsManager.onRequestPermissionsResult(requestCode, permissions, grantResults);
    }

    @Override
    public void onExplanationNeeded(List<String> permissionsToExplain) {
        Toast.makeText(this, R.string.user_location_permission_explanation, Toast.LENGTH_LONG).show();
    }

    @Override
    public void onPermissionResult(boolean granted) {
        if (granted)
            Toast.makeText(this, "Please wait ...", Toast.LENGTH_LONG).show();
        getMyLocation();
    }

private void getMyLocation() {
        if (googleApiClient != null) {
            if (googleApiClient.isConnected()) {
                int permissionLocation = 0;
                if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.M) {
                    permissionLocation = checkSelfPermission(
                            Manifest.permission.ACCESS_FINE_LOCATION);
                }
                if (permissionLocation == PackageManager.PERMISSION_GRANTED) {
                    mylocation = LocationServices.FusedLocationApi.getLastLocation(googleApiClient);
                    LocationRequest locationRequest = new LocationRequest();
                    locationRequest.setInterval(3000);
                    locationRequest.setFastestInterval(3000);
                    locationRequest.setPriority(LocationRequest.PRIORITY_LOW_POWER);
                    LocationSettingsRequest.Builder builder = new LocationSettingsRequest.Builder()
                            .addLocationRequest(locationRequest);
                    builder.setAlwaysShow(true);
                    LocationServices.FusedLocationApi
                            .requestLocationUpdates(googleApiClient, locationRequest, this::onLocationChanged);
                    PendingResult result =
                            LocationServices.SettingsApi
                                    .checkLocationSettings(googleApiClient, builder.build());
                    result.setResultCallback(result1 -> {
                        final Status status = result1.getStatus();
                        switch (status.getStatusCode()) {
                            case LocationSettingsStatusCodes.RESOLUTION_REQUIRED:
                                // Location settings are not satisfied.
                                // But could be fixed by showing the user a dialog.
                                try {
                                    // Show the dialog by calling startResolutionForResult(),
                                    status.startResolutionForResult(this,
                                            Constants.GPS_REQUEST);
                                } catch (IntentSender.SendIntentException e) {
                                    // Ignore the error.
                                }
                                break;
                            case LocationSettingsStatusCodes.SUCCESS:
                                // All location settings are satisfied.
                                // You can initialize location requests here.
                                int permissionLocation1 = 0;
                                if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.M) {
                                    permissionLocation1 = checkSelfPermission(
                                            Manifest.permission.ACCESS_FINE_LOCATION);
                                }
                                if (permissionLocation1 == PackageManager.PERMISSION_GRANTED) {

                                    mylocation = LocationServices.FusedLocationApi
                                            .getLastLocation(googleApiClient);
                                    if (mylocation != null) {
                                        originPoint = Point.fromLngLat(mylocation.getLongitude(), mylocation.getLongitude());
                                        addOriginMarker(new LatLng(mylocation.getLatitude(), mylocation.getLongitude()));
                                        getAddressFromLibrary(new LatLng(mylocation.getLatitude(), mylocation.getLongitude()), "start");
                                    }
                                }

                                break;
                            case LocationSettingsStatusCodes.SETTINGS_CHANGE_UNAVAILABLE:
                                // Location settings are not satisfied. However, we have no way to fix the
                                // settings so we won't show the dialog.
                                //finish();
                                break;
                        }
                    });
                }
            } else googleApiClient.connect();
        } else setUpGClient();
    }

private synchronized void setUpGClient() {
    googleApiClient = new GoogleApiClient.Builder(this)
            .enableAutoManage(this, 0, this)
            .addConnectionCallbacks(this)
            .addOnConnectionFailedListener(this)
            .addApi(LocationServices.API)
            .build();
    googleApiClient.connect();
}

private void addOriginMarker(LatLng latLng) {
    if (mapboxMap.getMarkers().isEmpty()) {
        marker = new MarkerOptions().icon(startIcon).position(new LatLng(originPoint.latitude(), originPoint.longitude()));
        mapboxMap.addMarker(marker);
        bottomInfoLayout.setVisibility(VISIBLE);
        moveCameraTo(latLng);
    } else {
        Marker marker = mapboxMap.getMarkers().get(0);
        marker.setPosition(latLng);
        mapboxMap.updateMarker(marker);
    }
}

    private void moveCameraTo(LatLng point) {
        double zoom = mapboxMap.getCameraPosition().zoom;
        if (zoom < 10)
            zoom = 13;
        else if (zoom < 13)
            zoom = 15;
        else if (zoom < 15)
            zoom = zoom + 1;
        else if (zoom < 18)
            zoom = zoom + 1;
        mapboxMap.animateCamera(CameraUpdateFactory.newLatLngZoom(point, zoom), 300);
    }

private void addDestinationMarker(LatLng point) {
    if (mapboxMap.getMarkers().size() == 2) {
        Marker marker = mapboxMap.getMarkers().get(1);
        marker.setPosition(point);
        mapboxMap.updateMarker(marker);

    } else if (mapboxMap.getMarkers().size() == 1) {
        marker = new MarkerOptions().icon(destinationIcon).position(point);
        mapboxMap.addMarker(marker);
    }
}

private void setUpMarkers() {
        IconFactory mIconFactory = IconFactory.getInstance(this);
        Drawable drawables = ResourcesCompat.getDrawable(getResources(), R.drawable.ic_circle_stroke, null);
        Bitmap sBitmap = BitmapUtils.getBitmapFromDrawable(drawables);
        assert sBitmap != null;
        startIcon = mIconFactory.fromBitmap(sBitmap);

        Drawable drawabled = ResourcesCompat.getDrawable(getResources(), R.drawable.mapbox_marker_icon_default, null);
        Bitmap dBitmap = BitmapUtils.getBitmapFromDrawable(drawabled);
        assert dBitmap != null;
        destinationIcon = mIconFactory.fromBitmap(dBitmap);
    }

public void onMapClick(LatLng point) {
        try {
            btnGo.setVisibility(View.GONE);
            addDestinationMarker(point);
            destinationPoint = Point.fromLngLat(point.getLongitude(), point.getLatitude());
            if (originPoint != null && destinationPoint != null) {
                getRoute(originPoint, destinationPoint, navMode);
            }
            //to get address of a tapped point
            getAddressFromLibrary(point, "destination");
        } catch (Exception e) {
        }
    }

private void getAddressFromLibrary(LatLng point, String marker) {
        new BaatoReverse(this)
                .setLatLon(new LatLon(point.getLatitude(), point.getLongitude()))
                .setAccessToken(getString(R.string.baato_access_token))
                .setRadius(2)
                .withListener(new BaatoReverse.BaatoReverseRequestListener() {
                    @Override
                    public void onSuccess(PlaceAPIResponse places) {
                        // If the geocoder returns a result, we take the first in the list and show the address with the place name.
                        if (!places.getData().isEmpty()) {
                            Place place = places.getData().get(0);
                            addSnippetToMarker(marker, place);
                        } else {
                            bottomText.setText("No address found!");
                        }
                    }

                    @Override
                    public void onFailed(Throwable error) {
                        bottomText.setText(error.getMessage());
                    }
                })
                .doRequest();
    }

    private void addSnippetToMarker(String point, Place place) {
        if (!mapboxMap.getMarkers().isEmpty() && point.contains("start")) {
            Marker start = mapboxMap.getMarkers().get(0);
            start.setSnippet(place.getName() + "\n" + place.getAddress());
            mapboxMap.updateMarker(start);
        } else if (mapboxMap.getMarkers().size() > 1 && point.contains("destination")) {
            Marker dest = mapboxMap.getMarkers().get(1);
            dest.setSnippet(place.getName() + "\n" + place.getAddress());
            mapboxMap.updateMarker(dest);
        }
    }

private void getRoute(Point origin, Point destination, String navigationMode) {
        String[] points = new String[2];
        points[0] = origin.latitude() + "," + origin.longitude();
        points[1] = destination.latitude() + "," + destination.longitude();

        new BaatoRouting(this)
                .setPoints(points)
                .setAccessToken(getString(R.string.baato_access_token))
                .setMode("car") //eg bike, car, foot
                .setAlternatives(false) //optional parameter
                .setInstructions(true) //optional parameter
                .withListener(new BaatoRouting.BaatoRoutingRequestListener() {
                    @Override
                    public void onSuccess(DirectionsAPIResponse directionResponse) {
                        // If the routing returns a result, we take the first in the list and show the route.
                        NavResponse navResponse = directionResponse.getData().get(0);
                        initRouteCoordinates(navResponse.getEncoded_polyline());
                        double distanceInKm = navResponse.getDistanceInMeters() / 1000;
                        long time = navResponse.getTimeInMs() / 1000;

                        btnGo.setVisibility(VISIBLE);
                        bottomText.setText("Distance: " + df.format(distanceInKm) + " km" +
                                "  Time: " + TimeCalculation.giveMeTimeFromSecondsFormat(time));
                        bottomInfoLayout.setVisibility(VISIBLE);

                        String parsedNavigationResponse = BaatoRouting.getParsedNavResponse(directionResponse, navigationMode);
                        DirectionsResponse directionsResponse = DirectionsResponse.fromJson(parsedNavigationResponse);
                        currentRoute = directionsResponse.routes().get(0);

                        //show the route from here
                        navMapRoute(currentRoute);

                        btnGo.setOnClickListener(v -> {
                            //Navigation sdk requires PHONE_STATE_PERMISSION for target sdk versions 30 and above
                            checkPhoneStatePermission();
                        });
                    }

                    @Override
                    public void onFailed(Throwable t) {
                        if (t.getMessage() != null && t.getMessage().contains("Failed to connect"))
                            Toast.makeText(ComponentNavigationActivity.this, "Please connect to internet to get the routes!", Toast.LENGTH_SHORT).show();

                    }
                })
                .doRequest();
    }

    private void checkPhoneStatePermission() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
            int res = checkSelfPermission(android.Manifest.permission.READ_PHONE_STATE);
            if (res != PackageManager.PERMISSION_GRANTED) {
                requestPermissions(new String[]{android.Manifest.permission.READ_PHONE_STATE}, Constants.PHONE_STATE_PERMISSION_REQUEST);
            } else callTurnByTurnNavigationActivity();
        }
    }

    private void callTurnByTurnNavigationActivity() {
        Intent intent = new Intent(this, ComponentNavigationHelperActivity.class);
        intent.putExtra("Route", directionsResponse);
        intent.putExtra("origin", originPoint);
        intent.putExtra("lastLocation", mylocation);
        intent.putExtra("destination", destinationPoint);
        startActivity(intent);
    }

    private void navMapRoute(DirectionsRoute myRoute) {
        if (navigationMapRoute != null) {
            navigationMapRoute.removeRoute();
        } else {
            navigationMapRoute = new NavigationMapRoute(null, mapView, mapboxMap, R.style.NavigationMapRoute);
        }
        navigationMapRoute.addRoute(myRoute);
    }

    private void initRouteCoordinates(String encoded_polyline) {
        points = new ArrayList<>();
        List<LatLng> bboxPoints = new ArrayList<>();
        for (List<Double> coordinates :
                decodePolyline(encoded_polyline, false)) {
            points.add(Point.fromLngLat(coordinates.get(1), coordinates.get(0)));
            bboxPoints.add(new LatLng(coordinates.get(0), coordinates.get(1)));
        }

        if (bboxPoints.size() > 1) {
            try {
                LatLngBounds bounds = new LatLngBounds.Builder().includes(bboxPoints).build();
                // left, top, right, bottom
                animateCameraBbox(bounds, CAMERA_ANIMATION_DURATION, padding);
            } catch (InvalidLatLngBoundsException exception) {
                Toast.makeText(this, R.string.error_valid_route_not_found, Toast.LENGTH_SHORT).show();
            }

        }

    }

    private void animateCameraBbox(LatLngBounds bounds, int animationTime, int[] padding) {
        CameraPosition position = mapboxMap.getCameraForLatLngBounds(bounds, padding);
        mapboxMap.animateCamera(CameraUpdateFactory.newCameraPosition(position), animationTime);
    }

    @Override
    public void onLocationChanged(Location location) {
        originPoint = Point.fromLngLat(location.getLongitude(), location.getLatitude());
        mylocation = location;
        addOriginMarker(new LatLng(location.getLatitude(), location.getLongitude()));
    }

    @Override
    protected void onResume() {
        super.onResume();
        mapView.onResume();
    }

    @Override
    protected void onStart() {
        super.onStart();
        mapView.onStart();
        if (locationLayer != null)
            locationLayer.onStart();
    }

    @Override
    protected void onPause() {
        super.onPause();
        mapView.onPause();
    }

    @Override
    protected void onStop() {
        super.onStop();
        mapView.onStop();
        if (locationLayer != null)
            locationLayer.onStop();
    }

    @Override
    protected void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        mapView.onSaveInstanceState(outState);
    }

    @Override
    public void onLowMemory() {
        super.onLowMemory();
        mapView.onLowMemory();
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        mapView.onDestroy();
    }

    @Override
    public void onBackPressed() {
        super.onBackPressed();
    }

    @Override
    public void onConnected(Bundle bundle) {
        getMyLocation();
    }

}

<?xml version="1.0" encoding="utf-8"?>
    <com.mapbox.mapboxsdk.maps.MapView
        android:id="@+id/mapView"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        mapbox:mapbox_cameraTargetLat="27.7084"
        mapbox:mapbox_cameraTargetLng="85.3206"
        mapbox:mapbox_cameraZoom="13"
        />

@Override
  public void onRunning(boolean running) {
  // do something
  }

MapboxNavigationOptions options = MapboxNavigationOptions.builder()
                .build();
        navigation = new MapboxNavigation(this, "pk.xxx", options);

        // you can also add custom milestone
        navigation.addMilestone(new RouteMilestone.Builder()
                .setIdentifier(BEGIN_ROUTE_MILESTONE)
                .setInstruction(new BeginRouteInstruction())
                .setTrigger(
                        Trigger.all(
                                Trigger.lt(TriggerProperty.STEP_INDEX, 3),
                                Trigger.gt(TriggerProperty.STEP_DISTANCE_TOTAL_METERS, 200),
                                Trigger.gte(TriggerProperty.STEP_DISTANCE_TRAVELED_METERS, 75)
                        )
                ).build());

 locationLayerPlugin.setRenderMode(RenderMode.GPS);
 locationLayerPlugin.setLocationLayerEnabled(false);
 navigationMapRoute = new NavigationMapRoute(navigation, mapView, mapboxMap);
 navigationMapRoute.addRoute(route);
 locationEngine = new ReplayRouteLocationEngine();

  // Attach navigation listeners.
            navigation.addNavigationEventListener(this);
            navigation.addProgressChangeListener(this);
            navigation.addMilestoneEventListener(this);
            navigation.addOffRouteListener(this);

  // Attach the replay engine
  ((ReplayRouteLocationEngine) locationEngine).assign(route);
            navigation.setLocationEngine(locationEngine);
            locationLayerPlugin.setLocationLayerEnabled(true);

  // Start navigation
            navigation.startNavigation(route);

  @Override
    public void onProgressChange(Location location, RouteProgress routeProgress) {

        // Cache "snapped" Locations for re-route Directions API requests

            if (location == null) {
                location = lastLocation;
            }
            locationLayerPlugin.forceLocationUpdate(location);
            moveCameraTo(location);
            // Update InstructionView data from RouteProgress
            instructionView.update(routeProgress);
            summaryBottomSheet.update(routeProgress);
    }