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

 /*
  * Copyright (C) 2017 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 android.app.AlarmManager;
 import android.app.PendingIntent;
 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
 import android.content.IntentFilter;
 import android.hardware.Sensor;
 import android.hardware.SensorEvent;
 import android.hardware.SensorEventListener;
 import android.hardware.SensorManager;
 import android.hardware.cts.helpers.SensorNotSupportedException;
 import android.hardware.cts.helpers.SuspendStateMonitor;
 import android.os.PowerManager;
 import android.os.SystemClock;
 import androidx.localbroadcastmanager.content.LocalBroadcastManager;
 import android.util.Log;

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

 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;

 import junit.framework.Assert;
 import static junit.framework.Assert.fail;


 /**
  * Manual test for testing the low-latency offbody detect sensor. This test consists of 3
  * sub-tests designed to verify the sensor event data, verify event trigger response times
  * are within spec for the sensor type, and to verify that the sensor can wake the device.
  */
 public class OffBodySensorTestActivity
         extends SensorCtsVerifierTestActivity {
     private static final String TAG="OffbodySensorTest";
     private static String ACTION_ALARM = "OffBodySensorTestActivity.ACTION_ALARM";
     private static final int MAX_OFF_BODY_EVENT_LATENCY_MS = 1000;
     private static final int MAX_ON_BODY_EVENT_LATENCY_MS = 5000;
     private static final int COUNTDOWN_INTERVAL_MS = 1000;
     private static final int LLOB_EVENT_MAX_DELAY_SEC = 20;
     private static final long MAX_ALLOWED_DELAY_MS = TimeUnit.SECONDS.toMillis(1);
     private static final long RESULT_REPORT_SHOW_TIME_MS = TimeUnit.SECONDS.toMillis(5);
     private static final int OFFBODY_EVENT_VALUES_LENGTH = 1;
     private static final int COUNTDOWN_NUM_INTERVALS = 3;

     private static final float OFF_BODY_EVENT_VALUE = 0;
     private static final float ON_BODY_EVENT_VALUE = 1;
     private static final float BAD_VALUE_SEEN_INIT = 0;
     private static float mBadValueSeen = BAD_VALUE_SEEN_INIT;

     private enum State {
         OFF_BODY, ON_BODY, UNKNOWN
     }

     // time to wait for offbody event after the device has gone into suspend. Even after
     // 45 secs if LLOB sensor does not trigger, the test will fail.
     private static final long ALARM_WAKE_UP_AP_DELAY_MS = TimeUnit.SECONDS.toMillis(45);

     // acceptable time difference between event time and AP wake up time.
     private static final long MAX_ACCEPTABLE_DELAY_EVENT_AP_WAKE_UP_NS =
             TimeUnit.MILLISECONDS.toNanos(1200);

     private static final int NANOSECONDS_PER_MILLISECOND = 1000000;
     private AlarmManager mAlarmManager;
     private SensorManager mSensorManager;
     private Sensor mOffBodySensor;
     private boolean mOffBodySensorRegistered;
     private long mTestStartTimestampMs;
     private State mPreviousSensorState;
     private PendingIntent mPendingIntent;
     private PowerManager.WakeLock mDeviceSuspendLock;
     private SensorEventVerifier mVerifier;
     private SensorTestScreenManipulator mScreenManipulator;

     public class SensorEventRegistry {
         public final SensorEvent event;
         public final long receiveTimestampNanos;

         public SensorEventRegistry(SensorEvent event, long realtimeTimestampNanos) {
             this.event = event;
             this.receiveTimestampNanos = realtimeTimestampNanos;
         }
     }

     private class SensorEventVerifier implements SensorEventListener {
         private volatile CountDownLatch mCountDownLatch;
         private volatile SensorEventRegistry mEventRegistry;
         private volatile long mTimestampForLastSensorEvent = 0;

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

         @Override
         public void onSensorChanged(SensorEvent event) {
             long elapsedRealtimeNanos = SystemClock.elapsedRealtimeNanos();
             int type = event.sensor.getType();

             if (type == Sensor.TYPE_LOW_LATENCY_OFFBODY_DETECT) {
                 switch((int) event.values[0]) {
                     case (int) OFF_BODY_EVENT_VALUE:
                         Log.i(TAG, "onSensorChanged(): OFF_BODY ts="+event.timestamp+
                                 ", now="+elapsedRealtimeNanos+", delta="+
                                 (elapsedRealtimeNanos-event.timestamp)/1000000+"mS");
                         mPreviousSensorState = State.OFF_BODY;
                         break;
                     case (int) ON_BODY_EVENT_VALUE:
                         Log.i(TAG, "onSensorChanged(): ON_BODY ts = "+event.timestamp+
                                 ", now="+elapsedRealtimeNanos+", delta="+
                                 (elapsedRealtimeNanos-event.timestamp)/1000000+"mS");
                         mPreviousSensorState = State.ON_BODY;
                         break;
                     default:
                         Log.e(TAG, "onSensorChanged(): invalid value "+event.values[0]+
                                 " received");
                         mBadValueSeen = event.values[0];
                         break;
                 }
                 mEventRegistry = new SensorEventRegistry(event, elapsedRealtimeNanos);
                 getTestLogger().logMessage(
                         R.string.snsr_offbody_state_change,
                         (int) event.values[0],
                         elapsedRealtimeNanos);
                 releaseLatch();
             }
         }

         public void releaseLatch() {
             if (mCountDownLatch != null) {
                 mCountDownLatch.countDown();
             }
         }

         public long getTimeStampForSensorEvent() {
             return mTimestampForLastSensorEvent;
         }

         public String awaitAndVerifyEvent(float expectedResponseValue) throws Throwable {
             return awaitAndVerifyEvent(expectedResponseValue, 0);
         }

         public String awaitAndVerifyEvent(float expectedResponseValue, int maxEventLatencyMs)
                 throws Throwable {
             SensorEventRegistry registry = waitForEvent();
             String eventArrivalMessage;
             if ((registry == null) || (registry.event == null)) {
                 eventArrivalMessage = getString(R.string.snsr_offbody_event_arrival, false);
                 Assert.fail(eventArrivalMessage);
             }

             // verify an event arrived, and it is indeed a Low Latency Offbody Detect event
             SensorEvent event = registry.event;
             eventArrivalMessage = getString(R.string.snsr_offbody_event_arrival, event != null);
             Assert.assertNotNull(eventArrivalMessage, event);

             String result = verifyEvent(registry, expectedResponseValue, maxEventLatencyMs);
             return result;
         }

         public String verifyEvent(SensorEventRegistry registry, float expectedResponseValue,
                 int maxEventLatencyMs) throws Throwable {
             int eventType = registry.event.sensor.getType();
             String eventTypeMessage = getString(
                     R.string.snsr_offbody_event_type,
                     Sensor.TYPE_LOW_LATENCY_OFFBODY_DETECT,
                     eventType);
             Assert.assertEquals(eventTypeMessage,
                     Sensor.TYPE_LOW_LATENCY_OFFBODY_DETECT,
                     eventType);

             float value = registry.event.values[0];
             String sensorName = registry.event.sensor.getName();
             String eventName = (value == ON_BODY_EVENT_VALUE) ? "ON-BODY" : "OFF-BODY";

             long eventLatencyMs = (registry.receiveTimestampNanos/NANOSECONDS_PER_MILLISECOND)
                     - mTestStartTimestampMs;

             int valuesLength = registry.event.values.length;
             String valuesLengthMessage = getString(
                     R.string.snsr_event_length,
                     OFFBODY_EVENT_VALUES_LENGTH,
                     valuesLength,
                     sensorName);
             Assert.assertEquals(valuesLengthMessage, OFFBODY_EVENT_VALUES_LENGTH, valuesLength);

             String valuesMessage = getString(
                     R.string.snsr_event_value,
                     expectedResponseValue,
                     value,
                     sensorName);
             Assert.assertEquals(valuesMessage, expectedResponseValue, value);

             if (maxEventLatencyMs != 0) {
                 Log.i(TAG, "event latency was "+eventLatencyMs+" ms for "+
                         eventName+" event");
                 String responseViolationMessage = getString(
                     R.string.snsr_offbody_response_timing_violation,
                     eventName,
                     maxEventLatencyMs,
                     eventLatencyMs);
                 boolean violation = (eventLatencyMs > maxEventLatencyMs);
                 Assert.assertFalse(responseViolationMessage, violation);
             }
             return null;
         }

         private void verifyOffbodyEventNotInvalid() throws InterruptedException {
             if (mBadValueSeen != BAD_VALUE_SEEN_INIT) {
                 Assert.fail(
                     String.format(getString(R.string.snsr_offbody_event_invalid_value),
                     OFF_BODY_EVENT_VALUE,
                     ON_BODY_EVENT_VALUE,
                     mBadValueSeen));
             }
         }

         private SensorEventRegistry waitForEvent() throws InterruptedException {
             return waitForEvent(null);
         }

         private SensorEventRegistry waitForEvent(PowerManager.WakeLock suspendLock)
                 throws InterruptedException {
             mCountDownLatch = new CountDownLatch(1);

             if ((suspendLock != null) && suspendLock.isHeld()) {
                 suspendLock.release();
             }

             mCountDownLatch.await(LLOB_EVENT_MAX_DELAY_SEC, TimeUnit.SECONDS);

             if ((suspendLock != null) && !suspendLock.isHeld()) {
                 suspendLock.acquire();
             }

             SensorEventRegistry registry = mEventRegistry;

             // Save the last timestamp when the event triggered.
             if (mEventRegistry != null && mEventRegistry.event != null) {
                 mTimestampForLastSensorEvent = mEventRegistry.event.timestamp;
             }

             mEventRegistry = null;
             verifyOffbodyEventNotInvalid();
             return registry != null ? registry : new SensorEventRegistry(null, 0);
         }

         public SensorEvent waitForSensorEvent() throws InterruptedException {
             SensorEvent event = null;
             mCountDownLatch = new CountDownLatch(1);
             mCountDownLatch.await(LLOB_EVENT_MAX_DELAY_SEC, TimeUnit.SECONDS);

             if (mEventRegistry != null && mEventRegistry.event != null) {
                 event = mEventRegistry.event;
             }

             mEventRegistry = null;
             verifyOffbodyEventNotInvalid();
             return event;
         }
     }

     public OffBodySensorTestActivity() {
         super(OffBodySensorTestActivity.class);
     }


     @Override
     protected void activitySetUp() throws InterruptedException {
         PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE);
         mDeviceSuspendLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK,
                                             "OffBodySensorTestActivity");
         mDeviceSuspendLock.acquire();
         mOffBodySensorRegistered = false;
         mSensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
         mOffBodySensor = mSensorManager.getDefaultSensor(Sensor.TYPE_LOW_LATENCY_OFFBODY_DETECT,
                 true);
         if (mOffBodySensor == null) {
             setTestResultAndFinish(true);
             return;
         }
         LocalBroadcastManager.getInstance(this).registerReceiver(myBroadCastReceiver,
                                         new IntentFilter(ACTION_ALARM));
         Intent intent = new Intent(this, AlarmReceiver.class);
         mPendingIntent = PendingIntent.getBroadcast(this, 0, intent, 0);
         mAlarmManager = (AlarmManager) getSystemService(ALARM_SERVICE);
         mScreenManipulator = new SensorTestScreenManipulator(this);
         try {
             mScreenManipulator.initialize(this);
         } catch (InterruptedException e) {
         }
     }

     private void startTimeoutTimer(long delayMs) {
         mAlarmManager.setExact(AlarmManager.ELAPSED_REALTIME_WAKEUP,
                                 SystemClock.elapsedRealtime() + delayMs,
                                 mPendingIntent);
     }

     private void stopTimeoutTimer() {
         mAlarmManager.cancel(mPendingIntent);
     }

     private void stopOffbodySensorListener(SensorEventVerifier verifier) {
         if (mOffBodySensorRegistered) {
             mSensorManager.unregisterListener(verifier);
             mOffBodySensorRegistered = false;
         }
     }

     private boolean startOffbodySensorListener(SensorEventVerifier verifier) {
         if (!mOffBodySensorRegistered) {
             if (!mSensorManager.registerListener(verifier, mOffBodySensor,
                         SensorManager.SENSOR_DELAY_FASTEST)) {
                 Log.e(TAG, "error registering listener for LLOB");
                 setTestResultAndFinish(true);
                 return false;
             }
             mOffBodySensorRegistered = true;
         }
         return true;
     }

     public static class AlarmReceiver extends BroadcastReceiver {
         @Override
         public void onReceive(Context context, Intent intent) {
             Intent alarm_intent = new Intent(context, OffBodySensorTestActivity.class);
             alarm_intent.setAction(OffBodySensorTestActivity.ACTION_ALARM);
             LocalBroadcastManager.getInstance(context).sendBroadcastSync(alarm_intent);
         }
     }

     public BroadcastReceiver myBroadCastReceiver = new BroadcastReceiver() {
         @Override
         public void onReceive(Context context, Intent intent) {
             mVerifier.releaseLatch();
             mScreenManipulator.turnScreenOn();
             if (!mDeviceSuspendLock.isHeld()) {
                 mDeviceSuspendLock.acquire();
             }
         }
     };

     public String testOffbodyDetectResponseTime() throws Throwable {
         Sensor wakeUpSensor = mSensorManager.getDefaultSensor(
                 Sensor.TYPE_LOW_LATENCY_OFFBODY_DETECT, true);
         if (wakeUpSensor == null) {
             throw new SensorNotSupportedException(Sensor.TYPE_LOW_LATENCY_OFFBODY_DETECT, true);
         }
         return runOffbodyDetectResponseTimeTest(wakeUpSensor);
     }

     public String testOnbodyDetectResponseTime() throws Throwable {
         Sensor wakeUpSensor = mSensorManager.getDefaultSensor(
                 Sensor.TYPE_LOW_LATENCY_OFFBODY_DETECT, true);
         if (wakeUpSensor == null) {
             throw new SensorNotSupportedException(Sensor.TYPE_LOW_LATENCY_OFFBODY_DETECT, true);
         }
         return runOnbodyDetectResponseTimeTest(wakeUpSensor);
     }

     public String testWakeAPOffbodyDetect() throws Throwable {
         Sensor wakeUpSensor = mSensorManager.getDefaultSensor(
                 Sensor.TYPE_LOW_LATENCY_OFFBODY_DETECT, true);
         if (wakeUpSensor == null) {
             throw new SensorNotSupportedException(Sensor.TYPE_LOW_LATENCY_OFFBODY_DETECT, true);
         }
         return runWakeAPOffbodyDetectTest(wakeUpSensor);
     }

     public String runOffbodyDetectResponseTimeTest(Sensor sensor) throws Throwable {
         boolean success;
         String eventArrivalMessage;
         mOffBodySensor = sensor;
         mBadValueSeen = BAD_VALUE_SEEN_INIT;

         try {
             // If device not currently on-body, instruct user to put it on wrist
             mTestStartTimestampMs = 0;
             mVerifier = new SensorEventVerifier();
             success = startOffbodySensorListener(mVerifier);
             Assert.assertTrue(
                     getString(R.string.snsr_offbody_sensor_registration, success),
                     success);
             SensorEvent event = mVerifier.waitForSensorEvent();
             eventArrivalMessage = getString(R.string.snsr_offbody_event_arrival, event != null);
             Assert.assertNotNull(eventArrivalMessage, event);

             SensorTestLogger logger = getTestLogger();
             if (event.values[0] != ON_BODY_EVENT_VALUE) {
                 // Instruct user on how to perform offbody detect test
                 logger.logInstructions(R.string.snsr_start_offbody_sensor_test_instr);
                 waitForUserToBegin();
                 if (mPreviousSensorState != State.ON_BODY) {
                     event = mVerifier.waitForSensorEvent();
                     eventArrivalMessage = getString(R.string.snsr_offbody_event_arrival,
                             event != null);
                     Assert.assertNotNull(eventArrivalMessage, event);
                     if (event.values[0] != ON_BODY_EVENT_VALUE) {
                         Assert.fail(
                             String.format(getString(R.string.snsr_offbody_event_wrong_value),
                             ON_BODY_EVENT_VALUE,
                             event.values[0]));
                     }
                 }
             }

             // Instruct user on how to perform offbody detect test
             logger.logInstructions(R.string.snsr_offbody_detect_test_instr);
             waitForUserToBegin();

             // Count down before actually starting, leaving time to react after pressing the Next
             // button.
             for (int i = 0; i < COUNTDOWN_NUM_INTERVALS; i++) {
                 try {
                     Thread.sleep(COUNTDOWN_INTERVAL_MS);
                 } catch (InterruptedException e) {
                     // Ignore the interrupt and continue counting down.
                 }
                 logger.logInstructions(R.string.snsr_offbody_detect_test_countdown,
                         COUNTDOWN_NUM_INTERVALS - i - 1);
             }
             mTestStartTimestampMs = SystemClock.elapsedRealtime();

             // Verify off-body event latency is within spec
             mVerifier.awaitAndVerifyEvent(OFF_BODY_EVENT_VALUE, MAX_OFF_BODY_EVENT_LATENCY_MS);
         } finally {
             stopOffbodySensorListener(mVerifier);
         }
         return null;
     }

     public String runOnbodyDetectResponseTimeTest(Sensor sensor) throws Throwable {
         mOffBodySensor = sensor;
         SensorTestLogger logger = getTestLogger();
         mBadValueSeen = BAD_VALUE_SEEN_INIT;

         try {
             // If device not currently off-body, instruct user to remove it from wrist
             mTestStartTimestampMs = 0;
             mVerifier = new SensorEventVerifier();
             boolean success = startOffbodySensorListener(mVerifier);
             Assert.assertTrue(
                     getString(R.string.snsr_offbody_sensor_registration, success),
                     success);
             SensorEvent event = mVerifier.waitForSensorEvent();
             String eventArrivalMessage = getString(R.string.snsr_offbody_event_arrival,
                     event != null);
             Assert.assertNotNull(eventArrivalMessage, event);
             if (event.values[0] != OFF_BODY_EVENT_VALUE) {
                 // Instruct user on how to perform offbody detect test
                 logger.logInstructions(R.string.snsr_start_onbody_sensor_test_instr);
                 waitForUserToBegin();
                 if (mPreviousSensorState != State.OFF_BODY) {
                     event = mVerifier.waitForSensorEvent();
                     eventArrivalMessage = getString(R.string.snsr_offbody_event_arrival,
                             event != null);
                     Assert.assertNotNull(eventArrivalMessage, event);
                     if (event.values[0] != OFF_BODY_EVENT_VALUE) {
                         Assert.fail(
                             String.format(getString(R.string.snsr_offbody_event_wrong_value),
                             OFF_BODY_EVENT_VALUE,
                             event.values[0]));
                     }
                 }
             }

             // Display on-body latency test instructions
             logger.logInstructions(R.string.snsr_onbody_detect_test_instr);
             waitForUserToBegin();
             mTestStartTimestampMs = SystemClock.elapsedRealtime();
             mVerifier.awaitAndVerifyEvent(ON_BODY_EVENT_VALUE, MAX_ON_BODY_EVENT_LATENCY_MS);
         } finally {
             stopOffbodySensorListener(mVerifier);
         }
         return null;
     }

     public String runWakeAPOffbodyDetectTest(Sensor sensor) throws Throwable {
         final long ALARM_WAKE_UP_DELAY_MS = 40000;
         String eventArrivalMessage;
         SensorEventRegistry registry;
         SensorTestLogger logger = getTestLogger();
         mBadValueSeen = BAD_VALUE_SEEN_INIT;
         mVerifier = new SensorEventVerifier();
         mOffBodySensor = sensor;
         mTestStartTimestampMs = 0;

         mTestStartTimestampMs = SystemClock.elapsedRealtime();
         SuspendStateMonitor suspendStateMonitor = new SuspendStateMonitor();
         try {
             boolean success = startOffbodySensorListener(mVerifier);
             Assert.assertTrue(
                     getString(R.string.snsr_offbody_sensor_registration, success),
                     success);

             // grab the current off-body state, which should be ON-BODY
             if (mPreviousSensorState != State.ON_BODY) {
                 registry = mVerifier.waitForEvent();
                 if ((registry == null) || (registry.event == null) ||
                         (registry.event.values[0] != ON_BODY_EVENT_VALUE)) {
                     eventArrivalMessage = getString(R.string.snsr_offbody_event_arrival, false);
                     Assert.fail(eventArrivalMessage);

                     // Tell user to put watch on wrist
                     logger.logInstructions(R.string.snsr_start_offbody_sensor_test_instr);
                     waitForUserToBegin();
                     if (mPreviousSensorState != State.ON_BODY) {
                         registry = mVerifier.waitForEvent();
                         if ((registry == null) || (registry.event == null)) {
                             eventArrivalMessage = getString(R.string.snsr_offbody_event_arrival, false);
                             Assert.fail(eventArrivalMessage);
                         } else {
                             Assert.assertTrue(
                                 String.format(getString(R.string.snsr_offbody_event_wrong_value),
                                 ON_BODY_EVENT_VALUE,
                                 registry.event.values[0]),
                                 ON_BODY_EVENT_VALUE == registry.event.values[0]);
                         }
                     }
                 }
             }

             // Instruct user on how to perform offbody detect sleep test
             logger.logInstructions(R.string.snsr_ap_wake_offbody_detect_test_instr);
             waitForUserToBegin();

             long testStartTimeNs = SystemClock.elapsedRealtimeNanos();
             startTimeoutTimer(ALARM_WAKE_UP_AP_DELAY_MS);

             // Wait for the first event to trigger. Device is expected to go into suspend here.
             registry = mVerifier.waitForEvent(mDeviceSuspendLock);
             if ((registry == null) || (registry.event == null)) {
                 eventArrivalMessage = getString(R.string.snsr_offbody_event_arrival, false);
                 Assert.fail(eventArrivalMessage);
             }

             mVerifier.verifyEvent(registry, OFF_BODY_EVENT_VALUE, 0);

             long eventTimeStampNs = registry.event.timestamp;
             long endTimeNs = SystemClock.elapsedRealtimeNanos();
             long lastWakeupTimeNs = TimeUnit.MILLISECONDS.toNanos(
                     suspendStateMonitor.getLastWakeUpTime());
             Assert.assertTrue(getString(R.string.snsr_device_did_not_go_into_suspend),
                               testStartTimeNs < lastWakeupTimeNs && lastWakeupTimeNs < endTimeNs);
             long timestampDelta = Math.abs(lastWakeupTimeNs - eventTimeStampNs);
             Assert.assertTrue(
                     String.format(getString(R.string.snsr_device_did_not_wake_up_at_trigger),
                               TimeUnit.NANOSECONDS.toMillis(lastWakeupTimeNs),
                               TimeUnit.NANOSECONDS.toMillis(eventTimeStampNs)),
                               timestampDelta < MAX_ACCEPTABLE_DELAY_EVENT_AP_WAKE_UP_NS);
         } finally {
             stopTimeoutTimer();
             suspendStateMonitor.cancel();
             mScreenManipulator.turnScreenOn();
             playSound();
         }
         return null;
     }

     @Override
     protected void activityCleanUp() {
         if (mOffBodySensorRegistered) {
             stopOffbodySensorListener(mVerifier);
         }
         stopTimeoutTimer();
         LocalBroadcastManager.getInstance(this).unregisterReceiver(myBroadCastReceiver);
         if (mOffBodySensor != null) {
             mOffBodySensor = null;
         }
         if (mScreenManipulator != null){
             mScreenManipulator.close();
         }
         if ((mDeviceSuspendLock != null) && mDeviceSuspendLock.isHeld()) {
             mDeviceSuspendLock.release();
         }
     }
 }
	/*
	* Copyright (C) 2017 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 android.app.AlarmManager;
	import android.app.PendingIntent;
	import android.content.BroadcastReceiver;
	import android.content.Context;
	import android.content.Intent;
	import android.content.IntentFilter;
	import android.hardware.Sensor;
	import android.hardware.SensorEvent;
	import android.hardware.SensorEventListener;
	import android.hardware.SensorManager;
	import android.hardware.cts.helpers.SensorNotSupportedException;
	import android.hardware.cts.helpers.SuspendStateMonitor;
	import android.os.PowerManager;
	import android.os.SystemClock;
	import androidx.localbroadcastmanager.content.LocalBroadcastManager;
	import android.util.Log;

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

	import java.util.concurrent.CountDownLatch;
	import java.util.concurrent.TimeUnit;

	import junit.framework.Assert;
	import static junit.framework.Assert.fail;


	/**
	* Manual test for testing the low-latency offbody detect sensor. This test consists of 3
	* sub-tests designed to verify the sensor event data, verify event trigger response times
	* are within spec for the sensor type, and to verify that the sensor can wake the device.
	*/
	public class OffBodySensorTestActivity
	extends SensorCtsVerifierTestActivity {
	private static final String TAG="OffbodySensorTest";
	private static String ACTION_ALARM = "OffBodySensorTestActivity.ACTION_ALARM";
	private static final int MAX_OFF_BODY_EVENT_LATENCY_MS = 1000;
	private static final int MAX_ON_BODY_EVENT_LATENCY_MS = 5000;
	private static final int COUNTDOWN_INTERVAL_MS = 1000;
	private static final int LLOB_EVENT_MAX_DELAY_SEC = 20;
	private static final long MAX_ALLOWED_DELAY_MS = TimeUnit.SECONDS.toMillis(1);
	private static final long RESULT_REPORT_SHOW_TIME_MS = TimeUnit.SECONDS.toMillis(5);
	private static final int OFFBODY_EVENT_VALUES_LENGTH = 1;
	private static final int COUNTDOWN_NUM_INTERVALS = 3;

	private static final float OFF_BODY_EVENT_VALUE = 0;
	private static final float ON_BODY_EVENT_VALUE = 1;
	private static final float BAD_VALUE_SEEN_INIT = 0;
	private static float mBadValueSeen = BAD_VALUE_SEEN_INIT;

	private enum State {
	OFF_BODY, ON_BODY, UNKNOWN
	}

	// time to wait for offbody event after the device has gone into suspend. Even after
	// 45 secs if LLOB sensor does not trigger, the test will fail.
	private static final long ALARM_WAKE_UP_AP_DELAY_MS = TimeUnit.SECONDS.toMillis(45);

	// acceptable time difference between event time and AP wake up time.
	private static final long MAX_ACCEPTABLE_DELAY_EVENT_AP_WAKE_UP_NS =
	TimeUnit.MILLISECONDS.toNanos(1200);

	private static final int NANOSECONDS_PER_MILLISECOND = 1000000;
	private AlarmManager mAlarmManager;
	private SensorManager mSensorManager;
	private Sensor mOffBodySensor;
	private boolean mOffBodySensorRegistered;
	private long mTestStartTimestampMs;
	private State mPreviousSensorState;
	private PendingIntent mPendingIntent;
	private PowerManager.WakeLock mDeviceSuspendLock;
	private SensorEventVerifier mVerifier;
	private SensorTestScreenManipulator mScreenManipulator;

	public class SensorEventRegistry {
	public final SensorEvent event;
	public final long receiveTimestampNanos;

	public SensorEventRegistry(SensorEvent event, long realtimeTimestampNanos) {
	this.event = event;
	this.receiveTimestampNanos = realtimeTimestampNanos;
	}
	}

	private class SensorEventVerifier implements SensorEventListener {
	private volatile CountDownLatch mCountDownLatch;
	private volatile SensorEventRegistry mEventRegistry;
	private volatile long mTimestampForLastSensorEvent = 0;

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

	@Override
	public void onSensorChanged(SensorEvent event) {
	long elapsedRealtimeNanos = SystemClock.elapsedRealtimeNanos();
	int type = event.sensor.getType();

	if (type == Sensor.TYPE_LOW_LATENCY_OFFBODY_DETECT) {
	switch((int) event.values[0]) {
	case (int) OFF_BODY_EVENT_VALUE:
	Log.i(TAG, "onSensorChanged(): OFF_BODY ts="+event.timestamp+
	", now="+elapsedRealtimeNanos+", delta="+
	(elapsedRealtimeNanos-event.timestamp)/1000000+"mS");
	mPreviousSensorState = State.OFF_BODY;
	break;
	case (int) ON_BODY_EVENT_VALUE:
	Log.i(TAG, "onSensorChanged(): ON_BODY ts = "+event.timestamp+
	", now="+elapsedRealtimeNanos+", delta="+
	(elapsedRealtimeNanos-event.timestamp)/1000000+"mS");
	mPreviousSensorState = State.ON_BODY;
	break;
	default:
	Log.e(TAG, "onSensorChanged(): invalid value "+event.values[0]+
	" received");
	mBadValueSeen = event.values[0];
	break;
	}
	mEventRegistry = new SensorEventRegistry(event, elapsedRealtimeNanos);
	getTestLogger().logMessage(
	R.string.snsr_offbody_state_change,
	(int) event.values[0],
	elapsedRealtimeNanos);
	releaseLatch();
	}
	}

	public void releaseLatch() {
	if (mCountDownLatch != null) {
	mCountDownLatch.countDown();
	}
	}

	public long getTimeStampForSensorEvent() {
	return mTimestampForLastSensorEvent;
	}

	public String awaitAndVerifyEvent(float expectedResponseValue) throws Throwable {
	return awaitAndVerifyEvent(expectedResponseValue, 0);
	}

	public String awaitAndVerifyEvent(float expectedResponseValue, int maxEventLatencyMs)
	throws Throwable {
	SensorEventRegistry registry = waitForEvent();
	String eventArrivalMessage;
	if ((registry == null) \|\| (registry.event == null)) {
	eventArrivalMessage = getString(R.string.snsr_offbody_event_arrival, false);
	Assert.fail(eventArrivalMessage);
	}

	// verify an event arrived, and it is indeed a Low Latency Offbody Detect event
	SensorEvent event = registry.event;
	eventArrivalMessage = getString(R.string.snsr_offbody_event_arrival, event != null);
	Assert.assertNotNull(eventArrivalMessage, event);

	String result = verifyEvent(registry, expectedResponseValue, maxEventLatencyMs);
	return result;
	}

	public String verifyEvent(SensorEventRegistry registry, float expectedResponseValue,
	int maxEventLatencyMs) throws Throwable {
	int eventType = registry.event.sensor.getType();
	String eventTypeMessage = getString(
	R.string.snsr_offbody_event_type,
	Sensor.TYPE_LOW_LATENCY_OFFBODY_DETECT,
	eventType);
	Assert.assertEquals(eventTypeMessage,
	Sensor.TYPE_LOW_LATENCY_OFFBODY_DETECT,
	eventType);

	float value = registry.event.values[0];
	String sensorName = registry.event.sensor.getName();
	String eventName = (value == ON_BODY_EVENT_VALUE) ? "ON-BODY" : "OFF-BODY";

	long eventLatencyMs = (registry.receiveTimestampNanos/NANOSECONDS_PER_MILLISECOND)
	- mTestStartTimestampMs;

	int valuesLength = registry.event.values.length;
	String valuesLengthMessage = getString(
	R.string.snsr_event_length,
	OFFBODY_EVENT_VALUES_LENGTH,
	valuesLength,
	sensorName);
	Assert.assertEquals(valuesLengthMessage, OFFBODY_EVENT_VALUES_LENGTH, valuesLength);

	String valuesMessage = getString(
	R.string.snsr_event_value,
	expectedResponseValue,
	value,
	sensorName);
	Assert.assertEquals(valuesMessage, expectedResponseValue, value);

	if (maxEventLatencyMs != 0) {
	Log.i(TAG, "event latency was "+eventLatencyMs+" ms for "+
	eventName+" event");
	String responseViolationMessage = getString(
	R.string.snsr_offbody_response_timing_violation,
	eventName,
	maxEventLatencyMs,
	eventLatencyMs);
	boolean violation = (eventLatencyMs > maxEventLatencyMs);
	Assert.assertFalse(responseViolationMessage, violation);
	}
	return null;
	}

	private void verifyOffbodyEventNotInvalid() throws InterruptedException {
	if (mBadValueSeen != BAD_VALUE_SEEN_INIT) {
	Assert.fail(
	String.format(getString(R.string.snsr_offbody_event_invalid_value),
	OFF_BODY_EVENT_VALUE,
	ON_BODY_EVENT_VALUE,
	mBadValueSeen));
	}
	}

	private SensorEventRegistry waitForEvent() throws InterruptedException {
	return waitForEvent(null);
	}

	private SensorEventRegistry waitForEvent(PowerManager.WakeLock suspendLock)
	throws InterruptedException {
	mCountDownLatch = new CountDownLatch(1);

	if ((suspendLock != null) && suspendLock.isHeld()) {
	suspendLock.release();
	}

	mCountDownLatch.await(LLOB_EVENT_MAX_DELAY_SEC, TimeUnit.SECONDS);

	if ((suspendLock != null) && !suspendLock.isHeld()) {
	suspendLock.acquire();
	}

	SensorEventRegistry registry = mEventRegistry;

	// Save the last timestamp when the event triggered.
	if (mEventRegistry != null && mEventRegistry.event != null) {
	mTimestampForLastSensorEvent = mEventRegistry.event.timestamp;
	}

	mEventRegistry = null;
	verifyOffbodyEventNotInvalid();
	return registry != null ? registry : new SensorEventRegistry(null, 0);
	}

	public SensorEvent waitForSensorEvent() throws InterruptedException {
	SensorEvent event = null;
	mCountDownLatch = new CountDownLatch(1);
	mCountDownLatch.await(LLOB_EVENT_MAX_DELAY_SEC, TimeUnit.SECONDS);

	if (mEventRegistry != null && mEventRegistry.event != null) {
	event = mEventRegistry.event;
	}

	mEventRegistry = null;
	verifyOffbodyEventNotInvalid();
	return event;
	}
	}

	public OffBodySensorTestActivity() {
	super(OffBodySensorTestActivity.class);
	}


	@Override
	protected void activitySetUp() throws InterruptedException {
	PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE);
	mDeviceSuspendLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK,
	"OffBodySensorTestActivity");
	mDeviceSuspendLock.acquire();
	mOffBodySensorRegistered = false;
	mSensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);
	mOffBodySensor = mSensorManager.getDefaultSensor(Sensor.TYPE_LOW_LATENCY_OFFBODY_DETECT,
	true);
	if (mOffBodySensor == null) {
	setTestResultAndFinish(true);
	return;
	}
	LocalBroadcastManager.getInstance(this).registerReceiver(myBroadCastReceiver,
	new IntentFilter(ACTION_ALARM));
	Intent intent = new Intent(this, AlarmReceiver.class);
	mPendingIntent = PendingIntent.getBroadcast(this, 0, intent, 0);
	mAlarmManager = (AlarmManager) getSystemService(ALARM_SERVICE);
	mScreenManipulator = new SensorTestScreenManipulator(this);
	try {
	mScreenManipulator.initialize(this);
	} catch (InterruptedException e) {
	}
	}

	private void startTimeoutTimer(long delayMs) {
	mAlarmManager.setExact(AlarmManager.ELAPSED_REALTIME_WAKEUP,
	SystemClock.elapsedRealtime() + delayMs,
	mPendingIntent);
	}

	private void stopTimeoutTimer() {
	mAlarmManager.cancel(mPendingIntent);
	}

	private void stopOffbodySensorListener(SensorEventVerifier verifier) {
	if (mOffBodySensorRegistered) {
	mSensorManager.unregisterListener(verifier);
	mOffBodySensorRegistered = false;
	}
	}

	private boolean startOffbodySensorListener(SensorEventVerifier verifier) {
	if (!mOffBodySensorRegistered) {
	if (!mSensorManager.registerListener(verifier, mOffBodySensor,
	SensorManager.SENSOR_DELAY_FASTEST)) {
	Log.e(TAG, "error registering listener for LLOB");
	setTestResultAndFinish(true);
	return false;
	}
	mOffBodySensorRegistered = true;
	}
	return true;
	}

	public static class AlarmReceiver extends BroadcastReceiver {
	@Override
	public void onReceive(Context context, Intent intent) {
	Intent alarm_intent = new Intent(context, OffBodySensorTestActivity.class);
	alarm_intent.setAction(OffBodySensorTestActivity.ACTION_ALARM);
	LocalBroadcastManager.getInstance(context).sendBroadcastSync(alarm_intent);
	}
	}

	public BroadcastReceiver myBroadCastReceiver = new BroadcastReceiver() {
	@Override
	public void onReceive(Context context, Intent intent) {
	mVerifier.releaseLatch();
	mScreenManipulator.turnScreenOn();
	if (!mDeviceSuspendLock.isHeld()) {
	mDeviceSuspendLock.acquire();
	}
	}
	};

	public String testOffbodyDetectResponseTime() throws Throwable {
	Sensor wakeUpSensor = mSensorManager.getDefaultSensor(
	Sensor.TYPE_LOW_LATENCY_OFFBODY_DETECT, true);
	if (wakeUpSensor == null) {
	throw new SensorNotSupportedException(Sensor.TYPE_LOW_LATENCY_OFFBODY_DETECT, true);
	}
	return runOffbodyDetectResponseTimeTest(wakeUpSensor);
	}

	public String testOnbodyDetectResponseTime() throws Throwable {
	Sensor wakeUpSensor = mSensorManager.getDefaultSensor(
	Sensor.TYPE_LOW_LATENCY_OFFBODY_DETECT, true);
	if (wakeUpSensor == null) {
	throw new SensorNotSupportedException(Sensor.TYPE_LOW_LATENCY_OFFBODY_DETECT, true);
	}
	return runOnbodyDetectResponseTimeTest(wakeUpSensor);
	}

	public String testWakeAPOffbodyDetect() throws Throwable {
	Sensor wakeUpSensor = mSensorManager.getDefaultSensor(
	Sensor.TYPE_LOW_LATENCY_OFFBODY_DETECT, true);
	if (wakeUpSensor == null) {
	throw new SensorNotSupportedException(Sensor.TYPE_LOW_LATENCY_OFFBODY_DETECT, true);
	}
	return runWakeAPOffbodyDetectTest(wakeUpSensor);
	}

	public String runOffbodyDetectResponseTimeTest(Sensor sensor) throws Throwable {
	boolean success;
	String eventArrivalMessage;
	mOffBodySensor = sensor;
	mBadValueSeen = BAD_VALUE_SEEN_INIT;

	try {
	// If device not currently on-body, instruct user to put it on wrist
	mTestStartTimestampMs = 0;
	mVerifier = new SensorEventVerifier();
	success = startOffbodySensorListener(mVerifier);
	Assert.assertTrue(
	getString(R.string.snsr_offbody_sensor_registration, success),
	success);
	SensorEvent event = mVerifier.waitForSensorEvent();
	eventArrivalMessage = getString(R.string.snsr_offbody_event_arrival, event != null);
	Assert.assertNotNull(eventArrivalMessage, event);

	SensorTestLogger logger = getTestLogger();
	if (event.values[0] != ON_BODY_EVENT_VALUE) {
	// Instruct user on how to perform offbody detect test
	logger.logInstructions(R.string.snsr_start_offbody_sensor_test_instr);
	waitForUserToBegin();
	if (mPreviousSensorState != State.ON_BODY) {
	event = mVerifier.waitForSensorEvent();
	eventArrivalMessage = getString(R.string.snsr_offbody_event_arrival,
	event != null);
	Assert.assertNotNull(eventArrivalMessage, event);
	if (event.values[0] != ON_BODY_EVENT_VALUE) {
	Assert.fail(
	String.format(getString(R.string.snsr_offbody_event_wrong_value),
	ON_BODY_EVENT_VALUE,
	event.values[0]));
	}
	}
	}

	// Instruct user on how to perform offbody detect test
	logger.logInstructions(R.string.snsr_offbody_detect_test_instr);
	waitForUserToBegin();

	// Count down before actually starting, leaving time to react after pressing the Next
	// button.
	for (int i = 0; i < COUNTDOWN_NUM_INTERVALS; i++) {
	try {
	Thread.sleep(COUNTDOWN_INTERVAL_MS);
	} catch (InterruptedException e) {
	// Ignore the interrupt and continue counting down.
	}
	logger.logInstructions(R.string.snsr_offbody_detect_test_countdown,
	COUNTDOWN_NUM_INTERVALS - i - 1);
	}
	mTestStartTimestampMs = SystemClock.elapsedRealtime();

	// Verify off-body event latency is within spec
	mVerifier.awaitAndVerifyEvent(OFF_BODY_EVENT_VALUE, MAX_OFF_BODY_EVENT_LATENCY_MS);
	} finally {
	stopOffbodySensorListener(mVerifier);
	}
	return null;
	}

	public String runOnbodyDetectResponseTimeTest(Sensor sensor) throws Throwable {
	mOffBodySensor = sensor;
	SensorTestLogger logger = getTestLogger();
	mBadValueSeen = BAD_VALUE_SEEN_INIT;

	try {
	// If device not currently off-body, instruct user to remove it from wrist
	mTestStartTimestampMs = 0;
	mVerifier = new SensorEventVerifier();
	boolean success = startOffbodySensorListener(mVerifier);
	Assert.assertTrue(
	getString(R.string.snsr_offbody_sensor_registration, success),
	success);
	SensorEvent event = mVerifier.waitForSensorEvent();
	String eventArrivalMessage = getString(R.string.snsr_offbody_event_arrival,
	event != null);
	Assert.assertNotNull(eventArrivalMessage, event);
	if (event.values[0] != OFF_BODY_EVENT_VALUE) {
	// Instruct user on how to perform offbody detect test
	logger.logInstructions(R.string.snsr_start_onbody_sensor_test_instr);
	waitForUserToBegin();
	if (mPreviousSensorState != State.OFF_BODY) {
	event = mVerifier.waitForSensorEvent();
	eventArrivalMessage = getString(R.string.snsr_offbody_event_arrival,
	event != null);
	Assert.assertNotNull(eventArrivalMessage, event);
	if (event.values[0] != OFF_BODY_EVENT_VALUE) {
	Assert.fail(
	String.format(getString(R.string.snsr_offbody_event_wrong_value),
	OFF_BODY_EVENT_VALUE,
	event.values[0]));
	}
	}
	}

	// Display on-body latency test instructions
	logger.logInstructions(R.string.snsr_onbody_detect_test_instr);
	waitForUserToBegin();
	mTestStartTimestampMs = SystemClock.elapsedRealtime();
	mVerifier.awaitAndVerifyEvent(ON_BODY_EVENT_VALUE, MAX_ON_BODY_EVENT_LATENCY_MS);
	} finally {
	stopOffbodySensorListener(mVerifier);
	}
	return null;
	}

	public String runWakeAPOffbodyDetectTest(Sensor sensor) throws Throwable {
	final long ALARM_WAKE_UP_DELAY_MS = 40000;
	String eventArrivalMessage;
	SensorEventRegistry registry;
	SensorTestLogger logger = getTestLogger();
	mBadValueSeen = BAD_VALUE_SEEN_INIT;
	mVerifier = new SensorEventVerifier();
	mOffBodySensor = sensor;
	mTestStartTimestampMs = 0;

	mTestStartTimestampMs = SystemClock.elapsedRealtime();
	SuspendStateMonitor suspendStateMonitor = new SuspendStateMonitor();
	try {
	boolean success = startOffbodySensorListener(mVerifier);
	Assert.assertTrue(
	getString(R.string.snsr_offbody_sensor_registration, success),
	success);

	// grab the current off-body state, which should be ON-BODY
	if (mPreviousSensorState != State.ON_BODY) {
	registry = mVerifier.waitForEvent();
	if ((registry == null) \|\| (registry.event == null) \|\|
	(registry.event.values[0] != ON_BODY_EVENT_VALUE)) {
	eventArrivalMessage = getString(R.string.snsr_offbody_event_arrival, false);
	Assert.fail(eventArrivalMessage);

	// Tell user to put watch on wrist
	logger.logInstructions(R.string.snsr_start_offbody_sensor_test_instr);
	waitForUserToBegin();
	if (mPreviousSensorState != State.ON_BODY) {
	registry = mVerifier.waitForEvent();
	if ((registry == null) \|\| (registry.event == null)) {
	eventArrivalMessage = getString(R.string.snsr_offbody_event_arrival, false);
	Assert.fail(eventArrivalMessage);
	} else {
	Assert.assertTrue(
	String.format(getString(R.string.snsr_offbody_event_wrong_value),
	ON_BODY_EVENT_VALUE,
	registry.event.values[0]),
	ON_BODY_EVENT_VALUE == registry.event.values[0]);
	}
	}
	}
	}

	// Instruct user on how to perform offbody detect sleep test
	logger.logInstructions(R.string.snsr_ap_wake_offbody_detect_test_instr);
	waitForUserToBegin();

	long testStartTimeNs = SystemClock.elapsedRealtimeNanos();
	startTimeoutTimer(ALARM_WAKE_UP_AP_DELAY_MS);

	// Wait for the first event to trigger. Device is expected to go into suspend here.
	registry = mVerifier.waitForEvent(mDeviceSuspendLock);
	if ((registry == null) \|\| (registry.event == null)) {
	eventArrivalMessage = getString(R.string.snsr_offbody_event_arrival, false);
	Assert.fail(eventArrivalMessage);
	}

	mVerifier.verifyEvent(registry, OFF_BODY_EVENT_VALUE, 0);

	long eventTimeStampNs = registry.event.timestamp;
	long endTimeNs = SystemClock.elapsedRealtimeNanos();
	long lastWakeupTimeNs = TimeUnit.MILLISECONDS.toNanos(
	suspendStateMonitor.getLastWakeUpTime());
	Assert.assertTrue(getString(R.string.snsr_device_did_not_go_into_suspend),
	testStartTimeNs < lastWakeupTimeNs && lastWakeupTimeNs < endTimeNs);
	long timestampDelta = Math.abs(lastWakeupTimeNs - eventTimeStampNs);
	Assert.assertTrue(
	String.format(getString(R.string.snsr_device_did_not_wake_up_at_trigger),
	TimeUnit.NANOSECONDS.toMillis(lastWakeupTimeNs),
	TimeUnit.NANOSECONDS.toMillis(eventTimeStampNs)),
	timestampDelta < MAX_ACCEPTABLE_DELAY_EVENT_AP_WAKE_UP_NS);
	} finally {
	stopTimeoutTimer();
	suspendStateMonitor.cancel();
	mScreenManipulator.turnScreenOn();
	playSound();
	}
	return null;
	}

	@Override
	protected void activityCleanUp() {
	if (mOffBodySensorRegistered) {
	stopOffbodySensorListener(mVerifier);
	}
	stopTimeoutTimer();
	LocalBroadcastManager.getInstance(this).unregisterReceiver(myBroadCastReceiver);
	if (mOffBodySensor != null) {
	mOffBodySensor = null;
	}
	if (mScreenManipulator != null){
	mScreenManipulator.close();
	}
	if ((mDeviceSuspendLock != null) && mDeviceSuspendLock.isHeld()) {
	mDeviceSuspendLock.release();
	}
	}
	}