Home | History | Annotate | Download | only in jni 
      1 /*
      2  * Copyright (C) 2017 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 #ifndef SENSOR_TEST_H
     18 #define SENSOR_TEST_H
     19 
     20 #include "nativeTestHelper.h"
     21 #include <android/sensor.h>
     22 #include <android/hardware_buffer.h>
     23 #include <android/sharedmem.h>
     24 
     25 #include <unordered_set>
     26 #include <vector>
     27 #include <sys/mman.h>
     28 #include <unistd.h>
     29 
     30 namespace android {
     31 namespace SensorTest {
     32 
     33 class TestSensor;
     34 class TestSensorManager;
     35 class TestSharedMemory;
     36 
     37 class SensorTest {
     38 public:
     39     virtual bool SetUp();
     40     virtual void TearDown();
     41     virtual ~SensorTest() = default;
     42 
     43     // tests
     44     void testInitialized(JNIEnv *env);
     45     void testInvalidParameter(JNIEnv *env);
     46     void testDirectReport(JNIEnv *env, int32_t sensorType, int32_t channelType, int32_t rateLevel);
     47 
     48 private:
     49     std::unique_ptr<TestSensorManager> mManager;
     50 };
     51 
     52 // NDK ASensorManager wrapper
     53 class TestSensorManager {
     54 public:
     55     static TestSensorManager * getInstanceForPackage(const char *package);
     56     virtual ~TestSensorManager();
     57 
     58     TestSensor getDefaultSensor(int type);
     59     int createDirectChannel(const TestSharedMemory &mem);
     60     void destroyDirectChannel(int channel);
     61     int configureDirectReport(TestSensor sensor, int channel, int rateLevel);
     62     bool isValid() const { return mManager != nullptr; }
     63 private:
     64     TestSensorManager(const char *package);
     65     int createSharedMemoryDirectChannel(int fd, size_t size);
     66     int createHardwareBufferDirectChannel(AHardwareBuffer const *buffer, size_t size);
     67 
     68     ASensorManager *mManager; // singleton, does not need delete
     69 
     70     // book keeping
     71     std::unordered_set<int> mSensorDirectChannel;
     72 };
     73 
     74 // NDK ASensor warpper
     75 class TestSensor {
     76 public:
     77     TestSensor(ASensor const *s) : mSensor(s) { }
     78 
     79     int getType() const {
     80         if (!isValid()) {
     81             return -1;
     82         }
     83         return ASensor_getType(mSensor);
     84     }
     85 
     86     bool isDirectChannelTypeSupported(int channelType) const {
     87         if (!isValid()) {
     88             return false;
     89         }
     90         return ASensor_isDirectChannelTypeSupported(mSensor, channelType);
     91     }
     92 
     93     int getHighestDirectReportRateLevel() const {
     94         if (!isValid()) {
     95             return ASENSOR_DIRECT_RATE_STOP;
     96         }
     97         return ASensor_getHighestDirectReportRateLevel(mSensor);
     98     }
     99 
    100     operator ASensor const * () { return mSensor; }
    101 
    102     bool isValid() const { return mSensor != nullptr; }
    103 private:
    104     ASensor const * mSensor;
    105 };
    106 
    107 // Shared memory wrapper class
    108 class TestSharedMemory {
    109 public:
    110     static TestSharedMemory* create(int type, size_t size);
    111     char * getBuffer() const;
    112     std::vector<ASensorEvent> parseEvents(int64_t lastCounter = -1, size_t offset = 0) const;
    113     virtual ~TestSharedMemory();
    114 
    115     int getSharedMemoryFd() const {
    116         return mSharedMemoryFd;
    117     }
    118 
    119     AHardwareBuffer const * getHardwareBuffer() const {
    120         return mHardwareBuffer;
    121     }
    122 
    123     int getType() const {
    124         return mType;
    125     }
    126 
    127     size_t getSize() const {
    128         return mSize;
    129     }
    130 private:
    131     TestSharedMemory(int type, size_t size);
    132     void release();
    133 
    134     const int mType;
    135     size_t mSize;
    136     char* mBuffer;
    137     int mSharedMemoryFd;
    138     AHardwareBuffer *mHardwareBuffer;
    139 };
    140 } // namespace SensorTest
    141 } // namespace android
    142 
    143 #endif // SENSOR_TEST_H
    144