LOG_GPS(DBG_LOW, "get_last_position[%d]", last_pos->timestamp);
}
+
+void gps_set_last_mock(int timestamp, double lat, double lon, double alt, double spd, double dir, double h_acc)
+{
+ setting_set_int(VCONFKEY_LOCATION_LAST_GPS_TIMESTAMP, timestamp);
+ setting_set_double(VCONFKEY_LOCATION_LAST_GPS_LATITUDE, lat);
+ setting_set_double(VCONFKEY_LOCATION_LAST_GPS_LONGITUDE, lon);
+ setting_set_double(VCONFKEY_LOCATION_LAST_GPS_ALTITUDE, alt);
+ setting_set_double(VCONFKEY_LOCATION_LAST_GPS_SPEED, spd);
+ setting_set_double(VCONFKEY_LOCATION_LAST_GPS_DIRECTION, dir);
+ setting_set_double(VCONFKEY_LOCATION_LAST_GPS_HOR_ACCURACY, h_acc);
+}
+
void gps_get_last_position(pos_data_t *last_pos);
+void gps_set_last_mock(int timestamp, double lat, double lon, double alt, double spd, double dir, double h_acc);
+
#endif /* _LAST_POSITON_H_ */
#include "debug_util.h"
#include "dump_log.h"
-
-/* For test
-#define VCONFKEY_LOCATION_MOCK_ENABLED "db/location/setting/MockEnabled"
-#define VCONFKEY_LOCATION_MOCK_STATE "memory/location/mock/state"
-*/
-
#define MOCK_LOCATION_CLEAR_VALUE 999
+#define MOCK_RUNNING_OFF LBS_SERVER_METHOD_SIZE
typedef struct {
/* gps variables */
lbs_server_dbus_h lbs_dbus_server;
/* mock variables */
- gboolean is_mock_running;
- gint mock_client_count;
+ gint is_mock_running;
gint mock_timer;
- LbsStatus mock_status;
- NpsManagerPositionExt mock_position;
+ NpsManagerPositionExt mock_pos;
GVariant *mock_accuracy;
} lbs_server_s;
static gboolean gps_remove_all_clients(lbs_server_s *lbs_server);
static NpsManagerPositionExt g_mock_position;
static void set_mock_location_cb(gint method, gdouble latitude, gdouble longitude, gdouble altitude, gdouble speed, gdouble direction, gdouble accuracy, gpointer userdata);
-static int mock_start_tracking(lbs_server_s *lbs_server);
-static int mock_stop_tracking(lbs_server_s *lbs_server);
-static void mock_set_status(lbs_server_s *lbs_server, LbsStatus status);
-static void __setting_mock_cb(keynode_t *key, gpointer user_data);
+static void mock_start_tracking(lbs_server_s *lbs_server);
+static void mock_stop_tracking(lbs_server_s *lbs_server);
static void __setting_gps_cb(keynode_t *key, gpointer user_data)
{
- LOG_GPS(DBG_LOW, "ENTER >>>");
+ LOG_GPS(DBG_LOW, "__setting_gps_cb");
lbs_server_s *lbs_server = (lbs_server_s *)user_data;
int onoff = 0;
gboolean ret = FALSE;
}
}
+static void __setting_mock_cb(keynode_t *key, gpointer user_data)
+{
+ LOG_GPS(DBG_LOW, "__setting_mock_cb");
+ lbs_server_s *lbs_server = (lbs_server_s *)user_data;
+ int onoff = 0;
+
+ setting_get_int(VCONFKEY_LOCATION_MOCK_ENABLED, &onoff);
+
+ if (onoff == 0) {
+ mock_stop_tracking(lbs_server);
+ setting_ignore_key_changed(VCONFKEY_LOCATION_MOCK_ENABLED, __setting_mock_cb);
+ }
+}
+
static void nps_set_last_position(NpsManagerPositionExt pos)
{
LOG_NPS(DBG_LOW, "nps_set_last_position[%d]", pos.timestamp);
return;
}
+ if (lbs_server_nps->is_mock_running != MOCK_RUNNING_OFF)
+ return ;
+
GVariant *accuracy = NULL;
lbs_server_nps->pos.fields = pos.fields;
if (!location) {
LOG_NPS(DBG_LOW, "NULL is returned from plugin...");
- nps_set_status (lbs_server , LBS_STATUS_ACQUIRING);
+ nps_set_status(lbs_server , LBS_STATUS_ACQUIRING);
return;
}
g_mutex_unlock(&lbs_server->mutex);
if (lbs_server->is_gps_running == FALSE) {
- LOG_GPS(DBG_LOW, "Batch: start_tracking GPS");
+ LOG_GPS(DBG_LOW, "Batch: start tracking GPS");
lbs_server->status = LBS_STATUS_ACQUIRING;
}
lbs_server->gps_client_count++;
g_mutex_unlock(&lbs_server->mutex);
+ if (lbs_server->is_mock_running != MOCK_RUNNING_OFF && lbs_server->is_gps_running == FALSE && lbs_server->is_nps_running == FALSE)
+ mock_start_tracking(lbs_server);
+
if (lbs_server->is_gps_running == TRUE) {
LOG_GPS(DBG_LOW, "gps is already running");
return;
}
- LOG_GPS(DBG_LOW, "start_tracking GPS");
+ LOG_GPS(DBG_LOW, "start tracking GPS");
lbs_server->status = LBS_STATUS_ACQUIRING;
if (request_start_session((int)(lbs_server->optimized_interval_array[method])) == TRUE) {
g_mutex_unlock(&lbs_server->mutex);
lbs_server->is_needed_changing_interval = FALSE;
-
- /* ADD notify */
setting_notify_key_changed(VCONFKEY_LOCATION_ENABLED, __setting_gps_cb, lbs_server);
} else {
LOG_GPS(DBG_ERR, "Failed to request_start_session");
lbs_server->nps_client_count++;
g_mutex_unlock(&lbs_server->mutex);
+ if (lbs_server->is_mock_running != MOCK_RUNNING_OFF && lbs_server->is_gps_running == FALSE && lbs_server->is_nps_running == FALSE)
+ mock_start_tracking(lbs_server);
+
if (lbs_server->is_nps_running == TRUE) {
LOG_NPS(DBG_LOW, "nps is already running");
return;
nps_set_status(lbs_server, LBS_STATUS_ERROR);
break;
- case LBS_SERVER_METHOD_MOCK:
- g_mutex_lock(&lbs_server->mutex);
- lbs_server->mock_client_count++;
- g_mutex_unlock(&lbs_server->mutex);
-
- if (lbs_server->is_mock_running == TRUE) {
- LOG_MOCK(DBG_LOW, "mock is already running");
- return;
- }
-
- LOG_MOCK(DBG_LOW, "start_tracking MOCK");
- ret = mock_start_tracking(lbs_server);
- if (ret) {
- g_mutex_lock(&lbs_server->mutex);
- lbs_server->is_mock_running = TRUE;
- g_mutex_unlock(&lbs_server->mutex);
-
- /* ADD notify */
- setting_notify_key_changed(VCONFKEY_LOCATION_MOCK_ENABLED, __setting_mock_cb, lbs_server);
- return;
- } else {
- LOG_MOCK(DBG_ERR, "Failed to start MOCK");
- }
- break;
-
default:
LOG_GPS(DBG_LOW, "start_tracking Invalid");
break;
case LBS_SERVER_METHOD_GPS:
LOG_GPS(DBG_LOW, "stop_tracking GPS");
- gps_set_last_position(&lbs_server->position);
+ if (lbs_server->is_mock_running == MOCK_RUNNING_OFF)
+ gps_set_last_position(&lbs_server->position);
g_mutex_lock(&lbs_server->mutex);
lbs_server->gps_client_count--;
}
break;
- case LBS_SERVER_METHOD_MOCK:
- LOG_NPS(DBG_LOW, "stop_tracking MOCK");
-
- g_mutex_lock(&lbs_server->mutex);
- lbs_server->mock_client_count--;
- g_mutex_unlock(&lbs_server->mutex);
-
- if (lbs_server->is_mock_running == FALSE) {
- LOG_NPS(DBG_LOW, "mock is already stopped");
- return;
- }
-
- if (lbs_server->mock_client_count <= 0) {
- g_mutex_lock(&lbs_server->mutex);
- lbs_server->mock_client_count = 0;
- g_mutex_unlock(&lbs_server->mutex);
-
- LOG_NPS(DBG_LOW, "lbs_server_mock Normal stop");
- mock_stop_tracking(lbs_server);
- setting_ignore_key_changed(VCONFKEY_LOCATION_MOCK_ENABLED, __setting_mock_cb);
- }
-
- break;
default:
LOG_GPS(DBG_LOW, "stop_tracking Invalid");
break;
gint b_interval = 0, b_period = 0;
while (g_variant_iter_next(&iter, "{&sv}", &key, &value)) {
- if (!g_strcmp0(key, "BATCH_INTERVAL")) {
+ if (!g_strcmp0(key, "BATCH_INTERVAL"))
b_interval = g_variant_get_int32(value);
- } else if (!g_strcmp0(key, "BATCH_PERIOD")) {
+ else if (!g_strcmp0(key, "BATCH_PERIOD"))
b_period = g_variant_get_int32(value);
- }
}
LOG_GPS(DBG_LOW, "BATCH_INTERVAL [%d], BATCH_PERIOD [%d]", b_interval, b_period);
start_batch_tracking(lbs_server, lbs_server->optimized_batch_array[LBS_BATCH_INTERVAL],
lbs_server->optimized_batch_array[LBS_BATCH_PERIOD]);
- }
- else if (!g_strcmp0(g_variant_get_string(value, &length), "STOP_BATCH")) {
+ } else if (!g_strcmp0(g_variant_get_string(value, &length), "STOP_BATCH")) {
if (client)
update_batch_tracking_interval(LBS_SERVER_INTERVAL_REMOVE, client, 0, 0, lbs_server);
static gboolean gps_remove_all_clients(lbs_server_s *lbs_server)
{
LOG_GPS(DBG_LOW, "remove_all_clients GPS");
+ if (lbs_server->is_mock_running == LBS_SERVER_METHOD_GPS) {
+ mock_stop_tracking(lbs_server);
+ setting_ignore_key_changed(VCONFKEY_LOCATION_MOCK_ENABLED, __setting_mock_cb);
+ }
+
if (lbs_server->gps_client_count <= 0) {
lbs_server->gps_client_count = 0;
return FALSE;
static void shutdown(gpointer userdata, gboolean *shutdown_arr)
{
- LOG_GPS(DBG_LOW, "shutdown callback gps:%d nps:%d, mock:%d",
- shutdown_arr[LBS_SERVER_METHOD_GPS], shutdown_arr[LBS_SERVER_METHOD_NPS], shutdown_arr[LBS_SERVER_METHOD_MOCK]);
+ LOG_GPS(DBG_LOW, "shutdown callback gps:%d nps:%d", shutdown_arr[LBS_SERVER_METHOD_GPS], shutdown_arr[LBS_SERVER_METHOD_NPS]);
lbs_server_s *lbs_server = (lbs_server_s *)userdata;
if (shutdown_arr[LBS_SERVER_METHOD_GPS]) {
}
}
- if (shutdown_arr[LBS_SERVER_METHOD_MOCK]) {
- LOG_NPS(DBG_LOW, "-> shutdown MOCK");
- if (lbs_server->is_mock_running) {
- LOG_NPS(DBG_ERR, "mock location is running");
- mock_stop_tracking(lbs_server);
- }
- }
-
#if 0 /* Not needed */
int enabled = 0;
setting_get_int(VCONFKEY_LOCATION_NETWORK_ENABLED, &enabled);
lbs_server_s *lbs_server = (lbs_server_s *)(user_data);
+ if (lbs_server->is_mock_running != MOCK_RUNNING_OFF)
+ return ;
+
memcpy(&lbs_server->position, pos, sizeof(pos_data_t));
if (lbs_server->status != LBS_STATUS_AVAILABLE) {
fields = (LBS_POSITION_EXT_FIELDS_LATITUDE | LBS_POSITION_EXT_FIELDS_LONGITUDE | LBS_POSITION_EXT_FIELDS_ALTITUDE | LBS_POSITION_EXT_FIELDS_SPEED | LBS_POSITION_EXT_FIELDS_DIRECTION);
accuracy = g_variant_new("(idd)", LBS_ACCURACY_LEVEL_DETAILED, pos->hor_accuracy, pos->ver_accuracy);
- if (NULL == accuracy)
+ if (accuracy == NULL)
LOG_GPS(DBG_LOW, "accuracy is NULL");
+ 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);
}
static void gps_update_satellite_cb(sv_data_t *sv, void *user_data)
{
lbs_server_s *lbs_server = (lbs_server_s *)(user_data);
- if (lbs_server->sv_used == FALSE) {
- /* LOG_GPS(DBG_LOW, "sv_used is FALSE"); */
+ if (lbs_server->sv_used == FALSE)
return;
- }
- LOG_GPS(DBG_LOW, "ENTER >>>");
int index;
int timestamp = 0;
int satellite_used = 0;
lbs_server->is_needed_changing_interval = FALSE;
/* Mock Location init */
- lbs_server->mock_status = LBS_STATUS_UNAVAILABLE;
- lbs_server->is_mock_running = FALSE;
- lbs_server->gps_client_count = 0;
+ lbs_server->is_mock_running = MOCK_RUNNING_OFF;
lbs_server->mock_timer = 0;
+ lbs_server->mock_accuracy = NULL;
#ifndef TIZEN_DEVICE
lbs_server->batch_interval_table = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
LOG_MOCK(DBG_ERR, "lbs-server is NULL!!");
return;
}
- LOG_SEC("Input lat = %lf, lng = %lf", latitude, longitude);
+ LOG_SEC("[set_mock_location] lat = %lf, lng = %lf", latitude, longitude);
memset(&g_mock_position, 0x00, sizeof(NpsManagerPositionExt));
if (latitude == MOCK_LOCATION_CLEAR_VALUE) {
- LOG_MOCK(DBG_LOW, "MOCK Location is cleared");
- mock_set_status(lbs_server, LBS_STATUS_ACQUIRING);
- return;
+ if (lbs_server->is_mock_running != MOCK_RUNNING_OFF) {
+ g_mutex_lock(&lbs_server->mutex);
+ lbs_server->is_mock_running = MOCK_RUNNING_OFF;
+ g_mutex_unlock(&lbs_server->mutex);
+
+ mock_stop_tracking(lbs_server);
+ setting_ignore_key_changed(VCONFKEY_LOCATION_MOCK_ENABLED, __setting_mock_cb);
+ g_mock_position.timestamp = 0;
+ }
+ return ;
}
time_t timestamp;
g_mock_position.hor_accuracy = accuracy;
g_mock_position.ver_accuracy = -1;
- LOG_SEC("[%d] lat = %lf, lng = %lf", g_mock_position.timestamp, g_mock_position.latitude, g_mock_position.longitude);
+ if (lbs_server->is_mock_running == MOCK_RUNNING_OFF) {
+ g_mutex_lock(&lbs_server->mutex);
+ lbs_server->is_mock_running = method;
+ g_mutex_unlock(&lbs_server->mutex);
+ }
+
+ if (lbs_server->is_gps_running || lbs_server->is_nps_running)
+ mock_start_tracking(lbs_server);
+
+ gps_set_last_mock(timestamp, latitude, longitude, altitude, speed, direction, accuracy);
}
int __copy_mock_location(lbs_server_s *lbs_server)
return FALSE;
}
- memset(&lbs_server->mock_position, 0x00, sizeof(NpsManagerPositionExt));
- memcpy(&lbs_server->mock_position, &g_mock_position, sizeof(NpsManagerPositionExt));
+ memset(&lbs_server->mock_pos, 0x00, sizeof(NpsManagerPositionExt));
+ memcpy(&lbs_server->mock_pos, &g_mock_position, sizeof(NpsManagerPositionExt));
g_mock_position.fields = LBS_POSITION_EXT_FIELDS_NONE;
- LOG_SEC("[%ld] lat = %lf, lng = %lf", lbs_server->mock_position.timestamp, lbs_server->mock_position.latitude, lbs_server->mock_position.longitude);
+ LOG_SEC("[%ld] lat = %lf, lng = %lf", lbs_server->mock_pos.timestamp, lbs_server->mock_pos.latitude, lbs_server->mock_pos.longitude);
- if (lbs_server->mock_position.latitude >= -90 && lbs_server->mock_position.latitude <= 90)
- lbs_server->mock_position.fields |= LBS_POSITION_EXT_FIELDS_LATITUDE;
+ if (lbs_server->mock_pos.latitude >= -90 && lbs_server->mock_pos.latitude <= 90)
+ lbs_server->mock_pos.fields |= LBS_POSITION_EXT_FIELDS_LATITUDE;
- if (lbs_server->mock_position.longitude >= -180 && lbs_server->mock_position.longitude <= 180)
- lbs_server->mock_position.fields |= LBS_POSITION_EXT_FIELDS_LONGITUDE;
+ if (lbs_server->mock_pos.longitude >= -180 && lbs_server->mock_pos.longitude <= 180)
+ lbs_server->mock_pos.fields |= LBS_POSITION_EXT_FIELDS_LONGITUDE;
- lbs_server->mock_position.fields |= LBS_POSITION_EXT_FIELDS_ALTITUDE;
+ lbs_server->mock_pos.fields |= LBS_POSITION_EXT_FIELDS_ALTITUDE;
- if (lbs_server->mock_position.speed >= 0)
- lbs_server->mock_position.fields |= LBS_POSITION_EXT_FIELDS_SPEED;
+ if (lbs_server->mock_pos.speed >= 0)
+ lbs_server->mock_pos.fields |= LBS_POSITION_EXT_FIELDS_SPEED;
- if (lbs_server->mock_position.direction >= 0 && lbs_server->mock_position.direction <= 360)
- lbs_server->mock_position.fields |= LBS_POSITION_EXT_FIELDS_DIRECTION;
+ if (lbs_server->mock_pos.direction >= 0 && lbs_server->mock_pos.direction <= 360)
+ lbs_server->mock_pos.fields |= LBS_POSITION_EXT_FIELDS_DIRECTION;
- lbs_server->mock_accuracy = g_variant_ref_sink(g_variant_new("(idd)", LBS_ACCURACY_LEVEL_DETAILED, lbs_server->mock_position.hor_accuracy, -1));
+ lbs_server->mock_accuracy = g_variant_ref_sink(g_variant_new("(idd)", LBS_ACCURACY_LEVEL_DETAILED, lbs_server->mock_pos.hor_accuracy, -1));
return TRUE;
}
return FALSE;
}
- if (lbs_server->mock_status == LBS_STATUS_ACQUIRING) {
- if (g_mock_position.timestamp) {
+ if (g_mock_position.timestamp) {
+ if (g_mock_position.fields & LBS_POSITION_EXT_FIELDS_DIRTY)
__copy_mock_location(lbs_server);
- mock_set_status(lbs_server, LBS_STATUS_AVAILABLE);
- }
- } else if (lbs_server->mock_status == LBS_STATUS_AVAILABLE) {
- if (g_mock_position.timestamp) {
- if (g_mock_position.fields & LBS_POSITION_EXT_FIELDS_DIRTY)
- __copy_mock_location(lbs_server);
-
- time_t timestamp;
- time(×tamp);
-
- LOG_SEC("[%d] lat = %lf, lng = %lf", lbs_server->mock_position.timestamp,
- lbs_server->mock_position.latitude, lbs_server->mock_position.longitude);
-
- lbs_server->mock_position.timestamp = timestamp;
- lbs_server_emit_position_changed(lbs_server->lbs_dbus_server, LBS_SERVER_METHOD_MOCK,
- lbs_server->mock_position.fields, lbs_server->mock_position.timestamp,
- lbs_server->mock_position.latitude, lbs_server->mock_position.longitude, lbs_server->mock_position.altitude,
- lbs_server->mock_position.speed, lbs_server->mock_position.direction, 0.0, lbs_server->mock_accuracy);
- } else {
- mock_set_status(lbs_server, LBS_STATUS_ACQUIRING);
- }
+
+ time_t timestamp;
+ time(×tamp);
+
+ LOG_SEC("[%d] lat = %lf, lng = %lf", lbs_server->mock_pos.timestamp, lbs_server->mock_pos.latitude, lbs_server->mock_pos.longitude);
+
+ lbs_server->mock_pos.timestamp = timestamp;
+ lbs_server_emit_position_changed(lbs_server->lbs_dbus_server, LBS_SERVER_METHOD_MOCK,
+ lbs_server->mock_pos.fields, lbs_server->mock_pos.timestamp,
+ lbs_server->mock_pos.latitude, lbs_server->mock_pos.longitude, lbs_server->mock_pos.altitude,
+ lbs_server->mock_pos.speed, lbs_server->mock_pos.direction, 0.0, lbs_server->mock_accuracy);
}
return TRUE;
}
-static gboolean mock_start_tracking(lbs_server_s *lbs_server)
+static void mock_start_tracking(lbs_server_s *lbs_server)
{
- LOG_MOCK(DBG_LOW, "ENTER >>>");
+ LOG_MOCK(DBG_LOW, "ENTER >>> mock_start_tracking");
if (!lbs_server) {
LOG_MOCK(DBG_ERR, "lbs_server is NULL!!");
- return FALSE;
+ return ;
}
__copy_mock_location(lbs_server);
- mock_set_status(lbs_server, LBS_STATUS_ACQUIRING);
- if (!lbs_server->mock_timer)
+ if (!lbs_server->mock_timer) {
lbs_server->mock_timer = g_timeout_add_seconds(1, __mock_position_update_cb, lbs_server);
-
- return TRUE;
+ setting_notify_key_changed(VCONFKEY_LOCATION_MOCK_ENABLED, __setting_mock_cb, lbs_server);
+ }
}
-static int mock_stop_tracking(lbs_server_s *lbs_server)
+static void mock_stop_tracking(lbs_server_s *lbs_server)
{
- LOG_MOCK(DBG_LOW, "ENTER >>>");
+ LOG_MOCK(DBG_LOW, ">>> mock_stop_tracking");
if (!lbs_server) {
LOG_MOCK(DBG_ERR, "lbs-server is NULL!!");
- return FALSE;
+ return ;
}
- if (lbs_server->mock_timer) g_source_remove(lbs_server->mock_timer);
+ if (lbs_server->mock_timer)
+ g_source_remove(lbs_server->mock_timer);
+
lbs_server->mock_timer = 0;
- g_variant_unref(lbs_server->mock_accuracy);
+ if (lbs_server->mock_accuracy)
+ g_variant_unref(lbs_server->mock_accuracy);
- if (lbs_server->is_mock_running) {
+ if (lbs_server->is_mock_running != MOCK_RUNNING_OFF) {
g_mutex_lock(&lbs_server->mutex);
- lbs_server->is_mock_running = FALSE;
+ lbs_server->is_mock_running = MOCK_RUNNING_OFF;
g_mutex_unlock(&lbs_server->mutex);
}
-
- mock_set_status(lbs_server, LBS_STATUS_UNAVAILABLE);
-
- return 0;
-}
-
-static void mock_set_status(lbs_server_s *lbs_server, LbsStatus status)
-{
- if (!lbs_server) {
- LOG_MOCK(DBG_ERR, "lbs_server is NULL!!");
- return;
- }
- LOG_MOCK(DBG_LOW, "Previous status: %d, Current status: %d", lbs_server->mock_status, status);
- if (lbs_server->mock_status == status) {
- LOG_MOCK(DBG_ERR, "Don't update MOCK status");
- return;
- }
-
- lbs_server->mock_status = status;
-
- if (lbs_server->mock_status == LBS_STATUS_AVAILABLE)
- setting_set_int(VCONFKEY_LOCATION_MOCK_STATE, POSITION_CONNECTED);
- else if (lbs_server->mock_status == LBS_STATUS_ACQUIRING)
- setting_set_int(VCONFKEY_LOCATION_MOCK_STATE, POSITION_SEARCHING);
- else
- setting_set_int(VCONFKEY_LOCATION_MOCK_STATE, POSITION_OFF);
-
- lbs_server_emit_status_changed(lbs_server->lbs_dbus_server, LBS_SERVER_METHOD_MOCK, status);
-}
-
-static gboolean mock_remove_all_clients(lbs_server_s *lbs_server)
-{
- LOG_MOCK(DBG_LOW, "remove_all_clients MOCK");
- if (lbs_server->mock_client_count <= 0) {
- lbs_server->mock_client_count = 0;
- return FALSE;
- }
-
- lbs_server->mock_client_count = 0;
- stop_tracking(lbs_server, LBS_SERVER_METHOD_MOCK);
-
- return TRUE;
-}
-
-static void __setting_mock_cb(keynode_t *key, gpointer user_data)
-{
- LOG_MOCK(DBG_LOW, "ENTER >>>");
- lbs_server_s *lbs_server = (lbs_server_s *)user_data;
- int onoff = 0;
- gboolean ret = FALSE;
-
- setting_get_int(VCONFKEY_LOCATION_MOCK_ENABLED, &onoff);
-
- if (onoff == 0) {
- ret = mock_remove_all_clients(lbs_server);
-
- if (ret == FALSE)
- LOG_MOCK(DBG_LOW, "already removed.");
- }
}
#ifndef TIZEN_DEVICE
case LBS_SERVER_INTERVAL_REMOVE: {
LOG_GPS(DBG_LOW, "REMOVE, client[%s]", client);
guint *interval_array = (guint *) g_hash_table_lookup(lbs_server->batch_interval_table, client);
- if(!interval_array) {
+ if (!interval_array) {
LOG_GPS(DBG_INFO, "Client[%s] is already removed from batch-table", client);
break;
}
LOG_GPS(DBG_LOW, "Remove interval_array(%p):[%u, %u] from batch-table", interval_array, interval_array[LBS_BATCH_INTERVAL], interval_array[LBS_BATCH_PERIOD]);
- if (!g_hash_table_remove(lbs_server->batch_interval_table, client)) {
+ if (!g_hash_table_remove(lbs_server->batch_interval_table, client))
LOG_GPS(DBG_ERR, "g_hash_table_remove is failed.");
- }
+
break;
}
return FALSE;
} else {
LOG_GPS(DBG_LOW, "updates optimized-batch-interval.");
- dynamic_interval_updator_user_data updator_user_data; // temporary struct
+ dynamic_interval_updator_user_data updator_user_data;
updator_user_data.lbs_server = lbs_server;
g_hash_table_foreach(lbs_server->batch_interval_table,
memcpy(server->pos_data, &(gps_event->event_data.pos_ind.pos), sizeof(pos_data_t));
/* change m/s to km/h */
server->pos_data->speed = server->pos_data->speed * MPS_TO_KMPH;
- gps_set_position(server->pos_data);
g_update_cb.pos_cb(server->pos_data, gps_event->event_data.pos_ind.error, g_user_data);
} else {
LOG_GPS(DBG_ERR, "server->pos_data is NULL");
SET(gps_module "gps")
SET(nps_module "wps")
-SET(mock_module "mock")
SET(CLIENT_SRCS_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
SET(module_pkgs_LDFLAGS "${module_pkgs_LDFLAGS} -ldl")
INSTALL(TARGETS ${nps_module} DESTINATION ${LIB_DIR}/location/module)
ENDIF (ENABLE_WPS)
-ADD_LIBRARY(${mock_module} SHARED ${CLIENT_SRCS_DIR}/mock_module.c)
-TARGET_LINK_LIBRARIES(${mock_module} ${module_pkgs_LDFLAGS})
-SET_TARGET_PROPERTIES(${mock_module} PROPERTIES VERSION ${FULLVER} SOVERSION ${MAJORVER} CLEAN_DIRECT_OUTPUT 1)
-SET_TARGET_PROPERTIES(${mock_module} PROPERTIES COMPILE_FLAGS ${MODULE_EXTRA_CFLAGS})
-
-INSTALL(TARGETS ${mock_module} DESTINATION ${LIB_DIR}/location/module)
#include "log.h"
#define MAX_GPS_LOC_ITEM 7
+#define MOCK_LOCATION_CLEAR_VALUE 999
typedef struct {
lbs_client_dbus_h lbs_client;
g_variant_get(param, "(iiidddddd@(idd))", &method, &fields, ×tamp, &latitude, &longitude, &altitude, &speed, &direction, &climb, &accuracy);
- /* MOD_LOGD("position_callback [method: %d, field: %d]", method, fields); */
if (method != LBS_CLIENT_METHOD_GPS) {
- MOD_LOGD("Method is not LBS_CLIENT_METHOD_GPS: %d", method);
- return;
+ if (method != LBS_CLIENT_METHOD_MOCK) {
+ MOD_LOGD("Method is not LBS_CLIENT_METHOD_GPS: %d", method);
+ return;
+ }
}
g_variant_get(accuracy, "(idd)", &level, &horizontal, &vertical);
MOD_LOGD("Invaild signal[%s]", sig);
}
-static int start_batch(gpointer handle, LocModBatchExtCB batch_cb, guint batch_interval, guint batch_period, gpointer userdata)
+static int start(gpointer handle, guint pos_update_interval, LocModStatusCB status_cb, LocModPositionExtCB pos_cb, LocModSatelliteCB sat_cb, gpointer userdata)
{
- MOD_LOGD("start_batch");
+ MOD_LOGD("start");
GpsManagerData *mod_gps = (GpsManagerData *) handle;
g_return_val_if_fail(mod_gps, LOCATION_ERROR_NOT_AVAILABLE);
- g_return_val_if_fail(batch_cb, 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->batch_cb = batch_cb;
+ mod_gps->status_cb = status_cb;
+ mod_gps->pos_cb = pos_cb;
+ mod_gps->sat_cb = sat_cb;
mod_gps->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) {
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) pos_cb (%p) user_data(%p)", mod_gps, mod_gps->pos_cb, mod_gps->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_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);
if (ret != LBS_CLIENT_ERROR_NONE) {
if (ret == LBS_CLIENT_ERROR_ACCESS_DENIED) {
MOD_LOGE("Access denied[%d]", ret);
return LOCATION_ERROR_NONE;
}
-static int start(gpointer handle, guint pos_update_interval, LocModStatusCB status_cb, LocModPositionExtCB pos_cb, LocModSatelliteCB sat_cb, gpointer userdata)
+static int stop(gpointer handle)
{
- MOD_LOGD("start");
+ MOD_LOGD("stop");
GpsManagerData *mod_gps = (GpsManagerData *) handle;
g_return_val_if_fail(mod_gps, 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);
+ 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);
- mod_gps->status_cb = status_cb;
- mod_gps->pos_cb = pos_cb;
- mod_gps->sat_cb = sat_cb;
+ int ret = LBS_CLIENT_ERROR_NONE;
+
+ ret = lbs_client_stop(mod_gps->lbs_client);
+ 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;
+ return LOCATION_ERROR_NOT_AVAILABLE;
+ }
+
+ ret = lbs_client_destroy(mod_gps->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;
+
+ if (mod_gps->status_cb)
+ mod_gps->status_cb(FALSE, LOCATION_STATUS_NO_FIX, mod_gps->userdata);
+
+ mod_gps->status_cb = NULL;
+ mod_gps->pos_cb = NULL;
+ mod_gps->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);
+ g_return_val_if_fail(batch_cb, LOCATION_ERROR_NOT_AVAILABLE);
+
+ mod_gps->batch_cb = batch_cb;
mod_gps->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) {
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) batch_cb(%p) user_data(%p)", mod_gps, mod_gps->batch_cb, mod_gps->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_batch_start(mod_gps->lbs_client, LBS_CLIENT_BATCH_CB, on_signal_batch_callback, batch_interval, batch_period, mod_gps);
if (ret != LBS_CLIENT_ERROR_NONE) {
if (ret == LBS_CLIENT_ERROR_ACCESS_DENIED) {
MOD_LOGE("Access denied[%d]", ret);
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);
-
- int ret = LBS_CLIENT_ERROR_NONE;
-
- ret = lbs_client_stop(mod_gps->lbs_client);
- 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;
- return LOCATION_ERROR_NOT_AVAILABLE;
- }
-
- ret = lbs_client_destroy(mod_gps->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;
-
- if (mod_gps->status_cb)
- mod_gps->status_cb(FALSE, LOCATION_STATUS_NO_FIX, mod_gps->userdata);
-
- mod_gps->status_cb = NULL;
- mod_gps->pos_cb = NULL;
- mod_gps->sat_cb = NULL;
-
- return LOCATION_ERROR_NONE;
-}
-
static int get_nmea(gpointer handle, gchar **nmea_data)
{
MOD_LOGD("get_nmea");
return LOCATION_ERROR_NONE;
}
+static int set_mock_location(gpointer handle, LocationPosition *position, LocationVelocity *velocity,
+ 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);
+ 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) {
+ MOD_LOGE("Fail to create lbs_client_h. Error[%d]", ret);
+ return LOCATION_ERROR_NOT_AVAILABLE;
+ }
+ }
+ mod_gps->userdata = userdata;
+
+ ret = lbs_client_set_mock_location_async(mod_gps->lbs_client, LBS_CLIENT_METHOD_GPS,
+ position->latitude, position->longitude, position->altitude,
+ velocity->speed, velocity->direction, accuracy->horizontal_accuracy, NULL, mod_gps);
+
+ 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;
+
+ return LOCATION_ERROR_NOT_AVAILABLE;
+ }
+
+ return LOCATION_ERROR_NONE;
+}
+
+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);
+ 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) {
+ MOD_LOGE("Fail to create lbs_client_h. Error[%d]", ret);
+ return LOCATION_ERROR_NOT_AVAILABLE;
+ }
+ }
+ mod_gps->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);
+
+ 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;
+
+ return LOCATION_ERROR_NOT_AVAILABLE;
+ }
+
+ return LOCATION_ERROR_NONE;
+}
+
LOCATION_MODULE_API gpointer init(LocModGpsOps *ops)
{
MOD_LOGD("init");
g_return_val_if_fail(ops, NULL);
ops->start = start;
- ops->start_batch = start_batch;
ops->stop = stop;
- ops->stop_batch = stop_batch;
ops->get_last_position = get_last_position;
ops->set_option = set_option;
ops->set_position_update_interval = set_position_update_interval;
+ ops->start_batch = start_batch;
+ ops->stop_batch = stop_batch;
+ ops->set_mock_location = set_mock_location;
+ ops->clear_mock_location = clear_mock_location;
+
Dl_info info;
if (dladdr(&get_last_position, &info) == 0)
MOD_LOGE("Failed to get module name");
+++ /dev/null
-/*
- * lbs-server
- *
- * Copyright (c) 2011-2013 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact: Youngae Kang <youngae.kang@samsung.com>, Minjune Kim <sena06.kim@samsung.com>
- * Genie Kim <daejins.kim@samsung.com>
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <glib.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include <vconf.h>
-#include <vconf-internal-location-keys.h>
-#include <location-module.h>
-
-#include <dlfcn.h>
-#include <lbs_dbus_client.h>
-#include <lbs_agps.h>
-
-#include "log.h"
-
-#define MOCK_LOCATION_CLEAR_VALUE 999
-
-typedef struct {
- lbs_client_dbus_h lbs_client;
- LocModStatusCB mock_status_cb;
- LocModStatusCB status_cb;
- LocModPositionExtCB pos_cb;
- gpointer userdata;
- gboolean is_started;
- LocationPosition *last_pos;
- LocationVelocity *last_vel;
- LocationAccuracy *last_acc;
-} ModMockData;
-
-typedef enum {
- LBS_STATUS_ERROR, /* from lbs-server */
- LBS_STATUS_UNAVAILABLE,
- LBS_STATUS_ACQUIRING,
- LBS_STATUS_AVAILABLE,
- LBS_STATUS_BATCH,
- LBS_STATUS_MOCK_SET, /* from lbs-dbus status for mock location */
- LBS_STATUS_MOCK_FAIL,
-} LbsStatus;
-
-static void status_callback(GVariant *param, void *user_data)
-{
- ModMockData *mod_mock = (ModMockData *) user_data;
- g_return_if_fail(param);
- g_return_if_fail(mod_mock);
- g_return_if_fail(mod_mock->status_cb);
-
- int status = 0, method = 0;
- g_variant_get(param, "(ii)", &method, &status);
- MOD_MOCK_LOGD("method(%d) status(%d)", method, status);
-
- if (method != LBS_CLIENT_METHOD_MOCK)
- return;
-
- if (status == LBS_STATUS_AVAILABLE) {
- MOD_MOCK_LOGD("LBS_STATUS_AVAILABLE : mock_module");
- mod_mock->status_cb(TRUE, LOCATION_STATUS_3D_FIX, mod_mock->userdata);
- } else {
- MOD_LOGD("LBS_STATUS_ACQUIRING/ERROR/UNAVAILABLE. Status[%d]", status);
- mod_mock->status_cb(FALSE, LOCATION_STATUS_NO_FIX, mod_mock->userdata);
- }
-}
-
-static void position_callback(GVariant *param, void *user_data)
-{
- ModMockData *mod_mock = (ModMockData *)user_data;
- g_return_if_fail(mod_mock);
- g_return_if_fail(mod_mock->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);
-
- MOD_MOCK_LOGD("position_callback [method: %d, field: %d]", method, fields);
- if (method != LBS_CLIENT_METHOD_MOCK) {
- MOD_LOGD("Method is not LBS_CLIENT_METHOD_MOCK: %d", method);
- return;
- }
-
- 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);
-
- mod_mock->pos_cb(TRUE, pos, vel, acc, mod_mock->userdata);
-
- mod_mock->last_pos = location_position_copy(pos);
- mod_mock->last_vel = location_velocity_copy(vel);
- mod_mock->last_acc = location_accuracy_copy(acc);
-
- 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, "PositionChanged"))
- position_callback(param, user_data);
- else if (!g_strcmp0(sig, "StatusChanged"))
- status_callback(param, user_data);
- else
- MOD_MOCK_LOGD("Invaild signal[%s]", sig);
-}
-
-static int start(gpointer handle, LocModStatusCB status_cb, LocModPositionExtCB pos_cb, gpointer userdata)
-{
- MOD_MOCK_LOGD("ENTER >>>");
- ModMockData *mod_mock = (ModMockData *) handle;
- g_return_val_if_fail(mod_mock, 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_mock->status_cb = status_cb;
- mod_mock->pos_cb = pos_cb;
- mod_mock->userdata = userdata;
-
- int ret = LBS_CLIENT_ERROR_NONE;
- if (mod_mock->lbs_client == NULL) {
- ret = lbs_client_create(LBS_CLIENT_METHOD_MOCK , &(mod_mock->lbs_client));
- if (ret != LBS_CLIENT_ERROR_NONE || !mod_mock->lbs_client) {
- MOD_MOCK_LOGE("Fail to create lbs_client_h. Error[%d]", ret);
- return LOCATION_ERROR_NOT_AVAILABLE;
- }
- }
- MOD_MOCK_LOGD("mod_mock(%p) pos_cb(%p) user_data(%p)", mod_mock, mod_mock->pos_cb, mod_mock->userdata);
-
- ret = lbs_client_start(mod_mock->lbs_client, 1, LBS_CLIENT_LOCATION_CB | LBS_CLIENT_LOCATION_STATUS_CB, on_signal_callback, mod_mock);
- if (ret != LBS_CLIENT_ERROR_NONE) {
- if (ret == LBS_CLIENT_ERROR_ACCESS_DENIED) {
- MOD_MOCK_LOGE("Access denied[%d]", ret);
- return LOCATION_ERROR_NOT_ALLOWED;
- }
- MOD_MOCK_LOGE("Fail to start lbs_client_h. Error[%d]", ret);
- lbs_client_destroy(mod_mock->lbs_client);
- mod_mock->lbs_client = NULL;
-
- return LOCATION_ERROR_NOT_AVAILABLE;
- }
- MOD_MOCK_LOGD("EXIT <<<");
-
- return LOCATION_ERROR_NONE;
-}
-
-static int stop(gpointer handle)
-{
- MOD_MOCK_LOGD("stop");
- ModMockData *mod_mock = (ModMockData *) handle;
- g_return_val_if_fail(mod_mock, LOCATION_ERROR_NOT_AVAILABLE);
- g_return_val_if_fail(mod_mock->lbs_client, LOCATION_ERROR_NOT_AVAILABLE);
- g_return_val_if_fail(mod_mock->status_cb, LOCATION_ERROR_NOT_AVAILABLE);
-
- int ret = LBS_CLIENT_ERROR_NONE;
-
- ret = lbs_client_stop(mod_mock->lbs_client);
- if (ret != LBS_CLIENT_ERROR_NONE) {
- MOD_MOCK_LOGE("Fail to stop. Error[%d]", ret);
- lbs_client_destroy(mod_mock->lbs_client);
- mod_mock->lbs_client = NULL;
- return LOCATION_ERROR_NOT_AVAILABLE;
- }
-
- ret = lbs_client_destroy(mod_mock->lbs_client);
- if (ret != LBS_CLIENT_ERROR_NONE) {
- MOD_MOCK_LOGE("Fail to destroy. Error[%d]", ret);
- return LOCATION_ERROR_NOT_AVAILABLE;
- }
- mod_mock->lbs_client = NULL;
-
- if (mod_mock->status_cb)
- mod_mock->status_cb(FALSE, LOCATION_STATUS_NO_FIX, mod_mock->userdata);
-
- mod_mock->status_cb = NULL;
- mod_mock->pos_cb = NULL;
-
- return LOCATION_ERROR_NONE;
-}
-
-static int get_last_position(gpointer handle, LocationPosition **position, LocationVelocity **velocity, LocationAccuracy **accuracy)
-{
- MOD_MOCK_LOGD("get_last_position");
- ModMockData *mod_mock = (ModMockData *) handle;
- g_return_val_if_fail(mod_mock, 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);
-
- *position = NULL;
- *velocity = NULL;
- *accuracy = NULL;
-
- if (mod_mock->last_pos)
- *position = location_position_copy(mod_mock->last_pos);
-
- if (mod_mock->last_vel)
- *velocity = location_velocity_copy(mod_mock->last_vel);
-
- if (mod_mock->last_acc)
- *accuracy = location_accuracy_copy(mod_mock->last_acc);
-
- return LOCATION_ERROR_NONE;
-}
-
-static int set_option(gpointer handle, const char *option)
-{
- ModMockData *mod_mock = (ModMockData *) handle;
- g_return_val_if_fail(mod_mock, LOCATION_ERROR_NOT_AVAILABLE);
- g_return_val_if_fail(option, LOCATION_ERROR_PARAMETER);
- MOD_MOCK_LOGD("set_option : %s", option);
-
- int ret = LBS_CLIENT_ERROR_NONE;
- ret = lbs_set_option(option);
- if (ret != LBS_AGPS_ERROR_NONE) {
- MOD_MOCK_LOGE("Fail to lbs_set_option [%d]", ret);
- return LOCATION_ERROR_NOT_AVAILABLE;
- }
-
- return LOCATION_ERROR_NONE;
-}
-
-#if 0
-static int set_position_update_interval(gpointer handle, guint interval)
-{
- MOD_LOGD("set_position_update_interval [%d]", interval);
- ModMockData *mod_mock = (ModMockData *) handle;
- g_return_val_if_fail(mod_mock, LOCATION_ERROR_NOT_AVAILABLE);
- g_return_val_if_fail(mod_mock->lbs_client, LOCATION_ERROR_NOT_AVAILABLE);
-
- int ret;
- ret = lbs_client_set_position_update_interval(mod_mock->lbs_client, interval);
- 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("Failed lbs_client_set_position_update_interval. Error[%d]", ret);
- return LOCATION_ERROR_NOT_AVAILABLE;
- }
-
- return LOCATION_ERROR_NONE;
-}
-#endif
-
-
-/* Tizen 3.0 Mock Location */
-
-static void on_set_mock_location_callback(const gchar *sig, GVariant *param, gpointer userdata)
-{
- ModMockData *mod_mock = (ModMockData *) userdata;
- g_return_if_fail(param);
- g_return_if_fail(mod_mock);
- g_return_if_fail(mod_mock);
-
- MOD_MOCK_LOGD("ENTER >>>");
-
- int method = 0, status = 0;
- g_variant_get(param, "(ii)", &method, &status);
- MOD_MOCK_LOGD("mock_module: method(%d) status(%d)", method, status);
-
- if (method != LBS_CLIENT_METHOD_MOCK) {
- MOD_MOCK_LOGI("mock_module Invalid(%d)", method);
- return;
- }
-
- if (status == LBS_STATUS_MOCK_FAIL) { /* LBS_STATUS_BATCH + 2 */
- MOD_MOCK_LOGD("LBS_STATUS_MOCK_FAIL");
- mod_mock->mock_status_cb(FALSE, LOCATION_STATUS_MOCK_FAIL, mod_mock->userdata);
- } else {
- MOD_MOCK_LOGD("Others. Status[%d]", status); /* Nothing to do */
- }
- MOD_MOCK_LOGD("EXIT <<<");
-
- return;
-}
-
-static int set_mock_location(gpointer handle, LocationPosition *position, LocationVelocity *velocity,
- LocationAccuracy *accuracy, LocModStatusCB mock_status_cb, gpointer userdata)
-{
- MOD_MOCK_LOGD("ENTER >>> set_mock_location");
- ModMockData *mod_mock = (ModMockData *) handle;
- g_return_val_if_fail(mod_mock, LOCATION_ERROR_NOT_AVAILABLE);
- g_return_val_if_fail(mock_status_cb, LOCATION_ERROR_NOT_AVAILABLE);
-
- int ret = LBS_CLIENT_ERROR_NONE;
-
- if (mod_mock->lbs_client == NULL) {
- ret = lbs_client_create(LBS_CLIENT_METHOD_MOCK, &(mod_mock->lbs_client));
- if (ret != LBS_CLIENT_ERROR_NONE || !mod_mock->lbs_client) {
- MOD_MOCK_LOGE("Fail to create lbs_client_h. Error[%d]", ret);
- return LOCATION_ERROR_NOT_AVAILABLE;
- }
- }
- MOD_MOCK_LOGD("mod_mock(%p)", mod_mock);
-
- mod_mock->mock_status_cb = mock_status_cb;
- mod_mock->userdata = userdata;
-
- ret = lbs_client_set_mock_location_async(mod_mock->lbs_client, LBS_CLIENT_METHOD_MOCK, position->latitude, position->longitude, position->altitude,
- velocity->speed, velocity->direction, accuracy->horizontal_accuracy, on_set_mock_location_callback, mod_mock);
-
- if (ret != LBS_CLIENT_ERROR_NONE) {
- if (ret == LBS_CLIENT_ERROR_ACCESS_DENIED) {
- MOD_MOCK_LOGE("Access denied[%d]", ret);
- return LOCATION_ERROR_NOT_ALLOWED;
- }
- MOD_MOCK_LOGE("Fail to start lbs_client_h. Error[%d]", ret);
- lbs_client_destroy(mod_mock->lbs_client);
- mod_mock->lbs_client = NULL;
-
- return LOCATION_ERROR_NOT_AVAILABLE;
- }
-
- return LOCATION_ERROR_NONE;
-}
-
-static int clear_mock_location(gpointer handle, LocModStatusCB mock_status_cb, gpointer userdata)
-{
- MOD_MOCK_LOGD("ENTER >>>");
- ModMockData *mod_mock = (ModMockData *) handle;
- g_return_val_if_fail(mod_mock, LOCATION_ERROR_NOT_AVAILABLE);
- g_return_val_if_fail(mock_status_cb, LOCATION_ERROR_NOT_AVAILABLE);
-
- int ret = LBS_CLIENT_ERROR_NONE;
-
- if (mod_mock->lbs_client == NULL) {
- ret = lbs_client_create(LBS_CLIENT_METHOD_MOCK, &(mod_mock->lbs_client));
- if (ret != LBS_CLIENT_ERROR_NONE || !mod_mock->lbs_client) {
- MOD_MOCK_LOGE("Fail to create lbs_client_h. Error[%d]", ret);
- return LOCATION_ERROR_NOT_AVAILABLE;
- }
- }
- MOD_MOCK_LOGD("mod_mock(%p)", mod_mock);
-
- mod_mock->mock_status_cb = mock_status_cb;
- mod_mock->userdata = userdata;
-
- ret = lbs_client_set_mock_location_async(mod_mock->lbs_client, LBS_CLIENT_METHOD_MOCK,
- MOCK_LOCATION_CLEAR_VALUE, 0, 0, 0, 0, 0, on_set_mock_location_callback, mod_mock);
-
- if (ret != LBS_CLIENT_ERROR_NONE) {
- if (ret == LBS_CLIENT_ERROR_ACCESS_DENIED) {
- MOD_MOCK_LOGE("Access denied[%d]", ret);
- return LOCATION_ERROR_NOT_ALLOWED;
- }
- MOD_MOCK_LOGE("Fail to start lbs_client_h. Error[%d]", ret);
- lbs_client_destroy(mod_mock->lbs_client);
- mod_mock->lbs_client = NULL;
-
- return LOCATION_ERROR_NOT_AVAILABLE;
- }
-
- return LOCATION_ERROR_NONE;
-}
-
-LOCATION_MODULE_API gpointer init(LocModMockOps *ops)
-{
- MOD_MOCK_LOGD("init");
-
- g_return_val_if_fail(ops, NULL);
- ops->start = start;
- ops->stop = stop;
- ops->get_last_position = get_last_position;
- ops->set_option = set_option;
-
- /*
- ops->start_batch = NULL;
- ops->stop_batch = NULL;
- ops->set_position_update_interval = set_position_update_interval;
- */
-
- /* Tien 3.0 */
- ops->set_mock_location = set_mock_location;
- ops->clear_mock_location = clear_mock_location;
-
- ModMockData *mod_mock = g_new0(ModMockData, 1);
- g_return_val_if_fail(mod_mock, NULL);
-
- return (gpointer) mod_mock;
-}
-
-LOCATION_MODULE_API void shutdown(gpointer handle)
-{
- MOD_MOCK_LOGD("shutdown");
- g_return_if_fail(handle);
- ModMockData *mod_mock = (ModMockData *) handle;
- if (mod_mock->lbs_client) {
- lbs_client_stop(mod_mock->lbs_client);
- lbs_client_destroy(mod_mock->lbs_client);
- mod_mock->lbs_client = NULL;
- }
-
- mod_mock->status_cb = NULL;
- mod_mock->pos_cb = NULL;
-
- if (mod_mock->last_pos) location_position_free(mod_mock->last_pos);
- if (mod_mock->last_vel) location_velocity_free(mod_mock->last_vel);
- if (mod_mock->last_acc) location_accuracy_free(mod_mock->last_acc);
-
- mod_mock->last_pos = NULL;
- mod_mock->last_vel = NULL;
- mod_mock->last_acc = NULL;
-
- g_free(mod_mock);
- mod_mock = NULL;
-}
#include "log.h"
#define MAX_NPS_LOC_ITEM 6
+#define MOCK_LOCATION_CLEAR_VALUE 999
typedef struct {
lbs_client_dbus_h lbs_client;
g_variant_get(param, "(iiidddddd@(idd))", &method, &fields, ×tamp, &latitude, &longitude, &altitude, &speed, &direction, &climb, &accuracy);
MOD_NPS_LOGD("method: %d", method);
- if (method != LBS_CLIENT_METHOD_NPS)
- return;
+ if (method != LBS_CLIENT_METHOD_NPS) {
+ if (method != LBS_CLIENT_METHOD_MOCK)
+ return;
+ }
g_variant_get(accuracy, "(idd)", &level, &horizontal, &vertical);
return LOCATION_ERROR_NONE;
}
+static int set_mock_location(gpointer handle, LocationPosition *position, LocationVelocity *velocity,
+ 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);
+ 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) {
+ MOD_LOGE("Fail to create lbs_client_h. Error[%d]", ret);
+ return LOCATION_ERROR_NOT_AVAILABLE;
+ }
+ }
+ mod_nps->userdata = userdata;
+
+ ret = lbs_client_set_mock_location_async(mod_nps->lbs_client, LBS_CLIENT_METHOD_NPS,
+ position->latitude, position->longitude, position->altitude,
+ velocity->speed, velocity->direction, accuracy->horizontal_accuracy, NULL, mod_nps);
+
+ 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_nps->lbs_client);
+ mod_nps->lbs_client = NULL;
+
+ return LOCATION_ERROR_NOT_AVAILABLE;
+ }
+
+ return LOCATION_ERROR_NONE;
+}
+
+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);
+ 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) {
+ MOD_LOGE("Fail to create lbs_client_h. Error[%d]", ret);
+ return LOCATION_ERROR_NOT_AVAILABLE;
+ }
+ }
+ mod_nps->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);
+
+ 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_nps->lbs_client);
+ mod_nps->lbs_client = NULL;
+
+ return LOCATION_ERROR_NOT_AVAILABLE;
+ }
+
+ return LOCATION_ERROR_NONE;
+}
+
LOCATION_MODULE_API gpointer init(LocModWpsOps *ops)
{
MOD_NPS_LOGD("init");
ops->start = start;
ops->stop = stop;
ops->get_last_position = get_last_position;
+ 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);
+[Version] lbs-server_1.0.7
+[Date] 16 Aug 2016
+[Changes] Mock location.
+[Developer] Kyoungjun Sung <kj7.sung@samsung.com>
+
+================================================================================
[Version] lbs-server_1.0.6
[Date] 3 Aug 2016
[Changes] GPS plugin list updated.
Name: lbs-server
Summary: LBS Server for Tizen
-Version: 1.0.6
+Version: 1.0.7
Release: 1
Group: Location/Service
License: Apache-2.0
%files -n location-lbs-server
%manifest location-lbs-server.manifest
%{_libdir}/location/module/libgps.so*
-%{_libdir}/location/module/libmock.so*
%if 0%{?model_build_feature_location_position_wps}
%{_libdir}/location/module/libwps.so*
projects / platform / core / location / lbs-server.git / commitdiff