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 forte la précision et l'exactitude. Ils sont utiles si vous souhaitez surveiller le mouvement d'un appareil en trois dimensions ou ou de surveiller les changements dans l'environnement ambiant à proximité d'un appareil. Par exemple, un peut suivre les mesures du capteur de gravité d'un appareil pour déduire des gestes complexes des utilisateurs et mouvements, comme une inclinaison, un tremblement, une rotation ou un mouvement de balancier. De même, une application météo peut utiliser le capteur de température et d'humidité de l'appareil pour calculer et indiquer le point de rosée, ou une distance application peut utiliser le capteur de champ géomagnétique et l'accéléromètre pour signaler une boussole de direction.

Consultez les ressources associées suivantes :

La plate-forme Android est compatible avec trois grandes catégories de capteurs:

  • Capteurs de mouvement

    Ces capteurs mesurent les forces d'accélération et de rotation sur trois axes. Ce inclut les accéléromètres, les capteurs de gravité, les gyroscopes et les vecteurs de rotation capteurs.

  • Capteurs d'ambiance

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

  • Capteurs de position

    Ces capteurs mesurent la position physique d'un appareil. Cette catégorie comprend les éléments suivants : les capteurs d'orientation et les magnétomètres.

Vous pouvez accéder aux capteurs disponibles sur l'appareil et obtenir leurs données brutes à l'aide de l'application Android de capteurs. Le framework de capteurs fournit plusieurs classes et interfaces pour vous aider à effectuer un grand pour diverses tâches liées aux capteurs. Par exemple, vous pouvez utiliser le framework du capteur pour:

  • Déterminer les capteurs disponibles sur un appareil
  • Déterminer les caractéristiques d'un capteur individuel : portée maximale, fabricant, puissance les exigences et la résolution.
  • Collecte des données brutes des capteurs et définition de la fréquence minimale d'acquisition de ces données
  • Enregistrez et annulez l'enregistrement des écouteurs d'événements de capteurs qui surveillent les modifications des capteurs.

Cet article présente les capteurs disponibles sur la plate-forme Android. Il présente également la structure des capteurs.

Présentation des capteurs

Android Sensor Framework vous permet d'accéder à de nombreux types de capteurs. Certains de ces capteurs sont basés sur le matériel et d'autres sur des logiciels. Les capteurs matériels sont des composants physiques conçus sur un téléphone ou une tablette. Ils extraient leurs données en mesurant directement des données environnementales spécifiques telles que l'accélération, l'intensité du champ géomagnétique ou le changement d'angle. Basée sur un logiciel les capteurs ne sont pas des appareils physiques, bien qu'ils imitent des capteurs matériels. Capteurs logiciels peuvent extraire leurs données d'un ou de plusieurs des capteurs matériels, et sont parfois appelés ou des capteurs synthétiques. Le capteur d'accélération linéaire et le capteur de gravité sont des exemples des capteurs logiciels. Le tableau 1 récapitule les capteurs compatibles avec l'application Android Google Cloud.

Peu d'appareils Android sont équipés de capteurs de ce type. Par exemple, la plupart des téléphones portables et les tablettes sont équipées d'un accéléromètre et d'un magnétomètre, mais elles sont moins nombreuses baromètres ou thermomètres. En outre, un appareil peut être équipé de plusieurs capteurs d'un type donné. Pour exemple, un appareil peut avoir deux capteurs de gravité, chacun ayant une portée différente.

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

