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

Before starting this tutorial:

You need an ArcGIS Location Platform or ArcGIS Online account.
Confirm that your system meets the system requirements.
An IDE for Android development in Kotlin.

Steps

Get an access token

You need an access token to use the location services used in this tutorial.

Go to the Create an API key tutorial to obtain an access token.
Ensure that the following privileges are enabled: Location services > Basemaps > Basemap styles service and Location services > Routing.
Copy the access token as it will be used in the next step.

To learn more about other ways to get an access token, go to Types of authentication.

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
  21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 21 22 23 24
  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 24 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.
Set the API key using the copied access token.
1. In Android Studio: in the Android tool window, open app > java > com.example.app > MainActivity.
2. In the setApiKeyForApp() method, find the ArcGISRuntimeEnvironment.setApiKey("YOUR_ACCESS_TOKEN") call and paste your access token inside the double quotes, replacing YOUR_ACCESS_TOKEN.
  MainActivity.kt
  Use dark colors for code blocks
  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 private fun setApiKeyForApp(){ ArcGISRuntimeEnvironment.setApiKey("YOUR_ACCESS_TOKEN") }
  Warning
  The access token is stored directly in the code as a convenience for this tutorial. Storing access tokens in the source code is not best practice.

Add import statements and class properties

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 app-specific import statements with the imports needed for this tutorial.

MainActivity.kt
Use dark colors for code blocks
16
16
16
16
16
16
16
16
16
16
16
16
16
16
16
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
45
Change lineChange lineChange lineChange lineChange lineChange lineChange lineChange lineChange lineChange lineChange lineChange lineChange lineChange lineChange lineChange lineChange lineChange lineChange lineChange lineChange lineChange linepackage com.example.app

import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity

import android.R.layout
import android.graphics.Color
import android.util.Log
import android.view.MotionEvent
import android.widget.ArrayAdapter
import android.widget.ListView
import android.widget.Toast

import com.esri.arcgisruntime.ArcGISRuntimeEnvironment
import com.esri.arcgisruntime.mapping.ArcGISMap
import com.esri.arcgisruntime.mapping.BasemapStyle
import com.esri.arcgisruntime.mapping.Viewpoint
import com.esri.arcgisruntime.mapping.view.DefaultMapViewOnTouchListener
import com.esri.arcgisruntime.mapping.view.Graphic
import com.esri.arcgisruntime.mapping.view.GraphicsOverlay
import com.esri.arcgisruntime.mapping.view.MapView
import com.esri.arcgisruntime.symbology.SimpleLineSymbol
import com.esri.arcgisruntime.symbology.SimpleMarkerSymbol
import com.esri.arcgisruntime.tasks.networkanalysis.RouteTask
import com.esri.arcgisruntime.tasks.networkanalysis.Stop

import kotlin.math.roundToInt

import com.example.app.databinding.ActivityMainBinding

Within the MainActivity class, add the following class properties.

MainActivity.kt
Use dark colors for code blocks
46
46
46
46
46
46
46
46
46
46
46
46
46
46
46
46
46
46
46
46
46
46
46
46
46
46
46
46
46
46
46
46
46
46
46
46
46
46
46
46
46
46
46
46
46
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
80
Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.
class MainActivity : AppCompatActivity() {

    private val activityMainBinding: ActivityMainBinding by lazy {
        ActivityMainBinding.inflate(layoutInflater)
    }

    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)
        setContentView(activityMainBinding.root)

Update the map

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

In the setupMap() function, update the Basemap style property from ARCGIS_TOPOGRAPHIC to ARCGIS_STREETS, and update the latitude and longitude coordinates to center on Los Angeles.

