Nilalaman

• Anong mga sensor ng Android ang magagamit ko?
• Mga sensor sa kapaligiran: Pagsukat ng nakapaligid na ilaw
• Ipinapakita ang data ng iyong sensor
• Nakikipag-usap sa isang sensor: SensorManager, SensorEvents, at tagapakinig
• 1. Kumuha ng isang halimbawa ng SensorManager
• 2. Kumuha ng isang sanggunian sa lightTextView
• 3. Suriin kung umiiral ang sensor sa kasalukuyang aparato
• 4. Irehistro ang iyong mga tagapakinig ng sensor
• 5. Ipatupad ang mga callback ng SensorEventListener
• onSensorChanged ()
• onAccuracyChanged ()
• 6. Kunin ang halaga ng sensor
• 7. I-unregister ang iyong mga tagapakinig
• Gamit ang mga light sensor ng Android: Nakumpleto na code
• Subukan ang iyong nakumpletong Android sensor app
• Pagsukat ng distansya, na may mga malapit na sensor ng Android
• Paglikha ng interface ng gumagamit
• Pagkuha ng data mula sa proximity sensor
• Pagsubok: Gaano kalapit ang gumagamit sa kanilang aparato?
• Ang mga sensor ng Paggalaw: Pagproseso ng mga multidimensional na arrays
• Nagpapakita ng real time pitch at roll data
• Gamit ang rotation vector sensor sa iyong app
• 1. Gumamit ng TYPE_ROTATION_VECTOR
• 2. Isalin ang data ng sensor
• 3. I-update ang mga string ng placeholder
• Ipinapakita ang maraming data ng sensor: Nakumpleto na code
• Pagsubok sa aming pangwakas na application ng Android sensor
• Pagputol

Sa ngayon, ang karamihan sa mga modernong aparato ng Android ay nilalabas ng isang grupo ng mga sensor.

Maaari mong gamitin ang impormasyong ito sa maraming iba't ibang mga paraan - kung ang antas ng ilaw sa pagsubaybay upang ang iyong aplikasyon ay maaaring awtomatikong ayusin ang ningning o kulay na scheme nito; nagpapahintulot sa gumagamit na makipag-ugnay sa iyong mobile na laro gamit ang mga kilos tulad ng pagtagilid sa kanilang aparato; o gamit ang proximity sensor upang awtomatikong huwag paganahin ang mga kaganapan sa pagpindot sa tuwing hinawakan ng gumagamit ang kanilang aparato sa kanilang tainga.

Sa artikulong ito, gagawa kami ng tatlong mga application na makukuha ang ilaw, kalapitan at data ng paggalaw mula sa isang hanay ng mga sensor ng hardware at software. Susubaybayan din namin ang mga sensor ng Android na ito sa tunay na oras, kaya laging naka-access ang iyong application sa pinakabagong impormasyon.

Sa pagtatapos ng artikulong ito, malalaman mo kung paano kunin ang isang solong piraso ng data mula sa isang sensor ng Android, at kung paano mahawakan ang mga sensor na nagbibigay ng kanilang data sa anyo ng isang multidimensional na hanay.

Anong mga sensor ng Android ang magagamit ko?

Ang mga sensor ng Android ay maaaring nahahati sa mga sumusunod na kategorya:

• Mga sensor sa kapaligiran. Sinusukat nito ang mga kondisyon ng kapaligiran, tulad ng temperatura ng hangin, presyon, kahalumigmigan at mga antas ng ilaw sa paligid.

• Mga sensor ng posisyon. Kasama sa kategoryang ito ang mga sensor na sumusukat sa posisyon ng pisikal na aparato, tulad ng mga proximity sensor at geomagnetic field sensor.
  Mga sensor ng paggalaw. Sinusukat ng mga sensor na ito ang paggalaw ng aparato, at kasama ang mga accelerometer, gravity sensor, gyroscope, at mga sensor ng vector ng pag-ikot.

Bilang karagdagan, ang mga sensor ay maaaring maging:

• Batay sa Hardware. Ito ay mga pisikal na sangkap na itinayo sa aparato at direktang sukatin ang mga tiyak na mga katangian, tulad ng pagpabilis o ang lakas ng nakapaligid na mga patlang na geomagnetic.
• Nakabatay sa software, kung minsan ay kilala bilang virtual sensor o mga composite sensor. Ang mga ito ay karaniwang nagtitipon ng data mula sa maraming mga sensor na nakabase sa hardware. Sa pagtatapos ng artikulong ito, magtatrabaho kami kasama ang rotation vector sensor, na isang sensor ng software na pinagsasama ang data mula sa accelerometer, magnetometer, at dyayroskop.

Mga sensor sa kapaligiran: Pagsukat ng nakapaligid na ilaw

Sinusukat ng light sensor ng Android ang nakapaligid na ilaw sa mga yunit na "lux", na kung saan ay ang intensity ng ilaw na nakikita ng mata ng tao. Ang kahalagahan ng maluho na iniulat ng isang sensor ay maaaring magkakaiba sa lahat ng mga aparato, kaya kung ang iyong aplikasyon ay nangangailangan ng pare-pareho na mga halaga, maaaring kailanganin mong manipulahin ang raw data bago gamitin ito sa iyong aplikasyon.

