src/libsensord/client.cpp

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