MainActivity.kt
Expand
Use dark colors for code blocks
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
110
109
108
108
108
108
108
108
108
108
108
108
108
108
108
108
108
108
108
108
108
108
108
108
108
108
108
108
108
108
109
110
111
112
113
114
115
116
117
118
119
119
119
119
119
119
119
119
119
119
119
119
119
119
119
119
119
119
119
119
119
119
119
119
119
119
119
119
119
119
119
119
120
121
122
122
121
120
119
118
117
116
115
114
113
112
111
110
109
108
107
106
105
104
103
102
101
100
99
98
97
96
95
94
93
92
91
90
89
88
87
86
85
84
83
82
81
80
79
78
77
76
75
74
73
72
71
70
69
68
67
66
65
64
63
62
61
60
59
58
57
56
55
54
53
52
51
50
49
48
47
46
46
Change lineChange line    // set up your map here. You will call this method from onCreate()
    private fun setupMap() {

        val map = ArcGISMap(BasemapStyle.ARCGIS_STREETS)

        mapView.apply {
            // set the map on the map view
            this.map = map

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

        }

    }
Expand

Add the graphicsOverlay to the mapView. 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.

MainActivity.kt
Expand
Use dark colors for code blocks
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
114
113
113
113
113
113
113
113
113
113
113
113
113
113
113
113
113
113
113
113
113
113
113
113
113
113
113
113
113
113
113
113
113
113
114
115
116
117
118
119
120
121
121
121
121
121
121
121
121
121
121
121
121
121
121
121
121
121
121
121
121
121
121
121
121
121
121
121
121
121
121
122
122
122
122
121
120
119
118
117
116
115
114
113
112
111
110
109
108
107
106
105
104
103
102
101
100
99
98
97
96
95
94
93
92
91
90
89
88
87
86
85
84
83
82
81
80
79
78
77
76
75
74
73
72
71
70
69
68
67
66
65
64
63
62
61
60
59
58
57
56
55
54
53
52
51
50
49
48
47
46
46
Add line.        mapView.apply {
            // set the map on the map view
            this.map = map

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

            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 AndroidListView which will display a vertical list of directions.

activity_main.xml
Expand
Use dark colors for code blocks
17
17
17
17
17
17
17
17
17
17
17
17
17
17
17
17
17
18
19
20
21
22
23
24
25
26
26
26
Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.    <ListView
        android:id="@+id/listView"
        android:layout_width="0dp"
        android:layout_height="0dp"
        android:background="@android:drawable/screen_background_light"
        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, set the arrayAdapter to the listView. The ArrayAdapter will create and populate the listView with TextViews as required.

MainActivity.kt
Expand
Use dark colors for code blocks
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
77
78
79
80
81
82
83
84
85
86
87
88
88
88
88
88
88
88
88
88
88
88
88
88
88
88
88
88
88
88
88
88
88
88
88
88
88
88
88
88
88
88
88
88
88
88
88
87
86
85
84
83
82
81
80
79
78
77
76
75
74
73
72
71
70
69
68
67
66
65
64
63
62
61
60
59
59
59
59
59
58
57
56
55
54
53
52
51
50
49
48
47
46
45
44
43
42
41
40
39
38
37
36
35
34
33
32
31
30
29
28
27
26
25
24
23
22
21
20
19
18
17
16
15
14
13
12
11
10
9
8
7
6
5
4
3
2
1
0
-1
-2
-3
-4
-5
-6
-7
-8
-9
-10
-11
-12
-13
-14
-15
-16
-17
-17
Add line.    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(activityMainBinding.root)

        listView.adapter = arrayAdapter

        setApiKeyForApp()

        setupMap()

    }
Expand

Create an `addStop` function

A RouteTask requires at least a single origin and destination stop to find a route. Create a function to handle user interaction with the map and to add stops and display them as graphics when the map is tapped.

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
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
155
154
153
152
151
150
149
148
147
146
145
144
143
142
141
140
139
138
137
136
135
134
133
132
131
130
129
128
127
127
127
127
127
128
129
129
129
129
129
129
129
129
129
129
130
130
129
128
127
126
125
124
123
122
121
120
119
118
117
116
115
114
113
112
111
110
109
108
107
106
105
104
103
102
101
100
99
98
97
96
95
94
93
92
91
90
89
88
87
86
85
84
83
82
81
80
79
78
77
76
75
74
73
72
71
70
69
68
67
67
Add line.Add line.Add line.    private fun addStop(stop: Stop) {

    }
