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