Wie man mit Geofences unter Android arbeitet kann

German (Deutsch) translation by Nikol Angelowa (you can also view the original English article)

Standortbezogene Ressourcen ermöglichen Ihrer Anwendung die Interaktion mit der physischen Welt und sind ideal, um die Benutzerinteraktion zu erhöhen. Obwohl viele mobile Apps sie verwenden, ist das Thema dieses Tutorials eine häufig übersehene Funktion, das Geofencing.

Ein Geofence ist ein virtueller Umkreis, der auf einem realen geografischen Gebiet festgelegt ist. Durch die Kombination einer Benutzerposition mit einem Geofence-Umkreis kann festgestellt werden, ob sich der Benutzer innerhalb oder außerhalb des Geofence befindet oder ob er den Bereich verlässt oder betritt.

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

Stellen Sie sich eine Universitäts-App vor, mit der Sie feststellen können, welche Kollegen und Professoren sich derzeit auf dem Campus befinden. Oder eine App für ein Einkaufszentrum, das Stammkunden belohnt. Es gibt viele andere interessante Möglichkeiten, die Sie erkunden können.

In diesem Lernprogramm erfahren Sie, wie Sie Geofences unter Android verwenden, indem Sie eine Anwendung erstellen, die dem Benutzer eine Benachrichtigung anzeigt, wenn er einen Geofence betritt oder verlässt. Es ist hilfreich, wenn Sie über Vorkenntnisse in Google Play Services, der Google Maps Android API oder IntentService verfügen. Wenn Sie dies nicht tun, können Sie trotzdem mitmachen, aber Sie möchten möglicherweise nach dem Lesen dieses Tutorials Nachforschungen zu diesen Themen anstellen.

1. Geofences auf Android

Unter Android gibt es verschiedene Möglichkeiten, mit Geofences zu arbeiten. Sie können sogar eine eigene Implementierung für die Arbeit mit Geofences erstellen. Die Verwendung von GeofencingApi von Google ist jedoch einfacher.

Diese APIs sind Teil der Location-APIs von Google. Es enthält Geofence, GeofencingRequest, GeofenceApi, GeofencingEvent und GeofenceStatusCodes. In diesem Tutorial verwenden wir diese Klassen, um Geofences zu erstellen und damit zu arbeiten.

Geofence-Schnittstelle

Geofence ist eine Schnittstelle, die ein geografisches Gebiet darstellt, das überwacht werden sollte. Es wird mit dem Geofence.Builder erstellt. Während der Erstellung legen Sie die überwachte Region, das Ablaufdatum des Geofence, die Reaktionsfähigkeit, eine Kennung und die Art der Übergänge fest, nach denen gesucht werden soll.

Um den Stromverbrauch so gering wie möglich zu halten, wird empfohlen, in den meisten Situationen einen Geofence mit einem Radius von mindestens 100 Metern zu verwenden. Wenn sich Geofences auf dem Land befinden, sollten Sie den Radius auf 500 Meter oder mehr erhöhen, um sicherzustellen, dass die Geofences wirksam sind.

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();

Geofence-Übergänge

GEOFENCE_TRANSITION_DWELL gibt an, dass der Benutzer den Bereich betreten und einige Zeit dort verbracht hat. Es ist nützlich, mehrere Warnungen zu vermeiden, wenn der Benutzer den Bereich zu schnell betritt und verlässt. Sie können die Verweilzeit mit dem Parameter setLoiteringDelay konfigurieren.
GEOFENCE_TRANSITION_ENTER gibt an, wann der Benutzer den überwachten Bereich betritt.
GEOFENCE_TRANSITION_EXIT gibt an, wann der Benutzer die Region verlässt.

`GeofenceRequest`

