lbs-server/src/server.c

   1 /*
   2  * lbs-server
   3  *
   4  * Copyright (c) 2011-2013 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  * http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  */
  18
  19 #include <stdio.h>
  20 #include <signal.h>
  21 #include <stdlib.h>
  22
  23 #include <unistd.h>
  24 #include <sys/types.h>
  25 #include <sys/wait.h>
  26 #include <fcntl.h>
  27 #include <errno.h>
  28 #include <pthread.h>
  29 #include <string.h>
  30
  31 #include "server.h"
  32 #include "gps_plugin_data_types.h"
  33 #include "gps_plugin_intf.h"
  34 #include "nmea_logger.h"
  35 #include "data_connection.h"
  36 #include "setting.h"
  37 #include "gps_plugin_module.h"
  38 #include "debug_util.h"
  39 #include "last_position.h"
  40 #include "dump_log.h"
  41
  42 #include "nps_plugin_module.h"
  43 #include "nps_plugin_intf.h"
  44
  45 #ifdef _TIZEN_PUBLIC_
  46 #include <msg.h>
  47 #include <msg_transport.h>
  48 #include <pmapi.h>
  49 #endif
  50
  51 #include <vconf.h>
  52 #include <vconf-keys.h>
  53 #include <dlog.h>
  54
  55 #include <glib.h>
  56 #include <glib-object.h>
  57 #if !GLIB_CHECK_VERSION(2, 31, 0)
  58 #include <glib/gthread.h>
  59 #endif
  60
  61 #define MPS_TO_KMPH             3.6             /* 1 m/s = 3.6 km/h */
  62
  63 struct gps_callbacks g_update_cb;
  64 void *g_user_data;
  65
  66 typedef struct {
  67         void *handle;
  68         char *name;
  69 } gps_plugin_handler_t;
  70
  71 typedef struct {
  72         void *handle;
  73 } nps_plugin_handler_t;
  74
  75 typedef struct {
  76         gps_session_state_t session_state;
  77         int dnet_used;
  78         gboolean logging_enabled;
  79         gboolean replay_enabled;
  80
  81 #ifdef _TIZEN_PUBLIC_
  82         pthread_t msg_thread;   /* Register SUPL NI cb to msg server Thread */
  83         pthread_t popup_thread; /* Register SUPL NI cb to msg server Thread */
  84         int msg_thread_status;
  85 #endif
  86
  87         gps_plugin_handler_t gps_plugin;
  88
  89         pos_data_t *pos_data;
  90         batch_data_t *batch_data;
  91         sv_data_t *sv_data;
  92         nmea_data_t *nmea_data;
  93 } gps_server_t;
  94
  95 gps_server_t *g_gps_server = NULL;
  96
  97 nps_plugin_handler_t g_nps_plugin;
  98
  99 static void __nps_plugin_handler_deinit(void)
 100 {
 101         if (g_nps_plugin.handle != NULL)
 102                 g_nps_plugin.handle = NULL;
 103 }
 104
 105 static int _gps_server_gps_event_cb(gps_event_info_t *gps_event_info, void *user_data);
 106
 107 static void _gps_nmea_changed_cb(keynode_t *key, void *data)
 108 {
 109         gps_server_t *server = (gps_server_t *)data;
 110         int int_val;
 111         if (setting_get_int(VCONFKEY_LOCATION_NMEA_LOGGING, &int_val) == FALSE) {
 112                 LOG_GPS(DBG_ERR, "//ERROR!! get VCONFKEY_LOCATION_NMEA_LOGGING setting");
 113                 int_val = 0;
 114         }
 115         server->logging_enabled = (int_val == 1) ? TRUE : FALSE;
 116         return;
 117 }
 118
 119 static gboolean get_replay_enabled()
 120 {
 121         int int_val;
 122         gboolean ret;
 123
 124         if (setting_get_int(VCONFKEY_LOCATION_REPLAY_ENABLED, &int_val) == FALSE) {
 125                 LOG_GPS(DBG_ERR, "//ERROR get VCONFKEY_LOCATION_REPLAY_ENABLED setting");
 126                 int_val = 0;
 127         }
 128
 129         ret = (int_val == 1) ? TRUE : FALSE;
 130
 131         return ret;
 132 }
 133
 134 static void reload_plugin_module(gps_server_t *server)
 135 {
 136         gps_failure_reason_t ReasonCode = GPS_FAILURE_CAUSE_NORMAL;
 137
 138         LOG_GPS(DBG_LOW, "reload_plugin_module : replay enabled: %d", server->replay_enabled);
 139
 140         if (!get_plugin_module()->deinit(&ReasonCode)) {
 141                 LOG_GPS(DBG_ERR, "Fail to GPS plugin deinit");
 142         } else {
 143                 unload_plugin_module(&server->gps_plugin.handle);
 144                 if (!load_plugin_module(server->replay_enabled, &server->gps_plugin.handle)) {
 145                         LOG_GPS(DBG_ERR, "Fail to load plugin module");
 146                 } else {
 147                         if (!get_plugin_module()->init(_gps_server_gps_event_cb, (void *)server)) {
 148                                 LOG_GPS(DBG_ERR, "Fail to plugin init");
 149                                 return;
 150                         }
 151                 }
 152         }
 153 }
 154
 155 static void _gps_replay_changed_cb(keynode_t *key, void *data)
 156 {
 157         gps_server_t *server = (gps_server_t *)data;
 158         server->replay_enabled = get_replay_enabled();
 159         reload_plugin_module(server);
 160
 161         return;
 162 }
 163
 164 static int _gps_server_get_gps_state()
 165 {
 166         int val;
 167
 168         if (setting_get_int(VCONFKEY_LOCATION_GPS_STATE, &val) == FALSE)
 169                 val = POSITION_OFF;
 170
 171         return val;
 172 }
 173
 174 static void _gps_server_set_gps_state(int gps_state)
 175 {
 176         int ret;
 177
 178         switch (gps_state) {
 179         case POSITION_CONNECTED:
 180                 ret = setting_set_int(VCONFKEY_LOCATION_GPS_STATE, POSITION_CONNECTED);
 181                 gps_dump_log("GPS state : POSITION_CONNECTED", NULL);
 182                 break;
 183         case POSITION_SEARCHING:
 184                 ret = setting_set_int(VCONFKEY_LOCATION_GPS_STATE, POSITION_SEARCHING);
 185                 gps_dump_log("GPS state : POSITION_SEARCHING", NULL);
 186                 break;
 187         case POSITION_OFF:
 188                 ret = setting_set_int(VCONFKEY_LOCATION_GPS_STATE, POSITION_OFF);
 189                 gps_dump_log("GPS state : POSITION_OFF", NULL);
 190                 break;
 191         default:
 192                 ret = setting_set_int(VCONFKEY_LOCATION_GPS_STATE, POSITION_OFF);
 193                 break;
 194         }
 195
 196         if (ret == TRUE)
 197                 LOG_GPS(DBG_LOW, "Succeed to set VCONFKEY_LOCATION_GPS_STATE");
 198         else
 199                 LOG_GPS(DBG_ERR, "Fail to set VCONF_LOCATION_GPS_STATE");
 200 }
 201
 202 int request_change_pos_update_interval_standalone_gps(unsigned int interval)
 203 {
 204         LOG_GPS(DBG_INFO, "request_change_pos_update_interval_standalone_gps. interval[%u]", interval);
 205         gboolean status = TRUE;
 206         gps_failure_reason_t reason_code = GPS_FAILURE_CAUSE_NORMAL;
 207         gps_server_t *server = g_gps_server;
 208
 209         if (server->session_state == GPS_SESSION_STARTING || server->session_state == GPS_SESSION_STARTED) {
 210                 gps_action_change_interval_data_t gps_change_interval_data;
 211                 gps_change_interval_data.interval = (int)interval;
 212                 status = get_plugin_module()->request(GPS_ACTION_CHANGE_INTERVAL, &gps_change_interval_data, &reason_code);
 213                 LOG_GPS(DBG_INFO, "requested go GPS module done. gps_change_interval_data.interval [%d]", gps_change_interval_data.interval);
 214
 215                 if (status == FALSE) {
 216                         LOG_GPS(DBG_ERR, "Main: sending GPS_ACTION_CHANGE_INTERVAL Fail !");
 217                         return FALSE;
 218                 }
 219                 LOG_GPS(DBG_INFO, "Main: sending GPS_ACTION_CHANGE_INTERVAL OK !");
 220                 return TRUE;
 221         }
 222         return FALSE;
 223 }
 224
 225 int request_start_session(int interval)
 226 {
 227         LOG_GPS(DBG_INFO, "GPS start with interval [%d]", interval);
 228
 229         gboolean status = TRUE;
 230         gps_failure_reason_t reason_code = GPS_FAILURE_CAUSE_NORMAL;
 231         gps_server_t *server = g_gps_server;
 232         gps_action_start_data_t gps_start_data;
 233
 234         if (server->session_state != GPS_SESSION_STOPPED && server->session_state != GPS_SESSION_STOPPING) {
 235                 LOG_GPS(DBG_WARN, "Main: GPS Session Already Started!");
 236                 return TRUE;
 237         }
 238
 239         server->session_state = GPS_SESSION_STARTING;
 240         LOG_GPS(DBG_LOW, "==GPSSessionState[%d]", server->session_state);
 241         gps_start_data.interval = interval;
 242         status = get_plugin_module()->request(GPS_ACTION_START_SESSION, &gps_start_data, &reason_code);
 243
 244         if (status == FALSE) {
 245                 LOG_GPS(DBG_ERR, "Main: sending GPS_ACTION_START_SESSION Fail !");
 246                 return FALSE;
 247         }
 248
 249         LOG_GPS(DBG_INFO, "Main: sending GPS_ACTION_START_SESSION OK !");
 250
 251         setting_ignore_key_changed(VCONFKEY_LOCATION_REPLAY_ENABLED, _gps_replay_changed_cb);
 252
 253         return TRUE;
 254 }
 255
 256 int request_stop_session()
 257 {
 258         gboolean status = TRUE;
 259         gboolean is_replay_enabled = FALSE;
 260         gps_failure_reason_t reason_code = GPS_FAILURE_CAUSE_NORMAL;
 261         gps_server_t *server = g_gps_server;
 262
 263         LOG_GPS(DBG_LOW, "Main: Stop GPS Session, ==GPSSessionState[%d]", server->session_state);
 264         if (server->session_state == GPS_SESSION_STARTED || server->session_state == GPS_SESSION_STARTING) {
 265                 status = get_plugin_module()->request(GPS_ACTION_STOP_SESSION, NULL, &reason_code);
 266                 if (status) {
 267                         server->session_state = GPS_SESSION_STOPPING;
 268                         LOG_GPS(DBG_LOW, "==GPSSessionState[%d]", server->session_state);
 269                         is_replay_enabled = get_replay_enabled();
 270                         if (server->replay_enabled != is_replay_enabled) {
 271                                 server->replay_enabled = is_replay_enabled;
 272                                 reload_plugin_module(server);
 273                         }
 274                         setting_notify_key_changed(VCONFKEY_LOCATION_REPLAY_ENABLED, _gps_replay_changed_cb, (void *)server);
 275                 } else {
 276                         LOG_GPS(DBG_ERR, "plugin->request to LBS_GPS_STOP_SESSION Failed, reasonCode =%d", reason_code);
 277                 }
 278         } else {
 279                 /* If request is not sent, keep the client registed */
 280                 LOG_GPS(DBG_LOW, "LBS_GPS_STOP_SESSION is not sent because the GPS state is not started, keep the client registed");
 281         }
 282         return status;
 283 }
 284
 285 #ifndef TIZEN_DEVICE
 286 int request_start_batch_session(int batch_interval, int batch_period)
 287 {
 288         LOG_GPS(DBG_INFO, "Batch: GPS start with interval[%d]", batch_interval);
 289
 290         gboolean status = TRUE;
 291         gps_failure_reason_t reason_code = GPS_FAILURE_CAUSE_NORMAL;
 292         gps_server_t *server = g_gps_server;
 293         gps_action_start_data_t gps_start_data;
 294
 295         if (server->session_state == GPS_SESSION_STARTING || server->session_state == GPS_SESSION_STARTED)
 296                 gps_start_data.session_status = 1;      /* 1:Already running, 0:need to start*/
 297         else
 298                 gps_start_data.session_status = 0;
 299
 300         server->session_state = GPS_SESSION_STARTING;
 301         LOG_GPS(DBG_LOW, "==GPSSessionState[%d]", server->session_state);
 302         gps_start_data.interval = batch_interval;
 303         gps_start_data.period = batch_period;
 304         status = get_plugin_module()->request(GPS_ACTION_START_BATCH, &gps_start_data, &reason_code);
 305
 306         if (status == FALSE) {
 307                 LOG_GPS(DBG_ERR, "Batch: sending GPS_ACTION_START_SESSION Fail !");
 308                 return FALSE;
 309         }
 310
 311         LOG_GPS(DBG_INFO, "Batch: sending GPS_ACTION_START_SESSION OK !");
 312
 313         setting_ignore_key_changed(VCONFKEY_LOCATION_REPLAY_ENABLED, _gps_replay_changed_cb);
 314
 315         return TRUE;
 316 }
 317
 318 int request_stop_batch_session(int batch_interval, int batch_period, int session_status)
 319 {
 320         gboolean status = TRUE;
 321         gboolean is_replay_enabled = FALSE;
 322         gps_failure_reason_t reason_code = GPS_FAILURE_CAUSE_NORMAL;
 323         gps_server_t *server = g_gps_server;
 324         gps_action_start_data_t gps_start_data;
 325         gps_start_data.interval = batch_interval;
 326         gps_start_data.period = batch_period;
 327         gps_start_data.session_status = session_status;         /* 0:need to stop, 1:keep status */
 328
 329         LOG_GPS(DBG_LOW, "Batch: Stop GPS Session, ==GPSSessionState[%d]", server->session_state);
 330         if (server->session_state == GPS_SESSION_STARTED || server->session_state == GPS_SESSION_STARTING) {
 331                 /* TURE: All clients stopped, FALSE: Some clients are running with GPS or BATCH */
 332                 status = get_plugin_module()->request(GPS_ACTION_STOP_BATCH, &gps_start_data, &reason_code);
 333                 if (status == TRUE && session_status == 0) {
 334                         server->session_state = GPS_SESSION_STOPPING;
 335                         LOG_GPS(DBG_LOW, "==GPSSessionState[%d]", server->session_state);
 336                         is_replay_enabled = get_replay_enabled();
 337                         if (server->replay_enabled != is_replay_enabled) {
 338                                 server->replay_enabled = is_replay_enabled;
 339                                 reload_plugin_module(server);
 340                         }
 341                         setting_notify_key_changed(VCONFKEY_LOCATION_REPLAY_ENABLED, _gps_replay_changed_cb, (void *)server);
 342                 } else {
 343                         LOG_GPS(DBG_ERR, "  Client exists. plugin->request to LBS_GPS_STOP_SESSION passed");
 344                         status = FALSE;
 345                 }
 346         } else {
 347                 LOG_GPS(DBG_LOW, " Keep the client status because the GPS state is not started");
 348         }
 349         return status;
 350 }
 351 #endif
 352
 353 int request_add_geofence(int fence_id, double latitude, double longitude, int radius, int last_state, int monitor_states, int notification_responsiveness, int unknown_timer)
 354 {
 355         gboolean status = FALSE;
 356         gps_failure_reason_t reason_code = GPS_FAILURE_CAUSE_NORMAL;
 357         geofence_action_data_t action_data;
 358
 359         action_data.geofence.geofence_id = fence_id;
 360         action_data.geofence.latitude = latitude;
 361         action_data.geofence.longitude = longitude;
 362         action_data.geofence.radius = radius;
 363         action_data.last_state = last_state;
 364         action_data.monitor_states = monitor_states;
 365         /* Default value : temp */
 366         action_data.notification_responsiveness_ms = 5000;
 367         action_data.unknown_timer_ms = 30000;
 368         /* action_data.notification_responsiveness_ms = notification_responsiveness; */
 369         /* action_data.unknown_timer_ms = unknown_timer; */
 370
 371         LOG_GPS(DBG_LOW, "request_add_geofence with geofence_id [%d]", fence_id);
 372         status = get_plugin_module()->request(GPS_ACTION_ADD_GEOFENCE, &action_data, &reason_code);
 373
 374         return status;
 375 }
 376
 377 int request_delete_geofence(int fence_id)
 378 {
 379         gboolean status = FALSE;
 380         gps_failure_reason_t reason_code = GPS_FAILURE_CAUSE_NORMAL;
 381
 382         LOG_GPS(DBG_LOW, "request_delete_geofence with geofence_id [%d]", fence_id);
 383         status = get_plugin_module()->request(GPS_ACTION_DELETE_GEOFENCE, &fence_id, &reason_code);
 384
 385         return status;
 386 }
 387
 388 int request_pause_geofence(int fence_id)
 389 {
 390         gboolean status = FALSE;
 391         gps_failure_reason_t reason_code = GPS_FAILURE_CAUSE_NORMAL;
 392
 393         LOG_GPS(DBG_LOW, "request_pause_geofence with geofence_id [%d]", fence_id);
 394         status = get_plugin_module()->request(GPS_ACTION_PAUSE_GEOFENCE, &fence_id, &reason_code);
 395
 396         return status;
 397 }
 398
 399 int request_resume_geofence(int fence_id, int monitor_states)
 400 {
 401         gboolean status = FALSE;
 402         gps_failure_reason_t reason_code = GPS_FAILURE_CAUSE_NORMAL;
 403         geofence_action_data_t action_data;
 404
 405         action_data.geofence.geofence_id = fence_id;
 406         action_data.monitor_states = monitor_states;
 407
 408         LOG_GPS(DBG_LOW, "request_resume_geofence with geofence_id [%d]", fence_id);
 409         status = get_plugin_module()->request(GPS_ACTION_RESUME_GEOFENCE, &action_data, &reason_code);
 410
 411         return status;
 412 }
 413
 414 int request_delete_gps_data()
 415 {
 416         gboolean status = TRUE;
 417         gps_failure_reason_t reason_code = GPS_FAILURE_CAUSE_NORMAL;
 418
 419         status = get_plugin_module()->request(GPS_ACTION_DELETE_GPS_DATA, NULL, &reason_code);
 420
 421         if (status == FALSE) {
 422                 LOG_GPS(DBG_ERR, "Fail : GPS_ACTION_DELETE_GPS_DATA [%d]", reason_code);
 423                 return FALSE;
 424         }
 425
 426         LOG_GPS(DBG_LOW, "Success to GPS_ACTION_DELETE_GPS_DATA");
 427         return TRUE;
 428 }
 429
 430 int get_nmea_from_server(int *timestamp, char **nmea_data)
 431 {
 432         LOG_GPS(DBG_INFO, "ENTER >>>");
 433
 434         gps_server_t *server = g_gps_server;
 435
 436         if (server->session_state == GPS_SESSION_STARTING || server->session_state == GPS_SESSION_STARTED) {
 437                 *timestamp = (int) server->nmea_data->timestamp;
 438                 *nmea_data = g_strndup(server->nmea_data->data, server->nmea_data->len);
 439         }
 440         LOG_GPS(DBG_LOW, "=== timestmap: %d, nmea_data: %s", *timestamp, *nmea_data);
 441         return TRUE;
 442 }
 443
 444 static void _gps_plugin_handler_deinit(gps_server_t *server)
 445 {
 446         if (server->gps_plugin.handle != NULL)
 447                 server->gps_plugin.handle = NULL;
 448 }
 449
 450 static void _gps_get_nmea_replay_mode(gps_server_t *server)
 451 {
 452         int int_val = 0;
 453
 454         if (setting_get_int(VCONFKEY_LOCATION_NMEA_LOGGING, &int_val) == FALSE) {
 455                 LOG_GPS(DBG_ERR, "//ERROR!! get VCONFKEY_LOCATION_NMEA_LOGGING setting");
 456                 int_val = 0;
 457         }
 458         server->logging_enabled = (int_val == 1) ? TRUE : FALSE;
 459
 460         if (setting_get_int(VCONFKEY_LOCATION_REPLAY_ENABLED, &int_val) == FALSE) {
 461                 LOG_GPS(DBG_ERR, "//ERROR!! get VCONFKEY_LOCATION_REPLAY_ENABLED setting");
 462                 int_val = 0;
 463         }
 464         server->replay_enabled = (int_val == 1) ? TRUE : FALSE;
 465 }
 466
 467 static void _gps_notify_params(gps_server_t *server)
 468 {
 469         setting_notify_key_changed(VCONFKEY_LOCATION_NMEA_LOGGING, _gps_nmea_changed_cb, (void *)server);
 470         setting_notify_key_changed(VCONFKEY_LOCATION_REPLAY_ENABLED, _gps_replay_changed_cb, (void *)server);
 471 }
 472
 473 static void _gps_ignore_params()
 474 {
 475         setting_ignore_key_changed(VCONFKEY_LOCATION_NMEA_LOGGING, _gps_nmea_changed_cb);
 476         setting_ignore_key_changed(VCONFKEY_LOCATION_REPLAY_ENABLED, _gps_replay_changed_cb);
 477 }
 478
 479 static void _gps_server_start_event(gps_server_t *server)
 480 {
 481         LOG_GPS(DBG_LOW, "==GPSSessionState [%d] -> [%d]", server->session_state, GPS_SESSION_STARTED);
 482         server->session_state = GPS_SESSION_STARTED;
 483
 484         if (server->logging_enabled) {
 485                 LOG_GPS(DBG_LOW, "NMEA STARTED");
 486                 start_nmea_log();
 487         }
 488
 489         if (server->pos_data == NULL) {
 490                 server->pos_data = (pos_data_t *) malloc(sizeof(pos_data_t));
 491                 if (server->pos_data == NULL)
 492                         LOG_GPS(DBG_WARN, "//callback: server->pos_data re-malloc Failed!!");
 493                 else
 494                         memset(server->pos_data, 0x00, sizeof(pos_data_t));
 495         }
 496         if (server->batch_data == NULL) {
 497                 server->batch_data = (batch_data_t *) malloc(sizeof(batch_data_t));
 498                 if (server->batch_data == NULL)
 499                         LOG_GPS(DBG_WARN, "//callback: server->batch_data re-malloc Failed!!");
 500                 else
 501                         memset(server->batch_data, 0x00, sizeof(batch_data_t));
 502         }
 503         if (server->sv_data == NULL) {
 504                 server->sv_data = (sv_data_t *) malloc(sizeof(sv_data_t));
 505                 if (server->sv_data == NULL)
 506                         LOG_GPS(DBG_WARN, "//callback: server->sv_data re-malloc Failed!!");
 507                 else
 508                         memset(server->sv_data, 0x00, sizeof(sv_data_t));
 509         }
 510         if (server->nmea_data == NULL) {
 511                 server->nmea_data = (nmea_data_t *) malloc(sizeof(nmea_data_t));
 512                 if (server->nmea_data == NULL)
 513                         LOG_GPS(DBG_WARN, "//callback: server->nmea_data re-malloc Failed!!");
 514                 else
 515                         memset(server->nmea_data, 0x00, sizeof(nmea_data_t));
 516         }
 517
 518         _gps_server_set_gps_state(POSITION_SEARCHING);
 519 #ifdef _TIZEN_PUBLIC_
 520         pm_lock_state(LCD_OFF, STAY_CUR_STATE, 0);
 521 #endif
 522 }
 523
 524 static void _gps_server_stop_event(gps_server_t *server)
 525 {
 526         LOG_GPS(DBG_LOW, "==GPSSessionState [%d] -> [%d]", server->session_state, GPS_SESSION_STOPPED);
 527         server->session_state = GPS_SESSION_STOPPED;
 528
 529         _gps_server_set_gps_state(POSITION_OFF);
 530 #ifdef _TIZEN_PUBLIC_
 531         pm_unlock_state(LCD_OFF, PM_RESET_TIMER);
 532 #endif
 533
 534         if (server->logging_enabled) {
 535                 LOG_GPS(DBG_LOW, "NMEA STOPPED");
 536                 stop_nmea_log();
 537         }
 538 }
 539
 540 static void _report_pos_event(gps_server_t *server, gps_event_info_t *gps_event)
 541 {
 542         if (server->pos_data != NULL) {
 543                 memset(server->pos_data, 0x00, sizeof(pos_data_t)); /* Moved: the address of server->pos_data sometimes returns 0 when stopping GPS */
 544                 memcpy(server->pos_data, &(gps_event->event_data.pos_ind.pos), sizeof(pos_data_t));
 545                 /* change m/s to km/h */
 546                 server->pos_data->speed = server->pos_data->speed * MPS_TO_KMPH;
 547                 g_update_cb.pos_cb(server->pos_data, gps_event->event_data.pos_ind.error, g_user_data);
 548         } else {
 549                 LOG_GPS(DBG_ERR, "server->pos_data is NULL");
 550         }
 551 }
 552
 553 static void _report_batch_event(gps_server_t *server, gps_event_info_t *gps_event)
 554 {
 555         if (server->batch_data != NULL) {
 556                 memset(server->batch_data, 0x00, sizeof(batch_data_t));
 557                 memcpy(server->batch_data, &(gps_event->event_data.batch_ind.batch), sizeof(batch_data_t));
 558                 g_update_cb.batch_cb(server->batch_data, g_user_data);
 559         } else {
 560                 LOG_GPS(DBG_ERR, "server->batch_data is NULL");
 561         }
 562 }
 563
 564 static void _report_sv_event(gps_server_t *server, gps_event_info_t *gps_event)
 565 {
 566         if (server->sv_data != NULL) {
 567                 memset(server->sv_data, 0x00, sizeof(sv_data_t));
 568                 memcpy(server->sv_data, &(gps_event->event_data.sv_ind.sv), sizeof(sv_data_t));
 569                 g_update_cb.sv_cb(server->sv_data, g_user_data);
 570         } else {
 571                 LOG_GPS(DBG_ERR, "server->sv_data is NULL");
 572         }
 573 }
 574
 575 static void _report_nmea_event(gps_server_t *server, gps_event_info_t *gps_event)
 576 {
 577         if (server->nmea_data == NULL) {
 578                 LOG_GPS(DBG_ERR, "server->nmea_data is NULL");
 579                 return;
 580         }
 581
 582         if (server->nmea_data->data) {
 583                 free(server->nmea_data->data);
 584                 server->nmea_data->data = NULL;
 585         }
 586
 587         /*LOG_GPS(DBG_LOW, "server->nmea_data->len : [%d]", gps_event->event_data.nmea_ind.nmea.len); */
 588         server->nmea_data->len = gps_event->event_data.nmea_ind.nmea.len;
 589         server->nmea_data->data = (char *)malloc(server->nmea_data->len);
 590         if (server->nmea_data->data == NULL) {
 591                 LOG_GPS(DBG_ERR, "Fail to malloc of server->nmea_data->data");
 592                 return;
 593         }
 594         memset(server->nmea_data->data, 0x00, server->nmea_data->len);
 595         memcpy(server->nmea_data->data, gps_event->event_data.nmea_ind.nmea.data, server->nmea_data->len);
 596         g_update_cb.nmea_cb(server->nmea_data, g_user_data);
 597
 598         if (server->logging_enabled) {
 599                 int nmea_len;
 600                 char *p_nmea_data;
 601                 nmea_len = gps_event->event_data.nmea_ind.nmea.len;
 602                 p_nmea_data = gps_event->event_data.nmea_ind.nmea.data;
 603                 write_nmea_log(p_nmea_data, nmea_len);
 604         }
 605 }
 606
 607 static int _gps_server_open_data_connection(gps_server_t *server)
 608 {
 609         LOG_GPS(DBG_LOW, "Enter _gps_server_open_data_connection");
 610
 611         server->dnet_used++;
 612
 613         if (server->dnet_used > 1) {
 614                 LOG_GPS(DBG_LOW, "dnet_used : count[ %d ]", server->dnet_used);
 615                 return TRUE;
 616         } else {
 617                 LOG_GPS(DBG_LOW, "First open the data connection");
 618         }
 619
 620         unsigned char result;
 621
 622         result = start_pdp_connection();
 623
 624         if (result == TRUE) {
 625                 LOG_GPS(DBG_LOW, "//Open PDP Conn for SUPL Success.");
 626         } else {
 627                 LOG_GPS(DBG_ERR, "//Open PDP Conn for SUPL Fail.");
 628                 return FALSE;
 629         }
 630         return TRUE;
 631 }
 632
 633 static int _gps_server_close_data_connection(gps_server_t *server)
 634 {
 635         LOG_GPS(DBG_LOW, "Enter _gps_server_close_data_connection");
 636
 637         if (server->dnet_used > 0)
 638                 server->dnet_used--;
 639
 640         if (server->dnet_used != 0) {
 641                 LOG_GPS(DBG_LOW, "Cannot stop the data connection! [ dnet_used : %d ]", server->dnet_used);
 642                 return TRUE;
 643         } else {
 644                 LOG_GPS(DBG_LOW, "Close the data connection");
 645         }
 646
 647         unsigned char result;
 648
 649         result = stop_pdp_connection();
 650         if (result == TRUE) {
 651                 LOG_GPS(DBG_LOW, "Close PDP Conn for SUPL Success.");
 652         } else {
 653                 LOG_GPS(DBG_ERR, "//Close PDP Conn for SUPL Fail.");
 654                 return FALSE;
 655         }
 656
 657         return TRUE;
 658 }
 659
 660 static int _gps_server_resolve_dns(char *domain)
 661 {
 662         LOG_GPS(DBG_LOW, "Enter _gps_server_resolve_dns");
 663
 664         unsigned char result;
 665         gps_failure_reason_t reason_code = GPS_FAILURE_CAUSE_NORMAL;
 666         unsigned int ipaddr;
 667         int port;
 668
 669         result = query_dns(domain, &ipaddr, &port);
 670         if (result == TRUE) {
 671                 LOG_GPS(DBG_LOW, "Success to resolve domain name [ %s ] / ipaddr [ %u ]", domain, ipaddr);
 672                 get_plugin_module()->request(GPS_INDI_SUPL_DNSQUERY, (void *)(&ipaddr), &reason_code);
 673         } else {
 674                 ipaddr = 0;
 675                 LOG_GPS(DBG_ERR, "Fail to resolve domain name [ %s ] / ipaddr [ %u ]", domain, ipaddr);
 676                 get_plugin_module()->request(GPS_INDI_SUPL_DNSQUERY, (void *)(&ipaddr), &reason_code);
 677                 return FALSE;
 678         }
 679
 680         return TRUE;
 681 }
 682
 683 static void _gps_server_send_facttest_result(double snr_data, int prn, unsigned short result)
 684 {
 685 }
 686
 687 static void _report_geofence_transition(int geofence_id, geofence_zone_state_t transition, double latitude, double longitude, double altitude, double speed, double bearing, double hor_accuracy)
 688 {
 689         gps_update_geofence_transition(geofence_id, transition, latitude, longitude, altitude, speed, bearing, hor_accuracy, (void *)g_user_data);
 690 }
 691
 692 static void _report_geofence_service_status(int status)
 693 {
 694         gps_update_geofence_service_status(status, (void *)g_user_data);
 695 }
 696
 697 static void _gps_server_send_geofence_result(geofence_event_e event, int geofence_id, int result)
 698 {
 699         if (result != 0) {
 700                 LOG_GPS(DBG_ERR, "result is [%d]", result);
 701                 return;
 702         }
 703
 704         switch (event) {
 705         case GEOFENCE_ADD_FENCE:
 706                 LOG_GPS(DBG_LOW, "Geofence ID[%d], Success ADD_GEOFENCE", geofence_id);
 707                 break;
 708         case GEOFENCE_DELETE_FENCE:
 709                 LOG_GPS(DBG_LOW, "Geofence ID[%d], Success DELETE_GEOFENCE", geofence_id);
 710                 break;
 711         case GEOFENCE_PAUSE_FENCE:
 712                 LOG_GPS(DBG_LOW, "Geofence ID[%d], Success PAUSE_GEOFENCE", geofence_id);
 713                 break;
 714         case GEOFENCE_RESUME_FENCE:
 715                 LOG_GPS(DBG_LOW, "Geofence ID[%d], Success RESUME_GEOFENCE", geofence_id);
 716                 break;
 717         default:
 718                 break;
 719         }
 720 }
 721
 722 static int _gps_server_gps_event_cb(gps_event_info_t *gps_event_info, void *user_data)
 723 {
 724         /*LOG_FUNC; */
 725         gps_server_t *server = (gps_server_t *)user_data;
 726         int result = TRUE;
 727         if (gps_event_info == NULL) {
 728                 LOG_GPS(DBG_WARN, "//NULL pointer variable passed");
 729                 return result;
 730         }
 731
 732         switch (gps_event_info->event_id) {
 733         case GPS_EVENT_START_SESSION:
 734                 LOG_GPS(DBG_LOW, "<<::::::::::: GPS_EVENT_START_SESSION :::::::::::::::");
 735                 if (gps_event_info->event_data.start_session_rsp.error == GPS_ERR_NONE)
 736                         _gps_server_start_event(server);
 737                 else
 738                         LOG_GPS(DBG_ERR, "//Start Session Failed, error : %d", gps_event_info->event_data.start_session_rsp.error);
 739
 740                 break;
 741         case GPS_EVENT_SET_OPTION:
 742                 LOG_GPS(DBG_LOW, "<<::::::::::: GPS_EVENT_SET_OPTION :::::::::::::::");
 743                 if (gps_event_info->event_data.set_option_rsp.error != GPS_ERR_NONE)
 744                         LOG_GPS(DBG_ERR, "//Set Option Failed, error : %d", gps_event_info->event_data.set_option_rsp.error);
 745
 746                 break;
 747         case GPS_EVENT_STOP_SESSION:
 748                 LOG_GPS(DBG_LOW, "<<::::::::::: GPS_EVENT_STOP_SESSION :::::::::::::::");
 749                 if (gps_event_info->event_data.stop_session_rsp.error == GPS_ERR_NONE) {
 750                         _gps_server_close_data_connection(server);
 751                         _gps_server_stop_event(server);
 752                 } else {
 753                         LOG_GPS(DBG_ERR, "//Stop Session Failed, error : %d", gps_event_info->event_data.stop_session_rsp.error);
 754                 }
 755
 756                 break;
 757         case GPS_EVENT_CHANGE_INTERVAL:
 758                 LOG_GPS(DBG_LOW, "<<::::::::::: GPS_EVENT_CHANGE_INTERVAL :::::::::::::::");
 759                 if (gps_event_info->event_data.change_interval_rsp.error == GPS_ERR_NONE)
 760                         LOG_GPS(DBG_LOW, "Change interval success.");
 761                 else
 762                         LOG_GPS(DBG_ERR, "//Change interval Failed, error : %d", gps_event_info->event_data.change_interval_rsp.error);
 763
 764                 break;
 765         case GPS_EVENT_REPORT_POSITION:
 766                 LOG_GPS(DBG_LOW, "<<::::::::::: GPS_EVENT_POSITION :::::::::::::::");
 767                 if (gps_event_info->event_data.pos_ind.error == GPS_ERR_NONE)
 768                         _report_pos_event(server, gps_event_info);
 769                 else
 770                         LOG_GPS(DBG_ERR, "GPS_EVENT_POSITION Failed, error : %d", gps_event_info->event_data.pos_ind.error);
 771
 772                 break;
 773         case GPS_EVENT_REPORT_BATCH:
 774                 LOG_GPS(DBG_LOW, "<<::::::::::: GPS_EVENT_BATCH :::::::::::::::");
 775                 if (gps_event_info->event_data.batch_ind.error == GPS_ERR_NONE)
 776                         _report_batch_event(server, gps_event_info);
 777                 else
 778                         LOG_GPS(DBG_ERR, "GPS_EVENT_BATCH Failed, error : %d", gps_event_info->event_data.batch_ind.error);
 779
 780                 break;
 781         case GPS_EVENT_REPORT_SATELLITE:
 782                 if (gps_event_info->event_data.sv_ind.error == GPS_ERR_NONE) {
 783                         if (gps_event_info->event_data.sv_ind.sv.pos_valid) {
 784                                 if (_gps_server_get_gps_state() != POSITION_CONNECTED)
 785                                         _gps_server_set_gps_state(POSITION_CONNECTED);
 786                         } else {
 787                                 LOG_GPS(DBG_LOW, "<<::::::::::: GPS_EVENT_SATELLITE :::::::::::::::");
 788                                 if (_gps_server_get_gps_state() != POSITION_SEARCHING)
 789                                         _gps_server_set_gps_state(POSITION_SEARCHING);
 790                         }
 791                         _report_sv_event(server, gps_event_info);
 792                 } else {
 793                         LOG_GPS(DBG_ERR, "GPS_EVENT_SATELLITE Failed, error : %d", gps_event_info->event_data.sv_ind.error);
 794                 }
 795                 break;
 796         case GPS_EVENT_REPORT_NMEA:
 797                 /* if (_gps_server_get_gps_state() != POSITION_CONNECTED) */
 798                         /*LOG_GPS(DBG_LOW, "<<::::::::::: GPS_EVENT_NMEA :::::::::::::::"); */
 799
 800                 if (gps_event_info->event_data.nmea_ind.error == GPS_ERR_NONE)
 801                         _report_nmea_event(server, gps_event_info);
 802                 else
 803                         LOG_GPS(DBG_ERR, "GPS_EVENT_NMEA Failed, error : %d", gps_event_info->event_data.nmea_ind.error);
 804
 805                 break;
 806         case GPS_EVENT_ERR_CAUSE:
 807                 break;
 808         case GPS_EVENT_AGPS_VERIFICATION_INDI:
 809                 break;
 810         case GPS_EVENT_GET_IMSI:
 811                 break;
 812         case GPS_EVENT_GET_REF_LOCATION:
 813                 break;
 814         case GPS_EVENT_OPEN_DATA_CONNECTION: {
 815                 LOG_GPS(DBG_LOW, "<<::::::::::: GPS_EVENT_OPEN_DATA_CONNECTION :::::::::::::::");
 816                         result = _gps_server_open_data_connection(server);
 817                 }
 818                 break;
 819         case GPS_EVENT_CLOSE_DATA_CONNECTION: {
 820                 LOG_GPS(DBG_LOW, "<<::::::::::: GPS_EVENT_CLOSE_DATA_CONNECTION :::::::::::::::");
 821                 result = _gps_server_close_data_connection(server);
 822                 }
 823                 break;
 824         case GPS_EVENT_DNS_LOOKUP_IND:
 825                 LOG_GPS(DBG_LOW, "<<::::::::::: GPS_EVENT_DNS_LOOKUP_IND :::::::::::::::");
 826                 if (gps_event_info->event_data.dns_query_ind.error == GPS_ERR_NONE)
 827                         result = _gps_server_resolve_dns(gps_event_info->event_data.dns_query_ind.domain_name);
 828                 else
 829                         result = FALSE;
 830
 831                 if (result == TRUE)
 832                         LOG_GPS(DBG_LOW, "Success to get the DNS Query about [ %s ]", gps_event_info->event_data.dns_query_ind.domain_name);
 833
 834                 break;
 835         case GPS_EVENT_FACTORY_TEST:
 836                 LOG_GPS(DBG_LOW, "<<::::::::::: GPS_EVENT_FACTORY_TEST :::::::::::::::");
 837                 if (gps_event_info->event_data.factory_test_rsp.error == GPS_ERR_NONE) {
 838                         LOG_GPS(DBG_LOW, "[LBS server] Response Factory test result success");
 839                         _gps_server_send_facttest_result(gps_event_info->event_data.factory_test_rsp.snr,
 840                                                                                                  gps_event_info->event_data.factory_test_rsp.prn, TRUE);
 841                 } else {
 842                         LOG_GPS(DBG_ERR, "//[LBS server] Response Factory test result ERROR");
 843                         _gps_server_send_facttest_result(gps_event_info->event_data.factory_test_rsp.snr,
 844                                                                                                  gps_event_info->event_data.factory_test_rsp.prn, FALSE);
 845                 }
 846                 break;
 847         case GPS_EVENT_GEOFENCE_TRANSITION:
 848                 LOG_GPS(DBG_LOW, "<<::::::::::: GPS_EVENT_GEOFENCE_TRANSITION :::::::::::::::");
 849                 _report_geofence_transition(gps_event_info->event_data.geofence_transition_ind.geofence_id,
 850                                                                         gps_event_info->event_data.geofence_transition_ind.state,
 851                                                                         gps_event_info->event_data.geofence_transition_ind.pos.latitude,
 852                                                                         gps_event_info->event_data.geofence_transition_ind.pos.longitude,
 853                                                                         gps_event_info->event_data.geofence_transition_ind.pos.altitude,
 854                                                                         gps_event_info->event_data.geofence_transition_ind.pos.speed,
 855                                                                         gps_event_info->event_data.geofence_transition_ind.pos.bearing,
 856                                                                         gps_event_info->event_data.geofence_transition_ind.pos.hor_accuracy);
 857                 break;
 858         case GPS_EVENT_GEOFENCE_STATUS:
 859                 LOG_GPS(DBG_LOW, "<<::::::::::: GPS_EVENT_GEOFENCE_STATUS :::::::::::::::");
 860                 _report_geofence_service_status(gps_event_info->event_data.geofence_status_ind.status);
 861                 break;
 862         case GPS_EVENT_ADD_GEOFENCE:
 863                 LOG_GPS(DBG_LOW, "<<::::::::::: GPS_EVENT_ADD_GEOFENCE :::::::::::::::");
 864                 _gps_server_send_geofence_result(GEOFENCE_ADD_FENCE,
 865                                                                                  gps_event_info->event_data.geofence_event_rsp.geofence_id,
 866                                                                                  gps_event_info->event_data.geofence_event_rsp.error);
 867                 break;
 868         case GPS_EVENT_DELETE_GEOFENCE:
 869                 LOG_GPS(DBG_LOW, "<<::::::::::: GPS_EVENT_DELETE_GEOFENCE :::::::::::::::");
 870                 _gps_server_send_geofence_result(GEOFENCE_DELETE_FENCE,
 871                                                                                  gps_event_info->event_data.geofence_event_rsp.geofence_id,
 872                                                                                  gps_event_info->event_data.geofence_event_rsp.error);
 873                 break;
 874         case GPS_EVENT_PAUSE_GEOFENCE:
 875                 LOG_GPS(DBG_LOW, "<<::::::::::: GPS_EVENT_PAUSE_GEOFENCE :::::::::::::::");
 876                 _gps_server_send_geofence_result(GEOFENCE_PAUSE_FENCE,
 877                                                                                  gps_event_info->event_data.geofence_event_rsp.geofence_id,
 878                                                                                  gps_event_info->event_data.geofence_event_rsp.error);
 879                 break;
 880         case GPS_EVENT_RESUME_GEOFENCE:
 881                 LOG_GPS(DBG_LOW, "<<::::::::::: GPS_EVENT_RESUME_GEOFENCE :::::::::::::::");
 882                 _gps_server_send_geofence_result(GEOFENCE_RESUME_FENCE,
 883                                                                                  gps_event_info->event_data.geofence_event_rsp.geofence_id,
 884                                                                                  gps_event_info->event_data.geofence_event_rsp.error);
 885                 break;
 886         default:
 887                 LOG_GPS(DBG_WARN, "//Error: Isettingalid Event Type %d", gps_event_info->event_id);
 888                 break;
 889         }
 890         return result;
 891 }
 892
 893 #ifndef _TIZEN_PUBLIC_
 894 int request_supl_ni_session(const char *header, const char *body, int size)
 895 {
 896         agps_supl_ni_info_t info;
 897         gps_failure_reason_t reason_code;
 898
 899         info.msg_body = (char *)body;
 900         info.msg_size = size;
 901         info.status = TRUE;
 902
 903         if (!get_plugin_module()->request(GPS_ACTION_REQUEST_SUPL_NI, &info, &reason_code)) {
 904                 LOG_GPS(DBG_ERR, "Failed to request SUPL NI (code:%d)", reason_code);
 905                 return FALSE;
 906         }
 907
 908         return TRUE;
 909 }
 910 #else
 911 static void *request_supl_ni_session(void *data)
 912 {
 913         gps_ni_data_t *ni_data = (gps_ni_data_t *) data;
 914         agps_supl_ni_info_t info;
 915         gps_failure_reason_t reason_code;
 916
 917         info.msg_body = (char *)ni_data->msg_body;
 918         info.msg_size = ni_data->msg_size;
 919         info.status = TRUE;
 920
 921         if (!get_plugin_module()->request(GPS_ACTION_REQUEST_SUPL_NI, &info, &reason_code))
 922                 LOG_GPS(DBG_ERR, "Failed to request SUPL NI (code:%d)", reason_code);
 923
 924         free(ni_data);
 925
 926         return NULL;
 927 }
 928
 929 static void _gps_supl_networkinit_smscb(msg_handle_t hMsgHandle, msg_struct_t msg, void *user_param)
 930 {
 931         LOG_GPS(DBG_ERR, "_gps_supl_networkinit_smscb is called");
 932         gps_server_t *server = (gps_server_t *)user_param;
 933
 934         gps_ni_data_t *new_message = NULL;
 935
 936         new_message = (gps_ni_data_t *)malloc(sizeof(gps_ni_data_t));
 937         memset(new_message, 0x00, sizeof(gps_ni_data_t));
 938         msg_get_int_value(msg, MSG_MESSAGE_DATA_SIZE_INT, &new_message->msg_size);
 939         msg_get_str_value(msg, MSG_MESSAGE_SMS_DATA_STR, new_message->msg_body, new_message->msg_size);
 940
 941         pthread_attr_t attr;
 942         pthread_attr_init(&attr);
 943         pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
 944
 945         if (pthread_create(&server->popup_thread, &attr, request_supl_ni_session, new_message) != 0)
 946                 LOG_GPS(DBG_WARN, "Can not make pthread......");
 947 }
 948
 949 static void _gps_supl_networkinit_wappushcb(msg_handle_t hMsgHandle, const char *pPushHeader, const char *pPushBody,
 950                 int pushBodyLen, void *user_param)
 951 {
 952         gps_server_t *server = (gps_server_t *)user_param;
 953         char *str;
 954
 955         LOG_GPS(DBG_ERR, "_gps_supl_networkinit_wappushcb is called");
 956
 957         if (strstr(pPushHeader, "application/vnd.omaloc-supl-init") != NULL) {
 958                 str = strstr(pPushHeader, "X-Wap-Application-Id:");
 959
 960                 if (strncmp(str + 22, "x-oma-application:ulp.ua", 24) != 0) {
 961                         LOG_GPS(DBG_ERR, "Wrong Application-ID");
 962                         return;
 963                 }
 964         }
 965
 966         gps_ni_data_t *new_message = NULL;
 967
 968         new_message = (gps_ni_data_t *) malloc(sizeof(gps_ni_data_t));
 969         new_message->msg_body = (char *)pPushBody;
 970         new_message->msg_size = pushBodyLen;
 971
 972         pthread_attr_t attr;
 973         pthread_attr_init(&attr);
 974         pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
 975
 976         if (pthread_create(&server->popup_thread, &attr, request_supl_ni_session, new_message) != 0)
 977                 LOG_GPS(DBG_WARN, "Can not make pthread......");
 978 }
 979
 980 static void *_gps_register_msgfwcb(void *data)
 981 {
 982         gps_server_t *server = (gps_server_t *)data;
 983         msg_handle_t msgHandle = NULL;
 984         msg_error_t err = MSG_SUCCESS;
 985
 986         int setValue = 0;
 987         int ret;
 988
 989         int cnt = 60;
 990
 991         while (cnt > 0) {
 992                 ret = vconf_get_bool(VCONFKEY_MSG_SERVER_READY, &setValue);
 993
 994                 if (ret == -1) {
 995                         LOG_GPS(DBG_WARN, "Fail to get VCONFKEY_MSG_SERVER_READY");
 996                         return NULL;
 997                 }
 998
 999                 if (setValue) {
1000                         LOG_GPS(DBG_LOW, "MSG server is READY!!");
1001                         cnt = -1;
1002                 } else {
1003                         sleep(5);
1004                         cnt--;
1005                         if (cnt == 0) {
1006                                 LOG_GPS(DBG_WARN, "Never connect to MSG Server for 300 secs.");
1007                                 return NULL;
1008                         }
1009                 }
1010         }
1011
1012         err = msg_open_msg_handle(&msgHandle);
1013
1014         if (err != MSG_SUCCESS) {
1015                 LOG_GPS(DBG_WARN, "Fail to MsgOpenMsgHandle. Error type = [ %d ]", err);
1016                 return NULL;
1017         }
1018
1019         err = msg_reg_sms_message_callback(msgHandle, &_gps_supl_networkinit_smscb, 7275, (void *)server);
1020
1021         if (err != MSG_SUCCESS) {
1022                 LOG_GPS(DBG_WARN, "Fail to MsgRegSmsMessageCallback. Error type = [ %d ]", err);
1023                 return NULL;
1024         }
1025
1026         err = msg_reg_lbs_message_callback(msgHandle, &_gps_supl_networkinit_wappushcb, (void *)server);
1027
1028         if (err != MSG_SUCCESS) {
1029                 LOG_GPS(DBG_WARN, "Fail to MsgRegLBSMessageCallback. Error type = [ %d ]", err);
1030                 return NULL;
1031         }
1032
1033         LOG_GPS(DBG_LOW, "Success to lbs_register_msgfwcb");
1034         return NULL;
1035
1036 }
1037 #endif
1038
1039 static gps_server_t *_initialize_gps_data(void)
1040 {
1041         g_gps_server = (gps_server_t *) malloc(sizeof(gps_server_t));
1042         if (g_gps_server == NULL) {
1043                 LOG_GPS(DBG_ERR, "Failed to alloc g_gps_server");
1044                 return NULL;
1045         }
1046         memset(g_gps_server, 0x00, sizeof(gps_server_t));
1047
1048         g_gps_server->session_state = GPS_SESSION_STOPPED;
1049         g_gps_server->dnet_used = 0;
1050         g_gps_server->logging_enabled = FALSE;
1051         g_gps_server->replay_enabled = FALSE;
1052 #ifdef _TIZEN_PUBLIC_
1053         g_gps_server->msg_thread = 0;
1054         g_gps_server->popup_thread = 0;
1055 #endif
1056
1057         memset(&g_gps_server->gps_plugin, 0x00, sizeof(gps_plugin_handler_t));
1058
1059         if (g_gps_server->pos_data == NULL) {
1060                 g_gps_server->pos_data = (pos_data_t *) malloc(sizeof(pos_data_t));
1061                 if (g_gps_server->pos_data == NULL) {
1062                         LOG_GPS(DBG_ERR, "Failed to alloc g_gps_server->pos_data");
1063                         return NULL;
1064                 } else {
1065                         memset(g_gps_server->pos_data, 0x00, sizeof(pos_data_t));
1066                 }
1067         }
1068
1069         if (g_gps_server->batch_data == NULL) {
1070                 g_gps_server->batch_data = (batch_data_t *) malloc(sizeof(batch_data_t));
1071                 if (g_gps_server->batch_data == NULL) {
1072                         LOG_GPS(DBG_ERR, "Failed to alloc g_gps_server->batch_data");
1073                         return NULL;
1074                 } else {
1075                         memset(g_gps_server->batch_data, 0x00, sizeof(batch_data_t));
1076                 }
1077         }
1078
1079         if (g_gps_server->sv_data == NULL) {
1080                 g_gps_server->sv_data = (sv_data_t *) malloc(sizeof(sv_data_t));
1081                 if (g_gps_server->sv_data == NULL) {
1082                         LOG_GPS(DBG_ERR, "Failed to alloc g_gps_server->sv_data");
1083                         return NULL;
1084                 } else {
1085                         memset(g_gps_server->sv_data, 0x00, sizeof(sv_data_t));
1086                 }
1087         }
1088
1089         if (g_gps_server->nmea_data == NULL) {
1090                 g_gps_server->nmea_data = (nmea_data_t *) malloc(sizeof(nmea_data_t));
1091                 if (g_gps_server->nmea_data == NULL) {
1092                         LOG_GPS(DBG_ERR, "Failed to alloc g_gps_server->nmea_data");
1093                         return NULL;
1094                 } else {
1095                         memset(g_gps_server->nmea_data, 0x00, sizeof(nmea_data_t));
1096                 }
1097         }
1098
1099         return g_gps_server;
1100 }
1101
1102 static void _deinitialize_gps_data(void)
1103 {
1104         if (g_gps_server == NULL) return;
1105
1106         if (g_gps_server->pos_data != NULL) {
1107                 free(g_gps_server->pos_data);
1108                 g_gps_server->pos_data = NULL;
1109         }
1110
1111         if (g_gps_server->batch_data != NULL) {
1112                 free(g_gps_server->batch_data);
1113                 g_gps_server->batch_data = NULL;
1114         }
1115
1116         if (g_gps_server->sv_data != NULL) {
1117                 free(g_gps_server->sv_data);
1118                 g_gps_server->sv_data = NULL;
1119         }
1120
1121         if (g_gps_server->nmea_data != NULL) {
1122                 if (g_gps_server->nmea_data->data != NULL) {
1123                         free(g_gps_server->nmea_data->data);
1124                         g_gps_server->nmea_data->data = NULL;
1125                 }
1126                 free(g_gps_server->nmea_data);
1127                 g_gps_server->nmea_data = NULL;
1128         }
1129
1130         free(g_gps_server);
1131         g_gps_server = NULL;
1132 }
1133
1134 int initialize_server(int argc, char **argv)
1135 {
1136         LOG_FUNC;
1137
1138         gps_server_t *server;
1139
1140         server = _initialize_gps_data();
1141         if (server == NULL)
1142                 return -1;
1143
1144         _gps_get_nmea_replay_mode(server);
1145         _gps_notify_params(server);
1146
1147         if (!load_plugin_module(server->replay_enabled, &server->gps_plugin.handle)) {
1148                 LOG_GPS(DBG_ERR, "Fail to load plugin module.");
1149                 return -1;
1150         }
1151
1152         if (!get_plugin_module()->init(_gps_server_gps_event_cb, (void *)server)) {
1153                 LOG_GPS(DBG_WARN, "Fail to gps module initialization");
1154                 return -1;
1155         }
1156
1157 #ifdef _TIZEN_PUBLIC_
1158         if (pthread_create(&g_gps_server->msg_thread, NULL, _gps_register_msgfwcb, g_gps_server) != 0)
1159                 LOG_GPS(DBG_WARN, "Can not make pthread......");
1160 #endif
1161
1162         LOG_GPS(DBG_LOW, "Initialization-gps is completed.");
1163
1164         if (!nps_load_plugin_module(&g_nps_plugin.handle)) {
1165                 LOG_NPS(DBG_ERR, "Fail to load lbs_server_NPS plugin module.");
1166                 __nps_plugin_handler_deinit();
1167                 return 0; /* TBD: how to deal with this error situation */
1168         }
1169
1170         LOG_NPS(DBG_LOW, "Initialization-nps is completed.");
1171
1172         return 0;
1173 }
1174
1175 int deinitialize_server()
1176 {
1177         gps_failure_reason_t ReasonCode = GPS_FAILURE_CAUSE_NORMAL;
1178
1179 #ifdef _TIZEN_PUBLIC_
1180         pthread_join(g_gps_server->msg_thread, (void *)&g_gps_server->msg_thread_status);
1181 #endif
1182
1183         _gps_ignore_params();
1184
1185         if (!get_plugin_module()->deinit(&ReasonCode))
1186                 LOG_GPS(DBG_WARN, "Fail to gps module de-initialization");
1187
1188         unload_plugin_module(g_gps_server->gps_plugin.handle);
1189
1190         _gps_plugin_handler_deinit(g_gps_server);
1191         _deinitialize_gps_data();
1192
1193         nps_unload_plugin_module(g_nps_plugin.handle);
1194         __nps_plugin_handler_deinit();
1195
1196         return 0;
1197 }
1198
1199 int register_update_callbacks(struct gps_callbacks *gps_callback, void *user_data)
1200 {
1201         g_update_cb = *gps_callback;
1202         g_user_data = user_data;
1203         return 0;
1204 }