Innhold

• Hvilke Android-sensorer kan jeg bruke?
• Miljøsensorer: Måling av omgivelseslys
• Viser sensordataene dine
• Kommuniserer med en sensor: SensorManager, SensorEvents og lyttere
• 1. Få en forekomst av SensorManager
• 2. Få en referanse til lightTextView
• 3. Sjekk om sensoren finnes på den gjeldende enheten
• 4. Registrer sensorlytterne dine
• 5. Implementering av tilbakeringinger av SensorEventListener
• onSensorChanged ()
• onAccuracyChanged ()
• 6. Hent sensorverdien
• 7. Avregistrer lytterne dine
• Bruke Android lyssensorer: Fullført kode
• Test den komplette Android-sensorappen
• Måling avstand, med Androids nærhetssensorer
• Opprette brukergrensesnittet
• Henter data fra nærhetssensoren
• Testing: Hvor nær er brukeren enheten deres?
• Bevegelsessensorer: Behandler flerdimensjonale matriser
• Viser sanntids pitch and roll data
• Bruker rotasjonsvektorsensoren i appen din
• 1. Bruk TYPE_ROTATION_VECTOR
• 2. Oversett sensordataene
• 3. Oppdater plassholderstrengene
• Vise flere sensordata: Fullført kode
• Testing av vår endelige Android-sensorapplikasjon
• Innpakking

I dag er de fleste moderne Android-enheter utstyrt med en mengde sensorer.

Du kan bruke denne informasjonen på mange forskjellige måter - enten det overvåker lysnivåene slik at applikasjonen din automatisk kan justere lysstyrken eller fargeskjemaet; slik at brukeren kan samhandle med ditt mobilspill ved å bruke bevegelser som å vippe enheten; eller ved å bruke nærhetssensoren for å deaktivere berøringshendelser automatisk når brukeren holder enheten til øret.

I denne artikkelen lager vi tre applikasjoner som henter lys-, nærhets- og bevegelsesdata fra en rekke maskinvare- og programvaresensorer. Vi overvåker også disse Android-sensorene i sanntid, så applikasjonen din har alltid tilgang til den nyeste informasjonen.

Mot slutten av denne artikkelen vet du hvordan du kan trekke ut et enkelt stykke data fra en Android-sensor, og hvordan du skal håndtere sensorer som gir dataene deres i form av en flerdimensjonal matrise.

Hvilke Android-sensorer kan jeg bruke?

Android-sensorer kan deles inn i følgende kategorier:

• Miljøsensorer. Disse måler miljøforhold, som lufttemperatur, trykk, fuktighet og lysnivå i omgivelsene.

• Posisjonssensorer. Denne kategorien inkluderer sensorer som måler enhetens fysiske posisjon, for eksempel nærhetssensorer og geomagnetiske feltfølere.
  Bevegelsessensorer. Disse sensorene måler enhetens bevegelse, og inkluderer akselerometre, tyngdekraftssensorer, gyroskoper og rotasjonsvektorsensorer.

I tillegg kan sensorer enten være:

• Maskinvarebasert. Dette er fysiske komponenter som er innebygd i enheten og måler direkte spesifikke egenskaper, for eksempel akselerasjon eller styrken til de omkringliggende geomagnetiske feltene.
• Programvarebasert, noen ganger kjent som virtuelle sensorer eller sammensatte sensorer. Disse samler typisk inn data fra flere maskinvarebaserte sensorer. Mot slutten av denne artikkelen jobber vi med rotasjonsvektorsensoren, som er en programvaresensor som kombinerer data fra enhetens akselerometer, magnetometer og gyroskop.

Miljøsensorer: Måling av omgivelseslys

Android's lyssensor måler omgivelseslys i "lux" -enheter, som er lysets intensitet slik det oppfattes av det menneskelige øyet. Lux-verdien som er rapportert av en sensor, kan variere mellom enheter, så hvis applikasjonen din krever konsistente verdier, kan det hende du må manipulere rådataene før du bruker dem i applikasjonen.

