Geofencing and Location Tracking in Android Development

Geofencing and location tracking are essential features in many Android apps, providing functionality such as real-time location monitoring, location-based notifications, and geospatial data processing. This article will walk you through using geofencing and tracking location with the Android Location Services API, including how to implement geofencing using Google's Geofencing API in Kotlin.

What is Geofencing?

Geofencing is the process of creating a virtual boundary around a physical location. When a device enters or exits this boundary, the app can trigger specific actions, such as sending notifications or performing background tasks. Geofencing is commonly used in apps like location-based reminders, geolocation tracking, and notifications for nearby locations (e.g., restaurants, stores, etc.).

Setting Up Location and Geofencing in Android

To use location tracking and geofencing, you need to add the necessary permissions, dependencies, and Google Play services.

1. Add Permissions in AndroidManifest.xml

Start by adding location permissions to your app’s manifest file to allow the app to access the user’s location.

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

2. Add Dependencies

To access location services and geofencing, you need to include the necessary dependencies in your build.gradle file:

    dependencies {
        implementation 'com.google.android.gms:play-services-location:18.0.0'
    }

Geofencing in Android

Android provides the GeofencingClient API for implementing geofencing. This allows you to create geofences and receive notifications when the device enters or exits a defined area.

3. Create a Geofence

To set up a geofence, define the location (latitude, longitude), radius, and expiration time for the geofence. You can also specify the transitions you want to track (enter, exit, dwell).

    import com.google.android.gms.location.Geofence
    import com.google.android.gms.location.GeofencingRequest
    import com.google.android.gms.location.GeofencingClient
    import com.google.android.gms.location.GeofenceStatusCodes
    import com.google.android.gms.maps.model.LatLng
    import android.content.Context

    class GeofenceHelper(context: Context) {

        private var geofencingClient: GeofencingClient = LocationServices.getGeofencingClient(context)

        fun addGeofence(latLng: LatLng, radius: Float, geofenceId: String) {
            val geofence = Geofence.Builder()
                .setRequestId(geofenceId)
                .setCircularRegion(latLng.latitude, latLng.longitude, radius)
                .setExpirationDuration(Geofence.NEVER_EXPIRE)
                .setTransitionTypes(Geofence.GEOFENCE_TRANSITION_ENTER or Geofence.GEOFENCE_TRANSITION_EXIT)
                .build()

            val geofencingRequest = GeofencingRequest.Builder()
                .setInitialTrigger(GeofencingRequest.INITIAL_TRIGGER_ENTER)
                .addGeofence(geofence)
                .build()

            geofencingClient.addGeofences(geofencingRequest, getGeofencePendingIntent())
                .addOnSuccessListener {
                    // Geofence added successfully
                }
                .addOnFailureListener { e ->
                    // Handle error
                    if (e is GeofenceStatusCodes) {
                        println("Geofence Error: ${e.statusCode}")
                    }
                }
        }

        private fun getGeofencePendingIntent(): PendingIntent {
            // Return a PendingIntent to handle geofence transitions
        }
    }

4. Monitor Geofence Transitions

After adding a geofence, you need to handle geofence transitions. For this, you’ll need to create a BroadcastReceiver that listens for geofence transition events and responds accordingly.

    class GeofenceReceiver : BroadcastReceiver() {
        override fun onReceive(context: Context, intent: Intent) {
            val geofencingEvent = GeofencingEvent.fromIntent(intent)
            if (geofencingEvent.hasError()) {
                // Handle error
                return
            }

            val transition = geofencingEvent.geofenceTransition
            if (transition == Geofence.GEOFENCE_TRANSITION_ENTER) {
                // Handle entering geofence
            } else if (transition == Geofence.GEOFENCE_TRANSITION_EXIT) {
                // Handle exiting geofence
            }
        }
    }

5. Register the Receiver

Finally, register the receiver in your app to handle geofence transitions:

    val filter = IntentFilter(GeofenceReceiver.ACTION_GEOFENCE_TRANSITION)
    registerReceiver(geofenceReceiver, filter)

Location Tracking in Android

Location tracking allows you to monitor the user’s real-time location. This can be achieved using the FusedLocationProviderClient API, which is part of Google Play Services. It provides a more efficient and accurate way to track the device's location.

6. Requesting Location Updates

To request location updates, you can use the following approach:

    import com.google.android.gms.location.FusedLocationProviderClient
    import com.google.android.gms.location.LocationRequest
    import com.google.android.gms.location.LocationCallback
    import com.google.android.gms.location.LocationResult
    import com.google.android.gms.location.LocationServices

    class LocationHelper(context: Context) {

        private var fusedLocationClient: FusedLocationProviderClient = LocationServices.getFusedLocationProviderClient(context)

        fun startLocationUpdates() {
            val locationRequest = LocationRequest.create().apply {
                interval = 10000
                fastestInterval = 5000
                priority = LocationRequest.PRIORITY_HIGH_ACCURACY
            }

            val locationCallback = object : LocationCallback() {
                override fun onLocationResult(locationResult: LocationResult) {
                    super.onLocationResult(locationResult)
                    val location = locationResult.lastLocation
                    // Handle location updates
                }
            }

            fusedLocationClient.requestLocationUpdates(locationRequest, locationCallback, Looper.getMainLooper())
        }
    }

7. Stopping Location Updates

To stop receiving location updates, use the following method:

    fusedLocationClient.removeLocationUpdates(locationCallback)

Conclusion

Geofencing and location tracking are powerful tools that can be used to build location-aware Android applications. Whether you're developing a geolocation-based reminder app, or you need real-time location updates, Android provides the necessary tools to handle these tasks efficiently. With the help of the GeofencingClient and FusedLocationProviderClient APIs, you can implement robust geofencing and location tracking features in your app.




Advertisement