Présentation des capteurs

La plupart des appareils Android sont équipés de capteurs intégrés qui mesurent le mouvement, 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 le mouvement ou le positionnement tridimensionnel d'un appareil, ou si vous souhaitez surveiller les changements dans l'environnement ambiant à proximité d'un appareil. Par exemple, un jeu peut suivre les lectures du capteur de gravité d'un appareil pour inférer des gestes et des mouvements complexes de l'utilisateur, tels que l'inclinaison, le balancement, la rotation ou le balancement. De même, une application météo peut utiliser le capteur de température et 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 signaler la position d'une 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 les forces de rotation sur trois axes. Cette catégorie inclut les accéléromètres, les capteurs de gravité, les gyroscopes et les capteurs de vecteurs 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 de capteur brutes à l'aide du framework de capteur Android. Le framework de capteurs fournit plusieurs classes et interfaces pour vous aider à effectuer diverses 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 exigences en termes d'alimentation et sa 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 le 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 basés sur du matériel, d'autres sur du logiciel. Les capteurs matériels sont des composants physiques intégrés à un téléphone ou à une tablette. Ils génèrent 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 l'angle de rotation. Les capteurs logiciels ne sont pas des appareils physiques, bien qu'ils imitent des capteurs matériels. Les capteurs logiciels tirent leurs données d'un ou de plusieurs capteurs matériels et 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 basés sur des logiciels. Le tableau 1 récapitule les capteurs compatibles avec la plate-forme Android.

Peu d'appareils Android sont équipés de capteurs de ce type. 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 de baromètres ou de thermomètres. De plus, un appareil peut comporter plusieurs capteurs d'un même type. Par 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.

Framework de capteurs

Vous pouvez accéder à ces capteurs et acquérir des données 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 capteur. Cette classe fournit diverses méthodes pour accéder et lister les capteurs, enregistrer et désenregistrer des écouteurs d'événements de capteur et acquérir des informations d'orientation. Cette classe fournit également plusieurs constantes de capteur qui sont utilisées pour signaler la précision des capteurs, définir les taux d'acquisition de 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 diverses méthodes vous 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 ayant 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 des capteurs changent ou que la précision des capteurs change.

Dans une application typique, 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 caractéristiques au moment de l'exécution est utile si votre application possède des fonctionnalités qui reposent sur des types ou des capacités de capteurs spécifiques. Par exemple, vous pouvez identifier tous les capteurs présents sur un appareil et désactiver les fonctionnalités de l'application qui s'appuient sur des capteurs qui ne sont pas présents. De même, vous pouvez identifier tous les capteurs d'un type donné afin de choisir l'implémentation de capteurs offrant les performances optimales pour votre application.

• Surveiller les événements liés aux capteurs

  La surveillance des événements des capteurs vous permet d'acquérir des données brutes des capteurs. Un événement de capteur se produit chaque fois qu'un capteur détecte une modification des paramètres qu'il mesure. Un événement de capteur fournit quatre informations: le nom du capteur ayant 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 ayant déclenché l'événement.

Disponibilité des capteurs

Bien que la disponibilité des capteurs varie d'un appareil à l'autre, elle peut également varier d'une version d'Android à l'autre. En effet, les capteurs Android ont été introduits au fil 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'ont pas été 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 qu'ils soient présents sur un appareil), conformément à la politique de rétrocompatibilité 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 il 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 à l'exécution les capteurs présents sur un appareil. L'API fournit également des méthodes qui vous permettent de déterminer les fonctionnalités de chaque capteur, telles que sa portée maximale, sa résolution et ses exigences en termes d'alimentation.

Pour identifier les capteurs d'un appareil, vous devez d'abord obtenir une référence au service de capteur. 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 à la place de TYPE_ALL, comme TYPE_GYROSCOPE, TYPE_LINEAR_ACCELERATION ou TYPE_GRAVITY.

