android-12.0.0_r2/s

/*
 * 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 android.hardware.cts;

import android.content.Context;
import android.hardware.HardwareBuffer;
import android.hardware.Sensor;
import android.hardware.SensorDirectChannel;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;
import android.hardware.cts.helpers.SensorCtsHelper;
import android.hardware.cts.helpers.SensorCtsHelper.TestResultCollector;
import android.os.MemoryFile;
import android.os.SystemClock;
import android.util.Log;

import java.io.IOException;
import java.io.UncheckedIOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.TimeUnit;

/**
 * Checks Sensor Direct Report functionality
 *
 * This testcase tests operation of:
 *   - SensorManager.createDirectChannel()
 *   - SensorDirectChannel.*
 *   - Sensor.getHighestDirectReportRateLevel()
 *   - Sensor.isDirectChannelTypeSupported()
 *
 * Tests:
 *   - test<Sensor><SharedMemoryType><RateLevel>
 *     tests basic operation of sensor in direct report mode at various rate level specification.
 *   - testRateIndependency<Sensor1><Sensor2>SingleChannel
 *     tests if two sensors in the same direct channel are able to run at different rates.
 *   - testRateIndependency<Sensor>MultiChannel
 *     tests if a sensor is able to be configured to different rate levels for multiple channels.
 *   - testRateIndependency<Sensor>MultiMode
 *     tests if a sensor is able to report at different rates in direct report mode and traditional
 *     report mode (polling).
 *   - testTimestamp<Sensor>
 *     tests if the timestamp is correct both in absolute sense and relative to traditional report.
 *   - testAtomicCounter<Sensor>
 *     test if atomic counter is increased as specified and if sensor event content is fully updated
 *     before update of atomic counter.
 *   - testRegisterMultipleChannels
 *     test scenarios when multiple channels are registered simultaneously.
 *   - testReconfigure
 *     test channel reconfiguration (configure to a rate level; configure to stop; configure to
 *     another rate level)
 *   - testRegisterMultipleChannelsUsingSameMemory
 *     test a negative case when the same memory is being used twice for registering sensor direct
 *     channel
 *   - testCloseWithoutConfigStop
 *     test a common mistake in API usage and make sure no negative effect is made to system.
 */
public class SensorDirectReportTest extends SensorTestCase {
    private static final String TAG = "SensorDirectReportTest";
    // nominal rates of each rate level supported
    private static final float RATE_NORMAL_NOMINAL = 50;
    private static final float RATE_FAST_NOMINAL = 200;
    private static final float RATE_VERY_FAST_NOMINAL = 800;

    // actuall value is allowed to be 55% to 220% of nominal value
    private static final float FREQ_LOWER_BOUND = 0.55f;
    private static final float FREQ_UPPER_BOUND = 2.2f;

    // actuall value is allowed to be 90% to 200% of nominal value in poll() interface
    private static final float FREQ_LOWER_BOUND_POLL = 0.90f;
    private static final float FREQ_UPPER_BOUND_POLL = 2.00f;

    // sensor reading assumption
    private static final float GRAVITY_MIN = 9.81f - 1.0f;
    private static final float GRAVITY_MAX = 9.81f + 1.0f;
    private static final float GYRO_NORM_MAX = 0.1f;

    // test constants
    public static final int REST_PERIOD_BEFORE_TEST_MILLISEC = 3000;
    private static final int TEST_RUN_TIME_PERIOD_MILLISEC = 5000;
    private static final int ALLOWED_SENSOR_INIT_TIME_MILLISEC = 500;
    private static final int SENSORS_EVENT_SIZE = 104;
    private static final int ATOMIC_COUNTER_OFFSET = 12;
    private static final int ATOMIC_COUNTER_SIZE = 4;
    private static final int SENSORS_EVENT_COUNT = 10240; // 800Hz * 2.2 * 5 sec + extra
    private static final int SHARED_MEMORY_SIZE = SENSORS_EVENT_COUNT * SENSORS_EVENT_SIZE;
    private static final float MERCY_FACTOR = 0.1f;
    private static final boolean CHECK_ABSOLUTE_LATENCY = false;

    // list of rate levels being tested
    private static final int[] POSSIBLE_RATE_LEVELS = new int[] {
            SensorDirectChannel.RATE_NORMAL,
            SensorDirectChannel.RATE_FAST,
            SensorDirectChannel.RATE_VERY_FAST
        };

    // list of channel types being tested
    private static final int[] POSSIBLE_CHANNEL_TYPES = new int [] {
            SensorDirectChannel.TYPE_MEMORY_FILE,
            SensorDirectChannel.TYPE_HARDWARE_BUFFER
        };

    // list of sensor types being tested
    private static final int[] POSSIBLE_SENSOR_TYPES = new int [] {
            Sensor.TYPE_ACCELEROMETER,
            Sensor.TYPE_GYROSCOPE,
            Sensor.TYPE_MAGNETIC_FIELD
        };

    // list of sampling period being tested
    private static final int[] POSSIBLE_SAMPLE_PERIOD_US = new int [] {
            200_000, // Normal 5 Hz
            66_667,  // UI    15 Hz
            20_000,  // Game  50 Hz
            5_000,   // 200Hz
            0        // fastest
        };

    private static final ByteOrder NATIVE_BYTE_ORDER = ByteOrder.nativeOrder();

    private static native boolean nativeReadHardwareBuffer(HardwareBuffer hardwareBuffer,
            byte[] buffer, int srcOffset, int destOffset, int count);

    private boolean mNeedMemoryFile;
    private MemoryFile mMemoryFile;
    private MemoryFile mMemoryFileSecondary;
    private boolean mNeedHardwareBuffer;
    private HardwareBuffer mHardwareBuffer;
    private HardwareBuffer mHardwareBufferSecondary;
    private ByteBuffer mByteBuffer;
    private byte[] mBuffer;

    private SensorManager mSensorManager;
    private SensorDirectChannel mChannel;
    private SensorDirectChannel mChannelSecondary;

    private EventPool mEventPool;

    static {
        System.loadLibrary("cts-sensors-ndk-jni");
    }

    @Override
    protected void setUp() throws Exception {
        super.setUp();

        mByteBuffer = ByteBuffer.allocate(SHARED_MEMORY_SIZE);
        mBuffer = mByteBuffer.array();
        mByteBuffer.order(ByteOrder.nativeOrder());

        mEventPool = new EventPool(10 * SENSORS_EVENT_COUNT);
        mSensorManager = (SensorManager) getContext().getSystemService(Context.SENSOR_SERVICE);

        mNeedMemoryFile = isMemoryTypeNeeded(SensorDirectChannel.TYPE_MEMORY_FILE);
        mNeedHardwareBuffer = isMemoryTypeNeeded(SensorDirectChannel.TYPE_HARDWARE_BUFFER);

        allocateSharedMemory();
    }

    @Override
    protected void tearDown() throws Exception {
        if (mChannel != null) {
            mChannel.close();
            mChannel = null;
        }

        if (mChannelSecondary != null) {
            mChannelSecondary.close();
            mChannelSecondary = null;
        }

        freeSharedMemory();
        super.tearDown();
    }

    public void testSharedMemoryAllocation() throws AssertionError {
        assertTrue("allocating MemoryFile returned null: "
                        + (mMemoryFile == null) + ", " + (mMemoryFileSecondary == null),
                   !mNeedMemoryFile || (mMemoryFile != null && mMemoryFileSecondary != null));
        assertTrue("allocating HardwareBuffer returned null: "
                        + (mHardwareBuffer == null) + ", " + (mHardwareBufferSecondary == null),
                   !mNeedHardwareBuffer ||
                       (mHardwareBuffer != null && mHardwareBufferSecondary != null));
    }

    public void testAccelerometerAshmemNormal() {
        runSensorDirectReportTest(
                Sensor.TYPE_ACCELEROMETER,
                SensorDirectChannel.TYPE_MEMORY_FILE,
                SensorDirectChannel.RATE_NORMAL);
    }

    public void testAccelerometerAshmemNormalUidIdle() {
        runSensorDirectReportUidIdleTest(
                Sensor.TYPE_ACCELEROMETER,
                SensorDirectChannel.TYPE_MEMORY_FILE,
                SensorDirectChannel.RATE_NORMAL);
    }

    public void testGyroscopeAshmemNormal() {
        runSensorDirectReportTest(
                Sensor.TYPE_GYROSCOPE,
                SensorDirectChannel.TYPE_MEMORY_FILE,
                SensorDirectChannel.RATE_NORMAL);
    }

    public void testGyroscopeAshmemNormalUidIdle() {
        runSensorDirectReportUidIdleTest(
                Sensor.TYPE_GYROSCOPE,
                SensorDirectChannel.TYPE_MEMORY_FILE,
                SensorDirectChannel.RATE_NORMAL);
    }

    public void testMagneticFieldAshmemNormal() {
        runSensorDirectReportTest(
                Sensor.TYPE_MAGNETIC_FIELD,
                SensorDirectChannel.TYPE_MEMORY_FILE,
                SensorDirectChannel.RATE_NORMAL);
    }

