Tizen 2.0 release

20 files changed, 4812 insertions, 2110 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 0cfe898..f990f84 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -9,7 +9,7 @@ SET(PREFIX ${CMAKE_INSTALL_PREFIX})
 SET(INC_DIR include)
 INCLUDE_DIRECTORIES(${INC_DIR})
 
-SET(dependents "dlog glib-2.0 capi-base-common bluetooth-api")
+SET(dependents "dlog glib-2.0 capi-base-common bluetooth-api bluetooth-media-control")
 SET(pc_dependents "capi-base-common")
 
 INCLUDE(FindPkgConfig)
@@ -30,7 +30,20 @@ ADD_DEFINITIONS("-DTIZEN_DEBUG")
 
 SET(CMAKE_EXE_LINKER_FLAGS "-Wl,--as-needed -Wl,--rpath=/usr/lib")
 
-aux_source_directory(src SOURCES)
+SET(SOURCES
+src/bluetooth-common.c
+src/bluetooth-adapter.c
+src/bluetooth-device.c
+src/bluetooth-socket.c
+src/bluetooth-opp-server.c
+src/bluetooth-opp-client.c
+src/bluetooth-pan.c
+src/bluetooth-hdp.c
+src/bluetooth-hid.c
+src/bluetooth-audio.c
+src/bluetooth-avrcp.c
+)
+
 ADD_LIBRARY(${fw_name} SHARED ${SOURCES})
 
 TARGET_LINK_LIBRARIES(${fw_name} ${${fw_name}_LDFLAGS})
@@ -61,8 +74,6 @@ CONFIGURE_FILE(
 )
 INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/${fw_name}.pc DESTINATION lib/pkgconfig)
 
-ADD_SUBDIRECTORY(test)
-
 IF(UNIX)
 
 ADD_CUSTOM_TARGET (distclean @echo cleaning for source distribution)
diff --git a/debian/changelog b/debian/changelog
index 277f508..ec84732 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,7 +1,87 @@
+capi-network-bluetooth (0.1.12-1) unstable; urgency=low
+
+  * Tagging and upload the package
+  * Git: slp/api/bluetooth
+  * Tag: capi-network-bluetooth_0.1.12-1
+
+ -- DoHyun Pyun <dh79.pyun@samsung.com> Thu, 16 Aug 2012 16:56:23 +0900
+
+capi-network-bluetooth (0.1.11-1) unstable; urgency=low
+
+  * Tagging and upload the package
+  * Git: slp/api/bluetooth
+  * Tag: capi-network-bluetooth_0.1.11-1
+
+ -- DoHyun Pyun <dh79.pyun@samsung.com>  Wed, 08 Aug 2012 19:26:30 +0900
+
+capi-network-bluetooth (0.1.10-1) unstable; urgency=low
+
+  * Tagging and upload the package
+  * Git: slp/api/bluetooth
+  * Tag: capi-network-bluetooth_0.1.10-1
+
+ -- DoHyun Pyun <dh79.pyun@samsung.com>  Wed, 08 Aug 2012 17:08:38 +0900
+
+capi-network-bluetooth (0.1.9-1) unstable; urgency=low
+
+  * Modify the HID APIs
+  * Git: slp/api/bluetooth
+  * Tag: capi-network-bluetooth_0.1.9-1
+
+ -- DoHyun Pyun <dh79.pyun@samsung.com>  Tue, 07 Aug 2012 17:39:52 +0900
+
+capi-network-bluetooth (0.1.8-1) unstable; urgency=low
+
+  * Implement bt_socket_set_connection_requested_cb APIs
+  * Git: slp/api/bluetooth
+  * Tag: capi-network-bluetooth_0.1.8-1
+
+ -- DoHyun Pyun <dh79.pyun@samsung.com>  Mon, 06 Aug 2012 18:08:24 +0900
+
+capi-network-bluetooth (0.1.7-1) unstable; urgency=low
+
+  * Implement bt_get_device_info API
+  * Git: slp/api/bluetooth
+  * Tag: capi-network-bluetooth_0.1.7-1
+
+ -- DoHyun Pyun <dh79.pyun@samsung.com>  Wed, 01 Aug 2012 14:03:45 +0900
+
+capi-network-bluetooth (0.1.6-1) unstable; urgency=low
+
+  * Modify the RFCOMM implement
+  * Git: slp/api/bluetooth
+  * Tag: capi-network-bluetooth_0.1.6-1
+
+ -- DoHyun Pyun <dh79.pyun@samsung.com>  Wed, 25 Jul 2012 11:02:31 +0900
+
+capi-network-bluetooth (0.1.5-1) unstable; urgency=low
+
+  * Add bt_get_device_info API
+  * Git: slp/api/bluetooth
+  * Tag: capi-network-bluetooth_0.1.5-1
+
+ -- DoHyun Pyun <dh79.pyun@samsung.com>  Tue, 17 Jul 2012 13:51:51 +0900
+
+capi-network-bluetooth (0.1.4-1) unstable; urgency=low
+
+  * Add HDP API / Fix inapposite data type (rssi)
+  * Git: slp/api/bluetooth
+  * Tag: capi-network-bluetooth_0.1.4-1
+
+ -- Sangki Park <sangki79.park@samsung.com>  Fri, 29 Jun 2012 17:10:28 +0900
+
+capi-network-bluetooth (0.1.3-1) unstable; urgency=low
+
+  * Implement the requirements from OSP
+  * Git: slp/api/bluetooth
+  * Tag: capi-network-bluetooth_0.1.3-1
+
+ -- DoHyun Pyun <dh79.pyun@samsung.com>  Wed, 13 Jun 2012 09:14:03 +0900
+
 capi-network-bluetooth (0.1.2-1) unstable; urgency=low
 
   * Fix the DTS testcase
-  * Git: api/bluetooth
+  * Git: slp/api/bluetooth
   * Tag: capi-network-bluetooth_0.1.2-1
 
  -- DoHyun Pyun <dh79.pyun@samsung.com>  Thu, 12 Apr 2012 15:48:47 +0900
@@ -9,7 +89,7 @@ capi-network-bluetooth (0.1.2-1) unstable; urgency=low
 capi-network-bluetooth (0.1.1-1) unstable; urgency=low
 
   * Fix the crash in DTS test
-  * Git: api/bluetooth
+  * Git: slp/api/bluetooth
   * Tag: capi-network-bluetooth_0.1.1-1
 
  -- DoHyun Pyun <dh79.pyun@samsung.com>  Thu, 29 Mar 2012 14:45:08 +0900
@@ -17,7 +97,7 @@ capi-network-bluetooth (0.1.1-1) unstable; urgency=low
 capi-network-bluetooth (0.1.0-14) unstable; urgency=low
 
   * Initialize the pointer to NULL after free
-  * Git: api/bluetooth
+  * Git: slp/api/bluetooth
   * Tag: capi-network-bluetooth_0.1.0-14
 
  -- DoHyun Pyun <dh79.pyun@samsung.com>  Wed, 21 Mar 2012 17:15:59 +0900
@@ -25,15 +105,15 @@ capi-network-bluetooth (0.1.0-14) unstable; urgency=low
 capi-network-bluetooth (0.1.0-13) unstable; urgency=low
 
   * Correct dependent package
-  * Git: api/bluetooth
+  * Git: slp/api/bluetooth
   * Tag: capi-network-bluetooth_0.1.0-13
 
  -- ByungWoo Lee <bw1212.lee@samsung.com>  Thu, 15 Mar 2012 13:13:36 +0900
 
 capi-network-bluetooth (0.1.0-12) unstable; urgency=low
 
-  * Convert internal symbol to static
-  * Git: api/bluetooth
+  * Modify coding style
+  * Git: slp/api/bluetooth
   * Tag: capi-network-bluetooth_0.1.0-12
 
  -- ByungWoo Lee <bw1212.lee@samsung.com>  Mon, 20 Feb 2012 15:50:45 +0900
@@ -41,31 +121,160 @@ capi-network-bluetooth (0.1.0-12) unstable; urgency=low
 capi-network-bluetooth (0.1.0-11) unstable; urgency=low
 
   * Add versioning of library
-  * Git: api/bluetooth
+  * Git: slp/api/bluetooth
   * Tag: capi-network-bluetooth_0.1.0-11
 
  -- ByungWoo Lee <bw1212.lee@samsung.com>  Tue, 14 Feb 2012 17:09:56 +0900
 
 capi-network-bluetooth (0.1.0-10) unstable; urgency=low
 
-  * Correct typos
-  * Git: api/bluetooth
+  * Clean codes
+  * Git: slp/api/bluetooth
   * Tag: capi-network-bluetooth_0.1.0-10
 
- -- ByungWoo Lee <bw1212.lee@samsung.com>  Fri, 03 Feb 2012 09:43:46 +0900
+ -- ByungWoo Lee <bw1212.lee@samsung.com>  Thu, 02 Feb 2012 14:49:58 +0900
 
 capi-network-bluetooth (0.1.0-9) unstable; urgency=low
 
-  * Update version
-  * Git: api/bluetooth
+  * Add LICENSE, remove COPYING and Convert TIZEN_ERROR_OK to TIZEN_ERROR_NONE
+  * Git: slp/api/bluetooth
   * Tag: capi-network-bluetooth_0.1.0-9
 
- -- ByungWoo Lee <bw1212.lee@samsung.com>  Thu, 15 Dec 2011 13:09:32 +0900
+ -- ByungWoo Lee <bw1212.lee@samsung.com>  Mon, 05 Dec 2011 13:04:56 +0900
+
+capi-network-bluetooth (0.1.0-8) unstable; urgency=low
+
+  * Fix bug in destroying a bond
+  * Git: slp-source.sec.samsung.net:slp/api/bluetooth
+  * Tag: capi-network-bluetooth_0.1.0-8
+
+ -- ByungWoo Lee <bw1212.lee@samsung.com>  Wed, 30 Nov 2011 21:07:06 +0900
+
+capi-network-bluetooth (0.1.0-7) unstable; urgency=low
+
+  * Add service_uuid to bt_device_info_s and bt_device_sdp_info_s instead of service_list and modify log
+  * Git: slp-source.sec.samsung.net:slp/api/bluetooth
+  * Tag: capi-network-bluetooth_0.1.0-7
+
+ -- ByungWoo Lee <bw1212.lee@samsung.com>  Wed, 30 Nov 2011 19:49:10 +0900
+
+capi-network-bluetooth (0.1.0-6) unstable; urgency=low
+
+  * Convert SLP into TIZEN
+  * Git: slp-source.sec.samsung.net:slp/api/bluetooth
+  * Tag: capi-network-bluetooth_0.1.0-6
+
+ -- ByungWoo Lee <bw1212.lee@samsung.com>  Wed, 23 Nov 2011 13:09:26 +0900
+
+capi-network-bluetooth (0.1.0-5) unstable; urgency=low
+
+  * Change bt_device_cancel_bonding() and bt_adapter_set_visibility() into synchronous function, and Add BT_ERROR_SERVICE_SEARCH_ERROR to bt_error_e.
+  * Git: slp-source.sec.samsung.net:slp/api/bluetooth
+  * Tag: capi-network-bluetooth_0.1.0-5
+
+ -- ByungWoo Lee <bw1212.lee@samsung.com>  Wed, 02 Nov 2011 18:58:16 +0900
+
+capi-network-bluetooth (0.1.0-4) unstable; urgency=low
+
+  * Modify bt_error_e and change bt_device_cancel_service_search() and bt_device_cancel_bonding() into synchronous function
+  * Git: slp-source.sec.samsung.net:slp/api/bluetooth
+  * Tag: capi-network-bluetooth_0.1.0-4
+
+ -- ByungWoo Lee <bw1212.lee@samsung.com>  Thu, 27 Oct 2011 16:59:18 +0900
+
+capi-network-bluetooth (0.1.0-3) unstable; urgency=low
+
+  * Change bt_adapter_set_name into synchronous function
+  * Git: slp-source.sec.samsung.net:slp/api/bluetooth
+  * Tag: capi-network-bluetooth_0.1.0-3
+
+ -- ByungWoo Lee <bw1212.lee@samsung.com>  Mon, 17 Oct 2011 18:34:03 +0900
+
+capi-network-bluetooth (0.1.0-2) unstable; urgency=low
+
+  * Correct bug which happens when set local name and modify bt_error_e
+  * Git: slp-source.sec.samsung.net:slp/api/bluetooth
+  * Tag: capi-network-bluetooth_0.1.0-2
+
+ -- ByungWoo Lee <bw1212.lee@samsung.com>  Mon, 10 Oct 2011 18:37:32 +0900
+
+capi-network-bluetooth (0.1.0-1) unstable; urgency=low
+
+  * Modify error code of bt_initialize() and bt_deinitialize()
+  * Git: slp-source.sec.samsung.net:slp/api/bluetooth
+  * Tag: capi-network-bluetooth_0.1.0-1
+
+ -- ByungWoo Lee <bw1212.lee@samsung.com>  Tue, 27 Sep 2011 22:17:33 +0900
+
+capi-network-bluetooth (0.0.1-9) unstable; urgency=low
+
+  * Remove undefined enum type
+  * Git: slp-source.sec.samsung.net:slp/api/bluetooth
+  * Tag: capi-network-bluetooth_0.0.1-9
+
+ -- Kangho Hur <kangho.hur@samsung.com>  Mon, 26 Sep 2011 21:31:34 +0900
+
+capi-network-bluetooth (0.0.1-8) unstable; urgency=low
+
+  * Change device_address to remote_address
+  * Git: slp-source.sec.samsung.net:slp/api/bluetooth
+  * Tag: capi-network-bluetooth_0.0.1-8 
+
+ -- ByungWoo Lee <bw1212.lee@samsung.com>  Fri, 23 Sep 2011 20:02:07 +0900
+
+capi-network-bluetooth (0.0.1-7) unstable; urgency=low
+
+  * Remove BT_MAJOR_SERVICE_CLASS_UNKNOWN
+  * Git: slp-source.sec.samsung.net:slp/api/bluetooth
+  * Tag: capi-network-bluetooth_0.0.1-7
+
+ -- ByungWoo Lee <bw1212.lee@samsung.com>  Tue, 20 Sep 2011 17:17:01 +0900
+
+capi-network-bluetooth (0.0.1-6) unstable; urgency=low
+
+  * Rename class to bt_class
+  * Git: slp-source.sec.samsung.net:slp/api/bluetooth
+  * Tag: capi-network-bluetooth_0.0.1-6
+
+ -- ByungWoo Lee <bw1212.lee@samsung.com>  Thu, 08 Sep 2011 10:54:58 +0900
+
+capi-network-bluetooth (0.0.1-5) unstable; urgency=low
+
+   * Remove parameters of bt_adapter_start_device_discovery()
+   * Git: slp-source.sec.samsung.net:slp/api/bluetooth
+   * Tag: capi-network-bluetooth_0.0.1-5
+
+ -- ByungWoo Lee <bw1212.lee@samsung.com>  Mon, 05 Sep 2011 20:22:36 +0900
+
+capi-network-bluetooth (0.0.1-4) unstable; urgency=low
+
+   * Add bt_adapter_device_discovery_info_s
+   * Git: slp-source.sec.samsung.net:slp/api/bluetooth
+   * Tag: capi-network-bluetooth_0.0.1-4
+
+ -- ByungWoo Lee <bw1212.lee@samsung.com>  Mon, 22 Aug 2011 15:41:37 +0900
+
+capi-network-bluetooth (0.0.1-3) unstable; urgency=low
+
+   * Fix build break
+   * Git: slp-source.sec.samsung.net:slp/api/bluetooth
+   * Tag: capi-network-bluetooth_0.0.1-3
+
+ -- Kangho Hur <kangho.hur@samsung.com>  Sat, 13 Aug 2011 01:07:56 +0900
+
+capi-network-bluetooth (0.0.1-2) unstable; urgency=low
+
+   * Modify how to copy service list
+   * Git: slp-source.sec.samsung.net:slp/api/bluetooth
+   * Tag: capi-network-bluetooth_0.0.1-2
+
+ -- ByungWoo Lee <bw1212.lee@samsung.com>  Thu, 11 Aug 2011 19:45:20 +0900
 
 capi-network-bluetooth (0.0.1-1) unstable; urgency=low
 
-  * Initial release.
-  * Git: api/bluetooth
-  * Tag: capi-network-bluetooth_0.0.1-1
+   * Initial upload
+   * Git: slp-source.sec.samsung.net:slp/api/bluetooth
+   * Tag: capi-network-bluetooth_0.0.1-1
+
+ -- ByungWoo Lee <bw1212.lee@samsung.com>  Mon, 08 Aug 2011 10:12:25 +0900
 
- -- ByungWoo Lee <bw1212.lee@samsung.com>  Wed, 07 Dec 2011 12:48:41 +0900
diff --git a/include/bluetooth.h b/include/bluetooth.h
index 60d828e..3a419b9 100644
--- a/include/bluetooth.h
+++ b/include/bluetooth.h
@@ -74,6 +74,7 @@ typedef enum
 	BT_ERROR_AUTH_FAILED = TIZEN_ERROR_NETWORK_CLASS|0x0108, /**< Authentication failed */
 	BT_ERROR_REMOTE_DEVICE_NOT_FOUND = TIZEN_ERROR_NETWORK_CLASS|0x0109, /**< Remote device not found */
 	BT_ERROR_SERVICE_SEARCH_FAILED = TIZEN_ERROR_NETWORK_CLASS|0x010A, /**< Service search failed */
+	BT_ERROR_REMOTE_DEVICE_NOT_CONNECTED = TIZEN_ERROR_NETWORK_CLASS|0x010B, /**< Remote device is not connected */
 } bt_error_e;
 
 /**
@@ -94,7 +95,7 @@ typedef enum
 {
 	BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE = 0x00,  /**< Other devices cannot find your device via discovery */
 	BT_ADAPTER_VISIBILITY_MODE_GENERAL_DISCOVERABLE,  /**< Discoverable mode */
-	BT_ADAPTER_VISIBILITY_MODE_LIMITED_DISCOVERABLE,  /**< Discoverable mode with time limit. After specific period, 
+	BT_ADAPTER_VISIBILITY_MODE_LIMITED_DISCOVERABLE,  /**< Discoverable mode with time limit. After specific period,
 							    it is changed to #BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE.*/
 } bt_adapter_visibility_mode_e;
 
@@ -126,8 +127,8 @@ typedef enum
  */
 typedef enum
 {
-	BT_SOCKET_CONNECTED, /**< Socket is connected */
-	BT_SOCKET_DISCONNECTED, /**< Socket is disconnected */
+	BT_SOCKET_CONNECTED, /**< RFCOMM is connected */
+	BT_SOCKET_DISCONNECTED, /**< RFCOMM is disconnected */
 } bt_socket_connection_state_e;
 
 /**
@@ -262,8 +263,83 @@ typedef enum
 } bt_minor_device_class_e;
 
 /**
- * @}
+ * @ingroup CAPI_NETWORK_BLUETOOTH_PAN_PANU_MODULE
+ * @brief  Enumerations for the types of PAN(Personal Area Networking) service
+ */
+typedef enum {
+    BT_PANU_SERVICE_TYPE_NAP = 0,  /**< Network Access Point */
+} bt_panu_service_type_e;
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_MODULE
+ * @brief  Enumerations for the types of profiles related with audio
+ */
+typedef enum {
+    BT_AUDIO_PROFILE_TYPE_ALL = 0,  /**< All supported profiles related with audio */
+    BT_AUDIO_PROFILE_TYPE_HSP_HFP,  /**< HSP(Headset Profile) and HFP(Hands-Free Profile) */
+    BT_AUDIO_PROFILE_TYPE_A2DP,  /**< A2DP(Advanced Audio Distribution Profile) */
+} bt_audio_profile_type_e;
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE
+ * @brief  Enumerations for the equalizer state
+ */
+typedef enum {
+    BT_AVRCP_EQUALIZER_STATE_OFF = 0x01,  /**< Equalizer Off */
+    BT_AVRCP_EQUALIZER_STATE_ON,  /**< Equalizer On */
+} bt_avrcp_equalizer_state_e;
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE
+ * @brief  Enumerations for the repeat mode
+ */
+typedef enum {
+    BT_AVRCP_REPEAT_MODE_OFF = 0x01,  /**< Repeat Off */
+    BT_AVRCP_REPEAT_MODE_SINGLE_TRACK,  /**< Single track repeat */
+    BT_AVRCP_REPEAT_MODE_ALL_TRACK,  /**< All track repeat */
+    BT_AVRCP_REPEAT_MODE_GROUP,  /**< Group repeat */
+} bt_avrcp_repeat_mode_e;
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE
+ * @brief  Enumerations for the shuffle mode
+ */
+typedef enum {
+    BT_AVRCP_SHUFFLE_MODE_OFF = 0x01,  /**< Shuffle Off */
+    BT_AVRCP_SHUFFLE_MODE_ALL_TRACK,  /**< All tracks shuffle */
+    BT_AVRCP_SHUFFLE_MODE_GROUP,  /**< Group shuffle */
+} bt_avrcp_shuffle_mode_e;
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE
+ * @brief  Enumerations for the scan mode
+ */
+typedef enum {
+    BT_AVRCP_SCAN_MODE_OFF = 0x01,  /**< Scan Off */
+    BT_AVRCP_SCAN_MODE_ALL_TRACK,  /**< All tracks scan */
+    BT_AVRCP_SCAN_MODE_GROUP,  /**< Group scan */
+} bt_avrcp_scan_mode_e;
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE
+ * @brief  Enumerations for the player state
+ */
+typedef enum {
+    BT_AVRCP_PLAYER_STATE_STOPPED = 0x00,  /**< Stopped */
+    BT_AVRCP_PLAYER_STATE_PLAYING,  /**< Playing */
+    BT_AVRCP_PLAYER_STATE_PAUSED,  /**< Paused */
+    BT_AVRCP_PLAYER_STATE_FORWARD_SEEK,  /**< Seek Forward */
+    BT_AVRCP_PLAYER_STATE_REWIND_SEEK,  /**< Seek Rewind */
+} bt_avrcp_player_state_e;
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_HDP_MODULE
+ * @brief  Enumerations for the data channel type
  */
+typedef enum {
+    BT_HDP_CHANNEL_TYPE_RELIABLE  = 0x01,  /**< Reliable Data Channel */
+    BT_HDP_CHANNEL_TYPE_STREAMING,  /**< Streaming Data Channel */
+} bt_hdp_channel_type_e;
 
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
@@ -291,11 +367,13 @@ typedef struct
  */
 typedef struct
 {
-	char* remote_address;	/**< The address of remote device */
-	char* remote_name;	/**< The name of remote device */
+	char *remote_address;	/**< The address of remote device */
+	char *remote_name;	/**< The name of remote device */
 	bt_class_s bt_class;	/**< The Bluetooth classes */
 	int rssi;	/**< The strength indicator of received signal  */
 	bool is_bonded;	/**< The bonding state */
+	char **service_uuid;  /**< The UUID list of service */
+	int service_count;	/**< The number of services */
 } bt_adapter_device_discovery_info_s;
 
 /**
@@ -307,10 +385,10 @@ typedef struct
  */
 typedef struct
 {
-	char* remote_address;	/**< The address of remote device */
-	char* remote_name;	/**< The name of remote device */
+	char *remote_address;	/**< The address of remote device */
+	char *remote_name;	/**< The name of remote device */
 	bt_class_s bt_class;	/**< The Bluetooth classes */
-	char** service_uuid;  /**< The UUID list of service */
+	char **service_uuid;  /**< The UUID list of service */
 	int service_count;	/**< The number of services */
 	bool is_bonded;	/**< The bonding state */
 	bool is_connected;	/**< The connection state */
@@ -328,8 +406,8 @@ typedef struct
  */
 typedef struct
 {
-	char* remote_address;   /**< The address of remote device */
-	char** service_uuid;  /**< The UUID list of service */
+	char *remote_address;   /**< The address of remote device */
+	char **service_uuid;  /**< The UUID list of service */
 	int service_count;    /**< The number of services. */
 } bt_device_sdp_info_s;
 
@@ -342,9 +420,10 @@ typedef struct
  */
 typedef struct
 {
-	int socket_fd;	/**< The socket fd */
+	int socket_fd;	/**< The file descriptor of connected socket */
 	bt_socket_role_e local_role;	/**< The local device role in this connection */
-	char* remote_address;	/**< The remote device address. */
+	char *remote_address;	/**< The remote device address */
+	char *service_uuid;	/**< The service UUId */
 } bt_socket_connection_s;
 
 /**
@@ -361,15 +440,10 @@ typedef struct
 {
 	int socket_fd;	/**< The socket fd */
 	int data_size;	/**< The length of the received data */
-	char* data;	/**< The received data */
+	char *data;	/**< The received data */
 } bt_socket_received_data_s;
 
 /**
- * @addtogroup CAPI_NETWORK_BLUETOOTH_MODULE
- * @{
- */
-
-/**
  * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
  * @brief  Called when the Bluetooth adapter state changes.
  * @param[in]   result  The result of the adapter state changing
@@ -452,7 +526,7 @@ typedef void (*bt_adapter_device_discovery_state_changed_cb)
  * @see bt_adapter_foreach_bonded_device()
  *
  */
-typedef bool (*bt_adapter_bonded_device_cb)(bt_device_info_s* device_info, void *user_data);
+typedef bool (*bt_adapter_bonded_device_cb)(bt_device_info_s *device_info, void *user_data);
 
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
@@ -866,7 +940,7 @@ int bt_adapter_stop_device_discovery(void);
  * @see bt_adapter_start_device_discovery()
  * @see bt_adapter_stop_device_discovery()
  */
