Présentation des capteurs

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 précision et une exactitude élevées. Ils sont utiles si vous souhaitez surveiller les mouvements ou le positionnement d'un appareil en trois dimensions, ou si vous souhaitez surveiller les changements dans l'environnement ambiant à proximité d'un appareil. Par exemple, un jeu peut suivre les relevés du capteur de gravité d'un appareil pour déduire des gestes et des mouvements complexes de l'utilisateur, tels que l'inclinaison, l'agitation, la rotation ou le balancement. De même, une application météo peut utiliser le capteur de température et le capteur d'humidité d'un appareil pour calculer et indiquer le point de rosée, ou une application de voyage peut utiliser le capteur de champ géomagnétique et l'accéléromètre pour indiquer un relèvement de boussole.

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. Cette catégorie inclut les accéléromètres, les capteurs de gravité, les gyroscopes et les capteurs de vecteur de rotation.

• Capteurs d'ambiance

  Ces capteurs mesurent divers paramètres environnementaux, tels que la température et la pression de l'air ambiant, l'éclairage et l'humidité. Cette catégorie inclut les baromètres, les photomètres et les thermomètres.

• Capteurs de position

  Ces capteurs mesurent la position physique d'un appareil. Cette catégorie inclut les capteurs d'orientation et les magnétomètres.

Vous pouvez accéder aux capteurs disponibles sur l'appareil et acquérir des données des capteurs brutes à l'aide du framework de capteur Android. Le framework de capteurs fournit plusieurs classes et interfaces qui vous aident à effectuer un large éventail de tâches liées aux capteurs. Par exemple, vous pouvez utiliser le framework de capteurs pour effectuer les opérations suivantes :

• Déterminer les capteurs disponibles sur un appareil
• Déterminez les capacités d'un capteur individuel, telles que sa portée maximale, son fabricant, ses besoins en alimentation et sa résolution.
• Acquérir des données brutes des capteurs et définir la fréquence minimale à laquelle vous les acquérez.
• Enregistrer et désenregistrer les écouteurs d'événements de capteur qui surveillent les modifications des capteurs.

Cette rubrique présente les capteurs disponibles sur la plate-forme Android. Il fournit également une introduction au framework de capteurs.

Présentation des capteurs

Le framework de capteurs Android vous permet d'accéder à de nombreux types de capteurs. Certains de ces capteurs sont matériels, d'autres sont logiciels. Les capteurs matériels sont des composants physiques intégrés à un téléphone ou une tablette. Ils obtiennent leurs données en mesurant directement des propriétés environnementales spécifiques, telles que l'accélération, l'intensité du champ géomagnétique ou la variation angulaire. Les capteurs logiciels ne sont pas des appareils physiques, même s'ils imitent les capteurs matériels. Les capteurs logiciels dérivent leurs données d'un ou de plusieurs capteurs matériels. Ils sont parfois appelés capteurs virtuels ou capteurs synthétiques. Le capteur d'accélération linéaire et le capteur de gravité sont des exemples de capteurs logiciels. Le tableau 1 récapitule les capteurs compatibles avec la plate-forme Android.

Peu d'appareils Android disposent de tous les types de capteurs. Par exemple, la plupart des téléphones et des tablettes sont équipés d'un accéléromètre et d'un magnétomètre, mais moins d'appareils sont équipés d'un baromètre ou d'un thermomètre. De plus, un appareil peut comporter plusieurs capteurs d'un type donné. Par exemple, un appareil peut disposer de deux capteurs de gravité, chacun ayant une plage différente.

Tableau 1. Types de capteurs compatibles avec la plate-forme Android.

Framework de capteurs

Vous pouvez accéder à ces capteurs et acquérir des données des capteurs brutes à l'aide du framework de capteur Android. Le framework de capteurs fait partie du package android.hardware et inclut les classes et interfaces suivantes :

SensorManager

Vous pouvez utiliser cette classe pour créer une instance du service de capteurs. Cette classe fournit différentes méthodes pour accéder aux capteurs et les lister, enregistrer et annuler l'enregistrement des écouteurs d'événements de capteur, et obtenir des informations d'orientation. Cette classe fournit également plusieurs constantes de capteur utilisées pour signaler la précision des capteurs, définir les taux d'acquisition des données et calibrer les capteurs.

Sensor

