From: Youngjae Shin <yj99.shin@samsung.com>
Date: Thu, 29 Aug 2013 08:08:51 +0000 (+0900)
Subject: revise p2p and remove exchange data type
X-Git-Tag: submit/tizen/20130830.071135~3
X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=dc96674b01f8af7ea5e63cdb6b1c42ef87ebdb14;p=platform%2Fcore%2Fconnectivity%2Fnfc-manager.git

revise p2p and remove exchange data type

Change-Id: I8015971765c8090db60168777f3709524e1a60a1
---

diff --git a/client/include/net_nfc.h b/client/include/net_nfc.h
index 454332d..51183ae 100644
--- a/client/include/net_nfc.h
+++ b/client/include/net_nfc.h
@@ -38,7 +38,6 @@ extern "C" {
 #include "net_nfc_client_llcp.h"
 #include "net_nfc_client_p2p.h"
 #include "net_nfc_client_snep.h"
-#include "net_nfc_client_exchanger.h"
 #include "net_nfc_client_handover.h"
 #include "net_nfc_client_se.h"
 #include "net_nfc_client_tag_felica.h"
diff --git a/client/include/net_nfc_client_exchanger.h b/client/include/net_nfc_client_exchanger.h
deleted file mode 100644
index 21b0545..0000000
--- a/client/include/net_nfc_client_exchanger.h
+++ /dev/null
@@ -1,140 +0,0 @@
-/*
- * Copyright (c) 2012, 2013 Samsung Electronics Co., Ltd.
- *
- * Licensed under the Flora License, Version 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://floralicense.org/license/
- *
- * 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 __NET_NFC_CLIENT_EXCHANGER_H__
-#define __NET_NFC_CLIENT_EXCHANGER_H__
-
-
-#include "net_nfc_typedef.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
-@addtogroup NET_NFC_MANAGER_EXCHANGE
-@{
-
-*/
-
-
-/**
-	create net_nfc_exchagner raw type data handler with given values
-
-	@param[out]	ex_data 		exchangner handler
-	@param[in]	payload		the data will be deliver (NDEF message)
-
-	@return 		result of this function call
-
-	@exception NET_NFC_ALLOC_FAIL			memory allocation is failed
-	@exception NET_NFC_NULL_PARAMETER		parameter(s) has(have) illegal NULL pointer(s)
-*/
-net_nfc_error_e net_nfc_client_create_exchanger_data(
-			net_nfc_exchanger_data_h *ex_data,
-			data_h payload);
-
-
-/**
-	this makes free exchagner data handler
-
-	@param[in]	ex_data 		exchagner handler
-
-	@return 		result of this function call
-
-	@exception NET_NFC_NULL_PARAMETER		parameter(s) has(have) illigal NULL pointer(s)
-*/
-net_nfc_error_e net_nfc_client_free_exchanger_data (
-			net_nfc_exchanger_data_h ex_data);
-
-
-net_nfc_error_e net_nfc_client_unset_exchanger_cb();
-
-
-net_nfc_error_e net_nfc_client_send_exchanger_data (
-			net_nfc_exchanger_data_h ex_handle,
-			net_nfc_target_handle_h target_handle,
-			void* trans_param);
-
-/**
-	request connection handover with discovered P2P device
-
-	@param[in]	target_handle 		target device handle
-	@param[in]	type 		specific alternative carrier type (if type is NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN, it will be selected available type of this target)
-	@param[in] 	trans_param	user data
-
-	@return 		result of this function call
-
-	@exception NET_NFC_ALLOC_FAIL			memory allocation is failed
-	@exception NET_NFC_NULL_PARAMETER		parameter(s) has(have) illigal NULL pointer(s)
-*/
-net_nfc_error_e net_nfc_client_exchanger_request_connection_handover(
-			net_nfc_target_handle_h target_handle,
-			net_nfc_conn_handover_carrier_type_e type);
-
-/**
-	get alternative carrier type from connection handover information handle.
-
-	@param[in] 	info_handle		connection handover information handle
-	@param[out] 	type	alternative carrier type
-
-	@return 	return the result of this operation
-
-	@exception NET_NFC_NULL_PARAMETER		parameter(s) has(have) illigal NULL pointer(s)
-*/
-net_nfc_error_e net_nfc_client_exchanger_get_alternative_carrier_type(
-			net_nfc_connection_handover_info_h info_handle,
-			net_nfc_conn_handover_carrier_type_e *type);
-
-/**
-	get alternative carrier dependant data from connection handover information handle.
-	Bluetooth : target device address
-	Wifi : target device ip address
-
-	@param[in] 	info_handle		connection handover information handle
-	@param[out] 	data	alternative carrier data
-
-	@return 	return the result of this operation
-
-	@exception NET_NFC_ALLOC_FAIL			memory allocation is failed
-	@exception NET_NFC_NULL_PARAMETER		parameter(s) has(have) illigal NULL pointer(s)
-*/
-net_nfc_error_e net_nfc_client_exchanger_get_alternative_carrier_data(
-			net_nfc_connection_handover_info_h info_handle,
-			data_h *data);
-
-/**
-	this makes free alternative carrier data handler
-
-	@param[in]	info_handle 		alternative carrier data handler
-
-	@return 		result of this function call
-
-	@exception NET_NFC_NULL_PARAMETER		parameter(s) has(have) illigal NULL pointer(s)
-*/
-net_nfc_error_e net_nfc_client_exchanger_free_alternative_carrier_data(
-			net_nfc_connection_handover_info_h info_handle);
-
-
-/**
-@}
-*/
-
-
-#ifdef __cplusplus
-}
-#endif
-
-
-#endif //__NET_NFC_CLIENT_EXCHANGER_H__
diff --git a/client/include/net_nfc_client_llcp.h b/client/include/net_nfc_client_llcp.h
index cc559a7..e31e790 100644
--- a/client/include/net_nfc_client_llcp.h
+++ b/client/include/net_nfc_client_llcp.h
@@ -60,8 +60,7 @@ typedef void (*net_nfc_client_llcp_disconnect_completed)(net_nfc_error_e result,
 		net_nfc_llcp_socket_t client_socket, void *user_data);
 
 net_nfc_error_e net_nfc_client_llcp_config(net_nfc_llcp_config_info_h config,
-		net_nfc_client_llcp_config_completed callback,
-		void *user_data);
+		net_nfc_client_llcp_config_completed callback, void *user_data);
 
 net_nfc_error_e net_nfc_client_llcp_config_sync
 					(net_nfc_llcp_config_info_h config);
@@ -208,28 +207,22 @@ net_nfc_error_e net_nfc_client_llcp_get_config_wks(
 		uint16_t *wks);
 
 net_nfc_error_e net_nfc_client_llcp_get_config_lto(
-		net_nfc_llcp_config_info_h config,
-		uint8_t *lto);
+		net_nfc_llcp_config_info_h config, uint8_t *lto);
 
 net_nfc_error_e net_nfc_client_llcp_get_config_option(
-		net_nfc_llcp_config_info_h config,
-		uint8_t *option);
+		net_nfc_llcp_config_info_h config, uint8_t *option);
 
 net_nfc_error_e net_nfc_client_llcp_set_config_miu(
-		net_nfc_llcp_config_info_h config,
-		uint16_t miu);
+		net_nfc_llcp_config_info_h config, uint16_t miu);
 
 net_nfc_error_e net_nfc_client_llcp_set_config_wks(
-		net_nfc_llcp_config_info_h config,
-		uint16_t wks);
+		net_nfc_llcp_config_info_h config, uint16_t wks);
 
 net_nfc_error_e net_nfc_client_llcp_set_config_lto(
-		net_nfc_llcp_config_info_h config,
-		uint8_t lto);
+		net_nfc_llcp_config_info_h config, uint8_t lto);
 
 net_nfc_error_e net_nfc_client_llcp_set_config_option(
-		net_nfc_llcp_config_info_h config,
-		uint8_t option);
+		net_nfc_llcp_config_info_h config, uint8_t option);
 
 net_nfc_error_e net_nfc_client_llcp_free_config(
 		net_nfc_llcp_config_info_h config);
diff --git a/client/include/net_nfc_client_ndef.h b/client/include/net_nfc_client_ndef.h
index 68791e7..33d11cf 100644
--- a/client/include/net_nfc_client_ndef.h
+++ b/client/include/net_nfc_client_ndef.h
@@ -19,8 +19,7 @@
 #include "net_nfc_typedef.h"
 
 typedef void (*net_nfc_client_ndef_read_completed) (net_nfc_error_e result,
-		ndef_message_h message,
-		void *user_data);
+		ndef_message_h message, void *user_data);
 
 typedef void (*net_nfc_client_ndef_write_completed) (net_nfc_error_e result,
 		void *user_data);
@@ -40,9 +39,7 @@ net_nfc_error_e net_nfc_client_ndef_read_sync(net_nfc_target_handle_h handle,
 		ndef_message_h *message);
 
 net_nfc_error_e net_nfc_client_ndef_write(net_nfc_target_handle_h handle,
-		ndef_message_h message,
-		net_nfc_client_ndef_write_completed callback,
-		void *user_data);
+		ndef_message_h message, net_nfc_client_ndef_write_completed callback, void *user_data);
 
 net_nfc_error_e net_nfc_client_ndef_write_sync(net_nfc_target_handle_h handle,
 		ndef_message_h message);
@@ -56,12 +53,9 @@ net_nfc_error_e net_nfc_client_ndef_make_read_only_sync(
 		net_nfc_target_handle_h handle);
 
 net_nfc_error_e net_nfc_client_ndef_format(net_nfc_target_handle_h handle,
-		data_h key,
-		net_nfc_client_ndef_format_completed callback,
-		void *user_data);
+		data_h key, net_nfc_client_ndef_format_completed callback, void *user_data);
 
-net_nfc_error_e net_nfc_client_ndef_format_sync(
-		net_nfc_target_handle_h handle,
+net_nfc_error_e net_nfc_client_ndef_format_sync(net_nfc_target_handle_h handle,
 		data_h key);
 
 /* TODO : move to internal header */
diff --git a/client/include/net_nfc_client_p2p.h b/client/include/net_nfc_client_p2p.h
index 6ebdef3..93546c0 100644
--- a/client/include/net_nfc_client_p2p.h
+++ b/client/include/net_nfc_client_p2p.h
@@ -28,33 +28,25 @@ typedef void (*net_nfc_client_p2p_device_discovered)(net_nfc_target_handle_h han
 
 typedef void (*net_nfc_client_p2p_device_detached)(void *user_data);
 
-typedef void (*net_nfc_client_p2p_data_received)(
-		data_h p2p_data,
-		void *user_data);
+typedef void (*net_nfc_client_p2p_data_received)(data_h p2p_data, void *user_data);
 
 /* P2P client API's*/
-net_nfc_error_e net_nfc_client_p2p_send(net_nfc_exchanger_data_h exchg_data,
-		net_nfc_target_handle_h handle,
-		net_nfc_client_p2p_send_completed callback,
-		void *cb_data);
+net_nfc_error_e net_nfc_client_p2p_send(net_nfc_target_handle_h handle,
+		data_h data, net_nfc_client_p2p_send_completed callback, void *user_data);
 
-net_nfc_error_e net_nfc_client_p2p_send_sync(
-		net_nfc_exchanger_data_h exchg_data,
-		net_nfc_target_handle_h handle);
+net_nfc_error_e net_nfc_client_p2p_send_sync(net_nfc_target_handle_h handle,
+		data_h data);
 
 
 /* P2P client API's - used for registering callbacks*/
 void net_nfc_client_p2p_set_data_received(
-		net_nfc_client_p2p_data_received callback,
-		void *user_data);
+		net_nfc_client_p2p_data_received callback, void *user_data);
 
 void net_nfc_client_p2p_set_device_detached(
-		net_nfc_client_p2p_device_detached callback,
-		void *user_data);
+		net_nfc_client_p2p_device_detached callback, void *user_data);
 
 void net_nfc_client_p2p_set_device_discovered(
-		net_nfc_client_p2p_device_discovered callback,
-		void *user_data);
+		net_nfc_client_p2p_device_discovered callback, void *user_data);
 
 /* P2P client API's - used for unregistering callbacks*/
 void net_nfc_client_p2p_unset_data_received(void);
