src/model.c

   1 /*
   2  * Copyright (c) 2017 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Contact: Jin Yoon <jinny.yoon@samsung.com>
   5  *          Geunsun Lee <gs86.lee@samsung.com>
   6  *          Eunyoung Lee <ey928.lee@samsung.com>
   7  *          Junkyu Han <junkyu.han@samsung.com>
   8  *
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  * http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  */
  21
  22 #include <stdlib.h>
  23 #include <unistd.h>
  24 #include <peripheral_io.h>
  25 #include <sys/time.h>
  26 #include <Eina.h>
  27
  28 #include "log.h"
  29 #include "model.h"
  30 #include "model/model_ultrasonic_sensor.h"
  31 #include "model/model_infrared_motion_sensor.h"
  32 #include "model/model_infrared_obstacle_avoidance_sensor.h"
  33 #include "model/model_touch_sensor.h"
  34
  35 struct _model_sensor_s {
  36         char *id;
  37         sensor_type_e sensor_type;
  38         int gpio_num[2];
  39         void *peripheral_info;
  40 };
  41 static struct {
  42         Eina_List *list;
  43 } model_s;
  44
  45 int model_init(const char *id, sensor_type_e sensor_type, int gpio_num1, int gpio_num2, model_sensor_h *out_info)
  46 {
  47         model_sensor_h info = NULL;
  48         int ret = -1;
  49
  50         retv_if(!id, -1);
  51
  52         info = calloc(1, sizeof(model_sensor_s));
  53         retv_if(!info, -1);
  54         *out_info = info;
  55
  56         info->sensor_type = sensor_type;
  57         info->id = strdup(id);
  58         goto_if(!info->id, error);
  59
  60         info->gpio_num[0] = gpio_num1;
  61         info->gpio_num[1] = gpio_num2;
  62         goto_if(gpio_num1 == -1, error);
  63
  64         switch (sensor_type) {
  65         case SENSOR_TYPE_ULTRASONIC:
  66                 goto_if(gpio_num2 == -1, error);
  67                 ret = model_init_ultrasonic_sensor(gpio_num1, gpio_num2, &info->peripheral_info);
  68                 break;
  69         case SENSOR_TYPE_INFRARED_MOTION:
  70                 ret = model_init_infrared_motion_sensor(gpio_num1, &info->peripheral_info);
  71                 break;
  72         case SENSOR_TYPE_INFRARED_OBSTACLE_AVOIDANCE:
  73                 ret = model_init_infrared_obstacle_avoidance_sensor(gpio_num1, &info->peripheral_info);
  74                 break;
  75         case SENSOR_TYPE_TOUCH:
  76                 ret = model_init_touch_sensor(gpio_num1, &info->peripheral_info);
  77                 break;
  78         default:
  79                 break;
  80         }
  81
  82         goto_if(ret != 0, error);
  83
  84         return 0;
  85
  86 error:
  87         if (info->id) free(info->id);
  88         if (info) free(info);
  89         *out_info = NULL;
  90         return -1;
  91 }
  92
  93 void model_fini(model_sensor_h info)
  94 {
  95         ret_if(!info);
  96
  97         switch (info->sensor_type) {
  98         case SENSOR_TYPE_ULTRASONIC:
  99                 model_fini_ultrasonic_sensor(info->peripheral_info);
 100                 break;
 101         case SENSOR_TYPE_INFRARED_MOTION:
 102                 model_fini_infrared_motion_sensor(info->peripheral_info);
 103                 break;
 104         case SENSOR_TYPE_INFRARED_OBSTACLE_AVOIDANCE:
 105                 model_fini_infrared_obstacle_avoidance_sensor(info->peripheral_info);
 106                 break;
 107         case SENSOR_TYPE_TOUCH:
 108                 model_fini_touch_sensor(info->peripheral_info);
 109                 break;
 110         default:
 111                 break;
 112         }
 113
 114         free(info->id);
 115         free(info);
 116 }
 117
 118 int model_read_int_value(model_sensor_h info, int *out_value)
 119 {
 120         int ret = 0;
 121
 122         switch (info->sensor_type) {
 123         case SENSOR_TYPE_ULTRASONIC:
 124                 ret = model_read_infrared_obstacle_avoidance_sensor(info, out_value);
 125                 break;
 126         case SENSOR_TYPE_INFRARED_MOTION:
 127                 ret = model_read_infrared_motion_sensor(info, out_value);
 128                 break;
 129         case SENSOR_TYPE_TOUCH:
 130                 ret = model_read_touch_sensor(info, out_value);
 131                 break;
 132         default:
 133                 break;
 134         }
 135
 136         if (ret < 0) {
 137                 _E("Something wrong in the result[%d]", ret);
 138                 return -1;
 139         }
 140
 141         return 0;
 142 }
 143
 144 int model_read_double_value(model_sensor_h info, double *out_value)
 145 {
 146         int ret = 0;
 147
 148         switch (info->sensor_type) {
 149         case SENSOR_TYPE_ULTRASONIC:
 150                 ret = model_read_ultrasonic_sensor(info, out_value);
 151                 break;
 152         default:
 153                 _E("There is no data to retrieve");
 154                 break;
 155         }
 156
 157         if (ret < 0) {
 158                 _E("Something wrong in the result[%d]", ret);
 159                 return -1;
 160         }
 161
 162         return 0;
 163 }
 164
 165 int model_list_add_sensor(model_sensor_h info)
 166 {
 167         Eina_List *l, *ln;
 168         model_sensor_h temp = NULL;
 169
 170         retv_if(!info, -1);
 171         retv_if(!info->id, -1);
 172
 173         EINA_LIST_FOREACH_SAFE(model_s.list, l, ln, temp) {
 174                 retv_if(!temp->id, -1);
 175                 if (!strcmp(temp->id, info->id)) {
 176                         _E("That id[%s] already exists.", info->id);
 177                         return -1;
 178                 }
 179         }
 180         model_s.list = eina_list_append(model_s.list, info);
 181         return 0;
 182 }
 183
 184 int model_list_remove_sensor(model_sensor_h info)
 185 {
 186         retv_if(!info, -1);
 187         model_s.list = eina_list_remove(model_s.list, info);
 188         return 0;
 189 }
 190
 191 int model_list_get_sensor(const char *id, model_sensor_h *out_info)
 192 {
 193         Eina_List *l, *ln;
 194         model_sensor_h temp = NULL;
 195
 196         retv_if(!id, -1);
 197
 198         EINA_LIST_FOREACH_SAFE(model_s.list, l, ln, temp) {
 199                 retv_if(!temp->id, -1);
 200                 if (!strcmp(temp->id, id)) {
 201                         _E("That id[%s] already exists.", id);
 202                         *out_info = temp;
 203                         return 0;
 204                 }
 205         }
 206
 207         *out_info = NULL;
 208         return -1;
 209 }
 210
 211 int model_list_foreach(void (*cb)(model_sensor_h info))
 212 {
 213         Eina_List *l, *ln;
 214         model_sensor_h temp = NULL;
 215
 216         retv_if(!cb, -1);
 217
 218         EINA_LIST_FOREACH_SAFE(model_s.list, l, ln, temp) {
 219                 cb(temp);
 220         }
 221
 222         return 0;
 223 }