Share
Le risorse di localizzazione consentono alla tua applicazione di interagire con il mondo fisico e sono ideali per aumentare il coinvolgimento degli utenti. Sebbene molte app mobili li usino, l'argomento di questo tutorial è una caratteristica che viene spesso trascurata, il geofencing.
Un geofence è un perimetro virtuale impostato su un'area geografica reale. Combinando una posizione utente con un perimetro geofence, è possibile sapere se l'utente si trova all'interno o all'esterno del Geofence o anche se sta uscendo o entrando nell'area.
Immagina un'app universitaria in grado di dirti quali colleghi e professori sono attualmente al campus. O un'app per un centro commerciale che premia i clienti abituali. Ci sono molte altre possibilità interessanti che puoi esplorare.
In questo tutorial, si impara come utilizzare geofences su Android creando un'applicazione che mostra all'utente una notifica quando entra o esce da un geofence. È utile se hai una conoscenza precedente dei servizi di Google Play, dell'API Android di Google Maps o IntentService. Se non lo fai, puoi continuare a seguirlo, ma potresti voler fare delle ricerche su questi argomenti dopo aver letto questo tutorial.
Su Android, ci sono diversi modi per lavorare con i geofences. Potresti persino creare la tua implementazione per lavorare con i geofence, ma è più facile usare Google GeofencingApi.
Queste API fanno parte di Google Posizione API. Include Geofence, GeofencingRequest, GeofenceApi, GeofencingEvent, e GeofenceStatusCodes. In questo tutorial, usiamo queste classi per creare e lavorare con geofences.
Geofence è un'interfaccia che rappresenta un'area geografica che deve essere monitorata. Viene creato usando il Geofence.Builder. Durante la sua creazione, si imposta la regione monitorata, la data di scadenza del geofence, la reattività, un identificatore e il tipo di transizioni che dovrebbe essere cercato.
Per mantenere il consumo energetico al minimo, si consiglia di utilizzare un geofence con un raggio di almeno 100 metri per la maggior parte delle situazioni. Se i geofisici si trovano in campagna, è necessario aumentare il raggio a 500 metri o più per assicurarsi che i geofisici siano efficaci.
Geofence Geofence = new Geofence.Builder () .setRequestId (GEOFENCE_REQ_ID) // Geofence ID .setCircularRegion (LATITUDE, LONGITUDE, RADIUS) // definizione della regione di fence .setExpirationDuration (DURANTION) // data di scadenza // Tipi di transizione che dovrebbe cercare .setTransitionTypes (Geofence.GEOFENCE_TRANSITION_ENTER | Geofence.GEOFENCE_TRANSITION_EXIT) .build ();
Accentsconagua
GEOFENCE_TRANSITION_DWELL indica che l'utente è entrato nell'area e ha trascorso un po 'di tempo lì. È utile evitare più avvisi quando l'utente sta entrando e uscendo dall'area troppo velocemente. È possibile configurare il tempo di dimora usando il setLoiteringDelay parametro.GEOFENCE_TRANSITION_ENTER indica quando l'utente entra nella regione monitorata.GEOFENCE_TRANSITION_EXIT indica quando l'utente esce dalla regione.GeofenceRequestIl GeofencingRequest la classe riceve i geofences che devono essere monitorati. È possibile creare un'istanza utilizzando a Costruttore, passando a Geofence o a Elenco, e il tipo di notifica da attivare quando vengono creati i geofence.
GeofencingRequest request = new GeofencingRequest.Builder () // Notifica da attivare quando viene creato Geofence. SetInitialTrigger (GeofencingRequest.INITIAL_TRIGGER_ENTER) .addGeofence (geofence) // aggiungi un Geofence .build ();
GeofencingApiIl GeofencingApi class è il punto di ingresso per tutte le interazioni con l'API di geofencing di Google. Fa parte del Posizione API e dipende da a GoogleApiClient lavorare. Utilizzerai il GeofencingApi aggiungere e rimuovere geofences.
Per aggiungere un Geofence, chiami il addGeofence () metodo. Controlla l'area data usando le impostazioni passate a GeofencingRequest e spara a PendingIntent quando avviene una transizione di geofence, entrando o uscendo dall'area.
PendingResultaddGeofences (client GoogleApiClient, GeofencingRequest geofencingRequest, PendingIntent pendingIntent)
Per rimuovere il Geofence, chiami removeGeofences (). Puoi rimuovere il Geofence utilizzando il suo identificatore di richiesta o il suo intento in sospeso.
PendingResultremoveGeofences (client GoogleApiClient, elenco geofenceRequestIds)
PendingResultremoveGeofences (client GoogleApiClient, PendingIntent pendingIntent)
In questo tutorial, creiamo una semplice applicazione che monitora la posizione dell'utente e pubblica una notifica quando l'utente entra o esce da un'area georeferenziata. L'app è composta da una sola Attività e un IntentService. Diamo anche uno sguardo veloce a Google Map, GoogleApiClient, e FusedLocationProviderApi, ed esploriamo alcuni avvertimenti dell'API di geofence.
GeofencingApi fa parte di Google Play Services. Per accedervi, è necessario configurare correttamente il proprio ambiente di sviluppo e creare un'istanza di GoogleApiClient. Crea un nuovo progetto con uno spazio vuoto Attività, modifica del progetto build.gradle file come mostrato di seguito e sincronizzare il progetto.
Abbiamo bisogno di impostare le autorizzazioni corrette per creare e utilizzare i geofences. Aggiungi la seguente autorizzazione al manifest del progetto:
A partire da Android 6.0, l'app richiede il permesso in fase di esecuzione e non durante l'installazione. Ci occuperemo di questo più avanti nel tutorial.
Il progetto consiste in un layout, il MainActity disposizione. Contiene latitudine e longitudine attuali del dispositivo e a Google Map frammento che mostra i geofence e la posizione dell'utente.
Da activity_main.xml è piuttosto semplice, voglio concentrarmi solo sul MapFragment elemento. Puoi dare un'occhiata al layout completato nei file sorgente di questo tutorial.
Dal momento che stiamo usando un MapFragment, abbiamo bisogno di impostare e inizializzare a Google Map esempio. Innanzitutto, è necessario ottenere una chiave API. Una volta che hai una chiave API, aggiungila al manifest del progetto.
Iniziamo con il Google Map esempio. Strumento GoogleMap.OnMapReadyCallback, GoogleMap.OnMapClickListener, e GoogleMap.OnMarkerClickListener nel Attività classificare e inizializzare la mappa.
public class MainActivity estende AppCompatActivity implementa OnMapReadyCallback, GoogleMap.OnMapClickListener, GoogleMap.OnMarkerClickListener String statico finale privato TAG = MainActivity.class.getSimpleName (); TextView privato textLat, textLong; mapFragment mapFragment privato; mappa GoogleMap privata; @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); // inizializza GoogleMaps initGMaps (); // Inizializza il vuoto privato di GoogleMaps initGMaps () mapFragment = (MapFragment) getFragmentManager (). FindFragmentById (R.id.map); mapFragment.getMapAsync (questo); // Callback chiamato quando Map è pronto @Override public void onMapReady (GoogleMap googleMap) Log.d (TAG, "onMapReady ()"); map = googleMap; map.setOnMapClickListener (questo); map.setOnMarkerClickListener (questo); // Chiamata richiamata quando viene toccata la mappa @Override public void onMapClick (LatLng latLng) Log.d (TAG, "onMapClick (" + latLng + ")"); // Chiamata richiamata quando viene toccato Marker @Override public boolean onMarkerClick (Marker marker) Log.d (TAG, "onMarkerClickListener:" + marker.getPosition ()); restituisce falso; GoogleApiClientPer usare il GeofencingApi interfaccia, abbiamo bisogno di a GoogleApiClient punto d'entrata. Implementiamo a GoogleApiClient.ConnectionCallbacks e a GoogleApiClient.OnConnectionFailedListener nel Attività come mostrato di seguito.
public class MainActivity estende AppCompatActivity implementa GoogleApiClient.ConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener, OnMapReadyCallback, GoogleMap.OnMapClickListener, GoogleMap.OnMarkerClickListener // ... private GoogleApiClient googleApiClient; @Override protected void onCreate (Bundle savedInstanceState) // ... // crea GoogleApiClient createGoogleApi (); // Crea istanza privata di GoogleApiClient 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 (); // Chiama la connessione GoogleApiClient quando avvii l'attività googleApiClient.connect (); @Override protected void onStop () super.onStop (); // Disconnettere GoogleApiClient quando si interrompe l'attività googleApiClient.disconnect (); // GoogleApiClient.ConnectionCallbacks connected @Override public void onConnected (bundle @Nullable Bundle) Log.i (TAG, "onConnected ()"); // GoogleApiClient.ConnectionCallbacks sospeso @Override public void onConnectionSuspended (int i) Log.w (TAG, "onConnectionSuspended ()"); // GoogleApiClient.OnConnectionFailedListener fail @Override public void onConnectionFailed (@NonNull ConnectionResult connectionResult) Log.w (TAG, "onConnectionFailed ()");
FusedLocationProviderApiDobbiamo anche accedere alla posizione corrente dell'utente. Il FusedLocationProviderApi interfaccia ci dà questa informazione e consente un grande livello di controllo della richiesta di posizione. Questo è molto importante, considerando che le richieste di localizzazione hanno un effetto diretto sul consumo della batteria del dispositivo.
Ora, implementiamo un LocationListener. Controllare se l'utente ha fornito all'applicazione le autorizzazioni appropriate creando il file Posizione richiedere e visualizzare la loro posizione attuale sullo schermo.
public class MainActivity estende AppCompatActivity implements // ... LocationListener location LastLocation privata; // ... // GoogleApiClient.ConnectionCallbacks connected @Override public void onConnected (bundle @Nullable Bundle) Log.i (TAG, "onConnected ()"); getLastKnownLocation (); // Ottieni l'ultima ubicazione nota privata void getLastKnownLocation () Log.d (TAG, "getLastKnownLocation ()"); if (checkPermission ()) lastLocation = LocationServices.FusedLocationApi.getLastLocation (googleApiClient); if (lastLocation! = null) Log.i (TAG, "Posizione LasKnown." + "Long:" + lastLocation.getLongitude () + "| Lat:" + lastLocation.getLatitude ()); writeLastLocation (); startLocationUpdates (); else Log.w (TAG, "Nessuna posizione recuperata ancora"); startLocationUpdates (); else askPermission (); private LocationRequest locationRequest; // Definito in mili secondi. // Questo numero è estremamente basso e dovrebbe essere usato solo per il 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 = posizione; writeActualLocation (posizione); // Scrivi coordinate di posizione su UI private void writeActualLocation (Posizione posizione) textLat.setText ("Lat:" + location.getLatitude ()); textLong.setText ("Long:" + location.getLongitude ()); private void writeLastLocation () writeActualLocation (lastLocation); // Verifica l'autorizzazione per accedere a Location private boolean checkPermission () Log.d (TAG, "checkPermission ()"); // Richiedere l'autorizzazione se non è stata ancora concessa la restituzione (ContextCompat.checkSelfPermission (this, Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED); // Chiede il permesso private void askPermission () Log.d (TAG, "askPermission ()"); ActivityCompat.requestPermissions (this, new String [] Manifest.permission.ACCESS_FINE_LOCATION, REQ_PERMISSION); // Verifica la risposta dell'utente dell'autorizzazione richiesta @Override public void onRequestPermissionsResult (int requestCode, @NonNull String [] autorizzazioni, @NonNull int [] grantResults) Log.d (TAG, "onRequestPermissionsResult ()"); super.onRequestPermissionsResult (requestCode, permessi, grantResults); switch (requestCode) case REQ_PERMISSION: if (grantResults.length> 0 && grantResults [0] == PackageManager.PERMISSION_GRANTED) // Autorizzazione ottenuta getLastKnownLocation (); else // Autorizzazione negata permissionsDenied (); rompere; // L'app non può funzionare senza le autorizzazioni private void permissionsDenied () Log.w (TAG, "permissionsDenied ()"); È importante affrontare il problema LocationRequest creato sopra non è ottimizzato per un ambiente di produzione. Il INTERVALLO DI AGGIORNAMENTO è troppo corto e consumerebbe troppa carica della batteria. Una configurazione più realistica per la produzione potrebbe essere:
private final int UPDATE_INTERVAL = 3 * 60 * 1000; // 3 minuti private final int FASTEST_INTERVAL = 30 * 1000; // 30 secondi 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);
Nostro Attività ha bisogno di due diversi marcatori. UN locationMarker usa la latitudine e la longitudine date dal FusedLocationProviderApi per informare la posizione corrente del dispositivo. UN geoFenceMarker è l'obiettivo per la creazione di geofence in quanto utilizza l'ultimo tocco fornito sulla mappa per recuperare la sua posizione.
@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; // Crea un indicatore di posizione 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) // Rimuovi il marker anteriore if (locationMarker! = null) locationMarker.remove (); locationMarker = map.addMarker (markerOptions); float zoom = 14f; CameraUpdate cameraUpdate = CameraUpdateFactory.newLatLngZoom (latLng, zoom); map.animateCamera (cameraUpdate); Marker privato geoFenceMarker; // Crea un marker per la creazione di geofence private void markerForGeofence (LatLng latLng) Log.i (TAG, "markerForGeofence (" + latLng + ")"); String title = latLng.latitude + "," + latLng.longitude; // Definisci le opzioni dei marker MarkerOptions markerOptions = new MarkerOptions () .position (latLng) .icon (BitmapDescriptorFactory.defaultMarker (BitmapDescriptorFactory.HUE_ORANGE)) .title (title); if (map! = null) // Rimuovi last geoFenceMarker if (geoFenceMarker! = null) geoFenceMarker.remove (); geoFenceMarker = map.addMarker (markerOptions); Finalmente, è il momento di creare un geofence. Noi usiamo il geoFenceMarker come il punto centrale per il Geofence.
private static final long GEO_DURATION = 60 * 60 * 1000; stringa statica finale privata GEOFENCE_REQ_ID = "My Geofence"; galleggiante statico finale privato GEOFENCE_RADIUS = 500.0f; // in metri // Creare un Geofence privato 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 ();
Successivamente, creiamo il GeofencingRequest oggetto.
// Crea una richiesta di Geofence Geofencing privatoRichiedi createGeofenceRequest (Geofence geofence) Log.d (TAG, "createGeofenceRequest"); return new GeofencingRequest.Builder () .setInitialTrigger (GeofencingRequest.INITIAL_TRIGGER_ENTER) .addGeofence (geofence) .build ();
Noi usiamo a PendingIntent oggetto da chiamare a IntentService che gestirà il GeofenceEvent. Creiamo il GeofenceTrasitionService.class dopo.
private PendingIntent geoFencePendingIntent; private final int GEOFENCE_REQ_CODE = 0; private PendingIntent createGeofencePendingIntent () Log.d (TAG, "createGeofencePendingIntent"); if (geoFencePendingIntent! = null) restituisce geoFencePendingIntent; Intento intenzionale = nuovo intento (questo, GeofenceTrasitionService.class); restituire PendingIntent.getService (questo, GEOFENCE_REQ_CODE, intent, PendingIntent.FLAG_UPDATE_CURRENT); // Aggiungi il GeofenceRequest creato all'elenco di monitoraggio del dispositivo privato addGeofence (richiesta GeofencingRequest) Log.d (TAG, "addGeofence"); if (checkPermission ()) LocationServices.GeofencingApi.addGeofences (googleApiClient, request, createGeofencePendingIntent ()) .setResultCallback (this);
Disegniamo anche il Geofence sulla mappa come riferimento visivo.
@Override public void onResult (@NonNull Status status) Log.i (TAG, "onResult:" + status); if (status.isSuccess ()) drawGeofence (); else // informa about fail // Disegna il cerchio di Geofence su 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);
Il startGeofence () metodo è responsabile per l'avvio del processo di geofencing in Attività principale classe.
@Override public boolean onOptionsItemSelected (MenuItem item) switch (item.getItemId ()) case R.id.geofence: startGeofence (); ritorna vero; return super.onOptionsItemSelected (item); // Avvia il processo di creazione di Geofence 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");
Ora possiamo finalmente creare il GeofenceTrasitionService.class menzionato prima. Questa classe si estende IntentService ed è responsabile della gestione del GeofencingEvent. Innanzitutto, otteniamo questo evento dall'intenzione ricevuta.
GeofencingEvent geofencingEvent = GeofencingEvent.fromIntent (intento);
Controlliamo quindi se il tipo di transizione di geofencing che ha avuto luogo ci interessa. Se lo è, recuperiamo un elenco dei geofencing attivati e creiamo una notifica con le azioni appropriate.
// Recupera GeofenceTrasition int geoFenceTransition = geofencingEvent.getGeofenceTransition (); // Verifica se il tipo di transizione è (geoFenceTransition == Geofence.GEOFENCE_TRANSITION_ENTER || geoFenceTransition == Geofence.GEOFENCE_TRANSITION_EXIT) // Ottieni il geofence che è stato attivato ElencotriggeringGeofences = geofencingEvent.getTriggeringGeofences (); // Crea un messaggio di dettaglio con Geofences ricevuto String geofenceTransitionDetails = getGeofenceTrasitionDetails (geoFenceTransition, triggeringGeofences); // Invia i dettagli della notifica come stringa SendNotification (geofenceTransitionDetails);
Ho anche implementato alcuni metodi di supporto per rendere l'implementazione della classe più facile da capire.
la classe pubblica GeofenceTrasitionService estende IntentService string statico finale privata TAG = GeofenceTrasitionService.class.getSimpleName (); public static final int GEOFENCE_NOTIFICATION_ID = 0; public GeofenceTrasitionService () super (TAG); @Override protected void onHandleIntent (Intent intent) // Recupera l'intento Geofencing GeofencingEvent geofencingEvent = GeofencingEvent.fromIntent (intent); // Gestione degli errori if (geofencingEvent.hasError ()) String errorMsg = getErrorString (geofencingEvent.getErrorCode ()); Log.e (TAG, errorMsg); ritorno; // Recupera GeofenceTrasition int geoFenceTransition = geofencingEvent.getGeofenceTransition (); // Verifica se il tipo di transizione è (geoFenceTransition == Geofence.GEOFENCE_TRANSITION_ENTER || geoFenceTransition == Geofence.GEOFENCE_TRANSITION_EXIT) // Ottieni il geofence che è stato attivato ElencotriggeringGeofences = geofencingEvent.getTriggeringGeofences (); // Crea un messaggio di dettaglio con Geofences ricevuto String geofenceTransitionDetails = getGeofenceTrasitionDetails (geoFenceTransition, triggeringGeofences); // Invia i dettagli della notifica come stringa SendNotification (geofenceTransitionDetails); // Crea un messaggio di dettaglio con Geofences ricevuto String privata getGeofenceTrasitionDetails (int geoFenceTransition, List triggeringGeofences) // ottiene l'ID di ogni ArrayList attivato da geofence triggeringGeofencesList = new ArrayList <> (); for (Geofence geofence: triggeringGeofences) triggeringGeofencesList.add (geofence.getRequestId ()); Stato stringa = null; if (geoFenceTransition == Geofence.GEOFENCE_TRANSITION_ENTER) status = "Entering"; else if (geoFenceTransition == Geofence.GEOFENCE_TRANSITION_EXIT) status = "Uscita"; stato di ritorno + TextUtils.join (",", triggeringGeofencesList); // Invia una notifica private void sendNotification (String msg) Log.i (TAG, "sendNotification:" + msg); // Intento per avviare l'Activity Intent principale 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); // Creazione e invio Notification NotificationManager notificatioMng = (NotificationManager) getSystemService (Context.NOTIFICATION_SERVICE); notificatioMng.notify (GEOFENCE_NOTIFICATION_ID, createNotification (msg, notificationPendingIntent)); // Crea notifica notifica privata 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 (); // Gestisce gli errori private static String getErrorString (int errorCode) switch (errorCode) case GeofenceStatusCodes.GEOFENCE_NOT_AVAILABLE: restituisce "GeoFence non disponibile"; case GeofenceStatusCodes.GEOFENCE_TOO_MANY_GEOFENCES: restituisce "Too many GeoFences"; case GeofenceStatusCodes.GEOFENCE_TOO_MANY_PENDING_INTENTS: restituisce "Troppi intenti in sospeso"; default: return "Unknown error.";
È molto più semplice testare il geofencing su un dispositivo virtuale. Ci sono diversi modi per farlo. In Android Studio, apri un dispositivo virtuale e fai clic sul pulsante Altre opzioni in basso a destra.
Nel Posizione scheda a sinistra, inserire le coordinate per la posizione.
Preferisco usare telnet comandi per controllare il dispositivo virtuale. Per utilizzare questo, è necessario connettersi al dispositivo dalla riga di comando utilizzando il seguente comando:
telnet localhost [DEVICE_PORT]
La porta del dispositivo è mostrata nella finestra del dispositivo virtuale. La porta del dispositivo è solitamente uguale a 5554.
È possibile che tu debba autorizzare questa connessione usando il tuo auth_token, ma la riga di comando mostra dove si trova. Passare a quella posizione e copiare il token e digitare, auth [YOUR_AUTH_TOKEN].
Ora puoi impostare la posizione del dispositivo eseguendo il seguente comando:
geo fix [LATITUDE] [LONGITUDE]
Geofencing può essere una grande aggiunta alla tua app in quanto può aumentare notevolmente il coinvolgimento degli utenti. Ci sono molte possibilità da esplorare e potresti anche creare un'esperienza sofisticata usando i beacon interni, come l'Estimote. Con i beacon interni, sai esattamente dove è passato l'utente, ad esempio un centro commerciale.
Aggiungere Geofencing a un progetto è semplice, ma dobbiamo tenere a mente il consumo di energia in ogni momento. Ciò significa che dobbiamo scegliere con attenzione la dimensione del geofence e il tasso di aggiornamento, poiché entrambi influiscono direttamente sul consumo energetico della vostra applicazione.
I test sono quindi molto importanti per ottenere un'idea realistica del consumo energetico della vostra applicazione. Considera inoltre di dare agli utenti la possibilità di disabilitare del tutto il geofencing se non lo desiderano o se non ne hanno bisogno.
