Change C++ class to C structure of functions for sensor devices

The hal interface between backend and api is changed to use C functions
rather than giving C++ object directly.
To accomplish that, codes are changed as below:
 * Functions for api calls are added
 * Device id is added to distinguish between the target sensor devices.
   Device id is required since it is hard to know which device should be
   used for a random api call.

Change-Id: Iaf474e4a7dfcb596995d95fb3bd96a25444d7c34
Signed-off-by: SangYoun Kwak <sy.kwak@samsung.com>

diff --git a/src/accel/accel_device.cpp b/src/accel/accel_device.cpp
index efb9018690bfe4f06b3a1d65d1c4bfc6a657bb9e..91f9515397c94996da1f14a66000393383b2ca58 100755 (executable)
--- a/src/accel/accel_device.cpp
+++ b/src/accel/accel_device.cpp
@@ -318,7 +318,7 @@ int accel_device::read_fd(uint32_t **ids)
        return event_ids.size();
 }
 
-int accel_device::get_data(uint32_t id, sensor_data_t **data, int *length)
+int accel_device::get_data(uint32_t id, sensor_data_t **data, size_t *length)
 {
        sensor_data_t *sensor_data;
        sensor_data = (sensor_data_t *)malloc(sizeof(sensor_data_t));

diff --git a/src/accel/accel_device.h b/src/accel/accel_device.h
index 099ee6325955347c267dd4a61c798d09f774be43..f440b0cfb3f6323b317965bcfd7aab35e9a8a8aa 100644 (file)
--- a/src/accel/accel_device.h
+++ b/src/accel/accel_device.h
@@ -18,11 +18,14 @@
 #ifndef _ACCEL_DEVICE_H_
 #define _ACCEL_DEVICE_H_
 
-#include <hal/hal-sensor-types.h>
 #include <string>
 #include <vector>
 #include <functional>
 
+#include <hal/hal-sensor-types.h>
+
+#include "sensor_device.h"
+
 class accel_device : public sensor_device {
 public:
        accel_device();
@@ -37,7 +40,7 @@ public:
        bool set_interval(uint32_t id, unsigned long val);
 
        int read_fd(uint32_t **ids);
-       int get_data(uint32_t id, sensor_data_t **data, int *length);
+       int get_data(uint32_t id, sensor_data_t **data, size_t *length);
 
 private:
        int m_node_handle;

diff --git a/src/geomag/geomag_device.cpp b/src/geomag/geomag_device.cpp
index 0bbdcbbdef1ca35c52db6ce64a6040663c7e9b4e..1a827b8856b1cb4100df9c809c5fefad564ea435 100755 (executable)
--- a/src/geomag/geomag_device.cpp
+++ b/src/geomag/geomag_device.cpp
@@ -321,7 +321,7 @@ int geomag_device::read_fd(uint32_t **ids)
        return event_ids.size();
 }
 
-int geomag_device::get_data(uint32_t id, sensor_data_t **data, int *length)
+int geomag_device::get_data(uint32_t id, sensor_data_t **data, size_t *length)
 {
        sensor_data_t *sensor_data;
        sensor_data = (sensor_data_t *)malloc(sizeof(sensor_data_t));

diff --git a/src/geomag/geomag_device.h b/src/geomag/geomag_device.h
index 36ea2bf1e57ffe5c02d42f4cafdc8754bc13a251..e84cb50d3525eb390f42eb413f5c0a695c656737 100644 (file)
--- a/src/geomag/geomag_device.h
+++ b/src/geomag/geomag_device.h
@@ -18,11 +18,14 @@
 #ifndef _GEOMAG_DEVICE_H_
 #define _GEOMAG_DEVICE_H_
 
-#include <hal/hal-sensor-types.h>
 #include <string>
 #include <vector>
 #include <functional>
 
+#include <hal/hal-sensor-types.h>
+
+#include "sensor_device.h"
+
 class geomag_device : public sensor_device {
 public:
        geomag_device();
@@ -37,7 +40,7 @@ public:
        bool set_interval(uint32_t id, unsigned long val);
 
        int read_fd(uint32_t **ids);
-       int get_data(uint32_t id, sensor_data_t **data, int *length);
+       int get_data(uint32_t id, sensor_data_t **data, size_t *length);
 
 private:
        int m_node_handle;

diff --git a/src/gyro/gyro_device.cpp b/src/gyro/gyro_device.cpp
index 46f87d236dc0ce1273236b6458a9c1aa3811071d..f30e5d57c96b38fcda3f6a03e02375c5ca35f6ba 100755 (executable)
--- a/src/gyro/gyro_device.cpp
+++ b/src/gyro/gyro_device.cpp
@@ -315,7 +315,7 @@ int gyro_device::read_fd(uint32_t **ids)
        return event_ids.size();
 }
 
-int gyro_device::get_data(uint32_t id, sensor_data_t **data, int *length)
+int gyro_device::get_data(uint32_t id, sensor_data_t **data, size_t *length)
 {
        sensor_data_t *sensor_data;
        sensor_data = (sensor_data_t *)malloc(sizeof(sensor_data_t));

diff --git a/src/gyro/gyro_device.h b/src/gyro/gyro_device.h
index 2f90a9c7c3fa756032843742d4607cd3079dedd0..68f9e5a48e1622870b00da1a1cbf6f045ecee0df 100644 (file)
--- a/src/gyro/gyro_device.h
+++ b/src/gyro/gyro_device.h
@@ -18,11 +18,14 @@
 #ifndef _GYRO_DEVICE_H_
 #define _GYRO_DEVICE_H_
 
-#include <hal/hal-sensor-types.h>
 #include <string>
 #include <vector>
 #include <functional>
 
+#include <hal/hal-sensor-types.h>
+
+#include "sensor_device.h"
+
 class gyro_device : public sensor_device {
 public:
        gyro_device();
@@ -36,7 +39,7 @@ public:
 
        bool set_interval(uint32_t id, unsigned long val);
        int read_fd(uint32_t **ids);
-       int get_data(uint32_t id, sensor_data_t **data, int *length);
+       int get_data(uint32_t id, sensor_data_t **data, size_t *length);
 
 private:
        int m_node_handle;

diff --git a/src/gyro_uncal/gyro_uncal_device.cpp b/src/gyro_uncal/gyro_uncal_device.cpp
index e33c269a44719e192ac30272ceafe1163589ffe3..cc1c79433fc492bdaea5ce7296a65360766dd0de 100755 (executable)
--- a/src/gyro_uncal/gyro_uncal_device.cpp
+++ b/src/gyro_uncal/gyro_uncal_device.cpp
@@ -274,7 +274,7 @@ int gyro_uncal_device::read_fd(uint32_t **ids)
        return event_ids.size();
 }
 
-int gyro_uncal_device::get_data(uint32_t id, sensor_data_t **data, int *length)
+int gyro_uncal_device::get_data(uint32_t id, sensor_data_t **data, size_t *length)
 {
        sensor_data_t *sensor_data;
        sensor_data = (sensor_data_t *)malloc(sizeof(sensor_data_t));

diff --git a/src/gyro_uncal/gyro_uncal_device.h b/src/gyro_uncal/gyro_uncal_device.h
index 0438df44bb999fd7d594dff0393363295182734e..f5f7214e1df972077b18a652f22b4fe9378207a8 100644 (file)
--- a/src/gyro_uncal/gyro_uncal_device.h
+++ b/src/gyro_uncal/gyro_uncal_device.h
@@ -18,11 +18,14 @@
 #ifndef _GYRO_UNCAL_DEVICE_H_
 #define _GYRO_UNCAL_DEVICE_H_
 
-#include <hal/hal-sensor-types.h>
 #include <string>
 #include <vector>
 #include <functional>
 
+#include <hal/hal-sensor-types.h>
+
+#include "sensor_device.h"
+
 class gyro_uncal_device : public sensor_device {
 public:
        gyro_uncal_device();
@@ -37,7 +40,7 @@ public:
        bool set_interval(uint32_t id, unsigned long val);
 
        int read_fd(uint32_t **ids);
-       int get_data(uint32_t id, sensor_data_t **data, int *length);
+       int get_data(uint32_t id, sensor_data_t **data, size_t *length);
 
 private:
        int m_node_handle;

diff --git a/src/hal-backend-sensor.cpp b/src/hal-backend-sensor.cpp
index 2a721a2a25f9b439736eedcf90dc9c37ff0146bc..de891e21754dce88ce05635a997a5a29bfcfe350 100644 (file)
--- a/src/hal-backend-sensor.cpp
+++ b/src/hal-backend-sensor.cpp
@@ -31,68 +31,258 @@
 #include "ultraviolet/uv_device.h"
 #include "sensorhub/sensorhub.h"
 
-static std::vector<sensor_device_t> devs;
+static std::vector<sensor_device *> sensor_device_list;
+static std::vector<sensor_device_s *> sensor_device_funcs_list;
+
+#define RET_IF_INVALID_DEVICE(DEVICE_ID) \
+do {\
+       if (sensor_device_list.size() <= (DEVICE_ID)) \
+               return -EINVAL; \
+       if (sensor_device_list[DEVICE_ID] == nullptr) \
+               return -ENODEV; \
+} while (0)
+
+static int sensor_emulator_get_poll_fd(uint32_t sensor_device_id, int *poll_fd)
+{
+       RET_IF_INVALID_DEVICE(sensor_device_id);
+
+       int fd = sensor_device_list[sensor_device_id]->get_poll_fd();
+       if (fd < 0)
+               return -EINVAL;
+
+       *poll_fd = fd;
+
+       return 0;
+}
+
+static int sensor_emulator_get_sensors(uint32_t sensor_device_id, const sensor_info_t **sensors, size_t *sensors_len)
+{
+       RET_IF_INVALID_DEVICE(sensor_device_id);
+
+       int ret = sensor_device_list[sensor_device_id]->get_sensors(sensors);
+       if (ret < 0)
+               return ret;
+
+       *sensors_len = ret;
+
+       return 0;
+}
+
+static int sensor_emulator_enable(uint32_t sensor_device_id, uint32_t id)
+{
+       RET_IF_INVALID_DEVICE(sensor_device_id);
+
+       return sensor_device_list[sensor_device_id]->enable(id) ? 0 : -EINVAL;
+}
+
+static int sensor_emulator_disable(uint32_t sensor_device_id, uint32_t id)
+{
+       RET_IF_INVALID_DEVICE(sensor_device_id);
+
+       return sensor_device_list[sensor_device_id]->disable(id) ? 0 : -EINVAL;
+}
+
+static int sensor_emulator_read_fd(uint32_t sensor_device_id, uint32_t **ids, size_t *ids_len)
+{
+       RET_IF_INVALID_DEVICE(sensor_device_id);
+
+       int ret = sensor_device_list[sensor_device_id]->read_fd(ids);
+       if (ret < 0)
+               return ret;
+
+       *ids_len = ret;
+
+       return 0;
+}
+
+static int sensor_emulator_get_data(uint32_t sensor_device_id, uint32_t id, sensor_data_t **data, size_t *length)
+{
+       RET_IF_INVALID_DEVICE(sensor_device_id);
+
+       return sensor_device_list[sensor_device_id]->get_data(id, data, length);
+}
+
+static int sensor_emulator_set_interval(uint32_t sensor_device_id, uint32_t id, unsigned long val)
+{
+       RET_IF_INVALID_DEVICE(sensor_device_id);
+
+       return sensor_device_list[sensor_device_id]->set_interval(id, val) ? 0 : -EINVAL;
+}
+
+static int sensor_emulator_set_batch_latency(uint32_t sensor_device_id, uint32_t id, unsigned long val)
+{
+       RET_IF_INVALID_DEVICE(sensor_device_id);
+
+       return sensor_device_list[sensor_device_id]->set_batch_latency(id, val) ? 0 : -EINVAL;
+}
+
+static int sensor_emulator_set_attribute_int(uint32_t sensor_device_id, uint32_t id, int32_t attribute, int32_t value)
+{
+       RET_IF_INVALID_DEVICE(sensor_device_id);
+
+       return sensor_device_list[sensor_device_id]->set_attribute_int(id, attribute, value) ? 0 : -EINVAL;
+}
+
+static int sensor_emulator_set_attribute_str(uint32_t sensor_device_id, uint32_t id, int32_t attribute, const char *value, size_t len)
+{
+       RET_IF_INVALID_DEVICE(sensor_device_id);
+
+       return sensor_device_list[sensor_device_id]->set_attribute_str(id, attribute, value, len) ? 0 : -EINVAL;
+}
+
+static int sensor_emulator_get_attribute_int(uint32_t sensor_device_id, uint32_t id, int32_t attribute, int32_t *value)
+{
+       RET_IF_INVALID_DEVICE(sensor_device_id);
+
+       return sensor_device_list[sensor_device_id]->get_attribute_int(id, attribute, value) ? 0 : -EINVAL;
+}
+
+static int sensor_emulator_get_attribute_str(uint32_t sensor_device_id, uint32_t id, int32_t attribute, char **value, size_t *len)
+{
+       RET_IF_INVALID_DEVICE(sensor_device_id);
+
+       return sensor_device_list[sensor_device_id]->get_attribute_str(id, attribute, value, len) ? 0 : -EINVAL;
+}
+
+static int sensor_emulator_flush(uint32_t sensor_device_id, uint32_t id)
+{
+       RET_IF_INVALID_DEVICE(sensor_device_id);
+
+       return sensor_device_list[sensor_device_id]->flush(id) ? 0 : -EINVAL;
+}
+
+int create_sensor_device_funcs(sensor_device_s **sensor_device_funcs)
+{
+       sensor_device_s *funcs = (sensor_device_s *)malloc(sizeof(*funcs));
+       if (funcs == nullptr)
+               return -ENOMEM;
+
+       funcs->get_poll_fd = sensor_emulator_get_poll_fd;
+       funcs->get_sensors = sensor_emulator_get_sensors;
+       funcs->enable = sensor_emulator_enable;
+       funcs->disable = sensor_emulator_disable;
+       funcs->read_fd = sensor_emulator_read_fd;
+       funcs->get_data = sensor_emulator_get_data;
+       funcs->set_interval = sensor_emulator_set_interval;
+       funcs->set_batch_latency = sensor_emulator_set_batch_latency;
+       funcs->set_attribute_int = sensor_emulator_set_attribute_int;
+       funcs->set_attribute_str = sensor_emulator_set_attribute_str;
+       funcs->get_attribute_int = sensor_emulator_get_attribute_int;
+       funcs->get_attribute_str = sensor_emulator_get_attribute_str;
+       funcs->flush = sensor_emulator_flush;
+
+       *sensor_device_funcs = funcs;
+
+       return 0;
+}
 
 template <typename _sensor>
 void create_sensor(const char *name) {
-  sensor_device *instance = NULL;
-  try {
-    instance = new _sensor;
-  } catch (std::exception &e) {
-    ERR("Failed to create %s sensor device, exception: %s", name, e.what());
-    return;
-  } catch (int err) {
-    _ERRNO(err, _E, "Failed to create %s sensor device", name);
-    return;
-  }
-
-  devs.push_back(instance);
-}
-
-static int sensor_emulator_create(sensor_device_t **devices) {
-  create_sensor<accel_device>("Accelerometer");
-  create_sensor<gyro_device>("Gyroscope");
-  create_sensor<geomag_device>("Geomagnetic");
-  create_sensor<pressure_device>("Pressure");
-  create_sensor<uv_device>("Ultra Violet");
-  create_sensor<light_device>("Light");
-  create_sensor<proxi_device>("Proximity");
-  create_sensor<hrm_device>("HRM");
-  create_sensor<sensorhub_device>("Sensorhub");
-
-  *devices = &devs[0];
-  return devs.size();
+       int ret = 0;
+       sensor_device *instance = nullptr;
+       sensor_device_s *funcs = nullptr;
+
+       try {
+               instance = new _sensor;
+       } catch (std::exception &e) {
+               ERR("Failed to create %s sensor device, exception: %s", name, e.what());
+               return;
+       } catch (int err) {
+               _ERRNO(err, _E, "Failed to create %s sensor device", name);
+               return;
+       }
+
+       ret = create_sensor_device_funcs(&funcs);
+       if (ret != 0) {
+               ERR("Failed to create sensor_device_s: ret(%d)", ret);
+               delete instance;
+               return;
+       }
+
+       sensor_device_funcs_list.push_back(funcs);
+       sensor_device_list.push_back(instance);
 }
 
+static int sensor_emulator_create(sensor_device_s ***sensor_devices, size_t *sensor_devices_len) {
+       create_sensor<accel_device>("Accelerometer");
+       create_sensor<gyro_device>("Gyroscope");
+       create_sensor<geomag_device>("Geomagnetic");
+       create_sensor<pressure_device>("Pressure");
+       create_sensor<uv_device>("Ultra Violet");
+       create_sensor<light_device>("Light");
+       create_sensor<proxi_device>("Proximity");
+       create_sensor<hrm_device>("HRM");
+       create_sensor<sensorhub_device>("Sensorhub");
+
+       if (sensor_device_funcs_list.size() == 0) {
+               ERR("Failed to create any sensor device(0 sensor created)");
+               return -ENOENT;
+       }
+
+       *sensor_devices = &sensor_device_funcs_list[0];
+       *sensor_devices_len = sensor_device_funcs_list.size();
+
+       return 0;
+}
+
+static int sensor_emulator_delete(uint32_t *sensor_device_ids, size_t sensor_device_ids_len)
+{
+       size_t failed_count = 0;
+       uint32_t sensor_device_id = 0;
+
+       for (size_t i = 0; i < sensor_device_ids_len; ++i) {
+               sensor_device_id = sensor_device_ids[i];
+
+               if (sensor_device_list.size() <= sensor_device_id ||
+                               sensor_device_list[sensor_device_id] == nullptr) {
+                       ++failed_count;
+                       continue;
+               }
+
+               delete sensor_device_list[sensor_device_id];
+               sensor_device_list[sensor_device_id] = nullptr;
+
+               free(sensor_device_funcs_list[sensor_device_id]);
+               sensor_device_funcs_list[sensor_device_id] = nullptr;
+       }
+
+       if (failed_count != 0)
+               return -EINVAL;
+
+       return 0;
+}
+
+
 static int sensor_emulator_init(void **data) {
-  _I("init hal backend sensor");
-  hal_backend_sensor_funcs *funcs = NULL;
+       _I("init hal backend sensor");
+       hal_backend_sensor_funcs *funcs = nullptr;
 
-  if (!data) {
-    _E("Invalid parameter");
-    return -EINVAL;
-  }
+       if (!data) {
+               _E("Invalid parameter");
+               return -EINVAL;
+       }
 
-  funcs = *((hal_backend_sensor_funcs **)data);
-  if (!funcs) {
-    _E("Invalid parameter");
-    return -EINVAL;
-  }
+       funcs = *((hal_backend_sensor_funcs **)data);
+       if (!funcs) {
+               _E("Invalid parameter");
+               return -EINVAL;
+       }
 
-  funcs->create = sensor_emulator_create;
+       funcs->create_sensor = sensor_emulator_create;
+       funcs->delete_sensor = sensor_emulator_delete;
 
-  return 0;
+       return 0;
 }
 
 static int sensor_emulator_exit(void *data) {
-  return 0;
+       return 0;
 }
 
 extern "C" hal_backend hal_backend_sensor_data = {
-    .name = "sensor-emulator",
-    .vendor = "Tizen",
-    .init = sensor_emulator_init,
-    .exit = sensor_emulator_exit,
-    .major_version = 1,
-    .minor_version = 0,
+       .name = "sensor-emulator",
+       .vendor = "Tizen",
+       .init = sensor_emulator_init,
+       .exit = sensor_emulator_exit,
+       .major_version = 1,
+       .minor_version = 0,
 };

diff --git a/src/hrm/hrm_device.cpp b/src/hrm/hrm_device.cpp
index bad0be355458c50f56e7be86d2125b76f92276d3..557b7c3836dd3414fbaf46f178232087cf57452c 100755 (executable)
--- a/src/hrm/hrm_device.cpp
+++ b/src/hrm/hrm_device.cpp
@@ -253,7 +253,7 @@ int hrm_device::read_fd(uint32_t **ids)
        return event_ids.size();
 }
 
-int hrm_device::get_data(uint32_t id, sensor_data_t **data, int *length)
+int hrm_device::get_data(uint32_t id, sensor_data_t **data, size_t *length)
 {
        sensor_data_t *sensor_data;
        sensor_data = (sensor_data_t *)malloc(sizeof(sensor_data_t));

diff --git a/src/hrm/hrm_device.h b/src/hrm/hrm_device.h
index 090882d44ac4d68e3dd480c92e411b7d2e5cd86d..e277e75030010763c43e713b48b00538fb357ae3 100644 (file)
--- a/src/hrm/hrm_device.h
+++ b/src/hrm/hrm_device.h
@@ -18,11 +18,14 @@
 #ifndef _HRM_DEVICE_H_
 #define _HRM_DEVICE_H_
 
-#include <hal/hal-sensor-types.h>
 #include <string>
 #include <vector>
 #include <functional>
 
+#include <hal/hal-sensor-types.h>
+
+#include "sensor_device.h"
+
 class hrm_device : public sensor_device {
 public:
        hrm_device();
@@ -37,7 +40,7 @@ public:
        bool set_interval(uint32_t id, unsigned long val);
 
        int read_fd(uint32_t **ids);
-       int get_data(uint32_t id, sensor_data_t **data, int *length);
+       int get_data(uint32_t id, sensor_data_t **data, size_t *length);
 
 private:
        int m_node_handle;

diff --git a/src/light/light_device.cpp b/src/light/light_device.cpp
index 852e3537fa15398255dcedd4beff9dc585291566..503a9e63ca5eaaaba540f5e78bd3c48e00e16a14 100755 (executable)
--- a/src/light/light_device.cpp
+++ b/src/light/light_device.cpp
@@ -215,7 +215,7 @@ int light_device::read_fd(uint32_t **ids)
        return event_ids.size();
 }
 
-int light_device::get_data(uint32_t id, sensor_data_t **data, int *length)
+int light_device::get_data(uint32_t id, sensor_data_t **data, size_t *length)
 {
        sensor_data_t *sensor_data;
        sensor_data = (sensor_data_t *)malloc(sizeof(sensor_data_t));

diff --git a/src/light/light_device.h b/src/light/light_device.h
index c9d9febb892412cff2ebea7423e695f4cfe1da63..6fba3ac6b13c990289ebd97cb93a4e112072b441 100644 (file)
--- a/src/light/light_device.h
+++ b/src/light/light_device.h
@@ -18,11 +18,14 @@
 #ifndef _LIGHT_DEVICE_H_
 #define _LIGHT_DEVICE_H_
 
-#include <hal/hal-sensor-types.h>
 #include <string>
 #include <vector>
 #include <functional>
 
+#include <hal/hal-sensor-types.h>
+
+#include "sensor_device.h"
+
 class light_device : public sensor_device {
 public:
        light_device();
@@ -37,7 +40,7 @@ public:
        bool set_interval(uint32_t id, unsigned long val);
 
        int read_fd(uint32_t **ids);
-       int get_data(uint32_t id, sensor_data_t **data, int *length);
+       int get_data(uint32_t id, sensor_data_t **data, size_t *length);
 
 private:
        int m_node_handle;

diff --git a/src/pressure/pressure_device.cpp b/src/pressure/pressure_device.cpp
index c314db63314569f5dcc857ac9c32b215e03366a7..ef1b56f413c07939d76e5ebf8e6eefd634004414 100755 (executable)
--- a/src/pressure/pressure_device.cpp
+++ b/src/pressure/pressure_device.cpp
@@ -256,7 +256,7 @@ int pressure_device::read_fd(uint32_t **ids)
        return event_ids.size();
 }
 
-int pressure_device::get_data(uint32_t id, sensor_data_t **data, int *length)
+int pressure_device::get_data(uint32_t id, sensor_data_t **data, size_t *length)
 {
        sensor_data_t *sensor_data;
        sensor_data = (sensor_data_t *)malloc(sizeof(sensor_data_t));

diff --git a/src/pressure/pressure_device.h b/src/pressure/pressure_device.h
index 13235903c172d2ad78945c39aafdb63e3368ba8d..0c1e047bd49274cd35a54a775fe6a224f528425a 100644 (file)
--- a/src/pressure/pressure_device.h
+++ b/src/pressure/pressure_device.h
@@ -18,11 +18,14 @@
 #ifndef _PRESSURE_DEVICE_H_
 #define _PRESSURE_DEVICE_H_
 
-#include <hal/hal-sensor-types.h>
 #include <string>
 #include <vector>
 #include <functional>
 
+#include <hal/hal-sensor-types.h>
+
+#include "sensor_device.h"
+
 class pressure_device : public sensor_device {
 public:
        pressure_device();
@@ -37,7 +40,7 @@ public:
        bool set_interval(uint32_t id, unsigned long val);
 
        int read_fd(uint32_t **ids);
-       int get_data(uint32_t id, sensor_data_t **data, int *length);
+       int get_data(uint32_t id, sensor_data_t **data, size_t *length);
 
 private:
        int m_node_handle;

diff --git a/src/proxi/proxi_device.cpp b/src/proxi/proxi_device.cpp
index 72936b9d6caa08f29a90a64184c51d35c5812567..8cdca9b284545765f45c92aff81554f23c6f73e0 100644 (file)
--- a/src/proxi/proxi_device.cpp
+++ b/src/proxi/proxi_device.cpp
@@ -189,7 +189,7 @@ int proxi_device::read_fd(uint32_t **ids)
        return event_ids.size();
 }
 
-int proxi_device::get_data(uint32_t id, sensor_data_t **data, int *length)
+int proxi_device::get_data(uint32_t id, sensor_data_t **data, size_t *length)
 {
        sensor_data_t *sensor_data;
        sensor_data = (sensor_data_t *)malloc(sizeof(sensor_data_t));

diff --git a/src/proxi/proxi_device.h b/src/proxi/proxi_device.h
index ba57a080dc9d2cd17f7aa3d7b98c34e81fac8ff6..f8676932944acd6f3b9d9d1ac05d1242ba4be5a7 100644 (file)
--- a/src/proxi/proxi_device.h
+++ b/src/proxi/proxi_device.h
@@ -18,11 +18,14 @@
 #ifndef _PROXI_DEVICE_H_
 #define _PROXI_DEVICE_H_
 
-#include <hal/hal-sensor-types.h>
 #include <string>
 #include <vector>
 #include <functional>
 
+#include <hal/hal-sensor-types.h>
+
+#include "sensor_device.h"
+
 class proxi_device : public sensor_device {
 public:
        enum proxi_node_state_event_t {
@@ -41,7 +44,7 @@ public:
        bool disable(uint32_t id);
 
        int read_fd(uint32_t **ids);
-       int get_data(uint32_t id, sensor_data_t **data, int *length);
+       int get_data(uint32_t id, sensor_data_t **data, size_t *length);
 
 private:
        int m_node_handle;

diff --git a/src/sensor_device.h b/src/sensor_device.h
new file mode 100644 (file)
index 0000000..4a77811
--- /dev/null
+++ b/src/sensor_device.h
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2025 Samsung Electronics Co., Ltd.
+ *
+ * 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.
+ */
+
+#pragma once
+
+class sensor_device {
+ public:
+  virtual ~sensor_device() {}
+
+  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, size_t *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,
+                                 size_t 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,
+                                 size_t *len) {
+    return true;
+  }
+
+  virtual bool flush(uint32_t id) { return true; }
+};

diff --git a/src/sensorhub/pedometer.cpp b/src/sensorhub/pedometer.cpp
index ff0340c0222448d41e0be8d838fc242e47545a2c..5164dfc7714fbc2c9915bf342d0a043c9890e5bf 100644 (file)
--- a/src/sensorhub/pedometer.cpp
+++ b/src/sensorhub/pedometer.cpp
@@ -163,7 +163,7 @@ public:
        bool disable(void);
 
        int parse(const char *data, int data_len);
-       int get_data(sensor_data_t **data, int *length);
+       int get_data(sensor_data_t **data, size_t *length);
 
        bool set_attribute_int(int32_t attribute, int32_t value);
        bool set_attribute_str(int32_t key, char *value, int len);
@@ -421,7 +421,7 @@ int sh_pedometer_sensor::parse_scale_factor(const char *data, int data_len, int
        return PAYLOAD_SFACTOR;
 }
 
-int sh_pedometer_sensor::get_data(sensor_data_t **data, int *length)
+int sh_pedometer_sensor::get_data(sensor_data_t **data, size_t *length)
 {
        *data = m_data;
        *length = m_is_sfactor ? sizeof(sensorhub_data_t) : sizeof(sensor_pedometer_data_t);

diff --git a/src/sensorhub/sensorhub.cpp b/src/sensorhub/sensorhub.cpp
index 130e46f9177bd88866aaf5a994b458391fe9c915..2a7bf4a53dbcb1e8af00999d9c19b6a2569aecec 100644 (file)
--- a/src/sensorhub/sensorhub.cpp
+++ b/src/sensorhub/sensorhub.cpp
@@ -126,7 +126,7 @@ bool sensorhub_device::set_attribute_int(uint32_t id, int32_t attribute, int32_t
        return sensor->set_attribute_int(attribute, value);
 }
 
-bool sensorhub_device::set_attribute_str(uint32_t id, int32_t attribute, char *value, int len)
+bool sensorhub_device::set_attribute_str(uint32_t id, int32_t attribute, char *value, size_t len)
 {
        sensorhub_sensor *sensor = manager->get_sensor(id);
 
@@ -177,7 +177,7 @@ int sensorhub_device::read_fd(uint32_t **ids)
        return size;
 }
 
-int sensorhub_device::get_data(uint32_t id, sensor_data_t **data, int *length)
+int sensorhub_device::get_data(uint32_t id, sensor_data_t **data, size_t *length)
 {
        int remains = 1;
 

diff --git a/src/sensorhub/sensorhub.h b/src/sensorhub/sensorhub.h
index 98c57841956702661533756b466c62d500efd401..e3341459c6bc45e12e2854b9f80200b1accc5d27 100644 (file)
--- a/src/sensorhub/sensorhub.h
+++ b/src/sensorhub/sensorhub.h
@@ -19,8 +19,10 @@
 #define _SENSORHUB_DEVICE_H_
 
 #include <vector>
+
 #include <hal/hal-sensor-types.h>
 
+#include "sensor_device.h"
 #include "sensorhub_controller.h"
 #include "sensorhub_manager.h"
 
@@ -38,10 +40,10 @@ public:
        bool set_interval(uint32_t id, unsigned long val);
        bool set_batch_latency(uint32_t id, unsigned long val);
        bool set_attribute_int(uint32_t id, int32_t attribute, int32_t value);
-       bool set_attribute_str(uint32_t id, int32_t attribute, char *value, int len);
+       bool set_attribute_str(uint32_t id, int32_t attribute, char *value, size_t len);
 
        int read_fd(uint32_t **ids);
-       int get_data(uint32_t id, sensor_data_t **data, int *length);
+       int get_data(uint32_t id, sensor_data_t **data, size_t *length);
 
        bool flush(uint32_t id);
 

diff --git a/src/sensorhub/sensorhub_sensor.h b/src/sensorhub/sensorhub_sensor.h
index d5e9da47d17c28c5f25d465decf6cefc4d219865..3feafc350cc9b585a02a9a02efa751c7fc62f95d 100644 (file)
--- a/src/sensorhub/sensorhub_sensor.h
+++ b/src/sensorhub/sensorhub_sensor.h
@@ -59,7 +59,7 @@ public:
        virtual bool enable(void);
        virtual bool disable(void);
        virtual int parse(const char *hub_data, int data_len) = 0;
-       virtual int get_data(sensor_data_t **data, int *length) = 0;
+       virtual int get_data(sensor_data_t **data, size_t *length) = 0;
 
        void set_controller(sensorhub_controller *controller);
 

diff --git a/src/ultraviolet/uv_device.cpp b/src/ultraviolet/uv_device.cpp
index 0096498be65d9e8fb6ef8892047d9b7247e10bdd..34a2383fc062260f8d90ef2fb8d70eee22903d85 100755 (executable)
--- a/src/ultraviolet/uv_device.cpp
+++ b/src/ultraviolet/uv_device.cpp
@@ -226,7 +226,7 @@ int uv_device::read_fd(uint32_t **ids)
        return event_ids.size();
 }
 
-int uv_device::get_data(uint32_t id, sensor_data_t **data, int *length)
+int uv_device::get_data(uint32_t id, sensor_data_t **data, size_t *length)
 {
        sensor_data_t *sensor_data;
        sensor_data = (sensor_data_t *)malloc(sizeof(sensor_data_t));

diff --git a/src/ultraviolet/uv_device.h b/src/ultraviolet/uv_device.h
index 06ea4cf02507364afadefc6fbd451f4a23865c40..320f11a3aac9e226395429c948c2041b4b7b9f40 100644 (file)
--- a/src/ultraviolet/uv_device.h
+++ b/src/ultraviolet/uv_device.h
@@ -18,11 +18,14 @@
 #ifndef _UV_DEVICE_H_
 #define _UV_DEVICE_H_
 
-#include <hal/hal-sensor-types.h>
 #include <string>
 #include <vector>
 #include <functional>
 
+#include <hal/hal-sensor-types.h>
+
+#include "sensor_device.h"
+
 class uv_device : public sensor_device {
 public:
        uv_device();
@@ -37,7 +40,7 @@ public:
        bool set_interval(uint32_t id, unsigned long val);
 
        int read_fd(uint32_t **ids);
-       int get_data(uint32_t id, sensor_data_t **data, int *length);
+       int get_data(uint32_t id, sensor_data_t **data, size_t *length);
 
 private:
        int m_node_handle;