sensord: separate channel for event and command

- if the event occurs during sending command, a timing issue will occur.

Change-Id: I8ed5ad2f7c6bcc9ea44641c619458639553822c2
Signed-off-by: kibak.yoon <seseki17@gmail.com>

diff --git a/src/client/sensor_listener.cpp b/src/client/sensor_listener.cpp
index a5c4af2..95c411c 100644 (file)
--- a/src/client/sensor_listener.cpp
+++ b/src/client/sensor_listener.cpp
@@ -66,7 +66,8 @@ sensor_listener::sensor_listener(sensor_t sensor)
 : m_id(0)
 , m_sensor(reinterpret_cast<sensor_info *>(sensor))
 , m_client(NULL)
-, m_channel(NULL)
+, m_cmd_channel(NULL)
+, m_evt_channel(NULL)
 , m_handler(NULL)
 , m_evt_handler(NULL)
 , m_acc_handler(NULL)
@@ -148,8 +149,11 @@ void sensor_listener::restore(void)
 
 bool sensor_listener::connect(void)
 {
-       m_channel = m_client->connect(m_handler, &m_loop);
-       retvm_if(!m_channel, false, "Failed to connect to server");
+       m_cmd_channel = m_client->connect(NULL);
+       retvm_if(!m_cmd_channel, false, "Failed to connect to server");
+
+       m_evt_channel = m_client->connect(m_handler, &m_loop);
+       retvm_if(!m_evt_channel, false, "Failed to connect to server");
 
        ipc::message msg;
        ipc::message reply;
@@ -158,9 +162,9 @@ bool sensor_listener::connect(void)
        memcpy(buf.sensor, m_sensor->get_uri().c_str(), m_sensor->get_uri().size());
        msg.set_type(CMD_LISTENER_CONNECT);
        msg.enclose((const char *)&buf, sizeof(buf));
-       m_channel->send_sync(&msg);
+       m_evt_channel->send_sync(&msg);
 
-       m_channel->read_sync(reply);
+       m_evt_channel->read_sync(reply);
        reply.disclose((char *)&buf);
 
        m_id = buf.listener_id;
@@ -180,13 +184,17 @@ void sensor_listener::disconnect(void)
        ipc::message reply;
 
        msg.set_type(CMD_LISTENER_DISCONNECT);
-       m_channel->send_sync(&msg);
+       m_evt_channel->send_sync(&msg);
+
+       m_evt_channel->read_sync(reply);
+       m_evt_channel->disconnect();
 
-       m_channel->read_sync(reply);
-       m_channel->disconnect();
+       delete m_evt_channel;
+       m_evt_channel = NULL;
 
-       delete m_channel;
-       m_channel = NULL;
+       m_cmd_channel->disconnect();
+       delete m_cmd_channel;
+       m_cmd_channel = NULL;
 
        _I("Disconnected[%d]", get_id());
 }
@@ -234,14 +242,14 @@ int sensor_listener::start(void)
        ipc::message reply;
        cmd_listener_start_t buf;
 
-       retvm_if(!m_channel, -EINVAL, "Failed to connect to server");
+       retvm_if(!m_cmd_channel, -EINVAL, "Failed to connect to server");
 
        buf.listener_id = m_id;
        msg.set_type(CMD_LISTENER_START);
        msg.enclose((char *)&buf, sizeof(buf));
 
-       m_channel->send_sync(&msg);
-       m_channel->read_sync(reply);
+       m_cmd_channel->send_sync(&msg);
+       m_cmd_channel->read_sync(reply);
 
        if (reply.header()->err < 0)
                return reply.header()->err;
@@ -257,15 +265,15 @@ int sensor_listener::stop(void)
        ipc::message reply;
        cmd_listener_stop_t buf;
 
-       retvm_if(!m_channel, -EINVAL, "Failed to connect to server");
+       retvm_if(!m_cmd_channel, -EINVAL, "Failed to connect to server");
        retvm_if(!m_started.load(), -EAGAIN, "Already stopped");
 
        buf.listener_id = m_id;
        msg.set_type(CMD_LISTENER_STOP);
        msg.enclose((char *)&buf, sizeof(buf));
 
