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));
#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();
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;
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));
#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();
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;
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));
#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();
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;
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));
#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();
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;
#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,
};
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));
#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();
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;
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));
#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();
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;
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));
#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();
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;
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));
#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 {
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;
--- /dev/null
+/*
+ * 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; }
+};
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);
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);
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);
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;
+ int int_length = 0;
sensorhub_sensor *sensor = manager->get_sensor(id);
if (!sensor) {
return -EINVAL;
}
- remains = sensor->get_data(data, length);
+ remains = sensor->get_data(data, &int_length);
+ if (remains != 0)
+ return remains;
+ if (int_length < 0)
+ return -EINVAL;
+
+ *length = int_length;
return remains;
}
#define _SENSORHUB_DEVICE_H_
#include <vector>
+
#include <hal/hal-sensor-types.h>
+#include "sensor_device.h"
#include "sensorhub_controller.h"
#include "sensorhub_manager.h"
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);
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);
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));
#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();
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;
projects / platform / hal / backend / emulator / sensor-emulator.git / commitdiff