Find a route and directions

Learn how to find a route and directions with the route service.

Routing is the process of finding the path from an origin to a destination in a street network. You can use the Routing service to find routes, get driving directions, calculate drive times, and solve complicated, multiple vehicle routing problems. To create a route, you typically define a set of stops (origin and one or more destinations) and use the service to find a route with directions. You can also use a number of additional parameters such as barriers and mode of travel to refine the results.

In this tutorial, you define an origin and destination by clicking on the map. These values are used to get a route and directions from the route service. The directions are also displayed on the map.

Prerequisites

The following are required for this tutorial:

An ArcGIS account to access API keys. If you don't have an account, sign up for free.
A development and deployment environment that meets the system requirements.
An IDE for Android development in Kotlin.

Steps

Open an Android Studio project

To start this tutorial, complete the Display a map tutorial. Or download and unzip the Display a map solution in a new folder.
Modify the old project for use in this new tutorial. Expand More info for instructions.
1. On your file system, delete the .idea folder, if present, at the top level of your project.
2. In the Android tool window, open app > res > values > strings.xml.
  
  In the <string name="app_name"> element, change the text content to Find a route and directions.
  strings.xml
  Use dark colors for code blocks
  1 2 3 4 5
  Change line
  1 2 3 4 5 <resources> <string name="app_name">Find a route and directions</string> </resources>
3. In the Android tool window, open Gradle Scripts > settings.gradle.
  
  Change the value of rootProject.name to Find a route and directions.
  settings.gradle
  Expand
  Use dark colors for code blocks
  20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 20 21 22 23
  Change line
  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 rootProject.name = "Find a route and directions" include ':app'
4. Click File > Sync Project with Gradle files. Android Studio will recognize your changes and create a new .idea folder.

If you downloaded the solution project, set your API key.

An API Key enables access to services, web maps, and web scenes hosted in ArcGIS Online.

Go to your developer dashboard to get your API key. For these tutorials, use your default API key. It is scoped to include all of the services demonstrated in the tutorials.
In Android Studio: in the Android tool window, open app > java > com.example.app > MainActivity.

In the setApiKey() function, find the ApiKey.create() call and paste your API key inside the quotes, replacing YOUR_API_KEY.

MainActivity.kt
Use dark colors for code blocks
    private fun setApiKey() {
        // It is not best practice to store API keys in source code. We have you insert one here
        // to streamline this tutorial.

        ArcGISEnvironment.apiKey = ApiKey.create("YOUR_API_KEY")

    }

Add import statements, class properties, and application context

Modify import statements to reference the packages and classes required for this tutorial. Then add properties to the class that are used in multiple functions within this tutorial.

Replace the import statements with the imports needed for this tutorial.

MainActivity.kt
Use dark colors for code blocks
package com.example.app

import android.os.Bundle
import android.R.layout
import android.util.Log
import android.widget.ArrayAdapter
import android.widget.ListView
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
import androidx.databinding.DataBindingUtil
import androidx.lifecycle.lifecycleScope
import com.arcgismaps.ApiKey
import com.arcgismaps.ArcGISEnvironment
import com.arcgismaps.Color
import com.arcgismaps.geometry.Point
import com.arcgismaps.mapping.ArcGISMap
import com.arcgismaps.mapping.BasemapStyle
import com.arcgismaps.mapping.Viewpoint
import com.arcgismaps.mapping.view.Graphic
import com.arcgismaps.mapping.view.GraphicsOverlay
import com.arcgismaps.mapping.view.MapView
import com.arcgismaps.mapping.symbology.SimpleLineSymbol
import com.arcgismaps.mapping.symbology.SimpleLineSymbolStyle
import com.arcgismaps.mapping.symbology.SimpleMarkerSymbol
import com.arcgismaps.mapping.symbology.SimpleMarkerSymbolStyle
import com.arcgismaps.mapping.view.SingleTapConfirmedEvent
import com.arcgismaps.tasks.networkanalysis.DirectionManeuver
import com.arcgismaps.tasks.networkanalysis.RouteParameters
import com.arcgismaps.tasks.networkanalysis.RouteResult
import com.arcgismaps.tasks.networkanalysis.RouteTask
import com.arcgismaps.tasks.networkanalysis.Stop
import com.example.app.databinding.ActivityMainBinding
import kotlinx.coroutines.launch

Add the following properties to the MainActivity class. These properties will be used extensively in the steps that follow.

MainActivity.kt
Use dark colors for code blocks

class MainActivity : AppCompatActivity() {