-       m_channel->send_sync(&msg);
-       m_channel->read_sync(reply);
+       m_cmd_channel->send_sync(&msg);
+       m_cmd_channel->read_sync(reply);
 
        if (reply.header()->err < 0)
                return reply.header()->err;
@@ -343,7 +351,7 @@ int sensor_listener::set_attribute(int attribute, int value)
        ipc::message reply;
        cmd_listener_attr_int_t buf;
 
-       retvm_if(!m_channel, false, "Failed to connect to server");
+       retvm_if(!m_cmd_channel, false, "Failed to connect to server");
 
        buf.listener_id = m_id;
        buf.attribute = attribute;
@@ -351,8 +359,8 @@ int sensor_listener::set_attribute(int attribute, int value)
        msg.set_type(CMD_LISTENER_ATTR_INT);
        msg.enclose((char *)&buf, sizeof(buf));
 
-       m_channel->send_sync(&msg);
-       m_channel->read_sync(reply);
+       m_cmd_channel->send_sync(&msg);
+       m_cmd_channel->read_sync(reply);
 
        if (reply.header()->err < 0)
                return reply.header()->err;
@@ -368,7 +376,7 @@ int sensor_listener::set_attribute(int attribute, const char *value, int len)
        ipc::message reply;
        cmd_listener_attr_str_t buf;
 
-       retvm_if(!m_channel, false, "Failed to connect to server");
+       retvm_if(!m_cmd_channel, false, "Failed to connect to server");
 
        msg.set_type(CMD_LISTENER_ATTR_STR);
        buf.listener_id = m_id;
@@ -378,8 +386,8 @@ int sensor_listener::set_attribute(int attribute, const char *value, int len)
 
        msg.enclose((char *)&buf, sizeof(buf) + len);
 
-       m_channel->send_sync(&msg);
-       m_channel->read_sync(reply);
+       m_cmd_channel->send_sync(&msg);
+       m_cmd_channel->read_sync(reply);
 
        return reply.header()->err;
 }
@@ -390,19 +398,26 @@ int sensor_listener::get_sensor_data(sensor_data_t *data)
        ipc::message reply;
        cmd_listener_get_data_t buf;
 
-       retvm_if(!m_channel, false, "Failed to connect to server");
+       retvm_if(!m_cmd_channel, false, "Failed to connect to server");
 
        buf.listener_id = m_id;
        msg.set_type(CMD_LISTENER_GET_DATA);
        msg.enclose((char *)&buf, sizeof(buf));
-       m_channel->send_sync(&msg);
 
-       m_channel->read_sync(reply);
-       /* TODO */
-       /*
+       m_cmd_channel->send_sync(&msg);
+       m_cmd_channel->read_sync(reply);
+
        reply.disclose((char *)&buf);
-       memcpy(data, buf.data, sizeof(buf.len));
-       */
+       int size = sizeof(sensor_data_t);
+
+       if (buf.len > size || buf.len < 0) {
+               data->accuracy = -1;
+               data->value_count = 0;
+               /* TODO: it should return OP_ERROR */
+               return OP_SUCCESS;
+       }
+
+       memcpy(data, &buf.data, buf.len);
 
        return OP_SUCCESS;
 }

diff --git a/src/client/sensor_listener.h b/src/client/sensor_listener.h
index ea30092..f0a1f1b 100644 (file)
--- a/src/client/sensor_listener.h
+++ b/src/client/sensor_listener.h
@@ -80,7 +80,8 @@ private:
        sensor_info *m_sensor;
 
        ipc::ipc_client *m_client;
-       ipc::channel *m_channel;
+       ipc::channel *m_cmd_channel;
+       ipc::channel *m_evt_channel;
        ipc::channel_handler *m_handler;
        ipc::channel_handler *m_evt_handler;
        ipc::channel_handler *m_acc_handler;

