Style a feature layer

Learn how to apply renderers and label definitions to a feature layer based on attribute values.

style a feature layer

Applications can display feature layer data with different styles to enhance the visualization. The type of AGSRenderer you choose depends on your application. An AGSSimpleRenderer applies the same symbol to all features, an AGSUniqueValueRenderer applies a different symbol to each unique attribute value, and an AGSClassBreaksRenderer 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 AGSLabelDefinition 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 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

The following are required for this tutorial:

  1. An ArcGIS account to access your API keys. If you don't have an account, sign up for free.
  2. Your system meets the system requirements.

Steps

Open the Xcode project

  1. To start the tutorial, complete the Display a map tutorial or download and unzip the solution.

  2. Open the .xcodeproj file in Xcode.

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

Add app configuration constants

Create a configuration file to specify constants that can be used by the app to connect to data and resources.

  1. Add a new swift file named AppConfiguration.swift.

  2. Create four static URLs: 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.

    AppConfiguration.swift
    Use dark colors for code blocks
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    extension URL {
        static let parksAndOpenSpaces = URL(string: "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Parks_and_Open_Space/FeatureServer/0")!
        static let trails = URL(string: "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Trails/FeatureServer/0")!
        static let trailheads = URL(string: "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Trailheads/FeatureServer/0")!
        static let trailheadImage = URL(string: "https://static.arcgis.com/images/Symbols/NPS/npsPictograph_0231b.png")!
    }

Create helper method to add feature layer to map

