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 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 peut suivre les mesures du capteur de gravité d'un appareil pour déduire des gestes complexes des utilisateurs et des mouvements tels qu'une inclinaison, un secousses, une rotation ou un mouvement de balancier. De même, une application météo peut utiliser les capteurs 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.

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 comprend 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 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 inclut 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 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éterminez 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.
  • Acquérez des données brutes des capteurs et définissez le taux minimal auquel vous les acquérez.
  • 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

Android Sensor Framework 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 conçus sur 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 basés sur des logiciels ne sont pas des appareils physiques, bien qu'ils imitent les capteurs basés sur du matériel. 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 de capteurs basés sur des 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 disposent 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. En outre, un appareil peut être équipé de plusieurs capteurs d'un type donné. Par exemple, un appareil peut comporter 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 de la pièce en degrés Celsius (°C). Voir la remarque ci-dessous. Surveillance des températures de l'air
TYPE_GRAVITY Logiciel ou matériel Mesure la force de gravité en m/s2 appliquée à un appareil sur les trois axes physiques (x, y, z). Détection de mouvement (secousse, 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 rotation (tourner, pivoter, 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 appliquée à un appareil sur les trois axes physiques (x, y et z), en excluant 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) en μ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 le getRotationMatrix() . Déterminer la position de l'appareil.
TYPE_PRESSURE Matériel Mesure la pression de l'air ambiant en hPa ou en 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 un combiné est tenu contre l'oreille d'une personne. Position du téléphone pendant 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

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 comprend 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 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 différentes méthodes qui vous permettent de déterminer les fonctionnalité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 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 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 capteur qui offre les performances optimales pour votre application.

  • Surveiller les événements des 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 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 ont 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 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 en fonction de la plate-forme. Seules quatre plates-formes sont listées, car ce sont celles qui ont impliqué des modifications 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 il n'était pas disponible avant Android 2.3 (niveau d'API 9).

2 Ce capteur est disponible, mais il a été 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 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 :

KotlinJava
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 à l'aide de la constante TYPE_ALL. Exemple :

KotlinJava
val deviceSensors: List<Sensor> = sensorManager.getSensorList(Sensor.TYPE_ALL)
 
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 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 :

KotlinJava
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 de créer des types de capteurs particuliers dans leurs appareils Android. Les appareils 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 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 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 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 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. possède le numéro de version 3. Si ce capteur particulier n'est pas présent sur l'appareil, nous essayons d'utiliser l'accéléromètre.

KotlinJava
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 streaming. 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 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 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:

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

KotlinJava
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. 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 (niveau d'API 11), vous pouvez également spécifier le délai sous la forme d'une 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. 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 long impose une charge inférieure 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 la fréquence 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.

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 activité est mise en pause. Sinon, la batterie risque d'être déchargée en quelques heures, car certains capteurs ont des besoins énergétiques importants et peuvent rapidement vider 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 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 que le 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 selon les besoins.
  • 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étection 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, 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 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 s'il y a un capteur de pression sur un appareil:

KotlinJava
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 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 s'assurer que les appareils peuvent installer votre application même s'ils ne disposent pas de ce capteur particulier. 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, le framework de capteurs utilise un système de coordonnées à trois axes standard 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 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.

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.

Autre point à comprendre : votre application ne doit pas supposer que l'expérience utilisateur (par défaut) l'orientation est portrait. L'orientation naturelle de nombreuses tablettes est le 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 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 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(), le capteur d'orientation et le 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 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 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 accéder aux capteurs et les utiliser

Lorsque vous concevez l'implémentation de vos capteurs, veillez à respecter les consignes décrites dans la section 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 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 le mode de reporting 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 à changement 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

N'oubliez pas d'annuler l'enregistrement de l'écouteur d'un capteur lorsque vous avez fini de l'utiliser ou lorsque 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. Le code suivant montre comment utiliser la méthode onPause() pour annuler l'enregistrement d'un écouteur :

KotlinJava
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 permettent 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 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 fonctionne sous Android 4.0, la version 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 : étapes:

  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 :

    6. $ 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, réessayez d'exécuter la commande 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. Il est recommandé de faire le moins 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).

Éviter 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, vous devez utiliser la méthode getOrientation(). De même, le type de capteur TYPE_TEMPERATURE a été abandonné. 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 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 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 débits très élevés. 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.

Suivant
Capteurs de mouvement