Contenido

• ¿Qué sensores de Android puedo usar?
• Sensores ambientales: medición de luz ambiental
• Mostrar los datos de su sensor
• Comunicación con un sensor: SensorManager, SensorEvents y oyentes
• 1. Obtenga una instancia de SensorManager
• 2. Obtenga una referencia a lightTextView
• 3. Compruebe si el sensor existe en el dispositivo actual
• 4. Registre sus oyentes sensores
• 5. Implemente las devoluciones de llamada SensorEventListener
• onSensorChanged ()
• onAccuracyChanged ()
• 6. Recupere el valor del sensor
• 7. Anule el registro de sus oyentes
• Uso de los sensores de luz de Android: código completado
• Prueba tu aplicación de sensor de Android completada
• Medición de distancia, con los sensores de proximidad de Android
• Crear la interfaz de usuario
• Obtener datos del sensor de proximidad
• Prueba: ¿qué tan cerca está el usuario de su dispositivo?
• Sensores de movimiento: procesamiento de matrices multidimensionales
• Visualización de datos de lanzamiento y balanceo en tiempo real
• Usando el sensor de vector de rotación en su aplicación
• 1. Use el TYPE_ROTATION_VECTOR
• 2. Traducir los datos del sensor
• 3. Actualice las cadenas de marcador de posición
• Visualización de datos de múltiples sensores: código completado
• Probar nuestra aplicación final de sensor de Android
• Terminando

Hoy, la mayoría de los dispositivos Android modernos están equipados con un montón de sensores.

Puede usar esta información de muchas maneras diferentes, ya sea que esté monitoreando los niveles de luz para que su aplicación pueda ajustar automáticamente su brillo o esquema de color; permitiendo al usuario interactuar con su juego móvil usando gestos como inclinar su dispositivo; o usando el sensor de proximidad para deshabilitar automáticamente los eventos táctiles cada vez que el usuario se lleva el dispositivo al oído.

En este artículo, crearemos tres aplicaciones que recuperen datos de luz, proximidad y movimiento de una gama de sensores de hardware y software. También controlaremos estos sensores de Android en tiempo real, para que su aplicación siempre tenga acceso a la información más reciente.

Al final de este artículo, sabrá cómo extraer una sola pieza de datos de un sensor de Android y cómo manejar los sensores que proporcionan sus datos en forma de una matriz multidimensional.

¿Qué sensores de Android puedo usar?

Los sensores de Android se pueden dividir en las siguientes categorías:

• Sensores ambientales. Estos miden las condiciones ambientales, como la temperatura del aire, la presión, la humedad y los niveles de luz ambiental.

• Sensores de posición. Esta categoría incluye sensores que miden la posición física del dispositivo, como sensores de proximidad y sensores de campo geomagnético.
  Sensores de movimiento. Estos sensores miden el movimiento del dispositivo e incluyen acelerómetros, sensores de gravedad, giroscopios y sensores de vector de rotación.

Además, los sensores pueden ser:

• Basado en hardware. Estos son componentes físicos que están integrados en el dispositivo y miden directamente propiedades específicas, como la aceleración o la fuerza de los campos geomagnéticos circundantes.
• Basado en software, a veces conocido como sensores virtuales o sensores compuestos. Estos suelen recopilar datos de múltiples sensores basados ​​en hardware. Hacia el final de este artículo, trabajaremos con el sensor de vector de rotación, que es un sensor de software que combina datos del acelerómetro, magnetómetro y giroscopio del dispositivo.

Sensores ambientales: medición de luz ambiental

El sensor de luz de Android mide la luz ambiental en unidades "lux", que es la intensidad de la luz tal como la percibe el ojo humano. El valor de lux informado por un sensor puede variar de un dispositivo a otro, por lo que si su aplicación requiere valores consistentes, es posible que deba manipular los datos sin procesar antes de usarlos en su aplicación.