    public void testMagneticFieldAshmemNormalUidIdle() {
        runSensorDirectReportUidIdleTest(
                Sensor.TYPE_MAGNETIC_FIELD,
                SensorDirectChannel.TYPE_MEMORY_FILE,
                SensorDirectChannel.RATE_NORMAL);
    }

    public void testAccelerometerAshmemFast() {
        runSensorDirectReportTest(
                Sensor.TYPE_ACCELEROMETER,
                SensorDirectChannel.TYPE_MEMORY_FILE,
                SensorDirectChannel.RATE_FAST);
    }

    public void testAccelerometerAshmemFastUidIdle() {
        runSensorDirectReportUidIdleTest(
                Sensor.TYPE_ACCELEROMETER,
                SensorDirectChannel.TYPE_MEMORY_FILE,
                SensorDirectChannel.RATE_FAST);
    }

    public void testGyroscopeAshmemFast() {
        runSensorDirectReportTest(
                Sensor.TYPE_GYROSCOPE,
                SensorDirectChannel.TYPE_MEMORY_FILE,
                SensorDirectChannel.RATE_FAST);
    }

    public void testGyroscopeAshmemFastUidIdle() {
        runSensorDirectReportUidIdleTest(
                Sensor.TYPE_GYROSCOPE,
                SensorDirectChannel.TYPE_MEMORY_FILE,
                SensorDirectChannel.RATE_FAST);
    }

    public void testMagneticFieldAshmemFast() {
        runSensorDirectReportTest(
                Sensor.TYPE_MAGNETIC_FIELD,
                SensorDirectChannel.TYPE_MEMORY_FILE,
                SensorDirectChannel.RATE_FAST);
    }

    public void testMagneticFieldAshmemFastUidIdle() {
        runSensorDirectReportUidIdleTest(
                Sensor.TYPE_MAGNETIC_FIELD,
                SensorDirectChannel.TYPE_MEMORY_FILE,
                SensorDirectChannel.RATE_FAST);
    }

    public void testAccelerometerAshmemVeryFast() {
        runSensorDirectReportTest(
                Sensor.TYPE_ACCELEROMETER,
                SensorDirectChannel.TYPE_MEMORY_FILE,
                SensorDirectChannel.RATE_VERY_FAST);
    }

    public void testAccelerometerAshmemVeryFastUidIdle() {
        runSensorDirectReportUidIdleTest(
                Sensor.TYPE_ACCELEROMETER,
                SensorDirectChannel.TYPE_MEMORY_FILE,
                SensorDirectChannel.RATE_VERY_FAST);
    }

    public void testGyroscopeAshmemVeryFast() {
        runSensorDirectReportTest(
                Sensor.TYPE_GYROSCOPE,
                SensorDirectChannel.TYPE_MEMORY_FILE,
                SensorDirectChannel.RATE_VERY_FAST);
    }

    public void testGyroscopeAshmemVeryFastUidIdle() {
        runSensorDirectReportUidIdleTest(
                Sensor.TYPE_GYROSCOPE,
                SensorDirectChannel.TYPE_MEMORY_FILE,
                SensorDirectChannel.RATE_VERY_FAST);
    }

    public void testMagneticFieldAshmemVeryFast() {
        runSensorDirectReportTest(
                Sensor.TYPE_MAGNETIC_FIELD,
                SensorDirectChannel.TYPE_MEMORY_FILE,
                SensorDirectChannel.RATE_VERY_FAST);
    }

    public void testMagneticFieldAshmemVeryFastUidIdle() {
        runSensorDirectReportUidIdleTest(
                Sensor.TYPE_MAGNETIC_FIELD,
                SensorDirectChannel.TYPE_MEMORY_FILE,
                SensorDirectChannel.RATE_VERY_FAST);
    }

    public void testAccelerometerHardwareBufferNormal() {
        runSensorDirectReportTest(
                Sensor.TYPE_ACCELEROMETER,
                SensorDirectChannel.TYPE_HARDWARE_BUFFER,
                SensorDirectChannel.RATE_NORMAL);
    }

    public void testAccelerometerHardwareBufferNormalUidIdle() {
        runSensorDirectReportUidIdleTest(
                Sensor.TYPE_ACCELEROMETER,
                SensorDirectChannel.TYPE_HARDWARE_BUFFER,
                SensorDirectChannel.RATE_NORMAL);
    }

    public void testGyroscopeHardwareBufferNormal() {
        runSensorDirectReportTest(
                Sensor.TYPE_GYROSCOPE,
                SensorDirectChannel.TYPE_HARDWARE_BUFFER,
                SensorDirectChannel.RATE_NORMAL);
    }

    public void testGyroscopeHardwareBufferNormalUidIdle() {
        runSensorDirectReportUidIdleTest(
                Sensor.TYPE_GYROSCOPE,
                SensorDirectChannel.TYPE_HARDWARE_BUFFER,
                SensorDirectChannel.RATE_NORMAL);
    }

    public void testMagneticFieldHardwareBufferNormal() {
        runSensorDirectReportTest(
                Sensor.TYPE_MAGNETIC_FIELD,
                SensorDirectChannel.TYPE_HARDWARE_BUFFER,
                SensorDirectChannel.RATE_NORMAL);
    }

    public void testMagneticFieldHardwareBufferNormalUidIdle() {
        runSensorDirectReportUidIdleTest(
                Sensor.TYPE_MAGNETIC_FIELD,
                SensorDirectChannel.TYPE_HARDWARE_BUFFER,
                SensorDirectChannel.RATE_NORMAL);
    }

    public void testAccelerometerHardwareBufferFast() {
        runSensorDirectReportTest(
                Sensor.TYPE_ACCELEROMETER,
                SensorDirectChannel.TYPE_HARDWARE_BUFFER,
                SensorDirectChannel.RATE_FAST);
    }

    public void testAccelerometerHardwareBufferFastUidIdle() {
        runSensorDirectReportUidIdleTest(
                Sensor.TYPE_ACCELEROMETER,
                SensorDirectChannel.TYPE_HARDWARE_BUFFER,
                SensorDirectChannel.RATE_FAST);
    }

    public void testGyroscopeHardwareBufferFast() {
        runSensorDirectReportTest(
                Sensor.TYPE_GYROSCOPE,
                SensorDirectChannel.TYPE_HARDWARE_BUFFER,
                SensorDirectChannel.RATE_FAST);
    }
    public void testGyroscopeHardwareBufferFastUidIdle() {
        runSensorDirectReportUidIdleTest(
                Sensor.TYPE_GYROSCOPE,
                SensorDirectChannel.TYPE_HARDWARE_BUFFER,
                SensorDirectChannel.RATE_FAST);
    }

    public void testMagneticFieldHardwareBufferFast() {
        runSensorDirectReportTest(
                Sensor.TYPE_MAGNETIC_FIELD,
                SensorDirectChannel.TYPE_HARDWARE_BUFFER,
                SensorDirectChannel.RATE_FAST);
    }

    public void testMagneticFieldHardwareBufferFastUidIdle() {
        runSensorDirectReportUidIdleTest(
                Sensor.TYPE_MAGNETIC_FIELD,
                SensorDirectChannel.TYPE_HARDWARE_BUFFER,
                SensorDirectChannel.RATE_FAST);
    }

    public void testAccelerometerHardwareBufferVeryFast() {
        runSensorDirectReportTest(
                Sensor.TYPE_ACCELEROMETER,
                SensorDirectChannel.TYPE_HARDWARE_BUFFER,
                SensorDirectChannel.RATE_VERY_FAST);
    }

    public void testAccelerometerHardwareBufferVeryFastUidIdle() {
        runSensorDirectReportUidIdleTest(
                Sensor.TYPE_ACCELEROMETER,
                SensorDirectChannel.TYPE_HARDWARE_BUFFER,
                SensorDirectChannel.RATE_VERY_FAST);
    }

    public void testGyroscopeHardwareBufferVeryFast() {
        runSensorDirectReportTest(
                Sensor.TYPE_GYROSCOPE,
                SensorDirectChannel.TYPE_HARDWARE_BUFFER,
                SensorDirectChannel.RATE_VERY_FAST);
    }

    public void testGyroscopeHardwareBufferVeryFastUidIdle() {
        runSensorDirectReportUidIdleTest(
                Sensor.TYPE_GYROSCOPE,
                SensorDirectChannel.TYPE_HARDWARE_BUFFER,
                SensorDirectChannel.RATE_VERY_FAST);
    }

    public void testMagneticFieldHardwareBufferVeryFast() {
        runSensorDirectReportTest(
                Sensor.TYPE_MAGNETIC_FIELD,
                SensorDirectChannel.TYPE_HARDWARE_BUFFER,
                SensorDirectChannel.RATE_VERY_FAST);
    }

    public void testMagneticFieldHardwareBufferVeryFastUidIdle() {
        runSensorDirectReportUidIdleTest(
                Sensor.TYPE_MAGNETIC_FIELD,
                SensorDirectChannel.TYPE_HARDWARE_BUFFER,
                SensorDirectChannel.RATE_VERY_FAST);
    }

