Innehåll

• Vilka Android-sensorer kan jag använda?
• Miljösensorer: Mät omgivande ljus
• Visa dina sensordata
• Kommunikera med en sensor: SensorManager, SensorEvents och lyssnare
• 1. Få en instans av SensorManager
• 2. Få en referens till lightTextView
• 3. Kontrollera om sensorn finns på den aktuella enheten
• 4. Registrera dina sensorns lyssnare
• 5. Implementera återuppringningar av SensorEventListener
• onSensorChanged ()
• onAccuracyChanged ()
• 6. Hämta sensorns värde
• 7. Avregistrera dina lyssnare
• Använda Android: s ljusgivare: Komplett kod
• Testa din färdiga Android-sensorapp
• Mät avstånd med Android: s närhetssensorer
• Skapa användargränssnittet
• Hämta data från närhetssensorn
• Testning: Hur nära ligger användaren på sin enhet?
• Rörelsessensorer: Bearbetar flerdimensionella matriser
• Visar data i realtid tonhöjd och rullning
• Använd rotationsvektorsensorn i din app
• 1. Använd TYPE_ROTATION_VECTOR
• 2. Översätt sensordata
• 3. Uppdatera platshållarens strängar
• Visa flera sensordata: Komplett kod
• Testar vår slutliga Android-sensorapplikation
• Avslutar

Idag är de flesta moderna Android-enheter utrustade med ett gäng sensorer.

Du kan använda den här informationen på många olika sätt - oavsett om den övervakar ljusnivåer så att din applikation automatiskt kan justera dess ljusstyrka eller färgschema; så att användaren kan interagera med ditt mobilspel genom att använda gester som att luta sin enhet; eller med hjälp av närhetssensorn för att automatiskt inaktivera beröringshändelser när användaren håller sin enhet i örat.

I den här artikeln skapar vi tre applikationer som hämtar data om ljus, närhet och rörelse från en rad hårdvaru- och mjukvarusensorer. Vi övervakar också dessa Android-sensorer i realtid, så din applikation har alltid tillgång till den senaste informationen.

I slutet av den här artikeln vet du hur man extraherar en enda data från en Android-sensor och hur man hanterar sensorer som tillhandahåller deras data i form av en flerdimensionell matris.

Vilka Android-sensorer kan jag använda?

Android-sensorer kan delas in i följande kategorier:

• Miljöavkännare. Dessa mäter miljöförhållanden, såsom lufttemperatur, tryck, luftfuktighet och ljusnivåer i omgivningen.

• Position sensorer. Denna kategori inkluderar sensorer som mäter enhetens fysiska position, till exempel närhetssensorer och geomagnetiska fältsensorer.
  Rörelsessensorer. Dessa sensorer mäter enhetens rörelse och inkluderar accelerometrar, tyngdkraftssensorer, gyroskop och rotationsvektorsensorer.

Dessutom kan sensorer antingen vara:

• Hårdvarubaserad. Detta är fysiska komponenter som är inbyggda i enheten och mäter specifika egenskaper, till exempel acceleration eller styrkan hos de omgivande geomagnetiska fälten.
• Programvarubaserad, ibland känd som virtuella sensorer eller sammansatta sensorer. Dessa samlar vanligtvis data från flera hårdvarubaserade sensorer. Mot slutet av den här artikeln kommer vi att arbeta med rotationsvektorsensorn, som är en mjukvarasensor som kombinerar data från enhetens accelerometer, magnetometer och gyroskop.

Miljösensorer: Mät omgivande ljus

Android: s ljusgivare mäter omgivande ljus i ”lux” -enheter, vilket är ljusintensiteten som det uppfattas av det mänskliga ögat. Lux-värdet som rapporteras av en sensor kan variera mellan enheter, så om din applikation kräver konsekventa värden kan du behöva manipulera rådata innan du använder den i din applikation.

I det här avsnittet kommer vi att skapa en applikation som hämtar det nuvarande lux-värdet från enhetens ljussensor, visar det i en TextView och sedan uppdaterar TextView när ny data blir tillgänglig.Du kan sedan använda den här informationen i en rad appar, till exempel kan du skapa en facklaapplikation som drar information från ljussensorn och justerar automatiskt styrka på strålen baserat på de aktuella ljusnivåerna.

Skapa ett nytt Android-projekt med dina inställningar och låt oss komma igång!

Visa dina sensordata

