Migrate from 100.x to 200.x

1
AGSGeometryEngine.bufferGeometry(geometry, byDistance: 5000)

1
GeometryEngine.buffer(around: geometry, distance: 5000)

1
featureLayer.setFeature(feature, visible: true)

1
featureLayer.setVisible(true, for: feature)

1
trackingStatus.calculatingRoute

1
trackingStatus.isCalculatingRoute

1
featureTable.createFeature()

1
featureTable.makeFeature()

1
graphicsOverlay.graphics.add(graphic)

1
graphicsOverlay.addGraphic(graphic)

1
2
3
4
5
6
7
routeTask.solveRoute(with: routeParameters) { (routeResult: AGSRouteResult?, error: Error?) in
    if let error {
        // Handle error.
    } else if let routeResult {
        // Use the result.
    }
}

1
2
3
4
5
6
do {
    let routeResult = try await routeTask.solveRoute(using: routeParameters)
    // Use the result.
} catch {
    // Handle error.
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
let job = offlineMapTask.generateOfflineMapJob(
    with: parameters,
    downloadDirectory: downloadDirectoryURL
)
job.start(statusHandler: { status in
    print(status)
}, completion: { [weak self] (result, error) in
    guard let self = self else { return }
    if let result {
        self.offlineMapGenerationDidSucceed(with: result)
    } else if let error {
        self.offlineMapGenerationDidFail(with: error)
    }
})

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
let job = offlineMapTask.makeGenerateOfflineMapJob(
    parameters: parameters,
    downloadDirectory: downloadDirectoryURL
)
job.start()
Task {
    for await status in job.$status {
        print(status)
    }
}
do {
    let output = try await job.output
} catch {
    self.error = error
}

1
2
3
locationDisplay.dataSourceStatusChangedHandler = { [weak self] isStarted in
    // Check if started.
}

1
2
3
for await isStarted in locationDisplay.statusChanged {
    // Check if started.
}

1
2
3
4
5
6
extension NavigateRouteViewController: AGSRouteTrackerDelegate {
    func routeTracker(_ routeTracker: AGSRouteTracker, didUpdate trackingStatus: AGSTrackingStatus) {
        routeRemainingGraphic.geometry = trackingStatus.routeProgress.remainingGeometry
        routeTraversedGraphic.geometry = trackingStatus.routeProgress.traversedGeometry
    }
}

1
2
3
4
for try await newStatus in routeTracker.$trackingStatus {
    routeRemainingGraphic.geometry = newStatus?.routeProgress.remainingGeometry
    routeTraversedGraphic.geometry = newStatus?.routeProgress.traversedGeometry
}

1
2
3
4
5
6
@IBOutlet private var mapView: AGSMapView! {
    didSet {
        mapView.map = AGSMap(basemapStyle: .arcGISOceans)
        mapView.setViewpoint(AGSViewpoint(latitude: -117, longitude: 34, scale: 1e5))
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// A model to store various model objects required by the geo view.
private class Model: ObservableObject {
    let map = Map(basemapStyle: .arcGISOceans)
}

// Held as a StateObject so it doesn't get recreated when the view's state changes.
@StateObject private var model = Model()

// The current viewpoint of the map view.
@State private var viewpoint = Viewpoint(
    center: Point(x: -117, y: 34, spatialReference: .wgs84),
    scale: 1e5
)

var body: some View {
    MapView(
        map: model.map,
        viewpoint: viewpoint
    )
}

1
.onViewpointChanged(kind: .centerAndScale) { viewpoint = $0 }

1
2
3
.onDrawStatusChanged {
    if $0 == .completed { print("Map view draw completed.") }
}

1
.locationDisplay(model.locationDisplay)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
.onSingleTapGesture { screenPoint, mapPoint in
    if calloutPlacement == nil {
        // Shows the callout at the tapped location in WGS 84.
        calloutPlacement = LocationCalloutPlacement(location: mapPoint)
    } else {
        // Hides the callout.
        calloutPlacement = nil
    }
}
.callout(placement: $calloutPlacement.animation(.default.speed(4))) { callout in
    Text(
        CoordinateFormatter.toLatitudeLongitude(
            point: callout.location,
            format: .decimalDegrees,
            decimalPlaces: 2
        )
    )
    .font(.callout)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// Completion block.
mapView.identifyLayer(
    featureLayer,
    screenPoint: screenPoint,
    tolerance: 12,
    returnPopupsOnly: false,
    maximumResults: 10
) { (results: [AGSIdentifyLayerResult]?, error: Error?) in
    if let error {
        self.presentAlert(error: error)
    } else if let results {
        self.handleIdentifyResults(results)
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
MapViewReader { mapViewProxy in
    MapView(map: map)
        .onSingleTapGesture { screenPoint, tapLocation in
            identifyScreenPoint = screenPoint
            identifyTapLocation = tapLocation
        }
        .task(id: identifyScreenPoint) {
            guard let screenPoint = identifyScreenPoint else { return }
            // Async/Await.
            do {
                let results = try await mapViewProxy.identify(
                    on: featureLayer,
                    screenPoint: screenPoint,
                    tolerance: 12,
                    maximumResults: 10
                )
            } catch {
                self.error = error
            }
            // Handles the identify results below.
        }
}

1
2
3
4
5
6
7
8
9
10
@IBOutlet private var mapView: AGSMapView! {
    didSet {
        mapView.map = AGSMap(basemapStyle: .arcGISOceans)
    }
}

// Get the visible area using…
private var visibleArea: AGSPolygon? {
    mapView.visibleArea
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
private class Model: ObservableObject {
    let map = Map(basemapStyle: .arcGISOceans)
}

@StateObject private var model = Model()

/// The visible area of the current map view.
/// Can be used in an overview map.
@State private var visibleArea: Polygon?

var body: some View {
    MapView(map: model.map)
        .onVisibleAreaChanged { visibleArea = $0 }
}