    public void testRateIndependencyAccelGyroSingleChannel() {
        runSingleChannelRateIndependencyTestGroup(Sensor.TYPE_ACCELEROMETER,
                                                  Sensor.TYPE_GYROSCOPE);
    }

    public void testRateIndependencyAccelMagSingleChannel() {
        runSingleChannelRateIndependencyTestGroup(Sensor.TYPE_ACCELEROMETER,
                                                  Sensor.TYPE_MAGNETIC_FIELD);
    }

    public void testRateIndependencyGyroMagSingleChannel() {
        runSingleChannelRateIndependencyTestGroup(Sensor.TYPE_GYROSCOPE,
                                                  Sensor.TYPE_MAGNETIC_FIELD);
    }

    public void testRateIndependencyAccelUncalAccelSingleChannel() {
        runSingleChannelRateIndependencyTestGroup(Sensor.TYPE_ACCELEROMETER,
                                             Sensor.TYPE_ACCELEROMETER_UNCALIBRATED);
    }

    public void testRateIndependencyGyroUncalGyroSingleChannel() {
        runSingleChannelRateIndependencyTestGroup(Sensor.TYPE_GYROSCOPE,
                                             Sensor.TYPE_GYROSCOPE_UNCALIBRATED);
    }

    public void testRateIndependencyMagUncalMagSingleChannel() {
        runSingleChannelRateIndependencyTestGroup(Sensor.TYPE_MAGNETIC_FIELD,
                                             Sensor.TYPE_MAGNETIC_FIELD_UNCALIBRATED);
    }

    public void testRateIndependencyAccelMultiChannel() {
        runMultiChannelRateIndependencyTestGroup(Sensor.TYPE_ACCELEROMETER);
    }

    public void testRateIndependencyGyroMultiChannel() {
        runMultiChannelRateIndependencyTestGroup(Sensor.TYPE_GYROSCOPE);
    }

    public void testRateIndependencyMagMultiChannel() {
        runMultiChannelRateIndependencyTestGroup(Sensor.TYPE_MAGNETIC_FIELD);
    }

    public void testRateIndependencyAccelMultiMode() {
        runMultiModeRateIndependencyTestGroup(Sensor.TYPE_ACCELEROMETER);
    }

    public void testRateIndependencyGyroMultiMode() {
        runMultiModeRateIndependencyTestGroup(Sensor.TYPE_GYROSCOPE);
    }

    public void testRateIndependencyMagMultiMode() {
        runMultiModeRateIndependencyTestGroup(Sensor.TYPE_MAGNETIC_FIELD);
    }

    public void testTimestampAccel() {
        runTimestampTestGroup(Sensor.TYPE_ACCELEROMETER);
    }

    public void testTimestampGyro() {
        runTimestampTestGroup(Sensor.TYPE_GYROSCOPE);
    }

    public void testTimestampMag() {
        runTimestampTestGroup(Sensor.TYPE_MAGNETIC_FIELD);
    }

    public void testAtomicCounterAccel() {
        for (int memType : POSSIBLE_CHANNEL_TYPES) {
            runAtomicCounterTest(Sensor.TYPE_ACCELEROMETER, memType);
        }
    }

    public void testAtomicCounterGyro() {
        for (int memType : POSSIBLE_CHANNEL_TYPES) {
            runAtomicCounterTest(Sensor.TYPE_GYROSCOPE, memType);
        }
    }

    public void testAtomicCounterMag() {
        for (int memType : POSSIBLE_CHANNEL_TYPES) {
            runAtomicCounterTest(Sensor.TYPE_MAGNETIC_FIELD, memType);
        }
    }

    public void testRegisterMultipleChannels() throws AssertionError {
        resetEvent();
        freeSharedMemory();

        for (int memType : POSSIBLE_CHANNEL_TYPES) {
            if (!isMemoryTypeNeeded(memType)) {
                continue;
            }

            for (int repeat = 0; repeat < 10; ++repeat) {
                // allocate new memory every time
                allocateSharedMemory();

                mChannel = prepareDirectChannel(memType, false /* secondary */);
                assertNotNull("mChannel is null", mChannel);

                mChannelSecondary = prepareDirectChannel(memType, true /* secondary */);
                assertNotNull("mChannelSecondary is null", mChannelSecondary);

                if (mChannel != null) {
                    mChannel.close();
                    mChannel = null;
                }
                if (mChannelSecondary != null) {
                    mChannelSecondary.close();
                    mChannelSecondary = null;
                }

                // free shared memory
                freeSharedMemory();
            }
        }
    }

    public void testRegisterMultipleChannelsUsingSameMemory() throws AssertionError {
        // MemoryFile identification is not supported by Android yet
        int memType = SensorDirectChannel.TYPE_HARDWARE_BUFFER;
        if (!isMemoryTypeNeeded(memType)) {
            return;
        }

        mChannel = prepareDirectChannel(memType, false /* secondary */);
        assertNotNull("mChannel is null", mChannel);

        // use same memory to register, should fail.
        mChannelSecondary = prepareDirectChannel(memType, false /* secondary */);
        assertNull("mChannelSecondary is not null", mChannelSecondary);

        mChannel.close();
        // after mChannel.close(), memory should free up and this should return non-null
        // channel
        mChannelSecondary = prepareDirectChannel(memType, false /* secondary */);
        assertNotNull("mChannelSecondary is null", mChannelSecondary);
        mChannelSecondary.close();
    }

    public void testReconfigure() {
        TestResultCollector c = new TestResultCollector("testReconfigure", TAG);

        for (int type : POSSIBLE_SENSOR_TYPES) {
            for (int memType : POSSIBLE_CHANNEL_TYPES) {
                c.perform(() -> { runReconfigureTest(type, memType);},
                        String.format("sensor type %d, mem type %d", type, memType));
            }
        }
        c.judge();
    }

    public void testCloseWithoutConfigStop() {
        for (int type : POSSIBLE_SENSOR_TYPES) {
            for (int memType : POSSIBLE_CHANNEL_TYPES) {
                Sensor s = mSensorManager.getDefaultSensor(type);
                if (s == null
                        || s.getHighestDirectReportRateLevel() == SensorDirectChannel.RATE_STOP
                        || !s.isDirectChannelTypeSupported(memType)) {
                    continue;
                }

                mChannel = prepareDirectChannel(memType, false /* secondary */);
                assertTrue("createDirectChannel failed", mChannel != null);

                try {
                    waitBeforeStartSensor();
                    mChannel.configure(s, s.getHighestDirectReportRateLevel());

                    // wait for a while
                    waitBeforeStartSensor();

                    // The following line is commented out intentionally.
                    // mChannel.configure(s, SensorDirectChannel.RATE_STOP);
                } finally {
                    mChannel.close();
                    mChannel = null;
                }
                waitBeforeStartSensor();
            }
        }
    }

    private void runSingleChannelRateIndependencyTestGroup(int type1, int type2) {
        if (type1 == type2) {
            throw new IllegalArgumentException("Cannot run single channel rate independency test "
                    + "on type " + type1 + " and " + type2);
        }
        String stype1 = SensorCtsHelper.sensorTypeShortString(type1);
        String stype2 = SensorCtsHelper.sensorTypeShortString(type2);

        TestResultCollector c =
                new TestResultCollector(
                    "testRateIndependency" + stype1 + stype2 + "SingleChannel", TAG);

        for (int rate1 : POSSIBLE_RATE_LEVELS) {
            for (int rate2 : POSSIBLE_RATE_LEVELS) {
                for (int memType : POSSIBLE_CHANNEL_TYPES) {
                    c.perform(
                        () -> {
                            runSingleChannelRateIndependencyTest(
                                    type1, rate1, type2, rate2,
                                    SensorDirectChannel.TYPE_MEMORY_FILE);
                        },
                        String.format("(%s rate %d, %s rate %d, mem %d)",
                                      stype1, rate1, stype2, rate2, memType));
                }
            }
        }
        c.judge();
    }

    public void runMultiChannelRateIndependencyTestGroup(int sensorType) {
        TestResultCollector c = new TestResultCollector(
                "testRateIndependency" + SensorCtsHelper.sensorTypeShortString(sensorType)
                    + "MultiChannel", TAG);

        for (int rate1 : POSSIBLE_RATE_LEVELS) {
            for (int rate2 : POSSIBLE_RATE_LEVELS) {
                for (int type1 : POSSIBLE_CHANNEL_TYPES) {
                    for (int type2 : POSSIBLE_CHANNEL_TYPES) {
                        // only test upper triangle
                        if (rate1 > rate2 || type1 > type2) {
                            continue;
                        }
                        c.perform(() -> {
                                runMultiChannelRateIndependencyTest(
                                        sensorType, rate1, rate2, type1, type2);},
                                String.format("rate1 %d, rate2 %d, type1 %d, type2 %d",
                                              rate1, rate2, type1, type2));
                    }
                }
            }
        }
        c.judge();
    }

