Mapkit

import MapKitimport SwiftUI
struct PlaceMap: View {    @State private var position: MapCameraPosition = .automatic
    var body: some View {        Map(position: $position) {            Marker("Apple Park", coordinate: applePark)            Marker("Infinite Loop", systemImage: "building.2",                   coordinate: infiniteLoop)        }        .mapStyle(.standard(elevation: .realistic))        .mapControls {            MapUserLocationButton()            MapCompass()            MapScaleView()        }    }}

// Balloon marker -- simplest way to pin a locationMarker("Cafe", systemImage: "cup.and.saucer.fill", coordinate: cafeCoord)    .tint(.brown)
// Annotation -- custom SwiftUI view at a coordinateAnnotation("You", coordinate: userCoord, anchor: .bottom) {    Image(systemName: "figure.wave")        .padding(6)        .background(.blue.gradient, in: .circle)        .foregroundStyle(.white)}

Map {    // Polyline from coordinates    MapPolyline(coordinates: routeCoords)        .stroke(.blue, lineWidth: 4)
    // Polygon (area highlight)    MapPolygon(coordinates: parkBoundary)        .foregroundStyle(.green.opacity(0.3))        .stroke(.green, lineWidth: 2)
    // Circle (radius around a point)    MapCircle(center: storeCoord, radius: 500)        .foregroundStyle(.red.opacity(0.15))        .stroke(.red, lineWidth: 1)}

// Center on a region@State private var position: MapCameraPosition = .region(    MKCoordinateRegion(        center: CLLocationCoordinate2D(latitude: 37.334, longitude: -122.009),        span: MKCoordinateSpan(latitudeDelta: 0.05, longitudeDelta: 0.05)    ))
// Follow user location@State private var position: MapCameraPosition = .userLocation(fallback: .automatic)
// Specific camera angle (3D perspective)@State private var position: MapCameraPosition = .camera(    MapCamera(centerCoordinate: applePark, distance: 1000, heading: 90, pitch: 60))
// Frame specific itemsposition = .item(MKMapItem.forCurrentLocation())position = .rect(MKMapRect(...))

@State private var selectedMarker: MKMapItem?
Map(selection: $selectedMarker) {    ForEach(places) { place in        Marker(place.name, coordinate: place.coordinate)            .tag(place.mapItem)     // Tag must match selection type    }}.onChange(of: selectedMarker) { _, newValue in    guard let item = newValue else { return }    // React to selection}

import CoreLocation
@MainActor@Observablefinal class LocationTracker {    var currentLocation: CLLocation?    private var updateTask: Task<Void, Never>?
    func startTracking() {        updateTask = Task {            do {                let updates = CLLocationUpdate.liveUpdates()                for try await update in updates {                    guard let location = update.location else { continue }                    // Filter by horizontal accuracy                    guard location.horizontalAccuracy >= 0,                          location.horizontalAccuracy < 50 else { continue }                    currentLocation = location                }            } catch is CancellationError {                // Expected when tracking stops.            } catch {                currentLocation = nil            }        }    }
    func stopTracking() {        updateTask?.cancel()        updateTask = nil    }}

// When-in-use authorization with full accuracy preferencelet session = CLServiceSession(    authorization: .whenInUse,    fullAccuracyPurposeKey: "NearbySearchPurpose")// Hold `session` as a stored property; release it when done.

// Info.plist keys (required):// NSLocationWhenInUseUsageDescription// NSLocationAlwaysAndWhenInUseUsageDescription (only if .always needed)
// Check authorization and guide user to Settings when deniedstruct LocationPermissionView: View {    @Environment(\.openURL) private var openURL
    var body: some View {        ContentUnavailableView {            Label("Location Access Denied", systemImage: "location.slash")        } description: {            Text("Enable location access in Settings to use this feature.")        } actions: {            Button("Open Settings") {                if let url = URL(string: UIApplication.openSettingsURLString) {                    openURL(url)                }            }        }    }}

let geocoder = CLGeocoder()
// Forward geocoding: address string -> coordinateslet placemarks = try await geocoder.geocodeAddressString("1 Apple Park Way, Cupertino")if let location = placemarks.first?.location {    print(location.coordinate) // CLLocationCoordinate2D}
// Reverse geocoding: coordinates -> placemarklet location = CLLocation(latitude: 37.3349, longitude: -122.0090)let placemarks = try await geocoder.reverseGeocodeLocation(location)if let placemark = placemarks.first {    let address = [placemark.name, placemark.locality, placemark.administrativeArea]        .compactMap { $0 }        .joined(separator: ", ")}

@available(iOS 26, *)func reverseGeocode(location: CLLocation) async throws -> MKMapItem? {    guard let request = MKReverseGeocodingRequest(location: location) else {        return nil    }    let mapItems = try await request.mapItems    return mapItems.first}
@available(iOS 26, *)func forwardGeocode(address: String) async throws -> [MKMapItem] {    guard let request = MKGeocodingRequest(addressString: address) else { return [] }    return try await request.mapItems}

@Observablefinal class SearchCompleter: NSObject, MKLocalSearchCompleterDelegate {    var results: [MKLocalSearchCompletion] = []    var query: String = "" { didSet { completer.queryFragment = query } }
    private let completer = MKLocalSearchCompleter()
    override init() {        super.init()        completer.delegate = self        completer.resultTypes = [.address, .pointOfInterest]    }
    func completerDidUpdateResults(_ completer: MKLocalSearchCompleter) {        results = completer.results    }
    func completer(_ completer: MKLocalSearchCompleter, didFailWithError error: Error) {        results = []    }}

func search(for completion: MKLocalSearchCompletion) async throws -> [MKMapItem] {    let request = MKLocalSearch.Request(completion: completion)    request.resultTypes = [.pointOfInterest, .address]    let search = MKLocalSearch(request: request)    let response = try await search.start()    return response.mapItems}
// Search by natural language query within a regionfunc searchNearby(query: String, region: MKCoordinateRegion) async throws -> [MKMapItem] {    let request = MKLocalSearch.Request()    request.naturalLanguageQuery = query    request.region = region    let search = MKLocalSearch(request: request)    let response = try await search.start()    return response.mapItems}

func getDirections(from source: MKMapItem, to destination: MKMapItem,                   transport: MKDirectionsTransportType = .automobile) async throws -> MKRoute? {    let request = MKDirections.Request()    request.source = source    request.destination = destination    request.transportType = transport    let directions = MKDirections(request: request)    let response = try await directions.calculate()    return response.routes.first}

@State private var route: MKRoute?
Map {    if let route {        MapPolyline(route.polyline)            .stroke(.blue, lineWidth: 5)    }    Marker("Start", coordinate: startCoord)    Marker("End", coordinate: endCoord)}.task {    route = try? await getDirections(from: startItem, to: endItem)}

func getETA(from source: MKMapItem, to destination: MKMapItem) async throws -> TimeInterval {    let request = MKDirections.Request()    request.source = source    request.destination = destination    let directions = MKDirections(request: request)    let response = try await directions.calculateETA()    return response.expectedTravelTime}

import GeoToolbox
@available(iOS 26, *)func lookupPlace(name: String, coordinate: CLLocationCoordinate2D) async throws -> MKMapItem {    let descriptor = PlaceDescriptor(        representations: [.coordinate(coordinate)],        commonName: name    )    let request = MKMapItemRequest(placeDescriptor: descriptor)    return try await request.mapItem}