src/sensor_provider.cpp

   1 /*
   2  * Copyright (c) 2017 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <sensor.h>
  18 #include <sensor_private.h>
  19 #include <sensor_internal.h>
  20 #include <new>
  21 #include <map>
  22
  23 #include "include/sensor_log.h"
  24
  25 #define RETV_IF(expr, val) \
  26         do { if (expr) { return (val); } } while (0)
  27
  28 typedef struct _sensor_provider_s {
  29         sensord_provider_h sensor;
  30         sensor_provider_start_cb start_cb;
  31         sensor_provider_stop_cb  stop_cb;
  32         sensor_provider_interval_changed_cb interval_cb;
  33         void *start_user_data;
  34         void *stop_user_data;
  35         void *interval_user_data;
  36 } sensor_provider_handle;
  37
  38 int sensor_create_provider(const char *uri, sensor_provider_h *provider)
  39 {
  40         RETV_IF(!provider, SENSOR_ERROR_INVALID_PARAMETER);
  41
  42         *provider = new(std::nothrow) sensor_provider_handle();
  43         RETV_IF(!*provider, SENSOR_ERROR_OUT_OF_MEMORY);
  44
  45         (*provider)->sensor = NULL;
  46         (*provider)->stop_cb = NULL;
  47         (*provider)->interval_cb = NULL;
  48         (*provider)->start_cb = NULL;
  49         (*provider)->start_user_data = NULL;
  50         (*provider)->stop_user_data = NULL;
  51         (*provider)->interval_user_data = NULL;
  52
  53         return sensord_create_provider(uri, &(*provider)->sensor);
  54 }
  55
  56 int sensor_add_provider(sensor_provider_h provider)
  57 {
  58         RETV_IF(!provider, SENSOR_ERROR_INVALID_PARAMETER);
  59
  60         int result;
  61         result = sensord_add_provider(provider->sensor);
  62         RETV_IF(result == -EINVAL, SENSOR_ERROR_INVALID_PARAMETER);
  63         RETV_IF(result == -EACCES, SENSOR_ERROR_PERMISSION_DENIED);
  64         RETV_IF(result < 0, SENSOR_ERROR_OPERATION_FAILED);
  65
  66         return SENSOR_ERROR_NONE;
  67 }
  68
  69 int sensor_remove_provider(sensor_provider_h provider)
  70 {
  71         RETV_IF(!provider, SENSOR_ERROR_INVALID_PARAMETER);
  72
  73         int result;
  74         result = sensord_remove_provider(provider->sensor);
  75         RETV_IF(result == -EINVAL, SENSOR_ERROR_INVALID_PARAMETER);
  76         RETV_IF(result < 0, SENSOR_ERROR_OPERATION_FAILED);
  77
  78         return SENSOR_ERROR_NONE;
  79 }
  80
  81 int sensor_destroy_provider(sensor_provider_h provider)
  82 {
  83         RETV_IF(!provider, SENSOR_ERROR_INVALID_PARAMETER);
  84
  85         int result;
  86         result = sensord_destroy_provider(provider->sensor);
  87
  88         if (result == SENSOR_ERROR_NONE)
  89                 delete provider;
  90
  91         return result;
  92 }
  93
  94 int sensor_provider_set_name(sensor_provider_h provider, const char *name)
  95 {
  96         RETV_IF(!provider, SENSOR_ERROR_INVALID_PARAMETER);
  97         return sensord_provider_set_name(provider->sensor, name);
  98 }
  99
 100 int sensor_provider_set_vendor(sensor_provider_h provider, const char *vendor)
 101 {
 102         RETV_IF(!provider, SENSOR_ERROR_INVALID_PARAMETER);
 103         return sensord_provider_set_vendor(provider->sensor, vendor);
 104 }
 105
 106 int sensor_provider_set_range(sensor_provider_h provider, float min_range, float max_range)
 107 {
 108         RETV_IF(!provider, SENSOR_ERROR_INVALID_PARAMETER);
 109         return sensord_provider_set_range(provider->sensor, min_range, max_range);
 110 }
 111
 112 int sensor_provider_set_resolution(sensor_provider_h provider, float resolution)
 113 {
 114         RETV_IF(!provider, SENSOR_ERROR_INVALID_PARAMETER);
 115         return sensord_provider_set_resolution(provider->sensor, resolution);
 116 }
 117
 118 static void sensor_start_callback(sensord_provider_h provider, void *user_data)
 119 {
 120         sensor_provider_h p = (sensor_provider_h)user_data;
 121         if (p->start_cb)
 122                 p->start_cb(p, p->start_user_data);
 123 }
 124
 125 int sensor_provider_set_start_cb(sensor_provider_h provider,
 126                 sensor_provider_start_cb callback, void *user_data)
 127 {
 128         RETV_IF(!provider, SENSOR_ERROR_INVALID_PARAMETER);
 129         RETV_IF(!callback, SENSOR_ERROR_INVALID_PARAMETER);
 130
 131         provider->start_cb = callback;
 132         provider->start_user_data = user_data;
 133
 134         return sensord_provider_set_start_cb(provider->sensor, sensor_start_callback, provider);
 135 }
 136
 137 static void sensor_stop_callback(sensord_provider_h provider, void *user_data)
 138 {
 139         sensor_provider_h p = (sensor_provider_h)user_data;
 140         if (p->stop_cb)
 141                 p->stop_cb(p, p->stop_user_data);
 142 }
 143
 144 int sensor_provider_set_stop_cb(sensor_provider_h provider,
 145                 sensor_provider_stop_cb callback, void *user_data)
 146 {
 147         RETV_IF(!provider, SENSOR_ERROR_INVALID_PARAMETER);
 148         RETV_IF(!callback, SENSOR_ERROR_INVALID_PARAMETER);
 149
 150         provider->stop_cb = callback;
 151         provider->stop_user_data = user_data;
 152
 153         return sensord_provider_set_stop_cb(provider->sensor, sensor_stop_callback, provider);
 154 }
 155
 156 static void sensor_interval_changed_callback(sensord_provider_h provider,
 157                 unsigned int interval_ms, void *user_data)
 158 {
 159         sensor_provider_h p = (sensor_provider_h)user_data;
 160         if (p->interval_cb)
 161                 p->interval_cb(p, interval_ms, p->interval_user_data);
 162 }
 163
 164 int sensor_provider_set_interval_changed_cb(sensor_provider_h provider,
 165                 sensor_provider_interval_changed_cb callback, void *user_data)
 166 {
 167         RETV_IF(!provider, SENSOR_ERROR_INVALID_PARAMETER);
 168         RETV_IF(!callback, SENSOR_ERROR_INVALID_PARAMETER);
 169
 170         provider->interval_cb = callback;
 171         provider->interval_user_data = user_data;
 172
 173         return sensord_provider_set_interval_changed_cb(provider->sensor,
 174                         sensor_interval_changed_callback, provider);
 175 }
 176
 177 int sensor_provider_publish(sensor_provider_h provider, sensor_event_s event)
 178 {
 179         RETV_IF(!provider, SENSOR_ERROR_INVALID_PARAMETER);
 180
 181         int result;
 182         sensor_data_t data;
 183         memcpy(&data, &event, sizeof(data));
 184
 185         result = sensord_provider_publish(provider->sensor, data);
 186         RETV_IF(result == -EINVAL, SENSOR_ERROR_INVALID_PARAMETER);
 187         RETV_IF(result < 0, SENSOR_ERROR_OPERATION_FAILED);
 188
 189         return SENSOR_ERROR_NONE;
 190 }