Merge changes from topic "equalizer_1" am: 1ba697e29b
am: 46f2249f46
Change-Id: Icd3c715dfed772d05b8314a394aad2725a9937e0
This commit is contained in:
@@ -204,7 +204,7 @@ final class LegacySensorManager {
|
||||
}
|
||||
|
||||
private static final class LegacyListener implements SensorEventListener {
|
||||
private float mValues[] = new float[6];
|
||||
private float[] mValues = new float[6];
|
||||
private SensorListener mTarget;
|
||||
private int mSensors;
|
||||
private final LmsFilter mYawfilter = new LmsFilter();
|
||||
@@ -256,7 +256,7 @@ final class LegacySensorManager {
|
||||
}
|
||||
|
||||
public void onSensorChanged(SensorEvent event) {
|
||||
final float v[] = mValues;
|
||||
final float[] v = mValues;
|
||||
v[0] = event.values[0];
|
||||
v[1] = event.values[1];
|
||||
v[2] = event.values[2];
|
||||
@@ -264,10 +264,10 @@ final class LegacySensorManager {
|
||||
int legacyType = getLegacySensorType(type);
|
||||
mapSensorDataToWindow(legacyType, v, LegacySensorManager.getRotation());
|
||||
if (type == Sensor.TYPE_ORIENTATION) {
|
||||
if ((mSensors & SensorManager.SENSOR_ORIENTATION_RAW)!=0) {
|
||||
if ((mSensors & SensorManager.SENSOR_ORIENTATION_RAW) != 0) {
|
||||
mTarget.onSensorChanged(SensorManager.SENSOR_ORIENTATION_RAW, v);
|
||||
}
|
||||
if ((mSensors & SensorManager.SENSOR_ORIENTATION)!=0) {
|
||||
if ((mSensors & SensorManager.SENSOR_ORIENTATION) != 0) {
|
||||
v[0] = mYawfilter.filter(event.timestamp, v[0]);
|
||||
mTarget.onSensorChanged(SensorManager.SENSOR_ORIENTATION, v);
|
||||
}
|
||||
@@ -317,7 +317,7 @@ final class LegacySensorManager {
|
||||
switch (sensor) {
|
||||
case SensorManager.SENSOR_ACCELEROMETER:
|
||||
case SensorManager.SENSOR_MAGNETIC_FIELD:
|
||||
values[0] =-y;
|
||||
values[0] = -y;
|
||||
values[1] = x;
|
||||
values[2] = z;
|
||||
break;
|
||||
@@ -337,15 +337,15 @@ final class LegacySensorManager {
|
||||
switch (sensor) {
|
||||
case SensorManager.SENSOR_ACCELEROMETER:
|
||||
case SensorManager.SENSOR_MAGNETIC_FIELD:
|
||||
values[0] =-x;
|
||||
values[1] =-y;
|
||||
values[0] = -x;
|
||||
values[1] = -y;
|
||||
values[2] = z;
|
||||
break;
|
||||
case SensorManager.SENSOR_ORIENTATION:
|
||||
case SensorManager.SENSOR_ORIENTATION_RAW:
|
||||
values[0] = (x >= 180) ? (x - 180) : (x + 180);
|
||||
values[1] =-y;
|
||||
values[2] =-z;
|
||||
values[1] = -y;
|
||||
values[2] = -z;
|
||||
break;
|
||||
}
|
||||
}
|
||||
@@ -369,10 +369,11 @@ final class LegacySensorManager {
|
||||
private static final class LmsFilter {
|
||||
private static final int SENSORS_RATE_MS = 20;
|
||||
private static final int COUNT = 12;
|
||||
private static final float PREDICTION_RATIO = 1.0f/3.0f;
|
||||
private static final float PREDICTION_TIME = (SENSORS_RATE_MS*COUNT/1000.0f)*PREDICTION_RATIO;
|
||||
private float mV[] = new float[COUNT*2];
|
||||
private long mT[] = new long[COUNT*2];
|
||||
private static final float PREDICTION_RATIO = 1.0f / 3.0f;
|
||||
private static final float PREDICTION_TIME =
|
||||
(SENSORS_RATE_MS * COUNT / 1000.0f) * PREDICTION_RATIO;
|
||||
private float[] mV = new float[COUNT * 2];
|
||||
private long[] mT = new long[COUNT * 2];
|
||||
private int mIndex;
|
||||
|
||||
public LmsFilter() {
|
||||
@@ -383,9 +384,9 @@ final class LegacySensorManager {
|
||||
float v = in;
|
||||
final float ns = 1.0f / 1000000000.0f;
|
||||
float v1 = mV[mIndex];
|
||||
if ((v-v1) > 180) {
|
||||
if ((v - v1) > 180) {
|
||||
v -= 360;
|
||||
} else if ((v1-v) > 180) {
|
||||
} else if ((v1 - v) > 180) {
|
||||
v += 360;
|
||||
}
|
||||
/* Manage the circular buffer, we write the data twice spaced
|
||||
@@ -393,40 +394,43 @@ final class LegacySensorManager {
|
||||
* when it's full
|
||||
*/
|
||||
mIndex++;
|
||||
if (mIndex >= COUNT*2)
|
||||
if (mIndex >= COUNT * 2) {
|
||||
mIndex = COUNT;
|
||||
}
|
||||
mV[mIndex] = v;
|
||||
mT[mIndex] = time;
|
||||
mV[mIndex-COUNT] = v;
|
||||
mT[mIndex-COUNT] = time;
|
||||
mV[mIndex - COUNT] = v;
|
||||
mT[mIndex - COUNT] = time;
|
||||
|
||||
float A, B, C, D, E;
|
||||
float a, b;
|
||||
int i;
|
||||
|
||||
A = B = C = D = E = 0;
|
||||
for (i=0 ; i<COUNT-1 ; i++) {
|
||||
for (i = 0; i < COUNT - 1; i++) {
|
||||
final int j = mIndex - 1 - i;
|
||||
final float Z = mV[j];
|
||||
final float T = (mT[j]/2 + mT[j+1]/2 - time)*ns;
|
||||
float dT = (mT[j] - mT[j+1])*ns;
|
||||
final float T = (mT[j] / 2 + mT[j + 1] / 2 - time) * ns;
|
||||
float dT = (mT[j] - mT[j + 1]) * ns;
|
||||
dT *= dT;
|
||||
A += Z*dT;
|
||||
B += T*(T*dT);
|
||||
C += (T*dT);
|
||||
D += Z*(T*dT);
|
||||
A += Z * dT;
|
||||
B += T * (T * dT);
|
||||
C += (T * dT);
|
||||
D += Z * (T * dT);
|
||||
E += dT;
|
||||
}
|
||||
b = (A*B + C*D) / (E*B + C*C);
|
||||
a = (E*b - A) / C;
|
||||
float f = b + PREDICTION_TIME*a;
|
||||
b = (A * B + C * D) / (E * B + C * C);
|
||||
a = (E * b - A) / C;
|
||||
float f = b + PREDICTION_TIME * a;
|
||||
|
||||
// Normalize
|
||||
f *= (1.0f / 360.0f);
|
||||
if (((f>=0)?f:-f) >= 0.5f)
|
||||
f = f - (float)Math.ceil(f + 0.5f) + 1.0f;
|
||||
if (f < 0)
|
||||
if (((f >= 0) ? f : -f) >= 0.5f) {
|
||||
f = f - (float) Math.ceil(f + 0.5f) + 1.0f;
|
||||
}
|
||||
if (f < 0) {
|
||||
f += 1.0f;
|
||||
}
|
||||
f *= 360.0f;
|
||||
return f;
|
||||
}
|
||||
|
||||
@@ -794,12 +794,12 @@ public final class Sensor {
|
||||
1, // SENSOR_TYPE_PICK_UP_GESTURE
|
||||
1, // SENSOR_TYPE_WRIST_TILT_GESTURE
|
||||
1, // SENSOR_TYPE_DEVICE_ORIENTATION
|
||||
16,// SENSOR_TYPE_POSE_6DOF
|
||||
16, // SENSOR_TYPE_POSE_6DOF
|
||||
1, // SENSOR_TYPE_STATIONARY_DETECT
|
||||
1, // SENSOR_TYPE_MOTION_DETECT
|
||||
1, // SENSOR_TYPE_HEART_BEAT
|
||||
2, // SENSOR_TYPE_DYNAMIC_SENSOR_META
|
||||
16,// skip over additional sensor info type
|
||||
16, // skip over additional sensor info type
|
||||
1, // SENSOR_TYPE_LOW_LATENCY_OFFBODY_DETECT
|
||||
6, // SENSOR_TYPE_ACCELEROMETER_UNCALIBRATED
|
||||
};
|
||||
@@ -857,8 +857,8 @@ public final class Sensor {
|
||||
static int getMaxLengthValuesArray(Sensor sensor, int sdkLevel) {
|
||||
// RotationVector length has changed to 3 to 5 for API level 18
|
||||
// Set it to 3 for backward compatibility.
|
||||
if (sensor.mType == Sensor.TYPE_ROTATION_VECTOR &&
|
||||
sdkLevel <= Build.VERSION_CODES.JELLY_BEAN_MR1) {
|
||||
if (sensor.mType == Sensor.TYPE_ROTATION_VECTOR
|
||||
&& sdkLevel <= Build.VERSION_CODES.JELLY_BEAN_MR1) {
|
||||
return 3;
|
||||
}
|
||||
int offset = sensor.mType;
|
||||
@@ -1033,9 +1033,9 @@ public final class Sensor {
|
||||
* Returns true if the sensor is a wake-up sensor.
|
||||
* <p>
|
||||
* <b>Application Processor Power modes</b> <p>
|
||||
* Application Processor(AP), is the processor on which applications run. When no wake lock is held
|
||||
* and the user is not interacting with the device, this processor can enter a “Suspend” mode,
|
||||
* reducing the power consumption by 10 times or more.
|
||||
* Application Processor(AP), is the processor on which applications run. When no wake lock is
|
||||
* held and the user is not interacting with the device, this processor can enter a “Suspend”
|
||||
* mode, reducing the power consumption by 10 times or more.
|
||||
* </p>
|
||||
* <p>
|
||||
* <b>Non-wake-up sensors</b> <p>
|
||||
@@ -1232,6 +1232,6 @@ public final class Sensor {
|
||||
*/
|
||||
private void setUuid(long msb, long lsb) {
|
||||
// TODO(b/29547335): Rename this method to setId.
|
||||
mId = (int)msb;
|
||||
mId = (int) msb;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -200,7 +200,7 @@ public class SensorAdditionalInfo {
|
||||
public static final int TYPE_DEBUG_INFO = 0x40000000;
|
||||
|
||||
SensorAdditionalInfo(
|
||||
Sensor aSensor, int aType, int aSerial, int [] aIntValues, float [] aFloatValues) {
|
||||
Sensor aSensor, int aType, int aSerial, int[] aIntValues, float[] aFloatValues) {
|
||||
sensor = aSensor;
|
||||
type = aType;
|
||||
serial = aSerial;
|
||||
@@ -222,10 +222,10 @@ public class SensorAdditionalInfo {
|
||||
null, new float[] { strength, declination, inclination});
|
||||
}
|
||||
/** @hide */
|
||||
public static SensorAdditionalInfo createCustomInfo(Sensor aSensor, int type, float [] data) {
|
||||
public static SensorAdditionalInfo createCustomInfo(Sensor aSensor, int type, float[] data) {
|
||||
if (type < TYPE_CUSTOM_INFO || type >= TYPE_DEBUG_INFO || aSensor == null) {
|
||||
throw new IllegalArgumentException("invalid parameter(s): type: " + type +
|
||||
"; sensor: " + aSensor);
|
||||
throw new IllegalArgumentException(
|
||||
"invalid parameter(s): type: " + type + "; sensor: " + aSensor);
|
||||
}
|
||||
|
||||
return new SensorAdditionalInfo(aSensor, type, 0, null, data);
|
||||
|
||||
@@ -207,8 +207,8 @@ public class SensorEvent {
|
||||
* timestamp = event.timestamp;
|
||||
* float[] deltaRotationMatrix = new float[9];
|
||||
* SensorManager.getRotationMatrixFromVector(deltaRotationMatrix, deltaRotationVector);
|
||||
* // User code should concatenate the delta rotation we computed with the current rotation
|
||||
* // in order to get the updated rotation.
|
||||
* // User code should concatenate the delta rotation we computed with the current
|
||||
* // rotation in order to get the updated rotation.
|
||||
* // rotationCurrent = rotationCurrent * deltaRotationMatrix;
|
||||
* }
|
||||
* </pre>
|
||||
@@ -244,21 +244,22 @@ public class SensorEvent {
|
||||
* <h4>{@link android.hardware.Sensor#TYPE_GRAVITY Sensor.TYPE_GRAVITY}:</h4>
|
||||
* <p>A three dimensional vector indicating the direction and magnitude of gravity. Units
|
||||
* are m/s^2. The coordinate system is the same as is used by the acceleration sensor.</p>
|
||||
* <p><b>Note:</b> When the device is at rest, the output of the gravity sensor should be identical
|
||||
* to that of the accelerometer.</p>
|
||||
* <p><b>Note:</b> When the device is at rest, the output of the gravity sensor should be
|
||||
* identical to that of the accelerometer.</p>
|
||||
*
|
||||
* <h4>{@link android.hardware.Sensor#TYPE_LINEAR_ACCELERATION Sensor.TYPE_LINEAR_ACCELERATION}:</h4>
|
||||
* A three dimensional vector indicating acceleration along each device axis, not including
|
||||
* gravity. All values have units of m/s^2. The coordinate system is the same as is used by the
|
||||
* acceleration sensor.
|
||||
* <h4>
|
||||
* {@link android.hardware.Sensor#TYPE_LINEAR_ACCELERATION Sensor.TYPE_LINEAR_ACCELERATION}:
|
||||
* </h4> A three dimensional vector indicating acceleration along each device axis, not
|
||||
* including gravity. All values have units of m/s^2. The coordinate system is the same as is
|
||||
* used by the acceleration sensor.
|
||||
* <p>The output of the accelerometer, gravity and linear-acceleration sensors must obey the
|
||||
* following relation:</p>
|
||||
* <p><ul>acceleration = gravity + linear-acceleration</ul></p>
|
||||
* <p><ul>acceleration = gravity + linear-acceleration</ul></p>
|
||||
*
|
||||
* <h4>{@link android.hardware.Sensor#TYPE_ROTATION_VECTOR Sensor.TYPE_ROTATION_VECTOR}:</h4>
|
||||
* <p>The rotation vector represents the orientation of the device as a combination of an <i>angle</i>
|
||||
* and an <i>axis</i>, in which the device has rotated through an angle θ around an axis
|
||||
* <x, y, z>.</p>
|
||||
* <p>The rotation vector represents the orientation of the device as a combination of an
|
||||
* <i>angle</i> and an <i>axis</i>, in which the device has rotated through an angle θ
|
||||
* around an axis <x, y, z>.</p>
|
||||
* <p>The three elements of the rotation vector are
|
||||
* <x*sin(θ/2), y*sin(θ/2), z*sin(θ/2)>, such that the magnitude of the rotation
|
||||
* vector is equal to sin(θ/2), and the direction of the rotation vector is equal to the
|
||||
|
||||
@@ -19,8 +19,8 @@ package android.hardware;
|
||||
/**
|
||||
* Used for receiving notifications from the SensorManager when
|
||||
* sensor values have changed.
|
||||
*
|
||||
* @deprecated Use
|
||||
*
|
||||
* @deprecated Use
|
||||
* {@link android.hardware.SensorEventListener SensorEventListener} instead.
|
||||
*/
|
||||
@Deprecated
|
||||
@@ -36,7 +36,7 @@ public interface SensorListener {
|
||||
* <p><u>Definition of the coordinate system used below.</u><p>
|
||||
* <p>The X axis refers to the screen's horizontal axis
|
||||
* (the small edge in portrait mode, the long edge in landscape mode) and
|
||||
* points to the right.
|
||||
* points to the right.
|
||||
* <p>The Y axis refers to the screen's vertical axis and points towards
|
||||
* the top of the screen (the origin is in the lower-left corner).
|
||||
* <p>The Z axis points toward the sky when the device is lying on its back
|
||||
@@ -44,18 +44,18 @@ public interface SensorListener {
|
||||
* <p> <b>IMPORTANT NOTE:</b> The axis <b><u>are swapped</u></b> when the
|
||||
* device's screen orientation changes. To access the unswapped values,
|
||||
* use indices 3, 4 and 5 in values[].
|
||||
*
|
||||
*
|
||||
* <p>{@link android.hardware.SensorManager#SENSOR_ORIENTATION SENSOR_ORIENTATION},
|
||||
* {@link android.hardware.SensorManager#SENSOR_ORIENTATION_RAW SENSOR_ORIENTATION_RAW}:<p>
|
||||
* All values are angles in degrees.
|
||||
*
|
||||
*
|
||||
* <p>values[0]: Azimuth, rotation around the Z axis (0<=azimuth<360).
|
||||
* 0 = North, 90 = East, 180 = South, 270 = West
|
||||
*
|
||||
*
|
||||
* <p>values[1]: Pitch, rotation around X axis (-180<=pitch<=180), with positive
|
||||
* values when the z-axis moves toward the y-axis.
|
||||
*
|
||||
* <p>values[2]: Roll, rotation around Y axis (-90<=roll<=90), with positive values
|
||||
* <p>values[2]: Roll, rotation around Y axis (-90<=roll<=90), with positive values
|
||||
* when the z-axis moves toward the x-axis.
|
||||
*
|
||||
* <p>Note that this definition of yaw, pitch and roll is different from the
|
||||
@@ -64,17 +64,17 @@ public interface SensorListener {
|
||||
*
|
||||
* <p>{@link android.hardware.SensorManager#SENSOR_ACCELEROMETER SENSOR_ACCELEROMETER}:<p>
|
||||
* All values are in SI units (m/s^2) and measure contact forces.
|
||||
*
|
||||
* <p>values[0]: force applied by the device on the x-axis
|
||||
* <p>values[1]: force applied by the device on the y-axis
|
||||
*
|
||||
* <p>values[0]: force applied by the device on the x-axis
|
||||
* <p>values[1]: force applied by the device on the y-axis
|
||||
* <p>values[2]: force applied by the device on the z-axis
|
||||
*
|
||||
*
|
||||
* <p><u>Examples</u>:
|
||||
* <li>When the device is pushed on its left side toward the right, the
|
||||
* x acceleration value is negative (the device applies a reaction force
|
||||
* to the push toward the left)</li>
|
||||
*
|
||||
* <li>When the device lies flat on a table, the acceleration value is
|
||||
*
|
||||
* <li>When the device lies flat on a table, the acceleration value is
|
||||
* {@link android.hardware.SensorManager#STANDARD_GRAVITY -STANDARD_GRAVITY},
|
||||
* which correspond to the force the device applies on the table in reaction
|
||||
* to gravity.</li>
|
||||
@@ -83,7 +83,7 @@ public interface SensorListener {
|
||||
* All values are in micro-Tesla (uT) and measure the ambient magnetic
|
||||
* field in the X, Y and -Z axis.
|
||||
* <p><b><u>Note:</u></b> the magnetic field's Z axis is inverted.
|
||||
*
|
||||
*
|
||||
* @param sensor The ID of the sensor being monitored
|
||||
* @param values The new values for the sensor.
|
||||
*/
|
||||
@@ -97,5 +97,5 @@ public interface SensorListener {
|
||||
* @param sensor The ID of the sensor being monitored
|
||||
* @param accuracy The new accuracy of this sensor.
|
||||
*/
|
||||
public void onAccuracyChanged(int sensor, int accuracy);
|
||||
public void onAccuracyChanged(int sensor, int accuracy);
|
||||
}
|
||||
|
||||
@@ -83,7 +83,7 @@ public abstract class SensorManager {
|
||||
/** @hide */
|
||||
protected static final String TAG = "SensorManager";
|
||||
|
||||
private static final float[] mTempMatrix = new float[16];
|
||||
private static final float[] sTempMatrix = new float[16];
|
||||
|
||||
// Cached lists of sensors by type. Guarded by mSensorListByType.
|
||||
private final SparseArray<List<Sensor>> mSensorListByType =
|
||||
@@ -188,7 +188,7 @@ public abstract class SensorManager {
|
||||
* @deprecated use {@link android.hardware.Sensor Sensor} instead.
|
||||
*/
|
||||
@Deprecated
|
||||
public static final int SENSOR_MAX = ((SENSOR_ALL + 1)>>1);
|
||||
public static final int SENSOR_MAX = ((SENSOR_ALL + 1) >> 1);
|
||||
|
||||
|
||||
/**
|
||||
@@ -425,8 +425,9 @@ public abstract class SensorManager {
|
||||
} else {
|
||||
list = new ArrayList<Sensor>();
|
||||
for (Sensor i : fullList) {
|
||||
if (i.getType() == type)
|
||||
if (i.getType() == type) {
|
||||
list.add(i);
|
||||
}
|
||||
}
|
||||
}
|
||||
list = Collections.unmodifiableList(list);
|
||||
@@ -461,8 +462,9 @@ public abstract class SensorManager {
|
||||
} else {
|
||||
List<Sensor> list = new ArrayList();
|
||||
for (Sensor i : fullList) {
|
||||
if (i.getType() == type)
|
||||
if (i.getType() == type) {
|
||||
list.add(i);
|
||||
}
|
||||
}
|
||||
return Collections.unmodifiableList(list);
|
||||
}
|
||||
@@ -490,10 +492,11 @@ public abstract class SensorManager {
|
||||
// For the following sensor types, return a wake-up sensor. These types are by default
|
||||
// defined as wake-up sensors. For the rest of the SDK defined sensor types return a
|
||||
// non_wake-up version.
|
||||
if (type == Sensor.TYPE_PROXIMITY || type == Sensor.TYPE_SIGNIFICANT_MOTION ||
|
||||
type == Sensor.TYPE_TILT_DETECTOR || type == Sensor.TYPE_WAKE_GESTURE ||
|
||||
type == Sensor.TYPE_GLANCE_GESTURE || type == Sensor.TYPE_PICK_UP_GESTURE ||
|
||||
type == Sensor.TYPE_WRIST_TILT_GESTURE || type == Sensor.TYPE_DYNAMIC_SENSOR_META) {
|
||||
if (type == Sensor.TYPE_PROXIMITY || type == Sensor.TYPE_SIGNIFICANT_MOTION
|
||||
|| type == Sensor.TYPE_TILT_DETECTOR || type == Sensor.TYPE_WAKE_GESTURE
|
||||
|| type == Sensor.TYPE_GLANCE_GESTURE || type == Sensor.TYPE_PICK_UP_GESTURE
|
||||
|| type == Sensor.TYPE_WRIST_TILT_GESTURE
|
||||
|| type == Sensor.TYPE_DYNAMIC_SENSOR_META) {
|
||||
wakeUpSensor = true;
|
||||
}
|
||||
|
||||
@@ -509,12 +512,12 @@ public abstract class SensorManager {
|
||||
* <p>
|
||||
* For example,
|
||||
* <ul>
|
||||
* <li>getDefaultSensor({@link Sensor#TYPE_ACCELEROMETER}, true) returns a wake-up accelerometer
|
||||
* sensor if it exists. </li>
|
||||
* <li>getDefaultSensor({@link Sensor#TYPE_PROXIMITY}, false) returns a non wake-up proximity
|
||||
* sensor if it exists. </li>
|
||||
* <li>getDefaultSensor({@link Sensor#TYPE_PROXIMITY}, true) returns a wake-up proximity sensor
|
||||
* which is the same as the Sensor returned by {@link #getDefaultSensor(int)}. </li>
|
||||
* <li>getDefaultSensor({@link Sensor#TYPE_ACCELEROMETER}, true) returns a wake-up
|
||||
* accelerometer sensor if it exists. </li>
|
||||
* <li>getDefaultSensor({@link Sensor#TYPE_PROXIMITY}, false) returns a non wake-up
|
||||
* proximity sensor if it exists. </li>
|
||||
* <li>getDefaultSensor({@link Sensor#TYPE_PROXIMITY}, true) returns a wake-up proximity
|
||||
* sensor which is the same as the Sensor returned by {@link #getDefaultSensor(int)}. </li>
|
||||
* </ul>
|
||||
* </p>
|
||||
* <p class="note">
|
||||
@@ -532,8 +535,9 @@ public abstract class SensorManager {
|
||||
public Sensor getDefaultSensor(int type, boolean wakeUp) {
|
||||
List<Sensor> l = getSensorList(type);
|
||||
for (Sensor sensor : l) {
|
||||
if (sensor.isWakeUpSensor() == wakeUp)
|
||||
if (sensor.isWakeUpSensor() == wakeUp) {
|
||||
return sensor;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
@@ -842,8 +846,8 @@ public abstract class SensorManager {
|
||||
* @return <code>true</code> if the sensor is supported and successfully enabled.
|
||||
* @see #registerListener(SensorEventListener, Sensor, int, int)
|
||||
*/
|
||||
public boolean registerListener(SensorEventListener listener, Sensor sensor, int samplingPeriodUs,
|
||||
int maxReportLatencyUs, Handler handler) {
|
||||
public boolean registerListener(SensorEventListener listener, Sensor sensor,
|
||||
int samplingPeriodUs, int maxReportLatencyUs, Handler handler) {
|
||||
int delayUs = getDelay(samplingPeriodUs);
|
||||
return registerListenerImpl(listener, sensor, delayUs, handler, maxReportLatencyUs, 0);
|
||||
}
|
||||
@@ -953,7 +957,7 @@ public abstract class SensorManager {
|
||||
* Used for receiving notifications from the SensorManager when dynamic sensors are connected or
|
||||
* disconnected.
|
||||
*/
|
||||
public static abstract class DynamicSensorCallback {
|
||||
public abstract static class DynamicSensorCallback {
|
||||
/**
|
||||
* Called when there is a dynamic sensor being connected to the system.
|
||||
*
|
||||
@@ -1180,7 +1184,7 @@ public abstract class SensorManager {
|
||||
float Ay = gravity[1];
|
||||
float Az = gravity[2];
|
||||
|
||||
final float normsqA = (Ax*Ax + Ay*Ay + Az*Az);
|
||||
final float normsqA = (Ax * Ax + Ay * Ay + Az * Az);
|
||||
final float g = 9.81f;
|
||||
final float freeFallGravitySquared = 0.01f * g * g;
|
||||
if (normsqA < freeFallGravitySquared) {
|
||||
@@ -1191,10 +1195,10 @@ public abstract class SensorManager {
|
||||
final float Ex = geomagnetic[0];
|
||||
final float Ey = geomagnetic[1];
|
||||
final float Ez = geomagnetic[2];
|
||||
float Hx = Ey*Az - Ez*Ay;
|
||||
float Hy = Ez*Ax - Ex*Az;
|
||||
float Hz = Ex*Ay - Ey*Ax;
|
||||
final float normH = (float)Math.sqrt(Hx*Hx + Hy*Hy + Hz*Hz);
|
||||
float Hx = Ey * Az - Ez * Ay;
|
||||
float Hy = Ez * Ax - Ex * Az;
|
||||
float Hz = Ex * Ay - Ey * Ax;
|
||||
final float normH = (float) Math.sqrt(Hx * Hx + Hy * Hy + Hz * Hz);
|
||||
|
||||
if (normH < 0.1f) {
|
||||
// device is close to free fall (or in space?), or close to
|
||||
@@ -1205,13 +1209,13 @@ public abstract class SensorManager {
|
||||
Hx *= invH;
|
||||
Hy *= invH;
|
||||
Hz *= invH;
|
||||
final float invA = 1.0f / (float)Math.sqrt(Ax*Ax + Ay*Ay + Az*Az);
|
||||
final float invA = 1.0f / (float) Math.sqrt(Ax * Ax + Ay * Ay + Az * Az);
|
||||
Ax *= invA;
|
||||
Ay *= invA;
|
||||
Az *= invA;
|
||||
final float Mx = Ay*Hz - Az*Hy;
|
||||
final float My = Az*Hx - Ax*Hz;
|
||||
final float Mz = Ax*Hy - Ay*Hx;
|
||||
final float Mx = Ay * Hz - Az * Hy;
|
||||
final float My = Az * Hx - Ax * Hz;
|
||||
final float Mz = Ax * Hy - Ay * Hx;
|
||||
if (R != null) {
|
||||
if (R.length == 9) {
|
||||
R[0] = Hx; R[1] = Hy; R[2] = Hz;
|
||||
@@ -1228,17 +1232,17 @@ public abstract class SensorManager {
|
||||
// compute the inclination matrix by projecting the geomagnetic
|
||||
// vector onto the Z (gravity) and X (horizontal component
|
||||
// of geomagnetic vector) axes.
|
||||
final float invE = 1.0f / (float)Math.sqrt(Ex*Ex + Ey*Ey + Ez*Ez);
|
||||
final float c = (Ex*Mx + Ey*My + Ez*Mz) * invE;
|
||||
final float s = (Ex*Ax + Ey*Ay + Ez*Az) * invE;
|
||||
final float invE = 1.0f / (float) Math.sqrt(Ex * Ex + Ey * Ey + Ez * Ez);
|
||||
final float c = (Ex * Mx + Ey * My + Ez * Mz) * invE;
|
||||
final float s = (Ex * Ax + Ey * Ay + Ez * Az) * invE;
|
||||
if (I.length == 9) {
|
||||
I[0] = 1; I[1] = 0; I[2] = 0;
|
||||
I[3] = 0; I[4] = c; I[5] = s;
|
||||
I[6] = 0; I[7] =-s; I[8] = c;
|
||||
I[6] = 0; I[7] = -s; I[8] = c;
|
||||
} else if (I.length == 16) {
|
||||
I[0] = 1; I[1] = 0; I[2] = 0;
|
||||
I[4] = 0; I[5] = c; I[6] = s;
|
||||
I[8] = 0; I[9] =-s; I[10]= c;
|
||||
I[8] = 0; I[9] = -s; I[10] = c;
|
||||
I[3] = I[7] = I[11] = I[12] = I[13] = I[14] = 0;
|
||||
I[15] = 1;
|
||||
}
|
||||
@@ -1262,9 +1266,9 @@ public abstract class SensorManager {
|
||||
*/
|
||||
public static float getInclination(float[] I) {
|
||||
if (I.length == 9) {
|
||||
return (float)Math.atan2(I[5], I[4]);
|
||||
return (float) Math.atan2(I[5], I[4]);
|
||||
} else {
|
||||
return (float)Math.atan2(I[6], I[5]);
|
||||
return (float) Math.atan2(I[6], I[5]);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1343,17 +1347,16 @@ public abstract class SensorManager {
|
||||
* @see #getRotationMatrix(float[], float[], float[], float[])
|
||||
*/
|
||||
|
||||
public static boolean remapCoordinateSystem(float[] inR, int X, int Y,
|
||||
float[] outR)
|
||||
{
|
||||
public static boolean remapCoordinateSystem(float[] inR, int X, int Y, float[] outR) {
|
||||
if (inR == outR) {
|
||||
final float[] temp = mTempMatrix;
|
||||
synchronized(temp) {
|
||||
final float[] temp = sTempMatrix;
|
||||
synchronized (temp) {
|
||||
// we don't expect to have a lot of contention
|
||||
if (remapCoordinateSystemImpl(inR, X, Y, temp)) {
|
||||
final int size = outR.length;
|
||||
for (int i=0 ; i<size ; i++)
|
||||
for (int i = 0; i < size; i++) {
|
||||
outR[i] = temp[i];
|
||||
}
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@@ -1361,9 +1364,7 @@ public abstract class SensorManager {
|
||||
return remapCoordinateSystemImpl(inR, X, Y, outR);
|
||||
}
|
||||
|
||||
private static boolean remapCoordinateSystemImpl(float[] inR, int X, int Y,
|
||||
float[] outR)
|
||||
{
|
||||
private static boolean remapCoordinateSystemImpl(float[] inR, int X, int Y, float[] outR) {
|
||||
/*
|
||||
* X and Y define a rotation matrix 'r':
|
||||
*
|
||||
@@ -1376,14 +1377,18 @@ public abstract class SensorManager {
|
||||
*/
|
||||
|
||||
final int length = outR.length;
|
||||
if (inR.length != length)
|
||||
if (inR.length != length) {
|
||||
return false; // invalid parameter
|
||||
if ((X & 0x7C)!=0 || (Y & 0x7C)!=0)
|
||||
}
|
||||
if ((X & 0x7C) != 0 || (Y & 0x7C) != 0) {
|
||||
return false; // invalid parameter
|
||||
if (((X & 0x3)==0) || ((Y & 0x3)==0))
|
||||
}
|
||||
if (((X & 0x3) == 0) || ((Y & 0x3) == 0)) {
|
||||
return false; // no axis specified
|
||||
if ((X & 0x3) == (Y & 0x3))
|
||||
}
|
||||
if ((X & 0x3) == (Y & 0x3)) {
|
||||
return false; // same axis specified
|
||||
}
|
||||
|
||||
// Z is "the other" axis, its sign is either +/- sign(X)*sign(Y)
|
||||
// this can be calculated by exclusive-or'ing X and Y; except for
|
||||
@@ -1391,28 +1396,29 @@ public abstract class SensorManager {
|
||||
int Z = X ^ Y;
|
||||
|
||||
// extract the axis (remove the sign), offset in the range 0 to 2.
|
||||
final int x = (X & 0x3)-1;
|
||||
final int y = (Y & 0x3)-1;
|
||||
final int z = (Z & 0x3)-1;
|
||||
final int x = (X & 0x3) - 1;
|
||||
final int y = (Y & 0x3) - 1;
|
||||
final int z = (Z & 0x3) - 1;
|
||||
|
||||
// compute the sign of Z (whether it needs to be inverted)
|
||||
final int axis_y = (z+1)%3;
|
||||
final int axis_z = (z+2)%3;
|
||||
if (((x^axis_y)|(y^axis_z)) != 0)
|
||||
final int axis_y = (z + 1) % 3;
|
||||
final int axis_z = (z + 2) % 3;
|
||||
if (((x ^ axis_y) | (y ^ axis_z)) != 0) {
|
||||
Z ^= 0x80;
|
||||
}
|
||||
|
||||
final boolean sx = (X>=0x80);
|
||||
final boolean sy = (Y>=0x80);
|
||||
final boolean sz = (Z>=0x80);
|
||||
final boolean sx = (X >= 0x80);
|
||||
final boolean sy = (Y >= 0x80);
|
||||
final boolean sz = (Z >= 0x80);
|
||||
|
||||
// Perform R * r, in avoiding actual muls and adds.
|
||||
final int rowLength = ((length==16)?4:3);
|
||||
for (int j=0 ; j<3 ; j++) {
|
||||
final int offset = j*rowLength;
|
||||
for (int i=0 ; i<3 ; i++) {
|
||||
if (x==i) outR[offset+i] = sx ? -inR[offset+0] : inR[offset+0];
|
||||
if (y==i) outR[offset+i] = sy ? -inR[offset+1] : inR[offset+1];
|
||||
if (z==i) outR[offset+i] = sz ? -inR[offset+2] : inR[offset+2];
|
||||
final int rowLength = ((length == 16) ? 4 : 3);
|
||||
for (int j = 0; j < 3; j++) {
|
||||
final int offset = j * rowLength;
|
||||
for (int i = 0; i < 3; i++) {
|
||||
if (x == i) outR[offset + i] = sx ? -inR[offset + 0] : inR[offset + 0];
|
||||
if (y == i) outR[offset + i] = sy ? -inR[offset + 1] : inR[offset + 1];
|
||||
if (z == i) outR[offset + i] = sz ? -inR[offset + 2] : inR[offset + 2];
|
||||
}
|
||||
}
|
||||
if (length == 16) {
|
||||
@@ -1466,7 +1472,7 @@ public abstract class SensorManager {
|
||||
* @see #getRotationMatrix(float[], float[], float[], float[])
|
||||
* @see GeomagneticField
|
||||
*/
|
||||
public static float[] getOrientation(float[] R, float values[]) {
|
||||
public static float[] getOrientation(float[] R, float[] values) {
|
||||
/*
|
||||
* 4x4 (length=16) case:
|
||||
* / R[ 0] R[ 1] R[ 2] 0 \
|
||||
@@ -1481,13 +1487,13 @@ public abstract class SensorManager {
|
||||
*
|
||||
*/
|
||||
if (R.length == 9) {
|
||||
values[0] = (float)Math.atan2(R[1], R[4]);
|
||||
values[1] = (float)Math.asin(-R[7]);
|
||||
values[2] = (float)Math.atan2(-R[6], R[8]);
|
||||
values[0] = (float) Math.atan2(R[1], R[4]);
|
||||
values[1] = (float) Math.asin(-R[7]);
|
||||
values[2] = (float) Math.atan2(-R[6], R[8]);
|
||||
} else {
|
||||
values[0] = (float)Math.atan2(R[1], R[5]);
|
||||
values[1] = (float)Math.asin(-R[9]);
|
||||
values[2] = (float)Math.atan2(-R[8], R[10]);
|
||||
values[0] = (float) Math.atan2(R[1], R[5]);
|
||||
values[1] = (float) Math.asin(-R[9]);
|
||||
values[2] = (float) Math.atan2(-R[8], R[10]);
|
||||
}
|
||||
|
||||
return values;
|
||||
@@ -1524,7 +1530,7 @@ public abstract class SensorManager {
|
||||
*/
|
||||
public static float getAltitude(float p0, float p) {
|
||||
final float coef = 1.0f / 5.255f;
|
||||
return 44330.0f * (1.0f - (float)Math.pow(p/p0, coef));
|
||||
return 44330.0f * (1.0f - (float) Math.pow(p / p0, coef));
|
||||
}
|
||||
|
||||
/** Helper function to compute the angle change between two rotation matrices.
|
||||
@@ -1557,12 +1563,13 @@ public abstract class SensorManager {
|
||||
* (in radians) is stored
|
||||
*/
|
||||
|
||||
public static void getAngleChange( float[] angleChange, float[] R, float[] prevR) {
|
||||
float rd1=0,rd4=0, rd6=0,rd7=0, rd8=0;
|
||||
float ri0=0,ri1=0,ri2=0,ri3=0,ri4=0,ri5=0,ri6=0,ri7=0,ri8=0;
|
||||
float pri0=0, pri1=0, pri2=0, pri3=0, pri4=0, pri5=0, pri6=0, pri7=0, pri8=0;
|
||||
public static void getAngleChange(float[] angleChange, float[] R, float[] prevR) {
|
||||
float rd1 = 0, rd4 = 0, rd6 = 0, rd7 = 0, rd8 = 0;
|
||||
float ri0 = 0, ri1 = 0, ri2 = 0, ri3 = 0, ri4 = 0, ri5 = 0, ri6 = 0, ri7 = 0, ri8 = 0;
|
||||
float pri0 = 0, pri1 = 0, pri2 = 0, pri3 = 0, pri4 = 0;
|
||||
float pri5 = 0, pri6 = 0, pri7 = 0, pri8 = 0;
|
||||
|
||||
if(R.length == 9) {
|
||||
if (R.length == 9) {
|
||||
ri0 = R[0];
|
||||
ri1 = R[1];
|
||||
ri2 = R[2];
|
||||
@@ -1572,7 +1579,7 @@ public abstract class SensorManager {
|
||||
ri6 = R[6];
|
||||
ri7 = R[7];
|
||||
ri8 = R[8];
|
||||
} else if(R.length == 16) {
|
||||
} else if (R.length == 16) {
|
||||
ri0 = R[0];
|
||||
ri1 = R[1];
|
||||
ri2 = R[2];
|
||||
@@ -1584,7 +1591,7 @@ public abstract class SensorManager {
|
||||
ri8 = R[10];
|
||||
}
|
||||
|
||||
if(prevR.length == 9) {
|
||||
if (prevR.length == 9) {
|
||||
pri0 = prevR[0];
|
||||
pri1 = prevR[1];
|
||||
pri2 = prevR[2];
|
||||
@@ -1594,7 +1601,7 @@ public abstract class SensorManager {
|
||||
pri6 = prevR[6];
|
||||
pri7 = prevR[7];
|
||||
pri8 = prevR[8];
|
||||
} else if(prevR.length == 16) {
|
||||
} else if (prevR.length == 16) {
|
||||
pri0 = prevR[0];
|
||||
pri1 = prevR[1];
|
||||
pri2 = prevR[2];
|
||||
@@ -1615,9 +1622,9 @@ public abstract class SensorManager {
|
||||
rd7 = pri2 * ri1 + pri5 * ri4 + pri8 * ri7; //rd[2][1]
|
||||
rd8 = pri2 * ri2 + pri5 * ri5 + pri8 * ri8; //rd[2][2]
|
||||
|
||||
angleChange[0] = (float)Math.atan2(rd1, rd4);
|
||||
angleChange[1] = (float)Math.asin(-rd7);
|
||||
angleChange[2] = (float)Math.atan2(-rd6, rd8);
|
||||
angleChange[0] = (float) Math.atan2(rd1, rd4);
|
||||
angleChange[1] = (float) Math.asin(-rd7);
|
||||
angleChange[2] = (float) Math.atan2(-rd6, rd8);
|
||||
|
||||
}
|
||||
|
||||
@@ -1650,8 +1657,8 @@ public abstract class SensorManager {
|
||||
if (rotationVector.length >= 4) {
|
||||
q0 = rotationVector[3];
|
||||
} else {
|
||||
q0 = 1 - q1*q1 - q2*q2 - q3*q3;
|
||||
q0 = (q0 > 0) ? (float)Math.sqrt(q0) : 0;
|
||||
q0 = 1 - q1 * q1 - q2 * q2 - q3 * q3;
|
||||
q0 = (q0 > 0) ? (float) Math.sqrt(q0) : 0;
|
||||
}
|
||||
|
||||
float sq_q1 = 2 * q1 * q1;
|
||||
@@ -1664,7 +1671,7 @@ public abstract class SensorManager {
|
||||
float q2_q3 = 2 * q2 * q3;
|
||||
float q1_q0 = 2 * q1 * q0;
|
||||
|
||||
if(R.length == 9) {
|
||||
if (R.length == 9) {
|
||||
R[0] = 1 - sq_q2 - sq_q3;
|
||||
R[1] = q1_q2 - q3_q0;
|
||||
R[2] = q1_q3 + q2_q0;
|
||||
@@ -1707,8 +1714,8 @@ public abstract class SensorManager {
|
||||
if (rv.length >= 4) {
|
||||
Q[0] = rv[3];
|
||||
} else {
|
||||
Q[0] = 1 - rv[0]*rv[0] - rv[1]*rv[1] - rv[2]*rv[2];
|
||||
Q[0] = (Q[0] > 0) ? (float)Math.sqrt(Q[0]) : 0;
|
||||
Q[0] = 1 - rv[0] * rv[0] - rv[1] * rv[1] - rv[2] * rv[2];
|
||||
Q[0] = (Q[0] > 0) ? (float) Math.sqrt(Q[0]) : 0;
|
||||
}
|
||||
Q[1] = rv[0];
|
||||
Q[2] = rv[1];
|
||||
@@ -1800,7 +1807,7 @@ public abstract class SensorManager {
|
||||
*/
|
||||
@SystemApi
|
||||
public boolean initDataInjection(boolean enable) {
|
||||
return initDataInjectionImpl(enable);
|
||||
return initDataInjectionImpl(enable);
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -1846,9 +1853,9 @@ public abstract class SensorManager {
|
||||
}
|
||||
int expectedNumValues = Sensor.getMaxLengthValuesArray(sensor, Build.VERSION_CODES.M);
|
||||
if (values.length != expectedNumValues) {
|
||||
throw new IllegalArgumentException ("Wrong number of values for sensor " +
|
||||
sensor.getName() + " actual=" + values.length + " expected=" +
|
||||
expectedNumValues);
|
||||
throw new IllegalArgumentException("Wrong number of values for sensor "
|
||||
+ sensor.getName() + " actual=" + values.length + " expected="
|
||||
+ expectedNumValues);
|
||||
}
|
||||
if (accuracy < SENSOR_STATUS_NO_CONTACT || accuracy > SENSOR_STATUS_ACCURACY_HIGH) {
|
||||
throw new IllegalArgumentException("Invalid sensor accuracy");
|
||||
|
||||
@@ -28,10 +28,11 @@ import android.util.Log;
|
||||
import android.util.SparseArray;
|
||||
import android.util.SparseBooleanArray;
|
||||
import android.util.SparseIntArray;
|
||||
import dalvik.system.CloseGuard;
|
||||
|
||||
import com.android.internal.annotations.GuardedBy;
|
||||
|
||||
import dalvik.system.CloseGuard;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.io.UncheckedIOException;
|
||||
import java.lang.ref.WeakReference;
|
||||
@@ -40,7 +41,6 @@ import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
|
||||
|
||||
/**
|
||||
* Sensor manager implementation that communicates with the built-in
|
||||
* system sensors.
|
||||
@@ -101,7 +101,7 @@ public class SystemSensorManager extends SensorManager {
|
||||
|
||||
/** {@hide} */
|
||||
public SystemSensorManager(Context context, Looper mainLooper) {
|
||||
synchronized(sLock) {
|
||||
synchronized (sLock) {
|
||||
if (!sNativeClassInited) {
|
||||
sNativeClassInited = true;
|
||||
nativeClassInit();
|
||||
@@ -114,7 +114,7 @@ public class SystemSensorManager extends SensorManager {
|
||||
mNativeInstance = nativeCreate(context.getOpPackageName());
|
||||
|
||||
// initialize the sensor list
|
||||
for (int index = 0;;++index) {
|
||||
for (int index = 0;; ++index) {
|
||||
Sensor sensor = new Sensor();
|
||||
if (!nativeGetSensorAtIndex(mNativeInstance, sensor, index)) break;
|
||||
mFullSensorsList.add(sensor);
|
||||
@@ -157,9 +157,9 @@ public class SystemSensorManager extends SensorManager {
|
||||
return false;
|
||||
}
|
||||
if (mSensorListeners.size() >= MAX_LISTENER_COUNT) {
|
||||
throw new IllegalStateException("register failed, " +
|
||||
"the sensor listeners size has exceeded the maximum limit " +
|
||||
MAX_LISTENER_COUNT);
|
||||
throw new IllegalStateException("register failed, "
|
||||
+ "the sensor listeners size has exceeded the maximum limit "
|
||||
+ MAX_LISTENER_COUNT);
|
||||
}
|
||||
|
||||
// Invariants to preserve:
|
||||
@@ -170,9 +170,10 @@ public class SystemSensorManager extends SensorManager {
|
||||
SensorEventQueue queue = mSensorListeners.get(listener);
|
||||
if (queue == null) {
|
||||
Looper looper = (handler != null) ? handler.getLooper() : mMainLooper;
|
||||
final String fullClassName = listener.getClass().getEnclosingClass() != null ?
|
||||
listener.getClass().getEnclosingClass().getName() :
|
||||
listener.getClass().getName();
|
||||
final String fullClassName =
|
||||
listener.getClass().getEnclosingClass() != null
|
||||
? listener.getClass().getEnclosingClass().getName()
|
||||
: listener.getClass().getName();
|
||||
queue = new SensorEventQueue(listener, looper, this, fullClassName);
|
||||
if (!queue.addSensor(sensor, delayUs, maxBatchReportLatencyUs)) {
|
||||
queue.dispose();
|
||||
@@ -221,17 +222,18 @@ public class SystemSensorManager extends SensorManager {
|
||||
if (sensor.getReportingMode() != Sensor.REPORTING_MODE_ONE_SHOT) return false;
|
||||
|
||||
if (mTriggerListeners.size() >= MAX_LISTENER_COUNT) {
|
||||
throw new IllegalStateException("request failed, " +
|
||||
"the trigger listeners size has exceeded the maximum limit " +
|
||||
MAX_LISTENER_COUNT);
|
||||
throw new IllegalStateException("request failed, "
|
||||
+ "the trigger listeners size has exceeded the maximum limit "
|
||||
+ MAX_LISTENER_COUNT);
|
||||
}
|
||||
|
||||
synchronized (mTriggerListeners) {
|
||||
TriggerEventQueue queue = mTriggerListeners.get(listener);
|
||||
if (queue == null) {
|
||||
final String fullClassName = listener.getClass().getEnclosingClass() != null ?
|
||||
listener.getClass().getEnclosingClass().getName() :
|
||||
listener.getClass().getName();
|
||||
final String fullClassName =
|
||||
listener.getClass().getEnclosingClass() != null
|
||||
? listener.getClass().getEnclosingClass().getName()
|
||||
: listener.getClass().getName();
|
||||
queue = new TriggerEventQueue(listener, mMainLooper, this, fullClassName);
|
||||
if (!queue.addSensor(sensor, 0, 0)) {
|
||||
queue.dispose();
|
||||
@@ -336,27 +338,27 @@ public class SystemSensorManager extends SensorManager {
|
||||
mHandleToSensor.remove(sensor.getHandle());
|
||||
|
||||
if (sensor.getReportingMode() == Sensor.REPORTING_MODE_ONE_SHOT) {
|
||||
synchronized(mTriggerListeners) {
|
||||
synchronized (mTriggerListeners) {
|
||||
HashMap<TriggerEventListener, TriggerEventQueue> triggerListeners =
|
||||
new HashMap<TriggerEventListener, TriggerEventQueue>(mTriggerListeners);
|
||||
new HashMap<TriggerEventListener, TriggerEventQueue>(mTriggerListeners);
|
||||
|
||||
for (TriggerEventListener l: triggerListeners.keySet()) {
|
||||
if (DEBUG_DYNAMIC_SENSOR){
|
||||
Log.i(TAG, "removed trigger listener" + l.toString() +
|
||||
" due to sensor disconnection");
|
||||
for (TriggerEventListener l : triggerListeners.keySet()) {
|
||||
if (DEBUG_DYNAMIC_SENSOR) {
|
||||
Log.i(TAG, "removed trigger listener" + l.toString()
|
||||
+ " due to sensor disconnection");
|
||||
}
|
||||
cancelTriggerSensorImpl(l, sensor, true);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
synchronized(mSensorListeners) {
|
||||
synchronized (mSensorListeners) {
|
||||
HashMap<SensorEventListener, SensorEventQueue> sensorListeners =
|
||||
new HashMap<SensorEventListener, SensorEventQueue>(mSensorListeners);
|
||||
new HashMap<SensorEventListener, SensorEventQueue>(mSensorListeners);
|
||||
|
||||
for (SensorEventListener l: sensorListeners.keySet()) {
|
||||
if (DEBUG_DYNAMIC_SENSOR){
|
||||
Log.i(TAG, "removed event listener" + l.toString() +
|
||||
" due to sensor disconnection");
|
||||
if (DEBUG_DYNAMIC_SENSOR) {
|
||||
Log.i(TAG, "removed event listener" + l.toString()
|
||||
+ " due to sensor disconnection");
|
||||
}
|
||||
unregisterListenerImpl(l, sensor);
|
||||
}
|
||||
@@ -365,7 +367,7 @@ public class SystemSensorManager extends SensorManager {
|
||||
}
|
||||
|
||||
private void updateDynamicSensorList() {
|
||||
synchronized(mFullDynamicSensorsList) {
|
||||
synchronized (mFullDynamicSensorsList) {
|
||||
if (mDynamicSensorListDirty) {
|
||||
List<Sensor> list = new ArrayList<>();
|
||||
nativeGetDynamicSensors(mNativeInstance, list);
|
||||
@@ -488,15 +490,15 @@ public class SystemSensorManager extends SensorManager {
|
||||
|
||||
int i = 0, j = 0;
|
||||
while (true) {
|
||||
if (j < oldList.size() && ( i >= newList.size() ||
|
||||
newList.get(i).getHandle() > oldList.get(j).getHandle()) ) {
|
||||
if (j < oldList.size() && (i >= newList.size()
|
||||
|| newList.get(i).getHandle() > oldList.get(j).getHandle())) {
|
||||
changed = true;
|
||||
if (removed != null) {
|
||||
removed.add(oldList.get(j));
|
||||
}
|
||||
++j;
|
||||
} else if (i < newList.size() && ( j >= oldList.size() ||
|
||||
newList.get(i).getHandle() < oldList.get(j).getHandle())) {
|
||||
} else if (i < newList.size() && (j >= oldList.size()
|
||||
|| newList.get(i).getHandle() < oldList.get(j).getHandle())) {
|
||||
changed = true;
|
||||
if (added != null) {
|
||||
added.add(newList.get(i));
|
||||
@@ -505,8 +507,8 @@ public class SystemSensorManager extends SensorManager {
|
||||
updated.add(newList.get(i));
|
||||
}
|
||||
++i;
|
||||
} else if (i < newList.size() && j < oldList.size() &&
|
||||
newList.get(i).getHandle() == oldList.get(j).getHandle()) {
|
||||
} else if (i < newList.size() && j < oldList.size()
|
||||
&& newList.get(i).getHandle() == oldList.get(j).getHandle()) {
|
||||
if (updated != null) {
|
||||
updated.add(oldList.get(j));
|
||||
}
|
||||
@@ -623,7 +625,7 @@ public class SystemSensorManager extends SensorManager {
|
||||
* associated with any listener and there is one InjectEventQueue associated with a
|
||||
* SensorManager instance.
|
||||
*/
|
||||
private static abstract class BaseEventQueue {
|
||||
private abstract static class BaseEventQueue {
|
||||
private static native long nativeInitBaseEventQueue(long nativeManager,
|
||||
WeakReference<BaseEventQueue> eventQWeak, MessageQueue msgQ,
|
||||
String packageName, int mode, String opPackageName);
|
||||
@@ -633,9 +635,9 @@ public class SystemSensorManager extends SensorManager {
|
||||
private static native void nativeDestroySensorEventQueue(long eventQ);
|
||||
private static native int nativeFlushSensor(long eventQ);
|
||||
private static native int nativeInjectSensorData(long eventQ, int handle,
|
||||
float[] values,int accuracy, long timestamp);
|
||||
float[] values, int accuracy, long timestamp);
|
||||
|
||||
private long nSensorEventQueue;
|
||||
private long mNativeSensorEventQueue;
|
||||
private final SparseBooleanArray mActiveSensors = new SparseBooleanArray();
|
||||
protected final SparseIntArray mSensorAccuracies = new SparseIntArray();
|
||||
private final CloseGuard mCloseGuard = CloseGuard.get();
|
||||
@@ -646,7 +648,7 @@ public class SystemSensorManager extends SensorManager {
|
||||
|
||||
BaseEventQueue(Looper looper, SystemSensorManager manager, int mode, String packageName) {
|
||||
if (packageName == null) packageName = "";
|
||||
nSensorEventQueue = nativeInitBaseEventQueue(manager.mNativeInstance,
|
||||
mNativeSensorEventQueue = nativeInitBaseEventQueue(manager.mNativeInstance,
|
||||
new WeakReference<>(this), looper.getQueue(),
|
||||
packageName, mode, manager.mContext.getOpPackageName());
|
||||
mCloseGuard.open("dispose");
|
||||
@@ -668,17 +670,17 @@ public class SystemSensorManager extends SensorManager {
|
||||
addSensorEvent(sensor);
|
||||
if (enableSensor(sensor, delayUs, maxBatchReportLatencyUs) != 0) {
|
||||
// Try continuous mode if batching fails.
|
||||
if (maxBatchReportLatencyUs == 0 ||
|
||||
maxBatchReportLatencyUs > 0 && enableSensor(sensor, delayUs, 0) != 0) {
|
||||
removeSensor(sensor, false);
|
||||
return false;
|
||||
if (maxBatchReportLatencyUs == 0
|
||||
|| maxBatchReportLatencyUs > 0 && enableSensor(sensor, delayUs, 0) != 0) {
|
||||
removeSensor(sensor, false);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
public boolean removeAllSensors() {
|
||||
for (int i=0 ; i<mActiveSensors.size(); i++) {
|
||||
for (int i = 0; i < mActiveSensors.size(); i++) {
|
||||
if (mActiveSensors.valueAt(i) == true) {
|
||||
int handle = mActiveSensors.keyAt(i);
|
||||
Sensor sensor = mManager.mHandleToSensor.get(handle);
|
||||
@@ -706,8 +708,8 @@ public class SystemSensorManager extends SensorManager {
|
||||
}
|
||||
|
||||
public int flush() {
|
||||
if (nSensorEventQueue == 0) throw new NullPointerException();
|
||||
return nativeFlushSensor(nSensorEventQueue);
|
||||
if (mNativeSensorEventQueue == 0) throw new NullPointerException();
|
||||
return nativeFlushSensor(mNativeSensorEventQueue);
|
||||
}
|
||||
|
||||
public boolean hasSensors() {
|
||||
@@ -731,29 +733,30 @@ public class SystemSensorManager extends SensorManager {
|
||||
}
|
||||
mCloseGuard.close();
|
||||
}
|
||||
if (nSensorEventQueue != 0) {
|
||||
nativeDestroySensorEventQueue(nSensorEventQueue);
|
||||
nSensorEventQueue = 0;
|
||||
if (mNativeSensorEventQueue != 0) {
|
||||
nativeDestroySensorEventQueue(mNativeSensorEventQueue);
|
||||
mNativeSensorEventQueue = 0;
|
||||
}
|
||||
}
|
||||
|
||||
private int enableSensor(
|
||||
Sensor sensor, int rateUs, int maxBatchReportLatencyUs) {
|
||||
if (nSensorEventQueue == 0) throw new NullPointerException();
|
||||
if (mNativeSensorEventQueue == 0) throw new NullPointerException();
|
||||
if (sensor == null) throw new NullPointerException();
|
||||
return nativeEnableSensor(nSensorEventQueue, sensor.getHandle(), rateUs,
|
||||
return nativeEnableSensor(mNativeSensorEventQueue, sensor.getHandle(), rateUs,
|
||||
maxBatchReportLatencyUs);
|
||||
}
|
||||
|
||||
protected int injectSensorDataBase(int handle, float[] values, int accuracy,
|
||||
long timestamp) {
|
||||
return nativeInjectSensorData(nSensorEventQueue, handle, values, accuracy, timestamp);
|
||||
return nativeInjectSensorData(
|
||||
mNativeSensorEventQueue, handle, values, accuracy, timestamp);
|
||||
}
|
||||
|
||||
private int disableSensor(Sensor sensor) {
|
||||
if (nSensorEventQueue == 0) throw new NullPointerException();
|
||||
if (mNativeSensorEventQueue == 0) throw new NullPointerException();
|
||||
if (sensor == null) throw new NullPointerException();
|
||||
return nativeDisableSensor(nSensorEventQueue, sensor.getHandle());
|
||||
return nativeDisableSensor(mNativeSensorEventQueue, sensor.getHandle());
|
||||
}
|
||||
protected abstract void dispatchSensorEvent(int handle, float[] values, int accuracy,
|
||||
long timestamp);
|
||||
@@ -840,7 +843,7 @@ public class SystemSensorManager extends SensorManager {
|
||||
// sensor disconnected
|
||||
return;
|
||||
}
|
||||
((SensorEventListener2)mListener).onFlushCompleted(sensor);
|
||||
((SensorEventListener2) mListener).onFlushCompleted(sensor);
|
||||
}
|
||||
return;
|
||||
}
|
||||
@@ -858,7 +861,7 @@ public class SystemSensorManager extends SensorManager {
|
||||
}
|
||||
SensorAdditionalInfo info =
|
||||
new SensorAdditionalInfo(sensor, type, serial, intValues, floatValues);
|
||||
((SensorEventCallback)mListener).onSensorAdditionalInfo(info);
|
||||
((SensorEventCallback) mListener).onSensorAdditionalInfo(info);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -930,8 +933,8 @@ public class SystemSensorManager extends SensorManager {
|
||||
super(looper, manager, OPERATING_MODE_DATA_INJECTION, packageName);
|
||||
}
|
||||
|
||||
int injectSensorData(int handle, float[] values,int accuracy, long timestamp) {
|
||||
return injectSensorDataBase(handle, values, accuracy, timestamp);
|
||||
int injectSensorData(int handle, float[] values, int accuracy, long timestamp) {
|
||||
return injectSensorDataBase(handle, values, accuracy, timestamp);
|
||||
}
|
||||
|
||||
@SuppressWarnings("unused")
|
||||
@@ -959,6 +962,7 @@ public class SystemSensorManager extends SensorManager {
|
||||
int handle = -1;
|
||||
if (parameter.sensor != null) handle = parameter.sensor.getHandle();
|
||||
return nativeSetOperationParameter(
|
||||
mNativeInstance, handle, parameter.type, parameter.floatValues, parameter.intValues) == 0;
|
||||
mNativeInstance, handle,
|
||||
parameter.type, parameter.floatValues, parameter.intValues) == 0;
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user