En esta sección, vamos a crear una aplicación que recupere el valor de lux actual del sensor de luz del dispositivo, lo muestre en TextView y luego actualice TextView cuando haya nuevos datos disponibles.Luego puede usar esta información en una variedad de aplicaciones, por ejemplo, puede crear una aplicación de antorcha que extraiga información del sensor de luz y luego ajuste automáticamente la intensidad de su haz en función de los niveles de luz actuales.

Crea un nuevo proyecto de Android con la configuración que elijas y ¡comencemos!

Mostrar los datos de su sensor

Voy a agregar un TextView que eventualmente mostrará los datos que hemos extraído del sensor de luz. Este TextView se actualizará cuando haya nuevos datos disponibles, de modo que el usuario siempre tenga acceso a la información más reciente.

Abra el archivo activity_main.xml de su proyecto y agregue lo siguiente:

A continuación, debemos crear el recurso de cadena "light_sensor" al que se hace referencia en nuestro diseño. Abra el archivo strings.xml de su proyecto y agregue lo siguiente:

Sensor de luz:% 1 $ .2f

El "% 1 $ .2f" es un marcador de posición que especifica la información que queremos mostrar y cómo debe formatearse:

• %1. Puede insertar múltiples marcadores de posición en el mismo recurso de cadena; "% 1" indica que estamos usando un marcador de posición único.
• $.2. Esto especifica cómo nuestra aplicación debe formatear cada valor de punto flotante entrante. El "$ .2" indica que el valor debe redondearse a dos decimales.
• F. Formatee el valor como un número de punto flotante.

Si bien algunos sensores son más comunes que otros, nunca debe suponer que todos los dispositivos tienen acceso al mismo hardware y software. La disponibilidad de sensores incluso puede variar según las diferentes versiones de Android, ya que algunos sensores no se introdujeron hasta versiones posteriores de la plataforma Android.

Puede verificar si un sensor particular está presente en un dispositivo, utilizando el marco de sensores de Android. Luego puede deshabilitar o habilitar partes de su aplicación en función de la disponibilidad del sensor, o puede mostrar una explicación de que algunas de las funciones de su aplicación no funcionarán como se esperaba.

Si bien tenemos abierto nuestro archivo strings.xml, creemos una cadena "no_sensor", que mostraremos si el sensor de luz no está disponible:

No hay sensor de luz disponible

Si su aplicación no puede proporcionar una buena experiencia de usuario sin tener acceso a un sensor en particular, entonces debe agregar esta información a su Manifiesto. Por ejemplo, si su aplicación requiere acceso a un sensor de brújula, puede usar lo siguiente:

Ahora, su aplicación solo se puede descargar a dispositivos que tienen un sensor de brújula.

Si bien esto puede limitar su audiencia, es mucho menos perjudicial que permitir que alguien descargue su aplicación cuando está garantizado tener una mala experiencia, debido a la configuración del sensor de su dispositivo.

Comunicación con un sensor: SensorManager, SensorEvents y oyentes

Para comunicarse con el sensor de luz del dispositivo, debe completar los siguientes pasos:

1. Obtenga una instancia de SensorManager

SensorManager proporciona todos los métodos que necesita para acceder a la gama completa de sensores del dispositivo.

Para comenzar, cree una variable que contendrá una instancia de SensorManager:

SensorManager privado lightSensorManager;

Luego, debe obtener una instancia de SensorManager, llamando al método Context.getSystemService y pasando el argumento Context.SENSOR_SERVICE:

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

2. Obtenga una referencia a lightTextView

A continuación, debemos crear una variable miembro privada que contendrá nuestros objetos TextView y asignarla a nuestro TextView:

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

3. Compruebe si el sensor existe en el dispositivo actual

Puede obtener acceso a un sensor en particular llamando al método getDefaultSensor () y luego pasándole el sensor en cuestión. La constante de tipo para el sensor de luz es TYPE_LIGHT, por lo que debemos usar lo siguiente:

lightSensor = lightSensorManager.getDefaultSensor (Sensor.TYPE_LIGHT);

Si el sensor no existe en este dispositivo, el método getDefaultSensor () devolverá un valor nulo y mostraremos la cadena "no_sensor":

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