-int bt_adapter_is_discovering(bool* is_discovering);
+int bt_adapter_is_discovering(bool *is_discovering);
 
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
@@ -893,6 +967,61 @@ int bt_adapter_foreach_bonded_device(bt_adapter_bonded_device_cb callback, void
 
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
+ * @brief Gets the device information of a bonded device.
+ * @remarks The @a device_info must be released with bt_adapter_free_device_info() by you .
+ *
+ * @param [in] remote_address The address of remote device
+ * @param [out] device_info The bonded device information
+ *
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
+ * @retval #BT_ERROR_OUT_OF_MEMORY  Out of memory
+ * @retval #BT_ERROR_NOT_ENABLED  Not enabled
+ * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @retval #BT_ERROR_REMOTE_DEVICE_NOT_BONDED  Remote device not bonded
+ *
+ * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED with bt_adapter_enable().
+ * @post This function invokes bt_adapter_bonded_device_cb().
+ *
+ * @see bt_adapter_bonded_device_cb()
+ * @see bt_adapter_enable()
+ */
+int bt_adapter_get_bonded_device_info(const char *remote_address, bt_device_info_s **device_info);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
+ * @brief Frees device info.
+ *
+ * @param [in] device_info The bonded device information
+ *
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
+ *
+ * @see bt_adapter_get_bonded_device_info()
+ */
+int bt_adapter_free_device_info(bt_device_info_s *device_info);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
+ * @brief Checks whether the UUID of service is used or not
+ * @param[in] service_uuid The UUID of service
+ * @param[out] used Indicates whether the service is used or not
+ * @return true on success, otherwise false.
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
+ * @retval #BT_ERROR_NOT_ENABLED  Not enabled
+ * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @see bt_adapter_enable()
+ */
+int bt_adapter_is_service_used(const char *service_uuid, bool *used);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
  * @brief  Registers a callback function to be invoked when the Bluetooth adapter state changes.
  *
  * @param[in] callback	The callback function to invoke
@@ -1348,8 +1477,8 @@ int bt_device_unset_service_searched_cb(void);
  *
  * @remarks A socket can be destroyed by bt_socket_destroy_rfcomm().
  *
- * @param[in] port_uuid The UUID of service to provide
- * @param[out] socket_fd A socket file descriptor to be used to communicate
+ * @param[in] service_uuid The UUID of service to provide
+ * @param[out] socket_fd The file descriptor of socket to listen
  * @return 0 on success, otherwise a negative error value.
  *
  * @retval #BT_ERROR_NONE  Successful
@@ -1363,13 +1492,13 @@ int bt_device_unset_service_searched_cb(void);
  * @see bt_socket_listen_and_accept_rfcomm()
  * @see bt_socket_destroy_rfcomm()
  */
-int bt_socket_create_rfcomm(const char* port_uuid, int *socket_fd);
+int bt_socket_create_rfcomm(const char *service_uuid, int *socket_fd);
 
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE
- * @brief Removes the rfcomm socket with the given socket file descriptor.
+ * @brief Removes the rfcomm socket with the given socket.
  *
- * @param[in] socket_fd The socket file descriptor to destroy
+ * @param[in] socket_fd The file descriptor of socket to destroy
  * @return 0 on success, otherwise a negative error value.
  * @retval #BT_ERROR_NONE  Successful
  * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
@@ -1390,9 +1519,12 @@ int bt_socket_destroy_rfcomm(int socket_fd);
 
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE
- * @brief Starts listening on passed rfcomm socket and accepts connection requests, asynchronously.
+ * @brief Starts listening on passed rfcomm socket and accepts connection requests.
+ * @details Pop-up is shown automatically when a RFCOMM connection is requested.
+ * bt_socket_connection_state_changed_cb() will be called with
+ * #BT_SOCKET_CONNECTED if you click "yes" and connection is finished successfully.
  *
- * @param[in] socket_fd	The socket file descriptor on which start to listen
+ * @param[in] socket_fd The file descriptor of socket on which start to listen
  * @param[in] max_pending_connections The maximum number of pending connections
  *
  * @return 0 on success, otherwise a negative error value.
@@ -1414,12 +1546,89 @@ int bt_socket_listen_and_accept_rfcomm(int socket_fd, int max_pending_connection
 
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE
+ * @brief  Called when a RFCOMM connection is requested.
+ * @details You must call bt_socket_accept() if you want to accept. Otherwise, you must call bt_socket_reject().
+ * @param[in] socket_fd  The file descriptor of socket on which a connection is requested
+ * @param[in] remote_address  The address of remote device
+ * @param[in] user_data The user data passed from the callback registration function
+ * @pre If you register this callback function by bt_socket_set_connection_requested_cb() and listen a socket by bt_socket_listen(),
+ * bt_socket_connection_requested_cb() will be invoked.
+ * @see bt_socket_listen()
+ * @see bt_socket_accept()
+ * @see bt_socket_reject()
+ */
+typedef void (*bt_socket_connection_requested_cb) (int socket_fd, const char *remote_address, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE
+ * @brief Starts listening on passed rfcomm socket.
+ * @details bt_socket_connection_requested_cb() will be called when a RFCOMM connection is requested.
+ *
+ * @param[in] socket_fd  The file descriptor socket on which start to listen
+ * @param[in] user_data  The user data to be passed to the callback function
+ *
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_NOT_ENABLED  Not enabled
+ * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
+ * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ *
+ * @pre The socket must be created with bt_socket_create_rfcomm().
+ * @post This function invokes bt_socket_connection_state_changed_cb().
+ *
+ * @see bt_socket_create_rfcomm()
+ * @see bt_socket_set_connection_requested_cb()
+ * @see bt_socket_unset_connection_requested_cb()
+ * @see bt_socket_connection_requested_cb()
+ */
+int bt_socket_listen(int socket_fd, int max_pending_connections);
+
+/**
+ * @ingroup  CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE
+ * @brief  Accepts a connection request.
+ * @param[in] requested_socket_fd  The file descriptor of socket on which a connection is requested
+ * @param[out] connected_socket_fd  The file descriptor of connected socket
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_NOT_ENABLED  Not enabled
+ * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
+ * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @pre The connection is requested by bt_socket_connection_requested_cb().
+ * @see bt_socket_create_rfcomm()
+ * @see bt_socket_connection_requested_cb()
+ * @see bt_socket_listen()
+ * @see bt_socket_reject()
+*/
+int bt_socket_accept(int requested_socket_fd, int *connected_socket_fd);
+
+/**
+ * @ingroup  CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE
+ * @brief  Rejects a connection request.
+ * @param[in] socket_fd  The file descriptor of socket on which a connection is requested
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_NOT_ENABLED  Not enabled
+ * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
+ * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @pre The connection is requested by bt_socket_connection_requested_cb().
+ * @see bt_socket_create_rfcomm()
+ * @see bt_socket_connection_requested_cb()
+ * @see bt_socket_listen()
+ * @see bt_socket_accept()
+ */
+int bt_socket_reject(int socket_fd);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE
  * @brief Connects to a specific RFCOMM based service on a remote Bluetooth device UUID, asynchronously.
  *
  * @remarks A connection can be disconnected by bt_socket_disconnect_rfcomm().
  *
  * @param[in] remote_address The address of the remote Bluetooth device
- * @param[in] remote_port_uuid The UUID of service provided by the remote Bluetooth device
+ * @param[in] service_uuid The UUID of service provided by the remote Bluetooth device
  *
  * @return 0 on success, otherwise a negative error value.
  * @retval #BT_ERROR_NONE  Successful
@@ -1443,25 +1652,19 @@ int bt_socket_listen_and_accept_rfcomm(int socket_fd, int max_pending_connection
  * @see bt_socket_set_connection_state_changed_cb()
  * @see bt_socket_unset_connection_state_changed_cb()
  */
-int bt_socket_connect_rfcomm(const char *remote_address, const char* remote_port_uuid);
+int bt_socket_connect_rfcomm(const char *remote_address, const char *service_uuid);
 
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE
- * @brief Disconnects the RFCOMM connection with the given socket file descriptor.
- * @remarks Because this is a synchronous function, bt_socket_connection_state_changed_cb() won't be called
- * even though a connection is disconnected successfully.
- *
- * @param[in] socket_fd The socket file descriptor to close
- *
+ * @brief Disconnects the RFCOMM connection with the given file descriptor of conneted socket.
+ * @remarks Because this function is synchronous, bt_socket_connection_state_changed_cb() won't be called
+ * @param[in] socket_fd  The file descriptor of socket to close
  * @return 0 on success, otherwise a negative error value.
  * @retval #BT_ERROR_NONE  Successful
  * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
  * @retval #BT_ERROR_NOT_ENABLED  Not enabled
  * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
- *
- * @pre The connection must be established with bt_socket_connect_rfcomm().
- *
- * @see bt_socket_connect_rfcomm()
+ * @pre The connection must be established.
  */
 int bt_socket_disconnect_rfcomm(int socket_fd);
 
@@ -1469,7 +1672,7 @@ int bt_socket_disconnect_rfcomm(int socket_fd);
  * @ingroup CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE
  * @brief Sends data to the connected device.
  *
- * @param[in] socket_fd The connected socket
+ * @param[in] socket_fd The file descriptor of connected socket
  * @param[in] data The data to be sent
  * @param[in] length The length of data to be sent
  *
@@ -1480,12 +1683,9 @@ int bt_socket_disconnect_rfcomm(int socket_fd);
  * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
  * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
  *
- * @pre The connection must be established with either bt_socket_connect_rfcomm() or bt_socket_listen_and_accept_rfcomm().
- *
- * @see bt_socket_connect_rfcomm()
- * @see bt_socket_listen_and_accept_rfcomm()
+ * @pre The connection must be established.
  */
-int bt_socket_send_data(int socket_fd, const char* data, int length);
+int bt_socket_send_data(int socket_fd, const char *data, int length);
 
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE
@@ -1520,6 +1720,35 @@ int bt_socket_unset_data_received_cb(void);
 
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE
+ * @brief  Register a callback function that will be invoked when a RFCOMM connection is requested.
+ * @param[in] callback The callback function to register
+ * @param[in] user_data The user data to be passed to the callback function
+ * @return   0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
+ * @pre The Bluetooth service must be initialized with bt_initialize().
+ * @post If you listen a socket by bt_socket_listen(), bt_socket_connection_requested_cb() will be invoked.
+ * @see bt_initialize()
+ * @see bt_socket_unset_connection_requested_cb()
+ */
+int bt_socket_set_connection_requested_cb(bt_socket_connection_requested_cb callback, void *user_data);
+
+/**
+ * @ingroup  CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE
+ * @brief  Unregisters the callback function.
+ * @return  0 on success, otherwise a negative error value.
+ * @retval  #BT_ERROR_NONE  Successful
+ * @retval  #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @pre  The Bluetooth service must be initialized with bt_initialize().
+ * @see  bt_initialize()
+ * @see  bt_socket_set_connection_requested_cb()
+ * @see  bt_socket_connection_requested_cb()
+ */
+int bt_socket_unset_connection_requested_cb(void);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE
  * @brief  Register a callback function that will be invoked when the connection state changes.
  * @param[in] callback The callback function to register
  * @param[in] user_data The user data to be passed to the callback function
@@ -1548,11 +1777,1139 @@ int bt_socket_set_connection_state_changed_cb(bt_socket_connection_state_changed
  */
 int bt_socket_unset_connection_state_changed_cb(void);
 
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_OPP_SERVER_MODULE
+ * @brief  Called when the push is requested.
+ * @details You must call bt_opp_server_accept_push() if you want to accept.
+ * Otherwise, you must call bt_opp_server_reject_push().
+ * @param[in] file  The path of file to be pushed
+ * @param[in] size The file size (bytes)
+ * @param[in] user_data The user data passed from the callback registration function
+ * @see bt_opp_server_initialize()
+ */
+typedef void (*bt_opp_server_push_requested_cb)(const char *file, int size, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_OPP_SERVER_MODULE
+ * @brief  Called when an OPP connection is requested.
+ * @details You must call bt_opp_server_accept_connection() if you want to accept.
+ * Otherwise, you must call bt_opp_server_reject_connection().
+ * @param[in] remote_address  The address of remote device
+ * @param[in] user_data The user data passed from the callback registration function
+ * @see bt_opp_server_initialize()
+ * @see bt_opp_server_accept_connection()
+ * @see bt_opp_server_reject_connection()
+ */
+typedef void (*bt_opp_server_connection_requested_cb)(const char *remote_address, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_OPP_SERVER_MODULE
+ * @brief Initializes the Bluetooth OPP server requested by bt_opp_server_push_requested_cb().
+ * @details The popup appears when an OPP connection is requested from a remote device.
+ * If you accept the request, then connection will be established and bt_opp_server_push_requested_cb() will be called.
+ * At that time, you can call either bt_opp_server_accept() or bt_opp_server_reject().
+ * @remarks This function must be called to start Bluetooth OPP server. You must free all resources of the Bluetooth service
+ * by calling bt_opp_server_deinitialize() if Bluetooth OPP service is no longer needed.
+ * @param[in] destination  The destination path
+ * @param[in] push_requested_cb  The callback called when a push is requested
+ * @param[in] user_data The user data to be passed to the callback function
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_NOT_ENABLED  Not enabled
+ * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
+ * @retval #BT_ERROR_RESOURCE_BUSY  Device or resource busy
+ * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @see  bt_opp_server_push_requested_cb()
+ * @see  bt_opp_server_deinitialize()
+ * @see  bt_opp_server_accept_push()
+ * @see  bt_opp_server_reject_push()
+ */
+int bt_opp_server_initialize(const char *destination, bt_opp_server_push_requested_cb push_requested_cb, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_OPP_SERVER_MODULE
+ * @brief Initializes the Bluetooth OPP server requested by bt_opp_server_connection_requested_cb().
+ * @details No popup appears when an OPP connection is requested from a remote device.
+ * Instead, @a connection_requested_cb() will be called.
+ * At that time, you can call either bt_opp_server_accept() or bt_opp_server_reject().
+ * @remarks This function must be called to start Bluetooth OPP server. \n
+ * You must free all resources of the Bluetooth service by calling bt_opp_server_deinitialize() if Bluetooth OPP service is no longer needed.
+ * @param[in] destination  The destination path
+ * @param[in] connection_requested_cb  The callback called when an OPP connection is requested
+ * @param[in] user_data The user data to be passed to the callback function
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_NOT_ENABLED  Not enabled
+ * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
+ * @retval #BT_ERROR_RESOURCE_BUSY  Device or resource busy
+ * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @see  bt_opp_server_connection_requested_cb()
+ * @see  bt_opp_server_deinitialize()
+ * @see  bt_opp_server_accept_connection()
+ * @see  bt_opp_server_reject_connection()
+ */
+int bt_opp_server_initialize_by_connection_request(const char *destination, bt_opp_server_connection_requested_cb connection_requested_cb, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_OPP_SERVER_MODULE
+ * @brief Denitializes the Bluetooth OPP server.
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_NOT_ENABLED  Not enabled
+ * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @see  bt_opp_server_initialize()
+ * @see  bt_opp_server_deinitialize()
+ * @see  bt_opp_server_initialize()
+ */
+int bt_opp_server_deinitialize(void);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_OPP_SERVER_MODULE
+ * @brief  Called when a file is being transfered.
+ * @param[in] file  The path of file to be pushed
+ * @param[in] size The file size (bytes)
+ * @param[in] percent The progress in percentage (1 ~ 100)
+ * @param[in] user_data The user data passed from the callback registration function
+ * @see bt_opp_server_accept_push()
+ * @see bt_opp_server_accept_connection()
+ */
+typedef void (*bt_opp_server_transfer_progress_cb) (const char *file, long long size, int percent, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_OPP_SERVER_MODULE
+ * @brief  Called when a transfer is finished.
+ * @param[in] error_code  The result of push
+ * @param[in] file  The path of file to be pushed
+ * @param[in] size The file size (bytes)
+ * @param[in] user_data The user data passed from the callback registration function
+ * @see bt_opp_server_accept_push()
+ * @see bt_opp_server_accept_connection()
+ */
+typedef void (*bt_opp_server_transfer_finished_cb) (int result, const char *file, long long size, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_OPP_SERVER_MODULE
+ * @brief Accepts the push request from the remote device.
+ * @remarks If you initialize OPP server by bt_opp_server_initialize_by_connection_request(), then name is ignored.
+ * You can cancel the pushes by bt_opp_server_cancel_transfer() with transfer_id.
+ * @param[in] progress_cb  The callback called when a file is being transfered
+ * @param[in] finished_cb  The callback called when a transfer is finished
+ * @param[in] name  The name to store. This can be NULL if you initialize OPP server by bt_opp_server_initialize_by_connection_request().
+ * @param[in] user_data The user data to be passed to the callback function
+ * @param[out]  transfer_id  The ID of transfer
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_NOT_ENABLED  Not enabled
+ * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @retval #BT_ERROR_NOW_IN_PROGRESS  Operation now in progress
+ * @see  bt_opp_server_reject()
+ */
+int bt_opp_server_accept(bt_opp_server_transfer_progress_cb progress_cb, bt_opp_server_transfer_finished_cb finished_cb, const char *name,
+ void *user_data, int *transfer_id);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_OPP_SERVER_MODULE
+ * @brief Rejects the push request from the remote device.
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_NOT_ENABLED  Not enabled
+ * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
+ * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @see  bt_opp_server_accept_push()
+ */
+int bt_opp_server_reject(void);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_OPP_SERVER_MODULE
+ * @brief Cancels the transfer.
+ * @param[in] transfer_id  The ID of transfer
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_NOT_ENABLED  Not enabled
+ * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
+ * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @see  bt_opp_server_accept_connection()
+ * @see  bt_opp_server_accept_push()
+ */
+int bt_opp_server_cancel_transfer(int transfer_id);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_OPP_SERVER_MODULE
+ * @brief Sets the destination path of file to be pushed.
+ * @param[in] destination  The destination path of file to be pushed
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_NOT_ENABLED  Not enabled
+ * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
+ * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @see  bt_opp_server_initialize()
+ */
+int bt_opp_server_set_destination(const char *destination);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_OPP_CLIENT_MODULE
+ * @brief Initializes the Bluetooth OPP client.
+ * @remarks This function must be called before Bluetooth OPP client starts. \n
+ * You must free all resources of the Bluetooth service by calling bt_opp_client_deinitialize()
+ * if Bluetooth OPP service is no longer needed.
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_NOT_ENABLED  Not enabled
+ * @retval #BT_ERROR_RESOURCE_BUSY  Device or resource busy
+ * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @see  bt_opp_client_deinitialize()
+ */
+int bt_opp_client_initialize(void);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_OPP_CLIENT_MODULE
+ * @brief Denitializes the Bluetooth OPP client.
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_NOT_ENABLED  Not enabled
+ * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @see  bt_opp_client_initialize()
+ */
+int bt_opp_client_deinitialize(void);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_OPP_CLIENT_MODULE
+ * @brief Adds file to be pushed.
+ * @param[in] file  The path of file to be pushed
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_NOT_ENABLED  Not enabled
+ * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @see  bt_opp_client_clear_files()
+ * @see  bt_opp_client_push_files()
+ */
+int bt_opp_client_add_file(const char *file);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_OPP_CLIENT_MODULE
+ * @brief Adds file to be pushed.
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_NOT_ENABLED  Not enabled
+ * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @see  bt_opp_client_add_file()
+ * @see  bt_opp_client_push_files()
+ */
+int bt_opp_client_clear_files(void);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_OPP_CLIENT_MODULE
+ * @brief  Called when OPP server responds to the push request.
+ * @param[in] result  The result of OPP server response
+ * @param[in] remote_address  The remote address
+ * @param[in] user_data  The user data passed from the callback registration function
+ * @pre bt_opp_client_push_files() will invoke this function.
+ * @see bt_opp_client_push_files()
+ */
+typedef void (*bt_opp_client_push_responded_cb)(int result, const char *remote_address, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_OPP_CLIENT_MODULE
+ * @brief  Called when each file is being transfered.
+ * @param[in] file  The path of file to be pushed
+ * @param[in] size The file size (bytes)
+ * @param[in] percent The progress in percentage (1 ~ 100). 100 means that a file is transfered completely.
+ * @param[in] user_data The user data passed from the callback registration function
+ * @pre bt_opp_client_push_files() will invoke this function.
+ * @see bt_opp_client_push_files()
+ */
+typedef void (*bt_opp_client_push_progress_cb)(const char *file, long long size, int percent, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_OPP_CLIENT_MODULE
+ * @brief  Called when the push request is finished.
+ * @param[in] result  The result of the push request
+ * @param[in] remote_address  The remote address
+ * @param[in] user_data The user data passed from the callback registration function
+ * @see bt_opp_client_push_files()
+ */
+typedef void (*bt_opp_client_push_finished_cb)(int result, const char *remote_address, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_OPP_CLIENT_MODULE
+ * @brief Pushes the file to the remote device, asynchronously.
+ * @details At first, bt_opp_client_push_responded_cb() will be called when OPP server responds to the push request.
+ * After connection is established, bt_opp_client_push_progress_cb() will be called repeatedly until a file is tranfered completely.
+ * If you send several files, then bt_opp_client_push_progress_cb() with another file will be called repeatedly until the file is tranfered completely.
+ * bt_opp_client_push_finished_cb() will be called when the push request is finished.
+ * @param[in] remote_address The remote address
+ * @param[in] responded_cb  The callback called when OPP server responds to the push request
+ * @param[in] progress_cb  The callback called when each file is being transfered
+ * @param[in] finished_cb  The callback called when the push request is finished
+ * @param[in] user_data The user data to be passed to the callback function
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_NOT_ENABLED  Not enabled
+ * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
+ * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @retval #BT_ERROR_NOW_IN_PROGRESS  Operation now in progress
+ * @see bt_opp_client_initialize()
+ * @see bt_opp_client_cancel_push
+ */
+int bt_opp_client_push_files(const char *remote_address, bt_opp_client_push_responded_cb responded_cb,
+ bt_opp_client_push_progress_cb progress_cb, bt_opp_client_push_finished_cb finished_cb, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_OPP_CLIENT_MODULE
+ * @brief Cancels the push request in progress, asynchronously.
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_NOT_ENABLED  Not enabled
+ * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @pre bt_opp_client_push_files() must be called.
+ * @post bt_opp_client_push_finished_cb() will be invoked with result #BT_ERROR_CANCELLED,
+ * which is a parameter of bt_opp_client_push_files().
+ * @see bt_opp_client_initialize()
+ * @see bt_opp_client_push_files()
+ */
+int bt_opp_client_cancel_push(void);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_PAN_NAP_MODULE
+ * @brief  Called when the connection state is changed.
+ * @param[in] connected  Indicates whether a client is connected or disconnected
+ * @param[in] remote_address  The remote address
+ * @param[in] interface_name  The interface name. For example, bnep0, bnep1.
+ * @param[in] user_data The user data passed from the callback registration function
+ * @see bt_nap_set_connection_state_changed_cb()
+ * @see bt_nap_unset_connection_state_changed_cb()
+ */
+typedef void (*bt_nap_connection_state_changed_cb) (bool connected, const char *remote_address, const char *interface_name, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_PAN_NAP_MODULE
+ * @brief Activates the NAP(Network Access Point).
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_NOT_ENABLED  Not enabled
+ * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @pre The Bluetooth must be enabled with bt_adapter_enable().
+ * @see bt_adapter_enable()
+ * @see bt_nap_deactivate()
+ */
+int bt_nap_activate(void);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_PAN_NAP_MODULE
+ * @brief Deactivates the NAP(Network Access Point).
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_NOT_ENABLED  Not enabled
+ * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @pre The Bluetooth NAP service must be activated with bt_nap_activate().
+ * @see bt_nap_activate()
+ */
+int bt_nap_deactivate(void);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_PAN_NAP_MODULE
+ * @brief  Registers a callback function that will be invoked when the connection state changes.
+ * @param[in] callback The callback function to register
+ * @param[in] user_data The user data to be passed to the callback function
+ * @return   0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
+ * @pre The Bluetooth service must be initialized with bt_initialize().
+ * @post bt_nap_connection_state_changed_cb() will be invoked.
+ * @see bt_initialize()
+ * @see bt_nap_connection_state_changed_cb()
+ * @see bt_nap_unset_connection_state_changed_cb()
+ */
+int bt_nap_set_connection_state_changed_cb(bt_nap_connection_state_changed_cb callback, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_PAN_NAP_MODULE
+ * @brief  Unregisters a callback function that will be invoked when the connection state changes.
+ * @return   0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @pre The Bluetooth service must be initialized with bt_initialize().
+ * @post bt_nap_connection_state_changed_cb() will be invoked.
+ * @see bt_initialize()
+ * @see bt_nap_connection_state_changed_cb()
+ * @see bt_nap_set_connection_state_changed_cb()
+ */
+int bt_nap_unset_connection_state_changed_cb(void);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_PAN_PANU_MODULE
+ * @brief  Called when the connection state is changed.
+ * @details  This callback is called when the connection state is changed.
+ * When you call bt_panu_connect() or bt_panu_disconnect(), this callback is also called with error result even though these functions fail.
+ * @param[in] result  The result of changing the connection state
+ * @param[in] connected  The state to be changed. @a true means connected state, Otherwise, @a false.
+ * @param[in] remote_address  The remote address
+ * @param[in] type  The type of PAN service
+ * @param[in] user_data The user data passed from the callback registration function
+ * @see bt_nap_set_connection_state_changed_cb()
+ * @see bt_nap_unset_connection_state_changed_cb()
+ */
+typedef void (*bt_panu_connection_state_changed_cb) (int result, bool connected, const char *remote_address, bt_panu_service_type_e type, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_PAN_PANU_MODULE
+ * @brief  Registers a callback function that will be invoked when the connection state changes.
+ * @param[in] callback The callback function to register
+ * @param[in] user_data The user data to be passed to the callback function
+ * @return   0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
+ * @pre The Bluetooth service must be initialized with bt_initialize().
+ * @post bt_nap_connection_state_changed_cb() will be invoked.
+ * @see bt_initialize()
+ * @see bt_panu_connection_state_changed_cb()
+ * @see bt_panu_unset_connection_state_changed_cb()
+ */
+int bt_panu_set_connection_state_changed_cb(bt_panu_connection_state_changed_cb callback, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_PAN_PANU_MODULE
+ * @brief  Unregisters a callback function that will be invoked when the connection state changes.
+ * @return   0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @pre The Bluetooth service must be initialized with bt_initialize().
+ * @post bt_nap_connection_state_changed_cb() will be invoked.
+ * @see bt_initialize()
+ * @see bt_panu_connection_state_changed_cb()
+ * @see bt_panu_set_connection_state_changed_cb()
+ */
+int bt_panu_unset_connection_state_changed_cb(void);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_PAN_PANU_MODULE
+ * @brief Connects the remote device with the PAN(Personal Area Networking) service, asynchronously.
+ * @param[in] remote_address  The remote address
+ * @param[in] type  The type of PAN service
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
+ * @retval #BT_ERROR_NOT_ENABLED  Not enabled
+ * @retval #BT_ERROR_REMOTE_DEVICE_NOT_BONDED  Remote device is not bonded
+ * @retval #BT_ERROR_OUT_OF_MEMORY  Out of memory
+ * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @pre The local device must be bonded with the remote device by bt_device_create_bond().
+ * @post bt_panu_connection_state_changed_cb() will be invoked.
+ * @see bt_panu_disconnect()
+ * @see bt_panu_connection_state_changed_cb()
+ */
+int bt_panu_connect(const char *remote_address, bt_panu_service_type_e type);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_PAN_PANU_MODULE
+ * @brief Disconnects the remote device with the PAN(Personal Area Networking) service, asynchronously.
+ * @param[in] remote_address  The remote address
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
+ * @retval #BT_ERROR_NOT_ENABLED  Not enabled
+ * @retval #BT_ERROR_REMOTE_DEVICE_NOT_CONNECTED  Remote device is not connected
+ * @retval #BT_ERROR_OUT_OF_MEMORY  Out of memory
+ * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @pre The remote device must be connected by bt_panu_connect().
+ * @post bt_panu_connection_state_changed_cb() will be invoked.
+ * @see bt_panu_connect()
+ * @see bt_panu_connection_state_changed_cb()
+ */
+int bt_panu_disconnect(const char *remote_address);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_HID_MODULE
+ * @brief  Called when the connection state is changed.
+ * @details  This callback is called when the connection state is changed.
+ * When you call bt_hid_host_connect() or bt_hid_host_disconnect(), this callback is also called with error result even though these functions fail.
+ * @param[in] result  The result of changing the connection state
+ * @param[in] connected  The state to be changed. @a true means connected state, Otherwise, @a false.
+ * @param[in] remote_address  The remote address
+ * @param[in] user_data The user data passed from the callback registration function
+ * @see bt_hid_host_connect()
+ * @see bt_hid_host_disconnect()
+ */
+typedef void (*bt_hid_host_connection_state_changed_cb) (int result, bool connected, const char *remote_address, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_HID_MODULE
+ * @brief Initializes the Bluetooth HID(Human Interface Device) Host.
+ * @remarks This function must be called before Bluetooth HID Host starts. \n
+ * You must free all resources of the Bluetooth service by calling bt_hid_host_deinitialize()
+ * if Bluetooth HID Host service is no longer needed.
+ * @param[in] connection_cb  The callback called when the connection state is changed
+ * @param[in] user_data The user data to be passed to the callback function
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
+ * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @pre The Bluetooth service must be initialized with bt_initialize().
+ * @see bt_initialize()
+ * @see  bt_hid_host_deinitialize()
+ */
+int bt_hid_host_initialize(bt_hid_host_connection_state_changed_cb connection_cb, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_HID_MODULE
+ * @brief Deinitializes the Bluetooth HID(Human Interface Device) Host.
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @pre The Bluetooth HID service must be initialized with bt_hid_host_initialize().
+ * @see  bt_hid_host_initialize()
+ */
+int bt_hid_host_deinitialize(void);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_HID_MODULE
+ * @brief Connects the remote device with the HID(Human Interface Device) service, asynchronously.
+ * @param[in] remote_address  The remote address
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
+ * @retval #BT_ERROR_NOT_ENABLED  Not enabled
+ * @retval #BT_ERROR_REMOTE_DEVICE_NOT_BONDED  Remote device is not bonded
+ * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @pre The local device must be bonded with the remote device by bt_device_create_bond().
+ * @pre The Bluetooth HID service must be initialized with bt_hid_host_initialize().
+ * @post bt_hid_host_connection_state_changed_cb() will be invoked.
+ * @see bt_hid_host_disconnect()
+ * @see bt_hid_host_connection_state_changed_cb()
+ */
+int bt_hid_host_connect(const char *remote_address);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_HID_MODULE
+ * @brief Disconnects the remote device with the HID(Human Interface Device) service, asynchronously.
+ * @param[in] remote_address  The remote address
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
+ * @retval #BT_ERROR_NOT_ENABLED  Not enabled
+ * @retval #BT_ERROR_REMOTE_DEVICE_NOT_CONNECTED  Remote device is not connected
+ * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @pre The remote device must be connected by bt_hid_host_connect().
+ * @post bt_hid_host_connection_state_changed_cb() will be invoked.
+ * @see bt_hid_host_connect()
+ * @see bt_hid_host_connection_state_changed_cb()
+ */
+int bt_hid_host_disconnect(const char *remote_address);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_MODULE
+ * @brief Initializes the Bluetooth profiles related with audio.
+ * @remarks This function must be called before Bluetooth profiles related with audio starts. \n
+ * You must free all resources of the this service by calling bt_audio_deinitialize()
+ * if Bluetooth profiles related with audio service is no longer needed.
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @pre The Bluetooth service must be initialized with bt_initialize().
+ * @see bt_initialize()
+ * @see bt_audio_deinitialize()
+ */
+int bt_audio_initialize(void);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_MODULE
+ * @brief Deinitializes the Bluetooth profiles related with audio.
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @pre The Bluetooth audio service must be initialized with bt_audio_initialize().
+ * @see bt_audio_initialize()
+ */
+int bt_audio_deinitialize(void);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_MODULE
+ * @brief Connects the remote device with the given audio profile, asynchronously.
+ * @details If you input type as #BT_AUDIO_PROFILE_TYPE_ALL and connection request succeeds, then bt_audio_connection_state_changed_cb() will be called twice
+ * when #BT_AUDIO_PROFILE_TYPE_HSP_HFP is connected and #BT_AUDIO_PROFILE_TYPE_A2DP is connected.
+ * @param[in] remote_address  The remote address
+ * @param[in] type  The type of audio profile
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
+ * @retval #BT_ERROR_NOT_ENABLED  Not enabled
+ * @retval #BT_ERROR_REMOTE_DEVICE_NOT_BONDED  Remote device is not bonded
+ * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @pre The Bluetooth audio service must be initialized with bt_audio_initialize().
+ * @pre The local device must be bonded with the remote device by bt_device_create_bond().
+ * @post bt_audio_connection_state_changed_cb() will be invoked.
+ * @see bt_audio_disconnect()
+ * @see bt_audio_connection_state_changed_cb()
+ */
+int bt_audio_connect(const char *remote_address, bt_audio_profile_type_e type);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_MODULE
+ * @brief Disconnects the remote device with the given audio profile, asynchronously.
+ * @details If you input type as #BT_AUDIO_PROFILE_TYPE_ALL and disconnection request succeeds, then bt_audio_connection_state_changed_cb() will be called twice
+ * when #BT_AUDIO_PROFILE_TYPE_HSP_HFP is disconnected and #BT_AUDIO_PROFILE_TYPE_A2DP is disconnected.
+ * @param[in] remote_address  The remote address
+ * @param[in] type  The type of audio profile
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
+ * @retval #BT_ERROR_NOT_ENABLED  Not enabled
+ * @retval #BT_ERROR_REMOTE_DEVICE_NOT_CONNECTED  Remote device is not connected
+ * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @pre The remote device must be connected by bt_audio_connect().
+ * @post bt_audio_connection_state_changed_cb() will be invoked.
+ * @see bt_audio_connect()
+ * @see bt_audio_connection_state_changed_cb()
+ */
+int bt_audio_disconnect(const char *remote_address, bt_audio_profile_type_e type);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_MODULE
+ * @brief  Called when the connection state is changed.
+ * @details  This callback is called when the connection state is changed.
+ * When you call bt_audio_connect() or bt_audio_disconnect(), this callback is also called with error result even though these functions fail.
+ * @param[in] result  The result of changing the connection state
+ * @param[in] connected  The state to be changed. @a true means connected state, Otherwise, @a false.
+ * @param[in] remote_address  The remote address
+ * @param[in] type  The type of audio profile except #BT_AUDIO_PROFILE_TYPE_ALL
+ * @param[in] user_data The user data passed from the callback registration function
+ * @see bt_audio_set_connection_state_changed_cb()
+ * @see bt_audio_unset_connection_state_changed_cb()
+ */
+typedef void (*bt_audio_connection_state_changed_cb) (int result, bool connected, const char *remote_address, bt_audio_profile_type_e type, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_MODULE
+ * @brief  Registers a callback function that will be invoked when the connection state is changed.
+ * @param[in] callback The callback function to register
+ * @param[in] user_data The user data to be passed to the callback function
+ * @return   0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
+ * @pre The Bluetooth audio service must be initialized with bt_audio_initialize().
+ * @see bt_audio_initialize()
+ * @see bt_audio_connection_state_changed_cb()
+ * @see bt_panu_unset_connection_state_changed_cb()
+ */
+int bt_audio_set_connection_state_changed_cb(bt_audio_connection_state_changed_cb callback, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_MODULE
+ * @brief  Unregisters a callback function that will be invoked when the connection state is changed.
+ * @return   0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @pre The Bluetooth audio service must be initialized with bt_audio_initialize().
+ * @see bt_audio_initialize()
+ * @see bt_audio_connection_state_changed_cb()
+ * @see bt_audio_set_connection_state_changed_cb()
+ */
+int bt_audio_unset_connection_state_changed_cb(void);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
+ * @brief  Notifies the speaker gain to the remote device.
+ * @details This function sends a signal to the remote device. This signal has the gain value.
+ * @a gain is represented on a scale from 0 to 15. This value is absolute value relating to a particular volume level.
+ * When the speaker gain of remote device is changed to the requested gain, bt_audio_speaker_gain_changed_cb() will be called.
+ * @param[in] remote_address  The remote address
+ * @param[in] gain The gain of speaker (0 ~ 15)
+ * @return   0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
+ * @retval #BT_ERROR_NOT_ENABLED  Not enabled
+ * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @retval #BT_ERROR_REMOTE_DEVICE_NOT_CONNECTED  Remote device is not connected
+ * @pre The remote device is connected by bt_audio_connect() with #BT_AUDIO_PROFILE_TYPE_HSP_HFP service.
+ * @see bt_ag_get_speaker_gain()
+ * @see bt_ag_set_speaker_gain_changed_cb()
+ * @see bt_ag_unset_speaker_gain_changed_cb()
+ */
+int bt_ag_notify_speaker_gain(const char *remote_address, int gain);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
+ * @brief  Gets the current speaker gain of the remote device.
+ * @details This function gets the value of speaker gain of the remote device.
+ * @a gain is represented on a scale from 0 to 15. This value is absolute value relating to a particular volume level.
+ * @param[in] remote_address  The remote address
+ * @param[out] gain The gain of speaker (0 ~ 15)
+ * @return   0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
+ * @retval #BT_ERROR_NOT_ENABLED  Not enabled
+ * @retval #BT_ERROR_REMOTE_DEVICE_NOT_CONNECTED  Remote device is not connected
+ * @pre The remote device is connected by bt_audio_connect() with #BT_AUDIO_PROFILE_TYPE_HSP_HFP service.
+ * @see bt_ag_notify_speaker_gain()
+ * @see bt_ag_set_speaker_gain_changed_cb()
+ * @see bt_ag_unset_speaker_gain_changed_cb()
+ */
+int bt_ag_get_speaker_gain(const char *remote_address, int *gain);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_MODULE
+ * @brief  Called when the speaker gain of the remote device is changed.
+ * @param[in] remote_address  The remote address
+ * @param[in] gain The gain of speaker (0 ~ 15)
+ * @param[in] user_data The user data passed from the callback registration function
+ * @see bt_ag_set_speaker_gain_changed_cb()
+ * @see bt_ag_unset_speaker_gain_changed_cb()
+ */
+typedef void (*bt_ag_speaker_gain_changed_cb) (const char *remote_address, int gain, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
+ * @brief  Registers a callback function that will be invoked when the speaker gain of the remote device is changed.
+ * @details This function let you know the change of the speaker gain of the remote device.
+ * @a gain is represented on a scale from 0 to 15. This value is absolute value relating to a particular volume level.
+ * @param[in] callback The callback function to register
+ * @param[in] user_data The user data to be passed to the callback function
+ * @return   0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
+ * @pre The Bluetooth audio service must be initialized with bt_audio_initialize().
+ * @see bt_audio_initialize()
+ * @see bt_ag_unset_speaker_gain_changed_cb()
+ */
+int bt_ag_set_speaker_gain_changed_cb(bt_ag_speaker_gain_changed_cb callback, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
+ * @brief  Unregisters a callback function that will be invoked when the speaker gain of the remote device is changed.
+ * @return   0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
+ * @pre The Bluetooth audio service must be initialized with bt_audio_initialize().
+ * @see bt_audio_initialize()
+ * @see bt_ag_set_speaker_gain_changed_cb()
+ */
+int bt_ag_unset_speaker_gain_changed_cb(void);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_MODULE
+ * @brief  Called when the microphone gain of the remote device is changed.
+ * @param[in] remote_address  The remote address
+ * @param[in] gain The gain of microphone (0 ~ 15)
+ * @param[in] user_data The user data passed from the callback registration function
+ * @see bt_ag_set_microphone_gain_changed_cb()
+ * @see bt_ag_unset_microphone_gain_changed_cb()
+ */
+typedef void (*bt_ag_microphone_gain_changed_cb) (const char *remote_address, int gain, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
+ * @brief  Registers a callback function that will be invoked when the microphone gain of the remote device is changed.
+ * @param[in] callback The callback function to register
+ * @param[in] user_data The user data to be passed to the callback function
+ * @return   0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
+ * @pre The Bluetooth audio service must be initialized with bt_audio_initialize().
+ * @see bt_audio_initialize()
+ * @see bt_ag_unset_microphone_gain_changed_cb()
+ */
+int bt_ag_set_microphone_gain_changed_cb(bt_ag_microphone_gain_changed_cb callback, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
+ * @brief  Unregisters a callback function that will be invoked when the microphone gain of the remote device is changed.
+ * @return   0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
+ * @pre The Bluetooth audio service must be initialized with bt_audio_initialize().
+ * @see bt_audio_initialize()
+ * @see bt_ag_set_microphone_gain_changed_cb()
+ */
+int bt_ag_unset_microphone_gain_changed_cb(void);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE
+ * @brief  Called when the connection state is changed.
+ * @param[in] connected  The state to be changed. @a true means connected state, Otherwise, @a false.
+ * @param[in] remote_address  The remote address
+ * @param[in] user_data The user data passed from the callback registration function
+ * @see bt_avrcp_target_initialize()
+ * @see bt_avrcp_target_deinitialize()
+ */
+typedef void (*bt_avrcp_target_connection_state_changed_cb) (bool connected, const char *remote_address, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE
+ * @brief Initializes the Bluetooth AVRCP(Audio/Video Remote Control Profile) service.
+ * @remarks This function must be called before Bluetooth AVRCP service. \n
+ * You must free all resources of the this service by calling bt_avrcp_target_deinitialize()
+ * if Bluetooth AVRCP service is no longer needed.
+ * @param[in] callback The callback function called when the connection state is changed
+ * @param[in] user_data The user data to be passed to the callback function
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
+ * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @pre The Bluetooth service must be initialized with bt_initialize().
+ * @see bt_initialize()
+ * @see bt_avrcp_target_deinitialize()
+ */
+int bt_avrcp_target_initialize(bt_avrcp_target_connection_state_changed_cb callback, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE
+ * @brief Deinitializes the Bluetooth AVRCP(Audio/Video Remote Control Profile) service.
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @pre The Bluetooth audio service must be initialized with bt_avrcp_target_initialize().
+ * @see bt_avrcp_target_initialize()
+ */
+int bt_avrcp_target_deinitialize(void);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE
+ * @brief  Notify the equalize state to the remote device.
+ * @param[in] state The state of equalizer
+ * @return   0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
+ * @retval #BT_ERROR_NOT_ENABLED  Not enabled
+ * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @retval #BT_ERROR_REMOTE_DEVICE_NOT_CONNECTED  Remote device is not connected
+ * @pre The remote device must be connected.
+ * @see bt_avrcp_target_connection_state_changed_cb()
+ * @see bt_avrcp_target_initialize()
+ */
+int bt_avrcp_target_notify_equalizer_state(bt_avrcp_equalizer_state_e state);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE
+ * @brief  Notify the repeat mode to the remote device.
+ * @param[in] mode The repeat mode
+ * @return   0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
+ * @retval #BT_ERROR_NOT_ENABLED  Not enabled
+ * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @retval #BT_ERROR_REMOTE_DEVICE_NOT_CONNECTED  Remote device is not connected
+ * @pre The remote device must be connected.
+ * @see bt_avrcp_target_connection_state_changed_cb()
+ * @see bt_avrcp_target_initialize()
+ */
+int bt_avrcp_target_notify_repeat_mode(bt_avrcp_repeat_mode_e mode);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE
+ * @brief  Notify the shuffle mode to the remote device.
+ * @param[in] mode The repeat mode
+ * @return   0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
+ * @retval #BT_ERROR_NOT_ENABLED  Not enabled
+ * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @retval #BT_ERROR_REMOTE_DEVICE_NOT_CONNECTED  Remote device is not connected
+ * @pre The remote device must be connected.
+ * @see bt_avrcp_target_connection_state_changed_cb()
+ * @see bt_avrcp_target_initialize()
+ */
+int bt_avrcp_target_notify_shuffle_mode(bt_avrcp_shuffle_mode_e mode);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE
+ * @brief  Notify the scan mode to the remote device.
+ * @param[in] mode The scan mode
+ * @return   0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
+ * @retval #BT_ERROR_NOT_ENABLED  Not enabled
+ * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @retval #BT_ERROR_REMOTE_DEVICE_NOT_CONNECTED  Remote device is not connected
+ * @pre The remote device must be connected.
+ * @see bt_avrcp_target_connection_state_changed_cb()
+ * @see bt_avrcp_target_initialize()
+ */
+int bt_avrcp_target_notify_scan_mode(bt_avrcp_scan_mode_e mode);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE
+ * @brief  Notify the player state to the remote device.
+ * @param[in] state The player state
+ * @return   0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
+ * @retval #BT_ERROR_NOT_ENABLED  Not enabled
+ * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @retval #BT_ERROR_REMOTE_DEVICE_NOT_CONNECTED  Remote device is not connected
+ * @pre The remote device must be connected.
+ * @see bt_avrcp_target_connection_state_changed_cb()
+ * @see bt_avrcp_target_initialize()
+ */
+int bt_avrcp_target_notify_player_state(bt_avrcp_player_state_e state);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE
+ * @brief  Notify the current position of song to the remote device.
+ * @param[in] position The current position in milliseconds
+ * @return  0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
+ * @retval #BT_ERROR_NOT_ENABLED  Not enabled
+ * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @retval #BT_ERROR_REMOTE_DEVICE_NOT_CONNECTED  Remote device is not connected
+ * @pre The remote device must be connected.
+ * @see bt_avrcp_target_connection_state_changed_cb()
+ * @see bt_avrcp_target_initialize()
+ */
+int bt_avrcp_target_notify_position(unsigned int position);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE
+ * @brief  Notify the track to the remote device.
+ * @param[in] title The title of track
+ * @param[in] artist The artist of track
+ * @param[in] album The album of track
+ * @param[in] genre The genre of track
+ * @param[in] track_num The track number
+ * @param[in] total_tracks The number of all tracks
+ * @param[in] duration The duration of track in milliseconds
+ * @return   0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
+ * @retval #BT_ERROR_NOT_ENABLED  Not enabled
+ * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @retval #BT_ERROR_REMOTE_DEVICE_NOT_CONNECTED  Remote device is not connected
+ * @pre The remote device must be connected.
+ * @see bt_avrcp_target_connection_state_changed_cb()
+ * @see bt_avrcp_target_initialize()
+ */
+int bt_avrcp_target_notify_track(const char *title, const char *artist, const char *album, const char *genre, unsigned int track_num, unsigned int total_tracks, unsigned int duration);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_HDP_MODULE
+ * @brief Registers an application that acts as the @a Sink role of HDP(Health Device Profile).
+ * @param[in] data_type  The data type of MDEP. This value is defined in ISO/IEEE 11073-20601 spec.
+ * For example, pulse oximeter is 0x1004 and blood pressure monitor is 0x1007.
+ * @param[out] app_id  The ID of application
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_NOT_ENABLED  Not enabled
+ * @pre The Bluetooth must be enabled with bt_adapter_enable().
+ * @see bt_adapter_enable()
+ * @see bt_hdp_deactivate_sink()
+ */
+int bt_hdp_register_sink_app(unsigned short data_type, char **app_id);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_HDP_MODULE
+ * @brief Unregisters the given application that acts as the @a Sink role of HDP(Health Device Profile).
+ * @param[in] app_id  The ID of application
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_NOT_ENABLED  Not enabled
+ * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @see bt_hdp_register_sink_app()
+ */
+int bt_hdp_unregister_sink_app(const char *app_id);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_HDP_MODULE
+ * @brief Connects the remote device which acts as @a Source role, asynchronously.
+ * @param[in] remote_address  The remote address
+ * @param[in] app_id  The ID of application
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
+ * @retval #BT_ERROR_NOT_ENABLED  Not enabled
+ * @retval #BT_ERROR_REMOTE_DEVICE_NOT_BONDED  Remote device is not bonded
+ * @retval #BT_ERROR_OUT_OF_MEMORY  Out of memory
+ * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @pre The Sink role of HDP must be activated with bt_hdp_activate_sink().
+ * @pre The local device must be bonded with the remote device by bt_device_create_bond().
+ * @post bt_hdp_connected_cb() will be invoked.
+ * @see bt_hdp_disconnect()
+ * @see bt_hdp_set_connection_state_changed_cb()
+ * @see bt_hdp_unset_connection_state_changed_cb()
+ */
+int bt_hdp_connect_to_source(const char *remote_address, const char *app_id);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_HDP_MODULE
+ * @brief Disconnects the remote device, asynchronously.
+ * @param[in] remote_address  The remote address
+ * @param[in] channel  The connected data channel
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
+ * @retval #BT_ERROR_NOT_ENABLED  Not enabled
+ * @retval #BT_ERROR_REMOTE_DEVICE_NOT_CONNECTED  Remote device is not connected
+ * @retval #BT_ERROR_OUT_OF_MEMORY  Out of memory
+ * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @pre The remote device must be connected.
+ * @post bt_hdp_disconnected_cb() will be invoked.
+ * @see bt_hdp_set_connection_state_changed_cb()
+ * @see bt_hdp_unset_connection_state_changed_cb()
+ */
+int bt_hdp_disconnect(const char *remote_address, unsigned int channel);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_HDP_MODULE
+ * @brief Sends the data to the remote device.
+ * @param[in] channel  The connected data channel
+ * @param[in] data  The data to send
+ * @param[in] size  The size of data to send (byte)
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
+ * @retval #BT_ERROR_NOT_ENABLED  Not enabled
+ * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @pre The remote device must be connected.
+ * @see bt_hdp_data_received_cb()
+ * @see bt_hdp_set_data_received_cb()
+ * @see bt_hdp_unset_data_received_cb()
+ */
+int bt_hdp_send_data(unsigned int channel, const char *data, unsigned int size);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_HDP_MODULE
+ * @brief  Called when the connection is established.
+ * @param[in] result  The result of connecting to the remote device
+ * @param[in] remote_address  The address of connected remote device
+ * @param[in] app_id  The ID of application
+ * @param[in] type  The type of HDP(Health Device Profile) channel
+ * @param[in] channel  The connected data channel
+ * @param[in] user_data The user data passed from the callback registration function
+ * @see  bt_hdp_disconnected_cb
+ * @see bt_hdp_set_connection_state_changed_cb()
+ * @see bt_hdp_unset_connection_state_changed_cb()
+ */
+typedef void (*bt_hdp_connected_cb) (int result, const char *remote_address, const char *app_id,
+    bt_hdp_channel_type_e type, unsigned int channel, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_HDP_MODULE
+ * @brief  Called when the connection is disconnected.
+ * @param[in] result  The result of disconnecting from the remote device
+ * @param[in] remote_address  The address of disconnected remote device
+ * @param[in] channel  The connected data channel
+ * @param[in] user_data The user data passed from the callback registration function
+ * @see  bt_hdp_connected_cb
+ * @see bt_hdp_set_connection_state_changed_cb()
+ * @see bt_hdp_unset_connection_state_changed_cb()
+ */
+typedef void (*bt_hdp_disconnected_cb) (int result, const char *remote_address, unsigned int channel, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_HDP_MODULE
+ * @brief  Registers a callback function that will be invoked when the connection state is changed.
+ * @param[in] connected_cb The callback function called when a connection is established
+ * @param[in] disconnected_cb The callback function called when a connection is disconnected
+ * @param[in] user_data The user data to be passed to the callback function
+ * @return   0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
+ * @pre The Bluetooth service must be initialized with bt_initialize().
+ * @see bt_hdp_unset_connection_state_changed_cb()
+ */
+int bt_hdp_set_connection_state_changed_cb(bt_hdp_connected_cb connected_cb, bt_hdp_disconnected_cb disconnected_cb, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_HDP_MODULE
+ * @brief  Unregisters a callback function that will be invoked when the connection state is changed.
+ * @return   0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @pre The Bluetooth service must be initialized with bt_initialize().
+ * @see bt_hdp_set_connection_state_changed_cb()
+ */
+int bt_hdp_unset_connection_state_changed_cb(void);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_HDP_MODULE
+ * @brief  Called when the you receive the data.
+ * @param[in] channel  The connected data channel
+ * @param[in] data  The received data
+ * @param[in] size  The size of received data (byte)
+ * @param[in] user_data The user data passed from the callback registration function
+ * @see bt_hdp_set_data_received_cb()
+ * @see bt_hdp_unset_data_received_cb()
+ */
+typedef void (*bt_hdp_data_received_cb) (unsigned int channel, const char *data, unsigned int size, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_HDP_MODULE
+ * @brief  Registers a callback function that will be invoked when you receive the data.
+ * @param[in] callback The callback function to register
+ * @param[in] user_data The user data to be passed to the callback function
+ * @return   0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
+ * @pre The Bluetooth service must be initialized with bt_initialize().
+ * @see bt_hdp_unset_data_received_cb()
+ */
+int bt_hdp_set_data_received_cb(bt_hdp_data_received_cb callback, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_HDP_MODULE
+ * @brief  Unregisters a callback function that will be invoked when you receive the data.
+ * @return   0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @pre The Bluetooth service must be initialized with bt_initialize().
+ * @see bt_hdp_set_data_received_cb()
+ */
+int bt_hdp_unset_data_received_cb(void);
 
 /**
  * @}
  */
 
+
 #ifdef __cplusplus
 }
 #endif /* __cplusplus */
diff --git a/include/bluetooth_private.h b/include/bluetooth_private.h
index 8727d4c..5135d81 100644
--- a/include/bluetooth_private.h
+++ b/include/bluetooth_private.h
@@ -13,18 +13,29 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
- 
+
 
 #ifndef __TIZEN_NETWORK_BLUETOOTH_PRIVATE_H__
 #define __TIZEN_NETWORK_BLUETOOTH_PRIVATE_H__
 
+#include <dlog.h>
+#include <stdbool.h>
+#include <bluetooth-api.h>
+#include <bluetooth-audio-api.h>
+#include <bluetooth-media-control.h>
+#include <bluetooth-hid-api.h>
+
+#include "bluetooth.h"
+
 #ifdef __cplusplus
 extern "C" {
 #endif
 
+#define OPP_UUID "00001105-0000-1000-8000-00805f9b34fb"
+
 /**
  * @internal
- * @brief Bluetooth callback. 
+ * @brief Bluetooth callback.
  */
 typedef enum
 {
@@ -38,6 +49,24 @@ typedef enum
 	BT_EVENT_SERVICE_SEARCHED, /**< Service search finish */
 	BT_EVENT_DATA_RECEIVED, /**< Data is received */
 	BT_EVENT_CONNECTION_STATE_CHANGED, /**< Connection state is changed */
+	BT_EVENT_RFCOMM_CONNECTION_REQUESTED, /**< RFCOMM connection is requested */
+	BT_EVENT_OPP_CONNECTION_REQUESTED, /**< OPP connection is requested */
+	BT_EVENT_OPP_PUSH_REQUESTED, /**< OPP push is requested */
+	BT_EVENT_OPP_SERVER_TRANSFER_PROGRESS, /**< OPP transfer progress */
+	BT_EVENT_OPP_SERVER_TRANSFER_FINISHED, /**< OPP transfer is completed */
+	BT_EVENT_OPP_CLIENT_PUSH_RESPONSED, /**< OPP client connection is reponsed */
+	BT_EVENT_OPP_CLIENT_PUSH_PROGRESS, /**< OPP client push progress */
+	BT_EVENT_OPP_CLIENT_PUSH_FINISHED, /**< OPP client push is finished */
+	BT_EVENT_PAN_CONNECTION_STATE_CHANGED, /**< PAN connection change */
+	BT_EVENT_NAP_CONNECTION_STATE_CHANGED, /**< NAP connection change */
+	BT_EVENT_HDP_CONNECTED, /**< HDP connection change */
+	BT_EVENT_HDP_DISCONNECTED, /**< HDP disconnection change */
+	BT_EVENT_HDP_DATA_RECIEVED, /**< HDP Data recieve Callabck */
+	BT_EVENT_AUDIO_CONNECTION_STATUS, /**< Audio Connection change callback */
+	BT_EVENT_AG_MICROPHONE_GAIN_CHANGE, /**< Audio Microphone change callback */
+	BT_EVENT_AG_SPEAKER_GAIN_CHANGE, /**< Audio Speaker gain change callback */
+	BT_EVENT_AVRCP_CONNECTION_STATUS, /**< AVRCP connection change callback */
+	BT_EVENT_HID_CONNECTION_STATUS /**< HID connection status callback */
 } bt_event_e;
 
 /**
@@ -46,16 +75,54 @@ typedef enum
 typedef struct bt_event_sig_event_slot_s
 {
     int event_type;
-    const void* callback;
-    void* user_data;
+    const void *callback;
+    void *user_data;
 } bt_event_sig_event_slot_s;
 
 
+#define BT_CHECK_INPUT_PARAMETER(arg) \
+	if (arg == NULL) \
+	{ \
+		LOGE("[%s] INVALID_PARAMETER(0x%08x)", __FUNCTION__, BT_ERROR_INVALID_PARAMETER); \
+		return BT_ERROR_INVALID_PARAMETER; \
+	}
+
+/**
+ * @internal
+ * @brief Check the initialzating status
+ */
+int _bt_check_init_status(void);
+
+#define BT_CHECK_INIT_STATUS() \
+	if (_bt_check_init_status() == BT_ERROR_NOT_INITIALIZED) \
+	{ \
+		LOGE("[%s] NOT_INITIALIZED(0x%08x)", __FUNCTION__, BT_ERROR_NOT_INITIALIZED); \
+		return BT_ERROR_NOT_INITIALIZED; \
+	}
+
+/**
+ * @internal
+ * @brief Set the event callback.
+ */
+void _bt_set_cb(int events, void *callback, void *user_data);
+
+/**
+ * @internal
+ * @brief Unset the event callback.
+ */
+void _bt_unset_cb(int events);
+
+/**
+ * @internal
+ * @brief Check if the event callback exist or not.
+ */
+bool _bt_check_cb(int events);
+
 /**
  * @internal
  * @brief Convert Bluetooth F/W error codes to capi Bluetooth error codes.
  */
-int _bt_get_error_code(int origin_error); 
+int _bt_get_error_code(int origin_error);
 
 
 /**
@@ -82,7 +149,7 @@ int _bt_convert_address_to_string(char **addr_str, bluetooth_device_address_t *a
  * @internal
  * @brief Convert string to Bluetooth F/W bluetooth_device_address_t.
  */
-void _bt_convert_address_to_hex(bluetooth_device_address_t* addr_hex, const char* addr_str);
+void _bt_convert_address_to_hex(bluetooth_device_address_t *addr_hex, const char *addr_str);
 
 
 /**
@@ -91,6 +158,30 @@ void _bt_convert_address_to_hex(bluetooth_device_address_t* addr_hex, const char
  */
 char* _bt_convert_error_to_string(int error);
 
+/**
+ * @internal
+ * @brief Convert the visibility mode
+ */
+bt_adapter_visibility_mode_e _bt_get_bt_visibility_mode_e(bluetooth_discoverable_mode_t mode);
+
+/**
+ * @internal
+ * @brief Since the Audio call back and event proxy call backs have different prototype it is wrapper function.
+ */
+void _bt_audio_event_proxy(int event, bt_audio_event_param_t *param, void *user_data);
+
+/**
+ * @internal
+ * @brief Since the AVRCP call back and event proxy call backs have different prototype it is wrapper function.
+ */
+void _bt_avrcp_event_proxy(int event, media_event_param_t *param, void *user_data);
+
+/**
+ * @internal
+ * @brief Since the HID call back and event proxy call backs have different prototype it is wrapper function.
+ */
+void _bt_hid_event_proxy(int event, hid_event_param_t *param, void *user_data);
+
 
 #ifdef __cplusplus
 }
diff --git a/packaging/capi-network-bluetooth.spec b/packaging/capi-network-bluetooth.spec
index 3a5f868..30c618d 100644
--- a/packaging/capi-network-bluetooth.spec
+++ b/packaging/capi-network-bluetooth.spec
@@ -1,9 +1,10 @@
+#sbs-git:slp/api/bluetooth capi-network-bluetooth 0.1.0 686c444083e4197845c768e5dd034022b1dfa250
 Name:       capi-network-bluetooth
 Summary:    Network Bluetooth Framework
-Version: 0.1.2
+Version: 0.1.12
 Release:    1
 Group:      TO_BE/FILLED_IN
-License:    Apache-2.0
+License:    TO BE FILLED IN
 Source0:    %{name}-%{version}.tar.gz
 Requires(post): /sbin/ldconfig
 Requires(postun): /sbin/ldconfig
diff --git a/src/bluetooth-adapter.c b/src/bluetooth-adapter.c
new file mode 100644
index 0000000..da0f9c8
--- /dev/null
+++ b/src/bluetooth-adapter.c
@@ -0,0 +1,424 @@
+/*
+ * Copyright (c) 2011 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 <glib.h>
+#include <string.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <dlog.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include <bluetooth-api.h>
+
+#include "bluetooth.h"
+#include "bluetooth_private.h"
+
+#ifdef LOG_TAG
+#undef LOG_TAG
+#endif
+#define LOG_TAG "TIZEN_N_BLUETOOTH"
+
+
+int bt_adapter_enable(void)
+{
+	int error_code = BT_ERROR_NONE;
+
+	BT_CHECK_INIT_STATUS();
+	error_code = _bt_get_error_code(bluetooth_enable_adapter());
+	if (error_code != BT_ERROR_NONE) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(error_code), error_code);
+	}
+	return error_code;
+}
+
+int bt_adapter_disable(void)
+{
+	int error_code = BT_ERROR_NONE;
+
+	BT_CHECK_INIT_STATUS();
+	error_code = _bt_get_error_code(bluetooth_disable_adapter());
+	if (error_code != BT_ERROR_NONE) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(error_code), error_code);
+	}
+	return error_code;
+}
+
+int bt_adapter_get_state(bt_adapter_state_e *adapter_state)
+{
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(adapter_state);
+
+	*adapter_state = bluetooth_check_adapter();
+	return BT_ERROR_NONE;
+}
+
+int bt_adapter_get_address(char **address)
+{
+	bluetooth_device_address_t loc_address = { {0} };
+	int error_code = BT_ERROR_NONE;
+
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(address);
+
+	error_code = _bt_get_error_code(bluetooth_get_local_address(&loc_address));
+	if (error_code != BT_ERROR_NONE) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(error_code), error_code);
+		return error_code;
+	}
+
+	error_code = _bt_convert_address_to_string(address, &loc_address);
+	if (error_code != BT_ERROR_NONE) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(error_code), error_code);
+		return error_code;
+	}
+
+	return BT_ERROR_NONE;
+}
+
+int bt_adapter_get_name(char **name)
+{
+	int ret = BT_ERROR_NONE;
+	bluetooth_device_name_t loc_name = { {0} };
+
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(name);
+
+	ret = _bt_get_error_code(bluetooth_get_local_name(&loc_name));
+	if (ret != BT_ERROR_NONE) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
+		return ret;
+	}
+
+	*name = strdup(loc_name.name);
+	if (*name == NULL) {
+		LOGE("[%s] OUT_OF_MEMORY(0x%08x)", __FUNCTION__, BT_ERROR_OUT_OF_MEMORY);
+		return BT_ERROR_OUT_OF_MEMORY;
+	}
+
+	return BT_ERROR_NONE;
+}
+
+int bt_adapter_set_name(const char *name)
+{
+	bluetooth_device_name_t loc_name = { {0} };
+	int ret = BT_ERROR_NONE;
+
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(name);
+
+	strncpy(loc_name.name, name, BLUETOOTH_DEVICE_NAME_LENGTH_MAX);
+	loc_name.name[BLUETOOTH_DEVICE_NAME_LENGTH_MAX] = '\0';
+
+	ret = _bt_get_error_code(bluetooth_set_local_name(&loc_name));
+	if (ret != BT_ERROR_NONE) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
+	}
+
+	return ret;
+}
+
+int bt_adapter_get_visibility(bt_adapter_visibility_mode_e *mode)
+{
+	bluetooth_discoverable_mode_t discoverable_mode = BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE;
+	int ret = BT_ERROR_NONE;
+
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(mode);
+
+	ret = _bt_get_error_code(bluetooth_get_discoverable_mode(&discoverable_mode));
+	if (ret != BT_ERROR_NONE) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
+		return ret;
+	}
+
+	*mode = _bt_get_bt_visibility_mode_e(discoverable_mode);
+	return BT_ERROR_NONE;
+}
+
+int bt_adapter_set_visibility(bt_adapter_visibility_mode_e visibility_mode, int timeout_sec)
+{
+	bluetooth_discoverable_mode_t discoverable_mode = BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE;
+	int error_code = BT_ERROR_NONE;
+
+	BT_CHECK_INIT_STATUS();
+	switch (visibility_mode) {
+	case BT_ADAPTER_VISIBILITY_MODE_LIMITED_DISCOVERABLE:
+		discoverable_mode = BLUETOOTH_DISCOVERABLE_MODE_TIME_LIMITED_DISCOVERABLE;
+		break;
+	case BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE:
+		discoverable_mode = BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE;
+		timeout_sec = 0;
+		break;
+	case BT_ADAPTER_VISIBILITY_MODE_GENERAL_DISCOVERABLE:
+		discoverable_mode = BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE;
+		timeout_sec = 0;
+		break;
+	default:
+		LOGE("[%s] INVALID_PARAMETER(0x%08x)", __FUNCTION__, BT_ERROR_INVALID_PARAMETER);
+		return BT_ERROR_INVALID_PARAMETER;
+	}
+
+	error_code = _bt_get_error_code(bluetooth_set_discoverable_mode(discoverable_mode, timeout_sec));
+	if (error_code != BT_ERROR_NONE) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(error_code), error_code);
+	}
+
+	return error_code;
+}
+
+int bt_adapter_foreach_bonded_device(bt_adapter_bonded_device_cb foreach_cb, void *user_data)
+{
+	GPtrArray *dev_list = NULL;
+	bt_device_info_s *dev_info = NULL;
+	bluetooth_device_info_t *ptr = NULL;
+	int ret = BT_ERROR_NONE;
+	int i = 0;
+
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(foreach_cb);
+
+	dev_list = g_ptr_array_new();
+	if (dev_list == NULL) {
+		LOGE("[%s] OUT_OF_MEMORY(0x%08x)", __FUNCTION__, BT_ERROR_OUT_OF_MEMORY);
+		return BT_ERROR_OUT_OF_MEMORY;
+	}
+
+	ret = _bt_get_error_code(bluetooth_get_bonded_device_list(&dev_list));
+	if (ret != BT_ERROR_NONE) {
+		LOGE("[%s] %s(0x%08x) : Failed to get bonded device list", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
+		return ret;
+	}
+
+	for (i = 0; i < dev_list->len; i++) {
+		ptr = g_ptr_array_index(dev_list, i);
+		if (ptr != NULL) {
+			ret = _bt_get_bt_device_info_s(&dev_info, (bluetooth_device_info_t *)ptr);
+			if (ret != BT_ERROR_NONE) {
+				LOGE("[%s] %s(0x%08x) : Failed to get device info", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
+				break;
+			}
+
+			if (!foreach_cb(dev_info, user_data)) {
+				_bt_free_bt_device_info_s(dev_info);
+				break;
+			}
+			_bt_free_bt_device_info_s(dev_info);
+		} else {
+			LOGE("[%s] OPERATION_FAILED(0x%08x)", __FUNCTION__, BT_ERROR_OPERATION_FAILED);
+			ret = BT_ERROR_OPERATION_FAILED;
+			break;
+		}
+	}
+
+	if (dev_list != NULL) {
+		g_ptr_array_free(dev_list, TRUE);
+	}
+
+	return ret;
+}
+
+int bt_adapter_get_bonded_device_info(const char *remote_address, bt_device_info_s **device_info)
+{
+	int ret;
+	bluetooth_device_address_t addr_hex = { {0,} };
+	bluetooth_device_info_t *info;
+
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(remote_address);
+
+	info = (bluetooth_device_info_t *)malloc(sizeof(bluetooth_device_info_t));
+	if (info == NULL)
+		return BT_ERROR_OUT_OF_MEMORY;
+
+	_bt_convert_address_to_hex(&addr_hex, remote_address);
+
+	ret = _bt_get_error_code(bluetooth_get_bonded_device(&addr_hex, info));
+	if (ret != BT_ERROR_NONE) {
+		LOGE("[%s] %s(0x%08x) : Failed to run function", __FUNCTION__,
+					_bt_convert_error_to_string(ret), ret);
+	} else {
+		ret = _bt_get_bt_device_info_s(device_info, info);
+		if (ret != BT_ERROR_NONE) {
+			LOGE("[%s] %s(0x%08x) : Failed to get device info",
+						__FUNCTION__,
+						_bt_convert_error_to_string(ret),
+						ret);
+		}
+	}
+
+	free(info);
+
+	return ret;
+}
+
+int bt_adapter_free_device_info(bt_device_info_s *device_info)
+{
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(device_info);
+
+	_bt_free_bt_device_info_s(device_info);
+
+	return BT_ERROR_NONE;
+}
+
+int bt_adapter_is_service_used(const char *service_uuid, bool *used)
+{
+	int ret = BT_ERROR_NONE;
+
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(service_uuid);
+	BT_CHECK_INPUT_PARAMETER(used);
+
+	if (strcmp(service_uuid, OPP_UUID) == 0) {
+		*used = bluetooth_obex_server_is_activated();
+	} else {
+		ret = _bt_get_error_code(bluetooth_is_service_used(service_uuid,
+							(gboolean *)used));
+	}
+
+	if (ret != BT_ERROR_NONE) {
+		LOGE("[%s] %s(0x%08x) : Failed to run function", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
+	}
+
+	return ret;
+}
+
+int bt_adapter_set_state_changed_cb(bt_adapter_state_changed_cb callback, void *user_data)
+{
+	int ret = BT_ERROR_NONE;
+
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(callback);
+	_bt_set_cb(BT_EVENT_STATE_CHANGED, callback, user_data);
+	if (ret != BT_ERROR_NONE) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
+	}
+
+	return ret;
+}
+
+int bt_adapter_set_name_changed_cb(bt_adapter_name_changed_cb callback, void *user_data)
+{
+	int ret = BT_ERROR_NONE;
+
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(callback);
+	_bt_set_cb(BT_EVENT_NAME_CHANGED, callback, user_data);
+	if (ret != BT_ERROR_NONE) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
+	}
+
+	return ret;
+}
+
+int bt_adapter_set_visibility_mode_changed_cb(bt_adapter_visibility_mode_changed_cb callback, void *user_data)
+{
+	int ret = BT_ERROR_NONE;
+
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(callback);
+	_bt_set_cb(BT_EVENT_VISIBILITY_MODE_CHANGED, callback, user_data);
+	if (ret != BT_ERROR_NONE) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
+	}
+
+	return ret;
+}
+
+int bt_adapter_set_device_discovery_state_changed_cb(bt_adapter_device_discovery_state_changed_cb callback, void *user_data)
+{
+	int ret = BT_ERROR_NONE;
+
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(callback);
+	_bt_set_cb(BT_EVENT_DEVICE_DISCOVERY_STATE_CHANGED, callback, user_data);
+	if (ret != BT_ERROR_NONE) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
+	}
+
+	return ret;
+}
+
+int bt_adapter_unset_state_changed_cb(void)
+{
+	BT_CHECK_INIT_STATUS();
+	_bt_unset_cb(BT_EVENT_STATE_CHANGED);
+	return BT_ERROR_NONE;
+}
+
+int bt_adapter_unset_name_changed_cb(void)
+{
+	BT_CHECK_INIT_STATUS();
+	_bt_unset_cb(BT_EVENT_NAME_CHANGED);
+	return BT_ERROR_NONE;
+}
+
+int bt_adapter_unset_visibility_mode_changed_cb(void)
+{
+	BT_CHECK_INIT_STATUS();
+	_bt_unset_cb(BT_EVENT_VISIBILITY_MODE_CHANGED);
+	return BT_ERROR_NONE;
+}
+
+int bt_adapter_unset_device_discovery_state_changed_cb(void)
+{
+	BT_CHECK_INIT_STATUS();
+	_bt_unset_cb(BT_EVENT_DEVICE_DISCOVERY_STATE_CHANGED);
+	return BT_ERROR_NONE;
+}
+
+int bt_adapter_start_device_discovery(void)
+{
+	int error_code = BT_ERROR_NONE;
+
+	BT_CHECK_INIT_STATUS();
+	error_code = _bt_get_error_code(bluetooth_start_discovery(0, 0, BLUETOOTH_DEVICE_MAJOR_MASK_MISC));
+	if (error_code != BT_ERROR_NONE) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(error_code), error_code);
+	}
+	return error_code;
+}
+
+int bt_adapter_stop_device_discovery(void)
+{
+	int error_code = BT_ERROR_NONE;
+
+	BT_CHECK_INIT_STATUS();
+	error_code = _bt_get_error_code(bluetooth_cancel_discovery());
+	if (error_code != BT_ERROR_NONE) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(error_code), error_code);
+	}
+	return error_code;
+}
+
+int bt_adapter_is_discovering(bool *is_discovering)
+{
+	int ret = 0;
+
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(is_discovering);
+
+	ret = bluetooth_is_discovering();
+	if (ret >= BLUETOOTH_ERROR_BASE) {
+		*is_discovering = (ret == 1) ? true : false;
+		return BT_ERROR_NONE;
+	} else {
+		ret = _bt_get_error_code(ret);
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
+		return ret;
+	}
+}
+
diff --git a/src/bluetooth-audio.c b/src/bluetooth-audio.c
new file mode 100644
index 0000000..6ce6abd
--- /dev/null
+++ b/src/bluetooth-audio.c
@@ -0,0 +1,218 @@
+/*
+ * Copyright (c) 2011 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 <dlog.h>
+#include <stdbool.h>
+#include <bluetooth-api.h>
+#include <string.h>
+#include "bluetooth.h"
+#include "bluetooth_private.h"
+#include "bluetooth-audio-api.h"
+
+#ifdef LOG_TAG
+#undef LOG_TAG
+#endif
+#define LOG_TAG "TIZEN_N_BLUETOOTH"
+
+/*The below API is just to convert the error from Audio API's to CAPI error codes,
+* this is temporary change and changes to proper error code will be done in
+* subsequent check ins.*/
+int _bt_convert_media_error_code(int error)
+{
+	switch(error) {
+	case BLUETOOTH_AUDIO_ERROR_NONE:
+		return BT_ERROR_NONE;
+	case BLUETOOTH_AUDIO_ERROR_INTERNAL:
+		return BT_ERROR_INVALID_PARAMETER;
+	case BLUETOOTH_AUDIO_ERROR_INVALID_PARAM:
+		return BT_ERROR_INVALID_PARAMETER;
+	case BLUETOOTH_AG_ERROR_CONNECTION_ERROR:
+		return BT_ERROR_OPERATION_FAILED;
+	case BLUETOOTH_AV_ERROR_CONNECTION_ERROR:
+		return BT_ERROR_OPERATION_FAILED;
+	default:
+		return BT_ERROR_NONE;
+	}
+}
+int bt_audio_initialize(void)
+{
+	int error = BT_ERROR_NONE;
+
+	BT_CHECK_INIT_STATUS();
+	error = bluetooth_audio_init(_bt_audio_event_proxy, NULL);
+	error = _bt_convert_media_error_code(error);
+	error = _bt_get_error_code(error);
+	if (BT_ERROR_NONE != error) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__,
+			_bt_convert_error_to_string(error), error);
+	}
+	return error;
+}
+
+int bt_audio_deinitialize(void)
+{
+	int error = BT_ERROR_NONE;
+
+	BT_CHECK_INIT_STATUS();
+
+	error = bluetooth_audio_deinit();
+	error = _bt_convert_media_error_code(error);
+	error = _bt_get_error_code(error);
+	if (BT_ERROR_NONE != error) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__,
+			_bt_convert_error_to_string(error), error);
+	}
+	return error;
+}
+
+int bt_audio_connect(const char *remote_address, bt_audio_profile_type_e type)
+{
+	int error = BT_ERROR_NONE;
+	bluetooth_device_address_t addr_hex = { {0,} };
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(remote_address);
+	_bt_convert_address_to_hex(&addr_hex, remote_address);
+	switch(type) {
+	case BT_AUDIO_PROFILE_TYPE_HSP_HFP:
+		error = bluetooth_ag_connect(&addr_hex);
+		break;
+	case BT_AUDIO_PROFILE_TYPE_A2DP:
+		error = bluetooth_av_connect(&addr_hex);
+		break;
+	case BT_AUDIO_PROFILE_TYPE_ALL:
+	default:
+		error = bluetooth_audio_connect(&addr_hex);
+		break;
+	}
+	error = _bt_convert_media_error_code(error);
+	error = _bt_get_error_code(error);
+	if (error != BT_ERROR_NONE) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__,
+			_bt_convert_error_to_string(error), error);
+	}
+	return error;
+}
+
+int bt_audio_disconnect(const char *remote_address, bt_audio_profile_type_e type)
+{
+	int error = BT_ERROR_NONE;
+	bluetooth_device_address_t addr_hex = { {0,} };
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(remote_address);
+	_bt_convert_address_to_hex(&addr_hex, remote_address);
+	switch(type) {
+	case BT_AUDIO_PROFILE_TYPE_HSP_HFP:
+		error = bluetooth_ag_disconnect(&addr_hex);
+		break;
+	case BT_AUDIO_PROFILE_TYPE_A2DP:
+		error = bluetooth_av_disconnect(&addr_hex);
+		break;
+	case BT_AUDIO_PROFILE_TYPE_ALL:
+	default:
+		error = bluetooth_audio_disconnect(&addr_hex);
+		break;
+	}
+	error = _bt_convert_media_error_code(error);
+	error = _bt_get_error_code(error);
+	if (error != BT_ERROR_NONE) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__,
+			_bt_convert_error_to_string(error), error);
+	}
+	return error;
+}
+
+int bt_audio_set_connection_state_changed_cb(bt_audio_connection_state_changed_cb callback, void *user_data)
+{
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(callback);
+	_bt_set_cb(BT_EVENT_AUDIO_CONNECTION_STATUS, callback, user_data);
+	return BT_ERROR_NONE;
+
+}
+int bt_audio_unset_connection_state_changed_cb(void)
+{
+	BT_CHECK_INIT_STATUS();
+	if (_bt_check_cb(BT_EVENT_AUDIO_CONNECTION_STATUS) == true)
+		_bt_unset_cb(BT_EVENT_AUDIO_CONNECTION_STATUS);
+	return BT_ERROR_NONE;
+}
+
+int bt_ag_notify_speaker_gain(const char *remote_address, int gain)
+{
+	int error = BT_ERROR_NONE;
+
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(remote_address);
+	error = bluetooth_ag_set_speaker_gain((unsigned short)gain);
+	error = _bt_convert_media_error_code(error);
+	error = _bt_get_error_code(error);
+	if (BT_ERROR_NONE != error) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__,
+			_bt_convert_error_to_string(error), error);
+	}
+	return error;
+}
+
+int bt_ag_get_speaker_gain(const char *remote_address, int *gain)
+{
+	int error = BT_ERROR_NONE;
+
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(gain);
+	BT_CHECK_INPUT_PARAMETER(remote_address);
+	error = bluetooth_ag_get_headset_volume((unsigned int *)gain);
+	error = _bt_convert_media_error_code(error);
+	error = _bt_get_error_code(error);
+	if (BT_ERROR_NONE != error) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__,
+			_bt_convert_error_to_string(error), error);
+	}
+	return error;
+}
+
+int bt_ag_set_microphone_gain_changed_cb(bt_ag_microphone_gain_changed_cb callback, void *user_data)
+{
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(callback);
+	_bt_set_cb(BT_EVENT_AG_MICROPHONE_GAIN_CHANGE, callback, user_data);
+	return BT_ERROR_NONE;
+
+}
+
+int bt_ag_unset_microphone_gain_changed_cb(void)
+{
+	BT_CHECK_INIT_STATUS();
+	if (_bt_check_cb(BT_EVENT_AG_MICROPHONE_GAIN_CHANGE) == true)
+		_bt_unset_cb(BT_EVENT_AG_MICROPHONE_GAIN_CHANGE);
+	return BT_ERROR_NONE;
+}
+
+int bt_ag_set_speaker_gain_changed_cb(bt_ag_speaker_gain_changed_cb callback,
+					void *user_data)
+{
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(callback);
+	_bt_set_cb(BT_EVENT_AG_SPEAKER_GAIN_CHANGE, callback, user_data);
+	return BT_ERROR_NONE;
+}
+
+int bt_ag_unset_speaker_gain_changed_cb(void)
+{
+	BT_CHECK_INIT_STATUS();
+	if (_bt_check_cb(BT_EVENT_AG_SPEAKER_GAIN_CHANGE) == true)
+		_bt_unset_cb(BT_EVENT_AG_SPEAKER_GAIN_CHANGE);
+	return BT_ERROR_NONE;
+}
diff --git a/src/bluetooth-avrcp.c b/src/bluetooth-avrcp.c
new file mode 100644
index 0000000..b20a5c5
--- /dev/null
+++ b/src/bluetooth-avrcp.c
@@ -0,0 +1,185 @@
+/*
+ * Copyright (c) 2011 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 <dlog.h>
+#include <stdbool.h>
+#include <bluetooth-api.h>
+#include "bluetooth.h"
+#include "bluetooth_private.h"
+#include "bluetooth-audio-api.h"
+#include "bluetooth-media-control.h"
+#ifdef LOG_TAG
+#undef LOG_TAG
+#endif
+#define LOG_TAG "TIZEN_N_BLUETOOTH"
+
+/*The below API is just to conver the error from Audio API's to CAPI error codes,
+* this is temporary change and changes to proper error code will be done in
+* subsequent check ins.*/
+int _bt_convert_avrcp_error_code(int error)
+{
+	switch(error) {
+	case BT_MEDIA_ERROR_NONE:
+		return BT_ERROR_NONE;
+	case BT_MEDIA_ERROR_INTERNAL:
+		return BT_ERROR_INVALID_PARAMETER;
+	case BT_MEDIA_ERROR_ALREADY_INITIALIZED:
+		return BT_ERROR_OPERATION_FAILED;
+	default:
+		return BT_ERROR_NONE;
+	}
+}
+
+int bt_avrcp_target_initialize(bt_avrcp_target_connection_state_changed_cb callback, void *user_data)
+{
+	int error;
+
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(callback);
+	_bt_set_cb(BT_EVENT_AVRCP_CONNECTION_STATUS, callback, user_data);
+	error = bluetooth_media_player_init(_bt_avrcp_event_proxy, NULL);
+	error = _bt_convert_avrcp_error_code(error);
+	error = _bt_get_error_code(error);
+	if (BT_ERROR_NONE != error) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__,
+			_bt_convert_error_to_string(error), error);
+	}
+	return error;
+}
+
+int bt_avrcp_target_deinitialize(void)
+{
+	int error;
+
+	BT_CHECK_INIT_STATUS();
+	if (_bt_check_cb(BT_EVENT_AVRCP_CONNECTION_STATUS) == true)
+		_bt_unset_cb(BT_EVENT_AVRCP_CONNECTION_STATUS);
+
+	error = bluetooth_media_player_deinit();
+	error = _bt_convert_avrcp_error_code(error);
+
+	error = _bt_get_error_code(error);
+	if (BT_ERROR_NONE != error) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__,
+			_bt_convert_error_to_string(error), error);
+	}
+	return error;
+}
+
+int bt_avrcp_target_notify_equalizer_state(bt_avrcp_equalizer_state_e state)
+{
+	int error;
+	BT_CHECK_INIT_STATUS();
+	error = bluetooth_media_player_change_property(EQUILIZER, state);
+	error = _bt_convert_avrcp_error_code(error);
+	error = _bt_get_error_code(error);
+	if (BT_ERROR_NONE != error) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__,
+			_bt_convert_error_to_string(error), error);
+	}
+	return error;
+}
+int bt_avrcp_target_notify_repeat_mode(bt_avrcp_repeat_mode_e mode)
+{
+	int error;
+	BT_CHECK_INIT_STATUS();
+	error = bluetooth_media_player_change_property(REPEAT, mode);
+	error = _bt_convert_avrcp_error_code(error);
+	error = _bt_get_error_code(error);
+	if (BT_ERROR_NONE != error) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__,
+			_bt_convert_error_to_string(error), error);
+	}
+	return error;
+}
+
+int bt_avrcp_target_notify_shuffle_mode(bt_avrcp_shuffle_mode_e mode)
+{
+	int error;
+	BT_CHECK_INIT_STATUS();
+	error = bluetooth_media_player_change_property(SHUFFLE, mode);
+	error = _bt_convert_avrcp_error_code(error);
+	error = _bt_get_error_code(error);
+	if (BT_ERROR_NONE != error) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__,
+			_bt_convert_error_to_string(error), error);
+	}
+	return error;
+}
+int bt_avrcp_target_notify_scan_mode(bt_avrcp_scan_mode_e mode)
+{
+	int error;
+	BT_CHECK_INIT_STATUS();
+	error = bluetooth_media_player_change_property(SCAN, mode);
+	error = _bt_convert_avrcp_error_code(error);
+	error = _bt_get_error_code(error);
+	if (BT_ERROR_NONE != error) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__,
+			_bt_convert_error_to_string(error), error);
+	}
+	return error;
+}
+
+int bt_avrcp_target_notify_player_state(bt_avrcp_player_state_e state)
+{
+	int error;
+	BT_CHECK_INIT_STATUS();
+	error = bluetooth_media_player_change_property(STATUS, state);
+	error = _bt_convert_avrcp_error_code(error);
+	error = _bt_get_error_code(error);
+	if (BT_ERROR_NONE != error) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__,
+			_bt_convert_error_to_string(error), error);
+	}
+	return error;
+}
+
+int bt_avrcp_target_notify_position(unsigned int position)
+{
+	int error;
+	BT_CHECK_INIT_STATUS();
+	error = bluetooth_media_player_change_property(POSITION, position);
+	error = _bt_convert_avrcp_error_code(error);
+	error = _bt_get_error_code(error);
+	if (BT_ERROR_NONE != error) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__,
+			_bt_convert_error_to_string(error), error);
+	}
+	return error;
+}
+
+int bt_avrcp_target_notify_track(const char *title, const char *artist, const char *album,
+		const char *genre, unsigned int track_num, unsigned int total_tracks, unsigned int duration)
+{
+	int error;
+	BT_CHECK_INIT_STATUS();
+	media_metadata_attributes_t metadata;
+	metadata.title = title;
+	metadata.artist = artist;
+	metadata.duration = duration;
+	metadata.genre = genre;
+	metadata.number = track_num;
+	metadata.album = album;
+	metadata.total_tracks = total_tracks;
+	error = bluetooth_media_player_change_track(&metadata);
+	error = _bt_convert_avrcp_error_code(error);
+	error = _bt_get_error_code(error);
+	if (BT_ERROR_NONE != error) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__,
+			_bt_convert_error_to_string(error), error);
+	}
+	return error;
+}
diff --git a/src/bluetooth-common.c b/src/bluetooth-common.c
new file mode 100644
index 0000000..3df52a6
--- /dev/null
+++ b/src/bluetooth-common.c
@@ -0,0 +1,1028 @@
+/*
+ * Copyright (c) 2011 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 <glib.h>
+#include <string.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <dlog.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include <bluetooth-api.h>
+
+#include "bluetooth.h"
+#include "bluetooth_private.h"
+#include "bluetooth-media-control.h"
+#ifdef LOG_TAG
+#undef LOG_TAG
+#endif
+#define LOG_TAG "TIZEN_N_BLUETOOTH"
+
+static bool is_initialized = false;
+static bt_event_sig_event_slot_s bt_event_slot_container[] = {
+	{BT_EVENT_STATE_CHANGED, NULL, NULL},
+	{BT_EVENT_NAME_CHANGED, NULL, NULL},
+	{BT_EVENT_VISIBILITY_MODE_CHANGED, NULL, NULL},
+	{BT_EVENT_DEVICE_DISCOVERY_STATE_CHANGED, NULL, NULL},
+	{BT_EVENT_BOND_CREATED, NULL, NULL},
+	{BT_EVENT_BOND_DESTROYED, NULL, NULL},
+	{BT_EVENT_AUTHORIZATION_CHANGED, NULL, NULL},
+	{BT_EVENT_SERVICE_SEARCHED, NULL, NULL},
+	{BT_EVENT_DATA_RECEIVED, NULL, NULL},
+	{BT_EVENT_CONNECTION_STATE_CHANGED, NULL, NULL},
+	{BT_EVENT_RFCOMM_CONNECTION_REQUESTED, NULL, NULL},
+	{BT_EVENT_OPP_CONNECTION_REQUESTED, NULL, NULL},
+	{BT_EVENT_OPP_PUSH_REQUESTED, NULL, NULL},
+	{BT_EVENT_OPP_SERVER_TRANSFER_PROGRESS, NULL, NULL},
+	{BT_EVENT_OPP_SERVER_TRANSFER_FINISHED, NULL, NULL},
+	{BT_EVENT_OPP_CLIENT_PUSH_RESPONSED, NULL, NULL},
+	{BT_EVENT_OPP_CLIENT_PUSH_PROGRESS, NULL, NULL},
+	{BT_EVENT_OPP_CLIENT_PUSH_FINISHED, NULL, NULL},
+	{BT_EVENT_PAN_CONNECTION_STATE_CHANGED, NULL, NULL},
+	{BT_EVENT_NAP_CONNECTION_STATE_CHANGED, NULL, NULL},
+	{BT_EVENT_HDP_CONNECTED, NULL, NULL},
+	{BT_EVENT_HDP_DISCONNECTED, NULL, NULL},
+	{BT_EVENT_HDP_DATA_RECIEVED, NULL, NULL},
+	{BT_EVENT_AUDIO_CONNECTION_STATUS, NULL, NULL},
+	{BT_EVENT_AG_MICROPHONE_GAIN_CHANGE, NULL, NULL},
+	{BT_EVENT_AG_MICROPHONE_GAIN_CHANGE, NULL, NULL},
+	{BT_EVENT_AVRCP_CONNECTION_STATUS, NULL, NULL},
+	{BT_EVENT_HID_CONNECTION_STATUS, NULL, NULL}
+};
+
+/*
+ *  Internal Functions
+ */
+static void __bt_event_proxy(int event, bluetooth_event_param_t * param, void *user_data);
+static int __bt_get_cb_index(int event);
+static void __bt_convert_lower_to_upper(char *origin);
+static int __bt_get_bt_device_sdp_info_s(bt_device_sdp_info_s **dest, bt_sdp_info_t *source);
+static void __bt_free_bt_device_sdp_info_s(bt_device_sdp_info_s *sdp_info);
+static int __bt_get_bt_adapter_device_discovery_info_s(bt_adapter_device_discovery_info_s **discovery_info, bluetooth_device_info_t *source_info);
+static void __bt_free_bt_adapter_device_discovery_info_s(bt_adapter_device_discovery_info_s *discovery_info);
+
+
+/*
+ *  Public Functions
+ */
+
+int bt_initialize(void)
+{
+	if (is_initialized != true) {
+		if (bluetooth_register_callback(&__bt_event_proxy, NULL) != BLUETOOTH_ERROR_NONE) {
+			LOGE("[%s] OPERATION_FAILED(0x%08x)", __FUNCTION__, BT_ERROR_OPERATION_FAILED);
+			return BT_ERROR_OPERATION_FAILED;
+		}
+		is_initialized = true;
+	}
+
+	return BT_ERROR_NONE;
+}
+
+int bt_deinitialize(void)
+{
+	BT_CHECK_INIT_STATUS();
+	if (bluetooth_unregister_callback() != BLUETOOTH_ERROR_NONE) {
+		LOGE("[%s] OPERATION_FAILED(0x%08x)", __FUNCTION__, BT_ERROR_OPERATION_FAILED);
+		return BT_ERROR_OPERATION_FAILED;
+	}
+	is_initialized = false;
+
+	return BT_ERROR_NONE;
+}
+
+
+/*
+ *  Common Functions
+ */
+int _bt_check_init_status(void)
+{
+	if (is_initialized != true)
+	{
+		LOGE("[%s] NOT_INITIALIZED(0x%08x)", __FUNCTION__, BT_ERROR_NOT_INITIALIZED);
+		return BT_ERROR_NOT_INITIALIZED;
+	}
+
+	return BT_ERROR_NONE;
+}
+
+void _bt_set_cb(int events, void *callback, void *user_data)
+{
+	bt_event_slot_container[events].callback = callback;
+	bt_event_slot_container[events].user_data = user_data;
+}
+
+void _bt_unset_cb(int events)
+{
+	if (bt_event_slot_container[events].callback != NULL) {
+		bt_event_slot_container[events].callback = NULL;
+		bt_event_slot_container[events].user_data = NULL;
+	}
+}
+
+bool _bt_check_cb(int events)
+{
+	return (bt_event_slot_container[events].callback != NULL) ? true : false;
+}
+
+int _bt_get_error_code(int origin_error)
+{
+	switch (origin_error) {
+	case BLUETOOTH_ERROR_NONE:
+		return BT_ERROR_NONE;
+	case BLUETOOTH_ERROR_INVALID_DATA:
+	case BLUETOOTH_ERROR_INVALID_PARAM:
+	case BLUETOOTH_ERROR_NOT_CONNECTED:
+	case BLUETOOTH_ERROR_NOT_SUPPORT:
+		return BT_ERROR_INVALID_PARAMETER;
+	case BLUETOOTH_ERROR_MEMORY_ALLOCATION:
+	case BLUETOOTH_ERROR_OUT_OF_MEMORY:
+		return BT_ERROR_OUT_OF_MEMORY;
+	case BLUETOOTH_ERROR_TIMEOUT:
+		return BT_ERROR_TIMED_OUT;
+	case BLUETOOTH_ERROR_DEVICE_NOT_ENABLED:
+		return BT_ERROR_NOT_ENABLED;
+	case BLUETOOTH_ERROR_DEVICE_ALREADY_ENABLED:
+		return BT_ERROR_ALREADY_DONE;
+	case BLUETOOTH_ERROR_NOT_PAIRED:
+		return BT_ERROR_REMOTE_DEVICE_NOT_BONDED;
+	case BLUETOOTH_ERROR_NOT_IN_OPERATION:
+		return BT_ERROR_NOT_IN_PROGRESS;
+	case BLUETOOTH_ERROR_IN_PROGRESS:
+		return BT_ERROR_NOW_IN_PROGRESS;
+	case BLUETOOTH_ERROR_DEVICE_BUSY:
+		return BT_ERROR_RESOURCE_BUSY;
+	case BLUETOOTH_ERROR_CANCEL:
+	case BLUETOOTH_ERROR_CANCEL_BY_USER:
+		return BT_ERROR_CANCELLED;
+	case BLUETOOTH_ERROR_AUTHENTICATION_FAILED:
+		return BT_ERROR_AUTH_FAILED;
+	case BLUETOOTH_ERROR_HOST_DOWN:
+		return BT_ERROR_REMOTE_DEVICE_NOT_FOUND;
+	case BLUETOOTH_ERROR_SERVICE_SEARCH_ERROR:
+		return BT_ERROR_SERVICE_SEARCH_FAILED;
+	case BLUETOOTH_ERROR_SERVICE_NOT_FOUND:
+	case BLUETOOTH_ERROR_PARING_FAILED:
+	case BLUETOOTH_ERROR_MAX_CONNECTION:
+	case BLUETOOTH_ERROR_ALREADY_CONNECT:
+	case BLUETOOTH_ERROR_NO_RESOURCES:
+	case BLUETOOTH_ERROR_REGISTRATION_FAILED:
+	case BLUETOOTH_ERROR_CONNECTION_BUSY:
+	case BLUETOOTH_ERROR_MAX_CLIENT:
+	case BLUETOOTH_ERROR_INVALID_CALLBACK:
+	case BLUETOOTH_ERROR_NOT_FOUND:
+	case BLUETOOTH_ERROR_INTERNAL:
+	case BLUETOOTH_ERROR_CONNECTION_ERROR:
+	case BLUETOOTH_ERROR_ACCESS_DENIED:
+	default:
+		return BT_ERROR_OPERATION_FAILED;
+	}
+
+}
+
+int _bt_get_bt_device_info_s(bt_device_info_s **dest_dev, bluetooth_device_info_t *source_dev)
+{
+	int i = 0;
+
+	BT_CHECK_INPUT_PARAMETER(source_dev);
+
+	*dest_dev = (bt_device_info_s *)malloc(sizeof(bt_device_info_s));
+	if (*dest_dev == NULL) {
+		return BT_ERROR_OUT_OF_MEMORY;
+	}
+
+	if (strlen(source_dev->device_name.name) > 0) {
+		(*dest_dev)->remote_name = strdup(source_dev->device_name.name);
+	} else {
+		(*dest_dev)->remote_name = NULL;
+	}
+
+	_bt_convert_address_to_string(&((*dest_dev)->remote_address), &(source_dev->device_address));
+
+	(*dest_dev)->bt_class.major_device_class = source_dev->device_class.major_class;
+	(*dest_dev)->bt_class.minor_device_class = source_dev->device_class.minor_class;
+	(*dest_dev)->bt_class.major_service_class_mask = source_dev->device_class.service_class;
+	if (source_dev->service_index > 0) {
+		(*dest_dev)->service_uuid = (char **)malloc(sizeof(char *) * source_dev->service_index);
+		if ((*dest_dev)->service_uuid != NULL) {
+			for (i = 0; i < source_dev->service_index; i++) {
+				(*dest_dev)->service_uuid[i] = strdup(source_dev->uuids[i]);
+				if ((*dest_dev)->service_uuid[i] != NULL) {
+					__bt_convert_lower_to_upper((*dest_dev)->service_uuid[i]);
+				}
+			}
+		}
+	} else {
+		(*dest_dev)->service_uuid = NULL;
+	}
+	(*dest_dev)->service_count = source_dev->service_index;
+	(*dest_dev)->is_bonded = (bool)source_dev->paired;
+	(*dest_dev)->is_connected = (bool)source_dev->connected;
+	(*dest_dev)->is_authorized = (bool)source_dev->trust;
+
+	return BT_ERROR_NONE;
+}
+
+void _bt_free_bt_device_info_s(bt_device_info_s *device_info)
+{
+	int i = 0;
+
+	if (device_info == NULL)
+		return;
+
+	if (device_info->remote_name != NULL)
+		free(device_info->remote_name);
+
+	if (device_info->remote_address != NULL)
+		free(device_info->remote_address);
+
+	if (device_info->service_uuid != NULL) {
+		for (i = 0; i < device_info->service_count; i++) {
+			if (device_info->service_uuid[i] != NULL)
+				free(device_info->service_uuid[i]);
+		}
+		free(device_info->service_uuid);
+	}
+
+	free(device_info);
+	device_info = NULL;
+}
+
+int _bt_convert_address_to_string(char **addr_str, bluetooth_device_address_t *addr_hex)
+{
+	char address[18] = { 0, };
+
+	snprintf(address, 18, "%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X", addr_hex->addr[0], addr_hex->addr[1], addr_hex->addr[2], addr_hex->addr[3], addr_hex->addr[4], addr_hex->addr[5]);
+	*addr_str = strdup(address);
+
+	if (*addr_str != NULL) {
+		return BT_ERROR_NONE;
+	} else {
+		return BT_ERROR_OUT_OF_MEMORY;
+	}
+}
+
+void _bt_convert_address_to_hex(bluetooth_device_address_t *addr_hex, const char *addr_str)
+{
+	int i = 0;
+	unsigned int addr[BLUETOOTH_ADDRESS_LENGTH] = { 0, };
+
+	i = sscanf(addr_str, "%X:%X:%X:%X:%X:%X", &addr[0], &addr[1], &addr[2], &addr[3], &addr[4], &addr[5]);
+	if (i != BLUETOOTH_ADDRESS_LENGTH) {
+		LOGI("[%s] Invalid format string - %s", __FUNCTION__, addr_str);
+	}
+
+	for (i = 0; i < BLUETOOTH_ADDRESS_LENGTH; i++) {
+		addr_hex->addr[i] = (unsigned char)addr[i];
+	}
+}
+
+char *_bt_convert_error_to_string(int error)
+{
+	switch (error) {
+	case BT_ERROR_CANCELLED:
+		return "CANCELLED";
+	case BT_ERROR_INVALID_PARAMETER:
+		return "INVALID_PARAMETER";
+	case BT_ERROR_OUT_OF_MEMORY:
+		return "OUT_OF_MEMORY";
+	case BT_ERROR_RESOURCE_BUSY:
+		return "RESOURCE_BUSY";
+	case BT_ERROR_TIMED_OUT:
+		return "TIMED_OUT";
+	case BT_ERROR_NOW_IN_PROGRESS:
+		return "NOW_IN_PROGRESS";
+	case BT_ERROR_NOT_INITIALIZED:
+		return "NOT_INITIALIZED";
+	case BT_ERROR_NOT_ENABLED:
+		return "DEVICE_NOT_ENABLED";
+	case BT_ERROR_ALREADY_DONE:
+		return "ALREADY_DONE";
+	case BT_ERROR_OPERATION_FAILED:
+		return "OPERATION_FAILED";
+	case BT_ERROR_NOT_IN_PROGRESS:
+		return "NOT_IN_PROGRESS";
+	case BT_ERROR_REMOTE_DEVICE_NOT_BONDED:
+		return "REMOTE_DEVICE_NOT_BONDED";
+	case BT_ERROR_AUTH_REJECTED:
+		return "AUTH_REJECTED";
+	case BT_ERROR_AUTH_FAILED:
+		return "AUTH_FAILED";
+	case BT_ERROR_REMOTE_DEVICE_NOT_FOUND:
+		return "REMOTE_DEVICE_NOT_FOUND";
+	case BT_ERROR_SERVICE_SEARCH_FAILED:
+		return "SERVICE_SEARCH_FAILED";
+	default:
+		return "UNKNOWN";
+	}
+}
+
+bt_adapter_visibility_mode_e _bt_get_bt_visibility_mode_e(bluetooth_discoverable_mode_t mode)
+{
+	switch (mode) {
+	case BLUETOOTH_DISCOVERABLE_MODE_TIME_LIMITED_DISCOVERABLE:
+		return BT_ADAPTER_VISIBILITY_MODE_LIMITED_DISCOVERABLE;
+	case BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE:
+		return BT_ADAPTER_VISIBILITY_MODE_GENERAL_DISCOVERABLE;
+	default:
+		return BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE;
+	}
+}
+
+/*
+ *  Internal Functions
+ */
+
+static int __bt_get_bt_device_sdp_info_s(bt_device_sdp_info_s **dest, bt_sdp_info_t *source)
+{
+	int i = 0;
+
+	*dest = (bt_device_sdp_info_s *)malloc(sizeof(bt_device_sdp_info_s));
+	if (*dest == NULL) {
+		return BT_ERROR_OUT_OF_MEMORY;
+	}
+
+	if (_bt_convert_address_to_string(&((*dest)->remote_address), &(source->device_addr)) != BT_ERROR_NONE) {
+		__bt_free_bt_device_sdp_info_s(*dest);
+		return BT_ERROR_OUT_OF_MEMORY;
+	}
+
+	if (source->service_index > 0) {
+		(*dest)->service_uuid = (char **)malloc(sizeof(char *) * source->service_index);
+		if ((*dest)->service_uuid == NULL) {
+			__bt_free_bt_device_sdp_info_s(*dest);
+			return BT_ERROR_OUT_OF_MEMORY;
+		}
+
+		for (i = 0; i < source->service_index; i++) {
+			(*dest)->service_uuid[i] = strdup(source->uuids[i]);
+			if ((*dest)->service_uuid[i] == NULL) {
+				__bt_free_bt_device_sdp_info_s(*dest);
+				return BT_ERROR_OUT_OF_MEMORY;
+			}
+			__bt_convert_lower_to_upper((*dest)->service_uuid[i]);
+		}
+	} else {
+		(*dest)->service_uuid = NULL;
+	}
+	(*dest)->service_count = source->service_index;
+
+	return BT_ERROR_NONE;
+}
+
+static void __bt_free_bt_device_sdp_info_s(bt_device_sdp_info_s *sdp_info)
+{
+	int i = 0;
+
+	if (sdp_info == NULL)
+		return;
+
+	if (sdp_info->remote_address != NULL)
+		free(sdp_info->remote_address);
+
+	if (sdp_info->service_uuid != NULL) {
+		for (i = 0; i < sdp_info->service_count; i++) {
+			if (sdp_info->service_uuid[i] != NULL)
+				free(sdp_info->service_uuid[i]);
+		}
+		free(sdp_info->service_uuid);
+	}
+
+	free(sdp_info);
+	sdp_info = NULL;
+}
+
+void _bt_audio_event_proxy(int event, bt_audio_event_param_t *param, void *user_data)
+{
+	bluetooth_event_param_t new_param;
+	new_param.event = param->event;
+	new_param.param_data = param->param_data;
+	new_param.result = param->result;
+	new_param.user_data = NULL;
+	__bt_event_proxy(event, &new_param, user_data);
+}
+
+void _bt_avrcp_event_proxy(int event, media_event_param_t *param, void *user_data)
+{
+	bluetooth_event_param_t new_param;
+	new_param.event = param->event;
+	new_param.param_data = param->param_data;
+	new_param.result = param->result;
+	new_param.user_data = param->user_data;
+	__bt_event_proxy(event, &new_param, user_data);
+}
+
+void _bt_hid_event_proxy(int event, hid_event_param_t *param, void *user_data)
+{
+	bluetooth_event_param_t new_param;
+	new_param.event = param->event;
+	new_param.param_data = param->param_data;
+	new_param.result = param->result;
+	new_param.user_data = param->user_data;
+	__bt_event_proxy(event, &new_param, user_data);
+}
+
+static void __bt_event_proxy(int event, bluetooth_event_param_t *param, void *user_data)
+{
+	bluetooth_rfcomm_connection_t *connection_ind = NULL;
+	bluetooth_rfcomm_disconnection_t *disconnection_ind = NULL;
+	bt_socket_connection_s rfcomm_connection;
+	bt_device_sdp_info_s *sdp_info = NULL;
+	bt_adapter_device_discovery_info_s *discovery_info = NULL;
+	bt_device_info_s *bonded_device = NULL;
+	bluetooth_rfcomm_connection_request_t *reqeust_ind = NULL;
+	bt_obex_server_authorize_into_t *auth_info = NULL;
+	bt_obex_server_transfer_info_t *transfer_info = NULL;
+	bt_opc_transfer_info_t *client_info = NULL;
+	bluetooth_device_address_t *bd_addr = NULL;
+	char *device_addr = NULL;
+	int error_code = BT_ERROR_NONE;
+	int event_index = -1;
+	bluetooth_network_device_info_t *dev_info = NULL;
+	bt_hdp_connected_t *hdp_conn_info = NULL;
+	bt_hdp_disconnected_t *hdp_disconn_info = NULL;
+	bt_hdp_data_ind_t *hdp_data_ind = NULL;
+
+	event_index = __bt_get_cb_index(event);
+	if (event_index == -1 || bt_event_slot_container[event_index].callback == NULL) {
+		return;
+	}
+
+	memset(&rfcomm_connection, 0x00, sizeof(bt_socket_connection_s));
+
+	switch (event) {
+	case BLUETOOTH_EVENT_ENABLED:
+		LOGI("[%s] bt_adapter_state_changed_cb() will be called with BT_ADAPTER_ENABLED", __FUNCTION__);
+		((bt_adapter_state_changed_cb) bt_event_slot_container[event_index].callback)
+		    (_bt_get_error_code(param->result), BT_ADAPTER_ENABLED, bt_event_slot_container[event_index].user_data);
+		break;
+	case BLUETOOTH_EVENT_DISABLED:
+		LOGI("[%s] bt_adapter_state_changed_cb() will be called with BT_ADAPTER_DISABLED", __FUNCTION__);
+		((bt_adapter_state_changed_cb) bt_event_slot_container[event_index].callback)
+		    (_bt_get_error_code(param->result), BT_ADAPTER_DISABLED, bt_event_slot_container[event_index].user_data);
+		break;
+	case BLUETOOTH_EVENT_LOCAL_NAME_CHANGED:
+		LOGI("[%s] bt_adapter_name_changed_cb() will be called", __FUNCTION__);
+		((bt_adapter_name_changed_cb)bt_event_slot_container[event_index].callback)
+		    ((char *)(param->param_data), bt_event_slot_container[event_index].user_data);
+		break;
+	case BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED:
+		LOGI("[%s] bt_adapter_visibility_mode_changed_cb() will be called", __FUNCTION__);
+		((bt_adapter_visibility_mode_changed_cb)bt_event_slot_container[event_index].callback)
+		    (_bt_get_error_code(param->result), _bt_get_bt_visibility_mode_e(*(bt_adapter_visibility_mode_e *)(param->param_data)), bt_event_slot_container[event_index].user_data);
+		break;
+	case BLUETOOTH_EVENT_DISCOVERY_STARTED:
+		LOGI("[%s] bt_adapter_device_discovery_state_changed_cb() will be called with BT_ADAPTER_DEVICE_DISCOVERY_STARTED", __FUNCTION__);
+		((bt_adapter_device_discovery_state_changed_cb) bt_event_slot_container[event_index].callback)
+		    (_bt_get_error_code(param->result), BT_ADAPTER_DEVICE_DISCOVERY_STARTED, NULL, bt_event_slot_container[event_index].user_data);
+		break;
+	case BLUETOOTH_EVENT_DISCOVERY_FINISHED:
+		LOGI("[%s] bt_adapter_device_discovery_state_changed_cb() will be called with BT_ADAPTER_DEVICE_DISCOVERY_FINISHED", __FUNCTION__);
+		((bt_adapter_device_discovery_state_changed_cb)bt_event_slot_container[event_index].callback)
+		    (_bt_get_error_code(param->result), BT_ADAPTER_DEVICE_DISCOVERY_FINISHED, NULL, bt_event_slot_container[event_index].user_data);
+		break;
+	case BLUETOOTH_EVENT_REMOTE_DEVICE_NAME_UPDATED:
+		LOGI("[%s] bt_adapter_device_discovery_state_changed_cb() will be called with BT_ADAPTER_DEVICE_DISCOVERY_FOUND", __FUNCTION__);
+		if (__bt_get_bt_adapter_device_discovery_info_s(&discovery_info, (bluetooth_device_info_t *)(param->param_data)) == BT_ERROR_NONE) {
+			((bt_adapter_device_discovery_state_changed_cb)bt_event_slot_container[event_index].callback)
+			    (_bt_get_error_code(param->result), BT_ADAPTER_DEVICE_DISCOVERY_FOUND, discovery_info, bt_event_slot_container[event_index].user_data);
+			__bt_free_bt_adapter_device_discovery_info_s(discovery_info);
+		} else {
+			((bt_adapter_device_discovery_state_changed_cb)bt_event_slot_container[event_index].callback)
+			    (_bt_get_error_code(param->result), BT_ADAPTER_DEVICE_DISCOVERY_FOUND, NULL, bt_event_slot_container[event_index].user_data);
+		}
+		break;
+	case BLUETOOTH_EVENT_BONDING_FINISHED:
+		LOGI("[%s] bt_device_bond_created_cb() will be called", __FUNCTION__);
+		_bt_get_bt_device_info_s(&bonded_device, (bluetooth_device_info_t *)(param->param_data));
+
+		((bt_device_bond_created_cb)bt_event_slot_container[event_index].callback)
+		    (_bt_get_error_code(param->result), bonded_device, bt_event_slot_container[event_index].user_data);
+		_bt_free_bt_device_info_s(bonded_device);
+		bonded_device = NULL;
+		break;
+	case BLUETOOTH_EVENT_BONDED_DEVICE_REMOVED:
+		LOGI("[%s] bt_device_bond_destroyed_cb() will be called", __FUNCTION__);
+		_bt_convert_address_to_string(&device_addr, (bluetooth_device_address_t *)(param->param_data));
+		((bt_device_bond_destroyed_cb)bt_event_slot_container[event_index].callback)
+		    (_bt_get_error_code(param->result), device_addr, bt_event_slot_container[event_index].user_data);
+		if (device_addr != NULL)
+			free(device_addr);
+		device_addr = NULL;
+		break;
+	case BLUETOOTH_EVENT_DEVICE_AUTHORIZED:
+		LOGI("[%s] bt_device_authorization_changed_cb() will be called with BT_DEVICE_AUTHORIZED", __FUNCTION__);
+		_bt_convert_address_to_string(&device_addr, (bluetooth_device_address_t *)(param->param_data));
+		((bt_device_authorization_changed_cb)bt_event_slot_container[event_index].callback)
+		    (BT_DEVICE_AUTHORIZED, device_addr, bt_event_slot_container[event_index].user_data);
+		if (device_addr != NULL)
+			free(device_addr);
+		device_addr = NULL;
+		break;
+	case BLUETOOTH_EVENT_DEVICE_UNAUTHORIZED:
+		LOGI("[%s] bt_device_authorization_changed_cb() will be called with BT_DEVICE_UNAUTHORIZED", __FUNCTION__);
+		_bt_convert_address_to_string(&device_addr, (bluetooth_device_address_t *)(param->param_data));
+		((bt_device_authorization_changed_cb)bt_event_slot_container[event_index].callback)
+		    (BT_DEVICE_UNAUTHORIZED, device_addr, bt_event_slot_container[event_index].user_data);
+		if (device_addr != NULL)
+			free(device_addr);
+		device_addr = NULL;
+		break;
+	case BLUETOOTH_EVENT_SERVICE_SEARCHED:
+		LOGI("[%s] bt_device_service_searched_cb() will be called", __FUNCTION__);
+		__bt_get_bt_device_sdp_info_s(&sdp_info, (bt_sdp_info_t *)(param->param_data));
+		error_code = _bt_get_error_code(param->result);
+		// In service search, BT_ERROR_SERVICE_SEARCH_FAILED is returned instead of BT_ERROR_OPERATION_FAILED.
+		if (error_code == BT_ERROR_OPERATION_FAILED)
+			error_code = BT_ERROR_SERVICE_SEARCH_FAILED;
+		((bt_device_service_searched_cb)bt_event_slot_container[event_index].callback)
+		    (error_code, sdp_info, bt_event_slot_container[event_index].user_data);
+		__bt_free_bt_device_sdp_info_s(sdp_info);
+		break;
+	case BLUETOOTH_EVENT_RFCOMM_DATA_RECEIVED:
+		LOGI("[%s] bt_socket_data_received_cb() will be called", __FUNCTION__);
+		((bt_socket_data_received_cb)bt_event_slot_container[event_index].callback)
+		    ((bt_socket_received_data_s *)(param->param_data), bt_event_slot_container[event_index].user_data);
+		break;
+	case BLUETOOTH_EVENT_RFCOMM_CONNECTED:
+		LOGI("[%s] bt_socket_connection_state_changed_cb() will be called with BT_SOCKET_CONNECTED", __FUNCTION__);
+		if (param->result == BLUETOOTH_ERROR_INVALID_PARAM)
+			error_code = BT_ERROR_OPERATION_FAILED;
+		else
+			error_code = _bt_get_error_code(param->result);
+
+		connection_ind = (bluetooth_rfcomm_connection_t *)(param->param_data);
+		rfcomm_connection.socket_fd = connection_ind->socket_fd;
+		rfcomm_connection.local_role = connection_ind->device_role;
+
+		if (connection_ind->uuid) {
+			rfcomm_connection.service_uuid = strdup(connection_ind->uuid);
+			LOGI("uuid: [%s]", rfcomm_connection.service_uuid);
+		}
+
+		_bt_convert_address_to_string(&(rfcomm_connection.remote_address), &(connection_ind->device_addr));
+
+		((bt_socket_connection_state_changed_cb)bt_event_slot_container[event_index].callback)
+		    (error_code, BT_SOCKET_CONNECTED, &rfcomm_connection, bt_event_slot_container[event_index].user_data);
+
+		if (rfcomm_connection.remote_address != NULL) {
+			free(rfcomm_connection.remote_address);
+			rfcomm_connection.remote_address = NULL;
+		}
+
+		if (rfcomm_connection.service_uuid != NULL) {
+			free(rfcomm_connection.service_uuid);
+			rfcomm_connection.service_uuid = NULL;
+		}
+
+		break;
+	case BLUETOOTH_EVENT_RFCOMM_DISCONNECTED:
+		LOGI("[%s] bt_socket_connection_state_changed_cb() will be called with BT_SOCKET_DISCONNECTED", __FUNCTION__);
+
+		disconnection_ind = (bluetooth_rfcomm_disconnection_t *)(param->param_data);
+		rfcomm_connection.socket_fd = disconnection_ind->socket_fd;
+		rfcomm_connection.local_role = disconnection_ind->device_role;
+
+		if (disconnection_ind->uuid) {
+			rfcomm_connection.service_uuid = strdup(disconnection_ind->uuid);
+			LOGI("uuid: [%s]", rfcomm_connection.service_uuid);
+		}
+
+		_bt_convert_address_to_string(&(rfcomm_connection.remote_address), &(disconnection_ind->device_addr));
+		((bt_socket_connection_state_changed_cb)bt_event_slot_container[event_index].callback)
+		    (_bt_get_error_code(param->result), BT_SOCKET_DISCONNECTED, &rfcomm_connection, bt_event_slot_container[event_index].user_data);
+
+		if (rfcomm_connection.remote_address != NULL) {
+			free(rfcomm_connection.remote_address);
+			rfcomm_connection.remote_address = NULL;
+		}
+
+		if (rfcomm_connection.service_uuid != NULL) {
+			free(rfcomm_connection.service_uuid);
+			rfcomm_connection.service_uuid = NULL;
+		}
+
+		break;
+	case BLUETOOTH_EVENT_RFCOMM_AUTHORIZE:
+		LOGI("[%s] bt_socket_connection_requested_cb() will be called", __FUNCTION__);
+		reqeust_ind = (bluetooth_rfcomm_connection_request_t *)(param->param_data);
+		_bt_convert_address_to_string(&device_addr, &(reqeust_ind->device_addr));
+		((bt_socket_connection_requested_cb)bt_event_slot_container[event_index].callback)
+		    (reqeust_ind->socket_fd, device_addr, bt_event_slot_container[event_index].user_data);
+
+		if (device_addr != NULL)
+			free(device_addr);
+		break;
+	case BLUETOOTH_EVENT_OBEX_SERVER_CONNECTION_AUTHORIZE:
+		LOGI("[%s] bt_opp_server_connection_requested_cb() will be called", __FUNCTION__);
+		bd_addr = (bluetooth_device_address_t *)(param->param_data);
+		_bt_convert_address_to_string(&device_addr, bd_addr);
+		((bt_opp_server_connection_requested_cb)bt_event_slot_container[event_index].callback)
+		    (device_addr, bt_event_slot_container[event_index].user_data);
+
+		if (device_addr != NULL)
+			free(device_addr);
+		break;
+	case BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_AUTHORIZE:
+		LOGI("[%s] bt_opp_server_push_requested_cb() will be called", __FUNCTION__);
+		auth_info = (bt_obex_server_authorize_into_t *)(param->param_data);
+		((bt_opp_server_push_requested_cb)bt_event_slot_container[event_index].callback)
+		    (auth_info->filename, auth_info->length, bt_event_slot_container[event_index].user_data);
+		break;
+
+	case BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_STARTED:
+		LOGI("[%s] bt_opp_server_transfer_started_cb() will be called", __FUNCTION__);
+		transfer_info = (bt_obex_server_transfer_info_t *)(param->param_data);
+		((bt_opp_server_transfer_progress_cb)bt_event_slot_container[event_index].callback)
+		    (transfer_info->filename, transfer_info->file_size, 0, bt_event_slot_container[event_index].user_data);
+		break;
+
+	case BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_PROGRESS:
+		LOGI("[%s] bt_opp_server_transfer_in_progress_cb() will be called", __FUNCTION__);
+		transfer_info = (bt_obex_server_transfer_info_t *)(param->param_data);
+		((bt_opp_server_transfer_progress_cb)bt_event_slot_container[event_index].callback)
+		    (transfer_info->filename, transfer_info->file_size, transfer_info->percentage, bt_event_slot_container[event_index].user_data);
+		break;
+
+	case BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_COMPLETED:
+		LOGI("[%s] bt_opp_server_transfer_completed_cb() will be called", __FUNCTION__);
+		transfer_info = (bt_obex_server_transfer_info_t *)(param->param_data);
+
+		((bt_opp_server_transfer_finished_cb)bt_event_slot_container[event_index].callback)
+		    (_bt_get_error_code(param->result), transfer_info->filename, transfer_info->file_size, bt_event_slot_container[event_index].user_data);
+
+		break;
+
+	case BLUETOOTH_EVENT_OPC_CONNECTED:
+		LOGI("[%s] bt_opp_client_push_responded_cb() will be called", __FUNCTION__);
+		bd_addr = (bluetooth_device_address_t *)(param->param_data);
+		_bt_convert_address_to_string(&device_addr, bd_addr);
+
+		LOGI("address: %s", device_addr);
+
+		((bt_opp_client_push_responded_cb)bt_event_slot_container[event_index].callback)
+		    (_bt_get_error_code(param->result), device_addr, bt_event_slot_container[event_index].user_data);
+		break;
+
+	case BLUETOOTH_EVENT_OPC_DISCONNECTED:
+		LOGI("[%s] bt_opp_client_push_finished_cb() will be called", __FUNCTION__);
+		bd_addr = (bluetooth_device_address_t *)(param->param_data);
+		_bt_convert_address_to_string(&device_addr, bd_addr);
+
+		LOGI("address: %s", device_addr);
+
+		((bt_opp_client_push_finished_cb)bt_event_slot_container[event_index].callback)
+		    (_bt_get_error_code(param->result), device_addr, bt_event_slot_container[event_index].user_data);
+		break;
+
+	case BLUETOOTH_EVENT_OPC_TRANSFER_STARTED:
+		LOGI("[%s] bt_opp_client_transfer_started_cb() will be called", __FUNCTION__);
+		client_info = (bt_opc_transfer_info_t *)(param->param_data);
+		((bt_opp_client_push_progress_cb)bt_event_slot_container[event_index].callback)
+		    (client_info->filename, client_info->size, 0, bt_event_slot_container[event_index].user_data);
+		break;
+
+	case BLUETOOTH_EVENT_OPC_TRANSFER_PROGRESS:
+		LOGI("[%s] bt_opp_client_transfer_in_progress_cb() will be called", __FUNCTION__);
+		client_info = (bt_opc_transfer_info_t *)(param->param_data);
+		((bt_opp_client_push_progress_cb)bt_event_slot_container[event_index].callback)
+		    (client_info->filename, client_info->size, client_info->percentage, bt_event_slot_container[event_index].user_data);
+		break;
+
+	case BLUETOOTH_EVENT_OPC_TRANSFER_COMPLETE:
+		LOGI("[%s] bt_opp_client_push_progress_cb() will be called", __FUNCTION__);
+		client_info = (bt_opc_transfer_info_t *)(param->param_data);
+
+		if (param->result != BLUETOOTH_ERROR_NONE) {
+			LOGI("[%s] bt_opp_client_push_finished_cb() will be called", __FUNCTION__);
+			break;
+		}
+
+		((bt_opp_client_push_progress_cb)bt_event_slot_container[event_index].callback)
+		    (client_info->filename, client_info->size, 100, bt_event_slot_container[event_index].user_data);
+		break;
+
+	case BLUETOOTH_EVENT_NETWORK_SERVER_CONNECTED:
+		LOGI("[%s] BLUETOOTH_EVENT_NETWORK_SERVER_CONNECTED", __FUNCTION__);
+		dev_info = (bluetooth_network_device_info_t *)(param->param_data);
+
+		if (param->result != BLUETOOTH_ERROR_NONE) {
+			LOGI("[%s]BLUETOOTH_EVENT_NETWORK_SERVER_CONNECTED", __FUNCTION__);
+		}
+		_bt_convert_address_to_string(&device_addr, &dev_info->device_address);
+		((bt_nap_connection_state_changed_cb)bt_event_slot_container[event_index].callback)
+		(TRUE, device_addr, dev_info->interface_name, bt_event_slot_container[event_index].user_data);
+		break;
+
+	case BLUETOOTH_EVENT_NETWORK_SERVER_DISCONNECTED:
+		LOGI("[%s] BLUETOOTH_EVENT_NETWORK_SERVER_DISCONNECTED", __FUNCTION__);
+		dev_info = (bluetooth_network_device_info_t *)(param->param_data);
+
+		if (param->result != BLUETOOTH_ERROR_NONE) {
+			LOGI("[%s]BLUETOOTH_EVENT_NETWORK_SERVER_DISCONNECTED", __FUNCTION__);
+		}
+		_bt_convert_address_to_string(&device_addr, &dev_info->device_address);
+		((bt_nap_connection_state_changed_cb)bt_event_slot_container[event_index].callback)
+		(FALSE, device_addr, dev_info->interface_name, bt_event_slot_container[event_index].user_data);
+		break;
+	case BLUETOOTH_EVENT_NETWORK_DISCONNECTED:
+		LOGI("[%s] Network callback will be", __FUNCTION__);
+		((bt_panu_connection_state_changed_cb)bt_event_slot_container[event_index].callback)
+		(_bt_get_error_code(param->result), FALSE, NULL, BLUETOOTH_NETWORK_NAP_ROLE,
+		bt_event_slot_container[event_index].user_data);
+		break;
+
+	case BLUETOOTH_EVENT_NETWORK_CONNECTED:
+		LOGI("[%s] Network callback will be ", __FUNCTION__);
+		((bt_panu_connection_state_changed_cb)bt_event_slot_container[event_index].callback)
+		(_bt_get_error_code(param->result), TRUE, NULL, BLUETOOTH_NETWORK_NAP_ROLE,
+		bt_event_slot_container[event_index].user_data);
+		break;
+
+	case BLUETOOTH_EVENT_HDP_CONNECTED:
+		LOGI("[%s] HDP Connected ", __FUNCTION__);
+		hdp_conn_info = (bt_hdp_connected_t *)(param->param_data);
+		_bt_convert_address_to_string(&device_addr, &hdp_conn_info->device_address);
+		((bt_hdp_connected_cb)bt_event_slot_container[event_index].callback)
+		(_bt_get_error_code(param->result), device_addr, hdp_conn_info->app_handle,
+		hdp_conn_info->type, hdp_conn_info->channel_id,
+		bt_event_slot_container[event_index].user_data);
+		break;
+
+	case BLUETOOTH_EVENT_HDP_DISCONNECTED:
+		LOGI("[%s] HDP disconnected callback will be ", __FUNCTION__);
+		hdp_disconn_info = (bt_hdp_disconnected_t *)(param->param_data);
+
+		_bt_convert_address_to_string(&device_addr, &hdp_disconn_info->device_address);
+		((bt_hdp_disconnected_cb)bt_event_slot_container[event_index].callback)
+		(_bt_get_error_code(param->result), device_addr,
+		hdp_disconn_info->channel_id, bt_event_slot_container[event_index].user_data);
+		break;
+	case BLUETOOTH_EVENT_HDP_DATA_RECEIVED:
+		LOGI("[%s] HDP data recieved callback will be ", __FUNCTION__);
+		hdp_data_ind = (bt_hdp_data_ind_t *)(param->param_data);
+		if (param->result != BLUETOOTH_ERROR_NONE) {
+			LOGI("[%s] BLUETOOTH_EVENT_HDP_DATA_RECEIVED will be called", __FUNCTION__);
+		}
+
+		((bt_hdp_data_received_cb)bt_event_slot_container[event_index].callback)
+		(hdp_data_ind->channel_id, hdp_data_ind->buffer, hdp_data_ind->size,
+		bt_event_slot_container[event_index].user_data);
+		break;
+	case BLUETOOTH_EVENT_AG_CONNECTED:
+		LOGI("[%s] BLUETOOTH_EVENT_AG_CONNECTED ", __FUNCTION__);
+		device_addr = (char *)(param->param_data);
+		((bt_audio_connection_state_changed_cb)bt_event_slot_container[event_index].callback)
+		(_bt_get_error_code(param->result), TRUE, device_addr, BT_AUDIO_PROFILE_TYPE_HSP_HFP,
+		bt_event_slot_container[event_index].user_data);
+		break;
+	case BLUETOOTH_EVENT_AG_DISCONNECTED:
+		LOGI("[%s] BLUETOOTH_EVENT_AG_DISCONNECTED ", __FUNCTION__);
+		device_addr = (char *)(param->param_data);
+		((bt_audio_connection_state_changed_cb)bt_event_slot_container[event_index].callback)
+		(_bt_get_error_code(param->result), FALSE, device_addr, BT_AUDIO_PROFILE_TYPE_HSP_HFP,
+		bt_event_slot_container[event_index].user_data);
+		break;
+	case BLUETOOTH_EVENT_AG_SPEAKER_GAIN:
+		LOGI("[%s] BLUETOOTH_EVENT_AG_SPEAKER_GAIN", __FUNCTION__);
+		int *spk_gain = (int *)(param->param_data);
+		if (param->result != BLUETOOTH_ERROR_NONE) {
+			LOGI("[%s] BLUETOOTH_EVENT_AG_SPEAKER_GAIN will be called", __FUNCTION__);
+		}
+		((bt_ag_speaker_gain_changed_cb)bt_event_slot_container[event_index].callback)
+		(NULL, *spk_gain, bt_event_slot_container[event_index].user_data);
+		break;
+	case BLUETOOTH_EVENT_AG_MIC_GAIN:
+		LOGI("[%s] BLUETOOTH_EVENT_AG_MIC_GAIN", __FUNCTION__);
+		int *mik_gain = (int *)(param->param_data);
+		if (param->result != BLUETOOTH_ERROR_NONE) {
+			LOGI("[%s] BLUETOOTH_EVENT_AG_MIC_GAIN will be called", __FUNCTION__);
+		}
+		((bt_ag_microphone_gain_changed_cb)bt_event_slot_container[event_index].callback)
+		(NULL, *mik_gain , bt_event_slot_container[event_index].user_data);
+		break;
+	case BLUETOOTH_EVENT_AG_AUDIO_CONNECTED:
+		LOGI("[%s] BLUETOOTH_EVENT_AG_AUDIO_CONNECTED", __FUNCTION__);
+		((bt_audio_connection_state_changed_cb)bt_event_slot_container[event_index].callback)
+		(_bt_get_error_code(param->result), TRUE, NULL, BT_AUDIO_PROFILE_TYPE_HSP_HFP,
+		bt_event_slot_container[event_index].user_data);
+		break;
+	case BLUETOOTH_EVENT_AG_AUDIO_DISCONNECTED:
+		LOGI("[%s] BLUETOOTH_EVENT_AG_AUDIO_DISCONNECTED", __FUNCTION__);
+		device_addr = (char *)(param->param_data);
+
+		((bt_audio_connection_state_changed_cb)bt_event_slot_container[event_index].callback)
+		(_bt_get_error_code(param->result), FALSE, device_addr, BT_AUDIO_PROFILE_TYPE_HSP_HFP,
+		bt_event_slot_container[event_index].user_data);
+		break;
+	case BLUETOOTH_EVENT_AV_CONNECTED:
+		LOGI("[%s] BLUETOOTH_EVENT_AV_CONNECTED ", __FUNCTION__);
+		device_addr = (char *)(param->param_data);
+		((bt_audio_connection_state_changed_cb)bt_event_slot_container[event_index].callback)
+		(_bt_get_error_code(param->result), TRUE, device_addr, BT_AUDIO_PROFILE_TYPE_A2DP,
+		bt_event_slot_container[event_index].user_data);
+		break;
+	case BLUETOOTH_EVENT_AV_DISCONNECTED:
+		LOGI("[%s] BLUETOOTH_EVENT_Av_DISCONNECTED ", __FUNCTION__);
+		device_addr = (char *)(param->param_data);
+		((bt_audio_connection_state_changed_cb)bt_event_slot_container[event_index].callback)
+		(_bt_get_error_code(param->result), FALSE, device_addr, BT_AUDIO_PROFILE_TYPE_A2DP,
+		bt_event_slot_container[event_index].user_data);
+		break;
+	case BLUETOOTH_HID_CONNECTED:
+		LOGI("[%s] BLUETOOTH_HID_CONNECTED", __FUNCTION__);
+		device_addr = (char *)(param->param_data);
+		((bt_hid_host_connection_state_changed_cb)bt_event_slot_container[event_index].callback)
+		(_bt_get_error_code(param->result), TRUE, device_addr, bt_event_slot_container[event_index].user_data);
+		break;
+	case BLUETOOTH_HID_DISCONNECTED:
+		LOGI("[%s] BLUETOOTH_HID_DISCONNECTED", __FUNCTION__);
+		device_addr = (char *)(param->param_data);
+		((bt_hid_host_connection_state_changed_cb)bt_event_slot_container[event_index].callback)
+		(_bt_get_error_code(param->result), FALSE, device_addr, bt_event_slot_container[event_index].user_data);
+		break;
+	default:
+		break;
+	}
+}
+
+static int __bt_get_bt_adapter_device_discovery_info_s(bt_adapter_device_discovery_info_s **discovery_info, bluetooth_device_info_t *source_info) {
+	int i;
+
+	BT_CHECK_INPUT_PARAMETER(source_info);
+
+	*discovery_info = (bt_adapter_device_discovery_info_s *)malloc(sizeof(bt_adapter_device_discovery_info_s));
+	if (*discovery_info == NULL) {
+		return BT_ERROR_OUT_OF_MEMORY;
+	}
+
+	if (strlen(source_info->device_name.name) > 0) {
+		(*discovery_info)->remote_name = strdup(source_info->device_name.name);
+	} else {
+		(*discovery_info)->remote_name = NULL;
+	}
+
+	_bt_convert_address_to_string(&((*discovery_info)->remote_address), &(source_info->device_address));
+
+	(*discovery_info)->bt_class.major_device_class = source_info->device_class.major_class;
+	(*discovery_info)->bt_class.minor_device_class = source_info->device_class.minor_class;
+	(*discovery_info)->bt_class.major_service_class_mask = source_info->device_class.service_class;
+
+	if (source_info->service_index > 0) {
+		(*discovery_info)->service_uuid = (char **)malloc(sizeof(char *) * source_info->service_index);
+		if ((*discovery_info)->service_uuid != NULL) {
+			for (i = 0; i < source_info->service_index; i++) {
+				(*discovery_info)->service_uuid[i] = strdup(source_info->uuids[i]);
+				if ((*discovery_info)->service_uuid[i] != NULL) {
+					__bt_convert_lower_to_upper((*discovery_info)->service_uuid[i]);
+				}
+
+				LOGI("[%s] UUID: %s", __FUNCTION__, (*discovery_info)->service_uuid[i]);
+			}
+		}
+	} else {
+		(*discovery_info)->service_uuid = NULL;
+	}
+	(*discovery_info)->service_count = source_info->service_index;
+
+	(*discovery_info)->rssi = (int)source_info->rssi;
+	(*discovery_info)->is_bonded = (bool)source_info->paired;
+
+	return BT_ERROR_NONE;
+}
+
+static void __bt_free_bt_adapter_device_discovery_info_s(bt_adapter_device_discovery_info_s *discovery_info)
+{
+	int i;
+
+	if (discovery_info == NULL)
+		return;
+
+	if (discovery_info->remote_name != NULL)
+		free(discovery_info->remote_name);
+
+	if (discovery_info->remote_address != NULL)
+		free(discovery_info->remote_address);
+
+	if (discovery_info->service_uuid != NULL) {
+		for (i = 0; i < discovery_info->service_count; i++) {
+			if (discovery_info->service_uuid[i] != NULL)
+				free(discovery_info->service_uuid[i]);
+		}
+		free(discovery_info->service_uuid);
+	}
+
+	free(discovery_info);
+	discovery_info = NULL;
+}
+
+static int __bt_get_cb_index(int event)
+{
+	switch (event) {
+	case BLUETOOTH_EVENT_ENABLED:
+	case BLUETOOTH_EVENT_DISABLED:
+		return BT_EVENT_STATE_CHANGED;
+	case BLUETOOTH_EVENT_LOCAL_NAME_CHANGED:
+		return BT_EVENT_NAME_CHANGED;
+	case BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED:
+		return BT_EVENT_VISIBILITY_MODE_CHANGED;
+	case BLUETOOTH_EVENT_DISCOVERY_STARTED:
+	case BLUETOOTH_EVENT_DISCOVERY_FINISHED:
+	case BLUETOOTH_EVENT_REMOTE_DEVICE_NAME_UPDATED:
+		return BT_EVENT_DEVICE_DISCOVERY_STATE_CHANGED;
+	case BLUETOOTH_EVENT_BONDING_FINISHED:
+		return BT_EVENT_BOND_CREATED;
+	case BLUETOOTH_EVENT_BONDED_DEVICE_REMOVED:
+		return BT_EVENT_BOND_DESTROYED;
+	case BLUETOOTH_EVENT_DEVICE_AUTHORIZED:
+	case BLUETOOTH_EVENT_DEVICE_UNAUTHORIZED:
+		return BT_EVENT_AUTHORIZATION_CHANGED;
+	case BLUETOOTH_EVENT_SERVICE_SEARCHED:
+		return BT_EVENT_SERVICE_SEARCHED;
+	case BLUETOOTH_EVENT_RFCOMM_DATA_RECEIVED:
+		return BT_EVENT_DATA_RECEIVED;
+	case BLUETOOTH_EVENT_RFCOMM_CONNECTED:
+	case BLUETOOTH_EVENT_RFCOMM_DISCONNECTED:
+		return BT_EVENT_CONNECTION_STATE_CHANGED;
+	case BLUETOOTH_EVENT_RFCOMM_AUTHORIZE:
+		return BT_EVENT_RFCOMM_CONNECTION_REQUESTED;
+	case BLUETOOTH_EVENT_OBEX_SERVER_CONNECTION_AUTHORIZE:
+		return BT_EVENT_OPP_CONNECTION_REQUESTED;
+	case BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_AUTHORIZE:
+		return BT_EVENT_OPP_PUSH_REQUESTED;
+	case BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_STARTED:
+		return BT_EVENT_OPP_SERVER_TRANSFER_PROGRESS;
+	case BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_PROGRESS:
+		return BT_EVENT_OPP_SERVER_TRANSFER_PROGRESS;
+	case BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_COMPLETED:
+		return BT_EVENT_OPP_SERVER_TRANSFER_FINISHED;
+	case BLUETOOTH_EVENT_OPC_CONNECTED:
+		return BT_EVENT_OPP_CLIENT_PUSH_RESPONSED;
+	case BLUETOOTH_EVENT_OPC_TRANSFER_STARTED:
+		return BT_EVENT_OPP_CLIENT_PUSH_PROGRESS;
+	case BLUETOOTH_EVENT_OPC_TRANSFER_PROGRESS:
+	case BLUETOOTH_EVENT_OPC_TRANSFER_COMPLETE:
+		return BT_EVENT_OPP_CLIENT_PUSH_PROGRESS;
+	case BLUETOOTH_EVENT_OPC_DISCONNECTED:
+		return BT_EVENT_OPP_CLIENT_PUSH_FINISHED;
+	case BLUETOOTH_EVENT_NETWORK_SERVER_CONNECTED:
+	case BLUETOOTH_EVENT_NETWORK_SERVER_DISCONNECTED:
+		return BT_EVENT_NAP_CONNECTION_STATE_CHANGED;
+	case BLUETOOTH_EVENT_NETWORK_CONNECTED:
+	case BLUETOOTH_EVENT_NETWORK_DISCONNECTED:
+		return BT_EVENT_PAN_CONNECTION_STATE_CHANGED;
+	case BLUETOOTH_EVENT_HDP_DATA_RECEIVED:
+		return BT_EVENT_HDP_DATA_RECIEVED;
+	case BLUETOOTH_EVENT_HDP_CONNECTED:
+		return BT_EVENT_HDP_CONNECTED;
+	case BLUETOOTH_EVENT_HDP_DISCONNECTED:
+		return BT_EVENT_HDP_DISCONNECTED;
+	case BLUETOOTH_EVENT_AG_CONNECTED:
+		return BT_EVENT_AUDIO_CONNECTION_STATUS;
+	case BLUETOOTH_EVENT_AG_DISCONNECTED:
+		return BT_EVENT_AUDIO_CONNECTION_STATUS;
+	case BLUETOOTH_EVENT_AG_SPEAKER_GAIN:
+		return BT_EVENT_AG_SPEAKER_GAIN_CHANGE;
+	case BLUETOOTH_EVENT_AG_MIC_GAIN:
+		return BT_EVENT_AG_MICROPHONE_GAIN_CHANGE;
+	case BLUETOOTH_EVENT_AG_AUDIO_CONNECTED:
+		return BT_EVENT_AUDIO_CONNECTION_STATUS;
+	case BLUETOOTH_EVENT_AG_AUDIO_DISCONNECTED:
+		return BT_EVENT_AUDIO_CONNECTION_STATUS;
+	case BLUETOOTH_EVENT_AV_CONNECTED:
+		return BT_EVENT_AUDIO_CONNECTION_STATUS;
+	case BLUETOOTH_EVENT_AV_DISCONNECTED:
+		return BT_EVENT_AUDIO_CONNECTION_STATUS;
+	case BLUETOOTH_HID_CONNECTED:
+		return  BT_EVENT_HID_CONNECTION_STATUS;
+	case BLUETOOTH_HID_DISCONNECTED:
+		return  BT_EVENT_HID_CONNECTION_STATUS;
+	default:
+		return -1;
+	}
+}
+
+static void __bt_convert_lower_to_upper(char *origin)
+{
+	int length = strlen(origin);
+	int i = 0;
+
+	for (i = 0; i < length; i++) {
+		if (islower(origin[i])) {
+			origin[i] = toupper(origin[i]);
+		}
+	}
+}
diff --git a/src/bluetooth-device.c b/src/bluetooth-device.c
new file mode 100644
index 0000000..a242617
--- /dev/null
+++ b/src/bluetooth-device.c
@@ -0,0 +1,231 @@
+/*
+ * Copyright (c) 2011 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 <glib.h>
+#include <dlog.h>
+#include <stdio.h>
+#include <bluetooth-api.h>
+
+#include "bluetooth.h"
+#include "bluetooth_private.h"
+
+#ifdef LOG_TAG
+#undef LOG_TAG
+#endif
+#define LOG_TAG "TIZEN_N_BLUETOOTH"
+
+int bt_device_create_bond(const char *device_address)
+{
+	bluetooth_device_address_t addr_hex = { {0,} };
+	int error_code = BT_ERROR_NONE;
+
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(device_address);
+
+	_bt_convert_address_to_hex(&addr_hex, device_address);
+	error_code = _bt_get_error_code(bluetooth_bond_device(&addr_hex));
+	if (error_code != BT_ERROR_NONE) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(error_code), error_code);
+	}
+
+	return error_code;
+}
+
+int bt_device_cancel_bonding(void)
+{
+	int error_code = BT_ERROR_NONE;
+
+	BT_CHECK_INIT_STATUS();
+	error_code = _bt_get_error_code(bluetooth_cancel_bonding());
+	if (error_code != BT_ERROR_NONE) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(error_code), error_code);
+	}
+
+	return error_code;
+}
+
+int bt_device_destroy_bond(const char *device_address)
+{
+	bluetooth_device_address_t addr_hex = { {0,} };
+	int error_code = BT_ERROR_NONE;
+
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(device_address);
+
+	_bt_convert_address_to_hex(&addr_hex, device_address);
+	error_code = _bt_get_error_code(bluetooth_unbond_device(&addr_hex));
+	if (error_code != BT_ERROR_NONE) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(error_code), error_code);
+	}
+
+	return error_code;
+}
+
+int bt_device_set_alias(const char *device_address, const char *alias)
+{
+	bluetooth_device_address_t addr_hex = { {0,} };
+	int error_code = BT_ERROR_NONE;
+
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(device_address);
+	BT_CHECK_INPUT_PARAMETER(alias);
+
+	_bt_convert_address_to_hex(&addr_hex, device_address);
+	error_code = _bt_get_error_code(bluetooth_set_alias(&addr_hex, alias));
+	if (error_code != BT_ERROR_NONE) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(error_code), error_code);
+	}
+	return error_code;
+}
+
+int bt_device_set_authorization(const char *device_address, bt_device_authorization_e authorization)
+{
+	bluetooth_device_address_t addr_hex = { {0,} };
+	gboolean trusted = FALSE;
+	int error_code = BT_ERROR_NONE;
+
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(device_address);
+
+	_bt_convert_address_to_hex(&addr_hex, device_address);
+	if (authorization == BT_DEVICE_AUTHORIZED)
+		trusted = TRUE;
+
+	error_code = _bt_get_error_code(bluetooth_authorize_device(&addr_hex, trusted));
+	if (error_code != BT_ERROR_NONE) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(error_code), error_code);
+	}
+	return error_code;
+}
+
+int bt_device_start_service_search(const char *device_address)
+{
+	bluetooth_device_address_t addr_hex = { {0,} };
+	int ret = 0;
+
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(device_address);
+
+	_bt_convert_address_to_hex(&addr_hex, device_address);
+	ret = _bt_get_error_code(bluetooth_search_service(&addr_hex));
+
+	// In service search, BT_ERROR_SERVICE_SEARCH_FAILED is returned instead of BT_ERROR_OPERATION_FAILED.
+	if (ret == BT_ERROR_OPERATION_FAILED)
+		ret = BT_ERROR_SERVICE_SEARCH_FAILED;
+
+	if (ret != BT_ERROR_NONE) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
+	}
+	return ret;
+}
+
+int bt_device_cancel_service_search(void)
+{
+	int ret = 0;
+
+	BT_CHECK_INIT_STATUS();
+	ret = _bt_get_error_code(bluetooth_cancel_service_search());
+	if (ret != BT_ERROR_NONE) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
+	}
+
+	return ret;
+}
+
+int bt_device_set_bond_created_cb(bt_device_bond_created_cb callback, void *user_data)
+{
+	int ret = BT_ERROR_NONE;
+
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(callback);
+	_bt_set_cb(BT_EVENT_BOND_CREATED, callback, user_data);
+	if (ret != BT_ERROR_NONE) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
+	}
+
+	return ret;
+}
+
+int bt_device_set_bond_destroyed_cb(bt_device_bond_destroyed_cb callback, void *user_data)
+{
+	int ret = BT_ERROR_NONE;
+
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(callback);
+	_bt_set_cb(BT_EVENT_BOND_DESTROYED, callback, user_data);
+	if (ret != BT_ERROR_NONE) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
+	}
+
+	return ret;
+}
+
+int bt_device_set_authorization_changed_cb(bt_device_authorization_changed_cb callback, void *user_data)
+{
+	int ret = BT_ERROR_NONE;
+
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(callback);
+	_bt_set_cb(BT_EVENT_AUTHORIZATION_CHANGED, callback, user_data);
+	if (ret != BT_ERROR_NONE) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
+	}
+
+	return ret;
+}
+
+int bt_device_set_service_searched_cb(bt_device_service_searched_cb callback, void *user_data)
+{
+	int ret = BT_ERROR_NONE;
+
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(callback);
+	_bt_set_cb(BT_EVENT_SERVICE_SEARCHED, callback, user_data);
+	if (ret != BT_ERROR_NONE) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
+	}
+
+	return ret;
+}
+
+int bt_device_unset_bond_created_cb(void)
+{
+	BT_CHECK_INIT_STATUS();
+	_bt_unset_cb(BT_EVENT_BOND_CREATED);
+	return BT_ERROR_NONE;
+}
+
+int bt_device_unset_bond_destroyed_cb(void)
+{
+	BT_CHECK_INIT_STATUS();
+	_bt_unset_cb(BT_EVENT_BOND_DESTROYED);
+	return BT_ERROR_NONE;
+}
+
+int bt_device_unset_authorization_changed_cb(void)
+{
+	BT_CHECK_INIT_STATUS();
+	_bt_unset_cb(BT_EVENT_AUTHORIZATION_CHANGED);
+	return BT_ERROR_NONE;
+}
+
+int bt_device_unset_service_searched_cb(void)
+{
+	BT_CHECK_INIT_STATUS();
+	_bt_unset_cb(BT_EVENT_SERVICE_SEARCHED);
+	return BT_ERROR_NONE;
+}
+
diff --git a/src/bluetooth-hdp.c b/src/bluetooth-hdp.c
new file mode 100644
index 0000000..60fe951
--- /dev/null
+++ b/src/bluetooth-hdp.c
@@ -0,0 +1,153 @@
+/*
+ * Copyright (c) 2011 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 <glib.h>
+#include <dlog.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include <string.h>
+#include <bluetooth-api.h>
+
+#include "bluetooth.h"
+#include "bluetooth_private.h"
+
+#ifdef LOG_TAG
+#undef LOG_TAG
+#endif
+#define LOG_TAG "TIZEN_N_BLUETOOTH"
+
+
+int bt_hdp_register_sink_app(unsigned short data_type, char **app_id)
+{
+	int error = BT_ERROR_NONE;
+
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(app_id);
+	error = bluetooth_hdp_activate(data_type, HDP_ROLE_SINK, HDP_QOS_ANY, app_id);
+	error = _bt_get_error_code(error);
+	if (BT_ERROR_NONE != error) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__,
+			_bt_convert_error_to_string(error), error);
+	}
+	return error;
+}
+
+int bt_hdp_unregister_sink_app(const char *app_id)
+{
+	int error = BT_ERROR_NONE;
+
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(app_id);
+	error = bluetooth_hdp_deactivate(app_id);
+	error = _bt_get_error_code(error);
+	if (BT_ERROR_NONE != error) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__,
+			_bt_convert_error_to_string(error), error);
+	}
+	return error;
+}
+
+int bt_hdp_send_data(unsigned int channel, const char *data, unsigned int size)
+{
+	int error = BT_ERROR_NONE;
+
+	BT_CHECK_INIT_STATUS();
+	if (NULL == data || 0 >= size) {
+		LOGE("[%s] %s)", __FUNCTION__,
+			_bt_convert_error_to_string(error));
+	}
+	error = bluetooth_hdp_send_data(channel, data, size);
+	error = _bt_get_error_code(error);
+	if (BT_ERROR_NONE != error) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__,
+			_bt_convert_error_to_string(error), error);
+	}
+	return error;
+}
+
+int bt_hdp_connect_to_source(const char *remote_address, const char *app_id)
+{
+	int error = BT_ERROR_NONE;
+	bluetooth_device_address_t addr_hex = { {0,} };
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(app_id);
+	BT_CHECK_INPUT_PARAMETER(remote_address);
+	_bt_convert_address_to_hex(&addr_hex, remote_address);
+	error = bluetooth_hdp_connect(app_id, HDP_QOS_ANY, &addr_hex);
+	error = _bt_get_error_code(error);
+	if (error != BT_ERROR_NONE) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__,
+			_bt_convert_error_to_string(error), error);
+	}
+	return error;
+}
+
+int bt_hdp_disconnect(const char *remote_address, unsigned int channel)
+{
+	int error = BT_ERROR_NONE;
+	bluetooth_device_address_t addr_hex = { {0,} };
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(remote_address);
+	_bt_convert_address_to_hex(&addr_hex, remote_address);
+
+	error = bluetooth_hdp_disconnect(channel, &addr_hex);
+	error = _bt_get_error_code(error);
+	if (error != BT_ERROR_NONE) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__,
+			_bt_convert_error_to_string(error), error);
+	}
+	return error;
+}
+
+int bt_hdp_set_connection_state_changed_cb(bt_hdp_connected_cb connected_cb,
+		bt_hdp_disconnected_cb disconnected_cb, void *user_data)
+{
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(connected_cb);
+	BT_CHECK_INPUT_PARAMETER(disconnected_cb);
+	_bt_set_cb(BT_EVENT_HDP_CONNECTED, connected_cb, user_data);
+	_bt_set_cb(BT_EVENT_HDP_DISCONNECTED, disconnected_cb, user_data);
+	return BT_ERROR_NONE;
+
+}
+
+int bt_hdp_unset_connection_state_changed_cb(void)
+{
+	BT_CHECK_INIT_STATUS();
+	if ( _bt_check_cb(BT_EVENT_HDP_CONNECTED) == true)
+		_bt_unset_cb(BT_EVENT_HDP_CONNECTED);
+	if ( _bt_check_cb(BT_EVENT_HDP_DISCONNECTED) == true)
+		_bt_unset_cb(BT_EVENT_HDP_DISCONNECTED);
+
+	return BT_ERROR_NONE;
+}
+
+int bt_hdp_set_data_received_cb(bt_hdp_data_received_cb callback,
+				void *user_data)
+{
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(callback);
+	_bt_set_cb(BT_EVENT_HDP_DATA_RECIEVED, callback, user_data);
+	return BT_ERROR_NONE;
+}
+
+int bt_hdp_unset_data_received_cb(void)
+{
+	BT_CHECK_INIT_STATUS();
+	if ( _bt_check_cb(BT_EVENT_HDP_DATA_RECIEVED) == true)
+		_bt_unset_cb(BT_EVENT_HDP_DATA_RECIEVED);
+	return BT_ERROR_NONE;
+}
diff --git a/src/bluetooth-hid.c b/src/bluetooth-hid.c
new file mode 100644
index 0000000..921e1bf
--- /dev/null
+++ b/src/bluetooth-hid.c
@@ -0,0 +1,106 @@
+/*
+ * Copyright (c) 2011 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 <glib.h>
+#include <dlog.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include <string.h>
+#include <bluetooth-api.h>
+#include <bluetooth-hid-api.h>
+
+#include "bluetooth.h"
+#include "bluetooth_private.h"
+
+#ifdef LOG_TAG
+#undef LOG_TAG
+#endif
+#define LOG_TAG "TIZEN_N_BLUETOOTH"
+
+int bt_hid_host_initialize(bt_hid_host_connection_state_changed_cb connection_cb,
+								void *user_data)
+{
+	int error;
+
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(connection_cb);
+
+	error = bluetooth_hid_init(_bt_hid_event_proxy, user_data);
+	error = _bt_get_error_code(error);
+	if (BT_ERROR_NONE != error) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__,
+			_bt_convert_error_to_string(error), error);
+	} else {
+		_bt_set_cb(BT_EVENT_HID_CONNECTION_STATUS, connection_cb, user_data);
+	}
+	return error;
+}
+
+int bt_hid_host_deinitialize()
+{
+	int error;
+
+	BT_CHECK_INIT_STATUS();
+
+	error = bluetooth_hid_deinit();
+	error = _bt_get_error_code(error);
+	if (BT_ERROR_NONE != error) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__,
+			_bt_convert_error_to_string(error), error);
+	} else {
+		_bt_unset_cb(BT_EVENT_HID_CONNECTION_STATUS);
+	}
+
+	return error;
+}
+
+int bt_hid_host_connect(const char *remote_address)
+{
+	int error;
+	bluetooth_device_address_t addr_hex = { {0,} };
+
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(remote_address);
+
+	_bt_convert_address_to_hex(&addr_hex, remote_address);
+
+	error = bluetooth_hid_connect((hid_device_address_t *)&addr_hex);
+	error = _bt_get_error_code(error);
+	if (error != BT_ERROR_NONE) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__,
+			_bt_convert_error_to_string(error), error);
+	}
+	return error;
+}
+
+int bt_hid_host_disconnect(const char *remote_address)
+{
+	int error;
+	bluetooth_device_address_t addr_hex = { {0,} };
+
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(remote_address);
+
+	_bt_convert_address_to_hex(&addr_hex, remote_address);
+
+	error = bluetooth_hid_disconnect((hid_device_address_t *)&addr_hex);
+	error = _bt_get_error_code(error);
+	if (error != BT_ERROR_NONE) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__,
+			_bt_convert_error_to_string(error), error);
+	}
+	return error;
+}
diff --git a/src/bluetooth-opp-client.c b/src/bluetooth-opp-client.c
new file mode 100644
index 0000000..817c1bd
--- /dev/null
+++ b/src/bluetooth-opp-client.c
@@ -0,0 +1,193 @@
+/*
+ * Copyright (c) 2011 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 <glib.h>
+#include <dlog.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include <string.h>
+#include <bluetooth-api.h>
+
+#include "bluetooth.h"
+#include "bluetooth_private.h"
+
+#ifdef LOG_TAG
+#undef LOG_TAG
+#endif
+#define LOG_TAG "TIZEN_N_BLUETOOTH"
+
+GList *sending_files;
+
+char** __bt_opp_get_file_array(GList *file_list)
+{
+	char **files = NULL;
+	char *c_file = NULL;
+	int file_num = 0;
+	int i = 0;
+
+	if (file_list == NULL)
+		return NULL;
+
+	file_num = g_list_length(file_list);
+
+	if (file_num == 0)
+		return NULL;
+
+	files = (char **)calloc(file_num + 1, sizeof(char *));
+	if (!files)
+		return NULL;
+
+	for (i = 0; i < file_num; i++) {
+		c_file = (char *)g_list_nth_data(file_list, i);
+
+		if (c_file == NULL)
+			continue;
+
+		files[i] = c_file;
+	}
+
+	for (i = 0; i < file_num; i++)
+		LOGE("[%s] %s", __FUNCTION__, files[i]);
+
+	return files;
+}
+
+int bt_opp_client_initialize(void)
+{
+	int error_code = BT_ERROR_NONE;
+
+	BT_CHECK_INIT_STATUS();
+
+	error_code = _bt_get_error_code(bluetooth_opc_init());
+
+	if (error_code != BT_ERROR_NONE) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(error_code), error_code);
+	}
+
+	return error_code;
+}
+
+int bt_opp_client_deinitialize(void)
+{
+	int error_code = BT_ERROR_NONE;
+
+	BT_CHECK_INIT_STATUS();
+
+	error_code = _bt_get_error_code(bluetooth_opc_deinit());
+
+	if (error_code != BT_ERROR_NONE) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(error_code), error_code);
+	}
+
+	bt_opp_client_clear_files();
+
+	return error_code;
+}
+
+int bt_opp_client_add_file(const char *file)
+{
+	int error_code = BT_ERROR_NONE;
+
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(file);
+
+	if (access(file, F_OK) == 0) {
+		sending_files = g_list_append(sending_files, strdup(file));
+	} else {
+		error_code = BT_ERROR_INVALID_PARAMETER;
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(error_code), error_code);
+	}
+
+	return error_code;
+}
+
+int bt_opp_client_clear_files(void)
+{
+	int i = 0;
+	int file_num = 0;
+	char *c_file = NULL;
+
+	BT_CHECK_INIT_STATUS();
+
+	if (sending_files) {
+		file_num = g_list_length(sending_files);
+
+		for (i = 0; i < file_num; i++) {
+			c_file = (char *)g_list_nth_data(sending_files, i);
+
+			if (c_file == NULL)
+				continue;
+
+			free(c_file);
+		}
+
+		g_list_free(sending_files);
+		sending_files = NULL;
+	}
+
+	return BT_ERROR_NONE;
+}
+
+int bt_opp_client_push_files(const char *remote_address,
+			bt_opp_client_push_responded_cb responded_cb,
+			bt_opp_client_push_progress_cb progress_cb,
+			bt_opp_client_push_finished_cb finished_cb,
+			void *user_data)
+{
+	int error_code = BT_ERROR_NONE;
+	bluetooth_device_address_t addr_hex = { {0,} };
+	char **files = NULL;
+
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(remote_address);
+
+	_bt_convert_address_to_hex(&addr_hex, remote_address);
+
+	files = __bt_opp_get_file_array(sending_files);
+
+	error_code = _bt_get_error_code(bluetooth_opc_push_files(&addr_hex, files));
+
+	if (error_code != BT_ERROR_NONE) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(error_code), error_code);
+	} else {
+		_bt_set_cb(BT_EVENT_OPP_CLIENT_PUSH_RESPONSED, responded_cb, user_data);
+		_bt_set_cb(BT_EVENT_OPP_CLIENT_PUSH_PROGRESS, progress_cb, user_data);
+		_bt_set_cb(BT_EVENT_OPP_CLIENT_PUSH_FINISHED, finished_cb, user_data);
+	}
+
+	bt_opp_client_clear_files();
+
+	if (files)
+		free(files);
+
+	return error_code;
+}
+
+int bt_opp_client_cancel_push(void)
+{
+	int error_code = BT_ERROR_NONE;
+
+	BT_CHECK_INIT_STATUS();
+
+	error_code = _bt_get_error_code(bluetooth_opc_cancel_push());
+
+	if (error_code != BT_ERROR_NONE) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(error_code), error_code);
+	}
+
+	return error_code;
+}
+
diff --git a/src/bluetooth-opp-server.c b/src/bluetooth-opp-server.c
new file mode 100644
index 0000000..9526a92
--- /dev/null
+++ b/src/bluetooth-opp-server.c
@@ -0,0 +1,176 @@
+/*
+ * Copyright (c) 2011 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 <dlog.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include <bluetooth-api.h>
+
+#include "bluetooth.h"
+#include "bluetooth_private.h"
+
+#ifdef LOG_TAG
+#undef LOG_TAG
+#endif
+#define LOG_TAG "TIZEN_N_BLUETOOTH"
+
+int bt_opp_server_initialize(const char *destination,
+			bt_opp_server_push_requested_cb push_requested_cb,
+			void *user_data)
+{
+	int error_code = BT_ERROR_NONE;
+
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(destination);
+
+	_bt_get_error_code(bluetooth_obex_server_init(destination));
+
+	if (error_code != BT_ERROR_NONE) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(error_code), error_code);
+	} else {
+		_bt_set_cb(BT_EVENT_OPP_PUSH_REQUESTED, push_requested_cb, user_data);
+	}
+
+	return error_code;
+}
+
+int bt_opp_server_initialize_by_connection_request(const char *destination,
+			bt_opp_server_connection_requested_cb connection_requested_cb,
+			void *user_data)
+{
+	int error_code = BT_ERROR_NONE;
+
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(destination);
+
+	_bt_get_error_code(bluetooth_obex_server_init_without_agent(destination));
+
+	if (error_code != BT_ERROR_NONE) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(error_code), error_code);
+	} else {
+		_bt_set_cb(BT_EVENT_OPP_CONNECTION_REQUESTED, connection_requested_cb, user_data);
+	}
+
+	return error_code;
+}
+
+int bt_opp_server_deinitialize(void)
+{
+	int error_code = BT_ERROR_NONE;
+
+	BT_CHECK_INIT_STATUS();
+
+	if (_bt_check_cb(BT_EVENT_OPP_CONNECTION_REQUESTED) == false) {
+		error_code = _bt_get_error_code(bluetooth_obex_server_deinit());
+	} else {
+		/* BADA API */
+		error_code = _bt_get_error_code(bluetooth_obex_server_deinit_without_agent());
+	}
+
+	if (error_code != BT_ERROR_NONE) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(error_code), error_code);
+	}
+
+	_bt_unset_cb(BT_EVENT_OPP_CONNECTION_REQUESTED);
+	_bt_unset_cb(BT_EVENT_OPP_PUSH_REQUESTED);
+
+	return error_code;
+}
+
+int bt_opp_server_accept(bt_opp_server_transfer_progress_cb progress_cb,
+			bt_opp_server_transfer_finished_cb finished_cb,
+			const char *name,
+			void *user_data,
+			int *transfer_id)
+{
+	int error_code = BT_ERROR_NONE;
+
+	BT_CHECK_INIT_STATUS();
+
+	/* Unset the transfer callbacks */
+	_bt_unset_cb(BT_EVENT_OPP_SERVER_TRANSFER_PROGRESS);
+	_bt_unset_cb(BT_EVENT_OPP_SERVER_TRANSFER_FINISHED);
+
+	if (_bt_check_cb(BT_EVENT_OPP_CONNECTION_REQUESTED) == false) {
+		error_code = _bt_get_error_code(bluetooth_obex_server_accept_authorize(name));
+	} else {
+		/* BADA API */
+		error_code = _bt_get_error_code(bluetooth_obex_server_accept_connection());
+	}
+
+	if (error_code != BT_ERROR_NONE) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(error_code), error_code);
+	} else {
+		_bt_set_cb(BT_EVENT_OPP_SERVER_TRANSFER_PROGRESS, progress_cb, user_data);
+		_bt_set_cb(BT_EVENT_OPP_SERVER_TRANSFER_FINISHED, finished_cb, user_data);
+	}
+
+	return error_code;
+}
+
+int bt_opp_server_reject(void)
+{
+	int error_code = BT_ERROR_NONE;
+
+	BT_CHECK_INIT_STATUS();
+
+	if (_bt_check_cb(BT_EVENT_OPP_CONNECTION_REQUESTED) == false) {
+		error_code = _bt_get_error_code(bluetooth_obex_server_reject_authorize());
+	} else {
+		/* BADA API */
+		error_code = _bt_get_error_code(bluetooth_obex_server_reject_connection());
+	}
+
+	if (error_code != BT_ERROR_NONE) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(error_code), error_code);
+	}
+
+	/* Unset the transfer callbacks */
+	_bt_unset_cb(BT_EVENT_OPP_SERVER_TRANSFER_PROGRESS);
+	_bt_unset_cb(BT_EVENT_OPP_SERVER_TRANSFER_FINISHED);
+
+	return error_code;
+}
+
+int bt_opp_server_set_destination(const char *destination)
+{
+	int error_code = BT_ERROR_NONE;
+
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(destination);
+
+	error_code = _bt_get_error_code(bluetooth_obex_server_set_destination_path(destination));
+	if (error_code != BT_ERROR_NONE) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(error_code), error_code);
+	}
+
+	return error_code;
+}
+
+int bt_opp_server_cancel_transfer(int transfer_id)
+{
+	int error_code = BT_ERROR_NONE;
+
+	BT_CHECK_INIT_STATUS();
+
+	error_code = _bt_get_error_code(bluetooth_obex_server_cancel_transfer(transfer_id));
+	if (error_code != BT_ERROR_NONE) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(error_code), error_code);
+	}
+
+	return error_code;
+}
+
diff --git a/src/bluetooth-pan.c b/src/bluetooth-pan.c
new file mode 100644
index 0000000..3c858a1
--- /dev/null
+++ b/src/bluetooth-pan.c
@@ -0,0 +1,128 @@
+/*
+ * Copyright (c) 2011 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 <glib.h>
+#include <dlog.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include <string.h>
+#include <bluetooth-api.h>
+
+#include "bluetooth.h"
+#include "bluetooth_private.h"
+
+#ifdef LOG_TAG
+#undef LOG_TAG
+#endif
+#define LOG_TAG "TIZEN_N_BLUETOOTH"
+
+GList *sending_files;
+
+int bt_nap_activate(void)
+{
+	int error = BT_ERROR_NONE;
+
+	BT_CHECK_INIT_STATUS();
+	error = bluetooth_network_activate_server();
+	if (error != BT_ERROR_NONE) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__,
+			_bt_convert_error_to_string(error), error);
+	}
+	return error;
+}
+
+int bt_nap_deactivate(void)
+{
+	int error = BT_ERROR_NONE;
+
+	BT_CHECK_INIT_STATUS();
+	error = bluetooth_network_deactivate_server();
+	if (error != BT_ERROR_NONE) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__,
+			_bt_convert_error_to_string(error), error);
+	}
+	return error;
+}
+
+int bt_nap_set_connection_state_changed_cb(
+				bt_nap_connection_state_changed_cb callback,
+				void *user_data)
+{
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(callback);
+	_bt_set_cb(BT_EVENT_NAP_CONNECTION_STATE_CHANGED, callback, user_data);
+	return BT_ERROR_NONE;
+
+}
+
+int bt_nap_unset_connection_state_changed_cb(void)
+{
+	_bt_unset_cb(BT_EVENT_NAP_CONNECTION_STATE_CHANGED);
+	return BT_ERROR_NONE;
+}
+
+int bt_panu_set_connection_state_changed_cb(
+				bt_panu_connection_state_changed_cb callback,
+				void *user_data)
+{
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(callback);
+	_bt_set_cb(BT_EVENT_PAN_CONNECTION_STATE_CHANGED, callback, user_data);
+	return BT_ERROR_NONE;
+}
+
+int bt_panu_unset_connection_state_changed_cb(void)
+{
+	_bt_unset_cb(BT_EVENT_PAN_CONNECTION_STATE_CHANGED);
+	return BT_ERROR_NONE;
+}
+
+int bt_panu_connect(const char *remote_address, bt_panu_service_type_e type)
+{
+	int error = BT_ERROR_INVALID_PARAMETER;
+	bluetooth_device_address_t addr_hex = { {0,} };
+
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(remote_address);
+	_bt_convert_address_to_hex(&addr_hex, remote_address);
+	if (BT_PANU_SERVICE_TYPE_NAP == type) {
+		error = bluetooth_network_connect(&addr_hex,
+					BLUETOOTH_NETWORK_NAP_ROLE, NULL);
+		if (error != BT_ERROR_NONE) {
+			LOGE("[%s] %s(0x%08x)", __FUNCTION__,
+				_bt_convert_error_to_string(error), error);
+		}
+	}
+	return error;
+}
+
+int bt_panu_disconnect(const char *remote_address)
+{
+	int error = BT_ERROR_INVALID_PARAMETER;
+	bluetooth_device_address_t addr_hex = { {0,} };
+
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(remote_address);
+	_bt_convert_address_to_hex(&addr_hex, remote_address);
+	error = bluetooth_network_disconnect(&addr_hex);
+	if (error != BT_ERROR_NONE) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__,
+			_bt_convert_error_to_string(error), error);
+	}
+	return error;
+}
+
+
diff --git a/src/bluetooth-socket.c b/src/bluetooth-socket.c
new file mode 100644
index 0000000..62296a2
--- /dev/null
+++ b/src/bluetooth-socket.c
@@ -0,0 +1,226 @@
+/*
+ * Copyright (c) 2011 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 <dlog.h>
+#include <stdio.h>
+#include <bluetooth-api.h>
+
+#include "bluetooth.h"
+#include "bluetooth_private.h"
+
+#ifdef LOG_TAG
+#undef LOG_TAG
+#endif
+#define LOG_TAG "TIZEN_N_BLUETOOTH"
+
+
+int bt_socket_create_rfcomm(const char *uuid, int *socket_fd)
+{
+	int ret = 0;
+
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(uuid);
+	BT_CHECK_INPUT_PARAMETER(socket_fd);
+
+	ret = bluetooth_rfcomm_create_socket(uuid);
+	if (ret < 0) {
+		ret = _bt_get_error_code(ret);
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
+		return ret;
+	} else {
+		*socket_fd = ret;
+		return BT_ERROR_NONE;
+	}
+}
+
+int bt_socket_destroy_rfcomm(int socket_fd)
+{
+	int error_code = BT_ERROR_NONE;
+
+	BT_CHECK_INIT_STATUS();
+	error_code = _bt_get_error_code(bluetooth_rfcomm_remove_socket(socket_fd));
+	if (error_code != BT_ERROR_NONE) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(error_code), error_code);
+	}
+
+	return error_code;
+}
+
+int bt_socket_is_service_used(const char* service_uuid, bool *used)
+{
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(service_uuid);
+	BT_CHECK_INPUT_PARAMETER(used);
+
+	*used = bluetooth_rfcomm_is_server_uuid_available(service_uuid);
+
+	return BT_ERROR_NONE;
+}
+
+int bt_socket_listen_and_accept_rfcomm(int socket_fd, int max_pending_connections)
+{
+	int error_code = BT_ERROR_NONE;
+
+	BT_CHECK_INIT_STATUS();
+	error_code = _bt_get_error_code(bluetooth_rfcomm_listen_and_accept(socket_fd, max_pending_connections));
+	if (error_code != BT_ERROR_NONE) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(error_code), error_code);
+	}
+
+	return error_code;
+}
+
+int bt_socket_listen(int socket_fd, int max_pending_connections)
+{
+	int error_code = BT_ERROR_NONE;
+
+	BT_CHECK_INIT_STATUS();
+
+	error_code = _bt_get_error_code(bluetooth_rfcomm_listen(socket_fd, max_pending_connections));
+	if (error_code != BT_ERROR_NONE) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(error_code), error_code);
+	}
+
+	return error_code;
+}
+
+int bt_socket_accept(int socket_fd, int *connected_socket_fd)
+{
+	int error_code = BT_ERROR_NONE;
+
+	BT_CHECK_INIT_STATUS();
+
+	error_code = _bt_get_error_code(bluetooth_rfcomm_accept_connection(socket_fd, connected_socket_fd));
+	if (error_code != BT_ERROR_NONE) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(error_code), error_code);
+	}
+
+	_bt_unset_cb(BT_EVENT_RFCOMM_CONNECTION_REQUESTED);
+
+	return error_code;
+}
+
+int bt_socket_reject(int socket_fd)
+{
+	int error_code = BT_ERROR_NONE;
+
+	BT_CHECK_INIT_STATUS();
+
+	error_code = _bt_get_error_code(bluetooth_rfcomm_reject_connection(socket_fd));
+	if (error_code != BT_ERROR_NONE) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(error_code), error_code);
+	}
+
+	return error_code;
+}
+
+int bt_socket_connect_rfcomm(const char *remote_address, const char *remote_port_uuid)
+{
+	bluetooth_device_address_t addr_hex = { {0,} };
+	int error_code = BT_ERROR_NONE;
+
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(remote_address);
+	BT_CHECK_INPUT_PARAMETER(remote_port_uuid);
+
+	_bt_convert_address_to_hex(&addr_hex, remote_address);
+
+	error_code = _bt_get_error_code(bluetooth_rfcomm_connect(&addr_hex, remote_port_uuid));
+	if (error_code != BT_ERROR_NONE) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(error_code), error_code);
+	}
+
+	return error_code;
+}
+
+int bt_socket_disconnect_rfcomm(int socket_fd)
+{
+	int ret = BT_ERROR_NONE;
+
+	BT_CHECK_INIT_STATUS();
+
+	ret = _bt_get_error_code(bluetooth_rfcomm_disconnect(socket_fd));
+	if (ret != BT_ERROR_NONE) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
+	}
+
+	return ret;
+}
+
+int bt_socket_send_data(int socket_fd, const char *data, int length)
+{
+	int ret = 0;
+
+	BT_CHECK_INIT_STATUS();
+	ret = bluetooth_rfcomm_write(socket_fd, data, length);
+	if (ret == BLUETOOTH_ERROR_NOT_IN_OPERATION) {
+		LOGE("[%s] OPERATION_FAILED(0x%08x)", __FUNCTION__, BT_ERROR_OPERATION_FAILED);
+		return BT_ERROR_OPERATION_FAILED;
+	}
+
+	ret = _bt_get_error_code(ret);
+	if (ret != BT_ERROR_NONE) {
+		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
+	}
+
+	return ret;
+}
+
+int bt_socket_set_data_received_cb(bt_socket_data_received_cb callback, void *user_data)
+{
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(callback);
+	_bt_set_cb(BT_EVENT_DATA_RECEIVED, callback, user_data);
+	return BT_ERROR_NONE;
+}
+
+int bt_socket_unset_data_received_cb(void)
+{
+	BT_CHECK_INIT_STATUS();
+	_bt_unset_cb(BT_EVENT_DATA_RECEIVED);
+	return BT_ERROR_NONE;
+}
+
+int bt_socket_set_connection_requested_cb(bt_socket_connection_requested_cb callback, void *user_data)
+{
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(callback);
+	_bt_set_cb(BT_EVENT_RFCOMM_CONNECTION_REQUESTED, callback, user_data);
+	return BT_ERROR_NONE;
+}
+
+int bt_socket_unset_connection_requested_cb(void)
+{
+	BT_CHECK_INIT_STATUS();
+	_bt_unset_cb(BT_EVENT_RFCOMM_CONNECTION_REQUESTED);
+	return BT_ERROR_NONE;
+}
+
+int bt_socket_set_connection_state_changed_cb(bt_socket_connection_state_changed_cb callback, void *user_data)
+{
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(callback);
+	_bt_set_cb(BT_EVENT_CONNECTION_STATE_CHANGED, callback, user_data);
+	return BT_ERROR_NONE;
+}
+
+int bt_socket_unset_connection_state_changed_cb(void)
+{
+	BT_CHECK_INIT_STATUS();
+	_bt_unset_cb(BT_EVENT_CONNECTION_STATE_CHANGED);
+	return BT_ERROR_NONE;
+}
+
diff --git a/src/bluetooth.c b/src/bluetooth.c
deleted file mode 100644
index 04e5a11..0000000
--- a/src/bluetooth.c
+++ /dev/null
@@ -1,1285 +0,0 @@
-/*
- * Copyright (c) 2011 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 <glib.h>
-#include <string.h>
-#include <stdlib.h>
-#include <ctype.h>
-#include <dlog.h>
-#include <stdio.h>
-#include <stdbool.h>
-#include <bluetooth.h>
-#include <bluetooth-api.h>
-#include <bluetooth_private.h>
-
-#ifdef LOG_TAG
-#undef LOG_TAG
-#endif
-#define LOG_TAG "TIZEN_N_BLUETOOTH"
-
-static bool is_initialized = false;
-static bt_event_sig_event_slot_s bt_event_slot_container[] = {
-	{BT_EVENT_STATE_CHANGED, NULL, NULL},
-	{BT_EVENT_NAME_CHANGED, NULL, NULL},
-	{BT_EVENT_VISIBILITY_MODE_CHANGED, NULL, NULL},
-	{BT_EVENT_DEVICE_DISCOVERY_STATE_CHANGED, NULL, NULL},
-	{BT_EVENT_BOND_CREATED, NULL, NULL},
-	{BT_EVENT_BOND_DESTROYED, NULL, NULL},
-	{BT_EVENT_AUTHORIZATION_CHANGED, NULL, NULL},
-	{BT_EVENT_SERVICE_SEARCHED, NULL, NULL},
-	{BT_EVENT_DATA_RECEIVED, NULL, NULL},
-	{BT_EVENT_CONNECTION_STATE_CHANGED, NULL, NULL},
-};
-
-/*
- *  Internal Macros
- */
-#define BT_CHECK_INIT_STATUS() \
-	if( is_initialized != true ) \
-	{ \
-		LOGE("[%s] NOT_INITIALIZED(0x%08x)", __FUNCTION__, BT_ERROR_NOT_INITIALIZED); \
-		return BT_ERROR_NOT_INITIALIZED; \
-	}
-
-#define BT_CHECK_INPUT_PARAMETER(arg) \
-	if( arg == NULL ) \
-	{ \
-		LOGE("[%s] INVALID_PARAMETER(0x%08x)", __FUNCTION__, BT_ERROR_INVALID_PARAMETER); \
-		return BT_ERROR_INVALID_PARAMETER; \
-	}
-
-/*
- *  Internal Functions
- */
-static void __bt_event_proxy(int event, bluetooth_event_param_t *param, void *user_data);
-static void __bt_set_cb(int events, void *callback, void *user_data);
-static void __bt_unset_cb(int events);
-static int __bt_get_cb_index(int event);
-static void __bt_convert_lower_to_upper(char* origin);
-static bt_adapter_visibility_mode_e __bt_get_bt_adapter_visibility_mode_e(bluetooth_discoverable_mode_t mode);
-static int __bt_get_bt_device_sdp_info_s(bt_device_sdp_info_s **dest, bt_sdp_info_t *source);
-static void __bt_free_bt_device_sdp_info_s(bt_device_sdp_info_s *sdp_info);
-static int __bt_get_bt_adapter_device_discovery_info_s(bt_adapter_device_discovery_info_s **discovery_info, bluetooth_device_info_t *source_info);
-static void __bt_free_bt_adapter_device_discovery_info_s(bt_adapter_device_discovery_info_s *discovery_info);
-
-/*
- *  Public Functions
- */
-int bt_initialize(void)
-{
-	if (is_initialized != true) {
-		if (bluetooth_register_callback(&__bt_event_proxy, NULL) != BLUETOOTH_ERROR_NONE) {
-			LOGE("[%s] OPERATION_FAILED(0x%08x)", __FUNCTION__, BT_ERROR_OPERATION_FAILED);
-			return BT_ERROR_OPERATION_FAILED;
-		}
-		is_initialized = true;
-	}
-
-	return BT_ERROR_NONE;
-}
-
-int bt_deinitialize(void)
-{
-	BT_CHECK_INIT_STATUS();
-	if (bluetooth_unregister_callback() != BLUETOOTH_ERROR_NONE) {
-		LOGE("[%s] OPERATION_FAILED(0x%08x)", __FUNCTION__, BT_ERROR_OPERATION_FAILED);
-		return BT_ERROR_OPERATION_FAILED;
-	}
-	is_initialized = false;
-
-	return BT_ERROR_NONE;
-}
-
-int bt_adapter_enable(void)
-{
-	int error_code = BT_ERROR_NONE;
-
-	BT_CHECK_INIT_STATUS();
-	error_code = _bt_get_error_code( bluetooth_enable_adapter() );
-	if (error_code != BT_ERROR_NONE) {
-		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(error_code), error_code);
-	}
-	return error_code;
-}
-
-int bt_adapter_disable(void)
-{
-	int error_code = BT_ERROR_NONE;
-
-	BT_CHECK_INIT_STATUS();
-	error_code = _bt_get_error_code( bluetooth_disable_adapter() );
-	if (error_code != BT_ERROR_NONE) {
-		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(error_code), error_code);
-	}
-	return error_code;
-}
-
-int bt_adapter_get_state(bt_adapter_state_e *adapter_state)
-{
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(adapter_state);
-
-	*adapter_state = bluetooth_check_adapter();
-	return BT_ERROR_NONE;
-}
-
-int bt_adapter_get_address(char **address)
-{
-	bluetooth_device_address_t loc_address = { {0} };
-	int error_code = BT_ERROR_NONE;
-
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(address);
-
-	error_code = _bt_get_error_code( bluetooth_get_local_address(&loc_address) );
-	if (error_code != BT_ERROR_NONE) {
-		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(error_code), error_code);
-		return error_code;
-	}
-
-	error_code = _bt_convert_address_to_string(address, &loc_address);
-	if (error_code != BT_ERROR_NONE) {
-		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(error_code), error_code);
-		return error_code;
-	}
-
-	return BT_ERROR_NONE;
-}
-
-int bt_adapter_get_name(char** name)
-{
-	int ret = BT_ERROR_NONE;
-	bluetooth_device_name_t loc_name = { {0} };
-
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(name);
-
-	ret = _bt_get_error_code( bluetooth_get_local_name(&loc_name) );
-	if (ret != BT_ERROR_NONE) {
-		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
-		return ret;
-	}
-
-	*name = strdup(loc_name.name);
-	if (*name == NULL) {
-		LOGE("[%s] OUT_OF_MEMORY(0x%08x)", __FUNCTION__, BT_ERROR_OUT_OF_MEMORY);
-		return BT_ERROR_OUT_OF_MEMORY; 
-	}
-
-	return BT_ERROR_NONE;
-}
-
-int bt_adapter_set_name(const char* name)
-{
-	bluetooth_device_name_t loc_name = { {0} };
-	int ret = BT_ERROR_NONE;
-
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(name);
-
-	strncpy(loc_name.name, name, BLUETOOTH_DEVICE_NAME_LENGTH_MAX);
-	loc_name.name[BLUETOOTH_DEVICE_NAME_LENGTH_MAX] = '\0';
-
-	ret = _bt_get_error_code( bluetooth_set_local_name(&loc_name) );
-	if (ret != BT_ERROR_NONE) {
-		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
-	}
-
-	return ret;
-}
-
-int bt_adapter_get_visibility(bt_adapter_visibility_mode_e *mode)
-{
-	bluetooth_discoverable_mode_t discoverable_mode = BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE;
-	int ret = BT_ERROR_NONE;
-
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(mode);
-
-	ret = _bt_get_error_code( bluetooth_get_discoverable_mode(&discoverable_mode) );
-	if (ret != BT_ERROR_NONE) {
-		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
-		return ret;
-	}
-
-	*mode = __bt_get_bt_adapter_visibility_mode_e(discoverable_mode);
-	return BT_ERROR_NONE;
-}
-
-int bt_adapter_set_visibility(bt_adapter_visibility_mode_e visibility_mode, int timeout_sec)
-{
-	bluetooth_discoverable_mode_t discoverable_mode = BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE;
-	int error_code = BT_ERROR_NONE;
-
-	BT_CHECK_INIT_STATUS();
-	switch (visibility_mode) {
-		case BT_ADAPTER_VISIBILITY_MODE_LIMITED_DISCOVERABLE :
-			discoverable_mode = BLUETOOTH_DISCOVERABLE_MODE_TIME_LIMITED_DISCOVERABLE;
-			break;
-		case BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE :
-			discoverable_mode = BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE;
-			timeout_sec = 0;
-			break;
-		case BT_ADAPTER_VISIBILITY_MODE_GENERAL_DISCOVERABLE :
-			discoverable_mode = BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE;
-			timeout_sec = 0;
-			break;
-		default:
-			LOGE("[%s] INVALID_PARAMETER(0x%08x)", __FUNCTION__, BT_ERROR_INVALID_PARAMETER);
-			return BT_ERROR_INVALID_PARAMETER;
-	}
-
-	error_code = _bt_get_error_code( bluetooth_set_discoverable_mode(discoverable_mode, timeout_sec) );
-	if (error_code != BT_ERROR_NONE) {
-		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(error_code), error_code);
-	}
-
-	return error_code;
-}
-
-int bt_device_create_bond(const char* device_address)
-{
-	bluetooth_device_address_t addr_hex = {{0,}};
-	int error_code = BT_ERROR_NONE;
-
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(device_address);
-
-	_bt_convert_address_to_hex(&addr_hex, device_address);
-	error_code = _bt_get_error_code( bluetooth_bond_device(&addr_hex) );
-	if (error_code != BT_ERROR_NONE) {
-		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(error_code), error_code);
-	}
-
-	return error_code;
-}
-
-int bt_device_cancel_bonding(void)
-{
-	int error_code = BT_ERROR_NONE;
-
-	BT_CHECK_INIT_STATUS();
-	error_code = _bt_get_error_code( bluetooth_cancel_bonding() );
-	if (error_code != BT_ERROR_NONE) {
-		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(error_code), error_code);
-	}
-
-	return error_code;
-}
-
-int bt_device_destroy_bond(const char *device_address)
-{
-	bluetooth_device_address_t addr_hex = {{0,}};
-	int error_code = BT_ERROR_NONE;
-
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(device_address);
-
-	_bt_convert_address_to_hex(&addr_hex, device_address);
-	error_code = _bt_get_error_code( bluetooth_unbond_device(&addr_hex) );
-	if (error_code != BT_ERROR_NONE) {
-		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(error_code), error_code);
-	}
-
-	return error_code;
-}
-
-int bt_adapter_foreach_bonded_device(bt_adapter_bonded_device_cb foreach_cb, void *user_data)
-{
-	GPtrArray* dev_list = NULL;
-	bt_device_info_s* dev_info = NULL;
-	bluetooth_device_info_t* ptr = NULL;
-	int ret = BT_ERROR_NONE;
-	int i = 0;
-
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(foreach_cb);
-
-	dev_list = g_ptr_array_new();
-	if (dev_list == NULL) {
-		LOGE("[%s] OUT_OF_MEMORY(0x%08x)", __FUNCTION__, BT_ERROR_OUT_OF_MEMORY);
-		return BT_ERROR_OUT_OF_MEMORY;
-	}
-
-	ret = _bt_get_error_code( bluetooth_get_bonded_device_list(&dev_list) );
-	if (ret != BT_ERROR_NONE) {
-		LOGE("[%s] %s(0x%08x) : Failed to get bonded device list", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
-		return ret;
-	}
-
-	for (i = 0; i < dev_list->len; i++) {
-		ptr = g_ptr_array_index(dev_list, i);
-		if (ptr != NULL) {
-			ret = _bt_get_bt_device_info_s(&dev_info, (bluetooth_device_info_t*)ptr);
-			if (ret != BT_ERROR_NONE) {
-				LOGE("[%s] %s(0x%08x) : Failed to get device info", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
-				break;
-			}
-
-			if (!foreach_cb(dev_info, user_data)) {
-				_bt_free_bt_device_info_s(dev_info);
-				break;
-			}
-			_bt_free_bt_device_info_s(dev_info);
-		} else {
-			LOGE("[%s] OPERATION_FAILED(0x%08x)", __FUNCTION__, BT_ERROR_OPERATION_FAILED);
-			ret = BT_ERROR_OPERATION_FAILED;
-			break;
-		}
-	}
-
-	if (dev_list != NULL) {
-		g_ptr_array_free(dev_list, TRUE);
-	}
-
-	return ret;
-}
-
-int bt_device_set_alias(const char* device_address, const char* alias)
-{
-	bluetooth_device_address_t addr_hex = {{0,}};
-	int error_code = BT_ERROR_NONE;
-
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(device_address);
-	BT_CHECK_INPUT_PARAMETER(alias);
-
-	_bt_convert_address_to_hex(&addr_hex, device_address);
-	error_code = _bt_get_error_code( bluetooth_set_alias(&addr_hex, alias) );
-	if (error_code != BT_ERROR_NONE) {
-		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(error_code), error_code);
-	}
-	return error_code;
-}
-
-int bt_device_set_authorization(const char *device_address, bt_device_authorization_e authorization)
-{
-	bluetooth_device_address_t addr_hex = {{0,}};
-	gboolean trusted = FALSE;
-	int error_code = BT_ERROR_NONE;
-
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(device_address);
-
-	_bt_convert_address_to_hex(&addr_hex, device_address);
-	if( authorization == BT_DEVICE_AUTHORIZED )
-		trusted = TRUE;
-
-	error_code = _bt_get_error_code( bluetooth_authorize_device(&addr_hex, trusted) );
-	if (error_code != BT_ERROR_NONE) {
-		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(error_code), error_code);
-	}
-	return error_code;
-}
-
-int bt_device_start_service_search(const char * device_address)
-{
-	bluetooth_device_address_t addr_hex = {{0,}};
-	int ret = 0;
-
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(device_address);
-
-	_bt_convert_address_to_hex(&addr_hex, device_address);
-	ret = _bt_get_error_code( bluetooth_search_service(&addr_hex) );
-
-	// In service search, BT_ERROR_SERVICE_SEARCH_FAILED is returned instead of BT_ERROR_OPERATION_FAILED.
-	if( ret == BT_ERROR_OPERATION_FAILED )
-		ret = BT_ERROR_SERVICE_SEARCH_FAILED;
-
-	if (ret != BT_ERROR_NONE) {
-		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
-	}
-	return ret;
-}
-
-int bt_device_cancel_service_search(void)
-{
-	int ret = 0;
-
-	BT_CHECK_INIT_STATUS();
-	ret = _bt_get_error_code( bluetooth_cancel_service_search() );
-	if (ret != BT_ERROR_NONE) {
-		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
-	}
-
-	return ret;
-}
-
-int bt_socket_create_rfcomm(const char* uuid, int *socket_fd)
-{
-	int ret = 0;
-
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(uuid);
-	BT_CHECK_INPUT_PARAMETER(socket_fd);
-
-	ret = bluetooth_rfcomm_create_socket(uuid);
-	if (ret < 0) {
-		ret = _bt_get_error_code(ret);
-		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
-		return ret;
-	} else {
-		*socket_fd = ret;
-		return BT_ERROR_NONE;
-	}
-}
-
-int bt_socket_destroy_rfcomm(int socket_fd)
-{
-	int error_code = BT_ERROR_NONE;
-
-	BT_CHECK_INIT_STATUS();
-	error_code = _bt_get_error_code( bluetooth_rfcomm_remove_socket(socket_fd, 0) );
-	if (error_code != BT_ERROR_NONE) {
-		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(error_code), error_code);
-	}
-
-	return error_code;
-}
-
-int bt_socket_listen_and_accept_rfcomm(int socket_fd, int max_pending_connection)
-{
-	int ret = BT_ERROR_NONE;
-
-	BT_CHECK_INIT_STATUS();
-	ret = _bt_get_error_code( bluetooth_rfcomm_listen_and_accept(socket_fd,max_pending_connection) );
-	if (ret != BT_ERROR_NONE) {
-		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
-	}
-
-	return ret;
-}
-
-int bt_socket_connect_rfcomm(const char* remote_address, const char* remote_port_uuid)
-{
-	bluetooth_device_address_t addr_hex = {{0,}};
-	int error_code = BT_ERROR_NONE;
-
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(remote_address);
-	BT_CHECK_INPUT_PARAMETER(remote_port_uuid);
-
-	_bt_convert_address_to_hex(&addr_hex, remote_address);
-
-	error_code = _bt_get_error_code( bluetooth_rfcomm_connect(&addr_hex, remote_port_uuid) );
-	if (error_code != BT_ERROR_NONE) {
-		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(error_code), error_code);
-	}
-
-	return error_code;
-}
-
-int bt_socket_disconnect_rfcomm(int socket_fd)
-{
-	int ret = BT_ERROR_NONE;
-
-	BT_CHECK_INIT_STATUS();
-
-	ret = _bt_get_error_code( bluetooth_rfcomm_disconnect(socket_fd) );
-	if (ret != BT_ERROR_NONE) {
-		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
-	}
-
-	return ret;
-}
-
-int bt_socket_send_data(int socket_fd, const char* data, int length)
-{
-	int ret = 0;
-
-	BT_CHECK_INIT_STATUS();
-	ret = bluetooth_rfcomm_write(socket_fd, data, length);
-	if (ret == BLUETOOTH_ERROR_NOT_IN_OPERATION) {
-		LOGE("[%s] OPERATION_FAILED(0x%08x)", __FUNCTION__, BT_ERROR_OPERATION_FAILED);
-		return BT_ERROR_OPERATION_FAILED;
-	}
-
-	ret = _bt_get_error_code(ret);
-	if (ret != BT_ERROR_NONE) {
-		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
-	}
-
-	return ret;
-}
-
-int bt_adapter_set_state_changed_cb(bt_adapter_state_changed_cb callback, void* user_data)
-{
-	int ret = BT_ERROR_NONE;
-
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(callback);
-	__bt_set_cb(BT_EVENT_STATE_CHANGED, callback, user_data);
-	if (ret != BT_ERROR_NONE) {
-		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
-	}
-
-	return ret;
-}
-
-int bt_adapter_set_name_changed_cb(bt_adapter_name_changed_cb callback, void* user_data)
-{
-	int ret = BT_ERROR_NONE;
-
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(callback);
-	__bt_set_cb(BT_EVENT_NAME_CHANGED, callback, user_data);
-	if (ret != BT_ERROR_NONE) {
-		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
-	}
-
-	return ret;
-}
-
-int bt_adapter_set_visibility_mode_changed_cb(bt_adapter_visibility_mode_changed_cb callback, void* user_data)
-{
-	int ret = BT_ERROR_NONE;
-
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(callback);
-	__bt_set_cb(BT_EVENT_VISIBILITY_MODE_CHANGED, callback, user_data);
-	if (ret != BT_ERROR_NONE) {
-		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
-	}
-
-	return ret;
-}
-
-int bt_adapter_set_device_discovery_state_changed_cb(bt_adapter_device_discovery_state_changed_cb callback, void* user_data)
-{
-	int ret = BT_ERROR_NONE;
-
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(callback);
-	__bt_set_cb(BT_EVENT_DEVICE_DISCOVERY_STATE_CHANGED, callback, user_data);
-	if (ret != BT_ERROR_NONE) {
-		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
-	}
-
-	return ret;
-}
-
-int bt_device_set_bond_created_cb(bt_device_bond_created_cb callback, void* user_data)
-{
-	int ret = BT_ERROR_NONE;
-
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(callback);
-	__bt_set_cb(BT_EVENT_BOND_CREATED, callback, user_data);
-	if (ret != BT_ERROR_NONE) {
-		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
-	}
-
-	return ret;
-}
-
-int bt_device_set_bond_destroyed_cb(bt_device_bond_destroyed_cb callback, void* user_data)
-{
-	int ret = BT_ERROR_NONE;
-
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(callback);
-	__bt_set_cb(BT_EVENT_BOND_DESTROYED, callback, user_data);
-	if (ret != BT_ERROR_NONE) {
-		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
-	}
-
-	return ret;
-}
-
-int bt_device_set_authorization_changed_cb(bt_device_authorization_changed_cb callback, void* user_data)
-{
-	int ret = BT_ERROR_NONE;
-
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(callback);
-	__bt_set_cb(BT_EVENT_AUTHORIZATION_CHANGED, callback, user_data);
-	if (ret != BT_ERROR_NONE) {
-		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
-	}
-
-	return ret;
-}
-
-int bt_device_set_service_searched_cb(bt_device_service_searched_cb callback, void* user_data)
-{
-	int ret = BT_ERROR_NONE;
-
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(callback);
-	__bt_set_cb(BT_EVENT_SERVICE_SEARCHED, callback, user_data);
-	if (ret != BT_ERROR_NONE) {
-		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
-	}
-
-	return ret;
-}
-
-int bt_socket_set_data_received_cb(bt_socket_data_received_cb callback, void* user_data)
-{
-	int ret = BT_ERROR_NONE;
-
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(callback);
-	__bt_set_cb(BT_EVENT_DATA_RECEIVED, callback, user_data);
-	if (ret != BT_ERROR_NONE) {
-		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
-	}
-
-	return ret;
-}
-
-int bt_socket_set_connection_state_changed_cb(bt_socket_connection_state_changed_cb callback, void* user_data)
-{
-	int ret = BT_ERROR_NONE;
-
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(callback);
-	__bt_set_cb(BT_EVENT_CONNECTION_STATE_CHANGED, callback, user_data);
-	if (ret != BT_ERROR_NONE) {
-		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
-	}
-
-	return ret;
-}
-
-int bt_adapter_unset_state_changed_cb(void)
-{
-	BT_CHECK_INIT_STATUS();
-	__bt_unset_cb(BT_EVENT_STATE_CHANGED);
-	return BT_ERROR_NONE;
-}
-
-int bt_adapter_unset_name_changed_cb(void)
-{
-	BT_CHECK_INIT_STATUS();
-	__bt_unset_cb(BT_EVENT_NAME_CHANGED);
-	return BT_ERROR_NONE;
-}
-
-int bt_adapter_unset_visibility_mode_changed_cb(void)
-{
-	BT_CHECK_INIT_STATUS();
-	__bt_unset_cb(BT_EVENT_VISIBILITY_MODE_CHANGED);
-	return BT_ERROR_NONE;
-}
-
-int bt_adapter_unset_device_discovery_state_changed_cb(void)
-{
-	BT_CHECK_INIT_STATUS();
-	__bt_unset_cb(BT_EVENT_DEVICE_DISCOVERY_STATE_CHANGED);
-	return BT_ERROR_NONE;
-}
-
-int bt_device_unset_bond_created_cb(void)
-{
-	BT_CHECK_INIT_STATUS();
-	__bt_unset_cb(BT_EVENT_BOND_CREATED);
-	return BT_ERROR_NONE;
-}
-
-int bt_device_unset_bond_destroyed_cb(void)
-{
-	BT_CHECK_INIT_STATUS();
-	__bt_unset_cb(BT_EVENT_BOND_DESTROYED);
-	return BT_ERROR_NONE;
-}
-
-int bt_device_unset_authorization_changed_cb(void)
-{
-	BT_CHECK_INIT_STATUS();
-	__bt_unset_cb(BT_EVENT_AUTHORIZATION_CHANGED);
-	return BT_ERROR_NONE;
-}
-
-int bt_device_unset_service_searched_cb(void)
-{
-	BT_CHECK_INIT_STATUS();
-	__bt_unset_cb(BT_EVENT_SERVICE_SEARCHED);
-	return BT_ERROR_NONE;
-}
-
-int bt_socket_unset_data_received_cb(void)
-{
-	BT_CHECK_INIT_STATUS();
-	__bt_unset_cb(BT_EVENT_DATA_RECEIVED);
-	return BT_ERROR_NONE;
-}
-
-int bt_socket_unset_connection_state_changed_cb(void)
-{
-	BT_CHECK_INIT_STATUS();
-	__bt_unset_cb(BT_EVENT_CONNECTION_STATE_CHANGED);
-	return BT_ERROR_NONE;
-}
-
-int bt_adapter_start_device_discovery(void)
-{
-	int error_code = BT_ERROR_NONE;
-
-	BT_CHECK_INIT_STATUS();
-	error_code = _bt_get_error_code( bluetooth_start_discovery(0, 0, BLUETOOTH_DEVICE_MAJOR_MASK_MISC) );
-	if (error_code != BT_ERROR_NONE) {
-		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(error_code), error_code);
-	}
-	return error_code;
-}
-
-int bt_adapter_stop_device_discovery(void)
-{
-	int error_code = BT_ERROR_NONE;
-
-	BT_CHECK_INIT_STATUS();
-	error_code = _bt_get_error_code( bluetooth_cancel_discovery() );
-	if (error_code != BT_ERROR_NONE) {
-		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(error_code), error_code);
-	}
-	return error_code;
-}
-
-int bt_adapter_is_discovering(bool* is_discovering)
-{
-	int ret = 0;
-
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(is_discovering);
-
-	ret = bluetooth_is_discovering();
-	if (ret >= BLUETOOTH_ERROR_BASE) {
-		*is_discovering = (ret == 1)?true:false;
-		return BT_ERROR_NONE;
-	} else {
-		ret = _bt_get_error_code(ret);
-		LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
-		return ret;
-	}
-}
-
-/*
- *  Internal Functions
- */
-static void __bt_set_cb(int events, void* callback, void* user_data)
-{
-	bt_event_slot_container[events].callback = callback;
-	bt_event_slot_container[events].user_data = user_data;
-}
-
-static void __bt_unset_cb(int events)
-{
-	if (bt_event_slot_container[events].callback != NULL) {
-		bt_event_slot_container[events].callback = NULL;
-		bt_event_slot_container[events].user_data = NULL;
-	}
-}
-
-int _bt_get_error_code(int origin_error)
-{
-	switch (origin_error) {
-		case BLUETOOTH_ERROR_NONE:
-			return BT_ERROR_NONE;
-		case BLUETOOTH_ERROR_INVALID_DATA:
-		case BLUETOOTH_ERROR_INVALID_PARAM:
-		case BLUETOOTH_ERROR_NOT_CONNECTED:
-		case BLUETOOTH_ERROR_NOT_SUPPORT:
-			return BT_ERROR_INVALID_PARAMETER;
-		case BLUETOOTH_ERROR_MEMORY_ALLOCATION:
-		case BLUETOOTH_ERROR_OUT_OF_MEMORY:
-			return BT_ERROR_OUT_OF_MEMORY;
-		case BLUETOOTH_ERROR_TIMEOUT:
-			return BT_ERROR_TIMED_OUT;
-		case BLUETOOTH_ERROR_DEVICE_NOT_ENABLED:
-			return BT_ERROR_NOT_ENABLED;
-		case BLUETOOTH_ERROR_DEVICE_ALREADY_ENABLED:
-			return BT_ERROR_ALREADY_DONE;
-		case BLUETOOTH_ERROR_NOT_PAIRED:
-			return BT_ERROR_REMOTE_DEVICE_NOT_BONDED;
-		case BLUETOOTH_ERROR_NOT_IN_OPERATION:
-			return BT_ERROR_NOT_IN_PROGRESS;
-		case BLUETOOTH_ERROR_IN_PROGRESS:
-			return BT_ERROR_NOW_IN_PROGRESS;
-		case BLUETOOTH_ERROR_DEVICE_BUSY:
-			return BT_ERROR_RESOURCE_BUSY;
-		case BLUETOOTH_ERROR_CANCEL:
-		case BLUETOOTH_ERROR_CANCEL_BY_USER:
-			return BT_ERROR_CANCELLED;
-		case BLUETOOTH_ERROR_AUTHENTICATION_FAILED:
-			return BT_ERROR_AUTH_FAILED;
-		case BLUETOOTH_ERROR_HOST_DOWN:
-			return BT_ERROR_REMOTE_DEVICE_NOT_FOUND;
-		case BLUETOOTH_ERROR_SERVICE_SEARCH_ERROR:
-			return BT_ERROR_SERVICE_SEARCH_FAILED;
-		case BLUETOOTH_ERROR_SERVICE_NOT_FOUND:
-		case BLUETOOTH_ERROR_PARING_FAILED:
-		case BLUETOOTH_ERROR_MAX_CONNECTION:
-		case BLUETOOTH_ERROR_ALREADY_CONNECT:
-		case BLUETOOTH_ERROR_NO_RESOURCES:
-		case BLUETOOTH_ERROR_REGISTRATION_FAILED:
-		case BLUETOOTH_ERROR_CONNECTION_BUSY:
-		case BLUETOOTH_ERROR_MAX_CLIENT:
-		case BLUETOOTH_ERROR_INVALID_CALLBACK:
-		case BLUETOOTH_ERROR_NOT_FOUND:
-		case BLUETOOTH_ERROR_INTERNAL:
-		case BLUETOOTH_ERROR_CONNECTION_ERROR:
-		case BLUETOOTH_ERROR_ACCESS_DENIED:
-		default:
-			return BT_ERROR_OPERATION_FAILED;
-	}
-
-}
-
-int _bt_get_bt_device_info_s(bt_device_info_s** dest_dev, bluetooth_device_info_t* source_dev)
-{
-	int i = 0;
-
-	BT_CHECK_INPUT_PARAMETER(source_dev);
-
-	*dest_dev = (bt_device_info_s *)malloc(sizeof(bt_device_info_s));
-	if (*dest_dev == NULL) {
-		return BT_ERROR_OUT_OF_MEMORY;
-	}
-
-	if (strlen(source_dev->device_name.name) > 0) {
-		(*dest_dev)->remote_name = strdup(source_dev->device_name.name);
-	} else {
-		(*dest_dev)->remote_name = NULL;
-	}
-
-	_bt_convert_address_to_string(&((*dest_dev)->remote_address), &(source_dev->device_address));
-
-	(*dest_dev)->bt_class.major_device_class = source_dev->device_class.major_class;
-	(*dest_dev)->bt_class.minor_device_class = source_dev->device_class.minor_class;
-	(*dest_dev)->bt_class.major_service_class_mask = source_dev->device_class.service_class;
-	if (source_dev->service_index > 0) {
-		(*dest_dev)->service_uuid = (char**)malloc(sizeof(char*) * source_dev->service_index);
-		if ((*dest_dev)->service_uuid != NULL) {
-			for (i = 0; i < source_dev->service_index; i++) {
-				(*dest_dev)->service_uuid[i] = strdup(source_dev->uuids[i]);
-				if ((*dest_dev)->service_uuid[i] != NULL) {
-					__bt_convert_lower_to_upper((*dest_dev)->service_uuid[i]);
-				}
-			}
-		}
-	} else {
-		(*dest_dev)->service_uuid = NULL;
-	}
-	(*dest_dev)->service_count = source_dev->service_index;
-	(*dest_dev)->is_bonded = (bool)source_dev->paired;
-	(*dest_dev)->is_connected = (bool)source_dev->connected;
-	(*dest_dev)->is_authorized = (bool)source_dev->trust;
-
-	return BT_ERROR_NONE;
-}
-
-void _bt_free_bt_device_info_s(bt_device_info_s* device_info)
-{
-	int i = 0;
-
-	if(device_info == NULL)
-		return;
-
-	if(device_info->remote_name != NULL)
-		free(device_info->remote_name);
-
-	if(device_info->remote_address != NULL)
-		free(device_info->remote_address);
-
-	if (device_info->service_uuid != NULL) {
-		for (i = 0; i < device_info->service_count; i++) {
-			if( device_info->service_uuid[i] != NULL )
-				free(device_info->service_uuid[i]);
-		}
-		free(device_info->service_uuid);
-	}
-
-	free(device_info);
-	device_info = NULL;
-}
-
-int _bt_convert_address_to_string(char** addr_str, bluetooth_device_address_t* addr_hex)
-{
-	char address[18] = {0,};
-
-	snprintf(address, 18, "%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X", addr_hex->addr[0], addr_hex->addr[1], addr_hex->addr[2], addr_hex->addr[3], addr_hex->addr[4], addr_hex->addr[5]);
-	*addr_str = strdup(address);
-
-	if (*addr_str != NULL) {
-		return BT_ERROR_NONE;
-	} else {
-		return BT_ERROR_OUT_OF_MEMORY;
-	}
-}
-
-void _bt_convert_address_to_hex(bluetooth_device_address_t* addr_hex, const char* addr_str)
-{
-	int i = 0;
-	unsigned int addr[BLUETOOTH_ADDRESS_LENGTH] = {0,};
-
-	i = sscanf(addr_str, "%X:%X:%X:%X:%X:%X", &addr[0], &addr[1], &addr[2], &addr[3], &addr[4], &addr[5]);
-	if (i != BLUETOOTH_ADDRESS_LENGTH) {
-		LOGI("[%s] Invalid format string - %s", __FUNCTION__, addr_str);
-	}
-
-	for (i = 0; i < BLUETOOTH_ADDRESS_LENGTH; i++) {
-		addr_hex->addr[i] = (unsigned char)addr[i];
-	}
-}
-
-static int __bt_get_bt_device_sdp_info_s(bt_device_sdp_info_s** dest, bt_sdp_info_t* source)
-{
-	int i = 0;
-
-	*dest = (bt_device_sdp_info_s *)malloc(sizeof(bt_device_sdp_info_s));
-	if (*dest == NULL) {
-		return BT_ERROR_OUT_OF_MEMORY;
-	}
-
-	if (_bt_convert_address_to_string(&((*dest)->remote_address), &(source->device_addr)) != BT_ERROR_NONE) {
-		__bt_free_bt_device_sdp_info_s(*dest);
-		return BT_ERROR_OUT_OF_MEMORY;
-	}
-
-	if (source->service_index > 0) {
-		(*dest)->service_uuid = (char**)malloc(sizeof(char*) * source->service_index);
-		if ((*dest)->service_uuid == NULL) {
-			__bt_free_bt_device_sdp_info_s(*dest);
-			return BT_ERROR_OUT_OF_MEMORY;
-		}
-
-		for (i = 0; i < source->service_index; i++) {
-			(*dest)->service_uuid[i] = strdup(source->uuids[i]);
-			if ((*dest)->service_uuid[i] == NULL) {
-				__bt_free_bt_device_sdp_info_s(*dest);
-				return BT_ERROR_OUT_OF_MEMORY;
-			}
-			__bt_convert_lower_to_upper((*dest)->service_uuid[i]);
-		}
-	} else {
-		(*dest)->service_uuid = NULL;
-	}
-	(*dest)->service_count = source->service_index;
-
-	return BT_ERROR_NONE;
-}
-
-static void __bt_free_bt_device_sdp_info_s(bt_device_sdp_info_s* sdp_info)
-{
-	int i = 0;
-
-	if(sdp_info == NULL)
-		return;
-
-	if(sdp_info->remote_address != NULL)
-		free(sdp_info->remote_address);
-
-	if (sdp_info->service_uuid != NULL) {
-		for (i = 0; i < sdp_info->service_count; i++) {
-			if( sdp_info->service_uuid[i] != NULL )
-				free( sdp_info->service_uuid[i] );
-		}
-		free( sdp_info->service_uuid );
-	}
-
-	free(sdp_info);
-	sdp_info = NULL;
-}
-
-static bt_adapter_visibility_mode_e __bt_get_bt_adapter_visibility_mode_e(bluetooth_discoverable_mode_t mode)
-{
-	switch (mode) {
-		case BLUETOOTH_DISCOVERABLE_MODE_TIME_LIMITED_DISCOVERABLE:
-			return BT_ADAPTER_VISIBILITY_MODE_LIMITED_DISCOVERABLE;
-		case BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE:
-			return BT_ADAPTER_VISIBILITY_MODE_GENERAL_DISCOVERABLE;
-		default:
-			return BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE;
-	}
-}
-
-static void __bt_event_proxy(int event, bluetooth_event_param_t *param, void* user_data)
-{
-	bluetooth_rfcomm_connection_t* connection_ind = NULL;
-	bluetooth_rfcomm_disconnection_t* disconnection_ind = NULL;
-	bt_socket_connection_s rfcomm_connection;
-	bt_device_sdp_info_s* sdp_info = NULL;
-	bt_adapter_device_discovery_info_s* discovery_info = NULL;
-	bt_device_info_s *bonded_device = NULL;
-	char* device_addr = NULL;
-	int error_code = BT_ERROR_NONE;
-	int event_index = -1;
-
-	event_index = __bt_get_cb_index(event);
-	if (event_index == -1 || bt_event_slot_container[event_index].callback == NULL) {
-		return;
-	}
-
-	switch (event) {
-		case BLUETOOTH_EVENT_ENABLED:
-			LOGI("[%s] bt_adapter_state_changed_cb() will be called with BT_ADAPTER_ENABLED", __FUNCTION__);
-			((bt_adapter_state_changed_cb)bt_event_slot_container[event_index].callback)
-		    (_bt_get_error_code(param->result), BT_ADAPTER_ENABLED, bt_event_slot_container[event_index].user_data);
-			break;
-		case BLUETOOTH_EVENT_DISABLED:
-			LOGI("[%s] bt_adapter_state_changed_cb() will be called with BT_ADAPTER_DISABLED", __FUNCTION__);
-			((bt_adapter_state_changed_cb)bt_event_slot_container[event_index].callback)
-		    (_bt_get_error_code(param->result), BT_ADAPTER_DISABLED, bt_event_slot_container[event_index].user_data);
-			break;
-		case BLUETOOTH_EVENT_LOCAL_NAME_CHANGED:
-			LOGI("[%s] bt_adapter_name_changed_cb() will be called", __FUNCTION__);
-			((bt_adapter_name_changed_cb)bt_event_slot_container[event_index].callback)
-				((char*)(param->param_data), bt_event_slot_container[event_index].user_data);
-			break;
-		case BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED:
-			LOGI("[%s] bt_adapter_visibility_mode_changed_cb() will be called", __FUNCTION__);
-			((bt_adapter_visibility_mode_changed_cb)bt_event_slot_container[event_index].callback)
-		    (_bt_get_error_code(param->result), __bt_get_bt_adapter_visibility_mode_e(*(bt_adapter_visibility_mode_e *)(param->param_data)), bt_event_slot_container[event_index].user_data);
-			break;
-		case BLUETOOTH_EVENT_DISCOVERY_STARTED:
-			LOGI("[%s] bt_adapter_device_discovery_state_changed_cb() will be called with BT_ADAPTER_DEVICE_DISCOVERY_STARTED", __FUNCTION__);
-			((bt_adapter_device_discovery_state_changed_cb)bt_event_slot_container[event_index].callback)
-		    (_bt_get_error_code(param->result), BT_ADAPTER_DEVICE_DISCOVERY_STARTED, NULL, bt_event_slot_container[event_index].user_data);
-			break;
-		case BLUETOOTH_EVENT_DISCOVERY_FINISHED:
-			LOGI("[%s] bt_adapter_device_discovery_state_changed_cb() will be called with BT_ADAPTER_DEVICE_DISCOVERY_FINISHED", __FUNCTION__);
-			((bt_adapter_device_discovery_state_changed_cb)bt_event_slot_container[event_index].callback)
-		    (_bt_get_error_code(param->result), BT_ADAPTER_DEVICE_DISCOVERY_FINISHED, NULL, bt_event_slot_container[event_index].user_data);
-			break;
-		case BLUETOOTH_EVENT_REMOTE_DEVICE_NAME_UPDATED:
-			LOGI("[%s] bt_adapter_device_discovery_state_changed_cb() will be called with BT_ADAPTER_DEVICE_DISCOVERY_FOUND", __FUNCTION__);
-			if( __bt_get_bt_adapter_device_discovery_info_s(&discovery_info, (bluetooth_device_info_t *)(param->param_data)) == BT_ERROR_NONE ) {
-				((bt_adapter_device_discovery_state_changed_cb)bt_event_slot_container[event_index].callback)
-					(_bt_get_error_code(param->result), BT_ADAPTER_DEVICE_DISCOVERY_FOUND, discovery_info, bt_event_slot_container[event_index].user_data);
-				__bt_free_bt_adapter_device_discovery_info_s(discovery_info);
-			} else {
-				((bt_adapter_device_discovery_state_changed_cb)bt_event_slot_container[event_index].callback)
-					(_bt_get_error_code(param->result), BT_ADAPTER_DEVICE_DISCOVERY_FOUND, NULL, bt_event_slot_container[event_index].user_data);
-			}
-			break;
-		case BLUETOOTH_EVENT_BONDING_FINISHED:
-			LOGI("[%s] bt_device_bond_created_cb() will be called", __FUNCTION__);
-			_bt_get_bt_device_info_s(&bonded_device, (bluetooth_device_info_t *)(param->param_data));
-
-			((bt_device_bond_created_cb)bt_event_slot_container[event_index].callback)
-			  (_bt_get_error_code(param->result), bonded_device, bt_event_slot_container[event_index].user_data);
-			_bt_free_bt_device_info_s(bonded_device);
-			bonded_device = NULL;
-			break;
-		case BLUETOOTH_EVENT_BONDED_DEVICE_REMOVED:
-			LOGI("[%s] bt_device_bond_destroyed_cb() will be called", __FUNCTION__);
-			_bt_convert_address_to_string(&device_addr, (bluetooth_device_address_t *)(param->param_data));
-			((bt_device_bond_destroyed_cb)bt_event_slot_container[event_index].callback)
-			  (_bt_get_error_code(param->result), device_addr, bt_event_slot_container[event_index].user_data);
-			if(device_addr != NULL)
-				free(device_addr);
-			device_addr = NULL;
-			break;
-		case BLUETOOTH_EVENT_DEVICE_AUTHORIZED:
-			LOGI("[%s] bt_device_authorization_changed_cb() will be called with BT_DEVICE_AUTHORIZED", __FUNCTION__);
-			_bt_convert_address_to_string(&device_addr, (bluetooth_device_address_t *)(param->param_data));
-			((bt_device_authorization_changed_cb)bt_event_slot_container[event_index].callback)
-				(BT_DEVICE_AUTHORIZED, device_addr, bt_event_slot_container[event_index].user_data);
-			if(device_addr != NULL)
-				free(device_addr);
-			device_addr = NULL;
-			break;
-		case BLUETOOTH_EVENT_DEVICE_UNAUTHORIZED:
-			LOGI("[%s] bt_device_authorization_changed_cb() will be called with BT_DEVICE_UNAUTHORIZED", __FUNCTION__);
-			_bt_convert_address_to_string(&device_addr, (bluetooth_device_address_t *)(param->param_data));
-			((bt_device_authorization_changed_cb)bt_event_slot_container[event_index].callback)
-				(BT_DEVICE_UNAUTHORIZED, device_addr, bt_event_slot_container[event_index].user_data);
-			if(device_addr != NULL)
-				free(device_addr);
-			device_addr = NULL;
-			break;
-		case BLUETOOTH_EVENT_SERVICE_SEARCHED:
-			LOGI("[%s] bt_device_service_searched_cb() will be called", __FUNCTION__);
-			__bt_get_bt_device_sdp_info_s(&sdp_info, (bt_sdp_info_t*)(param->param_data));
-			error_code = _bt_get_error_code(param->result);
-			// In service search, BT_ERROR_SERVICE_SEARCH_FAILED is returned instead of BT_ERROR_OPERATION_FAILED.
-			if( error_code == BT_ERROR_OPERATION_FAILED )
-				error_code = BT_ERROR_SERVICE_SEARCH_FAILED;
-			((bt_device_service_searched_cb)bt_event_slot_container[event_index].callback)
-				(error_code, sdp_info, bt_event_slot_container[event_index].user_data);
-			__bt_free_bt_device_sdp_info_s(sdp_info);
-			break;
-		case BLUETOOTH_EVENT_RFCOMM_DATA_RECEIVED:
-			LOGI("[%s] bt_socket_data_received_cb() will be called", __FUNCTION__);
-			((bt_socket_data_received_cb)bt_event_slot_container[event_index].callback)
-				((bt_socket_received_data_s*)(param->param_data), bt_event_slot_container[event_index].user_data);
-			break;
-		case BLUETOOTH_EVENT_RFCOMM_CONNECTED:
-			LOGI("[%s] bt_socket_connection_state_changed_cb() will be called with BT_SOCKET_CONNECTED", __FUNCTION__);
-			// In other case, BLUETOOTH_ERROR_INVALID_PARAM will be changed to BT_ERROR_INVALID_PARAM
-			if(param->result == BLUETOOTH_ERROR_INVALID_PARAM)
-				error_code = BT_ERROR_OPERATION_FAILED;
-			else
-				error_code = _bt_get_error_code(param->result);
-
-			connection_ind = (bluetooth_rfcomm_connection_t*)(param->param_data);
-			rfcomm_connection.socket_fd = connection_ind->socket_fd;
-			rfcomm_connection.local_role = connection_ind->device_role;
-			_bt_convert_address_to_string(&(rfcomm_connection.remote_address), &(connection_ind->device_addr));
-
-			((bt_socket_connection_state_changed_cb)bt_event_slot_container[event_index].callback)
-				(error_code, BT_SOCKET_CONNECTED, &rfcomm_connection, bt_event_slot_container[event_index].user_data);
-
-			if( rfcomm_connection.remote_address != NULL ) {
-				free(rfcomm_connection.remote_address);
-				rfcomm_connection.remote_address = NULL;
-			}
-
-			break;
-		case BLUETOOTH_EVENT_RFCOMM_DISCONNECTED:
-			LOGI("[%s] bt_socket_connection_state_changed_cb() will be called with BT_SOCKET_DISCONNECTED", __FUNCTION__);
-			disconnection_ind = (bluetooth_rfcomm_disconnection_t*)(param->param_data);
-			rfcomm_connection.socket_fd = disconnection_ind->socket_fd;
-			rfcomm_connection.local_role = BT_SOCKET_UNKNOWN;
-			_bt_convert_address_to_string(&(rfcomm_connection.remote_address), &(disconnection_ind->device_addr));
-			((bt_socket_connection_state_changed_cb)bt_event_slot_container[event_index].callback)
-				(_bt_get_error_code(param->result), BT_SOCKET_DISCONNECTED, &rfcomm_connection, bt_event_slot_container[event_index].user_data);
-
-			if( rfcomm_connection.remote_address != NULL ) {
-				free(rfcomm_connection.remote_address);
-				rfcomm_connection.remote_address = NULL;
-			}
-			break;
-	}
-}
-
-static int __bt_get_bt_adapter_device_discovery_info_s(bt_adapter_device_discovery_info_s **discovery_info, bluetooth_device_info_t *source_info) {
-	BT_CHECK_INPUT_PARAMETER(source_info);
-
-	*discovery_info = (bt_adapter_device_discovery_info_s *)malloc(sizeof(bt_adapter_device_discovery_info_s));
-	if (*discovery_info == NULL) {
-		return BT_ERROR_OUT_OF_MEMORY;
-	}
-
-	if (strlen(source_info->device_name.name) > 0) {
-		(*discovery_info)->remote_name = strdup(source_info->device_name.name);
-	} else {
-		(*discovery_info)->remote_name = NULL;
-	}
-
-	_bt_convert_address_to_string(&((*discovery_info)->remote_address), &(source_info->device_address));
-
-	(*discovery_info)->bt_class.major_device_class = source_info->device_class.major_class;
-	(*discovery_info)->bt_class.minor_device_class = source_info->device_class.minor_class;
-	(*discovery_info)->bt_class.major_service_class_mask = source_info->device_class.service_class;
-
-	(*discovery_info)->rssi = (bool)source_info->rssi;
-	(*discovery_info)->is_bonded = (bool)source_info->paired;
-
-	return BT_ERROR_NONE;
-}
-
-static void __bt_free_bt_adapter_device_discovery_info_s(bt_adapter_device_discovery_info_s* discovery_info)
-{
-	if(discovery_info == NULL)
-		return;
-
-	if(discovery_info->remote_name != NULL)
-		free(discovery_info->remote_name);
-
-	if(discovery_info->remote_address != NULL)
-		free(discovery_info->remote_address);
-
-	free(discovery_info);
-	discovery_info = NULL;
-}
-
-static int __bt_get_cb_index(int event)
-{
-	switch (event) {
-		case BLUETOOTH_EVENT_ENABLED:
-		case BLUETOOTH_EVENT_DISABLED:
-			return BT_EVENT_STATE_CHANGED;
-		case BLUETOOTH_EVENT_LOCAL_NAME_CHANGED:
-			return BT_EVENT_NAME_CHANGED;
-		case BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED:
-			return BT_EVENT_VISIBILITY_MODE_CHANGED;
-		case BLUETOOTH_EVENT_DISCOVERY_STARTED:
-		case BLUETOOTH_EVENT_DISCOVERY_FINISHED:
-		case BLUETOOTH_EVENT_REMOTE_DEVICE_NAME_UPDATED:
-			return BT_EVENT_DEVICE_DISCOVERY_STATE_CHANGED;
-		case BLUETOOTH_EVENT_BONDING_FINISHED:
-			return BT_EVENT_BOND_CREATED;
-		case BLUETOOTH_EVENT_BONDED_DEVICE_REMOVED:
-			return BT_EVENT_BOND_DESTROYED;
-		case BLUETOOTH_EVENT_DEVICE_AUTHORIZED:
-		case BLUETOOTH_EVENT_DEVICE_UNAUTHORIZED:
-			return BT_EVENT_AUTHORIZATION_CHANGED;
-		case BLUETOOTH_EVENT_SERVICE_SEARCHED:
-			return BT_EVENT_SERVICE_SEARCHED;
-		case BLUETOOTH_EVENT_RFCOMM_DATA_RECEIVED:
-			return BT_EVENT_DATA_RECEIVED;
-		case BLUETOOTH_EVENT_RFCOMM_CONNECTED:
-		case BLUETOOTH_EVENT_RFCOMM_DISCONNECTED:
-			return BT_EVENT_CONNECTION_STATE_CHANGED;
-		default:
-			return -1;
-	}
-}
-
-char* _bt_convert_error_to_string(int error)
-{
-	switch (error) {
-		case BT_ERROR_CANCELLED:
-			return "CANCELLED";
-		case BT_ERROR_INVALID_PARAMETER:
-			return "INVALID_PARAMETER";
-		case BT_ERROR_OUT_OF_MEMORY:
-			return "OUT_OF_MEMORY";
-		case BT_ERROR_RESOURCE_BUSY:
-			return "RESOURCE_BUSY";
-		case BT_ERROR_TIMED_OUT:
-			return "TIMED_OUT";
-		case BT_ERROR_NOW_IN_PROGRESS:
-			return "NOW_IN_PROGRESS";
-		case BT_ERROR_NOT_INITIALIZED:
-			return "NOT_INITIALIZED";
-		case BT_ERROR_NOT_ENABLED:
-			return "DEVICE_NOT_ENABLED";
-		case BT_ERROR_ALREADY_DONE:
-			return "ALREADY_DONE";
-		case BT_ERROR_OPERATION_FAILED:
-			return "OPERATION_FAILED";
-		case BT_ERROR_NOT_IN_PROGRESS:
-			return "NOT_IN_PROGRESS";
-		case BT_ERROR_REMOTE_DEVICE_NOT_BONDED:
-			return "REMOTE_DEVICE_NOT_BONDED";
-		case BT_ERROR_AUTH_REJECTED:
-			return "AUTH_REJECTED";
-		case BT_ERROR_AUTH_FAILED:
-			return "AUTH_FAILED";
-		case BT_ERROR_REMOTE_DEVICE_NOT_FOUND:
-			return "REMOTE_DEVICE_NOT_FOUND";
-		case BT_ERROR_SERVICE_SEARCH_FAILED:
-			return "SERVICE_SEARCH_FAILED";
-		default:
-			return "UNKNOWN";
-	}
-}
-
-static void __bt_convert_lower_to_upper(char* origin)
-{
-	int length = strlen(origin);
-	int i = 0;
-
-	for (i = 0; i < length; i++) {
-		if (islower(origin[i])) {
-			origin[i] = toupper(origin[i]);
-		}
-	}
-}
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
deleted file mode 100644
index 7715cac..0000000
--- a/test/CMakeLists.txt
+++ /dev/null
@@ -1,17 +0,0 @@
-SET(fw_test "${fw_name}-test")
-
-INCLUDE(FindPkgConfig)
-pkg_check_modules(${fw_test} REQUIRED glib-2.0)
-FOREACH(flag ${${fw_test}_CFLAGS})
-    SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}")
-ENDFOREACH(flag)
-
-SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS} -Wall")
-
-aux_source_directory(. sources)
-FOREACH(src ${sources})
-    GET_FILENAME_COMPONENT(src_name ${src} NAME_WE)
-    MESSAGE("${src_name}")
-    ADD_EXECUTABLE(${src_name} ${src})
-    TARGET_LINK_LIBRARIES(${src_name} ${fw_name} ${${fw_test}_LDFLAGS})
-ENDFOREACH()
diff --git a/test/bt_chat_client.c b/test/bt_chat_client.c
deleted file mode 100644
index 62e1212..0000000
--- a/test/bt_chat_client.c
+++ /dev/null
@@ -1,453 +0,0 @@
-/*
- * Copyright (c) 2011 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 <bluetooth.h>
-#include <dlog.h>
-#include <glib.h>
-#include <string.h>
-
-#ifdef LOG_TAG
-#undef LOG_TAG
-#endif
-#define LOG_TAG "BT_CHAT_CLIENT"
-
-/**
- *   Variables
- **/
-static GMainLoop* g_mainloop = NULL;
-static bt_adapter_state_e bt_state = BT_ADAPTER_DISABLED;	
-static int socket_fd = -1;
-static char* bt_address = NULL;
-static char* server_name = "chat_server";
-static char quit_command[5] = "Quit";
-static int bonding_state = BT_ERROR_OPERATION_FAILED;
-
-
-/**
- *   Callback functions
- **/
-gboolean timeout_func(gpointer data)
-{
-	LOGE("[%s] Callback: Timeout.", __FUNCTION__);
-	g_main_loop_quit((GMainLoop*)data);
-	return FALSE;
-}
-
-void bt_state_changed_impl(int result, bt_adapter_state_e adapter_state, void* user_data)
-{
-	if(adapter_state == BT_ADAPTER_ENABLED)
-	{
-		if(result == BT_ERROR_NONE)
-		{
-			LOGI("[%s] Callback: BT was enabled successfully.", __FUNCTION__);
-			bt_state = BT_ADAPTER_ENABLED;
-		}
-		else
-		{
-			LOGE("[%s] Callback: Failed to enable BT.", __FUNCTION__);
-		}
-	}
-	
-	if(g_mainloop)
-	{
-		g_main_loop_quit(g_mainloop);                                
-	}                	
-}
-
-void bt_socket_connection_state_changed_impl(int result, bt_socket_connection_state_e connection_state, 
-	bt_socket_connection_s *connection, void *user_data)
-{
-	if(result == BT_ERROR_NONE)
-	{
-		LOGI("[%s] Callback: Result is BT_ERROR_NONE.", __FUNCTION__);
-	}
-	else
-	{
-		LOGI("[%s] Callback: Result is not BT_ERROR_NONE.", __FUNCTION__);
-	}
-	
-	if(connection_state == BT_SOCKET_CONNECTED)
-	{
-		LOGI("[%s] Callback: Connected.", __FUNCTION__);
-		if(result == BT_ERROR_NONE && connection != NULL)
-		{	
-			socket_fd = connection->socket_fd;
-			LOGI("[%s] Callback: Socket of connection - %d.", __FUNCTION__, socket_fd);
-			LOGI("[%s] Callback: Role of connection - %d.", __FUNCTION__, connection->local_role);			
-			LOGI("[%s] Callback: Address of connection - %s.", __FUNCTION__, connection->remote_address);			
-			
-			if(bt_socket_send_data(socket_fd, quit_command, strlen(quit_command)) == BT_ERROR_NONE)
-			{
-				LOGI("[%s] Callback: Send quit command.", __FUNCTION__);
-			}
-			else
-			{
-				LOGE("[%s] Callback: bt_socket_send_data() failed.", __FUNCTION__);
-				if(g_mainloop)
-				{
-					g_main_loop_quit(g_mainloop);                                
-				}           					
-			}
-		}
-		else
-		{
-			LOGI("[%s] Callback: Failed to connect", __FUNCTION__);
-			if(g_mainloop)
-			{
-				g_main_loop_quit(g_mainloop);                                
-			}           					
-		}
-	}
-	else
-	{
-		LOGI("[%s] Callback: Disconnected.", __FUNCTION__);
-	}
-}
-
-void bt_socket_data_received_impl(bt_socket_received_data_s *data, void *user_data)
-{
-	if(socket_fd == data->socket_fd)
-	{
-		if(data->data_size > 0)
-		{
-			if(!strncmp(data->data, quit_command, data->data_size))
-			{
-				LOGI("[%s] Callback: Quit command.", __FUNCTION__);	
-				if(g_mainloop)
-				{
-					g_main_loop_quit(g_mainloop);                                
-				} 
-			}
-		}
-		else
-		{
-			LOGE("[%s] Callback: No data.", __FUNCTION__);
-		}
-	}
-	else
-	{
-		LOGI("[%s] Callback: Another socket - %d.", __FUNCTION__, data->socket_fd);
-	}
-}
-
-bool bt_adapter_bonded_device_impl(bt_device_info_s *device_info, void *user_data)
-{
-	int i = 0;
-	if(device_info != NULL)
-	{
-		if(device_info->remote_name != NULL && !strcmp(device_info->remote_name, (char*)user_data))
-		{
-			LOGI("[%s] Callback: chat_server is found in bonded list.", __FUNCTION__);
-			if( device_info->remote_address != NULL )
-			{
-				LOGI("[%s] Callback: Address of chat_server - %s.", __FUNCTION__, device_info->remote_address);			
-				bt_address = strdup(device_info->remote_address);
-				LOGI("[%s] Callback: The number of service_count - %d.", __FUNCTION__, device_info->service_count);	
-				if(device_info->service_count <= 0)
-				{
-					bonding_state = BT_ERROR_SERVICE_SEARCH_FAILED;
-				}
-				else
-				{
-					bonding_state = BT_ERROR_NONE;
-					for(i=0; i<device_info->service_count; i++)
-					{
-						LOGI("[%s] Callback: service[%d] - %s", __FUNCTION__, i+1, device_info->service_uuid[i]);
-					}
-					LOGI("[%s] Callback: is_bonded - %d.", __FUNCTION__, device_info->is_bonded);		
-					LOGI("[%s] Callback: is_connected - %d.", __FUNCTION__, device_info->is_connected);							
-					LOGI("[%s] Callback: is_authorized - %d.", __FUNCTION__, device_info->is_authorized);
-				}
-			}
-			else
-			{
-				LOGE("[%s] Callback: Address of chat_server is NULL.", __FUNCTION__);			
-			}
-
-			return false;
-		}
-	}
-
-	return true;
-}
-
-void bt_adapter_device_discovery_state_changed_impl(int result, bt_adapter_device_discovery_state_e discovery_state, 
-	bt_adapter_device_discovery_info_s *discovery_info, void *user_data)
-{
-	if(discovery_state == BT_ADAPTER_DEVICE_DISCOVERY_FOUND)
-	{
-		if(discovery_info->remote_address != NULL && !strcmp(discovery_info->remote_name, server_name))
-		{
-			LOGI("[%s] Callback: chat_server is found.", __FUNCTION__);
-			LOGI("[%s] Callback: Address of chat_server - %s.", __FUNCTION__, discovery_info->remote_address);
-			LOGI("[%s] Callback: Device major class - %d.", __FUNCTION__, discovery_info->bt_class.major_device_class);						
-			LOGI("[%s] Callback: Device minor class - %d.", __FUNCTION__, discovery_info->bt_class.minor_device_class);			
-			LOGI("[%s] Callback: Service major class - %d.", __FUNCTION__, discovery_info->bt_class.major_service_class_mask);			
-			bt_address = strdup(discovery_info->remote_address);			
-			LOGI("[%s] Callback: is_bonded - %d.", __FUNCTION__, discovery_info->is_bonded);				
-			bt_adapter_stop_device_discovery();
-		}
-		else
-		{
-			LOGE("[%s] Callback: Another device is found.", __FUNCTION__);			
-		}		
-	}
-	else if(discovery_state == BT_ADAPTER_DEVICE_DISCOVERY_FINISHED)
-	{
-		LOGI("[%s] Callback: device discovery finished.", __FUNCTION__);
-		if(g_mainloop)
-		{
-			g_main_loop_quit(g_mainloop);                                
-		}           			
-	}
-}
-
-void bt_device_bond_created_impl(int result, bt_device_info_s *device_info, void *user_data)
-{
-	if(device_info != NULL && !strcmp(device_info->remote_address, bt_address))
-	{
-		bonding_state = result;
-		if(result == BT_ERROR_NONE)
-		{
-			LOGI("[%s] Callback: A bond with chat_server is created.", __FUNCTION__);
-			LOGI("[%s] Callback: The number of service - %d.", __FUNCTION__, device_info->service_count);			
-
-			int i = 0;
-			for(i=0; i<device_info->service_count; i++)
-			{
-				LOGI("[%s] Callback: service[%d] - %s", __FUNCTION__, i+1, device_info->service_uuid[i]);
-			}	
-			LOGI("[%s] Callback: is_bonded - %d.", __FUNCTION__, device_info->is_bonded);				
-			LOGI("[%s] Callback: is_connected - %d.", __FUNCTION__, device_info->is_connected);											
-		}
-		else
-		{
-			LOGE("[%s] Callback: Creating a bond is failed.", __FUNCTION__);			
-		}
-	}
-	else
-	{
-		LOGE("[%s] Callback: A bond with another device is created.", __FUNCTION__);			
-	}
-
-	if(g_mainloop)
-	{
-		g_main_loop_quit(g_mainloop);                                
-	}	
-}
-
-void bt_device_service_searched_impl(int result, bt_device_sdp_info_s* sdp_info, void* user_data)
-{
-	if(sdp_info != NULL && !strcmp(sdp_info->remote_address, bt_address))
-	{
-		bonding_state = result;
-		if(result == BT_ERROR_NONE)
-		{
-			LOGI("[%s] Callback: Services of chat_service are found.", __FUNCTION__);
-			LOGI("[%s] Callback: The number of service - %d.", __FUNCTION__, sdp_info->service_count);			
-
-			int i = 0;
-			for(i = 0; i < sdp_info->service_count; i++)
-			{
-				LOGI("[%s] Callback: service[%d] - %s", __FUNCTION__, i+1, sdp_info->service_uuid[i]);
-			}	
-		}
-	}
-	else
-	{
-		LOGE("[%s] Callback: Services of another device are found.", __FUNCTION__);			
-	}	
-	
-	if(g_mainloop)
-	{
-		g_main_loop_quit(g_mainloop);                                
-	}	
-}
-
-
-
-
-int main()
-{	
-	g_mainloop = g_main_loop_new(NULL, FALSE);
-	const char* my_uuid="11011101-0000-1000-8000-00805F9B34FB";
-	int timeout_id = -1;
-
-	LOGI("[%s] Client starts.", __FUNCTION__);
-	
-	if(bt_initialize() != BT_ERROR_NONE)
-	{
-		LOGE("[%s] bt_initialize() failed.", __FUNCTION__);
-		return -1;
-	}
-
-	if(bt_adapter_get_state(&bt_state) != BT_ERROR_NONE)
-	{
-		LOGE("[%s] bt_adapter_get_state() failed.", __FUNCTION__);
-		return -1;
-	}
-
-	//	Enable BT
-	if(bt_state == BT_ADAPTER_DISABLED)
-	{
-		if(bt_adapter_set_state_changed_cb(bt_state_changed_impl, NULL) != BT_ERROR_NONE)
-		{
-			LOGE("[%s] bt_adapter_set_state_changed_cb() failed.", __FUNCTION__);
-			return -1;
-		}
-
-		if(bt_adapter_enable() == BT_ERROR_NONE)
-		{
-			LOGI("[%s] bt_adapter_state_changed_cb will be called.", __FUNCTION__);
-			timeout_id = g_timeout_add (60000, timeout_func, g_mainloop);
-			g_main_loop_run(g_mainloop);
-			g_source_remove(timeout_id);
-		}
-		else
-		{
-			LOGE("[%s] bt_adapter_enable() failed.", __FUNCTION__);
-			return -1;
-		}
-	}
-	else
-	{
-		LOGI("[%s] BT was already enabled.", __FUNCTION__);
-	}
-
-	//	Device discovery
-	if(bt_state == BT_ADAPTER_ENABLED)
-	{
-		if(bt_adapter_foreach_bonded_device(bt_adapter_bonded_device_impl, server_name) != BT_ERROR_NONE)
-		{
-			LOGE("[%s] bt_adapter_foreach_bonded_device() failed.", __FUNCTION__);
-			return -1;
-		}
-
-		if(bt_address == NULL)
-		{
-			if(bt_adapter_set_device_discovery_state_changed_cb(bt_adapter_device_discovery_state_changed_impl, NULL) 
-				!= BT_ERROR_NONE )
-			{
-				LOGE("[%s] bt_adapter_set_device_discovery_state_changed_cb() failed.", __FUNCTION__);
-				return -1;
-			}
-
-			if(bt_adapter_start_device_discovery() == BT_ERROR_NONE)
-			{
-				LOGI("[%s] bt_adapter_device_discovery_state_changed_cb will be called.", __FUNCTION__);
-				g_main_loop_run(g_mainloop);			
-			}
-			else
-			{
-				LOGE("[%s] bt_adapter_start_device_discovery() failed.", __FUNCTION__);
-				return -1;
-			}
-		}
-		else
-		{
-			LOGI("[%s] chat_server is found in bonded device list.", __FUNCTION__);
-		}
-	}
-	else
-	{
-		LOGE("[%s] BT is not enabled.", __FUNCTION__);
-		return -1;
-	}
-
-	// Create bond with a server
-	if(bonding_state == BT_ERROR_SERVICE_SEARCH_FAILED)
-	{
-		if(bt_device_set_service_searched_cb(bt_device_service_searched_impl, NULL) != BT_ERROR_NONE)
-		{
-			LOGE("[%s] bt_device_set_service_searched_cb() failed.", __FUNCTION__);
-			return -1;
-		}
-
-		if(bt_device_start_service_search(bt_address) == BT_ERROR_NONE)
-		{
-			LOGI("[%s] bt_device_service_searched_cb will be called.", __FUNCTION__);
-			g_main_loop_run(g_mainloop);			
-		}
-		else
-		{
-			LOGE("[%s] bt_device_start_service_search() failed.", __FUNCTION__);
-			return -1;
-		}		
-	}
-	else if(bonding_state != BT_ERROR_NONE)
-	{
-		if(bt_device_set_bond_created_cb(bt_device_bond_created_impl, NULL) != BT_ERROR_NONE)
-		{
-			LOGE("[%s] bt_device_set_bond_created_cb() failed.", __FUNCTION__);
-			return -1;
-		}
-
-		if(bt_device_create_bond(bt_address) == BT_ERROR_NONE)
-		{
-			LOGI("[%s] bt_device_bond_created_cb will be called.", __FUNCTION__);
-			g_main_loop_run(g_mainloop);			
-		}
-		else
-		{
-			LOGE("[%s] bt_device_create_bond() failed.", __FUNCTION__);
-			return -1;
-		}
-	}
-
-	//	Connecting socket as a client
-	if( bonding_state == BT_ERROR_NONE )
-	{
-		if( bt_socket_set_connection_state_changed_cb(bt_socket_connection_state_changed_impl, NULL) != BT_ERROR_NONE )
-		{
-			LOGE("[%s] bt_socket_set_connection_state_changed_cb() failed.", __FUNCTION__);
-			return -1;
-		}
-
-		if( bt_socket_set_data_received_cb(bt_socket_data_received_impl, NULL) != BT_ERROR_NONE )
-		{
-			LOGE("[%s] bt_socket_set_data_received_cb() failed.", __FUNCTION__);
-			return -1;
-		}		
-
-		if( bt_socket_connect_rfcomm(bt_address, my_uuid) == BT_ERROR_NONE )
-		{
-			LOGI("[%s] bt_socket_connection_state_changed_cb will be called.", __FUNCTION__);
-			g_main_loop_run(g_mainloop);			
-		}
-		else
-		{
-			LOGE("[%s] bt_socket_connect_rfcomm() failed.", __FUNCTION__);				
-			return -1;
-		}
-
-		if( bt_socket_disconnect_rfcomm(socket_fd) != BT_ERROR_NONE )
-		{
-			LOGE("[%s] bt_socket_disconnect_rfcomm() failed.", __FUNCTION__);
-			return -1;
-		}
-	}
-	else
-	{
-		LOGE("[%s] Bond is not created.", __FUNCTION__);
-		return -1;
-	}
-
-	bt_deinitialize();
-	
-	LOGI("[%s] Client ends.", __FUNCTION__);
-	return 0;
-}
diff --git a/test/bt_chat_server.c b/test/bt_chat_server.c
deleted file mode 100644
index 44edd83..0000000
--- a/test/bt_chat_server.c
+++ /dev/null
@@ -1,280 +0,0 @@
-/*
- * Copyright (c) 2011 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 <bluetooth.h>
-#include <dlog.h>
-#include <glib.h>
-#include <string.h>
-
-#ifdef LOG_TAG
-#undef LOG_TAG
-#endif
-#define LOG_TAG "BT_CHAT_SERVER"
-
-/**
- *   Variables
- **/
-static GMainLoop* g_mainloop = NULL;
-static bt_adapter_visibility_mode_e visibility_mode = BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE;
-static bt_adapter_state_e bt_state = BT_ADAPTER_DISABLED;	
-static int service_socket = -1;
-static int connected_socket = -1;
-static char* quit_command = "Quit";
-
-
-/**
- *   Callback functions
- **/
-gboolean timeout_func(gpointer data)
-{
-	LOGE("[%s] Timeout.", __FUNCTION__);
-	if(g_mainloop)
-	{
-		g_main_loop_quit((GMainLoop*)data);
-	}
-	
-	return FALSE;
-}
-
-void bt_state_changed_impl(int result, bt_adapter_state_e adapter_state, void* user_data)
-{
-	if( adapter_state == BT_ADAPTER_ENABLED )
-	{
-		if( result == BT_ERROR_NONE )
-		{
-			LOGI("[%s] Callback: BT was enabled successfully.", __FUNCTION__);
-			bt_state = BT_ADAPTER_ENABLED;
-		}
-		else
-		{
-			LOGE("[%s] Callback: Failed to enable BT.", __FUNCTION__);
-		}
-	}
-
-	if(g_mainloop)
-	{
-		g_main_loop_quit(g_mainloop);                                
-	}	
-}
-
-void bt_socket_connection_state_changed_impl(int result, bt_socket_connection_state_e connection_state, 
-	bt_socket_connection_s *connection, void *user_data)
-{
-	if( result == BT_ERROR_NONE )
-	{
-		LOGI("[%s] Callback: Result is BT_ERROR_NONE.", __FUNCTION__);
-	}
-	else
-	{
-		LOGI("[%s] Callback: Result is not BT_ERROR_NONE.", __FUNCTION__);
-	}
-	
-	if( connection_state == BT_SOCKET_CONNECTED )
-	{
-		LOGI("[%s] Callback: Connected.", __FUNCTION__);		
-		if( connection != NULL )
-		{	
-			connected_socket = connection->socket_fd;
-			LOGI("[%s] Callback: Socket of connection - %d.", __FUNCTION__, connected_socket);
-			LOGI("[%s] Callback: Role of connection - %d.", __FUNCTION__, connection->local_role);			
-			LOGI("[%s] Callback: Address of connection - %s.", __FUNCTION__, connection->remote_address);			
-			
-		}
-		else
-		{
-			LOGI("[%s] Callback: No connection data", __FUNCTION__);
-		}
-	}
-	else
-	{
-		LOGI("[%s] Callback: Disconnected.", __FUNCTION__);
-		LOGI("[%s] Callback: Socket of connection - %d.", __FUNCTION__, connected_socket);
-		LOGI("[%s] Callback: Role of connection - %d.", __FUNCTION__, connection->local_role);			
-		LOGI("[%s] Callback: Address of connection - %s.", __FUNCTION__, connection->remote_address);			
-	}
-}
-
-void bt_socket_data_received_impl(bt_socket_received_data_s *data, void *user_data)
-{
-	if( data->data_size > 0 )
-	{
-		if( !strncmp(data->data, quit_command, data->data_size) )
-		{
-			LOGI("[%s] Callback: Quit command.", __FUNCTION__);	
-			if(g_mainloop)
-			{
-				g_main_loop_quit(g_mainloop);                                
-			}           	
-		}
-
-		if( bt_socket_send_data(connected_socket, quit_command, strlen(quit_command)) == BT_ERROR_NONE )
-		{
-			LOGI("[%s] Callback: Send quit command.", __FUNCTION__);						
-		}
-		else
-		{
-			LOGE("[%s] Callback: bt_socket_send_data() failed.", __FUNCTION__);
-		}		
-	}
-	else
-	{
-		LOGE("[%s] Callback: No data.", __FUNCTION__);
-	}
-}
-
-
-int main()
-{	
-	g_mainloop = g_main_loop_new(NULL, FALSE);
-	const char* my_uuid="11011101-0000-1000-8000-00805F9B34FB";
-	int timeout_id = -1;
-
-	LOGI("[%s] Server starts.", __FUNCTION__);
-	
-	if(bt_initialize() != BT_ERROR_NONE)
-	{
-		LOGE("[%s] bt_initialize() failed.", __FUNCTION__);
-		return -1;
-	}
-
-	if(bt_adapter_get_state(&bt_state) != BT_ERROR_NONE)
-	{
-		LOGE("[%s] bt_adapter_get_state() failed.", __FUNCTION__);
-		return -1;
-	}
-
-	//	Enable BT
-	if(bt_state == BT_ADAPTER_DISABLED)
-	{
-		if(bt_adapter_set_state_changed_cb(bt_state_changed_impl, NULL) != BT_ERROR_NONE)
-		{
-			LOGE("[%s] bt_adapter_set_state_changed_cb() failed.", __FUNCTION__);
-			return -1;
-		}
-
-		if(bt_adapter_enable() == BT_ERROR_NONE)
-		{
-			LOGI("[%s] bt_adapter_state_changed_cb will be called.", __FUNCTION__);
-			timeout_id = g_timeout_add (60000, timeout_func, g_mainloop);
-			g_main_loop_run(g_mainloop);
-			g_source_remove(timeout_id);
-		}
-		else
-		{
-			LOGE("[%s] bt_adapter_enable() failed.", __FUNCTION__);
-			return -1;
-		}
-	}
-	else
-	{
-		LOGI("[%s] BT was already enabled.", __FUNCTION__);
-	}
-
-	//  Set name as "chat_server"
-	if(bt_state == BT_ADAPTER_ENABLED)
-	{
-		char* name = NULL; 
-		if(bt_adapter_get_name(&name) != BT_ERROR_NONE)
-		{
-			LOGE("[%s] bt_adapter_get_name() failed.", __FUNCTION__);
-			return -1;
-		}
-
-		if(strncmp(name, "chat_server", strlen(name)) != 0)
-		{
-			free(name);
-			if(bt_adapter_set_name("chat_server") != BT_ERROR_NONE)
-			{
-				LOGE("[%s] bt_adapter_set_name() failed.", __FUNCTION__);
-				return -1;
-			}			
-		}
-	}
-	else
-	{
-		LOGE("[%s] BT is not enabled.", __FUNCTION__);
-		return -1;
-	}	
-		
-	//  Set visibility as BT_ADAPTER_VISIBILITY_MODE_GENERAL_DISCOVERABLE 
-	if(bt_adapter_get_visibility(&visibility_mode) != BT_ERROR_NONE)
-	{
-		LOGE("[%s] bt_adapter_get_visibility() failed.", __FUNCTION__);
-		return -1;
-	}
-	
-	if(visibility_mode != BT_ADAPTER_VISIBILITY_MODE_GENERAL_DISCOVERABLE)
-	{		
-		if(bt_adapter_set_visibility(BT_ADAPTER_VISIBILITY_MODE_GENERAL_DISCOVERABLE, 0) != BT_ERROR_NONE)
-		{
-			LOGE("[%s] bt_adapter_set_visibility() failed.", __FUNCTION__);
-			return -1;
-		}
-		visibility_mode = BT_ADAPTER_VISIBILITY_MODE_GENERAL_DISCOVERABLE;
-	}
-	else
-	{			
-		LOGI("[%s] Visibility mode was already set as BT_ADAPTER_VISIBILITY_MODE_GENERAL_DISCOVERABLE.", __FUNCTION__);
-	}		
-
-	//	Connecting socket as a server
-	if(bt_socket_create_rfcomm(my_uuid, &service_socket) != BT_ERROR_NONE)
-	{
-		LOGE("[%s] bt_socket_create_rfcomm() failed.", __FUNCTION__);
-		return -1;
-	}
-	LOGI("[%s] socket is created - %d.", __FUNCTION__, service_socket);
-
-	if(bt_socket_set_connection_state_changed_cb(bt_socket_connection_state_changed_impl, NULL) != BT_ERROR_NONE)
-	{
-		LOGE("[%s] bt_socket_set_connection_state_changed_cb() failed.", __FUNCTION__);
-		return -1;
-	}
-
-	if(bt_socket_set_data_received_cb(bt_socket_data_received_impl, NULL) != BT_ERROR_NONE)
-	{
-		LOGE("[%s] bt_socket_set_data_received_cb() failed.", __FUNCTION__);
-		return -1;
-	}
-
-	if(bt_socket_listen_and_accept_rfcomm(service_socket, 5) == BT_ERROR_NONE)
-	{
-		LOGI("[%s] bt_socket_connection_state_changed_cb will be called.", __FUNCTION__);
-		g_main_loop_run(g_mainloop);			
-	}
-	else
-	{
-		LOGE("[%s] bt_socket_listen_and_accept_rfcomm() failed.", __FUNCTION__);				
-		return -1;
-	}
-
-	sleep(5);	// Wait for completing delivery
-	if(bt_socket_destroy_rfcomm(service_socket) != BT_ERROR_NONE)
-	{
-		LOGE("[%s] bt_socket_destroy_rfcomm() failed.", __FUNCTION__);
-		return -1;
-	}	
-	else
-	{
-		LOGE("[%s] bt_socket_destroy_rfcomm() succeeded.", __FUNCTION__);
-	}
-
-	bt_deinitialize();
-	
-	LOGI("[%s] Server ends.", __FUNCTION__);
-	return 0;
-}