Vous pouvez également déterminer si un type de capteur spécifique existe sur un appareil à l'aide de la méthode getDefaultSensor() et en transmettant la constante de type pour un capteur spécifique. Si un appareil comporte 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 nulle, ce qui signifie que l'appareil ne dispose pas de ce type de capteur. Par exemple, le code suivant vérifie si un appareil dispose 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 des fabricants d'appareils qu'ils intègrent des types de capteurs particuliers à leurs appareils Android. Ils peuvent donc avoir une large gamme 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. Cette option 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 différents capteurs de fabricants ou différentes versions d'un capteur. Par exemple, si votre application doit surveiller les gestes des utilisateurs tels que l'inclinaison et le tremblement, vous pouvez créer un ensemble de règles et d'optimisations de filtrage des données 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 et d'optimisations de filtrage des données pour les appareils qui ne disposent pas de capteur de gravité et ne possèdent qu'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é dont le fournisseur est Google LLC et dont le numéro de version est 3. Si ce capteur particulier 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(), qui renvoie l'intervalle de temps minimal (en microsecondes) qu'un capteur peut utiliser pour détecter des données, est également utile. 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 signale des données que lorsqu'il y a un changement dans les paramètres qu'il détecte.

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 pertinentes de votre application en conséquence.

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

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 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(), ce qui vous fournit une référence à l'objet Sensor qui a été modifié 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 indique une nouvelle valeur.

  Dans ce cas, le système appelle la méthode onSensorChanged(), qui vous fournit 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 à partir duquel les données ont été générées 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 du capteur 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 des capteurs 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 typiques et utilise un délai de 200 000 microsecondes. Vous pouvez spécifier d'autres retards de données, tels que SENSOR_DELAY_GAME (retard de 20 000 microsecondes), SENSOR_DELAY_UI (retard de 60 000 microsecondes) ou SENSOR_DELAY_FASTEST (retard de 0 microseconde). À partir d'Android 3.0 (niveau d'API 11), vous pouvez également spécifier le délai en tant que valeur absolue (en microsecondes).

Le délai que vous spécifiez n'est qu'une suggestion. 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 inférieur à celui que vous spécifiez (c'est-à-dire, 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 important impose une charge inférieure au processeur et consomme donc moins d'énergie.

Il n'existe pas de méthode publique pour déterminer le taux auquel le framework de capteurs envoie des événements de capteurs à 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 (retard) une fois que vous l'avez défini. Si, pour une raison quelconque, vous devez modifier le délai, vous devrez annuler l'enregistrement 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 du capteur. Il est recommandé de toujours désactiver les capteurs dont vous n'avez pas besoin, en particulier lorsque votre activité est mise en pause. À défaut, la batterie peut se décharger rapidement en quelques heures, car certains capteurs nécessitent une alimentation importante et consomment rapidement de l'énergie. 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 de capteur standard pour les appareils, ce qui signifie que les fabricants d'appareils peuvent intégrer n'importe quelle configuration de capteur dans leurs appareils Android. Par conséquent, les appareils peuvent inclure différents capteurs dans un large éventail de configurations. Si votre application repose sur un type de capteur spécifique, vous devez vous assurer qu'il est présent sur un appareil pour que votre application puisse s'exécuter.

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 ne s'appuie pas dessus, vous pouvez utiliser le framework de capteurs pour le détecter au moment de l'exécution, puis désactiver ou activer les fonctionnalités de l'application selon les besoins. 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 la direction de la boussole. Si un appareil ne possède pas de 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 si un appareil est doté d'un capteur de pression:

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 des 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 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, lumière et proximité. 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 ne verront votre application sur Google Play que si leur appareil dispose 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 s'exécute toujours sans lui, 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 le détecter au moment de l'exécution et désactiver ou activer les fonctionnalités de l'application en conséquence.

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 lorsqu'il est tenu 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 pointe 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:

Figure 1 : Système de coordonnées (par rapport à 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. Autrement dit, 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.

Un autre point à comprendre est 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 met en correspondance les données des capteurs avec 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 sur les 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 par rapport au référentiel mondial (par opposition au référentiel de l'appareil). Ces capteurs et méthodes renvoient des données représentant le mouvement de l'appareil ou sa position par rapport à la Terre. Pour en savoir plus, consultez les méthodes getOrientation() et getRotationMatrix(), le capteur d'orientation et le capteur de vecteur de rotation.

Limiter le 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 la fréquence d'actualisation des données provenant 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 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 des capteurs, le taux d'échantillonnage des capteurs est limité à 200 Hz. Cela est vrai 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 capteur de mouvement à un débit 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 débit plus élevé sans déclarer cette autorisation, une erreur SecurityException se produit.

AndroidManifest.xml

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

Bonnes pratiques pour l'accès aux capteurs et leur utilisation

Lorsque vous concevez la mise en œuvre de vos capteurs, veillez à suivre les consignes décrites dans cette section. Ces consignes sont des bonnes pratiques recommandées pour toute personne qui utilise le framework de capteurs pour accéder aux capteurs et acquérir des données de capteur.

Ne collecter les données des capteurs que 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 création de rapports 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 création de rapports à chaque modification ou à usage unique 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 à annuler l'enregistrement de l'écouteur d'un capteur lorsque vous avez terminé de l'utiliser ou lorsque l'activité du capteur se met en pause. Si un écouteur de capteur est enregistré et que son activité est suspendue, le capteur continue 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

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 lumière, 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 est équipé d'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 consulter 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 votre 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 transforment pas l'émulateur, essayez d'exécuter à nouveau la commande adb de l'étape 5.

Pour en savoir plus, consultez le guide Android Emulator.

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 d'en faire le moins 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 tâche 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, 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 désormais obsolète. Vous devez utiliser le type de capteur TYPE_AMBIENT_TEMPERATURE à la place 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 de tenter 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 fréquences très élevées. Autoriser le système à envoyer des données supplémentaires dont vous n'avez pas besoin gaspille des ressources système et consomme de l'énergie de la batterie.