Sa seksyong ito, gagawa kami ng isang application na makukuha ang kasalukuyang halaga ng lux mula sa light sensor ng aparato, ipinapakita ito sa isang TextView, at pagkatapos ay mai-update ang TextView habang magagamit ang mga bagong data.Pagkatapos ay maaari mong gamitin ang impormasyong ito sa isang hanay ng mga app, halimbawa maaari kang lumikha ng isang application ng sulo na kumukuha ng impormasyon mula sa light sensor at pagkatapos ay awtomatikong inaayos ang lakas ng beam nito batay sa kasalukuyang mga antas ng ilaw.

Lumikha ng isang bagong proyekto sa Android kasama ang mga setting ng iyong napili, at magsimula!

Ipinapakita ang data ng iyong sensor

Magdadagdag ako ng isang TextView na sa huli ay ipapakita ang data na nakuha namin mula sa light sensor. Ang pag-update ng TextView na ito ay magagamit kapag ang bagong data ay magagamit, kaya laging gumagamit ang access sa pinakabagong impormasyon.

Buksan ang file ng activity_main.xml ng iyong proyekto, at idagdag ang sumusunod:

Susunod, kailangan nating lumikha ng "light_sensor" na mapagkukunan ng string na tinukoy sa aming layout. Buksan ang file ng strings.xml ng iyong proyekto, at idagdag ang sumusunod:

Banayad na Sensor:% 1 $ .2f

Ang "% 1 $ .2f" ay isang placeholder na tumutukoy sa impormasyong nais naming ipakita, at kung paano ito dapat na na-format:

• %1. Maaari kang magpasok ng maraming mga placeholder sa parehong mapagkukunan ng string; Ang "% 1" ay nagpapahiwatig na gumagamit kami ng isang nag-iisang placeholder.
• $.2. Tinukoy nito kung paano dapat i-format ang aming aplikasyon sa bawat papasok na halaga ng lumulutang-point. Ang "$ .2" ay nagpapahiwatig na ang halaga ay dapat na bilugan sa dalawang lugar na desimal.
• F. I-format ang halaga bilang isang lumulutang na point number.

Habang ang ilang mga sensor ay mas karaniwan kaysa sa iba, hindi mo dapat ipagpalagay na ang bawat aparato ay may access sa eksaktong parehong hardware at software. Ang kakayahang magamit ng sensor ay maaari ring mag-iba sa iba't ibang mga bersyon ng Android, dahil ang ilang mga sensor ay hindi ipinakilala hanggang sa paglaon ng paglabas ng platform ng Android.

Maaari mong suriin kung ang isang partikular na sensor ay naroroon sa isang aparato, gamit ang balangkas ng sensor ng Android. Pagkatapos ay maaari mong paganahin o paganahin ang mga bahagi ng iyong aplikasyon batay sa pagkakaroon ng sensor, o maaari mong ipakita ang isang pagpapaliwanag na ang ilan sa mga tampok ng iyong aplikasyon ay hindi gagana tulad ng inaasahan.

Habang binuksan namin ang aming strings.xml file, gumawa tayo ng isang "no_sensor" string, na ipapakita namin kung hindi magagamit ang light sensor:

Walang magagamit na light sensor

Kung ang iyong aplikasyon ay hindi maaaring magbigay ng isang mahusay na karanasan ng gumagamit nang hindi pagkakaroon ng pag-access sa isang partikular na sensor, pagkatapos ay kailangan mong idagdag ang impormasyong ito sa iyong Manifest. Halimbawa, kung ang iyong app ay nangangailangan ng pag-access sa isang sensor ng compass, pagkatapos ay maaari mong gamitin ang sumusunod:

Ngayon, maaari lamang mai-download ang iyong app sa mga aparato na may sensor sensor.

Habang ito ay maaaring limitahan ang iyong mga tagapakinig, mas mababa ang pinsala kaysa sa pagpapahintulot sa isang tao na i-download ang iyong aplikasyon kapag sila garantisado magkaroon ng masamang karanasan, dahil sa pagsasaayos ng sensor ng kanilang aparato.

Nakikipag-usap sa isang sensor: SensorManager, SensorEvents, at tagapakinig

Upang makipag-usap sa light sensor ng aparato, kailangan mong kumpletuhin ang mga sumusunod na hakbang:

1. Kumuha ng isang halimbawa ng SensorManager

Nagbibigay ang SensorManager ng lahat ng mga pamamaraan na kailangan mo upang ma-access ang buong saklaw ng mga sensor.

Upang magsimula, lumikha ng isang variable na kukuha ng isang halimbawa ng SensorManager:

pribadong SensorManager lightSensorManager;

Pagkatapos, kailangan mong makakuha ng isang halimbawa ng SensorManager, sa pamamagitan ng pagtawag sa pamamaraan ng Konteksto.getSystemService at pagpasa sa argument na Context.SENSOR_SERVICE:

lightSensorManager = (SensorManager) kumuhaSystemService (Konteksto.SENSOR_SERVICE);

2. Kumuha ng isang sanggunian sa lightTextView

Susunod, kailangan nating lumikha ng isang variable ng pribadong miyembro na kukuha ng aming mga bagay sa TextView, at italaga ito sa aming TextView:

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

3. Suriin kung umiiral ang sensor sa kasalukuyang aparato

