include_directories(${CMAKE_SOURCE_DIR}/src/server)
include_directories(${CMAKE_SOURCE_DIR}/src/shared)
-IF("${ACCEL}" STREQUAL "ON")
-include_directories(${CMAKE_SOURCE_DIR}/src/server/plugins/accel)
-list (APPEND PLUGIN_SRCS "accel/accel_sensor.cpp")
-add_definitions(-DENABLE_ACCEL)
-ENDIF()
-IF("${GYRO}" STREQUAL "ON")
-include_directories(${CMAKE_SOURCE_DIR}/src/server/plugins/gyro)
-list (APPEND PLUGIN_SRCS "gyro/gyro_sensor.cpp")
-add_definitions(-DENABLE_GYRO)
-ENDIF()
-IF("${PROXI}" STREQUAL "ON")
-include_directories(${CMAKE_SOURCE_DIR}/src/server/plugins/proxi)
-list (APPEND PLUGIN_SRCS "proxi/proxi_sensor.cpp")
-add_definitions(-DENABLE_PROXI)
-ENDIF()
-IF("${LIGHT}" STREQUAL "ON")
-include_directories(${CMAKE_SOURCE_DIR}/src/server/plugins/light)
-list (APPEND PLUGIN_SRCS "light/light_sensor.cpp")
-add_definitions(-DENABLE_LIGHT)
-ENDIF()
-IF("${GEO}" STREQUAL "ON")
-include_directories(${CMAKE_SOURCE_DIR}/src/server/plugins/geo)
-list (APPEND PLUGIN_SRCS "geo/geo_sensor.cpp")
-add_definitions(-DENABLE_GEO)
-ENDIF()
+
+list (APPEND DIR_INCLUDE "${CMAKE_CURRENT_SOURCE_DIR}/accel")
+list (APPEND PLUGIN_SRCS "${CMAKE_CURRENT_SOURCE_DIR}/accel/accel_sensor.cpp")
+
+list (APPEND DIR_INCLUDE "${CMAKE_CURRENT_SOURCE_DIR}/gyro")
+list (APPEND PLUGIN_SRCS "${CMAKE_CURRENT_SOURCE_DIR}/gyro/gyro_sensor.cpp")
+
+list (APPEND DIR_INCLUDE "${CMAKE_CURRENT_SOURCE_DIR}/proxi")
+list (APPEND PLUGIN_SRCS "${CMAKE_CURRENT_SOURCE_DIR}/proxi/proxi_sensor.cpp")
+
+list (APPEND DIR_INCLUDE "${CMAKE_CURRENT_SOURCE_DIR}/light")
+list (APPEND PLUGIN_SRCS "${CMAKE_CURRENT_SOURCE_DIR}/light/light_sensor.cpp")
+
+list (APPEND DIR_INCLUDE "${CMAKE_CURRENT_SOURCE_DIR}/geo")
+list (APPEND PLUGIN_SRCS "${CMAKE_CURRENT_SOURCE_DIR}/geo/geo_sensor.cpp")
+
IF("${AUTO_ROTATION}" STREQUAL "ON")
-include_directories(${CMAKE_SOURCE_DIR}/src/server/plugins/auto_rotation)
-list (APPEND PLUGIN_SRCS "auto_rotation/auto_rotation_alg.cpp")
-list (APPEND PLUGIN_SRCS "auto_rotation/auto_rotation_alg_emul.cpp")
-list (APPEND PLUGIN_SRCS "auto_rotation/auto_rotation_sensor.cpp")
-add_definitions(-DENABLE_AUTO_ROTATION)
-ENDIF()
-IF("${PRESSURE}" STREQUAL "ON")
-include_directories(${CMAKE_SOURCE_DIR}/src/server/plugins/pressure)
-list (APPEND PLUGIN_SRCS "pressure/pressure_sensor.cpp")
-add_definitions(-DENABLE_PRESSURE)
-ENDIF()
-IF("${TEMPERATURE}" STREQUAL "ON")
-include_directories(${CMAKE_SOURCE_DIR}/src/server/plugins/temperature)
-list (APPEND PLUGIN_SRCS "temperature/temperature_sensor.cpp")
-add_definitions(-DENABLE_TEMPERATURE)
-ENDIF()
-IF("${ULTRAVIOLET}" STREQUAL "ON")
-include_directories(${CMAKE_SOURCE_DIR}/src/server/plugins/ultraviolet)
-list (APPEND PLUGIN_SRCS "ultraviolet/ultraviolet_sensor.cpp")
-add_definitions(-DENABLE_ULTRAVIOLET)
-ENDIF()
-IF("${BIO_LED_RED}" STREQUAL "ON")
-include_directories(${CMAKE_SOURCE_DIR}/src/server/plugins/bio_led_red)
-list (APPEND PLUGIN_SRCS "bio_led_red/bio_led_red_sensor.cpp")
-add_definitions(-DENABLE_BIO_LED_RED)
+list (APPEND DIR_INCLUDE "${CMAKE_CURRENT_SOURCE_DIR}/auto_rotation")
+list (APPEND PLUGIN_SRCS "${CMAKE_CURRENT_SOURCE_DIR}/auto_rotation/auto_rotation_alg.cpp")
+list (APPEND PLUGIN_SRCS "${CMAKE_CURRENT_SOURCE_DIR}/auto_rotation/auto_rotation_alg_emul.cpp")
+list (APPEND PLUGIN_SRCS "${CMAKE_CURRENT_SOURCE_DIR}/auto_rotation/auto_rotation_sensor.cpp")
+list (APPEND PLUGIN_DEFS "-DENABLE_AUTO_ROTATION")
ENDIF()
+
+list (APPEND DIR_INCLUDE "${CMAKE_CURRENT_SOURCE_DIR}/pressure")
+list (APPEND PLUGIN_SRCS "${CMAKE_CURRENT_SOURCE_DIR}/pressure/pressure_sensor.cpp")
+
+list (APPEND DIR_INCLUDE "${CMAKE_CURRENT_SOURCE_DIR}/temperature")
+list (APPEND PLUGIN_SRCS "${CMAKE_CURRENT_SOURCE_DIR}/temperature/temperature_sensor.cpp")
+
+list (APPEND DIR_INCLUDE "${CMAKE_CURRENT_SOURCE_DIR}/ultraviolet")
+list (APPEND PLUGIN_SRCS "${CMAKE_CURRENT_SOURCE_DIR}/ultraviolet/ultraviolet_sensor.cpp")
+
+list (APPEND DIR_INCLUDE "${CMAKE_CURRENT_SOURCE_DIR}/bio_led_red")
+list (APPEND PLUGIN_SRCS "${CMAKE_CURRENT_SOURCE_DIR}/bio_led_red/bio_led_red_sensor.cpp")
+
IF("${ORIENTATION}" STREQUAL "ON")
set(SENSOR_FUSION_ENABLE "1")
set(ORIENTATION_ENABLE "1")
set(GRAVITY_ENABLE "1")
set(LINEAR_ACCEL_ENABLE "1")
ENDIF()
+
IF("${SENSOR_FUSION_ENABLE}" STREQUAL "1")
-include_directories(${CMAKE_SOURCE_DIR}/src/server/plugins/sensor_fusion)
-list (APPEND PLUGIN_SRCS "sensor_fusion/euler_angles.cpp")
-list (APPEND PLUGIN_SRCS "sensor_fusion/matrix.cpp")
-list (APPEND PLUGIN_SRCS "sensor_fusion/orientation_filter.cpp")
-list (APPEND PLUGIN_SRCS "sensor_fusion/quaternion.cpp")
-list (APPEND PLUGIN_SRCS "sensor_fusion/rotation_matrix.cpp")
-list (APPEND PLUGIN_SRCS "sensor_fusion/sensor_data.cpp")
-list (APPEND PLUGIN_SRCS "sensor_fusion/vector.cpp")
-include_directories(${CMAKE_SOURCE_DIR}/src/server/plugins/fusion)
-list (APPEND PLUGIN_SRCS "fusion/fusion_sensor.cpp")
-add_definitions(-DENABLE_SENSOR_FUSION)
+list (APPEND DIR_INCLUDE "${CMAKE_CURRENT_SOURCE_DIR}/sensor_fusion")
+list (APPEND PLUGIN_SRCS "${CMAKE_CURRENT_SOURCE_DIR}/sensor_fusion/euler_angles.cpp")
+list (APPEND PLUGIN_SRCS "${CMAKE_CURRENT_SOURCE_DIR}/sensor_fusion/matrix.cpp")
+list (APPEND PLUGIN_SRCS "${CMAKE_CURRENT_SOURCE_DIR}/sensor_fusion/orientation_filter.cpp")
+list (APPEND PLUGIN_SRCS "${CMAKE_CURRENT_SOURCE_DIR}/sensor_fusion/quaternion.cpp")
+list (APPEND PLUGIN_SRCS "${CMAKE_CURRENT_SOURCE_DIR}/sensor_fusion/rotation_matrix.cpp")
+list (APPEND PLUGIN_SRCS "${CMAKE_CURRENT_SOURCE_DIR}/sensor_fusion/sensor_data.cpp")
+list (APPEND PLUGIN_SRCS "${CMAKE_CURRENT_SOURCE_DIR}/sensor_fusion/vector.cpp")
+list (APPEND DIR_INCLUDE "${CMAKE_CURRENT_SOURCE_DIR}/fusion")
+list (APPEND PLUGIN_SRCS "${CMAKE_CURRENT_SOURCE_DIR}/fusion/fusion_sensor.cpp")
+list (APPEND PLUGIN_DEFS "-DENABLE_SENSOR_FUSION")
ENDIF()
+
IF("${ORIENTATION_ENABLE}" STREQUAL "1")
-include_directories(${CMAKE_SOURCE_DIR}/src/server/plugins/orientation)
-list (APPEND PLUGIN_SRCS "orientation/orientation_sensor.cpp")
-add_definitions(-DENABLE_ORIENTATION)
+list (APPEND DIR_INCLUDE "${CMAKE_CURRENT_SOURCE_DIR}/orientation")
+list (APPEND PLUGIN_SRCS "${CMAKE_CURRENT_SOURCE_DIR}/orientation/orientation_sensor.cpp")
+list (APPEND PLUGIN_DEFS "-DENABLE_ORIENTATION")
ENDIF()
IF("${GRAVITY_ENABLE}" STREQUAL "1")
-include_directories(${CMAKE_SOURCE_DIR}/src/server/plugins/gravity)
-list (APPEND PLUGIN_SRCS "gravity/gravity_sensor.cpp")
-add_definitions(-DENABLE_GRAVITY)
+list (APPEND DIR_INCLUDE "${CMAKE_CURRENT_SOURCE_DIR}/gravity")
+list (APPEND PLUGIN_SRCS "${CMAKE_CURRENT_SOURCE_DIR}/gravity/gravity_sensor.cpp")
+list (APPEND PLUGIN_DEFS "-DENABLE_GRAVITY")
ENDIF()
IF("${LINEAR_ACCEL_ENABLE}" STREQUAL "1")
-include_directories(${CMAKE_SOURCE_DIR}/src/server/plugins/linear_accel)
-list (APPEND PLUGIN_SRCS "linear_accel/linear_accel_sensor.cpp")
-add_definitions(-DENABLE_LINEAR_ACCEL)
+list (APPEND DIR_INCLUDE "${CMAKE_CURRENT_SOURCE_DIR}/linear_accel")
+list (APPEND PLUGIN_SRCS "${CMAKE_CURRENT_SOURCE_DIR}/linear_accel/linear_accel_sensor.cpp")
+list (APPEND PLUGIN_DEFS "-DENABLE_LINEAR_ACCEL")
ENDIF()
IF("${TILT_ENABLE}" STREQUAL "1")
-include_directories(${CMAKE_SOURCE_DIR}/src/server/plugins/tilt)
-list (APPEND PLUGIN_SRCS "tilt/tilt_sensor.cpp")
-add_definitions(-DENABLE_TILT)
+list (APPEND DIR_INCLUDE "${CMAKE_CURRENT_SOURCE_DIR}/tilt")
+list (APPEND PLUGIN_SRCS "${CMAKE_CURRENT_SOURCE_DIR}/tilt/tilt_sensor.cpp")
+list (APPEND PLUGIN_DEFS "-DENABLE_TILT")
ENDIF()
IF("${UNCAL_GYRO_ENABLE}" STREQUAL "1")
-include_directories(${CMAKE_SOURCE_DIR}/src/server/plugins/uncal_gyro)
-list (APPEND PLUGIN_SRCS "uncal_gyro/uncal_gyro_sensor.cpp")
-add_definitions(-DENABLE_UNCAL_GYRO)
+list (APPEND DIR_INCLUDE "${CMAKE_CURRENT_SOURCE_DIR}/uncal_gyro")
+list (APPEND PLUGIN_SRCS "${CMAKE_CURRENT_SOURCE_DIR}/uncal_gyro/uncal_gyro_sensor.cpp")
+list (APPEND PLUGIN_DEFS "-DENABLE_UNCAL_GYRO")
ENDIF()
IF("${RV_ENABLE}" STREQUAL "1")
-include_directories(${CMAKE_SOURCE_DIR}/src/server/plugins/rotation_vector/rv)
-list (APPEND PLUGIN_SRCS "rotation_vector/rv/rv_sensor.cpp")
-add_definitions(-DENABLE_RV)
+list (APPEND DIR_INCLUDE "${CMAKE_CURRENT_SOURCE_DIR}/rotation_vector/rv")
+list (APPEND PLUGIN_SRCS "${CMAKE_CURRENT_SOURCE_DIR}/rotation_vector/rv/rv_sensor.cpp")
+list (APPEND PLUGIN_DEFS "-DENABLE_RV")
ENDIF()
IF("${GEOMAGNETIC_RV_ENABLE}" STREQUAL "1")
-include_directories(${CMAKE_SOURCE_DIR}/src/server/plugins/rotation_vector/geomagnetic_rv)
-list (APPEND PLUGIN_SRCS "rotation_vector/geomagnetic_rv/geomagnetic_rv_sensor.cpp")
-add_definitions(-DENABLE_GEOMAGNETIC_RV)
+list (APPEND DIR_INCLUDE "${CMAKE_CURRENT_SOURCE_DIR}/rotation_vector/geomagnetic_rv")
+list (APPEND PLUGIN_SRCS "${CMAKE_CURRENT_SOURCE_DIR}/rotation_vector/geomagnetic_rv/geomagnetic_rv_sensor.cpp")
+list (APPEND PLUGIN_DEFS "-DENABLE_GEOMAGNETIC_RV")
ENDIF()
IF("${GAMING_RV_ENABLE}" STREQUAL "1")
-include_directories(${CMAKE_SOURCE_DIR}/src/server/plugins/rotation_vector/gaming_rv)
-list (APPEND PLUGIN_SRCS "rotation_vector/gaming_rv/gaming_rv_sensor.cpp")
-add_definitions(-DENABLE_GAMING_RV)
-ENDIF()
-IF("${RV_RAW}" STREQUAL "ON")
-include_directories(${CMAKE_SOURCE_DIR}/src/server/plugins/rotation_vector/rv_raw)
-list (APPEND PLUGIN_SRCS "rotation_vector/rv_raw/rv_raw_sensor.cpp")
+list (APPEND DIR_INCLUDE "${CMAKE_CURRENT_SOURCE_DIR}/rotation_vector/gaming_rv")
+list (APPEND PLUGIN_SRCS "${CMAKE_CURRENT_SOURCE_DIR}/rotation_vector/gaming_rv/gaming_rv_sensor.cpp")
+list (APPEND PLUGIN_DEFS "-DENABLE_GAMING_RV")
ENDIF()
-configure_file(sensor_module_create.cpp.in sensor_module_create.cpp)
+list (APPEND DIR_INCLUDE "${CMAKE_CURRENT_SOURCE_DIR}/rotation_vector/rv_raw")
+list (APPEND PLUGIN_SRCS "${CMAKE_CURRENT_SOURCE_DIR}/rotation_vector/rv_raw/rv_raw_sensor.cpp")
-add_library(${PROJECT_NAME} SHARED
- sensor_module_create.cpp
- ${PLUGIN_SRCS}
- )
-target_link_libraries(${PROJECT_NAME} ${plugin_pkgs_LDFLAGS} "-lrt -ldl -pthread")
+set(PLUGIN_SRCS ${PLUGIN_SRCS} PARENT_SCOPE)
+set(DIR_INCLUDE ${DIR_INCLUDE} PARENT_SCOPE)
+set(PLUGIN_DEFS ${PLUGIN_DEFS} PARENT_SCOPE)
-install(TARGETS ${PROJECT_NAME} DESTINATION ${CMAKE_INSTALL_LIBDIR})
\ No newline at end of file
+++ /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 <dlfcn.h>
-#include <dirent.h>
-#include <sensor_logs.h>
-#include <unordered_set>
-#include <algorithm>
-
-using std::make_pair;
-using std::equal;
-using std::unordered_set;
-using std::pair;
-using std::vector;
-using std::string;
-using std::shared_ptr;
-using std::static_pointer_cast;
-
-#define ROOT_ELEMENT "PLUGIN"
-#define TEXT_ELEMENT "text"
-#define PATH_ATTR "path"
-#define HAL_ELEMENT "HAL"
-#define SENSOR_ELEMENT "SENSOR"
-
-#define SENSOR_PLUGINS_DIR_PATH "/usr/lib/libsensord-plugins.so"
-#define HAL_PLUGINS_DIR_PATH "/usr/lib/libsensor-hal.so"
-
-#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_module(const string &path, vector<void*> &sensors, void* &handle)
-{
- 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_module = (create_t) dlsym(_handle, "create");
-
- if (!create_module) {
- ERR("Failed to find symbols in %s", path.c_str());
- dlclose(_handle);
- return false;
- }
-
- sensor_module *module = create_module();
-
- if (!module) {
- ERR("Failed to create module, path is %s\n", path.c_str());
- dlclose(_handle);
- return false;
- }
-
- sensors.clear();
- sensors.swap(module->sensors);
-
- delete module;
- handle = _handle;
-
- return true;
-}
-
-bool sensor_plugin_loader::insert_module(plugin_type type, const string &path)
-{
- if (type == PLUGIN_TYPE_HAL) {
- DBG("Insert HAL plugin [%s]", path.c_str());
-
- std::vector<void *>hals;
- void *handle;
-
- if (!load_module(path, hals, handle))
- return false;
-
- shared_ptr<sensor_hal> hal;
-
- for (unsigned int i = 0; i < hals.size(); ++i) {
- hal.reset(static_cast<sensor_hal*> (hals[i]));
- sensor_hal_type_t sensor_hal_type = hal->get_type();
- m_sensor_hals.insert(make_pair(sensor_hal_type, hal));
- }
- } else if (type == PLUGIN_TYPE_SENSOR) {
- DBG("Insert Sensor plugin [%s]", path.c_str());
-
- std::vector<void *> sensors;
- void *handle;
-
- if (!load_module(path, sensors, handle))
- return false;
-
- shared_ptr<sensor_base> sensor;
-
- for (unsigned int i = 0; i < sensors.size(); ++i) {
- sensor.reset(static_cast<sensor_base*> (sensors[i]));
-
- if (!sensor->init()) {
- ERR("Failed to init [%s] module\n", sensor->get_name());
- continue;
- }
-
- DBG("init [%s] module", sensor->get_name());
-
- vector<sensor_type_t> sensor_types;
-
- sensor->get_types(sensor_types);
-
- for (unsigned int i = 0; i < sensor_types.size(); ++i) {
- int idx;
- idx = m_sensors.count(sensor_types[i]);
- sensor->add_id(idx << SENSOR_INDEX_SHIFT | sensor_types[i]);
- m_sensors.insert(make_pair(sensor_types[i], sensor));
- }
- }
- }else {
- ERR("Not supported type: %d", type);
- return false;
- }
-
- return true;
-}
-
-bool sensor_plugin_loader::load_plugins(void)
-{
- insert_module(PLUGIN_TYPE_HAL, HAL_PLUGINS_DIR_PATH);
- insert_module(PLUGIN_TYPE_SENSOR, SENSOR_PLUGINS_DIR_PATH);
-
- 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()) {
- shared_ptr<sensor_base> sensor = it->second;
-
- sensor_info info;
- sensor->get_sensor_info(it->first, info);
- INFO("No:%d [%s]\n", ++index, sensor->get_name());
- info.show();
- it++;
- }
-
- INFO("===============================================\n");
-}
-
-sensor_hal* sensor_plugin_loader::get_sensor_hal(sensor_hal_type_t type)
-{
- auto it_plugins = m_sensor_hals.find(type);
-
- if (it_plugins == m_sensor_hals.end())
- return NULL;
-
- return it_plugins->second.get();
-}
-
-vector<sensor_hal *> sensor_plugin_loader::get_sensor_hals(sensor_hal_type_t type)
-{
- vector<sensor_hal *> sensor_hal_list;
- pair<sensor_hal_plugins::iterator, sensor_hal_plugins::iterator> ret;
- ret = m_sensor_hals.equal_range(type);
-
- for (auto it = ret.first; it != ret.second; ++it)
- sensor_hal_list.push_back(it->second.get());
-
- return sensor_hal_list;
-}
-
-sensor_base* sensor_plugin_loader::get_sensor(sensor_type_t type)
-{
- auto it_plugins = m_sensors.find(type);
-
- if (it_plugins == m_sensors.end())
- return NULL;
-
- return it_plugins->second.get();
-}
-
-vector<sensor_base *> sensor_plugin_loader::get_sensors(sensor_type_t type)
-{
- vector<sensor_base *> sensor_list;
- pair<sensor_plugins::iterator, sensor_plugins::iterator> ret;
-
- if (type == ALL_SENSOR)
- ret = std::make_pair(m_sensors.begin(), m_sensors.end());
- else
- ret = m_sensors.equal_range(type);
-
- for (auto it = ret.first; it != ret.second; ++it)
- sensor_list.push_back(it->second.get());
-
- return sensor_list;
-}
-
-
-sensor_base* sensor_plugin_loader::get_sensor(sensor_id_t id)
-{
- vector<sensor_base *> sensors;
-
- sensor_type_t type = (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_virtual_sensors(void)
-{
- vector<sensor_base *> virtual_list;
- sensor_base* module;
-
- for (auto sensor_it = m_sensors.begin(); sensor_it != m_sensors.end(); ++sensor_it) {
- module = sensor_it->second.get();
-
- if (module && module->is_virtual() == true) {
- virtual_list.push_back(module);
- }
- }
-
- return virtual_list;
-}
-
--- /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 <dlfcn.h>
+#include <dirent.h>
+#include <sensor_logs.h>
+#include <unordered_set>
+#include <algorithm>
+
+#include <accel_sensor.h>
+#include <gyro_sensor.h>
+#include <geo_sensor.h>
+#include <light_sensor.h>
+#include <proxi_sensor.h>
+#include <pressure_sensor.h>
+#include <bio_led_red_sensor.h>
+#include <temperature_sensor.h>
+#include <ultraviolet_sensor.h>
+#include <rv_raw_sensor.h>
+
+#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_UNCAL_GYRO
+#include <uncal_gyro_sensor.h>
+#endif
+
+
+using std::make_pair;
+using std::equal;
+using std::unordered_set;
+using std::pair;
+using std::vector;
+using std::string;
+using std::shared_ptr;
+using std::static_pointer_cast;
+
+#define ROOT_ELEMENT "PLUGIN"
+#define TEXT_ELEMENT "text"
+#define PATH_ATTR "path"
+#define HAL_ELEMENT "HAL"
+#define SENSOR_ELEMENT "SENSOR"
+
+#define ACCELEROMETER_ENABLED 0x01
+#define GYROSCOPE_ENABLED 0x02
+#define GEOMAGNETIC_ENABLED 0x04
+#define TILT_ENABLED 1
+#define FUSION_ENABLED 1
+#define AUTO_ROTATION_ENABLED 1
+#define GAMING_RV_ENABLED 3
+#define GEOMAGNETIC_RV_ENABLED 5
+#define ORIENTATION_ENABLED 7
+#define GRAVITY_ENABLED 7
+#define LINEAR_ACCEL_ENABLED 7
+#define ORIENTATION_ENABLED 7
+
+#define HAL_PLUGINS_DIR_PATH "/usr/lib/sensor-hal"
+
+#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_module(const string &path, vector<void*> &sensors, void* &handle)
+{
+ 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_module = (create_t) dlsym(_handle, "create");
+
+ if (!create_module) {
+ ERR("Failed to find symbols in %s", path.c_str());
+ dlclose(_handle);
+ return false;
+ }
+
+ sensor_module *module = create_module();
+
+ if (!module) {
+ ERR("Failed to create module, path is %s\n", path.c_str());
+ dlclose(_handle);
+ return false;
+ }
+
+ sensors.clear();
+ sensors.swap(module->sensors);
+
+ delete module;
+ handle = _handle;
+
+ return true;
+}
+
+bool sensor_plugin_loader::insert_module(plugin_type type, const string &path)
+{
+ if (type == PLUGIN_TYPE_HAL) {
+ DBG("Insert HAL plugin [%s]", path.c_str());
+
+ std::vector<void *>hals;
+ void *handle;
+
+ if (!load_module(path, hals, handle))
+ return false;
+
+ shared_ptr<sensor_hal> hal;
+
+ for (unsigned int i = 0; i < hals.size(); ++i) {
+ hal.reset(static_cast<sensor_hal*> (hals[i]));
+ sensor_hal_type_t sensor_hal_type = hal->get_type();
+ m_sensor_hals.insert(make_pair(sensor_hal_type, hal));
+ }
+ } else if (type == PLUGIN_TYPE_SENSOR) {
+ DBG("Insert Sensor plugin [%s]", path.c_str());
+
+ std::vector<void *> sensors;
+ void *handle;
+
+ if (!load_module(path, sensors, handle))
+ return false;
+
+ shared_ptr<sensor_base> sensor;
+
+ for (unsigned int i = 0; i < sensors.size(); ++i) {
+ sensor.reset(static_cast<sensor_base*> (sensors[i]));
+
+ if (!sensor->init()) {
+ ERR("Failed to init [%s] module\n", sensor->get_name());
+ continue;
+ }
+
+ DBG("init [%s] module", sensor->get_name());
+
+ vector<sensor_type_t> sensor_types;
+
+ sensor->get_types(sensor_types);
+
+ for (unsigned int i = 0; i < sensor_types.size(); ++i) {
+ int idx;
+ idx = m_sensors.count(sensor_types[i]);
+ sensor->add_id(idx << SENSOR_INDEX_SHIFT | sensor_types[i]);
+ m_sensors.insert(make_pair(sensor_types[i], sensor));
+ }
+ }
+ }else {
+ ERR("Not supported type: %d", type);
+ return false;
+ }
+
+ return true;
+}
+
+bool sensor_plugin_loader::load_plugins(void)
+{
+ vector<string> hal_paths;
+ vector<string> unique_hal_paths;
+
+ int enable_virtual_sensor = 0;
+ vector<void*> sensors;
+
+ 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) {
+ insert_module(PLUGIN_TYPE_HAL, path);
+ }
+ );
+
+
+ sensor_hal *accel_hal = get_sensor_hal(SENSOR_HAL_TYPE_ACCELEROMETER);
+ if (accel_hal != NULL) {
+ enable_virtual_sensor |= ACCELEROMETER_ENABLED;
+
+ accel_sensor* accel_sensor_ptr = NULL;
+ try {
+ accel_sensor_ptr = new(std::nothrow) accel_sensor;
+ } catch (int err) {
+ ERR("Failed to create accel_sensor module, err: %d, cause: %s", err, strerror(err));
+ }
+ if (accel_sensor_ptr != NULL)
+ sensors.push_back(accel_sensor_ptr);
+ }
+
+ sensor_hal *gyro_hal = get_sensor_hal(SENSOR_HAL_TYPE_GYROSCOPE);
+ if (gyro_hal != NULL) {
+ enable_virtual_sensor |= GYROSCOPE_ENABLED;
+
+ gyro_sensor* gyro_sensor_ptr = NULL;
+ try {
+ gyro_sensor_ptr = new(std::nothrow) gyro_sensor;
+ } catch (int err) {
+ ERR("Failed to create gyro_sensor module, err: %d, cause: %s", err, strerror(err));
+ }
+ if (gyro_sensor_ptr != NULL)
+ sensors.push_back(gyro_sensor_ptr);
+ }
+
+ sensor_hal *geo_hal = get_sensor_hal(SENSOR_HAL_TYPE_GEOMAGNETIC);
+ if (geo_hal != NULL) {
+ enable_virtual_sensor |= GEOMAGNETIC_ENABLED;
+
+ geo_sensor* geo_sensor_ptr = NULL;
+ try {
+ geo_sensor_ptr = new(std::nothrow) geo_sensor;
+ } catch (int err) {
+ ERR("Failed to create geo_sensor module, err: %d, cause: %s", err, strerror(err));
+ }
+ if (geo_sensor_ptr != NULL)
+ sensors.push_back(geo_sensor_ptr);
+ }
+#ifdef ENABLE_SENSOR_FUSION
+ fusion_sensor* fusion_sensor_ptr = NULL;
+ try {
+ fusion_sensor_ptr = new(std::nothrow) fusion_sensor;
+ } catch (int err) {
+ ERR("Failed to create fusion_sensor module, err: %d, cause: %s", err, strerror(err));
+ }
+ if (fusion_sensor_ptr != NULL)
+ sensors.push_back(fusion_sensor_ptr);
+#endif
+#ifdef ENABLE_TILT
+ if (enable_virtual_sensor & TILT_ENABLED == TILT_ENABLED) {
+ tilt_sensor* tilt_sensor_ptr = NULL;
+ try {
+ tilt_sensor_ptr = new(std::nothrow) tilt_sensor;
+ } catch (int err) {
+ ERR("Failed to create tilt_sensor module, err: %d, cause: %s", err, strerror(err));
+ }
+ if (tilt_sensor_ptr != NULL)
+ sensors.push_back(tilt_sensor_ptr);
+ }
+#endif
+#ifdef ENABLE_AUTO_ROTATION
+ if (enable_virtual_sensor & AUTO_ROTATION_ENABLED == AUTO_ROTATION_ENABLED) {
+ 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)
+ sensors.push_back(auto_rot_sensor_ptr);
+ }
+#endif
+#ifdef ENABLE_GRAVITY
+ if (enable_virtual_sensor & GRAVITY_ENABLED == GRAVITY_ENABLED) {
+ gravity_sensor* gravity_sensor_ptr = NULL;
+ try {
+ gravity_sensor_ptr = new(std::nothrow) gravity_sensor;
+ } catch (int err) {
+ ERR("Failed to create tilt_sensor module, err: %d, cause: %s", err, strerror(err));
+ }
+ if (gravity_sensor_ptr != NULL)
+ sensors.push_back(gravity_sensor_ptr);
+ }
+#endif
+#ifdef ENABLE_LINEAR_ACCEL
+ if (enable_virtual_sensor & LINEAR_ACCEL_ENABLED == LINEAR_ACCEL_ENABLED) {
+ linear_accel_sensor* linear_accel_sensor_ptr = NULL;
+ try {
+ linear_accel_sensor_ptr = new(std::nothrow) linear_accel_sensor;
+ } catch (int err) {
+ ERR("Failed to create linear_accel_sensor module, err: %d, cause: %s", err, strerror(err));
+ }
+ if (linear_accel_sensor_ptr != NULL)
+ sensors.push_back(linear_accel_sensor_ptr);
+ }
+#endif
+
+ if (enable_virtual_sensor & ORIENTATION_ENABLED == ORIENTATION_ENABLED) {
+#ifdef ENABLE_ORIENTATION
+ orientation_sensor* orientation_sensor_ptr = NULL;
+ try {
+ orientation_sensor_ptr = new(std::nothrow) orientation_sensor;
+ } catch (int err) {
+ ERR("Failed to create orientation_sensor module, err: %d, cause: %s", err, strerror(err));
+ }
+ if (orientation_sensor_ptr != NULL)
+ sensors.push_back(orientation_sensor_ptr);
+#endif
+#ifdef ENABLE_RV
+ rv_sensor* rv_sensor_ptr = NULL;
+ try {
+ rv_sensor_ptr = new(std::nothrow) rv_sensor;
+ } catch (int err) {
+ ERR("Failed to create rv_sensor module, err: %d, cause: %s", err, strerror(err));
+ }
+ if (rv_sensor_ptr != NULL)
+ sensors.push_back(rv_sensor_ptr);
+#endif
+#ifdef ENABLE_UNCAL_GYRO
+ uncal_gyro_sensor* uncal_gyro_sensor_ptr = NULL;
+ try {
+ uncal_gyro_sensor_ptr = new(std::nothrow) uncal_gyro_sensor;
+ } catch (int err) {
+ ERR("Failed to create uncal_gyro_sensor module, err: %d, cause: %s", err, strerror(err));
+ }
+ if (uncal_gyro_sensor_ptr != NULL)
+ sensors.push_back(uncal_gyro_sensor_ptr);
+#endif
+ }
+
+#ifdef ENABLE_GAMING_RV
+ if (enable_virtual_sensor & GAMING_RV_ENABLED == GAMING_RV_ENABLED) {
+ gaming_rv_sensor* gaming_rv_sensor_ptr = NULL;
+ try {
+ gaming_rv_sensor_ptr = new(std::nothrow) gaming_rv_sensor;
+ } catch (int err) {
+ ERR("Failed to create gaming_rv_sensor module, err: %d, cause: %s", err, strerror(err));
+ }
+ if (gaming_rv_sensor_ptr != NULL)
+ sensors.push_back(gaming_rv_sensor_ptr);
+ }
+#endif
+#ifdef ENABLE_GEOMAGNETIC_RV
+ if (enable_virtual_sensor & GEOMAGNETIC_RV_ENABLED == GEOMAGNETIC_RV_ENABLED) {
+ geomagnetic_rv_sensor* geomagnetic_rv_sensor_ptr = NULL;
+ try {
+ geomagnetic_rv_sensor_ptr = new(std::nothrow) geomagnetic_rv_sensor;
+ } catch (int err) {
+ ERR("Failed to create geomagnetic_rv_sensor module, err: %d, cause: %s", err, strerror(err));
+ }
+ if (geomagnetic_rv_sensor_ptr != NULL)
+ sensors.push_back(geomagnetic_rv_sensor_ptr);
+ }
+#endif
+ sensor_hal *light_hal = get_sensor_hal(SENSOR_HAL_TYPE_LIGHT);
+ if (light_hal != NULL) {
+ light_sensor* light_sensor_ptr = NULL;
+ try {
+ light_sensor_ptr = new(std::nothrow) light_sensor;
+ } catch (int err) {
+ ERR("Failed to create light_sensor module, err: %d, cause: %s", err, strerror(err));
+ }
+ if (light_sensor_ptr != NULL)
+ sensors.push_back(light_sensor_ptr);
+ }
+
+ sensor_hal *proxi_hal = get_sensor_hal(SENSOR_HAL_TYPE_PROXIMITY);
+ if (proxi_hal != NULL) {
+ proxi_sensor* proxi_sensor_ptr = NULL;
+ try {
+ proxi_sensor_ptr = new(std::nothrow) proxi_sensor;
+ } catch (int err) {
+ ERR("Failed to create proxi_sensor module, err: %d, cause: %s", err, strerror(err));
+ }
+ if (proxi_sensor_ptr != NULL)
+ sensors.push_back(proxi_sensor_ptr);
+ }
+
+ sensor_hal *pressure_hal = get_sensor_hal(SENSOR_HAL_TYPE_PRESSURE);
+ if (pressure_hal != NULL) {
+ pressure_sensor* pressure_sensor_ptr = NULL;
+ try {
+ pressure_sensor_ptr = new(std::nothrow) pressure_sensor;
+ } catch (int err) {
+ ERR("Failed to create pressure_sensor module, err: %d, cause: %s", err, strerror(err));
+ }
+ if (pressure_sensor_ptr != NULL)
+ sensors.push_back(pressure_sensor_ptr);
+ }
+
+ sensor_hal *temp_hal = get_sensor_hal(SENSOR_HAL_TYPE_TEMPERATURE);
+ if (temp_hal != NULL) {
+ temperature_sensor* temp_sensor_ptr = NULL;
+ try {
+ temp_sensor_ptr = new(std::nothrow) temperature_sensor;
+ } catch (int err) {
+ ERR("Failed to create temperature_sensor module, err: %d, cause: %s", err, strerror(err));
+ }
+ if (temp_sensor_ptr != NULL)
+ sensors.push_back(temp_sensor_ptr);
+ }
+
+ sensor_hal *ultra_hal = get_sensor_hal(SENSOR_HAL_TYPE_ULTRAVIOLET);
+ if (ultra_hal != NULL) {
+ ultraviolet_sensor* ultra_sensor_ptr = NULL;
+ try {
+ ultra_sensor_ptr = new(std::nothrow) ultraviolet_sensor;
+ } catch (int err) {
+ ERR("Failed to create ultraviolet_sensor module, err: %d, cause: %s", err, strerror(err));
+ }
+ if (ultra_sensor_ptr != NULL)
+ sensors.push_back(ultra_sensor_ptr);
+ }
+
+ sensor_hal *bio_led_red_hal = get_sensor_hal(SENSOR_HAL_TYPE_BIO_LED_RED);
+ if (bio_led_red_hal != NULL) {
+ bio_led_red_sensor* bio_led_red_sensor_ptr = NULL;
+ try {
+ bio_led_red_sensor_ptr = new(std::nothrow) bio_led_red_sensor;
+ } catch (int err) {
+ ERR("Failed to create bio_led_red_sensor module, err: %d, cause: %s", err, strerror(err));
+ }
+ if (bio_led_red_sensor_ptr != NULL)
+ sensors.push_back(bio_led_red_sensor_ptr);
+ }
+
+ sensor_hal *rv_raw_hal = get_sensor_hal(SENSOR_HAL_TYPE_RV_RAW);
+ if (rv_raw_hal != NULL) {
+ rv_raw_sensor* rv_raw_sensor_ptr = NULL;
+ try {
+ rv_raw_sensor_ptr = new(std::nothrow) rv_raw_sensor;
+ } catch (int err) {
+ ERR("Failed to create rv_raw_sensor module, err: %d, cause: %s", err, strerror(err));
+ }
+ if (rv_raw_sensor_ptr != NULL)
+ sensors.push_back(rv_raw_sensor_ptr);
+ }
+
+ shared_ptr<sensor_base> sensor;
+
+ for (unsigned int i = 0; i < sensors.size(); ++i) {
+ sensor.reset(static_cast<sensor_base*> (sensors[i]));
+
+ if (!sensor->init()) {
+ ERR("Failed to init [%s] module\n", sensor->get_name());
+ continue;
+ }
+
+ DBG("init [%s] module", sensor->get_name());
+
+ vector<sensor_type_t> sensor_types;
+
+ sensor->get_types(sensor_types);
+
+ for (unsigned int i = 0; i < sensor_types.size(); ++i) {
+ int idx;
+ idx = m_sensors.count(sensor_types[i]);
+ sensor->add_id(idx << SENSOR_INDEX_SHIFT | sensor_types[i]);
+ m_sensors.insert(make_pair(sensor_types[i], sensor));
+ }
+ }
+
+ 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()) {
+ shared_ptr<sensor_base> sensor = it->second;
+
+ sensor_info info;
+ sensor->get_sensor_info(it->first, 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_hal* sensor_plugin_loader::get_sensor_hal(sensor_hal_type_t type)
+{
+ auto it_plugins = m_sensor_hals.find(type);
+
+ if (it_plugins == m_sensor_hals.end())
+ return NULL;
+
+ return it_plugins->second.get();
+}
+
+vector<sensor_hal *> sensor_plugin_loader::get_sensor_hals(sensor_hal_type_t type)
+{
+ vector<sensor_hal *> sensor_hal_list;
+ pair<sensor_hal_plugins::iterator, sensor_hal_plugins::iterator> ret;
+ ret = m_sensor_hals.equal_range(type);
+
+ for (auto it = ret.first; it != ret.second; ++it)
+ sensor_hal_list.push_back(it->second.get());
+
+ return sensor_hal_list;
+}
+
+sensor_base* sensor_plugin_loader::get_sensor(sensor_type_t type)
+{
+ auto it_plugins = m_sensors.find(type);
+
+ if (it_plugins == m_sensors.end())
+ return NULL;
+
+ return it_plugins->second.get();
+}
+
+vector<sensor_base *> sensor_plugin_loader::get_sensors(sensor_type_t type)
+{
+ vector<sensor_base *> sensor_list;
+ pair<sensor_plugins::iterator, sensor_plugins::iterator> ret;
+
+ if (type == ALL_SENSOR)
+ ret = std::make_pair(m_sensors.begin(), m_sensors.end());
+ else
+ ret = m_sensors.equal_range(type);
+
+ for (auto it = ret.first; it != ret.second; ++it)
+ sensor_list.push_back(it->second.get());
+
+ return sensor_list;
+}
+
+
+sensor_base* sensor_plugin_loader::get_sensor(sensor_id_t id)
+{
+ vector<sensor_base *> sensors;
+
+ sensor_type_t type = (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_virtual_sensors(void)
+{
+ vector<sensor_base *> virtual_list;
+ sensor_base* module;
+
+ for (auto sensor_it = m_sensors.begin(); sensor_it != m_sensors.end(); ++sensor_it) {
+ module = sensor_it->second.get();
+
+ if (module && module->is_virtual() == true) {
+ virtual_list.push_back(module);
+ }
+ }
+
+ return virtual_list;
+}
+
projects / platform / core / system / sensord.git / commitdiff