gint gps_client_count;
/* nps variables */
- NpsManagerHandle handle;
+ NpsManagerHandle nps_handle;
unsigned long period;
NpsManagerPositionExt pos;
NpsManagerLastPositionExt last_pos;
/* 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
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;
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);
}
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;
}
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));
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;
}
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;
}
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");
}
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);
}
}
*/
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);
}
-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;
}
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);
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);
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 {
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");
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;
#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)
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);
}
}
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)
{
/* 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 */
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,};
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;
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,
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");
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);
#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;
projects / platform / core / location / lbs-server.git / commitdiff