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 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.
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.
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é.
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}")
}
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.
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égorie | Capteurs | Type (constante) | Physique/Virtuel |
|---|---|---|---|
| Motion | Accéléromètre | TYPE_ACCELEROMETER | Physique |
| Motion | Gyroscope | TYPE_GYROSCOPE | Physique |
| Motion | Podomètre | TYPE_STEP_COUNTER | Physique |
| Motion | Gravity | TYPE_GRAVITY | Virtuel |
| Position | Magnétomètre | TYPE_MAGNETIC_FIELD | Physique |
| Position | Rotation Vector | TYPE_ROTATION_VECTOR | Virtuel |
| Environment | Lumière | TYPE_LIGHT | Physique |
| Environment | Pression | TYPE_PRESSURE | Physique |
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.
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) {}
}
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.
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.
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.
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é.
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.
val sensor = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)
sensorManager.registerListener(
this,
sensor,
SensorManager.SENSOR_DELAY_GAME
)
À 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.
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.
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.
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")
}
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.
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.
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.
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.
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())
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.
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")
}
}
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.
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.
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 — 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 — 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.
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.
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.
À 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.
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
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.
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.
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.
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.
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é
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.
Lisez aussi