La plupart des appareils Android sont équipés de capteurs intégrés qui mesurent les mouvements, l'orientation, et diverses conditions environnementales. Ces capteurs sont capables de fournir des données brutes avec une forte la précision et l'exactitude. Ils sont utiles si vous souhaitez surveiller le mouvement d'un appareil en trois dimensions ou ou de surveiller les changements dans l'environnement ambiant à proximité d'un appareil. Par exemple, un peut suivre les mesures du capteur de gravité d'un appareil pour déduire des gestes complexes des utilisateurs et mouvements, comme une inclinaison, un tremblement, une rotation ou un mouvement de balancier. De même, une application météo peut utiliser le capteur de température et d'humidité de l'appareil pour calculer et indiquer le point de rosée, ou une distance application peut utiliser le capteur de champ géomagnétique et l'accéléromètre pour signaler une boussole de direction.
Consultez les ressources associées suivantes :
- Capteurs
- Capteurs de mouvement
- Position Capteurs
- Environnement Capteurs
- <ph type="x-smartling-placeholder"></ph> Démonstrations de l'API (OS : RotationVectorDemo)
La plate-forme Android est compatible avec trois grandes catégories de capteurs:
- Capteurs de mouvement
Ces capteurs mesurent les forces d'accélération et de rotation sur trois axes. Ce inclut les accéléromètres, les capteurs de gravité, les gyroscopes et les vecteurs de rotation capteurs.
- Capteurs d'ambiance
Ces capteurs mesurent différents paramètres environnementaux, tels que la température de l'air ambiant la pression, l'éclairage et l'humidité. Cette catégorie comprend les baromètres, les photomètres et thermomètres.
- Capteurs de position
Ces capteurs mesurent la position physique d'un appareil. Cette catégorie comprend les éléments suivants : les capteurs d'orientation et les magnétomètres.
Vous pouvez accéder aux capteurs disponibles sur l'appareil et obtenir leurs données brutes à l'aide de l'application Android de capteurs. Le framework de capteurs fournit plusieurs classes et interfaces pour vous aider à effectuer un grand pour diverses tâches liées aux capteurs. Par exemple, vous pouvez utiliser le framework du capteur pour:
- Déterminer les capteurs disponibles sur un appareil
- Déterminer les caractéristiques d'un capteur individuel : portée maximale, fabricant, puissance les exigences et la résolution.
- Collecte des données brutes des capteurs et définition de la fréquence minimale d'acquisition de ces données
- Enregistrez et annulez l'enregistrement des écouteurs d'événements de capteurs qui surveillent les modifications des capteurs.
Cet article présente les capteurs disponibles sur la plate-forme Android. Il présente également la structure des capteurs.
Présentation des capteurs
Android Sensor Framework vous permet d'accéder à de nombreux types de capteurs. Certains de ces capteurs sont basés sur le matériel et d'autres sur des logiciels. Les capteurs matériels sont des composants physiques conçus sur un téléphone ou une tablette. Ils extraient leurs données en mesurant directement des données environnementales spécifiques telles que l'accélération, l'intensité du champ géomagnétique ou le changement d'angle. Basée sur un logiciel les capteurs ne sont pas des appareils physiques, bien qu'ils imitent des capteurs matériels. Capteurs logiciels peuvent extraire leurs données d'un ou de plusieurs des capteurs matériels, et sont parfois appelés ou des capteurs synthétiques. Le capteur d'accélération linéaire et le capteur de gravité sont des exemples des capteurs logiciels. Le tableau 1 récapitule les capteurs compatibles avec l'application Android Google Cloud.
Peu d'appareils Android sont équipés de capteurs de ce type. Par exemple, la plupart des téléphones portables et les tablettes sont équipées d'un accéléromètre et d'un magnétomètre, mais elles sont moins nombreuses baromètres ou thermomètres. En outre, un appareil peut être équipé de plusieurs capteurs d'un type donné. Pour exemple, un appareil peut avoir deux capteurs de gravité, chacun ayant une portée différente.
Tableau 1. Types de capteurs compatibles avec la plate-forme Android.
Capteur | Type | Description | Utilisations courantes |
---|---|---|---|
TYPE_ACCELEROMETER |
Matériel | Mesure la force d'accélération en m/s2 appliquée à un appareil sur les trois axes physiques (x, y et z), y compris la force de gravité. | Détection des mouvements (secousses, inclinaison, etc.) |
TYPE_AMBIENT_TEMPERATURE |
Matériel | Mesure la température ambiante d'une pièce en degrés Celsius (°C). Voir la remarque ci-dessous. | Surveiller la température de l'air. |
TYPE_GRAVITY |
Logiciel ou matériel | Mesure la force de gravité en m/s2, appliquée à un appareil sur trois axes physiques (x, y, z). | Détection des mouvements (secousses, inclinaison, etc.) |
TYPE_GYROSCOPE |
Matériel | Mesure le taux de rotation d'un appareil en rad/s autour de chacun des trois axes physiques (x, y et z). | Détection de la rotation (rotation, virage, etc.) |
TYPE_LIGHT |
Matériel | Mesure le niveau de luminosité ambiante (illumination) en lx. | Contrôle de la luminosité de l'écran |
TYPE_LINEAR_ACCELERATION |
Logiciel ou matériel | Mesure la force d'accélération en m/s2, soit appliquée à un appareil sur les trois axes physiques (x, y et z), à l'exclusion de la force de gravité. | Surveiller l'accélération sur un seul axe |
TYPE_MAGNETIC_FIELD |
Matériel | Mesure le champ géomagnétique ambiant pour les trois axes physiques (x, y, z) dans μT. | Création d'une boussole... |
TYPE_ORIENTATION |
Logiciel | Mesure les degrés de rotation effectués par un appareil autour des trois axes physiques (x, y, z).
À partir du niveau d'API 3, vous pouvez obtenir la matrice d'inclinaison et la matrice de rotation pour
un appareil en utilisant le capteur de gravité et le capteur de champ géomagnétique conjointement avec
l'/le/la getRotationMatrix()
. |
Déterminer la position de l'appareil. |
TYPE_PRESSURE |
Matériel | Mesure la pression de l'air ambiant en hPa ou mbar. | Surveiller les variations de la pression atmosphérique |
TYPE_PROXIMITY |
Matériel | Mesure la proximité d'un objet (en cm) par rapport à l'écran d'un appareil. Ce capteur est généralement utilisé pour déterminer si le téléphone est tenu l'oreille d'une personne. | Position du téléphone au cours d'un appel. |
TYPE_RELATIVE_HUMIDITY |
Matériel | Mesure l'humidité ambiante relative en pourcentage (%). | Surveillez le point de rosée, l'humidité absolue et l'humidité relative. |
TYPE_ROTATION_VECTOR |
Logiciel ou matériel | Mesure l'orientation d'un appareil en fournissant les trois éléments de son un vecteur de rotation. | Détection des mouvements et de la rotation |
TYPE_TEMPERATURE |
Matériel | Mesure la température de l'appareil en degrés Celsius (°C). Ce capteur
l'implémentation varie selon les appareils
ce capteur a été remplacé par celui de TYPE_AMBIENT_TEMPERATURE dans
Niveau d'API 14 |
Surveillance des températures |
Cadre de capteur
Vous pouvez accéder à ces capteurs et acquérir les données brutes des capteurs à l'aide du framework de capteurs Android.
Le framework du capteur fait partie du package android.hardware
et inclut les éléments suivants :
et interfaces utilisateur:
SensorManager
- Vous pouvez utiliser cette classe pour créer une instance du service de capteurs. Cette classe fournit diverses méthodes permettant d'accéder aux capteurs et de les lister, d'enregistrer et d'annuler l'enregistrement des événements liés aux capteurs. et l'acquisition d'informations d'orientation. Cette classe fournit également plusieurs constantes de capteur permettant de rendre compte de la précision des capteurs, de définir les taux d'acquisition de données et de calibrer les capteurs.
Sensor
- Vous pouvez utiliser cette classe pour créer une instance d'un capteur spécifique. Cette classe fournit diverses qui vous permettent de déterminer les capacités d'un capteur.
SensorEvent
- Le système utilise cette classe pour créer un objet événement de capteur, qui fournit des informations sur une événement du capteur. Un objet événement de capteur inclut les informations suivantes: les données brutes du capteur, les le type de capteur ayant généré l'événement, la précision des données et l'horodatage de l'événement .
SensorEventListener
- Vous pouvez utiliser cette interface pour créer deux méthodes de rappel qui reçoivent des notifications (un capteur les événements) lorsque les valeurs du capteur changent ou que sa précision change.
Dans une application type, vous utilisez ces API liées aux capteurs pour effectuer deux tâches de base:
- Identifier les capteurs et leurs caractéristiques
L'identification des capteurs et de leurs caractéristiques au moment de l'exécution est utile si votre application qui reposent sur des types ou des capacités de capteurs spécifiques. Par exemple, vous pouvez identifier tous les capteurs d'un appareil et désactiver les fonctionnalités de l'application ; reposent sur des capteurs absents. De même, il peut être utile d'identifier tous les capteurs d'un type donné, ce qui vous permet de choisir l'implémentation de capteurs offrant les meilleures performances pour votre application.
- Surveiller les événements des capteurs
La surveillance des événements de capteurs vous permet d'obtenir les données brutes des capteurs. Un événement de capteur se produit à chaque fois un capteur détecte un changement des paramètres qu'il mesure. Un événement de capteur vous indique avec quatre informations: le nom du capteur ayant déclenché l'événement, le code temporel de l'événement, sa précision et les données brutes du capteur ayant déclenché l'événement.
Disponibilité des capteurs
La disponibilité des capteurs varie d'un appareil à l'autre, mais elle peut également varier d'un appareil Android à l'autre. versions. En effet, les capteurs Android ont été introduits au cours de plusieurs de la plate-forme. Par exemple, de nombreux capteurs ont été introduits dans Android 1.5 (niveau d'API 3), mais certains n'étaient pas implémentées et ne pouvaient être utilisées qu'à partir d'Android 2.3 (niveau d'API 9). De même, plusieurs capteurs ont été introduits dans Android 2.3 (niveau d'API 9) et Android 4.0 (niveau d'API 14). Deux les capteurs ont été abandonnés et remplacés par de nouveaux capteurs de meilleure qualité.
Le tableau 2 récapitule la disponibilité de chaque capteur en fonction de la plate-forme. Seulement quatre les plateformes sont listées, car ce sont les plateformes qui ont impliqué des changements de capteurs. Les capteurs qui sont répertoriés comme obsolètes restent disponibles sur les plates-formes suivantes (à condition que les est présent sur l'appareil), ce qui est conforme à la règle de compatibilité ascendante d'Android.
Tableau 2. Disponibilité des capteurs par plate-forme.
Capteur | Android 4.0 (niveau d'API 14) |
Android 2.3 (niveau d'API 9) |
Android 2.2 (niveau d'API 8) |
Android 1.5 (niveau d'API 3) |
---|---|---|---|---|
TYPE_ACCELEROMETER |
Oui | Oui | Oui | Oui |
TYPE_AMBIENT_TEMPERATURE |
Oui | n/a | n/a | n/a |
TYPE_GRAVITY |
Oui | Oui | n/a | n/a |
TYPE_GYROSCOPE |
Oui | Oui | N/A1 | N/A1 |
TYPE_LIGHT |
Oui | Oui | Oui | Oui |
TYPE_LINEAR_ACCELERATION |
Oui | Oui | n/a | n/a |
TYPE_MAGNETIC_FIELD |
Oui | Oui | Oui | Oui |
TYPE_ORIENTATION |
Oui2 | Oui2 | Oui2 | Oui |
TYPE_PRESSURE |
Oui | Oui | N/A1 | N/A1 |
TYPE_PROXIMITY |
Oui | Oui | Oui | Oui |
TYPE_RELATIVE_HUMIDITY |
Oui | n/a | n/a | n/a |
TYPE_ROTATION_VECTOR |
Oui | Oui | n/a | n/a |
TYPE_TEMPERATURE |
Oui2 | Oui | Oui | Oui |
1 Ce type de capteur a été ajouté dans Android 1.5 (niveau d'API). 3), mais elle n'était disponible qu'à partir d'Android 2.3 (niveau d'API 9).
2 Ce capteur est disponible, mais il a été obsolète.
Identification des capteurs et de leurs capacités
Android Sensor Framework propose plusieurs méthodes vous permettant de déterminer facilement quel est l'environnement d'exécution des capteurs d'un appareil. L'API fournit également des méthodes vous permettant de déterminer de chaque capteur, telles que sa portée maximale, sa résolution et sa puissance exigences.
Pour identifier les capteurs d'un appareil, vous devez d'abord obtenir une référence au capteur
Google Cloud. Pour ce faire, vous devez créer une instance de la classe SensorManager
en appelant la méthode getSystemService()
et en transmettant
dans l'argument SENSOR_SERVICE
. Exemple :
Kotlin
private lateinit var sensorManager: SensorManager ... sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
Java
private SensorManager sensorManager; ... sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
Vous pouvez ensuite obtenir la liste de tous les capteurs d'un appareil en appelant la méthode
getSensorList()
et à l'aide de la constante TYPE_ALL
. Exemple :
Kotlin
val deviceSensors: List<Sensor> = sensorManager.getSensorList(Sensor.TYPE_ALL)
Java
List<Sensor> deviceSensors = sensorManager.getSensorList(Sensor.TYPE_ALL);
Si vous voulez répertorier tous les capteurs d'un type donné, vous pouvez utiliser une autre constante au lieu de
TYPE_ALL
, par exemple TYPE_GYROSCOPE
,
TYPE_LINEAR_ACCELERATION
ou
TYPE_GRAVITY
Vous pouvez également déterminer si un type spécifique de capteur existe sur un appareil en utilisant la méthode getDefaultSensor()
et en transmettant le type.
pour un capteur spécifique. Si un appareil est équipé de plusieurs capteurs d'un type donné, l'un des
les capteurs doivent être définis comme capteurs par défaut. Si aucun capteur par défaut n'existe pour un
type de capteur, l'appel de méthode renvoie "null", ce qui signifie que l'appareil ne possède pas ce type de
capteur vidéo. Par exemple, le code suivant vérifie si un appareil est doté d'un magnétomètre:
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. }
Remarque:Android n'exige pas des fabricants d'appareils qu'ils créent des de capteurs particuliers dans leurs appareils Android, de sorte qu'ils disposent d'un large éventail de configurations de capteurs.
En plus de répertorier les capteurs d'un appareil, vous pouvez utiliser les méthodes publiques de
Sensor
pour déterminer les capacités et les attributs d'une personne
capteurs. Cette fonctionnalité est utile si vous souhaitez que votre application
se comporte différemment selon les capteurs ou
les capacités des capteurs sont disponibles sur un appareil. Par exemple, vous pouvez utiliser getResolution()
et getMaximumRange()
.
pour obtenir la résolution et la plage de mesure maximale d'un capteur. Vous pouvez également utiliser
getPower()
pour connaître la puissance requise d'un capteur.
Deux des méthodes publiques sont particulièrement utiles si vous souhaitez optimiser votre application
les capteurs de différents fabricants
ou les différentes versions d'un même capteur. Par exemple, si votre application
doit surveiller les gestes des utilisateurs, comme l'inclinaison et le tremblement, vous pouvez créer un ensemble de filtres de données
des règles et optimisations pour les appareils plus récents dotés d'un capteur de gravité d'un fournisseur spécifique, et d'un autre
ensemble de règles de filtrage des données et d'optimisations pour les appareils dépourvus de capteur de gravité et présentant
qu'un accéléromètre. L'exemple de code suivant vous montre comment effectuer les opérations à l'aide des méthodes getVendor()
et getVersion()
.
cette étape. Dans cet exemple, nous recherchons un capteur de gravité qui indique Google LLC comme fournisseur.
possède le numéro de version 3. Si ce capteur n'est pas présent sur l'appareil, nous essayons d'utiliser le
accéléromètre.
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. } }
La méthode getMinDelay()
est également utile.
qui renvoie l'intervalle de temps minimal (en microsecondes) qu'un capteur peut utiliser pour détecter des données. N'importe quel capteur
qui renvoie une valeur non nulle pour getMinDelay()
est une méthode de traitement par flux
capteur vidéo. Les capteurs de flux détectent les données à intervalles réguliers et ont été introduits dans Android 2.3 (API
niveau 9). Si un capteur renvoie zéro lorsque vous appelez la méthode getMinDelay()
, cela signifie que
n'est pas un capteur par flux, car il transmet des données uniquement en cas de changement au niveau
les paramètres qu'il détecte.
La méthode getMinDelay()
est utile, car elle permet
vous déterminez le taux maximal
permettant à un capteur d'acquérir des données. Si certaines fonctionnalités de votre application nécessitent un volume de données élevé
ou un capteur de flux, vous pouvez utiliser cette méthode pour déterminer
respecte ces conditions, puis activer ou désactiver les fonctionnalités adéquates dans votre application
en conséquence.
Attention:Le taux maximal d'acquisition de données d'un capteur la vitesse à laquelle le framework du capteur envoie les données de capteur à votre application. La capteur transmet les données par le biais d'événements de capteurs, et plusieurs facteurs influencent la fréquence à laquelle votre application reçoit les événements de capteurs. Pour en savoir plus, consultez la section Surveiller les événements de capteurs.
Surveiller les événements de capteurs
Pour surveiller les données brutes des capteurs, vous devez implémenter deux méthodes de rappel, exposées via
l'interface SensorEventListener
: onAccuracyChanged()
et onSensorChanged()
. Le système Android appelle
ces méthodes chaque fois que les événements suivants se produisent:
- La précision d'un capteur change.
Dans ce cas, le système appelle la méthode
onAccuracyChanged()
, en fournissant une référence à l'objetSensor
qui a été modifié et la précision du capteur. La précision est représentée par l'une des quatre constantes d'état:SENSOR_STATUS_ACCURACY_LOW
,SENSOR_STATUS_ACCURACY_MEDIUM
,SENSOR_STATUS_ACCURACY_HIGH
, ouSENSOR_STATUS_UNRELIABLE
. - Un capteur signale une nouvelle valeur.
Dans ce cas, le système appelle la méthode
onSensorChanged()
, ce qui vous fournit un objetSensorEvent
. Un objetSensorEvent
contient des informations sur les nouvelles données des capteurs, y compris: la précision des données, le capteur qui a généré les données, le code temporel de la génération des données enregistrées par le capteur.
Le code suivant montre comment utiliser la méthode onSensorChanged()
pour surveiller les données de
le capteur de lumière. Cet exemple affiche les données brutes des capteurs dans un TextView
.
qui est
défini dans le fichier main.xml comme 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); } }
Dans cet exemple, le délai de données par défaut (SENSOR_DELAY_NORMAL
) est spécifié lorsque la méthode registerListener()
est appelée. Les données
Le délai (ou taux d'échantillonnage) contrôle l'intervalle auquel les événements des capteurs sont envoyés à votre application.
via la méthode de rappel onSensorChanged()
. La valeur par défaut
le délai entre les données est adapté à la surveillance
l'orientation habituelle d'un écran change et utilise un délai de 200 000 microsecondes. Vous pouvez spécifier d'autres
les retards de données, tels que SENSOR_DELAY_GAME
(20 000 microsecondes
retard de 60 000 microsecondes), SENSOR_DELAY_UI
(délai de 60 000 microsecondes) ou SENSOR_DELAY_FASTEST
(délai de 0 microseconde). À partir d'Android 3.0 (API
niveau 11), vous pouvez également spécifier le délai sous forme de valeur absolue (en microsecondes).
Le délai que vous spécifiez n'est qu'une suggestion. Le système Android et d'autres applications pouvez modifier ce délai. Nous vous recommandons de spécifier le délai maximal possible, car le système utilise généralement un délai inférieur à celui spécifié (vous devez donc choisir le taux d'échantillonnage le plus lent tout en répondant aux besoins de votre application). Un délai plus important impose une charge plus faible sur le processeur et utilise donc moins d'énergie.
Il n'existe aucune méthode publique pour déterminer la fréquence à laquelle la structure du capteur envoie les événements de capteurs à votre application ; Toutefois, vous pouvez utiliser les codes temporels l'événement du capteur pour calculer le taux d'échantillonnage sur plusieurs événements. Vous ne devriez pas avoir à modifier du taux d'échantillonnage (retard) une fois que vous l'avez défini. Si, pour une raison quelconque, vous devez modifier le délai, vous devez annuler l'enregistrement et réenregistrer l'écouteur du capteur.
Il est également important de noter que cet exemple utilise onResume()
et
Méthodes de rappel onPause()
pour enregistrer et annuler l'enregistrement de l'événement de capteur
l'écouteur. Il est recommandé de toujours désactiver les capteurs dont vous n'avez pas besoin, en particulier
activité est mise en pause. Si vous ne le faites pas, la batterie risque de se décharger rapidement en quelques heures, car certains capteurs
ont un besoin d'énergie conséquent et peuvent
consommer rapidement la batterie. Le système
ne désactive pas automatiquement les capteurs lorsque l'écran s'éteint.
Gérer différentes configurations de capteurs
Android ne spécifie pas de configuration standard de capteur pour les appareils, ce qui signifie que les fabricants d'appareils peuvent intégrer n'importe quelle configuration de capteur de leur choix à leurs Appareils Android De ce fait, les appareils peuvent inclure une variété de capteurs dans un large éventail de configurations. Si votre application repose sur un type de capteur spécifique, vous devez vous assurer que est présent sur un appareil pour que votre application puisse s'exécuter correctement.
Vous disposez de deux options pour vous assurer qu'un capteur donné est présent sur un appareil:
- Détectez les capteurs au moment de l'exécution et activez ou désactivez les fonctionnalités de l'application, le cas échéant.
- Utilisez les filtres Google Play pour cibler les appareils avec des configurations de capteurs spécifiques.
Chaque option est abordée dans les sections suivantes.
Détecter des capteurs au moment de l'exécution
Si votre application utilise un type de capteur spécifique, mais n'en a pas besoin, vous pouvez utiliser le module Sensor Framework pour détecter le capteur au moment de l'exécution, puis désactiver ou activer les fonctionnalités de l'application le cas échéant. Par exemple, une application de navigation peut utiliser le capteur de température, capteur de pression, capteur GPS et capteur de champ géométrique pour afficher la température, les valeurs barométriques la pression, l'emplacement et l'orientation. Si un appareil n'est pas équipé d'un capteur de pression, vous pouvez utiliser le pour détecter l'absence du capteur de pression au moment de l'exécution, puis désactiver de l'interface utilisateur de l'application qui affiche la pression. Par exemple, le code suivant vérifie s'il y a un capteur de pression sur un appareil:
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. }
Utiliser des filtres Google Play pour cibler des configurations de capteurs spécifiques
Si vous publiez votre application sur Google Play, vous pouvez utiliser le
<uses-feature>
dans votre fichier manifeste pour filtrer votre application sur les appareils qui ne
disposer de la configuration de capteur
appropriée pour votre application. La
L'élément <uses-feature>
comporte plusieurs descripteurs matériels qui vous permettent de filtrer
en fonction de la présence de capteurs spécifiques. Vous pouvez répertorier les capteurs suivants:
accéléromètre, baromètre, boussole (champ géomagnétique), gyroscope, lumière et proximité. La
Voici un exemple d'entrée de fichier manifeste qui filtre les applications qui ne disposent pas d'accéléromètre:
<uses-feature android:name="android.hardware.sensor.accelerometer" android:required="true" />
Si vous ajoutez cet élément et ce descripteur au fichier manifeste de votre application, les utilisateurs verront votre application sur Google Play uniquement si leur appareil est équipé d'un accéléromètre.
Vous ne devez définir le descripteur sur android:required="true"
que si votre application
repose entièrement sur un capteur spécifique. Si votre application utilise un capteur pour certaines fonctionnalités,
s'exécute toujours sans le capteur, vous devez le répertorier dans <uses-feature>
.
, mais définissez le descripteur sur android:required="false"
. Cela permet de garantir que
les appareils peuvent installer votre application même s'ils ne sont pas équipés de ce capteur. Il s'agit également
de gestion de projet qui vous permet de suivre les fonctionnalités utilisées par votre application.
Gardez à l'esprit que si votre application utilise un capteur spécifique, mais qu'elle s'exécute quand même sans ce capteur,
vous devez détecter le capteur au moment de l'exécution et désactiver ou activer les fonctionnalités de l'application
approprié.
Système de coordonnées du capteur
En général, la structure du capteur utilise un système de coordonnées standard à trois axes pour exprimer les valeurs des données. Pour la plupart des capteurs, le système de coordonnées est défini par rapport à l'écran de l'appareil lorsque celui-ci est maintenue dans son orientation par défaut (voir figure 1). Lorsqu'un appareil est tenu dans son orientation par défaut, l'axe X est horizontal et pointe vers la droite, l'axe Y est vertical et pointe vers le haut, et l'axe Z est dirigé vers l'extérieur de la face de l'écran. Dans ce système, les coordonnées derrière l'écran ont des valeurs Z négatives. Ce système de coordonnées est utilisé par les capteurs suivants:
![](https://developer.android.google.cn/static/images/axis_device.png?authuser=19&hl=fr)
Figure 1 : Système de coordonnées (relatif à un appareil) utilisé par le capteur API.
- Accélération capteur
- Gravité capteur
- Gyroscope
- Accélération linéaire capteur
- Champ géomagnétique capteur
Le point le plus important à comprendre à propos de ce système de coordonnées est que les axes ne sont pas est échangé lorsque l'orientation de l'écran de l'appareil change (système de coordonnées du capteur) ; ne change jamais lorsque l'appareil bouge. Ce comportement est identique à celui d'OpenGL le système de coordonnées.
Autre point à comprendre : votre application ne doit pas supposer que l'expérience utilisateur (par défaut) l'orientation est portrait. De nombreuses tablettes sont orientées naturellement en mode paysage. Et le système de coordonnées du capteur est toujours basé sur l'orientation naturelle d'un appareil.
Enfin, si votre application associe les données des capteurs à l'écran à l'écran, vous devez utiliser la fonction
getRotation()
pour déterminer la rotation de l'écran, puis utilisez la
Méthode remapCoordinateSystem()
à mapper
les coordonnées du capteur à celles de l'écran. Vous devez effectuer cette opération même si votre fichier manifeste spécifie
l'écran en mode portrait uniquement.
Remarque:Certains capteurs et méthodes utilisent un système de coordonnées
par rapport au cadre de référence mondial (par opposition au cadre de référence de l'appareil). Ces
les capteurs et les méthodes renvoient des données représentant le mouvement ou la position de l'appareil par rapport
sur Terre. Pour en savoir plus, consultez les méthodes getOrientation()
, getRotationMatrix()
et Orientation
Sensor, et vecteur de rotation
Capteur.
Limitation du débit des capteurs
Pour protéger les informations potentiellement sensibles sur les utilisateurs, si votre application cible Android 12 (niveau d'API 31) ou version ultérieure, le système limite l'actualisation du débit de données de certains capteurs de mouvement et de position. Ces données inclut les valeurs enregistrées par l'API accéléromètre, gyroscope, et champ géomagnétique capteur.
La limite de fréquence d'actualisation dépend de la manière dont vous accédez aux données des capteurs:
- Si vous appelez la méthode
registerListener()
pour surveiller les événements liés aux capteurs, le taux d'échantillonnage du capteur est limitée à 200 Hz. Cela est vrai pour toutes les variantes surchargéesregisterListener()
. - Si vous utilisez les
la classe
SensorDirectChannel
, le taux d'échantillonnage des capteurs est limitéRATE_NORMAL
, qui est généralement d'environ 50 Hz.
Si votre application doit collecter les données des capteurs de mouvement à une fréquence plus élevée, vous devez
déclarez le
HIGH_SAMPLING_RATE_SENSORS
l'autorisation, comme indiqué dans l'extrait de code suivant. Sinon, si votre application tente
de collecter des données de capteurs de mouvement à un taux plus élevé sans déclarer cette autorisation,
un SecurityException
se produit.
AndroidManifest.xml
<manifest ...> <uses-permission android:name="android.permission.HIGH_SAMPLING_RATE_SENSORS"/> <application ...> ... </application> </manifest>
Bonnes pratiques concernant l'accès aux capteurs et leur utilisation
Lorsque vous concevez l'implémentation de vos capteurs, veillez à respecter les consignes décrites dans la section cette section. Ces consignes sont les bonnes pratiques recommandées pour toute personne utilisant le capteur pour accéder aux capteurs et acquérir des données de capteurs.
Ne collecter les données des capteurs qu'au premier plan
Sur les appareils équipés d'Android 9 (niveau d'API 28) ou version ultérieure, les applications exécutées dans le arrière-plan sont soumis aux restrictions suivantes:
- Les capteurs qui utilisent la continu (accéléromètres ou gyroscopes, par exemple) ne reçoivent pas événements.
- Les capteurs qui utilisent la en cas de changement ou one-shot les modes de création de rapports ne reçoivent pas d'événements.
Compte tenu de ces restrictions, il est préférable de détecter les événements de capteurs est exécutée au premier plan ou fait partie d'une service de premier plan.
Annuler l'enregistrement des écouteurs de capteurs
N'oubliez pas d'annuler l'enregistrement de l'écouteur d'un capteur lorsque vous avez fini de l'utiliser ou que celui-ci
les pauses d'activité. Si un écouteur de capteur est enregistré et que son activité est interrompue, le capteur
continuent d'acquérir des données et d'utiliser les ressources de la batterie, sauf si vous annulez l'enregistrement du capteur. Les éléments suivants :
Le code montre comment utiliser la méthode onPause()
pour annuler l'enregistrement d'un écouteur:
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); }
Pour en savoir plus, consultez unregisterListener(SensorEventListener)
.
Tester avec Android Emulator
Android Emulator inclut un ensemble de commandes de capteurs virtuels qui permettent de tester des capteurs tels que l'accéléromètre, la température ambiante, le magnétomètre, proximité, lumière, etc.
L'émulateur utilise une connexion avec un appareil Android qui exécute la SdkControllerSensor l'application. Notez que cette application n'est disponible que sur les appareils équipés d'Android 4.0 (API). niveau 14) ou supérieur. Si l'appareil est équipé d'Android 4.0, il doit Révision 2 installée.) L'application SdkControllerSensor surveille les modifications apportées à les capteurs de l'appareil et les transmet à l'émulateur. L'émulateur est puis transformées en fonction des nouvelles valeurs reçues des capteurs votre appareil.
Vous pouvez afficher le code source de l'application SdkControllerSensor dans la lieu suivant:
$ your-android-sdk-directory/tools/apps/SdkController
Pour transférer des données entre votre appareil et l'émulateur, procédez comme suit : étapes:
- Vérifiez que la connexion USB le débogage est activé sur votre appareil.
- Connectez votre appareil à votre ordinateur de développement à l'aide d'un câble USB.
- Lancez l'application SdkControllerSensor sur votre appareil.
- Dans l'application, sélectionnez les capteurs que vous souhaitez émuler.
Exécutez la commande
adb
suivante:- Démarrez l'émulateur. Vous devriez maintenant être en mesure d'appliquer des transformations au émulateur en déplaçant votre appareil.
$ adb forward tcp:1968 tcp:1968
Remarque : Si les mouvements que vous effectuez
ne transforment pas l'émulateur, essayez d'exécuter
adb
de l'étape 5.
Pour plus d'informations, consultez les Guide de l'émulateur
Ne pas bloquer la méthode onSensorChanged()
Les données des capteurs peuvent changer à un rythme élevé, ce qui signifie que le système peut appeler la méthode onSensorChanged(SensorEvent)
assez souvent. Nous vous recommandons
doit faire le moins d'opérations possible dans la méthode onSensorChanged(SensorEvent)
afin de ne pas la bloquer. Si votre
requiert un filtrage des données ou une réduction des données des capteurs,
qui fonctionnent en dehors de la méthode onSensorChanged(SensorEvent)
.
Évitez d'utiliser des méthodes ou des types de capteurs obsolètes.
Plusieurs méthodes et constantes ont été abandonnées.
En particulier, la règle TYPE_ORIENTATION
type de capteur est obsolète. Pour obtenir des données d'orientation, utilisez plutôt la méthode getOrientation()
. De même,
Le type de capteur TYPE_TEMPERATURE
est obsolète. Vous devez utiliser
le type de capteur TYPE_AMBIENT_TEMPERATURE
sur les appareils
équipés d'Android 4.0.
Vérifiez les capteurs avant de les utiliser
Vérifiez toujours qu'un capteur est installé sur l'appareil avant d'essayer d'obtenir des données à partir de celui-ci. À ne pas faire Partons du principe qu'un capteur existe parce qu'il s'agit d'un capteur fréquemment utilisé. Les fabricants d’appareils sont ne sont pas tenus de fournir un capteur particulier dans leurs appareils.
Choisissez bien les temporisations des capteurs
Lorsque vous enregistrez un capteur avec la méthode registerListener()
, veillez à choisir une fréquence de diffusion adaptée à votre
application ou cas d'utilisation. Les capteurs peuvent fournir des données à des fréquences très élevées. Autoriser le système à envoyer
des données supplémentaires dont vous n’avez pas besoin gaspillent
des ressources système et utilisent l’énergie de la batterie.