Vous pouvez utiliser cette classe pour créer une instance d'un capteur spécifique. Cette classe fournit différentes méthodes permettant de déterminer les capacités d'un capteur.

SensorEvent

Le système utilise cette classe pour créer un objet d'événement de capteur, qui fournit des informations sur un événement de capteur. Un objet d'événement de capteur inclut les informations suivantes : les données brutes du capteur, le type de capteur qui a généré l'événement, la précision des données et le code temporel de l'événement.

SensorEventListener

Vous pouvez utiliser cette interface pour créer deux méthodes de rappel qui reçoivent des notifications (événements de capteur) lorsque les valeurs ou la précision du capteur changent.

Dans une application classique, vous utilisez ces API liées aux capteurs pour effectuer deux tâches de base :

• Identifier les capteurs et leurs fonctionnalités

  L'identification des capteurs et de leurs fonctionnalités au moment de l'exécution est utile si votre application comporte des fonctionnalités qui reposent sur des types ou des fonctionnalités de capteurs spécifiques. Par exemple, vous pouvez identifier tous les capteurs présents sur un appareil et désactiver toutes les fonctionnalités de l'application qui reposent sur des capteurs non présents. De même, vous pouvez identifier tous les capteurs d'un type donné afin de choisir l'implémentation de capteur offrant les performances optimales pour votre application.

• Surveiller les événements des capteurs

  La surveillance des événements de capteur vous permet d'acquérir des données brutes de capteur. Un événement de capteur se produit chaque fois qu'un capteur détecte un changement dans les paramètres qu'il mesure. Un événement de capteur vous fournit quatre informations : le nom du capteur qui a déclenché l'événement, le code temporel de l'événement, la précision de l'événement et les données brutes du capteur qui a déclenché l'événement.

Disponibilité des capteurs

La disponibilité des capteurs varie d'un appareil à l'autre, mais aussi d'une version d'Android à l'autre. En effet, les capteurs Android ont été introduits au cours de plusieurs versions de la plate-forme. Par exemple, de nombreux capteurs ont été introduits dans Android 1.5 (niveau d'API 3), mais certains n'ont pas été implémentés et n'étaient pas disponibles avant 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 capteurs ont été abandonnés et remplacés par des capteurs plus récents et plus performants.

Le tableau 2 récapitule la disponibilité de chaque capteur par plate-forme. Seules quatre plates-formes sont listées, car ce sont celles qui ont impliqué des modifications de capteurs. Les capteurs listés comme obsolètes sont toujours disponibles sur les plates-formes ultérieures (à condition que le capteur soit présent sur un appareil), ce qui est conforme à la règle de compatibilité ascendante d'Android.

Tableau 2. Disponibilité des capteurs par plate-forme.

