From 481a41815973c1d650a3983fb3176a8a2d484285 Mon Sep 17 00:00:00 2001 From: "kj7.sung" Date: Mon, 6 Feb 2017 13:28:02 +0900 Subject: [PATCH] sync with latest 3.0 Change-Id: I71ec82ee27628e52a8f288ed3473dcf623996f04 Signed-off-by: kj7.sung --- lbs-server/src/data_connection.c | 4 +- lbs-server/src/lbs_server.c | 36 +++--- lbs-server/src/lbs_server.h | 1 + module/gps_module.c | 235 ++++++++++++++++++++------------------- module/nps_module.c | 146 ++++++++++++------------ module/passive_module.c | 213 +++++++++++++++++++++++++++++++++-- packaging/lbs-server.changes | 7 ++ packaging/lbs-server.spec | 2 +- 8 files changed, 426 insertions(+), 218 deletions(-) diff --git a/lbs-server/src/data_connection.c b/lbs-server/src/data_connection.c index 6e7522c..6440642 100644 --- a/lbs-server/src/data_connection.c +++ b/lbs-server/src/data_connection.c @@ -292,7 +292,9 @@ unsigned int query_dns(char *pdns_lookup_addr, unsigned int *ipaddr, int *port) pdns_lookup_addr = ptr; ptr = (char *)strtok_r(NULL, ":", &last); - *port = atoi(ptr); + + if (ptr) + *port = atoi(ptr); } tmpbuf = malloc(tmplen); diff --git a/lbs-server/src/lbs_server.c b/lbs-server/src/lbs_server.c index 61b7554..ba8b30f 100755 --- a/lbs-server/src/lbs_server.c +++ b/lbs-server/src/lbs_server.c @@ -240,9 +240,9 @@ static void nps_update_position(lbs_server_s *lbs_server_nps, NpsManagerPosition LOG_NPS(DBG_LOW, "time:%d", lbs_server_nps->pos.timestamp); 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_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); g_variant_unref(accuracy); } @@ -492,7 +492,6 @@ static void start_tracking(lbs_server_s *lbs_server, lbs_server_method_e method) switch (method) { case LBS_SERVER_METHOD_GPS: - g_mutex_lock(&lbs_server->mutex); lbs_server->gps_client_count++; g_mutex_unlock(&lbs_server->mutex); @@ -541,6 +540,7 @@ static void start_tracking(lbs_server_s *lbs_server, lbs_server_method_e method) LOG_NPS(DBG_LOW, "after get_nps_plugin_module()->location"); if (ret) { + LOG_NPS(DBG_LOW, "get_nps_plugin_module()->start() success"); lbs_server->handle = handle_str; g_mutex_lock(&lbs_server->mutex); lbs_server->is_nps_running = TRUE; @@ -554,10 +554,13 @@ static void start_tracking(lbs_server_s *lbs_server, lbs_server_method_e method) if (nps_is_dummy_plugin_module() != TRUE) nps_offline_location(lbs_server); - LOG_NPS(DBG_ERR, "Filed to start NPS"); + LOG_NPS(DBG_ERR, "Failed to start NPS"); nps_set_status(lbs_server, LBS_STATUS_ERROR); break; + case LBS_SERVER_METHOD_PASSIVE: + break; + default: LOG_GPS(DBG_LOW, "start_tracking Invalid"); break; @@ -655,6 +658,10 @@ static void stop_tracking(lbs_server_s *lbs_server, lbs_server_method_e method) } break; + + case LBS_SERVER_METHOD_PASSIVE: + break; + default: LOG_GPS(DBG_LOW, "stop_tracking Invalid"); break; @@ -1178,7 +1185,7 @@ static void gps_update_position_cb(pos_data_t *pos, gps_error_t error, void *use gps_set_position(pos); lbs_server_emit_position_changed(lbs_server->lbs_dbus_server, LBS_SERVER_METHOD_GPS, fields, pos->timestamp, - pos->latitude, pos->longitude, pos->altitude, pos->speed, pos->bearing, 0.0, accuracy); + pos->latitude, pos->longitude, pos->altitude, pos->speed, pos->bearing, 0.0, accuracy); } static void gps_update_batch_cb(batch_data_t *batch, void *user_data) @@ -1227,8 +1234,8 @@ static void gps_update_satellite_cb(sv_data_t *sv, void *user_data) } satellite_info = g_variant_builder_end(satellite_info_builder); - lbs_server_emit_satellite_changed(lbs_server->lbs_dbus_server, timestamp, satellite_used, sv->num_of_sat, - used_prn, satellite_info); + lbs_server_emit_satellite_changed(lbs_server->lbs_dbus_server, timestamp, satellite_used, + sv->num_of_sat, used_prn, satellite_info); } static void gps_update_nmea_cb(nmea_data_t *nmea, void *user_data) @@ -1466,12 +1473,12 @@ static void _glib_log(const gchar *log_domain, GLogLevelFlags log_level, int main(int argc, char **argv) { lbs_server_s *lbs_server = NULL; - struct gps_callbacks cb; + struct gps_callbacks g_update_cb; int ret = 0; - cb.pos_cb = gps_update_position_cb; - cb.batch_cb = gps_update_batch_cb; - cb.sv_cb = gps_update_satellite_cb; - cb.nmea_cb = gps_update_nmea_cb; + g_update_cb.pos_cb = gps_update_position_cb; + g_update_cb.batch_cb = gps_update_batch_cb; + g_update_cb.sv_cb = gps_update_satellite_cb; + g_update_cb.nmea_cb = gps_update_nmea_cb; #if !GLIB_CHECK_VERSION(2, 31, 0) if (!g_thread_supported()) @@ -1496,7 +1503,7 @@ int main(int argc, char **argv) lbs_server_init(lbs_server); gps_init_log(); - register_update_callbacks(&cb, lbs_server); + register_update_callbacks(&g_update_cb, lbs_server); g_log_set_default_handler(_glib_log, lbs_server); @@ -1516,7 +1523,6 @@ int main(int argc, char **argv) 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; ret = lbs_server_create(SERVICE_NAME, SERVICE_PATH, "lbs-server", "lbs-server", diff --git a/lbs-server/src/lbs_server.h b/lbs-server/src/lbs_server.h index fc256ef..4cba28f 100755 --- a/lbs-server/src/lbs_server.h +++ b/lbs-server/src/lbs_server.h @@ -39,6 +39,7 @@ typedef enum { LBS_SERVER_METHOD_AGPS, LBS_SERVER_METHOD_GEOFENCE, LBS_SERVER_METHOD_MOCK, + LBS_SERVER_METHOD_PASSIVE, LBS_SERVER_METHOD_SIZE, } lbs_server_method_e; diff --git a/module/gps_module.c b/module/gps_module.c index 4fd8972..6d29042 100644 --- a/module/gps_module.c +++ b/module/gps_module.c @@ -54,10 +54,10 @@ typedef struct { static void status_callback(GVariant *param, void *user_data) { - GpsManagerData *mod_gps = (GpsManagerData *) user_data; + GpsManagerData *module = (GpsManagerData *) user_data; g_return_if_fail(param); - g_return_if_fail(mod_gps); - g_return_if_fail(mod_gps->status_cb); + g_return_if_fail(module); + g_return_if_fail(module->status_cb); int status = 0, method = 0; g_variant_get(param, "(ii)", &method, &status); @@ -68,18 +68,18 @@ static void status_callback(GVariant *param, void *user_data) if (status == 3) { MOD_LOGD("LBS_STATUS_AVAILABLE : gps_module"); - mod_gps->status_cb(TRUE, LOCATION_STATUS_3D_FIX, mod_gps->userdata); + module->status_cb(TRUE, LOCATION_STATUS_3D_FIX, module->userdata); } else { MOD_LOGD("LBS_STATUS_ACQUIRING/ERROR/UNAVAILABLE. Status[%d]", status); - mod_gps->status_cb(FALSE, LOCATION_STATUS_NO_FIX, mod_gps->userdata); + module->status_cb(FALSE, LOCATION_STATUS_NO_FIX, module->userdata); } } static void satellite_callback(GVariant *param, void *user_data) { - GpsManagerData *mod_gps = (GpsManagerData *)user_data; - g_return_if_fail(mod_gps); - g_return_if_fail(mod_gps->sat_cb); + GpsManagerData *module = (GpsManagerData *)user_data; + g_return_if_fail(module); + g_return_if_fail(module->sat_cb); guint idx; guint used_idx; @@ -102,6 +102,7 @@ static void satellite_callback(GVariant *param, void *user_data) int num_of_used_prn = g_variant_iter_n_children(used_prn_iter); if (num_of_used_prn > 0) { used_prn_array = (guint *)g_new0(guint, num_of_used_prn); + g_return_val_if_fail(used_prn_array, NULL); for (idx = 0; idx < num_of_used_prn; idx++) { ret = g_variant_iter_next(used_prn_iter, "i", &tmp_prn); if (ret == FALSE) @@ -133,7 +134,7 @@ static void satellite_callback(GVariant *param, void *user_data) g_variant_unref(tmp_var); } - mod_gps->sat_cb(TRUE, sat, mod_gps->userdata); + module->sat_cb(TRUE, sat, module->userdata); location_satellite_free(sat); g_variant_iter_free(used_prn_iter); g_variant_iter_free(sat_iter); @@ -148,9 +149,9 @@ static void satellite_callback(GVariant *param, void *user_data) static void position_callback(GVariant *param, void *user_data) { - GpsManagerData *mod_gps = (GpsManagerData *)user_data; - g_return_if_fail(mod_gps); - g_return_if_fail(mod_gps->pos_cb); + GpsManagerData *module = (GpsManagerData *)user_data; + g_return_if_fail(module); + g_return_if_fail(module->pos_cb); int method = 0, fields = 0 , timestamp = 0 , level = 0; double latitude = 0.0, longitude = 0.0, altitude = 0.0, speed = 0.0, direction = 0.0, climb = 0.0, horizontal = 0.0, vertical = 0.0; @@ -175,7 +176,7 @@ static void position_callback(GVariant *param, void *user_data) vel = location_velocity_new(timestamp, speed, direction, climb); acc = location_accuracy_new(LOCATION_ACCURACY_LEVEL_DETAILED, horizontal, vertical); - mod_gps->pos_cb(TRUE, pos, vel, acc, mod_gps->userdata); + module->pos_cb(TRUE, pos, vel, acc, module->userdata); location_position_free(pos); location_velocity_free(vel); @@ -186,14 +187,14 @@ static void position_callback(GVariant *param, void *user_data) static void batch_callback(GVariant *param, void *user_data) { MOD_LOGD("batch_callback"); - GpsManagerData *mod_gps = (GpsManagerData *)user_data; - g_return_if_fail(mod_gps); - g_return_if_fail(mod_gps->batch_cb); + GpsManagerData *module = (GpsManagerData *)user_data; + g_return_if_fail(module); + g_return_if_fail(module->batch_cb); int num_of_location = 0; g_variant_get(param, "(i)", &num_of_location); - mod_gps->batch_cb(TRUE, num_of_location, mod_gps->userdata); + module->batch_cb(TRUE, num_of_location, module->userdata); } static void on_signal_batch_callback(const gchar *sig, GVariant *param, gpointer user_data) @@ -221,73 +222,73 @@ static void on_signal_callback(const gchar *sig, GVariant *param, gpointer user_ static int start(gpointer handle, guint pos_update_interval, LocModStatusCB status_cb, LocModPositionExtCB pos_cb, LocModSatelliteCB sat_cb, gpointer userdata) { MOD_LOGD("start"); - GpsManagerData *mod_gps = (GpsManagerData *) handle; - g_return_val_if_fail(mod_gps, LOCATION_ERROR_NOT_AVAILABLE); + GpsManagerData *module = (GpsManagerData *) handle; + g_return_val_if_fail(module, LOCATION_ERROR_NOT_AVAILABLE); g_return_val_if_fail(status_cb, LOCATION_ERROR_NOT_AVAILABLE); g_return_val_if_fail(pos_cb, LOCATION_ERROR_NOT_AVAILABLE); - mod_gps->status_cb = status_cb; - mod_gps->pos_cb = pos_cb; - mod_gps->sat_cb = sat_cb; - mod_gps->userdata = userdata; + module->status_cb = status_cb; + module->pos_cb = pos_cb; + module->sat_cb = sat_cb; + module->userdata = userdata; int ret = LBS_CLIENT_ERROR_NONE; - ret = lbs_client_create(LBS_CLIENT_METHOD_GPS , &(mod_gps->lbs_client)); - if (ret != LBS_CLIENT_ERROR_NONE || !mod_gps->lbs_client) { + ret = lbs_client_create(LBS_CLIENT_METHOD_GPS , &(module->lbs_client)); + if (ret != LBS_CLIENT_ERROR_NONE || !module->lbs_client) { MOD_LOGE("Fail to create lbs_client_h. Error[%d]", ret); return LOCATION_ERROR_NOT_AVAILABLE; } - MOD_LOGD("gps-manger(%p) pos_cb (%p) user_data(%p)", mod_gps, mod_gps->pos_cb, mod_gps->userdata); + MOD_LOGD("gps-manger(%p) pos_cb (%p) user_data(%p)", module, module->pos_cb, module->userdata); - ret = lbs_client_start(mod_gps->lbs_client, pos_update_interval, LBS_CLIENT_LOCATION_CB | LBS_CLIENT_LOCATION_STATUS_CB | LBS_CLIENT_SATELLITE_CB | LBS_CLIENT_NMEA_CB, on_signal_callback, mod_gps); + ret = lbs_client_start(module->lbs_client, pos_update_interval, LBS_CLIENT_LOCATION_CB | LBS_CLIENT_LOCATION_STATUS_CB | LBS_CLIENT_SATELLITE_CB | LBS_CLIENT_NMEA_CB, on_signal_callback, module); if (ret != LBS_CLIENT_ERROR_NONE) { if (ret == LBS_CLIENT_ERROR_ACCESS_DENIED) { MOD_LOGE("Access denied[%d]", ret); return LOCATION_ERROR_NOT_ALLOWED; } MOD_LOGE("Fail to start lbs_client_h. Error[%d]", ret); - lbs_client_destroy(mod_gps->lbs_client); - mod_gps->lbs_client = NULL; + lbs_client_destroy(module->lbs_client); + module->lbs_client = NULL; return LOCATION_ERROR_NOT_AVAILABLE; } - mod_gps->pos_interval = pos_update_interval; + module->pos_interval = pos_update_interval; return LOCATION_ERROR_NONE; } static int stop(gpointer handle) { MOD_LOGD("stop"); - 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); - g_return_val_if_fail(mod_gps->status_cb, LOCATION_ERROR_NOT_AVAILABLE); + GpsManagerData *module = (GpsManagerData *) handle; + g_return_val_if_fail(module, LOCATION_ERROR_NOT_AVAILABLE); + g_return_val_if_fail(module->lbs_client, LOCATION_ERROR_NOT_AVAILABLE); + g_return_val_if_fail(module->status_cb, LOCATION_ERROR_NOT_AVAILABLE); int ret = LBS_CLIENT_ERROR_NONE; - ret = lbs_client_stop(mod_gps->lbs_client, mod_gps->pos_interval); - MOD_LOGE("stop gps interval [%d]", mod_gps->pos_interval); + ret = lbs_client_stop(module->lbs_client, module->pos_interval); + MOD_LOGE("stop gps interval [%d]", module->pos_interval); if (ret != LBS_CLIENT_ERROR_NONE) { MOD_LOGE("Fail to stop. Error[%d]", ret); - lbs_client_destroy(mod_gps->lbs_client); - mod_gps->lbs_client = NULL; + lbs_client_destroy(module->lbs_client); + module->lbs_client = NULL; return LOCATION_ERROR_NOT_AVAILABLE; } - ret = lbs_client_destroy(mod_gps->lbs_client); + ret = lbs_client_destroy(module->lbs_client); if (ret != LBS_CLIENT_ERROR_NONE) { MOD_LOGE("Fail to destroy. Error[%d]", ret); return LOCATION_ERROR_NOT_AVAILABLE; } - mod_gps->lbs_client = NULL; + module->lbs_client = NULL; - if (mod_gps->status_cb) - mod_gps->status_cb(FALSE, LOCATION_STATUS_NO_FIX, mod_gps->userdata); + if (module->status_cb) + module->status_cb(FALSE, LOCATION_STATUS_NO_FIX, module->userdata); - mod_gps->status_cb = NULL; - mod_gps->pos_cb = NULL; - mod_gps->sat_cb = NULL; + module->status_cb = NULL; + module->pos_cb = NULL; + module->sat_cb = NULL; return LOCATION_ERROR_NONE; } @@ -295,31 +296,31 @@ static int stop(gpointer handle) static int start_batch(gpointer handle, LocModBatchExtCB batch_cb, guint batch_interval, guint batch_period, gpointer userdata) { MOD_LOGD("start_batch"); - GpsManagerData *mod_gps = (GpsManagerData *) handle; - g_return_val_if_fail(mod_gps, LOCATION_ERROR_NOT_AVAILABLE); + GpsManagerData *module = (GpsManagerData *) handle; + g_return_val_if_fail(module, LOCATION_ERROR_NOT_AVAILABLE); g_return_val_if_fail(batch_cb, LOCATION_ERROR_NOT_AVAILABLE); - mod_gps->batch_cb = batch_cb; - mod_gps->userdata = userdata; + module->batch_cb = batch_cb; + module->userdata = userdata; int ret = LBS_CLIENT_ERROR_NONE; - ret = lbs_client_create(LBS_CLIENT_METHOD_GPS , &(mod_gps->lbs_client)); - if (ret != LBS_CLIENT_ERROR_NONE || !mod_gps->lbs_client) { + ret = lbs_client_create(LBS_CLIENT_METHOD_GPS , &(module->lbs_client)); + if (ret != LBS_CLIENT_ERROR_NONE || !module->lbs_client) { MOD_LOGE("Fail to create lbs_client_h. Error[%d]", ret); return LOCATION_ERROR_NOT_AVAILABLE; } - MOD_LOGD("gps-manger(%p) batch_cb(%p) user_data(%p)", mod_gps, mod_gps->batch_cb, mod_gps->userdata); + MOD_LOGD("gps-manger(%p) batch_cb(%p) user_data(%p)", module, module->batch_cb, module->userdata); - ret = lbs_client_batch_start(mod_gps->lbs_client, LBS_CLIENT_BATCH_CB, on_signal_batch_callback, batch_interval, batch_period, mod_gps); + ret = lbs_client_batch_start(module->lbs_client, LBS_CLIENT_BATCH_CB, on_signal_batch_callback, batch_interval, batch_period, module); if (ret != LBS_CLIENT_ERROR_NONE) { if (ret == LBS_CLIENT_ERROR_ACCESS_DENIED) { MOD_LOGE("Access denied[%d]", ret); return LOCATION_ERROR_NOT_ALLOWED; } MOD_LOGE("Fail to start lbs_client_h. Error[%d]", ret); - lbs_client_destroy(mod_gps->lbs_client); - mod_gps->lbs_client = NULL; + lbs_client_destroy(module->lbs_client); + module->lbs_client = NULL; return LOCATION_ERROR_NOT_AVAILABLE; } @@ -330,26 +331,26 @@ static int start_batch(gpointer handle, LocModBatchExtCB batch_cb, guint batch_i static int stop_batch(gpointer handle) { MOD_LOGD("stop_batch"); - GpsManagerData *mod_gps = (GpsManagerData *) handle; - g_return_val_if_fail(mod_gps, LOCATION_ERROR_NOT_AVAILABLE); + GpsManagerData *module = (GpsManagerData *) handle; + g_return_val_if_fail(module, LOCATION_ERROR_NOT_AVAILABLE); int ret = LBS_CLIENT_ERROR_NONE; - ret = lbs_client_batch_stop(mod_gps->lbs_client); + ret = lbs_client_batch_stop(module->lbs_client); if (ret != LBS_CLIENT_ERROR_NONE) { MOD_LOGE("Fail to stop batch. Error[%d]", ret); - lbs_client_destroy(mod_gps->lbs_client); - mod_gps->lbs_client = NULL; + lbs_client_destroy(module->lbs_client); + module->lbs_client = NULL; return LOCATION_ERROR_NOT_AVAILABLE; } - ret = lbs_client_destroy(mod_gps->lbs_client); + ret = lbs_client_destroy(module->lbs_client); if (ret != LBS_CLIENT_ERROR_NONE) { MOD_LOGE("Fail to destroy. Error[%d]", ret); return LOCATION_ERROR_NOT_AVAILABLE; } - mod_gps->lbs_client = NULL; - mod_gps->batch_cb = NULL; + module->lbs_client = NULL; + module->batch_cb = NULL; return LOCATION_ERROR_NONE; } @@ -357,14 +358,14 @@ static int stop_batch(gpointer handle) static int get_nmea(gpointer handle, gchar **nmea_data) { MOD_LOGD("get_nmea"); - GpsManagerData *mod_gps = (GpsManagerData *) handle; - g_return_val_if_fail(mod_gps, LOCATION_ERROR_NOT_AVAILABLE); + GpsManagerData *module = (GpsManagerData *) handle; + g_return_val_if_fail(module, LOCATION_ERROR_NOT_AVAILABLE); g_return_val_if_fail(nmea_data, LOCATION_ERROR_PARAMETER); gboolean ret = FALSE; int timestamp = 0; - ret = lbs_client_get_nmea(mod_gps->lbs_client, ×tamp, nmea_data); + ret = lbs_client_get_nmea(module->lbs_client, ×tamp, nmea_data); if (ret) { MOD_LOGE("Error getting nmea: %d", ret); return LOCATION_ERROR_NOT_AVAILABLE; @@ -376,8 +377,8 @@ static int get_nmea(gpointer handle, gchar **nmea_data) static int get_last_position(gpointer handle, LocationPosition **position, LocationVelocity **velocity, LocationAccuracy **accuracy) { MOD_LOGD("get_last_position"); - GpsManagerData *mod_gps = (GpsManagerData *) handle; - g_return_val_if_fail(mod_gps, LOCATION_ERROR_NOT_AVAILABLE); + GpsManagerData *module = (GpsManagerData *) handle; + g_return_val_if_fail(module, LOCATION_ERROR_NOT_AVAILABLE); g_return_val_if_fail(position, LOCATION_ERROR_PARAMETER); g_return_val_if_fail(velocity, LOCATION_ERROR_PARAMETER); g_return_val_if_fail(accuracy, LOCATION_ERROR_PARAMETER); @@ -474,8 +475,8 @@ static int get_last_position(gpointer handle, LocationPosition **position, Locat static int set_option(gpointer handle, const char *option) { - GpsManagerData *mod_gps = (GpsManagerData *) handle; - g_return_val_if_fail(mod_gps, LOCATION_ERROR_NOT_AVAILABLE); + GpsManagerData *module = (GpsManagerData *) handle; + g_return_val_if_fail(module, LOCATION_ERROR_NOT_AVAILABLE); g_return_val_if_fail(option, LOCATION_ERROR_PARAMETER); MOD_LOGD("set_option : %s", option); @@ -491,13 +492,13 @@ static int set_option(gpointer handle, const char *option) static int set_position_update_interval(gpointer handle, guint 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); + GpsManagerData *module = (GpsManagerData *) handle; + g_return_val_if_fail(module, LOCATION_ERROR_NOT_AVAILABLE); + g_return_val_if_fail(module->lbs_client, LOCATION_ERROR_NOT_AVAILABLE); int ret; - 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); + MOD_LOGD("set_position_update inteval [%d] -> [%d]", module->pos_interval, interval); + ret = lbs_client_set_position_update_interval(module->lbs_client, interval, module->pos_interval); if (ret != LBS_CLIENT_ERROR_NONE) { if (ret == LBS_CLIENT_ERROR_ACCESS_DENIED) { MOD_LOGE("Access denied[%d]", ret); @@ -507,7 +508,7 @@ static int set_position_update_interval(gpointer handle, guint interval) return LOCATION_ERROR_NOT_AVAILABLE; } - mod_gps->pos_interval = interval; + module->pos_interval = interval; return LOCATION_ERROR_NONE; } @@ -516,22 +517,22 @@ static int set_mock_location(gpointer handle, LocationPosition *position, Locati LocationAccuracy *accuracy, LocModStatusCB mock_status_cb, gpointer userdata) { MOD_LOGD("ENTER >>> set_mock_location"); - GpsManagerData *mod_gps = (GpsManagerData *) handle; - g_return_val_if_fail(mod_gps, LOCATION_ERROR_NOT_AVAILABLE); + GpsManagerData *module = (GpsManagerData *) handle; + g_return_val_if_fail(module, LOCATION_ERROR_NOT_AVAILABLE); int ret = LBS_CLIENT_ERROR_NONE; - if (mod_gps->lbs_client == NULL) { - ret = lbs_client_create(LBS_CLIENT_METHOD_GPS , &(mod_gps->lbs_client)); - if (ret != LBS_CLIENT_ERROR_NONE || !mod_gps->lbs_client) { + if (module->lbs_client == NULL) { + ret = lbs_client_create(LBS_CLIENT_METHOD_GPS , &(module->lbs_client)); + if (ret != LBS_CLIENT_ERROR_NONE || !module->lbs_client) { MOD_LOGE("Fail to create lbs_client_h. Error[%d]", ret); return LOCATION_ERROR_NOT_AVAILABLE; } } - mod_gps->userdata = userdata; + module->userdata = userdata; - ret = lbs_client_set_mock_location_async(mod_gps->lbs_client, LBS_CLIENT_METHOD_GPS, + ret = lbs_client_set_mock_location_async(module->lbs_client, LBS_CLIENT_METHOD_GPS, position->latitude, position->longitude, position->altitude, - velocity->speed, velocity->direction, accuracy->horizontal_accuracy, NULL, mod_gps); + velocity->speed, velocity->direction, accuracy->horizontal_accuracy, NULL, module); if (ret != LBS_CLIENT_ERROR_NONE) { if (ret == LBS_CLIENT_ERROR_ACCESS_DENIED) { @@ -539,8 +540,8 @@ static int set_mock_location(gpointer handle, LocationPosition *position, Locati return LOCATION_ERROR_NOT_ALLOWED; } MOD_LOGE("Fail to start lbs_client_h. Error[%d]", ret); - lbs_client_destroy(mod_gps->lbs_client); - mod_gps->lbs_client = NULL; + lbs_client_destroy(module->lbs_client); + module->lbs_client = NULL; return LOCATION_ERROR_NOT_AVAILABLE; } @@ -551,21 +552,21 @@ static int set_mock_location(gpointer handle, LocationPosition *position, Locati static int clear_mock_location(gpointer handle, LocModStatusCB mock_status_cb, gpointer userdata) { MOD_LOGD("ENTER >>> clear_mock_location"); - GpsManagerData *mod_gps = (GpsManagerData *) handle; - g_return_val_if_fail(mod_gps, LOCATION_ERROR_NOT_AVAILABLE); + GpsManagerData *module = (GpsManagerData *) handle; + g_return_val_if_fail(module, LOCATION_ERROR_NOT_AVAILABLE); int ret = LBS_CLIENT_ERROR_NONE; - if (mod_gps->lbs_client == NULL) { - ret = lbs_client_create(LBS_CLIENT_METHOD_GPS , &(mod_gps->lbs_client)); - if (ret != LBS_CLIENT_ERROR_NONE || !mod_gps->lbs_client) { + if (module->lbs_client == NULL) { + ret = lbs_client_create(LBS_CLIENT_METHOD_GPS , &(module->lbs_client)); + if (ret != LBS_CLIENT_ERROR_NONE || !module->lbs_client) { MOD_LOGE("Fail to create lbs_client_h. Error[%d]", ret); return LOCATION_ERROR_NOT_AVAILABLE; } } - mod_gps->userdata = userdata; + module->userdata = userdata; - ret = lbs_client_set_mock_location_async(mod_gps->lbs_client, LBS_CLIENT_METHOD_GPS, - MOCK_LOCATION_CLEAR_VALUE, 0, 0, 0, 0, 0, NULL, mod_gps); + ret = lbs_client_set_mock_location_async(module->lbs_client, LBS_CLIENT_METHOD_GPS, + MOCK_LOCATION_CLEAR_VALUE, 0, 0, 0, 0, 0, NULL, module); if (ret != LBS_CLIENT_ERROR_NONE) { if (ret == LBS_CLIENT_ERROR_ACCESS_DENIED) { @@ -573,8 +574,8 @@ static int clear_mock_location(gpointer handle, LocModStatusCB mock_status_cb, g return LOCATION_ERROR_NOT_ALLOWED; } MOD_LOGE("Fail to start lbs_client_h. Error[%d]", ret); - lbs_client_destroy(mod_gps->lbs_client); - mod_gps->lbs_client = NULL; + lbs_client_destroy(module->lbs_client); + module->lbs_client = NULL; return LOCATION_ERROR_NOT_AVAILABLE; } @@ -606,36 +607,36 @@ LOCATION_MODULE_API gpointer init(LocModGpsOps *ops) else MOD_LOGE("Invalid module name"); - GpsManagerData *mod_gps = g_new0(GpsManagerData, 1); - g_return_val_if_fail(mod_gps, NULL); + GpsManagerData *module = g_new0(GpsManagerData, 1); + g_return_val_if_fail(module, NULL); - mod_gps->status_cb = NULL; - mod_gps->pos_cb = NULL; - mod_gps->batch_cb = NULL; - mod_gps->userdata = NULL; - mod_gps->is_started = FALSE; - mod_gps->pos_interval = 0; + module->status_cb = NULL; + module->pos_cb = NULL; + module->batch_cb = NULL; + module->userdata = NULL; + module->is_started = FALSE; + module->pos_interval = 0; - return (gpointer) mod_gps; + return (gpointer) module; } LOCATION_MODULE_API void shutdown(gpointer handle) { MOD_LOGD("shutdown"); g_return_if_fail(handle); - GpsManagerData *mod_gps = (GpsManagerData *) handle; - if (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; + GpsManagerData *module = (GpsManagerData *) handle; + if (module->lbs_client) { + lbs_client_stop(module->lbs_client, module->pos_interval); + lbs_client_destroy(module->lbs_client); + module->lbs_client = NULL; } - mod_gps->status_cb = NULL; - mod_gps->pos_cb = NULL; - mod_gps->batch_cb = NULL; - mod_gps->sat_cb = NULL; - mod_gps->pos_interval = 0; + module->status_cb = NULL; + module->pos_cb = NULL; + module->batch_cb = NULL; + module->sat_cb = NULL; + module->pos_interval = 0; - g_free(mod_gps); - mod_gps = NULL; + g_free(module); + module = NULL; } diff --git a/module/nps_module.c b/module/nps_module.c index 7a35f42..58ece59 100644 --- a/module/nps_module.c +++ b/module/nps_module.c @@ -38,7 +38,7 @@ #define MAX_NPS_LOC_ITEM 6 #define MOCK_LOCATION_CLEAR_VALUE 999 -#define DEFAULT_INTERVAL_FOR_NOT_SUPPORTED 1 +#define UNNECESSARY_INTERVAL 1 typedef struct { lbs_client_dbus_h lbs_client; @@ -50,10 +50,10 @@ typedef struct { static void status_callback(GVariant *param, void *user_data) { - ModNpsData *mod_nps = (ModNpsData *) user_data; - g_return_if_fail(mod_nps); + ModNpsData *module = (ModNpsData *) user_data; + g_return_if_fail(module); g_return_if_fail(param); - g_return_if_fail(mod_nps->status_cb); + g_return_if_fail(module->status_cb); int status = 0, method = 0; @@ -65,18 +65,18 @@ static void status_callback(GVariant *param, void *user_data) if (status == 3) { /*TODO: LBS_STATUS_AVAILABLE ? */ MOD_NPS_LOGD("LBS_STATUS_AVAILABLE"); - mod_nps->status_cb(TRUE, LOCATION_STATUS_2D_FIX, mod_nps->userdata); + module->status_cb(TRUE, LOCATION_STATUS_2D_FIX, module->userdata); } else { MOD_NPS_LOGD("LBS_STATUS_ACQUIRING/ERROR/UNAVAILABLE"); - mod_nps->status_cb(FALSE, LOCATION_STATUS_NO_FIX, mod_nps->userdata); + module->status_cb(FALSE, LOCATION_STATUS_NO_FIX, module->userdata); } } static void position_callback(GVariant *param, void *user_data) { - ModNpsData *mod_nps = (ModNpsData *)user_data; - g_return_if_fail(mod_nps); - g_return_if_fail(mod_nps->pos_cb); + ModNpsData *module = (ModNpsData *)user_data; + g_return_if_fail(module); + g_return_if_fail(module->pos_cb); int method = 0, fields = 0 , timestamp = 0 , level = 0; double latitude = 0.0, longitude = 0.0, altitude = 0.0, speed = 0.0, direction = 0.0, climb = 0.0, horizontal = 0.0, vertical = 0.0; @@ -105,7 +105,7 @@ static void position_callback(GVariant *param, void *user_data) acc = location_accuracy_new(LOCATION_ACCURACY_LEVEL_DETAILED, horizontal, vertical); MOD_NPS_LOGD("method(%d)", method); - mod_nps->pos_cb(TRUE, pos, vel, acc, mod_nps->userdata); + module->pos_cb(TRUE, pos, vel, acc, module->userdata); location_position_free(pos); location_velocity_free(vel); @@ -126,23 +126,23 @@ static void on_signal_callback(const gchar *sig, GVariant *param, gpointer user_ static int start(gpointer handle, LocModStatusCB status_cb, LocModPositionExtCB pos_cb, gpointer userdata) { MOD_NPS_LOGD("start"); - ModNpsData *mod_nps = (ModNpsData *) handle; - g_return_val_if_fail(mod_nps, LOCATION_ERROR_NOT_AVAILABLE); + ModNpsData *module = (ModNpsData *) handle; + g_return_val_if_fail(module, LOCATION_ERROR_NOT_AVAILABLE); g_return_val_if_fail(status_cb, LOCATION_ERROR_NOT_AVAILABLE); g_return_val_if_fail(pos_cb, LOCATION_ERROR_NOT_AVAILABLE); - mod_nps->status_cb = status_cb; - mod_nps->pos_cb = pos_cb; - mod_nps->userdata = userdata; + module->status_cb = status_cb; + module->pos_cb = pos_cb; + module->userdata = userdata; int ret = LBS_CLIENT_ERROR_NONE; - ret = lbs_client_create(LBS_CLIENT_METHOD_NPS, &(mod_nps->lbs_client)); - if (ret != LBS_CLIENT_ERROR_NONE || !mod_nps->lbs_client) { + ret = lbs_client_create(LBS_CLIENT_METHOD_NPS, &(module->lbs_client)); + if (ret != LBS_CLIENT_ERROR_NONE || !module->lbs_client) { MOD_NPS_LOGE("Fail to create lbs_client_h. Error[%d]", ret); return LOCATION_ERROR_NOT_AVAILABLE; } - 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); + ret = lbs_client_start(module->lbs_client, UNNECESSARY_INTERVAL, LBS_CLIENT_LOCATION_CB | LBS_CLIENT_LOCATION_STATUS_CB, on_signal_callback, module); if (ret != LBS_CLIENT_ERROR_NONE) { if (ret == LBS_CLIENT_ERROR_ACCESS_DENIED) { MOD_NPS_LOGE("Access denied[%d]", ret); @@ -150,8 +150,8 @@ static int start(gpointer handle, LocModStatusCB status_cb, LocModPositionExtCB } MOD_NPS_LOGE("Fail to start lbs_client_h. Error[%d]", ret); - lbs_client_destroy(mod_nps->lbs_client); - mod_nps->lbs_client = NULL; + lbs_client_destroy(module->lbs_client); + module->lbs_client = NULL; return LOCATION_ERROR_NOT_AVAILABLE; } @@ -161,29 +161,29 @@ static int start(gpointer handle, LocModStatusCB status_cb, LocModPositionExtCB static int stop(gpointer handle) { MOD_NPS_LOGD("stop"); - ModNpsData *mod_nps = (ModNpsData *) handle; - g_return_val_if_fail(mod_nps, LOCATION_ERROR_NOT_AVAILABLE); - g_return_val_if_fail(mod_nps->lbs_client, LOCATION_ERROR_NOT_AVAILABLE); - g_return_val_if_fail(mod_nps->status_cb, LOCATION_ERROR_NOT_AVAILABLE); + ModNpsData *module = (ModNpsData *) handle; + g_return_val_if_fail(module, LOCATION_ERROR_NOT_AVAILABLE); + g_return_val_if_fail(module->lbs_client, LOCATION_ERROR_NOT_AVAILABLE); + g_return_val_if_fail(module->status_cb, LOCATION_ERROR_NOT_AVAILABLE); int ret = LBS_CLIENT_ERROR_NONE; - ret = lbs_client_stop(mod_nps->lbs_client, DEFAULT_INTERVAL_FOR_NOT_SUPPORTED); + ret = lbs_client_stop(module->lbs_client, UNNECESSARY_INTERVAL); if (ret != LBS_CLIENT_ERROR_NONE) { MOD_NPS_LOGE("Fail to stop. Error[%d]", ret); - lbs_client_destroy(mod_nps->lbs_client); - mod_nps->lbs_client = NULL; + lbs_client_destroy(module->lbs_client); + module->lbs_client = NULL; return LOCATION_ERROR_NOT_AVAILABLE; } - lbs_client_destroy(mod_nps->lbs_client); - mod_nps->lbs_client = NULL; + lbs_client_destroy(module->lbs_client); + module->lbs_client = NULL; - if (mod_nps->status_cb) - mod_nps->status_cb(FALSE, LOCATION_STATUS_NO_FIX, mod_nps->userdata); + if (module->status_cb) + module->status_cb(FALSE, LOCATION_STATUS_NO_FIX, module->userdata); - mod_nps->status_cb = NULL; - mod_nps->pos_cb = NULL; + module->status_cb = NULL; + module->pos_cb = NULL; return LOCATION_ERROR_NONE; } @@ -191,8 +191,8 @@ static int stop(gpointer handle) static int get_last_position(gpointer handle, LocationPosition **position, LocationVelocity **velocity, LocationAccuracy **accuracy) { MOD_NPS_LOGD("get_last_position"); - ModNpsData *mod_nps = (ModNpsData *) handle; - g_return_val_if_fail(mod_nps, LOCATION_ERROR_NOT_AVAILABLE); + ModNpsData *module = (ModNpsData *) handle; + g_return_val_if_fail(module, LOCATION_ERROR_NOT_AVAILABLE); g_return_val_if_fail(position, LOCATION_ERROR_PARAMETER); g_return_val_if_fail(velocity, LOCATION_ERROR_PARAMETER); g_return_val_if_fail(accuracy, LOCATION_ERROR_PARAMETER); @@ -288,22 +288,22 @@ static int set_mock_location(gpointer handle, LocationPosition *position, Locati LocationAccuracy *accuracy, LocModStatusCB mock_status_cb, gpointer userdata) { MOD_LOGD("ENTER >>> set_mock_location"); - ModNpsData *mod_nps = (ModNpsData *) handle; - g_return_val_if_fail(mod_nps, LOCATION_ERROR_NOT_AVAILABLE); + ModNpsData *module = (ModNpsData *) handle; + g_return_val_if_fail(module, LOCATION_ERROR_NOT_AVAILABLE); int ret = LBS_CLIENT_ERROR_NONE; - if (mod_nps->lbs_client == NULL) { - ret = lbs_client_create(LBS_CLIENT_METHOD_NPS , &(mod_nps->lbs_client)); - if (ret != LBS_CLIENT_ERROR_NONE || !mod_nps->lbs_client) { + if (module->lbs_client == NULL) { + ret = lbs_client_create(LBS_CLIENT_METHOD_NPS , &(module->lbs_client)); + if (ret != LBS_CLIENT_ERROR_NONE || !module->lbs_client) { MOD_LOGE("Fail to create lbs_client_h. Error[%d]", ret); return LOCATION_ERROR_NOT_AVAILABLE; } } - mod_nps->userdata = userdata; + module->userdata = userdata; - ret = lbs_client_set_mock_location_async(mod_nps->lbs_client, LBS_CLIENT_METHOD_NPS, + ret = lbs_client_set_mock_location_async(module->lbs_client, LBS_CLIENT_METHOD_NPS, position->latitude, position->longitude, position->altitude, - velocity->speed, velocity->direction, accuracy->horizontal_accuracy, NULL, mod_nps); + velocity->speed, velocity->direction, accuracy->horizontal_accuracy, NULL, module); if (ret != LBS_CLIENT_ERROR_NONE) { if (ret == LBS_CLIENT_ERROR_ACCESS_DENIED) { @@ -311,8 +311,8 @@ static int set_mock_location(gpointer handle, LocationPosition *position, Locati return LOCATION_ERROR_NOT_ALLOWED; } MOD_LOGE("Fail to start lbs_client_h. Error[%d]", ret); - lbs_client_destroy(mod_nps->lbs_client); - mod_nps->lbs_client = NULL; + lbs_client_destroy(module->lbs_client); + module->lbs_client = NULL; return LOCATION_ERROR_NOT_AVAILABLE; } @@ -323,21 +323,21 @@ static int set_mock_location(gpointer handle, LocationPosition *position, Locati static int clear_mock_location(gpointer handle, LocModStatusCB mock_status_cb, gpointer userdata) { MOD_LOGD("ENTER >>> clear_mock_location"); - ModNpsData *mod_nps = (ModNpsData *) handle; - g_return_val_if_fail(mod_nps, LOCATION_ERROR_NOT_AVAILABLE); + ModNpsData *module = (ModNpsData *) handle; + g_return_val_if_fail(module, LOCATION_ERROR_NOT_AVAILABLE); int ret = LBS_CLIENT_ERROR_NONE; - if (mod_nps->lbs_client == NULL) { - ret = lbs_client_create(LBS_CLIENT_METHOD_NPS , &(mod_nps->lbs_client)); - if (ret != LBS_CLIENT_ERROR_NONE || !mod_nps->lbs_client) { + if (module->lbs_client == NULL) { + ret = lbs_client_create(LBS_CLIENT_METHOD_NPS , &(module->lbs_client)); + if (ret != LBS_CLIENT_ERROR_NONE || !module->lbs_client) { MOD_LOGE("Fail to create lbs_client_h. Error[%d]", ret); return LOCATION_ERROR_NOT_AVAILABLE; } } - mod_nps->userdata = userdata; + module->userdata = userdata; - ret = lbs_client_set_mock_location_async(mod_nps->lbs_client, LBS_CLIENT_METHOD_NPS, - MOCK_LOCATION_CLEAR_VALUE, 0, 0, 0, 0, 0, NULL, mod_nps); + ret = lbs_client_set_mock_location_async(module->lbs_client, LBS_CLIENT_METHOD_NPS, + MOCK_LOCATION_CLEAR_VALUE, 0, 0, 0, 0, 0, NULL, module); if (ret != LBS_CLIENT_ERROR_NONE) { if (ret == LBS_CLIENT_ERROR_ACCESS_DENIED) { @@ -345,8 +345,8 @@ static int clear_mock_location(gpointer handle, LocModStatusCB mock_status_cb, g return LOCATION_ERROR_NOT_ALLOWED; } MOD_LOGE("Fail to start lbs_client_h. Error[%d]", ret); - lbs_client_destroy(mod_nps->lbs_client); - mod_nps->lbs_client = NULL; + lbs_client_destroy(module->lbs_client); + module->lbs_client = NULL; return LOCATION_ERROR_NOT_AVAILABLE; } @@ -364,34 +364,34 @@ LOCATION_MODULE_API gpointer init(LocModWpsOps *ops) ops->set_mock_location = set_mock_location; ops->clear_mock_location = clear_mock_location; - ModNpsData *mod_nps = g_new0(ModNpsData, 1); - g_return_val_if_fail(mod_nps, NULL); + ModNpsData *module = g_new0(ModNpsData, 1); + g_return_val_if_fail(module, NULL); - mod_nps->userdata = NULL; - mod_nps->status_cb = NULL; - mod_nps->pos_cb = NULL; - mod_nps->is_started = FALSE; + module->userdata = NULL; + module->status_cb = NULL; + module->pos_cb = NULL; + module->is_started = FALSE; - return mod_nps; + return module; } LOCATION_MODULE_API void shutdown(gpointer handle) { MOD_NPS_LOGD("shutdown"); - ModNpsData *mod_nps = (ModNpsData *) handle; - g_return_if_fail(mod_nps); + ModNpsData *module = (ModNpsData *) handle; + g_return_if_fail(module); - if (mod_nps->lbs_client) { - if (mod_nps->is_started) - lbs_client_stop(mod_nps->lbs_client, DEFAULT_INTERVAL_FOR_NOT_SUPPORTED); + if (module->lbs_client) { + if (module->is_started) + lbs_client_stop(module->lbs_client, UNNECESSARY_INTERVAL); - lbs_client_destroy(mod_nps->lbs_client); - mod_nps->lbs_client = NULL; + lbs_client_destroy(module->lbs_client); + module->lbs_client = NULL; } - mod_nps->status_cb = NULL; - mod_nps->pos_cb = NULL; + module->status_cb = NULL; + module->pos_cb = NULL; - g_free(mod_nps); - mod_nps = NULL; + g_free(module); + module = NULL; } diff --git a/module/passive_module.c b/module/passive_module.c index 7adfba6..1d943d6 100644 --- a/module/passive_module.c +++ b/module/passive_module.c @@ -40,16 +40,195 @@ #define MAX_GPS_LOC_ITEM 7 #define MAX_NPS_LOC_ITEM 6 +#define UNNECESSARY_INTERVAL 1 typedef struct { + lbs_client_dbus_h lbs_client; + LocModPositionExtCB pos_cb; + LocModSatelliteCB sat_cb; gpointer userdata; } ModPassiveData; +static void satellite_callback(GVariant *param, void *user_data) +{ + ModPassiveData *module = (ModPassiveData *)user_data; + g_return_if_fail(module); + g_return_if_fail(module->sat_cb); + + guint idx; + guint used_idx; + guint *used_prn_array = NULL; + gboolean ret = FALSE; + int timestamp = 0, satellite_used = 0, satellite_visible = 0; + + LocationSatellite *sat = NULL; + GVariant *used_prn = NULL; + GVariantIter *used_prn_iter = NULL; + GVariant *sat_info = NULL; + GVariantIter *sat_iter = NULL; + int prn = 0, elev = 0, azim = 0, snr = 0; + + g_variant_get(param, "(iii@ai@a(iiii))", ×tamp, &satellite_used, &satellite_visible, &used_prn, &sat_info); + g_variant_get(used_prn, "ai", &used_prn_iter); + g_variant_get(sat_info, "a(iiii)", &sat_iter); + MOD_LOGD("timestamp [%d], satellite_used [%d], satellite_visible[%d]", timestamp, satellite_used, satellite_visible); + int tmp_prn = 0; + int num_of_used_prn = g_variant_iter_n_children(used_prn_iter); + if (num_of_used_prn > 0) { + used_prn_array = (guint *)g_new0(guint, num_of_used_prn); + for (idx = 0; idx < num_of_used_prn; idx++) { + ret = g_variant_iter_next(used_prn_iter, "i", &tmp_prn); + if (ret == FALSE) + break; + used_prn_array[idx] = tmp_prn; + } + } + sat = location_satellite_new(satellite_visible); + + sat->timestamp = timestamp; + sat->num_of_sat_inview = satellite_visible; + sat->num_of_sat_used = satellite_used; + + GVariant *tmp_var = NULL; + for (idx = 0; idx < satellite_visible; idx++) { + gboolean used = FALSE; + tmp_var = g_variant_iter_next_value(sat_iter); + g_variant_get(tmp_var, "(iiii)", &prn, &elev, &azim, &snr); + if (used_prn_array != NULL) { + for (used_idx = 0; used_idx < satellite_used; used_idx++) { + if (prn == used_prn_array[used_idx]) { + used = TRUE; + break; + } + } + } + location_satellite_set_satellite_details(sat, idx, prn, used, elev, azim, snr); + g_variant_unref(tmp_var); + } + + module->sat_cb(TRUE, sat, module->userdata); + location_satellite_free(sat); + g_variant_iter_free(used_prn_iter); + g_variant_iter_free(sat_iter); + g_variant_unref(used_prn); + g_variant_unref(sat_info); + + if (used_prn_array) { + g_free(used_prn_array); + used_prn_array = NULL; + } +} + +static void position_callback(GVariant *param, void *user_data) +{ + ModPassiveData *module = (ModPassiveData *)user_data; + g_return_if_fail(module); + g_return_if_fail(module->pos_cb); + + int method = 0, fields = 0 , timestamp = 0 , level = 0; + double latitude = 0.0, longitude = 0.0, altitude = 0.0, speed = 0.0, direction = 0.0, climb = 0.0, horizontal = 0.0, vertical = 0.0; + GVariant *accuracy = NULL; + + g_variant_get(param, "(iiidddddd@(idd))", &method, &fields, ×tamp, &latitude, &longitude, &altitude, &speed, &direction, &climb, &accuracy); + g_variant_get(accuracy, "(idd)", &level, &horizontal, &vertical); + + LocationPosition *pos = NULL; + LocationVelocity *vel = NULL; + LocationAccuracy *acc = NULL; + + pos = location_position_new(timestamp, latitude, longitude, altitude, LOCATION_STATUS_3D_FIX); + vel = location_velocity_new(timestamp, speed, direction, climb); + acc = location_accuracy_new(LOCATION_ACCURACY_LEVEL_DETAILED, horizontal, vertical); + + module->pos_cb(TRUE, pos, vel, acc, module->userdata); + + location_position_free(pos); + location_velocity_free(vel); + location_accuracy_free(acc); + g_variant_unref(accuracy); +} + +static void on_signal_callback(const gchar *sig, GVariant *param, gpointer user_data) +{ + if (!g_strcmp0(sig, "SatelliteChanged")) + satellite_callback(param, user_data); + else if (!g_strcmp0(sig, "PositionChanged")) + position_callback(param, user_data); + else + MOD_LOGD("Invaild signal[%s]", sig); +} + +static int start(gpointer handle, guint pos_update_interval, LocModStatusCB status_cb, LocModPositionExtCB pos_cb, LocModSatelliteCB sat_cb, gpointer userdata) +{ + MOD_LOGD("start"); + ModPassiveData *module = (ModPassiveData *) handle; + g_return_val_if_fail(module, LOCATION_ERROR_NOT_AVAILABLE); + g_return_val_if_fail(pos_cb, LOCATION_ERROR_NOT_AVAILABLE); + + module->pos_cb = pos_cb; + module->sat_cb = sat_cb; + module->userdata = userdata; + + int ret = LBS_CLIENT_ERROR_NONE; + ret = lbs_client_create(LBS_CLIENT_METHOD_PASSIVE , &(module->lbs_client)); + if (ret != LBS_CLIENT_ERROR_NONE || !module->lbs_client) { + MOD_LOGE("Fail to create lbs_client_h. Error[%d]", ret); + return LOCATION_ERROR_NOT_AVAILABLE; + } + MOD_LOGD("fused handle(%p) pos_cb(%p) user_data(%p)", module, module->pos_cb, module->userdata); + + ret = lbs_client_start(module->lbs_client, UNNECESSARY_INTERVAL, LBS_CLIENT_LOCATION_CB | LBS_CLIENT_SATELLITE_CB, on_signal_callback, module); + if (ret != LBS_CLIENT_ERROR_NONE) { + if (ret == LBS_CLIENT_ERROR_ACCESS_DENIED) { + MOD_LOGE("Access denied[%d]", ret); + return LOCATION_ERROR_NOT_ALLOWED; + } + MOD_LOGE("Fail to start lbs_client_h. Error[%d]", ret); + lbs_client_destroy(module->lbs_client); + module->lbs_client = NULL; + + return LOCATION_ERROR_NOT_AVAILABLE; + } + + return LOCATION_ERROR_NONE; +} + +static int stop(gpointer handle) +{ + MOD_LOGD("stop"); + ModPassiveData *module = (ModPassiveData *) handle; + g_return_val_if_fail(module, LOCATION_ERROR_NOT_AVAILABLE); + g_return_val_if_fail(module->lbs_client, LOCATION_ERROR_NOT_AVAILABLE); + + int ret = LBS_CLIENT_ERROR_NONE; + + ret = lbs_client_stop(module->lbs_client, UNNECESSARY_INTERVAL); + MOD_LOGE("stop gps interval [%d]", UNNECESSARY_INTERVAL); + if (ret != LBS_CLIENT_ERROR_NONE) { + MOD_LOGE("Fail to stop. Error[%d]", ret); + lbs_client_destroy(module->lbs_client); + module->lbs_client = NULL; + return LOCATION_ERROR_NOT_AVAILABLE; + } + + ret = lbs_client_destroy(module->lbs_client); + if (ret != LBS_CLIENT_ERROR_NONE) { + MOD_LOGE("Fail to destroy. Error[%d]", ret); + return LOCATION_ERROR_NOT_AVAILABLE; + } + module->lbs_client = NULL; + + module->pos_cb = NULL; + module->sat_cb = NULL; + + return LOCATION_ERROR_NONE; +} + static int get_last_position(gpointer handle, LocationPosition **position, LocationVelocity **velocity, LocationAccuracy **accuracy) { MOD_LOGD("get_last_position"); - ModPassiveData *mod_passive = (ModPassiveData *) handle; - g_return_val_if_fail(mod_passive, LOCATION_ERROR_NOT_AVAILABLE); + ModPassiveData *module = (ModPassiveData *) handle; + g_return_val_if_fail(module, LOCATION_ERROR_NOT_AVAILABLE); g_return_val_if_fail(position, LOCATION_ERROR_PARAMETER); g_return_val_if_fail(velocity, LOCATION_ERROR_PARAMETER); g_return_val_if_fail(accuracy, LOCATION_ERROR_PARAMETER); @@ -145,8 +324,8 @@ static int get_last_position(gpointer handle, LocationPosition **position, Locat static int get_last_wps_position(gpointer handle, LocationPosition **position, LocationVelocity **velocity, LocationAccuracy **accuracy) { MOD_LOGD("get_last_wps_position"); - ModPassiveData *mod_passive = (ModPassiveData *) handle; - g_return_val_if_fail(mod_passive, LOCATION_ERROR_NOT_AVAILABLE); + ModPassiveData *module = (ModPassiveData *) handle; + g_return_val_if_fail(module, LOCATION_ERROR_NOT_AVAILABLE); g_return_val_if_fail(position, LOCATION_ERROR_PARAMETER); g_return_val_if_fail(velocity, LOCATION_ERROR_PARAMETER); g_return_val_if_fail(accuracy, LOCATION_ERROR_PARAMETER); @@ -243,24 +422,36 @@ LOCATION_MODULE_API gpointer init(LocModPassiveOps *ops) MOD_LOGD("init"); g_return_val_if_fail(ops, NULL); + ops->start = start; + ops->stop = stop; ops->get_last_position = get_last_position; ops->get_last_wps_position = get_last_wps_position; - ModPassiveData *mod_passive = g_new0(ModPassiveData, 1); - g_return_val_if_fail(mod_passive, NULL); + ModPassiveData *module = g_new0(ModPassiveData, 1); + g_return_val_if_fail(module, NULL); - mod_passive->userdata = NULL; + module->pos_cb = NULL; + module->sat_cb = NULL; + module->userdata = NULL; - return (gpointer) mod_passive; + return (gpointer) module; } LOCATION_MODULE_API void shutdown(gpointer handle) { MOD_LOGD("shutdown"); g_return_if_fail(handle); - ModPassiveData *mod_passive = (ModPassiveData *) handle; + ModPassiveData *module = (ModPassiveData *) handle; + + if (module->lbs_client) { + lbs_client_stop(module->lbs_client, UNNECESSARY_INTERVAL); + lbs_client_destroy(module->lbs_client); + module->lbs_client = NULL; + } - g_free(mod_passive); - mod_passive = NULL; + module->pos_cb = NULL; + module->sat_cb = NULL; + g_free(module); + module = NULL; } diff --git a/packaging/lbs-server.changes b/packaging/lbs-server.changes index b3d7fa4..f5b129b 100644 --- a/packaging/lbs-server.changes +++ b/packaging/lbs-server.changes @@ -1,3 +1,10 @@ +[Version] lbs-server_1.0.12 +[Date] 1 Feb 2017 +[Changes] Support satellite for passive mode + Fix to support SUPLNI +[Developer] Kyoungjun Sung + +================================================================================ [Version] lbs-server_1.0.11 [Date] 20 Dec 2016 [Changes] GPS plugin list updated to support serial mode diff --git a/packaging/lbs-server.spec b/packaging/lbs-server.spec index 62b7290..2d497c9 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.11 +Version: 1.0.12 Release: 1 Group: Location/Service License: Apache-2.0 -- 2.7.4