Content

• Quins sensors Android puc fer servir?
• Sensors ambientals: mesura de la llum ambiental
• Es mostren les dades del sensor
• Comunicar-se amb un sensor: SensorManager, SensorEvents i oients
• 1. Obteniu una instància de SensorManager
• 2. Obteniu una referència a lightTextView
• 3. Comproveu si el sensor existeix al dispositiu actual
• 4. Registreu els vostres oients del sensor
• 5. Implementeu les devolucions SensorEventListener
• onSensorChanged ()
• onAccurityChanged ()
• 6. Recupereu el valor del sensor
• 7. Doneu de baixa els vostres oients
• Utilitzar els sensors de llum d'Android: codi completat
• Prova la teva aplicació de sensor Android completada
• Mesura la distància amb els sensors de proximitat d'Android
• Creació de la interfície d'usuari
• Obtenció de dades del sensor de proximitat
• Prova: fins a quin punt es troba l'usuari del dispositiu?
• Sensors de moviment: processament de matrius multidimensionals
• Es mostren dades de tonalitat i llançament en temps real
• Utilitzant el sensor de vector de rotació de la vostra aplicació
• 1. Utilitzeu TYPE_ROTATION_VECTOR
• 2. Tradueix les dades del sensor
• 3. Actualitzeu les cadenes de marcador de posició
• Es mostren dades de diversos sensors: codi completat
• Prova de la nostra aplicació de sensor Android final
• Embalatge

Avui en dia, la majoria de dispositius Android moderns estan equipats amb diversos sensors.

Podeu utilitzar aquesta informació de moltes maneres diferents, ja sigui si fa un seguiment dels nivells de llum perquè la vostra aplicació pugui ajustar automàticament la seva brillantor o el seu color; permetre a l'usuari interactuar amb el joc mòbil mitjançant gestos com inclinar el dispositiu; o utilitzant el sensor de proximitat per desactivar automàticament els esdeveniments tàctils sempre que l'usuari subjecti el seu dispositiu a l'orella.

En aquest article, crearem tres aplicacions que recuperen dades de llum, de proximitat i de moviment d’una gamma de sensors de maquinari i programari. També controlarem aquests sensors Android en temps real, de manera que la vostra aplicació sempre tingui accés a la informació més recent.

Al final d’aquest article, sabreu extreure una sola dada d’un sensor d’Android i com gestionar sensors que proporcionin les seves dades en forma d’una matriu multidimensional.

Quins sensors Android puc fer servir?

Els sensors d'Android es poden dividir en les categories següents:

• Sensors ambientals. Aquests mesuren les condicions ambientals, com ara la temperatura de l'aire, la pressió, la humitat i els nivells de llum ambientals.

• Sensors de posició. Aquesta categoria inclou sensors que mesuren la posició física del dispositiu, com ara els sensors de proximitat i els camps de geomagnètica.
  Sensors de moviment. Aquests sensors mesuren el moviment del dispositiu i inclouen acceleròmetres, sensors de gravetat, giroscopis i sensors vectorials de rotació.

A més, els sensors poden ser:

• Basat en el maquinari. Es tracta de components físics integrats al dispositiu i mesuren directament propietats específiques, com ara l'acceleració o la força dels camps geomagnètics circumdants.
• Basat en programari, de vegades conegut com a sensors virtuals o sensors compostos. Normalment es recopilen dades de diversos sensors basats en maquinari. Cap al final d’aquest article, treballarem amb el sensor de vector de rotació, que és un sensor de programari que combina dades de l’acceleròmetre, el magnetòmetre i el giroscopi del dispositiu.

Sensors ambientals: mesura de la llum ambiental

El sensor de llum d’Android mesura la llum ambiental en unitats “lux”, que és la intensitat de la llum que percep l’ull humà. El valor lux reportat per un sensor pot variar segons els dispositius, de manera que si l’aplicació requereix valors consistents, potser haureu de manipular les dades en brut abans d’utilitzar-les a la vostra aplicació.

