Style a feature layer | ArcGIS Maps SDK for Kotlin

Learn how to apply renderers A renderer is a collection of rules and symbols used to display the data in a layer. Learn more and label definitions to a feature layer A feature layer (client-side) is a data layer that can access and display features from a feature service that has the same type of geometry and attribute fields. Learn more based on attribute values.

style a feature layer

Applications can display feature layer data with different styles to enhance the visualization. The type of Renderer you choose depends on your application. A SimpleRenderer applies the same symbol to all features, a UniqueValueRenderer applies a different symbol to each unique attribute value, and a ClassBreaksRenderer applies a symbol to a range of numeric values. Renderers are responsible for accessing the data and applying the appropriate symbol to each feature when the layer draws. You can also use a LabelDefinition to show attribute information for features. Visit the Styles and data visualization documentation to learn more about styling layers.

You can also author, style and save web maps, web scenes, and layers as portal items and then add them to the map in your application. Visit the following tutorials to learn more about adding portal items.

In this tutorial, you will apply different renderers A renderer is a collection of rules and symbols used to display the data in a layer. Learn more to enhance the visualization of three feature layers with data for the Santa Monica Mountains: Trailheads with a single symbol, Trails based on elevation change and bike use, and Parks and Open Spaces based on the type of park.

Prerequisites

Before starting this tutorial, you need the following:

An ArcGIS Location Platform or ArcGIS Online account.
A development and deployment environment that meets the system requirements.
An IDE for Android development in Kotlin.

Develop or download

You have two options for completing this tutorial:

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

Option 1: Develop the code

Open an Android Studio project

Open the project you created by completing the Display a map tutorial.
Continue with the following instructions to apply renderers and label definitions to a feature layer based on attribute values.

Modify the old project for use in this new tutorial.

On your file system, delete the .idea folder, if present, at the top level of your project.
In the Android view, open app > res > values > strings.xml.

In the <string name="app_name"> element, change the text content to Style a feature layer.
strings.xml
<resources> <string name="app_name">Style a feature layer</string> </resources>

In the Android view, open Gradle Scripts > settings.gradle.kts.

Change the value of rootProject.name to “Style a feature layer”.

settings.gradle.kts

14 collapsed lines
pluginManagement {
    repositories {
        google {
            content {
                includeGroupByRegex("com\\.android.*")
                includeGroupByRegex("com\\.google.*")
                includeGroupByRegex("androidx.*")
            }
        }
        mavenCentral()
        gradlePluginPortal()
    }
}

dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        google()
        mavenCentral()
        maven { url = uri("https://esri.jfrog.io/artifactory/arcgis") }
    }
}

rootProject.name = "Style a feature layer"
include(":app")

Click File > Sync Project with Gradle files. Android Studio will recognize your changes and create a new .idea folder.

Add import statements

In the Android view, open app > kotlin+java > com.example.app > 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.Color
import com.arcgismaps.data.ServiceFeatureTable
import com.arcgismaps.mapping.ArcGISMap
import com.arcgismaps.mapping.BasemapStyle
import com.arcgismaps.mapping.Viewpoint
import com.arcgismaps.mapping.labeling.ArcadeLabelExpression
import com.arcgismaps.mapping.labeling.LabelDefinition
import com.arcgismaps.mapping.layers.FeatureLayer
import com.arcgismaps.mapping.symbology.ClassBreak
import com.arcgismaps.mapping.symbology.ClassBreaksRenderer
import com.arcgismaps.mapping.symbology.FontStyle
import com.arcgismaps.mapping.symbology.FontWeight
import com.arcgismaps.mapping.symbology.PictureMarkerSymbol
import com.arcgismaps.mapping.symbology.SimpleFillSymbol
import com.arcgismaps.mapping.symbology.SimpleFillSymbolStyle
import com.arcgismaps.mapping.symbology.SimpleLineSymbol
import com.arcgismaps.mapping.symbology.SimpleLineSymbolStyle
import com.arcgismaps.mapping.symbology.SimpleRenderer
import com.arcgismaps.mapping.symbology.TextSymbol
import com.arcgismaps.mapping.symbology.UniqueValue
import com.arcgismaps.mapping.symbology.UniqueValueRenderer
import com.arcgismaps.toolkit.geoviewcompose.MapView
import com.example.app.R

Create a function to add a feature layer

You can add a feature layer A feature layer (client-side) is a data layer that can access and display features from a feature service that has the same type of geometry and attribute fields. Learn more from a feature service A 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 ArcGIS ArcGIS is the brand name for all of the desktop, server, and developer products and technologies offered by Esri. Learn more . Each feature layer contains features A 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 geometry A 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 ( point A point is a type of geometry containing a single set of x,y coordinates and a spatial reference. Learn more , line A polyline is a type of geometry containing ordered point coordinates and a spatial reference. Learn more , or polygon A 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 attributes Attributes 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 . Once added to the map, feature layers can be symbolized, styled, and labeled in a variety of ways.

Define variables that store feature service URLs used by the app’s layers, and then create a helper function to add a layer to the map’s list of operational layers An operational layer is a layer used by a map or a scene to visualize geographic data. Operational layers are displayed on top of a basemap layer. Learn more . You will use this code throughout the tutorial as you add and symbolize various layers.

In createMap() add four read-only String variables: three for accessing feature layers, and a fourth for accessing a static image for use in a picture marker symbol. You will use these resources in future steps.

MainScreen.kt


53 collapsed lines
1
@file:OptIn(ExperimentalMaterial3Api::class)
2

3
package com.example.app.screens
4

5
import androidx.compose.foundation.layout.fillMaxSize
6
import androidx.compose.foundation.layout.padding
7
import androidx.compose.material3.ExperimentalMaterial3Api
8
import androidx.compose.material3.Scaffold
9
import androidx.compose.material3.Text
10
import androidx.compose.material3.TopAppBar
11
import androidx.compose.runtime.Composable
12
import androidx.compose.runtime.remember
13
import androidx.compose.ui.Modifier
14
import androidx.compose.ui.res.stringResource
15
import com.arcgismaps.Color
16
import com.arcgismaps.data.ServiceFeatureTable
17
import com.arcgismaps.mapping.ArcGISMap
18
import com.arcgismaps.mapping.BasemapStyle
19
import com.arcgismaps.mapping.Viewpoint
20
import com.arcgismaps.mapping.labeling.ArcadeLabelExpression
21
import com.arcgismaps.mapping.labeling.LabelDefinition
22
import com.arcgismaps.mapping.layers.FeatureLayer
23
import com.arcgismaps.mapping.symbology.ClassBreak
24
import com.arcgismaps.mapping.symbology.ClassBreaksRenderer
25
import com.arcgismaps.mapping.symbology.FontStyle
26
import com.arcgismaps.mapping.symbology.FontWeight
27
import com.arcgismaps.mapping.symbology.PictureMarkerSymbol
28
import com.arcgismaps.mapping.symbology.SimpleFillSymbol
29
import com.arcgismaps.mapping.symbology.SimpleFillSymbolStyle
30
import com.arcgismaps.mapping.symbology.SimpleLineSymbol
31
import com.arcgismaps.mapping.symbology.SimpleLineSymbolStyle
32
import com.arcgismaps.mapping.symbology.SimpleRenderer
33
import com.arcgismaps.mapping.symbology.TextSymbol
34
import com.arcgismaps.mapping.symbology.UniqueValue
35
import com.arcgismaps.mapping.symbology.UniqueValueRenderer
36
import com.arcgismaps.toolkit.geoviewcompose.MapView
37
import com.example.app.R
38

39
@Composable
40
fun MainScreen() {
41
    val map = remember {
42
        createMap()
43
    }
44
    Scaffold(
45
        topBar = { TopAppBar(title = { Text(text = stringResource(id = R.string.app_name)) }) }
46
    ) {
47
        MapView(
48
            modifier = Modifier.fillMaxSize().padding(it),
49
            arcGISMap = map
50
        )
51
    }
52
}
53

54
fun createMap(): ArcGISMap {
55

56
    val parksAndOpenSpaces =
57
        "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Parks_and_Open_Space/FeatureServer/0"
58
    val trails =
59
        "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Trails/FeatureServer/0"
60
    val trailheads =
61
        "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Trailheads/FeatureServer/0"
62
    val trailheadImage =
63
        "https://static.arcgis.com/images/Symbols/NPS/npsPictograph_0231b.png"
64

65
    return ArcGISMap(BasemapStyle.ArcGISTopographic).apply {
66
        initialViewpoint = Viewpoint(
67
            latitude = 34.0270,
68
            longitude = -118.8050,
69
            scale = 72000.0
70
        )
71

72
    }
73
}
7 collapsed lines
74

75
fun createFeatureLayer(featureServiceUri: String): FeatureLayer {
76
    // Create a service feature table from a Uri
77
    val serviceFeatureTable = ServiceFeatureTable(featureServiceUri)
78
    // Return a feature layer created from the service feature table
79
    return FeatureLayer.createWithFeatureTable(serviceFeatureTable)
80
}

In the apply block for ArcGISMap, insert code that adds FeatureLayers to the map’s operationalLayers. For now, the listOf() function has no parameters. In this tutorial, you will be adding each new feature layer to the list of parameters.

MainScreen.kt


53 collapsed lines
1
@file:OptIn(ExperimentalMaterial3Api::class)
2

3
package com.example.app.screens
4

5
import androidx.compose.foundation.layout.fillMaxSize
6
import androidx.compose.foundation.layout.padding
7
import androidx.compose.material3.ExperimentalMaterial3Api
8
import androidx.compose.material3.Scaffold
9
import androidx.compose.material3.Text
10
import androidx.compose.material3.TopAppBar
11
import androidx.compose.runtime.Composable
12
import androidx.compose.runtime.remember
13
import androidx.compose.ui.Modifier
14
import androidx.compose.ui.res.stringResource
15
import com.arcgismaps.Color
16
import com.arcgismaps.data.ServiceFeatureTable
17
import com.arcgismaps.mapping.ArcGISMap
18
import com.arcgismaps.mapping.BasemapStyle
19
import com.arcgismaps.mapping.Viewpoint
20
import com.arcgismaps.mapping.labeling.ArcadeLabelExpression
21
import com.arcgismaps.mapping.labeling.LabelDefinition
22
import com.arcgismaps.mapping.layers.FeatureLayer
23
import com.arcgismaps.mapping.symbology.ClassBreak
24
import com.arcgismaps.mapping.symbology.ClassBreaksRenderer
25
import com.arcgismaps.mapping.symbology.FontStyle
26
import com.arcgismaps.mapping.symbology.FontWeight
27
import com.arcgismaps.mapping.symbology.PictureMarkerSymbol
28
import com.arcgismaps.mapping.symbology.SimpleFillSymbol
29
import com.arcgismaps.mapping.symbology.SimpleFillSymbolStyle
30
import com.arcgismaps.mapping.symbology.SimpleLineSymbol
31
import com.arcgismaps.mapping.symbology.SimpleLineSymbolStyle
32
import com.arcgismaps.mapping.symbology.SimpleRenderer
33
import com.arcgismaps.mapping.symbology.TextSymbol
34
import com.arcgismaps.mapping.symbology.UniqueValue
35
import com.arcgismaps.mapping.symbology.UniqueValueRenderer
36
import com.arcgismaps.toolkit.geoviewcompose.MapView
37
import com.example.app.R
38

39
@Composable
40
fun MainScreen() {
41
    val map = remember {
42
        createMap()
43
    }
44
    Scaffold(
45
        topBar = { TopAppBar(title = { Text(text = stringResource(id = R.string.app_name)) }) }
46
    ) {
47
        MapView(
48
            modifier = Modifier.fillMaxSize().padding(it),
49
            arcGISMap = map
50
        )
51
    }
52
}
53

54
fun createMap(): ArcGISMap {
55

56
    val parksAndOpenSpaces =
57
        "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Parks_and_Open_Space/FeatureServer/0"
58
    val trails =
59
        "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Trails/FeatureServer/0"
60
    val trailheads =
61
        "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Trailheads/FeatureServer/0"
62
    val trailheadImage =
63
        "https://static.arcgis.com/images/Symbols/NPS/npsPictograph_0231b.png"
64

65
    return ArcGISMap(BasemapStyle.ArcGISTopographic).apply {
66
        initialViewpoint = Viewpoint(
67
            latitude = 34.0270,
68
            longitude = -118.8050,
69
            scale = 72000.0
70
        )
71

72
        operationalLayers.addAll(
73

74
            listOf(
75

76
            )
77

78
        )
79

80
    }
81
}
7 collapsed lines
82

83
fun createFeatureLayer(featureServiceUri: String): FeatureLayer {
84
    // Create a service feature table from a Uri
85
    val serviceFeatureTable = ServiceFeatureTable(featureServiceUri)
86
    // Return a feature layer created from the service feature table
87
    return FeatureLayer.createWithFeatureTable(serviceFeatureTable)
88
}

Add a top-level helper function named createFeatureLayer() that takes a feature service URI as an argument and returns a FeatureLayer created from the URI.

MainScreen.kt


82 collapsed lines
1
@file:OptIn(ExperimentalMaterial3Api::class)
2

3
package com.example.app.screens
4

5
import androidx.compose.foundation.layout.fillMaxSize
6
import androidx.compose.foundation.layout.padding
7
import androidx.compose.material3.ExperimentalMaterial3Api
8
import androidx.compose.material3.Scaffold
9
import androidx.compose.material3.Text
10
import androidx.compose.material3.TopAppBar
11
import androidx.compose.runtime.Composable
12
import androidx.compose.runtime.remember
13
import androidx.compose.ui.Modifier
14
import androidx.compose.ui.res.stringResource
15
import com.arcgismaps.Color
16
import com.arcgismaps.data.ServiceFeatureTable
17
import com.arcgismaps.mapping.ArcGISMap
18
import com.arcgismaps.mapping.BasemapStyle
19
import com.arcgismaps.mapping.Viewpoint
20
import com.arcgismaps.mapping.labeling.ArcadeLabelExpression
21
import com.arcgismaps.mapping.labeling.LabelDefinition
22
import com.arcgismaps.mapping.layers.FeatureLayer
23
import com.arcgismaps.mapping.symbology.ClassBreak
24
import com.arcgismaps.mapping.symbology.ClassBreaksRenderer
25
import com.arcgismaps.mapping.symbology.FontStyle
26
import com.arcgismaps.mapping.symbology.FontWeight
27
import com.arcgismaps.mapping.symbology.PictureMarkerSymbol
28
import com.arcgismaps.mapping.symbology.SimpleFillSymbol
29
import com.arcgismaps.mapping.symbology.SimpleFillSymbolStyle
30
import com.arcgismaps.mapping.symbology.SimpleLineSymbol
31
import com.arcgismaps.mapping.symbology.SimpleLineSymbolStyle
32
import com.arcgismaps.mapping.symbology.SimpleRenderer
33
import com.arcgismaps.mapping.symbology.TextSymbol
34
import com.arcgismaps.mapping.symbology.UniqueValue
35
import com.arcgismaps.mapping.symbology.UniqueValueRenderer
36
import com.arcgismaps.toolkit.geoviewcompose.MapView
37
import com.example.app.R
38

39
@Composable
40
fun MainScreen() {
41
    val map = remember {
42
        createMap()
43
    }
44
    Scaffold(
45
        topBar = { TopAppBar(title = { Text(text = stringResource(id = R.string.app_name)) }) }
46
    ) {
47
        MapView(
48
            modifier = Modifier.fillMaxSize().padding(it),
49
            arcGISMap = map
50
        )
51
    }
52
}
53

54
fun createMap(): ArcGISMap {
55

56
    val parksAndOpenSpaces =
57
        "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Parks_and_Open_Space/FeatureServer/0"
58
    val trails =
59
        "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Trails/FeatureServer/0"
60
    val trailheads =
61
        "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Trailheads/FeatureServer/0"
62
    val trailheadImage =
63
        "https://static.arcgis.com/images/Symbols/NPS/npsPictograph_0231b.png"
64

65
    return ArcGISMap(BasemapStyle.ArcGISTopographic).apply {
66
        initialViewpoint = Viewpoint(
67
            latitude = 34.0270,
68
            longitude = -118.8050,
69
            scale = 72000.0
70
        )
71

72
        operationalLayers.addAll(
73

74
            listOf(
75

76
            )
77

78
        )
79

80
    }
81
}
82

83
fun createFeatureLayer(featureServiceUri: String): FeatureLayer {
84
    // Create a service feature table from a Uri
85
    val serviceFeatureTable = ServiceFeatureTable(featureServiceUri)
86
    // Return a feature layer created from the service feature table
87
    return FeatureLayer.createWithFeatureTable(serviceFeatureTable)
88
}

Add a layer with a unique value renderer

Create a method to apply a different symbol for each type of park area to the Parks and Open Spaces feature layer.

Add a top-level function named createOpenSpaceLayer().

UniqueValue assigns a symbol to a value or values. A unique value renderer uses a collection of unique values to assign the appropriate symbol for each feature it renderers.

For this example, the renderer uses a feature’s TYPE attribute value to apply the correct symbol.

MainScreen.kt


89 collapsed lines
1
@file:OptIn(ExperimentalMaterial3Api::class)
2

3
package com.example.app.screens
4

5
import androidx.compose.foundation.layout.fillMaxSize
6
import androidx.compose.foundation.layout.padding
7
import androidx.compose.material3.ExperimentalMaterial3Api
8
import androidx.compose.material3.Scaffold
9
import androidx.compose.material3.Text
10
import androidx.compose.material3.TopAppBar
11
import androidx.compose.runtime.Composable
12
import androidx.compose.runtime.remember
13
import androidx.compose.ui.Modifier
14
import androidx.compose.ui.res.stringResource
15
import com.arcgismaps.Color
16
import com.arcgismaps.data.ServiceFeatureTable
17
import com.arcgismaps.mapping.ArcGISMap
18
import com.arcgismaps.mapping.BasemapStyle
19
import com.arcgismaps.mapping.Viewpoint
20
import com.arcgismaps.mapping.labeling.ArcadeLabelExpression
21
import com.arcgismaps.mapping.labeling.LabelDefinition
22
import com.arcgismaps.mapping.layers.FeatureLayer
23
import com.arcgismaps.mapping.symbology.ClassBreak
24
import com.arcgismaps.mapping.symbology.ClassBreaksRenderer
25
import com.arcgismaps.mapping.symbology.FontStyle
26
import com.arcgismaps.mapping.symbology.FontWeight
27
import com.arcgismaps.mapping.symbology.PictureMarkerSymbol
28
import com.arcgismaps.mapping.symbology.SimpleFillSymbol
29
import com.arcgismaps.mapping.symbology.SimpleFillSymbolStyle
30
import com.arcgismaps.mapping.symbology.SimpleLineSymbol
31
import com.arcgismaps.mapping.symbology.SimpleLineSymbolStyle
32
import com.arcgismaps.mapping.symbology.SimpleRenderer
33
import com.arcgismaps.mapping.symbology.TextSymbol
34
import com.arcgismaps.mapping.symbology.UniqueValue
35
import com.arcgismaps.mapping.symbology.UniqueValueRenderer
36
import com.arcgismaps.toolkit.geoviewcompose.MapView
37
import com.example.app.R
38

39
@Composable
40
fun MainScreen() {
41
    val map = remember {
42
        createMap()
43
    }
44
    Scaffold(
45
        topBar = { TopAppBar(title = { Text(text = stringResource(id = R.string.app_name)) }) }
46
    ) {
47
        MapView(
48
            modifier = Modifier.fillMaxSize().padding(it),
49
            arcGISMap = map
50
        )
51
    }
52
}
53

54
fun createMap(): ArcGISMap {
55

56
    val parksAndOpenSpaces =
57
        "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Parks_and_Open_Space/FeatureServer/0"
58
    val trails =
59
        "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Trails/FeatureServer/0"
60
    val trailheads =
61
        "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Trailheads/FeatureServer/0"
62
    val trailheadImage =
63
        "https://static.arcgis.com/images/Symbols/NPS/npsPictograph_0231b.png"
64

65
    return ArcGISMap(BasemapStyle.ArcGISTopographic).apply {
66
        initialViewpoint = Viewpoint(
67
            latitude = 34.0270,
68
            longitude = -118.8050,
69
            scale = 72000.0
70
        )
71

72
        operationalLayers.addAll(
73

74
            listOf(
75

76
            )
77

78
        )
79

80
    }
81
}
82

83
fun createFeatureLayer(featureServiceUri: String): FeatureLayer {
84
    // Create a service feature table from a Uri
85
    val serviceFeatureTable = ServiceFeatureTable(featureServiceUri)
86
    // Return a feature layer created from the service feature table
87
    return FeatureLayer.createWithFeatureTable(serviceFeatureTable)
88
}
89

90
fun createOpenSpaceLayer(featureServiceUri: String): FeatureLayer {
91
    // Create fill symbol objects to represent the parks and open spaces layer
92
    val magentaFillSymbol = SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.fromRgba(255, 0, 255), null)
93
    val greenFillSymbol = SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.green, null)