Maaari kang makakuha ng access sa isang partikular na sensor sa pamamagitan ng pagtawag ng getDefaultSensor () na pamamaraan, at pagkatapos ay ipasa ang sensor na pinag-uusapan. Ang uri ng pare-pareho para sa light sensor ay TYPE_LIGHT, kaya kailangan naming gamitin ang sumusunod:

lightSensor = lightSensorManager.getDefaultSensor (Sensor.TYPE_LIGHT);

Kung wala ang sensor sa device na ito, ang paraan ng getDefaultSensor () ay babalik, at ipapakita namin ang "no_sensor" string:

String sensor_error = getRes Pinagmulan (). GetString (R.string.no_sensor); kung (lightSensor == null) {lightTextView.setText (sensor_error); }}

4. Irehistro ang iyong mga tagapakinig ng sensor

Sa bawat oras na ang isang sensor ay may bagong data, ang Android ay bumubuo ng isang bagay na SensorEvent. Ang bagay na SensorEvent na ito ay nagsasama ng sensor na nabuo ang kaganapan, isang timestamp, at ang bagong halaga ng data.

Sa una, tututuon namin ang ilaw at mga malapit na sensor, na nagbabalik ng isang solong piraso ng data. Gayunpaman, ang ilang mga sensor ay nagbibigay ng mga multidimensional na arrays para sa bawat SensorEvent, kasama na ang sensor ng vector ng rotation, na aming sasaliksikin sa pagtatapos ng artikulong ito.

Upang matiyak na ang aming aplikasyon ay inaalam tungkol sa mga bagay na SensorEvent, kailangan naming magrehistro ng isang tagapakinig para sa tiyak na kaganapan ng sensor, gamit ang SensorManager's registerListener ().

Ang paraan ng rehistrador () ay tumatagal ng mga sumusunod na argumento:

• Isang app o Konteksto ng Aktibidad.
• Ang uri ng Sensor na nais mong subaybayan.
• Ang rate kung saan ang sensor ay dapat magpadala ng bagong data. Ibibigay ng isang mas mataas na rate ang iyong aplikasyon ng maraming data, ngunit gagamitin din nito ang maraming mga mapagkukunan ng system, lalo na ang buhay ng baterya. Upang makatulong na mapanatili ang baterya ng aparato, dapat mong hilingin ang minimum na halaga ng data na kinakailangan ng iyong aplikasyon. Gagamit ako ng SensorManager.SENSOR_DELAY_NORMAL, na nagpapadala ng bagong data minsan sa bawat 200,000 microsecond (0.2 segundo).

Dahil ang pakikinig sa isang sensor ay nagpapatalsik ng baterya ng aparato, hindi ka dapat magrehistro sa mga tagapakinig sa pamamaraan ng onCreate () ng iyong aplikasyon, dahil ito ay magiging sanhi ng mga sensor na magpatuloy sa pagpapadala ng data, kahit na nasa background ang iyong aplikasyon.

Sa halip, dapat mong irehistro ang iyong mga sensor sa onStart () paraan ng lifecycle ng application:

Protektado ng @Override na walang bisa saStart () {super.onStart (); // Kung ang sensor ay magagamit sa kasalukuyang aparato ... // kung (lightSensor! = Null) {//….tapos simulan ang pakikinig // lightSensorManager.registerListener (ito, lightSensor, SensorManager.SENSOR_DELAY_NORMAL); }}

5. Ipatupad ang mga callback ng SensorEventListener

Ang SensorEventListener ay isang interface na nakakatanggap ng mga abiso mula sa SensorManager
tuwing magagamit ang mga bagong data, o nagbabago ang kawastuhan ng sensor.

Ang unang hakbang, ay binabago ang aming lagda sa klase upang maipatupad ang interface ng SensorEventListener:

pampublikong klase MainActivity ay nagpapalawak ng AppCompatActivity nagpapatupad ng SensorEventListener {

Pagkatapos ay kailangan nating ipatupad ang mga sumusunod na pamamaraan ng callback:

onSensorChanged ()

Ang pamamaraang ito ay tinawag bilang tugon sa bawat bagong SensorEvent.

Ang data ng sensor ay maaaring madalas na magbago nang mabilis, kaya ang iyong aplikasyon ay maaaring tumatawag sa onSensorChanged () na pamamaraan sa isang regular na batayan. Upang matulungan ang iyong application na tumatakbo nang maayos, dapat kang magsagawa ng kaunting trabaho hangga't maaari sa loob ng onSensorChanged () na pamamaraan.

@Override pampublikong walang bisa saSensorChanged (SensorEvent sensorEvent) {// To do //}

onAccuracyChanged ()

Kung ang katumpakan ng sensor ay nagpapabuti o tumanggi, tatawagin ng Android ang pamamaraan na OnAccuracyChanged () at ipasa ito ng isang sensor ng Sensor na naglalaman ng bagong halaga ng kawastuhan, tulad ng SENSOR_STATUS_UNRELIABLE o SENSOR_STATUS_ACCURACY_HIGH.

Ang light sensor ay hindi nag-uulat ng mga pagbabago sa kawastuhan, kaya maiiwan ko ang onAccuracyChanged () callback na walang laman:

@Override pampublikong walang bisa saAccuracyChanged (Sensor sensor, int i) {// To do //}}

6. Kunin ang halaga ng sensor

Sa tuwing mayroon tayong bagong halaga, kailangan nating tawagan ang onSensorChanged () na pamamaraan, at kunin ang "light_sensor" string. Maaari naming mai-override ang teksto ng placeholder ng string (% 1 $ .2f) at ipakita ang na-update na string bilang bahagi ng aming TextView:

@Override pampublikong walang bisa saSensorChanged (SensorEvent sensorEvent) {// Ang halaga ng sensor // lumutang kasalukuyangValue = sensorEvent.values; // Kunin ang string na "light_sensor", ipasok ang bagong halaga at ipakita ito sa gumagamit // lightTextView.setText (getRes Source (). GetString (R.string.light_sensor, currentValue)); }

7. I-unregister ang iyong mga tagapakinig

Ang mga sensor ay maaaring makabuo ng maraming data sa isang maliit na oras, upang makatulong na mapanatili ang mga mapagkukunan ng aparato ay kakailanganin mong i-unregister ang iyong mga tagapakinig kapag hindi na nila kailangan.

Upang ihinto ang pakikinig para sa mga kaganapan ng sensor kapag nasa background ang iyong aplikasyon, magdagdag ng unregisterListener () sa pamamaraan ng lifecycle ng iyong proyekto:

Protektado ng @Override na walang bisa saStop () {super.onStop (); ilawSensorManager.unregisterListener (ito); }

Tandaan na hindi mo dapat i-unregister ang iyong mga tagapakinig sa onPause (), tulad ng sa Android 7.0 at mas mataas na application ay maaaring tumakbo sa split-screen at picture-in-picture mode, kung saan sila ay nasa isang naka-pause na estado, ngunit mananatiling nakikita sa onscreen.

Gamit ang mga light sensor ng Android: Nakumpleto na code

Matapos makumpleto ang lahat ng mga hakbang sa itaas, ang MainActivity ng iyong proyekto ay dapat magmukhang katulad nito:

i-import ang android.support.v7.app.AppCompatActivity; i-import ang android.os.Bundle; mag-import ng android.content.Context; mag-import ng android.hardware.Sensor; i-import ang android.hardware.SensorEvent; i-import ang android.hardware.SensorEventListener; i-import ang android.hardware.SensorManager; mag-import ng android.widget.TextView; pampublikong klase na MainActivity ay nagpapalawak ng AppCompatActivity // Ipatupad ang interface ng SensorEventListener // ipinatutupad ang SensorEventListener {// Lumikha ng iyong variable / pribadong Sensor lightSensor; pribadong SensorManager lightSensorManager; pribadong TextView lightTextView; Protektado ng @Override na walang bisa saCreate (Bundle saveInstanceState) {super.onCreate (saveInstanceState); setContentView (R.layout.activity_main); lightTextView = (TextView) findViewById (R.id.lightTextView); // Kumuha ng isang halimbawa ng SensorManager // lightSensorManager = (SensorManager) getSystemService (Context.SENSOR_SERVICE); // Suriin para sa isang light sensor // lightSensor = lightSensorManager.getDefaultSensor (Sensor.TYPE_LIGHT); // Kung wala ang ilaw sensor, pagkatapos ay magpakita ng error // String sensor_error = getRes Source (). GetString (R.string.no_sensor); kung (lightSensor == null) {lightTextView.setText (sensor_error); }} @Override protektado walang bisa saStart () {super.onStart (); // Kung ang sensor ay magagamit sa kasalukuyang aparato ... // kung (lightSensor! = Null) {//….tapos magrehistro ng isang nakikinig // lightSensorManager.registerListener (ito, lightSensor, // Tukuyin kung gaano kadalas ang nais mong makatanggap ng bagong data // SensorManager.SENSOR_DELAY_NORMAL); }} @Override protektado walang bisa saStop () {super.onStop (); // Unregister iyong tagapakinig // lightSensorManager.unregisterListener (ito); } @Override pampublikong walang bisa saSensorChanged (SensorEvent sensorEvent) {// Ang halaga ng sensor // float currentValue = sensorEvent.values; // Kunin ang string na "light_sensor", ipasok ang bagong halaga at i-update ang TextView // lightTextView.setText (getRes Source (). GetString (R.string.light_sensor, currentValue)); } @Override // Kung nagbago ang kawastuhan ng sensor .... .// pampublikong walang bisa saAccuracyChanged (Sensor sensor, int i) {// TO GAWIN //}}

Subukan ang iyong nakumpletong Android sensor app

Upang subukan ang application na ito sa isang pisikal na Android smartphone o tablet:

• I-install ang proyekto sa iyong aparato (sa pamamagitan ng pagpili ng "Run> Run" mula sa tool ng Android Studio).
• Bagaman nag-iiba ito sa pagitan ng mga aparato, ang light sensor ay madalas na matatagpuan sa kanang itaas ng screen. Upang manipulahin ang mga antas ng ilaw, ilipat ang iyong aparato nang mas malapit, at pagkatapos ay malayo sa isang ilaw na mapagkukunan. Bilang kahalili, maaari mong subukang takpan ang aparato gamit ang iyong kamay, upang harangan ang ilaw. Ang halaga ng "Light Sensor" ay dapat dagdagan at bawasan, depende sa dami ng magagamit na ilaw.

Kung gumagamit ka ng isang Android Virtual Device (AVD), pagkatapos ang emulator ay may isang hanay ng mga virtual control control na maaari mong magamit upang gayahin ang iba't ibang mga kaganapan ng sensor. Na-access mo ang mga virtual sensor na kontrol, sa pamamagitan ng window ng "Extended Controls" ng emulator:

• I-install ang application sa iyong AVD.
• Sa tabi ng AVD, makikita mo ang isang guhit ng mga pindutan. Hanapin ang tatlong dotted na "Higit pang" pindutan (kung saan ang cursor ay nakaposisyon sa sumusunod na screenshot) at bigyan ito ng isang pag-click. Inilunsad nito ang window na "Pinahabang Kontrol".

• Sa kaliwang menu, piliin ang "Virtual sensor."
• Piliin ang tab na "Mga karagdagang sensor." Ang tab na ito ay naglalaman ng iba't ibang mga slider na magagamit mo upang gayahin ang iba't ibang posisyon at mga kaganapan sa sensor ng kapaligiran.

• Hanapin ang "Light (lux)" na slider at i-drag ito pakaliwa at pakanan, upang mabago ang simulate na antas ng ilaw. Dapat ipakita ng iyong application ang mga nagbabagong halaga, sa real time.

Maaari mong i-download ang nakumpletong proyekto mula sa GitHub.

Pagsukat ng distansya, na may mga malapit na sensor ng Android

Ngayon nakita namin kung paano makuha ang impormasyon mula sa isang sensor sa kapaligiran, tingnan natin kung paano mo mailalapat ang kaalamang ito sa isang posisyon sensor.

Sa seksyong ito, gagamitin namin ang proximity sensor ng aparato upang masubaybayan ang distansya sa pagitan ng iyong smartphone o tablet, at iba pang mga bagay. Kung ang iyong aplikasyon ay may anumang uri ng pag-andar ng boses, maaaring matulungan ka ng proximity sensor na matukoy kung kailan gaganapin ang smartphone sa tainga ng gumagamit, halimbawa kapag nakikipag-usap sila sa telepono. Pagkatapos ay maaari mong gamitin ang impormasyong ito upang hindi paganahin ang mga kaganapan sa pag-ugnay, kaya hindi sinasadyang mag-hang ang gumagamit, o mag-trigger ng iba pang hindi ginustong mga kaganapan sa kalagitnaan ng pag-uusap.

Paglikha ng interface ng gumagamit

Ipapakita ko ang onscreen ng data ng kalapitan, upang mapanood mo itong mai-update sa real time. Upang makatulong na gawing simple ang mga bagay, muling gamitin ang karamihan sa layout mula sa aming nakaraang aplikasyon:

Susunod, buksan ang iyong strings.xml file at lumikha ng isang "proximity_sensor" string. Muli, ang string na ito ay kailangang maglaman ng isang placeholder, na sa kalaunan ay mapapaligiran ng data na nakuha mula sa proximity sensor:

Ang ProximitySensor Ang Proximity Sensor:% 1 $ .2f Walang magagamit na sensor ng kalapitan

Pagkuha ng data mula sa proximity sensor

Katulad sa light sensor, ang proximity sensor ng Android ay nagbabalik ng isang solong halaga ng data, na nangangahulugang maaari naming muling magamit ang karamihan sa code mula sa aming nakaraang aplikasyon. Gayunpaman, may ilang mga pangunahing pagkakaiba, kasama ang ilang mga pagbabago na nauugnay sa pangalan na ginagawang mas madaling sundin ang code na ito:

• Lumikha ng isang halimbawa ng SensorManager, na oras na ito sa paligid ay tatawagin ko ang "kalapitanSensorManager."
• Kumuha ng isang halimbawa ng "kalapitanSensorManager."
• Lumikha ng isang sanggunian sa "kalapitanTextView."
• Tawagan ang paraan ng getDefaultSensor (), at ipasa ito ang sensor ng TYPE_PROXIMITY.
• Magrehistro at unregister mga tagapakinig para sa proximity sensor.

Matapos gawin ang mga pag-tweak na ito, dapat mong tapusin ang mga sumusunod:

i-import ang android.support.v7.app.AppCompatActivity; i-import ang android.os.Bundle; mag-import ng android.content.Context; mag-import ng android.hardware.Sensor; i-import ang android.hardware.SensorEvent; i-import ang android.hardware.SensorManager; i-import ang android.hardware.SensorEventListener; mag-import ng android.widget.TextView; pampublikong klase na MainActivity ay nagpapalawak ng AppCompatActivity // Ipatupad ang interface ng SensorEventListener // ipinatutupad ang SensorEventListener {// Lumikha ng iyong mga variable / pribadong proximitySensor; pribadong SensorManager proximitySensorManager; pribadong TextView proximityTextView; Protektado ng @Override na walang bisa saCreate (Bundle saveInstanceState) {super.onCreate (saveInstanceState); setContentView (R.layout.activity_main); kalapitanTextView = (TextView) mahanapViewById (R.id.proximityTextView); // Kumuha ng isang halimbawa ng SensorManager // proximitySensorManager = (SensorManager) getSystemService (Context.SENSOR_SERVICE); // Suriin para sa isang proximity sensor // proximitySensor = proximitySensorManager.getDefaultSensor (Sensor.TYPE_PROXIMITY); // Kung wala ang proximity sensor, pagkatapos ay magpakita ng error // String sensor_error = getRes Source (). GetString (R.string.no_sensor); kung (proximitySensor == null) {proximityTextView.setText (sensor_error); }} @Override protektado walang bisa saStart () {super.onStart (); // Kung ang sensor ay magagamit sa kasalukuyang aparato ... // kung (proximitySensor! = Null) {//….tapos magparehistro ng isang nakikinig // proximitySensorManager.registerListener (ito, proximitySensor, // Tukuyin kung gaano kadalas mong nais makatanggap ng bagong data // SensorManager.SENSOR_DELAY_NORMAL); }} @Override protektado walang bisa saStop () {super.onStop (); // Unregister iyong tagapakinig upang mapanatili ang mga mapagkukunan ng system // proximitySensorManager.unregisterListener (ito); } @Override pampublikong walang bisa saSensorChanged (SensorEvent sensorEvent) {// Ang halaga ng sensor // float currentValue = sensorEvent.values; // Kunin ang string na "proximity_sensor", ipasok ang bagong halaga at i-update ang TextView // proximityTextView.setText (getRes Source (). GetString (R.string.proximity_sensor, kasalukuyangValue)); } @Override // Kung nagbago ang katumpakan ng sensor ..... Pampublikong walang bisa saAccuracyChanged (Sensor sensor, int i) {//...TO GAWIN //}}

Pagsubok: Gaano kalapit ang gumagamit sa kanilang aparato?

Upang ilagay ang application na ito sa pagsubok sa isang pisikal na Android smartphone o tablet, i-install ang application sa iyong aparato at pagkatapos ay mag-eksperimento sa pamamagitan ng paglipat ng iyong kamay patungo sa screen, at pagkatapos ay ilipat muli ito. Ang halaga ng "Proximity Sensor" ay dapat irekord ang iyong mga paggalaw.

Basta magkaroon ng kamalayan na ang mga malapit na sensor ay maaaring mag-iba sa pagitan ng mga aparato. Ang ilang mga aparato ay maaaring magpakita lamang ng dalawang mga halagang malapit - isa upang ipahiwatig ang "Malapit" at isa upang ipahiwatig ang "Malayo" - kaya huwag magulat kung hindi ka nakakakita ng maraming pagkakaiba-iba sa iyong pisikal na aparato ng Android.

Upang subukan ang application na ito sa isang emulator:

• I-install ang iyong aplikasyon sa isang AVD.
• Hanapin ang tatlong dotted na "Higit pang" pindutan at bigyan ito ng isang pag-click, na naglulunsad ng "Extended Controls" window.
• Sa menu ng kaliwang kamay ng window, piliin ang "Virtual sensor."
• Piliin ang tab na "Mga karagdagang sensor."
• Hanapin ang "Lapit ng slider", at i-drag ito pakaliwa at pakanan upang tularan ang isang bagay na lumapit sa aparato, at pagkatapos ay malayo pa. Ang mga halaga ng "Proximity Sensor" ay dapat magbago, dahil manipulahin mo ang slider.

Maaari mong i-download ang nakumpletong proyekto mula sa GitHub.

Ang mga sensor ng Paggalaw: Pagproseso ng mga multidimensional na arrays

Hanggang sa puntong ito, nakatuon kami sa mga sensor na nagbibigay ng isang solong item ng data, ngunit may ilang mga sensor na nagbibigay ng mga multidimensional na mga arrays para sa bawat SensorEvent. Ang mga multidimensional sensor na ito ay nagsasama ng mga sensor ng paggalaw, na tututuon namin sa panghuling seksyon na ito.

Ang mga sensor ng paggalaw ay makakatulong sa iyo:

• Magbigay ng isang alternatibong paraan ng pag-input ng gumagamit. Halimbawa, kung ikaw ay bubuo ng isang mobile na laro pagkatapos ay maaaring ilipat ng gumagamit ang kanilang karakter sa paligid ng screen sa pamamagitan ng pagtagilid ng kanilang aparato.
• Mas kaunting aktibidad ng gumagamit. Kung nakagawa ka ng isang app sa pagsubaybay sa aktibidad, ang mga paggalaw ng sensor ay makakatulong sa iyo na masukat kung naglalakbay ang gumagamit sa isang kotse, jogging, o pag-upo sa kanilang desk.
• Mas tumpak na matukoy ang orientation.Posible na kunin ang mga coordinate mula sa mga sensor ng paggalaw ng aparato, at pagkatapos ay isalin ang mga ito batay sa sistema ng coordinate ng Earth, upang makuha ang pinaka tumpak na pananaw sa kasalukuyang orientation ng aparato.

Sa huling bahagi na ito, gumagamit kami ng sensor ng vector ng pag-ikot (TYPE_ROTATION_VECTOR). Hindi tulad ng ilaw at proximity sensor, ito ay isang sensor ng software na nagtitipon ng data mula sa accelerometer, magnetometer, at sensor ng gyroscope. Kahit na ang pagtatrabaho sa sensor na ito ay madalas na nangangailangan sa iyo upang magsagawa ng mga pagbabagong matematika at pagbabagong-anyo, maaari ka ring magbigay sa iyo ng isang saklaw ng lubos na tumpak na impormasyon tungkol sa aparato.

Lumilikha kami ng isang application na gumagamit ng sensor ng vector ng pag-ikot upang masukat:

• Pitch. Ito ang top-to-bottom na ikiling ng aparato.
• Gumulong. Ito ang kaliwa-kanan-ikiling ng aparato.

Nagpapakita ng real time pitch at roll data

Dahil sinusukat namin ang dalawang sukatan, kailangan naming lumikha ng dalawang TextViews at dalawang kaukulang mapagkukunan ng string:

Buksan ang file ng strings.xml, at idagdag ang sumusunod:

MotionSensors Sensor ng Pitch:% 1 $ .2f Roll Sensor:% 1 $ .2f Walang magagamit na sensor sensor

Gamit ang rotation vector sensor sa iyong app

Gagamitin namin muli ang ilan sa code mula sa aming mga naunang aplikasyon, kaya't ituon ang pansin sa mga lugar kung saan nakikipag-usap sa rotation vector sensor, ay naiiba sa kakaibang nakita.

1. Gumamit ng TYPE_ROTATION_VECTOR

Dahil nagtatrabaho kami sa sensor ng vector ng pag-ikot, kailangan naming tawagan ang paraan ng getDefaultSensor (), at pagkatapos ay ipasa ito ang TYPE_ROTATION_VECTOR na palagi:

posisyonSensorManager.getDefaultSensor (Sensor.TYPE_ROTATION_VECTOR);

2. Isalin ang data ng sensor

Hindi tulad ng nakaraang mga sensor ng ilaw at proximity, ang mga sensor ng paggalaw ay nagbabalik ng maraming mga pagdaragdag ng mga nadarama ng sensor para sa bawat SensorEvent. Ang mga halagang ito ay na-format gamit ang pamantayang sistemang coordinate ng "X, Y, Z", na kinakalkula na nauugnay sa aparato kapag gaganapin ito sa default, "natural" na oryentasyon.

Hindi pinapalitan ng Android ang mga coordinate ng X, Y at Z na ito upang tumugma sa kasalukuyang orientation ng aparato, kaya ang axis ng "X" ay mananatiling pareho kahit na kung ang aparato ay nasa portrait o landscape mode. Kapag gumagamit ng sensor ng rotation vector, maaaring kailanganin mong i-convert ang papasok na data upang tumugma sa kasalukuyang pag-ikot ng aparato.

Ang larawan ay ang default na oryentasyon para sa karamihan sa mga smartphone, ngunit hindi mo dapat ipagpalagay na ito ang mangyayari lahat Mga aparato ng Android, lalo na ang mga tablet. Sa artikulong ito, gagamit kami ng isang rotation matrix upang isalin ang data ng sensor mula sa orihinal nito, aparato coordinate system, sa Lupa coordinate system, na kumakatawan sa paggalaw at posisyon ng aparato na nauugnay sa Earth. Kung kinakailangan, maaari naming muling mai-remap ang data ng sensor, batay sa kasalukuyang oryentasyon ng aparato.

Una, ang system coordinate ng aparato ay isang karaniwang 3-axis X, Y, Z coordinate system, kung saan ang bawat punto sa bawat isa sa tatlong axes ay kinakatawan ng isang 3D vector. Nangangahulugan ito na kailangan nating lumikha ng isang hanay ng 9 na mga halaga ng float:

pag-ikot ng floatMatrix = bagong float;

Pagkatapos ay maipasa namin ang array na ito sa paraan ng getRotationMatrix ():

SensorManager.getRotationMatrixFromVector (pag-ikotMatrix, vectors); int mundoAxisX = SensorManager.AXIS_X; int mundoAxisZ = SensorManager.AXIS_Z;

Ang susunod na hakbang, ay ang paggamit ng paraan ng SensorManager.remapCoordinateSystem () upang mai-remap ang data ng sensor, batay sa kasalukuyang oryentasyon ng aparato.

Ang pamamaraan ng SensorManager.remapCoordinateSystem () ay tumatagal ng mga sumusunod na argumento:

• Ang orihinal na rotation matrix.
• Ang mga palakol na nais mong i-remap.
• Ang hanay na nakakaranas ka ng bagong data na ito.

Narito ang code na gagamitin ko sa aking app:

nababagay sa floatRotationMatrix = bagong float; SensorManager.remapCoordinateSystem (pag-ikotMatrix, mundoAxisX, mundoAxisZ, nababagayRotasyonMatrix);

Sa wakas, tatawagin namin ang SensorManager.getOrientation at sabihin ito upang gamitin ang nababagayRotationMatrix:

SensorManager.getOrientation (nababagayRotasyonMatrix, orientation);

3. I-update ang mga string ng placeholder

Dahil mayroon kaming dalawang hanay ng data (pitch at roll), kailangan nating makuha ang dalawang magkahiwalay na mga string ng placeholder, mamayan ang mga ito gamit ang tamang mga halaga, at pagkatapos ay i-update ang kaukulang TextView:

pitchTextView.setText (getRes Source (). getString (R.string.pitch_sensor, pitch)); rollTextView.setText (getRes Pinagmulan (). getString (R.string.roll_sensor, roll));

Ipinapakita ang maraming data ng sensor: Nakumpleto na code

Matapos maisagawa ang mga hakbang sa itaas, ang iyong MainActivity ay dapat magmukhang ganito:

i-import ang android.app.Activity; i-import ang android.os.Bundle; mag-import ng android.hardware.Sensor; i-import ang android.hardware.SensorEvent; i-import ang android.hardware.SensorEventListener; i-import ang android.hardware.SensorManager; mag-import ng android.widget.TextView; pampublikong klase MainActivity ay nagpapalawak ng Aktibidad nagpapatupad ng SensorEventListener {pribadong SensorManager motionSensorManager; pribadong Sensor motionSensor; pribadong TextView pitchTextView; pribadong TextView rollTextView; pribadong static final int SENSOR_DELAY = 500 * 1000; pribadong static na panghuling int FROM_RADS_TO_DEGS = -57; Protektado ng @Override na walang bisa saCreate (Bundle saveInstanceState) {super.onCreate (saveInstanceState); setContentView (R.layout.activity_main); pitchTextView = (TextView) findViewById (R.id.pitchTextView); rollTextView = (TextView) findViewById (R.id.rollTextView); subukang {motionSensorManager = (SensorManager) getSystemService (Aktibidad.SENSOR_SERVICE); motionSensor = motionSensorManager.getDefaultSensor (Sensor.TYPE_ROTATION_VECTOR); paggalawSensorManager.registerListener (ito, motionSensor, SENSOR_DELAY); } mahuli (Pagbubukod e) {pitchTextView.setText (R.string.no_sensor); rollTextView.setText (R.string.no_sensor); }} @Override pampublikong walang bisa saAccuracyChanged (Sensor sensor, int katumpakan) {// To do //} @Override public void onSensorChanged (SensorEvent event) {if (event.sensor == motionSensor) {update (event.values); }} pribadong walang pag-update (float vectors) {// Compute ang rotation matrix // float rotationMatrix = bagong float; SensorManager.getRotationMatrixFromVector (pag-ikotMatrix, vectors); int mundoAxisX = SensorManager.AXIS_X; int mundoAxisZ = SensorManager.AXIS_Z; // I-Remap ang matrix batay sa kasalukuyang oryentasyon ng Aktibidad // nababagay na floatRotationMatrix = bagong float; SensorManager.remapCoordinateSystem (pag-ikotMatrix, mundoAxisX, mundoAxisZ, nababagayRotasyonMatrix); // Ikumpara ang orientation ng aparato // orientation ng float = bagong float; // Ibigay ang hanay ng mga halaga ng float sa pamamaraan ng getOrientation () // SensorManager.getOrientation (nababagayRotasyonMatrix, orientation); float pitch = orientation * FROM_RADS_TO_DEGS; float roll = orientation * FROM_RADS_TO_DEGS; // I-update ang TextViews gamit ang mga halaga ng pitch at roll // pitchTextView.setText (getRes Pinagmulan (). GetString (R.string.pitch_sensor, pitch)); rollTextView.setText (getRes Pinagmulan (). getString (R.string.roll_sensor, roll)); }}

Maaari mong i-download ang nakumpletong proyekto mula sa GitHub.

Pagsubok sa aming pangwakas na application ng Android sensor

Upang subukan ang rotation vector Android sensor app sa isang pisikal na Android smartphone o tablet:

• I-install ang application sa iyong aparato.
• Ilagay ang iyong smartphone o tablet sa isang patag na ibabaw. Tandaan na ang mga sensor ng paggalaw ay sobrang sensitibo, kaya hindi pangkaraniwan para sa isang tila walang kilusang aparato na mag-ulat ng mga pagbabago sa mga halaga ng pitch at roll.
• Upang subukan ang pitch, iangat ang ilalim ng iyong aparato upang ito ay lumayo sa iyo. Ang halaga ng pitch ay dapat na magbago nang malaki.
• Upang subukan ang roll, subukang iangat ang kaliwang bahagi ng iyong aparato, kaya ikiling sa kaliwa - pagmasdan ang halagang roll!

Kung sinusubukan mo ang iyong proyekto sa isang emulator:

• I-install ang application sa iyong AVD.
• Piliin ang "Higit pa," na naglulunsad ng window na "Pinahabang Mga Kontrol".
• Sa kaliwang menu, piliin ang "Virtual sensor."
• Tiyaking napili ang tab na "Accelerometer". Ang tab na ito ay naglalaman ng mga kontrol na maaaring gayahin ang mga pagbabago sa posisyon at oryentasyon ng aparato.
• Subukang mag-eksperimento sa iba't ibang mga slider (Paikutin: Z-Rot, X-Rot, Y-Rot; at Ilipat: X, Y, at Z) at ang iba't ibang mga pindutan ng "Pag-ikot ng Device", upang makita kung paano nakakaapekto sa "Roll Sensor ng iyong aplikasyon". "At" Pitch Sensor "na halaga.

Pagputol

Sa artikulong ito, nakita namin kung paano makukuha ang data mula sa tatlong pangunahing kategorya ng mga sensor ng Android: kapaligiran, posisyon at paggalaw, at kung paano masubaybayan ang data na ito sa real time.

Nakita mo ba ang anumang mga Android apps na gumagamit ng mga sensor sa kawili-wili o natatanging paraan? Ipaalam sa amin sa mga komento sa ibaba!