Location Strategies & Battery Trade-offs

Copy codeclass LocationManager(private val context: Context) {
    private val fusedLocationClient = LocationServices.getFusedLocationProviderClient(context)

    // Get last known location (no GPS activation — minimal battery)
    suspend fun getLastLocation(): Location? {
        return if (ContextCompat.checkSelfPermission(
                context, Manifest.permission.ACCESS_FINE_LOCATION
            ) == PackageManager.PERMISSION_GRANTED
        ) {
            fusedLocationClient.lastLocation.await()
        } else null
    }

    // Continuous updates — for navigation or active tracking
    fun requestContinuousUpdates(callback: (Location) -> Unit): LocationCallback {
        val request = LocationRequest.Builder(
            Priority.PRIORITY_HIGH_ACCURACY,    // GPS + network fusion
            5_000L                              // update interval: 5 seconds
        )
        .setMinUpdateDistanceMeters(10f)        // only update if moved >10m
        .setMinUpdateIntervalMillis(2_000L)     // fastest possible update
        .build()

        val locationCallback = object : LocationCallback() {
            override fun onLocationResult(result: LocationResult) {
                result.lastLocation?.let(callback)
            }
        }

        fusedLocationClient.requestLocationUpdates(
            request, locationCallback, Looper.getMainLooper()
        )

        return locationCallback
    }

    fun stopUpdates(callback: LocationCallback) {
        fusedLocationClient.removeLocationUpdates(callback)
    }
}

Copy codefun buildLocationRequest(strategy: LocationStrategy): LocationRequest {
    return when (strategy) {
        // Navigation: high accuracy, frequent updates
        LocationStrategy.NAVIGATION -> LocationRequest.Builder(
            Priority.PRIORITY_HIGH_ACCURACY, 1_000L  // 1s interval
        ).setMinUpdateDistanceMeters(2f).build()

        // Ride tracking (driver): medium accuracy, less frequent
        LocationStrategy.RIDE_TRACKING -> LocationRequest.Builder(
            Priority.PRIORITY_BALANCED_POWER, 5_000L  // 5s interval
        ).setMinUpdateDistanceMeters(10f).build()

        // Background geofencing check: passive + low accuracy
        LocationStrategy.BACKGROUND -> LocationRequest.Builder(
            Priority.PRIORITY_LOW_POWER, 60_000L  // 1 min interval
        ).setMinUpdateDistanceMeters(100f).build()

        // One-time city-level location
        LocationStrategy.COARSE -> LocationRequest.Builder(
            Priority.PRIORITY_PASSIVE, Long.MAX_VALUE
        ).setMaxUpdates(1).build()
    }
}

enum class LocationStrategy { NAVIGATION, RIDE_TRACKING, BACKGROUND, COARSE }

Copy codeclass LocationPermissionHelper(private val activity: ComponentActivity) {
    private val permissionLauncher = activity.registerForActivityResult(
        ActivityResultContracts.RequestMultiplePermissions()
    ) { permissions ->
        when {
            permissions[Manifest.permission.ACCESS_FINE_LOCATION] == true ->
                onFineLocationGranted()
            permissions[Manifest.permission.ACCESS_COARSE_LOCATION] == true ->
                onCoarseLocationGranted()
            else ->
                onLocationDenied()
        }
    }

    fun requestForegroundLocation() {
        permissionLauncher.launch(arrayOf(
            Manifest.permission.ACCESS_FINE_LOCATION,
            Manifest.permission.ACCESS_COARSE_LOCATION
        ))
    }

    // Background location requires explicit separate prompt and user going to settings on API 30+
    fun requestBackgroundLocation() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
            permissionLauncher.launch(arrayOf(Manifest.permission.ACCESS_BACKGROUND_LOCATION))
        }
    }
}

Copy code// Stop updates when app goes to background (if not needed there)
lifecycle.addObserver(object : DefaultLifecycleObserver {
    override fun onStop(owner: LifecycleOwner) {
        locationManager.stopUpdates(locationCallback)
    }
    override fun onStart(owner: LifecycleOwner) {
        locationManager.requestContinuousUpdates { location -> handleLocation(location) }
    }
})