From: Young-Ae Kang Date: Wed, 10 Jun 2015 11:39:17 +0000 (+0900) Subject: 1. Code sync with tizen_2.4. X-Git-Tag: accepted/tizen/wearable/20150611.122037 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=refs%2Ftags%2Faccepted%2Ftizen%2Fwearable%2F20150611.122037;p=platform%2Fcore%2Flocation%2Flbs-dbus.git 1. Code sync with tizen_2.4. 2. To support 64bit arch Change-Id: I2072cafdfcb571d3dbc7b121ca6d93acbe7953f1 Signed-off-by: Young-Ae Kang --- diff --git a/AUTHORS b/AUTHORS index 6fe4f19..7e87d48 100644 --- a/AUTHORS +++ b/AUTHORS @@ -1,4 +1,2 @@ Youngae Kang -Minjune Kim -Genie Kim -Ming Zhu +KyoungJun Sung diff --git a/CMakeLists.txt b/CMakeLists.txt old mode 100644 new mode 100755 index eae5fda..5284253 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -3,21 +3,22 @@ PROJECT(lbs-dbus C) SET(PREFIX ${CMAKE_INSTALL_PREFIX}) SET(EXEC_PREFIX "\${prefix}") -SET(LIBDIR "\${prefix}/lib") -SET(INCLUDEDIR "\${prefix}/include") +#SET(LIBDIR "\${prefix}/lib") +#SET(INCLUDEDIR "\${prefix}/include") # Set required packages INCLUDE(FindPkgConfig) -pkg_check_modules(pkgs REQUIRED glib-2.0 gio-2.0 gthread-2.0 dlog gobject-2.0 gio-unix-2.0) +pkg_check_modules(pkgs REQUIRED glib-2.0 gio-2.0 gthread-2.0 dlog gobject-2.0 gio-unix-2.0 capi-appfw-app-manager capi-appfw-package-manager pkgmgr-info) FOREACH(flag ${pkgs_CFLAGS}) SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}") ENDFOREACH(flag) -SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} -Wl,-zdefs -fvisibility=hidden ") +SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} -Wl,-zdefs -fvisibility=hidden ") +SET(CMAKE_EXE_LINKER_FLAGS "-Wl,--as-needed") SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS}") -SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wextra -fvisibility=hidden -fPIC") +SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror -Wextra -fvisibility=hidden -fPIC") SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-unused-parameter -Wno-missing-field-initializers -Wmissing-declarations -Wcast-align") ADD_DEFINITIONS("-DFEATURE_DLOG_DEBUG") @@ -31,7 +32,8 @@ MESSAGE(${CMAKE_EXE_LINKER_FLAGS}) SET(PREFIX ${CMAKE_INSTALL_PREFIX}) CONFIGURE_FILE(lbs-dbus.pc.in lbs-dbus.pc @ONLY) -INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lbs-dbus.pc DESTINATION ${LIB_INSTALL_DIR}/pkgconfig) +INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/lbs-dbus.pc DESTINATION ${LIBDIR}/pkgconfig) ADD_SUBDIRECTORY(client) ADD_SUBDIRECTORY(server) +ADD_SUBDIRECTORY(agps) diff --git a/agps/CMakeLists.txt b/agps/CMakeLists.txt new file mode 100644 index 0000000..54e7958 --- /dev/null +++ b/agps/CMakeLists.txt @@ -0,0 +1,16 @@ +CMAKE_MINIMUM_REQUIRED(VERSION 2.6) +PROJECT(lbs-agps C) + +INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/include) + +### Build ### +SET(SRCS + src/lbs_agps.c +) + +ADD_LIBRARY(lbs-agps SHARED ${SRCS}) +TARGET_LINK_LIBRARIES(lbs-agps ${pkgs_LDFLAGS}) +SET_TARGET_PROPERTIES(lbs-agps PROPERTIES VERSION 0.1.0 SOVERSION 0 OUTPUT_NAME lbs-agps) + +INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/include/lbs_agps.h DESTINATION ${INCLUDEDIR}/lbs-dbus) +INSTALL(TARGETS lbs-agps DESTINATION ${LIBDIR} COMPONENT Runtime) diff --git a/agps/include/lbs_agps.h b/agps/include/lbs_agps.h new file mode 100644 index 0000000..8663c76 --- /dev/null +++ b/agps/include/lbs_agps.h @@ -0,0 +1,48 @@ +/* + * lbs-dbus + * + * Copyright (c) 2013 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Youngae Kang , Minjune Kim + * Genie Kim , Ming Zhu + * + * 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. + */ + +#ifndef __LBS_AGPS_H__ +#define __LBS_AGPS_H__ + +__BEGIN_DECLS + +#include + +typedef enum { + LBS_AGPS_ERROR_NONE = 0x0, + LBS_AGPS_ERROR_UNKNOWN, + LBS_AGPS_ERROR_PARAMETER, + LBS_AGPS_ERROR_MEMORY, + LBS_AGPS_ERROR_CONNECTION, + LBS_AGPS_ERROR_STATUS, + LBS_AGPS_ERROR_DBUS_CALL, + LBS_AGPS_ERROR_NO_RESULT, +} lbs_agps_error_e; + +int lbs_agps_sms(const char *msg_body, int msg_size); +int lbs_agps_wap_push(const char *push_header, const char *push_body, int push_body_size); +int lbs_set_option(const char *option); + +__END_DECLS + +#endif /* __LBS_AGPS_H__ */ + + diff --git a/agps/include/lbs_agps_priv.h b/agps/include/lbs_agps_priv.h new file mode 100644 index 0000000..74ae855 --- /dev/null +++ b/agps/include/lbs_agps_priv.h @@ -0,0 +1,51 @@ +/* + * lbs-dbus + * + * Copyright (c) 2013 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Youngae Kang , Minjune Kim + * Genie Kim , Ming Zhu + * + * 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. + */ + +#ifndef __LBS_AGPS_PRIV_H__ +#define __LBS_AGPS_PRIV_H__ + +__BEGIN_DECLS + +#ifdef FEATURE_DLOG_DEBUG +#include + +#ifdef LOG_TAG +#undef LOG_TAG +#define LOG_TAG "LBS_AGPS" +#endif + +#define LBS_AGPS_LOGI(fmt,args...) { LOGI(fmt, ##args); } +#define LBS_AGPS_LOGD(fmt,args...) { LOGD(fmt, ##args); } +#define LBS_AGPS_LOGW(fmt,args...) { LOGW(fmt, ##args); } +#define LBS_AGPS_LOGE(fmt,args...) { LOGE(fmt, ##args); } + +#else + +#define LBS_AGPS_LOGI(fmt,args...) +#define LBS_AGPS_LOGD(fmt,args...) +#define LBS_AGPS_LOGW(fmt,args...) +#define LBS_AGPS_LOGE(fmt,args...) + +#endif + +__END_DECLS + +#endif diff --git a/agps/src/lbs_agps.c b/agps/src/lbs_agps.c new file mode 100644 index 0000000..15cef4b --- /dev/null +++ b/agps/src/lbs_agps.c @@ -0,0 +1,384 @@ +/* + * lbs-dbus + * + * Copyright (c) 2013 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Youngae Kang , Minjune Kim + * Genie Kim , Ming Zhu + * + * 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 "lbs_agps.h" +#include "lbs_agps_priv.h" + +#define SERVICE_NAME "org.tizen.lbs.Providers.LbsServer" +#define SERVICE_PATH "/org/tizen/lbs/Providers/LbsServer" +#define LBS_SERVER_METHOD_AGPS 2 + +typedef struct _lbs_agps_s { + gchar *addr; + GDBusConnection *conn; +} lbs_agps_s; + +typedef void *lbs_agps_h; + +static int +_create_connection(lbs_agps_s *agps) +{ + LBS_AGPS_LOGD("create connection"); + g_return_val_if_fail(agps, LBS_AGPS_ERROR_PARAMETER); + GError *error = NULL; + + agps->addr = g_dbus_address_get_for_bus_sync(G_BUS_TYPE_SYSTEM, NULL, &error); + if (!agps->addr) { + LBS_AGPS_LOGD("Fail to get addr of bus."); + return LBS_AGPS_ERROR_CONNECTION; + } + + agps->conn = g_dbus_connection_new_for_address_sync(agps->addr, + G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT | + G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION, + NULL, NULL, &error); + if (!agps->conn) { + LBS_AGPS_LOGD("Fail to get addr of bus."); + g_free(agps->addr); + return LBS_AGPS_ERROR_CONNECTION; + } + + return LBS_AGPS_ERROR_NONE; +} + + +static int +lbs_agps_create(lbs_agps_h *lbs_agps) +{ + LBS_AGPS_LOGD("lbs_agps_create"); + + int ret = LBS_AGPS_ERROR_NONE; + + lbs_agps_s *agps = g_new0(lbs_agps_s, 1); + g_return_val_if_fail(agps, LBS_AGPS_ERROR_MEMORY); + + ret = _create_connection(agps); + if (ret != LBS_AGPS_ERROR_NONE) { + g_free(agps); + return ret; + } + + *lbs_agps = (lbs_agps_h *) agps; + + return LBS_AGPS_ERROR_NONE; +} + +static int +lbs_agps_destroy(lbs_agps_h lbs_agps) +{ + LBS_AGPS_LOGD("lbs_agps_destroy"); + g_return_val_if_fail(lbs_agps, LBS_AGPS_ERROR_PARAMETER); + + lbs_agps_s *handle = (lbs_agps_s *) lbs_agps; + + int ret = LBS_AGPS_ERROR_NONE; + GError *error = NULL; + + if (handle->conn) { + ret = g_dbus_connection_close_sync(handle->conn, NULL, &error); + if (ret != TRUE) { + LBS_AGPS_LOGD("Fail to disconnection Dbus"); + } + g_object_unref(handle->conn); + handle->conn = NULL; + } + + if (handle->addr) g_free(handle->addr); + g_free(handle); + + return LBS_AGPS_ERROR_NONE; +} + +EXPORT_API int +lbs_agps_sms(const char *msg_body, int msg_size) +{ + LBS_AGPS_LOGD("lbs_agps_sms"); + int ret = LBS_AGPS_ERROR_NONE; + lbs_agps_h lbs_agps = NULL; + GVariant *reg = NULL; + GVariant *param = NULL; + GVariant *method = NULL; + GError *error = NULL; + GVariantBuilder *builder = NULL; + GDBusProxy *proxy = NULL; + gchar *signal_path = NULL; + + ret = lbs_agps_create(&lbs_agps); + if (ret != LBS_AGPS_ERROR_NONE || !lbs_agps) { + LBS_AGPS_LOGE("Cannot get agps handle Error[%d]", ret); + return ret; + } + lbs_agps_s *handle = (lbs_agps_s *) lbs_agps; + + signal_path = g_strdup_printf("%s/%s", SERVICE_PATH, "SAMSUNG"); + LBS_AGPS_LOGD("LBS signal subscribe Object Path [%s]", signal_path); + g_free(signal_path); + + LBS_AGPS_LOGD("AGPS NI SMS START : SUPLNI"); + builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}")); + g_variant_builder_add(builder, "{sv}", "CMD", g_variant_new_string("SUPLNI")); + g_variant_builder_add(builder, "{sv}", "BODY", g_variant_new_from_data(G_VARIANT_TYPE_BYTESTRING, (gconstpointer) msg_body , (gsize) msg_size, TRUE, NULL, NULL)); + g_variant_builder_add(builder, "{sv}", "SIZE", g_variant_new_int32((gint32) msg_size)); + param = g_variant_ref_sink(g_variant_new("(@a{sv})", g_variant_builder_end(builder))); + + method = g_variant_ref_sink(g_variant_new("(i)", LBS_SERVER_METHOD_AGPS)); + + proxy = g_dbus_proxy_new_sync(handle->conn, /* GDBusConnection */ + G_DBUS_PROXY_FLAGS_NONE, /*GDbusProxyFlags */ + NULL, + SERVICE_NAME, SERVICE_PATH, + "org.tizen.lbs.Manager", + NULL, + &error); + if (proxy) { + reg = g_dbus_proxy_call_sync(proxy, + "AddReference", + method, + G_DBUS_CALL_FLAGS_NONE, + -1, + NULL, + &error); + if (reg) { + g_variant_unref(reg); + reg = NULL; + } + + reg = g_dbus_proxy_call_sync(proxy, + "SetOptions", + param, + G_DBUS_CALL_FLAGS_NO_AUTO_START, + -1, + NULL, + &error); + if (reg) { + g_variant_unref(reg); + reg = NULL; + } + + reg = g_dbus_proxy_call_sync(proxy, + "RemoveReference", + method, + G_DBUS_CALL_FLAGS_NO_AUTO_START, + -1, + NULL, + &error); + if (reg) { + g_variant_unref(reg); + reg = NULL; + } + + g_object_unref(proxy); + } + + /* g_variant_builder_unref(builder); */ + g_variant_unref(method); + g_variant_unref(param); + + lbs_agps_destroy(lbs_agps); + + return LBS_AGPS_ERROR_NONE; +} + +EXPORT_API int +lbs_agps_wap_push(const char *push_header, const char *push_body, int push_body_size) +{ + LBS_AGPS_LOGD("lbs_agps_wap_push"); + int ret = LBS_AGPS_ERROR_NONE; + lbs_agps_h lbs_agps = NULL; + GVariant *reg = NULL; + GVariant *param = NULL; + GVariant *method = NULL; + GError *error = NULL; + GVariantBuilder *builder = NULL; + GDBusProxy *proxy = NULL; + gchar *signal_path = NULL; + + ret = lbs_agps_create(&lbs_agps); + if (ret != LBS_AGPS_ERROR_NONE || !lbs_agps) { + LBS_AGPS_LOGE("Cannot get agps handle Error[%d]", ret); + return ret; + } + lbs_agps_s *handle = (lbs_agps_s *) lbs_agps; + + signal_path = g_strdup_printf("%s/%s", SERVICE_PATH, "SAMSUNG"); + LBS_AGPS_LOGD("LBS signal subscribe Object Path [%s]", signal_path); + g_free(signal_path); + + LBS_AGPS_LOGD("AGPS NI WAP PUSH START : SUPLNI"); + builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}")); + g_variant_builder_add(builder, "{sv}", "CMD", g_variant_new_string("SUPLNI")); + g_variant_builder_add(builder, "{sv}", "HEADER", g_variant_new_string(push_header)); + g_variant_builder_add(builder, "{sv}", "BODY", g_variant_new_from_data(G_VARIANT_TYPE_BYTESTRING, (gconstpointer) push_body , (gsize) push_body_size, TRUE, NULL, NULL)); + g_variant_builder_add(builder, "{sv}", "SIZE", g_variant_new_int32((gint32) push_body_size)); + param = g_variant_ref_sink(g_variant_new("(@a{sv})", g_variant_builder_end(builder))); + + method = g_variant_ref_sink(g_variant_new("(i)", LBS_SERVER_METHOD_AGPS)); + + + proxy = g_dbus_proxy_new_sync(handle->conn, /* GDBusConnection */ + G_DBUS_PROXY_FLAGS_NONE, /*GDbusProxyFlags */ + NULL, + SERVICE_NAME, SERVICE_PATH, + "org.tizen.lbs.Manager", + NULL, + &error); + + if (proxy) { + reg = g_dbus_proxy_call_sync(proxy, + "AddReference", + method, + G_DBUS_CALL_FLAGS_NONE, + -1, + NULL, + &error); + + if (reg) { + g_variant_unref(reg); + reg = NULL; + } + + reg = g_dbus_proxy_call_sync(proxy, + "SetOptions", + param, + G_DBUS_CALL_FLAGS_NO_AUTO_START, + -1, + NULL, + &error); + if (reg) { + g_variant_unref(reg); + reg = NULL; + } + + reg = g_dbus_proxy_call_sync(proxy, + "RemoveReference", + method, + G_DBUS_CALL_FLAGS_NO_AUTO_START, + -1, + NULL, + &error); + if (reg) { + g_variant_unref(reg); + reg = NULL; + } + + g_object_unref(proxy); + } + /* g_variant_builder_unref(builder); */ + g_variant_unref(param); + g_variant_unref(method); + + lbs_agps_destroy(lbs_agps); + + return LBS_AGPS_ERROR_NONE; +} + +EXPORT_API int +lbs_set_option(const char *option) +{ + LBS_AGPS_LOGD("lbs_set_option"); + int ret = LBS_AGPS_ERROR_NONE; + lbs_agps_h lbs_agps = NULL; + GVariant *reg = NULL; + GVariant *param = NULL; + GVariant *method = NULL; + GError *error = NULL; + GVariantBuilder *builder = NULL; + GDBusProxy *proxy = NULL; + gchar *signal_path = NULL; + + + ret = lbs_agps_create(&lbs_agps); + if (ret != LBS_AGPS_ERROR_NONE || !lbs_agps) { + LBS_AGPS_LOGE("Cannot get agps handle Error[%d]", ret); + return ret; + } + lbs_agps_s *handle = (lbs_agps_s *) lbs_agps; + + signal_path = g_strdup_printf("%s/%s", SERVICE_PATH, "SAMSUNG"); + LBS_AGPS_LOGD("LBS signal subscribe Object Path [%s]", signal_path); + g_free(signal_path); + + LBS_AGPS_LOGD("SET option START : %s", option); + builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}")); + g_variant_builder_add(builder, "{sv}", "CMD", g_variant_new_string("SET:OPT")); + g_variant_builder_add(builder, "{sv}", "OPTION", g_variant_new_string(option)); + param = g_variant_ref_sink(g_variant_new("(@a{sv})", g_variant_builder_end(builder))); + + method = g_variant_ref_sink(g_variant_new("(i)", LBS_SERVER_METHOD_AGPS)); + + + proxy = g_dbus_proxy_new_sync(handle->conn, /* GDBusConnection */ + G_DBUS_PROXY_FLAGS_NONE, /*GDbusProxyFlags */ + NULL, SERVICE_NAME, SERVICE_PATH, + "org.tizen.lbs.Manager", + NULL, + &error); + if (proxy) { + reg = g_dbus_proxy_call_sync(proxy, + "AddReference", + method, + G_DBUS_CALL_FLAGS_NONE, + -1, + NULL, + &error); + if (reg) { + g_variant_unref(reg); + reg = NULL; + } + + reg = g_dbus_proxy_call_sync(proxy, + "SetOptions", + param, + G_DBUS_CALL_FLAGS_NO_AUTO_START, + -1, + NULL, + &error); + if (reg) { + g_variant_unref(reg); + reg = NULL; + } + + reg = g_dbus_proxy_call_sync(proxy, + "RemoveReference", + method, + G_DBUS_CALL_FLAGS_NO_AUTO_START, + -1, + NULL, + &error); + if (reg) { + g_variant_unref(reg); + reg = NULL; + } + + g_object_unref(proxy); + } + /* g_variant_builder_unref(builder); */ + g_variant_unref(param); + g_variant_unref(method); + + lbs_agps_destroy(lbs_agps); + + return LBS_AGPS_ERROR_NONE; +} diff --git a/client/CMakeLists.txt b/client/CMakeLists.txt index 91e5634..61e0b24 100644 --- a/client/CMakeLists.txt +++ b/client/CMakeLists.txt @@ -1,17 +1,27 @@ CMAKE_MINIMUM_REQUIRED(VERSION 2.6) PROJECT(lbs-dbus-client C) -INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/include) +INCLUDE_DIRECTORIES( + ${CMAKE_CURRENT_SOURCE_DIR}/include + ${CMAKE_CURRENT_SOURCE_DIR} + ${CMAKE_CURRENT_SOURCE_DIR}/cmake_tmp + ${CMAKE_BINARY_DIR} + ) ### Build ### SET(SRCS src/lbs_dbus_client.c + ${CMAKE_CURRENT_SOURCE_DIR}/generated-code.c ) ADD_LIBRARY(lbs-dbus SHARED ${SRCS}) TARGET_LINK_LIBRARIES(lbs-dbus ${pkgs_LDFLAGS}) SET_TARGET_PROPERTIES(lbs-dbus PROPERTIES VERSION 0.1.0 SOVERSION 0 OUTPUT_NAME lbs-dbus) -INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/include/lbs_dbus_client.h DESTINATION include/lbs-dbus) -INSTALL(TARGETS lbs-dbus DESTINATION ${LIB_INSTALL_DIR} COMPONENT Runtime) -#ADD_SUBDIRECTORY(test_src) +INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/include/lbs_dbus_client.h DESTINATION ${INCLUDEDIR}/lbs-dbus) +INSTALL(TARGETS lbs-dbus DESTINATION ${LIBDIR} COMPONENT Runtime) + +ADD_CUSTOM_COMMAND( + OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/generated-code.c + COMMAND gdbus-codegen --interface-prefix org.tizen.lbs. --generate-c-code generated-code --c-generate-object-manager --c-namespace Lbs --generate-docbook generated-docs ${CMAKE_SOURCE_DIR}/introspection/lbs.xml ${CMAKE_SOURCE_DIR}/introspection/lbs_position.xml ${CMAKE_SOURCE_DIR}/introspection/lbs_batch.xml ${CMAKE_SOURCE_DIR}/introspection/lbs_satellite.xml ${CMAKE_SOURCE_DIR}/introspection/lbs_nmea.xml ${CMAKE_SOURCE_DIR}/introspection/lbs_gps_geofence.xml + COMMENT "Generating GDBus .c/.h") diff --git a/client/include/lbs_dbus_client.h b/client/include/lbs_dbus_client.h index 29de5d1..fe4e45c 100644 --- a/client/include/lbs_dbus_client.h +++ b/client/include/lbs_dbus_client.h @@ -4,7 +4,7 @@ * Copyright (c) 2013 Samsung Electronics Co., Ltd. All rights reserved. * * Contact: Youngae Kang , Minjune Kim - * Genie Kim , Ming Zhu + * Genie Kim , Ming Zhu * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -26,33 +26,50 @@ __BEGIN_DECLS #include +#define SERVICE_NAME "org.tizen.lbs.Providers.LbsServer" +#define SERVICE_PATH "/org/tizen/lbs/Providers/LbsServer" + +typedef enum { + LBS_CLIENT_METHOD_GPS = 0, + LBS_CLIENT_METHOD_NPS, + LBS_CLIENT_METHOD_AGPS, + LBS_CLIENT_METHOD_GEOFENCE, +} lbs_client_method_e; + typedef enum { - LBS_CLIENT_LOCATION_CB = 0x01, - LBS_CLIENT_LOCATION_STATUS_CB = LBS_CLIENT_LOCATION_CB << 0x01, - LBS_CLIENT_SATELLITE_CB = LBS_CLIENT_LOCATION_CB << 0x02, - LBS_CLIENT_NMEA_CB = LBS_CLIENT_LOCATION_CB << 0x03, + LBS_CLIENT_LOCATION_CB = 0x01, + LBS_CLIENT_LOCATION_STATUS_CB = LBS_CLIENT_LOCATION_CB << 0x01, + LBS_CLIENT_SATELLITE_CB = LBS_CLIENT_LOCATION_CB << 0x02, + LBS_CLIENT_NMEA_CB = LBS_CLIENT_LOCATION_CB << 0x03, + LBS_CLIENT_BATCH_CB = LBS_CLIENT_LOCATION_CB << 0x04, } lbs_client_callback_e; typedef enum { - LBS_CLIENT_ERROR_NONE = 0x0, - LBS_CLIENT_ERROR_UNKNOWN, - LBS_CLIENT_ERROR_PARAMETER, - LBS_CLIENT_ERROR_MEMORY, - LBS_CLIENT_ERROR_CONNECTION, - LBS_CLIENT_ERROR_STATUS, - LBS_CLIENT_ERROR_DBUS_CALL, - LBS_CLIENT_ERROR_NO_RESULT, + LBS_CLIENT_ERROR_NONE = 0x0, + LBS_CLIENT_ERROR_UNKNOWN, + LBS_CLIENT_ERROR_PARAMETER, + LBS_CLIENT_ERROR_MEMORY, + LBS_CLIENT_ERROR_CONNECTION, + LBS_CLIENT_ERROR_STATUS, + LBS_CLIENT_ERROR_DBUS_CALL, + LBS_CLIENT_ERROR_NO_RESULT, + LBS_CLIENT_ERROR_ACCESS_DENIED, } lbs_client_error_e; typedef void *lbs_client_dbus_h; -int lbs_client_create(char *service_name, char *service_path, lbs_client_dbus_h *lbs_client); +typedef void (*lbs_client_cb)(const char *sig, GVariant *param, void *user_data); + +int lbs_client_create(lbs_client_method_e method, lbs_client_dbus_h *lbs_client); int lbs_client_destroy(lbs_client_dbus_h lbs_client); -int lbs_client_start(lbs_client_dbus_h lbs_client, lbs_client_callback_e callback_type, GDBusSignalCallback callback, void *user_data); +int lbs_client_start(lbs_client_dbus_h lbs_client, unsigned int interval, lbs_client_callback_e callback_type, lbs_client_cb callback, void *user_data); int lbs_client_stop(lbs_client_dbus_h lbs_client); +int lbs_client_start_batch(lbs_client_dbus_h lbs_client, lbs_client_callback_e callback_type, lbs_client_cb callback, unsigned int batch_interval, unsigned int batch_period, void *user_data); +int lbs_client_stop_batch(lbs_client_dbus_h lbs_client); int lbs_client_get_nmea(lbs_client_dbus_h lbs_client, int *timestamp, char **nmea); +int lbs_client_set_position_update_interval(lbs_client_dbus_h lbs_client, unsigned int interval); __END_DECLS diff --git a/client/include/lbs_dbus_client_priv.h b/client/include/lbs_dbus_client_priv.h index 945b14b..3258128 100644 --- a/client/include/lbs_dbus_client_priv.h +++ b/client/include/lbs_dbus_client_priv.h @@ -4,7 +4,7 @@ * Copyright (c) 2013 Samsung Electronics Co., Ltd. All rights reserved. * * Contact: Youngae Kang , Minjune Kim - * Genies 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. @@ -32,10 +32,11 @@ __BEGIN_DECLS #define LOG_TAG "LBS_DBUS_CLIENT" #endif -#define LBS_CLIENT_LOGI(fmt,args...) { LOGI(fmt, ##args); } -#define LBS_CLIENT_LOGD(fmt,args...) { LOGD(fmt, ##args); } -#define LBS_CLIENT_LOGW(fmt,args...) { LOGW(fmt, ##args); } -#define LBS_CLIENT_LOGE(fmt,args...) { LOGE(fmt, ##args); } +#define LBS_CLIENT_LOGI(fmt,args...) { LOGI(fmt, ##args); } +#define LBS_CLIENT_LOGD(fmt,args...) { LOGD(fmt, ##args); } +#define LBS_CLIENT_LOGW(fmt,args...) { LOGW(fmt, ##args); } +#define LBS_CLIENT_LOGE(fmt,args...) { LOGE(fmt, ##args); } +#define LBS_CLIENT_SECLOG(fmt,args...) SECURE_LOGW(fmt, ##args) #else @@ -43,6 +44,7 @@ __BEGIN_DECLS #define LBS_CLIENT_LOGD(fmt,args...) #define LBS_CLIENT_LOGW(fmt,args...) #define LBS_CLIENT_LOGE(fmt,args...) +#define LBS_CLIENT_SECLOG(fmt,args...) #endif diff --git a/client/src/lbs_dbus_client.c b/client/src/lbs_dbus_client.c index b8e48bb..869d71c 100644 --- a/client/src/lbs_dbus_client.c +++ b/client/src/lbs_dbus_client.c @@ -4,7 +4,7 @@ * Copyright (c) 2013 Samsung Electronics Co., Ltd. All rights reserved. * * Contact: Youngae Kang , Minjune Kim - * Genie Kim , Ming Zhu + * Genie Kim , Ming Zhu * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -20,158 +20,783 @@ */ #include - +#include +#include #include "lbs_dbus_client.h" #include "lbs_dbus_client_priv.h" +#include "generated-code.h" + +#define LOCATION_PRIVACY_ID "http://tizen.org/privacy/location" +#define PRIVACY_INTERFACE "org.tizen.privacy_manager.signal" +#define PRIVACY_MEMBER "privacy_setting_changed" +#define PRIVACY_PATH "/privacy_manager/dbus_notification" typedef struct _lbs_client_dbus_s { int is_started; - gchar *addr; GDBusConnection *conn; - gchar *service_name; - gchar *service_path; + lbs_client_method_e method; int loc_evt_id; int loc_status_evt_id; int sat_evt_id; + int batch_evt_id; int nmea_evt_id; + int privacy_evt_id; + lbs_client_cb user_cb; + lbs_client_cb batch_cb; void *user_data; } lbs_client_dbus_s; +static int __lbs_get_appid(char **app_id) +{ + pid_t pid = getpid(); + int ret = 0; + char *aid = NULL; + + ret = app_manager_get_app_id(pid, &aid); + if (ret != APP_MANAGER_ERROR_NONE || aid == NULL) { + LBS_CLIENT_LOGE("Fail to app_manager_get_package. Error[%d]", ret); + return FALSE; + } + *app_id = (char *)g_malloc0(sizeof(char) * 64); + g_strlcpy(*app_id, aid, 64); + LBS_CLIENT_LOGD("get_appid %s", *app_id); + g_free(aid); + + return TRUE; +} + +static int __lbs_get_app_type(char *app_id, char **type) +{ + int ret; + app_info_h app_info; + char *app_type = NULL; + + ret = app_info_create(app_id, &app_info); + if (ret != APP_MANAGER_ERROR_NONE) { + LBS_CLIENT_LOGE("Fail to get app_info. Err[%d]", ret); + return FALSE; + } + + ret = app_info_get_type(app_info, &app_type); + if (ret != APP_MANAGER_ERROR_NONE) { + LBS_CLIENT_LOGE("Fail to get type. Err[%d]", ret); + app_info_destroy(app_info); + return FALSE; + } + + *type = (char *)g_malloc0(sizeof(char) * 16); + g_strlcpy(*type, app_type, 16); + g_free(app_type); + app_info_destroy(app_info); + + return TRUE; +} + +static int __lbs_check_package_id(char *pkg_id) +{ + int ret; + gchar *app_id = NULL; + gchar *type = NULL; + char *package_id = NULL; + + if (!__lbs_get_appid(&app_id)) { + return FALSE; + } + if (!__lbs_get_app_type(app_id, &type)) { + return FALSE; + } + + if ((g_strcmp0(type, "c++app") == 0) || (g_strcmp0(type, "webapp") == 0)) { + LBS_CLIENT_LOGE("Do not check for App[%s] Type[%s]", app_id, type); + g_free(app_id); + g_free(type); + return FALSE; + } + g_free(type); + + ret = package_manager_get_package_id_by_app_id(app_id, &package_id); + if (ret != PACKAGE_MANAGER_ERROR_NONE) { + LBS_CLIENT_LOGE("Fail to get package_id for [%s]. Err[%d]", app_id, ret); + g_free(app_id); + return FALSE; + } + LBS_CLIENT_LOGD("Current package[%s] / Privacy package[%s]", package_id, pkg_id); + + if (g_strcmp0(pkg_id, package_id) == 0) { + ret = TRUE; + } else { + ret = FALSE; + } + g_free(package_id); + g_free(app_id); + + return ret; +} + + +static void __signal_batch_callback(GDBusConnection *conn, const gchar *name, const gchar *path, const gchar *interface, const gchar *sig, GVariant *param, gpointer user_data) +{ + lbs_client_dbus_s *handle = (lbs_client_dbus_s *)user_data; + if (handle == NULL) { + LBS_CLIENT_LOGD("Invalid handle"); + return; + } + + if (handle->is_started == FALSE) { + LBS_CLIENT_LOGD("Handle[%p] is not started", handle); + return; + } + + if (handle->batch_cb) { + handle->batch_cb(sig, param, handle->user_data); + } +} + +static void __signal_callback(GDBusConnection *conn, const gchar *name, const gchar *path, const gchar *interface, const gchar *sig, GVariant *param, gpointer user_data) +{ + lbs_client_dbus_s *handle = (lbs_client_dbus_s *)user_data; + if (handle == NULL) { + LBS_CLIENT_LOGD("Invalid handle"); + return; + } + + if (handle->is_started == FALSE) { + LBS_CLIENT_LOGD("Handle[%p] is not started", handle); + return; + } + + if (handle->user_cb) { + handle->user_cb(sig, param, handle->user_data); + } +} + +static void __privacy_setting_changed(GDBusConnection *conn, const gchar *name, const gchar *path, const gchar *interface, const gchar *sig, GVariant *param, gpointer user_data) +{ + LBS_CLIENT_LOGD("ENTER >>>"); + + gchar *pkg_id = NULL; + gchar *privacy_id = NULL; + + g_variant_get(param, "(ss)", &pkg_id, &privacy_id); + if (!pkg_id) { + return; + } + if (!privacy_id) { + g_free(pkg_id); + return; + } + + if (g_strcmp0(privacy_id, LOCATION_PRIVACY_ID) != 0) { + LBS_CLIENT_LOGD("[%s]'s [%s] privacy is changed", pkg_id, privacy_id); + g_free(pkg_id); + g_free(privacy_id); + return; + } + + LBS_CLIENT_LOGD("[%s]'s location privacy is changed", pkg_id, privacy_id); + lbs_client_dbus_s *handle = (lbs_client_dbus_s *)user_data; + + if (handle == NULL || handle->is_started == FALSE) { + LBS_CLIENT_LOGE("Invalid handle or is_started [FALSE]"); + g_free(pkg_id); + g_free(privacy_id); + return; + } + + if (!__lbs_check_package_id(pkg_id)) { + LBS_CLIENT_LOGE("pkg_id[%s] is not current pakcage id", pkg_id); + g_free(pkg_id); + g_free(privacy_id); + return; + } + g_free(pkg_id); + g_free(privacy_id); + + if (lbs_client_stop(handle) != LBS_CLIENT_ERROR_NONE) { + LBS_CLIENT_LOGE("lbs_client_stop is fail"); + } + + if (handle->user_cb) { + handle->user_cb("StatusChanged", g_variant_new("(i)", FALSE), handle->user_data); + } + + lbs_client_destroy(handle); + handle = NULL; + + LBS_CLIENT_LOGD("EXIT <<<"); +} + +static void +lbs_client_signal_unsubcribe(lbs_client_dbus_h lbs_client) +{ + LBS_CLIENT_LOGD("lbs_client_unsubcribe"); + + lbs_client_dbus_s *handle = (lbs_client_dbus_s *)lbs_client; + if (handle == NULL) { + LBS_CLIENT_LOGD("Invalid handle"); + return; + } + if (handle->conn == NULL) { + LBS_CLIENT_LOGD("Invalid dbus_connection"); + return; + } + + if (handle->loc_evt_id) { + g_dbus_connection_signal_unsubscribe(handle->conn, handle->loc_evt_id); + handle->loc_evt_id = 0; + } + + if (handle->batch_evt_id) { + g_dbus_connection_signal_unsubscribe(handle->conn, handle->batch_evt_id); + handle->batch_evt_id = 0; + } + + if (handle->sat_evt_id) { + g_dbus_connection_signal_unsubscribe(handle->conn, handle->sat_evt_id); + handle->sat_evt_id = 0; + } + + if (handle->loc_status_evt_id) { + g_dbus_connection_signal_unsubscribe(handle->conn, handle->loc_status_evt_id); + handle->loc_status_evt_id = 0; + } + + if (handle->nmea_evt_id) { + g_dbus_connection_signal_unsubscribe(handle->conn, handle->nmea_evt_id); + handle->nmea_evt_id = 0; + } +} + +static void +lbs_client_privacy_signal_subcribe(lbs_client_dbus_h lbs_client) +{ + LBS_CLIENT_LOGD("lbs_client_privacy_signal_subcribe"); + + lbs_client_dbus_s *handle = (lbs_client_dbus_s *)lbs_client; + handle->privacy_evt_id = g_dbus_connection_signal_subscribe(handle->conn, NULL, + PRIVACY_INTERFACE, + PRIVACY_MEMBER, + PRIVACY_PATH, + NULL, G_DBUS_SIGNAL_FLAGS_NONE, + __privacy_setting_changed, handle, + NULL); + + if (handle->privacy_evt_id) { + LBS_CLIENT_LOGD("Listening Privacy info"); + } else { + LBS_CLIENT_LOGD("Fail to listen Privacy info"); + } +} + +static void +lbs_client_privacy_signal_unsubcribe(lbs_client_dbus_h lbs_client) +{ + LBS_CLIENT_LOGD("lbs_client_privacy_signal_unsubcribe"); + + lbs_client_dbus_s *handle = (lbs_client_dbus_s *)lbs_client; + if (handle->privacy_evt_id) { + g_dbus_connection_signal_unsubscribe(handle->conn, handle->privacy_evt_id); + handle->privacy_evt_id = 0; + } +} + EXPORT_API int -lbs_client_start(lbs_client_dbus_h lbs_client, lbs_client_callback_e callback_type, GDBusSignalCallback callback, void *user_data) +lbs_client_start_batch(lbs_client_dbus_h lbs_client, lbs_client_callback_e callback_type, lbs_client_cb callback, unsigned int batch_interval, unsigned int batch_period, void *user_data) { - LBS_CLIENT_LOGD("lbs_client_start"); + LBS_CLIENT_LOGD("lbs_client_start_batch"); - g_return_val_if_fail (lbs_client, LBS_CLIENT_ERROR_PARAMETER); - g_return_val_if_fail (callback_type, LBS_CLIENT_ERROR_PARAMETER); + g_return_val_if_fail(lbs_client, LBS_CLIENT_ERROR_PARAMETER); + g_return_val_if_fail(callback_type, LBS_CLIENT_ERROR_PARAMETER); + + lbs_client_dbus_s *handle = (lbs_client_dbus_s *)lbs_client; + g_return_val_if_fail(handle->is_started == FALSE, LBS_CLIENT_ERROR_STATUS); + GVariant *reg = NULL; + GVariant *param = NULL, *method = NULL; + GError *error = NULL; + GVariantBuilder *builder = NULL; + GDBusProxy *proxy = NULL; + gchar *signal_path = NULL; + int ret = LBS_CLIENT_ERROR_NONE; + + signal_path = g_strdup_printf("%s/%s", SERVICE_PATH, "SAMSUNG"); + LBS_CLIENT_SECLOG("LBS signal subscribe Object Path [%s]", signal_path); + + if (callback) { + handle->batch_cb = callback; + handle->user_data = user_data; + + if (callback_type & LBS_CLIENT_BATCH_CB) { + handle->batch_evt_id = g_dbus_connection_signal_subscribe(handle->conn, + SERVICE_NAME, /* Sender */ + "org.tizen.lbs.Batch", /* Interface */ + "BatchChanged", /* Member */ + signal_path, /* Object */ + NULL, /* arg0 */ + G_DBUS_SIGNAL_FLAGS_NONE, + __signal_batch_callback, handle, + NULL); + + if (handle->batch_evt_id) { + LBS_CLIENT_LOGD("Listening batch info"); + } else { + LBS_CLIENT_LOGD("Fail to listen batch info"); + } + } + } + g_free(signal_path); + + /* Start Batch */ + LBS_CLIENT_LOGD("START: CMD-START_BATCH"); + builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}")); + g_variant_builder_add(builder, "{sv}", "CMD", g_variant_new_string("START_BATCH")); + g_variant_builder_add(builder, "{sv}", "BATCH_INTERVAL", g_variant_new_int32((gint32) batch_interval)); + g_variant_builder_add(builder, "{sv}", "BATCH_PERIOD", g_variant_new_int32((gint32) batch_period)); + param = g_variant_ref_sink(g_variant_new("(@a{sv})", g_variant_builder_end(builder))); + method = g_variant_ref_sink(g_variant_new("(i)", handle->method)); + + proxy = g_dbus_proxy_new_sync(handle->conn, /* GDBusConnection */ + G_DBUS_PROXY_FLAGS_NONE, /*GDbusProxyFlags */ + NULL, + SERVICE_NAME, SERVICE_PATH, + "org.tizen.lbs.Manager", + NULL, + &error); + + if (error && error->message) { + if (error->code == G_DBUS_ERROR_ACCESS_DENIED) { + LBS_CLIENT_LOGE("Access denied. Msg[%s]", error->message); + ret = LBS_CLIENT_ERROR_ACCESS_DENIED; + } else { + LBS_CLIENT_LOGE("Fail to new proxy ErrCode[%d], Msg[%s]", error->code, error->message); + ret = LBS_CLIENT_ERROR_DBUS_CALL; + } + g_error_free(error); + g_variant_unref(param); + g_variant_unref(method); + lbs_client_signal_unsubcribe(handle); + return ret; + } + + if (proxy) { + reg = g_dbus_proxy_call_sync(proxy, + "AddReference", + method, + G_DBUS_CALL_FLAGS_NONE, + -1, + NULL, + &error); + + if (error && error->message) { + if (error->code == G_DBUS_ERROR_ACCESS_DENIED) { + LBS_CLIENT_LOGE("Access denied. Msg[%s]", error->message); + ret = LBS_CLIENT_ERROR_ACCESS_DENIED; + } else { + LBS_CLIENT_LOGE("Fail to new proxy ErrCode[%d], Msg[%s]", error->code, error->message); + ret = LBS_CLIENT_ERROR_DBUS_CALL; + } + g_error_free(error); + g_variant_unref(param); + g_variant_unref(method); + lbs_client_signal_unsubcribe(handle); + return ret; + } + if (reg) { + g_variant_unref(reg); + reg = NULL; + } + + reg = g_dbus_proxy_call_sync(proxy, + "SetOptions", + param, + G_DBUS_CALL_FLAGS_NO_AUTO_START, + -1, + NULL, + &error); + + if (error && error->message) { + if (error->code == G_DBUS_ERROR_ACCESS_DENIED) { + LBS_CLIENT_LOGE("Access denied. Msg[%s]", error->message); + ret = LBS_CLIENT_ERROR_ACCESS_DENIED; + } else { + LBS_CLIENT_LOGE("Fail to new proxy ErrCode[%d], Msg[%s]", error->code, error->message); + ret = LBS_CLIENT_ERROR_DBUS_CALL; + } + g_error_free(error); + g_variant_unref(param); + g_variant_unref(method); + + lbs_client_signal_unsubcribe(handle); + return ret; + } + if (reg) { + g_variant_unref(reg); + reg = NULL; + } + + g_object_unref(proxy); + } + + /* g_variant_builder_unref(builder); */ + g_variant_unref(method); + g_variant_unref(param); + + lbs_client_privacy_signal_subcribe(handle); + handle->is_started = TRUE; + + return LBS_CLIENT_ERROR_NONE; +} + +EXPORT_API int +lbs_client_set_position_update_interval(lbs_client_dbus_h lbs_client, unsigned int interval) +{ + LBS_CLIENT_LOGD("lbs_client_set_position_update_interval"); lbs_client_dbus_s *handle = (lbs_client_dbus_s *)lbs_client; - g_return_val_if_fail (handle->is_started == FALSE, LBS_CLIENT_ERROR_STATUS); + + g_return_val_if_fail(handle, LBS_CLIENT_ERROR_PARAMETER); + g_return_val_if_fail(handle->is_started == TRUE, LBS_CLIENT_ERROR_STATUS); GVariant *reg = NULL; GVariant *param = NULL; + GVariant *method = NULL; GError *error = NULL; GVariantBuilder *builder = NULL; GDBusProxy *proxy = NULL; gchar *signal_path = NULL; - signal_path = g_strdup_printf ("%s/%s", handle->service_path, "SAMSUNG"); + signal_path = g_strdup_printf("%s/%s", SERVICE_PATH, "SAMSUNG"); LBS_CLIENT_LOGD("LBS signal subscribe Object Path [%s]", signal_path); + g_free(signal_path); + + LBS_CLIENT_LOGD("SET option INTERVAL_UPDATE:[%u], method:[%d]", interval, method); + builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}")); + g_variant_builder_add(builder, "{sv}", "CMD", g_variant_new_string("SET:OPT")); + g_variant_builder_add(builder, "{sv}", "INTERVAL_UPDATE", g_variant_new_uint32(interval)); + g_variant_builder_add(builder, "{sv}", "METHOD", g_variant_new_int32(handle->method)); + param = g_variant_ref_sink(g_variant_new("(@a{sv})", g_variant_builder_end(builder))); + method = g_variant_ref_sink(g_variant_new("(i)", handle->method)); + + proxy = g_dbus_proxy_new_sync(handle->conn, /* GDBusConnection */ + G_DBUS_PROXY_FLAGS_NONE, /*GDbusProxyFlags */ + NULL, SERVICE_NAME, SERVICE_PATH, + "org.tizen.lbs.Manager", + NULL, + &error); + if (proxy) { + reg = g_dbus_proxy_call_sync(proxy, + "SetOptions", + param, + G_DBUS_CALL_FLAGS_NO_AUTO_START, + -1, + NULL, + &error); + if (reg) { + g_variant_unref(reg); + reg = NULL; + } + + g_object_unref(proxy); + } + /* g_variant_builder_unref(builder); */ + g_variant_unref(param); + g_variant_unref(method); + + return LBS_CLIENT_ERROR_NONE; +} + +EXPORT_API int +lbs_client_stop_batch(lbs_client_dbus_h lbs_client) +{ + LBS_CLIENT_LOGD("lbs_client_stop_batch"); + + lbs_client_dbus_s *handle = (lbs_client_dbus_s *)lbs_client; + g_return_val_if_fail(handle, LBS_CLIENT_ERROR_PARAMETER); + g_return_val_if_fail(handle->is_started == TRUE, LBS_CLIENT_ERROR_STATUS); + + int ret = LBS_CLIENT_ERROR_NONE; + GVariant *param = NULL, *method = NULL, *reg = NULL; + GError *error = NULL; + GVariantBuilder *builder = NULL; + + lbs_client_privacy_signal_unsubcribe(handle); + lbs_client_signal_unsubcribe(handle); + + /* Stop */ + LBS_CLIENT_LOGD("STOP: CMD-STOP_BATCH"); + builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}")); + g_variant_builder_add(builder, "{sv}", "CMD", g_variant_new_string("STOP_BATCH")); + + LBS_CLIENT_LOGD("METHOD: %d", handle->method); + g_variant_builder_add(builder, "{sv}", "METHOD", g_variant_new_int32(handle->method)); + param = g_variant_ref_sink(g_variant_new("(@a{sv})", g_variant_builder_end(builder))); + method = g_variant_ref_sink(g_variant_new("(i)", handle->method)); + + GDBusProxy *proxy = NULL; + proxy = g_dbus_proxy_new_sync(handle->conn, /* GDBusConnection */ + G_DBUS_PROXY_FLAGS_NONE, /*GDbusProxyFlags */ + NULL, SERVICE_NAME, SERVICE_PATH, + "org.tizen.lbs.Manager", + NULL, + &error); + + if (error && error->message) { + if (error->code == G_DBUS_ERROR_ACCESS_DENIED) { + LBS_CLIENT_LOGI("Access denied. Msg[%s]", error->message); + ret = LBS_CLIENT_ERROR_ACCESS_DENIED; + } else { + LBS_CLIENT_LOGI("Fail to new proxy ErrCode[%d], Msg[%s]", error->code, error->message); + ret = LBS_CLIENT_ERROR_DBUS_CALL; + } + g_error_free(error); + g_variant_unref(param); + g_variant_unref(method); + + g_object_unref(proxy); + return ret; + } + + error = NULL; + if (proxy) { + reg = g_dbus_proxy_call_sync(proxy, "SetOptions", param, G_DBUS_CALL_FLAGS_NO_AUTO_START, -1, NULL, &error); + if (error && error->message) { + if (error->code == G_DBUS_ERROR_ACCESS_DENIED) { + LBS_CLIENT_LOGI("Access denied. Msg[%s]", error->message); + ret = LBS_CLIENT_ERROR_ACCESS_DENIED; + } else { + LBS_CLIENT_LOGI("Fail to proxy call. ErrCode[%d], Msg[%s]", error->code, error->message); + ret = LBS_CLIENT_ERROR_DBUS_CALL; + } + g_error_free(error); + g_variant_unref(param); + g_variant_unref(method); + + g_object_unref(proxy); + return ret; + } + + if (reg) { + g_variant_unref(reg); + reg = NULL; + } + + g_object_unref(proxy); + } + /* g_variant_builder_unref (builder); */ + g_variant_unref(param); + g_variant_unref(method); + + handle->is_started = FALSE; + + return ret; +} + +EXPORT_API int +lbs_client_start(lbs_client_dbus_h lbs_client, unsigned int interval, lbs_client_callback_e callback_type, lbs_client_cb callback, void *user_data) +{ + LBS_CLIENT_LOGD("lbs_client_start"); + + g_return_val_if_fail(lbs_client, LBS_CLIENT_ERROR_PARAMETER); + g_return_val_if_fail(callback_type, LBS_CLIENT_ERROR_PARAMETER); + + lbs_client_dbus_s *handle = (lbs_client_dbus_s *)lbs_client; + g_return_val_if_fail(handle->is_started == FALSE, LBS_CLIENT_ERROR_STATUS); + + GVariant *reg = NULL; + GVariant *param = NULL, *method = NULL; + GError *error = NULL; + GVariantBuilder *builder = NULL; + GDBusProxy *proxy = NULL; + gchar *signal_path = NULL; + gchar *app_id = NULL; + int ret = LBS_CLIENT_ERROR_NONE; + + signal_path = g_strdup_printf("%s/%s", SERVICE_PATH, "SAMSUNG"); + LBS_CLIENT_SECLOG("LBS signal subscribe Object Path [%s]", signal_path); if (callback) { + handle->user_cb = callback; + handle->user_data = user_data; + if (callback_type & LBS_CLIENT_LOCATION_CB) { - handle->loc_evt_id = g_dbus_connection_signal_subscribe(handle->conn, - handle->service_name, //GPS_MANAGER_SERVICE_NAME, /* Sender */ - "org.tizen.lbs.Position", /* Interface */ - "PositionChanged", /* Member */ - signal_path, //GPS_MANAGER_SERVICE_PATH, /* Object */ - NULL, /* arg0 */ - G_DBUS_SIGNAL_FLAGS_NONE, - callback, user_data, - NULL); + handle->loc_evt_id = g_dbus_connection_signal_subscribe( + handle->conn, + SERVICE_NAME, /* Sender */ + "org.tizen.lbs.Position", /* Interface */ + "PositionChanged", /* Member */ + signal_path, + NULL, + G_DBUS_SIGNAL_FLAGS_NONE, + __signal_callback, handle, + NULL); if (handle->loc_evt_id) { LBS_CLIENT_LOGD("Listening Position info"); - } - else { + } else { LBS_CLIENT_LOGD("Fail to listen Position info"); } } if (callback_type & LBS_CLIENT_LOCATION_STATUS_CB) { handle->loc_status_evt_id = g_dbus_connection_signal_subscribe(handle->conn, - handle->service_name, //GPS_MANAGER_SERVICE_NAME, /* Sender */ - "org.tizen.lbs.Manager", /* Interface */ - "StatusChanged", /* Member */ - handle->service_path, //GPS_MANAGER_SERVICE_PATH, /* Object */ - NULL, /* arg0 */ - G_DBUS_SIGNAL_FLAGS_NONE, - callback, user_data, - NULL); + SERVICE_NAME, /* Sender */ + "org.tizen.lbs.Manager", /* Interface */ + "StatusChanged", /* Member */ + SERVICE_PATH, + NULL, + G_DBUS_SIGNAL_FLAGS_NONE, + __signal_callback, handle, + NULL); if (handle->loc_status_evt_id) { LBS_CLIENT_LOGD("Listening location Status"); - } - else { + } else { LBS_CLIENT_LOGD("Fail to listen location Status"); } } if (callback_type & LBS_CLIENT_SATELLITE_CB) { - handle->sat_evt_id= g_dbus_connection_signal_subscribe(handle->conn, - handle->service_name, //GPS_MANAGER_SERVICE_NAME, /* Sender */ - "org.tizen.lbs.Satellite", /* Interface */ - "SatelliteChanged", /* Member */ - signal_path, //GPS_MANAGER_SERVICE_PATH, /* Object */ - NULL, /* arg0 */ - G_DBUS_SIGNAL_FLAGS_NONE, - callback, user_data, - NULL); + handle->sat_evt_id = g_dbus_connection_signal_subscribe(handle->conn, + SERVICE_NAME, /* Sender */ + "org.tizen.lbs.Satellite", /* Interface */ + "SatelliteChanged", /* Member */ + signal_path, + NULL, + G_DBUS_SIGNAL_FLAGS_NONE, + __signal_callback, handle, + NULL); if (handle->sat_evt_id) { LBS_CLIENT_LOGD("Listening satellite info"); - } - else { + } else { LBS_CLIENT_LOGD("Fail to listen satellite info"); } } if (callback_type & LBS_CLIENT_NMEA_CB) { handle->nmea_evt_id = g_dbus_connection_signal_subscribe(handle->conn, - handle->service_name, /* Sender */ - "org.tizen.lbs.Nmea", /* Interface */ - "NmeaChanged", /* Member */ - signal_path, //GPS_MANAGER_SERVICE_PATH, /* Object */ - NULL, /* arg0 */ - G_DBUS_SIGNAL_FLAGS_NONE, - callback, user_data, - NULL); + SERVICE_NAME, /* Sender */ + "org.tizen.lbs.Nmea", /* Interface */ + "NmeaChanged", /* Member */ + signal_path, + NULL, + G_DBUS_SIGNAL_FLAGS_NONE, + __signal_callback, handle, + NULL); if (handle->nmea_evt_id) { LBS_CLIENT_LOGD("Listening nmea info"); - } - else { + } else { LBS_CLIENT_LOGD("Fail to listen nmea info"); } } } g_free(signal_path); - // Start + /* Start */ LBS_CLIENT_LOGD("START: CMD-START"); - builder = g_variant_builder_new(G_VARIANT_TYPE ("a{sv}")); + builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}")); g_variant_builder_add(builder, "{sv}", "CMD", g_variant_new_string("START")); - param = g_variant_ref_sink(g_variant_new ("(@a{sv})", g_variant_builder_end(builder))); - - proxy = g_dbus_proxy_new_sync (handle->conn, // GDBusConnection - G_DBUS_PROXY_FLAGS_NONE, //GDbusProxyFlags - NULL, - handle->service_name, - handle->service_path, - "org.tizen.lbs.Manager", - NULL, - &error); - - reg = g_dbus_proxy_call_sync(proxy, - "AddReference", - NULL, - G_DBUS_CALL_FLAGS_NONE, - -1, - NULL, - &error); - - reg = g_dbus_proxy_call_sync(proxy, - "SetOptions", - param, - G_DBUS_CALL_FLAGS_NO_AUTO_START, - -1, - NULL, - &error); - - g_object_unref(proxy); - g_variant_builder_unref (builder); + + g_variant_builder_add(builder, "{sv}", "METHOD", g_variant_new_int32(handle->method)); + g_variant_builder_add(builder, "{sv}", "INTERVAL", g_variant_new_uint32(interval)); + + if (__lbs_get_appid(&app_id)) { + LBS_CLIENT_LOGD("[%s] Request START", app_id); + g_variant_builder_add(builder, "{sv}", "APP_ID", g_variant_new_string(app_id)); + if (app_id) { + g_free(app_id); + } + } + + param = g_variant_ref_sink(g_variant_new("(@a{sv})", g_variant_builder_end(builder))); + + method = g_variant_ref_sink(g_variant_new("(i)", handle->method)); + + proxy = g_dbus_proxy_new_sync(handle->conn, /* GDBusConnection */ + G_DBUS_PROXY_FLAGS_NONE, /* GDbusProxyFlags */ + NULL, SERVICE_NAME, SERVICE_PATH, + "org.tizen.lbs.Manager", + NULL, + &error); + + if (error && error->message) { + if (error->code == G_DBUS_ERROR_ACCESS_DENIED) { + LBS_CLIENT_LOGI("Access denied. Msg[%s]", error->message); + ret = LBS_CLIENT_ERROR_ACCESS_DENIED; + } else { + LBS_CLIENT_LOGI("Fail to new proxy ErrCode[%d], Msg[%s]", error->code, error->message); + ret = LBS_CLIENT_ERROR_DBUS_CALL; + } + g_error_free(error); + g_variant_unref(param); + g_variant_unref(method); + lbs_client_signal_unsubcribe(handle); + return ret; + } + + if (proxy) { + reg = g_dbus_proxy_call_sync(proxy, + "AddReference", + method, + G_DBUS_CALL_FLAGS_NONE, + -1, + NULL, + &error); + + if (error && error->message) { + if (error->code == G_DBUS_ERROR_ACCESS_DENIED) { + LBS_CLIENT_LOGI("Access denied. Msg[%s]", error->message); + ret = LBS_CLIENT_ERROR_ACCESS_DENIED; + } else { + LBS_CLIENT_LOGI("Fail to new proxy ErrCode[%d], Msg[%s]", error->code, error->message); + ret = LBS_CLIENT_ERROR_DBUS_CALL; + } + g_error_free(error); + g_variant_unref(param); + g_variant_unref(method); + lbs_client_signal_unsubcribe(handle); + return ret; + } + if (reg) { + g_variant_unref(reg); + reg = NULL; + } + + reg = g_dbus_proxy_call_sync(proxy, + "SetOptions", + param, + G_DBUS_CALL_FLAGS_NO_AUTO_START, + -1, + NULL, + &error); + if (error && error->message) { + if (error->code == G_DBUS_ERROR_ACCESS_DENIED) { + LBS_CLIENT_LOGI("Access denied. Msg[%s]", error->message); + ret = LBS_CLIENT_ERROR_ACCESS_DENIED; + } else { + LBS_CLIENT_LOGI("Fail to new proxy ErrCode[%d], Msg[%s]", error->code, error->message); + ret = LBS_CLIENT_ERROR_DBUS_CALL; + } + g_error_free(error); + g_variant_unref(param); + g_variant_unref(method); + + lbs_client_signal_unsubcribe(handle); + return ret; + } + if (reg) { + g_variant_unref(reg); + reg = NULL; + } + + g_object_unref(proxy); + } + + /* g_variant_builder_unref (builder); */ g_variant_unref(param); + g_variant_unref(method); + lbs_client_privacy_signal_subcribe(handle); handle->is_started = TRUE; return LBS_CLIENT_ERROR_NONE; @@ -183,70 +808,117 @@ lbs_client_stop(lbs_client_dbus_h lbs_client) LBS_CLIENT_LOGD("lbs_client_stop"); lbs_client_dbus_s *handle = (lbs_client_dbus_s *)lbs_client; - g_return_val_if_fail (handle, LBS_CLIENT_ERROR_PARAMETER); - g_return_val_if_fail (handle->is_started == TRUE, LBS_CLIENT_ERROR_STATUS); + g_return_val_if_fail(handle, LBS_CLIENT_ERROR_PARAMETER); + g_return_val_if_fail(handle->is_started == TRUE, LBS_CLIENT_ERROR_STATUS); int ret = LBS_CLIENT_ERROR_NONE; - GVariant *param = NULL; - GVariant *reg = NULL; + GVariant *param = NULL, *method = NULL, *reg = NULL; GError *error = NULL; GVariantBuilder *builder = NULL; + gchar *app_id = NULL; - //TODO: Unsubscribe - if (handle->loc_evt_id) { - g_dbus_connection_signal_unsubscribe(handle->conn, handle->loc_evt_id); - handle->loc_evt_id = 0; - } + lbs_client_privacy_signal_unsubcribe(handle); + lbs_client_signal_unsubcribe(handle); - if (handle->sat_evt_id) { - g_dbus_connection_signal_unsubscribe(handle->conn, handle->sat_evt_id); - handle->sat_evt_id = 0; - } + /* Stop */ + LBS_CLIENT_LOGD("STOP: CMD-STOP"); + builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}")); + g_variant_builder_add(builder, "{sv}", "CMD", g_variant_new_string("STOP")); - if (handle->loc_status_evt_id) { - g_dbus_connection_signal_unsubscribe(handle->conn, handle->loc_status_evt_id); - handle->loc_status_evt_id = 0; - } + LBS_CLIENT_LOGD("METHOD: %d", handle->method); + g_variant_builder_add(builder, "{sv}", "METHOD", g_variant_new_int32(handle->method)); - if (handle->nmea_evt_id) { - g_dbus_connection_signal_unsubscribe(handle->conn, handle->nmea_evt_id); - handle->nmea_evt_id = 0; + if (__lbs_get_appid(&app_id)) { + LBS_CLIENT_LOGD("[%s] Request STOP", app_id); + g_variant_builder_add(builder, "{sv}", "APP_ID", g_variant_new_string(app_id)); + if (app_id) { + g_free(app_id); + } } - // Stop - LBS_CLIENT_LOGD("STOP: CMD-STOP"); - builder = g_variant_builder_new(G_VARIANT_TYPE ("a{sv}")); - g_variant_builder_add(builder, "{sv}", "CMD", g_variant_new_string("STOP")); - param = g_variant_ref_sink(g_variant_new ("(@a{sv})", g_variant_builder_end(builder))); + param = g_variant_ref_sink(g_variant_new("(@a{sv})", g_variant_builder_end(builder))); + + method = g_variant_ref_sink(g_variant_new("(i)", handle->method)); GDBusProxy *proxy = NULL; - proxy = g_dbus_proxy_new_sync (handle->conn, // GDBusConnection - G_DBUS_PROXY_FLAGS_NONE, //GDbusProxyFlags - NULL, - handle->service_name, - handle->service_path, - "org.tizen.lbs.Manager", - NULL, - &error); - reg = g_dbus_proxy_call_sync(proxy, - "SetOptions", - param, - G_DBUS_CALL_FLAGS_NO_AUTO_START, - -1, - NULL, - &error); - - reg = g_dbus_proxy_call_sync(proxy, - "RemoveReference", - NULL, - G_DBUS_CALL_FLAGS_NO_AUTO_START, - -1, - NULL, - &error); - - g_object_unref(proxy); - g_variant_builder_unref (builder); + proxy = g_dbus_proxy_new_sync(handle->conn, /* GDBusConnection */ + G_DBUS_PROXY_FLAGS_NONE, /*GDbusProxyFlags */ + NULL, SERVICE_NAME, SERVICE_PATH, + "org.tizen.lbs.Manager", + NULL, + &error); + + if (error && error->message) { + if (error->code == G_DBUS_ERROR_ACCESS_DENIED) { + LBS_CLIENT_LOGI("Access denied. Msg[%s]", error->message); + ret = LBS_CLIENT_ERROR_ACCESS_DENIED; + } else { + LBS_CLIENT_LOGI("Fail to new proxy ErrCode[%d], Msg[%s]", error->code, error->message); + ret = LBS_CLIENT_ERROR_DBUS_CALL; + } + g_error_free(error); + g_variant_unref(param); + g_variant_unref(method); + + g_object_unref(proxy); + return ret; + } + + error = NULL; + if (proxy) { + reg = g_dbus_proxy_call_sync(proxy, "SetOptions", param, G_DBUS_CALL_FLAGS_NO_AUTO_START, -1, NULL, &error); + if (error && error->message) { + if (error->code == G_DBUS_ERROR_ACCESS_DENIED) { + LBS_CLIENT_LOGI("Access denied. Msg[%s]", error->message); + ret = LBS_CLIENT_ERROR_ACCESS_DENIED; + } else { + LBS_CLIENT_LOGI("Fail to proxy call. ErrCode[%d], Msg[%s]", error->code, error->message); + ret = LBS_CLIENT_ERROR_DBUS_CALL; + } + g_error_free(error); + g_variant_unref(param); + g_variant_unref(method); + + g_object_unref(proxy); + return ret; + } + + if (reg) { + g_variant_unref(reg); + reg = NULL; + } + + reg = g_dbus_proxy_call_sync(proxy, "RemoveReference", + method, + G_DBUS_CALL_FLAGS_NO_AUTO_START, + -1, NULL, &error); + + if (error && error->message) { + if (error->code == G_DBUS_ERROR_ACCESS_DENIED) { + LBS_CLIENT_LOGI("Access denied. Msg[%s]", error->message); + ret = LBS_CLIENT_ERROR_ACCESS_DENIED; + } else { + LBS_CLIENT_LOGI("Fail to proxy call. ErrCode[%d], Msg[%s]", error->code, error->message); + ret = LBS_CLIENT_ERROR_DBUS_CALL; + } + g_error_free(error); + g_variant_unref(param); + g_variant_unref(method); + + g_object_unref(proxy); + return ret; + } + if (reg) { + g_variant_unref(reg); + reg = NULL; + } + + g_object_unref(proxy); + } + /* g_variant_builder_unref (builder); */ g_variant_unref(param); + g_variant_unref(method); + handle->is_started = FALSE; return ret; @@ -255,105 +927,112 @@ lbs_client_stop(lbs_client_dbus_h lbs_client) EXPORT_API int lbs_client_get_nmea(lbs_client_dbus_h lbs_client, int *timestamp, char **nmea) { - LBS_CLIENT_LOGD("lbs_client_nmea"); - g_return_val_if_fail (lbs_client, LBS_CLIENT_ERROR_PARAMETER); - g_return_val_if_fail (timestamp, LBS_CLIENT_ERROR_PARAMETER); - g_return_val_if_fail (nmea, LBS_CLIENT_ERROR_PARAMETER); + LBS_CLIENT_LOGD("ENTER >>>"); + g_return_val_if_fail(lbs_client, LBS_CLIENT_ERROR_PARAMETER); + g_return_val_if_fail(timestamp, LBS_CLIENT_ERROR_PARAMETER); + g_return_val_if_fail(nmea, LBS_CLIENT_ERROR_PARAMETER); - GVariant *reg = NULL; GError *error = NULL; - lbs_client_dbus_s *handle = (lbs_client_dbus_s *)lbs_client; + int ret = LBS_CLIENT_ERROR_NONE; + lbs_client_dbus_s *handle = (lbs_client_dbus_s *)lbs_client; *timestamp = 0; *nmea = NULL; - reg = g_dbus_connection_call_sync(handle->conn, - handle->service_name, //GPS_MANAGER_SERVICE_NAME, /* Bus Name */ - handle->service_path, //GPS_MANAGER_SERVICE_PATH, /* Object path */ - "org.tizen.lbs.Nmea", /* Interface*/ - "GetNmea", /* Method name */ - NULL, /* Param */ - NULL, /* Ret */ - G_DBUS_CALL_FLAGS_NONE, /* GDBusCallFlags (G_DBUS_CALL_FLAGS_NONE/G_DBUS_CALL_FLAGS_NO_AUTO_START) */ - -1, /* timeout msec */ - NULL, /* cancellable */ - &error); + LbsNmea *proxy = NULL; + proxy = lbs_nmea_proxy_new_sync(handle->conn, + G_DBUS_PROXY_FLAGS_NONE, + SERVICE_NAME, + SERVICE_PATH, + NULL, + &error); - if (error) { - LBS_CLIENT_LOGE("Fail to get nmea. Error[%s]", error->message); - g_error_free (error); - return LBS_CLIENT_ERROR_DBUS_CALL; - } + gint cur_timestamp = 0; + gchar *cur_nmea_data = NULL; - /* Get Ret */ - if (!reg) { - LBS_CLIENT_LOGD("There is no result"); - return LBS_CLIENT_ERROR_NO_RESULT; - } + if (proxy) { + ret = lbs_nmea_call_get_nmea_sync(proxy, &cur_timestamp, &cur_nmea_data, NULL, &error); + if (error && error->message) { + if (error->code == G_DBUS_ERROR_ACCESS_DENIED) { + LBS_CLIENT_LOGE("Access denied. Msg[%s]", error->message); + ret = LBS_CLIENT_ERROR_ACCESS_DENIED; + } else { + LBS_CLIENT_LOGE("Fail to new proxy ErrCode[%d], Msg[%s]", error->code, error->message); + ret = LBS_CLIENT_ERROR_DBUS_CALL; + } + g_error_free(error); + lbs_client_signal_unsubcribe(handle); + return ret; + } + + LBS_CLIENT_LOGD("Get NMEA: Timestamp[%d], NMEA[%s]", cur_timestamp, cur_nmea_data); + *timestamp = cur_timestamp; + *nmea = cur_nmea_data; - LBS_CLIENT_LOGD("type : %s", g_variant_get_type(reg)); - g_variant_get (reg, "(is)", timestamp, nmea); - LBS_CLIENT_LOGD("Get NMEA. Timestamp[%d], NMEA[%s]", *timestamp, *nmea); + g_object_unref(proxy); + } return LBS_CLIENT_ERROR_NONE; } static int -_client_create_connection (lbs_client_dbus_s *client) +_client_create_connection(lbs_client_dbus_s *client) { LBS_CLIENT_LOGD("create connection"); - g_return_val_if_fail (client, LBS_CLIENT_ERROR_PARAMETER); + g_return_val_if_fail(client, LBS_CLIENT_ERROR_PARAMETER); GError *error = NULL; - client->addr = g_dbus_address_get_for_bus_sync (G_BUS_TYPE_SYSTEM, NULL, &error); - if (!client->addr) { - LBS_CLIENT_LOGD("Fail to get addr of bus."); - return LBS_CLIENT_ERROR_CONNECTION; - } - - client->conn = g_dbus_connection_new_for_address_sync (client->addr, - G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT | - G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION, - NULL, NULL, &error); + client->conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error); if (!client->conn) { - LBS_CLIENT_LOGD("Fail to get addr of bus."); - g_free(client->addr); + if (error && error->message) { + LBS_CLIENT_LOGI("Fail to get GBus. ErrCode[%d], Msg[%s]", error->code, error->message); + g_error_free(error); + error = NULL; + } + LBS_CLIENT_LOGI("Fail to get addr of bus."); return LBS_CLIENT_ERROR_CONNECTION; } + LBS_CLIENT_LOGD("client->conn: %p", client->conn); + return LBS_CLIENT_ERROR_NONE; } -// The reason why we seperate this from start is to support IPC for db operation between a server and a client. +static void _glib_log(const gchar *log_domain, GLogLevelFlags log_level, + const gchar *msg, gpointer user_data) +{ + LBS_CLIENT_LOGD("GLIB[%d] : %s", log_level, msg); +} + +/* The reason why we seperate this from start is to support IPC for db operation between a server and a client. */ EXPORT_API int -lbs_client_create(char *service_name, char *service_path, lbs_client_dbus_h *lbs_client) +lbs_client_create(lbs_client_method_e method, lbs_client_dbus_h *lbs_client) { LBS_CLIENT_LOGD("lbs_client_create"); - g_return_val_if_fail (service_name, LBS_CLIENT_ERROR_PARAMETER); - g_return_val_if_fail (service_path, LBS_CLIENT_ERROR_PARAMETER); - g_return_val_if_fail (lbs_client, LBS_CLIENT_ERROR_PARAMETER); + g_return_val_if_fail(lbs_client, LBS_CLIENT_ERROR_PARAMETER); int ret = LBS_CLIENT_ERROR_NONE; lbs_client_dbus_s *client = g_new0(lbs_client_dbus_s, 1); - g_return_val_if_fail (client, LBS_CLIENT_ERROR_MEMORY); + g_return_val_if_fail(client, LBS_CLIENT_ERROR_MEMORY); - ret = _client_create_connection (client); + g_log_set_default_handler(_glib_log, NULL); + + ret = _client_create_connection(client); if (ret != LBS_CLIENT_ERROR_NONE) { g_free(client); return ret; } - client->service_name = g_strdup(service_name); - client->service_path = g_strdup(service_path); + client->method = method; - *lbs_client = (lbs_client_dbus_h *)client; + *lbs_client = (lbs_client_dbus_s *)client; return LBS_CLIENT_ERROR_NONE; } EXPORT_API int -lbs_client_destroy (lbs_client_dbus_h lbs_client) +lbs_client_destroy(lbs_client_dbus_h lbs_client) { LBS_CLIENT_LOGD("lbs_client_destroy"); g_return_val_if_fail(lbs_client, LBS_CLIENT_ERROR_PARAMETER); @@ -361,21 +1040,15 @@ lbs_client_destroy (lbs_client_dbus_h lbs_client) lbs_client_dbus_s *handle = (lbs_client_dbus_s *)lbs_client; g_return_val_if_fail(handle->is_started == FALSE, LBS_CLIENT_ERROR_STATUS); - int ret = LBS_CLIENT_ERROR_NONE; - GError *error = NULL; + handle->user_cb = NULL; + handle->batch_cb = NULL; + handle->user_data = NULL; - //TODO : disconnect if (handle->conn) { - ret = g_dbus_connection_close_sync(handle->conn, NULL, &error); - if (ret != TRUE) { - LBS_CLIENT_LOGD("Fail to disconnection Dbus"); - } + g_object_unref(handle->conn); handle->conn = NULL; } - if (handle->addr) g_free(handle->addr); - if (handle->service_path) g_free(handle->service_path); - if (handle->service_name) g_free(handle->service_name); g_free(handle); return LBS_CLIENT_ERROR_NONE; diff --git a/introspection/gen.sh b/introspection/gen.sh old mode 100644 new mode 100755 index 3617331..bfd8df0 --- a/introspection/gen.sh +++ b/introspection/gen.sh @@ -1,6 +1,8 @@ +#!/bin/bash -x + gdbus-codegen --interface-prefix org.tizen.lbs. \ - --generate-c-code generated-code \ - --c-generate-object-manager \ - --c-namespace Lbs \ - --generate-docbook generated-docs \ - lbs.xml lbs_position.xml lbs_satellite.xml lbs_nmea.xml + --generate-c-code generated-code \ + --c-generate-object-manager \ + --c-namespace Lbs \ + --generate-docbook generated-docs \ + lbs.xml lbs_position.xml lbs_batch.xml lbs_satellite.xml lbs_nmea.xml lbs_gps_geofence.xml diff --git a/introspection/lbs.xml b/introspection/lbs.xml index eaf89e7..e54241f 100644 --- a/introspection/lbs.xml +++ b/introspection/lbs.xml @@ -8,15 +8,18 @@ + + + diff --git a/introspection/lbs_batch.xml b/introspection/lbs_batch.xml new file mode 100644 index 0000000..57e7f31 --- /dev/null +++ b/introspection/lbs_batch.xml @@ -0,0 +1,7 @@ + + + + + + + diff --git a/introspection/lbs_gps_geofence.xml b/introspection/lbs_gps_geofence.xml new file mode 100644 index 0000000..20dff97 --- /dev/null +++ b/introspection/lbs_gps_geofence.xml @@ -0,0 +1,36 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/introspection/lbs_nmea.xml b/introspection/lbs_nmea.xml index 16ca309..035e3bc 100644 --- a/introspection/lbs_nmea.xml +++ b/introspection/lbs_nmea.xml @@ -1,5 +1,9 @@ + + + + diff --git a/introspection/lbs_position.xml b/introspection/lbs_position.xml index 9978ceb..ca61b52 100644 --- a/introspection/lbs_position.xml +++ b/introspection/lbs_position.xml @@ -1,6 +1,7 @@ + diff --git a/lbs-dbus.pc.in b/lbs-dbus.pc.in old mode 100644 new mode 100755 index 29b91a7..1e4ce9b --- a/lbs-dbus.pc.in +++ b/lbs-dbus.pc.in @@ -1,11 +1,11 @@ prefix=@PREFIX@ -exec_prefix=${prefix} -libdir=${exec_prefix}/lib -includedir=${prefix}/include +exec_prefix=@PREFIX@ +libdir=@LIBDIR@ +includedir=@INCLUDEDIR@ Name: LBS dbus Library Description: LBS dbus library Requires: glib-2.0 gobject-2.0 Version: 0.1 -Libs: -L${libdir} -llbs-dbus -llbs-dbus-server +Libs: -L${libdir} -llbs-dbus -llbs-dbus-server -llbs-agps Cflags: -I${includedir}/lbs-dbus diff --git a/packaging/lbs-dbus.changes b/packaging/lbs-dbus.changes deleted file mode 100644 index 69ab88d..0000000 --- a/packaging/lbs-dbus.changes +++ /dev/null @@ -1,9 +0,0 @@ -* Mon Jul 01 2013 Alexandru Cornea ba0aa6f -- resetting manifest requested domain to floor - -* Fri Jun 28 2013 Patrick McCarty c83f00d -- packaging: remove explicit requires on sys-assert - -* Tue Jun 04 2013 Anas Nashif submit/tizen/20130517.044934@56bc9cf -- Remove hardcoding and fixed build - diff --git a/packaging/lbs-dbus.manifest b/packaging/lbs-dbus.manifest deleted file mode 100644 index 017d22d..0000000 --- a/packaging/lbs-dbus.manifest +++ /dev/null @@ -1,5 +0,0 @@ - - - - - diff --git a/packaging/lbs-dbus.spec b/packaging/lbs-dbus.spec deleted file mode 100644 index 92a760b..0000000 --- a/packaging/lbs-dbus.spec +++ /dev/null @@ -1,68 +0,0 @@ -Name: lbs-dbus -Summary: Dbus interface for Location based service -Version: 0.1.6 -Release: 1 -Group: Location/Service -License: Apache-2.0 -Source0: lbs-dbus-%{version}.tar.gz -Source1001: lbs-dbus.manifest -BuildRequires: cmake -BuildRequires: pkgconfig(glib-2.0) -BuildRequires: pkgconfig(gobject-2.0) -BuildRequires: pkgconfig(dlog) -BuildRequires: pkgconfig(gio-2.0) -BuildRequires: pkgconfig(gio-unix-2.0) -BuildRequires: python -BuildRequires: python-xml -BuildRequires: pkgconfig(libtzplatform-config) - -%description -LBS dbus interface - -%package -n liblbs-dbus -Summary: LBS dbus library -Group: Location/Libraries - -%description -n liblbs-dbus -LBS client API library - -%package -n liblbs-dbus-devel -Summary: Telephony client API (devel) -Group: Development/Location -Requires: liblbs-dbus = %{version}-%{release} - -%description -n liblbs-dbus-devel -LBS client API library (devel) - - -%prep -%setup -q -cp %{SOURCE1001} . - -%build -%cmake . \ --DTZ_SYS_USER_GROUP=%TZ_SYS_USER_GROUP - -make %{?jobs:-j%jobs} - -%install -%make_install - -%post -p /sbin/ldconfig -n liblbs-dbus - -%postun -p /sbin/ldconfig -n liblbs-dbus - - -%files -n liblbs-dbus -%manifest %{name}.manifest -%license LICENSE -%defattr(-,root,root,-) -%{_libdir}/*.so.* -%{_sysconfdir}/dbus-1/system.d/* - -%files -n liblbs-dbus-devel -%manifest %{name}.manifest -%defattr(-,root,root,-) -%{_includedir}/lbs-dbus/*.h -%{_libdir}/pkgconfig/*.pc -%{_libdir}/*.so diff --git a/packaging/liblbs-dbus.changes b/packaging/liblbs-dbus.changes new file mode 100644 index 0000000..184b16c --- /dev/null +++ b/packaging/liblbs-dbus.changes @@ -0,0 +1,125 @@ +[Version] lbs-dbus_0.3.2 +[date] 10 June 2015 +[Title] Code sync with tizen_2.4 +[Developer] Young-Ae Kang + +================================================================================ + +[Version] lbs-dbus_0.1.10-1 +[date] 11 June 2013 +[Title] add SECURE_LOG +[Issue#] NA +[Problem] NA +[Cause] NA +[Solution] NA +[Developer] Genie Kim + +================================================================================ + +[Version] lbs-dbus_0.1.9-1 +[date] 29 May 2013 +[Title] to free XX_call_sync return value, don't free g_variant_builder. +[Issue#] NA +[Problem] NA +[Cause] NA +[Solution] NA +[Developer] Ming Zhu + +================================================================================ + +[Version] lbs-dbus_0.1.8-1 +[date] 22 May 2013 +[Title] lbs_object_get_XX to get gbus object, to fix PLM P130516-0557. +[Issue#] NA +[Problem] NA +[Cause] NA +[Solution] NA +[Developer] Congyi Shi + +================================================================================ + +[Version] lbs-dbus_0.1.7-1 +[date] 13 May 2013 +[Title] Change the DoCoMo location logs saving mechanism. +[Issue#] NA +[Problem] NA +[Cause] NA +[Solution] NA +[Developer] Congyi Shi + +================================================================================ + +[Version] lbs-dbus_0.1.6-1 +[date] 7 May 2013 +[Title] change g_variant from {ss} to {sv} for SUPL NI message +[Issue#] NA +[Problem] NA +[Cause] NA +[Solution] NA +[Developer] Genie Kim + +================================================================================ + +[Version] lbs-dbus_0.1.5-1 +[date] 2 May 2013 +[Title] Add LBS agps library for SUPK NI +[Issue#] NA +[Problem] NA +[Cause] NA +[Solution] NA +[Developer] Genie Kim + +================================================================================ + +[Version] lbs-dbus_0.1.4-1 +[date] 26 Apr 2013 +[Title] Change ProxyCall. +[Issue#] NA +[Problem] NA +[Cause] NA +[Solution] NA +[Developer] Minjune Kim + +================================================================================ + +[Version] lbs-dbus_0.1.3-1 +[date] 1 Apr 2013 +[Title] Add GDbus server side +[Issue#] NA +[Problem] NA +[Cause] NA +[Solution] NA +[Developer] Ming Zhu + +================================================================================ + +[Version] lbs-dbus_0.1.2-1 +[date] 23 Mar 2013 +[Title] Fix a crash when unsubscribing signals +[Issue#] NA +[Problem] NA +[Cause] NA +[Solution] NA +[Developer] Minjune Kim + +================================================================================ + +[Version] lbs-dbus_0.1.1-1 +[date] 19 Mar 2013 +[Title] Fix a crash when timeout +[Issue#] NA +[Problem] NA +[Cause] NA +[Solution] NA +[Developer] Minjune Kim + +================================================================================ + +* Mon Jul 01 2013 Alexandru Cornea ba0aa6f +- resetting manifest requested domain to floor + +* Fri Jun 28 2013 Patrick McCarty c83f00d +- packaging: remove explicit requires on sys-assert + +* Tue Jun 04 2013 Anas Nashif submit/tizen/20130517.044934@56bc9cf +- Remove hardcoding and fixed build diff --git a/liblbs-dbus.manifest b/packaging/liblbs-dbus.manifest similarity index 100% rename from liblbs-dbus.manifest rename to packaging/liblbs-dbus.manifest diff --git a/packaging/liblbs-dbus.spec b/packaging/liblbs-dbus.spec new file mode 100644 index 0000000..8e3e30c --- /dev/null +++ b/packaging/liblbs-dbus.spec @@ -0,0 +1,69 @@ +Name: liblbs-dbus +Summary: DBus interface for Location Based Service +Version: 0.3.2 +Release: 1 +Group: Location/Libraries +License: Apache-2.0 +Source0: %{name}-%{version}.tar.gz +Source1001: %{name}.manifest +Requires(post): /sbin/ldconfig +Requires(postun): /sbin/ldconfig +BuildRequires: cmake +BuildRequires: pkgconfig(glib-2.0) +BuildRequires: pkgconfig(gobject-2.0) +BuildRequires: pkgconfig(dlog) +BuildRequires: pkgconfig(gio-2.0) +BuildRequires: pkgconfig(gio-unix-2.0) +BuildRequires: pkgconfig(capi-appfw-app-manager) +BuildRequires: pkgconfig(capi-appfw-package-manager) +BuildRequires: pkgconfig(pkgmgr-info) + +%description +DBus interface for Location Based Service +The package provides IPC between LBS Server and Location Manager. + +%package devel +Summary: LBS DBus Library (devel) +Group: Location/Development +Requires: %{name} = %{version}-%{release} + +%description devel +LBS DBus Library (devel) +The package includes header files and pkgconfig file of LBS DBus interface. + +%prep +%setup -q +cp %{SOURCE1001} . + +%build +export CFLAGS="$CFLAGS -DTIZEN_DEBUG_ENABLE" +export CXXFLAGS="$CXXFLAGS -DTIZEN_DEBUG_ENABLE" +export FFLAGS="$FFLAGS -DTIZEN_DEBUG_ENABLE" + +export CFLAGS+=" -Wno-unused-local-typedefs " +#cmake . -DCMAKE_INSTALL_PREFIX=%{_prefix} +cmake . -DCMAKE_INSTALL_PREFIX=%{_prefix} -DBUILD_PKGTYPE=rpm -DLIBDIR=%{_libdir} -DINCLUDEDIR=%{_includedir} + +make %{?jobs:-j%jobs} + +%install +rm -rf %{buildroot} +%make_install + +%post -p /sbin/ldconfig + +%postun -p /sbin/ldconfig + + +%files +%manifest %{name}.manifest +%license LICENSE +%defattr(-,root,root,-) +%{_libdir}/*.so.* +%{_prefix}/etc/dbus-1/system.d/* + +%files devel +%defattr(-,root,root,-) +%{_includedir}/lbs-dbus/*.h +%{_libdir}/pkgconfig/*.pc +%{_libdir}/*.so diff --git a/server/CMakeLists.txt b/server/CMakeLists.txt old mode 100644 new mode 100755 index 283d2b3..a701606 --- a/server/CMakeLists.txt +++ b/server/CMakeLists.txt @@ -8,23 +8,20 @@ SET(SRCS_S src/lbs_dbus_server.c ${CMAKE_CURRENT_SOURCE_DIR}/generated-code.c ) -SET(SYSCONFDIR "/etc") MESSAGE(Server_CMAKE_BINARY_DIR: ${CMAKE_BINARY_DIR}) MESSAGE(CMAKE_CURRENT_SOURCE_DIR: ${CMAKE_CURRENT_SOURCE_DIR}) MESSAGE(CMAKE_SOURCE_DIR: ${CMAKE_SOURCE_DIR}) -ADD_CUSTOM_COMMAND( - OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/generated-code.c - COMMAND gdbus-codegen --interface-prefix org.tizen.lbs. --generate-c-code generated-code --c-generate-object-manager --c-namespace Lbs --generate-docbook generated-docs ${CMAKE_SOURCE_DIR}/introspection/lbs.xml ${CMAKE_SOURCE_DIR}/introspection/lbs_position.xml ${CMAKE_SOURCE_DIR}/introspection/lbs_satellite.xml ${CMAKE_SOURCE_DIR}/introspection/lbs_nmea.xml - COMMENT "Generating GDBus .c/.h") - ADD_LIBRARY(lbs-dbus-server SHARED ${SRCS_S}) TARGET_LINK_LIBRARIES(lbs-dbus-server ${pkgs_LDFLAGS}) SET_TARGET_PROPERTIES(lbs-dbus-server PROPERTIES VERSION 0.1.0 SOVERSION 0 OUTPUT_NAME lbs-dbus-server) -CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/res/lbs-dbus-server.conf.in ${CMAKE_CURRENT_SOURCE_DIR}/res/lbs-dbus-server.conf) - -INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/res/lbs-dbus-server.conf DESTINATION ${SYSCONFDIR}/dbus-1/system.d) -INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/include/lbs_dbus_server.h DESTINATION include/lbs-dbus) -INSTALL(TARGETS lbs-dbus-server DESTINATION ${LIB_INSTALL_DIR} COMPONENT Runtime) +INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/res/lbs-dbus-server.conf DESTINATION ${PREFIX}/etc/dbus-1/system.d) +INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/include/lbs_dbus_server.h DESTINATION ${INCLUDEDIR}/lbs-dbus) +INSTALL(TARGETS lbs-dbus-server DESTINATION ${LIBDIR} COMPONENT Runtime) #ADD_SUBDIRECTORY(test_src) + +ADD_CUSTOM_COMMAND( + OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/generated-code.c + COMMAND gdbus-codegen --interface-prefix org.tizen.lbs. --generate-c-code generated-code --c-generate-object-manager --c-namespace Lbs --generate-docbook generated-docs ${CMAKE_SOURCE_DIR}/introspection/lbs.xml ${CMAKE_SOURCE_DIR}/introspection/lbs_position.xml ${CMAKE_SOURCE_DIR}/introspection/lbs_batch.xml ${CMAKE_SOURCE_DIR}/introspection/lbs_satellite.xml ${CMAKE_SOURCE_DIR}/introspection/lbs_nmea.xml ${CMAKE_SOURCE_DIR}/introspection/lbs_gps_geofence.xml + COMMENT "Generating GDBus .c/.h") diff --git a/server/include/lbs_dbus_server.h b/server/include/lbs_dbus_server.h index 5522776..fc076e7 100644 --- a/server/include/lbs_dbus_server.h +++ b/server/include/lbs_dbus_server.h @@ -4,7 +4,7 @@ * Copyright (c) 2013 Samsung Electronics Co., Ltd. All rights reserved. * * Contact: Youngae Kang , Minjune Kim - * Genie Kim , Ming Zhu + * Genie Kim , Ming Zhu * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -26,64 +26,125 @@ __BEGIN_DECLS #include -typedef void (*LbsDbusSetOptionsCB)(GVariant *options, gpointer userdata); -typedef void (*LbsDbusShutdownCB)(gpointer userdata); +typedef void (*LbsDbusSetOptionsCB)(GVariant *options, const gchar *client, gpointer userdata); +typedef void (*LbsDbusShutdownCB)(gpointer userdata, gboolean *shutdown_arr); +typedef enum { + LBS_SERVER_INTERVAL_ADD = 0, + LBS_SERVER_INTERVAL_REMOVE, + LBS_SERVER_INTERVAL_UPDATE, +} lbs_server_interval_manipulation_type; +typedef gboolean(*LbsDbusUpdateIntervalCB)(lbs_server_interval_manipulation_type type, const gchar *client, int method, guint interval, gpointer userdata); +typedef void (*LbsDbusRequestChangeIntervalCB)(int method, gpointer userdata); + +typedef void (*LbsDbusGetNmeaCB)(int *timestamp, gchar **nmea_data, gpointer userdata); + +/* for geofence callbacks */ +typedef gint(*LbsGeofenceAddFenceCB)(const gchar *app_id, + gint geofence_type, + const gchar *name, + gint direction, + gdouble latitude, + gdouble longitude, + gdouble radius, + const gchar *bssid, + gpointer userdata); +typedef void (*LbsGeofenceRemoveFenceCB)(gint fence_id, const gchar *app_id, gpointer userdata); +typedef void (*LbsGeofencePauseFenceCB)(gint fence_id, const gchar *app_id, gpointer userdata); +typedef void (*LbsGeofenceResumeFenceCB)(gint fence_id, const gchar *app_id, gpointer userdata); +typedef void (*LbsGeofenceStartGeofenceCB)(const gchar *app_id, gpointer userdata); +typedef void (*LbsGeofenceStopGeofenceCB)(const gchar *app_id, gpointer userdata); +/* for gps-geofence (H/W geofence) callbacks */ +typedef void (*GpsGeofenceAddFenceCB)(gint fence_id, + gdouble latitude, + gdouble longitude, + gint radius, + gint last_state, + gint monitor_states, + gint notification_responsiveness, + gint unknown_timer, + gpointer userdata); +typedef void (*GpsGeofenceDeleteFenceCB)(gint fence_id, gpointer userdata); +typedef void (*GpsGeofencePauseFenceCB)(gint fence_id, gpointer userdata); +typedef void (*GpsGeofenceResumeFenceCB)(gint fence_id, gint monitor_states, gpointer userdata); typedef enum { - LBS_SERVER_ERROR_NONE = 0x0, - LBS_SERVER_ERROR_UNKNOWN, - LBS_SERVER_ERROR_PARAMETER, - LBS_SERVER_ERROR_MEMORY, - LBS_SERVER_ERROR_CONNECTION, - LBS_SERVER_ERROR_STATUS, - LBS_SERVER_ERROR_DBUS_CALL, - LBS_SERVER_ERROR_NO_RESULT, + LBS_SERVER_ERROR_NONE = 0x0, + LBS_SERVER_ERROR_UNKNOWN, + LBS_SERVER_ERROR_PARAMETER, + LBS_SERVER_ERROR_MEMORY, + LBS_SERVER_ERROR_CONNECTION, + LBS_SERVER_ERROR_STATUS, + LBS_SERVER_ERROR_DBUS_CALL, + LBS_SERVER_ERROR_NO_RESULT, } lbs_server_error_e; typedef void *lbs_server_dbus_h; int lbs_server_emit_position_changed(lbs_server_dbus_h lbs_server, - gint arg_fields, - gint arg_timestamp, - gdouble arg_latitude, - gdouble arg_longitude, - gdouble arg_altitude, - gdouble arg_speed, - gdouble arg_direction, - gdouble arg_climb, - GVariant *arg_accuracy); + gint arg_method, + gint arg_fields, + gint arg_timestamp, + gdouble arg_latitude, + gdouble arg_longitude, + gdouble arg_altitude, + gdouble arg_speed, + gdouble arg_direction, + gdouble arg_climb, + GVariant *arg_accuracy); + +int +lbs_server_emit_batch_changed(lbs_server_dbus_h lbs_server, + gint arg_num_of_location); int lbs_server_emit_satellite_changed(lbs_server_dbus_h lbs_server, - gint arg_timestamp, - gint arg_satellite_used, - gint arg_satellite_visible, - GVariant *arg_used_prn, - GVariant *arg_sat_info); + gint arg_timestamp, + gint arg_satellite_used, + gint arg_satellite_visible, + GVariant *arg_used_prn, + GVariant *arg_sat_info); int lbs_server_emit_nmea_changed(lbs_server_dbus_h lbs_server, - gint arg_timestamp, - const gchar *arg_nmea_data); + gint arg_timestamp, + const gchar *arg_nmea_data); int -lbs_server_emit_status_changed(lbs_server_dbus_h lbs_server, gint status); +lbs_server_emit_status_changed(lbs_server_dbus_h lbs_server, int method, gint status); int -lbs_server_create(char *service_name, - char *service_path, - char *name, - char *description, - lbs_server_dbus_h *lbs_server, - LbsDbusSetOptionsCB set_options_cb, - LbsDbusShutdownCB shutdown_cb, - gpointer userdata); +lbs_server_emit_geofence_status_changed(lbs_server_dbus_h lbs_server, gint status); + +int +lbs_server_emit_geofence_changed(lbs_server_dbus_h lbs_server, const gchar *app_id, gint fence_id, gint fence_state); +int +lbs_server_emit_gps_geofence_status_changed(lbs_server_dbus_h lbs_server, gint status); + +int +lbs_server_emit_gps_geofence_changed(lbs_server_dbus_h lbs_server, gint fence_id, gint transition, gdouble latitude, gdouble longitude, gdouble altitude, gdouble speed, gdouble bearing, gdouble hor_accuracy); + +int +lbs_server_create(char *service_name, + char *service_path, + char *name, + char *description, + lbs_server_dbus_h *lbs_server, + LbsDbusSetOptionsCB set_options_cb, + LbsDbusShutdownCB shutdown_cb, + LbsDbusUpdateIntervalCB update_interval_cb, + LbsDbusRequestChangeIntervalCB request_change_interval_cb, + LbsDbusGetNmeaCB get_nmea_cb, + GpsGeofenceAddFenceCB add_hw_fence_cb, + GpsGeofenceDeleteFenceCB delete_hw_fence_cb, + GpsGeofencePauseFenceCB pause_hw_fence_cb, + GpsGeofenceResumeFenceCB resume_hw_fence_cb, + gpointer userdata); int -lbs_server_destroy (lbs_server_dbus_h lbs_server); +lbs_server_destroy(lbs_server_dbus_h lbs_server); __END_DECLS diff --git a/server/include/lbs_dbus_server_priv.h b/server/include/lbs_dbus_server_priv.h index 452f9e6..07c992c 100644 --- a/server/include/lbs_dbus_server_priv.h +++ b/server/include/lbs_dbus_server_priv.h @@ -4,7 +4,7 @@ * Copyright (c) 2013 Samsung Electronics Co., Ltd. All rights reserved. * * Contact: Youngae Kang , Minjune Kim - * Genie Kim , Ming Zhu + * Genie Kim , Ming Zhu * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -32,10 +32,11 @@ __BEGIN_DECLS #define LOG_TAG "LBS_DBUS_SERVER" #endif -#define LBS_SERVER_LOGI(fmt,args...) { LOGI(fmt, ##args); } -#define LBS_SERVER_LOGD(fmt,args...) { LOGD(fmt, ##args); } -#define LBS_SERVER_LOGW(fmt,args...) { LOGW(fmt, ##args); } -#define LBS_SERVER_LOGE(fmt,args...) { LOGE(fmt, ##args); } +#define LBS_SERVER_LOGI(fmt,args...) { LOGI(fmt, ##args); } +#define LBS_SERVER_LOGD(fmt,args...) { LOGD(fmt, ##args); } +#define LBS_SERVER_LOGW(fmt,args...) { LOGW(fmt, ##args); } +#define LBS_SERVER_LOGE(fmt,args...) { LOGE(fmt, ##args); } +#define LBS_SERVER_SECLOG(fmt,args...) { SECURE_LOGD(fmt, ##args); } #else @@ -43,6 +44,7 @@ __BEGIN_DECLS #define LBS_SERVER_LOGD(fmt,args...) #define LBS_SERVER_LOGW(fmt,args...) #define LBS_SERVER_LOGE(fmt,args...) +#define LBS_SERVER_SECLOG(fmt,args...) #endif diff --git a/server/res/lbs-dbus-server.conf b/server/res/lbs-dbus-server.conf new file mode 100644 index 0000000..3a56b59 --- /dev/null +++ b/server/res/lbs-dbus-server.conf @@ -0,0 +1,124 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/server/res/lbs-dbus-server.conf.in b/server/res/lbs-dbus-server.conf.in deleted file mode 100644 index a9c5323..0000000 --- a/server/res/lbs-dbus-server.conf.in +++ /dev/null @@ -1,96 +0,0 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - diff --git a/server/src/lbs_dbus_server.c b/server/src/lbs_dbus_server.c index 9f75c02..2e1b2b1 100644 --- a/server/src/lbs_dbus_server.c +++ b/server/src/lbs_dbus_server.c @@ -4,7 +4,7 @@ * Copyright (c) 2013 Samsung Electronics Co., Ltd. All rights reserved. * * Contact: Youngae Kang , Minjune Kim - * Genie Kim , Ming Zhu + * Genie Kim , Ming Zhu * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -25,7 +25,6 @@ #include "lbs_dbus_server.h" #include "lbs_dbus_server_priv.h" - typedef struct _lbs_server_dbus_s { /* LBS server dbus info */ gchar *service_name; @@ -40,19 +39,49 @@ typedef struct _lbs_server_dbus_s { LbsDbusSetOptionsCB set_options_cb; LbsDbusShutdownCB shutdown_cb; - gpointer userdata; /* used for save GeoclueGpsManager */ + LbsDbusUpdateIntervalCB update_interval_cb; + LbsDbusRequestChangeIntervalCB request_change_interval_cb; + LbsDbusGetNmeaCB get_nmea_cb; + gpointer userdata; /* used for save GpsManager */ guint owner_changed_id; - LbsManager *lbs_mgr; - LbsPosition *lbs_pos; guint owner_id; guint get_providerinfo_h; guint get_status_h; guint set_option_h; guint add_reference_h; guint remove_reference_h; + guint get_nmea_h; + + /* for geofence */ + guint add_fence_h; + guint remove_fence_h; + guint pause_fence_h; + guint resume_fence_h; + guint start_geofence_h; + guint stop_geofence_h; + gint geofence_status; + + /* for H/W gps-geofence */ + guint add_hw_fence_h; + guint delete_hw_fence_h; + guint pause_hw_fence_h; + guint resume_hw_fence_h; + gint hw_geofence_status; + GpsGeofenceAddFenceCB add_hw_fence_cb; + GpsGeofenceDeleteFenceCB delete_hw_fence_cb; + GpsGeofencePauseFenceCB pause_hw_fence_cb; + GpsGeofenceResumeFenceCB resume_hw_fence_cb; } lbs_server_dbus_s; +typedef enum { + LBS_SERVER_METHOD_GPS = 0, + LBS_SERVER_METHOD_NPS, + LBS_SERVER_METHOD_AGPS, + LBS_SERVER_METHOD_GEOFENCE, + LBS_SERVER_METHOD_SIZE, +} lbs_server_method_e; + static gboolean lbs_dbus_setup_position_interface(LbsObjectSkeleton *object, lbs_server_dbus_s *ctx) { LBS_SERVER_LOGD("lbs_dbus_setup_position_interface"); @@ -62,11 +91,23 @@ static gboolean lbs_dbus_setup_position_interface(LbsObjectSkeleton *object, lbs LbsPosition *position = NULL; position = lbs_position_skeleton_new(); - ctx->lbs_pos = position; lbs_object_skeleton_set_position(object, position); g_object_unref(position); - LBS_SERVER_LOGD("position = %p", position); + return TRUE; +} + +static gboolean lbs_dbus_setup_batch_interface(LbsObjectSkeleton *object, lbs_server_dbus_s *ctx) +{ + LBS_SERVER_LOGD("lbs_dbus_setup_batch_interface"); + if (!object || !ctx) { + return FALSE; + } + + LbsBatch *batch = NULL; + batch = lbs_batch_skeleton_new(); + lbs_object_skeleton_set_batch(object, batch); + g_object_unref(batch); return TRUE; } @@ -83,8 +124,6 @@ static gboolean lbs_dbus_setup_satellite_interface(LbsObjectSkeleton *object, lb lbs_object_skeleton_set_satellite(object, sat); g_object_unref(sat); - LBS_SERVER_LOGD("sat = %p", sat); - return TRUE; } @@ -100,17 +139,29 @@ static gboolean lbs_dbus_setup_nmea_interface(LbsObjectSkeleton *object, lbs_ser lbs_object_skeleton_set_nmea(object, nmea); g_object_unref(nmea); - LBS_SERVER_LOGD("nmea = %p", nmea); - return TRUE; } +static gboolean lbs_dbus_setup_gps_geofence_interface(LbsObjectSkeleton *object, lbs_server_dbus_s *ctx) +{ + LBS_SERVER_LOGD("lbs_dbus_setup_gps_geofence_interface"); + if (!object || !ctx) { + return FALSE; + } + + LbsGpsGeofence *gps_geofence = NULL; + gps_geofence = lbs_gps_geofence_skeleton_new(); + lbs_object_skeleton_set_gps_geofence(object, gps_geofence); + g_object_unref(gps_geofence); + + return TRUE; +} static gboolean -on_manager_getproviderinfo (LbsManager *mgr, - GDBusMethodInvocation *invocation, - gpointer user_data) +on_manager_getproviderinfo(LbsManager *mgr, + GDBusMethodInvocation *invocation, + gpointer user_data) { LBS_SERVER_LOGD("on_manager_getproviderinfo"); lbs_server_dbus_s *ctx = (lbs_server_dbus_s *)user_data; @@ -128,9 +179,9 @@ on_manager_getproviderinfo (LbsManager *mgr, } static gboolean -on_manager_getstatus (LbsManager *mgr, - GDBusMethodInvocation *invocation, - gpointer user_data) +on_manager_getstatus(LbsManager *mgr, + GDBusMethodInvocation *invocation, + gpointer user_data) { LBS_SERVER_LOGD("on_manager_getstatus"); lbs_server_dbus_s *ctx = (lbs_server_dbus_s *)user_data; @@ -144,20 +195,45 @@ on_manager_getstatus (LbsManager *mgr, } static gboolean -on_manager_setoptions (LbsManager *mgr, - GDBusMethodInvocation *invocation, - GVariant *options, - gpointer user_data) +on_nmea_getnmea(LbsNmea *nmea, + GDBusMethodInvocation *invocation, + gpointer user_data) +{ + lbs_server_dbus_s *ctx = (lbs_server_dbus_s *)user_data; + if (!ctx) { + return FALSE; + } + + gint timestamp = 0; + gchar *nmea_data = NULL; + + if (ctx->get_nmea_cb) { + ctx->get_nmea_cb(×tamp, &nmea_data, ctx->userdata); + LBS_SERVER_LOGD("timestmap: %d, nmea_data: %s", timestamp, nmea_data); + } + lbs_nmea_complete_get_nmea(nmea, invocation, timestamp, nmea_data); + g_free(nmea_data); + + return TRUE; +} + +static gboolean +on_manager_setoptions(LbsManager *mgr, + GDBusMethodInvocation *invocation, + GVariant *options, + gpointer user_data) { - LBS_SERVER_LOGD("on_manager_setoptions"); + LBS_SERVER_LOGD("ENTER >>>"); lbs_server_dbus_s *ctx = (lbs_server_dbus_s *)user_data; if (!ctx) { return FALSE; } if (ctx->set_options_cb) { - ctx->set_options_cb(options, ctx->userdata); - LBS_SERVER_LOGD("set_options_cb called"); + const gchar *sender = NULL; + sender = g_dbus_method_invocation_get_sender(invocation); + ctx->set_options_cb(options, sender, ctx->userdata); + LBS_SERVER_LOGD("set_options_cb was called"); } lbs_manager_complete_set_options(mgr, invocation); @@ -166,11 +242,12 @@ on_manager_setoptions (LbsManager *mgr, } static gboolean -on_manager_addreference (LbsManager *mgr, - GDBusMethodInvocation *invocation, - gpointer user_data) +on_manager_addreference(LbsManager *mgr, + GDBusMethodInvocation *invocation, + int method, + gpointer user_data) { - LBS_SERVER_LOGD("on_manager_addreference"); + LBS_SERVER_LOGD("method: %d", method); lbs_server_dbus_s *ctx = (lbs_server_dbus_s *)user_data; if (!ctx) { return FALSE; @@ -178,69 +255,138 @@ on_manager_addreference (LbsManager *mgr, const gchar *sender = NULL; gchar *sender_cp = NULL; - int *pcount = NULL; + int count = 0; /* Update the hash of open connections */ sender = g_dbus_method_invocation_get_sender(invocation); sender_cp = g_strdup(sender); - pcount = g_hash_table_lookup(ctx->connections, sender); - if (!pcount) { - pcount = g_malloc0(sizeof(int)); + + int *count_arr = (int *) g_hash_table_lookup(ctx->connections, sender_cp); + if (!count_arr) { + LBS_SERVER_LOGD("first add for sender %s ", sender_cp); + count_arr = (int *)g_malloc0(LBS_SERVER_METHOD_SIZE * sizeof(int)); + g_return_val_if_fail(count_arr, FALSE); + + g_hash_table_insert(ctx->connections, (gpointer)sender_cp, (gpointer)count_arr); } - (*pcount)++; - g_hash_table_insert(ctx->connections, (gpointer)sender_cp, pcount); - LBS_SERVER_LOGD("sender [%s], pcount [%d] insert into hash table", sender_cp, *pcount); + + count = count_arr[method]; + + LBS_SERVER_LOGD("sender: [%s] method:%d count:%d table:%p", sender_cp, method, count, count_arr); + count++; + + if (count <= 0) { + count = 1; + LBS_SERVER_LOGE("Client reference count set to 1 for sender [%s] of method [%d]", sender_cp, method); + } + + LBS_SERVER_LOGD("sender [%s], method[%d], count [%d] is inserted in hash table", sender_cp, method, count); + + count_arr[method] = count; lbs_manager_complete_add_reference(mgr, invocation); return TRUE; } +static gboolean lbs_find_method(gpointer key, gpointer value, gpointer user_data) +{ + int *ip = (int *) user_data; + int *arr = (int *) value; + int method = *ip; + + LBS_SERVER_LOGD("[%s] lbs_find_method method:%d, count:%d", (char *)key, method, arr[method]); + + return (arr[method] > 0) ? TRUE : FALSE; +} + static gboolean -lbs_server_remove_client (lbs_server_dbus_s *ctx, const char *client) +lbs_server_remove_client(lbs_server_dbus_s *ctx, const char *client, int method) { if (!ctx || !client) { return FALSE; } - int *pcount = NULL; + int count = 0; + int *count_arr = (int *) g_hash_table_lookup(ctx->connections, client); - pcount = g_hash_table_lookup(ctx->connections, client); - if (!pcount) { - LBS_SERVER_LOGD("Client[%s] is already removed", client); + if (!count_arr) { + LBS_SERVER_LOGD("Client[%s] Method[%d] is already removed", client, method); + return FALSE; + } + + count = count_arr[method]; + LBS_SERVER_LOGD("lbs_server_remove_client method:%d count:%d", method, count); + + if (count == 0) { + LBS_SERVER_LOGD("Client[%s] Method[%d] is already removed", client, method); return FALSE; } - (*pcount)--; - LBS_SERVER_LOGD("Client[%s] has reference count[%d]", client, *pcount); - if (*pcount == 0) { - LBS_SERVER_LOGD("Reference count is zero, Now remove client[%s] in hash table", client); - g_hash_table_remove(ctx->connections, client); + + count--; + count_arr[method] = count; + + if (count > 0) { + LBS_SERVER_LOGD("Client[%s] of method[%d] has reference count[%d]", client, method, count); + } else if (count == 0) { + LBS_SERVER_LOGD("Remove [%s : %d] in hash table, ref count is 0", client, method); + + int i = 0, count_each = 0; + for (i = 0; i < LBS_SERVER_METHOD_SIZE; i++) { + count_each = count_arr[i]; + if (count_each != 0) { + LBS_SERVER_LOGD("[%s] method[%d]'s count is not zero - count: %d", client, i, count_each); + return FALSE; + } + } + + if (!g_hash_table_remove(ctx->connections, client)) { + LBS_SERVER_LOGE("g_hash_table_remove is Fail"); + } } + + int index = 0; + gboolean *shutdown_arr = (gboolean *) g_malloc0_n(LBS_SERVER_METHOD_SIZE, sizeof(gboolean)); + g_return_val_if_fail(shutdown_arr, FALSE); + if (g_hash_table_size(ctx->connections) == 0) { - LBS_SERVER_LOGD("Hash table size is zero, Now we shutdown provider[%s]", ctx->name); - if (ctx->shutdown_cb) { - LBS_SERVER_LOGD("shutdown_cb to be called..."); - ctx->shutdown_cb(ctx->userdata); - LBS_SERVER_LOGD("shutdown_cb called..."); + LBS_SERVER_SECLOG("Hash table size is zero, Now shutdown provider[%s]", ctx->name); + + for (; index < LBS_SERVER_METHOD_SIZE; index++) shutdown_arr[index] = TRUE; + } else { + LBS_SERVER_SECLOG("Hash table size is not zero"); + + for (; index < LBS_SERVER_METHOD_SIZE ; index++) { + if (g_hash_table_find(ctx->connections, (GHRFunc)lbs_find_method, &index) == NULL) { + shutdown_arr[index] = TRUE; + continue; + } } } + + if (ctx->shutdown_cb) { + ctx->shutdown_cb(ctx->userdata, shutdown_arr); + LBS_SERVER_LOGD("shutdown_cb called.. gps:%d, nps:%d", + shutdown_arr[LBS_SERVER_METHOD_GPS], shutdown_arr[LBS_SERVER_METHOD_NPS]); + } + + g_free(shutdown_arr); return TRUE; } -static gboolean -on_manager_removereference (LbsManager *mgr, - GDBusMethodInvocation *invocation, - gpointer user_data) +static gboolean on_manager_removereference(LbsManager *mgr, + GDBusMethodInvocation *invocation, + int method, + gpointer user_data) { - LBS_SERVER_LOGD("on_manager_removereference"); + LBS_SERVER_LOGD("on_manager_removereference method:%d", method); lbs_server_dbus_s *ctx = (lbs_server_dbus_s *)user_data; if (!ctx) { return FALSE; } - const gchar *sender = NULL; sender = g_dbus_method_invocation_get_sender(invocation); - if (!lbs_server_remove_client(ctx, sender)) { + if (!lbs_server_remove_client(ctx, sender, method)) { LBS_SERVER_LOGD("Unreffed by client that has not been referenced"); } @@ -249,15 +395,167 @@ on_manager_removereference (LbsManager *mgr, return TRUE; } +/* + * For H/W gps-geofence methods + */ +static gboolean +on_gps_geofence_addfence(LbsGpsGeofence *gps_geofence, + GDBusMethodInvocation *invocation, + gint fence_id, + gdouble latitude, + gdouble longitude, + gint radius, + gint last_state, + gint monitor_states, + gint notification_responsiveness, + gint unknown_timer, + gpointer user_data) +{ + LBS_SERVER_LOGD("on_gps_geofence_addfence"); + + /* call gps-manager's callback, add_hw_fence_cb */ + lbs_server_dbus_s *ctx = (lbs_server_dbus_s *)user_data; + if (!ctx) { + return FALSE; + } + + if (ctx->add_hw_fence_cb) { + ctx->add_hw_fence_cb(fence_id, latitude, longitude, radius, last_state, monitor_states, + notification_responsiveness, unknown_timer, ctx->userdata); + LBS_SERVER_LOGD("add_hw_fence_cb called"); + } + lbs_gps_geofence_complete_add_fence(gps_geofence, invocation); + return TRUE; +} + +static gboolean +on_gps_geofence_deletefence(LbsGpsGeofence *gps_geofence, + GDBusMethodInvocation *invocation, + gint fence_id, + gpointer user_data) +{ + LBS_SERVER_LOGD("on_gps_geofence_deletefence"); + + /* call gps-manager's callback, delete_hw_fence_cb */ + lbs_server_dbus_s *ctx = (lbs_server_dbus_s *)user_data; + if (!ctx) { + return FALSE; + } + + if (ctx->delete_hw_fence_cb) { + ctx->delete_hw_fence_cb(fence_id, ctx->userdata); + LBS_SERVER_LOGD("delete_hw_fence_cb called"); + } + lbs_gps_geofence_complete_delete_fence(gps_geofence, invocation); + return TRUE; +} + +static gboolean +on_gps_geofence_pausefence(LbsGpsGeofence *gps_geofence, + GDBusMethodInvocation *invocation, + gint fence_id, + gpointer user_data) +{ + LBS_SERVER_LOGD("on_gps_geofence_pausefence"); + + /* call gps-manager's callback, pause_hw_fence_cb */ + lbs_server_dbus_s *ctx = (lbs_server_dbus_s *)user_data; + if (!ctx) { + return FALSE; + } + + if (ctx->pause_hw_fence_cb) { + ctx->pause_hw_fence_cb(fence_id, ctx->userdata); + LBS_SERVER_LOGD("pause_hw_fence_cb called"); + } + + lbs_gps_geofence_complete_pause_fence(gps_geofence, invocation); + return TRUE; +} + +static gboolean +on_gps_geofence_resumefence(LbsGpsGeofence *gps_geofence, + GDBusMethodInvocation *invocation, + gint fence_id, + gint monitor_states, + gpointer user_data) +{ + LBS_SERVER_LOGD("on_gps_geofence_resumefence"); + + lbs_server_dbus_s *ctx = (lbs_server_dbus_s *)user_data; + if (!ctx) { + return FALSE; + } + + /* call gps-manager's callback, resume_hw_fence_cb */ + if (ctx->resume_hw_fence_cb) { + ctx->resume_hw_fence_cb(fence_id, monitor_states, ctx->userdata); + LBS_SERVER_LOGD("resume_hw_fence_cb called"); + } + + lbs_gps_geofence_complete_resume_fence(gps_geofence, invocation); + return TRUE; +} + static gboolean lbs_remove_client_by_force(const char *client, void *data) { - LBS_SERVER_LOGD("remove client by force"); + LBS_SERVER_LOGD("remove client by force for client [%s]", client); lbs_server_dbus_s *ctx = (lbs_server_dbus_s *)data; - if (lbs_server_remove_client (ctx, client)) { - LBS_SERVER_LOGD("###### A clinet[%s] is abnormally shut down ########", client); + + int *count_arr = (int *) g_hash_table_lookup(ctx->connections, client); + + if (!count_arr) { + LBS_SERVER_LOGD("Client[%s] is already removed", client); + return FALSE; + } else { + LBS_SERVER_LOGD("[Client: %s]. Remove all clients in hash table", client); + if (!g_hash_table_remove(ctx->connections, client)) { + LBS_SERVER_LOGE("g_hash_table_remove is Fail"); + } + } + + int index = 0; + gboolean *shutdown_arr = (gboolean *) g_malloc0_n(LBS_SERVER_METHOD_SIZE, sizeof(gboolean)); + g_return_val_if_fail(shutdown_arr, FALSE); + + if (g_hash_table_size(ctx->connections) == 0) { + LBS_SERVER_SECLOG("Hash table size is zero, Now shutdown provider[%s]", ctx->name); + + for (; index < LBS_SERVER_METHOD_SIZE; index++) shutdown_arr[index] = TRUE; + } else { + LBS_SERVER_SECLOG("Hash table size is not zero"); + + for (; index < LBS_SERVER_METHOD_SIZE ; index++) { + if (g_hash_table_find(ctx->connections, (GHRFunc)lbs_find_method, &index) == NULL) { + shutdown_arr[index] = TRUE; + continue; + } + } + } + + if (ctx->shutdown_cb) { + ctx->shutdown_cb(ctx->userdata, shutdown_arr); + LBS_SERVER_LOGD("shutdown_cb called.. gps:%d, nps:%d", + shutdown_arr[LBS_SERVER_METHOD_GPS], shutdown_arr[LBS_SERVER_METHOD_NPS]); } + if (ctx->update_interval_cb) { + gboolean is_needed_change_interval = FALSE; + for (index = 0; index < LBS_SERVER_METHOD_SIZE ; index++) { + is_needed_change_interval = ctx->update_interval_cb(LBS_SERVER_INTERVAL_REMOVE, client, index, 0, ctx->userdata); + if (is_needed_change_interval) { + is_needed_change_interval = FALSE; + if (ctx->request_change_interval_cb) + ctx->request_change_interval_cb(index, ctx->userdata); + } + } + + } + + LBS_SERVER_LOGD("###### A client[%s] is abnormally shut down ########", client); + + g_free(shutdown_arr); return TRUE; } @@ -269,7 +567,6 @@ lbs_scan_sender(char *key, char *value, gpointer user_data) gchar *prev_owner = handle->prev_owner; g_return_if_fail(prev_owner); - LBS_SERVER_LOGD("lbs_scan_sender >> key[%s] : prev_owner[%s]\n", key, prev_owner); if (g_strcmp0(prev_owner, key) == 0) { LBS_SERVER_LOGD("disconnected sender name matched, remove client by force!"); lbs_remove_client_by_force(prev_owner, handle); @@ -278,31 +575,28 @@ lbs_scan_sender(char *key, char *value, gpointer user_data) static void on_name_owner_changed(GDBusConnection *connection, - const gchar *sender_name, - const gchar *object_path, - const gchar *interface_name, - const gchar *signal_name, - GVariant *parameters, /* 1. service name 2. prev_owner 3. new_owner */ - gpointer user_data) + const gchar *sender_name, + const gchar *object_path, + const gchar *interface_name, + const gchar *signal_name, + GVariant *parameters, /* 1. service name 2. prev_owner 3. new_owner */ + gpointer user_data) { lbs_server_dbus_s *handle = (lbs_server_dbus_s *)user_data; g_return_if_fail(handle); - LBS_SERVER_LOGD("on_name_owner_changed: sender_name[%s], object_path[%s], interface_name[%s]", - sender_name, object_path, interface_name); - gchar *service_name = NULL, *prev_owner = NULL, *new_owner = NULL; - g_variant_get (parameters, "(&s&s&s)", &service_name, &prev_owner, &new_owner); - LBS_SERVER_LOGD("service_name %s, prev_owner %s, new_owner %s", service_name, prev_owner, new_owner); + g_variant_get(parameters, "(&s&s&s)", &service_name, &prev_owner, &new_owner); - if (g_strcmp0 (object_path, "/org/freedesktop/DBus") != 0 || - g_strcmp0 (interface_name, "org.freedesktop.DBus") != 0 || - g_strcmp0 (sender_name, "org.freedesktop.DBus") != 0) { + if (g_strcmp0(object_path, "/org/freedesktop/DBus") != 0 || + g_strcmp0(interface_name, "org.freedesktop.DBus") != 0 || + g_strcmp0(sender_name, "org.freedesktop.DBus") != 0) { goto out; } /* if the prev_owner matches the sender name, then remote sender(client) is crashed */ - if (g_strcmp0 (new_owner, "") == 0 && (prev_owner != NULL && strlen(prev_owner) > 0) && handle->connections != NULL) { + if (g_strcmp0(new_owner, "") == 0 && (prev_owner != NULL && strlen(prev_owner) > 0) + && handle->connections != NULL) { if (handle->prev_owner) { g_free(handle->prev_owner); handle->prev_owner = NULL; @@ -312,7 +606,7 @@ on_name_owner_changed(GDBusConnection *connection, } out: - ; + ; } static void on_bus_acquired(GDBusConnection *conn, const gchar *name, gpointer user_data) @@ -329,205 +623,342 @@ static void on_bus_acquired(GDBusConnection *conn, const gchar *name, gpointer u LBS_SERVER_LOGD("dbus registered"); /* create object for each interfaces*/ - path = g_strdup_printf ("%s/%s", ctx->service_path, "SAMSUNG"); + path = g_strdup_printf("%s/%s", ctx->service_path, "SAMSUNG"); object = lbs_object_skeleton_new(path); ctx->obj_skeleton = object; - LBS_SERVER_LOGD("object path [%s], obj_skeleton [%p]", path, ctx->obj_skeleton); + if (NULL != path) { + LBS_SERVER_LOGD("object path [%s], obj_skeleton [%p]", path, ctx->obj_skeleton); + g_free(path); + path = NULL; + } lbs_dbus_setup_position_interface(object, ctx); + lbs_dbus_setup_batch_interface(object, ctx); lbs_dbus_setup_satellite_interface(object, ctx); lbs_dbus_setup_nmea_interface(object, ctx); + + /* add H/W gps-geofence interface */ + lbs_dbus_setup_gps_geofence_interface(object, ctx); g_dbus_object_manager_server_export(ctx->manager, G_DBUS_OBJECT_SKELETON(object)); /* Add interface to default object path */ mgr = lbs_manager_skeleton_new(); - ctx->lbs_mgr = mgr; - LBS_SERVER_LOGD("mgr = %p", mgr); - - ctx->get_providerinfo_h = g_signal_connect (mgr, - "handle-get-provider-info", - G_CALLBACK (on_manager_getproviderinfo), - ctx); /* user_data */ - ctx->get_status_h = g_signal_connect (mgr, - "handle-get-status", - G_CALLBACK (on_manager_getstatus), - ctx); /* user_data */ - ctx->set_option_h = g_signal_connect (mgr, - "handle-set-options", - G_CALLBACK (on_manager_setoptions), - ctx); /* user_data */ - ctx->add_reference_h = g_signal_connect (mgr, - "handle-add-reference", - G_CALLBACK (on_manager_addreference), - ctx); /* user_data */ - ctx->remove_reference_h = g_signal_connect (mgr, - "handle-remove-reference", - G_CALLBACK (on_manager_removereference), - ctx); /* user_data */ - - ctx->owner_changed_id = g_dbus_connection_signal_subscribe (conn, - "org.freedesktop.DBus", - "org.freedesktop.DBus", - "NameOwnerChanged", - "/org/freedesktop/DBus", - NULL, - G_DBUS_SIGNAL_FLAGS_NONE, - on_name_owner_changed, - ctx, - NULL); + + ctx->get_providerinfo_h = g_signal_connect(mgr, + "handle-get-provider-info", + G_CALLBACK(on_manager_getproviderinfo), + ctx); /* user_data */ + ctx->get_status_h = g_signal_connect(mgr, + "handle-get-status", + G_CALLBACK(on_manager_getstatus), + ctx); /* user_data */ + if (ctx->set_options_cb != NULL) { + ctx->set_option_h = g_signal_connect(mgr, + "handle-set-options", + G_CALLBACK(on_manager_setoptions), + ctx); /* user_data */ + } + ctx->add_reference_h = g_signal_connect(mgr, + "handle-add-reference", + G_CALLBACK(on_manager_addreference), + ctx); /* user_data */ + if (ctx->shutdown_cb) { + ctx->remove_reference_h = g_signal_connect(mgr, + "handle-remove-reference", + G_CALLBACK(on_manager_removereference), + ctx); /* user_data */ + } + + /* Add interface for nmea method*/ + LbsNmea *nmea = NULL; + nmea = lbs_nmea_skeleton_new(); + ctx->get_nmea_h = g_signal_connect(nmea, + "handle-get-nmea", + G_CALLBACK(on_nmea_getnmea), + ctx); /* user_data */ + + /* register callback for each methods for H/W gps-geofence */ + LbsGpsGeofence *gps_geofence = NULL; + gps_geofence = lbs_object_get_gps_geofence(LBS_OBJECT(ctx->obj_skeleton)); + g_return_if_fail(gps_geofence); + if (ctx->add_hw_fence_cb) { + ctx->add_hw_fence_h = g_signal_connect(gps_geofence, + "handle-add-fence", + G_CALLBACK(on_gps_geofence_addfence), + ctx); /* user_data */ + } + if (ctx->delete_hw_fence_cb) { + ctx->delete_hw_fence_h = g_signal_connect(gps_geofence, + "handle-delete-fence", + G_CALLBACK(on_gps_geofence_deletefence), + ctx); /* user_data */ + } + if (ctx->pause_hw_fence_cb) { + ctx->pause_hw_fence_h = g_signal_connect(gps_geofence, + "handle-pause-fence", + G_CALLBACK(on_gps_geofence_pausefence), + ctx); /* user_data */ + } + if (ctx->resume_hw_fence_cb) { + ctx->resume_hw_fence_h = g_signal_connect(gps_geofence, + "handle-resume-fence", + G_CALLBACK(on_gps_geofence_resumefence), + ctx); /* user_data */ + } + g_object_unref(gps_geofence); + + ctx->owner_changed_id = g_dbus_connection_signal_subscribe(conn, + "org.freedesktop.DBus", + "org.freedesktop.DBus", + "NameOwnerChanged", + "/org/freedesktop/DBus", + NULL, + G_DBUS_SIGNAL_FLAGS_NONE, + on_name_owner_changed, + ctx, + NULL); g_dbus_interface_skeleton_export(G_DBUS_INTERFACE_SKELETON(mgr), conn, ctx->service_path, NULL); + g_dbus_interface_skeleton_export(G_DBUS_INTERFACE_SKELETON(nmea), conn, ctx->service_path, NULL); + /* g_dbus_interface_skeleton_export(G_DBUS_INTERFACE_SKELETON(nmea), conn, path, NULL); */ - g_dbus_object_manager_server_set_connection (ctx->manager, conn); + g_dbus_object_manager_server_set_connection(ctx->manager, conn); LBS_SERVER_LOGD("done to acquire the dbus"); } static void on_name_acquired(GDBusConnection *connection, - const gchar *name, - gpointer user_data) + const gchar *name, + gpointer user_data) { - LBS_SERVER_LOGD("LBS Server: Acquired the name <%s> on the system bus", name); + LBS_SERVER_SECLOG("LBS Server: Acquired the name <%s> on the system bus", name); } static void on_name_lost(GDBusConnection *connection, - const gchar *name, - gpointer user_data) + const gchar *name, + gpointer user_data) { - LBS_SERVER_LOGD("LBS Server: Lost the name <%s> on the system bus", name); + LBS_SERVER_SECLOG("LBS Server: Lost the name <%s> on the system bus", name); } EXPORT_API int lbs_server_emit_position_changed(lbs_server_dbus_h lbs_server, - gint arg_fields, - gint arg_timestamp, - gdouble arg_latitude, - gdouble arg_longitude, - gdouble arg_altitude, - gdouble arg_speed, - gdouble arg_direction, - gdouble arg_climb, - GVariant *arg_accuracy) -{ - LBS_SERVER_LOGD("lbs_server_emit_position_changed"); + gint arg_method, + gint arg_fields, + gint arg_timestamp, + gdouble arg_latitude, + gdouble arg_longitude, + gdouble arg_altitude, + gdouble arg_speed, + gdouble arg_direction, + gdouble arg_climb, + GVariant *arg_accuracy) +{ + LBS_SERVER_LOGD("method:%d", arg_method); g_return_val_if_fail(lbs_server, LBS_SERVER_ERROR_PARAMETER); + g_return_val_if_fail(arg_accuracy, LBS_SERVER_ERROR_PARAMETER); lbs_server_dbus_s *handle = (lbs_server_dbus_s *)lbs_server; g_return_val_if_fail(handle->obj_skeleton, LBS_SERVER_ERROR_PARAMETER); - g_return_val_if_fail(handle->lbs_pos, LBS_SERVER_ERROR_PARAMETER); - LBS_SERVER_LOGD("lbs_pos = %p", handle->lbs_pos); + LbsPosition *lbs_pos = NULL; + lbs_pos = lbs_object_get_position(LBS_OBJECT(handle->obj_skeleton)); + g_return_val_if_fail(lbs_pos, LBS_SERVER_ERROR_PARAMETER); + + lbs_position_emit_position_changed(lbs_pos, + arg_method, + arg_fields, + arg_timestamp, + arg_latitude, + arg_longitude, + arg_altitude, + arg_speed, + arg_direction, + arg_climb, + arg_accuracy); - lbs_position_emit_position_changed(handle->lbs_pos, - arg_fields, - arg_timestamp, - arg_latitude, - arg_longitude, - arg_altitude, - arg_speed, - arg_direction, - arg_climb, - arg_accuracy); + g_object_unref(lbs_pos); return LBS_SERVER_ERROR_NONE; } EXPORT_API int +lbs_server_emit_batch_changed(lbs_server_dbus_h lbs_server, + gint arg_num_of_location) +{ + g_return_val_if_fail(lbs_server, LBS_SERVER_ERROR_PARAMETER); + + lbs_server_dbus_s *handle = (lbs_server_dbus_s *)lbs_server; + g_return_val_if_fail(handle->obj_skeleton, LBS_SERVER_ERROR_PARAMETER); + + LbsBatch *lbs_batch = NULL; + lbs_batch = lbs_object_get_batch(LBS_OBJECT(handle->obj_skeleton)); + g_return_val_if_fail(lbs_batch, LBS_SERVER_ERROR_PARAMETER); + + lbs_batch_emit_batch_changed(lbs_batch, + arg_num_of_location); + + g_object_unref(lbs_batch); + + return LBS_SERVER_ERROR_NONE; +} + +EXPORT_API int lbs_server_emit_satellite_changed(lbs_server_dbus_h lbs_server, - gint arg_timestamp, - gint arg_satellite_used, - gint arg_satellite_visible, - GVariant *arg_used_prn, - GVariant *arg_sat_info) + gint arg_timestamp, + gint arg_satellite_used, + gint arg_satellite_visible, + GVariant *arg_used_prn, + GVariant *arg_sat_info) { - LBS_SERVER_LOGD("lbs_server_emit_satellite_changed"); g_return_val_if_fail(lbs_server, LBS_SERVER_ERROR_PARAMETER); + g_return_val_if_fail(arg_used_prn, LBS_SERVER_ERROR_PARAMETER); + g_return_val_if_fail(arg_sat_info, LBS_SERVER_ERROR_PARAMETER); lbs_server_dbus_s *handle = (lbs_server_dbus_s *)lbs_server; g_return_val_if_fail(handle->obj_skeleton, LBS_SERVER_ERROR_PARAMETER); LbsSatellite *sat = NULL; - sat = lbs_object_peek_satellite(LBS_OBJECT(handle->obj_skeleton)); - LBS_SERVER_LOGD("sat = %p", sat); - - lbs_satellite_emit_satellite_changed (sat, - arg_timestamp, - arg_satellite_used, - arg_satellite_visible, - arg_used_prn, - arg_sat_info); + sat = lbs_object_get_satellite(LBS_OBJECT(handle->obj_skeleton)); + g_return_val_if_fail(sat, LBS_SERVER_ERROR_PARAMETER); + + lbs_satellite_emit_satellite_changed(sat, + arg_timestamp, + arg_satellite_used, + arg_satellite_visible, + arg_used_prn, + arg_sat_info); + g_object_unref(sat); return LBS_SERVER_ERROR_NONE; } EXPORT_API int lbs_server_emit_nmea_changed(lbs_server_dbus_h lbs_server, - gint arg_timestamp, - const gchar *arg_nmea_data) + gint arg_timestamp, + const gchar *arg_nmea_data) { - LBS_SERVER_LOGD("lbs_server_emit_nmea_changed"); + LBS_SERVER_LOGW("timestamp: %d, nmea_data: %s", arg_timestamp, arg_nmea_data); + g_return_val_if_fail(lbs_server, LBS_SERVER_ERROR_PARAMETER); + g_return_val_if_fail(arg_nmea_data, LBS_SERVER_ERROR_PARAMETER); lbs_server_dbus_s *handle = (lbs_server_dbus_s *)lbs_server; g_return_val_if_fail(handle->obj_skeleton, LBS_SERVER_ERROR_PARAMETER); LbsNmea *nmea = NULL; - nmea = lbs_object_peek_nmea(LBS_OBJECT(handle->obj_skeleton)); - LBS_SERVER_LOGD("nmea = %p", nmea); + nmea = lbs_object_get_nmea(LBS_OBJECT(handle->obj_skeleton)); + g_return_val_if_fail(nmea, LBS_SERVER_ERROR_PARAMETER); lbs_nmea_emit_nmea_changed(nmea, arg_timestamp, arg_nmea_data); + g_object_unref(nmea); return LBS_SERVER_ERROR_NONE; +} + +EXPORT_API int +lbs_server_emit_status_changed(lbs_server_dbus_h lbs_server, int method, gint status) +{ + LBS_SERVER_LOGD("method: %d, status: %d", method, status); + g_return_val_if_fail(lbs_server, LBS_SERVER_ERROR_PARAMETER); + + lbs_server_dbus_s *handle = (lbs_server_dbus_s *)lbs_server; + g_return_val_if_fail(handle->obj_skeleton, LBS_SERVER_ERROR_PARAMETER); + + LbsManager *lbs_mgr = NULL; + lbs_mgr = lbs_object_get_manager(LBS_OBJECT(handle->obj_skeleton)); + g_return_val_if_fail(lbs_mgr, LBS_SERVER_ERROR_PARAMETER); + + handle->status = status; + lbs_manager_emit_status_changed(lbs_mgr, method, status); + g_object_unref(lbs_mgr); + return LBS_SERVER_ERROR_NONE; } +/* gps-manager -> geofence-manager : enable/disable */ +EXPORT_API int +lbs_server_emit_gps_geofence_status_changed(lbs_server_dbus_h lbs_server, gint status) +{ + LBS_SERVER_LOGD("ENTER >>>"); + g_return_val_if_fail(lbs_server, LBS_SERVER_ERROR_PARAMETER); + + lbs_server_dbus_s *handle = (lbs_server_dbus_s *)lbs_server; + g_return_val_if_fail(handle->obj_skeleton, LBS_SERVER_ERROR_PARAMETER); + + LbsGpsGeofence *gps_geofence = NULL; + gps_geofence = lbs_object_get_gps_geofence(LBS_OBJECT(handle->obj_skeleton)); + g_return_val_if_fail(gps_geofence, LBS_SERVER_ERROR_PARAMETER); + handle->hw_geofence_status = status; + lbs_gps_geofence_emit_status_changed(gps_geofence, status); + g_object_unref(gps_geofence); + return LBS_SERVER_ERROR_NONE; +} + +/* gps-manager -> geofence-manger: fence in/out */ EXPORT_API int -lbs_server_emit_status_changed(lbs_server_dbus_h lbs_server, gint status) +lbs_server_emit_gps_geofence_changed(lbs_server_dbus_h lbs_server, gint fence_id, gint transition, gdouble latitude, gdouble longitude, gdouble altitude, gdouble speed, gdouble bearing, gdouble hor_accuracy) { - LBS_SERVER_LOGD("lbs_server_emit_status_changed"); + LBS_SERVER_LOGD("ENTER >>>"); g_return_val_if_fail(lbs_server, LBS_SERVER_ERROR_PARAMETER); lbs_server_dbus_s *handle = (lbs_server_dbus_s *)lbs_server; g_return_val_if_fail(handle->obj_skeleton, LBS_SERVER_ERROR_PARAMETER); - g_return_val_if_fail(handle->lbs_mgr, LBS_SERVER_ERROR_PARAMETER); - LBS_SERVER_LOGD("lbs_mgr = %p", handle->lbs_mgr); + LbsGpsGeofence *gps_geofence = NULL; + gps_geofence = lbs_object_get_gps_geofence(LBS_OBJECT(handle->obj_skeleton)); + g_return_val_if_fail(gps_geofence, LBS_SERVER_ERROR_PARAMETER); - handle->status = status; - lbs_manager_emit_status_changed(handle->lbs_mgr, status); + lbs_gps_geofence_emit_geofence_changed(gps_geofence, fence_id, transition, latitude, longitude, altitude, speed, bearing, hor_accuracy); + g_object_unref(gps_geofence); return LBS_SERVER_ERROR_NONE; } +static void _glib_log(const gchar *log_domain, GLogLevelFlags log_level, + const gchar *msg, gpointer user_data) +{ + LBS_SERVER_LOGD("GLIB[%d]: %s", log_level, msg); +} + EXPORT_API int lbs_server_create(char *service_name, - char *service_path, - char *name, - char *description, - lbs_server_dbus_h *lbs_server, - LbsDbusSetOptionsCB set_options_cb, - LbsDbusShutdownCB shutdown_cb, - gpointer userdata) -{ - LBS_SERVER_LOGD("lbs_server_create"); - g_return_val_if_fail (service_name, LBS_SERVER_ERROR_PARAMETER); - g_return_val_if_fail (service_path, LBS_SERVER_ERROR_PARAMETER); - g_return_val_if_fail (lbs_server, LBS_SERVER_ERROR_PARAMETER); + char *service_path, + char *name, + char *description, + lbs_server_dbus_h *lbs_server, + LbsDbusSetOptionsCB set_options_cb, + LbsDbusShutdownCB shutdown_cb, + LbsDbusUpdateIntervalCB update_interval_cb, + LbsDbusRequestChangeIntervalCB request_change_interval_cb, + LbsDbusGetNmeaCB get_nmea_cb, + GpsGeofenceAddFenceCB add_hw_fence_cb, + GpsGeofenceDeleteFenceCB delete_hw_fence_cb, + GpsGeofencePauseFenceCB pause_hw_fence_cb, + GpsGeofenceResumeFenceCB resume_hw_fence_cb, + gpointer userdata) + +{ + LBS_SERVER_LOGD("ENTER >>>"); + g_return_val_if_fail(service_name, LBS_SERVER_ERROR_PARAMETER); + g_return_val_if_fail(service_path, LBS_SERVER_ERROR_PARAMETER); + g_return_val_if_fail(lbs_server, LBS_SERVER_ERROR_PARAMETER); int ret = LBS_SERVER_ERROR_NONE; lbs_server_dbus_s *server = g_new0(lbs_server_dbus_s, 1); - g_return_val_if_fail (server, LBS_SERVER_ERROR_MEMORY); + g_return_val_if_fail(server, LBS_SERVER_ERROR_MEMORY); + + g_log_set_default_handler(_glib_log, NULL); server->service_name = g_strdup(service_name); server->service_path = g_strdup(service_path); server->manager = g_dbus_object_manager_server_new(server->service_path); - LBS_SERVER_LOGD("server->manager (%p)", server->manager); if (name) { server->name = g_strdup(name); @@ -540,15 +971,24 @@ lbs_server_create(char *service_name, server->userdata = userdata; server->set_options_cb = set_options_cb; server->shutdown_cb = shutdown_cb; + server->update_interval_cb = update_interval_cb; + server->request_change_interval_cb = request_change_interval_cb; + server->get_nmea_cb = get_nmea_cb; + + /* add H/W gps-gefence callbacks */ + server->add_hw_fence_cb = add_hw_fence_cb; + server->delete_hw_fence_cb = delete_hw_fence_cb; + server->pause_hw_fence_cb = pause_hw_fence_cb; + server->resume_hw_fence_cb = resume_hw_fence_cb; server->owner_id = g_bus_own_name(G_BUS_TYPE_SYSTEM, - service_name, - G_BUS_NAME_OWNER_FLAGS_REPLACE, - on_bus_acquired, - on_name_acquired, - on_name_lost, - server, - NULL); + service_name, + G_BUS_NAME_OWNER_FLAGS_REPLACE, + on_bus_acquired, + on_name_acquired, + on_name_lost, + server, + NULL); LBS_SERVER_LOGD("g_bus_own_name id=[%d]", server->owner_id); @@ -557,10 +997,11 @@ lbs_server_create(char *service_name, return ret; } + EXPORT_API int -lbs_server_destroy (lbs_server_dbus_h lbs_server) +lbs_server_destroy(lbs_server_dbus_h lbs_server) { - LBS_SERVER_LOGD("lbs_server_destroy"); + LBS_SERVER_LOGD("ENTER >>>"); g_return_val_if_fail(lbs_server, LBS_SERVER_ERROR_PARAMETER); lbs_server_dbus_s *handle = (lbs_server_dbus_s *)lbs_server; @@ -573,42 +1014,76 @@ lbs_server_destroy (lbs_server_dbus_h lbs_server) g_free(handle->prev_owner); handle->prev_owner = NULL; } - if (handle->service_path) { - g_free(handle->service_path); - handle->service_path = NULL; - } - if (handle->service_name) { - g_free(handle->service_name); - handle->service_name = NULL; - } - + + LbsManager *lbs_mgr = NULL; + lbs_mgr = lbs_object_get_manager(LBS_OBJECT(handle->obj_skeleton)); + g_return_val_if_fail(lbs_mgr, LBS_SERVER_ERROR_PARAMETER); + if (handle->get_providerinfo_h) { - g_signal_handler_disconnect (handle->lbs_mgr, handle->get_providerinfo_h); + g_signal_handler_disconnect(lbs_mgr, handle->get_providerinfo_h); handle->get_providerinfo_h = 0; } if (handle->get_status_h) { - g_signal_handler_disconnect (handle->lbs_mgr, handle->get_status_h); + g_signal_handler_disconnect(lbs_mgr, handle->get_status_h); handle->get_status_h = 0; } if (handle->set_option_h) { - g_signal_handler_disconnect (handle->lbs_mgr, handle->set_option_h); + g_signal_handler_disconnect(lbs_mgr, handle->set_option_h); handle->set_option_h = 0; } if (handle->add_reference_h) { - g_signal_handler_disconnect (handle->lbs_mgr, handle->add_reference_h); + g_signal_handler_disconnect(lbs_mgr, handle->add_reference_h); handle->add_reference_h = 0; } if (handle->remove_reference_h) { - g_signal_handler_disconnect (handle->lbs_mgr, handle->remove_reference_h); + g_signal_handler_disconnect(lbs_mgr, handle->remove_reference_h); handle->remove_reference_h = 0; } + g_object_unref(lbs_mgr); + + LbsNmea *nmea = NULL; + nmea = lbs_object_get_nmea(LBS_OBJECT(handle->obj_skeleton)); + g_return_val_if_fail(nmea, LBS_SERVER_ERROR_PARAMETER); + + if (handle->get_nmea_h) { + g_signal_handler_disconnect(nmea, handle->get_nmea_h); + handle->get_nmea_h = 0; + } + g_object_unref(nmea); + + /* disconnect H/W gps-geofence callbacks */ + LbsGpsGeofence *gps_geofence = NULL; + gps_geofence = lbs_object_get_gps_geofence(LBS_OBJECT(handle->obj_skeleton)); + g_return_val_if_fail(gps_geofence, LBS_SERVER_ERROR_PARAMETER); + + if (handle->add_hw_fence_h) { + g_signal_handler_disconnect(gps_geofence, handle->add_hw_fence_h); + handle->add_hw_fence_h = 0; + } + + if (handle->delete_hw_fence_h) { + g_signal_handler_disconnect(gps_geofence, handle->delete_hw_fence_h); + handle->delete_hw_fence_h = 0; + } + + if (handle->pause_hw_fence_h) { + g_signal_handler_disconnect(gps_geofence, handle->pause_hw_fence_h); + handle->pause_hw_fence_h = 0; + } + + if (handle->resume_hw_fence_h) { + g_signal_handler_disconnect(gps_geofence, handle->resume_hw_fence_h); + handle->resume_hw_fence_h = 0; + } + + g_object_unref(gps_geofence); if (handle->manager) { - if(handle->owner_changed_id) { + if (handle->owner_changed_id) { g_dbus_connection_signal_unsubscribe(g_dbus_object_manager_server_get_connection(handle->manager), handle->owner_changed_id); handle->owner_changed_id = 0; }