CMAKE_MINIMUM_REQUIRED(VERSION 2.0)
-PROJECT(lbs-server C CXX)
+PROJECT(lbs-server C)
SET(SERVER_SRCS_DIR "src")
SET(server_pkgs_LDFLAGS "${server_pkgs_LDFLAGS} -ldl")
INSTALL(DIRECTORY include/ DESTINATION ${INCLUDE_DIR}/lbs-server-plugin FILES_MATCHING PATTERN "*.h")
-INSTALL(TARGETS ${PROJECT_NAME} DESTINATION ${BIN_DIR})
+INSTALL(TARGETS ${PROJECT_NAME} DESTINATION ${BIN_DIR})
\ No newline at end of file
#include <dlog.h>
#define TAG_GPS_MANAGER "LBS_SERVER_GPS"
#define TAG_NPS_MANAGER "LBS_SERVER_NPS"
+#define TAG_MOCK_MANAGER "LBS_SERVER_MOCK"
#define DBG_LOW LOG_DEBUG
#define DBG_INFO LOG_INFO
#define LOG_GPS(dbg_lvl,fmt,args...) SLOG(dbg_lvl, TAG_GPS_MANAGER, fmt, ##args)
#define LOG_NPS(dbg_lvl,fmt,args...) SLOG(dbg_lvl, TAG_NPS_MANAGER, fmt,##args)
+#define LOG_MOCK(dbg_lvl,fmt,args...) SLOG(dbg_lvl, TAG_MOCK_MANAGER, fmt,##args)
+#define LOG_SEC(fmt,args...) SECURE_SLOG(LOG_DEBUG, TAG_MOCK_MANAGER, fmt, ##args)
+
#define FUNC_ENTRANCE_SERVER LOG_GPS(DBG_LOW, "[%s] Entered!!", __func__);
#ifdef __cplusplus
dlclose(*plugin_handle);
return FALSE;
}
- LOG_GPS(DBG_LOW, "Success to load plugin module");
+ LOG_GPS(DBG_LOW, "Success to load plugin module (%s)", plugin_path);
return TRUE;
}
#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
+
typedef struct {
/* gps variables */
pos_data_t position;
gboolean is_needed_changing_interval;
lbs_server_dbus_h lbs_dbus_server;
+
+ /* mock variables */
+ gboolean is_mock_running;
+ gint mock_client_count;
+ gint mock_timer;
+ LbsStatus mock_status;
+
+ NpsManagerPositionExt mock_position;
+ GVariant *mock_accuracy;
+
} lbs_server_s;
typedef struct {
} dynamic_interval_updator_user_data;
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 __setting_gps_cb(keynode_t *key, gpointer user_data)
{
}
-static void nps_set_status(lbs_server_s *lbs_server, LbsStatus status)
+static void nps_set_status(lbs_server_s *lbs_server_nps, LbsStatus status)
{
- if (!lbs_server) {
- LOG_NPS(DBG_ERR, "lbs_server is NULL!!");
+ if (!lbs_server_nps) {
+ LOG_NPS(DBG_ERR, "lbs_server_nps is NULL!!");
return;
}
- LOG_NPS(DBG_LOW, "nps_set_status[%d]", status);
- if (lbs_server->status == status) {
- LOG_NPS(DBG_ERR, "Donot update NPS status");
+ LOG_NPS(DBG_LOW, "Previous status: %d, Current status: %d", lbs_server_nps->status, status);
+ if (lbs_server_nps->status == status) {
+ LOG_NPS(DBG_WARN, "Don't update NPS status");
return;
}
- lbs_server->status = status;
+ lbs_server_nps->status = status;
- if (lbs_server->status == LBS_STATUS_AVAILABLE) {
+ if (lbs_server_nps->status == LBS_STATUS_AVAILABLE) {
setting_set_int(VCONFKEY_LOCATION_WPS_STATE, POSITION_CONNECTED);
- } else if (lbs_server->status == LBS_STATUS_ACQUIRING) {
+ } else if (lbs_server_nps->status == LBS_STATUS_ACQUIRING) {
setting_set_int(VCONFKEY_LOCATION_WPS_STATE, POSITION_SEARCHING);
} else {
setting_set_int(VCONFKEY_LOCATION_WPS_STATE, POSITION_OFF);
}
if (status != LBS_STATUS_AVAILABLE) {
- lbs_server->pos.fields = LBS_POSITION_FIELDS_NONE;
+ lbs_server_nps->pos.fields = LBS_POSITION_FIELDS_NONE;
}
- lbs_server_emit_status_changed(lbs_server->lbs_dbus_server, LBS_SERVER_METHOD_NPS, status);
+ lbs_server_emit_status_changed(lbs_server_nps->lbs_dbus_server, LBS_SERVER_METHOD_NPS, status);
}
static void nps_update_position(lbs_server_s *lbs_server_nps, NpsManagerPositionExt pos)
GVariant *accuracy = NULL;
- LOG_NPS(DBG_LOW, "nps_update_position");
lbs_server_nps->pos.fields = pos.fields;
lbs_server_nps->pos.timestamp = pos.timestamp;
lbs_server_nps->pos.latitude = pos.latitude;
static gboolean nps_report_callback(gpointer user_data)
{
LOG_NPS(DBG_LOW, "ENTER >>>");
- double vertical_accuracy = -1.0; /* vertical accuracy's invalid value is -1 */
- Plugin_LocationInfo location;
- memset(&location, 0x00, sizeof(Plugin_LocationInfo));
- lbs_server_s *lbs_server_nps = (lbs_server_s *) user_data;
- if (NULL == lbs_server_nps) {
- LOG_GPS(DBG_ERR, "lbs_server_s is NULL!!");
+ lbs_server_s *lbs_server_nps = (lbs_server_s *)user_data;
+ if (!lbs_server_nps) {
+ LOG_NPS(DBG_ERR, "lbs_server_nps is NULL!!");
return FALSE;
}
+
+ double vertical_accuracy = -1.0; /* vertical accuracy's invalid value is -1 */
time_t timestamp;
+ Plugin_LocationInfo location;
g_mutex_lock(&lbs_server_nps->mutex);
+ memset(&location, 0x00, sizeof(Plugin_LocationInfo));
memcpy(&location, &lbs_server_nps->location, sizeof(Plugin_LocationInfo));
g_mutex_unlock(&lbs_server_nps->mutex);
LOG_NPS(DBG_LOW, "_nps_token_callback ended");
}
+#if 0 /* Not needed */
static void _network_enabled_cb(keynode_t *key, void *user_data)
{
LOG_GPS(DBG_LOW, "ENTER >>>");
}
*/
}
+#endif
+
static gboolean nps_offline_location(lbs_server_s *lbs_server)
{
LOG_NPS(DBG_LOW, "ENTER >>>");
static void start_tracking(lbs_server_s *lbs_server, lbs_server_method_e method)
{
+ int ret = 0;
+
switch (method) {
case LBS_SERVER_METHOD_GPS:
/* ADD notify */
setting_notify_key_changed(VCONFKEY_LOCATION_ENABLED, __setting_gps_cb, lbs_server);
} else {
- LOG_GPS(DBG_ERR, "Fail to request_start_session");
+ LOG_GPS(DBG_ERR, "Failed to request_start_session");
}
break;
nps_set_status(lbs_server, LBS_STATUS_ACQUIRING);
void *handle_str = NULL;
- int ret = get_nps_plugin_module()->start(lbs_server->period, __nps_callback, lbs_server, &(handle_str));
+ ret = get_nps_plugin_module()->start(lbs_server->period, __nps_callback, lbs_server, &(handle_str));
LOG_NPS(DBG_LOW, "after get_nps_plugin_module()->location");
if (ret) {
g_mutex_lock(&lbs_server->mutex);
lbs_server->is_nps_running = TRUE;
g_mutex_unlock(&lbs_server->mutex);
+ /* calling key_changed API was comment out.
vconf_ignore_key_changed(VCONFKEY_LOCATION_NETWORK_ENABLED, _network_enabled_cb);
+ */
return;
}
nps_offline_location(lbs_server);
}
- LOG_NPS(DBG_ERR, "FAILS WPS START");
+ LOG_NPS(DBG_ERR, "Filed to start NPS");
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;
}
}
g_mutex_unlock(&lbs_server->mutex);
if (lbs_server->is_gps_running == FALSE) {
- LOG_GPS(DBG_LOW, "gps- is already stopped");
+ LOG_GPS(DBG_LOW, "gps is already stopped");
return;
}
lbs_server->sv_used = FALSE;
/* remove notify */
setting_ignore_key_changed(VCONFKEY_LOCATION_ENABLED, __setting_gps_cb);
- g_mutex_unlock(&lbs_server->mutex);
}
+ g_mutex_unlock(&lbs_server->mutex);
}
lbs_server->status = LBS_STATUS_UNAVAILABLE;
g_mutex_unlock(&lbs_server->mutex);
if (lbs_server->is_nps_running == FALSE) {
- LOG_NPS(DBG_LOW, "nps- is already stopped");
+ LOG_NPS(DBG_LOW, "nps is already stopped");
return;
}
nps_stop(lbs_server);
}
+ 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;
}
}
guint *interval_array = (guint *) g_hash_table_lookup(lbs_server->dynamic_interval_table, client_cpy);
if (!interval_array) {
- LOG_GPS(DBG_LOW, "first add key[%s] to interval-table", client);
+ /* LOG_GPS(DBG_LOW, "first add key[%s] to interval-table", client); */
interval_array = (guint *)g_malloc0(LBS_SERVER_METHOD_SIZE * sizeof(guint));
if (!interval_array) {
- LOG_GPS(DBG_ERR, "interval_array is NULL");
+ /* LOG_GPS(DBG_ERR, "interval_array is NULL"); */
g_free(client_cpy);
return FALSE;
}
}
interval_array[method] = interval;
lbs_server->temp_minimum_interval = interval;
- LOG_GPS(DBG_LOW, "ADD done");
+ /* LOG_GPS(DBG_LOW, "ADD done"); */
break;
}
}
}
#ifdef _TIZEN_PUBLIC_
- } else if (!g_strcmp0(g_variant_get_string(value, &length), "SUPLNI")) {
- while (g_variant_iter_next(&iter, "{&sv}", &key, &value)) {
- if (!g_strcmp0(key, "HEADER")) {
- msg_header = g_variant_dup_string(value, &length);
- } else if (!g_strcmp0(key, "BODY")) {
- size = (int) g_variant_get_size(value);
- msg_body = (char *) g_malloc0(sizeof(char) * size);
- memcpy(msg_body, g_variant_get_data(value), size);
- } else if (!g_strcmp0(key, "SIZE")) {
- size = (int) g_variant_get_int32(value);
+ else if (!g_strcmp0(g_variant_get_string(value, &length), "SUPLNI")) {
+ while (g_variant_iter_next(&iter, "{&sv}", &key, &value)) {
+ if (!g_strcmp0(key, "HEADER")) {
+ msg_header = g_variant_dup_string(value, &length);
+ } else if (!g_strcmp0(key, "BODY")) {
+ size = (int) g_variant_get_size(value);
+ msg_body = (char *) g_malloc0(sizeof(char) * size);
+ memcpy(msg_body, g_variant_get_data(value), size);
+ } else if (!g_strcmp0(key, "SIZE")) {
+ size = (int) g_variant_get_int32(value);
+ }
}
+ request_supl_ni_session(msg_header, msg_body, size);
+ if (msg_header) g_free(msg_header);
+ if (msg_body) g_free(msg_body);
}
- request_supl_ni_session(msg_header, msg_body, size);
- if (msg_header) g_free(msg_header);
- if (msg_body) g_free(msg_body);
- }
#endif
- else if (!g_strcmp0(g_variant_get_string(value, &length), "SET:OPT")) {
- LOG_GPS(DBG_LOW, "SET:OPT is called");
- gboolean is_update_interval = FALSE, is_update_interval_method = FALSE;
-
- while (g_variant_iter_next(&iter, "{&sv}", &key, &value)) {
+ else if (!g_strcmp0(g_variant_get_string(value, &length), "SET:OPT")) {
+ LOG_GPS(DBG_LOW, "SET:OPT is called");
+ gboolean is_update_interval = FALSE, is_update_interval_method = FALSE;
- if (!g_strcmp0(key, "OPTION")) {
- option = g_variant_dup_string(value, &length);
- LOG_GPS(DBG_ERR, "option [%s]", option);
+ while (g_variant_iter_next(&iter, "{&sv}", &key, &value)) {
- if (!g_strcmp0(option, "DELGPS")) {
- if (request_delete_gps_data() != TRUE) {
- LOG_GPS(DBG_ERR, "Fail to request_delete_gps_data");
+ if (!g_strcmp0(key, "OPTION")) {
+ option = g_variant_dup_string(value, &length);
+ LOG_GPS(DBG_ERR, "option [%s]", option);
+
+ if (!g_strcmp0(option, "DELGPS")) {
+ if (request_delete_gps_data() != TRUE) {
+ LOG_GPS(DBG_ERR, "Fail to request_delete_gps_data");
+ }
+ } else if (!g_strcmp0(option, "USE_SV")) {
+ g_mutex_lock(&lbs_server->mutex);
+ if (lbs_server->sv_used == FALSE)
+ lbs_server->sv_used = TRUE;
+ g_mutex_unlock(&lbs_server->mutex);
}
- } else if (!g_strcmp0(option, "USE_SV")) {
- g_mutex_lock(&lbs_server->mutex);
- if (lbs_server->sv_used == FALSE)
- lbs_server->sv_used = TRUE;
- g_mutex_unlock(&lbs_server->mutex);
+ g_free(option);
}
- g_free(option);
- }
- if (!g_strcmp0(key, "METHOD")) {
- method = g_variant_get_int32(value);
- LOG_GPS(DBG_LOW, "METHOD [%d]", method);
- is_update_interval_method = TRUE;
- }
+ if (!g_strcmp0(key, "METHOD")) {
+ method = g_variant_get_int32(value);
+ LOG_GPS(DBG_LOW, "METHOD [%d]", method);
+ is_update_interval_method = TRUE;
+ }
- if (!g_strcmp0(key, "INTERVAL_UPDATE")) {
- interval = g_variant_get_uint32(value);
- LOG_GPS(DBG_LOW, "INTERVAL_UPDATE [%u] <-- [%u] ", interval, lbs_server->temp_minimum_interval);
- if (interval != lbs_server->temp_minimum_interval)
- is_update_interval = TRUE;
+ if (!g_strcmp0(key, "INTERVAL_UPDATE")) {
+ interval = g_variant_get_uint32(value);
+ LOG_GPS(DBG_LOW, "INTERVAL_UPDATE [%u] <-- [%u] ", interval, lbs_server->temp_minimum_interval);
+ if (interval != lbs_server->temp_minimum_interval)
+ is_update_interval = TRUE;
+ }
}
- }
- if (is_update_interval && is_update_interval_method && client) {
- update_pos_tracking_interval(LBS_SERVER_INTERVAL_UPDATE, client, method, interval, lbs_server);
- if (lbs_server->is_needed_changing_interval) {
- lbs_server->is_needed_changing_interval = FALSE;
- request_change_pos_update_interval(method, (gpointer)lbs_server);
+ if (is_update_interval && is_update_interval_method && client) {
+ update_pos_tracking_interval(LBS_SERVER_INTERVAL_UPDATE, client, method, interval, lbs_server);
+ if (lbs_server->is_needed_changing_interval) {
+ lbs_server->is_needed_changing_interval = FALSE;
+ request_change_pos_update_interval(method, (gpointer)lbs_server);
+ }
}
}
}
}
-}
static gboolean gps_remove_all_clients(lbs_server_s *lbs_server)
{
static void shutdown(gpointer userdata, gboolean *shutdown_arr)
{
- LOG_GPS(DBG_LOW, "shutdown callback gps:%d nps:%d", shutdown_arr[LBS_SERVER_METHOD_GPS], shutdown_arr[LBS_SERVER_METHOD_NPS]);
+ 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]);
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);
if (enabled == 0) {
LOG_NPS(DBG_ERR, "fail to notify VCONFKEY_LOCATION_NETWORK_ENABLED");
}
}
- */
+#endif
}
static void gps_update_position_cb(pos_data_t *pos, gps_error_t error, void *user_data)
lbs_server->nmea.len = nmea->len;
if (lbs_server->nmea_used == FALSE) {
- /*LOG_GPS(DBG_LOW, "nmea_used is FALSE"); */
return;
}
LOG_GPS(DBG_LOW, "[%d] %s", lbs_server->nmea.timestamp, lbs_server->nmea.data);
lbs_server->dynamic_interval_table = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
lbs_server->optimized_interval_array = (guint *)g_malloc0(LBS_SERVER_METHOD_SIZE * sizeof(guint));
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->mock_timer = 0;
}
static void nps_get_last_position(lbs_server_s *lbs_server_nps)
{
- int timestamp;
+ int timestamp = 0;
char location[128] = {0,};
char *last_location[MAX_NPS_LOC_ITEM] = {0,};
char *last = NULL;
if (++index == MAX_NPS_LOC_ITEM) break;
last_location[index] = (char *)strtok_r(NULL, ";", &last);
}
- LOG_NPS(DBG_LOW, "get nps_last_position timestamp : %d", lbs_server_nps->last_pos.timestamp);
+ LOG_NPS(DBG_LOW, "[%d] %lf, %lf", lbs_server_nps->last_pos.timestamp, lbs_server_nps->last_pos.latitude, lbs_server_nps->last_pos.longitude);
}
static void nps_init(lbs_server_s *lbs_server_nps)
lbs_server = g_new0(lbs_server_s, 1);
if (!lbs_server) {
- LOG_GPS(DBG_ERR, "lbs_server_s create fail");
+ LOG_GPS(DBG_ERR, "Failed to create lbs_server_s create");
return 1;
}
lbs_server_init(lbs_server);
g_log_set_default_handler(_glib_log, lbs_server);
/* create lbs-dbus server */
+ lbs_server_dbus_cb_t *lbs_dbus_callback = g_new0(lbs_server_dbus_cb_t, 1);
+ if (!lbs_dbus_callback) {
+ LOG_GPS(DBG_ERR, "Failed to create lbs_server_dbus_cb");
+ return 1;
+ }
+
+ lbs_dbus_callback->set_options_cb = set_options;
+ lbs_dbus_callback->shutdown_cb = shutdown;
+ lbs_dbus_callback->update_interval_cb = update_pos_tracking_interval;
+ lbs_dbus_callback->request_change_interval_cb = request_change_pos_update_interval;
+ lbs_dbus_callback->get_nmea_cb = get_nmea;
+ lbs_dbus_callback->add_hw_fence_cb = add_fence;
+ lbs_dbus_callback->delete_hw_fence_cb = remove_fence;
+ lbs_dbus_callback->pause_hw_fence_cb = pause_fence;
+ lbs_dbus_callback->resume_hw_fence_cb = resume_fence;
+
+ lbs_dbus_callback->set_mock_location_cb = set_mock_location_cb;
+
ret_code = lbs_server_create(SERVICE_NAME, SERVICE_PATH, "lbs-server", "lbs-server",
- &(lbs_server->lbs_dbus_server), set_options, shutdown, update_pos_tracking_interval,
- request_change_pos_update_interval, get_nmea,
- add_fence, remove_fence, pause_fence, resume_fence, (gpointer)lbs_server);
+ &(lbs_server->lbs_dbus_server), lbs_dbus_callback, (gpointer)lbs_server);
if (ret_code != LBS_SERVER_ERROR_NONE) {
LOG_GPS(DBG_ERR, "lbs_server_create failed");
return 1;
}
-
LOG_GPS(DBG_LOW, "lbs_server_create called");
lbs_server->loop = g_main_loop_new(NULL, TRUE);
g_free(lbs_server->optimized_interval_array);
g_hash_table_destroy(lbs_server->dynamic_interval_table);
+ /* free dbus callback */
+ g_free(lbs_dbus_callback);
+
/* destroy lbs-dbus server */
lbs_server_destroy(lbs_server->lbs_dbus_server);
LOG_GPS(DBG_LOW, "lbs_server_destroy called");
return 0;
}
+
+
+/* Tizen 3.0 */
+
+static void set_mock_location_cb(gint method, gdouble latitude, gdouble longitude, gdouble altitude,
+ gdouble speed, gdouble direction, gdouble accuracy, gpointer userdata)
+{
+ lbs_server_s *lbs_server = (lbs_server_s *)userdata;
+
+ if (!lbs_server) {
+ LOG_MOCK(DBG_ERR, "lbs-server is NULL!!");
+ return;
+ }
+ LOG_SEC("Input 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;
+ }
+
+ time_t timestamp;
+ time(×tamp);
+ g_mock_position.timestamp = timestamp;
+ g_mock_position.latitude = latitude;
+ g_mock_position.longitude = longitude;
+ g_mock_position.altitude = altitude;
+ g_mock_position.speed = speed;
+ g_mock_position.direction = direction;
+ g_mock_position.acc_level = LBS_ACCURACY_LEVEL_DETAILED;
+ 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);
+}
+
+int __copy_mock_location(lbs_server_s *lbs_server)
+{
+ if (!lbs_server) {
+ LOG_MOCK(DBG_ERR, "lbs_server is NULL!!");
+ return FALSE;
+ }
+
+ memset(&lbs_server->mock_position, 0x00, sizeof(NpsManagerPositionExt));
+ memcpy(&lbs_server->mock_position, &g_mock_position, sizeof(NpsManagerPositionExt));
+ LOG_SEC("[%ld] lat = %lf, lng = %lf", lbs_server->mock_position.timestamp, lbs_server->mock_position.latitude, lbs_server->mock_position.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_position.longitude >= -180 && lbs_server->mock_position.longitude <= 180 ) {
+ lbs_server->mock_position.fields |= LBS_POSITION_EXT_FIELDS_LONGITUDE;
+ }
+
+ lbs_server->mock_position.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_position.direction >= 0 && lbs_server->mock_position.direction <= 360) {
+ lbs_server->mock_position.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));
+
+ return TRUE;
+}
+
+static gboolean __mock_position_update_cb(gpointer userdata)
+{
+ lbs_server_s *lbs_server = (lbs_server_s *)userdata;
+
+ if (!lbs_server) {
+ LOG_MOCK(DBG_ERR, "lbs-server is NULL!!");
+ return FALSE;
+ }
+
+ if (lbs_server->mock_status == LBS_STATUS_ACQUIRING) {
+ if (g_mock_position.timestamp) {
+ __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) {
+ time_t timestamp;
+ time(×tamp);
+ LOG_MOCK(DBG_LOW, "previous time: %d", lbs_server->mock_position.timestamp);
+
+ 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);
+ }
+ }
+
+ return TRUE;
+}
+
+static gboolean mock_start_tracking(lbs_server_s *lbs_server)
+{
+
+ LOG_MOCK(DBG_LOW, "ENTER >>>");
+ if (!lbs_server) {
+ LOG_MOCK(DBG_ERR, "lbs_server is NULL!!");
+ return FALSE;
+ }
+
+ __copy_mock_location(lbs_server);
+ mock_set_status(lbs_server, LBS_STATUS_ACQUIRING);
+
+ if (!lbs_server->mock_timer) {
+ lbs_server->mock_timer = g_timeout_add_seconds(1, __mock_position_update_cb, lbs_server);
+ }
+
+ return TRUE;
+}
+
+static int mock_stop_tracking(lbs_server_s *lbs_server)
+{
+ LOG_MOCK(DBG_LOW, "ENTER >>>");
+ if (!lbs_server) {
+ LOG_MOCK(DBG_ERR, "lbs-server is NULL!!");
+ return FALSE;
+ }
+
+ 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->is_mock_running){
+ g_mutex_lock(&lbs_server->mutex);
+ lbs_server->is_mock_running = FALSE;
+ 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.");
+ }
+ }
+}
LBS_SERVER_METHOD_NPS,
LBS_SERVER_METHOD_AGPS,
LBS_SERVER_METHOD_GEOFENCE,
+ LBS_SERVER_METHOD_MOCK,
LBS_SERVER_METHOD_SIZE,
} lbs_server_method_e;
SET(gps_module "gps")
SET(nps_module "wps")
-SET(companion_module "companion")
-
+SET(mock_module "mock")
SET(CLIENT_SRCS_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
SET(module_pkgs_LDFLAGS "${module_pkgs_LDFLAGS} -ldl")
INSTALL(TARGETS ${gps_module} DESTINATION ${LIB_DIR}/location/module)
IF (ENABLE_WPS)
-SET(nps_module "wps")
-ADD_LIBRARY(${nps_module} SHARED ${CLIENT_SRCS_DIR}/nps_module.c)
-TARGET_LINK_LIBRARIES(${nps_module} ${module_pkgs_LDFLAGS})
-SET_TARGET_PROPERTIES(${nps_module} PROPERTIES VERSION ${FULLVER} SOVERSION ${MAJORVER} CLEAN_DIRECT_OUTPUT 1)
-SET_TARGET_PROPERTIES(${nps_module} PROPERTIES COMPILE_FLAGS ${MODULE_EXTRA_CFLAGS})
+ SET(nps_module "wps")
+ ADD_LIBRARY(${nps_module} SHARED ${CLIENT_SRCS_DIR}/nps_module.c)
+ TARGET_LINK_LIBRARIES(${nps_module} ${module_pkgs_LDFLAGS})
+ SET_TARGET_PROPERTIES(${nps_module} PROPERTIES VERSION ${FULLVER} SOVERSION ${MAJORVER} CLEAN_DIRECT_OUTPUT 1)
+ SET_TARGET_PROPERTIES(${nps_module} PROPERTIES COMPILE_FLAGS ${MODULE_EXTRA_CFLAGS})
-INSTALL(TARGETS ${nps_module} DESTINATION ${LIB_DIR}/location/module)
+ 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)
static void position_callback(GVariant *param, void *user_data)
{
- MOD_LOGD("position_callback");
GpsManagerData *gps_manager = (GpsManagerData *)user_data;
g_return_if_fail(gps_manager);
g_return_if_fail(gps_manager->pos_cb);
g_variant_get(param, "(iiidddddd@(idd))", &method, &fields, ×tamp, &latitude, &longitude, &altitude, &speed, &direction, &climb, &accuracy);
+ MOD_LOGD("method: %d", method);
if (method != LBS_CLIENT_METHOD_GPS)
return;
MOD_LOGE("Fail to create lbs_client_h. Error[%d]", ret);
return LOCATION_ERROR_NOT_AVAILABLE;
}
- MOD_LOGD("gps-manger(%x)", gps_manager);
- MOD_LOGD("batch (%x), user_data(%x)", gps_manager->batch_cb, gps_manager->userdata);
+ MOD_LOGD("gps-manger(%p) batch_cb(%p) user_data(%p)", gps_manager, gps_manager->batch_cb, gps_manager->userdata);
ret = lbs_client_start_batch(gps_manager->lbs_client, LBS_CLIENT_BATCH_CB, on_signal_batch_callback, batch_interval, batch_period, gps_manager);
if (ret != LBS_CLIENT_ERROR_NONE) {
MOD_LOGE("Fail to create lbs_client_h. Error[%d]", ret);
return LOCATION_ERROR_NOT_AVAILABLE;
}
- MOD_LOGD("gps-manger(%p)", gps_manager);
- MOD_LOGD("pos_cb (%p), user_data(%p)", gps_manager->pos_cb, gps_manager->userdata);
+ MOD_LOGD("gps-manger(%p) pos_cb (%p) user_data(%p)", gps_manager, gps_manager->pos_cb, gps_manager->userdata);
- ret = lbs_client_start(gps_manager->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, gps_manager);
+ ret = lbs_client_start(gps_manager->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, gps_manager);
if (ret != LBS_CLIENT_ERROR_NONE) {
if (ret == LBS_CLIENT_ERROR_ACCESS_DENIED) {
MOD_LOGE("Access denied[%d]", ret);
#ifndef __MOD_LOG_H__
#define __MOD_LOG_H__
-#define TAG_LOCATION "LOCATION_GPS"
-
#include <dlog.h>
-#define MOD_LOGD(fmt,args...) SLOG(LOG_DEBUG, TAG_LOCATION, fmt, ##args)
-#define MOD_LOGW(fmt,args...) SLOG(LOG_WARN, TAG_LOCATION, fmt, ##args)
-#define MOD_LOGI(fmt,args...) SLOG(LOG_INFO, TAG_LOCATION, fmt, ##args)
-#define MOD_LOGE(fmt,args...) SLOG(LOG_ERROR, TAG_LOCATION, fmt, ##args)
-#define MOD_SECLOG(fmt,args...) SECURE_SLOG(LOG_DEBUG, TAG_LOCATION, fmt, ##args)
-#define TAG_MOD_NPS "LOCATION_NPS"
+#define TAG_LOCATION "LOCATION_GPS"
+#define MOD_LOGD(fmt,args...) LOG(LOG_DEBUG, TAG_LOCATION, fmt, ##args)
+#define MOD_LOGW(fmt,args...) LOG(LOG_WARN, TAG_LOCATION, fmt, ##args)
+#define MOD_LOGI(fmt,args...) LOG(LOG_INFO, TAG_LOCATION, fmt, ##args)
+#define MOD_LOGE(fmt,args...) LOG(LOG_ERROR, TAG_LOCATION, fmt, ##args)
+#define MOD_SECLOG(fmt,args...) SECURE_LOG(LOG_DEBUG, TAG_LOCATION, fmt, ##args)
-#include <dlog.h>
-#define MOD_NPS_LOGD(fmt,args...) SLOG(LOG_DEBUG, TAG_MOD_NPS, fmt, ##args)
-#define MOD_NPS_LOGW(fmt,args...) SLOG(LOG_WARN, TAG_MOD_NPS, fmt, ##args)
-#define MOD_NPS_LOGI(fmt,args...) SLOG(LOG_INFO, TAG_MOD_NPS, fmt, ##args)
-#define MOD_NPS_LOGE(fmt,args...) SLOG(LOG_ERROR, TAG_MOD_NPS, fmt, ##args)
-#define MOD_NPS_SECLOG(fmt,args...) SECURE_SLOG(LOG_DEBUG, TAG_MOD_NPS, fmt, ##args)
+#define TAG_MOD_NPS "LOCATION_NPS"
+#define MOD_NPS_LOGD(fmt,args...) LOG(LOG_DEBUG, TAG_MOD_NPS, fmt, ##args)
+#define MOD_NPS_LOGW(fmt,args...) LOG(LOG_WARN, TAG_MOD_NPS, fmt, ##args)
+#define MOD_NPS_LOGI(fmt,args...) LOG(LOG_INFO, TAG_MOD_NPS, fmt, ##args)
+#define MOD_NPS_LOGE(fmt,args...) LOG(LOG_ERROR, TAG_MOD_NPS, fmt, ##args)
+#define MOD_NPS_SECLOG(fmt,args...) SECURE_LOG(LOG_DEBUG, TAG_MOD_NPS, fmt, ##args)
+#define TAG_MOD_MOCK "LOCATION_MOCK"
+#define MOD_MOCK_LOGD(fmt,args...) LOG(LOG_DEBUG, TAG_MOD_MOCK, fmt, ##args)
+#define MOD_MOCK_LOGW(fmt,args...) LOG(LOG_WARN, TAG_MOD_MOCK, fmt, ##args)
+#define MOD_MOCK_LOGI(fmt,args...) LOG(LOG_INFO, TAG_MOD_MOCK, fmt, ##args)
+#define MOD_MOCK_LOGE(fmt,args...) LOG(LOG_ERROR, TAG_MOD_MOCK, fmt, ##args)
+#define MOD_MOCK_SECLOG(fmt,args...) SECURE_LOG(LOG_DEBUG, TAG_MOD_MOCK, fmt, ##args)
#endif
--- /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 MAX_GPS_LOC_ITEM 7
+#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, //from lbs-server
+ LBS_STATUS_ACQUIRING, // from lbs-server
+ LBS_STATUS_AVAILABLE, // from lbs-server
+ LBS_STATUS_BATCH, //from lbs-server
+ LBS_STATUS_MOCK_SET, //from lbs-dbus status for mock location
+ LBS_STATUS_MOCK_FAIL, // from lbs-dbus status fro mock location
+} 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");
+ 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("method: %d", method);
+ if (method != LBS_CLIENT_METHOD_MOCK)
+ 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, guint pos_update_interval, LocModStatusCB status_cb, LocModPositionExtCB pos_cb, gpointer userdata)
+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("method(%d) status(%d)", method, status);
+
+ if (method != LBS_CLIENT_METHOD_MOCK) {
+ MOD_MOCK_LOGI("Invaild method(%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 >>>");
+ 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;
+ /*
+ mod_mock->batch_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;
+}
static void position_callback(GVariant *param, void *user_data)
{
-
- MOD_NPS_LOGD("position_callback");
ModNpsData *mod_nps = (ModNpsData *)user_data;
g_return_if_fail(mod_nps);
g_return_if_fail(mod_nps->pos_cb);
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;
static void on_signal_callback(const gchar *sig, GVariant *param, gpointer user_data)
{
if (!g_strcmp0(sig, "PositionChanged")) {
- MOD_NPS_LOGD("PositionChanged");
position_callback(param, user_data);
} else if (!g_strcmp0(sig, "StatusChanged")) {
- MOD_NPS_LOGD("StatusChanged");
status_callback(param, user_data);
} else {
MOD_NPS_LOGD("Invaild signal[%s]", sig);
}
-static int start(gpointer handle, LocModStatusCB status_cb, LocModPositionExtCB pos_cb, LocModSatelliteCB sat_cb, gpointer userdata)
+static int start(gpointer handle, LocModStatusCB status_cb, LocModPositionExtCB pos_cb, gpointer userdata)
{
MOD_NPS_LOGD("start");
ModNpsData *mod_nps = (ModNpsData *) handle;
return LOCATION_ERROR_NOT_AVAILABLE;
}
- ret = lbs_client_start(mod_nps->lbs_client, 1, LBS_CLIENT_LOCATION_CB | LBS_CLIENT_LOCATION_STATUS_CB, on_signal_callback, mod_nps);
+ ret = lbs_client_start(mod_nps->lbs_client, 1,
+ LBS_CLIENT_LOCATION_CB | LBS_CLIENT_LOCATION_STATUS_CB, on_signal_callback, mod_nps);
if (ret != LBS_CLIENT_ERROR_NONE) {
if (ret == LBS_CLIENT_ERROR_ACCESS_DENIED) {
MOD_NPS_LOGE("Access denied[%d]", ret);
+[Version] lbs-server_1.0.0
+[Date] 18 January 2016
+[Changes] 1. Supported Mock Location
+ 2. Major version was updated.
+[Developer] Young-Ae Kang <youngae.kang@samsung.com>
+================================================================================
+
[Version] lbs-server_0.6.10
[Date] 12 November 2015
[Problem] lbs-server has smack issue because brcm plugin(libbrcm.so) doesn't write data into /run/systemd/journal/dev-log.
Name: lbs-server
Summary: LBS Server for Tizen
-Version: 0.6.8
+Version: 1.0.0
Release: 1
Group: Location/Service
License: Apache-2.0
BuildRequires: pkgconfig(vconf-internal-keys)
BuildRequires: pkgconfig(gthread-2.0)
BuildRequires: pkgconfig(gmodule-2.0)
-Requires: sys-assert
%description
LBS Server for Tizen
%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