Cómo trabajar con geofences en Android

Spanish (Español) translation by Elías Nicolás (you can also view the original English article)

Los recursos conscientes de la ubicación permiten que su aplicación interactúe con el mundo físico y son ideales para aumentar la participación del usuario. Aunque muchas aplicaciones móviles las usan, el tema de este tutorial es una característica que a menudo se pasa por alto, el geofencing.

Un geofence es un perímetro virtual establecido en un área geográfica real. Combinando la posición de un usuario con un perímetro de geofence, es posible saber si el usuario está dentro o fuera del geofence o incluso si está saliendo o ingresando al área.

A geofence knows if a location is inside or outside its delimited area

Imagine una aplicación universitaria que le puede decir qué colegas y profesores están actualmente en el campus. O una aplicación para un centro comercial que recompensa a los clientes habituales. Hay muchas otras posibilidades interesantes que puedes explorar.

En este tutorial, aprenderá a usar geofences en Android creando una aplicación que muestre al usuario una notificación cuando ingrese o salga de un geofence. Es útil si tiene conocimientos previos de Google Play Services, Google Maps Android API o IntentService. Si no lo hace, entonces puede seguir adelante, pero es posible que desee hacer una investigación sobre estos temas después de leer este tutorial.

1. Geofences en Android

En Android, hay varias formas de trabajar con geofences. Incluso podría crear su propia implementación para trabajar con geofences, pero es más fácil usar GeofencingApi de Google.

Estas API son parte de las API Location de Google. Incluye Geofence, GeofencingRequest, GeofenceApi, GeofencingEvent, y GeofenceStatusCodes. En este tutorial, usamos estas clases para crear y trabajar con geofences.

Interfaz Geofence

Geofence es una interfaz que representa un área geográfica que debe ser monitoreada. Se crea utilizando el Geofence.Builder. Durante su creación, establece la región supervisada, la fecha de caducidad del geofence, la capacidad de respuesta, un identificador y el tipo de transiciones que debe buscar.

Para mantener el consumo de energía al mínimo, se recomienda utilizar un geofence con un radio de al menos 100 metros para la mayoría de las situaciones. Si las geofences están ubicadas en el campo, debe aumentar el radio a 500 metros o más para asegurarse de que las geofences sean efectivas.

Geofence geofence = new Geofence.Builder()
    .setRequestId(GEOFENCE_REQ_ID) // Geofence ID
    .setCircularRegion( LATITUDE, LONGITUDE, RADIUS) // defining fence region
    .setExpirationDuration( DURANTION ) // expiring date
    // Transition types that it should look for
    .setTransitionTypes( Geofence.GEOFENCE_TRANSITION_ENTER | Geofence.GEOFENCE_TRANSITION_EXIT )
    .build();

Transiciones geofence

GEOFENCE_TRANSITION_DWELL indica que el usuario ingresó al área y pasó algún tiempo allí. Es útil evitar múltiples alertas cuando el usuario ingresa y sale del área demasiado rápido. Puede configurar el tiempo de permanencia usando el parámetro setLoiteringDelay.
GEOFENCE_TRANSITION_ENTER indica cuando el usuario ingresa a la región monitoreada.
GEOFENCE_TRANSITION_EXIT indica cuando el usuario sale de la región.

`GeofenceRequest`

GeofencingRequest recibe las geofences que deben ser monitoreadas. Puede crear una instancia utilizando un Builder, pasando un Geofence o una List<Geofence>, y el tipo de notificación que se activará cuando se crean los geofence(s).

GeofencingRequest request = new GeofencingRequest.Builder()
    // Notification to trigger when the Geofence is created
    .setInitialTrigger( GeofencingRequest.INITIAL_TRIGGER_ENTER )
    .addGeofence( geofence ) // add a Geofence
    .build();

`GeofencingApi`

La clase GeofencingApi es el punto de entrada para todas las interacciones con la API de geofencing de Google. Es parte de las API Location y depende de un GoogleApiClient para que funcione. Utilizará GeofencingApi para agregar y eliminar geofences.

