services/core/java/com/android/server/AnyMotionDetector.java - platform/frameworks/base - Git at Google

 /*
  * Copyright (C) 2015 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.android.server;

 import android.hardware.Sensor;
 import android.hardware.SensorEvent;
 import android.hardware.SensorEventListener;
 import android.hardware.SensorManager;
 import android.os.Handler;
 import android.os.Message;
 import android.os.PowerManager;
 import android.os.SystemClock;
 import android.util.Slog;

 import java.lang.Float;

 /**
  * Determines if the device has been set upon a stationary object.
  */
 public class AnyMotionDetector {
     interface DeviceIdleCallback {
         public void onAnyMotionResult(int result);
     }

     private static final String TAG = "AnyMotionDetector";

     private static final boolean DEBUG = false;

     /** Stationary status is unknown due to insufficient orientation measurements. */
     public static final int RESULT_UNKNOWN = -1;

     /** Device is stationary, e.g. still on a table. */
     public static final int RESULT_STATIONARY = 0;

     /** Device has been moved. */
     public static final int RESULT_MOVED = 1;

     /** Orientation measurements are being performed or are planned. */
     private static final int STATE_INACTIVE = 0;

     /** No orientation measurements are being performed or are planned. */
     private static final int STATE_ACTIVE = 1;

     /** Current measurement state. */
     private int mState;

     /** Threshold energy above which the device is considered moving. */
     private final float THRESHOLD_ENERGY = 5f;

     /** The duration of the accelerometer orientation measurement. */
     private static final long ORIENTATION_MEASUREMENT_DURATION_MILLIS = 2500;

     /** The maximum duration we will collect accelerometer data. */
     private static final long ACCELEROMETER_DATA_TIMEOUT_MILLIS = 3000;

     /** The interval between accelerometer orientation measurements. */
     private static final long ORIENTATION_MEASUREMENT_INTERVAL_MILLIS = 5000;

     /** The maximum duration we will hold a wakelock to determine stationary status. */
     private static final long WAKELOCK_TIMEOUT_MILLIS = 30000;

     /**
      * The duration in milliseconds after which an orientation measurement is considered
      * too stale to be used.
      */
     private static final int STALE_MEASUREMENT_TIMEOUT_MILLIS = 2 * 60 * 1000;

     /** The accelerometer sampling interval. */
     private static final int SAMPLING_INTERVAL_MILLIS = 40;

     private final Handler mHandler;
     private final Object mLock = new Object();
     private Sensor mAccelSensor;
     private SensorManager mSensorManager;
     private PowerManager.WakeLock mWakeLock;

     /** Threshold angle in degrees beyond which the device is considered moving. */
     private final float mThresholdAngle;

     /** The minimum number of samples required to detect AnyMotion. */
     private int mNumSufficientSamples;

     /** True if an orientation measurement is in progress. */
     private boolean mMeasurementInProgress;

     /** True if sendMessageDelayed() for the mMeasurementTimeout callback has been scheduled */
     private boolean mMeasurementTimeoutIsActive;

     /** True if sendMessageDelayed() for the mWakelockTimeout callback has been scheduled */
     private boolean mWakelockTimeoutIsActive;

     /** True if sendMessageDelayed() for the mSensorRestart callback has been scheduled */
     private boolean mSensorRestartIsActive;

     /** The most recent gravity vector. */
     private Vector3 mCurrentGravityVector = null;

     /** The second most recent gravity vector. */
     private Vector3 mPreviousGravityVector = null;

     /** Running sum of squared errors. */
     private RunningSignalStats mRunningStats;

     private DeviceIdleCallback mCallback = null;

     public AnyMotionDetector(PowerManager pm, Handler handler, SensorManager sm,
             DeviceIdleCallback callback, float thresholdAngle) {
         if (DEBUG) Slog.d(TAG, "AnyMotionDetector instantiated.");
         synchronized (mLock) {
             mWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, TAG);
             mWakeLock.setReferenceCounted(false);
             mHandler = handler;
             mSensorManager = sm;
             mAccelSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
             mMeasurementInProgress = false;
             mMeasurementTimeoutIsActive = false;
             mWakelockTimeoutIsActive = false;
             mSensorRestartIsActive = false;
             mState = STATE_INACTIVE;
             mCallback = callback;
             mThresholdAngle = thresholdAngle;
             mRunningStats = new RunningSignalStats();
             mNumSufficientSamples = (int) Math.ceil(
                     ((double)ORIENTATION_MEASUREMENT_DURATION_MILLIS / SAMPLING_INTERVAL_MILLIS));
             if (DEBUG) Slog.d(TAG, "mNumSufficientSamples = " + mNumSufficientSamples);
         }
     }

     /*
      * Acquire accel data until we determine AnyMotion status.
      */
     public void checkForAnyMotion() {
         if (DEBUG) {
             Slog.d(TAG, "checkForAnyMotion(). mState = " + mState);
         }
         if (mState != STATE_ACTIVE) {
             synchronized (mLock) {
                 mState = STATE_ACTIVE;
                 if (DEBUG) {
                     Slog.d(TAG, "Moved from STATE_INACTIVE to STATE_ACTIVE.");
                 }
                 mCurrentGravityVector = null;
                 mPreviousGravityVector = null;
                 mWakeLock.acquire();
                 Message wakelockTimeoutMsg = Message.obtain(mHandler, mWakelockTimeout);
                 mHandler.sendMessageDelayed(wakelockTimeoutMsg, WAKELOCK_TIMEOUT_MILLIS);
                 mWakelockTimeoutIsActive = true;
                 startOrientationMeasurementLocked();
             }
         }
     }

     public void stop() {
         synchronized (mLock) {
             if (mState == STATE_ACTIVE) {
                 mState = STATE_INACTIVE;
                 if (DEBUG) Slog.d(TAG, "Moved from STATE_ACTIVE to STATE_INACTIVE.");
             }
             mHandler.removeCallbacks(mMeasurementTimeout);
             mHandler.removeCallbacks(mSensorRestart);
             mMeasurementTimeoutIsActive = false;
             mSensorRestartIsActive = false;
             if (mMeasurementInProgress) {
                 mMeasurementInProgress = false;
                 mSensorManager.unregisterListener(mListener);
             }
             mCurrentGravityVector = null;
             mPreviousGravityVector = null;
             if (mWakeLock.isHeld()) {
                 mHandler.removeCallbacks(mWakelockTimeout);
                 mWakelockTimeoutIsActive = false;
                 mWakeLock.release();
             }
         }
     }

     private void startOrientationMeasurementLocked() {
         if (DEBUG) Slog.d(TAG, "startOrientationMeasurementLocked: mMeasurementInProgress=" +
             mMeasurementInProgress + ", (mAccelSensor != null)=" + (mAccelSensor != null));
         if (!mMeasurementInProgress && mAccelSensor != null) {
             if (mSensorManager.registerListener(mListener, mAccelSensor,
                     SAMPLING_INTERVAL_MILLIS * 1000)) {
                 mMeasurementInProgress = true;
                 mRunningStats.reset();
             }
             Message measurementTimeoutMsg = Message.obtain(mHandler, mMeasurementTimeout);
             mHandler.sendMessageDelayed(measurementTimeoutMsg, ACCELEROMETER_DATA_TIMEOUT_MILLIS);
             mMeasurementTimeoutIsActive = true;
         }
     }

     private int stopOrientationMeasurementLocked() {
         if (DEBUG) Slog.d(TAG, "stopOrientationMeasurement. mMeasurementInProgress=" +
                 mMeasurementInProgress);
         int status = RESULT_UNKNOWN;
         if (mMeasurementInProgress) {
             mHandler.removeCallbacks(mMeasurementTimeout);
             mMeasurementTimeoutIsActive = false;
             mSensorManager.unregisterListener(mListener);
             mMeasurementInProgress = false;
             mPreviousGravityVector = mCurrentGravityVector;
             mCurrentGravityVector = mRunningStats.getRunningAverage();
             if (mRunningStats.getSampleCount() == 0) {
                 Slog.w(TAG, "No accelerometer data acquired for orientation measurement.");
             }
             if (DEBUG) {
                 Slog.d(TAG, "mRunningStats = " + mRunningStats.toString());
                 String currentGravityVectorString = (mCurrentGravityVector == null) ?
                         "null" : mCurrentGravityVector.toString();
                 String previousGravityVectorString = (mPreviousGravityVector == null) ?
                         "null" : mPreviousGravityVector.toString();
                 Slog.d(TAG, "mCurrentGravityVector = " + currentGravityVectorString);
                 Slog.d(TAG, "mPreviousGravityVector = " + previousGravityVectorString);
             }
             mRunningStats.reset();
             status = getStationaryStatus();
             if (DEBUG) Slog.d(TAG, "getStationaryStatus() returned " + status);
             if (status != RESULT_UNKNOWN) {
                 if (mWakeLock.isHeld()) {
                     mHandler.removeCallbacks(mWakelockTimeout);
                     mWakelockTimeoutIsActive = false;
                     mWakeLock.release();
                 }
                 if (DEBUG) {
                     Slog.d(TAG, "Moved from STATE_ACTIVE to STATE_INACTIVE. status = " + status);
                 }
                 mState = STATE_INACTIVE;
             } else {
                 /*
                  * Unknown due to insufficient measurements. Schedule another orientation
                  * measurement.
                  */
                 if (DEBUG) Slog.d(TAG, "stopOrientationMeasurementLocked(): another measurement" +
                         " scheduled in " + ORIENTATION_MEASUREMENT_INTERVAL_MILLIS +
                         " milliseconds.");
                 Message msg = Message.obtain(mHandler, mSensorRestart);
                 mHandler.sendMessageDelayed(msg, ORIENTATION_MEASUREMENT_INTERVAL_MILLIS);
                 mSensorRestartIsActive = true;
             }
         }
         return status;
     }

     /*
      * Updates mStatus to the current AnyMotion status.
      */
     public int getStationaryStatus() {
         if ((mPreviousGravityVector == null) || (mCurrentGravityVector == null)) {
             return RESULT_UNKNOWN;
         }
         Vector3 previousGravityVectorNormalized = mPreviousGravityVector.normalized();
         Vector3 currentGravityVectorNormalized = mCurrentGravityVector.normalized();
         float angle = previousGravityVectorNormalized.angleBetween(currentGravityVectorNormalized);
         if (DEBUG) Slog.d(TAG, "getStationaryStatus: angle = " + angle
                 + " energy = " + mRunningStats.getEnergy());
         if ((angle < mThresholdAngle) && (mRunningStats.getEnergy() < THRESHOLD_ENERGY)) {
             return RESULT_STATIONARY;
         } else if (Float.isNaN(angle)) {
           /**
            * Floating point rounding errors have caused the angle calcuation's dot product to
            * exceed 1.0. In such case, we report RESULT_MOVED to prevent devices from rapidly
            * retrying this measurement.
            */
             return RESULT_MOVED;
         }
         long diffTime = mCurrentGravityVector.timeMillisSinceBoot -
                 mPreviousGravityVector.timeMillisSinceBoot;
         if (diffTime > STALE_MEASUREMENT_TIMEOUT_MILLIS) {
             if (DEBUG) Slog.d(TAG, "getStationaryStatus: mPreviousGravityVector is too stale at " +
                     diffTime + " ms ago. Returning RESULT_UNKNOWN.");
             return RESULT_UNKNOWN;
         }
         return RESULT_MOVED;
     }

     private final SensorEventListener mListener = new SensorEventListener() {
         @Override
         public void onSensorChanged(SensorEvent event) {
             int status = RESULT_UNKNOWN;
             synchronized (mLock) {
                 Vector3 accelDatum = new Vector3(SystemClock.elapsedRealtime(), event.values[0],
                         event.values[1], event.values[2]);
                 mRunningStats.accumulate(accelDatum);

                 // If we have enough samples, stop accelerometer data acquisition.
                 if (mRunningStats.getSampleCount() >= mNumSufficientSamples) {
                     status = stopOrientationMeasurementLocked();
                 }
             }
             if (status != RESULT_UNKNOWN) {
                 mHandler.removeCallbacks(mWakelockTimeout);
                 mWakelockTimeoutIsActive = false;
                 mCallback.onAnyMotionResult(status);
             }
         }

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

     private final Runnable mSensorRestart = new Runnable() {
         @Override
         public void run() {
             synchronized (mLock) {
                 if (mSensorRestartIsActive == true) {
                     mSensorRestartIsActive = false;
                     startOrientationMeasurementLocked();
                 }
             }
         }
     };

     private final Runnable mMeasurementTimeout = new Runnable() {
         @Override
         public void run() {
             int status = RESULT_UNKNOWN;
             synchronized (mLock) {
                 if (mMeasurementTimeoutIsActive == true) {
                     mMeasurementTimeoutIsActive = false;
                     if (DEBUG) Slog.i(TAG, "mMeasurementTimeout. Failed to collect sufficient accel " +
                           "data within " + ACCELEROMETER_DATA_TIMEOUT_MILLIS + " ms. Stopping " +
                           "orientation measurement.");
                     status = stopOrientationMeasurementLocked();
                     if (status != RESULT_UNKNOWN) {
                         mHandler.removeCallbacks(mWakelockTimeout);
                         mWakelockTimeoutIsActive = false;
                         mCallback.onAnyMotionResult(status);
                     }
                 }
             }
         }
     };

     private final Runnable mWakelockTimeout = new Runnable() {
         @Override
         public void run() {
             synchronized (mLock) {
                 if (mWakelockTimeoutIsActive == true) {
                     mWakelockTimeoutIsActive = false;
                     stop();
                 }
             }
         }
     };

     /**
      * A timestamped three dimensional vector and some vector operations.
      */
     public static final class Vector3 {
         public long timeMillisSinceBoot;
         public float x;
         public float y;
         public float z;

         public Vector3(long timeMillisSinceBoot, float x, float y, float z) {
             this.timeMillisSinceBoot = timeMillisSinceBoot;
             this.x = x;
             this.y = y;
             this.z = z;
         }

         public float norm() {
             return (float) Math.sqrt(dotProduct(this));
         }

         public Vector3 normalized() {
             float mag = norm();
             return new Vector3(timeMillisSinceBoot, x / mag, y / mag, z / mag);
         }

         /**
          * Returns the angle between this 3D vector and another given 3D vector.
          * Assumes both have already been normalized.
          *
          * @param other The other Vector3 vector.
          * @return angle between this vector and the other given one.
          */
         public float angleBetween(Vector3 other) {
             Vector3 crossVector = cross(other);
             float degrees = Math.abs((float)Math.toDegrees(
                     Math.atan2(crossVector.norm(), dotProduct(other))));
             Slog.d(TAG, "angleBetween: this = " + this.toString() +
                 ", other = " + other.toString() + ", degrees = " + degrees);
             return degrees;
         }

         public Vector3 cross(Vector3 v) {
             return new Vector3(
                 v.timeMillisSinceBoot,
                 y * v.z - z * v.y,
                 z * v.x - x * v.z,
                 x * v.y - y * v.x);
         }

         @Override
         public String toString() {
             String msg = "";
             msg += "timeMillisSinceBoot=" + timeMillisSinceBoot;
             msg += " | x=" + x;
             msg += ", y=" + y;
             msg += ", z=" + z;
             return msg;
         }

         public float dotProduct(Vector3 v) {
             return x * v.x + y * v.y + z * v.z;
         }

         public Vector3 times(float val) {
             return new Vector3(timeMillisSinceBoot, x * val, y * val, z * val);
         }

         public Vector3 plus(Vector3 v) {
             return new Vector3(v.timeMillisSinceBoot, x + v.x, y + v.y, z + v.z);
         }

         public Vector3 minus(Vector3 v) {
             return new Vector3(v.timeMillisSinceBoot, x - v.x, y - v.y, z - v.z);
         }
     }

     /**
      * Maintains running statistics on the signal revelant to AnyMotion detection, including:
      * <ul>
      *   <li>running average.
      *   <li>running sum-of-squared-errors as the energy of the signal derivative.
      * <ul>
      */
     private static class RunningSignalStats {
         Vector3 previousVector;
         Vector3 currentVector;
         Vector3 runningSum;
         float energy;
         int sampleCount;

         public RunningSignalStats() {
             reset();
         }

         public void reset() {
             previousVector = null;
             currentVector = null;
             runningSum = new Vector3(0, 0, 0, 0);
             energy = 0;
             sampleCount = 0;
         }

         /**
          * Apply a 3D vector v as the next element in the running SSE.
          */
         public void accumulate(Vector3 v) {
             if (v == null) {
                 if (DEBUG) Slog.i(TAG, "Cannot accumulate a null vector.");
                 return;
             }
             sampleCount++;
             runningSum = runningSum.plus(v);
             previousVector = currentVector;
             currentVector = v;
             if (previousVector != null) {
                 Vector3 dv = currentVector.minus(previousVector);
                 float incrementalEnergy = dv.x * dv.x + dv.y * dv.y + dv.z * dv.z;
                 energy += incrementalEnergy;
                 if (DEBUG) Slog.i(TAG, "Accumulated vector " + currentVector.toString() +
                         ", runningSum = " + runningSum.toString() +
                         ", incrementalEnergy = " + incrementalEnergy +
                         ", energy = " + energy);
             }
         }

         public Vector3 getRunningAverage() {
             if (sampleCount > 0) {
               return runningSum.times((float)(1.0f / sampleCount));
             }
             return null;
         }

         public float getEnergy() {
             return energy;
         }

         public int getSampleCount() {
             return sampleCount;
         }

         @Override
         public String toString() {
             String msg = "";
             String currentVectorString = (currentVector == null) ?
                 "null" : currentVector.toString();
             String previousVectorString = (previousVector == null) ?
                 "null" : previousVector.toString();
             msg += "previousVector = " + previousVectorString;
             msg += ", currentVector = " + currentVectorString;
             msg += ", sampleCount = " + sampleCount;
             msg += ", energy = " + energy;
             return msg;
         }
     }
 }
	/*
	* Copyright (C) 2015 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.android.server;

	import android.hardware.Sensor;
	import android.hardware.SensorEvent;
	import android.hardware.SensorEventListener;
	import android.hardware.SensorManager;
	import android.os.Handler;
	import android.os.Message;
	import android.os.PowerManager;
	import android.os.SystemClock;
	import android.util.Slog;

	import java.lang.Float;

	/**
	* Determines if the device has been set upon a stationary object.
	*/
	public class AnyMotionDetector {
	interface DeviceIdleCallback {
	public void onAnyMotionResult(int result);
	}

	private static final String TAG = "AnyMotionDetector";

	private static final boolean DEBUG = false;

	/** Stationary status is unknown due to insufficient orientation measurements. */
	public static final int RESULT_UNKNOWN = -1;

	/** Device is stationary, e.g. still on a table. */
	public static final int RESULT_STATIONARY = 0;

	/** Device has been moved. */
	public static final int RESULT_MOVED = 1;

	/** Orientation measurements are being performed or are planned. */
	private static final int STATE_INACTIVE = 0;

	/** No orientation measurements are being performed or are planned. */
	private static final int STATE_ACTIVE = 1;

	/** Current measurement state. */
	private int mState;

	/** Threshold energy above which the device is considered moving. */
	private final float THRESHOLD_ENERGY = 5f;

	/** The duration of the accelerometer orientation measurement. */
	private static final long ORIENTATION_MEASUREMENT_DURATION_MILLIS = 2500;

	/** The maximum duration we will collect accelerometer data. */
	private static final long ACCELEROMETER_DATA_TIMEOUT_MILLIS = 3000;

	/** The interval between accelerometer orientation measurements. */
	private static final long ORIENTATION_MEASUREMENT_INTERVAL_MILLIS = 5000;

	/** The maximum duration we will hold a wakelock to determine stationary status. */
	private static final long WAKELOCK_TIMEOUT_MILLIS = 30000;

	/**
	* The duration in milliseconds after which an orientation measurement is considered
	* too stale to be used.
	*/
	private static final int STALE_MEASUREMENT_TIMEOUT_MILLIS = 2 * 60 * 1000;

	/** The accelerometer sampling interval. */
	private static final int SAMPLING_INTERVAL_MILLIS = 40;

	private final Handler mHandler;
	private final Object mLock = new Object();
	private Sensor mAccelSensor;
	private SensorManager mSensorManager;
	private PowerManager.WakeLock mWakeLock;

	/** Threshold angle in degrees beyond which the device is considered moving. */
	private final float mThresholdAngle;

	/** The minimum number of samples required to detect AnyMotion. */
	private int mNumSufficientSamples;

	/** True if an orientation measurement is in progress. */
	private boolean mMeasurementInProgress;

	/** True if sendMessageDelayed() for the mMeasurementTimeout callback has been scheduled */
	private boolean mMeasurementTimeoutIsActive;

	/** True if sendMessageDelayed() for the mWakelockTimeout callback has been scheduled */
	private boolean mWakelockTimeoutIsActive;

	/** True if sendMessageDelayed() for the mSensorRestart callback has been scheduled */
	private boolean mSensorRestartIsActive;

	/** The most recent gravity vector. */
	private Vector3 mCurrentGravityVector = null;

	/** The second most recent gravity vector. */
	private Vector3 mPreviousGravityVector = null;

	/** Running sum of squared errors. */
	private RunningSignalStats mRunningStats;

	private DeviceIdleCallback mCallback = null;

	public AnyMotionDetector(PowerManager pm, Handler handler, SensorManager sm,
	DeviceIdleCallback callback, float thresholdAngle) {
	if (DEBUG) Slog.d(TAG, "AnyMotionDetector instantiated.");
	synchronized (mLock) {
	mWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, TAG);
	mWakeLock.setReferenceCounted(false);
	mHandler = handler;
	mSensorManager = sm;
	mAccelSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
	mMeasurementInProgress = false;
	mMeasurementTimeoutIsActive = false;
	mWakelockTimeoutIsActive = false;
	mSensorRestartIsActive = false;
	mState = STATE_INACTIVE;
	mCallback = callback;
	mThresholdAngle = thresholdAngle;
	mRunningStats = new RunningSignalStats();
	mNumSufficientSamples = (int) Math.ceil(
	((double)ORIENTATION_MEASUREMENT_DURATION_MILLIS / SAMPLING_INTERVAL_MILLIS));
	if (DEBUG) Slog.d(TAG, "mNumSufficientSamples = " + mNumSufficientSamples);
	}
	}

	/*
	* Acquire accel data until we determine AnyMotion status.
	*/
	public void checkForAnyMotion() {
	if (DEBUG) {
	Slog.d(TAG, "checkForAnyMotion(). mState = " + mState);
	}
	if (mState != STATE_ACTIVE) {
	synchronized (mLock) {
	mState = STATE_ACTIVE;
	if (DEBUG) {
	Slog.d(TAG, "Moved from STATE_INACTIVE to STATE_ACTIVE.");
	}
	mCurrentGravityVector = null;
	mPreviousGravityVector = null;
	mWakeLock.acquire();
	Message wakelockTimeoutMsg = Message.obtain(mHandler, mWakelockTimeout);
	mHandler.sendMessageDelayed(wakelockTimeoutMsg, WAKELOCK_TIMEOUT_MILLIS);
	mWakelockTimeoutIsActive = true;
	startOrientationMeasurementLocked();
	}
	}
	}

	public void stop() {
	synchronized (mLock) {
	if (mState == STATE_ACTIVE) {
	mState = STATE_INACTIVE;
	if (DEBUG) Slog.d(TAG, "Moved from STATE_ACTIVE to STATE_INACTIVE.");
	}
	mHandler.removeCallbacks(mMeasurementTimeout);
	mHandler.removeCallbacks(mSensorRestart);
	mMeasurementTimeoutIsActive = false;
	mSensorRestartIsActive = false;
	if (mMeasurementInProgress) {
	mMeasurementInProgress = false;
	mSensorManager.unregisterListener(mListener);
	}
	mCurrentGravityVector = null;
	mPreviousGravityVector = null;
	if (mWakeLock.isHeld()) {
	mHandler.removeCallbacks(mWakelockTimeout);
	mWakelockTimeoutIsActive = false;
	mWakeLock.release();
	}
	}
	}

	private void startOrientationMeasurementLocked() {
	if (DEBUG) Slog.d(TAG, "startOrientationMeasurementLocked: mMeasurementInProgress=" +
	mMeasurementInProgress + ", (mAccelSensor != null)=" + (mAccelSensor != null));
	if (!mMeasurementInProgress && mAccelSensor != null) {
	if (mSensorManager.registerListener(mListener, mAccelSensor,
	SAMPLING_INTERVAL_MILLIS * 1000)) {
	mMeasurementInProgress = true;
	mRunningStats.reset();
	}
	Message measurementTimeoutMsg = Message.obtain(mHandler, mMeasurementTimeout);
	mHandler.sendMessageDelayed(measurementTimeoutMsg, ACCELEROMETER_DATA_TIMEOUT_MILLIS);
	mMeasurementTimeoutIsActive = true;
	}
	}

	private int stopOrientationMeasurementLocked() {
	if (DEBUG) Slog.d(TAG, "stopOrientationMeasurement. mMeasurementInProgress=" +
	mMeasurementInProgress);
	int status = RESULT_UNKNOWN;
	if (mMeasurementInProgress) {
	mHandler.removeCallbacks(mMeasurementTimeout);
	mMeasurementTimeoutIsActive = false;
	mSensorManager.unregisterListener(mListener);
	mMeasurementInProgress = false;
	mPreviousGravityVector = mCurrentGravityVector;
	mCurrentGravityVector = mRunningStats.getRunningAverage();
	if (mRunningStats.getSampleCount() == 0) {
	Slog.w(TAG, "No accelerometer data acquired for orientation measurement.");
	}
	if (DEBUG) {
	Slog.d(TAG, "mRunningStats = " + mRunningStats.toString());
	String currentGravityVectorString = (mCurrentGravityVector == null) ?
	"null" : mCurrentGravityVector.toString();
	String previousGravityVectorString = (mPreviousGravityVector == null) ?
	"null" : mPreviousGravityVector.toString();
	Slog.d(TAG, "mCurrentGravityVector = " + currentGravityVectorString);
	Slog.d(TAG, "mPreviousGravityVector = " + previousGravityVectorString);
	}
	mRunningStats.reset();
	status = getStationaryStatus();
	if (DEBUG) Slog.d(TAG, "getStationaryStatus() returned " + status);
	if (status != RESULT_UNKNOWN) {
	if (mWakeLock.isHeld()) {
	mHandler.removeCallbacks(mWakelockTimeout);
	mWakelockTimeoutIsActive = false;
	mWakeLock.release();
	}
	if (DEBUG) {
	Slog.d(TAG, "Moved from STATE_ACTIVE to STATE_INACTIVE. status = " + status);
	}
	mState = STATE_INACTIVE;
	} else {
	/*
	* Unknown due to insufficient measurements. Schedule another orientation
	* measurement.
	*/
	if (DEBUG) Slog.d(TAG, "stopOrientationMeasurementLocked(): another measurement" +
	" scheduled in " + ORIENTATION_MEASUREMENT_INTERVAL_MILLIS +
	" milliseconds.");
	Message msg = Message.obtain(mHandler, mSensorRestart);
	mHandler.sendMessageDelayed(msg, ORIENTATION_MEASUREMENT_INTERVAL_MILLIS);
	mSensorRestartIsActive = true;
	}
	}
	return status;
	}

	/*
	* Updates mStatus to the current AnyMotion status.
	*/
	public int getStationaryStatus() {
	if ((mPreviousGravityVector == null) \|\| (mCurrentGravityVector == null)) {
	return RESULT_UNKNOWN;
	}
	Vector3 previousGravityVectorNormalized = mPreviousGravityVector.normalized();
	Vector3 currentGravityVectorNormalized = mCurrentGravityVector.normalized();
	float angle = previousGravityVectorNormalized.angleBetween(currentGravityVectorNormalized);
	if (DEBUG) Slog.d(TAG, "getStationaryStatus: angle = " + angle
	+ " energy = " + mRunningStats.getEnergy());
	if ((angle < mThresholdAngle) && (mRunningStats.getEnergy() < THRESHOLD_ENERGY)) {
	return RESULT_STATIONARY;
	} else if (Float.isNaN(angle)) {
	/**
	* Floating point rounding errors have caused the angle calcuation's dot product to
	* exceed 1.0. In such case, we report RESULT_MOVED to prevent devices from rapidly
	* retrying this measurement.
	*/
	return RESULT_MOVED;
	}
	long diffTime = mCurrentGravityVector.timeMillisSinceBoot -
	mPreviousGravityVector.timeMillisSinceBoot;
	if (diffTime > STALE_MEASUREMENT_TIMEOUT_MILLIS) {
	if (DEBUG) Slog.d(TAG, "getStationaryStatus: mPreviousGravityVector is too stale at " +
	diffTime + " ms ago. Returning RESULT_UNKNOWN.");
	return RESULT_UNKNOWN;
	}
	return RESULT_MOVED;
	}

	private final SensorEventListener mListener = new SensorEventListener() {
	@Override
	public void onSensorChanged(SensorEvent event) {
	int status = RESULT_UNKNOWN;
	synchronized (mLock) {
	Vector3 accelDatum = new Vector3(SystemClock.elapsedRealtime(), event.values[0],
	event.values[1], event.values[2]);
	mRunningStats.accumulate(accelDatum);

	// If we have enough samples, stop accelerometer data acquisition.
	if (mRunningStats.getSampleCount() >= mNumSufficientSamples) {
	status = stopOrientationMeasurementLocked();
	}
	}
	if (status != RESULT_UNKNOWN) {
	mHandler.removeCallbacks(mWakelockTimeout);
	mWakelockTimeoutIsActive = false;
	mCallback.onAnyMotionResult(status);
	}
	}

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

	private final Runnable mSensorRestart = new Runnable() {
	@Override
	public void run() {
	synchronized (mLock) {
	if (mSensorRestartIsActive == true) {
	mSensorRestartIsActive = false;
	startOrientationMeasurementLocked();
	}
	}
	}
	};

	private final Runnable mMeasurementTimeout = new Runnable() {
	@Override
	public void run() {
	int status = RESULT_UNKNOWN;
	synchronized (mLock) {
	if (mMeasurementTimeoutIsActive == true) {
	mMeasurementTimeoutIsActive = false;
	if (DEBUG) Slog.i(TAG, "mMeasurementTimeout. Failed to collect sufficient accel " +
	"data within " + ACCELEROMETER_DATA_TIMEOUT_MILLIS + " ms. Stopping " +
	"orientation measurement.");
	status = stopOrientationMeasurementLocked();
	if (status != RESULT_UNKNOWN) {
	mHandler.removeCallbacks(mWakelockTimeout);
	mWakelockTimeoutIsActive = false;
	mCallback.onAnyMotionResult(status);
	}
	}
	}
	}
	};

	private final Runnable mWakelockTimeout = new Runnable() {
	@Override
	public void run() {
	synchronized (mLock) {
	if (mWakelockTimeoutIsActive == true) {
	mWakelockTimeoutIsActive = false;
	stop();
	}
	}
	}
	};

	/**
	* A timestamped three dimensional vector and some vector operations.
	*/
	public static final class Vector3 {
	public long timeMillisSinceBoot;
	public float x;
	public float y;
	public float z;

	public Vector3(long timeMillisSinceBoot, float x, float y, float z) {
	this.timeMillisSinceBoot = timeMillisSinceBoot;
	this.x = x;
	this.y = y;
	this.z = z;
	}

	public float norm() {
	return (float) Math.sqrt(dotProduct(this));
	}

	public Vector3 normalized() {
	float mag = norm();
	return new Vector3(timeMillisSinceBoot, x / mag, y / mag, z / mag);
	}

	/**
	* Returns the angle between this 3D vector and another given 3D vector.
	* Assumes both have already been normalized.
	*
	* @param other The other Vector3 vector.
	* @return angle between this vector and the other given one.
	*/
	public float angleBetween(Vector3 other) {
	Vector3 crossVector = cross(other);
	float degrees = Math.abs((float)Math.toDegrees(
	Math.atan2(crossVector.norm(), dotProduct(other))));
	Slog.d(TAG, "angleBetween: this = " + this.toString() +
	", other = " + other.toString() + ", degrees = " + degrees);
	return degrees;
	}

	public Vector3 cross(Vector3 v) {
	return new Vector3(
	v.timeMillisSinceBoot,
	y * v.z - z * v.y,
	z * v.x - x * v.z,
	x * v.y - y * v.x);
	}

	@Override
	public String toString() {
	String msg = "";
	msg += "timeMillisSinceBoot=" + timeMillisSinceBoot;
	msg += " \| x=" + x;
	msg += ", y=" + y;
	msg += ", z=" + z;
	return msg;
	}

	public float dotProduct(Vector3 v) {
	return x * v.x + y * v.y + z * v.z;
	}

	public Vector3 times(float val) {
	return new Vector3(timeMillisSinceBoot, x * val, y * val, z * val);
	}

	public Vector3 plus(Vector3 v) {
	return new Vector3(v.timeMillisSinceBoot, x + v.x, y + v.y, z + v.z);
	}

	public Vector3 minus(Vector3 v) {
	return new Vector3(v.timeMillisSinceBoot, x - v.x, y - v.y, z - v.z);
	}
	}

	/**
	* Maintains running statistics on the signal revelant to AnyMotion detection, including:
	* <ul>
	* <li>running average.
	* <li>running sum-of-squared-errors as the energy of the signal derivative.
	* <ul>
	*/
	private static class RunningSignalStats {
	Vector3 previousVector;
	Vector3 currentVector;
	Vector3 runningSum;
	float energy;
	int sampleCount;

	public RunningSignalStats() {
	reset();
	}

	public void reset() {
	previousVector = null;
	currentVector = null;
	runningSum = new Vector3(0, 0, 0, 0);
	energy = 0;
	sampleCount = 0;
	}

	/**
	* Apply a 3D vector v as the next element in the running SSE.
	*/
	public void accumulate(Vector3 v) {
	if (v == null) {
	if (DEBUG) Slog.i(TAG, "Cannot accumulate a null vector.");
	return;
	}
	sampleCount++;
	runningSum = runningSum.plus(v);
	previousVector = currentVector;
	currentVector = v;
	if (previousVector != null) {
	Vector3 dv = currentVector.minus(previousVector);
	float incrementalEnergy = dv.x * dv.x + dv.y * dv.y + dv.z * dv.z;
	energy += incrementalEnergy;
	if (DEBUG) Slog.i(TAG, "Accumulated vector " + currentVector.toString() +
	", runningSum = " + runningSum.toString() +
	", incrementalEnergy = " + incrementalEnergy +
	", energy = " + energy);
	}
	}

	public Vector3 getRunningAverage() {
	if (sampleCount > 0) {
	return runningSum.times((float)(1.0f / sampleCount));
	}
	return null;
	}

	public float getEnergy() {
	return energy;
	}

	public int getSampleCount() {
	return sampleCount;
	}

	@Override
	public String toString() {
	String msg = "";
	String currentVectorString = (currentVector == null) ?
	"null" : currentVector.toString();
	String previousVectorString = (previousVector == null) ?
	"null" : previousVector.toString();
	msg += "previousVector = " + previousVectorString;
	msg += ", currentVector = " + currentVectorString;
	msg += ", sampleCount = " + sampleCount;
	msg += ", energy = " + energy;
	return msg;
	}
	}
	}