Android accelerometer sensor tutorial

Android Application Development Training Tutorial

For more info visit

http://www.zybotech.in

A7, Stephanos Tower, Eachamukku, Kakkanadu,Kochi

Android Accelerometer Sensor tutorial
Android supports a wide variety of sensors that can be used by applications to capture informations about the
phone’s environment.

In this tutorial, we’ll see how to use the accelerometer sensor in an application in order to capture acceleration
change events. We’ll use these events to build a custom listener that will trigger others events such as shake
events :

package net.androgames.bolg.sample.accelerometer;

public interface AccelerometerListener {

public void onAccelerationChanged(float x, float y, float z);

public void onShake(float force);

}

An instance of the SensorManager is required in order to retrieve informations about the supported sensors. No
permission is required to access the sensor service. It is then possible to retrieve the list of available sensors of a
certain type. For an accelerometer sensor, the type to use is given by the Sensor.TYPE_ACCELEROMETER
constant. If at least one Sensor exists, it is possible to register a SensorEventListener for a Sensor of the list. It
is possible to specify the delivering rate for sensor events. Specified rate must be one of :

1. SensorManager.SENSOR_DELAY_FASTEST : as fast as possible
2. SensorManager.SENSOR_DELAY_GAME : rate suitable for game
3. SensorManager.SENSOR_DELAY_NORMAL : normal rate
4. SensorManager.SENSOR_DELAY_UI : rate suitable for UI Thread

In order to allow a correct shake detection, it is preferable to use at least
SensorManager.SENSOR_DELAY_GAME.

The custom accelerometer manager is as follow :


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 Accelerometer Sensor Manager Archetype
* @author antoine vianey
* under GPL v3 : http://www.gnu.org/licenses/gpl-3.0.html
*/
public class AccelerometerManager {

/** Accuracy configuration */
private static float threshold = 0.2f;
private static int interval = 1000;


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 AccelerometerListener listener;

/** indicates whether or not Accelerometer Sensor is supported */
private static Boolean supported;
/** indicates whether or not Accelerometer Sensor is running */
private static boolean running = false;

/**
* 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 Accelerometer sensor is available
*/
public static boolean isSupported() {
if (supported == null) {
if (Accelerometer.getContext() != null) {
sensorManager = (SensorManager) Accelerometer.getContext().
getSystemService(Context.SENSOR_SERVICE);
List<Sensor> sensors = sensorManager.getSensorList(
Sensor.TYPE_ACCELEROMETER);
supported = new Boolean(sensors.size() > 0);
} else {
supported = Boolean.FALSE;
}
}
return supported;
}

/**
* Configure the listener for shaking
* @param threshold
* minimum acceleration variation for considering shaking
* @param interval
* minimum interval between to shake events
*/
public static void configure(int threshold, int interval) {
AccelerometerManager.threshold = threshold;
AccelerometerManager.interval = interval;
}


/**
* Registers a listener and start listening
* @param accelerometerListener
* callback for accelerometer events
*/
public static void startListening(
AccelerometerListener accelerometerListener) {
sensorManager = (SensorManager) Accelerometer.getContext().
getSystemService(Context.SENSOR_SERVICE);
Sensor.TYPE_ACCELEROMETER);
if (sensors.size() > 0) {
sensor = sensors.get(0);
running = sensorManager.registerListener(
sensorEventListener, sensor,
SensorManager.SENSOR_DELAY_GAME);
listener = accelerometerListener;
}
}

/**
* Configures threshold and interval
* And registers a listener and start listening
* @param accelerometerListener
* callback for accelerometer events
* @param threshold
* minimum acceleration variation for considering shaking
* @param interval
* minimum interval between to shake events
*/
AccelerometerListener accelerometerListener,
int threshold, int interval) {
configure(threshold, interval);
startListening(accelerometerListener);
}

/**
* The listener that listen to events from the accelerometer listener
*/
private static SensorEventListener sensorEventListener =
new SensorEventListener() {

private long now = 0;
private long timeDiff = 0;
private long lastUpdate = 0;
private long lastShake = 0;

private float x = 0;
private float y = 0;
private float z = 0;
private float lastX = 0;
private float lastY = 0;
private float lastZ = 0;
private float force = 0;

public void onAccuracyChanged(Sensor sensor, int accuracy) {}

public void onSensorChanged(SensorEvent event) {
// use the event timestamp as reference
// so the manager precision won't depends


// on the AccelerometerListener implementation
// processing time
now = event.timestamp;

x = event.values[0];
y = event.values[1];
z = event.values[2];

// if not interesting in shake events
// just remove the whole if then else bloc
if (lastUpdate == 0) {
lastUpdate = now;
lastShake = now;
lastX = x;
lastY = y;
lastZ = z;
} else {
timeDiff = now - lastUpdate;
if (timeDiff > 0) {
force = Math.abs(x + y + z - lastX - lastY - lastZ)
/ timeDiff;
if (force > threshold) {
if (now - lastShake >= interval) {
// trigger shake event
listener.onShake(force);
}
lastShake = now;
}
lastX = x;
lastY = y;
lastZ = z;
lastUpdate = now;
}
}
// trigger change event
listener.onAccelerationChanged(x, y, z);
}

};

}