Capteur Type Description Utilisations courantes
TYPE_ACCELEROMETER Matériel Mesure la force d'accélération en m/s2 appliquée à un appareil sur les trois axes physiques (x, y et z), y compris la force de gravité. Détection des mouvements (secousses, inclinaison, etc.)
TYPE_AMBIENT_TEMPERATURE Matériel Mesure la température ambiante d'une pièce en degrés Celsius (°C). Voir la remarque ci-dessous. Surveiller la température de l'air.
TYPE_GRAVITY Logiciel ou matériel Mesure la force de gravité en m/s2, appliquée à un appareil sur trois axes physiques (x, y, z). Détection des mouvements (secousses, inclinaison, etc.)
TYPE_GYROSCOPE Matériel Mesure le taux de rotation d'un appareil en rad/s autour de chacun des trois axes physiques (x, y et z). Détection de la rotation (rotation, virage, etc.)
TYPE_LIGHT Matériel Mesure le niveau de luminosité ambiante (illumination) en lx. Contrôle de la luminosité de l'écran
TYPE_LINEAR_ACCELERATION Logiciel ou matériel Mesure la force d'accélération en m/s2, soit appliquée à un appareil sur les trois axes physiques (x, y et z), à l'exclusion de la force de gravité. Surveiller l'accélération sur un seul axe
TYPE_MAGNETIC_FIELD Matériel Mesure le champ géomagnétique ambiant pour les trois axes physiques (x, y, z) dans μT. Création d'une boussole...
TYPE_ORIENTATION Logiciel Mesure les degrés de rotation effectués par un appareil autour des trois axes physiques (x, y, z). À partir du niveau d'API 3, vous pouvez obtenir la matrice d'inclinaison et la matrice de rotation pour un appareil en utilisant le capteur de gravité et le capteur de champ géomagnétique conjointement avec l'/le/la getRotationMatrix() . Déterminer la position de l'appareil.
TYPE_PRESSURE Matériel Mesure la pression de l'air ambiant en hPa ou mbar. Surveiller les variations de la pression atmosphérique
TYPE_PROXIMITY Matériel Mesure la proximité d'un objet (en cm) par rapport à l'écran d'un appareil. Ce capteur est généralement utilisé pour déterminer si le téléphone est tenu l'oreille d'une personne. Position du téléphone au cours d'un appel.
TYPE_RELATIVE_HUMIDITY Matériel Mesure l'humidité ambiante relative en pourcentage (%). Surveillez le point de rosée, l'humidité absolue et l'humidité relative.
TYPE_ROTATION_VECTOR Logiciel ou matériel Mesure l'orientation d'un appareil en fournissant les trois éléments de son un vecteur de rotation. Détection des mouvements et de la rotation
TYPE_TEMPERATURE Matériel Mesure la température de l'appareil en degrés Celsius (°C). Ce capteur l'implémentation varie selon les appareils ce capteur a été remplacé par celui de TYPE_AMBIENT_TEMPERATURE dans Niveau d'API 14 Surveillance des températures

Cadre de capteur

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

SensorManager
Vous pouvez utiliser cette classe pour créer une instance du service de capteurs. Cette classe fournit diverses méthodes permettant d'accéder aux capteurs et de les lister, d'enregistrer et d'annuler l'enregistrement des événements liés aux capteurs. et l'acquisition d'informations d'orientation. Cette classe fournit également plusieurs constantes de capteur permettant de rendre compte de la précision des capteurs, de définir les taux d'acquisition de données et de calibrer les capteurs.
Sensor
Vous pouvez utiliser cette classe pour créer une instance d'un capteur spécifique. Cette classe fournit diverses qui vous permettent de déterminer les capacités d'un capteur.
SensorEvent
Le système utilise cette classe pour créer un objet événement de capteur, qui fournit des informations sur une événement du capteur. Un objet événement de capteur inclut les informations suivantes: les données brutes du capteur, les le type de capteur ayant généré l'événement, la précision des données et l'horodatage de l'événement .
SensorEventListener
Vous pouvez utiliser cette interface pour créer deux méthodes de rappel qui reçoivent des notifications (un capteur les événements) lorsque les valeurs du capteur changent ou que sa précision change.

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

  • Identifier les capteurs et leurs caractéristiques

    L'identification des capteurs et de leurs caractéristiques au moment de l'exécution est utile si votre application qui reposent sur des types ou des capacités de capteurs spécifiques. Par exemple, vous pouvez identifier tous les capteurs d'un appareil et désactiver les fonctionnalités de l'application ; reposent sur des capteurs absents. De même, il peut être utile d'identifier tous les capteurs d'un type donné, ce qui vous permet de choisir l'implémentation de capteurs offrant les meilleures performances pour votre application.

  • Surveiller les événements des capteurs

    La surveillance des événements de capteurs vous permet d'obtenir les données brutes des capteurs. Un événement de capteur se produit à chaque fois un capteur détecte un changement des paramètres qu'il mesure. Un événement de capteur vous indique avec quatre informations: le nom du capteur ayant déclenché l'événement, le code temporel de l'événement, sa précision et les données brutes du capteur ayant déclenché l'événement.

