Amazon Location Service

# Remove Google Maps pods
# pod 'GoogleMaps'
# pod 'GooglePlaces'
# pod 'GoogleMapsUtils'

// Remove this from AppDelegate.swift
import GoogleMaps

func application(_ application: UIApplication,
                didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
    GMSServices.provideAPIKey("YOUR_GOOGLE_API_KEY")  // ← remove this line
    return true
}

<key>NSLocationWhenInUseUsageDescription</key>
<string>We need your location to show nearby places</string>

<key>NSLocationAlwaysAndWhenInUseUsageDescription</key>
<string>We need your location for tracking features</string>

import AmazonLocationiOSAuthSDK
import AWSGeoPlaces

class AmazonLocationAuth {
    static let apiKey = "YOUR_AMAZON_LOCATION_API_KEY"
    static let region = "us-west-2"

    // Create an authentication helper using your API key and region
    static func createAuthHelper() async throws -> AuthHelper {
        return try await AuthHelper.withApiKey(apiKey: apiKey, region: region)
    }

    // Create a Places client
    static func createPlacesClient() async throws -> GeoPlacesClient {
        let authHelper = try await createAuthHelper()
        return GeoPlacesClient(config: authHelper.getGeoPlacesClientConfig())
    }

    // Create a Routes client
    static func createRoutesClient() async throws -> GeoRoutesClient {
        let authHelper = try await createAuthHelper()
        return GeoRoutesClient(config: authHelper.getGeoRoutesClientConfig())
    }

    // Create a Location client (for geofencing/tracking)
    static func createLocationClient() async throws -> LocationClient {
        let authHelper = try await createAuthHelper()
        return LocationClient(config: authHelper.getLocationClientConfig())
    }
}

import AWSGeoPlaces

class PlacesViewController: UIViewController {
    var placesClient: GeoPlacesClient?

    override func viewDidLoad() {
        super.viewDidLoad()

        Task {
            // Simple one-line client creation
            placesClient = try await AmazonLocationAuth.createPlacesClient()

            // Use client for API calls
            let input = SearchTextInput(
                biasPosition: [-97.7431, 30.2747],
                queryText: "coffee shops"
            )
            let response = try await placesClient?.searchText(input: input)
        }
    }
}

import AmazonLocationiOSAuthSDK
import AWSLocation

func createLocationClientWithCognito() async throws -> LocationClient {
    let identityPoolId = "YOUR_IDENTITY_POOL_ID"

    // Create authentication helper using Cognito credentials
    let authHelper = try await AuthHelper.withIdentityPoolId(identityPoolId: identityPoolId)

    // Configure the LocationClient to use credentials from Cognito
    return LocationClient(config: authHelper.getLocationClientConfig())
}

// Google Maps (Before)
import GooglePlaces

let placesClient = GMSPlacesClient.shared()
let filter = GMSAutocompleteFilter()
filter.types = ["restaurant"]

placesClient.currentPlace { (placeLikelihoodList, error) in
    if let error = error {
        print("Error: \(error)")
        return
    }

    guard let placeLikelihoods = placeLikelihoodList?.likelihoods else {
        return
    }

    for likelihood in placeLikelihoods {
        let place = likelihood.place
        print("Place: \(place.name), \(place.coordinate)")
    }
}

// Amazon Location (After)
import AmazonLocationiOSAuthSDK
import AWSGeoPlaces
import CoreLocation

let placesClient = try await AmazonLocationAuth.createPlacesClient()

// Assume you have device location
let deviceLocation: [Double] = [-97.7431, 30.2747] // [lng, lat]

let input = SearchNearbyInput(
    filter: GeoPlacesClientTypes.SearchNearbyFilter(
        includeCategories: ["restaurant"]
    ),
    maxResults: 20,
    queryPosition: deviceLocation
)

let response = try await placesClient.searchNearby(input: input)

