Build a navigation app for Android

The Mapbox Navigation SDK for Android gives you all the tools that you need to add turn-by-turn navigation to your apps. Get up and running in a few minutes with our drop-in turn-by-turn navigation, or build a more custom navigation experience with our navigation UI components.

Getting started

The Mapbox Navigation SDK for Android runs on API 14 and above. The demo in this guide was built using API 26. Here are the resources you’ll need before getting started:

• A Mapbox account and access token. Sign up for an account at mapbox.com/signup. You can find your access tokens on your Account page. You will add your access token to your strings.xml file.
• An application including the Mapbox Maps SDK for Android. This guide assumes that you have already begun building an Android application that uses the Mapbox Maps SDK for Android. If you're new to the Mapbox Maps SDK for Android, complete the First steps with the Mapbox Maps SDK for Android guide to set up a map view first.

Install the Navigation SDK

Before developing your app with the Mapbox Navigation SDK, you'll need to add several dependencies. Android Studio uses a toolkit called Gradle to compile resources and source code into an APK. The build.gradle file is used to configure the build and list dependencies. You should add the Navigation UI SDK as a dependency in the repositories section.

Declaring this dependency will automatically pull in both the Mapbox Navigation SDK for Android and the Mapbox Maps SDK for Android. This is why the core Navigation SDK and Maps SDK dependency lines are not listed in the installation code snippet below.

We recommend not including an explicit version of the Maps SDK in your build.gradle file, because Gradle automatically takes care of adding the right dependencies. Instead, the Navigation SDK will include the Maps SDK versions that have been tested to provide the best user and developer experience for navigation apps. Manually adding a different Maps SDK version can lead to unexpected behavior.

In the module-level build.gradle file, add the following dependencies:

// in addition to the rest of your build.gradle contents
// you should include the following repository and dependencies

repositories {
  mavenCentral()
  maven { url 'https://mapbox.bintray.com/mapbox' }
}

dependencies {
    implementation 'com.mapbox.mapboxsdk:mapbox-android-navigation-ui:0.42.6'
}

Initialize a map

Start by creating a new project in Android Studio and initializing a MapView.

Besides the build.gradle file where you installed the Navigation SDK, there are four files you'll use in Android Studio to set up a Mapbox map. The four files you'll be starting with include:

• AndroidManifest.xml (app/manifests/AndroidManifest.xml): This file is where you'll describe components of the application, including Mapbox-related permissions.
• activity_main.xml (app/res/layout/activity_main.xml): This is where you'll set the properties for your MapView including the map center, the zoom level, and the map style that will be used when the application is initialized.
• strings.xml (app/res/values/strings.xml): You'll update the name of the application and store your access token in this file.
• MainActivity.java (app/java/yourcompany.yourproject/MainActivity.java): In this Java file, you'll specify Mapbox-related interactions, starting by initializing your map.

<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:mapbox="http://schemas.android.com/apk/res-auto"
android:layout_width="match_parent"
android:layout_height="match_parent">
 
<com.mapbox.mapboxsdk.maps.MapView
android:id="@+id/mapView"
android:layout_width="match_parent"
android:layout_height="match_parent"
mapbox:mapbox_cameraTargetLat="38.9098"
mapbox:mapbox_cameraTargetLng="-77.0295"
mapbox:mapbox_cameraZoom="12" />
 
<Button
android:id="@+id/startButton"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:layout_marginStart="16dp"
android:layout_marginLeft="16dp"
android:layout_marginTop="16dp"
android:layout_marginEnd="16dp"
android:background="@color/mapboxGrayLight"
android:enabled="false"
android:text="Start navigation"
android:textColor="@color/mapboxWhite"
mapbox:layout_constraintStart_toStartOf="parent"
mapbox:layout_constraintTop_toTopOf="parent" />
</androidx.constraintlayout.widget.ConstraintLayout>

<resources>
    <string name="app_name">Navigation map</string>
    <string name="access_token" translatable="false">YOUR_MAPBOX_ACCESS_TOKEN</string>
    <string name="user_location_permission_explanation">This app needs location permissions to show its functionality.</string>
    <string name="user_location_permission_not_granted">You didn\'t grant location permissions.</string>
