Tutoriel Android : apprendre à utiliser les capteurs sous Android

// The sensor manager 
SensorManager sensorManager;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    // Instanicer le SensorManager
    sensorManager = (SensorManager) getSystemService(SENSOR_SERVICE);
    // Faire la liste des capteurs de l'appareil
    listSensor();
}

/**
 * Lister les capteurs existants
 *
 * Trouve la liste de tous les capteurs existants, trouve un capteur spécifique ou l'ensemble des capteurs d'un type fixé.
 */
private void listSensor() {
    // Trouver tous les capteurs de l'appareil :
    List<Sensor> sensors = sensorManager.getSensorList(Sensor.TYPE_ALL);
    // La chaîne descriptive de chaque capteur
    StringBuffer sensorDesc = new StringBuffer();
    // pour chaque capteur trouvé, construire sa chaîne descriptive
    for (Sensor sensor : sensors) {
        sensorDesc.append("New sensor detected : \r\n");
        sensorDesc.append("\tName: " + sensor.getName() + "\r\n");
        sensorDesc.append("\tType: " + getType(sensor.getType()) + "\r\n");
        sensorDesc.append("Version: " + sensor.getVersion() + "\r\n");
        sensorDesc.append("Resolution (in the sensor unit): " + sensor.getResolution() + "\r\n");
        sensorDesc.append("Power in mA used by this sensor while in use" + sensor.getPower() + "\r\n");
        sensorDesc.append("Vendor: " + sensor.getVendor() + "\r\n");
        sensorDesc.append("Maximum range of the sensor in the sensor's unit." + sensor.getMaximumRange() + "\r\n");
        sensorDesc.append("Minimum delay allowed between two events in microsecond" + " or zero if this sensor only returns a value when the data it's measuring changes" + sensor.getMinDelay() + "\r\n");
    }
    
    // Faire quelque chose de cette liste
    Toast.makeText(this, sensorDesc.toString(), Toast.LENGTH_LONG).show();

    // Pour trouver un capteur spécifique :
    Sensor gyroscopeDefault = sensorManager.getDefaultSensor(Sensor.TYPE_GYROSCOPE);
    // Pour trouver tous les capteurs d'un type fixé :
    List<Sensor> gyroscopes = sensorManager.getSensorList(Sensor.TYPE_GYROSCOPE);
}

private String getType(int type) {
    String strType;
    switch (type) {
    case Sensor.TYPE_ACCELEROMETER: strType = "TYPE_ACCELEROMETER";break;
    case Sensor.TYPE_GRAVITY:strType = "TYPE_GRAVITY";break;
    case Sensor.TYPE_GYROSCOPE:    strType = "TYPE_GYROSCOPE";    break;
    case Sensor.TYPE_LIGHT:strType = "TYPE_LIGHT";break;
    case Sensor.TYPE_LINEAR_ACCELERATION:strType = "TYPE_LINEAR_ACCELERATION";
        break;
    case Sensor.TYPE_MAGNETIC_FIELD:strType = "TYPE_MAGNETIC_FIELD";break;
    case Sensor.TYPE_ORIENTATION:strType = "TYPE_ORIENTATION";break;
    case Sensor.TYPE_PRESSURE:strType = "TYPE_PRESSURE";break;
    case Sensor.TYPE_PROXIMITY:    strType = "TYPE_PROXIMITY";    break;
    case Sensor.TYPE_ROTATION_VECTOR:    strType = "TYPE_ROTATION_VECTOR";break;
    case Sensor.TYPE_TEMPERATURE:strType = "TYPE_TEMPERATURE";break;
    default: strType = "TYPE_UNKNOW";break;
    }
    return strType;
}

public class SensorAccelerationTutoActivity extends Activity implements SensorEventListener {

    // Déclaration de l'attribut en tant qu'attribut de l'activité
    // Le sensor manager (gestionnaire de capteurs)
    SensorManager sensorManager;

    // L'accéléromètre
    Sensor accelerometer;

/***************************************************************************/
/** Manage life cycle ******************************************************/
/***************************************************************************/

    // Appelé à la création de l'activité. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // Faire quelque chose
        // Gérer les capteurs :
        // Instancier le gestionnaire des capteurs, le SensorManager
        sensorManager = (SensorManager) getSystemService(SENSOR_SERVICE);
        // Instancier l'accéléromètre
        accelerometer = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
        // Faire d'autres trucs
    }

    @Override
    protected void onPause() {
        // unregister the sensor (désenregistrer le capteur)
        sensorManager.unregisterListener(this, accelerometer);
        super.onPause();
    }

    @Override
    protected void onResume() {
        /* Ce qu'en dit Google dans le cas de l'accéléromètre :
         * «  Ce n'est pas nécessaire d'avoir les évènements des capteurs à un rythme trop rapide.
         * En utilisant un rythme moins rapide (SENSOR_DELAY_UI), nous obtenons un filtre
         * automatique de bas niveau qui "extrait" la gravité  de l'accélération.
         * Un autre bénéfice étant que l'on utilise moins d'énergie et de CPU. »
         */
        sensorManager.registerListener(this, accelerometer, SensorManager.SENSOR_DELAY_UI);
        super.onResume();
    }

/********************************************************************/
/** SensorEventListener*************************************************/
/********************************************************************/

    @Override
    public void onAccuracyChanged(Sensor sensor, intaccuracy) {
        // Rien à faire la plupart du temps
    }

    @Override
    public void onSensorChanged(SensorEvent event) {
        // Récupérer les valeurs du capteur
        floatx, y, z;
        if (event.sensor.getType() == Sensor.TYPE_ACCELEROMETER) {
            x = event.values[0];
            y = event.values[1];
            z = event.values[2];
        }
    }

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.android2ee.android.tuto.sensor.light"android:versionCode="1"
    android:versionName="1.0">
    <uses-sdkandroid:minSdkVersion="10" />
    <uses-featureandroid:name="android.hardware.sensor.accelerometer" android:required="true" />
    <uses-featureandroid:name="android.hardware.sensor.barometer" android:required="true" />
    <uses-featureandroid:name="android.hardware.sensor.compass" android:required="true" />
    <uses-featureandroid:name="android.hardware.sensor.gyroscope" android:required="true" />
    <uses-featureandroid:name="android.hardware.sensor.light" android:required="true" />
    <uses-featureandroid:name="android.hardware.sensor.proximity" android:required="true" />
</manifest>

    // En attribut de la classe (de l'activité), le seul qui connaisse l'orientation de l'appareil 
    private Display mDisplay;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // Faire quelque chose
        // Gérer les capteurs :
        // Instancier le gestionnaire des capteurs, le SensorManager
        sensorManager = (SensorManager) getSystemService(SENSOR_SERVICE);
        // Instancier l'accéléromètre
        accelerometer = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
        // Faire d'autres trucs
    }
    
    @Override
    public void onSensorChanged(SensorEvent event) {
        // Récupérer les valeurs du capteur
        float x, y, z;
        if (event.sensor.getType() == Sensor.TYPE_ACCELEROMETER) {
            // Log.d(LOG_TAG, "TYPE_ACCELEROMETER");
            // En fonction de l'orientation de l'appareil, on corrige les valeurs x et y du capteur
            switch (mDisplay.getRotation()) {
            case Surface.ROTATION_0:
            x = event.values[0];
            y = event.values[1];
            break;
            case Surface.ROTATION_90:
            x = -event.values[1];
            y = event.values[0];
            break;
            case Surface.ROTATION_180:
            x = -event.values[0];
            y = -event.values[1];
            break;
            case Surface.ROTATION_270:
            x = event.values[1];
            y = -event.values[0];
            break;
        }
        
        // la valeur de z
        z = event.values[2];
        // faire quelque chose, par exemple un Log :
        Log.d(LOG_TAG, "Sensor's values ("+x+","+y+","+z+") and maxRange : "+maxRange);
    }
}

// Le SensorManager
sensorManager = (SensorManager) getSystemService(SENSOR_SERVICE);

// Le capteur d'orientation
orientation = sensorManager.getDefaultSensor(Sensor.TYPE_ORIENTATION);

@Override
public void onSensorChanged(SensorEvent event) {
// update only when your are in the right case:
if (event.sensor.getType() == Sensor.TYPE_ORIENTATION) {
    //l' azimuth
    x = event.values[0];
    //le pitch
    y = event.values[1];
    //le roll
    z = event.values[2];
    }
}

// Attribut de la classe pour calculer  l'orientation
float[] acceleromterVector=newfloat[3];
float[] magneticVector=newfloat[3];
float[] resultMatrix=newfloat[9];
float[] values=newfloat[3];

// Instantiate the magnetic sensor and its max range
magnetic = sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD);

// Instantiate the accelerometer
accelerometer = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);

@Override
public void onSensorChanged(SensorEvent event) {
    // Mettre à jour la valeur de l'accéléromètre et du champ magnétique
    if (event.sensor.getType() == Sensor.TYPE_ACCELEROMETER) {
        acceleromterVector=event.values;
    } elseif (event.sensor.getType() == Sensor.TYPE_MAGNETIC_FIELD) {
        magneticVector=event.values;
    }

    // Demander au sensorManager la matric de Rotation (resultMatric)
    SensorManager.getRotationMatrix(resultMatrix, null, acceleromterVector, magneticVector);

    // Demander au SensorManager le vecteur d'orientation associé (values)
    SensorManager.getOrientation(resultMatrix, values);
    // l'azimuth
    x =(float) Math.toDegrees(values[0]);
    // le pitch
    y = (float) Math.toDegrees(values[1]);
    // le roll
    z = (float) Math.toDegrees(values[2]);
}

// Sauver la configuration du canvas (orientation, translation)
canvas.save();

// trouver la valeur du roll à afficher
floatroll = activity.z;

// faire tourner le canvas, de manière à ce que la description de notre dessin s'effectue dans un repère
// orthonormé normal (y vers le haut), mais à ce que son affichage soit le y vers l'angle du roll
canvas.rotate(roll, 0, 0);

// Définir le rectangle contenant le cercle que l'on va dessiner
RectF pitchOval = new RectF(0,0, lenght, lenght);

// Dessiner le cercle de fond
paint.setColor(backgroundCircleColor);
canvas.drawArc(pitchOval, 0, 360, false, paint);

// dessiner le demi-cercle qui représente le roll (et là grâce à la rotation du canvas, on le dessine comme étant le demi-cercle inférieur)
paint.setColor(circleColor);
canvas.drawArc(pitchOval, 0, 180, false, paint);

// Pour finir, revenir à la configuration du canvas initiale ‘il ne prend plus en compte notre rotation dans sa future //utilisation)
canvas.restore();

// Sauver la configuration initiale du canvas
canvas.save();

// Trouver le pitch à afficher
floatpitch = activity.y;

// Mettre le centre au milieu de l'écran, dans son quart bas
canvas.translate(cx, cy + 3 * lenght / 2);

// Définir le rectangle contenant le cercle à dessiner
RectF pitchOval = new RectF(-lenght/2, -lenght/2, lenght/2, lenght/2);

// Dessiner le cercle du fond
paint.setColor(backgroundCircleColor);
canvas.drawCircle(0, 0, lenght / 2, paint);

// Dessiner le pitch 
paint.setColor(circleColor);
if(pitch<=0) {
    canvas.drawArc(pitchOval, -90-pitch, 360+2*pitch, false, paint);
}else {
    canvas.drawArc(pitchOval, 90+pitch, 360-2*pitch, false, paint);
}

// restaurer l'état initial du canvas
canvas.restore();
Pour l'azimut, ou comment dessiner une boussole :
canvas.save();

// Définir la flèche nord
Path northPath = new Path();
Path southPath = new Path();
northPath.moveTo(0, -60);
northPath.lineTo(-10, 0);
northPath.lineTo(10,0);
northPath.close();

// Définir la flèche sud
southPath.moveTo(-10,0);
southPath.lineTo(0,60);
southPath.lineTo(10,0);
southPath.close();
floatfontHeight = paint.getFontMetrics().ascent  +  paint.getFontMetrics().descent;

// Retrouver l'azimut à afficher
floatazimut = -activity.x;

// Centrer le compas au milieu de l'écran
canvas.translate(cx, cy);

// Effectuer une rotation de canvas, de sorte que la flèche indique le nord 
// quand on la dessine verticalement
canvas.rotate(azimut);

// Dessiner le cercle de la boussole
paint.setColor(backgroundCircleColor);
canvas.drawCircle(0, 0, lenght / 2, paint);

// Dessiner la graduation du compas
paint.setColor(Color.WHITE);
floathText = - lenght/2 - fontHeight+3;

// Tous les 15° faire une graduation
intstep = 15;
for (intdegree = 0; degree < 360; degree = degree + step) {
    // Si ce n'est pas un point cardinal, dessiner une graduation
    if ((degree % 90) != 0) {
        canvas.drawText("|", 0, hText, paint);
    }
    canvas.rotate(-step);
}

// Dessiner les points cardinaux
canvas.drawText("N", 0, hText, paint);
canvas.rotate(-90);
canvas.drawText("W", 0, hText, paint);
canvas.rotate(-90);
canvas.drawText("S", 0, hText, paint);
canvas.rotate(-90);
canvas.drawText("E", 0, hText, paint);
canvas.rotate(-90);

// Dessiner les flèches
paint.setStyle(Paint.Style.FILL);
paint.setColor(Color.RED);
canvas.drawPath(northPath, paint);
paint.setColor(circleColor);
canvas.drawPath(southPath, paint);

// Restaurer l'état initial du canvas
canvas.restore();

@Override
public void onSensorChanged(SensorEvent event) {
    // Récupérer les valeurs de l'accélération et du champ magnétique:    
    if (event.sensor.getType() == Sensor.TYPE_ACCELEROMETER) {
        acceleromterVector=event.values;
    } elseif (event.sensor.getType() == Sensor.TYPE_MAGNETIC_FIELD) {
        magneticVector=event.values;
    }
    
    // Retrouver la matrice de rotation
    SensorManager.getRotationMatrix(resultMatrix, null, acceleromterVector, magneticVector);
    
    // Effectuer le changement de coordonnées en utilisant la méthode remap:
    float[] outR=newfloat[9];
    SensorManager.remapCoordinateSystem(resultMatrix, SensorManager.AXIS_Y, 
        SensorManager.AXIS_Z, outR);
    
    // Retrouver la matrice d'orientation en lui passant outR et non pas resultMatrix
    SensorManager.getOrientation(outR, values);
    
    // Récuperer les différentes valeurs maintenant corrigées dans ce nouveau système.
    // l'azimut
    x =(float) Math.toDegrees(values[0]);
    // le pitch
    y = (float) Math.toDegrees(values[1]);
    // le roll
    z = (float) Math.toDegrees(values[2]);
}