response.resultItems?.forEach { place in
    print("Place: \(place.title ?? ""), \(place.position ?? [])")
}

// Google Maps (Before)
// Google's iOS Maps SDK does NOT support forward geocoding; call the web service:
let apiKey = "YOUR_GOOGLE_API_KEY"
let query = "Austin, TX".addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed)!
let url = URL(string: "https://maps.googleapis.com/maps/api/geocode/json?address=\(query)&key=\(apiKey)")!
URLSession.shared.dataTask(with: url) { data, _, error in
    guard let data = data else { return }
    let result = try? JSONDecoder().decode(GeocodeResponse.self, from: data)
    // result.results[0].geometry.location.lat / .lng
}.resume()

// Amazon Location (After)
import AmazonLocationiOSAuthSDK
import AWSGeoPlaces

let placesClient = try await AmazonLocationAuth.createPlacesClient()

let input = GeocodeInput(
    maxResults: 1,
    queryText: "Austin, TX"
)

let response = try await placesClient.geocode(input: input)

if let result = response.resultItems?.first,
   let position = result.position {
    let lng = position[0]
    let lat = position[1]
    print("Lat: \(lat), Lng: \(lng)")
}

// Google Maps (Before)
// Directions is a Google web service (REST) API — there is no native iOS SDK
// class for it, so it is called over HTTPS with URLSession.
import Foundation

let origin = "Austin, TX"
let destination = "Dallas, TX"
let apiKey = "YOUR_GOOGLE_API_KEY"

var components = URLComponents(string: "https://maps.googleapis.com/maps/api/directions/json")!
components.queryItems = [
    URLQueryItem(name: "origin", value: origin),
    URLQueryItem(name: "destination", value: destination),
    URLQueryItem(name: "key", value: apiKey),
]

let (data, _) = try await URLSession.shared.data(from: components.url!)
let json = try JSONSerialization.jsonObject(with: data) as? [String: Any]

if let routes = json?["routes"] as? [[String: Any]],
   let leg = (routes.first?["legs"] as? [[String: Any]])?.first,
   let distance = (leg["distance"] as? [String: Any])?["value"] as? Int {
    print("Distance: \(distance)")
}

// Amazon Location (After)
import AmazonLocationiOSAuthSDK
import AWSGeoRoutes

let routesClient = try await AmazonLocationAuth.createRoutesClient()

let input = CalculateRoutesInput(
    destination: [-96.7970, 32.7767], // Dallas [lng, lat]
    legAdditionalFeatures: [.summary],
    origin: [-97.7431, 30.2747], // Austin [lng, lat]
    travelMode: .car
)

let response = try await routesClient.calculateRoutes(input: input)

if let route = response.routes?.first,
   let leg = route.legs?.first,
   let distance = leg.vehicleLegDetails?.summary?.overview?.distance {
    print("Distance: \(distance) meters")
}

// Google Maps (Before)
import GoogleMaps

class MapViewController: UIViewController {
    var mapView: GMSMapView!

    override func viewDidLoad() {
        super.viewDidLoad()

        let camera = GMSCameraPosition.camera(
            withLatitude: 30.2747,
            longitude: -97.7431,
            zoom: 10
        )
        mapView = GMSMapView.map(withFrame: view.bounds, camera: camera)
        view.addSubview(mapView)

        // Add marker
        let marker = GMSMarker()
        marker.position = CLLocationCoordinate2D(latitude: 30.2747, longitude: -97.7431)
        marker.title = "Austin"
        marker.map = mapView
    }
}

// Amazon Location (After)
import MapLibre

class MapViewController: UIViewController {
    var mapView: MLNMapView!