    public void runMultiModeRateIndependencyTestGroup(int sensorType) {
        TestResultCollector c = new TestResultCollector(
                "testRateIndependency" + SensorCtsHelper.sensorTypeShortString(sensorType)
                    + "MultiMode", TAG);

        for (int rate : POSSIBLE_RATE_LEVELS) {
            for (int type : POSSIBLE_CHANNEL_TYPES) {
                for (int samplingPeriodUs : POSSIBLE_SAMPLE_PERIOD_US) {
                    c.perform(() -> {runMultiModeRateIndependencyTest(
                                        sensorType, rate, type, samplingPeriodUs);},
                              String.format("rateLevel %d, memType %d, period %d",
                                            rate, type, samplingPeriodUs));
                }
            }
        }
        c.judge();
    }

    private void runTimestampTestGroup(int sensorType) {
        String stype = SensorCtsHelper.sensorTypeShortString(sensorType);

        TestResultCollector c =
                new TestResultCollector("testTimestamp" + stype, TAG);

        for (int rateLevel : POSSIBLE_RATE_LEVELS) {
            for (int memType : POSSIBLE_CHANNEL_TYPES) {
                c.perform(
                        () -> {
                            runTimestampTest(sensorType, rateLevel, memType);
                        },
                        String.format("(%s, rate %d, memtype %d)", stype, rateLevel, memType));
            }
        }
        c.judge();
    }

    private void runSensorDirectReportTest(int sensorType, int memType, int rateLevel)
            throws AssertionError {
        Sensor s = mSensorManager.getDefaultSensor(sensorType);
        if (s == null
                || s.getHighestDirectReportRateLevel() < rateLevel
                || !s.isDirectChannelTypeSupported(memType)) {
            return;
        }
        resetEvent();

        mChannel = prepareDirectChannel(memType, false /* secondary */);
        assertTrue("createDirectChannel failed", mChannel != null);

        try {
            assertTrue("Shared memory is not formatted", isSharedMemoryFormatted(memType));
            waitBeforeStartSensor();

            int token = mChannel.configure(s, rateLevel);
            assertTrue("configure direct mChannel failed", token > 0);

            waitSensorCollection();

            //stop sensor and analyze content
            mChannel.configure(s, SensorDirectChannel.RATE_STOP);
            checkSharedMemoryContent(s, memType, rateLevel, token);
        } finally {
            mChannel.close();
            mChannel = null;
        }
    }

    private void runSensorDirectReportUidIdleTest(int sensorType, int memType, int rateLevel) {
        Sensor s = mSensorManager.getDefaultSensor(sensorType);
        if (s == null
                || s.getHighestDirectReportRateLevel() < rateLevel
                || !s.isDirectChannelTypeSupported(memType)) {
            return;
        }
        resetEvent();

        mChannel = prepareDirectChannel(memType, false /* secondary */);
        assertTrue("createDirectChannel failed", mChannel != null);

        try {
            assertTrue("Shared memory is not formatted", isSharedMemoryFormatted(memType));
            waitBeforeStartSensor();

            int token = mChannel.configure(s, rateLevel);
            assertTrue("configure direct mChannel failed", token > 0);

            // Make package idle and ensure no sensor events are received
            try {
                SensorCtsHelper.makeMyPackageIdle();
            } catch (IOException e) {
                fail("IOException while making package idle");
            }

            int originalEventSize = mBuffer.length;
            waitSensorCollection();

            assertEquals(mBuffer.length, originalEventSize);

            try {
                SensorCtsHelper.makeMyPackageActive();
            } catch (IOException e) {
                fail("IOException while making package active");
            }

            // Also verify sensor events can be received after becoming active.
            resetEvent();

            waitSensorCollection();

            //stop sensor and analyze content
            mChannel.configure(s, SensorDirectChannel.RATE_STOP);
            checkSharedMemoryContent(s, memType, rateLevel, token);
        } finally {
            mChannel.close();
            mChannel = null;
        }
    }

    private void runSingleChannelRateIndependencyTest(
            int type1, int rateLevel1, int type2, int rateLevel2, int memType)
                throws AssertionError {
        Sensor s1 = mSensorManager.getDefaultSensor(type1);
        Sensor s2 = mSensorManager.getDefaultSensor(type2);
        if (s1 == null
                || s1.getHighestDirectReportRateLevel() < rateLevel1
                || !s1.isDirectChannelTypeSupported(memType)) {
            return;
        }

        if (s2 == null
                || s2.getHighestDirectReportRateLevel() < rateLevel2
                || !s2.isDirectChannelTypeSupported(memType)) {
            return;
        }
        resetEvent();

        mChannel = prepareDirectChannel(memType, false /* secondary */);
        assertTrue("createDirectChannel failed", mChannel != null);

        try {
            assertTrue("Shared memory is not formatted", isSharedMemoryFormatted(memType));
            waitBeforeStartSensor();

            int token1 = mChannel.configure(s1, rateLevel1);
            int token2 = mChannel.configure(s2, rateLevel2);
            assertTrue("configure direct mChannel failed, token1 = " + token1, token1 > 0);
            assertTrue("configure direct mChannel failed, token2 = " + token2, token2 > 0);

            // run half amount of time so buffer is enough for both sensors
            try {
                SensorCtsHelper.sleep(TEST_RUN_TIME_PERIOD_MILLISEC / 2, TimeUnit.MILLISECONDS);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }

            //stop sensor and analyze content
            mChannel.configure(s1, SensorDirectChannel.RATE_STOP);
            mChannel.configure(s2, SensorDirectChannel.RATE_STOP);

            readSharedMemory(memType, false /*secondary*/);
            checkEventRate(TEST_RUN_TIME_PERIOD_MILLISEC / 2,
                    parseEntireBuffer(token1, mEventPool, mByteBuffer, SHARED_MEMORY_SIZE),
                    type1, rateLevel1);
            checkEventRate(TEST_RUN_TIME_PERIOD_MILLISEC / 2,
                    parseEntireBuffer(token2, mEventPool, mByteBuffer, SHARED_MEMORY_SIZE),
                    type2, rateLevel2);
        } finally {
            mChannel.close();
            mChannel = null;
        }
    }

    private void runMultiChannelRateIndependencyTest(
            int type, int rateLevel1, int rateLevel2, int memType1, int memType2)
                throws AssertionError {
        Sensor s = mSensorManager.getDefaultSensor(type);
        if (s == null
                || s.getHighestDirectReportRateLevel() < Math.max(rateLevel1, rateLevel2)
                || !s.isDirectChannelTypeSupported(memType1)
                || !s.isDirectChannelTypeSupported(memType2)) {
            return;
        }
        resetEvent();

        mChannel = prepareDirectChannel(memType1, false /* secondary */);
        mChannelSecondary = prepareDirectChannel(memType2, true /* secondary */);

        try {
            assertTrue("createDirectChannel failed", mChannel != null);
            assertTrue("Shared memory is not formatted",
                       isSharedMemoryFormatted(memType1));

            assertTrue("createDirectChannel(secondary) failed", mChannelSecondary != null);
            assertTrue("Shared memory(secondary) is not formatted",
                       isSharedMemoryFormatted(memType2, true));

            waitBeforeStartSensor();

            int token1 = mChannel.configure(s, rateLevel1);
            int token2 = mChannelSecondary.configure(s, rateLevel2);
            assertTrue("configure direct mChannel failed", token1 > 0);
            assertTrue("configure direct mChannelSecondary failed", token2 > 0);

            waitSensorCollection();

            //stop sensor and analyze content
            mChannel.configure(s, SensorDirectChannel.RATE_STOP);
            mChannelSecondary.configure(s, SensorDirectChannel.RATE_STOP);

            // check rate
            readSharedMemory(memType1, false /*secondary*/);
            checkEventRate(TEST_RUN_TIME_PERIOD_MILLISEC, parseEntireBuffer(token1, mEventPool,
                    mByteBuffer, SHARED_MEMORY_SIZE), type, rateLevel1);

            readSharedMemory(memType2, true /*secondary*/);
            checkEventRate(TEST_RUN_TIME_PERIOD_MILLISEC, parseEntireBuffer(token2, mEventPool,
                    mByteBuffer, SHARED_MEMORY_SIZE), type, rateLevel2);
        } finally {
            if (mChannel != null) {
                mChannel.close();
                mChannel = null;
            }
            if (mChannelSecondary != null) {
                mChannelSecondary.close();
                mChannelSecondary = null;
            }
        }
    }