94
    val blueFillSymbol = SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.fromRgba(0, 0, 255), null)
95
    val redFillSymbol = SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.red, null)
96

97
    // Create a unique value for natural areas, regional open spaces, local parks, and regional recreation parks
98
    val naturalAreas = UniqueValue(
99
        description = "Natural Areas",
100
        label = "Natural Areas",
101
        symbol = magentaFillSymbol,
102
        values = listOf("Natural Areas")
103
    )
104
    val regionalOpenSpace = UniqueValue(
105
        description = "Regional Open Space",
106
        label = "Regional Open Space",
107
        symbol = greenFillSymbol,
108
        values = listOf("Regional Open Space")
109
    )
110
    val localPark = UniqueValue(
111
        description = "Local Park",
112
        label = "Local Park",
113
        symbol = blueFillSymbol,
114
        values = listOf("Local Park")
115
    )
116
    val regionalRecreationPark = UniqueValue(
117
        description = "Regional Recreation Park",
118
        label = "Regional Recreation Park",
119
        symbol = redFillSymbol,
120
        values = listOf("Regional Recreation Park")
121
    )
122
    // Create a unique value list with the fill symbols
123
    val uniqueValuesList = listOf(
124
        naturalAreas,
125
        regionalOpenSpace,
126
        localPark,
127
        regionalRecreationPark
128
    )
129

130
    // Create and assign a unique value renderer to the feature layer
131
    val openSpacesUniqueValueRenderer =
132
        UniqueValueRenderer(
133
            fieldNames = listOf("TYPE"),
134
            uniqueValues = uniqueValuesList,
135
            defaultLabel = "Open Spaces",
136
            defaultSymbol = null
137
        )
138

139
    // Create a parks and open spaces feature layer
140
    val featureLayer = createFeatureLayer(featureServiceUri).apply {
141
        // Style the feature layer using the unique value renderer
142
        renderer = openSpacesUniqueValueRenderer
143
        // Set the layer opacity to semi-transparent
144
        opacity = 0.2f
145
    }
146

147
    return featureLayer
148
}

In createMap(), add the Parks and Open Space feature layer to the map’s operational layers by calling createOpenSpaceLayer().

MainScreen.kt


53 collapsed lines
1
@file:OptIn(ExperimentalMaterial3Api::class)
2

3
package com.example.app.screens
4

5
import androidx.compose.foundation.layout.fillMaxSize
6
import androidx.compose.foundation.layout.padding
7
import androidx.compose.material3.ExperimentalMaterial3Api
8
import androidx.compose.material3.Scaffold
9
import androidx.compose.material3.Text
10
import androidx.compose.material3.TopAppBar
11
import androidx.compose.runtime.Composable
12
import androidx.compose.runtime.remember
13
import androidx.compose.ui.Modifier
14
import androidx.compose.ui.res.stringResource
15
import com.arcgismaps.Color
16
import com.arcgismaps.data.ServiceFeatureTable
17
import com.arcgismaps.mapping.ArcGISMap
18
import com.arcgismaps.mapping.BasemapStyle
19
import com.arcgismaps.mapping.Viewpoint
20
import com.arcgismaps.mapping.labeling.ArcadeLabelExpression
21
import com.arcgismaps.mapping.labeling.LabelDefinition
22
import com.arcgismaps.mapping.layers.FeatureLayer
23
import com.arcgismaps.mapping.symbology.ClassBreak
24
import com.arcgismaps.mapping.symbology.ClassBreaksRenderer
25
import com.arcgismaps.mapping.symbology.FontStyle
26
import com.arcgismaps.mapping.symbology.FontWeight
27
import com.arcgismaps.mapping.symbology.PictureMarkerSymbol
28
import com.arcgismaps.mapping.symbology.SimpleFillSymbol
29
import com.arcgismaps.mapping.symbology.SimpleFillSymbolStyle
30
import com.arcgismaps.mapping.symbology.SimpleLineSymbol
31
import com.arcgismaps.mapping.symbology.SimpleLineSymbolStyle
32
import com.arcgismaps.mapping.symbology.SimpleRenderer
33
import com.arcgismaps.mapping.symbology.TextSymbol
34
import com.arcgismaps.mapping.symbology.UniqueValue
35
import com.arcgismaps.mapping.symbology.UniqueValueRenderer
36
import com.arcgismaps.toolkit.geoviewcompose.MapView
37
import com.example.app.R
38

39
@Composable
40
fun MainScreen() {
41
    val map = remember {
42
        createMap()
43
    }
44
    Scaffold(
45
        topBar = { TopAppBar(title = { Text(text = stringResource(id = R.string.app_name)) }) }
46
    ) {
47
        MapView(
48
            modifier = Modifier.fillMaxSize().padding(it),
49
            arcGISMap = map
50
        )
51
    }
52
}
53

54
fun createMap(): ArcGISMap {
55

56
    val parksAndOpenSpaces =
57
        "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Parks_and_Open_Space/FeatureServer/0"
58
    val trails =
59
        "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Trails/FeatureServer/0"
60
    val trailheads =
61
        "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Trailheads/FeatureServer/0"
62
    val trailheadImage =
63
        "https://static.arcgis.com/images/Symbols/NPS/npsPictograph_0231b.png"
64

65
    return ArcGISMap(BasemapStyle.ArcGISTopographic).apply {
66
        initialViewpoint = Viewpoint(
67
            latitude = 34.0270,
68
            longitude = -118.8050,
69
            scale = 72000.0
70
        )
71

72
        operationalLayers.addAll(
73

74
            listOf(
75

76
                createOpenSpaceLayer(parksAndOpenSpaces),
77

78
            )
79

80
        )
81

82
    }
83
}
67 collapsed lines
84

85
fun createFeatureLayer(featureServiceUri: String): FeatureLayer {
86
    // Create a service feature table from a Uri
87
    val serviceFeatureTable = ServiceFeatureTable(featureServiceUri)
88
    // Return a feature layer created from the service feature table
89
    return FeatureLayer.createWithFeatureTable(serviceFeatureTable)
90
}
91

92
fun createOpenSpaceLayer(featureServiceUri: String): FeatureLayer {
93
    // Create fill symbol objects to represent the parks and open spaces layer
94
    val magentaFillSymbol = SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.fromRgba(255, 0, 255), null)
95
    val greenFillSymbol = SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.green, null)
96
    val blueFillSymbol = SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.fromRgba(0, 0, 255), null)
97
    val redFillSymbol = SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.red, null)
98

99
    // Create a unique value for natural areas, regional open spaces, local parks, and regional recreation parks
100
    val naturalAreas = UniqueValue(
101
        description = "Natural Areas",
102
        label = "Natural Areas",
103
        symbol = magentaFillSymbol,
104
        values = listOf("Natural Areas")
105
    )
106
    val regionalOpenSpace = UniqueValue(
107
        description = "Regional Open Space",
108
        label = "Regional Open Space",
109
        symbol = greenFillSymbol,
110
        values = listOf("Regional Open Space")
111
    )
112
    val localPark = UniqueValue(
113
        description = "Local Park",
114
        label = "Local Park",
115
        symbol = blueFillSymbol,
116
        values = listOf("Local Park")
117
    )
118
    val regionalRecreationPark = UniqueValue(
119
        description = "Regional Recreation Park",
120
        label = "Regional Recreation Park",
121
        symbol = redFillSymbol,
122
        values = listOf("Regional Recreation Park")
123
    )
124
    // Create a unique value list with the fill symbols
125
    val uniqueValuesList = listOf(
126
        naturalAreas,
127
        regionalOpenSpace,
128
        localPark,
129
        regionalRecreationPark
130
    )
131

132
    // Create and assign a unique value renderer to the feature layer
133
    val openSpacesUniqueValueRenderer =
134
        UniqueValueRenderer(
135
            fieldNames = listOf("TYPE"),
136
            uniqueValues = uniqueValuesList,
137
            defaultLabel = "Open Spaces",
138
            defaultSymbol = null
139
        )
140

141
    // Create a parks and open spaces feature layer
142
    val featureLayer = createFeatureLayer(featureServiceUri).apply {
143
        // Style the feature layer using the unique value renderer
144
        renderer = openSpacesUniqueValueRenderer
145
        // Set the layer opacity to semi-transparent
146
        opacity = 0.2f
147
    }
148

149
    return featureLayer
150
}

Click Run > Run > app to run the app.

When the app opens, Parks and Open Spaces feature layer is added to the map. The map displays the different types of parks and open spaces with four unique symbols.

Add a layer with a class breaks renderer

Create a method to apply a different symbol for each of the five ranges of elevation gain to the Trails feature layer.

Add a top-level function named createTrailsLayer().

A ClassBreak assigns a symbol to a range of values.

For this example, the renderer uses each feature’s ELEV_GAIN attribute value to classify it into a defined range (class break) and apply the corresponding symbol.

MainScreen.kt


151 collapsed lines
1
@file:OptIn(ExperimentalMaterial3Api::class)
2

3
package com.example.app.screens
4

