La mayoría de los dispositivos con Android tienen sensores integrados que miden el movimiento, la orientación y diversas condiciones ambientales. Estos sensores son capaces de proporcionar datos sin procesar con alta precisión y exactitud, y son útiles si deseas supervisar el movimiento o el posicionamiento del dispositivo tridimensional, o si quieres supervisar los cambios en el entorno ambiente cerca de un dispositivo. Por ejemplo, un juego podría hacer un seguimiento de las lecturas del sensor de gravedad de un dispositivo para inferir gestos y movimientos complejos del usuario, como inclinación, agitación, rotación o balanceo. Del mismo modo, una aplicación meteorológica puede usar el sensor de temperatura y el sensor de humedad de un dispositivo para calcular e informar el punto de condensación, o una aplicación de viaje puede usar el sensor de campo geomagnético y el acelerómetro para informar el rumbo de la brújula.
Consulta los siguientes recursos relacionados:
La plataforma de Android admite tres amplias categorías de sensores:
- Sensores de movimiento
Estos sensores miden las fuerzas de aceleración y las fuerzas de rotación en tres ejes. Esta categoría incluye acelerómetros, sensores de gravedad, giroscopios y sensores del vector de rotación.
- Sensores ambientales
Estos sensores miden varios parámetros ambientales, como la temperatura y la presión del aire ambiente, la iluminación y la humedad. Esta categoría incluye barómetros, fotómetros y termómetros.
- Sensores de posición
Estos sensores miden la posición física de un dispositivo. Esta categoría incluye sensores de orientación y magnetómetros.
Puedes acceder a los sensores disponibles en el dispositivo y adquirir datos sin procesar del sensor usando el framework de sensores de Android. El marco de trabajo del sensor proporciona varias interfaces y clases que te ayudan a realizar una amplia variedad de tareas relacionadas con el sensor. Por ejemplo, puedes usar el marco de trabajo del sensor para las siguientes tareas:
- Determina qué sensores están disponibles en un dispositivo.
- Determina las capacidades de un sensor individual, como su rango máximo, el fabricante, los requisitos de energía y la resolución.
- Adquiere datos sin procesar del sensor y define la velocidad mínima con la que adquirirás los datos del sensor.
- Registra y cancela el registro de oyentes de objetos de escucha de eventos que supervisan los cambios del sensor.
En este tema, se proporciona una descripción general de los sensores que están disponibles en la plataforma de Android. También se proporciona una introducción al marco de trabajo del sensor.
Introducción a los sensores
El marco de trabajo del sensor de Android permite acceder a muchos tipos de sensores. Algunos de estos sensores se basan en hardware y otros en software. Los sensores basados en hardware son componentes físicos integrados en un teléfono celular o tablet. Para obtener sus datos, miden directamente propiedades ambientales específicas, como la aceleración, la intensidad del campo geomagnético o el cambio angular. Los sensores basados en software no son dispositivos físicos, aunque imitan los sensores basados en hardware. Los sensores basados en software obtienen sus datos de uno o más de los sensores basados en hardware y, a veces, se denominan sensores virtuales o sensores sintéticos. El sensor de aceleración lineal y el sensor de gravedad son ejemplos de sensores basados en software. En la tabla 1, se resumen los sensores que son compatibles con la plataforma de Android.
Solo unos pocos dispositivos con Android tienen todos los tipos de sensores. Por ejemplo, la mayoría de los teléfonos celulares y las tablets tienen un acelerómetro y un magnetómetro, pero menos dispositivos tienen barómetros o termómetros. Además, un dispositivo puede tener más de un sensor de un tipo determinado. Por ejemplo, un dispositivo puede tener dos sensores de gravedad, cada uno con un rango diferente.
Tabla 1: Tipos de sensores compatibles con la plataforma de Android
Sensor | Tipo | Descripción | Usos habituales |
---|---|---|---|
TYPE_ACCELEROMETER |
Hardware | Mide en m/s2 la fuerza de aceleración que se aplica a un dispositivo en los tres ejes físicos (x, y, z), incluida la fuerza de gravedad. | Detección de movimiento (agitación, inclinación, etc.). |
TYPE_AMBIENT_TEMPERATURE |
Hardware | Mide la temperatura ambiente de la habitación en grados Celsius (°C). Consulta la siguiente nota. | Supervisión de la temperatura del aire. |
TYPE_GRAVITY |
Software o hardware | Mide en m/s2 la fuerza de gravedad que se aplica a un dispositivo en los tres ejes físicos (x, y, z). | Detección de movimiento (agitación, inclinación, etc.). |
TYPE_GYROSCOPE |
Hardware | Mide en rad/s la velocidad de rotación de un dispositivo alrededor de cada uno de los tres ejes físicos (x, y, z). | Detección de rotación (agitación, giro, etc.). |
TYPE_LIGHT |
Hardware | Mide el nivel de luz ambiental (iluminación) en lx. | Control del brillo de la pantalla. |
TYPE_LINEAR_ACCELERATION |
Software o hardware | Mide en m/s2 la fuerza de aceleración que se aplica a un dispositivo en los tres ejes físicos (x, y, z), sin incluir la fuerza de gravedad. | Supervisión de la aceleración a lo largo de un solo eje. |
TYPE_MAGNETIC_FIELD |
Hardware | Mide el campo geomagnético ambiental de los tres ejes físicos (x, y, z) en μT. | Creación de una brújula. |
TYPE_ORIENTATION |
Software | Mide los grados de rotación de un dispositivo alrededor de los tres ejes físicos (x, y, z).
A partir del nivel de API 3, puedes obtener la matriz de inclinación y la matriz de rotación de un dispositivo usando el sensor de gravedad y el sensor de campo geomagnético junto con el método getRotationMatrix() . |
Determinación de la posición del dispositivo. |
TYPE_PRESSURE |
Hardware | Mide la presión del aire del ambiente en hPa o mbar. | Supervisa los cambios de la presión del aire. |
TYPE_PROXIMITY |
Hardware | Mide en cm la proximidad de un objeto en relación con la pantalla de visualización de un dispositivo. Este sensor suele usarse para determinar si un teléfono celular se está sosteniendo cerca del oído de una persona. | Posición del teléfono durante una llamada. |
TYPE_RELATIVE_HUMIDITY |
Hardware | Mide en valor de porcentaje (%) la humedad relativa del ambiente. | Supervisa el punto de condensación, la humedad absoluta y la humedad relativa. |
TYPE_ROTATION_VECTOR |
Software o hardware | Mide la orientación de un dispositivo proporcionando los tres elementos del vector de rotación del dispositivo. | Detección de movimiento y detección de rotación. |
TYPE_TEMPERATURE |
Hardware | Mide la temperatura del dispositivo en grados Celsius (°C). La implementación de este sensor varía según el dispositivo, y este sensor se reemplazó por el sensor TYPE_AMBIENT_TEMPERATURE en el nivel de API 14. |
Supervisión de temperaturas. |
Marco de trabajo del sensor
Puedes acceder a estos sensores y adquirir datos del sensor sin procesar con el marco de trabajo del sensor de Android.
El framework del sensor es parte del paquete android.hardware
e incluye las siguientes interfaces y clases:
SensorManager
- Puedes usar esta clase para crear una instancia del servicio del sensor. Esta clase proporciona varios métodos para acceder a sensores y enumerarlos, registrar y cancelar el registro de objetos de escucha de eventos de sensores y adquirir información de orientación. Esta clase también proporciona varias constantes del sensor que se usan para informar la precisión de los sensores, establecer las tasas de adquisición de datos y calibrar sensores.
Sensor
- Puedes usar esta clase para crear una instancia de un sensor específico. Esta clase proporciona varios métodos que te permiten determinar las capacidades de un sensor.
SensorEvent
- El sistema usa esta clase para crear un objeto de evento de sensor, que proporciona información sobre un evento de sensor. Un objeto de evento de sensor incluye la siguiente información: los datos sin procesar del sensor, el tipo de sensor que generó el evento, la precisión de los datos y la marca de tiempo del evento.
SensorEventListener
- Puedes usar esta interfaz para crear dos métodos de devolución de llamada que reciban notificaciones (eventos del sensor) cuando cambien los valores del sensor o cuando cambie la precisión del sensor.
En una aplicación típica, estas API relacionadas con sensores se usan para realizar dos tareas básicas:
- Identificación de sensores y capacidades de sensores
La identificación de sensores y capacidades de sensores en el tiempo de ejecución es útil si tu aplicación tiene funciones que se basan en tipos o capacidades de sensores específicos. Por ejemplo, es posible que desees identificar todos los sensores que están presentes en un dispositivo e inhabilitar las funciones de la aplicación que dependen de sensores que no están presentes. Del mismo modo, es posible que quieras identificar todos los sensores de un tipo determinado para que puedas elegir la implementación del sensor que tenga el rendimiento óptimo para tu aplicación.
- Supervisa los eventos del sensor
La supervisión de los eventos del sensor es la manera en la que adquieres los datos sin procesar del sensor. Un evento de sensor se produce cada vez que un sensor detecta un cambio en los parámetros que está midiendo. Un evento de sensor te proporciona cuatro datos: el nombre del sensor que activó el evento, la marca de tiempo del evento, la precisión del evento y los datos sin procesar del sensor que activaron el evento.
Disponibilidad del sensor
Si bien la disponibilidad del sensor varía de un dispositivo a otro, también puede variar entre las versiones de Android. Esto se debe a que los sensores de Android se introdujeron en el transcurso de varias versiones de la plataforma. Por ejemplo, muchos sensores se introdujeron en Android 1.5 (nivel de API 3), pero algunos no se implementaron ni estuvieron disponibles hasta Android 2.3 (nivel de API 9). Del mismo modo, se introdujeron varios sensores en Android 2.3 (nivel de API 9) y Android 4.0 (nivel de API 14). Dos sensores dejaron de estar disponibles y se reemplazaron por sensores más nuevos y mejores.
En la tabla 2, se resume la disponibilidad de los sensores en cada una de las plataformas. Solo se enumeran cuatro plataformas porque son las que involucraron cambios en los sensores. Los sensores que se indican como obsoletos seguirán estando disponibles en plataformas posteriores (siempre que el sensor esté presente en un dispositivo), lo que cumple con la política de compatibilidad con versiones posteriores de Android.
Tabla 2: Disponibilidad de sensores por plataforma
Sensor | Android 4.0 (API nivel 14) |
Android 2.3 (API nivel 9) |
Android 2.2 (API nivel 8) |
Android 1.5 (API nivel 3) |
---|---|---|---|---|
TYPE_ACCELEROMETER |
Sí | Sí | Sí | Sí |
TYPE_AMBIENT_TEMPERATURE |
Sí | n/a | n/a | N/A |
TYPE_GRAVITY |
Sí | Sí | n/a | N/A |
TYPE_GYROSCOPE |
Sí | Sí | n/a1 | n/a1 |
TYPE_LIGHT |
Sí | Sí | Sí | Sí |
TYPE_LINEAR_ACCELERATION |
Sí | Sí | n/a | N/A |
TYPE_MAGNETIC_FIELD |
Sí | Sí | Sí | Sí |
TYPE_ORIENTATION |
Sí2 | Sí2 | Sí2 | Sí |
TYPE_PRESSURE |
Sí | Sí | n/a1 | n/a1 |
TYPE_PROXIMITY |
Sí | Sí | Sí | Sí |
TYPE_RELATIVE_HUMIDITY |
Sí | n/a | n/a | N/A |
TYPE_ROTATION_VECTOR |
Sí | Sí | n/a | N/A |
TYPE_TEMPERATURE |
Sí2 | Sí | Sí | Sí |
1 Este tipo de sensor se agregó en Android 1.5 (nivel de API 3), pero no estuvo disponible hasta Android 2.3 (nivel de API 9).
2 Este sensor está disponible, pero es obsoleto.
Identificación de sensores y capacidades de sensores
El framework del sensor de Android proporciona varios métodos que te permiten determinar con facilidad en el tiempo de ejecución qué sensores están en un dispositivo. La API también proporciona métodos que te permiten determinar las capacidades de cada sensor, como su rango máximo, su resolución y sus requisitos de energía.
Para identificar los sensores que están en un dispositivo, primero debes obtener una referencia al servicio del sensor. Para ello, llama al método getSystemService()
y pasa el argumento SENSOR_SERVICE
a fin de crear una instancia de la clase SensorManager
. Por ejemplo:
Kotlin
private lateinit var sensorManager: SensorManager ... sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
Java
private SensorManager sensorManager; ... sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
A continuación, puedes obtener una lista de todos los sensores de un dispositivo llamando al método getSensorList()
y usando la constante TYPE_ALL
. Por ejemplo:
Kotlin
val deviceSensors: List<Sensor> = sensorManager.getSensorList(Sensor.TYPE_ALL)
Java
List<Sensor> deviceSensors = sensorManager.getSensorList(Sensor.TYPE_ALL);
Si deseas enumerar todos los sensores de un tipo determinado, puedes usar otra constante en lugar de TYPE_ALL
, como TYPE_GYROSCOPE
, TYPE_LINEAR_ACCELERATION
o TYPE_GRAVITY
.
También puedes determinar si un tipo específico de sensor existe en un dispositivo usando el método getDefaultSensor()
y pasando la constante de tipo para un sensor específico. Si un dispositivo tiene más de un sensor de un tipo determinado, se debe designar uno de los sensores como el sensor predeterminado. Si no existe un sensor predeterminado para un tipo de sensor determinado, la llamada al método muestra un valor nulo, lo que significa que el dispositivo no tiene ese tipo de sensor. Por ejemplo, en el siguiente código, se comprueba si hay un magnetómetro en un dispositivo:
Kotlin
private lateinit var sensorManager: SensorManager ... sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager if (sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD) != null) { // Success! There's a magnetometer. } else { // Failure! No magnetometer. }
Java
private SensorManager sensorManager; ... sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE); if (sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD) != null){ // Success! There's a magnetometer. } else { // Failure! No magnetometer. }
Nota: Android no requiere que los fabricantes de dispositivos compilen ningún tipo particular de sensores en sus dispositivos con Android, por lo que los dispositivos pueden tener una amplia gama de configuraciones de sensores.
Además de enumerar los sensores que están en un dispositivo, puedes usar los métodos públicos de la clase Sensor
para determinar las capacidades y los atributos de sensores individuales. Esto es útil si deseas que tu aplicación se comporte de manera diferente según los sensores o las capacidades de sensores disponibles en un dispositivo. Por ejemplo, puedes usar los métodos getResolution()
y getMaximumRange()
para obtener la resolución de un sensor y el rango máximo de medición. También puedes usar el método getPower()
para obtener los requisitos de alimentación de un sensor.
Dos de los métodos públicos son particularmente útiles si deseas optimizar tu aplicación para diferentes sensores de fabricantes o diferentes versiones de un sensor. Por ejemplo, si tu aplicación necesita supervisar gestos del usuario, como inclinación y agitación, puedes crear un conjunto de reglas de filtrado de datos y optimizaciones para dispositivos más nuevos que tengan un sensor de gravedad específico de un proveedor y otro conjunto de reglas y optimizaciones de filtrado de datos para dispositivos que no tienen sensor de gravedad y solo tienen un acelerómetro. En la siguiente muestra de código, se indica cómo puedes usar los métodos getVendor()
y getVersion()
para hacerlo. En esta muestra, buscamos un sensor de gravedad que indique a Google LLC como proveedor y que tenga el número de versión 3. Si ese sensor en particular no está presente en el dispositivo, intentamos usar el acelerómetro.
Kotlin
private lateinit var sensorManager: SensorManager private var mSensor: Sensor? = null ... sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager if (sensorManager.getDefaultSensor(Sensor.TYPE_GRAVITY) != null) { val gravSensors: List<Sensor> = sensorManager.getSensorList(Sensor.TYPE_GRAVITY) // Use the version 3 gravity sensor. mSensor = gravSensors.firstOrNull { it.vendor.contains("Google LLC") && it.version == 3 } } if (mSensor == null) { // Use the accelerometer. mSensor = if (sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER) != null) { sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER) } else { // Sorry, there are no accelerometers on your device. // You can't play this game. null } }
Java
private SensorManager sensorManager; private Sensor mSensor; ... sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE); mSensor = null; if (sensorManager.getDefaultSensor(Sensor.TYPE_GRAVITY) != null){ List<Sensor> gravSensors = sensorManager.getSensorList(Sensor.TYPE_GRAVITY); for(int i=0; i<gravSensors.size(); i++) { if ((gravSensors.get(i).getVendor().contains("Google LLC")) && (gravSensors.get(i).getVersion() == 3)){ // Use the version 3 gravity sensor. mSensor = gravSensors.get(i); } } } if (mSensor == null){ // Use the accelerometer. if (sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER) != null){ mSensor = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER); } else{ // Sorry, there are no accelerometers on your device. // You can't play this game. } }
Otro método útil es el método getMinDelay()
, que muestra el intervalo de tiempo mínimo (en microsegundos) que un sensor puede usar para detectar datos. Cualquier sensor que muestre un valor distinto de cero para el método getMinDelay()
es un sensor de transmisión. Los sensores de transmisión detectan datos a intervalos regulares y se introdujeron en Android 2.3 (nivel de API 9). Si un sensor muestra cero cuando llamas al método getMinDelay()
, significa que el sensor no es un sensor de transmisión porque informa datos solo cuando hay un cambio en los parámetros que está detectando.
El método getMinDelay()
es útil porque te permite determinar la velocidad máxima a la que un sensor puede adquirir datos. Si ciertas características de tu aplicación requieren altas tasas de adquisición de datos o un sensor de transmisión, puedes usar este método para determinar si un sensor cumple con esos requisitos y luego habilitar o inhabilitar las funciones relevantes en tu aplicación según corresponda.
Precaución: La velocidad máxima de adquisición de datos de un sensor no es necesariamente la velocidad a la que el marco de trabajo del sensor entrega los datos del sensor a tu aplicación. El framework del sensor informa los datos a través de eventos del sensor, y varios factores influyen en la velocidad a la que tu aplicación recibe los eventos del sensor. Para obtener más información, consulta Cómo supervisar los eventos del sensor.
Cómo supervisar los eventos del sensor
Para supervisar los datos sin procesar del sensor, debes implementar dos métodos de devolución de llamada expuestos a través de la interfaz SensorEventListener
: onAccuracyChanged()
y onSensorChanged()
. El sistema Android llama a estos métodos siempre que ocurre lo siguiente:
- La precisión de un sensor cambia.
En este caso, el sistema invoca el método
onAccuracyChanged()
, que te proporciona una referencia al objetoSensor
que cambió y la nueva precisión del sensor. Una de las cuatro constantes de estado representa la exactitud:SENSOR_STATUS_ACCURACY_LOW
,SENSOR_STATUS_ACCURACY_MEDIUM
,SENSOR_STATUS_ACCURACY_HIGH
oSENSOR_STATUS_UNRELIABLE
. - Un sensor informa un valor nuevo.
En este caso, el sistema invoca el método
onSensorChanged()
, que te proporciona un objetoSensorEvent
. Un objetoSensorEvent
contiene información sobre los nuevos datos del sensor, por ejemplo, la exactitud de los datos, el sensor que generó los datos, la marca de tiempo en la que se generaron los datos y los nuevos datos que registró el sensor.
En el siguiente código, se muestra cómo usar el método onSensorChanged()
para supervisar los datos del sensor de luz. En este ejemplo, se muestran los datos sin procesar del sensor en un TextView
que se define en el archivo main.xml como sensor_data
.
Kotlin
class SensorActivity : Activity(), SensorEventListener { private lateinit var sensorManager: SensorManager private var mLight: Sensor? = null public override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.main) sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager mLight = sensorManager.getDefaultSensor(Sensor.TYPE_LIGHT) } override fun onAccuracyChanged(sensor: Sensor, accuracy: Int) { // Do something here if sensor accuracy changes. } override fun onSensorChanged(event: SensorEvent) { // The light sensor returns a single value. // Many sensors return 3 values, one for each axis. val lux = event.values[0] // Do something with this sensor value. } override fun onResume() { super.onResume() mLight?.also { light -> sensorManager.registerListener(this, light, SensorManager.SENSOR_DELAY_NORMAL) } } override fun onPause() { super.onPause() sensorManager.unregisterListener(this) } }
Java
public class SensorActivity extends Activity implements SensorEventListener { private SensorManager sensorManager; private Sensor mLight; @Override public final void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE); mLight = sensorManager.getDefaultSensor(Sensor.TYPE_LIGHT); } @Override public final void onAccuracyChanged(Sensor sensor, int accuracy) { // Do something here if sensor accuracy changes. } @Override public final void onSensorChanged(SensorEvent event) { // The light sensor returns a single value. // Many sensors return 3 values, one for each axis. float lux = event.values[0]; // Do something with this sensor value. } @Override protected void onResume() { super.onResume(); sensorManager.registerListener(this, mLight, SensorManager.SENSOR_DELAY_NORMAL); } @Override protected void onPause() { super.onPause(); sensorManager.unregisterListener(this); } }
En este ejemplo, el retraso de los datos predeterminado (SENSOR_DELAY_NORMAL
) se especifica cuando se invoca el método registerListener()
. El retraso de datos (o tasa de muestreo) controla el intervalo en el que se envían los eventos del sensor a tu aplicación a través del método de devolución de llamada onSensorChanged()
. El retraso de datos predeterminado es adecuado para supervisar los cambios típicos de orientación de la pantalla y utiliza un retraso de 200,000 microsegundos. Puedes especificar otros retrasos de datos, como SENSOR_DELAY_GAME
(retraso de 20,000 microsegundos), SENSOR_DELAY_UI
(retraso de 60,000 microsegundos) o SENSOR_DELAY_FASTEST
(retraso de 0 microsegundos). A partir de Android 3.0 (nivel de API 11), también puedes especificar el retraso como un valor absoluto (en microsegundos).
El retraso que especificas es solo un retraso sugerido. El sistema Android y otras aplicaciones pueden modificar esta demora. Como práctica recomendada, debes especificar el retraso más grande que puedas, ya que el sistema suele usar un retraso menor que el que especificas (es decir, debes elegir la tasa de muestreo más lenta que aún satisfaga las necesidades de tu aplicación). El uso de un retraso mayor impone una carga menor en el procesador y, por lo tanto, usa menos energía.
No hay un método público para determinar la velocidad a la que el marco de trabajo del sensor envía eventos de sensores a tu aplicación. Sin embargo, puedes usar las marcas de tiempo asociadas con cada evento del sensor para calcular la tasa de muestreo de varios eventos. No deberías tener que cambiar la tasa de muestreo (retraso) una vez que la configures. Si por algún motivo necesitas cambiar el retraso, deberás cancelar el registro y volver a registrar el objeto de escucha del sensor.
También es importante tener en cuenta que, en este ejemplo, se usan los métodos de devolución de llamada onResume()
y onPause()
para registrar y cancelar el registro del objeto de escucha de eventos del sensor. Como práctica recomendada, siempre debes inhabilitar los sensores que no necesitas, en especial cuando la actividad está detenida. De lo contrario, es posible que la batería se agote en unas horas, ya que algunos sensores tienen requisitos de energía considerables y pueden agotar la batería con rapidez. El sistema no inhabilitará los sensores automáticamente cuando la pantalla se apague.
Cómo controlar diferentes configuraciones del sensor
Android no especifica una configuración de sensor estándar para los dispositivos, lo que significa que los fabricantes de dispositivos pueden incorporar cualquier configuración de sensor que deseen en sus dispositivos con Android. Como resultado, los dispositivos pueden incluir una variedad de sensores en una amplia gama de configuraciones. Si tu aplicación depende de un tipo específico de sensor, debes asegurarte de que el sensor esté presente en un dispositivo para que la app pueda ejecutarse correctamente.
Tienes dos opciones para garantizar que un sensor determinado esté presente en un dispositivo:
- Detecta sensores en el tiempo de ejecución y habilita o inhabilita las características de la aplicación según corresponda.
- Usa los filtros de Google Play para apuntar a dispositivos con configuraciones de sensor específicas.
En las siguientes secciones, se analiza cada una de las opciones.
Detecta los sensores en el tiempo de ejecución
Si tu aplicación usa un tipo específico de sensor, pero no depende de él, puedes usar el framework del sensor para detectar el sensor en el tiempo de ejecución y, luego, inhabilitar o habilitar las funciones de la aplicación según corresponda. Por ejemplo, una aplicación de navegación podría usar los sensores de temperatura, los de presión, los de GPS y los de campo geomagnético para mostrar la temperatura, la presión barométrica, la ubicación y la orientación de la brújula. Si un dispositivo no tiene sensor de presión, puedes usar el framework del sensor para detectar la ausencia del sensor de presión en el tiempo de ejecución y, luego, inhabilitar la parte de la IU de tu aplicación que muestra la presión. Por ejemplo, el siguiente código verifica si hay un sensor de presión en un dispositivo:
Kotlin
private lateinit var sensorManager: SensorManager ... sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager if (sensorManager.getDefaultSensor(Sensor.TYPE_PRESSURE) != null) { // Success! There's a pressure sensor. } else { // Failure! No pressure sensor. }
Java
private SensorManager sensorManager; ... sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE); if (sensorManager.getDefaultSensor(Sensor.TYPE_PRESSURE) != null){ // Success! There's a pressure sensor. } else { // Failure! No pressure sensor. }
Usa los filtros de Google Play para orientar configuraciones específicas de sensores
Si publicas tu aplicación en Google Play, puedes usar el elemento <uses-feature>
en el archivo de manifiesto para filtrar tu aplicación y excluir dispositivos que no tengan la configuración de sensor adecuada para tu aplicación. El elemento <uses-feature>
tiene varios descriptores de hardware que te permiten filtrar aplicaciones en función de la presencia de sensores específicos. Entre los sensores que puedes enumerar, se incluyen los siguientes: acelerómetro, barómetro, brújula (campo geomagnético), giroscopio, luz y proximidad. La siguiente es una entrada de manifiesto de ejemplo que filtra las apps que no tienen un acelerómetro:
<uses-feature android:name="android.hardware.sensor.accelerometer" android:required="true" />
Si agregas este elemento y descriptor al manifiesto de tu aplicación, los usuarios verán tu aplicación en Google Play solo si su dispositivo tiene un acelerómetro.
Debes establecer el descriptor en android:required="true"
solo si tu aplicación se basa por completo en un sensor específico. Si tu aplicación usa un sensor para alguna funcionalidad, pero aún se ejecuta sin el sensor, debes incluir el sensor en el elemento <uses-feature>
, pero establecer el descriptor en android:required="false"
. Esto ayuda a garantizar que los dispositivos puedan instalar tu app incluso si no tienen ese sensor en particular. Esta también es una práctica recomendada de administración de proyectos que te ayuda a realizar un seguimiento de las funciones que usa tu aplicación.
Ten en cuenta que, si tu aplicación usa un sensor en particular, pero aún se ejecuta sin el sensor, debes detectar el sensor en el tiempo de ejecución e inhabilitar o habilitar las funciones de la aplicación según corresponda.
Sistema de coordenadas del sensor
En general, el marco de trabajo del sensor utiliza un sistema de coordenadas estándar de 3 ejes para expresar valores de datos. Para la mayoría de los sensores, el sistema de coordenadas se define en relación con la pantalla del dispositivo cuando este se mantiene en su orientación predeterminada (consulta la figura 1). Cuando un dispositivo se mantiene en su orientación predeterminada, el eje X es horizontal y apunta hacia la derecha, el eje Y es vertical y apunta hacia arriba, y el eje Z apunta hacia el exterior de la cara de la pantalla. En este sistema, las coordenadas detrás de la pantalla tienen valores Z negativos. Los siguientes sensores utilizan este sistema de coordenadas:
![](https://developer.android.google.cn/static/images/axis_device.png?authuser=5&hl=es)
Figura 1: Sistema de coordenadas (en relación con un dispositivo) que usa la API del sensor.
- Sensor de aceleración
- Sensor de gravedad
- Giroscopio
- Sensor de aceleración lineal
- Sensor de campo geomagnético
El punto más importante que debes comprender sobre este sistema de coordenadas es que los ejes no se intercambian cuando cambia la orientación de la pantalla del dispositivo, es decir, el sistema de coordenadas del sensor nunca cambia a medida que se mueve el dispositivo. Este comportamiento es el mismo que el del sistema de coordenadas OpenGL.
Otro punto que debes comprender es que tu aplicación no debe suponer que la orientación natural (predeterminada) de un dispositivo es vertical. La orientación natural de muchos dispositivos tablet es horizontal. Además, el sistema de coordenadas del sensor siempre se basa en la orientación natural de un dispositivo.
Por último, si tu aplicación hace coincidir los datos del sensor con la pantalla en pantalla, debes usar el método getRotation()
para determinar la rotación de la pantalla y, luego, usar el método remapCoordinateSystem()
para asignar las coordenadas del sensor a las coordenadas de la pantalla. Debes hacer esto incluso si el manifiesto especifica una pantalla solo vertical.
Nota: Algunos sensores y métodos usan un sistema de coordenadas que está relacionado con el marco de referencia del mundo (a diferencia del marco de referencia del dispositivo). Estos sensores y métodos devuelven datos que representan el movimiento del dispositivo o su posición en relación con la Tierra. Para obtener más información, consulta el método getOrientation()
, el método getRotationMatrix()
, el sensor de orientación y el sensor del vector de rotación.
Límite de frecuencia del sensor
Para proteger información potencialmente sensible sobre los usuarios, si tu app se orienta a Android 12 (nivel de API 31) o versiones posteriores, el sistema establece un límite en la frecuencia de actualización de datos de ciertos sensores de movimiento y de posición. Estos datos incluyen valores registrados por el acelerómetro, el giroscopio y el sensor de campo geomagnético del dispositivo.
El límite de frecuencia de actualización depende de la manera en que accedes a los datos del sensor:
- Si llamas al método
registerListener()
para supervisar los eventos del sensor, la tasa de muestreo del sensor se limita a 200 Hz. Esto se aplica a todas las variantes sobrecargadas del métodoregisterListener()
. - Si usas la clase
SensorDirectChannel
, la tasa de muestreo del sensor se limita aRATE_NORMAL
, que suele ser, aproximadamente, 50 Hz.
Si tu app necesita recopilar datos del sensor de movimiento con una frecuencia mayor, debes declarar el permiso HIGH_SAMPLING_RATE_SENSORS
, como se muestra en el siguiente fragmento de código. De lo contrario, si tu app intenta recopilar datos del sensor de movimiento con una frecuencia más alta sin declarar este permiso, se produce una SecurityException
.
AndroidManifest.xml
<manifest ...> <uses-permission android:name="android.permission.HIGH_SAMPLING_RATE_SENSORS"/> <application ...> ... </application> </manifest>
Prácticas recomendadas para acceder a los sensores y usarlos
Cuando diseñes la implementación del sensor, asegúrate de seguir las pautas que se analizan en esta sección. Estos lineamientos son prácticas recomendadas para cualquier persona que use el marco de trabajo del sensor para acceder a los sensores y adquirir sus datos.
Recopila solo datos de los sensores en segundo plano
En los dispositivos que ejecutan Android 9 (nivel de API 28) o versiones posteriores, las apps que se ejecutan en segundo plano tienen las siguientes restricciones:
- Los sensores que usan el modo de generación de informes continuo, como acelerómetros y giroscopios, no reciben eventos.
- Los sensores que usan los modos de generación de informes ante un cambio o por única vez no reciben eventos.
Dadas estas restricciones, es mejor detectar los eventos de sensores cuando la app está en primer plano o como parte de un servicio en primer plano.
Cancela el registro de los objetos de escucha de los sensores
Asegúrate de cancelar el registro del objeto de escucha de un sensor cuando termines de usar el sensor o cuando se detenga la actividad del sensor. Si se registra un objeto de escucha del sensor y se detiene su actividad, el sensor seguirá adquiriendo datos y usando recursos de la batería, a menos que canceles el registro del sensor. En el siguiente código, se muestra cómo usar el método onPause()
para cancelar el registro de un objeto de escucha:
Kotlin
private lateinit var sensorManager: SensorManager ... override fun onPause() { super.onPause() sensorManager.unregisterListener(this) }
Java
private SensorManager sensorManager; ... @Override protected void onPause() { super.onPause(); sensorManager.unregisterListener(this); }
Para obtener más detalles, consulta la información de unregisterListener(SensorEventListener)
.
Haz una prueba con Android Emulator
Android Emulator incluye un conjunto de controles de sensores virtuales que te permiten probar sensores como el acelerómetro, la temperatura ambiente, el magnetómetro, la proximidad, la luz y mucho más.
El emulador usa una conexión con un dispositivo Android que ejecuta la app SdkControllerSensor. Ten en cuenta que esta app solo está disponible en dispositivos con Android 4.0 (nivel de API 14) o versiones posteriores. (Si el dispositivo ejecuta Android 4.0, debe tener instalada la Versión 2). La app SdkControllerSensor supervisa los cambios en los sensores del dispositivo y los transmite al emulador. Luego, el emulador se transforma en función de los valores nuevos que recibe de los sensores de tu dispositivo.
Puedes ver el código fuente de la app SdkControllerSensor en la siguiente ubicación:
$ your-android-sdk-directory/tools/apps/SdkController
Para transferir datos entre tu dispositivo y el emulador, sigue estos pasos:
- Comprueba que la depuración por USB esté habilitada en tu dispositivo.
- Conecta el dispositivo a la máquina de desarrollo con un cable USB.
- Inicia la app SdkControllerSensor en tu dispositivo.
- En la app, selecciona los sensores que quieras emular.
Ejecuta el siguiente comando
adb
:- Inicia el emulador. Ahora deberías poder aplicar transformaciones al emulador moviendo el dispositivo.
$ adb forward tcp:1968 tcp:1968
Nota: Si los movimientos que haces en el dispositivo físico no transforman el emulador, intenta ejecutar el comando adb
del paso 5 nuevamente.
Para obtener más información, consulta la guía de Android Emulator.
No bloquees el método onSensorChanged()
Los datos del sensor pueden cambiar a una velocidad alta, lo que significa que es posible que el sistema llame al método onSensorChanged(SensorEvent)
con bastante frecuencia. Como práctica recomendada, debes hacer lo menos posible dentro del método onSensorChanged(SensorEvent)
para no bloquearlo. Si tu aplicación requiere que realices algún filtrado de datos o reduzcas los datos de sensores, debes realizar ese trabajo fuera del método onSensorChanged(SensorEvent)
.
Evita usar métodos o tipos de sensores obsoletos
Varios métodos y constantes ya no están disponibles.
En particular, el tipo de sensor TYPE_ORIENTATION
dejó de estar disponible. Para obtener datos de orientación, debes utilizar el método getOrientation()
en su lugar. Del mismo modo, el tipo de sensor TYPE_TEMPERATURE
dejó de estar disponible. En su lugar, debes usar el tipo de sensor TYPE_AMBIENT_TEMPERATURE
en dispositivos que ejecutan Android 4.0.
Comprueba los sensores antes de usarlos
Siempre comprueba que existe un sensor en un dispositivo antes de intentar obtener datos de él. No supongas que existe un sensor simplemente porque es un sensor de uso frecuente. Los fabricantes de dispositivos no están obligados a proporcionar sensores particulares en sus dispositivos.
Elige los retrasos del sensor con cuidado
Cuando registres un sensor con el método registerListener()
, asegúrate de elegir un ritmo de entrega que sea adecuado para tu aplicación o caso de uso. Los sensores pueden proporcionar datos a ritmos muy rápidos. Permitir que el sistema envíe datos adicionales que no necesitas desperdicia recursos del sistema y utiliza energía de la batería.