Learn how to use a URL to access and display a feature layerA feature layer (server-side) is a spatially-enabled table in a feature service. All features in a feature layer share the same geometry type and set of fields. Learn more in a map.A map is a collection of layers that are displayed in 2D. It is typically composed of a basemap layer and data layers. Learn more

Map of the Santa Monica Mountains with parks, trails, and trailhead symbols.

A mapA map is a collection of layers that are displayed in 2D. It is typically composed of a basemap layer and data layers. Learn more contains layersA layer is a reference to a collection of geographic data that is used to access and display data. The data for layers are typically provided by the basemap layer service and data services. Learn more of geographic data. A map contains a basemap layerA basemap layer is the layer in a map or scene that displays basemap data. The data source for a basemap layer is typically a basemap service. Learn more and, optionally, one or more data layersA data layer is a layer that references geographic data from a file or a service and is used to visualize the data in a map or scene. Learn more . This tutorial shows you how to access and display a feature layerA feature layer (server-side) is a spatially-enabled table in a feature service. All features in a feature layer share the same geometry type and set of fields. Learn more in a mapA map is a collection of layers that are displayed in 2D. It is typically composed of a basemap layer and data layers. Learn more . You access feature layers with an itemAn item, also known as a content item, is a resource stored in a portal such as a web map, hosted layer, style, script tool, file, or notebook. Learn more ID or URL. You will use URLs to access the Trailheads, Trails, and Parks and Open Spaces feature layers and display them in a map.

A feature layerA feature layer (server-side) is a spatially-enabled table in a feature service. All features in a feature layer share the same geometry type and set of fields. Learn more is a dataset in a feature serviceA feature service is a data service that provides access to spatial and non-spatial data in feature layers, feature layer views, and tables. Learn more hosted in ArcGISArcGIS is the brand name for all of the desktop, server, and developer products and technologies offered by Esri. Learn more . Each feature layer contains featuresA feature is a single record, also known as a row, that represents a real-world entity. It typically contains a geometry (point, multipoint, polyline, or polygon) and attributes but it can also contain just attributes. Learn more with a single geometryA geometry is a geometric shape, such as a point, polyline, or polygon, that contains one or more coordinates and a spatial reference. Learn more type (pointA point is a type of geometry containing a single set of x,y coordinates and a spatial reference. Learn more , lineA polyline is a type of geometry containing ordered point coordinates and a spatial reference. Learn more , or polygonA polygon is a type of geometry containing an array of rings and a spatial reference. Each ring contains an array of point coordinates, where the first and last point are the same. Learn more ), and a set of attributesAttributes are fields and values for a single feature or non-spatial record. They are typically stored in a database or service such as a feature service. Learn more . You can use feature layers to store, access, and manage large amounts of geographic data for your applications.

In this tutorial, you use URLs to access and display three different feature layersA feature layer (server-side) is a spatially-enabled table in a feature service. All features in a feature layer share the same geometry type and set of fields. Learn more hosted in ArcGIS OnlineArcGIS Online is a GIS mapping, analytics, data hosting, and content management software as a service (SaaS) product. It includes applications, tools, APIs, and location services for users and developers. It is subscription-based and requires an ArcGIS Online account. Learn more :

Prerequisites

Before starting this tutorial, you need the following:

  1. An ArcGIS Location Platform or ArcGIS Online account.

  2. A development and deployment environment that meets the system requirements.

  3. An IDE for Android development in Kotlin.

Develop or download

You have two options for completing this tutorial:

  1. Option 1: Develop the code or
  2. Option 2: Download the completed solution

Option 1: Develop the code

Open an Android Studio project

  1. Open the project you created by completing the Display a map tutorial.

  2. Continue with the following instructions to use a URL to access and display a feature layer in a map.

  3. Modify the old project for use in this new tutorial.

Add import statements

In MainScreen.kt, replace the import statements with the imports needed for this tutorial.