    private val activityMainBinding: ActivityMainBinding by lazy {
        DataBindingUtil.setContentView(this, R.layout.activity_main)
    }

    private val mapView: MapView by lazy {
        activityMainBinding.mapView
    }

    private val listView: ListView by lazy {
        activityMainBinding.listView
    }

    private val directionsList: MutableList<String> by lazy {
        mutableListOf("Tap to add two points to the map to find a route between them.")
    }

    private val arrayAdapter by lazy {
        ArrayAdapter(this, layout.simple_list_item_1, directionsList)
    }

    private val routeStops: MutableList<Stop> by lazy {
        mutableListOf()
    }

    private val graphicsOverlay: GraphicsOverlay by lazy {
        GraphicsOverlay()
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        lifecycle.addObserver(mapView)

Assign applicationContext (a property inherited by the MainActivity class) to the ArcGISEnvironment.applicationContext property.

MainActivity.kt
Use dark colors for code blocks
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        lifecycle.addObserver(mapView)

        // some parts of the API require an Android Context to properly interact with Android system
        // features, such as LocationProvider and application resources
        ArcGISEnvironment.applicationContext = applicationContext

        setApiKeyForApp()

        setupMap()

    }

Update the map

A streets basemap layer is typically used in routing applications. Update the basemap to use the ArcGISStreets basemap style, change the position of the map to center on Los Angeles and add a GraphicsOverlay.

In the setupMap() function, change the BasemapStyle from ArcGISTopographic to ArcGISStreets, and change the latitude and longitude coordinates to center on Los Angeles.

MainActivity.kt
Expand
Use dark colors for code blocks
    // set up your map here. You will call this function from onCreate()
    private fun setupMap() {

        val map = ArcGISMap(BasemapStyle.ArcGISStreets)

        // set the map to be displayed in the layout's MapView
        mapView.map = map

        mapView.setViewpoint(Viewpoint(34.0539, -118.2453, 144447.638572))

        mapView.apply {

        }

    }
Expand

Add the graphicsOverlay to the mapView.graphicsOverlays property. A graphics overlay is a container for graphics. Graphics will be added later in this tutorial as a visual means to display the route stops and route result on the map.

For more information, see GraphicsOverlay and GeoView.graphicsOverlays. Note that MapView inherits graphicsOverlays from GeoView.

MainActivity.kt
Expand
Use dark colors for code blocks
        // set the map to be displayed in the layout's MapView
        mapView.map = map

        mapView.setViewpoint(Viewpoint(34.0539, -118.2453, 144447.638572))

        mapView.apply {

            graphicsOverlays.add(graphicsOverlay)

        }
Expand

Add a `ListView` to display driving directions

To display the turn-by-turn directions from the route, use an Android list view to display it on the screen.

In the activity_main.xml file, create an Android ListView that will display a vertical list of directions.

activity_main.xml
Expand
Use dark colors for code blocks
        <ListView
            android:id="@+id/listView"
            android:layout_width="0dp"
            android:layout_height="0dp"
            android:background="@android:drawable/screen_background_dark_transparent"
            app:layout_constraintHeight_percent="0.35"
            app:layout_constraintWidth_percent="0.5"
            app:layout_constraintStart_toStartOf="parent"
            app:layout_constraintTop_toTopOf="parent" />
Expand

In MainActivity.kt, in the onCreate() function, assign arrayAdapter to the listView.adapter property. The ArrayAdapter will create and populate the listView with TextView objects, one text view for each string in the directionsList.

MainActivity.kt
Expand
Use dark colors for code blocks
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        lifecycle.addObserver(mapView)

        // some parts of the API require an Android Context to properly interact with Android system
        // features, such as LocationProvider and application resources
        ArcGISEnvironment.applicationContext = applicationContext

        listView.adapter = arrayAdapter

        setApiKeyForApp()

        setupMap()

    }
Expand

Create an `addStop` function

A RouteTask requires at least an origin and a destination stop to find a route. Create a function that adds Stop objects to the routeStops list.

When a user taps on the map, a stop will be added to a list of route stops. In this tutorial, the first tap will create the origin stop and the second will create the destination stop.

Create an addStop(stop) function.

MainActivity.kt
Expand
Use dark colors for code blocks
    private fun addStop(stop: Stop) {

    }
Expand

Add the given stop to the routeStops list.

MainActivity.kt
Expand
Use dark colors for code blocks
    private fun addStop(stop: Stop) {

        routeStops.add(stop)

    }
Expand

