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