shekhar23/claude-zero-to-hero-android-kmp/android-background-location-geofencing

<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
<uses-permission android:name="android.permission.ACCESS_BACKGROUND_LOCATION" />
 
<!-- Required for Android 14+ foreground location service -->
<uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
<uses-permission android:name="android.permission.FOREGROUND_SERVICE_LOCATION" />

data class LocationPermissionState(
    val isForegroundGranted: Boolean = false,
    val isBackgroundGranted: Boolean = false,
    val shouldShowForegroundRationale: Boolean = false,
    val shouldShowBackgroundRationale: Boolean = false,
    val isForegroundPermanentlyDenied: Boolean = false,
    val isBackgroundPermanentlyDenied: Boolean = false
)

@Composable
fun LocationTrackingRoot(viewModel: LocationViewModel = koinViewModel()) {
    val state by viewModel.state.collectAsStateWithLifecycle()
 
    val foregroundLauncher = rememberLauncherForActivityResult(
        ActivityResultContracts.RequestMultiplePermissions()
    ) { results ->
        viewModel.onAction(LocationAction.OnForegroundPermissionResult(results))
    }
 
    val backgroundLauncher = rememberLauncherForActivityResult(
        ActivityResultContracts.RequestPermission()
    ) { granted ->
        viewModel.onAction(LocationAction.OnBackgroundPermissionResult(granted))
    }
 
    LocationTrackingScreen(
        state = state,
        onAction = { action ->
            when (action) {
                LocationAction.OnRequestForegroundClick -> foregroundLauncher.launch(
                    arrayOf(
                        Manifest.permission.ACCESS_FINE_LOCATION,
                        Manifest.permission.ACCESS_COARSE_LOCATION
                    )
                )
                LocationAction.OnRequestBackgroundClick -> backgroundLauncher.launch(
                    Manifest.permission.ACCESS_BACKGROUND_LOCATION
                )
                else -> viewModel.onAction(action)
            }
        }
    )
}

<service
    android:name=".location.LocationForegroundService"
    android:foregroundServiceType="location"
    android:exported="false" />

class LocationForegroundService : Service() {
 
    private val fusedClient by lazy {
        LocationServices.getFusedLocationProviderClient(this)
    }
    private var locationCallback: LocationCallback? = null
 
    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        if (intent?.action == ACTION_STOP) {
            stopTracking()
            return START_NOT_STICKY
        }
        startForeground(NOTIFICATION_ID, buildNotification())
        startTracking()
        return START_STICKY
    }
 
    private fun startTracking() {
        val request = buildLocationRequest()
        locationCallback = object : LocationCallback() {
            override fun onLocationResult(result: LocationResult) {
                result.lastLocation?.let { location ->
                    // Emit to a shared Flow, repository, or broadcast
                    LocationEventBus.emit(location)
                }
            }
        }
        fusedClient.requestLocationUpdates(request, locationCallback!!, Looper.getMainLooper())
    }
 
    private fun stopTracking() {
        locationCallback?.let { fusedClient.removeLocationUpdates(it) }
        stopForeground(STOP_FOREGROUND_REMOVE)
        stopSelf()
    }
 
    override fun onBind(intent: Intent?): IBinder? = null
 
    companion object {
        const val ACTION_STOP = "action.stop_location"
        private const val NOTIFICATION_ID = 1001
    }
}

fun buildLocationRequest(): LocationRequest =
    LocationRequest.Builder(
        Priority.PRIORITY_BALANCED_POWER_ACCURACY,
        intervalMillis = 30_000L          // preferred update interval
    )
        .setMinUpdateIntervalMillis(15_000L)     // fastest interval if updates come faster
        .setMinUpdateDistanceMeters(50f)         // skip update if moved less than 50 m
        .setWaitForAccurateLocation(false)
        .build()

interface LocationDataSource {
    fun locationUpdates(): Flow<Location>
    suspend fun lastKnownLocation(): Location?
}
 
