sensord: notify that the sensor is registered or unregistered

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

diff --git a/src/server/sensor_manager.cpp b/src/server/sensor_manager.cpp
index 9a06489..8d79ed0 100644 (file)
--- a/src/server/sensor_manager.cpp
+++ b/src/server/sensor_manager.cpp
@@ -21,6 +21,8 @@
 
 #include <unistd.h>
 #include <sensor_log.h>
+#include <message.h>
+#include <command_types.h>
 #include <string>
 #include <vector>
 #include <memory>
@@ -105,6 +107,53 @@ bool sensor_manager::is_supported(std::string uri)
        return false;
 }
 
+int sensor_manager::serialize(sensor_info *info, char **bytes)
+{
+       int size;
+       raw_data_t *raw = new(std::nothrow) raw_data_t;
+       retvm_if(!raw, -ENOMEM, "Failed to allocated memory");
+
+       info->serialize(*raw);
+
+       *bytes = new(std::nothrow) char[raw->size()];
+       retvm_if(!*bytes, -ENOMEM, "Failed to allocate memory");
+
+       std::copy(raw->begin(), raw->end(), *bytes);
+
+       size = raw->size();
+       delete raw;
+
+       return size;
+}
+
+void sensor_manager::send(ipc::message &msg)
+{
+       for (auto it = m_channels.begin(); it != m_channels.end(); ++it)
+               (*it)->send_sync(&msg);
+}
+
+void sensor_manager::send_added_msg(sensor_info *info)
+{
+       char *bytes;
+       int size;
+
+       size = serialize(info, &bytes);
+
+       ipc::message msg((const char *)bytes, size);
+       msg.set_type(CMD_MANAGER_SENSOR_ADDED);
+
+       send(msg);
+}
+
+void sensor_manager::send_removed_msg(const std::string &uri)
+{
+       ipc::message msg;
+       msg.set_type(CMD_MANAGER_SENSOR_REMOVED);
+       msg.enclose(uri.c_str(), uri.size());
+
+       send(msg);
+}
+
 bool sensor_manager::register_sensor(sensor_handler *sensor)
 {
        retvm_if(!sensor, false, "Invalid sensor");
@@ -116,6 +165,8 @@ bool sensor_manager::register_sensor(sensor_handler *sensor)
 
        m_sensors[info.get_uri()] = sensor;
 
+       send_added_msg(&info);
+
        _I("Registered[%s]", info.get_uri().c_str());
 
        return true;
@@ -129,9 +180,29 @@ void sensor_manager::deregister_sensor(const std::string uri)
        delete it->second;
        m_sensors.erase(it);
 
+       send_removed_msg(uri);
+
        _I("Deregistered[%s]", uri.c_str());
 }
 
+void sensor_manager::register_channel(ipc::channel *ch)
+{
+       ret_if(!ch);
+       m_channels.push_back(ch);
+}
+
+void sensor_manager::deregister_channel(ipc::channel *ch)
+{
+       ret_if(!ch);
+
+       for (auto it = m_channels.begin(); it != m_channels.end(); ++it) {
+               if (*it == ch) {
+                       m_channels.erase(it);
+                       return;
+               }
+       }
+}
+
 sensor_handler *sensor_manager::get_sensor_by_type(const std::string uri)
 {
        auto it = m_sensors.begin();
@@ -247,6 +318,7 @@ static void put_int_to_vec(std::vector<char> &data, int value)
        std::copy(&buf[0], &buf[sizeof(buf)], back_inserter(data));
 }
 
+/* TODO: remove socket fd parameter */
 /* packet format :
  * [count:4] {[size:4] [info:n] [size:4] [info:n] ...}
  */

diff --git a/src/server/sensor_manager.h b/src/server/sensor_manager.h
index 5c09b0e..78692a8 100644 (file)
--- a/src/server/sensor_manager.h
+++ b/src/server/sensor_manager.h
@@ -24,7 +24,8 @@
 #include <vector>
 #include <unordered_map>
 
