From 392d135f6bdf3b53fedb9c6fdb5c366d404c23d5 Mon Sep 17 00:00:00 2001 From: jomui Date: Wed, 29 Jul 2015 19:04:16 +0900 Subject: [PATCH] sync with tizen_2.4 Signed-off-by: jomui Change-Id: Id3aa381a6872a49338bf206ed1a209f29045d3b9 --- CMakeLists.txt | 6 +- geofence-server/include/geofence-module.h | 86 --- .../include/geofence_server_data_types.h | 105 ++-- .../include/geofence_server_extra_data_types.h | 3 +- geofence-server/src/debug_util.h | 2 +- geofence-server/src/geofence_server.c | 600 +++++++++++---------- geofence-server/src/geofence_server.h | 42 +- geofence-server/src/geofence_server_bluetooth.c | 10 +- geofence-server/src/geofence_server_db.c | 41 +- geofence-server/src/geofence_server_internal.c | 2 +- geofence-server/src/geofence_server_log.c | 6 +- geofence-server/src/geofence_server_log.h | 4 +- geofence-server/src/geofence_server_private.h | 10 +- geofence-server/src/server.h | 6 +- module/CMakeLists.txt | 1 - module/log.h | 5 - module/module_geofence_server.c | 315 +++++------ module/module_internal.c | 143 ----- module/module_internal.h | 102 ---- packaging/geofence-server.spec | 48 +- 20 files changed, 600 insertions(+), 937 deletions(-) delete mode 100644 geofence-server/include/geofence-module.h delete mode 100644 module/module_internal.c delete mode 100644 module/module_internal.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 39189a4..749eb11 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -8,7 +8,7 @@ SET(BIN_DIR "${PREFIX}/bin") SET(common_dp "glib-2.0 geofence-dbus dlog gio-2.0 capi-appfw-app-manager") SET(server_dp "${common_dp} network vconf vconf-internal-keys gthread-2.0 gio-unix-2.0 sqlite3 db-util alarm-service deviced capi-location-manager capi-network-bluetooth capi-network-wifi libcore-context-manager") -SET(module_dp "${common_dp} gmodule-2.0") +SET(module_dp "${common_dp} gmodule-2.0 capi-geofence-manager") # Set required packages INCLUDE(FindPkgConfig) @@ -25,10 +25,10 @@ FOREACH(flag ${module_pkgs_CFLAGS}) SET(MODULE_EXTRA_CFLAGS "${MODULE_EXTRA_CFLAGS} ${flag}") ENDFOREACH(flag) -SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} -Wl,-zdefs -fvisibility=hidden ") +SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} -Wl,-zdefs ") SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS}") -SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -fvisibility=hidden -fPIC") +SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror -fvisibility=hidden -fPIC") #SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-unused-parameter -Wno-missing-field-initializers -Wno-missing-declarations -Wall -Wcast-align -Wno-sign-compare") SET(SERVER_SRCS_DIR "${CMAKE_CURRENT_SOURCE_DIR}/geofence-server") diff --git a/geofence-server/include/geofence-module.h b/geofence-server/include/geofence-module.h deleted file mode 100644 index 67361b4..0000000 --- a/geofence-server/include/geofence-module.h +++ /dev/null @@ -1,86 +0,0 @@ -/* Copyright 2014 Samsung Electronics Co., Ltd All Rights Reserved - * - * 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 __GEOFENCE_MODULE_H__ -#define __GEOFENCE_MODULE_H__ - -#ifdef __cplusplus -extern "C" { -#endif - -/** - * @file geofence-module.h - * @brief This file contains the structure and enumeration for geofence plug-in development. - */ - - -/** - * @brief This represents geofence parameter. - */ -typedef enum { - GEOFENCE_TYPE_GEOPOINT = 1, /**< Geofence is specified by geo position */ - GEOFENCE_TYPE_WIFI, /**< Geofence is specified by WiFi hotspot */ - GEOFENCE_TYPE_BT, /**< Geofence is specified BT */ -} geofence_type_e; - -typedef enum { - ACCESS_TYPE_PRIVATE = 1, - ACCESS_TYPE_PUBLIC, - ACCESS_TYPE_UNKNOWN, -} access_type_e; - -/** - * @brief The geofence manager handle. - */ -typedef struct place_params_s *place_params_h; -/** - * @brief The geofence params handle. - */ -typedef struct geofence_params_s *geofence_params_h; - -/** - * @brief This represents a geofence callback function for geofence plug-in. - */ -typedef void (*GeofenceModCB) (int fence_id, int state, gpointer userdata); - -typedef void (*GeofenceModEventCB) (int place_id, int fence_id, int error, int state, gpointer userdata); - -/** - * @brief This represents APIs declared in a Geofence plug-in for Geofence modules. - */ -typedef struct { - int (*create) (void *handle, GeofenceModCB geofence_cb, GeofenceModEventCB geofence_event_cb, void *userdata); - int (*destroy) (void *handle); - int (*enable_service) (void *handle, int fence_id, bool enable); - int (*add_geopoint) (void *handle, int place_id, double latitude, double longitude, int radius, const char *address, int *fence_id); - int (*add_bssid) (void *handle, int place_id, const char *bssid, const char *ssid, geofence_type_e type, int *fence_id); - int (*add_place) (void *handle, const char *place_name, int *place_id); - int (*update_place) (void *handle, int place_id, const char *place_name); - int (*remove_geofence) (void *handle, int fence_id); - int (*remove_place) (void *handle, int place_id); - int (*start_geofence) (void *handle, int fence_id); - int (*stop_geofence) (void *handle, int fence_id); - int (*get_place_name) (void *handle, int place_id, char **place_name); - int (*get_list) (void *handle, int place_id, int *fence_amount, int **fence_ids, struct geofence_params_s **params); - int (*get_place_list) (void *handle, int *place_amount, int **place_ids, struct place_params_s **params); -} GeofenceModOps; - -/** - * @} @} - */ -#ifdef __cplusplus -} -#endif -#endif diff --git a/geofence-server/include/geofence_server_data_types.h b/geofence-server/include/geofence_server_data_types.h index 36353d5..89e26b3 100644 --- a/geofence-server/include/geofence_server_data_types.h +++ b/geofence-server/include/geofence_server_data_types.h @@ -27,7 +27,7 @@ extern "C" { /* Tizen Geofence Server Error */ #if !defined(TIZEN_ERROR_GEOFENCE_SERVER) -#define TIZEN_ERROR_GEOFENCE_SERVER -0x02C10000 +#define TIZEN_ERROR_GEOFENCE_SERVER TIZEN_ERROR_GEOFENCE_MANAGER #endif /** @@ -36,33 +36,34 @@ extern "C" { typedef enum { GEOFENCE_STATUS_UNABAILABLE = 0, GEOFENCE_STATUS_ABAILABLE = 1, -} geofence_status_t; +} +geofence_status_t; /** * This enumeration descript the geofence fence state. */ typedef enum { - GEOFENCE_EMIT_STATE_UNCERTAIN = 0, - GEOFENCE_EMIT_STATE_IN = 1, - GEOFENCE_EMIT_STATE_OUT = 2, + GEOFENCE_EMIT_STATE_UNCERTAIN = 0, + GEOFENCE_EMIT_STATE_IN = 1, + GEOFENCE_EMIT_STATE_OUT = 2, } geofence_emit_state_e; /** * This enumeration descript the geofence fence state. */ typedef enum { - GEOFENCE_FENCE_STATE_UNCERTAIN = -1, - GEOFENCE_FENCE_STATE_OUT = 0, - GEOFENCE_FENCE_STATE_IN = 1, + GEOFENCE_FENCE_STATE_UNCERTAIN = -1, + GEOFENCE_FENCE_STATE_OUT = 0, + GEOFENCE_FENCE_STATE_IN = 1, } geofence_fence_state_e; /** * This enumeration descript the geofence state. */ typedef enum { - GEOFENCE_DIRECTION_BOTH = 0, - GEOFENCE_DIRECTION_ENTER, - GEOFENCE_DIRECTION_EXIT, + GEOFENCE_DIRECTION_BOTH = 0, + GEOFENCE_DIRECTION_ENTER, + GEOFENCE_DIRECTION_EXIT, } geofence_direction_e; /** @@ -70,16 +71,16 @@ typedef enum { */ typedef enum { - FENCE_ERR_NONE = 0, /** No error */ - FENCE_ERR_SQLITE_FAIL = -100, - FENCE_ERR_INVALID_PARAMETER = -101, - FENCE_ERR_INTERNAL = -102, - FENCE_ERR_FENCE_ID = -103, - FENCE_ERR_PREPARE = -104, - FENCE_ERR_FENCE_TYPE = -105, /* geofence type ERROR */ - FENCE_ERR_STRING_TRUNCATED = -106, /* String truncated */ - FENCE_ERR_COUNT = -107, /* count <= 0 */ - FENCE_ERR_UNKNOWN = -108 + FENCE_ERR_NONE = 0, /** No error */ + FENCE_ERR_SQLITE_FAIL = -100, + FENCE_ERR_INVALID_PARAMETER = -101, + FENCE_ERR_INTERNAL = -102, + FENCE_ERR_FENCE_ID = -103, + FENCE_ERR_PREPARE = -104, + FENCE_ERR_FENCE_TYPE = -105, /* geofence type ERROR */ + FENCE_ERR_STRING_TRUNCATED = -106, /* String truncated */ + FENCE_ERR_COUNT = -107, /* count <= 0 */ + FENCE_ERR_UNKNOWN = -108 } fence_err_e; /** @@ -87,47 +88,59 @@ typedef enum { * @since_tizen 2.4 */ typedef enum { - GEOFENCE_SERVER_ERROR_NONE = TIZEN_ERROR_NONE, /**< Success */ - GEOFENCE_SERVER_ERROR_OUT_OF_MEMORY = TIZEN_ERROR_OUT_OF_MEMORY, /**< Out of memory */ - GEOFENCE_SERVER_ERROR_INVALID_PARAMETER = TIZEN_ERROR_INVALID_PARAMETER, /**< Invalid parameter */ - GEOFENCE_SERVER_ERROR_PERMISSION_DENIED = TIZEN_ERROR_PERMISSION_DENIED, /**< Permission denied */ - GEOFENCE_SERVER_ERROR_NOT_SUPPORTED = TIZEN_ERROR_NOT_SUPPORTED, /**< Not supported */ - GEOFENCE_SERVER_ERROR_NOT_INITIALIZED = TIZEN_ERROR_GEOFENCE_SERVER | 0x01, /**< Geofence Manager is not initialized */ - GEOFENCE_SERVER_ERROR_ID_NOT_EXIST = TIZEN_ERROR_GEOFENCE_SERVER | 0x02, /**< Geofence ID is not exist */ - GEOFENCE_SERVER_ERROR_EXCEPTION = TIZEN_ERROR_GEOFENCE_SERVER | 0x03, /**< exception is occured */ - GEOFENCE_SERVER_ERROR_ALREADY_STARTED = TIZEN_ERROR_GEOFENCE_SERVER | 0x04, /**< Geofence is already started */ - GEOFENCE_SERVER_ERROR_TOO_MANY_GEOFENCE = TIZEN_ERROR_GEOFENCE_SERVER | 0x05, /**< Too many Geofence */ - GEOFENCE_SERVER_ERROR_IPC = TIZEN_ERROR_GEOFENCE_SERVER | 0x06, /**< Error occured in GPS/WIFI/BT */ - GEOFENCE_SERVER_ERROR_DATABASE = TIZEN_ERROR_GEOFENCE_SERVER | 0x07, /**< DB error occured in the server side */ - GEOFENCE_SERVER_ERROR_PLACE_ACCESS_DENIED = TIZEN_ERROR_GEOFENCE_SERVER | 0x08, /**< Access to specified place is denied */ - GEOFENCE_SERVER_ERROR_GEOFENCE_ACCESS_DENIED = TIZEN_ERROR_GEOFENCE_SERVER | 0x09, /**< Access to specified geofence is denied */ + GEOFENCE_SERVER_ERROR_NONE = TIZEN_ERROR_NONE, /**< Success */ + GEOFENCE_SERVER_ERROR_OUT_OF_MEMORY = TIZEN_ERROR_OUT_OF_MEMORY, /**< Out of memory */ + GEOFENCE_SERVER_ERROR_INVALID_PARAMETER = TIZEN_ERROR_INVALID_PARAMETER, /**< Invalid parameter */ + GEOFENCE_SERVER_ERROR_PERMISSION_DENIED = TIZEN_ERROR_PERMISSION_DENIED, /**< Permission denied */ + GEOFENCE_SERVER_ERROR_NOT_SUPPORTED = TIZEN_ERROR_NOT_SUPPORTED, /**< Not supported */ + GEOFENCE_SERVER_ERROR_NOT_INITIALIZED = TIZEN_ERROR_GEOFENCE_SERVER | 0x01, /**< Geofence Manager is not initialized */ + GEOFENCE_SERVER_ERROR_ID_NOT_EXIST = TIZEN_ERROR_GEOFENCE_SERVER | 0x02, /**< Geofence ID is not exist */ + GEOFENCE_SERVER_ERROR_EXCEPTION = TIZEN_ERROR_GEOFENCE_SERVER | 0x03, /**< exception is occured */ + GEOFENCE_SERVER_ERROR_ALREADY_STARTED = TIZEN_ERROR_GEOFENCE_SERVER | 0x04, /**< Geofence is already started */ + GEOFENCE_SERVER_ERROR_TOO_MANY_GEOFENCE = TIZEN_ERROR_GEOFENCE_SERVER | 0x05, /**< Too many Geofence */ + GEOFENCE_SERVER_ERROR_IPC = TIZEN_ERROR_GEOFENCE_SERVER | 0x06, /**< Error occured in GPS/WIFI/BT */ + GEOFENCE_SERVER_ERROR_DATABASE = TIZEN_ERROR_GEOFENCE_SERVER | 0x07, /**< DB error occured in the server side */ + GEOFENCE_SERVER_ERROR_PLACE_ACCESS_DENIED = TIZEN_ERROR_GEOFENCE_SERVER | 0x08, /**< Access to specified place is denied */ + GEOFENCE_SERVER_ERROR_GEOFENCE_ACCESS_DENIED = TIZEN_ERROR_GEOFENCE_SERVER | 0x09, /**< Access to specified geofence is denied */ } geofence_server_error_e; /** * This enumeration describes the geofence param state */ typedef enum { - GEOFENCE_MANAGE_FENCE_ADDED = 0x00, - GEOFENCE_MANAGE_FENCE_REMOVED, - GEOFENCE_MANAGE_FENCE_STARTED, - GEOFENCE_MANAGE_FENCE_STOPPED, + GEOFENCE_MANAGE_FENCE_ADDED = 0x00, + GEOFENCE_MANAGE_FENCE_REMOVED, + GEOFENCE_MANAGE_FENCE_STARTED, + GEOFENCE_MANAGE_FENCE_STOPPED, - GEOFENCE_MANAGE_PLACE_ADDED = 0x10, - GEOFENCE_MANAGE_PLACE_REMOVED, - GEOFENCE_MANAGE_PLACE_UPDATED, + GEOFENCE_MANAGE_PLACE_ADDED = 0x10, + GEOFENCE_MANAGE_PLACE_REMOVED, + GEOFENCE_MANAGE_PLACE_UPDATED, - GEOFENCE_MANAGE_SETTING_ENABLED = 0x20, - GEOFENCE_MANAGE_SETTING_DISABLED + GEOFENCE_MANAGE_SETTING_ENABLED = 0x20, + GEOFENCE_MANAGE_SETTING_DISABLED } geofence_manage_e; /** * This enumeration descript the Smart Assistant State */ typedef enum { - GEOFENCE_SMART_ASSIST_STOP = 0, - GEOFENCE_SMART_ASSIST_START + GEOFENCE_SMART_ASSIST_STOP = 0, + GEOFENCE_SMART_ASSIST_START } geofence_smart_assist_state_e; +typedef enum { + GEOFENCE_TYPE_GEOPOINT = 1, /**< Geofence is specified by geospatial coordinate */ + GEOFENCE_TYPE_WIFI, /**< Geofence is specified by Wi-Fi access point */ + GEOFENCE_TYPE_BT, /**< Geofence is specified by Blutetooth device */ +} geofence_type_e; + +typedef enum { + ACCESS_TYPE_PRIVATE = 1, + ACCESS_TYPE_PUBLIC, + ACCESS_TYPE_UNKNOWN, +} access_type_e; + #ifdef __cplusplus } #endif diff --git a/geofence-server/include/geofence_server_extra_data_types.h b/geofence-server/include/geofence_server_extra_data_types.h index 6effb67..8c6cdde 100644 --- a/geofence-server/include/geofence_server_extra_data_types.h +++ b/geofence-server/include/geofence_server_extra_data_types.h @@ -24,7 +24,8 @@ typedef enum { GEOFENCE_ZONE_IN = 0x00, GEOFENCE_ZONE_OUT = 0x01, GEOFENCE_ZONE_UNCERTAIN = 0x02, -} geofence_zone_state_t; +} +geofence_zone_state_t; #ifdef __cplusplus } diff --git a/geofence-server/src/debug_util.h b/geofence-server/src/debug_util.h index 56a4347..6ba1183 100644 --- a/geofence-server/src/debug_util.h +++ b/geofence-server/src/debug_util.h @@ -35,7 +35,7 @@ extern "C" { #define LOGI_GEOFENCE(fmt, args...) SLOG(LOG_INFO, TAG_GEOFENCE_SERVER, fmt, ##args) #define LOGW_GEOFENCE(fmt, args...) SLOG(LOG_WARN, TAG_GEOFENCE_SERVER, fmt, ##args) #define LOGE_GEOFENCE(fmt, args...) SLOG(LOG_ERROR, TAG_GEOFENCE_SERVER, fmt, ##args) -#define FUNC_ENTRANCE_SERVER LOGD_GEOFENCE("[%s] Entered!!\n", __func__); +#define FUNC_ENTRANCE_SERVER LOGD_GEOFENCE("ENTER >>>"); #ifdef __cplusplus } diff --git a/geofence-server/src/geofence_server.c b/geofence-server/src/geofence_server.c index 848ef5b..6eaedb4 100644 --- a/geofence-server/src/geofence_server.c +++ b/geofence-server/src/geofence_server.c @@ -40,15 +40,10 @@ #include "geofence_server_log.h" #endif -#define GEOFENCE_SERVER_SERVICE_NAME "org.tizen.lbs.Providers.GeofenceServer" -#define GEOFENCE_SERVER_SERVICE_PATH "/org/tizen/lbs/Providers/GeofenceServer" #define TIME_INTERVAL 5 - #define SMART_ASSIST_HOME 1 - #define SMART_ASSIST_TIMEOUT 60 /* Refer to LPP */ #define GEOFENCE_DEFAULT_RADIUS 200 /* Default 200 m */ - #define NPS_TIMEOUT 180 #define MYPLACES_APPID "org.tizen.myplace" @@ -59,7 +54,6 @@ static int __nps_alarm_cb(alarm_id_t alarm_id, void *user_data); static int __nps_timeout_cb(alarm_id_t alarm_id, void *user_data); static void __add_left_fences(gpointer user_data); -static void __stop_geofence_service(gint fence_id, const gchar *app_id, gpointer userdata); static void __start_activity_service(GeofenceServer *geofence_server); static void __stop_activity_service(GeofenceServer *geofence_server); static void __activity_cb(activity_type_e type, const activity_data_h data, double timestamp, activity_error_e error, void *user_data); @@ -67,38 +61,38 @@ static void __activity_cb(activity_type_e type, const activity_data_h data, doub static const char *__convert_wifi_error_to_string(wifi_error_e err_type) { switch (err_type) { - case WIFI_ERROR_NONE: - return "NONE"; - case WIFI_ERROR_INVALID_PARAMETER: - return "INVALID_PARAMETER"; - case WIFI_ERROR_OUT_OF_MEMORY: - return "OUT_OF_MEMORY"; - case WIFI_ERROR_INVALID_OPERATION: - return "INVALID_OPERATION"; - case WIFI_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED: - return "ADDRESS_FAMILY_NOT_SUPPORTED"; - case WIFI_ERROR_OPERATION_FAILED: - return "OPERATION_FAILED"; - case WIFI_ERROR_NO_CONNECTION: - return "NO_CONNECTION"; - case WIFI_ERROR_NOW_IN_PROGRESS: - return "NOW_IN_PROGRESS"; - case WIFI_ERROR_ALREADY_EXISTS: - return "ALREADY_EXISTS"; - case WIFI_ERROR_OPERATION_ABORTED: - return "OPERATION_ABORTED"; - case WIFI_ERROR_DHCP_FAILED: - return "DHCP_FAILED"; - case WIFI_ERROR_INVALID_KEY: - return "INVALID_KEY"; - case WIFI_ERROR_NO_REPLY: - return "NO_REPLY"; - case WIFI_ERROR_SECURITY_RESTRICTED: - return "SECURITY_RESTRICTED"; - case WIFI_ERROR_PERMISSION_DENIED: - return "PERMISSION_DENIED"; - default: - return "NOT Defined"; + case WIFI_ERROR_NONE: + return "NONE"; + case WIFI_ERROR_INVALID_PARAMETER: + return "INVALID_PARAMETER"; + case WIFI_ERROR_OUT_OF_MEMORY: + return "OUT_OF_MEMORY"; + case WIFI_ERROR_INVALID_OPERATION: + return "INVALID_OPERATION"; + case WIFI_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED: + return "ADDRESS_FAMILY_NOT_SUPPORTED"; + case WIFI_ERROR_OPERATION_FAILED: + return "OPERATION_FAILED"; + case WIFI_ERROR_NO_CONNECTION: + return "NO_CONNECTION"; + case WIFI_ERROR_NOW_IN_PROGRESS: + return "NOW_IN_PROGRESS"; + case WIFI_ERROR_ALREADY_EXISTS: + return "ALREADY_EXISTS"; + case WIFI_ERROR_OPERATION_ABORTED: + return "OPERATION_ABORTED"; + case WIFI_ERROR_DHCP_FAILED: + return "DHCP_FAILED"; + case WIFI_ERROR_INVALID_KEY: + return "INVALID_KEY"; + case WIFI_ERROR_NO_REPLY: + return "NO_REPLY"; + case WIFI_ERROR_SECURITY_RESTRICTED: + return "SECURITY_RESTRICTED"; + case WIFI_ERROR_PERMISSION_DENIED: + return "PERMISSION_DENIED"; + default: + return "NOT Defined"; } } @@ -106,50 +100,50 @@ static const char *__convert_wifi_error_to_string(wifi_error_e err_type) static const char *__bt_get_error_message(bt_error_e err) { switch (err) { - case BT_ERROR_NONE: - return "BT_ERROR_NONE"; - case BT_ERROR_CANCELLED: - return "BT_ERROR_CANCELLED"; - case BT_ERROR_INVALID_PARAMETER: - return "BT_ERROR_INVALID_PARAMETER"; - case BT_ERROR_OUT_OF_MEMORY: - return "BT_ERROR_OUT_OF_MEMORY"; - case BT_ERROR_RESOURCE_BUSY: - return "BT_ERROR_RESOURCE_BUSY"; - case BT_ERROR_TIMED_OUT: - return "BT_ERROR_TIMED_OUT"; - case BT_ERROR_NOW_IN_PROGRESS: - return "BT_ERROR_NOW_IN_PROGRESS"; - case BT_ERROR_NOT_INITIALIZED: - return "BT_ERROR_NOT_INITIALIZED"; - case BT_ERROR_NOT_ENABLED: - return "BT_ERROR_NOT_ENABLED"; - case BT_ERROR_ALREADY_DONE: - return "BT_ERROR_ALREADY_DONE"; - case BT_ERROR_OPERATION_FAILED: - return "BT_ERROR_OPERATION_FAILED"; - case BT_ERROR_NOT_IN_PROGRESS: - return "BT_ERROR_NOT_IN_PROGRESS"; - case BT_ERROR_REMOTE_DEVICE_NOT_BONDED: - return "BT_ERROR_REMOTE_DEVICE_NOT_BONDED"; - case BT_ERROR_AUTH_REJECTED: - return "BT_ERROR_AUTH_REJECTED"; - case BT_ERROR_AUTH_FAILED: - return "BT_ERROR_AUTH_FAILED"; - case BT_ERROR_REMOTE_DEVICE_NOT_FOUND: - return "BT_ERROR_REMOTE_DEVICE_NOT_FOUND"; - case BT_ERROR_SERVICE_SEARCH_FAILED: - return "BT_ERROR_SERVICE_SEARCH_FAILED"; - case BT_ERROR_REMOTE_DEVICE_NOT_CONNECTED: - return "BT_ERROR_REMOTE_DEVICE_NOT_CONNECTED"; + case BT_ERROR_NONE: + return "BT_ERROR_NONE"; + case BT_ERROR_CANCELLED: + return "BT_ERROR_CANCELLED"; + case BT_ERROR_INVALID_PARAMETER: + return "BT_ERROR_INVALID_PARAMETER"; + case BT_ERROR_OUT_OF_MEMORY: + return "BT_ERROR_OUT_OF_MEMORY"; + case BT_ERROR_RESOURCE_BUSY: + return "BT_ERROR_RESOURCE_BUSY"; + case BT_ERROR_TIMED_OUT: + return "BT_ERROR_TIMED_OUT"; + case BT_ERROR_NOW_IN_PROGRESS: + return "BT_ERROR_NOW_IN_PROGRESS"; + case BT_ERROR_NOT_INITIALIZED: + return "BT_ERROR_NOT_INITIALIZED"; + case BT_ERROR_NOT_ENABLED: + return "BT_ERROR_NOT_ENABLED"; + case BT_ERROR_ALREADY_DONE: + return "BT_ERROR_ALREADY_DONE"; + case BT_ERROR_OPERATION_FAILED: + return "BT_ERROR_OPERATION_FAILED"; + case BT_ERROR_NOT_IN_PROGRESS: + return "BT_ERROR_NOT_IN_PROGRESS"; + case BT_ERROR_REMOTE_DEVICE_NOT_BONDED: + return "BT_ERROR_REMOTE_DEVICE_NOT_BONDED"; + case BT_ERROR_AUTH_REJECTED: + return "BT_ERROR_AUTH_REJECTED"; + case BT_ERROR_AUTH_FAILED: + return "BT_ERROR_AUTH_FAILED"; + case BT_ERROR_REMOTE_DEVICE_NOT_FOUND: + return "BT_ERROR_REMOTE_DEVICE_NOT_FOUND"; + case BT_ERROR_SERVICE_SEARCH_FAILED: + return "BT_ERROR_SERVICE_SEARCH_FAILED"; + case BT_ERROR_REMOTE_DEVICE_NOT_CONNECTED: + return "BT_ERROR_REMOTE_DEVICE_NOT_CONNECTED"; #ifndef TIZEN_TV - case BT_ERROR_PERMISSION_DENIED: - return "BT_ERROR_PERMISSION_DENIED"; - case BT_ERROR_SERVICE_NOT_FOUND: - return "BT_ERROR_SERVICE_NOT_FOUND"; + case BT_ERROR_PERMISSION_DENIED: + return "BT_ERROR_PERMISSION_DENIED"; + case BT_ERROR_SERVICE_NOT_FOUND: + return "BT_ERROR_SERVICE_NOT_FOUND"; #endif - default: - return "NOT Defined"; + default: + return "NOT Defined"; } } #endif @@ -159,6 +153,8 @@ static int __emit_fence_event(GeofenceServer *geofence_server, int place_id, int FUNC_ENTRANCE_SERVER; g_return_val_if_fail(geofence_server, -1); + LOGD_GEOFENCE("place_id: %d, fence_id: %d, access_type: %d, error: %d, state: %d", place_id, fence_id, access_type, error, state); + geofence_dbus_server_send_geofence_event_changed(geofence_server->geofence_dbus_server, place_id, fence_id, access_type, app_id, error, state); return 0; } @@ -178,7 +174,7 @@ static int __emit_fence_inout(GeofenceServer *geofence_server, int fence_id, geo if (state == GEOFENCE_FENCE_STATE_IN) { LOGD_GEOFENCE("FENCE_IN to be set, current state: %d", - item_data->common_info.status); + item_data->common_info.status); if (item_data->common_info.status != GEOFENCE_FENCE_STATE_IN) { geofence_dbus_server_send_geofence_inout_changed(geofence_server->geofence_dbus_server, item_data->common_info.appid, fence_id, item_data->common_info.access_type, GEOFENCE_EMIT_STATE_IN); if (item_data->client_status == GEOFENCE_CLIENT_STATUS_START) { @@ -193,7 +189,7 @@ static int __emit_fence_inout(GeofenceServer *geofence_server, int fence_id, geo } else if (state == GEOFENCE_FENCE_STATE_OUT) { LOGD_GEOFENCE("FENCE_OUT to be set, current state: %d", - item_data->common_info.status); + item_data->common_info.status); if (item_data->common_info.status != GEOFENCE_FENCE_STATE_OUT) { geofence_dbus_server_send_geofence_inout_changed(geofence_server->geofence_dbus_server, item_data->common_info.appid, fence_id, item_data->common_info.access_type, GEOFENCE_EMIT_STATE_OUT); if (item_data->client_status == GEOFENCE_CLIENT_STATUS_START) { @@ -252,7 +248,7 @@ static void __check_current_location_cb(double latitude, double longitude, doubl FUNC_ENTRANCE_SERVER; GeofenceServer *geofence_server = (GeofenceServer *) user_data; location_accuracy_level_e level; - double hor_acc = 0.0; + double hor_acc = 0.0; double ver_acc = 0.0; int ret = 0; int fence_id = 0; @@ -359,7 +355,7 @@ static void __geofence_position_changed_cb(double latitude, double longitude, do } static void __check_tracking_list(const char *bssid, void *user_data, - geofence_type_e type) + geofence_type_e type) { FUNC_ENTRANCE_SERVER; GeofenceServer *geofence_server = (GeofenceServer *) user_data; @@ -424,7 +420,7 @@ void bt_adapter_device_discovery_state_cb(int result, bt_adapter_device_discover } } } else { - LOGI_GEOFENCE("%s %s", discovery_info->remote_address, discovery_info->remote_name); + LOGI_GEOFENCE("%s, %s", discovery_info->remote_address, discovery_info->remote_name); LOGI_GEOFENCE("rssi: %d is_bonded: %d", discovery_info->rssi, discovery_info->is_bonded); if (geofence_server->running_bt_cnt > 0) { @@ -447,46 +443,45 @@ static void geofence_network_evt_cb(net_event_info_t *event_cb, void *user_data) int tracking_fence_id = 0; switch (event_cb->Event) { - case NET_EVENT_WIFI_SCAN_IND: - - LOGD_GEOFENCE("Got WIFI scan Ind : %d\n", event_cb->Error); + case NET_EVENT_WIFI_SCAN_IND: + LOGD_GEOFENCE("Got WIFI scan Ind : %d\n", event_cb->Error); - net_profile_info_t *profiles = NULL; - int num_of_profile = 0; + net_profile_info_t *profiles = NULL; + int num_of_profile = 0; - if (geofence_server->running_wifi_cnt > 0) { /*Check only if some wifi fence is running*/ - if (NET_ERR_NONE != net_get_profile_list(NET_DEVICE_WIFI, &profiles, &num_of_profile)) { - LOGD_GEOFENCE("Failed to get the scanned list"); - } else { - LOGD_GEOFENCE("Scan results retrieved successfully. No.of profiles: %d", num_of_profile); - if (num_of_profile > 0 && profiles != NULL) { - int cnt; - for (cnt = 0; cnt < num_of_profile; cnt++) { - net_wifi_profile_info_t *ap_info = &profiles[cnt].ProfileInfo.Wlan; - LOGD_GEOFENCE("BSSID %s", ap_info->bssid); - __check_tracking_list(ap_info->bssid, geofence_server, GEOFENCE_TYPE_WIFI); - } - LOGD_GEOFENCE("Comparing fences with scan results is done.Now emit the status to the application"); - while (tracking_fences) { + if (geofence_server->running_wifi_cnt > 0) { /*Check only if some wifi fence is running*/ + if (NET_ERR_NONE != net_get_profile_list(NET_DEVICE_WIFI, &profiles, &num_of_profile)) { + LOGD_GEOFENCE("Failed to get the scanned list"); + } else { + LOGD_GEOFENCE("Scan results retrieved successfully. No.of profiles: %d", num_of_profile); + if (num_of_profile > 0 && profiles != NULL) { + int cnt; + for (cnt = 0; cnt < num_of_profile; cnt++) { + net_wifi_profile_info_t *ap_info = &profiles[cnt].ProfileInfo.Wlan; + LOGD_GEOFENCE("BSSID %s", ap_info->bssid); + __check_tracking_list(ap_info->bssid, geofence_server, GEOFENCE_TYPE_WIFI); + } + LOGD_GEOFENCE("Comparing fences with scan results is done.Now emit the status to the application"); + while (tracking_fences) { tracking_fence_id = GPOINTER_TO_INT(tracking_fences->data); - tracking_fences = g_list_next(tracking_fences); - item_data = __get_item_by_fence_id(tracking_fence_id, geofence_server); - if (item_data && item_data->common_info.type == GEOFENCE_TYPE_WIFI) { - if (item_data->is_wifi_status_in == true) { - __emit_fence_inout(geofence_server, item_data->common_info.fence_id, GEOFENCE_FENCE_STATE_IN); - } else { - __emit_fence_inout(geofence_server, item_data->common_info.fence_id, GEOFENCE_FENCE_STATE_OUT); + tracking_fences = g_list_next(tracking_fences); + item_data = __get_item_by_fence_id(tracking_fence_id, geofence_server); + if (item_data && item_data->common_info.type == GEOFENCE_TYPE_WIFI) { + if (item_data->is_wifi_status_in == true) { + __emit_fence_inout(geofence_server, item_data->common_info.fence_id, GEOFENCE_FENCE_STATE_IN); + } else { + __emit_fence_inout(geofence_server, item_data->common_info.fence_id, GEOFENCE_FENCE_STATE_OUT); + } + item_data->is_wifi_status_in = false; } - item_data->is_wifi_status_in = false; } } } } - } - break; - default: - break; + break; + default: + break; } } @@ -540,7 +535,7 @@ static void __stop_gps_positioning(gpointer userdata) } geofence_server->loc_started = FALSE; ret = location_manager_unset_position_updated_cb - (geofence_server->loc_manager); + (geofence_server->loc_manager); if (ret != LOCATIONS_ERROR_NONE) { return; } @@ -581,7 +576,7 @@ static int __nps_alarm_cb(alarm_id_t alarm_id, void *user_data) } static void gps_setting_changed_cb(location_method_e method, bool enable, - void *user_data) + void *user_data) { FUNC_ENTRANCE_SERVER; GeofenceServer *geofence_server = (GeofenceServer *) user_data; @@ -602,7 +597,7 @@ static void gps_setting_changed_cb(location_method_e method, bool enable, /*stop the timeout alarm if it is running...*/ if (geofence_server->nps_timeout_alarm_id != -1) { LOGI_GEOFENCE("Timeout timer removed. ID[%d]", - geofence_server->nps_timeout_alarm_id); + geofence_server->nps_timeout_alarm_id); geofence_server->nps_timeout_alarm_id = _geofence_remove_alarm(geofence_server->nps_timeout_alarm_id); } while (tracking_fences) { @@ -707,14 +702,135 @@ static int __check_place_permission(int place_id, const char *app_id) return 1; } -static int __add_fence(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) +static void __stop_geofence_service(gint fence_id, const gchar *app_id, gpointer userdata) +{ + FUNC_ENTRANCE_SERVER; + g_return_if_fail(userdata); + + GeofenceServer *geofence_server = (GeofenceServer *) userdata; + GeofenceItemData *item_data = NULL; + int tracking_status = -1; + int ret = FENCE_ERR_NONE; + int place_id = -1; + access_type_e access_type = ACCESS_TYPE_UNKNOWN; + + item_data = __get_item_by_fence_id(fence_id, geofence_server); /*Fetch the fence details from add_list*/ + if (item_data == NULL) { + LOGI_GEOFENCE("Invalid fence id - no fence exists with this fence id"); + __emit_fence_event(geofence_server, -1, fence_id, ACCESS_TYPE_UNKNOWN, app_id, GEOFENCE_SERVER_ERROR_ID_NOT_EXIST, GEOFENCE_MANAGE_FENCE_STOPPED); + return; /*Invalid fence id - no fence exists with this fence id*/ + } + ret = geofence_manager_get_place_id(fence_id, &place_id); + if (ret != FENCE_ERR_NONE) { + LOGI_GEOFENCE("Error fetching the place_id from the DB for fence: %d", fence_id); + __emit_fence_event(geofence_server, -1, fence_id, ACCESS_TYPE_UNKNOWN, app_id, GEOFENCE_SERVER_ERROR_DATABASE, GEOFENCE_MANAGE_FENCE_STOPPED); + return; + } + ret = geofence_manager_get_access_type(fence_id, -1, &access_type); + if (ret != FENCE_ERR_NONE) { + LOGI_GEOFENCE("Error fetching the access type from the DB for fence: %d", fence_id); + __emit_fence_event(geofence_server, place_id, fence_id, ACCESS_TYPE_UNKNOWN, app_id, GEOFENCE_SERVER_ERROR_DATABASE, GEOFENCE_MANAGE_FENCE_STOPPED); + return; + } + ret = __check_fence_permission(fence_id, app_id); + if (ret != 1) { + LOGE("Permission denied or DB error occured while accessing the fence[%d]", fence_id); + if (ret == 0) { + __emit_fence_event(geofence_server, place_id, fence_id, ACCESS_TYPE_UNKNOWN, app_id, GEOFENCE_SERVER_ERROR_GEOFENCE_ACCESS_DENIED, GEOFENCE_MANAGE_FENCE_STOPPED); + } else { + __emit_fence_event(geofence_server, place_id, fence_id, ACCESS_TYPE_UNKNOWN, app_id, GEOFENCE_SERVER_ERROR_DATABASE, GEOFENCE_MANAGE_FENCE_STOPPED); + } + return; + } + ret = geofence_manager_get_running_status(fence_id, &tracking_status); + if (ret != FENCE_ERR_NONE) { + LOGI_GEOFENCE("Error fetching the running status from the DB for fence: %d", fence_id); + __emit_fence_event(geofence_server, place_id, fence_id, ACCESS_TYPE_UNKNOWN, app_id, GEOFENCE_SERVER_ERROR_DATABASE, GEOFENCE_MANAGE_FENCE_STOPPED); + return; + } + + if (tracking_status == 0) { + /*This fence is not in the tracking mode currently - nothing to do, just return saying the error*/ + LOGI_GEOFENCE("Fence ID: %d, is not in the tracking mode", fence_id); + __emit_fence_event(geofence_server, place_id, fence_id, access_type, app_id, GEOFENCE_SERVER_ERROR_NONE, GEOFENCE_MANAGE_FENCE_STOPPED); + return; + } + + if (tracking_status > 0) { + LOGI_GEOFENCE("Remove from tracklist: Fence id: %d", fence_id); + item_data = __get_item_by_fence_id(fence_id, geofence_server); + + /*Item needs to be removed from the fence list*/ + if (item_data != NULL) { + /*Main DB table should be updated here with the unsetting of running status flag*/ + tracking_status = tracking_status - 1; + ret = geofence_manager_set_running_status(fence_id, tracking_status); + if (ret != FENCE_ERR_NONE) { + LOGI_GEOFENCE("Error resetting the running status in DB for fence: %d", fence_id); + __emit_fence_event(geofence_server, place_id, fence_id, ACCESS_TYPE_UNKNOWN, app_id, GEOFENCE_SERVER_ERROR_DATABASE, GEOFENCE_MANAGE_FENCE_STOPPED); + return; + } + /*Update the geofence count according to the type of geofence*/ + if (item_data->common_info.type == GEOFENCE_TYPE_GEOPOINT) { + geofence_server->running_geopoint_cnt--; + LOGI_GEOFENCE("Removed geopoint fence: %d from tracking list", fence_id); + + if (geofence_server->running_geopoint_cnt <= 0) { + /*Stopping GPS...*/ + __stop_gps_positioning(geofence_server); + + /*Stop the interval alarm if it is running...*/ + if (geofence_server->nps_alarm_id != -1) { + LOGI_GEOFENCE("Interval timer removed. ID[%d]", geofence_server->nps_alarm_id); + geofence_server->nps_alarm_id = _geofence_remove_alarm(geofence_server->nps_alarm_id); + } + /*Stop the timeout alarm if it is running...*/ + if (geofence_server->nps_timeout_alarm_id != -1) { + LOGI_GEOFENCE("Timeout timer removed. ID[%d]", geofence_server->nps_timeout_alarm_id); + geofence_server->nps_timeout_alarm_id = _geofence_remove_alarm(geofence_server->nps_timeout_alarm_id); + } + + __stop_activity_service(geofence_server); + } + } else if (item_data->common_info.type == GEOFENCE_TYPE_BT) { + geofence_server->running_bt_cnt--; + LOGI_GEOFENCE("Removed bt fence: %d from tracking list", fence_id); + + if (geofence_server->running_bt_cnt <= 0) { + /*May be unsetting the cb for bt discovery can be done here*/ + } + } else if (item_data->common_info.type == GEOFENCE_TYPE_WIFI) { + /*NOTHING NEED TO BE DONE HERE EXCEPT DECREMENTING THE COUNT*/ + geofence_server->running_wifi_cnt--; + } + + if (tracking_status == 0) { + /*Remove the fence from the tracklist*/ + LOGD_GEOFENCE("Setting the fence status as uncertain here..."); + item_data->common_info.status = GEOFENCE_FENCE_STATE_UNCERTAIN; + geofence_server->tracking_list = g_list_remove(geofence_server->tracking_list, GINT_TO_POINTER(fence_id)); + if (g_list_length(geofence_server->tracking_list) == 0) { + g_list_free(geofence_server->tracking_list); + geofence_server->tracking_list = NULL; + } + } + } else { + LOGI_GEOFENCE("Geofence service is not running for this fence"); + } + + } + /* Emit the error code */ + __emit_fence_event(geofence_server, place_id, fence_id, access_type, app_id, GEOFENCE_SERVER_ERROR_NONE, GEOFENCE_MANAGE_FENCE_STOPPED); +} + +static int dbus_add_fence_cb(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) { FUNC_ENTRANCE_SERVER; GeofenceServer *geofence_server = (GeofenceServer *) userdata; @@ -876,8 +992,8 @@ static int __add_fence(const gchar *app_id, return fence_id; } -static int __add_place(const gchar *app_id, - const gchar *place_name, gpointer userdata) +static int dbus_add_place_cb(const gchar *app_id, + const gchar *place_name, gpointer userdata) { FUNC_ENTRANCE_SERVER; int place_id = -1; @@ -910,7 +1026,7 @@ static int __add_place(const gchar *app_id, return place_id; } -static void __enable_service(gint fence_id, const gchar *app_id, gboolean enable, gpointer userdata) +static void dbus_enable_geofence_cb(gint fence_id, const gchar *app_id, gboolean enable, gpointer userdata) { FUNC_ENTRANCE_SERVER; g_return_if_fail(userdata); @@ -959,7 +1075,7 @@ static void __enable_service(gint fence_id, const gchar *app_id, gboolean enable __emit_fence_event(geofence_server, place_id, fence_id, access_type, app_id, GEOFENCE_SERVER_ERROR_NONE, manage_enum); } -static void __update_place(gint place_id, const gchar *app_id, const gchar *place_name, gpointer userdata) +static void dbus_update_place_cb(gint place_id, const gchar *app_id, const gchar *place_name, gpointer userdata) { FUNC_ENTRANCE_SERVER; int ret = FENCE_ERR_NONE; @@ -1002,7 +1118,7 @@ static void __update_place(gint place_id, const gchar *app_id, const gchar *plac g_free(place_info); } -static void __remove_fence(gint fence_id, const gchar *app_id, gpointer userdata) +static void dbus_remove_fence_cb(gint fence_id, const gchar *app_id, gpointer userdata) { FUNC_ENTRANCE_SERVER; GeofenceServer *geofence_server = (GeofenceServer *) userdata; @@ -1089,7 +1205,7 @@ static void __remove_fence(gint fence_id, const gchar *app_id, gpointer userdata __emit_fence_event(geofence_server, place_id, fence_id, access_type, app_id, GEOFENCE_SERVER_ERROR_NONE, GEOFENCE_MANAGE_FENCE_REMOVED); } -static void __get_place_name(gint place_id, const gchar *app_id, char **place_name, int *error_code, gpointer userdata) +static void dbus_get_place_name_cb(gint place_id, const gchar *app_id, char **place_name, int *error_code, gpointer userdata) { FUNC_ENTRANCE_SERVER; access_type_e access_type = ACCESS_TYPE_UNKNOWN; @@ -1119,8 +1235,8 @@ static void __get_place_name(gint place_id, const gchar *app_id, char **place_na *error_code = GEOFENCE_SERVER_ERROR_NONE; } -static void __remove_place(gint place_id, const gchar *app_id, - gpointer userdata) +static void dbus_remove_place_cb(gint place_id, const gchar *app_id, + gpointer userdata) { FUNC_ENTRANCE_SERVER; g_return_if_fail(userdata); @@ -1145,7 +1261,7 @@ static void __remove_place(gint place_id, const gchar *app_id, } place_info_s *place_info = - (place_info_s *) g_malloc0(sizeof(place_info_s)); + (place_info_s *) g_malloc0(sizeof(place_info_s)); ret = geofence_manager_get_place_info(place_id, &place_info); if (ret != FENCE_ERR_NONE) { LOGI_GEOFENCE("Place_id does not exist or DB error in getting the place info for place_id[%d].", place_id); @@ -1211,7 +1327,7 @@ static void __remove_place(gint place_id, const gchar *app_id, __emit_fence_event(geofence_server, place_id, -1, access_type, app_id, GEOFENCE_SERVER_ERROR_NONE, GEOFENCE_MANAGE_PLACE_REMOVED); } -static void __start_geofence_service(gint fence_id, const gchar *app_id, gpointer userdata) +static void dbus_start_geofence_cb(gint fence_id, const gchar *app_id, gpointer userdata) { FUNC_ENTRANCE_SERVER; g_return_if_fail(userdata); @@ -1296,7 +1412,7 @@ static void __start_geofence_service(gint fence_id, const gchar *app_id, gpointe } if (enable == 0) { LOGI_GEOFENCE("Error - Fence[%d] is not enabled", - fence_id); + fence_id); __emit_fence_event(geofence_server, place_id, fence_id, ACCESS_TYPE_UNKNOWN, app_id, GEOFENCE_SERVER_ERROR_GEOFENCE_ACCESS_DENIED, GEOFENCE_MANAGE_FENCE_STARTED); return; } @@ -1332,7 +1448,7 @@ static void __start_geofence_service(gint fence_id, const gchar *app_id, gpointe return; } geofence_server->running_geopoint_cnt++; - + __start_activity_service(geofence_server); } else if (item_data->common_info.type == GEOFENCE_TYPE_BT) { LOGI_GEOFENCE("fence_type [GEOFENCE_TYPE_BT]"); @@ -1430,7 +1546,7 @@ static void __start_geofence_service(gint fence_id, const gchar *app_id, gpointe } } else { LOGI_GEOFENCE("Invalid fence_type[%d]", - item_data->common_info.type); + item_data->common_info.type); return; } /*Adding the fence to the tracking list*/ @@ -1454,125 +1570,9 @@ static void __start_geofence_service(gint fence_id, const gchar *app_id, gpointe } } -static void __stop_geofence_service(gint fence_id, const gchar *app_id, gpointer userdata) +static void dbus_stop_geofence_cb(gint fence_id, const gchar *app_id, gpointer userdata) { - FUNC_ENTRANCE_SERVER; - g_return_if_fail(userdata); - - GeofenceServer *geofence_server = (GeofenceServer *) userdata; - GeofenceItemData *item_data = NULL; - int tracking_status = -1; - int ret = FENCE_ERR_NONE; - int place_id = -1; - access_type_e access_type = ACCESS_TYPE_UNKNOWN; - - item_data = __get_item_by_fence_id(fence_id, geofence_server); /*Fetch the fence details from add_list*/ - if (item_data == NULL) { - LOGI_GEOFENCE("Invalid fence id - no fence exists with this fence id"); - __emit_fence_event(geofence_server, -1, fence_id, ACCESS_TYPE_UNKNOWN, app_id, GEOFENCE_SERVER_ERROR_ID_NOT_EXIST, GEOFENCE_MANAGE_FENCE_STOPPED); - return; /*Invalid fence id - no fence exists with this fence id*/ - } - ret = geofence_manager_get_place_id(fence_id, &place_id); - if (ret != FENCE_ERR_NONE) { - LOGI_GEOFENCE("Error fetching the place_id from the DB for fence: %d", fence_id); - __emit_fence_event(geofence_server, -1, fence_id, ACCESS_TYPE_UNKNOWN, app_id, GEOFENCE_SERVER_ERROR_DATABASE, GEOFENCE_MANAGE_FENCE_STOPPED); - return; - } - ret = geofence_manager_get_access_type(fence_id, -1, &access_type); - if (ret != FENCE_ERR_NONE) { - LOGI_GEOFENCE("Error fetching the access type from the DB for fence: %d", fence_id); - __emit_fence_event(geofence_server, place_id, fence_id, ACCESS_TYPE_UNKNOWN, app_id, GEOFENCE_SERVER_ERROR_DATABASE, GEOFENCE_MANAGE_FENCE_STOPPED); - return; - } - ret = __check_fence_permission(fence_id, app_id); - if (ret != 1) { - LOGE("Permission denied or DB error occured while accessing the fence[%d]", fence_id); - if (ret == 0) { - __emit_fence_event(geofence_server, place_id, fence_id, ACCESS_TYPE_UNKNOWN, app_id, GEOFENCE_SERVER_ERROR_GEOFENCE_ACCESS_DENIED, GEOFENCE_MANAGE_FENCE_STOPPED); - } else { - __emit_fence_event(geofence_server, place_id, fence_id, ACCESS_TYPE_UNKNOWN, app_id, GEOFENCE_SERVER_ERROR_DATABASE, GEOFENCE_MANAGE_FENCE_STOPPED); - } - return; - } - ret = geofence_manager_get_running_status(fence_id, &tracking_status); - if (ret != FENCE_ERR_NONE) { - LOGI_GEOFENCE("Error fetching the running status from the DB for fence: %d", fence_id); - __emit_fence_event(geofence_server, place_id, fence_id, ACCESS_TYPE_UNKNOWN, app_id, GEOFENCE_SERVER_ERROR_DATABASE, GEOFENCE_MANAGE_FENCE_STOPPED); - return; - } - - if (tracking_status == 0) { - /*This fence is not in the tracking mode currently - nothing to do, just return saying the error*/ - LOGI_GEOFENCE("Fence ID: %d, is not in the tracking mode", fence_id); - __emit_fence_event(geofence_server, place_id, fence_id, access_type, app_id, GEOFENCE_SERVER_ERROR_NONE, GEOFENCE_MANAGE_FENCE_STOPPED); - return; - } - - if (tracking_status > 0) { - LOGI_GEOFENCE("Remove from tracklist: Fence id: %d", fence_id); - item_data = __get_item_by_fence_id(fence_id, geofence_server); - - /*Item needs to be removed from the fence list*/ - if (item_data != NULL) { - /*Main DB table should be updated here with the unsetting of running status flag*/ - tracking_status = tracking_status - 1; - ret = geofence_manager_set_running_status(fence_id, tracking_status); - if (ret != FENCE_ERR_NONE) { - LOGI_GEOFENCE("Error resetting the running status in DB for fence: %d", fence_id); - __emit_fence_event(geofence_server, place_id, fence_id, ACCESS_TYPE_UNKNOWN, app_id, GEOFENCE_SERVER_ERROR_DATABASE, GEOFENCE_MANAGE_FENCE_STOPPED); - return; - } - /*Update the geofence count according to the type of geofence*/ - if (item_data->common_info.type == GEOFENCE_TYPE_GEOPOINT) { - geofence_server->running_geopoint_cnt--; - LOGI_GEOFENCE("Removed geopoint fence: %d from tracking list", fence_id); - - if (geofence_server->running_geopoint_cnt <= 0) { - /*Stopping GPS...*/ - __stop_gps_positioning(geofence_server); - - /*Stop the interval alarm if it is running...*/ - if (geofence_server->nps_alarm_id != -1) { - LOGI_GEOFENCE("Interval timer removed. ID[%d]", geofence_server->nps_alarm_id); - geofence_server->nps_alarm_id = _geofence_remove_alarm(geofence_server->nps_alarm_id); - } - /*Stop the timeout alarm if it is running...*/ - if (geofence_server->nps_timeout_alarm_id != -1) { - LOGI_GEOFENCE("Timeout timer removed. ID[%d]", geofence_server->nps_timeout_alarm_id); - geofence_server->nps_timeout_alarm_id = _geofence_remove_alarm(geofence_server->nps_timeout_alarm_id); - } - - __stop_activity_service(geofence_server); - } - } else if (item_data->common_info.type == GEOFENCE_TYPE_BT) { - geofence_server->running_bt_cnt--; - LOGI_GEOFENCE("Removed bt fence: %d from tracking list", fence_id); - - if (geofence_server->running_bt_cnt <= 0) { - /*May be unsetting the cb for bt discovery can be done here*/ - } - } else if (item_data->common_info.type == GEOFENCE_TYPE_WIFI) { - /*NOTHING NEED TO BE DONE HERE EXCEPT DECREMENTING THE COUNT*/ - geofence_server->running_wifi_cnt--; - } - - if (tracking_status == 0) { - /*Remove the fence from the tracklist*/ - LOGD_GEOFENCE("Setting the fence status as uncertain here..."); - item_data->common_info.status = GEOFENCE_FENCE_STATE_UNCERTAIN; - geofence_server->tracking_list = g_list_remove(geofence_server->tracking_list, GINT_TO_POINTER(fence_id)); - if (g_list_length(geofence_server->tracking_list) == 0) { - g_list_free(geofence_server->tracking_list); - geofence_server->tracking_list = NULL; - } - } - } else { - LOGI_GEOFENCE("Geofence service is not running for this fence"); - } - - } - /* Emit the error code */ - __emit_fence_event(geofence_server, place_id, fence_id, access_type, app_id, GEOFENCE_SERVER_ERROR_NONE, GEOFENCE_MANAGE_FENCE_STOPPED); + __stop_geofence_service(fence_id, app_id, userdata); } static void __start_activity_service(GeofenceServer *geofence_server) @@ -1738,7 +1738,7 @@ static void __activity_cb(activity_type_e type, const activity_data_h data, doub } } -static GVariant *__get_list(int place_id, const gchar *app_id, int *fenceCnt, int *errorCode, gpointer userdata) +static GVariant *dbus_get_geofences_cb(int place_id, const gchar *app_id, int *fenceCnt, int *errorCode, gpointer userdata) { geofence_info_s *item; GVariantBuilder b; @@ -1813,32 +1813,32 @@ static GVariant *__get_list(int place_id, const gchar *app_id, int *fenceCnt, in LOGI_GEOFENCE("fence_id: %d, place_id: %d, latitude: %f, longitude: %f, radius: %d", item->fence_id, item->param.place_id, item->param.latitude, item->param.longitude, item->param.radius); switch (item->param.type) { - case GEOFENCE_TYPE_GEOPOINT:{ - g_variant_builder_add(&b, "{sv}", "place_id", g_variant_new_int32(item->param.place_id)); - g_variant_builder_add(&b, "{sv}", "geofence_type", g_variant_new_int32(item->param.type)); - g_variant_builder_add(&b, "{sv}", "latitude", g_variant_new_double(item->param.latitude)); - g_variant_builder_add(&b, "{sv}", "longitude", g_variant_new_double(item->param.longitude)); - g_variant_builder_add(&b, "{sv}", "radius", g_variant_new_int32(item->param.radius)); - g_variant_builder_add(&b, "{sv}", "address", g_variant_new_string(item->param.address)); - g_variant_builder_add(&b, "{sv}", "bssid", g_variant_new_string("NA")); - g_variant_builder_add(&b, "{sv}", "ssid", g_variant_new_string("NA")); - } - break; - case GEOFENCE_TYPE_WIFI: - case GEOFENCE_TYPE_BT:{ - g_variant_builder_add(&b, "{sv}", "place_id", g_variant_new_int32(item->param.place_id)); - g_variant_builder_add(&b, "{sv}", "geofence_type", g_variant_new_int32(item->param.type)); - g_variant_builder_add(&b, "{sv}", "latitude", g_variant_new_double(0.0)); - g_variant_builder_add(&b, "{sv}", "longitude", g_variant_new_double(0.0)); - g_variant_builder_add(&b, "{sv}", "radius", g_variant_new_int32(0.0)); - g_variant_builder_add(&b, "{sv}", "address", g_variant_new_string("NA")); - g_variant_builder_add(&b, "{sv}", "bssid", g_variant_new_string(item->param.bssid)); - g_variant_builder_add(&b, "{sv}", "ssid", g_variant_new_string(item->param.ssid)); - } - break; - default: - LOGI_GEOFENCE("Unsupported type: [%d]", item->param.type); - break; + case GEOFENCE_TYPE_GEOPOINT: { + g_variant_builder_add(&b, "{sv}", "place_id", g_variant_new_int32(item->param.place_id)); + g_variant_builder_add(&b, "{sv}", "geofence_type", g_variant_new_int32(item->param.type)); + g_variant_builder_add(&b, "{sv}", "latitude", g_variant_new_double(item->param.latitude)); + g_variant_builder_add(&b, "{sv}", "longitude", g_variant_new_double(item->param.longitude)); + g_variant_builder_add(&b, "{sv}", "radius", g_variant_new_int32(item->param.radius)); + g_variant_builder_add(&b, "{sv}", "address", g_variant_new_string(item->param.address)); + g_variant_builder_add(&b, "{sv}", "bssid", g_variant_new_string("NA")); + g_variant_builder_add(&b, "{sv}", "ssid", g_variant_new_string("NA")); + } + break; + case GEOFENCE_TYPE_WIFI: + case GEOFENCE_TYPE_BT: { + g_variant_builder_add(&b, "{sv}", "place_id", g_variant_new_int32(item->param.place_id)); + g_variant_builder_add(&b, "{sv}", "geofence_type", g_variant_new_int32(item->param.type)); + g_variant_builder_add(&b, "{sv}", "latitude", g_variant_new_double(0.0)); + g_variant_builder_add(&b, "{sv}", "longitude", g_variant_new_double(0.0)); + g_variant_builder_add(&b, "{sv}", "radius", g_variant_new_int32(0.0)); + g_variant_builder_add(&b, "{sv}", "address", g_variant_new_string("NA")); + g_variant_builder_add(&b, "{sv}", "bssid", g_variant_new_string(item->param.bssid)); + g_variant_builder_add(&b, "{sv}", "ssid", g_variant_new_string(item->param.ssid)); + } + break; + default: + LOGI_GEOFENCE("Unsupported type: [%d]", item->param.type); + break; } /* Close container*/ @@ -1857,7 +1857,7 @@ static GVariant *__get_list(int place_id, const gchar *app_id, int *fenceCnt, in return g_variant_builder_end(&b); } -static GVariant *__get_place_list(const gchar *app_id, int *placeCnt, int *errorCode, gpointer userdata) +static GVariant *dbus_get_places_cb(const gchar *app_id, int *placeCnt, int *errorCode, gpointer userdata) { place_info_s *item; GVariantBuilder b; @@ -2013,10 +2013,10 @@ int __copy_geofence_to_item_data(int fence_id, GeofenceItemData *item_data) if (FENCE_ERR_NONE != geofence_manager_get_access_type(fence_id, -1, &item_data->common_info.access_type)) return FENCE_ERR_SQLITE_FAIL; - + if (FENCE_ERR_NONE != geofence_manager_get_enable_status(fence_id, &item_data->common_info.enable)) return FENCE_ERR_SQLITE_FAIL; - + if (FENCE_ERR_NONE != geofence_manager_get_appid_from_geofence(fence_id, &app_id)) { g_free(app_id); return FENCE_ERR_SQLITE_FAIL; @@ -2026,7 +2026,7 @@ int __copy_geofence_to_item_data(int fence_id, GeofenceItemData *item_data) } if (FENCE_ERR_NONE != geofence_manager_get_placeid_from_geofence(fence_id, &item_data->common_info.place_id)) return FENCE_ERR_SQLITE_FAIL; - + if (FENCE_ERR_NONE != geofence_manager_get_running_status(fence_id, &item_data->common_info.running_status)) return FENCE_ERR_SQLITE_FAIL; @@ -2146,7 +2146,23 @@ int main(int argc, char **argv) #endif /* This call goes to Geofence_dbus_server.c and creates the actual server dbus connection who will interact with the client*/ - geofence_dbus_server_create(GEOFENCE_SERVER_SERVICE_NAME, GEOFENCE_SERVER_SERVICE_PATH, "geofence_manager", "geofence manager provider", &(geofenceserver->geofence_dbus_server), __add_fence, __add_place, __enable_service, __update_place, __remove_fence, __remove_place, __get_place_name, __get_list, __get_place_list, __start_geofence_service, __stop_geofence_service, (void *) geofenceserver); + geofence_dbus_callback_s *dbus_callback; + dbus_callback = g_new0(geofence_dbus_callback_s, 1); + g_return_val_if_fail(dbus_callback, GEOFENCE_DBUS_SERVER_ERROR_MEMORY); + + dbus_callback->add_geofence_cb = dbus_add_fence_cb; + dbus_callback->delete_geofence_cb = dbus_remove_fence_cb; + dbus_callback->get_geofences_cb = dbus_get_geofences_cb; + dbus_callback->enable_geofence_cb = dbus_enable_geofence_cb; + dbus_callback->start_geofence_cb = dbus_start_geofence_cb; + dbus_callback->stop_geofence_cb = dbus_stop_geofence_cb; + dbus_callback->add_place_cb = dbus_add_place_cb; + dbus_callback->update_place_cb = dbus_update_place_cb; + dbus_callback->delete_place_cb = dbus_remove_place_cb; + dbus_callback->get_place_name_cb = dbus_get_place_name_cb; + dbus_callback->get_places_cb = dbus_get_places_cb; + + geofence_dbus_server_create(&(geofenceserver->geofence_dbus_server), dbus_callback, (void *) geofenceserver); LOGD_GEOFENCE("lbs_geofence_server_creation done"); @@ -2165,12 +2181,12 @@ int main(int argc, char **argv) geofence_dbus_server_destroy(geofenceserver->geofence_dbus_server); LOGD_GEOFENCE("lbs_server_destroy called"); + g_free(dbus_callback); g_main_loop_unref(geofenceserver->loop); + g_free(geofenceserver); /*Closing the DB and the handle is aquired again when geofence server comes up.*/ geofence_manager_close_db(); - g_free(geofenceserver); - return 0; } diff --git a/geofence-server/src/geofence_server.h b/geofence-server/src/geofence_server.h index cdd42a0..a001d51 100644 --- a/geofence-server/src/geofence_server.h +++ b/geofence-server/src/geofence_server.h @@ -39,7 +39,7 @@ * @Param[in] user_data The user data to be returned * @see None. */ -typedef void (*geofence_bt_conn_state_changed_cb) (gboolean connected, bt_device_connection_info_s *conn_info, void *user_data); +typedef void (*geofence_bt_conn_state_changed_cb)(gboolean connected, bt_device_connection_info_s *conn_info, void *user_data); /** * @brief Bluetooth adapter disabled callback @@ -48,7 +48,7 @@ typedef void (*geofence_bt_conn_state_changed_cb) (gboolean connected, bt_device * @Param[in] user_data The user data to be returned * @see None. */ -typedef void (*geofence_bt_adapter_disable_cb) (gboolean connected, void *user_data); +typedef void (*geofence_bt_adapter_disable_cb)(gboolean connected, void *user_data); /** * @brief Wifi connection status change callback @@ -58,7 +58,7 @@ typedef void (*geofence_bt_adapter_disable_cb) (gboolean connected, void *user_d * @Param[in] user_data The user data to be returned * @see None. */ -typedef void (*geofence_wifi_conn_state_changed_cb) (wifi_connection_state_e state, wifi_ap_h ap, void *user_data); +typedef void (*geofence_wifi_conn_state_changed_cb)(wifi_connection_state_e state, wifi_ap_h ap, void *user_data); /** * @brief Wifi device status change callback @@ -67,7 +67,7 @@ typedef void (*geofence_wifi_conn_state_changed_cb) (wifi_connection_state_e sta * @Param[in] user_data The user data to be returned * @see None. */ -typedef void (*geofence_wifi_device_state_changed_cb) (wifi_device_state_e state, void *user_data); +typedef void (*geofence_wifi_device_state_changed_cb)(wifi_device_state_e state, void *user_data); /** * @brief Network scan status change callback @@ -76,7 +76,7 @@ typedef void (*geofence_wifi_device_state_changed_cb) (wifi_device_state_e state * @Param[in] user_data The user data to be returned * @see None. */ -typedef void (*geofence_network_event_cb) (net_event_info_t *event_cb, void *user_data); +typedef void (*geofence_network_event_cb)(net_event_info_t *event_cb, void *user_data); /** * @brief BT Discovery status change callback @@ -85,7 +85,7 @@ typedef void (*geofence_network_event_cb) (net_event_info_t *event_cb, void *use * @Param[in] user_data The user data to be returned * @see None. */ -typedef void (*geofence_bt_adapter_device_discovery_state_changed_cb) (int result, bt_adapter_device_discovery_state_e discovery_state, bt_adapter_device_discovery_info_s *discovery_info, void *user_data); +typedef void (*geofence_bt_adapter_device_discovery_state_changed_cb)(int result, bt_adapter_device_discovery_state_e discovery_state, bt_adapter_device_discovery_info_s *discovery_info, void *user_data); /** * @brief Called when the state of location method is changed. @@ -97,7 +97,7 @@ typedef void (*geofence_bt_adapter_device_discovery_state_changed_cb) (int resul * @see location_manager_set_setting_changed_cb() * @see location_manager_unset_setting_changed_cb() */ -typedef void (*geofence_gps_setting_changed_cb) (location_method_e method, bool enable, void *user_data); +typedef void (*geofence_gps_setting_changed_cb)(location_method_e method, bool enable, void *user_data); /** * Geofence callback structure. @@ -118,38 +118,38 @@ typedef struct geofence_callbacks_s geofence_callbacks; * This enumeration describe the smart assistant status. */ typedef enum { - GEOFENCE_SMART_ASSIST_NONE, - GEOFENCE_SMART_ASSIST_ENABLED, - GEOFENCE_SMART_ASSIST_DISABLED, - GEOFENCE_SMART_ASSIST_COLLECTING, + GEOFENCE_SMART_ASSIST_NONE, + GEOFENCE_SMART_ASSIST_ENABLED, + GEOFENCE_SMART_ASSIST_DISABLED, + GEOFENCE_SMART_ASSIST_COLLECTING, } smart_assist_status_e; /** * This enumeration describe the cell geofence in and out status. */ typedef enum { - CELL_UNKNOWN = -1, - CELL_OUT = 0, - CELL_IN = 1 + CELL_UNKNOWN = -1, + CELL_OUT = 0, + CELL_IN = 1 } cell_status_e; /** * This enumeration describe the wifi geofence in and out status. */ typedef enum { - WIFI_DIRECTION_UNKNOWN = -1, - WIFI_DIRECTION_OUT = 0, - WIFI_DIRECTION_IN = 1 + WIFI_DIRECTION_UNKNOWN = -1, + WIFI_DIRECTION_OUT = 0, + WIFI_DIRECTION_IN = 1 } wifi_status_e; /** * This enumeration describe the geofence client status. */ typedef enum { - GEOFENCE_CLIENT_STATUS_NONE, - GEOFENCE_CLIENT_STATUS_FIRST_LOCATION, - GEOFENCE_CLIENT_STATUS_START, - GEOFENCE_CLIENT_STATUS_RUNNING + GEOFENCE_CLIENT_STATUS_NONE, + GEOFENCE_CLIENT_STATUS_FIRST_LOCATION, + GEOFENCE_CLIENT_STATUS_START, + GEOFENCE_CLIENT_STATUS_RUNNING } geofence_client_status_e; #endif diff --git a/geofence-server/src/geofence_server_bluetooth.c b/geofence-server/src/geofence_server_bluetooth.c index 51f78b7..f756c31 100644 --- a/geofence-server/src/geofence_server_bluetooth.c +++ b/geofence-server/src/geofence_server_bluetooth.c @@ -40,7 +40,7 @@ static gboolean __geofence_check_fence_status(int fence_status, GeofenceItemData static void emit_bt_geofence_inout_changed(GeofenceServer *geofence_server, GeofenceItemData *item_data, int fence_status) { FUNC_ENTRANCE_SERVER - char *app_id = (char *)g_malloc0(sizeof(char)*APP_ID_LEN); + char *app_id = (char *)g_malloc0(sizeof(char) * APP_ID_LEN); g_strlcpy(app_id, item_data->common_info.appid, APP_ID_LEN); if (app_id == NULL) { LOGD_GEOFENCE("get app_id failed. fence_id [%d]", item_data->common_info.fence_id); @@ -85,15 +85,15 @@ static void __geofence_check_bt_fence_type(gboolean connected, const char *bssid continue; fence_type = item_data->common_info.type; - + if (fence_type != GEOFENCE_TYPE_BT) continue; - + bt_info_from_list = (bssid_info_s *) item_data->priv; if (bt_info_from_list == NULL || bt_info_from_list->enabled == FALSE) continue; - + ret = geofence_manager_get_bssid_info(fence_id, &bt_info_from_db); if (bt_info_from_db == NULL) { @@ -147,7 +147,7 @@ void bt_conn_state_changed(gboolean connected, bt_device_connection_info_s *conn void bt_adp_disable(gboolean connected, void *user_data) { FUNC_ENTRANCE_SERVER - GeofenceServer * geofence_server = (GeofenceServer *) user_data; + GeofenceServer *geofence_server = (GeofenceServer *) user_data; g_return_if_fail(geofence_server); int fence_id = 0; diff --git a/geofence-server/src/geofence_server_db.c b/geofence-server/src/geofence_server_db.c index 13cf92c..3c64ed8 100644 --- a/geofence-server/src/geofence_server_db.c +++ b/geofence-server/src/geofence_server_db.c @@ -31,9 +31,8 @@ #define GEOFENCE_SERVER_DB_FILE ".geofence-server.db" #define GEOFENCE_SERVER_DB_PATH "/opt/dbspace/"GEOFENCE_SERVER_DB_FILE -#define FENCE_SQL_LEN_MAX 256 #define MAX_DATA_NAME 20 -#define DATA_LEN 20 +#define DATA_LEN 20 #define GEOFENCE_INVALID 0 @@ -46,10 +45,10 @@ const char *col_longitude = "lo"; const char *col_radius = "r"; typedef enum { - FENCE_MAIN_TABLE = 0, /*GeoFence */ - FENCE_GEOCOORDINATE_TAB, /*FenceGeocoordinate */ - FENCE_GEOPOINT_WIFI_TABLE, /*FenceCurrentLocation */ - FENCE_BSSID_TABLE /*FenceBluetoothBssid */ + FENCE_MAIN_TABLE = 0, /*GeoFence */ + FENCE_GEOCOORDINATE_TAB, /*FenceGeocoordinate */ + FENCE_GEOPOINT_WIFI_TABLE, /*FenceCurrentLocation */ + FENCE_BSSID_TABLE /*FenceBluetoothBssid */ } fence_table_type_e; static struct { @@ -59,13 +58,13 @@ static struct { }; #define SQLITE3_RETURN(ret, msg, state) \ - if (ret != SQLITE_OK) { \ - LOGI_GEOFENCE("sqlite3 Error[%d] : %s", ret, msg); \ - sqlite3_reset(state); \ - sqlite3_clear_bindings(state); \ - sqlite3_finalize(state); \ - return FENCE_ERR_SQLITE_FAIL; \ - } + if (ret != SQLITE_OK) { \ + LOGI_GEOFENCE("sqlite3 Error[%d] : %s", ret, msg); \ + sqlite3_reset(state); \ + sqlite3_clear_bindings(state); \ + sqlite3_finalize(state); \ + return FENCE_ERR_SQLITE_FAIL; \ + } /* * \note @@ -337,7 +336,7 @@ static int __geofence_manager_db_insert_bssid_info(const int fence_id, const cha char *bssid = NULL; char *query = sqlite3_mprintf("INSERT INTO %Q(fence_id, bssid, ssid) VALUES (?, ?, ?)", menu_table[FENCE_BSSID_TABLE]); - bssid = (char *)g_malloc0(sizeof(char)*WLAN_BSSID_LEN); + bssid = (char *)g_malloc0(sizeof(char) * WLAN_BSSID_LEN); g_strlcpy(bssid, bssid_info, WLAN_BSSID_LEN); LOGI_GEOFENCE("fence_id[%d], bssid[%s], ssid[%s]", fence_id, bssid, ssid); @@ -401,7 +400,7 @@ static int __geofence_manager_db_insert_wifi_data_info(gpointer data, gpointer u const char *tail; char *bssid = NULL; wifi_info = (wifi_info_s *) data; - bssid = (char *)g_malloc0(sizeof(char)*WLAN_BSSID_LEN); + bssid = (char *)g_malloc0(sizeof(char) * WLAN_BSSID_LEN); g_strlcpy(bssid, wifi_info->bssid, WLAN_BSSID_LEN); LOGI_GEOFENCE("fence_id[%d] bssid[%s]", *fence_id, wifi_info->bssid); @@ -734,9 +733,9 @@ int geofence_manager_set_place_info(place_info_s *place_info, int *place_id) char *place_name = NULL; char *query = sqlite3_mprintf("INSERT INTO Places (access_type, place_name, app_id) VALUES (?, ?, ?)"); - place_name = (char *)g_malloc0(sizeof(char)*PLACE_NAME_LEN); + place_name = (char *)g_malloc0(sizeof(char) * PLACE_NAME_LEN); g_strlcpy(place_name, place_info->place_name, PLACE_NAME_LEN); - appid = (char *)g_malloc0(sizeof(char)*APP_ID_LEN); + appid = (char *)g_malloc0(sizeof(char) * APP_ID_LEN); g_strlcpy(appid, place_info->appid, APP_ID_LEN); ret = sqlite3_prepare_v2(db_info_s.handle, query, -1, &state, &tail); @@ -793,7 +792,7 @@ int geofence_manager_set_common_info(fence_common_info_s *fence_info, int *fence const char *tail; char *appid = NULL; char *query = sqlite3_mprintf("INSERT INTO GeoFence (place_id, enable, app_id, geofence_type, access_type, running_status) VALUES (?, ?, ?, ?, ?, ?)"); - appid = (char *)g_malloc0(sizeof(char)*APP_ID_LEN); + appid = (char *)g_malloc0(sizeof(char) * APP_ID_LEN); g_strlcpy(appid, fence_info->appid, APP_ID_LEN); ret = sqlite3_prepare_v2(db_info_s.handle, query, -1, &state, &tail); @@ -1054,7 +1053,7 @@ int geofence_manager_update_place_info(int place_id, const char *place_info_name int ret = SQLITE_OK; char *place_name = NULL; - place_name = (char *)g_malloc0(sizeof(char)*PLACE_NAME_LEN); + place_name = (char *)g_malloc0(sizeof(char) * PLACE_NAME_LEN); g_strlcpy(place_name, place_info_name, PLACE_NAME_LEN); char *query = sqlite3_mprintf("UPDATE Places SET place_name = %Q where place_id = %d", place_name, place_id); @@ -1134,7 +1133,7 @@ int geofence_manager_set_geocoordinate_info(int fence_id, geocoordinate_info_s * __geofence_manager_genarate_password(password); /* ssa_put : latitude*/ - ret = snprintf(data_name_lat, DATA_LEN, "%lf", geocoordinate_info->latitude); + ret = snprintf(data_name_lat, MAX_DATA_NAME, "%lf", geocoordinate_info->latitude); ret = sqlite3_bind_text(state, ++index, data_name_lat, -1, SQLITE_STATIC); @@ -1221,7 +1220,7 @@ int geofence_manager_get_geocoordinate_info(int fence_id, geocoordinate_info_s * *geocoordinate_info = (geocoordinate_info_s *)g_malloc0(sizeof(geocoordinate_info_s)); g_return_val_if_fail(*geocoordinate_info, FENCE_ERR_INVALID_PARAMETER); - + if (password == NULL) __geofence_manager_genarate_password(password); diff --git a/geofence-server/src/geofence_server_internal.c b/geofence-server/src/geofence_server_internal.c index 710450c..d71b96c 100644 --- a/geofence-server/src/geofence_server_internal.c +++ b/geofence-server/src/geofence_server_internal.c @@ -70,7 +70,7 @@ double _get_min_distance(double cur_lat, double cur_lon, GeofenceServer *geofenc geocoordinate_info = (geocoordinate_info_s *)item_data->priv; /* get_current_position/ check_fence_in/out for geoPoint*/ location_manager_get_distance(cur_lat, cur_lon, geocoordinate_info->latitude, geocoordinate_info->longitude, &distance); - if (distance < min_dist) + if (distance < min_dist) min_dist = distance; } item_list = g_list_next(item_list); diff --git a/geofence-server/src/geofence_server_log.c b/geofence-server/src/geofence_server_log.c index ea882e8..c28179a 100644 --- a/geofence-server/src/geofence_server_log.c +++ b/geofence-server/src/geofence_server_log.c @@ -48,7 +48,7 @@ void _init_log() if (cur_time != NULL) sprintf(buf, "[%02d:%02d:%02d] -- START -- \n", cur_time->tm_hour, cur_time->tm_min, cur_time->tm_sec); LOGI_GEOFENCE("BUF[%s]", buf); -/* write(fd, buf, strlen(buf));*/ + /* write(fd, buf, strlen(buf));*/ } void _deinit_log() @@ -61,7 +61,7 @@ void _deinit_log() if (cur_time != NULL) sprintf(buf, "[%02d:%02d:%02d] -- END -- \n", cur_time->tm_hour, cur_time->tm_min, cur_time->tm_sec); LOGI_GEOFENCE("BUF[%s]", buf); -/* write(fd, buf, strlen(buf));*/ + /* write(fd, buf, strlen(buf));*/ close(fd); fd = -1; @@ -78,6 +78,6 @@ void _print_log(const char *str) sprintf(buf, "[%02d:%02d:%02d] %s\n", cur_time->tm_hour, cur_time->tm_min, cur_time->tm_sec, str); LOGI_GEOFENCE("BUF %s", buf); -/* write(fd, buf, strlen(buf));*/ + /* write(fd, buf, strlen(buf));*/ } diff --git a/geofence-server/src/geofence_server_log.h b/geofence-server/src/geofence_server_log.h index 5b1d7a0..592fe66 100644 --- a/geofence-server/src/geofence_server_log.h +++ b/geofence-server/src/geofence_server_log.h @@ -27,11 +27,11 @@ struct tm *__get_current_time(); char buf[256] = {0, }; \ sprintf(buf, " [%s:%d] Status[%s]", __func__, __LINE__, #state); \ _print_log(buf); \ - } + } #define GEOFENCE_PRINT_LOG_WITH_ID(state, id) { \ char buf[256] = {0, }; \ sprintf(buf, " [%s:%d] Status[%s]. ID[%d]", __func__, __LINE__, #state, id); \ _print_log(buf); \ - } + } #endif /* _GEOFENCE_MANAGER_LOG_H_ */ diff --git a/geofence-server/src/geofence_server_private.h b/geofence-server/src/geofence_server_private.h index 73e11e1..f109450 100644 --- a/geofence-server/src/geofence_server_private.h +++ b/geofence-server/src/geofence_server_private.h @@ -23,7 +23,6 @@ #define __GEOFENCE_MANAGER_PRIVATE_H__ #include -#include "geofence-module.h" #include #include #include @@ -38,8 +37,8 @@ extern "C" { /** Length of bssid */ #define WLAN_BSSID_LEN 18 -#define APP_ID_LEN 64 -#define ADDRESS_LEN 64 +#define APP_ID_LEN 64 +#define ADDRESS_LEN 64 #define PLACE_NAME_LEN 64 /** @@ -87,7 +86,6 @@ typedef struct { char ssid[WLAN_BSSID_LEN]; } geofence_s; -/* This can be substituded to GeofenceData*/ typedef struct _geofence_info_s { int fence_id; char app_id[APP_ID_LEN]; @@ -132,14 +130,16 @@ typedef struct { typedef struct { GMainLoop *loop; geofence_dbus_server_h geofence_dbus_server; - GList *geofence_list; /* list of GeofenceData for multi clients */ + GList *geofence_list; /* list of geofence list for multi clients */ GList *tracking_list; /* list of geofence ids for tracking */ time_t last_loc_time; time_t last_result_time; int running_geopoint_cnt; int running_bt_cnt; int running_wifi_cnt; +#if USE_HW_GEOFENCE GeofenceModCB geofence_cb; +#endif gpointer userdata; /* for Geometry's GPS positioning*/ location_manager_h loc_manager; diff --git a/geofence-server/src/server.h b/geofence-server/src/server.h index c5de762..154db89 100644 --- a/geofence-server/src/server.h +++ b/geofence-server/src/server.h @@ -28,9 +28,9 @@ #include typedef enum { - GEOFENCE_STATE_AVAILABLE, - GEOFENCE_STATE_OUT_OF_SERVICE, - GEOFENCE_STATE_TEMPORARILY_UNAVAILABLE, + GEOFENCE_STATE_AVAILABLE, + GEOFENCE_STATE_OUT_OF_SERVICE, + GEOFENCE_STATE_TEMPORARILY_UNAVAILABLE, } geofence_state_t; /** diff --git a/module/CMakeLists.txt b/module/CMakeLists.txt index 6059ff9..b13e779 100644 --- a/module/CMakeLists.txt +++ b/module/CMakeLists.txt @@ -11,7 +11,6 @@ INCLUDE_DIRECTORIES(${SERVER_SRCS_DIR}/include) SET (CLIENT_SRCS module_geofence_server.c - module_internal.c ) ADD_LIBRARY(${geofence_module} SHARED ${CLIENT_SRCS}) diff --git a/module/log.h b/module/log.h index dd3832d..71352ae 100644 --- a/module/log.h +++ b/module/log.h @@ -25,11 +25,6 @@ extern "C" { #include #define TAG_GEOFENCE_MOD "GEOFENCE_MOD" -#define LOGD_GEOFENCE(fmt, args...) LOG(LOG_DEBUG, TAG_GEOFENCE_MOD, fmt, ##args) -#define LOGI_GEOFENCE(fmt, args...) LOG(LOG_INFO, TAG_GEOFENCE_MOD, fmt, ##args) -#define LOGW_GEOFENCE(fmt, args...) LOG(LOG_WARN, TAG_GEOFENCE_MOD, fmt, ##args) -#define LOGE_GEOFENCE(fmt, args...) LOG(LOG_ERROR, TAG_GEOFENCE_SERVER_MOD, fmt, ##args) - #define MOD_LOGD(fmt, args...) LOG(LOG_DEBUG, TAG_GEOFENCE_MOD, fmt, ##args) #define MOD_LOGW(fmt, args...) LOG(LOG_WARN, TAG_GEOFENCE_MOD, fmt, ##args) #define MOD_LOGI(fmt, args...) LOG(LOG_INFO, TAG_GEOFENCE_MOD, fmt, ##args) diff --git a/module/module_geofence_server.c b/module/module_geofence_server.c index 9336895..b6a30da 100644 --- a/module/module_geofence_server.c +++ b/module/module_geofence_server.c @@ -24,150 +24,124 @@ #include #include #include -#include "module_internal.h" +#include #include "log.h" -#define GEOFENCE_MODULE_API __attribute__((visibility("default"))) G_MODULE_EXPORT +#define GEOFENCE_SERVER_SERVICE_NAME "org.tizen.lbs.Providers.GeofenceServer" +#define GEOFENCE_SERVER_SERVICE_PATH "/org/tizen/lbs/Providers/GeofenceServer" + #define MYPLACES_APP_ID "org.tizen.myplace" -/** - * This enumeration descript the geofence type. - * Should be SYNC to geofence_mananger_data_types.h - */ typedef enum { - GEOFENCE_SERVER_TYPE_INVALID = 0, - GEOFENCE_SERVER_TYPE_GEOPOINT = 1, - GEOFENCE_SERVER_TYPE_WIFI, - GEOFENCE_SERVER_TYPE_BT -} geofence_server_type_e; - -/** - * Enumerations of the geofence bssid type. - */ -typedef enum { - GEOFENCE_BSSID_TYPE_WIFI = 0, - GEOFENCE_BSSID_TYPE_BT -} geofence_bssid_type_e; - -#define GEOFENCE_STATE_UNCERTAIN 0 -#define GEOFENCE_STATE_IN 1 -#define GEOFENCE_STATE_OUT 2 -#define _WLAN_BSSID_LEN 18/* bssid 17 + "null"*/ - -typedef struct { - int enabled; - int geofence_type; - gint geofence_id; - gdouble latitude; - gdouble longitude; - gint radius; - char bssid[_WLAN_BSSID_LEN]; -} GeofenceData; + ACCESS_TYPE_PRIVATE = 1, + ACCESS_TYPE_PUBLIC, + ACCESS_TYPE_UNKNOWN, +} access_type_e; typedef struct { geofence_client_dbus_h geofence_client; - GList *geofence_list; GeofenceModCB geofence_cb; GeofenceModEventCB geofence_event_cb; + gchar *app_id; gpointer userdata; } GeofenceManagerData; -#define GEOFENCE_SERVER_SERVICE_NAME "org.tizen.lbs.Providers.GeofenceServer" -#define GEOFENCE_SERVER_SERVICE_PATH "/org/tizen/lbs/Providers/GeofenceServer" - -GEOFENCE_MODULE_API int add_geopoint(void *handle, int place_id, double latitude, double longitude, int radius, const char *address, int *fence_id) +EXPORT_API int add_geopoint(void *handle, int place_id, double latitude, double longitude, int radius, const char *address, int *fence_id) { MOD_LOGD("add_geopoint"); GeofenceManagerData *geofence_manager = (GeofenceManagerData *)handle; - g_return_val_if_fail(geofence_manager, GEOFENCE_MANAGER_ERROR_EXCEPTION); - int geofence_id = -1; + g_return_val_if_fail(geofence_manager, GEOFENCE_MANAGER_ERROR_INVALID_PARAMETER); + int new_fence_id = -1; - geofence_id = geo_client_add_geofence(geofence_manager->geofence_client, place_id, GEOFENCE_TYPE_GEOPOINT, latitude, longitude, radius, address, "", ""); - if (geofence_id == -1) - return GEOFENCE_MANAGER_ERROR_EXCEPTION; - *fence_id = geofence_id; + new_fence_id = geo_client_add_geofence(geofence_manager->geofence_client, geofence_manager->app_id, place_id, GEOFENCE_TYPE_GEOPOINT, latitude, longitude, radius, address, "", ""); + *fence_id = new_fence_id; + + if (new_fence_id == -1) + return GEOFENCE_CLIENT_ERROR_DBUS_CALL; return GEOFENCE_MANAGER_ERROR_NONE; } -GEOFENCE_MODULE_API int add_bssid(void *handle, int place_id, const char *bssid, const char *ssid, geofence_type_e type, int *fence_id) +EXPORT_API int add_bssid(void *handle, int place_id, const char *bssid, const char *ssid, geofence_type_e type, int *fence_id) { MOD_LOGD("add_bssid"); GeofenceManagerData *geofence_manager = (GeofenceManagerData *)handle; - g_return_val_if_fail(geofence_manager, GEOFENCE_MANAGER_ERROR_EXCEPTION); - int geofence_id = -1; + g_return_val_if_fail(geofence_manager, GEOFENCE_MANAGER_ERROR_INVALID_PARAMETER); + int new_fence_id = -1; - geofence_id = geo_client_add_geofence(geofence_manager->geofence_client, place_id, type, -1, -1, -1, "", bssid, ssid); - if (geofence_id == -1) - return GEOFENCE_MANAGER_ERROR_EXCEPTION; - *fence_id = geofence_id; + new_fence_id = geo_client_add_geofence(geofence_manager->geofence_client, geofence_manager->app_id, place_id, type, -1, -1, -1, "", bssid, ssid); + *fence_id = new_fence_id; + + if (new_fence_id == -1) + return GEOFENCE_CLIENT_ERROR_DBUS_CALL; return GEOFENCE_MANAGER_ERROR_NONE; } -GEOFENCE_MODULE_API int add_place(void *handle, const char *place_name, int *place_id) +EXPORT_API int add_place(void *handle, const char *place_name, int *place_id) { MOD_LOGD("add_place"); GeofenceManagerData *geofence_manager = (GeofenceManagerData *)handle; - g_return_val_if_fail(geofence_manager, GEOFENCE_MANAGER_ERROR_EXCEPTION); - int placeid = -1; + g_return_val_if_fail(geofence_manager, GEOFENCE_MANAGER_ERROR_INVALID_PARAMETER); + int new_place_id = -1; - placeid = geo_client_add_place(geofence_manager->geofence_client, place_name); - if (placeid == -1) - return GEOFENCE_MANAGER_ERROR_EXCEPTION; - *place_id = placeid; + new_place_id = geo_client_add_place(geofence_manager->geofence_client, geofence_manager->app_id, place_name); + *place_id = new_place_id; + + if (new_place_id == -1) + return GEOFENCE_CLIENT_ERROR_DBUS_CALL; return GEOFENCE_MANAGER_ERROR_NONE; } -GEOFENCE_MODULE_API int update_place(void *handle, int place_id, const char *place_name) +EXPORT_API int update_place(void *handle, int place_id, const char *place_name) { MOD_LOGD("update_place"); GeofenceManagerData *geofence_manager = (GeofenceManagerData *)handle; - g_return_val_if_fail(geofence_manager, GEOFENCE_MANAGER_ERROR_EXCEPTION); + g_return_val_if_fail(geofence_manager, GEOFENCE_MANAGER_ERROR_INVALID_PARAMETER); - int ret = geo_client_update_place(geofence_manager->geofence_client, place_id, place_name); + int ret = geo_client_update_place(geofence_manager->geofence_client, geofence_manager->app_id, place_id, place_name); if (ret != GEOFENCE_CLIENT_ERROR_NONE) - return GEOFENCE_MANAGER_ERROR_EXCEPTION; + return GEOFENCE_CLIENT_ERROR_DBUS_CALL; return GEOFENCE_MANAGER_ERROR_NONE; } -GEOFENCE_MODULE_API int remove_geofence(void *handle, int fence_id) +EXPORT_API int remove_geofence(void *handle, int fence_id) { MOD_LOGD("remove_geofence"); GeofenceManagerData *geofence_manager = (GeofenceManagerData *)handle; - g_return_val_if_fail(geofence_manager, GEOFENCE_MANAGER_ERROR_EXCEPTION); + g_return_val_if_fail(geofence_manager, GEOFENCE_MANAGER_ERROR_INVALID_PARAMETER); - int ret = geo_client_delete_geofence(geofence_manager->geofence_client, fence_id); + int ret = geo_client_delete_geofence(geofence_manager->geofence_client, geofence_manager->app_id, fence_id); if (ret != GEOFENCE_CLIENT_ERROR_NONE) - return GEOFENCE_MANAGER_ERROR_EXCEPTION; + return GEOFENCE_CLIENT_ERROR_DBUS_CALL; return GEOFENCE_MANAGER_ERROR_NONE; } -GEOFENCE_MODULE_API int remove_place(void *handle, int place_id) +EXPORT_API int remove_place(void *handle, int place_id) { MOD_LOGD("remove_place"); GeofenceManagerData *geofence_manager = (GeofenceManagerData *)handle; - g_return_val_if_fail(geofence_manager, GEOFENCE_MANAGER_ERROR_EXCEPTION); + g_return_val_if_fail(geofence_manager, GEOFENCE_MANAGER_ERROR_INVALID_PARAMETER); - int ret = geo_client_delete_place(geofence_manager->geofence_client, place_id); + int ret = geo_client_delete_place(geofence_manager->geofence_client, geofence_manager->app_id, place_id); if (ret != GEOFENCE_CLIENT_ERROR_NONE) - return GEOFENCE_MANAGER_ERROR_EXCEPTION; + return GEOFENCE_CLIENT_ERROR_DBUS_CALL; return GEOFENCE_MANAGER_ERROR_NONE; } -GEOFENCE_MODULE_API int enable_service(void *handle, int fence_id, bool enable) +EXPORT_API int enable_service(void *handle, int fence_id, bool enable) { MOD_LOGD("enable_service"); GeofenceManagerData *geofence_manager = (GeofenceManagerData *)handle; - g_return_val_if_fail(geofence_manager, GEOFENCE_MANAGER_ERROR_EXCEPTION); + g_return_val_if_fail(geofence_manager, GEOFENCE_MANAGER_ERROR_INVALID_PARAMETER); - int ret = geo_client_enable_service(geofence_manager->geofence_client, fence_id, enable); + int ret = geo_client_enable_geofence(geofence_manager->geofence_client, geofence_manager->app_id, fence_id, enable); if (ret != GEOFENCE_CLIENT_ERROR_NONE) - return GEOFENCE_MANAGER_ERROR_EXCEPTION; + return GEOFENCE_CLIENT_ERROR_DBUS_CALL; return GEOFENCE_MANAGER_ERROR_NONE; } @@ -178,22 +152,11 @@ static void geofence_callback(GVariant *param, void *user_data) GeofenceManagerData *geofence_manager = (GeofenceManagerData *)user_data; int fence_id, access_type, state; char *app_id = NULL; - pid_t pid = 0; - char *appid_from_app = NULL; - g_variant_get(param, "(siii)", &app_id, &fence_id, &access_type, &state); - MOD_LOGI("Getting the app id"); - pid = getpid(); - int ret = app_manager_get_app_id(pid, &appid_from_app); - if (ret != APP_MANAGER_ERROR_NONE) { - MOD_LOGE("Fail to get app_id from module_geofence_server. Err[%d]", ret); - return; - } - MOD_LOGI("APP ID from server : %s", app_id); - MOD_LOGI("APP ID from app manager : %s", appid_from_app); + g_variant_get(param, "(siii)", &app_id, &fence_id, &access_type, &state); if (access_type == ACCESS_TYPE_PRIVATE) { - if (!(g_strcmp0(appid_from_app, app_id))) { /*Sending the alert only the app-id matches in case of private fence*/ + if (!(g_strcmp0(geofence_manager->app_id, app_id))) { /*Sending the alert only the app-id matches in case of private fence*/ if (geofence_manager->geofence_cb) geofence_manager->geofence_cb(fence_id, state, geofence_manager->userdata); } @@ -201,10 +164,6 @@ static void geofence_callback(GVariant *param, void *user_data) if (geofence_manager->geofence_cb) /*Here filteration is done in the manager as public fences cannot be restricted/filtered.*/ geofence_manager->geofence_cb(fence_id, state, geofence_manager->userdata); } - if (appid_from_app) - g_free(appid_from_app); - if (app_id) - g_free(app_id); } static void geofence_event_callback(GVariant *param, void *user_data) @@ -213,63 +172,46 @@ static void geofence_event_callback(GVariant *param, void *user_data) GeofenceManagerData *geofence_manager = (GeofenceManagerData *)user_data; int place_id, fence_id, access_type, error, state; char *app_id = NULL; - pid_t pid = 0; - char *appid = NULL; + g_variant_get(param, "(iiisii)", &place_id, &fence_id, &access_type, &app_id, &error, &state); - MOD_LOGI("Getting the app id"); - pid = getpid(); - int ret = app_manager_get_app_id(pid, &appid); - if (ret != APP_MANAGER_ERROR_NONE) { - MOD_LOGE("Fail to get app_id from module_geofence_server. Err[%d]", ret); - return; - } - MOD_LOGI("APP ID from server : %s", app_id); - MOD_LOGI("APP ID from app manager : %s", appid); - MOD_LOGI("Fence_ID: %d, Error: %d, State: %d", fence_id, error, state); - if (access_type == ACCESS_TYPE_PRIVATE) { - if (!(g_strcmp0(appid, app_id))) { - if (geofence_manager->geofence_event_cb) - geofence_manager->geofence_event_cb(place_id, fence_id, error, state, geofence_manager->userdata); - } - } else if (access_type == ACCESS_TYPE_PUBLIC) { - if (!g_strcmp0(app_id, MYPLACES_APP_ID) || !g_strcmp0(appid, app_id)) { + MOD_LOGD("place_id: %d, fence_id: %d, Error: %d, State: %d(0x%x", place_id, fence_id, error, state, state); + MOD_LOGD("app_id: %s", geofence_manager->app_id); + + if (access_type == ACCESS_TYPE_PUBLIC) { + if (!g_strcmp0(app_id, MYPLACES_APP_ID) || !g_strcmp0(geofence_manager->app_id, app_id)) { if (geofence_manager->geofence_event_cb) geofence_manager->geofence_event_cb(place_id, fence_id, error, state, geofence_manager->userdata); } } else { - if (!(g_strcmp0(appid, app_id))) { + if (!(g_strcmp0(geofence_manager->app_id, app_id))) { if (geofence_manager->geofence_event_cb) geofence_manager->geofence_event_cb(place_id, fence_id, error, state, geofence_manager->userdata); } } - if (appid) - g_free(appid); - if (app_id) - g_free(app_id); } -GEOFENCE_MODULE_API int get_place_name(void *handle, int place_id, char **place_name) +EXPORT_API int get_place_name(void *handle, int place_id, char **place_name) { GeofenceManagerData *geofence_manager = (GeofenceManagerData *) handle; - g_return_val_if_fail(geofence_manager, GEOFENCE_MANAGER_ERROR_EXCEPTION); - g_return_val_if_fail(place_name, GEOFENCE_MANAGER_ERROR_EXCEPTION); + g_return_val_if_fail(geofence_manager, GEOFENCE_MANAGER_ERROR_INVALID_PARAMETER); + g_return_val_if_fail(place_name, GEOFENCE_MANAGER_ERROR_INVALID_PARAMETER); int error_code = GEOFENCE_MANAGER_ERROR_NONE; - int ret = geo_client_get_place_name(geofence_manager->geofence_client, place_id, place_name, &error_code); + int ret = geo_client_get_place_name(geofence_manager->geofence_client, geofence_manager->app_id, place_id, place_name, &error_code); if (ret != GEOFENCE_CLIENT_ERROR_NONE) - return GEOFENCE_MANAGER_ERROR_EXCEPTION; + return GEOFENCE_CLIENT_ERROR_DBUS_CALL; return error_code; } -GEOFENCE_MODULE_API int get_list(void *handle, int place_id, int *fence_amount, int **fence_ids, struct geofence_params_s **params) +EXPORT_API int get_geofences(void *handle, int place_id, int *fence_amount, int **fence_ids, geofence_s **params) { GeofenceManagerData *geofence_manager = (GeofenceManagerData *) handle; - g_return_val_if_fail(geofence_manager, GEOFENCE_MANAGER_ERROR_EXCEPTION); - g_return_val_if_fail(fence_amount, GEOFENCE_MANAGER_ERROR_EXCEPTION); - g_return_val_if_fail(fence_ids, GEOFENCE_MANAGER_ERROR_EXCEPTION); - g_return_val_if_fail(params, GEOFENCE_MANAGER_ERROR_EXCEPTION); + g_return_val_if_fail(geofence_manager, GEOFENCE_MANAGER_ERROR_INVALID_PARAMETER); + g_return_val_if_fail(fence_amount, GEOFENCE_MANAGER_ERROR_INVALID_PARAMETER); + g_return_val_if_fail(fence_ids, GEOFENCE_MANAGER_ERROR_INVALID_PARAMETER); + g_return_val_if_fail(params, GEOFENCE_MANAGER_ERROR_INVALID_PARAMETER); if (!geofence_manager) { *fence_amount = 0; @@ -283,15 +225,16 @@ GEOFENCE_MODULE_API int get_list(void *handle, int place_id, int *fence_amount, int fence_cnt = 0; int error_code = GEOFENCE_MANAGER_ERROR_NONE; - /*Call the geofence_client api here....*/ - geo_client_get_list(geofence_manager->geofence_client, place_id, &iter, &fence_cnt, &error_code); + int ret = geo_client_get_geofences(geofence_manager->geofence_client, geofence_manager->app_id, place_id, &iter, &fence_cnt, &error_code); if (error_code != GEOFENCE_MANAGER_ERROR_NONE) return error_code; + else if (ret != GEOFENCE_MANAGER_ERROR_NONE) + return GEOFENCE_CLIENT_ERROR_DBUS_CALL; *fence_amount = fence_cnt; - MOD_LOGI("Total fence count : %d", *fence_amount); - int *fence_id_array = (int *) g_slice_alloc0(sizeof(int)*fence_cnt); - geofence_params_s *p = (geofence_params_s *)g_slice_alloc0(sizeof(geofence_params_s)*fence_cnt); + MOD_LOGD("Total fence count : %d", *fence_amount); + int *fence_id_array = (int *) g_slice_alloc0(sizeof(int) * fence_cnt); + geofence_s *p = (geofence_s *) g_slice_alloc0(sizeof(geofence_s) * fence_cnt); if (iter == NULL) { MOD_LOGI("Iterator is null"); @@ -300,7 +243,7 @@ GEOFENCE_MODULE_API int get_list(void *handle, int place_id, int *fence_amount, while (g_variant_iter_loop(iter_row, "{sv}", &key, &value)) { if (!g_strcmp0(key, "fence_id")) { fence_id_array[index] = - g_variant_get_int32(value); + g_variant_get_int32(value); } else if (!g_strcmp0(key, "place_id")) { p[index].place_id = g_variant_get_int32(value); } else if (!g_strcmp0(key, "geofence_type")) { @@ -312,11 +255,11 @@ GEOFENCE_MODULE_API int get_list(void *handle, int place_id, int *fence_amount, } else if (!g_strcmp0(key, "radius")) { p[index].radius = g_variant_get_int32(value); } else if (!g_strcmp0(key, "address")) { - g_strlcpy(p[index].address, g_variant_get_string(value, NULL), _ADDRESS_LEN); + g_strlcpy(p[index].address, g_variant_get_string(value, NULL), ADDRESS_LEN); } else if (!g_strcmp0(key, "bssid")) { - g_strlcpy(p[index].bssid, g_variant_get_string(value, NULL), _WLAN_BSSID_LEN); + g_strlcpy(p[index].bssid, g_variant_get_string(value, NULL), WLAN_BSSID_LEN); } else if (!g_strcmp0(key, "ssid")) { - g_strlcpy(p[index].ssid, g_variant_get_string(value, NULL), _WLAN_BSSID_LEN); + g_strlcpy(p[index].ssid, g_variant_get_string(value, NULL), WLAN_BSSID_LEN); } } MOD_LOGI("Fence_id: %d, Place_id: %d, Type: %d, lat: %f, lon: %f, rad: %d, address: %s, bssid: %s, ssid: %s", fence_id_array[index], p[index].place_id, p[index].type, p[index].latitude, p[index].longitude, p[index].radius, p[index].address, p[index].bssid, p[index].ssid); @@ -324,19 +267,19 @@ GEOFENCE_MODULE_API int get_list(void *handle, int place_id, int *fence_amount, g_variant_iter_free(iter_row); } g_variant_iter_free(iter); - *params = (struct geofence_params_s *) p; + *params = (geofence_s *) p; *fence_ids = fence_id_array; return GEOFENCE_MANAGER_ERROR_NONE; } -GEOFENCE_MODULE_API int get_place_list(void *handle, int *place_amount, int **place_ids, struct place_params_s **params) +EXPORT_API int get_places(void *handle, int *place_amount, int **place_ids, place_s **params) { GeofenceManagerData *geofence_manager = (GeofenceManagerData *) handle; - g_return_val_if_fail(geofence_manager, GEOFENCE_MANAGER_ERROR_EXCEPTION); - g_return_val_if_fail(place_amount, GEOFENCE_MANAGER_ERROR_EXCEPTION); - g_return_val_if_fail(place_ids, GEOFENCE_MANAGER_ERROR_EXCEPTION); - g_return_val_if_fail(params, GEOFENCE_MANAGER_ERROR_EXCEPTION); + g_return_val_if_fail(geofence_manager, GEOFENCE_MANAGER_ERROR_INVALID_PARAMETER); + g_return_val_if_fail(place_amount, GEOFENCE_MANAGER_ERROR_INVALID_PARAMETER); + g_return_val_if_fail(place_ids, GEOFENCE_MANAGER_ERROR_INVALID_PARAMETER); + g_return_val_if_fail(params, GEOFENCE_MANAGER_ERROR_INVALID_PARAMETER); if (!geofence_manager) { *place_amount = 0; @@ -351,14 +294,14 @@ GEOFENCE_MODULE_API int get_place_list(void *handle, int *place_amount, int **pl int error_code = -1; /*Call the geofence_client api here....*/ - geo_client_get_place_list(geofence_manager->geofence_client, &iter, &place_cnt, &error_code); + geo_client_get_places(geofence_manager->geofence_client, geofence_manager->app_id, &iter, &place_cnt, &error_code); if (error_code != GEOFENCE_MANAGER_ERROR_NONE) return error_code; *place_amount = place_cnt; MOD_LOGI("Total place count : %d", *place_amount); - int *place_id_array = (int *)g_slice_alloc0(sizeof(int)*place_cnt); - place_params_s *p = (place_params_s *)g_slice_alloc0(sizeof(place_params_s)*place_cnt); + int *place_id_array = (int *)g_slice_alloc0(sizeof(int) * place_cnt); + place_s *p = (place_s *)g_slice_alloc0(sizeof(place_s) * place_cnt); if (iter == NULL) MOD_LOGI("Iterator is null"); @@ -368,7 +311,7 @@ GEOFENCE_MODULE_API int get_place_list(void *handle, int *place_amount, int **pl if (!g_strcmp0(key, "place_id")) { place_id_array[index] = g_variant_get_int32(value); } else if (!g_strcmp0(key, "place_name")) { - g_strlcpy(p[index].place_name, g_variant_get_string(value, NULL), _PLACE_NAME_LEN); + g_strlcpy(p[index].place_name, g_variant_get_string(value, NULL), PLACE_NAME_LEN); } } MOD_LOGI("place_id: %d, place_name: %s", place_id_array[index], p[index].place_name); @@ -376,7 +319,8 @@ GEOFENCE_MODULE_API int get_place_list(void *handle, int *place_amount, int **pl g_variant_iter_free(iter_row); } g_variant_iter_free(iter); - *params = (struct place_params_s *) p; + *params = (place_s *)p; + *place_ids = place_id_array; return GEOFENCE_MANAGER_ERROR_NONE; @@ -395,7 +339,7 @@ static void on_signal_callback(const gchar *sig, GVariant *param, gpointer user_ } } -GEOFENCE_MODULE_API int start_geofence(void *handle, int fence_id) +EXPORT_API int start_geofence(void *handle, int fence_id) { MOD_LOGD("start_geofence"); GeofenceManagerData *geofence_manager = (GeofenceManagerData *)handle; @@ -405,39 +349,39 @@ GEOFENCE_MODULE_API int start_geofence(void *handle, int fence_id) MOD_LOGD("geofence-server(%x)", geofence_manager); - ret = geo_client_start_geofence(geofence_manager->geofence_client, fence_id); + ret = geo_client_start_geofence(geofence_manager->geofence_client, geofence_manager->app_id, fence_id); if (ret != GEOFENCE_MANAGER_ERROR_NONE) { MOD_LOGE("Fail to start geofence_client_h. Error[%d]", ret); - return GEOFENCE_MANAGER_ERROR_EXCEPTION; + return GEOFENCE_CLIENT_ERROR_DBUS_CALL; } return GEOFENCE_MANAGER_ERROR_NONE; } -GEOFENCE_MODULE_API int stop_geofence(void *handle, int fence_id) +EXPORT_API int stop_geofence(void *handle, int fence_id) { GeofenceManagerData *geofence_manager = (GeofenceManagerData *)handle; MOD_LOGD("geofence_manager->geofence_cb : %x", geofence_manager->geofence_cb); - g_return_val_if_fail(geofence_manager, GEOFENCE_MANAGER_ERROR_EXCEPTION); - g_return_val_if_fail(geofence_manager->geofence_client, GEOFENCE_MANAGER_ERROR_EXCEPTION); + g_return_val_if_fail(geofence_manager, GEOFENCE_MANAGER_ERROR_INVALID_PARAMETER); + g_return_val_if_fail(geofence_manager->geofence_client, GEOFENCE_MANAGER_ERROR_INVALID_PARAMETER); int ret = GEOFENCE_CLIENT_ERROR_NONE; - ret = geo_client_stop_geofence(geofence_manager->geofence_client, fence_id); + ret = geo_client_stop_geofence(geofence_manager->geofence_client, geofence_manager->app_id, fence_id); if (ret != GEOFENCE_MANAGER_ERROR_NONE) { MOD_LOGE("Fail to stop. Error[%d]", ret); - return GEOFENCE_MANAGER_ERROR_EXCEPTION; + return GEOFENCE_CLIENT_ERROR_DBUS_CALL; } return GEOFENCE_MANAGER_ERROR_NONE; } -GEOFENCE_MODULE_API int create(void *handle, GeofenceModCB geofence_cb, - GeofenceModEventCB geofence_event_cb, void *userdata) +EXPORT_API int create(void *handle, GeofenceModCB geofence_cb, + GeofenceModEventCB geofence_event_cb, void *userdata) { GeofenceManagerData *geofence_manager = (GeofenceManagerData *) handle; - g_return_val_if_fail(geofence_manager, GEOFENCE_MANAGER_ERROR_EXCEPTION); - g_return_val_if_fail(geofence_cb, GEOFENCE_MANAGER_ERROR_EXCEPTION); + g_return_val_if_fail(geofence_manager, GEOFENCE_MANAGER_ERROR_INVALID_PARAMETER); + g_return_val_if_fail(geofence_cb, GEOFENCE_MANAGER_ERROR_INVALID_PARAMETER); /* create connnection */ int ret = GEOFENCE_MANAGER_ERROR_NONE; @@ -449,10 +393,15 @@ GEOFENCE_MODULE_API int create(void *handle, GeofenceModCB geofence_cb, ret = geo_client_create(&(geofence_manager->geofence_client)); if (ret != GEOFENCE_CLIENT_ERROR_NONE || !geofence_manager->geofence_client) { MOD_LOGE("Fail to create geofence_client_dbus_h. Error[%d]", ret); - return GEOFENCE_MANAGER_ERROR_EXCEPTION; + return GEOFENCE_CLIENT_ERROR_DBUS_CALL; } - ret = geo_client_start(GEOFENCE_SERVER_SERVICE_NAME, GEOFENCE_SERVER_SERVICE_PATH, geofence_manager->geofence_client, on_signal_callback, on_signal_callback, geofence_manager); + MOD_LOGD("geofence_manager->geofence_client: %p", geofence_manager->geofence_client); + ret = geo_client_start(geofence_manager->geofence_client, on_signal_callback, geofence_manager); +#if 0 + ret = geo_client_start(geofence_manager->geofence_client, on_signal_callback, geofence_manager); +#endif + if (ret != GEOFENCE_CLIENT_ERROR_NONE) { if (ret == GEOFENCE_CLIENT_ACCESS_DENIED) { MOD_LOGE("Access denied[%d]", ret); @@ -462,19 +411,19 @@ GEOFENCE_MODULE_API int create(void *handle, GeofenceModCB geofence_cb, geo_client_destroy(geofence_manager->geofence_client); geofence_manager->geofence_client = NULL; - return GEOFENCE_CLIENT_ERROR_UNKNOWN; + return GEOFENCE_CLIENT_ERROR_DBUS_CALL; } return GEOFENCE_MANAGER_ERROR_NONE; } -GEOFENCE_MODULE_API int destroy(void *handle) +EXPORT_API int destroy(void *handle) { MOD_LOGD("destroy"); GeofenceManagerData *geofence_manager = (GeofenceManagerData *)handle; - g_return_val_if_fail(geofence_manager, GEOFENCE_MANAGER_ERROR_EXCEPTION); - g_return_val_if_fail(geofence_manager->geofence_client, GEOFENCE_MANAGER_ERROR_EXCEPTION); + g_return_val_if_fail(geofence_manager, GEOFENCE_MANAGER_ERROR_INVALID_PARAMETER); + g_return_val_if_fail(geofence_manager->geofence_client, GEOFENCE_MANAGER_ERROR_INVALID_PARAMETER); int ret = GEOFENCE_MANAGER_ERROR_NONE; @@ -483,13 +432,13 @@ GEOFENCE_MODULE_API int destroy(void *handle) MOD_LOGE("Fail to stop. Error[%d]", ret); geo_client_destroy(geofence_manager->geofence_client); geofence_manager->geofence_client = NULL; - return GEOFENCE_CLIENT_ERROR_UNKNOWN; + return GEOFENCE_MANAGER_ERROR_IPC; } ret = geo_client_destroy(geofence_manager->geofence_client); if (ret != GEOFENCE_CLIENT_ERROR_NONE) { MOD_LOGE("Fail to destroy. Error[%d]", ret); - return GEOFENCE_CLIENT_ERROR_UNKNOWN; + return GEOFENCE_MANAGER_ERROR_IPC; } geofence_manager->geofence_client = NULL; geofence_manager->geofence_cb = NULL; @@ -499,7 +448,26 @@ GEOFENCE_MODULE_API int destroy(void *handle) return GEOFENCE_MANAGER_ERROR_NONE; } -GEOFENCE_MODULE_API gpointer init(GeofenceModOps *ops) +static void __get_caller_app_id(void *handle) +{ + GeofenceManagerData *geofence_manager = (GeofenceManagerData *)handle; + g_return_if_fail(geofence_manager); + + gchar *app_id = NULL; + int ret = 0; + + pid_t pid = 0; + pid = getpid(); + ret = app_manager_get_app_id(pid, &app_id); + if (ret != APP_MANAGER_ERROR_NONE) { + MOD_LOGE("Fail to get app_id from module_geofence_server. Err[%d]", ret); + } else { + MOD_LOGD("app_id: %s", app_id); + geofence_manager->app_id = app_id; + } +} + +EXPORT_API gpointer init(GeofenceModOps *ops) { MOD_LOGD("init"); @@ -511,13 +479,14 @@ GEOFENCE_MODULE_API gpointer init(GeofenceModOps *ops) ops->stop_geofence = stop_geofence; ops->add_geopoint = add_geopoint; ops->add_bssid = add_bssid; + ops->remove_geofence = remove_geofence; + ops->get_geofences = get_geofences; + ops->add_place = add_place; ops->update_place = update_place; - ops->remove_geofence = remove_geofence; ops->remove_place = remove_place; ops->get_place_name = get_place_name; - ops->get_list = get_list; - ops->get_place_list = get_place_list; + ops->get_places = get_places; GeofenceManagerData *geofence_manager = g_new0(GeofenceManagerData, 1); g_return_val_if_fail(geofence_manager, NULL); @@ -526,10 +495,12 @@ GEOFENCE_MODULE_API gpointer init(GeofenceModOps *ops) geofence_manager->geofence_event_cb = NULL; geofence_manager->userdata = NULL; + __get_caller_app_id(geofence_manager); + return (gpointer) geofence_manager; } -GEOFENCE_MODULE_API void shutdown(gpointer handle) +EXPORT_API void shutdown(gpointer handle) { MOD_LOGD("shutdown"); g_return_if_fail(handle); @@ -542,7 +513,7 @@ GEOFENCE_MODULE_API void shutdown(gpointer handle) } geofence_manager->geofence_cb = NULL; - + g_free(geofence_manager->app_id); g_free(geofence_manager); geofence_manager = NULL; } diff --git a/module/module_internal.c b/module/module_internal.c deleted file mode 100644 index a278ff4..0000000 --- a/module/module_internal.c +++ /dev/null @@ -1,143 +0,0 @@ -/* Copyright 2014 Samsung Electronics Co., Ltd All Rights Reserved - * - * 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 "module_internal.h" -#include "log.h" - -/** Length of bssid */ -#define WLAN_BSSID_LEN 18 -#define APP_ID_LEN 64 -#define FENCE_NAME_LEN 64 - -#define GEOFENCE_DEFAULT_RADIUS 200 /* Default 200 m */ - -/* -* TODO: after transiting geofence-server package on CMake build following structures must be elliminated, -* because they are copying existing structures in a sub-folder geofence-server -*/ - -/** - * This enumeration describe the cell geofence in and out status. - */ -typedef enum { - CELL_UNKNOWN = -1, - CELL_OUT = 0, - CELL_IN = 1 -} cell_status_e; - -/** - * This enumeration descript the geofence fence state. - */ -typedef enum { - GEOFENCE_FENCE_STATE_UNCERTAIN = -1, - GEOFENCE_FENCE_STATE_OUT = 0, - GEOFENCE_FENCE_STATE_IN = 1, -} geofence_fence_state_e; - -/** - * The geofence common information structure - */ -typedef struct { - int fence_id; - geofence_fence_state_e status; - geofence_manager_type_e type; /* Geocoordinate/WIFI/CurrentLocation/Bluetooth */ - char fence_name[FENCE_NAME_LEN]; - char appid[APP_ID_LEN]; - int smart_assist_id; - gboolean cell_db; - time_t last_update; -} fence_common_info_s; - -/** - *The geocoordinate structure - */ -typedef struct { - double latitude; - double longitude; - double radius; -} geocoordinate_info_s; - -/** - *The wifi info structure - */ -typedef struct { - char bssid[WLAN_BSSID_LEN]; -} wifi_info_s; - -/** - *The bluetooth info structure - */ -typedef struct { - char bssid[WLAN_BSSID_LEN]; - gboolean enabled; /* bluetooth callback receive or not */ -} bssid_info_s; - -typedef enum { - GEOFENCE_CLIENT_STATUS_NONE, - GEOFENCE_CLIENT_STATUS_FIRST_LOCATION, - GEOFENCE_CLIENT_STATUS_START, - GEOFENCE_CLIENT_STATUS_RUNNING -} geofence_client_status_e; - -/** - *The GeofenceItemData structure - */ -typedef struct { - double distance; -#ifdef __WIFI_DB_SUPPORTED__ - int wifi_db_set; - wifi_status_e wifi_direction; - wifi_status_e priv_wifi_direction; -#endif - geofence_client_status_e client_status; - cell_status_e cell_status; - fence_common_info_s common_info; - void *priv; /* Save (latitude, longitude and radius) or AP list */ - - bool is_wifi_status_in; - bool is_bt_status_in; -} GeofenceItemData; - -static gint __find_custom_item_by_fence_id(gconstpointer data, gconstpointer compare_with) -{ - g_return_val_if_fail(data, 1); - g_return_val_if_fail(compare_with, -1); - int ret = -1; - - GeofenceItemData *item_data = (GeofenceItemData *) data; - int *fence_id = (int *) compare_with; - if (item_data->common_info.fence_id == *fence_id) { - ret = 0; - } - - return ret; -} - -GeofenceItemData *__get_item_by_fence_id(gint fence_id, GList *geofence_list) -{ - g_return_val_if_fail(geofence_list, NULL); - - geofence_list = g_list_first(geofence_list); - GList *found_item = NULL; - found_item = g_list_find_custom(geofence_list, &fence_id, __find_custom_item_by_fence_id); - if (found_item == NULL || found_item->data == NULL) { - MOD_LOGD("item_data is not found. found_item[%d]", found_item); - return NULL; - } - - /*Get the item from the list and return it*/ - return (GeofenceItemData *) found_item->data; -} diff --git a/module/module_internal.h b/module/module_internal.h deleted file mode 100644 index 9fda603..0000000 --- a/module/module_internal.h +++ /dev/null @@ -1,102 +0,0 @@ -/* Copyright 2014 Samsung Electronics Co., Ltd All Rights Reserved - * - * 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 __GEOFENCE_MANAGER_PRIVATE_ITEM_DATA_H__ -#define __GEOFENCE_MANAGER_PRIVATE_ITEM_DATA_H__ - -#include -#include -#include -#include "geofence-module.h" - -typedef enum { - GEOFENCE_MANAGER_ERROR_NONE = TIZEN_ERROR_NONE, /**< Success */ - GEOFENCE_MANAGER_ERROR_OUT_OF_MEMORY = TIZEN_ERROR_OUT_OF_MEMORY, /**< Out of memory */ - GEOFENCE_MANAGER_ERROR_INVALID_PARAMETER = TIZEN_ERROR_INVALID_PARAMETER, /**< Invalid parameter */ - GEOFENCE_MANAGER_ERROR_PERMISSION_DENIED = TIZEN_ERROR_PERMISSION_DENIED, /**< Permission denied */ - GEOFENCE_MANAGER_ERROR_NOT_SUPPORTED = TIZEN_ERROR_NOT_SUPPORTED, /**< Not supported */ - GEOFENCE_MANAGER_ERROR_NOT_INITIALIZED = TIZEN_ERROR_GEOFENCE_MANAGER | 0x01, /**< Geofence Manager is not initialized */ - GEOFENCE_MANAGER_ERROR_INVALID_ID = TIZEN_ERROR_GEOFENCE_MANAGER | 0x02, /**< Geofence ID is not exist */ - GEOFENCE_MANAGER_ERROR_EXCEPTION = TIZEN_ERROR_GEOFENCE_MANAGER | 0x03, /**< exception is occured */ - GEOFENCE_MANAGER_ERROR_ALREADY_STARTED = TIZEN_ERROR_GEOFENCE_MANAGER | 0x04, /**< Geofence is already started */ - GEOFENCE_MANAGER_ERROR_TOO_MANY_GEOFENCE = TIZEN_ERROR_GEOFENCE_MANAGER | 0x05, /**< Too many Geofence */ - GEOFENCE_MANAGER_ERROR_IPC = TIZEN_ERROR_GEOFENCE_MANAGER | 0x06, /**< Error occured in GPS/WIFI/BT */ - GEOFENCE_MANAGER_ERROR_DATABASE = TIZEN_ERROR_GEOFENCE_MANAGER | 0x07, /**< DB error occured in the server side */ - GEOFENCE_MANAGER_ERROR_PLACE_ACCESS_DENIED = TIZEN_ERROR_GEOFENCE_MANAGER | 0x08, /**< Access to specified place is denied */ - GEOFENCE_MANAGER_ERROR_GEOFENCE_ACCESS_DENIED = TIZEN_ERROR_GEOFENCE_MANAGER | 0x09, /**< Access to specified geofence is denied */ -} geofence_manager_error_e; - -typedef enum { - GEOFENCE_MANAGER_TYPE_GEOPOINT = 1, - GEOFENCE_MANAGER_TYPE_WIFI, - GEOFENCE_MANAGER_TYPE_BT, -} geofence_manager_type_e; - -typedef enum { - GEOFENCE_MANAGER_ACCESS_TYPE_PRIVATE = 1, - GEOFENCE_MANAGER_ACCESS_TYPE_PUBLIC, - GEOFENCE_MANAGER_ACCESS_TYPE_UNKNOWN, -} geofence_manager_access_type_e; - -typedef enum { - GEOFENCE_STATE_UNCERTAIN = 0, - GEOFENCE_STATE_IN, - GEOFENCE_STATE_OUT, -} geofence_state_e; - -#define _WLAN_BSSID_LEN 18 -#define _PLACE_NAME_LEN 64 -#define _ADDRESS_LEN 64 -#define _APP_ID_LEN 64 - -typedef struct { - geofence_manager_type_e type; - double latitude; - double longitude; - int radius; - char address[_ADDRESS_LEN]; - char bssid[_WLAN_BSSID_LEN]; - char ssid[_WLAN_BSSID_LEN]; - int place_id; -} geofence_params_s; - -typedef struct { - char place_name[_PLACE_NAME_LEN]; -} place_params_s; - -typedef struct { - geofence_state_e state; - int seconds; -} geofence_status_s; - -/* This can be substituted to GeofenceData*/ -typedef struct _geofence_info_s { - int fence_id; - geofence_params_s param; -} geofence_info_s; - -typedef struct _place_info_s { - int place_id; - place_params_s param; -} place_info_s; - -int geofence_item_data_get_fence_id(gpointer data, int *fence_id); -int geofence_item_data_get_params(gpointer data, geofence_params_s *p); -int geofence_item_data_get_fence_status(gpointer data, geofence_status_s *s); -int add_fence_to_list(int fence_id, const char *fence_name, const double latitude, const double longitude, int radius, const char *bssid, geofence_type_e geofence_type, GList **geofence_list); -void remove_fence_from_list(int fence_id, GList **geofence_list); -void update_fence_state(int fence_id, geofence_state_e state, GList *geofence_list); - -#endif /* __GEOFENCE_MANAGER_PRIVATE_ITEM_DATA_H__ */ diff --git a/packaging/geofence-server.spec b/packaging/geofence-server.spec index 9467188..2d87db4 100644 --- a/packaging/geofence-server.spec +++ b/packaging/geofence-server.spec @@ -1,6 +1,6 @@ Name: geofence-server Summary: Geofence Server for Tizen -Version: 0.3.9 +Version: 0.4.0 Release: 1 Group: Location/Service License: Apache-2.0 @@ -16,7 +16,6 @@ Requires(post): lbs-server BuildRequires: cmake BuildRequires: pkgconfig(glib-2.0) BuildRequires: pkgconfig(network) -#BuildRequires: pkgconfig(tapi) BuildRequires: pkgconfig(vconf) BuildRequires: pkgconfig(dlog) BuildRequires: pkgconfig(geofence-dbus) @@ -29,33 +28,20 @@ BuildRequires: pkgconfig(vconf) BuildRequires: pkgconfig(vconf-internal-keys) BuildRequires: pkgconfig(capi-appfw-app-manager) BuildRequires: pkgconfig(capi-location-manager) -#BuildRequires: pkgconfig(capi-geofence-manager) -#BuildRequires: pkgconfig(capi-telephony-network-info) -BuildRequires: pkgconfig(capi-network-wifi) -BuildRequires: pkgconfig(capi-network-bluetooth) -#BuildRequires: pkgconfig(capi-context-manager) -BuildRequires: pkgconfig(secure-storage) -BuildRequires: pkgconfig(libcore-context-manager) +BuildRequires: pkgconfig(capi-network-wifi) +BuildRequires: pkgconfig(capi-network-bluetooth) +BuildRequires: pkgconfig(secure-storage) +BuildRequires: pkgconfig(libcore-context-manager) +#BuildRequires: pkgconfig(tapi) +#BuildRequires: pkgconfig(capi-telephony-network-info) +#BuildRequires: pkgconfig(capi-context-manager) +BuildRequires: pkgconfig(capi-geofence-manager) +BuildRequires: capi-geofence-manager-plugin-devel Requires: sys-assert %description Geofence Server for Tizen -%package -n location-geofence-server -Summary: Geofence Server for Tizen -Group: Location/Libraries -Requires: %{name} = %{version}-%{release} - -%description -n location-geofence-server -Geofence Server for Tizen - -%package -n geofence-server-devel -Summary: Geofence Server for Tizen (Development) -Group: Location/Development -Requires: %{name} = %{version}-%{release} - -%description -n geofence-server-devel -Geofence Server for Tizen (Development) %prep %setup -q @@ -112,6 +98,20 @@ chmod 660 /opt/dbspace/.geofence-server.db-journal /opt/dbspace/.*.db* %config %{_sysconfdir}/dbus-1/system.d/geofence-server.conf +%package -n location-geofence-server +Summary: Geofence Server for Tizen +Group: Development/Libraries +Requires: %{name} = %{version}-%{release} + +%description -n location-geofence-server +Geofence Server for Tizen + +%post -n location-geofence-server +/sbin/ldconfig + +%postun -n location-geofence-server +/sbin/ldconfig + %files -n location-geofence-server %manifest location-geofence-server.manifest %{_libdir}/geofence/module/libgeofence.so* -- 2.7.4