sync : multi handle

- Fix dynamic interval to support multi handle
- USE_NMEA

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

diff --git a/lbs-server/src/gps_plugin_module.c b/lbs-server/src/gps_plugin_module.c
index 5339444..e3821a2 100644 (file)
--- a/lbs-server/src/gps_plugin_module.c
+++ b/lbs-server/src/gps_plugin_module.c
@@ -59,7 +59,7 @@ int load_plugin_module(char *specific_name, void **plugin_handle)
        *plugin_handle = dlopen(plugin_path, RTLD_NOW);
        if (!*plugin_handle) {
                LOG_GPS(DBG_ERR, "Failed to load plugin module: %s", plugin_path);
-               /* LOG_GPS(DBG_ERR, "%s", dlerror()); */
+               LOG_GPS(DBG_ERR, "%s", dlerror());
                return FALSE;
        }
 

diff --git a/lbs-server/src/lbs_server.c b/lbs-server/src/lbs_server.c
index ba8b30f..e6bd81c 100755 (executable)
--- a/lbs-server/src/lbs_server.c
+++ b/lbs-server/src/lbs_server.c
@@ -43,6 +43,7 @@
 
 #define MOCK_LOCATION_CLEAR_VALUE 999
 #define MOCK_RUNNING_OFF       LBS_SERVER_METHOD_SIZE
+#define MAX_INTERVAL           120
 #define MAX_BATCH_INTERVAL     255
 #define MAX_BATCH_PERIOD       60000
 
