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