Jag kommer att lägga till en TextView som så småningom kommer att visa de data vi har extraherat från ljussensorn. Denna TextView kommer att uppdateras när nya data blir tillgängliga, så användaren har alltid tillgång till den senaste informationen.

Öppna projektets Activity_main.xml-fil och lägg till följande:

Därefter måste vi skapa strängaresursen "light_sensor" som det hänvisas till i vår layout. Öppna projektets strings.xml-fil och lägg till följande:

Ljussensor:% 1 $ .2f

"% 1 $ .2f" är en platshållare som anger informationen vi vill visa och hur den ska formateras:

• %1. Du kan infoga flera platshållare i samma strängresurs; "% 1" indikerar att vi använder en enda platshållare.
• $.2. Detta anger hur vår applikation ska formatera varje inkommande flytande punktvärde. "$ .2" indikerar att värdet bör avrundas till två decimaler.
• F. Formatera värdet som ett flytpunktsnummer.

Medan vissa sensorer är vanligare än andra, bör du aldrig anta att varje enhet har tillgång till exakt samma hårdvara och mjukvara. Sensortillgänglighet kan till och med variera mellan olika versioner av Android, eftersom vissa sensorer inte introducerades förrän senare versioner av Android-plattformen.

Du kan kontrollera om en viss sensor finns på en enhet med Android-sensorramen. Du kan sedan inaktivera eller aktivera delar av din applikation baserat på sensortillgänglighet, eller så kan du visa en förklaring av att vissa av din applikations funktioner inte fungerar som förväntat.

Medan vi har vår strings.xml-fil öppna, låt oss skapa en "no_sensor" -sträng, som vi visar om ljussensorn inte är tillgänglig:

Ingen ljusgivare tillgänglig

Om din applikation inte kan ge en bra användarupplevelse utan att ha tillgång till en viss sensor, måste du lägga till denna information till ditt Manifest. Om din app till exempel behöver åtkomst till en kompassgivare kan du använda följande:

Nu kan din app bara laddas ner till enheter som har kompassgivare.

Även om detta kan begränsa din publik är det mycket mindre skadligt än att låta någon ladda ner din ansökan när de är det garanterat att ha en dålig upplevelse på grund av enhetens sensorkonfiguration.

Kommunikera med en sensor: SensorManager, SensorEvents och lyssnare

För att kommunicera med enhetens ljussensor måste du utföra följande steg:

1. Få en instans av SensorManager

SensorManager tillhandahåller alla metoder du behöver för att komma åt enhetens hela sortiment av sensorer.

För att starta, skapa en variabel som kommer att innehålla en instans av SensorManager:

privat SensorManager lightSensorManager;

Sedan måste du skaffa en instans av SensorManager genom att anropa metoden Context.getSystemService och skicka in argumentet Context.SENSOR_SERVICE:

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

2. Få en referens till lightTextView

Därefter måste vi skapa en privat medlemsvariabel som kommer att innehålla våra TextView-objekt och tilldela den till vår TextView:

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

3. Kontrollera om sensorn finns på den aktuella enheten

Du kan få tillgång till en viss sensor genom att ringa metoden getDefaultSensor () och sedan skicka den ifrågavarande sensorn. Typkonstanten för ljussensorn är TYPE_LIGHT, så vi måste använda följande:

lightSensor = lightSensorManager.getDefaultSensor (Sensor.TYPE_LIGHT);

Om sensorn inte finns på den här enheten kommer metoden getDefaultSensor () att returnera noll och vi visar strängen "no_sensor":

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

4. Registrera dina sensorns lyssnare

Varje gång en sensor har ny data genererar Android ett SensorEvent-objekt. Detta SensorEvent-objekt inkluderar sensorn som genererade händelsen, en tidsstämpel och det nya datavärdet.

Till en början kommer vi att fokusera på ljus- och närhetssensorerna, som returnerar en enda data. Vissa sensorer tillhandahåller dock multidimensionella matriser för varje SensorEvent, inklusive rotationsvektorsensorn, som vi ska undersöka mot slutet av denna artikel.

För att säkerställa att vår applikation meddelas om dessa SensorEvent-objekt, måste vi registrera en lyssnare för den specifika sensorhändelsen med hjälp av SensorManagers registerListener ().

Metoden registerListener () tar följande argument:

• En app eller aktivitetskontekst.
• Vilken typ av sensor du vill övervaka.
• Den hastighet med vilken sensorn ska skicka ny data. En högre takt ger din applikation mer data, men den kommer också att använda fler systemresurser, särskilt batteritid. För att hjälpa till att bevara enhetens batteri bör du begära den minsta mängd data som din applikation kräver. Jag kommer att använda SensorManager.SENSOR_DELAY_NORMAL, som skickar ny data en gång var 200 000 mikrosekunder (0,2 sekunder).

Eftersom lyssna på en sensor dränerar enhetens batteri bör du aldrig registrera lyssnare i din applikations metod onCreate (), eftersom det kommer att göra att sensorerna fortsätter att skicka data, även när din applikation är i bakgrunden.

Istället bör du registrera dina sensorer i applikationens onStart () livscykelmetod:

@Override skyddat tomrum onStart () {super.onStart (); // Om sensorn är tillgänglig på den aktuella enheten ... // if (lightSensor! = Null) {//...börja sedan lyssna // lightSensorManager.registerListener (detta, lightSensor, SensorManager.SENSOR_DELAY_NORMAL); }}

5. Implementera återuppringningar av SensorEventListener

SensorEventListener är ett gränssnitt som tar emot aviseringar från SensorManager
när ny information finns tillgänglig eller sensorns noggrannhet ändras.

Det första steget är att ändra vår klasssignatur för att implementera SensorEventListener-gränssnittet:

public class MainActivity utökar AppCompatActivity implementerar SensorEventListener {

Vi måste sedan implementera följande återuppringningsmetoder:

onSensorChanged ()

Denna metod kallas som svar på varje nytt SensorEvent.

Sensordata kan ofta förändras snabbt, så din applikation kan ringa metoden onSensorChanged () regelbundet. För att hjälpa till att hålla din applikation smidig bör du utföra så lite arbete som möjligt i metoden onSensorChanged ().

@Override public void onSensorChanged (SensorEvent sensorEvent) {// Att göra //}

onAccuracyChanged ()

Om sensorns noggrannhet förbättras eller minskar, kommer Android att anropa metoden onAccuracyChanged () och skicka den ett sensorobjekt som innehåller det nya noggrannhetsvärdet, till exempel SENSOR_STATUS_UNRELIABLE eller SENSOR_STATUS_ACCURACY_HIGH.

Ljussensorn rapporterar inte noggrannhetsändringar, så jag lämnar återuppringningen onAccuracyChanged () tom:

@Override public void onAccuracyChanged (Sensorsensor, int i) {// To do //}}

6. Hämta sensorns värde

När vi har ett nytt värde måste vi anropa metoden onSensorChanged () och hämta strängen "light_sensor". Vi kan sedan åsidosätta strängens platshållartekst (% 1 $ .2f) och visa den uppdaterade strängen som en del av vår TextView:

@Override public void onSensorChanged (SensorEvent sensorEvent) {// Sensorns aktuella värde // float currentValue = sensorEvent.values; // Hämta strängen "light_sensor", sätt in det nya värdet och visa det till användaren // lightTextView.setText (getResources (). GetString (R.string.light_sensor, currentValue)); }

7. Avregistrera dina lyssnare

Sensorer kan generera stora mängder data på en liten tid, så för att hjälpa till att bevara enhetens resurser måste du avregistrera dina lyssnare när de inte längre behövs.

Om du vill sluta lyssna på sensorhändelser när din applikation är i bakgrunden lägger du till unregisterListener () till projektets onStop () livscykelmetod:

@Override skyddat tomrum onStop () {super.onStop (); lightSensorManager.unregisterListener (detta); }

Observera att du inte bör avregistrera dina lyssnare i onPause (), som i Android 7.0 och högre applikationer kan köras i delad skärm och bild-i-bild-läge, där de är i pausat tillstånd, men förblir synliga på skärmen.

Använda Android: s ljusgivare: Komplett kod

När du har slutfört alla ovanstående steg bör projektets MainActivity se ut så här:

importera 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; public class MainActivity utökar AppCompatActivity // Implementera SensorEventListener-gränssnittet // implementerar SensorEventListener {// Skapa dina variabler // private Sensor lightSensor; privat SensorManager lightSensorManager; privat TextView lightTextView; @Override skyddat tomrum onCreate (Bundle SavedInstanceState) {super.onCreate (SavedInstanceState); setContentView (R.layout.activity_main); lightTextView = (TextView) findViewById (R.id.lightTextView); // Skaffa en instans av SensorManager // lightSensorManager = (SensorManager) getSystemService (Context.SENSOR_SERVICE); // Kontrollera om en ljusgivare // lightSensor = lightSensorManager.getDefaultSensor (Sensor.TYPE_LIGHT); // Om ljussensorn inte finns, visa sedan ett fel // String sensor_error = getResources (). GetString (R.string.no_sensor); if (lightSensor == null) {lightTextView.setText (sensor_error); }} @Override skyddat tomrum onStart () {super.onStart (); // Om sensorn är tillgänglig på den aktuella enheten ... // if (lightSensor! = Null) {//...registrera sedan en lyssnare // lightSensorManager.registerListener (detta, lightSensor, // Ange hur ofta du vill ta emot nya data // SensorManager.SENSOR_DELAY_NORMAL); }} @Override skyddat tomrum onStop () {super.onStop (); // Avregistrera din lyssnare // lightSensorManager.unregisterListener (detta); } @Override public void onSensorChanged (SensorEvent sensorEvent) {// Sensorns aktuella värde // float currentValue = sensorEvent.values; // Hämta strängen "light_sensor", sätt in det nya värdet och uppdatera TextView // lightTextView.setText (getResources (). GetString (R.string.light_sensor, currentValue)); } @Override // Om sensorns noggrannhet förändras… .// public void onAccuracyChanged (Sensorsensor, int i) {// TO DO //}}

Testa din färdiga Android-sensorapp

Så här testar du den här applikationen på en fysisk Android-smartphone eller surfplatta:

• Installera projektet på din enhet (genom att välja "Kör> Kör" från Android Studio verktygsfält).
• Även om det varierar mellan enheterna, är ljussensorn ofta belägen längst upp till höger på skärmen. För att manipulera ljusnivåerna, flytta din enhet närmare och sedan bort från en ljuskälla. Alternativt kan du försöka täcka enheten med handen för att blockera ljuset. Värdet ”Ljussensor” bör öka och minska, beroende på mängden tillgängligt ljus.

Om du använder en Android Virtual Device (AVD) har emulatorn en uppsättning virtuella sensorkontroller som du kan använda för att simulera olika sensorhändelser. Du får åtkomst till dessa virtuella sensorkontroller via emulatorns "Utökade kontroller" -fönster:

• Installera applikationen på din AVD.
• Vid sidan av AVD ser du en knappremsa. Hitta den tre-prickade "More" -knappen (där markören är placerad i följande skärmdump) och ge den ett klick. Detta startar fönstret "Utökade kontroller".

• I menyn till vänster väljer du "Virtuella sensorer."
• Välj fliken "Ytterligare sensorer". Den här fliken innehåller olika reglage som du kan använda för att simulera olika positions- och miljösensorhändelser.

• Hitta skjutreglaget “Ljus (lux)” och dra den åt vänster och höger för att ändra de simulerade ljusnivåerna. Din applikation bör visa dessa förändrade värden i realtid.

Du kan ladda ner det slutförda projektet från GitHub.

Mät avstånd med Android: s närhetssensorer

Nu har vi sett hur man hämtar information från en miljösensor, låt oss titta på hur du skulle tillämpa denna kunskap på en placera sensor.

I det här avsnittet använder vi enhetens närhetssensor för att övervaka avståndet mellan din smartphone eller surfplatta och andra objekt. Om din applikation har någon form av röstfunktionalitet kan närhetssensorn hjälpa dig att avgöra när smarttelefonen hålls i användarens öra, till exempel när de håller på telefonsamtal. Du kan sedan använda den här informationen för att inaktivera berörningshändelser, så att användaren inte av misstag lägger på eller utlöser andra oönskade händelser i mitten av konversationen.

Skapa användargränssnittet

Jag kommer att visa närhetsdata på skärmen så att du kan se den uppdateras i realtid. För att hjälpa till att hålla sakerna enkla, låt oss återanvända mycket av layouten från vår tidigare applikation:

Därefter öppnar du din strings.xml-fil och skapar en "proximity_sensor" -sträng. Återigen måste den här strängen innehålla en platshållare, som så småningom kommer att fyllas i med data som extraheras från närhetssensorn:

Närhetssensor Närhetsgivare:% 1 $ .2f Ingen närhetssensor tillgänglig

Hämta data från närhetssensorn

I likhet med ljusgivaren ger Android: s närhetssensor ett enda datavärde, vilket innebär att vi kan återanvända mycket av koden från vår tidigare applikation. Det finns dock några stora skillnader, plus några namnrelaterade ändringar som gör denna kod lättare att följa:

• Skapa en instans av SensorManager, som den här gången kommer jag att kalla "proximitySensorManager."
• Skaffa en instans av "proximitySensorManager."
• Skapa en referens till "proximityTextView."
• Ring metoden getDefaultSensor () och skicka den TYPE_PROXIMITY-sensorn.
• Registrera och avregistrera lyssnare för närhetssensorn.

När du har gjort dessa tweaks bör du sluta med följande:

importera 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; public class MainActivity utökar AppCompatActivity // Implementera SensorEventListener-gränssnittet // implementerar SensorEventListener {// Skapa dina variabler // privat Sensor proximitySensor; privat SensorManager proximitySensorManager; privat TextView proximityTextView; @Override skyddat tomrum onCreate (Bundle SavedInstanceState) {super.onCreate (SavedInstanceState); setContentView (R.layout.activity_main); proximityTextView = (TextView) findViewById (R.id.proximityTextView); // Skaffa en instans av SensorManager // proximitySensorManager = (SensorManager) getSystemService (Context.SENSOR_SERVICE); // Kontrollera om en närhetssensor // proximitySensor = proximitySensorManager.getDefaultSensor (Sensor.TYPE_PROXIMITY); // Om närhetssensorn inte existerar, visas ett fel // String sensor_error = getResources (). GetString (R.string.no_sensor); if (proximitySensor == null) {proximityTextView.setText (sensor_error); }} @Override skyddat tomrum onStart () {super.onStart (); // Om sensorn är tillgänglig på den aktuella enheten ... // if (proximitySensor! = Null) {//….men registrerar sedan en lyssnare // proximitySensorManager.registerListener (detta, proximitySensor, // Ange hur ofta du vill ta emot nya data // SensorManager.SENSOR_DELAY_NORMAL); }} @Override skyddat tomrum onStop () {super.onStop (); // Avregistrera din lyssnare för att bevara systemresurser // proximitySensorManager.unregisterListener (detta); } @Override public void onSensorChanged (SensorEvent sensorEvent) {// Sensorns aktuella värde // float currentValue = sensorEvent.values; // Hämta strängen "proximity_sensor", sätt in det nya värdet och uppdatera TextView // proximityTextView.setText (getResources (). GetString (R.string.proximity_sensor, currentValue)); } @Override // Om sensorns noggrannhet förändras ... .// public void onAccuracyChanged (Sensorsensor, int i) {//...TO DO //}}

Testning: Hur nära ligger användaren på sin enhet?

För att testa denna applikation på en fysisk Android-smartphone eller surfplatta, installerar du applikationen på din enhet och experimenterar sedan genom att flytta handen mot skärmen och sedan flytta den bort igen. Värdet "Närhetssensor" bör registrera dina rörelser.

Tänk bara på att närhetssensorer kan variera mellan enheter. Vissa enheter kanske bara visar två närhetsvärden - en för att indikera "Nära" och en för att indikera "Far" - så var inte förvånad om du inte ser mycket variation på din fysiska Android-enhet.

Så här testar du den här applikationen på en emulator:

• Installera din applikation på en AVD.
• Hitta den tre-prickade "More" -knappen och ge den ett klick som öppnar fönstret "Utökade kontroller".
• I fönstrets vänstra meny väljer du "virtuella sensorer."
• Välj fliken "Ytterligare sensorer".
• Hitta skjutreglaget "Närhet" och dra den åt vänster och höger för att emulera ett objekt som rör sig närmare enheten och sedan längre bort. Värdena för "Proximity Sensor" bör ändras när du manipulerar reglaget.

Du kan ladda ner det slutförda projektet från GitHub.

Rörelsessensorer: Bearbetar flerdimensionella matriser

Fram till denna tidpunkt har vi fokuserat på sensorer som tillhandahåller en enda datainformation, men det finns vissa sensorer som tillhandahåller flerdimensionella matriser för varje SensorEvent. Dessa flerdimensionella sensorer inkluderar rörelsessensorer, som vi kommer att fokusera på i det här sista avsnittet.

Rörelsessensorer kan hjälpa dig:

• Ge en alternativ metod för användarinmatning. Om du till exempel utvecklar ett mobilspel kan användaren flytta sin karaktär runt skärmen genom att luta sin enhet.
• Avsluta användaraktivitet. Om du har skapat en aktivitetsspårningsapp kan rörelsessensorer hjälpa dig att mäta om användaren reser i en bil, joggar eller sitter vid sitt skrivbord.
• Bestäm mer orientering.Det är möjligt att extrahera koordinater från en enhets rörelsessensorer och sedan översätta dem baserat på jordens koordinatsystem för att få den mest exakta insikten i enhetens nuvarande orientering.

I det sista avsnittet använder vi rotationsvektorsensorn (TYPE_ROTATION_VECTOR). Till skillnad från ljus- och närhetssensorerna är detta en mjukvarasensor som samlar data från enhetens accelerometer, magnetometer och gyroskopsensorer. Även om du ofta arbetar med den här sensorn kräver att du utför matematiska omvandlingar och omvandlingar, kan det också ge dig en rad mycket noggrann information om enheten.

Vi skapar en applikation som använder rotationsvektorsensorn för att mäta:

• Kasta. Detta är enhetens topp-till-botten lutning.
• Rulla. Detta är enhetens vänster till höger lutning.

Visar data i realtid tonhöjd och rullning

Eftersom vi mäter två mätvärden måste vi skapa två TextViews och två motsvarande strängresurser:

Öppna filen strings.xml och lägg till följande:

MotionSensors Pitch Sensor:% 1 $ .2f Rullsensor:% 1 $ .2f Ingen rörelsessensor tillgänglig

Använd rotationsvektorsensorn i din app

Vi kommer att återanvända en del av koden från våra tidigare applikationer, så låt oss fokusera på områden där kommunikation med rotationsvektorsensorn skiljer sig väsentligt från vad vi har sett tidigare.

1. Använd TYPE_ROTATION_VECTOR

Eftersom vi arbetar med rotationsvektorsensorn måste vi ringa metoden getDefaultSensor () och sedan skicka den till TYPE_ROTATION_VECTOR-konstanten:

positionSensorManager.getDefaultSensor (Sensor.TYPE_ROTATION_VECTOR);

2. Översätt sensordata

Till skillnad från de tidigare ljus- och närhetssensorerna returnerar rörelsessensorer flerdimensionella uppsättningar av sensorvärden för varje SensorEvent. Dessa värden formateras med hjälp av standard "X, Y, Z" -koordinatsystemet, som beräknas i förhållande till enheten när den hålls i sin standard, "naturliga" orientering.

Android växlar inte om dessa X-, Y- och Z-koordinater för att matcha enhetens nuvarande orientering, så att "X" -axeln förblir densamma oavsett om enheten är i stående eller liggande läge. När du använder rotationsvektorsensorn kan du behöva konvertera inkommande data för att matcha enhetens aktuella rotation.

Stående är standardorienteringen för de flesta smartphones, men du bör inte anta att detta kommer att vara fallet för Allt Android-enheter, särskilt surfplattor. I den här artikeln kommer vi att använda en rotationsmatris för att översätta sensorns data från dess original, anordning koordinatsystem, till jordens koordinatsystem, som representerar enhetens rörelse och position relativt jorden. Vid behov kan vi sedan ombilda sensordata, baserat på enhetens nuvarande orientering.

För det första är anordningskoordinatsystemet ett standard 3-axlat X, Y, Z-koordinatsystem, där varje punkt på var och en av de tre axlarna representeras av en 3D-vektor. Detta innebär att vi måste skapa en matris med 9 flottörvärden:

float rotationMatrix = new float;

Vi kan sedan överföra denna matris till metoden getRotationMatrix ():

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

Nästa steg är att använda metoden SensorManager.remapCoordinateSystem () för att omforma sensordata, baserat på enhetens nuvarande orientering.

Metoden SensorManager.remapCoordinateSystem () tar följande argument:

• Den ursprungliga rotationsmatrisen.
• Axlarna som du vill omforma.
• Matrisen som du fyller i med den här nya informationen.

Här är koden som jag kommer att använda i min app:

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

Slutligen kommer vi att ringa SensorManager.getOrientation och berätta för den att använda den justerade rotationsmatrisen:

SensorManager.getOrientation (justeradRotationMatrix, orientering);

3. Uppdatera platshållarens strängar

Eftersom vi har två uppsättningar data (tonhöjd och rullning) måste vi hämta två separata platshållarsträngar, fylla dem med rätt värden och sedan uppdatera motsvarande TextView:

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

Visa flera sensordata: Komplett kod

När du har utfört ovanstående steg bör din MainActivity se ut så här:

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; public class MainActivity utökar Aktivitetsredskap SensorEventListener {privat SensorManager motionSensorManager; privat Sensor motion Sensor; privat TextView pitchTextView; privat TextView-rollTextView; privat statisk slutlig int SENSOR_DELAY = 500 * 1000; privat statisk sista int FROM_RADS_TO_DEGS = -57; @Override skyddat tomrum onCreate (Bundle SavedInstanceState) {super.onCreate (SavedInstanceState); setContentView (R.layout.activity_main); pitchTextView = (TextView) findViewById (R.id.pitchTextView); rollTextView = (TextView) findViewById (R.id.rollTextView); prova {motionSensorManager = (SensorManager) getSystemService (Activity.SENSOR_SERVICE); motionSensor = motionSensorManager.getDefaultSensor (Sensor.TYPE_ROTATION_VECTOR); motionSensorManager.registerListener (detta, motionSensor, SENSOR_DELAY); } fånga (undantag e) {pitchTextView.setText (R.string.no_sensor); rollTextView.setText (R.string.no_sensor); }} @Override public void onAccuracyChanged (Sensorsensor, int-noggrannhet) {// Att göra //} @Override public void onSensorChanged (SensorEvent-händelse) {if (event.sensor == motionSensor) {update (event.values); }} privat tomtuppdatering (floatvektorer) {// Beräkna rotationsmatrisen // float rotationMatrix = new float; SensorManager.getRotationMatrixFromVector (rotationMatrix, vektorer); int worldAxisX = SensorManager.AXIS_X; int worldAxisZ = SensorManager.AXIS_Z; // Byt om matrisen baserad på Aktivitetens nuvarande orientering // float adjustRotationMatrix = new float; SensorManager.remapCoordinateSystem (rotationMatrix, worldAxisX, worldAxisZ, justeradRotationMatrix); // Beräkna enhetsorienteringen // floatorientering = ny flottör; // Leverera matrisen med floatvärden till metoden getOrientation () // SensorManager.getOrientation (justeradRotationMatrix, orientering); float tonhöjd = orientering * FROM_RADS_TO_DEGS; flottörrulle = orientering * FROM_RADS_TO_DEGS; // Uppdatera TextViews med tonhöjds- och rullvärden // pitchTextView.setText (getResources (). GetString (R.string.pitch_sensor, pitch)); rollTextView.setText (getResources (). getString (R.string.roll_sensor, roll)); }}

Du kan ladda ner det slutförda projektet från GitHub.

Testar vår slutliga Android-sensorapplikation

För att testa denna rotationsvektor Android-sensorapp på en fysisk Android-smartphone eller surfplatta:

• Installera applikationen på din enhet.
• Placera din smartphone eller surfplatta på en plan yta. Observera att rörelsessensorer är extremt känsliga, så det är inte ovanligt att en till synes rörelsesfri enhet rapporterar fluktuationer i tonhöjds- och rullvärden.
• För att testa tonhöjden lyfter du botten på din enhet så att den lutar bort från dig. Tonhöjdsvärdet bör förändras dramatiskt.
• För att testa rullen, försök att lyfta vänster sida av din enhet så att den lutar åt vänster - håll ett öga på det rullvärdet!

Om du testar ditt projekt på en emulator:

• Installera applikationen på din AVD.
• Välj "Mer" som öppnar fönstret "Utökade kontroller".
• I menyn till vänster väljer du "Virtuella sensorer."
• Se till att fliken "Accelerometer" är vald. Den här fliken innehåller kontroller som kan simulera ändringar i enhetens position och riktning.
• Prova att experimentera med de olika skjutreglagen (Rotera: Z-Rot, X-Rot, Y-Rot; och Move: X, Y och Z) och de olika "Device Rotation" -knapparna, för att se hur de påverkar applikationens "Roll Sensor" ”Och” Pitch Sensor ”-värden.

Avslutar

I den här artikeln såg vi hur man hämtar data från de tre huvudkategorierna för Android-sensorer: miljö, position och rörelse och hur man övervakar dessa data i realtid.

Har du sett några Android-appar som använder sensorer på intressanta eller unika sätt? Låt oss veta i kommentarerna nedan!