Add new APIs skeleton to announce that attribute changed

* Remove a build warning
* Add sensorctl tests
* Refactor some codes

Change-Id: I048fa208303c18e7a52b7918c00beb3556e993d3
Signed-off-by: Boram Bae <boram21.bae@samsung.com>

diff --git a/include/sensor_internal.h b/include/sensor_internal.h
index cb7eac31c261609de4dbb7fec83db90550cee5ca..5727e23b9ce9addd29404e5c89954b797f520e3d 100644 (file)
--- a/include/sensor_internal.h
+++ b/include/sensor_internal.h
@@ -41,6 +41,8 @@ typedef void (*sensor_cb_t)(sensor_t sensor, unsigned int event_type, sensor_dat
 typedef void (*sensor_events_cb_t)(sensor_t sensor, unsigned int event_type, sensor_data_t* events[], int events_count, void *user_data);
 typedef void (*sensorhub_cb_t)(sensor_t sensor, unsigned int event_type, sensorhub_data_t *data, void *user_data);
 typedef void (*sensor_accuracy_changed_cb_t) (sensor_t sensor, unsigned long long timestamp, int accuracy, void *user_data);
+typedef void (*sensor_attribute_int_changed_cb_t)(sensor_t sensor, int attribute, int value, void *data);
+typedef void (*sensor_attribute_str_changed_cb_t)(sensor_t sensor, int attribute, const char *value, int len, void *data);
 
 /**
  * @brief Get the list of available sensors of a certain type,  use ALL_SENSOR to get all the sensors.
@@ -302,6 +304,13 @@ bool sensord_register_accuracy_cb(int handle, sensor_accuracy_changed_cb_t cb, v
  */
 bool sensord_unregister_accuracy_cb(int handle);
 
+bool sensord_register_attribute_int_changed_cb(int handle, sensor_attribute_int_changed_cb_t cb, void *user_data);
+
+bool sensord_unregister_attribute_int_changed_cb(int handle);
+
+bool sensord_register_attribute_str_changed_cb(int handle, sensor_attribute_str_changed_cb_t cb, void *user_data);
+
+bool sensord_unregister_attribute_str_changed_cb(int handle);
 /**
  * @brief Start listening events with a connected sensor.
  *

diff --git a/src/client-dummy/client_dummy.cpp b/src/client-dummy/client_dummy.cpp
index 074277eef54f42a4a88c3e2291c5b263f538a12c..d84e2ad9a9aebbc16ac0ef4d21254b11eec35501 100644 (file)
--- a/src/client-dummy/client_dummy.cpp
+++ b/src/client-dummy/client_dummy.cpp
@@ -153,6 +153,26 @@ API bool sensord_unregister_accuracy_cb(int handle)
        return false;
 }
 
+API bool sensord_register_attribute_int_changed_cb(int handle, sensor_attribute_int_changed_cb_t cb, void *user_data)
+{
+       return false;
+}
+
+API bool sensord_unregister_attribute_int_changed_cb(int handle)
+{
+       return false;
+}
+
+API bool sensord_register_attribute_str_changed_cb(int handle, sensor_attribute_str_changed_cb_t cb, void *user_data)
+{
+       return false;
+}
+
+API bool sensord_unregister_attribute_str_changed_cb(int handle)
+{
+       return false;
+}
+
 API bool sensord_start(int handle, int option)
 {
        return false;

diff --git a/src/client/sensor_internal.cpp b/src/client/sensor_internal.cpp
index d9bd4895599a69fd1a32f1e14bb19fcb9acda012..0bad9a806974ff8688527c32696f7690f373d07a 100644 (file)
--- a/src/client/sensor_internal.cpp
+++ b/src/client/sensor_internal.cpp
@@ -42,20 +42,20 @@ using namespace sensor;
 
 typedef struct {
        int listener_id;
-       void* cb;
-       bool is_events_cb;
-       sensor_accuracy_changed_cb_t acc_cb;
        sensor_info *sensor;
+       void* cb;
        char* data;
        size_t data_size;
        void *user_data;
 } callback_info_s;
 
+typedef GSourceFunc callback_dispatcher_t;
+
 static sensor::sensor_manager manager;
 static std::unordered_map<int, sensor::sensor_listener *> listeners;
 static cmutex lock;
 
-static gboolean callback_dispatcher(gpointer data)
+static gboolean sensor_events_callback_dispatcher(gpointer data)
 {
        int event_type = 0;
        callback_info_s *info = (callback_info_s *)data;
@@ -66,18 +66,33 @@ static gboolean callback_dispatcher(gpointer data)
                event_type = CONVERT_TYPE_EVENT(info->sensor->get_type());
 
        if (info->cb && info->sensor && listeners.find(info->listener_id) != listeners.end()) {
-               if (info->is_events_cb) {
-                       size_t element_size =  sizeof(sensor_data_t);
-                       size_t count = info->data_size / element_size;
-                       sensor_data_t *events[count];
-                       char* p = (char*)info->data;
-                       for (size_t i = 0 ; i < count; ++i) {
-                               events[i] = (sensor_data_t *)(p + i * element_size);
-                       }
-                       ((sensor_events_cb_t)info->cb)(info->sensor, event_type, events, count, info->user_data);
-               } else {
-                       ((sensor_cb_t)info->cb)(info->sensor, event_type, (sensor_data_t*)info->data, info->user_data);
+               size_t element_size =  sizeof(sensor_data_t);
+               size_t count = info->data_size / element_size;
+               sensor_data_t *events[count];
+               char* p = (char*)info->data;
+               for (size_t i = 0 ; i < count; ++i) {
+                       events[i] = (sensor_data_t *)(p + i * element_size);
                }
+               ((sensor_events_cb_t)info->cb)(info->sensor, event_type, events, count, info->user_data);
+       }
+
+       delete [] info->data;
+       delete info;
+       return FALSE;
+}
+
+static gboolean sensor_event_callback_dispatcher(gpointer data)
+{
+       int event_type = 0;
+       callback_info_s *info = (callback_info_s *)data;
+
+       AUTOLOCK(lock);
+
+       if (info->sensor)
+               event_type = CONVERT_TYPE_EVENT(info->sensor->get_type());
+
+       if (info->cb && info->sensor && listeners.find(info->listener_id) != listeners.end()) {
+               ((sensor_cb_t)info->cb)(info->sensor, event_type, (sensor_data_t*)info->data, info->user_data);
        }
 
        delete [] info->data;
@@ -85,15 +100,15 @@ static gboolean callback_dispatcher(gpointer data)
        return FALSE;
 }
 
-static gboolean accuracy_callback_dispatcher(gpointer data)
+static gboolean sensor_accuracy_changed_callback_dispatcher(gpointer data)
 {
        callback_info_s *info = (callback_info_s *)data;
 
        AUTOLOCK(lock);
 
-       if (info->acc_cb && info->sensor && listeners.find(info->listener_id) != listeners.end()) {
+       if (info->cb && info->sensor && listeners.find(info->listener_id) != listeners.end()) {
                sensor_data_t * data = (sensor_data_t *)info->data;
-               info->acc_cb(info->sensor, data->timestamp, data->accuracy, info->user_data);
+               ((sensor_accuracy_changed_cb_t)info->cb)(info->sensor, data->timestamp, data->accuracy, info->user_data);
        }
 
        delete [] info->data;
@@ -101,15 +116,15 @@ static gboolean accuracy_callback_dispatcher(gpointer data)
        return FALSE;
 }
 
-class sensor_event_handler : public ipc::channel_handler
+class sensor_listener_handler : public ipc::channel_handler
 {
 public:
-       sensor_event_handler(int id, sensor_t sensor, void* cb, bool is_events_cb, void *user_data)
+       sensor_listener_handler(int id, sensor_t sensor, void* cb, void *user_data, callback_dispatcher_t dispatcher)
        : m_listener_id(id)
        , m_sensor(reinterpret_cast<sensor_info *>(sensor))
        , m_cb(cb)
        , m_user_data(user_data)
-       , m_is_events_cb(is_events_cb)
+       , m_dispatcher(dispatcher)
        {}
 
        void connected(ipc::channel *ch) {}
@@ -129,9 +144,8 @@ public:
                info->data = data;
                info->data_size = size;
                info->user_data = m_user_data;
-               info->is_events_cb = m_is_events_cb;
 
-               g_idle_add(callback_dispatcher, info);
+               g_idle_add(m_dispatcher, info);
        }
 
        void read_complete(ipc::channel *ch) {}
@@ -142,46 +156,7 @@ private:
        sensor_info *m_sensor;
        void* m_cb;
        void *m_user_data;
-       bool m_is_events_cb;
-};
-
-class sensor_accuracy_handler : public ipc::channel_handler
-{
-public:
-       sensor_accuracy_handler(int id, sensor_t sensor, sensor_accuracy_changed_cb_t cb, void *user_data)
-       : m_listener_id(id)
-       , m_sensor(reinterpret_cast<sensor_info *>(sensor))
-       , m_cb(cb)
-       , m_user_data(user_data)
-       {}
-
-       void connected(ipc::channel *ch) {}
-       void disconnected(ipc::channel *ch) {}
-       void read(ipc::channel *ch, ipc::message &msg)
-       {
-               callback_info_s *info;
-               char *data = new(std::nothrow) char[msg.size()];
-
-               memcpy(data, msg.body(), msg.size());
-
-               info = new(std::nothrow) callback_info_s();
-               info->listener_id = m_listener_id;
-               info->acc_cb = m_cb;
-               info->sensor = m_sensor;
-               info->data = data;
-               info->user_data = m_user_data;
-
-               g_idle_add(accuracy_callback_dispatcher, info);
-       }
-
-       void read_complete(ipc::channel *ch) {}
-       void error_caught(ipc::channel *ch, int error) {}
-
-private:
-       int m_listener_id;
-       sensor_info *m_sensor;
-       sensor_accuracy_changed_cb_t m_cb;
-       void *m_user_data;
+       callback_dispatcher_t m_dispatcher;
 };
 
 /*
@@ -368,7 +343,7 @@ static inline bool sensord_register_event_impl(int handle, unsigned int event_ty
        sensor::sensor_listener *listener;
        int prev_interval;
        int prev_max_batch_latency;
-       sensor_event_handler *handler;
+       sensor_listener_handler *handler;
 
        AUTOLOCK(lock);
 
@@ -391,7 +366,12 @@ static inline bool sensord_register_event_impl(int handle, unsigned int event_ty
                return false;
        }
 
-       handler = new(std::nothrow) sensor_event_handler(handle, listener->get_sensor(), cb, is_events_callback, user_data);
+       if (is_events_callback) {
+               handler = new(std::nothrow)sensor_listener_handler(handle, listener->get_sensor(), (void *)cb, user_data, sensor_events_callback_dispatcher);
+       } else {
+               handler = new(std::nothrow)sensor_listener_handler(handle, listener->get_sensor(), (void *)cb, user_data, sensor_event_callback_dispatcher);
+       }
+
        if (!handler) {
                listener->set_max_batch_latency(prev_max_batch_latency);
                listener->set_interval(prev_interval);
@@ -448,7 +428,7 @@ API bool sensord_unregister_events(int handle, unsigned int event_type)
 API bool sensord_register_accuracy_cb(int handle, sensor_accuracy_changed_cb_t cb, void *user_data)
 {
        sensor::sensor_listener *listener;
-       sensor_accuracy_handler *handler;
+       sensor_listener_handler *handler;
 
        AUTOLOCK(lock);
 
@@ -457,7 +437,7 @@ API bool sensord_register_accuracy_cb(int handle, sensor_accuracy_changed_cb_t c
 
        listener = it->second;
 
-       handler = new(std::nothrow) sensor_accuracy_handler(handle, listener->get_sensor(), cb, user_data);
+       handler = new(std::nothrow) sensor_listener_handler(handle, listener->get_sensor(), (void *)cb, user_data, sensor_accuracy_changed_callback_dispatcher);
        retvm_if(!handler, false, "Failed to allocate memory");
 
        listener->set_accuracy_handler(handler);
@@ -481,6 +461,30 @@ API bool sensord_unregister_accuracy_cb(int handle)
        return true;
 }
 
+API bool sensord_register_attribute_int_changed_cb(int handle, sensor_attribute_int_changed_cb_t cb, void *user_data)
+{
+       // TODO
+       return false;
+}
+
+API bool sensord_unregister_attribute_int_changed_cb(int handle)
+{
+       // TODO
+       return false;
+}
+
+API bool sensord_register_attribute_str_changed_cb(int handle, sensor_attribute_str_changed_cb_t cb, void *user_data)
+{
+       // TODO
+       return false;
+}
+
+API bool sensord_unregister_attribute_str_changed_cb(int handle)
+{
+       // TODO
+       return false;
+}
+
 API bool sensord_start(int handle, int option)
 {
        sensor::sensor_listener *listener;

diff --git a/src/client/sensor_reader.cpp b/src/client/sensor_reader.cpp
index cdbad28dff684a1635e90fea5e9f37b18f628622..bc3a7a191dbab636ab0801fab2a507603200d360 100644 (file)
--- a/src/client/sensor_reader.cpp
+++ b/src/client/sensor_reader.cpp
@@ -27,10 +27,10 @@ using namespace sensor;
 
 sensor_reader::sensor_reader()
 : m_reader(NULL)
+, m_loop(NULL)
 , m_event_loop(NULL)
 , m_mutex()
 , m_cond()
-, m_loop(NULL)
 , m_running(false)
 {
        m_event_loop = new(std::nothrow) ipc::event_loop();

diff --git a/src/sensorctl/testcase/sensor_listener.cpp b/src/sensorctl/testcase/sensor_listener.cpp
index ebff117e27c96e88bf8e3c51f8c3c620b2819b2a..3bdf4dc99c79290957938974b2d51ba584e1df3c 100644 (file)
--- a/src/sensorctl/testcase/sensor_listener.cpp
+++ b/src/sensorctl/testcase/sensor_listener.cpp
@@ -246,3 +246,184 @@ TESTCASE(sensor_listener, attribute_string_1)
 
        return true;
 }
+
+void sensor_attribute_int_changed_callback(sensor_t sensor, int attribute, int value, void *data)
+{
+       _I("[ATTRIBUTE INT CHANGED] attribute : %d, value : %d\n", attribute, value);
+}
+
+TESTCASE(skip_sensor_listener, register_attribute_int_changed)
+{
+       int err;
+       bool ret;
+       int handle;
+       sensor_t sensor;
+
+       called = false;
+
+       err = sensord_get_default_sensor(ACCELEROMETER_SENSOR, &sensor);
+       ASSERT_EQ(err, 0);
+
+       handle = sensord_connect(sensor);
+       ASSERT_EQ(err, 0);
+
+       ret = sensord_register_attribute_int_changed_cb(handle, sensor_attribute_int_changed_callback, NULL);
+       ASSERT_TRUE(ret);
+
+       ret = sensord_start(handle, 0);
+       ASSERT_TRUE(ret);
+
+       mainloop::run();
+
+       ret = sensord_stop(handle);
+       ASSERT_TRUE(ret);
+
+       ret = sensord_unregister_attribute_int_changed_cb(handle);
+       ASSERT_TRUE(ret);
+
+       ret = sensord_disconnect(handle);
+       ASSERT_TRUE(ret);
+
+       return true;
+}
+
+static int attribute = 1; // 1 is SENSOR_ATTRIBUTE_AXIS_ORIENTATION of sensor_attribute_e in sensor.h
+static int attribute_value = 0;
+
+static gboolean change_attribute_int(gpointer gdata)
+{
+       int *handle = reinterpret_cast<int *>(gdata);
+
+       sensord_set_attribute_int(*handle, attribute, attribute_value);
+
+       _N("[ SET ATTRIBUTE INT ] attribute %d, value : %d\n", attribute, attribute_value);
+
+       g_timeout_add_seconds(1, change_attribute_int, handle);
+
+       attribute_value ? attribute_value = 0 : attribute_value = 1;
+
+       return FALSE;
+}
+
+TESTCASE(skip_sensor_listener, attribute_int_changer)
+{
+       int err;
+       bool ret;
+       int handle;
+       sensor_t sensor;
+
+       called = false;
+
+       err = sensord_get_default_sensor(ACCELEROMETER_SENSOR, &sensor);
+       ASSERT_EQ(err, 0);
+
+       handle = sensord_connect(sensor);
+       ASSERT_EQ(err, 0);
+
+       ret = sensord_start(handle, 0);
+       ASSERT_TRUE(ret);
+
+       g_timeout_add_seconds(1, change_attribute_int, &handle);
+       mainloop::run();
+
+       ret = sensord_stop(handle);
+       ASSERT_TRUE(ret);
+
+       ret = sensord_disconnect(handle);
+       ASSERT_TRUE(ret);
+
+       return true;
+}
+
+void sensor_attribute_str_changed_callback(sensor_t sensor, int attribute, const char *value, int len, void *data)
+{
+       _I("[ATTRIBUTE STR CHANGED] attribute : %d, value : %s, len : %d\n", attribute, value, len);
+}
+
+TESTCASE(skip_sensor_listener, register_attribute_str_changed)
+{
+       int err;
+       bool ret;
+       int handle;
+       sensor_t sensor;
+
+       called = false;
+
+       err = sensord_get_default_sensor(ACCELEROMETER_SENSOR, &sensor);
+       ASSERT_EQ(err, 0);
+
+       handle = sensord_connect(sensor);
+       ASSERT_EQ(err, 0);
+
+       ret = sensord_register_attribute_str_changed_cb(handle, sensor_attribute_str_changed_callback, NULL);
+       ASSERT_TRUE(ret);
+
+       ret = sensord_start(handle, 0);
+       ASSERT_TRUE(ret);
+
+       mainloop::run();
+
+       ret = sensord_stop(handle);
+       ASSERT_TRUE(ret);
+
+       ret = sensord_unregister_attribute_int_changed_cb(handle);
+       ASSERT_TRUE(ret);
+
+       ret = sensord_disconnect(handle);
+       ASSERT_TRUE(ret);
+
+       return true;
+}
+
+static const char *attribute_value_str1 = "test_str_1";
+static const char *attribute_value_str2 = "test_str_2";
+static const char *attribute_value_str = attribute_value_str1;
+
+static gboolean change_attribute_str(gpointer gdata)
+{
+       int *handle = reinterpret_cast<int *>(gdata);
+       int len = strlen(attribute_value_str);
+       sensord_set_attribute_str(*handle, attribute, attribute_value_str, len);
+
+       _N("[ SET ATTRIBUTE STR ] attribute %d, value : %s, len : %d\n", attribute, attribute_value_str, len);
+
+       g_timeout_add_seconds(1, change_attribute_str, handle);
+
+       if (attribute_value_str == attribute_value_str1) {
+               attribute_value_str = attribute_value_str2;
+       } else {
+               attribute_value_str = attribute_value_str1;
+       }
+
+       return FALSE;
+}
+
+TESTCASE(skip_sensor_listener, attribute_str_changer)
+{
+       int err;
+       bool ret;
+       int handle;
+       sensor_t sensor;
+
+       called = false;
+
+       err = sensord_get_default_sensor(ACCELEROMETER_SENSOR, &sensor);
+       ASSERT_EQ(err, 0);
+
+       handle = sensord_connect(sensor);
+       ASSERT_EQ(err, 0);
+
+       ret = sensord_start(handle, 0);
+       ASSERT_TRUE(ret);
+
+       g_timeout_add_seconds(1, change_attribute_str, &handle);
+       mainloop::run();
+
+       ret = sensord_stop(handle);
+       ASSERT_TRUE(ret);
+
+       ret = sensord_disconnect(handle);
+       ASSERT_TRUE(ret);
+
+       return true;
+}
\ No newline at end of file