Tartalom

• Milyen Android-érzékelőket használhatom?
• Környezeti érzékelők: A környezeti fény mérése
• Az érzékelő adatainak megjelenítése
• Kommunikáció érzékelővel: SensorManager, SensorEvents és hallgatók
• 1. Szerezze be a SensorManager példányát
• 2. Kérjen hivatkozást a lightTextView-ra
• 3. Ellenőrizze, hogy az érzékelő létezik-e az aktuális eszközön
• 4. Regisztrálja érzékelő-hallgatóit
• 5. Végezzük el a SensorEventListener visszahívásokat
• onSensorChanged ()
• onAccuracyChanged ()
• 6. Keresse meg az érzékelő értékét
• 7. Törölje a hallgatók regisztrációját
• Az Android fényérzékelőinek használata: kitöltött kód
• Tesztelje a kész Android érzékelő alkalmazást
• Távolságmérés az Android közelségérzékelőivel
• A felhasználói felület létrehozása
• Adatok beolvasása a közelségérzékelőről
• Tesztelés: Mennyire közel van a felhasználó készülékéhez?
• Mozgásérzékelők: Többdimenziós tömbök feldolgozása
• Valós idejű hangmagasság és görgetési adatok megjelenítése
• A forgatásvektor-érzékelő használata az alkalmazásban
• 1. Használja a TYPE_ROTATION_VECTOR eszközt
• 2. Fordítsa le az érzékelő adatait
• 3. Frissítse a helyőrző karakterláncokat
• Több érzékelő adatainak megjelenítése: Kész kód
• Teszteljük a végső Android érzékelő alkalmazást
• Csomagolás

Manapság a legtöbb modern Android készülék egy csomó érzékelővel van felszerelve.

Ezt az információt sokféle módon felhasználhatja - függetlenül attól, hogy megfigyeli-e a fényszintet, hogy az alkalmazás automatikusan beállítsa a fényerőt vagy a színösszeállítást; lehetővé teszi a felhasználónak, hogy mozdulatokkal, például eszközük megdöntésével, kölcsönhatásba lépjen a mobil játékával; vagy a közelségérzékelő segítségével automatikusan letiltja az érintési eseményeket, amikor a felhasználó az eszközét a füléhez tartja.

Ebben a cikkben három alkalmazást hozunk létre, amelyek fény-, közelségi és mozgási adatokat vesznek fel számos hardver- és szoftverérzékelővel. Ezeket az Android-érzékelőket is valós időben figyeljük, tehát az alkalmazásod mindig hozzáférhet a legfrissebb információkhoz.

A cikk végére megtudhatja, hogyan lehet egyetlen adatot kinyerni egy Android-érzékelőből, és hogyan kell kezelni azokat az érzékelőket, amelyek adataikat többdimenziós tömb formájában szolgáltatják.

Milyen Android-érzékelőket használhatom?

Az Android érzékelőket a következő kategóriákba lehet osztani:

• Környezeti érzékelők. Ezek mérik a környezeti feltételeket, mint például a levegő hőmérséklete, nyomása, páratartalma és a környezeti fény szintje.

• Pozíció érzékelők. Ez a kategória magában foglalja azokat az érzékelőket, amelyek mérik az eszköz fizikai helyzetét, például közelségérzékelőket és geomágneses mező érzékelőket.
  Mozgásérzékelők. Ezek az érzékelők mérik az eszköz mozgását, és gyorsulásmérőket, gravitációs érzékelőket, giroszkópokat és forgásvektor-érzékelőket tartalmaznak.

Ezen felül az érzékelők lehetnek:

• Hardver alapú. Ezek olyan fizikai alkatrészek, amelyek be vannak építve az eszközbe, és közvetlenül mérik a meghatározott tulajdonságokat, például a gyorsulást vagy a környező geomágneses mezők erősségét.
• Szoftver alapú, néha virtuális érzékelőknek vagy összetett érzékelőknek nevezik. Ezek jellemzően több hardver alapú érzékelőből származó adatokat gyűjtenek. A cikk vége felé dolgozunk a forgatásvektor-érzékelővel, amely egy szoftverérzékelő, amely egyesíti az eszköz gyorsulásmérőjét, magnetométerét és giroszkópját.

Környezeti érzékelők: A környezeti fény mérése

Az Android fényérzékelője méri a környezeti fényt „lux” egységekben, azaz az emberi szem által érzékelt fényerősség. Az érzékelő által megadott lux érték eszközönként eltérő lehet, tehát ha az alkalmazás konzisztens értékeket igényel, akkor előfordulhat, hogy a nyers adatokat manipulálni kell, mielőtt felhasználnák azokat az alkalmazásban.

Ebben a szakaszban olyan alkalmazást fogunk létrehozni, amely lekérdezi az aktuális lux értéket az eszköz fényérzékelőjéről, megjeleníti azt egy TextView-ban, majd frissíti a TextView-t, amint új adatok elérhetővé válnak.Ezt az információt ezután számos alkalmazásban felhasználhatja, például létrehozhat egy fáklya alkalmazást, amely információt húz a fényérzékelőről, majd automatikusan beállítja a sugár erősségét az aktuális fényszint alapján.

Hozzon létre egy új Android projektet a választott beállításokkal, és kezdjük el!

Az érzékelő adatainak megjelenítése

Hozzáteszek egy TextView-t, amely végül megjeleníti azokat az adatokat, amelyeket a fényérzékelőből kivontunk. Ez a TextView frissül, amikor új adatok állnak rendelkezésre, így a felhasználó mindig hozzáférhet a legfrissebb információkhoz.

Nyissa meg a projekt aktiv_main.xml fájlját, és adja hozzá a következőket:

Ezután létre kell hoznunk a „light_sensor” karakterlánc-erőforrást, amelyre az elrendezésünk hivatkozik. Nyissa meg a projekt strings.xml fájlt, és adja hozzá a következőket:

Fényérzékelő:% 1 $ .2f

A „% 1 $ .2f” egy helyőrző, amely meghatározza a megjeleníteni kívánt információkat és annak formázását:

• %1. Több helyőrzőt beszúrhat ugyanabba a karakterlánc-erőforrásba; A „% 1” azt jelzi, hogy egyetlen helyőrzőt használunk.
• $.2. Ez meghatározza, hogy az alkalmazás miként formázza az egyes bejövő lebegőpontos értékeket. A „$ .2” azt jelzi, hogy az értéket két tizedesjegyre kell kerekíteni.
• F. Formázza az értéket lebegőpontos számként.

Bár egyes érzékelők gyakoribbak, mint mások, soha nem szabad azt feltételezni, hogy minden eszköz hozzáfér ugyanahhoz a hardverhez és szoftverhez. Az érzékelők elérhetősége az Android különféle verzióiban is változhat, mivel néhány érzékelőt csak az Android platform későbbi kiadásaira vezettek be.

Az Android érzékelőkeret segítségével ellenőrizheti, hogy van-e egy adott érzékelő egy eszközön. Ezután az érzékelők rendelkezésre állása alapján letilthatja vagy engedélyezheti alkalmazásának részeit, vagy megjelenítheti azt, amely magyarázza, hogy az alkalmazás egyes funkciói nem fognak megfelelően működni.

Amíg nyitva van a strings.xml fájlunk, hozzunk létre egy „no_sensor” karakterláncot, amelyet akkor jelenítünk meg, ha a fényérzékelő nem érhető el:

Nincs fényérzékelő

Ha az alkalmazás nem nyújt jó felhasználói élményt anélkül, hogy hozzáférne egy adott érzékelőhöz, akkor ezeket az információkat hozzá kell tennie a manifeszthoz. Például, ha az alkalmazás hozzáférést igényel egy iránytű-érzékelőhöz, akkor a következőket használhatja:

Mostantól alkalmazását csak az iránytű-érzékelővel rendelkező eszközökre lehet letölteni.

Noha ez korlátozhatja a közönséget, ez sokkal kevésbé káros, mint ha valaki letöltheti az alkalmazását, amikor van garantált rossz tapasztalattal rendelkezik az eszköz érzékelő konfigurációja miatt.

Kommunikáció érzékelővel: SensorManager, SensorEvents és hallgatók

Az eszköz fényérzékelőjével való kommunikációhoz a következő lépéseket kell végrehajtania:

1. Szerezze be a SensorManager példányát

A SensorManager biztosítja az összes szükséges módszert az eszköz teljes érzékelőinek eléréséhez.

A kezdéshez hozzon létre egy olyan változót, amely tartalmazza az SensorManager példányát:

privát SensorManager lightSensorManager;

Ezután be kell szereznie egy SensorManager példányt, hívva a Context.getSystemService metódust, és átadva a Context.SENSOR_SERVICE argumentumot:

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

2. Kérjen hivatkozást a lightTextView-ra

Ezután létre kell hoznunk egy privát tagváltozót, amely megtartja a TextView objektumokat, és hozzá kell rendelnünk azt a TextView elemhez:

privát TextView lightTextView; ... ... ... lightTextView = (TextView) findViewById (R.id.lightTextView);

3. Ellenőrizze, hogy az érzékelő létezik-e az aktuális eszközön