@@ -605,7 +606,7 @@ static void stop_tracking(lbs_server_s *lbs_server, lbs_server_method_e method)
 {
        switch (method) {
        case LBS_SERVER_METHOD_GPS:
-               LOG_GPS(DBG_LOW, "stop_tracking GPS");
+               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);
@@ -669,113 +670,74 @@ static void stop_tracking(lbs_server_s *lbs_server, lbs_server_method_e method)
 }
 
 /*
-*
-* Please reference following diagram when you need to manipulate the dynamic_interval_table.
-*
-*  |----------------------------------------------------------------------|
-*  |                            |  Interval  |           Index            |
-*  |----------------------------------------------------------------------|
-*  | LBS_SERVER_METHOD_GPS      | Used       |             0              |
-*  | LBS_SERVER_METHOD_NPS      | Used       |             1              |
-*  | LBS_SERVER_METHOD_AGPS     | Not Used   |             2              |
-*  | LBS_SERVER_METHOD_GEOFENCE | Not Used   |             3              |
-*  | LBS_SERVER_METHOD_MOCK     | Not Used   |             4              |
-*  | INTERVAL_ARRAY_GPS2        | Used       | 5 (LBS_SERVER_METHOD_SIZE) |
-*  | INTERVAL_ARRAY_WPS2        | Used       |             6              |
-*  |----------------------------------------------------------------------|
-*
+*  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;
+       guint interval = GPOINTER_TO_UINT(key);
+       LOG_GPS(DBG_LOW, "list : interval [%u], count [%u]", interval, GPOINTER_TO_UINT(value));
+       if (lbs_server->temp_minimum_interval > interval)
+               lbs_server->temp_minimum_interval = interval;
+}
+
 static void update_dynamic_interval_table_foreach_cb(gpointer key, gpointer value, gpointer userdata)
 {
-       guint *interval_array = (guint *)value;
+       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;
        int method = updator_ud->method;
 
-       if (method == LBS_SERVER_METHOD_GPS || method == LBS_SERVER_METHOD_NPS) {
-               guint interval1 = interval_array[method];
-               guint interval2 = interval_array[method + LBS_SERVER_METHOD_SIZE];
-
-               if ((lbs_server->temp_minimum_interval > interval1) && (interval1 > 0))
-                       lbs_server->temp_minimum_interval = interval1;
-
-               if ((lbs_server->temp_minimum_interval > interval2) && (interval2 > 0))
-                       lbs_server->temp_minimum_interval = interval2;
-       }
-       LOG_GPS(DBG_LOW, "method:[%d], key:[%s] interval:[%u], temp_min[%u]", method, (char *)key, interval_array[method], lbs_server->temp_minimum_interval);
+       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]", method, (char *)key, lbs_server->temp_minimum_interval, g_hash_table_size(interval_table));
 }
 
-static void __add_interval_table(guint *interval_array, int method, guint interval, gpointer userdata)
+static void __add_interval_table(GHashTable *interval_table, guint interval)
 {
-       LOG_GPS(DBG_LOW, "Add interval to dynamic array [%u]", interval);
-       lbs_server_s *lbs_server = (lbs_server_s *)userdata;
-       lbs_server->temp_minimum_interval = interval;
-
-       if (method == LBS_SERVER_METHOD_GPS || method == LBS_SERVER_METHOD_NPS) {
-               if (interval_array[method] == 0) {
-                       interval_array[method] = interval;
-               } else {
-                       if (interval_array[method + LBS_SERVER_METHOD_SIZE] == 0) {
-                               interval_array[method + LBS_SERVER_METHOD_SIZE] = interval;
-
-                               if (interval_array[method] < interval)
-                                       lbs_server->temp_minimum_interval = interval_array[method];
-                       }
-               }
+       gpointer *value = (gpointer *) g_hash_table_lookup(interval_table, GUINT_TO_POINTER(interval));
+       if (value) {
+               guint count = GPOINTER_TO_UINT(value);
+               g_hash_table_insert(interval_table, GUINT_TO_POINTER(interval), GUINT_TO_POINTER(count + 1));
+       } else {
+               g_hash_table_insert(interval_table, GUINT_TO_POINTER(interval), GUINT_TO_POINTER(1));
        }
 }
 
-static void __remove_interval_table(guint *interval_array, int method, guint interval, gpointer userdata)
+static void __remove_interval_table(GHashTable *interval_table, guint interval)
 {
-       LOG_GPS(DBG_LOW, "Remove interval from table[%u]", interval);
-       lbs_server_s *lbs_server = (lbs_server_s *)userdata;
-       lbs_server->temp_minimum_interval = interval;
-
-       if (method == LBS_SERVER_METHOD_GPS || method == LBS_SERVER_METHOD_NPS) {
-               if (interval == 0) {
-                       interval_array[method] = 0;
-                       interval_array[method + LBS_SERVER_METHOD_SIZE] = 0;
-               } else if (interval_array[method + LBS_SERVER_METHOD_SIZE] == interval) {
-                       interval_array[method + LBS_SERVER_METHOD_SIZE] = 0;
-               } else if (interval_array[method] == interval) {
-                       interval_array[method] = interval_array[method + LBS_SERVER_METHOD_SIZE];
-                       interval_array[method + LBS_SERVER_METHOD_SIZE] = 0;
+       gpointer *value = (gpointer *) g_hash_table_lookup(interval_table, GUINT_TO_POINTER(interval));
+       if (value) {
+               guint count = GPOINTER_TO_UINT(value);
+               if (count == 1) {
+                       if (g_hash_table_remove(interval_table, GUINT_TO_POINTER(interval)) != TRUE)
+                               LOG_GPS(DBG_LOW, "Remove interval[%u] failed from g_hash_table", interval);
                } else {
-                       LOG_GPS(DBG_LOW, "interval[%u] is not exist.", interval);
+                       g_hash_table_insert(interval_table, GUINT_TO_POINTER(interval), GUINT_TO_POINTER(count - 1));
                }
+       } else {
+               LOG_GPS(DBG_LOW, "Remove interval : lookup result is null");
        }
 }
 
-static void __update_interval_table(guint *interval_array, int method, guint interval, guint prev_interval, gpointer userdata)
+static void __update_interval_table(GHashTable *interval_table, guint interval, guint prev_interval)
 {
-       LOG_GPS(DBG_LOW, "Update interval from table[%u -> %u]", prev_interval, interval);
-       lbs_server_s *lbs_server = (lbs_server_s *)userdata;
-       lbs_server->temp_minimum_interval = interval;
-
-       if (method == LBS_SERVER_METHOD_GPS || method == LBS_SERVER_METHOD_NPS) {
-               if (interval_array[method] == prev_interval)
-                       interval_array[method] = interval;
-               else if (interval_array[method + LBS_SERVER_METHOD_SIZE] == prev_interval)
-                       interval_array[method + LBS_SERVER_METHOD_SIZE] = interval;
-               else
-                       LOG_GPS(DBG_LOW, "interval[%u] is not exist. cannot change to [%u]", prev_interval, interval);
-       }
+       LOG_GPS(DBG_LOW, "Update interval [%u -> %u]", prev_interval, interval);
+       __remove_interval_table(interval_table, prev_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)
 {
-       LOG_GPS(DBG_LOW, "ENTER >>>");
+       LOG_GPS(DBG_LOW, ">>> update_pos_tracking_interval");
        if (userdata == NULL) return FALSE;
        if (client == NULL) {
                LOG_GPS(DBG_ERR, "client is NULL");
                return FALSE;
        }
 
-       if (method < LBS_SERVER_METHOD_GPS || method >= LBS_SERVER_METHOD_SIZE) {
-               LOG_GPS(DBG_ERR, "unavailable method [%d]", method);
+       if (method != LBS_SERVER_METHOD_GPS)
                return FALSE;
-       }
 
        gboolean ret_val = FALSE;
        lbs_server_s *lbs_server = (lbs_server_s *)userdata;
@@ -783,71 +745,69 @@ static gboolean update_pos_tracking_interval(lbs_server_interval_manipulation_ty
        /* manipulate logic for dynamic-interval hash table */
        switch (type) {
                case LBS_SERVER_INTERVAL_ADD: {
-                       LOG_GPS(DBG_LOW, "ADD, client[%s], method[%d], interval[%u]", client, method, interval);
                        gchar *client_cpy = NULL;
                        client_cpy = g_strdup(client);
 
-                       guint *interval_array = (guint *) g_hash_table_lookup(lbs_server->dynamic_interval_table, client_cpy);
-                       if (!interval_array) {
-                               LOG_GPS(DBG_LOW, "first add key[%s] to interval-table", client);
-                               interval_array = (guint *)g_malloc0(INTERVAL_ARRAY_MAX * sizeof(guint));
-                               if (!interval_array) {
-                                       LOG_GPS(DBG_ERR, "interval_array is NULL");
-                                       g_free(client_cpy);
-                                       return FALSE;
-                               }
-                               g_hash_table_insert(lbs_server->dynamic_interval_table, (gpointer)client_cpy, (gpointer)interval_array);
+                       GHashTable *interval_table = (GHashTable *) g_hash_table_lookup(lbs_server->dynamic_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);
+                       } else {
+                               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);
                        }
 
-                       __add_interval_table(interval_array, method, interval, userdata);
-
-                       LOG_GPS(DBG_LOW, "ADD done");
+                       LOG_GPS(DBG_LOW, "ADD, done");
                        break;
                }
 
                case LBS_SERVER_INTERVAL_REMOVE: {
-                       LOG_GPS(DBG_LOW, "REMOVE, client[%s], method[%d], interval[%u]", client, method, interval);
-                       lbs_server->temp_minimum_interval = 120;
-                       guint *interval_array = (guint *) g_hash_table_lookup(lbs_server->dynamic_interval_table, client);
-                       if (!interval_array) {
+                       GHashTable *interval_table = (GHashTable *) g_hash_table_lookup(lbs_server->dynamic_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)
+                                                       LOG_GPS(DBG_LOW, "g_hash_table_remove is failed.");
+                                       }
+                                       break;
+                               } else {
+                                       __remove_interval_table(interval_table, interval);
+                               }
+                       } else {
                                LOG_GPS(DBG_INFO, "Client[%s] Method[%d] is already removed from interval-table", client, method);
                                break;
                        }
