Sensors API : qu’est-ce que c’est, types de capteurs et travail avec les capteurs

Auteur : IT Sectr Publié le : 2026-03-26 Temps de lecture : 10 min

Sensors API est une interface de la plateforme Android pour accéder aux capteurs matériels du périphérique. L’API fournit une méthode unifiée pour obtenir des données de l’accéléromètre, du gyroscope, du magnétomètre, du capteur de lumière et d’autres capteurs. Selon Google, 2026, plus de 95 % des appareils Android modernes sont équipés d’au moins trois types de capteurs, ce qui ouvre de vastes possibilités pour le développement d’applications contextuelles.

Points clés

  • Sensors API — une interface Android unifiée pour travailler avec les capteurs matériels du périphérique.
  • Trois catégories — capteurs Motion, Position et Environment avec différents principes de mesure.
  • SensorManager — un service système pour obtenir la liste des capteurs et enregistrer des écouteurs.
  • Taux d’actualisation défini via les constantes SENSOR_DELAY de NORMAL à FASTEST.
  • Capteurs virtuels — Gravity, Rotation Vector et Linear Acceleration sont basés sur une combinaison de capteurs physiques.

Qu’est-ce que Sensors API dans Android ?

Sensors API est une interface logicielle du framework Android qui offre aux développeurs un accès aux capteurs matériels du périphérique mobile. L’API fait partie du SDK Android depuis la version 1.0 et est disponible via le package android.hardware. L’interface abstrait les différences entre les implémentations de capteurs de différents fabricants — Qualcomm, MediaTek, Samsung Exynos — et fournit un modèle unifié pour travailler avec les capteurs.

Fonctionnalités principales de Sensors API

L’API permet trois opérations clés : obtenir la liste des capteurs disponibles, enregistrer des écouteurs pour recevoir des données et gérer le taux d’actualisation. SensorManager agit comme le point d’accès central pour toutes les opérations. Le système notifie l’application via le callback onSensorChanged, en passant un objet SensorEvent avec un tableau de valeurs float.

Évolution de Sensors API

Au cours de l’existence d’Android, l’API a traversé plusieurs étapes de développement. La version 2.3 (Gingerbread) a introduit la prise en charge du traitement par lots — le regroupement des événements de capteurs pour réduire la consommation d’énergie. Android 4.0 (Ice Cream Sandwich) a ajouté les capteurs virtuels Gravity et Linear Acceleration. À partir d’Android 8.0, le système a restreint l’accès en arrière-plan aux capteurs pour améliorer la confidentialité.

kotlin
val sensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
val sensorList: List<Sensor> = sensorManager.getSensorList(Sensor.TYPE_ALL)
sensorList.forEach { sensor ->
    Log.d("Capteurs", "${sensor.name} — ${sensor.type}")
}

Limites et exigences

Tous les appareils n’ont pas le même ensemble de capteurs. Une application doit vérifier la disponibilité d’un capteur spécifique avant d’enregistrer un écouteur. L’émulateur Android ne prend en charge qu’un ensemble limité de capteurs — accéléromètre et magnétomètre. Tester d’autres capteurs nécessite un périphérique physique. À partir d’Android 12, les applications doivent déclarer l’utilisation des capteurs dans le manifeste.

Types de capteurs Android : Motion, Position, Environment

Android classe tous les capteurs en trois catégories : Motion, Position et Environment. Les capteurs Motion incluent l’accéléromètre, le gyroscope et le podomètre. Les capteurs Position incluent le magnétomètre et l’orientation. Les capteurs Environment incluent la lumière, la pression, la température et l’humidité.

CatégorieCapteursType (constante)Physique/Virtuel
MotionAccéléromètreTYPE_ACCELEROMETERPhysique
MotionGyroscopeTYPE_GYROSCOPEPhysique
MotionPodomètreTYPE_STEP_COUNTERPhysique
MotionGravityTYPE_GRAVITYVirtuel
PositionMagnétomètreTYPE_MAGNETIC_FIELDPhysique
PositionRotation VectorTYPE_ROTATION_VECTORVirtuel
EnvironmentLumièreTYPE_LIGHTPhysique
EnvironmentPressionTYPE_PRESSUREPhysique

Capteurs Motion : accéléromètre et gyroscope

L’accéléromètre mesure l’accélération en m/s² selon trois axes — X, Y et Z. Les valeurs incluent la gravité (9,8 m/s² le long de l’axe Z au repos). Le gyroscope mesure la vitesse angulaire en rad/s — la vitesse de rotation du périphérique autour de chaque axe. La combinaison de ces deux capteurs est utilisée dans la navigation, les jeux et les applications de RA.

