Inhoud

• Welke Android-sensoren kan ik gebruiken?
• Omgevingssensoren: omgevingslicht meten
• Uw sensorgegevens weergeven
• Communiceren met een sensor: SensorManager, SensorEvents en luisteraars
• 1. Verkrijg een exemplaar van SensorManager
• 2. Krijg een verwijzing naar lightTextView
• 3. Controleer of de sensor aanwezig is op het huidige apparaat
• 4. Registreer uw sensorluisteraars
• 5. Implementeer de SensorEventListener-callbacks
• onSensorChanged ()
• onAccuracyChanged ()
• 6. Haal de sensorwaarde op
• 7. Maak de registratie van uw luisteraars ongedaan
• De lichtsensoren van Android gebruiken: voltooide code
• Test uw voltooide Android-sensor-app
• Afstand meten met de naderingssensoren van Android
• Aanmaken van de gebruikersinterface
• Gegevens ophalen van de naderingssensor
• Testen: hoe dicht is de gebruiker bij zijn apparaat?
• Bewegingssensoren: multidimensionale arrays verwerken
• Real-time pitch- en roll-gegevens weergeven
• De rotatievectorsensor in uw app gebruiken
• 1. Gebruik de TYPE_ROTATION_VECTOR
• 2. Vertaal de sensorgegevens
• 3. Werk de plaatsaanduidingsstrings bij
• Meerdere sensorgegevens weergeven: voltooide code
• Onze laatste Android-sensortoepassing testen
• Afsluiten

Tegenwoordig zijn de meeste moderne Android-apparaten uitgerust met een aantal sensoren.

U kunt deze informatie op veel verschillende manieren gebruiken - of het nu lichtniveaus bewaken, zodat uw toepassing automatisch de helderheid of het kleurenschema kan aanpassen; waardoor de gebruiker met uw mobiele spel kan communiceren met behulp van gebaren zoals het kantelen van hun apparaat; of de nabijheidssensor gebruiken om aanraakgebeurtenissen automatisch uit te schakelen wanneer de gebruiker zijn apparaat tegen zijn oor houdt.

In dit artikel maken we drie applicaties die licht-, nabijheids- en bewegingsgegevens ophalen uit een reeks hardware- en softwaresensoren. We zullen deze Android-sensoren ook in realtime volgen, zodat uw applicatie altijd toegang heeft tot de nieuwste informatie.

Aan het einde van dit artikel weet u hoe u een enkel stuk gegevens uit een Android-sensor kunt extraheren en hoe u kunt omgaan met sensoren die hun gegevens in de vorm van een multidimensionale array leveren.

Welke Android-sensoren kan ik gebruiken?

Android-sensoren kunnen worden onderverdeeld in de volgende categorieën:

• Omgevingssensoren. Deze meten omgevingscondities, zoals luchttemperatuur, druk, vochtigheid en omgevingslichtniveaus.

• Positie sensoren. Deze categorie omvat sensoren die de fysieke positie van het apparaat meten, zoals naderingssensoren en geomagnetische veldsensoren.
  Bewegingssensoren. Deze sensoren meten de beweging van het apparaat en omvatten versnellingsmeters, zwaartekrachtsensoren, gyroscopen en rotatievectorsensoren.

Bovendien kunnen sensoren zijn:

• Hardware gebaseerd. Dit zijn fysieke componenten die in het apparaat zijn ingebouwd en die direct specifieke eigenschappen meten, zoals versnelling of de sterkte van de omringende geomagnetische velden.
• Op software gebaseerd, ook wel virtuele sensoren of samengestelde sensoren genoemd. Deze verzamelen meestal gegevens van meerdere op hardware gebaseerde sensoren. Tegen het einde van dit artikel werken we met de rotatievectorsensor, een softwaresensor die gegevens combineert van de versnellingsmeter, magnetometer en gyroscoop van het apparaat.

Omgevingssensoren: omgevingslicht meten

De lichtsensor van Android meet omgevingslicht in "lux" -eenheden, de lichtintensiteit zoals waargenomen door het menselijk oog. De luxwaarde die door een sensor wordt gemeld, kan per apparaat verschillen, dus als uw toepassing consistente waarden vereist, moet u mogelijk de onbewerkte gegevens manipuleren voordat u deze in uw toepassing gebruikt.

In dit gedeelte gaan we een applicatie maken die de huidige luxwaarde van de lichtsensor van het apparaat ophaalt, deze in een TextView weergeeft en vervolgens de TextView bijwerkt wanneer nieuwe gegevens beschikbaar komen.U kunt deze informatie vervolgens in verschillende apps gebruiken. U kunt bijvoorbeeld een fakkeltoepassing maken die informatie van de lichtsensor haalt en vervolgens automatisch de sterkte van de straal aanpassen op basis van de huidige lichtniveaus.

Maak een nieuw Android-project met de instellingen van uw keuze, en laten we beginnen!

Uw sensorgegevens weergeven

Ik ga een TextView toevoegen die uiteindelijk de gegevens weergeeft die we uit de lichtsensor hebben gehaald. Deze TextView wordt bijgewerkt wanneer nieuwe gegevens beschikbaar komen, zodat de gebruiker altijd toegang heeft tot de nieuwste informatie.

Open het bestand activity_main.xml van uw project en voeg het volgende toe:

Vervolgens moeten we de stringbron "light_sensor" maken waarnaar in onze lay-out wordt verwezen. Open het bestand strings.xml van uw project en voeg het volgende toe:

Lichtsensor:% 1 $ .2f

De "% 1 $ .2f" is een tijdelijke aanduiding die de informatie opgeeft die we willen weergeven en hoe deze moet worden opgemaakt:

• %1. U kunt meerdere tijdelijke aanduidingen in dezelfde tekenreeksresource invoegen; % 1 geeft aan dat we één tijdelijke aanduiding gebruiken.
• $.2. Dit specificeert hoe onze applicatie elke inkomende floating-point-waarde moet opmaken. De "$ .2" geeft aan dat de waarde moet worden afgerond op twee decimalen.
• F. Maak de waarde op als een getal met drijvende komma.

Hoewel sommige sensoren vaker voorkomen dan andere, moet u er nooit van uitgaan dat elk apparaat toegang heeft tot exact dezelfde hardware en software. De beschikbaarheid van sensoren kan zelfs variëren tussen verschillende versies van Android, omdat sommige sensoren pas werden geïntroduceerd tot latere releases van het Android-platform.

U kunt controleren of een bepaalde sensor aanwezig is op een apparaat, met behulp van het Android-sensorraamwerk. U kunt vervolgens delen van uw toepassing uitschakelen of inschakelen op basis van de beschikbaarheid van de sensor, of u kunt een verklaring weergeven dat sommige functies van uw toepassing niet werken zoals verwacht.

Terwijl we ons bestand strings.xml open hebben, laten we een "no_sensor" -reeks maken, die we weergeven als de lichtsensor niet beschikbaar is:

Geen lichtsensor beschikbaar

Als uw toepassing geen goede gebruikerservaring kan bieden zonder toegang te hebben tot een bepaalde sensor, moet u deze informatie toevoegen aan uw Manifest. Als uw app bijvoorbeeld toegang tot een kompassensor vereist, kunt u het volgende gebruiken:

Nu kan uw app alleen worden gedownload naar apparaten met een kompassensor.

Hoewel dit je publiek kan beperken, is het veel minder schadelijk dan iemand toe te staan ​​om je applicatie te downloaden wanneer deze dat is gegarandeerd om een ​​slechte ervaring te hebben, vanwege de sensorconfiguratie van hun apparaat.

Communiceren met een sensor: SensorManager, SensorEvents en luisteraars

Om te communiceren met de lichtsensor van het apparaat, moet u de volgende stappen uitvoeren:

1. Verkrijg een exemplaar van SensorManager

De SensorManager biedt alle methoden die u nodig hebt om toegang te krijgen tot de volledige reeks sensoren van het apparaat.

Maak om te beginnen een variabele met een exemplaar van SensorManager:

privé SensorManager lightSensorManager;

Vervolgens moet u een exemplaar van SensorManager verkrijgen door de methode Context.getSystemService aan te roepen en het argument Context.SENSOR_SERVICE door te geven:

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

2. Krijg een verwijzing naar lightTextView

Vervolgens moeten we een privé-lidvariabele maken die onze TextView-objecten bevat en deze toewijzen aan onze TextView:

privé TextView lightTextView; ... ... ... lightTextView = (TextView) findViewById (R.id.lightTextView);

3. Controleer of de sensor aanwezig is op het huidige apparaat

U kunt toegang krijgen tot een bepaalde sensor door de methode getDefaultSensor () aan te roepen en deze vervolgens door te geven aan de sensor in kwestie. De typeconstante voor de lichtsensor is TYPE_LIGHT, dus we moeten het volgende gebruiken:

lightSensor = lightSensorManager.getDefaultSensor (Sensor.TYPE_LIGHT);

Als de sensor niet op dit apparaat bestaat, retourneert de methode getDefaultSensor () null en wordt de tekenreeks 'no_sensor' weergegeven:

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

4. Registreer uw sensorluisteraars

Telkens wanneer een sensor nieuwe gegevens heeft, genereert Android een SensorEvent-object. Dit SensorEvent-object bevat de sensor die de gebeurtenis heeft gegenereerd, een tijdstempel en de nieuwe gegevenswaarde.

In eerste instantie zullen we ons concentreren op de licht- en nabijheidssensoren, die een enkel stuk gegevens retourneren. Sommige sensoren bieden echter multidimensionale arrays voor elke SensorEvent, inclusief de rotatievectorsensor, die we tegen het einde van dit artikel zullen onderzoeken.

Om ervoor te zorgen dat onze toepassing op de hoogte wordt gesteld van deze SensorEvent-objecten, moeten we een luisteraar registreren voor die specifieke sensorgebeurtenis met behulp van de registerListener () van SensorManager.

De methode registerListener () heeft de volgende argumenten:

• Een app of activiteitscontext.
• Het type sensor dat u wilt controleren.
• De snelheid waarmee de sensor nieuwe gegevens moet verzenden. Een hogere snelheid zal uw toepassing van meer gegevens voorzien, maar het zal ook meer systeembronnen gebruiken, met name de levensduur van de batterij. Om de batterij van het apparaat te sparen, moet u de minimale hoeveelheid gegevens opvragen die uw app vereist. Ik ga SensorManager.SENSOR_DELAY_NORMAL gebruiken, die elke 200.000 microseconden (0,2 seconden) nieuwe gegevens verzendt.

Omdat het luisteren naar een sensor de batterij van het apparaat leeg maakt, moet u luisteraars nooit registreren in de methode onCreate () van uw toepassing, omdat de sensoren hierdoor gegevens blijven verzenden, zelfs wanneer uw toepassing op de achtergrond staat.

In plaats daarvan moet u uw sensoren registreren in de levenscyclusmethode van de toepassing onStart ():

@Override beveiligde ongeldig onStart () {super.onStart (); // Als de sensor beschikbaar is op het huidige apparaat ... // if (lightSensor! = Null) {//…. Begin dan te luisteren // lightSensorManager.registerListener (this, lightSensor, SensorManager.SENSOR_DELAY_NORMAL); }}

5. Implementeer de SensorEventListener-callbacks

SensorEventListener is een interface die meldingen ontvangt van de SensorManager
wanneer er nieuwe gegevens beschikbaar zijn of de nauwkeurigheid van de sensor verandert.

De eerste stap is het wijzigen van onze klassesignatuur om de SensorEventListener-interface te implementeren:

openbare klasse MainActivity breidt AppCompatActivity implementeert SensorEventListener {

Vervolgens moeten we de volgende callback-methoden implementeren:

onSensorChanged ()

Deze methode wordt opgeroepen als reactie op elke nieuwe SensorEvent.

Sensorgegevens kunnen vaak snel veranderen, dus uw toepassing roept mogelijk regelmatig de methode onSensorChanged () aan. Om ervoor te zorgen dat uw toepassing soepel blijft werken, moet u zo weinig mogelijk werk uitvoeren binnen de methode onSensorChanged ().

@Override public void onSensorChanged (SensorEvent sensorEvent) {// To do //}

onAccuracyChanged ()

Als de nauwkeurigheid van de sensor verbetert of daalt, roept Android de methode onAccuracyChanged () aan en geeft deze een sensorobject met de nieuwe nauwkeurigheidswaarde, zoals SENSOR_STATUS_UNRELIABLE of SENSOR_STATUS_ACCURACY_HIGH.

De lichtsensor rapporteert geen nauwkeurigheidsveranderingen, dus laat ik de call onAccuracyChanged () leeg:

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

6. Haal de sensorwaarde op

Wanneer we een nieuwe waarde hebben, moeten we de methode onSensorChanged () aanroepen en de tekenreeks 'light_sensor' ophalen. We kunnen vervolgens de plaatsaanduidingstekst van de string overschrijven (% 1 $ .2f) en de bijgewerkte string weergeven als onderdeel van onze TextView:

@Override public void onSensorChanged (SensorEvent sensorEvent) {// De huidige waarde van de sensor // float currentValue = sensorEvent.values; // Haal de string “light_sensor” op, voer de nieuwe waarde in en geef deze aan de gebruiker // lightTextView.setText (getResources (). GetString (R.string.light_sensor, currentValue)); }

7. Maak de registratie van uw luisteraars ongedaan

Sensoren kunnen in een korte tijd grote hoeveelheden gegevens genereren, dus om de bronnen van het apparaat te behouden, moet u uw luisteraars afmelden wanneer ze niet langer nodig zijn.

Als u wilt stoppen met luisteren naar sensorgebeurtenissen wanneer uw toepassing op de achtergrond staat, voegt u unregisterListener () toe aan de levenscyclusmethode onStop () van uw project:

@Override beschermde ongeldig onStop () {super.onStop (); lightSensorManager.unregisterListener (deze); }

Houd er rekening mee dat u uw luisteraars niet moet afmelden in onPause (), omdat applicaties in Android 7.0 en hoger kunnen worden uitgevoerd in split-screen en picture-in-picture-modus, waarbij ze in de pauzestand staan, maar zichtbaar blijven op het scherm.

De lichtsensoren van Android gebruiken: voltooide code

Na het voltooien van alle bovenstaande stappen zou de MainActivity van uw project er ongeveer zo uit moeten zien:

android.support.v7.app.AppCompatActivity importeren; android.os.bundle importeren; android.content.Context importeren; android.hardware.Sensor importeren; android.hardware.SensorEvent importeren; android.hardware.SensorEventListener importeren; android.hardware.SensorManager importeren; android.widget.TextView importeren; public class MainActivity breidt AppCompatActivity // Implementeer de SensorEventListener-interface // implementeert SensorEventListener {// Maak uw variabelen // private Sensor lightSensor; privé SensorManager lightSensorManager; privé TextView lightTextView; @Override beschermde nietig onCreate (bundle saveInstanceState) {super.onCreate (saveInstanceState); setContentView (R.layout.activity_main); lightTextView = (TextView) findViewById (R.id.lightTextView); // Krijg een exemplaar van SensorManager // lightSensorManager = (SensorManager) getSystemService (Context.SENSOR_SERVICE); // Controleer op een lichtsensor // lightSensor = lightSensorManager.getDefaultSensor (Sensor.TYPE_LIGHT); // Als de lichtsensor niet bestaat, geeft u een fout weer // String sensor_error = getResources (). GetString (R.string.no_sensor); if (lightSensor == null) {lightTextView.setText (sensor_error); }} @Override beveiligde ongeldig onStart () {super.onStart (); // Als de sensor beschikbaar is op het huidige apparaat ... // if (lightSensor! = Null) {//…. Registreer dan een luisteraar // lightSensorManager.registerListener (this, lightSensor, // Specificeer hoe vaak u wilt nieuwe gegevens ontvangen // SensorManager.SENSOR_DELAY_NORMAL); }} @Override beschermde ongeldig onStop () {super.onStop (); // Meld uw luisteraar af // lightSensorManager.unregisterListener (this); } @Override public void onSensorChanged (SensorEvent sensorEvent) {// De huidige waarde van de sensor // float currentValue = sensorEvent.values; // Haal de tekenreeks “light_sensor” op, voer de nieuwe waarde in en werk de TextView // lightTextView.setText (getResources (). GetString (R.string.light_sensor, currentValue) bij); } @Override // Als de nauwkeurigheid van de sensor verandert ... .// publiekelijk ongeldig op AccuracyChanged (Sensor sensor, int i) {// TO DO //}}

Test uw voltooide Android-sensor-app

Om deze applicatie te testen op een fysieke Android-smartphone of -tablet:

• Installeer het project op uw apparaat (door "Uitvoeren> Uitvoeren" te selecteren op de werkbalk van Android Studio).
• Hoewel het tussen apparaten varieert, bevindt de lichtsensor zich vaak rechtsboven op het scherm. Als u de lichtniveaus wilt manipuleren, plaatst u uw apparaat dichter bij en vervolgens verder weg van een lichtbron. U kunt ook proberen het apparaat met uw hand te bedekken om het licht te blokkeren. De waarde "Lichtsensor" moet toenemen en afnemen, afhankelijk van de beschikbare hoeveelheid licht.

Als u een Android Virtual Device (AVD) gebruikt, heeft de emulator een set virtuele sensorbesturingen die u kunt gebruiken om verschillende sensorgebeurtenissen te simuleren. U hebt toegang tot deze virtuele sensorbedieningen via het venster 'Uitgebreide bedieningselementen' van de emulator:

• Installeer de applicatie op uw AVD.
• Naast de AVD ziet u een strook knoppen. Zoek de knop met de drie punten "Meer" (waar de cursor in de volgende schermafbeelding staat) en klik erop. Hiermee wordt het venster "Uitgebreide bedieningselementen" geopend.

• Selecteer 'Virtuele sensoren' in het menu aan de linkerkant.
• Selecteer het tabblad "Extra sensoren". Dit tabblad bevat verschillende schuifregelaars die u kunt gebruiken om verschillende positie- en omgevingssensorgebeurtenissen te simuleren.

• Zoek de schuifregelaar "Licht (lux)" en sleep deze naar links en rechts om de gesimuleerde lichtniveaus te wijzigen. Uw toepassing moet deze veranderende waarden in realtime weergeven.

Je kunt het voltooide project downloaden van GitHub.

Afstand meten met de naderingssensoren van Android

Nu hebben we gezien hoe we informatie kunnen ophalen van een omgevingssensor, laten we eens kijken hoe u deze kennis op een positie sensor.

In dit gedeelte gebruiken we de naderingssensor van het apparaat om de afstand tussen uw smartphone of tablet en andere objecten te controleren. Als uw toepassing enige spraakfunctionaliteit heeft, kan de nabijheidssensor u helpen bepalen wanneer de smartphone tegen het oor van de gebruiker wordt gehouden, bijvoorbeeld wanneer hij een telefoongesprek voert. U kunt deze informatie vervolgens gebruiken om aanraakgebeurtenissen uit te schakelen, zodat de gebruiker niet per ongeluk ophangt of andere ongewenste gebeurtenissen veroorzaakt tijdens een gesprek.

Aanmaken van de gebruikersinterface

Ik ga de naderingsgegevens op het scherm weergeven, zodat je deze in realtime kunt bekijken. Laten we, om dingen eenvoudig te houden, een groot deel van de lay-out van onze vorige applicatie hergebruiken:

Open vervolgens uw bestand strings.xml en maak een tekenreeks 'proximity_sensor'. Nogmaals, deze string moet een tijdelijke aanduiding bevatten, die uiteindelijk zal worden gevuld met gegevens die zijn geëxtraheerd uit de nabijheidssensor:

Nabijheids sensor Nabijheidssensor:% 1 $ .2f Geen nabijheidssensor beschikbaar

Gegevens ophalen van de naderingssensor

Net als de lichtsensor retourneert de naderingssensor van Android een enkele gegevenswaarde, wat betekent dat we veel van de code van onze vorige applicatie kunnen hergebruiken. Er zijn echter een paar belangrijke verschillen, plus enkele naamgerelateerde wijzigingen waardoor deze code gemakkelijker te volgen is:

• Maak een exemplaar van SensorManager, deze keer ga ik 'proximitySensorManager' noemen.
• Verkrijg een exemplaar van "proximitySensorManager."
• Maak een verwijzing naar de "proximityTextView."
• Roep de methode getDefaultSensor () aan en geef deze de TYPE_PROXIMITY-sensor door.
• Luisteraars registreren en afmelden voor de naderingssensor.

Nadat je deze tweaks hebt gemaakt, zou je het volgende moeten hebben:

android.support.v7.app.AppCompatActivity importeren; android.os.bundle importeren; android.content.Context importeren; android.hardware.Sensor importeren; android.hardware.SensorEvent importeren; android.hardware.SensorManager importeren; android.hardware.SensorEventListener importeren; android.widget.TextView importeren; public class MainActivity breidt AppCompatActivity // Implementeer de SensorEventListener-interface // implementeert SensorEventListener {// Maak uw variabelen // private Sensor proximitySensor; privé SensorManager proximitySensorManager; privé TextView proximityTextView; @Override beschermde nietig onCreate (bundle saveInstanceState) {super.onCreate (saveInstanceState); setContentView (R.layout.activity_main); proximityTextView = (TextView) findViewById (R.id.proximityTextView); // Krijg een exemplaar van SensorManager // proximitySensorManager = (SensorManager) getSystemService (Context.SENSOR_SERVICE); // Controleer op een nabijheidssensor // proximitySensor = proximitySensorManager.getDefaultSensor (Sensor.TYPE_PROXIMITY); // Als de nabijheidssensor niet bestaat, geeft u een fout weer // String sensor_error = getResources (). GetString (R.string.no_sensor); if (proximitySensor == null) {proximityTextView.setText (sensor_error); }} @Override beveiligde ongeldig onStart () {super.onStart (); // Als de sensor beschikbaar is op het huidige apparaat ... // if (proximitySensor! = Null) {//…. Registreer dan een luisteraar // proximitySensorManager.registerListener (this, proximitySensor, // Specificeer hoe vaak u wilt nieuwe gegevens ontvangen // SensorManager.SENSOR_DELAY_NORMAL); }} @Override beschermde ongeldig onStop () {super.onStop (); // Maak de registratie van uw luisteraar ongedaan om systeembronnen te behouden // proximitySensorManager.unregisterListener (this); } @Override public void onSensorChanged (SensorEvent sensorEvent) {// De huidige waarde van de sensor // float currentValue = sensorEvent.values; // Haal de tekenreeks “proximity_sensor” op, voer de nieuwe waarde in en werk de TextView // proximityTextView.setText bij (getResources (). GetString (R.string.proximity_sensor, currentValue)); } @Override // Als de nauwkeurigheid van de sensor verandert ... .// publieke leegte op AccuracyChanged (Sensor sensor, int i) {//...TO DO //}}

Testen: hoe dicht is de gebruiker bij zijn apparaat?

Als u deze applicatie op een fysieke Android-smartphone of -tablet wilt testen, installeert u de applicatie op uw apparaat en experimenteert u door uw hand naar het scherm te bewegen en vervolgens weer weg te bewegen. De waarde "Nabijheidssensor" moet uw bewegingen registreren.

Houd er rekening mee dat naderingssensoren tussen apparaten kunnen variëren. Sommige apparaten kunnen slechts twee nabijheidswaarden weergeven - één om "Near" aan te geven en één om "Far" aan te duiden - dus wees niet verbaasd als u niet veel variatie ziet op uw fysieke Android-apparaat.

Om deze applicatie op een emulator te testen:

• Installeer uw applicatie op een AVD.
• Zoek de knop "Meer" met drie punten en klik erop, waarmee het venster "Uitgebreide bedieningselementen" wordt geopend.
• Selecteer 'Virtuele sensoren' in het linkermenu van het venster.
• Selecteer het tabblad "Extra sensoren".
• Zoek de schuifregelaar 'Nabijheid' en sleep deze naar links en rechts om een ​​object te emuleren dat dichter bij het apparaat komt en vervolgens verder weg. De waarden van de "Nabijheidssensor" moeten veranderen terwijl u de schuifregelaar manipuleert.

Je kunt het voltooide project downloaden van GitHub.

Bewegingssensoren: multidimensionale arrays verwerken

Tot dit punt hebben we ons gericht op sensoren die een enkel gegevensitem leveren, maar er zijn enkele sensoren die multidimensionale arrays bieden voor elke SensorEvent. Deze multidimensionale sensoren omvatten bewegingssensoren, waarop we ons in dit laatste deel zullen concentreren.

Bewegingssensoren kunnen u helpen:

• Bied een alternatieve methode voor gebruikersinvoer. Als u bijvoorbeeld een mobiele game ontwikkelt, kan de gebruiker zijn personage over het scherm verplaatsen door zijn apparaat te kantelen.
• Gebruikersactiviteit afleiden. Als je een app voor het volgen van activiteiten hebt gemaakt, kunnen bewegingssensoren je helpen te bepalen of de gebruiker in een auto reist, jogt of aan zijn bureau zit.
• Nauwkeuriger de oriëntatie bepalen.Het is mogelijk om coördinaten te extraheren uit de bewegingssensoren van een apparaat en deze vervolgens te vertalen op basis van het coördinatensysteem van de aarde, om het meest nauwkeurige inzicht te krijgen in de huidige oriëntatie van het apparaat.

In dit laatste gedeelte gebruiken we de rotatievectorsensor (TYPE_ROTATION_VECTOR). In tegenstelling tot de licht- en nabijheidssensoren is dit een softwaresensor die gegevens verzamelt van de versnellingsmeter, magnetometer en gyroscoopsensor van het apparaat. Hoewel het werken met deze sensor vaak vereist dat u wiskundige conversies en transformaties uitvoert, kan het u ook een reeks zeer nauwkeurige informatie over het apparaat bieden.

We gaan een applicatie maken die de rotatievectorsensor gebruikt om te meten:

• Pitch. Dit is de kanteling van boven naar beneden van het apparaat.
• Rollen. Dit is de kanteling van links naar rechts van het apparaat.

Real-time pitch- en roll-gegevens weergeven

Omdat we twee statistieken meten, moeten we twee TextViews en twee bijbehorende tekenreeksbronnen maken:

Open het bestand strings.xml en voeg het volgende toe:

bewegings detectoren Pitch-sensor:% 1 $ .2f Rollensensor:% 1 $ .2f Geen bewegingssensor beschikbaar

De rotatievectorsensor in uw app gebruiken

We zullen een deel van de code van onze vorige applicaties opnieuw gebruiken, dus laten we ons concentreren op de gebieden waar communicatie met de rotatievectorsensor aanzienlijk verschilt van wat we eerder hebben gezien.

1. Gebruik de TYPE_ROTATION_VECTOR

Omdat we met de rotatievectorsensor werken, moeten we de methode getDefaultSensor () aanroepen en deze vervolgens de constante TYPE_ROTATION_VECTOR doorgeven:

positionSensorManager.getDefaultSensor (Sensor.TYPE_ROTATION_VECTOR);

2. Vertaal de sensorgegevens

In tegenstelling tot de vorige licht- en nabijheidssensoren retourneren bewegingssensoren multidimensionale reeksen sensorwaarden voor elke SensorEvent. Deze waarden worden opgemaakt met behulp van het standaard "X, Y, Z" coördinatensysteem, dat wordt berekend ten opzichte van het apparaat wanneer het in de standaard "natuurlijke" oriëntatie wordt gehouden.

Android schakelt deze X-, Y- en Z-coördinaten niet om zodat deze overeenkomen met de huidige oriëntatie van het apparaat, dus de "X" -as blijft hetzelfde, ongeacht of het apparaat zich in de staande of liggende modus bevindt. Wanneer u de rotatievectorsensor gebruikt, moet u mogelijk de inkomende gegevens omzetten in overeenstemming met de huidige rotatie van het apparaat.

Portret is de standaardoriëntatie voor de meeste smartphones, maar u moet er niet vanuit gaan dat dit het geval zal zijn alle Android-apparaten, met name tablets. In dit artikel gebruiken we een rotatiematrix om de gegevens van de sensor te vertalen van zijn oorspronkelijke, apparaat coördinatensysteem, naar de aarde coördinatensysteem, dat de beweging en positie van het apparaat ten opzichte van de aarde weergeeft. Indien nodig kunnen we de sensorgegevens opnieuw toewijzen op basis van de huidige oriëntatie van het apparaat.

Ten eerste is het apparaatcoördinatensysteem een ​​standaard 3-assen X, Y, Z coördinatensysteem, waarbij elk punt op elk van de drie assen wordt voorgesteld door een 3D-vector. Dit betekent dat we een reeks van 9 floatwaarden moeten maken:

float rotatieMatrix = nieuwe float;

We kunnen deze array vervolgens doorgeven aan de methode getRotationMatrix ():

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

De volgende stap is het gebruik van de methode SensorManager.remapCoordinateSystem () om de sensorgegevens opnieuw toe te wijzen op basis van de huidige oriëntatie van het apparaat.

De methode SensorManager.remapCoordinateSystem () heeft de volgende argumenten:

• De originele rotatiematrix.
• De assen die u opnieuw wilt toewijzen.
• De array die u vult met deze nieuwe gegevens.

Hier is de code die ik in mijn app ga gebruiken:

float aangepastRotationMatrix = nieuwe float; SensorManager.remapCoordinateSystem (rotationMatrix, worldAxisX, worldAxisZ, adjustRotationMatrix);

Ten slotte zullen we SensorManager.getOrientation aanroepen en vertellen dat het de aangepaste RotationMatrix moet gebruiken:

SensorManager.getOrientation (aangepaste rotatiematrix, oriëntatie);

3. Werk de plaatsaanduidingsstrings bij

Omdat we twee gegevenssets hebben (pitch and roll), moeten we twee afzonderlijke plaatsaanduidingsstrings ophalen, deze vullen met de juiste waarden en vervolgens de bijbehorende TextView bijwerken:

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

Meerdere sensorgegevens weergeven: voltooide code

Na het uitvoeren van de bovenstaande stappen zou uw MainActivity er ongeveer zo uit moeten zien:

android.app.Activity importeren; android.os.bundle importeren; android.hardware.Sensor importeren; android.hardware.SensorEvent importeren; android.hardware.SensorEventListener importeren; android.hardware.SensorManager importeren; android.widget.TextView importeren; openbare klasse MainActivity breidt activiteit implementeert SensorEventListener {private SensorManager motionSensorManager; privé Sensor motionSensor; privé TextView pitchTextView; privé TextView rollTextView; privé statische finale int SENSOR_DELAY = 500 * 1000; private statische finale int FROM_RADS_TO_DEGS = -57; @Override beschermde nietig onCreate (bundle saveInstanceState) {super.onCreate (saveInstanceState); setContentView (R.layout.activity_main); pitchTextView = (TextView) findViewById (R.id.pitchTextView); rollTextView = (TextView) findViewById (R.id.rollTextView); probeer {motionSensorManager = (SensorManager) getSystemService (Activity.SENSOR_SERVICE); motionSensor = motionSensorManager.getDefaultSensor (Sensor.TYPE_ROTATION_VECTOR); motionSensorManager.registerListener (this, motionSensor, SENSOR_DELAY); } catch (uitzondering e) {pitchTextView.setText (R.string.no_sensor); rollTextView.setText (R.string.no_sensor); }} @Override public void onAccuracyChanged (Sensor sensor, int nauwkeurigheid) {// To do //} @Override public void onSensorChanged (SensorEvent event) {if (event.sensor == motionSensor) {update (event.values); }} privé-void-update (floatvectoren) {// Bereken de rotatiematrix // float rotationMatrix = nieuwe float; SensorManager.getRotationMatrixFromVector (rotationMatrix, vectoren); int worldAxisX = SensorManager.AXIS_X; int worldAxisZ = SensorManager.AXIS_Z; // Wijs de matrix opnieuw toe op basis van de huidige oriëntatie van de activiteit // float aangepastRotationMatrix = nieuwe float; SensorManager.remapCoordinateSystem (rotationMatrix, worldAxisX, worldAxisZ, adjustRotationMatrix); // Bereken de oriëntatie van de apparaten // float-oriëntatie = nieuwe float; // Geef de array met floatwaarden aan de methode getOrientation () // SensorManager.getOrientation (adjustRotationMatrix, orientatie); zweefhoogte = oriëntatie * FROM_RADS_TO_DEGS; vlotterrol = oriëntatie * FROM_RADS_TO_DEGS; // Update de TextViews met de pitch- en roll-waarden // pitchTextView.setText (getResources (). GetString (R.string.pitch_sensor, pitch)); rollTextView.setText (getResources (). getString (R.string.roll_sensor, roll)); }}

Je kunt het voltooide project downloaden van GitHub.

Onze laatste Android-sensortoepassing testen

Om deze rotatie vector Android-sensor-app te testen op een fysieke Android-smartphone of -tablet:

• Installeer de applicatie op uw apparaat.
• Plaats uw smartphone of tablet op een vlakke ondergrond. Merk op dat bewegingssensoren extreem gevoelig zijn, dus het is niet ongebruikelijk dat een schijnbaar bewegingsloos apparaat schommelingen in toonhoogte en rolwaarden meldt.
• Til de onderkant van uw apparaat op, zodat deze van u kantelt om de toonhoogte te testen. De toonhoogte waarde moet drastisch veranderen.
• Om de rol te testen, probeer de linkerkant van uw apparaat op te tillen, zodat deze naar links kantelt - houd die rolwaarde in de gaten!

Als u uw project test op een emulator:

• Installeer de applicatie op uw AVD.
• Selecteer "Meer", waarmee het venster "Uitgebreide bedieningselementen" wordt geopend.
• Selecteer 'Virtuele sensoren' in het menu aan de linkerkant.
• Zorg ervoor dat het tabblad 'Accelerometer' is geselecteerd. Dit tabblad bevat bedieningselementen die veranderingen in de positie en oriëntatie van het apparaat kunnen simuleren.
• Probeer eens te experimenteren met de verschillende schuifregelaars (Roteren: Z-Rot, X-Rot, Y-Rot; en Move: X, Y en Z) en de verschillende knoppen "Device Rotation" om te zien hoe ze de rolsensor van uw toepassing beïnvloeden "En" Pitch Sensor "waarden.

Afsluiten

In dit artikel hebben we gezien hoe we gegevens kunnen ophalen uit de drie hoofdcategorieën van Android-sensoren: omgeving, positie en beweging, en hoe we deze gegevens in realtime kunnen volgen.

Heb je Android-apps gezien die op interessante of unieke manieren sensoren gebruiken? Laat het ons weten in de reacties hieronder!