Dynamic interval table for multi handle

 - dynamic interval table updated
 - wps module added

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

diff --git a/lbs-server/src/last_position.c b/lbs-server/src/last_position.c
old mode 100755 (executable)
new mode 100644 (file)

diff --git a/lbs-server/src/lbs_server.c b/lbs-server/src/lbs_server.c
index be1fa54292c484f50b2fcd64a29fdac773ea6fcd..44011323b50e876a20f1c03124dda2acd6bdb03e 100755 (executable)
--- a/lbs-server/src/lbs_server.c
+++ b/lbs-server/src/lbs_server.c
@@ -43,6 +43,8 @@
 
 #define MOCK_LOCATION_CLEAR_VALUE 999
 #define MOCK_RUNNING_OFF       LBS_SERVER_METHOD_SIZE
+#define MAX_BATCH_INTERVAL     255
+#define MAX_BATCH_PERIOD       60000
 
 typedef struct {
        /* gps variables */
@@ -659,6 +661,24 @@ 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              |
+*  |----------------------------------------------------------------------|
+*
+*/
+
 static void update_dynamic_interval_table_foreach_cb(gpointer key, gpointer value, gpointer userdata)
 {
        guint *interval_array = (guint *)value;
@@ -666,12 +686,77 @@ static void update_dynamic_interval_table_foreach_cb(gpointer key, gpointer valu
        lbs_server_s *lbs_server = updator_ud->lbs_server;
        int method = updator_ud->method;
 
-       LOG_GPS(DBG_LOW, "method:[%d], key:[%s] interval:[%u], current optimized interval [%u]", method, (char *)key, interval_array[method], lbs_server->optimized_interval_array[method]);
-       if ((lbs_server->temp_minimum_interval > interval_array[method]))
-               lbs_server->temp_minimum_interval = interval_array[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);
+}
+
+static void __add_interval_table(guint *interval_array, int method, guint interval, gpointer userdata)
+{
+       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];
+                       }
+               }
+       }
+}
+
+static void __remove_interval_table(guint *interval_array, int method, guint interval, gpointer userdata)
+{
+       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;
+               } else {
+                       LOG_GPS(DBG_LOW, "interval[%u] is not exist.", interval);
+               }
+       }
+}
+
+static void __update_interval_table(guint *interval_array, int method, guint interval, guint prev_interval, gpointer userdata)
+{
+       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);
+       }
 }
 
-static gboolean update_pos_tracking_interval(lbs_server_interval_manipulation_type type, const gchar *client, int method, guint interval, gpointer userdata)
+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 >>>");
        if (userdata == NULL) return FALSE;
@@ -697,39 +782,39 @@ static gboolean update_pos_tracking_interval(lbs_server_interval_manipulation_ty
 
                        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(LBS_SERVER_METHOD_SIZE * sizeof(guint));
+                               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"); */
+                                       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);
                        }
-                       interval_array[method] = interval;
-                       lbs_server->temp_minimum_interval = interval;
-                       /* LOG_GPS(DBG_LOW, "ADD done"); */
+
+                       __add_interval_table(interval_array, method, interval, userdata);
+
+                       LOG_GPS(DBG_LOW, "ADD done");
                        break;
                }
 
                case LBS_SERVER_INTERVAL_REMOVE: {
-                       LOG_GPS(DBG_LOW, "REMOVE, client[%s], method[%d]", client, method);
-                       lbs_server->temp_minimum_interval = 120; /* interval max value */
+                       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) {
                                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]);
-                       interval_array[method] = 0;
+
+                       __remove_interval_table(interval_array, method, interval, userdata);
 
                        int i = 0;
-                       guint interval_each = 0;
                        gboolean is_need_remove_client_from_table = TRUE;
                        for (i = 0; i < LBS_SERVER_METHOD_SIZE; i++) {
-                               interval_each = interval_array[i];
-                               if (interval_each != 0) {
-                                       LOG_GPS(DBG_LOW, "[%s] method[%d]'s interval is not zero - interval: %d. It will not be removed.", client, i, interval_each);
+                               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;
                                }
@@ -746,14 +831,15 @@ static gboolean update_pos_tracking_interval(lbs_server_interval_manipulation_ty
                }
 
                case LBS_SERVER_INTERVAL_UPDATE: {
-                       LOG_GPS(DBG_LOW, "UPDATE client[%s], method[%d], interval[%u]", client, method, interval);
+                       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);
                                break;
                        }