kotlin
class SensorActivity : Activity(), SensorEventListener {
    override fun onSensorChanged(event: SensorEvent) {
        if (event.sensor.type == Sensor.TYPE_ACCELEROMETER) {
            val x = event.values[0]
            val y = event.values[1]
            val z = event.values[2]
            textView.text = "X: $x, Y: $y, Z: $z"
        }
    }
    override fun onAccuracyChanged(sensor: Sensor, accuracy: Int) {}
}

Capteurs Position : magnétomètre et orientation

Le magnétomètre (TYPE_MAGNETIC_FIELD) mesure le champ magnétique en microteslas (µT) selon trois axes. Il est utilisé comme boussole numérique — combiné à l’accéléromètre, il détermine l’azimut du périphérique. Rotation Vector est un capteur virtuel qui fusionne les données du gyroscope, de l’accéléromètre et du magnétomètre pour une détermination précise de l’orientation.

Capteurs Environment : lumière, pression, température

Le capteur de lumière (TYPE_LIGHT) mesure le niveau de lumière ambiante en lux (lx). Il est utilisé pour le réglage automatique de la luminosité de l’écran. Le capteur de pression (TYPE_PRESSURE) mesure la pression atmosphérique en hectopascals (hPa) — utilisé dans les applications de navigation pour déterminer l’altitude au-dessus du niveau de la mer.

Comment fonctionne l’architecture de Sensors API

Sensors API est construit sur une architecture client-serveur. L’application agit comme client et SensorManager comme service système Android. Lorsque l’application enregistre un écouteur via registerListener, SensorManager communique avec la HAL (Hardware Abstraction Layer) — un pilote de capteur de bas niveau fonctionnant au niveau du noyau Linux.

Cycle de vie d’un événement de capteur

Le pilote HAL reçoit les données brutes de la puce matérielle, filtre le bruit et les transmet vers le haut de la pile — via SensorService (processus système) jusqu’à l’application. Les données sont transmises sous forme d’objet SensorEvent contenant un tableau de valeurs float values et un horodatage en nanosecondes. Le taux d’événements dépend du mode de livraison sélectionné.

Modes de livraison des événements

Lors de l’enregistrement d’un écouteur, le développeur spécifie le délai souhaité entre les événements à l’aide des constantes SENSOR_DELAY_NORMAL (200 ms), SENSOR_DELAY_UI (60 ms), SENSOR_DELAY_GAME (20 ms) et SENSOR_DELAY_FASTEST (0 ms — taux maximum). Le taux réel peut différer — le système optimise la consommation d’énergie.

kotlin
val sensor = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)
sensorManager.registerListener(
    this,
    sensor,
    SensorManager.SENSOR_DELAY_GAME
)

Traitement par lots (Batch Processing)

À partir d’Android 2.3, les capteurs prennent en charge le mode par lots — les événements sont accumulés dans un tampon FIFO et livrés en un seul lot. Cela permet au processeur de rester plus longtemps en mode veille, réduisant la consommation d’énergie jusqu’à 60 %. La taille du tampon dépend de la puce du capteur et est spécifiée dans le champ Sensor.fifoMaxEventCount.

Utilisation de SensorManager pour accéder aux capteurs

SensorManager est un service système disponible via getSystemService(Context.SENSOR_SERVICE). Il fournit des méthodes pour obtenir une liste de capteurs, obtenir un capteur par défaut spécifique et enregistrer/désabonner des écouteurs. SensorManager est un singleton — une seule instance pour toute l’application.

Vérification de la disponibilité du capteur

Avant d’utiliser un capteur, vous devez vérifier sa disponibilité. La méthode getDefaultSensor(type) retourne null si le capteur n’est pas présent sur l’appareil. Obtenir null sans vérification entraînera une NullPointerException lors de l’enregistrement d’un écouteur. La méthode getSensorList(type) retourne une liste de tous les capteurs.

kotlin
fun checkSensorAvailability(type: Int): Boolean {
    val sensorManager =
        getSystemService(Context.SENSOR_SERVICE) as SensorManager
    return sensorManager.getDefaultSensor(type) != null
}

// Utilisation :
if (checkSensorAvailability(Sensor.TYPE_GYROSCOPE)) {
    Log.d("Capteur", "Gyroscope disponible")
}

Enregistrement et désabonnement d’un écouteur

Un écouteur est enregistré via registerListener(listener, sensor, delay). Important : vous devez désabonner l’écouteur dans la méthode onPause() via unregisterListener(listener). Si cela n’est pas fait, l’application continuera à recevoir des événements de capteur, épuisant la batterie même en arrière-plan. Android 8+ affiche un avertissement dans logcat concernant les écouteurs non désabonnés.

Gestion des changements de précision

La méthode onAccuracyChanged(sensor, accuracy) est appelée lorsque la précision du capteur change. Valeurs : SENSOR_STATUS_ACCURACY_HIGH, MEDIUM, LOW et UNRELIABLE. Lors de la réception d’UNRELIABLE, les données du capteur doivent être ignorées jusqu’à ce que la précision soit restaurée. Par exemple, le magnétomètre nécessite un étalonnage — agiter l’appareil en forme de huit.

Exemples de code pour travailler avec les capteurs en Kotlin

Examinons des exemples pratiques d’utilisation de Sensors API dans des applications Android avec Kotlin. Le premier exemple — déterminer l’orientation de l’écran à l’aide de l’accéléromètre. Le deuxième — lire les données du magnétomètre avec étalonnage. Le troisième — un détecteur de pas utilisant le podomètre.

Détermination de l’orientation du périphérique

Une combinaison d’accéléromètre et de magnétomètre est utilisée pour déterminer l’orientation. La méthode SensorManager.getRotationMatrix() calcule la matrice de rotation, et getOrientation() extrait les angles pitch, roll et azimuth. Azimuth — l’angle par rapport au nord magnétique en radians.

kotlin
val gravity = FloatArray(3)
val geomagnetic = FloatArray(3)
val rotationMatrix = FloatArray(9)
val orientation = FloatArray(3)

SensorManager.getRotationMatrix(
    rotationMatrix, null, gravity, geomagnetic
)
SensorManager.getOrientation(rotationMatrix, orientation)
// orientation[0] — azimuth, [1] — pitch, [2] — roll
val azimuthDeg = Math.toDegrees(orientation[0].toDouble())

Détecteur de pas avec podomètre

Le podomètre (TYPE_STEP_COUNTER) retourne le nombre total de pas effectués par l’utilisateur depuis le dernier redémarrage de l’appareil. Le capteur fonctionne au niveau matériel — il est actif même lorsque l’application ne tourne pas. Pour obtenir les pas par session, vous devez enregistrer la valeur initiale et calculer la différence.

kotlin
var initialSteps = 0
var isInitialized = false

override fun onSensorChanged(event: SensorEvent) {
    if (event.sensor.type == Sensor.TYPE_STEP_COUNTER) {
        if (!isInitialized) {
            initialSteps = event.values[0].toInt()
            isInitialized = true
        }
        val currentSteps = event.values[0].toInt()
        val sessionSteps = currentSteps - initialSteps
        Log.d("Pas", "Pas par session : $sessionSteps")
    }
}

Luminosité adaptative avec le capteur de lumière

Le capteur de lumière permet d’adapter l’interface aux conditions ambiantes. En cas de faible luminosité (moins de 10 lx), vous pouvez passer en mode sombre. En plein soleil (plus de 10 000 lx), vous pouvez augmenter le contraste. Une moyenne mobile des 5 dernières valeurs est utilisée pour filtrer le bruit.

Capteurs virtuels et algorithmes de fusion

Android fournit plusieurs capteurs virtuels qui n’ont pas d’équivalent matériel direct. Un capteur virtuel calcule ses lectures en combinant des capteurs physiques. Cela réduit la charge du développeur — le système lui-même implémente les algorithmes de fusion de données.

Gravity et Linear Acceleration

Le capteur Gravity (TYPE_GRAVITY) extrait la composante gravitationnelle des lectures de l’accéléromètre à l’aide d’un filtre passe-bas. Linear Acceleration (TYPE_LINEAR_ACCELERATION), au contraire, supprime la gravité et ne laisse que l’accélération linéaire du périphérique. La somme de Gravity et Linear Acceleration donne les lectures brutes de l’accéléromètre.

Rotation Vector

Rotation Vector — le capteur virtuel le plus complexe. Il combine les données du gyroscope (changements haute fréquence), de l’accéléromètre (vecteur de gravité) et du magnétomètre (orientation par rapport au nord). Le résultat est un quaternion décrivant l’orientation absolue du périphérique dans l’espace. Il est utilisé dans les applications de RA et les casques de VR.

Game Rotation Vector

Game Rotation Vector — une version simplifiée de Rotation Vector sans utiliser le magnétomètre. Cela donne une précision d’azimut plus faible mais un taux d’actualisation et une stabilité plus élevés. Il est recommandé pour les jeux où une faible latence est importante plutôt que l’orientation absolue par rapport au nord.

Optimisation de la batterie lors du travail avec les capteurs

Les capteurs font partie des composants les plus énergivores du périphérique. L’accéléromètre et le gyroscope à taux d’échantillonnage maximal peuvent épuiser la batterie en 3–4 heures de fonctionnement continu. L’optimisation de l’utilisation des capteurs est une tâche critique pour toute application utilisant Sensors API.

Choix du délai optimal

N’utilisez pas SENSOR_DELAY_FASTEST inutilement. Pour les animations d’interface, SENSOR_DELAY_UI (60 ms) est suffisant. Pour la détection d’orientation de l’écran — SENSOR_DELAY_NORMAL (200 ms). Plus le taux est élevé, plus le processeur passe de temps dans un état actif. La différence entre NORMAL et FASTEST atteint jusqu’à 10x en consommation d’énergie.

Désabonnement des écouteurs en arrière-plan

À partir d’Android 8.0 (API 26), les applications en arrière-plan reçoivent les événements de capteurs à un taux réduit. Dans Android 12+, l’accès en arrière-plan aux capteurs Motion et Position nécessite l’autorisation BODY_SENSORS_BACKGROUND. Désabonnez l’écouteur lorsque l’application passe en arrière-plan — cela prolonge l’autonomie de la batterie.

Traitement par lots et tampon FIFO

Utilisez le traitement par lots via la méthode registerListener(listener, sensor, delay, maxReportLatencyUs). Le paramètre maxReportLatencyUs définit la latence maximale de livraison des événements en microsecondes. Avec une valeur de 1 000 000 (1 seconde), les événements s’accumulent dans le tampon FIFO du capteur et sont livrés une fois par seconde — le processeur se réveille moins fréquemment.

Foire aux questions

Quels capteurs sont présents sur tous les appareils Android ?

L’ensemble minimum comprend un accéléromètre et un magnétomètre. Ces deux capteurs sont présents sur plus de 95 % des appareils. Gyroscope, capteur de lumière et capteur de proximité — sur 70–80 % des modèles modernes. Les autres capteurs (pression, température, humidité, podomètre) sont moins courants et dépendent de la gamme de prix de l’appareil.

Quelle est la différence entre TYPE_ACCELEROMETER et TYPE_LINEAR_ACCELERATION ?

TYPE_ACCELEROMETER retourne l’accélération totale incluant la gravité (9,8 m/s²). TYPE_LINEAR_ACCELERATION retourne l’accélération sans gravité — uniquement l’accélération due au mouvement de l’appareil. Si l’appareil est immobile, l’accéléromètre indiquera 9,8 m/s² le long de l’axe Z, tandis que Linear Acceleration indiquera 0 sur tous les axes.

Comment vérifier si le capteur requis est disponible sur l’appareil ?

Utilisez getPackageManager().hasSystemFeature() avec les constantes appropriées : FEATURE_SENSOR_ACCELEROMETER, FEATURE_SENSOR_GYROSCOPE, FEATURE_SENSOR_PROXIMITY, etc. Une autre méthode consiste à appeler getDefaultSensor(type) et à vérifier si le résultat est null. La première méthode est préférable pour la vérification lors de l’initialisation.

Pourquoi les valeurs du capteur fluctuent-elles et comment les lisser ?

Les données brutes des capteurs contiennent du bruit. Pour les lisser, utilisez un filtre passe-bas : newValue = alpha * rawValue + (1 — alpha) * previousValue. Un coefficient alpha de 0,1–0,3 offre un bon équilibre entre réactivité et fluidité. Pour le gyroscope, un filtre passe-haut est également appliqué pour supprimer la dérive du zéro.

Peut-on utiliser les capteurs en arrière-plan ?

Oui, mais avec des limitations. À partir d’Android 8.0, le taux d’événements des capteurs est réduit pour les applications en arrière-plan. À partir d’Android 12, l’autorisation BODY_SENSORS_BACKGROUND est requise pour l’accès aux capteurs en arrière-plan. Pour le travail en arrière-plan, il est recommandé d’utiliser un Foreground Service avec une notification.

Résumé

  • Sensors API — une interface Android unifiée pour obtenir des données des capteurs matériels du périphérique via SensorManager.
  • Trois catégories — Motion (accéléromètre, gyroscope), Position (magnétomètre) et Environment (lumière, pression) avec différents principes de fonctionnement et applications.
  • Capteurs virtuels — Gravity, Linear Acceleration et Rotation Vector sont basés sur la fusion de données de capteurs physiques et n’ont pas d’équivalent matériel.
  • Optimisation — choisir le bon délai (SENSOR_DELAY_NORMAL, UI, GAME, FASTEST) et utiliser le traitement par lots réduisent la consommation d’énergie jusqu’à 60 %.
  • Limites — Android 8+ réduit le taux des capteurs en arrière-plan, Android 12+ nécessite BODY_SENSORS_BACKGROUND pour l’accès en arrière-plan.
  • Vérification de base — avant d’enregistrer un écouteur, vérifiez la disponibilité du capteur via getDefaultSensor ou hasSystemFeature.
  • Utilisez un filtre passe-bas pour lisser le bruit et désabonnez l’écouteur lors du passage en arrière-plan pour économiser la batterie.

Nous développerons une application mobile clé en main

IT Sectr crée des applications iOS et Android pour les startups et les entreprises depuis 2017. Nous vous conseillerons et vous proposerons la meilleure solution.

Discuter du projet

Lisez aussi