src/sensor-data.c

   1 /*
   2  * Copyright (c) 2018 Samsung Electronics Co., Ltd.
   3  *
   4  * Contact: Jin Yoon <jinny.yoon@samsung.com>
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  * http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an AS IS BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  */
  18
  19 #include <stdlib.h>
  20 #include <pthread.h>
  21 #include "log.h"
  22 #include "sensor-data.h"
  23
  24 struct __sensor_data_s {
  25         sensor_data_type_e type;
  26         union {
  27                 int int_val;
  28                 unsigned int uint_val;
  29                 bool b_val;
  30                 double d_val;
  31                 char *str_val;
  32         } value;
  33         pthread_mutex_t mutex;
  34 };
  35
  36 sensor_data *sensor_data_new(sensor_data_type_e type)
  37 {
  38         sensor_data *data = NULL;
  39         retv_if(type == SENSOR_DATA_TYPE_NONE, NULL);
  40
  41         data = calloc(1, sizeof(sensor_data));
  42         retv_if(!data, NULL);
  43
  44         data->type = type;
  45         pthread_mutex_init(&data->mutex, NULL);
  46
  47         return data;
  48 }
  49
  50 void sensor_data_free(sensor_data *data)
  51 {
  52         ret_if(!data);
  53
  54         if (data->type == SENSOR_DATA_TYPE_STR) {
  55                 pthread_mutex_lock(&data->mutex);
  56                 free(data->value.str_val);
  57                 data->value.str_val = NULL;
  58                 pthread_mutex_unlock(&data->mutex);
  59         }
  60         pthread_mutex_destroy(&data->mutex);
  61
  62         free(data);
  63 }
  64
  65 int sensor_data_set_int(sensor_data *data, int value)
  66 {
  67         retv_if(!data, -1);
  68         retv_if(data->type != SENSOR_DATA_TYPE_INT, -1);
  69
  70         pthread_mutex_lock(&data->mutex);
  71         data->value.int_val = value;
  72         pthread_mutex_unlock(&data->mutex);
  73
  74         return 0;
  75 }
  76
  77 int sensor_data_set_uint(sensor_data *data, unsigned int value)
  78 {
  79         retv_if(!data, -1);
  80         retv_if(data->type != SENSOR_DATA_TYPE_UINT, -1);
  81
  82         pthread_mutex_lock(&data->mutex);
  83         data->value.uint_val = value;
  84         pthread_mutex_unlock(&data->mutex);
  85
  86         return 0;
  87 }
  88
  89 int sensor_data_set_bool(sensor_data *data, bool value)
  90 {
  91         retv_if(!data, -1);
  92         retv_if(data->type != SENSOR_DATA_TYPE_BOOL, -1);
  93
  94         pthread_mutex_lock(&data->mutex);
  95         data->value.b_val = value;
  96         pthread_mutex_unlock(&data->mutex);
  97
  98         return 0;
  99 }
 100
 101 int sensor_data_set_double(sensor_data *data, double value)
 102 {
 103         retv_if(!data, -1);
 104         retv_if(data->type != SENSOR_DATA_TYPE_DOUBLE, -1);
 105
 106         pthread_mutex_lock(&data->mutex);
 107         data->value.d_val = value;
 108         pthread_mutex_unlock(&data->mutex);
 109
 110         return 0;
 111 }
 112
 113 int sensor_data_set_string(sensor_data *data, const char *value, unsigned int size)
 114 {
 115         char *temp = NULL;
 116         retv_if(!data, -1);
 117         retv_if(data->type != SENSOR_DATA_TYPE_STR, -1);
 118         retv_if(!value, -1);
 119         retv_if(size == 0, -1);
 120
 121         temp = strndup(value, size);
 122         retv_if(!temp, -1);
 123
 124         pthread_mutex_lock(&data->mutex);
 125         free(data->value.str_val);
 126         data->value.str_val = temp;
 127         pthread_mutex_unlock(&data->mutex);
 128
 129         return 0;
 130 }
 131
 132 int sensor_data_get_int(sensor_data *data, int *value)
 133 {
 134         retv_if(!data, -1);
 135         retv_if(!value, -1);
 136         retv_if(data->type != SENSOR_DATA_TYPE_INT, -1);
 137
 138         pthread_mutex_lock(&data->mutex);
 139         *value = data->value.int_val;
 140         pthread_mutex_unlock(&data->mutex);
 141
 142         return 0;
 143 }
 144
 145 int sensor_data_get_uint(sensor_data *data, unsigned int *value)
 146 {
 147         retv_if(!data, -1);
 148         retv_if(!value, -1);
 149         retv_if(data->type != SENSOR_DATA_TYPE_UINT, -1);
 150
 151         pthread_mutex_lock(&data->mutex);
 152         *value = data->value.uint_val;
 153         pthread_mutex_unlock(&data->mutex);
 154
 155         return 0;
 156 }
 157
 158 int sensor_data_get_bool(sensor_data *data, bool *value)
 159 {
 160         retv_if(!data, -1);
 161         retv_if(!value, -1);
 162         retv_if(data->type != SENSOR_DATA_TYPE_BOOL, -1);
 163
 164         pthread_mutex_lock(&data->mutex);
 165         *value = data->value.b_val;
 166         pthread_mutex_unlock(&data->mutex);
 167
 168         return 0;
 169 }
 170
 171 int sensor_data_get_double(sensor_data *data, double *value)
 172 {
 173         retv_if(!data, -1);
 174         retv_if(!value, -1);
 175         retv_if(data->type != SENSOR_DATA_TYPE_DOUBLE, -1);
 176
 177         pthread_mutex_lock(&data->mutex);
 178         *value = data->value.d_val;
 179         pthread_mutex_unlock(&data->mutex);
 180
 181         return 0;
 182 }
 183
 184 int sensor_data_get_string(sensor_data *data, const char **value)
 185 {
 186         retv_if(!data, -1);
 187         retv_if(!value, -1);
 188         retv_if(data->type != SENSOR_DATA_TYPE_STR, -1);
 189
 190         pthread_mutex_lock(&data->mutex);
 191         *value = data->value.str_val;
 192         pthread_mutex_unlock(&data->mutex);
 193
 194         return 0;
 195 }