add_definitions(${PLUGIN_DEFS})
-configure_file(sensor_plugin_loader.cpp.in sensor_plugin_loader.cpp)
+configure_file(sensor_loader.cpp.in sensor_loader.cpp)
INCLUDE_DIRECTORIES(include)
FILE(GLOB SERVER_SRCS *.c *.cpp)
*/
#include <command_worker.h>
-#include <sensor_plugin_loader.h>
+#include <sensor_loader.h>
#include <sensor_info.h>
#include <sensor_types.h>
#include <thread>
sensor_info info;
int permission;
- sensors = sensor_plugin_loader::get_instance().get_sensors(ALL_SENSOR);
+ sensors = sensor_loader::get_instance().get_sensors(ALL_SENSOR);
std::sort(sensors.begin(), sensors.end());
auto last = std::unique(sensors.begin(), sensors.end());
if (m_permission == SENSOR_PERMISSION_NONE)
get_client_info_manager().get_permission(m_client_id, m_permission);
- m_module = (sensor_base *)sensor_plugin_loader::get_instance().get_sensor(cmd->sensor);
+ m_module = (sensor_base *)sensor_loader::get_instance().get_sensor(cmd->sensor);
if (!m_module) {
ERR("Sensor type[%d] is not supported", cmd->sensor);
#include <sensor_logs.h>
#include <server.h>
#include <dbus_util.h>
-#include <sensor_plugin_loader.h>
+#include <sensor_loader.h>
#include <string>
using std::string;
signal_init();
- sensor_plugin_loader::get_instance().load_plugins();
+ sensor_loader::get_instance().load_sensors();
server::get_instance().run();
#include <permission_checker.h>
#include <sf_common.h>
#include <sensor_logs.h>
-#include <sensor_plugin_loader.h>
+#include <sensor_loader.h>
#include <sensor_base.h>
static cynara *cynara_env = NULL;
m_permission_infos.push_back(std::make_shared<permission_info> (SENSOR_PERMISSION_BIO, true, "http://tizen.org/privilege/healthinfo"));
std::vector<sensor_base *> sensors;
- sensors = sensor_plugin_loader::get_instance().get_sensors(ALL_SENSOR);
+ sensors = sensor_loader::get_instance().get_sensors(ALL_SENSOR);
for (unsigned int i = 0; i < sensors.size(); ++i)
m_permission_set |= sensors[i]->get_permission();
#define UNKNOWN_NAME "UNKNOWN_SENSOR"
physical_sensor::physical_sensor()
-: m_sensor_hal(NULL)
+: m_sensor_device(NULL)
{
}
return m_handle.event_type;
}
-const char* physical_sensor::get_name()
+const char* physical_sensor::get_name(void)
{
if (m_handle.name.empty())
return UNKNOWN_NAME;
m_handle.properties = handle.properties;
}
-void physical_sensor::set_sensor_hal(sensor_hal *hal)
+void physical_sensor::set_sensor_device(sensor_device *device)
{
- m_sensor_hal = hal;
+ m_sensor_device = device;
}
int physical_sensor::get_poll_fd()
{
AUTOLOCK(m_mutex);
- if (!m_sensor_hal)
+ if (!m_sensor_device)
return -1;
- return m_sensor_hal->get_poll_fd();
+ return m_sensor_device->get_poll_fd();
}
bool physical_sensor::on_start()
{
AUTOLOCK(m_mutex);
- return m_sensor_hal->enable(m_handle.id);
+ return m_sensor_device->enable(m_handle.id);
}
bool physical_sensor::on_stop()
{
AUTOLOCK(m_mutex);
- return m_sensor_hal->disable(m_handle.id);
+ return m_sensor_device->disable(m_handle.id);
}
long physical_sensor::set_command(unsigned int cmd, long value)
{
AUTOLOCK(m_mutex);
- return m_sensor_hal->set_command(m_handle.id, std::to_string(cmd), std::to_string(value));
+ return m_sensor_device->set_command(m_handle.id, std::to_string(cmd), std::to_string(value));
}
bool physical_sensor::set_interval(unsigned long interval)
INFO("Polling interval is set to %dms", interval);
- return m_sensor_hal->set_interval(m_handle.id, interval);
+ return m_sensor_device->set_interval(m_handle.id, interval);
}
bool physical_sensor::set_batch(unsigned long latency)
INFO("Polling interval is set to %dms", latency);
- return m_sensor_hal->set_batch_latency(m_handle.id, latency);
+ return m_sensor_device->set_batch_latency(m_handle.id, latency);
}
bool physical_sensor::set_wakeup(int wakeup)
{
AUTOLOCK(m_mutex);
- return m_sensor_hal->is_data_ready();
+ return m_sensor_device->is_data_ready();
}
int physical_sensor::get_sensor_data(sensor_data_t &data)
{
AUTOLOCK(m_mutex);
- if (!m_sensor_hal->get_sensor_data(m_handle.id, data)) {
+ if (!m_sensor_device->get_sensor_data(m_handle.id, data)) {
ERR("Failed to get sensor data");
return -1;
}
AUTOLOCK(m_mutex);
int event_length = -1;
- event_length = m_sensor_hal->get_sensor_event(m_handle.id, event);
+ event_length = m_sensor_device->get_sensor_event(m_handle.id, event);
if (event_length < 0) {
ERR("Failed to get sensor event");
bool physical_sensor::get_properties(sensor_properties_s &properties)
{
- return m_sensor_hal->get_properties(m_handle.id, properties);
+ return m_sensor_device->get_properties(m_handle.id, properties);
}
/* setting module */
void set_sensor_handle(sensor_handle_t handle);
- void set_sensor_hal(sensor_hal *hal);
+ void set_sensor_device(sensor_device *device);
/* module info */
- virtual sensor_type_t get_type();
+ virtual sensor_type_t get_type(void);
virtual unsigned int get_event_type(void);
virtual const char* get_name(void);
private:
sensor_handle_t m_handle;
- sensor_hal *m_sensor_hal;
+ sensor_device *m_sensor_device;
virtual bool set_interval(unsigned long interval);
virtual bool set_wakeup(int wakeup);
virtual bool set_batch(unsigned long latency);
- virtual bool on_start();
- virtual bool on_stop();
+ virtual bool on_start(void);
+ virtual bool on_stop(void);
virtual long set_command(unsigned int cmd, long value);
virtual bool get_properties(sensor_properties_s &properties);
};
#include <virtual_sensor.h>
#include <auto_rotation_sensor.h>
-#include <sensor_plugin_loader.h>
+#include <sensor_loader.h>
#include <virtual_sensor_config.h>
#include <auto_rotation_alg.h>
#include <auto_rotation_alg_emul.h>
bool auto_rotation_sensor::init()
{
- m_accel_sensor = sensor_plugin_loader::get_instance().get_sensor(ACCELEROMETER_SENSOR);
+ m_accel_sensor = sensor_loader::get_instance().get_sensor(ACCELEROMETER_SENSOR);
if (!m_accel_sensor) {
ERR("cannot load accel sensor_hal[%s]", sensor_base::get_name());
#include <sensor_logs.h>
#include <sf_common.h>
#include <fusion_sensor.h>
-#include <sensor_plugin_loader.h>
+#include <sensor_loader.h>
#include <orientation_filter.h>
#include <virtual_sensor_config.h>
#include <algorithm>
bool fusion_sensor::init(void)
{
- m_accel_sensor = sensor_plugin_loader::get_instance().get_sensor(ACCELEROMETER_SENSOR);
- m_gyro_sensor = sensor_plugin_loader::get_instance().get_sensor(GYROSCOPE_SENSOR);
- m_magnetic_sensor = sensor_plugin_loader::get_instance().get_sensor(GEOMAGNETIC_SENSOR);
+ m_accel_sensor = sensor_loader::get_instance().get_sensor(ACCELEROMETER_SENSOR);
+ m_gyro_sensor = sensor_loader::get_instance().get_sensor(GYROSCOPE_SENSOR);
+ m_magnetic_sensor = sensor_loader::get_instance().get_sensor(GEOMAGNETIC_SENSOR);
if (!m_accel_sensor) {
ERR("Failed to load accel sensor: 0x%x", m_accel_sensor);
#include <sensor_logs.h>
#include <sf_common.h>
#include <gravity_sensor.h>
-#include <sensor_plugin_loader.h>
+#include <sensor_loader.h>
#include <virtual_sensor_config.h>
using std::string;
{
virtual_sensor_config &config = virtual_sensor_config::get_instance();
- sensor_hal *fusion_sensor_hal = sensor_plugin_loader::get_instance().get_sensor_hal(SENSOR_HAL_TYPE_FUSION);
+ sensor_hal *fusion_sensor_hal = sensor_loader::get_instance().get_sensor_hal(SENSOR_HAL_TYPE_FUSION);
if (!fusion_sensor_hal)
m_hardware_fusion = false;
else
bool gravity_sensor::init()
{
- m_accel_sensor = sensor_plugin_loader::get_instance().get_sensor(ACCELEROMETER_SENSOR);
- m_gyro_sensor = sensor_plugin_loader::get_instance().get_sensor(GYROSCOPE_SENSOR);
- m_magnetic_sensor = sensor_plugin_loader::get_instance().get_sensor(GEOMAGNETIC_SENSOR);
+ m_accel_sensor = sensor_loader::get_instance().get_sensor(ACCELEROMETER_SENSOR);
+ m_gyro_sensor = sensor_loader::get_instance().get_sensor(GYROSCOPE_SENSOR);
+ m_magnetic_sensor = sensor_loader::get_instance().get_sensor(GEOMAGNETIC_SENSOR);
- m_fusion_sensor = sensor_plugin_loader::get_instance().get_sensor(FUSION_SENSOR);
+ m_fusion_sensor = sensor_loader::get_instance().get_sensor(FUSION_SENSOR);
if (!m_accel_sensor || !m_gyro_sensor || !m_magnetic_sensor || !m_fusion_sensor) {
ERR("Failed to load sensors, accel: 0x%x, gyro: 0x%x, mag: 0x%x, fusion: 0x%x",
#include <sensor_logs.h>
#include <sf_common.h>
#include <linear_accel_sensor.h>
-#include <sensor_plugin_loader.h>
+#include <sensor_loader.h>
#include <virtual_sensor_config.h>
using std::string;
m_enable_linear_accel = 0;
register_supported_event(LINEAR_ACCEL_RAW_DATA_EVENT);
- sensor_hal *fusion_sensor_hal = sensor_plugin_loader::get_instance().get_sensor_hal(SENSOR_HAL_TYPE_FUSION);
+ sensor_hal *fusion_sensor_hal = sensor_loader::get_instance().get_sensor_hal(SENSOR_HAL_TYPE_FUSION);
if (!fusion_sensor_hal)
m_hardware_fusion = false;
else
bool linear_accel_sensor::init()
{
- m_accel_sensor = sensor_plugin_loader::get_instance().get_sensor(ACCELEROMETER_SENSOR);
- m_gyro_sensor = sensor_plugin_loader::get_instance().get_sensor(GYROSCOPE_SENSOR);
- m_magnetic_sensor = sensor_plugin_loader::get_instance().get_sensor(GEOMAGNETIC_SENSOR);
+ m_accel_sensor = sensor_loader::get_instance().get_sensor(ACCELEROMETER_SENSOR);
+ m_gyro_sensor = sensor_loader::get_instance().get_sensor(GYROSCOPE_SENSOR);
+ m_magnetic_sensor = sensor_loader::get_instance().get_sensor(GEOMAGNETIC_SENSOR);
- m_fusion_sensor = sensor_plugin_loader::get_instance().get_sensor(FUSION_SENSOR);
+ m_fusion_sensor = sensor_loader::get_instance().get_sensor(FUSION_SENSOR);
if (!m_accel_sensor || !m_gyro_sensor || !m_magnetic_sensor || !m_fusion_sensor) {
ERR("Failed to load sensors, accel: 0x%x, gyro: 0x%x, mag: 0x%x, fusion: 0x%x",
#include <sensor_logs.h>
#include <sf_common.h>
#include <orientation_sensor.h>
-#include <sensor_plugin_loader.h>
+#include <sensor_loader.h>
#include <orientation_filter.h>
#include <virtual_sensor_config.h>
{
virtual_sensor_config &config = virtual_sensor_config::get_instance();
- sensor_hal *fusion_sensor_hal = sensor_plugin_loader::get_instance().get_sensor_hal(SENSOR_HAL_TYPE_FUSION);
+ sensor_hal *fusion_sensor_hal = sensor_loader::get_instance().get_sensor_hal(SENSOR_HAL_TYPE_FUSION);
if (!fusion_sensor_hal)
m_hardware_fusion = false;
else
bool orientation_sensor::init(void)
{
- m_accel_sensor = sensor_plugin_loader::get_instance().get_sensor(ACCELEROMETER_SENSOR);
- m_gyro_sensor = sensor_plugin_loader::get_instance().get_sensor(GYROSCOPE_SENSOR);
- m_magnetic_sensor = sensor_plugin_loader::get_instance().get_sensor(GEOMAGNETIC_SENSOR);
+ m_accel_sensor = sensor_loader::get_instance().get_sensor(ACCELEROMETER_SENSOR);
+ m_gyro_sensor = sensor_loader::get_instance().get_sensor(GYROSCOPE_SENSOR);
+ m_magnetic_sensor = sensor_loader::get_instance().get_sensor(GEOMAGNETIC_SENSOR);
- m_fusion_sensor = sensor_plugin_loader::get_instance().get_sensor(FUSION_SENSOR);
+ m_fusion_sensor = sensor_loader::get_instance().get_sensor(FUSION_SENSOR);
if (!m_accel_sensor || !m_gyro_sensor || !m_magnetic_sensor || !m_fusion_sensor) {
ERR("Failed to load sensors, accel: 0x%x, gyro: 0x%x, mag: 0x%x, fusion: 0x%x",
#include <sensor_logs.h>
#include <sf_common.h>
#include <gaming_rv_sensor.h>
-#include <sensor_plugin_loader.h>
+#include <sensor_loader.h>
#include <orientation_filter.h>
#include <virtual_sensor_config.h>
{
virtual_sensor_config &config = virtual_sensor_config::get_instance();
- sensor_hal *fusion_sensor_hal = sensor_plugin_loader::get_instance().get_sensor_hal(SENSOR_HAL_TYPE_FUSION);
+ sensor_hal *fusion_sensor_hal = sensor_loader::get_instance().get_sensor_hal(SENSOR_HAL_TYPE_FUSION);
if (!fusion_sensor_hal)
m_hardware_fusion = false;
else
bool gaming_rv_sensor::init()
{
- m_accel_sensor = sensor_plugin_loader::get_instance().get_sensor(ACCELEROMETER_SENSOR);
- m_gyro_sensor = sensor_plugin_loader::get_instance().get_sensor(GYROSCOPE_SENSOR);
+ m_accel_sensor = sensor_loader::get_instance().get_sensor(ACCELEROMETER_SENSOR);
+ m_gyro_sensor = sensor_loader::get_instance().get_sensor(GYROSCOPE_SENSOR);
if (!m_accel_sensor || !m_gyro_sensor) {
ERR("Failed to load sensors, accel: 0x%x, gyro: 0x%x",
#include <sensor_logs.h>
#include <sf_common.h>
#include <geomagnetic_rv_sensor.h>
-#include <sensor_plugin_loader.h>
+#include <sensor_loader.h>
#include <orientation_filter.h>
#include <virtual_sensor_config.h>
{
virtual_sensor_config &config = virtual_sensor_config::get_instance();
- sensor_hal *fusion_sensor_hal = sensor_plugin_loader::get_instance().get_sensor_hal(SENSOR_HAL_TYPE_FUSION);
+ sensor_hal *fusion_sensor_hal = sensor_loader::get_instance().get_sensor_hal(SENSOR_HAL_TYPE_FUSION);
if (!fusion_sensor_hal)
m_hardware_fusion = false;
else
bool geomagnetic_rv_sensor::init()
{
- m_accel_sensor = sensor_plugin_loader::get_instance().get_sensor(ACCELEROMETER_SENSOR);
- m_magnetic_sensor = sensor_plugin_loader::get_instance().get_sensor(GEOMAGNETIC_SENSOR);
+ m_accel_sensor = sensor_loader::get_instance().get_sensor(ACCELEROMETER_SENSOR);
+ m_magnetic_sensor = sensor_loader::get_instance().get_sensor(GEOMAGNETIC_SENSOR);
- m_fusion_sensor = sensor_plugin_loader::get_instance().get_sensor(FUSION_SENSOR);
+ m_fusion_sensor = sensor_loader::get_instance().get_sensor(FUSION_SENSOR);
if (!m_accel_sensor || !m_magnetic_sensor || !m_fusion_sensor) {
ERR("Failed to load sensors, accel: 0x%x, mag: 0x%x, fusion: 0x%x",
#include <sensor_logs.h>
#include <sf_common.h>
#include <rv_sensor.h>
-#include <sensor_plugin_loader.h>
+#include <sensor_loader.h>
#include <orientation_filter.h>
#include <virtual_sensor_config.h>
virtual_sensor_config &config = virtual_sensor_config::get_instance();
// Will check if fusion_sensor is in the list of hal sensors.
- sensor_hal *fusion_sensor_hal = sensor_plugin_loader::get_instance().get_sensor_hal(SENSOR_HAL_TYPE_FUSION);
+ sensor_hal *fusion_sensor_hal = sensor_loader::get_instance().get_sensor_hal(SENSOR_HAL_TYPE_FUSION);
if (!fusion_sensor_hal)
m_hardware_fusion = false;
else
bool rv_sensor::init()
{
- m_accel_sensor = sensor_plugin_loader::get_instance().get_sensor(ACCELEROMETER_SENSOR);
- m_gyro_sensor = sensor_plugin_loader::get_instance().get_sensor(GYROSCOPE_SENSOR);
- m_magnetic_sensor = sensor_plugin_loader::get_instance().get_sensor(GEOMAGNETIC_SENSOR);
+ m_accel_sensor = sensor_loader::get_instance().get_sensor(ACCELEROMETER_SENSOR);
+ m_gyro_sensor = sensor_loader::get_instance().get_sensor(GYROSCOPE_SENSOR);
+ m_magnetic_sensor = sensor_loader::get_instance().get_sensor(GEOMAGNETIC_SENSOR);
- m_fusion_sensor = sensor_plugin_loader::get_instance().get_sensor(FUSION_SENSOR);
+ m_fusion_sensor = sensor_loader::get_instance().get_sensor(FUSION_SENSOR);
if (!m_accel_sensor || !m_gyro_sensor || !m_magnetic_sensor || !m_fusion_sensor) {
ERR("Failed to load sensors, accel: 0x%x, gyro: 0x%x, mag: 0x%x, fusion: 0x%x",
#include <sensor_logs.h>
#include <sf_common.h>
#include <tilt_sensor.h>
-#include <sensor_plugin_loader.h>
+#include <sensor_loader.h>
#include <orientation_filter.h>
#include <virtual_sensor_config.h>
bool tilt_sensor::init(void)
{
- m_accel_sensor = sensor_plugin_loader::get_instance().get_sensor(ACCELEROMETER_SENSOR);
- m_fusion_sensor = sensor_plugin_loader::get_instance().get_sensor(FUSION_SENSOR);
+ m_accel_sensor = sensor_loader::get_instance().get_sensor(ACCELEROMETER_SENSOR);
+ m_fusion_sensor = sensor_loader::get_instance().get_sensor(FUSION_SENSOR);
if (!m_accel_sensor || !m_fusion_sensor) {
ERR("Failed to load sensors, accel: 0x%x, fusion: 0x%x",
#include <sensor_base.h>
#include <physical_sensor.h>
#include <sensor_event_poller.h>
-#include <sensor_plugin_loader.h>
+#include <sensor_loader.h>
#define EPOLL_MAX_FD 32
physical_sensor *sensor;
std::vector<sensor_base *> sensors;
- sensors = sensor_plugin_loader::get_instance().get_sensors(ALL_SENSOR);
+ sensors = sensor_loader::get_instance().get_sensors(ALL_SENSOR);
auto it_sensor = sensors.begin();
void sensor_event_poller::init_fd()
{
- fd_sensor_plugins::iterator it;
+ fd_sensors_t::iterator it;
for (it = m_fd_sensors.begin(); it != m_fd_sensors.end(); it = m_fd_sensors.upper_bound(it->first)) {
if (!add_poll_fd(it->first))
continue;
bool sensor_event_poller::is_data_ready(int fd)
{
- fd_sensor_plugins::iterator it;
+ fd_sensors_t::iterator it;
physical_sensor *sensor;
it = m_fd_sensors.find(fd);
sensor = dynamic_cast<physical_sensor *>(it->second);
if (!sensor) {
- ERR("Failed to get sensor plugin");
+ ERR("Failed to get sensor");
return false;
}
bool sensor_event_poller::process_event(int fd)
{
physical_sensor *sensor;
- std::pair<fd_sensor_plugins::iterator, fd_sensor_plugins::iterator> ret;
+ std::pair<fd_sensors_t::iterator, fd_sensors_t::iterator> ret;
ret = m_fd_sensors.equal_range(fd);
#include <poller.h>
#include <physical_sensor.h>
-typedef std::multimap<int, physical_sensor *> fd_sensor_plugins;
+typedef std::multimap<int, physical_sensor *> fd_sensors_t;
class sensor_event_poller {
public:
bool poll();
private:
poller m_poller;
- fd_sensor_plugins m_fd_sensors;
+ fd_sensors_t m_fd_sensors;
void init_fd();
void init_sensor_map();
--- /dev/null
+/*
+ * libsensord-share
+ *
+ * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <sensor_loader.h>
+#include <libxml/xmlmemory.h>
+#include <libxml/parser.h>
+#include <sensor_hal.h>
+#include <sensor_base.h>
+#include <physical_sensor.h>
+#include <dlfcn.h>
+#include <dirent.h>
+#include <sensor_logs.h>
+#include <unordered_set>
+#include <algorithm>
+
+#ifdef ENABLE_AUTO_ROTATION
+#include <auto_rotation_sensor.h>
+#endif
+
+using std::vector;
+using std::string;
+
+#define DEVICE_PLUGINS_DIR_PATH "/usr/lib/sensor"
+#define SENSOR_INDEX_SHIFT 16
+
+sensor_loader::sensor_loader()
+{
+}
+
+sensor_loader& sensor_loader::get_instance()
+{
+ static sensor_loader inst;
+ return inst;
+}
+
+bool sensor_loader::load_devices(const string &path, vector<void*> &devices, void* &handle)
+{
+ INFO("load device: [%s]", path.c_str());
+
+ void *_handle = dlopen(path.c_str(), RTLD_NOW);
+
+ if (!_handle) {
+ ERR("Failed to dlopen(%s), dlerror : %s", path.c_str(), dlerror());
+ return false;
+ }
+
+ dlerror();
+
+ create_t create_devices = (create_t) dlsym(_handle, "create");
+
+ if (!create_devices) {
+ ERR("Failed to find symbols in %s", path.c_str());
+ dlclose(_handle);
+ return false;
+ }
+
+ sensor_devices *_devices = create_devices();
+
+ if (!_devices) {
+ ERR("Failed to create devices, path is %s\n", path.c_str());
+ dlclose(_handle);
+ return false;
+ }
+
+ devices.clear();
+ devices.swap(_devices->devices);
+
+ delete _devices;
+ handle = _handle;
+
+ return true;
+}
+
+physical_sensor* sensor_loader::create_sensor(sensor_handle_t handle, sensor_device *device)
+{
+ int index;
+ physical_sensor *sensor;
+
+ index = m_sensors.count(handle.type);
+
+ sensor = new(std::nothrow) physical_sensor();
+ if (!sensor) {
+ ERR("Memory allocation failed[%s]", handle.name.c_str());
+ return NULL;
+ }
+
+ sensor->set_id(index << SENSOR_INDEX_SHIFT | handle.type);
+ sensor->set_sensor_handle(handle);
+ sensor->set_sensor_device(device);
+
+ return sensor;
+}
+
+bool sensor_loader::insert_sensors(std::vector<void *> devices)
+{
+ sensor_device *device;
+ vector<sensor_handle_t> handles;
+ physical_sensor *sensor;
+
+ for (void *device_ptr : devices) {
+ device = static_cast<sensor_device *>(device_ptr);
+ device->get_sensors(handles);
+
+ for (unsigned int i = 0; i < handles.size(); ++i) {
+ sensor = create_sensor(handles[i], device);
+ if (!sensor)
+ continue;
+
+ std::shared_ptr<sensor_base> sensor_ptr(sensor);
+ m_sensors.insert(std::make_pair(handles[i].type, sensor_ptr));
+
+ INFO("inserted [%s] sensor", sensor->get_name());
+ }
+ }
+
+ return true;
+}
+
+bool sensor_loader::load_sensors(void)
+{
+ vector<string> device_plugin_paths;
+ vector<string> unique_device_plugin_paths;
+
+ get_paths_from_dir(string(DEVICE_PLUGINS_DIR_PATH), device_plugin_paths);
+
+ std::unordered_set<string> s;
+ auto unique = [&s](vector<string> &paths, const string &path) {
+ if (s.insert(path).second)
+ paths.push_back(path);
+ };
+
+ for_each(device_plugin_paths.begin(), device_plugin_paths.end(),
+ [&](const string &path) {
+ unique(unique_device_plugin_paths, path);
+ }
+ );
+
+ for_each(unique_device_plugin_paths.begin(), unique_device_plugin_paths.end(),
+ [&](const string &path) {
+ void *handle;
+ std::vector<void *> devices;
+
+ load_devices(path, devices, handle);
+ insert_sensors(devices);
+ }
+ );
+
+#ifdef ENABLE_AUTO_ROTATION
+ auto_rotation_sensor* auto_rot_sensor_ptr = NULL;
+ try {
+ auto_rot_sensor_ptr = new(std::nothrow) auto_rotation_sensor;
+ } catch (int err) {
+ ERR("Failed to create auto_rotation_sensor, err: %d, cause: %s", err, strerror(err));
+ }
+ if (auto_rot_sensor_ptr != NULL) {
+ std::shared_ptr<sensor_base> sensor(auto_rot_sensor_ptr);
+ sensor_device_type type;
+
+ type = static_cast<sensor_device_type>(sensor->get_type());
+ sensor->set_id(type);
+
+ m_sensors.insert(std::make_pair(type, sensor));
+ }
+#endif
+
+ show_sensor_info();
+ return true;
+}
+
+void sensor_loader::show_sensor_info(void)
+{
+ INFO("========== Loaded sensor information ==========\n");
+
+ int index = 0;
+
+ auto it = m_sensors.begin();
+
+ while (it != m_sensors.end()) {
+ sensor_base *sensor = it->second.get();
+
+ sensor_info info;
+ sensor->get_sensor_info(info);
+ INFO("No:%d [%s]\n", ++index, sensor->get_name());
+ info.show();
+ it++;
+ }
+
+ INFO("===============================================\n");
+}
+
+bool sensor_loader::get_paths_from_dir(const string &dir_path, vector<string> &plugin_paths)
+{
+ DIR *dir = NULL;
+ struct dirent *dir_entry = NULL;
+
+ dir = opendir(dir_path.c_str());
+
+ if (!dir) {
+ ERR("Failed to open dir: %s", dir_path.c_str());
+ return false;
+ }
+
+ string name;
+
+ while ((dir_entry = readdir(dir))) {
+ name = string(dir_entry->d_name);
+ plugin_paths.push_back(dir_path + "/" + name);
+ }
+
+ closedir(dir);
+ return true;
+}
+
+sensor_base* sensor_loader::get_sensor(sensor_type_t type)
+{
+ auto it_plugins = m_sensors.find(static_cast<sensor_device_type>(type));
+
+ if (it_plugins == m_sensors.end())
+ return NULL;
+
+ return it_plugins->second.get();
+}
+
+sensor_base* sensor_loader::get_sensor(sensor_id_t id)
+{
+ vector<sensor_base *> sensors;
+
+ sensor_type_t type = static_cast<sensor_type_t> (id & SENSOR_TYPE_MASK);
+ unsigned int index = id >> SENSOR_INDEX_SHIFT;
+
+ sensors = get_sensors(type);
+
+ if (sensors.size() <= index)
+ return NULL;
+
+ return sensors[index];
+}
+
+vector<sensor_base *> sensor_loader::get_sensors(sensor_type_t type)
+{
+ vector<sensor_base *> sensor_list;
+ std::pair<sensor_map_t::iterator, sensor_map_t::iterator> ret;
+
+ if ((int)(type) == (int)SENSOR_DEVICE_ALL)
+ ret = std::make_pair(m_sensors.begin(), m_sensors.end());
+ else
+ ret = m_sensors.equal_range(static_cast<sensor_device_type>(type));
+
+ for (auto it = ret.first; it != ret.second; ++it)
+ sensor_list.push_back(it->second.get());
+
+ return sensor_list;
+}
+
+vector<sensor_base *> sensor_loader::get_virtual_sensors(void)
+{
+ vector<sensor_base *> virtual_list;
+ sensor_base* sensor;
+
+ for (auto sensor_it = m_sensors.begin(); sensor_it != m_sensors.end(); ++sensor_it) {
+ sensor = sensor_it->second.get();
+
+ if (sensor && sensor->is_virtual() == true) {
+ virtual_list.push_back(sensor);
+ }
+ }
+
+ return virtual_list;
+}
#include <map>
#include <set>
#include <memory>
+#include <physical_sensor.h>
class sensor_hal;
class sensor_base;
-typedef std::multimap<sensor_hal_type, std::shared_ptr<sensor_base>> sensor_plugins;
+typedef std::multimap<sensor_device_type, std::shared_ptr<sensor_base>> sensor_map_t;
-class sensor_plugin_loader
+class sensor_loader
{
private:
- sensor_plugin_loader();
+ sensor_loader();
- bool load_plugin(const std::string &path, std::vector<void *> &sensors, void* &handle);
- bool insert_plugins(std::vector<void *> hals);
- bool insert_sensors(sensor_hal *hal);
+ bool load_devices(const std::string &path, std::vector<void *> &devices, void* &handle);
+ physical_sensor* create_sensor(sensor_handle_t handle, sensor_device *device);
+ bool insert_sensors(std::vector<void *> hals);
void show_sensor_info(void);
bool get_paths_from_dir(const std::string &dir_path, std::vector<std::string> &hal_paths);
- sensor_plugins m_sensors;
+ sensor_map_t m_sensors;
public:
- static sensor_plugin_loader& get_instance();
- bool load_plugins(void);
+ static sensor_loader& get_instance();
+ bool load_sensors(void);
sensor_base* get_sensor(sensor_type_t type);
sensor_base* get_sensor(sensor_id_t id);
std::vector<sensor_base *> get_sensors(sensor_type_t type);
- std::vector<sensor_base*> get_virtual_sensors(void);
+ std::vector<sensor_base *> get_virtual_sensors(void);
};
#endif /* _SENSOR_PLUGIN_LOADER_H_ */
+++ /dev/null
-/*
- * libsensord-share
- *
- * Copyright (c) 2014 Samsung Electronics Co., Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- */
-
-#include <sensor_plugin_loader.h>
-#include <libxml/xmlmemory.h>
-#include <libxml/parser.h>
-#include <sensor_hal.h>
-#include <sensor_base.h>
-#include <physical_sensor.h>
-#include <dlfcn.h>
-#include <dirent.h>
-#include <sensor_logs.h>
-#include <unordered_set>
-#include <algorithm>
-
-#ifdef ENABLE_AUTO_ROTATION
-#include <auto_rotation_sensor.h>
-#endif
-/*
-#ifdef ENABLE_TILT
-#include <tilt_sensor.h>
-#endif
-#ifdef ENABLE_GRAVITY
-#include <gravity_sensor.h>
-#endif
-#ifdef ENABLE_SENSOR_FUSION
-#include <fusion_sensor.h>
-#endif
-#ifdef ENABLE_LINEAR_ACCEL
-#include <linear_accel_sensor.h>
-#endif
-#ifdef ENABLE_ORIENTATION
-#include <orientation_sensor.h>
-#endif
-#ifdef ENABLE_GAMING_RV
-#include <gaming_rv_sensor.h>
-#endif
-#ifdef ENABLE_GEOMAGNETIC_RV
-#include <geomagnetic_rv_sensor.h>
-#endif
-#ifdef ENABLE_RV
-#include <rv_sensor.h>
-#endif
-#ifdef ENABLE_GYROSCOPE_UNCAL
-#include <gyroscope_uncal_sensor.h>
-#endif
-*/
-
-using std::unordered_set;
-using std::vector;
-using std::string;
-
-#define ROOT_ELEMENT "PLUGIN"
-#define TEXT_ELEMENT "text"
-#define PATH_ATTR "path"
-#define HAL_ELEMENT "HAL"
-#define SENSOR_ELEMENT "SENSOR"
-
-#define HAL_PLUGINS_DIR_PATH "/usr/lib/sensor"
-
-#define SENSOR_INDEX_SHIFT 16
-
-sensor_plugin_loader::sensor_plugin_loader()
-{
-}
-
-sensor_plugin_loader& sensor_plugin_loader::get_instance()
-{
- static sensor_plugin_loader inst;
- return inst;
-}
-
-bool sensor_plugin_loader::load_plugin(const string &path, vector<void*> &sensors, void* &handle)
-{
- INFO("load HAL plugin [%s]", path.c_str());
-
- void *_handle = dlopen(path.c_str(), RTLD_NOW);
-
- if (!_handle) {
- ERR("Failed to dlopen(%s), dlerror : %s", path.c_str(), dlerror());
- return false;
- }
-
- dlerror();
-
- create_t create_plugin = (create_t) dlsym(_handle, "create");
-
- if (!create_plugin) {
- ERR("Failed to find symbols in %s", path.c_str());
- dlclose(_handle);
- return false;
- }
-
- sensor_module *plugin = create_plugin();
-
- if (!plugin) {
- ERR("Failed to create plugin, path is %s\n", path.c_str());
- dlclose(_handle);
- return false;
- }
-
- sensors.clear();
- sensors.swap(plugin->sensors);
-
- delete plugin;
- handle = _handle;
-
- return true;
-}
-
-bool sensor_plugin_loader::insert_plugins(std::vector<void *> hals)
-{
- unsigned int i;
- sensor_hal *hal;
-
- for (i = 0; i < hals.size(); ++i) {
- hal = static_cast<sensor_hal *>(hals[i]);
-
- insert_sensors(hal);
- }
-
- return true;
-}
-
-bool sensor_plugin_loader::insert_sensors(sensor_hal *hal)
-{
- unsigned int i;
- vector<sensor_handle_t> sensors;
- physical_sensor *phy_sensor;
-
- hal->get_sensors(sensors);
-
- for (i = 0; i < sensors.size(); ++i) {
- int idx;
- idx = m_sensors.count(sensors[i].type);
-
- phy_sensor = new(std::nothrow) physical_sensor();
- if (!phy_sensor) {
- ERR("Memory allocation failed[%s]", sensors[i].name.c_str());
- continue;
- }
-
- phy_sensor->set_id(idx << SENSOR_INDEX_SHIFT | sensors[i].type);
- phy_sensor->set_sensor_handle(sensors[i]);
- phy_sensor->set_sensor_hal(hal);
-
- std::shared_ptr<sensor_base> sensor(phy_sensor);
- m_sensors.insert(std::make_pair(sensors[i].type, sensor));
-
- INFO("created [%s] sensor", sensor->get_name());
- }
-
- return true;
-}
-
-bool sensor_plugin_loader::load_plugins(void)
-{
- vector<string> hal_paths;
- vector<string> unique_hal_paths;
-
- get_paths_from_dir(string(HAL_PLUGINS_DIR_PATH), hal_paths);
-
- unordered_set<string> s;
- auto unique = [&s](vector<string> &paths, const string &path) {
- if (s.insert(path).second)
- paths.push_back(path);
- };
-
- for_each(hal_paths.begin(), hal_paths.end(),
- [&](const string &path) {
- unique(unique_hal_paths, path);
- }
- );
-
- for_each(unique_hal_paths.begin(), unique_hal_paths.end(),
- [&](const string &path) {
- void *handle;
- std::vector<void *> hals;
-
- load_plugin(path, hals, handle);
- insert_plugins(hals);
- }
- );
-
-#ifdef ENABLE_AUTO_ROTATION
- auto_rotation_sensor* auto_rot_sensor_ptr = NULL;
- try {
- auto_rot_sensor_ptr = new(std::nothrow) auto_rotation_sensor;
- } catch (int err) {
- ERR("Failed to create auto_rotation_sensor module, err: %d, cause: %s", err, strerror(err));
- }
- if (auto_rot_sensor_ptr != NULL) {
- std::shared_ptr<sensor_base> sensor(auto_rot_sensor_ptr);
- sensor_hal_type type;
-
- type = static_cast<sensor_hal_type>(sensor->get_type());
- sensor->set_id(type);
-
- m_sensors.insert(std::make_pair(type, sensor));
- }
-#endif
-
- show_sensor_info();
- return true;
-}
-
-void sensor_plugin_loader::show_sensor_info(void)
-{
- INFO("========== Loaded sensor information ==========\n");
-
- int index = 0;
-
- auto it = m_sensors.begin();
-
- while (it != m_sensors.end()) {
- sensor_base *sensor = it->second.get();
-
- sensor_info info;
- sensor->get_sensor_info(info);
- INFO("No:%d [%s]\n", ++index, sensor->get_name());
- info.show();
- it++;
- }
-
- INFO("===============================================\n");
-}
-
-bool sensor_plugin_loader::get_paths_from_dir(const string &dir_path, vector<string> &hal_paths)
-{
- DIR *dir = NULL;
- struct dirent *dir_entry = NULL;
-
- dir = opendir(dir_path.c_str());
-
- if (!dir) {
- ERR("Failed to open dir: %s", dir_path.c_str());
- return false;
- }
-
- string name;
-
- while ((dir_entry = readdir(dir))) {
- name = string(dir_entry->d_name);
- hal_paths.push_back(dir_path + "/" + name);
- }
-
- closedir(dir);
- return true;
-}
-
-sensor_base* sensor_plugin_loader::get_sensor(sensor_type_t type)
-{
- auto it_plugins = m_sensors.find(static_cast<sensor_hal_type>(type));
-
- if (it_plugins == m_sensors.end())
- return NULL;
-
- return it_plugins->second.get();
-}
-
-sensor_base* sensor_plugin_loader::get_sensor(sensor_id_t id)
-{
- vector<sensor_base *> sensors;
-
- sensor_type_t type = static_cast<sensor_type_t> (id & SENSOR_TYPE_MASK);
- unsigned int index = id >> SENSOR_INDEX_SHIFT;
-
- sensors = get_sensors(type);
-
- if (sensors.size() <= index)
- return NULL;
-
- return sensors[index];
-}
-
-vector<sensor_base *> sensor_plugin_loader::get_sensors(sensor_type_t type)
-{
- vector<sensor_base *> sensor_list;
- std::pair<sensor_plugins::iterator, sensor_plugins::iterator> ret;
-
- if ((int)(type) == (int)SENSOR_HAL_TYPE_ALL)
- ret = std::make_pair(m_sensors.begin(), m_sensors.end());
- else
- ret = m_sensors.equal_range(static_cast<sensor_hal_type>(type));
-
- for (auto it = ret.first; it != ret.second; ++it)
- sensor_list.push_back(it->second.get());
-
- return sensor_list;
-}
-
-vector<sensor_base *> sensor_plugin_loader::get_virtual_sensors(void)
-{
- vector<sensor_base *> virtual_list;
- sensor_base* sensor;
-
- for (auto sensor_it = m_sensors.begin(); sensor_it != m_sensors.end(); ++sensor_it) {
- sensor = sensor_it->second.get();
-
- if (sensor && sensor->is_virtual() == true) {
- virtual_list.push_back(sensor);
- }
- }
-
- return virtual_list;
-}
#include <systemd/sd-daemon.h>
#include <server.h>
-#include <sensor_plugin_loader.h>
+#include <sensor_loader.h>
#include <command_worker.h>
#include <thread>
#include <sys/epoll.h>
* humidity : relative humidity (%)
*/
typedef enum {
- SENSOR_HAL_TYPE_UNKNOWN = -2,
- SENSOR_HAL_TYPE_ALL = -1,
- SENSOR_HAL_TYPE_ACCELEROMETER,
- SENSOR_HAL_TYPE_GRAVITY,
- SENSOR_HAL_TYPE_LINEAR_ACCELERATION,
- SENSOR_HAL_TYPE_GEOMAGNETIC,
- SENSOR_HAL_TYPE_ROTATION_VECTOR,
- SENSOR_HAL_TYPE_ORIENTATION,
- SENSOR_HAL_TYPE_GYROSCOPE,
- SENSOR_HAL_TYPE_LIGHT,
- SENSOR_HAL_TYPE_PROXIMITY,
- SENSOR_HAL_TYPE_PRESSURE,
- SENSOR_HAL_TYPE_ULTRAVIOLET,
- SENSOR_HAL_TYPE_TEMPERATURE,
- SENSOR_HAL_TYPE_HUMIDITY,
- SENSOR_HAL_TYPE_HRM,
- SENSOR_HAL_TYPE_HRM_LED_GREEN,
- SENSOR_HAL_TYPE_HRM_LED_IR,
- SENSOR_HAL_TYPE_HRM_LED_RED,
- SENSOR_HAL_TYPE_GYROSCOPE_UNCAL,
- SENSOR_HAL_TYPE_GEOMAGNETIC_UNCAL,
- SENSOR_HAL_TYPE_GYROSCOPE_RV,
- SENSOR_HAL_TYPE_GEOMAGNETIC_RV,
-
- SENSOR_HAL_TYPE_ACTIVITY_STATIONARY = 0x100,
- SENSOR_HAL_TYPE_ACTIVITY_WALK,
- SENSOR_HAL_TYPE_ACTIVITY_RUN,
- SENSOR_HAL_TYPE_ACTIVITY_IN_VEHICLE,
- SENSOR_HAL_TYPE_ACTIVITY_ON_BICYCLE,
-
- SENSOR_HAL_TYPE_GESTURE_MOVEMENT = 0x200,
- SENSOR_HAL_TYPE_GESTURE_WRIST_UP,
- SENSOR_HAL_TYPE_GESTURE_WRIST_DOWN,
-
- SENSOR_HAL_TYPE_HUMAN_PEDOMETER = 0x300,
- SENSOR_HAL_TYPE_HUMAN_SLEEP_MONITOR,
-
- SENSOR_HAL_TYPE_FUSION = 0x900,
- SENSOR_HAL_TYPE_AUTO_ROTATION,
-
- SENSOR_HAL_TYPE_CONTEXT = 0x1000,
- SENSOR_HAL_TYPE_MOTION,
- SENSOR_HAL_TYPE_PIR,
- SENSOR_HAL_TYPE_PIR_LONG,
- SENSOR_HAL_TYPE_DUST,
- SENSOR_HAL_TYPE_THERMOMETER,
- SENSOR_HAL_TYPE_PEDOMETER,
- SENSOR_HAL_TYPE_FLAT,
- SENSOR_HAL_TYPE_HRM_RAW,
- SENSOR_HAL_TYPE_TILT,
- SENSOR_HAL_TYPE_ROTATION_VECTOR_RAW,
-} sensor_hal_type;
+ SENSOR_DEVICE_UNKNOWN = -2,
+ SENSOR_DEVICE_ALL = -1,
+ SENSOR_DEVICE_ACCELEROMETER,
+ SENSOR_DEVICE_GRAVITY,
+ SENSOR_DEVICE_LINEAR_ACCELERATION,
+ SENSOR_DEVICE_GEOMAGNETIC,
+ SENSOR_DEVICE_ROTATION_VECTOR,
+ SENSOR_DEVICE_ORIENTATION,
+ SENSOR_DEVICE_GYROSCOPE,
+ SENSOR_DEVICE_LIGHT,
+ SENSOR_DEVICE_PROXIMITY,
+ SENSOR_DEVICE_PRESSURE,
+ SENSOR_DEVICE_ULTRAVIOLET,
+ SENSOR_DEVICE_TEMPERATURE,
+ SENSOR_DEVICE_HUMIDITY,
+ SENSOR_DEVICE_HRM,
+ SENSOR_DEVICE_HRM_LED_GREEN,
+ SENSOR_DEVICE_HRM_LED_IR,
+ SENSOR_DEVICE_HRM_LED_RED,
+ SENSOR_DEVICE_GYROSCOPE_UNCAL,
+ SENSOR_DEVICE_GEOMAGNETIC_UNCAL,
+ SENSOR_DEVICE_GYROSCOPE_RV,
+ SENSOR_DEVICE_GEOMAGNETIC_RV,
+
+ SENSOR_DEVICE_ACTIVITY_STATIONARY = 0x100,
+ SENSOR_DEVICE_ACTIVITY_WALK,
+ SENSOR_DEVICE_ACTIVITY_RUN,
+ SENSOR_DEVICE_ACTIVITY_IN_VEHICLE,
+ SENSOR_DEVICE_ACTIVITY_ON_BICYCLE,
+
+ SENSOR_DEVICE_GESTURE_MOVEMENT = 0x200,
+ SENSOR_DEVICE_GESTURE_WRIST_UP,
+ SENSOR_DEVICE_GESTURE_WRIST_DOWN,
+
+ SENSOR_DEVICE_HUMAN_PEDOMETER = 0x300,
+ SENSOR_DEVICE_HUMAN_SLEEP_MONITOR,
+
+ SENSOR_DEVICE_FUSION = 0x900,
+ SENSOR_DEVICE_AUTO_ROTATION,
+
+ SENSOR_DEVICE_CONTEXT = 0x1000,
+ SENSOR_DEVICE_MOTION,
+ SENSOR_DEVICE_PIR,
+ SENSOR_DEVICE_PIR_LONG,
+ SENSOR_DEVICE_DUST,
+ SENSOR_DEVICE_THERMOMETER,
+ SENSOR_DEVICE_PEDOMETER,
+ SENSOR_DEVICE_FLAT,
+ SENSOR_DEVICE_HRM_RAW,
+ SENSOR_DEVICE_TILT,
+ SENSOR_DEVICE_ROTATION_VECTOR_RAW,
+} sensor_device_type;
/*
* A platform sensor handler is generated based on this handle
typedef struct sensor_handle_t {
uint32_t id;
std::string name;
- sensor_hal_type type;
+ sensor_device_type type;
unsigned int event_type; // for Internal API
sensor_properties_s properties;
} sensor_handle_t;
/*
- * Sensor HAL interface
+ * Sensor device interface
* 1 HAL must be abstracted from 1 device event node
*/
-class sensor_hal
+class sensor_device
{
public:
- uint32_t get_hal_version(void) {
+ uint32_t get_hal_version(void)
+ {
return SENSOR_HAL_VERSION(1, 0);
}
sensorhub_data_t data;
} sensorhub_event_t;
-typedef struct sensor_module{
- std::vector<void*> sensors;
-} sensor_module;
+typedef struct sensor_devices {
+ std::vector<void*> devices;
+} sensor_devices;
-typedef sensor_module* (*create_t)(void);
+typedef sensor_devices* (*create_t)(void);
typedef void *(*cmd_func_t)(void *data, void *cb_data);
projects / platform / core / system / sensord.git / commitdiff