¹ Ce type de capteur a été ajouté dans Android 1.5 (niveau d'API 3), mais n'était pas disponible avant Android 2.3 (niveau d'API 9).

² Ce capteur est disponible, mais il est obsolète.

Identifier les capteurs et leurs fonctionnalités

Le framework de capteurs Android fournit plusieurs méthodes qui vous permettent de déterminer facilement au moment de l'exécution quels capteurs sont présents sur un appareil. L'API fournit également des méthodes qui vous permettent de déterminer les capacités de chaque capteur, telles que sa portée maximale, sa résolution et ses besoins en énergie.

Pour identifier les capteurs d'un appareil, vous devez d'abord obtenir une référence au service de capteurs. Pour ce faire, créez une instance de la classe SensorManager en appelant la méthode getSystemService() et en transmettant l'argument SENSOR_SERVICE. Exemple :

private lateinit var sensorManager: SensorManager
...
sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager

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 en utilisant la constante TYPE_ALL. Exemple :

val deviceSensors: List<Sensor> = sensorManager.getSensorList(Sensor.TYPE_ALL)

List<Sensor> deviceSensors = sensorManager.getSensorList(Sensor.TYPE_ALL);

Si vous souhaitez lister 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 de capteur spécifique existe sur un appareil en utilisant la méthode getDefaultSensor() et en transmettant la constante de type pour un capteur spécifique. Si un appareil possède plusieurs capteurs d'un type donné, l'un d'eux doit être désigné comme capteur par défaut. Si aucun capteur par défaut n'existe pour un type de capteur donné, l'appel de méthode renvoie la valeur "null", ce qui signifie que l'appareil ne dispose pas de ce type de capteur. Par exemple, le code suivant vérifie si un appareil est équipé d'un magnétomètre :

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.
}

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 que les fabricants d'appareils intègrent des types de capteurs particuliers dans leurs appareils Android. Les appareils peuvent donc présenter un large éventail de configurations de capteurs.

En plus de lister les capteurs d'un appareil, vous pouvez utiliser les méthodes publiques de la classe Sensor pour déterminer les fonctionnalités et les attributs de chaque capteur. Cela est utile si vous souhaitez que votre application se comporte différemment en fonction des capteurs ou des fonctionnalités de capteur disponibles sur un appareil. Par exemple, vous pouvez utiliser les méthodes getResolution() et getMaximumRange() pour obtenir la résolution et la plage de mesure maximale d'un capteur. Vous pouvez également utiliser la méthode getPower() pour obtenir les exigences d'alimentation d'un capteur.

Deux des méthodes publiques sont particulièrement utiles si vous souhaitez optimiser votre application pour les capteurs de différents fabricants ou différentes versions d'un capteur. Par exemple, si votre application doit surveiller les gestes de l'utilisateur, tels que l'inclinaison et l'agitation, vous pouvez créer un ensemble de règles de filtrage des données et d'optimisations pour les appareils plus récents dotés d'un capteur de gravité d'un fournisseur spécifique, et un autre ensemble de règles de filtrage des données et d'optimisations pour les appareils qui n'ont pas de capteur de gravité et ne disposent que d'un accéléromètre. L'exemple de code suivant montre comment utiliser les méthodes getVendor() et getVersion() pour ce faire. Dans cet exemple, nous recherchons un capteur de gravité qui indique Google LLC comme fournisseur et dont le numéro de version est 3. Si ce capteur n'est pas présent sur l'appareil, nous essayons d'utiliser l'accéléromètre.

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
    }
}

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 une autre méthode utile. Elle renvoie l'intervalle de temps minimal (en microsecondes) qu'un capteur peut utiliser pour détecter des données. Tout capteur qui renvoie une valeur non nulle pour la méthode getMinDelay() est un capteur de flux. Les capteurs de flux détectent les données à intervalles réguliers et ont été introduits dans Android 2.3 (niveau d'API 9). Si un capteur renvoie zéro lorsque vous appelez la méthode getMinDelay(), cela signifie qu'il ne s'agit pas d'un capteur de streaming, car il ne transmet des données que lorsque les paramètres qu'il détecte sont modifiés.

La méthode getMinDelay() est utile, car elle vous permet de déterminer la fréquence maximale à laquelle un capteur peut acquérir des données. Si certaines fonctionnalités de votre application nécessitent des taux d'acquisition de données élevés ou un capteur de streaming, vous pouvez utiliser cette méthode pour déterminer si un capteur répond à ces exigences, puis activer ou désactiver les fonctionnalités correspondantes dans votre application.

Attention : Le taux d'acquisition de données maximal d'un capteur n'est pas nécessairement le taux auquel le framework de capteurs fournit les données de capteur à votre application. Le framework de capteurs transmet les données via des événements de capteur, et plusieurs facteurs influencent la fréquence à laquelle votre application reçoit ces événements. Pour en savoir plus, consultez Surveiller les événements de capteur.

Surveiller les événements des 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 dans les cas suivants :

• La précision d'un capteur change.

  Dans ce cas, le système appelle la méthode onAccuracyChanged(), en vous fournissant une référence à l'objet Sensor qui a changé et la nouvelle 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 ou SENSOR_STATUS_UNRELIABLE.

• Un capteur signale une nouvelle valeur.

  Dans ce cas, le système appelle la méthode onSensorChanged(), en vous fournissant un objet SensorEvent. Un objet SensorEvent contient des informations sur les nouvelles données du capteur, y compris la précision des données, le capteur qui les a générées, l'horodatage de leur génération et les nouvelles données enregistrées par le capteur.

Le code suivant montre comment utiliser la méthode onSensorChanged() pour surveiller les données du capteur de luminosité. Cet exemple affiche les données brutes des capteurs dans un TextView défini dans le fichier main.xml en tant que sensor_data.

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)
    }
}

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. Le délai de données (ou taux d'échantillonnage) contrôle l'intervalle auquel les événements de capteur sont envoyés à votre application via la méthode de rappel onSensorChanged(). Le délai de données par défaut est adapté à la surveillance des changements d'orientation d'écran standards et utilise un délai de 200 000 microsecondes. Vous pouvez spécifier d'autres délais de données, tels que SENSOR_DELAY_GAME (délai de 20 000 microsecondes), SENSOR_DELAY_UI (délai de 60 000 microsecondes) ou SENSOR_DELAY_FASTEST (délai de 0 microseconde). Depuis Android 3.0 (niveau d'API 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'un délai suggéré. Le système Android et d'autres applications peuvent modifier ce délai. Il est recommandé de spécifier le délai le plus long possible, car le système utilise généralement un délai plus court que celui que vous spécifiez (autrement dit, vous devez choisir le taux d'échantillonnage le plus lent qui répond toujours aux besoins de votre application). L'utilisation d'un délai plus long impose une charge plus faible au processeur et consomme donc moins d'énergie.

Il n'existe aucune méthode publique permettant de déterminer la fréquence à laquelle le framework de capteurs envoie des événements de capteur à votre application. Toutefois, vous pouvez utiliser les codes temporels associés à chaque événement de capteur pour calculer le taux d'échantillonnage sur plusieurs événements. Vous ne devriez pas avoir à modifier le taux d'échantillonnage (délai) une fois que vous l'avez défini. Si, pour une raison quelconque, vous devez modifier le délai, vous devrez désenregistrer et réenregistrer l'écouteur de capteur.

Notez également que cet exemple utilise les méthodes de rappel onResume() et onPause() pour enregistrer et annuler l'enregistrement de l'écouteur d'événements de capteur. Il est recommandé de toujours désactiver les capteurs dont vous n'avez pas besoin, en particulier lorsque votre activité est suspendue. Sinon, la batterie peut se décharger en quelques heures, car certains capteurs ont des besoins en énergie importants et peuvent consommer rapidement la batterie. Le système ne désactivera pas automatiquement les capteurs lorsque l'écran s'éteindra.

Gérer différentes configurations de capteurs

Android ne spécifie pas de configuration de capteur standard pour les appareils. Les fabricants d'appareils peuvent donc intégrer la configuration de capteur de leur choix dans leurs appareils Android. Par conséquent, les appareils peuvent inclure divers capteurs dans un large éventail de configurations. Si votre application repose sur un type de capteur spécifique, vous devez vous assurer que ce capteur est présent sur l'appareil pour que votre application puisse s'exécuter correctement.

Deux options s'offrent à vous pour vous assurer qu'un capteur donné est présent sur un appareil :

• Détectez les capteurs au moment de l'exécution, puis activez ou désactivez les fonctionnalités de l'application, selon le cas.
• Utilisez les filtres Google Play pour cibler les appareils dotés de configurations de capteurs spécifiques.

Chaque option est décrite 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 dépend pas, vous pouvez utiliser le framework de capteurs pour détecter le capteur au moment de l'exécution, puis désactiver ou activer les fonctionnalités de l'application, selon le cas. Par exemple, une application de navigation peut utiliser le capteur de température, le capteur de pression, le capteur GPS et le capteur de champ géomagnétique pour afficher la température, la pression barométrique, la position et l'orientation de la boussole. Si un appareil n'est pas équipé d'un capteur de pression, vous pouvez utiliser le framework de capteurs pour détecter l'absence de capteur de pression au moment de l'exécution, puis désactiver la partie de l'interface utilisateur de votre application qui affiche la pression. Par exemple, le code suivant vérifie s'il existe un capteur de pression sur un appareil :

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.
}

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 les filtres Google Play pour cibler des configurations de capteurs spécifiques

Si vous publiez votre application sur Google Play, vous pouvez utiliser l'élément <uses-feature> dans votre fichier manifeste pour filtrer votre application et l'exclure des appareils qui ne disposent pas de la configuration de capteur appropriée pour votre application. L'élément <uses-feature> comporte plusieurs descripteurs matériels qui vous permettent de filtrer les applications en fonction de la présence de capteurs spécifiques. Vous pouvez lister les capteurs suivants : accéléromètre, baromètre, boussole (champ géomagnétique), gyroscope, luminosité et proximité. Voici un exemple d'entrée de fichier manifeste qui filtre les applications ne disposant pas d'un 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 ne verront votre application sur Google Play que 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, mais qu'elle fonctionne toujours sans, vous devez lister le capteur dans l'élément <uses-feature>, mais définir le descripteur sur android:required="false". Cela permet de s'assurer que les appareils peuvent installer votre application même s'ils ne disposent pas de ce capteur particulier. Il s'agit également d'une bonne pratique de gestion de projet qui vous aide à suivre les fonctionnalités utilisées par votre application. N'oubliez pas que si votre application utilise un capteur particulier, mais qu'elle s'exécute toujours sans lui, vous devez détecter le capteur au moment de l'exécution, puis désactiver ou activer les fonctionnalités de l'application, selon le cas.

Système de coordonnées du capteur

En général, le framework de capteurs utilise un système de coordonnées standard à trois axes pour exprimer les valeurs de 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 tenu dans son orientation par défaut (voir la figure 1). Lorsque l'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 pointe vers l'extérieur 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 :

Figure 1. Système de coordonnées (relatif à un appareil) utilisé par l'API Sensor.

• Capteur d'accélération
• Capteur de gravité
• Gyroscope
• Capteur d'accélération linéaire
• Capteur de champ géomagnétique

Le point le plus important à comprendre concernant ce système de coordonnées est que les axes ne sont pas permutés lorsque l'orientation de l'écran de l'appareil change. En d'autres termes, le système de coordonnées du capteur ne change jamais lorsque l'appareil se déplace. Ce comportement est identique à celui du système de coordonnées OpenGL.

Il est également important de comprendre que votre application ne doit pas supposer que l'orientation naturelle (par défaut) d'un appareil est le mode portrait. L'orientation naturelle de nombreuses tablettes est le mode paysage. Le système de coordonnées du capteur est toujours basé sur l'orientation naturelle d'un appareil.

Enfin, si votre application fait correspondre les données des capteurs à l'affichage à l'écran, vous devez utiliser la méthode getRotation() pour déterminer la rotation de l'écran, puis la méthode remapCoordinateSystem() pour mapper les coordonnées des capteurs aux coordonnées de l'écran. Vous devez le faire même si votre fichier manifeste spécifie un affichage en mode portrait uniquement.

Remarque : Certains capteurs et méthodes utilisent un système de coordonnées relatif au repère mondial (par opposition au repère de l'appareil). Ces capteurs et méthodes renvoient des données qui représentent le mouvement ou la position de l'appareil par rapport à la Terre. Pour en savoir plus, consultez les méthodes getOrientation() et getRotationMatrix(), ainsi que les sections Capteur d'orientation et Capteur de vecteur de rotation.

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 une version ultérieure, le système limite la fréquence d'actualisation des données de certains capteurs de mouvement et de position. Ces données incluent les valeurs enregistrées par l'accéléromètre, le gyroscope et le capteur de champ géomagnétique de l'appareil.

La limite de la fréquence d'actualisation dépend de la façon dont vous accédez aux données des capteurs :

• Si vous appelez la méthode registerListener() pour surveiller les événements de capteur, le taux d'échantillonnage du capteur est limité à 200 Hz. Cela vaut pour toutes les variantes surchargées de la méthode registerListener().
• Si vous utilisez la classe SensorDirectChannel, le taux d'échantillonnage du capteur est limité à RATE_NORMAL, qui est généralement d'environ 50 Hz.

Si votre application doit collecter des données de capteurs de mouvement à un taux plus élevé, vous devez déclarer l'autorisation HIGH_SAMPLING_RATE_SENSORS, comme indiqué dans l'extrait de code suivant. Sinon, si votre application tente de collecter des données de capteur de mouvement à un taux plus élevé sans déclarer cette autorisation, une SecurityException se produit.

AndroidManifest.xml

<manifest ...>
    <uses-permission android:name="android.permission.HIGH_SAMPLING_RATE_SENSORS"/>
    <application ...>
        ...
    </application>
</manifest>

Bonnes pratiques pour accéder aux capteurs et les utiliser

Lorsque vous concevez l'implémentation de vos capteurs, veillez à suivre les consignes décrites dans cette section. Ces consignes sont des bonnes pratiques recommandées pour toute personne utilisant le framework de capteurs 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 en arrière-plan sont soumises aux restrictions suivantes :

• Les capteurs qui utilisent le mode de signalement continu, tels que les accéléromètres et les gyroscopes, ne reçoivent pas d'événements.
• Les capteurs qui utilisent les modes de reporting on-change ou one-shot ne reçoivent pas d'événements.

Compte tenu de ces restrictions, il est préférable de détecter les événements de capteur lorsque votre application est au premier plan ou dans le cadre d'un service de premier plan.

Désenregistrer les écouteurs de capteur

Veillez à désinscrire l'écouteur d'un capteur lorsque vous avez fini d'utiliser le capteur ou lorsque l'activité du capteur est suspendue. Si un écouteur de capteur est enregistré et que son activité est suspendue, le capteur continuera d'acquérir des données et d'utiliser les ressources de la batterie, sauf si vous annulez l'enregistrement du capteur. Le code suivant montre comment utiliser la méthode onPause() pour annuler l'enregistrement d'un écouteur :

private lateinit var sensorManager: SensorManager
...
override fun onPause() {
    super.onPause()
    sensorManager.unregisterListener(this)
}

private SensorManager sensorManager;
...
@Override
protected void onPause() {
    super.onPause();
    sensorManager.unregisterListener(this);
}

Pour en savoir plus, consultez unregisterListener(SensorEventListener).

Tester avec Android Emulator

L'Android Emulator inclut un ensemble de commandes de capteurs virtuels qui vous permettent de tester des capteurs tels que l'accéléromètre, la température ambiante, le magnétomètre, la proximité, la luminosité, etc.

L'émulateur utilise une connexion avec un appareil Android exécutant l'application SdkControllerSensor. Notez que cette application n'est disponible que sur les appareils équipés d'Android 4.0 (niveau d'API 14) ou version ultérieure. (Si l'appareil exécute Android 4.0, la révision 2 doit être installée.) L'application SdkControllerSensor surveille les modifications apportées aux capteurs de l'appareil et les transmet à l'émulateur. L'émulateur est ensuite transformé en fonction des nouvelles valeurs qu'il reçoit des capteurs de votre appareil.

Vous pouvez afficher le code source de l'application SdkControllerSensor à l'emplacement suivant :

$ your-android-sdk-directory/tools/apps/SdkController

Pour transférer des données entre votre appareil et l'émulateur, procédez comme suit :

1. Vérifiez que le débogage USB est activé sur votre appareil.
2. Connectez l'appareil à votre ordinateur de développement à l'aide d'un câble USB.
3. Lancez l'application SdkControllerSensor sur votre appareil.
4. Dans l'application, sélectionnez les capteurs que vous souhaitez émuler.

5. Exécutez la commande adb suivante :

$ adb forward tcp:1968 tcp:1968

6. Démarrez l'émulateur. Vous devriez maintenant pouvoir appliquer des transformations à l'émulateur en déplaçant votre appareil.

Remarque  : Si les mouvements que vous effectuez sur votre appareil physique ne sont pas reproduits sur l'émulateur, essayez d'exécuter à nouveau la commande adb de l'étape 5.

Pour en savoir plus, consultez le guide sur Android Emulator.

Ne bloquez pas 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. Il est recommandé d'effectuer le moins d'opérations possible dans la méthode onSensorChanged(SensorEvent) afin de ne pas la bloquer. Si votre application nécessite de filtrer ou de réduire les données des capteurs, vous devez effectuer cette opération en dehors de la méthode onSensorChanged(SensorEvent).

Éviter d'utiliser des méthodes ou des types de capteurs obsolètes

Plusieurs méthodes et constantes ont été abandonnées. En particulier, le type de capteur TYPE_ORIENTATION est obsolète. Pour obtenir des données d'orientation, vous devez utiliser 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érifier les capteurs avant de les utiliser

Vérifiez toujours qu'un capteur existe sur un appareil avant d'essayer d'en acquérir des données. Ne partez pas du principe qu'un capteur existe simplement parce qu'il est fréquemment utilisé. Les fabricants d'appareils ne sont pas tenus de fournir des capteurs particuliers dans leurs appareils.

Choisissez soigneusement les délais des capteurs

Lorsque vous enregistrez un capteur avec la méthode registerListener(), veillez à choisir un taux de diffusion adapté à votre application ou à votre cas d'utilisation. Les capteurs peuvent fournir des données à des débits très élevés. Autoriser le système à envoyer des données supplémentaires dont vous n'avez pas besoin gaspille les ressources système et consomme de la batterie.