5
import androidx.compose.foundation.layout.fillMaxSize
6
import androidx.compose.foundation.layout.padding
7
import androidx.compose.material3.ExperimentalMaterial3Api
8
import androidx.compose.material3.Scaffold
9
import androidx.compose.material3.Text
10
import androidx.compose.material3.TopAppBar
11
import androidx.compose.runtime.Composable
12
import androidx.compose.runtime.remember
13
import androidx.compose.ui.Modifier
14
import androidx.compose.ui.res.stringResource
15
import com.arcgismaps.Color
16
import com.arcgismaps.data.ServiceFeatureTable
17
import com.arcgismaps.mapping.ArcGISMap
18
import com.arcgismaps.mapping.BasemapStyle
19
import com.arcgismaps.mapping.Viewpoint
20
import com.arcgismaps.mapping.labeling.ArcadeLabelExpression
21
import com.arcgismaps.mapping.labeling.LabelDefinition
22
import com.arcgismaps.mapping.layers.FeatureLayer
23
import com.arcgismaps.mapping.symbology.ClassBreak
24
import com.arcgismaps.mapping.symbology.ClassBreaksRenderer
25
import com.arcgismaps.mapping.symbology.FontStyle
26
import com.arcgismaps.mapping.symbology.FontWeight
27
import com.arcgismaps.mapping.symbology.PictureMarkerSymbol
28
import com.arcgismaps.mapping.symbology.SimpleFillSymbol
29
import com.arcgismaps.mapping.symbology.SimpleFillSymbolStyle
30
import com.arcgismaps.mapping.symbology.SimpleLineSymbol
31
import com.arcgismaps.mapping.symbology.SimpleLineSymbolStyle
32
import com.arcgismaps.mapping.symbology.SimpleRenderer
33
import com.arcgismaps.mapping.symbology.TextSymbol
34
import com.arcgismaps.mapping.symbology.UniqueValue
35
import com.arcgismaps.mapping.symbology.UniqueValueRenderer
36
import com.arcgismaps.toolkit.geoviewcompose.MapView
37
import com.example.app.R
38

39
@Composable
40
fun MainScreen() {
41
    val map = remember {
42
        createMap()
43
    }
44
    Scaffold(
45
        topBar = { TopAppBar(title = { Text(text = stringResource(id = R.string.app_name)) }) }
46
    ) {
47
        MapView(
48
            modifier = Modifier.fillMaxSize().padding(it),
49
            arcGISMap = map
50
        )
51
    }
52
}
53

54
fun createMap(): ArcGISMap {
55

56
    val parksAndOpenSpaces =
57
        "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Parks_and_Open_Space/FeatureServer/0"
58
    val trails =
59
        "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Trails/FeatureServer/0"
60
    val trailheads =
61
        "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Trailheads/FeatureServer/0"
62
    val trailheadImage =
63
        "https://static.arcgis.com/images/Symbols/NPS/npsPictograph_0231b.png"
64

65
    return ArcGISMap(BasemapStyle.ArcGISTopographic).apply {
66
        initialViewpoint = Viewpoint(
67
            latitude = 34.0270,
68
            longitude = -118.8050,
69
            scale = 72000.0
70
        )
71

72
        operationalLayers.addAll(
73

74
            listOf(
75

76
                createOpenSpaceLayer(parksAndOpenSpaces),
77

78
            )
79

80
        )
81

82
    }
83
}
84

85
fun createFeatureLayer(featureServiceUri: String): FeatureLayer {
86
    // Create a service feature table from a Uri
87
    val serviceFeatureTable = ServiceFeatureTable(featureServiceUri)
88
    // Return a feature layer created from the service feature table
89
    return FeatureLayer.createWithFeatureTable(serviceFeatureTable)
90
}
91

92
fun createOpenSpaceLayer(featureServiceUri: String): FeatureLayer {
93
    // Create fill symbol objects to represent the parks and open spaces layer
94
    val magentaFillSymbol = SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.fromRgba(255, 0, 255), null)
95
    val greenFillSymbol = SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.green, null)
96
    val blueFillSymbol = SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.fromRgba(0, 0, 255), null)
97
    val redFillSymbol = SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.red, null)
98

99
    // Create a unique value for natural areas, regional open spaces, local parks, and regional recreation parks
100
    val naturalAreas = UniqueValue(
101
        description = "Natural Areas",
102
        label = "Natural Areas",
103
        symbol = magentaFillSymbol,
104
        values = listOf("Natural Areas")
105
    )
106
    val regionalOpenSpace = UniqueValue(
107
        description = "Regional Open Space",
108
        label = "Regional Open Space",
109
        symbol = greenFillSymbol,
110
        values = listOf("Regional Open Space")
111
    )
112
    val localPark = UniqueValue(
113
        description = "Local Park",
114
        label = "Local Park",
115
        symbol = blueFillSymbol,
116
        values = listOf("Local Park")
117
    )
118
    val regionalRecreationPark = UniqueValue(
119
        description = "Regional Recreation Park",
120
        label = "Regional Recreation Park",
121
        symbol = redFillSymbol,
122
        values = listOf("Regional Recreation Park")
123
    )
124
    // Create a unique value list with the fill symbols
125
    val uniqueValuesList = listOf(
126
        naturalAreas,
127
        regionalOpenSpace,
128
        localPark,
129
        regionalRecreationPark
130
    )
131

132
    // Create and assign a unique value renderer to the feature layer
133
    val openSpacesUniqueValueRenderer =
134
        UniqueValueRenderer(
135
            fieldNames = listOf("TYPE"),
136
            uniqueValues = uniqueValuesList,
137
            defaultLabel = "Open Spaces",
138
            defaultSymbol = null
139
        )
140

141
    // Create a parks and open spaces feature layer
142
    val featureLayer = createFeatureLayer(featureServiceUri).apply {
143
        // Style the feature layer using the unique value renderer
144
        renderer = openSpacesUniqueValueRenderer
145
        // Set the layer opacity to semi-transparent
146
        opacity = 0.2f
147
    }
148

149
    return featureLayer
150
}
151

152
fun createTrailsLayer(featureServiceUri: String): FeatureLayer {
153
    // Create simple symbol objects to represent the trails layer
154
    val firstClassSymbol = SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.fromRgba(255, 0, 255), 3.0f)
155
    val secondClassSymbol = SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.fromRgba(255, 0, 255), 4.0f)
156
    val thirdClassSymbol = SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.fromRgba(255, 0, 255), 5.0f)
157
    val fourthClassSymbol = SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.fromRgba(255, 0, 255), 6.0f)
158
    val fifthClassSymbol = SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.fromRgba(255, 0, 255), 7.0f)
159

160
    // Create 5 class breaks
161
    val firstClassBreak = ClassBreak(
162
        description = "Under 500",
163
        label = "0 - 500",
164
        minValue = 0.0,
165
        maxValue = 500.0,
166
        symbol = firstClassSymbol
167
    )
168
    val secondClassBreak = ClassBreak(
169
        description = "501 to 1000",
170
        label = "501 - 1000",
171
        minValue = 501.0,
172
        maxValue = 1000.0,
173
        symbol = secondClassSymbol
174
    )
175
    val thirdClassBreak = ClassBreak(
176
        description = "1001 to 1500",
177
        label = "1001 - 1500",
178
        minValue = 1001.0,
179
        maxValue = 1500.0,
180
        symbol = thirdClassSymbol
181
    )
182
    val fourthClassBreak = ClassBreak(
183
        description = "1501 to 2000",
184
        label = "1501 - 2000",
185
        minValue = 1501.0,
186
        maxValue = 2000.0,
187
        symbol = fourthClassSymbol
188
    )
189
    val fifthClassBreak = ClassBreak(
190
        description = "2001 to 2300",
191
        label = "2001 - 2300",
192
        minValue = 2001.0,
193
        maxValue = 2300.0,
194
        symbol = fifthClassSymbol
195
    )
196
    val elevationBreaks = listOf(
197
        firstClassBreak,
198
        secondClassBreak,
199
        thirdClassBreak,
200
        fourthClassBreak,
201
        fifthClassBreak
202
    )
203

204
    // Create and assign a class breaks renderer to the feature layer
205
    val elevationClassBreaksRenderer = ClassBreaksRenderer("ELEV_GAIN", elevationBreaks)
206

207
    // Create a trails feature layer
208
    val featureLayer = createFeatureLayer(featureServiceUri).apply {
209
        // Style the feature layer using the class breaks renderer
210
        renderer = elevationClassBreaksRenderer
211
        // Set the layer opacity to semi-transparent
212
        opacity = 0.75f
213
    }
214

215
    return featureLayer
216
}

Update createMap() to call the new createTrailsLayer() function.

MainScreen.kt


53 collapsed lines
1
@file:OptIn(ExperimentalMaterial3Api::class)
2

3
package com.example.app.screens
4

5
import androidx.compose.foundation.layout.fillMaxSize
6
import androidx.compose.foundation.layout.padding
7
import androidx.compose.material3.ExperimentalMaterial3Api
8
import androidx.compose.material3.Scaffold
9
import androidx.compose.material3.Text
10
import androidx.compose.material3.TopAppBar
11
import androidx.compose.runtime.Composable
12
import androidx.compose.runtime.remember
13
import androidx.compose.ui.Modifier
14
import androidx.compose.ui.res.stringResource
15
import com.arcgismaps.Color
16
import com.arcgismaps.data.ServiceFeatureTable
17
import com.arcgismaps.mapping.ArcGISMap
18
import com.arcgismaps.mapping.BasemapStyle
19
import com.arcgismaps.mapping.Viewpoint
20
import com.arcgismaps.mapping.labeling.ArcadeLabelExpression
21
import com.arcgismaps.mapping.labeling.LabelDefinition
22
import com.arcgismaps.mapping.layers.FeatureLayer
23
import com.arcgismaps.mapping.symbology.ClassBreak
24
import com.arcgismaps.mapping.symbology.ClassBreaksRenderer
25
import com.arcgismaps.mapping.symbology.FontStyle
26
import com.arcgismaps.mapping.symbology.FontWeight
27
import com.arcgismaps.mapping.symbology.PictureMarkerSymbol
28
import com.arcgismaps.mapping.symbology.SimpleFillSymbol
29
import com.arcgismaps.mapping.symbology.SimpleFillSymbolStyle
30
import com.arcgismaps.mapping.symbology.SimpleLineSymbol
31
import com.arcgismaps.mapping.symbology.SimpleLineSymbolStyle
32
import com.arcgismaps.mapping.symbology.SimpleRenderer
33
import com.arcgismaps.mapping.symbology.TextSymbol
34
import com.arcgismaps.mapping.symbology.UniqueValue
35
import com.arcgismaps.mapping.symbology.UniqueValueRenderer
36
import com.arcgismaps.toolkit.geoviewcompose.MapView
37
import com.example.app.R
38

39
@Composable
40
fun MainScreen() {
41
    val map = remember {
42
        createMap()
43
    }
44
    Scaffold(
45
        topBar = { TopAppBar(title = { Text(text = stringResource(id = R.string.app_name)) }) }
46
    ) {
47
        MapView(
48
            modifier = Modifier.fillMaxSize().padding(it),
49
            arcGISMap = map
50
        )
51
    }
52
}
53

54
fun createMap(): ArcGISMap {
55

56
    val parksAndOpenSpaces =
57
        "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Parks_and_Open_Space/FeatureServer/0"
58
    val trails =
59
        "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Trails/FeatureServer/0"
60
    val trailheads =
61
        "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Trailheads/FeatureServer/0"
62
    val trailheadImage =
63
        "https://static.arcgis.com/images/Symbols/NPS/npsPictograph_0231b.png"
64

65
    return ArcGISMap(BasemapStyle.ArcGISTopographic).apply {
66
        initialViewpoint = Viewpoint(
67
            latitude = 34.0270,
68
            longitude = -118.8050,
69
            scale = 72000.0
70
        )
71

72
        operationalLayers.addAll(
73

74
            listOf(
75

76
                createOpenSpaceLayer(parksAndOpenSpaces),
77

78
                createTrailsLayer(trails),
79

80
            )
81

82
        )
83

84
    }
85
}
133 collapsed lines
86

87
fun createFeatureLayer(featureServiceUri: String): FeatureLayer {
88
    // Create a service feature table from a Uri
89
    val serviceFeatureTable = ServiceFeatureTable(featureServiceUri)
90
    // Return a feature layer created from the service feature table
91
    return FeatureLayer.createWithFeatureTable(serviceFeatureTable)
92
}
93

94
fun createOpenSpaceLayer(featureServiceUri: String): FeatureLayer {
95
    // Create fill symbol objects to represent the parks and open spaces layer
96
    val magentaFillSymbol = SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.fromRgba(255, 0, 255), null)
97
    val greenFillSymbol = SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.green, null)
98
    val blueFillSymbol = SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.fromRgba(0, 0, 255), null)
99
    val redFillSymbol = SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.red, null)
100

101
    // Create a unique value for natural areas, regional open spaces, local parks, and regional recreation parks
102
    val naturalAreas = UniqueValue(
103
        description = "Natural Areas",
104
        label = "Natural Areas",
105
        symbol = magentaFillSymbol,
106
        values = listOf("Natural Areas")
107
    )
108
    val regionalOpenSpace = UniqueValue(
109
        description = "Regional Open Space",
110
        label = "Regional Open Space",
111
        symbol = greenFillSymbol,
112
        values = listOf("Regional Open Space")
113
    )
114
    val localPark = UniqueValue(
115
        description = "Local Park",
116
        label = "Local Park",
117
        symbol = blueFillSymbol,
118
        values = listOf("Local Park")
119
    )
120
    val regionalRecreationPark = UniqueValue(
121
        description = "Regional Recreation Park",
122
        label = "Regional Recreation Park",
123
        symbol = redFillSymbol,
124
        values = listOf("Regional Recreation Park")
125
    )
126
    // Create a unique value list with the fill symbols
127
    val uniqueValuesList = listOf(
128
        naturalAreas,
129
        regionalOpenSpace,
130
        localPark,
131
        regionalRecreationPark
132
    )
133

134
    // Create and assign a unique value renderer to the feature layer
135
    val openSpacesUniqueValueRenderer =
136
        UniqueValueRenderer(
137
            fieldNames = listOf("TYPE"),
138
            uniqueValues = uniqueValuesList,
139
            defaultLabel = "Open Spaces",
140
            defaultSymbol = null
141
        )
142

143
    // Create a parks and open spaces feature layer
144
    val featureLayer = createFeatureLayer(featureServiceUri).apply {
145
        // Style the feature layer using the unique value renderer
146
        renderer = openSpacesUniqueValueRenderer
147
        // Set the layer opacity to semi-transparent
148
        opacity = 0.2f
149
    }
150

151
    return featureLayer
152
}
153

154
fun createTrailsLayer(featureServiceUri: String): FeatureLayer {
155
    // Create simple symbol objects to represent the trails layer
156
    val firstClassSymbol = SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.fromRgba(255, 0, 255), 3.0f)
157
    val secondClassSymbol = SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.fromRgba(255, 0, 255), 4.0f)
158
    val thirdClassSymbol = SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.fromRgba(255, 0, 255), 5.0f)
159
    val fourthClassSymbol = SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.fromRgba(255, 0, 255), 6.0f)
160
    val fifthClassSymbol = SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.fromRgba(255, 0, 255), 7.0f)
161

162
    // Create 5 class breaks
163
    val firstClassBreak = ClassBreak(
164
        description = "Under 500",
165
        label = "0 - 500",
166
        minValue = 0.0,
167
        maxValue = 500.0,
168
        symbol = firstClassSymbol
169
    )
170
    val secondClassBreak = ClassBreak(
171
        description = "501 to 1000",
172
        label = "501 - 1000",
173
        minValue = 501.0,
174
        maxValue = 1000.0,
175
        symbol = secondClassSymbol
176
    )
177
    val thirdClassBreak = ClassBreak(
178
        description = "1001 to 1500",
179
        label = "1001 - 1500",
180
        minValue = 1001.0,
181
        maxValue = 1500.0,
182
        symbol = thirdClassSymbol
183
    )
184
    val fourthClassBreak = ClassBreak(
185
        description = "1501 to 2000",
186
        label = "1501 - 2000",
187
        minValue = 1501.0,
188
        maxValue = 2000.0,
189
        symbol = fourthClassSymbol
190
    )
