Search for an address

Before starting this tutorial:

1. You need an ArcGIS Location Platform or ArcGIS Online account.

2. Your system meets the system requirements.

Option 1: Develop the code

To start the tutorial, complete the Display a map tutorial. This creates a map to display the Santa Monica Mountains in California using the topographic basemap from 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 .

Continue with the following instructions to add a search bar to the user interface and search for an address or place using the ArcGIS Geocoding service A geocoding service is a service that can search for addresses, place addresses, businesses, reverse geocode coordinates to addresses, provide suggestions for places, and perform bulk geocoding. It is hosted by Esri as the ArcGIS Geocoding service and can also be hosted in ArcGIS Enterprise. Learn more . First, you need to set the develop credentials in your app so that your app users can access the ArcGIS Geocoding service A geocoding service is a service that can search for addresses, place addresses, businesses, reverse geocode coordinates to addresses, provide suggestions for places, and perform bulk geocoding. It is hosted by Esri as the ArcGIS Geocoding service and can also be hosted in ArcGIS Enterprise. Learn more .

Set developer credentials

If you implemented 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 in the Display a map tutorial, the API key access token will only have the Basemaps privilege. The Search for an address tutorial requires the Geocoding privilege to search for an address using the LocatorTask. To create an API Key access token that has the Basemaps and Geocoding privileges, see the Set up authentication step and then follow the instructions below.

Update the map

1. In Xcode, in the Project Navigator, click ContentView.swift.

