- l'Azimtuh en degrés
angle formé par l'axe vertical du téléphone (axe x) et la direction nord
0° ≤ azimuth ≤ 360° - le Pitch en degrés
angle formé par l'axe horizontal du téléphone (axe y) et la position horizontal de référence
-180° ≤ pitch ≤ 180° - le Roll en degrés
angle formé par l'axe vertical du téléphone (axe x) et la position horizontal de référence
-90° ≤ roll ≤ 90°
package net.androgames.blog.sample.orientation;
public interface OrientationListener {
public void onOrientationChanged(float azimuth,
float pitch, float roll);
/**
* Top side of the phone is up
* The phone is standing on its bottom side
*/
public void onTopUp();
/**
* Bottom side of the phone is up
* The phone is standing on its top side
*/
public void onBottomUp();
/**
* Right side of the phone is up
* The phone is standing on its left side
*/
public void onRightUp();
/**
* Left side of the phone is up
* The phone is standing on its right side
*/
public void onLeftUp();
}Une instance de la classe SensorManager nous permet de récupérer les informations sur les changements d'orientation du téléphone. L'utilisation du senseur d'orientation ne requière aucune autorisation. La liste des senseurs d'orientation du téléphone se récupère au moyen de la constante caractérisant le type de senseur : Sensor.TYPE_ORIENTATION. S'il existe au moins un Sensor, un SensorEventListener peut alors être associé à l'un des Sensor de la liste afin de récupérer les informations sur les changements d'orientation. Il est possible de maîtriser la fréquence des mises à jour souhaitées grâce aux constantes suivantes :
- SensorManager.SENSOR_DELAY_FASTEST : aussi vite que possible
- SensorManager.SENSOR_DELAY_GAME : suffisant pour un jeu
- SensorManager.SENSOR_DELAY_NORMAL : fréquence normale
- SensorManager.SENSOR_DELAY_UI : fréquence compatible pour être traité dans l'UI Thread
Notre manager d'orientation personnalisé est codé comme suit :
package net.androgames.blog.sample.orientation;
import java.util.List;
import android.content.Context;
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;
/**
* Android Orientation Sensor Manager Archetype
* @author antoine vianey
* under GPL v3 : http://www.gnu.org/licenses/gpl-3.0.html
*/
public class OrientationManager {
private static Sensor sensor;
private static SensorManager sensorManager;
// you could use an OrientationListener array instead
// if you plans to use more than one listener
private static OrientationListener listener;
/** indicates whether or not Orientation Sensor is supported */
private static Boolean supported;
/** indicates whether or not Orientation Sensor is running */
private static boolean running = false;
/** Sides of the phone */
enum Side {
TOP,
BOTTOM,
LEFT,
RIGHT;
}
/**
* Returns true if the manager is listening to orientation changes
*/
public static boolean isListening() {
return running;
}
/**
* Unregisters listeners
*/
public static void stopListening() {
running = false;
try {
if (sensorManager != null && sensorEventListener != null) {
sensorManager.unregisterListener(sensorEventListener);
}
} catch (Exception e) {}
}
/**
* Returns true if at least one Orientation sensor is available
*/
public static boolean isSupported(Context context) {
if (supported == null) {
if (Orientation.getContext() != null) {
sensorManager = (SensorManager) context
.getSystemService(Context.SENSOR_SERVICE);
List<Sensor> sensors = sensorManager.getSensorList(
Sensor.TYPE_ORIENTATION);
supported = new Boolean(sensors.size() > 0);
} else {
supported = Boolean.FALSE;
}
}
return supported;
}
/**
* Registers a listener and start listening
*/
public static void startListening(Context context,
OrientationListener orientationListener) {
sensorManager = (SensorManager) context
.getSystemService(Context.SENSOR_SERVICE);
List<Sensor> sensors = sensorManager.getSensorList(
Sensor.TYPE_ORIENTATION);
if (sensors.size() > 0) {
sensor = sensors.get(0);
running = sensorManager.registerListener(
sensorEventListener, sensor,
SensorManager.SENSOR_DELAY_NORMAL);
listener = orientationListener;
}
}
/**
* The listener that listen to events from the orientation listener
*/
private static SensorEventListener sensorEventListener =
new SensorEventListener() {
/** The side that is currently up */
private Side currentSide = null;
private Side oldSide = null;
private float azimuth;
private float pitch;
private float roll;
public void onAccuracyChanged(Sensor sensor, int accuracy) {}
public void onSensorChanged(SensorEvent event) {
azimuth = event.values[0]; // azimuth
pitch = event.values[1]; // pitch
roll = event.values[2]; // roll
if (pitch < -45 && pitch > -135) {
// top side up
currentSide = Side.TOP;
} else if (pitch > 45 && pitch < 135) {
// bottom side up
currentSide = Side.BOTTOM;
} else if (roll > 45) {
// right side up
currentSide = Side.RIGHT;
} else if (roll < -45) {
// left side up
currentSide = Side.LEFT;
}
if (currentSide != null && !currentSide.equals(oldSide)) {
switch (currentSide) {
case TOP :
listener.onTopUp();
break;
case BOTTOM :
listener.onBottomUp();
break;
case LEFT:
listener.onLeftUp();
break;
case RIGHT:
listener.onRightUp();
break;
}
oldSide = currentSide;
}
// forwards orientation to the OrientationListener
listener.onOrientationChanged(azimuth, pitch, roll);
}
};
}Cet OrientationManager personnalisé peut être utilisé dans n'importe quelle Activity ou Service en suivant l'exemple ci-dessous :
package net.androgames.blog.sample.orientation;
import android.app.Activity;
import android.content.Context;
import android.os.Bundle;
import android.widget.TextView;
import android.widget.Toast;
/**
* Android orientation sensor tutorial
* @author antoine vianey
* under GPL v3 : http://www.gnu.org/licenses/gpl-3.0.html
*/
public class Orientation extends Activity implements OrientationListener {
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
}
protected void onResume() {
super.onResume();
if (OrientationManager.isSupported(this)) {
OrientationManager.startListening(this, this);
}
}
protected void onPause() {
super.onPause();
if (OrientationManager.isListening()) {
OrientationManager.stopListening();
}
}
@Override
public void onOrientationChanged(float azimuth,
float pitch, float roll) {
((TextView) findViewById(R.id.azimuth)).setText(
String.valueOf(azimuth));
((TextView) findViewById(R.id.pitch)).setText(
String.valueOf(pitch));
((TextView) findViewById(R.id.roll)).setText(
String.valueOf(roll));
}
@Override
public void onBottomUp() {
Toast.makeText(this, "Bottom UP", 1000).show();
}
@Override
public void onLeftUp() {
Toast.makeText(this, "Left UP", 1000).show();
}
@Override
public void onRightUp() {
Toast.makeText(this, "Right UP", 1000).show();
}
@Override
public void onTopUp() {
Toast.makeText(this, "Top UP", 1000).show();
}
}Le meilleur endroit pour associer le manager personnalisé est la méthode onResume() de l'Activity. La désassociation se fera de préférence dans la méthode onPause() de l'Activity afin de ne pas maintenir de ressources inutilisées.
Comme d'habitude, n'hésitez pas à partager vos créations utilisant le senseur d'orientation !