Para agregar un geofence, llame al método addGeofence(). Supervisa el área dada utilizando la configuración pasada a GeofencingRequest y dispara un PendingIntent cuando se produce una transición de geofence, entrando o saliendo del área.

1	PendingResult<Status> addGeofences (GoogleApiClient client,
2	GeofencingRequest geofencingRequest,
3	PendingIntent pendingIntent)

Para eliminar el geofence, llame a removeGeofences(). Puede eliminar el geofence usando su identificador de solicitud o su intento pendiente.

1	PendingResult<Status> removeGeofences(GoogleApiClient client,
2	List<String> geofenceRequestIds)

1	PendingResult<Status> removeGeofences (GoogleApiClient client,
2	PendingIntent pendingIntent)

2. Creando una aplicación de geofencing

En este tutorial, creamos una aplicación simple que supervisa la ubicación del usuario y publica una notificación cuando el usuario ingresa o sale de un área geofence. La aplicación consta de una sola Activity y un IntentService. También echamos un vistazo rápido a GoogleMap, GoogleApiClient, y FusedLocationProviderApi, y exploramos algunas advertencias de la API de geofence.

Paso 1: Configuración del proyecto

GeofencingApi es parte de Google Play Services. Para acceder a él, debe configurar correctamente su entorno de desarrollo y crear una instancia de GoogleApiClient. Cree un nuevo proyecto con una Activity, en blanco, edite el archivo build.gradle del proyecto como se muestra a continuación y sincronice su proyecto.

Paso 2: Permisos

Necesitamos establecer los permisos correctos para crear y usar geofences. Agregue el siguiente permiso al manifiesto del proyecto:

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

A partir de Android 6.0, la aplicación solicita permiso en tiempo de ejecución y no durante la instalación. Abordaremos esto más adelante en el tutorial.

Paso 3: Crear el diseño

El proyecto consta de un diseño, el diseño MainActity. Contiene la latitud y longitud actuales del dispositivo, y un fragmento de GoogleMap que muestra las geofences y la posición del usuario.

Dado que activity_main.xml es bastante sencillo, quiero concentrarme solo en el elemento MapFragment. Puede ver el diseño completado en los archivos de origen de este tutorial.

<!--GoogleMap fragment-->
<fragment xmlns:android="http://schemas.android.com/apk/res/android"
    android:name="com.google.android.gms.maps.MapFragment"
    android:id="@+id/map"
    android:layout_width="match_parent"
    android:layout_height="match_parent"/>

Paso 4: Clave API de Google Maps

Como estamos usando un MapFragment, necesitamos configurar e inicializar una instancia de GoogleMap. Primero, necesitas obtener una clave API. Una vez que tenga una clave API, agréguela al manifiesto del proyecto.

1	<meta-data
2	android:name="com.google.android.geo.API_KEY"
3	android:value="YOUR_API_KEY"/>

Vamos a empezar con la instancia de GoogleMap. Implemente GoogleMap.OnMapReadyCallback, GoogleMap.OnMapClickListener, y GoogleMap.OnMarkerClickListener en la clase Activity e inicialice el mapa.

public class MainActivity extends AppCompatActivity
    implements 
  		OnMapReadyCallback, 
			GoogleMap.OnMapClickListener,
            GoogleMap.OnMarkerClickListener
    {
    
    private static final String TAG = MainActivity.class.getSimpleName();
        
    private TextView textLat, textLong;
    private MapFragment mapFragment;
    private GoogleMap map;
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        textLat = (TextView) findViewById(R.id.lat);
        textLong = (TextView) findViewById(R.id.lon);
        
        // initialize GoogleMaps
        initGMaps();
    }
    
    // Initialize GoogleMaps
    private void initGMaps(){
        mapFragment = (MapFragment) getFragmentManager().findFragmentById(R.id.map);
        mapFragment.getMapAsync(this);
    } 
    
    // Callback called when Map is ready
    @Override
    public void onMapReady(GoogleMap googleMap) {
        Log.d(TAG, "onMapReady()");
        map = googleMap;
        map.setOnMapClickListener(this);
        map.setOnMarkerClickListener(this);
    }
    
	// Callback called when Map is touched
    @Override
    public void onMapClick(LatLng latLng) {
        Log.d(TAG, "onMapClick("+latLng +")");
    }

	// Callback called when Marker is touched
    @Override
    public boolean onMarkerClick(Marker marker) {
        Log.d(TAG, "onMarkerClickListener: " + marker.getPosition() );
        return false;
    } 
}

