Share
Aflați cum să utilizați senzorii de mediu Android pentru a detecta informații despre mediul utilizatorului, inclusiv temperatura ambiantă, presiunea, umiditatea și lumina.
Sistemul Android suportă o serie de senzori de dispozitiv, unii implementați în hardware și alții în software. Senzorii de mediu sunt toate caracteristicile hardware, oferind acces la informații despre temperatura ambiantă, presiunea, umiditatea și lumina. Acești senzori revin valorile după cum urmează: temperatura este măsurată în grade Celsius, presiunea atmosferică în millibari hPa, umiditatea relativă a aerului înconjurător ca valoare procentuală și lumina ambientală în unități SI lux. În acest tutorial, vom trece prin procesul de bază pentru utilizarea acestor patru senzori de mediu principali. Nu vom folosi senzorul de temperatură al dispozitivului, deoarece este acum depreciat ca de la Android 4.0.
Există multe aplicații posibile pentru acești senzori, cum ar fi barometrele și termometrele. Este posibil să fi întâlnit deja astfel de aplicații pe Google Play, dar merită să rețineți că este posibil ca acestea să nu implementeze neapărat funcțiile prin utilizarea senzorilor de mediu. De exemplu, aplicațiile meteorologice folosesc frecvent date de locație preluate pe Web pentru a determina informații despre mediul în funcție de locul în care vă aflați.
Deoarece acești senzori sunt furnizați prin intermediul hardware-ului utilizatorilor, suportul diferă între dispozitive și producători. La momentul scrierii, foarte puține telefoane inteligente Android sau tablete suportă toți senzorii de mediu, însă multe dintre cele mai recente modele suportă una sau mai multe dintre acestea. Este esențial să se verifice dacă utilizatorul are senzori speciali și să evitați utilizarea funcționalității care se bazează în totalitate pe acestea. Singura excepție este dacă vă asigurați că numai utilizatorii cu hardware-ul necesar vă pot descărca aplicația - puteți face acest lucru utilizând filtrele pentru o aplicație listată în magazinul Google Play.
Creați un nou proiect Android în Eclipse și dați-i un nume de alegere. Lăsați Eclipse să creeze o activitate principală, deoarece aceasta este singura clasă de care avem nevoie. Pentru codul utilizat în acest tutorial, vizăm Android API nivel 14 (Android 4.0 - Ice Cream Sandwich), dar puteți viza o versiune mai recentă, dacă doriți. Nu este nevoie să modificați fișierul Manifest. Clasa principală de activitate trebuie să aibă următoarea structură inițială, cu numele dvs. de clasă ales:
clasa publică EnvironmentCheckerActivity extinde Activitatea / ** Chemată când activitatea este creată pentru prima dată. * / @Override publică void onCreate (Bundle savedInstanceState) super.onCreate (savedInstanceState); setContentView (R.layout.main);
Vom implementa câteva interfețe, extindeți astfel linia de declarație a claselor de deschidere după cum urmează:
clasa publică EnvironmentCheckerActivity se extinde Activitatea implementează OnClickListener, SensorEventListener
Ascultătorul de clic este destinat interacțiunii utilizatorilor, iar Listenerul de evenimente al senzorului este destinat recepționării datelor de la senzorii dispozitivului. Eclipse ar fi trebuit să furnizeze declarații de import pentru clasele Activitate și Bundle, dar trebuie să adăugați și următoarele elemente în listă:
importați android.content.Context; import șiroid.hardware.Sensor; import android.hardware.SensorEvent; import android.hardware.SensorEventListener; import șiroid.hardware.SensorManager; import șiroid.view.View; importă android.view.View.OnClickListener; import șiroid.widget.Button; import șiroid.widget.TextView; importă android.widget.Toast;
Vom adăuga codul în clasă mai târziu.
Pentru a demonstra procesul de bază pentru utilizarea senzorilor de mediu, vom construi o interfață de utilizator simplă. Aplicația va afișa o listă cu patru butoane, una pentru fiecare senzor pe care îl vom folosi. Când utilizatorul selectează un buton, aplicația va încerca să recupereze informațiile corespunzătoare și să le prezinte într-o vizualizare text. Mai intai, sa definim cateva siruri de text pe care le vom folosi in interfata. Deschideți fișierul "res / values / strings.xml" și editați-l pentru a conține următoarele:
Alegeți din opțiuni pentru a verifica mediul Verificatorul de mediu Temperatura ambientala Ușoară Presiune Umiditate relativă -
Acestea reprezintă titlul, textul introductiv, etichetele de butoane și un substituent pentru vizualizările textului. Vom folosi câteva resurse remarcabile pentru proiectare, dar le puteți omite dacă doriți. Pentru a le folosi, în fiecare dintre folderele desenate ale aplicației, va trebui să creați două fișiere suplimentare, "back.xml" și "btn.xml" (selectați câte un folder desenat și selectați "File"> "New" Fișier ", apoi introduceți numele fișierului). Pentru fișierul "back.xml", introduceți următorul cod:
Pentru fișierul "btn.xml", introduceți următoarele:
Încărcarea din spate este pentru fundalul activității, iar trasabilitatea "btn" este pentru background-urile butonului. Simțiți-vă liber să modificați aceste modele în orice fel doriți - asigurați-vă că le copiați în fiecare folder desenabil din aplicația dvs..
Acum, deschideți fișierul de configurare "principal.xml" al aplicației (res / layout / main.xml). Introduceți o listă de vizualizare și o dispunere liniară după cum urmează:
În interiorul layout-ului liniar, adăugați introducerea, apoi un buton și un text pentru fiecare dintre cei patru senzori:
Fiecare pereche de butoane și text este aproape identică, cu atribute ID pentru a le identifica în codul Java. Desigur, puteți modifica oricare dintre elementele de design, dacă doriți. Aspectul se referă la resursele drawable și Strings.
Deschideți clasa principală a activității aplicației. În partea de sus a declarației de clasă, înainte de metoda "onCreate", adăugați următoarele variabile de instanță:
privat Button ambientBtn, lightBtn, pressureBtn, humidityBtn; privat TextView ambientValue, lightValue, pressureValue, humidityValue;
Acestea reprezintă butoanele și vizualizările de text pe care le-am creat în aspect. Vom folosi un tablou pentru a urmări elementele Text View, deoarece acestea vor fi actualizate cu informații atunci când senzorii îl returnează, deci adăugați următoarea variabilă de matrice:
privat TextView [] valueFields = TextView nou [4];
Acum adăugați aceste constante pentru a se referi la fiecare tip de senzor:
finală privată int AMBIENT = 0; finală privată int LIGHT = 1; finală privată int PRESSURE = 2; final privat int UMIDITATEA = 3;
În cadrul metodei "onCreate", după rândul în care este setată vizualizarea conținutului, preluați o referință la fiecare buton folosind atributele ID pe care le-am inclus în aspect, după cum urmează:
ambientBtn = (buton) findViewById (R.id.ambient_btn); lightBtn = (buton) findViewById (R.id.light_btn); pressureBtn = (buton) findViewById (R.id.pressure_btn); umiditateBtn = (buton) findViewById (R.id.humidity_btn);
Acum, setați fiecare dintre acestea să utilizeze clasa Activitate ca ascultător de clic:
ambientBtn.setOnClickListener (aceasta); lightBtn.setOnClickListener (aceasta); pressureBtn.setOnClickListener (aceasta); humidityBtn.setOnClickListener (aceasta);
Când se apasă aceste butoane, se va executa metoda Activitate "onClick". Apoi, extrageți elementele Text View și adăugați o referință la fiecare în matricele pe care le-am declarat, folosind constantele pentru a specifica fiecare index:
ambientValue = (TextView) findViewById (R.id.ambient_text); valueFields [AMBIENT] = ambientValue; lightValue = (TextView) findViewById (R.id.light_text); valueFields [LIGHT] = lightValue; presiuneValue = (TextView) findViewById (R.id.pressure_text); valueFields [PRESIUNE] = pressureValue; umiditateValue = (TextView) findViewById (R.id.humidity_text); valueFields [UMIDITATE] = humidityValue;
Acum trebuie să furnizăm metoda "onClick", adăugând-o la clasă după metoda "onCreate":
public void onClick (Vizualizare v)
În interiorul metodei, trebuie să determinăm ce buton a fost apăsat pe baza unei condiționări:
dacă (v.getId () == R.id.ambient_btn) // temperatura ambientală altceva dacă (v.getId () == R.id.light_btn) // light altceva dacă (v.getId () == R.id.pressure_btn) // presiune altceva dacă (v.getId () == R.id.humidity_btn) // umiditate
În interiorul fiecăruia vom încerca să preluăm datele de mediu relevante.
În partea de sus a clasei, adăugați câteva variabile pentru procesul de detectare a mediului:
privat SensorManager senseManage; senzor privat envSense;
Înapoi în metoda "onCreate", după codul existent, adăugați următoarele pentru a crea o instanță a clasei Managerului senzorilor:
sensManage = (SensorManager) getSystemService (Context.SENSOR_SERVICE);
Avem nevoie de Managerul senzor pentru toate procesele de detectare a mediului. Îl folosim pentru a extrage senzori specifici. În cadrul procedurii "onClick" "if" pentru temperatura ambientală, încercați să preluați senzorul de temperatură ambiantă după cum urmează:
envSense = sensManage.getDefaultSensor (Sensor.TYPE_AMBIENT_TEMPERATURE);
Acum trebuie să avem grijă de cazurile în care senzorul nu este furnizat de dispozitivul utilizatorului, deci adăugați următorul test:
dacă (envSense == null) Toast.makeText (this.getApplicationContext (), "Ne pare rău - dispozitivul nu are senzor de temperatură ambiantă!", Toast.LENGTH_SHORT) .show ();
Pur și simplu trimitem un mesaj de eroare. Dacă senzorul este prezent, trebuie să ne înregistrăm pentru a primi datele returnate, deci adăugați următoarele după această instrucțiune "if":
altfel senseManage.registerListener (acest lucru, envSense, SensorManager.SENSOR_DELAY_NORMAL);
Acum efectuați același proces pentru fiecare dintre butoanele din metoda "onClick". Pentru butonul de lumină (în instrucțiunea "if" din "onClick"):
envSense = sensManage.getDefaultSensor (Sensor.TYPE_LIGHT); dacă (envSense == null) Toast.makeText (this.getApplicationContext (), "Ne pare rău - dispozitivul nu are un senzor de lumină!", Toast.LENGTH_SHORT) .show (); altfel senseManage.registerListener (acest lucru, envSense, SensorManager.SENSOR_DELAY_NORMAL);
Observați că aici solicităm senzorul "TYPE_LIGHT" și adaptăm mesajul de eroare la tipul de senzor. Pentru butonul de presiune:
envSense = sensManage.getDefaultSensor (Sensor.TYPE_PRESSURE); dacă (envSense == null) Toast.makeText (this.getApplicationContext (), "Ne pare rău - dispozitivul nu are senzor de presiune!", Toast.LENGTH_SHORT) .show (); altfel senseManage.registerListener (acest lucru, envSense, SensorManager.SENSOR_DELAY_NORMAL);
În cele din urmă, în instrucțiunea "if" pentru butonul de umiditate:
envSense = sensManage.getDefaultSensor (Sensor.TYPE_RELATIVE_HUMIDITY); dacă (envSense == null) Toast.makeText (this.getApplicationContext (), "Ne pare rău - dispozitivul nu are un senzor de umiditate!", Toast.LENGTH_SHORT) .show (); altfel senseManage.registerListener (acest lucru, envSense, SensorManager.SENSOR_DELAY_NORMAL);
Pe lângă returnarea datelor despre mediul solicitat, senzorul va returna și datele de precizie. Adăugați la clasă următoarea metodă, care este necesară atunci când implementați interfața de recepționare a evenimentelor senzorilor:
@Override public final void onAccuracyChanged (Sensor senzor, int acuratețea)
În cadrul metodei, începeți să construiți un mesaj cu privire la precizie:
Acuratețea șiruluiMsg = "";
Vom folosi o declarație de comutare pe parametrul de precizie intreg:
comutator (acuratețe) caz SensorManager.SENSOR_STATUS_ACCURACY_HIGH: accuracyMsg = "Senzorul are o precizie mare"; pauză; caz SensorManager.SENSOR_STATUS_ACCURACY_MEDIUM: accuracyMsg = "Senzorul are o precizie medie"; pauză; caz SensorManager.SENSOR_STATUS_ACCURACY_LOW: accuracyMsg = "Senzorul are precizie redusă"; pauză; caz SensorManager.SENSOR_STATUS_UNRELIABLE: accuracyMsg = "Senzorul are o precizie nesigură"; pauză; prestabilit: pauză;
Prindem mesajul la nivelul de precizie al senzorului, folosind clasa Sensor Manager. Afișează precizia atunci când este recepționată după cum urmează, dar după instrucțiunea comutatorului:
Precizia toastuluiToast = Toast.makeText (this.getApplicationContext (), accuracyMsg, Toast.LENGTH_SHORT); accuracyToast.show ();
În cadrul metodei "onAccuracyChanged" puteți determina, de asemenea, tipul senzorului din parametrul trecut dacă este necesar.
Acum putem recupera în cele din urmă datele returnate de la senzori folosind un eveniment Sensor - facem acest lucru în metoda "onSensorChanged", care este, de asemenea, necesară pentru implementarea Interfeței:
@Override public final void onSensorChanged (eveniment SensorEvent)
Evenimentul Sensor returnează datele în moduri diferite, în funcție de tipul de senzor. Pentru toate cele patru tipuri pe care le folosim, este recuperat în același mod, de la primul element dintr-o matrice de valori în virgulă mobilă. Adăugați următoarele în interiorul metodei:
senzor de plutireValue = evenimente.value [0];
Acum vom construi un String de text care include aceste date și îl vom scrie în Vizualizarea Textului relevantă pe care utilizatorul o va vedea. Mai întâi, vom crea o variabilă de vizualizare a textului și îi vom oferi o valoare implicită (această valoare va fi suprascrisă - includeți-o pentru a păstra Eclipse fericită):
TextView currValue = ambientValue;
Apoi, declarăm Stringul:
Şir;
Conținutul String-ului va depinde de tipul de senzor, deci să aflăm care este:
int currType = eveniment.sensor.getType ();
Acum putem folosi o declarație de comutare la această valoare:
comutator (currType) caz Sensor.TYPE_AMBIENT_TEMPERATURE: envInfo = sensorValue + "grade Celsius"; currValue = valueFields [AMBIENT]; pauză; caz Sensor.TYPE_LIGHT: envInfo = sensorValue + "Unități SI lux"; currValue = valueFields [LIGHT]; pauză; caz Sensor.TYPE_PRESSURE: envInfo = sensorValue + "hPa (millibars)"; currValue = valueFields [PRESIUNE]; pauză; caz Sensor.TYPE_RELATIVE_HUMIDITY: envInfo = sensorValue + "umiditate procentuală"; currValue = valueFields [UMIDITATE]; pauză; prestabilit: pauză;
În fiecare caz, construim Stringul informativ folosind valoarea senzorului preluată și un extras text relevant pentru tip. De asemenea, setăm Vizualizarea textului la elementul de interfață utilizator relevant utilizând matricea și constantele. După instrucțiunea comutator, extrageți informațiile:
currValue.setText (envInfo);
Acum, resetați variabila senzorului și opriți ascultarea pentru actualizări pentru a preveni utilizarea inutilă a bateriei:
envSense = null; senseManage.unregisterListener (aceasta);
În cele din urmă, nu vrem ca aplicația să utilizeze resurse inutile atunci când este întreruptă, deci adăugați această metodă la clasă:
@Override protejat void onPause () super.onPause (); senseManage.unregisterListener (aceasta);
Aceasta este aplicația demonstrativă completă! Nu are nici un rost să rulați această aplicație pe emulatorul implicit Android, deoarece nu oferă senzori de mediu. Cu toate acestea, puteți fie să o rulați pe un dispozitiv real, fie să utilizați instrumentul Simulator senzor, care vă permite să simulați anumite aspecte ale mediului. Următoarea este o captură de ecran a aplicației care rulează pe Samsung Galaxy S III imediat după preluarea datelor de lumină și presiune:
Aici este vorba despre ceilalți doi senzori, care nu sunt susținuți:
Senzorii de mediu sunt o caracteristică interesantă, dar în continuă dezvoltare a platformei Android. Cu toate acestea, este destul de devreme să ne concentrăm asupra lor. Dacă doriți să explorați utilizarea acestor senzori în moduri mai avansate, consultați secțiunea Ghidul dezvoltatorului privind calculul nivelului de rouă și a nivelului de umiditate absolută pe baza umidității relative și a temperaturii ambientale. În afară de asta - încercați să fiți răbdători!
Accentsconagua