2. In the editor, change the map and viewpoint into two separate @State variables so that the viewpoint can be changed as the geocode results change.

   ContentView.swift

   1
   struct ContentView: View {
   2
   
   3
       @State private var map = Map(basemapStyle: .arcGISImagery)
   4
       @State private var viewpoint: Viewpoint? = Viewpoint(
   5
           latitude: 34.02700,
   6
           longitude: -118.80500,
   7
           scale: 72_000
   8
       )

3. Create a private class named Model of type ObservableObject and add a @StateObject variable of the Model to the ContentView. See the programming patterns page for more information on how to manage states.

   ContentView.swift

   1
   import SwiftUI
   2
   
   3
   import ArcGIS
   4
   
   5
   private class Model: ObservableObject {
   6
   
   7
   }
   8
   
   9
   struct ContentView: View {
   10
   
   11
       @StateObject private var model = Model()
   12
   
   13
   }

4. Create a GraphicsOverlay named graphicsOverlay in the Model class. A graphics overlay A graphics overlay is a client-side, temporary container of graphics to display on a map view or scene view. Learn more is a container for graphics A graphic is a visual element composed of a geometry, symbol, and attributes that is displayed on a map or scene. Learn more .

   More info

   A graphics overlay A graphics overlay is a client-side, temporary container of graphics to display on a map view or scene view. Learn more is a container for graphics A graphic is a visual element composed of a geometry, symbol, and attributes that is displayed on a map or scene. Learn more . It is used with a map view A map view is a user interface that displays map layers and graphics in 2D. It controls the area (extent) of the map that is visible and supports user interactions such as pan and zoom. Learn more to display graphics on a map A map is a collection of layers that are displayed in 2D. It is typically composed of a basemap layer and data layers. Learn more . You can add more than one graphics overlay to a map view. Graphics overlays are displayed on top of all the other layers A layer is a reference to a collection of geographic data that is used to access and display data. The data for layers are typically provided by the basemap layer service and data services. Learn more .

   ContentView.swift

   1
   private class Model: ObservableObject {
   2
   
   3
       let graphicsOverlay: GraphicsOverlay
   4
   
   5
   }

5. Lastly, add the viewpoint and graphics overlay to the map view A map view is a user interface that displays map layers and graphics in 2D. It controls the area (extent) of the map that is visible and supports user interactions such as pan and zoom. Learn more .

   ContentView.swift

   1
       var body: some View {
   2
   
   3
           MapView(map: map, viewpoint: viewpoint, graphicsOverlays: [model.graphicsOverlay])
   4
   
   5
       }

Add graphics

Graphics are added as a visual means to display the search result on the map A map is a collection of layers that are displayed in 2D. It is typically composed of a basemap layer and data layers. Learn more .

1. Create a private property named textGraphic in the Model class. This graphic will be used to display the result’s text label.

   More info

   A TextSymbol is used to display text at a location on the map view.

   ContentView.swift

   19 collapsed lines
   1
   // Copyright 2024 Esri
   2
   //
   3
   // Licensed under the Apache License, Version 2.0 (the "License");
   4
   // you may not use this file except in compliance with the License.
   5
   // You may obtain a copy of the License at
   6
   //
   7
   //   https://www.apache.org/licenses/LICENSE-2.0
   8
   //
   9
   // Unless required by applicable law or agreed to in writing, software
   10
   // distributed under the License is distributed on an "AS IS" BASIS,
   11
   // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   12
   // See the License for the specific language governing permissions and
   13
   // limitations under the License.
   14
   
   15
   
   16
   import SwiftUI
   17
   
   18
   import ArcGIS
   19
   
   20
   private class Model: ObservableObject {
   21
   
   22
       let graphicsOverlay: GraphicsOverlay
   23
   
   24
       let textGraphic: Graphic = {
   25
           let textSymbol = TextSymbol(
   26
               text: "",
   27
               color: .black,
   28
               size: 14,
   29
               horizontalAlignment: .center,
   30
               verticalAlignment: .bottom
   31
           )
   32
           textSymbol.backgroundColor = .white
   33
           return Graphic(symbol: textSymbol)
   34
       }()
   35
   
   36
   }
   19 collapsed lines
   37
   
   38
   struct ContentView: View {
   39
   
   40
       @StateObject private var model = Model()
   41
   
   42
       @State private var map = Map(basemapStyle: .arcGISImagery)
   43
       @State private var viewpoint: Viewpoint? = Viewpoint(
   44
           latitude: 34.02700,
   45
           longitude: -118.80500,
   46
           scale: 72_000
   47
       )
   48
   
   49
       var body: some View {
   50
   
   51
           MapView(map: map, viewpoint: viewpoint, graphicsOverlays: [model.graphicsOverlay])
   52
   
   53
       }
   54
   
   55
   }

2. Create a private property named markerGraphic in the Model class. This graphic will be used to display the result’s location.

   More info

   A SimpleMarkerSymbol is used to display a location on the map view.

   ContentView.swift

   19 collapsed lines
   1
   // Copyright 2024 Esri
   2
   //
   3
   // Licensed under the Apache License, Version 2.0 (the "License");
   4
   // you may not use this file except in compliance with the License.
   5
   // You may obtain a copy of the License at
   6
   //
   7
   //   https://www.apache.org/licenses/LICENSE-2.0
   8
   //
   9
   // Unless required by applicable law or agreed to in writing, software
   10
   // distributed under the License is distributed on an "AS IS" BASIS,
   11
   // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   12
   // See the License for the specific language governing permissions and
   13
   // limitations under the License.
   14
   
   15
   
   16
   import SwiftUI
   17
   
   18
   import ArcGIS
   19
   
   20
   private class Model: ObservableObject {
   21
   
   22
       let graphicsOverlay: GraphicsOverlay
   23
   
   24
       let textGraphic: Graphic = {
   25
           let textSymbol = TextSymbol(
   26
               text: "",
   27
               color: .black,
   28
               size: 14,
   29
               horizontalAlignment: .center,
   30
               verticalAlignment: .bottom
   31
           )
   32
           textSymbol.backgroundColor = .white
   33
           return Graphic(symbol: textSymbol)
   34
       }()
   35
   
   36
       let markerGraphic: Graphic = {
   37
           let markerSymbol = SimpleMarkerSymbol(
   38
               style: .square,
   39
               color: .red,
   40
               size: 14
   41
           )
   42
           return Graphic(symbol: markerSymbol)
   43
       }()
   44
   
   45
   }
   19 collapsed lines
   46
   
   47
   struct ContentView: View {
   48
   
   49
       @StateObject private var model = Model()
   50
   
   51
       @State private var map = Map(basemapStyle: .arcGISImagery)
   52
       @State private var viewpoint: Viewpoint? = Viewpoint(
   53
           latitude: 34.02700,
   54
           longitude: -118.80500,
   55
           scale: 72_000
   56
       )
   57
   
   58
       var body: some View {
   59
   
   60
           MapView(map: map, viewpoint: viewpoint, graphicsOverlays: [model.graphicsOverlay])
   61
   
   62
       }
   63
   
   64
   }

3. Create an init function for the Model class. Create a GraphicsOverlay with the textGraphic and markerGraphic and assign it to the model’s graphics overlay. This function will be called when Model is initialized.

   More info

   Because textGraphic and markerGraphic haven’t yet specified a Geometry, they will not be visible.

   ContentView.swift

   19 collapsed lines
   1
   // Copyright 2024 Esri
   2
   //
   3
   // Licensed under the Apache License, Version 2.0 (the "License");
   4
   // you may not use this file except in compliance with the License.
   5
   // You may obtain a copy of the License at
   6
   //
   7
   //   https://www.apache.org/licenses/LICENSE-2.0
   8
   //
   9
   // Unless required by applicable law or agreed to in writing, software
   10
   // distributed under the License is distributed on an "AS IS" BASIS,
   11
   // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   12
   // See the License for the specific language governing permissions and
   13
   // limitations under the License.
   14
   
   15
   
   16
   import SwiftUI
   17
   
   18
   import ArcGIS
   19
   
   20
   private class Model: ObservableObject {
   21
   
   22
       let graphicsOverlay: GraphicsOverlay
   23
   
   24
       let textGraphic: Graphic = {
   25
           let textSymbol = TextSymbol(
   26
               text: "",
   27
               color: .black,
   28
               size: 14,
   29
               horizontalAlignment: .center,
   30
               verticalAlignment: .bottom
   31
           )
   32
           textSymbol.backgroundColor = .white
   33
           return Graphic(symbol: textSymbol)
   34
       }()
   35
   
   36
       let markerGraphic: Graphic = {
   37
           let markerSymbol = SimpleMarkerSymbol(
   38
               style: .square,
   39
               color: .red,
   40
               size: 14
   41
           )
   42
           return Graphic(symbol: markerSymbol)
   43
       }()
   44
   
   45
       init() {
   46
           graphicsOverlay = GraphicsOverlay(graphics: [textGraphic, markerGraphic])
   47
       }
   48
   
   49
   }
   19 collapsed lines
   50
   
   51
   struct ContentView: View {
   52
   
   53
       @StateObject private var model = Model()
   54
   
   55
       @State private var map = Map(basemapStyle: .arcGISImagery)
   56
       @State private var viewpoint: Viewpoint? = Viewpoint(
   57
           latitude: 34.02700,
   58
           longitude: -118.80500,
   59
           scale: 72_000
   60
       )
   61
   
   62
       var body: some View {
   63
   
   64
           MapView(map: map, viewpoint: viewpoint, graphicsOverlays: [model.graphicsOverlay])
   65
   
   66
       }
   67
   
   68
   }

Create a locator task with geocode parameters

Geocoding is implemented with a locator A locator is an ArcGIS dataset that stores address information and the rules for translating descriptions of places (such as street addresses or place names) into spatial data that can be displayed on a map. Learn more , typically created by referencing a service such as the Geocoding service A geocoding service is a service that can search for addresses, place addresses, businesses, reverse geocode coordinates to addresses, provide suggestions for places, and perform bulk geocoding. It is hosted by Esri as the ArcGIS Geocoding service and can also be hosted in ArcGIS Enterprise. Learn more or, for offline geocoding, by referencing locator data contained in a mobile package A mobile package is a stand-alone Mobile Map Package (MMPK) or Mobile Scene Package (MSPK) file for use in offline applications built with ArcGIS Maps SDKs for Native Apps. Learn more . Geocoding parameters can be used to fine-tune the results, such as setting the maximum number of results or requesting additional attributes in the results.

1. Create a LocatorTask property in the Model, named locator, based on the ArcGIS Geocoding service hosted by ESRI.

   More info

   A locator task is used to convert an address to a point A point is a type of geometry containing a single set of x,y coordinates and a spatial reference. Learn more (geocode) or vice-versa ( reverse geocode Reverse geocoding is the process of converting a point to its nearest address or place. Learn more ). An address includes any type of information that distinguishes a place. A locator A locator is an ArcGIS dataset that stores address information and the rules for translating descriptions of places (such as street addresses or place names) into spatial data that can be displayed on a map. Learn more involves finding matching locations for a given address. Reverse-geocoding is the opposite and finds the closest address for a given point.

   ContentView.swift

   19 collapsed lines
   1
   // Copyright 2024 Esri
   2
   //
   3
   // Licensed under the Apache License, Version 2.0 (the "License");
   4
   // you may not use this file except in compliance with the License.
   5
   // You may obtain a copy of the License at
   6
   //
   7
   //   https://www.apache.org/licenses/LICENSE-2.0
   8
   //
   9
   // Unless required by applicable law or agreed to in writing, software
   10
   // distributed under the License is distributed on an "AS IS" BASIS,
   11
   // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   12
   // See the License for the specific language governing permissions and
   13
   // limitations under the License.
   14
   
   15
   
   16
   import SwiftUI
   17
   
   18
   import ArcGIS
   19
   
   20
   private class Model: ObservableObject {
   21
   
   22
       let graphicsOverlay: GraphicsOverlay
   23
   
   24
       let locator = LocatorTask(
   25
           url: URL(string: "https://geocode-api.arcgis.com/arcgis/rest/services/World/GeocodeServer")!
   26
       )
   27
   
   28
       let textGraphic: Graphic = {
   29
           let textSymbol = TextSymbol(
   30
               text: "",
   31
               color: .black,
   32
               size: 14,
   33
               horizontalAlignment: .center,
   34
               verticalAlignment: .bottom
   35
           )
   36
           textSymbol.backgroundColor = .white
   37
           return Graphic(symbol: textSymbol)
   38
       }()
   39
   
   40
       let markerGraphic: Graphic = {
   41
           let markerSymbol = SimpleMarkerSymbol(
   42
               style: .square,
   43
               color: .red,
   44
               size: 14
   45
           )
   46
           return Graphic(symbol: markerSymbol)
   47
       }()
   48
   
   49
       init() {
   50
           graphicsOverlay = GraphicsOverlay(graphics: [textGraphic, markerGraphic])
   51
       }
   52
   
   53
   }
   19 collapsed lines
   54
   
   55
   struct ContentView: View {
   56
   
   57
       @StateObject private var model = Model()
   58
   
   59
       @State private var map = Map(basemapStyle: .arcGISImagery)
   60
       @State private var viewpoint: Viewpoint? = Viewpoint(
   61
           latitude: 34.02700,
   62
           longitude: -118.80500,
   63
           scale: 72_000
   64
       )
   65
   
   66
       var body: some View {
   67
   
   68
           MapView(map: map, viewpoint: viewpoint, graphicsOverlays: [model.graphicsOverlay])
   69
   
   70
       }
   71
   
   72
   }

2. In the ContentView, create a private String variable named searchText with the @State property wrapper. This will hold the user input and be used to perform the geocode operation.

   ContentView.swift

   54 collapsed lines
   1
   // Copyright 2024 Esri
   2
   //
   3
   // Licensed under the Apache License, Version 2.0 (the "License");
   4
   // you may not use this file except in compliance with the License.
   5
   // You may obtain a copy of the License at
   6
   //
   7
   //   https://www.apache.org/licenses/LICENSE-2.0
   8
   //
   9
   // Unless required by applicable law or agreed to in writing, software
   10
   // distributed under the License is distributed on an "AS IS" BASIS,
   11
   // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   12
   // See the License for the specific language governing permissions and
   13
   // limitations under the License.
   14
   
   15
   
   16
   import SwiftUI
   17
   
   18
   import ArcGIS
   19
   
   20
   private class Model: ObservableObject {
   21
   
   22
       let graphicsOverlay: GraphicsOverlay
   23
   
   24
       let locator = LocatorTask(
   25
           url: URL(string: "https://geocode-api.arcgis.com/arcgis/rest/services/World/GeocodeServer")!
   26
       )
   27
   
   28
       let textGraphic: Graphic = {
   29
           let textSymbol = TextSymbol(
   30
               text: "",
   31
               color: .black,
   32
               size: 14,
   33
               horizontalAlignment: .center,
   34
               verticalAlignment: .bottom
   35
           )
   36
           textSymbol.backgroundColor = .white
   37
           return Graphic(symbol: textSymbol)
   38
       }()
   39
   
   40
       let markerGraphic: Graphic = {
   41
           let markerSymbol = SimpleMarkerSymbol(
   42
               style: .square,
   43
               color: .red,
   44
               size: 14
   45
           )
   46
           return Graphic(symbol: markerSymbol)
   47
       }()
   48
   
   49
       init() {
   50
           graphicsOverlay = GraphicsOverlay(graphics: [textGraphic, markerGraphic])
   51
       }
   52
   
   53
   }
   54
   
   55
   struct ContentView: View {
   56
   
   57
       @StateObject private var model = Model()
   58
   
   59
       @State private var map = Map(basemapStyle: .arcGISImagery)
   60
       @State private var viewpoint: Viewpoint? = Viewpoint(
   61
           latitude: 34.02700,
   62
           longitude: -118.80500,
   63
           scale: 72_000
   64
       )
   65
   
   66
       @State private var searchText: String = ""
   67
   
   68
       var body: some View {
   69
   
   70
           MapView(map: map, viewpoint: viewpoint, graphicsOverlays: [model.graphicsOverlay])
   71
   
   72
       }
   73
   
   74
   }

3. Create a private, asynchronous function named geocode(with:). This function will be called when the user inputs an address.

   ContentView.swift

   54 collapsed lines
   1
   // Copyright 2024 Esri
   2
   //
   3
   // Licensed under the Apache License, Version 2.0 (the "License");
   4
   // you may not use this file except in compliance with the License.
   5
   // You may obtain a copy of the License at
   6
   //
   7
   //   https://www.apache.org/licenses/LICENSE-2.0
   8
   //
   9
   // Unless required by applicable law or agreed to in writing, software
   10
   // distributed under the License is distributed on an "AS IS" BASIS,
   11
   // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   12
   // See the License for the specific language governing permissions and
   13
   // limitations under the License.
   14
   
   15
   
   16
   import SwiftUI
   17
   
   18
   import ArcGIS
   19
   
   20
   private class Model: ObservableObject {
   21
   
   22
       let graphicsOverlay: GraphicsOverlay
   23
   
   24
       let locator = LocatorTask(
   25
           url: URL(string: "https://geocode-api.arcgis.com/arcgis/rest/services/World/GeocodeServer")!
   26
       )
   27
   
   28
       let textGraphic: Graphic = {
   29
           let textSymbol = TextSymbol(
   30
               text: "",
   31
               color: .black,
   32
               size: 14,
   33
               horizontalAlignment: .center,
   34
               verticalAlignment: .bottom
   35
           )
   36
           textSymbol.backgroundColor = .white
   37
           return Graphic(symbol: textSymbol)
   38
       }()
   39
   
   40
       let markerGraphic: Graphic = {
   41
           let markerSymbol = SimpleMarkerSymbol(
   42
               style: .square,
   43
               color: .red,
   44
               size: 14
   45
           )
   46
           return Graphic(symbol: markerSymbol)
   47
       }()
   48
   
   49
       init() {
   50
           graphicsOverlay = GraphicsOverlay(graphics: [textGraphic, markerGraphic])
   51
       }
   52
   
   53
   }
   54
   
   55
   struct ContentView: View {
   56
   
   57
       @StateObject private var model = Model()
   58
   
   59
       @State private var map = Map(basemapStyle: .arcGISImagery)
   60
       @State private var viewpoint: Viewpoint? = Viewpoint(
   61
           latitude: 34.02700,
   62
           longitude: -118.80500,
   63
           scale: 72_000
   64
       )
   65
   
   66
       @State private var searchText: String = ""
   67
   
   68
       private func geocode(with searchText: String) async throws {
   69
   
   70
       }
   71
   
   72
       var body: some View {
   73
   
   74
           MapView(map: map, viewpoint: viewpoint, graphicsOverlays: [model.graphicsOverlay])
   75
   
   76
       }
   77
   
   78
   }

4. Within the new function, create GeocodeParameters, and its attributes as follows:

   • Specify which attributes to return with addResultAttributeName. * is used to return all attributes.
   • Set the maximum number of results to be returned with maxResults. In this tutorial, only return the best match by passing in 1. Results are ordered by score, so just returning the first result will return the highest scoring result.
   • Set the spatial reference A spatial reference is a set of parameters, typically defined by a WKID, that define the coordinate system and spatial properties for geographic data. Applications use a spatial reference to correctly display the position of geographic data in a map or scene. Learn more with outputSpatialReference. By default the output spatial reference is determined by the geocode service. For optimal performance when displaying the geocode result, ensure the returned coordinates match those of the map view by providing mapView.spatialReference as a parameter.
   More info

   When geocoding an address, you can optionally provide GeocodeParameters to control certain aspects of the geocoding operation, and specify the kinds of results to return from the locator task.

   ContentView.swift

   67 collapsed lines
   1
   // Copyright 2024 Esri
   2
   //
   3
   // Licensed under the Apache License, Version 2.0 (the "License");
   4
   // you may not use this file except in compliance with the License.
   5
   // You may obtain a copy of the License at
   6
   //
   7
   //   https://www.apache.org/licenses/LICENSE-2.0
   8
   //
   9
   // Unless required by applicable law or agreed to in writing, software
   10
   // distributed under the License is distributed on an "AS IS" BASIS,
   11
   // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   12
   // See the License for the specific language governing permissions and
   13
   // limitations under the License.
   14
   
   15
   
   16
   import SwiftUI
   17
   
   18
   import ArcGIS
   19
   
   20
   private class Model: ObservableObject {
   21
   
   22
       let graphicsOverlay: GraphicsOverlay
   23
   
   24
       let locator = LocatorTask(
   25
           url: URL(string: "https://geocode-api.arcgis.com/arcgis/rest/services/World/GeocodeServer")!
   26
       )
   27
   
   28
       let textGraphic: Graphic = {
   29
           let textSymbol = TextSymbol(
   30
               text: "",
   31
               color: .black,
   32
               size: 14,
   33
               horizontalAlignment: .center,
   34
               verticalAlignment: .bottom
   35
           )
   36
           textSymbol.backgroundColor = .white
   37
           return Graphic(symbol: textSymbol)
   38
       }()
   39
   
   40
       let markerGraphic: Graphic = {
   41
           let markerSymbol = SimpleMarkerSymbol(
   42
               style: .square,
   43
               color: .red,
   44
               size: 14
   45
           )
   46
           return Graphic(symbol: markerSymbol)
   47
       }()
   48
   
   49
       init() {
   50
           graphicsOverlay = GraphicsOverlay(graphics: [textGraphic, markerGraphic])
   51
       }
   52
   
   53
   }
   54
   
   55
   struct ContentView: View {
   56
   
   57
       @StateObject private var model = Model()
   58
   
   59
       @State private var map = Map(basemapStyle: .arcGISImagery)
   60
       @State private var viewpoint: Viewpoint? = Viewpoint(
   61
           latitude: 34.02700,
   62
           longitude: -118.80500,
   63
           scale: 72_000
   64
       )
   65
   
   66
       @State private var searchText: String = ""
   67
   
   68
       private func geocode(with searchText: String) async throws {
   69
   
   70
           let parameters = GeocodeParameters()
   71
           parameters.addResultAttributeName("*")
   72
           parameters.maxResults = 1
   73
           parameters.outputSpatialReference = map.spatialReference
   74
   
   75
       }
   8 collapsed lines
   76
   
   77
       var body: some View {
   78
   
   79
           MapView(map: map, viewpoint: viewpoint, graphicsOverlays: [model.graphicsOverlay])
   80
   
   81
       }
   82
   
   83
   }

5. Perform the geocode operation by calling geocode(forSearchText:using:) and supplying the search text and the geocode parameters. The result obtained from the geocode operation will be displayed as a graphic A graphic is a visual element composed of a geometry, symbol, and attributes that is displayed on a map or scene. Learn more in the map view’s graphics overlay A graphics overlay is a client-side, temporary container of graphics to display on a map view or scene view. Learn more .

   ContentView.swift

   67 collapsed lines
   1
   // Copyright 2024 Esri
   2
   //
   3
   // Licensed under the Apache License, Version 2.0 (the "License");
   4
   // you may not use this file except in compliance with the License.
   5
   // You may obtain a copy of the License at
   6
   //
   7
   //   https://www.apache.org/licenses/LICENSE-2.0
   8
   //
   9
   // Unless required by applicable law or agreed to in writing, software
   10
   // distributed under the License is distributed on an "AS IS" BASIS,
   11
   // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   12
   // See the License for the specific language governing permissions and
   13
   // limitations under the License.
   14
   
   15
   
   16
   import SwiftUI
   17
   
   18
   import ArcGIS
   19
   
   20
   private class Model: ObservableObject {
   21
   
   22
       let graphicsOverlay: GraphicsOverlay
   23
   
   24
       let locator = LocatorTask(
   25
           url: URL(string: "https://geocode-api.arcgis.com/arcgis/rest/services/World/GeocodeServer")!
   26
       )
   27
   
   28
       let textGraphic: Graphic = {
   29
           let textSymbol = TextSymbol(
   30
               text: "",
   31
               color: .black,
   32
               size: 14,
   33
               horizontalAlignment: .center,
   34
               verticalAlignment: .bottom
   35
           )
   36
           textSymbol.backgroundColor = .white
   37
           return Graphic(symbol: textSymbol)
   38
       }()
   39
   
   40
       let markerGraphic: Graphic = {
   41
           let markerSymbol = SimpleMarkerSymbol(
   42
               style: .square,
   43
               color: .red,
   44
               size: 14
   45
           )
   46
           return Graphic(symbol: markerSymbol)
   47
       }()
   48
   
   49
       init() {
   50
           graphicsOverlay = GraphicsOverlay(graphics: [textGraphic, markerGraphic])
   51
       }
   52
   
   53
   }
   54
   
   55
   struct ContentView: View {
   56
   
   57
       @StateObject private var model = Model()
   58
   
   59
       @State private var map = Map(basemapStyle: .arcGISImagery)
   60
       @State private var viewpoint: Viewpoint? = Viewpoint(
   61
           latitude: 34.02700,
   62
           longitude: -118.80500,
   63
           scale: 72_000
   64
       )
   65
   
   66
       @State private var searchText: String = ""
   67
   
   68
       private func geocode(with searchText: String) async throws {
   69
   
   70
           let parameters = GeocodeParameters()
   71
           parameters.addResultAttributeName("*")
   72
           parameters.maxResults = 1
   73
           parameters.outputSpatialReference = map.spatialReference
   74
   
   75
           let geocodeResults = try await model.locator.geocode(forSearchText: searchText, using: parameters)
   76
           if let firstResult = geocodeResults.first,
   77
              let extent = firstResult.extent,
   78
              let location = firstResult.displayLocation,
   79
              let symbol = model.textGraphic.symbol as? TextSymbol {
   80
               viewpoint = Viewpoint(boundingGeometry: extent)
   81
               model.markerGraphic.geometry = location
   82
               model.textGraphic.geometry = location
   83
               symbol.text = firstResult.label
   84
           }
   85
   
   86
       }
   8 collapsed lines
   87
   
   88
       var body: some View {
   89
   
   90
           MapView(map: map, viewpoint: viewpoint, graphicsOverlays: [model.graphicsOverlay])
   91
   
   92
       }
   93
   
   94
   }

Add a search bar to the UI

To search an address using the application, add a UI element to prompt the user for text input.

1. In the body, add an overlay to the MapView. Set the alignment to the top, add padding all around, and set the background.

   ContentView.swift

   87 collapsed lines
   1
   // Copyright 2024 Esri
   2
   //
   3
   // Licensed under the Apache License, Version 2.0 (the "License");
   4
   // you may not use this file except in compliance with the License.
   5
   // You may obtain a copy of the License at
   6
   //
   7
   //   https://www.apache.org/licenses/LICENSE-2.0
   8
   //
   9
   // Unless required by applicable law or agreed to in writing, software
   10
   // distributed under the License is distributed on an "AS IS" BASIS,
   11
   // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   12
   // See the License for the specific language governing permissions and
   13
   // limitations under the License.
   14
   
   15
   
   16
   import SwiftUI
   17
   
   18
   import ArcGIS
   19
   
   20
   private class Model: ObservableObject {
   21
   
   22
       let graphicsOverlay: GraphicsOverlay
   23
   
   24
       let locator = LocatorTask(
   25
           url: URL(string: "https://geocode-api.arcgis.com/arcgis/rest/services/World/GeocodeServer")!
   26
       )
   27
   
   28
       let textGraphic: Graphic = {
   29
           let textSymbol = TextSymbol(
   30
               text: "",
   31
               color: .black,
   32
               size: 14,
   33
               horizontalAlignment: .center,
   34
               verticalAlignment: .bottom
   35
           )
   36
           textSymbol.backgroundColor = .white
   37
           return Graphic(symbol: textSymbol)
   38
       }()
   39
   
   40
       let markerGraphic: Graphic = {
   41
           let markerSymbol = SimpleMarkerSymbol(
   42
               style: .square,
   43
               color: .red,
   44
               size: 14
   45
           )
   46
           return Graphic(symbol: markerSymbol)
   47
       }()
   48
   
   49
       init() {
   50
           graphicsOverlay = GraphicsOverlay(graphics: [textGraphic, markerGraphic])
   51
       }
   52
   
   53
   }
   54
   
   55
   struct ContentView: View {
   56
   
   57
       @StateObject private var model = Model()
   58
   
   59
       @State private var map = Map(basemapStyle: .arcGISImagery)
   60
       @State private var viewpoint: Viewpoint? = Viewpoint(
   61
           latitude: 34.02700,
   62
           longitude: -118.80500,
   63
           scale: 72_000
   64
       )
   65
   
   66
       @State private var searchText: String = ""
   67
   
   68
       private func geocode(with searchText: String) async throws {
   69
   
   70
           let parameters = GeocodeParameters()
   71
           parameters.addResultAttributeName("*")
   72
           parameters.maxResults = 1
   73
           parameters.outputSpatialReference = map.spatialReference
   74
   
   75
           let geocodeResults = try await model.locator.geocode(forSearchText: searchText, using: parameters)
   76
           if let firstResult = geocodeResults.first,
   77
              let extent = firstResult.extent,
   78
              let location = firstResult.displayLocation,
   79
              let symbol = model.textGraphic.symbol as? TextSymbol {
   80
               viewpoint = Viewpoint(boundingGeometry: extent)
   81
               model.markerGraphic.geometry = location
   82
               model.textGraphic.geometry = location
   83
               symbol.text = firstResult.label
   84
           }
   85
   
   86
       }
   87
   
   88
       var body: some View {
   89
   
   90
           MapView(map: map, viewpoint: viewpoint, graphicsOverlays: [model.graphicsOverlay])
   91
   
   92
               .overlay(alignment: .top) {
   93
   
   94
                   .padding(EdgeInsets(top: 60, leading: 10, bottom: 10, trailing: 10))
   95
                   .background(.thinMaterial, ignoresSafeAreaEdges: .horizontal)
   96
               }
   97
   
   98
       }
   2 collapsed lines
   99
   
   100
   }

2. Within the overlay, add the following:

   • TextField: Pass in “Enter address” as the titleKey and the searchText variable as a binding for the text parameter
   • Spacer(): Add space in between the text field and button.
   • Button: Label it “Search” and using a Task method, call the geocode(with:) function and pass in searchText
   ContentView.swift

   87 collapsed lines
   1
   // Copyright 2024 Esri
   2
   //
   3
   // Licensed under the Apache License, Version 2.0 (the "License");
   4
   // you may not use this file except in compliance with the License.
   5
   // You may obtain a copy of the License at
   6
   //
   7
   //   https://www.apache.org/licenses/LICENSE-2.0
   8
   //
   9
   // Unless required by applicable law or agreed to in writing, software
   10
   // distributed under the License is distributed on an "AS IS" BASIS,
   11
   // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   12
   // See the License for the specific language governing permissions and
   13
   // limitations under the License.
   14
   
   15
   
   16
   import SwiftUI
   17
   
   18
   import ArcGIS
   19
   
   20
   private class Model: ObservableObject {
   21
   
   22
       let graphicsOverlay: GraphicsOverlay
   23
   
   24
       let locator = LocatorTask(
   25
           url: URL(string: "https://geocode-api.arcgis.com/arcgis/rest/services/World/GeocodeServer")!
   26
       )
   27
   
   28
       let textGraphic: Graphic = {
   29
           let textSymbol = TextSymbol(
   30
               text: "",
   31
               color: .black,
   32
               size: 14,
   33
               horizontalAlignment: .center,
   34
               verticalAlignment: .bottom
   35
           )
   36
           textSymbol.backgroundColor = .white
   37
           return Graphic(symbol: textSymbol)
   38
       }()
   39
   
   40
       let markerGraphic: Graphic = {
   41
           let markerSymbol = SimpleMarkerSymbol(
   42
               style: .square,
   43
               color: .red,
   44
               size: 14
   45
           )
   46
           return Graphic(symbol: markerSymbol)
   47
       }()
   48
   
   49
       init() {
   50
           graphicsOverlay = GraphicsOverlay(graphics: [textGraphic, markerGraphic])
   51
       }
   52
   
   53
   }
   54
   
   55
   struct ContentView: View {
   56
   
   57
       @StateObject private var model = Model()
   58
   
   59
       @State private var map = Map(basemapStyle: .arcGISImagery)
   60
       @State private var viewpoint: Viewpoint? = Viewpoint(
   61
           latitude: 34.02700,
   62
           longitude: -118.80500,
   63
           scale: 72_000
   64
       )
   65
   
   66
       @State private var searchText: String = ""
   67
   
   68
       private func geocode(with searchText: String) async throws {
   69
   
   70
           let parameters = GeocodeParameters()
   71
           parameters.addResultAttributeName("*")
   72
           parameters.maxResults = 1
   73
           parameters.outputSpatialReference = map.spatialReference
   74
   
   75
           let geocodeResults = try await model.locator.geocode(forSearchText: searchText, using: parameters)
   76
           if let firstResult = geocodeResults.first,
   77
              let extent = firstResult.extent,
   78
              let location = firstResult.displayLocation,
   79
              let symbol = model.textGraphic.symbol as? TextSymbol {
   80
               viewpoint = Viewpoint(boundingGeometry: extent)
   81
               model.markerGraphic.geometry = location
   82
               model.textGraphic.geometry = location
   83
               symbol.text = firstResult.label
   84
           }
   85
   
   86
       }
   87
   
   88
       var body: some View {
   89
   
   90
           MapView(map: map, viewpoint: viewpoint, graphicsOverlays: [model.graphicsOverlay])
   91
   
   92
               .overlay(alignment: .top) {
   93
   
   94
                   HStack {
   95
                       TextField("Enter address", text: $searchText)
   96
                       Spacer()
   97
                       Button("Search") {
   98
                           Task {
   99
                               try await geocode(with: searchText)
   100
                           }
   101
                       }
   102
                   }
   103
   
   104
                   .padding(EdgeInsets(top: 60, leading: 10, bottom: 10, trailing: 10))
   105
                   .background(.thinMaterial, ignoresSafeAreaEdges: .horizontal)
   106
               }
   107
   
   108
       }
   2 collapsed lines
   109
   
   110
   }

Run the solution

Press Command + R to run the app.

You should see a search box at the top of the map. Search for an address by entering an address and tap the Search button. The result of the search should display on the map as a red square with the address displayed on top.

Option 2: Download the solution

1. Click the Download solution link under Solution and unzip the file to a location on your machine.

2. Open the .xcodeproj file in Xcode.

Since the downloaded solution does not contain authentication credentials, you must add the developer credentials that you created in the Set up authentication section.

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.