diff --git a/src/server/server_channel_handler.cpp b/src/server/server_channel_handler.cpp
index 1c18d1d..86abf93 100644 (file)
--- a/src/server/server_channel_handler.cpp
+++ b/src/server/server_channel_handler.cpp
@@ -47,13 +47,14 @@ void server_channel_handler::connected(channel *ch)
 
 void server_channel_handler::disconnected(channel *ch)
 {
-       auto it = m_listeners.find(ch);
-       ret_if(it == m_listeners.end());
+       auto it = m_listener_ids.find(ch);
+       ret_if(it == m_listener_ids.end());
 
-       _I("Disconnected listener[%u]", it->second->get_id());
+       _I("Disconnected listener[%u]", it->second);
 
-       delete it->second;
-       m_listeners.erase(ch);
+       delete m_listeners[it->second];
+       m_listeners.erase(it->second);
+       m_listener_ids.erase(ch);
 }
 
 void server_channel_handler::read(channel *ch, message &msg)
@@ -104,6 +105,7 @@ int server_channel_handler::manager_get_sensor_list(channel *ch, message &msg)
        retv_if(size < 0, size);
 
        reply.enclose((const char *)bytes, size);
+       reply.header()->err = OP_SUCCESS;
        ch->send_sync(&reply);
 
        delete [] bytes;
@@ -138,24 +140,26 @@ int server_channel_handler::listener_connect(channel *ch, message &msg)
                return OP_ERROR;
 
        _I("Connected sensor_listener[fd(%d) -> id(%u)]", ch->get_fd(), listener_id);
+       m_listeners[listener_id] = listener;
+       m_listener_ids[ch] = listener_id;
        listener_id++;