-                       LOG_GPS(DBG_LOW, "Found interval_array[%d](%p):[%u] from interval-table", method, interval_array, interval_array[method]);
-
-                       __remove_interval_table(interval_array, method, interval, userdata);
 
-                       int i = 0;
-                       gboolean is_need_remove_client_from_table = TRUE;
-                       for (i = 0; i < LBS_SERVER_METHOD_SIZE; i++) {
-                               if (interval_array[i] != 0) {
-                                       LOG_GPS(DBG_LOW, "[%s] method[%d]'s interval[%d] is not zero.", client, i, interval_array[i]);
-                                       is_need_remove_client_from_table = FALSE;
-                                       break;
+                       if (g_hash_table_size(interval_table) == 0) {
+                               LOG_GPS(DBG_LOW, "Remove client[%s] from dynamic_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)
+                                               LOG_GPS(DBG_LOW, "g_hash_table_remove is failed.");
                                }
                        }
 
-                       if (is_need_remove_client_from_table) {
-                               LOG_GPS(DBG_LOW, "is_need_remove_client_from_table is TRUE");
-                               if (!g_hash_table_remove(lbs_server->dynamic_interval_table, client))
-                                       LOG_GPS(DBG_ERR, "g_hash_table_remove is failed.");
+                       LOG_GPS(DBG_LOW, "REMOVE, done.");
 
-                               LOG_GPS(DBG_LOW, "REMOVE done.");
-                       }
                        break;
                }
 
                case LBS_SERVER_INTERVAL_UPDATE: {
-                       LOG_GPS(DBG_LOW, "UPDATE client[%s], method[%d], interval[%u -> %u]", client, method, prev_interval, interval);
-                       guint *interval_array = (guint *) g_hash_table_lookup(lbs_server->dynamic_interval_table, client);
-                       if (!interval_array) {
-                               LOG_GPS(DBG_LOW, "Client[%s] is not exist in interval-table", client, method);
+                       GHashTable *interval_table = (GHashTable *) g_hash_table_lookup(lbs_server->dynamic_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);
+                       } else {
+                               LOG_GPS(DBG_LOW, "Client[%s] is not exist in interval-table", client);
                                break;
                        }
-
-                       __update_interval_table(interval_array, method, interval, prev_interval, userdata);
-
-                       LOG_GPS(DBG_LOW, "UPDATE done.");
+                       LOG_GPS(DBG_LOW, "UPDATE, done.");
                        break;
                }
 
@@ -860,24 +820,28 @@ 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;
                int i = 0;
                for (i = 0; i < LBS_SERVER_METHOD_SIZE; i++)
                        lbs_server->optimized_interval_array[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;
 
-               g_hash_table_foreach(lbs_server->dynamic_interval_table, (GHFunc)update_dynamic_interval_table_foreach_cb, (gpointer)&updator_user_data);
+               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);
 
                if (lbs_server->optimized_interval_array[method] != lbs_server->temp_minimum_interval) {
-                       LOG_GPS(DBG_INFO, "Changing method[%d]'s optimized_interval value %u -> [ %u ]",
-                                       method, lbs_server->optimized_interval_array[method], lbs_server->temp_minimum_interval);
+                       LOG_GPS(DBG_INFO, "Changing method[GPS]'s optimized_interval value %u -> [ %u ]",
+                                       lbs_server->optimized_interval_array[method], lbs_server->temp_minimum_interval);
                        lbs_server->optimized_interval_array[method] = 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;
                }
 
@@ -962,8 +926,10 @@ static void set_options(GVariant *options, const gchar *client, gpointer userdat
                        }
                        LOG_GPS(DBG_LOW, "METHOD [%d], INTERVAL [%u], APP_ID [%s]", method, interval, app_id);
 
-                       if (client)
+                       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);
+                       }
 
                        if (app_id) {
                                if (LBS_SERVER_METHOD_GPS == method)
@@ -992,8 +958,10 @@ static void set_options(GVariant *options, const gchar *client, gpointer userdat
                        }
                        LOG_GPS(DBG_LOW, "METHOD [%d], INTERVAL [%u], APP_ID [%s]", method, interval, app_id);
 
-                       if (client)
+                       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);
+                       }
 
                        if (app_id) {
                                if (LBS_SERVER_METHOD_GPS == method)
@@ -1074,6 +1042,12 @@ static void set_options(GVariant *options, const gchar *client, gpointer userdat
                                                if (lbs_server->sv_used == FALSE)
                                                        lbs_server->sv_used = TRUE;
                                                g_mutex_unlock(&lbs_server->mutex);
+                                       } else if (!g_strcmp0(option, "USE_NMEA")) {
+                                               if (lbs_server->nmea_used == FALSE)
+                                                       lbs_server->nmea_used = TRUE;
+                                       } else if (!g_strcmp0(option, "UNUSE_NMEA")) {
+                                               if (lbs_server->nmea_used == TRUE)
+                                                       lbs_server->nmea_used = FALSE;
                                        }
                                        g_free(option);
                                }