Paso 5: `GoogleApiClient`

Para utilizar la interfaz GeofencingApi, necesitamos un punto de entrada GoogleApiClient. Implementemos un GoogleApiClient.ConnectionCallbacks y un GoogleApiClient.OnConnectionFailedListener en Activity como se muestra a continuación.

public class MainActivity extends AppCompatActivity
        implements
            GoogleApiClient.ConnectionCallbacks,
            GoogleApiClient.OnConnectionFailedListener,
            OnMapReadyCallback,
            GoogleMap.OnMapClickListener,
            GoogleMap.OnMarkerClickListener {
            
    // ...
    private GoogleApiClient googleApiClient;
            
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        
        // ...

        // create GoogleApiClient
        createGoogleApi();
    }
    
    // Create GoogleApiClient instance
    private void createGoogleApi() {
        Log.d(TAG, "createGoogleApi()");
        if ( googleApiClient == null ) {
            googleApiClient = new GoogleApiClient.Builder( this )
                    .addConnectionCallbacks( this )
                    .addOnConnectionFailedListener( this )
                    .addApi( LocationServices.API )
                    .build();
        }
    }
    
    @Override
    protected void onStart() {
        super.onStart();

        // Call GoogleApiClient connection when starting the Activity
        googleApiClient.connect();
    }

    @Override
    protected void onStop() {
        super.onStop();

        // Disconnect GoogleApiClient when stopping Activity
        googleApiClient.disconnect();
    }
    
    // GoogleApiClient.ConnectionCallbacks connected
    @Override
    public void onConnected(@Nullable Bundle bundle) {
        Log.i(TAG, "onConnected()");
    }

    // GoogleApiClient.ConnectionCallbacks suspended
    @Override
    public void onConnectionSuspended(int i) {
        Log.w(TAG, "onConnectionSuspended()");
    }

    // GoogleApiClient.OnConnectionFailedListener fail
    @Override
    public void onConnectionFailed(@NonNull ConnectionResult connectionResult) {
        Log.w(TAG, "onConnectionFailed()");
    }
} 

Paso 6: `FusedLocationProviderApi`

También necesitamos acceder a la ubicación actual del usuario. La interfaz FusedLocationProviderApi nos proporciona esta información y permite un gran nivel de control de la solicitud de ubicación. Esto es muy importante, ya que las solicitudes de ubicación tienen un efecto directo sobre el consumo de la batería del dispositivo.

Ahora, implementemos un LocationListener. Verifique si el usuario le dio a la aplicación los permisos apropiados creando la solicitud Location y muestre su ubicación actual en la pantalla.