</resources>

import android.graphics.BitmapFactory;
import android.os.Bundle;
import java.util.List;
import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;
import android.widget.Toast;
 
// classes needed to initialize map
import com.mapbox.mapboxsdk.Mapbox;
import com.mapbox.mapboxsdk.maps.MapView;
import com.mapbox.mapboxsdk.maps.MapboxMap;
import com.mapbox.mapboxsdk.maps.Style;
import com.mapbox.mapboxsdk.maps.OnMapReadyCallback;
show hidden lines
public class MainActivity extends AppCompatActivity implements OnMapReadyCallback, MapboxMap.OnMapClickListener, PermissionsListener {
// variables for adding location layer
private MapView mapView;
private MapboxMap mapboxMap;
show hidden lines
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
Mapbox.getInstance(this, getString(R.string.access_token));
setContentView(R.layout.activity_main);
mapView = findViewById(R.id.mapView);
mapView.onCreate(savedInstanceState);
mapView.getMapAsync(this);
}
 
@Override
public void onMapReady(@NonNull final MapboxMap mapboxMap) {
this.mapboxMap = mapboxMap;
mapboxMap.setStyle(getString(R.string.navigation_guidance_day), new Style.OnStyleLoaded() {
show hidden lines
});
}
show hidden lines
@Override
protected void onStart() {
super.onStart();
mapView.onStart();
}
 
@Override
protected void onResume() {
super.onResume();
mapView.onResume();
}
 
@Override
protected void onPause() {
super.onPause();
mapView.onPause();
}
 
@Override
protected void onStop() {
super.onStop();
mapView.onStop();
}
 
@Override
protected void onSaveInstanceState(Bundle outState) {
super.onSaveInstanceState(outState);
mapView.onSaveInstanceState(outState);
}
 
@Override
protected void onDestroy() {
super.onDestroy();
mapView.onDestroy();
}
 
@Override
public void onLowMemory() {
super.onLowMemory();
mapView.onLowMemory();
}
show hidden lines

You can learn how to set up an Android Studio project with the Mapbox Maps SDK for Android in the First steps with the Mapbox Maps SDK for Android guide.

Display user location

If you haven't configured location permissions already, you can use the Mapbox LocationComponent to display the user's location on the map.

Showing a user's location requires importing several classes related both specifically to Mapbox and generally to location. Import the following classes below the classes you've already imported to your NavigationActivity file.

You'll also be using several variables throughout the process of adding a user's location to the map. Declare the following variables inside the NavigationActivity class below the existing variable, private MapView mapView;.

Now you are ready to enable the location component and display the user's location.

• You will also need to add two implementations to the NavigationActivity class: LocationEngineListener and PermissionsListener.
• Notice the updates to the onStart, onStop, and onDestroy methods.

Next, you'll call the enableLocationComponent() method when the map is finished loading. Add the following code after the code used to initialize the map.

show hidden lines
// classes needed to add the location component
import com.mapbox.android.core.permissions.PermissionsListener;
import com.mapbox.android.core.permissions.PermissionsManager;
import com.mapbox.mapboxsdk.location.LocationComponent;
import com.mapbox.mapboxsdk.location.modes.CameraMode;
show hidden lines
// variables for adding location layer
private PermissionsManager permissionsManager;
private LocationComponent locationComponent;
show hidden lines
@Override
public void onStyleLoaded(@NonNull Style style) {
enableLocationComponent(style);
show hidden lines
}
show hidden lines
@SuppressWarnings( {"MissingPermission"})
private void enableLocationComponent(@NonNull Style loadedMapStyle) {
// Check if permissions are enabled and if not request
if (PermissionsManager.areLocationPermissionsGranted(this)) {
// Activate the MapboxMap LocationComponent to show user location
// Adding in LocationComponentOptions is also an optional parameter
locationComponent = mapboxMap.getLocationComponent();
locationComponent.activateLocationComponent(this, loadedMapStyle);
locationComponent.setLocationComponentEnabled(true);
// Set the component's camera mode
locationComponent.setCameraMode(CameraMode.TRACKING);
} else {
permissionsManager = new PermissionsManager(this);
permissionsManager.requestLocationPermissions(this);
}
}
 