-       m_listeners[ch] = listener;
 
        return OP_SUCCESS;
 }
 
 int server_channel_handler::listener_disconnect(channel *ch, message &msg)
 {
-       auto it = m_listeners.find(ch);
-       retv_if(it == m_listeners.end(), -EINVAL);
+       auto it = m_listener_ids.find(ch);
+       retv_if(it == m_listener_ids.end(), -EINVAL);
 
-       uint32_t id = m_listeners[ch]->get_id();
+       uint32_t id = it->second;
 
-       retvm_if(!has_privileges(ch->get_fd(), m_listeners[ch]->get_required_privileges()),
+       retvm_if(!has_privileges(ch->get_fd(), m_listeners[id]->get_required_privileges()),
                        -EACCES, "Permission denied");
 
-       delete m_listeners[ch];
-       m_listeners.erase(ch);
+       delete m_listeners[id];
+       m_listeners.erase(id);
+       m_listener_ids.erase(ch);
 
        _D("Disconnected sensor_listener[%u]", id);
 
@@ -164,12 +168,16 @@ int server_channel_handler::listener_disconnect(channel *ch, message &msg)
 
 int server_channel_handler::listener_start(channel *ch, message &msg)
 {
-       auto it = m_listeners.find(ch);
+       cmd_listener_start_t buf;
+       msg.disclose((char *)&buf);
+       uint32_t id = buf.listener_id;
+
+       auto it = m_listeners.find(id);
        retv_if(it == m_listeners.end(), -EINVAL);
-       retvm_if(!has_privileges(ch->get_fd(), m_listeners[ch]->get_required_privileges()),
+       retvm_if(!has_privileges(ch->get_fd(), m_listeners[id]->get_required_privileges()),
                        -EACCES, "Permission denied");
 
-       int ret = m_listeners[ch]->start();
+       int ret = m_listeners[id]->start();
        retv_if(ret < 0, ret);
 
        return send_reply(ch, OP_SUCCESS);
@@ -177,12 +185,16 @@ int server_channel_handler::listener_start(channel *ch, message &msg)
 
 int server_channel_handler::listener_stop(channel *ch, message &msg)
 {
-       auto it = m_listeners.find(ch);
+       cmd_listener_stop_t buf;
+       msg.disclose((char *)&buf);
+       uint32_t id = buf.listener_id;
+
+       auto it = m_listeners.find(id);
        retv_if(it == m_listeners.end(), -EINVAL);
-       retvm_if(!has_privileges(ch->get_fd(), m_listeners[ch]->get_required_privileges()),
+       retvm_if(!has_privileges(ch->get_fd(), m_listeners[id]->get_required_privileges()),
                        -EACCES, "Permission denied");
 
-       int ret = m_listeners[ch]->stop();
+       int ret = m_listeners[id]->stop();
        retv_if(ret < 0, ret);
 
        return send_reply(ch, OP_SUCCESS);
@@ -190,44 +202,48 @@ int server_channel_handler::listener_stop(channel *ch, message &msg)
 
 int server_channel_handler::listener_attr_int(channel *ch, message &msg)
 {
+       cmd_listener_attr_int_t buf;
+       msg.disclose((char *)&buf);
+       uint32_t id = buf.listener_id;
+
        int ret = OP_SUCCESS;
 
-       auto it = m_listeners.find(ch);
+       auto it = m_listeners.find(id);
        retv_if(it == m_listeners.end(), -EINVAL);
-       retvm_if(!has_privileges(ch->get_fd(), m_listeners[ch]->get_required_privileges()),
+       retvm_if(!has_privileges(ch->get_fd(), m_listeners[id]->get_required_privileges()),
                        -EACCES, "Permission denied");
 
-       cmd_listener_attr_int_t buf;
-       msg.disclose((char *)&buf);
-
        switch (buf.attribute) {
        case SENSORD_ATTRIBUTE_INTERVAL:
-               ret = m_listeners[ch]->set_interval(buf.value); break;
+               ret = m_listeners[id]->set_interval(buf.value); break;
        case SENSORD_ATTRIBUTE_MAX_BATCH_LATENCY:
-               ret = m_listeners[ch]->set_max_batch_latency(buf.value); break;
+               ret = m_listeners[id]->set_max_batch_latency(buf.value); break;
        case SENSORD_ATTRIBUTE_PASSIVE_MODE:
-               ret = m_listeners[ch]->set_passive_mode(buf.value); break;
+               ret = m_listeners[id]->set_passive_mode(buf.value); break;
        case SENSORD_ATTRIBUTE_PAUSE_POLICY:
        case SENSORD_ATTRIBUTE_AXIS_ORIENTATION:
        default:
-               ret = m_listeners[ch]->set_attribute(buf.attribute, buf.value);
+               ret = m_listeners[id]->set_attribute(buf.attribute, buf.value);
        }
-       retv_if(ret < 0, ret);
+       /* TODO : check return value */
+       if (ret < 0)
+               _W("Return : %d", ret);
 
        return send_reply(ch, OP_SUCCESS);
 }
 
 int server_channel_handler::listener_attr_str(channel *ch, message &msg)
 {
-       auto it = m_listeners.find(ch);
-       retv_if(it == m_listeners.end(), -EINVAL);
-       retvm_if(!has_privileges(ch->get_fd(), m_listeners[ch]->get_required_privileges()),
-                       -EACCES, "Permission denied");
-
        cmd_listener_attr_str_t buf;
        msg.disclose((char *)&buf);
+       uint32_t id = buf.listener_id;
+
+       auto it = m_listeners.find(id);
+       retv_if(it == m_listeners.end(), -EINVAL);
+       retvm_if(!has_privileges(ch->get_fd(), m_listeners[id]->get_required_privileges()),
+                       -EACCES, "Permission denied");
 
-       int ret = m_listeners[ch]->set_attribute(buf.attribute, buf.value, buf.len);
+       int ret = m_listeners[id]->set_attribute(buf.attribute, buf.value, buf.len);
        retv_if(ret < 0, ret);
 
        return send_reply(ch, OP_SUCCESS);

diff --git a/src/server/server_channel_handler.h b/src/server/server_channel_handler.h
index 1ccc998..a2d9fce 100644 (file)
--- a/src/server/server_channel_handler.h
+++ b/src/server/server_channel_handler.h
@@ -67,8 +67,11 @@ private:
 
        sensor_manager *m_manager;
 
-       /* {fd, listener} */
-       std::unordered_map<ipc::channel *, sensor_listener_proxy *> m_listeners;
+       /* {id, listener} */
+       std::unordered_map<uint32_t, sensor_listener_proxy *> m_listeners;
+
+       /* {channel, id} */
+       std::unordered_map<ipc::channel *, uint32_t> m_listener_ids;
 
        /* {name, application_sensor_handler} */
        /* TODO: move it to sensor_manager */