SET(PREFIX ${CMAKE_INSTALL_PREFIX})
SET(EXEC_PREFIX "\${prefix}")
-SET(LIBDIR ${LIBDIR})
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 capi-appfw-app-manager capi-appfw-package-manager pkgmgr-info)
+pkg_check_modules(pkgs REQUIRED glib-2.0 gio-2.0 gthread-2.0 dlog gobject-2.0 gio-unix-2.0)
FOREACH(flag ${pkgs_CFLAGS})
SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}")
ADD_DEFINITIONS("-DFEATURE_DLOG_DEBUG")
ADD_DEFINITIONS("-DPREFIX=\"${CMAKE_INSTALL_PREFIX}\"")
-ADD_DEFINITIONS("-DLIBDIR=\"${LIBDIR}\"")
ADD_DEFINITIONS(" -DEXPORT_API=\"__attribute__((visibility(\\\"default\\\")))\" ")
IF ( ENABLE_DOCOMO_LOCATION )
prefix=@PREFIX@
exec_prefix=${prefix}
-libdir=${exec_prefix}/lib
+libdir=@LIBDIR@
includedir=${prefix}/include
Name: GEOFENCE dbus Library
__BEGIN_DECLS
#include <gio/gio.h>
+#include <tizen_error.h>
+
typedef enum {
- GEOFENCE_STATUS_CB = 0x01,
- GEOFENCE_INOUT_CB = GEOFENCE_STATUS_CB << 0x01,
+ GEOFENCE_STATUS_CB = 0x01,
+ GEOFENCE_INOUT_CB = GEOFENCE_STATUS_CB << 0x01,
} geofence_client_callback_e;
typedef enum {
- GEOFENCE_CLIENT_ERROR_NONE = 0x0,
- GEOFENCE_CLIENT_ERROR_UNKNOWN,
- GEOFENCE_CLIENT_ERROR_PARAMETER,
- GEOFENCE_CLIENT_ERROR_MEMORY,
- GEOFENCE_CLIENT_ERROR_CONNECTION,
- GEOFENCE_CLIENT_ERROR_STATUS,
- GEOFENCE_CLIENT_ERROR_DBUS_CALL,
- GEOFENCE_CLIENT_ERROR_NO_RESULT,
- GEOFENCE_CLIENT_ACCESS_DENIED
+ GEOFENCE_CLIENT_ERROR_NONE = 0x0,
+ GEOFENCE_CLIENT_ERROR_PARAMETER = TIZEN_ERROR_INVALID_PARAMETER,
+ GEOFENCE_CLIENT_ERROR_MEMORY = TIZEN_ERROR_OUT_OF_MEMORY,
+ GEOFENCE_CLIENT_ACCESS_DENIED = TIZEN_ERROR_PERMISSION_DENIED,
+ GEOFENCE_CLIENT_ERROR_CONNECTION = TIZEN_ERROR_GEOFENCE_MANAGER | 0x01,
+ GEOFENCE_CLIENT_ERROR_DBUS_CALL = TIZEN_ERROR_GEOFENCE_MANAGER | 0x06,
} geofence_client_error_e;
typedef void *geofence_client_dbus_h;
/**
-* @brief Callback registered by the client to get the callback for the geofence in/out status
+* @brief Callback registered by the client to get the callback for the geofence in/out status
*/
-typedef void (*geofence_client_cb) (const char *sig, GVariant *param, void *user_data);
+typedef void (*geofence_client_cb)(const char *sig, GVariant *param, void *user_data);
+#if 0
/**
-* @brief Callback registered by the client to get the callback for the geofence event status
+* @brief Callback registered by the client to get the callback for the geofence event status
*/
-typedef void (*geofence_client_event_cb) (const char *sig, GVariant *param, void *user_data);
+typedef void (*geofence_client_event_cb)(const char *sig, GVariant *param, void *user_data);
+#endif
/**
* @brief API to add the geofence. This will call the server API.
* @param[in] geofence_client - Client dbus handle
+* @param[in] app_id - Caller's application ID
* @param[in] latitude - latitude value if is a geopoint geofence
* @param[in] longitude - longitude value if it is a geopint geofence
* @param[in] radius - radius value if it is a geopoint geofence
* @retval returns the fence-id of the geofence added
* @see geo_client_delete_geofence
*/
-int geo_client_add_geofence(geofence_client_dbus_h geofence_client, gint place_id, gint geofence_type, gdouble latitude, gdouble longitude, gint radius, const gchar *address, const gchar *bssid, const gchar *ssid);
+int geo_client_add_geofence(geofence_client_dbus_h geofence_client, gchar *app_id, gint place_id, gint geofence_type, gdouble latitude, gdouble longitude, gint radius, const gchar *address, const gchar *bssid, const gchar *ssid);
/**
* @brief API to add the place. This will call the server API
* @param[in] geofence_client - Client dbus handle
+* @param[in] app_id - Caller's application ID
* @param[in] place_name - Name of the place
* retval returns the place_id of the place added
* @see geo_client_delete_place
*/
-int geo_client_add_place(geofence_client_dbus_h geofence_client, const gchar *place_name);
-
-/**
-* @brief API to enable the geofence. This will call the server API
-* @param[in] geofence_client - Client dbus handle
-* @param[in] fence_id - Unique id of the fence
-* @param[in] bEnable - enable flag for geofence
-*/
-int geo_client_enable_service(geofence_client_dbus_h geofence_client, gint geofence_id, gboolean bEnable);
+int geo_client_add_place(geofence_client_dbus_h geofence_client, gchar *appid, const gchar *place_name);
/**
* @brief API to update the place. This will call the server API
* @param[in] geofence_client - Client dbus handle
+* @param[in] app_id - Caller's application ID
* @param[in] place_id - Unique id of the place
* @param[in] place_name - Name of the place[may be a new value]
* @return int
GEOFENCE_CLIENT_ERROR_DBUS_CALL if failure
* @see geo_client_add_place
*/
-int geo_client_update_place(geofence_client_dbus_h geofence_client, gint place_id, const gchar *place_name);
+int geo_client_update_place(geofence_client_dbus_h geofence_client, gchar *app_id, gint place_id, const gchar *place_name);
/**
* @brief API to delete the geofence from the server
* @param[in] geofence_client - Client dbus handle
+* @param[in] app_id - Caller's application ID
* @param[in] fence-id - Fence ID of the fence which needs to be deleted
* @return int
* @retval GEOFENCE_CLIENT_ERROR_NONE if success
GEOFENCE_CLIENT_ERROR_DBUS_CALL if failure
* @see geo_client_add_geofence
*/
-int geo_client_delete_geofence(geofence_client_dbus_h geofence_client, gint fence_id);
+int geo_client_delete_geofence(geofence_client_dbus_h geofence_client, gchar *app_id, gint fence_id);
/**
* @brief API to delete the place from the server
* @param[in] geofence_client - Client dbus handle
+* @param[in] app_id - Caller's application ID
* @param[in] place_id - Place ID of the place which needs to be deleted
* @return int
* @retval GEOFENCE_CLIENT_ERROR_NONE if success
GEOFENCE_CLIENT_ERROR_DBUS_CALL if failure
* @see geo_client_add_place
*/
-int geo_client_delete_place(geofence_client_dbus_h geofence_client, gint place_id);
+int geo_client_delete_place(geofence_client_dbus_h geofence_client, gchar *app_id, gint place_id);
/**
* @brief API to get the place name
* @return GEOFENCE_CLIENT_ERROR_NONE if success
GEOFENCE_CLIENT_ERROR_DBUS_CALL if failure
*/
-int geo_client_get_place_name(geofence_client_dbus_h geofence_client, gint place_id, char **placeName, int *errorCode);
+int geo_client_get_place_name(geofence_client_dbus_h geofence_client, gchar *app_id, gint place_id, gchar **place_name, gint *error_code);
/**
* @brief API to get the fence list
* @param[in] geofence_client - Client dbus handle
+* @param[in] app_id - Caller's application ID
* @param[in] place_id - ID of the place whose list has to be retrived
* @param[out] iter - iterator for the array of fences
* @param[out] fenceCnt - total count of the fence
* @retval GEOFENCE_CLIENT_ERROR_NONE if success
GEOFENCE_CLIENT_ERROR_DBUS_CALL if failure
*/
-int geo_client_get_list(geofence_client_dbus_h geofence_client, int place_id, GVariantIter **iter, gint *fenceCnt, int *errorCode);
+int geo_client_get_geofences(geofence_client_dbus_h geofence_client, gchar *app_id, gint place_id, GVariantIter **iter, gint *fence_cnt, gint *error_code);
/**
* @brief API to get the place list
* @param[in] geofence_client - Client dbus handle
+* @param[in] app_id - Caller's application ID
* @param[out] iter - iterator for the array of fences
* @param[out] placeCnt - total count of the fence
* @param[out] errorCode - error code for the API
* @retval GEOFENCE_CLIENT_ERROR_NONE if success
GEOFENCE_CLIENT_ERROR_DBUS_CALL if failure
*/
-int geo_client_get_place_list(geofence_client_dbus_h geofence_client, GVariantIter **iter, gint *fenceCnt, int *errorCode);
+int geo_client_get_places(geofence_client_dbus_h geofence_client, gchar *app_id, GVariantIter **iter, gint *fence_cnt, int *error_code);
+
+/**
+* @brief API to enable the geofence. This will call the server API
+* @param[in] geofence_client - Client dbus handle
+* @param[in] app_id - Caller's application ID
+* @param[in] fence_id - Unique id of the fence
+* @param[in] bEnable - enable flag for geofence
+*/
+int geo_client_enable_geofence(geofence_client_dbus_h geofence_client, gchar *app_id, gint geofence_id, gboolean onoff);
/**
* @brief API to start the geofence service on a particular geofence
+* @param[in] app_id - Caller's application ID
* @param[in] geofence_client - Client dbus handle
* @param[in] fence-id - Fence ID of the fence for which geofence service should be started
* @return int
* @retval GEOFENCE_CLIENT_ERROR_NONE if success
GEOFENCE_CLIENT_ERROR_DBUS_CALL if failure
-* @see geo_client_stop_geofence
+* @see geo_client_stop_geofence
*/
-int geo_client_start_geofence(geofence_client_dbus_h geofence_client, gint fence_id);
+int geo_client_start_geofence(geofence_client_dbus_h geofence_client, gchar *app_id, gint fence_id);
/**
* @brief API to stop the geofence service on a particular geofence
* @param[in] geofence_client - Client dbus handle
+* @param[in] app_id - Caller's application ID
* @param[in] fence-id - Fence ID of the fence for which geofence service should be stopped
* @return int
* @retval GEOFENCE_CLIENT_ERROR_NONE if success
GEOFENCE_CLIENT_ERROR_DBUS_CALL if failure
-* @see geo_client_start_geofence
+* @see geo_client_start_geofence
*/
-int geo_client_stop_geofence(geofence_client_dbus_h geofence_client, gint fence_id);
+int geo_client_stop_geofence(geofence_client_dbus_h geofence_client, gchar *app_id, gint fence_id);
/**
* @brief API to start the client and make a subscription to the server
-* @param[in] service_name - Name of the service required by the client
-* @param[in] service_path - Path of the service for dbus connection
* @param[in] geofence_client - Client dbus handle
* @param[in] callback - callback registered by the client
* @param[in] user_data - Data that has to come back in the callback
GEOFENCE_CLIENT_ERROR_DBUS_CALL - if failure
* @see geo_client_stop
*/
-int geo_client_start(char *service_name, char *service_path, geofence_client_dbus_h *geofence_client, geofence_client_cb callback, geofence_client_event_cb evt_callback, void *user_data);
+int geo_client_start(geofence_client_dbus_h geofence_client, geofence_client_cb callback, void *user_data);
/**
* @brief API to stop the client and remove the subscription to the server
GEOFENCE_CLIENT_ERROR_DBUS_CALL - if failure
* @see geo_client_start
*/
-int geo_client_stop(geofence_client_dbus_h *geofence_client);
+int geo_client_stop(geofence_client_dbus_h geofence_client);
/**
* @brief API to create the connection with the server
#define GEOFENCE_CLIENT_LOGE(fmt, args...)
#define GEOFENCE_CLIENT_SECLOG(fmt, args...)
#endif
- __END_DECLS
+__END_DECLS
#endif /* __GEOFENCE_CLIENT_PRIV_H__ */
*/
#include <stdio.h>
-#include <app_manager.h>
#include "geofence_client.h"
#include "geofence_client_priv.h"
+#define GEOFENCE_SERVICE_NAME "org.tizen.lbs.Providers.GeofenceServer"
+#define GEOFENCE_SERVICE_PATH "/org/tizen/lbs/Providers/GeofenceServer"
+#define GEOFENCE_INTERFACE_NAME "org.tizen.lbs.Geofence"
+
+
typedef struct _geofence_client_dbus_s {
GDBusConnection *conn;
gchar *service_name;
gchar *service_path;
+ gchar *signal_path;
int geofence_evt_id;
int geofence_evt_status_id;
- int geofence_id;
geofence_client_cb user_cb;
- geofence_client_event_cb user_event_cb;
void *user_data;
} geofence_client_dbus_s;
static void __geofence_signal_callback(GDBusConnection *conn, const gchar *name, const gchar *path, const gchar *interface, const gchar *sig, GVariant *param, gpointer user_data)
{
- GEOFENCE_CLIENT_SECLOG("name : %s, path : %s, interface : %s, sig : %s, handle[%p]", name, path, interface, sig, user_data);
+ GEOFENCE_CLIENT_SECLOG("name: %s, path: %s, interface: %s, sig: %s, handle[%p]", name, path, interface, sig, user_data);
geofence_client_dbus_s *handle = (geofence_client_dbus_s *) user_data;
if (handle == NULL) {
GEOFENCE_CLIENT_LOGD("Invalid handle");
handle->user_cb(sig, param, handle->user_data);
}
-EXPORT_API int geo_client_add_geofence(geofence_client_dbus_h geofence_client, gint place_id, gint geofence_type, gdouble latitude, gdouble longitude, gint radius, const gchar *address, const gchar *bssid, const gchar *ssid)
+EXPORT_API int geo_client_add_geofence(geofence_client_dbus_h geofence_client, gchar *app_id, gint place_id, gint geofence_type, gdouble latitude, gdouble longitude, gint radius, const gchar *address, const gchar *bssid, const gchar *ssid)
{
- /* add fence interface between App & geofence-server */
- GEOFENCE_CLIENT_LOGD("geo_client_add_fence");
- g_return_val_if_fail(geofence_client, 0);
- geofence_client_dbus_s *handle = (geofence_client_dbus_s *)geofence_client;
+ GEOFENCE_CLIENT_LOGD("ENTER >>>");
+ g_return_val_if_fail(geofence_client, GEOFENCE_CLIENT_ERROR_PARAMETER);
+ geofence_client_dbus_s *handle = (geofence_client_dbus_s *)geofence_client;
GVariant *reg = NULL;
GError *error = NULL;
GDBusProxy *proxy = NULL;
- gchar *app_id = NULL;
- gint fence_id = -1;
- pid_t pid = 0;
-
- GEOFENCE_CLIENT_LOGI("Getting the app id in client");
- pid = getpid();
- int ret = app_manager_get_app_id(pid, &app_id);
-
- if (ret != APP_MANAGER_ERROR_NONE)
- GEOFENCE_CLIENT_LOGE("Fail to get app_id from module_geofence_server. Err[%d]", ret);
-
- GEOFENCE_CLIENT_LOGI("APP ID is : %s", app_id);
- gchar *signal_path = NULL;
- signal_path = g_strdup_printf("%s/%s", handle->service_path, "SAMSUNG");
- GEOFENCE_CLIENT_SECLOG("GEOFENCE signal subscribe Object Path [%s]", signal_path);
-
- proxy = g_dbus_proxy_new_sync(handle->conn, G_DBUS_PROXY_FLAGS_NONE, NULL, handle->service_name, signal_path, "org.tizen.lbs.Geofence", NULL, &error);
- g_free(signal_path);
+ int fence_id = -1;
+ proxy = g_dbus_proxy_new_sync(handle->conn, G_DBUS_PROXY_FLAGS_NONE, NULL, handle->service_name, handle->signal_path, GEOFENCE_INTERFACE_NAME, NULL, &error);
if (proxy) {
- GEOFENCE_CLIENT_LOGD(" proxy exited !");
+ GEOFENCE_CLIENT_LOGD("proxy: %p", proxy);
+
reg = g_dbus_proxy_call_sync(proxy, "AddGeofence", g_variant_new("(siiddisss)", app_id, place_id, geofence_type, latitude, longitude, radius, address, bssid, ssid), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
if (reg) {
g_variant_get(reg, "(i)", &fence_id);
}
g_object_unref(proxy);
} else {
- GEOFENCE_CLIENT_LOGD(" proxy NOT exited !");
if (error) {
GEOFENCE_CLIENT_LOGE("Fail to get proxy Error[%s]", error->message);
g_error_free(error);
}
- }
- if (app_id)
- g_free(app_id);
+ }
+ GEOFENCE_CLIENT_LOGD("fence_id: %d", fence_id);
return fence_id;
}
-EXPORT_API int geo_client_add_place(geofence_client_dbus_h geofence_client, const gchar *place_name)
+EXPORT_API int geo_client_delete_geofence(geofence_client_dbus_h geofence_client, gchar *app_id, gint fence_id)
{
- /* add fence interface between App & geofence-server */
- GEOFENCE_CLIENT_LOGD("geo_client_add_place");
- g_return_val_if_fail(geofence_client, 0);
- geofence_client_dbus_s *handle = (geofence_client_dbus_s *)geofence_client;
+ GEOFENCE_CLIENT_LOGD("ENTER >>>");
+ g_return_val_if_fail(geofence_client, GEOFENCE_CLIENT_ERROR_PARAMETER);
- GVariant *reg = NULL;
+ geofence_client_dbus_s *handle = (geofence_client_dbus_s *) geofence_client;
GError *error = NULL;
GDBusProxy *proxy = NULL;
- gchar *app_id = NULL;
- int place_id = -1;
- pid_t pid = 0;
-
- GEOFENCE_CLIENT_LOGI("Getting the app id in client");
- pid = getpid();
- int ret = app_manager_get_app_id(pid, &app_id);
-
- if (ret != APP_MANAGER_ERROR_NONE)
- GEOFENCE_CLIENT_LOGE("Fail to get app_id from module_geofence_server. Err[%d]", ret);
-
- GEOFENCE_CLIENT_LOGI("APP ID is : %s", app_id);
- gchar *signal_path = NULL;
- signal_path = g_strdup_printf("%s/%s", handle->service_path, "SAMSUNG");
- GEOFENCE_CLIENT_SECLOG("GEOFENCE signal subscribe Object Path [%s]", signal_path);
-
- proxy = g_dbus_proxy_new_sync(handle->conn, G_DBUS_PROXY_FLAGS_NONE, NULL, handle->service_name, signal_path, "org.tizen.lbs.Geofence", NULL, &error);
- g_free(signal_path);
+ int ret = GEOFENCE_CLIENT_ERROR_NONE;
+ proxy = g_dbus_proxy_new_sync(handle->conn, G_DBUS_PROXY_FLAGS_NONE, NULL, handle->service_name, handle->signal_path, GEOFENCE_INTERFACE_NAME, NULL, &error);
if (proxy) {
- GEOFENCE_CLIENT_LOGD(" proxy exited !");
- reg = g_dbus_proxy_call_sync(proxy, "AddPlace", g_variant_new("(ss)", app_id, place_name), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
- if (reg) {
- g_variant_get(reg, "(i)", &place_id);
- g_variant_unref(reg);
- reg = NULL;
- } else {
- if (error) {
- GEOFENCE_CLIENT_LOGE("Fail to add place Error[%s]", error->message);
- g_error_free(error);
- }
- }
- g_object_unref(proxy);
+ g_dbus_proxy_call(proxy, "DeleteGeofence", g_variant_new("(is)", fence_id, app_id), G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, &error);
} else {
- GEOFENCE_CLIENT_LOGD(" proxy NOT exited !");
if (error) {
GEOFENCE_CLIENT_LOGE("Fail to get proxy Error[%s]", error->message);
g_error_free(error);
+ ret = GEOFENCE_CLIENT_ERROR_DBUS_CALL;
}
}
- if (app_id)
- g_free(app_id);
- return place_id;
+ return ret;
}
-EXPORT_API int geo_client_update_place(geofence_client_dbus_h geofence_client, gint place_id, const gchar *place_name)
+EXPORT_API int geo_client_get_geofences(geofence_client_dbus_h geofence_client, gchar *app_id, gint place_id, GVariantIter **iter, gint *fence_cnt, gint *error_code)
{
- GEOFENCE_CLIENT_LOGD("geo_client_update_place");
- g_return_val_if_fail(geofence_client, 0);
+ GEOFENCE_CLIENT_LOGD("ENTER >>>");
+ g_return_val_if_fail(geofence_client, GEOFENCE_CLIENT_ERROR_PARAMETER);
+
geofence_client_dbus_s *handle = (geofence_client_dbus_s *)geofence_client;
+ GVariant *reg = NULL;
GError *error = NULL;
GDBusProxy *proxy = NULL;
- gchar *app_id = NULL;
- pid_t pid = 0;
-
- GEOFENCE_CLIENT_LOGI("Getting the app id in client");
- pid = getpid();
- int ret = app_manager_get_app_id(pid, &app_id);
- if (ret != APP_MANAGER_ERROR_NONE)
- GEOFENCE_CLIENT_LOGE("Fail to get app_id from module_geofence_server. Err[%d]", ret);
- GEOFENCE_CLIENT_LOGI("APP ID is : %s", app_id);
-
- ret = GEOFENCE_CLIENT_ERROR_NONE;
- gchar *signal_path = NULL;
- signal_path = g_strdup_printf("%s/%s", handle->service_path, "SAMSUNG");
- GEOFENCE_CLIENT_SECLOG("GEOFENCE signal subscribe Object Path [%s]", signal_path);
-
- proxy = g_dbus_proxy_new_sync(handle->conn, G_DBUS_PROXY_FLAGS_NONE, NULL, handle->service_name, signal_path, "org.tizen.lbs.Geofence", NULL, &error);
- g_free(signal_path);
+ int ret = GEOFENCE_CLIENT_ERROR_NONE;
+ GVariantIter *iterator;
+ int new_error_code = 0;
+ int new_fence_cnt = 0;
+ proxy = g_dbus_proxy_new_sync(handle->conn, G_DBUS_PROXY_FLAGS_NONE, NULL, handle->service_name, handle->signal_path, GEOFENCE_INTERFACE_NAME, NULL, &error);
if (proxy) {
- GEOFENCE_CLIENT_LOGD(" proxy exited !");
- g_dbus_proxy_call(proxy, "UpdatePlace", g_variant_new("(iss)", place_id, app_id, place_name), G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, &error);
+ GEOFENCE_CLIENT_LOGD("proxy: %p", proxy);
+
+ reg = g_dbus_proxy_call_sync(proxy, "GetGeofences", g_variant_new("(is)", place_id, app_id), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
+ if (reg) {
+ g_variant_get(reg, "(iiaa{sv})", &new_fence_cnt, &new_error_code, &iterator);
+ *error_code = new_error_code;
+ *fence_cnt = new_fence_cnt;
+ if (iterator == NULL)
+ GEOFENCE_CLIENT_LOGE("Iterator is null");
+ *iter = iterator;
+ g_variant_unref(reg);
+ } else {
+ if (error) {
+ GEOFENCE_CLIENT_LOGE("Fail to get the list Error[%s]", error->message);
+ g_error_free(error);
+ ret = GEOFENCE_CLIENT_ERROR_DBUS_CALL;
+ }
+ }
+ g_object_unref(proxy);
} else {
- GEOFENCE_CLIENT_LOGD(" proxy NOT exited !");
if (error) {
GEOFENCE_CLIENT_LOGE("Fail to get proxy Error[%s]", error->message);
g_error_free(error);
ret = GEOFENCE_CLIENT_ERROR_DBUS_CALL;
}
}
- if (app_id)
- g_free(app_id);
return ret;
}
-EXPORT_API int geo_client_delete_geofence(geofence_client_dbus_h geofence_client, gint fence_id)
+EXPORT_API int geo_client_enable_geofence(geofence_client_dbus_h geofence_client, gchar *app_id, gint geofence_id, gboolean onoff)
{
- GEOFENCE_CLIENT_LOGD("geo_client_delete_geofence");
+ GEOFENCE_CLIENT_LOGD("ENTER >>>");
g_return_val_if_fail(geofence_client, GEOFENCE_CLIENT_ERROR_PARAMETER);
- geofence_client_dbus_s *handle = (geofence_client_dbus_s *) geofence_client;
+ geofence_client_dbus_s *handle = (geofence_client_dbus_s *)geofence_client;
GError *error = NULL;
GDBusProxy *proxy = NULL;
- gchar *app_id = NULL;
int ret = GEOFENCE_CLIENT_ERROR_NONE;
- pid_t pid = 0;
-
- GEOFENCE_CLIENT_LOGI("Getting the app id in client");
- pid = getpid();
- ret = app_manager_get_app_id(pid, &app_id);
-
- if (ret != APP_MANAGER_ERROR_NONE)
- GEOFENCE_CLIENT_LOGE("Fail to get app_id from module_geofence_server. Err[%d]", ret);
-
- GEOFENCE_CLIENT_LOGI("APP ID is : %s", app_id);
-
- gchar *signal_path = NULL;
- signal_path = g_strdup_printf("%s/%s", handle->service_path, "SAMSUNG");
- GEOFENCE_CLIENT_SECLOG("GEOFENCE signal subscribe Object Path [%s]", signal_path);
-
- proxy = g_dbus_proxy_new_sync(handle->conn, G_DBUS_PROXY_FLAGS_NONE, NULL, handle->service_name, signal_path, "org.tizen.lbs.Geofence", NULL, &error);
- g_free(signal_path);
+ proxy = g_dbus_proxy_new_sync(handle->conn, G_DBUS_PROXY_FLAGS_NONE, NULL, handle->service_name, handle->signal_path, GEOFENCE_INTERFACE_NAME, NULL, &error);
if (proxy) {
- g_dbus_proxy_call(proxy, "DeleteGeofence", g_variant_new("(is)", fence_id, app_id), G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, &error);
+ g_dbus_proxy_call(proxy, "EnableGeofence", g_variant_new("(isb)", geofence_id, app_id, onoff), G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, &error);
} else {
- GEOFENCE_CLIENT_LOGD(" proxy NOT exited !");
if (error) {
GEOFENCE_CLIENT_LOGE("Fail to get proxy Error[%s]", error->message);
g_error_free(error);
ret = GEOFENCE_CLIENT_ERROR_DBUS_CALL;
}
}
- if (app_id)
- g_free(app_id);
return ret;
}
-EXPORT_API int geo_client_delete_place(geofence_client_dbus_h geofence_client, gint place_id)
+EXPORT_API int geo_client_start_geofence(geofence_client_dbus_h geofence_client, gchar *app_id, gint geofence_id)
{
- GEOFENCE_CLIENT_LOGD("geo_client_delete_place");
+ GEOFENCE_CLIENT_LOGD("ENTER >>>");
g_return_val_if_fail(geofence_client, GEOFENCE_CLIENT_ERROR_PARAMETER);
- geofence_client_dbus_s *handle = (geofence_client_dbus_s *)geofence_client;
+ geofence_client_dbus_s *handle = (geofence_client_dbus_s *)geofence_client;
GError *error = NULL;
GDBusProxy *proxy = NULL;
- gchar *app_id = NULL;
int ret = GEOFENCE_CLIENT_ERROR_NONE;
- pid_t pid = 0;
-
- GEOFENCE_CLIENT_LOGI("Getting the app id in client");
- pid = getpid();
- ret = app_manager_get_app_id(pid, &app_id);
- if (ret != APP_MANAGER_ERROR_NONE)
- GEOFENCE_CLIENT_LOGE("Fail to get app_id from module_geofence_server. Err[%d]", ret);
+ GEOFENCE_CLIENT_LOGD("handle->conn: %p, geofence_id", handle->conn, geofence_id);
- GEOFENCE_CLIENT_LOGI("APP ID is : %s", app_id);
-
- gchar *signal_path = NULL;
- signal_path = g_strdup_printf("%s/%s", handle->service_path, "SAMSUNG");
- GEOFENCE_CLIENT_SECLOG("GEOFENCE signal subscribe Object Path [%s]", signal_path);
-
- proxy = g_dbus_proxy_new_sync(handle->conn, G_DBUS_PROXY_FLAGS_NONE, NULL, handle->service_name, signal_path, "org.tizen.lbs.Geofence", NULL, &error);
- g_free(signal_path);
+ proxy = g_dbus_proxy_new_sync(handle->conn, G_DBUS_PROXY_FLAGS_NONE, NULL, handle->service_name, handle->signal_path, GEOFENCE_INTERFACE_NAME, NULL, &error);
if (proxy) {
- g_dbus_proxy_call(proxy, "DeletePlace", g_variant_new("(is)", place_id, app_id), G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, &error);
+ g_dbus_proxy_call(proxy, "StartGeofence", g_variant_new("(is)", geofence_id, app_id), G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, &error);
} else {
- GEOFENCE_CLIENT_LOGD(" proxy NOT exited !");
if (error) {
GEOFENCE_CLIENT_LOGE("Fail to get proxy Error[%s]", error->message);
g_error_free(error);
ret = GEOFENCE_CLIENT_ERROR_DBUS_CALL;
}
}
- if (app_id)
- g_free(app_id);
-
return ret;
}
-EXPORT_API int geo_client_enable_service(geofence_client_dbus_h geofence_client, gint geofence_id, gboolean bEnable)
+EXPORT_API int geo_client_stop_geofence(geofence_client_dbus_h geofence_client, gchar *app_id, gint geofence_id)
{
- GEOFENCE_CLIENT_LOGD("geo_client_enable_geofence, id(%d)", geofence_id);
+ GEOFENCE_CLIENT_LOGD("ENTER >>>");
g_return_val_if_fail(geofence_client, GEOFENCE_CLIENT_ERROR_PARAMETER);
geofence_client_dbus_s *handle = (geofence_client_dbus_s *)geofence_client;
-
+ int ret = GEOFENCE_CLIENT_ERROR_NONE;
GError *error = NULL;
GDBusProxy *proxy = NULL;
- gchar *app_id = NULL;
- int ret = GEOFENCE_CLIENT_ERROR_NONE;
- gchar *signal_path = NULL;
- pid_t pid = 0;
- gboolean enable = bEnable;
-
- GEOFENCE_CLIENT_LOGI("Getting the app id in client");
- pid = getpid();
- ret = app_manager_get_app_id(pid, &app_id);
-
- if (ret != APP_MANAGER_ERROR_NONE)
- GEOFENCE_CLIENT_LOGE("Fail to get app_id from module_geofence_server. Err[%d]", ret);
-
- GEOFENCE_CLIENT_LOGI("APP ID is : %s", app_id);
-
- signal_path = g_strdup_printf("%s/%s", handle->service_path, "SAMSUNG");
- GEOFENCE_CLIENT_SECLOG("GEOFENCE signal subscribe Object Path [%s]", signal_path);
-
- GEOFENCE_CLIENT_LOGD("handle->user_cb : %x", handle->user_cb);
- /* Start geofence */
- proxy = g_dbus_proxy_new_sync(handle->conn, G_DBUS_PROXY_FLAGS_NONE, NULL, handle->service_name, signal_path, "org.tizen.lbs.Geofence", NULL, &error);
- g_free(signal_path);
+ GEOFENCE_CLIENT_LOGD("handle->conn: %p", handle->conn);
+ proxy = g_dbus_proxy_new_sync(handle->conn, G_DBUS_PROXY_FLAGS_NONE, NULL, handle->service_name, handle->signal_path, GEOFENCE_INTERFACE_NAME, NULL, &error);
if (proxy) {
- g_dbus_proxy_call(proxy, "EnableGeofence", g_variant_new("(isb)", geofence_id, app_id, enable), G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, &error);
+ g_dbus_proxy_call(proxy, "StopGeofence", g_variant_new("(is)", geofence_id, app_id), G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, &error);
} else {
- GEOFENCE_CLIENT_LOGD(" proxy NOT exited !");
if (error) {
GEOFENCE_CLIENT_LOGE("Fail to get proxy Error[%s]", error->message);
g_error_free(error);
ret = GEOFENCE_CLIENT_ERROR_DBUS_CALL;
}
}
- if (app_id)
- g_free(app_id);
return ret;
}
-EXPORT_API int geo_client_start_geofence(geofence_client_dbus_h geofence_client, int geofence_id)
+EXPORT_API int geo_client_add_place(geofence_client_dbus_h geofence_client, gchar *app_id, const gchar *place_name)
{
- GEOFENCE_CLIENT_LOGD("geo_client_start_geofence, id(%d)", geofence_id);
+ /* add fence interface between App & geofence-server */
+ GEOFENCE_CLIENT_LOGD("ENTER >>>");
g_return_val_if_fail(geofence_client, GEOFENCE_CLIENT_ERROR_PARAMETER);
geofence_client_dbus_s *handle = (geofence_client_dbus_s *)geofence_client;
-
+ GVariant *reg = NULL;
GError *error = NULL;
GDBusProxy *proxy = NULL;
- gchar *app_id = NULL;
- int ret = GEOFENCE_CLIENT_ERROR_NONE;
- gchar *signal_path = NULL;
- pid_t pid = 0;
-
- GEOFENCE_CLIENT_LOGI("Getting the app id in client");
- pid = getpid();
- ret = app_manager_get_app_id(pid, &app_id);
-
- if (ret != APP_MANAGER_ERROR_NONE)
- GEOFENCE_CLIENT_LOGE("Fail to get app_id from module_geofence_server. Err[%d]", ret);
-
- GEOFENCE_CLIENT_LOGI("APP ID is : %s", app_id);
-
- signal_path = g_strdup_printf("%s/%s", handle->service_path, "SAMSUNG");
- GEOFENCE_CLIENT_SECLOG("GEOFENCE signal subscribe Object Path [%s]", signal_path);
-
- GEOFENCE_CLIENT_LOGD("handle->user_cb : %x", handle->user_cb);
+ int place_id = -1;
- /* Start geofence */
- proxy = g_dbus_proxy_new_sync(handle->conn, G_DBUS_PROXY_FLAGS_NONE, NULL, handle->service_name, signal_path, "org.tizen.lbs.Geofence", NULL, &error);
- g_free(signal_path);
+ GEOFENCE_CLIENT_LOGI("APP ID: %s", app_id);
+ proxy = g_dbus_proxy_new_sync(handle->conn, G_DBUS_PROXY_FLAGS_NONE, NULL, handle->service_name, handle->signal_path, GEOFENCE_INTERFACE_NAME, NULL, &error);
if (proxy) {
- g_dbus_proxy_call(proxy, "StartGeofence", g_variant_new("(is)", geofence_id, app_id), G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, &error);
+ GEOFENCE_CLIENT_LOGD("proxy: %p", proxy);
+ reg = g_dbus_proxy_call_sync(proxy, "AddPlace", g_variant_new("(ss)", app_id, place_name), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
+ if (reg) {
+ g_variant_get(reg, "(i)", &place_id);
+ g_variant_unref(reg);
+ reg = NULL;
+ } else {
+ if (error) {
+ GEOFENCE_CLIENT_LOGE("Fail to add place Error[%s]", error->message);
+ g_error_free(error);
+ }
+ }
+ g_object_unref(proxy);
} else {
- GEOFENCE_CLIENT_LOGD(" proxy NOT exited !");
if (error) {
GEOFENCE_CLIENT_LOGE("Fail to get proxy Error[%s]", error->message);
g_error_free(error);
- ret = GEOFENCE_CLIENT_ERROR_DBUS_CALL;
}
}
- if (app_id)
- g_free(app_id);
- return ret;
+ GEOFENCE_CLIENT_LOGD("place_id: %d", place_id);
+
+ return place_id;
}
-EXPORT_API int geo_client_stop_geofence(geofence_client_dbus_h geofence_client, int geofence_id)
+EXPORT_API int geo_client_update_place(geofence_client_dbus_h geofence_client, gchar *app_id, gint place_id, const gchar *place_name)
{
- GEOFENCE_CLIENT_LOGD("geo_client_stop_geofence");
+ GEOFENCE_CLIENT_LOGD("ENTER >>>");
+ g_return_val_if_fail(geofence_client, GEOFENCE_CLIENT_ERROR_PARAMETER);
geofence_client_dbus_s *handle = (geofence_client_dbus_s *)geofence_client;
- g_return_val_if_fail(handle, GEOFENCE_CLIENT_ERROR_PARAMETER);
-
- int ret = GEOFENCE_CLIENT_ERROR_NONE;
GError *error = NULL;
- gchar *app_id = NULL;
- pid_t pid = 0;
-
- GEOFENCE_CLIENT_LOGI("Getting the app id in client");
- pid = getpid();
- ret = app_manager_get_app_id(pid, &app_id);
-
- if (ret != APP_MANAGER_ERROR_NONE)
- GEOFENCE_CLIENT_LOGE("Fail to get app_id from module_geofence_server. Err[%d]", ret);
-
- GEOFENCE_CLIENT_LOGI("APP ID is : %s", app_id);
- GEOFENCE_CLIENT_LOGD("handle->user_cb : %x", handle->user_cb);
-
- gchar *signal_path = NULL;
- signal_path = g_strdup_printf("%s/%s", handle->service_path, "SAMSUNG");
- GEOFENCE_CLIENT_SECLOG("GEOFENCE signal subscribe Object Path [%s]", signal_path);
-
- /* Stop*/
GDBusProxy *proxy = NULL;
- GEOFENCE_CLIENT_LOGD("handle->conn: %p", handle->conn);
- proxy = g_dbus_proxy_new_sync(handle->conn, G_DBUS_PROXY_FLAGS_NONE, NULL, handle->service_name, signal_path, "org.tizen.lbs.Geofence", NULL, &error);
- g_free(signal_path);
+ int ret = GEOFENCE_CLIENT_ERROR_NONE;
+ proxy = g_dbus_proxy_new_sync(handle->conn, G_DBUS_PROXY_FLAGS_NONE, NULL, handle->service_name, handle->signal_path, GEOFENCE_INTERFACE_NAME, NULL, &error);
if (proxy) {
- g_dbus_proxy_call(proxy, "StopGeofence", g_variant_new("(is)", geofence_id, app_id), G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, &error);
+ g_dbus_proxy_call(proxy, "UpdatePlace", g_variant_new("(iss)", place_id, app_id, place_name), G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, &error);
} else {
- GEOFENCE_CLIENT_LOGD(" proxy NOT exited !");
if (error) {
GEOFENCE_CLIENT_LOGE("Fail to get proxy Error[%s]", error->message);
g_error_free(error);
ret = GEOFENCE_CLIENT_ERROR_DBUS_CALL;
}
}
- if (app_id)
- g_free(app_id);
return ret;
}
-EXPORT_API int geo_client_get_place_name(geofence_client_dbus_h geofence_client, int place_id, char **placeName, int *errorCode)
+EXPORT_API int geo_client_delete_place(geofence_client_dbus_h geofence_client, gchar *app_id, gint place_id)
{
- GEOFENCE_CLIENT_LOGD("geo_client_get_place_name");
+ GEOFENCE_CLIENT_LOGD("ENTER >>>");
g_return_val_if_fail(geofence_client, GEOFENCE_CLIENT_ERROR_PARAMETER);
geofence_client_dbus_s *handle = (geofence_client_dbus_s *)geofence_client;
-
- GVariant *reg = NULL;
GError *error = NULL;
GDBusProxy *proxy = NULL;
- gchar *app_id = NULL;
int ret = GEOFENCE_CLIENT_ERROR_NONE;
- gchar *signal_path = NULL;
- pid_t pid = 0;
- char *place_name = NULL;
- int error_code = -1;
-
- GEOFENCE_CLIENT_LOGI("Getting the app id in client");
- pid = getpid();
- ret = app_manager_get_app_id(pid, &app_id);
-
- if (ret != APP_MANAGER_ERROR_NONE)
- GEOFENCE_CLIENT_LOGE("Fail to get app_id from module_geofence_server. Err[%d]", ret);
-
- GEOFENCE_CLIENT_LOGI("APP ID is : %s", app_id);
-
- signal_path = g_strdup_printf("%s/%s", handle->service_path, "SAMSUNG");
- GEOFENCE_CLIENT_SECLOG("GEOFENCE signal subscribe Object Path [%s]", signal_path);
-
- GEOFENCE_CLIENT_LOGD("handle->user_cb : %x", handle->user_cb);
- /* Start geofence */
- proxy = g_dbus_proxy_new_sync(handle->conn, G_DBUS_PROXY_FLAGS_NONE, NULL, handle->service_name, signal_path, "org.tizen.lbs.Geofence", NULL, &error);
- g_free(signal_path);
+ proxy = g_dbus_proxy_new_sync(handle->conn, G_DBUS_PROXY_FLAGS_NONE, NULL, handle->service_name, handle->signal_path, GEOFENCE_INTERFACE_NAME, NULL, &error);
if (proxy) {
- reg = g_dbus_proxy_call_sync(proxy, "GetPlaceName", g_variant_new("(is)", place_id, app_id), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
- if (reg) {
- g_variant_get(reg, "(is)", &error_code, &place_name);
- *errorCode = error_code;
- *placeName = strdup(place_name);
- if (place_name)
- g_free(place_name);
- g_variant_unref(reg);
- } else {
- if (error) {
- GEOFENCE_CLIENT_LOGE("Fail to get the place name Error[%s]", error->message);
- g_error_free(error);
- ret = GEOFENCE_CLIENT_ERROR_DBUS_CALL;
- }
- }
- g_object_unref(proxy);
+ g_dbus_proxy_call(proxy, "DeletePlace", g_variant_new("(is)", place_id, app_id), G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL, &error);
} else {
- GEOFENCE_CLIENT_LOGD(" proxy NOT exited !");
if (error) {
GEOFENCE_CLIENT_LOGE("Fail to get proxy Error[%s]", error->message);
g_error_free(error);
}
}
- if (app_id)
- g_free(app_id);
-
return ret;
}
-EXPORT_API int geo_client_get_list(geofence_client_dbus_h geofence_client, int place_id, GVariantIter **iter, int *fenceCnt, int *errorCode)
+EXPORT_API int geo_client_get_place_name(geofence_client_dbus_h geofence_client, gchar *app_id, gint place_id, gchar **place_name, gint *error_code)
{
- GEOFENCE_CLIENT_LOGD("geo_client_get_list");
+ GEOFENCE_CLIENT_LOGD("ENTER >>>");
g_return_val_if_fail(geofence_client, GEOFENCE_CLIENT_ERROR_PARAMETER);
geofence_client_dbus_s *handle = (geofence_client_dbus_s *)geofence_client;
-
GVariant *reg = NULL;
GError *error = NULL;
GDBusProxy *proxy = NULL;
- gchar *app_id = NULL;
int ret = GEOFENCE_CLIENT_ERROR_NONE;
- gchar *signal_path = NULL;
- pid_t pid = 0;
- GVariantIter *iterator;
- int error_code = -1;
- int fence_cnt = 1;
-
- GEOFENCE_CLIENT_LOGI("Getting the app id in client");
- pid = getpid();
- ret = app_manager_get_app_id(pid, &app_id);
-
- if (ret != APP_MANAGER_ERROR_NONE)
- GEOFENCE_CLIENT_LOGE("Fail to get app_id from module_geofence_server. Err[%d]", ret);
-
- GEOFENCE_CLIENT_LOGI("APP ID is : %s", app_id);
-
- signal_path = g_strdup_printf("%s/%s", handle->service_path, "SAMSUNG");
- GEOFENCE_CLIENT_SECLOG("GEOFENCE signal subscribe Object Path [%s]", signal_path);
-
- GEOFENCE_CLIENT_LOGD("handle->user_cb : %x", handle->user_cb);
-
- /* Start geofence */
- proxy = g_dbus_proxy_new_sync(handle->conn, G_DBUS_PROXY_FLAGS_NONE, NULL, handle->service_name, signal_path, "org.tizen.lbs.Geofence", NULL, &error);
- g_free(signal_path);
+ char *new_place_name = NULL;
+ int new_error_code = 0;
+ proxy = g_dbus_proxy_new_sync(handle->conn, G_DBUS_PROXY_FLAGS_NONE, NULL, handle->service_name, handle->signal_path, GEOFENCE_INTERFACE_NAME, NULL, &error);
if (proxy) {
- reg = g_dbus_proxy_call_sync(proxy, "GetList", g_variant_new("(is)", place_id, app_id), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
+ reg = g_dbus_proxy_call_sync(proxy, "GetPlaceName", g_variant_new("(is)", place_id, app_id), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
if (reg) {
- g_variant_get(reg, "(iiaa{sv})", &fence_cnt, &error_code, &iterator);
- *fenceCnt = fence_cnt;
- *errorCode = error_code;
- if (iterator == NULL)
- GEOFENCE_CLIENT_LOGE("Iterator is null");
- *iter = iterator;
+ g_variant_get(reg, "(is)", &new_error_code, &new_place_name);
+ *error_code = new_error_code;
+ *place_name = g_strdup(new_place_name);
+ g_free(new_place_name);
g_variant_unref(reg);
} else {
if (error) {
- GEOFENCE_CLIENT_LOGE("Fail to get the list Error[%s]", error->message);
+ GEOFENCE_CLIENT_LOGE("Fail to get the place name Error[%s]", error->message);
g_error_free(error);
ret = GEOFENCE_CLIENT_ERROR_DBUS_CALL;
}
}
g_object_unref(proxy);
} else {
- GEOFENCE_CLIENT_LOGD(" proxy NOT exited !");
if (error) {
GEOFENCE_CLIENT_LOGE("Fail to get proxy Error[%s]", error->message);
g_error_free(error);
ret = GEOFENCE_CLIENT_ERROR_DBUS_CALL;
}
}
- if (app_id)
- g_free(app_id);
return ret;
}
-EXPORT_API int geo_client_get_place_list(geofence_client_dbus_h geofence_client, GVariantIter **iter, int *placeCnt, int *errorCode)
+EXPORT_API int geo_client_get_places(geofence_client_dbus_h geofence_client, gchar *app_id, GVariantIter **iter, gint *place_cnt, gint *error_code)
{
- GEOFENCE_CLIENT_LOGD("geo_client_get_place_list");
+ GEOFENCE_CLIENT_LOGD("ENTER >>>");
g_return_val_if_fail(geofence_client, GEOFENCE_CLIENT_ERROR_PARAMETER);
geofence_client_dbus_s *handle = (geofence_client_dbus_s *)geofence_client;
-
GVariant *reg = NULL;
GError *error = NULL;
GDBusProxy *proxy = NULL;
- gchar *app_id = NULL;
+
int ret = GEOFENCE_CLIENT_ERROR_NONE;
- gchar *signal_path = NULL;
- pid_t pid = 0;
GVariantIter *iterator;
- int error_code = -1;
- int place_cnt = 0;
+ int new_error_code = 0;
+ int new_place_cnt = 0;
- GEOFENCE_CLIENT_LOGI("Getting the app id in client");
- pid = getpid();
- ret = app_manager_get_app_id(pid, &app_id);
- if (ret != APP_MANAGER_ERROR_NONE)
- GEOFENCE_CLIENT_LOGE("Fail to get app_id from module_geofence_server. Err[%d]", ret);
-
- GEOFENCE_CLIENT_LOGI("APP ID is : %s", app_id);
-
- signal_path = g_strdup_printf("%s/%s", handle->service_path, "SAMSUNG");
- GEOFENCE_CLIENT_SECLOG("GEOFENCE signal subscribe Object Path [%s]", signal_path);
-
- GEOFENCE_CLIENT_LOGD("handle->user_cb : %x", handle->user_cb);
+ GEOFENCE_CLIENT_LOGD("handle->conn: %p", handle->conn);
+ GEOFENCE_CLIENT_LOGI("APP ID: %s", app_id);
- /* Start geofence */
- proxy = g_dbus_proxy_new_sync(handle->conn, G_DBUS_PROXY_FLAGS_NONE, NULL, handle->service_name, signal_path, "org.tizen.lbs.Geofence", NULL, &error);
- g_free(signal_path);
+ proxy = g_dbus_proxy_new_sync(handle->conn, G_DBUS_PROXY_FLAGS_NONE, NULL, handle->service_name, handle->signal_path, GEOFENCE_INTERFACE_NAME, NULL, &error);
if (proxy) {
- reg = g_dbus_proxy_call_sync(proxy, "GetPlaceList", g_variant_new("(s)", app_id), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
+ reg = g_dbus_proxy_call_sync(proxy, "GetPlaces", g_variant_new("(s)", app_id), G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
if (reg) {
- g_variant_get(reg, "(iiaa{sv})", &place_cnt, &error_code, &iterator);
- *placeCnt = place_cnt;
- *errorCode = error_code;
+ g_variant_get(reg, "(iiaa{sv})", &new_place_cnt, &new_error_code, &iterator);
+ *place_cnt = new_place_cnt;
+ *error_code = new_error_code;
if (iterator == NULL)
GEOFENCE_CLIENT_LOGE("Iterator is null");
*iter = iterator;
}
g_object_unref(proxy);
} else {
- GEOFENCE_CLIENT_LOGD(" proxy NOT exited !");
if (error) {
GEOFENCE_CLIENT_LOGE("Fail to get proxy Error[%s]", error->message);
g_error_free(error);
ret = GEOFENCE_CLIENT_ERROR_DBUS_CALL;
}
}
- if (app_id)
- g_free(app_id);
return ret;
}
-static void geo_client_signal_unsubcribe(geofence_client_dbus_h geofence_client)
+EXPORT_API int geo_client_start(geofence_client_dbus_h geofence_client, geofence_client_cb callback, void *user_data)
{
- GEOFENCE_CLIENT_LOGD("geo_client_signal_unsubcribe");
-
- geofence_client_dbus_s *handle = (geofence_client_dbus_s *)geofence_client;
- if (handle == NULL) {
- GEOFENCE_CLIENT_LOGE("Invalid handle");
- return;
- }
- if (handle->conn == NULL) {
- GEOFENCE_CLIENT_LOGE("Invalid dbus_connection");
- return;
- }
- if (handle->geofence_evt_id) {
- g_dbus_connection_signal_unsubscribe(handle->conn, handle->geofence_evt_id);
- handle->geofence_evt_id = 0;
- }
- if (handle->geofence_evt_status_id) {
- g_dbus_connection_signal_unsubscribe(handle->conn, handle->geofence_evt_status_id);
- handle->geofence_evt_status_id = 0;
- }
-}
-
-EXPORT_API int geo_client_start(char *service_name, char *service_path, geofence_client_dbus_h *geofence_client, geofence_client_cb callback, geofence_client_event_cb evt_callback, void *user_data)
-{
- GEOFENCE_CLIENT_LOGD("geo_client_start");
+ GEOFENCE_CLIENT_LOGD("ENTER >>>");
g_return_val_if_fail(geofence_client, GEOFENCE_CLIENT_ERROR_PARAMETER);
geofence_client_dbus_s *handle = (geofence_client_dbus_s *)geofence_client;
-
- GVariant *param = NULL;
- GVariantBuilder *builder = NULL;
gchar *signal_path = NULL;
- handle->service_name = g_strdup(service_name);
- handle->service_path = g_strdup(service_path);
-
- signal_path = g_strdup_printf("%s/%s", handle->service_path, "SAMSUNG");
- GEOFENCE_CLIENT_LOGD("Geofence signal subscribe Object Path [%s]", signal_path);
+ handle->service_name = g_strdup(GEOFENCE_SERVICE_NAME);
+ handle->service_path = g_strdup(GEOFENCE_SERVICE_PATH);
+ handle->signal_path = g_strdup_printf("%s/%s", handle->service_path, "SAMSUNG");
+ GEOFENCE_CLIENT_LOGD("Object Path [%s]", handle->signal_path);
if (callback) {
handle->user_cb = callback;
handle->user_data = user_data;
- handle->geofence_evt_id = g_dbus_connection_signal_subscribe(handle->conn, handle->service_name, "org.tizen.lbs.Geofence", "GeofenceInout", signal_path, NULL, G_DBUS_SIGNAL_FLAGS_NONE, __geofence_signal_callback, handle, NULL);
+ handle->geofence_evt_id = g_dbus_connection_signal_subscribe(handle->conn, handle->service_name, GEOFENCE_INTERFACE_NAME, "GeofenceInout", handle->signal_path, NULL, G_DBUS_SIGNAL_FLAGS_NONE, __geofence_signal_callback, handle, NULL);
if (handle->geofence_evt_id) {
- GEOFENCE_CLIENT_LOGD("Listening Geofence Changed");
+ GEOFENCE_CLIENT_LOGD("Listening GeofenceInout");
} else {
- GEOFENCE_CLIENT_LOGD("Fail to listen Geofence Changed");
+ GEOFENCE_CLIENT_LOGD("Fail to listen GeofenceInout");
}
- }
- if (callback) {
- handle->user_event_cb = evt_callback;
- handle->user_data = user_data;
- handle->geofence_evt_status_id = g_dbus_connection_signal_subscribe(handle->conn, handle->service_name, "org.tizen.lbs.Geofence", "GeofenceEvent", signal_path, NULL, G_DBUS_SIGNAL_FLAGS_NONE, __geofence_signal_callback, handle, NULL);
+
+ handle->geofence_evt_status_id = g_dbus_connection_signal_subscribe(handle->conn, handle->service_name, GEOFENCE_INTERFACE_NAME, "GeofenceEvent", handle->signal_path, NULL, G_DBUS_SIGNAL_FLAGS_NONE, __geofence_signal_callback, handle, NULL);
if (handle->geofence_evt_status_id) {
- GEOFENCE_CLIENT_LOGD("Listening Geofence event changed");
+ GEOFENCE_CLIENT_LOGD("Listening Geofence event");
} else {
- GEOFENCE_CLIENT_LOGD("Fail to listen Geofence event changed");
+ GEOFENCE_CLIENT_LOGD("Fail to listen Geofence event");
return GEOFENCE_CLIENT_ERROR_DBUS_CALL;
}
}
g_free(signal_path);
- /* Start */
+
+#if SUPPORT_MULTI_CLIENT
+ GVariant *param = NULL;
+ GVariantBuilder *builder = NULL;
+
+
GEOFENCE_CLIENT_LOGD("START: CMD-START");
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)));
g_variant_unref(param);
+#endif
return GEOFENCE_CLIENT_ERROR_NONE;
}
-EXPORT_API int geo_client_stop(geofence_client_dbus_h *geofence_client)
+static void __geo_client_signal_unsubcribe(geofence_client_dbus_h geofence_client)
+{
+ GEOFENCE_CLIENT_LOGD("ENTER >>>");
+
+ geofence_client_dbus_s *handle = (geofence_client_dbus_s *)geofence_client;
+ if (handle == NULL) {
+ GEOFENCE_CLIENT_LOGE("Invalid handle");
+ return;
+ }
+ if (handle->conn == NULL) {
+ GEOFENCE_CLIENT_LOGE("Invalid dbus_connection");
+ return;
+ }
+ if (handle->geofence_evt_id) {
+ g_dbus_connection_signal_unsubscribe(handle->conn, handle->geofence_evt_id);
+ handle->geofence_evt_id = 0;
+ }
+ if (handle->geofence_evt_status_id) {
+ g_dbus_connection_signal_unsubscribe(handle->conn, handle->geofence_evt_status_id);
+ handle->geofence_evt_status_id = 0;
+ }
+}
+
+EXPORT_API int geo_client_stop(geofence_client_dbus_h geofence_client)
{
- GEOFENCE_CLIENT_LOGD("geo_client_stop");
+ GEOFENCE_CLIENT_LOGD("ENTER >>>");
geofence_client_dbus_s *handle = (geofence_client_dbus_s *)geofence_client;;
g_return_val_if_fail(handle, GEOFENCE_CLIENT_ERROR_PARAMETER);
+ __geo_client_signal_unsubcribe(handle);
+
+#if SUPPORT_MULTI_CLIENT
GVariant *param = NULL;
GVariantBuilder *builder = NULL;
- geo_client_signal_unsubcribe(handle);
+
/* Stop*/
GEOFENCE_CLIENT_LOGD("STOP: CMD-STOP");
builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
g_variant_unref(param);
+#endif
+
return GEOFENCE_CLIENT_ERROR_NONE;
}
static int __geofence_client_create_connection(geofence_client_dbus_s *client)
{
- GEOFENCE_CLIENT_LOGD("__geofence_client_create_connection");
+ GEOFENCE_CLIENT_LOGD("ENTER >>>");
+
g_return_val_if_fail(client, GEOFENCE_CLIENT_ERROR_PARAMETER);
GError *error = NULL;
+#if 0
client->conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
+#endif
+
+ char *bus_addr = NULL;
+ bus_addr = g_dbus_address_get_for_bus_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
+ if (!bus_addr) {
+ GEOFENCE_CLIENT_LOGD("Fail to get addr of bus.");
+ return GEOFENCE_CLIENT_ERROR_CONNECTION;
+ }
+
+ GEOFENCE_CLIENT_LOGD("bus_addr: %s", bus_addr);
+
+ client->conn = g_dbus_connection_new_for_address_sync(bus_addr,
+ G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT |
+ G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION,
+ NULL, NULL, &error);
+ g_free(bus_addr);
+
if (!client->conn) {
if (error && error->message) {
GEOFENCE_CLIENT_LOGD("Fail to get GBus. ErrCode[%d], Msg[%s]", error->code, error->message);
g_error_free(error);
error = NULL;
}
- GEOFENCE_CLIENT_LOGD("Fail to get addr of bus.");
return GEOFENCE_CLIENT_ERROR_CONNECTION;
}
GEOFENCE_CLIENT_LOGD("client->conn: %p", client->conn);
return GEOFENCE_CLIENT_ERROR_NONE;
}
-static void _glib_log(const gchar *log_domain, GLogLevelFlags log_level, const gchar *msg, gpointer user_data)
+static void __glib_log(const gchar *log_domain, GLogLevelFlags log_level, const gchar *msg, gpointer user_data)
{
geofence_client_dbus_s *client = (geofence_client_dbus_s *)user_data;
if (client != NULL) {
GEOFENCE_CLIENT_LOGD("client->conn: %p", client->conn);
}
- GEOFENCE_CLIENT_LOGE("GLIB[%d] : %s", log_level, msg);
+ GEOFENCE_CLIENT_LOGE("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 geo_client_create(geofence_client_dbus_h *geofence_client)
{
- GEOFENCE_CLIENT_LOGD("geo_client_create");
+ GEOFENCE_CLIENT_LOGD("ENTER >>>");
int ret = GEOFENCE_CLIENT_ERROR_NONE;
geofence_client_dbus_s *client = g_new0(geofence_client_dbus_s, 1);
g_return_val_if_fail(client, GEOFENCE_CLIENT_ERROR_MEMORY);
- g_log_set_default_handler(_glib_log, client);
+ g_log_set_default_handler(__glib_log, client);
ret = __geofence_client_create_connection(client);
if (ret != GEOFENCE_CLIENT_ERROR_NONE) {
EXPORT_API int geo_client_destroy(geofence_client_dbus_h geofence_client)
{
- GEOFENCE_CLIENT_LOGD("geo_client_destroy");
+ GEOFENCE_CLIENT_LOGD("ENTER >>>");
g_return_val_if_fail(geofence_client, GEOFENCE_CLIENT_ERROR_PARAMETER);
geofence_client_dbus_s *handle = (geofence_client_dbus_s *)geofence_client;
g_object_unref(handle->conn);
handle->conn = NULL;
}
- if (handle->service_path)
- g_free(handle->service_path);
- if (handle->service_name)
- g_free(handle->service_name);
+ g_free(handle->service_path);
+ g_free(handle->service_name);
+ g_free(handle->signal_path);
g_free(handle);
return GEOFENCE_CLIENT_ERROR_NONE;
<arg direction="in" type="s" name="ssid"/>
<arg direction="out" type="i" name="fence_id"/>
</method>
- <method name="AddPlace">
- <arg direction="in" type="s" name="app_id"/>
- <arg direction="in" type="s" name="place_name"/>
- <arg direction="out" type="i" name="place_id"/>
- </method>
- <method name="EnableGeofence">
+ <method name="DeleteGeofence">
<arg direction="in" type="i" name="fence_id"/>
<arg direction="in" type="s" name="app_id"/>
- <arg direction="in" type="b" name="enable"/>
</method>
- <method name="UpdatePlace">
+ <method name="GetGeofences">
<arg direction="in" type="i" name="place_id"/>
<arg direction="in" type="s" name="app_id"/>
- <arg direction="in" type="s" name="place_name"/>
+ <arg direction="out" type="i" name="fence_count"/>
+ <arg direction="out" type="i" name="error_code"/>
+ <arg direction="out" type="aa{sv}" name="geofence_info"/>
</method>
- <method name="DeleteGeofence">
+ <method name="EnableGeofence">
<arg direction="in" type="i" name="fence_id"/>
<arg direction="in" type="s" name="app_id"/>
- </method>
- <method name="DeletePlace">
- <arg direction="in" type="i" name="place_id"/>
- <arg direction="in" type="s" name="app_id"/>
+ <arg direction="in" type="b" name="enable"/>
</method>
<method name="StartGeofence">
<arg direction="in" type="i" name="fence_id"/>
<arg direction="in" type="i" name="fence_id"/>
<arg direction="in" type="s" name="app_id"/>
</method>
- <method name="GetPlaceName">
+ <signal name="GeofenceInout">
+ <arg direction="out" type="s" name="app_id"/>
+ <arg direction="out" type="i" name="fence_id"/>
+ <arg direction="out" type="i" name="access_type"/>
+ <arg direction="out" type="i" name="fence_state"/>
+ </signal>
+
+ <!-- Place Management -->
+ <method name="AddPlace">
+ <arg direction="in" type="s" name="app_id"/>
+ <arg direction="in" type="s" name="place_name"/>
+ <arg direction="out" type="i" name="place_id"/>
+ </method>
+ <method name="UpdatePlace">
<arg direction="in" type="i" name="place_id"/>
<arg direction="in" type="s" name="app_id"/>
- <arg direction="out" type="i" name="error_code"/>
- <arg direction="out" type="s" name="place_name"/>
+ <arg direction="in" type="s" name="place_name"/>
</method>
- <method name="GetList">
+ <method name="DeletePlace">
+ <arg direction="in" type="i" name="place_id"/>
+ <arg direction="in" type="s" name="app_id"/>
+ </method>
+ <method name="GetPlaceName">
<arg direction="in" type="i" name="place_id"/>
<arg direction="in" type="s" name="app_id"/>
- <arg direction="out" type="i" name="fence_count"/>
<arg direction="out" type="i" name="error_code"/>
- <arg direction="out" type="aa{sv}" name="geofence_info"/>
+ <arg direction="out" type="s" name="place_name"/>
</method>
- <method name="GetPlaceList">
+ <method name="GetPlaces">
<arg direction="in" type="s" name="app_id"/>
<arg direction="out" type="i" name="place_count"/>
<arg direction="out" type="i" name="error_code"/>
<arg direction="out" type="aa{sv}" name="place_info"/>
</method>
- <signal name="GeofenceInout">
- <arg direction="out" type="s" name="app_id"/>
- <arg direction="out" type="i" name="fence_id"/>
- <arg direction="out" type="i" name="access_type"/>
- <arg direction="out" type="i" name="fence_state"/>
- </signal>
<signal name="GeofenceEvent">
<arg direction="out" type="i" name="place_id"/>
<arg direction="out" type="i" name="fence_id"/>
Name: geofence-dbus
Summary: Dbus interface for Geofence service
-Version: 0.2.2
+Version: 0.3.0
Release: 1
Group: Location/Libraries
License: Apache-2.0
BuildRequires: pkgconfig(glib-2.0)
BuildRequires: pkgconfig(gobject-2.0)
BuildRequires: pkgconfig(dlog)
-#BuildRequires: pkgconfig(security-server)
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)
-BuildRequires: python
-BuildRequires: python-xml
+BuildRequires: pkgconfig(capi-base-common)
%description
Geofence dbus interface
__BEGIN_DECLS
#include <gio/gio.h>
+typedef enum {
+ GEOFENCE_DBUS_SERVER_ERROR_NONE = 0x0,
+ GEOFENCE_DBUS_SERVER_ERROR_UNKNOWN,
+ GEOFENCE_DBUS_SERVER_ERROR_PARAMETER,
+ GEOFENCE_DBUS_SERVER_ERROR_MEMORY,
+ GEOFENCE_DBUS_SERVER_ERROR_CONNECTION,
+ GEOFENCE_DBUS_SERVER_ERROR_STATUS,
+ GEOFENCE_DBUS_SERVER_ERROR_DBUS_CALL,
+ GEOFENCE_DBUS_SERVER_ERROR_NO_RESULT,
+} geofence_dbus_server_error_e;
+
+
+typedef void *geofence_dbus_server_h;
+
+
+#if SUPPORT_MULTI_CLIENT
/**
* @brief Callback for setting the options
*/
-typedef void (*GeofenceDbusSetOptionsCB) (GVariant * options, gpointer userdata);
+typedef void (*GeofenceDbusSetOptionsCB)(GVariant *options, gpointer userdata);
+#endif
/**
* @brief Callback for shutting down the Dbus
*/
-typedef void (*GeofenceDbusShutdownCB) (gpointer userdata, gboolean *shutdown_arr);
+typedef void (*GeofenceDbusShutdownCB)(gpointer userdata, gboolean shutdown_arr);
+
/* for geofence callbacks */
/**
* @brief Callback for adding the fence
*/
-typedef gint (*GeofenceAddGeofenceCB) (const gchar * app_id, gint place_id, gint geofence_type, gdouble latitude, gdouble longitude, gint radius, const gchar * address, const gchar * bssid, const gchar * ssid, gpointer userdata);
+typedef gint(*GeofenceAddGeofenceCB)(const gchar *app_id, gint place_id, gint geofence_type, gdouble latitude, gdouble longitude, gint radius, const gchar *address, const gchar *bssid, const gchar *ssid, gpointer userdata);
/**
-* @brief Callback for adding the place
+* @brief Callback for deleting the geofence
*/
-typedef gint (*GeofenceAddPlaceCB) (const gchar * app_id, const gchar * place_name, gpointer userdata);
+typedef void (*GeofenceDeleteGeofenceCB)(gint fence_id, const gchar *app_id, gpointer userdata);
/**
-* @brief Callback for enabling the geofence
+* @brief Callback for getting the fence list
*/
-typedef void (*GeofenceEnableGeofenceCB) (gint fence_id, const gchar *app_id, gboolean enable, gpointer userdata);
+typedef GVariant *(*GeofenceGetGeofencesCB)(int place_id, const gchar *app_id, int *fence_cnt, int *error_code, gpointer userdata);
/**
-* @brief Callback for updating the place
+* @brief Callback for enabling the geofence
*/
-typedef void (*GeofenceUpdatePlaceCB) (gint place_id, const gchar *app_id, const gchar *place_name, gpointer userdata);
+typedef void (*GeofenceEnableGeofenceCB)(gint fence_id, const gchar *app_id, gboolean enable, gpointer userdata);
+
/**
-* @brief Callback for deleting the geofence
+* @brief Callback for Starting the Geofence service
*/
-typedef void (*GeofenceDeleteGeofenceCB) (gint fence_id, const gchar *app_id, gpointer userdata);
+typedef void (*GeofenceStartGeofenceCB)(gint fence_id, const gchar *app_id, gpointer userdata);
/**
-* @brief Callback for deleting the place
+* @brief Callback for Stopping the Geofence service
*/
-typedef void (*GeofenceDeletePlaceCB) (gint place_id, const gchar *app_id, gpointer userdata);
+typedef void (*GeofenceStopGeofenceCB)(gint fence_id, const gchar *app_id, gpointer userdata);
+
+
+/* for place callbacks */
/**
-* @brief Callback for Starting the Geofence service
+* @brief Callback for adding the place
*/
-typedef void (*GeofenceStartGeofenceCB) (gint fence_id, const gchar *app_id, gpointer userdata);
+typedef gint(*GeofenceAddPlaceCB)(const gchar *app_id, const gchar *place_name, gpointer userdata);
/**
-* @brief Callback for Stopping the Geofence service
+* @brief Callback for deleting the place
*/
-typedef void (*GeofenceStopGeofenceCB) (gint fence_id, const gchar *app_id, gpointer userdata);
+typedef void (*GeofenceDeletePlaceCB)(gint place_id, const gchar *app_id, gpointer userdata);
/**
-* @brief Callback for getting the place name
+* @brief Callback for updating the place
*/
-typedef void (*GeofenceGetPlaceNameGeofenceCB) (int place_id, const gchar *app_id, char **place_name, int *error_code, gpointer userdata);
+typedef void (*GeofenceUpdatePlaceCB)(gint place_id, const gchar *app_id, const gchar *place_name, gpointer userdata);
/**
-* @brief Callback for getting the fence list
+* @brief Callback for getting the place name
*/
-typedef GVariant * (*GeofenceGetlistGeofenceCB) (int place_id, const gchar *app_id, int *fenceCnt, int *error_code, gpointer userdata);
+typedef void (*GeofenceGetPlaceNameCB)(int place_id, const gchar *app_id, char **place_name, int *error_code, gpointer userdata);
/**
* @brief Callback for getting the place list
*/
-typedef GVariant * (*GeofenceGetPlaceListGeofenceCB) (const gchar *app_id, int *fenceCnt, int *error_code, gpointer userdata);
-
-typedef enum {
- GEOFENCE_DBUS_SERVER_ERROR_NONE = 0x0,
- GEOFENCE_DBUS_SERVER_ERROR_UNKNOWN,
- GEOFENCE_DBUS_SERVER_ERROR_PARAMETER,
- GEOFENCE_DBUS_SERVER_ERROR_MEMORY,
- GEOFENCE_DBUS_SERVER_ERROR_CONNECTION,
- GEOFENCE_DBUS_SERVER_ERROR_STATUS,
- GEOFENCE_DBUS_SERVER_ERROR_DBUS_CALL,
- GEOFENCE_DBUS_SERVER_ERROR_NO_RESULT,
-} geofence_dbus_server_error_e;
-
-typedef void *geofence_dbus_server_h;
+typedef GVariant *(*GeofenceGetPlacesCB)(const gchar *app_id, int *fence_cnt, int *error_code, gpointer userdata);
/**
* @brief API to send the geofence status to the application
* @param[in] app_id - The application to which the status needs to be sent
* @param[in] fence_state - The state of the fence whether in/out
* @return int
-* @retval GEOFENCE_DBUS_SERVER_ERROR_NONE
+* @retval GEOFENCE_DBUS_SERVER_ERROR_NONE
*/
int geofence_dbus_server_send_geofence_inout_changed(geofence_dbus_server_h geofence_dbus_server, const gchar *app_id, gint fence_id, gint access_type, gint fence_state);
int geofence_dbus_server_send_geofence_event_changed(geofence_dbus_server_h geofence_dbus_server, gint place_id, gint fence_id, gint access_type, const gchar *app_id, gint error, gint state);
+typedef struct {
+#if SUPPORT_MULTI_CLIENT
+ /* size_t size; */
+ GeofenceDbusSetOptionsCB set_options_cb;
+#endif
+ GeofenceDbusShutdownCB shutdown_cb;
+
+ GeofenceAddGeofenceCB add_geofence_cb;
+ GeofenceDeleteGeofenceCB delete_geofence_cb;
+ GeofenceGetGeofencesCB get_geofences_cb;
+ GeofenceEnableGeofenceCB enable_geofence_cb;
+ GeofenceStartGeofenceCB start_geofence_cb;
+ GeofenceStopGeofenceCB stop_geofence_cb;
+
+ GeofenceAddPlaceCB add_place_cb;
+ GeofenceUpdatePlaceCB update_place_cb;
+ GeofenceDeletePlaceCB delete_place_cb;
+ GeofenceGetPlaceNameCB get_place_name_cb;
+ GeofenceGetPlacesCB get_places_cb;
+} geofence_dbus_callback_s;
+
/**
* @brief API to create the server
* @param[in] service_name - Name of the service for which the server has to be created
* @param[in] service_path - Path for the service
-* @param[in] name - Server name
-* @param[in] description - Description about the server
* @param[in] geofence_dbus_server - Dbus server pointer
-* @param[in] add_geofence_cb - Callback for add geofence funtionality
-* @param[in] enable_geofence_cb - Callback for enable geofence functionality
-* @param[in] delete_fence_cb - Callback for delete geofence funtionality
-* @param[in] getlist_fence_cb - Callback for getlist functionality
-* @param[in] start_geofence_cb - Callback for start geofence functionality
-* @param[in] stop_geofence_cb - Callback for stopping the geofence functionality
+* @param[in] geofence_dbus_callback - Callback for all dbus interface
* @param[in] userdata - Userdata if any which will come back in the callbacks
* return int
* retval GEOFENCE_DBUS_SERVER_ERROR_NONE if success
GEOFENCE_DBUS_SERVER_ERROR_MEMORY if failure
*/
-int geofence_dbus_server_create(char *service_name, char *service_path, char *name, char *description, geofence_dbus_server_h *geofence_dbus_server, GeofenceAddGeofenceCB add_geofence_cb, GeofenceAddPlaceCB add_place_cb, GeofenceEnableGeofenceCB enable_geofence_cb, GeofenceUpdatePlaceCB update_place_cb, GeofenceDeleteGeofenceCB delete_fence_cb, GeofenceDeletePlaceCB delete_place_cb, GeofenceGetPlaceNameGeofenceCB getplacename_fence_cb, GeofenceGetlistGeofenceCB getlist_fence_cb, GeofenceGetPlaceListGeofenceCB getplacelist_fence_cb, GeofenceStartGeofenceCB start_geofence_cb, GeofenceStopGeofenceCB stop_geofence_cb, gpointer userdata);
+int geofence_dbus_server_create(geofence_dbus_server_h *geofence_dbus_server, geofence_dbus_callback_s *geofence_dbus_callback, gpointer userdata);
/**
* @brief API to destroy the dbus server which was created
#define GEOFENCE_DBUS_SERVER_LOGE(fmt, args...)
#define GEOFENCE_DBUS_SERVER_SECLOG(fmt, args...)
#endif
- __END_DECLS
+__END_DECLS
#endif /*__GEOFENCE_DBUS_SERVER_PRIV_H__*/
#include "geofence_dbus_server.h"
#include "geofence_dbus_server_priv.h"
+
+#define GEOFENCE_SERVICE_NAME "org.tizen.lbs.Providers.GeofenceServer"
+#define GEOFENCE_SERVICE_PATH "/org/tizen/lbs/Providers/GeofenceServer"
+
+typedef struct _geofence_dbus_signal_s {
+ guint add_geofence_h;
+ guint delete_geofence_h;
+ guint get_geofences_h;
+ guint enable_geofence_h;
+ guint start_geofence_h;
+ guint stop_geofence_h;
+
+ guint add_place_h;
+ guint update_place_h;
+ guint delete_place_h;
+ guint get_place_name_h;
+ guint get_places_h;
+} geofence_dbus_signal_s;
+
typedef struct _geofence_dbus_server_s {
/* Geofence Dbus Server info */
gchar *service_name;
gchar *prev_owner;
gchar *service_path;
- gchar *name;
- gchar *description;
- GHashTable *connections;
gint status;
GDBusObjectManagerServer *manager;
SLocObjectSkeleton *obj_skeleton;
- GeofenceDbusSetOptionsCB set_options_cb;
- GeofenceDbusShutdownCB shutdown_cb;
- gpointer userdata; /* used for save GpsManager */
+ GHashTable *connections;
+ gpointer userdata;
guint owner_changed_id;
guint owner_id;
guint get_providerinfo_h;
guint add_reference_h;
guint remove_reference_h;
- /* for geofence */
- guint add_geofence_h;
- guint add_place_h;
- guint enable_geofence_h;
- guint update_place_h;
- guint delete_geofence_h;
- guint delete_place_h;
- guint start_geofence_h;
- guint stop_geofence_h;
- guint getplacename_geofence_h;
- guint getlist_geofence_h;
- guint getplacelist_geofence_h;
-
- gint geofence_status;
- GeofenceAddGeofenceCB add_geofence_cb;
- GeofenceAddPlaceCB add_place_cb;
- GeofenceEnableGeofenceCB enable_geofence_cb;
- GeofenceUpdatePlaceCB update_place_cb;
- GeofenceDeleteGeofenceCB delete_geofence_cb;
- GeofenceDeletePlaceCB delete_place_cb;
- GeofenceGetPlaceNameGeofenceCB getplacename_geofence_cb;
- GeofenceGetlistGeofenceCB getlist_geofence_cb;
- GeofenceGetPlaceListGeofenceCB getplacelist_geofence_cb;
- GeofenceStartGeofenceCB start_geofence_cb;
- GeofenceStopGeofenceCB stop_geofence_cb;
+ geofence_dbus_signal_s *dbus_signal;
+ geofence_dbus_callback_s *dbus_callback;
} geofence_dbus_server_s;
-typedef enum {
- GEOFENCE_DBUS_SERVER_METHOD_GPS = 0,
- GEOFENCE_DBUS_SERVER_METHOD_NPS,
- GEOFENCE_DBUS_SERVER_METHOD_AGPS,
- GEOFENCE_DBUS_SERVER_METHOD_GEOFENCE,
- GEOFENCE_DBUS_SERVER_METHOD_SIZE,
-} geofence_dbus_server_method_e;
-
static gboolean geofence_dbus_setup_geofence_interface(SLocObjectSkeleton *object, geofence_dbus_server_s *ctx)
{
GEOFENCE_DBUS_SERVER_LOGD("geofence_dbus_setup_geofence_interface");
return TRUE;
}
-static gboolean geofence_find_method(gpointer key, gpointer value, gpointer user_data)
-{
- int *ip = (int *)user_data;
- int *arr = (int *)value;
- int method = *ip;
-
- GEOFENCE_DBUS_SERVER_LOGD("[%s] geofence_find_method method:%d, count:%d", (char *)key, method, arr[method]);
-
- return (arr[method] > 0) ? TRUE : FALSE;
-}
-
/*
* For geofence methods
*/
static gboolean on_add_geofence(SLocGeofence *geofence, GDBusMethodInvocation *invocation, const gchar *app_id, gint place_id, gint geofence_type, gdouble latitude, gdouble longitude, gint radius, const gchar *address, const gchar *bssid, const gchar *ssid, gpointer user_data)
{
- GEOFENCE_DBUS_SERVER_LOGD("on_add_geofence");
+ GEOFENCE_DBUS_SERVER_LOGD("ENTER >>>");
/* call geofence-server's callback, add_geofence_cb */
geofence_dbus_server_s *ctx = (geofence_dbus_server_s *)user_data;
- if (!ctx)
- return FALSE;
- gint fence_id = 0;
- if (ctx->add_geofence_cb) {
- fence_id = ctx->add_geofence_cb(app_id, place_id, geofence_type, latitude, longitude, radius, address, bssid, ssid, ctx->userdata);
+ if (!ctx) return FALSE;
+
+ gint fence_id = -1;
+ if (ctx->dbus_callback && ctx->dbus_callback->add_geofence_cb) {
+ fence_id = ctx->dbus_callback->add_geofence_cb(app_id, place_id, geofence_type, latitude, longitude, radius, address, bssid, ssid, ctx->userdata);
GEOFENCE_DBUS_SERVER_LOGD("add_geofence_cb called");
}
+ GEOFENCE_DBUS_SERVER_LOGD("fence_id: %d", fence_id);
sloc_geofence_complete_add_geofence(geofence, invocation, fence_id);
return TRUE;
}
-static gboolean on_add_place(SLocGeofence *geofence, GDBusMethodInvocation *invocation, const gchar *app_id, const gchar *place_name, gpointer user_data)
+static gboolean on_delete_geofence(SLocGeofence *geofence, GDBusMethodInvocation *invocation, gint fence_id, const gchar *app_id, gpointer user_data)
{
- GEOFENCE_DBUS_SERVER_LOGD("on_add_place");
+ GEOFENCE_DBUS_SERVER_LOGD("on_delete_geofence");
- /* call geofence-server's callback, add_place_cb */
+ /* call geofence-server's callback, delete_geofence_cb */
geofence_dbus_server_s *ctx = (geofence_dbus_server_s *)user_data;
- if (!ctx)
- return FALSE;
- gint place_id = 0;
- if (ctx->add_geofence_cb) {
- place_id = ctx->add_place_cb(app_id, place_name, ctx->userdata);
- GEOFENCE_DBUS_SERVER_LOGD("add_place_cb called");
+ if (!ctx) return FALSE;
+
+ if (ctx->dbus_callback && ctx->dbus_callback->delete_geofence_cb) {
+ ctx->dbus_callback->delete_geofence_cb(fence_id, app_id, ctx->userdata);
+ GEOFENCE_DBUS_SERVER_LOGD("delete_geofence_cb called");
}
- sloc_geofence_complete_add_place(geofence, invocation, place_id);
+ sloc_geofence_complete_delete_geofence(geofence, invocation);
return TRUE;
}
-static gboolean on_enable_geofence(SLocGeofence *geofence, GDBusMethodInvocation *invocation, gint fence_id, const gchar *app_id, gboolean enable, gpointer user_data)
+static gboolean on_get_geofences(SLocGeofence *geofence, GDBusMethodInvocation *invocation, gint place_id, const gchar *app_id, gpointer user_data)
{
- GEOFENCE_DBUS_SERVER_LOGD("on_enable_geofence");
+ GEOFENCE_DBUS_SERVER_LOGD("ENTER >>>");
+ /* call geofence-server's callback, getlist_geofence_cb */
geofence_dbus_server_s *ctx = (geofence_dbus_server_s *)user_data;
- if (!ctx)
- return FALSE;
+ if (!ctx) return FALSE;
- /* call geofence-server's callback, enable_geofence_cb */
- if (ctx->enable_geofence_cb) {
- ctx->enable_geofence_cb(fence_id, app_id, enable, ctx->userdata);
- GEOFENCE_DBUS_SERVER_LOGD("enable_geofence_cb called");
+ GVariant *geofence_info = NULL;
+ gint fence_cnt = 0;
+ gint error_code = -1;
+
+ if (ctx->dbus_callback && ctx->dbus_callback->get_geofences_cb) {
+ geofence_info = ctx->dbus_callback->get_geofences_cb(place_id, app_id, &fence_cnt, &error_code, ctx->userdata);
+ GEOFENCE_DBUS_SERVER_LOGD("getlist_geofence_cb called");
}
- sloc_geofence_complete_enable_geofence(geofence, invocation);
+ sloc_geofence_complete_get_geofences(geofence, invocation, fence_cnt, error_code, geofence_info);
return TRUE;
}
-static gboolean on_update_place(SLocGeofence *geofence, GDBusMethodInvocation *invocation, gint place_id, const gchar *app_id, const gchar *place_name, gpointer user_data)
+static gboolean on_enable_geofence(SLocGeofence *geofence, GDBusMethodInvocation *invocation, gint fence_id, const gchar *app_id, gboolean enable, gpointer user_data)
{
- GEOFENCE_DBUS_SERVER_LOGD("on_update_place");
+ GEOFENCE_DBUS_SERVER_LOGD("on_enable_geofence");
- /* call geofence-server's callback, update_place_cb */
geofence_dbus_server_s *ctx = (geofence_dbus_server_s *)user_data;
- if (!ctx)
- return FALSE;
- if (ctx->update_place_cb) {
- ctx->update_place_cb(place_id, app_id, place_name, ctx->userdata);
- GEOFENCE_DBUS_SERVER_LOGD("update_place_cb called");
+ if (!ctx) return FALSE;
+
+ /* call geofence-server's callback, enable_geofence_cb */
+ if (ctx->dbus_callback && ctx->dbus_callback->enable_geofence_cb) {
+ ctx->dbus_callback->enable_geofence_cb(fence_id, app_id, enable, ctx->userdata);
+ GEOFENCE_DBUS_SERVER_LOGD("enable_geofence_cb called");
}
- sloc_geofence_complete_update_place(geofence, invocation);
+ sloc_geofence_complete_enable_geofence(geofence, invocation);
return TRUE;
}
-static gboolean on_getplacename_geofence(SLocGeofence *geofence, GDBusMethodInvocation *invocation, gint place_id, const gchar *app_id, gpointer user_data)
+static gboolean on_start_geofence(SLocGeofence *geofence, GDBusMethodInvocation *invocation, gint fence_id, const gchar *app_id, gpointer user_data)
{
- GEOFENCE_DBUS_SERVER_LOGD("on_getplacename_geofence");
+ GEOFENCE_DBUS_SERVER_LOGD("on_start_geofence");
- /* call geofence-server's callback, getplacename_geofence_cb */
geofence_dbus_server_s *ctx = (geofence_dbus_server_s *)user_data;
- if (!ctx) {
- return FALSE;
- }
- char *place_name = NULL;
- gint error_code = -1;
- if (ctx->getplacename_geofence_cb) {
- ctx->getplacename_geofence_cb(place_id, app_id, &place_name, &error_code, ctx->userdata);
- GEOFENCE_DBUS_SERVER_LOGD("getlist_geofence_cb called");
+ if (!ctx) return FALSE;
+ /* call geofence-server's callback, start_geofence_cb */
+ if (ctx->dbus_callback && ctx->dbus_callback->start_geofence_cb) {
+ ctx->dbus_callback->start_geofence_cb(fence_id, app_id, ctx->userdata);
+ GEOFENCE_DBUS_SERVER_LOGD("start_geofence_cb called");
}
- sloc_geofence_complete_get_place_name(geofence, invocation, error_code, place_name);
- if (place_name)
- g_free(place_name); /*This has to be freed as it has been allocated by the server DB side*/
+ sloc_geofence_complete_start_geofence(geofence, invocation);
return TRUE;
}
-static gboolean on_getlist_geofence(SLocGeofence *geofence, GDBusMethodInvocation *invocation, gint place_id, const gchar *app_id, gpointer user_data)
+static gboolean on_stop_geofence(SLocGeofence *geofence, GDBusMethodInvocation *invocation, gint fence_id, const gchar *app_id, gpointer user_data)
{
- GEOFENCE_DBUS_SERVER_LOGD("on_getlist_geofence");
+ GEOFENCE_DBUS_SERVER_LOGD("on_stop_geofence");
- /* call geofence-server's callback, getlist_geofence_cb */
geofence_dbus_server_s *ctx = (geofence_dbus_server_s *)user_data;
- if (!ctx)
- return FALSE;
-
- GVariant *geofence_info = NULL;
- gint fence_cnt = 0;
- gint error_code = -1;
- if (ctx->getlist_geofence_cb) {
- geofence_info = ctx->getlist_geofence_cb(place_id, app_id, &fence_cnt, &error_code, ctx->userdata);
- GEOFENCE_DBUS_SERVER_LOGD("getlist_geofence_cb called");
+ if (!ctx) return FALSE;
+ /* call geofence-server's callback, stop_geofence_cb */
+ if (ctx->dbus_callback && ctx->dbus_callback->stop_geofence_cb) {
+ ctx->dbus_callback->stop_geofence_cb(fence_id, app_id, ctx->userdata);
+ GEOFENCE_DBUS_SERVER_LOGD("stop_geofence_cb called");
}
- sloc_geofence_complete_get_list(geofence, invocation, fence_cnt, error_code, geofence_info);
+ sloc_geofence_complete_stop_geofence(geofence, invocation);
return TRUE;
}
-static gboolean on_getplacelist_geofence(SLocGeofence *geofence, GDBusMethodInvocation *invocation, const gchar *app_id, gpointer user_data)
+static gboolean on_add_place(SLocGeofence *geofence, GDBusMethodInvocation *invocation, const gchar *app_id, const gchar *place_name, gpointer user_data)
{
- GEOFENCE_DBUS_SERVER_LOGD("on_getplacelist_geofence");
+ GEOFENCE_DBUS_SERVER_LOGD("on_add_place");
- /* call geofence-server's callback, getplacelist_geofence_cb */
+ /* call geofence-server's callback, add_place_cb */
geofence_dbus_server_s *ctx = (geofence_dbus_server_s *)user_data;
- if (!ctx)
- return FALSE;
- GVariant *place_info = NULL;
- gint place_cnt = 0;
- gint error_code = -1;
- if (ctx->getplacelist_geofence_cb) {
- place_info = ctx->getplacelist_geofence_cb(app_id, &place_cnt, &error_code, ctx->userdata);
- GEOFENCE_DBUS_SERVER_LOGD("getplacelist_geofence_cb called");
+ if (!ctx) return FALSE;
+ gint place_id = -1;
+ if (ctx->dbus_callback && ctx->dbus_callback->add_place_cb) {
+ place_id = ctx->dbus_callback->add_place_cb(app_id, place_name, ctx->userdata);
+ GEOFENCE_DBUS_SERVER_LOGD("add_place_cb called");
}
- sloc_geofence_complete_get_place_list(geofence, invocation, place_cnt, error_code, place_info);
+ sloc_geofence_complete_add_place(geofence, invocation, place_id);
return TRUE;
}
-static gboolean on_delete_geofence(SLocGeofence *geofence, GDBusMethodInvocation *invocation, gint fence_id, const gchar *app_id, gpointer user_data)
+static gboolean on_update_place(SLocGeofence *geofence, GDBusMethodInvocation *invocation, gint place_id, const gchar *app_id, const gchar *place_name, gpointer user_data)
{
- GEOFENCE_DBUS_SERVER_LOGD("on_delete_geofence");
+ GEOFENCE_DBUS_SERVER_LOGD("on_update_place");
- /* call geofence-server's callback, delete_geofence_cb */
+ /* call geofence-server's callback, update_place_cb */
geofence_dbus_server_s *ctx = (geofence_dbus_server_s *)user_data;
- if (!ctx)
- return FALSE;
- if (ctx->delete_geofence_cb) {
- ctx->delete_geofence_cb(fence_id, app_id, ctx->userdata);
- GEOFENCE_DBUS_SERVER_LOGD("delete_geofence_cb called");
+ if (!ctx) return FALSE;
+
+ if (ctx->dbus_callback && ctx->dbus_callback->update_place_cb) {
+ ctx->dbus_callback->update_place_cb(place_id, app_id, place_name, ctx->userdata);
+ GEOFENCE_DBUS_SERVER_LOGD("update_place_cb called");
}
- sloc_geofence_complete_delete_geofence(geofence, invocation);
+ sloc_geofence_complete_update_place(geofence, invocation);
return TRUE;
}
/* call geofence-server's callback, delete_place_cb */
geofence_dbus_server_s *ctx = (geofence_dbus_server_s *)user_data;
- if (!ctx)
- return FALSE;
- if (ctx->delete_place_cb) {
- ctx->delete_place_cb(place_id, app_id, ctx->userdata);
+ if (!ctx) return FALSE;
+
+ if (ctx->dbus_callback && ctx->dbus_callback->delete_place_cb) {
+ ctx->dbus_callback->delete_place_cb(place_id, app_id, ctx->userdata);
GEOFENCE_DBUS_SERVER_LOGD("delete_place_cb called");
}
sloc_geofence_complete_delete_place(geofence, invocation);
return TRUE;
}
-static gboolean on_start_geofence(SLocGeofence *geofence, GDBusMethodInvocation *invocation, gint fence_id, const gchar *app_id, gpointer user_data)
+static gboolean on_get_place_name(SLocGeofence *geofence, GDBusMethodInvocation *invocation, gint place_id, const gchar *app_id, gpointer user_data)
{
- GEOFENCE_DBUS_SERVER_LOGD("on_start_geofence");
+ GEOFENCE_DBUS_SERVER_LOGD("on_getplacename_geofence");
+ /* call geofence-server's callback, getplacename_geofence_cb */
geofence_dbus_server_s *ctx = (geofence_dbus_server_s *)user_data;
- if (!ctx)
- return FALSE;
- /* call geofence-server's callback, start_geofence_cb */
- if (ctx->start_geofence_cb) {
- ctx->start_geofence_cb(fence_id, app_id, ctx->userdata);
- GEOFENCE_DBUS_SERVER_LOGD("start_geofence_cb called");
+ if (!ctx) return FALSE;
+
+ char *place_name = NULL;
+ gint error_code = -1;
+ if (ctx->dbus_callback && ctx->dbus_callback->add_place_cb) {
+ ctx->dbus_callback->get_place_name_cb(place_id, app_id, &place_name, &error_code, ctx->userdata);
+ GEOFENCE_DBUS_SERVER_LOGD("getlist_geofence_cb called");
}
- sloc_geofence_complete_start_geofence(geofence, invocation);
+ sloc_geofence_complete_get_place_name(geofence, invocation, error_code, place_name);
+ if (place_name)
+ g_free(place_name); /*This has to be freed as it has been allocated by the server DB side*/
return TRUE;
}
-static gboolean on_stop_geofence(SLocGeofence *geofence, GDBusMethodInvocation *invocation, gint fence_id, const gchar *app_id, gpointer user_data)
+static gboolean on_get_places(SLocGeofence *geofence, GDBusMethodInvocation *invocation, const gchar *app_id, gpointer user_data)
{
- GEOFENCE_DBUS_SERVER_LOGD("on_stop_geofence");
+ GEOFENCE_DBUS_SERVER_LOGD("ENTER >>>");
+ /* call geofence-server's callback, getplacelist_geofence_cb */
geofence_dbus_server_s *ctx = (geofence_dbus_server_s *)user_data;
- if (!ctx)
- return FALSE;
- /* call geofence-server's callback, stop_geofence_cb */
- if (ctx->stop_geofence_cb) {
- ctx->stop_geofence_cb(fence_id, app_id, ctx->userdata);
- GEOFENCE_DBUS_SERVER_LOGD("stop_geofence_cb called");
+ if (!ctx) return FALSE;
+
+ GVariant *place_info = NULL;
+ gint place_cnt = 0;
+ gint error_code = -1;
+ if (ctx->dbus_callback && ctx->dbus_callback->add_place_cb) {
+ place_info = ctx->dbus_callback->get_places_cb(app_id, &place_cnt, &error_code, ctx->userdata);
+ GEOFENCE_DBUS_SERVER_LOGD("get_places_cb called");
}
- sloc_geofence_complete_stop_geofence(geofence, invocation);
+ sloc_geofence_complete_get_places(geofence, invocation, place_cnt, error_code, place_info);
return TRUE;
}
+/*#if SUPPORT_MULTI_CLIENT */
static gboolean geofence_remove_client_by_force(const char *client, void *data)
{
GEOFENCE_DBUS_SERVER_LOGD("remove client by force for client [%s]", client);
GEOFENCE_DBUS_SERVER_LOGE("g_hash_table_remove is Fail");
}
- int index = 0;
- gboolean *shutdown_arr = (gboolean *)g_malloc0_n(GEOFENCE_DBUS_SERVER_METHOD_SIZE, sizeof(gboolean));
- if (shutdown_arr == NULL) {
- GEOFENCE_DBUS_SERVER_LOGD("malloc fail for geofence_remove_client_by_force");
- return FALSE;
- }
+#if SUPPORT_MULTI_CLIENT
+ gboolean shutdown_arr = FALSE;
if (g_hash_table_size(ctx->connections) == 0) {
- GEOFENCE_DBUS_SERVER_SECLOG("Hash table size is zero, Now shutdown provider[%s]", ctx->name);
-
- for (; index < GEOFENCE_DBUS_SERVER_METHOD_SIZE; index++)
- shutdown_arr[index] = TRUE;
+ GEOFENCE_DBUS_SERVER_SECLOG("Hash table size is zero, Now shutdown provider[%s]", ctx->prev_owner);
+ shutdown_arr = TRUE;
} else {
GEOFENCE_DBUS_SERVER_SECLOG("Hash table size is not zero");
-
- for (; index < GEOFENCE_DBUS_SERVER_METHOD_SIZE; index++) {
- if (g_hash_table_find(ctx->connections, (GHRFunc) geofence_find_method, &index) == NULL) {
- shutdown_arr[index] = TRUE;
- continue;
- }
- }
}
if (ctx->shutdown_cb) {
ctx->shutdown_cb(ctx->userdata, shutdown_arr);
- GEOFENCE_DBUS_SERVER_LOGD("shutdown_cb called.. gps:%d, nps:%d", shutdown_arr[GEOFENCE_DBUS_SERVER_METHOD_GPS], shutdown_arr[GEOFENCE_DBUS_SERVER_METHOD_NPS]);
+ GEOFENCE_DBUS_SERVER_LOGD("shutdown_cb called..[%d]", shutdown_arr);
}
+#endif
GEOFENCE_DBUS_SERVER_LOGD("###### A client[%s] is abnormally shut down ########", client);
- g_free(shutdown_arr);
+
return TRUE;
}
g_hash_table_foreach(handle->connections, (GHFunc) geofence_scan_sender, handle);
}
}
+/*#endif */
static void on_bus_acquired(GDBusConnection *conn, const gchar *name, gpointer user_data)
{
geofence_dbus_server_s *ctx = (geofence_dbus_server_s *)user_data;
- if (!ctx)
- return;
+ g_return_if_fail(ctx);
gchar *path = NULL;
SLocGeofence *geofence = NULL;
/* register callback for each methods for geofence */
geofence = sloc_object_get_geofence(SLOC_OBJECT(ctx->obj_skeleton));
}
- if (geofence == NULL)
+ if (geofence == NULL) {
+ GEOFENCE_DBUS_SERVER_LOGE("Can't create geofence object");
return;
+ }
+
+ geofence_dbus_callback_s *dbus_callback = ctx->dbus_callback;
+ geofence_dbus_signal_s *dbus_signal = g_new0(geofence_dbus_signal_s, 1);
+ g_return_val_if_fail(dbus_signal, GEOFENCE_DBUS_SERVER_ERROR_MEMORY);
+
+ if (dbus_callback->add_geofence_cb)
+ dbus_signal->add_geofence_h = g_signal_connect(geofence, "handle-add-geofence", G_CALLBACK(on_add_geofence), ctx);
+ if (dbus_callback->delete_geofence_cb)
+ dbus_signal->delete_geofence_h = g_signal_connect(geofence, "handle-delete-geofence", G_CALLBACK(on_delete_geofence), ctx);
+ if (dbus_callback->get_geofences_cb)
+ dbus_signal->get_geofences_h = g_signal_connect(geofence, "handle-get-geofences", G_CALLBACK(on_get_geofences), ctx);
+ if (dbus_callback->enable_geofence_cb)
+ dbus_signal->enable_geofence_h = g_signal_connect(geofence, "handle-enable-geofence", G_CALLBACK(on_enable_geofence), ctx);
+ if (dbus_callback->start_geofence_cb)
+ dbus_signal->start_geofence_h = g_signal_connect(geofence, "handle-start-geofence", G_CALLBACK(on_start_geofence), ctx);
+ if (dbus_callback->stop_geofence_cb)
+ dbus_signal->stop_geofence_h = g_signal_connect(geofence, "handle-stop-geofence", G_CALLBACK(on_stop_geofence), ctx);
+
+ if (dbus_callback->add_place_cb)
+ dbus_signal->add_place_h = g_signal_connect(geofence, "handle-add-place", G_CALLBACK(on_add_place), ctx);
+ if (dbus_callback->update_place_cb)
+ dbus_signal->update_place_h = g_signal_connect(geofence, "handle-update-place", G_CALLBACK(on_update_place), ctx);
+ if (dbus_callback->delete_place_cb)
+ dbus_signal->delete_place_h = g_signal_connect(geofence, "handle-delete-place", G_CALLBACK(on_delete_place), ctx);
+ if (dbus_callback->get_place_name_cb)
+ dbus_signal->get_place_name_h = g_signal_connect(geofence, "handle-get-place-name", G_CALLBACK(on_get_place_name), ctx);
+ if (dbus_callback->get_places_cb)
+ dbus_signal->get_places_h = g_signal_connect(geofence, "handle-get-places", G_CALLBACK(on_get_places), ctx);
+
+ ctx->dbus_signal = dbus_signal;
- if (ctx->add_geofence_cb)
- ctx->add_geofence_h = g_signal_connect(geofence, "handle-add-geofence", G_CALLBACK(on_add_geofence), ctx); /* user_data */
- if (ctx->add_place_cb)
- ctx->add_place_h = g_signal_connect(geofence, "handle-add-place", G_CALLBACK(on_add_place), ctx); /* user_data */
- if (ctx->enable_geofence_cb)
- ctx->enable_geofence_h = g_signal_connect(geofence, "handle-enable-geofence", G_CALLBACK(on_enable_geofence), ctx); /* user_data */
- if (ctx->update_place_cb)
- ctx->update_place_h = g_signal_connect(geofence, "handle-update-place", G_CALLBACK(on_update_place), ctx); /* user_data */
- if (ctx->delete_geofence_cb)
- ctx->delete_geofence_h = g_signal_connect(geofence, "handle-delete-geofence", G_CALLBACK(on_delete_geofence), ctx); /* user_data */
- if (ctx->delete_place_cb)
- ctx->delete_place_h = g_signal_connect(geofence, "handle-delete-place", G_CALLBACK(on_delete_place), ctx); /* user_data */
- if (ctx->start_geofence_cb)
- ctx->start_geofence_h = g_signal_connect(geofence, "handle-start-geofence", G_CALLBACK(on_start_geofence), ctx); /* user_data */
- if (ctx->stop_geofence_cb)
- ctx->stop_geofence_h = g_signal_connect(geofence, "handle-stop-geofence", G_CALLBACK(on_stop_geofence), ctx); /* user_data */
- if (ctx->getplacename_geofence_cb)
- ctx->getplacename_geofence_h = g_signal_connect(geofence, "handle-get-place-name", G_CALLBACK(on_getplacename_geofence), ctx);
- if (ctx->getlist_geofence_cb)
- ctx->getlist_geofence_h = g_signal_connect(geofence, "handle-get-list", G_CALLBACK(on_getlist_geofence), ctx); /*user_data */
- if (ctx->getplacelist_geofence_cb)
- ctx->getplacelist_geofence_h = g_signal_connect(geofence, "handle-get-place-list", G_CALLBACK(on_getplacelist_geofence), ctx);
g_object_unref(geofence);
+ /*#if SUPPORT_MULTI_CLIENT //TODO: We need it? */
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);
+ /*#endif */
+
g_dbus_object_manager_server_set_connection(ctx->manager, conn);
GEOFENCE_DBUS_SERVER_LOGD("done to acquire the dbus");
}
EXPORT_API int geofence_dbus_server_send_geofence_inout_changed(geofence_dbus_server_h geofence_dbus_server, const gchar *app_id, gint fence_id, gint access_type, gint fence_state)
{
- GEOFENCE_DBUS_SERVER_LOGD("geofence_dbus_server_send_geofence_inout_changed");
+ GEOFENCE_DBUS_SERVER_LOGD("ENTER >>>");
g_return_val_if_fail(geofence_dbus_server, GEOFENCE_DBUS_SERVER_ERROR_PARAMETER);
geofence_dbus_server_s *handle = (geofence_dbus_server_s *)geofence_dbus_server;
EXPORT_API int geofence_dbus_server_send_geofence_event_changed(geofence_dbus_server_h geofence_dbus_server, gint place_id, gint fence_id, gint access_type, const gchar *app_id, gint error, gint state)
{
- GEOFENCE_DBUS_SERVER_LOGD("geofence_dbus_server_send_geofence_event_changed");
+ GEOFENCE_DBUS_SERVER_LOGD("ENTER >>>");
g_return_val_if_fail(geofence_dbus_server, GEOFENCE_DBUS_SERVER_ERROR_PARAMETER);
geofence_dbus_server_s *handle = (geofence_dbus_server_s *)geofence_dbus_server;
g_return_val_if_fail(handle->obj_skeleton, GEOFENCE_DBUS_SERVER_ERROR_PARAMETER);
return GEOFENCE_DBUS_SERVER_ERROR_NONE;
}
-static void _glib_log(const gchar *log_domain, GLogLevelFlags log_level, const gchar *msg, gpointer user_data)
+/* Because of this, geofence-server's handler doesn't work. */
+#if 0
+static void __glib_log(const gchar *log_domain, GLogLevelFlags log_level, const gchar *msg, gpointer user_data)
{
geofence_dbus_server_s *server = (geofence_dbus_server_s *)user_data;
if (server != NULL)
GEOFENCE_DBUS_SERVER_LOGD("server->manager (%p)", server->manager);
GEOFENCE_DBUS_SERVER_LOGE("GLIB[%d] : %s", log_level, msg);
}
+#endif
-EXPORT_API int geofence_dbus_server_create(char *service_name, char *service_path, char *name, char *description, geofence_dbus_server_h *geofence_dbus_server, GeofenceAddGeofenceCB add_geofence_cb, GeofenceAddPlaceCB add_place_cb, GeofenceEnableGeofenceCB enable_geofence_cb, GeofenceUpdatePlaceCB update_place_cb, GeofenceDeleteGeofenceCB delete_geofence_cb, GeofenceDeletePlaceCB delete_place_cb, GeofenceGetPlaceNameGeofenceCB getplacename_geofence_cb, GeofenceGetlistGeofenceCB getlist_geofence_cb, GeofenceGetPlaceListGeofenceCB getplacelist_geofence_cb, GeofenceStartGeofenceCB start_geofence_cb, GeofenceStopGeofenceCB stop_geofence_cb, gpointer userdata)
+EXPORT_API int geofence_dbus_server_create(geofence_dbus_server_h *geofence_dbus_server, geofence_dbus_callback_s *geofence_dbus_callback, gpointer userdata)
{
GEOFENCE_DBUS_SERVER_LOGD("geofence_dbus_server_create");
- g_return_val_if_fail(service_name, GEOFENCE_DBUS_SERVER_ERROR_PARAMETER);
- g_return_val_if_fail(service_path, GEOFENCE_DBUS_SERVER_ERROR_PARAMETER);
g_return_val_if_fail(geofence_dbus_server, GEOFENCE_DBUS_SERVER_ERROR_PARAMETER);
+ g_return_val_if_fail(geofence_dbus_callback, GEOFENCE_DBUS_SERVER_ERROR_PARAMETER);
int ret = GEOFENCE_DBUS_SERVER_ERROR_NONE;
geofence_dbus_server_s *server = g_new0(geofence_dbus_server_s, 1);
g_return_val_if_fail(server, GEOFENCE_DBUS_SERVER_ERROR_MEMORY);
- g_log_set_default_handler(_glib_log, server);
+ /* g_log_set_default_handler(__glib_log, server); */
- server->service_name = g_strdup(service_name);
- server->service_path = g_strdup(service_path);
+ server->service_name = g_strdup(GEOFENCE_SERVICE_NAME);
+ server->service_path = g_strdup(GEOFENCE_SERVICE_PATH);
server->manager = g_dbus_object_manager_server_new(server->service_path);
-
- if (name)
- server->name = g_strdup(name);
- if (description)
- server->description = g_strdup(description);
-
server->connections = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
server->userdata = userdata;
- /* add gefence callbacks */
- server->add_geofence_cb = add_geofence_cb;
- server->add_place_cb = add_place_cb;
- server->enable_geofence_cb = enable_geofence_cb;
- server->update_place_cb = update_place_cb;
- server->delete_geofence_cb = delete_geofence_cb;
- server->delete_place_cb = delete_place_cb;
- server->getplacename_geofence_cb = getplacename_geofence_cb;
- server->getlist_geofence_cb = getlist_geofence_cb;
- server->getplacelist_geofence_cb = getplacelist_geofence_cb;
- server->start_geofence_cb = start_geofence_cb;
- server->stop_geofence_cb = stop_geofence_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);
+ /* set gefence callbacks */
+ server->dbus_callback = geofence_dbus_callback;
+
+ server->owner_id = g_bus_own_name(G_BUS_TYPE_SYSTEM, server->service_name, G_BUS_NAME_OWNER_FLAGS_REPLACE, on_bus_acquired, on_name_acquired, on_name_lost, server, NULL);
GEOFENCE_DBUS_SERVER_LOGD("g_bus_own_name id=[%d]", server->owner_id);
- *geofence_dbus_server = (geofence_dbus_server_h *) server;
+ *geofence_dbus_server = (geofence_dbus_server_s *) server;
return ret;
}
-
EXPORT_API int geofence_dbus_server_destroy(geofence_dbus_server_h geofence_dbus_server)
{
GEOFENCE_DBUS_SERVER_LOGD("geofence_dbus_server_destroy");
g_return_val_if_fail(geofence_dbus_server, GEOFENCE_DBUS_SERVER_ERROR_PARAMETER);
- geofence_dbus_server_s *handle = (geofence_dbus_server_s *)geofence_dbus_server;
+ geofence_dbus_server_s *server = (geofence_dbus_server_s *)geofence_dbus_server;
int ret = GEOFENCE_DBUS_SERVER_ERROR_NONE;
- g_bus_unown_name(handle->owner_id);
- if (handle->prev_owner) {
- g_free(handle->prev_owner);
- handle->prev_owner = NULL;
+ g_bus_unown_name(server->owner_id);
+ if (server->prev_owner) {
+ g_free(server->prev_owner);
+ server->prev_owner = NULL;
}
/* disconnect geofence callbacks */
SLocGeofence *geofence = NULL;
- geofence = sloc_object_get_geofence(SLOC_OBJECT(handle->obj_skeleton));
+ geofence = sloc_object_get_geofence(SLOC_OBJECT(server->obj_skeleton));
g_return_val_if_fail(geofence, GEOFENCE_DBUS_SERVER_ERROR_PARAMETER);
+ geofence_dbus_signal_s *handle = server->dbus_signal;
+ g_return_val_if_fail(handle, GEOFENCE_DBUS_SERVER_ERROR_PARAMETER);
+
if (handle->add_geofence_h) {
g_signal_handler_disconnect(geofence, handle->add_geofence_h);
handle->add_geofence_h = 0;
}
- if (handle->add_place_h) {
- g_signal_handler_disconnect(geofence, handle->add_place_h);
- handle->add_place_h = 0;
- }
- if (handle->enable_geofence_h) {
- g_signal_handler_disconnect(geofence, handle->enable_geofence_h);
- handle->enable_geofence_h = 0;
- }
- if (handle->update_place_h) {
- g_signal_handler_disconnect(geofence, handle->update_place_h);
- handle->update_place_h = 0;
- }
if (handle->delete_geofence_h) {
g_signal_handler_disconnect(geofence, handle->delete_geofence_h);
handle->delete_geofence_h = 0;
}
- if (handle->delete_place_h) {
- g_signal_handler_disconnect(geofence, handle->delete_place_h);
- handle->delete_place_h = 0;
+ if (handle->get_geofences_h) {
+ g_signal_handler_disconnect(geofence, handle->get_geofences_h);
+ handle->get_geofences_h = 0;
+ }
+ if (handle->enable_geofence_h) {
+ g_signal_handler_disconnect(geofence, handle->enable_geofence_h);
+ handle->enable_geofence_h = 0;
}
if (handle->start_geofence_h) {
g_signal_handler_disconnect(geofence, handle->start_geofence_h);
g_signal_handler_disconnect(geofence, handle->stop_geofence_h);
handle->stop_geofence_h = 0;
}
- if (handle->getplacename_geofence_h) {
- g_signal_handler_disconnect(geofence, handle->getplacename_geofence_h);
- handle->getplacename_geofence_h = 0;
+
+ if (handle->add_place_h) {
+ g_signal_handler_disconnect(geofence, handle->add_place_h);
+ handle->add_place_h = 0;
+ }
+ if (handle->update_place_h) {
+ g_signal_handler_disconnect(geofence, handle->update_place_h);
+ handle->update_place_h = 0;
+ }
+ if (handle->delete_place_h) {
+ g_signal_handler_disconnect(geofence, handle->delete_place_h);
+ handle->delete_place_h = 0;
}
- if (handle->getlist_geofence_h) {
- g_signal_handler_disconnect(geofence, handle->getlist_geofence_h);
- handle->getlist_geofence_h = 0;
+ if (handle->get_place_name_h) {
+ g_signal_handler_disconnect(geofence, handle->get_place_name_h);
+ handle->get_place_name_h = 0;
}
- if (handle->getplacelist_geofence_h) {
- g_signal_handler_disconnect(geofence, handle->getplacelist_geofence_h);
- handle->getplacelist_geofence_h = 0;
+ if (handle->get_places_h) {
+ g_signal_handler_disconnect(geofence, handle->get_places_h);
+ handle->get_places_h = 0;
}
+ g_free(handle);
g_object_unref(geofence);
- if (handle->manager) {
- 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;
+ if (server->manager) {
+ if (server->owner_changed_id) {
+ g_dbus_connection_signal_unsubscribe(g_dbus_object_manager_server_get_connection(server->manager), server->owner_changed_id);
+ server->owner_changed_id = 0;
}
- g_object_unref(handle->manager);
- handle->manager = NULL;
+ g_object_unref(server->manager);
+ server->manager = NULL;
}
- g_hash_table_destroy(handle->connections);
- g_free(handle);
+ g_hash_table_destroy(server->connections);
+
+ g_free(server->service_name);
+ g_free(server->service_path);
+
+ g_free(server);
return ret;
}
projects / platform / core / location / geofence-dbus.git / commitdiff