diff --git a/client/net_nfc_client.h b/client/net_nfc_client.h
index 70ea5e8..c80142c 100644
--- a/client/net_nfc_client.h
+++ b/client/net_nfc_client.h
@@ -18,6 +18,12 @@
 
 #include <glib.h>
 
+typedef struct _NetNfcCallback
+{
+	void *callback;
+	void *user_data;
+}
+NetNfcCallback;
 
 void net_nfc_client_gdbus_init(void);
 
diff --git a/client/net_nfc_client_exchanger.c b/client/net_nfc_client_exchanger.c
deleted file mode 100644
index ffe0655..0000000
--- a/client/net_nfc_client_exchanger.c
+++ /dev/null
@@ -1,204 +0,0 @@
-/*
- * Copyright (c) 2012, 2013 Samsung Electronics Co., Ltd.
- *
- * Licensed under the Flora License, Version 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://floralicense.org/license/
- *
- * 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 <pthread.h>
-
-#include "net_nfc_typedef_internal.h"
-#include "net_nfc_debug_internal.h"
-#include "net_nfc_util_internal.h"
-#include "net_nfc_data.h"
-#include "net_nfc_client_context.h"
-#include "net_nfc_client_p2p.h"
-#include "net_nfc_client_handover.h"
-#include "net_nfc_client_exchanger.h"
-
-static net_nfc_exchanger_cb gdbus_exch_cb = NULL;
-
-API net_nfc_error_e net_nfc_client_create_exchanger_data(
-		net_nfc_exchanger_data_h *ex_data,
-		data_h payload)
-{
-	net_nfc_exchanger_data_s* tmp_ex_data = NULL;
-
-	if (ex_data == NULL || payload == NULL)
-	{
-		return NET_NFC_NULL_PARAMETER;
-	}
-
-	_net_nfc_util_alloc_mem(
-			tmp_ex_data,
-			sizeof(net_nfc_exchanger_data_s));
-
-	if (tmp_ex_data == NULL)
-	{
-		return NET_NFC_ALLOC_FAIL;
-	}
-
-	tmp_ex_data->type = NET_NFC_EXCHANGER_RAW;
-
-	_net_nfc_util_alloc_mem(
-			tmp_ex_data->binary_data.buffer,
-			((data_s *)payload)->length);
-
-	if (tmp_ex_data->binary_data.buffer == NULL)
-	{
-		_net_nfc_util_free_mem(tmp_ex_data);
-
-		return NET_NFC_ALLOC_FAIL;
-	}
-
-	memcpy(tmp_ex_data->binary_data.buffer,
-			((data_s *)payload)->buffer,
-			((data_s *)payload)->length);
-
-	tmp_ex_data->binary_data.length = ((data_s *)payload)->length;
-
-	*ex_data = (net_nfc_exchanger_data_h)tmp_ex_data;
-
-	return NET_NFC_OK;
-}
-
-
-API net_nfc_error_e net_nfc_client_free_exchanger_data(
-		net_nfc_exchanger_data_h ex_data)
-{
-	if (ex_data == NULL)
-	{
-		return NET_NFC_NULL_PARAMETER;
-	}
-
-	if (((net_nfc_exchanger_data_s *)ex_data)->binary_data.buffer != NULL)
-	{
-		_net_nfc_util_free_mem(
-				((net_nfc_exchanger_data_s *)ex_data)->binary_data.buffer);
-	}
-
-	_net_nfc_util_free_mem(ex_data);
-
-	return NET_NFC_OK;
-}
-
-API net_nfc_exchanger_cb net_nfc_client_get_exchanger_cb()
-{
-	return gdbus_exch_cb;
-}
-
-API net_nfc_error_e net_nfc_client_unset_exchanger_cb()
-{
-
-	if (gdbus_exch_cb == NULL)
-	{
-		return NET_NFC_NOT_REGISTERED;
-	}
-
-	gdbus_exch_cb = NULL;
-
-	net_nfc_client_deinitialize();
-
-	return NET_NFC_OK;
-}
-
-API net_nfc_error_e net_nfc_client_send_exchanger_data(
-		net_nfc_exchanger_data_h ex_handle,
-		net_nfc_target_handle_h target_handle,
-		void* trans_param)
-{
-	net_nfc_error_e ret;
-	net_nfc_exchanger_data_s *ex_data = (net_nfc_exchanger_data_s *)ex_handle;
-
-	DEBUG_CLIENT_MSG("send reqeust :: exchanger data = "
-			"[%p] target_handle = [%p]", ex_handle, target_handle);
-
-	/*Sync call is used because there is no callback provided*/
-	ret = net_nfc_client_p2p_send_sync(ex_data,target_handle);
-
-	return ret;
-}
-
-API net_nfc_error_e net_nfc_client_exchanger_request_connection_handover(
-		net_nfc_target_handle_h target_handle,
-		net_nfc_conn_handover_carrier_type_e type)
-{
-	net_nfc_error_e ret = NET_NFC_UNKNOWN_ERROR;
-	net_nfc_conn_handover_carrier_type_e carrier_type;
-	data_h data = NULL;
-
-	if (target_handle == NULL)
-	{
-		return NET_NFC_NULL_PARAMETER;
-	}
-
-	ret = net_nfc_client_p2p_connection_handover_sync(target_handle,
-			type,
-			&carrier_type,
-			&data);
-
-	return ret;
-}
-
-API net_nfc_error_e net_nfc_client_exchanger_get_alternative_carrier_type(
-		net_nfc_connection_handover_info_h info_handle,
-		net_nfc_conn_handover_carrier_type_e *type)
-{
-	net_nfc_connection_handover_info_s *info = NULL;
-
-	if (info_handle == NULL || type == NULL)
-		return NET_NFC_NULL_PARAMETER;
-
-	info = (net_nfc_connection_handover_info_s *)info_handle;
-
-	*type = info->type;
-
-	return NET_NFC_OK;
-}
-
-API net_nfc_error_e net_nfc_client_exchanger_get_alternative_carrier_data(
-		net_nfc_connection_handover_info_h info_handle,
-		data_h *data)
-{
-	net_nfc_error_e result = NET_NFC_UNKNOWN_ERROR;
-	net_nfc_connection_handover_info_s *info = NULL;
-
-	if (info_handle == NULL || data == NULL)
-		return NET_NFC_NULL_PARAMETER;
-
-	info = (net_nfc_connection_handover_info_s *)info_handle;
-
-	result = net_nfc_create_data(data, info->data.buffer, info->data.length);
-
-	return result;
-}
-
-API net_nfc_error_e net_nfc_client_exchanger_free_alternative_carrier_data(
-		net_nfc_connection_handover_info_h info_handle)
-{
-	net_nfc_error_e result = NET_NFC_UNKNOWN_ERROR;
-	net_nfc_connection_handover_info_s *info = NULL;
-
-	if (info_handle == NULL)
-		return NET_NFC_NULL_PARAMETER;
-
-	info = (net_nfc_connection_handover_info_s *)info_handle;
-
-	if (info->data.buffer != NULL)
-	{
-		_net_nfc_util_free_mem(info->data.buffer);
-	}
-
-	_net_nfc_util_free_mem(info);
-
-	return result;
-}
diff --git a/client/net_nfc_client_handover.c b/client/net_nfc_client_handover.c
index 51478bd..c68a91a 100644
--- a/client/net_nfc_client_handover.c
+++ b/client/net_nfc_client_handover.c
@@ -25,13 +25,6 @@
 #include "net_nfc_client_manager.h"
 #include "net_nfc_client_handover.h"
 
-typedef struct _HandoverFuncData HandoverFuncData;
-
-struct _HandoverFuncData
-{
-	gpointer handover_callback;
-	gpointer handover_data;
-};
 
 static NetNfcGDbusHandover *handover_proxy = NULL;
 
