src/server/sensor_handler.cpp

   1 /*
   2  * sensord
   3  *
   4  * Copyright (c) 2017 Samsung Electronics Co., Ltd.
   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
  20 #include "sensor_handler.h"
  21
  22 #include <message.h>
  23 #include <sensor_log.h>
  24 #include <sensor_utils.h>
  25 #include <sensor_types_private.h>
  26
  27 using namespace sensor;
  28
  29 sensor_handler::sensor_handler(const sensor_info &info)
  30 : m_info(info)
  31 , m_last_data(NULL)
  32 , m_last_data_size(0)
  33 {
  34         const char *priv = sensor::utils::get_privilege(m_info.get_uri());
  35         m_info.set_privilege(priv);
  36
  37         sensor_type_t type = sensor::utils::get_type(m_info.get_uri());
  38         m_info.set_type(type);
  39
  40         /* TODO: temporary walkaround for sensors that require multiple privileges */
  41         switch (m_info.get_type()) {
  42         case EXTERNAL_EXERCISE_SENSOR:
  43         case EXERCISE_STANDALONE_SENSOR:
  44                 m_info.add_privilege(PRIVILEGE_LOCATION_URI);
  45                 break;
  46         default:
  47                 break;
  48         }
  49 }
  50
  51 bool sensor_handler::has_observer(sensor_observer *ob)
  52 {
  53         for (auto it = m_observers.begin(); it != m_observers.end(); ++it) {
  54                 if ((*it) == ob)
  55                         return true;
  56         }
  57
  58         return false;
  59 }
  60
  61 void sensor_handler::add_observer(sensor_observer *ob)
  62 {
  63         ret_if(has_observer(ob));
  64
  65         m_observers.push_back(ob);
  66 }
  67
  68 void sensor_handler::remove_observer(sensor_observer *ob)
  69 {
  70         m_observers.remove(ob);
  71 }
  72
  73 int sensor_handler::notify(const char *uri, sensor_data_t *data, int len)
  74 {
  75         if (observer_count() == 0)
  76                 return OP_ERROR;
  77
  78         ipc::message *msg;
  79
  80         msg = new(std::nothrow) ipc::message((char *)data, len);
  81         retvm_if(!msg, OP_ERROR, "Failed to allocate memory");
  82
  83         for (auto it = m_observers.begin(); it != m_observers.end(); ++it)
  84                 (*it)->update(uri, msg);
  85
  86         if (msg->ref_count() == 0) {
  87                 delete msg;
  88                 msg = NULL;
  89         }
  90
  91         set_cache(data, len);
  92
  93         return OP_SUCCESS;
  94 }
  95
  96 uint32_t sensor_handler::observer_count(void)
  97 {
  98         return m_observers.size();
  99 }
 100
 101 void sensor_handler::set_cache(sensor_data_t *data, int size)
 102 {
 103         retm_if(data == NULL, "Nothing to copy from as source is NULL");
 104         retm_if(size <= 0, "data is of size 0");
 105
 106         if (m_last_data_size != size) {
 107                 m_last_data = (sensor_data_t*)realloc(m_last_data, size);
 108                 retm_if(m_last_data == NULL, "Memory allocation failed");
 109                 m_last_data_size = size;
 110         }
 111
 112         memcpy(m_last_data, data, size);
 113 }
 114
 115 int sensor_handler::get_cache(sensor_data_t **data, int *len)
 116 {
 117         retv_if(m_last_data == NULL, -ENODATA);
 118
 119         *data = (sensor_data_t *)malloc(m_last_data_size);
 120         retvm_if(*data == NULL, -ENOMEM, "Memory allocation failed");
 121
 122         memcpy(*data, m_last_data, m_last_data_size);
 123         *len = m_last_data_size;
 124
 125         return 0;
 126 }