public class MainActivity extends AppCompatActivity
        implements
            // ....
            LocationListener
            {
            
    private Location lastLocation;
    //...
    
    // GoogleApiClient.ConnectionCallbacks connected
    @Override
    public void onConnected(@Nullable Bundle bundle) {
        Log.i(TAG, "onConnected()");
        getLastKnownLocation();
    }
    
    // Get last known location
    private void getLastKnownLocation() {
        Log.d(TAG, "getLastKnownLocation()");
        if ( checkPermission() ) {
            lastLocation = LocationServices.FusedLocationApi.getLastLocation(googleApiClient);
            if ( lastLocation != null ) {
                Log.i(TAG, "LasKnown location. " +
                        "Long: " + lastLocation.getLongitude() +
                        " | Lat: " + lastLocation.getLatitude());
                writeLastLocation();
                startLocationUpdates();
            } else {
                Log.w(TAG, "No location retrieved yet");
                startLocationUpdates();
            }
        }
        else askPermission();
    }
    
    private LocationRequest locationRequest;
    // Defined in mili seconds. 
    // This number in extremely low, and should be used only for debug
    private final int UPDATE_INTERVAL =  1000;
    private final int FASTEST_INTERVAL = 900;

    // Start location Updates
    private void startLocationUpdates(){
        Log.i(TAG, "startLocationUpdates()");
        locationRequest = LocationRequest.create()
                .setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY)
                .setInterval(UPDATE_INTERVAL)
                .setFastestInterval(FASTEST_INTERVAL);

        if ( checkPermission() )
            LocationServices.FusedLocationApi.requestLocationUpdates(googleApiClient, locationRequest, this);
    }
    
    @Override
    public void onLocationChanged(Location location) {
        Log.d(TAG, "onLocationChanged ["+location+"]");
        lastLocation = location;
        writeActualLocation(location);
    }
    
    // Write location coordinates on UI
    private void writeActualLocation(Location location) {
        textLat.setText( "Lat: " + location.getLatitude() );
        textLong.setText( "Long: " + location.getLongitude() );
    }

    private void writeLastLocation() {
        writeActualLocation(lastLocation);
    }
    
    // Check for permission to access Location
    private boolean checkPermission() {
        Log.d(TAG, "checkPermission()");
        // Ask for permission if it wasn't granted yet
        return (ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_FINE_LOCATION)
                == PackageManager.PERMISSION_GRANTED );
    }
    
    // Asks for permission
    private void askPermission() {
        Log.d(TAG, "askPermission()");
        ActivityCompat.requestPermissions(
                this,
                new String[] { Manifest.permission.ACCESS_FINE_LOCATION },
                REQ_PERMISSION
        );
    }

    // Verify user's response of the permission requested
    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        Log.d(TAG, "onRequestPermissionsResult()");
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        switch ( requestCode ) {
            case REQ_PERMISSION: {
                if ( grantResults.length > 0
                        && grantResults[0] == PackageManager.PERMISSION_GRANTED ){
                    // Permission granted
                    getLastKnownLocation();

                } else {
                    // Permission denied
                    permissionsDenied();
                }
                break;
            }
        }
    }

    // App cannot work without the permissions
    private void permissionsDenied() {
        Log.w(TAG, "permissionsDenied()");
    }
}

Es importante tener en cuenta que el LocationRequest creado anteriormente no está optimizado para un entorno de producción. El UPDATE_INTERVAL es demasiado corto y consumiría demasiada energía de la batería. Una configuración más realista para la producción podría ser:

private final int UPDATE_INTERVAL =  3 * 60 * 1000; // 3 minutes
private final int FASTEST_INTERVAL = 30 * 1000;  // 30 secs
private void startLocationUpdates(){
        Log.i(TAG, "startLocationUpdates()");
        locationRequest = LocationRequest.create()
                .setPriority(LocationRequest.PRIORITY_HIGH_ACCURACY)
                .setInterval(UPDATE_INTERVAL)
                .setFastestInterval(FASTEST_INTERVAL);

        if ( checkPermission() )
            LocationServices.FusedLocationApi.requestLocationUpdates(googleApiClient, locationRequest, this);
}

Paso 7: Marcadores GoogleMap

Nuestra Activity necesita dos marcadores diferentes. Un locationMarker usa la latitud y longitud que proporciona FusedLocationProviderApi para informar la ubicación actual del dispositivo. Un geoFenceMarker es el objetivo para la creación de geofence ya que usa el último toque dado en el mapa para recuperar su posición.

@Override
public void onMapClick(LatLng latLng) {
    Log.d(TAG, "onMapClick("+latLng +")");
    markerForGeofence(latLng);
}

private void writeActualLocation(Location location) {
    // ...
    markerLocation(new LatLng(location.getLatitude(), location.getLongitude()));
}

private Marker locationMarker;
// Create a Location Marker 
private void markerLocation(LatLng latLng) {
    Log.i(TAG, "markerLocation("+latLng+")");
    String title = latLng.latitude + ", " + latLng.longitude;
    MarkerOptions markerOptions = new MarkerOptions()
            .position(latLng)
            .title(title);
    if ( map!=null ) {
        // Remove the anterior marker
        if ( locationMarker != null )
            locationMarker.remove();
        locationMarker = map.addMarker(markerOptions);
        float zoom = 14f;
        CameraUpdate cameraUpdate = CameraUpdateFactory.newLatLngZoom(latLng, zoom);
        map.animateCamera(cameraUpdate);
    }
}

