src/api/sensor.cpp

   1 /*
   2  * Copyright (c) 2014 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <math.h>
  18 #include <stdlib.h>
  19 #include <string.h>
  20 #include <sys/time.h>
  21 #include <limits.h>
  22 #include <libgen.h>
  23 #include <memory>
  24
  25 #include <sensor.h>
  26 #include <sensor-internal.h>
  27 #include <sensor-private.h>
  28 #include <sensor-log-private.h>
  29
  30 #define SENSOR_SHIFT_TYPE                   16
  31 #define SENSOR_UNDEFINED_ID                 -1
  32 #define SENSOR_LISTENER_MAGIC               0xCAFECAFE
  33 #define RAD2DEGREE                          (180/M_PI)
  34
  35 #define CONVERT_AXIS_ENUM(X)                ((X) < 3 ? (X) + 0x81 : (X) - 2)
  36 #define CONVERT_OPTION_PAUSE_POLICY(option) ((option) ^ 0b11)
  37
  38 #define WARN_DEPRECATED_SENSOR(X) \
  39         do { \
  40                 if ((X) == SENSOR_LAST || (X) == SENSOR_CUSTOM || (X) == SENSOR_HUMAN_STRESS_MONITOR) { \
  41                         _W("DEPRECATION WARNING: This sensor type is deprecated and will be removed from next release."); \
  42                 } \
  43         } while (0)
  44
  45 static int sensor_connect(sensor_h sensor, sensor_listener_h listener)
  46 {
  47         int id = SENSOR_UNDEFINED_ID;
  48         int event_type;
  49         sensor_type_t type;
  50         bool support = false;
  51
  52         if (!listener)
  53                 return SENSOR_ERROR_INVALID_PARAMETER;
  54
  55         _D("called sensor_connect : listener[%p], sensor[%p]", listener, sensor);
  56
  57         sensord_get_type(sensor, &type);
  58         event_type = type << SENSOR_SHIFT_TYPE | 0x1;
  59
  60         if (!sensord_is_supported_event_type(sensor, event_type, &support))
  61                 return SENSOR_ERROR_INVALID_PARAMETER;
  62
  63         if (!support)
  64                 return SENSOR_ERROR_NOT_SUPPORTED;
  65
  66         id = sensord_connect(sensor);
  67
  68         if (id < 0)
  69                 return SENSOR_ERROR_OPERATION_FAILED;
  70
  71         _D("success sensor_connect: id[%d]", id);
  72
  73         listener->id = id;
  74         listener->type = type;
  75
  76         return id;
  77 }
  78
  79 static void sensor_callback(sensor_t sensor, unsigned int event_type, sensor_data_t *data, void *user_data)
  80 {
  81         sensor_event_s *event;
  82         sensor_listener_h listener;
  83         listener = (sensor_listener_h)user_data;
  84
  85         if (!sensor || !listener->callback)
  86                 return;
  87
  88         event = (sensor_event_s *)data;
  89
  90         ((sensor_event_cb) listener->callback)(sensor, event, listener->user_data);
  91         return;
  92 }
  93
  94 static void sensor_events_callback(sensor_t sensor, unsigned int event_type, sensor_data_t datas[], int events_count, void *user_data)
  95 {
  96         sensor_event_s *events;
  97         sensor_listener_h listener;
  98         listener = (sensor_listener_h)user_data;
  99
 100         if (!sensor || !listener->callback)
 101                 return;
 102
 103         events = (sensor_event_s *)datas;
 104
 105         ((sensor_events_cb) listener->callback)(sensor, events, events_count, listener->user_data);
 106         return;
 107 }
 108
 109 static inline int sensor_listener_unset_event_cb_impl(sensor_listener_h listener, bool is_events_callback)
 110 {
 111         int id;
 112         int type;
 113         unsigned int event_id;
 114
 115         _D("called sensor_listener_unset_event_cb_impl : listener[%p]", listener);
 116
 117         if (!listener)
 118                 return SENSOR_ERROR_INVALID_PARAMETER;
 119
 120         if (listener->magic != SENSOR_LISTENER_MAGIC)
 121                 return SENSOR_ERROR_INVALID_PARAMETER;
 122
 123         id = listener->id;
 124         type = (int)listener->type;
 125         event_id = type << SENSOR_SHIFT_TYPE | 0x1;
 126
 127         int ret = false;
 128         if (is_events_callback) {
 129                 ret = sensord_unregister_events(id, event_id);
 130         } else {
 131                 ret = sensord_unregister_event(id, event_id);
 132         }
 133
 134         if (!ret)
 135                 return SENSOR_ERROR_OPERATION_FAILED;
 136
 137         listener->callback = NULL;
 138         listener->user_data = NULL;
 139
 140         _D("success sensor_unregister_event");
 141
 142         return SENSOR_ERROR_NONE;
 143 }
 144
 145 static inline int sensor_listener_set_event_cb_impl(sensor_listener_h listener,
 146                 unsigned int interval, void* callback, bool is_events_callback, void *user_data)
 147 {
 148         int id;
 149         unsigned int event_id;
 150         unsigned int batch_latency;
 151
 152         if (!listener || !callback)
 153                 return SENSOR_ERROR_INVALID_PARAMETER;
 154
 155         if (listener->magic != SENSOR_LISTENER_MAGIC)
 156                 return SENSOR_ERROR_INVALID_PARAMETER;
 157
 158         _D("called sensor_listener_set_event_cb_impl : listener[%p], interval[%u], callback[%p], user_data[%p], id[%d]",
 159                         listener, interval, callback, user_data, listener->id);
 160
 161         id = listener->id;
 162         event_id = (listener->type) << SENSOR_SHIFT_TYPE | 0x1;
 163         batch_latency = listener->batch_latency;
 164
 165         listener->callback = (void *)callback;
 166         listener->user_data = user_data;
 167
 168         int ret = false;
 169         if (is_events_callback) {
 170                 ret = sensord_register_events(id, event_id, batch_latency, sensor_events_callback, listener);
 171         } else {
 172                 ret = sensord_register_event(id, event_id, interval, batch_latency, sensor_callback, listener);
 173         }
 174
 175         if (!ret) {
 176                 listener->callback = NULL;
 177                 listener->user_data = NULL;
 178                 return SENSOR_ERROR_OPERATION_FAILED;
 179         }
 180
 181         _D("success sensor_listener_set_event");
 182
 183         return SENSOR_ERROR_NONE;
 184 }
 185
 186 int sensor_is_supported(sensor_type_e type, bool *supported)
 187 {
 188         int result;
 189         sensor_t sensor;
 190
 191         WARN_DEPRECATED_SENSOR(type);
 192
 193         if (type < SENSOR_ALL)
 194                 return SENSOR_ERROR_INVALID_PARAMETER;
 195
 196         if (!supported)
 197                 return SENSOR_ERROR_INVALID_PARAMETER;
 198
 199         _D("called sensor_is_supported : type[%d]", type);
 200
 201          result = sensord_get_default_sensor((sensor_type_t)type, &sensor);
 202
 203         if (result == -EPERM)
 204                 return SENSOR_ERROR_OPERATION_FAILED;
 205
 206         *supported = false;
 207
 208         /*
 209          * because is_supported() API is N/P API,
 210          * it must not returns PERMISSION_DENIED error.
 211          * -EACCES means that there is at least one sensor.
 212          */
 213         if (sensor || (result == -EACCES))
 214                 *supported = true;
 215
 216         _D("success sensor(%d) is supported[%d]", type, *supported);
 217
 218         return SENSOR_ERROR_NONE;
 219 }
 220
 221 int sensor_is_supported_by_uri(const char *uri, bool *supported)
 222 {
 223         int result;
 224         sensor_t sensor;
 225
 226         if (!supported)
 227                 return SENSOR_ERROR_INVALID_PARAMETER;
 228
 229         result = sensord_get_default_sensor_by_uri(uri, &sensor);
 230         if (result == -EINVAL)
 231                 return SENSOR_ERROR_INVALID_PARAMETER;
 232         else if (result == -EPERM || result == -EIO)
 233                 return SENSOR_ERROR_OPERATION_FAILED;
 234
 235         if (result == -ENODATA)
 236                 *supported = false;
 237         else
 238                 *supported = true;
 239
 240         return SENSOR_ERROR_NONE;
 241 }
 242
 243 int sensor_get_default_sensor(sensor_type_e type, sensor_h *sensor)
 244 {
 245         int result;
 246         sensor_t _sensor;
 247         sensor_privilege_t privilege;
 248
 249         WARN_DEPRECATED_SENSOR(type);
 250
 251         _D("called sensor_get_default_sensor : type[%d], sensor[%p]", type, sensor);
 252
 253         if (type < SENSOR_ALL)
 254                 return SENSOR_ERROR_INVALID_PARAMETER;
 255
 256         if (!sensor)
 257                 return SENSOR_ERROR_INVALID_PARAMETER;
 258
 259         result = sensord_get_default_sensor((sensor_type_t)type, &_sensor);
 260         if (result == -EACCES)
 261                 return SENSOR_ERROR_PERMISSION_DENIED;
 262         else if (result == -EPERM)
 263                 return SENSOR_ERROR_OPERATION_FAILED;
 264
 265         if (!_sensor)
 266                 return SENSOR_ERROR_NOT_SUPPORTED;
 267
 268         sensord_get_privilege(_sensor, &privilege);
 269         if (privilege != SENSOR_PRIVILEGE_PUBLIC)
 270                 return SENSOR_ERROR_PERMISSION_DENIED;
 271
 272         *sensor = _sensor;
 273
 274         _D("success sensor_get_default_sensor sensor[%p]", _sensor);
 275
 276         return SENSOR_ERROR_NONE;
 277 }
 278
 279 int sensor_get_default_sensor_by_uri(const char *uri, sensor_h *sensor)
 280 {
 281         int result;
 282
 283         result = sensord_get_default_sensor_by_uri(uri, sensor);
 284         if (result == -EINVAL)
 285                 return SENSOR_ERROR_INVALID_PARAMETER;
 286         else if (result == -EACCES)
 287                 return SENSOR_ERROR_PERMISSION_DENIED;
 288         else if (result == -ENODATA)
 289                 return SENSOR_ERROR_NOT_SUPPORTED;
 290         else if (result < 0)
 291                 return SENSOR_ERROR_OPERATION_FAILED;
 292
 293         return SENSOR_ERROR_NONE;
 294 }
 295
 296 int sensor_get_sensor_list(sensor_type_e type, sensor_h **list, int *sensor_count)
 297 {
 298         int result;
 299         sensor_h *_list;
 300         int count;
 301
 302         WARN_DEPRECATED_SENSOR(type);
 303
 304         _D("called sensor_get_list : type[%d]", type);
 305
 306         if (type < SENSOR_ALL)
 307                 return SENSOR_ERROR_INVALID_PARAMETER;
 308
 309         if (!sensor_count || !list)
 310                 return SENSOR_ERROR_INVALID_PARAMETER;
 311
 312         result = sensord_get_sensors((sensor_type_t)type, &_list, &count);
 313
 314         if (result == -EACCES)
 315                 return SENSOR_ERROR_PERMISSION_DENIED;
 316         else if (result == -EPERM)
 317                 return SENSOR_ERROR_OPERATION_FAILED;
 318         else if (result == -ENODATA)
 319                 return SENSOR_ERROR_NOT_SUPPORTED;
 320
 321         int i, j;
 322         int count_public = 0;
 323
 324         for (i = 0; i < count; ++i) {
 325                 sensor_privilege_t privilege;
 326
 327                 sensord_get_privilege(_list[i], &privilege);
 328                 if (privilege != SENSOR_PRIVILEGE_PUBLIC)
 329                         continue;
 330
 331                 count_public++;
 332         }
 333
 334         if (count_public == 0) {
 335                 free(_list);
 336                 return SENSOR_ERROR_PERMISSION_DENIED;
 337         }
 338
 339         *list = (sensor_h *) malloc((sizeof(int *)) * count_public);
 340
 341         if (!*list) {
 342                 free(_list);
 343                 return SENSOR_ERROR_OUT_OF_MEMORY;
 344         }
 345
 346         for (i = 0, j = 0; i < count; ++i) {
 347                 sensor_privilege_t privilege;
 348
 349                 sensord_get_privilege(_list[i], &privilege);
 350                 if (privilege != SENSOR_PRIVILEGE_PUBLIC)
 351                         continue;
 352
 353                 *(*list + j) = _list[i];
 354                 j++;
 355         }
 356
 357         free(_list);
 358
 359         *sensor_count = count_public;
 360
 361         _D("success sensor_get_list");
 362
 363         return SENSOR_ERROR_NONE;
 364 }
 365
 366 int sensor_get_sensor_list_by_uri(const char *uri, sensor_h **list, int *sensor_count)
 367 {
 368         int result;
 369         result = sensord_get_sensors_by_uri(uri, list, sensor_count);
 370         if (result == -EINVAL)
 371                 return SENSOR_ERROR_INVALID_PARAMETER;
 372         else if (result == -EACCES)
 373                 return SENSOR_ERROR_PERMISSION_DENIED;
 374         else if (result == -ENODATA)
 375                 return SENSOR_ERROR_NOT_SUPPORTED;
 376         else if (result < 0)
 377                 return SENSOR_ERROR_OPERATION_FAILED;
 378
 379         return SENSOR_ERROR_NONE;
 380 }
 381
 382 int sensor_is_wake_up(sensor_h sensor, bool *wakeup)
 383 {
 384         _D("called sensor_get_type");
 385
 386         if (!sensor || !wakeup)
 387                 return SENSOR_ERROR_INVALID_PARAMETER;
 388
 389         *wakeup = sensord_is_wakeup_supported(sensor);
 390
 391         _D("success sensor_is_wake_up : [%d]", *wakeup);
 392
 393         return SENSOR_ERROR_NONE;
 394 }
 395
 396 int sensor_create_listener(sensor_h sensor, sensor_listener_h *listener)
 397 {
 398         struct sensor_listener_s *_listener;
 399         int error;
 400
 401         _D("called sensor_create_listener : listener[%p]", listener);
 402
 403         if (!sensor || !listener)
 404                 return SENSOR_ERROR_INVALID_PARAMETER;
 405
 406         _listener = new(std::nothrow) struct sensor_listener_s;
 407
 408         if (!_listener)
 409                 return SENSOR_ERROR_OUT_OF_MEMORY;
 410
 411         error = sensor_connect(sensor, _listener);
 412
 413         if (error < 0) {
 414                 delete (struct sensor_listener_s *)_listener;
 415                 return SENSOR_ERROR_OPERATION_FAILED;
 416         }
 417
 418         _listener->sensor = sensor;
 419         _listener->pause = SENSOR_PAUSE_ALL;
 420         _listener->batch_latency = SENSOR_BATCH_LATENCY_DEFAULT;
 421         _listener->magic = SENSOR_LISTENER_MAGIC;
 422
 423         *listener = (sensor_listener_h) _listener;
 424
 425         _D("success sensor_create_listener");
 426
 427         return SENSOR_ERROR_NONE;
 428 }
 429
 430 int sensor_destroy_listener(sensor_listener_h listener)
 431 {
 432         _D("called sensor_destroy : listener[%p]", listener);
 433
 434         if (!listener)
 435                 return SENSOR_ERROR_INVALID_PARAMETER;
 436
 437         if (listener->magic != SENSOR_LISTENER_MAGIC)
 438                 return SENSOR_ERROR_INVALID_PARAMETER;
 439
 440         sensord_disconnect(listener->id);
 441         listener->magic = 0;
 442
 443         delete (sensor_listener_s *)listener;
 444
 445         _D("success sensor_destroy");
 446
 447         return SENSOR_ERROR_NONE;
 448 }
 449
 450 int sensor_listener_start(sensor_listener_h listener)
 451 {
 452         int id;
 453         unsigned int pause = SENSOR_PAUSE_ALL;
 454
 455         _D("called sensor_listener_start : listener[%p]", listener);
 456
 457         if (!listener)
 458                 return SENSOR_ERROR_INVALID_PARAMETER;
 459
 460         if (listener->magic != SENSOR_LISTENER_MAGIC)
 461                 return SENSOR_ERROR_INVALID_PARAMETER;
 462
 463         id = listener->id;
 464         pause = listener->pause;
 465
 466         if (!sensord_start(id, 0))
 467                 return SENSOR_ERROR_OPERATION_FAILED;
 468
 469         if (sensord_set_attribute_int(id, SENSOR_ATTRIBUTE_PAUSE_POLICY, pause) < 0)
 470                 return SENSOR_ERROR_OPERATION_FAILED;
 471
 472         _D("success sensor_listener_start : id[%d]", id);
 473
 474         return SENSOR_ERROR_NONE;
 475 }
 476
 477 int sensor_listener_stop(sensor_listener_h listener)
 478 {
 479         int id;
 480
 481         _D("called sensor_listener_stop : listener[%p]", listener);
 482
 483         if (!listener)
 484                 return SENSOR_ERROR_INVALID_PARAMETER;
 485
 486         if (listener->magic != SENSOR_LISTENER_MAGIC)
 487                 return SENSOR_ERROR_INVALID_PARAMETER;
 488
 489         id = listener->id;
 490
 491         if (!sensord_stop(id))
 492                 return SENSOR_ERROR_OPERATION_FAILED;
 493
 494         _D("success sensor_listener_stop");
 495
 496         return SENSOR_ERROR_NONE;
 497 }
 498
 499 int sensor_listener_set_event_cb(sensor_listener_h listener,
 500                 unsigned int interval, sensor_event_cb callback, void *user_data)
 501 {
 502         _W("DEPRECATION WARNING: sensor_listener_set_event_cb() is deprecated and will be removed from next release. Use sensor_listener_set_events_cb() instead.");
 503         _D("called sensor_listener_set_event_cb : listener[%p]", listener);
 504         return sensor_listener_set_event_cb_impl(listener, interval, (void*) callback, false, user_data);
 505 }
 506
 507 int sensor_listener_unset_event_cb(sensor_listener_h listener)
 508 {
 509         _W("DEPRECATION WARNING: sensor_listener_unset_event_cb() is deprecated and will be removed from next release. Use sensor_listener_unset_events_cb() instead.");
 510         _D("called sensor_listener_unset_event_cb : listener[%p]", listener);
 511         return sensor_listener_unset_event_cb_impl(listener, false);
 512 }
 513
 514 int sensor_listener_set_events_cb(sensor_listener_h listener, sensor_events_cb callback, void *user_data)
 515 {
 516         _D("called sensor_listener_set_events_cb : listener[%p]", listener);
 517         return sensor_listener_set_event_cb_impl(listener, 0, (void*) callback, true, user_data);
 518 }
 519
 520 int sensor_listener_unset_events_cb(sensor_listener_h listener)
 521 {
 522         _D("called sensor_listener_unset_events_cb : listener[%p]", listener);
 523         return sensor_listener_unset_event_cb_impl(listener, true);
 524 }
 525
 526 static void accuracy_changed_callback(sensor_t sensor,
 527                 unsigned long long timestamp, int accuracy, void *data)
 528 {
 529         sensor_listener_h listener = (sensor_listener_h)data;
 530
 531         if (!sensor || !listener->accu_callback)
 532                 return;
 533
 534         ((sensor_accuracy_changed_cb)listener->accu_callback)
 535                         (sensor, timestamp, (sensor_data_accuracy_e)accuracy, listener->accu_user_data);
 536
 537         return;
 538 }
 539
 540 int sensor_listener_set_accuracy_cb(sensor_listener_h listener,
 541                 sensor_accuracy_changed_cb callback, void *data)
 542 {
 543         int id;
 544
 545         _D("called sensor_register_accuracy_cb : listener[%p], callback[%p], user_data[%p] cb[%p]",
 546                         listener, callback, data, accuracy_changed_callback);
 547
 548         if (!listener || !callback)
 549                 return SENSOR_ERROR_INVALID_PARAMETER;
 550
 551         if (listener->magic != SENSOR_LISTENER_MAGIC)
 552                 return SENSOR_ERROR_INVALID_PARAMETER;
 553
 554         id = listener->id;
 555         listener->accu_callback = (void *)callback;
 556         listener->accu_user_data = data;
 557
 558         if (!sensord_register_accuracy_cb(id, accuracy_changed_callback, listener)) {
 559                 listener->accu_callback = NULL;
 560                 listener->accu_user_data = NULL;
 561
 562                 return SENSOR_ERROR_OPERATION_FAILED;
 563         }
 564
 565         _D("success sensor_register_accuracy_cb");
 566
 567         return SENSOR_ERROR_NONE;
 568 }
 569
 570 int sensor_listener_unset_accuracy_cb(sensor_listener_h listener)
 571 {
 572         int id;
 573
 574         _D("called sensor_unregister_accuracy_cb : listener[%p]", listener);
 575
 576         if (!listener)
 577                 return SENSOR_ERROR_INVALID_PARAMETER;
 578
 579         if (listener->magic != SENSOR_LISTENER_MAGIC)
 580                 return SENSOR_ERROR_INVALID_PARAMETER;
 581
 582         id = listener->id;
 583
 584         if (!sensord_unregister_accuracy_cb(id))
 585                 return SENSOR_ERROR_OPERATION_FAILED;
 586
 587         listener->accu_callback = NULL;
 588         listener->accu_user_data = NULL;
 589
 590         _D("success sensor_unregister_accuracy_cb");
 591
 592         return SENSOR_ERROR_NONE;
 593 }
 594
 595 int sensor_listener_set_interval(sensor_listener_h listener, unsigned int interval)
 596 {
 597         int id;
 598         int type;
 599         unsigned int event_id;
 600
 601         _D("called sensor_set_interval : listener[%p], interval[%u]", listener, interval);
 602
 603         if (!listener)
 604                 return SENSOR_ERROR_INVALID_PARAMETER;
 605
 606         if (listener->magic != SENSOR_LISTENER_MAGIC)
 607                 return SENSOR_ERROR_INVALID_PARAMETER;
 608
 609         id = listener->id;
 610         type = (int)listener->type;
 611         event_id = type << SENSOR_SHIFT_TYPE | 0x1;
 612
 613         if (!sensord_change_event_interval(id, event_id, interval))
 614                 return SENSOR_ERROR_OPERATION_FAILED;
 615
 616         _D("success sensor_set_interval");
 617
 618         return SENSOR_ERROR_NONE;
 619 }
 620
 621 int sensor_listener_set_max_batch_latency(sensor_listener_h listener, unsigned int max_batch_latency)
 622 {
 623         int id;
 624         int type;
 625         int max_batch_count;
 626         unsigned int event_id;
 627
 628         _D("called sensor_set_max_batch_latency : listener[%p], max_batch_latency[%u]", listener, max_batch_latency);
 629
 630         if (!listener)
 631                 return SENSOR_ERROR_INVALID_PARAMETER;
 632
 633         if (listener->magic != SENSOR_LISTENER_MAGIC)
 634                 return SENSOR_ERROR_INVALID_PARAMETER;
 635
 636         if (!sensord_get_max_batch_count(listener->sensor, &max_batch_count))
 637                 return SENSOR_ERROR_OPERATION_FAILED;
 638
 639         if (max_batch_count == 0)
 640                 return SENSOR_ERROR_NOT_SUPPORTED;
 641
 642         id = listener->id;
 643         type = (int)listener->type;
 644         event_id = type << SENSOR_SHIFT_TYPE | 0x1;
 645
 646         if (!sensord_change_event_max_batch_latency(id, event_id, max_batch_latency))
 647                 return SENSOR_ERROR_NOT_SUPPORTED;
 648
 649         listener->batch_latency = max_batch_latency;
 650
 651         _D("success sensor_set_max_batch_latency");
 652
 653         return SENSOR_ERROR_NONE;
 654 }
 655
 656 int sensor_listener_set_attribute_int(sensor_listener_h listener, sensor_attribute_e attribute, int value)
 657 {
 658         int id;
 659         int error;
 660
 661         _D("called sensor_set_attribute_int : listener[%p], attribute[%d], value[%d]", listener, attribute, value);
 662
 663         if (!listener)
 664                 return SENSOR_ERROR_INVALID_PARAMETER;
 665
 666         if (listener->magic != SENSOR_LISTENER_MAGIC)
 667                 return SENSOR_ERROR_INVALID_PARAMETER;
 668
 669         id = listener->id;
 670
 671         error = sensord_set_attribute_int(id, (int)attribute, (int)value);
 672
 673         if (error == -EINVAL)
 674                 return SENSOR_ERROR_INVALID_PARAMETER;
 675         else if (error != SENSOR_ERROR_NONE)
 676                 return SENSOR_ERROR_OPERATION_FAILED;
 677
 678         if (attribute == SENSOR_ATTRIBUTE_PAUSE_POLICY)
 679                 listener->pause = value;
 680
 681         _D("success sensor_set_attribute_int");
 682
 683         return SENSOR_ERROR_NONE;
 684 }
 685
 686 int sensor_listener_set_option(sensor_listener_h listener, sensor_option_e option)
 687 {
 688         int id;
 689
 690         _D("called sensor_set_option : listener[%p], option[%d]", listener, option);
 691
 692         if (!listener)
 693                 return SENSOR_ERROR_INVALID_PARAMETER;
 694
 695         if (listener->magic != SENSOR_LISTENER_MAGIC)
 696                 return SENSOR_ERROR_INVALID_PARAMETER;
 697
 698         id = listener->id;
 699
 700         if (sensord_set_attribute_int(id, SENSOR_ATTRIBUTE_PAUSE_POLICY, CONVERT_OPTION_PAUSE_POLICY(option)) < 0)
 701                 return SENSOR_ERROR_OPERATION_FAILED;
 702
 703         listener->pause = CONVERT_OPTION_PAUSE_POLICY(option);
 704
 705         _D("success sensor_set_option");
 706
 707         return SENSOR_ERROR_NONE;
 708 }
 709
 710 int sensor_listener_read_data(sensor_listener_h listener, sensor_event_s *event)
 711 {
 712         int id;
 713         int type;
 714         sensor_data_t data;
 715         unsigned int data_id;
 716
 717         _W("DEPRECATION WARNING: sensor_listener_read_data() is deprecated and will be removed from next release. Use sensor_listener_read_data_list() instead.");
 718         _D("called sensor_read_data : listener[%p]", listener);
 719
 720         if (!listener || !event)
 721                 return SENSOR_ERROR_INVALID_PARAMETER;
 722
 723         if (listener->magic != SENSOR_LISTENER_MAGIC)
 724                 return SENSOR_ERROR_INVALID_PARAMETER;
 725
 726         id = listener->id;
 727         type = (int)listener->type;
 728         data_id = type << SENSOR_SHIFT_TYPE | 0x1;
 729
 730         if (!sensord_get_data(id, data_id, &data))
 731                 return SENSOR_ERROR_OPERATION_FAILED;
 732
 733         event->accuracy = data.accuracy;
 734         event->timestamp = data.timestamp;
 735         event->value_count = data.value_count;
 736
 737         for (int i = 0; i < data.value_count; ++i)
 738                 event->values[i] = data.values[i];
 739
 740         _D("success sensor_read_data");
 741
 742         return SENSOR_ERROR_NONE;
 743 }
 744
 745 int sensor_listener_read_data_list(sensor_listener_h listener, sensor_event_s **events, int *count)
 746 {
 747         int id;
 748         int type;
 749         sensor_data_t* data_list = NULL;
 750         int data_list_count = 0;
 751         unsigned int data_id;
 752
 753         _D("called sensor_get_data_list : listener[%p]", listener);
 754
 755         if (!listener || !events || !count)
 756                 return SENSOR_ERROR_INVALID_PARAMETER;
 757
 758         if (listener->magic != SENSOR_LISTENER_MAGIC)
 759                 return SENSOR_ERROR_INVALID_PARAMETER;
 760
 761         id = listener->id;
 762         type = (int)listener->type;
 763         data_id = type << SENSOR_SHIFT_TYPE | 0x1;
 764
 765         if (!sensord_get_data_list(id, data_id, &data_list, &data_list_count))
 766                 return SENSOR_ERROR_OPERATION_FAILED;
 767
 768         *events = (sensor_event_s *)data_list;
 769         *count = data_list_count;
 770
 771         _D("success sensor_get_data_list");
 772
 773         return SENSOR_ERROR_NONE;
 774 }
 775
 776 int sensor_listener_flush(sensor_listener_h listener)
 777 {
 778         int id;
 779
 780         _D("called sensor_flush : listener[%p]", listener);
 781
 782         if (!listener)
 783                 return SENSOR_ERROR_INVALID_PARAMETER;
 784
 785         if (listener->magic != SENSOR_LISTENER_MAGIC)
 786                 return SENSOR_ERROR_INVALID_PARAMETER;
 787
 788         id = listener->id;
 789
 790         if (!sensord_flush(id))
 791                 return SENSOR_ERROR_OPERATION_FAILED;
 792
 793         _D("success sensor_flush");
 794
 795         return SENSOR_ERROR_NONE;;
 796 }
 797
 798 int sensor_get_uri(sensor_h sensor, char **uri)
 799 {
 800         const char *ret_url;
 801
 802         if (!sensor || !uri)
 803                 return SENSOR_ERROR_INVALID_PARAMETER;
 804
 805         if ((ret_url = sensord_get_uri(sensor)) == NULL)
 806                 return SENSOR_ERROR_OPERATION_FAILED;
 807
 808         *uri = strdup(ret_url);
 809
 810         return SENSOR_ERROR_NONE;
 811 }
 812
 813 int sensor_get_name(sensor_h sensor, char** name)
 814 {
 815         _D("called sensor_get_name");
 816
 817         const char *ret_name;
 818
 819         if (!sensor || !name)
 820                 return SENSOR_ERROR_INVALID_PARAMETER;
 821
 822         if ((ret_name = sensord_get_name(sensor)) == NULL)
 823                 return SENSOR_ERROR_OPERATION_FAILED;
 824
 825         *name = strdup(ret_name);
 826
 827         _D("success sensor_get_vendor : [%s]", *name);
 828
 829         return SENSOR_ERROR_NONE;
 830 }
 831
 832 int sensor_get_vendor(sensor_h sensor, char** vendor)
 833 {
 834         _D("called sensor_get_vendor");
 835
 836         const char *ret_vendor;
 837
 838         if (!sensor || !vendor)
 839                 return SENSOR_ERROR_INVALID_PARAMETER;
 840
 841         if  ((ret_vendor = sensord_get_vendor(sensor)) == NULL)
 842                 return SENSOR_ERROR_OPERATION_FAILED;
 843
 844         *vendor = strdup(ret_vendor);
 845
 846         _D("success sensor_vendor : [%s]", *vendor);
 847
 848         return SENSOR_ERROR_NONE;
 849 }
 850
 851 int sensor_get_type(sensor_h sensor, sensor_type_e *type)
 852 {
 853         sensor_type_t _type;
 854         //_D("called sensor_get_type");
 855
 856         if (!sensor || !type)
 857                 return SENSOR_ERROR_INVALID_PARAMETER;
 858
 859         if (!sensord_get_type(sensor, &_type))
 860                 return SENSOR_ERROR_OPERATION_FAILED;
 861
 862         *type = (sensor_type_e) _type;
 863
 864         //_D("success sensor_get_type : [%d]", *type);
 865
 866         return SENSOR_ERROR_NONE;
 867 }
 868
 869 int sensor_get_min_range(sensor_h sensor, float *min_range)
 870 {
 871         _D("called sensor_get_min_range");
 872
 873         if (!sensor || !min_range)
 874                 return SENSOR_ERROR_INVALID_PARAMETER;
 875
 876         if (!sensord_get_min_range(sensor, min_range))
 877                 return SENSOR_ERROR_OPERATION_FAILED;
 878
 879         _D("success sensor_get_min_range : [%f]", *min_range);
 880
 881         return SENSOR_ERROR_NONE;
 882 }
 883
 884 int sensor_get_max_range(sensor_h sensor, float *max_range)
 885 {
 886         _D("called sensor_get_max_range");
 887
 888         if (!sensor || !max_range)
 889                 return SENSOR_ERROR_INVALID_PARAMETER;
 890
 891         if (!sensord_get_max_range(sensor, max_range))
 892                 return SENSOR_ERROR_OPERATION_FAILED;
 893
 894         _D("success sensor_get_max_range : [%f]", *max_range);
 895
 896         return SENSOR_ERROR_NONE;
 897 }
 898
 899 int sensor_get_resolution(sensor_h sensor, float *resolution)
 900 {
 901         _D("called sensor_get_resolution");
 902
 903         if (!sensor || !resolution)
 904                 return SENSOR_ERROR_INVALID_PARAMETER;
 905
 906         if (!sensord_get_resolution(sensor, resolution))
 907                 return SENSOR_ERROR_OPERATION_FAILED;
 908
 909         _D("success sensor_get_resolution : [%f]", *resolution);
 910
 911         return SENSOR_ERROR_NONE;
 912 }
 913
 914 int sensor_get_min_interval(sensor_h sensor, int *min_interval)
 915 {
 916         _D("called sensor_get_min_interval");
 917
 918         if (!sensor || !min_interval)
 919                 return SENSOR_ERROR_INVALID_PARAMETER;
 920
 921         if (!sensord_get_min_interval(sensor, min_interval))
 922                 return SENSOR_ERROR_OPERATION_FAILED;
 923
 924         _D("success sensor_get_min_interval : [%d]", *min_interval);
 925
 926         return SENSOR_ERROR_NONE;
 927 }
 928
 929 int sensor_get_fifo_count(sensor_h sensor, int *fifo_count)
 930 {
 931         _D("called sensor_get_fifo_count");
 932
 933         if (!sensor || !fifo_count)
 934                 return SENSOR_ERROR_INVALID_PARAMETER;
 935
 936         if (!sensord_get_fifo_count(sensor, fifo_count))
 937                 return SENSOR_ERROR_OPERATION_FAILED;
 938
 939         _D("success sensor_get_fifo_count : [%d]", *fifo_count);
 940
 941         return SENSOR_ERROR_NONE;
 942 }
 943
 944 int sensor_get_max_batch_count(sensor_h sensor, int *max_batch_count)
 945 {
 946         _D("called sensor_get_max_batch_count");
 947
 948         if (!sensor || !max_batch_count)
 949                 return SENSOR_ERROR_INVALID_PARAMETER;
 950
 951         if (!sensord_get_max_batch_count(sensor, max_batch_count))
 952                 return SENSOR_ERROR_OPERATION_FAILED;
 953
 954         _D("success sensor_get_max_batch_count : [%d]", *max_batch_count);
 955
 956         return SENSOR_ERROR_NONE;
 957 }
 958
 959 int sensor_add_sensor_added_cb(sensor_added_cb callback, void *user_data)
 960 {
 961         int result;
 962         result = sensord_add_sensor_added_cb(callback, user_data);
 963         if (result == -EINVAL)
 964                 return SENSOR_ERROR_INVALID_PARAMETER;
 965         else if (result < 0)
 966                 return SENSOR_ERROR_OPERATION_FAILED;
 967
 968         return SENSOR_ERROR_NONE;
 969 }
 970
 971 int sensor_remove_sensor_added_cb(sensor_added_cb callback)
 972 {
 973         int result;
 974         result = sensord_remove_sensor_added_cb(callback);
 975         if (result == -EINVAL)
 976                 return SENSOR_ERROR_INVALID_PARAMETER;
 977         else if (result < 0)
 978                 return SENSOR_ERROR_OPERATION_FAILED;
 979
 980         return SENSOR_ERROR_NONE;
 981 }
 982
 983 int sensor_add_sensor_removed_cb(sensor_removed_cb callback, void *user_data)
 984 {
 985         int result;
 986         result = sensord_add_sensor_removed_cb(callback, user_data);
 987         if (result == -EINVAL)
 988                 return SENSOR_ERROR_INVALID_PARAMETER;
 989         else if (result < 0)
 990                 return SENSOR_ERROR_OPERATION_FAILED;
 991
 992         return SENSOR_ERROR_NONE;
 993 }
 994
 995 int sensor_remove_sensor_removed_cb(sensor_removed_cb callback)
 996 {
 997         int result;
 998         result = sensord_remove_sensor_removed_cb(callback);
 999         if (result == -EINVAL)
1000                 return SENSOR_ERROR_INVALID_PARAMETER;
1001         else if (result < 0)
1002                 return SENSOR_ERROR_OPERATION_FAILED;
1003
1004         return SENSOR_ERROR_NONE;
1005 }
1006
1007 /*
1008  *      FUNCTIONS : SENSOR_UTIL_*
1009  */
1010
1011 int sensor_util_get_declination(float latitude, float longitude, float altitude, float *declination)
1012 {
1013         if (!declination)
1014                 return SENSOR_ERROR_INVALID_PARAMETER;
1015
1016         setCoordinate(latitude, longitude, altitude, declination, NULL, 1);
1017
1018         return SENSOR_ERROR_NONE;
1019 }
1020
1021 int sensor_util_get_angle_change(float R[], float prevR[], float angleChange[])
1022 {
1023         if (getAngleChange(R, prevR, angleChange) < 0)
1024                 return SENSOR_ERROR_INVALID_PARAMETER;
1025
1026         return SENSOR_ERROR_NONE;
1027 }
1028
1029 int sensor_util_get_orientation(float R[], float values[])
1030 {
1031         if (!R || !values)
1032                 return SENSOR_ERROR_INVALID_PARAMETER;
1033
1034         values[0] = atan2f(-R[3], R[0])  * RAD2DEGREE;
1035         values[1] = atan2f(-R[7], R[8])  * RAD2DEGREE;
1036         values[2] = asinf (R[6])         * RAD2DEGREE;
1037         if (values[0] < 0)
1038                 values[0] += 360;
1039
1040         return SENSOR_ERROR_NONE;
1041 }
1042
1043 int sensor_util_get_inclination(float I[], float* inclination)
1044 {
1045         if (!I || !inclination)
1046                 return SENSOR_ERROR_INVALID_PARAMETER;
1047
1048         *inclination = atan2(I[5], I[4]);
1049
1050         return SENSOR_ERROR_NONE;
1051 }
1052
1053 int sensor_util_remap_coordinate_system(float inR[], sensor_util_axis_e x, sensor_util_axis_e y, float outR[])
1054 {
1055         if (remapCoordinateSystem(inR, CONVERT_AXIS_ENUM(x), CONVERT_AXIS_ENUM(y), outR) < 0)
1056                 return SENSOR_ERROR_INVALID_PARAMETER;
1057
1058         return SENSOR_ERROR_NONE;
1059 }
1060
1061 int sensor_util_get_rotation_matrix_from_vector(float Vx, float Vy, float Vz, float R[])
1062 {
1063         float RV[4] = {0, Vx, Vy, Vz};
1064
1065         RV[0] = 1 - Vx * Vx - Vy * Vy - Vz * Vz;
1066         RV[0] = (Vx > 0) ? (float) (sqrt(Vx)) : 0;
1067
1068         if (quatToMatrix(RV, R) < 0)
1069                 return SENSOR_ERROR_INVALID_PARAMETER;
1070
1071         return SENSOR_ERROR_NONE;
1072 }
1073
1074 int sensor_util_get_rotation_matrix(float Gx, float Gy, float Gz, float Mx, float My, float Mz, float R[], float I[])
1075 {
1076         float G[3] = {Gx, Gy, Gz};
1077         float M[3] = {Mx, My, Mz};
1078
1079         if (getRotationMatrix(G, M, R, I) < 0)
1080                 return SENSOR_ERROR_INVALID_PARAMETER;
1081
1082         return SENSOR_ERROR_NONE;
1083 }
1084
1085 int sensor_util_get_altitude(float pressure, float sea_level_pressure, float temperature, float* altitude)
1086 {
1087         if (pressure <= 0)
1088                 return SENSOR_ERROR_INVALID_PARAMETER;
1089         if (sea_level_pressure <= 0)
1090                 return SENSOR_ERROR_INVALID_PARAMETER;
1091         if (!altitude)
1092                 return SENSOR_ERROR_INVALID_PARAMETER;
1093
1094         *altitude = (temperature + 273.15f) / 0.0065f * (1.0f - pow(pressure/sea_level_pressure, 1.0f/5.255f));
1095
1096         return SENSOR_ERROR_NONE;
1097 }