From 583c2c76aaeb9869ad6304725f3e2219ecbcbcad Mon Sep 17 00:00:00 2001 From: "kibak.yoon" Date: Wed, 26 Apr 2017 19:56:02 +0900 Subject: [PATCH] sensor: api: implement URI-based APIs and sensor provider APIs Change-Id: I339e2964b256f96d4462b57a2077bfd668be0ade Signed-off-by: kibak.yoon --- CMakeLists.txt | 1 + src/sensor.cpp | 114 +++++++++++++++++++++++- src/sensor_provider.cpp | 190 ++++++++++++++++++++++++++++++++++++++++ 3 files changed, 304 insertions(+), 1 deletion(-) create mode 100644 src/sensor_provider.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index d149868..e2d3fcb 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -36,6 +36,7 @@ SET(CMAKE_EXE_LINKER_FLAGS "-Wl,--as-needed -Wl, --rpath=${LIB_INSTALL_DIR}") # Compile Source files SET(SOURCES src/sensor.cpp src/sensor_recorder.cpp + src/sensor_provider.cpp src/geomagnetic_field.c src/fusion_util.c) diff --git a/src/sensor.cpp b/src/sensor.cpp index 82e35f5..5521628 100644 --- a/src/sensor.cpp +++ b/src/sensor.cpp @@ -127,6 +127,28 @@ int sensor_is_supported(sensor_type_e type, bool *supported) return SENSOR_ERROR_NONE; } +int sensor_is_supported_by_uri(const char *uri, bool *supported) +{ + int result; + sensor_t sensor; + + if (!supported) + return SENSOR_ERROR_INVALID_PARAMETER; + + result = sensord_get_default_sensor_by_uri(uri, &sensor); + if (result == -EINVAL) + return SENSOR_ERROR_INVALID_PARAMETER; + else if (result == -EPERM || result == -EIO) + return SENSOR_ERROR_OPERATION_FAILED; + + if (result == -ENODATA) + *supported = false; + else + *supported = true; + + return SENSOR_ERROR_NONE; +} + int sensor_get_default_sensor(sensor_type_e type, sensor_h *sensor) { int result; @@ -163,6 +185,23 @@ int sensor_get_default_sensor(sensor_type_e type, sensor_h *sensor) return SENSOR_ERROR_NONE; } +int sensor_get_default_sensor_by_uri(const char *uri, sensor_h *sensor) +{ + int result; + + result = sensord_get_default_sensor_by_uri(uri, sensor); + if (result == -EINVAL) + return SENSOR_ERROR_INVALID_PARAMETER; + else if (result == -EACCES) + return SENSOR_ERROR_PERMISSION_DENIED; + else if (result == -ENODATA) + return SENSOR_ERROR_NOT_SUPPORTED; + else if (result < 0) + return SENSOR_ERROR_OPERATION_FAILED; + + return SENSOR_ERROR_NONE; +} + int sensor_get_sensor_list(sensor_type_e type, sensor_h **list, int *sensor_count) { int result; @@ -233,6 +272,22 @@ int sensor_get_sensor_list(sensor_type_e type, sensor_h **list, int *sensor_coun return SENSOR_ERROR_NONE; } +int sensor_get_sensor_list_by_uri(const char *uri, sensor_h **list, int *sensor_count) +{ + int result; + result = sensord_get_sensors_by_uri(uri, list, sensor_count); + if (result == -EINVAL) + return SENSOR_ERROR_INVALID_PARAMETER; + else if (result == -EACCES) + return SENSOR_ERROR_PERMISSION_DENIED; + else if (result == -ENODATA) + return SENSOR_ERROR_NOT_SUPPORTED; + else if (result < 0) + return SENSOR_ERROR_OPERATION_FAILED; + + return SENSOR_ERROR_NONE; +} + int sensor_is_wake_up(sensor_h sensor, bool *wakeup) { _D("called sensor_get_type"); @@ -356,7 +411,6 @@ static void sensor_callback(sensor_t sensor, unsigned int event_type, sensor_dat sensor_listener_h listener; listener = (sensor_listener_h)user_data; - _D("success sensor_callback, sensor[%p] listener[%p] listener->callback[%p]", sensor, listener, listener->callback); if (!sensor || !listener->callback) return; @@ -649,6 +703,16 @@ int sensor_listener_read_data(sensor_listener_h listener, sensor_event_s *event) return SENSOR_ERROR_NONE; } +int sensor_get_uri(sensor_h sensor, char **uri) +{ + if (!sensor || !uri) + return SENSOR_ERROR_INVALID_PARAMETER; + + *uri = strdup(sensord_get_uri(sensor)); + + return SENSOR_ERROR_NONE; +} + int sensor_get_name(sensor_h sensor, char** name) { _D("called sensor_get_name"); @@ -785,6 +849,54 @@ int sensor_get_max_batch_count(sensor_h sensor, int *max_batch_count) return SENSOR_ERROR_NONE; } +int sensor_add_sensor_added_cb(sensor_added_cb callback, void *user_data) +{ + int result; + result = sensord_add_sensor_added_cb(callback, user_data); + if (result == -EINVAL) + return SENSOR_ERROR_INVALID_PARAMETER; + else if (result < 0) + return SENSOR_ERROR_OPERATION_FAILED; + + return SENSOR_ERROR_NONE; +} + +int sensor_remove_sensor_added_cb(sensor_added_cb callback) +{ + int result; + result = sensord_remove_sensor_added_cb(callback); + if (result == -EINVAL) + return SENSOR_ERROR_INVALID_PARAMETER; + else if (result < 0) + return SENSOR_ERROR_OPERATION_FAILED; + + return SENSOR_ERROR_NONE; +} + +int sensor_add_sensor_removed_cb(sensor_removed_cb callback, void *user_data) +{ + int result; + result = sensord_add_sensor_removed_cb(callback, user_data); + if (result == -EINVAL) + return SENSOR_ERROR_INVALID_PARAMETER; + else if (result < 0) + return SENSOR_ERROR_OPERATION_FAILED; + + return SENSOR_ERROR_NONE; +} + +int sensor_remove_sensor_removed_cb(sensor_removed_cb callback) +{ + int result; + result = sensord_remove_sensor_removed_cb(callback); + if (result == -EINVAL) + return SENSOR_ERROR_INVALID_PARAMETER; + else if (result < 0) + return SENSOR_ERROR_OPERATION_FAILED; + + return SENSOR_ERROR_NONE; +} + /* * FUNCTIONS : SENSOR_UTIL_* */ diff --git a/src/sensor_provider.cpp b/src/sensor_provider.cpp new file mode 100644 index 0000000..a33aa72 --- /dev/null +++ b/src/sensor_provider.cpp @@ -0,0 +1,190 @@ +/* + * Copyright (c) 2017 Samsung Electronics Co., Ltd All Rights Reserved + * + * 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 +#include +#include +#include +#include + +#include "include/sensor_log.h" + +#define RETV_IF(expr, val) \ + do { if (expr) { return (val); } } while (0) + +typedef struct _sensor_provider_s { + sensord_provider_h sensor; + sensor_provider_start_cb start_cb; + sensor_provider_stop_cb stop_cb; + sensor_provider_interval_changed_cb interval_cb; + void *start_user_data; + void *stop_user_data; + void *interval_user_data; +} sensor_provider_handle; + +int sensor_create_provider(const char *uri, sensor_provider_h *provider) +{ + RETV_IF(!provider, SENSOR_ERROR_INVALID_PARAMETER); + + *provider = new(std::nothrow) sensor_provider_handle(); + RETV_IF(!*provider, SENSOR_ERROR_OUT_OF_MEMORY); + + (*provider)->sensor = NULL; + (*provider)->stop_cb = NULL; + (*provider)->interval_cb = NULL; + (*provider)->start_cb = NULL; + (*provider)->start_user_data = NULL; + (*provider)->stop_user_data = NULL; + (*provider)->interval_user_data = NULL; + + return sensord_create_provider(uri, &(*provider)->sensor); +} + +int sensor_add_provider(sensor_provider_h provider) +{ + RETV_IF(!provider, SENSOR_ERROR_INVALID_PARAMETER); + + int result; + result = sensord_add_provider(provider->sensor); + RETV_IF(result == -EINVAL, SENSOR_ERROR_INVALID_PARAMETER); + RETV_IF(result == -EACCES, SENSOR_ERROR_PERMISSION_DENIED); + RETV_IF(result < 0, SENSOR_ERROR_OPERATION_FAILED); + + return SENSOR_ERROR_NONE; +} + +int sensor_remove_provider(sensor_provider_h provider) +{ + RETV_IF(!provider, SENSOR_ERROR_INVALID_PARAMETER); + + int result; + result = sensord_remove_provider(provider->sensor); + RETV_IF(result == -EINVAL, SENSOR_ERROR_INVALID_PARAMETER); + RETV_IF(result < 0, SENSOR_ERROR_OPERATION_FAILED); + + return SENSOR_ERROR_NONE; +} + +int sensor_destroy_provider(sensor_provider_h provider) +{ + RETV_IF(!provider, SENSOR_ERROR_INVALID_PARAMETER); + + int result; + result = sensord_destroy_provider(provider->sensor); + + if (result == SENSOR_ERROR_NONE) + delete provider; + + return result; +} + +int sensor_provider_set_name(sensor_provider_h provider, const char *name) +{ + RETV_IF(!provider, SENSOR_ERROR_INVALID_PARAMETER); + return sensord_provider_set_name(provider->sensor, name); +} + +int sensor_provider_set_vendor(sensor_provider_h provider, const char *vendor) +{ + RETV_IF(!provider, SENSOR_ERROR_INVALID_PARAMETER); + return sensord_provider_set_vendor(provider->sensor, vendor); +} + +int sensor_provider_set_range(sensor_provider_h provider, float min_range, float max_range) +{ + RETV_IF(!provider, SENSOR_ERROR_INVALID_PARAMETER); + return sensord_provider_set_range(provider->sensor, min_range, max_range); +} + +int sensor_provider_set_resolution(sensor_provider_h provider, float resolution) +{ + RETV_IF(!provider, SENSOR_ERROR_INVALID_PARAMETER); + return sensord_provider_set_resolution(provider->sensor, resolution); +} + +static void sensor_start_callback(sensord_provider_h provider, void *user_data) +{ + sensor_provider_h p = (sensor_provider_h)user_data; + if (p->start_cb) + p->start_cb(p, p->start_user_data); +} + +int sensor_provider_set_start_cb(sensor_provider_h provider, + sensor_provider_start_cb callback, void *user_data) +{ + RETV_IF(!provider, SENSOR_ERROR_INVALID_PARAMETER); + RETV_IF(!callback, SENSOR_ERROR_INVALID_PARAMETER); + + provider->start_cb = callback; + provider->start_user_data = user_data; + + return sensord_provider_set_start_cb(provider->sensor, sensor_start_callback, provider); +} + +static void sensor_stop_callback(sensord_provider_h provider, void *user_data) +{ + sensor_provider_h p = (sensor_provider_h)user_data; + if (p->stop_cb) + p->stop_cb(p, p->stop_user_data); +} + +int sensor_provider_set_stop_cb(sensor_provider_h provider, + sensor_provider_stop_cb callback, void *user_data) +{ + RETV_IF(!provider, SENSOR_ERROR_INVALID_PARAMETER); + RETV_IF(!callback, SENSOR_ERROR_INVALID_PARAMETER); + + provider->stop_cb = callback; + provider->stop_user_data = user_data; + + return sensord_provider_set_stop_cb(provider->sensor, sensor_stop_callback, provider); +} + +static void sensor_interval_changed_callback(sensord_provider_h provider, + unsigned int interval_ms, void *user_data) +{ + sensor_provider_h p = (sensor_provider_h)user_data; + if (p->interval_cb) + p->interval_cb(p, interval_ms, p->interval_user_data); +} + +int sensor_provider_set_interval_changed_cb(sensor_provider_h provider, + sensor_provider_interval_changed_cb callback, void *user_data) +{ + RETV_IF(!provider, SENSOR_ERROR_INVALID_PARAMETER); + RETV_IF(!callback, SENSOR_ERROR_INVALID_PARAMETER); + + provider->interval_cb = callback; + provider->interval_user_data = user_data; + + return sensord_provider_set_interval_changed_cb(provider->sensor, + sensor_interval_changed_callback, provider); +} + +int sensor_provider_publish(sensor_provider_h provider, sensor_event_s event) +{ + RETV_IF(!provider, SENSOR_ERROR_INVALID_PARAMETER); + + int result; + sensor_data_t data; + memcpy(&data, &event, sizeof(data)); + + result = sensord_provider_publish(provider->sensor, data); + RETV_IF(result == -EINVAL, SENSOR_ERROR_INVALID_PARAMETER); + RETV_IF(result < 0, SENSOR_ERROR_OPERATION_FAILED); + + return SENSOR_ERROR_NONE; +} -- 2.34.1