1 /* 2 * Copyright (C) 2015 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package com.android.server; 18 19 import android.hardware.Sensor; 20 import android.hardware.SensorEvent; 21 import android.hardware.SensorEventListener; 22 import android.hardware.SensorManager; 23 import android.os.Handler; 24 import android.os.Message; 25 import android.os.PowerManager; 26 import android.os.SystemClock; 27 import android.util.Slog; 28 29 import java.lang.Float; 30 31 /** 32 * Determines if the device has been set upon a stationary object. 33 */ 34 public class AnyMotionDetector { 35 interface DeviceIdleCallback { onAnyMotionResult(int result)36 public void onAnyMotionResult(int result); 37 } 38 39 private static final String TAG = "AnyMotionDetector"; 40 41 private static final boolean DEBUG = false; 42 43 /** Stationary status is unknown due to insufficient orientation measurements. */ 44 public static final int RESULT_UNKNOWN = -1; 45 46 /** Device is stationary, e.g. still on a table. */ 47 public static final int RESULT_STATIONARY = 0; 48 49 /** Device has been moved. */ 50 public static final int RESULT_MOVED = 1; 51 52 /** Orientation measurements are being performed or are planned. */ 53 private static final int STATE_INACTIVE = 0; 54 55 /** No orientation measurements are being performed or are planned. */ 56 private static final int STATE_ACTIVE = 1; 57 58 /** Current measurement state. */ 59 private int mState; 60 61 /** Threshold energy above which the device is considered moving. */ 62 private final float THRESHOLD_ENERGY = 5f; 63 64 /** The duration of the accelerometer orientation measurement. */ 65 private static final long ORIENTATION_MEASUREMENT_DURATION_MILLIS = 2500; 66 67 /** The maximum duration we will collect accelerometer data. */ 68 private static final long ACCELEROMETER_DATA_TIMEOUT_MILLIS = 3000; 69 70 /** The interval between accelerometer orientation measurements. */ 71 private static final long ORIENTATION_MEASUREMENT_INTERVAL_MILLIS = 5000; 72 73 /** The maximum duration we will hold a wakelock to determine stationary status. */ 74 private static final long WAKELOCK_TIMEOUT_MILLIS = 30000; 75 76 /** 77 * The duration in milliseconds after which an orientation measurement is considered 78 * too stale to be used. 79 */ 80 private static final int STALE_MEASUREMENT_TIMEOUT_MILLIS = 2 * 60 * 1000; 81 82 /** The accelerometer sampling interval. */ 83 private static final int SAMPLING_INTERVAL_MILLIS = 40; 84 85 private final Handler mHandler; 86 private final Object mLock = new Object(); 87 private Sensor mAccelSensor; 88 private SensorManager mSensorManager; 89 private PowerManager.WakeLock mWakeLock; 90 91 /** Threshold angle in degrees beyond which the device is considered moving. */ 92 private final float mThresholdAngle; 93 94 /** The minimum number of samples required to detect AnyMotion. */ 95 private int mNumSufficientSamples; 96 97 /** True if an orientation measurement is in progress. */ 98 private boolean mMeasurementInProgress; 99 100 /** The most recent gravity vector. */ 101 private Vector3 mCurrentGravityVector = null; 102 103 /** The second most recent gravity vector. */ 104 private Vector3 mPreviousGravityVector = null; 105 106 /** Running sum of squared errors. */ 107 private RunningSignalStats mRunningStats; 108 109 private DeviceIdleCallback mCallback = null; 110 AnyMotionDetector(PowerManager pm, Handler handler, SensorManager sm, DeviceIdleCallback callback, float thresholdAngle)111 public AnyMotionDetector(PowerManager pm, Handler handler, SensorManager sm, 112 DeviceIdleCallback callback, float thresholdAngle) { 113 if (DEBUG) Slog.d(TAG, "AnyMotionDetector instantiated."); 114 synchronized (mLock) { 115 mWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, TAG); 116 mWakeLock.setReferenceCounted(false); 117 mHandler = handler; 118 mSensorManager = sm; 119 mAccelSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER); 120 mMeasurementInProgress = false; 121 mState = STATE_INACTIVE; 122 mCallback = callback; 123 mThresholdAngle = thresholdAngle; 124 mRunningStats = new RunningSignalStats(); 125 mNumSufficientSamples = (int) Math.ceil( 126 ((double)ORIENTATION_MEASUREMENT_DURATION_MILLIS / SAMPLING_INTERVAL_MILLIS)); 127 if (DEBUG) Slog.d(TAG, "mNumSufficientSamples = " + mNumSufficientSamples); 128 } 129 } 130 131 /* 132 * Acquire accel data until we determine AnyMotion status. 133 */ checkForAnyMotion()134 public void checkForAnyMotion() { 135 if (DEBUG) { 136 Slog.d(TAG, "checkForAnyMotion(). mState = " + mState); 137 } 138 if (mState != STATE_ACTIVE) { 139 synchronized (mLock) { 140 mState = STATE_ACTIVE; 141 if (DEBUG) { 142 Slog.d(TAG, "Moved from STATE_INACTIVE to STATE_ACTIVE."); 143 } 144 mCurrentGravityVector = null; 145 mPreviousGravityVector = null; 146 mWakeLock.acquire(); 147 Message wakelockTimeoutMsg = Message.obtain(mHandler, mWakelockTimeout); 148 mHandler.sendMessageDelayed(wakelockTimeoutMsg, WAKELOCK_TIMEOUT_MILLIS); 149 startOrientationMeasurementLocked(); 150 } 151 } 152 } 153 stop()154 public void stop() { 155 synchronized (mLock) { 156 if (mState == STATE_ACTIVE) { 157 mState = STATE_INACTIVE; 158 if (DEBUG) Slog.d(TAG, "Moved from STATE_ACTIVE to STATE_INACTIVE."); 159 } 160 if (mMeasurementInProgress) { 161 mMeasurementInProgress = false; 162 mSensorManager.unregisterListener(mListener); 163 } 164 mHandler.removeCallbacks(mMeasurementTimeout); 165 mHandler.removeCallbacks(mSensorRestart); 166 mCurrentGravityVector = null; 167 mPreviousGravityVector = null; 168 if (mWakeLock.isHeld()) { 169 mWakeLock.release(); 170 mHandler.removeCallbacks(mWakelockTimeout); 171 } 172 } 173 } 174 startOrientationMeasurementLocked()175 private void startOrientationMeasurementLocked() { 176 if (DEBUG) Slog.d(TAG, "startOrientationMeasurementLocked: mMeasurementInProgress=" + 177 mMeasurementInProgress + ", (mAccelSensor != null)=" + (mAccelSensor != null)); 178 if (!mMeasurementInProgress && mAccelSensor != null) { 179 if (mSensorManager.registerListener(mListener, mAccelSensor, 180 SAMPLING_INTERVAL_MILLIS * 1000)) { 181 mMeasurementInProgress = true; 182 mRunningStats.reset(); 183 } 184 Message measurementTimeoutMsg = Message.obtain(mHandler, mMeasurementTimeout); 185 mHandler.sendMessageDelayed(measurementTimeoutMsg, ACCELEROMETER_DATA_TIMEOUT_MILLIS); 186 } 187 } 188 stopOrientationMeasurementLocked()189 private int stopOrientationMeasurementLocked() { 190 if (DEBUG) Slog.d(TAG, "stopOrientationMeasurement. mMeasurementInProgress=" + 191 mMeasurementInProgress); 192 int status = RESULT_UNKNOWN; 193 if (mMeasurementInProgress) { 194 mSensorManager.unregisterListener(mListener); 195 mHandler.removeCallbacks(mMeasurementTimeout); 196 mMeasurementInProgress = false; 197 mPreviousGravityVector = mCurrentGravityVector; 198 mCurrentGravityVector = mRunningStats.getRunningAverage(); 199 if (mRunningStats.getSampleCount() == 0) { 200 Slog.w(TAG, "No accelerometer data acquired for orientation measurement."); 201 } 202 if (DEBUG) { 203 Slog.d(TAG, "mRunningStats = " + mRunningStats.toString()); 204 String currentGravityVectorString = (mCurrentGravityVector == null) ? 205 "null" : mCurrentGravityVector.toString(); 206 String previousGravityVectorString = (mPreviousGravityVector == null) ? 207 "null" : mPreviousGravityVector.toString(); 208 Slog.d(TAG, "mCurrentGravityVector = " + currentGravityVectorString); 209 Slog.d(TAG, "mPreviousGravityVector = " + previousGravityVectorString); 210 } 211 mRunningStats.reset(); 212 status = getStationaryStatus(); 213 if (DEBUG) Slog.d(TAG, "getStationaryStatus() returned " + status); 214 if (status != RESULT_UNKNOWN) { 215 if (mWakeLock.isHeld()) { 216 mWakeLock.release(); 217 mHandler.removeCallbacks(mWakelockTimeout); 218 } 219 if (DEBUG) { 220 Slog.d(TAG, "Moved from STATE_ACTIVE to STATE_INACTIVE. status = " + status); 221 } 222 mState = STATE_INACTIVE; 223 } else { 224 /* 225 * Unknown due to insufficient measurements. Schedule another orientation 226 * measurement. 227 */ 228 if (DEBUG) Slog.d(TAG, "stopOrientationMeasurementLocked(): another measurement" + 229 " scheduled in " + ORIENTATION_MEASUREMENT_INTERVAL_MILLIS + 230 " milliseconds."); 231 Message msg = Message.obtain(mHandler, mSensorRestart); 232 mHandler.sendMessageDelayed(msg, ORIENTATION_MEASUREMENT_INTERVAL_MILLIS); 233 } 234 } 235 return status; 236 } 237 238 /* 239 * Updates mStatus to the current AnyMotion status. 240 */ getStationaryStatus()241 public int getStationaryStatus() { 242 if ((mPreviousGravityVector == null) || (mCurrentGravityVector == null)) { 243 return RESULT_UNKNOWN; 244 } 245 Vector3 previousGravityVectorNormalized = mPreviousGravityVector.normalized(); 246 Vector3 currentGravityVectorNormalized = mCurrentGravityVector.normalized(); 247 float angle = previousGravityVectorNormalized.angleBetween(currentGravityVectorNormalized); 248 if (DEBUG) Slog.d(TAG, "getStationaryStatus: angle = " + angle 249 + " energy = " + mRunningStats.getEnergy()); 250 if ((angle < mThresholdAngle) && (mRunningStats.getEnergy() < THRESHOLD_ENERGY)) { 251 return RESULT_STATIONARY; 252 } else if (Float.isNaN(angle)) { 253 /** 254 * Floating point rounding errors have caused the angle calcuation's dot product to 255 * exceed 1.0. In such case, we report RESULT_MOVED to prevent devices from rapidly 256 * retrying this measurement. 257 */ 258 return RESULT_MOVED; 259 } 260 long diffTime = mCurrentGravityVector.timeMillisSinceBoot - 261 mPreviousGravityVector.timeMillisSinceBoot; 262 if (diffTime > STALE_MEASUREMENT_TIMEOUT_MILLIS) { 263 if (DEBUG) Slog.d(TAG, "getStationaryStatus: mPreviousGravityVector is too stale at " + 264 diffTime + " ms ago. Returning RESULT_UNKNOWN."); 265 return RESULT_UNKNOWN; 266 } 267 return RESULT_MOVED; 268 } 269 270 private final SensorEventListener mListener = new SensorEventListener() { 271 @Override 272 public void onSensorChanged(SensorEvent event) { 273 int status = RESULT_UNKNOWN; 274 synchronized (mLock) { 275 Vector3 accelDatum = new Vector3(SystemClock.elapsedRealtime(), event.values[0], 276 event.values[1], event.values[2]); 277 mRunningStats.accumulate(accelDatum); 278 279 // If we have enough samples, stop accelerometer data acquisition. 280 if (mRunningStats.getSampleCount() >= mNumSufficientSamples) { 281 status = stopOrientationMeasurementLocked(); 282 } 283 } 284 if (status != RESULT_UNKNOWN) { 285 mHandler.removeCallbacks(mWakelockTimeout); 286 mCallback.onAnyMotionResult(status); 287 } 288 } 289 290 @Override 291 public void onAccuracyChanged(Sensor sensor, int accuracy) { 292 } 293 }; 294 295 private final Runnable mSensorRestart = new Runnable() { 296 @Override 297 public void run() { 298 synchronized (mLock) { 299 startOrientationMeasurementLocked(); 300 } 301 } 302 }; 303 304 private final Runnable mMeasurementTimeout = new Runnable() { 305 @Override 306 public void run() { 307 int status = RESULT_UNKNOWN; 308 synchronized (mLock) { 309 if (DEBUG) Slog.i(TAG, "mMeasurementTimeout. Failed to collect sufficient accel " + 310 "data within " + ACCELEROMETER_DATA_TIMEOUT_MILLIS + " ms. Stopping " + 311 "orientation measurement."); 312 status = stopOrientationMeasurementLocked(); 313 } 314 if (status != RESULT_UNKNOWN) { 315 mHandler.removeCallbacks(mWakelockTimeout); 316 mCallback.onAnyMotionResult(status); 317 } 318 } 319 }; 320 321 private final Runnable mWakelockTimeout = new Runnable() { 322 @Override 323 public void run() { 324 synchronized (mLock) { 325 stop(); 326 } 327 } 328 }; 329 330 /** 331 * A timestamped three dimensional vector and some vector operations. 332 */ 333 public static final class Vector3 { 334 public long timeMillisSinceBoot; 335 public float x; 336 public float y; 337 public float z; 338 Vector3(long timeMillisSinceBoot, float x, float y, float z)339 public Vector3(long timeMillisSinceBoot, float x, float y, float z) { 340 this.timeMillisSinceBoot = timeMillisSinceBoot; 341 this.x = x; 342 this.y = y; 343 this.z = z; 344 } 345 norm()346 public float norm() { 347 return (float) Math.sqrt(dotProduct(this)); 348 } 349 normalized()350 public Vector3 normalized() { 351 float mag = norm(); 352 return new Vector3(timeMillisSinceBoot, x / mag, y / mag, z / mag); 353 } 354 355 /** 356 * Returns the angle between this 3D vector and another given 3D vector. 357 * Assumes both have already been normalized. 358 * 359 * @param other The other Vector3 vector. 360 * @return angle between this vector and the other given one. 361 */ angleBetween(Vector3 other)362 public float angleBetween(Vector3 other) { 363 Vector3 crossVector = cross(other); 364 float degrees = Math.abs((float)Math.toDegrees( 365 Math.atan2(crossVector.norm(), dotProduct(other)))); 366 Slog.d(TAG, "angleBetween: this = " + this.toString() + 367 ", other = " + other.toString() + ", degrees = " + degrees); 368 return degrees; 369 } 370 cross(Vector3 v)371 public Vector3 cross(Vector3 v) { 372 return new Vector3( 373 v.timeMillisSinceBoot, 374 y * v.z - z * v.y, 375 z * v.x - x * v.z, 376 x * v.y - y * v.x); 377 } 378 379 @Override toString()380 public String toString() { 381 String msg = ""; 382 msg += "timeMillisSinceBoot=" + timeMillisSinceBoot; 383 msg += " | x=" + x; 384 msg += ", y=" + y; 385 msg += ", z=" + z; 386 return msg; 387 } 388 dotProduct(Vector3 v)389 public float dotProduct(Vector3 v) { 390 return x * v.x + y * v.y + z * v.z; 391 } 392 times(float val)393 public Vector3 times(float val) { 394 return new Vector3(timeMillisSinceBoot, x * val, y * val, z * val); 395 } 396 plus(Vector3 v)397 public Vector3 plus(Vector3 v) { 398 return new Vector3(v.timeMillisSinceBoot, x + v.x, y + v.y, z + v.z); 399 } 400 minus(Vector3 v)401 public Vector3 minus(Vector3 v) { 402 return new Vector3(v.timeMillisSinceBoot, x - v.x, y - v.y, z - v.z); 403 } 404 } 405 406 /** 407 * Maintains running statistics on the signal revelant to AnyMotion detection, including: 408 * <ul> 409 * <li>running average. 410 * <li>running sum-of-squared-errors as the energy of the signal derivative. 411 * <ul> 412 */ 413 private static class RunningSignalStats { 414 Vector3 previousVector; 415 Vector3 currentVector; 416 Vector3 runningSum; 417 float energy; 418 int sampleCount; 419 RunningSignalStats()420 public RunningSignalStats() { 421 reset(); 422 } 423 reset()424 public void reset() { 425 previousVector = null; 426 currentVector = null; 427 runningSum = new Vector3(0, 0, 0, 0); 428 energy = 0; 429 sampleCount = 0; 430 } 431 432 /** 433 * Apply a 3D vector v as the next element in the running SSE. 434 */ accumulate(Vector3 v)435 public void accumulate(Vector3 v) { 436 if (v == null) { 437 if (DEBUG) Slog.i(TAG, "Cannot accumulate a null vector."); 438 return; 439 } 440 sampleCount++; 441 runningSum = runningSum.plus(v); 442 previousVector = currentVector; 443 currentVector = v; 444 if (previousVector != null) { 445 Vector3 dv = currentVector.minus(previousVector); 446 float incrementalEnergy = dv.x * dv.x + dv.y * dv.y + dv.z * dv.z; 447 energy += incrementalEnergy; 448 if (DEBUG) Slog.i(TAG, "Accumulated vector " + currentVector.toString() + 449 ", runningSum = " + runningSum.toString() + 450 ", incrementalEnergy = " + incrementalEnergy + 451 ", energy = " + energy); 452 } 453 } 454 getRunningAverage()455 public Vector3 getRunningAverage() { 456 if (sampleCount > 0) { 457 return runningSum.times((float)(1.0f / sampleCount)); 458 } 459 return null; 460 } 461 getEnergy()462 public float getEnergy() { 463 return energy; 464 } 465 getSampleCount()466 public int getSampleCount() { 467 return sampleCount; 468 } 469 470 @Override toString()471 public String toString() { 472 String msg = ""; 473 String currentVectorString = (currentVector == null) ? 474 "null" : currentVector.toString(); 475 String previousVectorString = (previousVector == null) ? 476 "null" : previousVector.toString(); 477 msg += "previousVector = " + previousVectorString; 478 msg += ", currentVector = " + currentVectorString; 479 msg += ", sampleCount = " + sampleCount; 480 msg += ", energy = " + energy; 481 return msg; 482 } 483 } 484 } 485