191
    val fifthClassBreak = ClassBreak(
192
        description = "2001 to 2300",
193
        label = "2001 - 2300",
194
        minValue = 2001.0,
195
        maxValue = 2300.0,
196
        symbol = fifthClassSymbol
197
    )
198
    val elevationBreaks = listOf(
199
        firstClassBreak,
200
        secondClassBreak,
201
        thirdClassBreak,
202
        fourthClassBreak,
203
        fifthClassBreak
204
    )
205

206
    // Create and assign a class breaks renderer to the feature layer
207
    val elevationClassBreaksRenderer = ClassBreaksRenderer("ELEV_GAIN", elevationBreaks)
208

209
    // Create a trails feature layer
210
    val featureLayer = createFeatureLayer(featureServiceUri).apply {
211
        // Style the feature layer using the class breaks renderer
212
        renderer = elevationClassBreaksRenderer
213
        // Set the layer opacity to semi-transparent
214
        opacity = 0.75f
215
    }
216

217
    return featureLayer
218
}

Click Run > Run > app to run the app.

When the app opens, the Trails feature layer is added to the map. The map displays trails with different symbols depending on trail elevation.

Add layers with definition expressions

You can use a definition expression to define a subset of features to display. Features that do not meet the expression criteria are not displayed by the layer. In the following steps, you will create two methods that use a definition expression to apply a symbol to a subset of features in the Trails feature layer.

FeatureLayer.definitionExpression uses a SQL expression to limit the features available for query and display. Your code will create two layers that each display a different subset of trails based on the value for the USE_BIKE field. Trails that allow bikes will be symbolized with a blue symbol ("USE_BIKE = 'Yes'") and those that don’t will be yellowred ("USE_BIKE = 'No'"). Another way to symbolize these features would be to create a UniqueValueRenderer that applies a different symbol for these values.

Add a top-level function named createBikeOnlyTrailsLayer() that uses a definitionExpression to filter for trails that permit bikes.

MainScreen.kt


219 collapsed lines
1
@file:OptIn(ExperimentalMaterial3Api::class)
2

3
package com.example.app.screens
4

5
import androidx.compose.foundation.layout.fillMaxSize
6
import androidx.compose.foundation.layout.padding
7
import androidx.compose.material3.ExperimentalMaterial3Api
8
import androidx.compose.material3.Scaffold
9
import androidx.compose.material3.Text
10
import androidx.compose.material3.TopAppBar
11
import androidx.compose.runtime.Composable
12
import androidx.compose.runtime.remember
13
import androidx.compose.ui.Modifier
14
import androidx.compose.ui.res.stringResource
15
import com.arcgismaps.Color
16
import com.arcgismaps.data.ServiceFeatureTable
17
import com.arcgismaps.mapping.ArcGISMap
18
import com.arcgismaps.mapping.BasemapStyle
19
import com.arcgismaps.mapping.Viewpoint
20
import com.arcgismaps.mapping.labeling.ArcadeLabelExpression
21
import com.arcgismaps.mapping.labeling.LabelDefinition
22
import com.arcgismaps.mapping.layers.FeatureLayer
23
import com.arcgismaps.mapping.symbology.ClassBreak
24
import com.arcgismaps.mapping.symbology.ClassBreaksRenderer
25
import com.arcgismaps.mapping.symbology.FontStyle
26
import com.arcgismaps.mapping.symbology.FontWeight
27
import com.arcgismaps.mapping.symbology.PictureMarkerSymbol
28
import com.arcgismaps.mapping.symbology.SimpleFillSymbol
29
import com.arcgismaps.mapping.symbology.SimpleFillSymbolStyle
30
import com.arcgismaps.mapping.symbology.SimpleLineSymbol
31
import com.arcgismaps.mapping.symbology.SimpleLineSymbolStyle
32
import com.arcgismaps.mapping.symbology.SimpleRenderer
33
import com.arcgismaps.mapping.symbology.TextSymbol
34
import com.arcgismaps.mapping.symbology.UniqueValue
35
import com.arcgismaps.mapping.symbology.UniqueValueRenderer
36
import com.arcgismaps.toolkit.geoviewcompose.MapView
37
import com.example.app.R
38

39
@Composable
40
fun MainScreen() {
41
    val map = remember {
42
        createMap()
43
    }
44
    Scaffold(
45
        topBar = { TopAppBar(title = { Text(text = stringResource(id = R.string.app_name)) }) }
46
    ) {
47
        MapView(
48
            modifier = Modifier.fillMaxSize().padding(it),
49
            arcGISMap = map
50
        )
51
    }
52
}
53

54
fun createMap(): ArcGISMap {
55

56
    val parksAndOpenSpaces =
57
        "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Parks_and_Open_Space/FeatureServer/0"
58
    val trails =
59
        "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Trails/FeatureServer/0"
60
    val trailheads =
61
        "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Trailheads/FeatureServer/0"
62
    val trailheadImage =
63
        "https://static.arcgis.com/images/Symbols/NPS/npsPictograph_0231b.png"
64

65
    return ArcGISMap(BasemapStyle.ArcGISTopographic).apply {
66
        initialViewpoint = Viewpoint(
67
            latitude = 34.0270,
68
            longitude = -118.8050,
69
            scale = 72000.0
70
        )
71

72
        operationalLayers.addAll(
73

74
            listOf(
75

76
                createOpenSpaceLayer(parksAndOpenSpaces),
77

78
                createTrailsLayer(trails),
79

80
            )
81

82
        )
83

84
    }
85
}
86

87
fun createFeatureLayer(featureServiceUri: String): FeatureLayer {
88
    // Create a service feature table from a Uri
89
    val serviceFeatureTable = ServiceFeatureTable(featureServiceUri)
90
    // Return a feature layer created from the service feature table
91
    return FeatureLayer.createWithFeatureTable(serviceFeatureTable)
92
}
93

94
fun createOpenSpaceLayer(featureServiceUri: String): FeatureLayer {
95
    // Create fill symbol objects to represent the parks and open spaces layer
96
    val magentaFillSymbol = SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.fromRgba(255, 0, 255), null)
97
    val greenFillSymbol = SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.green, null)
98
    val blueFillSymbol = SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.fromRgba(0, 0, 255), null)
99
    val redFillSymbol = SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.red, null)
100

101
    // Create a unique value for natural areas, regional open spaces, local parks, and regional recreation parks
102
    val naturalAreas = UniqueValue(
103
        description = "Natural Areas",
104
        label = "Natural Areas",
105
        symbol = magentaFillSymbol,
106
        values = listOf("Natural Areas")
107
    )
108
    val regionalOpenSpace = UniqueValue(
109
        description = "Regional Open Space",
110
        label = "Regional Open Space",
111
        symbol = greenFillSymbol,
112
        values = listOf("Regional Open Space")
113
    )
114
    val localPark = UniqueValue(
115
        description = "Local Park",
116
        label = "Local Park",
117
        symbol = blueFillSymbol,
118
        values = listOf("Local Park")
119
    )
120
    val regionalRecreationPark = UniqueValue(
121
        description = "Regional Recreation Park",
122
        label = "Regional Recreation Park",
123
        symbol = redFillSymbol,
124
        values = listOf("Regional Recreation Park")
125
    )
126
    // Create a unique value list with the fill symbols
127
    val uniqueValuesList = listOf(
128
        naturalAreas,
129
        regionalOpenSpace,
130
        localPark,
131
        regionalRecreationPark
132
    )
133

134
    // Create and assign a unique value renderer to the feature layer
135
    val openSpacesUniqueValueRenderer =
136
        UniqueValueRenderer(
137
            fieldNames = listOf("TYPE"),
138
            uniqueValues = uniqueValuesList,
139
            defaultLabel = "Open Spaces",
140
            defaultSymbol = null
141
        )
142

143
    // Create a parks and open spaces feature layer
144
    val featureLayer = createFeatureLayer(featureServiceUri).apply {
145
        // Style the feature layer using the unique value renderer
146
        renderer = openSpacesUniqueValueRenderer
147
        // Set the layer opacity to semi-transparent
148
        opacity = 0.2f
149
    }
150

151
    return featureLayer
152
}
153

154
fun createTrailsLayer(featureServiceUri: String): FeatureLayer {
155
    // Create simple symbol objects to represent the trails layer
156
    val firstClassSymbol = SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.fromRgba(255, 0, 255), 3.0f)
157
    val secondClassSymbol = SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.fromRgba(255, 0, 255), 4.0f)
158
    val thirdClassSymbol = SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.fromRgba(255, 0, 255), 5.0f)
159
    val fourthClassSymbol = SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.fromRgba(255, 0, 255), 6.0f)
160
    val fifthClassSymbol = SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.fromRgba(255, 0, 255), 7.0f)
161

162
    // Create 5 class breaks
163
    val firstClassBreak = ClassBreak(
164
        description = "Under 500",
165
        label = "0 - 500",
166
        minValue = 0.0,
167
        maxValue = 500.0,
168
        symbol = firstClassSymbol
169
    )
170
    val secondClassBreak = ClassBreak(
171
        description = "501 to 1000",
172
        label = "501 - 1000",
173
        minValue = 501.0,
174
        maxValue = 1000.0,
175
        symbol = secondClassSymbol
176
    )
177
    val thirdClassBreak = ClassBreak(
178
        description = "1001 to 1500",
179
        label = "1001 - 1500",
180
        minValue = 1001.0,
181
        maxValue = 1500.0,
182
        symbol = thirdClassSymbol
183
    )
184
    val fourthClassBreak = ClassBreak(
185
        description = "1501 to 2000",
186
        label = "1501 - 2000",
187
        minValue = 1501.0,
188
        maxValue = 2000.0,
189
        symbol = fourthClassSymbol
190
    )
191
    val fifthClassBreak = ClassBreak(
192
        description = "2001 to 2300",
193
        label = "2001 - 2300",
194
        minValue = 2001.0,
195
        maxValue = 2300.0,
196
        symbol = fifthClassSymbol
197
    )
198
    val elevationBreaks = listOf(
199
        firstClassBreak,
200
        secondClassBreak,
201
        thirdClassBreak,
202
        fourthClassBreak,
203
        fifthClassBreak
204
    )
205

206
    // Create and assign a class breaks renderer to the feature layer
207
    val elevationClassBreaksRenderer = ClassBreaksRenderer("ELEV_GAIN", elevationBreaks)
208

209
    // Create a trails feature layer
210
    val featureLayer = createFeatureLayer(featureServiceUri).apply {
211
        // Style the feature layer using the class breaks renderer
212
        renderer = elevationClassBreaksRenderer
213
        // Set the layer opacity to semi-transparent
214
        opacity = 0.75f
215
    }
216

217
    return featureLayer
218
}
219

220
fun createBikeOnlyTrailsLayer(featureServiceUri: String): FeatureLayer {
221
    // Create blue dot style simple line symbol to represent the bike trails
222
    val bikeTrailSymbol = SimpleLineSymbol(SimpleLineSymbolStyle.Dot, Color.fromRgba(0, 0, 255), 2.0f)
223
    // Create a simple renderer for the feature layer
224
    val bikeTrailRenderer = SimpleRenderer(bikeTrailSymbol)
225

226
    // Create a bike trails feature layer
227
    val featureLayer = createFeatureLayer(featureServiceUri).apply {
228
        // Style the feature layer using the simple renderer
229
        renderer = bikeTrailRenderer
230
        // Write a definition expression to filter for trails that permit the use of bikes
231
        definitionExpression = "USE_BIKE = 'Yes'"
232
    }
233

234
    return featureLayer
235
}

Add another top-level function named createNoBikeTrailsLayer() with a definition expression to filter for trails that don’t allow bikes.

MainScreen.kt


236 collapsed lines
1
@file:OptIn(ExperimentalMaterial3Api::class)
2

3
package com.example.app.screens
4

5
import androidx.compose.foundation.layout.fillMaxSize
6
import androidx.compose.foundation.layout.padding
7
import androidx.compose.material3.ExperimentalMaterial3Api
8
import androidx.compose.material3.Scaffold
9
import androidx.compose.material3.Text
10
import androidx.compose.material3.TopAppBar
11
import androidx.compose.runtime.Composable
12
import androidx.compose.runtime.remember
13
import androidx.compose.ui.Modifier
14
import androidx.compose.ui.res.stringResource
15
import com.arcgismaps.Color
16
import com.arcgismaps.data.ServiceFeatureTable
17
import com.arcgismaps.mapping.ArcGISMap
18
import com.arcgismaps.mapping.BasemapStyle
19
import com.arcgismaps.mapping.Viewpoint
20
import com.arcgismaps.mapping.labeling.ArcadeLabelExpression
21
import com.arcgismaps.mapping.labeling.LabelDefinition
22
import com.arcgismaps.mapping.layers.FeatureLayer
23
import com.arcgismaps.mapping.symbology.ClassBreak
24
import com.arcgismaps.mapping.symbology.ClassBreaksRenderer
25
import com.arcgismaps.mapping.symbology.FontStyle
26
import com.arcgismaps.mapping.symbology.FontWeight
27
import com.arcgismaps.mapping.symbology.PictureMarkerSymbol
28
import com.arcgismaps.mapping.symbology.SimpleFillSymbol
29
import com.arcgismaps.mapping.symbology.SimpleFillSymbolStyle
30
import com.arcgismaps.mapping.symbology.SimpleLineSymbol
31
import com.arcgismaps.mapping.symbology.SimpleLineSymbolStyle
32
import com.arcgismaps.mapping.symbology.SimpleRenderer
33
import com.arcgismaps.mapping.symbology.TextSymbol
34
import com.arcgismaps.mapping.symbology.UniqueValue
35
import com.arcgismaps.mapping.symbology.UniqueValueRenderer
36
import com.arcgismaps.toolkit.geoviewcompose.MapView
37
import com.example.app.R
38

39
@Composable
40
fun MainScreen() {
41
    val map = remember {
42
        createMap()
43
    }
44
    Scaffold(
45
        topBar = { TopAppBar(title = { Text(text = stringResource(id = R.string.app_name)) }) }
46
    ) {
47
        MapView(
48
            modifier = Modifier.fillMaxSize().padding(it),
49
            arcGISMap = map
50
        )
51
    }
52
}
53

54
fun createMap(): ArcGISMap {
55

56
    val parksAndOpenSpaces =
57
        "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Parks_and_Open_Space/FeatureServer/0"
58
    val trails =
59
        "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Trails/FeatureServer/0"
60
    val trailheads =
61
        "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Trailheads/FeatureServer/0"
62
    val trailheadImage =
63
        "https://static.arcgis.com/images/Symbols/NPS/npsPictograph_0231b.png"
64

65
    return ArcGISMap(BasemapStyle.ArcGISTopographic).apply {
66
        initialViewpoint = Viewpoint(
67
            latitude = 34.0270,
68
            longitude = -118.8050,
69
            scale = 72000.0
70
        )
71

72
        operationalLayers.addAll(
73

74
            listOf(
75

76
                createOpenSpaceLayer(parksAndOpenSpaces),
77

78
                createTrailsLayer(trails),
79

80
            )
81

82
        )
83

84
    }
85
}
86

87
fun createFeatureLayer(featureServiceUri: String): FeatureLayer {
88
    // Create a service feature table from a Uri
89
    val serviceFeatureTable = ServiceFeatureTable(featureServiceUri)
90
    // Return a feature layer created from the service feature table
91
    return FeatureLayer.createWithFeatureTable(serviceFeatureTable)
92
}
93

