SensorManager

see remapCoordinateSystem(float[], int, int, float[])

see remapCoordinateSystem(float[], int, int, float[])

see remapCoordinateSystem(float[], int, int, float[])

see remapCoordinateSystem(float[], int, int, float[])

see remapCoordinateSystem(float[], int, int, float[])

see remapCoordinateSystem(float[], int, int, float[])

Index of the X value in the array returned by onSensorChanged(int, float[])

Index of the Y value in the array returned by onSensorChanged(int, float[])

Index of the Z value in the array returned by onSensorChanged(int, float[])

Gravity (estimate) on the first Death Star in Empire units (m/s^2)

Earth's gravity in SI units (m/s^2)

Jupiter's gravity in SI units (m/s^2)

Mars' gravity in SI units (m/s^2)

Mercury's gravity in SI units (m/s^2)

The Moon's gravity in SI units (m/s^2)

Neptune's gravity in SI units (m/s^2)

Pluto's gravity in SI units (m/s^2)

Saturn's gravity in SI units (m/s^2)

Sun's gravity in SI units (m/s^2)

Gravity on the island

Uranus' gravity in SI units (m/s^2)

Venus' gravity in SI units (m/s^2)

luminance under a cloudy sky in lux

luminance at night with full moon in lux

luminance at night with no moon in lux

luminance under an overcast sky in lux

luminance in shade in lux

luminance of sunlight in lux

Maximum luminance of sunlight in lux

luminance at sunrise in lux

Maximum magnetic field on Earth's surface

Minimum magnetic field on Earth's surface

Standard atmosphere, or average sea-level pressure in hPa (millibar)

Offset to the untransformed values in the array returned by onSensorChanged(int, float[])

Index of the untransformed X value in the array returned by onSensorChanged(int, float[])

Index of the untransformed Y value in the array returned by onSensorChanged(int, float[])

Index of the untransformed Z value in the array returned by onSensorChanged(int, float[])

A constant describing an accelerometer. See SensorListener for more details.

A constant that includes all sensors

get sensor data as fast as possible

rate suitable for games

rate (default) suitable for screen orientation changes

rate suitable for the user interface

A constant describing an ambient light sensor See SensorListener for more details.

A constant describing a magnetic sensor See SensorListener for more details.

Largest sensor ID

Smallest sensor ID

A constant describing an orientation sensor. See SensorListener for more details.

A constant describing an orientation sensor. See SensorListener for more details.

A constant describing a proximity sensor See SensorListener for more details.

This sensor is reporting data with maximum accuracy

This sensor is reporting data with low accuracy, calibration with the environment is needed

This sensor is reporting data with an average level of accuracy, calibration with the environment may improve the readings

The values returned by this sensor cannot be trusted, calibration is needed or the environment doesn't allow readings

A constant describing a temperature sensor See SensorListener for more details.

A constant describing a Tricorder See SensorListener for more details.

Standard gravity (g) on Earth. This value is equivalent to 1G

Cancels receiving trigger events for a trigger sensor.

Note that a Trigger sensor will be auto disabled if onTrigger(TriggerEvent) has triggered. This method is provided in case the user wants to explicitly cancel the request to receive trigger events.

Flushes the batch FIFO of all the sensors registered for this listener. If there are events in the FIFO of the sensor, they are returned as if the batch timeout in the FIFO of the sensors had expired. Events are returned in the usual way through the SensorEventListener. This call doesn't affect the batch timeout for this sensor. This call is asynchronous and returns immediately. onFlushCompleted is called after all the events in the batch at the time of calling this method have been delivered successfully. If the hardware doesn't support flush, it still returns true and a trivial flush complete event is sent after the current event for all the clients registered for this sensor.

Computes the Altitude in meters from the atmospheric pressure and the pressure at sea level.

Typically the atmospheric pressure is read from a TYPE_PRESSURE sensor. The pressure at sea level must be known, usually it can be retrieved from airport databases in the vicinity. If unknown, you can use PRESSURE_STANDARD_ATMOSPHERE as an approximation, but absolute altitudes won't be accurate.

To calculate altitude differences, you must calculate the difference between the altitudes at both points. If you don't know the altitude as sea level, you can use PRESSURE_STANDARD_ATMOSPHERE instead, which will give good results considering the range of pressure typically involved.

float altitude_difference = getAltitude(SensorManager.PRESSURE_STANDARD_ATMOSPHERE, pressure_at_point2) - getAltitude(SensorManager.PRESSURE_STANDARD_ATMOSPHERE, pressure_at_point1);

Helper function to compute the angle change between two rotation matrices. Given a current rotation matrix (R) and a previous rotation matrix (prevR) computes the rotation around the z,x, and y axes which transforms prevR to R. outputs a 3 element vector containing the z,x, and y angle change at indexes 0, 1, and 2 respectively.

Each input matrix is either as a 3x3 or 4x4 row-major matrix depending on the length of the passed array:

If the array length is 9, then the array elements represent this matrix

   /  R[ 0]   R[ 1]   R[ 2]   \
   |  R[ 3]   R[ 4]   R[ 5]   |
   \  R[ 6]   R[ 7]   R[ 8]   /

If the array length is 16, then the array elements represent this matrix

   /  R[ 0]   R[ 1]   R[ 2]   R[ 3]  \
   |  R[ 4]   R[ 5]   R[ 6]   R[ 7]  |
   |  R[ 8]   R[ 9]   R[10]   R[11]  |
   \  R[12]   R[13]   R[14]   R[15]  /

Use this method to get the default sensor for a given type. Note that the returned sensor could be a composite sensor, and its data could be averaged or filtered. If you need to access the raw sensors use getSensorList.

Computes the geomagnetic inclination angle in radians from the inclination matrix I returned by getRotationMatrix(float[], float[], float[], float[]).

Computes the device's orientation based on the rotation matrix.

When it returns, the array values is filled with the result:

• values[0]: azimuth, rotation around the Z axis.
• values[1]: pitch, rotation around the X axis.
• values[2]: roll, rotation around the Y axis.

The reference coordinate-system used is different from the world coordinate-system defined for the rotation matrix:

• X is defined as the vector product Y.Z (It is tangential to the ground at the device's current location and roughly points West).
• Y is tangential to the ground at the device's current location and points towards the magnetic North Pole.
• Z points towards the center of the Earth and is perpendicular to the ground.

All three angles above are in radians and positive in the counter-clockwise direction.

Helper function to convert a rotation vector to a normalized quaternion. Given a rotation vector (presumably from a ROTATION_VECTOR sensor), returns a normalized quaternion in the array Q. The quaternion is stored as [w, x, y, z]

Computes the inclination matrix I as well as the rotation matrix R transforming a vector from the device coordinate system to the world's coordinate system which is defined as a direct orthonormal basis, where:

• X is defined as the vector product Y.Z (It is tangential to the ground at the device's current location and roughly points East).
• Y is tangential to the ground at the device's current location and points towards the magnetic North Pole.
• Z points towards the sky and is perpendicular to the ground.

By definition:

[0 0 g] = R * gravity (g = magnitude of gravity)

[0 m 0] = I * R * geomagnetic (m = magnitude of geomagnetic field)

R is the identity matrix when the device is aligned with the world's coordinate system, that is, when the device's X axis points toward East, the Y axis points to the North Pole and the device is facing the sky.

I is a rotation matrix transforming the geomagnetic vector into the same coordinate space as gravity (the world's coordinate space). I is a simple rotation around the X axis. The inclination angle in radians can be computed with getInclination(float[]).

Each matrix is returned either as a 3x3 or 4x4 row-major matrix depending on the length of the passed array:

If the array length is 16:

   /  M[ 0]   M[ 1]   M[ 2]   M[ 3]  \
   |  M[ 4]   M[ 5]   M[ 6]   M[ 7]  |
   |  M[ 8]   M[ 9]   M[10]   M[11]  |
   \  M[12]   M[13]   M[14]   M[15]  /

Note that because OpenGL matrices are column-major matrices you must transpose the matrix before using it. However, since the matrix is a rotation matrix, its transpose is also its inverse, conveniently, it is often the inverse of the rotation that is needed for rendering; it can therefore be used with OpenGL ES directly.

Also note that the returned matrices always have this form:

   /  M[ 0]   M[ 1]   M[ 2]   0  \
   |  M[ 4]   M[ 5]   M[ 6]   0  |
   |  M[ 8]   M[ 9]   M[10]   0  |
   \      0       0       0   1  /

If the array length is 9:

   /  M[ 0]   M[ 1]   M[ 2]  \
   |  M[ 3]   M[ 4]   M[ 5]  |
   \  M[ 6]   M[ 7]   M[ 8]  /

The inverse of each matrix can be computed easily by taking its transpose.

The matrices returned by this function are meaningful only when the device is not free-falling and it is not close to the magnetic north. If the device is accelerating, or placed into a strong magnetic field, the returned matrices may be inaccurate.

Helper function to convert a rotation vector to a rotation matrix. Given a rotation vector (presumably from a ROTATION_VECTOR sensor), returns a 9 or 16 element rotation matrix in the array R. R must have length 9 or 16. If R.length == 9, the following matrix is returned:

   /  R[ 0]   R[ 1]   R[ 2]   \
   |  R[ 3]   R[ 4]   R[ 5]   |
   \  R[ 6]   R[ 7]   R[ 8]   /

   /  R[ 0]   R[ 1]   R[ 2]   0  \
   |  R[ 4]   R[ 5]   R[ 6]   0  |
   |  R[ 8]   R[ 9]   R[10]   0  |
   \  0       0       0       1  /

Use this method to get the list of available sensors of a certain type. Make multiple calls to get sensors of different types or use Sensor.TYPE_ALL to get all the sensors.

Registers a SensorListener for given sensors.

Registers a listener for given sensors.

Enables batch mode for a sensor with the given rate and maxBatchReportLatency. If the underlying hardware does not support batch mode, this defaults to registerListener(SensorEventListener, Sensor, int) and other parameters are ignored. In non-batch mode, all sensor events must be reported as soon as they are detected. While in batch mode, sensor events do not need to be reported as soon as they are detected. They can be temporarily stored in batches and reported in batches, as long as no event is delayed by more than "maxBatchReportLatency" microseconds. That is, all events since the previous batch are recorded and returned all at once. This allows to reduce the amount of interrupts sent to the SoC, and allows the SoC to switch to a lower power state (Idle) while the sensor is capturing and batching data.

Registering to a sensor in batch mode will not prevent the SoC from going to suspend mode. In this case, the sensor will continue to gather events and store it in a hardware FIFO. If the FIFO gets full before the AP wakes up again, some events will be lost, as the older events get overwritten by new events in the hardware FIFO. This can be avoided by holding a wake lock. If the application holds a wake lock, the SoC will not go to suspend mode, so no events will be lost, as the events will be reported before the FIFO gets full.

Batching is always best effort. If a different application requests updates in continuous mode, this application will also get events in continuous mode. Batch mode updates can be unregistered by calling unregisterListener(SensorEventListener).

Enables batch mode for a sensor with the given rate and maxBatchReportLatency.

Registers a SensorEventListener for the given sensor. Events are delivered in continuous mode as soon as they are available. To reduce the battery usage, use registerListener(SensorEventListener, Sensor, int, int) which enables batch mode for the sensor.

Registers a SensorEventListener for the given sensor.

Rotates the supplied rotation matrix so it is expressed in a different coordinate system. This is typically used when an application needs to compute the three orientation angles of the device (see getOrientation(float[], float[])) in a different coordinate system.

When the rotation matrix is used for drawing (for instance with OpenGL ES), it usually doesn't need to be transformed by this function, unless the screen is physically rotated, in which case you can use Display.getRotation() to retrieve the current rotation of the screen. Note that because the user is generally free to rotate their screen, you often should consider the rotation in deciding the parameters to use here.

Examples:

• Using the camera (Y axis along the camera's axis) for an augmented reality application where the rotation angles are needed:
remapCoordinateSystem(inR, AXIS_X, AXIS_Z, outR);
• Using the device as a mechanical compass when rotation is Surface.ROTATION_90:
remapCoordinateSystem(inR, AXIS_Y, AXIS_MINUS_X, outR);
Beware of the above example. This call is needed only to account for a rotation from its natural orientation when calculating the rotation angles (see getOrientation(float[], float[])). If the rotation matrix is also used for rendering, it may not need to be transformed, for instance if your Activity is running in landscape mode.

Since the resulting coordinate system is orthonormal, only two axes need to be specified.

Requests receiving trigger events for a trigger sensor.

When the sensor detects a trigger event condition, such as significant motion in the case of the TYPE_SIGNIFICANT_MOTION, the provided trigger listener will be invoked once and then its request to receive trigger events will be canceled. To continue receiving trigger events, the application must request to receive trigger events again.

Unregisters a listener for all sensors.

Unregisters a listener for the sensors with which it is registered.

Unregisters a listener for the sensors with which it is registered.

Unregisters a listener for all sensors.