    override func viewDidLoad() {
        super.viewDidLoad()

        // Create map with Amazon Location style
        let apiKey = AmazonLocationAuth.apiKey
        let region = AmazonLocationAuth.region
        let styleURL = URL(string: "https://maps.geo.\(region).amazonaws.com/v2/styles/Standard/descriptor?key=\(apiKey)")!

        mapView = MLNMapView(frame: view.bounds, styleURL: styleURL)
        mapView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
        mapView.setCenter(
            CLLocationCoordinate2D(latitude: 30.2747, longitude: -97.7431),
            zoomLevel: 10,
            animated: false
        )
        view.addSubview(mapView)

        // Add marker
        let annotation = MLNPointAnnotation()
        annotation.coordinate = CLLocationCoordinate2D(latitude: 30.2747, longitude: -97.7431)
        annotation.title = "Austin"
        mapView.addAnnotation(annotation)
    }
}

// Google Maps (Before)
import GoogleMaps

let path = GMSPath(fromEncodedPath: encodedPolyline)

// Amazon Location (After) - official library
import Polyline

// Decode the FlexiblePolyline returned by Amazon Location routing
let feature = Polyline.decodeToLineStringFeature(encodedPolyline)
// `feature` is a GeoJSON LineString Feature, ready to add to a MapLibre source

// Google Maps (Before)
import GoogleMaps

let from = CLLocationCoordinate2D(latitude: 30.2747, longitude: -97.7431)
let to = CLLocationCoordinate2D(latitude: 32.7767, longitude: -96.7970)
let distance = GMSGeometryDistance(from, to)

// Amazon Location (After) - Haversine implementation
import CoreLocation

extension CLLocationCoordinate2D {
    func distance(to: CLLocationCoordinate2D) -> Double {
        let earthRadius = 6371000.0 // meters

        let lat1 = self.latitude * .pi / 180
        let lat2 = to.latitude * .pi / 180
        let dLat = (to.latitude - self.latitude) * .pi / 180
        let dLng = (to.longitude - self.longitude) * .pi / 180

        let a = sin(dLat / 2) * sin(dLat / 2) +
                cos(lat1) * cos(lat2) *
                sin(dLng / 2) * sin(dLng / 2)

        let c = 2 * atan2(sqrt(a), sqrt(1 - a))
        return earthRadius * c
    }
}

let from = CLLocationCoordinate2D(latitude: 30.2747, longitude: -97.7431)
let to = CLLocationCoordinate2D(latitude: 32.7767, longitude: -96.7970)
let distance = from.distance(to: to)

// Google Maps
let coordinate = CLLocationCoordinate2D(latitude: 30.2747, longitude: -97.7431)

// Amazon Location
let position: [Double] = [-97.7431, 30.2747] // [lng, lat]

// Converting between them
extension CLLocationCoordinate2D {
    func toGeoJsonPosition() -> [Double] {
        return [longitude, latitude]
    }

    init(geoJsonPosition: [Double]) {
        self.init(latitude: geoJsonPosition[1], longitude: geoJsonPosition[0])
    }
}

import GooglePlaces

let autocompleteController = GMSAutocompleteViewController()
autocompleteController.delegate = self

present(autocompleteController, animated: true, completion: nil)

// GMSAutocompleteViewControllerDelegate
func viewController(_ viewController: GMSAutocompleteViewController,
                   didAutocompleteWith place: GMSPlace) {
    print("Place: \(place.name), \(place.coordinate)")
    dismiss(animated: true, completion: nil)
}

import AWSGeoPlaces
import UIKit

// Custom autocomplete UI
class AutocompleteViewController: UIViewController, UISearchBarDelegate {
    let searchBar = UISearchBar()
    let tableView = UITableView()
    var suggestions: [GeoPlacesClientTypes.AutocompleteResultItem] = []

    func searchBar(_ searchBar: UISearchBar, textDidChange searchText: String) {
        guard searchText.count >= 3 else { return }

        Task {
            let input = AutocompleteInput(
                maxResults: 5,
                queryText: searchText
            )

            let response = try await placesClient.autocomplete(input: input)
            suggestions = response.resultItems ?? []
            tableView.reloadData()
        }
    }

