Cara Bekerja dengan Geofences di Android

() translation by (you can also view the original English article)

Sumber daya yang sadar lokasi memungkinkan aplikasi Anda berinteraksi dengan dunia fisik dan mereka ideal untuk meningkatkan keterlibatan pengguna. Meski banyak aplikasi mobile menggunakannya, topik tutorial ini adalah fitur yang sering diabaikan, geofencing.

Geofence adalah perimeter virtual yang berada pada area geografis yang nyata. Menggabungkan posisi pengguna dengan perimeter geofence, adalah mungkin untuk mengetahui apakah pengguna berada di dalam atau di luar geofence atau bahkan jika dia keluar atau memasuki area tersebut.

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

Geofence tahu jika lokasi ada di dalam atau di luar area yang dibatasi penggunaannyaBayangkan sebuah aplikasi universitas yang bisa memberi tahu Anda kolega dan profesor mana yang saat ini berada di kampus. Atau aplikasi untuk mal yang memberi penghargaan kepada pelanggan reguler. Ada banyak kemungkinan menarik lainnya yang bisa Anda jelajahi.

Dalam tutorial ini, Anda belajar bagaimana menggunakan geofences di Android dengan membuat aplikasi yang menunjukkan pemberitahuan kepada pengguna saat mereka masuk atau keluar dari geofence. Ini membantu jika Anda memiliki pengetahuan sebelumnya tentang Google Play Services, API Android Google Maps, atau IntentService. Jika tidak, maka Anda masih bisa mengikuti, tapi Anda mungkin ingin melakukan penelitian tentang topik-topik ini setelah membaca tutorial ini.

1. Geofences di Android

Di Android, ada beberapa cara untuk bekerja dengan geofences. Anda bahkan bisa membuat implementasi sendiri untuk bekerja dengan geofences, namun lebih mudah menggunakan GeofencingApi Google.

API ini adalah bagian dari API Location Google. Ini termasuk Geofence, GeofencingRequest, GeofenceApi, GeofencingEvent, dan GeofenceStatusCodes. Dalam tutorial ini, kita menggunakan kelas-kelas ini untuk membuat dan bekerja dengan geofences.

Antarmuka Geofence

Geofence adalah antarmuka yang mewakili area geografis yang harus dipantau. Ini dibuat dengan menggunakan Geofence.Builder. Selama pembuatannya, Anda menetapkan wilayah yang dipantau, tanggal kedaluwarsa geofence, sifat responsif, pengenal, dan jenis transisi yang seharusnya dicari.

Untuk menjaga konsumsi daya seminimal mungkin, disarankan untuk menggunakan geofence dengan radius minimal 100 meter untuk kebanyakan situasi. Jika geofences berada di pedesaan, Anda harus meningkatkan radius menjadi 500 meter atau lebih tinggi untuk memastikan geofences efektif.

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

Transisi Geofence

GEOFENCE_TRANSITION_DWELL menunjukkan bahwa pengguna memasuki area tersebut dan menghabiskan beberapa waktu di sana. Hal ini berguna untuk menghindari banyak peringatan saat pengguna masuk dan keluar dari area terlalu cepat. Anda dapat mengkonfigurasi waktu tinggal dengan menggunakan parameter setLoiteringDelay.
GEOFENCE_TRANSITION_ENTER menunjukkan kapan pengguna memasuki wilayah yang dipantau.
GEOFENCE_TRANSITION_EXIT menunjukkan kapan pengguna keluar dari wilayah ini.

`GeofenceRequest`

