#include <unistd.h>
#include <sensor_log.h>
+#include <message.h>
+#include <command_types.h>
#include <string>
#include <vector>
#include <memory>
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");
m_sensors[info.get_uri()] = sensor;
+ send_added_msg(&info);
+
_I("Registered[%s]", info.get_uri().c_str());
return true;
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();
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] ...}
*/
#include <vector>
#include <unordered_map>
-#include "event_loop.h"
+#include <channel.h>
+#include <event_loop.h>
#include "sensor_handler.h"
#include "sensor_observer.h"
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);
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;
};
}
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);
}
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:
}
}
+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;
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);