@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
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) {
enableLocationComponent(mapboxMap.getStyle());
} else {
Toast.makeText(this, R.string.user_location_permission_not_granted, Toast.LENGTH_LONG).show();
finish();
}
}
show hidden lines

Run your application and you will see a circular "puck", which is the user's location on the map.

Add a marker on click

In this application, the user will be able to retrieve a route between their current location and any point that they select on the map. Next, you'll create the ability to add a marker to the map when the user taps on the map.

Start by importing the necessary classes for adding a marker to the map.

Then, add a few new variables that you will use to define the origin and destination based on the user's location and the selected point, respectively.

Now you are ready to add the code that will listen for when a user clicks on the map and then add a marker to the map.

show hidden lines
// classes needed to add a marker
import com.mapbox.geojson.Feature;
import com.mapbox.geojson.Point;
import com.mapbox.mapboxsdk.geometry.LatLng;
import com.mapbox.mapboxsdk.style.layers.SymbolLayer;
import com.mapbox.mapboxsdk.style.sources.GeoJsonSource;
import static com.mapbox.mapboxsdk.style.layers.PropertyFactory.iconAllowOverlap;
import static com.mapbox.mapboxsdk.style.layers.PropertyFactory.iconIgnorePlacement;
import static com.mapbox.mapboxsdk.style.layers.PropertyFactory.iconImage;
show hidden lines
addDestinationIconSymbolLayer(style);
 
mapboxMap.addOnMapClickListener(MainActivity.this);
show hidden lines
private void addDestinationIconSymbolLayer(@NonNull Style loadedMapStyle) {
loadedMapStyle.addImage("destination-icon-id",
BitmapFactory.decodeResource(this.getResources(), R.drawable.mapbox_marker_icon_default));
GeoJsonSource geoJsonSource = new GeoJsonSource("destination-source-id");
loadedMapStyle.addSource(geoJsonSource);
SymbolLayer destinationSymbolLayer = new SymbolLayer("destination-symbol-layer-id", "destination-source-id");
destinationSymbolLayer.withProperties(
iconImage("destination-icon-id"),
iconAllowOverlap(true),
iconIgnorePlacement(true)
);
loadedMapStyle.addLayer(destinationSymbolLayer);
}
show hidden lines
@SuppressWarnings( {"MissingPermission"})
@Override
public boolean onMapClick(@NonNull LatLng point) {
 
Point destinationPoint = Point.fromLngLat(point.getLongitude(), point.getLatitude());
Point originPoint = Point.fromLngLat(locationComponent.getLastKnownLocation().getLongitude(),
locationComponent.getLastKnownLocation().getLatitude());
 
GeoJsonSource source = mapboxMap.getStyle().getSourceAs("destination-source-id");
if (source != null) {
source.setGeoJson(Feature.fromGeometry(destinationPoint));
}
show hidden lines
return true;
}
show hidden lines

Run the application again. Click on the map, and you will see a marker added to the map.

Calculate and draw route

Next, you'll calculate and draw a route between the user's location and the newly added marker. First, import a set of classes required to calculate and draw a route on the map using the Mapbox Navigation SDK and the Mapbox Android Services Directions API wrapper.

Next, add a few more variables that you'll use while calculating and drawing the route.

Now you're ready to write a new getRoute method. This method will require a origin and destination to build a NavigationRoute. After passing an origin and destination to the method, you will make a request to the Mapbox Directions API. Once you've received a response, that response will be stored as the currentRoute. Then, you'll add currentRoute to your map. Start by checking if a route already exists on the map. If it does, remove it. Then, add the currentRoute to the map as a NavigationMapRoute.