private Marker geoFenceMarker;
// Create a marker for the geofence creation
private void markerForGeofence(LatLng latLng) {
    Log.i(TAG, "markerForGeofence("+latLng+")");
    String title = latLng.latitude + ", " + latLng.longitude;
    // Define marker options
    MarkerOptions markerOptions = new MarkerOptions()
            .position(latLng)
            .icon(BitmapDescriptorFactory.defaultMarker(BitmapDescriptorFactory.HUE_ORANGE))
            .title(title);
    if ( map!=null ) {
        // Remove last geoFenceMarker
        if (geoFenceMarker != null)
            geoFenceMarker.remove();

        geoFenceMarker = map.addMarker(markerOptions);
    }
}

Paso 8: Creando un Geofence

Por fin, es hora de crear un geofence. Usamos el geoFenceMarker como el punto central para el geofence.

private static final long GEO_DURATION = 60 * 60 * 1000;
private static final String GEOFENCE_REQ_ID = "My Geofence";
private static final float GEOFENCE_RADIUS = 500.0f; // in meters

// Create a Geofence
private Geofence createGeofence( LatLng latLng, float radius ) {
    Log.d(TAG, "createGeofence");
    return new Geofence.Builder()
            .setRequestId(GEOFENCE_REQ_ID)
            .setCircularRegion( latLng.latitude, latLng.longitude, radius)
            .setExpirationDuration( GEO_DURATION )
            .setTransitionTypes( Geofence.GEOFENCE_TRANSITION_ENTER
                    | Geofence.GEOFENCE_TRANSITION_EXIT )
            .build();
}

A continuación, creamos el objeto GeofencingRequest.

// Create a Geofence Request
private GeofencingRequest createGeofenceRequest( Geofence geofence ) {
    Log.d(TAG, "createGeofenceRequest");
    return new GeofencingRequest.Builder()
            .setInitialTrigger( GeofencingRequest.INITIAL_TRIGGER_ENTER )
            .addGeofence( geofence )
            .build();
}

Utilizamos un objeto PendingIntent para llamar a un IntentServiceque manejará GeofenceEvent. Creamos el GeofenceTrasitionService.class más tarde.

private PendingIntent geoFencePendingIntent;
private final int GEOFENCE_REQ_CODE = 0;
private PendingIntent createGeofencePendingIntent() {
    Log.d(TAG, "createGeofencePendingIntent");
    if ( geoFencePendingIntent != null )
        return geoFencePendingIntent;

    Intent intent = new Intent( this, GeofenceTrasitionService.class);
    return PendingIntent.getService(
            this, GEOFENCE_REQ_CODE, intent, PendingIntent.FLAG_UPDATE_CURRENT );
}

// Add the created GeofenceRequest to the device's monitoring list
private void addGeofence(GeofencingRequest request) {
    Log.d(TAG, "addGeofence");
    if (checkPermission())
        LocationServices.GeofencingApi.addGeofences(
                googleApiClient,
                request,
                createGeofencePendingIntent()
        ).setResultCallback(this);
}

También dibujamos la geofence en el mapa como referencia visual.

@Override
public void onResult(@NonNull Status status) {
    Log.i(TAG, "onResult: " + status);
    if ( status.isSuccess() ) {
        drawGeofence();
    } else {
        // inform about fail
    }
}

// Draw Geofence circle on GoogleMap
private Circle geoFenceLimits;
private void drawGeofence() {
    Log.d(TAG, "drawGeofence()");

    if ( geoFenceLimits != null )
        geoFenceLimits.remove();

    CircleOptions circleOptions = new CircleOptions()
            .center( geoFenceMarker.getPosition())
            .strokeColor(Color.argb(50, 70,70,70))
            .fillColor( Color.argb(100, 150,150,150) )
            .radius( GEOFENCE_RADIUS );
    geoFenceLimits = map.addCircle( circleOptions );
}

