pdns_lookup_addr = ptr;
ptr = (char *)strtok_r(NULL, ":", &last);
- *port = atoi(ptr);
+
+ if (ptr)
+ *port = atoi(ptr);
}
tmpbuf = malloc(tmplen);
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);
}
switch (method) {
case LBS_SERVER_METHOD_GPS:
-
g_mutex_lock(&lbs_server->mutex);
lbs_server->gps_client_count++;
g_mutex_unlock(&lbs_server->mutex);
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;
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;
}
break;
+
+ case LBS_SERVER_METHOD_PASSIVE:
+ break;
+
default:
LOG_GPS(DBG_LOW, "stop_tracking Invalid");
break;
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)
}
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)
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())
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);
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",
LBS_SERVER_METHOD_AGPS,
LBS_SERVER_METHOD_GEOFENCE,
LBS_SERVER_METHOD_MOCK,
+ LBS_SERVER_METHOD_PASSIVE,
LBS_SERVER_METHOD_SIZE,
} lbs_server_method_e;
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);
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;
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)
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);
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;
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);
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)
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;
}
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;
}
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;
}
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;
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);
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);
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);
return LOCATION_ERROR_NOT_AVAILABLE;
}
- mod_gps->pos_interval = interval;
+ module->pos_interval = interval;
return LOCATION_ERROR_NONE;
}
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) {
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;
}
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) {
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;
}
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;
}
#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;
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;
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;
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);
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);
}
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;
}
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;
}
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);
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) {
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;
}
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) {
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;
}
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;
}
#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);
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);
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;
}
+[Version] lbs-server_1.0.12
+[Date] 1 Feb 2017
+[Changes] Support satellite for passive mode
+ Fix to support SUPLNI
+[Developer] Kyoungjun Sung <kj7.sung@samsung.com>
+
+================================================================================
[Version] lbs-server_1.0.11
[Date] 20 Dec 2016
[Changes] GPS plugin list updated to support serial mode
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
projects / platform / core / location / lbs-server.git / commitdiff