    private void runMultiModeRateIndependencyTest(
            int type , int rateLevel, int memType, int samplingPeriodUs)
                throws AssertionError {
        final Sensor s = mSensorManager.getDefaultSensor(type);
        if (s == null
                || s.getHighestDirectReportRateLevel() < rateLevel
                || !s.isDirectChannelTypeSupported(memType)) {
            return;
        }

        if (samplingPeriodUs == 0) {
            samplingPeriodUs = s.getMinDelay();
        }

        if (samplingPeriodUs < s.getMinDelay()) {
            return;
        }

        if (samplingPeriodUs > s.getMaxDelay()) {
            samplingPeriodUs = s.getMaxDelay();
        }

        resetEvent();

        mChannel = prepareDirectChannel(memType, false /* secondary */);
        assertTrue("createDirectChannel failed", mChannel != null);
        SensorEventCollection listener = new SensorEventCollection(s);

        try {
            waitBeforeStartSensor();
            int token = mChannel.configure(s, rateLevel);
            boolean registerRet = mSensorManager.registerListener(listener, s, samplingPeriodUs);
            assertTrue("Register listener failed", registerRet);

            waitSensorCollection();

            mChannel.configure(s, SensorDirectChannel.RATE_STOP);
            mSensorManager.unregisterListener(listener);

            // check direct report rate
            readSharedMemory(memType, false /*secondary*/);
            List<DirectReportSensorEvent> events = parseEntireBuffer(token, mEventPool, mByteBuffer,
                    SHARED_MEMORY_SIZE);
            checkEventRate(TEST_RUN_TIME_PERIOD_MILLISEC, events, type, rateLevel);

            // check callback interface rate
            checkEventRateUs(TEST_RUN_TIME_PERIOD_MILLISEC, listener.getEvents(), type,
                             samplingPeriodUs);
        } finally {
            mChannel.close();
            mChannel = null;
            mSensorManager.unregisterListener(listener);
        }
    }

    private void runTimestampTest(int type, int rateLevel, int memType) {
        Sensor s = mSensorManager.getDefaultSensor(type);
        if (s == null
                || s.getHighestDirectReportRateLevel() < rateLevel
                || !s.isDirectChannelTypeSupported(memType)) {
            return;
        }
        resetEvent();

        mChannel = prepareDirectChannel(memType, false /* secondary */);
        assertTrue("createDirectChannel failed", mChannel != null);

        SensorEventCollection listener = new SensorEventCollection(s);

        try {
            float nominalFreq = getNominalFreq(rateLevel);
            int samplingPeriodUs = Math.max((int) (1e6f / nominalFreq), s.getMinDelay());

            assertTrue("Shared memory is not formatted",
                       isSharedMemoryFormatted(memType));

            int token = mChannel.configure(s, rateLevel);
            assertTrue("configure direct mChannel failed", token > 0);

            boolean registerRet = mSensorManager.registerListener(listener, s, samplingPeriodUs);
            assertTrue("Register listener failed", registerRet);

            List<DirectReportSensorEvent> events = collectSensorEventsRealtime(
                    memType, false /*secondary*/, TEST_RUN_TIME_PERIOD_MILLISEC);
            assertTrue("Realtime event collection failed", events != null);
            assertTrue("Realtime event collection got no data", events.size() > 0);

            //stop sensor and analyze content
            mChannel.configure(s, SensorDirectChannel.RATE_STOP);
            mSensorManager.unregisterListener(listener);

            // check rate
            checkTimestampRelative(events, listener.getEvents());
            checkTimestampAbsolute(events);
        } finally {
            mChannel.close();
            mChannel = null;
        }
    }

    private void runAtomicCounterTest(int sensorType, int memType) throws AssertionError {
        Sensor s = mSensorManager.getDefaultSensor(sensorType);
        if (s == null
                || s.getHighestDirectReportRateLevel() == SensorDirectChannel.RATE_STOP
                || !s.isDirectChannelTypeSupported(memType)) {
            return;
        }
        resetEvent();

        mChannel = prepareDirectChannel(memType, false /* secondary */);
        assertTrue("createDirectChannel failed", mChannel != null);

        try {
            assertTrue("Shared memory is not formatted", isSharedMemoryFormatted(memType));
            waitBeforeStartSensor();

            //int token = mChannel.configure(s, SensorDirectChannel.RATE_FAST);
            int token = mChannel.configure(s, s.getHighestDirectReportRateLevel());
            assertTrue("configure direct mChannel failed", token > 0);

            checkAtomicCounterUpdate(memType, 30 * 1000); // half min

            //stop sensor and analyze content
            mChannel.configure(s, SensorDirectChannel.RATE_STOP);
        } finally {
            mChannel.close();
            mChannel = null;
        }
    }

    private void runReconfigureTest(int type, int memType) {
        Sensor s = mSensorManager.getDefaultSensor(type);
        if (s == null
                || s.getHighestDirectReportRateLevel() == SensorDirectChannel.RATE_STOP
                || !s.isDirectChannelTypeSupported(memType)) {
            return;
        }
        resetEvent();

        mChannel = prepareDirectChannel(memType, false /* secondary */);
        assertTrue("createDirectChannel failed", mChannel != null);

        try {
            assertTrue("Shared memory is not formatted", isSharedMemoryFormatted(memType));
            waitBeforeStartSensor();

            int offset = 0;
            long counter = 1;
            List<Integer> rateLevels = new ArrayList<>();
            List<DirectReportSensorEvent> events;

            rateLevels.add(s.getHighestDirectReportRateLevel());
            rateLevels.add(s.getHighestDirectReportRateLevel());
            if (s.getHighestDirectReportRateLevel() != SensorDirectChannel.RATE_NORMAL) {
                rateLevels.add(SensorDirectChannel.RATE_NORMAL);
            }

            for (int rateLevel : rateLevels) {
                int token = mChannel.configure(s, rateLevel);
                assertTrue("configure direct mChannel failed", token > 0);

                events = collectSensorEventsRealtime(memType, false /*secondary*/,
                                                     TEST_RUN_TIME_PERIOD_MILLISEC,
                                                     offset, counter);
                // stop sensor
                mChannel.configure(s, SensorDirectChannel.RATE_STOP);
                checkEventRate(TEST_RUN_TIME_PERIOD_MILLISEC, events, type, rateLevel);

                // collect all events after stop
                events = collectSensorEventsRealtime(memType, false /*secondary*/,
                                                     REST_PERIOD_BEFORE_TEST_MILLISEC,
                                                     offset, counter);
                if (events.size() > 0) {
                    offset += (events.size() * SENSORS_EVENT_SIZE ) % SHARED_MEMORY_SIZE;
                    counter = events.get(events.size() - 1).serial;
                }
            }

            // finally stop the report
            mChannel.configure(s, SensorDirectChannel.RATE_STOP);
        } finally {
            mChannel.close();
            mChannel = null;
        }
    }

