Merge "Reset SensorEventListener when listener reenabled."
diff --git a/core/java/android/provider/Settings.java b/core/java/android/provider/Settings.java
index 3d850cf..25954b9 100644
--- a/core/java/android/provider/Settings.java
+++ b/core/java/android/provider/Settings.java
@@ -50,7 +50,6 @@
import android.text.TextUtils;
import android.util.AndroidException;
import android.util.Log;
-import android.view.WindowOrientationListener;
import com.android.internal.widget.ILockSettings;
diff --git a/policy/src/com/android/internal/policy/impl/PhoneWindowManager.java b/policy/src/com/android/internal/policy/impl/PhoneWindowManager.java
index 9d0903c..9cb54a9 100644
--- a/policy/src/com/android/internal/policy/impl/PhoneWindowManager.java
+++ b/policy/src/com/android/internal/policy/impl/PhoneWindowManager.java
@@ -84,7 +84,6 @@
import android.view.WindowManager;
import android.view.WindowManagerGlobal;
import android.view.WindowManagerPolicy;
-import android.view.WindowOrientationListener;
import android.view.accessibility.AccessibilityEvent;
import android.view.animation.Animation;
import android.view.animation.AnimationUtils;
@@ -555,8 +554,8 @@
}
class MyOrientationListener extends WindowOrientationListener {
- MyOrientationListener(Context context) {
- super(context);
+ MyOrientationListener(Context context, Handler handler) {
+ super(context, handler);
}
@Override
@@ -854,7 +853,7 @@
mKeyguardMediator = new KeyguardViewMediator(context, null);
}
mHandler = new PolicyHandler();
- mOrientationListener = new MyOrientationListener(mContext);
+ mOrientationListener = new MyOrientationListener(mContext, mHandler);
try {
mOrientationListener.setCurrentRotation(windowManager.getRotation());
} catch (RemoteException ex) { }
@@ -3760,13 +3759,16 @@
}
BroadcastReceiver mDockReceiver = new BroadcastReceiver() {
+ @Override
public void onReceive(Context context, Intent intent) {
if (Intent.ACTION_DOCK_EVENT.equals(intent.getAction())) {
mDockMode = intent.getIntExtra(Intent.EXTRA_DOCK_STATE,
Intent.EXTRA_DOCK_STATE_UNDOCKED);
}
updateRotation(true);
- updateOrientationListenerLp();
+ synchronized (mLock) {
+ updateOrientationListenerLp();
+ }
}
};
diff --git a/core/java/android/view/WindowOrientationListener.java b/policy/src/com/android/internal/policy/impl/WindowOrientationListener.java
similarity index 65%
rename from core/java/android/view/WindowOrientationListener.java
rename to policy/src/com/android/internal/policy/impl/WindowOrientationListener.java
index bf77c67..0c77556 100644
--- a/core/java/android/view/WindowOrientationListener.java
+++ b/policy/src/com/android/internal/policy/impl/WindowOrientationListener.java
@@ -14,13 +14,14 @@
* limitations under the License.
*/
-package android.view;
+package com.android.internal.policy.impl;
import android.content.Context;
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;
+import android.os.Handler;
import android.os.SystemProperties;
import android.util.FloatMath;
import android.util.Log;
@@ -47,26 +48,31 @@
private static final boolean USE_GRAVITY_SENSOR = false;
+ private Handler mHandler;
private SensorManager mSensorManager;
private boolean mEnabled;
private int mRate;
private Sensor mSensor;
private SensorEventListenerImpl mSensorEventListener;
- int mCurrentRotation = -1;
+ private int mCurrentRotation = -1;
+
+ private final Object mLock = new Object();
/**
* Creates a new WindowOrientationListener.
*
* @param context for the WindowOrientationListener.
+ * @param handler Provides the Looper for receiving sensor updates.
*/
- public WindowOrientationListener(Context context) {
- this(context, SensorManager.SENSOR_DELAY_UI);
+ public WindowOrientationListener(Context context, Handler handler) {
+ this(context, handler, SensorManager.SENSOR_DELAY_UI);
}
/**
* Creates a new WindowOrientationListener.
*
* @param context for the WindowOrientationListener.
+ * @param handler Provides the Looper for receiving sensor updates.
* @param rate at which sensor events are processed (see also
* {@link android.hardware.SensorManager SensorManager}). Use the default
* value of {@link android.hardware.SensorManager#SENSOR_DELAY_NORMAL
@@ -74,33 +80,36 @@
*
* This constructor is private since no one uses it.
*/
- private WindowOrientationListener(Context context, int rate) {
+ private WindowOrientationListener(Context context, Handler handler, int rate) {
+ mHandler = handler;
mSensorManager = (SensorManager)context.getSystemService(Context.SENSOR_SERVICE);
mRate = rate;
mSensor = mSensorManager.getDefaultSensor(USE_GRAVITY_SENSOR
? Sensor.TYPE_GRAVITY : Sensor.TYPE_ACCELEROMETER);
if (mSensor != null) {
// Create listener only if sensors do exist
- mSensorEventListener = new SensorEventListenerImpl(this);
+ mSensorEventListener = new SensorEventListenerImpl();
}
}
/**
* Enables the WindowOrientationListener so it will monitor the sensor and call
- * {@link #onOrientationChanged} when the device orientation changes.
+ * {@link #onProposedRotationChanged(int)} when the device orientation changes.
*/
public void enable() {
- if (mSensor == null) {
- Log.w(TAG, "Cannot detect sensors. Not enabled");
- return;
- }
- if (mEnabled == false) {
- if (LOG) {
- Log.d(TAG, "WindowOrientationListener enabled");
+ synchronized (mLock) {
+ if (mSensor == null) {
+ Log.w(TAG, "Cannot detect sensors. Not enabled");
+ return;
}
- mSensorEventListener.reset();
- mSensorManager.registerListener(mSensorEventListener, mSensor, mRate);
- mEnabled = true;
+ if (mEnabled == false) {
+ if (LOG) {
+ Log.d(TAG, "WindowOrientationListener enabled");
+ }
+ mSensorEventListener.resetLocked();
+ mSensorManager.registerListener(mSensorEventListener, mSensor, mRate, mHandler);
+ mEnabled = true;
+ }
}
}
@@ -108,16 +117,18 @@
* Disables the WindowOrientationListener.
*/
public void disable() {
- if (mSensor == null) {
- Log.w(TAG, "Cannot detect sensors. Invalid disable");
- return;
- }
- if (mEnabled == true) {
- if (LOG) {
- Log.d(TAG, "WindowOrientationListener disabled");
+ synchronized (mLock) {
+ if (mSensor == null) {
+ Log.w(TAG, "Cannot detect sensors. Invalid disable");
+ return;
}
- mSensorManager.unregisterListener(mSensorEventListener);
- mEnabled = false;
+ if (mEnabled == true) {
+ if (LOG) {
+ Log.d(TAG, "WindowOrientationListener disabled");
+ }
+ mSensorManager.unregisterListener(mSensorEventListener);
+ mEnabled = false;
+ }
}
}
@@ -127,7 +138,9 @@
* @param rotation The current rotation.
*/
public void setCurrentRotation(int rotation) {
- mCurrentRotation = rotation;
+ synchronized (mLock) {
+ mCurrentRotation = rotation;
+ }
}
/**
@@ -139,17 +152,21 @@
* @return The proposed rotation, or -1 if unknown.
*/
public int getProposedRotation() {
- if (mEnabled) {
- return mSensorEventListener.getProposedRotation();
+ synchronized (mLock) {
+ if (mEnabled) {
+ return mSensorEventListener.getProposedRotationLocked();
+ }
+ return -1;
}
- return -1;
}
/**
* Returns true if sensor is enabled and false otherwise
*/
public boolean canDetectOrientation() {
- return mSensor != null;
+ synchronized (mLock) {
+ return mSensor != null;
+ }
}
/**
@@ -160,7 +177,7 @@
* uncertain to being certain again, even if it is the same orientation as before.
*
* @param rotation The new orientation of the device, one of the Surface.ROTATION_* constants.
- * @see Surface
+ * @see android.view.Surface
*/
public abstract void onProposedRotationChanged(int rotation);
@@ -202,7 +219,7 @@
* See http://en.wikipedia.org/wiki/Low-pass_filter#Discrete-time_realization for
* signal processing background.
*/
- static final class SensorEventListenerImpl implements SensorEventListener {
+ final class SensorEventListenerImpl implements SensorEventListener {
// We work with all angles in degrees in this class.
private static final float RADIANS_TO_DEGREES = (float) (180 / Math.PI);
@@ -214,8 +231,6 @@
private static final int ACCELEROMETER_DATA_Y = 1;
private static final int ACCELEROMETER_DATA_Z = 2;
- private final WindowOrientationListener mOrientationListener;
-
// The minimum amount of time that a predicted rotation must be stable before it
// is accepted as a valid rotation proposal. This value can be quite small because
// the low-pass filter already suppresses most of the noise so we're really just
@@ -320,7 +335,7 @@
// facing up (resting on a table).
// The ideal tilt angle is 0 (when the device is vertical) so the limits establish
// how close to vertical the device must be in order to change orientation.
- private static final int[][] TILT_TOLERANCE = new int[][] {
+ private final int[][] TILT_TOLERANCE = new int[][] {
/* ROTATION_0 */ { -25, 70 },
/* ROTATION_90 */ { -25, 65 },
/* ROTATION_180 */ { -25, 60 },
@@ -362,12 +377,7 @@
private long[] mTiltHistoryTimestampNanos = new long[TILT_HISTORY_SIZE];
private int mTiltHistoryIndex;
- public SensorEventListenerImpl(WindowOrientationListener orientationListener) {
- mOrientationListener = orientationListener;
- reset();
- }
-
- public int getProposedRotation() {
+ public int getProposedRotationLocked() {
return mProposedRotation;
}
@@ -377,179 +387,187 @@
@Override
public void onSensorChanged(SensorEvent event) {
- // The vector given in the SensorEvent points straight up (towards the sky) under ideal
- // conditions (the phone is not accelerating). I'll call this up vector elsewhere.
- float x = event.values[ACCELEROMETER_DATA_X];
- float y = event.values[ACCELEROMETER_DATA_Y];
- float z = event.values[ACCELEROMETER_DATA_Z];
+ int proposedRotation;
+ int oldProposedRotation;
- if (LOG) {
- Slog.v(TAG, "Raw acceleration vector: "
- + "x=" + x + ", y=" + y + ", z=" + z
- + ", magnitude=" + FloatMath.sqrt(x * x + y * y + z * z));
- }
+ synchronized (mLock) {
+ // The vector given in the SensorEvent points straight up (towards the sky) under
+ // ideal conditions (the phone is not accelerating). I'll call this up vector
+ // elsewhere.
+ float x = event.values[ACCELEROMETER_DATA_X];
+ float y = event.values[ACCELEROMETER_DATA_Y];
+ float z = event.values[ACCELEROMETER_DATA_Z];
- // Apply a low-pass filter to the acceleration up vector in cartesian space.
- // Reset the orientation listener state if the samples are too far apart in time
- // or when we see values of (0, 0, 0) which indicates that we polled the
- // accelerometer too soon after turning it on and we don't have any data yet.
- final long now = event.timestamp;
- final long then = mLastFilteredTimestampNanos;
- final float timeDeltaMS = (now - then) * 0.000001f;
- final boolean skipSample;
- if (now < then
- || now > then + MAX_FILTER_DELTA_TIME_NANOS
- || (x == 0 && y == 0 && z == 0)) {
if (LOG) {
- Slog.v(TAG, "Resetting orientation listener.");
- }
- reset();
- skipSample = true;
- } else {
- final float alpha = timeDeltaMS / (FILTER_TIME_CONSTANT_MS + timeDeltaMS);
- x = alpha * (x - mLastFilteredX) + mLastFilteredX;
- y = alpha * (y - mLastFilteredY) + mLastFilteredY;
- z = alpha * (z - mLastFilteredZ) + mLastFilteredZ;
- if (LOG) {
- Slog.v(TAG, "Filtered acceleration vector: "
+ Slog.v(TAG, "Raw acceleration vector: "
+ "x=" + x + ", y=" + y + ", z=" + z
+ ", magnitude=" + FloatMath.sqrt(x * x + y * y + z * z));
}
- skipSample = false;
- }
- mLastFilteredTimestampNanos = now;
- mLastFilteredX = x;
- mLastFilteredY = y;
- mLastFilteredZ = z;
- boolean isAccelerating = false;
- boolean isFlat = false;
- boolean isSwinging = false;
- if (!skipSample) {
- // Calculate the magnitude of the acceleration vector.
- final float magnitude = FloatMath.sqrt(x * x + y * y + z * z);
- if (magnitude < NEAR_ZERO_MAGNITUDE) {
+ // Apply a low-pass filter to the acceleration up vector in cartesian space.
+ // Reset the orientation listener state if the samples are too far apart in time
+ // or when we see values of (0, 0, 0) which indicates that we polled the
+ // accelerometer too soon after turning it on and we don't have any data yet.
+ final long now = event.timestamp;
+ final long then = mLastFilteredTimestampNanos;
+ final float timeDeltaMS = (now - then) * 0.000001f;
+ final boolean skipSample;
+ if (now < then
+ || now > then + MAX_FILTER_DELTA_TIME_NANOS
+ || (x == 0 && y == 0 && z == 0)) {
if (LOG) {
- Slog.v(TAG, "Ignoring sensor data, magnitude too close to zero.");
+ Slog.v(TAG, "Resetting orientation listener.");
}
- clearPredictedRotation();
+ resetLocked();
+ skipSample = true;
} else {
- // Determine whether the device appears to be undergoing external acceleration.
- if (isAccelerating(magnitude)) {
- isAccelerating = true;
- mAccelerationTimestampNanos = now;
+ final float alpha = timeDeltaMS / (FILTER_TIME_CONSTANT_MS + timeDeltaMS);
+ x = alpha * (x - mLastFilteredX) + mLastFilteredX;
+ y = alpha * (y - mLastFilteredY) + mLastFilteredY;
+ z = alpha * (z - mLastFilteredZ) + mLastFilteredZ;
+ if (LOG) {
+ Slog.v(TAG, "Filtered acceleration vector: "
+ + "x=" + x + ", y=" + y + ", z=" + z
+ + ", magnitude=" + FloatMath.sqrt(x * x + y * y + z * z));
}
+ skipSample = false;
+ }
+ mLastFilteredTimestampNanos = now;
+ mLastFilteredX = x;
+ mLastFilteredY = y;
+ mLastFilteredZ = z;
- // Calculate the tilt angle.
- // This is the angle between the up vector and the x-y plane (the plane of
- // the screen) in a range of [-90, 90] degrees.
- // -90 degrees: screen horizontal and facing the ground (overhead)
- // 0 degrees: screen vertical
- // 90 degrees: screen horizontal and facing the sky (on table)
- final int tiltAngle = (int) Math.round(
- Math.asin(z / magnitude) * RADIANS_TO_DEGREES);
- addTiltHistoryEntry(now, tiltAngle);
-
- // Determine whether the device appears to be flat or swinging.
- if (isFlat(now)) {
- isFlat = true;
- mFlatTimestampNanos = now;
- }
- if (isSwinging(now, tiltAngle)) {
- isSwinging = true;
- mSwingTimestampNanos = now;
- }
-
- // If the tilt angle is too close to horizontal then we cannot determine
- // the orientation angle of the screen.
- if (Math.abs(tiltAngle) > MAX_TILT) {
+ boolean isAccelerating = false;
+ boolean isFlat = false;
+ boolean isSwinging = false;
+ if (!skipSample) {
+ // Calculate the magnitude of the acceleration vector.
+ final float magnitude = FloatMath.sqrt(x * x + y * y + z * z);
+ if (magnitude < NEAR_ZERO_MAGNITUDE) {
if (LOG) {
- Slog.v(TAG, "Ignoring sensor data, tilt angle too high: "
- + "tiltAngle=" + tiltAngle);
+ Slog.v(TAG, "Ignoring sensor data, magnitude too close to zero.");
}
- clearPredictedRotation();
+ clearPredictedRotationLocked();
} else {
- // Calculate the orientation angle.
- // This is the angle between the x-y projection of the up vector onto
- // the +y-axis, increasing clockwise in a range of [0, 360] degrees.
- int orientationAngle = (int) Math.round(
- -Math.atan2(-x, y) * RADIANS_TO_DEGREES);
- if (orientationAngle < 0) {
- // atan2 returns [-180, 180]; normalize to [0, 360]
- orientationAngle += 360;
+ // Determine whether the device appears to be undergoing external
+ // acceleration.
+ if (isAcceleratingLocked(magnitude)) {
+ isAccelerating = true;
+ mAccelerationTimestampNanos = now;
}
- // Find the nearest rotation.
- int nearestRotation = (orientationAngle + 45) / 90;
- if (nearestRotation == 4) {
- nearestRotation = 0;
+ // Calculate the tilt angle.
+ // This is the angle between the up vector and the x-y plane (the plane of
+ // the screen) in a range of [-90, 90] degrees.
+ // -90 degrees: screen horizontal and facing the ground (overhead)
+ // 0 degrees: screen vertical
+ // 90 degrees: screen horizontal and facing the sky (on table)
+ final int tiltAngle = (int) Math.round(
+ Math.asin(z / magnitude) * RADIANS_TO_DEGREES);
+ addTiltHistoryEntryLocked(now, tiltAngle);
+
+ // Determine whether the device appears to be flat or swinging.
+ if (isFlatLocked(now)) {
+ isFlat = true;
+ mFlatTimestampNanos = now;
+ }
+ if (isSwingingLocked(now, tiltAngle)) {
+ isSwinging = true;
+ mSwingTimestampNanos = now;
}
- // Determine the predicted orientation.
- if (isTiltAngleAcceptable(nearestRotation, tiltAngle)
- && isOrientationAngleAcceptable(nearestRotation,
- orientationAngle)) {
- updatePredictedRotation(now, nearestRotation);
+ // If the tilt angle is too close to horizontal then we cannot determine
+ // the orientation angle of the screen.
+ if (Math.abs(tiltAngle) > MAX_TILT) {
if (LOG) {
- Slog.v(TAG, "Predicted: "
- + "tiltAngle=" + tiltAngle
- + ", orientationAngle=" + orientationAngle
- + ", predictedRotation=" + mPredictedRotation
- + ", predictedRotationAgeMS="
- + ((now - mPredictedRotationTimestampNanos)
- * 0.000001f));
+ Slog.v(TAG, "Ignoring sensor data, tilt angle too high: "
+ + "tiltAngle=" + tiltAngle);
}
+ clearPredictedRotationLocked();
} else {
- if (LOG) {
- Slog.v(TAG, "Ignoring sensor data, no predicted rotation: "
- + "tiltAngle=" + tiltAngle
- + ", orientationAngle=" + orientationAngle);
+ // Calculate the orientation angle.
+ // This is the angle between the x-y projection of the up vector onto
+ // the +y-axis, increasing clockwise in a range of [0, 360] degrees.
+ int orientationAngle = (int) Math.round(
+ -Math.atan2(-x, y) * RADIANS_TO_DEGREES);
+ if (orientationAngle < 0) {
+ // atan2 returns [-180, 180]; normalize to [0, 360]
+ orientationAngle += 360;
}
- clearPredictedRotation();
+
+ // Find the nearest rotation.
+ int nearestRotation = (orientationAngle + 45) / 90;
+ if (nearestRotation == 4) {
+ nearestRotation = 0;
+ }
+
+ // Determine the predicted orientation.
+ if (isTiltAngleAcceptableLocked(nearestRotation, tiltAngle)
+ && isOrientationAngleAcceptableLocked(nearestRotation,
+ orientationAngle)) {
+ updatePredictedRotationLocked(now, nearestRotation);
+ if (LOG) {
+ Slog.v(TAG, "Predicted: "
+ + "tiltAngle=" + tiltAngle
+ + ", orientationAngle=" + orientationAngle
+ + ", predictedRotation=" + mPredictedRotation
+ + ", predictedRotationAgeMS="
+ + ((now - mPredictedRotationTimestampNanos)
+ * 0.000001f));
+ }
+ } else {
+ if (LOG) {
+ Slog.v(TAG, "Ignoring sensor data, no predicted rotation: "
+ + "tiltAngle=" + tiltAngle
+ + ", orientationAngle=" + orientationAngle);
+ }
+ clearPredictedRotationLocked();
+ }
}
}
}
- }
- // Determine new proposed rotation.
- final int oldProposedRotation = mProposedRotation;
- if (mPredictedRotation < 0 || isPredictedRotationAcceptable(now)) {
- mProposedRotation = mPredictedRotation;
- }
+ // Determine new proposed rotation.
+ oldProposedRotation = mProposedRotation;
+ if (mPredictedRotation < 0 || isPredictedRotationAcceptableLocked(now)) {
+ mProposedRotation = mPredictedRotation;
+ }
+ proposedRotation = mProposedRotation;
- // Write final statistics about where we are in the orientation detection process.
- if (LOG) {
- Slog.v(TAG, "Result: currentRotation=" + mOrientationListener.mCurrentRotation
- + ", proposedRotation=" + mProposedRotation
- + ", predictedRotation=" + mPredictedRotation
- + ", timeDeltaMS=" + timeDeltaMS
- + ", isAccelerating=" + isAccelerating
- + ", isFlat=" + isFlat
- + ", isSwinging=" + isSwinging
- + ", timeUntilSettledMS=" + remainingMS(now,
- mPredictedRotationTimestampNanos + PROPOSAL_SETTLE_TIME_NANOS)
- + ", timeUntilAccelerationDelayExpiredMS=" + remainingMS(now,
- mAccelerationTimestampNanos + PROPOSAL_MIN_TIME_SINCE_ACCELERATION_ENDED_NANOS)
- + ", timeUntilFlatDelayExpiredMS=" + remainingMS(now,
- mFlatTimestampNanos + PROPOSAL_MIN_TIME_SINCE_FLAT_ENDED_NANOS)
- + ", timeUntilSwingDelayExpiredMS=" + remainingMS(now,
- mSwingTimestampNanos + PROPOSAL_MIN_TIME_SINCE_SWING_ENDED_NANOS));
+ // Write final statistics about where we are in the orientation detection process.
+ if (LOG) {
+ Slog.v(TAG, "Result: currentRotation=" + mCurrentRotation
+ + ", proposedRotation=" + proposedRotation
+ + ", predictedRotation=" + mPredictedRotation
+ + ", timeDeltaMS=" + timeDeltaMS
+ + ", isAccelerating=" + isAccelerating
+ + ", isFlat=" + isFlat
+ + ", isSwinging=" + isSwinging
+ + ", timeUntilSettledMS=" + remainingMS(now,
+ mPredictedRotationTimestampNanos + PROPOSAL_SETTLE_TIME_NANOS)
+ + ", timeUntilAccelerationDelayExpiredMS=" + remainingMS(now,
+ mAccelerationTimestampNanos + PROPOSAL_MIN_TIME_SINCE_ACCELERATION_ENDED_NANOS)
+ + ", timeUntilFlatDelayExpiredMS=" + remainingMS(now,
+ mFlatTimestampNanos + PROPOSAL_MIN_TIME_SINCE_FLAT_ENDED_NANOS)
+ + ", timeUntilSwingDelayExpiredMS=" + remainingMS(now,
+ mSwingTimestampNanos + PROPOSAL_MIN_TIME_SINCE_SWING_ENDED_NANOS));
+ }
}
// Tell the listener.
- if (mProposedRotation != oldProposedRotation && mProposedRotation >= 0) {
+ if (proposedRotation != oldProposedRotation && proposedRotation >= 0) {
if (LOG) {
- Slog.v(TAG, "Proposed rotation changed! proposedRotation=" + mProposedRotation
+ Slog.v(TAG, "Proposed rotation changed! proposedRotation=" + proposedRotation
+ ", oldProposedRotation=" + oldProposedRotation);
}
- mOrientationListener.onProposedRotationChanged(mProposedRotation);
+ onProposedRotationChanged(proposedRotation);
}
}
/**
* Returns true if the tilt angle is acceptable for a given predicted rotation.
*/
- private boolean isTiltAngleAcceptable(int rotation, int tiltAngle) {
+ private boolean isTiltAngleAcceptableLocked(int rotation, int tiltAngle) {
return tiltAngle >= TILT_TOLERANCE[rotation][0]
&& tiltAngle <= TILT_TOLERANCE[rotation][1];
}
@@ -560,11 +578,11 @@
* This function takes into account the gap between adjacent orientations
* for hysteresis.
*/
- private boolean isOrientationAngleAcceptable(int rotation, int orientationAngle) {
+ private boolean isOrientationAngleAcceptableLocked(int rotation, int orientationAngle) {
// If there is no current rotation, then there is no gap.
// The gap is used only to introduce hysteresis among advertised orientation
// changes to avoid flapping.
- final int currentRotation = mOrientationListener.mCurrentRotation;
+ final int currentRotation = mCurrentRotation;
if (currentRotation >= 0) {
// If the specified rotation is the same or is counter-clockwise adjacent
// to the current rotation, then we set a lower bound on the orientation angle.
@@ -611,7 +629,7 @@
* Returns true if the predicted rotation is ready to be advertised as a
* proposed rotation.
*/
- private boolean isPredictedRotationAcceptable(long now) {
+ private boolean isPredictedRotationAcceptableLocked(long now) {
// The predicted rotation must have settled long enough.
if (now < mPredictedRotationTimestampNanos + PROPOSAL_SETTLE_TIME_NANOS) {
return false;
@@ -638,47 +656,47 @@
return true;
}
- private void reset() {
+ private void resetLocked() {
mLastFilteredTimestampNanos = Long.MIN_VALUE;
mProposedRotation = -1;
mFlatTimestampNanos = Long.MIN_VALUE;
mSwingTimestampNanos = Long.MIN_VALUE;
mAccelerationTimestampNanos = Long.MIN_VALUE;
- clearPredictedRotation();
- clearTiltHistory();
+ clearPredictedRotationLocked();
+ clearTiltHistoryLocked();
}
- private void clearPredictedRotation() {
+ private void clearPredictedRotationLocked() {
mPredictedRotation = -1;
mPredictedRotationTimestampNanos = Long.MIN_VALUE;
}
- private void updatePredictedRotation(long now, int rotation) {
+ private void updatePredictedRotationLocked(long now, int rotation) {
if (mPredictedRotation != rotation) {
mPredictedRotation = rotation;
mPredictedRotationTimestampNanos = now;
}
}
- private boolean isAccelerating(float magnitude) {
+ private boolean isAcceleratingLocked(float magnitude) {
return magnitude < MIN_ACCELERATION_MAGNITUDE
|| magnitude > MAX_ACCELERATION_MAGNITUDE;
}
- private void clearTiltHistory() {
+ private void clearTiltHistoryLocked() {
mTiltHistoryTimestampNanos[0] = Long.MIN_VALUE;
mTiltHistoryIndex = 1;
}
- private void addTiltHistoryEntry(long now, float tilt) {
+ private void addTiltHistoryEntryLocked(long now, float tilt) {
mTiltHistory[mTiltHistoryIndex] = tilt;
mTiltHistoryTimestampNanos[mTiltHistoryIndex] = now;
mTiltHistoryIndex = (mTiltHistoryIndex + 1) % TILT_HISTORY_SIZE;
mTiltHistoryTimestampNanos[mTiltHistoryIndex] = Long.MIN_VALUE;
}
- private boolean isFlat(long now) {
- for (int i = mTiltHistoryIndex; (i = nextTiltHistoryIndex(i)) >= 0; ) {
+ private boolean isFlatLocked(long now) {
+ for (int i = mTiltHistoryIndex; (i = nextTiltHistoryIndexLocked(i)) >= 0; ) {
if (mTiltHistory[i] < FLAT_ANGLE) {
break;
}
@@ -690,8 +708,8 @@
return false;
}
- private boolean isSwinging(long now, float tilt) {
- for (int i = mTiltHistoryIndex; (i = nextTiltHistoryIndex(i)) >= 0; ) {
+ private boolean isSwingingLocked(long now, float tilt) {
+ for (int i = mTiltHistoryIndex; (i = nextTiltHistoryIndexLocked(i)) >= 0; ) {
if (mTiltHistoryTimestampNanos[i] + SWING_TIME_NANOS < now) {
break;
}
@@ -703,12 +721,12 @@
return false;
}
- private int nextTiltHistoryIndex(int index) {
+ private int nextTiltHistoryIndexLocked(int index) {
index = (index == 0 ? TILT_HISTORY_SIZE : index) - 1;
return mTiltHistoryTimestampNanos[index] != Long.MIN_VALUE ? index : -1;
}
- private static float remainingMS(long now, long until) {
+ private float remainingMS(long now, long until) {
return now >= until ? 0 : (until - now) * 0.000001f;
}
}