I dette avsnittet skal vi lage et program som henter den nåværende lux-verdien fra enhets lyssensor, viser den i en TextView og deretter oppdaterer TextView når nye data blir tilgjengelige.Du kan deretter bruke denne informasjonen i en rekke apper, for eksempel kan du lage en lommelyktapplikasjon som henter informasjon fra lyssensoren og deretter automatisk justerer styrken på strålen basert på dagens lysnivåer.

Lag et nytt Android-prosjekt med innstillingene du velger, og la oss komme i gang!

Viser sensordataene dine

Jeg skal legge til en TextView som til slutt vil vise dataene vi har hentet ut fra lyssensoren. Denne TextView vil oppdateres når nye data blir tilgjengelige, slik at brukeren alltid har tilgang til den nyeste informasjonen.

Åpne prosjektets Activity_main.xml-fil, og legg til følgende:

Deretter må vi lage "light_sensor" strengressursen som det er referert til i oppsettet vårt. Åpne prosjektets strings.xml-fil, og legg til følgende:

Lyssensor:% 1 $ .2f

"% 1 $ .2f" er en plassholder som spesifiserer informasjonen vi vil vise, og hvordan den skal formateres:

• %1. Du kan sette inn flere plassholdere i den samme strengressursen; "% 1" indikerer at vi bruker en enkelt plassholder.
• $.2. Dette spesifiserer hvordan applikasjonen vår skal formatere hver innkommende flytende punktverdi. “$ .2” indikerer at verdien skal avrundes til to desimaler.
• F. Formater verdien som et flytende punktnummer.

Mens noen sensorer er vanligere enn andre, bør du aldri anta at hver enhet har tilgang til nøyaktig samme maskinvare og programvare. Sensortilgjengeligheten kan til og med variere på forskjellige versjoner av Android, ettersom noen sensorer ikke ble introdusert før senere utgivelser av Android-plattformen.

Du kan sjekke om en bestemt sensor er til stede på en enhet ved å bruke Android-sensorrammen. Du kan deretter deaktivere eller aktivere deler av applikasjonen din basert på sensortilgjengelighet, eller du kan vise en forklaring på at noen av programmets funksjoner ikke fungerer som forventet.

Mens vi har strings.xml-filen åpen, la oss lage en "no_sensor" streng, som vi vil vise hvis lyssensoren ikke er tilgjengelig:

Ingen lyssensor tilgjengelig

Hvis applikasjonen din ikke kan gi en god brukeropplevelse uten å ha tilgang til en bestemt sensor, må du legge denne informasjonen til manifestet ditt. Hvis appen din for eksempel trenger tilgang til en kompasssensor, kan du bruke følgende:

Nå kan appen din bare lastes ned til enheter som har en kompasssensor.

Selv om dette kan begrense publikummet ditt, er det langt mindre skadelig enn å la noen laste ned applikasjonen din når de er det garantert å ha en dårlig opplevelse, på grunn av enhetens sensorkonfigurasjon.

Kommuniserer med en sensor: SensorManager, SensorEvents og lyttere

For å kommunisere med enhetens lyssensor, må du utføre følgende trinn:

1. Få en forekomst av SensorManager

SensorManager tilbyr alle metodene du trenger for å få tilgang til enhetens fulle utvalg av sensorer.

For å starte, oppretter du en variabel som inneholder en forekomst av SensorManager:

privat SensorManager lightSensorManager;

Deretter må du skaffe en forekomst av SensorManager ved å kalle metoden Context.getSystemService og sende inn argumentet Context.SENSOR_SERVICE:

lightSensorManager = (SensorManager) getSystemService (Context.SENSOR_SERVICE);

2. Få en referanse til lightTextView

Deretter må vi opprette en privat medlemsvariabel som vil inneholde TextView-objektene våre, og tilordne den til TextView:

privat TextView lightTextView; ... ... ... lightTextView = (TextView) findViewById (R.id.lightTextView);

3. Sjekk om sensoren finnes på den gjeldende enheten

Du kan få tilgang til en bestemt sensor ved å kalle metoden getDefaultSensor () og deretter sende den aktuelle sensoren. Typekonstanten for lyssensoren er TYPE_LIGHT, så vi må bruke følgende:

lightSensor = lightSensorManager.getDefaultSensor (Sensor.TYPE_LIGHT);

Hvis sensoren ikke eksisterer på denne enheten, vil getDefaultSensor () -metoden returnere null, og vi viser "no_sensor" -strengen:

Streng sensor_error = getResources (). GetString (R.string.no_sensor); if (lightSensor == null) {lightTextView.setText (sensor_error); }}

4. Registrer sensorlytterne dine

Hver gang en sensor har nye data, genererer Android et SensorEvent-objekt. Dette SensorEvent-objektet inkluderer sensoren som genererte hendelsen, en tidsstempel og den nye dataverdien.

Til å begynne med fokuserer vi på lys- og nærhetssensorene, som returnerer et enkelt stykke data. Noen sensorer gir imidlertid flerdimensjonale matriser for hvert SensorEvent, inkludert rotasjonsvektorsensoren, som vi skal undersøke mot slutten av denne artikkelen.

For å sikre at applikasjonen vår blir varslet om disse SensorEvent-objektene, må vi registrere en lytter for den spesifikke sensorhendelsen ved å bruke SensorManagers registerListener ().

Metoden registerListener () tar følgende argumenter:

• En app eller aktivitetskontekst.
• Hvilken type sensor du vil overvåke.
• Hastigheten som sensoren skal sende nye data. En høyere hastighet vil gi applikasjonen din mer data, men den vil også bruke flere systemressurser, spesielt batterilevetid. For å bevare enhetens batteri, må du be om den minste datamengden som søknaden din krever. Jeg kommer til å bruke SensorManager.SENSOR_DELAY_NORMAL, som sender nye data en gang hvert 200 000 mikrosekund (0,2 sekunder).

Siden det å lytte til en sensor tømmer enhetens batteri, bør du aldri registrere lyttere i applikasjonens onCreate () -metode, da dette vil føre til at sensorene fortsetter å sende data, selv når applikasjonen din er i bakgrunnen.

I stedet bør du registrere sensorene dine i applikasjonens onStart () livssyklusmetode:

@Override beskyttet tomrom onStart () {super.onStart (); // Hvis sensoren er tilgjengelig på den gjeldende enheten ... // if (lightSensor! = Null) {//… .så begynn å lytte // lightSensorManager.registerListener (dette, lightSensor, SensorManager.SENSOR_DELAY_NORMAL); }}

5. Implementering av tilbakeringinger av SensorEventListener

SensorEventListener er et grensesnitt som mottar varsler fra SensorManager
når nye data er tilgjengelige, eller sensorens nøyaktighet endres.

Det første trinnet er å endre klassesignaturen for å implementere SensorEventListener-grensesnittet:

offentlig klasse MainActivity utvider AppCompatActivity implementerer SensorEventListener {

Vi må da implementere følgende tilbakeringingsmetoder:

onSensorChanged ()

Denne metoden kalles som svar på hver nye SensorEvent.

Sensordata kan ofte endre seg raskt, slik at applikasjonen din kan ringe onSensorChanged () -metoden regelmessig. For å bidra til at applikasjonen din fungerer jevnt, bør du utføre så lite arbeid som mulig innenfor onSensorChanged () -metoden.

@Override offentlig tomrom på SensorChanged (SensorEvent sensorEvent) {// Gjør //}

onAccuracyChanged ()

Hvis sensorens nøyaktighet forbedres eller avtar, vil Android kalle metoden onAccuracyChanged () og gi den et sensorobjekt som inneholder den nye nøyaktighetsverdien, for eksempel SENSOR_STATUS_UNRELIABLE eller SENSOR_STATUS_ACCURACY_HIGH.

Lyssensoren rapporterer ikke nøyaktighetsendringer, så jeg vil forlate tilbakeringingen onAccuracyChanged () tom:

@Override offentlig tomrom påAccuracyChanged (sensorsensor, int i) {// To do //}}

6. Hent sensorverdien

Hver gang vi har en ny verdi, må vi kalle metoden onSensorChanged () og hente “light_sensor” -strengen. Vi kan da overstyre strengens plassholdertekst (% 1 $ .2f) og vise den oppdaterte strengen som en del av Tekstvisningen:

@Override public void onSensorChanged (SensorEvent sensorEvent) {// Sensorens nåværende verdi // float currentValue = sensorEvent.values; // Hent “light_sensor” -strengen, sett inn den nye verdien og vis den til brukeren // lightTextView.setText (getResources (). GetString (R.string.light_sensor, currentValue)); }

7. Avregistrer lytterne dine

Sensorer kan generere store datamengder på litt tid, så for å bidra til å bevare enhetens ressurser trenger du å avregistrere lytterne dine når de ikke lenger er behov for det.

Hvis du vil slutte å lytte etter sensorhendelser når applikasjonen din er i bakgrunnen, legger du til unregisterListener () til prosjektets onStop () livssyklusmetode:

@Override beskyttet tomrom onStop () {super.onStop (); lightSensorManager.unregisterListener (this); }

Merk at du ikke bør avregistrere lytterne dine i OnPause (), da applikasjoner i Android 7.0 og nyere kan kjøres i delt skjerm- og bilde-i-bilde-modus, der de er i pausetilstand, men forblir synlige på skjermen.

Bruke Android lyssensorer: Fullført kode

Etter å ha fullført alle trinnene ovenfor, bør prosjektets MainActivity se slik ut:

import android.support.v7.app.AppCompatActivity; import android.os.Bundle; import android.content.Context; import android.hardware.Sensor; import android.hardware.SensorEvent; import android.hardware.SensorEventListener; import android.hardware.SensorManager; import android.widget.TextView; offentlig klasse MainActivity utvider AppCompatActivity // Implementere SensorEventListener-grensesnittet // implementerer SensorEventListener {// Lag dine variabler // private Sensor lightSensor; privat SensorManager lightSensorManager; privat TextView lightTextView; @Override beskyttet tomrom onCreate (Bundle savedInstanceState) {super.onCreate (savedInstanceState); setContentView (R.layout.activity_main); lightTextView = (TextView) findViewById (R.id.lightTextView); // Få en forekomst av SensorManager // lightSensorManager = (SensorManager) getSystemService (Context.SENSOR_SERVICE); // Se etter en lyssensor // lightSensor = lightSensorManager.getDefaultSensor (Sensor.TYPE_LIGHT); // Hvis lyssensoren ikke eksisterer, må du vise en feil // String sensor_error = getResources (). GetString (R.string.no_sensor); if (lightSensor == null) {lightTextView.setText (sensor_error); }} @Overr beskyttet tomrom onStart () {super.onStart (); // Hvis sensoren er tilgjengelig på den nåværende enheten ... // if (lightSensor! = Null) {// ... da registrer en lytter // lightSensorManager.registerListener (dette, lightSensor, // Angi hvor ofte du vil motta nye data // SensorManager.SENSOR_DELAY_NORMAL); }} @Overr beskyttet tomrom onStop () {super.onStop (); // Avregistrer lytteren din // lightSensorManager.unregisterListener (dette); } @Override offentlig tomrom på SensorChanged (SensorEvent sensorEvent) {// Sensorens nåværende verdi // float currentValue = sensorEvent.values; // Hent “light_sensor” -strengen, sett inn den nye verdien og oppdater TextView // lightTextView.setText (getResources (). GetString (R.string.light_sensor, currentValue)); } @Override // Hvis sensorens nøyaktighet endres…. // offentlig tomrom påAccuracyChanged (Sensorsensor, int i) {// TO DO //}}

Test den komplette Android-sensorappen

Slik tester du denne applikasjonen på en fysisk Android-smarttelefon eller -brett:

• Installer prosjektet på enheten din (ved å velge "Kjør> Kjør" fra verktøylinjen til Android Studio).
• Selv om det varierer mellom enheter, er lyssensoren ofte plassert øverst til høyre på skjermen. Hvis du vil manipulere lysnivåene, flytter du enheten nærmere og deretter lenger bort fra en lyskilde. Alternativt kan du prøve å dekke enheten med hånden for å blokkere lyset. Verdien "Lyssensor" skal øke og redusere, avhengig av mengden lys som er tilgjengelig.

Hvis du bruker en Android Virtual Device (AVD), har emulatoren et sett med virtuelle sensorkontroller som du kan bruke til å simulere forskjellige sensorhendelser. Du får tilgang til disse virtuelle sensorkontrollene, via emulatorens "Utvidede kontroller" -vindu:

• Installer applikasjonen på AVD-en.
• Ved siden av AVD ser du en knappestripe. Finn den tre-prikkede “Mer” -knappen (der markøren er plassert i følgende skjermbilde) og gi den et klikk. Dette starter vinduet "Utvidede kontroller".

• I menyen til venstre velger du “Virtuelle sensorer.”
• Velg kategorien “Flere sensorer”. Denne fanen inneholder forskjellige glidebrytere som du kan bruke til å simulere forskjellige posisjons- og miljøsensorhendelser.

• Finn glidebryteren “Lys (lux)” og dra den til venstre og høyre for å endre de simulerte lysnivåene. Søknaden din skal vise disse endrede verdiene i sanntid.

Du kan laste ned det ferdige prosjektet fra GitHub.

Måling avstand, med Androids nærhetssensorer

Nå har vi sett hvordan du kan hente informasjon fra en miljøsensor, la oss se på hvordan du vil bruke denne kunnskapen på en posisjon sensor.

I denne delen bruker vi enhetens nærhetssensor til å overvåke avstanden mellom smarttelefonen eller nettbrettet ditt og andre objekter. Hvis applikasjonen din har noen form for stemmefunksjonalitet, kan nærhetssensoren hjelpe deg med å bestemme når smarttelefonen holdes til brukerens øre, for eksempel når de holder en telefonsamtale. Du kan deretter bruke denne informasjonen til å deaktivere berøringshendelser, slik at brukeren ikke ved et uhell legger på eller utløser andre uønskede hendelser i løpet av samtalen.

Opprette brukergrensesnittet

Jeg kommer til å vise nærhetsdataene på skjermen, slik at du kan se den oppdateres i sanntid. La oss gjenbruke mye av oppsettet fra vår forrige applikasjon for å holde ting enkelt.

Deretter åpner du strings.xml-filen og oppretter en "proximity_sensor" -streng. Nok en gang må denne strengen inneholde en plassholder, som til slutt vil bli befolket av data hentet fra nærhetssensoren:

ProximitySensor Nærhetssensor:% 1 $ .2f Ingen nærhetssensor tilgjengelig

Henter data fra nærhetssensoren

I likhet med lyssensoren returnerer Androids nærhetssensor en enkelt dataverdi, noe som betyr at vi kan gjenbruke mye av koden fra vår forrige applikasjon. Imidlertid er det noen få store forskjeller, pluss noen navnerelaterte endringer som gjør denne koden enklere å følge:

• Lag en forekomst av SensorManager, som denne gangen jeg skal kalle “proximitySensorManager.”
• Få en forekomst av “proximitySensorManager.”
• Opprett en referanse til “proximityTextView.”
• Ring getDefaultSensor () -metoden, og pass den TYPE_PROXIMITY-sensoren.
• Registrer og avregistrer lyttere for nærhetssensoren.

Etter å ha laget disse justeringene, bør du ende opp med følgende:

import android.support.v7.app.AppCompatActivity; import android.os.Bundle; import android.content.Context; import android.hardware.Sensor; import android.hardware.SensorEvent; import android.hardware.SensorManager; import android.hardware.SensorEventListener; import android.widget.TextView; offentlig klasse MainActivity utvider AppCompatActivity // Implementere SensorEventListener-grensesnittet // implementerer SensorEventListener {// Lag dine variabler // private Sensor proximitySensor; privat SensorManager nærhetSensorManager; privat TextView proximityTextView; @Override beskyttet tomrom onCreate (Bundle savedInstanceState) {super.onCreate (savedInstanceState); setContentView (R.layout.activity_main); proximityTextView = (TextView) findViewById (R.id.proximityTextView); // Få en forekomst av SensorManager // proximitySensorManager = (SensorManager) getSystemService (Context.SENSOR_SERVICE); // Sjekk for en nærhetssensor // proximitySensor = proximitySensorManager.getDefaultSensor (Sensor.TYPE_PROXIMITY); // Hvis nærhetssensoren ikke eksisterer, viser du en feil // String sensor_error = getResources (). GetString (R.string.no_sensor); if (proximitySensor == null) {proximityTextView.setText (sensor_error); }} @Overr beskyttet tomrom onStart () {super.onStart (); // Hvis sensoren er tilgjengelig på den nåværende enheten ... // if (proximitySensor! = Null) {// ... da registrerer du en lytter // proximitySensorManager.registerListener (dette, proximitySensor, // Angi hvor ofte du vil motta nye data // SensorManager.SENSOR_DELAY_NORMAL); }} @Overr beskyttet tomrom onStop () {super.onStop (); // Avregistrer lytteren din for å bevare systemressurser // proximitySensorManager.unregisterListener (dette); } @Override offentlig tomrom på SensorChanged (SensorEvent sensorEvent) {// Sensorens nåværende verdi // float currentValue = sensorEvent.values; // Hent “proximity_sensor” -strengen, sett inn den nye verdien og oppdater TextView // proximityTextView.setText (getResources (). GetString (R.string.proximity_sensor, currentValue)); } @Override // Hvis sensorens nøyaktighet endres…. // offentlig tomrom påAccuracyChanged (Sensorsensor, int i) {//...TO DO //}}

Testing: Hvor nær er brukeren enheten deres?

Hvis du vil sette denne applikasjonen på prøve på en fysisk Android-smarttelefon eller -tablett, installerer du applikasjonen på enheten din og eksperimenterer deretter ved å bevege hånden mot skjermen og deretter flytte den bort igjen. Verdien "Nærhetssensor" skal registrere bevegelsene dine.

Bare vær oppmerksom på at nærhetssensorer kan variere mellom enheter. Noen enheter kan bare vise to nærhetsverdier - en for å indikere "Nær" og en for å indikere "Far" - så ikke bli overrasket om du ikke ser mye variasjon på din fysiske Android-enhet.

Slik tester du denne applikasjonen på en emulator:

• Installer applikasjonen din på en AVD.
• Finn den tre-prikkede “Mer” -knappen og gi den et klikk, som starter “Utvidede kontroller” -vinduet.
• I vinduets venstre meny velger du "Virtuelle sensorer."
• Velg kategorien “Flere sensorer”.
• Finn glidebryteren “Nærhet”, og dra den til venstre og høyre for å etterligne et objekt som beveger seg nærmere enheten, og deretter lenger bort. Verdiene "Nærhetssensor" bør endres når du manipulerer glidebryteren.

Du kan laste ned det ferdige prosjektet fra GitHub.

Bevegelsessensorer: Behandler flerdimensjonale matriser

Frem til dette tidspunktet har vi fokusert på sensorer som leverer et enkelt dataelement, men det er noen sensorer som gir flerdimensjonale matriser for hvert SensorEvent. Disse flerdimensjonale sensorene inkluderer bevegelsessensorer, som vi vil fokusere på i denne siste delen.

Bevegelsessensorer kan hjelpe deg:

• Gi en alternativ metode for brukerinndata. For eksempel, hvis du utvikler et mobilspill, kan brukeren flytte karakteren sin rundt på skjermen ved å vippe enheten.
• Avslutt brukeraktivitet. Hvis du har laget en aktivitetssporingsapp, kan bevegelsessensorer hjelpe deg med å måle om brukeren reiser i en bil, jogger eller sitter ved skrivebordet sitt.
• Mer nøyaktig bestemme orientering.Det er mulig å trekke ut koordinater fra en enhets bevegelsessensorer og deretter oversette dem basert på jordas koordinatsystem, for å få en mest mulig nøyaktig innsikt i enhetens nåværende retning.

I denne siste delen bruker vi rotasjonsvektorsensoren (TYPE_ROTATION_VECTOR). I motsetning til lys- og nærhetssensorene, er dette en programvaresensor som samler data fra enhetens akselerometer, magnetometer og gyroskopføler. Selv om du ofte arbeider med denne sensoren, krever at du utfører matematiske konverteringer og transformasjoner, kan den også gi deg en rekke svært nøyaktig informasjon om enheten.

Vi oppretter et program som bruker rotasjonsvektorsensoren til å måle:

• Tonehøyde. Dette er den øvre og nederste skråningen på enheten.
• Rull. Dette er skråningen fra venstre til høyre på enheten.

Viser sanntids pitch and roll data

Siden vi måler to beregninger, må vi lage to TextViews og to tilsvarende strengressurser:

Åpne filen strings.xml, og legg til følgende:

MotionSensors Pitch Sensor:% 1 $ .2f Rullesensor:% 1 $ .2f Ingen bevegelsessensor tilgjengelig

Bruker rotasjonsvektorsensoren i appen din

Vi bruker noe av koden fra de tidligere applikasjonene våre, så la oss fokusere på områdene der kommunikasjon med rotasjonsvektorsensoren, er betydelig forskjellig fra det vi har sett før.

1. Bruk TYPE_ROTATION_VECTOR

Siden vi jobber med rotasjonsvektorsensoren, må vi ringe metoden getDefaultSensor () og deretter passere den TYPE_ROTATION_VECTOR-konstanten:

positionSensorManager.getDefaultSensor (Sensor.TYPE_ROTATION_VECTOR);

2. Oversett sensordataene

I motsetning til de tidligere lys- og nærhetssensorene, returnerer bevegelsessensorer flerdimensjonale matriser av sensorverdier for hvert SensorEvent. Disse verdiene er formatert ved hjelp av standard "X, Y, Z" koordinatsystem, som beregnes i forhold til enheten når den holdes i standard, "naturlig" retning.

Android bytter ikke disse X-, Y- og Z-koordinatene slik at de samsvarer med enhetens nåværende retning, så “X” -aksen vil forbli den samme uansett om enheten er i stående eller liggende modus. Når du bruker rotasjonsvektorsensoren, kan det hende du må konvertere innkommende data for å samsvare med enhetens nåværende rotasjon.

Portrett er standardretning for de fleste smarttelefoner, men du bør ikke anta at dette kommer til å være tilfelle alle Android-enheter, spesielt nettbrett. I denne artikkelen bruker vi en rotasjonsmatrise for å oversette sensorens data fra originalen, enhet koordinatsystem, til jordens koordinatsystem, som representerer enhetens bevegelse og posisjon i forhold til jorden. Om nødvendig kan vi deretter gjenskape sensordataene, basert på enhetens nåværende retning.

For det første er enhetskoordinatsystemet et standard 3-akset X, Y, Z koordinatsystem, der hvert punkt på hver av de tre aksene er representert av en 3D-vektor. Dette betyr at vi må lage en rekke 9 floatverdier:

float rotationMatrix = new float;

Vi kan deretter overføre denne matrisen til getRotationMatrix () -metoden:

SensorManager.getRotationMatrixFromVector (rotationMatrix, vektorer); int worldAxisX = SensorManager.AXIS_X; int worldAxisZ = SensorManager.AXIS_Z;

Det neste trinnet er å bruke SensorManager.remapCoordinateSystem () -metoden for å gjenskape sensordataene, basert på enhetens nåværende retning.

SensorManager.remapCoordinateSystem () -metoden tar følgende argumenter:

• Den opprinnelige rotasjonsmatrisen.
• Øksene du vil gjenskape.
• Matrisen du fyller med disse nye dataene.

Her er koden jeg skal bruke i appen min:

float adjustRotationMatrix = ny flottør; SensorManager.remapCoordinateSystem (rotationMatrix, worldAxisX, worldAxisZ, justertRotationMatrix);

Til slutt vil vi ringe SensorManager.getOrientation og fortelle den å bruke den justerte rotasjonsmatrisen:

SensorManager.getOrientation (justertRotationMatrix, orientering);

3. Oppdater plassholderstrengene

Siden vi har to datasett (tonehøyde og rullering), må vi hente to separate plassholderstrenger, fylle dem med riktige verdier og deretter oppdatere den tilsvarende TextView:

pitchTextView.setText (getResources (). getString (R.string.pitch_sensor, pitch)); rollTextView.setText (getResources (). getString (R.string.roll_sensor, roll));

Vise flere sensordata: Fullført kode

Etter å ha utført trinnene ovenfor, bør MainActivity se slik ut:

import android.app.Aktivitet; import android.os.Bundle; import android.hardware.Sensor; import android.hardware.SensorEvent; import android.hardware.SensorEventListener; import android.hardware.SensorManager; import android.widget.TextView; offentlig klasse MainActivity utvider Aktivitetsredskaper SensorEventListener {privat SensorManager motionSensorManager; privat Sensor motion Sensor; privat TextView pitchTextView; privat TextView rollTextView; privat statisk finale int SENSOR_DELAY = 500 * 1000; privat statisk endelig int FROM_RADS_TO_DEGS = -57; @Override beskyttet tomrom onCreate (Bundle savedInstanceState) {super.onCreate (savedInstanceState); setContentView (R.layout.activity_main); pitchTextView = (TextView) findViewById (R.id.pitchTextView); rollTextView = (TextView) findViewById (R.id.rollTextView); prøv {motionSensorManager = (SensorManager) getSystemService (Activity.SENSOR_SERVICE); motionSensor = motionSensorManager.getDefaultSensor (Sensor.TYPE_ROTATION_VECTOR); motionSensorManager.registerListener (dette, motionSensor, SENSOR_DELAY); } fangst (unntak e) {pitchTextView.setText (R.string.no_sensor); rollTextView.setText (R.string.no_sensor); }} @Override offentlig tomrom onAccuracyChanged (sensorsensor, int nøyaktighet) {// For å gjøre //} @Override public void onSensorChanged (SensorEvent-hendelse) {if (event.sensor == motionSensor) {update (event.values); }} privat tomromoppdatering (floatvektorer) {// Beregn rotasjonsmatrisen // float rotationMatrix = new float; SensorManager.getRotationMatrixFromVector (rotationMatrix, vektorer); int worldAxisX = SensorManager.AXIS_X; int worldAxisZ = SensorManager.AXIS_Z; // Gjenta om matrisen basert på Aktivitetens nåværende retning // float adjustRotationMatrix = new float; SensorManager.remapCoordinateSystem (rotationMatrix, worldAxisX, worldAxisZ, justertRotationMatrix); // Beregn enhetens retning // floatorientering = ny flottør; // Tilfør rekken av floatverdier til metoden getOrientation () // SensorManager.getOrientation (justert rotasjonsmåter, orientering); float pitch = orientering * FROM_RADS_TO_DEGS; flyterulle = orientering * FROM_RADS_TO_DEGS; // Oppdater TextViews med tonehøyde og rulleverdier // pitchTextView.setText (getResources (). GetString (R.string.pitch_sensor, pitch)); rollTextView.setText (getResources (). getString (R.string.roll_sensor, roll)); }}

Du kan laste ned det ferdige prosjektet fra GitHub.

Testing av vår endelige Android-sensorapplikasjon

Slik tester du denne rotasjonsvektoren Android-sensorappen på en fysisk Android-smarttelefon eller nettbrett:

• Installer applikasjonen på enheten din.
• Plasser smarttelefonen eller nettbrettet på et flatt underlag. Legg merke til at bevegelsessensorer er ekstremt følsomme, så det er ikke uvanlig at en tilsynelatende bevegelsesfri enhet rapporterer svingninger i tonehøyde og rulleverdier.
• For å teste tonehøyde, løfter du bunnen av enheten din slik at den vipper bort fra deg. Toneverdien bør endres dramatisk.
• For å teste rullen, prøv å løfte venstre side av enheten din, så den vipper til venstre - følg med på den rulleverdien!

Hvis du tester prosjektet ditt på en emulator:

• Installer applikasjonen på AVD-en.
• Velg "Mer", som åpner vinduet "Utvidede kontroller".
• I menyen til venstre velger du “Virtuelle sensorer.”
• Forsikre deg om at "Accelerometer" -fanen er valgt. Denne fanen inneholder kontroller som kan simulere endringer i enhetens posisjon og retning.
• Prøv å eksperimentere med de forskjellige skyvekontrollene (Roter: Z-Rot, X-Rot, Y-Rot; og Move: X, Y og Z) og de forskjellige “Device Rotation” -knappene, for å se hvordan de påvirker applikasjonens “Roll Sensor” ”Og“ Pitch Sensor ”verdier.

Innpakking

I denne artikkelen så vi hvordan vi kan hente data fra de tre hovedkategoriene for Android-sensorer: miljø, posisjon og bevegelse, og hvordan du kan overvåke disse dataene i sanntid.

Har du sett noen Android-apper som bruker sensorer på interessante eller unike måter? Gi oss beskjed i kommentarene nedenfor!