Now you've written the getRoute method, but it still need to be called when the user adds a marker to the map. Call the getRoute method inside the onMapClick() { ... }); method.

show hidden lines
// classes to calculate a route
import com.mapbox.services.android.navigation.ui.v5.NavigationLauncherOptions;
import com.mapbox.services.android.navigation.ui.v5.route.NavigationMapRoute;
import com.mapbox.services.android.navigation.v5.navigation.NavigationRoute;
import com.mapbox.api.directions.v5.models.DirectionsResponse;
import com.mapbox.api.directions.v5.models.DirectionsRoute;
import retrofit2.Call;
import retrofit2.Callback;
import retrofit2.Response;
import android.util.Log;
show hidden lines
// variables for calculating and drawing a route
private DirectionsRoute currentRoute;
private static final String TAG = "DirectionsActivity";
private NavigationMapRoute navigationMapRoute;
show hidden lines
getRoute(originPoint, destinationPoint);
show hidden lines
private void getRoute(Point origin, Point destination) {
NavigationRoute.builder(this)
.accessToken(Mapbox.getAccessToken())
.origin(origin)
.destination(destination)
.build()
.getRoute(new Callback<DirectionsResponse>() {
@Override
public void onResponse(Call<DirectionsResponse> call, Response<DirectionsResponse> response) {
// You can get the generic HTTP info about the response
Log.d(TAG, "Response code: " + response.code());
if (response.body() == null) {
Log.e(TAG, "No routes found, make sure you set the right user and access token.");
return;
} else if (response.body().routes().size() < 1) {
Log.e(TAG, "No routes found");
return;
}
 
currentRoute = response.body().routes().get(0);
 
// Draw the route on the map
if (navigationMapRoute != null) {
navigationMapRoute.removeRoute();
} else {
navigationMapRoute = new NavigationMapRoute(null, mapView, mapboxMap, R.style.NavigationMapRoute);
}
navigationMapRoute.addRoute(currentRoute);
}
 
@Override
public void onFailure(Call<DirectionsResponse> call, Throwable throwable) {
Log.e(TAG, "Error: " + throwable.getMessage());
}
});
}
show hidden lines

Run the application, click the map, and you will see a marker added to the map and a line displaying a route between the user's location and the clicked point.

Add a button to start navigation

Finally, you'll add a button and specify that when that button is clicked, a navigation interface should be displayed. Start by defining a few styles for the button. In the colors.xml file, add three new colors.

<color name="colorPrimary">#33C377</color>
<color name="colorPrimaryDark">#FF218450</color>
<color name="colorAccent">#FF4081</color>
<color name="mapboxWhite">#ffffff</color>
<color name="mapboxBlue">#4264fb</color>
<color name="mapboxGrayLight">#c6d2e1</color>
<color name="mapboxPink">#ee4e8b</color>
<color name="mapboxYellow">#d9d838</color>
<color name="mapboxRed">#b43b71</color>

Then, create a button in the activity_main.xml file. Use the colors you specified to set the background and textColor. Notice that when the application is first opened, the button will not be enabled (android:enabled="false") and the button will be the mapboxGrayLight color.

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:mapbox="http://schemas.android.com/apk/res-auto"
android:layout_width="match_parent"
android:layout_height="match_parent">
 
<com.mapbox.mapboxsdk.maps.MapView
android:id="@+id/mapView"
android:layout_width="match_parent"
android:layout_height="match_parent"
mapbox:mapbox_cameraTargetLat="38.9098"
mapbox:mapbox_cameraTargetLng="-77.0295"
mapbox:mapbox_cameraZoom="12" />
 
<Button
android:id="@+id/startButton"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:layout_marginStart="16dp"
android:layout_marginLeft="16dp"
android:layout_marginTop="16dp"
android:layout_marginEnd="16dp"
android:background="@color/mapboxGrayLight"
android:enabled="false"
android:text="Start navigation"
android:textColor="@color/mapboxWhite"
mapbox:layout_constraintStart_toStartOf="parent"
mapbox:layout_constraintTop_toTopOf="parent" />
</androidx.constraintlayout.widget.ConstraintLayout>

