#include <unistd.h>
#include <sensor_log.h>
+#include <message.h>
+#include <command_types.h>
#include <string>
#include <vector>
#include <memory>
#include <algorithm>
#include "sensor_event_handler.h"
-#include "permission_checker.h"
#include "sensor_loader.h"
#include "physical_sensor_handler.h"
#include "fusion_sensor_handler.h"
using namespace sensor;
+#define DEVICE_HAL_DIR_PATH_LEGACY LIBDIR "/sensor"
#define DEVICE_HAL_DIR_PATH LIBDIR "/sensor/hal"
#define PHYSICAL_SENSOR_DIR_PATH LIBDIR "/sensor/physical"
#define VIRTUAL_SENSOR_DIR_PATH LIBDIR "/sensor/fusion"
bool sensor_manager::init(void)
{
+ m_loader.load_hal(DEVICE_HAL_DIR_PATH_LEGACY, devices);
m_loader.load_hal(DEVICE_HAL_DIR_PATH, devices);
m_loader.load_physical_sensor(PHYSICAL_SENSOR_DIR_PATH, physical_sensors);
m_loader.load_fusion_sensor(VIRTUAL_SENSOR_DIR_PATH, fusion_sensors);
m_loader.load_external_sensor(EXTERNAL_SENSOR_DIR_PATH, external_sensors);
- retvm_if(devices.empty(), false, "There is no sensors");
+ retvm_if(devices.empty() && external_sensors.empty(), false, "There is no sensors");
/* TODO: support dynamic sensor */
create_physical_sensors(devices, physical_sensors);
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();
- for (; it != m_sensors.end(); ++it) {
- std::size_t found = it->first.rfind(uri);
- if (found != std::string::npos)
+ for (auto it = m_sensors.begin(); it != m_sensors.end(); ++it) {
+ if (it->first == uri)
+ return it->second;
+
+ std::size_t found = it->first.find_last_of("/");
+ if (found == std::string::npos)
+ continue;
+
+ if (it->first.substr(0, found) == uri)
return it->second;
}
m_sensors[sinfo.get_uri()] = psensor;
}
}
-
}
void sensor_manager::create_fusion_sensors(fusion_sensor_registry_t &fsensors)
{
const sensor_info2_t *info;
+ const required_sensor_s *required_sensors;
fusion_sensor_handler *fsensor;
- std::vector<std::string> req_names;
+ sensor_handler *sensor = NULL;
for (auto it = fsensors.begin(); it != fsensors.end(); ++it) {
- int count = (*it)->get_sensors(&info);
-
- for (int i = 0; i < count; ++i) {
- bool support = true;
- req_names.clear();
+ bool support = true;
- fsensor = new(std::nothrow) fusion_sensor_handler(info[i], it->get());
- retm_if(!fsensor, "Failed to allocate memory");
+ (*it)->get_sensor_info(&info);
- (*it)->get_required_sensors(req_names);
- for (unsigned int j = 0; j < req_names.size(); ++j) {
- sensor_handler *sensor;
- sensor = get_sensor_by_type(req_names[j]);
+ fsensor = new(std::nothrow) fusion_sensor_handler(info[0], it->get());
+ retm_if(!fsensor, "Failed to allocate memory");
- if (sensor == NULL) {
- support = false;
- break;
- }
+ int count = (*it)->get_required_sensors(&required_sensors);
+ for (int i = 0; i < count; ++i) {
+ sensor = get_sensor_by_type(required_sensors[i].uri);
- fsensor->add_required_sensor(sensor);
+ if (sensor == NULL) {
+ support = false;
+ break;
}
- if (!support) {
- delete fsensor;
- /* TODO: remove plugin */
- continue;
- }
+ fsensor->add_required_sensor(required_sensors[i].id, sensor);
+ }
- sensor_info sinfo = fsensor->get_sensor_info();
- m_sensors[sinfo.get_uri()] = fsensor;
+ if (!support) {
+ delete fsensor;
+ continue;
}
+
+ sensor_info sinfo = fsensor->get_sensor_info();
+ m_sensors[sinfo.get_uri()] = fsensor;
}
}
external_sensor_handler *esensor;
for (auto it = esensors.begin(); it != esensors.end(); ++it) {
- int count = (*it)->get_sensors(&info);
+ (*it)->get_sensor_info(&info);
- for (int i = 0; i < count; ++i) {
- esensor = new(std::nothrow) external_sensor_handler(info[i], it->get());
- retm_if(!esensor, "Failed to allocate memory");
+ esensor = new(std::nothrow) external_sensor_handler(info[0], it->get());
+ retm_if(!esensor, "Failed to allocate memory");
- sensor_info sinfo = esensor->get_sensor_info();
- m_sensors[sinfo.get_uri()] = esensor;
- }
+ sensor_info sinfo = esensor->get_sensor_info();
+ m_sensors[sinfo.get_uri()] = esensor;
}
}
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] ...}
*/
size_t sensor_manager::serialize(int sock_fd, char **bytes)
{
- static permission_checker checker;
-
sensor_info info;
std::vector<char> raw_list;
projects / platform / core / system / sensord.git / blobdiff