    public static void waitBeforeStartSensor() {
        // wait for sensor system to come to a rest after previous test to avoid flakiness.
        try {
            SensorCtsHelper.sleep(REST_PERIOD_BEFORE_TEST_MILLISEC, TimeUnit.MILLISECONDS);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }

    private void waitSensorCollection() {
        // wait for sensor collection to finish
        try {
            SensorCtsHelper.sleep(TEST_RUN_TIME_PERIOD_MILLISEC, TimeUnit.MILLISECONDS);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }

    private List<DirectReportSensorEvent> collectSensorEventsRealtime(
            int memType, boolean secondary, int timeoutMs) {
        return collectSensorEventsRealtime(memType, secondary, timeoutMs,
                                          0 /*initialOffset*/, 1l /*initialCounter*/);
    }

    private List<DirectReportSensorEvent> collectSensorEventsRealtime(
            int memType, boolean secondary, int timeoutMs, int initialOffset, long initialCounter) {
        List<DirectReportSensorEvent> events = new ArrayList<>();
        long endTime = SystemClock.elapsedRealtime() + timeoutMs;

        long atomicCounter = initialCounter;
        int offset = initialOffset;

        long timeA = SystemClock.elapsedRealtimeNanos();
        boolean synced = false;
        int filtered = 0;

        while (SystemClock.elapsedRealtime() < endTime) {
            if (!readSharedMemory(
                    memType, secondary, offset + ATOMIC_COUNTER_OFFSET, ATOMIC_COUNTER_SIZE)) {
                return null;
            }

            long timeB = SystemClock.elapsedRealtimeNanos();
            if (timeB - timeA > 1_000_000L ) { // > 1ms
                synced = false;
            }
            timeA = timeB;

            if (readAtomicCounter(offset) == atomicCounter) {
                // read entire event again and parse
                if (!readSharedMemory(memType, secondary, offset, SENSORS_EVENT_SIZE)) {
                    return null;
                }
                DirectReportSensorEvent e = mEventPool.get();
                assertNotNull("cannot get event from reserve", e);
                parseSensorEvent(offset, e, mByteBuffer);

                atomicCounter += 1;
                if (synced) {
                    events.add(e);
                } else {
                    ++filtered;
                }

                offset += SENSORS_EVENT_SIZE;
                if (offset + SENSORS_EVENT_SIZE > SHARED_MEMORY_SIZE) {
                    offset = 0;
                }
            } else {
                synced = true;
            }
        }
        Log.d(TAG, "filtered " + filtered + " events, remain " + events.size() + " events");
        return events;
    }

    private void checkAtomicCounterUpdate(int memType, int timeoutMs) {
        List<DirectReportSensorEvent> events = new ArrayList<>();
        long endTime = SystemClock.elapsedRealtime() + timeoutMs;

        boolean lastValid = false;
        long atomicCounter = 1;
        int lastOffset = 0;
        int offset = 0;

        byte[] lastArray = new byte[SENSORS_EVENT_SIZE];
        DirectReportSensorEvent e = getEvent();

        while (SystemClock.elapsedRealtime() < endTime) {
            if (!readSharedMemory(memType, false/*secondary*/, lastOffset, SENSORS_EVENT_SIZE)
                    || !readSharedMemory(memType, false/*secondary*/,
                                         offset + ATOMIC_COUNTER_OFFSET, ATOMIC_COUNTER_SIZE)) {
                throw new IllegalStateException("cannot read shared memory, type " + memType);
            }

            if (lastValid) {
                boolean failed = false;
                int i;
                for (i = 0; i < SENSORS_EVENT_SIZE; ++i) {
                    if (lastArray[i] != mBuffer[lastOffset + i]) {
                        failed = true;
                        break;
                    }
                }

                if (failed) {
                    byte[] currentArray = new byte[SENSORS_EVENT_SIZE];
                    System.arraycopy(mBuffer, lastOffset, currentArray, 0, SENSORS_EVENT_SIZE);

                    // wait for 100ms and read again to see if the change settle
                    try {
                        SensorCtsHelper.sleep(100, TimeUnit.MILLISECONDS);
                    } catch (InterruptedException ex) {
                        Thread.currentThread().interrupt();
                    }

                    byte[] delayedRead = new byte[SENSORS_EVENT_SIZE];
                    if (!readSharedMemory(
                                memType, false/*secondary*/, lastOffset, SENSORS_EVENT_SIZE)) {
                        throw new IllegalStateException(
                                "cannot read shared memory, type " + memType);
                    }
                    System.arraycopy(mBuffer, lastOffset, delayedRead, 0, SENSORS_EVENT_SIZE);

                    fail(String.format(
                            "At offset %d(0x%x), byte %d(0x%x) changed after atomicCounter"
                                + "(expecting %d, 0x%x) update, old = [%s], new = [%s], "
                                + "delayed = [%s]",
                            lastOffset, lastOffset, i, i, atomicCounter, atomicCounter,
                            SensorCtsHelper.bytesToHex(lastArray, -1, -1),
                            SensorCtsHelper.bytesToHex(currentArray, -1, -1),
                            SensorCtsHelper.bytesToHex(delayedRead, -1, -1)));
                }
            }

            if (readAtomicCounter(offset) == atomicCounter) {
                // read entire event again and parse
                if (!readSharedMemory(memType, false/*secondary*/, offset, SENSORS_EVENT_SIZE)) {
                    throw new IllegalStateException("cannot read shared memory, type " + memType);
                }
                parseSensorEvent(offset, e, mByteBuffer);

                atomicCounter += 1;

                lastOffset = offset;
                System.arraycopy(mBuffer, lastOffset, lastArray, 0, SENSORS_EVENT_SIZE);
                lastValid = true;

                offset += SENSORS_EVENT_SIZE;
                if (offset + SENSORS_EVENT_SIZE > SHARED_MEMORY_SIZE) {
                    offset = 0;
                }
            }
        }
        Log.d(TAG, "at finish checkAtomicCounterUpdate has atomic counter = " + atomicCounter);
        // atomicCounter will not wrap back in reasonable amount of time
        assertTrue("Realtime event collection got no data", atomicCounter != 1);
    }

    private MemoryFile allocateMemoryFile() {
        MemoryFile memFile = null;
        try {
            memFile = new MemoryFile("Sensor Channel", SHARED_MEMORY_SIZE);
        } catch (IOException e) {
            Log.e(TAG, "IOException when allocating MemoryFile");
        }
        return memFile;
    }

    private HardwareBuffer allocateHardwareBuffer() {
        HardwareBuffer hardwareBuffer;

        hardwareBuffer = HardwareBuffer.create(
                SHARED_MEMORY_SIZE, 1 /* height */, HardwareBuffer.BLOB, 1 /* layer */,
                HardwareBuffer.USAGE_CPU_READ_OFTEN | HardwareBuffer.USAGE_GPU_DATA_BUFFER
                    | HardwareBuffer.USAGE_SENSOR_DIRECT_DATA);
        return hardwareBuffer;
    }

    private SensorDirectChannel prepareDirectChannel(int memType, boolean secondary) {
        SensorDirectChannel channel = null;

        try {
            switch(memType) {
                case SensorDirectChannel.TYPE_MEMORY_FILE: {
                    MemoryFile memoryFile = secondary ? mMemoryFileSecondary : mMemoryFile;
                    assertTrue("MemoryFile" + (secondary ? "(secondary)" : "") + " is null",
                               memoryFile != null);
                    channel = mSensorManager.createDirectChannel(memoryFile);
                    break;
                }
                case SensorDirectChannel.TYPE_HARDWARE_BUFFER: {
                    HardwareBuffer hardwareBuffer
                            = secondary ? mHardwareBufferSecondary : mHardwareBuffer;
                    assertTrue("HardwareBuffer" + (secondary ? "(secondary)" : "") + " is null",
                               hardwareBuffer != null);
                    channel = mSensorManager.createDirectChannel(hardwareBuffer);
                    break;
                }
                default:
                    Log.e(TAG, "Specified illegal memory type " + memType);
            }
        } catch (IllegalStateException | UncheckedIOException e) {
            Log.e(TAG, "Cannot initialize channel for memory type " + memType
                    + ", details:" + e);
            channel = null;
        }
        return channel;
    }

    private boolean readSharedMemory(int memType, boolean secondary, int offset, int length) {
        switch(memType) {
            case SensorDirectChannel.TYPE_MEMORY_FILE:
                try {
                    MemoryFile f = secondary ? mMemoryFileSecondary : mMemoryFile;
                    if (f.readBytes(mBuffer, offset, offset, length) != length) {
                        Log.e(TAG, "cannot read entire MemoryFile");
                        return false;
                    }
                } catch (IOException e) {
                    Log.e(TAG, "accessing MemoryFile causes IOException");
                    return false;
                }
                return true;
            case SensorDirectChannel.TYPE_HARDWARE_BUFFER:
                return nativeReadHardwareBuffer(
                        secondary ? mHardwareBufferSecondary : mHardwareBuffer,
                        mBuffer, offset, offset, length);
            default:
                return false;
        }
    }

    private boolean readSharedMemory(int memType, boolean secondary) {
        return readSharedMemory(memType, secondary, 0, SHARED_MEMORY_SIZE);
    }

    private boolean readSharedMemory(int memType) {
        return readSharedMemory(memType, false /*secondary*/);
    }

    private boolean isMemoryTypeNeeded(int memType) {
        List<Sensor> sensorList = mSensorManager.getSensorList(Sensor.TYPE_ALL);
        for (Sensor s : sensorList) {
            if (s.isDirectChannelTypeSupported(memType)) {
                return true;
            }
        }
        return false;
    }

    private boolean isSharedMemoryFormatted(int memType) {
        return isSharedMemoryFormatted(memType, false /* secondary */);
    }

    private boolean isSharedMemoryFormatted(int memType, boolean secondary) {
        readSharedMemory(memType, secondary);

        for (byte b : mBuffer) {
            if (b != 0) {
                return false;
            }
        }
        return true;
    }

    private void checkSharedMemoryContent(Sensor s, int memType, int rateLevel, int token) {
        assertTrue("read mem type " + memType + " content failed", readSharedMemory(memType));

        int offset = 0;
        int nextSerial = 1;
        DirectReportSensorEvent e = getEvent();
        while (offset <= SHARED_MEMORY_SIZE - SENSORS_EVENT_SIZE) {
            parseSensorEvent(offset, e, mByteBuffer);

            if (e.serial == 0) {
                // reaches end of events
                break;
            }

            assertTrue("incorrect size " + e.size + "  at offset " + offset,
                    e.size == SENSORS_EVENT_SIZE);
            assertTrue("incorrect token " + e.token + " at offset " + offset,
                    e.token == token);
            assertTrue("incorrect serial " + e.serial + " at offset " + offset,
                    e.serial == nextSerial);
            assertTrue("incorrect type " + e.type + " offset " + offset,
                    e.type == s.getType());

            switch(s.getType()) {
                case Sensor.TYPE_ACCELEROMETER:
                    double accNorm = Math.sqrt(e.x * e.x + e.y * e.y + e.z * e.z);
                    assertTrue("incorrect gravity norm " + accNorm + " at offset " + offset,
                            accNorm < GRAVITY_MAX && accNorm > GRAVITY_MIN);
                    break;
                case Sensor.TYPE_GYROSCOPE:
                    double gyroNorm = Math.sqrt(e.x * e.x + e.y * e.y + e.z * e.z);
                    assertTrue("gyro norm too large (" + gyroNorm + ") at offset " + offset,
                            gyroNorm < GYRO_NORM_MAX);
                    break;
            }

            ++nextSerial;
            offset += SENSORS_EVENT_SIZE;
        }

        int nEvents = nextSerial - 1;
        float nominalFreq = 0;

        switch (rateLevel) {
            case SensorDirectChannel.RATE_NORMAL:
                nominalFreq = RATE_NORMAL_NOMINAL;
                break;
            case SensorDirectChannel.RATE_FAST:
                nominalFreq = RATE_FAST_NOMINAL;
                break;
            case SensorDirectChannel.RATE_VERY_FAST:
                nominalFreq = RATE_VERY_FAST_NOMINAL;
                break;
        }

        if (nominalFreq != 0) {
            int minEvents;
            int maxEvents;
            minEvents = (int) Math.floor(
                    nominalFreq
                    * FREQ_LOWER_BOUND
                    * (TEST_RUN_TIME_PERIOD_MILLISEC - ALLOWED_SENSOR_INIT_TIME_MILLISEC)
                    * (1 - MERCY_FACTOR)
                    / 1000);
            maxEvents = (int) Math.ceil(
                    nominalFreq
                    * FREQ_UPPER_BOUND
                    * TEST_RUN_TIME_PERIOD_MILLISEC
                    * (1 + MERCY_FACTOR)
                    / 1000);

            assertTrue("nEvent is " + nEvents + " not between " + minEvents + " and " + maxEvents,
                    nEvents >= minEvents && nEvents <=maxEvents);
        }
    }

    private void checkEventRate(int testTimeMs, List<DirectReportSensorEvent> events,
                                int type, int rateLevel) {
        assertTrue("insufficient events of type " + type, events.size() > 1);
        for (DirectReportSensorEvent e : events) {
            assertTrue("incorrect type " + e.type + " expecting " + type, e.type == type);
        }

        // check number of events
        int[] minMax = calculateExpectedNEvents(testTimeMs, rateLevel);
        assertTrue(
                "Number of event of type " + type + " is " + events.size()
                    + ", which is not in range [" + minMax[0] + ", " + minMax[1] + "].",
                minMax[0] <= events.size() && events.size() <= minMax[1]);

        // intervals
        List<Long> intervals = new ArrayList<>(events.size() - 1);
        long minInterval = Long.MAX_VALUE;
        long maxInterval = Long.MIN_VALUE;
        long averageInterval = 0;
        for (int i = 1; i < events.size(); ++i) {
            long d = events.get(i).ts - events.get(i-1).ts;
            averageInterval += d;
            minInterval = Math.min(d, minInterval);
            maxInterval = Math.max(d, maxInterval);
            intervals.add(d);
        }
        averageInterval /= (events.size() - 1);

        // average rate
        float averageFreq = 1e9f / averageInterval;
        float nominalFreq = getNominalFreq(rateLevel);
        Log.d(TAG, String.format(
                "checkEventRate type %d: averageFreq %f, nominalFreq %f, lbound %f, ubound %f",
                type, averageFreq, nominalFreq,
                nominalFreq * FREQ_LOWER_BOUND,
                nominalFreq * FREQ_UPPER_BOUND));
        assertTrue("Average frequency of type " + type + " rateLevel " + rateLevel
                        + " is " + averageFreq,
                   nominalFreq * FREQ_LOWER_BOUND * (1 - MERCY_FACTOR) <= averageFreq &&
                       averageFreq <= nominalFreq * FREQ_UPPER_BOUND * (1 + MERCY_FACTOR));

        // jitter variance
        List<Long> percentileValues =
                SensorCtsHelper.getPercentileValue(intervals, 0.025f, (1 - 0.025f));
        assertTrue("Timestamp jitter of type " + type + " rateLevel " + rateLevel + " is "
                        + (percentileValues.get(1) - percentileValues.get(0) / 1000) + " us, "
                        + "while average interval is " + (averageInterval / 1000) + "us, over-range",
                   (percentileValues.get(1) - percentileValues.get(0)) / averageInterval < 0.05);
        Log.d(TAG, String.format(
                "checkEventRate type %d, timestamp interval range %f - %f ms, " +
                    "span %f ms, %.2f%% of averageInterval",
                    type, percentileValues.get(0)/1e6f, percentileValues.get(1)/1e6f,
                    (percentileValues.get(1) - percentileValues.get(0))/1e6f,
                    (percentileValues.get(1) - percentileValues.get(0)) / averageInterval * 100.f));

    }

    private void checkEventRateUs(int testTimeMs, List<DirectReportSensorEvent> events,
                                  int type, int samplingPeriodUs) {
        // samplingPeriodUs must be a valid one advertised by sensor
        assertTrue("insufficient events of type " + type, events.size() > 1);
        for (DirectReportSensorEvent e : events) {
            assertTrue("incorrect type " + e.type + " expecting " + type, e.type == type);
        }

        // check number of events
        int[] minMax = calculateExpectedNEventsUs(testTimeMs, samplingPeriodUs);
        assertTrue(
                "Number of event of type " + type + " is " + events.size()
                    + ", which is not in range [" + minMax[0] + ", " + minMax[1] + "].",
                minMax[0] <= events.size() && events.size() <= minMax[1]);

        // intervals
        List<Long> intervals = new ArrayList<>(events.size() - 1);
        long minInterval = Long.MAX_VALUE;
        long maxInterval = Long.MIN_VALUE;
        long averageInterval = 0;
        for (int i = 1; i < events.size(); ++i) {
            long d = events.get(i).ts - events.get(i-1).ts;
            averageInterval += d;
            minInterval = Math.min(d, minInterval);
            maxInterval = Math.max(d, maxInterval);
            intervals.add(d);
        }
        averageInterval /= (events.size() - 1);

        // average rate
        float averageFreq = 1e9f / averageInterval;
        float nominalFreq = 1e6f / samplingPeriodUs;
        Log.d(TAG, String.format(
                "checkEventRateUs type %d: averageFreq %f, nominalFreq %f, lbound %f, ubound %f",
                type, averageFreq, nominalFreq,
                nominalFreq * FREQ_LOWER_BOUND_POLL,
                nominalFreq * FREQ_UPPER_BOUND_POLL));
        assertTrue("Average frequency of type " + type
                        + " is " + averageFreq,
                   nominalFreq * FREQ_LOWER_BOUND_POLL * (1 - MERCY_FACTOR) <= averageFreq &&
                       averageFreq <= nominalFreq * FREQ_UPPER_BOUND_POLL * (1 + MERCY_FACTOR));

        // jitter variance
        List<Long> percentileValues =
                SensorCtsHelper.getPercentileValue(intervals, 0.025f, (1 - 0.025f));
        assertTrue("Timestamp jitter of type " + type + " is "
                        + (percentileValues.get(1) - percentileValues.get(0) / 1000) + " us, "
                        + "while average interval is " + (averageInterval / 1000) + "us, over-range",
                   (percentileValues.get(1) - percentileValues.get(0)) / averageInterval < 0.05);
        Log.d(TAG, String.format(
                "checkEventRateUs type %d, timestamp interval range %f - %f ms, " +
                    "span %f ms, %.2f%% of averageInterval",
                    type, percentileValues.get(0)/1e6f, percentileValues.get(1)/1e6f,
                    (percentileValues.get(1) - percentileValues.get(0)) / 1e6f,
                    (percentileValues.get(1) - percentileValues.get(0)) / averageInterval * 100.f));
    }

    private void allocateSharedMemory() {
        if (mNeedMemoryFile) {
            mMemoryFile = allocateMemoryFile();
            mMemoryFileSecondary = allocateMemoryFile();
        }

        if (mNeedHardwareBuffer) {
            mHardwareBuffer = allocateHardwareBuffer();
            mHardwareBufferSecondary = allocateHardwareBuffer();
        }
    }

    private void freeSharedMemory() {
        if (mMemoryFile != null) {
            mMemoryFile.close();
            mMemoryFile = null;
        }

        if (mMemoryFileSecondary != null) {
            mMemoryFileSecondary.close();
            mMemoryFileSecondary = null;
        }

        if (mHardwareBuffer != null) {
            mHardwareBuffer.close();
            mHardwareBuffer = null;
        }

        if (mHardwareBufferSecondary != null) {
            mHardwareBufferSecondary.close();
            mHardwareBufferSecondary = null;
        }
    }

    private float getNominalFreq(int rateLevel) {
        float nominalFreq = 0;
        switch (rateLevel) {
            case SensorDirectChannel.RATE_NORMAL:
                nominalFreq = RATE_NORMAL_NOMINAL;
                break;
            case SensorDirectChannel.RATE_FAST:
                nominalFreq = RATE_FAST_NOMINAL;
                break;
            case SensorDirectChannel.RATE_VERY_FAST:
                nominalFreq = RATE_VERY_FAST_NOMINAL;
                break;
        }
        return nominalFreq;
    }

    private int[] calculateExpectedNEvents(int timeMs, int rateLevel) {
        int[] minMax = new int[] { -1, Integer.MAX_VALUE };
        float nominalFreq = getNominalFreq(rateLevel);
        if (nominalFreq != 0) {
            // min
            if (timeMs > ALLOWED_SENSOR_INIT_TIME_MILLISEC) {
                minMax[0] = (int) Math.floor(
                        nominalFreq
                        * FREQ_LOWER_BOUND
                        * (timeMs - ALLOWED_SENSOR_INIT_TIME_MILLISEC)
                        * (1 - MERCY_FACTOR)
                        / 1000);
            }
            // max
            minMax[1] = (int) Math.ceil(
                    nominalFreq
                    * FREQ_UPPER_BOUND
                    * timeMs
                    * (1 + MERCY_FACTOR)
                    / 1000);
        }
        return minMax;
    }

    private void checkTimestampAbsolute(List<DirectReportSensorEvent> events) {
        final int MAX_DETAIL_ITEM = 10;

        StringBuffer buf = new StringBuffer();
        int oneMsEarlyCount = 0;
        int fiveMsLateCount = 0;
        int tenMsLateCount = 0;
        int errorCount = 0;

        for (int i = 0; i < events.size(); ++i) {
            DirectReportSensorEvent e = events.get(i);
            long d = e.arrivalTs - e.ts;
            boolean oneMsEarly = d < -1000_000;
            boolean fiveMsLate = d > 5000_000;
            boolean tenMsLate = d > 10_000_000;

            if (oneMsEarly || fiveMsLate || tenMsLate) {
                oneMsEarlyCount += oneMsEarly ? 1 : 0;
                fiveMsLateCount += fiveMsLate ? 1 : 0;
                tenMsLateCount += tenMsLate ? 1 : 0;

                if (errorCount++ < MAX_DETAIL_ITEM) {
                    buf.append("[").append(i).append("] diff = ").append(d / 1e6f).append(" ms; ");
                }
            }
        }

        Log.d(TAG, String.format("Irregular timestamp, %d, %d, %d out of %d",
                    oneMsEarlyCount, fiveMsLateCount, tenMsLateCount, events.size()));

        if (CHECK_ABSOLUTE_LATENCY) {
            assertTrue(String.format(
                    "Timestamp error, out of %d events, %d is >1ms early, %d is >5ms late, "
                        + "%d is >10ms late, details: %s%s",
                        events.size(), oneMsEarlyCount, fiveMsLateCount, tenMsLateCount,
                        buf.toString(), errorCount > MAX_DETAIL_ITEM ? "..." : ""),
                    oneMsEarlyCount == 0
                        && fiveMsLateCount <= events.size() / 20
                        && tenMsLateCount <= events.size() / 100);
        }
    }

    private void checkTimestampRelative(List<DirectReportSensorEvent> directEvents,
                                        List<DirectReportSensorEvent> pollEvents) {
        if (directEvents.size() < 10 || pollEvents.size() < 10) {
            // cannot check with so few data points
            return;
        }

        long directAverageLatency = 0;
        for (DirectReportSensorEvent e : directEvents) {
            directAverageLatency += e.arrivalTs - e.ts;
        }
        directAverageLatency /= directEvents.size();

        long pollAverageLatency = 0;
        for (DirectReportSensorEvent e : pollEvents) {
            pollAverageLatency += e.arrivalTs - e.ts;
        }
        pollAverageLatency /= pollEvents.size();

        Log.d(TAG, String.format("Direct, poll latency = %f, %f ms",
                directAverageLatency / 1e6f, pollAverageLatency / 1e6f));
        assertTrue(
                String.format("Direct, poll latency = %f, %f ms, expect direct < poll",
                    directAverageLatency / 1e6f,
                    pollAverageLatency / 1e6f),
                directAverageLatency < pollAverageLatency + 1000_000);
    }

    private int[] calculateExpectedNEventsUs(int timeMs, int samplingPeriodUs) {
        int[] minMax = new int[2];
        minMax[0] = Math.max((int) Math.floor(
                (timeMs - ALLOWED_SENSOR_INIT_TIME_MILLISEC) * 1000/ samplingPeriodUs), 0);
        minMax[1] = (int) Math.ceil(timeMs * 1000 * 2 / samplingPeriodUs);
        return minMax;
    }

    public static class DirectReportSensorEvent {
        public int size;
        public int token;
        public int type;
        public long serial;
        public long ts;
        public float x;
        public float y;
        public float z;
        public long arrivalTs;
    };

    // EventPool to avoid allocating too many event objects and hitting GC during test
    public static class EventPool {
        public EventPool(int n) {
            mEvents = Arrays.asList(new DirectReportSensorEvent[n]);
            for (int i = 0; i < n; ++i) {
                mEvents.set(i, new DirectReportSensorEvent());
            }
            reset();
        }

        public synchronized void reset() {
            Log.d(TAG, "Reset EventPool (" + mIndex + " events used)");
            mIndex = 0;
        }

        public synchronized DirectReportSensorEvent get() {
            if (mIndex < mEvents.size()) {
                return mEvents.get(mIndex++);
            } else {
                throw new IllegalStateException("EventPool depleted");
            }
        }

        private List<DirectReportSensorEvent> mEvents;
        private int mIndex;
    };

    private DirectReportSensorEvent getEvent() {
        return mEventPool.get();
    }

    private DirectReportSensorEvent getEvent(DirectReportSensorEvent e) {
        DirectReportSensorEvent event = mEventPool.get();
        event.size = e.size;
        event.token = e.token;
        event.type = e.type;
        event.serial = e.serial;
        event.ts = e.ts;
        event.x = e.x;
        event.y = e.y;
        event.z = e.z;
        event.arrivalTs = e.arrivalTs;
        return event;
    }

    private void resetEvent() {
        mEventPool.reset();
    }

    private class SensorEventCollection implements SensorEventListener {
        List<DirectReportSensorEvent> mEvents = new ArrayList<>();
        Sensor mSensor;

        public SensorEventCollection(Sensor s) {
            mSensor = s;
        }

        List<DirectReportSensorEvent> getEvents() {
            return mEvents;
        }

        @Override
        public void onSensorChanged(SensorEvent event) {
            if (mSensor == null || event.sensor == mSensor) {
                DirectReportSensorEvent e = mEventPool.get();
                e.size = SENSORS_EVENT_SIZE;
                e.token = event.sensor.getType();
                e.type = e.token;
                e.serial = -1;
                e.ts = event.timestamp;
                e.arrivalTs = SystemClock.elapsedRealtimeNanos();

                e.x = event.values[0];
                if (event.values.length > 1) {
                    e.y = event.values[1];
                }
                if (event.values.length > 2) {
                    e.z = event.values[2];
                }
                mEvents.add(e);
            }
        }

        @Override
        public void onAccuracyChanged(Sensor s, int accuracy) {
            // do nothing
        }
    };

    public static List<DirectReportSensorEvent> parseEntireBuffer(int token, EventPool eventPool,
                ByteBuffer byteBuffer, int sharedMemorySize) {
        int offset = 0;
        int nextSerial = 1;
        List<DirectReportSensorEvent> events = new ArrayList<>();

        while (offset <= sharedMemorySize - SENSORS_EVENT_SIZE) {
            SensorDirectReportTest.DirectReportSensorEvent e = eventPool.get();
            parseSensorEvent(offset, e, byteBuffer);

            if (e.serial == 0) {
                // reaches end of events
                break;
            }

            assertTrue("incorrect size " + e.size + "  at offset " + offset,
                    e.size == SENSORS_EVENT_SIZE);
            assertTrue("incorrect serial " + e.serial + " at offset " + offset,
                    e.serial == nextSerial);

            if (e.token == token) {
                events.add(e);
            }

            ++nextSerial;
            offset += SENSORS_EVENT_SIZE;
        }

        return events;
    }

    // parse sensors_event_t from byteBuffer and fill information into DirectReportSensorEvent
    public static void parseSensorEvent(int offset, DirectReportSensorEvent ev,
            ByteBuffer byteBuffer) {
        byteBuffer.position(offset);

        ev.size = byteBuffer.getInt();
        ev.token = byteBuffer.getInt();
        ev.type = byteBuffer.getInt();
        ev.serial = ((long) byteBuffer.getInt()) & 0xFFFFFFFFl; // signed=>unsigned
        ev.ts = byteBuffer.getLong();
        ev.arrivalTs = SystemClock.elapsedRealtimeNanos();
        ev.x = byteBuffer.getFloat();
        ev.y = byteBuffer.getFloat();
        ev.z = byteBuffer.getFloat();
    }

    // parse sensors_event_t and fill information into DirectReportSensorEvent
    private static void parseSensorEvent(byte [] buf, int offset, DirectReportSensorEvent ev) {
        ByteBuffer b = ByteBuffer.wrap(buf, offset, SENSORS_EVENT_SIZE);
        b.order(NATIVE_BYTE_ORDER);

        ev.size = b.getInt();
        ev.token = b.getInt();
        ev.type = b.getInt();
        ev.serial = ((long) b.getInt()) & 0xFFFFFFFFl; // signed=>unsigned
        ev.ts = b.getLong();
        ev.arrivalTs = SystemClock.elapsedRealtimeNanos();
        ev.x = b.getFloat();
        ev.y = b.getFloat();
        ev.z = b.getFloat();
    }

    private long readAtomicCounter(int offset) {
        mByteBuffer.position(offset + ATOMIC_COUNTER_OFFSET);
        return ((long) mByteBuffer.getInt()) & 0xFFFFFFFFl; // signed => unsigned
    }

    private static long readAtomicCounter(byte [] buf, int offset) {
        ByteBuffer b = ByteBuffer.wrap(buf, offset + ATOMIC_COUNTER_OFFSET, ATOMIC_COUNTER_SIZE);
        b.order(ByteOrder.nativeOrder());

        return ((long) b.getInt()) & 0xFFFFFFFFl; // signed => unsigned
    }
}