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_get_default_sensor(sensor_type_e type, sensor_h *sensor)
 131 {
 132         int result;
 133         sensor_t _sensor;
 134         sensor_privilege_t privilege;
 135
 136         WARN_DEPRECATED_SENSOR(type);
 137
 138         _D("called sensor_get_default_sensor : type[%d], sensor[0x%x]", type, sensor);
 139
 140         if (type < SENSOR_ALL)
 141                 return SENSOR_ERROR_INVALID_PARAMETER;
 142
 143         if (!sensor)
 144                 return SENSOR_ERROR_INVALID_PARAMETER;
 145
 146         result = sensord_get_default_sensor((sensor_type_t)type, &_sensor);
 147         if (result == -EACCES)
 148                 return SENSOR_ERROR_PERMISSION_DENIED;
 149         else if (result == -EPERM)
 150                 return SENSOR_ERROR_OPERATION_FAILED;
 151
 152         if (!_sensor)
 153                 return SENSOR_ERROR_NOT_SUPPORTED;
 154
 155         sensord_get_privilege(_sensor, &privilege);
 156         if (privilege != SENSOR_PRIVILEGE_PUBLIC)
 157                 return SENSOR_ERROR_PERMISSION_DENIED;
 158
 159         *sensor = _sensor;
 160
 161         _D("success sensor_get_default_sensor sensor[0x%x]", _sensor);
 162
 163         return SENSOR_ERROR_NONE;
 164 }
 165
 166 int sensor_get_sensor_list(sensor_type_e type, sensor_h **list, int *sensor_count)
 167 {
 168         int result;
 169         sensor_h *_list;
 170         int count;
 171
 172         WARN_DEPRECATED_SENSOR(type);
 173
 174         _D("called sensor_get_list : type[%d]", type);
 175
 176         if (type < SENSOR_ALL)
 177                 return SENSOR_ERROR_INVALID_PARAMETER;
 178
 179         if (!sensor_count || !list)
 180                 return SENSOR_ERROR_INVALID_PARAMETER;
 181
 182         result = sensord_get_sensors((sensor_type_t)type, &_list, &count);
 183
 184         if (result == -EACCES)
 185                 return SENSOR_ERROR_PERMISSION_DENIED;
 186         else if (result == -EPERM)
 187                 return SENSOR_ERROR_OPERATION_FAILED;
 188         else if (result == -ENODATA)
 189                 return SENSOR_ERROR_NOT_SUPPORTED;
 190
 191         int i, j;
 192         int count_public = 0;
 193
 194         for (i = 0; i < count; ++i) {
 195                 sensor_privilege_t privilege;
 196
 197                 sensord_get_privilege(_list[i], &privilege);
 198                 if (privilege != SENSOR_PRIVILEGE_PUBLIC)
 199                         continue;
 200
 201                 count_public++;
 202         }
 203
 204         if (count_public == 0) {
 205                 free(_list);
 206                 return SENSOR_ERROR_PERMISSION_DENIED;
 207         }
 208
 209         *list = (sensor_h *) malloc((sizeof(int *)) * count_public);
 210
 211         if (!*list) {
 212                 free(_list);
 213                 return SENSOR_ERROR_OUT_OF_MEMORY;
 214         }
 215
 216         for (i = 0, j = 0; i < count; ++i) {
 217                 sensor_privilege_t privilege;
 218
 219                 sensord_get_privilege(_list[i], &privilege);
 220                 if (privilege != SENSOR_PRIVILEGE_PUBLIC)
 221                         continue;
 222
 223                 *(*list + j) = _list[i];
 224                 j++;
 225         }
 226
 227         free(_list);
 228
 229         *sensor_count = count_public;
 230
 231         _D("success sensor_get_list");
 232
 233         return SENSOR_ERROR_NONE;
 234 }
 235
 236 int sensor_is_wake_up(sensor_h sensor, bool *wakeup)
 237 {
 238         _D("called sensor_get_type");
 239
 240         if (!sensor || !wakeup)
 241                 return SENSOR_ERROR_INVALID_PARAMETER;
 242
 243         *wakeup = sensord_is_wakeup_supported(sensor);
 244
 245         _D("success sensor_is_wake_up : [%d]", *wakeup);
 246
 247         return SENSOR_ERROR_NONE;
 248 }
 249
 250 int sensor_create_listener(sensor_h sensor, sensor_listener_h *listener)
 251 {
 252         struct sensor_listener_s *_listener;
 253         int error;
 254
 255         _D("called sensor_create_listener : listener[0x%x]", listener);
 256
 257         if (!sensor || !listener)
 258                 return SENSOR_ERROR_INVALID_PARAMETER;
 259
 260         _listener = new(std::nothrow) struct sensor_listener_s;
 261
 262         if (!_listener)
 263                 return SENSOR_ERROR_OUT_OF_MEMORY;
 264
 265         error = sensor_connect(sensor, _listener);
 266
 267         if (error < 0) {
 268                 delete (struct sensor_listener_s *)_listener;
 269                 return SENSOR_ERROR_OPERATION_FAILED;
 270         }
 271
 272         _listener->sensor = sensor;
 273         _listener->pause = SENSOR_PAUSE_ALL;
 274         _listener->batch_latency = SENSOR_BATCH_LATENCY_DEFAULT;
 275         _listener->magic = SENSOR_LISTENER_MAGIC;
 276
 277         *listener = (sensor_listener_h) _listener;
 278
 279         _D("success sensor_create_listener");
 280
 281         return SENSOR_ERROR_NONE;
 282 }
 283
 284 int sensor_destroy_listener(sensor_listener_h listener)
 285 {
 286         _D("called sensor_destroy : listener[0x%x]", listener);
 287
 288         if (!listener)
 289                 return SENSOR_ERROR_INVALID_PARAMETER;
 290
 291         if (listener->magic != SENSOR_LISTENER_MAGIC)
 292                 return SENSOR_ERROR_INVALID_PARAMETER;
 293
 294         sensord_disconnect(listener->id);
 295         listener->magic = 0;
 296
 297         delete (sensor_listener_s *)listener;
 298
 299         _D("success sensor_destroy");
 300
 301         return SENSOR_ERROR_NONE;
 302 }
 303
 304 int sensor_listener_start(sensor_listener_h listener)
 305 {
 306         int id;
 307         unsigned int pause = SENSOR_PAUSE_ALL;
 308
 309         _D("called sensor_listener_start : listener[0x%x]", listener);
 310
 311         if (!listener)
 312                 return SENSOR_ERROR_INVALID_PARAMETER;
 313
 314         if (listener->magic != SENSOR_LISTENER_MAGIC)
 315                 return SENSOR_ERROR_INVALID_PARAMETER;
 316
 317         id = listener->id;
 318         pause = listener->pause;
 319
 320         if (!sensord_start(id, 0))
 321                 return SENSOR_ERROR_OPERATION_FAILED;
 322
 323         if (sensord_set_attribute_int(id, SENSOR_ATTRIBUTE_PAUSE_POLICY, pause) < 0)
 324                 return SENSOR_ERROR_OPERATION_FAILED;
 325
 326         _D("success sensor_listener_start : id[%d]", id);
 327
 328         return SENSOR_ERROR_NONE;
 329 }
 330
 331 int sensor_listener_stop(sensor_listener_h listener)
 332 {
 333         int id;
 334
 335         _D("called sensor_listener_stop : listener[0x%x]", listener);
 336
 337         if (!listener)
 338                 return SENSOR_ERROR_INVALID_PARAMETER;
 339
 340         if (listener->magic != SENSOR_LISTENER_MAGIC)
 341                 return SENSOR_ERROR_INVALID_PARAMETER;
 342
 343         id = listener->id;
 344
 345         if (!sensord_stop(id))
 346                 return SENSOR_ERROR_OPERATION_FAILED;
 347
 348         _D("success sensor_listener_stop");
 349
 350         return SENSOR_ERROR_NONE;
 351 }
 352
 353 static void sensor_callback(sensor_t sensor, unsigned int event_type, sensor_data_t *data, void *user_data)
 354 {
 355         sensor_event_s *event;
 356         sensor_listener_h listener;
 357         listener = (sensor_listener_h)user_data;
 358
 359         _D("success sensor_callback, sensor[%p] listener[%p] listener->callback[%p]", sensor, listener, listener->callback);
 360         if (!sensor || !listener->callback)
 361                 return;
 362
 363         event = (sensor_event_s *)data;
 364
 365         ((sensor_event_cb) listener->callback)(sensor, event, listener->user_data);
 366         return;
 367 }
 368
 369 int sensor_listener_set_event_cb(sensor_listener_h listener,
 370                 unsigned int interval, sensor_event_cb callback, void *user_data)
 371 {
 372         int id;
 373         unsigned int event_id;
 374         unsigned int batch_latency;
 375
 376         if (!listener || !callback)
 377                 return SENSOR_ERROR_INVALID_PARAMETER;
 378
 379         if (listener->magic != SENSOR_LISTENER_MAGIC)
 380                 return SENSOR_ERROR_INVALID_PARAMETER;
 381
 382         _D("called sensor_listener_set_event : listener[0x%x], interval[%d], callback[0x%x], user_data[0x%x], id[%d]",
 383                         listener, interval, callback, user_data, listener->id);
 384
 385         id = listener->id;
 386         event_id = (listener->type) << SENSOR_SHIFT_TYPE | 0x1;
 387         batch_latency = listener->batch_latency;
 388
 389         listener->callback = (void *)callback;
 390         listener->user_data = user_data;
 391
 392         if (!sensord_register_event(id, event_id, interval, batch_latency,
 393                                 sensor_callback, listener)) {
 394                 listener->callback = NULL;
 395                 listener->user_data = NULL;
 396
 397                 return SENSOR_ERROR_OPERATION_FAILED;
 398         }
 399
 400         _D("success sensor_listener_set_event");
 401
 402         return SENSOR_ERROR_NONE;
 403 }
 404
 405 int sensor_listener_unset_event_cb(sensor_listener_h listener)
 406 {
 407         int id;
 408         int type;
 409         unsigned int event_id;
 410
 411         _D("called sensor_unregister_event : listener[0x%x]", listener);
 412
 413         if (!listener)
 414                 return SENSOR_ERROR_INVALID_PARAMETER;
 415
 416         if (listener->magic != SENSOR_LISTENER_MAGIC)
 417                 return SENSOR_ERROR_INVALID_PARAMETER;
 418
 419         id = listener->id;
 420         type = (int)listener->type;
 421         event_id = type << SENSOR_SHIFT_TYPE | 0x1;
 422
 423         if (!sensord_unregister_event(id, event_id))
 424                 return SENSOR_ERROR_OPERATION_FAILED;
 425
 426         listener->callback = NULL;
 427         listener->user_data = NULL;
 428
 429         _D("success sensor_unregister_event");
 430
 431         return SENSOR_ERROR_NONE;
 432 }
 433
 434 static void accuracy_changed_callback(sensor_t sensor,
 435                 unsigned long long timestamp, int accuracy, void *data)
 436 {
 437         sensor_listener_h listener = (sensor_listener_h)data;
 438
 439         if (!sensor || !listener->accu_callback)
 440                 return;
 441
 442         ((sensor_accuracy_changed_cb)listener->accu_callback)
 443                         (sensor, timestamp, (sensor_data_accuracy_e)accuracy, listener->accu_user_data);
 444
 445         return;
 446 }
 447
 448 int sensor_listener_set_accuracy_cb(sensor_listener_h listener,
 449                 sensor_accuracy_changed_cb callback, void *data)
 450 {
 451         int id;
 452
 453         _D("called sensor_register_accuracy_cb : listener[0x%x], callback[0x%x], user_data[0x%x] cb[%p]",
 454                         listener, callback, data, accuracy_changed_callback);
 455
 456         if (!listener || !callback)
 457                 return SENSOR_ERROR_INVALID_PARAMETER;
 458
 459         if (listener->magic != SENSOR_LISTENER_MAGIC)
 460                 return SENSOR_ERROR_INVALID_PARAMETER;
 461
 462         id = listener->id;
 463         listener->accu_callback = (void *)callback;
 464         listener->accu_user_data = data;
 465
 466         if (!sensord_register_accuracy_cb(id, accuracy_changed_callback, listener)) {
 467                 listener->accu_callback = NULL;
 468                 listener->accu_user_data = NULL;
 469
 470                 return SENSOR_ERROR_OPERATION_FAILED;
 471         }
 472
 473         _D("success sensor_register_accuracy_cb");
 474
 475         return SENSOR_ERROR_NONE;
 476 }
 477
 478 int sensor_listener_unset_accuracy_cb(sensor_listener_h listener)
 479 {
 480         int id;
 481
 482         _D("called sensor_unregister_accuracy_cb : listener[0x%x]", 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_unregister_accuracy_cb(id))
 493                 return SENSOR_ERROR_OPERATION_FAILED;
 494
 495         listener->accu_callback = NULL;
 496         listener->accu_user_data = NULL;
 497
 498         _D("success sensor_unregister_accuracy_cb");
 499
 500         return SENSOR_ERROR_NONE;
 501 }
 502
 503 int sensor_listener_set_interval(sensor_listener_h listener, unsigned int interval)
 504 {
 505         int id;
 506         int type;
 507         unsigned int event_id;
 508
 509         _D("called sensor_set_interval : listener[0x%x], interval[%d]", listener, interval);
 510
 511         if (!listener)
 512                 return SENSOR_ERROR_INVALID_PARAMETER;
 513
 514         if (listener->magic != SENSOR_LISTENER_MAGIC)
 515                 return SENSOR_ERROR_INVALID_PARAMETER;
 516
 517         id = listener->id;
 518         type = (int)listener->type;
 519         event_id = type << SENSOR_SHIFT_TYPE | 0x1;
 520
 521         if (!sensord_change_event_interval(id, event_id, interval))
 522                 return SENSOR_ERROR_OPERATION_FAILED;
 523
 524         _D("success sensor_set_interval");
 525
 526         return SENSOR_ERROR_NONE;
 527 }
 528
 529 int sensor_listener_set_max_batch_latency(sensor_listener_h listener, unsigned int max_batch_latency)
 530 {
 531         int id;
 532         int type;
 533         int max_batch_count;
 534         unsigned int event_id;
 535
 536         _D("called sensor_set_max_batch_latency : listener[0x%x], max_batch_latency[%d]", listener, max_batch_latency);
 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         if (!sensord_get_max_batch_count(listener->sensor, &max_batch_count))
 545                 return SENSOR_ERROR_OPERATION_FAILED;
 546
 547         if (max_batch_count == 0)
 548                 return SENSOR_ERROR_NOT_SUPPORTED;
 549
 550         id = listener->id;
 551         type = (int)listener->type;
 552         event_id = type << SENSOR_SHIFT_TYPE | 0x1;
 553
 554         if (!sensord_change_event_max_batch_latency(id, event_id, max_batch_latency))
 555                 return SENSOR_ERROR_NOT_SUPPORTED;
 556
 557         listener->batch_latency = max_batch_latency;
 558
 559         _D("success sensor_set_max_batch_latency");
 560
 561         return SENSOR_ERROR_NONE;
 562 }
 563
 564 int sensor_listener_set_attribute_int(sensor_listener_h listener, sensor_attribute_e attribute, int value)
 565 {
 566         int id;
 567         int error;
 568
 569         _D("called sensor_set_attribute_int : listener[0x%x], attribute[%d], value[%d]", listener, attribute, value);
 570
 571         if (!listener)
 572                 return SENSOR_ERROR_INVALID_PARAMETER;
 573
 574         if (listener->magic != SENSOR_LISTENER_MAGIC)
 575                 return SENSOR_ERROR_INVALID_PARAMETER;
 576
 577         id = listener->id;
 578
 579         error = sensord_set_attribute_int(id, (int)attribute, (int)value);
 580
 581         if (error == -EINVAL)
 582                 return SENSOR_ERROR_INVALID_PARAMETER;
 583         else if (error != SENSOR_ERROR_NONE)
 584                 return SENSOR_ERROR_OPERATION_FAILED;
 585
 586         if (attribute == SENSOR_ATTRIBUTE_PAUSE_POLICY)
 587                 listener->pause = value;
 588
 589         _D("success sensor_set_attribute_int");
 590
 591         return SENSOR_ERROR_NONE;
 592 }
 593
 594 int sensor_listener_set_option(sensor_listener_h listener, sensor_option_e option)
 595 {
 596         int id;
 597
 598         _D("called sensor_set_option : listener[0x%x], option[%d]", listener, option);
 599
 600         if (!listener)
 601                 return SENSOR_ERROR_INVALID_PARAMETER;
 602
 603         if (listener->magic != SENSOR_LISTENER_MAGIC)
 604                 return SENSOR_ERROR_INVALID_PARAMETER;
 605
 606         id = listener->id;
 607
 608         if (sensord_set_attribute_int(id, SENSOR_ATTRIBUTE_PAUSE_POLICY, CONVERT_OPTION_PAUSE_POLICY(option)) < 0)
 609                 return SENSOR_ERROR_OPERATION_FAILED;
 610
 611         listener->pause = CONVERT_OPTION_PAUSE_POLICY(option);
 612
 613         _D("success sensor_set_option");
 614
 615         return SENSOR_ERROR_NONE;
 616 }
 617
 618 int sensor_listener_read_data(sensor_listener_h listener, sensor_event_s *event)
 619 {
 620         int id;
 621         int type;
 622         sensor_data_t data;
 623         unsigned int data_id;
 624
 625         _D("called sensor_read_data : listener[0x%x]", listener);
 626
 627         if (!listener || !event)
 628                 return SENSOR_ERROR_INVALID_PARAMETER;
 629
 630         if (listener->magic != SENSOR_LISTENER_MAGIC)
 631                 return SENSOR_ERROR_INVALID_PARAMETER;
 632
 633         id = listener->id;
 634         type = (int)listener->type;
 635         data_id = type << SENSOR_SHIFT_TYPE | 0x1;
 636
 637         if (!sensord_get_data(id, data_id, &data))
 638                 return SENSOR_ERROR_OPERATION_FAILED;
 639
 640         event->accuracy = data.accuracy;
 641         event->timestamp = data.timestamp;
 642         event->value_count = data.value_count;
 643
 644         for (int i = 0; i < data.value_count; ++i)
 645                 event->values[i] = data.values[i];
 646
 647         _D("success sensor_read_data");
 648
 649         return SENSOR_ERROR_NONE;
 650 }
 651
 652 int sensor_get_name(sensor_h sensor, char** name)
 653 {
 654         _D("called sensor_get_name");
 655
 656         if (!sensor || !name)
 657                 return SENSOR_ERROR_INVALID_PARAMETER;
 658
 659         *name = strdup(sensord_get_name(sensor));
 660
 661         _D("success sensor_get_vendor : [%s]", *name);
 662
 663         return SENSOR_ERROR_NONE;
 664 }
 665
 666 int sensor_get_vendor(sensor_h sensor, char** vendor)
 667 {
 668         _D("called sensor_get_vendor");
 669
 670         if (!sensor || !vendor)
 671                 return SENSOR_ERROR_INVALID_PARAMETER;
 672
 673         *vendor = strdup(sensord_get_vendor(sensor));
 674
 675         _D("success sensor_vendor : [%s]", *vendor);
 676
 677         return SENSOR_ERROR_NONE;
 678 }
 679
 680 int sensor_get_type(sensor_h sensor, sensor_type_e *type)
 681 {
 682         sensor_type_t _type;
 683         _D("called sensor_get_type");
 684
 685         if (!sensor || !type)
 686                 return SENSOR_ERROR_INVALID_PARAMETER;
 687
 688         if (!sensord_get_type(sensor, &_type))
 689                 return SENSOR_ERROR_OPERATION_FAILED;
 690
 691         *type = (sensor_type_e) _type;
 692
 693         _D("success sensor_get_type : [%d]", *type);
 694
 695         return SENSOR_ERROR_NONE;
 696 }
 697
 698 int sensor_get_min_range(sensor_h sensor, float *min_range)
 699 {
 700         _D("called sensor_get_min_range");
 701
 702         if (!sensor || !min_range)
 703                 return SENSOR_ERROR_INVALID_PARAMETER;
 704
 705         if (!sensord_get_min_range(sensor, min_range))
 706                 return SENSOR_ERROR_OPERATION_FAILED;
 707
 708         _D("success sensor_get_min_range : [%d]", *min_range);
 709
 710         return SENSOR_ERROR_NONE;
 711 }
 712
 713 int sensor_get_max_range(sensor_h sensor, float *max_range)
 714 {
 715         _D("called sensor_get_max_range");
 716
 717         if (!sensor || !max_range)
 718                 return SENSOR_ERROR_INVALID_PARAMETER;
 719
 720         if (!sensord_get_max_range(sensor, max_range))
 721                 return SENSOR_ERROR_OPERATION_FAILED;
 722
 723         _D("success sensor_get_max_range : [%d]", *max_range);
 724
 725         return SENSOR_ERROR_NONE;
 726 }
 727
 728 int sensor_get_resolution(sensor_h sensor, float *resolution)
 729 {
 730         _D("called sensor_get_resolution");
 731
 732         if (!sensor || !resolution)
 733                 return SENSOR_ERROR_INVALID_PARAMETER;
 734
 735         if (!sensord_get_resolution(sensor, resolution))
 736                 return SENSOR_ERROR_OPERATION_FAILED;
 737
 738         _D("success sensor_get_resolution : [%d]", *resolution);
 739
 740         return SENSOR_ERROR_NONE;
 741 }
 742
 743 int sensor_get_min_interval(sensor_h sensor, int *min_interval)
 744 {
 745         _D("called sensor_get_min_interval");
 746
 747         if (!sensor || !min_interval)
 748                 return SENSOR_ERROR_INVALID_PARAMETER;
 749
 750         if (!sensord_get_min_interval(sensor, min_interval))
 751                 return SENSOR_ERROR_OPERATION_FAILED;
 752
 753         _D("success sensor_get_min_interval : [%d]", *min_interval);
 754
 755         return SENSOR_ERROR_NONE;
 756 }
 757
 758 int sensor_get_fifo_count(sensor_h sensor, int *fifo_count)
 759 {
 760         _D("called sensor_get_fifo_count");
 761
 762         if (!sensor || !fifo_count)
 763                 return SENSOR_ERROR_INVALID_PARAMETER;
 764
 765         if (!sensord_get_fifo_count(sensor, fifo_count))
 766                 return SENSOR_ERROR_OPERATION_FAILED;
 767
 768         _D("success sensor_get_fifo_count : [%d]", *fifo_count);
 769
 770         return SENSOR_ERROR_NONE;
 771 }
 772
 773 int sensor_get_max_batch_count(sensor_h sensor, int *max_batch_count)
 774 {
 775         _D("called sensor_get_max_batch_count");
 776
 777         if (!sensor || !max_batch_count)
 778                 return SENSOR_ERROR_INVALID_PARAMETER;
 779
 780         if (!sensord_get_max_batch_count(sensor, max_batch_count))
 781                 return SENSOR_ERROR_OPERATION_FAILED;
 782
 783         _D("success sensor_get_max_batch_count : [%d]", *max_batch_count);
 784
 785         return SENSOR_ERROR_NONE;
 786 }
 787
 788 /*
 789  *      FUNCTIONS : SENSOR_UTIL_*
 790  */
 791
 792 int sensor_util_get_declination(float latitude, float longitude, float altitude, float *declination)
 793 {
 794         if (!declination)
 795                 return SENSOR_ERROR_INVALID_PARAMETER;
 796
 797         setCoordinate(latitude, longitude, altitude, declination, NULL, 1);
 798
 799         return SENSOR_ERROR_NONE;
 800 }
 801
 802 int sensor_util_get_angle_change(float R[], float prevR[], float angleChange[])
 803 {
 804         if (getAngleChange(R, prevR, angleChange) < 0)
 805                 return SENSOR_ERROR_INVALID_PARAMETER;
 806
 807         return SENSOR_ERROR_NONE;
 808 }
 809
 810 int sensor_util_get_orientation(float R[], float values[])
 811 {
 812         if (!R || !values)
 813                 return SENSOR_ERROR_INVALID_PARAMETER;
 814
 815         values[0] = (float) atan2(R[1], R[4]);
 816         values[1] = (float) asin(-R[7]);
 817         values[2] = (float) atan2(-R[6], R[8]);
 818
 819         return SENSOR_ERROR_NONE;
 820 }
 821
 822 int sensor_util_get_inclination(float I[], float* inclination)
 823 {
 824         if (!I || !inclination)
 825                 return SENSOR_ERROR_INVALID_PARAMETER;
 826
 827         *inclination = atan2(I[5], I[4]);
 828
 829         return SENSOR_ERROR_NONE;
 830 }
 831
 832 int sensor_util_remap_coordinate_system(float inR[], sensor_util_axis_e x, sensor_util_axis_e y, float outR[])
 833 {
 834         if (remapCoordinateSystem(inR, CONVERT_AXIS_ENUM(x), CONVERT_AXIS_ENUM(y), outR) < 0)
 835                 return SENSOR_ERROR_INVALID_PARAMETER;
 836
 837         return SENSOR_ERROR_NONE;
 838 }
 839
 840 int sensor_util_get_rotation_matrix_from_vector(float Vx, float Vy, float Vz, float R[])
 841 {
 842         float RV[4] = {0, Vx, Vy, Vz};
 843
 844         RV[0] = 1 - Vx * Vx - Vy * Vy - Vz * Vz;
 845         RV[0] = (Vx > 0) ? (float) (sqrt(Vx)) : 0;
 846
 847         if (quatToMatrix(RV, R) < 0)
 848                 return SENSOR_ERROR_INVALID_PARAMETER;
 849
 850         return SENSOR_ERROR_NONE;
 851 }
 852
 853 int sensor_util_get_rotation_matrix(float Gx, float Gy, float Gz, float Mx, float My, float Mz, float R[], float I[])
 854 {
 855         float G[3] = {Gx, Gy, Gz};
 856         float M[3] = {Mx, My, Mz};
 857
 858         if (getRotationMatrix(G, M, R, I) < 0)
 859                 return SENSOR_ERROR_INVALID_PARAMETER;
 860
 861         return SENSOR_ERROR_NONE;
 862 }
 863