libsensord: support variable size of sensor data packets

Change-Id: I24891583cf9b7c8d95ac09ff6e7e60388f83fb55
Signed-off-by: kibak.yoon <kibak.yoon@samsung.com>

diff --git a/src/client/csensor_event_listener.cpp b/src/client/csensor_event_listener.cpp
index 8c298dc..17a1dbb 100644 (file)
--- a/src/client/csensor_event_listener.cpp
+++ b/src/client/csensor_event_listener.cpp
@@ -29,6 +29,9 @@
 #define MS_TO_US 1000
 #define MIN_DELIVERY_DIFF_FACTOR 0.75f
 
+/* TODO: this macro should be adjusted */
+#define EVENT_BUFFER_SIZE sizeof(sensorhub_event_t)
+
 using std::thread;
 using std::pair;
 using std::vector;
@@ -54,7 +57,6 @@ csensor_event_listener::csensor_event_listener(const csensor_event_listener& lis
 {
 }
 
-
 csensor_event_listener& csensor_event_listener::get_instance(void)
 {
        static csensor_event_listener inst;
@@ -113,7 +115,6 @@ client_callback_info* csensor_event_listener::handle_calibration_cb(csensor_hand
        cal_event_info = handle_info.get_reg_event_info(cal_event_type);
        if ((accuracy == SENSOR_ACCURACY_BAD) && !handle_info.m_bad_accuracy && cal_event_info) {
                sensor_event_data_t cal_event_data;
-               sensor_data_t cal_data;
                void *cal_sensor_data;
 
                cal_event_info->m_previous_event_time = time;
@@ -122,19 +123,22 @@ client_callback_info* csensor_event_listener::handle_calibration_cb(csensor_hand
                if (!event_info)
                        return NULL;
 
+               sensor_data_t *cal_data = (sensor_data_t *)malloc(sizeof(sensor_data_t));
+               retvm_if(!cal_data, NULL, "Failed to allocate memory");
+
                if (event_info->m_cb_type == SENSOR_LEGACY_CB) {
                        cal_event_data.event_data = (void *)&(accuracy);
                        cal_event_data.event_data_size = sizeof(accuracy);
                        cal_sensor_data = &cal_event_data;
                } else {
-                       cal_data.accuracy = accuracy;
-                       cal_data.timestamp = time;
-                       cal_data.values[0] = accuracy;
-                       cal_data.value_count = 1;
-                       cal_sensor_data = &cal_data;
+                       cal_data->accuracy = accuracy;
+                       cal_data->timestamp = time;
+                       cal_data->values[0] = accuracy;
+                       cal_data->value_count = 1;
+                       cal_sensor_data = cal_data;
                }
 
-               cal_callback_info = get_callback_info(handle_info.m_sensor_id, cal_event_info, cal_sensor_data);
+               cal_callback_info = get_callback_info(handle_info.m_sensor_id, cal_event_info, cal_sensor_data, cal_sensor_data);
 
                m_client_info.set_bad_accuracy(handle_info.m_handle, true);
 
@@ -222,9 +226,9 @@ void csensor_event_listener::handle_events(void* event)
                                client_callback_infos.push_back(cal_callback_info);
 
                        if (event_info->m_cb_type == SENSOR_LEGACY_CB)
-                               callback_info = get_callback_info(sensor_id, event_info, &event_data);
+                               callback_info = get_callback_info(sensor_id, event_info, &event_data, event);
                        else
-                               callback_info = get_callback_info(sensor_id, event_info, sensor_data);
+                               callback_info = get_callback_info(sensor_id, event_info, sensor_data, event);
 
                        if (!callback_info) {
                                ERR("Failed to get callback_info");
@@ -259,7 +263,7 @@ void csensor_event_listener::handle_events(void* event)
 }
 
 
-client_callback_info* csensor_event_listener::get_callback_info(sensor_id_t sensor_id, const creg_event_info *event_info, void* sensor_data)
+client_callback_info* csensor_event_listener::get_callback_info(sensor_id_t sensor_id, const creg_event_info *event_info, void* sensor_data, void *buffer)
 {
        client_callback_info* callback_info;
 
@@ -278,7 +282,10 @@ client_callback_info* csensor_event_listener::get_callback_info(sensor_id_t sens
        callback_info->accuracy = -1;
        callback_info->accuracy_user_data = NULL;
        callback_info->maincontext = event_info->m_maincontext;
+       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)];
 
@@ -326,6 +333,7 @@ client_callback_info* csensor_event_listener::get_callback_info(sensor_id_t sens
                else
                        memcpy(dest_sensor_data->event_data, src_sensor_data->event_data, src_sensor_data->event_data_size);
        }
+       */
 
        return callback_info;
 }
@@ -372,7 +380,7 @@ gboolean csensor_event_listener::callback_dispatcher(gpointer data)
                delete[] (char *)data->event_data;
        }
 
-       delete[] (char*)(cb_info->sensor_data);
+       free(cb_info->buffer);
        delete cb_info;
 
 /*
@@ -391,39 +399,55 @@ bool csensor_event_listener::sensor_event_poll(void* buffer, int buffer_len, int
 
        if (!len) {
                if(!m_poller->poll(event))
-                       return false;
+                       return -1;
                len = m_event_socket.recv(buffer, buffer_len);
 
                if (!len) {
                        INFO("%s failed to read after poll!", get_client_name());
-                       return false;
+                       return -1;
                }
        }
 
        if (len < 0) {
                INFO("%s failed to recv event from event socket", get_client_name());
-               return false;
+               return -1;
        }
 
-       return true;
+       return len;
 }
 
 
 
 void csensor_event_listener::listen_events(void)
 {
-       sensorhub_event_t buffer;
        int event;
+       ssize_t len = -1;
 
        do {
                lock l(m_thread_mutex);
                if (m_thread_state == THREAD_STATE_START) {
-                       if (!sensor_event_poll(&buffer, sizeof(buffer), event)) {
+                       void *buffer = malloc(EVENT_BUFFER_SIZE);
+
+                       if (!buffer) {
+                               ERR("Failed to allocate memory");
+                               break;
+                       }
+
+                       len = sensor_event_poll(buffer, EVENT_BUFFER_SIZE, event);
+                       if (len <= 0) {
                                INFO("sensor_event_poll failed");
+                               free(buffer);
+                               break;
+                       }
+
+                       void *buffer_shrinked = realloc(buffer, len);
+                       if (!buffer_shrinked) {
+                               ERR("Failed to allocate memory");
+                               free(buffer);
                                break;
                        }
 
-                       handle_events(&buffer);
+                       handle_events(buffer_shrinked);
                } else {
                        break;
                }

diff --git a/src/client/csensor_event_listener.h b/src/client/csensor_event_listener.h
index a578f0d..21f28cf 100644 (file)
--- a/src/client/csensor_event_listener.h
+++ b/src/client/csensor_event_listener.h
@@ -58,6 +58,7 @@ typedef struct {
        int accuracy;
        void *accuracy_user_data;
        GMainContext *maincontext;
+       void *buffer;
 } client_callback_info;
 
 typedef void (*hup_observer_t)(void);
@@ -109,7 +110,7 @@ private:
        client_callback_info* handle_calibration_cb(csensor_handle_info &handle_info, unsigned event_type, unsigned long long time, int accuracy);
        void handle_events(void* event);
 
-       client_callback_info* get_callback_info(sensor_id_t sensor_id, const creg_event_info *event_info, void *sensor_data);
+       client_callback_info* get_callback_info(sensor_id_t sensor_id, const creg_event_info *event_info, void *sensor_data, void *buffer);
 
        unsigned long long renew_event_id(void);