tests/sensor/jni/SensorTest.h

/*
 * 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.
 */

#ifndef SENSOR_TEST_H
#define SENSOR_TEST_H

#include "nativeTestHelper.h"
#include <android/sensor.h>
#include <android/hardware_buffer.h>
#include <android/sharedmem.h>

#include <unordered_set>
#include <vector>
#include <sys/mman.h>
#include <unistd.h>

namespace android {
namespace SensorTest {

class TestSensor;
class TestSensorManager;
class TestSharedMemory;

class SensorTest {
public:
    virtual bool SetUp();
    virtual void TearDown();
    virtual ~SensorTest() = default;

    // tests
    void testInitialized(JNIEnv *env);
    void testInvalidParameter(JNIEnv *env);
    void testDirectReport(JNIEnv *env, int32_t sensorType, int32_t channelType, int32_t rateLevel);

private:
    std::unique_ptr<TestSensorManager> mManager;
};

// NDK ASensorManager wrapper
class TestSensorManager {
public:
    static TestSensorManager * getInstanceForPackage(const char *package);
    virtual ~TestSensorManager();

    TestSensor getDefaultSensor(int type);
    int createDirectChannel(const TestSharedMemory &mem);
    void destroyDirectChannel(int channel);
    int configureDirectReport(TestSensor sensor, int channel, int rateLevel);
    bool isValid() const { return mManager != nullptr; }
private:
    TestSensorManager(const char *package);
    int createSharedMemoryDirectChannel(int fd, size_t size);
    int createHardwareBufferDirectChannel(AHardwareBuffer const *buffer, size_t size);

    ASensorManager *mManager; // singleton, does not need delete

    // book keeping
    std::unordered_set<int> mSensorDirectChannel;
};

// NDK ASensor warpper
class TestSensor {
public:
    TestSensor(ASensor const *s) : mSensor(s) { }

    int getType() const {
        if (!isValid()) {
            return -1;
        }
        return ASensor_getType(mSensor);
    }

    bool isDirectChannelTypeSupported(int channelType) const {
        if (!isValid()) {
            return false;
        }
        return ASensor_isDirectChannelTypeSupported(mSensor, channelType);
    }

    int getHighestDirectReportRateLevel() const {
        if (!isValid()) {
            return ASENSOR_DIRECT_RATE_STOP;
        }
        return ASensor_getHighestDirectReportRateLevel(mSensor);
    }

    operator ASensor const * () { return mSensor; }

    bool isValid() const { return mSensor != nullptr; }
private:
    ASensor const * mSensor;
};

// Shared memory wrapper class
class TestSharedMemory {
public:
    static TestSharedMemory* create(int type, size_t size);
    char * getBuffer() const;
    std::vector<ASensorEvent> parseEvents(int64_t lastCounter = -1, size_t offset = 0) const;
    virtual ~TestSharedMemory();

    int getSharedMemoryFd() const {
        return mSharedMemoryFd;
    }

    AHardwareBuffer const * getHardwareBuffer() const {
        return mHardwareBuffer;
    }

    int getType() const {
        return mType;
    }

    size_t getSize() const {
        return mSize;
    }
private:
    TestSharedMemory(int type, size_t size);
    void release();

    const int mType;
    size_t mSize;
    char* mBuffer;
    int mSharedMemoryFd;
    AHardwareBuffer *mHardwareBuffer;
};
} // namespace SensorTest
} // namespace android

#endif // SENSOR_TEST_H