Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 89df2e70 authored by Peng Xu's avatar Peng Xu
Browse files

[sensors] Default implementation and vts of direct report 

Added support for newly added HAL function for sensor event direct
report feature, replace dummy implementation with funtional ones for
the following:

  * registerDirectChannel
  * unregisterDirectChannel
  * configDirectReport

Added a vts test case for direct report.

Added new offset definition to types.hal. This will not affect
existing client/calling code.

Bug: 30985702
Bug: 32022776

Test: vts pass

Change-Id: Ie5e3cddd7c37664e8c59d69cf70aaa1310fd3f58
parent e9651fd0

sensors/1.0/default/Sensors.cpp

+56 −13
Original line number Diff line number Diff line
@@ -42,10 +42,12 @@ static Result ResultFromStatus(status_t err) { 
    switch (err) {

        case OK:

            return Result::OK;

        case BAD_VALUE:

            return Result::BAD_VALUE;

        case PERMISSION_DENIED:

            return Result::PERMISSION_DENIED;

        case NO_MEMORY:

            return Result::NO_MEMORY;

        case BAD_VALUE:

            return Result::BAD_VALUE;

        default:

            return Result::INVALID_OPERATION;

    }
@@ -226,30 +228,71 @@ Return<Result> Sensors::injectSensorData(const Event& event) { 


Return<void> Sensors::registerDirectChannel(

        const SharedMemInfo& mem, registerDirectChannel_cb _hidl_cb) {

    //TODO(b/30985702): finish implementation

    (void) mem;

    if (mSensorDevice->register_direct_channel == nullptr

            || mSensorDevice->config_direct_report == nullptr) {

        // HAL does not support

        _hidl_cb(Result::INVALID_OPERATION, -1);

        return Void();

    }



    sensors_direct_mem_t m;

    if (!convertFromSharedMemInfo(mem, &m)) {

      _hidl_cb(Result::BAD_VALUE, -1);

      return Void();

    }



    int err = mSensorDevice->register_direct_channel(mSensorDevice, &m, -1);



    if (err < 0) {

        _hidl_cb(ResultFromStatus(err), -1);

    } else {

        int32_t channelHandle = static_cast<int32_t>(err);

        _hidl_cb(Result::OK, channelHandle);

    }

    return Void();

}



Return<Result> Sensors::unregisterDirectChannel(int32_t channelHandle) {

    //TODO(b/30985702): finish implementation

    (void) channelHandle;

    if (mSensorDevice->register_direct_channel == nullptr

            || mSensorDevice->config_direct_report == nullptr) {

        // HAL does not support

        return Result::INVALID_OPERATION;

    }



    mSensorDevice->register_direct_channel(mSensorDevice, nullptr, channelHandle);



    return Result::OK;

}



Return<void> Sensors::configDirectReport(

        int32_t sensorHandle, int32_t channelHandle, RateLevel rate,

        configDirectReport_cb _hidl_cb) {

    //TODO(b/30985702): finish implementation

    (void) sensorHandle;

    (void) channelHandle;

    (void) rate;



    if (mSensorDevice->register_direct_channel == nullptr

            || mSensorDevice->config_direct_report == nullptr) {

        // HAL does not support

        _hidl_cb(Result::INVALID_OPERATION, -1);

        return Void();

    }



    sensors_direct_cfg_t cfg = {

        .rate_level = convertFromRateLevel(rate)

    };

    if (cfg.rate_level < 0) {

        _hidl_cb(Result::BAD_VALUE, -1);

        return Void();

    }



    int err = mSensorDevice->config_direct_report(mSensorDevice,

            sensorHandle, channelHandle, &cfg);



    if (rate == RateLevel::STOP) {

        _hidl_cb(ResultFromStatus(err), -1);

    } else {

        _hidl_cb(err > 0 ? Result::OK : ResultFromStatus(err), err);

    }

    return Void();

}



// static

void Sensors::convertFromSensorEvents(

        size_t count,

sensors/1.0/default/convert.cpp

+44 −0
Original line number Diff line number Diff line
@@ -340,6 +340,50 @@ void convertToSensorEvent(const Event &src, sensors_event_t *dst) { 
    }

}



bool convertFromSharedMemInfo(const SharedMemInfo& memIn, sensors_direct_mem_t *memOut) {

    if (memOut == nullptr) {

        return false;

    }



    switch(memIn.type) {

        case SharedMemType::ASHMEM:

            memOut->type = SENSOR_DIRECT_MEM_TYPE_ASHMEM;

            break;

        case SharedMemType::GRALLOC:

            memOut->type = SENSOR_DIRECT_MEM_TYPE_GRALLOC;

            break;

        default:

            return false;

    }



    switch(memIn.format) {

        case SharedMemFormat::SENSORS_EVENT:

            memOut->format = SENSOR_DIRECT_FMT_SENSORS_EVENT;

            break;

        default:

            return false;

    }



    memOut->size = memIn.size;

    memOut->handle = memIn.memoryHandle;

    return true;

}



int convertFromRateLevel(RateLevel rate) {

    switch(rate) {

        case RateLevel::STOP:

            return SENSOR_DIRECT_RATE_STOP;

        case RateLevel::NORMAL:

            return SENSOR_DIRECT_RATE_NORMAL;

        case RateLevel::FAST:

            return SENSOR_DIRECT_RATE_FAST;

        case RateLevel::VERY_FAST:

            return SENSOR_DIRECT_RATE_VERY_FAST;

        default:

            return -1;

    }

}



}  // namespace implementation

}  // namespace V1_0

}  // namespace sensors

