Amazon Location Service

// Remove Google Maps dependencies
dependencies {
    // ❌ Remove these
    // implementation("com.google.android.gms:play-services-maps:18.2.0")
    // implementation("com.google.android.libraries.places:places:3.3.0")

    // ✅ Keep: FusedLocationProviderClient (device location) still comes from this package
    implementation("com.google.android.gms:play-services-location:21.0.1")
}

dependencies {
    // MapLibre for map display
    implementation("org.maplibre.gl:android-sdk:13.1.0")
    // Annotation plugin for markers/symbols (SymbolManager, SymbolOptions).
    // 4.0.0 is built against SDK 13.x. Plugin versions are numbered independently
    // of the SDK, so check its release notes when bumping android-sdk.
    implementation("org.maplibre.gl:android-plugin-annotation:4.0.0")

    // AWS SDK for Kotlin - add only what you need
    implementation("aws.sdk.kotlin:geoplaces:1.8.+")  // Places, Geocoding
    implementation("aws.sdk.kotlin:georoutes:1.8.+")  // Routing
    implementation("aws.sdk.kotlin:geomaps:1.8.+")    // Static maps
    implementation("aws.sdk.kotlin:location:1.8.+")   // Geofencing, Tracking

    // For authentication
    implementation("aws.sdk.kotlin:cognitoidentity:1.8.+")

    // Coroutines (required for AWS SDK)
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3")
}

allprojects {
    repositories {
        google()
        mavenCentral() // MapLibre (org.maplibre.gl:android-sdk) is published here
    }
}

<!-- Remove this -->
<meta-data
    android:name="com.google.android.geo.API_KEY"
    android:value="YOUR_GOOGLE_API_KEY"/>

<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />

import android.content.Context
import software.amazon.location.auth.AuthHelper
import aws.sdk.kotlin.services.geoplaces.GeoPlacesClient
import aws.sdk.kotlin.services.georoutes.GeoRoutesClient

class AmazonLocationAuth {
    companion object {
        private const val API_KEY = "YOUR_AMAZON_LOCATION_API_KEY"
        private const val REGION = "us-west-2"

        // Create a Places client using the Amazon Location Auth SDK
        suspend fun createPlacesClient(context: Context): GeoPlacesClient {
            val authHelper = AuthHelper.withApiKey(API_KEY, REGION, context)
            return GeoPlacesClient(authHelper.getGeoPlacesClientConfig())
        }

        // Create a Routes client using the Amazon Location Auth SDK
        suspend fun createRoutesClient(context: Context): GeoRoutesClient {
            val authHelper = AuthHelper.withApiKey(API_KEY, REGION, context)
            return GeoRoutesClient(authHelper.getGeoRoutesClientConfig())
        }
    }
}

import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch

class MyActivity : AppCompatActivity() {
    private val scope = CoroutineScope(Dispatchers.Main)

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        scope.launch {
            val placesClient = AmazonLocationAuth.createPlacesClient(applicationContext)
            // Use client for API calls
        }
    }
}

import aws.sdk.kotlin.services.cognitoidentity.CognitoIdentityClient
import aws.sdk.kotlin.services.cognitoidentity.model.GetCredentialsForIdentityRequest
import aws.sdk.kotlin.services.cognitoidentity.model.GetIdRequest
import aws.smithy.kotlin.runtime.auth.awscredentials.Credentials

suspend fun getCognitoCredentials(identityPoolId: String): Credentials {
    val cognitoClient = CognitoIdentityClient {
        region = "us-west-2"
    }

    // Get identity ID
    val getIdResponse = cognitoClient.getId(GetIdRequest {
        this.identityPoolId = identityPoolId
    })

    // Get temporary credentials
    val credentialsResponse = cognitoClient.getCredentialsForIdentity(
        GetCredentialsForIdentityRequest {
            identityId = getIdResponse.identityId
        }
    )

    return Credentials.invoke(
        accessKeyId = credentialsResponse.credentials?.accessKeyId ?: "",
        secretAccessKey = credentialsResponse.credentials?.secretKey ?: "",
        sessionToken = credentialsResponse.credentials?.sessionToken
    )
}