94
fun createOpenSpaceLayer(featureServiceUri: String): FeatureLayer {
95
    // Create fill symbol objects to represent the parks and open spaces layer
96
    val magentaFillSymbol = SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.fromRgba(255, 0, 255), null)
97
    val greenFillSymbol = SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.green, null)
98
    val blueFillSymbol = SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.fromRgba(0, 0, 255), null)
99
    val redFillSymbol = SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.red, null)
100

101
    // Create a unique value for natural areas, regional open spaces, local parks, and regional recreation parks
102
    val naturalAreas = UniqueValue(
103
        description = "Natural Areas",
104
        label = "Natural Areas",
105
        symbol = magentaFillSymbol,
106
        values = listOf("Natural Areas")
107
    )
108
    val regionalOpenSpace = UniqueValue(
109
        description = "Regional Open Space",
110
        label = "Regional Open Space",
111
        symbol = greenFillSymbol,
112
        values = listOf("Regional Open Space")
113
    )
114
    val localPark = UniqueValue(
115
        description = "Local Park",
116
        label = "Local Park",
117
        symbol = blueFillSymbol,
118
        values = listOf("Local Park")
119
    )
120
    val regionalRecreationPark = UniqueValue(
121
        description = "Regional Recreation Park",
122
        label = "Regional Recreation Park",
123
        symbol = redFillSymbol,
124
        values = listOf("Regional Recreation Park")
125
    )
126
    // Create a unique value list with the fill symbols
127
    val uniqueValuesList = listOf(
128
        naturalAreas,
129
        regionalOpenSpace,
130
        localPark,
131
        regionalRecreationPark
132
    )
133

134
    // Create and assign a unique value renderer to the feature layer
135
    val openSpacesUniqueValueRenderer =
136
        UniqueValueRenderer(
137
            fieldNames = listOf("TYPE"),
138
            uniqueValues = uniqueValuesList,
139
            defaultLabel = "Open Spaces",
140
            defaultSymbol = null
141
        )
142

143
    // Create a parks and open spaces feature layer
144
    val featureLayer = createFeatureLayer(featureServiceUri).apply {
145
        // Style the feature layer using the unique value renderer
146
        renderer = openSpacesUniqueValueRenderer
147
        // Set the layer opacity to semi-transparent
148
        opacity = 0.2f
149
    }
150

151
    return featureLayer
152
}
153

154
fun createTrailsLayer(featureServiceUri: String): FeatureLayer {
155
    // Create simple symbol objects to represent the trails layer
156
    val firstClassSymbol = SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.fromRgba(255, 0, 255), 3.0f)
157
    val secondClassSymbol = SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.fromRgba(255, 0, 255), 4.0f)
158
    val thirdClassSymbol = SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.fromRgba(255, 0, 255), 5.0f)
159
    val fourthClassSymbol = SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.fromRgba(255, 0, 255), 6.0f)
160
    val fifthClassSymbol = SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.fromRgba(255, 0, 255), 7.0f)
161

162
    // Create 5 class breaks
163
    val firstClassBreak = ClassBreak(
164
        description = "Under 500",
165
        label = "0 - 500",
166
        minValue = 0.0,
167
        maxValue = 500.0,
168
        symbol = firstClassSymbol
169
    )
170
    val secondClassBreak = ClassBreak(
171
        description = "501 to 1000",
172
        label = "501 - 1000",
173
        minValue = 501.0,
174
        maxValue = 1000.0,
175
        symbol = secondClassSymbol
176
    )
177
    val thirdClassBreak = ClassBreak(
178
        description = "1001 to 1500",
179
        label = "1001 - 1500",
180
        minValue = 1001.0,
181
        maxValue = 1500.0,
182
        symbol = thirdClassSymbol
183
    )
184
    val fourthClassBreak = ClassBreak(
185
        description = "1501 to 2000",
186
        label = "1501 - 2000",
187
        minValue = 1501.0,
188
        maxValue = 2000.0,
189
        symbol = fourthClassSymbol
190
    )
191
    val fifthClassBreak = ClassBreak(
192
        description = "2001 to 2300",
193
        label = "2001 - 2300",
194
        minValue = 2001.0,
195
        maxValue = 2300.0,
196
        symbol = fifthClassSymbol
197
    )
198
    val elevationBreaks = listOf(
199
        firstClassBreak,
200
        secondClassBreak,
201
        thirdClassBreak,
202
        fourthClassBreak,
203
        fifthClassBreak
204
    )
205

206
    // Create and assign a class breaks renderer to the feature layer
207
    val elevationClassBreaksRenderer = ClassBreaksRenderer("ELEV_GAIN", elevationBreaks)
208

209
    // Create a trails feature layer
210
    val featureLayer = createFeatureLayer(featureServiceUri).apply {
211
        // Style the feature layer using the class breaks renderer
212
        renderer = elevationClassBreaksRenderer
213
        // Set the layer opacity to semi-transparent
214
        opacity = 0.75f
215
    }
216

217
    return featureLayer
218
}
219

220
fun createBikeOnlyTrailsLayer(featureServiceUri: String): FeatureLayer {
221
    // Create blue dot style simple line symbol to represent the bike trails
222
    val bikeTrailSymbol = SimpleLineSymbol(SimpleLineSymbolStyle.Dot, Color.fromRgba(0, 0, 255), 2.0f)
223
    // Create a simple renderer for the feature layer
224
    val bikeTrailRenderer = SimpleRenderer(bikeTrailSymbol)
225

226
    // Create a bike trails feature layer
227
    val featureLayer = createFeatureLayer(featureServiceUri).apply {
228
        // Style the feature layer using the simple renderer
229
        renderer = bikeTrailRenderer
230
        // Write a definition expression to filter for trails that permit the use of bikes
231
        definitionExpression = "USE_BIKE = 'Yes'"
232
    }
233

234
    return featureLayer
235
}
236

237
fun createNoBikeTrailsLayer(featureServiceUri: String): FeatureLayer {
238
    // Create a yellow dot style simple line symbol to represent no bike trails
239
    val noBikeTrailSymbol = SimpleLineSymbol(SimpleLineSymbolStyle.Dot, Color.fromRgba(255, 255, 0), 2.0f)
240
    // Create a simple renderer for the feature layer
241
    val noBikeTrailRenderer = SimpleRenderer(noBikeTrailSymbol)
242

243
    // Create a no-bike trails feature layer
244
    val featureLayer = createFeatureLayer(featureServiceUri).apply {
245
        // Style the feature layer using the simple renderer
246
        renderer = noBikeTrailRenderer
247
        // Write a definition expression to filter for trails that don't permit the use of bikes
248
        definitionExpression = "USE_BIKE = 'No'"
249
    }
250

251
    return featureLayer
252
}

Update createMap() to call the new createBikeOnlyTrailsLayer() and createNoBikeTrailsLayer() functions.

MainScreen.kt


53 collapsed lines
1
@file:OptIn(ExperimentalMaterial3Api::class)
2

3
package com.example.app.screens
4

5
import androidx.compose.foundation.layout.fillMaxSize
6
import androidx.compose.foundation.layout.padding
7
import androidx.compose.material3.ExperimentalMaterial3Api
8
import androidx.compose.material3.Scaffold
9
import androidx.compose.material3.Text
10
import androidx.compose.material3.TopAppBar
11
import androidx.compose.runtime.Composable
12
import androidx.compose.runtime.remember
13
import androidx.compose.ui.Modifier
14
import androidx.compose.ui.res.stringResource
15
import com.arcgismaps.Color
16
import com.arcgismaps.data.ServiceFeatureTable
17
import com.arcgismaps.mapping.ArcGISMap
18
import com.arcgismaps.mapping.BasemapStyle
19
import com.arcgismaps.mapping.Viewpoint
20
import com.arcgismaps.mapping.labeling.ArcadeLabelExpression
21
import com.arcgismaps.mapping.labeling.LabelDefinition
22
import com.arcgismaps.mapping.layers.FeatureLayer
23
import com.arcgismaps.mapping.symbology.ClassBreak
24
import com.arcgismaps.mapping.symbology.ClassBreaksRenderer
25
import com.arcgismaps.mapping.symbology.FontStyle
26
import com.arcgismaps.mapping.symbology.FontWeight
27
import com.arcgismaps.mapping.symbology.PictureMarkerSymbol
28
import com.arcgismaps.mapping.symbology.SimpleFillSymbol
29
import com.arcgismaps.mapping.symbology.SimpleFillSymbolStyle
30
import com.arcgismaps.mapping.symbology.SimpleLineSymbol
31
import com.arcgismaps.mapping.symbology.SimpleLineSymbolStyle
32
import com.arcgismaps.mapping.symbology.SimpleRenderer
33
import com.arcgismaps.mapping.symbology.TextSymbol
34
import com.arcgismaps.mapping.symbology.UniqueValue
35
import com.arcgismaps.mapping.symbology.UniqueValueRenderer
36
import com.arcgismaps.toolkit.geoviewcompose.MapView
37
import com.example.app.R
38

39
@Composable
40
fun MainScreen() {
41
    val map = remember {
42
        createMap()
43
    }
44
    Scaffold(
45
        topBar = { TopAppBar(title = { Text(text = stringResource(id = R.string.app_name)) }) }
46
    ) {
47
        MapView(
48
            modifier = Modifier.fillMaxSize().padding(it),
49
            arcGISMap = map
50
        )
51
    }
52
}
53

54
fun createMap(): ArcGISMap {
55

56
    val parksAndOpenSpaces =
57
        "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Parks_and_Open_Space/FeatureServer/0"
58
    val trails =
59
        "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Trails/FeatureServer/0"
60
    val trailheads =
61
        "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Trailheads/FeatureServer/0"
62
    val trailheadImage =
63
        "https://static.arcgis.com/images/Symbols/NPS/npsPictograph_0231b.png"
64

65
    return ArcGISMap(BasemapStyle.ArcGISTopographic).apply {
66
        initialViewpoint = Viewpoint(
67
            latitude = 34.0270,
68
            longitude = -118.8050,
69
            scale = 72000.0
70
        )
71

72
        operationalLayers.addAll(
73

74
            listOf(
75

76
                createOpenSpaceLayer(parksAndOpenSpaces),
77

78
                createTrailsLayer(trails),
79

80
                createBikeOnlyTrailsLayer(trails),
81

82
                createNoBikeTrailsLayer(trails),
83

84
            )
85

86
        )
87

88
    }
89
}
167 collapsed lines
90

91
fun createFeatureLayer(featureServiceUri: String): FeatureLayer {
92
    // Create a service feature table from a Uri
93
    val serviceFeatureTable = ServiceFeatureTable(featureServiceUri)
94
    // Return a feature layer created from the service feature table
95
    return FeatureLayer.createWithFeatureTable(serviceFeatureTable)
96
}
97

98
fun createOpenSpaceLayer(featureServiceUri: String): FeatureLayer {
99
    // Create fill symbol objects to represent the parks and open spaces layer
100
    val magentaFillSymbol = SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.fromRgba(255, 0, 255), null)
101
    val greenFillSymbol = SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.green, null)
102
    val blueFillSymbol = SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.fromRgba(0, 0, 255), null)
103
    val redFillSymbol = SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.red, null)
104

105
    // Create a unique value for natural areas, regional open spaces, local parks, and regional recreation parks
106
    val naturalAreas = UniqueValue(
107
        description = "Natural Areas",
108
        label = "Natural Areas",
109
        symbol = magentaFillSymbol,
110
        values = listOf("Natural Areas")
111
    )
112
    val regionalOpenSpace = UniqueValue(
113
        description = "Regional Open Space",
114
        label = "Regional Open Space",
115
        symbol = greenFillSymbol,
116
        values = listOf("Regional Open Space")
117
    )
118
    val localPark = UniqueValue(
119
        description = "Local Park",
120
        label = "Local Park",
121
        symbol = blueFillSymbol,
122
        values = listOf("Local Park")
123
    )
124
    val regionalRecreationPark = UniqueValue(
125
        description = "Regional Recreation Park",
126
        label = "Regional Recreation Park",
127
        symbol = redFillSymbol,
128
        values = listOf("Regional Recreation Park")
129
    )
130
    // Create a unique value list with the fill symbols
131
    val uniqueValuesList = listOf(
132
        naturalAreas,
133
        regionalOpenSpace,
134
        localPark,
135
        regionalRecreationPark
136
    )
137

138
    // Create and assign a unique value renderer to the feature layer
139
    val openSpacesUniqueValueRenderer =
140
        UniqueValueRenderer(
141
            fieldNames = listOf("TYPE"),
142
            uniqueValues = uniqueValuesList,
143
            defaultLabel = "Open Spaces",
144
            defaultSymbol = null
145
        )
146

147
    // Create a parks and open spaces feature layer
148
    val featureLayer = createFeatureLayer(featureServiceUri).apply {
149
        // Style the feature layer using the unique value renderer
150
        renderer = openSpacesUniqueValueRenderer
151
        // Set the layer opacity to semi-transparent
152
        opacity = 0.2f
153
    }
154

155
    return featureLayer
156
}
157

158
fun createTrailsLayer(featureServiceUri: String): FeatureLayer {
159
    // Create simple symbol objects to represent the trails layer
160
    val firstClassSymbol = SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.fromRgba(255, 0, 255), 3.0f)
161
    val secondClassSymbol = SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.fromRgba(255, 0, 255), 4.0f)
162
    val thirdClassSymbol = SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.fromRgba(255, 0, 255), 5.0f)
163
    val fourthClassSymbol = SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.fromRgba(255, 0, 255), 6.0f)
164
    val fifthClassSymbol = SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.fromRgba(255, 0, 255), 7.0f)
165

166
    // Create 5 class breaks
167
    val firstClassBreak = ClassBreak(
168
        description = "Under 500",
169
        label = "0 - 500",
170
        minValue = 0.0,
171
        maxValue = 500.0,
172
        symbol = firstClassSymbol
173
    )
174
    val secondClassBreak = ClassBreak(
175
        description = "501 to 1000",
176
        label = "501 - 1000",
177
        minValue = 501.0,
178
        maxValue = 1000.0,
179
        symbol = secondClassSymbol
180
    )
181
    val thirdClassBreak = ClassBreak(
182
        description = "1001 to 1500",
183
        label = "1001 - 1500",
184
        minValue = 1001.0,
185
        maxValue = 1500.0,
186
        symbol = thirdClassSymbol
187
    )
188
    val fourthClassBreak = ClassBreak(
189
        description = "1501 to 2000",
190
        label = "1501 - 2000",
191
        minValue = 1501.0,
192
        maxValue = 2000.0,
193
        symbol = fourthClassSymbol
194
    )
195
    val fifthClassBreak = ClassBreak(
196
        description = "2001 to 2300",
197
        label = "2001 - 2300",
198
        minValue = 2001.0,
199
        maxValue = 2300.0,
200
        symbol = fifthClassSymbol
201
    )
202
    val elevationBreaks = listOf(
203
        firstClassBreak,
204
        secondClassBreak,
205
        thirdClassBreak,
206
        fourthClassBreak,
207
        fifthClassBreak
208
    )
209

210
    // Create and assign a class breaks renderer to the feature layer
211
    val elevationClassBreaksRenderer = ClassBreaksRenderer("ELEV_GAIN", elevationBreaks)
212

213
    // Create a trails feature layer
214
    val featureLayer = createFeatureLayer(featureServiceUri).apply {
215
        // Style the feature layer using the class breaks renderer
216
        renderer = elevationClassBreaksRenderer
217
        // Set the layer opacity to semi-transparent
218
        opacity = 0.75f
219
    }