Back in the NavigationActivity file, import the necessary classes for adding a button and opening a new navigation view.

Add a new variable for the button.

Then, add a button with a click listener. When the button is clicked, start the NavigationLauncher.

Finally, you'll need to specify that the button should change to be enabled after a marker is added to the map (when the destination is defined). You can accomplish this by setting the button to enabled and setting the background to the mapboxBlue color defined in the colors.xml file.

show hidden lines
// classes needed to launch navigation UI
import android.view.View;
import android.widget.Button;
import com.mapbox.services.android.navigation.ui.v5.NavigationLauncher;
show hidden lines
// variables needed to initialize navigation
private Button button;
show hidden lines
button = findViewById(R.id.startButton);
button.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
boolean simulateRoute = true;
NavigationLauncherOptions options = NavigationLauncherOptions.builder()
.directionsRoute(currentRoute)
.shouldSimulateRoute(simulateRoute)
.build();
// Call this method with Context from within an Activity
NavigationLauncher.startNavigation(MainActivity.this, options);
}
});
show hidden lines
button.setEnabled(true);
button.setBackgroundResource(R.color.mapboxBlue);
show hidden lines

Run the application again. You should see a full width button at the top of the screen. Click a point on the map to add a marker and see an overview of the route. Then, click the Start navigation button to pull up the navigation view.

Customize the style

There are many ways to customize the appearance and functionality included in your navigation app. In this guide, you'll customize the colors to fit the Mapbox brand.

Style the navigation view

First, change the style of the navigation view by changing colors to match Mapbox's brand. Define the following colors in the colors.xml file.

<color name="colorPrimary">#33C377</color>
<color name="colorPrimaryDark">#FF218450</color>
<color name="colorAccent">#FF4081</color>
<color name="mapboxWhite">#ffffff</color>
<color name="mapboxBlue">#4264fb</color>
<color name="mapboxGrayLight">#c6d2e1</color>
<color name="mapboxPink">#ee4e8b</color>
<color name="mapboxYellow">#d9d838</color>
<color name="mapboxRed">#b43b71</color>

Then, specify the colors in the styles.xml file. The NavigationMapRoute style allows you change the appearance of the route on the map and the NavigationView style allows you to change the colors of the turn-by-turn instructions and progress bar.

<!-- Base application theme. -->
<style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
<!-- Customize your theme here. -->
<item name="colorPrimary">@color/colorPrimary</item>
<item name="colorPrimaryDark">@color/colorPrimaryDark</item>
<item name="colorAccent">@color/colorAccent</item>
</style>
 
<style name="NavigationMapRoute">
<!-- Colors -->
<item name="routeColor">@color/mapboxBlue</item>
<item name="routeModerateCongestionColor">@color/mapboxYellow</item>
<item name="routeSevereCongestionColor">@color/mapboxPink</item>
<item name="routeShieldColor">@color/mapboxWhite</item>
<!-- Scales -->
<item name="routeScale">1.0</item>
</style>
 
<style name="NavigationView" parent="Theme.AppCompat.NoActionBar">
<item name="navigationViewPrimary">@color/mapboxWhite</item>
<item name="navigationViewSecondary">@color/mapboxBlue</item>
<item name="navigationViewAccent">@color/mapboxPink</item>
</style>

Style the route overview

Next, change the color of the route overview that the SDK draws on the map when you click the map and add a marker. Find the code that is used to set the variable navigationMapRoute and replace it with the code below so the route will inherit the colors of the route in the navigation view.

navigationMapRoute = new NavigationMapRoute(null, mapView, map, R.style.NavigationMapRoute);

Run the application, and you will see these changes applied to your app.

Final product

You built a small navigation app with the Mapbox Navigation SDK for Android.

Here's the code for the final MainActivity.java file:

import android.graphics.BitmapFactory;
import android.os.Bundle;
import java.util.List;
import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;
import android.widget.Toast;
 
