Phil Dubach | 15f91be | 2009-05-19 16:41:52 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2008 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 android.hardware.cts; |
| 18 | |
destradaa | a0b3bbc | 2014-09-03 14:08:00 -0700 | [diff] [blame] | 19 | import com.android.cts.util.TimeoutReq; |
Phil Dubach | 15f91be | 2009-05-19 16:41:52 -0700 | [diff] [blame] | 20 | |
destradaa | 4458c69 | 2014-10-15 12:42:29 -0700 | [diff] [blame] | 21 | import junit.framework.Assert; |
| 22 | |
Phil Dubach | 15f91be | 2009-05-19 16:41:52 -0700 | [diff] [blame] | 23 | import android.content.Context; |
Dylan Reid | 91e5244 | 2011-03-17 15:45:10 -0700 | [diff] [blame] | 24 | import android.content.pm.PackageManager; |
Phil Dubach | 15f91be | 2009-05-19 16:41:52 -0700 | [diff] [blame] | 25 | import android.hardware.Sensor; |
Jaikumar Ganesh | fde5af6 | 2013-03-01 13:34:10 -0800 | [diff] [blame] | 26 | import android.hardware.SensorEvent; |
| 27 | import android.hardware.SensorEventListener; |
Aravind Akella | 220386d | 2013-10-09 12:03:32 -0700 | [diff] [blame] | 28 | import android.hardware.SensorEventListener2; |
Phil Dubach | 15f91be | 2009-05-19 16:41:52 -0700 | [diff] [blame] | 29 | import android.hardware.SensorManager; |
Jaikumar Ganesh | fde5af6 | 2013-03-01 13:34:10 -0800 | [diff] [blame] | 30 | import android.hardware.TriggerEvent; |
| 31 | import android.hardware.TriggerEventListener; |
Aravind Akella | 946ee6b | 2015-07-31 13:40:08 -0700 | [diff] [blame] | 32 | import android.hardware.cts.helpers.SensorCtsHelper; |
destradaa | 4458c69 | 2014-10-15 12:42:29 -0700 | [diff] [blame] | 33 | import android.hardware.cts.helpers.SensorNotSupportedException; |
| 34 | import android.hardware.cts.helpers.SensorTestStateNotSupportedException; |
| 35 | import android.hardware.cts.helpers.TestSensorEnvironment; |
| 36 | import android.hardware.cts.helpers.TestSensorEventListener; |
| 37 | import android.hardware.cts.helpers.TestSensorManager; |
| 38 | import android.hardware.cts.helpers.sensoroperations.ParallelSensorOperation; |
| 39 | import android.hardware.cts.helpers.sensoroperations.TestSensorOperation; |
| 40 | import android.hardware.cts.helpers.sensorverification.EventGapVerification; |
| 41 | import android.hardware.cts.helpers.sensorverification.EventOrderingVerification; |
| 42 | import android.hardware.cts.helpers.sensorverification.EventTimestampSynchronizationVerification; |
Aravind Akella | bbc90db | 2013-10-23 18:20:02 -0700 | [diff] [blame] | 43 | import android.os.Handler; |
| 44 | import android.os.HandlerThread; |
Aravind Akella | 5e68514 | 2014-06-06 11:58:12 -0700 | [diff] [blame] | 45 | import android.os.PowerManager; |
Aravind Akella | 32af558 | 2014-07-31 15:50:47 -0700 | [diff] [blame] | 46 | import android.os.SystemClock; |
Aravind Akella | cfea6df | 2014-05-29 18:28:44 -0700 | [diff] [blame] | 47 | import android.util.Log; |
Phil Dubach | 15f91be | 2009-05-19 16:41:52 -0700 | [diff] [blame] | 48 | |
destradaa | 4458c69 | 2014-10-15 12:42:29 -0700 | [diff] [blame] | 49 | import java.util.ArrayList; |
destradaa | a0b3bbc | 2014-09-03 14:08:00 -0700 | [diff] [blame] | 50 | import java.util.List; |
Peng Xu | 7a6fb7b | 2015-05-20 14:24:12 -0700 | [diff] [blame] | 51 | import java.util.Random; |
Aravind Akella | 490e9b8 | 2015-01-29 17:41:07 -0800 | [diff] [blame] | 52 | import java.util.concurrent.CountDownLatch; |
destradaa | a0b3bbc | 2014-09-03 14:08:00 -0700 | [diff] [blame] | 53 | import java.util.concurrent.TimeUnit; |
Aravind Akella | 8b91fd4 | 2014-08-26 16:57:31 -0700 | [diff] [blame] | 54 | |
destradaa | a0b3bbc | 2014-09-03 14:08:00 -0700 | [diff] [blame] | 55 | public class SensorTest extends SensorTestCase { |
Aravind Akella | cfea6df | 2014-05-29 18:28:44 -0700 | [diff] [blame] | 56 | private static final String TAG = "SensorTest"; |
destradaa | 4458c69 | 2014-10-15 12:42:29 -0700 | [diff] [blame] | 57 | |
Aravind Akella | cfea6df | 2014-05-29 18:28:44 -0700 | [diff] [blame] | 58 | // Test only SDK defined sensors. Any sensors with type > 100 are ignored. |
Aravind Akella | 8b91fd4 | 2014-08-26 16:57:31 -0700 | [diff] [blame] | 59 | private static final int MAX_OFFICIAL_ANDROID_SENSOR_TYPE = 100; |
destradaa | 4458c69 | 2014-10-15 12:42:29 -0700 | [diff] [blame] | 60 | |
Aravind Akella | 5e68514 | 2014-06-06 11:58:12 -0700 | [diff] [blame] | 61 | private PowerManager.WakeLock mWakeLock; |
destradaa | 4458c69 | 2014-10-15 12:42:29 -0700 | [diff] [blame] | 62 | private SensorManager mSensorManager; |
Han, He | 8264309 | 2015-02-10 10:33:02 +0800 | [diff] [blame] | 63 | private TestSensorManager mTestSensorManager; |
destradaa | 4458c69 | 2014-10-15 12:42:29 -0700 | [diff] [blame] | 64 | private NullTriggerEventListener mNullTriggerEventListener; |
| 65 | private NullSensorEventListener mNullSensorEventListener; |
Han, He | 8264309 | 2015-02-10 10:33:02 +0800 | [diff] [blame] | 66 | private Sensor mTriggerSensor; |
destradaa | 4458c69 | 2014-10-15 12:42:29 -0700 | [diff] [blame] | 67 | private List<Sensor> mSensorList; |
Jaikumar Ganesh | fde5af6 | 2013-03-01 13:34:10 -0800 | [diff] [blame] | 68 | |
| 69 | @Override |
| 70 | protected void setUp() throws Exception { |
destradaa | 4458c69 | 2014-10-15 12:42:29 -0700 | [diff] [blame] | 71 | Context context = getContext(); |
| 72 | PowerManager pm = (PowerManager) context.getSystemService(Context.POWER_SERVICE); |
Aravind Akella | 5e68514 | 2014-06-06 11:58:12 -0700 | [diff] [blame] | 73 | mWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, TAG); |
destradaa | 4458c69 | 2014-10-15 12:42:29 -0700 | [diff] [blame] | 74 | |
| 75 | mSensorManager = (SensorManager) context.getSystemService(Context.SENSOR_SERVICE); |
| 76 | mNullTriggerEventListener = new NullTriggerEventListener(); |
| 77 | mNullSensorEventListener = new NullSensorEventListener(); |
| 78 | |
| 79 | mSensorList = mSensorManager.getSensorList(Sensor.TYPE_ALL); |
| 80 | assertNotNull("SensorList was null.", mSensorList); |
| 81 | if (mSensorList.isEmpty()) { |
| 82 | // several devices will not have sensors, so we need to skip the tests in those cases |
| 83 | throw new SensorTestStateNotSupportedException( |
| 84 | "Sensors are not available in the system."); |
| 85 | } |
| 86 | |
| 87 | mWakeLock.acquire(); |
Jaikumar Ganesh | fde5af6 | 2013-03-01 13:34:10 -0800 | [diff] [blame] | 88 | } |
Phil Dubach | 15f91be | 2009-05-19 16:41:52 -0700 | [diff] [blame] | 89 | |
destradaa | 4458c69 | 2014-10-15 12:42:29 -0700 | [diff] [blame] | 90 | @Override |
| 91 | protected void tearDown(){ |
Han, He | 8264309 | 2015-02-10 10:33:02 +0800 | [diff] [blame] | 92 | if (mSensorManager != null) { |
| 93 | // SensorManager will check listener and status, so just unregister listener |
| 94 | mSensorManager.unregisterListener(mNullSensorEventListener); |
| 95 | if (mTriggerSensor != null) { |
| 96 | mSensorManager.cancelTriggerSensor(mNullTriggerEventListener, mTriggerSensor); |
| 97 | mTriggerSensor = null; |
| 98 | } |
| 99 | } |
| 100 | |
| 101 | if (mTestSensorManager != null) { |
| 102 | mTestSensorManager.unregisterListener(); |
| 103 | mTestSensorManager = null; |
| 104 | } |
| 105 | |
destradaa | 4458c69 | 2014-10-15 12:42:29 -0700 | [diff] [blame] | 106 | if (mWakeLock != null && mWakeLock.isHeld()) { |
| 107 | mWakeLock.release(); |
| 108 | } |
| 109 | } |
| 110 | |
| 111 | @SuppressWarnings("deprecation") |
Phil Dubach | 15f91be | 2009-05-19 16:41:52 -0700 | [diff] [blame] | 112 | public void testSensorOperations() { |
| 113 | // Because we can't know every sensors unit details, so we can't assert |
| 114 | // get values with specified values. |
Phil Dubach | 15f91be | 2009-05-19 16:41:52 -0700 | [diff] [blame] | 115 | Sensor sensor = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER); |
Dylan Reid | 91e5244 | 2011-03-17 15:45:10 -0700 | [diff] [blame] | 116 | boolean hasAccelerometer = getContext().getPackageManager().hasSystemFeature( |
| 117 | PackageManager.FEATURE_SENSOR_ACCELEROMETER); |
| 118 | // accelerometer sensor is optional |
| 119 | if (hasAccelerometer) { |
| 120 | assertEquals(Sensor.TYPE_ACCELEROMETER, sensor.getType()); |
| 121 | assertSensorValues(sensor); |
| 122 | } else { |
| 123 | assertNull(sensor); |
| 124 | } |
Phil Dubach | 15f91be | 2009-05-19 16:41:52 -0700 | [diff] [blame] | 125 | |
Aravind Akella | 8d20ef6 | 2013-10-12 18:30:24 -0700 | [diff] [blame] | 126 | sensor = mSensorManager.getDefaultSensor(Sensor.TYPE_STEP_COUNTER); |
| 127 | boolean hasStepCounter = getContext().getPackageManager().hasSystemFeature( |
Aravind Akella | cfea6df | 2014-05-29 18:28:44 -0700 | [diff] [blame] | 128 | PackageManager.FEATURE_SENSOR_STEP_COUNTER); |
Aravind Akella | 8d20ef6 | 2013-10-12 18:30:24 -0700 | [diff] [blame] | 129 | // stepcounter sensor is optional |
| 130 | if (hasStepCounter) { |
| 131 | assertEquals(Sensor.TYPE_STEP_COUNTER, sensor.getType()); |
| 132 | assertSensorValues(sensor); |
| 133 | } else { |
| 134 | assertNull(sensor); |
| 135 | } |
| 136 | |
| 137 | sensor = mSensorManager.getDefaultSensor(Sensor.TYPE_STEP_DETECTOR); |
| 138 | boolean hasStepDetector = getContext().getPackageManager().hasSystemFeature( |
Aravind Akella | cfea6df | 2014-05-29 18:28:44 -0700 | [diff] [blame] | 139 | PackageManager.FEATURE_SENSOR_STEP_DETECTOR); |
Aravind Akella | 8d20ef6 | 2013-10-12 18:30:24 -0700 | [diff] [blame] | 140 | // stepdetector sensor is optional |
| 141 | if (hasStepDetector) { |
| 142 | assertEquals(Sensor.TYPE_STEP_DETECTOR, sensor.getType()); |
| 143 | assertSensorValues(sensor); |
| 144 | } else { |
| 145 | assertNull(sensor); |
| 146 | } |
| 147 | |
Vinod Krishnan | 20d6725 | 2014-04-30 11:12:01 -0700 | [diff] [blame] | 148 | sensor = mSensorManager.getDefaultSensor(Sensor.TYPE_HEART_RATE); |
| 149 | boolean hasHeartRate = getContext().getPackageManager().hasSystemFeature( |
| 150 | PackageManager.FEATURE_SENSOR_HEART_RATE); |
| 151 | // heartrate sensor is optional |
| 152 | if (hasHeartRate) { |
| 153 | assertEquals(Sensor.TYPE_HEART_RATE, sensor.getType()); |
| 154 | assertSensorValues(sensor); |
| 155 | } else { |
| 156 | assertNull(sensor); |
| 157 | } |
| 158 | |
Phil Dubach | 15f91be | 2009-05-19 16:41:52 -0700 | [diff] [blame] | 159 | sensor = mSensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD); |
Dylan Reid | 91e5244 | 2011-03-17 15:45:10 -0700 | [diff] [blame] | 160 | boolean hasCompass = getContext().getPackageManager().hasSystemFeature( |
| 161 | PackageManager.FEATURE_SENSOR_COMPASS); |
| 162 | // compass sensor is optional |
| 163 | if (hasCompass) { |
| 164 | assertEquals(Sensor.TYPE_MAGNETIC_FIELD, sensor.getType()); |
| 165 | assertSensorValues(sensor); |
| 166 | } else { |
| 167 | assertNull(sensor); |
| 168 | } |
Phil Dubach | 15f91be | 2009-05-19 16:41:52 -0700 | [diff] [blame] | 169 | |
| 170 | sensor = mSensorManager.getDefaultSensor(Sensor.TYPE_ORIENTATION); |
Dylan Reid | 91e5244 | 2011-03-17 15:45:10 -0700 | [diff] [blame] | 171 | // orientation sensor is required if the device can physically implement it |
| 172 | if (hasCompass && hasAccelerometer) { |
| 173 | assertEquals(Sensor.TYPE_ORIENTATION, sensor.getType()); |
| 174 | assertSensorValues(sensor); |
| 175 | } |
Phil Dubach | 15f91be | 2009-05-19 16:41:52 -0700 | [diff] [blame] | 176 | |
| 177 | sensor = mSensorManager.getDefaultSensor(Sensor.TYPE_TEMPERATURE); |
Brett Chabot | bc192a6 | 2009-09-17 19:25:33 -0700 | [diff] [blame] | 178 | // temperature sensor is optional |
| 179 | if (sensor != null) { |
| 180 | assertEquals(Sensor.TYPE_TEMPERATURE, sensor.getType()); |
| 181 | assertSensorValues(sensor); |
| 182 | } |
Phil Dubach | 15f91be | 2009-05-19 16:41:52 -0700 | [diff] [blame] | 183 | } |
| 184 | |
Aravind Akella | 1717afa | 2013-09-26 17:15:02 -0700 | [diff] [blame] | 185 | public void testValuesForAllSensors() { |
Aravind Akella | 8b91fd4 | 2014-08-26 16:57:31 -0700 | [diff] [blame] | 186 | for (Sensor sensor : mSensorList) { |
| 187 | assertSensorValues(sensor); |
| 188 | } |
| 189 | } |
| 190 | |
| 191 | private void hasOnlyOneWakeUpSensorOrEmpty(List<Sensor> sensors) { |
| 192 | if (sensors == null || sensors.isEmpty()) return; |
| 193 | if (sensors.size() > 1) { |
| 194 | fail("More than one " + sensors.get(0).getName() + " defined."); |
| 195 | return; |
| 196 | } |
| 197 | assertTrue(sensors.get(0).getName() + " defined as non-wake-up sensor", |
| 198 | sensors.get(0).isWakeUpSensor()); |
Aravind Akella | 8b91fd4 | 2014-08-26 16:57:31 -0700 | [diff] [blame] | 199 | } |
| 200 | |
| 201 | // Some sensors like proximity, significant motion etc. are defined as wake-up sensors by |
| 202 | // default. Check if the wake-up flag is set correctly. |
| 203 | public void testWakeUpFlags() { |
| 204 | final int TYPE_WAKE_GESTURE = 23; |
| 205 | final int TYPE_GLANCE_GESTURE = 24; |
| 206 | final int TYPE_PICK_UP_GESTURE = 25; |
| 207 | |
| 208 | hasOnlyOneWakeUpSensorOrEmpty(mSensorManager.getSensorList(Sensor.TYPE_SIGNIFICANT_MOTION)); |
| 209 | hasOnlyOneWakeUpSensorOrEmpty(mSensorManager.getSensorList(TYPE_WAKE_GESTURE)); |
| 210 | hasOnlyOneWakeUpSensorOrEmpty(mSensorManager.getSensorList(TYPE_GLANCE_GESTURE)); |
| 211 | hasOnlyOneWakeUpSensorOrEmpty(mSensorManager.getSensorList(TYPE_PICK_UP_GESTURE)); |
| 212 | |
| 213 | List<Sensor> proximity_sensors = mSensorManager.getSensorList(Sensor.TYPE_PROXIMITY); |
| 214 | if (proximity_sensors.isEmpty()) return; |
| 215 | boolean hasWakeUpProximitySensor = false; |
| 216 | for (Sensor sensor : proximity_sensors) { |
| 217 | if (sensor.isWakeUpSensor()) { |
| 218 | hasWakeUpProximitySensor = true; |
| 219 | break; |
| 220 | } |
| 221 | } |
| 222 | assertTrue("No wake-up proximity sensors implemented", hasWakeUpProximitySensor); |
| 223 | } |
| 224 | |
| 225 | public void testGetDefaultSensorWithWakeUpFlag() { |
| 226 | // With wake-up flags set to false, the sensor returned should be a non wake-up sensor. |
| 227 | for (Sensor sensor : mSensorList) { |
| 228 | Sensor curr_sensor = mSensorManager.getDefaultSensor(sensor.getType(), false); |
| 229 | if (curr_sensor != null) { |
| 230 | assertFalse("getDefaultSensor wakeup=false returns a wake-up sensor" + |
| 231 | curr_sensor.getName(), |
| 232 | curr_sensor.isWakeUpSensor()); |
| 233 | } |
| 234 | |
| 235 | curr_sensor = mSensorManager.getDefaultSensor(sensor.getType(), true); |
| 236 | if (curr_sensor != null) { |
| 237 | assertTrue("getDefaultSensor wake-up returns non wake sensor" + |
| 238 | curr_sensor.getName(), |
| 239 | curr_sensor.isWakeUpSensor()); |
| 240 | } |
| 241 | } |
| 242 | } |
| 243 | |
| 244 | public void testSensorStringTypes() { |
| 245 | for (Sensor sensor : mSensorList) { |
| 246 | if (sensor.getType() < MAX_OFFICIAL_ANDROID_SENSOR_TYPE && |
| 247 | !sensor.getStringType().startsWith("android.sensor.")) { |
| 248 | fail("StringType not set correctly for android defined sensor " + |
| 249 | sensor.getName() + " " + sensor.getStringType()); |
Aravind Akella | 1717afa | 2013-09-26 17:15:02 -0700 | [diff] [blame] | 250 | } |
| 251 | } |
| 252 | } |
| 253 | |
Jaikumar Ganesh | fde5af6 | 2013-03-01 13:34:10 -0800 | [diff] [blame] | 254 | public void testRequestTriggerWithNonTriggerSensor() { |
Han, He | 8264309 | 2015-02-10 10:33:02 +0800 | [diff] [blame] | 255 | mTriggerSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER); |
| 256 | if (mTriggerSensor == null) { |
destradaa | 4458c69 | 2014-10-15 12:42:29 -0700 | [diff] [blame] | 257 | throw new SensorNotSupportedException(Sensor.TYPE_ACCELEROMETER); |
Jaikumar Ganesh | fde5af6 | 2013-03-01 13:34:10 -0800 | [diff] [blame] | 258 | } |
Han, He | 8264309 | 2015-02-10 10:33:02 +0800 | [diff] [blame] | 259 | boolean result = mSensorManager.requestTriggerSensor(mNullTriggerEventListener, mTriggerSensor); |
destradaa | 4458c69 | 2014-10-15 12:42:29 -0700 | [diff] [blame] | 260 | assertFalse(result); |
Jaikumar Ganesh | fde5af6 | 2013-03-01 13:34:10 -0800 | [diff] [blame] | 261 | } |
| 262 | |
| 263 | public void testCancelTriggerWithNonTriggerSensor() { |
Han, He | 8264309 | 2015-02-10 10:33:02 +0800 | [diff] [blame] | 264 | mTriggerSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER); |
| 265 | if (mTriggerSensor == null) { |
destradaa | 4458c69 | 2014-10-15 12:42:29 -0700 | [diff] [blame] | 266 | throw new SensorNotSupportedException(Sensor.TYPE_ACCELEROMETER); |
Jaikumar Ganesh | fde5af6 | 2013-03-01 13:34:10 -0800 | [diff] [blame] | 267 | } |
Han, He | 8264309 | 2015-02-10 10:33:02 +0800 | [diff] [blame] | 268 | boolean result = mSensorManager.cancelTriggerSensor(mNullTriggerEventListener, mTriggerSensor); |
destradaa | 4458c69 | 2014-10-15 12:42:29 -0700 | [diff] [blame] | 269 | assertFalse(result); |
Jaikumar Ganesh | fde5af6 | 2013-03-01 13:34:10 -0800 | [diff] [blame] | 270 | } |
| 271 | |
| 272 | public void testRegisterWithTriggerSensor() { |
| 273 | Sensor sensor = mSensorManager.getDefaultSensor(Sensor.TYPE_SIGNIFICANT_MOTION); |
destradaa | 4458c69 | 2014-10-15 12:42:29 -0700 | [diff] [blame] | 274 | if (sensor == null) { |
| 275 | throw new SensorNotSupportedException(Sensor.TYPE_SIGNIFICANT_MOTION); |
Jaikumar Ganesh | fde5af6 | 2013-03-01 13:34:10 -0800 | [diff] [blame] | 276 | } |
destradaa | 4458c69 | 2014-10-15 12:42:29 -0700 | [diff] [blame] | 277 | boolean result = mSensorManager.registerListener( |
| 278 | mNullSensorEventListener, |
| 279 | sensor, |
| 280 | SensorManager.SENSOR_DELAY_NORMAL); |
| 281 | assertFalse(result); |
Jaikumar Ganesh | fde5af6 | 2013-03-01 13:34:10 -0800 | [diff] [blame] | 282 | } |
| 283 | |
| 284 | public void testRegisterTwiceWithSameSensor() { |
| 285 | Sensor sensor = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER); |
destradaa | 4458c69 | 2014-10-15 12:42:29 -0700 | [diff] [blame] | 286 | if (sensor == null) { |
| 287 | throw new SensorNotSupportedException(Sensor.TYPE_ACCELEROMETER); |
Jaikumar Ganesh | fde5af6 | 2013-03-01 13:34:10 -0800 | [diff] [blame] | 288 | } |
destradaa | 4458c69 | 2014-10-15 12:42:29 -0700 | [diff] [blame] | 289 | |
| 290 | boolean result = mSensorManager.registerListener(mNullSensorEventListener, sensor, |
| 291 | SensorManager.SENSOR_DELAY_NORMAL); |
| 292 | assertTrue(result); |
| 293 | |
| 294 | result = mSensorManager.registerListener(mNullSensorEventListener, sensor, |
| 295 | SensorManager.SENSOR_DELAY_NORMAL); |
| 296 | assertFalse(result); |
Jaikumar Ganesh | fde5af6 | 2013-03-01 13:34:10 -0800 | [diff] [blame] | 297 | } |
| 298 | |
destradaa | 4458c69 | 2014-10-15 12:42:29 -0700 | [diff] [blame] | 299 | // TODO: remove when parametized tests are supported and EventTimestampSynchronization |
| 300 | // verification is added to default verifications |
Aravind Akella | 8b91fd4 | 2014-08-26 16:57:31 -0700 | [diff] [blame] | 301 | @TimeoutReq(minutes=60) |
Aravind Akella | 32af558 | 2014-07-31 15:50:47 -0700 | [diff] [blame] | 302 | public void testSensorTimeStamps() throws Exception { |
destradaa | 4458c69 | 2014-10-15 12:42:29 -0700 | [diff] [blame] | 303 | ArrayList<Throwable> errorsFound = new ArrayList<>(); |
| 304 | for (Sensor sensor : mSensorList) { |
| 305 | // test both continuous and batching mode sensors |
| 306 | verifyLongActivation(sensor, 0 /* maxReportLatencyUs */, errorsFound); |
| 307 | verifyLongActivation(sensor, (int) TimeUnit.SECONDS.toMicros(10), errorsFound); |
Aravind Akella | 32af558 | 2014-07-31 15:50:47 -0700 | [diff] [blame] | 308 | } |
destradaa | 4458c69 | 2014-10-15 12:42:29 -0700 | [diff] [blame] | 309 | assertOnErrors(errorsFound); |
Aravind Akella | 32af558 | 2014-07-31 15:50:47 -0700 | [diff] [blame] | 310 | } |
| 311 | |
destradaa | 4458c69 | 2014-10-15 12:42:29 -0700 | [diff] [blame] | 312 | // TODO: remove when parameterized tests are supported (see SensorBatchingTests.java) |
Aravind Akella | a8884ea | 2014-09-26 21:07:02 -0700 | [diff] [blame] | 313 | @TimeoutReq(minutes=20) |
Aravind Akella | 1717afa | 2013-09-26 17:15:02 -0700 | [diff] [blame] | 314 | public void testBatchAndFlush() throws Exception { |
Aravind Akella | 946ee6b | 2015-07-31 13:40:08 -0700 | [diff] [blame] | 315 | SensorCtsHelper.sleep(3, TimeUnit.SECONDS); |
destradaa | 4458c69 | 2014-10-15 12:42:29 -0700 | [diff] [blame] | 316 | ArrayList<Throwable> errorsFound = new ArrayList<>(); |
| 317 | for (Sensor sensor : mSensorList) { |
| 318 | verifyRegisterListenerCallFlush(sensor, null /* handler */, errorsFound); |
Aravind Akella | 1717afa | 2013-09-26 17:15:02 -0700 | [diff] [blame] | 319 | } |
destradaa | 4458c69 | 2014-10-15 12:42:29 -0700 | [diff] [blame] | 320 | assertOnErrors(errorsFound); |
Aravind Akella | 1717afa | 2013-09-26 17:15:02 -0700 | [diff] [blame] | 321 | } |
| 322 | |
destradaa | 4458c69 | 2014-10-15 12:42:29 -0700 | [diff] [blame] | 323 | /** |
| 324 | * Verifies that sensor events arrive in the given message queue (Handler). |
| 325 | */ |
Aravind Akella | 8b91fd4 | 2014-08-26 16:57:31 -0700 | [diff] [blame] | 326 | @TimeoutReq(minutes=10) |
Aravind Akella | bbc90db | 2013-10-23 18:20:02 -0700 | [diff] [blame] | 327 | public void testBatchAndFlushWithHandler() throws Exception { |
Aravind Akella | 946ee6b | 2015-07-31 13:40:08 -0700 | [diff] [blame] | 328 | SensorCtsHelper.sleep(3, TimeUnit.SECONDS); |
destradaa | 4458c69 | 2014-10-15 12:42:29 -0700 | [diff] [blame] | 329 | Sensor sensor = null; |
| 330 | for (Sensor s : mSensorList) { |
| 331 | if (s.getReportingMode() == Sensor.REPORTING_MODE_CONTINUOUS) { |
| 332 | sensor = s; |
| 333 | break; |
Aravind Akella | cfea6df | 2014-05-29 18:28:44 -0700 | [diff] [blame] | 334 | } |
Aravind Akella | bbc90db | 2013-10-23 18:20:02 -0700 | [diff] [blame] | 335 | } |
destradaa | 4458c69 | 2014-10-15 12:42:29 -0700 | [diff] [blame] | 336 | if (sensor == null) { |
| 337 | throw new SensorTestStateNotSupportedException( |
| 338 | "There are no Continuous sensors in the device."); |
| 339 | } |
| 340 | |
| 341 | TestSensorEnvironment environment = new TestSensorEnvironment( |
| 342 | getContext(), |
| 343 | sensor, |
| 344 | SensorManager.SENSOR_DELAY_FASTEST, |
| 345 | (int) TimeUnit.SECONDS.toMicros(5)); |
Han, He | 8264309 | 2015-02-10 10:33:02 +0800 | [diff] [blame] | 346 | mTestSensorManager = new TestSensorManager(environment); |
destradaa | 4458c69 | 2014-10-15 12:42:29 -0700 | [diff] [blame] | 347 | |
| 348 | HandlerThread handlerThread = new HandlerThread("sensorThread"); |
| 349 | handlerThread.start(); |
| 350 | Handler handler = new Handler(handlerThread.getLooper()); |
destradaa | cbb8c00 | 2014-12-12 17:31:16 -0800 | [diff] [blame] | 351 | TestSensorEventListener listener = new TestSensorEventListener(environment, handler); |
destradaa | 4458c69 | 2014-10-15 12:42:29 -0700 | [diff] [blame] | 352 | |
Han, He | 8264309 | 2015-02-10 10:33:02 +0800 | [diff] [blame] | 353 | CountDownLatch eventLatch = mTestSensorManager.registerListener(listener, 1); |
Aravind Akella | dbc95c5 | 2015-06-09 10:22:16 -0700 | [diff] [blame] | 354 | listener.waitForEvents(eventLatch, 1, true); |
Han, He | 8264309 | 2015-02-10 10:33:02 +0800 | [diff] [blame] | 355 | CountDownLatch flushLatch = mTestSensorManager.requestFlush(); |
Aravind Akella | dbc95c5 | 2015-06-09 10:22:16 -0700 | [diff] [blame] | 356 | listener.waitForFlushComplete(flushLatch, true); |
destradaa | 4458c69 | 2014-10-15 12:42:29 -0700 | [diff] [blame] | 357 | listener.assertEventsReceivedInHandler(); |
Aravind Akella | bbc90db | 2013-10-23 18:20:02 -0700 | [diff] [blame] | 358 | } |
| 359 | |
Peng Xu | 7a6fb7b | 2015-05-20 14:24:12 -0700 | [diff] [blame] | 360 | /** |
| 361 | * Explicit testing the SensorManager.registerListener(SensorEventListener, Sensor, int, int). |
| 362 | */ |
| 363 | @TimeoutReq(minutes=10) |
| 364 | public void testBatchAndFlushUseDefaultHandler() throws Exception { |
Aravind Akella | 946ee6b | 2015-07-31 13:40:08 -0700 | [diff] [blame] | 365 | SensorCtsHelper.sleep(3, TimeUnit.SECONDS); |
Peng Xu | 7a6fb7b | 2015-05-20 14:24:12 -0700 | [diff] [blame] | 366 | Sensor sensor = null; |
| 367 | for (Sensor s : mSensorList) { |
| 368 | if (s.getReportingMode() == Sensor.REPORTING_MODE_CONTINUOUS) { |
| 369 | sensor = s; |
| 370 | break; |
| 371 | } |
| 372 | } |
| 373 | if (sensor == null) { |
| 374 | throw new SensorTestStateNotSupportedException( |
| 375 | "There are no Continuous sensors in the device."); |
| 376 | } |
| 377 | |
| 378 | TestSensorEnvironment environment = new TestSensorEnvironment( |
| 379 | getContext(), |
| 380 | sensor, |
| 381 | SensorManager.SENSOR_DELAY_FASTEST, |
| 382 | (int) TimeUnit.SECONDS.toMicros(5)); |
| 383 | mTestSensorManager = new TestSensorManager(environment); |
| 384 | |
| 385 | TestSensorEventListener listener = new TestSensorEventListener(environment, null); |
| 386 | |
| 387 | // specifyHandler <= false, use the SensorManager API without Handler parameter |
| 388 | CountDownLatch eventLatch = mTestSensorManager.registerListener(listener, 1, false); |
Aravind Akella | dbc95c5 | 2015-06-09 10:22:16 -0700 | [diff] [blame] | 389 | listener.waitForEvents(eventLatch, 1, true); |
Peng Xu | 7a6fb7b | 2015-05-20 14:24:12 -0700 | [diff] [blame] | 390 | CountDownLatch flushLatch = mTestSensorManager.requestFlush(); |
Aravind Akella | dbc95c5 | 2015-06-09 10:22:16 -0700 | [diff] [blame] | 391 | listener.waitForFlushComplete(flushLatch, true); |
Peng Xu | 7a6fb7b | 2015-05-20 14:24:12 -0700 | [diff] [blame] | 392 | listener.assertEventsReceivedInHandler(); |
| 393 | } |
| 394 | |
destradaa | 4458c69 | 2014-10-15 12:42:29 -0700 | [diff] [blame] | 395 | // TODO: after L release move to SensorBatchingTests and run in all sensors with default |
| 396 | // verifications enabled |
Peng Xu | 0c8aadf | 2015-06-03 20:23:36 -0700 | [diff] [blame] | 397 | public void testBatchAndFlushWithMultipleSensors() throws Exception { |
Aravind Akella | 946ee6b | 2015-07-31 13:40:08 -0700 | [diff] [blame] | 398 | SensorCtsHelper.sleep(3, TimeUnit.SECONDS); |
destradaa | 4458c69 | 2014-10-15 12:42:29 -0700 | [diff] [blame] | 399 | final int maxSensors = 3; |
| 400 | final int maxReportLatencyUs = (int) TimeUnit.SECONDS.toMicros(10); |
Aravind Akella | 828afa9 | 2014-11-14 17:52:15 -0800 | [diff] [blame] | 401 | List<Sensor> sensorsToTest = new ArrayList<Sensor>(); |
| 402 | for (Sensor sensor : mSensorList) { |
| 403 | if (sensor.getReportingMode() == Sensor.REPORTING_MODE_CONTINUOUS) { |
| 404 | sensorsToTest.add(sensor); |
Aravind Akella | cae9e02 | 2015-01-28 13:51:02 -0800 | [diff] [blame] | 405 | if (sensorsToTest.size() == maxSensors) break; |
Aravind Akella | 828afa9 | 2014-11-14 17:52:15 -0800 | [diff] [blame] | 406 | } |
| 407 | } |
Aravind Akella | 828afa9 | 2014-11-14 17:52:15 -0800 | [diff] [blame] | 408 | final int numSensorsToTest = sensorsToTest.size(); |
| 409 | if (numSensorsToTest == 0) { |
Aravind Akella | bbc90db | 2013-10-23 18:20:02 -0700 | [diff] [blame] | 410 | return; |
| 411 | } |
destradaa | 4458c69 | 2014-10-15 12:42:29 -0700 | [diff] [blame] | 412 | |
| 413 | StringBuilder builder = new StringBuilder(); |
| 414 | ParallelSensorOperation parallelSensorOperation = new ParallelSensorOperation(); |
Aravind Akella | cae9e02 | 2015-01-28 13:51:02 -0800 | [diff] [blame] | 415 | for (Sensor sensor : sensorsToTest) { |
| 416 | TestSensorEnvironment environment = new TestSensorEnvironment( |
| 417 | getContext(), |
| 418 | sensor, |
| 419 | shouldEmulateSensorUnderLoad(), |
| 420 | SensorManager.SENSOR_DELAY_FASTEST, |
| 421 | maxReportLatencyUs); |
| 422 | FlushExecutor executor = new FlushExecutor(environment, 500 /* eventCount */); |
| 423 | parallelSensorOperation.add(new TestSensorOperation(environment, executor)); |
| 424 | builder.append(sensor.getName()).append(", "); |
Aravind Akella | bbc90db | 2013-10-23 18:20:02 -0700 | [diff] [blame] | 425 | } |
Aravind Akella | bbc90db | 2013-10-23 18:20:02 -0700 | [diff] [blame] | 426 | |
destradaa | 4458c69 | 2014-10-15 12:42:29 -0700 | [diff] [blame] | 427 | Log.i(TAG, "Testing batch/flush for sensors: " + builder); |
destradaa | 24289b5 | 2014-10-20 11:41:00 -0700 | [diff] [blame] | 428 | parallelSensorOperation.execute(getCurrentTestNode()); |
Aravind Akella | bbc90db | 2013-10-23 18:20:02 -0700 | [diff] [blame] | 429 | } |
| 430 | |
Aravind Akella | 1717afa | 2013-09-26 17:15:02 -0700 | [diff] [blame] | 431 | private void assertSensorValues(Sensor sensor) { |
Aravind Akella | a8884ea | 2014-09-26 21:07:02 -0700 | [diff] [blame] | 432 | assertTrue("Max range must be positive. Range=" + sensor.getMaximumRange() |
| 433 | + " " + sensor.getName(), sensor.getMaximumRange() >= 0); |
| 434 | assertTrue("Max power must be positive. Power=" + sensor.getPower() + " " + |
| 435 | sensor.getName(), sensor.getPower() >= 0); |
| 436 | assertTrue("Max resolution must be positive. Resolution=" + sensor.getResolution() + |
| 437 | " " + sensor.getName(), sensor.getResolution() >= 0); |
| 438 | assertNotNull("Vendor name must not be null " + sensor.getName(), sensor.getVendor()); |
destradaa | 4458c69 | 2014-10-15 12:42:29 -0700 | [diff] [blame] | 439 | assertTrue("Version must be positive version=" + sensor.getVersion() + " " + |
| 440 | sensor.getName(), sensor.getVersion() > 0); |
destradaa | 774c015 | 2014-09-15 17:00:37 -0700 | [diff] [blame] | 441 | int fifoMaxEventCount = sensor.getFifoMaxEventCount(); |
| 442 | int fifoReservedEventCount = sensor.getFifoReservedEventCount(); |
| 443 | assertTrue(fifoMaxEventCount >= 0); |
| 444 | assertTrue(fifoReservedEventCount >= 0); |
| 445 | assertTrue(fifoReservedEventCount <= fifoMaxEventCount); |
Aravind Akella | 8b91fd4 | 2014-08-26 16:57:31 -0700 | [diff] [blame] | 446 | if (sensor.getReportingMode() == Sensor.REPORTING_MODE_ONE_SHOT) { |
Aravind Akella | a8884ea | 2014-09-26 21:07:02 -0700 | [diff] [blame] | 447 | assertTrue("One shot sensors should have zero FIFO Size " + sensor.getName(), |
Aravind Akella | 8b91fd4 | 2014-08-26 16:57:31 -0700 | [diff] [blame] | 448 | sensor.getFifoMaxEventCount() == 0); |
Aravind Akella | a8884ea | 2014-09-26 21:07:02 -0700 | [diff] [blame] | 449 | assertTrue("One shot sensors should have zero FIFO Size " + sensor.getName(), |
Aravind Akella | 8b91fd4 | 2014-08-26 16:57:31 -0700 | [diff] [blame] | 450 | sensor.getFifoReservedEventCount() == 0); |
| 451 | } |
Phil Dubach | 15f91be | 2009-05-19 16:41:52 -0700 | [diff] [blame] | 452 | } |
Jeff Brown | f381563 | 2012-04-16 17:51:02 -0700 | [diff] [blame] | 453 | |
| 454 | @SuppressWarnings("deprecation") |
| 455 | public void testLegacySensorOperations() { |
| 456 | final SensorManager mSensorManager = |
| 457 | (SensorManager) getContext().getSystemService(Context.SENSOR_SERVICE); |
| 458 | |
| 459 | // We expect the set of sensors reported by the new and legacy APIs to be consistent. |
| 460 | int sensors = 0; |
| 461 | if (mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER) != null) { |
| 462 | sensors |= SensorManager.SENSOR_ACCELEROMETER; |
| 463 | } |
| 464 | if (mSensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD) != null) { |
| 465 | sensors |= SensorManager.SENSOR_MAGNETIC_FIELD; |
| 466 | } |
| 467 | if (mSensorManager.getDefaultSensor(Sensor.TYPE_ORIENTATION) != null) { |
| 468 | sensors |= SensorManager.SENSOR_ORIENTATION | SensorManager.SENSOR_ORIENTATION_RAW; |
| 469 | } |
| 470 | assertEquals(sensors, mSensorManager.getSensors()); |
| 471 | } |
Jaikumar Ganesh | fde5af6 | 2013-03-01 13:34:10 -0800 | [diff] [blame] | 472 | |
destradaa | 4458c69 | 2014-10-15 12:42:29 -0700 | [diff] [blame] | 473 | /** |
| 474 | * Verifies that a continuous sensor produces events that have timestamps synchronized with |
| 475 | * {@link SystemClock#elapsedRealtimeNanos()}. |
| 476 | */ |
| 477 | private void verifyLongActivation( |
| 478 | Sensor sensor, |
| 479 | int maxReportLatencyUs, |
| 480 | ArrayList<Throwable> errorsFound) throws InterruptedException { |
| 481 | if (sensor.getReportingMode() != Sensor.REPORTING_MODE_CONTINUOUS) { |
| 482 | return; |
| 483 | } |
| 484 | |
| 485 | try { |
| 486 | TestSensorEnvironment environment = new TestSensorEnvironment( |
| 487 | getContext(), |
| 488 | sensor, |
| 489 | shouldEmulateSensorUnderLoad(), |
| 490 | SensorManager.SENSOR_DELAY_FASTEST, |
| 491 | maxReportLatencyUs); |
| 492 | TestSensorOperation operation = |
| 493 | TestSensorOperation.createOperation(environment, 20, TimeUnit.SECONDS); |
| 494 | operation.addVerification(EventGapVerification.getDefault(environment)); |
| 495 | operation.addVerification(EventOrderingVerification.getDefault(environment)); |
| 496 | operation.addVerification( |
| 497 | EventTimestampSynchronizationVerification.getDefault(environment)); |
| 498 | |
| 499 | Log.i(TAG, "Running timestamp test on: " + sensor.getName()); |
destradaa | 24289b5 | 2014-10-20 11:41:00 -0700 | [diff] [blame] | 500 | operation.execute(getCurrentTestNode()); |
destradaa | 4458c69 | 2014-10-15 12:42:29 -0700 | [diff] [blame] | 501 | } catch (InterruptedException e) { |
| 502 | // propagate so the test can stop |
| 503 | throw e; |
| 504 | } catch (Throwable e) { |
| 505 | errorsFound.add(e); |
| 506 | Log.e(TAG, e.getMessage()); |
Jaikumar Ganesh | fde5af6 | 2013-03-01 13:34:10 -0800 | [diff] [blame] | 507 | } |
| 508 | } |
| 509 | |
destradaa | 4458c69 | 2014-10-15 12:42:29 -0700 | [diff] [blame] | 510 | /** |
| 511 | * Verifies that a client can listen for events, and that |
| 512 | * {@link SensorManager#flush(SensorEventListener)} will trigger the appropriate notification |
| 513 | * for {@link SensorEventListener2#onFlushCompleted(Sensor)}. |
| 514 | */ |
| 515 | private void verifyRegisterListenerCallFlush( |
| 516 | Sensor sensor, |
| 517 | Handler handler, |
| 518 | ArrayList<Throwable> errorsFound) |
| 519 | throws InterruptedException { |
| 520 | if (sensor.getReportingMode() == Sensor.REPORTING_MODE_ONE_SHOT) { |
| 521 | return; |
Jaikumar Ganesh | fde5af6 | 2013-03-01 13:34:10 -0800 | [diff] [blame] | 522 | } |
| 523 | |
destradaa | 4458c69 | 2014-10-15 12:42:29 -0700 | [diff] [blame] | 524 | try { |
| 525 | TestSensorEnvironment environment = new TestSensorEnvironment( |
| 526 | getContext(), |
| 527 | sensor, |
| 528 | shouldEmulateSensorUnderLoad(), |
| 529 | SensorManager.SENSOR_DELAY_FASTEST, |
| 530 | (int) TimeUnit.SECONDS.toMicros(10)); |
| 531 | FlushExecutor executor = new FlushExecutor(environment, 500 /* eventCount */); |
| 532 | TestSensorOperation operation = new TestSensorOperation(environment, executor, handler); |
| 533 | |
| 534 | Log.i(TAG, "Running flush test on: " + sensor.getName()); |
destradaa | 24289b5 | 2014-10-20 11:41:00 -0700 | [diff] [blame] | 535 | operation.execute(getCurrentTestNode()); |
destradaa | 4458c69 | 2014-10-15 12:42:29 -0700 | [diff] [blame] | 536 | } catch (InterruptedException e) { |
| 537 | // propagate so the test can stop |
| 538 | throw e; |
| 539 | } catch (Throwable e) { |
| 540 | errorsFound.add(e); |
| 541 | Log.e(TAG, e.getMessage()); |
Jaikumar Ganesh | fde5af6 | 2013-03-01 13:34:10 -0800 | [diff] [blame] | 542 | } |
| 543 | } |
destradaa | 4458c69 | 2014-10-15 12:42:29 -0700 | [diff] [blame] | 544 | |
| 545 | private void assertOnErrors(List<Throwable> errorsFound) { |
| 546 | if (!errorsFound.isEmpty()) { |
| 547 | StringBuilder builder = new StringBuilder(); |
| 548 | for (Throwable error : errorsFound) { |
| 549 | builder.append(error.getMessage()).append("\n"); |
| 550 | } |
| 551 | Assert.fail(builder.toString()); |
| 552 | } |
| 553 | } |
| 554 | |
| 555 | /** |
| 556 | * A delegate that drives the execution of Batch/Flush tests. |
| 557 | * It performs several operations in order: |
| 558 | * - registration |
| 559 | * - for continuous sensors it first ensures that the FIFO is filled |
| 560 | * - if events do not arrive on time, an assert will be triggered |
| 561 | * - requests flush of sensor data |
| 562 | * - waits for {@link SensorEventListener2#onFlushCompleted(Sensor)} |
| 563 | * - if the event does not arrive, an assert will be triggered |
| 564 | */ |
| 565 | private class FlushExecutor implements TestSensorOperation.Executor { |
| 566 | private final TestSensorEnvironment mEnvironment; |
| 567 | private final int mEventCount; |
| 568 | |
| 569 | public FlushExecutor(TestSensorEnvironment environment, int eventCount) { |
| 570 | mEnvironment = environment; |
| 571 | mEventCount = eventCount; |
| 572 | } |
| 573 | |
| 574 | /** |
| 575 | * Consider only continuous mode sensors for testing register listener. |
| 576 | * |
| 577 | * For on-change sensors, we only use |
| 578 | * {@link TestSensorManager#registerListener(TestSensorEventListener)} to associate the |
| 579 | * listener with the sensor. So that {@link TestSensorManager#requestFlush()} can be |
| 580 | * invoked on it. |
| 581 | */ |
| 582 | @Override |
| 583 | public void execute(TestSensorManager sensorManager, TestSensorEventListener listener) |
| 584 | throws InterruptedException { |
| 585 | int sensorReportingMode = mEnvironment.getSensor().getReportingMode(); |
| 586 | try { |
Aravind Akella | 490e9b8 | 2015-01-29 17:41:07 -0800 | [diff] [blame] | 587 | CountDownLatch eventLatch = sensorManager.registerListener(listener, mEventCount); |
destradaa | 4458c69 | 2014-10-15 12:42:29 -0700 | [diff] [blame] | 588 | if (sensorReportingMode == Sensor.REPORTING_MODE_CONTINUOUS) { |
Aravind Akella | dbc95c5 | 2015-06-09 10:22:16 -0700 | [diff] [blame] | 589 | listener.waitForEvents(eventLatch, mEventCount, true); |
destradaa | 4458c69 | 2014-10-15 12:42:29 -0700 | [diff] [blame] | 590 | } |
Aravind Akella | 490e9b8 | 2015-01-29 17:41:07 -0800 | [diff] [blame] | 591 | CountDownLatch flushLatch = sensorManager.requestFlush(); |
Aravind Akella | dbc95c5 | 2015-06-09 10:22:16 -0700 | [diff] [blame] | 592 | listener.waitForFlushComplete(flushLatch, true); |
destradaa | 4458c69 | 2014-10-15 12:42:29 -0700 | [diff] [blame] | 593 | } finally { |
| 594 | sensorManager.unregisterListener(); |
| 595 | } |
| 596 | } |
| 597 | } |
| 598 | |
| 599 | private class NullTriggerEventListener extends TriggerEventListener { |
| 600 | @Override |
| 601 | public void onTrigger(TriggerEvent event) {} |
| 602 | } |
| 603 | |
| 604 | private class NullSensorEventListener implements SensorEventListener { |
| 605 | @Override |
| 606 | public void onSensorChanged(SensorEvent event) {} |
| 607 | |
| 608 | @Override |
| 609 | public void onAccuracyChanged(Sensor sensor, int accuracy) {} |
| 610 | } |
Peng Xu | 7a6fb7b | 2015-05-20 14:24:12 -0700 | [diff] [blame] | 611 | |
Phil Dubach | 15f91be | 2009-05-19 16:41:52 -0700 | [diff] [blame] | 612 | } |