220

221
    return featureLayer
222
}
223

224
fun createBikeOnlyTrailsLayer(featureServiceUri: String): FeatureLayer {
225
    // Create blue dot style simple line symbol to represent the bike trails
226
    val bikeTrailSymbol = SimpleLineSymbol(SimpleLineSymbolStyle.Dot, Color.fromRgba(0, 0, 255), 2.0f)
227
    // Create a simple renderer for the feature layer
228
    val bikeTrailRenderer = SimpleRenderer(bikeTrailSymbol)
229

230
    // Create a bike trails feature layer
231
    val featureLayer = createFeatureLayer(featureServiceUri).apply {
232
        // Style the feature layer using the simple renderer
233
        renderer = bikeTrailRenderer
234
        // Write a definition expression to filter for trails that permit the use of bikes
235
        definitionExpression = "USE_BIKE = 'Yes'"
236
    }
237

238
    return featureLayer
239
}
240

241
fun createNoBikeTrailsLayer(featureServiceUri: String): FeatureLayer {
242
    // Create a yellow dot style simple line symbol to represent no bike trails
243
    val noBikeTrailSymbol = SimpleLineSymbol(SimpleLineSymbolStyle.Dot, Color.fromRgba(255, 255, 0), 2.0f)
244
    // Create a simple renderer for the feature layer
245
    val noBikeTrailRenderer = SimpleRenderer(noBikeTrailSymbol)
246

247
    // Create a no-bike trails feature layer
248
    val featureLayer = createFeatureLayer(featureServiceUri).apply {
249
        // Style the feature layer using the simple renderer
250
        renderer = noBikeTrailRenderer
251
        // Write a definition expression to filter for trails that don't permit the use of bikes
252
        definitionExpression = "USE_BIKE = 'No'"
253
    }
254

255
    return featureLayer
256
}

Click Run > Run > app to run the app.

When the app opens, two Trails feature layers are added to the map. One shows where bikes are permitted and the other where they are prohibited.

Symbolize a layer with a picture symbol and label features with an attribute

Create a method to style trailheads with hiker images and labels for the Trailheads feature layer.

Feature layers A feature layer (client-side) is a data layer that can access and display features from a feature service that has the same type of geometry and attribute fields. Learn more , graphics overlays A graphics overlay is a client-side, temporary container of graphics to display on a map view or scene view. Learn more , and map image layer A map image layer is a data layer that can access and display map images that are created dynamically as users zoom or pan around a map view. Learn more sublayers in your app can be labeled using a combination of attribute Attributes 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 values, text strings, and values calculated with an expression. You can determine how labels are positioned and prioritized, and how conflicts between overlapping labels are automatically and dynamically resolved.

For feature layers, graphics overlays, and map image sublayers, labeling is implemented using a collection of LabelDefinition objects to define what labels look like (font, size, color, angle, and so on), the scale at which they display, the text they contain, how they handle overlaps, and so on.

If you want to label everything in your layer or overlay to look identical, you can define a single label definition. If you want to use different label formatting for different attribute values, you can add as many label definitions as you need to define distinct sets of geoelements A geoelement refers to any geographic element in a map or map view that can be identified by its location to return attribute information. Learn more for labeling.

Add a top-level function named createTrailheadsLayer().

Use a PictureMarkerSymbol to draw a trailhead hiker image. Use the LabelDefinition to label each trailhead by its name.

MainScreen.kt


257 collapsed lines
1
@file:OptIn(ExperimentalMaterial3Api::class)
2

3
package com.example.app.screens
4

5
import androidx.compose.foundation.layout.fillMaxSize
6
import androidx.compose.foundation.layout.padding
7
import androidx.compose.material3.ExperimentalMaterial3Api
8
import androidx.compose.material3.Scaffold
9
import androidx.compose.material3.Text
10
import androidx.compose.material3.TopAppBar
11
import androidx.compose.runtime.Composable
12
import androidx.compose.runtime.remember
13
import androidx.compose.ui.Modifier
14
import androidx.compose.ui.res.stringResource
15
import com.arcgismaps.Color
16
import com.arcgismaps.data.ServiceFeatureTable
17
import com.arcgismaps.mapping.ArcGISMap
18
import com.arcgismaps.mapping.BasemapStyle
19
import com.arcgismaps.mapping.Viewpoint
20
import com.arcgismaps.mapping.labeling.ArcadeLabelExpression
21
import com.arcgismaps.mapping.labeling.LabelDefinition
22
import com.arcgismaps.mapping.layers.FeatureLayer
23
import com.arcgismaps.mapping.symbology.ClassBreak
24
import com.arcgismaps.mapping.symbology.ClassBreaksRenderer
25
import com.arcgismaps.mapping.symbology.FontStyle
26
import com.arcgismaps.mapping.symbology.FontWeight
27
import com.arcgismaps.mapping.symbology.PictureMarkerSymbol
28
import com.arcgismaps.mapping.symbology.SimpleFillSymbol
29
import com.arcgismaps.mapping.symbology.SimpleFillSymbolStyle
30
import com.arcgismaps.mapping.symbology.SimpleLineSymbol
31
import com.arcgismaps.mapping.symbology.SimpleLineSymbolStyle
32
import com.arcgismaps.mapping.symbology.SimpleRenderer
33
import com.arcgismaps.mapping.symbology.TextSymbol
34
import com.arcgismaps.mapping.symbology.UniqueValue
35
import com.arcgismaps.mapping.symbology.UniqueValueRenderer
36
import com.arcgismaps.toolkit.geoviewcompose.MapView
37
import com.example.app.R
38

39
@Composable
40
fun MainScreen() {
41
    val map = remember {
42
        createMap()
43
    }
44
    Scaffold(
45
        topBar = { TopAppBar(title = { Text(text = stringResource(id = R.string.app_name)) }) }
46
    ) {
47
        MapView(
48
            modifier = Modifier.fillMaxSize().padding(it),
49
            arcGISMap = map
50
        )
51
    }
52
}
53

54
fun createMap(): ArcGISMap {
55

56
    val parksAndOpenSpaces =
57
        "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Parks_and_Open_Space/FeatureServer/0"
58
    val trails =
59
        "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Trails/FeatureServer/0"
60
    val trailheads =
61
        "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Trailheads/FeatureServer/0"
62
    val trailheadImage =
63
        "https://static.arcgis.com/images/Symbols/NPS/npsPictograph_0231b.png"
64

65
    return ArcGISMap(BasemapStyle.ArcGISTopographic).apply {
66
        initialViewpoint = Viewpoint(
67
            latitude = 34.0270,
68
            longitude = -118.8050,
69
            scale = 72000.0
70
        )
71

72
        operationalLayers.addAll(
73

74
            listOf(
75

76
                createOpenSpaceLayer(parksAndOpenSpaces),
77

78
                createTrailsLayer(trails),
79

80
                createBikeOnlyTrailsLayer(trails),
81

82
                createNoBikeTrailsLayer(trails),
83

84
            )
85

86
        )
87

88
    }
89
}
90

91
fun createFeatureLayer(featureServiceUri: String): FeatureLayer {
92
    // Create a service feature table from a Uri
93
    val serviceFeatureTable = ServiceFeatureTable(featureServiceUri)
94
    // Return a feature layer created from the service feature table
95
    return FeatureLayer.createWithFeatureTable(serviceFeatureTable)
96
}
97

98
fun createOpenSpaceLayer(featureServiceUri: String): FeatureLayer {
99
    // Create fill symbol objects to represent the parks and open spaces layer
100
    val magentaFillSymbol = SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.fromRgba(255, 0, 255), null)
101
    val greenFillSymbol = SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.green, null)
102
    val blueFillSymbol = SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.fromRgba(0, 0, 255), null)
103
    val redFillSymbol = SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.red, null)
104

105
    // Create a unique value for natural areas, regional open spaces, local parks, and regional recreation parks
106
    val naturalAreas = UniqueValue(
107
        description = "Natural Areas",
108
        label = "Natural Areas",
109
        symbol = magentaFillSymbol,
110
        values = listOf("Natural Areas")
111
    )
112
    val regionalOpenSpace = UniqueValue(
113
        description = "Regional Open Space",
114
        label = "Regional Open Space",
115
        symbol = greenFillSymbol,
116
        values = listOf("Regional Open Space")
117
    )
118
    val localPark = UniqueValue(
119
        description = "Local Park",
120
        label = "Local Park",
121
        symbol = blueFillSymbol,
122
        values = listOf("Local Park")
123
    )
124
    val regionalRecreationPark = UniqueValue(
125
        description = "Regional Recreation Park",
126
        label = "Regional Recreation Park",
127
        symbol = redFillSymbol,
128
        values = listOf("Regional Recreation Park")
129
    )
130
    // Create a unique value list with the fill symbols
131
    val uniqueValuesList = listOf(
132
        naturalAreas,
133
        regionalOpenSpace,
134
        localPark,
135
        regionalRecreationPark
136
    )
137

138
    // Create and assign a unique value renderer to the feature layer
139
    val openSpacesUniqueValueRenderer =
140
        UniqueValueRenderer(
141
            fieldNames = listOf("TYPE"),
142
            uniqueValues = uniqueValuesList,
143
            defaultLabel = "Open Spaces",
144
            defaultSymbol = null
145
        )
146

147
    // Create a parks and open spaces feature layer
148
    val featureLayer = createFeatureLayer(featureServiceUri).apply {
149
        // Style the feature layer using the unique value renderer
150
        renderer = openSpacesUniqueValueRenderer
151
        // Set the layer opacity to semi-transparent
152
        opacity = 0.2f
153
    }
154

155
    return featureLayer
156
}
157

158
fun createTrailsLayer(featureServiceUri: String): FeatureLayer {
159
    // Create simple symbol objects to represent the trails layer
160
    val firstClassSymbol = SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.fromRgba(255, 0, 255), 3.0f)
161
    val secondClassSymbol = SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.fromRgba(255, 0, 255), 4.0f)
162
    val thirdClassSymbol = SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.fromRgba(255, 0, 255), 5.0f)
163
    val fourthClassSymbol = SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.fromRgba(255, 0, 255), 6.0f)
164
    val fifthClassSymbol = SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.fromRgba(255, 0, 255), 7.0f)
165

166
    // Create 5 class breaks
167
    val firstClassBreak = ClassBreak(
168
        description = "Under 500",
169
        label = "0 - 500",
170
        minValue = 0.0,
171
        maxValue = 500.0,
172
        symbol = firstClassSymbol
173
    )
174
    val secondClassBreak = ClassBreak(
175
        description = "501 to 1000",
176
        label = "501 - 1000",
177
        minValue = 501.0,
178
        maxValue = 1000.0,
179
        symbol = secondClassSymbol
180
    )
181
    val thirdClassBreak = ClassBreak(
182
        description = "1001 to 1500",
183
        label = "1001 - 1500",
184
        minValue = 1001.0,
185
        maxValue = 1500.0,
186
        symbol = thirdClassSymbol
187
    )
188
    val fourthClassBreak = ClassBreak(
189
        description = "1501 to 2000",
190
        label = "1501 - 2000",
191
        minValue = 1501.0,
192
        maxValue = 2000.0,
193
        symbol = fourthClassSymbol
194
    )
195
    val fifthClassBreak = ClassBreak(
196
        description = "2001 to 2300",
197
        label = "2001 - 2300",
198
        minValue = 2001.0,
199
        maxValue = 2300.0,
200
        symbol = fifthClassSymbol
201
    )
202
    val elevationBreaks = listOf(
203
        firstClassBreak,
204
        secondClassBreak,
205
        thirdClassBreak,
206
        fourthClassBreak,
207
        fifthClassBreak
208
    )
209

210
    // Create and assign a class breaks renderer to the feature layer
211
    val elevationClassBreaksRenderer = ClassBreaksRenderer("ELEV_GAIN", elevationBreaks)
212

213
    // Create a trails feature layer
214
    val featureLayer = createFeatureLayer(featureServiceUri).apply {
215
        // Style the feature layer using the class breaks renderer
216
        renderer = elevationClassBreaksRenderer
217
        // Set the layer opacity to semi-transparent
218
        opacity = 0.75f
219
    }
220

221
    return featureLayer
222
}
223

224
fun createBikeOnlyTrailsLayer(featureServiceUri: String): FeatureLayer {
225
    // Create blue dot style simple line symbol to represent the bike trails
226
    val bikeTrailSymbol = SimpleLineSymbol(SimpleLineSymbolStyle.Dot, Color.fromRgba(0, 0, 255), 2.0f)
227
    // Create a simple renderer for the feature layer
228
    val bikeTrailRenderer = SimpleRenderer(bikeTrailSymbol)
229

230
    // Create a bike trails feature layer
231
    val featureLayer = createFeatureLayer(featureServiceUri).apply {
232
        // Style the feature layer using the simple renderer
233
        renderer = bikeTrailRenderer
234
        // Write a definition expression to filter for trails that permit the use of bikes
235
        definitionExpression = "USE_BIKE = 'Yes'"
236
    }
237

238
    return featureLayer
239
}
240

241
fun createNoBikeTrailsLayer(featureServiceUri: String): FeatureLayer {
242
    // Create a yellow dot style simple line symbol to represent no bike trails
243
    val noBikeTrailSymbol = SimpleLineSymbol(SimpleLineSymbolStyle.Dot, Color.fromRgba(255, 255, 0), 2.0f)
244
    // Create a simple renderer for the feature layer
245
    val noBikeTrailRenderer = SimpleRenderer(noBikeTrailSymbol)
246

247
    // Create a no-bike trails feature layer
248
    val featureLayer = createFeatureLayer(featureServiceUri).apply {
249
        // Style the feature layer using the simple renderer
250
        renderer = noBikeTrailRenderer
251
        // Write a definition expression to filter for trails that don't permit the use of bikes
252
        definitionExpression = "USE_BIKE = 'No'"
253
    }
254

255
    return featureLayer
256
}
257

258
fun createTrailheadsLayer(featureServiceUri: String, trailheadImage: String): FeatureLayer {
259
    // Create a new picture marker symbol that uses the trailhead image
260
    val pictureMarkerSymbol = PictureMarkerSymbol(trailheadImage).apply {
261
        height = 18.0f
262
        width = 18.0f
263
    }
264
    // Create a new simple renderer based on the picture marker symbol
265
    val simpleRenderer = SimpleRenderer(pictureMarkerSymbol)
266
    // Create the label definition
267
    val trailHeadsDefinition = makeLabelDefinition(labelAttribute = "TRL_NAME")
268

269
    // Create a trail heads feature layer
270
    val featureLayer: FeatureLayer = createFeatureLayer(featureServiceUri).apply {
271
        // Style the feature layer using the simple renderer
272
        renderer = simpleRenderer
273
        // Set labeling on the layer to be enabled
274
        labelsEnabled = true
275
        // Add the label definition to the layer's label definition collection
276
        labelDefinitions.add(trailHeadsDefinition)
277
    }
278

279
    return featureLayer
280
}

Create a top-level function named makeLabelDefinition() that defines a label definition based on the passed in feature layer attribute. This helper function will also define the label placement and text symbol.

MainScreen.kt


281 collapsed lines
1
@file:OptIn(ExperimentalMaterial3Api::class)
2

3
package com.example.app.screens
4