// classes needed to initialize map
import com.mapbox.mapboxsdk.Mapbox;
import com.mapbox.mapboxsdk.maps.MapView;
import com.mapbox.mapboxsdk.maps.MapboxMap;
import com.mapbox.mapboxsdk.maps.Style;
import com.mapbox.mapboxsdk.maps.OnMapReadyCallback;
 
// classes needed to add the location component
import com.mapbox.android.core.permissions.PermissionsListener;
import com.mapbox.android.core.permissions.PermissionsManager;
import com.mapbox.mapboxsdk.location.LocationComponent;
import com.mapbox.mapboxsdk.location.modes.CameraMode;
 
// classes needed to add a marker
import com.mapbox.geojson.Feature;
import com.mapbox.geojson.Point;
import com.mapbox.mapboxsdk.geometry.LatLng;
import com.mapbox.mapboxsdk.style.layers.SymbolLayer;
import com.mapbox.mapboxsdk.style.sources.GeoJsonSource;
import static com.mapbox.mapboxsdk.style.layers.PropertyFactory.iconAllowOverlap;
import static com.mapbox.mapboxsdk.style.layers.PropertyFactory.iconIgnorePlacement;
import static com.mapbox.mapboxsdk.style.layers.PropertyFactory.iconImage;
 
// classes to calculate a route
import com.mapbox.services.android.navigation.ui.v5.NavigationLauncherOptions;
import com.mapbox.services.android.navigation.ui.v5.route.NavigationMapRoute;
import com.mapbox.services.android.navigation.v5.navigation.NavigationRoute;
import com.mapbox.api.directions.v5.models.DirectionsResponse;
import com.mapbox.api.directions.v5.models.DirectionsRoute;
import retrofit2.Call;
import retrofit2.Callback;
import retrofit2.Response;
import android.util.Log;
 
// classes needed to launch navigation UI
import android.view.View;
import android.widget.Button;
import com.mapbox.services.android.navigation.ui.v5.NavigationLauncher;
 
 
public class MainActivity extends AppCompatActivity implements OnMapReadyCallback, MapboxMap.OnMapClickListener, PermissionsListener {
// variables for adding location layer
private MapView mapView;
private MapboxMap mapboxMap;
// variables for adding location layer
private PermissionsManager permissionsManager;
private LocationComponent locationComponent;
// variables for calculating and drawing a route
private DirectionsRoute currentRoute;
private static final String TAG = "DirectionsActivity";
private NavigationMapRoute navigationMapRoute;
// variables needed to initialize navigation
private Button button;
 
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
Mapbox.getInstance(this, getString(R.string.access_token));
setContentView(R.layout.activity_main);
mapView = findViewById(R.id.mapView);
mapView.onCreate(savedInstanceState);
mapView.getMapAsync(this);
}
 
@Override
public void onMapReady(@NonNull final MapboxMap mapboxMap) {
this.mapboxMap = mapboxMap;
mapboxMap.setStyle(getString(R.string.navigation_guidance_day), new Style.OnStyleLoaded() {
@Override
public void onStyleLoaded(@NonNull Style style) {
enableLocationComponent(style);
 
addDestinationIconSymbolLayer(style);
 
mapboxMap.addOnMapClickListener(MainActivity.this);
button = findViewById(R.id.startButton);
button.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
boolean simulateRoute = true;
NavigationLauncherOptions options = NavigationLauncherOptions.builder()
.directionsRoute(currentRoute)
.shouldSimulateRoute(simulateRoute)
.build();
// Call this method with Context from within an Activity
NavigationLauncher.startNavigation(MainActivity.this, options);
}
});
}
});
}
 
private void addDestinationIconSymbolLayer(@NonNull Style loadedMapStyle) {
loadedMapStyle.addImage("destination-icon-id",
BitmapFactory.decodeResource(this.getResources(), R.drawable.mapbox_marker_icon_default));
GeoJsonSource geoJsonSource = new GeoJsonSource("destination-source-id");
loadedMapStyle.addSource(geoJsonSource);
SymbolLayer destinationSymbolLayer = new SymbolLayer("destination-symbol-layer-id", "destination-source-id");
destinationSymbolLayer.withProperties(
iconImage("destination-icon-id"),
iconAllowOverlap(true),
iconIgnorePlacement(true)
);
loadedMapStyle.addLayer(destinationSymbolLayer);
}
 
