From 4068dbe65e0f9eb26f902bd2bd99ee07fe00df11 Mon Sep 17 00:00:00 2001 From: Young-Ae Kang Date: Fri, 27 Nov 2015 16:02:49 +0900 Subject: [PATCH] [ACR-476] Added mock location APIs (Version 1.0.0) Change-Id: Ie64544ed1f99245cf96940630c69d7e1ac056357 --- lbs-server/CMakeLists.txt | 4 +- lbs-server/src/debug_util.h | 4 + lbs-server/src/gps_plugin_module.c | 2 +- lbs-server/src/lbs_server.c | 488 ++++++++++++++++++++++++----- lbs-server/src/lbs_server.h | 1 + module/CMakeLists.txt | 22 +- module/gps_module.c | 11 +- module/log.h | 32 +- module/mock_module.c | 440 ++++++++++++++++++++++++++ module/nps_module.c | 10 +- packaging/lbs-server.changes | 7 + packaging/lbs-server.spec | 4 +- 12 files changed, 899 insertions(+), 126 deletions(-) mode change 100644 => 100755 lbs-server/src/lbs_server.c create mode 100755 module/mock_module.c diff --git a/lbs-server/CMakeLists.txt b/lbs-server/CMakeLists.txt index 9373e90..5bc91cb 100644 --- a/lbs-server/CMakeLists.txt +++ b/lbs-server/CMakeLists.txt @@ -1,5 +1,5 @@ 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") @@ -38,4 +38,4 @@ SET(CMAKE_EXE_LINKER_FLAGS "-Wl,--as-needed -pie") 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 diff --git a/lbs-server/src/debug_util.h b/lbs-server/src/debug_util.h index fc59c02..a0c0eb0 100644 --- a/lbs-server/src/debug_util.h +++ b/lbs-server/src/debug_util.h @@ -32,6 +32,7 @@ extern "C" { #include #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 @@ -40,6 +41,9 @@ extern "C" { #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 diff --git a/lbs-server/src/gps_plugin_module.c b/lbs-server/src/gps_plugin_module.c index d67a603..471d45a 100644 --- a/lbs-server/src/gps_plugin_module.c +++ b/lbs-server/src/gps_plugin_module.c @@ -77,7 +77,7 @@ int load_plugin_module(char *specific_name, void **plugin_handle) 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; } diff --git a/lbs-server/src/lbs_server.c b/lbs-server/src/lbs_server.c old mode 100644 new mode 100755 index 91e0d43..c621917 --- a/lbs-server/src/lbs_server.c +++ b/lbs-server/src/lbs_server.c @@ -42,6 +42,13 @@ #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; @@ -78,6 +85,16 @@ typedef struct { 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 { @@ -86,6 +103,14 @@ 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) { @@ -147,33 +172,33 @@ static void nps_set_position(lbs_server_s *lbs_server_nps, NpsManagerPositionExt } -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) @@ -185,7 +210,6 @@ static void nps_update_position(lbs_server_s *lbs_server_nps, NpsManagerPosition 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; @@ -209,17 +233,18 @@ static void nps_update_position(lbs_server_s *lbs_server_nps, NpsManagerPosition 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); @@ -316,6 +341,7 @@ static void _nps_token_callback(void *arg, const unsigned char *token, unsigned 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 >>>"); @@ -333,6 +359,8 @@ static void _network_enabled_cb(keynode_t *key, void *user_data) } */ } +#endif + static gboolean nps_offline_location(lbs_server_s *lbs_server) { LOG_NPS(DBG_LOW, "ENTER >>>"); @@ -440,6 +468,8 @@ static void stop_batch_tracking(lbs_server_s *lbs_server) static void start_tracking(lbs_server_s *lbs_server, lbs_server_method_e method) { + int ret = 0; + switch (method) { case LBS_SERVER_METHOD_GPS: @@ -464,7 +494,7 @@ static void start_tracking(lbs_server_s *lbs_server, lbs_server_method_e method) /* 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; @@ -483,7 +513,7 @@ static void start_tracking(lbs_server_s *lbs_server, lbs_server_method_e method) 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) { @@ -491,7 +521,9 @@ static void start_tracking(lbs_server_s *lbs_server, lbs_server_method_e method) 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; } @@ -499,12 +531,38 @@ static void start_tracking(lbs_server_s *lbs_server, lbs_server_method_e method) 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; } } @@ -554,7 +612,7 @@ static void stop_tracking(lbs_server_s *lbs_server, lbs_server_method_e method) 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; } @@ -567,8 +625,8 @@ static void stop_tracking(lbs_server_s *lbs_server, lbs_server_method_e method) 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; @@ -584,7 +642,7 @@ static void stop_tracking(lbs_server_s *lbs_server, lbs_server_method_e method) 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; } @@ -597,9 +655,33 @@ static void stop_tracking(lbs_server_s *lbs_server, lbs_server_method_e method) 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; } } @@ -642,10 +724,10 @@ static gboolean update_pos_tracking_interval(lbs_server_interval_manipulation_ty 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; } @@ -653,7 +735,7 @@ static gboolean update_pos_tracking_interval(lbs_server_interval_manipulation_ty } interval_array[method] = interval; lbs_server->temp_minimum_interval = interval; - LOG_GPS(DBG_LOW, "ADD done"); + /* LOG_GPS(DBG_LOW, "ADD done"); */ break; } @@ -906,70 +988,70 @@ static void set_options(GVariant *options, const gchar *client, gpointer userdat } } #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) { @@ -987,7 +1069,8 @@ 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]) { @@ -1007,7 +1090,15 @@ static void shutdown(gpointer userdata, gboolean *shutdown_arr) } } - /* + 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) { @@ -1019,7 +1110,7 @@ static void shutdown(gpointer userdata, gboolean *shutdown_arr) 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) @@ -1122,7 +1213,6 @@ static void gps_update_nmea_cb(nmea_data_t *nmea, 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); @@ -1187,11 +1277,17 @@ static void lbs_server_init(lbs_server_s *lbs_server) 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; @@ -1235,7 +1331,7 @@ static void nps_get_last_position(lbs_server_s *lbs_server_nps) 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) @@ -1353,7 +1449,7 @@ int main(int argc, char **argv) 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); @@ -1364,15 +1460,30 @@ int main(int argc, char **argv) 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); @@ -1386,6 +1497,9 @@ int main(int argc, char **argv) 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"); @@ -1399,3 +1513,203 @@ int main(int argc, char **argv) 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."); + } + } +} diff --git a/lbs-server/src/lbs_server.h b/lbs-server/src/lbs_server.h index 9c33b19..4676952 100644 --- a/lbs-server/src/lbs_server.h +++ b/lbs-server/src/lbs_server.h @@ -38,6 +38,7 @@ typedef enum { LBS_SERVER_METHOD_NPS, LBS_SERVER_METHOD_AGPS, LBS_SERVER_METHOD_GEOFENCE, + LBS_SERVER_METHOD_MOCK, LBS_SERVER_METHOD_SIZE, } lbs_server_method_e; diff --git a/module/CMakeLists.txt b/module/CMakeLists.txt index 78675b8..423a9b2 100644 --- a/module/CMakeLists.txt +++ b/module/CMakeLists.txt @@ -3,8 +3,7 @@ PROJECT(client C) 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") @@ -18,11 +17,18 @@ SET_TARGET_PROPERTIES(${gps_module} PROPERTIES COMPILE_FLAGS ${MODULE_EXTRA_CFLA 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) diff --git a/module/gps_module.c b/module/gps_module.c index 48a06b7..76160e1 100644 --- a/module/gps_module.c +++ b/module/gps_module.c @@ -148,7 +148,6 @@ static void satellite_callback(GVariant *param, void *user_data) 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); @@ -159,6 +158,7 @@ static void position_callback(GVariant *param, void *user_data) 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; @@ -235,8 +235,7 @@ static int start_batch(gpointer handle, LocModBatchExtCB batch_cb, guint batch_i 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) { @@ -273,10 +272,10 @@ static int start(gpointer handle, guint pos_update_interval, LocModStatusCB stat 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); diff --git a/module/log.h b/module/log.h index c3c3df0..7c084c2 100644 --- a/module/log.h +++ b/module/log.h @@ -22,23 +22,27 @@ #ifndef __MOD_LOG_H__ #define __MOD_LOG_H__ -#define TAG_LOCATION "LOCATION_GPS" - #include -#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 -#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 diff --git a/module/mock_module.c b/module/mock_module.c new file mode 100755 index 0000000..ae3f740 --- /dev/null +++ b/module/mock_module.c @@ -0,0 +1,440 @@ +/* + * lbs-server + * + * Copyright (c) 2011-2013 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Youngae Kang , Minjune Kim + * Genie Kim + * + * 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 +#include +#include +#include + +#include +#include +#include + +#include +#include +#include + +#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; +} diff --git a/module/nps_module.c b/module/nps_module.c index 4f27f6b..efc5888 100644 --- a/module/nps_module.c +++ b/module/nps_module.c @@ -72,8 +72,6 @@ static void status_callback(GVariant *param, void *user_data) 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); @@ -84,6 +82,7 @@ static void position_callback(GVariant *param, void *user_data) 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; @@ -114,10 +113,8 @@ static void position_callback(GVariant *param, void *user_data) 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); @@ -125,7 +122,7 @@ static void on_signal_callback(const gchar *sig, GVariant *param, gpointer user_ } -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; @@ -144,7 +141,8 @@ static int start(gpointer handle, LocModStatusCB status_cb, LocModPositionExtCB 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); diff --git a/packaging/lbs-server.changes b/packaging/lbs-server.changes index 44539c7..415263b 100644 --- a/packaging/lbs-server.changes +++ b/packaging/lbs-server.changes @@ -1,3 +1,10 @@ +[Version] lbs-server_1.0.0 +[Date] 18 January 2016 +[Changes] 1. Supported Mock Location + 2. Major version was updated. +[Developer] Young-Ae Kang +================================================================================ + [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. diff --git a/packaging/lbs-server.spec b/packaging/lbs-server.spec index a3c44aa..89b19c8 100644 --- a/packaging/lbs-server.spec +++ b/packaging/lbs-server.spec @@ -1,6 +1,6 @@ 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 @@ -23,7 +23,6 @@ BuildRequires: pkgconfig(gio-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 @@ -128,6 +127,7 @@ rm -rf %{buildroot} %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* -- 2.34.1