Create a SimpleMarkerSymbol. Then create a graphic, using the stop's Geometry and the marker symbol. Finally, add the graphic to the graphicsOverlay.

MainActivity.kt
Expand
Use dark colors for code blocks
    private fun addStop(stop: Stop) {

        routeStops.add(stop)

        // create a green circle symbol for the stop
        val stopMarker = SimpleMarkerSymbol(SimpleMarkerSymbolStyle.Circle, Color.green, 20f)
        // get the stop's geometry
        val routeStopGeometry = stop.geometry
        // add graphic to graphics overlay
        graphicsOverlay.graphics.add(Graphic(routeStopGeometry, stopMarker))

    }
Expand

Create a `findRoute` function

A task can make asynchronous requests to an online service or offline data and then return the results. In this tutorial, we will solve the route between the origin and destination stops using a RouteTask that accesses a routing service.

A routing service with global coverage is part of ArcGIS location services. You can also publish custom routing services using ArcGIS Enterprise.

Create a findRoute() function.

MainActivity.kt
Expand
Use dark colors for code blocks
    private fun findRoute() {

    }
Expand

Create a RouteTask with a string URL to reference the routing service.

MainActivity.kt
Expand
Use dark colors for code blocks
    private fun findRoute() {

        val routeTask = RouteTask(
            "https://route-api.arcgis.com/arcgis/rest/services/World/Route/NAServer/Route_World"
        )

    }
Expand

To solve a route, the route task needs appropriate RouteParameters. We will start by retrieving the default route parameters and then modify them.

Get the default route parameters by calling RouteTask.createDefaultParameters(). When the call fails: in the getOrElse lambda, output an error message and return from lifecycleScope.launch. When the call returns a RouteParameters object: use it to add the route stops and configure the task to return step-by-step directions.

Note that createDefaultParameters()function is a suspend function that returns a Result<RouteParameters> object. For more information on Result<> in Kotlin, see Result. Scroll down to getOrElse.

For more information on RouteParameters, see setStops() and returnDirections in the API Reference for ArcGIS Maps SDK for Kotlin.

MainActivity.kt
Expand
Use dark colors for code blocks
    private fun findRoute() {

        val routeTask = RouteTask(
            "https://route-api.arcgis.com/arcgis/rest/services/World/Route/NAServer/Route_World"
        )

        lifecycleScope.launch {
            val routeParameters: RouteParameters = routeTask.createDefaultParameters().getOrElse { error ->
                return@launch showError("Error creating default route parameters: " + error.message)

            }
            routeParameters.setStops(routeStops)
            routeParameters.returnDirections = true

        }

    }
Expand

Solve the route by calling solveRoute() on the route task, passing in the route parameters. This is the route between the origin and the destination stops.

When the call fails: in the getOrElse lambda, output an error message and return from lifecycleScope.launch. When the call returns a RouteResults object: use it to get the list of routes from the route result, verify that the list is not empty, and retrieve the first route in the list.

Note that solveRoute()function is a suspend function that returns a Result<RouteResult> object. For more information on Result<> in Kotlin, see Result. Scroll down to getOrElse.

For more information on routeResult, see RouteResult in the API Reference for ArcGIS Maps SDK for Kotlin.

MainActivity.kt
Expand
Use dark colors for code blocks
        lifecycleScope.launch {
            val routeParameters: RouteParameters = routeTask.createDefaultParameters().getOrElse { error ->
                return@launch showError("Error creating default route parameters: " + error.message)

            }
            routeParameters.setStops(routeStops)
            routeParameters.returnDirections = true

            // get the route and display it
            val routeResult: RouteResult = routeTask.solveRoute(routeParameters).getOrElse { error ->
                return@launch showError("Error solving route: " + error.message)
            }

            val routes = routeResult.routes
            if (routes.isNotEmpty()) {
                val route = routes[0]

            }

        }
Expand

Create a new graphic that will be used to display this route. Call the Graphic constructor, passing in the route's Geometry and a SimpleLineSymbol. Then add the graphic to the graphicsOverlay.

MainActivity.kt
Expand
Use dark colors for code blocks
        lifecycleScope.launch {
            val routeParameters: RouteParameters = routeTask.createDefaultParameters().getOrElse { error ->
                return@launch showError("Error creating default route parameters: " + error.message)

            }
            routeParameters.setStops(routeStops)
            routeParameters.returnDirections = true

            // get the route and display it
            val routeResult: RouteResult = routeTask.solveRoute(routeParameters).getOrElse { error ->
                return@launch showError("Error solving route: " + error.message)
            }

            val routes = routeResult.routes
            if (routes.isNotEmpty()) {
                val route = routes[0]

                val shape = route.routeGeometry
                val routeGraphic = Graphic(
                    shape,
                    SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.green, 2f)
                )
                graphicsOverlay.graphics.add(routeGraphic)

            }

        }