El método startGeofence() es responsable de iniciar el proceso de geofencing en la clase MainActivity.

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        switch ( item.getItemId() ) {
            case R.id.geofence: {
                startGeofence();
                return true;
            }
        }
        return super.onOptionsItemSelected(item);
    }
    
	// Start Geofence creation process
    private void startGeofence() {
        Log.i(TAG, "startGeofence()");
        if( geoFenceMarker != null ) {
            Geofence geofence = createGeofence( geoFenceMarker.getPosition(), GEOFENCE_RADIUS );
            GeofencingRequest geofenceRequest = createGeofenceRequest( geofence );
            addGeofence( geofenceRequest );
        } else {
            Log.e(TAG, "Geofence marker is null");
        }
    }

Paso 9: Servicio de transición Geofence

Ahora podemos finalmente crear el GeofenceTrasitionService.class mencionado anteriormente. Esta clase extiende IntentService y es responsable de manejar GeofencingEvent. Primero, obtenemos este evento de la intención recibida.

1	GeofencingEvent geofencingEvent = GeofencingEvent.fromIntent(intent);

Luego verificamos si el tipo de transición de geofencing que tuvo lugar nos interesa. Si es así, recuperamos una lista de las geofences activadas y creamos una notificación con las acciones apropiadas.

// Retrieve GeofenceTrasition
int geoFenceTransition = geofencingEvent.getGeofenceTransition();
// Check if the transition type
if ( geoFenceTransition == Geofence.GEOFENCE_TRANSITION_ENTER ||
        geoFenceTransition == Geofence.GEOFENCE_TRANSITION_EXIT ) {
    // Get the geofence that were triggered
    List<Geofence> triggeringGeofences = geofencingEvent.getTriggeringGeofences();
    // Create a detail message with Geofences received
    String geofenceTransitionDetails = getGeofenceTrasitionDetails(geoFenceTransition, triggeringGeofences );
    // Send notification details as a String
    sendNotification( geofenceTransitionDetails );
}

También he implementado algunos métodos de ayuda para hacer que la implementación de la clase sea más fácil de entender.

public class GeofenceTrasitionService extends IntentService {

    private static final String TAG = GeofenceTrasitionService.class.getSimpleName();
    public static final int GEOFENCE_NOTIFICATION_ID = 0;

    public GeofenceTrasitionService() {
        super(TAG);
    }

    @Override
    protected void onHandleIntent(Intent intent) {
        // Retrieve the Geofencing intent
        GeofencingEvent geofencingEvent = GeofencingEvent.fromIntent(intent);

        // Handling errors
        if ( geofencingEvent.hasError() ) {
            String errorMsg = getErrorString(geofencingEvent.getErrorCode() );
            Log.e( TAG, errorMsg );
            return;
        }

		// Retrieve GeofenceTrasition
        int geoFenceTransition = geofencingEvent.getGeofenceTransition();
        // Check if the transition type
        if ( geoFenceTransition == Geofence.GEOFENCE_TRANSITION_ENTER ||
                geoFenceTransition == Geofence.GEOFENCE_TRANSITION_EXIT ) {
            // Get the geofence that were triggered
            List<Geofence> triggeringGeofences = geofencingEvent.getTriggeringGeofences();
			// Create a detail message with Geofences received
            String geofenceTransitionDetails = getGeofenceTrasitionDetails(geoFenceTransition, triggeringGeofences );
            // Send notification details as a String
            sendNotification( geofenceTransitionDetails );
        }
    }
	
	// Create a detail message with Geofences received
    private String getGeofenceTrasitionDetails(int geoFenceTransition, List<Geofence> triggeringGeofences) {
        // get the ID of each geofence triggered
        ArrayList<String> triggeringGeofencesList = new ArrayList<>();
        for ( Geofence geofence : triggeringGeofences ) {
            triggeringGeofencesList.add( geofence.getRequestId() );
        }

        String status = null;
        if ( geoFenceTransition == Geofence.GEOFENCE_TRANSITION_ENTER )
            status = "Entering ";
        else if ( geoFenceTransition == Geofence.GEOFENCE_TRANSITION_EXIT )
            status = "Exiting ";
        return status + TextUtils.join( ", ", triggeringGeofencesList);
    }

