src/client/client.cpp

   1 /*
   2  * sensord
   3  *
   4  * Copyright (c) 2013 Samsung Electronics Co., Ltd.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  * http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  */
  19
  20 #include <sensor_common.h>
  21 #include <sensor_internal_deprecated.h>
  22 #include <sensor_internal.h>
  23 #include <sensor_event_listener.h>
  24 #include <sensor_client_info.h>
  25 #include <client_common.h>
  26 #include <vconf.h>
  27 #include <cmutex.h>
  28 #include <sensor_log.h>
  29 #include <sensor_info.h>
  30 #include <sensor_info_manager.h>
  31 #include <vector>
  32 #include <algorithm>
  33 #include "dbus_listener.h"
  34
  35 using std::vector;
  36
  37 #ifndef API
  38 #define API __attribute__((visibility("default")))
  39 #endif
  40
  41 #define DEFAULT_INTERVAL POLL_10HZ_MS
  42
  43 static cmutex lock;
  44
  45 static int g_power_save_state = 0;
  46
  47 static int get_power_save_state(void);
  48 static void power_save_state_cb(keynode_t *node, void *data);
  49 static void clean_up(void);
  50 static bool change_sensor_rep(sensor_id_t sensor_id, sensor_rep &prev_rep, sensor_rep &cur_rep);
  51 static void restore_session(void);
  52 static bool register_event(int handle, unsigned int event_type, unsigned int interval, int max_batch_latency, void* cb, void *user_data);
  53
  54 class initiator {
  55 public:
  56         initiator()
  57         {
  58                 sensor_event_listener::get_instance().set_hup_observer(restore_session);
  59         }
  60 };
  61
  62 void good_bye(void)
  63 {
  64         _I("Good bye! %s\n", get_client_name());
  65         clean_up();
  66 }
  67
  68 static initiator g_initiator;
  69
  70 static int g_power_save_state_cb_cnt = 0;
  71
  72 static void set_power_save_state_cb(void)
  73 {
  74         if (g_power_save_state_cb_cnt < 0)
  75                 _E("g_power_save_state_cb_cnt(%d) is wrong", g_power_save_state_cb_cnt);
  76
  77         ++g_power_save_state_cb_cnt;
  78
  79         if (g_power_save_state_cb_cnt == 1) {
  80                 _D("Power save callback is registered");
  81                 g_power_save_state = get_power_save_state();
  82                 _D("power_save_state = [%d]", g_power_save_state);
  83                 vconf_notify_key_changed(VCONFKEY_PM_STATE, power_save_state_cb, NULL);
  84         }
  85 }
  86
  87 static void unset_power_save_state_cb(void)
  88 {
  89         --g_power_save_state_cb_cnt;
  90
  91         if (g_power_save_state_cb_cnt < 0)
  92                 _E("g_power_save_state_cb_cnt(%d) is wrong", g_power_save_state_cb_cnt);
  93
  94         if (g_power_save_state_cb_cnt == 0) {
  95                 _D("Power save callback is unregistered");
  96                 vconf_ignore_key_changed(VCONFKEY_PM_STATE, power_save_state_cb);
  97         }
  98 }
  99
 100 void clean_up(void)
 101 {
 102         handle_vector handles;
 103
 104         sensor_client_info::get_instance().get_all_handles(handles);
 105
 106         auto it_handle = handles.begin();
 107
 108         while (it_handle != handles.end()) {
 109                 sensord_disconnect(*it_handle);
 110                 ++it_handle;
 111         }
 112 }
 113
 114 static int get_power_save_state(void)
 115 {
 116         int state = 0;
 117         int pm_state;
 118
 119         vconf_get_int(VCONFKEY_PM_STATE, &pm_state);
 120
 121         if (pm_state == VCONFKEY_PM_STATE_LCDOFF)
 122                 state |= SENSOR_OPTION_ON_IN_SCREEN_OFF;
 123
 124         return state;
 125 }
 126
 127 static void power_save_state_cb(keynode_t *node, void *data)
 128 {
 129         int cur_power_save_state;
 130         sensor_id_vector sensors;
 131         sensor_rep prev_rep, cur_rep;
 132
 133         AUTOLOCK(lock);
 134
 135         cur_power_save_state = get_power_save_state();
 136
 137         if (cur_power_save_state == g_power_save_state) {
 138                 _D("g_power_save_state NOT changed : [%d]", cur_power_save_state);
 139                 return;
 140         }
 141
 142         g_power_save_state = cur_power_save_state;
 143         _D("power_save_state: %d noti to %s", g_power_save_state, get_client_name());
 144
 145         sensor_client_info::get_instance().get_listening_sensors(sensors);
 146
 147         auto it_sensor = sensors.begin();
 148
 149         while (it_sensor != sensors.end()) {
 150                 sensor_client_info::get_instance().get_sensor_rep(*it_sensor, prev_rep);
 151                 sensor_event_listener::get_instance().operate_sensor(*it_sensor, cur_power_save_state);
 152                 sensor_client_info::get_instance().get_sensor_rep(*it_sensor, cur_rep);
 153                 change_sensor_rep(*it_sensor, prev_rep, cur_rep);
 154
 155                 ++it_sensor;
 156         }
 157 }
 158
 159 void restore_session(void)
 160 {
 161         AUTOLOCK(lock);
 162
 163         _I("Trying to restore sensor client session for %s", get_client_name());
 164
 165         command_channel *cmd_channel;
 166         int client_id;
 167
 168         sensor_client_info::get_instance().close_command_channel();
 169         sensor_client_info::get_instance().set_client_id(CLIENT_ID_INVALID);
 170
 171         sensor_id_vector sensors;
 172
 173         sensor_client_info::get_instance().get_listening_sensors(sensors);
 174
 175         bool first_connection = true;
 176
 177         auto it_sensor = sensors.begin();
 178
 179         while (it_sensor != sensors.end()) {
 180                 cmd_channel = new(std::nothrow) command_channel();
 181                 retm_if(!cmd_channel, "Failed to allocate memory");
 182
 183                 if (!cmd_channel->create_channel()) {
 184                         _E("%s failed to create command channel for %s", get_client_name(), get_sensor_name(*it_sensor));
 185                         delete cmd_channel;
 186                         goto FAILED;
 187                 }
 188
 189                 sensor_client_info::get_instance().add_command_channel(*it_sensor, cmd_channel);
 190
 191                 if (first_connection) {
 192                         first_connection = false;
 193                         if (!cmd_channel->cmd_get_id(client_id)) {
 194                                 _E("Failed to get client id");
 195                                 goto FAILED;
 196                         }
 197
 198                         sensor_client_info::get_instance().set_client_id(client_id);
 199                         sensor_event_listener::get_instance().start_event_listener();
 200                 }
 201
 202                 cmd_channel->set_client_id(client_id);
 203
 204                 if (!cmd_channel->cmd_hello(*it_sensor)) {
 205                         _E("Sending cmd_hello(%s, %d) failed for %s", get_sensor_name(*it_sensor), client_id, get_client_name());
 206                         goto FAILED;
 207                 }
 208
 209                 sensor_rep prev_rep, cur_rep;
 210                 prev_rep.active = false;
 211                 prev_rep.option = SENSOR_OPTION_DEFAULT;
 212                 prev_rep.interval = 0;
 213
 214                 sensor_client_info::get_instance().get_sensor_rep(*it_sensor, cur_rep);
 215                 if (!change_sensor_rep(*it_sensor, prev_rep, cur_rep)) {
 216                         _E("Failed to change rep(%s) for %s", get_sensor_name(*it_sensor), get_client_name());
 217                         goto FAILED;
 218                 }
 219
 220                 ++it_sensor;
 221         }
 222
 223         _I("Succeeded to restore sensor client session for %s", get_client_name());
 224
 225         return;
 226
 227 FAILED:
 228         sensor_event_listener::get_instance().clear();
 229         _E("Failed to restore session for %s", get_client_name());
 230 }
 231
 232 static bool get_events_diff(event_type_vector &a_vec, event_type_vector &b_vec, event_type_vector &add_vec, event_type_vector &del_vec)
 233 {
 234         sort(a_vec.begin(), a_vec.end());
 235         sort(b_vec.begin(), b_vec.end());
 236
 237         set_difference(a_vec.begin(), a_vec.end(), b_vec.begin(), b_vec.end(), back_inserter(del_vec));
 238         set_difference(b_vec.begin(), b_vec.end(), a_vec.begin(), a_vec.end(), back_inserter(add_vec));
 239
 240         return !(add_vec.empty() && del_vec.empty());
 241 }
 242
 243 static bool change_sensor_rep(sensor_id_t sensor_id, sensor_rep &prev_rep, sensor_rep &cur_rep)
 244 {
 245         int client_id;
 246         command_channel *cmd_channel;
 247         event_type_vector add_event_types, del_event_types;
 248
 249         if (!sensor_client_info::get_instance().get_command_channel(sensor_id, &cmd_channel)) {
 250                 _E("client %s failed to get command channel for %s", get_client_name(), get_sensor_name(sensor_id));
 251                 return false;
 252         }
 253
 254         client_id = sensor_client_info::get_instance().get_client_id();
 255         retvm_if((client_id < 0), false, "Invalid client id : %d, %s, %s", client_id, get_sensor_name(sensor_id), get_client_name());
 256
 257         get_events_diff(prev_rep.event_types, cur_rep.event_types, add_event_types, del_event_types);
 258
 259         if (cur_rep.active) {
 260                 if (prev_rep.option != cur_rep.option) {
 261                         if (!cmd_channel->cmd_set_option(cur_rep.option)) {
 262                                 _E("Sending cmd_set_option(%d, %s, %d) failed for %s", client_id, get_sensor_name(sensor_id), cur_rep.option, get_client_name());
 263                                 return false;
 264                         }
 265                 }
 266
 267                 if ( (prev_rep.interval != cur_rep.interval) || (prev_rep.latency != cur_rep.latency)) {
 268                         if (!cmd_channel->cmd_set_batch(cur_rep.interval, cur_rep.latency)) {
 269                                 _E("Sending cmd_set_batch(%d, %s, %d, %d) failed for %s", client_id, get_sensor_name(sensor_id), cur_rep.interval, cur_rep.latency, get_client_name());
 270                                 return false;
 271                         }
 272                 }
 273
 274                 if (!add_event_types.empty()) {
 275                         if (!cmd_channel->cmd_register_events(add_event_types)) {
 276                                 _E("Sending cmd_register_events(%d, add_event_types) failed for %s", client_id, get_client_name());
 277                                 return false;
 278                         }
 279                 }
 280         }
 281
 282         if (prev_rep.active && !del_event_types.empty()) {
 283                 if (!cmd_channel->cmd_unregister_events(del_event_types)) {
 284                         _E("Sending cmd_unregister_events(%d, del_event_types) failed for %s", client_id, get_client_name());
 285                         return false;
 286                 }
 287         }
 288
 289         if (prev_rep.active != cur_rep.active) {
 290                 if (cur_rep.active) {
 291                         if (!cmd_channel->cmd_start()) {
 292                                 _E("Sending cmd_start(%d, %s) failed for %s", client_id, get_sensor_name(sensor_id), get_client_name());
 293                                 return false;
 294                         }
 295                 } else {
 296                         if (!cmd_channel->cmd_unset_batch()) {
 297                                 _E("Sending cmd_unset_interval(%d, %s) failed for %s", client_id, get_sensor_name(sensor_id), get_client_name());
 298                                 return false;
 299                         }
 300
 301                         if (!cmd_channel->cmd_stop()) {
 302                                 _E("Sending cmd_stop(%d, %s) failed for %s", client_id, get_sensor_name(sensor_id), get_client_name());
 303                                 return false;
 304                         }
 305                 }
 306         }
 307
 308         return true;
 309 }
 310
 311 static bool get_sensor_list(void)
 312 {
 313         static cmutex l;
 314         static bool init = false;
 315
 316         AUTOLOCK(l);
 317
 318         if (!init) {
 319                 command_channel cmd_channel;
 320
 321                 if (!cmd_channel.create_channel()) {
 322                         _E("%s failed to create command channel", get_client_name());
 323                         return false;
 324                 }
 325
 326                 if (!cmd_channel.cmd_get_sensor_list())
 327                         return false;
 328
 329                 init = true;
 330         }
 331
 332         return true;
 333 }
 334
 335 API int sensord_get_sensors(sensor_type_t type, sensor_t **list, int *sensor_count)
 336 {
 337         retvm_if(!get_sensor_list(), -EPERM, "Fail to get sensor list from server");
 338
 339         vector<sensor_info *> sensor_infos = sensor_info_manager::get_instance().get_infos(type);
 340
 341         if (sensor_infos.empty()) {
 342                 *sensor_count = 0;
 343                 return -ENODATA;
 344         }
 345
 346         if (type != ALL_SENSOR) {
 347                 if (sensor_infos[0]->get_id() == (sensor_id_t)(-EACCES))
 348                         return -EACCES;
 349         }
 350
 351         *list = (sensor_t *) malloc(sizeof(sensor_info *) * sensor_infos.size());
 352         retvm_if(!*list, false, "Failed to allocate memory");
 353
 354         for (unsigned int i = 0; i < sensor_infos.size(); ++i)
 355                 *(*list + i) = sensor_info_to_sensor(sensor_infos[i]);
 356
 357         *sensor_count = sensor_infos.size();
 358
 359         return OP_SUCCESS;
 360 }
 361
 362 API int sensord_get_default_sensor(sensor_type_t type, sensor_t *sensor)
 363 {
 364         retvm_if(!get_sensor_list(), -EPERM, "Fail to get sensor list from server");
 365
 366         const sensor_info *info;
 367
 368         info = sensor_info_manager::get_instance().get_info(type);
 369         if (info == NULL) {
 370                 *sensor = NULL;
 371                 return -ENODATA;
 372         }
 373
 374         if ((const_cast<sensor_info *>(info))->get_id() == (sensor_id_t)(-EACCES))
 375                 return -EACCES;
 376
 377         *sensor = sensor_info_to_sensor(info);
 378
 379         return OP_SUCCESS;
 380 }
 381
 382 API bool sensord_get_sensor_list(sensor_type_t type, sensor_t **list, int *sensor_count)
 383 {
 384         return (sensord_get_sensors(type, list, sensor_count) == OP_SUCCESS);
 385 }
 386
 387 API sensor_t sensord_get_sensor(sensor_type_t type)
 388 {
 389         sensor_t sensor;
 390         sensord_get_default_sensor(type, &sensor);
 391
 392         return sensor;
 393 }
 394
 395 API bool sensord_get_type(sensor_t sensor, sensor_type_t *type)
 396 {
 397         sensor_info* info = sensor_to_sensor_info(sensor);
 398
 399         retvm_if(!sensor_info_manager::get_instance().is_valid(info) || !type,
 400                 NULL, "Invalid param: sensor (%p), type(%p)", sensor, type);
 401
 402         *type = info->get_type();
 403
 404         return true;
 405 }
 406
 407 API const char* sensord_get_name(sensor_t sensor)
 408 {
 409         sensor_info* info = sensor_to_sensor_info(sensor);
 410
 411         retvm_if(!sensor_info_manager::get_instance().is_valid(info),
 412                 NULL, "Invalid param: sensor (%p)", sensor);
 413
 414         return info->get_name();
 415 }
 416
 417 API const char* sensord_get_vendor(sensor_t sensor)
 418 {
 419         sensor_info* info = sensor_to_sensor_info(sensor);
 420
 421         retvm_if(!sensor_info_manager::get_instance().is_valid(info),
 422                 NULL, "Invalid param: sensor (%p)", sensor);
 423
 424         return info->get_vendor();
 425 }
 426
 427 API bool sensord_get_privilege(sensor_t sensor, sensor_privilege_t *privilege)
 428 {
 429         sensor_info* info = sensor_to_sensor_info(sensor);
 430
 431         retvm_if(!sensor_info_manager::get_instance().is_valid(info) || !privilege,
 432                 false, "Invalid param: sensor (%p), privilege(%p)", sensor, privilege);
 433
 434         *privilege = info->get_privilege();
 435
 436         return true;
 437 }
 438
 439 API bool sensord_get_min_range(sensor_t sensor, float *min_range)
 440 {
 441         sensor_info* info = sensor_to_sensor_info(sensor);
 442
 443         retvm_if(!sensor_info_manager::get_instance().is_valid(info) || !min_range,
 444                 false, "Invalid param: sensor (%p), min_range(%p)", sensor, min_range);
 445
 446         *min_range = info->get_min_range();
 447
 448         return true;
 449 }
 450
 451 API bool sensord_get_max_range(sensor_t sensor, float *max_range)
 452 {
 453         sensor_info* info = sensor_to_sensor_info(sensor);
 454
 455         retvm_if(!sensor_info_manager::get_instance().is_valid(info) || !max_range,
 456                 false, "Invalid param: sensor (%p), max_range(%p)", sensor, max_range);
 457
 458         *max_range = info->get_max_range();
 459
 460         return true;
 461 }
 462
 463 API bool sensord_get_resolution(sensor_t sensor, float *resolution)
 464 {
 465         sensor_info* info = sensor_to_sensor_info(sensor);
 466
 467         retvm_if(!sensor_info_manager::get_instance().is_valid(info) || !resolution,
 468                 false, "Invalid param: sensor (%p), resolution(%p)", sensor, resolution);
 469
 470         *resolution = info->get_resolution();
 471
 472         return true;
 473 }
 474
 475 API bool sensord_get_min_interval(sensor_t sensor, int *min_interval)
 476 {
 477         sensor_info* info = sensor_to_sensor_info(sensor);
 478
 479         retvm_if(!sensor_info_manager::get_instance().is_valid(info) || !min_interval,
 480                 false, "Invalid param: sensor (%p), min_interval(%p)", sensor, min_interval);
 481
 482         *min_interval = info->get_min_interval();
 483
 484         return true;
 485 }
 486
 487 API bool sensord_get_fifo_count(sensor_t sensor, int *fifo_count)
 488 {
 489         sensor_info* info = sensor_to_sensor_info(sensor);
 490
 491         retvm_if(!sensor_info_manager::get_instance().is_valid(info) || !fifo_count,
 492                 false, "Invalid param: sensor (%p), fifo_count(%p)", sensor, fifo_count);
 493
 494         *fifo_count = info->get_fifo_count();
 495
 496         return true;
 497 }
 498
 499 API bool sensord_get_max_batch_count(sensor_t sensor, int *max_batch_count)
 500 {
 501         sensor_info* info = sensor_to_sensor_info(sensor);
 502
 503         retvm_if(!sensor_info_manager::get_instance().is_valid(info) || !max_batch_count,
 504                 false, "Invalid param: sensor (%p), max_batch_count(%p)", sensor, max_batch_count);
 505
 506         *max_batch_count = info->get_max_batch_count();
 507
 508         return true;
 509 }
 510
 511 API bool sensord_get_supported_event_types(sensor_t sensor, unsigned int **event_types, int *count)
 512 {
 513         sensor_info* info = sensor_to_sensor_info(sensor);
 514
 515         retvm_if(!sensor_info_manager::get_instance().is_valid(info) || !event_types || !count,
 516                 false, "Invalid param: sensor (%p), event_types(%p), count(%p)", sensor, event_types, count);
 517
 518         unsigned int event_type;
 519         event_type = info->get_supported_event();
 520         *event_types = (unsigned int *)malloc(sizeof(unsigned int));
 521
 522         retvm_if(!*event_types, false, "Failed to allocate memory");
 523
 524         (*event_types)[0] = event_type;
 525         *count = 1;
 526
 527         return true;
 528 }
 529
 530 API bool sensord_is_supported_event_type(sensor_t sensor, unsigned int event_type, bool *supported)
 531 {
 532         sensor_info* info = sensor_to_sensor_info(sensor);
 533
 534         retvm_if(!sensor_info_manager::get_instance().is_valid(info) || !event_type || !supported,
 535                 false, "Invalid param: sensor (%p), event_type(%p), supported(%p)", sensor, event_type, supported);
 536
 537         *supported = info->is_supported_event(event_type);
 538
 539         return true;
 540 }
 541
 542 API bool sensord_is_wakeup_supported(sensor_t sensor)
 543 {
 544         sensor_info* info = sensor_to_sensor_info(sensor);
 545
 546         retvm_if(!sensor_info_manager::get_instance().is_valid(info),
 547                 false, "Invalid param: sensor (%p)", sensor);
 548
 549         return info->is_wakeup_supported();
 550 }
 551
 552 API int sensord_connect(sensor_t sensor)
 553 {
 554         command_channel *cmd_channel = NULL;
 555         int handle;
 556         int client_id;
 557         bool sensor_registered;
 558         bool first_connection = false;
 559
 560         sensor_info* info = sensor_to_sensor_info(sensor);
 561
 562         retvm_if(!sensor_info_manager::get_instance().is_valid(info),
 563                 OP_ERROR, "Invalid param: sensor (%p)", sensor);
 564
 565         sensor_id_t sensor_id = info->get_id();
 566
 567         AUTOLOCK(lock);
 568
 569         sensor_registered = sensor_client_info::get_instance().is_sensor_registered(sensor_id);
 570
 571         // lazy loading after creating static variables
 572         atexit(good_bye);
 573
 574         handle = sensor_client_info::get_instance().create_handle(sensor_id);
 575         if (handle == MAX_HANDLE) {
 576                 _E("Maximum number of handles reached, sensor: %s in client %s", get_sensor_name(sensor_id), get_client_name());
 577                 return OP_ERROR;
 578         }
 579
 580         if (!sensor_registered) {
 581                 cmd_channel = new(std::nothrow) command_channel();
 582                 if (!cmd_channel) {
 583                         _E("Failed to allocated memory");
 584                         sensor_client_info::get_instance().delete_handle(handle);
 585                         return OP_ERROR;
 586                 }
 587
 588                 if (!cmd_channel->create_channel()) {
 589                         _E("%s failed to create command channel for %s", get_client_name(), get_sensor_name(sensor_id));
 590                         sensor_client_info::get_instance().delete_handle(handle);
 591                         delete cmd_channel;
 592                         return OP_ERROR;
 593                 }
 594
 595                 sensor_client_info::get_instance().add_command_channel(sensor_id, cmd_channel);
 596         }
 597
 598         if (!sensor_client_info::get_instance().get_command_channel(sensor_id, &cmd_channel)) {
 599                 _E("%s failed to get command channel for %s", get_client_name(), get_sensor_name(sensor_id));
 600                 sensor_client_info::get_instance().delete_handle(handle);
 601                 return OP_ERROR;
 602         }
 603
 604         if (!sensor_client_info::get_instance().has_client_id()) {
 605                 first_connection = true;
 606                 if (!cmd_channel->cmd_get_id(client_id)) {
 607                         _E("Sending cmd_get_id() failed for %s", get_sensor_name(sensor_id));
 608                         sensor_client_info::get_instance().close_command_channel(sensor_id);
 609                         sensor_client_info::get_instance().delete_handle(handle);
 610                         return OP_ERROR;
 611                 }
 612
 613                 sensor_client_info::get_instance().set_client_id(client_id);
 614                 _I("%s gets client_id [%d]", get_client_name(), client_id);
 615                 sensor_event_listener::get_instance().start_event_listener();
 616                 _I("%s starts listening events with client_id [%d]", get_client_name(), client_id);
 617         }
 618
 619         client_id = sensor_client_info::get_instance().get_client_id();
 620         cmd_channel->set_client_id(client_id);
 621
 622         _I("%s[%d] connects with %s[%d]", get_client_name(), client_id, get_sensor_name(sensor_id), handle);
 623
 624         sensor_client_info::get_instance().set_sensor_params(handle, SENSOR_STATE_STOPPED, SENSOR_OPTION_DEFAULT);
 625
 626         if (!sensor_registered) {
 627                 if (!cmd_channel->cmd_hello(sensor_id)) {
 628                         _E("Sending cmd_hello(%s, %d) failed for %s", get_sensor_name(sensor_id), client_id, get_client_name());
 629                         sensor_client_info::get_instance().close_command_channel(sensor_id);
 630                         sensor_client_info::get_instance().delete_handle(handle);
 631                         if (first_connection) {
 632                                 sensor_client_info::get_instance().set_client_id(CLIENT_ID_INVALID);
 633                                 sensor_event_listener::get_instance().stop_event_listener();
 634                         }
 635                         return OP_ERROR;
 636                 }
 637         }
 638
 639         set_power_save_state_cb();
 640         dbus_listener::init();
 641         return handle;
 642 }
 643
 644 API bool sensord_disconnect(int handle)
 645 {
 646         command_channel *cmd_channel;
 647         sensor_id_t sensor_id;
 648         int client_id;
 649         int sensor_state;
 650
 651         AUTOLOCK(lock);
 652
 653         if (!sensor_client_info::get_instance().get_sensor_state(handle, sensor_state)||
 654                 !sensor_client_info::get_instance().get_sensor_id(handle, sensor_id)) {
 655                 _E("client %s failed to get handle information", get_client_name());
 656                 return false;
 657         }
 658
 659         if (!sensor_client_info::get_instance().get_command_channel(sensor_id, &cmd_channel)) {
 660                 _E("client %s failed to get command channel for %s", get_client_name(), get_sensor_name(sensor_id));
 661                 return false;
 662         }
 663
 664         client_id = sensor_client_info::get_instance().get_client_id();
 665         retvm_if((client_id < 0), false, "Invalid client id : %d, handle: %d, %s, %s", client_id, handle, get_sensor_name(sensor_id), get_client_name());
 666
 667         _I("%s disconnects with %s[%d]", get_client_name(), get_sensor_name(sensor_id), handle);
 668
 669         if (sensor_state != SENSOR_STATE_STOPPED) {
 670                 _W("%s[%d] for %s is not stopped before disconnecting.",
 671                         get_sensor_name(sensor_id), handle, get_client_name());
 672                 sensord_stop(handle);
 673         }
 674
 675         if (!sensor_client_info::get_instance().delete_handle(handle))
 676                 return false;
 677
 678         if (!sensor_client_info::get_instance().is_active())
 679                 sensor_client_info::get_instance().set_client_id(CLIENT_ID_INVALID);
 680
 681         if (!sensor_client_info::get_instance().is_sensor_registered(sensor_id)) {
 682                 if (!cmd_channel->cmd_byebye()) {
 683                         _E("Sending cmd_byebye(%d, %s) failed for %s", client_id, get_sensor_name(sensor_id), get_client_name());
 684                         return false;
 685                 }
 686                 sensor_client_info::get_instance().close_command_channel(sensor_id);
 687         }
 688
 689         if (!sensor_client_info::get_instance().is_active()) {
 690                 _I("Stop listening events for client %s with client id [%d]", get_client_name(), sensor_client_info::get_instance().get_client_id());
 691                 sensor_event_listener::get_instance().stop_event_listener();
 692         }
 693
 694         unset_power_save_state_cb();
 695
 696         return true;
 697 }
 698
 699 static bool register_event(int handle, unsigned int event_type, unsigned int interval, int max_batch_latency, void* cb, void *user_data)
 700 {
 701         sensor_id_t sensor_id;
 702         sensor_rep prev_rep, cur_rep;
 703         bool ret;
 704
 705         retvm_if(!cb, false, "callback is NULL");
 706
 707         AUTOLOCK(lock);
 708
 709         if (!sensor_client_info::get_instance().get_sensor_id(handle, sensor_id)) {
 710                 _E("client %s failed to get handle information", get_client_name());
 711                 return false;
 712         }
 713
 714         if (interval == 0)
 715                 interval = DEFAULT_INTERVAL;
 716
 717         _I("%s registers event %s[%#x] for sensor %s[%d] with interval: %d, latency: %d,  cb: %#x, user_data: %#x",
 718                 get_client_name(), get_event_name(event_type), event_type, get_sensor_name(sensor_id),
 719                 handle, interval, max_batch_latency, cb, user_data);
 720
 721         sensor_client_info::get_instance().get_sensor_rep(sensor_id, prev_rep);
 722         sensor_client_info::get_instance().register_event(handle, event_type, interval, max_batch_latency, cb, user_data);
 723         sensor_client_info::get_instance().get_sensor_rep(sensor_id, cur_rep);
 724         ret = change_sensor_rep(sensor_id, prev_rep, cur_rep);
 725
 726         if (!ret)
 727                 sensor_client_info::get_instance().unregister_event(handle, event_type);
 728
 729         return ret;
 730 }
 731
 732 API bool sensord_register_event(int handle, unsigned int event_type, unsigned int interval, unsigned int max_batch_latency, sensor_cb_t cb, void *user_data)
 733 {
 734         return register_event(handle, event_type, interval, max_batch_latency, (void *)cb, user_data);
 735 }
 736
 737 API bool sensord_unregister_event(int handle, unsigned int event_type)
 738 {
 739         sensor_id_t sensor_id;
 740         sensor_rep prev_rep, cur_rep;
 741         bool ret;
 742         unsigned int prev_interval, prev_latency;
 743         void *prev_cb;
 744         void *prev_user_data;
 745
 746         AUTOLOCK(lock);
 747
 748         if (!sensor_client_info::get_instance().get_sensor_id(handle, sensor_id)) {
 749                 _E("client %s failed to get handle information", get_client_name());
 750                 return false;
 751         }
 752
 753         _I("%s unregisters event %s[%#x] for sensor %s[%d]", get_client_name(), get_event_name(event_type),
 754                 event_type, get_sensor_name(sensor_id), handle);
 755
 756         sensor_client_info::get_instance().get_sensor_rep(sensor_id, prev_rep);
 757         sensor_client_info::get_instance().get_event_info(handle, event_type, prev_interval, prev_latency, prev_cb, prev_user_data);
 758
 759         if (!sensor_client_info::get_instance().unregister_event(handle, event_type)) {
 760                 _E("%s try to unregister non registered event %s[%#x] for sensor %s[%d]",
 761                         get_client_name(), get_event_name(event_type), event_type, get_sensor_name(sensor_id), handle);
 762                 return false;
 763         }
 764
 765         sensor_client_info::get_instance().get_sensor_rep(sensor_id, cur_rep);
 766         ret =  change_sensor_rep(sensor_id, prev_rep, cur_rep);
 767
 768         if (!ret)
 769                 sensor_client_info::get_instance().register_event(handle, event_type, prev_interval, prev_latency, prev_cb, prev_user_data);
 770
 771         return ret;
 772 }
 773
 774 API bool sensord_register_accuracy_cb(int handle, sensor_accuracy_changed_cb_t cb, void *user_data)
 775 {
 776         sensor_id_t sensor_id;
 777
 778         retvm_if(!cb, false, "callback is NULL");
 779
 780         AUTOLOCK(lock);
 781
 782         if (!sensor_client_info::get_instance().get_sensor_id(handle, sensor_id)) {
 783                 _E("client %s failed to get handle information", get_client_name());
 784                 return false;
 785         }
 786
 787         _I("%s registers accuracy_changed_cb for sensor %s[%d] with cb: %#x, user_data: %#x",
 788                 get_client_name(), get_sensor_name(sensor_id), handle, cb, user_data);
 789
 790         sensor_client_info::get_instance().register_accuracy_cb(handle, cb , user_data);
 791
 792         return true;
 793 }
 794
 795 API bool sensord_unregister_accuracy_cb(int handle)
 796 {
 797         sensor_id_t sensor_id;
 798
 799         AUTOLOCK(lock);
 800
 801         if (!sensor_client_info::get_instance().get_sensor_id(handle, sensor_id)) {
 802                 _E("client %s failed to get handle information", get_client_name());
 803                 return false;
 804         }
 805
 806         _I("%s unregisters accuracy_changed_cb for sensor %s[%d]",
 807                 get_client_name(), get_sensor_name(sensor_id), handle);
 808
 809         sensor_client_info::get_instance().unregister_accuracy_cb(handle);
 810
 811         return true;
 812 }
 813
 814 API bool sensord_start(int handle, int option)
 815 {
 816         sensor_id_t sensor_id;
 817         sensor_rep prev_rep, cur_rep;
 818         bool ret;
 819         int prev_state, prev_option;
 820
 821         AUTOLOCK(lock);
 822
 823         if (!sensor_client_info::get_instance().get_sensor_id(handle, sensor_id)) {
 824                 _E("client %s failed to get handle information", get_client_name());
 825                 return false;
 826         }
 827
 828         retvm_if((option < 0) || (option >= SENSOR_OPTION_END), false, "Invalid option value : %d, handle: %d, %s, %s",
 829                 option, handle, get_sensor_name(sensor_id), get_client_name());
 830
 831         _I("%s starts %s[%d], with option: %d, power save state: %d", get_client_name(), get_sensor_name(sensor_id),
 832                 handle, option, g_power_save_state);
 833
 834         if (g_power_save_state && !(g_power_save_state & option)) {
 835                 sensor_client_info::get_instance().set_sensor_params(handle, SENSOR_STATE_PAUSED, option);
 836                 return true;
 837         }
 838
 839         sensor_client_info::get_instance().get_sensor_rep(sensor_id, prev_rep);
 840         sensor_client_info::get_instance().get_sensor_params(handle, prev_state, prev_option);
 841         sensor_client_info::get_instance().set_sensor_params(handle, SENSOR_STATE_STARTED, option);
 842         sensor_client_info::get_instance().get_sensor_rep(sensor_id, cur_rep);
 843
 844         ret = change_sensor_rep(sensor_id, prev_rep, cur_rep);
 845
 846         if (!ret)
 847                 sensor_client_info::get_instance().set_sensor_params(handle, prev_state, prev_option);
 848
 849         return ret;
 850 }
 851
 852 API bool sensord_stop(int handle)
 853 {
 854         sensor_id_t sensor_id;
 855         int sensor_state;
 856         bool ret;
 857         int prev_state, prev_option;
 858
 859         sensor_rep prev_rep, cur_rep;
 860
 861         AUTOLOCK(lock);
 862
 863         if (!sensor_client_info::get_instance().get_sensor_state(handle, sensor_state)||
 864                 !sensor_client_info::get_instance().get_sensor_id(handle, sensor_id)) {
 865                 _E("client %s failed to get handle information", get_client_name());
 866                 return false;
 867         }
 868
 869         retvm_if((sensor_state == SENSOR_STATE_STOPPED), true, "%s already stopped with %s[%d]",
 870                 get_client_name(), get_sensor_name(sensor_id), handle);
 871
 872         _I("%s stops sensor %s[%d]", get_client_name(), get_sensor_name(sensor_id), handle);
 873
 874         sensor_client_info::get_instance().get_sensor_rep(sensor_id, prev_rep);
 875         sensor_client_info::get_instance().get_sensor_params(handle, prev_state, prev_option);
 876         sensor_client_info::get_instance().set_sensor_state(handle, SENSOR_STATE_STOPPED);
 877         sensor_client_info::get_instance().get_sensor_rep(sensor_id, cur_rep);
 878
 879         ret = change_sensor_rep(sensor_id, prev_rep, cur_rep);
 880
 881         if (!ret)
 882                 sensor_client_info::get_instance().set_sensor_params(handle, prev_state, prev_option);
 883
 884         return ret;
 885 }
 886
 887 static bool change_event_batch(int handle, unsigned int event_type, unsigned int interval, unsigned int latency)
 888 {
 889         sensor_id_t sensor_id;
 890         sensor_rep prev_rep, cur_rep;
 891         bool ret;
 892         unsigned int prev_interval, prev_latency;
 893         void *prev_cb;
 894         void *prev_user_data;
 895
 896         AUTOLOCK(lock);
 897
 898         if (!sensor_client_info::get_instance().get_sensor_id(handle, sensor_id)) {
 899                 _E("client %s failed to get handle information", get_client_name());
 900                 return false;
 901         }
 902
 903         if (interval == 0)
 904                 interval = DEFAULT_INTERVAL;
 905
 906         _I("%s changes batch of event %s[%#x] for %s[%d] to (%d, %d)", get_client_name(), get_event_name(event_type),
 907                         event_type, get_sensor_name(sensor_id), handle, interval, latency);
 908
 909         sensor_client_info::get_instance().get_sensor_rep(sensor_id, prev_rep);
 910
 911         sensor_client_info::get_instance().get_event_info(handle, event_type, prev_interval, prev_latency, prev_cb, prev_user_data);
 912
 913         if (!sensor_client_info::get_instance().set_event_batch(handle, event_type, interval, latency))
 914                 return false;
 915
 916         sensor_client_info::get_instance().get_sensor_rep(sensor_id, cur_rep);
 917
 918         ret = change_sensor_rep(sensor_id, prev_rep, cur_rep);
 919
 920         if (!ret)
 921                 sensor_client_info::get_instance().set_event_batch(handle, event_type, prev_interval, prev_latency);
 922
 923         return ret;
 924 }
 925
 926 API bool sensord_change_event_interval(int handle, unsigned int event_type, unsigned int interval)
 927 {
 928         unsigned int prev_interval, prev_latency;
 929         void *prev_cb;
 930         void *prev_user_data;
 931
 932         AUTOLOCK(lock);
 933
 934         if (!sensor_client_info::get_instance().get_event_info(handle, event_type, prev_interval, prev_latency, prev_cb, prev_user_data)) {
 935                 _E("Failed to get event info with handle = %d, event_type = %#x", handle, event_type);
 936                 return false;
 937         }
 938
 939         _I("handle = %d, event_type = %#x, interval = %d, prev_latency = %d", handle, event_type, interval, prev_latency);
 940         return change_event_batch(handle, event_type, interval, prev_latency);
 941 }
 942
 943 API bool sensord_change_event_max_batch_latency(int handle, unsigned int event_type, unsigned int max_batch_latency)
 944 {
 945         unsigned int prev_interval, prev_latency;
 946         void *prev_cb;
 947         void *prev_user_data;
 948
 949         AUTOLOCK(lock);
 950
 951         if (!sensor_client_info::get_instance().get_event_info(handle, event_type, prev_interval, prev_latency, prev_cb, prev_user_data)) {
 952                 _E("Failed to get event info with handle = %d, event_type = %#x", handle, event_type);
 953                 return false;
 954         }
 955
 956         return change_event_batch(handle, event_type, prev_interval, max_batch_latency);
 957 }
 958
 959 API bool sensord_set_option(int handle, int option)
 960 {
 961         sensor_id_t sensor_id;
 962         sensor_rep prev_rep, cur_rep;
 963         int sensor_state;
 964         bool ret;
 965         int prev_state, prev_option;
 966
 967         AUTOLOCK(lock);
 968
 969         if (!sensor_client_info::get_instance().get_sensor_state(handle, sensor_state)||
 970                 !sensor_client_info::get_instance().get_sensor_id(handle, sensor_id)) {
 971                 _E("client %s failed to get handle information", get_client_name());
 972                 return false;
 973         }
 974
 975         retvm_if((option < 0) || (option >= SENSOR_OPTION_END), false, "Invalid option value : %d, handle: %d, %s, %s",
 976                 option, handle, get_sensor_name(sensor_id), get_client_name());
 977
 978         sensor_client_info::get_instance().get_sensor_rep(sensor_id, prev_rep);
 979         sensor_client_info::get_instance().get_sensor_params(handle, prev_state, prev_option);
 980
 981         if (g_power_save_state) {
 982                 if ((option & g_power_save_state) && (sensor_state == SENSOR_STATE_PAUSED))
 983                         sensor_client_info::get_instance().set_sensor_state(handle, SENSOR_STATE_STARTED);
 984                 else if (!(option & g_power_save_state) && (sensor_state == SENSOR_STATE_STARTED))
 985                         sensor_client_info::get_instance().set_sensor_state(handle, SENSOR_STATE_PAUSED);
 986         }
 987         sensor_client_info::get_instance().set_sensor_option(handle, option);
 988
 989         sensor_client_info::get_instance().get_sensor_rep(sensor_id, cur_rep);
 990         ret =  change_sensor_rep(sensor_id, prev_rep, cur_rep);
 991
 992         if (!ret)
 993                 sensor_client_info::get_instance().set_sensor_option(handle, prev_option);
 994
 995         return ret;
 996 }
 997
 998 API int sensord_set_attribute_int(int handle, int attribute, int value)
 999 {
1000         sensor_id_t sensor_id;
1001         command_channel *cmd_channel;
1002         int client_id;
1003
1004         AUTOLOCK(lock);
1005
1006         if (!sensor_client_info::get_instance().get_sensor_id(handle, sensor_id)) {
1007                 _E("client %s failed to get handle information", get_client_name());
1008                 return -EINVAL;
1009         }
1010
1011         if (!sensor_client_info::get_instance().get_command_channel(sensor_id, &cmd_channel)) {
1012                 _E("client %s failed to get command channel for %s", get_client_name(), get_sensor_name(sensor_id));
1013                 return -EPERM;
1014         }
1015
1016         client_id = sensor_client_info::get_instance().get_client_id();
1017         retvm_if((client_id < 0), -EPERM,
1018                         "Invalid client id : %d, handle: %d, %s, %s",
1019                         client_id, handle, get_sensor_name(sensor_id), get_client_name());
1020
1021         if (!cmd_channel->cmd_set_attribute_int(attribute, value)) {
1022                 _E("Sending cmd_set_attribute_int(%d, %d) failed for %s",
1023                         client_id, value, get_client_name());
1024                 return -EPERM;
1025         }
1026
1027         return OP_SUCCESS;
1028 }
1029
1030 API int sensord_set_attribute_str(int handle, int attribute, const char *value, int value_len)
1031 {
1032         sensor_id_t sensor_id;
1033         command_channel *cmd_channel;
1034         int client_id;
1035
1036         AUTOLOCK(lock);
1037
1038         if (!sensor_client_info::get_instance().get_sensor_id(handle, sensor_id)) {
1039                 _E("Client %s failed to get handle information", get_client_name());
1040                 return -EINVAL;
1041         }
1042
1043         if (!sensor_client_info::get_instance().get_command_channel(sensor_id, &cmd_channel)) {
1044                 _E("Client %s failed to get command channel for %s",
1045                         get_client_name(), get_sensor_name(sensor_id));
1046                 return -EPERM;
1047         }
1048
1049         retvm_if((value_len < 0) || (value == NULL), -EINVAL,
1050                         "Invalid value_len: %d, value: %#x, handle: %d, %s, %s",
1051                         value_len, value, handle, get_sensor_name(sensor_id), get_client_name());
1052
1053         client_id = sensor_client_info::get_instance().get_client_id();
1054         retvm_if((client_id < 0), -EPERM,
1055                         "Invalid client id : %d, handle: %d, %s, %s",
1056                         client_id, handle, get_sensor_name(sensor_id), get_client_name());
1057
1058         if (!cmd_channel->cmd_set_attribute_str(attribute, value, value_len)) {
1059                 _E("Sending cmd_set_attribute_str(%d, %d, %#x) failed for %s",
1060                         client_id, value_len, value, get_client_name());
1061                 return -EPERM;
1062         }
1063
1064         return OP_SUCCESS;
1065 }
1066
1067 API bool sensord_send_sensorhub_data(int handle, const char *data, int data_len)
1068 {
1069         return (sensord_set_attribute_str(handle, 0, data, data_len) == OP_SUCCESS);
1070 }
1071
1072 API bool sensord_send_command(int handle, const char *command, int command_len)
1073 {
1074         return (sensord_set_attribute_str(handle, 0, command, command_len) == OP_SUCCESS);
1075 }
1076
1077 API bool sensord_get_data(int handle, unsigned int data_id, sensor_data_t* sensor_data)
1078 {
1079         sensor_id_t sensor_id;
1080         command_channel *cmd_channel;
1081         int sensor_state;
1082         int client_id;
1083
1084         retvm_if((!sensor_data), false, "sensor_data is NULL");
1085
1086         AUTOLOCK(lock);
1087
1088         if (!sensor_client_info::get_instance().get_sensor_state(handle, sensor_state)||
1089                 !sensor_client_info::get_instance().get_sensor_id(handle, sensor_id)) {
1090                 _E("client %s failed to get handle information", get_client_name());
1091                 return false;
1092         }
1093
1094         if (!sensor_client_info::get_instance().get_command_channel(sensor_id, &cmd_channel)) {
1095                 _E("client %s failed to get command channel for %s", get_client_name(), get_sensor_name(sensor_id));
1096                 return false;
1097         }
1098
1099         client_id = sensor_client_info::get_instance().get_client_id();
1100         retvm_if((client_id < 0), false, "Invalid client id : %d, handle: %d, %s, %s", client_id, handle, get_sensor_name(sensor_id), get_client_name());
1101
1102         if (sensor_state != SENSOR_STATE_STARTED) {
1103                 _E("Sensor %s is not started for client %s with handle: %d, sensor_state: %d", get_sensor_name(sensor_id), get_client_name(), handle, sensor_state);
1104                 return false;
1105         }
1106
1107         if (!cmd_channel->cmd_get_data(data_id, sensor_data)) {
1108                 _E("cmd_get_data(%d, %d, %#x) failed for %s", client_id, data_id, sensor_data, get_client_name());
1109                 return false;
1110         }
1111
1112         return true;
1113 }
1114
1115 API bool sensord_flush(int handle)
1116 {
1117         sensor_id_t sensor_id;
1118         command_channel *cmd_channel;
1119         int sensor_state;
1120         int client_id;
1121
1122         AUTOLOCK(lock);
1123
1124         if (!sensor_client_info::get_instance().get_sensor_state(handle, sensor_state) ||
1125                 !sensor_client_info::get_instance().get_sensor_id(handle, sensor_id)) {
1126                 _E("client %s failed to get handle information", get_client_name());
1127                 return false;
1128         }
1129
1130         if (!sensor_client_info::get_instance().get_command_channel(sensor_id, &cmd_channel)) {
1131                 _E("client %s failed to get command channel for %s", get_client_name(), get_sensor_name(sensor_id));
1132                 return false;
1133         }
1134
1135         client_id = sensor_client_info::get_instance().get_client_id();
1136         retvm_if((client_id < 0), false, "Invalid client id : %d, handle: %d, %s, %s", client_id, handle, get_sensor_name(sensor_id), get_client_name());
1137
1138         if (sensor_state != SENSOR_STATE_STARTED) {
1139                 _E("Sensor %s is not started for client %s with handle: %d, sensor_state: %d", get_sensor_name(sensor_id), get_client_name(), handle, sensor_state);
1140                 return false;
1141         }
1142
1143         if (!cmd_channel->cmd_flush()) {
1144                 _E("cmd_flush() failed for %s", get_client_name());
1145                 return false;
1146         }
1147
1148         return true;
1149 }
1150
1151 API bool sensord_register_hub_event(int handle, unsigned int event_type, unsigned int interval, unsigned int max_batch_latency, sensorhub_cb_t cb, void *user_data)
1152 {
1153         return false;
1154 }
1155