5
import androidx.compose.foundation.layout.fillMaxSize
6
import androidx.compose.foundation.layout.padding
7
import androidx.compose.material3.ExperimentalMaterial3Api
8
import androidx.compose.material3.Scaffold
9
import androidx.compose.material3.Text
10
import androidx.compose.material3.TopAppBar
11
import androidx.compose.runtime.Composable
12
import androidx.compose.runtime.remember
13
import androidx.compose.ui.Modifier
14
import androidx.compose.ui.res.stringResource
15
import com.arcgismaps.Color
16
import com.arcgismaps.data.ServiceFeatureTable
17
import com.arcgismaps.mapping.ArcGISMap
18
import com.arcgismaps.mapping.BasemapStyle
19
import com.arcgismaps.mapping.Viewpoint
20
import com.arcgismaps.mapping.labeling.ArcadeLabelExpression
21
import com.arcgismaps.mapping.labeling.LabelDefinition
22
import com.arcgismaps.mapping.layers.FeatureLayer
23
import com.arcgismaps.mapping.symbology.ClassBreak
24
import com.arcgismaps.mapping.symbology.ClassBreaksRenderer
25
import com.arcgismaps.mapping.symbology.FontStyle
26
import com.arcgismaps.mapping.symbology.FontWeight
27
import com.arcgismaps.mapping.symbology.PictureMarkerSymbol
28
import com.arcgismaps.mapping.symbology.SimpleFillSymbol
29
import com.arcgismaps.mapping.symbology.SimpleFillSymbolStyle
30
import com.arcgismaps.mapping.symbology.SimpleLineSymbol
31
import com.arcgismaps.mapping.symbology.SimpleLineSymbolStyle
32
import com.arcgismaps.mapping.symbology.SimpleRenderer
33
import com.arcgismaps.mapping.symbology.TextSymbol
34
import com.arcgismaps.mapping.symbology.UniqueValue
35
import com.arcgismaps.mapping.symbology.UniqueValueRenderer
36
import com.arcgismaps.toolkit.geoviewcompose.MapView
37
import com.example.app.R
38

39
@Composable
40
fun MainScreen() {
41
    val map = remember {
42
        createMap()
43
    }
44
    Scaffold(
45
        topBar = { TopAppBar(title = { Text(text = stringResource(id = R.string.app_name)) }) }
46
    ) {
47
        MapView(
48
            modifier = Modifier.fillMaxSize().padding(it),
49
            arcGISMap = map
50
        )
51
    }
52
}
53

54
fun createMap(): ArcGISMap {
55

56
    val parksAndOpenSpaces =
57
        "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Parks_and_Open_Space/FeatureServer/0"
58
    val trails =
59
        "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Trails/FeatureServer/0"
60
    val trailheads =
61
        "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Trailheads/FeatureServer/0"
62
    val trailheadImage =
63
        "https://static.arcgis.com/images/Symbols/NPS/npsPictograph_0231b.png"
64

65
    return ArcGISMap(BasemapStyle.ArcGISTopographic).apply {
66
        initialViewpoint = Viewpoint(
67
            latitude = 34.0270,
68
            longitude = -118.8050,
69
            scale = 72000.0
70
        )
71

72
        operationalLayers.addAll(
73

74
            listOf(
75

76
                createOpenSpaceLayer(parksAndOpenSpaces),
77

78
                createTrailsLayer(trails),
79

80
                createBikeOnlyTrailsLayer(trails),
81

82
                createNoBikeTrailsLayer(trails),
83

84
            )
85

86
        )
87

88
    }
89
}
90

91
fun createFeatureLayer(featureServiceUri: String): FeatureLayer {
92
    // Create a service feature table from a Uri
93
    val serviceFeatureTable = ServiceFeatureTable(featureServiceUri)
94
    // Return a feature layer created from the service feature table
95
    return FeatureLayer.createWithFeatureTable(serviceFeatureTable)
96
}
97

98
fun createOpenSpaceLayer(featureServiceUri: String): FeatureLayer {
99
    // Create fill symbol objects to represent the parks and open spaces layer
100
    val magentaFillSymbol = SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.fromRgba(255, 0, 255), null)
101
    val greenFillSymbol = SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.green, null)
102
    val blueFillSymbol = SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.fromRgba(0, 0, 255), null)
103
    val redFillSymbol = SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.red, null)
104

105
    // Create a unique value for natural areas, regional open spaces, local parks, and regional recreation parks
106
    val naturalAreas = UniqueValue(
107
        description = "Natural Areas",
108
        label = "Natural Areas",
109
        symbol = magentaFillSymbol,
110
        values = listOf("Natural Areas")
111
    )
112
    val regionalOpenSpace = UniqueValue(
113
        description = "Regional Open Space",
114
        label = "Regional Open Space",
115
        symbol = greenFillSymbol,
116
        values = listOf("Regional Open Space")
117
    )
118
    val localPark = UniqueValue(
119
        description = "Local Park",
120
        label = "Local Park",
121
        symbol = blueFillSymbol,
122
        values = listOf("Local Park")
123
    )
124
    val regionalRecreationPark = UniqueValue(
125
        description = "Regional Recreation Park",
126
        label = "Regional Recreation Park",
127
        symbol = redFillSymbol,
128
        values = listOf("Regional Recreation Park")
129
    )
130
    // Create a unique value list with the fill symbols
131
    val uniqueValuesList = listOf(
132
        naturalAreas,
133
        regionalOpenSpace,
134
        localPark,
135
        regionalRecreationPark
136
    )
137

138
    // Create and assign a unique value renderer to the feature layer
139
    val openSpacesUniqueValueRenderer =
140
        UniqueValueRenderer(
141
            fieldNames = listOf("TYPE"),
142
            uniqueValues = uniqueValuesList,
143
            defaultLabel = "Open Spaces",
144
            defaultSymbol = null
145
        )
146

147
    // Create a parks and open spaces feature layer
148
    val featureLayer = createFeatureLayer(featureServiceUri).apply {
149
        // Style the feature layer using the unique value renderer
150
        renderer = openSpacesUniqueValueRenderer
151
        // Set the layer opacity to semi-transparent
152
        opacity = 0.2f
153
    }
154

155
    return featureLayer
156
}
157

158
fun createTrailsLayer(featureServiceUri: String): FeatureLayer {
159
    // Create simple symbol objects to represent the trails layer
160
    val firstClassSymbol = SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.fromRgba(255, 0, 255), 3.0f)
161
    val secondClassSymbol = SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.fromRgba(255, 0, 255), 4.0f)
162
    val thirdClassSymbol = SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.fromRgba(255, 0, 255), 5.0f)
163
    val fourthClassSymbol = SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.fromRgba(255, 0, 255), 6.0f)
164
    val fifthClassSymbol = SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.fromRgba(255, 0, 255), 7.0f)
165

166
    // Create 5 class breaks
167
    val firstClassBreak = ClassBreak(
168
        description = "Under 500",
169
        label = "0 - 500",
170
        minValue = 0.0,
171
        maxValue = 500.0,
172
        symbol = firstClassSymbol
173
    )
174
    val secondClassBreak = ClassBreak(
175
        description = "501 to 1000",
176
        label = "501 - 1000",
177
        minValue = 501.0,
178
        maxValue = 1000.0,
179
        symbol = secondClassSymbol
180
    )
181
    val thirdClassBreak = ClassBreak(
182
        description = "1001 to 1500",
183
        label = "1001 - 1500",
184
        minValue = 1001.0,
185
        maxValue = 1500.0,
186
        symbol = thirdClassSymbol
187
    )
188
    val fourthClassBreak = ClassBreak(
189
        description = "1501 to 2000",
190
        label = "1501 - 2000",
191
        minValue = 1501.0,
192
        maxValue = 2000.0,
193
        symbol = fourthClassSymbol
194
    )
195
    val fifthClassBreak = ClassBreak(
196
        description = "2001 to 2300",
197
        label = "2001 - 2300",
198
        minValue = 2001.0,
199
        maxValue = 2300.0,
200
        symbol = fifthClassSymbol
201
    )
202
    val elevationBreaks = listOf(
203
        firstClassBreak,
204
        secondClassBreak,
205
        thirdClassBreak,
206
        fourthClassBreak,
207
        fifthClassBreak
208
    )
209

210
    // Create and assign a class breaks renderer to the feature layer
211
    val elevationClassBreaksRenderer = ClassBreaksRenderer("ELEV_GAIN", elevationBreaks)
212

213
    // Create a trails feature layer
214
    val featureLayer = createFeatureLayer(featureServiceUri).apply {
215
        // Style the feature layer using the class breaks renderer
216
        renderer = elevationClassBreaksRenderer
217
        // Set the layer opacity to semi-transparent
218
        opacity = 0.75f
219
    }
220

221
    return featureLayer
222
}
223

224
fun createBikeOnlyTrailsLayer(featureServiceUri: String): FeatureLayer {
225
    // Create blue dot style simple line symbol to represent the bike trails
226
    val bikeTrailSymbol = SimpleLineSymbol(SimpleLineSymbolStyle.Dot, Color.fromRgba(0, 0, 255), 2.0f)
227
    // Create a simple renderer for the feature layer
228
    val bikeTrailRenderer = SimpleRenderer(bikeTrailSymbol)
229

230
    // Create a bike trails feature layer
231
    val featureLayer = createFeatureLayer(featureServiceUri).apply {
232
        // Style the feature layer using the simple renderer
233
        renderer = bikeTrailRenderer
234
        // Write a definition expression to filter for trails that permit the use of bikes
235
        definitionExpression = "USE_BIKE = 'Yes'"
236
    }
237

238
    return featureLayer
239
}
240

241
fun createNoBikeTrailsLayer(featureServiceUri: String): FeatureLayer {
242
    // Create a yellow dot style simple line symbol to represent no bike trails
243
    val noBikeTrailSymbol = SimpleLineSymbol(SimpleLineSymbolStyle.Dot, Color.fromRgba(255, 255, 0), 2.0f)
244
    // Create a simple renderer for the feature layer
245
    val noBikeTrailRenderer = SimpleRenderer(noBikeTrailSymbol)
246

247
    // Create a no-bike trails feature layer
248
    val featureLayer = createFeatureLayer(featureServiceUri).apply {
249
        // Style the feature layer using the simple renderer
250
        renderer = noBikeTrailRenderer
251
        // Write a definition expression to filter for trails that don't permit the use of bikes
252
        definitionExpression = "USE_BIKE = 'No'"
253
    }
254

255
    return featureLayer
256
}
257

258
fun createTrailheadsLayer(featureServiceUri: String, trailheadImage: String): FeatureLayer {
259
    // Create a new picture marker symbol that uses the trailhead image
260
    val pictureMarkerSymbol = PictureMarkerSymbol(trailheadImage).apply {
261
        height = 18.0f
262
        width = 18.0f
263
    }
264
    // Create a new simple renderer based on the picture marker symbol
265
    val simpleRenderer = SimpleRenderer(pictureMarkerSymbol)
266
    // Create the label definition
267
    val trailHeadsDefinition = makeLabelDefinition(labelAttribute = "TRL_NAME")
268

269
    // Create a trail heads feature layer
270
    val featureLayer: FeatureLayer = createFeatureLayer(featureServiceUri).apply {
271
        // Style the feature layer using the simple renderer
272
        renderer = simpleRenderer
273
        // Set labeling on the layer to be enabled
274
        labelsEnabled = true
275
        // Add the label definition to the layer's label definition collection
276
        labelDefinitions.add(trailHeadsDefinition)
277
    }
278

279
    return featureLayer
280
}
281

282
fun makeLabelDefinition(labelAttribute: String): LabelDefinition {
283
    // Create a text symbol for the label definition
284
    val labelTextSymbol = TextSymbol().apply {
285
        color = Color.white
286
        size = 12.0f
287
        haloColor = Color.red
288
        haloWidth = 1.0f
289
        fontFamily = "Arial"
290
        fontStyle = FontStyle.Italic
291
        fontWeight = FontWeight.Normal
292
    }
293

294
    // Create an Arcade label expression based on the field name
295
    val labelExpression = ArcadeLabelExpression("\$feature.$labelAttribute")
296

297
    // Create and return the label definition
298
    return LabelDefinition(labelExpression, labelTextSymbol)
299
}

Update createMap() to call the new createTrailheadsLayer() function.

MainScreen.kt


53 collapsed lines
1
@file:OptIn(ExperimentalMaterial3Api::class)
2

3
package com.example.app.screens
4

5
import androidx.compose.foundation.layout.fillMaxSize
6
import androidx.compose.foundation.layout.padding
7
import androidx.compose.material3.ExperimentalMaterial3Api
8
import androidx.compose.material3.Scaffold
9
import androidx.compose.material3.Text
10
import androidx.compose.material3.TopAppBar
11
import androidx.compose.runtime.Composable
12
import androidx.compose.runtime.remember
13
import androidx.compose.ui.Modifier
14
import androidx.compose.ui.res.stringResource
15
import com.arcgismaps.Color
16
import com.arcgismaps.data.ServiceFeatureTable
17
import com.arcgismaps.mapping.ArcGISMap
18
import com.arcgismaps.mapping.BasemapStyle
19
import com.arcgismaps.mapping.Viewpoint
20
import com.arcgismaps.mapping.labeling.ArcadeLabelExpression
21
import com.arcgismaps.mapping.labeling.LabelDefinition
22
import com.arcgismaps.mapping.layers.FeatureLayer
23
import com.arcgismaps.mapping.symbology.ClassBreak
24
import com.arcgismaps.mapping.symbology.ClassBreaksRenderer
25
import com.arcgismaps.mapping.symbology.FontStyle
26
import com.arcgismaps.mapping.symbology.FontWeight
27
import com.arcgismaps.mapping.symbology.PictureMarkerSymbol
28
import com.arcgismaps.mapping.symbology.SimpleFillSymbol
29
import com.arcgismaps.mapping.symbology.SimpleFillSymbolStyle
30
import com.arcgismaps.mapping.symbology.SimpleLineSymbol
31
import com.arcgismaps.mapping.symbology.SimpleLineSymbolStyle
32
import com.arcgismaps.mapping.symbology.SimpleRenderer
33
import com.arcgismaps.mapping.symbology.TextSymbol
34
import com.arcgismaps.mapping.symbology.UniqueValue
35
import com.arcgismaps.mapping.symbology.UniqueValueRenderer
36
import com.arcgismaps.toolkit.geoviewcompose.MapView
37
import com.example.app.R
38

39
@Composable
40
fun MainScreen() {
41
    val map = remember {
42
        createMap()
43
    }
44
    Scaffold(
45
        topBar = { TopAppBar(title = { Text(text = stringResource(id = R.string.app_name)) }) }
46
    ) {
47
        MapView(
48
            modifier = Modifier.fillMaxSize().padding(it),
49
            arcGISMap = map
50
        )
51
    }
52
}
53

54
fun createMap(): ArcGISMap {
55

56
    val parksAndOpenSpaces =
57
        "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Parks_and_Open_Space/FeatureServer/0"
58
    val trails =
59
        "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Trails/FeatureServer/0"
60
    val trailheads =
61
        "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Trailheads/FeatureServer/0"
62
    val trailheadImage =
63
        "https://static.arcgis.com/images/Symbols/NPS/npsPictograph_0231b.png"
64

65
    return ArcGISMap(BasemapStyle.ArcGISTopographic).apply {
66
        initialViewpoint = Viewpoint(
67
            latitude = 34.0270,
68
            longitude = -118.8050,
69
            scale = 72000.0
70
        )
71

72
        operationalLayers.addAll(
73

74
            listOf(
75

76
                createOpenSpaceLayer(parksAndOpenSpaces),
77

78
                createTrailsLayer(trails),
79

80
                createBikeOnlyTrailsLayer(trails),
81

82
                createNoBikeTrailsLayer(trails),
83

84
                createTrailheadsLayer(trailheads, trailheadImage)
85

86
            )
87

88
        )
89

90
    }
91
}
210 collapsed lines
92

