INCLUDE_DIRECTORIES(
${CMAKE_CURRENT_SOURCE_DIR}/src/
${CMAKE_CURRENT_SOURCE_DIR}/src/shared
+ ${CMAKE_CURRENT_SOURCE_DIR}/src/hal
)
# Sub-directory
ADD_SUBDIRECTORY(src/server)
ADD_SUBDIRECTORY(src/client)
ADD_SUBDIRECTORY(src/shared)
+ADD_SUBDIRECTORY(src/hal)
IF("${TEST_SUITE}" STREQUAL "ON")
ADD_SUBDIRECTORY(test)
%description -n libsensord-devel
Sensord shared library
+%package -n sensor-hal-devel
+Summary: Sensord HAL interface
+Group: System/Development
+
+%description -n sensor-hal-devel
+Sensord HAL interface
+
%if %{build_test_suite} == "ON"
%package -n sensor-test
Summary: Sensord library
%{_libdir}/pkgconfig/sensor.pc
%license LICENSE.APLv2
+%files -n sensor-hal-devel
+%defattr(-,root,root,-)
+%{_includedir}/sensor/sensor_hal.h
+%license LICENSE.APLv2
+
%if %{build_test_suite} == "ON"
%files -n sensor-test
%defattr(-,root,root,-)
#define MIN_DELIVERY_DIFF_FACTOR 0.75f
/* TODO: this macro should be adjusted */
-#define EVENT_BUFFER_SIZE sizeof(sensorhub_event_t)
+#define EVENT_BUFFER_SIZE 4224
using std::thread;
using std::pair;
int accuracy = SENSOR_ACCURACY_GOOD;
unsigned int event_type = *((unsigned int *)(event));
- bool is_hub_event = is_sensorhub_event(event_type);
client_callback_info* callback_info = NULL;
vector<client_callback_info *> client_callback_infos;
- if (is_hub_event) {
- sensorhub_event_t *sensor_hub_event = (sensorhub_event_t *)event;
- sensor_id = sensor_hub_event->sensor_id;
- sensor_data = &(sensor_hub_event->data);
- cur_time = sensor_hub_event->data.timestamp;
-
- event_data.event_data = &(sensor_hub_event->data);
- event_data.event_data_size = sizeof(sensor_hub_event->data);
+ sensor_event_t *sensor_event = (sensor_event_t *)event;
+ sensor_id = sensor_event->sensor_id;
+ sensor_event->data = (sensor_data_t *)((char *)sensor_event + sizeof(sensor_event_t));
+ sensor_data = sensor_event->data;
+ cur_time = sensor_event->data->timestamp;
+ accuracy = sensor_event->data->accuracy;
+
+ if (is_single_state_event(event_type)) {
+ single_state_event_data = (int) sensor_event->data->values[0];
+ event_data.event_data = (void *)&(single_state_event_data);
+ event_data.event_data_size = sizeof(single_state_event_data);
+ } else if (is_panning_event(event_type)) {
+ panning_data.x = (int)sensor_event->data->values[0];
+ panning_data.y = (int)sensor_event->data->values[1];
+ event_data.event_data = (void *)&panning_data;
+ event_data.event_data_size = sizeof(panning_data);
} else {
- sensor_event_t *sensor_event = (sensor_event_t *)event;
- sensor_id = sensor_event->sensor_id;
- sensor_event->data = (sensor_data_t *)((char *)sensor_event + sizeof(sensor_event_t));
- sensor_data = sensor_event->data;
- cur_time = sensor_event->data->timestamp;
- accuracy = sensor_event->data->accuracy;
-
- if (is_single_state_event(event_type)) {
- single_state_event_data = (int) sensor_event->data->values[0];
- event_data.event_data = (void *)&(single_state_event_data);
- event_data.event_data_size = sizeof(single_state_event_data);
- } else if (is_panning_event(event_type)) {
- panning_data.x = (int)sensor_event->data->values[0];
- panning_data.y = (int)sensor_event->data->values[1];
- event_data.event_data = (void *)&panning_data;
- event_data.event_data_size = sizeof(panning_data);
- } else {
- event_data.event_data = &(sensor_event->data);
- event_data.event_data_size = sizeof(sensor_event->data);
- }
+ event_data.event_data = &(sensor_event->data);
+ event_data.event_data_size = sizeof(sensor_event->data);
}
{ /* scope for the lock */
callback_info->sensor_data = sensor_data;
callback_info->buffer = buffer;
- /*
- if (event_info->m_cb_type == SENSOR_EVENT_CB) {
- callback_info->sensor_data = new(std::nothrow) char[sizeof(sensor_data_t)];
-
- if (!callback_info->sensor_data) {
- ERR("Failed to allocate memory");
- delete callback_info;
- return NULL;
- }
-
- copy_sensor_data((sensor_data_t*) callback_info->sensor_data, (sensor_data_t*) sensor_data);
- } else if (event_info->m_cb_type == SENSORHUB_EVENT_CB) {
- callback_info->sensor_data = new(std::nothrow) char[sizeof(sensorhub_data_t)];
-
- if (!callback_info->sensor_data) {
- ERR("Failed to allocate memory");
- delete callback_info;
- return NULL;
- }
-
- copy_sensorhub_data((sensorhub_data_t*) callback_info->sensor_data, (sensorhub_data_t*) sensor_data);
- } else if(event_info->m_cb_type == SENSOR_LEGACY_CB) {
- sensor_event_data_t *dest_sensor_data;
- sensor_event_data_t *src_sensor_data = (sensor_event_data_t *)sensor_data;
- callback_info->sensor_data = new(std::nothrow) char[sizeof(sensor_event_data_t)];
-
- if (!callback_info->sensor_data) {
- ERR("Failed to allocate memory");
- delete callback_info;
- return NULL;
- }
-
- dest_sensor_data = (sensor_event_data_t *) callback_info->sensor_data;
- dest_sensor_data->event_data_size = src_sensor_data->event_data_size;
- dest_sensor_data->event_data = new(std::nothrow) char[src_sensor_data->event_data_size];
-
- if (!dest_sensor_data->event_data) {
- ERR("Failed to allocate memory");
- delete[] (char *)(callback_info->sensor_data);
- delete callback_info;
- return NULL;
- }
-
- if (is_sensorhub_event(event_info->type))
- copy_sensorhub_data((sensorhub_data_t*)dest_sensor_data->event_data, (sensorhub_data_t*)src_sensor_data->event_data);
- else
- memcpy(dest_sensor_data->event_data, src_sensor_data->event_data, src_sensor_data->event_data_size);
- }
- */
-
return callback_info;
}
--- /dev/null
+CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
+PROJECT(sensor-hal CXX)
+
+INSTALL(FILES sensor_hal.h DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/sensor/)
#define SENSORHUB_DATA_VALUE_SIZE 4096
-#if 0
/* sensorhub_data_t */
typedef struct sensorhub_data_t {
int accuracy;
int value_count;
char values[SENSORHUB_DATA_VALUE_SIZE];
} sensorhub_data_t;
-#endif
/*
* Create devices
INFO("Event Dispatcher started");
while (true) {
- bool is_hub_event = false;
void *seed_event = get_event_queue().pop();
unsigned int event_type = *((unsigned int *)(seed_event));
- if (is_sensorhub_event(event_type))
- is_hub_event = true;
+ vector<void *> sensor_events;
+ sensor_events.push_back(seed_event);
- if (is_hub_event) {
- sensorhub_event_t *sensorhub_event = (sensorhub_event_t *)seed_event;
- send_sensorhub_events(sensorhub_event);
- } else {
- vector<void *> sensor_events;
- sensor_events.push_back(seed_event);
+ virtual_sensors v_sensors = get_active_virtual_sensors();
- virtual_sensors v_sensors = get_active_virtual_sensors();
+ auto it_v_sensor = v_sensors.begin();
- auto it_v_sensor = v_sensors.begin();
+ while (it_v_sensor != v_sensors.end()) {
+ int synthesized_cnt;
+ v_sensor_events.clear();
+ (*it_v_sensor)->synthesize(*((sensor_event_t *)seed_event));
+ synthesized_cnt = v_sensor_events.size();
- while (it_v_sensor != v_sensors.end()) {
- int synthesized_cnt;
- v_sensor_events.clear();
- (*it_v_sensor)->synthesize(*((sensor_event_t *)seed_event));
- synthesized_cnt = v_sensor_events.size();
-
- for (int i = 0; i < synthesized_cnt; ++i) {
- sensor_event_t *v_event = (sensor_event_t*)malloc(sizeof(sensor_event_t));
- if (!v_event) {
- ERR("Failed to allocate memory");
- continue;
- }
-
- memcpy(v_event, &v_sensor_events[i], sizeof(sensor_event_t));
- sensor_events.push_back(v_event);
+ for (int i = 0; i < synthesized_cnt; ++i) {
+ sensor_event_t *v_event = (sensor_event_t*)malloc(sizeof(sensor_event_t));
+ if (!v_event) {
+ ERR("Failed to allocate memory");
+ continue;
}
- ++it_v_sensor;
+ memcpy(v_event, &v_sensor_events[i], sizeof(sensor_event_t));
+ sensor_events.push_back(v_event);
}
- sort_sensor_events(sensor_events);
+ ++it_v_sensor;
+ }
- for (unsigned int i = 0; i < sensor_events.size(); ++i) {
- if (is_record_event(((sensor_event_t *)(sensor_events[i]))->event_type))
- put_last_event(((sensor_event_t *)(sensor_events[i]))->event_type, *((sensor_event_t *)(sensor_events[i])));
- }
+ sort_sensor_events(sensor_events);
- send_sensor_events(sensor_events);
+ for (unsigned int i = 0; i < sensor_events.size(); ++i) {
+ if (is_record_event(((sensor_event_t *)(sensor_events[i]))->event_type))
+ put_last_event(((sensor_event_t *)(sensor_events[i]))->event_type, *((sensor_event_t *)(sensor_events[i])));
}
+
+ send_sensor_events(sensor_events);
}
}
}
}
-void sensor_event_dispatcher::send_sensorhub_events(void* events)
-{
- sensorhub_event_t *sensor_hub_events;
- client_info_manager& client_info_manager = get_client_info_manager();
-
- const int RESERVED_CLIENT_CNT = 20;
- static client_id_vec id_vec(RESERVED_CLIENT_CNT);
-
- sensor_hub_events = (sensorhub_event_t *)events;
-
- sensor_id_t sensor_id;
- unsigned int event_type;
-
- sensor_id = sensor_hub_events->sensor_id;
- event_type = sensor_hub_events->event_type;
-
- id_vec.clear();
- client_info_manager.get_listener_ids(sensor_id, event_type, id_vec);
-
- auto it_client_id = id_vec.begin();
-
- while (it_client_id != id_vec.end()) {
- csocket client_socket;
- client_info_manager.get_event_socket(*it_client_id, client_socket);
- bool ret = (client_socket.send(sensor_hub_events, sizeof(sensorhub_event_t)) > 0);
-
- if (ret)
- DBG("Event[0x%x] sent to %s on socket[%d]", event_type, client_info_manager.get_client_info(*it_client_id), client_socket.get_socket_fd());
- else
- ERR("Failed to send event[0x%x] to %s on socket[%d]", event_type, client_info_manager.get_client_info(*it_client_id), client_socket.get_socket_fd());
-
- ++it_client_id;
- }
-
- free(sensor_hub_events);
-}
-
client_info_manager& sensor_event_dispatcher::get_client_info_manager(void)
{
return client_info_manager::get_instance();
void dispatch_event(void);
void send_sensor_events(std::vector<void *> &events);
- void send_sensorhub_events(void *events);
static client_info_manager& get_client_info_manager(void);
static sensor_event_queue& get_event_queue(void);
SENSOR_PRIVILEGE_INTERNAL,
} sensor_privilege_t;
-#define SENSOR_HUB_DATA_SIZE 4096
-
-typedef struct sensorhub_data_t {
- int accuracy;
- unsigned long long timestamp;
- int value_count;
- char values[SENSOR_HUB_DATA_SIZE];
-
- /* deprecated */
- char hub_data[SENSOR_HUB_DATA_SIZE];
- int version;
- int sensorhub;
- int type;
- int hub_data_size;
- float data[16];
-} sensorhub_data_t;
-
/*
* To prevent naming confliction as using same enums as sensor CAPI use
*/
#include <sys/stat.h>
#include <unistd.h>
#include <string.h>
-#include "sensor_logs.h"
#include <dlog.h>
#include <stdarg.h>
#include <stddef.h>
-#include <sf_common.h>
-#include <sensor_types.h>
+#include "sensor_logs.h"
#ifndef EXTAPI
#define EXTAPI __attribute__((visibility("default")))
return client_name;
}
-
-
-bool is_sensorhub_event(unsigned int event_type)
-{
- if ((event_type >> EVENT_TYPE_SHIFT) == CONTEXT_SENSOR)
- return true;
-
- return false;
-}
-
-void copy_sensor_data(sensor_data_t *dest, sensor_data_t *src)
-{
- memcpy(dest, src, offsetof(sensor_data_t, values));
- memcpy(dest->values, src->values, src->value_count * sizeof(src->values[0]));
-}
-
-void copy_sensorhub_data(sensorhub_data_t *dest, sensorhub_data_t *src)
-{
- memcpy(dest, src, offsetof(sensorhub_data_t, hub_data));
- memcpy(dest->hub_data, src->hub_data, src->hub_data_size);
- memcpy(dest->data, src->data, sizeof(src->data));
-}
#endif
-struct sensor_data_t;
-struct sensorhub_data_t;
-typedef struct sensor_data_t sensor_data_t;
-typedef struct sensorhub_data_t sensorhub_data_t;
-
const char* get_client_name(void);
bool get_proc_name(pid_t pid, char *process_name);
-bool is_sensorhub_event(unsigned int event_type);
-void copy_sensor_data(sensor_data_t *dest, sensor_data_t *src);
-void copy_sensorhub_data(sensorhub_data_t *dest, sensorhub_data_t *src);
#ifdef __cplusplus
}
sensor_data_t *data;
} sensor_event_t;
-typedef struct sensorhub_event_t {
- unsigned int event_type;
- sensor_id_t sensor_id;
- unsigned int data_length;
- sensorhub_data_t data;
-} sensorhub_event_t;
-
typedef void *(*cmd_func_t)(void *data, void *cb_data);
typedef std::vector<unsigned int> event_type_vector;
include_directories(${CMAKE_CURRENT_SOURCE_DIR})
include_directories(${CMAKE_SOURCE_DIR}/src/client)
include_directories(${CMAKE_SOURCE_DIR}/src/shared)
+include_directories(${CMAKE_SOURCE_DIR}/src/hal)
FOREACH(flag ${pkgs_CFLAGS})
SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}")
projects / platform / core / system / sensord.git / commitdiff