src/client/sensor_internal.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 <sensor_internal.h>
  21 #include <sensor_internal_deprecated.h>
  22 #include <sensor_types.h>
  23
  24 #include <channel_handler.h>
  25 #include <sensor_manager.h>
  26 #include <sensor_listener.h>
  27 #include <sensor_log.h>
  28 #include <unordered_map>
  29
  30 #define CONVERT_OPTION_PAUSE_POLICY(option) ((option) ^ 0b11)
  31
  32 using namespace sensor;
  33
  34 class sensor_event_handler : public ipc::channel_handler
  35 {
  36 public:
  37         sensor_event_handler(sensor_t sensor, sensor_cb_t cb, void *user_data)
  38         : m_sensor(reinterpret_cast<sensor_info *>(sensor))
  39         , m_cb(cb)
  40         , m_user_data(user_data)
  41         {}
  42
  43         void connected(ipc::channel *ch) {}
  44         void disconnected(ipc::channel *ch) {}
  45         void read(ipc::channel *ch, ipc::message &msg)
  46         {
  47                 int event_type;
  48                 sensor_data_t *data;
  49
  50                 data = reinterpret_cast<sensor_data_t *>(msg.body());
  51                 event_type = CONVERT_TYPE_EVENT(m_sensor->get_type());
  52
  53                 m_cb(m_sensor, event_type, data, m_user_data);
  54         }
  55
  56         void read_complete(ipc::channel *ch) {}
  57         void error_caught(ipc::channel *ch, int error) {}
  58
  59 private:
  60         sensor_info *m_sensor;
  61         sensor_cb_t m_cb;
  62         void *m_user_data;
  63 };
  64
  65 class sensor_accuracy_handler : public ipc::channel_handler
  66 {
  67 public:
  68         sensor_accuracy_handler(sensor_t sensor, sensor_accuracy_changed_cb_t cb, void *user_data)
  69         : m_sensor(reinterpret_cast<sensor_info *>(sensor))
  70         , m_cb(cb)
  71         , m_user_data(user_data)
  72         {}
  73
  74         void connected(ipc::channel *ch) {}
  75         void disconnected(ipc::channel *ch) {}
  76         void read(ipc::channel *ch, ipc::message &msg)
  77         {
  78                 sensor_data_t *data;
  79                 data = reinterpret_cast<sensor_data_t *>(msg.body());
  80
  81                 m_cb(m_sensor, data->timestamp, data->accuracy, m_user_data);
  82         }
  83
  84         void read_complete(ipc::channel *ch) {}
  85         void error_caught(ipc::channel *ch, int error) {}
  86
  87 private:
  88         sensor_info *m_sensor;
  89         sensor_accuracy_changed_cb_t m_cb;
  90         void *m_user_data;
  91 };
  92
  93 static sensor::sensor_manager manager;
  94 static std::unordered_map<int, sensor::sensor_listener *> listeners;
  95
  96 /*
  97  * TO-DO-LIST:
  98  * 1. power save option / lcd vconf : move to server
  99  * 2. thread-safe : ipc_client
 100  */
 101
 102 API int sensord_get_sensors(sensor_type_t type, sensor_t **list, int *count)
 103 {
 104         int ret = OP_ERROR;
 105
 106         retvm_if((!list || !count), -EINVAL,
 107                         "Invalid parameter[%#x, %#x]", list, count);
 108         retvm_if(!manager.connect(), -EIO, "Failed to connect");
 109
 110         ret = manager.get_sensors(type, list, count);
 111         retv_if(ret < 0, ret);
 112
 113         return OP_SUCCESS;
 114 }
 115
 116 API int sensord_get_default_sensor(sensor_type_t type, sensor_t *sensor)
 117 {
 118         int ret = OP_ERROR;
 119
 120         retvm_if(!sensor, -EINVAL, "Invalid parameter[%#x]", sensor);
 121         retvm_if(!manager.connect(), -EIO, "Failed to connect");
 122
 123         ret = manager.get_sensor(type, sensor);
 124         retv_if(ret < 0, ret);
 125
 126         return OP_SUCCESS;
 127 }
 128
 129 API bool sensord_get_type(sensor_t sensor, sensor_type_t *type)
 130 {
 131         retvm_if(!type, false, "Invalid parameter[%#x]", type);
 132         retvm_if(!manager.connect(), false, "Failed to connect");
 133         retvm_if(!manager.is_supported(sensor), false,
 134                         "Invalid sensor[%#x]", sensor);
 135
 136         *type = static_cast<sensor_info *>(sensor)->get_type();
 137
 138         return true;
 139 }
 140
 141 API const char* sensord_get_name(sensor_t sensor)
 142 {
 143         retvm_if(!manager.connect(), NULL, "Failed to connect");
 144         retvm_if(!manager.is_supported(sensor), NULL,
 145                         "Invalid sensor[%#x]", sensor);
 146
 147         return static_cast<sensor_info *>(sensor)->get_uri().c_str();
 148 }
 149
 150 API const char* sensord_get_vendor(sensor_t sensor)
 151 {
 152         retvm_if(!manager.connect(), NULL, "Failed to connect");
 153         retvm_if(!manager.is_supported(sensor), NULL,
 154                         "Invalid sensor[%#x]", sensor);
 155
 156         return static_cast<sensor_info *>(sensor)->get_vendor().c_str();
 157 }
 158
 159 API bool sensord_get_min_range(sensor_t sensor, float *min_range)
 160 {
 161         retvm_if(!manager.connect(), false, "Failed to connect");
 162         retvm_if(!min_range, false, "Invalid parameter[%#x]", min_range);
 163         retvm_if(!manager.is_supported(sensor), false,
 164                         "Invalid sensor[%#x]", sensor);
 165
 166         *min_range = static_cast<sensor_info *>(sensor)->get_min_range();
 167
 168         return true;
 169 }
 170
 171 API bool sensord_get_max_range(sensor_t sensor, float *max_range)
 172 {
 173         retvm_if(!max_range, false, "Invalid parameter[%#x]", max_range);
 174         retvm_if(!manager.connect(), false, "Failed to connect");
 175         retvm_if(!manager.is_supported(sensor), false,
 176                         "Invalid sensor[%#x]", sensor);
 177
 178         *max_range = static_cast<sensor_info *>(sensor)->get_max_range();
 179
 180         return true;
 181 }
 182
 183 API bool sensord_get_resolution(sensor_t sensor, float *resolution)
 184 {
 185         retvm_if(!resolution, false, "Invalid parameter[%#x]", resolution);
 186         retvm_if(!manager.connect(), false, "Failed to connect");
 187         retvm_if(!manager.is_supported(sensor), false,
 188                         "Invalid sensor[%#x]", sensor);
 189
 190         *resolution = static_cast<sensor_info *>(sensor)->get_resolution();
 191
 192         return true;
 193 }
 194
 195 API bool sensord_get_min_interval(sensor_t sensor, int *min_interval)
 196 {
 197         retvm_if(!min_interval, false, "Invalid parameter[%#x]", min_interval);
 198         retvm_if(!manager.connect(), false, "Failed to connect");
 199         retvm_if(!manager.is_supported(sensor), false,
 200                         "Invalid sensor[%#x]", sensor);
 201
 202         *min_interval = static_cast<sensor_info *>(sensor)->get_min_interval();
 203
 204         return true;
 205 }
 206
 207 API bool sensord_get_fifo_count(sensor_t sensor, int *fifo_count)
 208 {
 209         retvm_if(!fifo_count, false, "Invalid parameter[%#x]", fifo_count);
 210         retvm_if(!manager.connect(), false, "Failed to connect");
 211         retvm_if(!manager.is_supported(sensor), false,
 212                         "Invalid sensor[%#x]", sensor);
 213
 214         *fifo_count = 0;
 215
 216         return true;
 217 }
 218
 219 API bool sensord_get_max_batch_count(sensor_t sensor, int *max_batch_count)
 220 {
 221         retvm_if(!max_batch_count, false, "Invalid parameter[%#x]", max_batch_count);
 222         retvm_if(!manager.connect(), false, "Failed to connect");
 223         retvm_if(!manager.is_supported(sensor), false,
 224                         "Invalid sensor[%#x]", sensor);
 225
 226         *max_batch_count = static_cast<sensor_info *>(sensor)->get_max_batch_count();
 227
 228         return true;
 229 }
 230
 231 API bool sensord_is_wakeup_supported(sensor_t sensor)
 232 {
 233         retvm_if(!manager.connect(), false, "Failed to connect");
 234         retvm_if(!manager.is_supported(sensor), false,
 235                         "Invalid sensor[%#x]", sensor);
 236
 237         return static_cast<sensor_info *>(sensor)->is_wakeup_supported();
 238 }
 239
 240 API int sensord_connect(sensor_t sensor)
 241 {
 242         retvm_if(!manager.connect(), -EIO, "Failed to connect");
 243         retvm_if(!manager.is_supported(sensor), -EINVAL,
 244                         "Invalid sensor[%#x]", sensor);
 245
 246         sensor::sensor_listener *listener;
 247
 248         listener = new(std::nothrow) sensor::sensor_listener(sensor);
 249         retvm_if(!listener, -ENOMEM, "Failed to allocate memory");
 250
 251         listeners[listener->get_id()] = listener;
 252
 253         return listener->get_id();
 254 }
 255
 256 API bool sensord_disconnect(int handle)
 257 {
 258         sensor::sensor_listener *listener;
 259
 260         auto it = listeners.find(handle);
 261         retvm_if(it == listeners.end(), false, "Invalid handle[%d]", handle);
 262
 263         listener = it->second;
 264         retvm_if(!listener, false, "Invalid handle[%d]", handle);
 265
 266         delete listener;
 267         listeners.erase(handle);
 268
 269         return true;
 270 }
 271
 272 API bool sensord_register_event(int handle, unsigned int event_type,
 273                 unsigned int interval, unsigned int max_batch_latency, sensor_cb_t cb, void *user_data)
 274 {
 275         sensor::sensor_listener *listener;
 276         int prev_interval;
 277         int prev_max_batch_latency;
 278         sensor_event_handler *handler;
 279
 280         auto it = listeners.find(handle);
 281         retvm_if(it == listeners.end(), false, "Invalid handle[%d]", handle);
 282
 283         listener = it->second;
 284
 285         prev_interval = listener->get_interval();
 286         prev_max_batch_latency = listener->get_max_batch_latency();
 287
 288         if (listener->set_interval(interval) < 0) {
 289                 _E("Failed to set interval");
 290                 return false;
 291         }
 292
 293         if (listener->set_max_batch_latency(max_batch_latency) < 0) {
 294                 listener->set_interval(prev_interval);
 295                 _E("Failed to set max_batch_latency");
 296                 return false;
 297         }
 298
 299         handler = new(std::nothrow) sensor_event_handler(listener->get_sensor(), cb, user_data);
 300         if (!handler) {
 301                 listener->set_max_batch_latency(prev_max_batch_latency);
 302                 listener->set_interval(prev_interval);
 303                 _E("Failed to allocate memory");
 304                 return false;
 305         }
 306
 307         listener->set_event_handler(handler);
 308
 309         return true;
 310 }
 311
 312 API bool sensord_unregister_event(int handle, unsigned int event_type)
 313 {
 314         sensor::sensor_listener *listener;
 315
 316         auto it = listeners.find(handle);
 317         retvm_if(it == listeners.end(), false, "Invalid handle[%d]", handle);
 318
 319         listener = it->second;
 320
 321         listener->unset_event_handler();
 322
 323         return true;
 324 }
 325
 326 API bool sensord_register_accuracy_cb(int handle, sensor_accuracy_changed_cb_t cb, void *user_data)
 327 {
 328         sensor::sensor_listener *listener;
 329         sensor_accuracy_handler *handler;
 330
 331         auto it = listeners.find(handle);
 332         retvm_if(it == listeners.end(), false, "Invalid handle[%d]", handle);
 333
 334         listener = it->second;
 335
 336         handler = new(std::nothrow) sensor_accuracy_handler(listener->get_sensor(), cb, user_data);
 337         retvm_if(!handler, false, "Failed to allocate memory");
 338
 339         listener->set_accuracy_handler(handler);
 340
 341         return true;
 342 }
 343
 344 API bool sensord_unregister_accuracy_cb(int handle)
 345 {
 346         sensor::sensor_listener *listener;
 347
 348         auto it = listeners.find(handle);
 349         retvm_if(it == listeners.end(), false, "Invalid handle[%d]", handle);
 350
 351         listener = it->second;
 352
 353         listener->unset_accuracy_handler();
 354
 355         return true;
 356 }
 357
 358 API bool sensord_start(int handle, int option)
 359 {
 360         sensor::sensor_listener *listener;
 361         int prev_pause;
 362         int pause;
 363
 364         auto it = listeners.find(handle);
 365         retvm_if(it == listeners.end(), false, "Invalid handle[%d]", handle);
 366
 367         listener = it->second;
 368
 369         pause = CONVERT_OPTION_PAUSE_POLICY(option);
 370         prev_pause = listener->get_pause_policy();
 371
 372         if (listener->set_attribute(SENSORD_ATTRIBUTE_PAUSE_POLICY, pause) < 0) {
 373                 _E("Failed to set pause policy[%d]", pause);
 374                 return false;
 375         }
 376
 377         if (listener->start() < 0) {
 378                 listener->set_attribute(SENSORD_ATTRIBUTE_PAUSE_POLICY, prev_pause);
 379                 _E("Failed to start listener");
 380                 return false;
 381         }
 382
 383         return true;
 384 }
 385
 386 API bool sensord_stop(int handle)
 387 {
 388         int ret;
 389         sensor::sensor_listener *listener;
 390
 391         auto it = listeners.find(handle);
 392         retvm_if(it == listeners.end(), false, "Invalid handle[%d]", handle);
 393
 394         listener = it->second;
 395
 396         ret = listener->stop();
 397
 398         if (ret == -EAGAIN || ret == OP_SUCCESS)
 399                 return true;
 400
 401         return false;
 402 }
 403
 404 API bool sensord_change_event_interval(int handle, unsigned int event_type, unsigned int interval)
 405 {
 406         sensor::sensor_listener *listener;
 407
 408         auto it = listeners.find(handle);
 409         retvm_if(it == listeners.end(), false, "Invalid handle[%d]", handle);
 410
 411         listener = it->second;
 412
 413         if (listener->set_interval(interval) < 0) {
 414                 _E("Failed to set interval to listener");
 415                 return false;
 416         }
 417
 418         return true;
 419 }
 420
 421 API bool sensord_change_event_max_batch_latency(int handle, unsigned int event_type, unsigned int max_batch_latency)
 422 {
 423         sensor::sensor_listener *listener;
 424
 425         auto it = listeners.find(handle);
 426         retvm_if(it == listeners.end(), false, "Invalid handle[%d]", handle);
 427
 428         listener = it->second;
 429
 430         if (listener->set_max_batch_latency(max_batch_latency) < 0) {
 431                 _E("Failed to set max_batch_latency to listener");
 432                 return false;
 433         }
 434
 435         return true;
 436 }
 437
 438 API bool sensord_set_option(int handle, int option)
 439 {
 440         sensor::sensor_listener *listener;
 441         int pause;
 442
 443         auto it = listeners.find(handle);
 444         retvm_if(it == listeners.end(), false, "Invalid handle[%d]", handle);
 445
 446         listener = it->second;
 447
 448         pause = CONVERT_OPTION_PAUSE_POLICY(option);
 449
 450         if (listener->set_attribute(SENSORD_ATTRIBUTE_PAUSE_POLICY, pause) < 0) {
 451                 _E("Failed to set option[%d(%d)] to listener", option, pause);
 452                 return false;
 453         }
 454
 455         return true;
 456 }
 457
 458 API int sensord_set_attribute_int(int handle, int attribute, int value)
 459 {
 460         sensor::sensor_listener *listener;
 461
 462         auto it = listeners.find(handle);
 463         retvm_if(it == listeners.end(), -EINVAL, "Invalid handle[%d]", handle);
 464
 465         listener = it->second;
 466
 467         if (listener->set_attribute(attribute, value) < 0) {
 468                 _E("Failed to set attribute[%d, %d]", attribute, value);
 469                 return -EIO;
 470         }
 471
 472         return OP_SUCCESS;
 473 }
 474
 475 API int sensord_set_attribute_str(int handle, int attribute, const char *value, int len)
 476 {
 477         sensor::sensor_listener *listener;
 478
 479         auto it = listeners.find(handle);
 480         retvm_if(it == listeners.end(), -EINVAL, "Invalid handle[%d]", handle);
 481
 482         listener = it->second;
 483
 484         if (listener->set_attribute(attribute, value, len) < 0) {
 485                 _E("Failed to set attribute[%d, %s]", attribute, value);
 486                 return -EIO;
 487         }
 488
 489         return OP_SUCCESS;
 490 }
 491
 492 API bool sensord_get_data(int handle, unsigned int data_id, sensor_data_t* sensor_data)
 493 {
 494         sensor::sensor_listener *listener;
 495
 496         auto it = listeners.find(handle);
 497         retvm_if(it == listeners.end(), false, "Invalid handle[%d]", handle);
 498
 499         listener = it->second;
 500
 501         if (listener->get_sensor_data(sensor_data) < 0) {
 502                 _E("Failed to get sensor data from listener");
 503                 return false;
 504         }
 505
 506         return true;
 507 }
 508
 509 API bool sensord_flush(int handle)
 510 {
 511         sensor::sensor_listener *listener;
 512
 513         auto it = listeners.find(handle);
 514         retvm_if(it == listeners.end(), false, "Invalid handle[%d]", handle);
 515
 516         listener = it->second;
 517
 518         if (listener->flush() < 0) {
 519                 _E("Failed to flush sensor");
 520                 return false;
 521         }
 522
 523         return true;
 524 }
 525
 526 API bool sensord_set_passive_mode(int handle, bool passive)
 527 {
 528         sensor::sensor_listener *listener;
 529
 530         auto it = listeners.find(handle);
 531         retvm_if(it == listeners.end(), false, "Invalid handle[%d]", handle);
 532
 533         listener = it->second;
 534
 535         if (listener->set_passive_mode(passive) < 0) {
 536                 _E("Failed to set passive mode");
 537                 return false;
 538         }
 539
 540         return true;
 541 }
 542
 543 API int sensord_external_connect(const char *key, sensor_external_command_cb_t cb, void *user_data)
 544 {
 545         /*
 546          * 1. check parameter
 547          * 2. create handle in this client
 548          * 3. first connection(client)
 549          * 4. cmd_connect for external sensor with key
 550          */
 551         retvm_if(!key, -EINVAL, "Invalid key");
 552         return 0;
 553 }
 554
 555 API bool sensord_external_disconnect(int handle)
 556 {
 557         /*
 558          * 1. check parameter
 559          * 2. create handle in this client
 560          * 3. first connection(client)
 561          * 4. cmd_connect for external sensor with key
 562          * 5. disconnect this handle
 563          * 6. if there is no active sensor, remove client id and stop listener
 564          */
 565         return true;
 566 }
 567
 568 API bool sensord_external_post(int handle, unsigned long long timestamp, const float* data, int data_cnt)
 569 {
 570         /*
 571          * 1. check parameter
 572          * 1.1 (data_cnt <= 0) || (data_cnt > POST_DATA_LEN_MAX)), return false
 573          * 2. cmd_post
 574          */
 575
 576         return true;
 577 }
 578
 579 /* deperecated */
 580 API sensor_t sensord_get_sensor(sensor_type_t type)
 581 {
 582         sensor_t sensor;
 583
 584         if (sensord_get_default_sensor(type, &sensor) < 0)
 585                 return NULL;
 586
 587         return sensor;
 588 }
 589
 590 /* deprecated */
 591 API bool sensord_get_sensor_list(sensor_type_t type, sensor_t **list, int *sensor_count)
 592 {
 593         return (sensord_get_sensors(type, list, sensor_count) == OP_SUCCESS);
 594 }
 595
 596 /* deprecated */
 597 API bool sensord_register_hub_event(int handle, unsigned int event_type,
 598                 unsigned int interval, unsigned int max_batch_latency, sensorhub_cb_t cb, void *user_data)
 599 {
 600         return false;
 601 }
 602
 603 /* deprecated */
 604 API bool sensord_get_supported_event_types(sensor_t sensor, unsigned int **event_types, int *count)
 605 {
 606         /*
 607          * 1. check parameter
 608          * 2. if there is no sensor, return false
 609          * 3. memory allocation
 610          */
 611         return true;
 612 }
 613
 614 /* deprecated(BUT it is used in C-API....) */
 615 API bool sensord_is_supported_event_type(sensor_t sensor, unsigned int event_type, bool *supported)
 616 {
 617         if (!manager.is_supported(sensor))
 618                 *supported = false;
 619         else
 620                 *supported = true;
 621
 622         return true;
 623 }
 624
 625 /* deprecated */
 626 API bool sensord_send_sensorhub_data(int handle, const char *data, int data_len)
 627 {
 628         return (sensord_set_attribute_str(handle, 0, data, data_len) == OP_SUCCESS);
 629 }
 630
 631 /* deprecated */
 632 API bool sensord_send_command(int handle, const char *command, int command_len)
 633 {
 634         return (sensord_set_attribute_str(handle, 0, command, command_len) == OP_SUCCESS);
 635 }
 636
 637 /* deprecated */
 638 API bool sensord_get_privilege(sensor_t sensor, sensor_privilege_t *privilege)
 639 {
 640         *privilege = SENSOR_PRIVILEGE_PUBLIC;
 641
 642         return true;
 643 }
 644