class FusedLocationDataSource(
    private val context: Context
) : LocationDataSource {
 
    private val client = LocationServices.getFusedLocationProviderClient(context)
 
    @SuppressLint("MissingPermission")
    override fun locationUpdates(): Flow<Location> = callbackFlow {
        val request = buildLocationRequest()
        val callback = object : LocationCallback() {
            override fun onLocationResult(result: LocationResult) {
                result.lastLocation?.let { trySend(it) }
            }
        }
        client.requestLocationUpdates(request, callback, Looper.getMainLooper())
        awaitClose { client.removeLocationUpdates(callback) }
    }
 
    @SuppressLint("MissingPermission")
    override suspend fun lastKnownLocation(): Location? =
        client.lastLocation.await()
}

class GeofenceManager(private val context: Context) {
 
    private val client: GeofencingClient =
        LocationServices.getGeofencingClient(context)
 
    private val geofencePendingIntent: PendingIntent by lazy {
        val intent = Intent(context, GeofenceBroadcastReceiver::class.java)
        PendingIntent.getBroadcast(
            context,
            0,
            intent,
            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_MUTABLE
        )
    }
 
    @SuppressLint("MissingPermission")
    fun addGeofences(fences: List<GeofenceSpec>) {
        val geofences = fences.map { spec ->
            Geofence.Builder()
                .setRequestId(spec.id)
                .setCircularRegion(spec.lat, spec.lng, spec.radiusMeters)
                .setTransitionTypes(
                    Geofence.GEOFENCE_TRANSITION_ENTER or Geofence.GEOFENCE_TRANSITION_EXIT
                )
                .setExpirationDuration(Geofence.NEVER_EXPIRE)
                .build()
        }
 
        val request = GeofencingRequest.Builder()
            .setInitialTrigger(GeofencingRequest.INITIAL_TRIGGER_ENTER)
            .addGeofences(geofences)
            .build()
 
        client.addGeofences(request, geofencePendingIntent)
            .addOnFailureListener { e ->
                // Log failure; re-register on next app start if needed
            }
    }
 
    fun removeGeofences(ids: List<String>) {
        client.removeGeofences(ids)
    }
}
 
data class GeofenceSpec(
    val id: String,
    val lat: Double,
    val lng: Double,
    val radiusMeters: Float
)

class GeofenceBroadcastReceiver : BroadcastReceiver() {
 
    override fun onReceive(context: Context, intent: Intent) {
        val event = GeofencingEvent.fromIntent(intent) ?: return
        if (event.hasError()) {
            // Log GeofenceStatusCodes.getStatusCodeString(event.errorCode)
            return
        }
 
        val transition = event.geofenceTransition
        val triggeringIds = event.triggeringGeofences?.map { it.requestId } ?: return
 
        when (transition) {
            Geofence.GEOFENCE_TRANSITION_ENTER -> handleEnter(context, triggeringIds)
            Geofence.GEOFENCE_TRANSITION_EXIT -> handleExit(context, triggeringIds)
        }
    }
 
    private fun handleEnter(context: Context, ids: List<String>) {
        // Start a coroutine via a dedicated scope or inject via a service/work
        GeofenceEventBus.emit(GeofenceEvent.Enter(ids))
    }
 
    private fun handleExit(context: Context, ids: List<String>) {
        GeofenceEventBus.emit(GeofenceEvent.Exit(ids))
    }
}

<receiver
    android:name=".location.GeofenceBroadcastReceiver"
    android:exported="false" />

class BootReceiver : BroadcastReceiver() {
    override fun onReceive(context: Context, intent: Intent) {
        if (intent.action == Intent.ACTION_BOOT_COMPLETED) {
            // Re-enqueue geofence registration work via WorkManager
            GeofenceRestoreWorker.enqueue(WorkManager.getInstance(context))
        }
    }
}