-#include "event_loop.h"
+#include <channel.h>
+#include <event_loop.h>
 
 #include "sensor_handler.h"
 #include "sensor_observer.h"
@@ -49,6 +50,9 @@ public:
        bool register_sensor(sensor_handler *sensor);
        void deregister_sensor(const std::string uri);
 
+       void register_channel(ipc::channel *ch);
+       void deregister_channel(ipc::channel *ch);
+
        sensor_handler *get_sensor_by_type(const std::string uri);
        sensor_handler *get_sensor(const std::string uri);
        std::vector<sensor_handler *> get_sensors(void);
@@ -67,11 +71,19 @@ private:
        void init_sensors(void);
        void register_handler(physical_sensor_handler *sensor);
 
+       int serialize(sensor_info *info, char **bytes);
+
+       void send(ipc::message &msg);
+       void send_added_msg(sensor_info *info);
+       void send_removed_msg(const std::string &uri);
+
        void show(void);
 
        ipc::event_loop *m_loop;
        sensor_loader m_loader;
        sensor_map_t m_sensors;
+
+       std::vector<ipc::channel *> m_channels;
 };
 
 }

diff --git a/src/server/server_channel_handler.cpp b/src/server/server_channel_handler.cpp
index 5ad196e..429013a 100644 (file)
--- a/src/server/server_channel_handler.cpp
+++ b/src/server/server_channel_handler.cpp
@@ -53,13 +53,14 @@ void server_channel_handler::connected(channel *ch)
 
 void server_channel_handler::disconnected(channel *ch)
 {
+       m_manager->deregister_channel(ch);
+
        auto it_asensor = m_app_sensors.find(ch);
        if (it_asensor != m_app_sensors.end()) {
                sensor_info info = it_asensor->second->get_sensor_info();
 
                _I("Disconnected provider[%s]", info.get_uri().c_str());
 
-               /* TODO: if sensor is unregistered, related listeners has to be handled */
                m_manager->deregister_sensor(info.get_uri());
                m_app_sensors.erase(ch);
        }
@@ -79,6 +80,10 @@ void server_channel_handler::read(channel *ch, message &msg)
        int err = -EINVAL;
 
        switch (msg.type()) {
+       case CMD_MANAGER_CONNECT:
+               err = manager_connect(ch, msg); break;
+       case CMD_MANAGER_DISCONNECT:
+               err = manager_disconnect(ch, msg); break;
        case CMD_MANAGER_SENSOR_LIST:
                err = manager_get_sensor_list(ch, msg); break;
        case CMD_LISTENER_CONNECT:
@@ -112,6 +117,18 @@ void server_channel_handler::read(channel *ch, message &msg)
        }
 }
 
+int server_channel_handler::manager_connect(channel *ch, message &msg)
+{
+       m_manager->register_channel(ch);
+       return send_reply(ch, OP_SUCCESS);
+}
+
+int server_channel_handler::manager_disconnect(channel *ch, message &msg)
+{
+       m_manager->deregister_channel(ch);
+       return send_reply(ch, OP_SUCCESS);
+}
+
 int server_channel_handler::manager_get_sensor_list(channel *ch, message &msg)
 {
        ipc::message reply;

diff --git a/src/server/server_channel_handler.h b/src/server/server_channel_handler.h
index 9c912be..befa663 100644 (file)
--- a/src/server/server_channel_handler.h
+++ b/src/server/server_channel_handler.h
@@ -44,8 +44,11 @@ public:
        void error_caught(ipc::channel *ch, int error) {}
 
 private:
+       int manager_connect(ipc::channel *ch, ipc::message &msg);
+       int manager_disconnect(ipc::channel *ch, ipc::message &msg);
        int manager_get_sensor_list(ipc::channel *ch, ipc::message &msg);
 
+
        int listener_connect(ipc::channel *ch, ipc::message &msg);
        int listener_disconnect(ipc::channel *ch, ipc::message &msg);
        int listener_start(ipc::channel *ch, ipc::message &msg);