sensors/1.0/default/include/sensors/convert.h

+3 −0
Original line number Diff line number Diff line
@@ -33,6 +33,9 @@ void convertToSensor(const SensorInfo &src, sensor_t *dst); 
void convertFromSensorEvent(const sensors_event_t &src, Event *dst);

void convertToSensorEvent(const Event &src, sensors_event_t *dst);



bool convertFromSharedMemInfo(const SharedMemInfo& memIn, sensors_direct_mem_t *memOut);

int convertFromRateLevel(RateLevel rate);



}  // namespace implementation

}  // namespace V1_0

}  // namespace sensors

sensors/1.0/types.hal

+22 −13
Original line number Diff line number Diff line
@@ -1224,21 +1224,30 @@ enum SharedMemType : int32_t { 
@export(name="direct_format_t", value_prefix="SENSOR_DIRECT_FMT_")

enum SharedMemFormat : int32_t {

    SENSORS_EVENT = 1,  // shared memory is formated as an array of data

                        // elements, each sized 104 bytes. Details of fields:

                        //

                        // elements. See SensorsEventFormatOffset for details.

                        // Upon return of channel registration call, the

                        // shared memory space must be formated to all 0 by HAL.

};



enum SensorsEventFormatOffset : uint16_t {

    // offset   type        name

    //-----------------------------------

    // 0x0000   int32_t     size (always 104)

    // 0x0004   int32_t     sensor report token

    // 0x0008   int32_t     type (see SensorType)

                        // 0x000C   int32_t     atomic counter

    // 0x000C   uint32_t    atomic counter

    // 0x0010   int64_t     timestamp (see Event)

                        // 0x0014   float[16]/  data

    // 0x0018   float[16]/  data

    //          int64_t[8]

                        // 0x0058   int32_t[4]  reserved

                        //

                        // Upon return of channel registration call, the

                        // shared memory space must be formated to all 0 by HAL.

    // 0x0058   int32_t[4]  reserved (set to zero)

    SIZE_FIELD      = 0x0,

    REPORT_TOKEN    = 0x4,

    SENSOR_TYPE     = 0x8,

    ATOMIC_COUNTER  = 0xC,

    TIMESTAMP       = 0x10,

    DATA            = 0x18,

    RESERVED        = 0x58,

    TOTAL_LENGTH    = 0x68

};



/**

sensors/1.0/vts/functional/Android.bp

+3 −2
Original line number Diff line number Diff line
@@ -19,10 +19,11 @@ cc_test { 
    gtest: true,

    srcs: ["sensors_hidl_hal_test.cpp"],

    shared_libs: [

        "liblog",

        "android.hardware.sensors@1.0",

        "libcutils",

        "libhidlbase",

        "liblog",

        "libutils",

        "android.hardware.sensors@1.0",

    ],

    static_libs: ["libgtest"],

    cflags: [