	// Send a notification
    private void sendNotification( String msg ) {
        Log.i(TAG, "sendNotification: " + msg );

        // Intent to start the main Activity
        Intent notificationIntent = MainActivity.makeNotificationIntent(
                getApplicationContext(), msg
        );

        TaskStackBuilder stackBuilder = TaskStackBuilder.create(this);
        stackBuilder.addParentStack(MainActivity.class);
        stackBuilder.addNextIntent(notificationIntent);
        PendingIntent notificationPendingIntent = stackBuilder.getPendingIntent(0, PendingIntent.FLAG_UPDATE_CURRENT);

        // Creating and sending Notification
        NotificationManager notificatioMng =
                (NotificationManager) getSystemService( Context.NOTIFICATION_SERVICE );
        notificatioMng.notify(
                GEOFENCE_NOTIFICATION_ID,
                createNotification(msg, notificationPendingIntent));
    }

    // Create a notification
    private Notification createNotification(String msg, PendingIntent notificationPendingIntent) {
        NotificationCompat.Builder notificationBuilder = new NotificationCompat.Builder(this);
        notificationBuilder
                .setSmallIcon(R.drawable.ic_action_location)
                .setColor(Color.RED)
                .setContentTitle(msg)
                .setContentText("Geofence Notification!")
                .setContentIntent(notificationPendingIntent)
                .setDefaults(Notification.DEFAULT_LIGHTS | Notification.DEFAULT_VIBRATE | Notification.DEFAULT_SOUND)
                .setAutoCancel(true);
        return notificationBuilder.build();
    }

	// Handle errors
    private static String getErrorString(int errorCode) {
        switch (errorCode) {
            case GeofenceStatusCodes.GEOFENCE_NOT_AVAILABLE:
                return "GeoFence not available";
            case GeofenceStatusCodes.GEOFENCE_TOO_MANY_GEOFENCES:
                return "Too many GeoFences";
            case GeofenceStatusCodes.GEOFENCE_TOO_MANY_PENDING_INTENTS:
                return "Too many pending intents";
            default:
                return "Unknown error.";
        }
    }
}

3. Pruebas

Pruebas en un dispositivo virtual

Es mucho más sencillo probar el geofencing en un dispositivo virtual. Hay varias formas de hacerlo. En Android Studio, abra un dispositivo virtual y haga clic en el botón más opciones en la parte inferior derecha.

Click on More Options

En la pestaña Location a la izquierda, ingrese las coordenadas para la ubicación.

Prefiero usar los comandos telnet para controlar el dispositivo virtual. Para usar esto, necesita conectarse al dispositivo desde la línea de comandos usando el siguiente comando:

1	telnet localhost [DEVICE_PORT]

El puerto del dispositivo se muestra en la ventana del dispositivo virtual. El puerto del dispositivo suele ser igual a 5554.

Es posible que necesite autorizar esta conexión utilizando su auth_token, pero la línea de comandos le muestra dónde se encuentra. Vaya a esa ubicación y copie el token y el tipo, auth [TU_TOKEN].

Ahora puede establecer la ubicación del dispositivo ejecutando el siguiente comando:

1	geo fix [LATITUDE] [LONGITUDE]

Conclusión

Geofencing puede ser una gran adición a su aplicación, ya que puede aumentar considerablemente la participación del usuario. Hay muchas posibilidades para explorar e incluso podría crear una experiencia sofisticada utilizando balizas interiores, como el Estimote. Con balizas interiores, usted sabe exactamente dónde ha pasado el usuario, por ejemplo, un centro comercial.

Agregar Geofencing a un proyecto es simple, pero debemos tener en cuenta el consumo de energía en todo momento. Esto significa que debemos elegir cuidadosamente el tamaño de la geofence y la tasa de actualización porque ambos afectan directamente el consumo de energía de su aplicación.

Por lo tanto, las pruebas son muy importantes para tener una idea realista del consumo de energía de su aplicación. También considere darles a los usuarios la opción de desactivar el geofencing por completo si no quieren o necesitan esta función.