MainScreen.kt
@file:OptIn(ExperimentalMaterial3Api::class)
package com.example.app.screens
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.ExperimentalMaterial3Api
import androidx.compose.material3.Scaffold
import androidx.compose.material3.Text
import androidx.compose.material3.TopAppBar
import androidx.compose.runtime.Composable
import androidx.compose.runtime.remember
import androidx.compose.ui.Modifier
import androidx.compose.ui.res.stringResource
import com.arcgismaps.data.ServiceFeatureTable
import com.arcgismaps.mapping.ArcGISMap
import com.arcgismaps.mapping.BasemapStyle
import com.arcgismaps.mapping.Viewpoint
import com.arcgismaps.mapping.layers.FeatureLayer
import com.arcgismaps.toolkit.geoviewcompose.MapView
import com.example.app.R

    Change the view point scale

    In MainScreen.kt, inside the top-level function createMap(): Modify the Viewpoint constructor call so it passes a scale parameter more appropriate to tutorial.

    MainScreen.kt
    40 collapsed lines
    @file:OptIn(ExperimentalMaterial3Api::class)
    package com.example.app.screens
    import androidx.compose.foundation.layout.fillMaxSize
    import androidx.compose.foundation.layout.padding
    import androidx.compose.material3.ExperimentalMaterial3Api
    import androidx.compose.material3.Scaffold
    import androidx.compose.material3.Text
    import androidx.compose.material3.TopAppBar
    import androidx.compose.runtime.Composable
    import androidx.compose.runtime.remember
    import androidx.compose.ui.Modifier
    import androidx.compose.ui.res.stringResource
    import com.arcgismaps.data.ServiceFeatureTable
    import com.arcgismaps.mapping.ArcGISMap
    import com.arcgismaps.mapping.BasemapStyle
    import com.arcgismaps.mapping.Viewpoint
    import com.arcgismaps.mapping.layers.FeatureLayer
    import com.arcgismaps.toolkit.geoviewcompose.MapView
    import com.example.app.R
    @Composable
    fun MainScreen() {
    val map = remember {
    createMap()
    }
    Scaffold(
    topBar = { TopAppBar(title = { Text(text = stringResource(id = R.string.app_name)) }) }
    ) {
    MapView(
    modifier = Modifier.fillMaxSize().padding(it),
    arcGISMap = map
    )
    }
    }
    fun createMap(): ArcGISMap {
    return ArcGISMap(BasemapStyle.ArcGISTopographic).apply {
    initialViewpoint = Viewpoint(
    latitude = 34.0270,
    longitude = -118.8050,
    scale = 200000.0
    )
    }
    }

      Create service feature tables to reference feature service data

      To display three new data layersA data layer is a layer that references geographic data from a file or a service and is used to visualize the data in a map or scene. Learn more (also known as operational layers) on top of the current basemap, you will create ServiceFeatureTables using URLs to reference datasets hosted in ArcGIS OnlineArcGIS Online is a GIS mapping, analytics, data hosting, and content management software as a service (SaaS) product. It includes applications, tools, APIs, and location services for users and developers. It is subscription-based and requires an ArcGIS Online account. Learn more .

      1. Open a browser and navigate to the URL for Parks and Open Spaces to view metadata about the layer. To display the layer in your app, you only need the URL.

      2. In createMap(), before the code that creates the ArcGISMap, do the following.

        1. Create strings that hold the URLs to the hosted layers. The URLs are: Trailheads (points), Trails (lines), and Parks and Open Spaces (polygons).

          MainScreen.kt
          40 collapsed lines
          @file:OptIn(ExperimentalMaterial3Api::class)
          package com.example.app.screens
          import androidx.compose.foundation.layout.fillMaxSize
          import androidx.compose.foundation.layout.padding
          import androidx.compose.material3.ExperimentalMaterial3Api
          import androidx.compose.material3.Scaffold
          import androidx.compose.material3.Text
          import androidx.compose.material3.TopAppBar
          import androidx.compose.runtime.Composable
          import androidx.compose.runtime.remember
          import androidx.compose.ui.Modifier
          import androidx.compose.ui.res.stringResource
          import com.arcgismaps.data.ServiceFeatureTable
          import com.arcgismaps.mapping.ArcGISMap
          import com.arcgismaps.mapping.BasemapStyle
          import com.arcgismaps.mapping.Viewpoint
          import com.arcgismaps.mapping.layers.FeatureLayer
          import com.arcgismaps.toolkit.geoviewcompose.MapView
          import com.example.app.R
          @Composable
          fun MainScreen() {
          val map = remember {
          createMap()
          }
          Scaffold(
          topBar = { TopAppBar(title = { Text(text = stringResource(id = R.string.app_name)) }) }
          ) {
          MapView(
          modifier = Modifier.fillMaxSize().padding(it),
          arcGISMap = map
          )
          }
          }
          fun createMap(): ArcGISMap {
          val parksUrl =
          "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Parks_and_Open_Space_Styled/FeatureServer/0"
          val trailsUrl =
          "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Trails_Styled/FeatureServer/0"
          val trailHeadsUrl =
          "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Trailheads_Styled/FeatureServer/0"
          return ArcGISMap(BasemapStyle.ArcGISTopographic).apply {
          initialViewpoint = Viewpoint(
          latitude = 34.0270,
          longitude = -118.8050,
          scale = 200000.0
          )
          }
          }
          • Create three ServiceFeatureTable objects, using a string URL to reference the datasets.

            MainScreen.kt
            40 collapsed lines
            @file:OptIn(ExperimentalMaterial3Api::class)
            package com.example.app.screens
            import androidx.compose.foundation.layout.fillMaxSize
            import androidx.compose.foundation.layout.padding
            import androidx.compose.material3.ExperimentalMaterial3Api
            import androidx.compose.material3.Scaffold
            import androidx.compose.material3.Text
            import androidx.compose.material3.TopAppBar
            import androidx.compose.runtime.Composable
            import androidx.compose.runtime.remember
            import androidx.compose.ui.Modifier
            import androidx.compose.ui.res.stringResource
            import com.arcgismaps.data.ServiceFeatureTable
            import com.arcgismaps.mapping.ArcGISMap
            import com.arcgismaps.mapping.BasemapStyle
            import com.arcgismaps.mapping.Viewpoint
            import com.arcgismaps.mapping.layers.FeatureLayer
            import com.arcgismaps.toolkit.geoviewcompose.MapView
            import com.example.app.R
            @Composable
            fun MainScreen() {
            val map = remember {
            createMap()
            }
            Scaffold(
            topBar = { TopAppBar(title = { Text(text = stringResource(id = R.string.app_name)) }) }
            ) {
            MapView(
            modifier = Modifier.fillMaxSize().padding(it),
            arcGISMap = map
            )
            }
            }
            fun createMap(): ArcGISMap {
            val parksUrl =
            "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Parks_and_Open_Space_Styled/FeatureServer/0"
            val trailsUrl =
            "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Trails_Styled/FeatureServer/0"
            val trailHeadsUrl =
            "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Trailheads_Styled/FeatureServer/0"
            val parksServiceFeatureTable = ServiceFeatureTable(parksUrl)
            val trailsServiceFeatureTable = ServiceFeatureTable(trailsUrl)
            val trailHeadsServiceFeatureTable = ServiceFeatureTable(trailHeadsUrl)
            return ArcGISMap(BasemapStyle.ArcGISTopographic).apply {
            initialViewpoint = Viewpoint(
            latitude = 34.0270,
            longitude = -118.8050,
            scale = 200000.0
            )
            }
            }
            • You will use FeatureLayers to display the hosted layers on top of the basemap.

              Create three new FeatureLayers using FeatureLayer.createWithFeatureTable(), to which you pass a service feature table.

              MainScreen.kt
              40 collapsed lines
              @file:OptIn(ExperimentalMaterial3Api::class)
              package com.example.app.screens
              import androidx.compose.foundation.layout.fillMaxSize
              import androidx.compose.foundation.layout.padding
              import androidx.compose.material3.ExperimentalMaterial3Api
              import androidx.compose.material3.Scaffold
              import androidx.compose.material3.Text
              import androidx.compose.material3.TopAppBar
              import androidx.compose.runtime.Composable
              import androidx.compose.runtime.remember
              import androidx.compose.ui.Modifier
              import androidx.compose.ui.res.stringResource
              import com.arcgismaps.data.ServiceFeatureTable
              import com.arcgismaps.mapping.ArcGISMap
              import com.arcgismaps.mapping.BasemapStyle
              import com.arcgismaps.mapping.Viewpoint
              import com.arcgismaps.mapping.layers.FeatureLayer
              import com.arcgismaps.toolkit.geoviewcompose.MapView
              import com.example.app.R
              @Composable
              fun MainScreen() {
              val map = remember {
              createMap()
              }
              Scaffold(
              topBar = { TopAppBar(title = { Text(text = stringResource(id = R.string.app_name)) }) }
              ) {
              MapView(
              modifier = Modifier.fillMaxSize().padding(it),
              arcGISMap = map
              )
              }
              }
              fun createMap(): ArcGISMap {
              val parksUrl =
              "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Parks_and_Open_Space_Styled/FeatureServer/0"
              val trailsUrl =
              "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Trails_Styled/FeatureServer/0"
              val trailHeadsUrl =
              "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Trailheads_Styled/FeatureServer/0"
              val parksServiceFeatureTable = ServiceFeatureTable(parksUrl)
              val trailsServiceFeatureTable = ServiceFeatureTable(trailsUrl)
              val trailHeadsServiceFeatureTable = ServiceFeatureTable(trailHeadsUrl)
              val featureLayerPark = FeatureLayer.createWithFeatureTable(parksServiceFeatureTable)
              val featureLayerTrail = FeatureLayer.createWithFeatureTable(trailsServiceFeatureTable)
              val featureLayerTrailHead = FeatureLayer.createWithFeatureTable(trailHeadsServiceFeatureTable)
              return ArcGISMap(BasemapStyle.ArcGISTopographic).apply {
              initialViewpoint = Viewpoint(
              latitude = 34.0270,
              longitude = -118.8050,
              scale = 200000.0
              )
              }
              }
            • In the apply block for ArcGISMap, create a list of these three FeatureLayers, and add them to the map’s operationalLayers using addAll().

              MainScreen.kt
              40 collapsed lines
              @file:OptIn(ExperimentalMaterial3Api::class)
              package com.example.app.screens
              import androidx.compose.foundation.layout.fillMaxSize
              import androidx.compose.foundation.layout.padding
              import androidx.compose.material3.ExperimentalMaterial3Api
              import androidx.compose.material3.Scaffold
              import androidx.compose.material3.Text
              import androidx.compose.material3.TopAppBar
              import androidx.compose.runtime.Composable
              import androidx.compose.runtime.remember
              import androidx.compose.ui.Modifier
              import androidx.compose.ui.res.stringResource
              import com.arcgismaps.data.ServiceFeatureTable
              import com.arcgismaps.mapping.ArcGISMap
              import com.arcgismaps.mapping.BasemapStyle
              import com.arcgismaps.mapping.Viewpoint
              import com.arcgismaps.mapping.layers.FeatureLayer
              import com.arcgismaps.toolkit.geoviewcompose.MapView
              import com.example.app.R
              @Composable
              fun MainScreen() {
              val map = remember {
              createMap()
              }
              Scaffold(
              topBar = { TopAppBar(title = { Text(text = stringResource(id = R.string.app_name)) }) }
              ) {
              MapView(
              modifier = Modifier.fillMaxSize().padding(it),
              arcGISMap = map
              )
              }
              }
              fun createMap(): ArcGISMap {
              val parksUrl =
              "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Parks_and_Open_Space_Styled/FeatureServer/0"
              val trailsUrl =
              "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Trails_Styled/FeatureServer/0"
              val trailHeadsUrl =
              "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Trailheads_Styled/FeatureServer/0"
              val parksServiceFeatureTable = ServiceFeatureTable(parksUrl)
              val trailsServiceFeatureTable = ServiceFeatureTable(trailsUrl)
              val trailHeadsServiceFeatureTable = ServiceFeatureTable(trailHeadsUrl)
              val featureLayerPark = FeatureLayer.createWithFeatureTable(parksServiceFeatureTable)
              val featureLayerTrail = FeatureLayer.createWithFeatureTable(trailsServiceFeatureTable)
              val featureLayerTrailHead = FeatureLayer.createWithFeatureTable(trailHeadsServiceFeatureTable)
              return ArcGISMap(BasemapStyle.ArcGISTopographic).apply {
              initialViewpoint = Viewpoint(
              latitude = 34.0270,
              longitude = -118.8050,
              scale = 200000.0
              )
              operationalLayers.addAll(
              listOf(
              featureLayerPark,
              featureLayerTrail,
              featureLayerTrailHead
              )
              )
              }
              }
              • Click Run > Run > app to run the app.

              You should see point features (representing trailheads) draw on the map for an area in the Santa Monica Mountains in southern California.

              Alternatively, you can download the tutorial solution, as follows.

              Option 2: Download the solution

              1. Click the Download solution link in the right-hand side of this page.

              2. Unzip the file to a location on your machine.

              3. Run Android Studio.

              4. Go to File > Open…. Navigate to the solution folder and click Open.

                On Windows: If you are in the Welcome to Android Studio dialog, click Open and navigate to the solution folder. Then click Open.

              Since the downloaded solution does not contain authentication credentials, you must first set up authentication to create credentials, and then add the developer credentials to the solution.

              Set up authentication

              To access the secure ArcGIS location servicesArcGIS Location Services, also referred to as Location Services, are services hosted by Esri that provide geospatial functionality for developing mapping applications. They include the ArcGIS Basemap Styles service, ArcGIS Static Basemap Tiles service, ArcGIS Static Maps service, ArcGIS Places service, ArcGIS Geocoding service, ArcGIS Routing service, ArcGIS GeoEnrichment service, and ArcGIS Elevation service. An ArcGIS Location Platform or ArcGIS Online account is required to use the services. Learn more used in this tutorial, you must implement API key authenticationAPI key authentication is a type of authentication that uses an API key to authenticate requests to ArcGIS services and secure portal items. Learn more or user authenticationUser authentication is a type of authentication that allows users with an ArcGIS account to sign into an application and allow it to access ArcGIS content, services, and resources on their behalf. The typical authorization protocol used is OAuth2.0. Learn more using an ArcGIS Location PlatformAn ArcGIS Location Platform account, formerly known as an ArcGIS Developer account, is an identity associated with an ArcGIS Location Platform subscription. Learn more or an ArcGIS OnlineAn ArcGIS Online account, also known as an ArcGIS Organization account, is an identity associated with an ArcGIS Online subscription. It can be used to access ArcGIS tools and develop applications with ArcGIS location services for an organization. Learn more account.

              To complete this tutorial, click on the tab in the switcher below for your authentication type of choice, either API key authentication or User authentication.

              Create a new API key access tokenAn access token is an authorization string that provides access to secure ArcGIS content, data, and services. Its capabilities are determined by the privileges it supports. It is obtained by implementing API key authentication, User authentication, or App authentication. Learn more with privilegesPrivileges are a set of permissions assigned to ArcGIS accounts, developer credentials, and applications that grant access to secure resources and functionality in ArcGIS. Learn more to access the secure resources used in this tutorial.

              1. Complete the Create an API key tutorial and create an API key with the following privilege(s)Privileges are a set of permissions assigned to ArcGIS accounts, developer credentials, and applications that grant access to secure resources and functionality in ArcGIS. Learn more :

                • Privileges
                  • Location services > Basemaps
              2. Copy and paste the API key access token into a safe location. It will be used in a later step.

              Set developer credentials in the solution

              To allow your app users to access ArcGIS location servicesArcGIS Location Services, also referred to as Location Services, are services hosted by Esri that provide geospatial functionality for developing mapping applications. They include the ArcGIS Basemap Styles service, ArcGIS Static Basemap Tiles service, ArcGIS Static Maps service, ArcGIS Places service, ArcGIS Geocoding service, ArcGIS Routing service, ArcGIS GeoEnrichment service, and ArcGIS Elevation service. An ArcGIS Location Platform or ArcGIS Online account is required to use the services. Learn more , use the developer credentials that you created in the Set up authentication step to authenticate requests for resources.

              1. In the Android view of Android Studio, open app > kotlin+java > com.example.app > MainActivity. Set the AuthenticationMode to .API_KEY.

                MainActivity.kt
                14 collapsed lines
                package com.example.app
                import android.os.Bundle
                import androidx.activity.ComponentActivity
                import androidx.activity.compose.setContent
                import androidx.activity.enableEdgeToEdge
                import com.arcgismaps.ApiKey
                import com.arcgismaps.ArcGISEnvironment
                import com.arcgismaps.httpcore.authentication.OAuthUserConfiguration
                import com.arcgismaps.toolkit.authentication.AuthenticatorState
                import com.arcgismaps.toolkit.authentication.DialogAuthenticator
                import com.example.app.screens.MainScreen
                import com.example.app.ui.theme.TutorialTheme
                class MainActivity : ComponentActivity() {
                private enum class AuthenticationMode { API_KEY, USER_AUTH }
                private val authenticationMode = AuthenticationMode.API_KEY
                42 collapsed lines
                private val authenticatorState = AuthenticatorState()
                override fun onCreate(savedInstanceState: Bundle?) {
                super.onCreate(savedInstanceState)
                when (authenticationMode) {
                AuthenticationMode.API_KEY -> {
                ArcGISEnvironment.apiKey = ApiKey.create("YOUR_ACCESS_TOKEN")
                }
                AuthenticationMode.USER_AUTH -> {
                authenticatorState.oAuthUserConfigurations = listOf(
                OAuthUserConfiguration(
                portalUrl = "https://www.arcgis.com",
                clientId = "YOUR_CLIENT_ID",
                redirectUrl = "YOUR_REDIRECT_URL"
                )
                )
                }
                }
                enableEdgeToEdge()
                setContent {
                TutorialTheme {
                MainScreen()
                if (authenticationMode == AuthenticationMode.USER_AUTH) {
                DialogAuthenticator(authenticatorState)
                }
                }
                }
                }
                }
                • Set the apiKey property with your API key access token.

                  MainActivity.kt
                  22 collapsed lines
                  package com.example.app
                  import android.os.Bundle
                  import androidx.activity.ComponentActivity
                  import androidx.activity.compose.setContent
                  import androidx.activity.enableEdgeToEdge
                  import com.arcgismaps.ApiKey
                  import com.arcgismaps.ArcGISEnvironment
                  import com.arcgismaps.httpcore.authentication.OAuthUserConfiguration
                  import com.arcgismaps.toolkit.authentication.AuthenticatorState
                  import com.arcgismaps.toolkit.authentication.DialogAuthenticator
                  import com.example.app.screens.MainScreen
                  import com.example.app.ui.theme.TutorialTheme
                  class MainActivity : ComponentActivity() {
                  private enum class AuthenticationMode { API_KEY, USER_AUTH }
                  private val authenticationMode = AuthenticationMode.API_KEY
                  private val authenticatorState = AuthenticatorState()
                  override fun onCreate(savedInstanceState: Bundle?) {
                  super.onCreate(savedInstanceState)
                  when (authenticationMode) {
                  AuthenticationMode.API_KEY -> {
                  ArcGISEnvironment.apiKey = ApiKey.create("YOUR_ACCESS_TOKEN")
                  }
                  30 collapsed lines
                  AuthenticationMode.USER_AUTH -> {
                  authenticatorState.oAuthUserConfigurations = listOf(
                  OAuthUserConfiguration(
                  portalUrl = "https://www.arcgis.com",
                  clientId = "YOUR_CLIENT_ID",
                  redirectUrl = "YOUR_REDIRECT_URL"
                  )
                  )
                  }
                  }
                  enableEdgeToEdge()
                  setContent {
                  TutorialTheme {
                  MainScreen()
                  if (authenticationMode == AuthenticationMode.USER_AUTH) {
                  DialogAuthenticator(authenticatorState)
                  }
                  }
                  }
                  }
                  }

                  Best Practice: The access token is stored directly in the code as a convenience for this tutorial. Do not store credentials directly in source code in a production environment.

                  Run the app

                  Click Run > Run > app to run the app.

                  You should see point features (representing trailheads) draw on the map for an area in the Santa Monica Mountains in southern California.

                  What’s next?

                  Learn how to use additional API features, ArcGIS location services, and ArcGIS tools in these tutorials: