apps/CtsVerifier/src/com/android/cts/verifier/sensors/StepCounterTestActivity.java - platform/cts - Git at Google

 /*
  * Copyright (C) 2014 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.cts.verifier.sensors;

 import com.android.cts.verifier.R;
 import com.android.cts.verifier.sensors.base.SensorCtsVerifierTestActivity;

 import junit.framework.Assert;

 import android.content.Context;
 import android.hardware.Sensor;
 import android.hardware.SensorEvent;
 import android.hardware.SensorEventListener;
 import android.hardware.SensorManager;
 import android.hardware.cts.helpers.MovementDetectorHelper;
 import android.hardware.cts.helpers.SensorTestStateNotSupportedException;
 import android.hardware.cts.helpers.TestSensorEnvironment;
 import android.hardware.cts.helpers.TestSensorEvent;
 import android.os.SystemClock;
 import android.view.MotionEvent;
 import android.view.View;

 import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.TimeUnit;

 public class StepCounterTestActivity
         extends SensorCtsVerifierTestActivity
         implements SensorEventListener {
     public StepCounterTestActivity() {
         super(StepCounterTestActivity.class);
     }

     private static final int TEST_DURATION_SECONDS = 20;
     private static final long TIMESTAMP_SYNCHRONIZATION_THRESHOLD_NANOS =
             TimeUnit.MILLISECONDS.toNanos(500);

     private static final int MIN_NUM_STEPS_PER_TEST = 10;
     private static final int MAX_STEP_DISCREPANCY = 5;
     private static final long MAX_TOLERANCE_STEP_TIME_NANOS = TimeUnit.SECONDS.toNanos(10);

     private static final long[] VIBRATE_PATTERN = {
             1000L, 500L, 1000L, 750L, 1000L, 500L, 1000L, 750L, 1000L, 1000L, 500L, 1000L,
             750L, 1000L, 500L, 1000L };

     private SensorManager mSensorManager;
     private Sensor mSensorStepCounter;
     private Sensor mSensorStepDetector;
     private MovementDetectorHelper mMovementDetectorHelper;

     private volatile boolean mMoveDetected;

     private final List<Long> mTimestampsUserReported = new ArrayList<Long>();
     private final List<TestSensorEvent> mStepCounterEvents = new ArrayList<TestSensorEvent>();
     private final List<TestSensorEvent> mStepDetectorEvents = new ArrayList<TestSensorEvent>();

     /**
      * A flag that indicates if the test is interested in registering steps reported by the
      * operator. The registration of events happens by tapping the screen throughout the test.
      */
     private volatile boolean mCheckForMotion;

     @Override
     protected void activitySetUp() {
         mSensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
         mSensorStepCounter = mSensorManager.getDefaultSensor(Sensor.TYPE_STEP_COUNTER);
         mSensorStepDetector = mSensorManager.getDefaultSensor(Sensor.TYPE_STEP_DETECTOR);

         if (mSensorStepCounter == null && mSensorStepDetector == null) {
             throw new SensorTestStateNotSupportedException(
                     "Sensors Step Counter/Detector are not supported.");
         }

         setLogScrollViewListener(new View.OnTouchListener() {
             @Override
             public boolean onTouch(View v, MotionEvent event) {
                 // during movement of the device, the ScrollView will detect user taps as attempts
                 // to scroll, when in reality they are taps in the layout
                 // to overcome the fact that a ScrollView cannot be disabled from scrolling, we
                 // listen for ACTION_UP events instead of click events in the child layout
                 long elapsedTime = SystemClock.elapsedRealtimeNanos();
                 if (event.getAction() != MotionEvent.ACTION_UP) {
                     return false;
                 }

                 try {
                     logUserReportedStep(elapsedTime);
                 } catch (InterruptedException e) {
                     // we cannot propagate the exception in the main thread, so we just catch and
                     // restore the status, we don't need to log as we are terminating anyways
                     Thread.currentThread().interrupt();
                 }
                 return false;
             }
         });
     }

     @Override
     protected void activityCleanUp() {
         setLogScrollViewListener(null /* listener */);
     }

     public String testWalking() throws Throwable {
         return runTest(
                 R.string.snsr_step_counter_test_walking,
                 MIN_NUM_STEPS_PER_TEST,
                 false /* vibrate */);
     }

     public String testStill() throws Throwable {
         return runTest(
                 R.string.snsr_step_counter_test_still,
                 0 /* expectedSteps */,
                 true /* vibrate */);
     }

     /**
      * @param instructionsResId Resource ID containing instruction to be shown to testers
      * @param expectedSteps Number of steps expected in this test
      * @param vibrate If TRUE, vibration will be concurrent with the test
      */
     private String runTest(int instructionsResId, int expectedSteps, boolean vibrate)
             throws Throwable {
         mTimestampsUserReported.clear();
         mStepCounterEvents.clear();
         mStepDetectorEvents.clear();

         mMoveDetected = false;
         mCheckForMotion = false;

         getTestLogger().logInstructions(instructionsResId);
         waitForUserToBegin();

         mCheckForMotion = (expectedSteps > 0);
         if (vibrate) {
             vibrate(VIBRATE_PATTERN);
         }
         startMeasurements();
         getTestLogger().logWaitForSound();

         Thread.sleep(TimeUnit.SECONDS.toMillis(TEST_DURATION_SECONDS));
         mCheckForMotion = false;
         playSound();

         return verifyMeasurements(expectedSteps);
     }

     private void startMeasurements() {
         if (mSensorStepCounter != null) {
             mSensorManager.registerListener(this, mSensorStepCounter,
                     SensorManager.SENSOR_DELAY_NORMAL);
         }

         if (mSensorStepDetector != null) {
             mSensorManager.registerListener(this, mSensorStepDetector,
                     SensorManager.SENSOR_DELAY_NORMAL);
         }

         mMovementDetectorHelper = new MovementDetectorHelper(getApplicationContext()) {
             @Override
             protected void onMovementDetected() {
                 mMoveDetected = true;
             }
         };
         mMovementDetectorHelper.start();
     }

     private String verifyMeasurements(int stepsExpected) {
         mSensorManager.unregisterListener(this);
         mMovementDetectorHelper.stop();

         if (mCheckForMotion) {
             Assert.assertTrue(
                     getString(R.string.snsr_movement_expected, mMoveDetected),
                     mMoveDetected);
         }

         final int userReportedSteps = mTimestampsUserReported.size();
         String stepsReportedMessage = getString(
                 R.string.snsr_step_counter_expected_steps,
                 stepsExpected,
                 userReportedSteps);
         Assert.assertFalse(stepsReportedMessage, userReportedSteps < stepsExpected);

         // TODO: split test cases for step detector and counter
         verifyStepDetectorMeasurements();
         verifyStepCounterMeasurements();
         return null;
     }

     private void verifyStepCounterMeasurements() {
         if (mSensorStepCounter == null) {
             // sensor not supported, so no-op
             return;
         }

         final int userReportedSteps = mTimestampsUserReported.size();
         int totalStepsCounted = 0;
         int initialStepCount = -1;
         for (TestSensorEvent counterEvent : mStepCounterEvents) {
             String sensorName = counterEvent.sensor.getName();
             float[] values = counterEvent.values;

             final int expectedLength = 1;
             int valuesLength = values.length;
             String eventLengthMessage = getString(
                     R.string.snsr_event_length,
                     expectedLength,
                     valuesLength,
                     sensorName);
             Assert.assertEquals(eventLengthMessage, expectedLength, valuesLength);

             int stepValue = (int) values[0];
             if (initialStepCount == -1) {
                 initialStepCount = stepValue;
             } else {
                 int stepsCounted = stepValue - initialStepCount;
                 int countDelta = stepsCounted - totalStepsCounted;

                 String eventTriggered = getString(
                         R.string.snsr_step_counter_event_changed,
                         countDelta,
                         counterEvent.timestamp);
                 Assert.assertTrue(eventTriggered, countDelta > 0);

                 // TODO: abstract this into an ISensorVerification

                 long deltaThreshold = TIMESTAMP_SYNCHRONIZATION_THRESHOLD_NANOS
                         + TestSensorEnvironment.getSensorMaxDetectionLatencyNs(counterEvent.sensor);
                 assertTimestampSynchronization(
                         counterEvent.timestamp,
                         counterEvent.receivedTimestamp,
                         deltaThreshold,
                         counterEvent.sensor.getName());

                 totalStepsCounted = stepsCounted;
             }
         }

         int stepsCountedDelta = Math.abs(totalStepsCounted - userReportedSteps);
         String stepsDeltaMessage = getString(
                 R.string.snsr_step_counter_detected_reported,
                 userReportedSteps,
                 totalStepsCounted,
                 stepsCountedDelta,
                 MAX_STEP_DISCREPANCY);
         Assert.assertFalse(stepsDeltaMessage, stepsCountedDelta > MAX_STEP_DISCREPANCY);

         int stepCounterLength = mStepCounterEvents.size();
         for (int i = 0; i < userReportedSteps && i < stepCounterLength; ++i) {
             long userReportedTimestamp = mTimestampsUserReported.get(i);
             TestSensorEvent counterEvent = mStepCounterEvents.get(i);

             assertTimestampSynchronization(
                     counterEvent.timestamp,
                     userReportedTimestamp,
                     MAX_TOLERANCE_STEP_TIME_NANOS,
                     counterEvent.sensor.getName());
         }
     }

     private void verifyStepDetectorMeasurements() {
         if (mSensorStepDetector == null) {
             // sensor not supported, so no-op
             return;
         }

         final int userReportedSteps = mTimestampsUserReported.size();
         int stepsDetected = mStepDetectorEvents.size();
         int stepsDetectedDelta = Math.abs(stepsDetected - userReportedSteps);
         String stepsDetectedMessage = getString(
                 R.string.snsr_step_detector_detected_reported,
                 userReportedSteps,
                 stepsDetected,
                 stepsDetectedDelta,
                 MAX_STEP_DISCREPANCY);
         Assert.assertFalse(stepsDetectedMessage, stepsDetectedDelta > MAX_STEP_DISCREPANCY);

         for (TestSensorEvent detectorEvent : mStepDetectorEvents) {
             String sensorName = detectorEvent.sensor.getName();
             float[] values = detectorEvent.values;

             final int expectedLength = 1;
             int valuesLength = values.length;
             String eventLengthMessage = getString(
                     R.string.snsr_event_length,
                     expectedLength,
                     valuesLength,
                     sensorName);
             Assert.assertEquals(eventLengthMessage, expectedLength, valuesLength);

             final float expectedValue = 1.0f;
             float value0 = values[0];
             String eventValueMessage =
                     getString(R.string.snsr_event_value, expectedValue, value0, sensorName);
             Assert.assertEquals(eventValueMessage, expectedValue, value0);
         }

         // TODO: verify correlation of events with steps from user
     }

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

     public final void onSensorChanged(SensorEvent event) {
         long elapsedRealtimeNanos = SystemClock.elapsedRealtimeNanos();
         int type = event.sensor.getType();
         if (type == Sensor.TYPE_STEP_COUNTER) {
             mStepCounterEvents.add(new TestSensorEvent(event, elapsedRealtimeNanos));
             getTestLogger().logMessage(
                     R.string.snsr_step_counter_event,
                     elapsedRealtimeNanos,
                     (int) event.values[0]);
         } else if (type == Sensor.TYPE_STEP_DETECTOR) {
             mStepDetectorEvents.add(new TestSensorEvent(event, elapsedRealtimeNanos));
             getTestLogger().logMessage(R.string.snsr_step_detector_event, elapsedRealtimeNanos);

         }
         // TODO: with delayed assertions check events of other types are tracked
     }

     private void logUserReportedStep(long timestamp) throws InterruptedException {
         if (!mCheckForMotion) {
             return;
         }
         playSound();
         mTimestampsUserReported.add(timestamp);
         getTestLogger().logMessage(R.string.snsr_step_reported, timestamp);
     }
 }
	/*
	* Copyright (C) 2014 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.cts.verifier.sensors;

	import com.android.cts.verifier.R;
	import com.android.cts.verifier.sensors.base.SensorCtsVerifierTestActivity;

	import junit.framework.Assert;

	import android.content.Context;
	import android.hardware.Sensor;
	import android.hardware.SensorEvent;
	import android.hardware.SensorEventListener;
	import android.hardware.SensorManager;
	import android.hardware.cts.helpers.MovementDetectorHelper;
	import android.hardware.cts.helpers.SensorTestStateNotSupportedException;
	import android.hardware.cts.helpers.TestSensorEnvironment;
	import android.hardware.cts.helpers.TestSensorEvent;
	import android.os.SystemClock;
	import android.view.MotionEvent;
	import android.view.View;

	import java.util.ArrayList;
	import java.util.List;
	import java.util.concurrent.TimeUnit;

	public class StepCounterTestActivity
	extends SensorCtsVerifierTestActivity
	implements SensorEventListener {
	public StepCounterTestActivity() {
	super(StepCounterTestActivity.class);
	}

	private static final int TEST_DURATION_SECONDS = 20;
	private static final long TIMESTAMP_SYNCHRONIZATION_THRESHOLD_NANOS =
	TimeUnit.MILLISECONDS.toNanos(500);

	private static final int MIN_NUM_STEPS_PER_TEST = 10;
	private static final int MAX_STEP_DISCREPANCY = 5;
	private static final long MAX_TOLERANCE_STEP_TIME_NANOS = TimeUnit.SECONDS.toNanos(10);

	private static final long[] VIBRATE_PATTERN = {
	1000L, 500L, 1000L, 750L, 1000L, 500L, 1000L, 750L, 1000L, 1000L, 500L, 1000L,
	750L, 1000L, 500L, 1000L };

	private SensorManager mSensorManager;
	private Sensor mSensorStepCounter;
	private Sensor mSensorStepDetector;
	private MovementDetectorHelper mMovementDetectorHelper;

	private volatile boolean mMoveDetected;

	private final List<Long> mTimestampsUserReported = new ArrayList<Long>();
	private final List<TestSensorEvent> mStepCounterEvents = new ArrayList<TestSensorEvent>();
	private final List<TestSensorEvent> mStepDetectorEvents = new ArrayList<TestSensorEvent>();

	/**
	* A flag that indicates if the test is interested in registering steps reported by the
	* operator. The registration of events happens by tapping the screen throughout the test.
	*/
	private volatile boolean mCheckForMotion;

	@Override
	protected void activitySetUp() {
	mSensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
	mSensorStepCounter = mSensorManager.getDefaultSensor(Sensor.TYPE_STEP_COUNTER);
	mSensorStepDetector = mSensorManager.getDefaultSensor(Sensor.TYPE_STEP_DETECTOR);

	if (mSensorStepCounter == null && mSensorStepDetector == null) {
	throw new SensorTestStateNotSupportedException(
	"Sensors Step Counter/Detector are not supported.");
	}

	setLogScrollViewListener(new View.OnTouchListener() {
	@Override
	public boolean onTouch(View v, MotionEvent event) {
	// during movement of the device, the ScrollView will detect user taps as attempts
	// to scroll, when in reality they are taps in the layout
	// to overcome the fact that a ScrollView cannot be disabled from scrolling, we
	// listen for ACTION_UP events instead of click events in the child layout
	long elapsedTime = SystemClock.elapsedRealtimeNanos();
	if (event.getAction() != MotionEvent.ACTION_UP) {
	return false;
	}

	try {
	logUserReportedStep(elapsedTime);
	} catch (InterruptedException e) {
	// we cannot propagate the exception in the main thread, so we just catch and
	// restore the status, we don't need to log as we are terminating anyways
	Thread.currentThread().interrupt();
	}
	return false;
	}
	});
	}

	@Override
	protected void activityCleanUp() {
	setLogScrollViewListener(null /* listener */);
	}

	public String testWalking() throws Throwable {
	return runTest(
	R.string.snsr_step_counter_test_walking,
	MIN_NUM_STEPS_PER_TEST,
	false /* vibrate */);
	}

	public String testStill() throws Throwable {
	return runTest(
	R.string.snsr_step_counter_test_still,
	0 /* expectedSteps */,
	true /* vibrate */);
	}

	/**
	* @param instructionsResId Resource ID containing instruction to be shown to testers
	* @param expectedSteps Number of steps expected in this test
	* @param vibrate If TRUE, vibration will be concurrent with the test
	*/
	private String runTest(int instructionsResId, int expectedSteps, boolean vibrate)
	throws Throwable {
	mTimestampsUserReported.clear();
	mStepCounterEvents.clear();
	mStepDetectorEvents.clear();

	mMoveDetected = false;
	mCheckForMotion = false;

	getTestLogger().logInstructions(instructionsResId);
	waitForUserToBegin();

	mCheckForMotion = (expectedSteps > 0);
	if (vibrate) {
	vibrate(VIBRATE_PATTERN);
	}
	startMeasurements();
	getTestLogger().logWaitForSound();

	Thread.sleep(TimeUnit.SECONDS.toMillis(TEST_DURATION_SECONDS));
	mCheckForMotion = false;
	playSound();

	return verifyMeasurements(expectedSteps);
	}

	private void startMeasurements() {
	if (mSensorStepCounter != null) {
	mSensorManager.registerListener(this, mSensorStepCounter,
	SensorManager.SENSOR_DELAY_NORMAL);
	}

	if (mSensorStepDetector != null) {
	mSensorManager.registerListener(this, mSensorStepDetector,
	SensorManager.SENSOR_DELAY_NORMAL);
	}

	mMovementDetectorHelper = new MovementDetectorHelper(getApplicationContext()) {
	@Override
	protected void onMovementDetected() {
	mMoveDetected = true;
	}
	};
	mMovementDetectorHelper.start();
	}

	private String verifyMeasurements(int stepsExpected) {
	mSensorManager.unregisterListener(this);
	mMovementDetectorHelper.stop();

	if (mCheckForMotion) {
	Assert.assertTrue(
	getString(R.string.snsr_movement_expected, mMoveDetected),
	mMoveDetected);
	}

	final int userReportedSteps = mTimestampsUserReported.size();
	String stepsReportedMessage = getString(
	R.string.snsr_step_counter_expected_steps,
	stepsExpected,
	userReportedSteps);
	Assert.assertFalse(stepsReportedMessage, userReportedSteps < stepsExpected);

	// TODO: split test cases for step detector and counter
	verifyStepDetectorMeasurements();
	verifyStepCounterMeasurements();
	return null;
	}

	private void verifyStepCounterMeasurements() {
	if (mSensorStepCounter == null) {
	// sensor not supported, so no-op
	return;
	}

	final int userReportedSteps = mTimestampsUserReported.size();
	int totalStepsCounted = 0;
	int initialStepCount = -1;
	for (TestSensorEvent counterEvent : mStepCounterEvents) {
	String sensorName = counterEvent.sensor.getName();
	float[] values = counterEvent.values;

	final int expectedLength = 1;
	int valuesLength = values.length;
	String eventLengthMessage = getString(
	R.string.snsr_event_length,
	expectedLength,
	valuesLength,
	sensorName);
	Assert.assertEquals(eventLengthMessage, expectedLength, valuesLength);

	int stepValue = (int) values[0];
	if (initialStepCount == -1) {
	initialStepCount = stepValue;
	} else {
	int stepsCounted = stepValue - initialStepCount;
	int countDelta = stepsCounted - totalStepsCounted;

	String eventTriggered = getString(
	R.string.snsr_step_counter_event_changed,
	countDelta,
	counterEvent.timestamp);
	Assert.assertTrue(eventTriggered, countDelta > 0);

	// TODO: abstract this into an ISensorVerification

	long deltaThreshold = TIMESTAMP_SYNCHRONIZATION_THRESHOLD_NANOS
	+ TestSensorEnvironment.getSensorMaxDetectionLatencyNs(counterEvent.sensor);
	assertTimestampSynchronization(
	counterEvent.timestamp,
	counterEvent.receivedTimestamp,
	deltaThreshold,
	counterEvent.sensor.getName());

	totalStepsCounted = stepsCounted;
	}
	}

	int stepsCountedDelta = Math.abs(totalStepsCounted - userReportedSteps);
	String stepsDeltaMessage = getString(
	R.string.snsr_step_counter_detected_reported,
	userReportedSteps,
	totalStepsCounted,
	stepsCountedDelta,
	MAX_STEP_DISCREPANCY);
	Assert.assertFalse(stepsDeltaMessage, stepsCountedDelta > MAX_STEP_DISCREPANCY);

	int stepCounterLength = mStepCounterEvents.size();
	for (int i = 0; i < userReportedSteps && i < stepCounterLength; ++i) {
	long userReportedTimestamp = mTimestampsUserReported.get(i);
	TestSensorEvent counterEvent = mStepCounterEvents.get(i);

	assertTimestampSynchronization(
	counterEvent.timestamp,
	userReportedTimestamp,
	MAX_TOLERANCE_STEP_TIME_NANOS,
	counterEvent.sensor.getName());
	}
	}

	private void verifyStepDetectorMeasurements() {
	if (mSensorStepDetector == null) {
	// sensor not supported, so no-op
	return;
	}

	final int userReportedSteps = mTimestampsUserReported.size();
	int stepsDetected = mStepDetectorEvents.size();
	int stepsDetectedDelta = Math.abs(stepsDetected - userReportedSteps);
	String stepsDetectedMessage = getString(
	R.string.snsr_step_detector_detected_reported,
	userReportedSteps,
	stepsDetected,
	stepsDetectedDelta,
	MAX_STEP_DISCREPANCY);
	Assert.assertFalse(stepsDetectedMessage, stepsDetectedDelta > MAX_STEP_DISCREPANCY);

	for (TestSensorEvent detectorEvent : mStepDetectorEvents) {
	String sensorName = detectorEvent.sensor.getName();
	float[] values = detectorEvent.values;

	final int expectedLength = 1;
	int valuesLength = values.length;
	String eventLengthMessage = getString(
	R.string.snsr_event_length,
	expectedLength,
	valuesLength,
	sensorName);
	Assert.assertEquals(eventLengthMessage, expectedLength, valuesLength);

	final float expectedValue = 1.0f;
	float value0 = values[0];
	String eventValueMessage =
	getString(R.string.snsr_event_value, expectedValue, value0, sensorName);
	Assert.assertEquals(eventValueMessage, expectedValue, value0);
	}

	// TODO: verify correlation of events with steps from user
	}

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

	public final void onSensorChanged(SensorEvent event) {
	long elapsedRealtimeNanos = SystemClock.elapsedRealtimeNanos();
	int type = event.sensor.getType();
	if (type == Sensor.TYPE_STEP_COUNTER) {
	mStepCounterEvents.add(new TestSensorEvent(event, elapsedRealtimeNanos));
	getTestLogger().logMessage(
	R.string.snsr_step_counter_event,
	elapsedRealtimeNanos,
	(int) event.values[0]);
	} else if (type == Sensor.TYPE_STEP_DETECTOR) {
	mStepDetectorEvents.add(new TestSensorEvent(event, elapsedRealtimeNanos));
	getTestLogger().logMessage(R.string.snsr_step_detector_event, elapsedRealtimeNanos);

	}
	// TODO: with delayed assertions check events of other types are tracked
	}

	private void logUserReportedStep(long timestamp) throws InterruptedException {
	if (!mCheckForMotion) {
	return;
	}
	playSound();
	mTimestampsUserReported.add(timestamp);
	getTestLogger().logMessage(R.string.snsr_step_reported, timestamp);
	}
	}