Kelas GeofencingRequest menerima geofences yang harus dipantau. Anda dapat membuat sebuah instance dengan menggunakan Builder, mengirimkan Geofence atau List<Geofence>, dan jenis notifikasi untuk dipicu saat geofence dibuat.

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`

Kelas GeofencingApi adalah titik masuk untuk semua interaksi dengan API geofencing Google. Ini adalah bagian dari API Location dan bergantung pada GoogleApiClient untuk bekerja. Anda akan menggunakan GeofencingApi untuk menambahkan dan menghapus geofence.

Untuk menambahkan geofence, Anda memanggil metode addGeofence(). Ini memonitor area yang diberikan dengan menggunakan pengaturan yang dikirimkan ke GeofencingRequest dan menembakkan PendingIntent saat terjadi transisi geofence, masuk atau keluar dari area.

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

Untuk menghapus geofence, Anda memanggil removeGeofences(). Anda bisa menghapus geofence menggunakan permintaan pengenal atau pending intent-nya.

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

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

2. Membuat Aplikasi Geofencing

Dalam tutorial ini, kita membuat aplikasi sederhana yang memantau lokasi pengguna dan memposting notifikasi saat pengguna memasuki atau keluar dari area geofence. Aplikasi hanya terdiri dari satu Activity dan IntentService. Kita juga melihat sekilas GoogleMap, GoogleApiClient, dan FusedLocationProviderApi, dan kita menjelajahi beberapa peringatan API geofence.

Langkah 1: Setup Proyek

GeofencingApi adalah bagian dari Layanan Google Play. Untuk mengaksesnya, Anda harus menyiapkan lingkungan pengembangan dengan benar dan membuat instance dari GoogleApiClient. Buat proyek baru dengan Activity kosong, edit file build.gradle proyek seperti yang ditunjukkan di bawah ini, dan sinkronkan proyek Anda.

Langkah 2: Izin

Kita perlu mengatur hak akses yang benar untuk membuat dan menggunakan geofences. Tambahkan izin berikut ke manifest proyek:

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

Dimulai dengan Android 6.0, aplikasi meminta izin pada waktu berjalan dan tidak selama penginstalan. Kita membahasnya nanti di tutorial.

Langkah 3: Membuat Layout

Proyek ini terdiri dari satu layout, layout MainActivity. Ini berisi garis lintang dan bujur perangkat saat ini, dan fragmen GoogleMap yang menampilkan geofences dan posisi pengguna.

Karena activity_main.xml cukup mudah, saya ingin berkonsentrasi hanya pada elemen MapFragment. Anda bisa melihat layout yang telah selesai di file sumber tutorial ini.

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

Langkah 4: Kunci API Google Maps

Karena kita menggunakan MapFragment, kita perlu menyiapkan dan menginisialisasi instance GoogleMap. Pertama, Anda perlu mendapatkan kunci API. Begitu Anda memiliki kunci API, tambahkan ke manifest proyek.

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

Mari kita mulai dengan instance GoogleMap. Terapkan GoogleMap.OnMapReadyCallback, GoogleMap.OnMapClickListener, dan GoogleMap.OnMarkerClickListener di kelas Activity dan inisialisasi peta.

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

Langkah 5: `GoogleApiClient`

Untuk menggunakan antarmuka GeofencingApi, kita memerlukan titik masuk GoogleApiClient. Mari menerapkan GoogleApiClient.ConnectionCallbacks dan GoogleApiClient.OnConnectionFailedListener dalam Activity seperti yang ditunjukkan di bawah ini.

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

Langkah 6: `FusedLocationProviderApi`

Kita juga perlu mengakses lokasi pengguna saat ini. Antarmuka FusedLocationProviderApi memberi kita informasi ini dan memungkinkan tingkat kontrol permintaan lokasi yang hebat. Ini sangat penting, mengingat permintaan lokasi memiliki efek langsung terhadap konsumsi baterai perangkat.

Sekarang, mari kita menerapkan LocationListener. Periksa apakah pengguna memberi aplikasi izin yang sesuai dengan membuat permintaan Location dan menampilkan lokasi mereka saat ini di layar.

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

Penting untuk memperhatikan bahwa LocationRequest yang dibuat di atas tidak dioptimalkan untuk lingkungan produksi. UPDATE_INTERVAL terlalu pendek dan akan mengkonsumsi terlalu banyak daya baterai. Konfigurasi yang lebih realistis untuk produksi bisa menjadi:

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

Langkah 7: Penanda GoogleMap

Activity kita membutuhkan dua penanda yang berbeda. locationMarker menggunakan garis lintang dan bujur yang diberikan oleh FusedLocationProviderApi untuk menginformasikan lokasi perangkat saat ini. geoFenceMarker adalah target pembuatan geofence karena menggunakan sentuhan terakhir yang diberikan pada peta untuk mengambil posisinya.

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

Langkah 8: Membuat Geofence

Akhirnya, sekarang saatnya menciptakan geofence. Kita menggunakan geoFenceMarker sebagai titik pusat 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();
}

Selanjutnya, kita membuat objek 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();
}

Kita menggunakan objek PendingIntent untuk memanggil IntentService yang akan menangani GeofenceEvent. Kita membuat GeofenceTrasitionService.class nanti.

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

Kita juga menggambar geofence di peta sebagai referensi 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 );
}

Metode startGeofence() bertanggung jawab untuk memulai proses geofencing di kelas 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");
        }
    }

Langkah 9: Layanan Transisi Geofence

Sekarang kita dapat akhirnya membuat GeofenceTrasitionService.class yang disebutkan sebelumnya. Kelas ini memperluas IntentService dan bertanggung jawab untuk menangani GeofencingEvent. Pertama, kita mendapatkan event ini dari intent yang diterima.

1	GeofencingEvent geofencingEvent = GeofencingEvent.fromIntent(intent);

Kita kemudian memeriksa apakah jenis transisi geofencing yang terjadi sangat menarik bagi kita. Jika iya, kita mengambil daftar geofensi yang dipicu dan membuat pemberitahuan dengan tindakan yang sesuai.

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

Saya juga telah menerapkan beberapa metode helper untuk membuat penerapan kelas lebih mudah dipahami.

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

Pengujian pada Perangkat Virtual

Jauh lebih mudah untuk menguji geofencing pada perangkat virtual. Ada beberapa cara untuk melakukan ini. Di Android Studio, buka perangkat virtual dan klik tombol more options di kanan bawah.

Click on More Options

Di tab Location di sebelah kiri, masukkan koordinat lokasi.

Saya lebih suka menggunakan perintah telnet untuk mengendalikan perangkat virtual. Untuk menggunakan ini, Anda perlu menyambungkan ke perangkat dari baris perintah menggunakan perintah berikut:

1	telnet localhost [DEVICE_PORT]

Port perangkat ditampilkan di jendela perangkat virtual. Port perangkat biasanya sama dengan 5554.

Ada kemungkinan Anda perlu mengotorisasi koneksi ini menggunakan auth_token Anda, namun baris perintah menunjukkan lokasi Anda berada. Arahkan ke lokasi itu dan salin token dan ketik, auth [YOUR_AUTH_TOKEN].

Anda sekarang dapat mengatur lokasi perangkat dengan menjalankan perintah berikut:

1	geo fix [LATITUDE] [LONGITUDE]

Kesimpulan

Geofencing mungkin merupakan tambahan yang bagus untuk aplikasi Anda karena dapat meningkatkan keterlibatan pengguna dengan lebih baik. Ada banyak kemungkinan untuk dijelajahi dan Anda bahkan bisa menciptakan pengalaman yang canggih dengan menggunakan beacon dalam ruangan, seperti Estimote. Dengan beacon dalam ruangan, Anda tahu persis di mana pengguna telah masuk, misalnya, sebuah pusat perbelanjaan.

Menambahkan Geofencing ke sebuah proyek adalah sederhana, namun kita perlu selalu mengingat konsumsi daya setiap saat. Ini berarti kita perlu berhati-hati memilih ukuran geofence dan tingkat pembaruan karena keduanya langsung mempengaruhi konsumsi daya aplikasi Anda.

Oleh karena itu pengujian sangat penting untuk mendapatkan ide realistis tentang konsumsi daya aplikasi Anda. Juga pertimbangkan untuk memberi pengguna pilihan untuk menonaktifkan geofencing sama sekali jika mereka tidak menginginkan atau membutuhkan fitur ini.