Expand

Add the stop to the MutableList<Stop> named routeStops.

MainActivity.kt
Expand
Use dark colors for code blocks
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
155
154
153
152
151
150
149
148
147
146
145
144
143
142
141
140
139
138
137
136
135
134
133
132
131
130
129
128
127
127
127
127
127
128
129
130
131
131
131
131
131
131
131
131
132
132
131
130
129
128
127
126
125
124
123
122
121
120
119
118
117
116
115
114
113
112
111
110
109
108
107
106
105
104
103
102
101
100
99
98
97
96
95
94
93
92
91
90
89
88
87
86
85
84
83
82
81
80
79
78
77
76
75
74
73
72
71
70
69
69
Add line.    private fun addStop(stop: Stop) {

        routeStops.add(stop)

    }
Expand

Create a SimpleMarkerSymbol and use the stop's Geometry to create a new Graphic and add it to the graphicsOverlay.

MainActivity.kt
Expand
Use dark colors for code blocks
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
156
155
154
153
152
151
150
149
148
147
146
145
144
143
142
141
140
139
138
137
136
135
134
133
132
131
130
129
128
127
127
127
127
127
128
129
130
131
132
133
134
135
136
137
138
139
139
138
137
136
135
134
133
132
131
130
129
128
127
126
125
124
123
122
121
120
119
118
117
116
115
114
113
112
111
110
109
108
107
106
105
104
103
102
101
100
99
98
97
96
95
94
93
92
91
90
89
88
87
86
85
84
83
82
81
80
79
78
77
76
76
Add line.Add line.Add line.Add line.Add line.Add line.    private fun addStop(stop: Stop) {

        routeStops.add(stop)

        // create a blue circle symbol for the stop
        val stopMarker = SimpleMarkerSymbol(SimpleMarkerSymbol.Style.CIRCLE, Color.BLUE, 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 route task makes a request to a service and returns the results. Solve the route between the origin and destination stops using a RouteTask, which 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
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
168
167
166
165
164
163
162
161
160
159
158
157
156
155
154
153
152
151
150
149
148
147
146
145
144
143
142
141
140
140
140
140
140
140
140
140
140
140
140
140
140
140
140
140
140
140
141
142
142
142
142
142
142
142
142
142
142
142
142
142
142
141
140
139
138
137
135
133
131
129
127
124
121
118
115
112
109
106
103
100
97
94
91
89
87
86
85
84
83
82
81
80
80
80
80
80
80
80
80
81
81
80
79
78
77
76
75
74
73
73
Add line.Add line.Add line.    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
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
168
167
166
165
164
163
162
161
160
159
158
157
156
155
154
153
152
151
150
149
148
147
146
145
144
143
142
141
140
140
140
140
140
140
140
140
140
140
140
140
140
140
140
140
140
140
141
142
143
144
145
146
147
147
147
147
147
147
147
147
147
146
145
144
143
142
140
138
136
134
132
129
126
123
120
117
114
111
108
105
102
99
96
94
92
91
90
89
88
87
86
85
85
85
85
85
85
85
85
86
86
85
84
83
82
81
80
79
78
78
Add line.Add line.Add line.Add line.    private fun findRoute() {

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

    }
Expand

Get default RouteParameters from the routeTask and set the return directions property to true. This specifies that the route results should include turn-by-turn directions. Also, set the routeStops list to the routeParameters with setStops(routeStops).

The createDefaultParametersAsync() method is asynchronous and you must handle its completion and check for errors.

MainActivity.kt
Expand
Use dark colors for code blocks
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
169
168
167
166
165
164
163
162
161
160
159
158
157
156
155
154
153
152
151
150
149
148
147
146
145
144
143
142
141
140
140
140
140
140
140
140
140
140
140
140
140
140
140
140
140
140
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
155
155
155
155
155
154
153
152
151
150
148
146
144
142
140
138
136
134
132
130
128
126
125
124
124
124
124
124
124
124
124
125
126
127
128
129
130
131
132
132
131
130
129
128
127
126
125
124
124
Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.    private fun findRoute() {

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

        val routeParametersFuture = routeTask.createDefaultParametersAsync()
        routeParametersFuture.addDoneListener {
            try {
                val routeParameters = routeParametersFuture.get().apply {
                    isReturnDirections = true
                    setStops(routeStops)
                }

            } catch (e: Exception) {
                val error = "Error creating default route parameters: " + e.message
                Toast.makeText(this, error, Toast.LENGTH_LONG).show()
                Log.e(MainActivity::class.simpleName, error)
            }
        }

    }
Expand

To find the route between the origin and destination stops, solve the route using the RouteTask with the routeParameters.

MainActivity.kt
Expand
Use dark colors for code blocks
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
176
175
174
173
172
171
170
169
168
167
166
165
164
163
162
161
160
159
158
157
156
155
154
153
152
151
150
149
148
147
147
147
147
147
147
147
147
147
147
147
147
147
147
147
147
147
147
147
147
147
147
147
147
147
148
149
150
151
152
153
154
155
156
157
158
159
160
160
160
160
160
160
159
158
157
156
155
154
153
152
151
150
149
148
148
148
149
150
151
152
153
154
155
156
157
158
159
160
161
161
161
161
160
159
158
157
156
155
154
153
153
Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.        val routeParametersFuture = routeTask.createDefaultParametersAsync()
        routeParametersFuture.addDoneListener {
            try {
                val routeParameters = routeParametersFuture.get().apply {
                    isReturnDirections = true
                    setStops(routeStops)
                }

                // get the route and display it
                val routeResultFuture = routeTask.solveRouteAsync(routeParameters)
                routeResultFuture.addDoneListener {
                    try {

                    } catch (e: Exception) {
                        val error = "Error solving route: " + e.message
                        Toast.makeText(this, error, Toast.LENGTH_LONG).show()
                        Log.e(MainActivity::class.simpleName, error)
                    }
                }

            } catch (e: Exception) {
                val error = "Error creating default route parameters: " + e.message
                Toast.makeText(this, error, Toast.LENGTH_LONG).show()
                Log.e(MainActivity::class.simpleName, error)
            }
        }
Expand

Obtain a RouteResult (the result is a collection of computed routes) and get the list of Routes from the result. Each element represents an independent route with its own driving directions. The routing service only returns the optimal route. Check that a route was returned, and retrieve the first one.

MainActivity.kt
Expand
Use dark colors for code blocks
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
184
183
182
181
180
179
178
177
176
175
174
173
172
171
170
169
168
167
166
165
164
163
162
161
160
159
158
157
156
155
155
155
155
155
155
155
155
155
155
155
155
155
155
155
155
155
155
155
155
155
155
155
155
155
155
155
155
155
155
155
155
155
156
157
158
159
160
161
162
163
164
165
165
165
165
165
165
165
165
165
165
165
165
165
166
167
168
169
170
171
172
173
173
173
173
173
173
173
173
173
173
173
172
171
170
169
168
167
166
165
165
Add line.Add line.Add line.Add line.Add line.Add line.                // get the route and display it
                val routeResultFuture = routeTask.solveRouteAsync(routeParameters)
                routeResultFuture.addDoneListener {
                    try {

                        val result = routeResultFuture.get()
                        val routes = result.routes
                        if (routes.isNotEmpty()) {
                            val route = routes[0]

                        }

                    } catch (e: Exception) {
                        val error = "Error solving route: " + e.message
                        Toast.makeText(this, error, Toast.LENGTH_LONG).show()
                        Log.e(MainActivity::class.simpleName, error)
                    }
                }
Expand

Display this route on the map by creating a new Graphic using the route's Geometry and a SimpleLineSymbol, and adding it to the graphicsOverlay.

MainActivity.kt
Expand
Use dark colors for code blocks
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
188
187
186
185
184
183
182
181
180
179
178
177
176
175
174
173
172
171
170
169
168
167
166
165
164
163
162
161
160
160
160
160
160
160
160
160
160
160
160
160
160
160
160
160
160
160
160
160
160
160
160
160
160
160
160
160
160
160
160
160
160
160
160
160
160
160
161
162
163
164
165
166
167
168
169
170
171
172
172
172
172
172
172
173
173
173
173
173
173
173
173
173
173
173
173
173
173
173
173
173
173
172
171
170
169
168
167
166
165
165
Add line.Add line.Add line.Add line.Add line.Add line.                        val result = routeResultFuture.get()
                        val routes = result.routes
                        if (routes.isNotEmpty()) {
                            val route = routes[0]

                            val shape = route.routeGeometry
                            val routeGraphic = Graphic(
                                shape,
                                SimpleLineSymbol(SimpleLineSymbol.Style.SOLID, Color.BLUE, 2f)
                            )
                            graphicsOverlay.graphics.add(routeGraphic)

                        }
Expand

You can get driving directions from the route service by passing true to the setReturnDirections() method on RouteParameters. To display the driving directions, get each DirectionManeuver from the route, and add them to the listView.

MainActivity.kt
Expand
Use dark colors for code blocks
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
189
188
187
186
185
184
183
182
181
180
179
178
177
176
175
174
173
172
171
170
169
168
167
166
165
164
163
162
161
160
160
160
160
160
160
160
160
160
160
160
160
160
160
160
160
160
160
160
160
160
160
160
160
160
160
160
160
160
160
160
160
160
160
160
160
160
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
178
178
178
178
178
178
178
178
178
178
178
178
178
178
178
178
178
177
176
175
174
173
172
171
170
170
Add line.Add line.Add line.Add line.                        val result = routeResultFuture.get()
                        val routes = result.routes
                        if (routes.isNotEmpty()) {
                            val route = routes[0]

                            val shape = route.routeGeometry
                            val routeGraphic = Graphic(
                                shape,
                                SimpleLineSymbol(SimpleLineSymbol.Style.SOLID, Color.BLUE, 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 { directionsList.add(it.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
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
215
214
213
212
211
210
209
208
207
206
205
204
203
202
201
200
199
198
197
196
195
194
193
192
191
190
189
188
187
186
186
186
186
186
186
186
186
186
186
186
186
186
186
186
186
186
186
186
186
186
186
186
186
186
186
186
186
186
186
186
186
186
186
186
186
186
186
186
186
186
186
186
186
186
186
186
186
186
186
186
186
186
186
186
186
186
186
186
186
186
186
186
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
202
202
Add line.Add line.Add line.Add line.Add line.Add line.Add line.            } catch (e: Exception) {
                val error = "Error creating default route parameters: " + e.message
                Toast.makeText(this, error, Toast.LENGTH_LONG).show()
                Log.e(MainActivity::class.simpleName, error)
            }
        }

    }

    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

Create a DefaultMapViewOnTouchListener and override onSingleTapConfirmed with a Kotlin when expression.

The Kotlin when expression adds the first stop on the first tap, the second stop on a second tap, and so forth on all subsequent taps, calls findRoute(), calls clear(), and adds a new first stop as the route progresses.

MainActivity.kt
Expand
Use dark colors for code blocks
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
153
Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.Add line.        mapView.apply {
            // set the map on the map view
            this.map = map

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

            graphicsOverlays.add(graphicsOverlay)

            onTouchListener =
                object : DefaultMapViewOnTouchListener(this@MainActivity, mapView) {
                    override fun onSingleTapConfirmed(e: MotionEvent): Boolean {
                        val screenPoint = android.graphics.Point(e.x.roundToInt(), e.y.roundToInt())
                        when (routeStops.size) {
                            // on first tap, add a stop
                            0 -> {
                                addStop(Stop(mapView.screenToLocation(screenPoint)))
                            }
                            // on second tap, add a stop and find route between them
                            1 -> {
                                addStop(Stop(mapView.screenToLocation(screenPoint)))
                                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(mapView.screenToLocation(screenPoint)))
                            }
                        }
                        return true
                    }
                }

        }
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: