Conţinut

• Ce senzori Android pot folosi?
• Senzori de mediu: Măsurarea luminii ambientale
• Afișarea datelor senzorului dvs.
• Comunicarea cu un senzor: SensorManager, SensorEvents și ascultători
• 1. Obțineți o instanță a SensorManager
• 2. Obțineți o referință la lightTextView
• 3. Verificați dacă senzorul există pe dispozitivul curent
• 4. Înregistrați ascultătorii de senzori
• 5. Implementați apelurile SensorEventListener
• onSensorChanged ()
• onAccuracyChanged ()
• 6. Recuperați valoarea senzorului
• 7. Anulați-vă ascultătorii
• Utilizarea senzorilor de lumină Android: cod completat
• Testează-ți aplicația de senzor pentru Android completată
• Măsurarea distanței, cu senzori de proximitate Android
• Crearea interfeței de utilizator
• Obținerea de date de la senzorul de proximitate
• Testare: Cât de aproape este utilizatorul de dispozitivul său?
• Senzori de mișcare: procesarea tablourilor multidimensionale
• Afișare date în timp real și rulare
• Utilizarea senzorului vectorului de rotație din aplicația dvs.
• 1. Folosiți TYPE_ROTATION_VECTOR
• 2. Traduceți datele senzorului
• 3. Actualizați șirurile marcajului
• Afișarea mai multor date despre senzori: cod completat
• Testarea aplicației noastre finale pentru senzori Android
• Înveliți

Astăzi, majoritatea dispozitivelor Android moderne sunt echipate cu o mulțime de senzori.

Puteți utiliza aceste informații în mai multe moduri diferite - fie că monitorizează nivelul luminii, astfel încât aplicația dvs. poate ajusta automat luminozitatea sau schema de culori; permițând utilizatorului să interacționeze cu jocul dvs. mobil folosind gesturi cum ar fi înclinarea dispozitivului; sau folosind senzorul de proximitate pentru a dezactiva automat evenimentele tactile ori de câte ori utilizatorul își ține dispozitivul la ureche.

În acest articol, vom crea trei aplicații care preiau date de lumină, de proximitate și de mișcare dintr-o gamă de senzori hardware și software. De asemenea, vom monitoriza acești senzori Android în timp real, astfel încât aplicația dvs. să aibă întotdeauna acces la cele mai recente informații.

Până la sfârșitul acestui articol, veți ști să extrageți o singură bucată de date dintr-un senzor Android și cum să gestionați senzori care furnizează datele lor sub forma unui tablou multidimensional.

Ce senzori Android pot folosi?

Senzorii Android pot fi împărțiți în următoarele categorii:

• Senzori de mediu Acestea măsoară condițiile de mediu, cum ar fi temperatura aerului, presiunea, umiditatea și nivelul de lumină ambientală.

• Senzori de poziție. Această categorie include senzori care măsoară poziția fizică a dispozitivului, precum senzori de proximitate și senzori de câmp geomagnetic.
  Senzori de mișcare. Acești senzori măsoară mișcarea dispozitivului și includ accelerometre, senzori de gravitație, giroscopuri și senzori de rotație.

În plus, senzorii pot fi:

• Bazat pe hardware. Acestea sunt componente fizice care sunt încorporate în dispozitiv și măsoară direct proprietăți specifice, cum ar fi accelerația sau puterea câmpurilor geomagnetice din jur.
• Bazat pe software, cunoscut uneori sub denumirea de senzori virtuali sau senzori compuși. Acestea colectează de obicei date de la mai mulți senzori pe bază de hardware. Spre sfârșitul acestui articol, vom lucra cu senzorul vectorului de rotație, care este un senzor software care combină datele de la accelerometrul, magnetometrul și giroscopul dispozitivului.

Senzori de mediu: Măsurarea luminii ambientale

Senzorul de lumină al Android măsoară lumina ambientală în unitățile „lux”, care este intensitatea luminii percepută de ochiul uman. Valoarea lux raportată de un senzor poate varia în funcție de dispozitive, astfel încât dacă aplicația necesită valori consistente, atunci trebuie să manipulați datele brute înainte de a le folosi în aplicația dvs.

În această secțiune, vom crea o aplicație care preia valoarea actuală de lux din senzorul de lumină al dispozitivului, o afișăm într-un TextView și apoi actualizăm TextView, pe măsură ce datele noi devin disponibile.Puteți utiliza aceste informații într-o serie de aplicații, de exemplu, puteți crea o aplicație cu torță care extrage informații de la senzorul de lumină și apoi ajustează automat puterea fasciculului său în funcție de nivelurile actuale de lumină.

Creați un nou proiect Android cu setările pe care le alegeți și să începem!

Afișarea datelor senzorului dvs.

Voi adăuga un TextView care va afișa în cele din urmă datele pe care le-am extras din senzorul de lumină. Acest TextView se va actualiza ori de câte ori vor fi disponibile date noi, astfel încât utilizatorul să aibă întotdeauna acces la cele mai recente informații.

Deschideți fișierul activității_main.xml al proiectului și adăugați următoarele:

În continuare, trebuie să creăm resursa de tip „light_sensor” la care este făcut referire în aspectul nostru. Deschideți fișierul strings.xml al proiectului și adăugați următoarele:

Senzor de lumină:% 1 $ .2f

„% 1 $ .2f” este un marcator de locație care specifică informațiile pe care dorim să le afișăm și cum trebuie formatate:

• %1. Puteți introduce mai multe marcatoare de plasă în aceeași resursă șir; „% 1” indică faptul că folosim un singur marcator.
• $.2. Aceasta specifică modul în care aplicația noastră ar trebui să formateze fiecare valoare în virgulă flotantă. „$ .2” indică faptul că valoarea ar trebui rotunjită la două zecimale.
• F. Formatați valoarea ca un număr în virgulă mobilă.

Deși unii senzori sunt mai comuni decât alții, nu ar trebui să presupuiți niciodată că fiecare dispozitiv are acces la aceleași hardware și software. Disponibilitatea senzorilor poate varia chiar și în diferite versiuni ale Android, deoarece unii senzori nu au fost introduși până la lansările ulterioare ale platformei Android.

Puteți verifica dacă un anumit senzor este prezent pe un dispozitiv, folosind cadrul senzorului Android. Puteți dezactiva sau activa anumite părți ale aplicației dvs. în funcție de disponibilitatea senzorului sau puteți afișa o explicație a faptului că unele dintre funcțiile aplicației dvs. nu vor funcționa așa cum era de așteptat.

În timp ce avem fișierul nostru strings.xml deschis, să creăm un șir „no_sensor”, pe care îl vom afișa dacă senzorul de lumină nu este disponibil:

Nu este disponibil senzor de lumină

Dacă aplicația dvs. nu poate oferi o experiență bună utilizatorului fără a avea acces la un anumit senzor, atunci trebuie să adăugați aceste informații la Manifest. De exemplu, dacă aplicația dvs. necesită acces la un senzor de busolă, puteți utiliza următoarele:

Acum, aplicația dvs. poate fi descărcată doar pe dispozitive care au senzor de busolă.

Deși acest lucru poate limita audiența dvs., este mult mai puțin dăunător decât să permiteți cuiva să descarce aplicația dvs. atunci când este garantat pentru a avea o experiență proastă datorită configurației senzorului dispozitivului lor.

Comunicarea cu un senzor: SensorManager, SensorEvents și ascultători

Pentru a comunica cu senzorul de lumină al dispozitivului, trebuie să parcurgeți următorii pași:

1. Obțineți o instanță a SensorManager

SensorManager oferă toate metodele de care aveți nevoie pentru a accesa gama completă de senzori a dispozitivului.

Pentru a începe, creați o variabilă care va conține o instanță a SensorManager:

private SensorManager lightSensorManager;

Apoi, trebuie să obțineți o instanță a SensorManager, apelând la metoda Context.getSystemService și trecând în argumentul Context.SENSOR_SERVICE:

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

2. Obțineți o referință la lightTextView

În continuare, trebuie să creăm o variabilă de membru privat care să dețină obiectele TextView și să o atribuim TextView-ului nostru:

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

3. Verificați dacă senzorul există pe dispozitivul curent

Puteți accesa un anumit senzor apelând la metoda getDefaultSensor (), apoi trecând senzorul în cauză. Constanta de tip pentru senzorul de lumină este TYPE_LIGHT, deci trebuie să utilizăm următoarele:

lightSensor = lightSensorManager.getDefaultSensor (Sensor.TYPE_LIGHT);

Dacă senzorul nu există pe acest dispozitiv, atunci metoda getDefaultSensor () va reveni nul și vom afișa șirul „no_sensor”:

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

4. Înregistrați ascultătorii de senzori

De fiecare dată când un senzor are date noi, Android generează un obiect SensorEvent. Acest obiect SensorEvent include senzorul care a generat evenimentul, o marcă de timp și noua valoare a datelor.

Inițial, ne vom concentra pe senzorii de lumină și de proximitate, care returnează o singură informație. Cu toate acestea, unii senzori furnizează tablouri multidimensionale pentru fiecare SensorEvent, inclusiv senzorul vectorului de rotație, pe care îl vom explora până la sfârșitul acestui articol.

Pentru a ne asigura că aplicația noastră este notificată cu privire la aceste obiecte SensorEvent, trebuie să înregistrăm un ascultător pentru acel eveniment senzor specific, utilizând registrul SensorManager RegisterListener ().

Metoda registerListener () ia următoarele argumente:

• O aplicație sau contextul activității.
• Tipul de senzor pe care doriți să îl monitorizați.
• Viteza cu care senzorul ar trebui să trimită date noi. O rată mai mare va oferi aplicației dvs. mai multe date, dar va folosi și mai multe resurse de sistem, în special durata de viață a bateriei. Pentru a ajuta la păstrarea bateriei dispozitivului, trebuie să solicitați cantitatea minimă de date necesară pentru aplicație. Voi folosi SensorManager.SENSOR_DELAY_NORMAL, care trimite date noi o dată la 200.000 de microsecunde (0,2 secunde).

Deoarece ascultarea unui senzor drenează bateria dispozitivului, nu trebuie să înregistrați niciodată ascultătorii în metoda onCreate () a aplicației, deoarece acest lucru va determina senzorii să continue să trimită date, chiar dacă aplicația dvs. este în fundal.

În schimb, ar trebui să vă înregistrați senzorii în metoda ciclului de viață al aplicației onStart ():

@ Supraveghează void protejat onStart () {super.onStart (); // Dacă senzorul este disponibil pe dispozitivul curent ... // dacă (lightSensor! = Null) {//….then începe să asculte // lightSensorManager.registerListener (acesta, LightSensor, SensorManager.SENSOR_DELAY_NORMAL); }}

5. Implementați apelurile SensorEventListener

SensorEventListener este o interfață care primește notificări de la SensorManager
ori de câte ori sunt disponibile date noi sau exactitatea senzorului se schimbă.

Primul pas este modificarea semnăturii clasei noastre pentru a implementa interfața SensorEventListener:

public class MainActivity extinde AppCompatActivity implementează SensorEventListener {

Apoi, trebuie să implementăm următoarele metode de apelare:

onSensorChanged ()

Această metodă este numită ca răspuns la fiecare nou SensorEvent.

De multe ori datele despre senzori se pot schimba rapid, astfel încât aplicația dvs. poate apela la metoda onSensorChanged () în mod regulat. Pentru a ajuta aplicația să funcționeze fără probleme, ar trebui să efectuați cât mai puțin lucru posibil în cadrul metodei onSensorChanged ().

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

onAccuracyChanged ()

Dacă precizia senzorului se îmbunătățește sau scade, atunci Android va apela la metoda onAccurityChanged () și o va transmite un obiect Sensor care conține noua valoare de precizie, cum ar fi SENSOR_STATUS_UNRELIABLE sau SENSOR_STATUS_ACCURACY_HIGH.

Senzorul de lumină nu raportează schimbările de acuratețe, așa că voi lăsa apelul de apel onAccurityChanged () gol:

@ Suprapune public void onAccarityChanged (Senzor senzor, int i) {// To do //}}

6. Recuperați valoarea senzorului

Ori de câte ori avem o nouă valoare, trebuie să apelăm la metoda onSensorChanged () și să regăsim șirul „light_sensor”. Putem apoi să înlocuim textul marcatorului de caractere al șirului (% 1 $ .2f) și să afișăm șirul actualizat ca parte a TextView:

@Substitui public void onSensorChanged (SensorEvent sensorEvent) {// Valoarea curentă a senzorului // float currentValue = sensorEvent.values; // Recuperați șirul „light_sensor”, introduceți noua valoare și afișați-l utilizatorului // lightTextView.setText (getResources (). GetString (R.string.light_sensor, currentValue)); }

7. Anulați-vă ascultătorii

Senzorii pot genera cantități mari de date într-o perioadă mică de timp, astfel încât să contribuie la păstrarea resurselor dispozitivului, va trebui să vă înregistrați ascultătorii atunci când nu mai sunt necesare.

Pentru a opri ascultarea evenimentelor de senzori atunci când aplicația dvs. este în fundal, adăugați anularea înregistrăriiListener () la metoda ciclului de viață pe Stop () al proiectului:

@ Supraveghează void protejat onStop () {super.onStop (); lightSensorManager.unregisterListener (aceasta); }

Rețineți că nu ar trebui să vă înregistrați ascultătorii în OnPause (), ca în Android 7.0 și aplicațiile superioare pot rula în modul split-screen și imagine-în-imagine, unde se află într-o stare întreruptă, dar rămân vizibile pe ecran.

Utilizarea senzorilor de lumină Android: cod completat

După parcurgerea tuturor etapelor de mai sus, Activitatea principală a proiectului dvs. ar trebui să arate astfel:

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; public class MainActivity extinde AppCompatActivity // Implementează interfața SensorEventListener // implementează SensorEventListener {// Creează-ți variabilele // private Sensor lightSensor; private SensorManager lightSensorManager; privat TextView lightTextView; @Override protected void onCreate (Bundle savedInstanceState) {super.onCreate (salvatInstanceState); setContentView (R.layout.activity_main); lightTextView = (TextView) findViewById (R.id.lightTextView); // Obțineți o instanță a SensorManager // lightSensorManager = (SensorManager) getSystemService (Context.SENSOR_SERVICE); // Verificați un senzor de lumină // lightSensor = lightSensorManager.getDefaultSensor (Sensor.TYPE_LIGHT); // Dacă senzorul de lumină nu există, afișați o eroare // String sensor_error = getResources (). GetString (R.string.no_sensor); if (lightSensor == null) {lightTextView.setText (senzor_error); }} @ Supraveghează void protejat onStart () {super.onStart (); // Dacă senzorul este disponibil pe dispozitivul curent ... // dacă (lightSensor! = Null) {//….then înregistrați un ascultător // lightSensorManager.registerListener (acesta, lightSensor, // Specificați cât de des doriți să primește date noi // SensorManager.SENSOR_DELAY_NORMAL); }} @ Supraveghează void protejat onStop () {super.onStop (); // Anulează-ți ascultătorul / lightSensorManager.unregisterListener (acesta); } @Substitui public void onSensorChanged (SensorEvent sensorEvent) {// Valoarea curentă a senzorului // float currentValue = sensorEvent.values; // Obțineți șirul „light_sensor”, inserați noua valoare și actualizați TextView // lightTextView.setText (getResources (). GetString (R.string.light_sensor, currentValue)); } @Override // Dacă precizia senzorului se schimbă ... .// public void onAccarityChanged (Senzor senzor, int i) {// TO DO //}}

Testează-ți aplicația de senzor pentru Android completată

Pentru a testa această aplicație pe un smartphone sau tabletă Android fizic:

• Instalați proiectul pe dispozitivul dvs. (selectând „Run> Run” din bara de instrumente Android Studio).
• Deși variază între dispozitive, senzorul de lumină este adesea situat în partea dreaptă sus a ecranului. Pentru a manipula nivelurile de lumină, mutați-vă dispozitivul mai aproape de, și apoi mai departe de o sursă de lumină. În mod alternativ, puteți încerca să acoperiți dispozitivul cu mâna, pentru a bloca lumina. Valoarea „Senzor de lumină” ar trebui să crească și să scadă, în funcție de cantitatea de lumină disponibilă.

Dacă utilizați un dispozitiv virtual Android (AVD), emulatorul are un set de controale de senzori virtuale pe care le puteți utiliza pentru a simula diverse evenimente ale senzorului. Accesați aceste comenzi virtuale ale senzorului, prin fereastra „Control extins” a emulatorului:

• Instalați aplicația pe AVD.
• Alături de AVD, veți vedea o fâșie de butoane. Găsiți butonul „Mai mult” cu trei puncte (unde este poziționat cursorul în imaginea următoare) și dați-i un clic. Aceasta lansează fereastra „Control extins”.

• În meniul din stânga, selectați „Senzori virtuali”.
• Selectați fila „Senzori suplimentari”. Această filă conține diverse glisiere pe care le puteți utiliza pentru a simula diferite evenimente ale senzorului de poziție și de mediu.

• Găsiți glisorul „Light (lux)” și trageți-l la stânga și la dreapta, pentru a schimba nivelurile de lumină simulate. Aplicația dvs. ar trebui să afișeze aceste valori în timp real.

Puteți descărca proiectul finalizat de pe GitHub.

Măsurarea distanței, cu senzori de proximitate Android

Acum am văzut cum să extragem informațiile de la un senzor de mediu, să ne uităm la modul în care aplicați aceste cunoștințe la un poziţie senzor.

În această secțiune, vom folosi senzorul de proximitate al dispozitivului pentru a monitoriza distanța dintre smartphone-ul sau tableta dvs. și alte obiecte. Dacă aplicația dvs. are orice fel de funcționalitate vocală, atunci senzorul de proximitate vă poate ajuta să determinați când smartphone-ul este ținut la urechea utilizatorului, de exemplu atunci când au o conversație telefonică. Puteți utiliza aceste informații pentru a dezactiva evenimentele tactile, astfel încât utilizatorul să nu se închidă din greșeală sau să declanșeze alte evenimente nedorite la mijlocul conversației.

Crearea interfeței de utilizator

Voi afișa pe ecran datele de proximitate, pentru a putea urmări actualizarea acestora în timp real. Pentru a vă menține lucrurile simple, să reutilizăm o mare parte din aspect din aplicația noastră anterioară:

Apoi, deschideți-vă fișierul strings.xml și creați un șir de „proximitate_sensor”. Încă o dată, acest șir trebuie să conțină un marcator de locație, care va fi în cele din urmă populat de date extrase din senzorul de proximitate:

Senzor de proximitate Senzor de proximitate:% 1 $ .2f Nu este disponibil senzor de proximitate

Obținerea de date de la senzorul de proximitate

Similar cu senzorul de lumină, senzorul de proximitate Android returnează o singură valoare de date, ceea ce înseamnă că putem reutiliza o mare parte din cod din aplicația noastră anterioară. Cu toate acestea, există câteva diferențe majore, plus câteva modificări legate de nume care fac ca acest cod să fie mai ușor de urmărit:

• Creați o instanță a SensorManager, pe care de data aceasta o voi numi „proximitateSensorManager”.
• Obțineți o instanță de „proximitateSensorManager”.
• Creați o referință la „proximitateTextView”.
• Sunați la metoda getDefaultSensor () și treceți-o pe senzorul TYPE_PROXIMITY.
• Înregistrați și dezabonați ascultătorii pentru senzorul de proximitate.

După efectuarea acestor modificări, ar trebui să închei următoarele:

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; public class MainActivity extinde AppCompatActivity // Implementează interfața SensorEventListener // implementează SensorEventListener {// Creați-vă variabilele // private Sensor proximitateSensor; private SensorManager proximitateSensorManager; privat TextView proximitateTextView; @Override protected void onCreate (Bundle savedInstanceState) {super.onCreate (salvatInstanceState); setContentView (R.layout.activity_main); prossimitateTextView = (TextView) findViewById (R.id.proximityTextView); // Obțineți o instanță de SensorManager // proximitateSensorManager = (SensorManager) getSystemService (Context.SENSOR_SERVICE); // Verificați un senzor de proximitate // proximitateSensor = proximitateSensorManager.getDefaultSensor (senzor.TYPE_PROXIMITY); // Dacă senzorul de proximitate nu există, atunci afișează o eroare // String sensor_error = getResources (). GetString (R.string.no_sensor); if (proximitateSensor == null) {proximitateTextView.setText (senzor_error); }} @ Supraveghează void protejat onStart () {super.onStart (); // Dacă senzorul este disponibil pe dispozitivul curent ... // dacă (proximitateSensor! = Nul) {//….then înregistrați un ascultător // proximitateSensorManager.registerListener (acesta, proximitateSensor, // Specificați cât de des doriți să primește date noi // SensorManager.SENSOR_DELAY_NORMAL); }} @ Supraveghează void protejat onStop () {super.onStop (); // Înregistrați-vă ascultătorul pentru a păstra resursele de sistem // proximitateSensorManager.unregisterListener (aceasta); } @Substitui public void onSensorChanged (SensorEvent sensorEvent) {// Valoarea curentă a senzorului // float currentValue = sensorEvent.values; // Recuperați „string_sensor” șir, introduceți noua valoare și actualizați TextView // proximitateTextView.setText (getResources (). GetString (R.string.proximity_sensor, currentValue)); } @Override // Dacă precizia senzorului se schimbă ... .// public void onAccarityChanged (Senzor senzor, int i) {//...TO DO //}}

Testare: Cât de aproape este utilizatorul de dispozitivul său?

Pentru a pune această aplicație la încercare pe un smartphone sau tabletă Android fizic, instalați aplicația pe dispozitivul dvs. și apoi experimentați mișcându-vă mâna spre ecran, apoi îndepărtându-o din nou. Valoarea „Senzor de proximitate” ar trebui să vă înregistreze mișcările.

Doar fiți conștienți că senzorii de proximitate pot varia între dispozitive. Unele dispozitive pot afișa doar două valori de proximitate - una pentru a indica „Aproape” și una pentru a indica „Departe”, astfel încât să nu fii surprins dacă nu vezi multă varietate pe dispozitivul tău fizic Android.

Pentru a testa această aplicație pe un emulator:

• Instalați aplicația pe un AVD.
• Găsiți butonul „Mai mult” cu trei puncte și dați-i un clic, care lansează fereastra „Control extins”.
• În meniul din stânga ferestrei, selectați „Senzori virtuali”.
• Selectați fila „Senzori suplimentari”.
• Găsiți glisorul „Proximitate” și trageți-l la stânga și la dreapta pentru a imula un obiect care se apropie mai mult de dispozitiv, apoi mai departe. Valorile „Senzor de proximitate” ar trebui să se schimbe, pe măsură ce manipulați glisorul.

Puteți descărca proiectul finalizat de pe GitHub.

Senzori de mișcare: procesarea tablourilor multidimensionale

Până în acest moment, ne-am concentrat pe senzori care furnizează un singur element de date, dar există unii senzori care furnizează tablouri multidimensionale pentru fiecare SensorEvent. Acești senzori multidimensionali includ senzori de mișcare, pe care ne vom concentra în această secțiune finală.

Senzorii de mișcare vă pot ajuta:

• Oferiți o metodă alternativă de introducere a utilizatorului. De exemplu, dacă dezvoltați un joc mobil, utilizatorul poate muta personajul său pe ecran prin înclinarea dispozitivului.
• Infer activitatea utilizatorului. Dacă ați creat o aplicație de urmărire a activității, atunci senzorii de mișcare vă pot ajuta să evaluați dacă utilizatorul călătorește într-o mașină, face jogging sau stă la biroul lor.
• Determinați mai exact orientarea.Este posibil să extragem coordonatele din senzorii de mișcare ale unui dispozitiv și apoi să le traducem pe baza sistemului de coordonate a Pământului, pentru a obține o precizie cât mai exactă asupra orientării actuale a dispozitivului.

În această secțiune finală, vom folosi senzorul vectorului de rotație (TYPE_ROTATION_VECTOR). Spre deosebire de senzorii de lumină și de proximitate, acesta este un senzor software care colectează date de la senzorii de accelerometru, magnetometru și giroscop. Deși lucrul cu acest senzor necesită adesea să efectuați conversii și transformări matematice, vă poate oferi, de asemenea, o gamă de informații extrem de precise despre dispozitiv.

Vom crea o aplicație care utilizează senzorul vectorului de rotație pentru a măsura:

• Pas. Aceasta este înclinarea de sus în jos a dispozitivului.
• Roll. Aceasta este înclinarea de la stânga la dreapta a dispozitivului.

Afișare date în timp real și rulare

Deoarece măsurăm două valori, trebuie să creăm două TextViews și două resurse de caractere corespunzătoare:

Deschideți fișierul strings.xml și adăugați următoarele:

MotionSensors Senzor de poziție:% 1 $ .2f Senzor de rulare:% 1 $ .2f Nu este disponibil senzor de mișcare

Utilizarea senzorului vectorului de rotație din aplicația dvs.

Vom reutiliza o parte din cod din aplicațiile noastre anterioare, așadar să ne concentrăm asupra domeniilor în care comunicăm cu senzorul vectorului de rotație, este semnificativ diferit de ceea ce am văzut anterior.

1. Folosiți TYPE_ROTATION_VECTOR

Întrucât lucrăm cu senzorul vectorului de rotație, trebuie să apelăm la metoda getDefaultSensor (), apoi să o transmitem constantă TYPE_ROTATION_VECTOR:

positionSensorManager.getDefaultSensor (Sensor.TYPE_ROTATION_VECTOR);

2. Traduceți datele senzorului

Spre deosebire de senzorii de lumină și de apropiere, senzorii de mișcare returnează tablouri multidimensionale ale valorilor senzorului pentru fiecare SensorEvent. Aceste valori sunt formatate folosind sistemul de coordonate standard „X, Y, Z”, care este calculat în raport cu dispozitivul, atunci când este menținut în mod implicit, orientarea „naturală”.

Android nu schimbă aceste coordonate X, Y și Z pentru a se potrivi cu orientarea curentă a dispozitivului, astfel încât axa „X” va rămâne aceeași indiferent dacă dispozitivul este în mod portret sau peisaj. Când utilizați senzorul vectorului de rotație, poate fi necesar să convertiți datele primite pentru a se potrivi cu rotația curentă a dispozitivului.

Portretul este orientarea implicită pentru majoritatea smartphone-urilor, dar nu ar trebui să presupuneți că acest lucru va fi cazul toate Dispozitive Android, în special tablete. În acest articol, vom folosi o matrice de rotație pentru a traduce datele senzorului din originalul său, dispozitiv sistem de coordonate, la Pamantului sistem de coordonate, care reprezintă mișcarea și poziția dispozitivului în raport cu Pământul. Dacă este necesar, putem reaprovoca datele senzorului, pe baza orientării actuale a dispozitivului.

În primul rând, sistemul de coordonate al dispozitivului este un sistem standard de 3 axe X, Y, Z, unde fiecare punct de pe fiecare dintre cele trei axe este reprezentat de un vector 3D. Aceasta înseamnă că trebuie să creăm un tablou de 9 valori float:

float rotationMatrix = float nou;

Putem trece apoi acest tablou la metoda getRotationMatrix ():

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

Următorul pas este utilizarea metodei SensorManager.remapCoordinateSystem () pentru a recapitula datele senzorului, pe baza orientării actuale a dispozitivului.

Metoda SensorManager.remapCoordinateSystem () ia următoarele argumente:

• Matricea de rotație originală.
• Axele pe care doriți să le reaprimați.
• Matricea pe care o populați cu aceste date noi.

Iată codul pe care îl voi folosi în aplicația mea:

float ajustatRotationMatrix = float nou; SensorManager.remapCoordinateSystem (rotationMatrix, worldAxisX, worldAxisZ, ajustatRotationMatrix);

În cele din urmă, vom apela SensorManager.getOrientation și îi vom spune să utilizezeRotationMatrix:

SensorManager.getOrientation (ajustatRotationMatrix, orientare);

3. Actualizați șirurile marcajului

Întrucât avem două seturi de date (pitch and roll), trebuie să regăsim două șiruri de marcaje separate, să le populăm cu valorile corecte și apoi să actualizăm TextView corespunzător:

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

Afișarea mai multor date despre senzori: cod completat

După efectuarea pașilor de mai sus, Activitatea principală ar trebui să arate așa:

import Android.app.Activitate; 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 extinde Activități de implementare SensorEventListener {private SensorManager motionSensorManager; Private Sensor motionSensor; privat TextView pitchTextView; privat TextView rollTextView; privat static final int SENSOR_DELAY = 500 * 1000; privat static final int FROM_RADS_TO_DEGS = -57; @Override protected void onCreate (Bundle savedInstanceState) {super.onCreate (salvatInstanceState); setContentView (R.layout.activity_main); pitchTextView = (TextView) findViewById (R.id.pitchTextView); rollTextView = (TextView) findViewById (R.id.rollTextView); încercați {motionSensorManager = (SensorManager) getSystemService (Activity.SENSOR_SERVICE); motionSensor = motionSensorManager.getDefaultSensor (Sensor.TYPE_ROTATION_VECTOR); motionSensorManager.registerListener (aceasta, motionSensor, SENSOR_DELAY); } catch (Excepție e) {pitchTextView.setText (R.string.no_sensor); rollTextView.setText (R.string.no_sensor); }} @Substitui public void onAcccisionChanged (Senzor senzor, precizie int) {// Pentru a face //} @ Supraversați public void onSensorChanged (SensorEvent eveniment) {if (event.sensor == motionSensor) {update (event.values); }} private void update (float vectors) {// Calculați matricea de rotație // float rotationMatrix = new float; SensorManager.getRotationMatrixFromVector (rotationMatrix, vectori); int worldAxisX = SensorManager.AXIS_X; int worldAxisZ = SensorManager.AXIS_Z; // Remapturează matricea pe baza orientării actuale a activității // float ajustatRotationMatrix = new float; SensorManager.remapCoordinateSystem (rotationMatrix, worldAxisX, worldAxisZ, ajustatRotationMatrix); // Calculați orientarea dispozitivelor // orientarea flotării = noua plutire; // Furnizați gama de valori float la metoda getOrientation () // SensorManager.getOrientation (ajustatRotationMatrix, orientare); float pitch = orientare * FROM_RADS_TO_DEGS; float roll = orientare * FROM_RADS_TO_DEGS; // Actualizați TextViews cu valorile pitch and roll // pitchTextView.setText (getResources (). GetString (R.string.pitch_sensor, pitch)); rollTextView.setText (getResources (). getString (R.string.roll_sensor, roll)); }}

Puteți descărca proiectul finalizat de pe GitHub.

Testarea aplicației noastre finale pentru senzori Android

Pentru a testa această aplicație cu senzori Android de rotație pe un smartphone sau tabletă Android fizică:

• Instalați aplicația pe dispozitivul dvs.
• Plasați smartphone-ul sau tableta pe o suprafață plană. Rețineți că senzorii de mișcare sunt extrem de sensibili, astfel încât nu este neobișnuit ca un dispozitiv aparent nemișcat să raporteze fluctuațiile valorilor de pas și rulare.
• Pentru a testa tonul, ridicați partea de jos a dispozitivului, astfel încât să se înclină departe de tine. Valoarea tonului ar trebui să se schimbe dramatic.
• Pentru a testa rola, încercați să ridicați partea din stânga a dispozitivului, astfel încât să se înclină spre stânga - urmăriți valoarea respectivă!

Dacă testați proiectul dvs. pe un emulator:

• Instalați aplicația pe AVD.
• Selectați „Mai mult”, care lansează fereastra „Control extins”.
• În meniul din stânga, selectați „Senzori virtuali”.
• Asigurați-vă că este selectată fila „Accelerometer”. Această filă conține controale care pot simula modificările în poziția și orientarea dispozitivului.
• Încercați să experimentați cu diversele glisoare (Rotire: Z-Rot, X-Rot, Y-Rot; și Move: X, Y și Z) și cu diversele butoane „Rotire dispozitiv”, pentru a vedea cum afectează aplicația dvs. „Senzor de rulare ”Și„ Pitch Sensor ”.

Înveliți

În acest articol, am văzut cum să regăsim date din cele trei categorii principale de senzori Android: mediu, poziție și mișcare și cum să monitorizăm aceste date în timp real.

Ați văzut aplicații Android care utilizează senzori în moduri interesante sau unice? Spuneți-ne în comentariile de mai jos!