From: kj7.sung Date: Thu, 30 Mar 2017 03:56:48 +0000 (+0900) Subject: sync : multi handle X-Git-Tag: submit/tizen/20170330.051533^0 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=d1a903580cbbf9111b7a2bf3f9301057ce8ec1ca;p=platform%2Fcore%2Flocation%2Flbs-server.git sync : multi handle - Fix dynamic interval to support multi handle - USE_NMEA Change-Id: I5538e2cdb2aa0b121920908668b38cbe656f2e4d Signed-off-by: kj7.sung --- diff --git a/lbs-server/src/gps_plugin_module.c b/lbs-server/src/gps_plugin_module.c index 5339444..e3821a2 100644 --- 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 --- 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 --- 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 --- 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 --- 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 --- 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 + +================================================================================ [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 --- 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