93
fun createFeatureLayer(featureServiceUri: String): FeatureLayer {
94
    // Create a service feature table from a Uri
95
    val serviceFeatureTable = ServiceFeatureTable(featureServiceUri)
96
    // Return a feature layer created from the service feature table
97
    return FeatureLayer.createWithFeatureTable(serviceFeatureTable)
98
}
99

100
fun createOpenSpaceLayer(featureServiceUri: String): FeatureLayer {
101
    // Create fill symbol objects to represent the parks and open spaces layer
102
    val magentaFillSymbol = SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.fromRgba(255, 0, 255), null)
103
    val greenFillSymbol = SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.green, null)
104
    val blueFillSymbol = SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.fromRgba(0, 0, 255), null)
105
    val redFillSymbol = SimpleFillSymbol(SimpleFillSymbolStyle.Solid, Color.red, null)
106

107
    // Create a unique value for natural areas, regional open spaces, local parks, and regional recreation parks
108
    val naturalAreas = UniqueValue(
109
        description = "Natural Areas",
110
        label = "Natural Areas",
111
        symbol = magentaFillSymbol,
112
        values = listOf("Natural Areas")
113
    )
114
    val regionalOpenSpace = UniqueValue(
115
        description = "Regional Open Space",
116
        label = "Regional Open Space",
117
        symbol = greenFillSymbol,
118
        values = listOf("Regional Open Space")
119
    )
120
    val localPark = UniqueValue(
121
        description = "Local Park",
122
        label = "Local Park",
123
        symbol = blueFillSymbol,
124
        values = listOf("Local Park")
125
    )
126
    val regionalRecreationPark = UniqueValue(
127
        description = "Regional Recreation Park",
128
        label = "Regional Recreation Park",
129
        symbol = redFillSymbol,
130
        values = listOf("Regional Recreation Park")
131
    )
132
    // Create a unique value list with the fill symbols
133
    val uniqueValuesList = listOf(
134
        naturalAreas,
135
        regionalOpenSpace,
136
        localPark,
137
        regionalRecreationPark
138
    )
139

140
    // Create and assign a unique value renderer to the feature layer
141
    val openSpacesUniqueValueRenderer =
142
        UniqueValueRenderer(
143
            fieldNames = listOf("TYPE"),
144
            uniqueValues = uniqueValuesList,
145
            defaultLabel = "Open Spaces",
146
            defaultSymbol = null
147
        )
148

149
    // Create a parks and open spaces feature layer
150
    val featureLayer = createFeatureLayer(featureServiceUri).apply {
151
        // Style the feature layer using the unique value renderer
152
        renderer = openSpacesUniqueValueRenderer
153
        // Set the layer opacity to semi-transparent
154
        opacity = 0.2f
155
    }
156

157
    return featureLayer
158
}
159

160
fun createTrailsLayer(featureServiceUri: String): FeatureLayer {
161
    // Create simple symbol objects to represent the trails layer
162
    val firstClassSymbol = SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.fromRgba(255, 0, 255), 3.0f)
163
    val secondClassSymbol = SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.fromRgba(255, 0, 255), 4.0f)
164
    val thirdClassSymbol = SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.fromRgba(255, 0, 255), 5.0f)
165
    val fourthClassSymbol = SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.fromRgba(255, 0, 255), 6.0f)
166
    val fifthClassSymbol = SimpleLineSymbol(SimpleLineSymbolStyle.Solid, Color.fromRgba(255, 0, 255), 7.0f)
167

168
    // Create 5 class breaks
169
    val firstClassBreak = ClassBreak(
170
        description = "Under 500",
171
        label = "0 - 500",
172
        minValue = 0.0,
173
        maxValue = 500.0,
174
        symbol = firstClassSymbol
175
    )
176
    val secondClassBreak = ClassBreak(
177
        description = "501 to 1000",
178
        label = "501 - 1000",
179
        minValue = 501.0,
180
        maxValue = 1000.0,
181
        symbol = secondClassSymbol
182
    )
183
    val thirdClassBreak = ClassBreak(
184
        description = "1001 to 1500",
185
        label = "1001 - 1500",
186
        minValue = 1001.0,
187
        maxValue = 1500.0,
188
        symbol = thirdClassSymbol
189
    )
190
    val fourthClassBreak = ClassBreak(
191
        description = "1501 to 2000",
192
        label = "1501 - 2000",
193
        minValue = 1501.0,
194
        maxValue = 2000.0,
195
        symbol = fourthClassSymbol
196
    )
197
    val fifthClassBreak = ClassBreak(
198
        description = "2001 to 2300",
199
        label = "2001 - 2300",
200
        minValue = 2001.0,
201
        maxValue = 2300.0,
202
        symbol = fifthClassSymbol
203
    )
204
    val elevationBreaks = listOf(
205
        firstClassBreak,
206
        secondClassBreak,
207
        thirdClassBreak,
208
        fourthClassBreak,
209
        fifthClassBreak
210
    )
211

212
    // Create and assign a class breaks renderer to the feature layer
213
    val elevationClassBreaksRenderer = ClassBreaksRenderer("ELEV_GAIN", elevationBreaks)
214

215
    // Create a trails feature layer
216
    val featureLayer = createFeatureLayer(featureServiceUri).apply {
217
        // Style the feature layer using the class breaks renderer
218
        renderer = elevationClassBreaksRenderer
219
        // Set the layer opacity to semi-transparent
220
        opacity = 0.75f
221
    }
222

223
    return featureLayer
224
}
225

226
fun createBikeOnlyTrailsLayer(featureServiceUri: String): FeatureLayer {
227
    // Create blue dot style simple line symbol to represent the bike trails
228
    val bikeTrailSymbol = SimpleLineSymbol(SimpleLineSymbolStyle.Dot, Color.fromRgba(0, 0, 255), 2.0f)
229
    // Create a simple renderer for the feature layer
230
    val bikeTrailRenderer = SimpleRenderer(bikeTrailSymbol)
231

232
    // Create a bike trails feature layer
233
    val featureLayer = createFeatureLayer(featureServiceUri).apply {
234
        // Style the feature layer using the simple renderer
235
        renderer = bikeTrailRenderer
236
        // Write a definition expression to filter for trails that permit the use of bikes
237
        definitionExpression = "USE_BIKE = 'Yes'"
238
    }
239

240
    return featureLayer
241
}
242

243
fun createNoBikeTrailsLayer(featureServiceUri: String): FeatureLayer {
244
    // Create a yellow dot style simple line symbol to represent no bike trails
245
    val noBikeTrailSymbol = SimpleLineSymbol(SimpleLineSymbolStyle.Dot, Color.fromRgba(255, 255, 0), 2.0f)
246
    // Create a simple renderer for the feature layer
247
    val noBikeTrailRenderer = SimpleRenderer(noBikeTrailSymbol)
248

249
    // Create a no-bike trails feature layer
250
    val featureLayer = createFeatureLayer(featureServiceUri).apply {
251
        // Style the feature layer using the simple renderer
252
        renderer = noBikeTrailRenderer
253
        // Write a definition expression to filter for trails that don't permit the use of bikes
254
        definitionExpression = "USE_BIKE = 'No'"
255
    }
256

257
    return featureLayer
258
}
259

260
fun createTrailheadsLayer(featureServiceUri: String, trailheadImage: String): FeatureLayer {
261
    // Create a new picture marker symbol that uses the trailhead image
262
    val pictureMarkerSymbol = PictureMarkerSymbol(trailheadImage).apply {
263
        height = 18.0f
264
        width = 18.0f
265
    }
266
    // Create a new simple renderer based on the picture marker symbol
267
    val simpleRenderer = SimpleRenderer(pictureMarkerSymbol)
268
    // Create the label definition
269
    val trailHeadsDefinition = makeLabelDefinition(labelAttribute = "TRL_NAME")
270

271
    // Create a trail heads feature layer
272
    val featureLayer: FeatureLayer = createFeatureLayer(featureServiceUri).apply {
273
        // Style the feature layer using the simple renderer
274
        renderer = simpleRenderer
275
        // Set labeling on the layer to be enabled
276
        labelsEnabled = true
277
        // Add the label definition to the layer's label definition collection
278
        labelDefinitions.add(trailHeadsDefinition)
279
    }
280

281
    return featureLayer
282
}
283

284
fun makeLabelDefinition(labelAttribute: String): LabelDefinition {
285
    // Create a text symbol for the label definition
286
    val labelTextSymbol = TextSymbol().apply {
287
        color = Color.white
288
        size = 12.0f
289
        haloColor = Color.red
290
        haloWidth = 1.0f
291
        fontFamily = "Arial"
292
        fontStyle = FontStyle.Italic
293
        fontWeight = FontWeight.Normal
294
    }
295

296
    // Create an Arcade label expression based on the field name
297
    val labelExpression = ArcadeLabelExpression("\$feature.$labelAttribute")
298

299
    // Create and return the label definition
300
    return LabelDefinition(labelExpression, labelTextSymbol)
301
}

Click Run > Run > app to run the app.

When the app opens, all the layers you’ve created and symbolized are displayed on the map.

Parks and open spaces are displayed with four unique symbols
Trails use different symbols (line widths) depending on trail elevation
Trails are blue where bikes are permitted and red where they are prohibited
Trailheads are displayed with a hiker icon and labels display each trail’s name

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

Option 2: Download the solution

Click the Download solution link in the right-hand side of this page.
Unzip the file to a location on your machine.
Run Android Studio.
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 services ArcGIS 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 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 authentication API 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 authentication User 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 Platform An 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 Online An 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.

You can implement API key authentication or user authentication in this tutorial. Compare the differences below:

API key authentication API key authentication is a type of authentication that uses an API key to authenticate requests to ArcGIS services and secure portal items. Learn more

Users are not required to sign in.
Requires creating an API key credential API key credentials are an item that contains the parameters used to create and manage long-lived access tokens for API key authentication. They are a type of developer credential. Learn more with the correct privileges.
API keys An API key is a long-lived access token created using API key credentials. They are valid for up to one year and are typically embedded directly into client applications. Learn more are long-lived access tokens.
Service usage is billed to the API key owner/developer.
Simplest authentication method to implement.
Recommended approach for new ArcGIS developers.

Learn more in API key authentication.

User authentication User 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

Users are required to sign in with an ArcGIS account An ArcGIS account is an identity with a user type and set of privileges that can access specific ArcGIS products, tools, APIs, services, and resources. The main account types that can be used for development are an ArcGIS Location Platform account, ArcGIS Online account, and ArcGIS Enterprise account. ArcGIS Location Platform and ArcGIS Online accounts are also associated with a subscription. Learn more .
User accounts must have privilege 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 to access the ArcGIS services A service, also known as an ArcGIS service, is software that supports an ArcGIS REST API and provides geospatial functionality or data. A service can be hosted by Esri or in ArcGIS Enterprise. Learn more used in application.
Requires creating OAuth credentials OAuth credentials are an item that contains parameters required to implement user authentication or app authentication, including a client_id, client_secret, and redirect URIs. They are a type of developer credential. Learn more .
Application uses a redirect URL and client ID.
Service usage is billed to the organization of the user signed into the application.

Learn more in User authentication.

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 token An 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 privileges 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 to access the secure resources used in this tutorial.

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
Copy and paste the API key access token into a safe location. It will be used in a later step.

Create new OAuth credentials to access the secure resources used in this tutorial.

Complete the Create OAuth credentials for user authentication tutorial to obtain a Client ID and Redirect URL.

A Client ID uniquely identifies your app on the authenticating server. If the server cannot find an app with the provided Client ID, it will not proceed with authentication.
The Redirect URL (also referred to as a callback url) is used to identify a response from the authenticating server when the system returns control back to your app after an OAuth login. Since it does not necessarily represent a valid endpoint that a user could navigate to, the redirect URL can use a custom scheme, such as my-app://auth. It is important to make sure the redirect URL used in your app’s code matches a redirect URL configured on the authenticating server.
Copy and paste the Client ID and Redirect URL into a safe location. They will be used in a later step.

All users that access this application need account privileges 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 to access the ArcGIS Basemap Styles service The ArcGIS Basemap Styles service, also referred to as the Basemap Styles service, is a location service that provides basemap styles and data for the world. It returns styles as Mapbox styles and web maps, and data as vector tiles and/or map tiles. It supports all of the styles in the ArcGIS Basemap style and Open Basemap style family. An ArcGIS Location Platform or ArcGIS Online account is required to use the service. Learn more .

Set developer credentials in the solution

To allow your app users to access ArcGIS location services ArcGIS 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 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.

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.

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

MainActivity.kt

class MainActivity : ComponentActivity() {
    private enum class AuthenticationMode { API_KEY, USER_AUTH }

    private val authenticationMode = AuthenticationMode.USER_AUTH

Set your clientID and redirectURL values. You must use the RedirectURL that you supplied for your app in the user authentication part of the Set up authentication step.

MainActivity.kt

            AuthenticationMode.USER_AUTH -> {
                authenticatorState.oAuthUserConfigurations = listOf(
                    OAuthUserConfiguration(
                        portalUrl = "https://www.arcgis.com",

                        clientId = "YOUR_CLIENT_ID",
                        redirectUrl = "YOUR_REDIRECT_URL"

                    )
                )

Open app > manifests > AndroidManifest.xml.

Set the android:scheme and android:host using the scheme and host from your RedirectURL.

A redirectURL is composed of a scheme and a host component. The format for the redirect url is scheme://host. For example, if the redirect url is myscheme://myhost then the scheme is myscheme and the host is myhost.

AndroidManifest.xml

41 collapsed lines
<?xml version="1.0" encoding="utf-8"?>

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools">

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

    <application
        android:allowBackup="true"
        android:dataExtractionRules="@xml/data_extraction_rules"
        android:fullBackupContent="@xml/backup_rules"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/Theme.Tutorial"
        tools:targetApi="31">
        <activity
            android:name=".MainActivity"
            android:exported="true"
            android:label="@string/app_name"
            android:theme="@style/Theme.Tutorial">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>

        </activity>

        <activity
            android:name="com.arcgismaps.toolkit.authentication.AuthenticationActivity"
            android:configChanges="keyboard|keyboardHidden|orientation|screenSize"
            android:exported="true"
            android:launchMode="singleTop" >
            <intent-filter>
                <action android:name="android.intent.action.VIEW" />

                <category android:name="android.intent.category.DEFAULT" />
                <category android:name="android.intent.category.BROWSABLE" />

                <data
                    android:scheme="your_redirect_url_scheme"
                    android:host="your_redirect_url_host" />
6 collapsed lines

            </intent-filter>
        </activity>

    </application>
</manifest>

Best Practice: The OAuth credentials are 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.

When the app opens, all the layers you’ve created and symbolized are displayed on the map.

Parks and open spaces are displayed with four unique symbols
Trails use different symbols (line widths) depending on trail elevation
Trails are blue where bikes are permitted and red where they are prohibited
Trailheads are displayed with a hiker icon and labels display each trail’s name

What’s next?

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

Styles and data visualizationRender features and graphics in 3D NextQuery