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 #include <sensor_types_private.h>
  24 #include <sensor_utils.h>
  25
  26 #include <channel_handler.h>
  27 #include <sensor_manager.h>
  28 #include <sensor_listener.h>
  29 #include <sensor_provider.h>
  30 #include <sensor_log.h>
  31 #include <unordered_map>
  32 #include <regex>
  33
  34 #define CONVERT_OPTION_PAUSE_POLICY(option) ((option) ^ 0b11)
  35 #define MAX_LISTENER 100
  36
  37 using namespace sensor;
  38
  39 class sensor_event_handler : public ipc::channel_handler
  40 {
  41 public:
  42         sensor_event_handler(sensor_t sensor, sensor_cb_t cb, void *user_data)
  43         : m_sensor(reinterpret_cast<sensor_info *>(sensor))
  44         , m_cb(cb)
  45         , m_user_data(user_data)
  46         {}
  47
  48         void connected(ipc::channel *ch) {}
  49         void disconnected(ipc::channel *ch) {}
  50         void read(ipc::channel *ch, ipc::message &msg)
  51         {
  52                 int event_type;
  53                 sensor_data_t *data;
  54
  55                 data = reinterpret_cast<sensor_data_t *>(msg.body());
  56                 event_type = CONVERT_TYPE_EVENT(m_sensor->get_type());
  57
  58                 m_cb(m_sensor, event_type, data, m_user_data);
  59         }
  60
  61         void read_complete(ipc::channel *ch) {}
  62         void error_caught(ipc::channel *ch, int error) {}
  63
  64 private:
  65         sensor_info *m_sensor;
  66         sensor_cb_t m_cb;
  67         void *m_user_data;
  68 };
  69
  70 class sensor_accuracy_handler : public ipc::channel_handler
  71 {
  72 public:
  73         sensor_accuracy_handler(sensor_t sensor, sensor_accuracy_changed_cb_t cb, void *user_data)
  74         : m_sensor(reinterpret_cast<sensor_info *>(sensor))
  75         , m_cb(cb)
  76         , m_user_data(user_data)
  77         {}
  78
  79         void connected(ipc::channel *ch) {}
  80         void disconnected(ipc::channel *ch) {}
  81         void read(ipc::channel *ch, ipc::message &msg)
  82         {
  83                 sensor_data_t *data;
  84                 data = reinterpret_cast<sensor_data_t *>(msg.body());
  85
  86                 m_cb(m_sensor, data->timestamp, data->accuracy, m_user_data);
  87         }
  88
  89         void read_complete(ipc::channel *ch) {}
  90         void error_caught(ipc::channel *ch, int error) {}
  91
  92 private:
  93         sensor_info *m_sensor;
  94         sensor_accuracy_changed_cb_t m_cb;
  95         void *m_user_data;
  96 };
  97
  98 static sensor::sensor_manager manager;
  99 static std::unordered_map<int, sensor::sensor_listener *> listeners;
 100
 101 /*
 102  * TO-DO-LIST:
 103  * 1. power save option / lcd vconf : move to server
 104  * 2. thread-safe : ipc_client
 105  */
 106
 107 API int sensord_get_sensors(sensor_type_t type, sensor_t **list, int *count)
 108 {
 109         return sensord_get_sensors_by_uri(utils::get_uri(type), list, count);
 110 }
 111
 112 API int sensord_get_default_sensor(sensor_type_t type, sensor_t *sensor)
 113 {
 114         return sensord_get_default_sensor_by_uri(utils::get_uri(type), sensor);
 115 }
 116
 117 API bool sensord_get_type(sensor_t sensor, sensor_type_t *type)
 118 {
 119         retvm_if(!type, false, "Invalid type");
 120         retvm_if(!manager.connect(), false, "Failed to connect");
 121         retvm_if(!manager.is_supported(sensor), false,
 122                         "Invalid sensor[%p]", sensor);
 123
 124         *type = static_cast<sensor_info *>(sensor)->get_type();
 125
 126         return true;
 127 }
 128
 129 API const char* sensord_get_uri(sensor_t sensor)
 130 {
 131         retvm_if(!manager.connect(), NULL, "Failed to connect");
 132         retvm_if(!manager.is_supported(sensor), NULL,
 133                         "Invalid sensor[%p]", sensor);
 134
 135         return static_cast<sensor_info *>(sensor)->get_uri().c_str();
 136 }
 137
 138 API const char* sensord_get_name(sensor_t sensor)
 139 {
 140         retvm_if(!manager.connect(), NULL, "Failed to connect");
 141         retvm_if(!manager.is_supported(sensor), NULL,
 142                         "Invalid sensor[%p]", sensor);
 143
 144         return static_cast<sensor_info *>(sensor)->get_model().c_str();
 145 }
 146
 147 API const char* sensord_get_vendor(sensor_t sensor)
 148 {
 149         retvm_if(!manager.connect(), NULL, "Failed to connect");
 150         retvm_if(!manager.is_supported(sensor), NULL,
 151                         "Invalid sensor[%p]", sensor);
 152
 153         return static_cast<sensor_info *>(sensor)->get_vendor().c_str();
 154 }
 155
 156 API bool sensord_get_min_range(sensor_t sensor, float *min_range)
 157 {
 158         retvm_if(!min_range, false, "Invalid paramter");
 159         retvm_if(!manager.connect(), false, "Failed to connect");
 160         retvm_if(!manager.is_supported(sensor), false,
 161                         "Invalid sensor[%p]", sensor);
 162
 163         *min_range = static_cast<sensor_info *>(sensor)->get_min_range();
 164
 165         return true;
 166 }
 167
 168 API bool sensord_get_max_range(sensor_t sensor, float *max_range)
 169 {
 170         retvm_if(!max_range, false, "Invalid parameter");
 171         retvm_if(!manager.connect(), false, "Failed to connect");
 172         retvm_if(!manager.is_supported(sensor), false,
 173                         "Invalid sensor[%p]", sensor);
 174
 175         *max_range = static_cast<sensor_info *>(sensor)->get_max_range();
 176
 177         return true;
 178 }
 179
 180 API bool sensord_get_resolution(sensor_t sensor, float *resolution)
 181 {
 182         retvm_if(!resolution, false, "Invalid parameter");
 183         retvm_if(!manager.connect(), false, "Failed to connect");
 184         retvm_if(!manager.is_supported(sensor), false,
 185                         "Invalid sensor[%p]", sensor);
 186
 187         *resolution = static_cast<sensor_info *>(sensor)->get_resolution();
 188
 189         return true;
 190 }
 191
 192 API bool sensord_get_min_interval(sensor_t sensor, int *min_interval)
 193 {
 194         retvm_if(!min_interval, false, "Invalid parameter");
 195         retvm_if(!manager.connect(), false, "Failed to connect");
 196         retvm_if(!manager.is_supported(sensor), false,
 197                         "Invalid sensor[%p]", sensor);
 198
 199         *min_interval = static_cast<sensor_info *>(sensor)->get_min_interval();
 200
 201         return true;
 202 }
 203
 204 API bool sensord_get_fifo_count(sensor_t sensor, int *fifo_count)
 205 {
 206         retvm_if(!fifo_count, false, "Invalid parameter");
 207         retvm_if(!manager.connect(), false, "Failed to connect");
 208         retvm_if(!manager.is_supported(sensor), false,
 209                         "Invalid sensor[%p]", sensor);
 210
 211         *fifo_count = 0;
 212
 213         return true;
 214 }
 215
 216 API bool sensord_get_max_batch_count(sensor_t sensor, int *max_batch_count)
 217 {
 218         retvm_if(!max_batch_count, false, "Invalid parameter");
 219         retvm_if(!manager.connect(), false, "Failed to connect");
 220         retvm_if(!manager.is_supported(sensor), false,
 221                         "Invalid sensor[%p]", sensor);
 222
 223         *max_batch_count = static_cast<sensor_info *>(sensor)->get_max_batch_count();
 224
 225         return true;
 226 }
 227
 228 API bool sensord_is_wakeup_supported(sensor_t sensor)
 229 {
 230         retvm_if(!manager.connect(), false, "Failed to connect");
 231         retvm_if(!manager.is_supported(sensor), false,
 232                         "Invalid sensor[%p]", sensor);
 233
 234         return static_cast<sensor_info *>(sensor)->is_wakeup_supported();
 235 }
 236
 237 API int sensord_connect(sensor_t sensor)
 238 {
 239         retvm_if(!manager.connect(), -EIO, "Failed to connect");
 240         retvm_if(!manager.is_supported(sensor), -EINVAL,
 241                         "Invalid sensor[%p]", sensor);
 242         retvm_if(listeners.size() > MAX_LISTENER, -EPERM, "Exceeded the maximum listener");
 243
 244         sensor::sensor_listener *listener;
 245
 246         listener = new(std::nothrow) sensor::sensor_listener(sensor);
 247         retvm_if(!listener, -ENOMEM, "Failed to allocate memory");
 248
 249         listeners[listener->get_id()] = listener;
 250
 251         return listener->get_id();
 252 }
 253
 254 API bool sensord_disconnect(int handle)
 255 {
 256         sensor::sensor_listener *listener;
 257
 258         auto it = listeners.find(handle);
 259         retvm_if(it == listeners.end(), false, "Invalid handle[%d]", handle);
 260
 261         listener = it->second;
 262         retvm_if(!listener, false, "Invalid handle[%d]", handle);
 263
 264         delete listener;
 265         listeners.erase(handle);
 266
 267         return true;
 268 }
 269
 270 API bool sensord_register_event(int handle, unsigned int event_type,
 271                 unsigned int interval, unsigned int max_batch_latency, sensor_cb_t cb, void *user_data)
 272 {
 273         sensor::sensor_listener *listener;
 274         int prev_interval;
 275         int prev_max_batch_latency;
 276         sensor_event_handler *handler;
 277
 278         auto it = listeners.find(handle);
 279         retvm_if(it == listeners.end(), false, "Invalid handle[%d]", handle);
 280
 281         listener = it->second;
 282
 283         prev_interval = listener->get_interval();
 284         prev_max_batch_latency = listener->get_max_batch_latency();
 285
 286         if (listener->set_interval(interval) < 0) {
 287                 _E("Failed to set interval");
 288                 return false;
 289         }
 290
 291         if (listener->set_max_batch_latency(max_batch_latency) < 0) {
 292                 listener->set_interval(prev_interval);
 293                 _E("Failed to set max_batch_latency");
 294                 return false;
 295         }
 296
 297         handler = new(std::nothrow) sensor_event_handler(listener->get_sensor(), cb, user_data);
 298         if (!handler) {
 299                 listener->set_max_batch_latency(prev_max_batch_latency);
 300                 listener->set_interval(prev_interval);
 301                 _E("Failed to allocate memory");
 302                 return false;
 303         }
 304
 305         listener->set_event_handler(handler);
 306
 307         return true;
 308 }
 309
 310 API bool sensord_unregister_event(int handle, unsigned int event_type)
 311 {
 312         sensor::sensor_listener *listener;
 313
 314         auto it = listeners.find(handle);
 315         retvm_if(it == listeners.end(), false, "Invalid handle[%d]", handle);
 316
 317         listener = it->second;
 318
 319         listener->unset_event_handler();
 320
 321         return true;
 322 }
 323
 324 API bool sensord_register_accuracy_cb(int handle, sensor_accuracy_changed_cb_t cb, void *user_data)
 325 {
 326         sensor::sensor_listener *listener;
 327         sensor_accuracy_handler *handler;
 328
 329         auto it = listeners.find(handle);
 330         retvm_if(it == listeners.end(), false, "Invalid handle[%d]", handle);
 331
 332         listener = it->second;
 333
 334         handler = new(std::nothrow) sensor_accuracy_handler(listener->get_sensor(), cb, user_data);
 335         retvm_if(!handler, false, "Failed to allocate memory");
 336
 337         listener->set_accuracy_handler(handler);
 338
 339         return true;
 340 }
 341
 342 API bool sensord_unregister_accuracy_cb(int handle)
 343 {
 344         sensor::sensor_listener *listener;
 345
 346         auto it = listeners.find(handle);
 347         retvm_if(it == listeners.end(), false, "Invalid handle[%d]", handle);
 348
 349         listener = it->second;
 350
 351         listener->unset_accuracy_handler();
 352
 353         return true;
 354 }
 355
 356 API bool sensord_start(int handle, int option)
 357 {
 358         sensor::sensor_listener *listener;
 359         int prev_pause;
 360         int pause;
 361
 362         auto it = listeners.find(handle);
 363         retvm_if(it == listeners.end(), false, "Invalid handle[%d]", handle);
 364
 365         listener = it->second;
 366
 367         pause = CONVERT_OPTION_PAUSE_POLICY(option);
 368         prev_pause = listener->get_pause_policy();
 369
 370         if (listener->set_attribute(SENSORD_ATTRIBUTE_PAUSE_POLICY, pause) < 0) {
 371                 _E("Failed to set pause policy[%d]", pause);
 372                 return false;
 373         }
 374
 375         if (listener->start() < 0) {
 376                 listener->set_attribute(SENSORD_ATTRIBUTE_PAUSE_POLICY, prev_pause);
 377                 _E("Failed to start listener");
 378                 return false;
 379         }
 380
 381         return true;
 382 }
 383
 384 API bool sensord_stop(int handle)
 385 {
 386         int ret;
 387         sensor::sensor_listener *listener;
 388
 389         auto it = listeners.find(handle);
 390         retvm_if(it == listeners.end(), false, "Invalid handle[%d]", handle);
 391
 392         listener = it->second;
 393
 394         ret = listener->stop();
 395
 396         if (ret == -EAGAIN || ret == OP_SUCCESS)
 397                 return true;
 398
 399         return false;
 400 }
 401
 402 API bool sensord_change_event_interval(int handle, unsigned int event_type, unsigned int interval)
 403 {
 404         sensor::sensor_listener *listener;
 405
 406         auto it = listeners.find(handle);
 407         retvm_if(it == listeners.end(), false, "Invalid handle[%d]", handle);
 408
 409         listener = it->second;
 410
 411         if (listener->set_interval(interval) < 0) {
 412                 _E("Failed to set interval to listener");
 413                 return false;
 414         }
 415
 416         return true;
 417 }
 418
 419 API bool sensord_change_event_max_batch_latency(int handle, unsigned int event_type, unsigned int max_batch_latency)
 420 {
 421         sensor::sensor_listener *listener;
 422
 423         auto it = listeners.find(handle);
 424         retvm_if(it == listeners.end(), false, "Invalid handle[%d]", handle);
 425
 426         listener = it->second;
 427
 428         if (listener->set_max_batch_latency(max_batch_latency) < 0) {
 429                 _E("Failed to set max_batch_latency to listener");
 430                 return false;
 431         }
 432
 433         return true;
 434 }
 435
 436 API bool sensord_set_option(int handle, int option)
 437 {
 438         sensor::sensor_listener *listener;
 439         int pause;
 440
 441         auto it = listeners.find(handle);
 442         retvm_if(it == listeners.end(), false, "Invalid handle[%d]", handle);
 443
 444         listener = it->second;
 445
 446         pause = CONVERT_OPTION_PAUSE_POLICY(option);
 447
 448         if (listener->set_attribute(SENSORD_ATTRIBUTE_PAUSE_POLICY, pause) < 0) {
 449                 _E("Failed to set option[%d(%d)] to listener", option, pause);
 450                 return false;
 451         }
 452
 453         return true;
 454 }
 455
 456 API int sensord_set_attribute_int(int handle, int attribute, int value)
 457 {
 458         sensor::sensor_listener *listener;
 459
 460         auto it = listeners.find(handle);
 461         retvm_if(it == listeners.end(), -EINVAL, "Invalid handle[%d]", handle);
 462
 463         listener = it->second;
 464
 465         if (listener->set_attribute(attribute, value) < 0) {
 466                 _E("Failed to set attribute[%d, %d]", attribute, value);
 467                 return -EIO;
 468         }
 469
 470         return OP_SUCCESS;
 471 }
 472
 473 API int sensord_set_attribute_str(int handle, int attribute, const char *value, int len)
 474 {
 475         sensor::sensor_listener *listener;
 476
 477         auto it = listeners.find(handle);
 478         retvm_if(it == listeners.end(), -EINVAL, "Invalid handle[%d]", handle);
 479
 480         listener = it->second;
 481
 482         if (listener->set_attribute(attribute, value, len) < 0) {
 483                 _E("Failed to set attribute[%d, %s]", attribute, value);
 484                 return -EIO;
 485         }
 486
 487         return OP_SUCCESS;
 488 }
 489
 490 API bool sensord_get_data(int handle, unsigned int data_id, sensor_data_t* sensor_data)
 491 {
 492         sensor::sensor_listener *listener;
 493
 494         auto it = listeners.find(handle);
 495         retvm_if(it == listeners.end(), false, "Invalid handle[%d]", handle);
 496
 497         listener = it->second;
 498
 499         if (listener->get_sensor_data(sensor_data) < 0) {
 500                 _E("Failed to get sensor data from listener");
 501                 return false;
 502         }
 503
 504         return true;
 505 }
 506
 507 API bool sensord_flush(int handle)
 508 {
 509         sensor::sensor_listener *listener;
 510
 511         auto it = listeners.find(handle);
 512         retvm_if(it == listeners.end(), false, "Invalid handle[%d]", handle);
 513
 514         listener = it->second;
 515
 516         if (listener->flush() < 0) {
 517                 _E("Failed to flush sensor");
 518                 return false;
 519         }
 520
 521         return true;
 522 }
 523
 524 API bool sensord_set_passive_mode(int handle, bool passive)
 525 {
 526         sensor::sensor_listener *listener;
 527
 528         auto it = listeners.find(handle);
 529         retvm_if(it == listeners.end(), false, "Invalid handle[%d]", handle);
 530
 531         listener = it->second;
 532
 533         if (listener->set_passive_mode(passive) < 0) {
 534                 _E("Failed to set passive mode");
 535                 return false;
 536         }
 537
 538         return true;
 539 }
 540
 541 /* Sensor Internal API using URI */
 542 API int sensord_get_default_sensor_by_uri(const char *uri, sensor_t *sensor)
 543 {
 544         retvm_if(!sensor, -EINVAL, "Invalid parameter");
 545         retvm_if(!manager.connect(), -EIO, "Failed to connect");
 546
 547         return manager.get_sensor(uri, sensor);
 548 }
 549
 550 API int sensord_get_sensors_by_uri(const char *uri, sensor_t **list, int *count)
 551 {
 552         retvm_if((!list || !count), -EINVAL, "Invalid parameter");
 553         retvm_if(!manager.connect(), -EIO, "Failed to connect");
 554
 555         return manager.get_sensors(uri, list, count);
 556 }
 557
 558 API int sensord_add_sensor_added_cb(sensord_added_cb callback, void *user_data)
 559 {
 560         retvm_if(!callback, -EINVAL, "Invalid paramter");
 561         retvm_if(!manager.connect(), -EIO, "Failed to connect");
 562
 563         manager.add_sensor_added_cb(callback, user_data);
 564         return OP_SUCCESS;
 565 }
 566
 567 API int sensord_remove_sensor_added_cb(sensord_added_cb callback)
 568 {
 569         retvm_if(!callback, -EINVAL, "Invalid paramter");
 570         retvm_if(!manager.connect(), -EIO, "Failed to connect");
 571
 572         manager.remove_sensor_added_cb(callback);
 573         return OP_SUCCESS;
 574 }
 575
 576 API int sensord_add_sensor_removed_cb(sensord_removed_cb callback, void *user_data)
 577 {
 578         retvm_if(!callback, -EINVAL, "Invalid paramter");
 579         retvm_if(!manager.connect(), -EIO, "Failed to connect");
 580
 581         manager.add_sensor_removed_cb(callback, user_data);
 582         return OP_SUCCESS;
 583 }
 584
 585 API int sensord_remove_sensor_removed_cb(sensord_removed_cb callback)
 586 {
 587         retvm_if(!callback, -EINVAL, "Invalid paramter");
 588         retvm_if(!manager.connect(), -EIO, "Failed to connect");
 589
 590         manager.remove_sensor_removed_cb(callback);
 591         return OP_SUCCESS;
 592 }
 593
 594 /* Sensor provider */
 595 API int sensord_create_provider(const char *uri, sensord_provider_h *provider)
 596 {
 597         retvm_if(!provider, -EINVAL, "Invalid paramter");
 598
 599         std::string str_uri(uri);
 600         retvm_if(str_uri.find(PREDEFINED_TYPE_URI) != std::string::npos,
 601                         -EINVAL, "Invalid URI format[%s]", uri);
 602
 603         static std::regex uri_regex(SENSOR_URI_REGEX, std::regex::optimize);
 604         retvm_if(!std::regex_match(uri, uri_regex),
 605                         -EINVAL, "Invalid URI format[%s]", uri);
 606
 607         sensor_provider *p;
 608
 609         p = new(std::nothrow) sensor_provider(uri);
 610         retvm_if(!p, -ENOMEM, "Failed to allocate memory");
 611
 612         *provider = static_cast<sensord_provider_h>(p);
 613         return OP_SUCCESS;
 614 }
 615
 616 API int sensord_destroy_provider(sensord_provider_h provider)
 617 {
 618         retvm_if(!provider, -EINVAL, "Invalid paramter");
 619
 620         delete static_cast<sensor::sensor_provider *>(provider);
 621         return OP_SUCCESS;
 622 }
 623
 624 API int sensord_add_provider(sensord_provider_h provider)
 625 {
 626         retvm_if(!provider, -EINVAL, "Invalid paramter");
 627         retvm_if(!manager.connect(), -EIO, "Failed to connect");
 628
 629         int ret;
 630         sensor_provider *p = static_cast<sensor_provider *>(provider);
 631
 632         ret = p->connect();
 633         retv_if(ret < 0, ret);
 634
 635         ret = manager.add_sensor(p);
 636         if (ret < 0) {
 637                 p->disconnect();
 638                 return ret;
 639         }
 640
 641         return OP_SUCCESS;
 642 }
 643
 644 API int sensord_remove_provider(sensord_provider_h provider)
 645 {
 646         retvm_if(!provider, -EINVAL, "Invalid paramter");
 647         retvm_if(!manager.connect(), -EIO, "Failed to connect");
 648
 649         int ret;
 650         sensor_provider *p = static_cast<sensor_provider *>(provider);
 651
 652         if (!p->disconnect())
 653                 return OP_ERROR;
 654
 655         ret = manager.remove_sensor(p);
 656         if (ret < 0) {
 657                 p->connect();
 658                 return OP_ERROR;
 659         }
 660
 661         return OP_SUCCESS;
 662 }
 663
 664 API int sensord_provider_set_name(sensord_provider_h provider, const char *name)
 665 {
 666         retvm_if(!provider, -EINVAL, "Invalid paramter");
 667
 668         sensor_provider *p = static_cast<sensor_provider *>(provider);
 669
 670         sensor_info *info = p->get_sensor_info();
 671         info->set_model(name);
 672
 673         return OP_SUCCESS;
 674 }
 675
 676 API int sensord_provider_set_vendor(sensord_provider_h provider, const char *vendor)
 677 {
 678         retvm_if(!provider, -EINVAL, "Invalid paramter");
 679
 680         sensor_provider *p = static_cast<sensor_provider *>(provider);
 681
 682         sensor_info *info = p->get_sensor_info();
 683         info->set_vendor(vendor);
 684
 685         return OP_SUCCESS;
 686 }
 687
 688 API int sensord_provider_set_range(sensord_provider_h provider, float min_range, float max_range)
 689 {
 690         retvm_if(!provider, -EINVAL, "Invalid paramter");
 691
 692         sensor_provider *p = static_cast<sensor_provider *>(provider);
 693
 694         sensor_info *info = p->get_sensor_info();
 695         info->set_min_range(min_range);
 696         info->set_max_range(max_range);
 697
 698         return OP_SUCCESS;
 699 }
 700
 701 API int sensord_provider_set_resolution(sensord_provider_h provider, float resolution)
 702 {
 703         retvm_if(!provider, -EINVAL, "Invalid paramter");
 704
 705         sensor_provider *p = static_cast<sensor_provider *>(provider);
 706
 707         sensor_info *info = p->get_sensor_info();
 708         info->set_resolution(resolution);
 709
 710         return OP_SUCCESS;
 711 }
 712
 713 API int sensord_provider_set_start_cb(sensord_provider_h provider, sensord_provider_start_cb callback, void *user_data)
 714 {
 715         retvm_if(!provider, -EINVAL, "Invalid paramter");
 716         retvm_if(!callback, -EINVAL, "Invalid paramter");
 717
 718         sensor_provider *p = static_cast<sensor_provider *>(provider);
 719
 720         p->set_start_cb(callback, user_data);
 721
 722         return OP_SUCCESS;
 723 }
 724
 725 API int sensord_provider_set_stop_cb(sensord_provider_h provider, sensord_provider_stop_cb callback, void *user_data)
 726 {
 727         retvm_if(!provider, -EINVAL, "Invalid paramter");
 728         retvm_if(!callback, -EINVAL, "Invalid paramter");
 729
 730         sensor_provider *p = static_cast<sensor_provider *>(provider);
 731
 732         p->set_stop_cb(callback, user_data);
 733
 734         return OP_SUCCESS;
 735 }
 736
 737 API int sensord_provider_set_interval_changed_cb(sensord_provider_h provider, sensord_provider_interval_changed_cb callback, void *user_data)
 738 {
 739         retvm_if(!provider, -EINVAL, "Invalid paramter");
 740         retvm_if(!callback, -EINVAL, "Invalid paramter");
 741
 742         sensor_provider *p = static_cast<sensor_provider *>(provider);
 743
 744         p->set_interval_cb(callback, user_data);
 745
 746         return OP_SUCCESS;
 747 }
 748
 749 API int sensord_provider_publish(sensord_provider_h provider, sensor_data_t data)
 750 {
 751         retvm_if(!provider, -EINVAL, "Invalid paramter");
 752
 753         sensor_provider *p = static_cast<sensor_provider *>(provider);
 754
 755         /* TODO: synchronous call is enough? */
 756         return p->publish(&data, sizeof(data));
 757 }
 758
 759 /* deperecated */
 760 API sensor_t sensord_get_sensor(sensor_type_t type)
 761 {
 762         sensor_t sensor;
 763
 764         if (sensord_get_default_sensor(type, &sensor) < 0)
 765                 return NULL;
 766
 767         return sensor;
 768 }
 769
 770 /* deprecated */
 771 API bool sensord_get_sensor_list(sensor_type_t type, sensor_t **list, int *sensor_count)
 772 {
 773         return (sensord_get_sensors(type, list, sensor_count) == OP_SUCCESS);
 774 }
 775
 776 /* deprecated */
 777 API bool sensord_register_hub_event(int handle, unsigned int event_type,
 778                 unsigned int interval, unsigned int max_batch_latency, sensorhub_cb_t cb, void *user_data)
 779 {
 780         return false;
 781 }
 782
 783 /* deprecated */
 784 API bool sensord_get_supported_event_types(sensor_t sensor, unsigned int **event_types, int *count)
 785 {
 786         /*
 787          * 1. check parameter
 788          * 2. if there is no sensor, return false
 789          * 3. memory allocation
 790          */
 791         return true;
 792 }
 793
 794 /* deprecated(BUT it is used in C-API....) */
 795 API bool sensord_is_supported_event_type(sensor_t sensor, unsigned int event_type, bool *supported)
 796 {
 797         if (!manager.is_supported(sensor))
 798                 *supported = false;
 799         else
 800                 *supported = true;
 801
 802         return true;
 803 }
 804
 805 /* deprecated */
 806 API bool sensord_send_sensorhub_data(int handle, const char *data, int data_len)
 807 {
 808         return (sensord_set_attribute_str(handle, 0, data, data_len) == OP_SUCCESS);
 809 }
 810
 811 /* deprecated */
 812 API bool sensord_send_command(int handle, const char *command, int command_len)
 813 {
 814         return (sensord_set_attribute_str(handle, 0, command, command_len) == OP_SUCCESS);
 815 }
 816
 817 /* deprecated */
 818 API bool sensord_get_privilege(sensor_t sensor, sensor_privilege_t *privilege)
 819 {
 820         *privilege = SENSOR_PRIVILEGE_PUBLIC;
 821
 822         return true;
 823 }
 824
 825 /* deprecated */
 826 API int sensord_external_connect(const char *key, sensor_external_command_cb_t cb, void *user_data)
 827 {
 828         /*
 829          * 1. check parameter
 830          * 2. create handle in this client
 831          * 3. first connection(client)
 832          * 4. cmd_connect for external sensor with key
 833          */
 834         retvm_if(!key, -EINVAL, "Invalid key");
 835         return 0;
 836 }
 837
 838 /* deprecated */
 839 API bool sensord_external_disconnect(int handle)
 840 {
 841         /*
 842          * 1. check parameter
 843          * 2. create handle in this client
 844          * 3. first connection(client)
 845          * 4. cmd_connect for external sensor with key
 846          * 5. disconnect this handle
 847          * 6. if there is no active sensor, remove client id and stop listener
 848          */
 849         return true;
 850 }
 851
 852 /* deprecated */
 853 API bool sensord_external_post(int handle, unsigned long long timestamp, const float* data, int data_cnt)
 854 {
 855         /*
 856          * 1. check parameter
 857          * 1.1 (data_cnt <= 0) || (data_cnt > POST_DATA_LEN_MAX)), return false
 858          * 2. cmd_post
 859          */
 860
 861         return true;
 862 }
 863