src/client.cpp

   1 /*
   2  *  libslp-sensor
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: JuHyun Kim <jh8212.kim@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  */
  21
  22
  23
  24 #include <sys/types.h>
  25 #include <sys/stat.h>
  26 #include <fcntl.h>
  27 #include <sys/socket.h>
  28 #include <netinet/in.h>
  29 #include <unistd.h>
  30 #include <sys/un.h>
  31 #include <stdio.h>
  32 #include <stdlib.h>
  33 #include <string.h>
  34 #include <assert.h>
  35 #include <errno.h>
  36 #include <sys/time.h>
  37 #include <pthread.h>
  38 #include <math.h>
  39 #include <sys/time.h>
  40 #include <time.h>
  41
  42 #include <cobject_type.h>
  43
  44 #include <csync.h>
  45 #include <cmutex.h>
  46 #include <clist.h>
  47 #include <cworker.h>
  48 #include <csock.h>
  49
  50 #include <cpacket.h>
  51
  52 #include <common.h>
  53 #include <sf_common.h>
  54
  55 #include <vconf.h>
  56 #include <glib.h>
  57 #include <sensor.h>
  58 #include <errno.h>
  59
  60 extern int errno;
  61
  62 #ifndef EXTAPI
  63 #define EXTAPI __attribute__((visibility("default")))
  64 #endif
  65
  66 #define MAX_BIND_SLOT                           16
  67 #define MAX_CB_SLOT_PER_BIND            16
  68 #define MAX_CB_BIND_SLOT                        64
  69 #define MAX_EVENT_LIST                          19
  70
  71 #define PITCH_MIN               35
  72 #define PITCH_MAX               145
  73
  74 #define MAX_CHANNEL_NAME_LEN    50
  75 #define BASE_GATHERING_INTERVAL 100
  76
  77 #define ACCEL_SENSOR_BASE_CHANNEL_NAME          "accel_datastream"
  78 #define GEOMAG_SENSOR_BASE_CHANNEL_NAME "geomag_datastream"
  79 #define LIGHT_SENSOR_BASE_CHANNEL_NAME          "lumin_datastream"
  80 #define PROXI_SENSOR_BASE_CHANNEL_NAME          "proxi_datastream"
  81 #define MOTION_ENGINE_BASE_CHANNEL_NAME "motion_datastream"
  82 #define GYRO_SENSOR_BASE_CHANNEL_NAME           "gyro_datastream"
  83 #define BAROMETER_SENSOR_BASE_CHANNEL_NAME       "barometer_datastream"
  84 #define FUSION_SENSOR_BASE_CHANNEL_NAME "fusion_datastream"
  85
  86 #define ROTATION_0 0
  87 #define ROTATION_90 90
  88 #define ROTATION_180 180
  89 #define ROTATION_270 270
  90 #define ROTATION_360 360
  91 #define ROTATION_THD 45
  92
  93 #define RADIAN_VALUE (57.2957)
  94 #define XY_POSITIVE_THD 2.0
  95 #define XY_NEGATIVE_THD -2.0
  96
  97 #define ON_TIME_REQUEST_COUNTER 1
  98
  99 #define VCONF_SF_SERVER_POWER_OFF "memory/private/sensor/poweroff"
 100
 101 const char *STR_SF_CLIENT_IPC_SOCKET    = "/tmp/sf_socket";
 102
 103 static cmutex _lock;
 104 static int g_system_off_cb_ct = 0;
 105
 106 enum _sensor_current_state {
 107         SENSOR_STATE_UNKNOWN = -1,
 108         SENSOR_STATE_STOPPED = 0,
 109         SENSOR_STATE_STARTED = 1,
 110         SENSOR_STATE_PAUSED = 2
 111 };
 112
 113 enum _sensor_wakeup_state {
 114         SENSOR_WAKEUP_UNKNOWN = -1,
 115         SENSOR_WAKEUP_UNSETTED = 0,
 116         SENSOR_WAKEUP_SETTED = 1,
 117 };
 118
 119 enum _sensor_poweroff_state {
 120         SENSOR_POWEROFF_UNKNOWN = -1,
 121         SENSOR_POWEROFF_AWAKEN  =  1,
 122 };
 123
 124 struct sf_bind_table_t {
 125         csock *ipc;
 126         sensor_type_t sensor_type;
 127         int cb_event_max_num;                                   /*limit by MAX_BIND_PER_CB_SLOT*/
 128         int cb_slot_num[MAX_CB_SLOT_PER_BIND];
 129         int my_handle;
 130         int sensor_state;
 131         int wakeup_state;
 132         int sensor_option;
 133 };
 134
 135 struct cb_bind_table_t {
 136         char call_back_key[MAX_KEY_LEN];
 137         void *client_data;
 138         void (*sensor_callback_func_t)(unsigned int, sensor_event_data_t *, void *);
 139         unsigned int cb_event_type;
 140         int my_cb_handle;
 141         int my_sf_handle;
 142
 143         unsigned int request_count;
 144         unsigned int request_data_id;
 145         void *collected_data;
 146         unsigned int current_collected_idx;
 147
 148         GSource *source;
 149         guint gsource_interval;
 150         guint gID;
 151 };
 152
 153 static struct rotation_event rotation_mode[] =
 154 {
 155         { ROTATION_UNKNOWN,       {     ROTATION_UNKNOWN,                 ROTATION_UNKNOWN                 }},
 156         { ROTATION_EVENT_90,  { ROTATION_LANDSCAPE_LEFT,  ROTATION_PORTRAIT_BTM    }},
 157         { ROTATION_EVENT_0,       {     ROTATION_PORTRAIT_TOP,    ROTATION_LANDSCAPE_LEFT  }},
 158         { ROTATION_EVENT_180, { ROTATION_PORTRAIT_BTM,    ROTATION_LANDSCAPE_RIGHT }},
 159         { ROTATION_EVENT_270, { ROTATION_LANDSCAPE_RIGHT, ROTATION_PORTRAIT_TOP    }},
 160 };
 161
 162 struct event_counter_t {
 163         const unsigned int event_type;
 164         unsigned int event_counter;
 165         unsigned int cb_list[MAX_BIND_SLOT];
 166 };
 167
 168 static event_counter_t g_event_list[MAX_EVENT_LIST] = {
 169         { ACCELEROMETER_EVENT_ROTATION_CHECK,      0, {0, }},
 170         { ACCELEROMETER_EVENT_CALIBRATION_NEEDED,  0, {0, }},
 171         { ACCELEROMETER_EVENT_SET_HORIZON,         0, {0, }},
 172         { ACCELEROMETER_EVENT_SET_WAKEUP,          0, {0, }},
 173         { GEOMAGNETIC_EVENT_CALIBRATION_NEEDED,    0, {0, }},
 174         { PROXIMITY_EVENT_CHANGE_STATE,                    0, {0, }},
 175         { LIGHT_EVENT_CHANGE_LEVEL,                        0, {0, }},
 176         { MOTION_ENGINE_EVENT_SNAP,                        0, {0, }},
 177         { MOTION_ENGINE_EVENT_SHAKE,                       0, {0, }},
 178         { MOTION_ENGINE_EVENT_DOUBLETAP,                   0, {0, }},
 179         { MOTION_ENGINE_EVENT_PANNING,                     0, {0, }},
 180         { MOTION_ENGINE_EVENT_TOP_TO_BOTTOM,       0, {0, }},
 181         { MOTION_ENGINE_EVENT_DIRECT_CALL,             0, {0, }},
 182         { MOTION_ENGINE_EVENT_TILT_TO_UNLOCK,      0, {0, }},
 183         { MOTION_ENGINE_EVENT_LOCK_EXECUTE_CAMERA, 0, {0, }},
 184         { MOTION_ENGINE_EVENT_SMART_ALERT        , 0, {0, }},
 185         { MOTION_ENGINE_EVENT_TILT              , 0, {0, }},
 186         { MOTION_ENGINE_EVENT_PANNING_BROWSE    , 0, {0, }},
 187         { MOTION_ENGINE_EVENT_NO_MOVE    , 0, {0, }},
 188 };
 189
 190 static sf_bind_table_t g_bind_table[MAX_BIND_SLOT];
 191
 192 static cb_bind_table_t g_cb_table[MAX_CB_BIND_SLOT];
 193
 194 static gboolean sensor_timeout_handler(gpointer data);
 195
 196 inline static void add_cb_number(int list_slot, unsigned int cb_number)
 197 {
 198         if(list_slot < 0 || list_slot > MAX_EVENT_LIST - 1)
 199                 return;
 200
 201         unsigned int i = 0;
 202         const unsigned int EVENT_COUNTER = g_event_list[list_slot].event_counter;
 203
 204         for(i = 0 ; i < EVENT_COUNTER ; i++) {
 205                 if(g_event_list[list_slot].cb_list[i] == cb_number){
 206                         return;
 207                 }
 208         }
 209
 210         if(EVENT_COUNTER < MAX_BIND_SLOT) {
 211                 g_event_list[list_slot].event_counter++;
 212                 g_event_list[list_slot].cb_list[EVENT_COUNTER] = cb_number;
 213         } else {
 214                 return ;
 215         }
 216 }
 217
 218
 219 inline static void del_cb_number(int list_slot, unsigned int cb_number)
 220 {
 221         if(list_slot < 0 || list_slot > MAX_EVENT_LIST - 1)
 222                 return;
 223
 224         unsigned int i = 0, j = 0;
 225         const unsigned int EVENT_COUNTER = g_event_list[list_slot].event_counter;
 226
 227         for(i = 0 ; i < EVENT_COUNTER ; i++){
 228                 if(g_event_list[list_slot].cb_list[i] == cb_number){
 229                         for(j = i ; j < EVENT_COUNTER - 1; j++){
 230                                 g_event_list[list_slot].cb_list[j] = g_event_list[list_slot].cb_list[j+1];
 231                         }
 232                         g_event_list[list_slot].cb_list[EVENT_COUNTER - 1] = 0;
 233                         g_event_list[list_slot].event_counter--;
 234                         return ;
 235                 }
 236         }
 237
 238         DBG("cb number [%d] is not registered\n", cb_number);
 239 }
 240
 241
 242 inline static void del_cb_by_event_type(unsigned int event_type, unsigned int cb_number)
 243 {
 244         int list_slot = 0;
 245
 246         for(list_slot = 0 ; list_slot < MAX_EVENT_LIST ; list_slot++)
 247                 if(g_event_list[list_slot].event_type == event_type)
 248                         break;
 249
 250         del_cb_number(list_slot, cb_number);
 251 }
 252
 253
 254 inline static int acquire_handle(void)
 255 {
 256         register int i;
 257         _lock.lock();
 258         for (i = 0; i < MAX_BIND_SLOT; i ++) {
 259                 if (g_bind_table[i].ipc == NULL) break;
 260         }
 261         _lock.unlock();
 262
 263         return i;
 264 }
 265
 266
 267 inline static int cb_acquire_handle(void)
 268 {
 269         register int i;
 270         _lock.lock();
 271         for (i = 0; i < MAX_CB_BIND_SLOT; i ++) {
 272                 if (g_cb_table[i].sensor_callback_func_t == NULL) break;
 273         }
 274         _lock.unlock();
 275
 276         return i;
 277 }
 278
 279
 280 inline static void release_handle(int i)
 281 {
 282         register int j;
 283
 284         _lock.lock();
 285         delete g_bind_table[i].ipc;
 286         g_bind_table[i].ipc = NULL;
 287         g_bind_table[i].sensor_type = UNKNOWN_SENSOR;
 288
 289         g_bind_table[i].my_handle = -1;
 290         g_bind_table[i].sensor_state = SENSOR_STATE_UNKNOWN;
 291         g_bind_table[i].wakeup_state = SENSOR_WAKEUP_UNKNOWN;
 292         g_bind_table[i].sensor_option = SENSOR_OPTION_DEFAULT;
 293
 294         for (j=0; j<g_bind_table[i].cb_event_max_num; j++) {
 295                 if (   (j<MAX_CB_SLOT_PER_BIND) && (g_bind_table[i].cb_slot_num[j] > -1)  ) {
 296                         del_cb_by_event_type(g_cb_table[g_bind_table[i].cb_slot_num[j]].cb_event_type, g_bind_table[i].cb_slot_num[j]);
 297                         g_cb_table[g_bind_table[i].cb_slot_num[j]].client_data= NULL;
 298                         g_cb_table[g_bind_table[i].cb_slot_num[j]].sensor_callback_func_t = NULL;
 299                         g_cb_table[g_bind_table[i].cb_slot_num[j]].cb_event_type = 0x00;
 300                         g_cb_table[g_bind_table[i].cb_slot_num[j]].my_cb_handle = -1;
 301                         g_bind_table[i].cb_slot_num[j] = -1;
 302                 }
 303         }
 304
 305         g_bind_table[i].cb_event_max_num = 0;
 306
 307         _lock.unlock();
 308 }
 309
 310
 311 inline static void cb_release_handle(int i)
 312 {
 313         _lock.lock();
 314         g_cb_table[i].client_data= NULL;
 315         g_cb_table[i].sensor_callback_func_t = NULL;
 316         g_cb_table[i].cb_event_type = 0x00;
 317         g_cb_table[i].my_cb_handle = -1;
 318         g_cb_table[i].my_sf_handle = -1;
 319
 320         g_cb_table[i].request_count = 0;
 321         g_cb_table[i].request_data_id = 0;
 322
 323         if ( g_cb_table[i].collected_data )
 324         {
 325                 free (g_cb_table[i].collected_data);
 326                 g_cb_table[i].collected_data = NULL;
 327         }
 328
 329         g_cb_table[i].collected_data = NULL;
 330         g_cb_table[i].current_collected_idx = 0;
 331
 332         g_cb_table[i].source = NULL;
 333         g_cb_table[i].gsource_interval = 0;
 334         g_cb_table[i].gID = 0;
 335         _lock.unlock();
 336 }
 337
 338
 339 void power_off_cb(keynode_t *node, void *data)
 340 {
 341         int val = -1;
 342         int handle = -1, j = -1;
 343         int state = -1;
 344
 345         if(vconf_keynode_get_type(node) != VCONF_TYPE_INT)
 346         {
 347                 ERR("Errer invailed keytype");
 348                 return;
 349         }
 350
 351         val = vconf_keynode_get_int(node);
 352
 353         switch(val)
 354         {
 355                 case SENSOR_POWEROFF_AWAKEN:
 356                         for(handle = 0 ; handle < MAX_BIND_SLOT ; handle++)
 357                         {
 358                                 if(g_bind_table[handle].ipc != NULL)
 359                                 {
 360                                         state = sf_stop(handle);
 361
 362                                         if(state < 0)
 363                                         {
 364                                                 ERR("Cannot stop handle [%d]",handle);
 365                                                 continue;
 366                                         }
 367                                         else
 368                                         {
 369                                                 DBG("LCD OFF and sensor handle [%d] stopped",handle);
 370                                         }
 371
 372                                         for(j = 0 ; j < g_bind_table[handle].cb_event_max_num ; j++)
 373                                         {
 374                                                 if((j<MAX_CB_SLOT_PER_BIND) && (g_bind_table[handle].cb_slot_num[j] > -1))
 375                                                 {
 376                                                         state = sf_unregister_event(handle ,g_cb_table[g_bind_table[handle].cb_slot_num[j]].cb_event_type);
 377
 378                                                         if(state < 0)
 379                                                                 ERR("cannot unregster_event for event [%x], handle [%d]",g_cb_table[g_bind_table[handle].cb_slot_num[j]].cb_event_type, handle);
 380                                                 }
 381                                         }
 382
 383                                         sf_disconnect(handle);
 384                                 }
 385                         }
 386                         break;
 387
 388                 default:
 389                         break;
 390
 391         }
 392 }
 393
 394
 395 void lcd_off_cb(keynode_t *node, void *data)
 396 {
 397         int val = -1;
 398         int i = -1, j = -1;
 399
 400         if(vconf_keynode_get_type(node) != VCONF_TYPE_INT)
 401         {
 402                 ERR("Errer invailed keytype");
 403                 return;
 404         }
 405
 406         val = vconf_keynode_get_int(node);
 407
 408         switch(val)
 409         {
 410                 case VCONFKEY_PM_STATE_LCDOFF:   // LCD OFF
 411                         for(i = 0 ; i < MAX_BIND_SLOT ; i++)
 412                         {
 413                                 if((g_bind_table[i].wakeup_state != SENSOR_WAKEUP_SETTED && g_bind_table[i].sensor_option != SENSOR_OPTION_ALWAYS_ON ) && g_bind_table[i].ipc != NULL)
 414                                 {
 415                                         if(g_bind_table[i].sensor_state == SENSOR_STATE_STARTED)
 416                                         {
 417                                                 if(sf_stop(i) < 0)
 418                                                 {
 419                                                         ERR("Cannot stop handle [%d]",i);
 420                                                 }
 421                                                 else
 422                                                 {
 423                                                         g_bind_table[i].sensor_state = SENSOR_STATE_PAUSED;
 424
 425                                                         for(j = 0; j < g_bind_table[i].cb_event_max_num; j++)
 426                                                         {
 427                                                                 if(g_cb_table[g_bind_table[i].cb_slot_num[j]].cb_event_type != 0)
 428                                                                         DBG("LCD OFF stopped event_type [%x]",g_cb_table[g_bind_table[i].cb_slot_num[j]].cb_event_type);
 429                                                                 if(g_cb_table[g_bind_table[i].cb_slot_num[j]].collected_data !=  NULL)
 430                                                                 {
 431                                                                         g_source_destroy(g_cb_table[g_bind_table[i].cb_slot_num[j]].source);
 432                                                                         g_source_unref(g_cb_table[g_bind_table[i].cb_slot_num[j]].source);
 433                                                                         g_cb_table[g_bind_table[i].cb_slot_num[j]].source = NULL;
 434                                                                 }
 435                                                         }
 436
 437                                                 }
 438                                         }
 439                                         DBG("LCD OFF and sensor handle [%d] stopped",i);
 440                                 }
 441                         }
 442
 443                         break;
 444                 case VCONFKEY_PM_STATE_NORMAL:  // LCD ON
 445                         for(i = 0 ; i < MAX_BIND_SLOT ; i++)
 446                         {
 447                                 if(g_bind_table[i].sensor_state == SENSOR_STATE_PAUSED)
 448                                 {
 449                                         if(sf_start(i,g_bind_table[i].sensor_option) < 0)
 450                                         {
 451                                                 ERR("Cannot start handle [%d]",i);
 452                                         }
 453                                         else
 454                                         {
 455                                                 for(j = 0; j < g_bind_table[i].cb_event_max_num; j++)
 456                                                 {
 457                                                         if(g_cb_table[g_bind_table[i].cb_slot_num[j]].cb_event_type != 0)
 458                                                                 DBG("LCD ON started event_type [%x]",g_cb_table[g_bind_table[i].cb_slot_num[j]].cb_event_type);
 459                                                         if(g_cb_table[g_bind_table[i].cb_slot_num[j]].collected_data !=  NULL)
 460                                                         {
 461                                                                 g_cb_table[g_bind_table[i].cb_slot_num[j]].source =     g_timeout_source_new(g_cb_table[g_bind_table[i].cb_slot_num[j]].gsource_interval);
 462                                                                 g_source_set_callback(g_cb_table[g_bind_table[i].cb_slot_num[j]].source, sensor_timeout_handler, (gpointer)&g_cb_table[g_bind_table[i].cb_slot_num[j]].my_cb_handle,NULL);
 463                                                                 g_cb_table[g_bind_table[i].cb_slot_num[j]].gID = g_source_attach(g_cb_table[g_bind_table[i].cb_slot_num[j]].source,     NULL);
 464                                                         }
 465                                                 }
 466                                         }
 467                                         DBG("LCD ON and sensor handle [%d] started",i);
 468                                 }
 469                         }
 470
 471                         break;
 472                 default :
 473                         break ;
 474         }
 475 }
 476
 477 int system_off_set(void)
 478 {
 479         int result = -1;
 480         if(g_system_off_cb_ct == 0)
 481         {
 482                 result = vconf_notify_key_changed(VCONFKEY_PM_STATE, lcd_off_cb, NULL);
 483                 if(result < 0)
 484                 {
 485                         ERR("cannot setting lcd_off_set_cb");
 486                 }
 487
 488                 result = vconf_notify_key_changed(VCONF_SF_SERVER_POWER_OFF, power_off_cb, NULL);
 489                 if(result < 0)
 490                 {
 491                         ERR("cannot setting power_off_set_cb");
 492                 }
 493
 494                 g_system_off_cb_ct++;
 495         }
 496         else if (g_system_off_cb_ct > 0)
 497         {
 498                 g_system_off_cb_ct++;
 499         }
 500         else
 501         {
 502                 ERR("g_system_off_cb_ct is negative");
 503                 return -1;
 504         }
 505
 506         DBG("system_off_set success");
 507         return 1;
 508 }
 509
 510 int system_off_unset(void)
 511 {
 512         int result = -1;
 513         if(g_system_off_cb_ct == 1)
 514         {
 515                 result = vconf_ignore_key_changed(VCONFKEY_PM_STATE, lcd_off_cb);
 516                 if(result < 0)
 517                 {
 518                         ERR("cannot setting lcd_off_set_cb");
 519                 }
 520
 521                 result = vconf_ignore_key_changed(VCONF_SF_SERVER_POWER_OFF, power_off_cb);
 522                 if(result < 0)
 523                 {
 524                         ERR("cannot setting power_off_set_cb");
 525                 }
 526
 527                 g_system_off_cb_ct = 0;
 528         }
 529         else if (g_system_off_cb_ct > 1)
 530         {
 531                 g_system_off_cb_ct--;
 532         }
 533         else
 534         {
 535                 ERR("g_system_off_cb_ct is negative");
 536                 return -1;
 537         }
 538         DBG("system_off_unset success");
 539
 540         return 1;
 541 }
 542
 543
 544 void lcd_off_set_wake_up(keynode_t *node, void *data)
 545 {
 546         int state = 0;
 547
 548         state = sf_set_property(ACCELEROMETER_SENSOR, ACCELEROMETER_PROPERTY_SET_WAKEUP, WAKEUP_SET);
 549
 550         if(state < 0)
 551         {
 552                 ERR("ACCELEROMETER_PROPERTY_SET_WAKEUP  fail");
 553         }
 554 }
 555
 556
 557 static void sensor_changed_cb(keynode_t *node, void *data)
 558 {
 559         signed long event_number = (signed long)(data);
 560         unsigned int i = 0;
 561         int val;
 562         int cb_number = 0;
 563         sensor_event_data_t cb_data;
 564         sensor_panning_data_t panning_data;
 565
 566         if(!node)
 567         {
 568                 ERR("Node is NULL");
 569                 return;
 570         }
 571
 572         if (vconf_keynode_get_type(node) !=  VCONF_TYPE_INT )
 573         {
 574                 ERR("Err invaild key_type , incomming key_type : %d , key_name : %s , key_value : %d", vconf_keynode_get_type(node), vconf_keynode_get_name(node),vconf_keynode_get_int(node));
 575                 return;
 576         }
 577
 578         val = vconf_keynode_get_int(node);
 579
 580         for( i = 0 ; i < g_event_list[event_number].event_counter ; i++)
 581         {
 582                 cb_number = g_event_list[event_number].cb_list[i];
 583
 584                 if(g_bind_table[g_cb_table[cb_number].my_sf_handle].sensor_state ==     SENSOR_STATE_STARTED)
 585                 {
 586                         if (g_cb_table[cb_number].sensor_callback_func_t)
 587                         {
 588                                 if(g_cb_table[cb_number].cb_event_type == MOTION_ENGINE_EVENT_PANNING || g_cb_table[cb_number].cb_event_type == MOTION_ENGINE_EVENT_TILT || g_cb_table[cb_number].cb_event_type == MOTION_ENGINE_EVENT_PANNING_BROWSE)
 589                                 {
 590                                         if(val != 0)
 591                                         {
 592                                                 panning_data.x = (short)(val >> 16);
 593                                                 panning_data.y = (short)(val & 0x0000FFFF);
 594                                                 cb_data.event_data_size = sizeof(sensor_panning_data_t);
 595                                                 cb_data.event_data = (void *)&panning_data;
 596                                                 g_cb_table[cb_number].sensor_callback_func_t(g_cb_table[cb_number].cb_event_type,&cb_data, g_cb_table[cb_number].client_data);
 597                                         }
 598                                 }
 599                                 else
 600                                 {
 601                                         if ( val<0 )
 602                                         {
 603                                                 ERR("vconf_keynode_get_int fail for key : %s , handle_num : %d ,get_value : %d\n",g_cb_table[cb_number].call_back_key,cb_number , val);
 604                                                 return ;
 605                                         }
 606
 607                                         switch (g_cb_table[cb_number].cb_event_type) {
 608                                                 case ACCELEROMETER_EVENT_SET_WAKEUP :
 609                                                         /* fall through */
 610                                                 case ACCELEROMETER_EVENT_ROTATION_CHECK :
 611                                                         /* fall through */
 612                                                 case ACCELEROMETER_EVENT_SET_HORIZON :
 613                                                         /* fall through */
 614                                                 case GEOMAGNETIC_EVENT_CALIBRATION_NEEDED :
 615                                                         /* fall through */
 616                                                 case LIGHT_EVENT_CHANGE_LEVEL :
 617                                                         /* fall through */
 618                                                 case PROXIMITY_EVENT_CHANGE_STATE:
 619                                                         /* fall through */
 620                                                 case MOTION_ENGINE_EVENT_SNAP:
 621                                                         /* fall through */
 622                                                 case MOTION_ENGINE_EVENT_SHAKE:
 623                                                         /* fall through */
 624                                                 case MOTION_ENGINE_EVENT_DOUBLETAP:
 625                                                         /* fall through */
 626                                                 case MOTION_ENGINE_EVENT_TOP_TO_BOTTOM:
 627                                                         /* fall through */
 628                                                 case MOTION_ENGINE_EVENT_DIRECT_CALL:
 629                                                         /* fall through */
 630                                                 case MOTION_ENGINE_EVENT_TILT_TO_UNLOCK:
 631                                                         /* fall through */
 632                                                 case MOTION_ENGINE_EVENT_LOCK_EXECUTE_CAMERA:
 633                                                         /* fall through */
 634                                                 case MOTION_ENGINE_EVENT_SMART_ALERT:
 635                                                         /* fall through */
 636                                                 case MOTION_ENGINE_EVENT_NO_MOVE:
 637                                                         cb_data.event_data_size = sizeof(val);
 638                                                         cb_data.event_data = (void *)&val;
 639                                                         g_cb_table[cb_number].sensor_callback_func_t(g_cb_table[cb_number].cb_event_type, &cb_data , g_cb_table[cb_number].client_data);
 640                                                         break;
 641                                                 default :
 642                                                         ERR("Undefined cb_event_type");
 643                                                         return ;
 644                                                         break;
 645                                         }
 646                                 }
 647                         }
 648                         else
 649                         {
 650                                 ERR("Empty Callback func in event : %x\n",g_cb_table[cb_number].cb_event_type);
 651                         }
 652                 }
 653                 else
 654                 {
 655                         ERR("Sensor doesn't start for event : %x",g_cb_table[cb_number].cb_event_type);
 656                 }
 657         }
 658 }
 659
 660
 661 static gboolean sensor_timeout_handler(gpointer data)
 662 {
 663         int *cb_handle = (int*)(data);
 664         int state;
 665         sensor_event_data_t cb_data;
 666
 667         if ( g_bind_table[g_cb_table[*cb_handle].my_sf_handle].sensor_state != SENSOR_STATE_STARTED ) {
 668                 return TRUE;
 669         }
 670
 671         if (g_cb_table[*cb_handle].sensor_callback_func_t) {
 672
 673                 if ( ((g_cb_table[*cb_handle].request_data_id & 0xFFFF) > 0) && ((g_cb_table[*cb_handle].request_data_id & 0xFFFF) < 10) ) {
 674                         sensor_data_t *base_data_values;
 675                         base_data_values =(sensor_data_t *)g_cb_table[*cb_handle].collected_data;
 676
 677                         if ( !base_data_values ) {
 678                                 ERR("ERR get  saved_gather_data stuct fail in sensor_timeout_handler \n");
 679                                 return FALSE;
 680                         }
 681                         state = sf_get_data(g_cb_table[*cb_handle].my_sf_handle, g_cb_table[*cb_handle].request_data_id, base_data_values);
 682
 683                         if ( state < 0 ) {
 684                                 ERR("ERR sensor_get_struct_data fail in sensor_timeout_handler : %d\n",state);
 685                                 return TRUE;
 686                         }
 687
 688                         cb_data.event_data_size = sizeof (sensor_data_t);
 689                         cb_data.event_data = g_cb_table[*cb_handle].collected_data;
 690
 691                         g_cb_table[*cb_handle].sensor_callback_func_t( g_cb_table[*cb_handle].cb_event_type , &cb_data , g_cb_table[*cb_handle].client_data);
 692
 693
 694                 } else {
 695                         ERR("Does not support data_type");
 696                         return TRUE;
 697                 }
 698
 699
 700         } else {
 701                 ERR("Empty Callback func in cb_handle : %d\n", *cb_handle);
 702         }
 703
 704         return TRUE;
 705 }
 706
 707 ///////////////////////////////////for internal ///////////////////////////////////
 708 static int server_get_properties(int handle , unsigned int data_id, void *property_data)
 709 {
 710         cpacket *packet;
 711
 712         try {
 713                 packet = new cpacket(sizeof(cmd_return_property_t) + sizeof(base_property_struct)+ 4);
 714         } catch (int ErrNo) {
 715                 ERR("packet creation fail , errno : %d , errstr : %s\n",ErrNo, strerror(ErrNo));
 716                 return -1;
 717         }
 718
 719         cmd_get_property_t *cmd_payload;
 720
 721         INFO("server_get_properties called with handle : %d \n", handle);
 722         if (handle < 0) {
 723                 ERR("Invalid handle\n");
 724                 errno = EINVAL;
 725                 delete packet;
 726                 return -1;
 727         }
 728
 729         cmd_payload = (cmd_get_property_t*)packet->data();
 730         if (!cmd_payload) {
 731                 ERR("cannot find memory for send packet->data");
 732                 errno = ENOMEM;
 733                 delete packet;
 734                 return -2;
 735         }
 736
 737         packet->set_version(PROTOCOL_VERSION);
 738         packet->set_cmd(CMD_GET_PROPERTY);
 739         packet->set_payload_size(sizeof(cmd_get_property_t));
 740
 741         if(data_id)
 742                 cmd_payload->get_level = data_id;
 743         else
 744                 cmd_payload->get_level = ((unsigned int)g_bind_table[handle].sensor_type<<16) | 0x0001;
 745
 746
 747
 748         INFO("Send CMD_GET_PROPERTY command\n");
 749         if (g_bind_table[handle].ipc && g_bind_table[handle].ipc->send(packet->packet(), packet->size()) == false) {
 750                 ERR("Faield to send a packet\n");
 751                 release_handle(handle);
 752                 errno = ECOMM;
 753                 delete packet;
 754                 return -2;
 755         }
 756
 757         if (g_bind_table[handle].ipc && g_bind_table[handle].ipc->recv(packet->packet(), packet->header_size()) == false) {
 758                 ERR("Faield to receive a packet\n");
 759                 release_handle(handle);
 760                 errno = ECOMM;
 761                 delete packet;
 762                 return -2;
 763         }
 764
 765         if (packet->payload_size()) {
 766                 if (g_bind_table[handle].ipc && g_bind_table[handle].ipc->recv((char*)packet->packet() + packet->header_size(), packet->payload_size()) == false) {
 767                         ERR("Faield to receive a packet\n");
 768                         release_handle(handle);
 769                         errno = ECOMM;
 770                         delete packet;
 771                         return -2;
 772                 }
 773
 774                 if (packet->cmd() == CMD_GET_PROPERTY) {
 775                         cmd_return_property_t *return_payload;
 776                         return_payload = (cmd_return_property_t*)packet->data();
 777                         if (return_payload->state < 0) {
 778                                 ERR("sever get property fail , return state : %d\n",return_payload->state);
 779                                 errno = EBADE;
 780                                 delete packet;
 781                                 return -2;
 782                         } else {
 783                                 base_property_struct *base_return_property;
 784                                 base_return_property = (base_property_struct *)return_payload->property_struct;
 785
 786                                 if(data_id)
 787                                 {
 788                                         sensor_data_properties_t *return_properties;
 789                                         return_properties = (sensor_data_properties_t *)property_data;
 790                                         return_properties->sensor_unit_idx = base_return_property->sensor_unit_idx ;
 791                                         return_properties->sensor_min_range= base_return_property->sensor_min_range;
 792                                         return_properties->sensor_max_range= base_return_property->sensor_max_range;
 793                                         return_properties->sensor_resolution = base_return_property->sensor_resolution;
 794                                 }
 795                                 else
 796                                 {
 797                                         sensor_properties_t *return_properties;
 798                                         return_properties = (sensor_properties_t *)property_data;
 799                                         return_properties->sensor_unit_idx = base_return_property->sensor_unit_idx ;
 800                                         return_properties->sensor_min_range= base_return_property->sensor_min_range;
 801                                         return_properties->sensor_max_range= base_return_property->sensor_max_range;
 802                                         return_properties->sensor_resolution = base_return_property->sensor_resolution;
 803                                         memset(return_properties->sensor_name, '\0', sizeof(return_properties->sensor_name));
 804                                         memset(return_properties->sensor_vendor, '\0', sizeof(return_properties->sensor_vendor));
 805                                         strncpy(return_properties->sensor_name, base_return_property->sensor_name, strlen(base_return_property->sensor_name));
 806                                         strncpy(return_properties->sensor_vendor, base_return_property->sensor_vendor, strlen(base_return_property->sensor_vendor));
 807                                 }
 808                         }
 809                 } else {
 810                         ERR("unexpected server cmd\n");
 811                         errno = EBADE;
 812                         delete packet;
 813                         return -2;
 814                 }
 815         }
 816
 817         delete packet;
 818         return 0;
 819 }
 820
 821
 822 static int server_set_property(int handle , unsigned int property_id, long value )
 823 {
 824         cpacket *packet;
 825         try {
 826                 packet = new cpacket(sizeof(cmd_set_value_t) + 4);
 827         } catch (int ErrNo) {
 828                 ERR("packet creation fail , errno : %d , errstr : %s\n",ErrNo, strerror(ErrNo));
 829                 return -1;
 830         }
 831         cmd_set_value_t *cmd_payload;
 832         INFO("server_set_property called with handle : %d \n", handle);
 833         if (handle < 0) {
 834                 ERR("Invalid handle\n");
 835                 errno = EINVAL;
 836                 delete packet;
 837                 return -1;
 838         }
 839
 840         cmd_payload = (cmd_set_value_t*)packet->data();
 841         if (!cmd_payload) {
 842                 ERR("cannot find memory for send packet->data");
 843                 errno = ENOMEM;
 844                 delete packet;
 845                 return -2;
 846         }
 847
 848         packet->set_version(PROTOCOL_VERSION);
 849         packet->set_cmd(CMD_SET_VALUE);
 850         packet->set_payload_size(sizeof(cmd_set_value_t));
 851
 852         cmd_payload->sensor_type = g_bind_table[handle].sensor_type;
 853         cmd_payload->property = property_id;
 854         cmd_payload->value = value;
 855
 856
 857         INFO("Send CMD_SET_VALUE command\n");
 858         if (g_bind_table[handle].ipc && g_bind_table[handle].ipc->send(packet->packet(), packet->size()) == false) {
 859                 ERR("Faield to send a packet\n");
 860                 release_handle(handle);
 861                 errno = ECOMM;
 862                 delete packet;
 863                 return -2;
 864         }
 865
 866         if (g_bind_table[handle].ipc && g_bind_table[handle].ipc->recv(packet->packet(), packet->header_size()) == false) {
 867                 ERR("Faield to receive a packet\n");
 868                 release_handle(handle);
 869                 errno = ECOMM;
 870                 delete packet;
 871                 return -2;
 872         }
 873
 874         if (packet->payload_size()) {
 875                 if (g_bind_table[handle].ipc && g_bind_table[handle].ipc->recv((char*)packet->packet() + packet->header_size(), packet->payload_size()) == false) {
 876                         ERR("Faield to receive a packet\n");
 877                         release_handle(handle);
 878                         errno = ECOMM;
 879                         delete packet;
 880                         return -2;
 881                 }
 882
 883                 if (packet->cmd() == CMD_DONE) {
 884                         cmd_done_t *payload;
 885                         payload = (cmd_done_t*)packet->data();
 886
 887                         if (payload->value == -1) {
 888                                 ERR("cannot support input property\n");
 889                                 errno = ENODEV;
 890                                 delete packet;
 891                                 return -1;
 892                         }
 893                 } else {
 894                         ERR("unexpected server cmd\n");
 895                         errno = ECOMM;
 896                         delete packet;
 897                         return -2;
 898                 }
 899         }
 900
 901         delete packet;
 902         return 0;
 903 }
 904
 905 ///////////////////////////////////for external ///////////////////////////////////
 906
 907 EXTAPI int sf_is_sensor_event_available ( sensor_type_t desired_sensor_type , unsigned int desired_event_type )
 908 {
 909         int handle;
 910         cpacket *packet;
 911         try {
 912                 packet = new cpacket(sizeof(cmd_reg_t)+4);
 913         } catch (int ErrNo) {
 914                 ERR("packet creation fail , errno : %d , errstr : %s\n",ErrNo, strerror(ErrNo));
 915                 return -1;
 916         }
 917         cmd_reg_t *payload;
 918
 919         handle = sf_connect(desired_sensor_type);
 920         if ( handle < 0 ) {
 921                 errno = ENODEV;
 922                 delete packet;
 923                 return -2;
 924         }
 925
 926         if ( desired_event_type != 0 ) {
 927
 928                 payload = (cmd_reg_t*)packet->data();
 929                 if (!payload) {
 930                         ERR("cannot find memory for send packet->data");
 931                         errno = ENOMEM;
 932                         delete packet;
 933                         return -2;
 934                 }
 935
 936                 packet->set_version(PROTOCOL_VERSION);
 937                 packet->set_cmd(CMD_REG);
 938                 packet->set_payload_size(sizeof(cmd_reg_t));
 939                 payload->type = REG_CHK;
 940                 payload->event_type = desired_event_type;
 941
 942                 INFO("Send CMD_REG command\n");
 943                 if (g_bind_table[handle].ipc && g_bind_table[handle].ipc->send(packet->packet(), packet->size()) == false) {
 944                         ERR("Faield to send a packet\n");
 945                         release_handle(handle);
 946                         errno = ECOMM;
 947                         delete packet;
 948                         return -2;
 949                 }
 950
 951                 if (g_bind_table[handle].ipc && g_bind_table[handle].ipc->recv(packet->packet(), packet->header_size()) == false) {
 952                         ERR("Faield to receive a packet\n");
 953                         release_handle(handle);
 954                         errno = ECOMM;
 955                         delete packet;
 956                         return -2;
 957                 }
 958
 959                 if (packet->payload_size()) {
 960                         if (g_bind_table[handle].ipc && g_bind_table[handle].ipc->recv((char*)packet->packet() + packet->header_size(), packet->payload_size()) == false) {
 961                                 ERR("Faield to receive a packet\n");
 962                                 release_handle(handle);
 963                                 errno = ECOMM;
 964                                 delete packet;
 965                                 return -2;
 966                         }
 967
 968                         if (packet->cmd() == CMD_DONE) {
 969                                 cmd_done_t *payload;
 970                                 payload = (cmd_done_t*)packet->data();
 971                                 if (payload->value == -1) {
 972                                         ERR("sever check fail\n");
 973                                         errno = ENODEV;
 974                                         delete packet;
 975                                         return -2;
 976                                 }
 977                         } else {
 978                                 ERR("unexpected server cmd\n");
 979                                 errno = ECOMM;
 980                                 delete packet;
 981                                 return -2;
 982                         }
 983                 }
 984
 985         }
 986
 987         sf_disconnect(handle);
 988         delete packet;
 989
 990         return 0;
 991 }
 992
 993 EXTAPI int sf_get_data_properties(unsigned int data_id, sensor_data_properties_t *return_data_properties)
 994 {
 995         int handle;
 996         int state = -1;
 997
 998         retvm_if( (!return_data_properties )  , -1 , "Invalid return properties pointer : %p", return_data_properties);
 999
1000
1001         handle = sf_connect((sensor_type_t)(data_id >> 16));
1002         if ( handle < 0 ) {
1003                 ERR("Sensor connet fail !! for : %x \n", (data_id >> 16));
1004                 return -1;
1005         } else {
1006                 state = server_get_properties( handle , data_id, return_data_properties );
1007                 if ( state < 0 ) {
1008                         ERR("server_get_properties fail , state : %d \n",state);
1009                 }
1010                 sf_disconnect(handle);
1011         }
1012
1013         return state;
1014 }
1015
1016 EXTAPI int sf_get_properties(sensor_type_t sensor_type, sensor_properties_t *return_properties)
1017 {
1018         int handle;
1019         int state = -1;
1020
1021         retvm_if( (!return_properties )  , -1 , "Invalid return properties pointer : %p", return_properties);
1022
1023         handle = sf_connect(sensor_type);
1024         if ( handle < 0 ) {
1025                 ERR("Sensor connet fail !! for : %x \n", sensor_type);
1026                 return -1;
1027         } else {
1028                 state = server_get_properties( handle , 0, return_properties );
1029                 if ( state < 0 ) {
1030                         ERR("server_get_properties fail , state : %d \n",state);
1031                 }
1032                 sf_disconnect(handle);
1033         }
1034
1035         return state;
1036 }
1037
1038
1039 EXTAPI int sf_set_property(sensor_type_t sensor_type, unsigned int property_id, long value)
1040 {
1041         int handle;
1042         int state = -1;
1043
1044         handle = sf_connect(sensor_type);
1045         if ( handle < 0 ) {
1046                 ERR("Sensor connet fail !! for : %x \n", sensor_type);
1047                 return -1;
1048         } else {
1049                 state = server_set_property( handle , property_id, value );
1050                 if ( state < 0 ) {
1051                         ERR("server_set_property fail , state : %d \n",state);
1052                 }
1053                 sf_disconnect(handle);
1054         }
1055
1056         return state;
1057 }
1058
1059
1060 EXTAPI int sf_connect(sensor_type_t sensor_type)
1061 {
1062         register int i, j;
1063         cpacket *packet;
1064         try {
1065                 packet = new cpacket(sizeof(cmd_hello_t)+MAX_CHANNEL_NAME_LEN+4);
1066         } catch (int ErrNo) {
1067                 ERR("packet creation fail , errno : %d , errstr : %s\n",ErrNo, strerror(ErrNo));
1068                 return -1;
1069         }
1070         cmd_hello_t *payload;
1071         cmd_done_t *return_payload;
1072
1073         pid_t cpid;
1074         size_t channel_name_length;
1075
1076         const char *sf_channel_name = NULL;
1077
1078         cpid = getpid();
1079
1080         INFO("Sensor_attach_channel from pid : %d , to sensor_type : %x",cpid ,sensor_type);
1081
1082         i = acquire_handle();
1083         if (i == MAX_BIND_SLOT) {
1084                 ERR("MAX_BIND_SLOT, Too many slot required");
1085                 errno = ENOMEM;
1086                 delete packet;
1087                 return -2;
1088         }
1089
1090         INFO("Empty slot : %d\n", i);
1091
1092         switch (sensor_type) {
1093                 case ACCELEROMETER_SENSOR :
1094                         sf_channel_name = (char *)ACCEL_SENSOR_BASE_CHANNEL_NAME;
1095                         g_bind_table[i].cb_event_max_num = 8;
1096                         break;
1097
1098                 case GEOMAGNETIC_SENSOR :
1099                         sf_channel_name = (char *)GEOMAG_SENSOR_BASE_CHANNEL_NAME;
1100                         g_bind_table[i].cb_event_max_num = 3;
1101                         break;
1102
1103                 case LIGHT_SENSOR:
1104                         sf_channel_name = (char *)LIGHT_SENSOR_BASE_CHANNEL_NAME;
1105                         g_bind_table[i].cb_event_max_num = 3;
1106                         break;
1107
1108                 case PROXIMITY_SENSOR:
1109                         sf_channel_name = (char *)PROXI_SENSOR_BASE_CHANNEL_NAME;
1110                         g_bind_table[i].cb_event_max_num = 3;
1111                         break;
1112
1113                 case MOTION_SENSOR:
1114                         sf_channel_name = (char *)MOTION_ENGINE_BASE_CHANNEL_NAME;
1115                         g_bind_table[i].cb_event_max_num = 12;
1116                         break;
1117
1118                 case GYROSCOPE_SENSOR:
1119                         sf_channel_name = (char *)GYRO_SENSOR_BASE_CHANNEL_NAME;
1120                         g_bind_table[i].cb_event_max_num = 1;
1121                         break;
1122
1123                 case THERMOMETER_SENSOR:
1124                         break;
1125                 case BAROMETER_SENSOR:
1126                         sf_channel_name = (char *)BAROMETER_SENSOR_BASE_CHANNEL_NAME;
1127                         g_bind_table[i].cb_event_max_num = 3;
1128                         break;
1129                 case FUSION_SENSOR:
1130                         sf_channel_name = (char *)FUSION_SENSOR_BASE_CHANNEL_NAME;
1131                         g_bind_table[i].cb_event_max_num = 3;
1132                         break;
1133
1134                 case UNKNOWN_SENSOR:
1135                 default :
1136                         ERR("Undefined sensor_type");
1137                         release_handle(i);
1138                         errno = ENODEV;
1139                         delete packet;
1140                         return -2;
1141                         break;
1142         }
1143
1144         g_bind_table[i].sensor_type = sensor_type ;
1145         g_bind_table[i].my_handle = i;
1146         g_bind_table[i].sensor_state = SENSOR_STATE_STOPPED;
1147         g_bind_table[i].wakeup_state = SENSOR_WAKEUP_UNSETTED;
1148         g_bind_table[i].sensor_option = SENSOR_OPTION_DEFAULT;
1149
1150         for(j = 0 ; j < g_bind_table[i].cb_event_max_num  ; j++)
1151                 g_bind_table[i].cb_slot_num[j] = -1;
1152
1153         try {
1154                 g_bind_table[i].ipc = new csock( (char *)STR_SF_CLIENT_IPC_SOCKET, csock::SOCK_TCP|csock::SOCK_IPC|csock::SOCK_WORKER, 0, 0);
1155         } catch (...) {
1156                 release_handle(i);
1157                 errno = ECOMM;
1158                 delete packet;
1159                 return -2;
1160         }
1161
1162         if (g_bind_table[i].ipc && g_bind_table[i].ipc->connect_to_server() == false) {
1163                 delete g_bind_table[i].ipc;
1164                 g_bind_table[i].ipc = NULL;
1165                 release_handle(i);
1166                 errno = ECOMM;
1167                 delete packet;
1168                 return -2;
1169         }
1170
1171
1172         INFO("Connected to server\n");
1173         payload = (cmd_hello_t*)packet->data();
1174         if (!payload) {
1175                 ERR("cannot find memory for send packet->data");
1176                 release_handle(i);
1177                 errno = ENOMEM;
1178                 delete packet;
1179                 return -2;
1180         }
1181
1182         if (!sf_channel_name ) {
1183                 ERR("cannot find matched-sensor name!!!");
1184                 release_handle(i);
1185                 errno = ENODEV;
1186                 delete packet;
1187                 return -2;
1188         } else {
1189                 channel_name_length = strlen(sf_channel_name);
1190                 if ( channel_name_length > MAX_CHANNEL_NAME_LEN  ) {
1191                         ERR("error, channel_name_length too long !!!");
1192                         release_handle(i);
1193                         errno = EINVAL;
1194                         delete packet;
1195                         return -1;
1196                 }
1197         }
1198
1199         packet->set_version(PROTOCOL_VERSION);
1200         packet->set_cmd(CMD_HELLO);
1201         packet->set_payload_size(sizeof(cmd_hello_t) + channel_name_length);
1202         strcpy(payload->name, sf_channel_name);
1203
1204         if (g_bind_table[i].ipc && g_bind_table[i].ipc->send(packet->packet(), packet->size()) == false) {
1205                 ERR("Failed to send a hello packet\n");
1206                 release_handle(i);
1207                 errno = ECOMM;
1208                 delete packet;
1209                 return -2;
1210         }
1211
1212         INFO("Wait for recv a reply packet\n");
1213         if (g_bind_table[i].ipc && g_bind_table[i].ipc->recv(packet->packet(), packet->header_size()) == false) {
1214                 release_handle(i);
1215                 errno = ECOMM;
1216                 delete packet;
1217                 return -2;
1218         }
1219
1220         if (packet->payload_size()) {
1221                 if (g_bind_table[i].ipc && g_bind_table[i].ipc->recv((char*)packet->packet() + packet->header_size(), packet->payload_size()) == false) {
1222                         release_handle(i);
1223                         errno = ECOMM;
1224                         delete packet;
1225                         return -2;
1226                 }
1227         }
1228
1229         return_payload = (cmd_done_t*)packet->data();
1230         if (!return_payload) {
1231                 ERR("cannot find memory for return packet->data");
1232                 release_handle(i);
1233                 delete packet;
1234                 return -1;
1235         }
1236
1237         if ( return_payload->value < 0) {
1238                 ERR("There is no sensor \n");
1239                 release_handle(i);
1240                 delete packet;
1241                 return -1;
1242         }
1243
1244         system_off_set();
1245
1246         INFO("Connected sensor type : %x , handle : %d \n", sensor_type , i);
1247         delete packet;
1248         return i;
1249 }
1250
1251 EXTAPI int sf_disconnect(int handle)
1252 {
1253         cpacket *packet;
1254         cmd_byebye_t *payload;
1255
1256         retvm_if( handle > MAX_BIND_SLOT - 1 , -1 , "Incorrect handle");
1257         retvm_if( (g_bind_table[handle].ipc == NULL) ||(handle < 0) , -1 , "sensor_detach_channel fail , invalid handle value : %d",handle);
1258
1259         try {
1260                 packet = new cpacket(sizeof(cmd_byebye_t)+4);
1261         } catch (int ErrNo) {
1262                 ERR("packet creation fail , errno : %d , errstr : %s\n",ErrNo, strerror(ErrNo));
1263                 return -1;
1264         }
1265
1266         INFO("Detach, so remove %d from the table\n", handle);
1267
1268         payload = (cmd_byebye_t*)packet->data();
1269         if (!payload) {
1270                 ERR("cannot find memory for send packet->data");
1271                 errno = ENOMEM;
1272                 delete packet;
1273                 return -2;
1274         }
1275
1276         packet->set_version(PROTOCOL_VERSION);
1277         packet->set_cmd(CMD_BYEBYE);
1278         packet->set_payload_size(sizeof(cmd_byebye_t));
1279
1280         if (g_bind_table[handle].ipc && g_bind_table[handle].ipc->send(packet->packet(), packet->size()) == false) {
1281                 ERR("Failed to send, but delete handle\n");
1282                 errno = ECOMM;
1283                 goto out;
1284         }
1285
1286         INFO("Recv a reply packet\n");
1287         if (g_bind_table[handle].ipc && g_bind_table[handle].ipc->recv(packet->packet(), packet->header_size()) == false) {
1288                 ERR("Send to reply packet fail\n");
1289                 errno = ECOMM;
1290                 goto out;
1291         }
1292
1293         if (packet->payload_size()) {
1294                 if (g_bind_table[handle].ipc && g_bind_table[handle].ipc->recv((char*)packet->packet() + packet->header_size(), packet->payload_size()) == false) {
1295                         ERR("Failed to recv packet\n");
1296                         errno = ECOMM;
1297                 }
1298         }
1299
1300 out:
1301         release_handle(handle);
1302         system_off_unset();
1303         delete packet;
1304         return 0;
1305
1306 }
1307
1308 EXTAPI int sf_start(int handle , int option)
1309 {
1310         cpacket *packet;
1311         cmd_start_t *payload;
1312
1313         int lcd_state = 0;
1314
1315         retvm_if( handle > MAX_BIND_SLOT - 1, -1 , "Incorrect handle");
1316         retvm_if( (g_bind_table[handle].ipc == NULL) ||(handle < 0) , -1 , "sensor_start fail , invalid handle value : %d",handle);
1317         retvm_if( option < 0 , -1 , "sensor_start fail , invalid option value : %d",option);
1318         retvm_if( g_bind_table[handle].sensor_state == SENSOR_STATE_STARTED , 0 , "sensor already started");
1319
1320         try {
1321                 packet = new cpacket(sizeof(cmd_start_t)+4);
1322         } catch (int ErrNo) {
1323                 ERR("packet creation fail , errno : %d , errstr : %s\n",ErrNo, strerror(ErrNo));
1324                 return -1;
1325         }
1326
1327         if(option != SENSOR_OPTION_ALWAYS_ON)
1328         {
1329                 if(vconf_get_int(VCONFKEY_PM_STATE, &lcd_state) == 0)
1330                 {
1331                         if(lcd_state == VCONFKEY_PM_STATE_LCDOFF)
1332                         {
1333                                 g_bind_table[handle].sensor_state = SENSOR_STATE_PAUSED;
1334                                 DBG("SENSOR_STATE_PAUSED(LCD OFF)");
1335                                 delete packet;
1336                                 return 0;
1337                         }
1338                 }
1339                 else
1340                 {
1341                         DBG("vconf_get_int Error lcd_state = [%d]",lcd_state);
1342                 }
1343         }
1344         else
1345         {
1346                 DBG("sensor start (SENSOR_OPTION_ALWAYS_ON)");
1347         }
1348
1349         INFO("Sensor S/F Started\n");
1350
1351         payload = (cmd_start_t*)packet->data();
1352         if (!payload) {
1353                 ERR("cannot find memory for send packet->data");
1354                 errno = ENOMEM;
1355                 delete packet;
1356                 return -2;
1357         }
1358
1359         packet->set_version(PROTOCOL_VERSION);
1360         packet->set_cmd(CMD_START);
1361         packet->set_payload_size(sizeof(cmd_start_t));
1362         payload->option = option;
1363
1364         INFO("Send CMD_START command\n");
1365         if (g_bind_table[handle].ipc && g_bind_table[handle].ipc->send(packet->packet(), packet->size()) == false) {
1366                 ERR("Faield to send a packet\n");
1367                 release_handle(handle);
1368                 errno = ECOMM;
1369                 delete packet;
1370                 return -2;
1371         }
1372
1373         INFO("Recv a reply packet\n");
1374
1375         if (g_bind_table[handle].ipc &&  g_bind_table[handle].ipc->recv(packet->packet(), packet->header_size()) == false) {
1376                 ERR("Send to reply packet fail\n");
1377                 errno = ECOMM;
1378                 delete packet;
1379                 return -2;
1380         }
1381
1382         DBG("packet received\n");
1383         if (packet->payload_size()) {
1384                 if (g_bind_table[handle].ipc && g_bind_table[handle].ipc->recv((char*)packet->packet() +        packet->header_size(), packet->payload_size()) == false) {
1385                         errno = ECOMM;
1386                         delete packet;
1387                         return -2;
1388                 }
1389
1390                 if (packet->cmd() == CMD_DONE) {
1391                         cmd_done_t *payload;
1392                         payload = (cmd_done_t*)packet->data();
1393                         if (payload->value < 0) {
1394                                 ERR("Error from sensor server [-1 or -2 : socket error, -3 : stopped by sensor plugin]   value = [%d]\n", payload->value);
1395                                 errno = ECOMM;
1396                                 delete packet;
1397                                 return payload->value;
1398                         }
1399                 } else {
1400                         ERR("unexpected server cmd\n");
1401                         errno = ECOMM;
1402                         delete packet;
1403                         return -2;
1404                 }
1405         }
1406
1407         g_bind_table[handle].sensor_state = SENSOR_STATE_STARTED;
1408         g_bind_table[handle].sensor_option = option;
1409
1410         delete packet;
1411         return 0;
1412
1413 }
1414
1415 EXTAPI int sf_stop(int handle)
1416 {
1417         cpacket *packet;
1418         cmd_stop_t *payload;
1419
1420         retvm_if( handle > MAX_BIND_SLOT - 1, -1 , "Incorrect handle");
1421         retvm_if( (g_bind_table[handle].ipc == NULL) ||(handle < 0) , -1 , "sensor_stop fail , invalid handle value : %d",handle);
1422         retvm_if( (g_bind_table[handle].sensor_state == SENSOR_STATE_STOPPED) || (g_bind_table[handle].sensor_state == SENSOR_STATE_PAUSED) , 0 , "sensor already stopped");
1423
1424         try {
1425                 packet = new cpacket(sizeof(cmd_stop_t)+4);
1426         } catch (int ErrNo) {
1427                 ERR("packet creation fail , errno : %d , errstr : %s\n",ErrNo, strerror(ErrNo));
1428                 return -1;
1429         }
1430
1431         INFO("Sensor S/F Stopped handle = [%d]\n", handle);
1432
1433         payload = (cmd_stop_t*)packet->data();
1434         if (!payload) {
1435                 ERR("cannot find memory for send packet->data");
1436                 errno = ENOMEM;
1437                 delete packet;
1438                 return -2;
1439         }
1440
1441         packet->set_version(PROTOCOL_VERSION);
1442         packet->set_cmd(CMD_STOP);
1443         packet->set_payload_size(sizeof(cmd_stop_t));
1444
1445         if (g_bind_table[handle].ipc && g_bind_table[handle].ipc->send(packet->packet(), packet->size()) == false) {
1446                 ERR("Failed to send a packet\n");
1447                 release_handle(handle);
1448                 errno = ECOMM;
1449                 delete packet;
1450                 return -2;
1451         }
1452
1453         g_bind_table[handle].sensor_state = SENSOR_STATE_STOPPED;
1454         delete packet;
1455
1456         return 0;
1457
1458 }
1459
1460 EXTAPI int sf_register_event(int handle , unsigned int event_type ,  event_condition_t *event_condition , sensor_callback_func_t cb , void *cb_data )
1461 {
1462         cpacket *packet;
1463         cmd_reg_t *payload;
1464         int i = 0, j = 0;
1465         int avail_cb_slot_idx = -1;
1466
1467         int collect_data_flag = 0;
1468
1469         retvm_if( handle > MAX_BIND_SLOT - 1 , -1 , "Incorrect handle");
1470         retvm_if( (g_bind_table[handle].ipc == NULL) ||(handle < 0) , -1 , "sensor_register_cb fail , invalid handle value : %d",handle);
1471
1472         try {
1473                 packet = new cpacket(sizeof(cmd_reg_t)+4);
1474         } catch (int ErrNo) {
1475                 ERR("packet creation fail , errno : %d , errstr : %s\n",ErrNo, strerror(ErrNo));
1476                 return -1;
1477         }
1478
1479         payload = (cmd_reg_t*)packet->data();
1480         if (!payload) {
1481                 ERR("cannot find memory for send packet->data");
1482                 errno = ENOMEM;
1483                 delete packet;
1484                 return -2;
1485         }
1486
1487         DBG("Current handle's(%d) cb_event_max_num : %d\n", handle , g_bind_table[handle].cb_event_max_num);
1488
1489         for ( i=0 ; i<g_bind_table[handle].cb_event_max_num ; i++ ) {
1490                 if ( ((event_type&0xFFFF)>>i) == 0x0001) {
1491                         if (  (g_bind_table[handle].cb_slot_num[i] == -1) ||(!(g_cb_table[ g_bind_table[handle].cb_slot_num[i] ].sensor_callback_func_t))  ) {
1492                                 DBG("Find available slot in g_bind_table for cb\n");
1493                                 avail_cb_slot_idx = i;
1494                                 break;
1495                         }
1496                 }
1497         }
1498
1499         if (avail_cb_slot_idx < 0 ) {
1500                 ERR("Find cb_slot fail, There is  already callback function!!\n");
1501                 errno = ENOMEM;
1502                 delete packet;
1503                 return -2;
1504         }
1505
1506         i = cb_acquire_handle();
1507         if (i == MAX_CB_BIND_SLOT) {
1508                 ERR("MAX_BIND_SLOT, Too many slot required");
1509                 errno = ENOMEM;
1510                 delete packet;
1511                 return -2;
1512         }
1513         INFO("Empty cb_slot : %d\n", i);
1514
1515         g_cb_table[i].my_cb_handle = i;
1516         g_cb_table[i].my_sf_handle = handle;
1517
1518         INFO("Sensor S/F register cb\n");
1519
1520         packet->set_version(PROTOCOL_VERSION);
1521         packet->set_cmd(CMD_REG);
1522         packet->set_payload_size(sizeof(cmd_reg_t));
1523         payload->type = REG_ADD;
1524         payload->event_type = event_type;
1525
1526          if(!event_condition)
1527                  payload->interval = BASE_GATHERING_INTERVAL;
1528          else if((event_condition->cond_op == CONDITION_EQUAL) && (event_condition->cond_value1 > 0 ))
1529                  payload->interval = event_condition->cond_value1;
1530          else
1531                  payload->interval = BASE_GATHERING_INTERVAL;
1532
1533
1534         INFO("Send CMD_REG command with reg_type : %x , event_typ : %x\n",payload->type , payload->event_type );
1535         if (g_bind_table[handle].ipc && g_bind_table[handle].ipc->send(packet->packet(), packet->size()) == false) {
1536                 ERR("Faield to send a packet\n");
1537                 cb_release_handle(i);
1538                 release_handle(handle);
1539                 errno = ECOMM;
1540                 delete packet;
1541                 return -2;
1542         }
1543
1544         if (g_bind_table[handle].ipc && g_bind_table[handle].ipc->recv(packet->packet(), packet->header_size()) == false) {
1545                 ERR("Faield to receive a packet\n");
1546                 cb_release_handle(i);
1547                 release_handle(handle);
1548                 errno = ECOMM;
1549                 delete packet;
1550                 return -2;
1551         }
1552
1553         if (packet->payload_size()) {
1554                 if (g_bind_table[handle].ipc && g_bind_table[handle].ipc->recv((char*)packet->packet() + packet->header_size(), packet->payload_size()) == false) {
1555                         ERR("Faield to receive a packet\n");
1556                         cb_release_handle(i);
1557                         release_handle(handle);
1558                         errno = ECOMM;
1559                         delete packet;
1560                         return -2;
1561                 }
1562
1563                 if (packet->cmd() == CMD_DONE) {
1564                         cmd_done_t *payload;
1565                         payload = (cmd_done_t*)packet->data();
1566                         if (payload->value == -1) {
1567                                 ERR("server register fail\n");
1568                                 cb_release_handle(i);
1569                                 errno = ECOMM;
1570                                 delete packet;
1571                                 return -2;
1572                         }
1573                 } else {
1574                         ERR("unexpected server cmd\n");
1575                         cb_release_handle(i);
1576                         errno = ECOMM;
1577                         delete packet;
1578                         return -2;
1579                 }
1580         }
1581
1582         memset(g_cb_table[i].call_back_key,'\0',MAX_KEY_LEN);
1583         snprintf(g_cb_table[i].call_back_key,(MAX_KEY_LEN-1),"%s%x",DEFAULT_SENSOR_KEY_PREFIX, event_type);
1584
1585         g_cb_table[i].cb_event_type = event_type;
1586         g_cb_table[i].client_data = cb_data;
1587         g_cb_table[i].sensor_callback_func_t = cb;
1588
1589         switch (event_type ) {
1590                         case ACCELEROMETER_EVENT_RAW_DATA_REPORT_ON_TIME:
1591                                 /* fall through */
1592                         case GEOMAGNETIC_EVENT_RAW_DATA_REPORT_ON_TIME:
1593                                 /* fall through */
1594                         case PROXIMITY_EVENT_STATE_REPORT_ON_TIME:
1595                                 /* fall through */
1596                         case GYROSCOPE_EVENT_RAW_DATA_REPORT_ON_TIME:
1597                                 /* fall through */
1598                         case BAROMETER_EVENT_RAW_DATA_REPORT_ON_TIME:
1599                                 /* fall through */
1600                         case LIGHT_EVENT_LEVEL_DATA_REPORT_ON_TIME:
1601                                 /* fall through */
1602                         case FUSION_SENSOR_EVENT_RAW_DATA_REPORT_ON_TIME:
1603                                 collect_data_flag = 1;
1604                                 g_cb_table[i].request_data_id = (event_type & (0xFFFF<<16)) |0x0001;
1605                                 break;
1606                         case LIGHT_EVENT_LUX_DATA_REPORT_ON_TIME:
1607                                 /* fall through */
1608                         case GEOMAGNETIC_EVENT_ATTITUDE_DATA_REPORT_ON_TIME:
1609                                 /* fall through */
1610                         case ACCELEROMETER_EVENT_ORIENTATION_DATA_REPORT_ON_TIME:
1611                                 /* fall through */
1612                         case BAROMETER_EVENT_TEMPERATURE_DATA_REPORT_ON_TIME:
1613                                 /* fall through */
1614                         case PROXIMITY_EVENT_DISTANCE_DATA_REPORT_ON_TIME:
1615                                 /* fall through */
1616                         case FUSION_ROTATION_VECTOR_EVENT_DATA_REPORT_ON_TIME:
1617                                 collect_data_flag = 1;
1618                                 g_cb_table[i].request_data_id = (event_type & (0xFFFF<<16)) |0x0002;
1619                                 break;
1620                         case ACCELEROMETER_EVENT_LINEAR_ACCELERATION_DATA_REPORT_ON_TIME:
1621                                 /* fall through */
1622                         case FUSION_ROTATION_MATRIX_EVENT_DATA_REPORT_ON_TIME:
1623                                 /* fall through */
1624                         case BAROMETER_EVENT_ALTITUDE_DATA_REPORT_ON_TIME:
1625                                 collect_data_flag = 1;
1626                                 g_cb_table[i].request_data_id = (event_type & (0xFFFF<<16)) |0x0004;
1627                                 break;
1628                         case ACCELEROMETER_EVENT_GRAVITY_DATA_REPORT_ON_TIME:
1629                                 collect_data_flag = 1;
1630                                 g_cb_table[i].request_data_id = (event_type & (0xFFFF<<16)) |0x0008;
1631                                 break;
1632                         default :
1633                                 collect_data_flag = 0;
1634         }
1635
1636         INFO("key : %s(p:%p), cb_handle value : %d\n", g_cb_table[i].call_back_key ,g_cb_table[i].call_back_key, i );
1637
1638         if ( collect_data_flag ) {
1639                 sensor_data_t *collected_data_set;
1640
1641                 collected_data_set = new sensor_data_t [ON_TIME_REQUEST_COUNTER];
1642                 if ( !collected_data_set ) {
1643                         ERR("memory allocation fail for gathering datas\n");
1644                         cb_release_handle(i);
1645                         errno = ECOMM;
1646                         delete packet;
1647                         return -2;
1648                 }
1649                 g_cb_table[i].collected_data = (void *)collected_data_set;
1650                 g_cb_table[i].current_collected_idx = 0;
1651
1652                 if (!event_condition) {
1653                         g_cb_table[i].gsource_interval = BASE_GATHERING_INTERVAL;
1654                 } else {
1655                         if ( (event_condition->cond_op == CONDITION_EQUAL) && (event_condition->cond_value1 > 0 ) ) {
1656                                 g_cb_table[i].gsource_interval = (guint)event_condition->cond_value1;
1657                         } else {
1658                                 ERR("Invaild input_condition interval , input_interval : %f\n", event_condition->cond_value1);
1659                                 cb_release_handle(i);
1660                                 errno = EINVAL;
1661                                 delete packet;
1662                                 return -1;
1663                         }
1664                 }
1665
1666
1667                 if ( g_cb_table[i].gsource_interval != 0 ) {
1668                         g_cb_table[i].source = g_timeout_source_new(g_cb_table[i].gsource_interval);
1669                 } else {
1670                         ERR("Error , gsource_interval value : %u",g_cb_table[i].gsource_interval);
1671                         cb_release_handle(i);
1672                         errno = EINVAL;
1673                         delete packet;
1674                         return -1;
1675                 }
1676                 g_source_set_callback (g_cb_table[i].source, sensor_timeout_handler, (gpointer)&g_cb_table[i].my_cb_handle,NULL);
1677                 g_cb_table[i].gID = g_source_attach (g_cb_table[i].source, NULL);
1678
1679         }else {
1680                 g_cb_table[i].request_count = 0;
1681                 g_cb_table[i].request_data_id = 0;
1682                 g_cb_table[i].collected_data = NULL;
1683                 g_cb_table[i].gsource_interval = BASE_GATHERING_INTERVAL;
1684
1685                 for(j = 0 ; j < MAX_EVENT_LIST ; j++){
1686                         if(g_event_list[j].event_type == event_type) {
1687                                 if(g_event_list[j].event_counter < 1){
1688                                         if(vconf_notify_key_changed(g_cb_table[i].call_back_key,sensor_changed_cb,(void*)(j)) == 0 ) {
1689                                                 DBG("vconf_add_chaged_cb success for key : %s  , my_cb_handle value : %d\n", g_cb_table[i].call_back_key, g_cb_table[i].my_cb_handle);
1690                                         } else {
1691                                                 DBG("vconf_add_chaged_cb fail for key : %s  , my_cb_handle value : %d\n", g_cb_table[i].call_back_key, g_cb_table[i].my_cb_handle);
1692                                                 cb_release_handle(i);
1693                                                 errno = ENODEV;
1694                                                 delete packet;
1695                                                 return -2;
1696                                         }
1697                                 }else {
1698                                         DBG("vconf_add_changed_cb is already registered for key : %s, my_cb_handle      value : %d\n", g_cb_table[i].call_back_key,     g_cb_table[i].my_cb_handle);
1699                                 }
1700                                 add_cb_number(j, i);
1701                         }
1702                 }
1703         }
1704
1705
1706         g_bind_table[handle].cb_slot_num[avail_cb_slot_idx] = i;
1707         delete packet;
1708
1709         return 0;
1710 }
1711
1712
1713 EXTAPI int sf_unregister_event(int handle, unsigned int event_type)
1714 {
1715         int state = 0;
1716         cpacket *packet;
1717         cmd_reg_t *payload;
1718         int find_cb_handle =-1;
1719         int i = 0, j = 0;
1720
1721         int collect_data_flag = 0;
1722
1723         retvm_if( handle > MAX_BIND_SLOT - 1, -1 , "Incorrect handle");
1724         retvm_if( (g_bind_table[handle].ipc == NULL) ||(handle < 0) , -1 , "sensor_unregister_cb fail , invalid handle value : %d",handle);
1725
1726         try {
1727                 packet = new cpacket(sizeof(cmd_reg_t)+4);
1728         } catch (int ErrNo) {
1729                 ERR("packet creation fail , errno : %d , errstr : %s\n",ErrNo, strerror(ErrNo));
1730                 return -1;
1731         }
1732
1733         payload = (cmd_reg_t*)packet->data();
1734         if (!payload) {
1735                 ERR("cannot find memory for send packet->data");
1736                 errno = ENOMEM;
1737                 delete packet;
1738                 return -2;
1739         }
1740
1741         for ( i=0 ; i<g_bind_table[handle].cb_event_max_num ; i++ ) {
1742                 if (  g_bind_table[handle].cb_slot_num[i] != -1 ) {
1743
1744                         if ( event_type == g_cb_table[ g_bind_table[handle].cb_slot_num[i] ].cb_event_type) {
1745                                 find_cb_handle = g_bind_table[handle].cb_slot_num[i];
1746                                 break;
1747                         }
1748                 }
1749         }
1750
1751         if (find_cb_handle < 0) {
1752                 ERR("Err , Cannot find cb_slot_num!! for event : %x\n", event_type );
1753                 errno = EINVAL;
1754                 delete packet;
1755                 return -1;
1756         }
1757
1758
1759         INFO("Sensor S/F unregister cb\n");
1760
1761         packet->set_version(PROTOCOL_VERSION);
1762         packet->set_cmd(CMD_REG);
1763         packet->set_payload_size(sizeof(cmd_reg_t));
1764         payload->type = REG_DEL;
1765         payload->event_type = event_type;
1766         payload->interval = g_cb_table[find_cb_handle].gsource_interval;
1767
1768         switch (event_type ) {
1769                 case ACCELEROMETER_EVENT_RAW_DATA_REPORT_ON_TIME:
1770                         /* fall through */
1771                 case ACCELEROMETER_EVENT_ORIENTATION_DATA_REPORT_ON_TIME:
1772                         /* fall through */
1773                 case ACCELEROMETER_EVENT_LINEAR_ACCELERATION_DATA_REPORT_ON_TIME :
1774                         /* fall through */
1775                 case GEOMAGNETIC_EVENT_ATTITUDE_DATA_REPORT_ON_TIME:
1776                         /* fall through */
1777                 case PROXIMITY_EVENT_STATE_REPORT_ON_TIME:
1778                         /* fall through */
1779                 case GYROSCOPE_EVENT_RAW_DATA_REPORT_ON_TIME:
1780                         /* fall through */
1781                 case BAROMETER_EVENT_RAW_DATA_REPORT_ON_TIME:
1782                         /* fall through */
1783                 case BAROMETER_EVENT_TEMPERATURE_DATA_REPORT_ON_TIME:
1784                         /* fall through */
1785                 case BAROMETER_EVENT_ALTITUDE_DATA_REPORT_ON_TIME:
1786                         /* fall through */
1787                 case LIGHT_EVENT_LEVEL_DATA_REPORT_ON_TIME:
1788                         /* fall through */
1789                 case GEOMAGNETIC_EVENT_RAW_DATA_REPORT_ON_TIME:
1790                         /* fall through */
1791                 case LIGHT_EVENT_LUX_DATA_REPORT_ON_TIME:
1792                         /* fall through */
1793                 case PROXIMITY_EVENT_DISTANCE_DATA_REPORT_ON_TIME:
1794                         /* fall through */
1795                 case FUSION_SENSOR_EVENT_RAW_DATA_REPORT_ON_TIME:
1796                         /* fall through */
1797                 case FUSION_ROTATION_VECTOR_EVENT_DATA_REPORT_ON_TIME:
1798                         /* fall through */
1799                 case FUSION_ROTATION_MATRIX_EVENT_DATA_REPORT_ON_TIME:
1800                         /* fall through */
1801                 case ACCELEROMETER_EVENT_GRAVITY_DATA_REPORT_ON_TIME:
1802                         collect_data_flag = 1;
1803                         break;
1804         }
1805
1806         INFO("Send CMD_REG command\n");
1807         if (g_bind_table[handle].ipc && g_bind_table[handle].ipc->send(packet->packet(), packet->size()) == false) {
1808                 ERR("Faield to send a packet\n");
1809                 release_handle(handle);
1810                 errno = ECOMM;
1811                 delete packet;
1812                 return -2;
1813         }
1814
1815         if (g_bind_table[handle].ipc && g_bind_table[handle].ipc->recv(packet->packet(), packet->header_size()) == false) {
1816                 ERR("Failed to recv packet_header\n");
1817                 release_handle(handle);
1818                 errno = ECOMM;
1819                 delete packet;
1820                 return -2;
1821         }
1822
1823         if (packet->payload_size()) {
1824                 if (g_bind_table[handle].ipc && g_bind_table[handle].ipc->recv((char*)packet->packet() + packet->header_size(), packet->payload_size()) == false) {
1825                         ERR("Failed to recv packet\n");
1826                         release_handle(handle);
1827                         errno = ECOMM;
1828                         delete packet;
1829                         return -2;
1830                 }
1831         }
1832
1833         if ( collect_data_flag ) {
1834                 if(g_cb_table[find_cb_handle].source)
1835                 {
1836                         g_source_destroy(g_cb_table[find_cb_handle].source);
1837                         g_source_unref(g_cb_table[find_cb_handle].source);
1838                 }
1839                 g_cb_table[find_cb_handle].request_count = 0;
1840                 g_cb_table[find_cb_handle].request_data_id = 0;
1841                 g_cb_table[find_cb_handle].gsource_interval = 0;
1842         } else {
1843                 for(j = 0 ; j < MAX_EVENT_LIST ; j++){
1844                         if(g_event_list[j].event_type == event_type){
1845                                 if(g_event_list[j].event_counter <= 1){
1846                                         state = vconf_ignore_key_changed(g_cb_table[find_cb_handle].call_back_key, sensor_changed_cb);
1847                                         if ( state < 0 ) {
1848                                                 ERR("Failed to del callback using by vconf_del_changed_cb for key : %s\n",g_cb_table[find_cb_handle].call_back_key);
1849                                                 errno = ENODEV;
1850                                                 state = -2;
1851                                         }
1852                                         else {
1853                                                 DBG("del callback using by vconf success [%s] handle = [%d]",g_cb_table[find_cb_handle].call_back_key, find_cb_handle);
1854                                         }
1855                                 } else {
1856                                         DBG("fake remove");
1857                                 }
1858                                 del_cb_number(j,find_cb_handle);
1859                         }
1860                 }
1861         }
1862
1863         cb_release_handle(find_cb_handle);
1864         g_bind_table[handle].cb_slot_num[i] = -1;
1865         delete packet;
1866
1867         return state;
1868 }
1869
1870
1871 EXTAPI int sf_get_data(int handle , unsigned int data_id ,  sensor_data_t* values)
1872 {
1873         cpacket *packet;
1874         cmd_get_data_t *payload;
1875         cmd_get_struct_t *return_payload;
1876         int i;
1877         struct timeval sv;
1878
1879
1880         retvm_if( (!values) , -1 , "sf_get_data fail , invalid get_values pointer %p", values);
1881         retvm_if( ( (data_id & 0xFFFF) < 1) || ( (data_id & 0xFFFF) > 0xFFF), -1 , "sf_get_data fail , invalid data_id %d", data_id);
1882         retvm_if( handle > MAX_BIND_SLOT - 1 , -1 , "Incorrect handle");
1883         retvm_if( (g_bind_table[handle].ipc == NULL) ||(handle < 0) , -1 , "sf_get_data fail , invalid handle value : %d",handle);
1884
1885         try {
1886                 packet = new cpacket(sizeof(cmd_get_struct_t)+sizeof(base_data_struct)+4);
1887         } catch (int ErrNo) {
1888                 ERR("packet creation fail , errno : %d , errstr : %s\n",ErrNo, strerror(ErrNo));
1889                 return -1;
1890         }
1891
1892         if(g_bind_table[handle].sensor_state != SENSOR_STATE_STARTED)
1893         {
1894                 ERR("sensor framewoker doesn't started");
1895                 values->data_accuracy = SENSOR_ACCURACY_UNDEFINED;
1896                 values->data_unit_idx = SENSOR_UNDEFINED_UNIT;
1897                 values->time_stamp = 0;
1898                 values->values_num = 0;
1899                 errno = ECOMM;
1900                 delete packet;
1901                 return -2;
1902         }
1903
1904         payload = (cmd_get_data_t*)packet->data();
1905         if (!payload) {
1906                 ERR("cannot find memory for send packet->data");
1907                 errno = ENOMEM;
1908                 delete packet;
1909                 return -2;
1910         }
1911
1912         packet->set_version(PROTOCOL_VERSION);
1913         packet->set_cmd(CMD_GET_STRUCT);
1914         packet->set_payload_size(sizeof(cmd_get_data_t));
1915         payload->data_id = data_id;
1916
1917         if (g_bind_table[handle].ipc && g_bind_table[handle].ipc->send(packet->packet(), packet->size()) == false) {
1918                 release_handle(handle);
1919                 errno = ECOMM;
1920                 delete packet;
1921                 return -2;
1922         }
1923
1924         if (g_bind_table[handle].ipc && g_bind_table[handle].ipc->recv(packet->packet(), packet->header_size()) == false) {
1925                 release_handle(handle);
1926                 errno = ECOMM;
1927                 delete packet;
1928                 return -2;
1929         }
1930
1931         if (packet->payload_size()) {
1932                 if (g_bind_table[handle].ipc && g_bind_table[handle].ipc->recv((char*)packet->packet() + packet->header_size(), packet->payload_size()) == false) {
1933                         release_handle(handle);
1934                         errno = ECOMM;
1935                         delete packet;
1936                         return -2;
1937                 }
1938         }
1939
1940         return_payload = (cmd_get_struct_t*)packet->data();
1941         if (!return_payload) {
1942                 ERR("cannot find memory for return packet->data");
1943                 errno = ENOMEM;
1944                 delete packet;
1945                 return -2;
1946         }
1947
1948         if ( return_payload->state < 0 ) {
1949                 ERR("get values fail from server \n");
1950                 values->data_accuracy = SENSOR_ACCURACY_UNDEFINED;
1951                 values->data_unit_idx = SENSOR_UNDEFINED_UNIT;
1952                 values->time_stamp = 0;
1953                 values->values_num = 0;
1954                 errno = ECOMM;
1955                 delete packet;
1956                 return -2;
1957         }
1958
1959         base_data_struct *base_return_data;
1960         base_return_data = (base_data_struct *)return_payload->data_struct;
1961
1962         gettimeofday(&sv, NULL);
1963         values->time_stamp = MICROSECONDS(sv);
1964
1965         values->data_accuracy = base_return_data->data_accuracy;
1966         values->data_unit_idx = base_return_data->data_unit_idx;
1967         values->values_num = base_return_data->values_num;
1968         for ( i = 0 ; i <  base_return_data->values_num ; i++ ) {
1969                 values->values[i] = base_return_data->values[i];
1970 //              DBG("client , get_data_value , [%d] : %f \n", i , values->values[i]);
1971         }
1972
1973         delete packet;
1974         return 0;
1975
1976 }
1977
1978 EXTAPI int sf_check_rotation( unsigned long *curr_state)
1979 {
1980         int state = -1;
1981
1982         double raw_z;
1983         double atan_value = 0, norm_z = 0;
1984         int acc_theta = 0 , acc_pitch = 0;
1985         int handle = 0;
1986         int lcd_type = 0;
1987
1988         sensor_data_t base_data_values;
1989
1990         retvm_if( curr_state==NULL , -1 , "sf_check_rotation fail , invalid curr_state");
1991
1992         *curr_state = ROTATION_UNKNOWN;
1993
1994         INFO("Sensor_attach_channel from pid : %d",getpid());
1995
1996         handle = sf_connect( ACCELEROMETER_SENSOR);
1997         if (handle<0)
1998         {
1999                 ERR("sensor attach fail\n");
2000                 return -1;
2001         }
2002
2003         state = sf_start(handle, 0);
2004         if(state < 0)
2005         {
2006                 ERR("sf_start fail\n");
2007                 return -1;
2008         }
2009
2010         state = sf_get_data(handle, ACCELEROMETER_BASE_DATA_SET, &base_data_values);
2011         if(state < 0)
2012         {
2013                 ERR("sf_get_data fail\n");
2014                 return -1;
2015         }
2016
2017         state = sf_stop(handle);
2018         if(state < 0)
2019         {
2020                 ERR("sf_stop fail\n");
2021                 return -1;
2022         }
2023
2024         state = sf_disconnect(handle);
2025         if(state < 0)
2026         {
2027                 ERR("sf_disconnect fail\n");
2028                 return -1;
2029         }
2030
2031         if((base_data_values.values[0] > XY_POSITIVE_THD || base_data_values.values[0] < XY_NEGATIVE_THD) || (base_data_values.values[1] > XY_POSITIVE_THD || base_data_values.values[1] < XY_NEGATIVE_THD))
2032         {
2033                 atan_value = atan2((base_data_values.values[0]),(base_data_values.values[1]));
2034                 acc_theta = ((int)(atan_value * (RADIAN_VALUE) + 360))%360;
2035
2036                 raw_z = (double)(base_data_values.values[2]) / 9.8;
2037
2038                 if ( raw_z > 1.0 ) {
2039                         norm_z = 1.0;
2040                 }
2041                 else if ( raw_z < -1.0 ) {
2042                         norm_z = -1.0;
2043                 }
2044                 else {
2045                         norm_z = raw_z;
2046                 }
2047                 acc_pitch = (int)( acos(norm_z) *(RADIAN_VALUE));
2048         }
2049
2050         INFO( "cal value [acc_theta] : %d , [acc_pitch] : %d\n",acc_theta ,acc_pitch);
2051
2052         if( (acc_pitch>PITCH_MIN) && (acc_pitch<PITCH_MAX) ) {
2053                 if ((acc_theta >= ROTATION_360 - ROTATION_THD && acc_theta <= ROTATION_360 ) || (acc_theta >= ROTATION_0 && acc_theta < ROTATION_0 + ROTATION_THD))
2054                 {
2055                         *curr_state = rotation_mode[ROTATION_EVENT_0].rm[lcd_type];
2056                 }
2057                 else if(acc_theta >= ROTATION_90 - ROTATION_THD && acc_theta < ROTATION_90 + ROTATION_THD)
2058                 {
2059                         *curr_state = rotation_mode[ROTATION_EVENT_90].rm[lcd_type];
2060                 }
2061                 else if(acc_theta >= ROTATION_180 - ROTATION_THD && acc_theta < ROTATION_180 + ROTATION_THD)
2062                 {
2063                         *curr_state = rotation_mode[ROTATION_EVENT_180].rm[lcd_type];
2064                 }
2065                 else if(acc_theta >= ROTATION_270 - ROTATION_THD && acc_theta < ROTATION_270 + ROTATION_THD)
2066                 {
2067                         *curr_state = rotation_mode[ROTATION_EVENT_270].rm[lcd_type];
2068                 }
2069                 else {
2070                         ERR("Wrong acc_theta : %d , cannot detect current state of ACCEL_SENSOR",acc_theta);
2071                         *curr_state = rotation_mode[ROTATION_UNKNOWN].rm[lcd_type];
2072                 }
2073         }else {
2074                 INFO("Cannot detect current state of ACCEL_SENSOR");
2075                 *curr_state = rotation_mode[ROTATION_UNKNOWN].rm[lcd_type];
2076         }
2077
2078         return 0;
2079
2080 }
2081
2082
2083 EXTAPI int sf_set_wakeup(sensor_type_t sensor_type)
2084 {
2085         int i = 0;
2086
2087         if(sf_is_wakeup_supported(sensor_type) < 0)
2088         {
2089                 ERR("Cannot support wake up");
2090                 return -1;
2091         }
2092
2093         for(i = 0 ; i < MAX_BIND_SLOT ; i++)
2094         {
2095                 if(g_bind_table[i].sensor_type == sensor_type)
2096                 {
2097                         g_bind_table[i].wakeup_state = SENSOR_WAKEUP_SETTED;
2098                 }
2099         }
2100
2101         vconf_notify_key_changed(VCONFKEY_PM_STATE, lcd_off_set_wake_up, NULL);
2102
2103         return 0;
2104 }
2105
2106 EXTAPI int sf_unset_wakeup(sensor_type_t sensor_type)
2107 {
2108         int i = 0;
2109         int state = -1;
2110
2111         if(sf_is_wakeup_supported(sensor_type) < 0)
2112         {
2113                 ERR("Cannot support wake up");
2114                 return -1;
2115         }
2116
2117         if(sensor_type == ACCELEROMETER_SENSOR)
2118         {
2119                 state = sf_set_property(sensor_type, ACCELEROMETER_PROPERTY_SET_WAKEUP, WAKEUP_UNSET);
2120                 if(state != 0)
2121                 {
2122                         ERR("set wakeup fail");
2123                         return -1;
2124                 }
2125         }
2126         else
2127         {
2128                 ERR("Cannot support wakeup");
2129                 return -1;
2130         }
2131
2132         for(i = 0 ; i < MAX_BIND_SLOT ; i++)
2133         {
2134                 if(g_bind_table[i].sensor_type == sensor_type)
2135                 {
2136                         g_bind_table[i].wakeup_state = SENSOR_WAKEUP_UNSETTED;
2137                 }
2138         }
2139
2140         vconf_ignore_key_changed(VCONFKEY_PM_STATE, lcd_off_set_wake_up);
2141
2142         return state;
2143 }
2144
2145 EXTAPI int sf_is_wakeup_supported(sensor_type_t sensor_type)
2146 {
2147         if(sensor_type == ACCELEROMETER_SENSOR)
2148                 return sf_set_property(sensor_type, ACCELEROMETER_PROPERTY_CHECK_WAKEUP_SUPPORTED,      WAKEUP_SET);
2149         else
2150         {
2151                 ERR("Cannot support wakeup");
2152                 return -1;
2153         }
2154 }
2155
2156 EXTAPI int sf_is_wakeup_enabled(sensor_type_t sensor_type)
2157 {
2158         if(sensor_type == ACCELEROMETER_SENSOR)
2159                 return sf_set_property(sensor_type,ACCELEROMETER_PROPERTY_CHECK_WAKEUP_STATUS,0);
2160         else
2161         {
2162                  ERR("Cannot support wakeup");
2163                  return -1;
2164         }
2165 }
2166
2167 EXTAPI int sf_change_event_condition(int handle, unsigned int event_type, event_condition_t *event_condition)
2168 {
2169         cpacket *packet;
2170         cmd_reg_t *payload;
2171         int sensor_state = SENSOR_STATE_UNKNOWN;
2172
2173         int i = 0;
2174
2175         retvm_if( handle > MAX_BIND_SLOT - 1 , -1 , "Incorrect handle");
2176         retvm_if( (g_bind_table[handle].ipc == NULL) ||(handle < 0) , -1 , "sf_change_event_condition fail , invalid handle value : %d",handle);
2177
2178         try {
2179                 packet = new cpacket(sizeof(cmd_reg_t) + 4);
2180         } catch (int ErrNo) {
2181                 ERR("packet creation fail , errno : %d , errstr : %s\n",ErrNo, strerror(ErrNo));
2182                 return -1;
2183         }
2184
2185         switch (event_type ) {
2186                 case ACCELEROMETER_EVENT_RAW_DATA_REPORT_ON_TIME:
2187                         /* fall through */
2188                 case ACCELEROMETER_EVENT_ORIENTATION_DATA_REPORT_ON_TIME:
2189                         /* fall through */
2190                 case ACCELEROMETER_EVENT_LINEAR_ACCELERATION_DATA_REPORT_ON_TIME :
2191                         /* fall through */
2192                 case GEOMAGNETIC_EVENT_ATTITUDE_DATA_REPORT_ON_TIME:
2193                         /* fall through */
2194                 case PROXIMITY_EVENT_STATE_REPORT_ON_TIME:
2195                         /* fall through */
2196                 case GYROSCOPE_EVENT_RAW_DATA_REPORT_ON_TIME:
2197                         /* fall through */
2198                 case BAROMETER_EVENT_RAW_DATA_REPORT_ON_TIME:
2199                         /* fall through */
2200                 case BAROMETER_EVENT_TEMPERATURE_DATA_REPORT_ON_TIME:
2201                         /* fall through */
2202                 case BAROMETER_EVENT_ALTITUDE_DATA_REPORT_ON_TIME:
2203                         /* fall through */
2204                 case LIGHT_EVENT_LEVEL_DATA_REPORT_ON_TIME:
2205                         /* fall through */
2206                 case GEOMAGNETIC_EVENT_RAW_DATA_REPORT_ON_TIME:
2207                         /* fall through */
2208                 case LIGHT_EVENT_LUX_DATA_REPORT_ON_TIME:
2209                         /* fall through */
2210                 case PROXIMITY_EVENT_DISTANCE_DATA_REPORT_ON_TIME:
2211                         /* fall through */
2212                 case FUSION_SENSOR_EVENT_RAW_DATA_REPORT_ON_TIME:
2213                         /* fall through */
2214                 case FUSION_ROTATION_VECTOR_EVENT_DATA_REPORT_ON_TIME:
2215                         /* fall through */
2216                 case FUSION_ROTATION_MATRIX_EVENT_DATA_REPORT_ON_TIME:
2217                         break;
2218                 default :
2219                         ERR("Cannot support this API");
2220                         delete packet;
2221                         return -1;
2222         }
2223
2224         for(i = 0 ; i < MAX_CB_SLOT_PER_BIND ; i++)
2225         {
2226                 if(g_cb_table[g_bind_table[handle].cb_slot_num[i]].cb_event_type == event_type)
2227                 {
2228                         if(!event_condition)
2229                         {
2230                                 if(g_cb_table[g_bind_table[handle].cb_slot_num[i]].gsource_interval == (guint)BASE_GATHERING_INTERVAL)
2231                                 {
2232                                         ERR("same interval");
2233                                         delete packet;
2234                                         return -1;
2235                                 }
2236                         }
2237                         else
2238                         {
2239                                 if(g_cb_table[g_bind_table[handle].cb_slot_num[i]].gsource_interval == (guint)event_condition->cond_value1)
2240                                 {
2241                                         ERR("same interval");
2242                                         delete packet;
2243                                         return -1;
2244                                 }
2245                         }
2246
2247                         DBG("find callback number [%d]",i);
2248                         break;
2249                 }
2250         }
2251
2252         if(i == MAX_CB_SLOT_PER_BIND)
2253         {
2254                 ERR("cannot find event_type [%x] in handle [%d]", event_type, handle);
2255                 delete packet;
2256                 return -1;
2257         }
2258
2259         sensor_state = g_bind_table[handle].sensor_state;
2260         g_bind_table[handle].sensor_state = SENSOR_STATE_STOPPED;
2261
2262         payload = (cmd_reg_t*)packet->data();
2263         if(!payload) {
2264                 ERR("cannot find memory for send packet->data");
2265                 errno = ENOMEM;
2266                 g_bind_table[handle].sensor_state = SENSOR_STATE_STARTED;
2267                 delete packet;
2268                 return -2;
2269         }
2270
2271         packet->set_version(PROTOCOL_VERSION);
2272         packet->set_cmd(CMD_REG);
2273         packet->set_payload_size(sizeof(cmd_reg_t));
2274         payload->type = REG_ADD;
2275         payload->event_type = event_type;
2276
2277         if(!event_condition)
2278                 payload->interval = BASE_GATHERING_INTERVAL;
2279         else if((event_condition->cond_op == CONDITION_EQUAL) && (event_condition->cond_value1 > 0 ))
2280                 payload->interval = event_condition->cond_value1;
2281         else
2282                 payload->interval = BASE_GATHERING_INTERVAL;
2283
2284
2285         INFO("Send CMD_REG command with reg_type : %x , event_type : %x\n",payload->type , payload->event_type );
2286         if (g_bind_table[handle].ipc && g_bind_table[handle].ipc->send(packet->packet(), packet->size()) == false) {
2287                 ERR("Faield to send a packet\n");
2288                 errno = ECOMM;
2289                 g_bind_table[handle].sensor_state = sensor_state;
2290                 delete packet;
2291                 return -2;
2292         }
2293
2294         if (g_bind_table[handle].ipc && g_bind_table[handle].ipc->recv(packet->packet(), packet->header_size()) == false) {
2295                 ERR("Faield to receive a packet\n");
2296                 errno = ECOMM;
2297                 g_bind_table[handle].sensor_state = sensor_state;
2298                 delete packet;
2299                 return -2;
2300         }
2301
2302         if (packet->payload_size()) {
2303                 if (g_bind_table[handle].ipc && g_bind_table[handle].ipc->recv((char*)packet->packet() + packet->header_size(), packet->payload_size()) == false) {
2304                         ERR("Faield to receive a packet\n");
2305                         errno = ECOMM;
2306                         g_bind_table[handle].sensor_state = sensor_state;
2307                         delete packet;
2308                         return -2;
2309                 }
2310
2311                 if (packet->cmd() == CMD_DONE) {
2312                         cmd_done_t *payload;
2313                         payload = (cmd_done_t*)packet->data();
2314                         if (payload->value == -1) {
2315                                 ERR("server register fail\n");
2316                                 errno = ECOMM;
2317                                 g_bind_table[handle].sensor_state = sensor_state;
2318                                 delete packet;
2319                                 return -2;
2320                         }
2321                 } else {
2322                         ERR("unexpected server cmd\n");
2323                         errno = ECOMM;
2324                         g_bind_table[handle].sensor_state = sensor_state;
2325                         delete packet;
2326                         return -2;
2327                 }
2328         }
2329
2330         if(g_cb_table[i].source != NULL)
2331         {
2332                 g_source_destroy(g_cb_table[i].source);
2333                 g_source_unref(g_cb_table[i].source);
2334         }
2335
2336         g_cb_table[i].gsource_interval = (guint)payload->interval;
2337         g_cb_table[i].source = g_timeout_source_new(g_cb_table[i].gsource_interval);
2338         g_source_set_callback (g_cb_table[i].source, sensor_timeout_handler, (gpointer)&g_cb_table[i].my_cb_handle,NULL);
2339         g_cb_table[i].gID = g_source_attach (g_cb_table[i].source, NULL);
2340
2341         g_bind_table[handle].sensor_state = sensor_state;
2342         delete packet;
2343
2344         return 0;
2345 }
2346
2347 int sf_change_sensor_option(int handle, int option)
2348 {
2349         retvm_if( handle > MAX_BIND_SLOT - 1 , -1 , "Incorrect handle");
2350         retvm_if( (g_bind_table[handle].ipc == NULL) ||(handle < 0) , -1 , "sensor_start fail , invalid handle value : %d",handle);
2351         retvm_if( option < 0 || option > 1, -1 , "sensor_start fail , invalid option value : %d",option);
2352
2353         g_bind_table[handle].sensor_option = option;
2354
2355         if(g_bind_table[handle].sensor_state == SENSOR_STATE_PAUSED)
2356         {
2357                 if( sf_start(handle, option) < 0)
2358                 {
2359                         ERR("sensor start fail");
2360                         return -1;
2361                 }
2362         }
2363
2364         return 0;
2365 }
2366 //! End of a file