4. Registre sus oyentes sensores

Cada vez que un sensor tiene datos nuevos, Android genera un objeto SensorEvent. Este objeto SensorEvent incluye el sensor que generó el evento, una marca de tiempo y el nuevo valor de datos.

Inicialmente, nos centraremos en los sensores de luz y proximidad, que devuelven una sola pieza de datos. Sin embargo, algunos sensores proporcionan matrices multidimensionales para cada Evento Sensor, incluido el sensor de vector de rotación, que exploraremos hacia el final de este artículo.

Para garantizar que se notifique a nuestra aplicación acerca de estos objetos SensorEvent, debemos registrar un oyente para ese evento de sensor específico, utilizando registerListener de SensorManager ().

El método registerListener () toma los siguientes argumentos:

• Una aplicación o contexto de actividad.
• El tipo de sensor que desea monitorear.
• La velocidad a la que el sensor debe enviar nuevos datos. Una tasa más alta proporcionará a su aplicación más datos, pero también utilizará más recursos del sistema, especialmente la duración de la batería. Para ayudar a preservar la batería del dispositivo, debe solicitar la cantidad mínima de datos que requiere su aplicación. Voy a usar SensorManager.SENSOR_DELAY_NORMAL, que envía nuevos datos una vez cada 200,000 microsegundos (0.2 segundos).

Dado que escuchar un sensor agota la batería del dispositivo, nunca debe registrar a los oyentes en el método onCreate () de su aplicación, ya que esto hará que los sensores continúen enviando datos, incluso cuando su aplicación esté en segundo plano.

En cambio, debe registrar sus sensores en el método del ciclo de vida onStart () de la aplicación:

