Browse an OGC API feature service for layers and add them to the map.
Use case
OGC API standards are used for sharing geospatial data on the web. As an open standard, the OGC API aims to improve access to geospatial or location information and could be a good choice for sharing data internationally or between organizations. That data could be of any type, including, for example, transportation layers shared between government organizations and private businesses.
How to use the sample
Enter a valid OGC API service URL. Select a layer to display from the list of layers shown in an OGC API service.
How it works
Create an AGSOGCFeatureService object with an OGC API feature service URL.
Obtain the AGSOGCFeatureServiceInfo object from serviceInfo property.
Create a list of feature collections from the featureCollectionInfos property of the service info object.
When a feature collection is selected, create an AGSOGCFeatureCollectionTable from the AGSOGCFeatureCollectionInfo.
Populate the AGSOGCFeatureCollectionTable using AGSOGCFeatureCollectionTable.populateFromService(with:clearCache:outfields:completion:) with AGSQueryParameters that contain a maxFeatures property.
Create a feature layer from the feature table.
Add the feature layer to the map.
Relevant API
AGSOGCFeatureCollectionInfo
AGSOGCFeatureCollectionTable
AGSOGCFeatureService
AGSOGCFeatureServiceInfo
About the data
The Daraa, Syria test data is OpenStreetMap data converted to the Topographic Data Store schema of NGA.
Additional information
See the OGC API website for more information on the OGC API family of standards.
Tags
browse, catalog, feature, layers, OGC, OGC API, service, web
Sample Code
BrowseOGCAPIFeatureServiceViewController.swift
Use dark colors for code blocksCopy
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
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
// Copyright 2021 Esri//// Licensed under the Apache License, Version 2.0 (the "License");// you may not use this file except in compliance with the License.// You may obtain a copy of the License at//// https://www.apache.org/licenses/LICENSE-2.0//// Unless required by applicable law or agreed to in writing, software// distributed under the License is distributed on an "AS IS" BASIS,// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.// See the License for the specific language governing permissions and// limitations under the License.import UIKit
import ArcGIS
classBrowseOGCAPIFeatureServiceViewController: UIViewController{
// MARK: Storyboard views/// The map view managed by the view controller.@IBOutletvar mapView: AGSMapView! {
didSet {
mapView.map =AGSMap(basemapStyle: .arcGISTopographic)
// Set the viewpoint to Daraa, Syria. mapView.setViewpoint(AGSViewpoint(latitude: 32.62, longitude: 36.10, scale: 20_000))
}
}
/// The bar button to browse feature layers.@IBOutletvar layersBarButtonItem: UIBarButtonItem!
// MARK: Properties/// The most recent query job.var lastQuery: AGSCancelable?
/// The Daraa, Syria OGC API feature service URL.let defaultServiceURL =URL(string: "https://demo.ldproxy.net/daraa")!/// The service metadata of feature collections from the loaded service.var featureCollectionInfos: [AGSOGCFeatureCollectionInfo] = []
/// The OGC feature collection info selected by the user.var selectedInfo: AGSOGCFeatureCollectionInfo?
/// The OGC API features service.var service: AGSOGCFeatureService!
/// The query parameters to populate features from the OGC API service.let queryParameters: AGSQueryParameters= {
let queryParameters =AGSQueryParameters()
// Set a limit of 1000 on the number of returned features per request,// because the default on some services could be as low as 10. queryParameters.maxFeatures =1_000return queryParameters
}()
// MARK: Methods/// Create and load the OGC API features service from a URL.funcmakeService(url: URL) -> AGSOGCFeatureService {
let service =AGSOGCFeatureService(url: url)
service.load { [weakself] error inguardletself=selfelse { return }
iflet error = error {
self.presentAlert(error: error)
} elseiflet infos =self.service.serviceInfo?.featureCollectionInfos {
self.featureCollectionInfos = infos
self.layersBarButtonItem.isEnabled =true }
}
return service
}
/// Load and display a feature layer from the OGC feature collection table./// - Parameter info: The `AGSOGCFeatureCollectionInfo` selected by user.funcdisplayLayer(withinfo: AGSOGCFeatureCollectionInfo) {
// Cancel if there is an existing query request. lastQuery?.cancel()
let table =AGSOGCFeatureCollectionTable(featureCollectionInfo: info)
// Set the feature request mode to manual (only manual is currently// supported). In this mode, you must manually populate the table -// panning and zooming won't request features automatically. table.featureRequestMode = .manualCache
lastQuery = table.populateFromService(
with: queryParameters,
clearCache: false,
outfields: nil ) { [weakself, table] _, error inguardletself=selfelse { return }
self.lastQuery =niliflet error = error,
// Do not display error if user simply cancelled the request. (error asNSError).code !=NSUserCancelledError {
self.presentAlert(error: error)
} elseiflet extent = info.extent {
// Zoom to the extent of the selected collection.let featureLayer =AGSFeatureLayer(featureTable: table)
featureLayer.renderer =self.makeRenderer(for: table.geometryType)
self.mapView.map?.operationalLayers.setArray([featureLayer])
self.mapView.setViewpointGeometry(extent, padding: 50)
self.selectedInfo = info
}
}
}
/// Create an appropriate renderer for a type of geometry.funcmakeRenderer(forgeometryType: AGSGeometryType) -> AGSSimpleRenderer? {
let renderer: AGSSimpleRenderer?
switch geometryType {
case .point, .multipoint:
renderer =AGSSimpleRenderer(symbol: AGSSimpleMarkerSymbol(style: .circle, color: .blue, size: 5))
case .polyline:
renderer =AGSSimpleRenderer(symbol: AGSSimpleLineSymbol(style: .solid, color: .blue, width: 1))
case .polygon, .envelope:
renderer =AGSSimpleRenderer(symbol: AGSSimpleFillSymbol(style: .solid, color: .blue, outline: nil))
case .unknown:
fallthrough@unknowndefault:
renderer =nil }
return renderer
}
// MARK: ActionfuncaskUserForServiceURL(completion: @escaping (URL) -> Void) {
// Create an object to observe changes from the text fields.var textFieldObserver: NSObjectProtocol!
let alertController =UIAlertController(
title: "Load OGC API feature service",
message: "Please provide a URL to an OGC API feature service.",
preferredStyle: .alert
)
// Remove observer on cancel.let cancelAction =UIAlertAction(title: "Cancel", style: .cancel) { _inNotificationCenter.default.removeObserver(textFieldObserver!)
}
// Create URL from user input and remove observer.let loadAction =UIAlertAction(title: "Load", style: .default) { _inNotificationCenter.default.removeObserver(textFieldObserver!)
let text = alertController.textFields![0].text!let serviceURL =URL(string: text.trimmingCharacters(in: .whitespacesAndNewlines))! completion(serviceURL)
}
alertController.addAction(cancelAction)
alertController.addAction(loadAction)
alertController.preferredAction = loadAction
// The text field for OGC API service URL. alertController.addTextField { [self] textField in textField.placeholder = defaultServiceURL.absoluteString
textField.text = defaultServiceURL.absoluteString
textField.keyboardType = .URL textFieldObserver =NotificationCenter.default.addObserver(
forName: UITextField.textDidChangeNotification,
object: textField,
queue: .main
) { [unowned loadAction] _inlet text = textField.text!let serviceURL =URL(string: text.trimmingCharacters(in: .whitespacesAndNewlines))
// Enable the load button if the text is a valid URL. loadAction.isEnabled = serviceURL !=nil }
}
present(alertController, animated: true)
}
@IBActionfuncbrowseLayerInfos(_sender: UIBarButtonItem) {
let selectedIndex = featureCollectionInfos.firstIndex { $0== selectedInfo }
let optionsViewController =OptionsTableViewController(labels: featureCollectionInfos.map(\.title), selectedIndex: selectedIndex) { [self] newIndex inlet selectedInfo = featureCollectionInfos[newIndex]
displayLayer(with: selectedInfo)
}
optionsViewController.modalPresentationStyle = .popover
optionsViewController.preferredContentSize =CGSize(width: 300, height: 300)
optionsViewController.presentationController?.delegate =self optionsViewController.popoverPresentationController?.barButtonItem = sender
present(optionsViewController, animated: true)
}
// MARK: UIViewControlleroverridefuncviewDidLoad() {
super.viewDidLoad()
// Add the source code button item to the right of navigation bar. (navigationItem.rightBarButtonItem as?SourceCodeBarButtonItem)?.filenames = ["BrowseOGCAPIFeatureServiceViewController"]
}
overridefuncviewDidAppear(_animated: Bool) {
super.viewDidAppear(animated)
guard service ==nilelse { return }
// Ask user for service URL when the sample has loaded. askUserForServiceURL { serviceURL inself.service =self.makeService(url: serviceURL)
}
}
}
// MARK: - UIAdaptivePresentationControllerDelegateextensionBrowseOGCAPIFeatureServiceViewController: UIAdaptivePresentationControllerDelegate{
funcadaptivePresentationStyle(forcontroller: UIPresentationController, traitCollection: UITraitCollection) -> UIModalPresentationStyle {
return .none
}
}