Geofencing is a potent tool that developers frequently use in the realm of mobile app development. Apps can now recognize when a device enters or leaves a predetermined geographic area thanks to this technology. Using geofencing creates exciting opportunities for location-based services and context-aware apps for Android developers. To learn more about Android geofencing and how to make the most of it, let’s take a closer look at its fundamentals.
What is Geofencing?
Geofencing is a location-based security feature used in mobile device management (MDM) that enables administrators to create rules to limit unwanted access to sensitive company data coming from outside the company. For field devices, or commercially used devices that are dispersed throughout the field, like transportation and logistics, it is especially suitable. With the help of automated workflows, sophisticated analytics tools, and device location tracking, Geofence enables you to increase operational efficiency and security.
Building an app with Android geofencing capabilities
Set up a New Project in Android Studio: Make a new project in Android Studio and start it with an empty activity. Give your project the name “GeofencingExample” and decide where to save it. Choose API level 19, or Android 4.4 KitKat, as the project’s minimum SDK.
Add the Required Dependencies: To add the following dependencies, open the app-level build. gradle file and select them:
dependencies {
implementation ‘com.google.android.gms:play-services-location:18.0.0’
implementation ‘com.google.android.gms:play-services-maps:17.0.1’
}
Set up Google Maps and Geofencing API:
- Go to the Platform Console for Google Cloud.
- Choose an already-existing project or start a new one.
- Go to the “APIs and Services” section and click “Enable APIs and Services.”
- Look up “Geofencing API” and “Google Maps Android API” and turn them both on.
- Make a copy of your API key so you can use it later.
Next, include the API key in the application tag of your AndroidManifest.xml file:
<meta-data
android:name=” com.google.android.geo.API_KEY”
android:value=”YOUR_API_KEY”/>
Implement the Geofencing Functionality: To begin with, create a new class named “GeofenceHelper” to assist with setting up and maintaining our geofences. Include the subsequent code in the class:
public class GeofenceHelper {
public GeofenceHelper() {
}
public Geofence createGeofence(LatLng latLng, float radius, int transitionTypes) {
return new Geofence.Builder()
.setRequestId(generateRequestId())
.setCircularRegion(latLng.latitude, latLng.longitude, radius)
.setExpirationDuration(Geofence.NEVER_EXPIRE)
.setTransitionTypes(transitionTypes)
.build();
}
private String generateRequestId() {
return UUID.randomUUID().toString();
}
}
To create a geofence, add the following technique and add it to the geofencing client:
private void addGeofence(LatLng latLng, float radius) {
Geofence geofence = geofenceHelper.createGeofence(latLng, radius, Geofence.GEOFENCE_TRANSITION_ENTER | Geofence.GEOFENCE_TRANSITION_EXIT);
GeofencingRequest geofencingRequest = new GeofencingRequest.Builder()
.addGeofence(geofence)
.build();
PendingIntent pendingIntent = getGeofencePendingIntent();
geofencingClient.addGeofences(geofencingRequest, pendingIntent)
.addOnSuccessListener(this, new OnSuccessListener<Void>() {
@Override
public void onSuccess(Void aVoid) {
Log.d(TAG, “onSuccess: Geofence Added…”);
}
})
.addOnFailureListener(this, new OnFailureListener() {
@Override
public void onFailure(@NonNull Exception e) {
Log.d(TAG, “onFailure: ” + e.getMessage());
}
});
}
Lastly, extend BroadcastReceiver by creating a new class named “GeofenceBroadcastReceiver”. The geofence transitions will be managed by this class:
public class GeofenceBroadcastReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
GeofencingEvent geofencingEvent = GeofencingEvent.fromIntent(intent);
if (geofencingEvent.hasError()) {
Log.d(TAG, “onReceive: Error receiving geofence event…”);
return;
}
int transition = geofencingEvent.getGeofenceTransition();
if (transition == Geofence.GEOFENCE_TRANSITION_ENTER) {
Log.d(TAG, “onReceive: ENTER”);
} else if (transition == Geofence.GEOFENCE_TRANSITION_EXIT) {
Log.d(TAG, “onReceive: EXIT”);
}
}
}
Test Your Geofencing App
It’s time to test your app now that you’ve added geofencing functionality. Use an actual or virtual Android device to run the app, and make sure the geofence activates when you enter or leave the designated area.
How Does Android Geofencing Work?
When the feature is enabled, modern smartphones are designed to detect their current location. Furthermore, users can choose to receive notifications whenever they enter or exit a location that they have registered as of interest. A geofence provides similar functions, with each area treated as a single geofence point.
To provide more context, each geofence point has three main characteristics.
- Latitude
- Longitude
- Radius
With Android geofencing, a virtual circle with a specified radius is drawn at a given latitude and longitude.
The mobile app notifies the user when they enter or leave a geofence region by signing them up for the events listed below for each geofence point:
- The indicator that the user enters the geofence(s) is GEOFENCE_TRANSISTION_ENTER.
- The GEOFENCE_TRANSISTION_DWELL indicator shows how long a user stays inside geofences after entering them.
- The geofence’s GEOFENCE_TRANSITION_EXIT signal indicates that the user has left it.
Conclusion
Android geofencing enables developers to create context-aware applications that respond to user locations in real-time. Using Google Maps and geofencing APIs, developers can create applications that take specific actions when a user enters or exits predefined geographic areas. On the Android platform, this technology opens up new possibilities for creative location-based services.
