src/server/client_info_manager.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 <command_common.h>
  21 #include <client_info_manager.h>
  22 #include <sensor_log.h>
  23 #include <csocket.h>
  24
  25 using std::pair;
  26 using std::string;
  27
  28 client_info_manager::client_info_manager()
  29 {
  30 }
  31
  32 client_info_manager::~client_info_manager()
  33 {
  34         m_clients.clear();
  35 }
  36
  37 client_info_manager& client_info_manager::get_instance()
  38 {
  39         static client_info_manager inst;
  40         return inst;
  41 }
  42
  43 bool client_info_manager::get_registered_events(int client_id, sensor_id_t sensor_id, event_type_vector &event_vec)
  44 {
  45         AUTOLOCK(m_mutex);
  46
  47         auto it_record = m_clients.find(client_id);
  48
  49         if (it_record == m_clients.end()) {
  50                 _E("Client[%d] is not found", client_id);
  51                 return false;
  52         }
  53
  54         if(!it_record->second.get_registered_events(sensor_id, event_vec))
  55                 return false;
  56
  57         return true;
  58 }
  59
  60 bool client_info_manager::register_event(int client_id, sensor_id_t sensor_id, unsigned int event_type)
  61 {
  62         AUTOLOCK(m_mutex);
  63
  64         auto it_record = m_clients.find(client_id);
  65
  66         if (it_record == m_clients.end()) {
  67                 _E("Client[%d] is not found", client_id);
  68                 return false;
  69         }
  70
  71         if(!it_record->second.register_event(sensor_id, event_type))
  72                 return false;
  73
  74         return true;
  75 }
  76
  77 bool client_info_manager::unregister_event(int client_id, sensor_id_t sensor_id, unsigned int event_type)
  78 {
  79         AUTOLOCK(m_mutex);
  80
  81         auto it_record = m_clients.find(client_id);
  82
  83         if (it_record == m_clients.end()) {
  84                 _E("Client[%d] is not found", client_id);
  85                 return false;
  86         }
  87
  88         if(!it_record->second.unregister_event(sensor_id, event_type))
  89                 return false;
  90
  91         return true;
  92 }
  93
  94 bool client_info_manager::set_batch(int client_id, sensor_id_t sensor_id, unsigned int interval, unsigned latency)
  95 {
  96         AUTOLOCK(m_mutex);
  97
  98         auto it_record = m_clients.find(client_id);
  99
 100         if (it_record == m_clients.end()) {
 101                 _E("Client[%d] is not found", client_id);
 102                 return false;
 103         }
 104
 105         return it_record->second.set_batch(sensor_id, interval, latency);
 106 }
 107
 108 bool client_info_manager::get_batch(int client_id, sensor_id_t sensor_id, unsigned int &interval, unsigned int &latency)
 109 {
 110         AUTOLOCK(m_mutex);
 111
 112         auto it_record = m_clients.find(client_id);
 113
 114         if (it_record == m_clients.end()) {
 115                 _E("Client[%d] is not found", client_id);
 116                 return false;
 117         }
 118
 119         return it_record->second.get_batch(sensor_id, interval, latency);
 120 }
 121
 122 bool client_info_manager::set_option(int client_id, sensor_id_t sensor_id, int option)
 123 {
 124         AUTOLOCK(m_mutex);
 125
 126         auto it_record = m_clients.find(client_id);
 127
 128         if (it_record == m_clients.end()) {
 129                 _E("Client[%d] is not found", client_id);
 130                 return false;
 131         }
 132
 133         if(!it_record->second.set_option(sensor_id, option))
 134                 return false;
 135
 136         return true;
 137 }
 138
 139 bool client_info_manager::set_start(int client_id, sensor_id_t sensor_id, bool start)
 140 {
 141         AUTOLOCK(m_mutex);
 142
 143         auto it_record = m_clients.find(client_id);
 144
 145         if (it_record == m_clients.end()) {
 146                 _E("Client[%d] is not found", client_id);
 147                 return false;
 148         }
 149
 150         if(!it_record->second.set_start(sensor_id, start))
 151                 return false;
 152
 153         return true;
 154 }
 155
 156 bool client_info_manager::is_started(int client_id, sensor_id_t sensor_id)
 157 {
 158         AUTOLOCK(m_mutex);
 159
 160         auto it_record = m_clients.find(client_id);
 161
 162         if (it_record == m_clients.end()) {
 163                 _E("Client[%d] is not found", client_id);
 164                 return false;
 165         }
 166
 167         return it_record->second.is_started(sensor_id);
 168 }
 169
 170 int client_info_manager::create_client_record(void)
 171 {
 172         AUTOLOCK(m_mutex);
 173
 174         int client_id = 0;
 175
 176         client_sensor_record client_record;
 177
 178         while (m_clients.count(client_id) > 0)
 179                 client_id++;
 180
 181         if (client_id == MAX_HANDLE) {
 182                 _E("Sensor records of clients are full");
 183                 return MAX_HANDLE_REACHED;
 184         }
 185
 186         client_record.set_client_id(client_id);
 187
 188         m_clients.insert(pair<int, client_sensor_record> (client_id, client_record));
 189
 190         return client_id;
 191 }
 192
 193 bool client_info_manager::remove_client_record(int client_id)
 194 {
 195         AUTOLOCK(m_mutex);
 196
 197         auto it_record = m_clients.find(client_id);
 198
 199         if (it_record == m_clients.end()) {
 200                 _E("Client[%d] is not found", client_id);
 201                 return false;
 202         }
 203
 204         m_clients.erase(it_record);
 205
 206         _I("Client record for client[%d] is removed from client info manager", client_id);
 207
 208         return true;
 209 }
 210
 211 bool client_info_manager::has_client_record(int client_id)
 212 {
 213         AUTOLOCK(m_mutex);
 214
 215         auto it_record = m_clients.find(client_id);
 216
 217         return (it_record != m_clients.end());
 218 }
 219
 220 void client_info_manager::set_client_info(int client_id, pid_t pid, const string &name)
 221 {
 222         AUTOLOCK(m_mutex);
 223
 224         auto it_record = m_clients.find(client_id);
 225
 226         if (it_record == m_clients.end()) {
 227                 _E("Client[%d] is not found", client_id);
 228                 return;
 229         }
 230
 231         it_record->second.set_client_info(pid, name);
 232
 233         return;
 234 }
 235
 236 const char* client_info_manager::get_client_info(int client_id)
 237 {
 238         AUTOLOCK(m_mutex);
 239
 240         auto it_record = m_clients.find(client_id);
 241
 242         if (it_record == m_clients.end()) {
 243                 _D("Client[%d] is not found", client_id);
 244                 return NULL;
 245         }
 246
 247         return it_record->second.get_client_info();
 248 }
 249
 250 bool client_info_manager::set_permission(int client_id, int permission)
 251 {
 252         AUTOLOCK(m_mutex);
 253
 254         auto it_record = m_clients.find(client_id);
 255
 256         if (it_record == m_clients.end()) {
 257                 _D("Client[%d] is not found", client_id);
 258                 return false;
 259         }
 260
 261         it_record->second.set_permission(permission);
 262         return true;
 263 }
 264
 265 bool client_info_manager::get_permission(int client_id, int &permission)
 266 {
 267         AUTOLOCK(m_mutex);
 268
 269         auto it_record = m_clients.find(client_id);
 270
 271         if (it_record == m_clients.end()) {
 272                 _D("Client[%d] is not found", client_id);
 273                 return false;
 274         }
 275
 276         permission = it_record->second.get_permission();
 277         return true;
 278 }
 279
 280 bool client_info_manager::create_sensor_record(int client_id, sensor_id_t sensor_id)
 281 {
 282         AUTOLOCK(m_mutex);
 283
 284         auto it_record = m_clients.find(client_id);
 285
 286         if (it_record == m_clients.end()) {
 287                 _E("Client record[%d] is not registered", client_id);
 288                 return false;
 289         }
 290
 291         it_record->second.add_sensor_usage(sensor_id);
 292
 293         return true;
 294 }
 295
 296 bool client_info_manager::remove_sensor_record(int client_id, sensor_id_t sensor_id)
 297 {
 298         AUTOLOCK(m_mutex);
 299
 300         auto it_record = m_clients.find(client_id);
 301
 302         if (it_record == m_clients.end()) {
 303                 _E("Client[%d] is not found", client_id);
 304                 return false;
 305         }
 306
 307         if(!it_record->second.remove_sensor_usage(sensor_id))
 308                 return false;
 309
 310         if(!it_record->second.has_sensor_usage())
 311                 remove_client_record(client_id);
 312
 313         return true;
 314 }
 315
 316 bool client_info_manager::has_sensor_record(int client_id, sensor_id_t sensor_id)
 317 {
 318         AUTOLOCK(m_mutex);
 319
 320         auto it_record = m_clients.find(client_id);
 321
 322         if (it_record == m_clients.end()) {
 323                 _D("Client[%d] is not found", client_id);
 324                 return false;
 325         }
 326
 327         if(!it_record->second.has_sensor_usage(sensor_id))
 328                 return false;
 329
 330         return true;
 331 }
 332
 333 bool client_info_manager::has_sensor_record(int client_id)
 334 {
 335         AUTOLOCK(m_mutex);
 336
 337         auto it_record = m_clients.find(client_id);
 338
 339         if (it_record == m_clients.end()) {
 340                 _D("Client[%d] is not found", client_id);
 341                 return false;
 342         }
 343
 344         if(!it_record->second.has_sensor_usage())
 345                 return false;
 346
 347         return true;
 348 }
 349
 350 bool client_info_manager::get_listener_ids(sensor_id_t sensor_id, unsigned int event_type, client_id_vec &id_vec)
 351 {
 352         AUTOLOCK(m_mutex);
 353
 354         auto it_record = m_clients.begin();
 355
 356         while (it_record != m_clients.end()) {
 357                 if(it_record->second.is_listening_event(sensor_id, event_type))
 358                         id_vec.push_back(it_record->first);
 359
 360                 ++it_record;
 361         }
 362
 363         return true;
 364 }
 365
 366 bool client_info_manager::get_event_socket(int client_id, csocket &socket)
 367 {
 368         AUTOLOCK(m_mutex);
 369
 370         auto it_record = m_clients.find(client_id);
 371
 372         if (it_record == m_clients.end()) {
 373                 _E("Client[%d] is not found", client_id);
 374                 return false;
 375         }
 376
 377         it_record->second.get_event_socket(socket);
 378
 379         return true;
 380 }
 381
 382 bool client_info_manager::set_event_socket(int client_id, const csocket &socket)
 383 {
 384         AUTOLOCK(m_mutex);
 385
 386         auto it_record = m_clients.find(client_id);
 387
 388         if (it_record == m_clients.end()) {
 389                 _E("Client[%d] is not found", client_id);
 390                 return false;
 391         }
 392
 393         it_record->second.set_event_socket(socket);
 394
 395         return true;
 396 }