Hozzáférhet egy adott érzékelőhöz, ha meghívja a getDefaultSensor () metódust, majd átadja neki a kérdéses érzékelőt. A fényérzékelő típusállandója TYPE_LIGHT, tehát a következőket kell használnunk:

lightSensor = lightSensorManager.getDefaultSensor (Sensor.TYPE_LIGHT);

Ha az érzékelő nem létezik ezen az eszközön, akkor a getDefaultSensor () metódus null értéket eredményez, és megjelenik a „no_sensor” karakterlánc:

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

4. Regisztrálja érzékelő-hallgatóit

Minden alkalommal, amikor egy érzékelő új adatokkal rendelkezik, az Android létrehoz egy SensorEvent objektumot. Ez a SensorEvent objektum tartalmazza az eseményt előállító érzékelőt, az időbélyeget és az új adatértéket.

Kezdetben a fény- és közelségérzékelőkre összpontosítunk, amelyek egyetlen adatot szolgáltatnak vissza. Néhány érzékelő azonban többdimenziós tömböket biztosít minden SensorEventhez, ideértve a forgatásvektor-érzékelőt is, amelyet a cikk vége felé vizsgálunk meg.

Annak biztosítása érdekében, hogy alkalmazásunk értesüljön ezekről a SensorEvent objektumokról, regisztrálnunk kell egy hallgatót az adott érzékelő eseményre, az SensorManager registerListener () használatával.

A registerListener () módszer a következő argumentumokat veszi figyelembe:

• Egy alkalmazás vagy tevékenységi környezet.
• A figyelni kívánt érzékelő típusa.
• Az a sebesség, amellyel az érzékelő új adatokat küld. A magasabb tarifa több adatot fog biztosítani az alkalmazásához, de több rendszer erőforrást is igényel, különösen az akkumulátor élettartamát. Az eszköz akkumulátorának megőrzése érdekében kérnie kell az alkalmazáshoz szükséges minimális mennyiségű adatot. A SensorManager.SENSOR_DELAY_NORMAL alkalmazást fogom használni, amely 200 000 mikrosekundumonként (0,2 másodpercenként) küld új adatokat.

Mivel egy érzékelő hallgatása kimeríti az eszköz akkumulátorait, soha nem regisztrálnia kell a hallgatókat az alkalmazás onCreate () módszerére, mivel ez az érzékelőknek folytatja az adatok küldését, még akkor is, ha az alkalmazás a háttérben van.

Ehelyett regisztrálnia kell érzékelőit az alkalmazás onStart () életciklus módszerén:

@ Felülírja a védett void onStart () {super.onStart (); // Ha az érzékelő elérhető az aktuális eszközön ... // if (lightSensor! = Null) {//… .még kezdje meghallgatni // lightSensorManager.registerListener (ez, lightSensor, SensorManager.SENSOR_DELAY_NORMAL); }}

5. Végezzük el a SensorEventListener visszahívásokat

Az SensorEventListener egy olyan felület, amely értesítéseket fogad a SensorManager-től
amikor új adatok állnak rendelkezésre, vagy ha az érzékelő pontossága megváltozik.

Az első lépés az osztály aláírásának módosítása a SensorEventListener felület megvalósításához:

A MainActivity nyilvános osztály kibővíti az AppCompatActivity SensorEventListener eszközöket {

Ezután a következő visszahívási módszereket kell végrehajtanunk:

onSensorChanged ()

Ezt a módszert minden új SensorEventre válaszul hívják.

Az érzékelők adatai gyakran gyorsan változhatnak, így az alkalmazás rendszeresen felhívhatja az onSensorChanged () metódust. Az alkalmazás zökkenőmentes működésének elősegítése érdekében a lehető legkevesebb munkát kell elvégeznie az onSensorChanged () módszerben.

@A nyilvános void felülírása az onSensorChanged (SensorEvent sensorEvent) {// Teendők //}

onAccuracyChanged ()

Ha az érzékelő pontossága javul vagy csökken, akkor az Android meghívja az onAcc pontChanged () metódust, és átadja az érzékelő objektumnak, amely tartalmazza az új pontossági értéket, például SENSOR_STATUS_UNRELIABLE vagy SENSOR_STATUS_ACCURACY_HIGH.

A fényérzékelő nem jeleníti meg a pontosság változásait, ezért az onAcc pontChanged () visszahívást üresen hagyom:

@A nyilvános érvénytelenség felülírása onAcc pontChanged (Érzékelő érzékelő, int i) {// Teendők //}}

6. Keresse meg az érzékelő értékét

Ha új értékünk van, fel kell hívnunk az onSensorChanged () metódust, és be kell töltenünk a „light_sensor” karakterláncot. Ezután felülbírálhatjuk a karakterlánc helyőrző szövegét (% 1 $ .2f), és megjeleníthetjük a frissített karakterláncot a TextView részeként:

@A nyilvános void felülbírálása onSensorChanged (SensorEvent sensorEvent) {// Az érzékelő aktuális értéke // float currentValue = sensorEvent.values; // Töltse le a „light_sensor” karakterláncot, illessze be az új értéket, és jelenítse meg a felhasználónak // lightTextView.setText (getResources (). GetString (R.string.light_sensor, currentValue)); }

7. Törölje a hallgatók regisztrációját

Az érzékelők nagy mennyiségű adatot állíthatnak elő rövid idő alatt, így az eszköz erőforrásainak megőrzése érdekében törölnie kell a hallgatók regisztrációját, amikor már nincs rá szükség.

Ha nem szeretné meghallgatni az érzékelő eseményeit, amikor az alkalmazás a háttérben van, akkor adja hozzá az irregisterListener () elemet a projekt onStop () életciklusának módszeréhez:

@ Felülírja a védett void onStop () {super.onStop (); lightSensorManager.unregisterListener (e); }

Vegye figyelembe, hogy ne törölje a hallgatók regisztrációját az onPause () alkalmazásban, mivel az Android 7.0 és újabb verziói osztott képernyő és kép a képben módban futhatnak, ahol szüneteltettek állapotban vannak, de a képernyőn továbbra is láthatóak maradnak.

Az Android fényérzékelőinek használata: kitöltött kód

A fenti lépések elvégzése után a projekt MainActivity-jének így kell kinéznie:

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; A nyilvános osztályú MainActivity kiterjeszti az AppCompatActivity // Az SensorEventListener felület végrehajtása // Az SensorEventListener eszköz végrehajtása {// Hozza létre a változókat // magán érzékelő lightSensor; privát SensorManager lightSensorManager; privát TextView lightTextView; @ Felülírja a védett érvénytelen onCreate (Bundle savedInstanceState) {super.onCreate (savedInstanceState); setContentView (R.layout.activity_main); lightTextView = (TextView) findViewById (R.id.lightTextView); // Szerezze be a SensorManager példányát // lightSensorManager = ((SensorManager) getSystemService (Context.SENSOR_SERVICE); // Ellenőrizze, hogy nincs-e fényérzékelő // lightSensor = lightSensorManager.getDefaultSensor (Sensor.TYPE_LIGHT); // Ha a fényérzékelő nem létezik, akkor jelenítsen meg egy hibát // String sensor_error = getResources (). GetString (R.string.no_sensor); if (lightSensor == null) {lightTextView.setText (sensor_error); }} @Override védett érvénytelen onStart () {super.onStart (); // Ha az érzékelő elérhető az aktuális eszközön ... // if (lightSensor! = Null) {//… .mire regisztrálja a hallgatót // lightSensorManager.registerListener (ez, lightSensor, // Adja meg, hogy milyen gyakran szeretné új adatok fogadása // SensorManager.SENSOR_DELAY_NORMAL); }} @Override védett void onStop () {super.onStop (); // Törölje a hallgató regisztrációját // lightSensorManager.unregisterListener (ez); } @A nyilvános érvénytelenség onSensorChanged (SensorEvent sensorEvent) {// az érzékelő aktuális értéke // float currentValue = sensorEvent.values; // Keresse meg a “light_sensor” karakterláncot, illessze be az új értéket és frissítse a TextView // lightTextView.setText fájlt (getResources (). GetString (R.string.light_sensor, currentValue)); } @ Felülírás // Ha az érzékelő pontossága megváltozik .// köztudat érvénytelen onAcc pontChanged (Érzékelő érzékelő, int i) {// TO DO //}}

Tesztelje a kész Android érzékelő alkalmazást

Az alkalmazás teszteléséhez fizikai Android okostelefonon vagy táblagépen:

• Telepítse a projektet a készülékére (az Android Studio eszköztáron válassza a „Futtatás> Futtatás” lehetőséget).
• Noha eszközönként eltérő, a fényérzékelő gyakran a képernyő jobb felső sarkában található. A fényszintek kezeléséhez mozgassa közelebb a készüléket a fényforráshoz, majd távolabb. Alternatív megoldásként megpróbálhatja letakarni az eszközt a kezével, hogy megakadályozza a fényt. A „Fényérzékelő” értékének növekednie kell és csökkennie kell, a rendelkezésre álló fény mennyiségétől függően.

Ha Android virtuális eszközt (AVD) használ, akkor az emulátor virtuális érzékelővezérlőkkel rendelkezik, amelyek segítségével különféle szenzor eseményeket szimulálhat. Ezeket a virtuális érzékelő vezérlőket az emulátor „Kiterjesztett vezérlők” ablakán keresztül érheti el:

• Telepítse az alkalmazást az AVD-re.
• Az AVD mellett egy gombcsíkot fog látni. Keresse meg a három ponttal ellátott „Több” gombot (ahol a kurzor a következő képernyőképen van elhelyezve), és kattintson rá. Ez megnyitja a „kiterjesztett vezérlők” ablakot.

• A bal oldali menüben válassza a „Virtuális érzékelők” lehetőséget.
• Válassza a „További érzékelők” fület. Ez a lap különféle csúszkákat tartalmaz, amelyek segítségével szimulálhatják a különböző helyzet- és környezeti érzékelők eseményeit.

• Keresse meg a „Fény (lux)” csúszkát, és húzza balra és jobbra a szimulált fényszintek megváltoztatásához. Az alkalmazásnak valós időben meg kell jelenítenie ezeket a változó értékeket.

A befejezett projektet letöltheti a GitHubból.

Távolságmérés az Android közelségérzékelőivel

Most megláttuk, hogyan lehet információkat lekérni egy környezeti érzékelőből, nézzük meg, hogyan alkalmazná ezt az információt egy pozíció érzékelő.

Ebben a szakaszban az eszköz közelségérzékelőjét használjuk az okostelefon vagy táblagép és más tárgyak közötti távolság figyelésére. Ha az alkalmazás bármilyen hangfunkcióval rendelkezik, akkor a közelség-érzékelő segít meghatározni, hogy mikor tartják az okostelefont a felhasználó füléhez, például amikor telefonbeszélgetést folytatnak. Ezt az információt ezután felhasználhatja az érintési események letiltására, így a felhasználó nem véletlenül leteszi, vagy nem indít el más nem kívánt eseményeket a beszélgetés közben.

A felhasználói felület létrehozása

Meg fogom jeleníteni a képernyőn a közelségi adatokat, így valós időben megnézheti, hogy azok frissülnek-e. A dolgok egyszerűségének megkönnyítése érdekében használjuk újra az előző alkalmazásunk elrendezésének nagy részét:

Ezután nyissa meg a strings.xml fájlt, és hozzon létre egy “proximity_sensor” karakterláncot. Ismét, ennek a karakterláncnak tartalmaznia kell egy helyőrzőt, amelyet végül a közelség-érzékelőből kinyert adatok töltnek el:

Közelség érzékelő Közelségérzékelő:% 1 $ .2f Nincs elérhető közelségérzékelő

Adatok beolvasása a közelségérzékelőről

A fényérzékelőhöz hasonlóan az Android közelségérzékelője egyetlen adatértéket ad vissza, ami azt jelenti, hogy a korábbi alkalmazásunkból származó kód nagy részét újra felhasználhatjuk. Van azonban néhány jelentős különbség, valamint néhány névvel kapcsolatos változás, amelyek megkönnyítik a kód követését:

• Készítsen egy SensorManager példányt, amelyet ezúttal „proximitySensorManager” -nek fogok nevezni.
• Szerezze be a „proximitySensorManager” példányt.
• Hozzon létre hivatkozást a „proximityTextView” elemre.
• Hívja a getDefaultSensor () metódust, és adja át a TYPE_PROXIMITY érzékelőt.
• Regisztrálja és törölje a hallgatókat a közelségérzékelő számára.

Miután elvégezte ezeket a csípéseket, az alábbiakkal kell végeznie:

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; A nyilvános osztályú MainActivity kiterjeszti az AppCompatActivity // Az SensorEventListener felület végrehajtása // Az SensorEventListener eszköz végrehajtása {// Hozza létre a változókat // magán Sensor proximitySensor; privát SensorManager proximitySensorManager; privát TextView proximityTextView; @ Felülírja a védett érvénytelen onCreate (Bundle savedInstanceState) {super.onCreate (savedInstanceState); setContentView (R.layout.activity_main); proximityTextView = (TextView) findViewById (R.id.proximityTextView); // Szerezzen be egy SensorManager példányt // proximitySensorManager = ((SensorManager) getSystemService (Context.SENSOR_SERVICE); // Ellenőrizze a közelségérzékelőt // proximitySensor = proximitySensorManager.getDefaultSensor (Sensor.TYPE_PROXIMITY); // Ha a közelség-érzékelő nem létezik, akkor jelenítsen meg egy hibát // String sensor_error = getResources (). GetString (R.string.no_sensor); if (proximitySensor == null) {proximityTextView.setText (sensor_error); }} @Override védett érvénytelen onStart () {super.onStart (); // Ha az érzékelő elérhető az aktuális eszközön ... // if (proximitySensor! = Null) {//… .mivel regisztráljon egy hallgatót // proximitySensorManager.registerListener (ez, proximitySensor, // Adja meg, hogy milyen gyakran szeretne új adatok fogadása // SensorManager.SENSOR_DELAY_NORMAL); }} @Override védett void onStop () {super.onStop (); // Törölje a hallgató regisztrációját a rendszer erőforrásainak megőrzése érdekében // proximitySensorManager.unregisterListener (ez); } @A nyilvános érvénytelenség onSensorChanged (SensorEvent sensorEvent) {// az érzékelő aktuális értéke // float currentValue = sensorEvent.values; // Töltse le a „proximity_sensor” karakterláncot, illessze be az új értéket és frissítse a TextView // proximityTextView.setText fájlt (getResources (). GetString (R.string.proximity_sensor, currentValue)); } @ Felülírás // Ha az érzékelő pontossága megváltozik .// köztudat érvénytelen onAcc pontChanged (Érzékelő érzékelő, int i) {//...TO DO //}}

Tesztelés: Mennyire közel van a felhasználó készülékéhez?

Az alkalmazás teszteléséhez fizikai Android okostelefonon vagy táblagépen telepítse az alkalmazást az eszközére, majd kísérletezzen úgy, hogy mozgatja a kezét a képernyő felé, majd ismét távolítja el. A „Proximity Sensor” értéknek rögzítenie kell a mozgásait.

Ne feledje, hogy a közelség-érzékelők eszközökönként változhatnak. Egyes eszközök csak két közelségi értéket jeleníthetnek meg - egyet jelölnek a „Közel”, a másik pedig a „Távol” jelölést - tehát ne lepődj meg, ha nem látsz sok különbséget a fizikai Android-eszközén.

Az alkalmazás tesztelése emulátoron:

• Telepítse az alkalmazást egy AVD-re.
• Keresse meg a három ponttal ellátott „Több” gombot, és kattintson rá, és elindítja a „kiterjesztett vezérlők” ablakot.
• Az ablak bal oldali menüjében válassza a „Virtuális érzékelők” lehetőséget.
• Válassza a „További érzékelők” fület.
• Keresse meg a „Proximity” csúszkát, és húzza balra és jobbra egy objektum emulációjához, amely közelebb kerül az eszközhöz, majd távolabb. A „Proximity Sensor” értékeinek meg kell változniuk, amikor a csúszkát manipulálja.

A befejezett projektet letöltheti a GitHubból.

Mozgásérzékelők: Többdimenziós tömbök feldolgozása

Eddig a pontig azokra az érzékelőkre összpontosítottunk, amelyek egyetlen adatot szolgáltatnak, de vannak olyan érzékelők, amelyek többdimenziós tömböket biztosítanak minden egyes SensorEventhez. Ezek a többdimenziós érzékelők mozgásérzékelőket is tartalmaznak, amelyekre ebben az utolsó szakaszban összpontosítunk.

A mozgásérzékelők segíthetnek:

• Adjon meg alternatív módszert a felhasználói bevitelhez. Például, ha mobiljátékot fejlesztenek, akkor a felhasználó a karakterét a képernyő körül mozgathatja, ha eszközét megdönt.
• Alacsony felhasználói tevékenység. Ha tevékenységi nyomkövető alkalmazást hozott létre, akkor a mozgásérzékelők segíthetnek felmérni, hogy a felhasználó autóval utazik, kocogik vagy ül az asztalukon.
• A tájolás pontosabb meghatározása.Lehetőség van a koordináták kinyerésére az eszköz mozgásérzékelőiről, és lefordíthatók a Föld koordinátarendszere alapján, hogy a lehető legpontosabb betekintést nyújtsák az eszköz jelenlegi tájolásához.

Ebben az utolsó szakaszban a rotációs vektor érzékelőt (TYPE_ROTATION_VECTOR) fogjuk használni. A fény- és közelségérzékelőkkel ellentétben ez egy szoftverérzékelő, amely összegyűjti az eszköz gyorsulásmérőjét, magnetométerét és giroszkóp érzékelőit. Bár ezzel az érzékelővel való munka gyakran matematikai átalakításokat és transzformációkat igényel, ez a készülékkel kapcsolatos nagyon pontos információkkal is szolgálhat.

Olyan alkalmazást hozunk létre, amely a rotációs vektor-érzékelőt használja a következők mérésére:

• Hangmagasság. Ez a készülék fentről lefelé történő döntése.
• Tekercs. Ez az eszköz balról jobbra döntése.

Valós idejű hangmagasság és görgetési adatok megjelenítése

Mivel két mérőt mérünk, létre kell hoznunk két TextView-t és két megfelelő string-erőforrást:

Nyissa meg a strings.xml fájlt, és adja hozzá a következőket:

MotionSensors Pitch érzékelő:% 1 $ .2f Hengerérzékelő:% 1 $ .2f Nincs mozgásérzékelő

A forgatásvektor-érzékelő használata az alkalmazásban

A korábbi alkalmazások egy részét újra felhasználjuk, tehát összpontosítsunk azon területekre, ahol a forgatásvektor-érzékelővel való kommunikáció jelentősen különbözik attól, amit korábban láttunk.

1. Használja a TYPE_ROTATION_VECTOR eszközt

Mivel a rotációs vektorérzékelővel dolgozunk, fel kell hívnunk a getDefaultSensor () metódust, majd át kell adnunk a TYPE_ROTATION_VECTOR állandó értéket:

positionSensorManager.getDefaultSensor (Sensor.TYPE_ROTATION_VECTOR);

2. Fordítsa le az érzékelő adatait

A korábbi fény- és közelségérzékelőkkel ellentétben a mozgásérzékelők minden szenzorEventhez visszaadnak az érzékelők értékének többdimenziós tömbjeit. Ezeket az értékeket a szabványos „X, Y, Z” koordinátarendszerrel formázják, amelyet az eszközhöz képest számítanak, amikor az alapértelmezett „természetes” tájolású.

Az Android nem változtatja meg ezeket az X, Y és Z koordinátákat az eszköz jelenlegi tájolásának megfelelően, tehát az „X” tengely változatlan marad, függetlenül attól, hogy az eszköz álló vagy fekvő módban van-e. A forgatásvektor-érzékelő használatakor előfordulhat, hogy a bejövő adatokat át kell alakítania, hogy azok megfeleljenek az eszköz jelenlegi forgásának.

A legtöbb okostelefon alapértelmezett tájolása a portré, de nem szabad azt feltételezni, hogy ez lesz a helyzet minden Android-eszközök, különösen a táblagépek. Ebben a cikkben egy forgató mátrixot használunk az érzékelő adatainak az eredeti, eszköz koordinátarendszer a Föld koordinátarendszer, amely képviseli az eszköz mozgását és helyzetét a Földhöz képest. Szükség esetén az érzékelő adatait az eszköz jelenlegi tájolása alapján újrakészíthetjük.

Először: az eszköz koordinátarendszere egy szabványos háromtengelyes X, Y, Z koordinátarendszer, ahol a három tengely mindegyik pontját 3D vektor képviseli. Ez azt jelenti, hogy létre kell hoznunk egy 9 lebegőérték-tömböt:

float rotationMatrix = új úszó;

Ezután továbbíthatjuk ezt a tömböt a getRotationMatrix () módszerhez:

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

A következő lépés az SensorManager.remapCoordinateSystem () módszer használata az érzékelőadatok újrakészítéséhez, az eszköz jelenlegi tájolása alapján.

A SensorManager.remapCoordinateSystem () módszer a következő argumentumokat veszi figyelembe:

• Az eredeti forgató mátrix.
• Azok a tengelyek, amelyeket át szeretne készíteni.
• A tömb, amelyet ezen új adatokkal tölt fel.

Íme a kód, amelyet használni fogok az alkalmazásomban:

úszó beállítvaRotationMatrix = új úszó; SensorManager.remapCoordinateSystem (rotationMatrix, worldAxisX, worldAxisZ, korrigáltRotationMatrix);

Végül felhívjuk az SensorManager.getOrientation-t, és azt mondjuk, hogy használja a beállítottRotationMatrix-ot:

SensorManager.getOrientation (beállítottRotationMatrix, tájolás);

3. Frissítse a helyőrző karakterláncokat

Mivel két adatkészlettel rendelkezik (hangmagasság és tekercs), ki kell töltenünk két külön helyőrző-karakterláncot, kitölteni őket a helyes értékekkel, majd frissíteni a megfelelő TextView-t:

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

Több érzékelő adatainak megjelenítése: Kész kód

A fenti lépések elvégzése után a MainActivity-nek a következőképpen néz ki:

import android.app.Activity; import android.os.Bundle; import android.hardware.Sensor; import android.hardware.SensorEvent; import android.hardware.SensorEventListener; import android.hardware.SensorManager; import android.widget.TextView; a nyilvános osztályú MainActivity kibővíti a tevékenységi eszközöket: SensorEventListener {private SensorManager motionSensorManager; magán érzékelő motionSensor; privát TextView pitchTextView; privát TextView rollTextView; magán statikus végleges int SENSOR_DELAY = 500 * 1000; privát statikus végleges int FROM_RADS_TO_DEGS = -57; @ Felülírja a védett érvénytelen onCreate (Bundle savedInstanceState) {super.onCreate (savedInstanceState); setContentView (R.layout.activity_main); pitchTextView = (TextView) findViewById (R.id.pitchTextView); rollTextView = (TextView) findViewById (R.id.rollTextView); próbáld ki a {motionSensorManager = (SensorManager) getSystemService (Activity.SENSOR_SERVICE) szolgáltatást; motionSensor = motionSensorManager.getDefaultSensor (Sensor.TYPE_ROTATION_VECTOR); motionSensorManager.registerListener (ez, motionSensor, SENSOR_DELAY); } fogás (e kivétel) {pitchTextView.setText (R.string.no_sensor); rollTextView.setText (R.string.no_sensor); }} @Override public void onAcc pontChanged (érzékelő érzékelő, int pontosság) {// Teendő //} @Oreride public void onSensorChanged (SensorEvent esemény) {if (event.sensor == motionSensor) {frissítés (event.values); }} privát void frissítés (úszóvektorok) {// Számolja ki a forgási mátrixot // float rotationMatrix = új úszó; SensorManager.getRotationMatrixFromVector (rotationMatrix, vektorok); int worldAxisX = SensorManager.AXIS_X; int worldAxisZ = SensorManager.AXIS_Z; // A mátrix ábrázolása a tevékenység jelenlegi tájolása alapján // float beállítvaRotationMatrix = új float; SensorManager.remapCoordinateSystem (rotationMatrix, worldAxisX, worldAxisZ, korrigáltRotationMatrix); // Számítsa ki az eszközök tájolását // Úszó tájolás = új úszó; // Adja meg az úszó értékek tömbjét a getOrientation () módszerhez // SensorManager.getOrientation (beállítottRotationMatrix, tájolás); úszó hangmagasság = tájolás * FROM_RADS_TO_DEGS; úszó tekercs = tájolás * FROM_RADS_TO_DEGS; // Frissítse a TextViews-t a hangmagasság és a roll értékekkel // pitchTextView.setText (getResources (). GetString (R.string.pitch_sensor, pitch)); rollTextView.setText (getResources (). getString (R.string.roll_sensor, roll)); }}

A befejezett projektet letöltheti a GitHubból.

Teszteljük a végső Android érzékelő alkalmazást

A forgó vektoros Android érzékelő alkalmazás teszteléséhez fizikai Android okostelefonon vagy táblagépen:

• Telepítse az alkalmazást az eszközére.
• Helyezze okostelefonját vagy táblagépét egy sima felületre. Vegye figyelembe, hogy a mozgásérzékelők rendkívül érzékenyek, tehát nem szokatlan, hogy egy látszólag mozdulatlan eszköz jelentést tesz a hangmagasság és a görgési értékek ingadozásáról.
• A hangmagasság teszteléséhez emelje fel a készülék alját úgy, hogy az elforduljon tőled. A hangmagasság értékének drámaian meg kell változnia.
• A tekercs teszteléséhez próbálja meg felemelni a készülék bal oldalát, hogy balra dőljön - tartsa szemmel a tekercs értékét!

Ha a projektet egy emulátoron teszteli:

• Telepítse az alkalmazást az AVD-re.
• Válassza a „Több” lehetőséget, amely elindítja az „Kiterjesztett vezérlők” ablakot.
• A bal oldali menüben válassza a „Virtuális érzékelők” lehetőséget.
• Győződjön meg arról, hogy a „Gyorsulásmérő” fül van kiválasztva. Ez a lap olyan vezérlőket tartalmaz, amelyek szimulálhatják az eszköz helyzetében és tájolásában bekövetkező változásokat.
• Próbálja ki a különböző csúszkákkal (Forgatás: Z-Rot, X-Rot, Y-Rot; és Mozgatás: X, Y és Z) és a különféle „Eszközforgatás” gombokkal, hogy megnézze, hogyan befolyásolják az alkalmazás „Tekercsérzékelő” ”És„ Pitch Sensor ”értékek.

Csomagolás

Ebben a cikkben megtudtuk, hogyan lehet adatokat kivenni az Android-érzékelők három fő kategóriájából: a környezetvédelem, a helyzet és a mozgás, valamint hogyan valós időben követhetjük ezeket az adatokat.

Látott olyan Android-alkalmazást, amely érdekes vagy egyedi módon használ érzékelőket? Tudassa velünk az alábbi megjegyzésekben!