    func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
        let suggestion = suggestions[indexPath.row]

        Task {
            if let placeId = suggestion.placeId {
                let input = GetPlaceInput(placeId: placeId)
                let response = try await placesClient.getPlace(input: input)

                if let position = response.position {
                    let coordinate = CLLocationCoordinate2D(geoJsonPosition: position)
                    print("Selected: \(coordinate)")
                }
            }
        }
    }
}

import GoogleMaps
import CoreLocation

class MapViewController: UIViewController, CLLocationManagerDelegate {
    let locationManager = CLLocationManager()
    var mapView: GMSMapView!

    override func viewDidLoad() {
        super.viewDidLoad()

        locationManager.delegate = self
        locationManager.requestWhenInUseAuthorization()
        locationManager.startUpdatingLocation()
    }

    func locationManager(_ manager: CLLocationManager,
                        didUpdateLocations locations: [CLLocation]) {
        guard let location = locations.first else { return }

        let camera = GMSCameraPosition.camera(
            withTarget: location.coordinate,
            zoom: 15
        )
        mapView.camera = camera

        let marker = GMSMarker(position: location.coordinate)
        marker.map = mapView

        locationManager.stopUpdatingLocation()
    }
}

import MapLibre
import CoreLocation

class MapViewController: UIViewController, CLLocationManagerDelegate {
    let locationManager = CLLocationManager()
    var mapView: MLNMapView!

    override func viewDidLoad() {
        super.viewDidLoad()

        let styleURL = URL(string: "https://maps.geo.us-west-2.amazonaws.com/v2/styles/Standard/descriptor?key=\(apiKey)")!
        mapView = MLNMapView(frame: view.bounds, styleURL: styleURL)
        view.addSubview(mapView)

        locationManager.delegate = self
        locationManager.requestWhenInUseAuthorization()
        locationManager.startUpdatingLocation()
    }

    func locationManager(_ manager: CLLocationManager,
                        didUpdateLocations locations: [CLLocation]) {
        guard let location = locations.first else { return }

        mapView.setCenter(
            location.coordinate,
            zoomLevel: 15,
            animated: true
        )

        let annotation = MLNPointAnnotation()
        annotation.coordinate = location.coordinate
        mapView.addAnnotation(annotation)

        locationManager.stopUpdatingLocation()
    }
}

import GoogleMaps

let path = GMSMutablePath()
routeCoordinates.forEach { path.add($0) }

let polyline = GMSPolyline(path: path)
polyline.strokeColor = .blue
polyline.strokeWidth = 5
polyline.map = mapView

import MapLibre

// Create polyline from coordinates
let polyline = MLNPolyline(coordinates: routeCoordinates, count: UInt(routeCoordinates.count))

// Add polyline to map
mapView.addAnnotation(polyline)

// Customize appearance using MLNMapViewDelegate
func mapView(_ mapView: MLNMapView, strokeColorForShapeAnnotation annotation: MLNShape) -> UIColor {
    return .blue
}

func mapView(_ mapView: MLNMapView, lineWidthForPolylineAnnotation annotation: MLNPolyline) -> CGFloat {
    return 5
}

Task {
    do {
        let response = try await placesClient.geocode(input: input)
        // Handle response
    } catch {
        print("Geocoding failed: \(error)")
        // Show error to user
    }
}

extension CLLocationCoordinate2D {
    func toGeoJsonPosition() -> [Double] {
        [longitude, latitude]
    }

    init(geoJsonPosition: [Double]) {
        self.init(latitude: geoJsonPosition[1], longitude: geoJsonPosition[0])
    }
}

class MapViewController: UIViewController, MLNMapViewDelegate {
    var mapView: MLNMapView!

    override func viewDidLoad() {
        super.viewDidLoad()
        mapView.delegate = self
    }

    deinit {
        mapView.delegate = nil
    }
}