Share
Apprenez à utiliser les capteurs d'environnement Android pour détecter des informations sur l'environnement de l'utilisateur, notamment la température ambiante, la pression, l'humidité et la lumière..
Le système Android prend en charge une gamme de capteurs de périphériques, certains implémentés dans le matériel et d'autres dans le logiciel. Les capteurs d'environnement sont toutes des fonctionnalités matérielles, donnant accès à des informations sur la température ambiante, la pression, l'humidité et la lumière. Ces capteurs renvoient les valeurs suivantes: la température est mesurée en degrés Celsius, la pression atmosphérique en millibars (hPa), l’humidité relative de l’air ambiant en pourcentage et la lumière ambiante en unités SI lux. Dans ce tutoriel, nous allons passer en revue le processus de base d'utilisation de ces quatre capteurs d'environnement principaux. Nous n'utiliserons pas le capteur de température de l'appareil, car il est désormais obsolète à partir d'Android 4.0..
Il existe de nombreuses applications possibles pour ces capteurs, telles que les baromètres et les thermomètres. Vous avez peut-être déjà rencontré de telles applications dans Google Play, mais il est à noter qu'elles n'implémentent peut-être pas leurs fonctions à l'aide des capteurs d'environnement. Par exemple, les applications météo utilisent souvent les données de localisation extraites sur le Web pour déterminer les informations d’environnement en fonction de l’emplacement où vous vous trouvez..
Étant donné que ces capteurs sont fournis via le matériel des utilisateurs, la prise en charge varie selon les appareils et les fabricants. Au moment de la rédaction de ce manuel, très peu de smartphones ou de tablettes Android prennent en charge tous les capteurs d'environnement, mais bon nombre des modèles les plus récents en prennent en charge un ou plusieurs. Il est essentiel de vérifier si l'utilisateur dispose de capteurs particuliers et d'éviter d'utiliser des fonctionnalités qui en dépendent totalement. La seule exception à cette règle est si vous vous assurez que seuls les utilisateurs disposant du matériel requis peuvent télécharger votre application. Pour ce faire, vous pouvez utiliser les filtres d'une application répertoriés dans le magasin Google Play..
Créez un nouveau projet Android dans Eclipse et nommez-le de votre choix. Laissez Eclipse créer une activité principale, car il s’agit de la seule classe dont nous aurons besoin. Pour le code utilisé dans ce didacticiel, nous ciblons le niveau 14 de l'API Android (Android 4.0 - Ice Cream Sandwich), mais vous pouvez également viser une version plus récente si vous le souhaitez. Vous n'avez pas besoin de modifier le fichier Manifest. Votre classe d'activité principale doit avoir la structure initiale suivante, avec le nom de la classe que vous avez choisi:
Classe publique EnvironmentCheckerActivity étend l'activité / ** Appelée lorsque l'activité est créée pour la première fois. * / @Override public void onCreate (Bundle savedInstanceState) super.onCreate (savedInstanceState); setContentView (R.layout.main);
Nous allons implémenter quelques interfaces, donc développez votre ligne de déclaration de classe d'ouverture comme suit:
Classe publique EnvironmentCheckerActivity, Activity implémente OnClickListener, SensorEventListener
L’écouteur de clics sert à l’interaction de l’utilisateur et l’écouteur d’événements de capteur sert à recevoir les données des capteurs du périphérique. Eclipse aurait dû fournir des instructions d'importation pour les classes Activity et Bundle, mais vous devez également ajouter les éléments suivants à la liste:
importer android.content.Context; importer android.hardware.Sensor; importer android.hardware.SensorEvent; importer android.hardware.SensorEventListener; importer android.hardware.SensorManager; importer android.view.View; importer android.view.View.OnClickListener; importer android.widget.Button; importer android.widget.TextView; importer android.widget.Toast;
Nous ajouterons du code à la classe plus tard.
Afin de démontrer le processus de base d'utilisation des capteurs d'environnement, nous allons créer une interface utilisateur simple. L'application affichera une liste de quatre boutons, un pour chacun des capteurs que nous utiliserons. Lorsque l'utilisateur sélectionne un bouton, l'application tente de récupérer les informations appropriées et de les présenter dans une vue de texte. Tout d’abord, définissons quelques chaînes de texte que nous utiliserons dans l’interface. Ouvrez votre fichier "res / values / strings.xml" et modifiez-le pour qu'il contienne les éléments suivants:
Choisissez parmi les options pour vérifier votre environnement Vérificateur de l'environnement Température ambiante Lumière Pression Humidité relative -
Ceux-ci représentent le titre, le texte d'introduction, les étiquettes de boutons et un espace réservé pour les vues de texte. Nous allons utiliser quelques ressources exploitables pour la conception, mais vous pouvez les omettre si vous le souhaitez. Pour les utiliser, dans chacun des dossiers de votre application, vous devez créer deux fichiers supplémentaires, "back.xml" et "btn.xml" (sélectionnez chaque dossier pouvant être dessiné et choisissez "Fichier"> "Nouveau"> " Fichier ", puis entrez le nom du fichier). Pour le fichier "back.xml", entrez le code suivant:
Pour le fichier "btn.xml", entrez les informations suivantes:
Le dos pouvant être dessiné est destiné à l’arrière-plan de l’activité et le "btn" pouvant être dessiné aux arrière-plans des boutons. N'hésitez pas à modifier ces conceptions comme bon vous semble - assurez-vous de les copier dans chaque dossier pouvant être dessiné dans votre application..
Ouvrez maintenant le fichier de présentation "main.xml" de votre application (res / layout / main.xml). Entrez une vue de défilement et une disposition linéaire comme suit:
Dans la mise en page linéaire, ajoutez l'introduction, puis un bouton et une vue texte pour chacun des quatre capteurs:
Chaque paire de boutons et d’affichage texte est pratiquement identique, avec des attributs d’ID permettant de les identifier dans le code Java. Bien sûr, vous pouvez modifier n'importe lequel des éléments de conception si vous le souhaitez. La mise en page fait référence aux ressources et aux chaînes pouvant être extraites.
Ouvrez la classe d'activité principale de votre application. En haut de la déclaration de classe, avant la méthode "onCreate", ajoutez les variables d'instance suivantes:
Bouton privé ambientBtn, lightBtn, pressureBtn, dampBtn; private TextView ambientValue, lightValue, pressureValue, dampValue;
Celles-ci représentent les boutons et les vues de texte que nous avons créés dans la présentation. Nous allons utiliser un tableau pour garder une trace des éléments de la vue texte, car ceux-ci seront mis à jour avec les informations lorsque les capteurs le renvoient. Ajoutez donc la variable suivante:
private TextView [] valueFields = new TextView [4];
Ajoutez maintenant ces constantes pour faire référence à chaque type de capteur:
finale privée int AMBIENT = 0; finale privée int LIGHT = 1; finale privée int PRESSION = 2; finale privée int HUMIDITY = 3;
Dans la méthode "onCreate", après la ligne dans laquelle la vue de contenu est définie, récupérez une référence à chaque bouton à l'aide des attributs d'ID inclus dans la présentation, comme suit:
ambientBtn = (Button) findViewById (R.id.ambient_btn); lightBtn = (Button) findViewById (R.id.light_btn); pressureBtn = (Button) findViewById (R.id.pressure_btn); dampBtn = (Button) findViewById (R.id.humidity_btn);
Définissez maintenant chacun d’eux pour utiliser la classe d’activité en tant qu’écouteur de clics:
ambientBtn.setOnClickListener (this); lightBtn.setOnClickListener (this); pressureBtn.setOnClickListener (this); dampBtn.setOnClickListener (this);
Lorsque ces boutons sont enfoncés, la méthode Activity "onClick" sera exécutée. Ensuite, récupérez les éléments de la vue texte et ajoutez une référence à chacun d'eux dans le tableau que nous avons déclaré, en utilisant les constantes pour spécifier chaque index:
ambientValue = (TextView) findViewById (R.id.ambient_text); valueFields [AMBIENT] = ambientValue; lightValue = (TextView) findViewById (R.id.light_text); valueFields [LIGHT] = lightValue; pressureValue = (TextView) findViewById (R.id.pressure_text); valueFields [PRESSURE] = pressureValue; dampValue = (TextView) findViewById (R.id.humidity_text); valueFields [HUMIDITY] = dampValue;
Nous devons maintenant fournir la méthode "onClick", en l'ajoutant à la classe après la méthode "onCreate":
vide publique onClick (View v)
Dans la méthode, nous devons déterminer quel bouton a été cliqué en utilisant une condition:
if (v.getId () == R.id.ambient_btn) // température ambiante else if (v.getId () == R.id.light_btn) // light else if (v.getId () == R.id.pressure_btn) // pression sinon if (v.getId () == R.id.humidity_btn) // humidité
Dans chacun de ces cas, nous tenterons de récupérer les données d'environnement pertinentes.
En haut de la classe, ajoutez quelques variables pour le processus de détection d'environnement:
SensorManager privé senseManage; capteur privé envSense;
De retour dans la méthode "onCreate", après le code existant, ajoutez ce qui suit pour créer une instance de la classe Sensor Manager:
senseManage = (SensorManager) getSystemService (Context.SENSOR_SERVICE);
Nous avons besoin du Sensor Manager pour tous les processus de détection d'environnement. Nous l'utilisons pour récupérer des capteurs spécifiques. Dans la "onClick" méthode "if" pour la température ambiante, essayez de récupérer le capteur de température ambiante comme suit:
envSense = senseManage.getDefaultSensor (Sensor.TYPE_AMBIENT_TEMPERATURE);
Nous devons maintenant nous occuper des cas dans lesquels le capteur n'est pas fourni par la machine utilisateur. Ajoutez donc le test suivant:
if (envSense == null) Toast.makeText (this.getApplicationContext (), "Désolé - votre appareil ne possède pas de capteur de température ambiante!", Toast.LENGTH_SHORT) .show ();
Nous produisons simplement un message d'erreur. Si le capteur est présent, nous devons nous enregistrer pour recevoir les données qu'il renvoie, alors ajoutez ce qui suit après cette instruction "if":
else senseManage.registerListener (this, envSense, SensorManager.SENSOR_DELAY_NORMAL);
Exécutez maintenant le même processus pour chacun des boutons de la méthode "onClick". Pour le bouton lumineux (dans sa déclaration "if" dans "onClick"):
envSense = senseManage.getDefaultSensor (Sensor.TYPE_LIGHT); if (envSense == null) Toast.makeText (this.getApplicationContext (), "Désolé - votre appareil ne possède pas de capteur de lumière!", Toast.LENGTH_SHORT) .show (); else senseManage.registerListener (this, envSense, SensorManager.SENSOR_DELAY_NORMAL);
Notez que nous demandons ici le capteur "TYPE_LIGHT" et adaptons le message d'erreur au type de capteur. Pour le bouton pression:
envSense = senseManage.getDefaultSensor (Sensor.TYPE_PRESSURE); if (envSense == null) Toast.makeText (this.getApplicationContext (), "Désolé - votre appareil ne possède pas de capteur de pression!", Toast.LENGTH_SHORT) .show (); else senseManage.registerListener (this, envSense, SensorManager.SENSOR_DELAY_NORMAL);
Enfin, dans l’énoncé "if" du bouton d’humidité:
envSense = senseManage.getDefaultSensor (Sensor.TYPE_RELATIVE_HUMIDITY); if (envSense == null) Toast.makeText (this.getApplicationContext (), "Désolé - votre appareil ne possède pas de capteur d'humidité!", Toast.LENGTH_SHORT) .show (); else senseManage.registerListener (this, envSense, SensorManager.SENSOR_DELAY_NORMAL);
En plus de renvoyer les données d'environnement demandées, le capteur renverra également des données de précision. Ajoutez la méthode suivante à votre classe, requise lors de l'implémentation de l'interface du détecteur d'événements du capteur:
@Override public final final onAccuracyChanged (capteur, précision int)
Dans la méthode, commencez à créer un message concernant la précision:
String precisionMsg = "";
Nous allons utiliser une instruction switch sur le paramètre entier de précision passé:
commutateur (précision) case SensorManager.SENSOR_STATUS_ACCURACY_HIGH: precisionMsg = "Le capteur a une grande précision"; Pause; case SensorManager.SENSOR_STATUS_ACCURACY_MEDIUM: precisionMsg = "La précision du capteur est moyenne"; Pause; case SensorManager.SENSOR_STATUS_ACCURACY_LOW: precisionMsg = "La précision du capteur est faible"; Pause; case SensorManager.SENSOR_STATUS_UNRELIABLE: precisionMsg = "La précision du capteur est incertaine"; Pause; défaut: break;
Nous adaptons le message au niveau de précision du capteur, en utilisant la classe Sensor Manager. Indiquez l’exactitude lorsqu’elle est reçue comme suit, mais après l’instruction switch:
Toast precisionToast = Toast.makeText (this.getApplicationContext (), precisionMsg, Toast.LENGTH_SHORT); precisionToast.show ();
Dans la méthode "onAccuracyChanged", vous pouvez également déterminer le type de capteur à partir du paramètre passé si nécessaire..
Nous pouvons maintenant récupérer les données renvoyées par les capteurs à l'aide d'un événement de capteur. Pour ce faire, utilisez la méthode "onSensorChanged", qui est également requise pour implémenter l'interface:
@Override public final final onSensorChanged (événement SensorEvent)
L'événement de capteur renvoie ses données de différentes manières en fonction du type de capteur. Pour les quatre types que nous utilisons, il est extrait de la même manière, à partir du premier élément d'un tableau de valeurs à virgule flottante. Ajoutez les éléments suivants dans la méthode:
float sensorValue = event.values [0];
Nous allons maintenant créer une chaîne de texte contenant ces données et l'écrire dans la vue de texte appropriée pour que l'utilisateur puisse la voir. Tout d'abord, nous créons une variable Text View et lui attribuons une valeur par défaut (cette valeur sera remplacée - nous l'incluons pour que Eclipse reste heureux):
TextView currValue = ambientValue;
Ensuite, nous déclarons la chaîne:
Chaîne;
Le contenu de la chaîne dépendra du type de capteur. Découvrez donc de quel capteur il s'agit:
int currType = event.sensor.getType ();
Nous pouvons maintenant utiliser une instruction switch sur cette valeur:
switch (currType) case Sensor.TYPE_AMBIENT_TEMPERATURE: envInfo = sensorValue + "degrés Celsius"; currValue = valueFields [AMBIENT]; Pause; case Sensor.TYPE_LIGHT: envInfo = sensorValue + "unités SI lux"; currValue = valueFields [LIGHT]; Pause; case Sensor.TYPE_PRESSURE: envInfo = sensorValue + "hPa (millibars)"; currValue = valueFields [PRESSURE]; Pause; case Sensor.TYPE_RELATIVE_HUMIDITY: envInfo = sensorValue + "pourcent d'humidité"; currValue = valueFields [HUMIDITY]; Pause; défaut: break;
Dans chaque cas, nous construisons la chaîne informative à l'aide de la valeur de capteur extraite et d'un extrait de texte correspondant au type. Nous définissons également la vue texte sur l'élément d'interface utilisateur approprié à l'aide du tableau et des constantes. Après l'instruction switch, indiquez les informations suivantes:
currValue.setText (envInfo);
Maintenant, réinitialisez la variable du capteur et arrêtez d’écouter les mises à jour pour éviter une utilisation inutile de la batterie:
envSense = null; senseManage.unregisterListener (this);
Enfin, nous ne voulons pas que l'application utilise des ressources inutiles lorsqu'elle est en pause, ajoutez donc cette méthode à la classe:
@Override protected void onPause () super.onPause (); senseManage.unregisterListener (this);
C'est l'application de démonstration complète! Il est inutile d'exécuter cette application sur l'émulateur Android par défaut, car elle ne fournit pas de capteurs d'environnement. Cependant, vous pouvez soit l'exécuter sur un périphérique réel, soit utiliser l'outil Sensor Simulator, qui vous permet de simuler certains aspects de l'environnement. Voici une capture d'écran de l'application en cours d'exécution sur le Samsung Galaxy S III juste après la récupération des données de luminosité et de pression:
La voici pour les deux autres capteurs, qui ne sont pas supportés:
Les capteurs d’environnement sont une fonctionnalité intéressante mais toujours en développement de la plate-forme Android. Cependant, il est un peu tôt pour se concentrer sur eux. Si vous souhaitez explorer l'utilisation de ces capteurs de manière plus avancée, consultez la section du Guide du développeur sur le calcul du point de rosée et des niveaux d'humidité absolue en fonction de l'humidité relative et de la température ambiante. Autre que cela - essayez d'être patient!
Accentsconagua