src/server/client_sensor_record.cpp

   1 /*
   2  * sensord
   3  *
   4  * Copyright (c) 2013 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 <client_sensor_record.h>
  21 #include <sensor_log.h>
  22
  23 using std::pair;
  24 using std::string;
  25
  26 client_sensor_record::client_sensor_record()
  27 : m_client_id(0)
  28 , m_pid(-1)
  29 , m_permission(SENSOR_PERMISSION_NONE)
  30 {
  31 }
  32
  33 client_sensor_record::~client_sensor_record()
  34 {
  35         m_sensor_usages.clear();
  36         close_event_socket();
  37 }
  38
  39 bool client_sensor_record::register_event(sensor_id_t sensor_id, unsigned int event_type)
  40 {
  41         auto it_usage = m_sensor_usages.find(sensor_id);
  42
  43         if (it_usage == m_sensor_usages.end()) {
  44                 sensor_usage usage;
  45                 usage.register_event(event_type);
  46                 m_sensor_usages.insert(pair<sensor_id_t, sensor_usage>(sensor_id, usage));
  47                 return true;
  48         }
  49
  50         if (!it_usage->second.register_event(event_type)) {
  51                 _E("Event[%#x] is already registered", event_type);
  52                 return false;
  53         }
  54
  55         return true;
  56 }
  57
  58 bool client_sensor_record::unregister_event(sensor_id_t sensor_id, unsigned int event_type)
  59 {
  60         auto it_usage = m_sensor_usages.find(sensor_id);
  61
  62         if (it_usage == m_sensor_usages.end()) {
  63                 _E("Sensor[%#x] is not registered", sensor_id);
  64                 return false;
  65         }
  66
  67         if (!it_usage->second.unregister_event(event_type)) {
  68                 _E("Event[%#x] is already registered", event_type);
  69                 return false;
  70         }
  71
  72         return true;
  73 }
  74
  75 bool client_sensor_record::set_pause_policy(sensor_id_t sensor_id, int pause_policy)
  76 {
  77         auto it_usage = m_sensor_usages.find(sensor_id);
  78
  79         if (it_usage == m_sensor_usages.end()) {
  80                 sensor_usage usage;
  81                 usage.m_pause_policy = pause_policy;
  82                 m_sensor_usages.insert(pair<sensor_id_t, sensor_usage>(sensor_id, usage));
  83         } else {
  84                 it_usage->second.m_pause_policy = pause_policy;
  85         }
  86
  87         return true;
  88 }
  89
  90 bool client_sensor_record::set_start(sensor_id_t sensor_id, bool start)
  91 {
  92         auto it_usage = m_sensor_usages.find(sensor_id);
  93
  94         if (it_usage == m_sensor_usages.end()) {
  95                 sensor_usage usage;
  96                 usage.m_start = start;
  97                 m_sensor_usages.insert(pair<sensor_id_t, sensor_usage>(sensor_id, usage));
  98         } else {
  99                 it_usage->second.m_start = start;
 100         }
 101
 102         return true;
 103 }
 104
 105 bool client_sensor_record::is_started(sensor_id_t sensor_id)
 106 {
 107         auto it_usage = m_sensor_usages.find(sensor_id);
 108
 109         if (it_usage == m_sensor_usages.end())
 110                 return false;
 111
 112         return it_usage->second.m_start;
 113 }
 114
 115 bool client_sensor_record::set_batch(sensor_id_t sensor_id, unsigned int interval, unsigned int latency)
 116 {
 117         auto it_usage = m_sensor_usages.find(sensor_id);
 118
 119         if (it_usage == m_sensor_usages.end()) {
 120                 sensor_usage usage;
 121                 usage.m_interval = interval;
 122                 usage.m_latency = latency;
 123                 m_sensor_usages.insert(pair<sensor_id_t, sensor_usage>(sensor_id, usage));
 124         } else {
 125                 it_usage->second.m_interval = interval;
 126                 it_usage->second.m_latency = latency;
 127         }
 128
 129         return true;
 130 }
 131
 132 bool client_sensor_record::get_batch(sensor_id_t sensor_id, unsigned int &interval, unsigned int &latency)
 133 {
 134         auto it_usage = m_sensor_usages.find(sensor_id);
 135
 136         if (it_usage == m_sensor_usages.end()) {
 137                 _E("Sensor[%#x] is not found", sensor_id);
 138                 return false;
 139         }
 140
 141         interval = it_usage->second.m_interval;
 142         latency = it_usage->second.m_latency;
 143
 144         return true;
 145 }
 146
 147 bool client_sensor_record::is_listening_event(sensor_id_t sensor_id, unsigned int event_type)
 148 {
 149         auto it_usage = m_sensor_usages.find(sensor_id);
 150
 151         if (it_usage == m_sensor_usages.end())
 152                 return false;
 153
 154         if (it_usage->second.is_event_registered(event_type))
 155                 return true;
 156
 157         return false;
 158 }
 159
 160 bool client_sensor_record::add_sensor_usage(sensor_id_t sensor_id)
 161 {
 162         auto it_usage = m_sensor_usages.find(sensor_id);
 163
 164         if (it_usage != m_sensor_usages.end()) {
 165                 _E("Sensor[%#x] is already registered", sensor_id);
 166                 return false;
 167         }
 168
 169         sensor_usage usage;
 170         m_sensor_usages.insert(pair<sensor_id_t, sensor_usage>(sensor_id, usage));
 171         return true;
 172 }
 173
 174 bool client_sensor_record::remove_sensor_usage(sensor_id_t sensor_id)
 175 {
 176         auto it_usage = m_sensor_usages.find(sensor_id);
 177
 178         if (it_usage == m_sensor_usages.end()) {
 179                 _E("Sensor[%#x] is not found", sensor_id);
 180                 return false;
 181         }
 182         m_sensor_usages.erase(it_usage);
 183         return true;
 184 }
 185
 186 bool client_sensor_record::has_sensor_usage(void)
 187 {
 188         if (m_sensor_usages.empty())
 189                 return false;
 190
 191         return true;
 192 }
 193
 194 bool client_sensor_record::has_sensor_usage(sensor_id_t sensor_id)
 195 {
 196         auto it_usage = m_sensor_usages.find(sensor_id);
 197
 198         if (it_usage == m_sensor_usages.end()) {
 199                 _D("Sensor[%#x] is not found", sensor_id);
 200                 return false;
 201         }
 202
 203         return true;
 204 }
 205
 206 bool client_sensor_record::get_registered_events(sensor_id_t sensor_id, event_type_vector &event_vec)
 207 {
 208         auto it_usage = m_sensor_usages.find(sensor_id);
 209
 210         if (it_usage == m_sensor_usages.end()) {
 211                 _D("Sensor[%#x] is not found", sensor_id);
 212                 return false;
 213         }
 214
 215         copy(it_usage->second.m_reg_events.begin(), it_usage->second.m_reg_events.end(), back_inserter(event_vec));
 216
 217         return true;
 218 }
 219
 220 void client_sensor_record::set_client_id(int client_id)
 221 {
 222         m_client_id = client_id;
 223 }
 224
 225 void client_sensor_record::set_client_info(pid_t pid, const string &name)
 226 {
 227         char client_info[NAME_MAX + 32];
 228         m_pid = pid;
 229
 230         snprintf(client_info, sizeof(client_info), "%s[pid=%d, id=%d]", name.c_str(), m_pid, m_client_id);
 231         m_client_info.assign(client_info);
 232 }
 233
 234 const char* client_sensor_record::get_client_info(void)
 235 {
 236         return m_client_info.c_str();
 237 }
 238
 239 void client_sensor_record::set_permission(int permission)
 240 {
 241         m_permission = permission;
 242 }
 243
 244 int client_sensor_record::get_permission(void)
 245 {
 246         return  m_permission;
 247 }
 248
 249 void client_sensor_record::set_event_socket(const csocket &socket)
 250 {
 251         m_event_socket = socket;
 252 }
 253
 254 void client_sensor_record::get_event_socket(csocket &socket)
 255 {
 256         socket = m_event_socket;
 257 }
 258
 259 bool client_sensor_record::close_event_socket(void)
 260 {
 261         return m_event_socket.close();
 262 }