Disponibilité des capteurs

La disponibilité des capteurs varie d'un appareil à l'autre, mais elle peut également varier d'un appareil Android à l'autre. versions. En effet, les capteurs Android ont été introduits au cours de plusieurs de la plate-forme. Par exemple, de nombreux capteurs ont été introduits dans Android 1.5 (niveau d'API 3), mais certains n'étaient pas implémentées et ne pouvaient être utilisées qu'à partir d'Android 2.3 (niveau d'API 9). De même, plusieurs capteurs ont été introduits dans Android 2.3 (niveau d'API 9) et Android 4.0 (niveau d'API 14). Deux les capteurs ont été abandonnés et remplacés par de nouveaux capteurs de meilleure qualité.

Le tableau 2 récapitule la disponibilité de chaque capteur en fonction de la plate-forme. Seulement quatre les plateformes sont listées, car ce sont les plateformes qui ont impliqué des changements de capteurs. Les capteurs qui sont répertoriés comme obsolètes restent disponibles sur les plates-formes suivantes (à condition que les est présent sur l'appareil), ce qui est conforme à la règle de compatibilité ascendante d'Android.

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

Capteur Android 4.0
(niveau d'API 14)		 Android 2.3
(niveau d'API 9)		 Android 2.2
(niveau d'API 8)		 Android 1.5
(niveau d'API 3)
TYPE_ACCELEROMETER Oui Oui Oui Oui
TYPE_AMBIENT_TEMPERATURE Oui n/a n/a n/a
TYPE_GRAVITY Oui Oui n/a n/a
TYPE_GYROSCOPE Oui Oui N/A1 N/A1
TYPE_LIGHT Oui Oui Oui Oui
TYPE_LINEAR_ACCELERATION Oui Oui n/a n/a
TYPE_MAGNETIC_FIELD Oui Oui Oui Oui
TYPE_ORIENTATION Oui2 Oui2 Oui2 Oui
TYPE_PRESSURE Oui Oui N/A1 N/A1
TYPE_PROXIMITY Oui Oui Oui Oui
TYPE_RELATIVE_HUMIDITY Oui n/a n/a n/a
TYPE_ROTATION_VECTOR Oui Oui n/a n/a
TYPE_TEMPERATURE Oui2 Oui Oui Oui

1 Ce type de capteur a été ajouté dans Android 1.5 (niveau d'API). 3), mais elle n'était disponible qu'à partir d'Android 2.3 (niveau d'API 9).

2 Ce capteur est disponible, mais il a été obsolète.

Identification des capteurs et de leurs capacités

Android Sensor Framework propose plusieurs méthodes vous permettant de déterminer facilement quel est l'environnement d'exécution des capteurs d'un appareil. L'API fournit également des méthodes vous permettant de déterminer de chaque capteur, telles que sa portée maximale, sa résolution et sa puissance exigences.

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

Kotlin

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

Java

private SensorManager sensorManager;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);

Vous pouvez ensuite obtenir la liste de tous les capteurs d'un appareil en appelant la méthode getSensorList() et à l'aide de la constante TYPE_ALL. Exemple :

Kotlin

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

Java

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

Si vous voulez répertorier tous les capteurs d'un type donné, vous pouvez utiliser une autre constante au lieu de TYPE_ALL, par exemple TYPE_GYROSCOPE, TYPE_LINEAR_ACCELERATION ou TYPE_GRAVITY

Vous pouvez également déterminer si un type spécifique de capteur existe sur un appareil en utilisant la méthode getDefaultSensor() et en transmettant le type. pour un capteur spécifique. Si un appareil est équipé de plusieurs capteurs d'un type donné, l'un des les capteurs doivent être définis comme capteurs par défaut. Si aucun capteur par défaut n'existe pour un type de capteur, l'appel de méthode renvoie "null", ce qui signifie que l'appareil ne possède pas ce type de capteur vidéo. Par exemple, le code suivant vérifie si un appareil est doté d'un magnétomètre:

Kotlin

private lateinit var sensorManager: SensorManager
...
sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
if (sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD) != null) {
    // Success! There's a magnetometer.
} else {
    // Failure! No magnetometer.
}

Java

private SensorManager sensorManager;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
if (sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD) != null){
    // Success! There's a magnetometer.
} else {
    // Failure! No magnetometer.
}

Remarque:Android n'exige pas des fabricants d'appareils qu'ils créent des de capteurs particuliers dans leurs appareils Android, de sorte qu'ils disposent d'un large éventail de configurations de capteurs.

En plus de répertorier les capteurs d'un appareil, vous pouvez utiliser les méthodes publiques de Sensor pour déterminer les capacités et les attributs d'une personne capteurs. Cette fonctionnalité est utile si vous souhaitez que votre application se comporte différemment selon les capteurs ou les capacités des capteurs sont disponibles sur un appareil. Par exemple, vous pouvez utiliser getResolution() et getMaximumRange(). pour obtenir la résolution et la plage de mesure maximale d'un capteur. Vous pouvez également utiliser getPower() pour connaître la puissance requise d'un capteur.

Deux des méthodes publiques sont particulièrement utiles si vous souhaitez optimiser votre application les capteurs de différents fabricants ou les différentes versions d'un même capteur. Par exemple, si votre application doit surveiller les gestes des utilisateurs, comme l'inclinaison et le tremblement, vous pouvez créer un ensemble de filtres de données des règles et optimisations pour les appareils plus récents dotés d'un capteur de gravité d'un fournisseur spécifique, et d'un autre ensemble de règles de filtrage des données et d'optimisations pour les appareils dépourvus de capteur de gravité et présentant qu'un accéléromètre. L'exemple de code suivant vous montre comment effectuer les opérations à l'aide des méthodes getVendor() et getVersion(). cette étape. Dans cet exemple, nous recherchons un capteur de gravité qui indique Google LLC comme fournisseur. possède le numéro de version 3. Si ce capteur n'est pas présent sur l'appareil, nous essayons d'utiliser le accéléromètre.

Kotlin

private lateinit var sensorManager: SensorManager
private var mSensor: Sensor? = null

...

sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager

if (sensorManager.getDefaultSensor(Sensor.TYPE_GRAVITY) != null) {
    val gravSensors: List<Sensor> = sensorManager.getSensorList(Sensor.TYPE_GRAVITY)
    // Use the version 3 gravity sensor.
    mSensor = gravSensors.firstOrNull { it.vendor.contains("Google LLC") && it.version == 3 }
}
if (mSensor == null) {
    // Use the accelerometer.
    mSensor = if (sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER) != null) {
        sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)
    } else {
        // Sorry, there are no accelerometers on your device.
        // You can't play this game.
        null
    }
}

Java

private SensorManager sensorManager;
private Sensor mSensor;

...

sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
mSensor = null;

if (sensorManager.getDefaultSensor(Sensor.TYPE_GRAVITY) != null){
    List<Sensor> gravSensors = sensorManager.getSensorList(Sensor.TYPE_GRAVITY);
    for(int i=0; i<gravSensors.size(); i++) {
        if ((gravSensors.get(i).getVendor().contains("Google LLC")) &&
           (gravSensors.get(i).getVersion() == 3)){
            // Use the version 3 gravity sensor.
            mSensor = gravSensors.get(i);
        }
    }
}
if (mSensor == null){
    // Use the accelerometer.
    if (sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER) != null){
        mSensor = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
    } else{
        // Sorry, there are no accelerometers on your device.
        // You can't play this game.
    }
}

La méthode getMinDelay() est également utile. qui renvoie l'intervalle de temps minimal (en microsecondes) qu'un capteur peut utiliser pour détecter des données. N'importe quel capteur qui renvoie une valeur non nulle pour getMinDelay() est une méthode de traitement par flux capteur vidéo. Les capteurs de flux détectent les données à intervalles réguliers et ont été introduits dans Android 2.3 (API niveau 9). Si un capteur renvoie zéro lorsque vous appelez la méthode getMinDelay(), cela signifie que n'est pas un capteur par flux, car il transmet des données uniquement en cas de changement au niveau les paramètres qu'il détecte.

La méthode getMinDelay() est utile, car elle permet vous déterminez le taux maximal permettant à un capteur d'acquérir des données. Si certaines fonctionnalités de votre application nécessitent un volume de données élevé ou un capteur de flux, vous pouvez utiliser cette méthode pour déterminer respecte ces conditions, puis activer ou désactiver les fonctionnalités adéquates dans votre application en conséquence.

Attention:Le taux maximal d'acquisition de données d'un capteur la vitesse à laquelle le framework du capteur envoie les données de capteur à votre application. La capteur transmet les données par le biais d'événements de capteurs, et plusieurs facteurs influencent la fréquence à laquelle votre application reçoit les événements de capteurs. Pour en savoir plus, consultez la section Surveiller les événements de capteurs.

Surveiller les événements de capteurs

Pour surveiller les données brutes des capteurs, vous devez implémenter deux méthodes de rappel, exposées via l'interface SensorEventListener: onAccuracyChanged() et onSensorChanged(). Le système Android appelle ces méthodes chaque fois que les événements suivants se produisent:

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

Kotlin

class SensorActivity : Activity(), SensorEventListener {
    private lateinit var sensorManager: SensorManager
    private var mLight: Sensor? = null

    public override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.main)

        sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
        mLight = sensorManager.getDefaultSensor(Sensor.TYPE_LIGHT)
    }

    override fun onAccuracyChanged(sensor: Sensor, accuracy: Int) {
        // Do something here if sensor accuracy changes.
    }

    override fun onSensorChanged(event: SensorEvent) {
        // The light sensor returns a single value.
        // Many sensors return 3 values, one for each axis.
        val lux = event.values[0]
        // Do something with this sensor value.
    }

    override fun onResume() {
        super.onResume()
        mLight?.also { light ->
            sensorManager.registerListener(this, light, SensorManager.SENSOR_DELAY_NORMAL)
        }
    }

    override fun onPause() {
        super.onPause()
        sensorManager.unregisterListener(this)
    }
}

Java

public class SensorActivity extends Activity implements SensorEventListener {
    private SensorManager sensorManager;
    private Sensor mLight;

    @Override
    public final void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
        mLight = sensorManager.getDefaultSensor(Sensor.TYPE_LIGHT);
    }

    @Override
    public final void onAccuracyChanged(Sensor sensor, int accuracy) {
        // Do something here if sensor accuracy changes.
    }

    @Override
    public final void onSensorChanged(SensorEvent event) {
        // The light sensor returns a single value.
        // Many sensors return 3 values, one for each axis.
        float lux = event.values[0];
        // Do something with this sensor value.
    }

    @Override
    protected void onResume() {
        super.onResume();
        sensorManager.registerListener(this, mLight, SensorManager.SENSOR_DELAY_NORMAL);
    }

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

Dans cet exemple, le délai de données par défaut (SENSOR_DELAY_NORMAL) est spécifié lorsque la méthode registerListener() est appelée. Les données Le délai (ou taux d'échantillonnage) contrôle l'intervalle auquel les événements des capteurs sont envoyés à votre application. via la méthode de rappel onSensorChanged(). La valeur par défaut le délai entre les données est adapté à la surveillance l'orientation habituelle d'un écran change et utilise un délai de 200 000 microsecondes. Vous pouvez spécifier d'autres les retards de données, tels que SENSOR_DELAY_GAME (20 000 microsecondes retard de 60 000 microsecondes), SENSOR_DELAY_UI (délai de 60 000 microsecondes) ou SENSOR_DELAY_FASTEST (délai de 0 microseconde). À partir d'Android 3.0 (API niveau 11), vous pouvez également spécifier le délai sous forme de valeur absolue (en microsecondes).

Le délai que vous spécifiez n'est qu'une suggestion. Le système Android et d'autres applications pouvez modifier ce délai. Nous vous recommandons de spécifier le délai maximal possible, car le système utilise généralement un délai inférieur à celui spécifié (vous devez donc choisir le taux d'échantillonnage le plus lent tout en répondant aux besoins de votre application). Un délai plus important impose une charge plus faible sur le processeur et utilise donc moins d'énergie.

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

Il est également important de noter que cet exemple utilise onResume() et Méthodes de rappel onPause() pour enregistrer et annuler l'enregistrement de l'événement de capteur l'écouteur. Il est recommandé de toujours désactiver les capteurs dont vous n'avez pas besoin, en particulier activité est mise en pause. Si vous ne le faites pas, la batterie risque de se décharger rapidement en quelques heures, car certains capteurs ont un besoin d'énergie conséquent et peuvent consommer rapidement la batterie. Le système ne désactive pas automatiquement les capteurs lorsque l'écran s'éteint.

Gérer différentes configurations de capteurs

Android ne spécifie pas de configuration standard de capteur pour les appareils, ce qui signifie que les fabricants d'appareils peuvent intégrer n'importe quelle configuration de capteur de leur choix à leurs Appareils Android De ce fait, les appareils peuvent inclure une variété de capteurs dans un large éventail de configurations. Si votre application repose sur un type de capteur spécifique, vous devez vous assurer que est présent sur un appareil pour que votre application puisse s'exécuter correctement.

Vous disposez de deux options pour vous assurer qu'un capteur donné est présent sur un appareil:

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

Chaque option est abordée dans les sections suivantes.

Détecter des capteurs au moment de l'exécution

Si votre application utilise un type de capteur spécifique, mais n'en a pas besoin, vous pouvez utiliser le module Sensor Framework pour détecter le capteur au moment de l'exécution, puis désactiver ou activer les fonctionnalités de l'application le cas échéant. Par exemple, une application de navigation peut utiliser le capteur de température, capteur de pression, capteur GPS et capteur de champ géométrique pour afficher la température, les valeurs barométriques la pression, l'emplacement et l'orientation. Si un appareil n'est pas équipé d'un capteur de pression, vous pouvez utiliser le pour détecter l'absence du capteur de pression au moment de l'exécution, puis désactiver de l'interface utilisateur de l'application qui affiche la pression. Par exemple, le code suivant vérifie s'il y a un capteur de pression sur un appareil:

Kotlin

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

if (sensorManager.getDefaultSensor(Sensor.TYPE_PRESSURE) != null) {
    // Success! There's a pressure sensor.
} else {
    // Failure! No pressure sensor.
}

Java

private SensorManager sensorManager;
...
sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
if (sensorManager.getDefaultSensor(Sensor.TYPE_PRESSURE) != null){
    // Success! There's a pressure sensor.
} else {
    // Failure! No pressure sensor.
}

Utiliser des filtres Google Play pour cibler des configurations de capteurs spécifiques

Si vous publiez votre application sur Google Play, vous pouvez utiliser le <uses-feature> dans votre fichier manifeste pour filtrer votre application sur les appareils qui ne disposer de la configuration de capteur appropriée pour votre application. La L'élément <uses-feature> comporte plusieurs descripteurs matériels qui vous permettent de filtrer en fonction de la présence de capteurs spécifiques. Vous pouvez répertorier les capteurs suivants: accéléromètre, baromètre, boussole (champ géomagnétique), gyroscope, lumière et proximité. La Voici un exemple d'entrée de fichier manifeste qui filtre les applications qui ne disposent pas d'accéléromètre:

<uses-feature android:name="android.hardware.sensor.accelerometer"
              android:required="true" />

Si vous ajoutez cet élément et ce descripteur au fichier manifeste de votre application, les utilisateurs verront votre application sur Google Play uniquement si leur appareil est équipé d'un accéléromètre.

Vous ne devez définir le descripteur sur android:required="true" que si votre application repose entièrement sur un capteur spécifique. Si votre application utilise un capteur pour certaines fonctionnalités, s'exécute toujours sans le capteur, vous devez le répertorier dans <uses-feature>. , mais définissez le descripteur sur android:required="false". Cela permet de garantir que les appareils peuvent installer votre application même s'ils ne sont pas équipés de ce capteur. Il s'agit également de gestion de projet qui vous permet de suivre les fonctionnalités utilisées par votre application. Gardez à l'esprit que si votre application utilise un capteur spécifique, mais qu'elle s'exécute quand même sans ce capteur, vous devez détecter le capteur au moment de l'exécution et désactiver ou activer les fonctionnalités de l'application approprié.

Système de coordonnées du capteur

En général, la structure du capteur utilise un système de coordonnées standard à trois axes pour exprimer les valeurs des données. Pour la plupart des capteurs, le système de coordonnées est défini par rapport à l'écran de l'appareil lorsque celui-ci est maintenue dans son orientation par défaut (voir figure 1). Lorsqu'un appareil est tenu dans son orientation par défaut, l'axe X est horizontal et pointe vers la droite, l'axe Y est vertical et pointe vers le haut, et l'axe Z est dirigé vers l'extérieur de la face de l'écran. Dans ce système, les coordonnées derrière l'écran ont des valeurs Z négatives. Ce système de coordonnées est utilisé par les capteurs suivants:

Figure 1 : Système de coordonnées (relatif à un appareil) utilisé par le capteur API.

Le point le plus important à comprendre à propos de ce système de coordonnées est que les axes ne sont pas est échangé lorsque l'orientation de l'écran de l'appareil change (système de coordonnées du capteur) ; ne change jamais lorsque l'appareil bouge. Ce comportement est identique à celui d'OpenGL le système de coordonnées.

Autre point à comprendre : votre application ne doit pas supposer que l'expérience utilisateur (par défaut) l'orientation est portrait. De nombreuses tablettes sont orientées naturellement en mode paysage. Et le système de coordonnées du capteur est toujours basé sur l'orientation naturelle d'un appareil.

Enfin, si votre application associe les données des capteurs à l'écran à l'écran, vous devez utiliser la fonction getRotation() pour déterminer la rotation de l'écran, puis utilisez la Méthode remapCoordinateSystem() à mapper les coordonnées du capteur à celles de l'écran. Vous devez effectuer cette opération même si votre fichier manifeste spécifie l'écran en mode portrait uniquement.

Remarque:Certains capteurs et méthodes utilisent un système de coordonnées par rapport au cadre de référence mondial (par opposition au cadre de référence de l'appareil). Ces les capteurs et les méthodes renvoient des données représentant le mouvement ou la position de l'appareil par rapport sur Terre. Pour en savoir plus, consultez les méthodes getOrientation(), getRotationMatrix() et Orientation Sensor, et vecteur de rotation Capteur.

Limitation du débit des capteurs

Pour protéger les informations potentiellement sensibles sur les utilisateurs, si votre application cible Android 12 (niveau d'API 31) ou version ultérieure, le système limite l'actualisation du débit de données de certains capteurs de mouvement et de position. Ces données inclut les valeurs enregistrées par l'API accéléromètre, gyroscope, et champ géomagnétique capteur.

La limite de fréquence d'actualisation dépend de la manière dont vous accédez aux données des capteurs:

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

AndroidManifest.xml

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

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

Lorsque vous concevez l'implémentation de vos capteurs, veillez à respecter les consignes décrites dans la section cette section. Ces consignes sont les bonnes pratiques recommandées pour toute personne utilisant le capteur pour accéder aux capteurs et acquérir des données de capteurs.

Ne collecter les données des capteurs qu'au premier plan

Sur les appareils équipés d'Android 9 (niveau d'API 28) ou version ultérieure, les applications exécutées dans le arrière-plan sont soumis aux restrictions suivantes:

  • Les capteurs qui utilisent la continu (accéléromètres ou gyroscopes, par exemple) ne reçoivent pas événements.
  • Les capteurs qui utilisent la en cas de changement ou one-shot les modes de création de rapports ne reçoivent pas d'événements.

Compte tenu de ces restrictions, il est préférable de détecter les événements de capteurs est exécutée au premier plan ou fait partie d'une service de premier plan.

Annuler l'enregistrement des écouteurs de capteurs

N'oubliez pas d'annuler l'enregistrement de l'écouteur d'un capteur lorsque vous avez fini de l'utiliser ou que celui-ci les pauses d'activité. Si un écouteur de capteur est enregistré et que son activité est interrompue, le capteur continuent d'acquérir des données et d'utiliser les ressources de la batterie, sauf si vous annulez l'enregistrement du capteur. Les éléments suivants : Le code montre comment utiliser la méthode onPause() pour annuler l'enregistrement d'un écouteur:

Kotlin

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

Java

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

Pour en savoir plus, consultez unregisterListener(SensorEventListener).

Tester avec Android Emulator

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

L'émulateur utilise une connexion avec un appareil Android qui exécute la SdkControllerSensor l'application. Notez que cette application n'est disponible que sur les appareils équipés d'Android 4.0 (API). niveau 14) ou supérieur. Si l'appareil est équipé d'Android 4.0, il doit Révision 2 installée.) L'application SdkControllerSensor surveille les modifications apportées à les capteurs de l'appareil et les transmet à l'émulateur. L'émulateur est puis transformées en fonction des nouvelles valeurs reçues des capteurs votre appareil.

