src/client/client.cpp

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