Add a helper method that creates a feature layer from a given URL and adds it to the list of map's operational layers.

  1. Open ViewController.swift in the Project Navigator. Add a new method named addFeatureLayer(url: URL).

    ViewController.swift
    Use dark colors for code blocks
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
        private func addFeatureLayer(url: URL) -> AGSFeatureLayer {
            let serviceFeatureTable = AGSServiceFeatureTable(url: url)
            let featureLayer = AGSFeatureLayer(featureTable: serviceFeatureTable)
            mapView.map?.operationalLayers.add(featureLayer)
            return featureLayer
        }
    

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.

  1. Add a new method named addOpenSpaceLayer() in ViewController.swift.

    ViewController.swift
    Use dark colors for code blocks
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
        private func addOpenSpaceLayer() {
            // Create a parks and open spaces feature layer, and add it to mapview.
            let featureLayer = addFeatureLayer(url: .parksAndOpenSpaces)
    
            // Create fill symbols.
            let purpleFillSymbol = AGSSimpleFillSymbol(style: .solid, color: .purple, outline: .none)
            let greenFillSymbol = AGSSimpleFillSymbol(style: .solid, color: .green, outline: .none)
            let blueFillSymbol = AGSSimpleFillSymbol(style: .solid, color: .blue, outline: .none)
            let redFillSymbol = AGSSimpleFillSymbol(style: .solid, color: .red, outline: .none)
    
            // Create a unique value for natural areas, regional open spaces, local parks & regional recreation parks.
            let naturalAreas = AGSUniqueValue(description: "Natural Areas", label: "Natural Areas", symbol: purpleFillSymbol, values: ["Natural Areas"])
            let regionalOpenSpace = AGSUniqueValue(description: "Regional Open Space", label: "Regional Open Space", symbol: greenFillSymbol, values: ["Regional Open Space"])
            let localPark = AGSUniqueValue(description: "Local Park", label: "Local Park", symbol: blueFillSymbol, values: ["Local Park"])
            let regionalRecreationPark = AGSUniqueValue(description: "Regional Recreation Park", label: "Regional Recreation Park", symbol: redFillSymbol, values: ["Regional Recreation Park"])
    
            // Create and assign a unique value renderer to the feature layer.
            let openSpacesUniqueValueRenderer = AGSUniqueValueRenderer(fieldNames: ["TYPE"], uniqueValues: [naturalAreas, regionalOpenSpace, localPark, regionalRecreationPark], defaultLabel: "Open Spaces", defaultSymbol: .none)
            featureLayer.renderer = openSpacesUniqueValueRenderer
    
            // Set the layer opacity to semi-transparent.
            featureLayer.opacity = 0.2
        }
    
  2. Update viewDidLoad() to call the new addOpenSpaceLayer() method.

    ViewController.swift
    Use dark colors for code blocks
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
        override func viewDidLoad() {
            super.viewDidLoad()
            setupMap()
    
            addOpenSpaceLayer()
    
        }
    
  3. Press Command + R 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.

  1. Add a new method named addTrailsLayer().

    ViewController.swift
    Use dark colors for code blocks
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
        private func addTrailsLayer() {
            // Create a trails feature layer, and add it to mapview
            let featureLayer = addFeatureLayer(url: .trails)
    
            // Create simple line symbols.
            let firstClassSymbol = AGSSimpleLineSymbol(style: .solid, color: .purple, width: 3.0)
            let secondClassSymbol = AGSSimpleLineSymbol(style: .solid, color: .purple, width: 4.0)
            let thirdClassSymbol = AGSSimpleLineSymbol(style: .solid, color: .purple, width: 5.0)
            let fourthClassSymbol = AGSSimpleLineSymbol(style: .solid, color: .purple, width: 6.0)
            let fifthClassSymbol = AGSSimpleLineSymbol(style: .solid, color: .purple, width: 7.0)
    
            // Create 5 class breaks.
            let firstClassBreak = AGSClassBreak(description: "Under 500", label: "0 - 500", minValue: 0.0, maxValue: 500.0, symbol: firstClassSymbol)
            let secondClassBreak = AGSClassBreak(description: "501 to 1000", label: "501 - 1000", minValue: 501.0, maxValue: 1000.0, symbol: secondClassSymbol)
            let thirdClassBreak = AGSClassBreak(description: "1001 to 1500", label: "1001 - 1500", minValue: 1001.0, maxValue: 1500.0, symbol: thirdClassSymbol)
            let fourthClassBreak = AGSClassBreak(description: "1501 to 2000", label: "1501 - 2000", minValue: 1501.0, maxValue: 2000.0, symbol: fourthClassSymbol)
            let fifthClassBreak = AGSClassBreak(description: "2001 to 2300", label: "2001 - 2300", minValue: 2001.0, maxValue: 2300.0, symbol: fifthClassSymbol)
            let elevationBreaks = [firstClassBreak, secondClassBreak, thirdClassBreak, fourthClassBreak, fifthClassBreak]
    
            // Create and assign a class breaks renderer to the feature layer.
            let elevationClassBreaksRenderer = AGSClassBreaksRenderer(fieldName: "ELEV_GAIN", classBreaks: elevationBreaks)
            featureLayer.renderer = elevationClassBreaksRenderer
    
            // Set the layer opacity to semi-transparent.
            featureLayer.opacity = 0.75
        }
    
  2. Update viewDidLoad() to call the new addTrailsLayer() method.

    ViewController.swift
    Use dark colors for code blocks
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
        override func viewDidLoad() {
            super.viewDidLoad()
            setupMap()
    
            addOpenSpaceLayer()
    
            addTrailsLayer()
    
        }
    
  3. Press Command + R 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.

  1. Add a method with a definition expression to filter for trails that permit bikes.

    ViewController.swift
    Use dark colors for code blocks
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
        private func addBikeOnlyTrailsLayer() {
            // Create a trails feature layer, and add it to mapview.
            let featureLayer = addFeatureLayer(url: URL(string: "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Trails/FeatureServer/0")!)
    
            // Write a definition expression to filter for trails that do permit the use of bikes.
            featureLayer.definitionExpression = "USE_BIKE = 'Yes'"
    
            // Create and assign a simple renderer to the feature layer.
            let bikeTrailSymbol = AGSSimpleLineSymbol(style: .dot, color: .blue, width: 2.0)
            let bikeTrailRenderer = AGSSimpleRenderer(symbol: bikeTrailSymbol)
            featureLayer.renderer = bikeTrailRenderer
        }
    
  2. Add another method with a definition expression to filter for trails that don't allow bikes.

    ViewController.swift
    Use dark colors for code blocks
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
        private func addNoBikeTrailsLayer() {
            // Create a trails feature layer, and add it to mapview.
            let featureLayer = addFeatureLayer(url: URL(string: "https://services3.arcgis.com/GVgbJbqm8hXASVYi/arcgis/rest/services/Trails/FeatureServer/0")!)
            // Write a definition expression to filter for trails that don't permit the use of bikes.
            featureLayer.definitionExpression = "USE_BIKE = 'No'"
    
            // Create and assign a simple renderer to the feature layer.
            let noBikeTrailSymbol = AGSSimpleLineSymbol(style: .dot, color: .red, width: 2.0)
            let noBikeTrailRenderer = AGSSimpleRenderer(symbol: noBikeTrailSymbol)
            featureLayer.renderer = noBikeTrailRenderer
        }
    
  3. Update viewDidLoad() to call the new addBikeOnlyTrailsLayer() and addNoBikeTrailsLayer() methods.

    ViewController.swift
    Use dark colors for code blocks
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
        override func viewDidLoad() {
            super.viewDidLoad()
            setupMap()
    
            addOpenSpaceLayer()
    
            addTrailsLayer()
    
            addNoBikeTrailsLayer()
            addBikeOnlyTrailsLayer()
    
        }
    
  4. Press Command + R 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.

