#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);
}
{
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;
}
#include <memory>
+#include <inttypes.h>
+
#include "sensor-haltest.h"
#include "hal-sensor.h"
#include "hal-sensor-types.h"
-typedef std::vector<std::shared_ptr<sensor_device>> device_registry_t;
+typedef std::vector<uint64_t> 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<sensor_device *>(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 { \
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);
}
}
#ifndef __HAL_SENSOR_INTERFACE_1__
#define __HAL_SENSOR_INTERFACE_1__
+#include <stdint.h>
+
#include <hal/hal-common-interface.h>
#include "hal-sensor-types.h"
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
#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__ */
#ifndef __HAL_SENSOR__
#define __HAL_SENSOR__
-#include "hal-sensor-types.h"
+#include <stdint.h>
+
+#include "hal-sensor-interface.h"
#ifdef __cplusplus
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
}
* limitations under the License.
*/
#include <stdlib.h>
+#include <stdint.h>
+#include <inttypes.h>
#include <vector>
#include <dlfcn.h>
#include <hal/hal-common.h>
-#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
HAL_SENSOR_INIT_SUCCESS = 1,
} static hal_initialized = HAL_SENSOR_INIT_NOT_INITIALIZED;
-static std::vector<sensor_device_t> hal_backend_devs;
+static size_t g_created_sensor_count = 0;
+static std::vector<std::vector<sensor_device_s*>> 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<sensor_device_s *>());
+
+ 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<uint64_t> 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)
{
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]);
}
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);
}
projects / platform / hal / api / sensor.git / commitdiff