@@ -1096,6 +1070,7 @@ static void set_options(GVariant *options, const gchar *client, gpointer userdat
                                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;
@@ -1108,7 +1083,7 @@ static void set_options(GVariant *options, const gchar *client, gpointer userdat
 
 static gboolean gps_remove_all_clients(lbs_server_s *lbs_server)
 {
-       LOG_GPS(DBG_LOW, "remove_all_clients GPS");
+       LOG_GPS(DBG_LOW, "remove_all_clients[%d] GPS", lbs_server->gps_client_count);
        if (lbs_server->is_mock_running == LBS_SERVER_METHOD_GPS) {
                mock_stop_tracking(lbs_server);
                setting_ignore_key_changed(VCONFKEY_LOCATION_MOCK_ENABLED, __setting_mock_cb);
@@ -1258,7 +1233,7 @@ static void gps_update_nmea_cb(nmea_data_t *nmea, void *user_data)
        if (lbs_server->nmea_used == FALSE)
                return;
 
-       LOG_GPS(DBG_LOW, "[%d] %s", lbs_server->nmea.timestamp, lbs_server->nmea.data);
+       /* LOG_GPS(DBG_LOW, "[%d] %s", lbs_server->nmea.timestamp, lbs_server->nmea.data); */
        lbs_server_emit_nmea_changed(lbs_server->lbs_dbus_server, lbs_server->nmea.timestamp, lbs_server->nmea.data);
 }
 
@@ -1317,7 +1292,7 @@ static void lbs_server_init(lbs_server_s *lbs_server)
        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, g_free);
+       lbs_server->dynamic_interval_table = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
        lbs_server->optimized_interval_array = (guint *)g_malloc0(LBS_SERVER_METHOD_SIZE * sizeof(guint));
        lbs_server->is_needed_changing_interval = FALSE;
 

diff --git a/lbs-server/src/lbs_server.h b/lbs-server/src/lbs_server.h
index 4cba28f..bb52ca8 100755 (executable)
--- a/lbs-server/src/lbs_server.h
+++ b/lbs-server/src/lbs_server.h
@@ -43,12 +43,6 @@ typedef enum {
        LBS_SERVER_METHOD_SIZE,
 } lbs_server_method_e;
 
-typedef enum {
-       INTERVAL_ARRAY_GPS2 = LBS_SERVER_METHOD_SIZE,
-       INTERVAL_ARRAY_WPS2,
-       INTERVAL_ARRAY_MAX,
-} dynamic_interval_e;
-
 /**
  * This callback is called with position data.
  *

diff --git a/module/nps_module.c b/module/nps_module.c
index 58ece59..976bd79 100644 (file)
--- a/module/nps_module.c
+++ b/module/nps_module.c
@@ -382,9 +382,7 @@ LOCATION_MODULE_API void shutdown(gpointer handle)
        g_return_if_fail(module);
 
        if (module->lbs_client) {
-               if (module->is_started)
-                       lbs_client_stop(module->lbs_client, UNNECESSARY_INTERVAL);
-
+               lbs_client_stop(module->lbs_client, UNNECESSARY_INTERVAL);
                lbs_client_destroy(module->lbs_client);
                module->lbs_client = NULL;
        }

diff --git a/module/passive_module.c b/module/passive_module.c
index 1d943d6..e722c9f 100644 (file)
--- a/module/passive_module.c
+++ b/module/passive_module.c
@@ -76,6 +76,7 @@ static void satellite_callback(GVariant *param, void *user_data)
        int num_of_used_prn = g_variant_iter_n_children(used_prn_iter);
        if (num_of_used_prn > 0) {
                used_prn_array = (guint *)g_new0(guint, num_of_used_prn);
+               g_return_if_fail(used_prn_array);
                for (idx = 0; idx < num_of_used_prn; idx++) {
                        ret = g_variant_iter_next(used_prn_iter, "i", &tmp_prn);
                        if (ret == FALSE)

diff --git a/packaging/lbs-server.changes b/packaging/lbs-server.changes
index f5b129b..17b0ab6 100644 (file)
--- a/packaging/lbs-server.changes
+++ b/packaging/lbs-server.changes
@@ -1,3 +1,9 @@
+[Version]      lbs-server_1.1.6
+[Date]         28 Mar 2017
+[Changes]      Fix dynamic interval to support multi handle
+[Developer]    Kyoungjun Sung <kj7.sung@samsung.com>
+
+================================================================================
 [Version]      lbs-server_1.0.12
 [Date]         1 Feb 2017
 [Changes]      Support satellite for passive mode

diff --git a/packaging/lbs-server.spec b/packaging/lbs-server.spec
index bb996a5..7465586 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.0.12
+Version: 1.1.6
 Release: 1
 Group:   Location/Service
 License: Apache-2.0