@@ -43,56 +36,41 @@ static void p2p_connection_handover(GObject *source_object,
 		GAsyncResult *res,
 		gpointer user_data)
 {
-	HandoverFuncData *func_data;
-	GVariant *data;
-	GError *error = NULL;
+	NetNfcCallback *func_data = (NetNfcCallback *)user_data;
+	GVariant *data = NULL;
 	net_nfc_error_e result = NET_NFC_OK;
-	net_nfc_exchanger_event_e event;
-	net_nfc_conn_handover_carrier_type_e type;
+	net_nfc_conn_handover_carrier_type_e type =
+		NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN;
+	GError *error = NULL;
 	data_s arg_data;
 
-	net_nfc_p2p_connection_handover_completed_cb callback;
+	g_assert(user_data != NULL);
 
-	if(net_nfc_gdbus_handover_call_request_finish (handover_proxy,
-				(gint32 *)&event,
-				(gint32 *)&type,
+	if (net_nfc_gdbus_handover_call_request_finish(handover_proxy,
+				(gint *)&result,
+				(gint *)&type,
 				&data,
 				res,
 				&error) == FALSE)
 	{
-		result = NET_NFC_UNKNOWN_ERROR;
-
 		DEBUG_ERR_MSG("Can not finish"
 				" connection handover: %s", error->message);
 		g_error_free(error);
-		return;
-	}
 
-	func_data = user_data;
-	if(func_data == NULL)
-	{
-		DEBUG_ERR_MSG("can not get HandoverFuncData");
-		return;
+		result = NET_NFC_IPC_FAIL;
 	}
 
-	if(func_data->handover_callback == NULL)
+	if (func_data->callback != NULL)
 	{
-		DEBUG_CLIENT_MSG("callback function is not avaiilable");
-		g_free(func_data);
-		return;
-	}
-
-	net_nfc_util_gdbus_variant_to_data_s(data, &arg_data);
+		net_nfc_p2p_connection_handover_completed_cb callback =
+			(net_nfc_p2p_connection_handover_completed_cb)func_data->callback;
 
-	callback = (net_nfc_p2p_connection_handover_completed_cb)
-		func_data->handover_callback;
+		net_nfc_util_gdbus_variant_to_data_s(data, &arg_data);
 
-	callback(result,
-			type,
-			&arg_data,
-			func_data->handover_data);
+		callback(result, type, &arg_data, func_data->user_data);
 
-	net_nfc_util_free_data(&arg_data);
+		net_nfc_util_free_data(&arg_data);
+	}
 
 	g_free(func_data);
 }
@@ -101,14 +79,12 @@ static void p2p_connection_handover(GObject *source_object,
 API net_nfc_error_e net_nfc_client_handover_free_alternative_carrier_data(
 		net_nfc_connection_handover_info_h info_handle)
 {
-	net_nfc_error_e result = NET_NFC_UNKNOWN_ERROR;
-	net_nfc_connection_handover_info_s *info = NULL;
+	net_nfc_connection_handover_info_s *info =
+		(net_nfc_connection_handover_info_s *)info_handle;
 
 	if (info_handle == NULL)
 		return NET_NFC_NULL_PARAMETER;
 
-	info = (net_nfc_connection_handover_info_s *)info_handle;
-
 	if (info->data.buffer != NULL)
 	{
 		_net_nfc_util_free_mem(info->data.buffer);
@@ -116,7 +92,7 @@ API net_nfc_error_e net_nfc_client_handover_free_alternative_carrier_data(
 
 	_net_nfc_util_free_mem(info);
 
-	return result;
+	return NET_NFC_OK;
 }
 
 
@@ -124,33 +100,27 @@ API net_nfc_error_e net_nfc_client_handover_get_alternative_carrier_type(
 		net_nfc_connection_handover_info_h info_handle,
 		net_nfc_conn_handover_carrier_type_e *type)
 {
-	net_nfc_connection_handover_info_s *info = NULL;
+	net_nfc_connection_handover_info_s *info =
+		(net_nfc_connection_handover_info_s *)info_handle;
 
 	if (info_handle == NULL || type == NULL)
 		return NET_NFC_NULL_PARAMETER;
 
-	info = (net_nfc_connection_handover_info_s *)info_handle;
-
 	*type = info->type;
 
 	return NET_NFC_OK;
 }
 
 API net_nfc_error_e net_nfc_client_handover_get_alternative_carrier_data(
-		net_nfc_connection_handover_info_h info_handle,
-		data_h *data)
+		net_nfc_connection_handover_info_h info_handle, data_h *data)
 {
-	net_nfc_error_e result = NET_NFC_UNKNOWN_ERROR;
-	net_nfc_connection_handover_info_s *info = NULL;
+	net_nfc_connection_handover_info_s *info =
+		(net_nfc_connection_handover_info_s *)info_handle;
 
 	if (info_handle == NULL || data == NULL)
 		return NET_NFC_NULL_PARAMETER;
 
-	info = (net_nfc_connection_handover_info_s *)info_handle;
-
-	result = net_nfc_create_data(data, info->data.buffer, info->data.length);
-
-	return result;
+	return net_nfc_create_data(data, info->data.buffer, info->data.length);
 }
 
 
@@ -160,14 +130,13 @@ API net_nfc_error_e net_nfc_client_p2p_connection_handover(
 		net_nfc_p2p_connection_handover_completed_cb callback,
 		void *cb_data)
 {
+	NetNfcCallback *funcdata;
 
-	HandoverFuncData *funcdata = NULL;
-	net_nfc_target_handle_s *tag_handle = (net_nfc_target_handle_s *)handle;
-
-	if(handover_proxy == NULL)
+	if (handover_proxy == NULL)
 	{
 		DEBUG_ERR_MSG("Can not get handover Proxy");
-		return NET_NFC_UNKNOWN_ERROR;
+
+		return NET_NFC_NOT_INITIALIZED;
 	}
 
 	/* prevent executing daemon when nfc is off */
@@ -175,15 +144,16 @@ API net_nfc_error_e net_nfc_client_p2p_connection_handover(
 		return NET_NFC_INVALID_STATE;
 	}
 
-	funcdata = g_new0(HandoverFuncData, 1);
-	if (funcdata == NULL)
-		return NET_NFC_UNKNOWN_ERROR;
+	funcdata = g_try_new0(NetNfcCallback, 1);
+	if (funcdata == NULL) {
+		return NET_NFC_ALLOC_FAIL;
+	}
 
-	funcdata->handover_callback = (gpointer)callback;
-	funcdata->handover_data = cb_data;
+	funcdata->callback = (gpointer)callback;
+	funcdata->user_data = cb_data;
 
 	net_nfc_gdbus_handover_call_request(handover_proxy,
-			GPOINTER_TO_UINT(tag_handle),
+			GPOINTER_TO_UINT(handle),
 			arg_type,
 			net_nfc_client_gdbus_get_privilege(),
 			NULL,
@@ -200,17 +170,17 @@ API net_nfc_error_e net_nfc_client_p2p_connection_handover_sync(
 		net_nfc_conn_handover_carrier_type_e *out_carrier,
 		data_h *out_ac_data)
 {
-
-	net_nfc_target_handle_s *tag_handle = (net_nfc_target_handle_s *)handle;
+	GVariant *out_data = NULL;
+	net_nfc_error_e out_result = NET_NFC_OK;
+	net_nfc_conn_handover_carrier_type_e out_type =
+		NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN;
 	GError *error = NULL;
-	GVariant *out_data;
-	net_nfc_exchanger_event_e out_event;
-	net_nfc_conn_handover_carrier_type_e out_type;
 
-	if(handover_proxy == NULL)
+	if (handover_proxy == NULL)
 	{
 		DEBUG_ERR_MSG("Can not get handover Proxy");
-		return NET_NFC_UNKNOWN_ERROR;
+
+		return NET_NFC_NOT_INITIALIZED;
 	}
 
 	/* prevent executing daemon when nfc is off */
@@ -218,36 +188,34 @@ API net_nfc_error_e net_nfc_client_p2p_connection_handover_sync(
 		return NET_NFC_INVALID_STATE;
 	}
 
-	if(net_nfc_gdbus_handover_call_request_sync(handover_proxy,
-				GPOINTER_TO_UINT(tag_handle),
+	if (net_nfc_gdbus_handover_call_request_sync(handover_proxy,
+				GPOINTER_TO_UINT(handle),
 				arg_type,
 				net_nfc_client_gdbus_get_privilege(),
-				(gint32 *)&out_event,
+				(gint32 *)&out_result,
 				(gint32 *)&out_type,
 				&out_data,
 				NULL,
-				&error) == FALSE)
-	{
+				&error) == TRUE) {
+		if (out_carrier) {
+			*out_carrier = out_type;
+		}
+
+		if (out_ac_data) {
+			*out_ac_data = net_nfc_util_gdbus_variant_to_data(out_data);
+		}
+	} else {
 		DEBUG_ERR_MSG("handover (sync call) failed: %s",error->message);
 		g_error_free(error);
-		return NET_NFC_UNKNOWN_ERROR;
-	}
-
-	if (out_carrier)
-	{
-		*out_carrier = out_type;
-	}
 
-	if (out_ac_data)
-	{
-		*out_ac_data = net_nfc_util_gdbus_variant_to_data(out_data);
+		out_result = NET_NFC_IPC_FAIL;
 	}
 
-	return NET_NFC_OK;
+	return out_result;
 }
 
 
-API net_nfc_error_e net_nfc_client_handover_init(void)
+net_nfc_error_e net_nfc_client_handover_init(void)
 {
 	GError *error = NULL;
 
@@ -265,7 +233,7 @@ API net_nfc_error_e net_nfc_client_handover_init(void)
 			NULL,
 			&error);
 
-	if(handover_proxy == NULL)
+	if (handover_proxy == NULL)
 	{
 		DEBUG_ERR_MSG("Can not create proxy : %s", error->message);
 		g_error_free(error);
@@ -275,9 +243,10 @@ API net_nfc_error_e net_nfc_client_handover_init(void)
 	return NET_NFC_OK;
 }
 
-API void net_nfc_client_handover_deinit(void)
+
+void net_nfc_client_handover_deinit(void)
 {
-	if(handover_proxy)
+	if (handover_proxy)
 	{
 		g_object_unref(handover_proxy);
 		handover_proxy = NULL;
diff --git a/client/net_nfc_client_llcp.c b/client/net_nfc_client_llcp.c
index 3fa98d3..c0986b0 100644
--- a/client/net_nfc_client_llcp.c
+++ b/client/net_nfc_client_llcp.c
@@ -723,8 +723,8 @@ API net_nfc_error_e net_nfc_client_llcp_config(net_nfc_llcp_config_info_h config
 	return NET_NFC_OK;
 }
 
-API net_nfc_error_e net_nfc_client_llcp_config_sync
-(net_nfc_llcp_config_info_h config)
+API net_nfc_error_e net_nfc_client_llcp_config_sync(
+		net_nfc_llcp_config_info_h config)
 {
 	GVariant *variant = NULL;
 	GError *error = NULL;
@@ -754,8 +754,7 @@ API net_nfc_error_e net_nfc_client_llcp_config_sync
 				NULL,
 				&error) == FALSE)
 	{
-		DEBUG_ERR_MSG("can not config: %s",
-				error->message);
+		DEBUG_ERR_MSG("can not config: %s", error->message);
 		g_error_free(error);
 		return NET_NFC_UNKNOWN_ERROR;
 	}
@@ -763,8 +762,8 @@ API net_nfc_error_e net_nfc_client_llcp_config_sync
 	return NET_NFC_OK;
 }
 
-API net_nfc_error_e net_nfc_client_llcp_get_config
-(net_nfc_llcp_config_info_h *config)
+API net_nfc_error_e net_nfc_client_llcp_get_config(
+		net_nfc_llcp_config_info_h *config)
 {
 	if (config == NULL)
 		return NET_NFC_NULL_PARAMETER;
@@ -774,7 +773,7 @@ API net_nfc_error_e net_nfc_client_llcp_get_config
 	return NET_NFC_OK;
 }
 
-	API net_nfc_error_e net_nfc_client_llcp_listen(net_nfc_llcp_socket_t socket,
+API net_nfc_error_e net_nfc_client_llcp_listen(net_nfc_llcp_socket_t socket,
 		const char *service_name,
 		sap_t sap,
 		net_nfc_client_llcp_listen_completed callback,
@@ -832,7 +831,7 @@ API net_nfc_error_e net_nfc_client_llcp_get_config
 	return NET_NFC_OK;
 }
 
-	API net_nfc_error_e net_nfc_client_llcp_listen_sync(net_nfc_llcp_socket_t socket,
+API net_nfc_error_e net_nfc_client_llcp_listen_sync(net_nfc_llcp_socket_t socket,
 		const char *service_name,
 		sap_t sap,
 		net_nfc_llcp_socket_t *out_socket)
@@ -908,7 +907,7 @@ API net_nfc_error_e net_nfc_client_llcp_get_config
 	return NET_NFC_OK;
 }
 
-	API net_nfc_error_e net_nfc_client_llcp_connect(net_nfc_llcp_socket_t socket,
+API net_nfc_error_e net_nfc_client_llcp_connect(net_nfc_llcp_socket_t socket,
 		const char *service_name,
 		net_nfc_client_llcp_connect_completed callback,
 		void *user_data)
@@ -960,7 +959,7 @@ API net_nfc_error_e net_nfc_client_llcp_get_config
 	return NET_NFC_OK;
 }
 
-	API net_nfc_error_e net_nfc_client_llcp_connect_sync(net_nfc_llcp_socket_t socket,
+API net_nfc_error_e net_nfc_client_llcp_connect_sync(net_nfc_llcp_socket_t socket,
 		const char *service_name,
 		net_nfc_llcp_socket_t *out_socket)
 {
@@ -1030,7 +1029,7 @@ API net_nfc_error_e net_nfc_client_llcp_get_config
 	return NET_NFC_OK;
 }
 
-	API net_nfc_error_e net_nfc_client_llcp_connect_sap(net_nfc_llcp_socket_t socket,
+API net_nfc_error_e net_nfc_client_llcp_connect_sap(net_nfc_llcp_socket_t socket,
 		sap_t sap,
 		net_nfc_client_llcp_connect_sap_completed callback,
 		void *user_data)
@@ -1076,7 +1075,7 @@ API net_nfc_error_e net_nfc_client_llcp_get_config
 	return NET_NFC_OK;
 }
 
-	API net_nfc_error_e net_nfc_client_llcp_connect_sap_sync(
+API net_nfc_error_e net_nfc_client_llcp_connect_sap_sync(
 		net_nfc_llcp_socket_t socket,
 		sap_t sap,
 		net_nfc_llcp_socket_t *out_socket)
@@ -1141,7 +1140,7 @@ API net_nfc_error_e net_nfc_client_llcp_get_config
 	return NET_NFC_OK;
 }
 
-	API net_nfc_error_e net_nfc_client_llcp_send(net_nfc_llcp_socket_t socket,
+API net_nfc_error_e net_nfc_client_llcp_send(net_nfc_llcp_socket_t socket,
 		data_h data,
 		net_nfc_client_llcp_send_completed callback,
 		void *user_data)
@@ -1199,7 +1198,7 @@ API net_nfc_error_e net_nfc_client_llcp_get_config
 	return NET_NFC_OK;
 }
 
-	API net_nfc_error_e net_nfc_client_llcp_send_sync(net_nfc_llcp_socket_t socket,
+API net_nfc_error_e net_nfc_client_llcp_send_sync(net_nfc_llcp_socket_t socket,
 		data_h data,
 		net_nfc_llcp_socket_t *out_socket)
 {
@@ -1271,7 +1270,7 @@ API net_nfc_error_e net_nfc_client_llcp_get_config
 }
 
 
-	API net_nfc_error_e net_nfc_client_llcp_send_to(net_nfc_llcp_socket_t socket,
+API net_nfc_error_e net_nfc_client_llcp_send_to(net_nfc_llcp_socket_t socket,
 		sap_t sap,
 		data_h data,
 		net_nfc_client_llcp_send_to_completed callback,
@@ -1330,7 +1329,7 @@ API net_nfc_error_e net_nfc_client_llcp_get_config
 	return NET_NFC_OK;
 }
 
-	API net_nfc_error_e net_nfc_client_llcp_send_to_sync(net_nfc_llcp_socket_t socket,
+API net_nfc_error_e net_nfc_client_llcp_send_to_sync(net_nfc_llcp_socket_t socket,
 		sap_t sap,
 		data_h data,
 		net_nfc_llcp_socket_t *out_socket)
@@ -1403,7 +1402,7 @@ API net_nfc_error_e net_nfc_client_llcp_get_config
 	return NET_NFC_OK;
 }
 
-	API net_nfc_error_e net_nfc_client_llcp_receive(net_nfc_llcp_socket_t socket,
+API net_nfc_error_e net_nfc_client_llcp_receive(net_nfc_llcp_socket_t socket,
 		size_t request_length,
 		net_nfc_client_llcp_receive_completed callback,
 		void *user_data)
@@ -1446,7 +1445,7 @@ API net_nfc_error_e net_nfc_client_llcp_get_config
 	return NET_NFC_OK;
 }
 
-	API net_nfc_error_e net_nfc_client_llcp_receive_sync(net_nfc_llcp_socket_t socket,
+API net_nfc_error_e net_nfc_client_llcp_receive_sync(net_nfc_llcp_socket_t socket,
 		size_t request_length,
 		data_h *out_data)
 {
@@ -1496,7 +1495,7 @@ API net_nfc_error_e net_nfc_client_llcp_get_config
 	return NET_NFC_OK;
 }
 
-	API net_nfc_error_e net_nfc_client_llcp_receive_from(net_nfc_llcp_socket_t socket,
+API net_nfc_error_e net_nfc_client_llcp_receive_from(net_nfc_llcp_socket_t socket,
 		size_t request_length,
 		net_nfc_client_llcp_receive_from_completed callback,
 		void *user_data)
@@ -1534,11 +1533,11 @@ API net_nfc_error_e net_nfc_client_llcp_get_config
 	return NET_NFC_OK;
 }
 
-API net_nfc_error_e net_nfc_client_llcp_receive_from_sync
-(net_nfc_llcp_socket_t socket,
- size_t request_length,
- sap_t *out_sap,
- data_h *out_data)
+API net_nfc_error_e net_nfc_client_llcp_receive_from_sync(
+		net_nfc_llcp_socket_t socket,
+		size_t request_length,
+		sap_t *out_sap,
+		data_h *out_data)
 {
 	GVariant *variant = NULL;
 	GError *error = NULL;
@@ -1592,7 +1591,7 @@ API net_nfc_error_e net_nfc_client_llcp_receive_from_sync
 	return NET_NFC_OK;
 }
 
-	API net_nfc_error_e net_nfc_client_llcp_close(net_nfc_llcp_socket_t socket,
+API net_nfc_error_e net_nfc_client_llcp_close(net_nfc_llcp_socket_t socket,
 		net_nfc_client_llcp_close_completed callback,
 		void *user_data)
 {
@@ -1633,7 +1632,7 @@ API net_nfc_error_e net_nfc_client_llcp_receive_from_sync
 	return NET_NFC_OK;
 }
 
-	API net_nfc_error_e net_nfc_client_llcp_close_sync(net_nfc_llcp_socket_t socket,
+API net_nfc_error_e net_nfc_client_llcp_close_sync(net_nfc_llcp_socket_t socket,
 		net_nfc_llcp_socket_t *out_socket)
 {
 	GError *error = NULL;
@@ -1688,7 +1687,7 @@ API net_nfc_error_e net_nfc_client_llcp_receive_from_sync
 	return NET_NFC_OK;
 }
 
-	API net_nfc_error_e net_nfc_client_llcp_disconnect(net_nfc_llcp_socket_t socket,
+API net_nfc_error_e net_nfc_client_llcp_disconnect(net_nfc_llcp_socket_t socket,
 		net_nfc_client_llcp_disconnect_completed callback,
 		void *user_data)
 {
@@ -1729,7 +1728,7 @@ API net_nfc_error_e net_nfc_client_llcp_receive_from_sync
 	return NET_NFC_OK;
 }
 
-	API net_nfc_error_e net_nfc_client_llcp_disconnect_sync(
+API net_nfc_error_e net_nfc_client_llcp_disconnect_sync(
 		net_nfc_llcp_socket_t socket,
 		net_nfc_llcp_socket_t *out_socket)
 {
@@ -1817,20 +1816,18 @@ API void net_nfc_client_llcp_create_socket(net_nfc_llcp_socket_t *socket,
 }
 
 
-	API net_nfc_error_e net_nfc_client_llcp_get_local_config(
+API net_nfc_error_e net_nfc_client_llcp_get_local_config(
 		net_nfc_llcp_config_info_h *config)
 {
 	if (config == NULL)
-	{
 		return NET_NFC_NULL_PARAMETER;
-	}
 
 	*config = (net_nfc_llcp_config_info_h)&llcp_config;
 
 	return NET_NFC_OK;
 }
 
-	API net_nfc_error_e net_nfc_client_llcp_get_local_socket_option(
+API net_nfc_error_e net_nfc_client_llcp_get_local_socket_option(
 		net_nfc_llcp_socket_t socket,
 		net_nfc_llcp_socket_option_h *info)
 {
@@ -1847,7 +1844,7 @@ API void net_nfc_client_llcp_create_socket(net_nfc_llcp_socket_t *socket,
 	return NET_NFC_OK;
 }
 
-	API net_nfc_error_e net_nfc_client_llcp_create_socket_option(
+API net_nfc_error_e net_nfc_client_llcp_create_socket_option(
 		net_nfc_llcp_socket_option_h *option,
 		uint16_t miu,
 		uint8_t rw,
@@ -1885,7 +1882,7 @@ API void net_nfc_client_llcp_create_socket(net_nfc_llcp_socket_t *socket,
 	}
 }
 
-	API net_nfc_error_e net_nfc_client_llcp_create_socket_option_default(
+API net_nfc_error_e net_nfc_client_llcp_create_socket_option_default(
 		net_nfc_llcp_socket_option_h *option)
 {
 	return net_nfc_client_llcp_create_socket_option(
@@ -1895,7 +1892,7 @@ API void net_nfc_client_llcp_create_socket(net_nfc_llcp_socket_t *socket,
 			NET_NFC_LLCP_SOCKET_TYPE_CONNECTIONORIENTED);
 }
 
-	API net_nfc_error_e net_nfc_client_llcp_get_socket_option_miu(
+API net_nfc_error_e net_nfc_client_llcp_get_socket_option_miu(
 		net_nfc_llcp_socket_option_h option,
 		uint16_t *miu)
 {
@@ -1909,7 +1906,7 @@ API void net_nfc_client_llcp_create_socket(net_nfc_llcp_socket_t *socket,
 	return NET_NFC_OK;
 }
 
-	API net_nfc_error_e net_nfc_client_llcp_set_socket_option_miu(
+API net_nfc_error_e net_nfc_client_llcp_set_socket_option_miu(
 		net_nfc_llcp_socket_option_h option,
 		uint16_t miu)
 {
@@ -1923,7 +1920,7 @@ API void net_nfc_client_llcp_create_socket(net_nfc_llcp_socket_t *socket,
 	return NET_NFC_OK;
 }
 
-	API net_nfc_error_e net_nfc_client_llcp_get_socket_option_rw(
+API net_nfc_error_e net_nfc_client_llcp_get_socket_option_rw(
 		net_nfc_llcp_socket_option_h option,
 		uint8_t *rw)
 {
@@ -1937,7 +1934,7 @@ API void net_nfc_client_llcp_create_socket(net_nfc_llcp_socket_t *socket,
 	return NET_NFC_OK;
 }
 
-	API net_nfc_error_e net_nfc_client_llcp_set_socket_option_rw(
+API net_nfc_error_e net_nfc_client_llcp_set_socket_option_rw(
 		net_nfc_llcp_socket_option_h option,
 		uint8_t rw)
 {
@@ -1951,7 +1948,7 @@ API void net_nfc_client_llcp_create_socket(net_nfc_llcp_socket_t *socket,
 	return NET_NFC_OK;
 }
 
-	API net_nfc_error_e net_nfc_client_llcp_get_socket_option_type(
+API net_nfc_error_e net_nfc_client_llcp_get_socket_option_type(
 		net_nfc_llcp_socket_option_h option,
 		net_nfc_socket_type_e * type)
 {
@@ -1965,7 +1962,7 @@ API void net_nfc_client_llcp_create_socket(net_nfc_llcp_socket_t *socket,
 	return NET_NFC_OK;
 }
 
-	API net_nfc_error_e net_nfc_client_llcp_set_socket_option_type(
+API net_nfc_error_e net_nfc_client_llcp_set_socket_option_type(
 		net_nfc_llcp_socket_option_h option,
 		net_nfc_socket_type_e type)
 {
@@ -1979,7 +1976,7 @@ API void net_nfc_client_llcp_create_socket(net_nfc_llcp_socket_t *socket,
 	return NET_NFC_OK;
 }
 
-	API net_nfc_error_e net_nfc_client_llcp_free_socket_option(
+API net_nfc_error_e net_nfc_client_llcp_free_socket_option(
 		net_nfc_llcp_socket_option_h option)
 {
 	if (option == NULL)
@@ -1992,48 +1989,44 @@ API void net_nfc_client_llcp_create_socket(net_nfc_llcp_socket_t *socket,
 	return NET_NFC_OK;
 }
 
-	API net_nfc_error_e net_nfc_client_llcp_create_config(
+API net_nfc_error_e net_nfc_client_llcp_create_config(
 		net_nfc_llcp_config_info_h *config,
 		uint16_t miu,
 		uint16_t wks,
 		uint8_t lto,
 		uint8_t option)
 {
+	net_nfc_llcp_config_info_s *tmp_config;
+
 	if (config == NULL)
-	{
 		return NET_NFC_NULL_PARAMETER;
-	}
 
-	net_nfc_llcp_config_info_s **tmp_config =
-		(net_nfc_llcp_config_info_s **)config;
+	_net_nfc_util_alloc_mem(tmp_config, sizeof(net_nfc_llcp_config_info_s));
 
-	_net_nfc_util_alloc_mem(*tmp_config,
-			sizeof(net_nfc_llcp_config_info_s));
-
-	if (*tmp_config == NULL)
+	if (tmp_config == NULL)
 		return NET_NFC_ALLOC_FAIL;
 
-	(*tmp_config)->miu = miu;
-	(*tmp_config)->wks = wks;
-	(*tmp_config)->lto = lto;
-	(*tmp_config)->option = option;
+	tmp_config->miu = miu;
+	tmp_config->wks = wks;
+	tmp_config->lto = lto;
+	tmp_config->option = option;
+
+	*config = (net_nfc_llcp_config_info_h)tmp_config;
 
 	return NET_NFC_OK;
 }
 
-	API net_nfc_error_e net_nfc_client_llcp_create_config_default(net_nfc_llcp_config_info_h *config)
+API net_nfc_error_e net_nfc_client_llcp_create_config_default(
+		net_nfc_llcp_config_info_h *config)
 {
 	return net_nfc_client_llcp_create_config(config, 128, 1, 10, 0);
 }
 
-	API net_nfc_error_e net_nfc_client_llcp_get_config_miu(
-		net_nfc_llcp_config_info_h config,
-		uint16_t *miu)
+API net_nfc_error_e net_nfc_client_llcp_get_config_miu(
+		net_nfc_llcp_config_info_h config, uint16_t *miu)
 {
 	if (config == NULL || miu == NULL)
-	{
 		return NET_NFC_NULL_PARAMETER;
-	}
 
 	net_nfc_llcp_config_info_s *tmp_config =
 		(net_nfc_llcp_config_info_s *)config;
@@ -2043,14 +2036,11 @@ API void net_nfc_client_llcp_create_socket(net_nfc_llcp_socket_t *socket,
 	return NET_NFC_OK;
 }
 
-	API net_nfc_error_e net_nfc_client_llcp_get_config_wks(
-		net_nfc_llcp_config_info_h config,
-		uint16_t *wks)
+API net_nfc_error_e net_nfc_client_llcp_get_config_wks(
+		net_nfc_llcp_config_info_h config, uint16_t *wks)
 {
 	if (config == NULL || wks == NULL)
-	{
 		return NET_NFC_NULL_PARAMETER;
-	}
 
 	net_nfc_llcp_config_info_s *tmp_config =
 		(net_nfc_llcp_config_info_s *)config;
@@ -2060,14 +2050,11 @@ API void net_nfc_client_llcp_create_socket(net_nfc_llcp_socket_t *socket,
 	return NET_NFC_OK;
 }
 
-	API net_nfc_error_e net_nfc_client_llcp_get_config_lto(
-		net_nfc_llcp_config_info_h config,
-		uint8_t *lto)
+API net_nfc_error_e net_nfc_client_llcp_get_config_lto(
+		net_nfc_llcp_config_info_h config, uint8_t *lto)
 {
 	if (config == NULL || lto == NULL)
-	{
 		return NET_NFC_NULL_PARAMETER;
-	}
 
 	net_nfc_llcp_config_info_s *tmp_config =
 		(net_nfc_llcp_config_info_s *)config;
@@ -2077,14 +2064,11 @@ API void net_nfc_client_llcp_create_socket(net_nfc_llcp_socket_t *socket,
 	return NET_NFC_OK;
 }
 
-	API net_nfc_error_e net_nfc_client_llcp_get_config_option(
-		net_nfc_llcp_config_info_h config,
-		uint8_t *option)
+API net_nfc_error_e net_nfc_client_llcp_get_config_option(
+		net_nfc_llcp_config_info_h config, uint8_t *option)
 {
 	if (config == NULL || option == NULL)
-	{
 		return NET_NFC_NULL_PARAMETER;
-	}
 
 	net_nfc_llcp_config_info_s *tmp_config =
 		(net_nfc_llcp_config_info_s *)config;
@@ -2094,19 +2078,14 @@ API void net_nfc_client_llcp_create_socket(net_nfc_llcp_socket_t *socket,
 	return NET_NFC_OK;
 }
 
-	API net_nfc_error_e net_nfc_client_llcp_set_config_miu(
-		net_nfc_llcp_config_info_h config,
-		uint16_t miu)
+API net_nfc_error_e net_nfc_client_llcp_set_config_miu(
+		net_nfc_llcp_config_info_h config, uint16_t miu)
 {
 	if (config == NULL)
-	{
 		return NET_NFC_NULL_PARAMETER;
-	}
 
 	if (miu < 128 || miu > 1152)
-	{
 		return NET_NFC_OUT_OF_BOUND;
-	}
 
 	net_nfc_llcp_config_info_s * tmp_config =
 		(net_nfc_llcp_config_info_s *)config;
@@ -2116,14 +2095,11 @@ API void net_nfc_client_llcp_create_socket(net_nfc_llcp_socket_t *socket,
 	return NET_NFC_OK;
 }
 
-	API net_nfc_error_e net_nfc_client_llcp_set_config_wks(
-		net_nfc_llcp_config_info_h config,
-		uint16_t wks)
+API net_nfc_error_e net_nfc_client_llcp_set_config_wks(
+		net_nfc_llcp_config_info_h config, uint16_t wks)
 {
 	if (config == NULL)
-	{
 		return NET_NFC_NULL_PARAMETER;
-	}
 
 	net_nfc_llcp_config_info_s *tmp_config =
 		(net_nfc_llcp_config_info_s *)config;
@@ -2133,14 +2109,11 @@ API void net_nfc_client_llcp_create_socket(net_nfc_llcp_socket_t *socket,
 	return NET_NFC_OK;
 }
 
-	API net_nfc_error_e net_nfc_client_llcp_set_config_lto(
-		net_nfc_llcp_config_info_h config,
-		uint8_t lto)
+API net_nfc_error_e net_nfc_client_llcp_set_config_lto(
+		net_nfc_llcp_config_info_h config, uint8_t lto)
 {
 	if (config == NULL)
-	{
 		return NET_NFC_NULL_PARAMETER;
-	}
 
 	net_nfc_llcp_config_info_s *tmp_config =
 		(net_nfc_llcp_config_info_s *)config;
@@ -2150,14 +2123,11 @@ API void net_nfc_client_llcp_create_socket(net_nfc_llcp_socket_t *socket,
 	return NET_NFC_OK;
 }
 
-	API net_nfc_error_e net_nfc_client_llcp_set_config_option(
-		net_nfc_llcp_config_info_h config,
-		uint8_t option)
+API net_nfc_error_e net_nfc_client_llcp_set_config_option(
+		net_nfc_llcp_config_info_h config, uint8_t option)
 {
 	if (config == NULL)
-	{
 		return NET_NFC_NULL_PARAMETER;
-	}
 
 	net_nfc_llcp_config_info_s * tmp_config =
 		(net_nfc_llcp_config_info_s *)config;
@@ -2167,12 +2137,11 @@ API void net_nfc_client_llcp_create_socket(net_nfc_llcp_socket_t *socket,
 	return NET_NFC_OK;
 }
 
-	API net_nfc_error_e net_nfc_client_llcp_free_config(net_nfc_llcp_config_info_h config)
+API net_nfc_error_e net_nfc_client_llcp_free_config(
+		net_nfc_llcp_config_info_h config)
 {
 	if (config == NULL)
-	{
 		return NET_NFC_NULL_PARAMETER;
-	}
 
 	_net_nfc_util_free_mem(config);
 	return NET_NFC_OK;
@@ -2203,8 +2172,7 @@ net_nfc_error_e net_nfc_client_llcp_init(void)
 		return NET_NFC_UNKNOWN_ERROR;
 	}
 
-	g_signal_connect(llcp_proxy, "error",
-			G_CALLBACK(llcp_error), NULL);
+	g_signal_connect(llcp_proxy, "error", G_CALLBACK(llcp_error), NULL);
 
 	return NET_NFC_OK;
 }
diff --git a/client/net_nfc_client_p2p.c b/client/net_nfc_client_p2p.c
index 6943b2a..3b34d84 100644
--- a/client/net_nfc_client_p2p.c
+++ b/client/net_nfc_client_p2p.c
@@ -24,14 +24,6 @@
 #include "net_nfc_client_manager.h"
 #include "net_nfc_client_p2p.h"
 
-typedef struct _P2pFuncData P2pFuncData;
-
-struct _P2pFuncData
-{
-	gpointer p2p_send_callback;
-	gpointer p2p_send_data;
-};
-
 
 typedef struct _P2p_SignalHandler P2pSignalHandler;
 
@@ -47,7 +39,7 @@ struct _P2p_SignalHandler
 };
 
 static NetNfcGDbusP2p *p2p_proxy = NULL;
-static P2pSignalHandler *p2p_signal_handler = NULL;
+static P2pSignalHandler p2p_signal_handler;
 
 static void p2p_device_detached(GObject *source_object,
 		gpointer user_data);
@@ -72,21 +64,17 @@ static void p2p_device_detached(GObject *source_object,
 	/*llcp client function to set/unset the current target id needs to be implemented*/
 	/*net_nfc_client_llcp_current_target_id(NULL);*/
 
-	if(p2p_signal_handler == NULL)
-		return;
-
-	if(p2p_signal_handler->p2p_device_detached_cb)
+	if (p2p_signal_handler.p2p_device_detached_cb)
 	{
-		p2p_signal_handler->p2p_device_detached_cb(
-				p2p_signal_handler->p2p_device_detached_data);
+		p2p_signal_handler.p2p_device_detached_cb(
+			p2p_signal_handler.p2p_device_detached_data);
 	}
 
 	/*llcp client function to close all socket needs to be implemented*/
 	/*net_nfc_client_llcp_close_all_socket();*/
 }
 
-static void p2p_device_discovered(GObject *source_object,
-		guint arg_handle,
+static void p2p_device_discovered(GObject *source_object, guint arg_handle,
 		gpointer user_data)
 {
 	net_nfc_target_handle_s *handle_info = NULL;
@@ -95,48 +83,39 @@ static void p2p_device_discovered(GObject *source_object,
 
 	handle_info = GUINT_TO_POINTER(arg_handle);
 
-	if(p2p_signal_handler == NULL)
-		return;
-
-	if(p2p_signal_handler->p2p_device_discovered_cb)
+	if (p2p_signal_handler.p2p_device_discovered_cb)
 	{
-		p2p_signal_handler->p2p_device_discovered_cb(handle_info,
-				p2p_signal_handler->p2p_device_discovered_data);
+		p2p_signal_handler.p2p_device_discovered_cb(handle_info,
+				p2p_signal_handler.p2p_device_discovered_data);
 	}
 }
 
-static void p2p_device_data_received(GObject *source_object,
-		GVariant *arg_data,
+static void p2p_device_data_received(GObject *source_object, GVariant *arg_data,
 		gpointer user_data)
 {
 	INFO_MSG(">>> SIGNAL arrived");
 
-	if (p2p_signal_handler == NULL)
-		return;
-
-	if (p2p_signal_handler->p2p_data_received_cb)
+	if (p2p_signal_handler.p2p_data_received_cb)
 	{
-		data_s p2p_data;
+		data_s p2p_data = { NULL, };
 
 		net_nfc_util_gdbus_variant_to_data_s(arg_data, &p2p_data);
 
-		p2p_signal_handler->p2p_data_received_cb(&p2p_data,
-				p2p_signal_handler->p2p_data_received_data);
+		p2p_signal_handler.p2p_data_received_cb(&p2p_data,
+				p2p_signal_handler.p2p_data_received_data);
 
 		net_nfc_util_free_data(&p2p_data);
 	}
 }
 
-static void p2p_call_send(GObject *source_object,
-		GAsyncResult *res,
+static void p2p_call_send(GObject *source_object, GAsyncResult *res,
 		gpointer user_data)
 {
-	P2pFuncData *func_data;
-
-	net_nfc_error_e out_result = NET_NFC_OK;
+	NetNfcCallback *func_data = (NetNfcCallback *)user_data;
+	net_nfc_error_e out_result;
 	GError *error = NULL;
 
-	net_nfc_client_p2p_send_completed callback;
+	g_assert(user_data != NULL);
 
 	if (net_nfc_gdbus_p2p_call_send_finish(
 				NET_NFC_GDBUS_P2P(source_object),
@@ -150,42 +129,29 @@ static void p2p_call_send(GObject *source_object,
 		g_error_free(error);
 	}
 
-	func_data = user_data;
-	if (func_data == NULL)
+	if (func_data->callback != NULL)
 	{
-		DEBUG_ERR_MSG("can not get P2pFuncData");
-		return;
-	}
+		net_nfc_client_p2p_send_completed callback =
+			(net_nfc_client_p2p_send_completed)func_data->callback;
 
-	if (func_data->p2p_send_callback == NULL)
-	{
-		DEBUG_CLIENT_MSG("callback function is not avaiilable");
-		g_free(func_data);
-		return;
+		callback(out_result, func_data->user_data);
 	}
 
-	callback = (net_nfc_client_p2p_send_completed)
-		func_data->p2p_send_callback;
-	callback(out_result, func_data->p2p_send_data);
-
 	g_free(func_data);
 }
 
 
-API net_nfc_error_e net_nfc_client_p2p_send(net_nfc_exchanger_data_h exchg_data,
-		net_nfc_target_handle_h handle,
-		net_nfc_client_p2p_send_completed callback,
-		void *cb_data)
+API net_nfc_error_e net_nfc_client_p2p_send(net_nfc_target_handle_s *handle,
+		data_s *data, net_nfc_client_p2p_send_completed callback, void *user_data)
 {
+	GVariant *arg_data;
+	NetNfcCallback *func_data;
 
-	GVariant *arg_data = NULL;
-	P2pFuncData *func_data = NULL;
-	net_nfc_exchanger_data_s *exch_data;
-
-	if(p2p_proxy == NULL)
+	if (p2p_proxy == NULL)
 	{
 		DEBUG_ERR_MSG("Can not get P2pProxy");
-		return NET_NFC_UNKNOWN_ERROR;
+
+		return NET_NFC_NOT_INITIALIZED;
 	}
 
 	/* prevent executing daemon when nfc is off */
@@ -193,44 +159,43 @@ API net_nfc_error_e net_nfc_client_p2p_send(net_nfc_exchanger_data_h exchg_data,
 		return NET_NFC_INVALID_STATE;
 	}
 
-	func_data = g_new0(P2pFuncData, 1);
-
-	func_data->p2p_send_callback = (gpointer)callback;
-	func_data->p2p_send_data = cb_data;
+	func_data = g_try_new0(NetNfcCallback, 1);
+	if (func_data == NULL) {
+		return NET_NFC_ALLOC_FAIL;
+	}
 
-	exch_data = (net_nfc_exchanger_data_s *)exchg_data;
+	func_data->callback = (gpointer)callback;
+	func_data->user_data = user_data;
 
-	arg_data = net_nfc_util_gdbus_data_to_variant(&exch_data->binary_data);
+	arg_data = net_nfc_util_gdbus_data_to_variant(data);
 
 	net_nfc_gdbus_p2p_call_send(p2p_proxy,
-			exch_data->type,
-			arg_data,
-			GPOINTER_TO_UINT(handle),
-			net_nfc_client_gdbus_get_privilege(),
-			NULL,
-			p2p_call_send,
-			func_data);
+		0 /* FIXME */,
+		arg_data,
+		GPOINTER_TO_UINT(handle),
+		net_nfc_client_gdbus_get_privilege(),
+		NULL,
+		p2p_call_send,
+		func_data);
 
 	return NET_NFC_OK;
 }
 
 
 
-API net_nfc_error_e net_nfc_client_p2p_send_sync(
-		net_nfc_exchanger_data_h exchg_data,
-		net_nfc_target_handle_h handle)
+API net_nfc_error_e net_nfc_client_p2p_send_sync(net_nfc_target_handle_s *handle,
+	data_s *data)
 {
-	GVariant *arg_data = NULL;
+	GVariant *arg_data;
 	GError *error = NULL;
-	net_nfc_exchanger_data_s *exch_data;
 
-	net_nfc_error_e out_result = NET_NFC_OK;
+	net_nfc_error_e out_result;
 
 	if (p2p_proxy == NULL)
 	{
 		DEBUG_ERR_MSG("Can not get P2pProxy");
 
-		return NET_NFC_UNKNOWN_ERROR;
+		return NET_NFC_NOT_INITIALIZED;
 	}
 
 	/* prevent executing daemon when nfc is off */
@@ -238,24 +203,22 @@ API net_nfc_error_e net_nfc_client_p2p_send_sync(
 		return NET_NFC_INVALID_STATE;
 	}
 
-	exch_data = (net_nfc_exchanger_data_s *)exchg_data;
-
-	arg_data = net_nfc_util_gdbus_data_to_variant(&exch_data->binary_data);
+	arg_data = net_nfc_util_gdbus_data_to_variant(data);
 
 	if (net_nfc_gdbus_p2p_call_send_sync(p2p_proxy,
-				exch_data->type,
-				arg_data,
-				GPOINTER_TO_UINT(handle),
-				net_nfc_client_gdbus_get_privilege(),
-				(gint *)&out_result,
-				NULL,
-				&error) == FALSE)
+		0 /* FIXME */,
+		arg_data,
+		GPOINTER_TO_UINT(handle),
+		net_nfc_client_gdbus_get_privilege(),
+		(gint *)&out_result,
+		NULL,
+		&error) == FALSE)
 	{
 		DEBUG_ERR_MSG("p2p send (sync call) failed: %s",
 				error->message);
 
 		g_error_free(error);
-		return NET_NFC_UNKNOWN_ERROR;
+		out_result = NET_NFC_IPC_FAIL;
 	}
 
 	return out_result;
@@ -263,94 +226,47 @@ API net_nfc_error_e net_nfc_client_p2p_send_sync(
 
 
 API void net_nfc_client_p2p_set_device_discovered(
-		net_nfc_client_p2p_device_discovered callback,
-		void *user_data)
+		net_nfc_client_p2p_device_discovered callback, void *user_data)
 {
-	if(p2p_signal_handler == NULL)
-	{
-		p2p_signal_handler = g_new0(P2pSignalHandler, 1);
-	}
-
-	p2p_signal_handler->p2p_device_discovered_cb = callback;
-	p2p_signal_handler->p2p_device_discovered_data = user_data;
+	p2p_signal_handler.p2p_device_discovered_cb = callback;
+	p2p_signal_handler.p2p_device_discovered_data = user_data;
 }
 
 
 API void net_nfc_client_p2p_set_device_detached(
-		net_nfc_client_p2p_device_detached callback,
-		void *user_data)
+		net_nfc_client_p2p_device_detached callback, void *user_data)
 {
-	if(p2p_signal_handler == NULL)
-	{
-		p2p_signal_handler = g_new0(P2pSignalHandler, 1);
-	}
-
-	p2p_signal_handler->p2p_device_detached_cb = callback;
-	p2p_signal_handler->p2p_device_detached_data = user_data;
+	p2p_signal_handler.p2p_device_detached_cb = callback;
+	p2p_signal_handler.p2p_device_detached_data = user_data;
 }
 
 
 API void net_nfc_client_p2p_set_data_received(
-		net_nfc_client_p2p_data_received callback,
-		void *user_data)
+		net_nfc_client_p2p_data_received callback, void *user_data)
 {
-	if(p2p_signal_handler == NULL)
-	{
-		p2p_signal_handler = g_new0(P2pSignalHandler, 1);
-	}
-
-	p2p_signal_handler->p2p_data_received_cb = callback;
-	p2p_signal_handler->p2p_data_received_data = user_data;
+	p2p_signal_handler.p2p_data_received_cb = callback;
+	p2p_signal_handler.p2p_data_received_data = user_data;
 }
 
 
 API void net_nfc_client_p2p_unset_device_discovered(void)
 {
-	if(p2p_signal_handler == NULL)
-	{
-		DEBUG_ERR_MSG("p2p_signal_handler is not initialized");
-		return;
-	}
-
-	else
-	{
-		p2p_signal_handler->p2p_device_discovered_cb = NULL;
-		p2p_signal_handler->p2p_device_discovered_data = NULL;
-		g_free(p2p_signal_handler);
-		p2p_signal_handler = NULL;
-	}
+	p2p_signal_handler.p2p_device_discovered_cb = NULL;
+	p2p_signal_handler.p2p_device_discovered_data = NULL;
 }
 
 
 API void net_nfc_client_p2p_unset_device_detached(void)
 {
-	if(p2p_signal_handler == NULL)
-	{
-		DEBUG_ERR_MSG("p2p_signal_handler is not initialized");
-		return;
-	}
-
-	else
-	{
-		p2p_signal_handler->p2p_device_detached_cb = NULL;
-		p2p_signal_handler->p2p_device_detached_data = NULL;
-	}
+	p2p_signal_handler.p2p_device_detached_cb = NULL;
+	p2p_signal_handler.p2p_device_detached_data = NULL;
 }
 
 
 API void net_nfc_client_p2p_unset_data_received(void)
 {
-	if(p2p_signal_handler == NULL)
-	{
-		DEBUG_ERR_MSG("p2p_signal_handler is not initialized");
-		return;
-	}
-
-	else
-	{
-		p2p_signal_handler->p2p_data_received_cb = NULL;
-		p2p_signal_handler->p2p_data_received_data = NULL;
-	}
+	p2p_signal_handler.p2p_data_received_cb = NULL;
+	p2p_signal_handler.p2p_data_received_data = NULL;
 }
 
 net_nfc_error_e net_nfc_client_p2p_init(void)
@@ -393,7 +309,7 @@ net_nfc_error_e net_nfc_client_p2p_init(void)
 
 void net_nfc_client_p2p_deinit(void)
 {
-	if(p2p_proxy)
+	if (p2p_proxy)
 	{
 		g_object_unref(p2p_proxy);
 		p2p_proxy = NULL;
diff --git a/daemon/net_nfc_server_handover.c b/daemon/net_nfc_server_handover.c
index ea08f21..4f8091b 100644
--- a/daemon/net_nfc_server_handover.c
+++ b/daemon/net_nfc_server_handover.c
@@ -13,15 +13,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
-
-#include "net_nfc_server_common.h"
-#include "net_nfc_server_process_handover.h"
-#include "net_nfc_server_handover.h"
 #include "net_nfc_debug_internal.h"
-#include "net_nfc_server_controller.h"
 #include "net_nfc_util_gdbus_internal.h"
+#include "net_nfc_server_controller.h"
+#include "net_nfc_server_common.h"
 #include "net_nfc_server_context.h"
+#include "net_nfc_server_handover.h"
+#include "net_nfc_server_process_handover.h"
 
 static NetNfcGDbusHandover *handover_skeleton = NULL;
 
@@ -36,55 +34,28 @@ static gboolean handover_handle_request(NetNfcGDbusHandover *hdover,
 
 static void handover_request_thread_func(gpointer user_data)
 {
-	HandoverRequestData *handover_data;
-	net_nfc_target_handle_s *handle;
-	net_nfc_error_e error = NET_NFC_OK;
-
-	handover_data = (HandoverRequestData *)user_data;
-
-	if (handover_data == NULL)
-	{
-		DEBUG_ERR_MSG("cannot send Handover data");
-
-		return;
-	}
-
-	if (handover_data->handoverobj == NULL)
-	{
-		DEBUG_ERR_MSG("can not get Handover object");
-
-		if (handover_data->invocation)
-		{
-			g_dbus_method_invocation_return_dbus_error(
-					handover_data->invocation,
-					"org.tizen.NetNfcService.Handover.DataError",
-					"Handover invocation is NULL");
+	HandoverRequestData *handover_data = (HandoverRequestData *)user_data;
+	net_nfc_error_e result;
 
-			g_object_unref(handover_data->invocation);
-		}
+	g_assert(handover_data != NULL);
+	g_assert(handover_data->handoverobj != NULL);
+	g_assert(handover_data->invocation != NULL);
 
-		g_free(handover_data);
-
-		return;
-	}
-
-	handle = GUINT_TO_POINTER(handover_data->handle);
-
-	if ((error = net_nfc_server_handover_default_client_start(
-					handle,
-					(void *)handover_data)) != NET_NFC_OK)
+	result = net_nfc_server_handover_default_client_start(
+			GUINT_TO_POINTER(handover_data->handle),
+			(void *)handover_data);
+	if (result != NET_NFC_OK)
 	{
-		if (handover_data->invocation)
-		{
-			g_dbus_method_invocation_return_dbus_error(
-					handover_data->invocation,
-					"org.tizen.NetNfcService.Handover.SendError",
-					"handover operation unsuccessfull");
-
-			g_object_unref(handover_data->invocation);
-		}
-
+		net_nfc_gdbus_handover_complete_request(
+				handover_data->handoverobj,
+				handover_data->invocation,
+				result,
+				NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN,
+				net_nfc_util_gdbus_buffer_to_variant(NULL, 0));
+
+		g_object_unref(handover_data->invocation);
 		g_object_unref(handover_data->handoverobj);
+
 		g_free(handover_data);
 	}
 }
@@ -97,6 +68,7 @@ static gboolean handover_handle_request(NetNfcGDbusHandover *hdover,
 		gpointer user_data)
 {
 	HandoverRequestData *data;
+	gboolean result;
 
 	INFO_MSG(">>> REQUEST from [%s]",
 			g_dbus_method_invocation_get_sender(invocation));
@@ -108,10 +80,10 @@ static gboolean handover_handle_request(NetNfcGDbusHandover *hdover,
 				"rw") == false) {
 		DEBUG_ERR_MSG("permission denied, and finished request");
 
-		return TRUE;
+		return FALSE;
 	}
 
-	data = g_new0(HandoverRequestData,1);
+	data = g_try_new0(HandoverRequestData,1);
 	if(data == NULL)
 	{
 		DEBUG_ERR_MSG("Memory allocation failed");
@@ -122,25 +94,25 @@ static gboolean handover_handle_request(NetNfcGDbusHandover *hdover,
 	}
 
 	data->handoverobj = g_object_ref(hdover);
+	data->invocation = g_object_ref(invocation);
 	data->handle = arg_handle;
 	data->type = arg_type;
-	data->invocation = g_object_ref(invocation);
 
-	if (net_nfc_server_controller_async_queue_push(
-				handover_request_thread_func, data) == FALSE)
+	result = net_nfc_server_controller_async_queue_push(
+			handover_request_thread_func, data);
+	if (result == FALSE)
 	{
 		g_dbus_method_invocation_return_dbus_error(invocation,
 				"org.tizen.NetNfcService.Handover.ThreadError",
 				"can not push to controller thread");
 
-		g_object_unref(data->handoverobj);
 		g_object_unref(data->invocation);
-		g_free(data);
+		g_object_unref(data->handoverobj);
 
-		return FALSE;
+		g_free(data);
 	}
 
-	return TRUE;
+	return result;
 }
 
 gboolean net_nfc_server_handover_init(GDBusConnection *connection)
@@ -164,6 +136,7 @@ gboolean net_nfc_server_handover_init(GDBusConnection *connection)
 				&error) == FALSE)
 	{
 		g_error_free(error);
+
 		g_object_unref(handover_skeleton);
 		handover_skeleton = NULL;
 
diff --git a/daemon/net_nfc_server_process_handover.c b/daemon/net_nfc_server_process_handover.c
index 4b4fba8..dc4cc8d 100644
--- a/daemon/net_nfc_server_process_handover.c
+++ b/daemon/net_nfc_server_process_handover.c
@@ -76,9 +76,10 @@ typedef struct _net_nfc_server_handover_process_config_context_t
 
 
 
-static void _net_nfc_server_handover_send_response(void *user_param,
-		data_h ac_data,
-		net_nfc_error_e result);
+static void _net_nfc_server_handover_send_response(net_nfc_error_e result,
+		net_nfc_conn_handover_carrier_type_e carrier,
+		data_s *ac_data,
+		void *user_param);
 
 static void _net_nfc_server_handover_client_process(
 		net_nfc_handover_context_t *context);
@@ -138,37 +139,23 @@ static void _net_nfc_server_handover_server_process(
 ////////////////////////////////////////////////////////////////////////////
 
 static void _net_nfc_server_handover_send_response(
-		void *user_param,
-		data_h ac_data,
-		net_nfc_error_e result)
+		net_nfc_error_e result,
+		net_nfc_conn_handover_carrier_type_e carrier,
+		data_s *ac_data,
+		void *user_param)
 {
-	HandoverRequestData *handover_data = NULL;
-	guint32 resp_event;
-	guint32 resp_type;
-	GVariant* data = NULL;
-
-	handover_data = (HandoverRequestData*)user_param;
-
-	data = net_nfc_util_gdbus_data_to_variant(ac_data);
+	HandoverRequestData *handover_data = (HandoverRequestData *)user_param;
 
-	resp_type = NET_NFC_MESSAGE_CONNECTION_HANDOVER;
-
-	if (result == NET_NFC_OK)
-		resp_event = NET_NFC_EXCHANGER_TRANSFER_COMPLETED;
-	else
-		resp_event = NET_NFC_EXCHANGER_TRANSFER_FAILED;
-
-	if (handover_data->invocation)
-	{
-		net_nfc_gdbus_handover_complete_request(
-				handover_data->handoverobj,
-				handover_data->invocation,
-				resp_event,
-				resp_type,
-				data);
+	g_assert(handover_data != NULL);
+	g_assert(handover_data->invocation != NULL);
+	g_assert(handover_data->handoverobj != NULL);
 
-		g_object_unref(handover_data->invocation);
-	}
+	net_nfc_gdbus_handover_complete_request(
+			handover_data->handoverobj,
+			handover_data->invocation,
+			result,
+			carrier,
+			net_nfc_util_gdbus_data_to_variant(ac_data));
 
 	if (handover_data->data)
 	{
@@ -176,6 +163,7 @@ static void _net_nfc_server_handover_send_response(
 		g_free(handover_data->data);
 	}
 
+	g_object_unref(handover_data->invocation);
 	g_object_unref(handover_data->handoverobj);
 
 	g_free(handover_data);
@@ -2090,9 +2078,10 @@ static void _net_nfc_server_handover_client_process(
 
 		/* complete and invoke callback */
 		_net_nfc_server_handover_send_response(
-				context->user_param,
+				context->result,
+				context->type,
 				&context->data,
-				context->result);
+				context->user_param);
 
 		net_nfc_util_free_data(&context->data);
 		net_nfc_util_free_record(context->record);
@@ -2104,9 +2093,10 @@ static void _net_nfc_server_handover_client_process(
 		DEBUG_ERR_MSG("NET_NFC_STATE_ERROR");
 
 		_net_nfc_server_handover_send_response(
-				context->user_param,
+				context->result,
+				context->type,
 				NULL,
-				context->result);
+				context->user_param);
 		break;
 	}
 }
@@ -2161,7 +2151,11 @@ static void _net_nfc_server_handover_client_error_cb(net_nfc_error_e result,
 
 	if (false)
 	{
-		_net_nfc_server_handover_send_response(user_param, NULL, result);
+		_net_nfc_server_handover_send_response(
+				result,
+				NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN,
+				NULL,
+				user_param);
 	}
 
 	net_nfc_controller_llcp_socket_close(socket, &result);
diff --git a/tests/main.c b/tests/main.c
index 2211fb1..7196a6e 100644
--- a/tests/main.c
+++ b/tests/main.c
@@ -32,7 +32,6 @@
 #include "net_nfc_test_jewel.h"
 #include "net_nfc_test_tag_mifare.h"
 #include "net_nfc_test_tag_felica.h"
-#include "net_nfc_test_exchanger.h"
 #include "net_nfc_test_se.h"
 #include "net_nfc_test_sys_handler.h"
 
@@ -427,46 +426,6 @@ static TestData test_data[] = {
 	},
 
 	{
-		"Exchanger",
-		"HandleData",
-		net_nfc_test_handle_exchanger_data,
-		net_nfc_test_handle_exchanger_data,
-		"Create/Free exchanger data"
-	},
-
-	{
-		"Exchanger",
-		"SendData",
-		net_nfc_test_send_exchanger_data,
-		net_nfc_test_send_exchanger_data,
-		"Send Exchanger Data"
-	},
-
-	{
-		"Exchanger",
-		"ConnectionHandover",
-		net_nfc_test_exchanger_request_connection_handover,
-		net_nfc_test_exchanger_request_connection_handover,
-		"Request Connection Hnadover"
-	},
-
-	{
-		"Exchanger",
-		"GetCarrierData",
-		net_nfc_test_exchanger_get_alternative_carrier_data,
-		net_nfc_test_exchanger_get_alternative_carrier_data,
-		"Get alternative carrier data"
-	},
-
-	{
-		"Exchanger",
-		"GetCarrierType",
-		net_nfc_test_exchanger_get_alternative_carrier_type,
-		net_nfc_test_exchanger_get_alternative_carrier_type,
-		"Get Alternative carrier type"
-	},
-
-	{
 		"llcp",
 		"CreateSocket",
 		net_nfc_test_llcp_create_socket,
diff --git a/tests/net_nfc_test_exchanger.c b/tests/net_nfc_test_exchanger.c
deleted file mode 100644
index d254ae0..0000000
--- a/tests/net_nfc_test_exchanger.c
+++ /dev/null
@@ -1,156 +0,0 @@
-/*
- * Copyright (c) 2012, 2013 Samsung Electronics Co., Ltd.
- *
- * Licensed under the Flora License, Version 1.1 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://floralicense.org/license/
- *
- * 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 "net_nfc_test_p2p.h"
-#include "net_nfc_target_info.h"
-#include "net_nfc_client_exchanger.h"
-#include "net_nfc_test_exchanger.h"
-#include "net_nfc_ndef_message.h"
-#include "net_nfc_test_util.h"
-#include "net_nfc_ndef_record.h"
-#include "net_nfc_typedef_internal.h"
-
-
-
-static void run_next_callback(gpointer user_data);
-
-static net_nfc_exchanger_data_h _net_nfc_test_create_exchgr_data();
-
-
-static void run_next_callback(gpointer user_data)
-{
-	if (user_data)
-	{
-		GCallback callback;
-
-		callback = (GCallback)(user_data);
-		callback();
-	}
-}
-
-static net_nfc_exchanger_data_h _net_nfc_test_create_exchgr_data()
-{
-	net_nfc_error_e result = NET_NFC_OK;
-	ndef_message_h msg = NULL;
-	data_h rawdata = NULL;
-	ndef_record_h record = NULL;
-	net_nfc_exchanger_data_h exch_data = NULL;
-
-	net_nfc_create_ndef_message (&msg);
-	net_nfc_create_uri_type_record (&record ,"http://www.samsung.com" ,NET_NFC_SCHEMA_FULL_URI);
-	net_nfc_append_record_to_ndef_message (msg ,record);
-	net_nfc_create_rawdata_from_ndef_message(msg, &rawdata);
-
-	if((result = net_nfc_client_create_exchanger_data(&exch_data, rawdata)) != NET_NFC_OK)
-	{
-		net_nfc_free_data(rawdata);
-		g_printerr(" Exchanger data creation failed \n");
-		return NULL;
-	}
-	net_nfc_free_data(rawdata);
-	return exch_data;
-}
-
-void net_nfc_test_handle_exchanger_data(gpointer data, gpointer user_data)
-{
-	net_nfc_error_e result = NET_NFC_OK;
-	ndef_message_h msg = NULL;
-	data_h rawdata = NULL;
-	ndef_record_h record = NULL;
-	net_nfc_exchanger_data_h exch_data = NULL;
-
-	net_nfc_create_ndef_message (&msg);
-	net_nfc_create_uri_type_record (&record ,"http://www.samsung.com" ,NET_NFC_SCHEMA_FULL_URI);
-	net_nfc_append_record_to_ndef_message (msg ,record);
-	net_nfc_create_rawdata_from_ndef_message(msg, &rawdata);
-
-	if((result = net_nfc_client_create_exchanger_data(&exch_data, rawdata)) != NET_NFC_OK)
-	{
-		net_nfc_free_data(rawdata);
-		g_printerr(" Exchanger data creation failed : %d\n", result);
-		return;
-	}
-	if((result = net_nfc_client_free_exchanger_data(exch_data)) != NET_NFC_OK)
-	{
-		g_printerr(" Exchanger data free failed : %d\n", result);
-		return;
-	}
-
-	net_nfc_free_data(rawdata);
-
-	g_print("Exchanger data created and freed successfully\n");
-	return;
-}
-
-void net_nfc_test_send_exchanger_data(gpointer data, gpointer user_data)
-{
-	net_nfc_error_e result = NET_NFC_OK;
-	net_nfc_target_handle_h handle = NULL;
-	net_nfc_exchanger_data_h exch_data = NULL;
-
-	exch_data = _net_nfc_test_create_exchgr_data();
-	handle = net_nfc_test_device_get_target_handle();
-
-	result = net_nfc_client_send_exchanger_data(exch_data,
-			handle,
-			user_data);
-	g_print("Send exchanger result : %d\n", result);
-	run_next_callback(user_data);
-}
-
-void net_nfc_test_exchanger_request_connection_handover(gpointer data, gpointer user_data)
-{
-	net_nfc_error_e result = NET_NFC_OK;
-	net_nfc_conn_handover_carrier_type_e type = NET_NFC_CONN_HANDOVER_CARRIER_BT;
-	net_nfc_target_handle_h handle = NULL;
-
-	handle = net_nfc_test_device_get_target_handle();
-	result = net_nfc_client_exchanger_request_connection_handover(handle, type);
-
-	g_print(" Exchanger request connection handover : %d\n", result);
-	run_next_callback(user_data);
-}
-
-void net_nfc_test_exchanger_get_alternative_carrier_type(gpointer data, gpointer user_data)
-{
-	net_nfc_error_e result = NET_NFC_OK;
-	/*Handover info needs to check-.As of now passing NULL*/
-	net_nfc_connection_handover_info_s info;
-	info.type = NET_NFC_CONN_HANDOVER_CARRIER_WIFI_BSS;
-
-	net_nfc_conn_handover_carrier_type_e type = NET_NFC_CONN_HANDOVER_CARRIER_UNKNOWN;
-
-	result = net_nfc_client_exchanger_get_alternative_carrier_type(&info, &type);
-	g_print(" Exchanger alternative carrier type and result : %d \n %d",type, result);
-}
-
-void net_nfc_test_exchanger_get_alternative_carrier_data(gpointer data,
-		gpointer user_data)
-{
-	net_nfc_error_e result = NET_NFC_OK;
-	/*Handover info needs to check-.As of now passing NULL*/
-	net_nfc_connection_handover_info_s info;
-	uint8_t *carrier_data = "Wifi";
-	data_h data_info = NULL;
-
-	data_info = calloc(1,sizeof(data_h));
-	result = net_nfc_set_data(data,carrier_data,4);
-
-	result = net_nfc_client_exchanger_get_alternative_carrier_data(&info, &data_info);
-	g_print(" Exchanger alternative carrier  result : %d \n",result);
-	print_received_data(data_info);
-}
-
diff --git a/tests/net_nfc_test_exchanger.h b/tests/net_nfc_test_exchanger.h
deleted file mode 100644
index 6c91835..0000000
--- a/tests/net_nfc_test_exchanger.h
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
-* Copyright (c) 2012, 2013 Samsung Electronics Co., Ltd.
-*
-* Licensed under the Flora License, Version 1.1 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*     http://floralicense.org/license/
-*
-* 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 __NET_NFC_TEST_EXCHANGER_H__
-#define __NET_NFC_TEST_EXCHANGER_H__
-
-
-#include <glib.h>
-#include "net_nfc_typedef.h"
-
-
-void net_nfc_test_handle_exchanger_data(gpointer data,
-				gpointer user_data);
-
-void net_nfc_test_send_exchanger_data(gpointer data,
-				gpointer user_data);
-
-void net_nfc_test_exchanger_request_connection_handover(gpointer data,
-				gpointer user_data);
-
-void net_nfc_test_exchanger_get_alternative_carrier_type(gpointer data,
-				gpointer user_data);
-
-void net_nfc_test_exchanger_get_alternative_carrier_data(gpointer data,
-				gpointer user_data);
-
-#endif //__NET_NFC_TEST_EXCHANGER_H__
diff --git a/tests/net_nfc_test_p2p.c b/tests/net_nfc_test_p2p.c
index 54b686a..748906c 100644
--- a/tests/net_nfc_test_p2p.c
+++ b/tests/net_nfc_test_p2p.c
@@ -15,7 +15,6 @@
  */
 
 #include "net_nfc_client_p2p.h"
-#include "net_nfc_client_exchanger.h"
 #include "net_nfc_test_p2p.h"
 #include "net_nfc_test_util.h"
 #include "net_nfc_target_info.h"
@@ -27,18 +26,12 @@
 
 
 static net_nfc_target_handle_h global_handle = NULL;
-
 static void run_next_callback(gpointer user_data);
-
-static void p2p_send(net_nfc_error_e result,
-		void *user_data);
-
+static void p2p_send(net_nfc_error_e result, void *user_data);
 static void p2p_device_discovered(net_nfc_target_handle_h handle,
 		void *user_data);
 
-
 static void p2p_device_detached(void * user_data);
-
 static void p2p_device_data_received(data_h p2p_data, void *user_data);
 
 static void run_next_callback(gpointer user_data)
@@ -48,21 +41,18 @@ static void run_next_callback(gpointer user_data)
 		GCallback callback;
 
 		callback = (GCallback)(user_data);
-
 		callback();
 	}
 }
 
-static void p2p_send(net_nfc_error_e result,
-		void *user_data)
+static void p2p_send(net_nfc_error_e result, void *user_data)
 {
 	g_print("P2P send  Completed %d\n", result);
 
 	run_next_callback(user_data);
 }
 
-static void p2p_device_discovered(net_nfc_target_handle_h handle,
-		void *user_data)
+static void p2p_device_discovered(net_nfc_target_handle_h handle, void *user_data)
 {
 	g_print("Target is Discovered\n");
 	global_handle = handle;
@@ -87,14 +77,11 @@ static void p2p_device_data_received(data_h p2p_data, void *user_data)
 	run_next_callback(user_data);
 }
 
-void net_nfc_test_p2p_send(gpointer data,
-		gpointer user_data)
+void net_nfc_test_p2p_send(gpointer data, gpointer user_data)
 {
-
 	net_nfc_error_e result = NET_NFC_OK;
 	ndef_message_h msg = NULL;
 	ndef_record_h record = NULL;
-	net_nfc_exchanger_data_h exch_data = NULL;
 	data_h rawdata = NULL;
 
 	net_nfc_create_ndef_message (&msg);
@@ -102,46 +89,40 @@ void net_nfc_test_p2p_send(gpointer data,
 	net_nfc_append_record_to_ndef_message (msg ,record);
 	net_nfc_create_rawdata_from_ndef_message(msg, &rawdata);
 
-	if((result = net_nfc_client_create_exchanger_data(&exch_data,  rawdata)) != NET_NFC_OK)
-	{
-		net_nfc_free_data(rawdata);
-
-		g_printerr("create exchanger data is failed\n");
-		return;
-	}
-	net_nfc_free_data(rawdata);
 	g_print("Handle is %#x\n", GPOINTER_TO_UINT(global_handle));
 
-	net_nfc_client_p2p_send(
-			exch_data,
-			global_handle,
-			p2p_send,
-			user_data);
+	result = net_nfc_client_p2p_send(global_handle,
+				rawdata,
+				p2p_send,
+				user_data);
+
+	g_print("net_nfc_client_p2p_send() Return(%d)\n", result);
+
+	net_nfc_free_data(rawdata);
 }
 
-void net_nfc_test_p2p_send_sync(gpointer data,
-		gpointer user_data)
+void net_nfc_test_p2p_send_sync(gpointer data, gpointer user_data)
 {
 	net_nfc_error_e result = NET_NFC_OK;
 	ndef_message_h msg = NULL;
 	ndef_record_h record = NULL;
-	net_nfc_exchanger_data_h exch_data = NULL;
 	data_h rawdata = NULL;
 
 	net_nfc_create_ndef_message (&msg);
 	net_nfc_create_uri_type_record (&record ,"http://www.samsung.com", NET_NFC_SCHEMA_FULL_URI);
 	net_nfc_append_record_to_ndef_message (msg, record);
 	net_nfc_create_rawdata_from_ndef_message(msg, &rawdata);
-	net_nfc_client_create_exchanger_data(&exch_data, rawdata);
 
-	result = net_nfc_client_p2p_send_sync(exch_data, global_handle);
+	result = net_nfc_client_p2p_send_sync(global_handle, rawdata);
 
 	g_print(" P2P send sync result: %d\n", result);
+
+	net_nfc_free_data(rawdata);
+
 	run_next_callback(user_data);
 }
 
-void net_nfc_test_p2p_set_device_discovered(gpointer data,
-		gpointer user_data)
+void net_nfc_test_p2p_set_device_discovered(gpointer data, gpointer user_data)
 {
 	g_print("Waiting for Device Discovered Singal\n");
 
@@ -150,18 +131,14 @@ void net_nfc_test_p2p_set_device_discovered(gpointer data,
 	g_print("Device Discovered set\n");
 }
 
-void net_nfc_test_p2p_set_device_detached(gpointer data,
-		gpointer user_data)
+void net_nfc_test_p2p_set_device_detached(gpointer data, gpointer user_data)
 {
-	net_nfc_client_p2p_set_device_detached(p2p_device_detached,
-			user_data);
+	net_nfc_client_p2p_set_device_detached(p2p_device_detached, user_data);
 }
 
-void net_nfc_test_p2p_set_data_received(gpointer data,
-		gpointer user_data)
+void net_nfc_test_p2p_set_data_received(gpointer data, gpointer user_data)
 {
-	net_nfc_client_p2p_set_data_received(p2p_device_data_received,
-			user_data);
+	net_nfc_client_p2p_set_data_received(p2p_device_data_received, user_data);
 }
 
 net_nfc_target_handle_h net_nfc_test_device_get_target_handle(void)