En aquesta secció, crearem una aplicació que recuperi el valor lux actual del sensor de llum del dispositiu, el mostrarem en un TextView i, a continuació, actualitzarem TextView quan es tornin a disposar de noves dades.A continuació, podeu utilitzar aquesta informació en diverses aplicacions, per exemple, podeu crear una aplicació de torxes que tiri informació del sensor de llum i ajusta automàticament la intensitat del seu feix en funció dels nivells actuals de llum.

Creeu un nou projecte per a Android amb la configuració que escolliu i comencem-ho!

Es mostren les dades del sensor

Afegiré un TextView que finalment mostrarà les dades que hem extret del sensor de llum. Aquest TextView s’actualitzarà sempre que estiguin disponibles dades noves, de manera que l’usuari sempre té accés a la informació més recent.

Obriu el fitxer Activity_main.xml del vostre projecte i afegiu-hi el següent:

A continuació, hem de crear el recurs de cadena “light_sensor” al qual es fa referència al nostre disseny. Obriu el fitxer strings.xml del vostre projecte i afegiu-hi el següent:

Sensor de llum:% 1 $ .2f

El "% 1 $ .2f" és un marcador de posició que especifica la informació que volem mostrar i com s'ha de formatar:

• %1. Podeu inserir diversos marcadors de posició al mateix recurs de cadena; El "% 1" indica que utilitzem un marcador de posició únic.
• $.2. Això especifica com la nostra aplicació ha de formatar cada valor de coma flotant entrant. El "$ .2" indica que el valor s'ha d'arrodonir a dues xifres decimals.
• F. Formateu el valor com a número de coma flotant.

Tot i que alguns sensors són més comuns que d’altres, mai no heu d’assumir que cada dispositiu tingui accés al mateix maquinari i programari. La disponibilitat de sensors fins i tot pot variar entre diferents versions d'Android, ja que alguns sensors no es van introduir fins a versions posteriors de la plataforma Android.

Podeu comprovar si hi ha un sensor en un dispositiu en funció del marc del sensor Android. Aleshores, podeu desactivar o habilitar parts de la vostra aplicació en funció de la disponibilitat del sensor, o bé mostrar una explicació que algunes de les funcions de la vostra aplicació no funcionaran tal com s'esperava.

Si bé tenim el nostre fitxer strings.xml, creem una cadena "no_sensor", que mostrarem si el sensor de llum no està disponible:

No hi ha cap sensor de llum disponible

Si la vostra aplicació no pot proporcionar una bona experiència d’usuari sense tenir accés a un sensor determinat, haureu d’afegir aquesta informació al manifest. Per exemple, si l'aplicació requereix accés a un sensor de brúixola, podeu utilitzar el següent:

Ara, la vostra aplicació només es pot descarregar en dispositius que tinguin un sensor de brúixola.

Tot i que això pot limitar la vostra audiència, és molt menys perjudicial que permetre que algú descarregui la seva aplicació quan sigui garantit tenir una mala experiència, a causa de la configuració del sensor del dispositiu.

Comunicar-se amb un sensor: SensorManager, SensorEvents i oients

Per comunicar-vos amb el sensor de llum del dispositiu, heu de realitzar els passos següents:

1. Obteniu una instància de SensorManager

SensorManager ofereix tots els mètodes que necessiteu per accedir a tota la gamma de sensors del dispositiu.

Per començar, creeu una variable que tingui una instància de SensorManager:

privat SensorManager lightSensorManager;

Aleshores, heu d’obtenir una instància de SensorManager, trucant al mètode Context.getSystemService i passant l’argument Context.SENSOR_SERVICE:

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

2. Obteniu una referència a lightTextView

A continuació, hem de crear una variable de membre privat que aguanti els nostres objectes TextView i assignar-la a TextView:

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

3. Comproveu si el sensor existeix al dispositiu actual

Podeu accedir a un sensor concret trucant al mètode getDefaultSensor () i, a continuació, passant-lo al sensor en qüestió. La constant de tipus per al sensor de llum és TYPE_LIGHT, per la qual cosa hem de fer servir el següent:

lightSensor = lightSensorManager.getDefaultSensor (Sensor.TYPE_LIGHT);

