Routing & ETAs

Copy code// Use the Routes API for optimal results (replaces Directions API)
class RoutingRepository(private val mapsApi: GoogleMapsApi) {
    suspend fun getRoute(
        origin: LatLng,
        destination: LatLng
    ): RouteResult = withContext(Dispatchers.IO) {
        val request = ComputeRoutesRequest(
            origin = Waypoint.fromLatLng(origin),
            destination = Waypoint.fromLatLng(destination),
            travelMode = RouteTravelMode.DRIVE,
            routingPreference = RoutingPreference.TRAFFIC_AWARE,
            computeAlternativeRoutes = true
        )

        val response = mapsApi.computeRoutes(request)
        RouteResult(
            polyline = response.routes.first().polyline.encodedPolyline,
            durationSeconds = response.routes.first().duration.seconds,
            distanceMeters = response.routes.first().distanceMeters
        )
    }
}

Copy code// Decode encoded polyline to LatLng list
fun decodePolyline(encoded: String): List<LatLng> {
    return PolyUtil.decode(encoded)  // from maps-utils
}

// Draw on Google Maps
fun drawRoute(map: GoogleMap, encodedPolyline: String): Polyline {
    val points = decodePolyline(encodedPolyline)
    return map.addPolyline(
        PolylineOptions()
            .addAll(points)
            .color(Color.parseColor("#4285F4"))
            .width(12f)
            .geodesic(true)  // renders along earth's curvature
            .startCap(RoundCap())
            .endCap(RoundCap())
    )
}

// Animate camera to fit the route
fun zoomToRoute(map: GoogleMap, points: List<LatLng>) {
    val bounds = LatLngBounds.builder()
        .also { builder -> points.forEach { builder.include(it) } }
        .build()
    map.animateCamera(CameraUpdateFactory.newLatLngBounds(bounds, 120))
}

Copy code// Simple ETA from route duration
fun computeEta(durationSeconds: Long): String {
    val arrivalTime = System.currentTimeMillis() + durationSeconds * 1000
    val formatter = SimpleDateFormat("h:mm a", Locale.getDefault())
    return formatter.format(Date(arrivalTime))
}

// Dynamic ETA: re-request route periodically as conditions change
class DynamicEtaManager(
    private val routingRepository: RoutingRepository,
    private val onEtaUpdate: (String) -> Unit
) {
    private var updateJob: Job? = null

    fun start(destination: LatLng, locationFlow: Flow<Location>) {
        updateJob = coroutineScope.launch {
            locationFlow
                .sample(30_000)  // recalculate every 30 seconds
                .collect { currentLocation ->
                    val origin = LatLng(currentLocation.latitude, currentLocation.longitude)
                    val result = runCatching { routingRepository.getRoute(origin, destination) }
                        .getOrNull() ?: return@collect

                    onEtaUpdate(computeEta(result.durationSeconds))
                }
        }
    }

    fun stop() { updateJob?.cancel() }
}

Copy codedata class TurnByTurnStep(
    val instruction: String,        // "Turn left on Main St"
    val distanceMeters: Int,        // distance until this maneuver
    val maneuver: Maneuver          // TURN_LEFT, TURN_RIGHT, STRAIGHT, etc.
)

class NavigationPromptManager(private val ttsEngine: TextToSpeech) {
    fun announceStep(step: TurnByTurnStep, metersToManeuver: Int) {
        when {
            metersToManeuver < 50 -> ttsEngine.speak(step.instruction, QUEUE_FLUSH, null, null)
            metersToManeuver < 200 -> ttsEngine.speak("In 200 meters, ${step.instruction}", QUEUE_FLUSH, null, null)
            else -> { /* no announcement yet */ }
        }
    }
}

Copy code// Download tiles for an area (Google Maps SDK supports offline regions via Maps SDK)
val southwest = LatLng(latitude - 0.1, longitude - 0.1)
val northeast = LatLng(latitude + 0.1, longitude + 0.1)

OfflineTileProvider.downloadRegion(
    bounds = LatLngBounds(southwest, northeast),
    minZoom = 10,
    maxZoom = 16
)