From 5f1679e38eca1595a8f49e869505f8ef69c78159 Mon Sep 17 00:00:00 2001 From: chanywa Date: Thu, 21 Jul 2016 10:43:44 +0900 Subject: [PATCH] Set the SMACK security label to run given executable file in systemd services, and rollback previous commits Change-Id: I613d0724fd4b642ed40b0735039fe656e23cc710 --- lbs-server/include/gps_plugin_intf.h | 3 +- lbs-server/src/gps_plugin_module.c | 3 +- lbs-server/src/lbs_server.c | 309 ++++++++++++----------------------- lbs-server/src/server.c | 37 ++--- lbs-server/src/server.h | 6 +- module/gps_module.c | 2 +- packaging/lbs-server.changes | 6 - packaging/lbs-server.spec | 8 +- 8 files changed, 120 insertions(+), 254 deletions(-) diff --git a/lbs-server/include/gps_plugin_intf.h b/lbs-server/include/gps_plugin_intf.h index b0700fa..c871906 100644 --- a/lbs-server/include/gps_plugin_intf.h +++ b/lbs-server/include/gps_plugin_intf.h @@ -394,8 +394,7 @@ typedef struct { typedef struct { int interval; - int period; /**< Emulator */ - int session_status; /**< Emulator */ + int period; } gps_action_start_data_t; typedef struct { diff --git a/lbs-server/src/gps_plugin_module.c b/lbs-server/src/gps_plugin_module.c index 5339444..471d45a 100644 --- a/lbs-server/src/gps_plugin_module.c +++ b/lbs-server/src/gps_plugin_module.c @@ -50,8 +50,7 @@ int load_plugin_module(char *specific_name, void **plugin_handle) if (stat(plugin_path, &st) != 0) { strncpy(plugin_path, GPS_PLUGIN_PATH, sizeof(plugin_path)); - - /* Comment out to support real GPS when GPS plugin is installed*/ + /* To support real GPS when additional plugin is added*/ /* setting_set_int(VCONFKEY_LOCATION_REPLAY_ENABLED, 1); */ } } diff --git a/lbs-server/src/lbs_server.c b/lbs-server/src/lbs_server.c index 0fceeac..3e3b549 100755 --- a/lbs-server/src/lbs_server.c +++ b/lbs-server/src/lbs_server.c @@ -83,10 +83,6 @@ typedef struct { guint *optimized_interval_array; guint temp_minimum_interval; gboolean is_needed_changing_interval; -#ifndef TIZEN_DEVICE - GHashTable *batch_interval_table; - guint *optimized_batch_array; -#endif lbs_server_dbus_h lbs_dbus_server; @@ -106,14 +102,6 @@ typedef struct { int method; } dynamic_interval_updator_user_data; -#ifndef TIZEN_DEVICE -typedef enum { - LBS_BATCH_INTERVAL = 0, - LBS_BATCH_PERIOD, - LBS_BATCH_SIZE, -} lbs_batch_interval; -#endif - static gboolean gps_remove_all_clients(lbs_server_s *lbs_server); static NpsManagerPositionExt g_mock_position; static void set_mock_location_cb(gint method, gdouble latitude, gdouble longitude, gdouble altitude, gdouble speed, gdouble direction, gdouble accuracy, gpointer userdata); @@ -415,33 +403,36 @@ static void __nps_cancel_callback(void *arg) g_mutex_unlock(&lbs_server->mutex); } -#ifndef TIZEN_DEVICE static void start_batch_tracking(lbs_server_s *lbs_server, int batch_interval, int batch_period) { - LOG_GPS(DBG_LOW, "start_batch_tracking"); g_mutex_lock(&lbs_server->mutex); lbs_server->gps_client_count++; g_mutex_unlock(&lbs_server->mutex); - if (lbs_server->is_gps_running == FALSE) { - LOG_GPS(DBG_LOW, "Batch: start_tracking GPS"); - lbs_server->status = LBS_STATUS_ACQUIRING; + if (lbs_server->is_gps_running == TRUE) { + LOG_GPS(DBG_LOW, "Batch: gps is already running"); + return; } + LOG_GPS(DBG_LOW, "Batch: start_tracking GPS"); + lbs_server->status = LBS_STATUS_ACQUIRING; if (request_start_batch_session(batch_interval, batch_period) == TRUE) { 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; + + /* ADD notify */ setting_notify_key_changed(VCONFKEY_LOCATION_ENABLED, __setting_gps_cb, lbs_server); } else { LOG_GPS(DBG_ERR, "Batch: Fail to request_start_batch_session"); } } -static void stop_batch_tracking(lbs_server_s *lbs_server, int batch_interval, int batch_period) +static void stop_batch_tracking(lbs_server_s *lbs_server) { - LOG_GPS(DBG_LOW, "Batch: stop_tracking GPS"); + LOG_GPS(DBG_LOW, "ENTER >>>"); g_mutex_lock(&lbs_server->mutex); lbs_server->gps_client_count--; @@ -452,28 +443,22 @@ static void stop_batch_tracking(lbs_server_s *lbs_server, int batch_interval, in return; } - int session_status = 1; /* Keep current status */ if (lbs_server->gps_client_count <= 0) { g_mutex_lock(&lbs_server->mutex); lbs_server->gps_client_count = 0; - g_mutex_unlock(&lbs_server->mutex); - session_status = 0; /* stop */ - } - /* TURE: All clients stopped, FALSE: Some clients are running with GPS or BATCH */ - if (request_stop_batch_session(batch_interval, batch_period, session_status) == TRUE) { - g_mutex_lock(&lbs_server->mutex); - lbs_server->is_gps_running = FALSE; - lbs_server->sv_used = FALSE; - g_mutex_unlock(&lbs_server->mutex); - - setting_ignore_key_changed(VCONFKEY_LOCATION_ENABLED, __setting_gps_cb); + if (request_stop_batch_session() == TRUE) { + lbs_server->is_gps_running = FALSE; + lbs_server->sv_used = FALSE; + /* remove notify */ + setting_ignore_key_changed(VCONFKEY_LOCATION_ENABLED, __setting_gps_cb); + g_mutex_unlock(&lbs_server->mutex); + } } lbs_server->status = LBS_STATUS_UNAVAILABLE; lbs_server_emit_status_changed(lbs_server->lbs_dbus_server, LBS_SERVER_METHOD_GPS, LBS_STATUS_UNAVAILABLE); } -#endif static void start_tracking(lbs_server_s *lbs_server, lbs_server_method_e method) { @@ -726,77 +711,77 @@ 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(LBS_SERVER_METHOD_SIZE * sizeof(guint)); + 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_ERR, "interval_array is NULL"); */ - g_free(client_cpy); - return FALSE; + /* LOG_GPS(DBG_LOW, "first add key[%s] to interval-table", client); */ + interval_array = (guint *)g_malloc0(LBS_SERVER_METHOD_SIZE * 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); } - 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"); */ + break; } - interval_array[method] = interval; - lbs_server->temp_minimum_interval = interval; - /* 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 */ - 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; - - 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); - is_need_remove_client_from_table = FALSE; + LOG_GPS(DBG_LOW, "REMOVE, client[%s], method[%d]", client, method); + lbs_server->temp_minimum_interval = 120; /* interval max value */ + 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; + + 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); + is_need_remove_client_from_table = FALSE; + break; + } + } - 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."); + 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; } - break; - } case LBS_SERVER_INTERVAL_UPDATE: { - LOG_GPS(DBG_LOW, "UPDATE client[%s], method[%d], interval[%u]", client, method, 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); + LOG_GPS(DBG_LOW, "UPDATE client[%s], method[%d], interval[%u]", client, method, 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; + LOG_GPS(DBG_LOW, "UPDATE done."); break; } - interval_array[method] = interval; - lbs_server->temp_minimum_interval = interval; - LOG_GPS(DBG_LOW, "UPDATE done."); - break; - } default: { - LOG_GPS(DBG_ERR, "unhandled interval-update type"); - return FALSE; - } + LOG_GPS(DBG_ERR, "unhandled interval-update type"); + return FALSE; + } } /* update logic for optimized-interval value */ @@ -808,6 +793,8 @@ static gboolean update_pos_tracking_interval(lbs_server_interval_manipulation_ty ret_val = FALSE; } else { + LOG_GPS(DBG_LOW, "dynamic_interval_table size is not zero."); + dynamic_interval_updator_user_data updator_user_data; updator_user_data.lbs_server = lbs_server; updator_user_data.method = method; @@ -828,6 +815,7 @@ static gboolean update_pos_tracking_interval(lbs_server_interval_manipulation_ty else ret_val = FALSE; } + LOG_GPS(DBG_LOW, "update_pos_tracking_interval done."); return ret_val; } @@ -856,10 +844,6 @@ static void get_nmea(int *timestamp, gchar **nmea_data, gpointer userdata) LOG_GPS(DBG_LOW, "timestmap: %d, nmea_data: %s", *timestamp, *nmea_data); } -#ifndef TIZEN_DEVICE -static gboolean update_batch_tracking_interval(lbs_server_interval_manipulation_type type, const gchar *client, guint interval, guint period, gpointer userdata); -#endif - static void set_options(GVariant *options, const gchar *client, gpointer userdata) { LOG_GPS(DBG_LOW, "ENTER >>>"); @@ -954,38 +938,43 @@ static void set_options(GVariant *options, const gchar *client, gpointer userdat 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")) { + } else if (!g_strcmp0(g_variant_get_string(value, &length), "START_BATCH")) { - gint b_interval = 0, b_period = 0; + int batch_interval = 0; + int batch_period = 0; while (g_variant_iter_next(&iter, "{&sv}", &key, &value)) { if (!g_strcmp0(key, "BATCH_INTERVAL")) { - b_interval = g_variant_get_int32(value); + batch_interval = g_variant_get_int32(value); + LOG_GPS(DBG_LOW, "BATCH_INTERVAL [%d]", batch_interval); } else if (!g_strcmp0(key, "BATCH_PERIOD")) { - b_period = g_variant_get_int32(value); + batch_period = g_variant_get_int32(value); + LOG_GPS(DBG_LOW, "BATCH_PERIOD [%d]", batch_period); } } - LOG_GPS(DBG_LOW, "BATCH_INTERVAL [%d], BATCH_PERIOD [%d]", b_interval, b_period); if (client) - update_batch_tracking_interval(LBS_SERVER_INTERVAL_ADD, client, b_interval, b_period, lbs_server); + update_pos_tracking_interval(LBS_SERVER_INTERVAL_ADD, client, method, batch_interval, lbs_server); - start_batch_tracking(lbs_server, lbs_server->optimized_batch_array[LBS_BATCH_INTERVAL], - lbs_server->optimized_batch_array[LBS_BATCH_PERIOD]); + start_batch_tracking(lbs_server, batch_interval, batch_period); - } - else if (!g_strcmp0(g_variant_get_string(value, &length), "STOP_BATCH")) { + 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_BATCH")) { if (client) - update_batch_tracking_interval(LBS_SERVER_INTERVAL_REMOVE, client, 0, 0, lbs_server); + update_pos_tracking_interval(LBS_SERVER_INTERVAL_REMOVE, client, method, interval, lbs_server); - stop_batch_tracking(lbs_server, lbs_server->optimized_batch_array[LBS_BATCH_INTERVAL], - lbs_server->optimized_batch_array[LBS_BATCH_PERIOD]); + stop_batch_tracking(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); + } } -#endif #ifdef _TIZEN_PUBLIC_ else if (!g_strcmp0(g_variant_get_string(value, &length), "SUPLNI")) { while (g_variant_iter_next(&iter, "{&sv}", &key, &value)) { @@ -1111,6 +1100,7 @@ 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; @@ -1135,7 +1125,7 @@ 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"); */ + LOG_GPS(DBG_LOW, "ENTER >>>"); lbs_server_s *lbs_server = (lbs_server_s *)(user_data); memcpy(&lbs_server->batch, batch, sizeof(batch_data_t)); @@ -1151,7 +1141,7 @@ static void gps_update_satellite_cb(sv_data_t *sv, void *user_data) { lbs_server_s *lbs_server = (lbs_server_s *)(user_data); if (lbs_server->sv_used == FALSE) { - /* LOG_GPS(DBG_LOW, "sv_used is FALSE"); */ + /*LOG_GPS(DBG_LOW, "sv_used is FALSE"); */ return; } @@ -1275,13 +1265,6 @@ static void lbs_server_init(lbs_server_s *lbs_server) lbs_server->is_mock_running = FALSE; lbs_server->gps_client_count = 0; lbs_server->mock_timer = 0; - -#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; -#endif } static void nps_get_last_position(lbs_server_s *lbs_server_nps) @@ -1483,7 +1466,6 @@ int main(int argc, char **argv) LOG_GPS(DBG_ERR, "lbs_server_create failed"); return 1; } - LOG_GPS(DBG_LOW, "lbs_server_create called"); lbs_server->loop = g_main_loop_new(NULL, TRUE); @@ -1496,10 +1478,7 @@ int main(int argc, char **argv) /* destroy resource for dynamic-interval */ g_free(lbs_server->optimized_interval_array); g_hash_table_destroy(lbs_server->dynamic_interval_table); -#ifndef TIZEN_DEVICE - g_free(lbs_server->optimized_batch_array); - g_hash_table_destroy(lbs_server->batch_interval_table); -#endif + /* free dbus callback */ g_free(lbs_dbus_callback); @@ -1716,91 +1695,3 @@ static void __setting_mock_cb(keynode_t *key, gpointer user_data) LOG_MOCK(DBG_LOW, "already removed."); } } - -#ifndef TIZEN_DEVICE -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; - - 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]; - - if (lbs_server->optimized_batch_array[LBS_BATCH_PERIOD] > interval_array[LBS_BATCH_PERIOD]) - lbs_server->optimized_batch_array[LBS_BATCH_PERIOD] = interval_array[LBS_BATCH_PERIOD]; - - LOG_GPS(DBG_LOW, "foreach dynamic-batch. key:[%s]-batch[interval:%u, period:%u], optimized [%u, %u]", (char *)key, interval_array[LBS_BATCH_INTERVAL], interval_array[LBS_BATCH_PERIOD], lbs_server->optimized_batch_array[LBS_BATCH_INTERVAL], lbs_server->optimized_batch_array[LBS_BATCH_PERIOD]); -} - -static gboolean update_batch_tracking_interval(lbs_server_interval_manipulation_type type, const gchar *client, guint interval, guint period, gpointer userdata) -{ - LOG_GPS(DBG_INFO, "update_batch_tracking_interval"); - if (userdata == NULL) return FALSE; - if (client == NULL) { - LOG_GPS(DBG_ERR, "client is NULL"); - return FALSE; - } - - lbs_server_s *lbs_server = (lbs_server_s *)userdata; - - switch (type) { - case LBS_SERVER_INTERVAL_ADD: { - LOG_GPS(DBG_LOW, "ADD, client[%s], interval[%u], period[%u]", client, interval, period); - gchar *client_cpy = NULL; - client_cpy = g_strdup(client); - - guint* interval_array = (guint *) g_hash_table_lookup(lbs_server->batch_interval_table, client_cpy); - if (!interval_array) { - LOG_GPS(DBG_LOW, "first add key[%s] to batch-table", client); - interval_array = (guint *)g_malloc0(LBS_BATCH_SIZE * 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->batch_interval_table, (gpointer)client_cpy, (gpointer)interval_array); - } - interval_array[LBS_BATCH_INTERVAL] = interval; - interval_array[LBS_BATCH_PERIOD] = period; - break; - } - - case LBS_SERVER_INTERVAL_REMOVE: { - LOG_GPS(DBG_LOW, "REMOVE, client[%s]", client); - guint *interval_array = (guint *) g_hash_table_lookup(lbs_server->batch_interval_table, client); - if(!interval_array) { - LOG_GPS(DBG_INFO, "Client[%s] is already removed from batch-table", client); - break; - } - LOG_GPS(DBG_LOW, "Remove interval_array(%p):[%u, %u] from batch-table", interval_array, interval_array[LBS_BATCH_INTERVAL], interval_array[LBS_BATCH_PERIOD]); - - if (!g_hash_table_remove(lbs_server->batch_interval_table, client)) { - LOG_GPS(DBG_ERR, "g_hash_table_remove is failed."); - } - break; - } - - default: { - LOG_GPS(DBG_ERR, "unhandled interval-update type"); - return FALSE; - } - } - - lbs_server->optimized_batch_array[LBS_BATCH_INTERVAL] = 151; - lbs_server->optimized_batch_array[LBS_BATCH_PERIOD] = 60001; - - if (g_hash_table_size(lbs_server->batch_interval_table) == 0) { - return FALSE; - } else { - LOG_GPS(DBG_LOW, "updates optimized-batch-interval."); - dynamic_interval_updator_user_data updator_user_data; // temporary struct - 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); - } - LOG_GPS(DBG_LOW, "Updates_batch_tracking_interval done."); - return TRUE; -} -#endif diff --git a/lbs-server/src/server.c b/lbs-server/src/server.c index 78bf24a..d7835aa 100644 --- a/lbs-server/src/server.c +++ b/lbs-server/src/server.c @@ -306,7 +306,6 @@ int request_stop_session() return status; } -#ifndef TIZEN_DEVICE int request_start_batch_session(int batch_interval, int batch_period) { LOG_GPS(DBG_INFO, "Batch: GPS start with interval[%d]", batch_interval); @@ -316,10 +315,10 @@ int request_start_batch_session(int batch_interval, int batch_period) gps_server_t *server = g_gps_server; gps_action_start_data_t gps_start_data; - if (server->session_state == GPS_SESSION_STARTING || server->session_state == GPS_SESSION_STARTED) - gps_start_data.session_status = 1; /* 1:Already running, 0:need to start*/ - else - gps_start_data.session_status = 0; + if (server->session_state != GPS_SESSION_STOPPED && server->session_state != GPS_SESSION_STOPPING) { + LOG_GPS(DBG_WARN, "Batch: GPS Session Already Started!"); + return TRUE; + } server->session_state = GPS_SESSION_STARTING; LOG_GPS(DBG_LOW, "==GPSSessionState[%d]", server->session_state); @@ -339,22 +338,17 @@ int request_start_batch_session(int batch_interval, int batch_period) return TRUE; } -int request_stop_batch_session(int batch_interval, int batch_period, int session_status) +int request_stop_batch_session() { gboolean status = TRUE; gboolean cur_replay_enabled = FALSE; gps_failure_reason_t reason_code = GPS_FAILURE_CAUSE_NORMAL; gps_server_t *server = g_gps_server; - gps_action_start_data_t gps_start_data; - gps_start_data.interval = batch_interval; - gps_start_data.period = batch_period; - gps_start_data.session_status = session_status; /* 0:need to stop, 1:keep status */ LOG_GPS(DBG_LOW, "Batch: Stop GPS Session, ==GPSSessionState[%d]", server->session_state); if (server->session_state == GPS_SESSION_STARTED || server->session_state == GPS_SESSION_STARTING) { - /* TURE: All clients stopped, FALSE: Some clients are running with GPS or BATCH */ - status = get_plugin_module()->request(GPS_ACTION_STOP_BATCH, &gps_start_data, &reason_code); - if (status == TRUE && session_status == 0) { + status = get_plugin_module()->request(GPS_ACTION_STOP_BATCH, NULL, &reason_code); + if (status) { server->session_state = GPS_SESSION_STOPPING; LOG_GPS(DBG_LOW, "==GPSSessionState[%d]", server->session_state); cur_replay_enabled = get_replay_enabled(); @@ -364,15 +358,14 @@ int request_stop_batch_session(int batch_interval, int batch_period, int session } setting_notify_key_changed(VCONFKEY_LOCATION_REPLAY_ENABLED, _gps_replay_changed_cb, (void *)server); } else { - LOG_GPS(DBG_ERR, " Client exists. plugin->request to LBS_GPS_STOP_SESSION passed"); - status = FALSE; + LOG_GPS(DBG_ERR, "plugin->request to LBS_GPS_STOP_SESSION Failed, reasonCode =%d", reason_code); } } else { - LOG_GPS(DBG_LOW, " Keep the client status because the GPS state is not started"); + /* If request is not sent, keep the client registed */ + LOG_GPS(DBG_LOW, " LBS_GPS_STOP_SESSION is not sent because the GPS state is not started, keep the client registed "); } return status; } -#endif int request_add_geofence(int fence_id, double latitude, double longitude, int radius, int last_state, int monitor_states, int notification_responsiveness, int unknown_timer) { @@ -389,8 +382,8 @@ int request_add_geofence(int fence_id, double latitude, double longitude, int ra /* Default value : temp */ action_data.notification_responsiveness_ms = 5000; action_data.unknown_timer_ms = 30000; - /* action_data.notification_responsiveness_ms = notification_responsiveness; */ - /* action_data.unknown_timer_ms = unknown_timer; */ + /*action_data.notification_responsiveness_ms = notification_responsiveness; */ + /*action_data.unknown_timer_ms = unknown_timer; */ LOG_GPS(DBG_LOW, "request_add_geofence with geofence_id [%d]", fence_id); status = get_plugin_module()->request(GPS_ACTION_ADD_GEOFENCE, &action_data, &reason_code); @@ -1093,14 +1086,14 @@ void check_plugin_module(char *module_name) } else if (access(CSR_PATH, F_OK) == 0) { g_strlcpy(module_name, "csr", strlen("csr") + 1); } else if (access(QCOM8x30_PATH, F_OK) == 0 || access(QCOM9x15_PATH, F_OK) == 0 || - access(QCOM8974_PATH, F_OK) == 0 || access(QCOM8210_PATH, F_OK) == 0 || - access(QCOM8226_PATH, F_OK) == 0 || access(QCOM8916_PATH, F_OK) == 0) { + access(QCOM8974_PATH, F_OK) == 0 || access(QCOM8210_PATH, F_OK) == 0 || + access(QCOM8226_PATH, F_OK) == 0 || access(QCOM8916_PATH, F_OK) == 0) { g_strlcpy(module_name, "qcom", strlen("qcom") + 1); } else { g_strlcpy(module_name, "replay", strlen("replay") + 1); } - LOG_GPS(DBG_LOW, ">> module name : %s", module_name); + LOG_GPS(DBG_LOW, "module name : %s", module_name); } static gps_server_t *_initialize_gps_data(void) diff --git a/lbs-server/src/server.h b/lbs-server/src/server.h index 1c8cea0..3584020 100644 --- a/lbs-server/src/server.h +++ b/lbs-server/src/server.h @@ -70,12 +70,8 @@ int initialize_server(int argc, char **argv); int deinitialize_server(); int request_change_pos_update_interval_standalone_gps(unsigned int interval); - -#ifndef TIZEN_DEVICE int request_start_batch_session(int batch_interval, int batch_period); -int request_stop_batch_session(int batch_interval, int batch_period, int session_status); -#endif - +int request_stop_batch_session(void); int request_start_session(int interval); int request_stop_session(void); #ifndef _TIZEN_PUBLIC_ diff --git a/module/gps_module.c b/module/gps_module.c index fb0540b..f642efb 100644 --- a/module/gps_module.c +++ b/module/gps_module.c @@ -156,7 +156,7 @@ static void position_callback(GVariant *param, void *user_data) g_variant_get(param, "(iiidddddd@(idd))", &method, &fields, ×tamp, &latitude, &longitude, &altitude, &speed, &direction, &climb, &accuracy); - /* MOD_LOGD("position_callback [method: %d, field: %d]", method, fields); */ + MOD_LOGD("position_callback [method: %d, field: %d]", method, fields); if (method != LBS_CLIENT_METHOD_GPS) { MOD_LOGD("Method is not LBS_CLIENT_METHOD_GPS: %d", method); return; diff --git a/packaging/lbs-server.changes b/packaging/lbs-server.changes index 22138cb..e5e1386 100644 --- a/packaging/lbs-server.changes +++ b/packaging/lbs-server.changes @@ -1,9 +1,3 @@ -[Version] lbs-server_1.0.5 -[Date] 7 Jul 2016 -[Changes] Change batch behavior about HW batching in emulator mode. -[Developer] Kyoungjun Sung - -================================================================================ [Version] lbs-server_1.0.4 [Date] 30 Jun 2016 [Changes] Change to non-root daemon. diff --git a/packaging/lbs-server.spec b/packaging/lbs-server.spec index 0c85185..be31328 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.5 +Version: 1.0.4 Release: 1 Group: Location/Service License: Apache-2.0 @@ -62,12 +62,6 @@ export CFLAGS="$CFLAGS -DTIZEN_DEBUG_ENABLE" export CXXFLAGS="$CXXFLAGS -DTIZEN_DEBUG_ENABLE" export FFLAGS="$FFLAGS -DTIZEN_DEBUG_ENABLE" -%ifarch %arm aarch64 -export CFLAGS="$CFLAGS -DTIZEN_DEVICE" -export CXXFLAGS="$CXXFLAGS -DTIZEN_DEVICE" -export FFLAGS="$FFLAGS -DTIZEN_DEVICE" -%endif - 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} \ -- 2.7.4