Vous pouvez afficher le code source de l'application SdkControllerSensor dans la lieu suivant:

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

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

  1. Vérifiez que la connexion USB le débogage 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 être en mesure d'appliquer des transformations au émulateur en déplaçant votre appareil.

Remarque : Si les mouvements que vous effectuez ne transforment pas l'émulateur, essayez d'exécuter adb de l'étape 5.

Pour plus d'informations, consultez les Guide de l'émulateur

Ne pas bloquer la méthode onSensorChanged()

Les données des capteurs peuvent changer à un rythme élevé, ce qui signifie que le système peut appeler la méthode onSensorChanged(SensorEvent) assez souvent. Nous vous recommandons doit faire le moins d'opérations possible dans la méthode onSensorChanged(SensorEvent) afin de ne pas la bloquer. Si votre requiert un filtrage des données ou une réduction des données des capteurs, qui fonctionnent en dehors de la méthode onSensorChanged(SensorEvent).

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

Plusieurs méthodes et constantes ont été abandonnées. En particulier, la règle TYPE_ORIENTATION type de capteur est obsolète. Pour obtenir des données d'orientation, utilisez plutôt la méthode getOrientation(). De même, Le type de capteur TYPE_TEMPERATURE est obsolète. Vous devez utiliser le type de capteur TYPE_AMBIENT_TEMPERATURE sur les appareils équipés d'Android 4.0.

Vérifiez les capteurs avant de les utiliser

Vérifiez toujours qu'un capteur est installé sur l'appareil avant d'essayer d'obtenir des données à partir de celui-ci. À ne pas faire Partons du principe qu'un capteur existe parce qu'il s'agit d'un capteur fréquemment utilisé. Les fabricants d’appareils sont ne sont pas tenus de fournir un capteur particulier dans leurs appareils.

Choisissez bien les temporisations des capteurs

Lorsque vous enregistrez un capteur avec la méthode registerListener(), veillez à choisir une fréquence de diffusion adaptée à votre application ou cas d'utilisation. Les capteurs peuvent fournir des données à des fréquences très élevées. Autoriser le système à envoyer des données supplémentaires dont vous n’avez pas besoin gaspillent des ressources système et utilisent l’énergie de la batterie.

Suivant
Capteurs de mouvement