Add a layer with a label definition

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

  1. Create a helper method named makeLabelDefinition() to define a label defintion based on a specific attribute of the feature layer TRL_NAME. Also define label placement and symbol.

    ViewController.swift
    Use dark colors for code blocks
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
        private func makeLabelDefinition() -> AGSLabelDefinition {
    
            let trailHeadsTextSymbol = AGSTextSymbol()
            trailHeadsTextSymbol.color = .white
            trailHeadsTextSymbol.size = 20.0
            trailHeadsTextSymbol.haloColor = .red
            trailHeadsTextSymbol.haloWidth = 2.0
            trailHeadsTextSymbol.fontFamily = "Noto Sans"
            trailHeadsTextSymbol.fontStyle = .italic
            trailHeadsTextSymbol.fontWeight = .normal
    
            // Make an arcade label expression.
            let expression = "$feature.TRL_NAME"
            let arcadeLabelExpression = AGSArcadeLabelExpression(arcadeString: expression)
            let labelDefinition = AGSLabelDefinition(labelExpression: arcadeLabelExpression, textSymbol: trailHeadsTextSymbol)
            labelDefinition.placement = .pointAboveCenter
    
            return labelDefinition
        }
    
  2. Add a method named addTrailheadsLayer().

    Use an AGSPictureMarkerSymbol to draw a trailhead hiker image. Use the AGSLabelDefinition to label each trailhead by its name.

    ViewController.swift
    Use dark colors for code blocks
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
        private func addTrailheadsLayer() {
            let featureLayer = addFeatureLayer(url: .trailheads)
    
            let pictureMarkerSymbol = AGSPictureMarkerSymbol(url: .trailheadImage)
            pictureMarkerSymbol.height = 18.0
            pictureMarkerSymbol.width = 18.0
            let simpleRenderer = AGSSimpleRenderer(symbol: pictureMarkerSymbol)
            featureLayer.renderer = simpleRenderer
    
            featureLayer.labelsEnabled = true
            let trailHeadsDefinition = makeLabelDefinition()
            featureLayer.labelDefinitions.addObjects(from: [trailHeadsDefinition])
        }
    
  3. Update viewDidLoad() to call the new addTrailheadsLayer() method.

    ViewController.swift
    Use dark colors for code blocks
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
        override func viewDidLoad() {
            super.viewDidLoad()
            setupMap()
    
            addOpenSpaceLayer()
    
            addTrailsLayer()
    
            addNoBikeTrailsLayer()
            addBikeOnlyTrailsLayer()
    
            addTrailheadsLayer()
    
        }
    
  4. Press Command + R 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:

Your browser is no longer supported. Please upgrade your browser for the best experience. See our browser deprecation post for more details.