From: SangYoun Kwak Date: Tue, 10 Dec 2024 03:08:22 +0000 (+0900) Subject: Convert C++ class to C style to guarantee ABI compatibility X-Git-Tag: accepted/tizen/unified/20250123.133215~3 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=b630a58dfb19c39fd0811bdc38ebc16fbb0594e8;p=platform%2Fhal%2Fapi%2Fsensor.git Convert C++ class to C style to guarantee ABI compatibility Previously, hal backend creates sensor_device class object and sensord uses it directly. The prototype(interface)of sensor_device is defined in the hal-api-sensor, so sensord can use it directly. But this approach is a bit dangerous in the abi compatibility manner. The C++ class cannot guarantee the abi compatibility, so it should be fixed to use only C functions and structures. To resolve this issue, hal api functions are added as the replacement of sensor_device class methods. According this change, hal backend should provides functions which were provided as the form of methods of sensor_device class. Also, according to this change, haltest is modified too. Change-Id: I1fb6d698e5346027d8dba654ca86218594655a7e Signed-off-by: SangYoun Kwak --- diff --git a/haltest/main.cpp b/haltest/main.cpp index a0da52b..cc87664 100644 --- a/haltest/main.cpp +++ b/haltest/main.cpp @@ -2,27 +2,23 @@ #include "hal-sensor.h" #define CHECK_NODEV(ret_val) \ - if (ret_val == -ENODEV) { \ - SKIP_MESSAGE("Not supported HAL."); \ - return ; \ - } +if (ret_val == -ENODEV) { \ + SKIP_MESSAGE("Not supported HAL."); \ + return; \ +} class SENSOR_API : public testing::Test { protected: - static void SetUpHalTestSuite() { - } - - void SetUp() override { - } - void TearDown() override {} + static void SetUpHalTestSuite() { } + void SetUp() override { } + void TearDown() override { } }; TEST_F(SENSOR_API, GetBackendP) { SKIP_NO_FEATURE(); - int ret_val; - ret_val = hal_sensor_get_backend(); + int ret_val = hal_sensor_get_backend(); EXPECT_EQ(ret_val, 0) << strerr("Failed to get sensor device", ret_val); } @@ -30,34 +26,40 @@ TEST_F(SENSOR_API, CreateP) { SKIP_NO_FEATURE(); - int ret_val; - void **devices; - ret_val = hal_sensor_create(&devices); + int ret_val = 0; + int poll_fd = 0; + uint64_t *created_device_ids = nullptr; + size_t created_device_ids_len = 0; + + ret_val = hal_sensor_create(&created_device_ids, &created_device_ids_len); if (ret_val == -ENODEV) { SKIP_MESSAGE("Not supported HAL"); return; } - ASSERT_GT(ret_val, 0) << strerr("Failed to call create", ret_val); - ASSERT_NE(devices[0], nullptr) << "Opened devices are invalid."; + + ASSERT_GT(created_device_ids_len, 0) << strerr("Failed to call create", ret_val); + + ret_val = hal_sensor_get_poll_fd(created_device_ids[0], &poll_fd); + ASSERT_EQ(ret_val, 0) << "Opened devices are invalid."; } int main(int argc, char **argv) { - int ret = -1; - - try { - testing::InitGoogleTest(&argc, argv); - } catch(...) { - std::cout << "Exception occurred." << std::endl; - } - - try { - ret = RUN_ALL_TESTS(); - } catch (const ::testing::internal::GoogleTestFailureException& e) { - ret = -1; - std::cout << "GoogleTestFailureException was thrown:" << e.what() << std::endl; - } - - return ret; + int ret = -1; + + try { + testing::InitGoogleTest(&argc, argv); + } catch(...) { + std::cout << "Exception occurred." << std::endl; + } + + try { + ret = RUN_ALL_TESTS(); + } catch (const ::testing::internal::GoogleTestFailureException& e) { + ret = -1; + std::cout << "GoogleTestFailureException was thrown:" << e.what() << std::endl; + } + + return ret; } diff --git a/haltest/sensor-device.cpp b/haltest/sensor-device.cpp index 2856c8f..b91b135 100644 --- a/haltest/sensor-device.cpp +++ b/haltest/sensor-device.cpp @@ -1,34 +1,37 @@ #include +#include + #include "sensor-haltest.h" #include "hal-sensor.h" #include "hal-sensor-types.h" -typedef std::vector> device_registry_t; +typedef std::vector device_id_registry_t; class SENSOR_DEV : public testing::Test { public: - static int device_count; - static device_registry_t devices; - - static void SetUpHalTestSuite() { - void **sensors = nullptr; - device_count = hal_sensor_create(&sensors); - ASSERT_GT(device_count, 0) << "Failed to get sensor devices"; - - DEBUG_MESSAGE("Setup test suite : Create %d sensor devices", device_count); - for (int i = 0; i < device_count; i++) { - devices.emplace_back(static_cast(sensors[i])); - } - } + static size_t device_count; + static device_id_registry_t device_ids; + + static void SetUpHalTestSuite() + { + int ret = 0; + uint64_t *created_device_ids = nullptr; - void SetUp() override { + ret = hal_sensor_create(&created_device_ids, &device_count); + ASSERT_EQ(ret, 0) << "Failed to get sensor devices"; + + DEBUG_MESSAGE("Setup test suite : Create %zu sensor devices", device_count); + for (size_t i = 0; i < device_count; i++) + device_ids.push_back(created_device_ids[i]); } - void TearDown() override{} + + void SetUp() override { } + void TearDown() override { } }; -int SENSOR_DEV::device_count = 0; -device_registry_t SENSOR_DEV::devices; +size_t SENSOR_DEV::device_count = 0; +device_id_registry_t SENSOR_DEV::device_ids; #define SKIP_NO_DEV() \ do { \ @@ -40,141 +43,116 @@ do { \ TEST_F(SENSOR_DEV, get_poll_fdP) { + int poll_fd = 0; + int ret = 0; + SKIP_NO_FEATURE(); SKIP_NO_DEV(); - for (auto it = devices.begin(); it != devices.end(); ++it) { - EXPECT_NE((*it)->get_poll_fd(), 0); + for (size_t i = 0; i < device_ids.size(); ++i) { + poll_fd = 0; + + ret = hal_sensor_get_poll_fd(device_ids[i], &poll_fd); + EXPECT_EQ(ret, 0); + EXPECT_GT(poll_fd, 0); } } TEST_F(SENSOR_DEV, get_sensorsP) { const sensor_info_t *sensors = nullptr; - int ret_func; + size_t sensors_len = 0; + int ret = 0; SKIP_NO_FEATURE(); SKIP_NO_DEV(); - for (auto it = devices.begin(); it != devices.end(); ++it) { - ret_func = (*it)->get_sensors(&sensors); - EXPECT_GE(ret_func, 1); + for (size_t i = 0; i < device_ids.size(); ++i) { + sensors = nullptr; + sensors_len = 0; + + ret = hal_sensor_get_sensors(device_ids[i], &sensors, &sensors_len); + EXPECT_EQ(ret, 0); + EXPECT_GE(sensors_len, 1); EXPECT_NE(sensors, nullptr); } } TEST_F(SENSOR_DEV, get_sensorsN) { + int ret = 0; + size_t sensors_len = 0; + SKIP_NO_FEATURE(); SKIP_NO_DEV(); - for (auto it = devices.begin(); it != devices.end(); ++it) { - EXPECT_EQ((*it)->get_sensors(nullptr), -EINVAL); - } -} -/* -TEST_F(SENSOR_DEV, enableP) -{ - const sensor_info_t *sensors = nullptr; - - SKIP_NO_DEV() + for (size_t i = 0; i < device_ids.size(); ++i) { + sensors_len = 0; - for (auto it = devices.begin(); it != devices.end(); ++it) { - EXPECT_GE((*it)->get_sensors(&sensors), 1); - (*it)->disable(sensors[0].id); - EXPECT_EQ((*it)->enable(sensors[0].id), true); + ret = hal_sensor_get_sensors(device_ids[i], nullptr, &sensors_len); + EXPECT_EQ(ret, -EINVAL); } } -TEST_F(SENSOR_DEV, enableN) +TEST_F(SENSOR_DEV, get_dataP) { - SKIP_NO_DEV() - - for (auto it = devices.begin(); it != devices.end(); ++it) { - EXPECT_EQ((*it)->enable(0), false); - EXPECT_EQ((*it)->enable(10), false); - } -} + int ret = 0; -TEST_F(SENSOR_DEV, disableP) -{ const sensor_info_t *sensors = nullptr; + size_t sensors_len = 0; - SKIP_NO_DEV() - - for (auto it = devices.begin(); it != devices.end(); ++it) { - EXPECT_GE((*it)->get_sensors(&sensors), 1); - EXPECT_EQ((*it)->disable(sensors[0].id), true); - } + sensor_data_t *data = nullptr; + size_t data_length = 0; -} - -TEST_F(SENSOR_DEV, disableN) -{ - SKIP_NO_DEV() + SKIP_NO_FEATURE(); + SKIP_NO_DEV(); - for (auto it = devices.begin(); it != devices.end(); ++it) { - EXPECT_EQ((*it)->disable(0), false); - EXPECT_EQ((*it)->disable(10), false); - } -} -*/ -/* -TEST_F(SENSOR_DEV, read_fdP) -{ - uint32_t *id = nullptr; - int ret_func = 0; + for (size_t i = 0; i < device_ids.size(); ++i) { + sensors = nullptr; + sensors_len = 0; - SKIP_NO_DEV(); + ret = hal_sensor_get_sensors(device_ids[i], &sensors, &sensors_len); + EXPECT_EQ(ret, 0); + EXPECT_NE(sensors, nullptr); + EXPECT_GE(sensors_len, 1); - for (auto it = devices.begin(); it != devices.end(); ++it) { - EXPECT_EQ((*it)->enable(1), true); + data = nullptr; + data_length = 0; - ret_func = (*it)->read_fd(&id); - EXPECT_NE(id, nullptr); - EXPECT_NE(ret_func, 0); + ret = hal_sensor_get_data(device_ids[i], sensors[0].id, &data, &data_length); + EXPECT_EQ(ret, 0); + EXPECT_NE(data, nullptr); + EXPECT_GE(data_length, 1); } } -TEST_F(SENSOR_DEV, read_fdN) +TEST_F(SENSOR_DEV, get_dataN) { + int ret = 0; - SKIP_NO_DEV(); - - for (auto it = devices.begin(); it != devices.end(); ++it) { - EXPECT_EQ((*it)->read_fd(nullptr), -EINVAL); - } -} -*/ -TEST_F(SENSOR_DEV, get_dataP) -{ - int length = 0; - int ret_func = 0; - sensor_data_t *data = NULL; - const sensor_info_t *sensors = nullptr; + sensor_data_t *data = nullptr; + size_t data_length = 0; SKIP_NO_FEATURE(); SKIP_NO_DEV(); - for (auto it = devices.begin(); it != devices.end(); ++it) { - EXPECT_GE((*it)->get_sensors(&sensors), 1); + for (size_t i = 0; i < device_ids.size(); ++i) { + data = nullptr; + data_length = 0; - ret_func = (*it)->get_data(sensors[0].id, &data, &length); - EXPECT_EQ(ret_func, 0); - } -} + ret = hal_sensor_get_data(device_ids[i], 0, &data, &data_length); + EXPECT_EQ(ret, -EINVAL); -TEST_F(SENSOR_DEV, get_dataN) -{ - int length = 0; - sensor_data_t *data = NULL; + data = nullptr; + data_length = 0; - SKIP_NO_FEATURE(); - SKIP_NO_DEV(); + hal_sensor_get_data(device_ids[i], 1, nullptr, &data_length); + EXPECT_EQ(ret, -EINVAL); + + data = nullptr; + data_length = 0; - for (auto it = devices.begin(); it != devices.end(); ++it) { - EXPECT_EQ((*it)->get_data(0, &data, &length), -EINVAL); - EXPECT_EQ((*it)->get_data(1, nullptr, &length), -EINVAL); - EXPECT_EQ((*it)->get_data(1, &data, nullptr), -EINVAL); + hal_sensor_get_data(device_ids[i], 1, &data, nullptr); + EXPECT_EQ(ret, -EINVAL); } } diff --git a/include/hal-sensor-interface-1.h b/include/hal-sensor-interface-1.h index f700964..0801ebf 100644 --- a/include/hal-sensor-interface-1.h +++ b/include/hal-sensor-interface-1.h @@ -19,6 +19,8 @@ #ifndef __HAL_SENSOR_INTERFACE_1__ #define __HAL_SENSOR_INTERFACE_1__ +#include + #include #include "hal-sensor-types.h" @@ -26,8 +28,29 @@ extern "C" { #endif +typedef struct { + int (*get_poll_fd)(uint32_t sensor_device_id, int *poll_fd); + int (*get_sensors)(uint32_t sensor_device_id, const sensor_info_t **sensors, size_t *sensors_len); + + int (*enable)(uint32_t sensor_device_id, uint32_t id); + int (*disable)(uint32_t sensor_device_id, uint32_t id); + + int (*read_fd)(uint32_t sensor_device_id, uint32_t **ids, size_t *ids_len); + int (*get_data)(uint32_t sensor_device_id, uint32_t id, sensor_data_t **data, size_t *length); + + int (*set_interval)(uint32_t sensor_device_id, uint32_t id, unsigned long val); + int (*set_batch_latency)(uint32_t sensor_device_id, uint32_t id, unsigned long val); + int (*set_attribute_int)(uint32_t sensor_device_id, uint32_t id, int32_t attribute, int32_t value); + int (*set_attribute_str)(uint32_t sensor_device_id, uint32_t id, int32_t attribute, const char *value, size_t len); + int (*get_attribute_int)(uint32_t sensor_device_id, uint32_t id, int32_t attribute, int32_t *value); + int (*get_attribute_str)(uint32_t sensor_device_id, uint32_t id, int32_t attribute, char **value, size_t *len); + + int (*flush)(uint32_t sensor_device_id, uint32_t id); +} sensor_device_s; + typedef struct _hal_backend_sensor_funcs { - int (*create)(sensor_device_t **devices); + int (*create_sensor)(sensor_device_s ***sensor_devices, size_t *sensor_devices_len); + int (*delete_sensor)(uint32_t *sensor_device_ids, size_t sensor_device_ids_len); } hal_backend_sensor_funcs; #ifdef __cplusplus diff --git a/include/hal-sensor-types.h b/include/hal-sensor-types.h index 7460faa..37d135b 100644 --- a/include/hal-sensor-types.h +++ b/include/hal-sensor-types.h @@ -560,54 +560,5 @@ enum hal_sensor_lidar_power_state { #ifdef __cplusplus } -/* - * Create devices - */ -typedef void *sensor_device_t; -typedef int (*create_t)(sensor_device_t **devices); - -/* - * Sensor device interface - * 1 device must be abstracted from 1 device event node - */ -class sensor_device { - public: - virtual ~sensor_device() {} - - uint32_t get_hal_version(void) { return SENSOR_HAL_VERSION(1, 0); } - - virtual int get_poll_fd(void) = 0; - virtual int get_sensors(const sensor_info_t **sensors) = 0; - - virtual bool enable(uint32_t id) = 0; - virtual bool disable(uint32_t id) = 0; - - virtual int read_fd(uint32_t **ids) = 0; - virtual int get_data(uint32_t id, sensor_data_t **data, int *length) = 0; - - virtual bool set_interval(uint32_t id, unsigned long val) { return true; } - virtual bool set_batch_latency(uint32_t id, unsigned long val) { - return true; - } - virtual bool set_attribute_int(uint32_t id, int32_t attribute, - int32_t value) { - return true; - } - virtual bool set_attribute_str(uint32_t id, int32_t attribute, const char *value, - int len) { - return true; - } - virtual bool get_attribute_int(uint32_t id, int32_t attribute, - int32_t *value) { - return true; - } - virtual bool get_attribute_str(uint32_t id, int32_t attribute, char **value, - int *len) { - return true; - } - - virtual bool flush(uint32_t id) { return true; } -}; - #endif /* __cplusplus */ #endif /* __HAL_SENSOR_TYPES__ */ diff --git a/include/hal-sensor.h b/include/hal-sensor.h index 6743422..1f218cb 100644 --- a/include/hal-sensor.h +++ b/include/hal-sensor.h @@ -19,7 +19,9 @@ #ifndef __HAL_SENSOR__ #define __HAL_SENSOR__ -#include "hal-sensor-types.h" +#include + +#include "hal-sensor-interface.h" #ifdef __cplusplus extern "C" { @@ -28,7 +30,26 @@ extern "C" { int hal_sensor_get_backend(void); int hal_sensor_put_backend(void); -int hal_sensor_create(sensor_device_t **devices); +int hal_sensor_create(uint64_t **sensor_device_ids, size_t *sensor_device_ids_len); +int hal_sensor_delete(uint64_t *sensor_device_ids, size_t sensor_device_ids_len); + +int hal_sensor_get_poll_fd(uint64_t sensor_device_id, int *poll_fd); +int hal_sensor_get_sensors(uint64_t sensor_device_id, const sensor_info_t **sensors, size_t *sensors_len); + +int hal_sensor_enable(uint64_t sensor_device_id, uint32_t id); +int hal_sensor_disable(uint64_t sensor_device_id, uint32_t id); + +int hal_sensor_read_fd(uint64_t sensor_device_id, uint32_t **ids, size_t *ids_len); +int hal_sensor_get_data(uint64_t sensor_device_id, uint32_t id, sensor_data_t **data, size_t *length); + +int hal_sensor_set_interval(uint64_t sensor_device_id, uint32_t id, unsigned long val); +int hal_sensor_set_batch_latency(uint64_t sensor_device_id, uint32_t id, unsigned long val); +int hal_sensor_set_attribute_int(uint64_t sensor_device_id, uint32_t id, int32_t attribute, int32_t value); +int hal_sensor_set_attribute_str(uint64_t sensor_device_id, uint32_t id, int32_t attribute, const char *value, size_t len); +int hal_sensor_get_attribute_int(uint64_t sensor_device_id, uint32_t id, int32_t attribute, int32_t *value); +int hal_sensor_get_attribute_str(uint64_t sensor_device_id, uint32_t id, int32_t attribute, char **value, size_t *len); + +int hal_sensor_flush(uint64_t sensor_device_id, uint32_t id); #ifdef __cplusplus } diff --git a/src/hal-api-sensor.cpp b/src/hal-api-sensor.cpp index cd5b24c..cac1f20 100644 --- a/src/hal-api-sensor.cpp +++ b/src/hal-api-sensor.cpp @@ -14,15 +14,17 @@ * limitations under the License. */ #include +#include +#include #include #include #include -#include "hal-api-sensor-log.h" #include "hal-sensor-interface.h" -#include "hal-sensor-types.h" #include "hal-sensor.h" +#include "hal-api-sensor-log.h" + #ifndef EXPORT #define EXPORT __attribute__((visibility("default"))) #endif @@ -37,13 +39,200 @@ enum { HAL_SENSOR_INIT_SUCCESS = 1, } static hal_initialized = HAL_SENSOR_INIT_NOT_INITIALIZED; -static std::vector hal_backend_devs; +static size_t g_created_sensor_count = 0; +static std::vector> g_sensor_devices; #define FREE(x) \ do { if (x) { free(x); x = NULL; } } while(0) +#define FOR_HAL_SENSOR_DEVICES_ID(SENSOR_TYPE, DEVICE_ID) \ +for ((SENSOR_TYPE) = 0; (SENSOR_TYPE) < g_sensor_devices.size(); ++(SENSOR_TYPE)) \ + for ((DEVICE_ID) = 0; (DEVICE_ID) < g_sensor_devices[(SENSOR_TYPE)].size(); ++(DEVICE_ID)) + +#define PARSE_SENSOR_DEVICE_ID(SENSOR_DEVICE_ID, SENSOR_TYPE, DEVICE_ID) \ +do { \ + (SENSOR_TYPE) = ((SENSOR_DEVICE_ID) >> 32) & 0xFFFFFFFF; \ + (DEVICE_ID) = (SENSOR_DEVICE_ID) & 0xFFFFFFFF; \ +} while (0) + #define MAX_LIB_NAME 256 +static int create_sensor_devices(void) +{ + int ret = 0; + sensor_device_s **created_sensor_devices = nullptr; + size_t created_sensor_devices_len = 0; + + if (g_created_sensor_count > 0) + return 0; + + if (hal_sensor_funcs == nullptr || hal_sensor_count == 0) { + _E("No hal sensor functions"); + return -ENOENT; + } + + g_sensor_devices.clear(); + g_sensor_devices.reserve(hal_sensor_count); + for (size_t i = 0; i < hal_sensor_count; ++i) + g_sensor_devices.push_back(std::vector()); + + for (size_t i = 0; i < hal_sensor_count; ++i) { + if (hal_sensor_funcs[i] == nullptr || hal_sensor_funcs[i]->create_sensor == nullptr) { + _W("Cannot create hal sensor: No hal function for index(%zu)", i); + continue; + } + + ret = hal_sensor_funcs[i]->create_sensor(&created_sensor_devices, &created_sensor_devices_len); + if (ret != 0) { + _W("Cannot create sensor device: ret(%d)", ret); + continue; + } + + g_sensor_devices[i].reserve(created_sensor_devices_len); + for (size_t device_id = 0; device_id < created_sensor_devices_len; ++device_id) + g_sensor_devices[i].push_back(created_sensor_devices[device_id]); + + g_created_sensor_count += created_sensor_devices_len; + } + + return 0; +} + +static int get_sensor_device_ids(uint64_t **sensor_device_ids, size_t *sensor_device_ids_len) +{ + if (g_created_sensor_count == 0) { + _E("There is no sensor device entry."); + return -ENOENT; + } + + std::vector sensor_device_id_vector; + size_t sensor_type = 0; + size_t device_id = 0; + uint64_t sensor_device_id = 0; + + FOR_HAL_SENSOR_DEVICES_ID(sensor_type, device_id) { + sensor_device_id = (((uint64_t)sensor_type) << 32) | ((uint64_t)device_id); + sensor_device_id_vector.push_back(sensor_device_id); + } + + if (sensor_device_id_vector.size() == 0) { + _E("There is no sensor device entry."); + return -ENOENT; + } + + uint64_t *sensor_device_id_arr = (uint64_t *)calloc(sensor_device_id_vector.size(), sizeof(*sensor_device_id_arr)); + if (sensor_device_id_arr == nullptr) { + _E("Failed to allocate memory for sensor device ids"); + return -ENOMEM; + } + + std::copy(sensor_device_id_vector.begin(), sensor_device_id_vector.end(), sensor_device_id_arr); + + *sensor_device_ids = sensor_device_id_arr; + *sensor_device_ids_len = sensor_device_id_vector.size(); + + return 0; +} + +static int get_sensor_device_with_sensor_type_and_device_id(uint32_t sensor_type, uint32_t device_id, sensor_device_s **sensor_device) +{ + if (g_created_sensor_count == 0) { + _E("There is no sensor device entry."); + return -ENOENT; + } + + if (sensor_device == nullptr) { + _E("Invalid sensor device(NULL)"); + return -EINVAL; + } + + if (sensor_type >= g_sensor_devices.size()) { + _E("Invalid sensor type(%" PRIu32 ")", sensor_type); + return -EINVAL; + } + + if (device_id >= g_sensor_devices[sensor_type].size()) { + _E("Invalid device id(%" PRIu32 ")", device_id); + return -EINVAL; + } + + *sensor_device = g_sensor_devices[sensor_type][device_id]; + + return 0; +} + +static int delete_sensor_device_with_sensor_type_and_device_id(uint32_t sensor_type, uint32_t device_id) +{ + if (g_created_sensor_count == 0) { + _E("There is no sensor device entry."); + return -ENOENT; + } + + int ret = 0; + sensor_device_s *sensor_device = nullptr; + + ret = get_sensor_device_with_sensor_type_and_device_id(sensor_type, device_id, &sensor_device); + if (ret != 0) { + _E("Failed to get sensor device: sensor type(%" PRIu32 "), device id(%" PRIu32 ")", + sensor_type, device_id); + return ret; + } + + if (sensor_device == nullptr) + return 0; + + ret = hal_sensor_funcs[sensor_type]->delete_sensor(&device_id, 1); + if (ret != 0) { + _E("Failed to delete sensor device: sensor type(%" PRIu32 "), device id(%" PRIu32 ")", + sensor_type, device_id); + return ret; + } + + g_sensor_devices[sensor_type][device_id] = nullptr; + --g_created_sensor_count; + + return 0; +} + +static int delete_sensor_device_with_sensor_device_id(uint64_t sensor_device_id) +{ + if (g_created_sensor_count == 0) { + _E("There is no sensor device entry."); + return -ENOENT; + } + + uint32_t sensor_type = 0; + uint32_t device_id = 0; + + PARSE_SENSOR_DEVICE_ID(sensor_device_id, sensor_type, device_id); + + return delete_sensor_device_with_sensor_type_and_device_id(sensor_type, device_id); +} + +static int delete_sensor_devices(void) +{ + int ret = 0; + size_t sensor_type = 0; + size_t device_id = 0; + + FOR_HAL_SENSOR_DEVICES_ID(sensor_type, device_id) { + if (sensor_type > UINT32_MAX || device_id > UINT32_MAX) { + _E("Invalid ids, exceeds available id range: sensor_type( %zu), device_id(%zu)", + sensor_type, device_id); + return -EINVAL; + } + + ret = delete_sensor_device_with_sensor_type_and_device_id(sensor_type, device_id); + if (ret != 0) { + _W("Cannot delete sensor device for sensor_type(%" PRIu32 "), device_id(%" PRIu32 ")", + (uint32_t)sensor_type, (uint32_t)device_id); + continue; + } + } + + return 0; +} + EXPORT int hal_sensor_get_backend(void) { @@ -140,6 +329,8 @@ int hal_sensor_put_backend(void) if (!hal_sensor_funcs) return -ENODEV; + delete_sensor_devices(); + for (i = 0; i < hal_sensor_count; i++) { if (hal_sensor_funcs[i]) { hal_common_put_backend_with_library_name(HAL_MODULE_SENSOR, (void *)hal_sensor_funcs[i], hal_sensor_names[i]); @@ -156,33 +347,219 @@ int hal_sensor_put_backend(void) } EXPORT -int hal_sensor_create(sensor_device_t **devices) +int hal_sensor_create(uint64_t **sensor_device_ids, size_t *sensor_device_ids_len) { - int ret, ret_create; - int i, j; - sensor_device_t *device; + int ret = 0; if (!hal_sensor_funcs && (hal_initialized == HAL_SENSOR_INIT_NOT_INITIALIZED)) { - if ((ret = hal_sensor_get_backend()) < 0) + ret = hal_sensor_get_backend(); + if (ret < 0) return ret; } if (!hal_sensor_funcs || (hal_sensor_count == 0)) return -ENODEV; - if (hal_backend_devs.empty()) { - for (i = 0; i < hal_sensor_count; i++) { - if (!hal_sensor_funcs[i] || !hal_sensor_funcs[i]->create) - continue; + ret = create_sensor_devices(); + if (ret != 0) { + _E("Failed to create sensor devices: ret(%d)", ret); + return ret; + } + + ret = get_sensor_device_ids(sensor_device_ids, sensor_device_ids_len); + if (ret != 0) { + _E("Failed to get sensor device ids array: ret(%d)", ret); + return ret; + } + + return 0; +} + +EXPORT +int hal_sensor_delete(uint64_t *sensor_device_ids, size_t sensor_device_ids_len) +{ + int ret = 0; + + if (sensor_device_ids == NULL) { + _E("Invalid parameter: sensor_device_ids is NULL"); + return -EINVAL; + } - ret_create = hal_sensor_funcs[i]->create(&device); - for (j = 0; j < ret_create; j++) - { - hal_backend_devs.push_back(device[j]); - } + for (size_t i = 0; i < sensor_device_ids_len; ++i) { + ret = delete_sensor_device_with_sensor_device_id(sensor_device_ids[i]); + if (ret != 0) { + _W("Cannot delete sensor for sensor device id(%" PRIu64 "): ret(%d)", + sensor_device_ids[i], ret); + continue; } } - *devices = &hal_backend_devs[0]; - return hal_backend_devs.size(); + return 0; +} + +#define RET_IF_INVALID_DEVICE(SENSOR_DEVICE_ID, DEVICE_ID, FUNC_NAME, SENSOR_DEVICE) \ +do { \ + if (g_created_sensor_count == 0) { \ + _E("There is no sensor device entry."); \ + return -ENOENT; \ + } \ + \ + int ret = 0; \ + uint32_t sensor_type = 0; \ + \ + PARSE_SENSOR_DEVICE_ID((SENSOR_DEVICE_ID), sensor_type, (DEVICE_ID)); \ + \ + ret = get_sensor_device_with_sensor_type_and_device_id(sensor_type, (DEVICE_ID), &(SENSOR_DEVICE)); \ + if (ret != 0) { \ + _E("Failed to get sensor device: ret(%d)", ret); \ + return ret; \ + } \ + \ + if ((SENSOR_DEVICE) == nullptr || (SENSOR_DEVICE)->FUNC_NAME == nullptr) { \ + _E("Failed to " #FUNC_NAME ": No hal function for sensor device id(%" PRIu64 ")", (SENSOR_DEVICE_ID)); \ + return -EINVAL; \ + } \ +} while (0) + +EXPORT +int hal_sensor_get_poll_fd(uint64_t sensor_device_id, int *poll_fd) +{ + int device_id = 0; + sensor_device_s *sensor_device = NULL; + + RET_IF_INVALID_DEVICE(sensor_device_id, device_id, get_poll_fd, sensor_device); + + return sensor_device->get_poll_fd(device_id, poll_fd); +} + +EXPORT +int hal_sensor_get_sensors(uint64_t sensor_device_id, const sensor_info_t **sensors, size_t *sensors_len) +{ + int device_id = 0; + sensor_device_s *sensor_device = NULL; + + RET_IF_INVALID_DEVICE(sensor_device_id, device_id, get_sensors, sensor_device); + + return sensor_device->get_sensors(device_id, sensors, sensors_len); +} + +EXPORT +int hal_sensor_enable(uint64_t sensor_device_id, uint32_t id) +{ + int device_id = 0; + sensor_device_s *sensor_device = NULL; + + RET_IF_INVALID_DEVICE(sensor_device_id, device_id, enable, sensor_device); + + return sensor_device->enable(device_id, id); +} + +EXPORT +int hal_sensor_disable(uint64_t sensor_device_id, uint32_t id) +{ + int device_id = 0; + sensor_device_s *sensor_device = NULL; + + RET_IF_INVALID_DEVICE(sensor_device_id, device_id, disable, sensor_device); + + return sensor_device->disable(device_id, id); +} + +EXPORT +int hal_sensor_read_fd(uint64_t sensor_device_id, uint32_t **ids, size_t *ids_len) +{ + int device_id = 0; + sensor_device_s *sensor_device = NULL; + + RET_IF_INVALID_DEVICE(sensor_device_id, device_id, read_fd, sensor_device); + + return sensor_device->read_fd(device_id, ids, ids_len); +} + +EXPORT +int hal_sensor_get_data(uint64_t sensor_device_id, uint32_t id, sensor_data_t **data, size_t *length) +{ + int device_id = 0; + sensor_device_s *sensor_device = NULL; + + RET_IF_INVALID_DEVICE(sensor_device_id, device_id, get_data, sensor_device); + + return sensor_device->get_data(device_id, id, data, length); +} + +EXPORT +int hal_sensor_set_interval(uint64_t sensor_device_id, uint32_t id, unsigned long val) +{ + int device_id = 0; + sensor_device_s *sensor_device = NULL; + + RET_IF_INVALID_DEVICE(sensor_device_id, device_id, set_interval, sensor_device); + + return sensor_device->set_interval(device_id, id, val); +} + +EXPORT +int hal_sensor_set_batch_latency(uint64_t sensor_device_id, uint32_t id, unsigned long val) +{ + int device_id = 0; + sensor_device_s *sensor_device = NULL; + + RET_IF_INVALID_DEVICE(sensor_device_id, device_id, set_batch_latency, sensor_device); + + return sensor_device->set_batch_latency(device_id, id, val); +} + +EXPORT +int hal_sensor_set_attribute_int(uint64_t sensor_device_id, uint32_t id, int32_t attribute, int32_t value) +{ + int device_id = 0; + sensor_device_s *sensor_device = NULL; + + RET_IF_INVALID_DEVICE(sensor_device_id, device_id, set_attribute_int, sensor_device); + + return sensor_device->set_attribute_int(device_id, id, attribute, value); +} + +EXPORT +int hal_sensor_set_attribute_str(uint64_t sensor_device_id, uint32_t id, int32_t attribute, const char *value, size_t len) +{ + int device_id = 0; + sensor_device_s *sensor_device = NULL; + + RET_IF_INVALID_DEVICE(sensor_device_id, device_id, set_attribute_str, sensor_device); + + return sensor_device->set_attribute_str(device_id, id, attribute, value, len); +} + +EXPORT +int hal_sensor_get_attribute_int(uint64_t sensor_device_id, uint32_t id, int32_t attribute, int32_t *value) +{ + int device_id = 0; + sensor_device_s *sensor_device = NULL; + + RET_IF_INVALID_DEVICE(sensor_device_id, device_id, get_attribute_int, sensor_device); + + return sensor_device->get_attribute_int(device_id, id, attribute, value); +} + +EXPORT +int hal_sensor_get_attribute_str(uint64_t sensor_device_id, uint32_t id, int32_t attribute, char **value, size_t *len) +{ + int device_id = 0; + sensor_device_s *sensor_device = NULL; + + RET_IF_INVALID_DEVICE(sensor_device_id, device_id, get_attribute_str, sensor_device); + + return sensor_device->get_attribute_str(device_id, id, attribute, value, len); +} + +EXPORT +int hal_sensor_flush(uint64_t sensor_device_id, uint32_t id) +{ + int device_id = 0; + sensor_device_s *sensor_device = NULL; + + RET_IF_INVALID_DEVICE(sensor_device_id, device_id, flush, sensor_device); + + return sensor_device->flush(device_id, id); }