From: kj7.sung Date: Mon, 17 Jul 2017 05:14:27 +0000 (+0900) Subject: Remove unused parameter X-Git-Tag: submit/tizen/20170717.080446^0 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=bca79ecf5b34b7bda8b690e512f8b26958c94ee9;p=platform%2Fcore%2Flocation%2Flbs-server.git Remove unused parameter Change-Id: Id0c927f74921d6b89257b1ae73185c163e34df14 Signed-off-by: kj7.sung --- diff --git a/lbs-server/src/lbs_server.c b/lbs-server/src/lbs_server.c index fae7aa4..89c33d0 100644 --- a/lbs-server/src/lbs_server.c +++ b/lbs-server/src/lbs_server.c @@ -63,7 +63,7 @@ typedef struct { gint gps_client_count; /* nps variables */ - NpsManagerHandle handle; + NpsManagerHandle nps_handle; unsigned long period; NpsManagerPositionExt pos; NpsManagerLastPositionExt last_pos; @@ -81,7 +81,7 @@ typedef struct { /* dynamic interval update */ GHashTable *dynamic_interval_table; - guint *optimized_interval_array; + guint *optimized_interval; guint temp_minimum_interval; gboolean is_needed_changing_interval; #ifndef TIZEN_DEVICE @@ -180,26 +180,26 @@ static void nps_set_last_position(NpsManagerPositionExt pos) setting_set_string(VCONFKEY_LOCATION_NV_LAST_WPS_LOCATION, location); } -static void nps_set_position(lbs_server_s *lbs_server_nps, NpsManagerPositionExt pos) +static void nps_set_position(lbs_server_s *lbs_server, NpsManagerPositionExt pos) { LOG_NPS(DBG_LOW, "set position timestamp : %d", pos.timestamp); - lbs_server_nps->last_pos.timestamp = pos.timestamp; - setting_set_int(VCONFKEY_LOCATION_LAST_WPS_TIMESTAMP, lbs_server_nps->last_pos.timestamp); + lbs_server->last_pos.timestamp = pos.timestamp; + setting_set_int(VCONFKEY_LOCATION_LAST_WPS_TIMESTAMP, lbs_server->last_pos.timestamp); - if ((lbs_server_nps->last_pos.latitude != pos.latitude) || (lbs_server_nps->last_pos.longitude != pos.longitude)) { - lbs_server_nps->last_pos.latitude = pos.latitude; - lbs_server_nps->last_pos.longitude = pos.longitude; - lbs_server_nps->last_pos.altitude = pos.altitude; - lbs_server_nps->last_pos.hor_accuracy = pos.hor_accuracy; - lbs_server_nps->last_pos.speed = pos.speed; - lbs_server_nps->last_pos.direction = pos.direction; + if ((lbs_server->last_pos.latitude != pos.latitude) || (lbs_server->last_pos.longitude != pos.longitude)) { + lbs_server->last_pos.latitude = pos.latitude; + lbs_server->last_pos.longitude = pos.longitude; + lbs_server->last_pos.altitude = pos.altitude; + lbs_server->last_pos.hor_accuracy = pos.hor_accuracy; + lbs_server->last_pos.speed = pos.speed; + lbs_server->last_pos.direction = pos.direction; - setting_set_double(VCONFKEY_LOCATION_LAST_WPS_LATITUDE, lbs_server_nps->last_pos.latitude); - setting_set_double(VCONFKEY_LOCATION_LAST_WPS_LONGITUDE, lbs_server_nps->last_pos.longitude); - setting_set_double(VCONFKEY_LOCATION_LAST_WPS_ALTITUDE, lbs_server_nps->last_pos.altitude); - setting_set_double(VCONFKEY_LOCATION_LAST_WPS_SPEED, lbs_server_nps->last_pos.speed); - setting_set_double(VCONFKEY_LOCATION_LAST_WPS_DIRECTION, lbs_server_nps->last_pos.direction); - setting_set_double(VCONFKEY_LOCATION_LAST_WPS_HOR_ACCURACY, lbs_server_nps->last_pos.hor_accuracy); + setting_set_double(VCONFKEY_LOCATION_LAST_WPS_LATITUDE, lbs_server->last_pos.latitude); + setting_set_double(VCONFKEY_LOCATION_LAST_WPS_LONGITUDE, lbs_server->last_pos.longitude); + setting_set_double(VCONFKEY_LOCATION_LAST_WPS_ALTITUDE, lbs_server->last_pos.altitude); + setting_set_double(VCONFKEY_LOCATION_LAST_WPS_SPEED, lbs_server->last_pos.speed); + setting_set_double(VCONFKEY_LOCATION_LAST_WPS_DIRECTION, lbs_server->last_pos.direction); + setting_set_double(VCONFKEY_LOCATION_LAST_WPS_HOR_ACCURACY, lbs_server->last_pos.hor_accuracy); } int last_timestamp = 0; @@ -210,63 +210,63 @@ static void nps_set_position(lbs_server_s *lbs_server_nps, NpsManagerPositionExt nps_set_last_position(pos); } -static void nps_set_status(lbs_server_s *lbs_server_nps, LbsStatus status) +static void nps_set_status(lbs_server_s *lbs_server, LbsStatus status) { - if (!lbs_server_nps) { - LOG_NPS(DBG_ERR, "lbs_server_nps is NULL!!"); + if (!lbs_server) { + LOG_NPS(DBG_ERR, "lbs_server is NULL!!"); return; } - LOG_NPS(DBG_LOW, "Previous status: %d, Current status: %d", lbs_server_nps->status, status); - if (lbs_server_nps->status == status) { + LOG_NPS(DBG_LOW, "Previous status: %d, Current status: %d", lbs_server->status, status); + if (lbs_server->status == status) { LOG_NPS(DBG_WARN, "Don't update NPS status"); return; } - lbs_server_nps->status = status; + lbs_server->status = status; - if (lbs_server_nps->status == LBS_STATUS_AVAILABLE) + if (lbs_server->status == LBS_STATUS_AVAILABLE) setting_set_int(VCONFKEY_LOCATION_WPS_STATE, POSITION_CONNECTED); - else if (lbs_server_nps->status == LBS_STATUS_ACQUIRING) + else if (lbs_server->status == LBS_STATUS_ACQUIRING) setting_set_int(VCONFKEY_LOCATION_WPS_STATE, POSITION_SEARCHING); else setting_set_int(VCONFKEY_LOCATION_WPS_STATE, POSITION_OFF); if (status != LBS_STATUS_AVAILABLE) - lbs_server_nps->pos.fields = LBS_POSITION_FIELDS_NONE; + lbs_server->pos.fields = LBS_POSITION_FIELDS_NONE; - lbs_server_emit_status_changed(lbs_server_nps->lbs_dbus_server, LBS_SERVER_METHOD_NPS, status); + lbs_server_emit_status_changed(lbs_server->lbs_dbus_server, LBS_SERVER_METHOD_NPS, status); } -static void nps_update_position(lbs_server_s *lbs_server_nps, NpsManagerPositionExt pos) +static void nps_update_position(lbs_server_s *lbs_server, NpsManagerPositionExt pos) { - if (!lbs_server_nps) { + if (!lbs_server) { LOG_NPS(DBG_ERR, "lbs-server is NULL!!"); return; } - if (lbs_server_nps->is_mock_running != MOCK_RUNNING_OFF) + if (lbs_server->is_mock_running != MOCK_RUNNING_OFF) return ; GVariant *accuracy = NULL; - lbs_server_nps->pos.fields = pos.fields; - lbs_server_nps->pos.timestamp = pos.timestamp; - lbs_server_nps->pos.latitude = pos.latitude; - lbs_server_nps->pos.longitude = pos.longitude; - lbs_server_nps->pos.altitude = pos.altitude; - lbs_server_nps->pos.hor_accuracy = pos.hor_accuracy; - lbs_server_nps->pos.ver_accuracy = pos.ver_accuracy; + lbs_server->pos.fields = pos.fields; + lbs_server->pos.timestamp = pos.timestamp; + lbs_server->pos.latitude = pos.latitude; + lbs_server->pos.longitude = pos.longitude; + lbs_server->pos.altitude = pos.altitude; + lbs_server->pos.hor_accuracy = pos.hor_accuracy; + lbs_server->pos.ver_accuracy = pos.ver_accuracy; - accuracy = g_variant_ref_sink(g_variant_new("(idd)", lbs_server_nps->pos.acc_level, lbs_server_nps->pos.hor_accuracy, lbs_server_nps->pos.ver_accuracy)); + accuracy = g_variant_ref_sink(g_variant_new("(idd)", lbs_server->pos.acc_level, lbs_server->pos.hor_accuracy, lbs_server->pos.ver_accuracy)); - LOG_NPS(DBG_LOW, "time:%d", lbs_server_nps->pos.timestamp); + LOG_NPS(DBG_LOW, "time:%d", lbs_server->pos.timestamp); send_wps_position_to_fused_engine(pos.timestamp, pos.latitude, pos.longitude, pos.hor_accuracy, pos.ver_accuracy); - lbs_server_emit_position_changed(lbs_server_nps->lbs_dbus_server, LBS_SERVER_METHOD_NPS, - lbs_server_nps->pos.fields, lbs_server_nps->pos.timestamp, lbs_server_nps->pos.latitude, - lbs_server_nps->pos.longitude, lbs_server_nps->pos.altitude, lbs_server_nps->pos.speed, - lbs_server_nps->pos.direction, 0.0, accuracy); + lbs_server_emit_position_changed(lbs_server->lbs_dbus_server, LBS_SERVER_METHOD_NPS, + lbs_server->pos.fields, lbs_server->pos.timestamp, lbs_server->pos.latitude, + lbs_server->pos.longitude, lbs_server->pos.altitude, lbs_server->pos.speed, + lbs_server->pos.direction, 0.0, accuracy); g_variant_unref(accuracy); } @@ -274,9 +274,9 @@ static void nps_update_position(lbs_server_s *lbs_server_nps, NpsManagerPosition static gboolean nps_report_callback(gpointer user_data) { LOG_NPS(DBG_LOW, "ENTER >>>"); - lbs_server_s *lbs_server_nps = (lbs_server_s *)user_data; - if (!lbs_server_nps) { - LOG_NPS(DBG_ERR, "lbs_server_nps is NULL!!"); + lbs_server_s *lbs_server = (lbs_server_s *)user_data; + if (!lbs_server) { + LOG_NPS(DBG_ERR, "lbs_server is NULL!!"); return FALSE; } @@ -284,16 +284,16 @@ static gboolean nps_report_callback(gpointer user_data) time_t timestamp; Plugin_LocationInfo location; - g_mutex_lock(&lbs_server_nps->mutex); + g_mutex_lock(&lbs_server->mutex); memset(&location, 0x00, sizeof(Plugin_LocationInfo)); - memcpy(&location, &lbs_server_nps->location, sizeof(Plugin_LocationInfo)); - g_mutex_unlock(&lbs_server_nps->mutex); + memcpy(&location, &lbs_server->location, sizeof(Plugin_LocationInfo)); + g_mutex_unlock(&lbs_server->mutex); time(×tamp); - if (timestamp == lbs_server_nps->last_pos.timestamp) + if (timestamp == lbs_server->last_pos.timestamp) return FALSE; - nps_set_status(lbs_server_nps, LBS_STATUS_AVAILABLE); + nps_set_status(lbs_server, LBS_STATUS_AVAILABLE); NpsManagerPositionExt pos; memset(&pos, 0x00, sizeof(NpsManagerPositionExt)); @@ -328,9 +328,9 @@ static gboolean nps_report_callback(gpointer user_data) pos.hor_accuracy = location.hpe; pos.ver_accuracy = vertical_accuracy; - nps_update_position(lbs_server_nps, pos); + nps_update_position(lbs_server, pos); - nps_set_position(lbs_server_nps, pos); + nps_set_position(lbs_server, pos); return FALSE; } @@ -360,8 +360,8 @@ static void __nps_callback(void *arg, const Plugin_LocationInfo *location, const static void _nps_token_callback(void *arg, const unsigned char *token, unsigned tokenSize) { LOG_NPS(DBG_LOW, "ENTER >>>"); - lbs_server_s *lbs_server_nps = (lbs_server_s *)arg; - if (NULL == lbs_server_nps) { + lbs_server_s *lbs_server = (lbs_server_s *)arg; + if (NULL == lbs_server) { LOG_NPS(DBG_ERR, "lbs-server is NULL!!"); return; } @@ -370,13 +370,13 @@ static void _nps_token_callback(void *arg, const unsigned char *token, unsigned LOG_NPS(DBG_ERR, "*** no token to save\n"); } else { /* save the token in persistent storage */ - g_mutex_lock(&lbs_server_nps->mutex); - lbs_server_nps->token = g_new0(unsigned char, tokenSize); + g_mutex_lock(&lbs_server->mutex); + lbs_server->token = g_new0(unsigned char, tokenSize); - if (lbs_server_nps->token) - memcpy(lbs_server_nps->token, token, tokenSize); + if (lbs_server->token) + memcpy(lbs_server->token, token, tokenSize); - g_mutex_unlock(&lbs_server_nps->mutex); + g_mutex_unlock(&lbs_server->mutex); } LOG_NPS(DBG_LOW, "_nps_token_callback ended"); } @@ -390,11 +390,11 @@ static void _network_enabled_cb(keynode_t *key, void *user_data) setting_get_int(VCONFKEY_LOCATION_NETWORK_ENABLED, &enabled); /* This is vestige of nps-server - lbs_server_s *lbs_server_nps = (lbs_server_s *)user_data; + lbs_server_s *lbs_server = (lbs_server_s *)user_data; if (enabled == 0) { - if (lbs_server_nps->loop != NULL) { - g_main_loop_quit(lbs_server_nps->loop); + if (lbs_server->loop != NULL) { + g_main_loop_quit(lbs_server->loop); } } */ @@ -449,61 +449,6 @@ 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"); - client_count_updater(lbs_server, LBS_SERVER_METHOD_GPS, _LBS_CLIENT_ADD, LOCATION_FUSED_NONE); - - if (lbs_server->is_gps_running == FALSE) { - 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); - - 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) -{ - LOG_GPS(DBG_LOW, "Batch: stop_tracking GPS"); - client_count_updater(lbs_server, LBS_SERVER_METHOD_GPS, _LBS_CLIENT_REMOVE, LOCATION_FUSED_NONE); - - if (lbs_server->is_gps_running == FALSE) { - LOG_GPS(DBG_LOW, "Batch: gps- is already stopped"); - 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 */ - } - - /* TRUE: All clients stopped, FALSE: Some clients are running with GPS or BATCH */ - if (request_stop_batch_session(batch_interval, batch_period, session_status) == TRUE) { - 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); - } - - 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 gboolean location_source_selector(lbs_server_s *lbs_server, gint fused_mode); static void plugin_status_controller(lbs_server_s *lbs_server); @@ -550,35 +495,35 @@ static void start_tracking(lbs_server_s *lbs_server, lbs_server_method_e method, } -static gboolean nps_plugin_stop(lbs_server_s *lbs_server_nps) +static gboolean nps_plugin_stop(lbs_server_s *lbs_server) { LOG_FUNC; - if (!lbs_server_nps) { + if (!lbs_server) { LOG_NPS(DBG_ERR, "lbs-server is NULL!!"); return FALSE; } - int ret = get_nps_plugin_module()->stop(lbs_server_nps->handle, __nps_cancel_callback, lbs_server_nps); + int ret = get_nps_plugin_module()->stop(lbs_server->nps_handle, __nps_cancel_callback, lbs_server); if (ret) { - g_mutex_lock(&lbs_server_nps->mutex); + g_mutex_lock(&lbs_server->mutex); - while (lbs_server_nps->is_nps_running) - g_cond_wait(&lbs_server_nps->cond, &lbs_server_nps->mutex); + while (lbs_server->is_nps_running) + g_cond_wait(&lbs_server->cond, &lbs_server->mutex); - lbs_server_nps->is_nps_running = FALSE; - g_mutex_unlock(&lbs_server_nps->mutex); + lbs_server->is_nps_running = FALSE; + g_mutex_unlock(&lbs_server->mutex); } /* This is vestige of nps-server else { - if (lbs_server_nps->loop != NULL) { + if (lbs_server->loop != NULL) { LOG_NPS(DBG_ERR, "module->stop() is failed. nps is cloesed."); - g_main_loop_quit(lbs_server_nps->loop); + g_main_loop_quit(lbs_server->loop); return FALSE; } } */ - nps_set_status(lbs_server_nps, LBS_STATUS_UNAVAILABLE); + nps_set_status(lbs_server, LBS_STATUS_UNAVAILABLE); return TRUE; } @@ -726,7 +671,7 @@ static gboolean gps_plugin_start(lbs_server_s *lbs_server) lbs_server->status = LBS_STATUS_ACQUIRING; - if (request_start_session((int)(lbs_server->optimized_interval_array[LBS_SERVER_METHOD_GPS])) == TRUE) { + if (request_start_session((int)(lbs_server->optimized_interval[LBS_SERVER_METHOD_GPS])) == TRUE) { g_mutex_lock(&lbs_server->mutex); lbs_server->is_gps_running = TRUE; g_mutex_unlock(&lbs_server->mutex); @@ -772,7 +717,7 @@ static gboolean nps_plugin_start(lbs_server_s *lbs_server) if (ret) { LOG_NPS(DBG_LOW, "get_nps_plugin_module()->start() success, ret[%d]", ret); - lbs_server->handle = handle_str; + lbs_server->nps_handle = handle_str; g_mutex_lock(&lbs_server->mutex); lbs_server->is_nps_running = TRUE; g_mutex_unlock(&lbs_server->mutex); @@ -984,7 +929,7 @@ static gboolean update_pos_tracking_interval(lbs_server_interval_manipulation_ty 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; + lbs_server->optimized_interval[i] = 0; ret_val = FALSE; } else { @@ -996,10 +941,10 @@ static gboolean update_pos_tracking_interval(lbs_server_interval_manipulation_ty 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) { + if (lbs_server->optimized_interval[method] != lbs_server->temp_minimum_interval) { LOG_GPS(DBG_INFO, "Changing method[GPS]'s optimized_interval value %u -> [ %u ]", - lbs_server->optimized_interval_array[method], lbs_server->temp_minimum_interval); - lbs_server->optimized_interval_array[method] = lbs_server->temp_minimum_interval; + lbs_server->optimized_interval[method], lbs_server->temp_minimum_interval); + lbs_server->optimized_interval[method] = lbs_server->temp_minimum_interval; /* need to send message to provider device */ LOG_GPS(DBG_LOW, "--> set needed_changing_interval"); @@ -1022,7 +967,7 @@ static void request_change_pos_update_interval(int method, gpointer userdata) lbs_server_s *lbs_server = (lbs_server_s *)userdata; switch (method) { case LBS_SERVER_METHOD_GPS: - request_change_pos_update_interval_standalone_gps(lbs_server->optimized_interval_array[method]); + request_change_pos_update_interval_standalone_gps(lbs_server->optimized_interval[method]); break; default: break; @@ -1041,6 +986,8 @@ static void get_nmea(int *timestamp, gchar **nmea_data, gpointer userdata) #ifndef TIZEN_DEVICE static gboolean update_batch_tracking_interval(lbs_server_interval_manipulation_type type, const gchar *client, guint interval, guint period, gpointer userdata); +static void start_batch_tracking(lbs_server_s *lbs_server, int batch_interval, int batch_period); +static void stop_batch_tracking(lbs_server_s *lbs_server, int batch_interval, int batch_period); #endif static void set_options(GVariant *options, const gchar *client, gpointer userdata) @@ -1276,7 +1223,7 @@ static void shutdown(gpointer userdata, gboolean *shutdown_arr) if (shutdown_arr[LBS_SERVER_METHOD_NPS]) { LOG_NPS(DBG_LOW, "-> shutdown NPS"); if (lbs_server->is_nps_running) { - LOG_NPS(DBG_ERR, "lbs_server_nps is running. nps_plugin_stop"); + LOG_NPS(DBG_ERR, "lbs_server is running. nps_plugin_stop"); nps_plugin_stop(lbs_server); } } @@ -1455,7 +1402,7 @@ static void resume_fence(gint fence_id, gint monitor_states, gpointer userdata) request_resume_geofence(fence_id, monitor_states); } -static void nps_init(lbs_server_s *lbs_server_nps); +static void nps_init(lbs_server_s *lbs_server); static void lbs_server_init(lbs_server_s *lbs_server) { @@ -1481,7 +1428,7 @@ static void lbs_server_init(lbs_server_s *lbs_server) /* create resource for dynamic-interval */ lbs_server->dynamic_interval_table = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL); - lbs_server->optimized_interval_array = (guint *)g_malloc0(LBS_SERVER_METHOD_SIZE * sizeof(guint)); + lbs_server->optimized_interval = (guint *)g_malloc0(LBS_SERVER_METHOD_SIZE * sizeof(guint)); lbs_server->is_needed_changing_interval = FALSE; /* Mock Location init */ @@ -1499,7 +1446,7 @@ static void lbs_server_init(lbs_server_s *lbs_server) location_fused_init(fused_update_position_cb, lbs_server); } -static void nps_get_last_position(lbs_server_s *lbs_server_nps) +static void nps_get_last_position(lbs_server_s *lbs_server) { int timestamp = 0; char location[128] = {0,}; @@ -1517,27 +1464,27 @@ static void nps_get_last_position(lbs_server_s *lbs_server_nps) free(str); last_location[index] = (char *)strtok_r(location, ";", &last); - lbs_server_nps->last_pos.timestamp = timestamp; + lbs_server->last_pos.timestamp = timestamp; while (last_location[index] != NULL) { switch (index) { case 0: - lbs_server_nps->last_pos.latitude = strtod(last_location[index], NULL); + lbs_server->last_pos.latitude = strtod(last_location[index], NULL); break; case 1: - lbs_server_nps->last_pos.longitude = strtod(last_location[index], NULL); + lbs_server->last_pos.longitude = strtod(last_location[index], NULL); break; case 2: - lbs_server_nps->last_pos.altitude = strtod(last_location[index], NULL); + lbs_server->last_pos.altitude = strtod(last_location[index], NULL); break; case 3: - lbs_server_nps->last_pos.speed = strtod(last_location[index], NULL); + lbs_server->last_pos.speed = strtod(last_location[index], NULL); break; case 4: - lbs_server_nps->last_pos.direction = strtod(last_location[index], NULL); + lbs_server->last_pos.direction = strtod(last_location[index], NULL); break; case 5: - lbs_server_nps->last_pos.hor_accuracy = strtod(last_location[index], NULL); + lbs_server->last_pos.hor_accuracy = strtod(last_location[index], NULL); break; default: break; @@ -1545,88 +1492,88 @@ static void nps_get_last_position(lbs_server_s *lbs_server_nps) if (++index == MAX_NPS_LOC_ITEM) break; last_location[index] = (char *)strtok_r(NULL, ";", &last); } - LOG_NPS(DBG_LOW, "[%d] %lf, %lf", lbs_server_nps->last_pos.timestamp, lbs_server_nps->last_pos.latitude, lbs_server_nps->last_pos.longitude); + LOG_NPS(DBG_LOW, "[%d] %lf, %lf", lbs_server->last_pos.timestamp, lbs_server->last_pos.latitude, lbs_server->last_pos.longitude); } -static void nps_init(lbs_server_s *lbs_server_nps) +static void nps_init(lbs_server_s *lbs_server) { LOG_NPS(DBG_LOW, "nps_init"); - lbs_server_nps->handle = NULL; - lbs_server_nps->period = 5000; - nps_set_status(lbs_server_nps, LBS_STATUS_UNAVAILABLE); - - lbs_server_nps->pos.fields = LBS_POSITION_EXT_FIELDS_NONE; - lbs_server_nps->pos.timestamp = 0; - lbs_server_nps->pos.latitude = 0.0; - lbs_server_nps->pos.longitude = 0.0; - lbs_server_nps->pos.altitude = 0.0; - lbs_server_nps->pos.acc_level = LBS_POSITION_EXT_FIELDS_NONE; - lbs_server_nps->pos.hor_accuracy = -1.0; - lbs_server_nps->pos.ver_accuracy = -1.0; - - lbs_server_nps->last_pos.timestamp = 0; - lbs_server_nps->last_pos.latitude = 0.0; - lbs_server_nps->last_pos.longitude = 0.0; - lbs_server_nps->last_pos.altitude = 0.0; - lbs_server_nps->last_pos.hor_accuracy = 0.0; - lbs_server_nps->last_pos.speed = 0.0; - lbs_server_nps->last_pos.direction = 0.0; + lbs_server->nps_handle = NULL; + lbs_server->period = 5000; + nps_set_status(lbs_server, LBS_STATUS_UNAVAILABLE); + + lbs_server->pos.fields = LBS_POSITION_EXT_FIELDS_NONE; + lbs_server->pos.timestamp = 0; + lbs_server->pos.latitude = 0.0; + lbs_server->pos.longitude = 0.0; + lbs_server->pos.altitude = 0.0; + lbs_server->pos.acc_level = LBS_POSITION_EXT_FIELDS_NONE; + lbs_server->pos.hor_accuracy = -1.0; + lbs_server->pos.ver_accuracy = -1.0; + + lbs_server->last_pos.timestamp = 0; + lbs_server->last_pos.latitude = 0.0; + lbs_server->last_pos.longitude = 0.0; + lbs_server->last_pos.altitude = 0.0; + lbs_server->last_pos.hor_accuracy = 0.0; + lbs_server->last_pos.speed = 0.0; + lbs_server->last_pos.direction = 0.0; #if !GLIB_CHECK_VERSION(2, 31, 0) GMutex *mutex_temp = g_mutex_new(); - lbs_server_nps->mutex = *mutex_temp; + lbs_server->mutex = *mutex_temp; GCond *cond_temp = g_cond_new(); - lbs_server_nps->cond = *cond_temp; + lbs_server->cond = *cond_temp; #endif - g_mutex_init(&lbs_server_nps->mutex); - g_cond_init(&lbs_server_nps->cond); + g_mutex_init(&lbs_server->mutex); + g_cond_init(&lbs_server->cond); - lbs_server_nps->is_nps_running = FALSE; - lbs_server_nps->nps_client_count = 0; + lbs_server->is_nps_running = FALSE; + lbs_server->nps_client_count = 0; if (!get_nps_plugin_module()->load()) { - LOG_NPS(DBG_ERR, "lbs_server_nps plugin load() failed."); + LOG_NPS(DBG_ERR, "lbs_server plugin load() failed."); return ; } - nps_get_last_position(lbs_server_nps); + nps_get_last_position(lbs_server); } -static void nps_deinit(lbs_server_s *lbs_server_nps) +static void nps_deinit(lbs_server_s *lbs_server) { LOG_NPS(DBG_LOW, "nps_deinit"); if (get_nps_plugin_module()->unload()) { - if (lbs_server_nps->is_nps_running) { - g_mutex_lock(&lbs_server_nps->mutex); - lbs_server_nps->is_nps_running = FALSE; - g_cond_signal(&lbs_server_nps->cond); - g_mutex_unlock(&lbs_server_nps->mutex); + if (lbs_server->is_nps_running) { + g_mutex_lock(&lbs_server->mutex); + lbs_server->is_nps_running = FALSE; + g_cond_signal(&lbs_server->cond); + g_mutex_unlock(&lbs_server->mutex); } - if (lbs_server_nps->token) { - g_mutex_lock(&lbs_server_nps->mutex); - g_free(lbs_server_nps->token); - g_mutex_unlock(&lbs_server_nps->mutex); + if (lbs_server->token) { + g_mutex_lock(&lbs_server->mutex); + g_free(lbs_server->token); + g_mutex_unlock(&lbs_server->mutex); } } else { LOG_NPS(DBG_ERR, "unload() failed."); } - lbs_server_nps->handle = NULL; - lbs_server_nps->is_nps_running = FALSE; - lbs_server_nps->nps_client_count = 0; + lbs_server->nps_handle = NULL; + lbs_server->is_nps_running = FALSE; + lbs_server->nps_client_count = 0; #if !GLIB_CHECK_VERSION(2, 31, 0) - g_cond_free(&lbs_server_nps->cond); - g_mutex_free(&lbs_server_nps->mutex); + g_cond_free(&lbs_server->cond); + g_mutex_free(&lbs_server->mutex); #endif - g_cond_clear(&lbs_server_nps->cond); - g_mutex_clear(&lbs_server_nps->mutex); + g_cond_clear(&lbs_server->cond); + g_mutex_clear(&lbs_server->mutex); - nps_set_status(lbs_server_nps, LBS_STATUS_UNAVAILABLE); + nps_set_status(lbs_server, LBS_STATUS_UNAVAILABLE); } static void _glib_log(const gchar *log_domain, GLogLevelFlags log_level, @@ -1673,25 +1620,25 @@ int main(int argc, char **argv) g_log_set_default_handler(_glib_log, lbs_server); /* create lbs-dbus server */ - lbs_server_dbus_cb_t *lbs_dbus_callback = g_new0(lbs_server_dbus_cb_t, 1); - if (!lbs_dbus_callback) { + lbs_server_dbus_cb_t *lbs_server_dbus_cb = g_new0(lbs_server_dbus_cb_t, 1); + if (!lbs_server_dbus_cb) { LOG_GPS(DBG_ERR, "Failed to create lbs_server_dbus_cb"); return 1; } - lbs_dbus_callback->set_options_cb = set_options; - lbs_dbus_callback->shutdown_cb = shutdown; - lbs_dbus_callback->update_interval_cb = update_pos_tracking_interval; - lbs_dbus_callback->request_change_interval_cb = request_change_pos_update_interval; - lbs_dbus_callback->get_nmea_cb = get_nmea; - lbs_dbus_callback->add_hw_fence_cb = add_fence; - lbs_dbus_callback->delete_hw_fence_cb = remove_fence; - lbs_dbus_callback->pause_hw_fence_cb = pause_fence; - lbs_dbus_callback->resume_hw_fence_cb = resume_fence; - lbs_dbus_callback->set_mock_location_cb = set_mock_location_cb; + lbs_server_dbus_cb->set_options_cb = set_options; + lbs_server_dbus_cb->shutdown_cb = shutdown; + lbs_server_dbus_cb->update_interval_cb = update_pos_tracking_interval; + lbs_server_dbus_cb->request_change_interval_cb = request_change_pos_update_interval; + lbs_server_dbus_cb->get_nmea_cb = get_nmea; + lbs_server_dbus_cb->add_hw_fence_cb = add_fence; + lbs_server_dbus_cb->delete_hw_fence_cb = remove_fence; + lbs_server_dbus_cb->pause_hw_fence_cb = pause_fence; + lbs_server_dbus_cb->resume_hw_fence_cb = resume_fence; + lbs_server_dbus_cb->set_mock_location_cb = set_mock_location_cb; ret = lbs_server_create(SERVICE_NAME, SERVICE_PATH, "lbs-server", "lbs-server", - &(lbs_server->lbs_dbus_server), lbs_dbus_callback, (gpointer)lbs_server); + &(lbs_server->lbs_dbus_server), lbs_server_dbus_cb, (gpointer)lbs_server); if (ret != LBS_SERVER_ERROR_NONE) { LOG_GPS(DBG_ERR, "lbs_server_create failed"); @@ -1710,14 +1657,14 @@ int main(int argc, char **argv) gps_deinit_log(); /* destroy resource for dynamic-interval */ - g_free(lbs_server->optimized_interval_array); + g_free(lbs_server->optimized_interval); 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); + g_free(lbs_server_dbus_cb); /* destroy lbs-dbus server */ lbs_server_destroy(lbs_server->lbs_dbus_server); @@ -1945,6 +1892,59 @@ static void client_count_updater(lbs_server_s *lbs_server, lbs_server_method_e m #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"); + client_count_updater(lbs_server, LBS_SERVER_METHOD_GPS, _LBS_CLIENT_ADD, LOCATION_FUSED_NONE); + + if (lbs_server->is_gps_running == FALSE) { + 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); + + 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) +{ + LOG_GPS(DBG_LOW, "Batch: stop_tracking GPS"); + client_count_updater(lbs_server, LBS_SERVER_METHOD_GPS, _LBS_CLIENT_REMOVE, LOCATION_FUSED_NONE); + + if (lbs_server->is_gps_running == FALSE) { + LOG_GPS(DBG_LOW, "Batch: gps- is already stopped"); + 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 */ + } + + /* TRUE: All clients stopped, FALSE: Some clients are running with GPS or BATCH */ + if (request_stop_batch_session(batch_interval, batch_period, session_status) == TRUE) { + 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); + } + + lbs_server->status = LBS_STATUS_UNAVAILABLE; + lbs_server_emit_status_changed(lbs_server->lbs_dbus_server, LBS_SERVER_METHOD_GPS, LBS_STATUS_UNAVAILABLE); +} + static void update_batch_interval_table_foreach_cb(gpointer key, gpointer value, gpointer userdata) { guint *interval_array = (guint *)value;