Si el sensor no existeix en aquest dispositiu, el mètode getDefaultSensor () tornarà nul i mostrarem la cadena "no_sensor":

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

4. Registreu els vostres oients del sensor

Cada vegada que un sensor té dades noves, Android genera un objecte SensorEvent. Aquest objecte SensorEvent inclou el sensor que va generar l'esdeveniment, una marca de temps i el nou valor de dades.

Inicialment, ens centrarem en els sensors de llum i de proximitat que ens retornen una sola dada. Tot i així, alguns sensors ofereixen matrius multidimensionals per a cada SensorEvent, inclòs el sensor de vector de rotació, que anirem explorant cap al final d’aquest article.

Per assegurar-nos que la nostra aplicació és notificada sobre aquests objectes SensorEvent, hem de registrar un oient per a aquell esdeveniment del sensor específic, mitjançant el registre RegisterListener de SensorManager ().

El mètode registerListener () conté els següents arguments:

• Una aplicació o context de l’activitat.
• El tipus de sensor que voleu supervisar.
• La velocitat amb què el sensor ha d'enviar noves dades. Un percentatge més alt proporcionarà a la vostra aplicació més dades, però també utilitzarà més recursos del sistema, especialment la durada de la bateria. Per conservar la bateria del dispositiu, heu de sol·licitar la quantitat mínima de dades que requereixi la vostra aplicació. Utilitzaré SensorManager.SENSOR_DELAY_NORMAL, que envia dades noves un cop cada 200.000 microsegons (0,2 segons).

Com que escoltar un sensor drena la bateria del dispositiu, mai no haureu de registrar els oients en el mètode onCreate () de la vostra aplicació, ja que això farà que els sensors continuïn enviant dades, fins i tot quan la vostra aplicació queda en segon pla.

En lloc d'això, heu de registrar els sensors al mètode del cicle de vida onStart () de l'aplicació:

@Override protected void onStart () {super.onStart (); // Si el sensor està disponible al dispositiu actual ... // if (lightSensor! = Null) {//….then comença a escoltar // lightSensorManager.registerListener (això, LightSensor, SensorManager.SENSOR_DELAY_NORMAL); }}

5. Implementeu les devolucions SensorEventListener

SensorEventListener és una interfície que rep notificacions de SensorManager
sempre que es disposin de dades noves o si es canvia la precisió del sensor.

El primer pas és modificar la nostra signatura de classe per implementar la interfície SensorEventListener:

public class MainActivity s'estén AppCompatActivity implementa SensorEventListener {

Cal implementar els mètodes de devolució següents:

onSensorChanged ()

Aquest mètode s'anomena com a resposta a cada nou SensorEvent.

Les dades del sensor sovint poden canviar ràpidament, de manera que la vostra aplicació pot trucar al mètode onSensorChanged () regularment. Per mantenir la vostra aplicació en bon funcionament, heu de realitzar el mínim treball possible dins del mètode onSensorChanged ().

@Override public void onSensorChanged (SensorEvent sensorEvent) {// Per fer //}

onAccurityChanged ()

Si la precisió del sensor millora o disminueix, aleshores Android trucarà al mètode onAcccisionChanged () i el passarà a un objecte Sensor que contingui el nou valor de precisió, com SENSOR_STATUS_UNRELIABLE o SENSOR_STATUS_ACCURACY_HIGH.

El sensor de llum no informa dels canvis de precisió, així que deixaré la devolució de trucada onAccurityChanged () buida:

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

6. Recupereu el valor del sensor

Sempre que tinguem un valor nou, hem de trucar al mètode onSensorChanged () i recuperar la cadena "light_sensor". A continuació, podem substituir el text de marcador de posició de la cadena (% 1 $ .2f) i mostrar la cadena actualitzada com a part del nostre TextView:

@Override public void onSensorChanged (SensorEvent sensorEvent) {// El valor actual del sensor // float currentValue = sensorEvent.values; // Recupereu la cadena "light_sensor", inseriu el nou valor i visualitzeu-lo a l'usuari // lightTextView.setText (getResources (). GetString (R.string.light_sensor, currentValue)); }

7. Doneu de baixa els vostres oients

Els sensors poden generar grans quantitats de dades en un període de temps reduït, de manera que ajuden a preservar els recursos del dispositiu, haureu de registrar la vostra audiència quan ja no els calgui.

Per deixar d’escoltar els esdeveniments del sensor quan la vostra aplicació està en segon pla, afegiu el registre del registre de registre () al mètode del cicle de vida onStop () del vostre projecte:

@Override void protected onStop () {super.onStop (); lightSensorManager.unregisterListener (això); }

Tingueu en compte que no heu de registrar de nou els vostres oients en onPause (), com en Android 7.0 i les aplicacions superiors es poden executar en mode de pantalla dividida i en imatge en imatge, on es troben en estat pausa, però romanen visibles a la pantalla.

Utilitzar els sensors de llum d'Android: codi completat

Després de completar tots els passos anteriors, l’activitat principal del vostre projecte hauria de tenir un aspecte així:

importa android.support.v7.app.AppCompatActivity; importa android.os.Bundle; importa android.content.Context; importa android.hardware.Sensor; importar android.hardware.SensorEvent; importar android.hardware.SensorEventListener; importa android.hardware.SensorManager; importa android.widget.TextView; public class MainActivity s'estén AppCompatActivity // Implementa la interfície SensorEventListener // implementa SensorEventListener {// Crea les vostres variables // private Sensor lightSensor; privat SensorManager lightSensorManager; privat TextView lightTextView; @Override protected void onCreate (Bundle savedInstanceState) {super.onCreate (savedInstanceState); setContentView (R.layout.activity_main); lightTextView = (TextView) findViewById (R.id.lightTextView); // Obtenir una instància de SensorManager // lightSensorManager = (SensorManager) getSystemService (Context.SENSOR_SERVICE); // Comproveu un sensor de llum // lightSensor = lightSensorManager.getDefaultSensor (Sensor.TYPE_LIGHT); // Si el sensor de llum no existeix, mostreu un error // Cadena sensor_error = getResources (). GetString (R.string.no_sensor); if (lightSensor == null) {lightTextView.setText (sensor_error); }} @Override protected void onStart () {super.onStart (); // Si el sensor està disponible al dispositiu actual ... // if (lightSensor! = Null) {//….then registreu un oient // lightSensorManager.registerListener (això, lightSensor, // Especifiqueu la freqüència amb què voleu rep dades noves // SensorManager.SENSOR_DELAY_NORMAL); }} @Override protected void onStop () {super.onStop (); // Registre el vostre oient // lightSensorManager.unregisterListener (això); } @Override public void onSensorChanged (SensorEvent sensorEvent) {// El valor actual del sensor // float currentValue = sensorEvent.values; // Recupereu la cadena "light_sensor", inseriu el nou valor i actualitzeu el TextView // lightTextView.setText (getResources (). GetString (R.string.light_sensor, currentValue)); } @Override // Si la precisió del sensor canvia ... .// public void onAccarityChanged (Sensor del sensor, int i) {// TO DO //}}

Prova la teva aplicació de sensor Android completada

Per provar aquesta aplicació en un smartphone o tablet Android físic:

• Instal·leu el projecte al vostre dispositiu (seleccionant "Executar> Executar" a la barra d'eines d'Android Studio).
• Tot i que varia entre els dispositius, el sensor de llum es troba sovint a la part superior dreta de la pantalla. Per manipular els nivells de llum, apropeu el dispositiu més lluny i, a més, allunyeu-vos d’una font de llum. També podeu intentar tapar el dispositiu amb la mà, per tal de deixar fora la llum. El valor del “Sensor de Llum” hauria d’augmentar i disminuir, depenent de la quantitat de llum disponible.

Si utilitzeu un dispositiu virtual Android (AVD), l'emulador té un conjunt de controls de sensors virtuals que podeu utilitzar per simular diversos esdeveniments del sensor. Accediu a aquests controls de sensors virtuals a través de la finestra "Controls ampliats" de l'emulador:

• Instal·leu l'aplicació a l'AVD.
• Al costat de l'AVD, podreu veure una sèrie de botons. Cerqueu el botó "Més" de tres punts (on es troba el cursor a la captura de pantalla següent) i feu-hi un clic. S'inicia la finestra "Controls ampliats".

• Al menú de l'esquerra, seleccioneu "Sensors virtuals".
• Seleccioneu la pestanya "Sensors addicionals". Aquesta pestanya conté diversos control lliscants que podeu utilitzar per simular diferents esdeveniments del sensor i de la posició.

• Cerqueu el control lliscant "Light (lux)" i arrossegueu-lo a l'esquerra ia la dreta per canviar els nivells de llum simulats. L’aplicació ha de mostrar aquests valors canviants en temps real.

Podeu descarregar el projecte completat de GitHub.

Mesura la distància amb els sensors de proximitat d'Android

Ara hem vist com recuperar la informació d’un sensor ambiental, vegem com aplicar aquest coneixement a una posició sensor.

En aquesta secció, utilitzarem el sensor de proximitat del dispositiu per monitoritzar la distància entre el vostre telèfon intel·ligent o tauleta i altres objectes. Si la vostra aplicació té algun tipus de funcionalitat de veu, el sensor de proximitat us pot ajudar a determinar quan es manté el telèfon intel·ligent a l'orella de l'usuari, per exemple, quan manté una conversa telefònica. Podeu utilitzar aquesta informació per desactivar els esdeveniments tàctils, de manera que l'usuari no es pengi de forma accidental ni accioni altres esdeveniments no desitjats a la meitat de la conversa.

Creació de la interfície d'usuari

Us mostraré les dades de proximitat a la pantalla, de manera que podreu veure-la actualitzada en temps real. Per ajudar a mantenir les coses senzilles, reutilitzem bona part del disseny de la nostra aplicació anterior:

A continuació, obriu el fitxer strings.xml i creeu una cadena "proximitat_sensor". Una vegada més, aquesta cadena ha de contenir un marcador de posició, que s'ocuparà de les dades extretes del sensor de proximitat:

Sensor de proximitat Sensor de proximitat:% 1 $ .2f No hi ha cap sensor de proximitat disponible

Obtenció de dades del sensor de proximitat

De manera similar al sensor de llum, el sensor de proximitat d’Android retorna un valor de dades únic, cosa que significa que podem reutilitzar bona part del codi de la nostra aplicació anterior. Tot i així, hi ha algunes diferències importants, a més d’alguns canvis relacionats amb el nom que fan que aquest codi sigui més fàcil de seguir:

• Creeu una instància de SensorManager, que aquesta vegada aniré a anomenar "proximitatSensorManager".
• Obteniu una instància de “proximitatSensorManager”.
• Creeu una referència al "proximitatTextView".
• Truqueu al mètode getDefaultSensor () i passeu-lo al sensor TYPE_PROXIMITY.
• Registra i baixa el registre dels oients del sensor de proximitat.

Després de fer aquests ajustaments, haureu d’acabar amb el següent:

importa android.support.v7.app.AppCompatActivity; importa android.os.Bundle; importa android.content.Context; importa android.hardware.Sensor; importar android.hardware.SensorEvent; importa android.hardware.SensorManager; importar android.hardware.SensorEventListener; importa android.widget.TextView; public class MainActivity s'estén AppCompatActivity // Implementa la interfície SensorEventListener // implementa SensorEventListener {// Crea les vostres variables // private Sensor proximitatSensor; privat SensorManager proximitatSensorManager; privat TextView proximitatTextView; @Override protected void onCreate (Bundle savedInstanceState) {super.onCreate (savedInstanceState); setContentView (R.layout.activity_main); proximitatTextView = (TextView) findViewById (R.id.proximityTextView); // Obtenir una instància de SensorManager // proximitatSensorManager = (SensorManager) getSystemService (Context.SENSOR_SERVICE); // Comproveu un sensor de proximitat // proximitatSensor = proximitatSensorManager.getDefaultSensor (Sensor.TYPE_PROXIMITY); // Si el sensor de proximitat no existeix, mostreu un error // String sensor_error = getResources (). GetString (R.string.no_sensor); if (proximitatSensor == null) {proximitatTextView.setText (sensor_error); }} @Override protected void onStart () {super.onStart (); // Si el sensor està disponible al dispositiu actual ... // if (proximitatSensor! = Nul) {//….then registrar un oient // proximitatSensorManager.registerListener (això, proximitatSensor, // Especifiqueu la freqüència amb què voleu rep dades noves // SensorManager.SENSOR_DELAY_NORMAL); }} @Override protected void onStop () {super.onStop (); // Donar de baixa el teu oient per preservar els recursos del sistema // proximitatSensorManager.unregisterListener (això); } @Override public void onSensorChanged (SensorEvent sensorEvent) {// El valor actual del sensor // float currentValue = sensorEvent.values; // Recupereu la cadena “proximitat_sensor”, inseriu el nou valor i actualitzeu el TextView // proximitatTextView.setText (getResources (). GetString (R.string.proximity_sensor, currentValue)); } @Override // Si la precisió del sensor canvia ... .// public void onAccurityChanged (Sensor del sensor, int i) {//...TO DO //}}

Prova: fins a quin punt es troba l'usuari del dispositiu?

Per posar a prova aquesta aplicació en un smartphone o tauleta Android físic, instal·leu l’aplicació al dispositiu i experimenteu, movent la mà cap a la pantalla i, després, tornant a allunyar-la. El valor "Sensor de proximitat" ha de registrar els moviments.

Només heu de tenir en compte que els sensors de proximitat poden variar entre dispositius. Alguns dispositius només mostren dos valors de proximitat: un per indicar "A prop" i un altre per indicar "Lluny", així que no us sorprendrà si no veieu molta varietat al vostre dispositiu Android físic.

Per provar aquesta aplicació en un emulador:

• Instal·leu la vostra aplicació en un AVD.
• Trobeu el botó "Més" de tres punts i feu-hi un clic, que llança la finestra "Controls ampliats".
• Al menú esquerre de la finestra, seleccioneu "Sensors virtuals".
• Seleccioneu la pestanya "Sensors addicionals".
• Cerqueu el botó lliscant "Proximitat" i arrossegueu-lo a l'esquerra ia la dreta per emular un objecte que s'apropi més al dispositiu i, a continuació, més lluny. Els valors del "Sensor de proximitat" haurien de canviar a mesura que manipuleu el control lliscant.

Podeu descarregar el projecte completat de GitHub.

Sensors de moviment: processament de matrius multidimensionals

Fins aquest moment, ens hem centrat en sensors que subministren un únic element de dades, però hi ha alguns sensors que ofereixen matrius multidimensionals per a cada SensorEvent. Aquests sensors multidimensionals inclouen sensors de moviment, als quals ens centrarem en aquesta secció final.

Els sensors de moviment us poden ajudar:

• Proporcioneu un mètode alternatiu d’entrada dels usuaris. Per exemple, si esteu desenvolupant un joc mòbil, l’usuari pot moure el seu personatge per la pantalla inclinant el seu dispositiu.
• Infer l'activitat dels usuaris. Si heu creat una aplicació de seguiment d’activitats, els sensors de moviment us poden ajudar a determinar si l’usuari viatja en un cotxe, fa trotar o s’asseu al seu escriptori.
• Determinar amb més precisió l’orientació.És possible extreure les coordenades dels sensors de moviment d'un dispositiu i després traduir-les en funció del sistema de coordenades de la Terra per obtenir una visió més exacta de l'orientació actual del dispositiu.

En aquesta secció final, utilitzarem el sensor de vector de rotació (TYPE_ROTATION_VECTOR). A diferència dels sensors de llum i proximitat, es tracta d’un sensor de programari que recopila dades dels sensors de l’acceleròmetre, el magnetòmetre i el giroscopi. Tot i que el treball amb aquest sensor sol requerir conversions i transformacions matemàtiques, també us pot proporcionar una informació molt precisa sobre el dispositiu.

Crearem una aplicació que utilitzi el sensor de vector de rotació per mesurar:

• Brea. Aquesta és la inclinació de dalt a baix del dispositiu.
• Rotlle. Aquesta és la inclinació d'esquerra a dreta del dispositiu.

Es mostren dades de tonalitat i llançament en temps real

Com que mesurem dues mètriques, hem de crear dos TextViews i dos recursos de cadena corresponents:

Obriu el fitxer strings.xml i afegiu el següent:

MotionSensors Sensor de connexió:% 1 $ .2f Sensor de rotllo:% 1 $ .2f No hi ha cap sensor de moviment disponible

Utilitzant el sensor de vector de rotació de la vostra aplicació

Tornarem a utilitzar alguns dels codis de les aplicacions anteriors, per tant, centrem-nos en les àrees on comunicar-nos amb el sensor de vector de rotació, és molt diferent del que hem vist abans.

1. Utilitzeu TYPE_ROTATION_VECTOR

Com que treballem amb el sensor de vector de rotació, hem de trucar al mètode getDefaultSensor (), i després passar-lo a la constant TYPE_ROTATION_VECTOR:

positionSensorManager.getDefaultSensor (Sensor.TYPE_ROTATION_VECTOR);

2. Tradueix les dades del sensor

A diferència dels anteriors sensors de llum i proximitat, els sensors de moviment retornen matrius multidimensionals de valors de sensor per a cada SensorEvent. Aquests valors es formategen mitjançant el sistema de coordenades "X, Y, Z" estàndard, que es calcula en relació amb el dispositiu quan es manté en forma d'orientació "natural" per defecte.

Android no canvia aquestes coordenades X, Y i Z per coincidir amb l’orientació actual del dispositiu, de manera que l’eix “X” continuarà essent el mateix, independentment de si el dispositiu està en mode retratat o paisatge. Quan feu servir el sensor de vector de rotació, potser haureu de convertir les dades entrants perquè coincideixin amb la rotació actual del dispositiu.

El retrat és l’orientació predeterminada de la majoria dels telèfons intel·ligents, però no hauria de suposar que això serà així tot Dispositius Android, sobretot tauletes. En aquest article, utilitzarem una matriu de rotació per traduir les dades del sensor des del seu original, dispositiu sistema de coordenades, a Terra sistema de coordenades, que representa el moviment i la posició del dispositiu respecte a la Terra. Si cal, podem tornar a modificar les dades del sensor en funció de l’orientació actual del dispositiu.

En primer lloc, el sistema de coordenades del dispositiu és un sistema estàndard de coordenades X, Y, Z de 3 eixos, on cada punt de cadascun dels tres eixos està representat per un vector 3D. Això vol dir que hem de crear una matriu de 9 valors float:

float rotationMatrix = nou flotador;

A continuació, podem passar aquesta matriu al mètode getRotationMatrix ():

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

El següent pas és utilitzar el mètode SensorManager.remapCoordinateSystem () per obtenir les dades del sensor basant-se en l'orientació actual del dispositiu.

El mètode SensorManager.remapCoordinateSystem () adopta els següents arguments:

• La matriu de rotació original.
• Els eixos que voleu remodelar.
• La matriu que pobleu amb aquestes noves dades.

Aquí teniu el codi que utilitzaré a la meva aplicació:

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

Finalment, cridarem SensorManager.getOrientation i li direm que utilitzi laRotationMatrix ajustada:

SensorManager.getOrientation (ajustatRotationMatrix, orientació);

3. Actualitzeu les cadenes de marcador de posició

Com que tenim dos conjunts de dades (pitch and roll), hem de recuperar dues cadenes de marcador de posició separades, poblar-les amb els valors correctes i actualitzar el TextView corresponent:

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

Es mostren dades de diversos sensors: codi completat

Després de realitzar els passos anteriors, el MainActivity hauria de tenir un aspecte així:

importa android.app.Activitat; importa android.os.Bundle; importa android.hardware.Sensor; importar android.hardware.SensorEvent; importar android.hardware.SensorEventListener; importa android.hardware.SensorManager; importa android.widget.TextView; public class MainActivity s'estén Activitats implementes SensorEventListener {private SensorManager motionSensorManager; Private Sensor motionSensor; TextView privat pitchTextView; privat TextView rollTextView; privada estàtica final int SENSOR_DELAY = 500 * 1000; privada estàtica final int FROM_RADS_TO_DEGS = -57; @Override protected void onCreate (Bundle savedInstanceState) {super.onCreate (savedInstanceState); setContentView (R.layout.activity_main); pitchTextView = (TextView) findViewById (R.id.pitchTextView); rollTextView = (TextView) findViewById (R.id.rollTextView); provar {motionSensorManager = (SensorManager) getSystemService (Activitat.SENSOR_SERVICE); motionSensor = motionSensorManager.getDefaultSensor (Sensor.TYPE_ROTATION_VECTOR); motionSensorManager.registerListener (això, motionSensor, SENSOR_DELAY); } catch (Excepció e) {pitchTextView.setText (R.string.no_sensor); rollTextView.setText (R.string.no_sensor); }} @Override public void onAcccisionChanged (Sensor del sensor, precisió int) {// Per fer //} @Override public void onSensorChanged (SensorEvent event) {if (event.sensor == motionSensor) {actualització (event.values); }} private void update (float vectors) {// Calcula la matriu de rotació // float rotationMatrix = new float; SensorManager.getRotationMatrixFromVector (rotationMatrix, vectors); int worldAxisX = SensorManager.AXIS_X; int worldAxisZ = SensorManager.AXIS_Z; // Torneu a posar la matriu en funció de l'orientació actual de l'activitat // float ajustatRotationMatrix = nou flotador; SensorManager.remapCoordinateSystem (rotationMatrix, worldAxisX, worldAxisZ ,justRotationMatrix); // Calcula l’orientació dels dispositius // orientació flotant = nou flotador; // Proporciona la matriu de valors float al mètode getOrientation () // SensorManager.getOrientation (ajustatRotationMatrix, orientació); float pitch = orientació * FROM_RADS_TO_DEGS; float roll = orientació * FROM_RADS_TO_DEGS; // Actualitzar les TextViews amb els valors de pitch and roll // pitchTextView.setText (getResources (). GetString (R.string.pitch_sensor, pitch)); rollTextView.setText (getResources (). getString (R.string.roll_sensor, roll)); }}

Podeu descarregar el projecte completat de GitHub.

Prova de la nostra aplicació de sensor Android final

Per provar aquesta rotació vectorial d'aplicacions del sensor d'Android en un smartphone o tablet Android Android

• Instal·leu l’aplicació al vostre dispositiu.
• Situeu el vostre smartphone o tauleta sobre una superfície plana. Tingueu en compte que els sensors de moviment són extremadament sensibles, per la qual cosa no és rar que un dispositiu aparentment immòbil reporti fluctuacions dels valors del pas i del rotllo.
• Per provar el to, aixequeu la part inferior del dispositiu de manera que us inclini fora de vosaltres. El valor de la tonalitat hauria de canviar dràsticament.
• Per provar el rotlle, proveu d'aixecar la part esquerra del dispositiu, de manera que aquesta s'inclina cap a l'esquerra: vigileu el valor del rotlle.

Si estàs provant el teu projecte en un emulador:

• Instal·leu l'aplicació a l'AVD.
• Seleccioneu "Més", que llança la finestra "Controls ampliats".
• Al menú de l'esquerra, seleccioneu "Sensors virtuals".
• Assegureu-vos que s'ha seleccionat la pestanya "Acceleròmetre". Aquesta pestanya conté controls que poden simular canvis en la posició i orientació del dispositiu.
• Proveu d’experimentar amb els diferents control lliscants (Gire: Z-Rot, X-Rot, Y-Rot; i Move: X, Y i Z) i els diversos botons de “Rotation Device” per veure com afecten el “Sensor de rodatge de l’aplicació. Valors "i" Sensor de pas ".

Embalatge

En aquest article, vam veure com recuperar dades de les tres categories principals de sensors d’Android: ambientals, de posició i moviment, i com monitoritzar aquestes dades en temps real.

Heu vist alguna aplicació Android que utilitzi sensors de maneres interessants o úniques? Feu-nos-ho saber als comentaris a continuació!