// Google Maps (Before)
import com.google.android.libraries.places.api.model.Place
import com.google.android.libraries.places.api.net.FindCurrentPlaceRequest
import com.google.android.libraries.places.api.net.PlacesClient

val placesClient = Places.createClient(context)
val placeFields = listOf(Place.Field.NAME, Place.Field.LAT_LNG)
val request = FindCurrentPlaceRequest.newInstance(placeFields)

placesClient.findCurrentPlace(request).addOnSuccessListener { response ->
    for (placeLikelihood in response.placeLikelihoods) {
        val place = placeLikelihood.place
        Log.i(TAG, "Place: ${place.name}, ${place.latLng}")
    }
}

// Amazon Location (After)
import aws.sdk.kotlin.services.geoplaces.GeoPlacesClient
import aws.sdk.kotlin.services.geoplaces.model.SearchNearbyRequest

val placesClient = AmazonLocationAuth.createPlacesClient(applicationContext)

// Assume you have the device location
val deviceLocation = listOf(-97.7431, 30.2747) // [lng, lat]

val response = placesClient.searchNearby(SearchNearbyRequest {
    queryPosition = deviceLocation
    maxResults = 20
})

response.resultItems?.forEach { place ->
    Log.i(TAG, "Place: ${place.title}, ${place.position}")
}

// Google Maps (Before)
import android.location.Geocoder
import android.location.Address

val geocoder = Geocoder(context)
val addresses = geocoder.getFromLocationName("Austin, TX", 1)
if (addresses.isNotEmpty()) {
    val location = addresses[0]
    Log.i(TAG, "Lat: ${location.latitude}, Lng: ${location.longitude}")
}

// Amazon Location (After)
import aws.sdk.kotlin.services.geoplaces.model.GeocodeRequest

val response = placesClient.geocode(GeocodeRequest {
    queryText = "Austin, TX"
    maxResults = 1
})

response.resultItems?.firstOrNull()?.let { result ->
    val (lng, lat) = result.position ?: return@let
    Log.i(TAG, "Lat: $lat, Lng: $lng")
}

// Google Maps (Before)
import com.google.maps.DirectionsApi
import com.google.maps.GeoApiContext
import com.google.maps.model.TravelMode

val context = GeoApiContext.Builder()
    .apiKey("YOUR_API_KEY")
    .build()

val directions = DirectionsApi.newRequest(context)
    .origin("Austin, TX")
    .destination("Dallas, TX")
    .mode(TravelMode.DRIVING)
    .await()

Log.i(TAG, "Distance: ${directions.routes[0].legs[0].distance}")

// Amazon Location (After)
import aws.sdk.kotlin.services.georoutes.GeoRoutesClient
import aws.sdk.kotlin.services.georoutes.model.CalculateRoutesRequest

val routesClient = AmazonLocationAuth.createRoutesClient(applicationContext)

val response = routesClient.calculateRoutes(CalculateRoutesRequest {
    origin = listOf(-97.7431, 30.2747) // Austin [lng, lat]
    destination = listOf(-96.7970, 32.7767) // Dallas [lng, lat]
    travelMode = aws.sdk.kotlin.services.georoutes.model.RouteTravelMode.Car
    legAdditionalFeatures = listOf(aws.sdk.kotlin.services.georoutes.model.RouteLegAdditionalFeature.Summary)
})

response.routes?.firstOrNull()?.let { route ->
    val leg = route.legs?.firstOrNull()
    val distance = leg?.vehicleLegDetails?.summary?.overview?.distance
    Log.i(TAG, "Distance: $distance meters")
}