Expand

Direction maneuvers are the step-by-step navigation actions for a route. Each direction maneuver has direction text, such as "Turn right at Avenue A."

Clear any existing directions in the directionsList property you created at the start of this tutorial.
Access the list of manuevers from the directionManeuvers property of route. Use forEach to iterate through the maneuvers, adding the direction text for each meaneuver to the directionsList property.

Call notifyDataSetChanged() on the arrayAdapter property, which causes the list view (in the listView property) to be updated with the text directions.

MainActivity.kt
Expand
Use dark colors for code blocks
        lifecycleScope.launch {
            val routeParameters: RouteParameters = routeTask.createDefaultParameters().getOrElse { error ->
                return@launch showError("Error creating default route parameters: " + error.message)

            }
            routeParameters.setStops(routeStops)
            routeParameters.returnDirections = true

            // get the route and display it
            val routeResult: RouteResult = routeTask.solveRoute(routeParameters).getOrElse { error ->
                return@launch showError("Error solving route: " + error.message)
            }

            val routes = routeResult.routes
            if (routes.isNotEmpty()) {
                val route = routes[0]

                val shape = route.routeGeometry
                val routeGraphic = Graphic(
                    shape,
                    SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.green, 2f)
                )
                graphicsOverlay.graphics.add(routeGraphic)

                // get the direction text for each maneuver and display it as a list in the UI
                directionsList.clear()
                route.directionManeuvers.forEach { directionManeuver: DirectionManeuver ->
                    directionsList.add(directionManeuver.directionText)
                }
                arrayAdapter.notifyDataSetChanged()

            }

        }
Expand

Create a `clear` function

Create a function to clear the current route.

This function will clear the routeStops list, clear any Graphics from the graphicsOverlay, and reset the listView.

MainActivity.kt
Expand
Use dark colors for code blocks
    private fun clear() {
        routeStops.clear()
        graphicsOverlay.graphics.clear()
        directionsList.clear()
        directionsList.add("Tap to add two points to the map to find a route between them.")
        arrayAdapter.notifyDataSetChanged()
    }
Expand

Handle user input

In the setupMap() function, access the onSingleTapConfirmed property of mapView. In the collect lambda, handle the SingleTapConfirmedEvent.

If the event's mapPoint property is null, then return immediately from the collect call. Otherwise, continue using a Kotlin when expression.

The when expression adds the first stop on the first tap. On the second tap, the second stop is added and your findRoute() function is called. A third tap calls your clear() function, and adds a new first stop as the route progresses.

The onSingleTapConfirmed property is of type SharedFlow<SingleTapConfirmedEvent>, which must be "collected" to obtain a value. That is why you call collect on the property and pass a lambda to handle the single tap confirmed event. For more information on the use of flows in Android development, see StateFlow and SharedFlow. For more information on the event, see SingleTapConfirmedEvent in the API Reference.

MainActivity.kt
Expand
Use dark colors for code blocks
        // set the map to be displayed in the layout's MapView
        mapView.map = map

        mapView.setViewpoint(Viewpoint(34.0539, -118.2453, 144447.638572))

        mapView.apply {

            graphicsOverlays.add(graphicsOverlay)

            lifecycleScope.launch {
                onSingleTapConfirmed.collect { event: SingleTapConfirmedEvent ->
                    val point: Point = event.mapPoint ?: return@collect showError("No map point retrieved from tap.")
                    when (routeStops.size) {
                        // on first tap, add a stop
                        0 -> {
                            addStop(Stop(point))
                        }
                        // on second tap, add a stop and find route between them
                        1 -> {
                            addStop(Stop(point))
                            findRoute()
                            Toast.makeText(
                                applicationContext,
                                "Calculating route.",
                                Toast.LENGTH_SHORT
                            ).show()
                        }
                        // on a further tap, clear and add a new first stop
                        else -> {
                            clear()
                            addStop(Stop(point))
                        }
                    }
                }
            }

        }
Expand

Click Run > Run > app to run the app.

The map should support two taps to create origin and destination points and then use the route service to display the resulting route and turn-by-turn directions.

What's next?

To explore more API features and ArcGIS location services, try the following tutorial: