Change interval table to support fused location

Change-Id: I537354b6f8024b59ab1eac641af77a1ad6ab28de
Signed-off-by: kj7.sung <kj7.sung@samsung.com>

diff --git a/lbs-server/src/fused.c b/lbs-server/src/fused.c
index fe7fc26..b6c2f6c 100644 (file)
--- a/lbs-server/src/fused.c
+++ b/lbs-server/src/fused.c
@@ -242,7 +242,7 @@ void location_fused_deinit()
 void send_gps_position_to_fused_engine(time_t timestamp, double latitude, double longitude, double altitude,
                double speed, double bearing, double hor_accuracy, double ver_accuracy)
 {
-       LOG_FUSED_FUNC;
+//     LOG_FUSED_FUNC;
 
        LocationPosition *pos = location_position_new(timestamp, latitude, longitude, altitude, LOCATION_STATUS_3D_FIX);
        LocationVelocity *vel = location_velocity_new(timestamp, speed, bearing, 0.0);
@@ -279,7 +279,7 @@ void send_wps_position_to_fused_engine(time_t timestamp, double latitude, double
 
 static void on_engine_position(const fl_position_4d* position, gpointer user_data)
 {
-       LOG_FUSED_FUNC;
+//     LOG_FUSED_FUNC;
 
        fused_engine_get_location(&fused.last_location.pos, &fused.last_location.vel, &fused.last_location.sigma);
 

diff --git a/lbs-server/src/lbs_server.c b/lbs-server/src/lbs_server.c
index 0f26aa4..fe9352f 100644 (file)
--- a/lbs-server/src/lbs_server.c
+++ b/lbs-server/src/lbs_server.c
@@ -58,6 +58,7 @@ typedef struct {
 
        gboolean is_gps_running;
        gint gps_client_count;
+       guint now_gps_interval;
 
        /* nps variables */
        NpsManagerHandle nps_handle;
@@ -77,10 +78,11 @@ typedef struct {
        LbsStatus status;
 
        /* dynamic interval update */
-       GHashTable *dynamic_interval_table;
+       GHashTable *gps_interval_table;
+       GHashTable *fused_interval_table;
        guint *optimized_interval;
        guint temp_minimum_interval;
-       gboolean is_needed_changing_interval;
+       gboolean is_changing_gps_interval;
 #ifndef TIZEN_DEVICE
        GHashTable *batch_interval_table;
        guint *optimized_batch_array;
@@ -96,16 +98,11 @@ typedef struct {
 
        /* fused variables */
        gint fused_high_count;
-       gint fused_balanced_count;
+       gint fused_balance_count;
        gboolean is_fused_running;
        gint current_location_source;
 } lbs_server_s;
 
-typedef struct {
-       lbs_server_s *lbs_server;
-       int method;
-} dynamic_interval_updator_user_data;
-
 #ifndef TIZEN_DEVICE
 typedef enum {
        LBS_BATCH_INTERVAL = 0,
@@ -450,10 +447,11 @@ static void __nps_cancel_callback(void *arg)
 
 static gboolean location_source_selector(lbs_server_s *lbs_server, gint fused_mode);
 static void plugin_status_controller(lbs_server_s *lbs_server);
+static void request_plugin_interval(lbs_server_s *lbs_server);
 
 static void start_tracking(lbs_server_s *lbs_server, lbs_server_method_e method, gint fused_mode)
 {
-       LOG_GPS(DBG_LOW, ">>> start_tracking");
+       LOG_GPS(DBG_LOW, ">>> start tracking");
 
        switch (method) {
        case LBS_SERVER_METHOD_GPS:
@@ -462,7 +460,7 @@ static void start_tracking(lbs_server_s *lbs_server, lbs_server_method_e method,
                if (lbs_server->is_mock_running != MOCK_RUNNING_OFF && lbs_server->is_gps_running == FALSE && lbs_server->is_nps_running == FALSE)
                        mock_start_tracking(lbs_server);
 
-               if (location_source_selector(lbs_server, fused_mode) == TRUE)
+               if (location_source_selector(lbs_server, fused_mode))
                        plugin_status_controller(lbs_server);
 
                break;
@@ -473,7 +471,7 @@ static void start_tracking(lbs_server_s *lbs_server, lbs_server_method_e method,
                if (lbs_server->is_mock_running != MOCK_RUNNING_OFF && lbs_server->is_gps_running == FALSE && lbs_server->is_nps_running == FALSE)
                        mock_start_tracking(lbs_server);
 
-               if (location_source_selector(lbs_server, fused_mode) == TRUE)
+               if (location_source_selector(lbs_server, fused_mode))
                        plugin_status_controller(lbs_server);
 
                if (nps_is_dummy_plugin_module() != TRUE)
@@ -487,9 +485,12 @@ static void start_tracking(lbs_server_s *lbs_server, lbs_server_method_e method,
                break;
 
        default:
-               LOG_GPS(DBG_LOW, "start_tracking Invalid");
+               LOG_GPS(DBG_LOW, "start tracking Invalid");
                break;
        }
+
+       if (method == LBS_SERVER_METHOD_GPS || method == LBS_SERVER_METHOD_NPS)
+               request_plugin_interval(lbs_server);
 }
 
 static gboolean nps_plugin_stop(lbs_server_s *lbs_server)
@@ -530,14 +531,14 @@ static void stop_tracking(lbs_server_s *lbs_server, lbs_server_method_e method,
        LOG_FUNC;
        switch (method) {
        case LBS_SERVER_METHOD_GPS:
-               LOG_GPS(DBG_LOW, "stop_tracking GPS [client: %d]", lbs_server->gps_client_count);
+               LOG_GPS(DBG_LOW, "stop tracking GPS [client: %d]", lbs_server->gps_client_count);
 
                if (lbs_server->is_mock_running == MOCK_RUNNING_OFF)
                        gps_set_last_position(&lbs_server->position);
 
                client_count_updater(lbs_server, LBS_SERVER_METHOD_GPS, _LBS_CLIENT_REMOVE, fused_mode);
 
-               if (location_source_selector(lbs_server, fused_mode) == TRUE)
+               if (location_source_selector(lbs_server, fused_mode))
                        plugin_status_controller(lbs_server);
 
                if (lbs_server->is_gps_running == FALSE) {
@@ -551,7 +552,7 @@ static void stop_tracking(lbs_server_s *lbs_server, lbs_server_method_e method,
 
                client_count_updater(lbs_server, LBS_SERVER_METHOD_NPS, _LBS_CLIENT_REMOVE, fused_mode);
 
-               if (location_source_selector(lbs_server, fused_mode) == TRUE)
+               if (location_source_selector(lbs_server, fused_mode))
                        plugin_status_controller(lbs_server);
 
                break;
@@ -560,9 +561,12 @@ static void stop_tracking(lbs_server_s *lbs_server, lbs_server_method_e method,
                break;
 
        default:
-               LOG_GPS(DBG_LOW, "stop_tracking Invalid");
+               LOG_GPS(DBG_LOW, "stop tracking Invalid");
                break;
        }
+
+       if (method == LBS_SERVER_METHOD_GPS || method == LBS_SERVER_METHOD_NPS)
+               request_plugin_interval(lbs_server);
 }
 
 static gboolean _set_current_location_source(lbs_server_s *lbs_server, gint mode)
@@ -575,6 +579,53 @@ static gboolean _set_current_location_source(lbs_server_s *lbs_server, gint mode
        return FALSE;
 }
 
+static gboolean __get_fused_interval_control(lbs_server_s *lbs_server)
+{
+       /* Activate fused combine interval when all clients are fused */
+       gint pure_gps_count = lbs_server->gps_client_count - lbs_server->fused_high_count;
+       if (pure_gps_count == 0 && lbs_server->fused_balance_count > 0)
+               return TRUE;
+
+       return FALSE;
+}
+
+static gboolean select_location_source(lbs_server_s *lbs_server)
+{
+       /*********************************************************************************
+                Define all condition to select optimized location source
+               gps, high ==>     1(gps0, high0) 2(gps3, high0) 3(gps3, high1) 4(gps3, high3)
+               wps, balance ==>  A(wps0, bal0)  B(wps3, bal0)  C(wps3, bal1)  D(wps3, bal3)
+
+               LOCATION_SOURCE_GPS  : 2A, 2D, 3A, 3D, 4A, 4D
+               LOCATION_SOURCE_WPS  : 1B, 1C, 1D
+               LOCATION_SOURCE_BOTH : 2B, 2C, 3B, 2C, 4B, 4C
+               LOCATION_SOURCE_NONE : 1A
+       *********************************************************************************/
+
+       gint pure_wps_count = lbs_server->nps_client_count - lbs_server->fused_balance_count;
+
+       if (lbs_server->gps_client_count > 0) {         /* case 2, 3, 4 */
+
+               if (lbs_server->nps_client_count > 0) {
+                       if (pure_wps_count > 0) {                       /* 2B, 2C, 3B, 3C, 4B, 4C */
+                               if (_set_current_location_source(lbs_server, LOCATION_SOURCE_BOTH)) return TRUE;
+                       } else {                                                        /* 2D, 3D, 4D */
+                               if (_set_current_location_source(lbs_server, LOCATION_SOURCE_GPS)) return TRUE;
+                       }
+               } else {                                                                /* 2A, 3A, 4A */
+                       if (_set_current_location_source(lbs_server, LOCATION_SOURCE_GPS)) return TRUE;
+               }
+
+       } else {                                                                        /* case 1*/
+               if (lbs_server->nps_client_count > 0) { /* 1B, 1C, 1D */
+                       if (_set_current_location_source(lbs_server, LOCATION_SOURCE_WPS)) return TRUE;
+               } else {                                                                /* 1A */
+                       if (_set_current_location_source(lbs_server, LOCATION_SOURCE_NONE)) return TRUE;
+               }
+       }
+       return FALSE;
+}
+
 static gboolean location_source_selector(lbs_server_s *lbs_server, gint fused_mode)
 {
        LOG_FUSED_FUNC;
@@ -585,8 +636,8 @@ static gboolean location_source_selector(lbs_server_s *lbs_server, gint fused_mo
 
        /* set fused running status */
        if (fused_mode == LOCATION_FUSED_HIGH || fused_mode == LOCATION_FUSED_BALANCED) {
-               if (lbs_server->fused_high_count == 0 && lbs_server->fused_balanced_count == 0) {
-                       LOG_GPS(DBG_LOW, "-- Checking to stop fused mode");
+               if (lbs_server->fused_high_count == 0 && lbs_server->fused_balance_count == 0) {
+                       LOG_GPS(DBG_LOW, "[FUSED] Need to stop fused mode");
                        if (lbs_server->is_fused_running) {
                                g_mutex_lock(&lbs_server->mutex);
                                lbs_server->is_fused_running = FALSE;
@@ -595,7 +646,7 @@ static gboolean location_source_selector(lbs_server_s *lbs_server, gint fused_mo
                                location_fused_stop();
                        }
                } else {
-                       LOG_GPS(DBG_LOW, "-- Checking to start fused mode");
+                       LOG_GPS(DBG_LOW, "[FUSED] Need to start fused mode");
                        if (lbs_server->is_fused_running == FALSE) {
                                g_mutex_lock(&lbs_server->mutex);
                                lbs_server->is_fused_running = TRUE;
@@ -604,54 +655,10 @@ static gboolean location_source_selector(lbs_server_s *lbs_server, gint fused_mo
                                location_fused_start();
                        }
                }
-
-#if 0
-               /* set fused_optimized_mode */
-               if (lbs_server->fused_high_count == 0 || lbs_server->fused_balanced_count == 0)
-                       lbs_server->fused_optimized_mode = LOCATION_FUSED_NONE;
-               else if (lbs_server->fused_high_count > 0)
-                       lbs_server->fused_optimized_mode = LOCATION_FUSED_HIGH;
-               else if (lbs_server->fused_high_count == 0 && lbs_server->fused_balanced_count > 0)
-                       lbs_server->fused_optimized_mode = LOCATION_FUSED_BALANCED;
-               else
-                       lbs_server->fused_optimized_mode = LOCATION_FUSED_NONE;
-
-               LOG_GPS(DBG_LOW, "fused_optimized_mode [high: %d, balanced: %d, mode: %d]",
-                       lbs_server->fused_high_count, lbs_server->fused_balanced_count, lbs_server->fused_optimized_mode);
-#endif
        }
 
-       /* Define all condition to select optimized location source
-               gps, high ==>     1(gps0, high0) 2(gps3, high0) 3(gps3, high1) 4(gps3, high3)
-               wps, balance ==>  A(wps0, bal0)  B(wps3, bal0)  C(wps3, bal1)  D(wps3, bal3)
-
-               LOCATION_SOURCE_GPS  : 2A, 2D, 3A, 3D, 4A, 4D
-               LOCATION_SOURCE_WPS  : 1B, 1C, 1D
-               LOCATION_SOURCE_BOTH : 2B, 2C, 3B, 2C, 4B, 4C
-               LOCATION_SOURCE_NONE : 1A
-       */
-
-       gint pure_wps_count = lbs_server->nps_client_count - lbs_server->fused_balanced_count;
-
-       if (lbs_server->gps_client_count > 0) {         /* case 2, 3, 4 */
-
-               if (lbs_server->nps_client_count > 0) {
-                       if (pure_wps_count > 0) {                       /* 2B, 2C, 3B, 3C, 4B, 4C */
-                               if (_set_current_location_source(lbs_server, LOCATION_SOURCE_BOTH) == TRUE) return TRUE;
-                       } else {                                                        /* 2D, 3D, 4D */
-                               if (_set_current_location_source(lbs_server, LOCATION_SOURCE_GPS) == TRUE) return TRUE;
-                       }
-               } else {                                                                /* 2A, 3A, 4A */
-                       if (_set_current_location_source(lbs_server, LOCATION_SOURCE_GPS) == TRUE) return TRUE;
-               }
-
-       } else {                                                                        /* case 1*/
-               if (lbs_server->nps_client_count > 0) { /* 1B, 1C, 1D */
-                       if (_set_current_location_source(lbs_server, LOCATION_SOURCE_WPS) == TRUE) return TRUE;
-               } else {                                                                /* 1A */
-                       if (_set_current_location_source(lbs_server, LOCATION_SOURCE_NONE) == TRUE) return TRUE;
-               }
-       }
+       if (select_location_source(lbs_server))
+               return TRUE;
 
        return FALSE;
 }
@@ -667,12 +674,12 @@ static gboolean gps_plugin_start(lbs_server_s *lbs_server)
 
        lbs_server->status = LBS_STATUS_ACQUIRING;
 
-       if (request_start_session((int)(lbs_server->optimized_interval[LBS_SERVER_METHOD_GPS])) == TRUE) {
+       if (request_start_session((int)(lbs_server->optimized_interval[LBS_SERVER_METHOD_GPS]))) {
                g_mutex_lock(&lbs_server->mutex);
                lbs_server->is_gps_running = TRUE;
                g_mutex_unlock(&lbs_server->mutex);
 
-               lbs_server->is_needed_changing_interval = FALSE;
+               lbs_server->is_changing_gps_interval = FALSE;
                setting_notify_key_changed(VCONFKEY_LOCATION_ENABLED, __setting_gps_cb, lbs_server);
        } else {
                LOG_GPS(DBG_ERR, "Failed to request_start_session");
@@ -688,7 +695,7 @@ static gboolean gps_plugin_stop(lbs_server_s *lbs_server)
                return FALSE;
        }
 
-       if (request_stop_session() == TRUE) {
+       if (request_stop_session()) {
                lbs_server->is_gps_running = FALSE;
                lbs_server->sv_used = FALSE;
                setting_ignore_key_changed(VCONFKEY_LOCATION_ENABLED, __setting_gps_cb);
@@ -731,7 +738,7 @@ static void plugin_status_controller(lbs_server_s *lbs_server)
 {
        LOG_FUNC;
        if (lbs_server->current_location_source == LOCATION_SOURCE_GPS) {
-               LOG_FUSED(DBG_LOW, ">>> LOCATION_SOURCE_GPS");
+               LOG_FUSED(DBG_LOW, "-->> LOCATION_SOURCE_GPS");
                if (lbs_server->is_gps_running == FALSE)
                        gps_plugin_start(lbs_server);
 
@@ -739,7 +746,7 @@ static void plugin_status_controller(lbs_server_s *lbs_server)
                        nps_plugin_stop(lbs_server);
 
        } else if (lbs_server->current_location_source == LOCATION_SOURCE_WPS) {
-               LOG_FUSED(DBG_LOW, ">>> LOCATION_SOURCE_WPS");
+               LOG_FUSED(DBG_LOW, "-->> LOCATION_SOURCE_WPS");
                if (lbs_server->is_gps_running)
                        gps_plugin_stop(lbs_server);
 
@@ -747,7 +754,7 @@ static void plugin_status_controller(lbs_server_s *lbs_server)
                        nps_plugin_start(lbs_server);
 
        } else if (lbs_server->current_location_source == LOCATION_SOURCE_BOTH) {
-               LOG_FUSED(DBG_LOW, ">>> LOCATION_SOURCE_BOTH");
+               LOG_FUSED(DBG_LOW, "-->> LOCATION_SOURCE_BOTH");
                if (lbs_server->is_gps_running == FALSE)
                        gps_plugin_start(lbs_server);
 
@@ -755,7 +762,7 @@ static void plugin_status_controller(lbs_server_s *lbs_server)
                        nps_plugin_start(lbs_server);
 
        } else if (lbs_server->current_location_source == LOCATION_SOURCE_NONE) {
-               LOG_FUSED(DBG_LOW, ">>> LOCATION_SOURCE_NONE");
+               LOG_FUSED(DBG_LOW, "-->> LOCATION_SOURCE_NONE");
                if (lbs_server->is_gps_running)
                        gps_plugin_stop(lbs_server);
 
@@ -764,10 +771,6 @@ static void plugin_status_controller(lbs_server_s *lbs_server)
        }
 }
 
-/*
-*  manipulate the dynamic_interval_table.
-*/
-
 static void find_min_interval_foreach_cb(gpointer key, gpointer value, gpointer userdata)
 {
        lbs_server_s *lbs_server = (lbs_server_s *)userdata;
@@ -777,11 +780,10 @@ static void find_min_interval_foreach_cb(gpointer key, gpointer value, gpointer
                lbs_server->temp_minimum_interval = interval;
 }
 
-static void update_dynamic_interval_table_foreach_cb(gpointer key, gpointer value, gpointer userdata)
+static void update_interval_table_foreach_cb(gpointer key, gpointer value, gpointer userdata)
 {
        GHashTable *interval_table = (GHashTable *) value;
-       dynamic_interval_updator_user_data *updator_ud = (dynamic_interval_updator_user_data *)userdata;
-       lbs_server_s *lbs_server = updator_ud->lbs_server;
+       lbs_server_s *lbs_server = (lbs_server_s *) userdata;
 
        g_hash_table_foreach(interval_table, (GHFunc) find_min_interval_foreach_cb, (gpointer) lbs_server);
        LOG_GPS(DBG_LOW, "foreach_cb, client:[%s] temp_min[%u], hash_size[%u]", (char *)key, lbs_server->temp_minimum_interval, g_hash_table_size(interval_table));
@@ -821,9 +823,9 @@ static void __update_interval_table(GHashTable *interval_table, guint interval,
        __add_interval_table(interval_table, interval);
 }
 
-static gboolean update_pos_tracking_interval(lbs_server_interval_manipulation_type type, const gchar *client, int method, guint interval, guint prev_interval, gpointer userdata)
+static gboolean update_gps_tracking_interval(lbs_server_interval_manipulation_type type, const gchar *client, int method, guint interval, guint prev_interval, gpointer userdata)
 {
-       LOG_GPS(DBG_LOW, ">>> update_pos_tracking_interval");
+       LOG_GPS(DBG_LOW, ">>> update gps_tracking_interval");
        if (userdata == NULL) return FALSE;
        if (client == NULL) {
                LOG_GPS(DBG_ERR, "client is NULL");
@@ -842,7 +844,7 @@ static gboolean update_pos_tracking_interval(lbs_server_interval_manipulation_ty
                        gchar *client_cpy = NULL;
                        client_cpy = g_strdup(client);
 
-                       GHashTable *interval_table = (GHashTable *) g_hash_table_lookup(lbs_server->dynamic_interval_table, client_cpy);
+                       GHashTable *interval_table = (GHashTable *) g_hash_table_lookup(lbs_server->gps_interval_table, client_cpy);
                        LOG_GPS(DBG_LOW, "ADD, interval[%u], client[%s], interval_table(%p)", interval, client, interval_table);
                        if (interval_table) {
                                __add_interval_table(interval_table, interval);
@@ -851,23 +853,22 @@ static gboolean update_pos_tracking_interval(lbs_server_interval_manipulation_ty
                                LOG_GPS(DBG_LOW, "create gps hash_table to add first key[%s]", client);
                                interval_table = g_hash_table_new(g_direct_hash, g_direct_equal);
                                g_hash_table_insert(interval_table, GUINT_TO_POINTER(interval), GUINT_TO_POINTER(1));
-                               g_hash_table_insert(lbs_server->dynamic_interval_table, (gpointer) client_cpy, (gpointer) interval_table);
+                               g_hash_table_insert(lbs_server->gps_interval_table, (gpointer) client_cpy, (gpointer) interval_table);
                        }
 
-                       LOG_GPS(DBG_LOW, "ADD, done");
                        break;
                }
 
                case LBS_SERVER_INTERVAL_REMOVE: {
-                       GHashTable *interval_table = (GHashTable *) g_hash_table_lookup(lbs_server->dynamic_interval_table, client);
+                       GHashTable *interval_table = (GHashTable *) g_hash_table_lookup(lbs_server->gps_interval_table, client);
                        LOG_GPS(DBG_LOW, "REMOVE, interval[%u, %u] , client[%s], interval_table(%p)", interval, prev_interval, client, interval_table);
                        if (interval_table) {
                                if ((interval == 0) && (prev_interval == 0)) {
                                        LOG_GPS(DBG_INFO, "client[%s] removed by force.", client);
                                        g_hash_table_remove_all(interval_table);
                                        g_hash_table_destroy(interval_table);
-                                       if (g_hash_table_contains(lbs_server->dynamic_interval_table, client)) {
-                                               if (g_hash_table_remove(lbs_server->dynamic_interval_table, client) != TRUE)
+                                       if (g_hash_table_contains(lbs_server->gps_interval_table, client)) {
+                                               if (g_hash_table_remove(lbs_server->gps_interval_table, client) != TRUE)
                                                        LOG_GPS(DBG_LOW, "g_hash_table_remove is failed.");
                                        }
                                        break;
@@ -880,21 +881,19 @@ static gboolean update_pos_tracking_interval(lbs_server_interval_manipulation_ty
                        }
 
                        if (g_hash_table_size(interval_table) == 0) {
-                               LOG_GPS(DBG_LOW, "Remove client[%s] from dynamic_interval_table", client);
+                               LOG_GPS(DBG_LOW, "Remove client[%s] from gps_interval_table", client);
                                g_hash_table_destroy(interval_table);
-                               if (g_hash_table_contains(lbs_server->dynamic_interval_table, client)) {
-                                       if (g_hash_table_remove(lbs_server->dynamic_interval_table, client) != TRUE)
+                               if (g_hash_table_contains(lbs_server->gps_interval_table, client)) {
+                                       if (g_hash_table_remove(lbs_server->gps_interval_table, client) != TRUE)
                                                LOG_GPS(DBG_LOW, "g_hash_table_remove is failed.");
                                }
                        }
 
-                       LOG_GPS(DBG_LOW, "REMOVE, done.");
-
                        break;
                }
 
                case LBS_SERVER_INTERVAL_UPDATE: {
-                       GHashTable *interval_table = (GHashTable *) g_hash_table_lookup(lbs_server->dynamic_interval_table, client);
+                       GHashTable *interval_table = (GHashTable *) g_hash_table_lookup(lbs_server->gps_interval_table, client);
                        LOG_GPS(DBG_LOW, "UPDATE, interval[%u -> %u], client[%s], interval_table(%p)", prev_interval, interval, client, interval_table);
                        if (interval_table) {
                                __update_interval_table(interval_table, interval, prev_interval);
@@ -913,34 +912,29 @@ static gboolean update_pos_tracking_interval(lbs_server_interval_manipulation_ty
        }
 
        /* update logic for optimized-interval value */
-       if (g_hash_table_size(lbs_server->dynamic_interval_table) == 0) {
-               LOG_GPS(DBG_LOW, "dynamic_interval_table size is zero. It will be updated all value as 0");
-               lbs_server->is_needed_changing_interval = FALSE;
+       if (g_hash_table_size(lbs_server->gps_interval_table) == 0) {
+               LOG_GPS(DBG_LOW, "gps_interval_table size = 0. optimized_interval[all] = 0");
+               lbs_server->is_changing_gps_interval = FALSE;
                int i = 0;
                for (i = 0; i < LBS_SERVER_METHOD_SIZE; i++)
                        lbs_server->optimized_interval[i] = 0;
 
                ret_val = FALSE;
        } else {
-               LOG_GPS(DBG_LOW, "update dynamic_interval_table");
-               dynamic_interval_updator_user_data updator_user_data;
-               updator_user_data.lbs_server = lbs_server;
-               updator_user_data.method = method;
-
                lbs_server->temp_minimum_interval = MAX_INTERVAL;
-               g_hash_table_foreach(lbs_server->dynamic_interval_table, (GHFunc) update_dynamic_interval_table_foreach_cb, (gpointer) &updator_user_data);
+               g_hash_table_foreach(lbs_server->gps_interval_table, (GHFunc) update_interval_table_foreach_cb, (gpointer) lbs_server);
 
-               if (lbs_server->optimized_interval[method] != lbs_server->temp_minimum_interval) {
-                       LOG_GPS(DBG_INFO, "Changing method[GPS]'s optimized_interval value %u -> [ %u ]",
-                                       lbs_server->optimized_interval[method], lbs_server->temp_minimum_interval);
-                       lbs_server->optimized_interval[method] = lbs_server->temp_minimum_interval;
+               if (lbs_server->optimized_interval[LBS_SERVER_METHOD_GPS] != lbs_server->temp_minimum_interval) {
+                       LOG_GPS(DBG_INFO, "[Update logic] Changing optimized_interval[GPS]  %u -> [ %u ]",
+                                       lbs_server->optimized_interval[LBS_SERVER_METHOD_GPS], lbs_server->temp_minimum_interval);
+                       lbs_server->optimized_interval[LBS_SERVER_METHOD_GPS] = lbs_server->temp_minimum_interval;
 
                        /* need to send message to provider device */
-                       LOG_GPS(DBG_LOW, "--> set needed_changing_interval");
-                       lbs_server->is_needed_changing_interval = TRUE;
+                       LOG_GPS(DBG_LOW, "--> set is_changing_gps_interva to TRUE");
+                       lbs_server->is_changing_gps_interval = TRUE;
                }
 
-               if (lbs_server->is_needed_changing_interval)
+               if (lbs_server->is_changing_gps_interval)
                        ret_val = TRUE;
                else
                        ret_val = FALSE;
@@ -948,6 +942,96 @@ static gboolean update_pos_tracking_interval(lbs_server_interval_manipulation_ty
        return ret_val;
 }
 
+static gboolean update_fused_tracking_interval(lbs_server_interval_manipulation_type type, const gchar *client, int method, guint interval, guint prev_interval, gpointer userdata)
+{
+       LOG_FUSED(DBG_LOW, "[FUSED] >>> update fused_tracking_interval");
+       if (userdata == NULL) return FALSE;
+       if (client == NULL) {
+               LOG_FUSED(DBG_ERR, "client is NULL");
+               return FALSE;
+       }
+
+       if (method != LBS_SERVER_METHOD_GPS && method != LBS_SERVER_METHOD_NPS)
+               return FALSE;
+
+       gboolean ret_val = FALSE;
+       lbs_server_s *lbs_server = (lbs_server_s *)userdata;
+
+       /* manipulate logic for dynamic-interval hash table */
+       switch (type) {
+               case LBS_SERVER_INTERVAL_ADD: {
+                       gchar *client_cpy = NULL;
+                       client_cpy = g_strdup(client);
+
+                       GHashTable *interval_table = (GHashTable *) g_hash_table_lookup(lbs_server->fused_interval_table, client_cpy);
+                       LOG_FUSED(DBG_LOW, "[FUSED] ADD, interval[%u], client[%s], interval_table(%p)", interval, client, interval_table);
+                       if (interval_table) {
+                               __add_interval_table(interval_table, interval);
+                               g_free(client_cpy);
+                       } else {
+                               LOG_FUSED(DBG_LOW, "[FUSED] create client hash_table to add first key[%s]", client);
+                               interval_table = g_hash_table_new(g_direct_hash, g_direct_equal);
+                               g_hash_table_insert(interval_table, GUINT_TO_POINTER(interval), GUINT_TO_POINTER(1));
+                               g_hash_table_insert(lbs_server->fused_interval_table, (gpointer) client_cpy, (gpointer) interval_table);
+                       }
+                       break;
+               }
+
+               case LBS_SERVER_INTERVAL_REMOVE: {
+                       GHashTable *interval_table = (GHashTable *) g_hash_table_lookup(lbs_server->fused_interval_table, client);
+                       LOG_FUSED(DBG_LOW, "[FUSED] REMOVE, interval[%u, %u] , client[%s], interval_table(%p)", interval, prev_interval, client, interval_table);
+                       if (interval_table) {
+                               __remove_interval_table(interval_table, interval);
+                       } else {
+                               LOG_FUSED(DBG_INFO, "[FUSED] client[%s] method[%d] is already removed from interval-table", client, method);
+                               break;
+                       }
+
+                       if (g_hash_table_size(interval_table) == 0) {
+                               LOG_FUSED(DBG_LOW, "[FUSED] Remove client[%s] from fused_interval_table", client);
+                               g_hash_table_destroy(interval_table);
+                               if (g_hash_table_contains(lbs_server->fused_interval_table, client)) {
+                                       if (g_hash_table_remove(lbs_server->fused_interval_table, client) != TRUE)
+                                               LOG_FUSED(DBG_LOW, "g_hash_table_remove is failed.");
+                               }
+                       }
+                       break;
+               }
+
+               case LBS_SERVER_INTERVAL_UPDATE: {
+                       GHashTable *interval_table = (GHashTable *) g_hash_table_lookup(lbs_server->fused_interval_table, client);
+                       LOG_FUSED(DBG_LOW, "[FUSED] UPDATE, interval[%u -> %u], client[%s], interval_table(%p)", prev_interval, interval, client, interval_table);
+                       if (interval_table) {
+                               __update_interval_table(interval_table, interval, prev_interval);
+                       } else {
+                               LOG_FUSED(DBG_LOW, "[FUSED] client[%s] is not exist in interval-table", client);
+                               break;
+                       }
+                       break;
+               }
+
+               default: {
+                       LOG_FUSED(DBG_ERR, "unhandled interval-update type");
+                       return FALSE;
+               }
+       }
+
+       /* update logic for optimized-interval value */
+       if (g_hash_table_size(lbs_server->fused_interval_table) > 0) {
+               LOG_FUSED(DBG_LOW, "[FUSED] update fused interval_table");
+               lbs_server->temp_minimum_interval = MAX_INTERVAL;
+               g_hash_table_foreach(lbs_server->fused_interval_table, (GHFunc) update_interval_table_foreach_cb, (gpointer) lbs_server);
+
+               if (lbs_server->optimized_interval[LBS_SERVER_METHOD_FUSED] != lbs_server->temp_minimum_interval) {
+                       LOG_FUSED(DBG_INFO, "[FUSED] Changing fused optimized_interval value %u -> [ %u ]",
+                                       lbs_server->optimized_interval[LBS_SERVER_METHOD_FUSED], lbs_server->temp_minimum_interval);
+                       lbs_server->optimized_interval[LBS_SERVER_METHOD_FUSED] = lbs_server->temp_minimum_interval;
+               }
+       }
+
+       return ret_val;
+}
+
 static void request_change_pos_update_interval(int method, gpointer userdata)
 {
        LOG_GPS(DBG_LOW, "ENTER >>>");
@@ -963,6 +1047,37 @@ static void request_change_pos_update_interval(int method, gpointer userdata)
        }
 }
 
+static void request_plugin_interval(lbs_server_s *lbs_server)
+{
+       LOG_GPS(DBG_LOW, "request plugin interval, now [%d]", lbs_server->now_gps_interval);
+       if (lbs_server->is_gps_running) {
+
+               if (__get_fused_interval_control(lbs_server)) {
+                       guint min_interval = 0;
+                       if (lbs_server->optimized_interval[LBS_SERVER_METHOD_GPS] <
+                                       lbs_server->optimized_interval[LBS_SERVER_METHOD_FUSED])
+                               min_interval = lbs_server->optimized_interval[LBS_SERVER_METHOD_GPS];
+                       else
+                               min_interval = lbs_server->optimized_interval[LBS_SERVER_METHOD_FUSED];
+
+                       if (lbs_server->now_gps_interval != min_interval) {
+                               lbs_server->now_gps_interval = min_interval;
+                               LOG_GPS(DBG_LOW, "request plugin[Fused only] --> [%d]", lbs_server->now_gps_interval);
+                               request_change_pos_update_interval_standalone_gps(lbs_server->now_gps_interval);
+                       }
+               } else {
+                       if (lbs_server->now_gps_interval != lbs_server->optimized_interval[LBS_SERVER_METHOD_GPS]) {
+                               lbs_server->now_gps_interval = lbs_server->optimized_interval[LBS_SERVER_METHOD_GPS];
+                               LOG_GPS(DBG_LOW, "request plugin[Gps] --> [%d]", lbs_server->now_gps_interval);
+                               request_change_pos_update_interval_standalone_gps(lbs_server->now_gps_interval);
+                       }
+               }
+       } else {
+               LOG_GPS(DBG_LOW, "request plugin[stop] --> [0]");
+               lbs_server->now_gps_interval = 0;
+       }
+}
+
 static void get_nmea(int *timestamp, gchar **nmea_data, gpointer userdata)
 {
        LOG_GPS(DBG_LOW, "ENTER >>>");
@@ -1009,7 +1124,7 @@ static void set_options(GVariant *options, const gchar *client, gpointer userdat
                return;
        }
        if (!g_strcmp0(key, "CMD")) {
-               LOG_GPS(DBG_LOW, "set_options [%s]", g_variant_get_string(value, &length));
+               LOG_GPS(DBG_LOW, "set options [%s]", g_variant_get_string(value, &length));
                if (!g_strcmp0(g_variant_get_string(value, &length), "START")) {
 
                        while (g_variant_iter_next(&iter, "{&sv}", &key, &value)) {
@@ -1022,26 +1137,23 @@ static void set_options(GVariant *options, const gchar *client, gpointer userdat
                                else if (!g_strcmp0(key, "FUSED_MODE"))
                                        fused_mode = g_variant_get_int32(value);
                        }
-                       LOG_GPS(DBG_LOW, "METHOD [%d], INTERVAL [%u], APP_ID [%s]", method, interval, app_id);
+                       LOG_GPS(DBG_LOW, "[opt:START] METHOD [%d], INTERVAL [%u], APP_ID [%s], FUSED_MODE[%d]", method, interval, app_id, fused_mode);
 
                        if (client) {
-                               LOG_GPS(DBG_LOW, "update_pos_tracking_interval -> START");
-                               update_pos_tracking_interval(LBS_SERVER_INTERVAL_ADD, client, method, interval, 0, lbs_server);
+                               LOG_GPS(DBG_LOW, "update gps_tracking_interval -> START");
+                               update_gps_tracking_interval(LBS_SERVER_INTERVAL_ADD, client, method, interval, 0, lbs_server);
+
+                               if (fused_mode != LOCATION_FUSED_NONE)
+                                       update_fused_tracking_interval(LBS_SERVER_INTERVAL_ADD, client, method, interval, 0, lbs_server);
                        }
 
                        if (app_id) {
-                               if (LBS_SERVER_METHOD_GPS == method)
-                                       gps_dump_log("START GPS", app_id);
-
+                               if (LBS_SERVER_METHOD_GPS == method) gps_dump_log("START GPS", app_id);
                                free(app_id);
                        }
 
                        start_tracking(lbs_server, method, fused_mode);
 
-                       if (lbs_server->is_needed_changing_interval) {
-                               lbs_server->is_needed_changing_interval = FALSE;
-                               request_change_pos_update_interval(method, (gpointer)lbs_server);
-                       }
                }
                else if (!g_strcmp0(g_variant_get_string(value, &length), "STOP")) {
                        while (g_variant_iter_next(&iter, "{&sv}", &key, &value)) {
@@ -1054,26 +1166,23 @@ static void set_options(GVariant *options, const gchar *client, gpointer userdat
                                else if (!g_strcmp0(key, "FUSED_MODE"))
                                        fused_mode = g_variant_get_int32(value);
                        }
-                       LOG_GPS(DBG_LOW, "METHOD [%d], INTERVAL [%u], APP_ID [%s]", method, interval, app_id);
+                       LOG_GPS(DBG_LOW, "[opt:STOP] METHOD[%d], INTERVAL[%u], APP_ID[%s], FUSED_MODE[%d]", method, interval, app_id, fused_mode);
 
                        if (client) {
-                               LOG_GPS(DBG_LOW, "update_pos_tracking_interval -> STOP");
-                               update_pos_tracking_interval(LBS_SERVER_INTERVAL_REMOVE, client, method, interval, 0, lbs_server);
+                               LOG_GPS(DBG_LOW, "update gps_tracking_interval -> STOP");
+                               update_gps_tracking_interval(LBS_SERVER_INTERVAL_REMOVE, client, method, interval, 0, lbs_server);
+
+                               if (fused_mode != LOCATION_FUSED_NONE)
+                                       update_fused_tracking_interval(LBS_SERVER_INTERVAL_REMOVE, client, method, interval, 0, lbs_server);
                        }
 
                        if (app_id) {
-                               if (LBS_SERVER_METHOD_GPS == method)
-                                       gps_dump_log("STOP GPS", app_id);
-
+                               if (LBS_SERVER_METHOD_GPS == method) gps_dump_log("STOP GPS", app_id);
                                free(app_id);
                        }
 
                        stop_tracking(lbs_server, method, fused_mode);
 
-                       if (lbs_server->is_needed_changing_interval) {
-                               lbs_server->is_needed_changing_interval = FALSE;
-                               request_change_pos_update_interval(method, (gpointer)lbs_server);
-                       }
                }
 #ifndef TIZEN_DEVICE
                else if (!g_strcmp0(g_variant_get_string(value, &length), "START_BATCH")) {
@@ -1144,7 +1253,7 @@ static void set_options(GVariant *options, const gchar *client, gpointer userdat
                                                if (lbs_server->nmea_used == FALSE)
                                                        lbs_server->nmea_used = TRUE;
                                        } else if (!g_strcmp0(option, "UNUSE_NMEA")) {
-                                               if (lbs_server->nmea_used == TRUE)
+                                               if (lbs_server->nmea_used)
                                                        lbs_server->nmea_used = FALSE;
                                        }
                                        g_free(option);
@@ -1161,15 +1270,19 @@ static void set_options(GVariant *options, const gchar *client, gpointer userdat
                                }
                        }
 
-                       LOG_GPS(DBG_LOW, "PREV_INTERVAL [%u] --> INTERVAL_UPDATE [%u], min [%u] ", prev_interval, interval, lbs_server->temp_minimum_interval);
+                       LOG_GPS(DBG_LOW, "[opt:OPT] PREV_INTERVAL [%u] --> INTERVAL_UPDATE [%u], min [%u] ", prev_interval, interval, lbs_server->temp_minimum_interval);
                        if ((interval != prev_interval) && (prev_interval > 0))
                                is_update_interval = TRUE;
 
                        if (is_update_interval && is_update_interval_method && client) {
-                               LOG_GPS(DBG_LOW, "update_pos_tracking_interval -> SET:OPT");
-                               update_pos_tracking_interval(LBS_SERVER_INTERVAL_UPDATE, client, method, interval, prev_interval, lbs_server);
-                               if (lbs_server->is_needed_changing_interval) {
-                                       lbs_server->is_needed_changing_interval = FALSE;
+                               LOG_GPS(DBG_LOW, "update gps_tracking_interval -> SET:OPT");
+                               update_gps_tracking_interval(LBS_SERVER_INTERVAL_UPDATE, client, method, interval, prev_interval, lbs_server);
+
+                               if (fused_mode != LOCATION_FUSED_NONE)
+                                       update_fused_tracking_interval(LBS_SERVER_INTERVAL_UPDATE, client, method, interval, prev_interval, lbs_server);
+
+                               if (lbs_server->is_changing_gps_interval) {
+                                       lbs_server->is_changing_gps_interval = FALSE;
                                        request_change_pos_update_interval(method, (gpointer)lbs_server);
                                }
                        }
@@ -1233,7 +1346,7 @@ static void shutdown(gpointer userdata, gboolean *shutdown_arr)
 #ifdef TIZEN_DEVICE
 static void fused_update_position_cb(fl_location *location, gpointer user_data)
 {
-       LOG_FUSED_FUNC;
+//     LOG_FUSED_FUNC;
        if (location == NULL || user_data == NULL) {
                LOG_FUSED(LOG_ERROR, "parameter is NULL");
                return;
@@ -1243,8 +1356,7 @@ static void fused_update_position_cb(fl_location *location, gpointer user_data)
                        | LBS_POSITION_EXT_FIELDS_ALTITUDE | LBS_POSITION_EXT_FIELDS_SPEED | LBS_POSITION_EXT_FIELDS_DIRECTION | LBS_POSITION_EXT_FIELDS_CLIMB);
 
        GVariant *accuracy = g_variant_new("(idd)", LBS_ACCURACY_LEVEL_DETAILED,
-                                                                       location->accuracy.horizontal_accuracy, // TODO: or from location->sigma.of_horizontal_pos
-                                                                       location->accuracy.vertical_accuracy);  // TODO: or from location->sigma.of_altitude
+                                                                       location->accuracy.horizontal_accuracy, location->accuracy.vertical_accuracy);
 
        lbs_server_emit_position_changed(lbs_server->lbs_dbus_server, LBS_SERVER_METHOD_FUSED,
                                fields, location->pos.timestamp,
@@ -1279,7 +1391,8 @@ static void gps_update_position_cb(pos_data_t *pos, gps_error_t error, void *use
        gps_set_position(pos);
 
 #ifdef TIZEN_DEVICE
-       send_gps_position_to_fused_engine(pos->timestamp, pos->latitude, pos->longitude, pos->altitude,
+       if (lbs_server->is_fused_running)
+               send_gps_position_to_fused_engine(pos->timestamp, pos->latitude, pos->longitude, pos->altitude,
                        pos->speed, pos->bearing, pos->hor_accuracy, pos->ver_accuracy);
 #endif
 
@@ -1413,16 +1526,17 @@ static void lbs_server_init(lbs_server_s *lbs_server)
        lbs_server->sv_used = FALSE;
        lbs_server->nmea_used = FALSE;
        lbs_server->gps_client_count = 0;
+       lbs_server->now_gps_interval = 0;
        lbs_server->fused_high_count = 0;
-       lbs_server->fused_balanced_count = 0;
+       lbs_server->fused_balance_count = 0;
        lbs_server->current_location_source = LOCATION_SOURCE_NONE;
 
        nps_init(lbs_server);
 
        /* create resource for dynamic-interval */
-       lbs_server->dynamic_interval_table = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
+       lbs_server->gps_interval_table = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
        lbs_server->optimized_interval = (guint *)g_malloc0(LBS_SERVER_METHOD_SIZE * sizeof(guint));
-       lbs_server->is_needed_changing_interval = FALSE;
+       lbs_server->is_changing_gps_interval = FALSE;
 
        /* Mock Location init */
        lbs_server->is_mock_running = MOCK_RUNNING_OFF;
@@ -1437,6 +1551,7 @@ static void lbs_server_init(lbs_server_s *lbs_server)
 #endif
 
 #ifdef TIZEN_DEVICE
+       lbs_server->fused_interval_table = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
        location_fused_init(fused_update_position_cb, lbs_server);
 #endif
 }
@@ -1623,7 +1738,7 @@ int main(int argc, char **argv)
 
        lbs_server_dbus_cb->set_options_cb = set_options;
        lbs_server_dbus_cb->shutdown_cb = shutdown;
-       lbs_server_dbus_cb->update_interval_cb = update_pos_tracking_interval;
+       lbs_server_dbus_cb->update_interval_cb = update_gps_tracking_interval;
        lbs_server_dbus_cb->request_change_interval_cb = request_change_pos_update_interval;
        lbs_server_dbus_cb->get_nmea_cb = get_nmea;
        lbs_server_dbus_cb->add_hw_fence_cb = add_fence;
@@ -1649,13 +1764,14 @@ int main(int argc, char **argv)
 
 #ifdef TIZEN_DEVICE
        location_fused_deinit();
+       g_hash_table_destroy(lbs_server->fused_interval_table);
 #endif
 
        gps_deinit_log();
 
        /* destroy resource for dynamic-interval */
        g_free(lbs_server->optimized_interval);
-       g_hash_table_destroy(lbs_server->dynamic_interval_table);
+       g_hash_table_destroy(lbs_server->gps_interval_table);
 #ifndef TIZEN_DEVICE
        g_free(lbs_server->optimized_batch_array);
        g_hash_table_destroy(lbs_server->batch_interval_table);
@@ -1865,15 +1981,15 @@ static void client_count_updater(lbs_server_s *lbs_server, lbs_server_method_e m
                if (fused_mode == LOCATION_FUSED_HIGH)
                        lbs_server->fused_high_count++;
                else if (fused_mode == LOCATION_FUSED_BALANCED)
-                       lbs_server->fused_balanced_count++;
+                       lbs_server->fused_balance_count++;
        } else if (type == _LBS_CLIENT_REMOVE) {
                if (fused_mode == LOCATION_FUSED_HIGH)
                        lbs_server->fused_high_count--;
                else if (fused_mode == LOCATION_FUSED_BALANCED)
-                       lbs_server->fused_balanced_count--;
+                       lbs_server->fused_balance_count--;
        } else if (type == _LBS_CLIENT_REMOVE_ALL) {
                lbs_server->fused_high_count = 0;
-               lbs_server->fused_balanced_count = 0;
+               lbs_server->fused_balance_count = 0;
        }
 
        if (lbs_server->fused_high_count < 0) {
@@ -1881,9 +1997,9 @@ static void client_count_updater(lbs_server_s *lbs_server, lbs_server_method_e m
                lbs_server->fused_high_count = 0;
        }
 
-       if (lbs_server->fused_balanced_count < 0) {
-               LOG_GPS(DBG_ERR, "fused_balanced count is negative value");
-               lbs_server->fused_balanced_count = 0;
+       if (lbs_server->fused_balance_count < 0) {
+               LOG_GPS(DBG_ERR, "fused_balance count is negative value");
+               lbs_server->fused_balance_count = 0;
        }
 }
 
@@ -1899,7 +2015,7 @@ static void start_batch_tracking(lbs_server_s *lbs_server, int batch_interval, i
                lbs_server->status = LBS_STATUS_ACQUIRING;
        }
 
-       if (request_start_batch_session(batch_interval, batch_period) == TRUE) {
+       if (request_start_batch_session(batch_interval, batch_period)) {
                g_mutex_lock(&lbs_server->mutex);
                lbs_server->is_gps_running = TRUE;
                g_mutex_unlock(&lbs_server->mutex);
@@ -1912,7 +2028,7 @@ static void start_batch_tracking(lbs_server_s *lbs_server, int batch_interval, i
 
 static void stop_batch_tracking(lbs_server_s *lbs_server, int batch_interval, int batch_period)
 {
-       LOG_GPS(DBG_LOW, "Batch: stop_tracking GPS");
+       LOG_GPS(DBG_LOW, "Batch: stop tracking GPS");
        client_count_updater(lbs_server, LBS_SERVER_METHOD_GPS, _LBS_CLIENT_REMOVE, LOCATION_FUSED_NONE);
 
        if (lbs_server->is_gps_running == FALSE) {
@@ -1929,7 +2045,7 @@ static void stop_batch_tracking(lbs_server_s *lbs_server, int batch_interval, in
        }
 
        /* TRUE: All clients stopped, FALSE: Some clients are running with GPS or BATCH */
-       if (request_stop_batch_session(batch_interval, batch_period, session_status) == TRUE) {
+       if (request_stop_batch_session(batch_interval, batch_period, session_status)) {
                g_mutex_lock(&lbs_server->mutex);
                lbs_server->is_gps_running = FALSE;
                lbs_server->sv_used = FALSE;
@@ -1945,8 +2061,7 @@ static void stop_batch_tracking(lbs_server_s *lbs_server, int batch_interval, in
 static void update_batch_interval_table_foreach_cb(gpointer key, gpointer value, gpointer userdata)
 {
        guint *interval_array = (guint *)value;
-       dynamic_interval_updator_user_data *updator_ud = (dynamic_interval_updator_user_data *)userdata;
-       lbs_server_s *lbs_server = updator_ud->lbs_server;
+       lbs_server_s *lbs_server = (lbs_server_s *) userdata;
 
        if (lbs_server->optimized_batch_array[LBS_BATCH_INTERVAL] > interval_array[LBS_BATCH_INTERVAL])
                lbs_server->optimized_batch_array[LBS_BATCH_INTERVAL] = interval_array[LBS_BATCH_INTERVAL];
@@ -2018,11 +2133,8 @@ static gboolean update_batch_tracking_interval(lbs_server_interval_manipulation_
                return FALSE;
        } else {
                LOG_GPS(DBG_LOW, "updates optimized-batch-interval.");
-               dynamic_interval_updator_user_data updator_user_data;
-               updator_user_data.lbs_server = lbs_server;
-
                g_hash_table_foreach(lbs_server->batch_interval_table,
-                                                       (GHFunc) update_batch_interval_table_foreach_cb, (gpointer) &updator_user_data);
+                                                       (GHFunc) update_batch_interval_table_foreach_cb, lbs_server);
        }
        LOG_GPS(DBG_LOW, "Updates_batch_tracking_interval done.");
        return TRUE;

diff --git a/lbs-server/src/server.c b/lbs-server/src/server.c
index 46ef2ac..7958a34 100644 (file)
--- a/lbs-server/src/server.c
+++ b/lbs-server/src/server.c
@@ -201,7 +201,7 @@ static void _gps_server_set_gps_state(int gps_state)
 
 int request_change_pos_update_interval_standalone_gps(unsigned int interval)
 {
-       LOG_GPS(DBG_INFO, "request_change_pos_update_interval_standalone_gps. interval[%u]", interval);
+       LOG_GPS(DBG_INFO, "-->> request to plugin GPS_ACTION_CHANGE_INTERVAL [%u]", interval);
        gboolean status = TRUE;
        gps_failure_reason_t reason_code = GPS_FAILURE_CAUSE_NORMAL;
        gps_server_t *server = g_gps_server;

diff --git a/module/fused_module.c b/module/fused_module.c
index 0b5ea06..adc9c70 100644 (file)
--- a/module/fused_module.c
+++ b/module/fused_module.c
@@ -60,13 +60,9 @@ static void position_callback(GVariant *param, void *user_data)
 
        g_variant_get(param, "(iiidddddd@(idd))", &method, &fields, &timestamp, &latitude, &longitude, &altitude, &speed, &direction, &climb, &accuracy);
 
-//     MOD_FUSED_LOGD("position_callback [method: %d] GPS=0, WPS=1/AGPS=2/GEOFENCE/MOCK/FUSED", method);
-
        if (method != LBS_CLIENT_METHOD_FUSED) {
-               if (method != LBS_CLIENT_METHOD_MOCK) {
-                       MOD_FUSED_LOGD("Method is not LBS_CLIENT_METHOD_FUSED: %d", method);
+               if (method != LBS_CLIENT_METHOD_MOCK)
                        return;
-               }
        }
 
        g_variant_get(accuracy, "(idd)", &level, &horizontal, &vertical);

diff --git a/module/gps_module.c b/module/gps_module.c
index f9131e8..499d560 100644 (file)
--- a/module/gps_module.c
+++ b/module/gps_module.c
@@ -158,10 +158,8 @@ static void position_callback(GVariant *param, void *user_data)
        g_variant_get(param, "(iiidddddd@(idd))", &method, &fields, &timestamp, &latitude, &longitude, &altitude, &speed, &direction, &climb, &accuracy);
 
        if (method != LBS_CLIENT_METHOD_GPS) {
-               if (method != LBS_CLIENT_METHOD_MOCK) {
-                       MOD_LOGD("Method is not LBS_CLIENT_METHOD_GPS: %d", method);
+               if (method != LBS_CLIENT_METHOD_MOCK)
                        return;
-               }
        }
 
        g_variant_get(accuracy, "(idd)", &level, &horizontal, &vertical);

diff --git a/packaging/lbs-server.spec b/packaging/lbs-server.spec
index b78af7c..bb62af8 100644 (file)
--- a/packaging/lbs-server.spec
+++ b/packaging/lbs-server.spec
@@ -1,6 +1,6 @@
 Name:    lbs-server
 Summary: LBS Server for Tizen
-Version: 1.2.3
+Version: 1.2.4
 Release: 1
 Group:   Location/Service
 License: Apache-2.0