// Google Maps (Before)
import com.google.android.gms.maps.MapFragment
import com.google.android.gms.maps.GoogleMap
import com.google.android.gms.maps.OnMapReadyCallback
import com.google.android.gms.maps.model.LatLng
import com.google.android.gms.maps.model.MarkerOptions

class MapActivity : AppCompatActivity(), OnMapReadyCallback {
    override fun onMapReady(googleMap: GoogleMap) {
        val austin = LatLng(30.2747, -97.7431)
        googleMap.addMarker(
            MarkerOptions()
                .position(austin)
                .title("Austin")
        )
        googleMap.moveCamera(CameraUpdateFactory.newLatLngZoom(austin, 10f))
    }
}

// Amazon Location (After)
import org.maplibre.android.MapLibre
import org.maplibre.android.maps.MapView
import org.maplibre.android.maps.MapLibreMap
import org.maplibre.android.maps.Style
import org.maplibre.android.geometry.LatLng
import org.maplibre.android.camera.CameraPosition
import org.maplibre.android.plugins.annotation.SymbolManager
import org.maplibre.android.plugins.annotation.SymbolOptions

class MapActivity : AppCompatActivity() {
    private lateinit var mapView: MapView

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        MapLibre.getInstance(this)
        mapView = MapView(this)
        setContentView(mapView)

        mapView.getMapAsync { map ->
            // Get Amazon Location map style
            val styleUrl = "https://maps.geo.us-west-2.amazonaws.com/v2/styles/Standard/descriptor?key=$API_KEY"

            map.setStyle(Style.Builder().fromUri(styleUrl)) { style ->
                // Add marker
                val symbolManager = SymbolManager(mapView, map, style)
                symbolManager.create(
                    SymbolOptions()
                        .withLatLng(LatLng(30.2747, -97.7431))
                        .withTextField("Austin")
                )

                // Move camera
                map.cameraPosition = CameraPosition.Builder()
                    .target(LatLng(30.2747, -97.7431))
                    .zoom(10.0)
                    .build()
            }
        }
    }
}

// Google Maps (Before)
import com.google.maps.android.PolyUtil

val points = PolyUtil.decode(encodedPolyline)

// Amazon Location (After) - official library
import software.amazon.location.polyline.Polyline

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

// Google Maps (Before)
import com.google.maps.android.SphericalUtil
import com.google.android.gms.maps.model.LatLng

val distance = SphericalUtil.computeDistanceBetween(
    LatLng(30.2747, -97.7431),
    LatLng(32.7767, -96.7970)
)

// Amazon Location (After) - Haversine implementation
object GeoUtils {
    private const val EARTH_RADIUS = 6371000.0 // meters

    fun computeDistanceBetween(
        lat1: Double, lng1: Double,
        lat2: Double, lng2: Double
    ): Double {
        val dLat = Math.toRadians(lat2 - lat1)
        val dLng = Math.toRadians(lng2 - lng1)

        val a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
                Math.cos(Math.toRadians(lat1)) * Math.cos(Math.toRadians(lat2)) *
                Math.sin(dLng / 2) * Math.sin(dLng / 2)

        val c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a))
        return EARTH_RADIUS * c
    }
}

val distance = GeoUtils.computeDistanceBetween(
    30.2747, -97.7431,
    32.7767, -96.7970
)

// Google Maps
val location = LatLng(30.2747, -97.7431) // lat, lng

// Amazon Location
val position = listOf(-97.7431, 30.2747) // lng, lat

// Converting between them
fun LatLng.toAmazonLocation(): List<Double> = listOf(longitude, latitude)
fun List<Double>.toLatLng(): LatLng = LatLng(this[1], this[0])

import com.google.android.libraries.places.widget.AutocompleteSupportFragment

val autocompleteFragment = supportFragmentManager.findFragmentById(R.id.autocomplete_fragment)
    as AutocompleteSupportFragment

