Share
Resursele bazate pe locație permit aplicației dvs. să interacționeze cu lumea fizică și sunt ideale pentru creșterea implicării utilizatorilor. Deși multe aplicații mobile le utilizează, tema acestui tutorial este o caracteristică care este adesea trecuta cu vederea, geofencing.
Geofence este un perimetru virtual, amplasat pe o zonă geografică reală. Combinând o poziție de utilizator cu un perimetru geofence, este posibil să se știe dacă utilizatorul se află în interiorul sau în exteriorul geofencei sau chiar dacă iese sau intră în zonă.
Imaginați-vă o aplicație universitară care vă poate spune care colegi și profesori se află în prezent în campus. Sau o aplicație pentru un mall care recompensează clienții obișnuiți. Există multe alte posibilități interesante pe care le puteți explora.
În acest tutorial, învățați cum să utilizați geofenele pe Android creând o aplicație care arată utilizatorului o notificare atunci când intră sau iese din geofence. Vă ajută dacă aveți cunoștințe anterioare despre serviciile Google Play, API-ul Google Maps Android sau IntentService. Dacă nu, atunci puteți continua, dar ați putea dori să faceți niște cercetări despre aceste subiecte după ce ați citit acest tutorial.
Pe Android, există mai multe modalități de a lucra cu geofenii. Puteți chiar să creați propria implementare pentru a lucra cu geofenii, dar este mai ușor să utilizați Google GeofencingApi.
Aceste API fac parte din Google Locație API-uri. Include Geofence, GeofencingRequest, GeofenceApi, GeofencingEvent, și GeofenceStatusCodes. În acest tutorial, folosim aceste clase pentru a crea și a lucra cu geofenii.
Geofence este o interfață care reprezintă o arie geografică care trebuie monitorizată. Acesta este creat folosind Geofence.Builder. În timpul creării acestuia, setați regiunea monitorizată, data de expirare a geofenței, răspunsul, un identificator și tipul de tranziții pe care ar trebui să îl caute.
Pentru a menține consumul de energie la un nivel minim, se recomandă utilizarea unei geofențe cu o rază de cel puțin 100 de metri în majoritatea situațiilor. Dacă geofences sunt situate în mediul rural, ar trebui să crească raza la 500 de metri sau mai mult pentru a vă asigura că geofences sunt eficiente.
Geofence geofence = Geofence.Builder () .setRequestId (GEOFENCE_REQ_ID) // Geofence ID .setCircularRegion (LATITUDE, LONGITUDE, RADIUS) // definirea regiunii gardului .setExpirationDuration (DURANTION) // data expirării // Tipurile de tranziție pe care ar trebui să le caute .setTransitionTypes (Geofence.GEOFENCE_TRANSITION_ENTER | Geofence.GEOFENCE_TRANSITION_EXIT) .build ();
Accentsconagua
GEOFENCE_TRANSITION_DWELL indică faptul că utilizatorul a intrat în zonă și a petrecut ceva timp acolo. Este util să evitați alertele multiple atunci când utilizatorul intră și iese din zonă prea repede. Puteți configura timpul de locuit folosind setLoiteringDelay parametru.GEOFENCE_TRANSITION_ENTER indică momentul în care utilizatorul intră în regiunea monitorizată.GEOFENCE_TRANSITION_EXIT indică când utilizatorul iese din regiune.GeofenceRequest GeofencingRequest clasa primește geofenii care ar trebui monitorizați. Puteți crea o instanță utilizând un a Constructor, trecând a Geofence sau a Listă, și tipul de notificare care trebuie declanșat la crearea geofenței.
Cererea GeofencingRequest = nou GeofencingRequest.Builder () // Notificare pentru a declanșa la crearea Geofence .setInitialTrigger (GeofencingRequest.INITIAL_TRIGGER_ENTER) .addGeofence (geofence) // adăugați un Geofence .build ();
GeofencingApi GeofencingApi clasa este punctul de intrare pentru toate interacțiunile cu API geofencing Google. Este parte din Locație API-uri și depinde de a GoogleApiClient a munci. Veți folosi GeofencingApi pentru a adăuga și elimina geofences.
Pentru a adăuga o geofence, apelați addGeofence () metodă. Monitorizează zona dată folosind setările trimise către GeofencingRequest și împușcă a PendingIntent când are loc o tranziție geofence, care intră sau iese din zonă.
PendingResultaddGeofences (client GoogleApiClient, GeofencingRequest geofencingRequest, PendingIntent pendingIntent)
Pentru a elimina geofence, apelați removeGeofences (). Puteți să eliminați geofence-ul folosind identificatorul de solicitare sau intenția sa în așteptare.
PendingResultremoveGeofences (client GoogleApiClient, listă geofenceRequestIds)
PendingResultremoveGeofences (client GoogleApiClient, PendingIntent pendingIntent)
În acest tutorial, creăm o aplicație simplă care monitorizează locația utilizatorului și publică o notificare atunci când utilizatorul intră sau iese dintr-o zonă geografică. Aplicația conține doar una Activitate si un IntentService. De asemenea, ne uităm rapid la Harta Google, GoogleApiClient, și FusedLocationProviderApi, și vom explora unele restricții ale API-ului geofence.
GeofencingApi face parte din serviciile Google Play. Pentru a le accesa, trebuie să configurați corect mediul de dezvoltare și să creați o instanță a GoogleApiClient. Creați un proiect nou cu un spațiu gol Activitate, editați proiectul build.gradle fișierul după cum se arată mai jos și sincronizați-vă proiectul.
Trebuie să setăm permisiunile corecte pentru a crea și utiliza geofenii. Adăugați următoarea permisiune la manifestul proiectului:
Începând cu versiunea Android 6.0, aplicația cere permisiunea la momentul executării, și nu în timpul instalării. Adresăm acest lucru mai târziu în tutorial.
Proiectul constă dintr - un aspect, MainActity aspect. Conține latitudinea și longitudinea actuale ale dispozitivului și a Harta Google fragment care afișează geofenii și poziția utilizatorului.
De cand activity_main.xml este destul de simplă, vreau să mă concentrez doar pe MapFragment element. Puteți să aruncați o privire asupra aspectului finalizat în fișierele sursă ale acestui tutorial.
Deoarece folosim a MapFragment, trebuie să instituim și să inițializăm o Harta Google instanță. În primul rând, trebuie să obțineți o cheie API. Odată ce aveți o cheie API, adăugați-o la manifestul proiectului.
Să începem cu Harta Google instanță. aplica GoogleMap.OnMapReadyCallback, GoogleMap.OnMapClickListener, și GoogleMap.OnMarkerClickListener în Activitate clasați și inițializați harta.
public class MainActivity se extinde AppCompatActivity implementează OnMapReadyCallback, GoogleMap.OnMapClickListener, GoogleMap.OnMarkerClickListener privat static final String TAG = MainActivity.class.getSimpleName (); privat TextView textLat, textLong; harta privată MapFragmentFragment; harta GoogleMap privată; @Override protejate void onCreate (Bundle savedInstanceState) super.onCreate (savedInstanceState); setContentView (R.layout.activity_main); textLat = (TextView) findViewById (R.id.lat); textLong = (TextView) findViewById (R.id.lon); // inițializați GoogleMaps initGMaps (); // Inițializați GoogleMaps void privat initGMaps () mapFragment = (MapFragment) getFragmentManager () findFragmentById (R.id.map); mapFragment.getMapAsync (aceasta); // Callback sunat când Map este gata @Override public void onMapReady (GoogleMap googleMap) Log.d (TAG, "onMapReady ()"); map = googleMap; map.setOnMapClickListener (aceasta); map.setOnMarkerClickListener (aceasta); // Apel invers apelat când hartă este atinsă @Override public void onMapClick (LatLng latLng) Log.d (TAG, "onMapClick (" + latLng + ")"); // Apel invers apelat la atingerea marcatorului @Override public boolean onMarkerClick (marcator) Log.d (TAG, "onMarkerClickListener:" + marker.getPosition ()); return false; GoogleApiClientPentru a utiliza GeofencingApi interfață, avem nevoie de o GoogleApiClient punct de intrare. Să implementăm a GoogleApiClient.ConnectionCallbacks și a GoogleApiClient.OnConnectionFailedListener în Activitate așa cum se arată mai jos.
public class MainActivity se extinde AppCompatActivity implementează GoogleApiClient.ConnectionCallbacks, GoogleApiClient.OnConnectionFailedListener, OnMapReadyCallback, GoogleMap.OnMapClickListener, GoogleMap.OnMarkerClickListener // ... privat GoogleApiClient googleApiClient; @Override protejat void onCreate (Bundle savedInstanceState) // ... // crea GoogleApiClient createGoogleApi (); // Creați instanța GoogleApiClient private void createGoogleApi () Log.d (TAG, "createGoogleApi ()"); dacă (googleApiClient == null) googleApiClient = noul GoogleApiClient.Builder (acest) .addConnectionCallbacks (acest) .addOnConnectionFailedListener (acest) .addApi (LocationServices.API) .build (); @Override protejate void onStart () super.onStart (); // Apelați conexiunea GoogleApiClient la pornirea activității googleApiClient.connect (); @Override protejate void onStop () super.onStop (); // Deconectați GoogleApiClient la oprirea Activității googleApiClient.disconnect (); // GoogleApiClient.ConnectionCallbacks conectat @Override public void onConnected (@Nullable Bundle Bundle) Log.i (TAG, "onConnected ()"); // GoogleApiClient.ConnectionCallbacks suspendat @Override public void onConnectionSuspended (int i) Log.w (TAG, "onConnectionSuspended ()"); // GoogleApiClient.OnConnectionFailedListener eșuează @Override public void onConnectionFailed (@NonNull ConnectionResult connectionResult) Log.w (TAG, "onConnectionFailed ()");
FusedLocationProviderApiDe asemenea, trebuie să accesăm locația curentă a utilizatorului. FusedLocationProviderApi interfața ne oferă aceste informații și permite un nivel ridicat de control al solicitării de locație. Acest lucru este foarte important, având în vedere că solicitările de locație au un efect direct asupra consumului de baterii al dispozitivului.
Acum, să punem în aplicare a LocationListener. Verificați dacă utilizatorul a acordat aplicației permisiunile necesare prin crearea unei licențe Locație solicitați și afișați locația curentă pe ecran.
clasa publica MainActivity extinde aplicațiile AppCompatActivity // ... LocationListener private Location lastLocation; // ... // GoogleApiClient.ConnectionCallbacks conectat @Override public void onConnected (@Nullable Bundle Bundle) Log.i (TAG, "onConnected ()"); getLastKnownLocation (); // Obțineți ultima locație cunoscută void privat getLastKnownLocation () Log.d (TAG, "getLastKnownLocation ()"); dacă (checkPermission ()) lastLocation = LocațiaServicii.FuzatăLocațiaApi.getLastLocation (googleApiClient); dacă lastLocation! = null) Log.i (TAG, "Locație LasKnown." + "Long:" + lastLocation.getLongitude () + "| Lat:" + lastLocation.getLatitude (); writeLastLocation (); startLocationUpdates (); altceva Log.w (TAG, "Nici o locație nu a fost recuperată încă"); startLocationUpdates (); altceva askPermission (); private LocationRequest locationRequest; // Definit în mil. Secunde. // Acest număr este extrem de scăzut și ar trebui să fie utilizat numai pentru depanarea finală privată int UPDATE_INTERVAL = 1000; finală privată int FASTEST_INTERVAL = 900; // Start locație Actualizări private void startLocationUpdates () Log.i (TAG, "startLocationUpdates ()"); locationRequest = LocațieRequest.create () .setPrioritate (LocațieRequest.PRIORITY_HIGH_ACCURACY) .setInterval (UPDATE_INTERVAL) .setFastestInterval (FASTEST_INTERVAL); dacă (checkPermission ()) LocationServices.FusedLocationApi.requestLocationApdates (googleApiClient, locationRequest, this); @Overide public void onLocationChanged (Locația locației) Log.d (TAG, "onLocationChanged [" + location + "]); lastLocation = locație; writeActualLocation (locație); // Scrieți coordonatele locației în privat private void writeActualLocation (Locația locației) textLat.setText ("Lat:" + location.getLatitude ()); textLong.setText ("Long:" + loc.getLongitude ()); void privat writeLastLocation () writeActualLocation (lastLocation); // Verificați pentru permisiunea de a accesa locație boolean private checkPermission () Log.d (TAG, "checkPermission ()"); // Cereți permisiunea dacă nu a fost încă acordată returnare (ContextCompat.checkSelfPermission (this, Manifest.permission.ACCESS_FINE_LOCATION == PackageManager.PERMISSION_GRANTED); // Solicită permisiune private void askPermission () Log.d (TAG, "askPermission ()"); ActivityCompat.requestPermissions (acest nou șir [] Manifest.permission.ACCESS_FINE_LOCATION, REQ_PERMISSION); // Verificați răspunsul utilizatorului pentru permisiunea solicitată @Override public void peRequestPermissionsResult (int requestCode, @NonNull String [] permisiuni, @NonNull int [] grantResults) Log.d (TAG, "onRequestPermissionsResult ()"); super.onRequestPermissionsResult (requestCode, permisiuni, grantResults); comanda (requestCode) caz REQ_PERMISSION: if (grantResults.length> 0 && grantResults [0] == PackageManager.PERMISSION_GRANTED) // Permisiunea acordată getLastKnownLocation (); altceva // Permisiune refuzată permisiuneDenied (); pauză; // Aplicația nu poate funcționa fără permisiuni permisiuni private voidDenied () Log.w (TAG, "permissionsDenied ()"); Este important să se țină cont de faptul că LocationRequest creat mai sus, nu este optimizat pentru un mediu de producție. INTERVAL DE ACTUALIZARE este prea scurt și ar consuma prea multă energie de la baterie. O configurație mai realistă pentru producție ar putea fi:
finale private int UPDATE_INTERVAL = 3 * 60 * 1000; // 3 minute finale private int int FASTEST_INTERVAL = 30 * 1000; // 30 de secunde private void startLocationUpdates () Log.i (TAG, "startLocationUpdates ()"); locationRequest = LocațieRequest.create () .setPrioritate (LocațieRequest.PRIORITY_HIGH_ACCURACY) .setInterval (UPDATE_INTERVAL) .setFastestInterval (FASTEST_INTERVAL); dacă (checkPermission ()) LocationServices.FusedLocationApi.requestLocationApdates (googleApiClient, locationRequest, this);
Al nostru Activitate are nevoie de două markere diferite. A locationMarker utilizează latitudinea și longitudinea date de FusedLocationProviderApi pentru a informa locația curentă a dispozitivului. A geoFenceMarker este ținta pentru crearea geofenței, deoarece utilizează ultima atingere dată pe hartă pentru a-și recupera poziția.
@Override publice void onMapClick (LatLng LatLng) Log.d (TAG, "onMapClick (" + latLng + ")"); markerForGeofence (LatLng); private void writeActualLocation (Locația locației) // ... markerLocation (nou LatLng (location.getLatitude (), location.getLongitude ())); privateMarker; // Creați un marker de locație marker privat voidLocation (LatLng latLng) Log.i (TAG, "markerLocation (" + latLng + ")"); Numele șirului = latLng.latitude + "," + latLng.longitude; MarkerOptions markerOptions = opțiuni noi MarkerOptions () poziție (latLng) .title (titlu); if (map! = null) // Eliminați markerul anterior dacă (locationMarker! = null) locationMarker.remove (); locMarker = map.addMarker (markerOptions); float zoom = 14f; CameraUpdate cameraUpdate = CameraUpdateFactory.newLatLngZoom (latLng, zoom); map.animateCamera (cameraUpdate); marcator privat geoFenceMarker; // Creați un marker pentru markerul void privat pentru crearea geofențeiForGeofence (LatLng latLng) Log.i (TAG, "markerForGeofence (" + latLng + ")"); Numele șirului = latLng.latitude + "," + latLng.longitude; // Definiți opțiunile markerului MarkerOptions markerOptions = new MarkerOptions (). Poziția (latLng) .icon (BitmapDescriptorFactory.defaultMarker (BitmapDescriptorFactory.HUE_ORANGE)). Titlu (titlu); dacă (map! = null) // Elimină ultimul geoFenceMarker dacă (geoFenceMarker! = null) geoFenceMarker.remove (); geoFenceMarker = harta.addMarker (markerOptions); În cele din urmă, este timpul să creați o geofenă. Noi folosim geoFenceMarker ca punct central pentru geofence.
statică privată finală lungă GEO_DURATION = 60 * 60 * 1000; statică finală privată statică GEOFENCE_REQ_ID = "My Geofence"; static float final static GEOFENCE_RADIUS = 500.0f; // în metri // Creați un geofence privat Geofence createGeofence (LatLng latLng, raft float) Log.d (TAG, "createGeofence"); returnează noul Geofence.Builder () .setRequestId (GEOFENCE_REQ_ID) .setCircularRegion (latLng.latitude, latLong.longitude, radius) .setExpirationDuration (GEO_DURATION) .setTransitionTypes (Geofence.GEOFENCE_TRANSITION_ENTER | Geofence.GEOFENCE_TRANSITION_EXIT) .build ();
Apoi, vom crea GeofencingRequest obiect.
// Creați o solicitare de Geofence Private GeofencingRequest createGeofenceRequest (Geofence geofence) Log.d (TAG, "createGeofenceRequest"); returnează noul GeofencingRequest.Builder () .setInitialTrigger (GeofencingRequest.INITIAL_TRIGGER_ENTER) .addGeofence (geofence) .build ();
Noi folosim a PendingIntent obiecte pentru a apela a IntentService care se va ocupa de GeofenceEvent. Noi creăm GeofenceTrasitionService.class mai tarziu.
private PendingIntent geoFencePendingIntent; final final privat GEOFENCE_REQ_CODE = 0; private PendingIntent createGeofencePendingIntent () Log.d (TAG, "createGeofencePendingIntent"); dacă (geoFencePendingIntent! = null) returnează geoFencePendingIntent; Intenția intenției = intenția nouă (aceasta, GeofenceTrasitionService.class); returnați PendingIntent.getService (acest lucru, GEOFENCE_REQ_CODE, intent, PendingIntent.FLAG_UPDATE_CURRENT); // Adăugați GeofenceRequest creat în lista de monitorizare a dispozitivului private void addGeofence (solicitarea GeofencingRequest) Log.d (TAG, "addGeofence"); dacă (checkPermission ()) LocationServices.GeofencingApi.addGeofences (googleApiClient, request, createGeofencePendingIntent ()) .setResultCallback (aceasta);
De asemenea, atragem Geofence pe hartă ca o referință vizuală.
@Override public void onResult (@NonNull Stare statut) Log.i (TAG, "onResult:" + status); dacă (status.isSuccess ()) drawGeofence (); altceva // informați despre eșec // Eliminați cercul Geofence în GoogleMap privat Circle geoFenceLimits; void privat drawGeofence () Log.d (TAG, "drawGeofence ()"); dacă (geoFenceLimits! = null) geoFenceLimits.remove (); CircleOptions cercOptions = 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);
startGeofence () metoda este responsabilă pentru pornirea procesului de geofenalizare în Activitate principala clasă.
@Override public boolean onOptionsItemSelected (elementul MenuItem) comutare (item.getItemId ()) caz R.id.geofence: startGeofence (); return true; return super.onOptionsItemSelected (element); // Începe procesul de creare a Geofence private void startGeofence () Log.i (TAG, "startGeofence ()"); dacă (geoFenceMarker! = null) Geofence geofence = createGeofence (geoFenceMarker.getPosition (), GEOFENCE_RADIUS); GeofencingRequest geofenceRequest = createGeofenceRequest (geofence); addGeofence (geofenceRequest); altceva Log.e (TAG, "Marcatorul Geofence este nul");
Acum putem crea GeofenceTrasitionService.class mentionat mai devreme. Această clasă se extinde IntentService și este responsabil pentru manipularea GeofencingEvent. În primul rând, primim acest eveniment din intenția primită.
GeofencingEvent geofencingEvent = GeofencingEvent.fromIntent (intent);
Apoi verificăm dacă tipul de tranziție geofencțională care a avut loc este de interes pentru noi. Dacă este cazul, vom prelua o listă a geofenelor declanșate și vom crea o notificare cu acțiunile corespunzătoare.
// Returnați GeofenceTrasition int geoFenceTransition = geofencingEvent.getGeofenceTransition (); // Verificați dacă tipul de tranziție dacă (geoFenceTransition == Geofence.GEOFENCE_TRANSITION_ENTER || geoFenceTransition == Geofence.GEOFENCE_TRANSITION_EXIT) // Obțineți geofența care a fost declanșată ListtriggeringGeofences = geofencingEvent.getTriggeringGeofences (); // Creați un mesaj detaliat cu Geofences primit Geofence StringTransitionDetails = getGeofenceTrasitionDetails (geoFenceTransition, triggeringGeofences); // Trimiteți detaliile de notificare sub forma unui String sendNotification (geofenceTransitionDetails);
Am implementat de asemenea câteva metode de ajutor pentru a face mai ușor de înțeles implementarea clasei.
clasa publică GeofenceTrasitionService extinde IntentService final static final String TAG = GeofenceTrasitionService.class.getSimpleName (); public final static public GEOFENCE_NOTIFICATION_ID = 0; public GeofenceTrasitionService () super (TAG); @Override protejat void onHandleIntent (Intent intent) // Preluarea intenției de geofencing GeofencingEvent geofencingEvent = GeofencingEvent.fromIntent (intent); // Eroare de manipulare dacă (geofencingEvent.hasError ()) String errorMsg = getErrorString (geofencingEvent.getErrorCode ()); Log.e (TAG, errorMsg); întoarcere; / / Retrieve GeofenceTrasition int geoFenceTransition = geofencingEvent.getGeofenceTransition (); // Verificați dacă tipul de tranziție dacă (geoFenceTransition == Geofence.GEOFENCE_TRANSITION_ENTER || geoFenceTransition == Geofence.GEOFENCE_TRANSITION_EXIT) // Obțineți geofența care a fost declanșată ListtriggeringGeofences = geofencingEvent.getTriggeringGeofences (); // Creați un mesaj detaliat cu Geofences primit Geofence StringTransitionDetails = getGeofenceTrasitionDetails (geoFenceTransition, triggeringGeofences); // Trimiteți detaliile de notificare sub forma unui String sendNotification (geofenceTransitionDetails); // Creați un mesaj detaliat cu Geofences primit String privat getGeofenceTrasitionDetails (int geoFenceTransition, List triggeringGeofences) // obțineți ID-ul fiecărui arrayList declanșat de geofence triggeringGeofencesList = noul ArrayList <> (); pentru (Geofence geofence: triggeringGeofences) triggeringGeofencesList.add (geofence.getRequestId ()); String status = null; dacă (geoFenceTransition == Geofence.GEOFENCE_TRANSITION_ENTER) status = "Intrarea"; altfel dacă (geoFenceTransition == Geofence.GEOFENCE_TRANSITION_EXIT) status = "Exit"; starea de returnare + TextUtils.join ("," triggeringGeofencesList); // Trimite o notificare privat void sendNotification (String msg) Log.i (TAG, "sendNotification:" + msg); // Intenția de a începe activitatea principală Notificare interactivăIntent = MainActivity.makeNotificationIntent (getApplicationContext (), msg); TaskStackBuilder stackBuilder = TaskStackBuilder.create (acest lucru); stackBuilder.addParentStack (MainActivity.class); stackBuilder.addNextIntent (notificationIntent); Notificare PendingIntentPendingIntent = stackBuilder.getPendingIntent (0, PendingIntent.FLAG_UPDATE_CURRENT); // Crearea și trimiterea notificării NotificationManager notifyatioMng = (NotificationManager) getSystemService (Context.NOTIFICATION_SERVICE); notificatioMng.notify (GEOFENCE_NOTIFICATION_ID, createNotification (msg, notificationPendingIntent)); // Creați o Notificare privată de notificare createNotification (Mesaj șir, PendingIntent notificationPendingIntent) NotificareCompat.Builder notificationBuilder = Notificare nouăCompat.Builder (aceasta); notificationBuilder .setSmallIcon (R.drawable.ic_action_location) .setColor (Color.RED) .setContentTitle (msg) .setContentText ("Notă geofenală!") .setContentIntent (notificationPendingIntent) .setDefaults (Notificare.DEFAULT_LIGHTS | Notificare.DEFAULT_VIBRATE | Notificare.DEFAULT_SOUND ). setAutoCancel (adevărat); returnați notificareaBuilder.build (); // Eroare de manipulare private static String getErrorString (int errorCode) comutare (errorCode) caz GeofenceStatusCodes.GEOFENCE_NOT_AVAILABLE: return "GeoFence nu este disponibil"; cazul GeofenceStatusCodes.GEOFENCE_TOO_MANY_GEOFENCES: returnați "Prea multe GeoFences"; caz GeofenceStatusCodes.GEOFENCE_TOO_MANY_PENDING_INTENTS: returnați "Prea multe intenții în așteptare"; default: return "Eroare necunoscută.";
Este mult mai simplu să testați geofenizarea pe un dispozitiv virtual. Există mai multe moduri de a face acest lucru. În Android Studio, deschideți un dispozitiv virtual și faceți clic pe butonul mai multe opțiuni din dreapta jos.
În Locație din stânga, introduceți coordonatele locației.
Prefer să o folosesc telnet comenzi pentru a controla dispozitivul virtual. Pentru a utiliza acest lucru, trebuie să vă conectați la dispozitiv din linia de comandă utilizând următoarea comandă:
telnet localhost [DEVICE_PORT]
Portul dispozitivului este afișat în fereastra dispozitivului virtual. Portul dispozitivului este de obicei egal cu 5554.
Este posibil să aveți nevoie să autorizați această conexiune cu ajutorul dvs. auth_token, dar linia de comandă vă arată unde este localizată. Navigați la acea locație și copiați simbolul și tastați, auth [YOUR_AUTH_TOKEN].
Acum puteți seta locația dispozitivului executând următoarea comandă:
geo fix [LATITUDE] [LONGITUDE]
Geofencingul poate fi o mare plus față de aplicația dvs., deoarece poate crește considerabil gradul de implicare a utilizatorilor. Există o mulțime de posibilități de explorare și puteți crea chiar și o experiență sofisticată folosind balize interioare, cum ar fi Estimote. Cu balizele de interior, știi exact unde a trecut utilizatorul, de exemplu, un mall.
Adăugarea Geofencingului la un proiect este simplă, dar trebuie să ținem cont în permanență de consumul de energie. Aceasta înseamnă că trebuie să alegeți cu atenție dimensiunea geofenței și rata de actualizare, deoarece ambele influențează direct consumul de energie al aplicației dvs..
Testarea este, prin urmare, foarte importantă pentru a obține o idee realistă privind consumul de energie al aplicației dvs. De asemenea, luați în considerare posibilitatea utilizatorilor de a dezactiva complet geofenizarea dacă nu doresc sau nu au nevoie de această funcție.
