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
 436         if (!sensor_infos.empty()) {
 437                 *list = (sensor_t *) malloc(sizeof(sensor_info *) * sensor_infos.size());
 438                 retvm_if(!*list, false, "Failed to allocate memory");
 439         }
 440
 441         for (int i = 0; i < sensor_infos.size(); ++i)
 442                 *(*list + i) = sensor_info_to_sensor(sensor_infos[i]);
 443
 444         *sensor_count = sensor_infos.size();
 445
 446         return true;
 447 }
 448
 449 API sensor_t sensord_get_sensor(sensor_type_t type)
 450 {
 451         retvm_if (!get_sensor_list(), NULL, "Fail to get sensor list from server");
 452
 453         const sensor_info *info;
 454
 455         info = sensor_info_manager::get_instance().get_info(type);
 456
 457         return sensor_info_to_sensor(info);
 458 }
 459
 460 API bool sensord_get_type(sensor_t sensor, sensor_type_t *type)
 461 {
 462         sensor_info* info = sensor_to_sensor_info(sensor);
 463
 464         retvm_if (!sensor_info_manager::get_instance().is_valid(info) || !type,
 465                 NULL, "Invalid param: sensor (%p), type(%p)", sensor, type);
 466
 467         *type = info->get_type();
 468
 469         return true;
 470 }
 471
 472 API const char* sensord_get_name(sensor_t sensor)
 473 {
 474         sensor_info* info = sensor_to_sensor_info(sensor);
 475
 476         retvm_if (!sensor_info_manager::get_instance().is_valid(info),
 477                 NULL, "Invalid param: sensor (%p)", sensor);
 478
 479         return info->get_name();
 480 }
 481
 482 API const char* sensord_get_vendor(sensor_t sensor)
 483 {
 484         sensor_info* info = sensor_to_sensor_info(sensor);
 485
 486         retvm_if (!sensor_info_manager::get_instance().is_valid(info),
 487                 NULL, "Invalid param: sensor (%p)", sensor);
 488
 489         return info->get_vendor();
 490 }
 491
 492 API bool sensord_get_privilege(sensor_t sensor, sensor_privilege_t *privilege)
 493 {
 494         sensor_info* info = sensor_to_sensor_info(sensor);
 495
 496         retvm_if (!sensor_info_manager::get_instance().is_valid(info) || !privilege,
 497                 false, "Invalid param: sensor (%p), privilege(%p)", sensor, privilege);
 498
 499         *privilege = info->get_privilege();
 500
 501         return true;
 502 }
 503
 504 API bool sensord_get_min_range(sensor_t sensor, float *min_range)
 505 {
 506         sensor_info* info = sensor_to_sensor_info(sensor);
 507
 508         retvm_if (!sensor_info_manager::get_instance().is_valid(info) || !min_range,
 509                 false, "Invalid param: sensor (%p), min_range(%p)", sensor, min_range);
 510
 511         *min_range = info->get_min_range();
 512
 513         return true;
 514 }
 515
 516 API bool sensord_get_max_range(sensor_t sensor, float *max_range)
 517 {
 518         sensor_info* info = sensor_to_sensor_info(sensor);
 519
 520         retvm_if (!sensor_info_manager::get_instance().is_valid(info) || !max_range,
 521                 false, "Invalid param: sensor (%p), max_range(%p)", sensor, max_range);
 522
 523         *max_range = info->get_max_range();
 524
 525         return true;
 526 }
 527
 528 API bool sensord_get_resolution(sensor_t sensor, float *resolution)
 529 {
 530         sensor_info* info = sensor_to_sensor_info(sensor);
 531
 532         retvm_if (!sensor_info_manager::get_instance().is_valid(info) || !resolution,
 533                 false, "Invalid param: sensor (%p), resolution(%p)", sensor, resolution);
 534
 535         *resolution = info->get_resolution();
 536
 537         return true;
 538 }
 539
 540 API bool sensord_get_min_interval(sensor_t sensor, int *min_interval)
 541 {
 542         sensor_info* info = sensor_to_sensor_info(sensor);
 543
 544         retvm_if (!sensor_info_manager::get_instance().is_valid(info) || !min_interval,
 545                 false, "Invalid param: sensor (%p), min_interval(%p)", sensor, min_interval);
 546
 547         *min_interval = info->get_min_interval();
 548
 549         return true;
 550 }
 551
 552 API bool sensord_get_fifo_count(sensor_t sensor, int *fifo_count)
 553 {
 554         sensor_info* info = sensor_to_sensor_info(sensor);
 555
 556         retvm_if (!sensor_info_manager::get_instance().is_valid(info) || !fifo_count,
 557                 false, "Invalid param: sensor (%p), fifo_count(%p)", sensor, fifo_count);
 558
 559         *fifo_count = info->get_fifo_count();
 560
 561         return true;
 562 }
 563
 564 API bool sensord_get_max_batch_count(sensor_t sensor, int *max_batch_count)
 565 {
 566         sensor_info* info = sensor_to_sensor_info(sensor);
 567
 568         retvm_if (!sensor_info_manager::get_instance().is_valid(info) || !max_batch_count,
 569                 false, "Invalid param: sensor (%p), max_batch_count(%p)", sensor, max_batch_count);
 570
 571         *max_batch_count = info->get_max_batch_count();
 572
 573         return true;
 574 }
 575
 576 API bool sensord_get_supported_event_types(sensor_t sensor, unsigned int **event_types, int *count)
 577 {
 578         sensor_info* info = sensor_to_sensor_info(sensor);
 579
 580         retvm_if (!sensor_info_manager::get_instance().is_valid(info) || !event_types || !count,
 581                 false, "Invalid param: sensor (%p), event_types(%p), count(%)", sensor, event_types, count);
 582
 583         vector<unsigned int> event_vec;
 584
 585         info->get_supported_events(event_vec);
 586         *event_types = (unsigned int *) malloc(sizeof(unsigned int) * event_vec.size());
 587         retvm_if(!*event_types, false, "Failed to allocate memory");
 588
 589         copy(event_vec.begin(), event_vec.end(), *event_types);
 590         *count = event_vec.size();
 591
 592         return true;
 593 }
 594
 595 API bool sensord_is_supported_event_type(sensor_t sensor, unsigned int event_type, bool *supported)
 596 {
 597         sensor_info* info = sensor_to_sensor_info(sensor);
 598
 599         retvm_if (!sensor_info_manager::get_instance().is_valid(info) || !event_type || !supported,
 600                 false, "Invalid param: sensor (%p), event_type(%p), supported(%)", sensor, event_type, supported);
 601
 602         *supported = info->is_supported_event(event_type);
 603
 604         return true;
 605 }
 606
 607 API int sensord_connect(sensor_t sensor)
 608 {
 609         command_channel *cmd_channel = NULL;
 610         int handle;
 611         int client_id;
 612         bool sensor_registered;
 613         bool first_connection = false;
 614
 615         sensor_info* info = sensor_to_sensor_info(sensor);
 616
 617         retvm_if (!sensor_info_manager::get_instance().is_valid(info),
 618                 OP_ERROR, "Invalid param: sensor (%p)", sensor);
 619
 620         sensor_id_t sensor_id =  info->get_id();
 621
 622         AUTOLOCK(lock);
 623
 624         sensor_registered = event_listener.is_sensor_registered(sensor_id);
 625
 626         handle = event_listener.create_handle(sensor_id);
 627         if (handle == MAX_HANDLE) {
 628                 ERR("Maximum number of handles reached, sensor: %s in client %s", get_sensor_name(sensor_id), get_client_name());
 629                 return OP_ERROR;
 630         }
 631
 632         if (!sensor_registered) {
 633                 cmd_channel = new(std::nothrow) command_channel();
 634                 retvm_if (!cmd_channel, OP_ERROR, "Failed to allocate memory");
 635
 636                 if (!cmd_channel->create_channel()) {
 637                         ERR("%s failed to create command channel for %s", get_client_name(), get_sensor_name(sensor_id));
 638                         event_listener.delete_handle(handle);
 639                         delete cmd_channel;
 640                         return OP_ERROR;
 641                 }
 642
 643                 event_listener.add_command_channel(sensor_id, cmd_channel);
 644         }
 645
 646         if (!event_listener.get_command_channel(sensor_id, &cmd_channel)) {
 647                 ERR("%s failed to get command channel for %s", get_client_name(), get_sensor_name(sensor_id));
 648                 event_listener.delete_handle(handle);
 649                 return OP_ERROR;
 650         }
 651
 652         if (!event_listener.has_client_id()) {
 653                 first_connection = true;
 654                 if(!cmd_channel->cmd_get_id(client_id)) {
 655                         ERR("Sending cmd_get_id() failed for %s", get_sensor_name(sensor_id));
 656                         event_listener.close_command_channel(sensor_id);
 657                         event_listener.delete_handle(handle);
 658                         return OP_ERROR;
 659                 }
 660
 661                 event_listener.set_client_id(client_id);
 662                 INFO("%s gets client_id [%d]", get_client_name(), client_id);
 663                 event_listener.start_event_listener();
 664                 INFO("%s starts listening events with client_id [%d]", get_client_name(), client_id);
 665         }
 666
 667         client_id = event_listener.get_client_id();
 668         cmd_channel->set_client_id(client_id);
 669
 670         INFO("%s[%d] connects with %s[%d]", get_client_name(), client_id, get_sensor_name(sensor_id), handle);
 671
 672         event_listener.set_sensor_params(handle, SENSOR_STATE_STOPPED, SENSOR_OPTION_DEFAULT);
 673
 674         if (!sensor_registered) {
 675                 if(!cmd_channel->cmd_hello(sensor_id)) {
 676                         ERR("Sending cmd_hello(%s, %d) failed for %s", get_sensor_name(sensor_id), client_id, get_client_name());
 677                         event_listener.close_command_channel(sensor_id);
 678                         event_listener.delete_handle(handle);
 679                         if (first_connection) {
 680                                 event_listener.set_client_id(CLIENT_ID_INVALID);
 681                                 event_listener.stop_event_listener();
 682                         }
 683                         return OP_ERROR;
 684                 }
 685         }
 686
 687         set_power_save_state_cb();
 688         return handle;
 689 }
 690
 691 API bool sensord_disconnect(int handle)
 692 {
 693         command_channel *cmd_channel;
 694         sensor_id_t sensor_id;
 695         int client_id;
 696         int sensor_state;
 697
 698         AUTOLOCK(lock);
 699
 700         if (!event_listener.get_sensor_state(handle, sensor_state)||
 701                 !event_listener.get_sensor_id(handle, sensor_id)) {
 702                 ERR("client %s failed to get handle information", get_client_name());
 703                 return false;
 704         }
 705
 706         if (!event_listener.get_command_channel(sensor_id, &cmd_channel)) {
 707                 ERR("client %s failed to get command channel for %s", get_client_name(), get_sensor_name(sensor_id));
 708                 return false;
 709         }
 710
 711         client_id = event_listener.get_client_id();
 712         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());
 713
 714         INFO("%s disconnects with %s[%d]", get_client_name(), get_sensor_name(sensor_id), handle);
 715
 716         if (sensor_state != SENSOR_STATE_STOPPED) {
 717                 WARN("%s[%d] for %s is not stopped before disconnecting.",
 718                         get_sensor_name(sensor_id), handle, get_client_name());
 719                 sensord_stop(handle);
 720         }
 721
 722         if (!event_listener.delete_handle(handle))
 723                 return false;
 724
 725         if (!event_listener.is_active())
 726                 event_listener.set_client_id(CLIENT_ID_INVALID);
 727
 728         if (!event_listener.is_sensor_registered(sensor_id)) {
 729                 if(!cmd_channel->cmd_byebye()) {
 730                         ERR("Sending cmd_byebye(%d, %s) failed for %s", client_id, get_sensor_name(sensor_id), get_client_name());
 731                         return false;
 732                 }
 733                 event_listener.close_command_channel(sensor_id);
 734         }
 735
 736         if (!event_listener.is_active()) {
 737                 INFO("Stop listening events for client %s with client id [%d]", get_client_name(), event_listener.get_client_id());
 738                 event_listener.stop_event_listener();
 739         }
 740
 741         unset_power_save_state_cb();
 742
 743         return true;
 744 }
 745
 746
 747 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)
 748 {
 749         sensor_id_t sensor_id;
 750         sensor_rep prev_rep, cur_rep;
 751         bool ret;
 752
 753         retvm_if (!cb, false, "callback is NULL");
 754
 755         AUTOLOCK(lock);
 756
 757         if (!event_listener.get_sensor_id(handle, sensor_id)) {
 758                 ERR("client %s failed to get handle information", get_client_name());
 759                 return false;
 760         }
 761
 762         if (interval == 0)
 763                 interval = 1;
 764
 765         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),
 766                         event_type, get_sensor_name(sensor_id), handle, interval, cb, user_data);
 767
 768         event_listener.get_sensor_rep(sensor_id, prev_rep);
 769         event_listener.register_event(handle, event_type, interval, cb_type, cb, user_data);
 770         event_listener.get_sensor_rep(sensor_id, cur_rep);
 771         ret = change_sensor_rep(sensor_id, prev_rep, cur_rep);
 772
 773         if (!ret)
 774                 event_listener.unregister_event(handle, event_type);
 775
 776         return ret;
 777 }
 778
 779 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)
 780 {
 781         return register_event(handle, event_type, interval, max_batch_latency, SENSOR_EVENT_CB, (void *)cb, user_data);
 782 }
 783
 784 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)
 785 {
 786         return register_event(handle, event_type, interval, max_batch_latency, SENSORHUB_EVENT_CB, (void *)cb, user_data);
 787 }
 788
 789
 790 API bool sensord_unregister_event(int handle, unsigned int event_type)
 791 {
 792         sensor_id_t sensor_id;
 793         sensor_rep prev_rep, cur_rep;
 794         bool ret;
 795         unsigned int prev_interval;
 796         int prev_cb_type;
 797         void *prev_cb;
 798         void *prev_user_data;
 799
 800         AUTOLOCK(lock);
 801
 802         if (!event_listener.get_sensor_id(handle, sensor_id)) {
 803                 ERR("client %s failed to get handle information", get_client_name());
 804                 return false;
 805         }
 806
 807         INFO("%s unregisters event %s[0x%x] for sensor %s[%d]", get_client_name(), get_event_name(event_type),
 808                 event_type, get_sensor_name(sensor_id), handle);
 809
 810         event_listener.get_sensor_rep(sensor_id, prev_rep);
 811         event_listener.get_event_info(handle, event_type, prev_interval, prev_cb_type, prev_cb, prev_user_data);
 812
 813         if (!event_listener.unregister_event(handle, event_type)) {
 814                 ERR("%s try to unregister non registered event %s[0x%x] for sensor %s[%d]",
 815                         get_client_name(),get_event_name(event_type), event_type, get_sensor_name(sensor_id), handle);
 816                 return false;
 817         }
 818
 819         event_listener.get_sensor_rep(sensor_id, cur_rep);
 820         ret =  change_sensor_rep(sensor_id, prev_rep, cur_rep);
 821
 822         if (!ret)
 823                 event_listener.register_event(handle, event_type, prev_interval, prev_cb_type, prev_cb, prev_user_data);
 824
 825         return ret;
 826
 827 }
 828
 829
 830 API bool sensord_register_accuracy_cb(int handle, sensor_accuracy_changed_cb_t cb, void *user_data)
 831 {
 832         sensor_id_t sensor_id;
 833
 834         retvm_if (!cb, false, "callback is NULL");
 835
 836         AUTOLOCK(lock);
 837
 838         if (!event_listener.get_sensor_id(handle, sensor_id)) {
 839                 ERR("client %s failed to get handle information", get_client_name());
 840                 return false;
 841         }
 842
 843
 844         INFO("%s registers accuracy_changed_cb for sensor %s[%d] with cb: 0x%x, user_data: 0x%x",
 845                 get_client_name(), get_sensor_name(sensor_id), handle, cb, user_data);
 846
 847         event_listener.register_accuracy_cb(handle, cb , user_data);
 848
 849         return true;
 850
 851 }
 852
 853 API bool sensord_unregister_accuracy_cb(int handle)
 854 {
 855         sensor_id_t sensor_id;
 856
 857         AUTOLOCK(lock);
 858
 859         if (!event_listener.get_sensor_id(handle, sensor_id)) {
 860                 ERR("client %s failed to get handle information", get_client_name());
 861                 return false;
 862         }
 863
 864
 865         INFO("%s unregisters accuracy_changed_cb for sensor %s[%d]",
 866                 get_client_name(), get_sensor_name(sensor_id), handle);
 867
 868         event_listener.unregister_accuracy_cb(handle);
 869
 870         return true;
 871 }
 872
 873
 874 API bool sensord_start(int handle, int option)
 875 {
 876         sensor_id_t sensor_id;
 877         sensor_rep prev_rep, cur_rep;
 878         bool ret;
 879         int prev_state, prev_option;
 880
 881         AUTOLOCK(lock);
 882
 883         if (!event_listener.get_sensor_id(handle, sensor_id)) {
 884                 ERR("client %s failed to get handle information", get_client_name());
 885                 return false;
 886         }
 887
 888         retvm_if ((option < 0) || (option >= SENSOR_OPTION_END), false, "Invalid option value : %d, handle: %d, %s, %s",
 889                 option, handle, get_sensor_name(sensor_id), get_client_name());
 890
 891         INFO("%s starts %s[%d], with option: %d, power save state: %d", get_client_name(), get_sensor_name(sensor_id),
 892                 handle, option, g_power_save_state);
 893
 894         if (g_power_save_state && !(g_power_save_state & option)) {
 895                 event_listener.set_sensor_params(handle, SENSOR_STATE_PAUSED, option);
 896                 return true;
 897         }
 898
 899         event_listener.get_sensor_rep(sensor_id, prev_rep);
 900         event_listener.get_sensor_params(handle, prev_state, prev_option);
 901         event_listener.set_sensor_params(handle, SENSOR_STATE_STARTED, option);
 902         event_listener.get_sensor_rep(sensor_id, cur_rep);
 903
 904         ret = change_sensor_rep(sensor_id, prev_rep, cur_rep);
 905
 906         if (!ret)
 907                 event_listener.set_sensor_params(handle, prev_state, prev_option);
 908
 909         return ret;
 910 }
 911
 912 API bool sensord_stop(int handle)
 913 {
 914         sensor_id_t sensor_id;
 915         int sensor_state;
 916         bool ret;
 917         int prev_state, prev_option;
 918
 919         sensor_rep prev_rep, cur_rep;
 920
 921         AUTOLOCK(lock);
 922
 923         if (!event_listener.get_sensor_state(handle, sensor_state)||
 924                 !event_listener.get_sensor_id(handle, sensor_id)) {
 925                 ERR("client %s failed to get handle information", get_client_name());
 926                 return false;
 927         }
 928
 929         retvm_if ((sensor_state == SENSOR_STATE_STOPPED), true, "%s already stopped with %s[%d]",
 930                 get_client_name(), get_sensor_name(sensor_id), handle);
 931
 932
 933         INFO("%s stops sensor %s[%d]", get_client_name(), get_sensor_name(sensor_id), handle);
 934
 935         event_listener.get_sensor_rep(sensor_id, prev_rep);
 936         event_listener.get_sensor_params(handle, prev_state, prev_option);
 937         event_listener.set_sensor_state(handle, SENSOR_STATE_STOPPED);
 938         event_listener.get_sensor_rep(sensor_id, cur_rep);
 939
 940         ret = change_sensor_rep(sensor_id, prev_rep, cur_rep);
 941
 942         if (!ret)
 943                 event_listener.set_sensor_params(handle, prev_state, prev_option);
 944
 945         return ret;
 946 }
 947
 948
 949 API bool sensord_change_event_interval(int handle, unsigned int event_type, unsigned int interval)
 950 {
 951         sensor_id_t sensor_id;
 952         sensor_rep prev_rep, cur_rep;
 953         bool ret;
 954         unsigned int prev_interval;
 955         int prev_cb_type;
 956         void *prev_cb;
 957         void *prev_user_data;
 958
 959         AUTOLOCK(lock);
 960
 961         if (!event_listener.get_sensor_id(handle, sensor_id)) {
 962                 ERR("client %s failed to get handle information", get_client_name());
 963                 return false;
 964         }
 965
 966         INFO("%s changes interval of event %s[0x%x] for %s[%d] to interval %d", get_client_name(), get_event_name(event_type),
 967                         event_type, get_sensor_name(sensor_id), handle, interval);
 968
 969         event_listener.get_sensor_rep(sensor_id, prev_rep);
 970
 971         event_listener.get_event_info(handle, event_type, prev_interval, prev_cb_type, prev_cb, prev_user_data);
 972
 973         if (!event_listener.set_event_interval(handle, event_type, interval))
 974                 return false;
 975
 976         event_listener.get_sensor_rep(sensor_id, cur_rep);
 977
 978         ret = change_sensor_rep(sensor_id, prev_rep, cur_rep);
 979
 980         if (!ret)
 981                 event_listener.set_event_interval(handle, event_type, prev_interval);
 982
 983         return ret;
 984
 985 }
 986
 987 API bool sensord_change_event_max_batch_latency(int handle, unsigned int max_batch_latency)
 988 {
 989         return false;
 990 }
 991
 992
 993 API bool sensord_set_option(int handle, int option)
 994 {
 995         sensor_id_t sensor_id;
 996         sensor_rep prev_rep, cur_rep;
 997         int sensor_state;
 998         bool ret;
 999         int prev_state, prev_option;
1000
1001         AUTOLOCK(lock);
1002
1003         if (!event_listener.get_sensor_state(handle, sensor_state)||
1004                 !event_listener.get_sensor_id(handle, sensor_id)) {
1005                 ERR("client %s failed to get handle information", get_client_name());
1006                 return false;
1007         }
1008
1009         retvm_if ((option < 0) || (option >= SENSOR_OPTION_END), false, "Invalid option value : %d, handle: %d, %s, %s",
1010                 option, handle, get_sensor_name(sensor_id), get_client_name());
1011
1012
1013         event_listener.get_sensor_rep(sensor_id, prev_rep);
1014         event_listener.get_sensor_params(handle, prev_state, prev_option);
1015
1016         if (g_power_save_state) {
1017                 if ((option & g_power_save_state) && (sensor_state == SENSOR_STATE_PAUSED))
1018                         event_listener.set_sensor_state(handle, SENSOR_STATE_STARTED);
1019                 else if (!(option & g_power_save_state) && (sensor_state == SENSOR_STATE_STARTED))
1020                         event_listener.set_sensor_state(handle, SENSOR_STATE_PAUSED);
1021         }
1022         event_listener.set_sensor_option(handle, option);
1023
1024         event_listener.get_sensor_rep(sensor_id, cur_rep);
1025         ret =  change_sensor_rep(sensor_id, prev_rep, cur_rep);
1026
1027         if (!ret)
1028                 event_listener.set_sensor_option(handle, prev_option);
1029
1030         return ret;
1031
1032 }
1033
1034 API bool sensord_send_sensorhub_data(int handle, const char *data, int data_len)
1035 {
1036         sensor_id_t sensor_id;
1037         command_channel *cmd_channel;
1038         int client_id;
1039
1040         AUTOLOCK(lock);
1041
1042         if (!event_listener.get_sensor_id(handle, sensor_id)) {
1043                 ERR("client %s failed to get handle information", get_client_name());
1044                 return false;
1045         }
1046
1047         retvm_if (sensor_id != CONTEXT_SENSOR, false, "%s use this API wrongly, only for CONTEXT_SENSOR not for %s",
1048                 get_client_name(), get_sensor_name(sensor_id));
1049
1050         if (!event_listener.get_command_channel(sensor_id, &cmd_channel)) {
1051                 ERR("client %s failed to get command channel for %s", get_client_name(), get_sensor_name(sensor_id));
1052                 return false;
1053         }
1054
1055         retvm_if((data_len < 0) || (data == NULL), false, "Invalid data_len: %d, data: 0x%x, handle: %d, %s, %s",
1056                 data_len, data, handle, get_sensor_name(sensor_id), get_client_name());
1057
1058         client_id = event_listener.get_client_id();
1059         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());
1060
1061         retvm_if (!event_listener.is_sensor_active(sensor_id), false, "%s with client_id:%d is not active state for %s with handle: %d",
1062                 get_sensor_name(sensor_id), client_id, get_client_name(), handle);
1063
1064         if (!cmd_channel->cmd_send_sensorhub_data(data, data_len)) {
1065                 ERR("Sending cmd_send_sensorhub_data(%d, %d, 0x%x) failed for %s",
1066                         client_id, data_len, data, get_client_name);
1067                 return false;
1068         }
1069
1070         return true;
1071
1072 }
1073
1074 API bool sensord_get_data(int handle, unsigned int data_id, sensor_data_t* sensor_data)
1075 {
1076         sensor_id_t sensor_id;
1077         command_channel *cmd_channel;
1078         int sensor_state;
1079         int client_id;
1080
1081         retvm_if ((!sensor_data), false, "sensor_data is NULL");
1082
1083         AUTOLOCK(lock);
1084
1085         if (!event_listener.get_sensor_state(handle, sensor_state)||
1086                 !event_listener.get_sensor_id(handle, sensor_id)) {
1087                 ERR("client %s failed to get handle information", get_client_name());
1088                 return false;
1089         }
1090
1091         if (!event_listener.get_command_channel(sensor_id, &cmd_channel)) {
1092                 ERR("client %s failed to get command channel for %s", get_client_name(), get_sensor_name(sensor_id));
1093                 return false;
1094         }
1095
1096         client_id = event_listener.get_client_id();
1097         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());
1098
1099         if (sensor_state != SENSOR_STATE_STARTED) {
1100                 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);
1101                 return false;
1102         }
1103
1104         if(!cmd_channel->cmd_get_data(data_id, sensor_data)) {
1105                 ERR("cmd_get_data(%d, %d, 0x%x) failed for %s", client_id, data_id, sensor_data, get_client_name());
1106                 return false;
1107         }
1108
1109         return true;
1110
1111 }