Die GeofencingRequest-Klasse empfängt die Geofences, die überwacht werden sollen. Sie können eine Instanz erstellen, indem Sie einen Builder verwenden, einen Geofence oder eine List<Geofence> übergeben und die Art der Benachrichtigung festlegen, die beim Erstellen des Geofences ausgelöst wird.

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`

Die GeofencingApi-Klasse ist der Einstiegspunkt für alle Interaktionen mit der Geofencing-API von Google. Es ist Teil der Location-APIs und hängt von einem GoogleApiClient ab. Mit GeofencingApi können Sie Geofences hinzufügen und entfernen.

Um einen Geofence hinzuzufügen, rufen Sie die Methode addGeofence() auf. Es überwacht den angegebenen Bereich anhand der an GeofencingRequest übergebenen Einstellungen und erstellt einen PendingIntent, wenn ein Geofence-Übergang beim Betreten oder Verlassen des Bereichs stattfindet.

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

Um den Geofence zu entfernen, rufen Sie removeGeofences() auf. Sie können den Geofence entweder mithilfe seiner Anforderungskennung oder seiner ausstehenden Absicht entfernen.

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

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

2. Erstellen einer Geofencing-App

In diesem Tutorial erstellen wir eine einfache Anwendung, die den Benutzerstandort überwacht und eine Benachrichtigung sendet, wenn der Benutzer einen geofenced Bereich betritt oder verlässt. Die App besteht nur aus einer Activity und einem IntentService. Wir werfen auch einen kurzen Blick auf GoogleMap, GoogleApiClient und FusedLocationProviderApi und untersuchen einige Einschränkungen der Geofence-API.

Schritt 1: Projekteinrichtung

GeofencingApi ist Teil der Google Play Services. Um darauf zugreifen zu können, müssen Sie Ihre Entwicklungsumgebung korrekt einrichten und eine Instanz von GoogleApiClient erstellen. Erstellen Sie ein neues Projekt mit einer leeren Activity, bearbeiten Sie die build.gradle-Datei des Projekts wie unten gezeigt und synchronisieren Sie Ihr Projekt.

Schritt 2: Berechtigungen

Wir müssen die richtigen Berechtigungen festlegen, um Geofences zu erstellen und zu verwenden. Fügen Sie dem Manifest des Projekts die folgende Berechtigung hinzu:

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

Ab Android 6.0 bittet die App zur Laufzeit und nicht während der Installation um Erlaubnis. Wir werden dies später im Tutorial ansprechen.

Schritt 3: Erstellen des Layouts

Das Projekt besteht aus einem Layout, dem MainActivity-Layout. Es enthält den aktuellen Breiten- und Längengrad des Geräts sowie ein GoogleMap-Fragment, in dem die Geofences und die Position des Benutzers angezeigt werden.

Da activity_main.xml ziemlich einfach ist, möchte ich mich nur auf das MapFragment-Element konzentrieren. Sie können sich das fertige Layout in den Quelldateien dieses Tutorials ansehen.

<!--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"/>

Schritt 4: Google Maps API-Schlüssel

Da wir ein MapFragment verwenden, müssen wir eine GoogleMap-Instanz einrichten und initialisieren. Zunächst müssen Sie einen API-Schlüssel erhalten. Wenn Sie einen API-Schlüssel haben, fügen Sie ihn dem Projektmanifest hinzu.

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

Beginnen wir mit der GoogleMap-Instanz. Implementieren Sie GoogleMap.OnMapReadyCallback, GoogleMap.OnMapClickListener und GoogleMap.OnMarkerClickListener in der Activity-Klasse und initialisieren Sie die Karte.

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;
    } 
}

Schritt 5: `GoogleApiClient`

Um die GeofencingApi-Oberfläche verwenden zu können, benötigen wir einen GoogleApiClient-Einstiegspunkt. Implementieren Sie in der Activity einen GoogleApiClient.ConnectionCallbacks und einen GoogleApiClient.OnConnectionFailedListener wie unten gezeigt.

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()");
    }
} 

Schritt 6: `FusedLocationProviderApi`

Wir müssen auch auf den aktuellen Standort des Benutzers zugreifen. Die FusedLocationProviderApi-Schnittstelle gibt uns diese Informationen und ermöglicht eine umfassende Kontrolle der Standortanforderung. Dies ist sehr wichtig, da Standortanforderungen einen direkten Einfluss auf den Batterieverbrauch des Geräts haben.

Implementieren wir nun einen LocationListener. Überprüfen Sie, ob der Benutzer der Anwendung die entsprechenden Berechtigungen erteilt hat, indem Sie die Location-Anforderung erstellen, und zeigen Sie den aktuellen Standort auf dem Bildschirm an.

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 ist wichtig zu beachten, dass die oben erstellte LocationRequest nicht für eine Produktionsumgebung optimiert ist. Das UPDATE_INTERVAL ist zu kurz und würde zu viel Batteriestrom verbrauchen. Eine realistischere Konfiguration für die Produktion könnte sein:

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);
}

Schritt 7: GoogleMap-Marker

Unsere Activity benötigt zwei verschiedene Marker. Ein locationMarker verwendet den vom FusedLocationProviderApi angegebenen Breiten- und Längengrad, um den aktuellen Standort des Geräts zu ermitteln. Ein geoFenceMarker ist das Ziel für die Geofence-Erstellung, da er die letzte Berührung auf der Karte verwendet, um seine Position abzurufen.

@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);
    }
}

Schritt 8: Erstellen eines Geofence

Endlich ist es Zeit, einen Geofence zu erstellen. Wir verwenden den geoFenceMarker als Mittelpunkt für den 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();
}

Als Nächstes erstellen wir das GeofencingRequest-Objekt.

// 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();
}

Wir verwenden ein PendingIntent-Objekt, um einen IntentService aufzurufen, der das GeofenceEvent verarbeitet. Wir erstellen die GeofenceTrasitionService.class später.

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);
}

Wir zeichnen den Geofence auch als visuelle Referenz auf die Karte.

@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 );
}

Die Methode startGeofence() ist für das Starten des Geofencing-Prozesses in der MainActivity-Klasse verantwortlich.

    @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");
        }
    }

Schritt 9: Geofence Transition Service

Wir können jetzt endlich die zuvor erwähnte GeofenceTrasitionService.class erstellen. Diese Klasse erweitert IntentService und ist für die Behandlung des GeofencingEvent verantwortlich. Erstens erhalten wir dieses Ereignis aus der empfangenen Absicht.

1	GeofencingEvent geofencingEvent = GeofencingEvent.fromIntent(intent);

Wir prüfen dann, ob die Art des Geofencing-Übergangs für uns von Interesse ist. Wenn dies der Fall ist, rufen wir eine Liste der ausgelösten Geofences ab und erstellen eine Benachrichtigung mit den entsprechenden Aktionen.

// 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 );
}

Ich habe auch einige Hilfsmethoden implementiert, um die Implementierung der Klasse verständlicher zu machen.

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. Testen

Testen auf einem virtuellen Gerät

Es ist viel einfacher, Geofencing auf einem virtuellen Gerät zu testen. Es gibt verschiedene Möglichkeiten, dies zu tun. Öffnen Sie in Android Studio ein virtuelles Gerät und klicken Sie unten rechts auf die Schaltfläche Weitere Optionen.

Click on More Options

Geben Sie auf der Registerkarte Standort links die Koordinaten für den Standort ein.

Ich bevorzuge die Verwendung von Telnet-Befehlen zur Steuerung des virtuellen Geräts. Um dies zu verwenden, müssen Sie über die Befehlszeile mit dem folgenden Befehl eine Verbindung zum Gerät herstellen:

1	telnet localhost [DEVICE_PORT]

Der Geräteport wird im Fenster des virtuellen Geräts angezeigt. Der Geräteport ist normalerweise gleich 5554.

Möglicherweise müssen Sie diese Verbindung mit Ihrem auth_token autorisieren, aber die Befehlszeile zeigt Ihnen, wo sie sich befindet. Navigieren Sie zu diesem Speicherort, kopieren Sie das Token und geben Sie auth [YOUR_AUTH_TOKEN] ein.

Sie können jetzt den Standort des Geräts festlegen, indem Sie den folgenden Befehl ausführen:

1	geo fix [LATITUDE] [LONGITUDE]

Abschluss

Geofencing kann eine großartige Ergänzung Ihrer App sein, da es die Benutzerinteraktion erheblich steigern kann. Es gibt viele Möglichkeiten zu erkunden und Sie können sogar ein anspruchsvolles Erlebnis mit Indoor-Beacons wie dem Estimote schaffen. Mit Indoor-Beacons wissen Sie genau, wo der Benutzer beispielsweise ein Einkaufszentrum betreten hat.

Das Hinzufügen von Geofencing zu einem Projekt ist einfach, aber wir müssen den Stromverbrauch jederzeit im Auge behalten. Dies bedeutet, dass wir die Größe des Geofence und die Aktualisierungsrate sorgfältig auswählen müssen, da sich beide direkt auf den Stromverbrauch Ihrer Anwendung auswirken.

Das Testen ist daher sehr wichtig, um eine realistische Vorstellung vom Stromverbrauch Ihrer Anwendung zu erhalten. Erwägen Sie außerdem, Benutzern die Option zu geben, Geofencing vollständig zu deaktivieren, wenn sie diese Funktion nicht möchten oder benötigen.