In the case of a SensorEvent triggered by a Sensor of type Sensor.TYPE_ACCELEROMETER, the event’s
values represents the acceleration of the phone given by a vector in a cartesian coordinate system. Landing on a
table, the values returned by the SensorEvent for the phone should be :

1. 0 m/s2 along x axis
2. 0 m/s2 along y axis
3. 9,80665 m/s2 along z axis

From an event to another, the coordinates of the acceleration vector are stored to detect suddent acceleration
changes and to trigger a shake event when the threshold is reached. Others events could be implemented such
as the detection of up and down gestures, circular gestures and lot more…

The custom AccelerometerManager can be use in any Activity or Service :



import android.app.Activity;
import android.os.Bundle;
import android.widget.TextView;
import android.widget.Toast;

/**
* Android accelerometer sensor tutorial
*/
public class Accelerometer extends Activity
implements AccelerometerListener {

private static Context CONTEXT;

/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
CONTEXT = this;
}

protected void onResume() {
super.onResume();
if (AccelerometerManager.isSupported()) {
AccelerometerManager.startListening(this);
}
}

protected void onDestroy() {
super.onDestroy();
if (AccelerometerManager.isListening()) {
AccelerometerManager.stopListening();
}

}

public static Context getContext() {
return CONTEXT;
}

/**
* onShake callback
*/
public void onShake(float force) {
Toast.makeText(this, "Phone shaked : " + force, 1000).show();
}

/**
* onAccelerationChanged callback
*/
public void onAccelerationChanged(float x, float y, float z) {
((TextView) findViewById(R.id.x)).setText(String.valueOf(x));
((TextView) findViewById(R.id.y)).setText(String.valueOf(y));
((TextView) findViewById(R.id.z)).setText(String.valueOf(z));
}

}


As usual, it is preferable to register listeners in the onResume() method of the Activity and removed in the
onFinish() method of the Activity.

Android Orientation Sensor tutorial
Posted by Tonio | Filed under Tutorial

Android phones includes an orientation sensor that is used to detect the orientation of the phone in space. The
orientation is given throught three values :

1. Azimtuh in degres
angle between the x axis of the phone and the north direction
0 ≤ azimuth ≤ 360
2. Pitch in degres
angle made by the y axis of the phone relatively to the phone’s horizontal position
-180 ≤ pitch ≤ 180
3. Roll in degres
angle made by the x axis of the phone relatively to the phone’s horizontal position
-90 ≤ roll ≤ 90

In this tutorial, we’ll see how to use the orientation sensor in an application in order to capture orientation
change events. We’ll use these events to build a custom listener that will trigger phone’s orientation change
events :

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();

}

An instance of the SensorManager is needed in order to retrieve informations about the supported sensors. No
permission is required to access the sensor service and to retrieve the list of available orientation sensors given
by the Sensor.TYPE_ORIENTATION constant. If at least one Sensor exists, it is possible to register a
SensorEventListener for a Sensor of the list. The delivering rate for the orientation sensor events can be
specified and must be one of these :

1. SensorManager.SENSOR_DELAY_FASTEST : as fast as possible
2. SensorManager.SENSOR_DELAY_GAME : rate suitable for game
3. SensorManager.SENSOR_DELAY_NORMAL : normal rate
4. SensorManager.SENSOR_DELAY_UI : rate suitable for UI Thread

The custom orientation manager is as follow :


import java.util.List;

import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;

/**
* Android Orientation Sensor Manager Archetype
*/
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() {
if (supported == null) {
if (Orientation.getContext() != null) {
sensorManager = (SensorManager) Orientation.getContext()
.getSystemService(Context.SENSOR_SERVICE);
Sensor.TYPE_ORIENTATION);
supported = new Boolean(sensors.size() > 0);
} else {
supported = Boolean.FALSE;
}
}
return supported;
}

/**
* Registers a listener and start listening
*/
OrientationListener orientationListener) {
sensorManager = (SensorManager) Orientation.getContext()
.getSystemService(Context.SENSOR_SERVICE);
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);
}

};

}

The custom OrientationManager can be use in any Activity or Service :


import android.app.Activity;
import android.os.Bundle;
import android.widget.TextView;
import android.widget.Toast;

/**


* Android orientation sensor tutorial
*/
public class Orientation extends Activity implements OrientationListener {

private static Context CONTEXT;

@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
CONTEXT = this;
}

protected void onResume() {
super.onResume();
if (OrientationManager.isSupported()) {
OrientationManager.startListening(this);
}
}

protected void onDestroy() {
super.onDestroy();
if (OrientationManager.isListening()) {
OrientationManager.stopListening();
}

}

public static Context getContext() {
return CONTEXT;
}

@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();
}

}

As usual, it is preferable to register listeners in the onResume() method of the Activity and removed in the
onFinish() method of the Activity.


Android accelerometer sensor tutorial

More Related Content

Similar to Android accelerometer sensor tutorial

More from info_zybotech

Recently uploaded

Android accelerometer sensor tutorial