sensor: api: implement URI-based APIs and sensor provider APIs

Change-Id: I339e2964b256f96d4462b57a2077bfd668be0ade
Signed-off-by: kibak.yoon <kibak.yoon@samsung.com>

diff --git a/CMakeLists.txt b/CMakeLists.txt
index d149868..e2d3fcb 100644 (file)
--- 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 (file)
--- 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 (file)
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 <sensor.h>
+#include <sensor_private.h>
+#include <sensor_internal.h>
+#include <new>
+#include <map>
+
+#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;
+}