-                       interval_array[method] = interval;
-                       lbs_server->temp_minimum_interval = interval;
+
+                       __update_interval_table(interval_array, method, interval, prev_interval, userdata);
+
                        LOG_GPS(DBG_LOW, "UPDATE done.");
                        break;
                }
@@ -780,8 +866,8 @@ static gboolean update_pos_tracking_interval(lbs_server_interval_manipulation_ty
                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 optimized_interval value [%u -> %u] for method [%d]",
-                                       lbs_server->optimized_interval_array[method], lbs_server->temp_minimum_interval, method);
+                       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);
                        lbs_server->optimized_interval_array[method] = lbs_server->temp_minimum_interval;
 
                        /* need to send message to provider device */
@@ -843,6 +929,7 @@ static void set_options(GVariant *options, const gchar *client, gpointer userdat
        char *option = NULL;
        char *app_id = NULL;
        guint interval = 0;
+       guint prev_interval = 0;
 
        lbs_server_method_e method = 0;
 
@@ -857,24 +944,19 @@ static void set_options(GVariant *options, const gchar *client, gpointer userdat
                if (!g_strcmp0(g_variant_get_string(value, &length), "START")) {
 
                        while (g_variant_iter_next(&iter, "{&sv}", &key, &value)) {
-                               if (!g_strcmp0(key, "METHOD")) {
+                               if (!g_strcmp0(key, "METHOD"))
                                        method = g_variant_get_int32(value);
-                                       LOG_GPS(DBG_LOW, "METHOD [%d]", method);
-                               }
 
-                               if (!g_strcmp0(key, "INTERVAL")) {
+                               if (!g_strcmp0(key, "INTERVAL"))
                                        interval = g_variant_get_uint32(value);
-                                       LOG_GPS(DBG_LOW, "INTERVAL [%u]", interval);
-                               }
 
-                               if (!g_strcmp0(key, "APP_ID")) {
+                               if (!g_strcmp0(key, "APP_ID"))
                                        app_id = g_variant_dup_string(value, &length);
-                                       LOG_GPS(DBG_LOW, "APP_ID [%s]", app_id);
-                               }
                        }
+                       LOG_GPS(DBG_LOW, "METHOD [%d], INTERVAL [%u], APP_ID [%s]", method, interval, app_id);
 
                        if (client)
-                               update_pos_tracking_interval(LBS_SERVER_INTERVAL_ADD, client, method, interval, lbs_server);
+                               update_pos_tracking_interval(LBS_SERVER_INTERVAL_ADD, client, method, interval, 0, lbs_server);
 
                        if (app_id) {
                                if (LBS_SERVER_METHOD_GPS == method)
@@ -892,19 +974,19 @@ static void set_options(GVariant *options, const gchar *client, gpointer userdat
                } else if (!g_strcmp0(g_variant_get_string(value, &length), "STOP")) {
 
                        while (g_variant_iter_next(&iter, "{&sv}", &key, &value)) {
-                               if (!g_strcmp0(key, "METHOD")) {
+                               if (!g_strcmp0(key, "METHOD"))
                                        method = g_variant_get_int32(value);
-                                       LOG_GPS(DBG_LOW, "METHOD [%d]", method);
-                               }
 
-                               if (!g_strcmp0(key, "APP_ID")) {
+                               if (!g_strcmp0(key, "INTERVAL"))
+                                       interval = g_variant_get_uint32(value);
+
+                               if (!g_strcmp0(key, "APP_ID"))
                                        app_id = g_variant_dup_string(value, &length);
-                                       LOG_GPS(DBG_LOW, "APP_ID [%s]", app_id);
-                               }
                        }
+                       LOG_GPS(DBG_LOW, "METHOD [%d], INTERVAL [%u], APP_ID [%s]", method, interval, app_id);
 
                        if (client)
-                               update_pos_tracking_interval(LBS_SERVER_INTERVAL_REMOVE, client, method, interval, lbs_server);
+                               update_pos_tracking_interval(LBS_SERVER_INTERVAL_REMOVE, client, method, interval, 0, lbs_server);
 
                        if (app_id) {
                                if (LBS_SERVER_METHOD_GPS == method)
@@ -995,16 +1077,19 @@ static void set_options(GVariant *options, const gchar *client, gpointer userdat
                                        is_update_interval_method = TRUE;
                                }
 
-                               if (!g_strcmp0(key, "INTERVAL_UPDATE")) {
+                               if (!g_strcmp0(key, "INTERVAL_UPDATE"))
                                        interval = g_variant_get_uint32(value);
-                                       LOG_GPS(DBG_LOW, "INTERVAL_UPDATE [%u] <-- [%u] ", interval, lbs_server->temp_minimum_interval);
-                                       if (interval != lbs_server->temp_minimum_interval)
-                                               is_update_interval = TRUE;
-                               }
+
+                               if (!g_strcmp0(key, "PREV_INTERVAL"))
+                                       prev_interval = g_variant_get_uint32(value);
                        }
 
+                       LOG_GPS(DBG_LOW, "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) {
-                               update_pos_tracking_interval(LBS_SERVER_INTERVAL_UPDATE, client, method, interval, lbs_server);
+                               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;
                                        request_change_pos_update_interval(method, (gpointer)lbs_server);
@@ -1069,7 +1154,6 @@ static void shutdown(gpointer userdata, gboolean *shutdown_arr)
 
 static void gps_update_position_cb(pos_data_t *pos, gps_error_t error, void *user_data)
 {
-       /* LOG_GPS(DBG_LOW, "ENTER >>>"); */
        GVariant *accuracy = NULL;
        LbsPositionExtFields fields;
 
@@ -1099,7 +1183,6 @@ static void gps_update_position_cb(pos_data_t *pos, gps_error_t error, void *use
 
 static void gps_update_batch_cb(batch_data_t *batch, void *user_data)
 {
-       /* LOG_GPS(DBG_LOW, "gps_update_batch_cb"); */
        lbs_server_s *lbs_server = (lbs_server_s *)(user_data);
        memcpy(&lbs_server->batch, batch, sizeof(batch_data_t));
 
@@ -1239,8 +1322,8 @@ static void lbs_server_init(lbs_server_s *lbs_server)
 #ifndef TIZEN_DEVICE
        lbs_server->batch_interval_table = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
        lbs_server->optimized_batch_array = (guint *)g_malloc0(LBS_BATCH_SIZE * sizeof(guint));
-       lbs_server->optimized_batch_array[LBS_BATCH_INTERVAL] = 150;
-       lbs_server->optimized_batch_array[LBS_BATCH_PERIOD] = 60000;
+       lbs_server->optimized_batch_array[LBS_BATCH_INTERVAL] = MAX_BATCH_INTERVAL;
+       lbs_server->optimized_batch_array[LBS_BATCH_PERIOD] = MAX_BATCH_PERIOD;
 #endif
 }
 
@@ -1696,8 +1779,8 @@ static gboolean update_batch_tracking_interval(lbs_server_interval_manipulation_
                }
        }
 
-       lbs_server->optimized_batch_array[LBS_BATCH_INTERVAL] = 151;
-       lbs_server->optimized_batch_array[LBS_BATCH_PERIOD] = 60001;
+       lbs_server->optimized_batch_array[LBS_BATCH_INTERVAL] = MAX_BATCH_INTERVAL + 1;
+       lbs_server->optimized_batch_array[LBS_BATCH_PERIOD] = MAX_BATCH_PERIOD + 1;
 
        if (g_hash_table_size(lbs_server->batch_interval_table) == 0) {
                return FALSE;

diff --git a/lbs-server/src/lbs_server.h b/lbs-server/src/lbs_server.h
index 1b47303f6f5045b274e3f6fb845e242dab82d621..fc256efbe30d8cc838fba1578190fdf454dde8a4 100755 (executable)
--- a/lbs-server/src/lbs_server.h
+++ b/lbs-server/src/lbs_server.h
@@ -42,6 +42,12 @@ 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/CMakeLists.txt b/module/CMakeLists.txt
index 22647ded073aaeb83aaa109e519982a2737a83e9..36edb1358ef5bbb55e612375f07c64383ec374a9 100644 (file)
--- a/module/CMakeLists.txt
+++ b/module/CMakeLists.txt
@@ -13,22 +13,16 @@ ADD_LIBRARY(${gps_module} SHARED ${CLIENT_SRCS_DIR}/gps_module.c)
 TARGET_LINK_LIBRARIES(${gps_module} ${module_pkgs_LDFLAGS})
 SET_TARGET_PROPERTIES(${gps_module} PROPERTIES VERSION ${FULLVER} SOVERSION ${MAJORVER} CLEAN_DIRECT_OUTPUT 1)
 SET_TARGET_PROPERTIES(${gps_module} PROPERTIES COMPILE_FLAGS ${MODULE_EXTRA_CFLAGS})
-
 INSTALL(TARGETS ${gps_module} DESTINATION ${LIB_DIR}/location/module)
 
-IF (ENABLE_WPS)
-       SET(nps_module "wps")
-       ADD_LIBRARY(${nps_module} SHARED ${CLIENT_SRCS_DIR}/nps_module.c)
-       TARGET_LINK_LIBRARIES(${nps_module} ${module_pkgs_LDFLAGS})
-       SET_TARGET_PROPERTIES(${nps_module} PROPERTIES VERSION ${FULLVER} SOVERSION ${MAJORVER} CLEAN_DIRECT_OUTPUT 1)
-       SET_TARGET_PROPERTIES(${nps_module} PROPERTIES COMPILE_FLAGS ${MODULE_EXTRA_CFLAGS})
-
-       INSTALL(TARGETS ${nps_module} DESTINATION ${LIB_DIR}/location/module)
-ENDIF (ENABLE_WPS)
+ADD_LIBRARY(${nps_module} SHARED ${CLIENT_SRCS_DIR}/nps_module.c)
+TARGET_LINK_LIBRARIES(${nps_module} ${module_pkgs_LDFLAGS})
+SET_TARGET_PROPERTIES(${nps_module} PROPERTIES VERSION ${FULLVER} SOVERSION ${MAJORVER} CLEAN_DIRECT_OUTPUT 1)
+SET_TARGET_PROPERTIES(${nps_module} PROPERTIES COMPILE_FLAGS ${MODULE_EXTRA_CFLAGS})
+INSTALL(TARGETS ${nps_module} DESTINATION ${LIB_DIR}/location/module)
 
 ADD_LIBRARY(${passive_module} SHARED ${CLIENT_SRCS_DIR}/passive_module.c)
 TARGET_LINK_LIBRARIES(${passive_module} ${module_pkgs_LDFLAGS})
 SET_TARGET_PROPERTIES(${passive_module} PROPERTIES VERSION ${FULLVER} SOVERSION ${MAJORVER} CLEAN_DIRECT_OUTPUT 1)
 SET_TARGET_PROPERTIES(${passive_module} PROPERTIES COMPILE_FLAGS ${MODULE_EXTRA_CFLAGS})
-
 INSTALL(TARGETS ${passive_module} DESTINATION ${LIB_DIR}/location/module)

diff --git a/module/gps_module.c b/module/gps_module.c
index 79b79a819bcaac5cd6e99e0049d226bfff396a2b..4fd8972bf964524fb28af3084b6b40ac54ed2ea9 100644 (file)
--- a/module/gps_module.c
+++ b/module/gps_module.c
@@ -49,6 +49,7 @@ typedef struct {
        LocModSatelliteCB sat_cb;
        gpointer userdata;
        gboolean is_started;
+       guint pos_interval;
 } GpsManagerData;
 
 static void status_callback(GVariant *param, void *user_data)
@@ -251,6 +252,7 @@ static int start(gpointer handle, guint pos_update_interval, LocModStatusCB stat
                return LOCATION_ERROR_NOT_AVAILABLE;
        }
 
+       mod_gps->pos_interval = pos_update_interval;
        return LOCATION_ERROR_NONE;
 }
 
@@ -264,7 +266,8 @@ static int stop(gpointer handle)
 
        int ret = LBS_CLIENT_ERROR_NONE;
 
-       ret = lbs_client_stop(mod_gps->lbs_client);
+       ret = lbs_client_stop(mod_gps->lbs_client, mod_gps->pos_interval);
+       MOD_LOGE("stop gps interval [%d]", mod_gps->pos_interval);
        if (ret != LBS_CLIENT_ERROR_NONE) {
                MOD_LOGE("Fail to stop. Error[%d]", ret);
                lbs_client_destroy(mod_gps->lbs_client);
@@ -488,13 +491,13 @@ static int set_option(gpointer handle, const char *option)
 
 static int set_position_update_interval(gpointer handle, guint interval)
 {
-       MOD_LOGD("set_position_update_interval [%d]", interval);
        GpsManagerData *mod_gps = (GpsManagerData *) handle;
        g_return_val_if_fail(mod_gps, LOCATION_ERROR_NOT_AVAILABLE);
        g_return_val_if_fail(mod_gps->lbs_client, LOCATION_ERROR_NOT_AVAILABLE);
 
        int ret;
-       ret = lbs_client_set_position_update_interval(mod_gps->lbs_client, interval);
+       MOD_LOGD("set_position_update inteval [%d] -> [%d]", mod_gps->pos_interval, interval);
+       ret = lbs_client_set_position_update_interval(mod_gps->lbs_client, interval, mod_gps->pos_interval);
        if (ret != LBS_CLIENT_ERROR_NONE) {
                if (ret == LBS_CLIENT_ERROR_ACCESS_DENIED) {
                        MOD_LOGE("Access denied[%d]", ret);
@@ -504,6 +507,8 @@ static int set_position_update_interval(gpointer handle, guint interval)
                return LOCATION_ERROR_NOT_AVAILABLE;
        }
 
+       mod_gps->pos_interval = interval;
+
        return LOCATION_ERROR_NONE;
 }
 
@@ -609,6 +614,7 @@ LOCATION_MODULE_API gpointer init(LocModGpsOps *ops)
        mod_gps->batch_cb = NULL;
        mod_gps->userdata = NULL;
        mod_gps->is_started = FALSE;
+       mod_gps->pos_interval = 0;
 
        return (gpointer) mod_gps;
 }
@@ -619,7 +625,7 @@ LOCATION_MODULE_API void shutdown(gpointer handle)
        g_return_if_fail(handle);
        GpsManagerData *mod_gps = (GpsManagerData *) handle;
        if (mod_gps->lbs_client) {
-               lbs_client_stop(mod_gps->lbs_client);
+               lbs_client_stop(mod_gps->lbs_client, mod_gps->pos_interval);
                lbs_client_destroy(mod_gps->lbs_client);
                mod_gps->lbs_client = NULL;
        }
@@ -628,8 +634,8 @@ LOCATION_MODULE_API void shutdown(gpointer handle)
        mod_gps->pos_cb = NULL;
        mod_gps->batch_cb = NULL;
        mod_gps->sat_cb = NULL;
+       mod_gps->pos_interval = 0;
 
        g_free(mod_gps);
        mod_gps = NULL;
-
 }

diff --git a/module/nps_module.c b/module/nps_module.c
index 86c4dfbc4b3411880f23b346ac29f08caeee82d1..145357b63be2560fecd9993d52a9ab3c6079370a 100644 (file)
--- a/module/nps_module.c
+++ b/module/nps_module.c
@@ -38,6 +38,7 @@
 
 #define MAX_NPS_LOC_ITEM       6
 #define MOCK_LOCATION_CLEAR_VALUE 999
+#define DEFAULT_INTERVAL_FOR_NOT_SUPPORTED 1
 
 typedef struct {
        lbs_client_dbus_h lbs_client;
@@ -141,7 +142,7 @@ static int start(gpointer handle, LocModStatusCB status_cb, LocModPositionExtCB
                return LOCATION_ERROR_NOT_AVAILABLE;
        }
 
-       ret = lbs_client_start(mod_nps->lbs_client, 1, LBS_CLIENT_LOCATION_CB | LBS_CLIENT_LOCATION_STATUS_CB, on_signal_callback, mod_nps);
+       ret = lbs_client_start(mod_nps->lbs_client, DEFAULT_INTERVAL_FOR_NOT_SUPPORTED, LBS_CLIENT_LOCATION_CB | LBS_CLIENT_LOCATION_STATUS_CB, on_signal_callback, mod_nps);
        if (ret != LBS_CLIENT_ERROR_NONE) {
                if (ret == LBS_CLIENT_ERROR_ACCESS_DENIED) {
                        MOD_NPS_LOGE("Access denied[%d]", ret);
@@ -167,7 +168,7 @@ static int stop(gpointer handle)
 
        int ret = LBS_CLIENT_ERROR_NONE;
 
-       ret = lbs_client_stop(mod_nps->lbs_client);
+       ret = lbs_client_stop(mod_nps->lbs_client, DEFAULT_INTERVAL_FOR_NOT_SUPPORTED);
        if (ret != LBS_CLIENT_ERROR_NONE) {
                MOD_NPS_LOGE("Fail to stop. Error[%d]", ret);
                lbs_client_destroy(mod_nps->lbs_client);
@@ -373,7 +374,7 @@ LOCATION_MODULE_API void shutdown(gpointer handle)
 
        if (mod_nps->lbs_client) {
                if (mod_nps->is_started)
-                       lbs_client_stop(mod_nps->lbs_client);
+                       lbs_client_stop(mod_nps->lbs_client, DEFAULT_INTERVAL_FOR_NOT_SUPPORTED);
 
                lbs_client_destroy(mod_nps->lbs_client);
                mod_nps->lbs_client = NULL;

diff --git a/packaging/lbs-server.changes b/packaging/lbs-server.changes
index 8742859e1f1d20fee904c938eecfd57e0ac706f7..b93d284ac562c89eade4694c9825cacd65588aee 100644 (file)
--- a/packaging/lbs-server.changes
+++ b/packaging/lbs-server.changes
@@ -1,3 +1,9 @@
+[Version]      lbs-server_1.0.9
+[Date]         28 Oct 2016
+[Changes]      Dynamic interval table for multi handle
+[Developer]    Kyoungjun Sung <kj7.sung@samsung.com>
+
+================================================================================
 [Version]      lbs-server_1.0.8
 [Date]         6 Sep 2016
 [Changes]      Passive location.

diff --git a/packaging/lbs-server.spec b/packaging/lbs-server.spec
index 515ece51ecfb090aff3f98272d33f64196eb6106..88da610f0c468b2126f0746514c0de5956bd2fff 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.8
+Version: 1.0.9
 Release: 1
 Group:   Location/Service
 License: Apache-2.0
@@ -71,9 +71,6 @@ export FFLAGS="$FFLAGS -DTIZEN_DEVICE"
 MAJORVER=`echo %{version} | awk 'BEGIN {FS="."}{print $1}'`
 cmake . -DCMAKE_INSTALL_PREFIX=%{_prefix} -DFULLVER=%{version} -DMAJORVER=${MAJORVER} \
         -DLIB_DIR=%{_libdir} -DINCLUDE_DIR=%{_includedir} -DSYSCONF_DIR=%{_sysconfdir} \
-#%if 0%{?model_build_feature_location_position_wps}
-#    -DENABLE_WPS=YES \
-#%endif
 
 make %{?jobs:-j%jobs}
 
@@ -126,11 +123,8 @@ rm -rf %{buildroot}
 %files -n location-lbs-server
 %manifest location-lbs-server.manifest
 %{_libdir}/location/module/libgps.so*
-%{_libdir}/location/module/libpassive.so*
-
-%if 0%{?model_build_feature_location_position_wps}
 %{_libdir}/location/module/libwps.so*
-%endif
+%{_libdir}/location/module/libpassive.so*
 
 %files -n lbs-server-plugin-devel
 %{_libdir}/pkgconfig/lbs-server-plugin.pc