autocompleteFragment.setOnPlaceSelectedListener(object : PlaceSelectionListener {
    override fun onPlaceSelected(place: Place) {
        Log.i(TAG, "Place: ${place.name}, ${place.latLng}")
    }

    override fun onError(status: Status) {
        Log.e(TAG, "Error: $status")
    }
})

import aws.sdk.kotlin.services.geoplaces.model.AutocompleteRequest
import kotlinx.coroutines.launch

// In your custom autocomplete UI
searchEditText.addTextChangedListener(object : TextWatcher {
    override fun afterTextChanged(s: Editable?) {
        val query = s.toString()
        if (query.length < 3) return

        scope.launch {
            val response = placesClient.autocomplete(AutocompleteRequest {
                queryText = query
                maxResults = 5
            })

            response.resultItems?.let { suggestions ->
                updateSuggestionsList(suggestions)
            }
        }
    }
})

// When user selects a suggestion
fun onSuggestionSelected(placeId: String) {
    scope.launch {
        val response = placesClient.getPlace(GetPlaceRequest {
            this.placeId = placeId
        })

        response.position?.let { position ->
            val (lng, lat) = position
            Log.i(TAG, "Selected: Lat $lat, Lng $lng")
        }
    }
}

import com.google.android.gms.location.FusedLocationProviderClient
import com.google.android.gms.location.LocationServices

val fusedLocationClient = LocationServices.getFusedLocationProviderClient(this)

fusedLocationClient.lastLocation.addOnSuccessListener { location ->
    if (location != null) {
        val currentLatLng = LatLng(location.latitude, location.longitude)
        googleMap.addMarker(MarkerOptions().position(currentLatLng))
        googleMap.moveCamera(CameraUpdateFactory.newLatLngZoom(currentLatLng, 15f))
    }
}

import com.google.android.gms.location.FusedLocationProviderClient
import com.google.android.gms.location.LocationServices

// Still use FusedLocationProviderClient for device location
val fusedLocationClient = LocationServices.getFusedLocationProviderClient(this)

fusedLocationClient.lastLocation.addOnSuccessListener { location ->
    if (location != null) {
        val currentLatLng = LatLng(location.latitude, location.longitude)

        // Use MapLibre to display
        mapLibreMap.cameraPosition = CameraPosition.Builder()
            .target(currentLatLng)
            .zoom(15.0)
            .build()

        symbolManager.create(
            SymbolOptions()
                .withLatLng(currentLatLng)
                .withIconImage("marker-icon")
        )
    }
}

import com.google.android.gms.maps.model.PolylineOptions

val polylineOptions = PolylineOptions()
    .addAll(decodedPath)
    .color(Color.BLUE)
    .width(5f)

googleMap.addPolyline(polylineOptions)

import org.maplibre.android.style.layers.LineLayer
import org.maplibre.android.style.layers.PropertyFactory.*
import org.maplibre.android.style.sources.GeoJsonSource
import org.maplibre.geojson.Feature
import org.maplibre.geojson.LineString
import org.maplibre.geojson.Point

// Convert route to GeoJSON
val coordinates = routePoints.map { Point.fromLngLat(it.second, it.first) }
val lineString = LineString.fromLngLats(coordinates)
val feature = Feature.fromGeometry(lineString)

// Add source and layer
val source = GeoJsonSource("route-source", feature)
style.addSource(source)

val lineLayer = LineLayer("route-layer", "route-source").withProperties(
    lineColor(Color.BLUE),
    lineWidth(5f)
)
style.addLayer(lineLayer)

lifecycleScope.launch {
    try {
        val response = placesClient.geocode(/* ... */)
        // Handle response
    } catch (e: Exception) {
        Log.e(TAG, "Geocoding failed", e)
        // Show error to user
    }
}

fun LatLng.toGeoJsonPosition(): List<Double> = listOf(longitude, latitude)
fun List<Double>.toLatLng(): LatLng = LatLng(this[1], this[0])