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