@Override protegido void onStart () {super.onStart (); // Si el sensor está disponible en el dispositivo actual ... // if (lightSensor! = Null) {//… .entonces comience a escuchar // lightSensorManager.registerListener (this, lightSensor, SensorManager.SENSOR_DELAY_NORMAL); }}

5. Implemente las devoluciones de llamada SensorEventListener

SensorEventListener es una interfaz que recibe notificaciones del SensorManager
cada vez que hay nuevos datos disponibles o la precisión del sensor cambia.

El primer paso es modificar nuestra firma de clase para implementar la interfaz SensorEventListener:

MainActivity de clase pública extiende AppCompatActivity implementa SensorEventListener {

Luego necesitamos implementar los siguientes métodos de devolución de llamada:

onSensorChanged ()

Este método se llama en respuesta a cada nuevo SensorEvent.

Los datos del sensor a menudo pueden cambiar rápidamente, por lo que su aplicación puede llamar al método onSensorChanged () de forma regular. Para ayudar a que su aplicación funcione sin problemas, debe realizar el menor trabajo posible dentro del método onSensorChanged ().

@Override public void onSensorChanged (SensorEvent sensorEvent) {// Para hacer //}

onAccuracyChanged ()

Si la precisión del sensor mejora o disminuye, Android llamará al método onAccuracyChanged () y le pasará un objeto Sensor que contiene el nuevo valor de precisión, como SENSOR_STATUS_UNRELIABLE o SENSOR_STATUS_ACCURACY_HIGH.

El sensor de luz no informa cambios en la precisión, por lo que dejaré la devolución de llamada onAccuracyChanged () vacía:

@Override public void onAccuracyChanged (Sensor sensor, int i) {// Para hacer //}}

6. Recupere el valor del sensor

Siempre que tengamos un nuevo valor, debemos llamar al método onSensorChanged () y recuperar la cadena "light_sensor". Luego podemos anular el texto del marcador de posición de la cadena (% 1 $ .2f) y mostrar la cadena actualizada como parte de nuestro TextView:

@Override public void onSensorChanged (SensorEvent sensorEvent) {// El valor actual del sensor // float currentValue = sensorEvent.values; // Recupere la cadena "light_sensor", inserte el nuevo valor y muéstrelo al usuario // lightTextView.setText (getResources (). GetString (R.string.light_sensor, currentValue)); }

7. Anule el registro de sus oyentes

Los sensores pueden generar grandes cantidades de datos en un corto período de tiempo, por lo tanto, para ayudar a preservar los recursos del dispositivo, deberá anular el registro de sus oyentes cuando ya no sean necesarios.

Para dejar de escuchar los eventos del sensor cuando su aplicación está en segundo plano, agregue unregisterListener () al método de ciclo de vida onStop () de su proyecto:

@Oversión de vacío protegido onStop () {super.onStop (); lightSensorManager.unregisterListener (esto); }

Tenga en cuenta que no debe cancelar el registro de sus oyentes en onPause (), ya que en Android 7.0 y las aplicaciones superiores pueden ejecutarse en modo de pantalla dividida e imagen en imagen, donde están en estado de pausa, pero permanecen visibles en la pantalla.

Uso de los sensores de luz de Android: código completado

Después de completar todos los pasos anteriores, la actividad principal de su proyecto debería verse así:

importar android.support.v7.app.AppCompatActivity; importar android.os.Bundle; importar android.content.Context; importar android.hardware.Sensor; importar android.hardware.SensorEvent; importar android.hardware.SensorEventListener; importar android.hardware.SensorManager; importar android.widget.TextView; public class MainActivity extiende AppCompatActivity // Implementa la interfaz SensorEventListener // implementa SensorEventListener {// Crea tus variables // Sensor privado lightSensor; SensorManager privado lightSensorManager; TextView privado lightTextView; @Override protected void onCreate (Bundle savedInstanceState) {super.onCreate (savedInstanceState); setContentView (R.layout.activity_main); lightTextView = (TextView) findViewById (R.id.lightTextView); // Obtenga una instancia de SensorManager // lightSensorManager = (SensorManager) getSystemService (Context.SENSOR_SERVICE); // Buscar un sensor de luz // lightSensor = lightSensorManager.getDefaultSensor (Sensor.TYPE_LIGHT); // Si el sensor de luz no existe, muestra un error // String 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 en el dispositivo actual ... // if (lightSensor! = Null) {//…., Entonces registre un oyente // lightSensorManager.registerListener (esto, lightSensor, // Especifique con qué frecuencia desea recibir nuevos datos // SensorManager.SENSOR_DELAY_NORMAL); }} @Override protected void onStop () {super.onStop (); // Anular el registro de su escucha // lightSensorManager.unregisterListener (this); } @Override public void onSensorChanged (SensorEvent sensorEvent) {// El valor actual del sensor // float currentValue = sensorEvent.values; // Recupere la cadena "light_sensor", inserte el nuevo valor y actualice TextView // lightTextView.setText (getResources (). GetString (R.string.light_sensor, currentValue)); } @Override // Si la precisión del sensor cambia ... .// public void onAccuracyChanged (Sensor sensor, int i) {// TO DO //}}

Prueba tu aplicación de sensor de Android completada

Para probar esta aplicación en un teléfono inteligente o tableta con Android físico:

• Instale el proyecto en su dispositivo (seleccionando "Ejecutar> Ejecutar" en la barra de herramientas de Android Studio).
• Aunque varía entre dispositivos, el sensor de luz a menudo se encuentra en la esquina superior derecha de la pantalla. Para manipular los niveles de luz, acerque su dispositivo y luego alejelo de una fuente de luz. Alternativamente, puede intentar cubrir el dispositivo con la mano para bloquear la luz. El valor del "Sensor de luz" debe aumentar y disminuir, dependiendo de la cantidad de luz disponible.

Si usa un dispositivo virtual Android (AVD), el emulador tiene un conjunto de controles de sensor virtual que puede usar para simular varios eventos de sensor. Usted accede a estos controles de sensor virtual, a través de la ventana "Controles extendidos" del emulador:

• Instale la aplicación en su AVD.
• Junto al AVD, verá una tira de botones. Busque el botón "Más" de tres puntos (donde se encuentra el cursor en la siguiente captura de pantalla) y haga clic. Esto inicia la ventana "Controles extendidos".

• En el menú de la izquierda, seleccione "Sensores virtuales".
• Seleccione la pestaña "Sensores adicionales". Esta pestaña contiene varios controles deslizantes que puede usar para simular diferentes eventos de posición y sensores ambientales.

• Busque el control deslizante “Luz (lux)” y arrástrelo hacia la izquierda y hacia la derecha para cambiar los niveles de luz simulados. Su aplicación debe mostrar estos valores cambiantes, en tiempo real.

Puede descargar el proyecto completado desde GitHub.

Medición de distancia, con los sensores de proximidad de Android

Ahora que hemos visto cómo recuperar información de un sensor ambiental, veamos cómo aplicaría este conocimiento a un posición sensor.

En esta sección, utilizaremos el sensor de proximidad del dispositivo para controlar la distancia entre su teléfono inteligente o tableta y otros objetos. Si su aplicación tiene algún tipo de funcionalidad de voz, entonces el sensor de proximidad puede ayudarlo a determinar cuándo el teléfono inteligente está cerca del oído del usuario, por ejemplo, cuando está teniendo una conversación telefónica. Luego puede usar esta información para deshabilitar los eventos táctiles, de modo que el usuario no cuelgue accidentalmente ni active otros eventos no deseados a mitad de la conversación.

Crear la interfaz de usuario

Voy a mostrar los datos de proximidad en la pantalla, para que pueda ver cómo se actualiza en tiempo real. Para ayudar a simplificar las cosas, reutilicemos gran parte del diseño de nuestra aplicación anterior:

A continuación, abra su archivo strings.xml y cree una cadena de "proximidad_sensor". Una vez más, esta cadena debe contener un marcador de posición, que eventualmente se completará con los datos extraídos del sensor de proximidad:

Sensor de proximidad Sensor de proximidad:% 1 $ .2f No hay sensor de proximidad disponible

Obtener datos del sensor de proximidad

Al igual que el sensor de luz, el sensor de proximidad de Android devuelve un único valor de datos, lo que significa que podemos reutilizar gran parte del código de nuestra aplicación anterior. Sin embargo, hay algunas diferencias importantes, además de algunos cambios relacionados con el nombre que hacen que este código sea más fácil de seguir:

• Cree una instancia de SensorManager, que esta vez voy a llamar "proximidadSensorManager".
• Obtenga una instancia de "proximidadSensorManager".
• Cree una referencia a la "proximidadTextView".
• Llame al método getDefaultSensor () y páselo al sensor TYPE_PROXIMITY.
• Registre y anule el registro de oyentes para el sensor de proximidad.

Después de hacer estos ajustes, debe terminar con lo siguiente:

importar android.support.v7.app.AppCompatActivity; importar android.os.Bundle; importar android.content.Context; importar android.hardware.Sensor; importar android.hardware.SensorEvent; importar android.hardware.SensorManager; importar android.hardware.SensorEventListener; importar android.widget.TextView; mainActivity de clase pública extiende AppCompatActivity // Implementa la interfaz SensorEventListener // implementa SensorEventListener {// Crea tus variables // SensorSensor de proximidad privado; sensorManager privado de proximidadSensorManager; TextView privado proximidadTextView; @Override protected void onCreate (Bundle savedInstanceState) {super.onCreate (savedInstanceState); setContentView (R.layout.activity_main); proximidadTextView = (TextView) findViewById (R.id.proximityTextView); // Obtenga una instancia de SensorManager // proximidadSensorManager = (SensorManager) getSystemService (Context.SENSOR_SERVICE); // Buscar un sensor de proximidad // proximidadSensor = proximidadSensorManager.getDefaultSensor (Sensor.TYPE_PROXIMITY); // Si el sensor de proximidad no existe, muestra un error // String sensor_error = getResources (). GetString (R.string.no_sensor); if (proximidadSensor == nulo) {proximidadTextView.setText (sensor_error); }} @Override protected void onStart () {super.onStart (); // Si el sensor está disponible en el dispositivo actual ... // if (proximidadSensor! = Nulo) {//…. Luego registre un escucha // proximidadSensorManager.registerListener (esto, proximidadSensor, // Especifique con qué frecuencia desea recibir nuevos datos // SensorManager.SENSOR_DELAY_NORMAL); }} @Override protected void onStop () {super.onStop (); // Anular el registro de su escucha para preservar los recursos del sistema // proximidadSensorManager.unregisterListener (esto); } @Override public void onSensorChanged (SensorEvent sensorEvent) {// El valor actual del sensor // float currentValue = sensorEvent.values; // Recupere la cadena de "proximidad_sensor", inserte el nuevo valor y actualice TextView // proximidadTextView.setText (getResources (). GetString (R.string.proximity_sensor, currentValue)); } @Override // Si la precisión del sensor cambia… .// public void onAccuracyChanged (Sensor sensor, int i) {//...TO DO //}}

Prueba: ¿qué tan cerca está el usuario de su dispositivo?

Para poner a prueba esta aplicación en un teléfono inteligente o tableta Android física, instale la aplicación en su dispositivo y luego experimente moviendo su mano hacia la pantalla, y luego retírela nuevamente. El valor del "Sensor de proximidad" debería registrar sus movimientos.

Solo tenga en cuenta que los sensores de proximidad pueden variar entre dispositivos. Algunos dispositivos solo pueden mostrar dos valores de proximidad: uno para indicar "Cercano" y otro para indicar "Lejos", por lo que no se sorprenda si no ve mucha variedad en su dispositivo Android físico.

Para probar esta aplicación en un emulador:

• Instale su aplicación en un AVD.
• Busque el botón "Más" de tres puntos y dele un clic, que abre la ventana "Controles extendidos".
• En el menú de la izquierda de la ventana, seleccione "Sensores virtuales".
• Seleccione la pestaña "Sensores adicionales".
• Busque el control deslizante "Proximidad" y arrástrelo hacia la izquierda y hacia la derecha para emular un objeto que se acerca al dispositivo y luego lo aleja. Los valores del "Sensor de proximidad" deberían cambiar a medida que manipula el control deslizante.

Puede descargar el proyecto completado desde GitHub.

Sensores de movimiento: procesamiento de matrices multidimensionales

Hasta este momento, nos hemos centrado en sensores que suministran un solo elemento de datos, pero hay algunos sensores que proporcionan matrices multidimensionales para cada Evento Sensor. Estos sensores multidimensionales incluyen sensores de movimiento, en los que nos centraremos en esta sección final.

Los sensores de movimiento pueden ayudarlo a:

• Proporcionar un método alternativo de entrada del usuario. Por ejemplo, si está desarrollando un juego móvil, el usuario puede mover su personaje por la pantalla inclinando su dispositivo.
• Inferir actividad del usuario. Si ha creado una aplicación de seguimiento de actividad, los sensores de movimiento pueden ayudarlo a evaluar si el usuario viaja en un automóvil, trota o está sentado en su escritorio.
• Determine con mayor precisión la orientación.Es posible extraer coordenadas de los sensores de movimiento de un dispositivo y luego traducirlas según el sistema de coordenadas de la Tierra, para obtener la información más precisa sobre la orientación actual del dispositivo.

En esta sección final, utilizaremos el sensor de vector de rotación (TYPE_ROTATION_VECTOR). A diferencia de los sensores de luz y proximidad, este es un sensor de software que recopila datos de los sensores de acelerómetro, magnetómetro y giroscopio del dispositivo. Aunque trabajar con este sensor a menudo requiere que realice conversiones y transformaciones matemáticas, también puede proporcionarle una variedad de información altamente precisa sobre el dispositivo.

Crearemos una aplicación que use el sensor de vector de rotación para medir:

• Tono. Esta es la inclinación de arriba a abajo del dispositivo.
• Rodar. Esta es la inclinación de izquierda a derecha del dispositivo.

Visualización de datos de lanzamiento y balanceo en tiempo real

Dado que estamos midiendo dos métricas, necesitamos crear dos TextViews y dos recursos de cadena correspondientes:

Abra el archivo strings.xml y agregue lo siguiente:

Sensores de movimiento Sensor de tono:% 1 $ .2f Sensor de balanceo:% 1 $ .2f No hay sensor de movimiento disponible

Usando el sensor de vector de rotación en su aplicación

Reutilizaremos parte del código de nuestras aplicaciones anteriores, así que centrémonos en las áreas donde la comunicación con el sensor de vector de rotación es significativamente diferente a lo que hemos visto antes.

1. Use el TYPE_ROTATION_VECTOR

Como estamos trabajando con el sensor de vector de rotación, debemos llamar al método getDefaultSensor () y luego pasarle la constante TYPE_ROTATION_VECTOR:

positionSensorManager.getDefaultSensor (Sensor.TYPE_ROTATION_VECTOR);

2. Traducir los datos del sensor

A diferencia de los sensores de luz y proximidad anteriores, los sensores de movimiento devuelven conjuntos multidimensionales de valores de sensores para cada SensorEvent. Estos valores se formatean utilizando el sistema de coordenadas estándar "X, Y, Z", que se calcula en relación con el dispositivo cuando se mantiene en su orientación predeterminada, "natural".

Android no cambia estas coordenadas X, Y y Z para que coincidan con la orientación actual del dispositivo, por lo que el eje "X" seguirá siendo el mismo independientemente de si el dispositivo está en modo vertical u horizontal. Al usar el sensor de vector de rotación, es posible que deba convertir los datos entrantes para que coincidan con la rotación actual del dispositivo.

Vertical es la orientación predeterminada para la mayoría de los teléfonos inteligentes, pero no debe suponer que este será el caso para todos Dispositivos Android, particularmente tabletas. En este artículo, utilizaremos una matriz de rotación para traducir los datos del sensor de su original, dispositivo sistema de coordenadas, a la La tierra sistema de coordenadas, que representa el movimiento y la posición del dispositivo en relación con la Tierra. Si es necesario, podemos reasignar los datos del sensor, según la orientación actual del dispositivo.

En primer lugar, el sistema de coordenadas del dispositivo es un sistema de coordenadas estándar de 3 ejes X, Y, Z, donde cada punto en cada uno de los tres ejes está representado por un vector 3D. Esto significa que necesitamos crear una matriz de 9 valores flotantes:

flotante rotación Matriz = flotante nuevo;

Luego podemos pasar esta matriz al método getRotationMatrix ():

SensorManager.getRotationMatrixFromVector (rotaciónMatriz, vectores); int worldAxisX = SensorManager.AXIS_X; int worldAxisZ = SensorManager.AXIS_Z;

El siguiente paso es utilizar el método SensorManager.remapCoordinateSystem () para reasignar los datos del sensor, en función de la orientación actual del dispositivo.

El método SensorManager.remapCoordinateSystem () toma los siguientes argumentos:

• La matriz de rotación original.
• Los ejes que desea reasignar.
• La matriz que está completando con estos nuevos datos.

Aquí está el código que usaré en mi aplicación:

flotante ajustadoRotaciónMatriz = nueva flotante; SensorManager.remapCoordinateSystem (rotaciónMatriz, worldAxisX, worldAxisZ, ajustadoRotationMatrix);

Finalmente, llamaremos a SensorManager.getOrientation y le diremos que use la matriz de rotación ajustada:

SensorManager.getOrientation (ajustadoRotationMatrix, orientación);

3. Actualice las cadenas de marcador de posición

Dado que tenemos dos conjuntos de datos (cabeceo y balanceo), necesitamos recuperar dos cadenas de marcador de posición separadas, llenarlas con los valores correctos y luego actualizar el TextView correspondiente:

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

Visualización de datos de múltiples sensores: código completado

Después de realizar los pasos anteriores, su MainActivity debería verse así:

importar android.app.Activity; importar android.os.Bundle; importar android.hardware.Sensor; importar android.hardware.SensorEvent; importar android.hardware.SensorEventListener; importar android.hardware.SensorManager; importar android.widget.TextView; MainActivity de clase pública extiende Actividad implementa SensorEventListener {SensorSeager privado motionSensorManager; Sensor privado motionSensor; TextView privado pitchTextView; TextView privado rollTextView; privado estático final int SENSOR_DELAY = 500 * 1000; privado estático 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); pruebe {motionSensorManager = (SensorManager) getSystemService (Activity.SENSOR_SERVICE); motionSensor = motionSensorManager.getDefaultSensor (Sensor.TYPE_ROTATION_VECTOR); motionSensorManager.registerListener (esto, motionSensor, SENSOR_DELAY); } catch (Excepción e) {pitchTextView.setText (R.string.no_sensor); rollTextView.setText (R.string.no_sensor); }} @Override public void onAccuracyChanged (Sensor sensor, precisión int) {// Para hacer //} @Override public void onSensorChanged (SensorEvent event) {if (event.sensor == motionSensor) {update (event.values); }} actualización privada vacía (vectores flotantes) {// Calcular la matriz de rotación // flotante rotaciónMatriz = nuevo flotante; SensorManager.getRotationMatrixFromVector (rotaciónMatriz, vectores); int worldAxisX = SensorManager.AXIS_X; int worldAxisZ = SensorManager.AXIS_Z; // Reasigna la matriz en función de la orientación actual de la Actividad // float ajustadoRotationMatrix = new float; SensorManager.remapCoordinateSystem (rotaciónMatriz, worldAxisX, worldAxisZ, ajustadoRotationMatrix); // Calcular la orientación de los dispositivos // float oriente = new float; // Proporcione la matriz de valores flotantes al método getOrientation () // SensorManager.getOrientation (ajustadoRotationMatrix, orientación); paso flotante = orientación * FROM_RADS_TO_DEGS; rollo flotante = orientación * FROM_RADS_TO_DEGS; // Actualice TextViews con los valores de pitch and roll // pitchTextView.setText (getResources (). GetString (R.string.pitch_sensor, pitch)); rollTextView.setText (getResources (). getString (R.string.roll_sensor, roll)); }}

Puede descargar el proyecto completado desde GitHub.

Probar nuestra aplicación final de sensor de Android

Para probar esta aplicación de sensor de Android de vector de rotación en un teléfono inteligente o tableta Android física:

• Instala la aplicación en tu dispositivo.
• Coloque su teléfono inteligente o tableta en una superficie plana. Tenga en cuenta que los sensores de movimiento son extremadamente sensibles, por lo que no es inusual que un dispositivo aparentemente inmóvil informe fluctuaciones en los valores de cabeceo y balanceo.
• Para probar el terreno de juego, levanta la parte inferior de tu dispositivo para que se incline hacia ti. El valor del tono debería cambiar dramáticamente.
• Para probar el rollo, intente levantar el lado izquierdo de su dispositivo, de modo que se incline hacia la izquierda. ¡Observe el valor del rollo!

Si está probando su proyecto en un emulador:

• Instale la aplicación en su AVD.
• Seleccione "Más", que inicia la ventana "Controles extendidos".
• En el menú de la izquierda, seleccione "Sensores virtuales".
• Asegúrese de que la pestaña "Acelerómetro" esté seleccionada. Esta pestaña contiene controles que pueden simular cambios en la posición y orientación del dispositivo.
• Intente experimentar con los diversos controles deslizantes (Rotar: Z-Rot, X-Rot, Y-Rot; y Mover: X, Y y Z) y los diversos botones de "Rotación del dispositivo", para ver cómo afectan el "Sensor de balanceo" de su aplicación "Y" Pitch Sensor "valores.

Terminando

En este artículo, vimos cómo recuperar datos de las tres categorías principales de sensores de Android: ambiental, posición y movimiento, y cómo monitorear estos datos en tiempo real.

¿Has visto alguna aplicación de Android que use sensores de maneras interesantes o únicas? ¡Háganos saber en los comentarios a continuación!