sync with tizen_2.4submit/tizen/20150810.082148submit/tizen/20150810.015457accepted/tizen/wearable/20150810.102057accepted/tizen/tv/20150810.101907accepted/tizen/mobile/20150810.101716

Signed-off-by: jomui <jongmun.woo@samsung.com>
Change-Id: Id3aa381a6872a49338bf206ed1a209f29045d3b9

20 files changed, 600 insertions, 937 deletions

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 <geofence_dbus_server.h>
-#include "geofence-module.h"
 #include <locations.h>
 #include <alarm.h>
 #include <network-wifi-intf.h>
@@ -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 <wifi.h>
 
 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 <dlog.h>
 #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 <app_manager.h>
 #include <dlfcn.h>
 #include <geofence_client.h>
-#include "module_internal.h"
+#include <geofence_module.h>
 #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 <stdbool.h>
-#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 <glib.h>
-#include <tizen_type.h>
-#include <tizen_error.h>
-#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*