@SuppressWarnings( {"MissingPermission"})
@Override
public boolean onMapClick(@NonNull LatLng point) {
 
Point destinationPoint = Point.fromLngLat(point.getLongitude(), point.getLatitude());
Point originPoint = Point.fromLngLat(locationComponent.getLastKnownLocation().getLongitude(),
locationComponent.getLastKnownLocation().getLatitude());
 
GeoJsonSource source = mapboxMap.getStyle().getSourceAs("destination-source-id");
if (source != null) {
source.setGeoJson(Feature.fromGeometry(destinationPoint));
}
 
getRoute(originPoint, destinationPoint);
button.setEnabled(true);
button.setBackgroundResource(R.color.mapboxBlue);
return true;
}
 
private void getRoute(Point origin, Point destination) {
NavigationRoute.builder(this)
.accessToken(Mapbox.getAccessToken())
.origin(origin)
.destination(destination)
.build()
.getRoute(new Callback<DirectionsResponse>() {
@Override
public void onResponse(Call<DirectionsResponse> call, Response<DirectionsResponse> response) {
// You can get the generic HTTP info about the response
Log.d(TAG, "Response code: " + response.code());
if (response.body() == null) {
Log.e(TAG, "No routes found, make sure you set the right user and access token.");
return;
} else if (response.body().routes().size() < 1) {
Log.e(TAG, "No routes found");
return;
}
 
currentRoute = response.body().routes().get(0);
 
// Draw the route on the map
if (navigationMapRoute != null) {
navigationMapRoute.removeRoute();
} else {
navigationMapRoute = new NavigationMapRoute(null, mapView, mapboxMap, R.style.NavigationMapRoute);
}
navigationMapRoute.addRoute(currentRoute);
}
 
@Override
public void onFailure(Call<DirectionsResponse> call, Throwable throwable) {
Log.e(TAG, "Error: " + throwable.getMessage());
}
});
}
 
@SuppressWarnings( {"MissingPermission"})
private void enableLocationComponent(@NonNull Style loadedMapStyle) {
// Check if permissions are enabled and if not request
if (PermissionsManager.areLocationPermissionsGranted(this)) {
// Activate the MapboxMap LocationComponent to show user location
// Adding in LocationComponentOptions is also an optional parameter
locationComponent = mapboxMap.getLocationComponent();
locationComponent.activateLocationComponent(this, loadedMapStyle);
locationComponent.setLocationComponentEnabled(true);
// Set the component's camera mode
locationComponent.setCameraMode(CameraMode.TRACKING);
} else {
permissionsManager = new PermissionsManager(this);
permissionsManager.requestLocationPermissions(this);
}
}
 
@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
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) {
enableLocationComponent(mapboxMap.getStyle());
} else {
Toast.makeText(this, R.string.user_location_permission_not_granted, Toast.LENGTH_LONG).show();
finish();
}
}
 
@Override
protected void onStart() {
super.onStart();
mapView.onStart();
}
 
@Override
protected void onResume() {
super.onResume();
mapView.onResume();
}
 
@Override
protected void onPause() {
super.onPause();
mapView.onPause();
}
 
@Override
protected void onStop() {
super.onStop();
mapView.onStop();
}
 
@Override
protected void onSaveInstanceState(Bundle outState) {
super.onSaveInstanceState(outState);
mapView.onSaveInstanceState(outState);
}
 
@Override
protected void onDestroy() {
super.onDestroy();
mapView.onDestroy();
}
 
@Override
public void onLowMemory() {
super.onLowMemory();
mapView.onLowMemory();
}
}

Next steps

There are many other ways you can customize the Mapbox Navigation SDK beyond what you've done in this tutorial. For a complete reference of customization options see the Mapbox Navigation SDK for Android documentation.