tizen 2.3 releasetizen_2.3_releasesubmit/tizen_2.3/20150202.060738tizen_2.3

143 files changed, 10706 insertions, 22086 deletions

diff --git a/mobile/AUTHORS b/AUTHORS
index 46d1687..46d1687 100644
--- a/mobile/AUTHORS
+++ b/AUTHORS
diff --git a/wearable/CMakeLists.txt b/CMakeLists.txt
index 47e3695..3179cc8 100644
--- a/wearable/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -9,7 +9,11 @@ SET(PREFIX ${CMAKE_INSTALL_PREFIX})
 SET(INC_DIR include)
 INCLUDE_DIRECTORIES(${INC_DIR})
 
+IF (TIZEN_WEARABLE)
+SET(dependents "dlog glib-2.0 capi-base-common bluetooth-api privacy-manager-client")
+ELSE ()
 SET(dependents "dlog glib-2.0 capi-base-common bluetooth-api")
+ENDIF (TIZEN_WEARABLE)
 SET(pc_dependents "capi-base-common")
 
 INCLUDE(FindPkgConfig)
diff --git a/wearable/LICENSE.APLv2 b/LICENSE
index 6b0b127..9c13a9b 100644
--- a/wearable/LICENSE.APLv2
+++ b/LICENSE
@@ -1,203 +1,204 @@
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   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.
-
+Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.

+

+                                 Apache License

+                           Version 2.0, January 2004

+                        http://www.apache.org/licenses/

+

+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

+

+   1. Definitions.

+

+      "License" shall mean the terms and conditions for use, reproduction,

+      and distribution as defined by Sections 1 through 9 of this document.

+

+      "Licensor" shall mean the copyright owner or entity authorized by

+      the copyright owner that is granting the License.

+

+      "Legal Entity" shall mean the union of the acting entity and all

+      other entities that control, are controlled by, or are under common

+      control with that entity. For the purposes of this definition,

+      "control" means (i) the power, direct or indirect, to cause the

+      direction or management of such entity, whether by contract or

+      otherwise, or (ii) ownership of fifty percent (50%) or more of the

+      outstanding shares, or (iii) beneficial ownership of such entity.

+

+      "You" (or "Your") shall mean an individual or Legal Entity

+      exercising permissions granted by this License.

+

+      "Source" form shall mean the preferred form for making modifications,

+      including but not limited to software source code, documentation

+      source, and configuration files.

+

+      "Object" form shall mean any form resulting from mechanical

+      transformation or translation of a Source form, including but

+      not limited to compiled object code, generated documentation,

+      and conversions to other media types.

+

+      "Work" shall mean the work of authorship, whether in Source or

+      Object form, made available under the License, as indicated by a

+      copyright notice that is included in or attached to the work

+      (an example is provided in the Appendix below).

+

+      "Derivative Works" shall mean any work, whether in Source or Object

+      form, that is based on (or derived from) the Work and for which the

+      editorial revisions, annotations, elaborations, or other modifications

+      represent, as a whole, an original work of authorship. For the purposes

+      of this License, Derivative Works shall not include works that remain

+      separable from, or merely link (or bind by name) to the interfaces of,

+      the Work and Derivative Works thereof.

+

+      "Contribution" shall mean any work of authorship, including

+      the original version of the Work and any modifications or additions

+      to that Work or Derivative Works thereof, that is intentionally

+      submitted to Licensor for inclusion in the Work by the copyright owner

+      or by an individual or Legal Entity authorized to submit on behalf of

+      the copyright owner. For the purposes of this definition, "submitted"

+      means any form of electronic, verbal, or written communication sent

+      to the Licensor or its representatives, including but not limited to

+      communication on electronic mailing lists, source code control systems,

+      and issue tracking systems that are managed by, or on behalf of, the

+      Licensor for the purpose of discussing and improving the Work, but

+      excluding communication that is conspicuously marked or otherwise

+      designated in writing by the copyright owner as "Not a Contribution."

+

+      "Contributor" shall mean Licensor and any individual or Legal Entity

+      on behalf of whom a Contribution has been received by Licensor and

+      subsequently incorporated within the Work.

+

+   2. Grant of Copyright License. Subject to the terms and conditions of

+      this License, each Contributor hereby grants to You a perpetual,

+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable

+      copyright license to reproduce, prepare Derivative Works of,

+      publicly display, publicly perform, sublicense, and distribute the

+      Work and such Derivative Works in Source or Object form.

+

+   3. Grant of Patent License. Subject to the terms and conditions of

+      this License, each Contributor hereby grants to You a perpetual,

+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable

+      (except as stated in this section) patent license to make, have made,

+      use, offer to sell, sell, import, and otherwise transfer the Work,

+      where such license applies only to those patent claims licensable

+      by such Contributor that are necessarily infringed by their

+      Contribution(s) alone or by combination of their Contribution(s)

+      with the Work to which such Contribution(s) was submitted. If You

+      institute patent litigation against any entity (including a

+      cross-claim or counterclaim in a lawsuit) alleging that the Work

+      or a Contribution incorporated within the Work constitutes direct

+      or contributory patent infringement, then any patent licenses

+      granted to You under this License for that Work shall terminate

+      as of the date such litigation is filed.

+

+   4. Redistribution. You may reproduce and distribute copies of the

+      Work or Derivative Works thereof in any medium, with or without

+      modifications, and in Source or Object form, provided that You

+      meet the following conditions:

+

+      (a) You must give any other recipients of the Work or

+          Derivative Works a copy of this License; and

+

+      (b) You must cause any modified files to carry prominent notices

+          stating that You changed the files; and

+

+      (c) You must retain, in the Source form of any Derivative Works

+          that You distribute, all copyright, patent, trademark, and

+          attribution notices from the Source form of the Work,

+          excluding those notices that do not pertain to any part of

+          the Derivative Works; and

+

+      (d) If the Work includes a "NOTICE" text file as part of its

+          distribution, then any Derivative Works that You distribute must

+          include a readable copy of the attribution notices contained

+          within such NOTICE file, excluding those notices that do not

+          pertain to any part of the Derivative Works, in at least one

+          of the following places: within a NOTICE text file distributed

+          as part of the Derivative Works; within the Source form or

+          documentation, if provided along with the Derivative Works; or,

+          within a display generated by the Derivative Works, if and

+          wherever such third-party notices normally appear. The contents

+          of the NOTICE file are for informational purposes only and

+          do not modify the License. You may add Your own attribution

+          notices within Derivative Works that You distribute, alongside

+          or as an addendum to the NOTICE text from the Work, provided

+          that such additional attribution notices cannot be construed

+          as modifying the License.

+

+      You may add Your own copyright statement to Your modifications and

+      may provide additional or different license terms and conditions

+      for use, reproduction, or distribution of Your modifications, or

+      for any such Derivative Works as a whole, provided Your use,

+      reproduction, and distribution of the Work otherwise complies with

+      the conditions stated in this License.

+

+   5. Submission of Contributions. Unless You explicitly state otherwise,

+      any Contribution intentionally submitted for inclusion in the Work

+      by You to the Licensor shall be under the terms and conditions of

+      this License, without any additional terms or conditions.

+      Notwithstanding the above, nothing herein shall supersede or modify

+      the terms of any separate license agreement you may have executed

+      with Licensor regarding such Contributions.

+

+   6. Trademarks. This License does not grant permission to use the trade

+      names, trademarks, service marks, or product names of the Licensor,

+      except as required for reasonable and customary use in describing the

+      origin of the Work and reproducing the content of the NOTICE file.

+

+   7. Disclaimer of Warranty. Unless required by applicable law or

+      agreed to in writing, Licensor provides the Work (and each

+      Contributor provides its Contributions) on an "AS IS" BASIS,

+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or

+      implied, including, without limitation, any warranties or conditions

+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A

+      PARTICULAR PURPOSE. You are solely responsible for determining the

+      appropriateness of using or redistributing the Work and assume any

+      risks associated with Your exercise of permissions under this License.

+

+   8. Limitation of Liability. In no event and under no legal theory,

+      whether in tort (including negligence), contract, or otherwise,

+      unless required by applicable law (such as deliberate and grossly

+      negligent acts) or agreed to in writing, shall any Contributor be

+      liable to You for damages, including any direct, indirect, special,

+      incidental, or consequential damages of any character arising as a

+      result of this License or out of the use or inability to use the

+      Work (including but not limited to damages for loss of goodwill,

+      work stoppage, computer failure or malfunction, or any and all

+      other commercial damages or losses), even if such Contributor

+      has been advised of the possibility of such damages.

+

+   9. Accepting Warranty or Additional Liability. While redistributing

+      the Work or Derivative Works thereof, You may choose to offer,

+      and charge a fee for, acceptance of support, warranty, indemnity,

+      or other liability obligations and/or rights consistent with this

+      License. However, in accepting such obligations, You may act only

+      on Your own behalf and on Your sole responsibility, not on behalf

+      of any other Contributor, and only if You agree to indemnify,

+      defend, and hold each Contributor harmless for any liability

+      incurred by, or claims asserted against, such Contributor by reason

+      of your accepting any such warranty or additional liability.

+

+   END OF TERMS AND CONDITIONS

+

+   APPENDIX: How to apply the Apache License to your work.

+

+      To apply the Apache License to your work, attach the following

+      boilerplate notice, with the fields enclosed by brackets "[]"

+      replaced with your own identifying information. (Don't include

+      the brackets!)  The text should be enclosed in the appropriate

+      comment syntax for the file format. We also recommend that a

+      file or class name and description of purpose be included on the

+      same "printed page" as the copyright notice for easier

+      identification within third-party archives.

+

+   Copyright [yyyy] [name of copyright owner]

+

+   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.

+

diff --git a/mobile/TC/READAME.txt b/TC/READAME.txt
index f0edad5..f0edad5 100644
--- a/mobile/TC/READAME.txt
+++ b/TC/READAME.txt
diff --git a/mobile/TC/_export_env.sh b/TC/_export_env.sh
index ac8f4a1..ac8f4a1 100755
--- a/mobile/TC/_export_env.sh
+++ b/TC/_export_env.sh
diff --git a/mobile/TC/_export_target_env.sh b/TC/_export_target_env.sh
index c693f83..c693f83 100755
--- a/mobile/TC/_export_target_env.sh
+++ b/TC/_export_target_env.sh
diff --git a/mobile/TC/build.sh b/TC/build.sh
index 72aad6c..72aad6c 100755
--- a/mobile/TC/build.sh
+++ b/TC/build.sh
diff --git a/mobile/TC/clean.sh b/TC/clean.sh
index 29743e0..29743e0 100755
--- a/mobile/TC/clean.sh
+++ b/TC/clean.sh
diff --git a/TC/config b/TC/config
new file mode 100644
index 0000000..bdfec87
--- /dev/null
+++ b/TC/config
@@ -0,0 +1,4 @@
+PKG_NAME=capi-network-bluetooth
+TET_INSTALL_HOST_PATH=/var/tmp/dts_fw/TC/TETware
+TET_INSTALL_TARGET_PATH=/opt/home/$PKG_NAME/TETware
+
diff --git a/mobile/TC/execute.sh b/TC/execute.sh
index 0fe02e2..0fe02e2 100755
--- a/mobile/TC/execute.sh
+++ b/TC/execute.sh
diff --git a/TC/push.sh b/TC/push.sh
new file mode 100755
index 0000000..5eb9510
--- /dev/null
+++ b/TC/push.sh
@@ -0,0 +1,13 @@
+#!/bin/sh
+
+. ./config
+
+TC_PATH=/opt/home/$PKG_NAME
+
+echo $TC_PATH
+
+sdb shell "mkdir -p $TC_PATH"
+
+sdb push . $TC_PATH
+
+
diff --git a/wearable/TC/execute.sh b/TC/run.sh
index 0fe02e2..cec5778 100755
--- a/wearable/TC/execute.sh
+++ b/TC/run.sh
@@ -1,6 +1,6 @@
 #!/bin/sh
 
-. ./_export_target_env.sh                    # setting environment variables
+source ./_export_target_env.sh
 
 export TET_SUITE_ROOT=`pwd`
 FILE_NAME_EXTENSION=`date +%s`
diff --git a/mobile/TC/testcase/Makefile b/TC/testcase/Makefile
index 7d86802..7d86802 100644
--- a/mobile/TC/testcase/Makefile
+++ b/TC/testcase/Makefile
diff --git a/mobile/TC/testcase/tslist b/TC/testcase/tslist
index 39a8464..c3d5dd0 100644
--- a/mobile/TC/testcase/tslist
+++ b/TC/testcase/tslist
@@ -1,9 +1,11 @@
 /testcase/utc_network_bluetooth_adapter_positive
 /testcase/utc_network_bluetooth_adapter_negative
-/testcase/utc_network_bluetooth_device_discovery_positive
-/testcase/utc_network_bluetooth_device_discovery_negative
+/testcase/utc_network_bluetooth_audio_negative
+/testcase/utc_network_bluetooth_audio_positive
 /testcase/utc_network_bluetooth_device_positive
 /testcase/utc_network_bluetooth_device_negative
+/testcase/utc_network_bluetooth_device_discovery_positive
+/testcase/utc_network_bluetooth_device_discovery_negative
 /testcase/utc_network_bluetooth_service_search_positive
 /testcase/utc_network_bluetooth_service_search_negative
 /testcase/utc_network_bluetooth_socket_positive
@@ -20,9 +22,7 @@
 /testcase/utc_network_bluetooth_opp-client_positive
 /testcase/utc_network_bluetooth_pan_negative
 /testcase/utc_network_bluetooth_pan_positive
-/testcase/utc_network_bluetooth_audio_negative
-/testcase/utc_network_bluetooth_audio_positive
 /testcase/utc_network_bluetooth_avrcp_negative
 /testcase/utc_network_bluetooth_avrcp_positive
 /testcase/utc_network_bluetooth_common_negative
-/testcase/utc_network_bluetooth_common_positive
+/testcase/utc_network_bluetooth_common_positive
\ No newline at end of file
diff --git a/TC/testcase/utc_network_bluetooth_adapter_negative.c b/TC/testcase/utc_network_bluetooth_adapter_negative.c
new file mode 100755
index 0000000..a7e2750
--- /dev/null
+++ b/TC/testcase/utc_network_bluetooth_adapter_negative.c
@@ -0,0 +1,429 @@
+/*
+ * 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 <tet_api.h>
+#include <bluetooth.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <glib.h>
+#include <time.h>
+
+enum {
+	POSITIVE_TC_IDX = 0x01,
+	NEGATIVE_TC_IDX,
+};
+
+static void startup(void);
+static void cleanup(void);
+bt_adapter_visibility_mode_e adapter_visibility_mode =
+		BT_ADAPTER_VISIBILITY_MODE_LIMITED_DISCOVERABLE;
+char adapter_name[128] = "dts_test";
+
+void (*tet_startup)(void) = startup;
+void (*tet_cleanup)(void) = cleanup;
+
+
+static void utc_network_bluetooth_deinitialize_n(void);
+static void utc_network_bluetooth_adapter_set_state_changed_cb_n(void);
+static void utc_network_bluetooth_adapter_set_name_changed_cb_n(void);
+static void utc_network_bluetooth_adapter_set_visibility_mode_changed_cb_n(void);
+static void utc_network_bluetooth_adapter_set_connectable_changed_cb_n(void);
+static void utc_network_bluetooth_adapter_enable_n(void);
+static void utc_network_bluetooth_adapter_get_state_n(void);
+static void utc_network_bluetooth_adapter_get_address_n(void);
+static void utc_network_bluetooth_adapter_set_name_n(void);
+static void utc_network_bluetooth_adapter_get_name_n(void);
+static void utc_network_bluetooth_adapter_set_visibility_n(void);
+static void utc_network_bluetooth_adapter_get_visibility_n(void);
+static void utc_network_bluetooth_adapter_add_white_list_n(void);
+static void utc_network_bluetooth_adapter_clear_white_list_n(void);
+static void utc_network_bluetooth_adapter_remove_white_list_n(void);
+static void utc_network_bluetooth_adapter_set_connectable_n(void);
+static void utc_network_bluetooth_adapter_get_connectable_n(void);
+static void utc_network_bluetooth_adapter_disable_n(void);
+static void utc_network_bluetooth_adapter_unset_state_changed_cb_n(void);
+static void utc_network_bluetooth_adapter_unset_name_changed_cb_n(void);
+static void utc_network_bluetooth_adapter_unset_visibility_mode_changed_cb_n(void);
+static void utc_network_bluetooth_adapter_unset_connectable_changed_cb_n(void);
+static void utc_network_bluetooth_adapter_set_le_state_changed_cb_n(void);
+static void utc_network_bluetooth_adapter_unset_le_state_changed_cb_n(void);
+static void utc_network_bluetooth_adapter_le_enable_n(void);
+static void utc_network_bluetooth_adapter_get_le_state_n(void);
+static void utc_network_bluetooth_adapter_le_disable_n(void);
+
+void adapter_state_changed_cb_for_adapter_n(int result,
+					    bt_adapter_state_e adapter_state,
+					    void *user_data);
+gboolean timeout_func(gpointer data);
+
+struct tet_testlist tet_testlist[] = {
+	{utc_network_bluetooth_adapter_disable_n, NEGATIVE_TC_IDX},
+	{utc_network_bluetooth_adapter_set_state_changed_cb_n, NEGATIVE_TC_IDX},
+	{utc_network_bluetooth_adapter_set_name_changed_cb_n, NEGATIVE_TC_IDX},
+	{utc_network_bluetooth_adapter_set_visibility_mode_changed_cb_n, NEGATIVE_TC_IDX},
+	{utc_network_bluetooth_adapter_set_connectable_changed_cb_n, NEGATIVE_TC_IDX},
+	{utc_network_bluetooth_adapter_get_state_n, NEGATIVE_TC_IDX},
+	{utc_network_bluetooth_adapter_get_address_n, NEGATIVE_TC_IDX},
+	{utc_network_bluetooth_adapter_set_name_n, NEGATIVE_TC_IDX},
+	{utc_network_bluetooth_adapter_get_name_n, NEGATIVE_TC_IDX},
+	{utc_network_bluetooth_adapter_get_visibility_n, NEGATIVE_TC_IDX},
+	{utc_network_bluetooth_adapter_set_visibility_n, NEGATIVE_TC_IDX},
+	{utc_network_bluetooth_adapter_le_disable_n, NEGATIVE_TC_IDX},
+	{utc_network_bluetooth_adapter_add_white_list_n, NEGATIVE_TC_IDX},
+	{utc_network_bluetooth_adapter_remove_white_list_n, NEGATIVE_TC_IDX},
+	{utc_network_bluetooth_adapter_clear_white_list_n, NEGATIVE_TC_IDX},
+	{utc_network_bluetooth_adapter_get_connectable_n, NEGATIVE_TC_IDX},
+	{utc_network_bluetooth_deinitialize_n, NEGATIVE_TC_IDX},
+	{utc_network_bluetooth_adapter_set_connectable_n, NEGATIVE_TC_IDX},
+	{utc_network_bluetooth_adapter_enable_n, NEGATIVE_TC_IDX},
+	{utc_network_bluetooth_adapter_unset_connectable_changed_cb_n, NEGATIVE_TC_IDX},
+	{utc_network_bluetooth_adapter_unset_state_changed_cb_n, NEGATIVE_TC_IDX},
+	{utc_network_bluetooth_adapter_unset_name_changed_cb_n, NEGATIVE_TC_IDX},
+	{utc_network_bluetooth_adapter_unset_visibility_mode_changed_cb_n, NEGATIVE_TC_IDX},
+	{utc_network_bluetooth_adapter_set_le_state_changed_cb_n, NEGATIVE_TC_IDX},
+	{utc_network_bluetooth_adapter_get_le_state_n, NEGATIVE_TC_IDX},
+	{utc_network_bluetooth_adapter_le_enable_n, NEGATIVE_TC_IDX},
+	{utc_network_bluetooth_adapter_unset_le_state_changed_cb_n, NEGATIVE_TC_IDX},
+	{NULL, 0},
+};
+
+static void startup(void)
+{
+	/* start of TC */
+	tet_printf("TC start.");
+	bt_initialize();
+}
+
+static void cleanup(void)
+{
+	/* end of TC */
+	tet_printf("TC end");
+}
+
+/**
+ * @brief Negative test case of bt_deinitialize()
+ */
+static void utc_network_bluetooth_deinitialize_n(void)
+{
+	int ret = bt_deinitialize();
+
+	if (ret == BT_ERROR_NONE) {
+		ret = bt_deinitialize();
+		dts_check_eq("bt_deinitialize", ret, BT_ERROR_NOT_INITIALIZED,
+				"BT_ERROR_NOT_INITIALIZED must be returned.");
+	} else {
+		dts_fail("bt_deinitialize", "bt_deinitialize() failed.");
+	}
+}
+
+/**
+ * @brief Negative test case of bt_adapter_disable()
+ */
+static void utc_network_bluetooth_adapter_disable_n(void)
+{
+	int ret = BT_ERROR_NONE;
+
+	ret = bt_adapter_disable();
+	dts_check_eq("bt_adapter_disable", ret, BT_ERROR_NOT_ENABLED,
+				"BT_ERROR_NOT_ENABLED must be returned when BT is disabled");
+}
+
+/**
+ * @brief Negative test case of bt_adapter_set_state_changed_cb()
+ */
+static void utc_network_bluetooth_adapter_set_state_changed_cb_n(void)
+{
+	int ret = BT_ERROR_NONE;
+
+	ret = bt_adapter_set_state_changed_cb(NULL, NULL);
+	dts_check_eq("bt_adapter_set_state_changed_cb", ret,
+				BT_ERROR_INVALID_PARAMETER,
+				"BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL.");
+}
+
+/**
+ * @brief Negative test case of bt_adapter_set_name_changed_cb()
+ */
+static void utc_network_bluetooth_adapter_set_name_changed_cb_n(void)
+{
+	int ret = BT_ERROR_NONE;
+
+	ret = bt_adapter_set_name_changed_cb(NULL, NULL);
+	dts_check_eq("bt_adapter_set_name_changed_cb", ret,
+				BT_ERROR_INVALID_PARAMETER,
+				"BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL.");
+}
+
+/**
+ * @brief Negative test case of bt_adapter_set_visibility_mode_changed_cb()
+ */
+static void utc_network_bluetooth_adapter_set_visibility_mode_changed_cb_n(void)
+{
+	int ret = BT_ERROR_NONE;
+
+	ret = bt_adapter_set_visibility_mode_changed_cb(NULL, NULL);
+	dts_check_eq("bt_adapter_set_visibility_mode_changed_cb", ret,
+				BT_ERROR_INVALID_PARAMETER,
+				"BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL.");
+}
+
+/**
+ * @brief Negative test case of bt_adapter_set_connectable_changed_cb()
+ */
+static void utc_network_bluetooth_adapter_set_connectable_changed_cb_n(void)
+{
+	int ret = BT_ERROR_NONE;
+
+	ret = bt_adapter_set_connectable_changed_cb(NULL, NULL);
+	dts_check_eq("bt_adapter_set_connectable_changed_cb", ret,
+			BT_ERROR_INVALID_PARAMETER,
+			"BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL.");
+}
+
+/**
+ * @brief Negative test case of bt_adapter_get_state()
+ */
+static void utc_network_bluetooth_adapter_get_state_n(void)
+{
+	int ret = BT_ERROR_NONE;
+
+	ret = bt_adapter_get_state(NULL);
+	dts_check_eq("bt_adapter_get_state", ret, BT_ERROR_INVALID_PARAMETER,
+			"BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL.");
+}
+
+/**
+ * @brief Negative test case of bt_adapter_get_address().
+ */
+static void utc_network_bluetooth_adapter_get_address_n(void)
+{
+	char *address = NULL;
+	int ret = bt_adapter_get_address(&address);
+
+	dts_check_eq("bt_adapter_get_address", ret, BT_ERROR_NOT_ENABLED,
+			"BT_ERROR_NOT_ENABLED must be returned when BT is not enabled.");
+}
+
+/**
+ * @brief Negative test case of bt_adapter_get_name().
+ */
+static void utc_network_bluetooth_adapter_get_name_n(void)
+{
+	char *name = NULL;
+	int ret = bt_adapter_get_name(&name);
+
+	dts_check_eq("bt_adapter_get_name", ret, BT_ERROR_NOT_ENABLED,
+			"BT_ERROR_NOT_ENABLED must be returned when BT is not enabled.");
+}
+
+/**
+ * @brief Negative test case of bt_adapter_get_visibility().
+ */
+static void utc_network_bluetooth_adapter_get_visibility_n(void)
+{
+	int dur = 10;
+	int ret = bt_adapter_get_visibility(NULL, &dur);
+
+	dts_check_eq("bt_adapter_get_visibility", ret, BT_ERROR_INVALID_PARAMETER,
+			"BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL.");
+}
+
+/**
+ * @brief Negative test case of bt_adapter_set_name().
+ */
+static void utc_network_bluetooth_adapter_set_name_n(void)
+{
+	int ret = bt_adapter_set_name(NULL);
+	dts_check_eq("bt_adapter_set_name", ret, BT_ERROR_INVALID_PARAMETER,
+			"BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL.");
+}
+
+/**
+ * @brief Negative test case of bt_adapter_set_visibility().
+ */
+static void utc_network_bluetooth_adapter_set_visibility_n(void)
+{
+	int ret = bt_adapter_set_visibility(adapter_visibility_mode, 180);
+
+	dts_check_eq("bt_adapter_set_visibility", ret, BT_ERROR_NOT_ENABLED,
+			"BT_ERROR_NOT_ENABLED must be returned when BT is not enabled.");
+}
+
+/**
+ * @brief Negative test case of bt_adapter_le_add_white_list
+ */
+static void utc_network_bluetooth_adapter_add_white_list_n(void)
+{
+	int ret = bt_adapter_le_add_white_list(NULL);
+	dts_check_eq("bt_adapter_le_add_white_list", ret, BT_ERROR_INVALID_PARAMETER,
+		"BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL.");
+}
+
+/**
+ * @brief Negative test case of bt_adapter_clear_white_list
+ */
+static void utc_network_bluetooth_adapter_clear_white_list_n(void)
+{
+	int ret = BT_ERROR_NONE;
+	ret = bt_adapter_clear_white_list();
+	dts_check_eq("bt_adapter_clear_white_list", ret, BT_ERROR_NOT_ENABLED,
+		"BT_ERROR_NOT_ENABLED must be returned when BT is not enabled.");
+}
+
+/**
+ * @brief Negative test case of bt_adapter_le_add_white_list
+ */
+static void utc_network_bluetooth_adapter_remove_white_list_n(void)
+{
+	int ret = bt_adapter_le_remove_white_list(NULL);
+	dts_check_eq("bt_adapter_le_remove_white_list", ret, BT_ERROR_INVALID_PARAMETER,
+		"BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL.");
+}
+
+/**
+ * @brief Negative test case of bt_adapter_get_connectable
+ */
+static void utc_network_bluetooth_adapter_get_connectable_n(void)
+{
+	int ret = bt_adapter_get_connectable(NULL);
+	dts_check_eq("bt_adapter_get_connectable", ret, BT_ERROR_INVALID_PARAMETER,
+		"BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL.");
+}
+
+/**
+ * @brief Negative test case of bt_adapter_set_connectable
+ */
+static void utc_network_bluetooth_adapter_set_connectable_n(void)
+{
+	int ret = bt_adapter_set_connectable(NULL);
+	dts_check_eq("bt_adapter_set_connectable", ret, BT_ERROR_NOT_INITIALIZED,
+		"BT_ERROR_NOT_INITIALIZED must be returned when BT is not initialized.");
+}
+
+/**
+ * @brief Negative test case of bt_adapter_unset_state_changed_cb()
+ */
+static void utc_network_bluetooth_adapter_unset_state_changed_cb_n(void)
+{
+	int ret = BT_ERROR_NONE;
+
+	ret = bt_adapter_unset_state_changed_cb();
+	dts_check_eq("bt_adapter_unset_state_changed_cb", ret,
+			BT_ERROR_NOT_INITIALIZED,
+			"BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized.");
+}
+
+/**
+ * @brief Negative test case of bt_adapter_unset_name_changed_cb()
+ */
+static void utc_network_bluetooth_adapter_unset_name_changed_cb_n(void)
+{
+	int ret = BT_ERROR_NONE;
+
+	ret = bt_adapter_unset_name_changed_cb();
+	dts_check_eq("bt_adapter_unset_name_changed_cb", ret,
+			BT_ERROR_NOT_INITIALIZED,
+			"BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized.");
+}
+
+/**
+ * @brief Negative test case of bt_adapter_unset_visibility_mode_changed_cb()
+ */
+static void
+utc_network_bluetooth_adapter_unset_visibility_mode_changed_cb_n(void)
+{
+	int ret = BT_ERROR_NONE;
+
+	ret = bt_adapter_unset_visibility_mode_changed_cb();
+	dts_check_eq("bt_adapter_unset_visibility_mode_changed_cb", ret,
+			BT_ERROR_NOT_INITIALIZED,
+			"BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized.");
+}
+
+/**
+ * @brief Negative test case of bt_adapter_enable()
+ */
+static void utc_network_bluetooth_adapter_enable_n(void)
+{
+	bt_error_e ret = bt_adapter_enable();
+	dts_check_eq("bt_adapter_enable", ret, BT_ERROR_NOT_INITIALIZED,
+			"BT_ERROR_NOT_INITIALIZED must be returned.");
+}
+
+/**
+ * @brief Negative test case of bt_adapter_unset_connectable_changed_cb()
+ */
+static void utc_network_bluetooth_adapter_unset_connectable_changed_cb_n(void)
+{
+	int ret = BT_ERROR_NONE;
+
+	ret = bt_adapter_unset_connectable_changed_cb();
+	dts_check_eq("bt_adapter_unset_connectable_changed_cb", ret,
+			BT_ERROR_NOT_INITIALIZED,
+			"bt_adapter_unset_connectable_changed_cb() failed.");
+}
+
+/**
+ * @brief Negative test case of bt_adapter_le_set_state_changed_cb()
+ */
+static void utc_network_bluetooth_adapter_set_le_state_changed_cb_n(void)
+{
+	int ret = BT_ERROR_NONE;
+
+	ret = bt_adapter_le_set_state_changed_cb(NULL, NULL);
+	dts_check_eq("bt_adapter_le_set_state_changed_cb", ret,
+			BT_ERROR_INVALID_PARAMETER,
+			"BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL.");
+}
+
+static void utc_network_bluetooth_adapter_le_enable_n(void)
+{
+	int ret = BT_ERROR_NONE;
+
+	ret = bt_adapter_le_enable();
+	dts_check_eq("bt_adapter_le_enable", ret,
+			BT_ERROR_NOT_INITIALIZED,
+			"BT_ERROR_NOT_INITIALIZED must be returned.");
+}
+
+static void utc_network_bluetooth_adapter_le_disable_n(void)
+{
+	int ret = BT_ERROR_NONE;
+
+	ret = bt_adapter_le_disable();
+	dts_check_eq("bt_adapter_disable", ret, BT_ERROR_NOT_ENABLED,
+			"BT_ERROR_NOT_ENABLED must be returned when BT is disabled");
+}
+
+static void utc_network_bluetooth_adapter_get_le_state_n(void)
+{
+	int ret = BT_ERROR_NONE;
+
+	ret = bt_adapter_le_get_state(NULL);
+	dts_check_eq("bt_adapter_get_state", ret, BT_ERROR_INVALID_PARAMETER,
+			"BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL.");
+}
+
+static void utc_network_bluetooth_adapter_unset_le_state_changed_cb_n(void)
+{
+	int ret = BT_ERROR_NONE;
+
+	ret = bt_adapter_le_unset_state_changed_cb();
+	dts_check_eq("bt_adapter_unset_state_changed_cb", ret,
+			BT_ERROR_NOT_INITIALIZED,
+			"BT_ERROR_NOT_INITIALIZED must be returned");
+}
diff --git a/mobile/TC/testcase/utc_network_bluetooth_adapter_positive.c b/TC/testcase/utc_network_bluetooth_adapter_positive.c
index 28168a3..6ad6815 100644..100755
--- a/mobile/TC/testcase/utc_network_bluetooth_adapter_positive.c
+++ b/TC/testcase/utc_network_bluetooth_adapter_positive.c
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+
 #include <tet_api.h>
 #include <bluetooth.h>
 #include <stdlib.h>
@@ -21,6 +22,8 @@
 #include <glib.h>
 #include <time.h>
 
+#define CONFIG_FILE_PATH "/opt/home/capi-network-bluetooth/tetware.conf"
+
 enum {
 	POSITIVE_TC_IDX = 0x01,
 	NEGATIVE_TC_IDX,
@@ -28,19 +31,22 @@ enum {
 
 static void startup(void);
 static void cleanup(void);
+char *remote_address;
 static GMainLoop *mainloop;
 static bool callback_result = false;
-bt_adapter_visibility_mode_e adapter_visibility_mode = BT_ADAPTER_VISIBILITY_MODE_LIMITED_DISCOVERABLE;
+bt_adapter_visibility_mode_e adapter_visibility_mode =
+		BT_ADAPTER_VISIBILITY_MODE_LIMITED_DISCOVERABLE;
 char adapter_name[128] = "dts_test";
 
-void (*tet_startup) (void) = startup;
-void (*tet_cleanup) (void) = cleanup;
+void (*tet_startup)(void) = startup;
+void (*tet_cleanup)(void) = cleanup;
 
 static void utc_network_bluetooth_initialize_p(void);
 static void utc_network_bluetooth_deinitialize_p(void);
 static void utc_network_bluetooth_adapter_set_state_changed_cb_p(void);
 static void utc_network_bluetooth_adapter_set_name_changed_cb_p(void);
 static void utc_network_bluetooth_adapter_set_visibility_mode_changed_cb_p(void);
+static void utc_network_bluetooth_adapter_set_connectable_changed_cb_p(void);
 static void utc_network_bluetooth_adapter_enable_p(void);
 static void utc_network_bluetooth_adapter_get_state_p(void);
 static void utc_network_bluetooth_adapter_get_address_p(void);
@@ -48,10 +54,21 @@ static void utc_network_bluetooth_adapter_set_name_p(void);
 static void utc_network_bluetooth_adapter_get_name_p(void);
 static void utc_network_bluetooth_adapter_set_visibility_p(void);
 static void utc_network_bluetooth_adapter_get_visibility_p(void);
+static void utc_network_bluetooth_adapter_add_white_list_p(void);
+static void utc_network_bluetooth_adapter_remove_white_list_p(void);
+static void utc_network_bluetooth_adapter_clear_white_list_p(void);
+static void utc_network_bluetooth_adapter_set_connectable_p(void);
+static void utc_network_bluetooth_adapter_get_connectable_p(void);
 static void utc_network_bluetooth_adapter_disable_p(void);
 static void utc_network_bluetooth_adapter_unset_state_changed_cb_p(void);
 static void utc_network_bluetooth_adapter_unset_name_changed_cb_p(void);
 static void utc_network_bluetooth_adapter_unset_visibility_mode_changed_cb_p(void);
+static void utc_network_bluetooth_adapter_unset_connectable_changed_cb_p(void);
+static void utc_network_bluetooth_adapter_set_le_state_changed_cb_p(void);
+static void utc_network_bluetooth_adapter_le_enable_p(void);
+static void utc_network_bluetooth_adapter_get_le_state_p(void);
+static void utc_network_bluetooth_adapter_le_disable_p(void);
+static void utc_network_bluetooth_adapter_unset_le_state_changed_cb_p(void);
 
 void adapter_state_changed_cb_for_adapter_p(int result,
 					    bt_adapter_state_e adapter_state,
@@ -67,6 +84,8 @@ void device_discovery_state_changed_cb_for_adapter_p(int result,
 						     bt_adapter_device_discovery_state_e discovery_state,
 						     bt_device_info_s *device_info,
 						     void *user_data);
+void adapter_connectable_changed_cb_for_adpater_p(int result,
+							bool connectable, void *user_data);
 gboolean timeout_func(gpointer data);
 
 struct tet_testlist tet_testlist[] = {
@@ -79,18 +98,70 @@ struct tet_testlist tet_testlist[] = {
 	{utc_network_bluetooth_adapter_get_name_p, POSITIVE_TC_IDX},
 	{utc_network_bluetooth_adapter_set_name_changed_cb_p, POSITIVE_TC_IDX},
 	{utc_network_bluetooth_adapter_unset_name_changed_cb_p, POSITIVE_TC_IDX},
+	{utc_network_bluetooth_adapter_set_connectable_changed_cb_p, POSITIVE_TC_IDX},
 	{utc_network_bluetooth_adapter_set_name_p, POSITIVE_TC_IDX},
 	{utc_network_bluetooth_adapter_set_visibility_mode_changed_cb_p, POSITIVE_TC_IDX},
 	{utc_network_bluetooth_adapter_unset_visibility_mode_changed_cb_p, POSITIVE_TC_IDX},
 	{utc_network_bluetooth_adapter_get_visibility_p, POSITIVE_TC_IDX},
 	{utc_network_bluetooth_adapter_set_visibility_p, POSITIVE_TC_IDX},
+	{utc_network_bluetooth_adapter_get_connectable_p, POSITIVE_TC_IDX},
+	{utc_network_bluetooth_adapter_set_connectable_p, POSITIVE_TC_IDX},
+	{utc_network_bluetooth_adapter_unset_connectable_changed_cb_p, POSITIVE_TC_IDX},
+	{utc_network_bluetooth_adapter_le_enable_p, POSITIVE_TC_IDX},
+	{utc_network_bluetooth_adapter_add_white_list_p, POSITIVE_TC_IDX},
+	{utc_network_bluetooth_adapter_remove_white_list_p, POSITIVE_TC_IDX},
+	{utc_network_bluetooth_adapter_clear_white_list_p, POSITIVE_TC_IDX},
+	{utc_network_bluetooth_adapter_set_le_state_changed_cb_p, POSITIVE_TC_IDX},
+	{utc_network_bluetooth_adapter_unset_le_state_changed_cb_p, POSITIVE_TC_IDX},
+	{utc_network_bluetooth_adapter_get_le_state_p, POSITIVE_TC_IDX},
+	{utc_network_bluetooth_adapter_le_disable_p, POSITIVE_TC_IDX},
 	{utc_network_bluetooth_adapter_disable_p, POSITIVE_TC_IDX},
 	{utc_network_bluetooth_deinitialize_p, POSITIVE_TC_IDX},
 	{NULL, 0},
 };
 
+int get_value_from_file(void)
+{
+	FILE *fp;
+	char *token;
+	char buf[100];
+
+	fp = fopen(CONFIG_FILE_PATH, "r");
+	if (fp == NULL) {
+		tet_printf("Default configuration is used\n");
+		return -1;
+	}
+	while (fgets(buf, sizeof(buf), fp)) {
+		if (buf[0] == '#' || buf[0] == '\n')
+			continue;
+
+		token = strrchr(buf, '\n');
+		if (token == NULL) {
+			tet_printf("g_conf is too long\n");
+			break;
+		}
+		*token = '\0';
+
+		token = strtok(buf, "=");
+		if (token == NULL) {
+			continue;
+		}
+		if (strcasecmp(token, "BT_ADDR_MOBILE") == 0) {
+			token = strtok(NULL, "=");
+			remote_address = strdup(token);
+			fclose(fp);
+			return 0;
+		}
+	}
+	return -1;
+}
+
 static void startup(void)
 {
+	if(get_value_from_file() == -1) {
+		tet_printf("Failed to read.");
+	}
+
 	/* start of TC */
 	tet_printf("TC start.");
 	mainloop = g_main_loop_new(NULL, FALSE);
@@ -105,7 +176,7 @@ static void cleanup(void)
 gboolean timeout_func(gpointer data)
 {
 	tet_printf("Callback: Timeout.");
-	g_main_loop_quit((GMainLoop *) data);
+	g_main_loop_quit((GMainLoop *)data);
 	return FALSE;
 }
 
@@ -113,8 +184,8 @@ gboolean timeout_func(gpointer data)
  * @brief Callback funtions
  */
 void adapter_state_changed_cb_for_adapter_p(int result,
-					    bt_adapter_state_e adapter_state,
-					    void *user_data)
+						bt_adapter_state_e adapter_state,
+						void *user_data)
 {
 	if (user_data != NULL && !strcmp((char *)user_data, "enable")) {
 		if (adapter_state == BT_ADAPTER_ENABLED && result == BT_ERROR_NONE) {
@@ -140,10 +211,38 @@ void adapter_state_changed_cb_for_adapter_p(int result,
 	}
 }
 
+void adapter_le_state_changed_cb_for_adapter_p(int result,
+						bt_adapter_le_state_e adapter_le_state,
+						void *user_data)
+{
+	if (user_data != NULL && !strcmp((char *)user_data, "enable")) {
+		if (adapter_le_state == BT_ADAPTER_LE_ENABLED && result == BT_ERROR_NONE) {
+			tet_printf("Callback: BT LE was enabled.");
+			callback_result = true;
+		} else {
+			tet_printf("Callback: BT LE was not enabled.");
+		}
+
+		if (mainloop)
+			g_main_loop_quit(mainloop);
+	} else if (user_data != NULL && !strcmp((char *)user_data, "disable")) {
+		if (adapter_le_state == BT_ADAPTER_LE_DISABLED && result == BT_ERROR_NONE) {
+			tet_printf("Callback: BT LEwas disabled.");
+			callback_result = true;
+		} else {
+			tet_printf("Callback: BT LE was not disabled.");
+		}
+
+		if (mainloop) {
+			g_main_loop_quit(mainloop);
+		}
+	}
+}
+
 void device_discovery_state_changed_cb_for_adapter_p(int result,
-						     bt_adapter_device_discovery_state_e discovery_state,
-						     bt_device_info_s *device_info,
-						     void *user_data)
+				bt_adapter_device_discovery_state_e discovery_state,
+				bt_device_info_s *device_info,
+				void *user_data)
 {
 	tet_printf("bt_adapter_device_discovery_state_changed_cb was called");
 
@@ -161,7 +260,7 @@ void device_discovery_state_changed_cb_for_adapter_p(int result,
 void adapter_name_changed_cb_for_adapter_p(char *device_name, void *user_data)
 {
 	tet_printf("bt_adapter_name_changed_cb_for_adapter_p was called: %s",
-		   (char *)device_name);
+			(char *)device_name);
 
 	if (user_data != NULL && !strcmp((char *)user_data, "set_name")) {
 		if (!strcmp(device_name, adapter_name))
@@ -174,8 +273,8 @@ void adapter_name_changed_cb_for_adapter_p(char *device_name, void *user_data)
 }
 
 void adapter_visibility_mode_changed_cb_for_adpater_p(int result,
-						      bt_adapter_visibility_mode_e visibility_mode,
-						      void *user_data)
+					bt_adapter_visibility_mode_e visibility_mode,
+					void *user_data)
 {
 	tet_printf("bt_adapter_visibility_mode_changed_cb was called: %d", visibility_mode);
 
@@ -198,6 +297,22 @@ void adapter_visibility_mode_changed_cb_for_adpater_p(int result,
 		g_main_loop_quit(mainloop);
 }
 
+void adapter_connectable_changed_cb_for_adpater_p(int result, bool connectable,
+					void *user_data)
+{
+	tet_printf("adapter_connectable_changed_cb_for_adapter_p was called.");
+	if (result == BT_ERROR_NONE) {
+		tet_printf("Callback: Connectable Changed");
+		tet_printf("%s", connectable ? "Connectable" : "Non-connectable");
+		callback_result = true;
+	} else {
+		tet_printf("Callback: adapter_connectable_changed_cb_for_adpater_p() was called but failed.");
+		callback_result = false;
+	}
+	if (mainloop)
+		g_main_loop_quit(mainloop);
+}
+
 /**
  * @brief Positive test case of bt_initialize()
  */
@@ -205,7 +320,7 @@ static void utc_network_bluetooth_initialize_p(void)
 {
 	int ret = bt_initialize();
 	dts_check_eq("bt_initialize", ret, BT_ERROR_NONE,
-		     "bt_initialize() failed.");
+			"bt_initialize() failed.");
 }
 
 /**
@@ -215,7 +330,7 @@ static void utc_network_bluetooth_deinitialize_p(void)
 {
 	int ret = bt_deinitialize();
 	dts_check_eq("bt_deinitialize", ret,
-		     BT_ERROR_NONE, "bt_deinitialize() failed.");
+			BT_ERROR_NONE, "bt_deinitialize() failed.");
 }
 
 /**
@@ -227,7 +342,7 @@ static void utc_network_bluetooth_adapter_set_state_changed_cb_p(void)
 
 	ret = bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_adapter_p, NULL);
 	dts_check_eq("bt_adapter_set_state_changed_cb", ret, BT_ERROR_NONE,
-		     "bt_adapter_set_state_changed_cb failed.");
+			"bt_adapter_set_state_changed_cb failed.");
 }
 
 /**
@@ -245,7 +360,7 @@ static void utc_network_bluetooth_adapter_set_name_changed_cb_p(void)
 		g_source_remove(timeout_id);
 	}
 	dts_check_eq("bt_adapter_set_name_changed_cb", ret, BT_ERROR_NONE,
-		     "bt_adapter_set_name_changed_cb failed.");
+			"bt_adapter_set_name_changed_cb failed.");
 }
 
 /**
@@ -256,15 +371,27 @@ static void utc_network_bluetooth_adapter_set_visibility_mode_changed_cb_p(void)
 	int ret = BT_ERROR_NONE;
 	int timeout_id = 0;
 
-	ret = bt_adapter_set_visibility_mode_changed_cb(adapter_visibility_mode_changed_cb_for_adpater_p, NULL);
+	ret = bt_adapter_set_visibility_mode_changed_cb(
+			adapter_visibility_mode_changed_cb_for_adpater_p, NULL);
 	if (ret == BT_ERROR_NONE) {
 		timeout_id = g_timeout_add(10000, timeout_func, mainloop);
 		g_main_loop_run(mainloop);
 		g_source_remove(timeout_id);
 	}
 	dts_check_eq("bt_adapter_set_visibility_mode_changed_cb", ret,
-		     BT_ERROR_NONE,
-		     "bt_adapter_set_visibility_mode_changed_cb failed.");
+			BT_ERROR_NONE,
+			"bt_adapter_set_visibility_mode_changed_cb failed.");
+}
+
+static void utc_network_bluetooth_adapter_set_connectable_changed_cb_p(void)
+{
+	int ret = BT_ERROR_NONE;
+
+	ret = bt_adapter_set_connectable_changed_cb(
+			adapter_connectable_changed_cb_for_adpater_p, NULL);
+	dts_check_eq("bt_adapter_set_connectable_changed_cb", ret,
+			BT_ERROR_NONE,
+			"bt_adapter_set_connectable_changed_cb failed.");
 }
 
 /**
@@ -278,7 +405,7 @@ static void utc_network_bluetooth_adapter_enable_p(void)
 
 	if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_adapter_p, "enable") != BT_ERROR_NONE) {
 		dts_fail("bt_adapter_enable",
-			 "bt_adapter_set_state_changed_cb() failed.");
+			"bt_adapter_set_state_changed_cb() failed.");
 	}
 
 	ret = bt_adapter_enable();
@@ -297,7 +424,7 @@ static void utc_network_bluetooth_adapter_enable_p(void)
 	tet_printf("callback_result: %d", callback_result);
 	bt_adapter_unset_state_changed_cb();
 	dts_check_eq("bt_adapter_enable", callback_result, true,
-		     "BT was not enabled.");
+		"BT was not enabled.");
 }
 
 /**
@@ -311,10 +438,10 @@ static void utc_network_bluetooth_adapter_get_state_p(void)
 	ret = bt_adapter_get_state(&adapter_state);
 	if (ret == BT_ERROR_NONE && adapter_state == BT_ADAPTER_ENABLED) {
 		dts_pass("bt_adapter_get_state",
-			 "bt_adapter_get_state() succeeded.");
+			"bt_adapter_get_state() succeeded.");
 	} else {
 		dts_fail("bt_adapter_get_state",
-			 "bt_adapter_get_state() failed.");
+			"bt_adapter_get_state() failed.");
 	}
 }
 
@@ -330,7 +457,7 @@ static void utc_network_bluetooth_adapter_get_address_p(void)
 		tet_printf("device address: %s", address);
 
 	dts_check_eq("bt_adapter_get_address", ret, BT_ERROR_NONE,
-		     "bt_adapter_get_address() failed.");
+			"bt_adapter_get_address() failed.");
 }
 
 /**
@@ -347,8 +474,8 @@ static void utc_network_bluetooth_adapter_get_name_p(void)
 	memset(adapter_name, 0x00, sizeof(adapter_name));
 	g_strlcpy(adapter_name, name, sizeof(adapter_name));
 
-	dts_check_eq("bt_adapter_get_name", ret, BT_ERROR_NONE,
-		     "bt_adapter_get_name() failed.");
+	dts_check_eq("bt_adapter_get_name", ret, BT_ERROR_NONE, \
+			"bt_adapter_get_name() failed.");
 }
 
 /**
@@ -369,7 +496,7 @@ static void utc_network_bluetooth_adapter_get_visibility_p(void)
 		adapter_visibility_mode = BT_ADAPTER_VISIBILITY_MODE_GENERAL_DISCOVERABLE;
 
 	dts_check_eq("bt_adapter_get_visibility", ret, BT_ERROR_NONE,
-		     "bt_adapter_get_visibility() failed.");
+			"bt_adapter_get_visibility() failed.");
 }
 
 /**
@@ -385,7 +512,7 @@ static void utc_network_bluetooth_adapter_set_name_p(void)
 
 	if (bt_adapter_set_name_changed_cb(adapter_name_changed_cb_for_adapter_p, "set_name") != BT_ERROR_NONE) {
 		dts_fail("bt_adapter_set_name",
-			 "bt_adapter_set_name_changed_cb() failed.");
+			"bt_adapter_set_name_changed_cb() failed.");
 	}
 
 	if (bt_adapter_set_name(adapter_name) == BT_ERROR_NONE) {
@@ -395,7 +522,7 @@ static void utc_network_bluetooth_adapter_set_name_p(void)
 		g_source_remove(timeout_id);
 		bt_adapter_unset_name_changed_cb();
 		dts_check_eq("bt_adapter_set_name", callback_result, true,
-			     "The local adapter name was not set.");
+			"The local adapter name was not set.");
 	} else {
 		dts_fail("bt_adapter_set_name", "bt_adapter_set_name() failed");
 	}
@@ -412,7 +539,7 @@ static void utc_network_bluetooth_adapter_set_visibility_p(void)
 
 	if (bt_adapter_set_visibility_mode_changed_cb(adapter_visibility_mode_changed_cb_for_adpater_p, "set_visibility") != BT_ERROR_NONE) {
 		dts_fail("bt_adapter_set_visibility",
-			 "bt_adapter_set_visibility_mode_changed_cb() failed.");
+			"bt_adapter_set_visibility_mode_changed_cb() failed.");
 	}
 
 	tet_printf("set visibility mode: %d", adapter_visibility_mode);
@@ -428,10 +555,77 @@ static void utc_network_bluetooth_adapter_set_visibility_p(void)
 		g_source_remove(timeout_id);
 		bt_adapter_unset_visibility_mode_changed_cb();
 		dts_check_eq("bt_adapter_set_visibility", callback_result, true,
-			     "The visibility of BT was not set.");
+			"The visibility of BT was not set.");
 	} else {
 		dts_fail("bt_adapter_set_visibility",
-			 "bt_adapter_set_visibility() failed");
+			"bt_adapter_set_visibility() failed");
+	}
+}
+
+/**
+ * @brief Positive test case of bt_adapter_le_add_white_list
+ */
+static void utc_network_bluetooth_adapter_add_white_list_p(void)
+{
+	int ret = BT_ERROR_NONE;
+	ret = bt_adapter_le_add_white_list(remote_address);
+	dts_check_eq("bt_adapter_le_add_white_list", ret, BT_ERROR_NONE,
+		"bt_adapter_le_add_white_list() failed.");
+}
+
+/**
+ * @brief Positive test case of bt_adapter_le_clear_white_list
+ */
+static void utc_network_bluetooth_adapter_clear_white_list_p(void)
+{
+	int ret = BT_ERROR_NONE;
+	ret = bt_adapter_le_clear_white_list();
+	dts_check_eq("bt_adapter_le_clear_white_list", ret, BT_ERROR_NONE,
+		"bt_adapter_le_clear_white_list() failed.");
+}
+
+/**
+ * @brief Positive test case of bt_adapter_le_remove_white_list
+ */
+static void utc_network_bluetooth_adapter_remove_white_list_p(void)
+{
+	int ret = BT_ERROR_NONE;
+	ret = bt_adapter_le_remove_white_list(remote_address);
+	dts_check_eq("bt_adapter_le_remove_white_list", ret, BT_ERROR_NONE,
+		"bt_adapter_le_remove_white_list() failed.");
+}
+
+/**
+ * @brief Positive test case of bt_adapter_get_connectable
+ */
+static void utc_network_bluetooth_adapter_get_connectable_p(void)
+{
+	int ret = BT_ERROR_NONE;
+	bool connectable = false;
+	ret = bt_adapter_get_connectable(&connectable);
+	dts_check_eq("bt_adapter_get_connectable", ret, BT_ERROR_NONE,
+		"bt_adapter_get_connectable() failed.");
+}
+
+/**
+ * @brief Positive test case of bt_adapter_set_connectable
+ */
+static void utc_network_bluetooth_adapter_set_connectable_p(void)
+{
+	int ret = BT_ERROR_NONE;
+	bool connectable = false;
+	int timeout_id = 0;
+	callback_result = false;
+
+	ret = bt_adapter_get_connectable(&connectable);
+	ret = bt_adapter_set_connectable(!connectable);
+	if (ret == BT_ERROR_NONE) {
+		tet_printf("adapter_connectable_changed_cb will be called");
+		timeout_id = g_timeout_add(60000, timeout_func, mainloop);
+		g_main_loop_run(mainloop);
+		g_source_remove(timeout_id);
+		dts_check_eq("bt_adapter_set_connectable", ret, BT_ERROR_NONE,
+				"bt_adapter_set_connectable() failed.");
 	}
 }
 
@@ -445,7 +639,7 @@ static void utc_network_bluetooth_adapter_disable_p(void)
 
 	if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_adapter_p, "disable") != BT_ERROR_NONE) {
 		dts_fail("bt_adapter_disable",
-			 "bt_adapter_set_state_changed_cb() failed.");
+			"bt_adapter_set_state_changed_cb() failed.");
 	}
 
 	if (bt_adapter_disable() == BT_ERROR_NONE) {
@@ -455,7 +649,7 @@ static void utc_network_bluetooth_adapter_disable_p(void)
 		g_source_remove(timeout_id);
 		bt_adapter_unset_state_changed_cb();
 		dts_check_eq("bt_adapter_disable", callback_result, true,
-			     "BT was not disabled");
+			"BT was not disabled");
 	} else {
 		dts_fail("bt_adapter_disable", "bt_adapter_disable() failed");
 	}
@@ -470,7 +664,7 @@ static void utc_network_bluetooth_adapter_unset_state_changed_cb_p(void)
 
 	ret = bt_adapter_unset_state_changed_cb();
 	dts_check_eq("bt_adapter_unset_state_changed_cb", ret, BT_ERROR_NONE,
-		     "bt_adapter_unset_state_changed_cb() failed.");
+			"bt_adapter_unset_state_changed_cb() failed.");
 }
 
 /**
@@ -482,7 +676,7 @@ static void utc_network_bluetooth_adapter_unset_name_changed_cb_p(void)
 
 	ret = bt_adapter_unset_name_changed_cb();
 	dts_check_eq("bt_adapter_unset_name_changed_cb", ret, BT_ERROR_NONE,
-		     "bt_adapter_unset_name_changed_cb() failed.");
+			"bt_adapter_unset_name_changed_cb() failed.");
 }
 
 /**
@@ -494,6 +688,109 @@ static void utc_network_bluetooth_adapter_unset_visibility_mode_changed_cb_p(voi
 
 	ret = bt_adapter_unset_visibility_mode_changed_cb();
 	dts_check_eq("bt_adapter_unset_visibility_mode_changed_cb", ret,
-		     BT_ERROR_NONE,
-		     "bt_adapter_unset_visibility_mode_changed_cb() failed.");
+			BT_ERROR_NONE,
+			"bt_adapter_unset_visibility_mode_changed_cb() failed.");
+}
+
+/**
+ * @brief Positive test case of bt_adapter_unset_connectable_changed_cb()
+ */
+static void utc_network_bluetooth_adapter_unset_connectable_changed_cb_p(void)
+{
+	int ret = BT_ERROR_NONE;
+
+	ret = bt_adapter_unset_connectable_changed_cb();
+	dts_check_eq("bt_adapter_unset_connectable_changed_cb", ret,
+			BT_ERROR_NONE,
+			"bt_adapter_unset_connectable_changed_cb() failed.");
+}
+
+/**
+ * @brief Positive test case of bt_adapter_le_set_state_changed_cb()
+ */
+static void utc_network_bluetooth_adapter_set_le_state_changed_cb_p(void)
+{
+	int ret = BT_ERROR_NONE;
+
+	ret = bt_adapter_le_set_state_changed_cb(
+			adapter_le_state_changed_cb_for_adapter_p, NULL);
+	dts_check_eq("bt_adapter_le_set_state_changed_cb", ret, BT_ERROR_NONE,
+			"bt_adapter_set_state_le_state_changed_cb failed.");
+}
+
+static void utc_network_bluetooth_adapter_le_enable_p(void)
+{
+	int timeout_id = 0;
+	callback_result = false;
+	bt_error_e ret = BT_ERROR_NONE;
+
+	if (bt_adapter_le_set_state_changed_cb(adapter_le_state_changed_cb_for_adapter_p, "enable") != BT_ERROR_NONE) {
+		dts_fail("bt_adapter_le_enable",
+			"bt_adapter_le_set_state_changed_cb() failed.");
+	}
+
+	ret = bt_adapter_le_enable();
+	if (ret == BT_ERROR_NONE) {
+		timeout_id = g_timeout_add(60000, timeout_func, mainloop);
+		g_main_loop_run(mainloop);
+		g_source_remove(timeout_id);
+	} else if (ret == BT_ERROR_ALREADY_DONE) {
+		callback_result = true;
+	} else {
+		dts_fail("bt_adapter_le_enable", "bt_adapter_le_enable() failed.");
+		bt_adapter_le_unset_state_changed_cb();
+		return;
+	}
+
+	tet_printf("callback_result: %d", callback_result);
+	bt_adapter_le_unset_state_changed_cb();
+	dts_check_eq("bt_adapter_le_enable", callback_result, true,
+		"BT LE was not enabled.");
+}
+
+static void utc_network_bluetooth_adapter_le_disable_p(void)
+{
+	callback_result = false;
+	int timeout_id = 0;
+
+	if (bt_adapter_le_set_state_changed_cb(adapter_le_state_changed_cb_for_adapter_p, "disable") != BT_ERROR_NONE) {
+		dts_fail("bt_adapter_le_disable",
+			"bt_adapter_le_set_state_changed_cb() failed.");
+	}
+
+	if (bt_adapter_le_disable() == BT_ERROR_NONE) {
+		tet_printf("bt_adapter_le_state_changed_cb() will be called");
+		timeout_id = g_timeout_add(60000, timeout_func, mainloop);
+		g_main_loop_run(mainloop);
+		g_source_remove(timeout_id);
+		bt_adapter_le_unset_state_changed_cb();
+		dts_check_eq("bt_adapter_le_disable", callback_result, true,
+			"BT LE was not disabled");
+	} else {
+		dts_fail("bt_adapter_le_disable", "bt_adapter_le_disable() failed");
+	}
+}
+
+static void utc_network_bluetooth_adapter_get_le_state_p(void)
+{
+	bt_adapter_le_state_e adapter_le_state = BT_ADAPTER_LE_DISABLED;
+	int ret = BT_ERROR_NONE;
+
+	ret = bt_adapter_le_get_state(&adapter_le_state);
+	if (ret == BT_ERROR_NONE && adapter_le_state == BT_ADAPTER_LE_ENABLED) {
+		dts_pass("bt_adapter_le_get_state",
+			"bt_adapter_le_get_state() succeeded.");
+	} else {
+		dts_fail("bt_adapter_le_get_state",
+			"bt_adapter_le_get_state() failed.");
+	}
+}
+
+static void utc_network_bluetooth_adapter_unset_le_state_changed_cb_p(void)
+{
+	int ret = BT_ERROR_NONE;
+
+	ret = bt_adapter_le_unset_state_changed_cb();
+	dts_check_eq("bt_adapter_le_unset_state_changed_cb", ret, BT_ERROR_NONE,
+			"bt_adapter_unset_state_le_changed_cb() failed.");
 }
diff --git a/mobile/TC/testcase/utc_network_bluetooth_audio_negative.c b/TC/testcase/utc_network_bluetooth_audio_negative.c
index 63c29d9..438b166 100644..100755
--- a/mobile/TC/testcase/utc_network_bluetooth_audio_negative.c
+++ b/TC/testcase/utc_network_bluetooth_audio_negative.c
@@ -35,15 +35,18 @@ static void utc_network_bluetooth_ag_notify_call_event_n(void);
 static void utc_network_bluetooth_ag_notify_call_list_n(void);
 static void utc_network_bluetooth_ag_set_call_handling_event_cb_n(void);
 static void utc_network_bluetooth_ag_set_multi_call_handling_event_cb_n(void);
+static void utc_network_bluetooth_ag_set_vendor_cmd_cb_n(void);
+static void utc_network_bluetooth_ag_unset_vendor_cmd_cb_n(void);
 static void utc_network_bluetooth_ag_unset_multi_call_handling_event_cb_n(void);
 static void utc_network_bluetooth_ag_unset_dtmf_transmitted_cb_n(void);
 static void utc_network_bluetooth_ag_call_list_destroy_n(void);
 static void utc_network_bluetooth_ag_call_list_reset_n(void);
 static void utc_network_bluetooth_ag_call_list_add_n(void);
+static void utc_network_bluetooth_ag_set_dtmf_transmitted_cb_n(void);
 
 void adapter_state_changed_cb_for_audio_negative(int result,
-						 bt_adapter_state_e adapter_state,
-						 void *user_data);
+						bt_adapter_state_e adapter_state,
+						void *user_data);
 gboolean timeout_func(gpointer data);
 
 struct tet_testlist tet_testlist[] = {
@@ -60,11 +63,14 @@ struct tet_testlist tet_testlist[] = {
 	{utc_network_bluetooth_ag_notify_call_list_n, NEGATIVE_TC_IDX},
 	{utc_network_bluetooth_ag_set_call_handling_event_cb_n, NEGATIVE_TC_IDX},
 	{utc_network_bluetooth_ag_set_multi_call_handling_event_cb_n, NEGATIVE_TC_IDX},
-	{utc_network_bluetooth_ag_unset_multi_call_handling_event_cb_n, NEGATIVE_TC_IDX},
-	{utc_network_bluetooth_ag_unset_dtmf_transmitted_cb_n, NEGATIVE_TC_IDX},
+	{utc_network_bluetooth_ag_set_vendor_cmd_cb_n, NEGATIVE_TC_IDX},
+	{utc_network_bluetooth_ag_set_dtmf_transmitted_cb_n, NEGATIVE_TC_IDX},
 	{utc_network_bluetooth_ag_call_list_destroy_n, NEGATIVE_TC_IDX},
 	{utc_network_bluetooth_ag_call_list_reset_n, NEGATIVE_TC_IDX},
 	{utc_network_bluetooth_ag_call_list_add_n, NEGATIVE_TC_IDX},
+	{utc_network_bluetooth_ag_unset_vendor_cmd_cb_n, NEGATIVE_TC_IDX},
+	{utc_network_bluetooth_ag_unset_multi_call_handling_event_cb_n, NEGATIVE_TC_IDX},
+	{utc_network_bluetooth_ag_unset_dtmf_transmitted_cb_n, NEGATIVE_TC_IDX},
 	{NULL, 0},
 };
 
@@ -123,8 +129,8 @@ gboolean timeout_func(gpointer data)
  * @brief Callback funtions
  */
 void adapter_state_changed_cb_for_audio_negative(int result,
-						 bt_adapter_state_e adapter_state,
-						 void *user_data)
+						bt_adapter_state_e adapter_state,
+						void *user_data)
 {
 	tet_printf("Callback: bt_adapter_state_changed_cb was called.");
 	if (user_data != NULL && !strcmp((char *)user_data, "startup")) {
@@ -149,7 +155,7 @@ static void utc_network_bluetooth_audio_connect_n(void)
 
 	ret = bt_audio_connect(NULL, BT_AUDIO_PROFILE_TYPE_HSP_HFP);
 	dts_check_eq("bt_audio_connect", ret,
-		     BT_ERROR_INVALID_PARAMETER, "bt_audio_connect() failed.");
+			BT_ERROR_INVALID_PARAMETER, "bt_audio_connect() failed.");
 }
 
 /**
@@ -161,8 +167,8 @@ static void utc_network_bluetooth_audio_disconnect_n(void)
 
 	ret = bt_audio_disconnect(NULL, BT_AUDIO_PROFILE_TYPE_A2DP);
 	dts_check_eq("bt_audio_disconnect", ret,
-		     BT_ERROR_INVALID_PARAMETER,
-		     "bt_audio_disconnect() failed.");
+			BT_ERROR_INVALID_PARAMETER,
+			"bt_audio_disconnect() failed.");
 }
 
 /**
@@ -173,8 +179,8 @@ static void utc_network_bluetooth_audio_set_connection_n(void)
 	int ret = BT_ERROR_NONE;
 	ret = bt_audio_set_connection_state_changed_cb(NULL, NULL);
 	dts_check_eq("bt_audio_set_connection_state_changed_cb", ret,
-		     BT_ERROR_INVALID_PARAMETER,
-		     "bt_audio_set_connection_state_changed_cb() failed.");
+			BT_ERROR_INVALID_PARAMETER,
+			"bt_audio_set_connection_state_changed_cb() failed.");
 }
 
 /**
@@ -185,8 +191,8 @@ static void utc_network_bluetooth_ag_get_speaker_gain_n(void)
 	int ret = BT_ERROR_NONE;
 	ret = bt_ag_get_speaker_gain(NULL);
 	dts_check_eq("bt_ag_get_speaker_gain", ret,
-		     BT_ERROR_INVALID_PARAMETER,
-		     "bt_ag_get_speaker_gain() failed.");
+			BT_ERROR_INVALID_PARAMETER,
+			"bt_ag_get_speaker_gain() failed.");
 }
 
 /**
@@ -197,8 +203,8 @@ static void utc_network_bluetooth_ag_is_nrec_enabled_n(void)
 	int ret = BT_ERROR_NONE;
 	ret = bt_ag_is_nrec_enabled(NULL);
 	dts_check_eq("bt_ag_is_nrec_enabled", ret,
-		     BT_ERROR_INVALID_PARAMETER,
-		     "bt_ag_is_nrec_enabled() failed.");
+			BT_ERROR_INVALID_PARAMETER,
+			"bt_ag_is_nrec_enabled() failed.");
 }
 
 /**
@@ -209,8 +215,8 @@ static void utc_network_bluetooth_ag_set_microphone_gain_changed_n(void)
 	int ret = BT_ERROR_NONE;
 	ret = bt_ag_set_microphone_gain_changed_cb(NULL, NULL);
 	dts_check_eq("bt_ag_set_microphone_gain_changed_cb", ret,
-		     BT_ERROR_INVALID_PARAMETER,
-		     "bt_ag_set_microphone_gain_changed_cb() failed.");
+			BT_ERROR_INVALID_PARAMETER,
+			"bt_ag_set_microphone_gain_changed_cb() failed.");
 }
 
 /**
@@ -221,8 +227,8 @@ static void utc_network_bluetooth_ag_set_speaker_gain_changed_n(void)
 	int ret = BT_ERROR_NONE;
 	ret = bt_ag_set_speaker_gain_changed_cb(NULL, NULL);
 	dts_check_eq("bt_ag_set_speaker_gain_changed_cb", ret,
-		     BT_ERROR_INVALID_PARAMETER,
-		     "bt_ag_set_speaker_gain_changed_cb() failed.");
+			BT_ERROR_INVALID_PARAMETER,
+			"bt_ag_set_speaker_gain_changed_cb() failed.");
 }
 
 /**
@@ -233,8 +239,8 @@ static void utc_network_bluetooth_ag_is_sco_opened_n(void)
 	int ret = BT_ERROR_NONE;
 	ret = bt_ag_is_sco_opened(NULL);
 	dts_check_eq("bt_ag_is_sco_opened", ret,
-		     BT_ERROR_INVALID_PARAMETER,
-		     "bt_ag_is_sco_opened() failed.");
+			BT_ERROR_INVALID_PARAMETER,
+			"bt_ag_is_sco_opened() failed.");
 }
 
 /**
@@ -245,8 +251,8 @@ static void utc_network_bluetooth_ag_set_sco_state_changed_n(void)
 	int ret = BT_ERROR_NONE;
 	ret = bt_ag_set_sco_state_changed_cb(NULL, NULL);
 	dts_check_eq("bt_ag_set_sco_state_changed_cb", ret,
-		     BT_ERROR_INVALID_PARAMETER,
-		     "bt_ag_set_sco_state_changed_cb() failed.");
+			BT_ERROR_INVALID_PARAMETER,
+			"bt_ag_set_sco_state_changed_cb() failed.");
 }
 
 /**
@@ -258,8 +264,8 @@ static void utc_network_bluetooth_ag_notify_call_event_n(void)
 	unsigned int call_id = 0;
 	ret = bt_ag_notify_call_event(BT_AG_CALL_EVENT_INCOMING, call_id, NULL);
 	dts_check_eq("bt_ag_notify_call_event", ret,
-		     BT_ERROR_INVALID_PARAMETER,
-		     "bt_ag_notify_call_event() failed.");
+			BT_ERROR_INVALID_PARAMETER,
+			"bt_ag_notify_call_event() failed.");
 }
 
 /**
@@ -270,8 +276,8 @@ static void utc_network_bluetooth_ag_notify_call_list_n(void)
 	int ret = BT_ERROR_NONE;
 	ret = bt_ag_notify_call_list(NULL);
 	dts_check_eq("bt_ag_notify_call_list", ret,
-		     BT_ERROR_INVALID_PARAMETER,
-		     "bt_ag_notify_call_list() failed.");
+			BT_ERROR_INVALID_PARAMETER,
+			"bt_ag_notify_call_list() failed.");
 }
 
 /**
@@ -282,8 +288,8 @@ static void utc_network_bluetooth_ag_set_call_handling_event_cb_n(void)
 	int ret = BT_ERROR_NONE;
 	ret = bt_ag_set_call_handling_event_cb(NULL, NULL);
 	dts_check_eq("bt_ag_set_call_handling_event_cb", ret,
-		     BT_ERROR_INVALID_PARAMETER,
-		     "bt_ag_set_call_handling_event_cb() failed.");
+			BT_ERROR_INVALID_PARAMETER,
+			"bt_ag_set_call_handling_event_cb() failed.");
 }
 
 /**
@@ -294,33 +300,47 @@ static void utc_network_bluetooth_ag_set_multi_call_handling_event_cb_n(void)
 	int ret = BT_ERROR_NONE;
 	ret = bt_ag_set_multi_call_handling_event_cb(NULL, NULL);
 	dts_check_eq("bt_ag_set_multi_call_handling_event_cb", ret,
-		     BT_ERROR_INVALID_PARAMETER,
-		     "bt_ag_set_multi_call_handling_event_cb() failed.");
+			BT_ERROR_INVALID_PARAMETER,
+			"bt_ag_set_multi_call_handling_event_cb() failed.");
 }
 
 /**
  * @brief Negative test case of bt_ag_set_dtmf_transmitted_cb()
  */
-static void utc_network_bluetooth_ag_unset_multi_call_handling_event_cb_n(void)
+static void utc_network_bluetooth_ag_set_dtmf_transmitted_cb_n(void)
 {
 	int ret = BT_ERROR_NONE;
 	ret = bt_ag_set_dtmf_transmitted_cb(NULL, NULL);
 	dts_check_eq("bt_ag_set_dtmf_transmitted_cb", ret,
-		     BT_ERROR_INVALID_PARAMETER,
-		     "bt_ag_set_dtmf_transmitted_cb() failed.");
+			BT_ERROR_INVALID_PARAMETER,
+			"bt_ag_set_dtmf_transmitted_cb() failed.");
+
+}
+
+/**
+ * @brief Negative test case of bt_ag_unset_multi_call_handling_event_cb()
+ */
+static void utc_network_bluetooth_ag_unset_multi_call_handling_event_cb_n(void)
+{
+	int ret = BT_ERROR_NONE;
+	ret = bt_deinitialize();
+	ret = bt_ag_unset_multi_call_handling_event_cb();
+	dts_check_eq("bt_ag_unset_multi_call_handling_event_cb", ret,
+			BT_ERROR_NOT_INITIALIZED,
+			"BT_ERROR_NOT_INITIALIZED must be returned when BT is not initialized.");
 }
 
 /**
- * @brief Negative test case of bt_call_list_create()
+ * @brief Negative test case of bt_ag_unset_dtmf_transmitted_cb()
  */
 static void utc_network_bluetooth_ag_unset_dtmf_transmitted_cb_n(void)
 {
 	int ret = BT_ERROR_NONE;
-	bt_call_list_h handle;
-	handle = g_malloc0(sizeof(bt_call_list_h));
-	ret = bt_call_list_create(handle);
-	dts_check_eq("bt_call_list_create", ret, BT_ERROR_NONE,
-		     "bt_call_list_create() failed.");
+	ret = bt_deinitialize();
+	ret = bt_ag_unset_dtmf_transmitted_cb();
+	dts_check_eq("bt_ag_unset_dtmf_transmitted_cb", ret,
+			BT_ERROR_NOT_INITIALIZED,
+			"BT_ERROR_NOT_INITIALIZED must be returned when BT is not initialized.");
 }
 
 /**
@@ -332,7 +352,7 @@ static void utc_network_bluetooth_ag_call_list_destroy_n(void)
 
 	ret = bt_call_list_destroy(NULL);
 	dts_check_eq("bt_call_list_destroy", ret, BT_ERROR_INVALID_PARAMETER,
-		     "bt_call_list_destroy() failed.");
+			"bt_call_list_destroy() failed.");
 }
 
 /**
@@ -344,7 +364,7 @@ static void utc_network_bluetooth_ag_call_list_reset_n(void)
 
 	ret = bt_call_list_reset(NULL);
 	dts_check_eq("bt_call_list_reset", ret, BT_ERROR_INVALID_PARAMETER,
-		     "bt_call_list_reset() failed.");
+			"bt_call_list_reset() failed.");
 }
 
 /**
@@ -354,9 +374,10 @@ static void utc_network_bluetooth_ag_call_list_add_n(void)
 {
 	int ret = BT_ERROR_NONE;
 	unsigned int call_id = 0;
+	const char *phone_number = "9663868998";
 
-	ret = bt_call_list_add(NULL, call_id, BT_AG_CALL_STATE_INCOMING);
+	ret = bt_call_list_add(NULL, call_id, BT_AG_CALL_STATE_INCOMING, phone_number);
 	dts_check_eq("bt_call_list_add", ret, BT_ERROR_INVALID_PARAMETER,
-		     "bt_call_list_add() failed.");
+			"bt_call_list_add() failed.");
 
 }
diff --git a/mobile/TC/testcase/utc_network_bluetooth_audio_positive.c b/TC/testcase/utc_network_bluetooth_audio_positive.c
index 1f7c6a5..d1fffbc 100644..100755
--- a/mobile/TC/testcase/utc_network_bluetooth_audio_positive.c
+++ b/TC/testcase/utc_network_bluetooth_audio_positive.c
@@ -9,6 +9,8 @@
 #include <bluetooth.h>
 #include <glib.h>
 
+#define CONFIG_FILE_PATH "/opt/home/capi-network-bluetooth/tetware.conf"
+
 enum {
 	POSITIVE_TC_IDX = 0x01,
 	NEGATIVE_TC_IDX,
@@ -20,7 +22,7 @@ static void cleanup(void);
 void (*tet_startup) (void) = startup;
 void (*tet_cleanup) (void) = cleanup;
 
-char target_address[18] = "";
+char *remote_address;
 static GMainLoop *mainloop;
 
 static void utc_network_bluetooth_audio_initialize_p(void);
@@ -50,6 +52,8 @@ static void utc_network_bluetooth_ag_set_multi_call_handling_event_cb_p(void);
 static void utc_network_bluetooth_ag_unset_multi_call_handling_event_cb_p(void);
 static void utc_network_bluetooth_ag_set_dtmf_transmitted_cb_p(void);
 static void utc_network_bluetooth_ag_unset_dtmf_transmitted_cb_p(void);
+static void utc_network_bluetooth_ag_set_vendor_cmd_cb_p(void);
+static void utc_network_bluetooth_ag_unset_vendor_cmd_cb_p(void);
 static void utc_network_bluetooth_ag_call_list_create_p(void);
 static void utc_network_bluetooth_ag_call_list_destroy_p(void);
 static void utc_network_bluetooth_ag_call_list_reset_p(void);
@@ -86,7 +90,10 @@ struct tet_testlist tet_testlist[] = {
 	{utc_network_bluetooth_ag_unset_microphone_gain_changed_p, POSITIVE_TC_IDX},
 	{utc_network_bluetooth_ag_unset_speaker_gain_changed_p, POSITIVE_TC_IDX},
 	{utc_network_bluetooth_ag_set_sco_state_changed_p, POSITIVE_TC_IDX},
+	{utc_network_bluetooth_ag_set_vendor_cmd_cb_p, POSITIVE_TC_IDX},
+	{utc_network_bluetooth_ag_unset_vendor_cmd_cb_p, POSITIVE_TC_IDX},
 	{utc_network_bluetooth_ag_is_sco_opened_p, POSITIVE_TC_IDX},
+	{utc_network_bluetooth_ag_close_sco_p, POSITIVE_TC_IDX},
 	{utc_network_bluetooth_ag_notify_call_event_p, POSITIVE_TC_IDX},
 	{utc_network_bluetooth_ag_notify_call_list_p, POSITIVE_TC_IDX},
 	{utc_network_bluetooth_ag_notify_voice_recognition_state_p, POSITIVE_TC_IDX},
@@ -96,7 +103,6 @@ struct tet_testlist tet_testlist[] = {
 	{utc_network_bluetooth_ag_unset_multi_call_handling_event_cb_p, POSITIVE_TC_IDX},
 	{utc_network_bluetooth_ag_set_dtmf_transmitted_cb_p, POSITIVE_TC_IDX},
 	{utc_network_bluetooth_ag_unset_dtmf_transmitted_cb_p, POSITIVE_TC_IDX},
-	{utc_network_bluetooth_ag_close_sco_p, POSITIVE_TC_IDX},
 	{utc_network_bluetooth_ag_unset_sco_state_changed_p, POSITIVE_TC_IDX},
 	{utc_network_bluetooth_ag_call_list_create_p, POSITIVE_TC_IDX},
 	{utc_network_bluetooth_ag_call_list_destroy_p, POSITIVE_TC_IDX},
@@ -109,11 +115,51 @@ struct tet_testlist tet_testlist[] = {
 	{NULL, 0},
 };
 
+int get_value_from_file(void)
+{
+	FILE *fp;
+	char *token;
+	char buf[100];
+
+	fp = fopen(CONFIG_FILE_PATH, "r");
+	if (fp == NULL) {
+		tet_printf("Default configuration is used\n");
+		return -1;
+	}
+	while (fgets(buf, sizeof(buf), fp)) {
+		if (buf[0] == '#' || buf[0] == '\n')
+			continue;
+
+		token = strrchr(buf, '\n');
+		if (token == NULL) {
+			tet_printf("g_conf is too long\n");
+			break;
+		}
+		*token = '\0';
+
+		token = strtok(buf, "=");
+		if (token == NULL) {
+			continue;
+		}
+		if (strcasecmp(token, "BT_ADDR_HEADSET") == 0) {
+			token = strtok(NULL, "=");
+			remote_address = strdup(token);
+			fclose(fp);
+			return 0;
+		}
+	}
+	return -1;
+}
+
 static void startup(void)
 {
 	bt_error_e ret = BT_ERROR_NONE;
 	int timeout_id = 0;
 
+	if(get_value_from_file() == -1) {
+		tet_printf("Failed to read.");
+	}
+
 	/* start of TC */
 	tet_printf("TC start.");
 	mainloop = g_main_loop_new(NULL, FALSE);
@@ -161,16 +207,16 @@ gboolean timeout_func(gpointer data)
  */
 
 void adapter_state_changed_cb_for_audio_p(int result,
-					  bt_adapter_state_e adapter_state,
-					  void *user_data)
+					bt_adapter_state_e adapter_state,
+					void *user_data)
 {
 
 }
 
 void connection_state_changed_cb_for_audio_p(int result, bool connected,
-					     const char *remote_address,
-					     bt_audio_profile_type_e type,
-					     void *user_data)
+						const char *remote_address,
+						bt_audio_profile_type_e type,
+						void *user_data)
 {
 
 }
@@ -191,7 +237,7 @@ void sco_state_changed_cb_for_ag_p(int result, bool opened, void *user_data)
 }
 
 void call_handling_event_cb_for_ag_p(bt_ag_call_handling_event_e event,
-				     unsigned int call_id, void *user_data)
+				unsigned int call_id, void *user_data)
 {
 
 }
@@ -206,6 +252,12 @@ void dtmf_transmitted_cb_for_ag_p(const char *dtmf, void *user_data)
 
 }
 
+void vendor_cmd_event_cb_for_ag_p(char *cmd, void *user_data)
+{
+	tet_printf("Callback : vendor_cmd_cb was called.");
+	tet_printf("Vendor Command[%s]", cmd);
+}
+
 /**
  * @brief Positive test case of bt_audio_initialize()
  */
@@ -215,7 +267,7 @@ static void utc_network_bluetooth_audio_initialize_p(void)
 
 	ret = bt_audio_initialize();
 	dts_check_eq("bt_audio_initialize", ret, BT_ERROR_NONE,
-		     "bt_audio_initialize() failed. %x", ret);
+			"bt_audio_initialize() failed. %x", ret);
 
 }
 
@@ -228,7 +280,7 @@ static void utc_network_bluetooth_audio_connect_p(void)
 	const char *remote_address = "00:23:78:AB:C4:20";
 	ret = bt_audio_connect(remote_address, BT_AUDIO_PROFILE_TYPE_HSP_HFP);
 	dts_check_eq("bt_audio_connect", ret, BT_ERROR_NONE,
-		     "bt_audio_connect() failed. %x", ret);
+			"bt_audio_connect() failed. %x", ret);
 }
 
 /**
@@ -237,10 +289,9 @@ static void utc_network_bluetooth_audio_connect_p(void)
 static void utc_network_bluetooth_audio_disconnect_p(void)
 {
 	int ret = BT_ERROR_NONE;
-	const char *remote_address = "00:23:78:AB:C4:20";
-	ret = bt_audio_disconnect(remote_address, BT_AUDIO_PROFILE_TYPE_A2DP);
+	ret = bt_audio_disconnect(remote_address, BT_AUDIO_PROFILE_TYPE_HSP_HFP);
 	dts_check_eq("bt_audio_disconnect", ret, BT_ERROR_NONE,
-		     "bt_audio_disconnect() failed. %x", ret);
+			"bt_audio_disconnect() failed. %x", ret);
 }
 
 /**
@@ -249,12 +300,11 @@ static void utc_network_bluetooth_audio_disconnect_p(void)
 static void utc_network_bluetooth_audio_set_connection_p(void)
 {
 	int ret = BT_ERROR_NONE;
-	ret =
-	    bt_audio_set_connection_state_changed_cb
-	    (connection_state_changed_cb_for_audio_p, NULL);
+	ret = bt_audio_set_connection_state_changed_cb
+		(connection_state_changed_cb_for_audio_p, NULL);
 	dts_check_eq("bt_audio_set_connection_state_changed_cb", ret,
-		     BT_ERROR_NONE,
-		     "bt_audio_set_connection_state_changed_cb() failed.");
+			BT_ERROR_NONE,
+			"bt_audio_set_connection_state_changed_cb() failed.");
 }
 
 /**
@@ -265,8 +315,8 @@ static void utc_network_bluetooth_audio_unset_connection_p(void)
 	int ret = BT_ERROR_NONE;
 	ret = bt_audio_unset_connection_state_changed_cb();
 	dts_check_eq("bt_audio_set_connection_state_changed_cb", ret,
-		     BT_ERROR_NONE,
-		     "bt_audio_set_connection_state_changed_cb() failed.");
+			BT_ERROR_NONE,
+			"bt_audio_set_connection_state_changed_cb() failed.");
 }
 
 /**
@@ -278,7 +328,7 @@ static void utc_network_bluetooth_ag_notify_speaker_gain_p(void)
 	int gain = 10;
 	ret = bt_ag_notify_speaker_gain(gain);
 	dts_check_eq("bt_ag_notify_speaker_gain", ret, BT_ERROR_NONE,
-		     "bt_ag_notify_speaker_gain() failed.%x", ret);
+			"bt_ag_notify_speaker_gain() failed.%x", ret);
 }
 
 /**
@@ -290,7 +340,7 @@ static void utc_network_bluetooth_ag_get_speaker_gain_p(void)
 	int gain = 0;
 	ret = bt_ag_get_speaker_gain(&gain);
 	dts_check_eq("bt_ag_get_speaker_gain", ret, BT_ERROR_NONE,
-		     "bt_ag_get_speaker_gain() failed.");
+			"bt_ag_get_speaker_gain() failed.");
 
 }
 
@@ -303,7 +353,7 @@ static void utc_network_bluetooth_ag_is_nrec_enabled_p(void)
 	bool enabled = 1;
 	ret = bt_ag_is_nrec_enabled(&enabled);
 	dts_check_eq("bt_ag_is_nrec_enabled", ret, BT_ERROR_NONE,
-		     "bt_ag_is_nrec_enabled() failed.");
+			"bt_ag_is_nrec_enabled() failed.");
 
 }
 
@@ -315,7 +365,7 @@ static void utc_network_bluetooth_ag_set_microphone_gain_changed_p(void)
 	int ret = BT_ERROR_NONE;
 	ret = bt_ag_set_microphone_gain_changed_cb(microphone_gain_changed_cb_for_ag_p, NULL);
 	dts_check_eq("bt_ag_set_microphone_gain_changed_cb", ret, BT_ERROR_NONE,
-		     "bt_ag_set_microphone_gain_changed_cb() failed.");
+			"bt_ag_set_microphone_gain_changed_cb() failed.");
 
 }
 
@@ -327,8 +377,8 @@ static void utc_network_bluetooth_ag_unset_microphone_gain_changed_p(void)
 	int ret = BT_ERROR_NONE;
 	ret = bt_ag_unset_microphone_gain_changed_cb();
 	dts_check_eq("bt_ag_unset_microphone_gain_changed_cb", ret,
-		     BT_ERROR_NONE,
-		     "bt_ag_unset_microphone_gain_changed_cb() failed.");
+			BT_ERROR_NONE,
+			"bt_ag_unset_microphone_gain_changed_cb() failed.");
 
 }
 
@@ -340,7 +390,7 @@ static void utc_network_bluetooth_ag_set_speaker_gain_changed_p(void)
 	int ret = BT_ERROR_NONE;
 	ret = bt_ag_set_speaker_gain_changed_cb(speaker_gain_changed_cb_for_ag_p, NULL);
 	dts_check_eq("bt_ag_set_speaker_gain_changed_cb", ret, BT_ERROR_NONE,
-		     "bt_ag_set_speaker_gain_changed_cb() failed.");
+			"bt_ag_set_speaker_gain_changed_cb() failed.");
 
 }
 
@@ -352,7 +402,7 @@ static void utc_network_bluetooth_ag_unset_speaker_gain_changed_p(void)
 	int ret = BT_ERROR_NONE;
 	ret = bt_ag_unset_speaker_gain_changed_cb();
 	dts_check_eq("bt_ag_unset_speaker_gain_changed_cb", ret, BT_ERROR_NONE,
-		     "bt_ag_unset_speaker_gain_changed_cb() failed.");
+			"bt_ag_unset_speaker_gain_changed_cb() failed.");
 
 }
 
@@ -364,7 +414,7 @@ static void utc_network_bluetooth_ag_open_sco_p(void)
 	int ret = BT_ERROR_NONE;
 	ret = bt_ag_open_sco();
 	dts_check_eq("bt_ag_open_sco", ret, BT_ERROR_NONE,
-		     "bt_ag_open_sco() failed.");
+			"bt_ag_open_sco() failed.");
 
 }
 
@@ -376,7 +426,7 @@ static void utc_network_bluetooth_ag_close_sco_p(void)
 	int ret = BT_ERROR_NONE;
 	ret = bt_ag_close_sco();
 	dts_check_eq("bt_ag_close_sco", ret, BT_ERROR_NONE,
-		     "bt_ag_close_sco() failed.");
+			"bt_ag_close_sco() failed.");
 
 }
 
@@ -389,7 +439,7 @@ static void utc_network_bluetooth_ag_is_sco_opened_p(void)
 	bool opened = 1;
 	ret = bt_ag_is_sco_opened(&opened);
 	dts_check_eq("bt_ag_is_sco_opened", ret, BT_ERROR_NONE,
-		     "bt_ag_is_sco_opened() failed.");
+			"bt_ag_is_sco_opened() failed.");
 
 }
 
@@ -401,7 +451,7 @@ static void utc_network_bluetooth_ag_set_sco_state_changed_p(void)
 	int ret = BT_ERROR_NONE;
 	ret = bt_ag_set_sco_state_changed_cb(sco_state_changed_cb_for_ag_p, NULL);
 	dts_check_eq("bt_ag_set_sco_state_changed_cb", ret, BT_ERROR_NONE,
-		     "bt_ag_set_sco_state_changed_cb() failed.");
+			"bt_ag_set_sco_state_changed_cb() failed.");
 
 }
 
@@ -413,7 +463,7 @@ static void utc_network_bluetooth_ag_unset_sco_state_changed_p(void)
 	int ret = BT_ERROR_NONE;
 	ret = bt_ag_unset_sco_state_changed_cb();
 	dts_check_eq("bt_ag_unset_sco_state_changed_cb", ret, BT_ERROR_NONE,
-		     "bt_ag_unset_sco_state_changed_cb() failed.");
+			"bt_ag_unset_sco_state_changed_cb() failed.");
 
 }
 
@@ -426,9 +476,9 @@ static void utc_network_bluetooth_ag_notify_call_event_p(void)
 	const char *phone_number = "9663868998";
 	unsigned int call_id = 0;
 	ret = bt_ag_notify_call_event(BT_AG_CALL_EVENT_INCOMING,
-				      call_id, phone_number);
+				call_id, phone_number);
 	dts_check_eq("bt_ag_notify_call_event", ret, BT_ERROR_NONE,
-		     "bt_ag_notify_call_event() failed.");
+				"bt_ag_notify_call_event() failed.");
 
 }
 
@@ -439,11 +489,13 @@ static void utc_network_bluetooth_ag_notify_call_list_p(void)
 {
 	int ret = BT_ERROR_NONE;
 	bt_call_list_h handle;
+	const char *phone_number = "9663868998";
+
 	handle = g_malloc0(sizeof(bt_call_list_h));
-	bt_call_list_add(handle, 1, BT_AG_CALL_STATE_ACTIVE);
+	bt_call_list_add(handle, 1, BT_AG_CALL_STATE_ACTIVE, phone_number);
 	ret = bt_ag_notify_call_list(handle);
 	dts_check_eq("bt_ag_notify_call_list", ret, BT_ERROR_NONE,
-		     "bt_ag_notify_call_list() failed.");
+				"bt_ag_notify_call_list() failed.");
 
 }
 
@@ -453,11 +505,11 @@ static void utc_network_bluetooth_ag_notify_call_list_p(void)
 static void utc_network_bluetooth_ag_notify_voice_recognition_state_p(void)
 {
 	int ret = BT_ERROR_NONE;
-	bool state = true;
+	bool state = 1;
 
 	ret = bt_ag_notify_voice_recognition_state(state);
 	dts_check_eq("bt_ag_notify_voice_recognition_state", ret, BT_ERROR_NONE,
-		     "bt_ag_notify_voice_recognition_state() failed.");
+				"bt_ag_notify_voice_recognition_state() failed.");
 
 }
 
@@ -468,9 +520,9 @@ static void utc_network_bluetooth_ag_set_call_handling_event_cb_p(void)
 {
 	int ret = BT_ERROR_NONE;
 	ret = bt_ag_set_call_handling_event_cb(call_handling_event_cb_for_ag_p,
-					       NULL);
+				NULL);
 	dts_check_eq("bt_ag_set_call_handling_event_cb", ret, BT_ERROR_NONE,
-		     "bt_ag_set_call_handling_event_cb() failed.");
+				"bt_ag_set_call_handling_event_cb() failed.");
 
 }
 
@@ -482,7 +534,7 @@ static void utc_network_bluetooth_ag_unset_call_handling_event_cb_p(void)
 	int ret = BT_ERROR_NONE;
 	ret = bt_ag_unset_call_handling_event_cb();
 	dts_check_eq("bt_ag_unset_call_handling_event_cb", ret, BT_ERROR_NONE,
-		     "bt_ag_unset_call_handling_event_cb() failed.");
+				"bt_ag_unset_call_handling_event_cb() failed.");
 
 }
 
@@ -494,8 +546,8 @@ static void utc_network_bluetooth_ag_set_multi_call_handling_event_cb_p(void)
 	int ret = BT_ERROR_NONE;
 	ret = bt_ag_set_multi_call_handling_event_cb(multi_call_handling_event_cb_for_ag_p, NULL);
 	dts_check_eq("bt_ag_set_multi_call_handling_event_cb", ret,
-		     BT_ERROR_NONE,
-		     "bt_ag_set_multi_call_handling_event_cb() failed.");
+			BT_ERROR_NONE,
+			"bt_ag_set_multi_call_handling_event_cb() failed.");
 
 }
 
@@ -507,8 +559,8 @@ static void utc_network_bluetooth_ag_unset_multi_call_handling_event_cb_p(void)
 	int ret = BT_ERROR_NONE;
 	ret = bt_ag_unset_multi_call_handling_event_cb();
 	dts_check_eq("bt_ag_unset_multi_call_handling_event_cb", ret,
-		     BT_ERROR_NONE,
-		     "bt_ag_unset_multi_call_handling_event_cb() failed.");
+			BT_ERROR_NONE,
+			"bt_ag_unset_multi_call_handling_event_cb() failed.");
 
 }
 
@@ -520,7 +572,7 @@ static void utc_network_bluetooth_ag_set_dtmf_transmitted_cb_p(void)
 	int ret = BT_ERROR_NONE;
 	ret = bt_ag_set_dtmf_transmitted_cb(dtmf_transmitted_cb_for_ag_p, NULL);
 	dts_check_eq("bt_ag_set_dtmf_transmitted_cb", ret, BT_ERROR_NONE,
-		     "bt_ag_set_dtmf_transmitted_cb() failed.");
+			"bt_ag_set_dtmf_transmitted_cb() failed.");
 
 }
 
@@ -532,7 +584,7 @@ static void utc_network_bluetooth_ag_unset_dtmf_transmitted_cb_p(void)
 	int ret = BT_ERROR_NONE;
 	ret = bt_ag_unset_dtmf_transmitted_cb();
 	dts_check_eq("bt_ag_unset_dtmf_transmitted_cb", ret, BT_ERROR_NONE,
-		     "bt_ag_unset_dtmf_transmitted_cb() failed.");
+			"bt_ag_unset_dtmf_transmitted_cb() failed.");
 
 }
 
@@ -543,11 +595,13 @@ static void utc_network_bluetooth_ag_call_list_create_p(void)
 {
 	int ret = BT_ERROR_NONE;
 	bt_call_list_h handle;
-	handle = g_malloc0(sizeof(bt_call_list_h));
-	bt_call_list_add(handle, 1, BT_AG_CALL_STATE_ACTIVE);
+	const char *phone_number = "9663868998";
+
 	ret = bt_call_list_create(&handle);
+	ret = bt_call_list_add(handle, 1, BT_AG_CALL_STATE_ACTIVE, phone_number);
+
 	dts_check_eq("bt_call_list_create", ret, BT_ERROR_NONE,
-		     "bt_call_list_create() failed.");
+			"bt_call_list_create() failed.");
 }
 
 /**
@@ -557,11 +611,13 @@ static void utc_network_bluetooth_ag_call_list_destroy_p(void)
 {
 	int ret = BT_ERROR_NONE;
 	bt_call_list_h handle;
+	const char *phone_number = "9663868998";
+
 	handle = g_malloc0(sizeof(bt_call_list_h));
-	bt_call_list_add(handle, 1, BT_AG_CALL_STATE_ACTIVE);
+	bt_call_list_add(handle, 1, BT_AG_CALL_STATE_ACTIVE, phone_number);
 	ret = bt_call_list_destroy(handle);
 	dts_check_eq("bt_call_list_destroy", ret, BT_ERROR_NONE,
-		     "bt_call_list_destroy() failed.");
+			"bt_call_list_destroy() failed.");
 }
 
 /**
@@ -571,11 +627,13 @@ static void utc_network_bluetooth_ag_call_list_reset_p(void)
 {
 	int ret = BT_ERROR_NONE;
 	bt_call_list_h handle;
+	const char *phone_number = "9663868998";
+
 	handle = g_malloc0(sizeof(bt_call_list_h));
-	bt_call_list_add(handle, 1, BT_AG_CALL_STATE_ACTIVE);
+	bt_call_list_add(handle, 1, BT_AG_CALL_STATE_ACTIVE, phone_number);
 	ret = bt_call_list_reset(handle);
 	dts_check_eq("bt_call_list_reset", ret, BT_ERROR_NONE,
-		     "bt_call_list_reset() failed.");
+			"bt_call_list_reset() failed.");
 }
 
 /**
@@ -586,23 +644,13 @@ static void utc_network_bluetooth_ag_call_list_add_p(void)
 	int ret = BT_ERROR_NONE;
 	unsigned int call_id = 0;
 	bt_call_list_h handle;
+	const char *phone_number = "9663868998";
+
 	handle = g_malloc0(sizeof(bt_call_list_h));
-	bt_call_list_add(handle, 1, BT_AG_CALL_STATE_ACTIVE);
-	ret = bt_call_list_add(handle, call_id, BT_AG_CALL_STATE_INCOMING);
+	bt_call_list_add(handle, 1, BT_AG_CALL_STATE_ACTIVE, phone_number);
+	ret = bt_call_list_add(handle, call_id, BT_AG_CALL_STATE_INCOMING, phone_number);
 	dts_check_eq("bt_call_list_add", ret, BT_ERROR_NONE,
-		     "bt_call_list_add() failed.");
-}
-
-/**
- * @brief Positive test case of bt_a2dp_set_content_protection()
- */
-static void utc_network_bluetooth_ag_ca2dp_set_content_protection_p(void)
-{
-	int ret = BT_ERROR_NONE;
-	bool status = true;
-	ret = bt_a2dp_set_content_protection(status);
-	dts_check_eq("bt_a2dp_set_content_protection", ret, BT_ERROR_NONE,
-		     "bt_a2dp_set_content_protection() failed.");
+			"bt_call_list_add() failed.");
 }
 
 /**
@@ -614,5 +662,5 @@ static void utc_network_bluetooth_audio_deinitialize_p(void)
 
 	ret = bt_audio_deinitialize();
 	dts_check_eq("bt_audio_deinitialize", ret, BT_ERROR_NONE,
-		     "bt_audio_deinitialize() failed.");
+			"bt_audio_deinitialize() failed.");
 }
diff --git a/mobile/TC/testcase/utc_network_bluetooth_avrcp_negative.c b/TC/testcase/utc_network_bluetooth_avrcp_negative.c
index d418475..a62c7b4 100644
--- a/mobile/TC/testcase/utc_network_bluetooth_avrcp_negative.c
+++ b/TC/testcase/utc_network_bluetooth_avrcp_negative.c
@@ -31,11 +31,13 @@ static void utc_network_bluetooth_avrcp_set_repeat_mode_changed_n(void);
 static void utc_network_bluetooth_avrcp_set_shuffle_mode_changed_n(void);
 static void utc_network_bluetooth_avrcp_set_scan_mode_changed_n(void);
 
+
 void adapter_state_changed_cb_for_avrcp_n(int result,
-					  bt_adapter_state_e adapter_state,
-					  void *user_data);
+					bt_adapter_state_e adapter_state,
+					void *user_data);
 gboolean timeout_func(gpointer data);
 
+
 struct tet_testlist tet_testlist[] = {
 	{utc_network_bluetooth_audio_initialize_n, NEGATIVE_TC_IDX},
 	{utc_network_bluetooth_avrcp_set_equalizer_state_changed_n, NEGATIVE_TC_IDX},
@@ -45,6 +47,7 @@ struct tet_testlist tet_testlist[] = {
 	{NULL, 0},
 };
 
+
 static void startup(void)
 {
 	int ret = BT_ERROR_NONE;
@@ -109,8 +112,8 @@ static void utc_network_bluetooth_audio_initialize_n(void)
 
 	ret = bt_avrcp_target_initialize(NULL, NULL);
 	dts_check_eq("bt_avrcp_target_initialize", ret,
-		     BT_ERROR_INVALID_PARAMETER,
-		     "bt_avrcp_target_initialize() failed.");
+			BT_ERROR_INVALID_PARAMETER,
+			"bt_avrcp_target_initialize() failed.");
 
 }
 
@@ -123,8 +126,8 @@ static void utc_network_bluetooth_avrcp_set_equalizer_state_changed_n(void)
 
 	ret = bt_avrcp_set_equalizer_state_changed_cb(NULL, NULL);
 	dts_check_eq("bt_avrcp_set_equalizer_state_changed_cb", ret,
-		     BT_ERROR_INVALID_PARAMETER,
-		     "bt_avrcp_set_equalizer_state_changed_cb() failed.");
+			BT_ERROR_INVALID_PARAMETER,
+			"bt_avrcp_set_equalizer_state_changed_cb() failed.");
 
 }
 
@@ -137,8 +140,8 @@ static void utc_network_bluetooth_avrcp_set_repeat_mode_changed_n(void)
 
 	ret = bt_avrcp_set_repeat_mode_changed_cb(NULL, NULL);
 	dts_check_eq("bt_avrcp_set_repeat_mode_changed_cb", ret,
-		     BT_ERROR_INVALID_PARAMETER,
-		     "bt_avrcp_set_repeat_mode_changed_cb() failed.");
+			BT_ERROR_INVALID_PARAMETER,
+			"bt_avrcp_set_repeat_mode_changed_cb() failed.");
 
 }
 
@@ -151,8 +154,8 @@ static void utc_network_bluetooth_avrcp_set_shuffle_mode_changed_n(void)
 
 	ret = bt_avrcp_set_shuffle_mode_changed_cb(NULL, NULL);
 	dts_check_eq("bt_avrcp_set_shuffle_mode_changed_cb", ret,
-		     BT_ERROR_INVALID_PARAMETER,
-		     "bt_avrcp_set_shuffle_mode_changed_cb() failed.");
+			BT_ERROR_INVALID_PARAMETER,
+			"bt_avrcp_set_shuffle_mode_changed_cb() failed.");
 
 }
 
@@ -165,7 +168,7 @@ static void utc_network_bluetooth_avrcp_set_scan_mode_changed_n(void)
 
 	ret = bt_avrcp_set_scan_mode_changed_cb(NULL, NULL);
 	dts_check_eq("bt_avrcp_set_scan_mode_changed_cb", ret,
-		     BT_ERROR_INVALID_PARAMETER,
-		     "bt_avrcp_set_scan_mode_changed_cb() failed.");
+			BT_ERROR_INVALID_PARAMETER,
+			"bt_avrcp_set_scan_mode_changed_cb() failed.");
 
 }
diff --git a/mobile/TC/testcase/utc_network_bluetooth_avrcp_positive.c b/TC/testcase/utc_network_bluetooth_avrcp_positive.c
index dab7f7e..79e0688 100644..100755
--- a/mobile/TC/testcase/utc_network_bluetooth_avrcp_positive.c
+++ b/TC/testcase/utc_network_bluetooth_avrcp_positive.c
@@ -5,7 +5,7 @@
  *      Author: mrinal.m
  */
 
-#include "bluetooth.h"
+#include <bluetooth.h>
 #include <tet_api.h>
 #include <glib.h>
 
@@ -23,15 +23,16 @@ void (*tet_startup) (void) = startup;
 void (*tet_cleanup) (void) = cleanup;
 
 void target_connection_state_changed_cb_for_avrcp_p(bool connected,
-						    const char *remote_address,
-						    void *user_data);
-void equalizer_state_changed_cb_for_avrcp_p(bt_avrcp_equalizer_state_e equalizer, void *user_data);
+						const char *remote_address,
+						void *user_data);
+void equalizer_state_changed_cb_for_avrcp_p(bt_avrcp_equalizer_state_e equalizer,
+						void *user_data);
 void repeat_mode_changed_cb_for_avrcp_p(bt_avrcp_repeat_mode_e repeat,
-					void *user_data);
+						void *user_data);
 void shuffle_mode_changed_cb_for_avrcp_p(bt_avrcp_shuffle_mode_e shuffle,
-					 void *user_data);
+						void *user_data);
 void scan_mode_changed_cb_for_avrcp_p(bt_avrcp_scan_mode_e scan,
-				      void *user_data);
+						void *user_data);
 
 static void utc_network_bluetooth_avrcp_targe_initialize_p(void);
 static void utc_network_bluetooth_avrcp_target_deinitialize_p(void);
@@ -52,8 +53,8 @@ static void utc_network_bluetooth_avrcp_set_scan_mode_changed_p(void);
 static void utc_network_bluetooth_avrcp_unset_scan_mode_changed_p(void);
 
 void adapter_state_changed_cb_for_avrcp_p(int result,
-					  bt_adapter_state_e adapter_state,
-					  void *user_data);
+					bt_adapter_state_e adapter_state,
+					void *user_data);
 gboolean timeout_func(gpointer data);
 
 struct tet_testlist tet_testlist[] = {
@@ -131,20 +132,22 @@ gboolean timeout_func(gpointer data)
  */
 
 void adapter_state_changed_cb_for_avrcp_p(int result,
-					  bt_adapter_state_e adapter_state,
-					  void *user_data)
+					bt_adapter_state_e adapter_state,
+					void *user_data)
 {
 
 }
 
 void target_connection_state_changed_cb_for_avrcp_p(bool connected,
-						    const char *remote_address,
-						    void *user_data)
+					const char *remote_address,
+					void *user_data)
 {
 
 }
 
-void equalizer_state_changed_cb_for_avrcp_p(bt_avrcp_equalizer_state_e equalizer, void *user_data)
+void equalizer_state_changed_cb_for_avrcp_p(
+					bt_avrcp_equalizer_state_e equalizer,
+					void *user_data)
 {
 
 }
@@ -156,13 +159,13 @@ void repeat_mode_changed_cb_for_avrcp_p(bt_avrcp_repeat_mode_e repeat,
 }
 
 void shuffle_mode_changed_cb_for_avrcp_p(bt_avrcp_shuffle_mode_e shuffle,
-					 void *user_data)
+					void *user_data)
 {
 
 }
 
 void scan_mode_changed_cb_for_avrcp_p(bt_avrcp_scan_mode_e scan,
-				      void *user_data)
+					void *user_data)
 {
 
 }
@@ -174,9 +177,11 @@ static void utc_network_bluetooth_avrcp_targe_initialize_p(void)
 {
 	int ret = BT_ERROR_NONE;
 
-	ret = bt_avrcp_target_initialize(target_connection_state_changed_cb_for_avrcp_p, NULL);
+	ret = bt_avrcp_target_initialize(
+								target_connection_state_changed_cb_for_avrcp_p,
+								NULL);
 	dts_check_eq("bt_avrcp_target_initialize", ret, BT_ERROR_NONE,
-		     "bt_avrcp_target_initialize() failed.");
+			"bt_avrcp_target_initialize() failed.");
 
 }
 
@@ -189,7 +194,7 @@ static void utc_network_bluetooth_avrcp_target_deinitialize_p(void)
 
 	ret = bt_avrcp_target_deinitialize();
 	dts_check_eq("bt_avrcp_target_deinitialize", ret, BT_ERROR_NONE,
-		     "bt_avrcp_target_deinitialize() failed.");
+			"bt_avrcp_target_deinitialize() failed.");
 
 }
 
@@ -202,8 +207,8 @@ static void utc_network_bluetooth_avrcp_target_notify_equalizer_state_p(void)
 
 	ret = bt_avrcp_target_notify_equalizer_state(BT_AVRCP_EQUALIZER_STATE_ON);
 	dts_check_eq("bt_avrcp_target_notify_equalizer_state", ret,
-		     BT_ERROR_NONE,
-		     "bt_avrcp_target_notify_equalizer_state() failed.");
+			BT_ERROR_NONE,
+			"bt_avrcp_target_notify_equalizer_state() failed.");
 
 }
 
@@ -216,7 +221,7 @@ static void utc_network_bluetooth_avrcp_target_notify_repeat_mode_p(void)
 
 	ret = bt_avrcp_target_notify_repeat_mode(BT_AVRCP_REPEAT_MODE_ALL_TRACK);
 	dts_check_eq("bt_avrcp_target_notify_repeat_mode", ret, BT_ERROR_NONE,
-		     "bt_avrcp_target_notify_repeat_mode() failed.");
+			"bt_avrcp_target_notify_repeat_mode() failed.");
 
 }
 
@@ -229,7 +234,7 @@ static void utc_network_bluetooth_avrcp_target_notify_shuffle_mode_p(void)
 
 	ret = bt_avrcp_target_notify_shuffle_mode(BT_AVRCP_SHUFFLE_MODE_ALL_TRACK);
 	dts_check_eq("bt_avrcp_target_notify_shuffle_mode", ret, BT_ERROR_NONE,
-		     "bt_avrcp_target_notify_shuffle_mode() failed.");
+			"bt_avrcp_target_notify_shuffle_mode() failed.");
 
 }
 
@@ -242,7 +247,7 @@ static void utc_network_bluetooth_avrcp_target_notify_scan_mode_p(void)
 
 	ret = bt_avrcp_target_notify_scan_mode(BT_AVRCP_SCAN_MODE_ALL_TRACK);
 	dts_check_eq("bt_avrcp_target_notify_scan_mode", ret, BT_ERROR_NONE,
-		     "bt_avrcp_target_notify_scan_mode() failed.");
+			"bt_avrcp_target_notify_scan_mode() failed.");
 }
 
 /**
@@ -254,7 +259,7 @@ static void utc_network_bluetooth_avrcp_target_notify_player_state_p(void)
 
 	ret = bt_avrcp_target_notify_player_state(BT_AVRCP_PLAYER_STATE_PLAYING);
 	dts_check_eq("bt_avrcp_target_notify_player_state", ret, BT_ERROR_NONE,
-		     "bt_avrcp_target_notify_player_state() failed.");
+			"bt_avrcp_target_notify_player_state() failed.");
 }
 
 /**
@@ -266,7 +271,7 @@ static void utc_network_bluetooth_avrcp_target_notify_position_p(void)
 	unsigned int position = 0;
 	ret = bt_avrcp_target_notify_position(position);
 	dts_check_eq("bt_avrcp_target_notify_position", ret, BT_ERROR_NONE,
-		     "bt_avrcp_target_notify_position() failed.");
+			"bt_avrcp_target_notify_position() failed.");
 }
 
 /**
@@ -278,7 +283,7 @@ static void utc_network_bluetooth_avrcp_target_notify_track_p(void)
 
 	ret = bt_avrcp_target_notify_track("title", "artist", "album", "genre", 5, 20, 2);
 	dts_check_eq("bt_avrcp_target_notify_track", ret, BT_ERROR_NONE,
-		     "bt_avrcp_target_notify_track() failed.");
+			"bt_avrcp_target_notify_track() failed.");
 }
 
 /**
@@ -288,10 +293,11 @@ static void utc_network_bluetooth_avrcp_set_equalizer_state_changed_p(void)
 {
 	int ret = BT_ERROR_NONE;
 
-	ret = bt_avrcp_set_equalizer_state_changed_cb(equalizer_state_changed_cb_for_avrcp_p, NULL);
-	dts_check_eq("bt_avrcp_set_equalizer_state_changed_cb", ret,
-		     BT_ERROR_NONE,
-		     "bt_avrcp_set_equalizer_state_changed_cb() failed.");
+	ret = bt_avrcp_set_equalizer_state_changed_cb(
+									equalizer_state_changed_cb_for_avrcp_p,
+									NULL);
+	dts_check_eq("bt_avrcp_set_equalizer_state_changed_cb", ret, BT_ERROR_NONE,
+			"bt_avrcp_set_equalizer_state_changed_cb() failed.");
 
 }
 
@@ -304,8 +310,8 @@ static void utc_network_bluetooth_avrcp_unset_equalizer_state_changed_p(void)
 
 	ret = bt_avrcp_unset_equalizer_state_changed_cb();
 	dts_check_eq("bt_avrcp_unset_equalizer_state_changed_cb", ret,
-		     BT_ERROR_NONE,
-		     "bt_avrcp_unset_equalizer_state_changed_cb() failed.");
+			BT_ERROR_NONE,
+			"bt_avrcp_unset_equalizer_state_changed_cb() failed.");
 
 }
 
@@ -318,7 +324,7 @@ static void utc_network_bluetooth_avrcp_set_repeat_mode_changed_p(void)
 
 	ret = bt_avrcp_set_repeat_mode_changed_cb(repeat_mode_changed_cb_for_avrcp_p, NULL);
 	dts_check_eq("bt_avrcp_set_repeat_mode_changed_cb", ret, BT_ERROR_NONE,
-		     "bt_avrcp_set_repeat_mode_changed_cb() failed.");
+			"bt_avrcp_set_repeat_mode_changed_cb() failed.");
 
 }
 
@@ -331,8 +337,8 @@ static void utc_network_bluetooth_avrcp_unset_repeat_mode_changed_p(void)
 
 	ret = bt_avrcp_unset_repeat_mode_changed_cb();
 	dts_check_eq("bt_avrcp_unset_repeat_mode_changed_cb", ret,
-		     BT_ERROR_NONE,
-		     "bt_avrcp_unset_repeat_mode_changed_cb() failed.");
+			BT_ERROR_NONE,
+			"bt_avrcp_unset_repeat_mode_changed_cb() failed.");
 
 }
 
@@ -343,9 +349,11 @@ static void utc_network_bluetooth_avrcp_set_shuffle_mode_changed_p(void)
 {
 	int ret = BT_ERROR_NONE;
 
-	ret = bt_avrcp_set_shuffle_mode_changed_cb(shuffle_mode_changed_cb_for_avrcp_p, NULL);
+	ret = bt_avrcp_set_shuffle_mode_changed_cb(
+										shuffle_mode_changed_cb_for_avrcp_p,
+										NULL);
 	dts_check_eq("bt_avrcp_set_shuffle_mode_changed_cb", ret, BT_ERROR_NONE,
-		     "bt_avrcp_set_shuffle_mode_changed_cb() failed.");
+			"bt_avrcp_set_shuffle_mode_changed_cb() failed.");
 }
 
 /**
@@ -357,8 +365,8 @@ static void utc_network_bluetooth_avrcp_unset_shuffle_mode_changed_p(void)
 
 	ret = bt_avrcp_unset_shuffle_mode_changed_cb();
 	dts_check_eq("bt_avrcp_unset_shuffle_mode_changed_cb", ret,
-		     BT_ERROR_NONE,
-		     "bt_avrcp_unset_shuffle_mode_changed_cb() failed.");
+			BT_ERROR_NONE,
+			"bt_avrcp_unset_shuffle_mode_changed_cb() failed.");
 }
 
 /**
@@ -368,9 +376,11 @@ static void utc_network_bluetooth_avrcp_set_scan_mode_changed_p(void)
 {
 	int ret = BT_ERROR_NONE;
 
-	ret = bt_avrcp_set_scan_mode_changed_cb(scan_mode_changed_cb_for_avrcp_p, NULL);
+	ret = bt_avrcp_set_scan_mode_changed_cb(scan_mode_changed_cb_for_avrcp_p,
+					NULL);
 	dts_check_eq("bt_avrcp_set_scan_mode_changed_cb", ret, BT_ERROR_NONE,
-		     "bt_avrcp_set_scan_mode_changed_cb() failed.");
+					"bt_avrcp_set_scan_mode_changed_cb() failed.");
+
 }
 
 /**
@@ -382,6 +392,7 @@ static void utc_network_bluetooth_avrcp_unset_scan_mode_changed_p(void)
 
 	ret = bt_avrcp_unset_scan_mode_changed_cb();
 	dts_check_eq("bt_avrcp_unset_scan_mode_changed_cb", ret, BT_ERROR_NONE,
-		     "bt_avrcp_unset_scan_mode_changed_cb() failed.");
+			"bt_avrcp_unset_scan_mode_changed_cb() failed.");
 
 }
+
diff --git a/mobile/TC/testcase/utc_network_bluetooth_common_negative.c b/TC/testcase/utc_network_bluetooth_common_negative.c
index 507d7f5..4d2eb6e 100644
--- a/mobile/TC/testcase/utc_network_bluetooth_common_negative.c
+++ b/TC/testcase/utc_network_bluetooth_common_negative.c
@@ -77,8 +77,8 @@ gboolean timeout_func(gpointer data)
 }
 
 void adapter_state_changed_cb_for_common_n(int result,
-					   bt_adapter_state_e adapter_state,
-					   void *user_data)
+						bt_adapter_state_e adapter_state,
+						void *user_data)
 {
 
 }
diff --git a/mobile/TC/testcase/utc_network_bluetooth_common_positive.c b/TC/testcase/utc_network_bluetooth_common_positive.c
index c694655..bf775cf 100644..100755
--- a/mobile/TC/testcase/utc_network_bluetooth_common_positive.c
+++ b/TC/testcase/utc_network_bluetooth_common_positive.c
@@ -5,7 +5,7 @@
  *      Author: mrinal.m
  */
 
-#include "bluetooth.h"
+#include <bluetooth.h>
 #include <tet_api.h>
 #include <glib.h>
 
@@ -23,8 +23,8 @@ void (*tet_startup) (void) = startup;
 void (*tet_cleanup) (void) = cleanup;
 
 void adapter_state_changed_cb_for_common_p(int result,
-					   bt_adapter_state_e adapter_state,
-					   void *user_data);
+					bt_adapter_state_e adapter_state,
+					void *user_data);
 gboolean timeout_func(gpointer data);
 
 static void utc_network_bluetooth_bt_initialize_p(void);
@@ -86,8 +86,8 @@ gboolean timeout_func(gpointer data)
 }
 
 void adapter_state_changed_cb_for_common_p(int result,
-					   bt_adapter_state_e adapter_state,
-					   void *user_data)
+					bt_adapter_state_e adapter_state,
+					void *user_data)
 {
 
 }
@@ -101,7 +101,7 @@ static void utc_network_bluetooth_bt_initialize_p(void)
 
 	ret = bt_initialize();
 	dts_check_eq("bt_initialize", ret, BT_ERROR_NONE,
-		     "bt_initialize() failed.");
+			"bt_initialize() failed.");
 
 }
 
@@ -114,6 +114,9 @@ static void utc_network_bluetooth_bt_deinitialize_p(void)
 
 	ret = bt_deinitialize();
 	dts_check_eq("bt_deinitialize", ret, BT_ERROR_NONE,
-		     "bt_deinitialize() failed.");
+			"bt_deinitialize() failed.");
 
 }
+
+
+
diff --git a/mobile/TC/testcase/utc_network_bluetooth_device_discovery_negative.c b/TC/testcase/utc_network_bluetooth_device_discovery_negative.c
index b5b422f..48b22d3 100644
--- a/mobile/TC/testcase/utc_network_bluetooth_device_discovery_negative.c
+++ b/TC/testcase/utc_network_bluetooth_device_discovery_negative.c
@@ -41,8 +41,8 @@ static void utc_network_bluetooth_device_discovery_start_n(void);
 static void utc_network_bluetooth_device_discovery_get_status_n(void);
 
 void adapter_state_changed_cb_for_discovery_n(int result,
-					      bt_adapter_state_e adapter_state,
-					      void *user_data);
+						bt_adapter_state_e adapter_state,
+						void *user_data);
 
 struct tet_testlist tet_testlist[] = {
 	{utc_network_bluetooth_device_discovery_cancel_n, NEGATIVE_TC_IDX},
@@ -104,13 +104,13 @@ gboolean timeout_func(gpointer data)
  * @brief Callback funtions
  */
 void adapter_state_changed_cb_for_discovery_n(int result,
-					      state_e adapter_state,
-					      void *user_data)
+						bt_adapter_state_e adapter_state,
+						void *user_data)
 {
 	tet_printf("Callback: bt_adapter_state_changed_cb was called.");
 	if (user_data != NULL && !strcmp((char *)user_data, "startup")) {
 		if (adapter_state == BT_ADAPTER_DISABLED &&
-		    result == BT_ERROR_NONE) {
+				result == BT_ERROR_NONE) {
 			tet_printf("Callback: BT was disabled. DTS will be started.");
 		} else {
 			tet_printf("Callback: BT was not disabled. DTS will be started but DTS may fail.");
@@ -130,8 +130,8 @@ static void utc_network_bluetooth_device_discovery_cancel_n(void)
 	int ret = bt_adapter_stop_device_discovery();
 
 	dts_check_eq("bt_adapter_stop_device_discovery", ret,
-		     BT_ERROR_NOT_ENABLED,
-		     "BT_ERROR_NOT_ENABLED must be returned when BT is not enabled");
+			BT_ERROR_NOT_ENABLED,
+			"BT_ERROR_NOT_ENABLED must be returned when BT is not enabled");
 }
 
 /**
@@ -143,12 +143,12 @@ static void utc_network_bluetooth_device_discovery_unset_state_changed_cb_n(void
 
 	if (bt_deinitialize() != BT_ERROR_NONE) {
 		dts_fail("bt_adapter_unset_device_discovery_state_changed_cb",
-			 "bt_deinitialize() failed.");
+			"bt_deinitialize() failed.");
 	}
 	ret = bt_adapter_unset_device_discovery_state_changed_cb();
 	dts_check_eq("bt_adapter_unset_device_discovery_state_changed_cb", ret,
-		     BT_ERROR_NOT_INITIALIZED,
-		     "BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized.");
+			BT_ERROR_NOT_INITIALIZED,
+			"BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized.");
 }
 
 /**
@@ -160,8 +160,8 @@ static void utc_network_bluetooth_device_discovery_set_state_changed_cb_n(void)
 
 	ret = bt_adapter_set_device_discovery_state_changed_cb(NULL, NULL);
 	dts_check_eq("bt_adapter_set_device_discovery_state_changed_cb", ret,
-		     BT_ERROR_INVALID_PARAMETER,
-		     "BT_ERROR_INVALID_PARAMETER must be returned when callback parameter is NULL");
+			BT_ERROR_INVALID_PARAMETER,
+			"BT_ERROR_INVALID_PARAMETER must be returned when callback parameter is NULL");
 }
 
 /**
@@ -173,8 +173,8 @@ static void utc_network_bluetooth_device_discovery_start_n(void)
 
 	ret = bt_adapter_start_device_discovery();;
 	dts_check_eq("bt_adapter_start_device_discovery", ret,
-		     BT_ERROR_NOT_ENABLED,
-		     "BT_ERROR_NOT_ENABLED must be returned when BT is not enabled");
+			BT_ERROR_NOT_ENABLED,
+			"BT_ERROR_NOT_ENABLED must be returned when BT is not enabled");
 }
 
 /**
@@ -187,5 +187,5 @@ static void utc_network_bluetooth_device_discovery_get_status_n(void)
 
 	ret = bt_adapter_is_discovering(&status);
 	dts_check_eq("bt_adapter_is_discovering", ret, BT_ERROR_NOT_ENABLED,
-		     "BT_ERROR_NOT_ENABLED must be returned when BT is not enabled");
+			"BT_ERROR_NOT_ENABLED must be returned when BT is not enabled");
 }
diff --git a/mobile/TC/testcase/utc_network_bluetooth_device_discovery_positive.c b/TC/testcase/utc_network_bluetooth_device_discovery_positive.c
index 0cd0fe4..76caf9f 100644..100755
--- a/mobile/TC/testcase/utc_network_bluetooth_device_discovery_positive.c
+++ b/TC/testcase/utc_network_bluetooth_device_discovery_positive.c
@@ -42,12 +42,12 @@ static void utc_network_bluetooth_device_discovery_cancel_p(void);
 
 gboolean timeout_func(gpointer data);
 void adapter_state_changed_cb_for_discovery_p(int result,
-					      bt_adapter_state_e adapter_state,
-					      void *user_data);
+						bt_adapter_state_e adapter_state,
+						void *user_data);
 void device_discovery_state_changed_cb_for_discovery_p(int result,
-						       bt_adapter_device_discovery_state_e discovery_state,
-						       bt_adapter_device_discovery_info_s *discovery_info,
-						       void *user_data);
+						bt_adapter_device_discovery_state_e discovery_state,
+						bt_adapter_device_discovery_info_s *discovery_info,
+						void *user_data);
 
 struct tet_testlist tet_testlist[] = {
 	{utc_network_bluetooth_device_discovery_get_status_p, POSITIVE_TC_IDX},
@@ -86,7 +86,7 @@ static void startup(void)
 
 	if (bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE) {
 		tet_printf
-		    ("bt_adapter_unset_device_discovery_state_changed_cb() failed.");
+			("bt_adapter_unset_device_discovery_state_changed_cb() failed.");
 	}
 
 	tet_printf("TC start");
@@ -110,12 +110,12 @@ gboolean timeout_func(gpointer data)
  * @brief Callback funtions
  */
 void adapter_state_changed_cb_for_discovery_p(int result,
-					      bt_adapter_state_e adapter_state,
-					      void *user_data)
+						bt_adapter_state_e adapter_state,
+						void *user_data)
 {
 	if (user_data != NULL && !strcmp((char *)user_data, "startup")) {
 		if (adapter_state == BT_ADAPTER_ENABLED &&
-		    result == BT_ERROR_NONE) {
+				result == BT_ERROR_NONE) {
 			tet_printf("Callback: BT was enabled.");
 		} else {
 			tet_printf("Callback: bt_adapter_state_changed_cb() was \
@@ -129,9 +129,9 @@ void adapter_state_changed_cb_for_discovery_p(int result,
 }
 
 void device_discovery_state_changed_cb_for_discovery_p(int result,
-						       bt_adapter_device_discovery_state_e discovery_state,
-						       bt_adapter_device_discovery_info_s *discovery_info,
-						       void *user_data)
+					bt_adapter_device_discovery_state_e discovery_state,
+					bt_adapter_device_discovery_info_s *discovery_info,
+					void *user_data)
 {
 	tet_printf("Callback: device_discovery_state_changed_cb_for_discovery_p is called");
 
@@ -174,7 +174,7 @@ static void utc_network_bluetooth_device_discovery_get_status_p(void)
 
 	ret = bt_adapter_is_discovering(&status);
 	dts_check_eq("bt_adapter_is_discovering", ret, BT_ERROR_NONE,
-		     "bt_adapter_is_discovering() failed.");
+			"bt_adapter_is_discovering() failed.");
 }
 
 /**
@@ -186,8 +186,8 @@ static void utc_network_bluetooth_device_discovery_set_state_changed_cb_p(void)
 
 	ret = bt_adapter_set_device_discovery_state_changed_cb(device_discovery_state_changed_cb_for_discovery_p, "start");
 	dts_check_eq("bt_adapter_set_device_discovery_state_changed_cb", ret,
-		     BT_ERROR_NONE,
-		     "bt_adapter_set_device_discovery_state_changed_cb() failed.");
+			BT_ERROR_NONE,
+			"bt_adapter_set_device_discovery_state_changed_cb() failed.");
 }
 
 /**
@@ -207,11 +207,11 @@ static void utc_network_bluetooth_device_discovery_start_p(void)
 		g_main_loop_run(mainloop);
 		g_source_remove(timeout_id);
 		dts_check_eq("bt_adapter_start_device_discovery",
-			     callback_result, true,
-			     "Callback was called but failed.");
+				callback_result, true,
+				"Callback was called but failed.");
 	} else {
 		dts_fail("bt_adapter_start_device_discovery",
-			 "bt_adapter_start_device_discovery() failed.");
+				"bt_adapter_start_device_discovery() failed.");
 	}
 }
 
@@ -224,8 +224,8 @@ static void utc_network_bluetooth_device_discovery_unset_state_changed_cb_p(void
 
 	ret = bt_adapter_unset_device_discovery_state_changed_cb();
 	dts_check_eq("bt_adapter_unset_device_discovery_state_changed_cb", ret,
-		     BT_ERROR_NONE,
-		     "bt_device_discovery_uset_state_changed_cb() failed");
+			BT_ERROR_NONE,
+			"bt_device_discovery_uset_state_changed_cb() failed");
 }
 
 /**
@@ -238,24 +238,25 @@ static void utc_network_bluetooth_device_discovery_cancel_p(void)
 
 	callback_result = false;
 
-	if (bt_adapter_set_device_discovery_state_changed_cb(device_discovery_state_changed_cb_for_discovery_p, "cancel") != BT_ERROR_NONE) {
+	if (bt_adapter_set_device_discovery_state_changed_cb
+		(device_discovery_state_changed_cb_for_discovery_p, "cancel") != BT_ERROR_NONE) {
 		dts_fail("bt_adapter_stop_device_discovery",
-			 "bt_adapter_set_device_discovery_state_changed_cb() failed");
+			"bt_adapter_set_device_discovery_state_changed_cb() failed");
 	}
 
 	ret = bt_adapter_stop_device_discovery();
 	if (ret == BT_ERROR_NONE) {
-		tet_printf("bt_adapter_device_discovery_state_changed_cb_for_discovery_p() will be called");
+		tet_printf("bt_adapter_device_discovery_state_changed_cb_for_discovery_p() will be called");   
 		timeout_id = g_timeout_add(60000, timeout_func, mainloop);
 		g_main_loop_run(mainloop);
 		g_source_remove(timeout_id);
 		bt_adapter_unset_device_discovery_state_changed_cb();
-		dts_check_eq("bt_adapter_stop_device_discovery",
-			     callback_result, true,
-			     "Callback was called but failed");
+		dts_check_eq("bt_adapter_stop_device_discovery", callback_result, true,
+					"Callback was called but failed");
 	} else {
 		dts_fail("bt_adapter_stop_device_discovery",
-			 "bt_adapter_stop_device_discovery() failed");
+				"bt_adapter_stop_device_discovery() failed");
 	}
 
 }
+
diff --git a/mobile/TC/testcase/utc_network_bluetooth_device_negative.c b/TC/testcase/utc_network_bluetooth_device_negative.c
index f1e7d42..9915c99 100644..100755
--- a/mobile/TC/testcase/utc_network_bluetooth_device_negative.c
+++ b/TC/testcase/utc_network_bluetooth_device_negative.c
@@ -46,10 +46,14 @@ static void utc_network_bluetooth_device_unbond_n(void);
 static void utc_network_bluetooth_device_unset_bonded_cb_n(void);
 static void utc_network_bluetooth_device_unset_unbonded_cb_n(void);
 static void utc_network_bluetooth_device_unset_authorization_state_changed_cb_n(void);
+static void utc_network_bluetooth_device_get_rssi_strength_n(void);
+static void utc_network_bluetooth_device_disable_rssi_monitor_n(void);
+static void utc_network_bluetooth_device_enable_rssi_monitor_n(void);
+static void utc_network_bluetooth_device_unset_rssi_alert_cb_n(void);
 
 void adapter_state_changed_cb_for_device_negative(int result,
-						  bt_adapter_state_e adapter_state,
-						  void *user_data);
+						bt_adapter_state_e adapter_state,
+						void *user_data);
 gboolean timeout_func(gpointer data);
 
 struct tet_testlist tet_testlist[] = {
@@ -62,6 +66,10 @@ struct tet_testlist tet_testlist[] = {
 	{utc_network_bluetooth_device_foreach_bonded_device_n, NEGATIVE_TC_IDX},
 	{utc_network_bluetooth_device_set_alias_n, NEGATIVE_TC_IDX},
 	{utc_network_bluetooth_device_set_authorization_n, NEGATIVE_TC_IDX},
+	{utc_network_bluetooth_device_get_rssi_strength_n, NEGATIVE_TC_IDX },
+	{utc_network_bluetooth_device_enable_rssi_monitor_n, NEGATIVE_TC_IDX },
+	{utc_network_bluetooth_device_disable_rssi_monitor_n, NEGATIVE_TC_IDX },
+	{utc_network_bluetooth_device_unset_rssi_alert_cb_n, NEGATIVE_TC_IDX },
 	{utc_network_bluetooth_device_unset_bonded_cb_n, NEGATIVE_TC_IDX},
 	{utc_network_bluetooth_device_unset_unbonded_cb_n, NEGATIVE_TC_IDX},
 	{utc_network_bluetooth_device_unset_authorization_state_changed_cb_n, NEGATIVE_TC_IDX},
@@ -119,8 +127,8 @@ static void cleanup(void)
  * @brief Callback funtions
  */
 void adapter_state_changed_cb_for_device_negative(int result,
-						  bt_adapter_state_e adapter_state,
-						  void *user_data)
+						bt_adapter_state_e adapter_state,
+						void *user_data)
 {
 	tet_printf("Callback: bt_adapter_state_changed_cb was called.");
 	if ((user_data != NULL) && !strcmp((char *)user_data, "startup")) {
@@ -145,8 +153,8 @@ static void utc_network_bluetooth_device_set_bonded_cb_n(void)
 
 	ret = bt_device_set_bond_created_cb(NULL, NULL);
 	dts_check_eq("bt_device_set_bond_created_cb", ret,
-		     BT_ERROR_INVALID_PARAMETER,
-		     "BT_ERROR_INVALID_PARAMETER must be returned when callback parameter is NULL");
+			BT_ERROR_INVALID_PARAMETER,
+			"BT_ERROR_INVALID_PARAMETER must be returned when callback parameter is NULL");
 }
 
 /**
@@ -158,8 +166,8 @@ static void utc_network_bluetooth_device_set_unbonded_cb_n(void)
 
 	ret = bt_device_set_bond_destroyed_cb(NULL, NULL);
 	dts_check_eq("bt_device_set_bond_destroyed_cb", ret,
-		     BT_ERROR_INVALID_PARAMETER,
-		     "BT_ERROR_INVALID_PARAMETER must be returned when callback parameter is NULL");
+			BT_ERROR_INVALID_PARAMETER,
+			"BT_ERROR_INVALID_PARAMETER must be returned when callback parameter is NULL");
 }
 
 /**
@@ -172,8 +180,8 @@ utc_network_bluetooth_device_set_authorization_state_changed_cb_n(void)
 
 	ret = bt_device_set_authorization_changed_cb(NULL, NULL);
 	dts_check_eq("bt_device_set_authorization_changed_cb", ret,
-		     BT_ERROR_INVALID_PARAMETER,
-		     "BT_ERROR_INVALID_PARAMETER must be returned when callback parameter is NULL");
+			BT_ERROR_INVALID_PARAMETER,
+			"BT_ERROR_INVALID_PARAMETER must be returned when callback parameter is NULL");
 }
 
 /**
@@ -183,15 +191,12 @@ static void utc_network_bluetooth_device_unset_bonded_cb_n(void)
 {
 	int ret = BT_ERROR_NONE;
 
-	if (bt_deinitialize() != BT_ERROR_NONE) {
-		dts_fail("bt_device_unset_bond_created_cb",
-			 "bt_deinitialize() failed.");
-	}
+	ret = bt_deinitialize();
 
 	ret = bt_device_unset_bond_created_cb();
 	dts_check_eq("bt_device_unset_bond_created_cb", ret,
-		     BT_ERROR_NOT_INITIALIZED,
-		     "BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized.");
+			BT_ERROR_NOT_INITIALIZED,
+			"BT_ERROR_NOT_INITIALIZED must be returned when BT is not initialized.");
 }
 
 	/**
@@ -203,8 +208,8 @@ static void utc_network_bluetooth_device_unset_unbonded_cb_n(void)
 
 	ret = bt_device_unset_bond_destroyed_cb();
 	dts_check_eq("bt_device_unset_bond_destroyed_cb", ret,
-		     BT_ERROR_NOT_INITIALIZED,
-		     "BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized.");
+			BT_ERROR_NOT_INITIALIZED,
+			"BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized.");
 }
 
 /**
@@ -217,8 +222,8 @@ utc_network_bluetooth_device_unset_authorization_state_changed_cb_n(void)
 
 	ret = bt_device_unset_authorization_changed_cb();
 	dts_check_eq("bt_device_unset_authorization_changed_cb", ret,
-		     BT_ERROR_NOT_INITIALIZED,
-		     "BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized.");
+			BT_ERROR_NOT_INITIALIZED,
+			"BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized.");
 }
 
 	/**
@@ -230,7 +235,7 @@ static void utc_network_bluetooth_device_bond_n(void)
 
 	ret = bt_device_create_bond(NULL);
 	dts_check_eq("bt_device_create_bond", ret, BT_ERROR_INVALID_PARAMETER,
-		     "BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized.");
+		"BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized.");
 }
 
 	/**
@@ -242,7 +247,7 @@ static void utc_network_bluetooth_device_cancel_bonding_n(void)
 
 	ret = bt_device_cancel_bonding();
 	dts_check_eq("bt_device_cancel_bonding", ret, BT_ERROR_NOT_ENABLED,
-		     "BT_ERROR_NOT_ENABLED must be returned when BT is not enabled");
+		"BT_ERROR_NOT_ENABLED must be returned when BT is not enabled");
 }
 
 /**
@@ -254,7 +259,7 @@ static void utc_network_bluetooth_device_unbond_n(void)
 
 	ret = bt_device_destroy_bond(NULL);
 	dts_check_eq("bt_device_destroy_bond", ret, BT_ERROR_INVALID_PARAMETER,
-		     "BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL");
+		"BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL");
 }
 
 /**
@@ -265,9 +270,8 @@ static void utc_network_bluetooth_device_foreach_bonded_device_n(void)
 	int ret = BT_ERROR_NONE;
 
 	ret = bt_adapter_foreach_bonded_device(NULL, NULL);
-	dts_check_eq("bt_adapter_foreach_bonded_device", ret,
-		     BT_ERROR_INVALID_PARAMETER,
-		     "BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL");
+	dts_check_eq("bt_adapter_foreach_bonded_device", ret, BT_ERROR_INVALID_PARAMETER,
+		"BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL");
 }
 
 /**
@@ -279,7 +283,7 @@ static void utc_network_bluetooth_device_set_alias_n(void)
 
 	ret = bt_device_set_alias(NULL, "dts_alias");
 	dts_check_eq("bt_device_set_alias", ret, BT_ERROR_INVALID_PARAMETER,
-		     "BT_ERROR_INVALID_PARAMETER must be returned when address parameter is NULL");
+		"BT_ERROR_INVALID_PARAMETER must be returned when address parameter is NULL");
 }
 
 /**
@@ -291,6 +295,6 @@ static void utc_network_bluetooth_device_set_authorization_n(void)
 
 	ret = bt_device_set_authorization(NULL, BT_DEVICE_AUTHORIZED);
 	dts_check_eq("bt_device_set_authorization", ret,
-		     BT_ERROR_INVALID_PARAMETER,
-		     "BT_ERROR_INVALID_PARAMETER must be returned when address parameter is NULL");
+		BT_ERROR_INVALID_PARAMETER,
+		"BT_ERROR_INVALID_PARAMETER must be returned when address parameter is NULL");
 }
diff --git a/mobile/TC/testcase/utc_network_bluetooth_device_positive.c b/TC/testcase/utc_network_bluetooth_device_positive.c
index 0a43e2d..1ee789e 100644..100755
--- a/mobile/TC/testcase/utc_network_bluetooth_device_positive.c
+++ b/TC/testcase/utc_network_bluetooth_device_positive.c
@@ -20,6 +20,8 @@
 #include <stdbool.h>
 #include <glib.h>
 
+#define CONFIG_FILE_PATH "/opt/home/capi-network-bluetooth/tetware.conf"
+
 enum {
 	POSITIVE_TC_IDX = 0x01,
 	NEGATIVE_TC_IDX,
@@ -31,7 +33,7 @@ static void cleanup(void);
 static GMainLoop *mainloop;
 static bool callback_result = false;
 char target_name[128] = "dts_test";
-char target_address[18] = "";
+char *target_address;
 bt_device_info_s *device_info = NULL;
 bool discovery_result = false;
 
@@ -50,45 +52,101 @@ static void utc_network_bluetooth_device_unbond_p(void);
 static void utc_network_bluetooth_device_unset_bonded_cb_p(void);
 static void utc_network_bluetooth_device_unset_unbonded_cb_p(void);
 static void utc_network_bluetooth_device_unset_authorization_state_changed_cb_p(void);
+static void utc_network_bluetooth_device_get_rssi_strength_p(void);
+static void utc_network_bluetooth_device_disable_rssi_monitor_p(void);
+static void utc_network_bluetooth_device_enable_rssi_monitor_p(void);
+static void utc_network_bluetooth_device_unset_rssi_alert_cb_p(void);
 
 gboolean timeout_func(gpointer data);
 void adapter_state_changed_cb_for_device_p(int result,
-					   bt_adapter_state_e adapter_state,
-					   void *user_data);
+							bt_adapter_state_e adapter_state,
+							void *user_data);
 void device_discovery_state_changed_cb_for_device_p(int result,
-						    bt_adapter_device_discovery_state_e discovery_state,
-						    bt_adapter_device_discovery_info_s *discovery_info,
-						    void *user_data);
+						bt_adapter_device_discovery_state_e discovery_state,
+						bt_adapter_device_discovery_info_s *discovery_info,
+						void *user_data);
 void device_bonded_cb(int result, bt_device_info_s *device_info,
-		      void *user_data);
+						void *user_data);
 void device_unbonded_cb(int result, char *remote_address, void *user_data);
-void device_authorization_state_changed_cb(bt_device_authorization_e authorization_state,
-					   char *remote_address,
-					   void *user_data);
+void device_authorization_state_changed_cb(bt_device_authorization_e authorization_state, \
+		char *remote_address, void *user_data);
 bool bonded_device_cb_for_device_p(bt_device_info_s *dev_info,
-				   void *user_data);
+						void *user_data);
+void device_get_rssi_strength_cb(char *bt_address,
+						bt_device_connection_link_type_e link_type,
+						int rssi_dbm, void *user_data);
+static void device_rssi_enabled_cb(const char *address,
+						bt_device_connection_link_type_e link_type,
+						int rssi_enabled, void *user_data);
+static void device_rssi_alert_cb(char *bt_address,
+						bt_device_connection_link_type_e link_type,
+						int rssi_alert_type, int rssi_alert_dbm, void *user_data);
 
 struct tet_testlist tet_testlist[] = {
-	{utc_network_bluetooth_device_set_bonded_cb_p, POSITIVE_TC_IDX},
-	{utc_network_bluetooth_device_unset_bonded_cb_p, POSITIVE_TC_IDX},
-	{utc_network_bluetooth_device_cancel_bonding_p, POSITIVE_TC_IDX},
-	{utc_network_bluetooth_device_bond_p, POSITIVE_TC_IDX},
-	{utc_network_bluetooth_device_foreach_bonded_device_p, POSITIVE_TC_IDX},
-	{utc_network_bluetooth_device_set_alias_p, POSITIVE_TC_IDX},
-	{utc_network_bluetooth_device_set_authorization_state_changed_cb_p, POSITIVE_TC_IDX},
-	{utc_network_bluetooth_device_set_authorization_p, POSITIVE_TC_IDX},
-	{utc_network_bluetooth_device_unset_authorization_state_changed_cb_p, POSITIVE_TC_IDX},
-	{utc_network_bluetooth_device_set_unbonded_cb_p, POSITIVE_TC_IDX},
-	{utc_network_bluetooth_device_unbond_p, POSITIVE_TC_IDX},
-	{utc_network_bluetooth_device_unset_unbonded_cb_p, POSITIVE_TC_IDX},
-	{NULL, 0},
+	{ utc_network_bluetooth_device_set_bonded_cb_p, POSITIVE_TC_IDX },
+	{ utc_network_bluetooth_device_bond_p, POSITIVE_TC_IDX },
+	{ utc_network_bluetooth_device_foreach_bonded_device_p, POSITIVE_TC_IDX },
+	{ utc_network_bluetooth_device_set_alias_p, POSITIVE_TC_IDX },
+	{ utc_network_bluetooth_device_set_authorization_state_changed_cb_p, POSITIVE_TC_IDX },
+	{ utc_network_bluetooth_device_set_authorization_p, POSITIVE_TC_IDX },
+	{ utc_network_bluetooth_device_unset_bonded_cb_p, POSITIVE_TC_IDX },
+	{ utc_network_bluetooth_device_unset_authorization_state_changed_cb_p, POSITIVE_TC_IDX },
+	{ utc_network_bluetooth_device_get_rssi_strength_p, POSITIVE_TC_IDX },
+	{ utc_network_bluetooth_device_enable_rssi_monitor_p, POSITIVE_TC_IDX },
+	{ utc_network_bluetooth_device_disable_rssi_monitor_p, POSITIVE_TC_IDX },
+	{ utc_network_bluetooth_device_unset_rssi_alert_cb_p, POSITIVE_TC_IDX },
+	{ utc_network_bluetooth_device_set_unbonded_cb_p, POSITIVE_TC_IDX },
+	{ utc_network_bluetooth_device_cancel_bonding_p, POSITIVE_TC_IDX },
+	{ utc_network_bluetooth_device_unbond_p, POSITIVE_TC_IDX },
+	{ utc_network_bluetooth_device_unset_unbonded_cb_p, POSITIVE_TC_IDX },
+	{ NULL, 0 },
 };
 
+int get_value_from_file(void)
+{
+	FILE *fp;
+	char *token;
+	char buf[100];
+
+	fp = fopen(CONFIG_FILE_PATH, "r");
+	if (fp == NULL) {
+		tet_printf("Default configuration is used\n");
+		return -1;
+	}
+	while (fgets(buf, sizeof(buf), fp)) {
+		if (buf[0] == '#' || buf[0] == '\n')
+			continue;
+
+		token = strrchr(buf, '\n');
+		if (token == NULL) {
+			tet_printf("g_conf is too long\n");
+			break;
+		}
+		*token = '\0';
+
+		token = strtok(buf, "=");
+		if (token == NULL) {
+				continue;
+		}
+		if (strcasecmp(token, "BT_ADDR_MOBILE") == 0) {
+			token = strtok(NULL, "=");
+			target_address = strdup(token);
+			fclose(fp);
+			return 0;
+		}
+	}
+	return -1;
+}
+
 static void startup(void)
 {
 	bt_error_e ret = BT_ERROR_NONE;
 	int timeout_id = 0;
 
+	if(get_value_from_file() == -1) {
+		tet_printf("Failed to read.");
+	}
+
 	/* start of TC */
 	callback_result = false;
 	discovery_result = false;
@@ -139,8 +197,8 @@ static void startup(void)
 	}
 
 	if (bt_adapter_unset_device_discovery_state_changed_cb() !=
-	    BT_ERROR_NONE) {
-		tet_printf("bt_adapter_unset_device_discovery_state_changed_cb() failed.");
+				BT_ERROR_NONE) {
+				tet_printf("bt_adapter_unset_device_discovery_state_changed_cb() failed.");
 	}
 
 	tet_printf("TC start.");
@@ -164,8 +222,8 @@ gboolean timeout_func(gpointer data)
 }
 
 void adapter_state_changed_cb_for_device_p(int result,
-					   bt_adapter_state_e adapter_state,
-					   void *user_data)
+						bt_adapter_state_e adapter_state,
+						void *user_data)
 {
 	tet_printf("Callback: bt_adapter_state_changed_cb() was called");
 	if (user_data != NULL && !strcmp((char *)user_data, "startup")) {
@@ -182,9 +240,9 @@ void adapter_state_changed_cb_for_device_p(int result,
 }
 
 void device_discovery_state_changed_cb_for_device_p(int result,
-						    bt_adapter_device_discovery_state_e discovery_state,
-						    bt_adapter_device_discovery_info_s *discovery_info,
-						    void *user_data)
+						bt_adapter_device_discovery_state_e discovery_state,
+						bt_adapter_device_discovery_info_s *discovery_info,
+						void *user_data)
 {
 	tet_printf("Callback: bt_adapter_device_discovery_state_changed_cb() was called");
 	if (user_data != NULL && !strcmp((char *)user_data, "startup")) {
@@ -209,7 +267,7 @@ void device_discovery_state_changed_cb_for_device_p(int result,
 }
 
 void device_bonded_cb(int result, bt_device_info_s * device_info,
-		      void *user_data)
+				void *user_data)
 {
 	int i = 0;
 
@@ -230,7 +288,7 @@ void device_bonded_cb(int result, bt_device_info_s * device_info,
 		tet_printf("result is BT_ERROR_NONE");
 	else
 		tet_printf("result is unknown: %s",
-			   _bt_convert_error_to_string(result));
+				_bt_convert_error_to_string(result));
 
 	/* in case of bt_device_cancel_bonding() */
 	if (user_data != NULL && !strcmp((char *)user_data, "cancel")) {
@@ -285,17 +343,18 @@ void device_unbonded_cb(int result, char *remote_address, void *user_data)
 	tet_printf("Callback: address of unbonded device");
 	if (remote_address != NULL) {
 		tet_printf("device address: %s", remote_address);
-		if (!strcmp(remote_address, target_address)) {
-			if (result == BT_ERROR_NONE) {
-				tet_printf("Callback: Unbonding succeeded");
-				callback_result = true;
-			} else {
-				tet_printf("Callback: Unbonding failed");
-			}
-		}
 	} else
 		tet_printf("Callback: address of unbonded device is NULL!");
 
+	if ((remote_address != NULL) && \
+			!strcmp(remote_address, target_address)) {
+		if (result == BT_ERROR_NONE) {
+			tet_printf("Callback: Unbonding succeeded");
+			callback_result = true;
+		} else {
+			tet_printf("Callback: Unbonding failed");
+		}
+	}
 
 	if (mainloop) {
 		g_main_loop_quit(mainloop);
@@ -303,9 +362,8 @@ void device_unbonded_cb(int result, char *remote_address, void *user_data)
 
 }
 
-void device_authorization_state_changed_cb(bt_device_authorization_e
-					   authorization_state, char *address,
-					   void *user_data)
+void device_authorization_state_changed_cb(bt_device_authorization_e authorization_state, \
+		char *address, void *user_data)
 {
 	if (authorization_state == BT_DEVICE_AUTHORIZED) {
 		if (address != NULL && !strcmp(address, target_address)) {
@@ -324,6 +382,32 @@ void device_authorization_state_changed_cb(bt_device_authorization_e
 	}
 }
 
+void device_get_rssi_strength_cb(char *bt_address,
+						bt_device_connection_link_type_e link_type,
+						int rssi_dbm, void *user_data)
+{
+	tet_printf("Callback:Rssi_strength_cb is called.");
+	tet_printf("RSSI Strength: [Address %s][Link Type %d][RSSI dBm %d]",
+			bt_address, link_type, rssi_dbm);
+}
+
+static void device_rssi_enabled_cb(const char *address,
+		bt_device_connection_link_type_e link_type,
+		int rssi_enabled, void *user_data)
+{
+	tet_printf("Callback:Rssi_enabled_cb is called.");
+	tet_printf("RSSI Enabled: %s %d %d", address, link_type, rssi_enabled);
+}
+
+static void device_rssi_alert_cb(char *bt_address,
+		bt_device_connection_link_type_e link_type,
+		int rssi_alert_type, int rssi_alert_dbm, void *user_data)
+{
+	tet_printf("Callback:rssi_alert_cb is called.");
+	tet_printf("RSSI Alert: [Address:%s LinkType:%d][RSSI Alert Type:%d dBm:%d]",
+			bt_address, link_type, rssi_alert_type, rssi_alert_dbm);
+}
+
 /**
  * @brief Positive test case of bt_device_set_bond_created_cb()
  */
@@ -334,7 +418,7 @@ static void utc_network_bluetooth_device_set_bonded_cb_p(void)
 	/*  Normal operation test */
 	ret = bt_device_set_bond_created_cb(device_bonded_cb, "cancel");
 	dts_check_eq("bt_device_set_bond_created_cb", ret, BT_ERROR_NONE,
-		     "bt_device_set_bond_created_cb() failed");
+			"bt_device_set_bond_created_cb() failed");
 }
 
 /**
@@ -347,7 +431,7 @@ static void utc_network_bluetooth_device_set_unbonded_cb_p(void)
 	/*  Normal operation test */
 	ret = bt_device_set_bond_destroyed_cb(device_unbonded_cb, NULL);
 	dts_check_eq("bt_device_set_bond_destroyed_cb", ret, BT_ERROR_NONE,
-		     "bt_device_set_bond_destroyed_cb() failed");
+		"bt_device_set_bond_destroyed_cb() failed");
 }
 
 /**
@@ -361,8 +445,8 @@ utc_network_bluetooth_device_set_authorization_state_changed_cb_p(void)
 	/*  Normal operation test */
 	ret = bt_device_set_authorization_changed_cb(device_authorization_state_changed_cb, NULL);
 	dts_check_eq("bt_device_set_authorization_changed_cb", ret,
-		     BT_ERROR_NONE,
-		     "bt_device_set_authorization_changed_cb() failed");
+				BT_ERROR_NONE,
+				"bt_device_set_authorization_changed_cb() failed");
 }
 
 /**
@@ -375,16 +459,16 @@ static void utc_network_bluetooth_device_cancel_bonding_p(void)
 	int timeout_id = 0;
 
 	if (bt_device_set_bond_created_cb(device_bonded_cb, "cancel") !=
-	    BT_ERROR_NONE) {
-		dts_fail("bt_device_cancel_bonding",
-			 "bt_device_set_bond_created_cb() failed");
+			BT_ERROR_NONE) {
+			dts_fail("bt_device_cancel_bonding",
+			"bt_device_set_bond_created_cb() failed");
 	}
 
 	/* bond device */
 	ret = bt_device_create_bond(target_address);
 	if (ret != BT_ERROR_NONE) {
 		dts_fail("bt_device_cancel_bonding",
-			 "bt_device_create_bond failed");
+			"bt_device_create_bond failed");
 	}
 	tet_printf("bt_device_create_bond() was called");
 
@@ -397,11 +481,11 @@ static void utc_network_bluetooth_device_cancel_bonding_p(void)
 		g_source_remove(timeout_id);
 		bt_device_unset_bond_created_cb();
 		dts_check_eq("bt_device_cancel_bonding", callback_result, true,
-			     "Failed");
+				"Failed");
 	} else {
 		bt_device_unset_bond_created_cb();
 		dts_fail("bt_device_cancel_bonding",
-			 "bt_device_cancel_bonding() failed");
+			"bt_device_cancel_bonding() failed");
 	}
 }
 
@@ -415,7 +499,7 @@ static void utc_network_bluetooth_device_unset_bonded_cb_p(void)
 	/*  Normal operation test */
 	ret = bt_device_unset_bond_created_cb();
 	dts_check_eq("bt_device_unset_bond_created_cb", ret, BT_ERROR_NONE,
-		     "bt_device_unset_bond_created_cb() failed");
+				"bt_device_unset_bond_created_cb() failed");
 }
 
 /**
@@ -431,8 +515,7 @@ static void utc_network_bluetooth_device_bond_p(void)
 	/* bond device */
 	ret = bt_device_set_bond_created_cb(device_bonded_cb, "bond");
 	if (ret != BT_ERROR_NONE) {
-		dts_fail("bt_device_create_bond",
-			 "bt_device_set_bond_created_cb() failed");
+		tet_printf("bt_device_set_bond_created_cb was called");
 	}
 
 	ret = bt_device_create_bond(target_address);
@@ -442,21 +525,22 @@ static void utc_network_bluetooth_device_bond_p(void)
 		g_main_loop_run(mainloop);
 		g_source_remove(timeout_id);
 		bt_device_unset_bond_created_cb();
-		dts_check_eq("bt_device_create_bond", callback_result, true,
-			     "Failed");
+		dts_check_eq("bt_device_create_bond", ret, BT_ERROR_NONE,
+								"bt_device_create_bond() failed.");
 	} else {
 		bt_device_unset_bond_created_cb();
 		dts_fail("bt_device_create_bond",
-			 "bt_device_create_bond() failed");
+			"bt_device_create_bond() failed");
 	}
 }
 
-bool bonded_device_cb_for_device_p(bt_device_info_s * dev_info, void *user_data)
+
+bool bonded_device_cb_for_device_p(bt_device_info_s *dev_info, void *user_data)
 {
 	int i = 0;
 	device_info = (bt_device_info_s *) malloc(sizeof(bt_device_info_s));
 	if (device_info == NULL) {
-		tet_printf("Callback: Memory allocation failed");;
+		tet_printf("Callback: Memory allocation failed");
 	} else if (dev_info != NULL) {
 		device_info->remote_address = strdup(dev_info->remote_address);
 		tet_printf("device address : %s", device_info->remote_address);
@@ -508,10 +592,10 @@ static void utc_network_bluetooth_device_foreach_bonded_device_p(void)
 	ret = bt_adapter_foreach_bonded_device(bonded_device_cb_for_device_p, NULL);
 	if (ret == BT_ERROR_NONE) {
 		dts_pass("bt_adapter_foreach_bonded_device",
-			 "bt_adapter_foreach_bonded_device pass");
+			"bt_adapter_foreach_bonded_device pass");
 	} else {
 		dts_fail("bt_adapter_foreach_bonded_device",
-			 "bt_adapter_foreach_bonded_device() failed");
+			"bt_adapter_foreach_bonded_device() failed");
 	}
 }
 
@@ -530,7 +614,7 @@ static void utc_network_bluetooth_device_set_alias_p(void)
 
 	ret = bt_device_set_alias(device_info->remote_address, "dts_alias");
 	dts_check_eq("bt_device_set_alias", ret, BT_ERROR_NONE,
-		     "bt_device_set_alias() failed");
+			"bt_device_set_alias() failed");
 }
 
 /**
@@ -549,12 +633,12 @@ static void utc_network_bluetooth_device_set_authorization_p(void)
 		timeout_id = g_timeout_add(60000, timeout_func, mainloop);
 		g_main_loop_run(mainloop);
 		g_source_remove(timeout_id);
-		dts_check_eq("bt_device_set_authorization", callback_result,
-			     true, "Callback was called but failed");
+		dts_check_eq("bt_device_set_authorization", ret, BT_ERROR_NONE,
+												"bt_device_set_authorization() failed.");
 		callback_result = false;
 	} else {
 		dts_fail("bt_device_set_authorization",
-			 "bt_device_set_authorization() failed");
+			"bt_device_set_authorization() failed");
 	}
 }
 
@@ -574,11 +658,11 @@ static void utc_network_bluetooth_device_unbond_p(void)
 		timeout_id = g_timeout_add(60000, timeout_func, mainloop);
 		g_main_loop_run(mainloop);
 		g_source_remove(timeout_id);
-		dts_check_eq("bt_device_destroy_bond", callback_result, true,
-			     "Failed");
+		dts_check_eq("bt_device_destroy_bond", ret, BT_ERROR_NONE,
+										"bt_device_destroy_bond() failed.");
 	} else {
 		dts_fail("bt_device_destroy_bond",
-			 "bt_device_destroy_bond() failed");
+			"bt_device_destroy_bond() failed");
 	}
 }
 
@@ -605,6 +689,6 @@ static void utc_network_bluetooth_device_unset_authorization_state_changed_cb_p(
 	/*  Normal operation test */
 	ret = bt_device_unset_authorization_changed_cb();
 	dts_check_eq("bt_device_unset_authorization_changed_cb", ret,
-		     BT_ERROR_NONE,
-		     "bt_device_unset_authorization_changed_cb() failed");
+				BT_ERROR_NONE,
+				"bt_device_unset_authorization_changed_cb() failed");
 }
diff --git a/mobile/TC/testcase/utc_network_bluetooth_gatt_negative.c b/TC/testcase/utc_network_bluetooth_gatt_negative.c
index c58bdcf..e15467d 100644..100755
--- a/mobile/TC/testcase/utc_network_bluetooth_gatt_negative.c
+++ b/TC/testcase/utc_network_bluetooth_gatt_negative.c
@@ -34,8 +34,13 @@ static void utc_network_bluetooth_gatt_get_characteristic_declaration_n(void);
 static void utc_network_bluetooth_gatt_set_characteristic_value_n(void);
 static void utc_network_bluetooth_gatt_clone_attribute_handle_n(void);
 static void utc_network_bluetooth_gatt_destroy_attribute_handle_n(void);
+static void utc_network_bluetooth_gatt_connect_n(void);
+static void utc_network_bluetooth_gatt_disconnect_n(void);
+static void utc_network_bluetooth_set_gatt_connection_state_changed_cb_n(void);
+static void utc_network_bluetooth_unset_gatt_connection_state_changed_cb_n(void);
 
-void adapter_state_changed_cb_for_gatt_n(int result, bt_adapter_state_e adapter_state, void *user_data);
+void adapter_state_changed_cb_for_gatt_n(int result,
+				bt_adapter_state_e adapter_state, void *user_data);
 gboolean timeout_func(gpointer data);
 
 struct tet_testlist tet_testlist[] = {
@@ -44,11 +49,15 @@ struct tet_testlist tet_testlist[] = {
 	{utc_network_bluetooth_gatt_get_service_uuid_n, NEGATIVE_TC_IDX},
 	{utc_network_bluetooth_gatt_foreach_included_services_n, NEGATIVE_TC_IDX},
 	{utc_network_bluetooth_gatt_set_characteristic_changed_cb_n, NEGATIVE_TC_IDX},
-	{utc_network_bluetooth_gatt_unset_characteristic_changed_cb_n, NEGATIVE_TC_IDX},
+	{utc_network_bluetooth_set_gatt_connection_state_changed_cb_n, NEGATIVE_TC_IDX},
+	{utc_network_bluetooth_gatt_connect_n, NEGATIVE_TC_IDX},
+	{utc_network_bluetooth_gatt_disconnect_n, NEGATIVE_TC_IDX},
 	{utc_network_bluetooth_gatt_get_characteristic_declaration_n, NEGATIVE_TC_IDX},
 	{utc_network_bluetooth_gatt_set_characteristic_value_n, NEGATIVE_TC_IDX},
 	{utc_network_bluetooth_gatt_clone_attribute_handle_n, NEGATIVE_TC_IDX},
 	{utc_network_bluetooth_gatt_destroy_attribute_handle_n, NEGATIVE_TC_IDX},
+	{utc_network_bluetooth_unset_gatt_connection_state_changed_cb_n, NEGATIVE_TC_IDX},
+	{utc_network_bluetooth_gatt_unset_characteristic_changed_cb_n, NEGATIVE_TC_IDX},
 	{NULL, 0},
 };
 
@@ -102,7 +111,8 @@ gboolean timeout_func(gpointer data)
 /**
  * @brief Callback funtions
  */
-void adapter_state_changed_cb_for_gatt_n(int result, bt_adapter_state_e adapter_state, void *user_data)
+void adapter_state_changed_cb_for_gatt_n(int result,
+					bt_adapter_state_e adapter_state, void *user_data)
 {
 	tet_printf("Callback: bt_adapter_state_changed_cb was called.");
 	if ((user_data != NULL) && !strcmp((char *)user_data, "startup")) {
@@ -118,6 +128,7 @@ void adapter_state_changed_cb_for_gatt_n(int result, bt_adapter_state_e adapter_
 	}
 }
 
+
 /**
  * @brief Negative test case of bt_gatt_foreach_primary_services()
  */
@@ -126,8 +137,9 @@ static void utc_network_bluetooth_gatt_foreach_primary_services_n(void)
 	int ret = BT_ERROR_NONE;
 
 	ret = bt_gatt_foreach_primary_services(NULL, NULL, NULL);
-	dts_check_eq("bt_gatt_foreach_primary_services", ret, BT_ERROR_INVALID_PARAMETER,
-		     "BT_ERROR_INVALID_PARAMETER must be returned when remote address and callback parameters are NULL.");
+	dts_check_eq("bt_gatt_foreach_primary_services", ret,
+			BT_ERROR_INVALID_PARAMETER,
+			"BT_ERROR_INVALID_PARAMETER must be returned when remote address and callback parameters are NULL.");
 }
 
 /**
@@ -138,8 +150,9 @@ static void utc_network_bluetooth_gatt_discover_characteristics_n(void)
 	int ret = BT_ERROR_NONE;
 
 	ret = bt_gatt_discover_characteristics(NULL, NULL, NULL);
-	dts_check_eq("bt_gatt_discover_characteristics", ret, BT_ERROR_INVALID_PARAMETER,
-		     "BT_ERROR_INVALID_PARAMETER must be returned when service and callback parameters are NULL.");
+	dts_check_eq("bt_gatt_discover_characteristics", ret,
+		BT_ERROR_INVALID_PARAMETER,
+		"BT_ERROR_INVALID_PARAMETER must be returned when service and callback parameters are NULL.");
 }
 
 /**
@@ -150,7 +163,7 @@ static void utc_network_bluetooth_gatt_get_service_uuid_n(void)
 	int ret = BT_ERROR_NONE;
 	ret = bt_gatt_get_service_uuid(NULL, NULL);
 	dts_check_eq("bt_gatt_get_service_uuid", ret, BT_ERROR_INVALID_PARAMETER,
-		     "BT_ERROR_INVALID_PARAMETER must be returned when service parameter is NULL.");
+		"BT_ERROR_INVALID_PARAMETER must be returned when service parameter is NULL.");
 }
 
 /**
@@ -161,8 +174,9 @@ static void utc_network_bluetooth_gatt_foreach_included_services_n(void)
 	int ret = BT_ERROR_NONE;
 
 	ret = bt_gatt_foreach_included_services(NULL, NULL, NULL);
-	dts_check_eq("bt_socket_unset_connection_state_changed_cb", ret, BT_ERROR_INVALID_PARAMETER,
-		     "BT_ERROR_INVALID_PARAMETER must be returned when service and callback parameters are NULL.");
+	dts_check_eq("bt_socket_unset_connection_state_changed_cb", ret,
+			BT_ERROR_INVALID_PARAMETER,
+			"BT_ERROR_INVALID_PARAMETER must be returned when service and callback parameters are NULL.");
 }
 
 /**
@@ -172,9 +186,10 @@ static void utc_network_bluetooth_gatt_set_characteristic_changed_cb_n(void)
 {
 	int ret = BT_ERROR_NONE;
 
-	ret = bt_gatt_set_characteristic_changed_cb(NULL, NULL, NULL);
-	dts_check_eq("bt_gatt_set_characteristic_changed_cb", ret, BT_ERROR_INVALID_PARAMETER,
-		     "BT_ERROR_INVALID_PARAMETER must be returned when service and callback parameters are NULL.");
+	ret = bt_gatt_set_characteristic_changed_cb(NULL, NULL);
+	dts_check_eq("bt_gatt_set_characteristic_changed_cb", ret,
+			BT_ERROR_INVALID_PARAMETER,
+			"BT_ERROR_INVALID_PARAMETER must be returned when service and callback parameters are NULL.");
 }
 
 /**
@@ -184,11 +199,13 @@ static void utc_network_bluetooth_gatt_unset_characteristic_changed_cb_n(void)
 {
 	int ret = BT_ERROR_NONE;
 
-	ret = bt_gatt_unset_characteristic_changed_cb(NULL);
-	dts_check_eq("bt_gatt_unset_characteristic_changed_cb", ret, BT_ERROR_INVALID_PARAMETER,
-		     "BT_ERROR_INVALID_PARAMETER must be returned when service parameter is NULL.");
+	ret = bt_gatt_unset_characteristic_changed_cb();
+	dts_check_eq("bt_gatt_unset_characteristic_changed_cb", ret,
+			BT_ERROR_NOT_INITIALIZED,
+			"BT_ERROR_NOT_INITIALIZED must be returned when BT is not initialized.");
 }
 
+
 /**
  * @brief Negative test case of bt_gatt_get_characteristic_declaration()
  */
@@ -197,8 +214,9 @@ static void utc_network_bluetooth_gatt_get_characteristic_declaration_n(void)
 	int ret = BT_ERROR_NONE;
 
 	ret = bt_gatt_get_characteristic_declaration(NULL, NULL, NULL, 0);
-	dts_check_eq("bt_gatt_get_characteristic_declaration", ret, BT_ERROR_INVALID_PARAMETER,
-		     "BT_ERROR_INVALID_PARAMETER must be returned when characteristic parameter is NULL.");
+	dts_check_eq("bt_gatt_get_characteristic_declaration", ret,
+			BT_ERROR_INVALID_PARAMETER,
+			"BT_ERROR_INVALID_PARAMETER must be returned when characteristic parameter is NULL.");
 }
 
 /**
@@ -210,7 +228,7 @@ static void utc_network_bluetooth_gatt_set_characteristic_value_n(void)
 
 	ret = bt_gatt_set_characteristic_value(NULL, NULL, -1);
 	dts_check_eq("bt_socket_connect_rfcomm", ret, BT_ERROR_INVALID_PARAMETER,
-		     "BT_ERROR_INVALID_PARAMETER must be returned when characteristic and value parameters are NULL.");
+			"BT_ERROR_INVALID_PARAMETER must be returned when characteristic and value parameters are NULL.");
 }
 
 /**
@@ -221,8 +239,9 @@ static void utc_network_bluetooth_gatt_clone_attribute_handle_n(void)
 	int ret = BT_ERROR_NONE;
 
 	ret = bt_gatt_clone_attribute_handle(NULL, NULL);
-	dts_check_eq("bt_gatt_clone_attribute_handle", ret, BT_ERROR_INVALID_PARAMETER,
-		     "BT_ERROR_INVALID_PARAMETER must be returned when origin parameter is NULL.");
+	dts_check_eq("bt_gatt_clone_attribute_handle", ret,
+			BT_ERROR_INVALID_PARAMETER,
+			"BT_ERROR_INVALID_PARAMETER must be returned when origin parameter is NULL.");
 }
 
 /**
@@ -233,6 +252,47 @@ static void utc_network_bluetooth_gatt_destroy_attribute_handle_n(void)
 	int ret = BT_ERROR_NONE;
 
 	ret = bt_gatt_destroy_attribute_handle(NULL);
-	dts_check_eq("bt_gatt_destroy_attribute_handle", ret, BT_ERROR_INVALID_PARAMETER,
-		     "BT_ERROR_INVALID_PARAMETER must be returned when handle parameter is NULL.");
+	dts_check_eq("bt_gatt_destroy_attribute_handle", ret,
+			BT_ERROR_INVALID_PARAMETER,
+			"BT_ERROR_INVALID_PARAMETER must be returned when handle parameter is NULL.");
+}
+
+static void utc_network_bluetooth_gatt_connect_n(void)
+{
+	int ret = BT_ERROR_NONE;
+	ret = bt_gatt_connect(NULL, false);
+	dts_check_eq("bt_gatt_connect", ret,
+			BT_ERROR_INVALID_PARAMETER,
+			"BT_ERROR_INVALID_PARAMETER must be returned when address is NULL.");
+
+}
+
+static void utc_network_bluetooth_gatt_disconnect_n(void)
+{
+	int ret = BT_ERROR_NONE;
+	ret = bt_gatt_disconnect(NULL);
+	dts_check_eq("bt_gatt_connect", ret,
+			BT_ERROR_INVALID_PARAMETER,
+			"BT_ERROR_INVALID_PARAMETER must be returned when address is NULL.");
+
+}
+
+static void utc_network_bluetooth_set_gatt_connection_state_changed_cb_n(void)
+{
+	int ret = BT_ERROR_NONE;
+
+	ret = bt_gatt_set_connection_state_changed_cb(NULL, NULL);
+	dts_check_eq("bt_gatt_set_connection_state_changed_cb", ret,
+			BT_ERROR_INVALID_PARAMETER,
+			"BT_ERROR_INVALID_PARAMETER must be returned when address is NULL.");
+}
+
+static void utc_network_bluetooth_unset_gatt_connection_state_changed_cb_n(void)
+{
+	int ret = BT_ERROR_NONE;
+	ret = bt_deinitialize();
+	ret = bt_gatt_unset_connection_state_changed_cb();
+	dts_check_eq("bt_gatt_unset_connection_state_changed_cb", ret,
+		BT_ERROR_NOT_INITIALIZED,
+		"BT_ERROR_NOT_INITIALIZED must be returned when BT is not initialized.");
 }
diff --git a/mobile/TC/testcase/utc_network_bluetooth_gatt_positive.c b/TC/testcase/utc_network_bluetooth_gatt_positive.c
index 5df118c..b45ecca 100644..100755
--- a/mobile/TC/testcase/utc_network_bluetooth_gatt_positive.c
+++ b/TC/testcase/utc_network_bluetooth_gatt_positive.c
@@ -10,6 +10,9 @@
 #include <stdlib.h>
 #include <stdbool.h>
 #include <glib.h>
+
+#define CONFIG_FILE_PATH "/opt/home/capi-network-bluetooth/tetware.conf"
+
 enum {
 	POSITIVE_TC_IDX = 0x01,
 	NEGATIVE_TC_IDX,
@@ -21,9 +24,7 @@ static void cleanup(void);
 void (*tet_startup) (void) = startup;
 void (*tet_cleanup) (void) = cleanup;
 
-const char target_name[128] = "dts_test";
-char target_address[18] = "";
-
+char *remote_address;
 static GMainLoop *mainloop;
 
 static void utc_network_bluetooth_gatt_foreach_primary_services_p(void);
@@ -37,16 +38,25 @@ static void utc_network_bluetooth_gatt_get_characteristic_declaration_p(void);
 static void utc_network_bluetooth_gatt_set_characteristic_value_p(void);
 static void utc_network_bluetooth_gatt_clone_attribute_handle_p(void);
 static void utc_network_bluetooth_gatt_destroy_attribute_handle_p(void);
+static void utc_network_bluetooth_gatt_connect_p(void);
+static void utc_network_bluetooth_gatt_disconnect_p(void);
+static void utc_network_bluetooth_set_gatt_connection_state_changed_cb_p(void);
+static void utc_network_bluetooth_unset_gatt_connection_state_changed_cb_p(void);
 
 gboolean timeout_func(gpointer data);
-void adapter_state_changed_cb_for_gatt_p(int result, bt_adapter_state_e adapter_state, void *user_data);
+void adapter_state_changed_cb_for_gatt_p(int result, bt_adapter_state_e adapter_state,
+					void *user_data);
+void adapter_le_state_changed_cb_for_gatt_p(int result, bt_adapter_le_state_e adapter_state,
+					void *user_data);
 
 bool primary_service_cb_for_gatt_p(bt_gatt_attribute_h service, void *user_data);
 bool included_service_cb_for_gatt_p(bt_gatt_attribute_h service, void *user_data);
 bool characteristics_discovered_cb_for_gatt_p(int result, int index, int total, bt_gatt_attribute_h characteristic,
-					      void *user_data);
+					void *user_data);
 void characteristics_changed_cb_for_gatt_p(bt_gatt_attribute_h characteristic, unsigned char *value, int value_length,
-					   void *user_data);
+					void *user_data);
+void gatt_connection_state_changed_cb(int result, bool connected,
+					const char *remote_address, void *user_data);
 
 struct tet_testlist tet_testlist[] = {
 	{utc_network_bluetooth_gatt_foreach_primary_services_p, POSITIVE_TC_IDX},
@@ -54,6 +64,10 @@ struct tet_testlist tet_testlist[] = {
 	{utc_network_bluetooth_gatt_get_service_uuid_p, POSITIVE_TC_IDX},
 	{utc_network_bluetooth_gatt_foreach_included_services_p, POSITIVE_TC_IDX},
 	{utc_network_bluetooth_gatt_set_characteristic_changed_cb_p, POSITIVE_TC_IDX},
+	{utc_network_bluetooth_set_gatt_connection_state_changed_cb_p, POSITIVE_TC_IDX},
+	{utc_network_bluetooth_gatt_connect_p, POSITIVE_TC_IDX},
+	{utc_network_bluetooth_gatt_disconnect_p, POSITIVE_TC_IDX},
+	{utc_network_bluetooth_unset_gatt_connection_state_changed_cb_p, POSITIVE_TC_IDX},
 	{utc_network_bluetooth_gatt_unset_characteristic_changed_cb_p, POSITIVE_TC_IDX},
 	{utc_network_bluetooth_gatt_get_characteristic_declaration_p, POSITIVE_TC_IDX},
 	{utc_network_bluetooth_gatt_set_characteristic_value_p, POSITIVE_TC_IDX},
@@ -62,11 +76,50 @@ struct tet_testlist tet_testlist[] = {
 	{NULL, 0},
 };
 
+int get_value_from_file(void)
+{
+	FILE *fp;
+	char *token;
+	char buf[100];
+
+	fp = fopen(CONFIG_FILE_PATH, "r");
+	if (fp == NULL) {
+		tet_printf("Default configuration is used\n");
+		return -1;
+	}
+	while (fgets(buf, sizeof(buf), fp)) {
+		if (buf[0] == '#' || buf[0] == '\n')
+			continue;
+
+		token = strrchr(buf, '\n');
+		if (token == NULL) {
+			tet_printf("g_conf is too long\n");
+			break;
+		}
+		*token = '\0';
+
+		token = strtok(buf, "=");
+		if (token == NULL) {
+			continue;
+		}
+		if (strcasecmp(token, "BT_ADDR_LE") == 0) {
+			token = strtok(NULL, "=");
+			remote_address = strdup(token);
+			return 0;
+		}
+	}
+	return -1;
+}
+
 static void startup(void)
 {
 	bt_error_e ret = BT_ERROR_NONE;
 	int timeout_id = 0;
 
+	if(get_value_from_file() == -1) {
+		tet_printf("Failed to read.");
+	}
+
 	/* start of TC */
 	tet_printf("TC start.");
 	mainloop = g_main_loop_new(NULL, FALSE);
@@ -77,17 +130,31 @@ static void startup(void)
 		tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed");
 	}
 
-	tet_printf("bt_adapter_disable() was called.");
-	ret = bt_adapter_disable();
+	if (bt_adapter_le_set_state_changed_cb(adapter_le_state_changed_cb_for_gatt_p, "enable") != BT_ERROR_NONE) {
+		dts_fail("bt_adapter_le_enable",
+			"bt_adapter_le_set_state_changed_cb() failed.");
+	}
+
+	tet_printf("bt_adapter_enable() was called.");
+	ret = bt_adapter_enable();
 	if (ret == BT_ERROR_NONE) {
-		tet_printf("bt_adapter_disable() succeeded.");
-		timeout_id = g_timeout_add(60000, timeout_func, mainloop);
-		g_main_loop_run(mainloop);
-		g_source_remove(timeout_id);
+		tet_printf("bt_adapter_enable() succeeded.");
+		tet_printf("bt_adapter_le_enable() was called.");
+		ret = bt_adapter_le_enable();
+		if (ret == BT_ERROR_NONE) {
+			tet_printf("bt_adapter_le_enable() succeeded.");
+			timeout_id = g_timeout_add(60000, timeout_func, mainloop);
+			g_main_loop_run(mainloop);
+			g_source_remove(timeout_id);
+		}
+		else {
+			tet_printf("DTS may fail because bt_adapter_le_enable failed");
+			bt_adapter_le_unset_state_changed_cb();
+		}
 	} else if (ret == BT_ERROR_NOT_ENABLED) {
 		tet_printf("Bluetooth adapter is not enabled.");
 	} else {
-		tet_printf("DTS may fail because bt_adapter_disable() failed");
+		tet_printf("DTS may fail because bt_adapter_enable failed");
 	}
 
 	if (bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE) {
@@ -111,19 +178,15 @@ gboolean timeout_func(gpointer data)
 	return FALSE;
 }
 
-void adapter_state_changed_cb_for_gatt_p(int result, bt_adapter_state_e adapter_state, void *user_data)
+
+
+void adapter_state_changed_cb_for_gatt_p(int result, bt_adapter_state_e adapter_state, void* user_data)
 {
-	if (user_data != NULL && !strcmp((char *)user_data, "startup")) {
-		if (adapter_state == BT_ADAPTER_ENABLED && result == BT_ERROR_NONE) {
-			tet_printf("Callback: BT was enabled.");
-			bt_adapter_start_device_discovery();
-		} else {
-			tet_printf("Callback: BT was not enabled. DTS will be started but DTS may fail.");
-			if (mainloop) {
-				g_main_loop_quit(mainloop);
-			}
-		}
-	}
+
+}
+void adapter_le_state_changed_cb_for_gatt_p(int result, bt_adapter_le_state_e adapter_le__state, void* user_data)
+{
+
 }
 
 bool primary_service_cb_for_gatt_p(bt_gatt_attribute_h service, void *user_data)
@@ -132,7 +195,7 @@ bool primary_service_cb_for_gatt_p(bt_gatt_attribute_h service, void *user_data)
 }
 
 bool characteristics_discovered_cb_for_gatt_p(int result, int index, int total, bt_gatt_attribute_h characteristic,
-					      void *user_data)
+				void *user_data)
 {
 	return false;
 }
@@ -143,36 +206,48 @@ bool included_service_cb_for_gatt_p(bt_gatt_attribute_h service, void *user_data
 }
 
 void characteristics_changed_cb_for_gatt_p(bt_gatt_attribute_h characteristic, unsigned char *value, int value_length,
-					   void *user_data)
+				void *user_data)
 {
 
 }
 
+void gatt_connection_state_changed_cb(int result, bool connected,
+					const char *remote_address, void *user_data)
+{
+	tet_printf("bt_gatt_connection_state_changed_cb : %d", result);
+	if (connected)
+		tet_printf("LE Connected");
+	else
+		tet_printf("LE Disconnected");
+}
+
 /**
  * @brief Positive test case of bt_gatt_foreach_primary_services()
  */
 static void utc_network_bluetooth_gatt_foreach_primary_services_p(void)
 {
 	int ret = BT_ERROR_NONE;
-	char *remote_addr = "dts_addr";
 
-	ret = bt_gatt_foreach_primary_services(remote_addr, primary_service_cb_for_gatt_p, NULL);
-	dts_check_eq("bt_gatt_foreach_primary_services", ret, BT_ERROR_NONE, "bt_gatt_foreach_primary_services() failed.");
+	ret = bt_gatt_foreach_primary_services(remote_address, primary_service_cb_for_gatt_p, NULL);
+	dts_check_eq("bt_gatt_foreach_primary_services", ret, BT_ERROR_NONE,
+		"bt_gatt_foreach_primary_services() failed.");
 }
 
+
 /**
  * @brief Positive test case of bt_gatt_discover_characteristics()
  */
 static void utc_network_bluetooth_gatt_discover_characteristics_p(void)
 {
 	int ret = BT_ERROR_NONE;
-	bt_call_list_h gatt_serv;
-	gatt_serv = g_malloc0(sizeof(bt_call_list_h));
+	bt_gatt_attribute_h gatt_serv;
+	gatt_serv = g_malloc0(sizeof(bt_gatt_attribute_h));
 
 	ret = bt_gatt_discover_characteristics(gatt_serv, characteristics_discovered_cb_for_gatt_p, NULL);
 	dts_check_eq("bt_gatt_discover_characteristics", ret, BT_ERROR_NONE, "bt_gatt_discover_characteristics() failed.");
 }
 
+
 /**
  * @brief Positive test case of bt_gatt_get_service_uuid()
  */
@@ -180,11 +255,12 @@ static void utc_network_bluetooth_gatt_get_service_uuid_p(void)
 {
 	int ret = BT_ERROR_NONE;
 	char *uid = "dts_uid";
-	bt_call_list_h gatt_serv;
-	gatt_serv = g_malloc0(sizeof(bt_call_list_h));
+	bt_gatt_attribute_h gatt_serv;
+	gatt_serv = g_malloc0(sizeof(bt_gatt_attribute_h));
 
 	ret = bt_gatt_get_service_uuid(gatt_serv, &uid);
-	dts_check_eq("bt_gatt_get_service_uuid", ret, BT_ERROR_NONE, "bt_gatt_get_service_uuid() failed.");
+	dts_check_eq("bt_gatt_get_service_uuid", ret, BT_ERROR_NONE,
+		"bt_gatt_get_service_uuid() failed.");
 }
 
 /**
@@ -193,39 +269,41 @@ static void utc_network_bluetooth_gatt_get_service_uuid_p(void)
 static void utc_network_bluetooth_gatt_foreach_included_services_p(void)
 {
 	int ret = BT_ERROR_NONE;
-	bt_call_list_h gatt_serv;
-	gatt_serv = g_malloc0(sizeof(bt_call_list_h));
+	bt_gatt_attribute_h gatt_serv;
+	gatt_serv = g_malloc0(sizeof(bt_gatt_attribute_h));
 	ret = bt_gatt_foreach_included_services(gatt_serv, included_service_cb_for_gatt_p, NULL);
-	dts_check_eq("bt_gatt_foreach_included_services", ret, BT_ERROR_NONE, "bt_gatt_foreach_included_services() failed.");
+	dts_check_eq("bt_gatt_foreach_included_services", ret, BT_ERROR_NONE,
+		"bt_gatt_foreach_included_services() failed.");
 }
 
+
 /**
  * @brief Positive test case of bt_gatt_set_characteristic_changed_cb()
  */
 static void utc_network_bluetooth_gatt_set_characteristic_changed_cb_p(void)
 {
 	int ret = BT_ERROR_NONE;
-	bt_call_list_h gatt_serv;
-	gatt_serv = g_malloc0(sizeof(bt_call_list_h));
-	ret = bt_gatt_set_characteristic_changed_cb(gatt_serv, characteristics_changed_cb_for_gatt_p, NULL);
+
+	ret = bt_gatt_set_characteristic_changed_cb(characteristics_changed_cb_for_gatt_p, NULL);
 	dts_check_eq("bt_gatt_set_characteristic_changed_cb", ret, BT_ERROR_NONE,
-		     "bt_gatt_set_characteristic_changed_cb() failed.");
+		"bt_gatt_set_characteristic_changed_cb() failed.");
 }
 
+
 /**
  * @brief Positive test case of bt_gatt_unset_characteristic_changed_cb()
  */
 static void utc_network_bluetooth_gatt_unset_characteristic_changed_cb_p(void)
 {
 	int ret = BT_ERROR_NONE;
-	bt_call_list_h gatt_serv;
-	gatt_serv = g_malloc0(sizeof(bt_call_list_h));
-	ret = bt_gatt_unset_characteristic_changed_cb(gatt_serv);
+
+	ret = bt_gatt_unset_characteristic_changed_cb();
 	dts_check_eq("bt_gatt_unset_characteristic_changed_cb", ret, BT_ERROR_NONE,
-		     "bt_gatt_unset_characteristic_changed_cb() failed.");
+			"bt_gatt_unset_characteristic_changed_cb() failed.");
 
 }
 
+
 /**
  * @brief Positive test case of bt_gatt_get_characteristic_declaration()
  */
@@ -235,48 +313,93 @@ static void utc_network_bluetooth_gatt_get_characteristic_declaration_p(void)
 	char **uid = "dts_uid";
 	unsigned char **val = "dts_value";
 	int l = 1;
-	bt_call_list_h gatt_charac;
-	gatt_charac = g_malloc0(sizeof(bt_call_list_h));
+	bt_gatt_attribute_h gatt_charac;
+	gatt_charac = g_malloc0(sizeof(bt_gatt_attribute_h));
 	ret = bt_gatt_get_characteristic_declaration(gatt_charac, uid, val, &l);
 	dts_check_eq("bt_gatt_get_characteristic_declaration", ret, BT_ERROR_NONE,
-		     "gatt_get_characteristic_declaration() failed.");
+			"gatt_get_characteristic_declaration() failed.");
 }
 
+
 /**
  * @brief Positive test case of bt_gatt_set_characteristic_value()
  */
 static void utc_network_bluetooth_gatt_set_characteristic_value_p(void)
 {
 	int ret = BT_ERROR_NONE;
-	bt_call_list_h gatt_charac;
-	gatt_charac = g_malloc0(sizeof(bt_call_list_h));
+	bt_gatt_attribute_h gatt_charac;
+	gatt_charac = g_malloc0(sizeof(bt_gatt_attribute_h));
 	const unsigned char *gatt_value = "dts_value";
 	ret = bt_gatt_set_characteristic_value(gatt_charac, gatt_value, strlen("dts_value"));
-	dts_check_eq("bt_gatt_set_characteristic_value", ret, BT_ERROR_NONE, "bt_gatt_set_characteristic_value() failed.");
+	dts_check_eq("bt_gatt_set_characteristic_value", ret, BT_ERROR_NONE,
+			"bt_gatt_set_characteristic_value() failed.");
 }
 
+
 /**
  * @brief Positive test case of bt_gatt_clone_attribute_handle()
  */
 static void utc_network_bluetooth_gatt_clone_attribute_handle_p(void)
 {
 	int ret = BT_ERROR_NONE;
-	bt_call_list_h gatt_origin;
-	gatt_origin = g_malloc0(sizeof(bt_call_list_h));
-
-	ret = bt_gatt_clone_attribute_handle(NULL, gatt_origin);
-	dts_check_eq("bt_gatt_clone_attribute_handle", ret, BT_ERROR_NONE, "bt_gatt_clone_attribute_handle() failed.");
+	bt_gatt_attribute_h gatt_origin;
+	bt_gatt_attribute_h gatt_clone;
+	gatt_origin = g_malloc0(sizeof(bt_gatt_attribute_h));
+	gatt_clone = g_malloc0(sizeof(bt_gatt_attribute_h));
+
+	ret = bt_gatt_clone_attribute_handle(&gatt_clone, gatt_origin);
+	dts_check_eq("bt_gatt_clone_attribute_handle", ret, BT_ERROR_NONE,
+		"bt_gatt_clone_attribute_handle() failed.");
 }
 
+
 /**
  * @brief Positive test case of bt_gatt_destroy_attribute_handle()
  */
 static void utc_network_bluetooth_gatt_destroy_attribute_handle_p(void)
 {
 	int ret = BT_ERROR_NONE;
-	bt_call_list_h gatt_handle;
-	gatt_handle = g_malloc0(sizeof(bt_call_list_h));
+	bt_gatt_attribute_h gatt_handle;
+	gatt_handle = g_malloc0(sizeof(bt_gatt_attribute_h));
 
 	ret = bt_gatt_destroy_attribute_handle(gatt_handle);
-	dts_check_eq("bt_gatt_destroy_attribute_handle", ret, BT_ERROR_NONE, "bt_gatt_destroy_attribute_handle() failed.");
+	dts_check_eq("bt_gatt_destroy_attribute_handle", ret, BT_ERROR_NONE,
+		"bt_gatt_destroy_attribute_handle() failed.");
+}
+
+static void utc_network_bluetooth_gatt_connect_p(void)
+{
+	int ret = BT_ERROR_NONE;
+
+	ret = bt_gatt_connect(remote_address, false);
+	dts_check_eq("bt_gatt_connect", ret, BT_ERROR_NONE,
+		"bt_gatt_connect() failed.");
+
+}
+
+static void utc_network_bluetooth_gatt_disconnect_p(void)
+{
+	int ret = BT_ERROR_NONE;
+	ret = bt_gatt_disconnect(remote_address);
+	dts_check_eq("bt_gatt_connect", ret, BT_ERROR_NONE,
+		"bt_gatt_connect() failed.");
+
+}
+
+static void utc_network_bluetooth_set_gatt_connection_state_changed_cb_p(void)
+{
+	int ret = BT_ERROR_NONE;
+
+	ret = bt_gatt_set_connection_state_changed_cb(gatt_connection_state_changed_cb, NULL);
+	dts_check_eq("bt_gatt_set_connection_state_changed_cb", ret, BT_ERROR_NONE,
+		"bt_gatt_set_connection_state_changed_cb() failed.");
+}
+
+static void utc_network_bluetooth_unset_gatt_connection_state_changed_cb_p(void)
+{
+	int ret = BT_ERROR_NONE;
+
+	ret = bt_gatt_unset_connection_state_changed_cb();
+	dts_check_eq("bt_gatt_unset_connection_state_changed_cb", ret, BT_ERROR_NONE,
+		"bt_gatt_unset_connection_state_changed_cb() failed.");
 }
diff --git a/mobile/TC/testcase/utc_network_bluetooth_hdp_negative.c b/TC/testcase/utc_network_bluetooth_hdp_negative.c
index 4313d0b..d157a1f 100644
--- a/mobile/TC/testcase/utc_network_bluetooth_hdp_negative.c
+++ b/TC/testcase/utc_network_bluetooth_hdp_negative.c
@@ -39,24 +39,21 @@ static void utc_network_bluetooth_hdp_connect_to_source_n(void);
 static void utc_network_bluetooth_hdp_disconnect_n(void);
 static void utc_network_bluetooth_hdp_send_data_n(void);
 static void utc_network_bluetooth_hdp_set_connection_state_changed_cb_n(void);
-static void utc_network_bluetooth_hdp_unset_connection_state_changed_cb_n(void);
 static void utc_network_bluetooth_hdp_set_data_received_cb_n(void);
-static void utc_network_bluetooth_hdp_unset_data_received_cb_n(void);
 
-void adapter_state_changed_cb_for_hdp_n(int result, bt_adapter_state_e adapter_state, void *user_data);
+void adapter_state_changed_cb_for_hdp_n(int result,
+					bt_adapter_state_e adapter_state, void *user_data);
 gboolean timeout_func(gpointer data);
 
 struct tet_testlist tet_testlist[] = {
-	{utc_network_bluetooth_hdp_register_sink_app_n, NEGATIVE_TC_IDX},
-	{utc_network_bluetooth_hdp_unregister_sink_app_n, NEGATIVE_TC_IDX},
-	{utc_network_bluetooth_hdp_connect_to_source_n, NEGATIVE_TC_IDX},
-	{utc_network_bluetooth_hdp_disconnect_n, NEGATIVE_TC_IDX},
-	{utc_network_bluetooth_hdp_send_data_n, NEGATIVE_TC_IDX},
-	{utc_network_bluetooth_hdp_set_connection_state_changed_cb_n, NEGATIVE_TC_IDX},
-	{utc_network_bluetooth_hdp_unset_connection_state_changed_cb_n, NEGATIVE_TC_IDX},
-	{utc_network_bluetooth_hdp_set_data_received_cb_n, NEGATIVE_TC_IDX},
-	{utc_network_bluetooth_hdp_unset_data_received_cb_n, NEGATIVE_TC_IDX},
-	{NULL, 0},
+	{ utc_network_bluetooth_hdp_register_sink_app_n, NEGATIVE_TC_IDX },
+	{ utc_network_bluetooth_hdp_connect_to_source_n, NEGATIVE_TC_IDX },
+	{ utc_network_bluetooth_hdp_send_data_n, NEGATIVE_TC_IDX },
+	{ utc_network_bluetooth_hdp_set_connection_state_changed_cb_n, NEGATIVE_TC_IDX },
+	{ utc_network_bluetooth_hdp_set_data_received_cb_n, NEGATIVE_TC_IDX },
+	{ utc_network_bluetooth_hdp_disconnect_n, NEGATIVE_TC_IDX },
+	{ utc_network_bluetooth_hdp_unregister_sink_app_n, NEGATIVE_TC_IDX },
+	{ NULL, 0 },
 };
 
 static void startup(void)
@@ -109,22 +106,13 @@ gboolean timeout_func(gpointer data)
 /**
  * @brief Callback funtions
  */
-void adapter_state_changed_cb_for_hdp_n(int result, bt_adapter_state_e adapter_state, void *user_data)
+void adapter_state_changed_cb_for_hdp_n(int result,
+							bt_adapter_state_e adapter_state, void *user_data)
 {
-	tet_printf("Callback: bt_adapter_state_changed_cb was called.");
-	if ((user_data != NULL) && !strcmp((char *)user_data, "startup")) {
-		if (adapter_state == BT_ADAPTER_DISABLED && result == BT_ERROR_NONE) {
-			tet_printf("Callback: BT was disabled. DTS will be started.");
-		} else {
-			tet_printf("Callback: BT was not disabled. DTS will be started but DTS may fail.");
-		}
-
-		if (mainloop) {
-			g_main_loop_quit(mainloop);
-		}
-	}
+
 }
 
+
 /**
  * @brief Negative test case of bt_hdp_set_data_received_cb()
  */
@@ -134,7 +122,7 @@ static void utc_network_bluetooth_hdp_set_data_received_cb_n(void)
 
 	ret = bt_hdp_set_data_received_cb(NULL, NULL);
 	dts_check_eq("bt_hdp_set_data_received_cb", ret, BT_ERROR_INVALID_PARAMETER,
-		     "BT_ERROR_INVALID_PARAMETER must be returned when callback parameter is NULL");
+		"BT_ERROR_INVALID_PARAMETER is returned when cb parameters are NULL");
 }
 
 /**
@@ -145,33 +133,11 @@ static void utc_network_bluetooth_hdp_set_connection_state_changed_cb_n(void)
 	int ret = BT_ERROR_NONE;
 
 	ret = bt_hdp_set_connection_state_changed_cb(NULL, NULL, NULL);
-	dts_check_eq("bt_hdp_set_connection_state_changed_cb", ret, BT_ERROR_INVALID_PARAMETER,
-		     "BT_ERROR_INVALID_PARAMETER must be returned when callback parameters are NULL");
-}
-
-/**
- * @brief Negative test case of bt_hdp_unset_data_received_cb()
- */
-static void utc_network_bluetooth_hdp_unset_data_received_cb_n(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_hdp_unset_data_received_cb();
-	dts_check_eq("bt_hdp_unset_data_received_cb", ret, BT_ERROR_NOT_INITIALIZED,
-		     "BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized.");
+	dts_check_eq("bt_hdp_set_connection_state_changed_cb", ret,
+				BT_ERROR_INVALID_PARAMETER,
+		"BT_ERROR_INVALID_PARAMETER is returned when cb parameters are NULL");
 }
 
-/**
- * @brief Negative test case of bt_hdp_unset_connection_state_changed_cb()
- */
-static void utc_network_bluetooth_hdp_unset_connection_state_changed_cb_n(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_hdp_unset_connection_state_changed_cb();
-	dts_check_eq("bt_hdp_unset_connection_state_changed_cb", ret, BT_ERROR_NOT_INITIALIZED,
-		     "BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized.");
-}
 
 /**
  * @brief Negative test case of bt_hdp_disconnect()
@@ -182,7 +148,7 @@ static void utc_network_bluetooth_hdp_disconnect_n(void)
 
 	ret = bt_hdp_disconnect(NULL, 1);
 	dts_check_eq("bt_hdp_disconnect", ret, BT_ERROR_INVALID_PARAMETER,
-		     "BT_ERROR_INVALID_PARAMETER must be returned when remote address parameter is NULL");
+		"BT_ERROR_INVALID_PARAMETER must be returned when remote address parameter is NULL");
 }
 
 /**
@@ -194,7 +160,7 @@ static void utc_network_bluetooth_hdp_connect_to_source_n(void)
 
 	ret = bt_hdp_connect_to_source(NULL, NULL);
 	dts_check_eq("bt_hdp_connect_to_source", ret, BT_ERROR_INVALID_PARAMETER,
-		     "BT_ERROR_INVALID_PARAMETER must be returned when remote address and app_id parameter are NULL");
+		"BT_ERROR_INVALID_PARAMETER must be returned when remote address and app_id parameter are NULL");
 }
 
 /**
@@ -206,7 +172,7 @@ static void utc_network_bluetooth_hdp_register_sink_app_n(void)
 
 	ret = bt_hdp_register_sink_app(1, NULL);
 	dts_check_eq("bt_hdp_register_sink_app", ret, BT_ERROR_INVALID_PARAMETER,
-		     "BT_ERROR_INVALID_PARAMETER must be returned when app_id parameter is NULL");
+			"BT_ERROR_INVALID_PARAMETER must be returned when app_id parameter is NULL");
 }
 
 /**
@@ -218,7 +184,7 @@ static void utc_network_bluetooth_hdp_unregister_sink_app_n(void)
 
 	ret = bt_hdp_unregister_sink_app(NULL);
 	dts_check_eq("bt_shdp_unregister_sink", ret, BT_ERROR_INVALID_PARAMETER,
-		     "BT_ERROR_INVALID_PARAMETER must be returned when app_id parameter is NULL");
+			"BT_ERROR_INVALID_PARAMETER must be returned when app_id parameter is NULL");
 }
 
 /**
@@ -231,5 +197,5 @@ static void utc_network_bluetooth_hdp_send_data_n(void)
 
 	ret = bt_hdp_send_data(1, data, sizeof(data));
 	dts_check_eq("bt_hdp_send_data", ret, BT_ERROR_NOT_ENABLED,
-		     "BT_ERROR_NOT_ENABLED must be returned when BT is not enabled");
+			"BT_ERROR_NOT_ENABLED must be returned when BT is not enabled");
 }
diff --git a/mobile/TC/testcase/utc_network_bluetooth_hdp_positive.c b/TC/testcase/utc_network_bluetooth_hdp_positive.c
index aa0eaa9..b99e6f5 100644..100755
--- a/mobile/TC/testcase/utc_network_bluetooth_hdp_positive.c
+++ b/TC/testcase/utc_network_bluetooth_hdp_positive.c
@@ -30,8 +30,11 @@ static void cleanup(void);
 
 static GMainLoop *mainloop;
 
-void (*tet_startup) (void) = startup;
-void (*tet_cleanup) (void) = cleanup;
+void(*tet_startup)(void) = startup;
+void(*tet_cleanup)(void) = cleanup;
+
+const char *appid = "/org/bluez/health_app_2";
+const char *remote_adr = "00:22:58:07:77:BB";
 
 static void utc_network_bluetooth_hdp_register_sink_app_p(void);
 static void utc_network_bluetooth_hdp_unregister_sink_app_p(void);
@@ -43,27 +46,34 @@ static void utc_network_bluetooth_hdp_unset_connection_state_changed_cb_p(void);
 static void utc_network_bluetooth_hdp_set_data_received_cb_p(void);
 static void utc_network_bluetooth_hdp_unset_data_received_cb_p(void);
 
-void data_received_cb_for_hdp_p(unsigned int channel, const char *data, unsigned int size, void *user_data);
-void connected_cb_for_hdp_p(int result, const char *remote_address, const char *app_id,
-			    bt_hdp_channel_type_e type, unsigned int channel, void *user_data);
-void disconnected_cb_for_hdp_p(int result, const char *remote_address, unsigned int channel, void *user_data);
+void data_received_cb_for_hdp_p(unsigned int channel, const char *data,
+					unsigned int size, void *user_data);
+void connected_cb_for_hdp_p(int result, const char *remote_address,
+					const char *app_id,
+					bt_hdp_channel_type_e type, unsigned int channel, void *user_data);
+void disconnected_cb_for_hdp_p(int result, const char *remote_address,
+					unsigned int channel, void *user_data);
+
+
 
-void adapter_state_changed_cb_for_hdp_p(int result, bt_adapter_state_e adapter_state, void *user_data);
+void adapter_state_changed_cb_for_hdp_p(int result,
+							bt_adapter_state_e adapter_state, void *user_data);
 gboolean timeout_func(gpointer data);
 
 struct tet_testlist tet_testlist[] = {
 	{utc_network_bluetooth_hdp_register_sink_app_p, POSITIVE_TC_IDX},
-	{utc_network_bluetooth_hdp_unregister_sink_app_p, POSITIVE_TC_IDX},
+	{utc_network_bluetooth_hdp_set_connection_state_changed_cb_p, POSITIVE_TC_IDX},
+	{utc_network_bluetooth_hdp_set_data_received_cb_p, POSITIVE_TC_IDX},
 	{utc_network_bluetooth_hdp_connect_to_source_p, POSITIVE_TC_IDX},
-	{utc_network_bluetooth_hdp_disconnect_p, POSITIVE_TC_IDX},
 	{utc_network_bluetooth_hdp_send_data_p, POSITIVE_TC_IDX},
-	{utc_network_bluetooth_hdp_set_connection_state_changed_cb_p, POSITIVE_TC_IDX},
+	{utc_network_bluetooth_hdp_disconnect_p, POSITIVE_TC_IDX},
 	{utc_network_bluetooth_hdp_unset_connection_state_changed_cb_p, POSITIVE_TC_IDX},
-	{utc_network_bluetooth_hdp_set_data_received_cb_p, POSITIVE_TC_IDX},
 	{utc_network_bluetooth_hdp_unset_data_received_cb_p, POSITIVE_TC_IDX},
+	{utc_network_bluetooth_hdp_unregister_sink_app_p, POSITIVE_TC_IDX},
 	{NULL, 0},
 };
 
+
 static void startup(void)
 {
 	int ret = BT_ERROR_NONE;
@@ -77,13 +87,15 @@ static void startup(void)
 		tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed");
 	}
 
-	tet_printf("bt_adapter_disable() was called.");
-	ret = bt_adapter_disable();
+	tet_printf("bt_adapter_enable() was called.");
+	ret = bt_adapter_enable();
 	if (ret == BT_ERROR_NONE) {
-		tet_printf("bt_adapter_disable() succeeded.");
+		tet_printf("bt_adapter_enable() succeeded.");
 		timeout_id = g_timeout_add(60000, timeout_func, mainloop);
 		g_main_loop_run(mainloop);
 		g_source_remove(timeout_id);
+	} else if (ret != BT_ERROR_ALREADY_DONE) {
+		tet_printf("DTS may fail because bt_adapter_disable() failed");
 	} else if (ret == BT_ERROR_NOT_ENABLED) {
 		tet_printf("Bluetooth adapter is not enabled.");
 	} else {
@@ -111,33 +123,27 @@ gboolean timeout_func(gpointer data)
 	return FALSE;
 }
 
-void adapter_state_changed_cb_for_hdp_p(int result, bt_adapter_state_e adapter_state, void *user_data)
+void adapter_state_changed_cb_for_hdp_p(int result,
+					bt_adapter_state_e adapter_state, void *user_data)
 {
-	if ((user_data != NULL) && !strcmp((char *)user_data, "startup")) {
-		if (adapter_state == BT_ADAPTER_ENABLED && result == BT_ERROR_NONE) {
-			tet_printf("Callback: BT was enabled.");
-			bt_adapter_start_device_discovery();
-		} else {
-			tet_printf("Callback: BT was not enabled. DTS will be started but DTS may fail.");
-			if (mainloop) {
-				g_main_loop_quit(mainloop);
-			}
-		}
-	}
+
 }
 
-void data_received_cb_for_hdp_p(unsigned int channel, const char *data, unsigned int size, void *user_data)
+void data_received_cb_for_hdp_p(unsigned int channel, const char *data,
+					unsigned int size, void *user_data)
 {
 
 }
 
-void connected_cb_for_hdp_p(int result, const char *remote_address, const char *app_id,
-			    bt_hdp_channel_type_e type, unsigned int channel, void *user_data)
+void connected_cb_for_hdp_p(int result, const char *remote_address,
+					const char *app_id,
+					bt_hdp_channel_type_e type, unsigned int channel, void *user_data)
 {
 
 }
 
-void disconnected_cb_for_hdp_p(int result, const char *remote_address, unsigned int channel, void *user_data)
+void disconnected_cb_for_hdp_p(int result, const char *remote_address,
+					unsigned int channel, void *user_data)
 {
 
 }
@@ -147,24 +153,28 @@ static void utc_network_bluetooth_hdp_set_data_received_cb_p(void)
 	int ret = BT_ERROR_NONE;
 
 	ret = bt_hdp_set_data_received_cb(data_received_cb_for_hdp_p, NULL);
-	dts_check_eq("bt_hdp_set_data_received_cb", ret, BT_ERROR_NONE, "bt_hdp_set_data_received_cb() failed.");
+	dts_check_eq("bt_hdp_set_data_received_cb", ret, BT_ERROR_NONE,
+					"bt_hdp_set_data_received_cb() failed.");
 }
 
+
 static void utc_network_bluetooth_hdp_unset_data_received_cb_p(void)
 {
 	int ret = BT_ERROR_NONE;
 
 	ret = bt_hdp_unset_data_received_cb();
-	dts_check_eq("bt_hdp_unset_data_received_cb", ret, BT_ERROR_NONE, "bt_hdp_unset_data_received_cb() failed.");
+	dts_check_eq("bt_hdp_unset_data_received_cb", ret, BT_ERROR_NONE,
+					"bt_hdp_unset_data_received_cb() failed.");
 }
 
 static void utc_network_bluetooth_hdp_set_connection_state_changed_cb_p(void)
 {
 	int ret = BT_ERROR_NONE;
 
-	ret = bt_hdp_set_connection_state_changed_cb(connected_cb_for_hdp_p, disconnected_cb_for_hdp_p, NULL);
+	ret = bt_hdp_set_connection_state_changed_cb(connected_cb_for_hdp_p,
+				disconnected_cb_for_hdp_p, NULL);
 	dts_check_eq("bt_hdp_set_connection_state_changed_cb", ret, BT_ERROR_NONE,
-		     "bt_hdp_set_connection_state_changed_cb() failed.");
+				"bt_hdp_set_connection_state_changed_cb() failed.");
 }
 
 static void utc_network_bluetooth_hdp_unset_connection_state_changed_cb_p(void)
@@ -173,7 +183,7 @@ static void utc_network_bluetooth_hdp_unset_connection_state_changed_cb_p(void)
 
 	ret = bt_hdp_unset_connection_state_changed_cb();
 	dts_check_eq("bt_hdp_unset_connection_state_changed_cb", ret, BT_ERROR_NONE,
-		     "bt_hdp_unset_connection_state_changed_cb() failed.");
+		"bt_hdp_unset_connection_state_changed_cb() failed.");
 }
 
 static void utc_network_bluetooth_hdp_send_data_p(void)
@@ -182,45 +192,51 @@ static void utc_network_bluetooth_hdp_send_data_p(void)
 	char *dts_test = "dts_test";
 
 	ret = bt_hdp_send_data(1, "dts_test", sizeof(dts_test));
-	dts_check_eq("bt_hdp_send_data", ret, BT_ERROR_NONE, "bt_hdp_send_data() failed.");
+	dts_check_eq("bt_hdp_send_data", ret, BT_ERROR_NONE,
+			"bt_hdp_send_data() failed.");
 }
 
 static void utc_network_bluetooth_hdp_disconnect_p(void)
 {
 	int ret = BT_ERROR_NONE;
-	char *remote_adr = "";
+	char *remote_adr = "00:22:58:07:77:BB";
 
-	ret = bt_hdp_disconnect(remote_adr, 1);
-	dts_check_eq("bt_hdp_disconnect", ret, BT_ERROR_NONE, "bt_hdp_disconnect() failed.");
+	ret = bt_hdp_disconnect(remote_adr, 0);
+	dts_check_eq("bt_hdp_disconnect", ret, BT_ERROR_NONE,
+					"bt_hdp_disconnect() failed.");
 }
 
 static void utc_network_bluetooth_hdp_connect_to_source_p(void)
 {
 	int ret = BT_ERROR_NONE;
-	char *remote_adr = "dts_remote";
-	char *appid = "dts_id";
 
 	ret = bt_hdp_connect_to_source(remote_adr, appid);
-	dts_check_eq("bt_hdp_connect_to_source", ret, BT_ERROR_NONE, "bt_hdp_connect_to_source() failed.");
+	dts_check_eq("bt_hdp_connect_to_source", ret, BT_ERROR_NONE,
+				"bt_hdp_connect_to_source() failed.");
 
 }
 
 static void utc_network_bluetooth_hdp_unregister_sink_app_p(void)
 {
 	int ret = BT_ERROR_NONE;
-	char *appid = "dts_id";
 
 	ret = bt_hdp_unregister_sink_app(appid);
-	dts_check_eq("bt_hdp_unregister_sink_app", ret, BT_ERROR_NONE, "bt_hdp_unregister_sink_app() failed.");
+	dts_check_eq("bt_hdp_unregister_sink_app", ret, BT_ERROR_NONE,
+					"bt_hdp_unregister_sink_app() failed.");
 
 }
 
 static void utc_network_bluetooth_hdp_register_sink_app_p(void)
 {
 	int ret = BT_ERROR_NONE;
-	char *appid = "dts_id";
 
 	ret = bt_hdp_register_sink_app(1, &appid);
-	dts_check_eq("bt_hdp_register_sink_app", ret, BT_ERROR_NONE, "bt_hdp_register_sink_app() failed.");
+	dts_check_eq("bt_hdp_register_sink_app", ret, BT_ERROR_NONE,
+					"bt_hdp_register_sink_app() failed.");
 
 }
+
+
+
+
+
diff --git a/mobile/TC/testcase/utc_network_bluetooth_hid_negative.c b/TC/testcase/utc_network_bluetooth_hid_negative.c
index 6b99d66..e8cb5f8 100644..100755
--- a/mobile/TC/testcase/utc_network_bluetooth_hid_negative.c
+++ b/TC/testcase/utc_network_bluetooth_hid_negative.c
@@ -34,21 +34,21 @@ void (*tet_startup) (void) = startup;
 void (*tet_cleanup) (void) = cleanup;
 
 static void utc_network_bluetooth_hid_host_initialize_n(void);
-static void utc_network_bluetooth_hid_host_deinitialize_n(void);
 static void utc_network_bluetooth_hid_host_connect_n(void);
 static void utc_network_bluetooth_hid_host_disconnect_n(void);
 
-void adapter_state_changed_cb_for_hid_n(int result, bt_adapter_state_e adapter_state, void *user_data);
+void adapter_state_changed_cb_for_hid_n(int result,
+		bt_adapter_state_e adapter_state, void *user_data);
 gboolean timeout_func(gpointer data);
 
 struct tet_testlist tet_testlist[] = {
 	{utc_network_bluetooth_hid_host_initialize_n, NEGATIVE_TC_IDX},
-	{utc_network_bluetooth_hid_host_deinitialize_n, NEGATIVE_TC_IDX},
 	{utc_network_bluetooth_hid_host_connect_n, NEGATIVE_TC_IDX},
 	{utc_network_bluetooth_hid_host_disconnect_n, NEGATIVE_TC_IDX},
 	{NULL, 0},
 };
 
+
 static void startup(void)
 {
 	int ret = BT_ERROR_NONE;
@@ -82,6 +82,7 @@ static void startup(void)
 	tet_printf("TC start");
 }
 
+
 static void cleanup(void)
 {
 	/* end of TC */
@@ -89,6 +90,7 @@ static void cleanup(void)
 	tet_printf("TC end.");
 }
 
+
 gboolean timeout_func(gpointer data)
 {
 	tet_printf("Callback: Timeout.");
@@ -96,54 +98,45 @@ gboolean timeout_func(gpointer data)
 	return FALSE;
 }
 
-void adapter_state_changed_cb_for_hid_n(int result, bt_adapter_state_e adapter_state, void *user_data)
+void adapter_state_changed_cb_for_hid_n(int result,
+							bt_adapter_state_e adapter_state, void *user_data)
 {
-	if ((user_data != NULL) && !strcmp((char *)user_data, "startup")) {
-		if (adapter_state == BT_ADAPTER_ENABLED && result == BT_ERROR_NONE) {
-			tet_printf("Callback: BT was enabled.");
-			bt_adapter_start_device_discovery();
-		} else {
-			tet_printf("Callback: BT was not enabled. DTS will be started but DTS may fail.");
-			if (mainloop) {
-				g_main_loop_quit(mainloop);
-			}
-		}
-	}
-}
 
-static void utc_network_bluetooth_hid_host_initialize_n(void)
+}
+void host_connection_state_changed_cb_for_hid_p(int result,
+				bool connected, const char *remote_address, void *user_data)
 {
-	int ret = BT_ERROR_NONE;
 
-	ret = bt_hid_host_initialize(NULL, NULL);
-	dts_check_eq("bt_socket_set_data_received_cb", ret, BT_ERROR_INVALID_PARAMETER,
-		     "BT_ERROR_INVALID_PARAMETER must be returned when callback parameter is NULL.");
 }
 
-static void utc_network_bluetooth_hid_host_deinitialize_n(void)
+static void utc_network_bluetooth_hid_host_initialize_n(void)
 {
 	int ret = BT_ERROR_NONE;
 
-	ret = bt_hid_host_deinitialize();
-	dts_check_eq("bt_hid_host_deinitialize", ret, BT_ERROR_INVALID_PARAMETER,
-		     "BT_ERROR_INVALID_PARAMETER must be returned.");
+	ret = bt_hid_host_initialize(NULL, NULL);
+	dts_check_eq("bt_hid_host_initialize", ret,
+		BT_ERROR_INVALID_PARAMETER,
+		"BT_ERROR_INVALID_PARAMETER must be returned when callback parameter is NULL.");
 }
 
+
 static void utc_network_bluetooth_hid_host_connect_n(void)
 {
 	int ret = BT_ERROR_NONE;
-	//char* remote_addr="dts_addr";
+
+	ret = bt_hid_host_initialize(host_connection_state_changed_cb_for_hid_p, NULL);
 
 	ret = bt_hid_host_connect(NULL);
 	dts_check_eq("bt_hid_host_connect", ret, BT_ERROR_INVALID_PARAMETER,
-		     "BT_ERROR_INVALID_PARAMETER must be returned when remote address parameter is NULL.");
+		"BT_ERROR_INVALID_PARAMETER must be returned when remote address parameter is NULL.");
 }
 
+
 static void utc_network_bluetooth_hid_host_disconnect_n(void)
 {
 	int ret = BT_ERROR_NONE;
 
 	ret = bt_hid_host_disconnect(NULL);
 	dts_check_eq("bt_hid_host_disconnect", ret, BT_ERROR_INVALID_PARAMETER,
-		     "BT_ERROR_INVALID_PARAMETER must be returned when remote address parameter is NULL.");
+			"BT_ERROR_INVALID_PARAMETER must be returned when remote address parameter is NULL.");
 }
diff --git a/mobile/TC/testcase/utc_network_bluetooth_hid_positive.c b/TC/testcase/utc_network_bluetooth_hid_positive.c
index a06a164..95e7db1 100644..100755
--- a/mobile/TC/testcase/utc_network_bluetooth_hid_positive.c
+++ b/TC/testcase/utc_network_bluetooth_hid_positive.c
@@ -38,18 +38,21 @@ static void utc_network_bluetooth_hid_host_deinitialize_p(void);
 static void utc_network_bluetooth_hid_host_connect_p(void);
 static void utc_network_bluetooth_hid_host_disconnect_p(void);
 
-void adapter_state_changed_cb_for_hid_p(int result, bt_adapter_state_e adapter_state, void *user_data);
-void host_connection_state_changed_cb_for_hid_p(int result, bool connected, const char *remote_address, void *user_data);
+void adapter_state_changed_cb_for_hid_p(int result,
+			bt_adapter_state_e adapter_state, void *user_data);
+void host_connection_state_changed_cb_for_hid_p(int result,
+				bool connected, const char *remote_address, void *user_data);
 gboolean timeout_func(gpointer data);
 
 struct tet_testlist tet_testlist[] = {
 	{utc_network_bluetooth_hid_host_initialize_p, POSITIVE_TC_IDX},
-	{utc_network_bluetooth_hid_host_deinitialize_p, POSITIVE_TC_IDX},
 	{utc_network_bluetooth_hid_host_connect_p, POSITIVE_TC_IDX},
 	{utc_network_bluetooth_hid_host_disconnect_p, POSITIVE_TC_IDX},
+	{utc_network_bluetooth_hid_host_deinitialize_p, POSITIVE_TC_IDX},
 	{NULL, 0},
 };
 
+
 static void startup(void)
 {
 	int ret = BT_ERROR_NONE;
@@ -63,13 +66,15 @@ static void startup(void)
 		tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed");
 	}
 
-	tet_printf("bt_adapter_disable() was called.");
-	ret = bt_adapter_disable();
+	tet_printf("bt_adapter_enable() was called.");
+			ret = bt_adapter_enable();
 	if (ret == BT_ERROR_NONE) {
-		tet_printf("bt_adapter_disable() succeeded.");
+		tet_printf("bt_adapter_enable() succeeded.");
 		timeout_id = g_timeout_add(60000, timeout_func, mainloop);
 		g_main_loop_run(mainloop);
 		g_source_remove(timeout_id);
+	} else if (ret != BT_ERROR_ALREADY_DONE) {
+		tet_printf("DTS may fail because bt_adapter_disable() failed");
 	} else if (ret == BT_ERROR_NOT_ENABLED) {
 		tet_printf("Bluetooth adapter is not enabled.");
 	} else {
@@ -83,6 +88,7 @@ static void startup(void)
 	tet_printf("TC start");
 }
 
+
 static void cleanup(void)
 {
 	/* end of TC */
@@ -90,6 +96,7 @@ static void cleanup(void)
 	tet_printf("TC end.");
 }
 
+
 gboolean timeout_func(gpointer data)
 {
 	tet_printf("Callback: Timeout.");
@@ -97,56 +104,56 @@ gboolean timeout_func(gpointer data)
 	return FALSE;
 }
 
-void adapter_state_changed_cb_for_hid_p(int result, bt_adapter_state_e adapter_state, void *user_data)
+void adapter_state_changed_cb_for_hid_p(int result,
+							bt_adapter_state_e adapter_state, void *user_data)
 {
-	if (user_data != NULL && !strcmp((char *)user_data, "startup")) {
-		if (adapter_state == BT_ADAPTER_ENABLED && result == BT_ERROR_NONE) {
-			tet_printf("Callback: BT was enabled.");
-			bt_adapter_start_device_discovery();
-		} else {
-			tet_printf("Callback: BT was not enabled. DTS will be started but DTS may fail.");
-			if (mainloop) {
-				g_main_loop_quit(mainloop);
-			}
-		}
-	}
+
 }
 
-void host_connection_state_changed_cb_for_hid_p(int result, bool connected, const char *remote_address, void *user_data)
+void host_connection_state_changed_cb_for_hid_p(int result,
+				bool connected, const char *remote_address, void *user_data)
 {
 
 }
 
+
 static void utc_network_bluetooth_hid_host_initialize_p(void)
 {
 	int ret = BT_ERROR_NONE;
 
 	ret = bt_hid_host_initialize(host_connection_state_changed_cb_for_hid_p, NULL);
-	dts_check_eq("bt_hid_host_initialize", ret, BT_ERROR_NONE, "bt_hid_host_initialize() failed.");
+	dts_check_eq("bt_hid_host_initialize", ret, BT_ERROR_NONE,
+		"bt_hid_host_initialize() failed.");
 }
 
+
 static void utc_network_bluetooth_hid_host_deinitialize_p(void)
 {
 	int ret = BT_ERROR_NONE;
 
 	ret = bt_hid_host_deinitialize();
-	dts_check_eq("bt_hid_host_deinitialize", ret, BT_ERROR_NONE, "bt_hid_host_deinitialize() failed.");
+	dts_check_eq("bt_hid_host_deinitialize", ret, BT_ERROR_NONE,
+		"bt_hid_host_deinitialize() failed.");
 }
 
+
 static void utc_network_bluetooth_hid_host_connect_p(void)
 {
 	int ret = BT_ERROR_NONE;
 	char *remote_addr = "dts_addr";
 
 	ret = bt_hid_host_connect(remote_addr);
-	dts_check_eq("bt_hid_host_connect", ret, BT_ERROR_NONE, "bt_hid_host_connect() failed.");
+	dts_check_eq("bt_hid_host_connect", ret, BT_ERROR_NONE,
+		"bt_hid_host_connect() failed.");
 }
 
+
 static void utc_network_bluetooth_hid_host_disconnect_p(void)
 {
 	int ret = BT_ERROR_NONE;
 	char *remote_addr = "dts_addr";
 
 	ret = bt_hid_host_disconnect(remote_addr);
-	dts_check_eq("bt_hid_host_disconnect", ret, BT_ERROR_NONE, "bt_hid_host_disconnect() failed.");
+	dts_check_eq("bt_hid_host_disconnect", ret, BT_ERROR_NONE,
+			"bt_hid_host_disconnect() failed.");
 }
diff --git a/mobile/TC/testcase/utc_network_bluetooth_opp-client_negative.c b/TC/testcase/utc_network_bluetooth_opp-client_negative.c
index 67299e9..77ecc79 100644..100755
--- a/mobile/TC/testcase/utc_network_bluetooth_opp-client_negative.c
+++ b/TC/testcase/utc_network_bluetooth_opp-client_negative.c
@@ -33,26 +33,20 @@ static GMainLoop *mainloop;
 void (*tet_startup) (void) = startup;
 void (*tet_cleanup) (void) = cleanup;
 
-static void utc_network_bluetooth_opp_client_initialize_n(void);
-static void utc_network_bluetooth_opp_client_deinitialize_n(void);
 static void utc_network_bluetooth_opp_client_add_file_n(void);
-static void utc_network_bluetooth_opp_client_clear_files_n(void);
 static void utc_network_bluetooth_opp_client_push_files_n(void);
-static void utc_network_bluetooth_opp_client_cancel_push_n(void);
 
-void adapter_state_changed_cb_for_opp_client_n(int result, bt_adapter_state_e adapter_state, void *user_data);
+void adapter_state_changed_cb_for_opp_client_n(int result,
+							bt_adapter_state_e adapter_state, void *user_data);
 gboolean timeout_func(gpointer data);
 
 struct tet_testlist tet_testlist[] = {
-	{utc_network_bluetooth_opp_client_initialize_n, NEGATIVE_TC_IDX},
-	{utc_network_bluetooth_opp_client_deinitialize_n, NEGATIVE_TC_IDX},
 	{utc_network_bluetooth_opp_client_add_file_n, NEGATIVE_TC_IDX},
-	{utc_network_bluetooth_opp_client_clear_files_n, NEGATIVE_TC_IDX},
 	{utc_network_bluetooth_opp_client_push_files_n, NEGATIVE_TC_IDX},
-	{utc_network_bluetooth_opp_client_cancel_push_n, NEGATIVE_TC_IDX},
 	{NULL, 0},
 };
 
+
 static void startup(void)
 {
 	int ret = BT_ERROR_NONE;
@@ -62,6 +56,7 @@ static void startup(void)
 	mainloop = g_main_loop_new(NULL, FALSE);
 
 	bt_initialize();
+	bt_opp_client_initialize();
 	if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_opp_client_n, "startup") != BT_ERROR_NONE) {
 		tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed");
 	}
@@ -86,6 +81,7 @@ static void startup(void)
 	tet_printf("TC start");
 }
 
+
 static void cleanup(void)
 {
 	/* end of TC */
@@ -93,6 +89,7 @@ static void cleanup(void)
 	tet_printf("TC end.");
 }
 
+
 gboolean timeout_func(gpointer data)
 {
 	tet_printf("Callback: Timeout.");
@@ -100,7 +97,8 @@ gboolean timeout_func(gpointer data)
 	return FALSE;
 }
 
-void adapter_state_changed_cb_for_opp_client_n(int result, bt_adapter_state_e adapter_state, void *user_data)
+void adapter_state_changed_cb_for_opp_client_n(int result,
+							bt_adapter_state_e adapter_state, void *user_data)
 {
 	if (user_data != NULL && !strcmp((char *)user_data, "startup")) {
 		if (adapter_state == BT_ADAPTER_ENABLED && result == BT_ERROR_NONE) {
@@ -115,24 +113,6 @@ void adapter_state_changed_cb_for_opp_client_n(int result, bt_adapter_state_e ad
 	}
 }
 
-static void utc_network_bluetooth_opp_client_initialize_n(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_opp_client_initialize();
-	dts_check_eq("bt_opp_client_initialize", ret, BT_ERROR_NOT_INITIALIZED,
-		     "BT_ERROR_NOT_INITIALIZED must be returned.");
-}
-
-static void utc_network_bluetooth_opp_client_deinitialize_n(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_opp_client_deinitialize();
-	dts_check_eq("bt_opp_client_deinitialize", ret, BT_ERROR_NOT_INITIALIZED,
-		     "BT_ERROR_NOT_INITIALIZED must be returned.");
-
-}
 
 static void utc_network_bluetooth_opp_client_add_file_n(void)
 {
@@ -140,18 +120,9 @@ static void utc_network_bluetooth_opp_client_add_file_n(void)
 
 	ret = bt_opp_client_add_file(NULL);
 	dts_check_eq("bt_opp_client_add_file", ret, BT_ERROR_INVALID_PARAMETER,
-		     "BT_ERROR_INVALID_PARAMETER must be returned when file parameter is NULL");
+		"BT_ERROR_INVALID_PARAMETER must be returned when file parameter is NULL");
 }
 
-static void utc_network_bluetooth_opp_client_clear_files_n(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_opp_client_clear_files();
-	dts_check_eq("bt_opp_client_clear_files", ret, BT_ERROR_NOT_INITIALIZED,
-		     "BT_ERROR_NOT_INITIALIZED must be returned.");
-
-}
 
 static void utc_network_bluetooth_opp_client_push_files_n(void)
 {
@@ -159,14 +130,7 @@ static void utc_network_bluetooth_opp_client_push_files_n(void)
 
 	ret = bt_opp_client_push_files(NULL, NULL, NULL, NULL, NULL);
 	dts_check_eq("bt_opp_client_push_files", ret, BT_ERROR_INVALID_PARAMETER,
-		     "BT_ERROR_INVALID_PARAMETER must be returned when parameters are NULL");
+		"BT_ERROR_INVALID_PARAMETER must be returned when parameters are NULL");
 }
 
-static void utc_network_bluetooth_opp_client_cancel_push_n(void)
-{
-	int ret = BT_ERROR_NONE;
 
-	ret = bt_opp_client_cancel_push();
-	dts_check_eq("bt_opp_client_cancel_push", ret, BT_ERROR_NOT_INITIALIZED,
-		     "BT_ERROR_NOT_INITIALIZED must be returned.");
-}
diff --git a/mobile/TC/testcase/utc_network_bluetooth_opp-client_positive.c b/TC/testcase/utc_network_bluetooth_opp-client_positive.c
index 341243d..b50baea 100644..100755
--- a/mobile/TC/testcase/utc_network_bluetooth_opp-client_positive.c
+++ b/TC/testcase/utc_network_bluetooth_opp-client_positive.c
@@ -14,12 +14,16 @@
  * limitations under the License.
  */
 
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
 #include <tet_api.h>
 #include <bluetooth.h>
 #include <stdlib.h>
 #include <stdbool.h>
 #include <glib.h>
 
+#define CONFIG_FILE_PATH "/opt/home/capi-network-bluetooth/tetware.conf"
 enum {
 	POSITIVE_TC_IDX = 0x01,
 	NEGATIVE_TC_IDX,
@@ -30,8 +34,10 @@ static void cleanup(void);
 
 static GMainLoop *mainloop;
 
-void (*tet_startup) (void) = startup;
-void (*tet_cleanup) (void) = cleanup;
+void(*tet_startup)(void) = startup;
+void(*tet_cleanup)(void) = cleanup;
+
+char *remote_address;
 
 static void utc_network_bluetooth_opp_client_initialize_p(void);
 static void utc_network_bluetooth_opp_client_deinitialize_p(void);
@@ -40,27 +46,71 @@ static void utc_network_bluetooth_opp_client_clear_files_p(void);
 static void utc_network_bluetooth_opp_client_push_files_p(void);
 static void utc_network_bluetooth_opp_client_cancel_push_p(void);
 
-void push_responded_cb_for_opp_client_p(int result, const char *remote_address, void *user_data);
-void push_progress_cb_for_opp_client_p(const char *file, long long size, int percent, void *user_data);
-void push_finished_cb_for_opp_client_p(int result, const char *remote_address, void *user_data);
-void adapter_state_changed_cb_for_opp_client_p(int result, bt_adapter_state_e adapter_state, void *user_data);
+void push_responded_cb_for_opp_client_p(int result,
+						const char *remote_address, void *user_data);
+void push_progress_cb_for_opp_client_p(const char *file,
+						long long size, int percent, void *user_data);
+void push_finished_cb_for_opp_client_p(int result,
+						const char *remote_address, void *user_data);
+void adapter_state_changed_cb_for_opp_client_p(int result,
+						bt_adapter_state_e adapter_state, void *user_data);
 gboolean timeout_func(gpointer data);
 
 struct tet_testlist tet_testlist[] = {
 	{utc_network_bluetooth_opp_client_initialize_p, POSITIVE_TC_IDX},
-	{utc_network_bluetooth_opp_client_deinitialize_p, POSITIVE_TC_IDX},
 	{utc_network_bluetooth_opp_client_add_file_p, POSITIVE_TC_IDX},
-	{utc_network_bluetooth_opp_client_clear_files_p, POSITIVE_TC_IDX},
 	{utc_network_bluetooth_opp_client_push_files_p, POSITIVE_TC_IDX},
 	{utc_network_bluetooth_opp_client_cancel_push_p, POSITIVE_TC_IDX},
+	{utc_network_bluetooth_opp_client_clear_files_p, POSITIVE_TC_IDX},
+	{utc_network_bluetooth_opp_client_deinitialize_p, POSITIVE_TC_IDX},
 	{NULL, 0},
 };
 
+int get_value_from_file(void)
+{
+	FILE *fp;
+	char *token;
+	char buf[100];
+
+	fp = fopen(CONFIG_FILE_PATH, "r");
+	if (fp == NULL) {
+		tet_printf("Default configuration is used\n");
+		return -1;
+	}
+	while (fgets(buf, sizeof(buf), fp)) {
+		if (buf[0] == '#' || buf[0] == '\n')
+			continue;
+
+		token = strrchr(buf, '\n');
+		if (token == NULL) {
+			tet_printf("g_conf is too long\n");
+			break;
+		}
+		*token = '\0';
+
+		token = strtok(buf, "=");
+		if (token == NULL) {
+			continue;
+		}
+		if (strcasecmp(token, "BT_ADDR_MOBILE") == 0) {
+			token = strtok(NULL, "=");
+			remote_address = strdup(token);
+			fclose(fp);
+			return 0;
+		}
+	}
+	return -1;
+}
+
 static void startup(void)
 {
 	int ret = BT_ERROR_NONE;
 	int timeout_id = 0;
 
+	if(get_value_from_file() == -1) {
+		tet_printf("Failed to read.");
+	}
+
 	/* start of TC */
 	mainloop = g_main_loop_new(NULL, FALSE);
 
@@ -69,14 +119,16 @@ static void startup(void)
 		tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed");
 	}
 
-	tet_printf("bt_adapter_disable() was called.");
-	ret = bt_adapter_disable();
-	if (ret == BT_ERROR_NONE) {
-		tet_printf("bt_adapter_disable() succeeded.");
-		timeout_id = g_timeout_add(60000, timeout_func, mainloop);
-		g_main_loop_run(mainloop);
-		g_source_remove(timeout_id);
-	} else if (ret == BT_ERROR_NOT_ENABLED) {
+	tet_printf("bt_adapter_enable() was called.");
+			ret = bt_adapter_enable();
+			if (ret == BT_ERROR_NONE) {
+				tet_printf("bt_adapter_enable() succeeded.");
+				timeout_id = g_timeout_add(60000, timeout_func, mainloop);
+				g_main_loop_run(mainloop);
+				g_source_remove(timeout_id);
+			} else if (ret != BT_ERROR_ALREADY_DONE) {
+				tet_printf("DTS may fail because bt_adapter_disable() failed");
+			} else if (ret == BT_ERROR_NOT_ENABLED) {
 		tet_printf("Bluetooth adapter is not enabled.");
 	} else {
 		tet_printf("DTS may fail because bt_adapter_disable() failed");
@@ -103,7 +155,8 @@ gboolean timeout_func(gpointer data)
 	return FALSE;
 }
 
-void adapter_state_changed_cb_for_opp_client_p(int result, bt_adapter_state_e adapter_state, void *user_data)
+void adapter_state_changed_cb_for_opp_client_p(int result,
+							bt_adapter_state_e adapter_state, void *user_data)
 {
 	if ((user_data != NULL) && !strcmp((char *)user_data, "startup")) {
 		if (adapter_state == BT_ADAPTER_ENABLED && result == BT_ERROR_NONE) {
@@ -118,27 +171,34 @@ void adapter_state_changed_cb_for_opp_client_p(int result, bt_adapter_state_e ad
 	}
 }
 
-void push_responded_cb_for_opp_client_p(int result, const char *remote_address, void *user_data)
+void push_responded_cb_for_opp_client_p(int result,
+								const char *remote_address, void *user_data)
 {
 
 }
 
-void push_progress_cb_for_opp_client_p(const char *file, long long size, int percent, void *user_data)
+
+void push_progress_cb_for_opp_client_p(const char *file, long long size,
+												int percent, void *user_data)
 {
 
 }
 
-void push_finished_cb_for_opp_client_p(int result, const char *remote_address, void *user_data)
+
+void push_finished_cb_for_opp_client_p(int result,
+		const char *remote_address, void *user_data)
 {
 
 }
 
+
 static void utc_network_bluetooth_opp_client_initialize_p(void)
 {
 	int ret = BT_ERROR_NONE;
 
 	ret = bt_opp_client_initialize();
-	dts_check_eq("bt_opp_client_initialize", ret, BT_ERROR_NONE, "bt_opp_client_initialize() failed.");
+	dts_check_eq("bt_opp_client_initialize", ret,
+			BT_ERROR_NONE, "bt_opp_client_initialize() failed.");
 }
 
 static void utc_network_bluetooth_opp_client_deinitialize_p(void)
@@ -146,45 +206,55 @@ static void utc_network_bluetooth_opp_client_deinitialize_p(void)
 	int ret = BT_ERROR_NONE;
 
 	ret = bt_opp_client_deinitialize();
-	dts_check_eq("bt_opp_client_deinitialize", ret, BT_ERROR_NONE, "bt_opp_client_deinitialize() failed.");
+	dts_check_eq("bt_opp_client_deinitialize", ret,
+			BT_ERROR_NONE, "bt_opp_client_deinitialize() failed.");
 
 }
 
 static void utc_network_bluetooth_opp_client_add_file_p(void)
 {
 	int ret = BT_ERROR_NONE;
+	int fd = 0;
+	const char *file = "/tmp/a.txt";
 
-	ret = bt_opp_client_add_file("dts_file");
-	dts_check_eq("bt_opp_client_add_file", ret, BT_ERROR_NONE, "bt_opp_client_add_file() failed");
+	if (access("/tmp/a.txt", F_OK) < 0) {
+		fd = open("/tmp/a.txt", O_RDWR|O_CREAT,0666);
+		write(fd, "hey", 3);
+	}
+
+	ret = bt_opp_client_add_file(file);
+	dts_check_eq("bt_opp_client_add_file", ret,
+			BT_ERROR_NONE, "bt_opp_client_add_file() failed");
 }
 
+
 static void utc_network_bluetooth_opp_client_clear_files_p(void)
 {
 	int ret = BT_ERROR_NONE;
 
 	ret = bt_opp_client_clear_files();
-	dts_check_eq("bt_opp_client_clear_files", ret, BT_ERROR_NONE, "bt_opp_client_clear_files() failed.");
+	dts_check_eq("bt_opp_client_clear_files", ret,
+			BT_ERROR_NONE, "bt_opp_client_clear_files() failed.");
 
 }
 
+
 static void utc_network_bluetooth_opp_client_push_files_p(void)
 {
 	int ret = BT_ERROR_NONE;
 
-	ret =
-	    bt_opp_client_push_files(NULL, push_responded_cb_for_opp_client_p, push_progress_cb_for_opp_client_p,
-				     push_finished_cb_for_opp_client_p, NULL);
-	if (ret == BT_ERROR_NONE) {
-		dts_pass("bt_opp_client_push_files", "bt_opp_client_push_files pass");
-	} else {
-		dts_fail("bt_opp_client_push_files", "bt_opp_client_push_files() failed");
-	}
+	ret = bt_opp_client_push_files(remote_address, push_responded_cb_for_opp_client_p,
+	push_progress_cb_for_opp_client_p, push_finished_cb_for_opp_client_p, NULL);
+
+	dts_check_eq("bt_opp_client_push_files", ret,
+				BT_ERROR_NONE, "bt_opp_client_push_files() failed");
 }
 
 static void utc_network_bluetooth_opp_client_cancel_push_p(void)
 {
 	int ret = BT_ERROR_NONE;
 
-	ret = bt_opp_client_cancel_push();
-	dts_check_eq("bt_opp_client_cancel_push", ret, BT_ERROR_NONE, "bt_opp_client_cancel_push() failed.");
+		ret = bt_opp_client_cancel_push();
+		dts_check_eq("bt_opp_client_cancel_push", ret,
+						BT_ERROR_NONE, "bt_opp_client_cancel_push() failed.");
 }
diff --git a/mobile/TC/testcase/utc_network_bluetooth_opp-server_negative.c b/TC/testcase/utc_network_bluetooth_opp-server_negative.c
index d44db06..a7d911d 100644..100755
--- a/mobile/TC/testcase/utc_network_bluetooth_opp-server_negative.c
+++ b/TC/testcase/utc_network_bluetooth_opp-server_negative.c
@@ -30,27 +30,31 @@ static void startup(void);
 static void cleanup(void);
 
 static GMainLoop *mainloop;
+const char *dest = "/tmp";
 
 void (*tet_startup) (void) = startup;
 void (*tet_cleanup) (void) = cleanup;
 
 static void utc_network_bluetooth_opp_server_initialize_n(void);
 static void utc_network_bluetooth_opp_server_initialize_by_connection_request_n(void);
-static void utc_network_bluetooth_opp_server_deinitialize_n(void);
 static void utc_network_bluetooth_opp_server_accept_n(void);
-static void utc_network_bluetooth_opp_server_reject_n(void);
 static void utc_network_bluetooth_opp_server_set_destination_n(void);
 
-void adapter_state_changed_cb_for_opp_server_n(int result, bt_adapter_state_e adapter_state, void *user_data);
+void adapter_state_changed_cb_for_opp_server_n(int result,
+							bt_adapter_state_e adapter_state, void *user_data);
+void transfer_progress_cb_for_opp_server(const char *file, long long size,
+												int percent, void *user_data);
+void transfer_finished_cb_for_opp_server(int result, const char *file,
+											long long size, void *user_data);
+void push_requested_cb_for_opp_server(const char *file, int size, void *user_data);
+
 gboolean timeout_func(gpointer data);
 
 struct tet_testlist tet_testlist[] = {
 	{utc_network_bluetooth_opp_server_initialize_n, NEGATIVE_TC_IDX},
 	{utc_network_bluetooth_opp_server_initialize_by_connection_request_n, NEGATIVE_TC_IDX},
-	{utc_network_bluetooth_opp_server_deinitialize_n, NEGATIVE_TC_IDX},
-	{utc_network_bluetooth_opp_server_accept_n, NEGATIVE_TC_IDX},
-	{utc_network_bluetooth_opp_server_reject_n, NEGATIVE_TC_IDX},
 	{utc_network_bluetooth_opp_server_set_destination_n, NEGATIVE_TC_IDX},
+	{utc_network_bluetooth_opp_server_accept_n, NEGATIVE_TC_IDX},
 	{NULL, 0},
 };
 
@@ -87,6 +91,7 @@ static void startup(void)
 	tet_printf("TC start");
 }
 
+
 static void cleanup(void)
 {
 	/* end of TC */
@@ -94,17 +99,37 @@ static void cleanup(void)
 	tet_printf("TC end.");
 }
 
+
 gboolean timeout_func(gpointer data)
 {
 	tet_printf("Callback: Timeout.");
-	g_main_loop_quit((GMainLoop *) data);
+	g_main_loop_quit((GMainLoop *)data);
 	return FALSE;
 }
 
+void push_requested_cb_for_opp_server(const char *file, int size,
+											void *user_data)
+{
+
+}
+
+void transfer_progress_cb_for_opp_server(const char *file, long long size,
+											int percent, void *user_data)
+{
+
+}
+
+void transfer_finished_cb_for_opp_server(int result, const char *file,
+											long long size, void *user_data)
+{
+
+}
+
 /**
  * @brief Callback funtions
  */
-void adapter_state_changed_cb_for_opp_server_n(int result, bt_adapter_state_e adapter_state, void *user_data)
+void adapter_state_changed_cb_for_opp_server_n(int result,
+							bt_adapter_state_e adapter_state, void *user_data)
 {
 	tet_printf("Callback: bt_adapter_state_changed_cb was called.");
 	if ((user_data != NULL) && !strcmp((char *)user_data, "startup")) {
@@ -125,42 +150,33 @@ static void utc_network_bluetooth_opp_server_initialize_n(void)
 	int ret = BT_ERROR_NONE;
 
 	ret = bt_opp_server_initialize(NULL, NULL, NULL);
-	dts_check_eq("bt_opp_server_initializa", ret, BT_ERROR_INVALID_PARAMETER,
-		     "BT_ERROR_INVALID_PARAMETER must be returned when destination parameter is NULL");
+	dts_check_eq("bt_opp_server_initialize", ret, BT_ERROR_INVALID_PARAMETER,
+		"BT_ERROR_INVALID_PARAMETER must be returned when destination parameter is NULL");
 }
 
-static void utc_network_bluetooth_opp_server_deinitialize_n(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_opp_server_deinitialize();
-	dts_check_eq("bt_opp_server_deinitialize", ret, BT_ERROR_NOT_INITIALIZED,
-		     "BT_ERROR_NOT_INITIALIZED must be returned.");
-}
 
 static void utc_network_bluetooth_opp_server_accept_n(void)
 {
 	int ret = BT_ERROR_NONE;
-	ret = bt_opp_server_accept(NULL, NULL, NULL, NULL, NULL);
-	dts_check_eq("bt_opp_server_accept", ret, BT_ERROR_NOT_INITIALIZED, "BT_ERROR_NOT_INITIALIZED must be returned.");
+	ret = bt_opp_server_accept(transfer_progress_cb_for_opp_server,
+						transfer_finished_cb_for_opp_server, NULL, NULL, NULL);
+	dts_check_eq("bt_opp_server_accept", ret, BT_ERROR_INVALID_PARAMETER,
+			"BT_ERROR_NOT_INITIALIZED must be returned.");
 
 }
 
-static void utc_network_bluetooth_opp_server_reject_n(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_opp_server_reject();
-	dts_check_eq("bt_opp_server_reject", ret, BT_ERROR_NOT_INITIALIZED, "BT_ERROR_NOT_INITIALIZED must be returned.");
-}
 
 static void utc_network_bluetooth_opp_server_set_destination_n(void)
 {
 	int ret = BT_ERROR_NONE;
 
+	ret = bt_opp_server_initialize(dest, push_requested_cb_for_opp_server_p,
+			NULL);
+
 	ret = bt_opp_server_set_destination(NULL);
-	dts_check_eq("bt_opp_server_set_destination", ret, BT_ERROR_INVALID_PARAMETER,
-		     "BT_ERROR_INVALID_PARAMETER must be returned destination parameter is NULL");
+	dts_check_eq("bt_opp_server_set_destination", ret,
+	BT_ERROR_INVALID_PARAMETER,
+	"BT_ERROR_INVALID_PARAMETER must be returned destination parameter is NULL");
 }
 
 static void utc_network_bluetooth_opp_server_initialize_by_connection_request_n(void)
@@ -168,7 +184,8 @@ static void utc_network_bluetooth_opp_server_initialize_by_connection_request_n(
 	int ret = BT_ERROR_NONE;
 
 	ret = bt_opp_server_initialize_by_connection_request(NULL, NULL, NULL);
-	dts_check_eq("bt_opp_server_initialize_by_connection_request", ret, BT_ERROR_INVALID_PARAMETER,
-		     "BT_ERROR_INVALID_PARAMETER must be returned destination parameter is NULL");
+	dts_check_eq("bt_opp_server_initialize_by_connection_request", ret,
+	BT_ERROR_INVALID_PARAMETER,
+	"BT_ERROR_INVALID_PARAMETER must be returned destination parameter is NULL");
 
 }
diff --git a/mobile/TC/testcase/utc_network_bluetooth_opp-server_positive.c b/TC/testcase/utc_network_bluetooth_opp-server_positive.c
index fa93272..39efb77 100644..100755
--- a/mobile/TC/testcase/utc_network_bluetooth_opp-server_positive.c
+++ b/TC/testcase/utc_network_bluetooth_opp-server_positive.c
@@ -29,7 +29,7 @@ static void startup(void);
 static void cleanup(void);
 
 static GMainLoop *mainloop;
-char dest[18] = "";
+const char *dest = "/tmp";
 
 void (*tet_startup) (void) = startup;
 void (*tet_cleanup) (void) = cleanup;
@@ -42,17 +42,26 @@ static void utc_network_bluetooth_opp_server_reject_p(void);
 static void utc_network_bluetooth_opp_server_set_destination_p(void);
 
 void push_requested_cb_for_opp_server_p(const char *file, int size, void *user_data);
-void connection_requested_cb_for_opp_server_p(const char *remote_address, void *user_data);
-void adapter_state_changed_cb_for_opp_server_p(int result, bt_adapter_state_e adapter_state, void *user_data);
+void connection_requested_cb_for_opp_server_p(const char *remote_address,
+															void *user_data);
+void adapter_state_changed_cb_for_opp_server_p(int result,
+							bt_adapter_state_e adapter_state, void *user_data);
+void transfer_finished_cb_for_opp_server_p(int result, const char *file,
+											long long size, void *user_data);
+void transfer_progress_cb_for_opp_server_p(int result, const char *file,
+											long long size, void *user_data);
+
+
 gboolean timeout_func(gpointer data);
 
+
 struct tet_testlist tet_testlist[] = {
 	{utc_network_bluetooth_opp_server_initialize_p, POSITIVE_TC_IDX},
 	{utc_network_bluetooth_opp_server_initialize_by_connection_request_p, POSITIVE_TC_IDX},
-	{utc_network_bluetooth_opp_server_deinitialize_p, POSITIVE_TC_IDX},
+	{utc_network_bluetooth_opp_server_set_destination_p, POSITIVE_TC_IDX},
 	{utc_network_bluetooth_opp_server_accept_p, POSITIVE_TC_IDX},
 	{utc_network_bluetooth_opp_server_reject_p, POSITIVE_TC_IDX},
-	{utc_network_bluetooth_opp_server_set_destination_p, POSITIVE_TC_IDX},
+	{utc_network_bluetooth_opp_server_deinitialize_p, POSITIVE_TC_IDX},
 	{NULL, 0},
 };
 
@@ -69,14 +78,16 @@ static void startup(void)
 		tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed");
 	}
 
-	tet_printf("bt_adapter_disable() was called.");
-	ret = bt_adapter_disable();
-	if (ret == BT_ERROR_NONE) {
-		tet_printf("bt_adapter_disable() succeeded.");
-		timeout_id = g_timeout_add(60000, timeout_func, mainloop);
-		g_main_loop_run(mainloop);
-		g_source_remove(timeout_id);
-	} else if (ret == BT_ERROR_NOT_ENABLED) {
+	tet_printf("bt_adapter_enable() was called.");
+			ret = bt_adapter_enable();
+			if (ret == BT_ERROR_NONE) {
+				tet_printf("bt_adapter_enable() succeeded.");
+				timeout_id = g_timeout_add(60000, timeout_func, mainloop);
+				g_main_loop_run(mainloop);
+				g_source_remove(timeout_id);
+			} else if (ret != BT_ERROR_ALREADY_DONE) {
+				tet_printf("DTS may fail because bt_adapter_disable() failed");
+			} else if (ret == BT_ERROR_NOT_ENABLED) {
 		tet_printf("Bluetooth adapter is not enabled.");
 	} else {
 		tet_printf("DTS may fail because bt_adapter_disable() failed");
@@ -89,6 +100,7 @@ static void startup(void)
 	tet_printf("TC start");
 }
 
+
 static void cleanup(void)
 {
 	/* end of TC */
@@ -96,35 +108,42 @@ static void cleanup(void)
 	tet_printf("TC end.");
 }
 
+
 gboolean timeout_func(gpointer data)
 {
 	tet_printf("Callback: Timeout.");
-	g_main_loop_quit((GMainLoop *) data);
+	g_main_loop_quit((GMainLoop *)data);
 	return FALSE;
 }
 
-void adapter_state_changed_cb_for_opp_server_p(int result, bt_adapter_state_e adapter_state, void *user_data)
+
+void adapter_state_changed_cb_for_opp_server_p(int result,
+							bt_adapter_state_e adapter_state, void *user_data)
 {
-	tet_printf("Callback: bt_adapter_state_changed_cb was called.");
-	if (user_data != NULL && !strcmp((char *)user_data, "startup")) {
-		if (adapter_state == BT_ADAPTER_DISABLED && result == BT_ERROR_NONE) {
-			tet_printf("Callback: BT was disabled. DTS will be started.");
-		} else {
-			tet_printf("Callback: BT was not disabled. DTS will be started but DTS may fail.");
-		}
-
-		if (mainloop) {
-			g_main_loop_quit(mainloop);
-		}
-	}
+
 }
 
-void push_requested_cb_for_opp_server_p(const char *file, int size, void *user_data)
+
+void push_requested_cb_for_opp_server_p(const char *file, int size,
+															void *user_data)
 {
 
 }
 
-void connection_requested_cb_for_opp_server_p(const char *remote_address, void *user_data)
+void connection_requested_cb_for_opp_server_p(const char *remote_address,
+															void *user_data)
+{
+
+}
+
+void transfer_progress_cb_for_opp_server_p(int result, const char *file,
+											long long size, void *user_data)
+{
+
+}
+
+void transfer_finished_cb_for_opp_server_p(int result, const char *file,
+											long long size, void *user_data)
 {
 
 }
@@ -133,8 +152,17 @@ static void utc_network_bluetooth_opp_server_initialize_p(void)
 {
 	int ret = BT_ERROR_NONE;
 
-	ret = bt_opp_server_initialize(dest, push_requested_cb_for_opp_server_p, NULL);
-	dts_check_eq("bt_opp_server_initialize", ret, BT_ERROR_NONE, "bt_opp_server_initialize() failed");
+	ret = bt_opp_server_initialize(dest, push_requested_cb_for_opp_server_p,
+									NULL);
+
+	if (ret != BT_ERROR_RESOURCE_BUSY) {
+	dts_check_eq("bt_opp_server_initialize", ret, BT_ERROR_NONE,
+						"bt_opp_server_initialize() failed");
+	} else {
+		dts_check_eq("bt_opp_server_initialize", ret, BT_ERROR_RESOURCE_BUSY,
+				"bt_opp_server_initialize() failed");
+	}
+
 
 }
 
@@ -143,15 +171,19 @@ static void utc_network_bluetooth_opp_server_deinitialize_p(void)
 	int ret = BT_ERROR_NONE;
 
 	ret = bt_opp_server_deinitialize();
-	dts_check_eq("bt_opp_server_deinitialize", ret, BT_ERROR_NONE, "bt_opp_server_deinitialize() failed.");
+	dts_check_eq("bt_opp_server_deinitialize", ret, BT_ERROR_NONE,
+			"bt_opp_server_deinitialize() failed.");
 }
 
 static void utc_network_bluetooth_opp_server_accept_p(void)
 {
 	int ret = BT_ERROR_NONE;
-	int tid = 1;
-	ret = bt_opp_server_accept(NULL, NULL, "dts_name", NULL, &tid);
-	dts_check_eq("bt_opp_server_accept", ret, BT_ERROR_NONE, "bt_opp_server_accept() failed.");
+	int tid = 0;
+	const char *name = "abc";
+	ret = bt_opp_server_accept(transfer_progress_cb_for_opp_server_p,
+			transfer_finished_cb_for_opp_server_p, name, NULL, &tid);
+	dts_check_eq("bt_opp_server_accept", ret,
+			BT_ERROR_NONE, "bt_opp_server_accept() failed.");
 
 }
 
@@ -160,7 +192,8 @@ static void utc_network_bluetooth_opp_server_reject_p(void)
 	int ret = BT_ERROR_NONE;
 
 	ret = bt_opp_server_reject();
-	dts_check_eq("bt_opp_server_reject", ret, BT_ERROR_NONE, "bt_opp_server_reject() failed.");
+	dts_check_eq("bt_opp_server_reject", ret,
+			BT_ERROR_NONE, "bt_opp_server_reject() failed.");
 }
 
 static void utc_network_bluetooth_opp_server_set_destination_p(void)
@@ -168,15 +201,24 @@ static void utc_network_bluetooth_opp_server_set_destination_p(void)
 	int ret = BT_ERROR_NONE;
 
 	ret = bt_opp_server_set_destination(dest);
-	dts_check_eq("bt_opp_server_set_destination", ret, BT_ERROR_NONE, "bt_opp_server_destination() failed");
+	dts_check_eq("bt_opp_server_set_destination", ret,
+			BT_ERROR_NONE, "bt_opp_server_destination() failed");
 }
 
 static void utc_network_bluetooth_opp_server_initialize_by_connection_request_p(void)
 {
 	int ret = BT_ERROR_NONE;
 
-	ret = bt_opp_server_initialize_by_connection_request(dest, connection_requested_cb_for_opp_server_p, NULL);
-	dts_check_eq("bt_opp_server_initialize_by_connection_request", ret, BT_ERROR_NONE,
-		     "bt_opp_server_initialize_by_connection_request() failed");
+	ret = bt_opp_server_initialize_by_connection_request(dest,
+				connection_requested_cb_for_opp_server_p, NULL);
+	dts_check_eq("bt_opp_server_initialize_by_connection_request", ret,
+				BT_ERROR_NONE,
+				"bt_opp_server_initialize_by_connection_request() failed");
 
 }
+
+
+
+
+
+
diff --git a/mobile/TC/testcase/utc_network_bluetooth_pan_negative.c b/TC/testcase/utc_network_bluetooth_pan_negative.c
index a5a0712..ec9db0c 100644
--- a/mobile/TC/testcase/utc_network_bluetooth_pan_negative.c
+++ b/TC/testcase/utc_network_bluetooth_pan_negative.c
@@ -25,17 +25,19 @@ void (*tet_cleanup) (void) = cleanup;
 static void utc_network_bluetooth_nap_set_connection_state_changed_n(void);
 static void utc_network_bluetooth_panu_set_connection_state_changed_n(void);
 static void utc_network_bluetooth_panu_connect_n(void);
+static void utc_network_bluetooth_nap_disconnect_n(void);
 static void utc_network_bluetooth_panu_disconnect_n(void);
 
 void adapter_state_changed_cb_for_pan_n(int result,
-					bt_adapter_state_e adapter_state,
-					void *user_data);
+						bt_adapter_state_e adapter_state, void *user_data);
 gboolean timeout_func(gpointer data);
 
+
 struct tet_testlist tet_testlist[] = {
 	{utc_network_bluetooth_nap_set_connection_state_changed_n, NEGATIVE_TC_IDX},
 	{utc_network_bluetooth_panu_set_connection_state_changed_n, NEGATIVE_TC_IDX},
 	{utc_network_bluetooth_panu_connect_n, NEGATIVE_TC_IDX},
+	{utc_network_bluetooth_nap_disconnect_n, NEGATIVE_TC_IDX},
 	{utc_network_bluetooth_panu_disconnect_n, NEGATIVE_TC_IDX},
 	{NULL, 0},
 };
@@ -73,6 +75,7 @@ static void startup(void)
 	tet_printf("TC start");
 }
 
+
 static void cleanup(void)
 {
 	/* end of TC */
@@ -80,13 +83,17 @@ static void cleanup(void)
 	tet_printf("TC end.");
 }
 
+
 gboolean timeout_func(gpointer data)
 {
 	tet_printf("Callback: Timeout.");
-	g_main_loop_quit((GMainLoop *) data);
+	g_main_loop_quit((GMainLoop *)data);
 	return FALSE;
 }
 
+
+
+
 /**
  * @brief Negative test case of bt_nap_set_connection_state_changed_cb()
  */
@@ -131,11 +138,22 @@ static void utc_network_bluetooth_panu_connect_n(void)
 	int ret = BT_ERROR_NONE;
 	ret = bt_panu_connect(NULL, BT_PANU_SERVICE_TYPE_NAP);
 	dts_check_eq("bt_panu_connect", ret, BT_ERROR_INVALID_PARAMETER,
-		     "bt_panu_connect() failed.");
+			"bt_panu_connect() failed.");
 
 }
 
 /**
+ * @brief Negative test case of bt_nap_disconnect()
+ */
+static void utc_network_bluetooth_nap_disconnect_n(void)
+{
+	int ret = BT_ERROR_NONE;
+	ret = bt_nap_disconnect(NULL);
+	dts_check_eq("bt_nap_disconnect", ret, BT_ERROR_INVALID_PARAMETER,
+			"bt_nap_disconnect() failed.");
+
+}
+/**
  * @brief Negative test case of bt_panu_disconnect()
  */
 static void utc_network_bluetooth_panu_disconnect_n(void)
@@ -143,6 +161,6 @@ static void utc_network_bluetooth_panu_disconnect_n(void)
 	int ret = BT_ERROR_NONE;
 	ret = bt_panu_disconnect(NULL);
 	dts_check_eq("bt_panu_disconnect", ret, BT_ERROR_INVALID_PARAMETER,
-		     "bt_panu_disconnect() failed.");
+			"bt_panu_disconnect() failed.");
 
 }
diff --git a/mobile/TC/testcase/utc_network_bluetooth_pan_positive.c b/TC/testcase/utc_network_bluetooth_pan_positive.c
index 28d5632..4526508 100644..100755
--- a/mobile/TC/testcase/utc_network_bluetooth_pan_positive.c
+++ b/TC/testcase/utc_network_bluetooth_pan_positive.c
@@ -5,7 +5,7 @@
  *      Author: mrinal.m
  */
 
-#include "bluetooth.h"
+#include <bluetooth.h>
 #include <tet_api.h>
 #include <glib.h>
 
@@ -30,12 +30,13 @@ static void utc_network_bluetooth_nap_unset_connection_state_changed_p(void);
 static void utc_network_bluetooth_panu_set_connection_state_changed_p(void);
 static void utc_network_bluetooth_panu_unset_connection_state_changed_p(void);
 static void utc_network_bluetooth_panu_connect_p(void);
+static void utc_network_bluetooth_nap_disconnect_p(void);
 static void utc_network_bluetooth_panu_disconnect_p(void);
 
 void connection_state_changed_cb_for_nap_p(bool connected,
-					   const char *remote_address,
-					   const char *interface_name,
-					   void *user_data);
+						const char *remote_address,
+						const char *interface_name,
+						void *user_data);
 void connection_state_changed_cb_for_panu_p(int result,
 						bool connected,
 						const char *remote_address,
@@ -43,8 +44,8 @@ void connection_state_changed_cb_for_panu_p(int result,
 						void *user_data);
 
 void adapter_state_changed_cb_for_pan_p(int result,
-					bt_adapter_state_e adapter_state,
-					void *user_data);
+						bt_adapter_state_e adapter_state,
+						void *user_data);
 gboolean timeout_func(gpointer data);
 
 struct tet_testlist tet_testlist[] = {
@@ -56,10 +57,12 @@ struct tet_testlist tet_testlist[] = {
 	{utc_network_bluetooth_panu_connect_p, POSITIVE_TC_IDX},
 	{utc_network_bluetooth_panu_set_connection_state_changed_p, POSITIVE_TC_IDX},
 	{utc_network_bluetooth_panu_unset_connection_state_changed_p, POSITIVE_TC_IDX},
+	{utc_network_bluetooth_nap_disconnect_p, POSITIVE_TC_IDX},
 	{utc_network_bluetooth_panu_disconnect_p, POSITIVE_TC_IDX},
 	{NULL, 0},
 };
 
+
 static void startup(void)
 {
 	int ret = BT_ERROR_NONE;
@@ -118,18 +121,18 @@ void adapter_state_changed_cb_for_pan_p(int result,
 }
 
 void connection_state_changed_cb_for_nap_p(bool connected,
-					   const char *remote_address,
-					   const char *interface_name,
-					   void *user_data)
+					const char *remote_address,
+					const char *interface_name,
+					void *user_data)
 {
 
 }
 
 void connection_state_changed_cb_for_panu_p(int result,
-					    bool connected,
-					    const char *remote_address,
-					    bt_panu_service_type_e type,
-					    void *user_data)
+					bool connected,
+					const char *remote_address,
+					bt_panu_service_type_e type,
+					void *user_data)
 {
 
 }
@@ -145,7 +148,7 @@ static void utc_network_bluetooth_nap_activate_p(void)
 		dts_check_eq("bt_nap_activate", ret, BT_ERROR_NONE, "bt_nap_activate() failed.");
 	} else {
 		dts_check_eq("bt_nap_activate", ret, BT_ERROR_ALREADY_DONE,
-			     "bt_nap_activate() failed.");
+			"bt_nap_activate() failed.");
 	}
 }
 
@@ -156,7 +159,9 @@ static void utc_network_bluetooth_nap_deactivate_p(void)
 {
 	int ret = BT_ERROR_NONE;
 	ret = bt_nap_deactivate();
-	dts_check_eq("bt_nap_deactivate", ret, BT_ERROR_NONE, "bt_nap_deactivate() failed.");
+	dts_check_eq("bt_nap_deactivate", ret, BT_ERROR_NONE,
+			"bt_nap_deactivate() failed.");
+
 }
 
 /**
@@ -167,7 +172,7 @@ static void utc_network_bluetooth_nap_disconnect_all_p(void)
 	int ret = BT_ERROR_NONE;
 	ret = bt_nap_disconnect_all();
 	dts_check_eq("bt_nap_disconnect_all", ret, BT_ERROR_NONE,
-		     "bt_nap_disconnect_all() failed.");
+			"bt_nap_disconnect_all() failed.");
 }
 
 /**
@@ -178,9 +183,10 @@ static void utc_network_bluetooth_nap_set_connection_state_changed_p(void)
 	int ret = BT_ERROR_NONE;
 	ret = bt_nap_set_connection_state_changed_cb(connection_state_changed_cb_for_nap_p, NULL);
 	dts_check_eq("bt_nap_set_connection_state_changed_cb", ret, BT_ERROR_NONE,
-		     "bt_nap_set_connection_state_changed_cb() failed.");
+			"bt_nap_set_connection_state_changed_cb() failed.");
 }
 
+
 /**
  * @brief Positive test case of bt_nap_unset_connection_state_changed_cb()
 */
@@ -189,20 +195,24 @@ static void utc_network_bluetooth_nap_unset_connection_state_changed_p(void)
 	int ret = BT_ERROR_NONE;
 	ret = bt_nap_unset_connection_state_changed_cb();
 	dts_check_eq("bt_nap_unset_connection_state_changed_cb", ret, BT_ERROR_NONE,
-		     "bt_nap_unset_connection_state_changed_cb() failed.");
+			"bt_nap_unset_connection_state_changed_cb() failed.");
 }
 
+
 /**
  * @brief Positive test case of bt_panu_set_connection_state_changed_cb()
 */
 static void utc_network_bluetooth_panu_set_connection_state_changed_p(void)
 {
 	int ret = BT_ERROR_NONE;
+
 	ret = bt_panu_set_connection_state_changed_cb(connection_state_changed_cb_for_panu_p, NULL);
 	dts_check_eq("bt_panu_set_connection_state_changed_cb", ret, BT_ERROR_NONE,
-		     "bt_panu_set_connection_state_changed_cb() failed.");
+			"bt_panu_set_connection_state_changed_cb() failed.");
+
 }
 
+
 /**
  * @brief Positive test case of bt_panu_unset_connection_state_changed_cb()
 */
@@ -211,7 +221,8 @@ static void utc_network_bluetooth_panu_unset_connection_state_changed_p(void)
 	int ret = BT_ERROR_NONE;
 	ret = bt_panu_unset_connection_state_changed_cb();
 	dts_check_eq("bt_panu_unset_connection_state_changed_cb", ret, BT_ERROR_NONE,
-		     "bt_panu_unset_connection_state_changed_cb() failed.");
+			"bt_panu_unset_connection_state_changed_cb() failed.");
+
 }
 
 /**
@@ -222,7 +233,22 @@ static void utc_network_bluetooth_panu_connect_p(void)
 	int ret = BT_ERROR_NONE;
 	const char *remote_address = "00:00:00:00:00:00";
 	ret = bt_panu_connect(remote_address, BT_PANU_SERVICE_TYPE_NAP);
-	dts_check_eq("bt_panu_connect", ret, BT_ERROR_NONE, "bt_panu_connect() failed.");
+	dts_check_eq("bt_panu_connect", ret, BT_ERROR_NONE,
+			"bt_panu_connect() failed.");
+
+}
+
+/**
+ * @brief Positive test case of bt_nap_disconnect()
+*/
+static void utc_network_bluetooth_nap_disconnect_p(void)
+{
+	int ret = BT_ERROR_NONE;
+	const char *remote_address = "00:00:00:00:00:00";
+	ret = bt_nap_disconnect(remote_address);
+	dts_check_eq("bt_nap_disconnect", ret, BT_ERROR_NONE,
+			"bt_nap_disconnect() failed.");
+
 }
 
 /**
@@ -233,5 +259,7 @@ static void utc_network_bluetooth_panu_disconnect_p(void)
 	int ret = BT_ERROR_NONE;
 	const char *remote_address = "00:00:00:00:00:00";
 	ret = bt_panu_disconnect(remote_address);
-	dts_check_eq("bt_panu_disconnect", ret, BT_ERROR_NONE, "bt_panu_disconnect() failed.");
+	dts_check_eq("bt_panu_disconnect", ret, BT_ERROR_NONE,
+			"bt_panu_disconnect() failed.");
+
 }
diff --git a/mobile/TC/testcase/utc_network_bluetooth_service_search_negative.c b/TC/testcase/utc_network_bluetooth_service_search_negative.c
index 1e83157..ce4dd7d 100644
--- a/mobile/TC/testcase/utc_network_bluetooth_service_search_negative.c
+++ b/TC/testcase/utc_network_bluetooth_service_search_negative.c
@@ -39,8 +39,8 @@ static void utc_network_bluetooth_service_search_n(void);
 static void utc_network_bluetooth_service_search_cancel_n(void);
 
 void adapter_state_changed_cb_for_service_search_n(int result,
-						   bt_adapter_state_e adapter_state,
-						   void *user_data);
+							bt_adapter_state_e adapter_state,
+							void *user_data);
 gboolean timeout_func(gpointer data);
 
 struct tet_testlist tet_testlist[] = {
@@ -84,6 +84,7 @@ static void startup(void)
 	tet_printf("TC start");
 }
 
+
 static void cleanup(void)
 {
 	/* end of TC */
@@ -91,6 +92,7 @@ static void cleanup(void)
 	tet_printf("TC end.");
 }
 
+
 gboolean timeout_func(gpointer data)
 {
 	tet_printf("Callback: Timeout.");
@@ -98,13 +100,13 @@ gboolean timeout_func(gpointer data)
 	return FALSE;
 }
 
+
 /**
  * @brief Callback funtions
  */
 void adapter_state_changed_cb_for_service_search_n(int result,
-						   bt_adapter_state_e
-						   adapter_state,
-						   void *user_data)
+							bt_adapter_state_e adapter_state,
+							void *user_data)
 {
 	tet_printf("Callback: bt_adapter_state_changed_cb was called.");
 	if (user_data != NULL && !strcmp((char *)user_data, "startup")) {
@@ -129,8 +131,8 @@ static void utc_network_bluetooth_service_search_set_cb_n(void)
 
 	ret = bt_device_set_service_searched_cb(NULL, NULL);
 	dts_check_eq("bt_device_set_service_searched_cb", ret,
-		     BT_ERROR_INVALID_PARAMETER,
-		     "BT_ERROR_INVALID_PARAMETER must be returned when callback parameter is NULL");
+			BT_ERROR_INVALID_PARAMETER,
+			"BT_ERROR_INVALID_PARAMETER must be returned when callback parameter is NULL");
 }
 
 /**
@@ -142,13 +144,13 @@ static void utc_network_bluetooth_service_search_unset_cb_n(void)
 
 	if (bt_deinitialize() != BT_ERROR_NONE) {
 		dts_fail("bt_device_unset_service_searched_cb",
-			 "bt_deinitialize() failed.");
+				"bt_deinitialize() failed.");
 	}
 
 	ret = bt_device_unset_service_searched_cb();
 	dts_check_eq("bt_device_unset_service_searched_cb", ret,
-		     BT_ERROR_NOT_INITIALIZED,
-		     "BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized.");
+			BT_ERROR_NOT_INITIALIZED,
+			"BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized.");
 }
 
 /**
@@ -160,8 +162,8 @@ static void utc_network_bluetooth_service_search_n(void)
 
 	ret = bt_device_start_service_search(NULL);
 	dts_check_eq("bt_device_start_service_search", ret,
-		     BT_ERROR_INVALID_PARAMETER,
-		     "BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL");
+			BT_ERROR_INVALID_PARAMETER,
+			"BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL");
 }
 
 /**
@@ -172,7 +174,6 @@ static void utc_network_bluetooth_service_search_cancel_n(void)
 	int ret = BT_ERROR_NONE;
 
 	ret = bt_device_cancel_service_search();
-	dts_check_eq("bt_device_cancel_service_search", ret,
-		     BT_ERROR_NOT_ENABLED,
-		     "BT_ERROR_NOT_ENABLED must be returned when BT is not enabled");
+	dts_check_eq("bt_device_cancel_service_search", ret, BT_ERROR_NOT_ENABLED,
+		"BT_ERROR_NOT_ENABLED must be returned when BT is not enabled");
 }
diff --git a/mobile/TC/testcase/utc_network_bluetooth_service_search_positive.c b/TC/testcase/utc_network_bluetooth_service_search_positive.c
index eab85ed..b0c5e70 100644..100755
--- a/mobile/TC/testcase/utc_network_bluetooth_service_search_positive.c
+++ b/TC/testcase/utc_network_bluetooth_service_search_positive.c
@@ -19,6 +19,8 @@
 #include <stdlib.h>
 #include <stdbool.h>
 #include <glib.h>
+
+#define CONFIG_FILE_PATH "/opt/home/capi-network-bluetooth/tetware.conf"
 enum {
 	POSITIVE_TC_IDX = 0x01,
 	NEGATIVE_TC_IDX,
@@ -31,7 +33,7 @@ void (*tet_startup) (void) = startup;
 void (*tet_cleanup) (void) = cleanup;
 
 char target_name[128] = "dts_test";
-char target_address[18] = "";
+char *target_address;
 bool callback_result = false;
 bool discovery_result = false;
 bool bonding_result = false;
@@ -44,18 +46,14 @@ static void utc_network_bluetooth_service_search_unset_cb_p(void);
 
 gboolean timeout_func(gpointer data);
 void adapter_state_changed_cb_for_service_search_p(int result,
-						   bt_adapter_state_e adapter_state,
-						   void *user_data);
+							bt_adapter_state_e adapter_state, void *user_data);
 void device_discovery_state_changed_cb_for_service_search_p(int result,
-							    bt_adapter_device_discovery_state_e discovery_state,
-							    bt_adapter_device_discovery_info_s *discovery_info,
-							    void *user_data);
+						bt_adapter_device_discovery_state_e discovery_state,
+		bt_adapter_device_discovery_info_s *discovery_info, void *user_data);
 void service_searched_cb_for_service_search_p(int result,
-					      bt_device_sdp_info_s *sdp_info,
-					      void *user_data);
+							bt_device_sdp_info_s *sdp_info, void *user_data);
 void device_bonded_cb_for_service_search_p(int result,
-					   bt_device_info_s *device_info,
-					   void *user_data);
+							bt_device_info_s *device_info, void *user_data);
 void device_unbonded_cb(int result, char *remote_address, void *user_data);
 
 struct tet_testlist tet_testlist[] = {
@@ -66,11 +64,51 @@ struct tet_testlist tet_testlist[] = {
 	{NULL, 0},
 };
 
+int get_value_from_file(void)
+{
+	FILE *fp;
+	char *token;
+	char buf[100];
+
+	fp = fopen(CONFIG_FILE_PATH, "r");
+	if (fp == NULL) {
+		tet_printf("Default configuration is used\n");
+		return -1;
+	}
+	while (fgets(buf, sizeof(buf), fp)) {
+		if (buf[0] == '#' || buf[0] == '\n')
+			continue;
+
+		token = strrchr(buf, '\n');
+		if (token == NULL) {
+			tet_printf("g_conf is too long\n");
+			break;
+		}
+		*token = '\0';
+
+		token = strtok(buf, "=");
+		if (token == NULL) {
+			continue;
+		}
+		if (strcasecmp(token, "BT_ADDR_MOBILE") == 0) {
+			token = strtok(NULL, "=");
+			target_address = strdup(token);
+			fclose(fp);
+			return 0;
+		}
+	}
+	return -1;
+}
+
 static void startup(void)
 {
 	bt_error_e ret = BT_ERROR_NONE;
 	int timeout_id = 0;
 
+	if(get_value_from_file() == -1) {
+		tet_printf("Failed to read.");
+	}
+
 	/* start of TC */
 	callback_result = false;
 	discovery_result = false;
@@ -82,7 +120,8 @@ static void startup(void)
 		tet_printf("bt_adapter_set_state_changed_cb() failed.");
 	}
 
-	if (bt_adapter_set_device_discovery_state_changed_cb(device_discovery_state_changed_cb_for_service_search_p, "startup") != BT_ERROR_NONE) {
+	if (bt_adapter_set_device_discovery_state_changed_cb
+		(device_discovery_state_changed_cb_for_service_search_p, "startup") != BT_ERROR_NONE) {
 		tet_printf("bt_adapter_set_device_discovery_state_changed_cb() failed.");
 	}
 
@@ -127,6 +166,7 @@ static void startup(void)
 	tet_printf("TC start.");
 }
 
+
 static void cleanup(void)
 {
 	/* end of TC */
@@ -144,6 +184,7 @@ static void cleanup(void)
 	tet_printf("TC end.");
 }
 
+
 gboolean timeout_func(gpointer data)
 {
 	tet_printf("[%s] Callback: Timeout.", __FUNCTION__);
@@ -151,6 +192,7 @@ gboolean timeout_func(gpointer data)
 	return FALSE;
 }
 
+
 /**
  * @brief Callback funtions
  */
@@ -165,8 +207,7 @@ void device_unbonded_cb(int result, char *remote_address, void *user_data)
 }
 
 void adapter_state_changed_cb_for_service_search_p(int result,
-						   bt_adapter_state_e adapter_state,
-						   void *user_data)
+						bt_adapter_state_e adapter_state, void *user_data)
 {
 	tet_printf("Callback: bt_adapter_state_changed_cb() was called");
 	if (user_data != NULL && !strcmp((char *)user_data, "startup")) {
@@ -183,11 +224,8 @@ void adapter_state_changed_cb_for_service_search_p(int result,
 }
 
 void device_discovery_state_changed_cb_for_service_search_p(int result,
-							    bt_adapter_device_discovery_state_e
-							    discovery_state,
-							    bt_adapter_device_discovery_info_s
-							    * discovery_info,
-							    void *user_data)
+						bt_adapter_device_discovery_state_e discovery_state,
+		bt_adapter_device_discovery_info_s *discovery_info, void *user_data)
 {
 	tet_printf("Callback: bt_adapter_device_discovery_state_changed_cb() was called");
 	if (user_data != NULL && !strcmp((char *)user_data, "startup")) {
@@ -213,8 +251,8 @@ void device_discovery_state_changed_cb_for_service_search_p(int result,
 }
 
 void service_searched_cb_for_service_search_p(int result,
-					      bt_device_sdp_info_s *sdp_info,
-					      void *user_data)
+							bt_device_sdp_info_s *sdp_info,
+							void *user_data)
 {
 	int i = 0;
 
@@ -244,8 +282,7 @@ void service_searched_cb_for_service_search_p(int result,
 }
 
 void device_bonded_cb_for_service_search_p(int result,
-					   bt_device_info_s *device_info,
-					   void *user_data)
+					bt_device_info_s *device_info, void *user_data)
 {
 	if (user_data != NULL && !strcmp((char *)user_data, "startup")) {
 		if (device_info->remote_address != NULL && !strcmp(device_info->remote_address, target_address)) {
@@ -288,7 +325,7 @@ static void utc_network_bluetooth_service_search_set_cb_p(void)
 	}
 
 	dts_check_eq("bt_device_set_service_searched_cb", ret, BT_ERROR_NONE,
-		     "bt_device_set_service_searched_cb() failed.");
+		"bt_device_set_service_searched_cb() failed.");
 }
 
 /**
@@ -297,24 +334,25 @@ static void utc_network_bluetooth_service_search_set_cb_p(void)
 static void utc_network_bluetooth_service_search_p(void)
 {
 	int timeout_id = 0;
+	int ret = BT_ERROR_NONE;
 
 	if (discovery_result != true) {
-		dts_fail("bt_device_start_service_search",
-			 "device discovery failed.");
+		tet_printf("bt_device_start_service_search failed.");
 	}
 
 	callback_result = false;
-	if (bt_device_start_service_search(target_address) == BT_ERROR_NONE) {
+	ret = bt_device_start_service_search(target_address);
+	if (ret == BT_ERROR_NONE) {
 		tet_printf("bt_device_start_service_search() succeeded.");
 		tet_printf("service_searched_cb_for_service_search_p() will be called.");
 		timeout_id = g_timeout_add(60000, timeout_func, mainloop);
 		g_main_loop_run(mainloop);
 		g_source_remove(timeout_id);
-		dts_check_eq("bt_device_start_service_search", callback_result,
-			     true, "Service search failed.");
+		dts_check_eq("bt_device_start_service_search", ret, BT_ERROR_NONE,
+												"bt_device_start_service_search() failed.");
 	} else {
 		dts_fail("bt_device_start_service_search",
-			 "bt_device_start_service_search() failed.");
+				"bt_device_start_service_search() failed.");
 	}
 }
 
@@ -324,32 +362,34 @@ static void utc_network_bluetooth_service_search_p(void)
 static void utc_network_bluetooth_service_search_cancel_p(void)
 {
 	int timeout_id = 0;
+	int ret = BT_ERROR_NONE;
 
 	if (discovery_result != true) {
-		dts_fail("bt_device_cancel_service_search",
-			 "device discovery failed.");
+		tet_printf("t_device_cancel_service_search failed.");
 	}
 
 	callback_result = false;
 	if (bt_device_start_service_search(target_address) != BT_ERROR_NONE) {
-		dts_fail("bt_device_cancel_service_search",
-			 "bt_device_start_service_search() failed.");
+		tet_printf("t_device_start_service_search failed.");
+
 	} else {
 		tet_printf("bt_device_cancel_service_search",
-			   "bt_device_start_service_search() succeeded.");
+				"bt_device_start_service_search() succeeded.");
 	}
 
-	if (bt_device_cancel_service_search() == BT_ERROR_NONE) {
+    ret = bt_device_cancel_service_search();
+	if (ret == BT_ERROR_NONE) {
 		tet_printf("bt_device_cancel_service_search() succeeded.");
 		tet_printf("service_searched_cb_for_service_search_p() will be called.");
 		timeout_id = g_timeout_add(60000, timeout_func, mainloop);
 		g_main_loop_run(mainloop);
 		g_source_remove(timeout_id);
-		dts_check_eq("bt_device_cancel_service_search", callback_result,
-			     true, "Cancellation of service search failed.");
+		dts_check_eq("bt_device_cancel_service_search", ret, BT_ERROR_NONE,
+				"bt_device_cancel_service_search() failed.");
+
 	} else {
 		dts_fail("bt_device_cancel_service_search",
-			 "bt_device_cancel_service_search() failed.");
+				"bt_device_cancel_service_search() failed.");
 	}
 }
 
@@ -362,5 +402,5 @@ static void utc_network_bluetooth_service_search_unset_cb_p(void)
 
 	ret = bt_device_unset_service_searched_cb();
 	dts_check_eq("bt_device_unset_service_searched_cb", ret, BT_ERROR_NONE,
-		     "bt_device_set_service_searched_cb() failed.");
+		"bt_device_set_service_searched_cb() failed.");
 }
diff --git a/mobile/TC/testcase/utc_network_bluetooth_socket_negative.c b/TC/testcase/utc_network_bluetooth_socket_negative.c
index 9e3f490..dea118f 100644
--- a/mobile/TC/testcase/utc_network_bluetooth_socket_negative.c
+++ b/TC/testcase/utc_network_bluetooth_socket_negative.c
@@ -45,19 +45,18 @@ static void utc_network_bluetooth_socket_disconnect_rfcomm_n(void);
 static void utc_network_bluetooth_socket_send_data_n(void);
 
 void adapter_state_changed_cb_for_device_negative(int result,
-						  bt_adapter_state_e adapter_state,
-						  void *user_data);
+					bt_adapter_state_e adapter_state, void *user_data);
 gboolean timeout_func(gpointer data);
 
 struct tet_testlist tet_testlist[] = {
-	{utc_network_bluetooth_socket_set_data_received_cb_n, NEGATIVE_TC_IDX},
-	{utc_network_bluetooth_socket_set_connection_state_changed_cb_n, NEGATIVE_TC_IDX},
 	{utc_network_bluetooth_socket_create_rfcomm_n, NEGATIVE_TC_IDX},
-	{utc_network_bluetooth_socket_destroy_rfcomm_n, NEGATIVE_TC_IDX},
+	{utc_network_bluetooth_socket_set_connection_state_changed_cb_n, NEGATIVE_TC_IDX},
 	{utc_network_bluetooth_socket_listen_and_accept_rfcomm_n, NEGATIVE_TC_IDX},
+	{utc_network_bluetooth_socket_set_data_received_cb_n, NEGATIVE_TC_IDX},
 	{utc_network_bluetooth_socket_connect_rfcomm_n, NEGATIVE_TC_IDX},
-	{utc_network_bluetooth_socket_disconnect_rfcomm_n, NEGATIVE_TC_IDX},
 	{utc_network_bluetooth_socket_send_data_n, NEGATIVE_TC_IDX},
+	{utc_network_bluetooth_socket_disconnect_rfcomm_n, NEGATIVE_TC_IDX},
+	{utc_network_bluetooth_socket_destroy_rfcomm_n, NEGATIVE_TC_IDX},
 	{utc_network_bluetooth_socket_unset_data_received_cb_n, NEGATIVE_TC_IDX},
 	{utc_network_bluetooth_socket_unset_connection_state_changed_cb_n, NEGATIVE_TC_IDX},
 	{NULL, 0},
@@ -114,8 +113,8 @@ gboolean timeout_func(gpointer data)
  * @brief Callback funtions
  */
 void adapter_state_changed_cb_for_device_negative(int result,
-						  bt_adapter_state_e adapter_state,
-						  void *user_data)
+							bt_adapter_state_e adapter_state,
+							void *user_data)
 {
 	tet_printf("Callback: bt_adapter_state_changed_cb was called.");
 	if (user_data != NULL && !strcmp((char *)user_data, "startup")) {
@@ -131,6 +130,8 @@ void adapter_state_changed_cb_for_device_negative(int result,
 	}
 }
 
+
+
 /**
  * @brief Negative test case of bt_socket_set_data_received_cb()
  */
@@ -140,8 +141,8 @@ static void utc_network_bluetooth_socket_set_data_received_cb_n(void)
 
 	ret = bt_socket_set_data_received_cb(NULL, NULL);
 	dts_check_eq("bt_socket_set_data_received_cb", ret,
-		     BT_ERROR_INVALID_PARAMETER,
-		     "BT_ERROR_INVALID_PARAMETER must be returned when callback parameter is NULL");
+				BT_ERROR_INVALID_PARAMETER,
+				"BT_ERROR_INVALID_PARAMETER must be returned when callback parameter is NULL");
 }
 
 /**
@@ -153,8 +154,8 @@ static void utc_network_bluetooth_socket_set_connection_state_changed_cb_n(void)
 
 	ret = bt_socket_set_connection_state_changed_cb(NULL, NULL);
 	dts_check_eq("bt_socket_set_connection_state_changed_cb", ret,
-		     BT_ERROR_INVALID_PARAMETER,
-		     "BT_ERROR_INVALID_PARAMETER must be returned when callback parameter is NULL");
+			BT_ERROR_INVALID_PARAMETER,
+			"BT_ERROR_INVALID_PARAMETER must be returned when callback parameter is NULL");
 }
 
 /**
@@ -166,13 +167,13 @@ static void utc_network_bluetooth_socket_unset_data_received_cb_n(void)
 
 	if (bt_deinitialize() != BT_ERROR_NONE) {
 		dts_fail("bt_socket_unset_data_received_cb",
-			 "bt_deinitialize() failed.");
+				"bt_deinitialize() failed.");
 	}
 
 	ret = bt_socket_unset_data_received_cb();
 	dts_check_eq("bt_socket_unset_data_received_cb", ret,
-		     BT_ERROR_NOT_INITIALIZED,
-		     "BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized.");
+			BT_ERROR_NOT_INITIALIZED,
+			"BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized.");
 }
 
 /**
@@ -184,8 +185,8 @@ static void utc_network_bluetooth_socket_unset_connection_state_changed_cb_n(voi
 
 	ret = bt_socket_unset_connection_state_changed_cb();
 	dts_check_eq("bt_socket_unset_connection_state_changed_cb", ret,
-		     BT_ERROR_NOT_INITIALIZED,
-		     "BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized.");
+			BT_ERROR_NOT_INITIALIZED,
+			"BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized.");
 }
 
 /**
@@ -197,7 +198,7 @@ static void utc_network_bluetooth_socket_create_rfcomm_n(void)
 
 	ret = bt_socket_create_rfcomm(NULL, NULL);
 	dts_check_eq("bt_socket_create_rfcomm", ret, BT_ERROR_INVALID_PARAMETER,
-		     "BT_ERROR_INVALID_PARAMETER must be returned when port_uuid parameter is NULL");
+		"BT_ERROR_INVALID_PARAMETER must be returned when port_uuid parameter is NULL");
 }
 
 /**
@@ -207,12 +208,13 @@ static void utc_network_bluetooth_socket_destroy_rfcomm_n(void)
 {
 	int ret = BT_ERROR_NONE;
 
-	ret = bt_socket_destroy_rfcomm(-1);
+	ret = bt_socket_destroy_rfcomm(NULL);
 	dts_check_eq("bt_socket_listen_and_accept_rfcomm", ret,
-		     BT_ERROR_INVALID_PARAMETER,
-		     "BT_ERROR_INVALID_PARAMETER must be returned when socket_fd is below 0");
+			BT_ERROR_NOT_ENABLED,
+		"BT_ERROR_INVALID_PARAMETER must be returned when socket_fd is below 0");
 }
 
+
 /**
  * @brief Negative test case of bt_socket_listen_and_accept_rfcomm()
  */
@@ -222,8 +224,8 @@ static void utc_network_bluetooth_socket_listen_and_accept_rfcomm_n(void)
 
 	ret = bt_socket_listen_and_accept_rfcomm(1, 1);
 	dts_check_eq("bt_socket_listen_and_accept_rfcomm", ret,
-		     BT_ERROR_NOT_ENABLED,
-		     "BT_ERROR_NOT_ENABLED must be returned when BT is not enabled");
+			BT_ERROR_NOT_ENABLED,
+			"BT_ERROR_NOT_ENABLED must be returned when BT is not enabled");
 }
 
 /**
@@ -232,12 +234,12 @@ static void utc_network_bluetooth_socket_listen_and_accept_rfcomm_n(void)
 static void utc_network_bluetooth_socket_connect_rfcomm_n(void)
 {
 	int ret = BT_ERROR_NONE;
-	char *address = "";
+	char *address = "00:02:79:AC:7D:FD";
 	char *uuid = "";
 
 	ret = bt_socket_connect_rfcomm(address, uuid);
 	dts_check_eq("bt_socket_connect_rfcomm", ret, BT_ERROR_NOT_ENABLED,
-		     "BT_ERROR_NOT_ENABLED must be returned when BT is not enabled");
+			"BT_ERROR_NOT_ENABLED must be returned when BT is not enabled");
 }
 
 /**
@@ -249,7 +251,7 @@ static void utc_network_bluetooth_socket_disconnect_rfcomm_n(void)
 
 	ret = bt_socket_disconnect_rfcomm(-1);
 	dts_check_eq("bt_socket_disconnect_rfcomm", ret, BT_ERROR_NOT_ENABLED,
-		     "BT_ERROR_NOT_ENABLED must be returned when BT is not enabled");
+			"BT_ERROR_NOT_ENABLED must be returned when BT is not enabled");
 }
 
 /**
@@ -262,5 +264,5 @@ static void utc_network_bluetooth_socket_send_data_n(void)
 
 	ret = bt_socket_send_data(1, data, sizeof(data));
 	dts_check_eq("bt_socket_send_data", ret, BT_ERROR_NOT_ENABLED,
-		     "BT_ERROR_NOT_ENABLED must be returned when BT is not enabled");
+			"BT_ERROR_NOT_ENABLED must be returned when BT is not enabled");
 }
diff --git a/mobile/TC/testcase/utc_network_bluetooth_socket_positive.c b/TC/testcase/utc_network_bluetooth_socket_positive.c
index 5754b4f..acaf2f9 100644..100755
--- a/mobile/TC/testcase/utc_network_bluetooth_socket_positive.c
+++ b/TC/testcase/utc_network_bluetooth_socket_positive.c
@@ -19,6 +19,9 @@
 #include <stdlib.h>
 #include <stdbool.h>
 #include <glib.h>
+
+#define CONFIG_FILE_PATH "/opt/home/capi-network-bluetooth/tetware.conf"
+
 enum {
 	POSITIVE_TC_IDX = 0x01,
 	NEGATIVE_TC_IDX,
@@ -32,7 +35,7 @@ void (*tet_cleanup) (void) = cleanup;
 
 const char target_name[128] = "dts_test";
 const char *rfcomm_test_uuid_spp = "00001101-0000-1000-8000-00805F9B34FB";
-char target_address[18] = "";
+char *target_address;
 int socket_fd = 0;
 bool callback_result = false;
 bool discovery_result = false;
@@ -54,41 +57,78 @@ static void utc_network_bluetooth_socket_unset_connection_state_changed_cb_p(voi
 
 gboolean timeout_func(gpointer data);
 void adapter_state_changed_cb_for_socket_p(int result,
-					   bt_adapter_state_e adapter_state,
-					   void *user_data);
+						bt_adapter_state_e adapter_state, void *user_data);
 void device_discovery_state_changed_cb_for_socket_p(int result,
-						    bt_adapter_device_discovery_state_e discovery_state,
-						    bt_adapter_device_discovery_info_s *discovery_info,
-						    void *user_data);
+						bt_adapter_device_discovery_state_e discovery_state,
+		bt_adapter_device_discovery_info_s *discovery_info, void *user_data);
 void device_bonded_cb_for_socket_p(int result, bt_device_info_s *device_info,
-				   void *user_data);
+						void *user_data);
 void socket_data_received_cb_for_socket_p(bt_socket_received_data_s *data,
-					  void *user_data);
+						void *user_data);
 void socket_connection_state_changed_cb_for_socket_p(int result,
-						     bt_socket_connection_state_e connection_state,
-						     bt_socket_connection_s *connection,
-						     void *user_data);
+						bt_socket_connection_state_e connection_state,
+						bt_socket_connection_s *connection, void *user_data);
 void device_unbonded_cb(int result, char *remote_address, void *user_data);
 
 struct tet_testlist tet_testlist[] = {
-	{utc_network_bluetooth_socket_set_connection_state_changed_cb_p, POSITIVE_TC_IDX},
-	{utc_network_bluetooth_socket_set_data_received_cb_p, POSITIVE_TC_IDX},
 	{utc_network_bluetooth_socket_create_rfcomm_p, POSITIVE_TC_IDX},
+	{utc_network_bluetooth_socket_set_connection_state_changed_cb_p, POSITIVE_TC_IDX},
 	{utc_network_bluetooth_socket_listen_and_accept_rfcomm_p, POSITIVE_TC_IDX},
-	{utc_network_bluetooth_socket_destroy_rfcomm_p, POSITIVE_TC_IDX},
+	{utc_network_bluetooth_socket_set_data_received_cb_p, POSITIVE_TC_IDX},
 	{utc_network_bluetooth_socket_connect_rfcomm_p, POSITIVE_TC_IDX},
 	{utc_network_bluetooth_socket_send_data_p, POSITIVE_TC_IDX},
 	{utc_network_bluetooth_socket_disconnect_rfcomm_p, POSITIVE_TC_IDX},
+	{utc_network_bluetooth_socket_destroy_rfcomm_p, POSITIVE_TC_IDX},
 	{utc_network_bluetooth_socket_unset_data_received_cb_p, POSITIVE_TC_IDX},
 	{utc_network_bluetooth_socket_unset_connection_state_changed_cb_p, POSITIVE_TC_IDX},
 	{NULL, 0},
 };
 
+int get_value_from_file(void)
+{
+	FILE *fp;
+	char *token;
+	char buf[100];
+
+	fp = fopen(CONFIG_FILE_PATH, "r");
+	if (fp == NULL) {
+		tet_printf("Default configuration is used\n");
+		return -1;
+	}
+	while (fgets(buf, sizeof(buf), fp)) {
+		if (buf[0] == '#' || buf[0] == '\n')
+			continue;
+
+		token = strrchr(buf, '\n');
+		if (token == NULL) {
+			tet_printf("g_conf is too long\n");
+			break;
+		}
+		*token = '\0';
+
+		token = strtok(buf, "=");
+		if (token == NULL) {
+			continue;
+		}
+		if (strcasecmp(token, "BT_ADDR_MOBILE") == 0) {
+			token = strtok(NULL, "=");
+			target_address = strdup(token);
+			fclose(fp);
+			return 0;
+		}
+	}
+	return -1;
+}
+
 static void startup(void)
 {
 	bt_error_e ret = BT_ERROR_NONE;
 	int timeout_id = 0;
 
+	if(get_value_from_file() == -1) {
+		tet_printf("Failed to read.");
+	}
+
 	/* start of TC */
 	tet_printf("TC start.");
 	callback_result = false;
@@ -201,8 +241,7 @@ void device_unbonded_cb(int result, char *remote_address, void *user_data)
 }
 
 void adapter_state_changed_cb_for_socket_p(int result,
-					   bt_adapter_state_e adapter_state,
-					   void *user_data)
+					bt_adapter_state_e adapter_state, void *user_data)
 {
 	if (user_data != NULL && !strcmp((char *)user_data, "startup")) {
 		if (adapter_state == BT_ADAPTER_ENABLED && result == BT_ERROR_NONE) {
@@ -218,9 +257,8 @@ void adapter_state_changed_cb_for_socket_p(int result,
 }
 
 void device_discovery_state_changed_cb_for_socket_p(int result,
-						    bt_adapter_device_discovery_state_e discovery_state,
-						    bt_adapter_device_discovery_info_s *discovery_info,
-						    void *user_data)
+			bt_adapter_device_discovery_state_e discovery_state,
+			bt_adapter_device_discovery_info_s *discovery_info, void *user_data)
 {
 	tet_printf("Callback: bt_adapter_device_discovery_state_changed_cb() was called");
 	if (user_data != NULL && !strcmp((char *)user_data, "startup")) {
@@ -244,11 +282,11 @@ void device_discovery_state_changed_cb_for_socket_p(int result,
 	}
 }
 
-void device_bonded_cb_for_socket_p(int result, bt_device_info_s *device_info,
-				   void *user_data)
+void device_bonded_cb_for_socket_p(int result, bt_device_info_s *device_info, void *user_data)
 {
-	if (user_data != NULL && !strcmp((char *)user_data, "startup")) {
-		if (device_info->remote_address != NULL && !strcmp(device_info->remote_address, target_address)) {
+	if ((user_data != NULL) && !strcmp((char *)user_data, "startup")) {
+		if ((device_info->remote_address != NULL) &&
+				!strcmp(device_info->remote_address, target_address)) {
 			if (result == BT_ERROR_NONE) {
 				tet_printf("Callback: Bonding succeeded");
 				bonding_result = true;
@@ -264,14 +302,13 @@ void device_bonded_cb_for_socket_p(int result, bt_device_info_s *device_info,
 }
 
 void socket_data_received_cb_for_socket_p(bt_socket_received_data_s *data,
-					  void *user_data)
+					void *user_data)
 {
 }
 
 void socket_connection_state_changed_cb_for_socket_p(int result,
-						     bt_socket_connection_state_e connection_state,
-						     bt_socket_connection_s *connection,
-						     void *user_data)
+				bt_socket_connection_state_e connection_state,
+				bt_socket_connection_s *connection, void *user_data)
 {
 	tet_printf("Callback: bt_socket_connection_state_changed_cb() was called");
 	if (connection_state == BT_SOCKET_CONNECTED)
@@ -313,7 +350,7 @@ static void utc_network_bluetooth_socket_set_data_received_cb_p(void)
 
 	ret = bt_socket_set_data_received_cb(socket_data_received_cb_for_socket_p, NULL);
 	dts_check_eq("bt_socket_set_data_received_cb", ret, BT_ERROR_NONE,
-		     "bt_socket_set_data_received_cb() failed.");
+				"bt_socket_set_data_received_cb() failed.");
 }
 
 /**
@@ -325,8 +362,8 @@ static void utc_network_bluetooth_socket_set_connection_state_changed_cb_p(void)
 
 	ret = bt_socket_set_connection_state_changed_cb(socket_connection_state_changed_cb_for_socket_p, NULL);
 	dts_check_eq("bt_socket_set_connection_state_changed_cb", ret,
-		     BT_ERROR_NONE,
-		     "bt_socket_set_connection_state_changed_cb() failed.");
+			BT_ERROR_NONE,
+			"bt_socket_set_connection_state_changed_cb() failed.");
 }
 
 /**
@@ -338,7 +375,7 @@ static void utc_network_bluetooth_socket_create_rfcomm_p(void)
 
 	ret = bt_socket_create_rfcomm(rfcomm_test_uuid_spp, &socket_fd);
 	dts_check_eq("bt_socket_create_rfcomm", ret, BT_ERROR_NONE,
-		     "bt_socket_create_rfcomm() failed.");
+			"bt_socket_create_rfcomm() failed.");
 }
 
 /**
@@ -350,7 +387,7 @@ static void utc_network_bluetooth_socket_listen_and_accept_rfcomm_p(void)
 
 	ret = bt_socket_listen_and_accept_rfcomm(socket_fd, 1);
 	dts_check_eq("bt_socket_listen_and_accept_rfcomm", ret, BT_ERROR_NONE,
-		     "bt_socket_listen_and_accept_rfcomm() failed.");
+			"bt_socket_listen_and_accept_rfcomm() failed.");
 }
 
 /**
@@ -362,7 +399,7 @@ static void utc_network_bluetooth_socket_destroy_rfcomm_p(void)
 
 	ret = bt_socket_destroy_rfcomm(socket_fd);
 	dts_check_eq("bt_socket_destroy_rfcomm", ret, BT_ERROR_NONE,
-		     "bt_socket_destroy_rfcomm() failed.");
+			"bt_socket_destroy_rfcomm() failed.");
 }
 
 /**
@@ -377,16 +414,16 @@ static void utc_network_bluetooth_socket_connect_rfcomm_p(void)
 	callback_result = false;
 	ret = bt_socket_connect_rfcomm(target_address, rfcomm_test_uuid_spp);
 	if (ret == BT_ERROR_NONE) {
+		dts_check_eq("bt_socket_connect_rfcomm", ret, BT_ERROR_NONE,
+						"bt_socket_connect_rfcomm() failed.");
 		tet_printf("bt_socket_connect_rfcomm() succeeded.");
 		timeout_id = g_timeout_add(60000, timeout_func, mainloop);
 		g_main_loop_run(mainloop);
 		g_source_remove(timeout_id);
 	} else {
 		dts_fail("bt_socket_connect_rfcomm",
-			 "bt_socket_connect_rfcomm() failed");
+				"bt_socket_connect_rfcomm() failed");
 	}
-	dts_check_eq("bt_socket_connect_rfcomm", callback_result, true,
-		     "connecting failed.");
 }
 
 /**
@@ -398,7 +435,7 @@ static void utc_network_bluetooth_socket_disconnect_rfcomm_p(void)
 
 	ret = bt_socket_disconnect_rfcomm(socket_fd);
 	dts_check_eq("bt_socket_disconnect_rfcomm", ret, BT_ERROR_NONE,
-		     "bt_socket_disconnect_rfcomm() failed.");
+				"bt_socket_disconnect_rfcomm() failed.");
 }
 
 /**
@@ -408,10 +445,10 @@ static void utc_network_bluetooth_socket_send_data_p(void)
 {
 	int ret = BT_ERROR_NONE;
 	char *dts_test = "dts_test";
-
+	int socket_fd = 1;
 	ret = bt_socket_send_data(socket_fd, "dts_test", sizeof(dts_test));
 	dts_check_eq("bt_socket_send_data", ret, BT_ERROR_NONE,
-		     "bt_socket_send_data() failed.");
+				"bt_socket_send_data() failed.");
 }
 
 /**
@@ -423,7 +460,7 @@ static void utc_network_bluetooth_socket_unset_data_received_cb_p(void)
 
 	ret = bt_socket_unset_data_received_cb();
 	dts_check_eq("bt_socket_unset_data_received_cb", ret, BT_ERROR_NONE,
-		     "bt_socket_unset_data_received_cb() failed.");
+				"bt_socket_unset_data_received_cb() failed.");
 }
 
 /**
@@ -435,6 +472,6 @@ static void utc_network_bluetooth_socket_unset_connection_state_changed_cb_p(voi
 
 	ret = bt_socket_unset_connection_state_changed_cb();
 	dts_check_eq("bt_socket_unset_connection_state_changed_cb", ret,
-		     BT_ERROR_NONE,
-		     "bt_socket_unset_connection_state_changed_cb() failed.");
+				BT_ERROR_NONE,
+				"bt_socket_unset_connection_state_changed_cb() failed.");
 }
diff --git a/mobile/TC/tet_scen b/TC/tet_scen
index 03f029a..03f029a 100755
--- a/mobile/TC/tet_scen
+++ b/TC/tet_scen
diff --git a/mobile/TC/tetbuild.cfg b/TC/tetbuild.cfg
index f7eda55..f7eda55 100644
--- a/mobile/TC/tetbuild.cfg
+++ b/TC/tetbuild.cfg
diff --git a/mobile/TC/tetclean.cfg b/TC/tetclean.cfg
index 02d7030..02d7030 100644
--- a/mobile/TC/tetclean.cfg
+++ b/TC/tetclean.cfg
diff --git a/mobile/TC/tetexec.cfg b/TC/tetexec.cfg
index ef3e452..ef3e452 100644
--- a/mobile/TC/tetexec.cfg
+++ b/TC/tetexec.cfg
diff --git a/TC/tetware.conf b/TC/tetware.conf
new file mode 100644
index 0000000..4d0c237
--- /dev/null
+++ b/TC/tetware.conf
@@ -0,0 +1,5 @@
+BT_ADDR_HEADSET=00:21:19:14:29:52
+BT_ADDR_MOBILE=E4:32:CB:41:1D:7A
+BT_ADDR_HDP=00:22:58:07:77:BB
+BT_ADDR_LE=E4:32:CB:41:1F:A6
+
diff --git a/bluetooth-test.manifest b/bluetooth-test.manifest
new file mode 100644
index 0000000..0c26ff0
--- /dev/null
+++ b/bluetooth-test.manifest
@@ -0,0 +1,12 @@
+<manifest>
+    <define>
+        <domain name="capi-network-bluetooth-test"/>
+	<request>
+		<smack request="bt-service::public" type="w"/>
+		<smack request="bt-service::platform" type="rw"/>
+	</request>
+    </define>
+    <request>
+        <domain name="capi-network-bluetooth-test"/>
+    </request>
+</manifest>
diff --git a/mobile/bluetooth.manifest b/bluetooth.manifest
index 75b0fa5..75b0fa5 100644
--- a/mobile/bluetooth.manifest
+++ b/bluetooth.manifest
diff --git a/wearable/capi-network-bluetooth.pc.in b/capi-network-bluetooth.pc.in
index 097a2d1..097a2d1 100644
--- a/wearable/capi-network-bluetooth.pc.in
+++ b/capi-network-bluetooth.pc.in
diff --git a/doc/bluetooth_doc.h b/doc/bluetooth_doc.h
new file mode 100644
index 0000000..1dfd984
--- /dev/null
+++ b/doc/bluetooth_doc.h
@@ -0,0 +1,695 @@
+/*
+ * 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.
+ */
+
+
+#ifndef __TIZEN_NETWORK_BLUETOOTH_DOC_H__
+#define __TIZEN_NETWORK_BLUETOOTH_DOC_H__
+
+/**
+ * @defgroup CAPI_NETWORK_BLUETOOTH_MODULE Bluetooth
+ * @brief Bluetooth Service provides API to manage Bluetooth device.
+ * @ingroup CAPI_NETWORK_FRAMEWORK
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_MODULE_HEADER Required Header
+ *   \#include <bluetooth.h>
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_MODULE_OVERVIEW Overview
+ * Bluetooth Service consists of @ref CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE, @ref CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE and @ref CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE.
+ *
+ *<BR>
+ * In order to use the above APIs, you must call #bt_initialize() in advance.
+ * In addition, #bt_deinitialize() should be called when Bluetooth Service is no longer needed.
+ * Please refer Bluetooth Tutorial if you want to get more detailed usages and information of this api.
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_MODULE_FEATURE Related Features
+ * This API is related with the following features:\n
+ *  - http://tizen.org/feature/network.bluetooth\n
+ *
+ * It is recommended to design feature related codes in your application for reliability.\n
+ *
+ * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE,thereby controlling the procedure of your application.\n
+ *
+ * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n
+ *
+ * More details on featuring your application can be found from <a href="../org.tizen.mobile.native.appprogramming/html/ide_sdk_tools/feature_element.htm"><b>Feature Element</b>.</a>
+ *
+ */
+
+/**
+ * @defgroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE Bluetooth Adapter
+ * @brief Bluetooth Adapter API provides functions for setting up Bluetooth and discovering other devices.
+ * @ingroup CAPI_NETWORK_BLUETOOTH_MODULE
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE_HEADER Required Header
+ *  \#include <bluetooth.h>
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE_OVERVIEW Overview
+ * This set of function is used to control a bluetooth adapter.
+ * You can also control visibility of the device, its appearance for others (adapter name).
+ * In addition, this api is used to discover neighboring bluetooth devices.
+ * This process is asynchronous, so it is up to you to build and hold list of devices in the neighborhood
+ * - the api does not provide this list.
+ * Before starting a device discovery, you can find a device from the connected devices.
+ * This functionality is implemented by foreach loop.
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE_FEATURE Related Features
+ * This API is related with the following features:\n
+ *  - http://tizen.org/feature/network.bluetooth\n
+ *
+ * It is recommended to design feature related codes in your application for reliability.\n
+ *
+ * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE,thereby controlling the procedure of your application.\n
+ *
+ * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n
+ *
+ * More details on featuring your application can be found from <a href="../org.tizen.mobile.native.appprogramming/html/ide_sdk_tools/feature_element.htm"><b>Feature Element</b>.</a>
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE_ASYNCHRONOUS_OPERATIONS Asynchronous Operations
+ * <div><table class="doxtable" >
+ *     <tr>
+ *        <th><b>FUNCTION</b></th>
+ *        <th><b>CALLBACK</b></th>
+ *        <th><b>DESCRIPTION</b></th>
+ *     </tr>
+ *     <tr>
+ *        <td>bt_adapter_set_name()</td>
+ *        <td>bt_adapter_name_changed_cb()</td>
+ *        <td>Used to set adapter name. </td>
+ *     </tr>
+ *     <tr>
+ *        <td>bt_adapter_visibility_mode_changed_cb()</td>
+ *        <td>Used to set visibility mode (#bt_adapter_visibility_mode_e). </td>
+ *     </tr>
+ *     <tr>
+ *        <td>bt_adapter_start_device_discovery()<br>
+ *            bt_adapter_stop_device_discovery()</td>
+ *        <td>bt_adapter_device_discovery_state_changed_cb()</td>
+ *        <td>Used to start or cancel device discovery. </td>
+ *     </tr>
+ *</table></div>
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE_CALLBACK_OPERATIONS Callback(Event) Operations
+ * <div><table class="doxtable" >
+ *     <tr>
+ *        <th><b>REGISTER</b></th>
+ *        <th><b>UNREGISTER</b></th>
+ *        <th><b>CALLBACK</b></th>
+ *        <th><b>DESCRIPTION</b></th>
+ *     </tr>
+ *     <tr>
+ *        <td>bt_adapter_set_state_changed_cb()</td>
+ *        <td>bt_adapter_unset_state_changed_cb()</td>
+ *        <td>bt_adapter_state_changed_cb()</td>
+ *        <td>Used to be notified of state change (enable or disable). </td>
+ *     </tr>
+ *     <tr>
+ *        <td>bt_adapter_set_name_changed_cb()</td>
+ *        <td>bt_adapter_unset_name_changed_cb()</td>
+ *        <td>bt_adapter_name_changed_cb()</td>
+ *        <td>Used to be notified of name change. </td>
+ *     </tr>
+ *     <tr>
+ *        <td>bt_adapter_set_visibility_mode_changed_cb()</td>
+ *        <td>bt_adapter_unset_visibility_mode_changed_cb()</td>
+ *        <td>bt_adapter_visibility_mode_changed_cb()</td>
+ *        <td>Used to be notified of change of visibility mode (#bt_adapter_visibility_mode_e). </td>
+ *     </tr>
+ *     <tr>
+ *        <td>bt_adapter_set_device_discovery_state_changed_cb()</td>
+ *        <td>bt_adapter_unset_device_discovery_state_changed_cb()</td>
+ *        <td>bt_adapter_device_discovery_state_changed_cb()</td>
+ *        <td>Used to be notified of change of device discovery state (#bt_adapter_device_discovery_state_e). </td>
+ *     </tr>
+ *</table></div>
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE_FOREACH_OPERATIONS Foreach Operations
+ * <div><table class="doxtable" >
+ *     <tr>
+ *        <th><b>FOREACH</b></th>
+ *        <th><b>CALLBACK</b></th>
+ *        <th><b>DESCRIPTION</b></th>
+ *     </tr>
+ *     <tr>
+ *        <td>bt_adapter_foreach_bonded_device()</td>
+ *        <td>bt_adapter_bonded_device_cb()</td>
+ *        <td>Used to get bonded devices.</td>
+ *     </tr>
+ *</table></div>
+ *
+ *<BR>
+ * Please refer Bluetooth Tutorial if you want to get more detailed usages and information of this api.
+ */
+
+/**
+ * @defgroup CAPI_NETWORK_BLUETOOTH_ADAPTER_LE_MODULE Bluetooth LE Adapter
+ * @brief Bluetooth LE API provides functions for managing bonds with other devices for LE and searching for supported LE services.
+ * @ingroup CAPI_NETWORK_BLUETOOTH_MODULE
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_ADAPTER_LE_MODULE_HEADER Required Header
+ *  \#include <bluetooth.h>
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE_OVERVIEW Overview
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_ADAPTER_LE_MODULE_MODULE_FEATURE Related Features
+ * This API is related with the following features:\n
+ *  - http://tizen.org/feature/network.bluetooth\n
+ *  - http://tizen.org/feature/network.bluetooth.le\n
+ *
+ * It is recommended to design feature related codes in your application for reliability.\n
+ *
+ * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE,thereby controlling the procedure of your application.\n
+ *
+ * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n
+ *
+ * More details on featuring your application can be found from <a href="../org.tizen.mobile.native.appprogramming/html/ide_sdk_tools/feature_element.htm"><b>Feature Element</b>.</a>
+ *
+ */
+
+/**
+ * @defgroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE Bluetooth Device
+ * @brief Bluetooth Device API provides functions for managing bonds with other devices and searching for supported services.
+ * @ingroup CAPI_NETWORK_BLUETOOTH_MODULE
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE_HEADER Required Header
+ *  \#include <bluetooth.h>
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE_OVERVIEW Overview
+ * This set of functions is used to handle the connection with other devices.
+ * Connected devices exchange keys needed for encrypted communication,
+ * but each connection has to be approved by the latest application user.
+ * You can also set authorization of other devices.
+ * Authorized devices are connected, and it is connected automatically without the latest user
+ * being asked for authorization.
+ * In addition, this is used to search for services available on remote devices.
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE_FEATURE Related Features
+ * This API is related with the following features:\n
+ *  - http://tizen.org/feature/network.bluetooth\n
+ *  - http://tizen.org/feature/network.bluetooth.le\n
+ *
+ * It is recommended to design feature related codes in your application for reliability.\n
+ *
+ * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE,thereby controlling the procedure of your application.\n
+ *
+ * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n
+ *
+ * More details on featuring your application can be found from <a href="../org.tizen.mobile.native.appprogramming/html/ide_sdk_tools/feature_element.htm"><b>Feature Element</b>.</a>
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE_ASYNCHRONOUS_OPERATIONS Asynchronous Operations
+ * <div><table class="doxtable" >
+ *     <tr>
+ *        <th><b>FUNCTION</b></th>
+ *        <th><b>CALLBACK</b></th>
+ *        <th><b>DESCRIPTION</b></th>
+ *     </tr>
+ *     <tr>
+ *        <td>bt_device_create_bond()<br>
+ *            bt_device_cancel_bonding()</td>
+ *        <td>bt_device_bond_created_cb()</td>
+ *        <td>Used to create bond or cancel creating bond. </td>
+ *     </tr>
+ *     <tr>
+ *        <td>bt_device_destroy_bond()</td>
+ *        <td>bt_device_bond_destroyed_cb()</td>
+ *        <td>Used to destroy bond. </td>
+ *     </tr>
+ *     <tr>
+ *        <td>bt_device_set_authorization()</td>
+ *        <td>bt_device_authorization_changed_cb()</td>
+ *        <td>Used to set as authorized or unauthorized device. </td>
+ *     </tr>
+ *     <tr>
+ *        <td>bt_device_start_service_search()</td>
+ *        <td>bt_device_service_searched_cb()</td>
+ *        <td>Used to start or cancel service search. </td>
+ *     </tr>
+ *</table></div>
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE_CALLBACK_OPERATIONS Callback(Event) Operations
+ * <div><table class="doxtable" >
+ *     <tr>
+ *        <th><b>REGISTER</b></th>
+ *        <th><b>UNREGISTER</b></th>
+ *        <th><b>CALLBACK</b></th>
+ *        <th><b>DESCRIPTION</b></th>
+ *     </tr>
+ *     <tr>
+ *        <td>bt_device_set_bond_created_cb()</td>
+ *        <td>bt_device_unset_bond_created_cb()</td>
+ *        <td>bt_device_bond_created_cb()</td>
+ *        <td>Used to be notified of the result of creating bond. </td>
+ *     </tr>
+ *     <tr>
+ *        <td>bt_device_set_bond_destroyed_cb()</td>
+ *        <td>bt_device_unset_bond_destroyed_cb()</td>
+ *        <td>bt_device_bond_destroyed_cb()</td>
+ *        <td>Used to be notified of the result of destroying bond. </td>
+ *     </tr>
+ *     <tr>
+ *        <td>bt_device_set_authorization_changed_cb()</td>
+ *        <td>bt_device_unset_authorization_changed_cb()</td>
+ *        <td>bt_device_authorization_changed_cb()</td>
+ *        <td>Used to be notified of change of authorization. </td>
+ *     </tr>
+ *     <tr>
+ *        <td>bt_device_set_service_searched_cb()</td>
+ *        <td>bt_device_unset_service_searched_cb()</td>
+ *        <td>bt_device_service_searched_cb()</td>
+ *        <td>Used to be notified of change of service search state. </td>
+ *     </tr>
+ *</table></div>
+ *
+ *<BR>
+ * Please refer Bluetooth Tutorial if you want to get more detailed usages and information of this api.
+ */
+
+
+/**
+ * @defgroup CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE Bluetooth Socket
+ * @brief Bluetooth Socket API provides functions for managing connections to other devices and exchanging data.
+ * @ingroup CAPI_NETWORK_BLUETOOTH_MODULE
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE_HEADER Required Header
+ *  \#include <bluetooth.h>
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE_OVERVIEW Overview
+ * This set of functions is used for exchanging data between two bluetooth
+ * devices, our device can have both roles as server (service provider) and client
+ * (service user).
+ * Depending on the role, there is difference in creating a connection.
+ * After that, processes of exchanging data and disconnection are same.
+ *
+ * To start communication, you should first register for #bt_socket_set_connection_state_changed_cb()
+ * and #bt_socket_set_data_received_cb().
+ * Next step depends on the role of your application.\n
+ * If you want to be \b server \b role, application should create socket
+ * (#bt_socket_create_rfcomm()), and start listening and accepting incoming connections
+ * (#bt_socket_listen_and_accept_rfcomm()).
+ * If you want to connect to specific device and use it's services (\a client \a role),
+ * you have to start connection with #bt_socket_connect_rfcomm() and wait for connection.\n
+ * After connection has been established (information is passed to your program with
+ * #bt_socket_connection_state_changed_cb() function call), you can exchange data by
+ * calling #bt_socket_send_data(). \n
+ * If you receive data from remote device, #bt_socket_data_received_cb() functions will be called.
+ * When you finish exchanging data, you should disconnect connection
+ * with #bt_socket_disconnect_rfcomm() and unregister callback functions (with using
+ * #bt_socket_unset_data_received_cb(), #bt_socket_unset_connection_state_changed_cb()).
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE_FEATURE Related Features
+ * This API is related with the following features:\n
+ *  - http://tizen.org/feature/network.bluetooth\n
+ *
+ * It is recommended to design feature related codes in your application for reliability.\n
+ *
+ * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE,thereby controlling the procedure of your application.\n
+ *
+ * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n
+ *
+ * More details on featuring your application can be found from <a href="../org.tizen.mobile.native.appprogramming/html/ide_sdk_tools/feature_element.htm"><b>Feature Element</b>.</a>
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE_ASYNCHRONOUS_OPERATIONS Asynchronous Operations
+ * <div><table class="doxtable" >
+ *     <tr>
+ *        <th><b>FUNCTION</b></th>
+ *        <th><b>CALLBACK</b></th>
+ *        <th><b>DESCRIPTION</b></th>
+ *     </tr>
+ *     <tr>
+ *        <td>bt_socket_listen_and_accept_rfcomm()<br>
+ *            bt_socket_connect_rfcomm()</td>
+ *        <td>bt_socket_connection_state_changed_cb()</td>
+ *        <td>Used to connect a device. </td>
+ *     </tr>
+ *</table></div>
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE_CALLBACK_OPERATIONS Callback(Event) Operations
+ * <div><table class="doxtable" >
+ *     <tr>
+ *        <th><b>REGISTER</b></th>
+ *        <th><b>UNREGISTER</b></th>
+ *        <th><b>CALLBACK</b></th>
+ *        <th><b>DESCRIPTION</b></th>
+ *     </tr>
+ *     <tr>
+ *        <td>bt_socket_set_data_received_cb()</td>
+ *        <td>bt_socket_unset_data_received_cb()</td>
+ *        <td>bt_socket_data_received_cb()</td>
+ *        <td>Used to be notified of received data. </td>
+ *     </tr>
+ *     <tr>
+ *        <td>bt_socket_set_connection_state_changed_cb()</td>
+ *        <td>bt_socket_unset_connection_state_changed_cb()</td>
+ *        <td>bt_socket_connection_state_changed_cb()</td>
+ *        <td>Used to be notified when the state of connection changes. </td>
+ *     </tr>
+ *</table></div>
+ *
+ *<BR>
+ * Please refer Bluetooth Tutorial if you want to get more detailed usages and information of this api.
+ */
+
+
+/**
+ * @defgroup CAPI_NETWORK_BLUETOOTH_OPP_MODULE Bluetooth OPP
+ * @brief Bluetooth OPP(Object Push Profile) API provides functions for exchanging objects such as pictures.
+ * @ingroup CAPI_NETWORK_BLUETOOTH_MODULE
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_OPP_MODULE_HEADER Required Header
+ *  \#include <bluetooth.h>
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_OPP_MODULE_OVERVIEW Overview
+ * OPP profile let users exchange objects between two devices.
+ *
+ */
+
+/**
+ * @defgroup CAPI_NETWORK_BLUETOOTH_OPP_SERVER_MODULE Bluetooth OPP Server
+ * @brief Bluetooth OPP(Object Push Profile) Server API provides functions for accepting objects such as pictures.
+ * @ingroup CAPI_NETWORK_BLUETOOTH_OPP_MODULE
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_OPP_SERVER_MODULE_HEADER Required Header
+ *  \#include <bluetooth.h>
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_OPP_SERVER_MODULE_OVERVIEW Overview
+ * This is OPP server APIs.
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_OPP_SERVER_MODULE_FEATURE Related Features
+ * This API is related with the following features:\n
+ *  - http://tizen.org/feature/network.bluetooth.opp\n
+ *
+ * It is recommended to design feature related codes in your application for reliability.\n
+ *
+ * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE,thereby controlling the procedure of your application.\n
+ *
+ * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n
+ *
+ * More details on featuring your application can be found from <a href="../org.tizen.mobile.native.appprogramming/html/ide_sdk_tools/feature_element.htm"><b>Feature Element</b>.</a>
+ *
+ */
+
+/**
+ * @defgroup CAPI_NETWORK_BLUETOOTH_OPP_CLIENT_MODULE Bluetooth OPP Client
+ * @brief Bluetooth OPP(Object Push Profile) Client API provides functions for pushing objects such as pictures.
+ * @ingroup CAPI_NETWORK_BLUETOOTH_OPP_MODULE
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_OPP_CLIENT_MODULE_HEADER Required Header
+ *  \#include <bluetooth.h>
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_OPP_CLIENT_MODULE_OVERVIEW Overview
+ * This is OPP Client APIs.
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_OPP_CLIENT_MODULE_FEATURE Related Features
+ * This API is related with the following features:\n
+ *  - http://tizen.org/feature/network.bluetooth.opp\n
+ *
+ * It is recommended to design feature related codes in your application for reliability.\n
+ *
+ * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE,thereby controlling the procedure of your application.\n
+ *
+ * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n
+ *
+ * More details on featuring your application can be found from <a href="../org.tizen.mobile.native.appprogramming/html/ide_sdk_tools/feature_element.htm"><b>Feature Element</b>.</a>
+ *
+ */
+
+/**
+ * @internal
+ * @defgroup CAPI_NETWORK_BLUETOOTH_PAN_MODULE Bluetooth PAN
+ * @brief Bluetooth PAN(Personal Area Networking) API provides functions for connecting to a higher level network and the Internet.
+ * @ingroup CAPI_NETWORK_BLUETOOTH_MODULE
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_PAN_MODULE_OVERVIEW Overview
+ * The PAN Profile describe how two or more Bluetooth enabled devices can form an ad-hoc network and how the same mechanism can be
+ * used to access a remote network through a network access point. But this API only supports network access point service.
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_PAN_MODULE_FEATURE Related Features
+ * This API is related with the following features:\n
+ *  - http://tizen.org/feature/network.tethering.bluetooth\n
+ *
+ * It is recommended to design feature related codes in your application for reliability.\n
+ *
+ * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE,thereby controlling the procedure of your application.\n
+ *
+ * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n
+ *
+ * More details on featuring your application can be found from <a href="../org.tizen.mobile.native.appprogramming/html/ide_sdk_tools/feature_element.htm"><b>Feature Element</b>.</a>
+ *
+ */
+
+/**
+ * @internal
+ * @defgroup CAPI_NETWORK_BLUETOOTH_PAN_NAP_MODULE Bluetooth NAP
+ * @brief Bluetooth NAP(Network Access Point) API provides functions for an Ethernet bridge to support network services.
+ * @ingroup CAPI_NETWORK_BLUETOOTH_PAN_MODULE
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_PAN_NAP_MODULE_HEADER Required Header
+ *  \#include <bluetooth.h>
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_PAN_NAP_MODULE_OVERVIEW Overview
+ * A Bluetooth device that supports the NAP service is a Bluetooth device that provides some of the features of an Ethernet bridge to support network services.
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_PAN_NAP_MODULE_FEATURE Related Features
+ * This API is related with the following features:\n
+ *  - http://tizen.org/feature/network.tethering.bluetooth\n
+ *
+ * It is recommended to design feature related codes in your application for reliability.\n
+ *
+ * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE, thereby controlling the procedure of your application.\n
+ *
+ * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n
+ *
+ * More details on featuring your application can be found from <a href="../org.tizen.mobile.native.appprogramming/html/ide_sdk_tools/feature_element.htm"><b>Feature Element</b>.</a>
+ *
+ */
+
+/**
+ * @internal
+ * @defgroup CAPI_NETWORK_BLUETOOTH_PAN_PANU_MODULE Bluetooth PANU
+ * @brief Bluetooth PANU(Personal Area Networking User) API provides functions for client of both the NAP(Network Access Point).
+ * @ingroup CAPI_NETWORK_BLUETOOTH_PAN_MODULE
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_PAN_PANU_MODULE_HEADER Required Header
+ *  \#include <bluetooth.h>
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_PAN_PANU_MODULE_OVERVIEW Overview
+ * In PAN Profile, PANU can uses either the NAP or GN service, but this API only supports NAP service.
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_PAN_PANU_MODULE_FEATURE Related Features
+ * This API is related with the following features:\n
+ *  - http://tizen.org/feature/network.tethering.bluetooth\n
+ *
+ * It is recommended to design feature related codes in your application for reliability.\n
+ *
+ * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE, thereby controlling the procedure of your application.\n
+ *
+ * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n
+ *
+ * More details on featuring your application can be found from <a href="../org.tizen.mobile.native.appprogramming/html/ide_sdk_tools/feature_element.htm"><b>Feature Element</b>.</a>
+ *
+ */
+
+/**
+ * @defgroup CAPI_NETWORK_BLUETOOTH_HID_MODULE Bluetooth HID
+ * @brief Bluetooth HID(Human Interface Device) API provides functions for connecting to Bluetooth HID such as keyboards and mouse.
+ * @ingroup CAPI_NETWORK_BLUETOOTH_MODULE
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_HID_MODULE_HEADER Required Header
+ *  \#include <bluetooth.h>
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_HID_MODULE_OVERVIEW Overview
+ * In HID Profile, there are two roles - @a Host and @a Device.
+ * The @a Host is a device that uses or requests the services of a HID. The @a Device is a device that provides the service of human data input and output to and from the @a Host.
+ * This API only supports @a Host role.
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_HID_MODULE_FEATURE Related Features
+ * This API is related with the following features:\n
+ *  - http://tizen.org/feature/network.bluetooth.hid\n
+ *
+ * It is recommended to design feature related codes in your application for reliability.\n
+ *
+ * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE, thereby controlling the procedure of your application.\n
+ *
+ * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n
+ *
+ * More details on featuring your application can be found from <a href="../org.tizen.mobile.native.appprogramming/html/ide_sdk_tools/feature_element.htm"><b>Feature Element</b>.</a>
+ *
+ */
+
+/**
+ * @defgroup CAPI_NETWORK_BLUETOOTH_AUDIO_MODULE Bluetooth Audio
+ * @brief Bluetooth Audio API provides functions for connecting to Bluetooth audio devices such as headset, hand-free and headphone.
+ * @ingroup CAPI_NETWORK_BLUETOOTH_MODULE
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_AUDIO_MODULE_HEADER Required Header
+ *  \#include <bluetooth.h>
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_AUDIO_MODULE_OVERVIEW Overview
+ * This API supports the HFP(Hands-Free Profile), HSP(Headset Profile) and A2DP(Advanced Audio Distribution Profile).
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_AUDIO_MODULE_FEATURE Related Features
+ * This API is related with the following features:\n
+ *  - http://tizen.org/feature/network.bluetooth.audio.call\n
+ *  - http://tizen.org/feature/network.bluetooth.audio.media\n
+ *
+ * It is recommended to design feature related codes in your application for reliability.\n
+ *
+ * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE, thereby controlling the procedure of your application.\n
+ *
+ * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n
+ *
+ * More details on featuring your application can be found from <a href="../org.tizen.mobile.native.appprogramming/html/ide_sdk_tools/feature_element.htm"><b>Feature Element</b>.</a>
+ *
+ */
+
+/**
+ * @internal
+ * @defgroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE Bluetooth AG
+ * @brief Bluetooth AG(Audio Gateway) API provides functions for controling the remote audio device.
+ * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_MODULE
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE_HEADER Required Header
+ *  \#include <bluetooth.h>
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE_OVERVIEW Overview
+ * This API supports the @a Audio @a Gateway role in HSP and HFP.
+ * Audio Gateway is the devie that is the gateway of the audio, both for input and output, typically a mobile phone or PC.
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE_FEATURE Related Features
+ * This API is related with the following features:\n
+ *  - http://tizen.org/feature/network.bluetooth.audio.call\n
+ *  - http://tizen.org/feature/network.bluetooth.audio.media\n
+ *
+ * It is recommended to design feature related codes in your application for reliability.\n
+ *
+ * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE, thereby controlling the procedure of your application.\n
+ *
+ * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n
+ *
+ * More details on featuring your application can be found from <a href="../org.tizen.mobile.native.appprogramming/html/ide_sdk_tools/feature_element.htm"><b>Feature Element</b>.</a>
+ *
+ */
+
+/**
+ * @internal
+ * @defgroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_CALL_MODULE Call List
+ * @brief Bluetooth AG(Audio Gateway) API provides functions for managing the handler of call list.
+ * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_AUDIO_AG_CALL_MODULE_HEADER Required Header
+ *  \#include <bluetooth.h>
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_AUDIO_AG_CALL_OVERVIEW Overview
+ * This set of functions is used for managing the handler of call list.
+ * This handler is used for notifying the call list to the remote bluetooth device which supports HFP(Hands-Free Profile).
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_AUDIO_AG_CALL_MODULE_FEATURE Related Features
+ * This API is related with the following features:\n
+ *  - http://tizen.org/feature/network.bluetooth.audio.call\n
+ *  - http://tizen.org/feature/network.bluetooth.audio.media\n
+ *
+ * It is recommended to design feature related codes in your application for reliability.\n
+ *
+ * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE, thereby controlling the procedure of your application.\n
+ *
+ * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n
+ *
+ * More details on featuring your application can be found from <a href="../org.tizen.mobile.native.appprogramming/html/ide_sdk_tools/feature_element.htm"><b>Feature Element</b>.</a>
+ *
+ */
+
+/**
+ * @internal
+ * @defgroup CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE Bluetooth AVRCP
+ * @brief Bluetooth AVRCP(Audio/Video Remote Control Profile) API provides functions for notifying the change of target device to the control device.
+ * @ingroup CAPI_NETWORK_BLUETOOTH_MODULE
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE_HEADER Required Header
+ *  \#include <bluetooth.h>
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE_OVERVIEW Overview
+ * This API supports the @a Target role in AVRCP spec.
+ * The @a Target is the device whose characteristics are being altered.
+ * In a "walkman" type media player scenario, the @a Control device may be a headset that allows tracks to be skipped and the @a Target device would be the actual medial player.
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_AVRCP__MODULE_FEATURE Related Features
+ * This API is related with the following features:\n
+ *  - http://tizen.org/feature/network.bluetooth.audio.media\n
+ *
+ * It is recommended to design feature related codes in your application for reliability.\n
+ *
+ * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE, thereby controlling the procedure of your application.\n
+ *
+ * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n
+ *
+ * More details on featuring your application can be found from <a href="../org.tizen.mobile.native.appprogramming/html/ide_sdk_tools/feature_element.htm"><b>Feature Element</b>.</a>
+ *
+ */
+
+/**
+ * @defgroup CAPI_NETWORK_BLUETOOTH_HDP_MODULE Bluetooth HDP
+ * @brief Bluetooth HDP(Health Device Profile) API provides functions for managing connections to health devices and exchanging data.
+ * @ingroup CAPI_NETWORK_BLUETOOTH_MODULE
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_HDP_MODULE_HEADER Required Header
+ *  \#include <bluetooth.h>
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_HDP_MODULE_OVERVIEW Overview
+ * The @a Source is a transmitter of application data that is to be transferred to a @a Sink. The @a Sink is a receiver of application data delivered from a @a Source.
+ * This API supports the @a Sink role in HDP spec.
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_HDP_MODULE_FEATURE Related Features
+ * This API is related with the following features:\n
+ *  - http://tizen.org/feature/network.bluetooth.health\n
+ *
+ * It is recommended to design feature related codes in your application for reliability.\n
+ *
+ * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE, thereby controlling the procedure of your application.\n
+ *
+ * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n
+ *
+ * More details on featuring your application can be found from <a href="../org.tizen.mobile.native.appprogramming/html/ide_sdk_tools/feature_element.htm"><b>Feature Element</b>.</a>
+ *
+ */
+
+/**
+ * @defgroup CAPI_NETWORK_BLUETOOTH_GATT_MODULE Bluetooth GATT
+ * @brief Bluetooth GATT(Generic Attribute Profile) API provides functions for discovering, reading and modifying attributes.
+ * @ingroup CAPI_NETWORK_BLUETOOTH_MODULE
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_GATT_MODULE_HEADER Required Header
+ *  \#include <bluetooth.h>
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_GATT_MODULE_OVERVIEW Overview
+ * Two roles are defined for devices that implement GATT.
+ * The @a Server is the device that accepts incoming commands and requests from the client and sends responses, indications and notifications to a client.
+ * The @a Client is the device that initiates commands and requests towards the server and can receive responses, indications and notifications sent by the server.
+ * This API supports the @a Client role in GATT.
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_GATT_MODULE_FEATURE Related Features
+ * This API is related with the following features:\n
+ *  - http://tizen.org/feature/network.bluetooth.le\n
+ *
+ * It is recommended to design feature related codes in your application for reliability.\n
+ *
+ * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE, thereby controlling the procedure of your application.\n
+ *
+ * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n
+ *
+ * More details on featuring your application can be found from <a href="../org.tizen.mobile.native.appprogramming/html/ide_sdk_tools/feature_element.htm"><b>Feature Element</b>.</a>
+ *
+ */
+
+#endif /* __TIZEN_NETWORK_BLUETOOTH_DOC_H__ */
diff --git a/mobile/include/bluetooth.h b/include/bluetooth.h
index 5480eed..807bbdc 100755..100644
--- a/mobile/include/bluetooth.h
+++ b/include/bluetooth.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
+ * 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.
@@ -23,6 +23,8 @@
 #include <stdbool.h>
 #include <tizen_error.h>
 
+#include "bluetooth_type.h"
+
 #ifdef __cplusplus
 extern "C"
 {
@@ -40,724 +42,11 @@ extern "C"
  * @{
  */
 
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE
- * @brief  Enumerations of connected Bluetooth device event role.
- */
-typedef enum
-{
-	BT_SOCKET_UNKNOWN = 0x00, /**< Unknown role*/
-	BT_SOCKET_SERVER , /**< Server role*/
-	BT_SOCKET_CLIENT, /**< Client role*/
-} bt_socket_role_e;
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_MODULE
- * @brief Enumerations of Bluetooth error codes.
- */
-typedef enum
-{
-	BT_ERROR_NONE = TIZEN_ERROR_NONE, /**< Successful*/
-	BT_ERROR_CANCELLED = TIZEN_ERROR_CANCELED, /**< Operation cancelled */
-	BT_ERROR_INVALID_PARAMETER = TIZEN_ERROR_INVALID_PARAMETER, /**< Invalid parameter */
-	BT_ERROR_OUT_OF_MEMORY = TIZEN_ERROR_OUT_OF_MEMORY, /**< Out of memory */
-	BT_ERROR_RESOURCE_BUSY = TIZEN_ERROR_RESOURCE_BUSY, /**< Device or resource busy */
-	BT_ERROR_TIMED_OUT = TIZEN_ERROR_TIMED_OUT, /**< Timeout error */
-	BT_ERROR_NOW_IN_PROGRESS = TIZEN_ERROR_NOW_IN_PROGRESS, /**< Operation now in progress */
-	BT_ERROR_NOT_INITIALIZED = TIZEN_ERROR_NETWORK_CLASS|0x0101, /**< Local adapter not initialized */
-	BT_ERROR_NOT_ENABLED = TIZEN_ERROR_NETWORK_CLASS|0x0102, /**< Local adapter not enabled */
-	BT_ERROR_ALREADY_DONE = TIZEN_ERROR_NETWORK_CLASS|0x0103, /**< Operation already done  */
-	BT_ERROR_OPERATION_FAILED = TIZEN_ERROR_NETWORK_CLASS|0x0104, /**< Operation failed */
-	BT_ERROR_NOT_IN_PROGRESS = TIZEN_ERROR_NETWORK_CLASS|0x0105, /**< Operation not in progress */
-	BT_ERROR_REMOTE_DEVICE_NOT_BONDED = TIZEN_ERROR_NETWORK_CLASS|0x0106, /**< Remote device not bonded */
-	BT_ERROR_AUTH_REJECTED = TIZEN_ERROR_NETWORK_CLASS|0x0107, /**< Authentication rejected */
-	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_PERMISSION_DENIED = TIZEN_ERROR_NETWORK_CLASS|0x010C, /**< Permission denied */
-} bt_error_e;
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief  Enumerations of the Bluetooth adapter state.
- */
-typedef enum
-{
-	BT_ADAPTER_DISABLED = 0x00, /**< Bluetooth adapter is disabled */
-	BT_ADAPTER_ENABLED, /**< Bluetooth adapter is enabled */
-} bt_adapter_state_e;
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief Enumerations of the Bluetooth visibility mode.
- */
-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,
-							    it is changed to #BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE.*/
-} bt_adapter_visibility_mode_e;
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief Enumerations of the discovery state of Bluetooth device.
- *
- */
-typedef enum
-{
-	BT_ADAPTER_DEVICE_DISCOVERY_STARTED, /**< Device discovery is started */
-	BT_ADAPTER_DEVICE_DISCOVERY_FINISHED, /**< Device discovery is finished */
-	BT_ADAPTER_DEVICE_DISCOVERY_FOUND, /**< The remote Bluetooth device is found */
-} bt_adapter_device_discovery_state_e;
-
-typedef enum
-{
-	BT_ADAPTER_DEVICE_DISCOVERY_BREDR = 0x01, /**< Device discovery for BREDR devices only */
-	BT_ADAPTER_DEVICE_DISCOVERY_LE, /**< Device discovery for LE devices only */
-	BT_ADAPTER_DEVICE_DISCOVERY_LE_BREDR, /**< Device discovery for both LE and BREDR devices */
-} bt_adapter_discover_devices_type_e;
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
- * @brief Enumerations of device authorization state.
- */
-typedef enum
-{
-	BT_DEVICE_AUTHORIZED, /**< The remote Bluetooth device is authorized */
-	BT_DEVICE_UNAUTHORIZED, /**< The remote Bluetooth device is unauthorized */
-} bt_device_authorization_e;
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
- * @brief Enumerations of Bluetooth profile.
- */
-typedef enum
-{
-    BT_PROFILE_RFCOMM = 0x01, /**< RFCOMM Profile */
-    BT_PROFILE_A2DP = 0x02, /**< Advanced Audio Distribution Profile */
-    BT_PROFILE_HSP = 0x04, /**< Headset Profile */
-    BT_PROFILE_HID = 0x08, /**< Human Interface Device Profile */
-    BT_PROFILE_NAP = 0x10, /**< Network Profile */
-} bt_profile_e;
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE
- * @brief  Enumerations of Bluetooth socket connection state.
- */
-typedef enum
-{
-	BT_SOCKET_CONNECTED, /**< RFCOMM is connected */
-	BT_SOCKET_DISCONNECTED, /**< RFCOMM is disconnected */
-} bt_socket_connection_state_e;
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
- * @brief  Enumerations of major service class.
- */
-typedef enum
-{
-	BT_MAJOR_SERVICE_CLASS_LIMITED_DISCOVERABLE_MODE  = 0x002000, /**< Limited discoverable mode */
-	BT_MAJOR_SERVICE_CLASS_POSITIONING                = 0x010000, /**< Positioning class */
-	BT_MAJOR_SERVICE_CLASS_NETWORKING                 = 0x020000, /**< Networking class */
-	BT_MAJOR_SERVICE_CLASS_RENDERING                  = 0x040000, /**< Rendering class */
-	BT_MAJOR_SERVICE_CLASS_CAPTURING                  = 0x080000, /**< Capturing class */
-	BT_MAJOR_SERVICE_CLASS_OBJECT_TRANSFER            = 0x100000, /**< Object transferring class */
-	BT_MAJOR_SERVICE_CLASS_AUDIO                      = 0x200000, /**< Audio class*/
-	BT_MAJOR_SERVICE_CLASS_TELEPHONY                  = 0x400000, /**< Telephony class */
-	BT_MAJOR_SERVICE_CLASS_INFORMATION                = 0x800000, /**< Information class */
-} bt_major_service_class_e;
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
- * @brief  Enumerations of major device class.
- */
-typedef enum
-{
-	BT_MAJOR_DEVICE_CLASS_MISC = 0x00, /**< Miscellaneous major device class*/
-	BT_MAJOR_DEVICE_CLASS_COMPUTER = 0x01, /**< Computer major device class */
-	BT_MAJOR_DEVICE_CLASS_PHONE = 0x02, /**< Phone major device class */
-	BT_MAJOR_DEVICE_CLASS_LAN_NETWORK_ACCESS_POINT = 0x03, /**< LAN/Network access point major device class */
-	BT_MAJOR_DEVICE_CLASS_AUDIO_VIDEO = 0x04, /**< Audio/Video major device class */
-	BT_MAJOR_DEVICE_CLASS_PERIPHERAL = 0x05, /**< Peripheral major device class */
-	BT_MAJOR_DEVICE_CLASS_IMAGING = 0x06, /**< Imaging major device class */
-	BT_MAJOR_DEVICE_CLASS_WEARABLE = 0x07, /**< Wearable device class */
-	BT_MAJOR_DEVICE_CLASS_TOY = 0x08, /**< Toy device class */
-	BT_MAJOR_DEVICE_CLASS_HEALTH = 0x09, /**< Health device class */
-	BT_MAJOR_DEVICE_CLASS_UNCATEGORIZED = 0x1F, /**< Uncategorized major device class */
-} bt_major_device_class_e;
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
- * @brief  Enumerations of minor device class.
- */
-typedef enum
-{
-	BT_MINOR_DEVICE_CLASS_COMPUTER_UNCATEGORIZED = 0x00, /**< Uncategorized minor device class of computer */
-	BT_MINOR_DEVICE_CLASS_COMPUTER_DESKTOP_WORKSTATION = 0x04, /**< Desktop workstation minor device class of computer */
-	BT_MINOR_DEVICE_CLASS_COMPUTER_SERVER_CLASS = 0x08, /**< Server minor device class of computer */
-	BT_MINOR_DEVICE_CLASS_COMPUTER_LAPTOP = 0x0C, /**< Laptop minor device class of computer */
-	BT_MINOR_DEVICE_CLASS_COMPUTER_HANDHELD_PC_OR_PDA = 0x10, /**< Handheld PC/PDA minor device class of computer */
-	BT_MINOR_DEVICE_CLASS_COMPUTER_PALM_SIZED_PC_OR_PDA = 0x14, /**< Palm sized PC/PDA minor device class of computer */
-	BT_MINOR_DEVICE_CLASS_COMPUTER_WEARABLE_COMPUTER = 0x18, /**< Wearable(watch sized) minor device class of computer */
-
-	BT_MINOR_DEVICE_CLASS_PHONE_UNCATEGORIZED = 0x00, /**< Uncategorized minor device class of phone */
-	BT_MINOR_DEVICE_CLASS_PHONE_CELLULAR = 0x04, /**< Cellular minor device class of phone */
-	BT_MINOR_DEVICE_CLASS_PHONE_CORDLESS = 0x08, /**< Cordless minor device class of phone */
-	BT_MINOR_DEVICE_CLASS_PHONE_SMART_PHONE = 0x0C, /**< Smart phone minor device class of phone */
-	BT_MINOR_DEVICE_CLASS_PHONE_WIRED_MODEM_OR_VOICE_GATEWAY = 0x10, /**< Wired modem or voice gateway minor device class of phone */
-	BT_MINOR_DEVICE_CLASS_PHONE_COMMON_ISDN_ACCESS = 0x14, /**< Common ISDN minor device class of phone */
-
-	BT_MINOR_DEVICE_CLASS_LAN_NETWORK_ACCESS_POINT_FULLY_AVAILABLE = 0x04, /**< Fully available minor device class of LAN/Network access point */
-	BT_MINOR_DEVICE_CLASS_LAN_NETWORK_ACCESS_POINT_1_TO_17_PERCENT_UTILIZED = 0x20, /**< 1-17% utilized minor device class of LAN/Network access point */
-	BT_MINOR_DEVICE_CLASS_LAN_NETWORK_ACCESS_POINT_17_TO_33_PERCENT_UTILIZED = 0x40, /**< 17-33% utilized minor device class of LAN/Network access point */
-	BT_MINOR_DEVICE_CLASS_LAN_NETWORK_ACCESS_POINT_33_TO_50_PERCENT_UTILIZED = 0x60, /**< 33-50% utilized minor device class of LAN/Network access point */
-	BT_MINOR_DEVICE_CLASS_LAN_NETWORK_ACCESS_POINT_50_to_67_PERCENT_UTILIZED = 0x80, /**< 50-67% utilized minor device class of LAN/Network access point */
-	BT_MINOR_DEVICE_CLASS_LAN_NETWORK_ACCESS_POINT_67_TO_83_PERCENT_UTILIZED = 0xA0, /**< 67-83% utilized minor device class of LAN/Network access point */
-	BT_MINOR_DEVICE_CLASS_LAN_NETWORK_ACCESS_POINT_83_TO_99_PERCENT_UTILIZED = 0xC0, /**< 83-99% utilized minor device class of LAN/Network access point */
-	BT_MINOR_DEVICE_CLASS_LAN_NETWORK_ACCESS_POINT_NO_SERVICE_AVAILABLE = 0xE0, /**< No service available minor device class of LAN/Network access point */
-
-	BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_UNCATEGORIZED = 0x00, /**< Uncategorized minor device class of audio/video */
-	BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_WEARABLE_HEADSET = 0x04, /**< Wearable headset minor device class of audio/video */
-	BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_HANDS_FREE = 0x08, /**< Hands-free minor device class of audio/video */
-	BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_MICROPHONE = 0x10, /**< Microphone minor device class of audio/video */
-	BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_LOUDSPEAKER = 0x14, /**< Loudspeaker minor device class of audio/video */
-	BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_HEADPHONES = 0x18, /**< Headphones minor device class of audio/video */
-	BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_PORTABLE_AUDIO = 0x1C, /**< Portable audio minor device class of audio/video */
-	BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_CAR_AUDIO = 0x20, /**< Car audio minor device class of audio/video */
-	BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_SET_TOP_BOX = 0x24, /**< Set-top box minor device class of audio/video */
-	BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_HIFI_AUDIO_DEVICE = 0x28, /**< Hifi audio minor device class of audio/video */
-	BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_VCR = 0x2C, /**< VCR minor device class of audio/video */
-	BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_VIDEO_CAMERA = 0x30, /**< Video camera minor device class of audio/video */
-	BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_CAMCORDER = 0x34, /**< Camcorder minor device class of audio/video */
-	BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_VIDEO_MONITOR = 0x38, /**< Video monitor minor device class of audio/video */
-	BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_VIDEO_DISPLAY_LOUDSPEAKER = 0x3C, /**< Video display and loudspeaker minor device class of audio/video */
-	BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_VIDEO_CONFERENCING = 0x40, /**< Video conferencing minor device class of audio/video */
-	BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_GAMING_TOY = 0x48, /**< Gaming/toy minor device class of audio/video */
-
-	BT_MINOR_DEVICE_CLASS_PERIPHERA_UNCATEGORIZED = 0x00, /**< Uncategorized minor device class of peripheral */
-	BT_MINOR_DEVICE_CLASS_PERIPHERAL_KEY_BOARD = 0x40, /**< Key board minor device class of peripheral */
-	BT_MINOR_DEVICE_CLASS_PERIPHERAL_POINTING_DEVICE = 0x80, /**< Pointing device minor device class of peripheral */
-	BT_MINOR_DEVICE_CLASS_PERIPHERAL_COMBO_KEYBOARD_POINTING_DEVICE = 0xC0, /**< Combo keyboard or pointing device minor device class of peripheral */
-	BT_MINOR_DEVICE_CLASS_PERIPHERAL_JOYSTICK = 0x04, /**< Joystick minor device class of peripheral */
-	BT_MINOR_DEVICE_CLASS_PERIPHERAL_GAME_PAD = 0x08, /**< Game pad minor device class of peripheral */
-	BT_MINOR_DEVICE_CLASS_PERIPHERAL_REMOTE_CONTROL = 0x0C, /**< Remote control minor device class of peripheral */
-	BT_MINOR_DEVICE_CLASS_PERIPHERAL_SENSING_DEVICE = 0x10, /**< Sensing device minor device class of peripheral */
-	BT_MINOR_DEVICE_CLASS_PERIPHERAL_DIGITIZER_TABLET = 0x14, /**< Digitizer minor device class of peripheral */
-	BT_MINOR_DEVICE_CLASS_PERIPHERAL_CARD_READER = 0x18, /**< Card reader minor device class of peripheral */
-	BT_MINOR_DEVICE_CLASS_PERIPHERAL_DIGITAL_PEN = 0x1C, /**< Digital pen minor device class of peripheral */
-	BT_MINOR_DEVICE_CLASS_PERIPHERAL_HANDHELD_SCANNER = 0x20, /**< Handheld scanner minor device class of peripheral */
-	BT_MINOR_DEVICE_CLASS_PERIPHERAL_HANDHELD_GESTURAL_INPUT_DEVICE = 0x24, /**< Handheld gestural input device minor device class of peripheral */
-
-	BT_MINOR_DEVICE_CLASS_IMAGING_DISPLAY = 0x10, /**< Display minor device class of imaging */
-	BT_MINOR_DEVICE_CLASS_IMAGING_CAMERA = 0x20, /**< Camera minor device class of imaging */
-	BT_MINOR_DEVICE_CLASS_IMAGING_SCANNER = 0x40, /**< Scanner minor device class of imaging */
-	BT_MINOR_DEVICE_CLASS_IMAGING_PRINTER = 0x80, /**< Printer minor device class of imaging */
-
-	BT_MINOR_DEVICE_CLASS_WEARABLE_WRIST_WATCH = 0x04, /**< Wrist watch minor device class of wearable */
-	BT_MINOR_DEVICE_CLASS_WEARABLE_PAGER = 0x08, /**< Pager minor device class of wearable */
-	BT_MINOR_DEVICE_CLASS_WEARABLE_JACKET = 0x0C, /**< Jacket minor device class of wearable */
-	BT_MINOR_DEVICE_CLASS_WEARABLE_HELMET = 0x10, /**< Helmet minor device class of wearable */
-	BT_MINOR_DEVICE_CLASS_WEARABLE_GLASSES = 0x14, /**< Glasses minor device class of wearable */
-
-	BT_MINOR_DEVICE_CLASS_TOY_ROBOT = 0x04, /**< Robot minor device class of toy */
-	BT_MINOR_DEVICE_CLASS_TOY_VEHICLE = 0x08, /**< Vehicle minor device class of toy */
-	BT_MINOR_DEVICE_CLASS_TOY_DOLL_ACTION = 0x0C, /**< Doll/Action minor device class of toy */
-	BT_MINOR_DEVICE_CLASS_TOY_CONTROLLER = 0x10, /**< Controller minor device class of toy */
-	BT_MINOR_DEVICE_CLASS_TOY_GAME = 0x14, /**< Game minor device class of toy */
-
-	BT_MINOR_DEVICE_CLASS_HEATH_UNCATEGORIZED = 0x00, /**< Uncategorized minor device class of health */
-	BT_MINOR_DEVICE_CLASS_HEATH_BLOOD_PRESSURE_MONITOR = 0x04, /**< Blood pressure monitor minor device class of health */
-	BT_MINOR_DEVICE_CLASS_HEATH_THERMOMETER = 0x08, /**< Thermometer minor device class of health */
-	BT_MINOR_DEVICE_CLASS_HEATH_WEIGHING_SCALE = 0x0C, /**< Weighing scale minor device class of health */
-	BT_MINOR_DEVICE_CLASS_HEATH_GLUCOSE_METER = 0x10, /**< Glucose minor device class of health */
-	BT_MINOR_DEVICE_CLASS_HEATH_PULSE_OXIMETER = 0x14, /**< Pulse oximeter minor device class of health */
-	BT_MINOR_DEVICE_CLASS_HEATH_HEART_PULSE_RATE_MONITOR = 0x18, /**< Heart/Pulse rate monitor minor device class of health */
-	BT_MINOR_DEVICE_CLASS_HEATH_DATA_DISPLAY = 0x1C, /**< Health data display minor device class of health */
-	BT_MINOR_DEVICE_CLASS_HEATH_STEP_COUNTER = 0x20, /**< Step counter minor device class of health */
-	BT_MINOR_DEVICE_CLASS_HEATH_BODY_COMPOSITION_ANALYZER = 0x24, /**< Body composition analyzer minor device class of health */
-	BT_MINOR_DEVICE_CLASS_HEATH_PEAK_FLOW_MONITOR = 0x28, /**< Peak flow monitor minor device class of health */
-	BT_MINOR_DEVICE_CLASS_HEATH_MEDICATION_MONITOR = 0x2C, /**< Medication monitor minor device class of health */
-	BT_MINOR_DEVICE_CLASS_HEATH_KNEE_PROSTHESIS = 0x30, /**< Knee prosthesis minor device class of health */
-	BT_MINOR_DEVICE_CLASS_HEATH_ANKLE_PROSTHESIS = 0x34, /**< Ankle prosthesis minor device class of health */
-} 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_AUDIO_AG_MODULE
- * @brief  Enumerations for the call state
- */
-typedef enum {
-    BT_AG_CALL_EVENT_IDLE = 0x00,  /**< Idle */
-    BT_AG_CALL_EVENT_ANSWERED,  /**< Answered */
-    BT_AG_CALL_EVENT_HELD,  /**< Held */
-    BT_AG_CALL_EVENT_RETRIEVED,  /**< Retrieved */
-    BT_AG_CALL_EVENT_DIALING,  /**< Dialing */
-    BT_AG_CALL_EVENT_ALERTING,  /**< Alerting */
-    BT_AG_CALL_EVENT_INCOMING,  /**< Incoming */
-} bt_ag_call_event_e;
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
- * @brief  Enumerations for the call state
- */
-typedef enum {
-    BT_AG_CALL_STATE_IDLE = 0x00,  /**< Idle state */
-    BT_AG_CALL_STATE_ACTIVE,  /**< Active state */
-    BT_AG_CALL_STATE_HELD,  /**< Held state */
-    BT_AG_CALL_STATE_DIALING,  /**< Dialing state */
-    BT_AG_CALL_STATE_ALERTING,  /**< Alerting state */
-    BT_AG_CALL_STATE_INCOMING,  /**< Incoming state */
-    BT_AG_CALL_STATE_WAITING,  /**< Waiting for connected indication event after answering an incoming call*/
-} bt_ag_call_state_e;
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
- * @brief  Enumerations for the call handling event
- */
-typedef enum {
-    BT_AG_CALL_HANDLING_EVENT_ANSWER = 0x00,  /**< Request to answer an incoming call */
-    BT_AG_CALL_HANDLING_EVENT_RELEASE,  /**< Request to release a call */
-    BT_AG_CALL_HANDLING_EVENT_REJECT,  /**< Request to reject an incoming call */
-} bt_ag_call_handling_event_e;
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
- * @brief  Enumerations for the multi call handling event
- */
-typedef enum {
-    BT_AG_MULTI_CALL_HANDLING_EVENT_RELEASE_HELD_CALLS = 0x00,  /**< Request to release held calls */
-    BT_AG_MULTI_CALL_HANDLING_EVENT_RELEASE_ACTIVE_CALLS,  /**< Request to release active calls */
-    BT_AG_MULTI_CALL_HANDLING_EVENT_ACTIVATE_HELD_CALL,  /**< Request to put active calls into hold state and activate another (held or waiting) call */
-    BT_AG_MULTI_CALL_HANDLING_EVENT_MERGE_CALLS,  /**< Request to add a held call to the conversation */
-    BT_AG_MULTI_CALL_HANDLING_EVENT_EXPLICIT_CALL_TRANSFER,  /**< Request to let a user who has two calls to connect these two calls together and release its connections to both other parties */
-} bt_ag_multi_call_handling_event_e;
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
- * @brief  The handle of calls state
- */
-typedef void* bt_call_list_h;
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_GATT_MODULE
- * @brief  The attribute handle of GATT(Generic Attribute Profile)
- */
-typedef void* bt_gatt_attribute_h;
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
- * @brief Class structure of device and service.
- *
- * @see #bt_device_info_s
- * @see #bt_adapter_device_discovery_info_s
- * @see bt_device_bond_created_cb()
- * @see bt_adapter_device_discovery_state_changed_cb()
- */
-typedef struct
-{
-	bt_major_device_class_e major_device_class;	/**< Major device class. */
-	bt_minor_device_class_e minor_device_class;	/**< Minor device class. */
-	int major_service_class_mask;	/**< Major service class mask.
-	This value can be a combination of #bt_major_service_class_e like #BT_MAJOR_SERVICE_CLASS_RENDERING | #BT_MAJOR_SERVICE_CLASS_AUDIO */
-} bt_class_s;
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief Structure of device discovery information.
- *
- * @see #bt_class_s
- * @see bt_adapter_device_discovery_state_changed_cb()
- */
-typedef struct
-{
-	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 */
-	unsigned char device_type;  /**< The Device Type of Remote Device */
-} bt_adapter_device_discovery_info_s;
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
- * @brief Device information structure used for identifying pear device.
- *
- * @see #bt_class_s
- * @see bt_device_bond_created_cb()
- */
-typedef struct
-{
-	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 */
-	int service_count;	/**< The number of services */
-	bool is_bonded;	/**< The bonding state */
-	bool is_connected;	/**< The connection state */
-	bool is_authorized;	/**< The authorization state */
-} bt_device_info_s;
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
- * @brief Service Discovery Protocol (SDP) data structure.
- *
- * @details This protocol is used for discovering available services or pear device,
- * and finding one to connect with.
- *
- * @see bt_device_service_searched_cb()
- */
-typedef struct
-{
-	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;
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE
- *
- * @brief Rfcomm connection data used for exchanging data between Bluetooth devices.
- *
- * @see bt_socket_connection_state_changed_cb()
- */
-typedef struct
-{
-	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 *service_uuid;	/**< The service UUId */
-} bt_socket_connection_s;
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE
- *
- * @brief Structure of RFCOMM received data.
- *
- * @remarks User can use standard linux functions for reading/writing
- * data from/to sockets.
- *
- * @see bt_socket_data_received_cb()
- */
-typedef struct
-{
-	int socket_fd;	/**< The socket fd */
-	int data_size;	/**< The length of the received data */
-	char *data;	/**< The received data */
-} bt_socket_received_data_s;
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief  Called when the Bluetooth adapter state changes.
- * @param[in]   result  The result of the adapter state changing
- * @param[in]   adapter_state  The adapter state to be changed
- * @param[in]   user_data  The user data passed from the callback registration function
- * @pre Either bt_adapter_enable() or bt_adapter_disable() will invoke this callback if you register this callback using bt_adapter_set_state_changed_cb().
- * @see bt_adapter_enable()
- * @see bt_adapter_disable()
- * @see bt_adapter_set_state_changed_cb()
- * @see bt_adapter_unset_state_changed_cb()
- */
-typedef void (*bt_adapter_state_changed_cb)(int result, bt_adapter_state_e adapter_state, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief  Called when adapter name changes.
- * @param[in]   device_name	The name of the Bluetooth device to be changed
- * @param[in]   user_data	The user data passed from the callback registration function
- * @pre This function will be invoked when the name of Bluetooth adapter changes
- * if you register this callback using bt_adapter_set_name_changed_cb().
- * @see bt_adapter_set_name()
- * @see bt_adapter_set_name_changed_cb()
- * @see bt_adapter_unset_name_changed_cb()
- */
-typedef void (*bt_adapter_name_changed_cb)(char *device_name, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief  Called when the visibility mode changes.
- * @param[in] result The result of the visibility mode changing
- * @param[in] visibility_mode The visibility mode to be changed
- * @param[in] user_data The user data passed from the callback registration function
- *
- * @pre This function will be invoked when the visibility of Bluetooth adapter changes
- * if you register this callback using bt_adapter_set_visibility_mode_changed_cb().
- *
- * @see bt_adapter_set_visibility()
- * @see bt_adapter_set_visibility_mode_changed_cb()
- * @see bt_adapter_unset_visibility_mode_changed_cb()
- */
-typedef void (*bt_adapter_visibility_mode_changed_cb)
-	(int result, bt_adapter_visibility_mode_e visibility_mode, void *user_data);
-
-/**
- * @ingroup  CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief  Called every second until the visibility mode is changed to #BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE.
- * @remarks  This callback function is called only if visibility mode is #BT_ADAPTER_VISIBILITY_MODE_LIMITED_DISCOVERABLE.
- * @param[in]  duration  The duration until the visibility mode is changed to #BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE (in seconds)
- * @param[in]  user_data  The user data passed from the callback registration function
- * @pre  This function will be invoked if you register this callback using bt_adapter_set_visibility_duration_changed_cb().
- * @see  bt_adapter_set_visibility_duration_changed_cb()
- * @see  bt_adapter_unset_visibility_duration_changed_cb()
- * @see  bt_adapter_set_visibility()
- */
-typedef void (*bt_adapter_visibility_duration_changed_cb)(int duration, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief  Called when the state of device discovery changes.
- *
- * @remarks If \a discovery_state is #BT_ADAPTER_DEVICE_DISCOVERY_FOUND,
- * then you can get some information, such as remote device address, remote device name, rssi, and bonding state.
- *
- * @param[in] result The result of the device discovery
- * @param[in] discovery_state The discovery state to be changed
- * @param[in] device_info The information of the discovered device \n
- *					If \a discovery_state is #BT_ADAPTER_DEVICE_DISCOVERY_STARTED or
- * #BT_ADAPTER_DEVICE_DISCOVERY_FINISHED, then \a device_info is NULL.
- * @param[in] user_data The user data passed from the callback registration function
- *
- * @pre Either bt_adapter_start_device_discovery() or bt_adapter_stop_device_discovery() will invoke this function
- * if you register this callback using bt_adapter_set_device_discovery_state_changed_cb().
- *
- * @see bt_adapter_start_device_discovery()
- * @see bt_adapter_stop_device_discovery()
- * @see bt_adapter_set_device_discovery_state_changed_cb()
- * @see bt_adapter_unset_device_discovery_state_changed_cb()
- *
- */
-typedef void (*bt_adapter_device_discovery_state_changed_cb)
-	(int result, bt_adapter_device_discovery_state_e discovery_state, bt_adapter_device_discovery_info_s *discovery_info, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief  Called when you get bonded devices repeatedly.
- *
- * @param[in] device_info The bonded device information
- * @param[in] user_data The user data passed from the foreach function
- * @return @c true to continue with the next iteration of the loop,
- * \n @c false to break out of the loop.
- * @pre bt_adapter_foreach_bonded_device() will invoke this function.
- *
- * @see bt_adapter_foreach_bonded_device()
- *
- */
-typedef bool (*bt_adapter_bonded_device_cb)(bt_device_info_s *device_info, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
- * @brief Called when the process of creating bond finishes.
- * @remarks If the remote user does not respond within 60 seconds, a time out will happen with #BT_ERROR_TIMED_OUT result code.\n
- * If bt_device_cancel_bonding() is called and it returns #BT_ERROR_NONE, then this callback function will be called
- * with #BT_ERROR_CANCELLED result. \n
- * If creating a bond succeeds but service search fails, then this callback will be called with #BT_ERROR_SERVICE_SEARCH_FAILED.
- * In this case, you should try service search again by bt_device_start_service_search() to get the supported service list.
- *
- * @param[in] result The result of the bonding device
- * @param[in] device_info The device information which you creates bond with
- * @param[in] user_data The user data passed from the callback registration function
- *
- * @pre Either bt_device_create_bond() will invoke this function
- * if you register this callback using bt_device_set_bond_created_cb().
- *
- * @see bt_device_create_bond()
- * @see bt_device_cancel_bonding()
- * @see bt_device_set_bond_created_cb()
- * @see bt_device_unset_bond_created_cb()
- */
-typedef void (*bt_device_bond_created_cb)(int result, bt_device_info_s *device_info, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
- * @brief  Called when you get connected profiles repeatedly.
- * @param[in] profile The connected Bluetooth profile
- * @param[in] user_data The user data passed from the foreach function
- * @return @c true to continue with the next iteration of the loop,
- * \n @c false to break out of the loop.
- * @pre bt_device_foreach_connected_profiles() will invoke this function.
- * @see bt_device_foreach_connected_profiles()
- */
-typedef bool (*bt_device_connected_profile)(bt_profile_e profile, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
- * @brief  Called when the bond destroys.
- * @param[in] result The result that a bond is destroyed
- * @param[in] remote_address The address of the remote Bluetooth device to destroy bond with
- * @param[in] user_data The user data passed from the callback registration function
- * @pre bt_device_destroy_bond() will invoke this function
- * if you register this callback using bt_device_set_bond_destroyed_cb().
- *
- * @see bt_device_destroy_bond()
- * @see bt_device_set_bond_destroyed_cb()
- * @see bt_device_unset_bond_destroyed_cb()
- */
-typedef void (*bt_device_bond_destroyed_cb)(int result, char *remote_address, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
- * @brief  Called when the authorization of device changes.
- * @param[in] authorization The authorization of device
- * @param[in] remote_address The address of the remote Bluetooth device which is (un)authorized
- * @param[in] user_data The user data passed from the callback registration function
- * @pre bt_device_set_authorization() will invoke this function if you register this callback using bt_device_set_authorization_changed_cb().
- *
- * @see bt_device_set_authorization()
- * @see #bt_device_set_authorization_changed_cb()
- * @see #bt_device_unset_authorization_changed_cb()
- */
-typedef void (*bt_device_authorization_changed_cb)
-	(bt_device_authorization_e authorization, char *remote_address, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
- * @brief  Called when the process of service search finishes.
- * @remark If bt_device_cancel_service_search() is called and it returns #BT_ERROR_NONE,
- * then this callback function will be called with #BT_ERROR_CANCELLED result.
- *
- * @param[in] result The result of the service searching
- * @param[in] sdp_info The structure of service lists found on a device
- * @param[in] user_data The user data passed from the callback registration function
- * @pre Either bt_device_start_service_search() will invoke this function
- * if you register this callback using  bt_device_set_service_searched_cb().
- *
- * @see bt_device_start_service_search()
- * @see bt_device_cancel_service_search()
- * @see bt_device_set_service_searched_cb()
- * @see bt_device_unset_service_searched_cb()
- *
- */
-typedef void (*bt_device_service_searched_cb)(int result, bt_device_sdp_info_s *sdp_info, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
- * @brief  Called when the connection state is changed.
- * @param[in] connected The connection status: (@c true = connected, @c false = disconnected)
- * @param[in] remote_address The address of the remote Bluetooth device
- * @param[in] user_data The user data passed from the callback registration function
- * @see bt_device_set_connection_state_changed_cb()
- * @see bt_device_unset_connection_state_changed_cb()
- */
-typedef void (*bt_device_connection_state_changed_cb)(bool connected, const char *remote_address, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE
- * @brief Called when you receive data.
- *
- * @param[in] data The received data from the remote device
- * @param[in] user_data The user data passed from the callback registration function
- *
- * @pre When the connected remote Bluetooth device invokes bt_socket_send_data(),
- *		this function will be invoked if you register this function using bt_socket_set_data_received_cb().
- *
- * @see bt_socket_set_data_received_cb()
- * @see bt_socket_unset_data_received_cb()
- * @see bt_socket_send_data()
- */
-typedef void (*bt_socket_data_received_cb)(bt_socket_received_data_s *data, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE
- * @brief  Called when the socket connection state changes.
- * @param[in] result The result of connection state changing
- * @param[in] connection_state The connection state
- * @param[in] connection The connection information which is established or disconnected
- * @param[in] user_data The user data passed from the callback registration function
- * @pre Either bt_socket_connect_rfcomm() will invoke this function.
- * In addtion, bt_socket_connection_state_changed_cb() will be invoked when the socket connection state is changed.
- * @see bt_socket_listen_and_accept_rfcomm()
- * @see bt_socket_connect_rfcomm()
- * @see bt_socket_set_connection_state_changed_cb()
- * @see bt_socket_unset_connection_state_changed_cb()
- */
-typedef void (*bt_socket_connection_state_changed_cb)
-	(int result, bt_socket_connection_state_e connection_state, bt_socket_connection_s *connection, void *user_data);
-
 
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_MODULE
  * @brief Initializes the Bluetooth API.
+ * @since_tizen 2.3
  *
  * @remarks This function must be called before Bluetooth API starts. \n
  * You must free all resources of the Bluetooth service by calling bt_deinitialize() if Bluetooth service is no longer needed.
@@ -765,6 +54,7 @@ typedef void (*bt_socket_connection_state_changed_cb)
  * @return 0 on success, otherwise a negative error value.
  * @retval #BT_ERROR_NONE  Successful
  * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
  *
  * @see  bt_deinitialize()
  */
@@ -774,6 +64,7 @@ int bt_initialize(void);
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_MODULE
  * @brief Releases all resources of the Bluetooth API.
+ * @since_tizen 2.3
  *
  * @remarks This function must be called if Bluetooth API is no longer needed.
  *
@@ -781,6 +72,7 @@ int bt_initialize(void);
  * @retval #BT_ERROR_NONE  Successful
  * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
  * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
  *
  * @pre Bluetooth API must be initialized with bt_initialize().
  *
@@ -788,10 +80,13 @@ int bt_initialize(void);
  */
 int bt_deinitialize(void);
 
-
 /**
+ * @internal
  * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
  * @brief Enables the local Bluetooth adapter, asynchronously.
+ * @since_tizen 2.3
+ * @privlevel platform
+ * @privilege %http://tizen.org/privilege/bluetooth.admin
  *
  * @details This function enables Bluetooth protocol stack and hardware.
  *
@@ -800,13 +95,15 @@ int bt_deinitialize(void);
  * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
  * @retval #BT_ERROR_ALREADY_DONE  Already enabled
  * @retval #BT_ERROR_NOW_IN_PROGRESS  Operation now in progress
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
  *
  * @pre Bluetooth service must be initialized with bt_initialize().
+ * @pre The state of local Bluetooth must be #BT_ADAPTER_DISABLED
  * @post This function invokes bt_adapter_state_changed_cb().
  *
  * @see bt_initialize()
  * @see bt_adapter_get_state()
- * @see bt_adapter_disable()
  * @see bt_adapter_set_state_changed_cb()
  * @see bt_adapter_unset_state_changed_cb()
  * @see bt_adapter_state_changed_cb()
@@ -815,24 +112,29 @@ int bt_deinitialize(void);
 int bt_adapter_enable(void);
 
 /**
+ * @internal
  * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
  * @brief Disables the local Bluetooth adapter, asynchronously.
+ * @since_tizen 2.3
+ * @privlevel platform
+ * @privilege %http://tizen.org/privilege/bluetooth.admin
  *
  * @details This function disables Bluetooth protocol stack and hardware.
  *
- * @remarks You should disable Bluetooth adapter to switch off Bluetooth chip, which is helpful for saving power.
+ * @remarks You should disable Bluetooth adapter, which is helpful for saving power.
  *
  * @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_NOW_IN_PROGRESS  Operation now in progress
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
  *
- * @pre Bluetooth API must be enabled with bt_adapter_enable().
+ * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED
  * @post This function invokes bt_adapter_state_changed_cb().
  *
  * @see bt_adapter_get_state()
- * @see bt_adapter_enable()
  * @see bt_adapter_state_changed_cb()
  * @see bt_adapter_set_state_changed_cb()
  * @see bt_adapter_unset_state_changed_cb ()
@@ -841,8 +143,41 @@ int bt_adapter_enable(void);
 int bt_adapter_disable(void);
 
 /**
+ * @internal
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
+ * @brief Recover the local Bluetooth adapter, asynchronously.
+ * @since_tizen 2.3
+ * @privlevel platform
+ * @privilege %http://tizen.org/privilege/bluetooth.admin
+ *
+ * @details This function does recovery logic, disables Bluetooth protocol stack and hardware, then enables after a few seconds.
+ *
+ * @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_NOW_IN_PROGRESS  Operation now in progress
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
+ * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED
+ * @post This function invokes bt_adapter_state_changed_cb().
+ *
+ * @see bt_adapter_get_state()
+ * @see bt_adapter_state_changed_cb()
+ * @see bt_adapter_set_state_changed_cb()
+ * @see bt_adapter_unset_state_changed_cb ()
+ *
+ */
+int bt_adapter_recover(void);
+
+/**
+ * @internal
  * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
  * @brief Reset the local Bluetooth adapter, synchronously.
+ * @since_tizen 2.3
+ * @privlevel platform
+ * @privilege %http://tizen.org/privilege/bluetooth.admin
  *
  * @details This function resets Bluetooth protocol and values.
  *
@@ -850,6 +185,8 @@ int bt_adapter_disable(void);
  * @retval #BT_ERROR_NONE  Successful
  * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
  * @retval #BT_ERROR_OPERATION_FAILED Operation failed
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
  *
  * @pre Bluetooth service must be initialized with bt_initialize().
  * @post bt_adapter_state_changed_cb() will be invoked if The state of local Bluetooth was #BT_ADAPTER_ENABLED.
@@ -866,6 +203,7 @@ int bt_adapter_reset(void);
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
  * @brief Gets the current state of local Bluetooth adapter.
+ * @since_tizen 2.3
  *
  * @param[out] adapter_state The current adapter state
  *
@@ -873,18 +211,18 @@ int bt_adapter_reset(void);
  * @retval #BT_ERROR_NONE  Successful
  * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
  * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
  *
  * @pre Bluetooth service must be initialized with bt_initialize().
  *
  * @see bt_initialize()
- * @see bt_adapter_enable()
- * @see bt_adapter_disable()
  */
 int bt_adapter_get_state(bt_adapter_state_e *adapter_state);
 
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
  * @brief Gets the address of local Bluetooth adapter.
+ * @since_tizen 2.3
  *
  * @remarks The @a local_address must be released with free() by you.
  *
@@ -897,15 +235,64 @@ int bt_adapter_get_state(bt_adapter_state_e *adapter_state);
  * @retval #BT_ERROR_NOT_ENABLED  Not enabled
  * @retval #BT_ERROR_OUT_OF_MEMORY  Out of memory
  * @retval #BT_ERROR_OPERATION_FAILED Operation failed
- * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED with bt_adapter_enable().
- * @see bt_adapter_enable()
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
+ * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED.
  * @see bt_adapter_get_name()
  */
 int bt_adapter_get_address(char **local_address);
 
 /**
+ * @internal
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
+ * @brief Gets the version of local Bluetooth adapter.
+ * @since_tizen 2.3
+ * @remarks The @a local_version must be released with free() by you.
+ *
+ * @param[out] local_version The version of local Bluetooth adapter
+ *
+ * @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_OUT_OF_MEMORY  Out of memory
+ * @retval #BT_ERROR_OPERATION_FAILED Operation failed
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
+ * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED.
+ */
+int bt_adapter_get_version(char **local_version);
+
+/**
+ * @internal
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
+ * @brief Gets the information regarding local Bluetooth adapter.
+ * @since_tizen 2.3
+ * @remarks The @a all parameters must be released with free() by you.
+ *
+ * @param[out] chipset Chipset name of local Bluetooth adapter
+ * @param[out] firmware Firmware info. of local Bluetooth adapter
+ * @param[out] stack_version Bluetooth stack version
+ * @param[out] profiles The profile list of local Bluetooth adapter
+ *
+ * @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_OUT_OF_MEMORY  Out of memory
+ * @retval #BT_ERROR_OPERATION_FAILED Operation failed
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
+ * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED.
+ */
+int bt_adapter_get_local_info(char **chipset, char **firmware, char **stack_version, char **profiles);
+
+/**
  * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
  * @brief Gets the name of local Bluetooth adapter.
+ * @since_tizen 2.3
  *
  * @details Use this function to get the friendly name associated with Bluetooth
  * device, retrieved by the remote Bluetooth devices.
@@ -921,10 +308,10 @@ int bt_adapter_get_address(char **local_address);
  * @retval #BT_ERROR_NOT_ENABLED  Not enabled
  * @retval #BT_ERROR_OUT_OF_MEMORY  Out of memory
  * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
  *
- * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED with bt_adapter_enable().
+ * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED.
  *
- * @see bt_adapter_enable()
  * @see bt_adapter_set_name()
  */
 int bt_adapter_get_name(char **local_name);
@@ -932,6 +319,9 @@ int bt_adapter_get_name(char **local_name);
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
  * @brief Sets the name of local Bluetooth adapter.
+ * @since_tizen 2.3
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/bluetooth
  *
  * @param[in] local_name The name of the Bluetooth device. \n
  *				The maximum length is 248 characters.
@@ -942,11 +332,12 @@ int bt_adapter_get_name(char **local_name);
  * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
  * @retval #BT_ERROR_NOT_ENABLED  Not enabled
  * @retval #BT_ERROR_OPERATION_FAILED Operation failed
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
  *
- * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED with bt_adapter_enable().
+ * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED.
  * @post bt_adapter_name_changed_cb() will be invoked if this function returns #BT_ERROR_NONE.
  *
- * @see bt_adapter_enable()
  * @see bt_adapter_get_name()
  * @see bt_adapter_name_changed_cb()
  * @see bt_adapter_set_name_changed_cb()
@@ -957,6 +348,7 @@ int bt_adapter_set_name(const char *local_name);
 /**
  * @ingroup  CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
  * @brief  Gets the visibility mode of local Bluetooth adapter.
+ * @since_tizen 2.3
  * @param[out] mode  The visibility mode of the Bluetooth device
  * @param[out] duration  The duration until the visibility mode is changed to #BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE (in seconds).
  * @a duration is valid only if @a mode is #BT_ADAPTER_VISIBILITY_MODE_LIMITED_DISCOVERABLE. This value can be NULL.
@@ -966,15 +358,19 @@ int bt_adapter_set_name(const char *local_name);
  * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
  * @retval #BT_ERROR_NOT_ENABLED  Not enabled
  * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
- * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED with bt_adapter_enable().
- * @see bt_adapter_enable()
- * @see bt_adapter_set_visibility()
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
+ * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED.
  */
 int bt_adapter_get_visibility(bt_adapter_visibility_mode_e *mode, int *duration);
 
 /**
+ * @internal
  * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
  * @brief Sets the visibility mode.
+ * @since_tizen 2.3
+ * @privlevel platform
+ * @privilege %http://tizen.org/privilege/bluetooth.admin
  *
  * @remarks #BT_ADAPTER_VISIBILITY_MODE_LIMITED_DISCOVERABLE will change to #BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE
  * after the given @a duration goes.
@@ -989,11 +385,12 @@ int bt_adapter_get_visibility(bt_adapter_visibility_mode_e *mode, int *duration)
  * @retval #BT_ERROR_NOT_ENABLED  Not enabled
  * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
  * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
  *
- * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED with bt_adapter_enable().
+ * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED.
  * @post bt_adapter_visibility_mode_changed_cb() will be invoked if this function returns #BT_ERROR_NONE.
  *
- * @see bt_adapter_enable()
  * @see bt_adapter_get_visibility()
  * @see bt_adapter_visibility_mode_changed_cb()
  * @see bt_adapter_set_visibility_mode_changed_cb()
@@ -1003,41 +400,10 @@ int bt_adapter_set_visibility(bt_adapter_visibility_mode_e discoverable_mode, in
 
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief Starts the device discovery for a particular type, asynchronously. The various
- * supporting discovery types are BT_ADAPTER_DEVICE_DISCOVERY_BREDR, BT_ADAPTER_DEVICE_DISCOVERY_LE
- * and BT_ADAPTER_DEVICE_DISCOVERY_LE_BREDR.
- *
- * @details If a device is discovered for a particular type, bt_adapter_device_discovery_state_changed_cb()
-*  will be invoked with #BT_ADAPTER_DEVICE_DISCOVERY_FOUND, and then bt_adapter_device_discovery_state_changed_cb()
- * will be called with #BT_ADAPTER_DEVICE_DISCOVERY_FINISHED in case of the completion or cancellation of the discovery.
- *
- * @remarks To connect to peer Bluetooth device, you need to know its Bluetooth address. \n
- * The device discovery can be stopped by bt_adapter_stop_device_discovery(). This API is similar to
- * bt_adapter_start_device_discovery() but here we can specify the device type to be discovered which
- * could makes the discovery procedure faster.
- *
- * @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_NOW_IN_PROGRESS  Operation is now in progress
- * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
- *
- * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED with bt_adapter_enable().
- * @post This function invokes bt_adapter_device_discovery_state_changed_cb().
- *
- * @see bt_adapter_enable()
- * @see bt_adapter_is_discovering()
- * @see bt_adapter_stop_device_discovery()
- * @see bt_adapter_device_discovery_state_changed_cb()
- * @see bt_adapter_set_device_discovery_state_changed_cb()
- * @see bt_adapter_unset_device_discovery_state_changed_cb()
- */
-int bt_adapter_start_discover_devices(bt_adapter_discover_devices_type_e type);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
  * @brief Starts the device discovery, asynchronously.
+ * @since_tizen 2.3
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/bluetooth
  *
  * @details If a device is discovered, bt_adapter_device_discovery_state_changed_cb() will be invoked
  * with #BT_ADAPTER_DEVICE_DISCOVERY_FOUND, and then bt_adapter_device_discovery_state_changed_cb()
@@ -1052,11 +418,12 @@ int bt_adapter_start_discover_devices(bt_adapter_discover_devices_type_e type);
  * @retval #BT_ERROR_NOT_ENABLED  Not enabled
  * @retval #BT_ERROR_NOW_IN_PROGRESS  Operation is now in progress
  * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
  *
- * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED with bt_adapter_enable().
+ * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED.
  * @post This function invokes bt_adapter_device_discovery_state_changed_cb().
  *
- * @see bt_adapter_enable()
  * @see bt_adapter_is_discovering()
  * @see bt_adapter_stop_device_discovery()
  * @see bt_adapter_device_discovery_state_changed_cb()
@@ -1068,6 +435,9 @@ int bt_adapter_start_device_discovery(void);
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
  * @brief Stops the device discovery, asynchronously.
+ * @since_tizen 2.3
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/bluetooth
  * @remarks The device discovery process will take 10 ~ 20 seconds to get all the devices in vicinity.
  *
  * @return 0 on success, otherwise a negative error value.
@@ -1076,6 +446,8 @@ int bt_adapter_start_device_discovery(void);
  * @retval #BT_ERROR_NOT_ENABLED  Not enabled
  * @retval #BT_ERROR_NOT_IN_PROGRESS  Operation is not in progress
  * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
  *
  * @pre The device discovery must be in progress with bt_adapter_start_device_discovery().
  * @post This function invokes bt_adapter_device_discovery_state_changed_cb().
@@ -1091,6 +463,7 @@ int bt_adapter_stop_device_discovery(void);
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
  * @brief Checks for the device discovery is in progress or not.
+ * @since_tizen 2.3
  *
  * @remarks If Bluetooth discovery is in progress, other operations are not allowed and
  * you have to either stop the discovery operation, or wait for it to be finished,
@@ -1104,18 +477,39 @@ int bt_adapter_stop_device_discovery(void);
  * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
  * @retval #BT_ERROR_NOT_ENABLED  Not enabled
  * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
  *
- * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED with bt_adapter_enable().
+ * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED.
  *
- * @see bt_adapter_enable()
  * @see bt_adapter_start_device_discovery()
  * @see bt_adapter_stop_device_discovery()
  */
 int bt_adapter_is_discovering(bool *is_discovering);
 
 /**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
+ * @brief Get the service mask from the uuid list.
+ * @since_tizen 2.3
+ *
+ * @param[in] uuids The UUID list of the device.
+ * @param[in] no_of_service The number of the UUID list count.
+ * @param[out] service_mask_list Service mask list converted from the given UUID list.
+ *
+ * @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_SUPPORTED  Not supported
+ *
+ * @see bt_service_class_t
+ */
+int bt_device_get_service_mask_from_uuid_list(char **uuids,
+				      int no_of_service,
+				      bt_service_class_t *service_mask_list);
+
+/**
  * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
  * @brief Retrieves the device information of all bonded devices.
+ * @since_tizen 2.3
  *
  * @param [in] callback The callback function to invoke
  * @param [in] user_data The user data passed from the foreach function
@@ -1127,18 +521,19 @@ int bt_adapter_is_discovering(bool *is_discovering);
  * @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_NOT_SUPPORTED  Not supported
  *
- * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED with bt_adapter_enable().
+ * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED.
  * @post This function invokes bt_adapter_bonded_device_cb().
  *
  * @see bt_adapter_bonded_device_cb()
- * @see bt_adapter_enable()
  */
 int bt_adapter_foreach_bonded_device(bt_adapter_bonded_device_cb callback, void *user_data);
 
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
  * @brief Gets the device information of a bonded device.
+ * @since_tizen 2.3
  * @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
@@ -1152,24 +547,26 @@ int bt_adapter_foreach_bonded_device(bt_adapter_bonded_device_cb callback, void
  * @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
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
  *
- * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED with bt_adapter_enable().
+ * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED.
  * @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.
+ * @since_tizen 2.3
  *
  * @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
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
  *
  * @see bt_adapter_get_bonded_device_info()
  */
@@ -1178,6 +575,7 @@ 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
+ * @since_tizen 2.3
  * @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.
@@ -1187,13 +585,14 @@ int bt_adapter_free_device_info(bt_device_info_s *device_info);
  * @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()
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
  */
 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.
+ * @since_tizen 2.3
  *
  * @param[in] callback	The callback function to invoke
  * @param[in] user_data	The user data to be passed to the callback function
@@ -1202,6 +601,7 @@ int bt_adapter_is_service_used(const char *service_uuid, bool *used);
  * @retval #BT_ERROR_NONE  Successful
  * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
  * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
  *
  * @pre The Bluetooth service must be initialized with bt_initialize().
  * @post bt_adapter_state_changed_cb() will be invoked.
@@ -1216,10 +616,12 @@ int bt_adapter_set_state_changed_cb(bt_adapter_state_changed_cb callback, void *
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
  * @brief	Unregisters the callback function.
+ * @since_tizen 2.3
  *
  * @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_SUPPORTED  Not supported
  *
  * @pre The Bluetooth service must be initialized with bt_initialize().
  *
@@ -1231,6 +633,7 @@ int bt_adapter_unset_state_changed_cb(void);
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
  * @brief  Registers a callback function to be invoked when the name of Bluetooth adapter changes.
+ * @since_tizen 2.3
  *
  * @param[in] callback The callback function to invoke
  * @param[in] user_data The user data to be passed to the callback function
@@ -1239,6 +642,7 @@ int bt_adapter_unset_state_changed_cb(void);
  * @retval #BT_ERROR_NONE  Successful
  * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
  * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
  *
  * @pre The Bluetooth service must be initialized with bt_initialize().
  * @post  bt_adapter_name_changed_cb() will be invoked.
@@ -1252,10 +656,12 @@ int bt_adapter_set_name_changed_cb(bt_adapter_name_changed_cb callback, void *us
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
  * @brief	Unregisters the callback function.
+ * @since_tizen 2.3
  *
  * @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_SUPPORTED  Not supported
  *
  * @pre The Bluetooth service must be initialized with bt_initialize().
  *
@@ -1267,6 +673,7 @@ int bt_adapter_unset_name_changed_cb(void);
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
  * @brief  Registers a callback function to be invoked when the visibility mode changes.
+ * @since_tizen 2.3
  *
  * @param[in] callback The callback function to register
  * @param[in] user_data The user data to be passed to the callback function
@@ -1275,6 +682,7 @@ int bt_adapter_unset_name_changed_cb(void);
  * @retval #BT_ERROR_NONE  Successful
  * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
  * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
  *
  * @pre The Bluetooth service must be initialized with bt_initialize().
  * @post bt_adapter_visibility_mode_changed_cb() will be invoked.
@@ -1288,10 +696,12 @@ int bt_adapter_set_visibility_mode_changed_cb(bt_adapter_visibility_mode_changed
 /**
  * @ingroup  CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
  * @brief  Unregisters the callback function.
+ * @since_tizen 2.3
  *
  * @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_SUPPORTED  Not supported
  *
  * @pre  The Bluetooth service must be initialized with bt_initialize().
  *
@@ -1303,6 +713,7 @@ int bt_adapter_unset_visibility_mode_changed_cb(void);
 /**
  * @ingroup  CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
  * @brief  Registers a callback function to be invoked every second
+ * @since_tizen 2.3
  * until the visibility mode is changed from #BT_ADAPTER_VISIBILITY_MODE_LIMITED_DISCOVERABLE
  * to #BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE.
  * @details  When you set visibility mode as #BT_ADAPTER_VISIBILITY_MODE_LIMITED_DISCOVERABLE,
@@ -1313,10 +724,11 @@ int bt_adapter_unset_visibility_mode_changed_cb(void);
  * @retval  #BT_ERROR_NONE  Successful
  * @retval  #BT_ERROR_NOT_INITIALIZED  Not initialized
  * @retval  #BT_ERROR_INVALID_PARAMETER  Invalid parameter
+ * @retval  #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
  * @pre  The Bluetooth service must be initialized by bt_initialize().
  * @post  bt_adapter_visibility_duration_changed_cb() will be invoked.
  * @see  bt_initialize()
- * @see  bt_adapter_set_visibility()
  * @see  bt_adapter_visibility_duration_changed_cb()
  * @see  bt_adapter_unset_visibility_duration_changed_cb()
  */
@@ -1325,9 +737,12 @@ int bt_adapter_set_visibility_duration_changed_cb(bt_adapter_visibility_duration
 /**
  * @ingroup  CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
  * @brief	 Unregisters the callback function.
+ * @since_tizen 2.3
  * @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_SUPPORTED  Not supported
+ *
  * @pre  The Bluetooth service must be initialized with bt_initialize().
  * @see  bt_initialize()
  * @see  bt_adapter_set_visibility_duration_changed_cb()
@@ -1337,6 +752,7 @@ int bt_adapter_unset_visibility_duration_changed_cb(void);
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
  * @brief  Registers a callback function to be invoked when the device discovery state changes.
+ * @since_tizen 2.3
  *
  * @param[in] callback The callback function to register
  * @param[in] user_data The user data to be passed to the callback function
@@ -1345,6 +761,7 @@ int bt_adapter_unset_visibility_duration_changed_cb(void);
  * @retval #BT_ERROR_NONE  Successful
  * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
  * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
  *
  * @pre The Bluetooth service must be initialized with bt_initialize().
  * @post bt_adapter_device_discovery_state_changed_cb() will be invoked.
@@ -1359,10 +776,12 @@ int bt_adapter_set_device_discovery_state_changed_cb(bt_adapter_device_discovery
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
  * @brief	Unregisters the callback function.
+ * @since_tizen 2.3
  *
  * @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_SUPPORTED  Not supported
  *
  * @pre The Bluetooth service must be initialized with bt_initialize().
  *
@@ -1374,6 +793,7 @@ int bt_adapter_unset_device_discovery_state_changed_cb(void);
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
  * @brief Get the Hash and Randmoizer value, synchronously.
+ * @since_tizen 2.3
  *
  * @param[out] hash The hash value recieved from the controller
  * @param[out] randomizer The hash value recieved from the controller
@@ -1385,8 +805,9 @@ int bt_adapter_unset_device_discovery_state_changed_cb(void);
  * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
  * @retval #BT_ERROR_NOT_ENABLED  Not enabled
  * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
  *
- * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED with bt_adapter_enable().
+ * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED.
  * @pre The Bluetooth service must be initialized with bt_initialize().
  * @see bt_initialize()
  */
@@ -1395,21 +816,26 @@ int bt_adapter_get_local_oob_data(unsigned char **hash, unsigned char **randomiz
 
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief Sets  the Hash and Randmoizer value, synchronously.
+ * @brief Sets the Hash and Randmoizer value, synchronously.
+ * @since_tizen 2.3
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/bluetooth
  *
  * @param[in] remote_address Remote device address
  * @param[in] hash The hash value recieved from the controller
  * @param[in] randomizer The hash value recieved from the controller
- * @param[in] hash_len The length of the hash value
- * @param[in] randomizer_len The length of the randomizer value
+ * @param[in] hash_len The length of the hash value. Allowed value is 16
+ * @param[in] randomizer_len The length of the randomizer value. Allowed value is 16
  * @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_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
  *
- * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED with bt_adapter_enable().
+ * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED.
  * @pre The Bluetooth service must be initialized with bt_initialize().
  * @see bt_initialize()
  */
@@ -1418,7 +844,10 @@ int bt_adapter_set_remote_oob_data(const char *remote_address,
 				int hash_len, int randomizer_len);
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief Sets  the Hash and Randmoizer value, synchronously.
+ * @brief Deletes the Hash and Randomizer value, synchronously.
+ * @since_tizen 2.3
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/bluetooth
  *
  * @param[in] remote_address Remote device address
  * @return 0 on success, otherwise a negative error value.
@@ -1427,17 +856,660 @@ int bt_adapter_set_remote_oob_data(const char *remote_address,
  * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
  * @retval #BT_ERROR_NOT_ENABLED  Not enabled
  * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
  *
- * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED with bt_adapter_enable().
+ * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED.
  * @pre The Bluetooth service must be initialized with bt_initialize().
  * @see bt_initialize()
  */
 int bt_adapter_remove_remote_oob_data(const char *remote_address);
 
+/**
+ * @internal
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
+ * @brief  Registers a callback function to be invoked when the connectable state changes.
+ * @since_tizen 2.3
+ *
+ * @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
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
+ * @pre The Bluetooth service must be initialized with bt_initialize().
+ * @post bt_adapter_connectable_changed_cb() will be invoked.
+ *
+ * @see bt_initialize()
+ * @see bt_adapter_connectable_changed_cb()
+ * @see bt_adapter_unset_connectable_changed_cb()
+ */
+int bt_adapter_set_connectable_changed_cb(bt_adapter_connectable_changed_cb callback, void *user_data);
+
+/**
+ * @internal
+ * @ingroup  CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
+ * @brief  Unregisters the callback function.
+ * @since_tizen 2.3
+ *
+ * @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_SUPPORTED  Not supported
+ *
+ * @pre  The Bluetooth service must be initialized with bt_initialize().
+ *
+ * @see  bt_initialize()
+ * @see  bt_adapter_set_connectable_changed_cb()
+ */
+int bt_adapter_unset_connectable_changed_cb(void);
+
+/**
+ * @internal
+ * @ingroup  CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
+ * @brief  Gets the connectable state of local Bluetooth adapter.
+ * @since_tizen 2.3
+ *
+ * @remarks When connectable state is false, no device can connect to this device and visibility mode cannot be changed.
+ *
+ * @param[out] connectable The connectable state of local Bluetooth adapter
+ *
+ * @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_NOT_SUPPORTED  Not supported
+ *
+ * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED.
+ *
+ * @see bt_adapter_set_connectable()
+ */
+int bt_adapter_get_connectable(bool *connectable);
+
+/**
+ * @internal
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
+ * @brief  Sets the connectable state of local Bluetooth adapter.
+ * @since_tizen 2.3
+ * @privlevel platform
+ * @privilege %http://tizen.org/privilege/bluetooth.admin
+ *
+ * @remarks When connectable state is false, no device can connect to this device and visibility mode cannot be changed.
+ *
+ * @param[in] connectable The connectable state to set
+ *
+ * @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
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
+ * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED.
+ * @post bt_adapter_connectable_changed_cb() will be invoked if this function returns #BT_ERROR_NONE.
+ *
+ * @see bt_adapter_get_connectable()
+ * @see bt_adapter_connectable_changed_cb()
+ * @see bt_adapter_set_connectable_changed_cb()
+ * @see bt_adapter_unset_connectable_changed_cb()
+ */
+int bt_adapter_set_connectable(bool connectable);
+
+/**
+ * @internal
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_LE_MODULE
+ * @brief Enables the local Bluetooth le adapter, asynchronously.
+ * @since_tizen 2.3
+ * @privlevel platform
+ * @privilege %http://tizen.org/privilege/bluetooth.admin
+ *
+ * @details This function enables Bluetooth protocol stack and hardware.
+ *
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_ALREADY_DONE  Already enabled
+ * @retval #BT_ERROR_NOW_IN_PROGRESS  Operation now in progress
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
+ * @pre Bluetooth service must be initialized with bt_initialize().
+ * @post This function invokes bt_adapter_le_state_changed_cb().
+ *
+ * @see bt_initialize()
+ * @see bt_adapter_le_get_state()
+ * @see bt_adapter_le_set_state_changed_cb()
+ * @see bt_adapter_le_unset_state_changed_cb()
+ * @see bt_adapter_le_state_changed_cb()
+ *
+ */
+int bt_adapter_le_enable(void);
+
+/**
+ * @internal
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_LE_MODULE
+ * @brief Disables the local Bluetooth le adapter, asynchronously.
+ * @since_tizen 2.3
+ * @privlevel platform
+ * @privilege %http://tizen.org/privilege/bluetooth.admin
+ *
+ * @details This function disables Bluetooth le protocol stack and hardware.
+ *
+ * @remarks
+ *
+ * @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_NOW_IN_PROGRESS  Operation now in progress
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
+ * @pre The state of local Bluetooth must be #BT_ADAPTER_LE_ENABLED
+ * @post This function invokes bt_adapter_le_state_changed_cb().
+ *
+ * @see bt_adapter_le_get_state()
+ * @see bt_adapter_le_state_changed_cb()
+ * @see bt_adapter_le_set_state_changed_cb()
+ * @see bt_adapter_le_unset_state_changed_cb ()
+ *
+ */
+int bt_adapter_le_disable(void);
+
+/**
+ * @internal
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_LE_MODULE
+ * @brief Gets the current state of local Bluetooth adapter.
+ * @since_tizen 2.3
+ *
+ * @param[out] adapter_le_state The current adapter le 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_SUPPORTED  Not supported
+ *
+ * @pre Bluetooth service must be initialized with bt_initialize().
+ *
+ * @see bt_initialize()
+ */
+int bt_adapter_le_get_state(bt_adapter_le_state_e *adapter_le_state);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_LE_MODULE
+ * @brief Starts the LE device discovery for a BT_ADAPTER_DEVICE_DISCOVERY_LE type.
+ * @since_tizen 2.3
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/bluetooth
+ *
+ * @details If a LE device is discovered, bt_adapter_le_device_discovery_state_changed_cb()
+*  will be invoked with #BT_ADAPTER_LE_DEVICE_DISCOVERY_FOUND, and then bt_adapter_le_device_discovery_state_changed_cb()
+ * will be called with #BT_ADAPTER_LE_DEVICE_DISCOVERY_FINISHED in case of the completion or cancellation of the discovery.
+ *
+ * @remarks To connect to peer Bluetooth device, you need to know its Bluetooth address. \n
+ * The device discovery can be stopped by bt_adapter_le_stop_device_discovery().
+ *
+ * @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_NOW_IN_PROGRESS  Operation is now in progress
+ * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
+ * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED.
+ * or must be #BT_ADAPTER_LE_ENABLED.
+ * @post This function invokes bt_adapter_le_device_discovery_state_changed_cb().
+ *
+ * @see bt_adapter_le_is_discovering()
+ * @see bt_adapter_le_device_discovery_state_changed_cb()
+ * @see bt_adapter_le_set_device_discovery_state_changed_cb()
+ * @see bt_adapter_le_unset_device_discovery_state_changed_cb()
+ */
+int bt_adapter_le_start_device_discovery(void);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_LE_MODULE
+ * @brief Stops the LE device discovery, asynchronously.
+ * @since_tizen 2.3
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/bluetooth
+ *
+ * @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_NOT_IN_PROGRESS  Operation is not in progress
+ * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
+ * @pre The device discovery must be in progress with bt_adapter_le_start_device_discovery().
+ * @post This function invokes bt_adapter_le_device_discovery_state_changed_cb().
+ *
+ * @see bt_adapter_le_is_discovering()
+ * @see bt_adapter_le_start_device_discovery()
+ * @see bt_adapter_le_set_device_discovery_state_changed_cb()
+ * @see bt_adapter_le_unset_device_discovery_state_changed_cb()
+ * @see bt_adapter_le_device_discovery_state_changed_cb()
+ */
+int bt_adapter_le_stop_device_discovery(void);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_LE_MODULE
+ * @brief Checks for the LE device discovery is in progress or not.
+ * @since_tizen 2.3
+ *
+ * @remarks If Bluetooth LE discovery is in progress, other operations are not allowed and
+ * you have to either stop the LE discovery operation, or wait for it to be finished,
+ * before performing other operations.
+
+ * @param[out] is_discovering The discovering status: (@c true = in progress , @c  false = not in progress )
+ *
+ * @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_NOT_SUPPORTED  Not supported
+ *
+ * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED.
+ * or must be #BT_ADAPTER_LE_ENABLED.
+ *
+ * @see bt_adapter_le_start_device_discovery()
+ * @see bt_adapter_le_stop_device_discovery()
+ */
+int bt_adapter_le_is_discovering(bool *is_discovering);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_LE_MODULE
+ * @brief  Registers a callback function to be invoked when the LE device discovery state changes.
+ * @since_tizen 2.3
+ *
+ * @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
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
+ * @pre The Bluetooth service must be initialized with bt_initialize().
+ * @post bt_adapter_le_device_discovery_state_changed_cb() will be invoked.
+ *
+ * @see bt_initialize()
+ * @see bt_adapter_le_device_discovery_state_changed_cb()
+ * @see bt_adapter_le_unset_device_discovery_state_changed_cb()
+ */
+int bt_adapter_le_set_device_discovery_state_changed_cb(bt_adapter_le_device_discovery_state_changed_cb callback, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_LE_MODULE
+ * @brief	Unregisters the callback function.
+ * @since_tizen 2.3
+ *
+ * @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_SUPPORTED  Not supported
+ *
+ * @pre The Bluetooth service must be initialized with bt_initialize().
+ *
+ * @see bt_initialize()
+ * @see bt_adapter_le_set_device_discovery_state_changed_cb()
+ */
+int bt_adapter_le_unset_device_discovery_state_changed_cb(void);
+
+/**
+ * @internal
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_LE_MODULE
+ * @brief  Registers a callback function to be invoked when the Bluetooth adapter le state changes.
+ * @since_tizen 2.3
+ *
+ * @param[in] callback	The callback function to invoke
+ * @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_NOT_SUPPORTED  Not supported
+ *
+ * @pre The Bluetooth service must be initialized with bt_initialize().
+ * @post bt_adapter_le_state_changed_cb() will be invoked.
+ *
+ * @see bt_initialize()
+ * @see bt_adapter_le_state_changed_cb()
+ * @see bt_adapter_le_unset_state_changed_cb()
+ */
+int bt_adapter_le_set_state_changed_cb(bt_adapter_le_state_changed_cb callback, void *user_data);
+
+/**
+ * @internal
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_LE_MODULE
+ * @brief	Unregisters the callback function.
+ * @since_tizen 2.3
+ *
+ * @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_SUPPORTED  Not supported
+ *
+ * @pre The Bluetooth service must be initialized with bt_initialize().
+ *
+ * @see bt_initialize()
+ * @see bt_adapter_le_set_state_changed_cb()
+ */
+int bt_adapter_le_unset_state_changed_cb(void);
+
+/**
+ * @internal
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_LE_MODULE
+ * @brief add address to whitelist for accepting scanning request.
+ * @since_tizen 2.3
+ * @privlevel platform
+ * @privilege %http://tizen.org/privilege/bluetooth.admin
+ *
+ * @remarks If the adress is in the whitelist then other LE devices are able to
+ * search this device. Before calling this API, make sure that the adapter is
+ * enabled. There is no callback event for this API.
+
+ * @param[in] address The other device's address
+ * @param[in] address_type The other device's address type
+ *
+ * @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  Adapter is not enabled
+ * @retval #BT_ERROR_RESOURCE_BUSY  Device or resource busy
+ * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
+ * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED.
+ *
+ * @see bt_adapter_le_start_advertising()
+ * @see bt_adapter_le_stop_advertising()
+ */
+int bt_adapter_le_add_white_list(const char *address, bt_device_address_type_e address_type);
+
+/**
+ * @internal
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_LE_MODULE
+ * @brief remove address from the whitelist for not accepting scanning request.
+ * @since_tizen 2.3
+ * @privlevel platform
+ * @privilege %http://tizen.org/privilege/bluetooth.admin
+ *
+ * @remarks If the adress is in the whitelist then other LE devices are able to
+ * search this device. Before calling this API, make sure that the adapter is
+ * enabled. There is no callback event for this API.
+ *
+ * @param[in] address The other device's address
+ * @param[in] address_type The other device's address type
+ *
+ * @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  Adapter is not enabled
+ * @retval #BT_ERROR_RESOURCE_BUSY  Device or resource busy
+ * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
+ * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED.
+ *
+ * @see bt_adapter_le_start_advertising()
+ * @see bt_adapter_le_stop_advertising()
+ */
+int bt_adapter_le_remove_white_list(const char *address, bt_device_address_type_e address_type);
+
+/**
+ * @internal
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_LE_MODULE
+ * @brief clear address from the whitelist for not accepting scanning request.
+ * @since_tizen 2.3
+ * @privlevel platform
+ * @privilege %http://tizen.org/privilege/bluetooth.admin
+ *
+ * @remarks If the adress is in the whitelist then other LE devices are able to
+ * search this device. Before calling this API, make sure that the adapter is
+ * enabled. There is no callback event for this API.
+ *
+ * @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  Adapter is not enabled
+ * @retval #BT_ERROR_RESOURCE_BUSY  Device or resource busy
+ * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
+ * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED.
+ *
+ * @see bt_adapter_le_start_advertising()
+ * @see bt_adapter_le_stop_advertising()
+ */
+int bt_adapter_le_clear_white_list(void);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_LE_MODULE
+ * @brief Create advertiser to advertise device's existence or respond to LE scanning reqeust.
+ * @since_tizen 2.3
+ *
+ * @param[out] advertiser The handle of advertiser
+ *
+ * @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_SUPPORTED  Not supported
+ *
+ * @pre The Bluetooth service must be initialized with bt_initialize().
+ *
+ * @see bt_adapter_le_destroy_advertiser()
+ */
+int bt_adapter_le_create_advertiser(bt_advertiser_h *advertiser);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_LE_MODULE
+ * @brief Destroy advertiser.
+ * @since_tizen 2.3
+ *
+ * @param[out] advertiser The handle of advertiser
+ *
+ * @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_SUPPORTED  Not supported
+ *
+ * @pre The Bluetooth service must be initialized with bt_initialize().
+ *
+ * @see bt_adapter_le_create_advertiser()
+ */
+int bt_adapter_le_destroy_advertiser(bt_advertiser_h advertiser);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_LE_MODULE
+ * @brief Set the data to be advertised or responded to scan request from LE scanning device.
+ *        The maximum advertised or responded data size is 31 bytes
+ *        including data type and system wide data.
+ * @since_tizen 2.3
+ *
+ * @param[in] advertiser The handle of advertiser
+ * @param[in] pkt_type The packet type
+ * @param[in] data_type The data type that is included in packet
+ * @param[in] data The data to be advertised or be responded to scan request from LE scanning device
+ * @param[in] data_size The size of data to be set.
+ *
+ * @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_QUOTA_EXCEEDED  Quota exceeded
+ * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
+ * @pre The Bluetooth service must be initialized with bt_initialize().
+ *
+ * @see bt_adapter_le_remove_advertising_data()
+ * @see bt_adapter_le_clear_advertising_data()
+ */
+int bt_adapter_le_add_advertising_data(bt_advertiser_h advertiser,
+		bt_adapter_le_packet_type_e pkt_type, bt_adapter_le_packet_data_type_e data_type,
+		void *data, unsigned int data_size);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_LE_MODULE
+ * @brief Unset the data to be advertised or responded to scan request from LE scanning device.
+ * @since_tizen 2.3
+ *
+ * @param[in] advertiser The handle of advertiser
+ * @param[in] pkt_type The packet type
+ * @param[in] data_type The data type to be removed from selected packet
+ *
+ * @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
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
+ * @pre The Bluetooth service must be initialized with bt_initialize().
+ *
+ * @see bt_adapter_le_add_advertising_data()
+ * @see bt_adapter_le_clear_advertising_data()
+ */
+int bt_adapter_le_remove_advertising_data(bt_advertiser_h advertiser,
+		bt_adapter_le_packet_type_e pkt_type, bt_adapter_le_packet_data_type_e data_type);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_LE_MODULE
+ * @brief Clear all data to be advertised or responded to scan request from LE scanning device.
+ * @since_tizen 2.3
+ *
+ * @param[in] advertiser The handle of advertiser
+ * @param[in] pkt_type The packet type to be cleared
+ *
+ * @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_SUPPORTED  Not supported
+ *
+ * @pre The Bluetooth service must be initialized with bt_initialize().
+ *
+ * @see bt_adapter_le_add_advertising_data()
+ * @see bt_adapter_le_remove_advertising_data()
+ */
+int bt_adapter_le_clear_advertising_data(bt_advertiser_h advertiser, bt_adapter_le_packet_type_e pkt_type);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_LE_MODULE
+ * @brief Start advertising with passed advertiser and advertising parameters.
+ * @since_tizen 2.3
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/bluetooth
+ *
+ * @details Once Bluetooth advertising is started, nearby Bluetooth LE(Low Energy) supported
+ * devices can know this device's existence. And one of them can make a connection reqeust,
+ * if it is allowed.
+ *
+ * @param[in] advertiser The handle of advertiser
+ * @param[in] adv_params The parameters of advertising \n
+ * If NULL is passed, default values which are defined in driver / controller are used.
+ * @param[in] cb The callback to report the result of this function
+ * @param[in] user_data The user data to be passed when callback is called
+ *
+ * @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_NOW_IN_PROGRESS  Operation is now in progress
+ * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
+ * @pre The Bluetooth service must be initialized with bt_initialize().
+ * @post This function invokes bt_adapter_le_advertising_state_changed_cb().
+ *
+ * @see bt_adapter_le_stop_advertising()
+ * @see bt_adapter_le_advertising_state_changed_cb()
+ */
+int bt_adapter_le_start_advertising(bt_advertiser_h advertiser, bt_adapter_le_advertising_params_s *adv_params,
+		bt_adapter_le_advertising_state_changed_cb cb, void *user_data);
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_LE_MODULE
+ * @brief Stops the advertising.
+ * @since_tizen 2.3
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/bluetooth
+ *
+ * @param[in] advertiser The handle of advertiser
+ *
+ * @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_NOT_IN_PROGRESS  Operation is not in progress
+ * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
+ * @pre The advertising must be going on with bt_adapter_le_start_advertising().
+ * @post This function invokes bt_adapter_le_advertising_state_changed_cb().
+ *
+ * @see bt_adapter_le_start_advertising()
+ * @see bt_adapter_le_advertising_state_changed_cb()
+ */
+int bt_adapter_le_stop_advertising(bt_advertiser_h advertiser);
+
+/**
+ * @internal
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
+ * @brief  Sets the Privacy feature state of local Bluetooth adapter.
+ * @since_tizen 2.3
+ * @privlevel platform
+ * @privilege %http://tizen.org/privilege/bluetooth.admin
+ *
+ * @param[in] enable_privacy The privacy feature to set/unset.
+ *
+ * @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
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
+ * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED.
+ * @pre The state of local Bluetooth must be #BT_ADAPTER_LE_ENABLED.
+ *
+ */
+int bt_adapter_le_enable_privacy(bool enable_privacy);
 
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
  * @brief Creates a bond with a remote Bluetooth device, asynchronously.
+ * @since_tizen 2.3
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/bluetooth
  *
  * @remarks A bond can be destroyed by bt_device_destroy_bond().\n
  * The bonding request can be cancelled by bt_device_cancel_bonding().
@@ -1451,12 +1523,13 @@ int bt_adapter_remove_remote_oob_data(const char *remote_address);
  * @retval #BT_ERROR_NOT_ENABLED  Not enabled
  * @retval #BT_ERROR_RESOURCE_BUSY  Device or resource busy
  * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
  *
- * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED with bt_adapter_enable()
+ * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED.
  * @pre The remote device must be discoverable with bt_adapter_start_device_discovery().
  * @post This function invokes bt_device_bond_created_cb().
  *
- * @see bt_adapter_enable()
  * @see bt_adapter_start_device_discovery()
  * @see bt_device_bond_created_cb()
  * @see bt_device_cancel_bonding()
@@ -1467,10 +1540,52 @@ int bt_adapter_remove_remote_oob_data(const char *remote_address);
 int bt_device_create_bond(const char *remote_address);
 
 /**
+ * @internal
+ * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
+ * @brief Creates a bond with a remote Bluetooth device, asynchronously.
+ * @since_tizen 2.3
+ * @privlevel platform
+ * @privilege %http://tizen.org/privilege/bluetooth.admin
+ *
+ * @remarks A bond can be destroyed by bt_device_destroy_bond().\n
+ * The bonding request can be cancelled by bt_device_cancel_bonding().
+ *
+ * @param[in] remote_address The address of the remote Bluetooth device with which the bond should be created
+ * @param[in] conn_type The connection type(LE or BREDR) to create bond with 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_INVALID_PARAMETER Invalid parameter
+ * @retval #BT_ERROR_NOT_ENABLED  Not enabled
+ * @retval #BT_ERROR_RESOURCE_BUSY     Device or resource busy
+ * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
+ * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED.
+ * @pre The remote device must be discoverable with bt_adapter_start_device_discovery().
+ * @post This function invokes bt_device_bond_created_cb().
+ *
+ * @see bt_adapter_start_device_discovery()
+ * @see bt_device_create_bond()
+ * @see bt_device_bond_created_cb()
+ * @see bt_device_cancel_bonding()
+ * @see bt_device_destroy_bond()
+ * @see bt_device_set_bond_created_cb()
+ * @see bt_device_unset_bond_created_cb()
+ */
+int bt_device_create_bond_by_type(const char *remote_address,
+				  bt_device_connection_link_type_e conn_type);
+
+/**
  * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
  * @brief Cancels the bonding process.
+ * @since_tizen 2.3
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/bluetooth
  *
- * @remakrs Use this function when the remote Bluetooth device is not responding to the
+ * @remarks Use this function when the remote Bluetooth device is not responding to the
  * bond request or you wish to cancel the bonding request.
  *
  * @return 0 on success, otherwise a negative error value.
@@ -1478,6 +1593,9 @@ int bt_device_create_bond(const char *remote_address);
  * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
  * @retval #BT_ERROR_NOT_ENABLED  Not enabled
  * @retval #BT_ERROR_NOT_IN_PROGRESS  Operation not in progress
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
  * @pre The creating a bond must be in progress by bt_device_create_bond().
  *
  * @see bt_device_create_bond()
@@ -1490,6 +1608,9 @@ int bt_device_cancel_bonding(void);
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
  * @brief Destroys the bond, asynchronously.
+ * @since_tizen 2.3
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/bluetooth
  *
  * @param[in] remote_address The address of the remote Bluetooth device to remove bonding
  *
@@ -1501,12 +1622,13 @@ int bt_device_cancel_bonding(void);
  * @retval #BT_ERROR_RESOURCE_BUSY  Device or resource busy
  * @retval #BT_ERROR_REMOTE_DEVICE_NOT_BONDED  Remote device not bonded
  * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
  *
- * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED with bt_adapter_enable().
+ * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED.
  * @pre The bond with the remote device must be created with bt_device_create_bond().
  * @post This function invokes bt_device_bond_destroyed_cb().
  *
- * @see bt_adapter_enable()
  * @see bt_device_create_bond()
  * @see bt_device_bond_destroyed_cb()
  * @see bt_device_set_bond_destroyed_cb()
@@ -1517,6 +1639,9 @@ int bt_device_destroy_bond(const char *remote_address);
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
  * @brief Sets an alias for the bonded device.
+ * @since_tizen 2.3
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/bluetooth
  *
  * @param[in] remote_address The address of the remote Bluetooth device
  * @param[in] alias The alias of the remote Bluetooth device
@@ -1528,11 +1653,12 @@ int bt_device_destroy_bond(const char *remote_address);
  * @retval #BT_ERROR_NOT_ENABLED  Not enabled
  * @retval #BT_ERROR_REMOTE_DEVICE_NOT_BONDED  Remote device not bonded
  * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
  *
- * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED with bt_adapter_enable().
+ * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED.
  * @pre The bond with the remote device must be created with bt_device_create_bond().
  *
- * @see bt_adapter_enable()
  * @see bt_device_create_bond()
  */
 int bt_device_set_alias(const char *remote_address, const char *alias);
@@ -1540,11 +1666,14 @@ int bt_device_set_alias(const char *remote_address, const char *alias);
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
  * @brief Sets the authorization of a bonded device, asynchronously.
+ * @since_tizen 2.3
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/bluetooth
  *
  * @remarks Once a device is authorized, you don't need to receive a confirmation.
  *
  * @param[in] remote_address The address of the remote Bluetooth device to authorize
- * @param[in] authorization The Bluetooth authorization state
+ * @param[in] authorization_state The Bluetooth authorization state
  *
  * @return 0 on success, otherwise a negative error value.
  * @retval #BT_ERROR_NONE  Successful
@@ -1553,12 +1682,13 @@ int bt_device_set_alias(const char *remote_address, const char *alias);
  * @retval #BT_ERROR_NOT_ENABLED  Not enabled
  * @retval #BT_ERROR_REMOTE_DEVICE_NOT_BONDED  Remote device not bonded
  * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
  *
- * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED with bt_adapter_enable().
+ * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED.
  * @pre The bond with the remote device must be created with bt_device_create_bond().
  * @post bt_device_authorization_changed_cb() will be invoked.
  *
- * @see bt_adapter_enable()
  * @see bt_device_create_bond()
  * @see bt_device_authorization_changed_cb()
  * @see bt_device_set_authorization_changed_cb()
@@ -1569,11 +1699,13 @@ int bt_device_set_authorization(const char *remote_address, bt_device_authorizat
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
  * @brief Starts the search for services supported by the specified device, asynchronously.
+ * @since_tizen 2.3
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/bluetooth
  *
  * @remarks If creating a bond succeeds, which means bt_device_bond_created_cb() is called with result #BT_ERROR_NONE,
  * then you don't need to run this function.\n
  * The service search takes a couple of seconds to complete normally. \n
- * The service search can be canceled by bt_device_cancel_service_search().
  *
  * @param[in] remote_address The address of the remote Bluetooth device whose services need to be checked
  *
@@ -1584,26 +1716,30 @@ int bt_device_set_authorization(const char *remote_address, bt_device_authorizat
  * @retval #BT_ERROR_NOT_ENABLED  Not enabled
  * @retval #BT_ERROR_REMOTE_DEVICE_NOT_BONDED  Remote device not bonded
  * @retval #BT_ERROR_SERVICE_SEARCH_FAILED  Service search failed
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
  *
- * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED with bt_adapter_enable().
+ * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED.
  * @pre The remote device must be discoverable with bt_adapter_start_device_discovery().
  * @pre The bond with the remote device must be created with bt_device_create_bond().
  * @post This function invokes bt_device_service_searched_cb().
  *
- * @see bt_adapter_enable()
  * @see bt_adapter_start_device_discovery()
  * @see bt_device_create_bond()
  * @see bt_device_bond_created_cb()
  * @see bt_device_service_searched_cb()
- * @see bt_device_cancel_service_search()
  * @see bt_device_set_service_searched_cb()
  * @see bt_device_unset_service_searched_cb()
  */
 int bt_device_start_service_search(const char *remote_address);
 
 /**
+ * @internal
  * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
  * @brief Cancels service search process.
+ * @since_tizen 2.3
+ * @privlevel platform
+ * @privilege %http://tizen.org/privilege/bluetooth.admin
  *
  * @return 0 on success, otherwise a negative error value.
  * @retval #BT_ERROR_NONE  Successful
@@ -1612,6 +1748,8 @@ int bt_device_start_service_search(const char *remote_address);
  * @retval #BT_ERROR_REMOTE_DEVICE_NOT_BONDED  Remote device not bonded
  * @retval #BT_ERROR_NOT_IN_PROGRESS  Operation not in progress
  * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
  *
  * @pre The service search must be in progress by bt_device_start_service_search().
  *
@@ -1625,6 +1763,7 @@ int bt_device_cancel_service_search(void);
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
  * @brief Gets the connected profiles.
+ * @since_tizen 2.3
  * @param[in] remote_address The address of the remote device
  * @param[in] callback The callback function to invoke
  * @param[in] user_data The user data to be passed to the callback function
@@ -1633,9 +1772,10 @@ int bt_device_cancel_service_search(void);
  * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
  * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
  * @retval #BT_ERROR_NOT_ENABLED  Not enabled
- * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED with bt_adapter_enable().
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
+ * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED.
  * @post bt_device_connected_profile() will be invoked.
- * @see bt_adapter_enable()
  * @see bt_device_connected_profile()
  */
 int bt_device_foreach_connected_profiles(const char *remote_address, bt_device_connected_profile callback, void *user_data);
@@ -1643,9 +1783,10 @@ int bt_device_foreach_connected_profiles(const char *remote_address, bt_device_c
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
  * @brief Gets the profile connected status.
+ * @since_tizen 2.3
  * @param[in] remote_address The address of the remote device
- * @param[in] wish to know bt_profile
- * @param[out] the connected status
+ * @param[in] bt_profile wish to know bt_profile
+ * @param[out] connected_status the connected status
  * @return 0 on success, otherwise a negative error value.
  * @retval #BT_ERROR_NONE  Successful
  * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
@@ -1653,8 +1794,9 @@ int bt_device_foreach_connected_profiles(const char *remote_address, bt_device_c
  * @retval #BT_ERROR_NOT_ENABLED  Not enabled
  * @retval #BT_ERROR_REMOTE_DEVICE_NOT_BONDED	Remote device not bonded
  * @retval #BT_ERROR_OPERATION_FAILED	Operation failed
- * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED with bt_adapter_enable().
- * @see bt_adapter_enable()
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
+ * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED.
  */
 int bt_device_is_profile_connected(const char *remote_address, bt_profile_e bt_profile,
 					bool *connected_status);
@@ -1662,12 +1804,15 @@ int bt_device_is_profile_connected(const char *remote_address, bt_profile_e bt_p
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
  * @brief  Registers a callback function to be invoked when the bond creates.
+ * @since_tizen 2.3
  * @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
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
  * @pre The Bluetooth service must be initialized with bt_initialize().
  * @post  bt_device_bond_created_cb() will be invoked.
  * @see bt_initialize()
@@ -1679,9 +1824,12 @@ int bt_device_set_bond_created_cb(bt_device_bond_created_cb callback, void *user
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
  * @brief	Unregisters the callback function.
+ * @since_tizen 2.3
  * @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_SUPPORTED  Not supported
+ *
  * @pre The Bluetooth service must be initialized with bt_initialize().
  * @see bt_initialize()
  * @see bt_device_set_bond_created_cb()
@@ -1691,12 +1839,15 @@ int bt_device_unset_bond_created_cb(void);
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
  * @brief  Registers a callback function to be invoked when the bond destroys.
+ * @since_tizen 2.3
  * @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
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
  * @pre The Bluetooth service must be initialized with bt_initialize().
  * @post  bt_device_bond_destroyed_cb() will be invoked.
  * @see bt_initialize()
@@ -1708,9 +1859,12 @@ int bt_device_set_bond_destroyed_cb(bt_device_bond_destroyed_cb callback, void *
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
  * @brief	Unregisters the callback function.
+ * @since_tizen 2.3
  * @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_SUPPORTED  Not supported
+ *
  * @pre The Bluetooth service must be initialized with bt_initialize().
  * @see bt_initialize()
  * @see bt_device_set_bond_destroyed_cb()
@@ -1720,12 +1874,15 @@ int bt_device_unset_bond_destroyed_cb(void);
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
  * @brief  Registers a callback function to be invoked when the authorization of device changes.
+ * @since_tizen 2.3
  * @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
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
  * @pre The Bluetooth service must be initialized with bt_initialize().
  * @post  bt_device_authorization_changed_cb() will be invoked.
  * @see bt_initialize()
@@ -1738,9 +1895,12 @@ int bt_device_set_authorization_changed_cb(bt_device_authorization_changed_cb ca
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
  * @brief	Unregisters the callback function.
+ * @since_tizen 2.3
  * @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_SUPPORTED  Not supported
+ *
  * @pre The Bluetooth service must be initialized with bt_initialize().
  * @see bt_initialize()
  * @see bt_device_set_authorization_changed_cb()
@@ -1750,12 +1910,15 @@ int bt_device_unset_authorization_changed_cb(void);
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
  * @brief  Registers a callback function to be invoked when the process of service search finishes.
+ * @since_tizen 2.3
  * @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
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
  * @pre The Bluetooth service must be initialized with bt_initialize().
  * @post  bt_device_service_searched_cb() will be invoked.
  * @see bt_initialize()
@@ -1767,9 +1930,12 @@ int bt_device_set_service_searched_cb(bt_device_service_searched_cb callback, vo
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
  * @brief	Unregisters the callback function.
+ * @since_tizen 2.3
  * @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_SUPPORTED  Not supported
+ *
  * @pre The Bluetooth service must be initialized with bt_initialize().
  * @see bt_initialize()
  * @see bt_device_set_service_searched_cb()
@@ -1779,12 +1945,15 @@ int bt_device_unset_service_searched_cb(void);
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
  * @brief  Registers a callback function to be invoked when the connection state is changed.
+ * @since_tizen 2.3
  * @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
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
  * @pre The Bluetooth service must be initialized with bt_initialize().
  * @post bt_device_connection_state_changed_cb() will be invoked.
  * @see bt_initialize()
@@ -1796,9 +1965,12 @@ int bt_device_set_connection_state_changed_cb(bt_device_connection_state_changed
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
  * @brief	Unregisters the callback function to be invoked when the connection state is changed.
+ * @since_tizen 2.3
  * @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_SUPPORTED  Not supported
+ *
  * @pre The Bluetooth service must be initialized with bt_initialize().
  * @see bt_initialize()
  * @see bt_device_set_connection_state_changed_cb()
@@ -1806,93 +1978,11 @@ int bt_device_set_connection_state_changed_cb(bt_device_connection_state_changed
 int bt_device_unset_connection_state_changed_cb(void);
 
 /**
- * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
- * @brief  Called when GATT connection state is changed.
- * @param[in]  result  The connection result (1 - Connected 0 - Disconnected)
- * @param[in]  user_data  The user data passed from the foreach function
- * @see bt_device_connect_le()
- * @see bt_device_disconnect_le()
- */
-typedef void (*bt_device_gatt_state_changed_cb)(int result, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
- * @brief Connects to remote BLE device, asynchronously.
- *
- * @remarks A Connection can be destroyed by bt_device_disconnect_le()
- *
- * @param[in] callback  The result callback
- * @param[in] address The address of the remote BLE device with which the connection should be created
- *
- * @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_RESOURCE_BUSY	Device or resource busy
- * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
- *
- * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED with bt_adapter_enable()
- * @pre The remote device must be discoverable with bt_adapter_start_device_discovery().
- * @post This function invokes bt_device_gatt_state_changed_cb().
- *
- * @see bt_adapter_enable()
- * @see bt_adapter_start_device_discovery()
- */
-int bt_device_connect_le(bt_device_gatt_state_changed_cb callback, const char *address);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
- * @brief Disconnects remote BLE device, asynchronously.
- *
- * @remarks A Connection can be established by bt_device_connect_le()
- *
- * @param[in] callback	The result callback
- * @param[in] address The address of the remote BLE device with which the connection should be created
- *
- * @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_RESOURCE_BUSY	Device or resource busy
- * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
- *
- * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED with bt_adapter_enable()
- * @pre The remote device must be discoverable with bt_adapter_start_device_discovery().
- * @pre The remote device must be connected with bt_device_connect_le().
- * @post This function invokes bt_device_gatt_state_changed_cb().
- *
- * @see bt_adapter_enable()
- * @see bt_adapter_start_device_discovery()
- */
-int bt_device_disconnect_le(bt_device_gatt_state_changed_cb callback, const char *address);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
- * @brief Read the RSSI values of remote BLE device, asynchronously.
- *
- * @param[in] address The address of the remote BLE device for which RSSI value should be read
- *
- * @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_RESOURCE_BUSY	Device or resource busy
- * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
- *
- * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED with bt_adapter_enable()
- * @pre The remote device must be connected with bt_device_connect_le().
- *
- * @see bt_adapter_enable()
- * @see bt_device_connect_le()
- */
-int bt_device_read_rssi_value(const char *address);
-
-/**
  * @ingroup CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE
- * @brief Registers a rfcomm socket with a specific UUID.
+ * @brief Registers a rfcomm server socket with a specific UUID.
+ * @since_tizen 2.3
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/bluetooth
  *
  * @remarks A socket can be destroyed by bt_socket_destroy_rfcomm().
  *
@@ -1905,9 +1995,11 @@ int bt_device_read_rssi_value(const char *address);
  * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
  * @retval #BT_ERROR_NOT_ENABLED  Not enabled
  * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
- * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED with bt_adapter_enable().
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
+ * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED.
  *
- * @see bt_adapter_enable()
  * @see bt_socket_listen_and_accept_rfcomm()
  * @see bt_socket_destroy_rfcomm()
  */
@@ -1915,17 +2007,22 @@ 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.
+ * @brief Removes the rfcomm server socket which was created using bt_socket_create_rfcomm().
+ * @since_tizen 2.3
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/bluetooth
  * @remarks If callback function bt_socket_connection_state_changed_cb() is set and the remote Bluetooth device is connected,
  * then bt_socket_connection_state_changed_cb() will be called when this function is finished successfully.
  *
- * @param[in] socket_fd The file descriptor of socket to destroy
+ * @param[in] socket_fd The file descriptor of socket (which was created using bt_socket_create_rfcomm()) to destroy
  * @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_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
  *
  * @pre The socket must be created with bt_socket_create_rfcomm().
  * @post If callback function bt_socket_connection_state_changed_cb() is set and the remote Bluetooth device is connected,
@@ -1940,6 +2037,9 @@ 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.
+ * @since_tizen 2.3
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/bluetooth
  * @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.
@@ -1951,6 +2051,9 @@ int bt_socket_destroy_rfcomm(int socket_fd);
  * @retval #BT_ERROR_NOT_ENABLED  Not enabled
  * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
  * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
  * @pre The socket must be created with bt_socket_create_rfcomm().
  * @post If callback function bt_socket_connection_state_changed_cb() is set,
  * then bt_socket_connection_state_changed_cb() will be called when the remote Bluetooth device is connected.
@@ -1962,27 +2065,16 @@ int bt_socket_destroy_rfcomm(int socket_fd);
 int bt_socket_listen_and_accept_rfcomm(int socket_fd, int max_pending_connections);
 
 /**
- * @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);
-
-/**
+ * @internal
  * @ingroup CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE
  * @brief Starts listening on passed rfcomm socket.
+ * @since_tizen 2.3
+ * @privlevel platform
+ * @privilege %http://tizen.org/privilege/bluetooth.admin
  * @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
+ * @param[in] max_pending_connections  The number of pending connections
  *
  * @return 0 on success, otherwise a negative error value.
  * @retval #BT_ERROR_NONE  Successful
@@ -1990,6 +2082,8 @@ typedef void (*bt_socket_connection_requested_cb) (int socket_fd, const char *re
  * @retval #BT_ERROR_NOT_ENABLED  Not enabled
  * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
  * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
  *
  * @pre The socket must be created with bt_socket_create_rfcomm().
  * @post This function invokes bt_socket_connection_state_changed_cb().
@@ -2002,27 +2096,37 @@ typedef void (*bt_socket_connection_requested_cb) (int socket_fd, const char *re
 int bt_socket_listen(int socket_fd, int max_pending_connections);
 
 /**
+ * @internal
  * @ingroup  CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE
  * @brief  Accepts a connection request.
+ * @since_tizen 2.3
+ * @privlevel platform
+ * @privilege %http://tizen.org/privilege/bluetooth.admin
  * @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
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
  * @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);
+int bt_socket_accept(int requested_socket_fd);
 
 /**
+ * @internal
  * @ingroup  CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE
  * @brief  Rejects a connection request.
+ * @since_tizen 2.3
+ * @privlevel platform
+ * @privilege %http://tizen.org/privilege/bluetooth.admin
  * @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
@@ -2030,6 +2134,9 @@ int bt_socket_accept(int requested_socket_fd, int *connected_socket_fd);
  * @retval #BT_ERROR_NOT_ENABLED  Not enabled
  * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
  * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
  * @pre The connection is requested by bt_socket_connection_requested_cb().
  * @see bt_socket_create_rfcomm()
  * @see bt_socket_connection_requested_cb()
@@ -2041,6 +2148,9 @@ 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.
+ * @since_tizen 2.3
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/bluetooth
  *
  * @remarks A connection can be disconnected by bt_socket_disconnect_rfcomm().
  *
@@ -2054,13 +2164,14 @@ int bt_socket_reject(int socket_fd);
  * @retval #BT_ERROR_NOT_ENABLED  Not enabled
  * @retval #BT_ERROR_REMOTE_DEVICE_NOT_BONDED  Remote device not bonded
  * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
  *
- * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED with bt_adapter_enable().
+ * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED.
  * @pre The remote device must be discoverable with bt_adapter_start_device_discovery().
  * @pre The bond with the remote device must be created with bt_device_create_bond().
  * @post This function invokes bt_socket_connection_state_changed_cb().
  *
- * @see bt_adapter_enable()
  * @see bt_device_create_bond()
  * @see bt_adapter_start_device_discovery()
  * @see bt_device_start_service_search()
@@ -2074,45 +2185,65 @@ int bt_socket_connect_rfcomm(const char *remote_address, const char *service_uui
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE
  * @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
+ * @since_tizen 2.3
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/bluetooth
+ * @param[in] socket_fd  The file descriptor of socket to close which was received using bt_socket_connection_state_changed_cb().
  * @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_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
  * @pre The connection must be established.
+ *
+ * @see bt_socket_connection_state_changed_cb()
+ * @see bt_socket_set_connection_state_changed_cb()
+ * @see bt_socket_unset_connection_state_changed_cb()
  */
 int bt_socket_disconnect_rfcomm(int socket_fd);
 
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE
  * @brief Sends data to the connected device.
+ * @since_tizen 2.3
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/bluetooth
+ * @remark The specific error code can be obtained using the get_last_result() method. Error codes are described in Exception section.
  *
- * @param[in] socket_fd The file descriptor of connected socket
+ * @param[in] socket_fd The file descriptor of connected socket which was received using bt_socket_connection_state_changed_cb()
  * @param[in] data The data to be sent
  * @param[in] length The length of data to be sent
  *
- * @return 0 on success, otherwise a negative error value.
- * @retval #BT_ERROR_NONE  Successful
+ * @return the number of bytes written (zero indicates nothing was written).
+ * @retval On error, -1 is returned, and errno is set appropriately. See write 2 man page.
  * @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_NOT_SUPPORTED   Not supported
+ * @exception BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @exception BT_ERROR_AGAIN  Resource temporarily unavailable
  *
  * @pre The connection must be established.
+ *
+ * @see bt_socket_connection_state_changed_cb()
+ * @see bt_socket_set_connection_state_changed_cb()
+ * @see bt_socket_unset_connection_state_changed_cb()
  */
 int bt_socket_send_data(int socket_fd, const char *data, int length);
 
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE
  * @brief  Register a callback function that will be invoked when you receive data.
+ * @since_tizen 2.3
  * @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
+ * @retval #BT_ERROR_NOT_SUPPORTED   Not supported
+ *
  * @pre The Bluetooth service must be initialized with bt_initialize().
  * @post  bt_socket_data_received_cb() will be invoked.
  * @see bt_initialize()
@@ -2125,9 +2256,12 @@ int bt_socket_set_data_received_cb(bt_socket_data_received_cb callback, void *us
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE
  * @brief	Unregisters the callback function.
+ * @since_tizen 2.3
  * @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_SUPPORTED   Not supported
+ *
  * @pre The Bluetooth service must be initialized with bt_initialize().
  * @see bt_initialize()
  * @see bt_socket_data_received_cb()
@@ -2138,12 +2272,15 @@ 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.
+ * @since_tizen 2.3
  * @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
+ * @retval #BT_ERROR_NOT_SUPPORTED   Not supported
+ *
  * @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()
@@ -2154,9 +2291,12 @@ int bt_socket_set_connection_requested_cb(bt_socket_connection_requested_cb call
 /**
  * @ingroup  CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE
  * @brief  Unregisters the callback function.
+ * @since_tizen 2.3
  * @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_SUPPORTED   Not supported
+ *
  * @pre  The Bluetooth service must be initialized with bt_initialize().
  * @see  bt_initialize()
  * @see  bt_socket_set_connection_requested_cb()
@@ -2167,12 +2307,15 @@ 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.
+ * @since_tizen 2.3
  * @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
+ * @retval #BT_ERROR_NOT_SUPPORTED   Not supported
+ *
  * @pre The Bluetooth service must be initialized with bt_initialize().
  * @post bt_socket_connection_state_changed_cb() will be invoked.
  * @see bt_initialize()
@@ -2184,9 +2327,12 @@ int bt_socket_set_connection_state_changed_cb(bt_socket_connection_state_changed
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE
  * @brief	Unregisters the callback function.
+ * @since_tizen 2.3
  * @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_SUPPORTED   Not supported
+ *
  * @pre The Bluetooth service must be initialized with bt_initialize().
  * @see bt_initialize()
  * @see bt_socket_connection_state_changed_cb()
@@ -2195,33 +2341,10 @@ 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() if you want to accept.
- * Otherwise, you must call bt_opp_server_reject().
- * @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);
-
-/**
+ * @internal
  * @ingroup CAPI_NETWORK_BLUETOOTH_OPP_SERVER_MODULE
  * @brief Initializes the Bluetooth OPP server requested by bt_opp_server_push_requested_cb().
+ * @since_tizen 2.3
  * @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().
@@ -2237,6 +2360,8 @@ typedef void (*bt_opp_server_connection_requested_cb)(const char *remote_address
  * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
  * @retval #BT_ERROR_RESOURCE_BUSY  Device or resource busy
  * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @retval #BT_ERROR_NOT_SUPPORTED   Not supported
+ *
  * @see  bt_opp_server_push_requested_cb()
  * @see  bt_opp_server_deinitialize()
  * @see  bt_opp_server_accept()
@@ -2247,6 +2372,7 @@ int bt_opp_server_initialize(const char *destination, bt_opp_server_push_request
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_OPP_SERVER_MODULE
  * @brief Initializes the Bluetooth OPP server requested by bt_opp_server_connection_requested_cb().
+ * @since_tizen 2.3
  * @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().
@@ -2262,54 +2388,37 @@ int bt_opp_server_initialize(const char *destination, bt_opp_server_push_request
  * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
  * @retval #BT_ERROR_RESOURCE_BUSY  Device or resource busy
  * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @retval #BT_ERROR_NOT_SUPPORTED   Not supported
+ *
  * @see  bt_opp_server_connection_requested_cb()
  * @see  bt_opp_server_deinitialize()
- * @see  bt_opp_server_accept_connection()
- * @see  bt_opp_server_reject_connection()
+ * @see  bt_opp_server_accept()
+ * @see  bt_opp_server_reject()
  */
 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.
+ * @since_tizen 2.3
  * @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
+ * @retval #BT_ERROR_NOT_SUPPORTED   Not supported
+ *
  * @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()
- * @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()
- * @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.
+ * @since_tizen 2.3
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/bluetooth
  * @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
@@ -2324,6 +2433,9 @@ typedef void (*bt_opp_server_transfer_finished_cb) (int result, const char *file
  * @retval #BT_ERROR_NOT_ENABLED  Not enabled
  * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
  * @retval #BT_ERROR_NOW_IN_PROGRESS  Operation now in progress
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED   Not supported
+ *
  * @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,
@@ -2332,12 +2444,18 @@ int bt_opp_server_accept(bt_opp_server_transfer_progress_cb progress_cb, bt_opp_
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_OPP_SERVER_MODULE
  * @brief Rejects the push request from the remote device.
+ * @since_tizen 2.3
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/bluetooth
  * @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_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED   Not supported
+ *
  * @see  bt_opp_server_accept()
  */
 int bt_opp_server_reject(void);
@@ -2345,6 +2463,9 @@ int bt_opp_server_reject(void);
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_OPP_SERVER_MODULE
  * @brief Cancels the transfer.
+ * @since_tizen 2.3
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/bluetooth
  * @param[in] transfer_id  The ID of transfer
  * @return 0 on success, otherwise a negative error value.
  * @retval #BT_ERROR_NONE  Successful
@@ -2352,7 +2473,9 @@ int bt_opp_server_reject(void);
  * @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()
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED   Not supported
+ *
  * @see  bt_opp_server_accept()
  */
 int bt_opp_server_cancel_transfer(int transfer_id);
@@ -2360,6 +2483,9 @@ 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.
+ * @since_tizen 2.3
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/bluetooth
  * @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
@@ -2367,6 +2493,9 @@ int bt_opp_server_cancel_transfer(int transfer_id);
  * @retval #BT_ERROR_NOT_ENABLED  Not enabled
  * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
  * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED   Not supported
+ *
  * @see  bt_opp_server_initialize()
  */
 int bt_opp_server_set_destination(const char *destination);
@@ -2374,15 +2503,17 @@ int bt_opp_server_set_destination(const char *destination);
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_OPP_CLIENT_MODULE
  * @brief Initializes the Bluetooth OPP client.
+ * @since_tizen 2.3
  * @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
+ * @retval #BT_ERROR_NOT_SUPPORTED   Not supported
+ *
  * @see  bt_opp_client_deinitialize()
  */
 int bt_opp_client_initialize(void);
@@ -2390,11 +2521,13 @@ int bt_opp_client_initialize(void);
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_OPP_CLIENT_MODULE
  * @brief Denitializes the Bluetooth OPP client.
+ * @since_tizen 2.3
  * @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
+ * @retval #BT_ERROR_NOT_SUPPORTED   Not supported
+ *
  * @see  bt_opp_client_initialize()
  */
 int bt_opp_client_deinitialize(void);
@@ -2402,12 +2535,16 @@ int bt_opp_client_deinitialize(void);
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_OPP_CLIENT_MODULE
  * @brief Adds file to be pushed.
+ * @since_tizen 2.3
  * @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
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED   Not supported
+ *
  * @see  bt_opp_client_clear_files()
  * @see  bt_opp_client_push_files()
  */
@@ -2416,11 +2553,14 @@ int bt_opp_client_add_file(const char *file);
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_OPP_CLIENT_MODULE
  * @brief Adds file to be pushed.
+ * @since_tizen 2.3
  * @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
+ * @retval #BT_ERROR_NOT_SUPPORTED   Not supported
+ *
  * @see  bt_opp_client_add_file()
  * @see  bt_opp_client_push_files()
  */
@@ -2428,40 +2568,10 @@ 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.
+ * @since_tizen 2.3
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/bluetooth
  * @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.
@@ -2478,6 +2588,9 @@ typedef void (*bt_opp_client_push_finished_cb)(int result, const char *remote_ad
  * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
  * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
  * @retval #BT_ERROR_NOW_IN_PROGRESS  Operation now in progress
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED   Not supported
+ *
  * @see bt_opp_client_initialize()
  * @see bt_opp_client_cancel_push
  */
@@ -2487,11 +2600,17 @@ int bt_opp_client_push_files(const char *remote_address, bt_opp_client_push_resp
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_OPP_CLIENT_MODULE
  * @brief Cancels the push request in progress, asynchronously.
+ * @since_tizen 2.3
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/bluetooth
  * @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
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED   Not supported
+ *
  * @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().
@@ -2501,206 +2620,9 @@ int bt_opp_client_push_files(const char *remote_address, bt_opp_client_push_resp
 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
- * @retval #BT_ERROR_ALREADY_DONE  Operation is already done
- * @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
- * @retval #BT_ERROR_ALREADY_DONE  Operation is already done
- * @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 Disconnects the all PANUs(Personal Area Networking User) which are connected to you.
- * @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_disconnect_all(void);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_PAN_NAP_MODULE
- * @brief Disconnects the specified PANU(Personal Area Networking User) which is connected to you.
- * @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_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_disconnect(const char *remote_address);
-
-/**
- * @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.
+ * @since_tizen 2.3
  * @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.
@@ -2711,6 +2633,8 @@ typedef void (*bt_hid_host_connection_state_changed_cb) (int result, bool connec
  * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
  * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
  * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @retval #BT_ERROR_NOT_SUPPORTED   Not supported
+ *
  * @pre The Bluetooth service must be initialized with bt_initialize().
  * @see bt_initialize()
  * @see  bt_hid_host_deinitialize()
@@ -2720,10 +2644,13 @@ int bt_hid_host_initialize(bt_hid_host_connection_state_changed_cb connection_cb
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_HID_MODULE
  * @brief Deinitializes the Bluetooth HID(Human Interface Device) Host.
+ * @since_tizen 2.3
  * @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
+ * @retval #BT_ERROR_NOT_SUPPORTED   Not supported
+ *
  * @pre The Bluetooth HID service must be initialized with bt_hid_host_initialize().
  * @see  bt_hid_host_initialize()
  */
@@ -2732,6 +2659,9 @@ 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.
+ * @since_tizen 2.3
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/bluetooth
  * @param[in] remote_address  The remote address
  * @return 0 on success, otherwise a negative error value.
  * @retval #BT_ERROR_NONE  Successful
@@ -2740,6 +2670,9 @@ int bt_hid_host_deinitialize(void);
  * @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
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED   Not supported
+ *
  * @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.
@@ -2751,6 +2684,9 @@ 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.
+ * @since_tizen 2.3
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/bluetooth
  * @param[in] remote_address  The remote address
  * @return 0 on success, otherwise a negative error value.
  * @retval #BT_ERROR_NONE  Successful
@@ -2759,6 +2695,9 @@ int bt_hid_host_connect(const char *remote_address);
  * @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
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED   Not supported
+ *
  * @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()
@@ -2769,6 +2708,7 @@ int bt_hid_host_disconnect(const char *remote_address);
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_MODULE
  * @brief Initializes the Bluetooth profiles related with audio.
+ * @since_tizen 2.3
  * @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.
@@ -2776,6 +2716,9 @@ int bt_hid_host_disconnect(const char *remote_address);
  * @retval #BT_ERROR_NONE  Successful
  * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
  * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED   Not supported
+ *
  * @pre The Bluetooth service must be initialized with bt_initialize().
  * @see bt_initialize()
  * @see bt_audio_deinitialize()
@@ -2785,10 +2728,14 @@ int bt_audio_initialize(void);
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_MODULE
  * @brief Deinitializes the Bluetooth profiles related with audio.
+ * @since_tizen 2.3
  * @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
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED   Not supported
+ *
  * @pre The Bluetooth audio service must be initialized with bt_audio_initialize().
  * @see bt_audio_initialize()
  */
@@ -2797,6 +2744,9 @@ int bt_audio_deinitialize(void);
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_MODULE
  * @brief Connects the remote device with the given audio profile, asynchronously.
+ * @since_tizen 2.3
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/bluetooth
  * @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
@@ -2808,6 +2758,9 @@ int bt_audio_deinitialize(void);
  * @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
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+
  * @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.
@@ -2819,6 +2772,9 @@ 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.
+ * @since_tizen 2.3
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/bluetooth
  * @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
@@ -2828,8 +2784,10 @@ int bt_audio_connect(const char *remote_address, bt_audio_profile_type_e type);
  * @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
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
  * @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()
@@ -2839,41 +2797,31 @@ 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.
+ * @since_tizen 2.3
  * @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
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
  * @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.
+ * @since_tizen 2.3
  * @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_SUPPORTED  Not supported
+ *
  * @pre The Bluetooth audio service must be initialized with bt_audio_initialize().
  * @see bt_audio_initialize()
  * @see bt_audio_connection_state_changed_cb()
@@ -2882,8 +2830,12 @@ int bt_audio_set_connection_state_changed_cb(bt_audio_connection_state_changed_c
 int bt_audio_unset_connection_state_changed_cb(void);
 
 /**
+ * @internal
  * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
  * @brief Opens a SCO(Synchronous Connection Oriented link) to connected remote device, asynchronously.
+ * @since_tizen 2.3
+ * @privlevel platform
+ * @privilege %http://tizen.org/privilege/bluetooth.admin
  * @return 0 on success, otherwise a negative error value.
  * @retval #BT_ERROR_NONE  Successful
  * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
@@ -2892,6 +2844,9 @@ int bt_audio_unset_connection_state_changed_cb(void);
  * @retval #BT_ERROR_REMOTE_DEVICE_NOT_CONNECTED  Remote device is not connected
  * @retval #BT_ERROR_ALREADY_DONE  Operation is already done
  * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
  * @pre The Bluetooth audio device must be connected with bt_audio_connect().
  * @post bt_ag_sco_state_changed_cb() will be invoked.
  * @see bt_ag_close_sco()
@@ -2901,14 +2856,21 @@ int bt_audio_unset_connection_state_changed_cb(void);
 int bt_ag_open_sco(void);
 
 /**
+ * @internal
  * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
  * @brief Closes an opened SCO(Synchronous Connection Oriented link), asynchronously.
+ * @since_tizen 2.3
+ * @privlevel platform
+ * @privilege %http://tizen.org/privilege/bluetooth.admin
  * @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_REMOTE_DEVICE_NOT_BONDED  Remote device is not bonded
  * @retval #BT_ERROR_REMOTE_DEVICE_NOT_CONNECTED  Remote device is not connected
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
  * @pre The SCO must be opened with bt_ag_open_sco().
  * @post bt_ag_sco_state_changed_cb() will be invoked.
  * @see bt_ag_open_sco()
@@ -2917,45 +2879,37 @@ int bt_ag_open_sco(void);
 int bt_ag_close_sco(void);
 
 /**
+ * @internal
  * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
  * @brief Checks whether an opened SCO(Synchronous Connection Oriented link) exists or not.
+ * @since_tizen 2.3
  * @param[out] opened The SCO status: (@c true = opened, @c  false = not opened)
  * @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_NOT_SUPPORTED  Not supported
+ *
  * @pre The Bluetooth audio service must be initialized with bt_audio_initialize().
- * @see bt_adapter_enable()
  * @see bt_ag_open_sco()
  * @see bt_ag_close_sco()
  */
 int bt_ag_is_sco_opened(bool *opened);
 
 /**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
- * @brief  Called when the SCO(Synchronous Connection Oriented link) state is changed.
- * @details  This callback is called when the SCO state is changed.
- * When you call bt_ag_open_sco() or bt_ag_close_sco(), this callback is also called with error result even though these functions failed.
- * @param[in] result  The result of changing the connection state
- * @param[in] opened  The state to be changed: (@c true = opened, @c  false = not opened)
- * @param[in] user_data The user data passed from the callback registration function
- * @see bt_ag_set_sco_state_changed_cb()
- * @see bt_ag_unset_sco_state_changed_cb()
- * @see bt_ag_open_sco()
- * @see bt_ag_close_sco()
- */
-typedef void (*bt_ag_sco_state_changed_cb) (int result, bool opened, void *user_data);
-
-/**
+ * @internal
  * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
  * @brief  Registers a callback function that will be invoked when the SCO(Synchronous Connection Oriented link) state is changed.
+ * @since_tizen 2.3
  * @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
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
  * @pre The Bluetooth audio service must be initialized with bt_audio_initialize().
  * @see bt_audio_initialize()
  * @see bt_ag_sco_state_changed_cb()
@@ -2964,11 +2918,15 @@ typedef void (*bt_ag_sco_state_changed_cb) (int result, bool opened, void *user_
 int bt_ag_set_sco_state_changed_cb(bt_ag_sco_state_changed_cb callback, void *user_data);
 
 /**
+ * @internal
  * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
  * @brief  Unregisters a callback function that will be invoked when the SCO(Synchronous Connection Oriented link) state is changed.
+ * @since_tizen 2.3
  * @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_SUPPORTED  Not supported
+ *
  * @pre The Bluetooth audio service must be initialized with bt_audio_initialize().
  * @see bt_audio_initialize()
  * @see bt_ag_sco_state_changed_cb()
@@ -2977,8 +2935,12 @@ int bt_ag_set_sco_state_changed_cb(bt_ag_sco_state_changed_cb callback, void *us
 int bt_ag_unset_sco_state_changed_cb(void);
 
 /**
+ * @internal
  * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
  * @brief Notifies the call event to the remote bluetooth device.
+ * @since_tizen 2.3
+ * @privlevel platform
+ * @privilege %http://tizen.org/privilege/bluetooth.admin
  * @remarks Before notifying #BT_AG_CALL_EVENT_ANSWERED or #BT_AG_CALL_EVENT_DIALING, you should open SCO(Synchronous Connection Oriented link)
  * if Bluetooth Hands-Free need SCO connection.
  * @param[in] event  The call event
@@ -2992,14 +2954,21 @@ int bt_ag_unset_sco_state_changed_cb(void);
  * @retval #BT_ERROR_NOT_ENABLED  Not enabled
  * @retval #BT_ERROR_REMOTE_DEVICE_NOT_BONDED  Remote device is not bonded
  * @retval #BT_ERROR_REMOTE_DEVICE_NOT_CONNECTED  Remote device is not connected
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
  * @pre The Bluetooth audio device must be connected with bt_audio_connect().
  * @see bt_audio_connect()
  */
 int bt_ag_notify_call_event(bt_ag_call_event_e event, unsigned int call_id, const char *phone_number);
 
 /**
+ * @internal
  * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
  * @brief Notifies the call list to the remote bluetooth device.
+ * @since_tizen 2.3
+ * @privlevel platform
+ * @privilege %http://tizen.org/privilege/bluetooth.admin
  * @param[in] list  The call list
  * @return 0 on success, otherwise a negative error value.
  * @retval #BT_ERROR_NONE  Successful
@@ -3009,14 +2978,21 @@ int bt_ag_notify_call_event(bt_ag_call_event_e event, unsigned int call_id, cons
  * @retval #BT_ERROR_REMOTE_DEVICE_NOT_BONDED  Remote device is not bonded
  * @retval #BT_ERROR_REMOTE_DEVICE_NOT_CONNECTED  Remote device is not connected
  * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
  * @pre The Bluetooth audio device must be connected with bt_audio_connect().
  * @see bt_audio_connect()
  */
 int bt_ag_notify_call_list(bt_call_list_h list);
 
 /**
+ * @internal
  * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
  * @brief Notifies the state of voice recognition.
+ * @since_tizen 2.3
+ * @privlevel platform
+ * @privilege %http://tizen.org/privilege/bluetooth.admin
  * @param[in] state  The state of voice recognition: (@c true = enabled, @c  false = disabled)
  * @return 0 on success, otherwise a negative error value.
  * @retval #BT_ERROR_NONE  Successful
@@ -3026,31 +3002,27 @@ int bt_ag_notify_call_list(bt_call_list_h list);
  * @retval #BT_ERROR_REMOTE_DEVICE_NOT_BONDED  Remote device is not bonded
  * @retval #BT_ERROR_REMOTE_DEVICE_NOT_CONNECTED  Remote device is not connected
  * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
  * @pre The Bluetooth audio device must be connected with bt_audio_connect().
  * @see bt_audio_connect()
  */
 int bt_ag_notify_voice_recognition_state(bool state);
 
 /**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
- * @brief  Called when a call handling event happened from Hands-Free.
- * @param[in] event  The call handling event happened from Hands-Free
- * @param[in] call_id  The call ID
- * @param[in] user_data The user data passed from the callback registration function
- * @see bt_ag_set_call_handling_event_cb()
- * @see bt_ag_unset_call_handling_event_cb()
- */
-typedef void (*bt_ag_call_handling_event_cb) (bt_ag_call_handling_event_e event, unsigned int call_id, void *user_data);
-
-/**
+ * @internal
  * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
  * @brief  Registers a callback function that will be invoked when a call handling event happened from Hands-Free.
+ * @since_tizen 2.3
  * @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
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
  * @pre The Bluetooth audio service must be initialized with bt_audio_initialize().
  * @see bt_audio_initialize()
  * @see bt_ag_call_handling_event_cb()
@@ -3059,11 +3031,15 @@ typedef void (*bt_ag_call_handling_event_cb) (bt_ag_call_handling_event_e event,
 int bt_ag_set_call_handling_event_cb(bt_ag_call_handling_event_cb callback, void *user_data);
 
 /**
+ * @internal
  * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
  * @brief  Unregisters a callback function that will be invoked when a call handling event happened from Hands-Free.
+ * @since_tizen 2.3
  * @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_SUPPORTED  Not supported
+ *
  * @pre The Bluetooth audio service must be initialized with bt_audio_initialize().
  * @see bt_audio_initialize()
  * @see bt_ag_call_handling_event_cb()
@@ -3072,24 +3048,18 @@ int bt_ag_set_call_handling_event_cb(bt_ag_call_handling_event_cb callback, void
 int bt_ag_unset_call_handling_event_cb(void);
 
 /**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
- * @brief  Called when a multi call handling event happened from Hands-Free.
- * @param[in] event  The call handling event happened from Hands-Free
- * @param[in] user_data The user data passed from the callback registration function
- * @see bt_ag_set_multi_call_handling_event_cb()
- * @see bt_ag_unset_multi_call_handling_event_cb()
- */
-typedef void (*bt_ag_multi_call_handling_event_cb) (bt_ag_multi_call_handling_event_e event, void *user_data);
-
-/**
+ * @internal
  * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
  * @brief  Registers a callback function that will be invoked when a multi call handling event happened from Hands-Free.
+ * @since_tizen 2.3
  * @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
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
  * @pre The Bluetooth audio service must be initialized with bt_audio_initialize().
  * @see bt_audio_initialize()
  * @see bt_ag_multi_call_handling_event_cb()
@@ -3098,11 +3068,15 @@ typedef void (*bt_ag_multi_call_handling_event_cb) (bt_ag_multi_call_handling_ev
 int bt_ag_set_multi_call_handling_event_cb(bt_ag_multi_call_handling_event_cb callback, void *user_data);
 
 /**
+ * @internal
  * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
  * @brief  Unregisters a callback function that will be invoked when a multi call handling event happened from Hands-Free.
+ * @since_tizen 2.3
  * @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_SUPPORTED  Not supported
+ *
  * @pre The Bluetooth audio service must be initialized with bt_audio_initialize().
  * @see bt_audio_initialize()
  * @see bt_ag_multi_call_handling_event_cb()
@@ -3111,24 +3085,18 @@ int bt_ag_set_multi_call_handling_event_cb(bt_ag_multi_call_handling_event_cb ca
 int bt_ag_unset_multi_call_handling_event_cb(void);
 
 /**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
- * @brief  Called when a DTMF(Dual Tone Multi Frequency) is transmitted from Hands-Free.
- * @param[in] dtmf  The DTMF transmitted from Hands-Free
- * @param[in] user_data The user data passed from the callback registration function
- * @see bt_ag_set_dtmf_transmitted_cb()
- * @see bt_ag_unset_dtmf_transmitted_cb()
- */
-typedef void (*bt_ag_dtmf_transmitted_cb) (const char *dtmf, void *user_data);
-
-/**
+ * @internal
  * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
  * @brief  Registers a callback function that will be invoked when a DTMF(Dual Tone Multi Frequency) is transmitted from Hands-Free.
+ * @since_tizen 2.3
  * @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
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
  * @pre The Bluetooth audio service must be initialized with bt_audio_initialize().
  * @see bt_audio_initialize()
  * @see bt_ag_dtmf_transmitted_cb()
@@ -3137,11 +3105,15 @@ typedef void (*bt_ag_dtmf_transmitted_cb) (const char *dtmf, void *user_data);
 int bt_ag_set_dtmf_transmitted_cb(bt_ag_dtmf_transmitted_cb callback, void *user_data);
 
 /**
+ * @internal
  * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
  * @brief  Unregisters a callback function that will be invoked when a DTMF(Dual Tone Multi Frequency) is transmitted from Hands-Free.
+ * @since_tizen 2.3
  * @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_SUPPORTED  Not supported
+ *
  * @pre The Bluetooth audio service must be initialized with bt_audio_initialize().
  * @see bt_audio_initialize()
  * @see bt_ag_dtmf_transmitted_cb()
@@ -3150,8 +3122,12 @@ int bt_ag_set_dtmf_transmitted_cb(bt_ag_dtmf_transmitted_cb callback, void *user
 int bt_ag_unset_dtmf_transmitted_cb(void);
 
 /**
+ * @internal
  * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
  * @brief  Notifies the speaker gain to the remote device.
+ * @since_tizen 2.3
+ * @privlevel platform
+ * @privilege %http://tizen.org/privilege/bluetooth.admin
  * @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.
@@ -3163,6 +3139,9 @@ int bt_ag_unset_dtmf_transmitted_cb(void);
  * @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
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
  * @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()
@@ -3171,8 +3150,10 @@ int bt_ag_unset_dtmf_transmitted_cb(void);
 int bt_ag_notify_speaker_gain(int gain);
 
 /**
+ * @internal
  * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
  * @brief  Gets the current speaker gain of the remote device.
+ * @since_tizen 2.3
  * @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[out] gain The gain of speaker (0 ~ 15)
@@ -3182,6 +3163,8 @@ int bt_ag_notify_speaker_gain(int gain);
  * @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_NOT_SUPPORTED  Not supported
+ *
  * @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()
@@ -3190,8 +3173,10 @@ int bt_ag_notify_speaker_gain(int gain);
 int bt_ag_get_speaker_gain(int *gain);
 
 /**
+ * @internal
  * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
  * @brief Checks whether the remoted device enables NREC(Noise Reduction and Echo Canceling) or not.
+ * @since_tizen 2.3
  * @param[out] enabled The NREC status: (@c true = enabled, @c  false = not enabled)
  * @return   0 on success, otherwise a negative error value.
  * @retval #BT_ERROR_NONE  Successful
@@ -3199,24 +3184,18 @@ int bt_ag_get_speaker_gain(int *gain);
  * @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_NOT_SUPPORTED  Not supported
+ *
  * @pre The remote device is connected by bt_audio_connect() with #BT_AUDIO_PROFILE_TYPE_HSP_HFP service.
  * @see bt_audio_connect()
  */
 int bt_ag_is_nrec_enabled(bool *enabled);
 
 /**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
- * @brief  Called when the speaker gain of the remote device is changed.
- * @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) (int gain, void *user_data);
-
-/**
+ * @internal
  * @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.
+ * @since_tizen 2.3
  * @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
@@ -3225,6 +3204,8 @@ typedef void (*bt_ag_speaker_gain_changed_cb) (int gain, void *user_data);
  * @retval #BT_ERROR_NONE  Successful
  * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
  * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
  * @pre The Bluetooth audio service must be initialized with bt_audio_initialize().
  * @see bt_audio_initialize()
  * @see bt_ag_unset_speaker_gain_changed_cb()
@@ -3232,12 +3213,16 @@ typedef void (*bt_ag_speaker_gain_changed_cb) (int gain, void *user_data);
 int bt_ag_set_speaker_gain_changed_cb(bt_ag_speaker_gain_changed_cb callback, void *user_data);
 
 /**
+ * @internal
  * @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.
+ * @since_tizen 2.3
  * @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_SUPPORTED  Not supported
+ *
  * @pre The Bluetooth audio service must be initialized with bt_audio_initialize().
  * @see bt_audio_initialize()
  * @see bt_ag_set_speaker_gain_changed_cb()
@@ -3245,24 +3230,18 @@ int bt_ag_set_speaker_gain_changed_cb(bt_ag_speaker_gain_changed_cb callback, vo
 int bt_ag_unset_speaker_gain_changed_cb(void);
 
 /**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
- * @brief  Called when the microphone gain of the remote device is changed.
- * @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) (int gain, void *user_data);
-
-/**
+ * @internal
  * @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.
+ * @since_tizen 2.3
  * @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
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
  * @pre The Bluetooth audio service must be initialized with bt_audio_initialize().
  * @see bt_audio_initialize()
  * @see bt_ag_unset_microphone_gain_changed_cb()
@@ -3270,12 +3249,16 @@ typedef void (*bt_ag_microphone_gain_changed_cb) (int gain, void *user_data);
 int bt_ag_set_microphone_gain_changed_cb(bt_ag_microphone_gain_changed_cb callback, void *user_data);
 
 /**
+ * @internal
  * @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.
+ * @since_tizen 2.3
  * @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_SUPPORTED  Not supported
+ *
  * @pre The Bluetooth audio service must be initialized with bt_audio_initialize().
  * @see bt_audio_initialize()
  * @see bt_ag_set_microphone_gain_changed_cb()
@@ -3283,65 +3266,76 @@ int bt_ag_set_microphone_gain_changed_cb(bt_ag_microphone_gain_changed_cb callba
 int bt_ag_unset_microphone_gain_changed_cb(void);
 
 /**
+ * @internal
  * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_CALL_MODULE
  * @brief Creates a handle of call list.
+ * @since_tizen 2.3
  * @param[out] list  The handle of call list
  * @return 0 on success, otherwise a negative error value.
  * @retval #BT_ERROR_NONE  Successful
  * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
  * @retval #BT_ERROR_OUT_OF_MEMORY  Out of memory
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
  * @see bt_call_list_destroy()
  */
 int bt_call_list_create(bt_call_list_h *list);
 
 /**
+ * @internal
  * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_CALL_MODULE
  * @brief Destroys the handle of call list.
+ * @since_tizen 2.3
  * @param[in] list  The handle of call list
  * @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_SUPPORTED  Not supported
+ *
  * @see bt_call_list_create()
  */
 int bt_call_list_destroy(bt_call_list_h list);
 
 /**
+ * @internal
  * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_CALL_MODULE
  * @brief Resets the handle of call list.
+ * @since_tizen 2.3
  * @param[in] list  The handle of call list
  * @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_SUPPORTED  Not supported
+ *
  * @see bt_call_list_create()
  */
 int bt_call_list_reset(bt_call_list_h list);
 
 /**
+ * @internal
  * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_CALL_MODULE
  * @brief Adds a call to the handle of call list.
+ * @since_tizen 2.3
  * @param[in] list  The handle of call list
+ * @param[in] call_id  The call ID
+ * @param[in] state  The state of audio gate call
+ * @param[in] phone_number The phone number. You must set this value in case of #BT_AG_CALL_EVENT_DIALING and      #BT_AG_CALL_EVENT_INCOMING.
  * @return 0 on success, otherwise a negative error value.
  * @retval #BT_ERROR_NONE  Successful
  * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
  * @retval #BT_ERROR_OUT_OF_MEMORY  Out of memory
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
  * @see bt_call_list_create()
  */
-int bt_call_list_add(bt_call_list_h list, unsigned int call_id, bt_ag_call_state_e state);
-
-/**
- * @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);
+int bt_call_list_add(bt_call_list_h list, unsigned int call_id, bt_ag_call_state_e state, const char *phone_number);
 
 /**
+ * @internal
  * @ingroup CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE
  * @brief Initializes the Bluetooth AVRCP(Audio/Video Remote Control Profile) service.
+ * @since_tizen 2.3
  * @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.
@@ -3352,6 +3346,8 @@ typedef void (*bt_avrcp_target_connection_state_changed_cb) (bool connected, con
  * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
  * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
  * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
  * @pre The Bluetooth service must be initialized with bt_initialize().
  * @see bt_initialize()
  * @see bt_avrcp_target_deinitialize()
@@ -3359,19 +3355,27 @@ typedef void (*bt_avrcp_target_connection_state_changed_cb) (bool connected, con
 int bt_avrcp_target_initialize(bt_avrcp_target_connection_state_changed_cb callback, void *user_data);
 
 /**
+ * @internal
  * @ingroup CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE
  * @brief Deinitializes the Bluetooth AVRCP(Audio/Video Remote Control Profile) service.
+ * @since_tizen 2.3
  * @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_SUPPORTED  Not supported
+ *
  * @pre The Bluetooth audio service must be initialized with bt_avrcp_target_initialize().
  * @see bt_avrcp_target_initialize()
  */
 int bt_avrcp_target_deinitialize(void);
 
 /**
+ * @internal
  * @ingroup CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE
  * @brief  Notifies the equalize state to the remote device.
+ * @since_tizen 2.3
+ * @privlevel platform
+ * @privilege %http://tizen.org/privilege/bluetooth.admin
  * @param[in] state The state of equalizer
  * @return   0 on success, otherwise a negative error value.
  * @retval #BT_ERROR_NONE  Successful
@@ -3380,6 +3384,9 @@ int bt_avrcp_target_deinitialize(void);
  * @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
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
  * @pre The remote device must be connected.
  * @see bt_avrcp_target_connection_state_changed_cb()
  * @see bt_avrcp_target_initialize()
@@ -3387,8 +3394,12 @@ int bt_avrcp_target_deinitialize(void);
 int bt_avrcp_target_notify_equalizer_state(bt_avrcp_equalizer_state_e state);
 
 /**
+ * @internal
  * @ingroup CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE
  * @brief  Notifies the repeat mode to the remote device.
+ * @since_tizen 2.3
+ * @privlevel platform
+ * @privilege %http://tizen.org/privilege/bluetooth.admin
  * @param[in] mode The repeat mode
  * @return   0 on success, otherwise a negative error value.
  * @retval #BT_ERROR_NONE  Successful
@@ -3397,6 +3408,9 @@ int bt_avrcp_target_notify_equalizer_state(bt_avrcp_equalizer_state_e state);
  * @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
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
  * @pre The remote device must be connected.
  * @see bt_avrcp_target_connection_state_changed_cb()
  * @see bt_avrcp_target_initialize()
@@ -3404,8 +3418,12 @@ int bt_avrcp_target_notify_equalizer_state(bt_avrcp_equalizer_state_e state);
 int bt_avrcp_target_notify_repeat_mode(bt_avrcp_repeat_mode_e mode);
 
 /**
+ * @internal
  * @ingroup CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE
  * @brief  Notifies the shuffle mode to the remote device.
+ * @since_tizen 2.3
+ * @privlevel platform
+ * @privilege %http://tizen.org/privilege/bluetooth.admin
  * @param[in] mode The repeat mode
  * @return   0 on success, otherwise a negative error value.
  * @retval #BT_ERROR_NONE  Successful
@@ -3414,6 +3432,9 @@ int bt_avrcp_target_notify_repeat_mode(bt_avrcp_repeat_mode_e mode);
  * @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
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
  * @pre The remote device must be connected.
  * @see bt_avrcp_target_connection_state_changed_cb()
  * @see bt_avrcp_target_initialize()
@@ -3421,8 +3442,12 @@ int bt_avrcp_target_notify_repeat_mode(bt_avrcp_repeat_mode_e mode);
 int bt_avrcp_target_notify_shuffle_mode(bt_avrcp_shuffle_mode_e mode);
 
 /**
+ * @internal
  * @ingroup CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE
  * @brief  Notifies the scan mode to the remote device.
+ * @since_tizen 2.3
+ * @privlevel platform
+ * @privilege %http://tizen.org/privilege/bluetooth.admin
  * @param[in] mode The scan mode
  * @return   0 on success, otherwise a negative error value.
  * @retval #BT_ERROR_NONE  Successful
@@ -3431,6 +3456,9 @@ int bt_avrcp_target_notify_shuffle_mode(bt_avrcp_shuffle_mode_e mode);
  * @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
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
  * @pre The remote device must be connected.
  * @see bt_avrcp_target_connection_state_changed_cb()
  * @see bt_avrcp_target_initialize()
@@ -3438,8 +3466,12 @@ int bt_avrcp_target_notify_shuffle_mode(bt_avrcp_shuffle_mode_e mode);
 int bt_avrcp_target_notify_scan_mode(bt_avrcp_scan_mode_e mode);
 
 /**
+ * @internal
  * @ingroup CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE
  * @brief  Notifies the player state to the remote device.
+ * @since_tizen 2.3
+ * @privlevel platform
+ * @privilege %http://tizen.org/privilege/bluetooth.admin
  * @param[in] state The player state
  * @return   0 on success, otherwise a negative error value.
  * @retval #BT_ERROR_NONE  Successful
@@ -3448,6 +3480,9 @@ int bt_avrcp_target_notify_scan_mode(bt_avrcp_scan_mode_e mode);
  * @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
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
  * @pre The remote device must be connected.
  * @see bt_avrcp_target_connection_state_changed_cb()
  * @see bt_avrcp_target_initialize()
@@ -3455,8 +3490,12 @@ int bt_avrcp_target_notify_scan_mode(bt_avrcp_scan_mode_e mode);
 int bt_avrcp_target_notify_player_state(bt_avrcp_player_state_e state);
 
 /**
+ * @internal
  * @ingroup CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE
  * @brief  Notifies the current position of song to the remote device.
+ * @since_tizen 2.3
+ * @privlevel platform
+ * @privilege %http://tizen.org/privilege/bluetooth.admin
  * @param[in] position The current position in milliseconds
  * @return  0 on success, otherwise a negative error value.
  * @retval #BT_ERROR_NONE  Successful
@@ -3465,6 +3504,9 @@ int bt_avrcp_target_notify_player_state(bt_avrcp_player_state_e state);
  * @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
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
  * @pre The remote device must be connected.
  * @see bt_avrcp_target_connection_state_changed_cb()
  * @see bt_avrcp_target_initialize()
@@ -3472,8 +3514,12 @@ int bt_avrcp_target_notify_player_state(bt_avrcp_player_state_e state);
 int bt_avrcp_target_notify_position(unsigned int position);
 
 /**
+ * @internal
  * @ingroup CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE
  * @brief  Notifies the track to the remote device.
+ * @since_tizen 2.3
+ * @privlevel platform
+ * @privilege %http://tizen.org/privilege/bluetooth.admin
  * @param[in] title The title of track
  * @param[in] artist The artist of track
  * @param[in] album The album of track
@@ -3488,6 +3534,9 @@ int bt_avrcp_target_notify_position(unsigned int position);
  * @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
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
  * @pre The remote device must be connected.
  * @see bt_avrcp_target_connection_state_changed_cb()
  * @see bt_avrcp_target_initialize()
@@ -3495,24 +3544,18 @@ int bt_avrcp_target_notify_position(unsigned int position);
 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_AVRCP_MODULE
- * @brief  Called when the equalizer state is changed by the remote control device.
- * @param[in] equalizer The equalizer state
- * @param[in] user_data The user data passed from the callback registration function
- * @see bt_avrcp_set_equalizer_state_changed_cb()
- * @see bt_avrcp_unset_equalizer_state_changed_cb()
- */
-typedef void (*bt_avrcp_equalizer_state_changed_cb) (bt_avrcp_equalizer_state_e equalizer, void *user_data);
-
-/**
+ * @internal
  * @ingroup CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE
  * @brief  Registers a callback function that will be invoked when the equalizer state is changed by the remote control device.
+ * @since_tizen 2.3
  * @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
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
  * @pre The Bluetooth service must be initialized by bt_initialize().
  * @see bt_initialize()
  * @see bt_avrcp_unset_equalizer_state_changed_cb()
@@ -3520,11 +3563,15 @@ typedef void (*bt_avrcp_equalizer_state_changed_cb) (bt_avrcp_equalizer_state_e
 int bt_avrcp_set_equalizer_state_changed_cb(bt_avrcp_equalizer_state_changed_cb callback, void *user_data);
 
 /**
+ * @internal
  * @ingroup CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE
  * @brief  Unregisters a callback function that will be invoked when the equalizer state is changed by the remote control device.
+ * @since_tizen 2.3
  * @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_SUPPORTED  Not supported
+ *
  * @pre The Bluetooth service must be initialized by bt_initialize().
  * @see bt_initialize()
  * @see bt_avrcp_set_equalizer_state_changed_cb()
@@ -3532,24 +3579,18 @@ int bt_avrcp_set_equalizer_state_changed_cb(bt_avrcp_equalizer_state_changed_cb
 int bt_avrcp_unset_equalizer_state_changed_cb(void);
 
 /**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE
- * @brief  Called when the repeat mode is changed by the remote control device.
- * @param[in] repeat The repeat mode
- * @param[in] user_data The user data passed from the callback registration function
- * @see bt_avrcp_set_repeat_mode_changed_cb()
- * @see bt_avrcp_unset_repeat_mode_changed_cb()
- */
-typedef void (*bt_avrcp_repeat_mode_changed_cb) (bt_avrcp_repeat_mode_e repeat, void *user_data);
-
-/**
+ * @internal
  * @ingroup CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE
  * @brief  Registers a callback function that will be invoked when the repeat mode is changed by the remote control device.
+ * @since_tizen 2.3
  * @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
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
  * @pre The Bluetooth service must be initialized by bt_initialize().
  * @see bt_initialize()
  * @see bt_avrcp_unset_repeat_mode_changed_cb()
@@ -3557,11 +3598,15 @@ typedef void (*bt_avrcp_repeat_mode_changed_cb) (bt_avrcp_repeat_mode_e repeat,
 int bt_avrcp_set_repeat_mode_changed_cb(bt_avrcp_repeat_mode_changed_cb callback, void *user_data);
 
 /**
+ * @internal
  * @ingroup CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE
  * @brief  Unregisters a callback function that will be invoked when the repeat mode is changed by the remote control device.
+ * @since_tizen 2.3
  * @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_SUPPORTED  Not supported
+ *
  * @pre The Bluetooth service must be initialized by bt_initialize().
  * @see bt_initialize()
  * @see bt_avrcp_set_repeat_mode_changed_cb()
@@ -3569,24 +3614,18 @@ int bt_avrcp_set_repeat_mode_changed_cb(bt_avrcp_repeat_mode_changed_cb callback
 int bt_avrcp_unset_repeat_mode_changed_cb(void);
 
 /**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE
- * @brief  Called when the shuffle mode is changed by the remote control device.
- * @param[in] shuffle The shuffle mode
- * @param[in] user_data The user data passed from the callback registration function
- * @see bt_avrcp_set_shuffle_mode_changed_cb()
- * @see bt_avrcp_unset_shuffle_mode_changed_cb()
- */
-typedef void (*bt_avrcp_shuffle_mode_changed_cb) (bt_avrcp_shuffle_mode_e shuffle, void *user_data);
-
-/**
+ * @internal
  * @ingroup CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE
  * @brief  Registers a callback function that will be invoked when the shuffle mode is changed by the remote control device.
+ * @since_tizen 2.3
  * @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
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
  * @pre The Bluetooth service must be initialized by bt_initialize().
  * @see bt_initialize()
  * @see bt_avrcp_unset_shuffle_mode_changed_cb()
@@ -3594,11 +3633,15 @@ typedef void (*bt_avrcp_shuffle_mode_changed_cb) (bt_avrcp_shuffle_mode_e shuffl
 int bt_avrcp_set_shuffle_mode_changed_cb(bt_avrcp_shuffle_mode_changed_cb callback, void *user_data);
 
 /**
+ * @internal
  * @ingroup CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE
  * @brief  Unregisters a callback function that will be invoked when the shuffle mode is changed by the remote control device.
+ * @since_tizen 2.3
  * @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_SUPPORTED  Not supported
+ *
  * @pre The Bluetooth service must be initialized by bt_initialize().
  * @see bt_initialize()
  * @see bt_avrcp_set_shuffle_mode_changed_cb()
@@ -3606,24 +3649,18 @@ int bt_avrcp_set_shuffle_mode_changed_cb(bt_avrcp_shuffle_mode_changed_cb callba
 int bt_avrcp_unset_shuffle_mode_changed_cb(void);
 
 /**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE
- * @brief  Called when the scan mode is changed by the remote control device.
- * @param[in] shuffle The shuffle mode
- * @param[in] user_data The user data passed from the callback registration function
- * @see bt_avrcp_set_scan_mode_changed_cb()
- * @see bt_avrcp_unset_scan_mode_changed_cb()
- */
-typedef void (*bt_avrcp_scan_mode_changed_cb) (bt_avrcp_scan_mode_e scan, void *user_data);
-
-/**
+ * @internal
  * @ingroup CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE
  * @brief  Registers a callback function that will be invoked when the scan mode is changed by the remote control device.
+ * @since_tizen 2.3
  * @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
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
  * @pre The Bluetooth service must be initialized by bt_initialize().
  * @see bt_initialize()
  * @see bt_avrcp_unset_scan_mode_changed_cb()
@@ -3631,11 +3668,15 @@ typedef void (*bt_avrcp_scan_mode_changed_cb) (bt_avrcp_scan_mode_e scan, void *
 int bt_avrcp_set_scan_mode_changed_cb(bt_avrcp_scan_mode_changed_cb callback, void *user_data);
 
 /**
+ * @internal
  * @ingroup CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE
  * @brief  Unregisters a callback function that will be invoked when the scan mode is changed by the remote control device.
+ * @since_tizen 2.3
  * @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_SUPPORTED  Not supported
+ *
  * @pre The Bluetooth service must be initialized by bt_initialize().
  * @see bt_initialize()
  * @see bt_avrcp_set_scan_mode_changed_cb()
@@ -3645,6 +3686,9 @@ int bt_avrcp_unset_scan_mode_changed_cb(void);
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_HDP_MODULE
  * @brief Registers an application that acts as the @a Sink role of HDP(Health Device Profile).
+ * @since_tizen 2.3
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/bluetooth
  * @remarks The @a app_id must be released with free() by you.
  * @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.
@@ -3654,21 +3698,29 @@ int bt_avrcp_unset_scan_mode_changed_cb(void);
  * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
  * @retval #BT_ERROR_OUT_OF_MEMORY  Out of memory
  * @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()
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
+ * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED.
+ * @see bt_hdp_unregister_sink_app()
  */
 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).
+ * @since_tizen 2.3
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/bluetooth
  * @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
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
  * @see bt_hdp_register_sink_app()
  */
 int bt_hdp_unregister_sink_app(const char *app_id);
@@ -3676,6 +3728,9 @@ 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.
+ * @since_tizen 2.3
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/bluetooth
  * @param[in] remote_address  The remote address
  * @param[in] app_id  The ID of application
  * @return 0 on success, otherwise a negative error value.
@@ -3686,7 +3741,10 @@ int bt_hdp_unregister_sink_app(const char *app_id);
  * @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().
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
+ * @pre The Sink role of HDP must be registered with bt_hdp_register_sink_app().
  * @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()
@@ -3698,6 +3756,9 @@ 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.
+ * @since_tizen 2.3
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/bluetooth
  * @param[in] remote_address  The remote address
  * @param[in] channel  The connected data channel
  * @return 0 on success, otherwise a negative error value.
@@ -3708,6 +3769,9 @@ int bt_hdp_connect_to_source(const char *remote_address, const char *app_id);
  * @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
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
  * @pre The remote device must be connected.
  * @post bt_hdp_disconnected_cb() will be invoked.
  * @see bt_hdp_set_connection_state_changed_cb()
@@ -3718,6 +3782,9 @@ 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.
+ * @since_tizen 2.3
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/bluetooth
  * @param[in] channel  The connected data channel
  * @param[in] data  The data to send
  * @param[in] size  The size of data to send (byte)
@@ -3727,6 +3794,9 @@ int bt_hdp_disconnect(const char *remote_address, unsigned int channel);
  * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
  * @retval #BT_ERROR_NOT_ENABLED  Not enabled
  * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
  * @pre The remote device must be connected.
  * @see bt_hdp_data_received_cb()
  * @see bt_hdp_set_data_received_cb()
@@ -3736,36 +3806,8 @@ 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.
+ * @since_tizen 2.3
  * @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
@@ -3773,6 +3815,8 @@ typedef void (*bt_hdp_disconnected_cb) (int result, const char *remote_address,
  * @retval #BT_ERROR_NONE  Successful
  * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
  * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
  * @pre The Bluetooth service must be initialized with bt_initialize().
  * @see bt_hdp_unset_connection_state_changed_cb()
  */
@@ -3781,9 +3825,12 @@ int bt_hdp_set_connection_state_changed_cb(bt_hdp_connected_cb connected_cb, bt_
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_HDP_MODULE
  * @brief  Unregisters a callback function that will be invoked when the connection state is changed.
+ * @since_tizen 2.3
  * @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_SUPPORTED  Not supported
+ *
  * @pre The Bluetooth service must be initialized with bt_initialize().
  * @see bt_hdp_set_connection_state_changed_cb()
  */
@@ -3791,25 +3838,16 @@ 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.
+ * @since_tizen 2.3
  * @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
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
  * @pre The Bluetooth service must be initialized with bt_initialize().
  * @see bt_hdp_unset_data_received_cb()
  */
@@ -3818,9 +3856,12 @@ int bt_hdp_set_data_received_cb(bt_hdp_data_received_cb callback, void *user_dat
 /**
  * @ingroup CAPI_NETWORK_BLUETOOTH_HDP_MODULE
  * @brief  Unregisters a callback function that will be invoked when you receive the data.
+ * @since_tizen 2.3
  * @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_SUPPORTED  Not supported
+ *
  * @pre The Bluetooth service must be initialized with bt_initialize().
  * @see bt_hdp_set_data_received_cb()
  */
@@ -3828,19 +3869,10 @@ int bt_hdp_unset_data_received_cb(void);
 
 /**
  * @ingroup  CAPI_NETWORK_BLUETOOTH_GATT_MODULE
- * @brief  Called when you get the primary services repeatedly.
- * @param[in]  service  The attribute handle of service
- * @param[in]  user_data  The user data passed from the foreach function
- * @return  @c true to continue with the next iteration of the loop,
- * \n @c false to break out of the loop.
- * @pre  bt_gatt_foreach_primary_services() will invoke this function.
- * @see  bt_gatt_foreach_primary_services()
- */
-typedef bool (*bt_gatt_primary_service_cb) (bt_gatt_attribute_h service, void *user_data);
-
-/**
- * @ingroup  CAPI_NETWORK_BLUETOOTH_GATT_MODULE
  * @brief  Gets the primary services of GATT(Generic Attribute Profile).
+ * @since_tizen 2.3
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/bluetooth
  * @param[in]  remote_address  The address of the remote device
  * @param[in]  callback  The callback function to invoke
  * @param[in]  user_data  The user data to be passed to the callback function
@@ -3850,32 +3882,21 @@ typedef bool (*bt_gatt_primary_service_cb) (bt_gatt_attribute_h service, void *u
  * @retval  #BT_ERROR_NOT_INITIALIZED  Not initialized
  * @retval  #BT_ERROR_NOT_ENABLED  Not enabled
  * @retval  #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @retva l #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval  #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
  * @pre  The state of local Bluetooth must be #BT_ADAPTER_ENABLED.
  * @post  @a callback will be called if there are primary services.
- * @see  bt_adapter_enable()
  * @see  bt_gatt_primary_service_cb()
  */
 int bt_gatt_foreach_primary_services(const char *remote_address, bt_gatt_primary_service_cb callback, void *user_data);
 
 /**
  * @ingroup  CAPI_NETWORK_BLUETOOTH_GATT_MODULE
- * @brief  Called after the characteristics are discovered by bt_gatt_discover_characteristics().
- * @remakrs  If bt_gatt_discover_characteristics() failed, then this callback function is called only once with 0 totla and NULL characteristic_handle.
- * @param[in]  result  The result of discovering
- * @param[in]  index  The index of characteristics in a service, starts from 0
- * @param[in]  total  The total number of characteristics in a service
- * @param[in]  characteristic  The attribute handle of characteristic
- * @param[in]  user_data  The user data passed from the request function
- * @return  @c true to continue with the next iteration of the loop,
- * \n @c false to break out of the loop.
- * @pre  bt_gatt_discover_characteristics() will invoke this callback.
- * @see  bt_gatt_discover_characteristics()
- */
-typedef bool (*bt_gatt_characteristics_discovered_cb) (int result, int index, int total, bt_gatt_attribute_h characteristic, void *user_data);
-
-/**
- * @ingroup  CAPI_NETWORK_BLUETOOTH_GATT_MODULE
  * @brief  Discovers the characteristics in service, asynchronously.
+ * @since_tizen 2.3
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/bluetooth
  * @param[in]  service  The attribute handle of service
  * @param[in]  callback  The result callback
  * @param[in]  user_data  The user data to be passed to the callback function
@@ -3884,9 +3905,11 @@ typedef bool (*bt_gatt_characteristics_discovered_cb) (int result, int index, in
  * @retval  #BT_ERROR_NOT_INITIALIZED  Not initialized
  * @retval  #BT_ERROR_INVALID_PARAMETER  Invalid parameter
  * @retval  #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @retval  #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval  #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
  * @pre  The state of local Bluetooth must be #BT_ADAPTER_ENABLED.
  * @post  @a callback will be called.
- * @see  bt_adapter_enable()
  * @see  bt_gatt_characteristics_discovered_cb()
  */
 int bt_gatt_discover_characteristics(bt_gatt_attribute_h service, bt_gatt_characteristics_discovered_cb callback, void *user_data);
@@ -3894,6 +3917,9 @@ int bt_gatt_discover_characteristics(bt_gatt_attribute_h service, bt_gatt_charac
 /**
  * @ingroup  CAPI_NETWORK_BLUETOOTH_GATT_MODULE
  * @brief  Gets the UUID of service.
+ * @since_tizen 2.3
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/bluetooth
  * @remarks  @a uuid must be released with free() by you.
  * @param[in]  service  The attribute handle of service
  * @param[out]  uuid  The UUID of service
@@ -3903,26 +3929,19 @@ int bt_gatt_discover_characteristics(bt_gatt_attribute_h service, bt_gatt_charac
  * @retval  #BT_ERROR_INVALID_PARAMETER  Invalid parameter
  * @retval  #BT_ERROR_OPERATION_FAILED  Operation failed
  * @retval  #BT_ERROR_OUT_OF_MEMORY  Out of memory
+ * @retval  #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval  #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
  * @pre  The state of local Bluetooth must be #BT_ADAPTER_ENABLED.
- * @see  bt_adapter_enable()
  */
 int bt_gatt_get_service_uuid(bt_gatt_attribute_h service, char **uuid);
 
 /**
  * @ingroup  CAPI_NETWORK_BLUETOOTH_GATT_MODULE
- * @brief  Called when you get the included services repeatedly.
- * @param[in]  service  The attribute handle of service
- * @param[in]  user_data  The user data passed from the foreach function
- * @return  @c true to continue with the next iteration of the loop,
- * \n @c false to break out of the loop.
- * @pre  bt_gatt_foreach_included_services() will invoke this function.
- * @see  bt_gatt_foreach_included_services()
- */
-typedef bool (*bt_gatt_included_service_cb) (bt_gatt_attribute_h service, void *user_data);
-
-/**
- * @ingroup  CAPI_NETWORK_BLUETOOTH_GATT_MODULE
  * @brief  Gets the included services in service.
+ * @since_tizen 2.3
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/bluetooth
  * @param[in]  service  The attribute handle of service
  * @param[in]  callback  The callback function to invoke
  * @param[in]  user_data  The user data to be passed to the callback function
@@ -3932,55 +3951,91 @@ typedef bool (*bt_gatt_included_service_cb) (bt_gatt_attribute_h service, void *
  * @retval  #BT_ERROR_NOT_INITIALIZED  Not initialized
  * @retval  #BT_ERROR_NOT_ENABLED  Not enabled
  * @retval  #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @retval  #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval  #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
  * @pre  The state of local Bluetooth must be #BT_ADAPTER_ENABLED.
  * @post  @a callback will be called if there are included services.
- * @see  bt_adapter_enable()
  * @see  bt_gatt_included_service_cb()
  */
 int bt_gatt_foreach_included_services(bt_gatt_attribute_h service, bt_gatt_included_service_cb callback, void *user_data);
 
 /**
  * @ingroup  CAPI_NETWORK_BLUETOOTH_GATT_MODULE
- * @brief  Called when a characteristic in service is changed.
- * @param[in]  characteristic  The attribute handle of characteristic
- * @param[in]  value  The value of characteristic (byte array)
- * @param[in]  value_length  The length of value
- * @param[in]  user_data  The user data passed from the callback registration function
+ * @brief  Registers a callback function that will be invoked when a characteristic value is changed.
+ * @since_tizen 2.3
+ * @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
+ * @retval  #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
+ * @pre  The Bluetooth service must be initialized with bt_initialize().
+ * @see  bt_gatt_unset_characteristic_changed_cb()
+ */
+int bt_gatt_set_characteristic_changed_cb(bt_gatt_characteristic_changed_cb callback, void *user_data);
+
+/**
+ * @ingroup  CAPI_NETWORK_BLUETOOTH_GATT_MODULE
+ * @brief  Unregisters a callback function that will be invoked when a characteristic is changed.
+ * @since_tizen 2.3
+ * @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_SUPPORTED  Not supported
+ *
+ * @pre The Bluetooth service must be initialized with bt_initialize().
  * @see bt_gatt_set_characteristic_changed_cb()
- * @see bt_gatt_unset_characteristic_changed_cb()
  */
-typedef void (*bt_gatt_characteristic_changed_cb) (bt_gatt_attribute_h characteristic, unsigned char *value, int value_length, void *user_data);
+int bt_gatt_unset_characteristic_changed_cb(void);
 
 /**
  * @ingroup  CAPI_NETWORK_BLUETOOTH_GATT_MODULE
- * @brief  Registers a callback function that will be invoked when a characteristic in service is changed.
+ * @brief  Watches all the characteristic value changes of the service
+ * @since_tizen 2.3
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/bluetooth
  * @param[in]  service  The attribute handle of service
- * @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
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
  * @pre  The Bluetooth service must be initialized with bt_initialize().
  * @see  bt_gatt_unset_characteristic_changed_cb()
  */
-int bt_gatt_set_characteristic_changed_cb(bt_gatt_attribute_h service, bt_gatt_characteristic_changed_cb callback, void *user_data);
+int bt_gatt_watch_characteristic_changes(bt_gatt_attribute_h service);
 
 /**
  * @ingroup  CAPI_NETWORK_BLUETOOTH_GATT_MODULE
- * @brief  Unregisters a callback function that will be invoked when a characteristic in service is changed.
+ * @brief  Remove watching of all the characteristic value changes of the service
+ * @since_tizen 2.3
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/bluetooth
  * @param[in]  service  The attribute handle of 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_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
  * @pre The Bluetooth service must be initialized with bt_initialize().
  * @see bt_gatt_set_characteristic_changed_cb()
  */
-int bt_gatt_unset_characteristic_changed_cb(bt_gatt_attribute_h service);
+int bt_gatt_unwatch_characteristic_changes(bt_gatt_attribute_h service);
+
 
 /**
  * @ingroup  CAPI_NETWORK_BLUETOOTH_GATT_MODULE
  * @brief  Gets the characteristic declaration.
+ * @since_tizen 2.3
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/bluetooth
  * @remarks  @a uuid and @a value must be released with free() by you.
  * @param[in]  characteristic  The attribute handle of characteristic
  * @param[out]  uuid  The UUID of service
@@ -3992,22 +4047,20 @@ int bt_gatt_unset_characteristic_changed_cb(bt_gatt_attribute_h service);
  * @retval  #BT_ERROR_INVALID_PARAMETER  Invalid parameter
  * @retval  #BT_ERROR_OPERATION_FAILED  Operation failed
  * @retval  #BT_ERROR_OUT_OF_MEMORY  Out of memory
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
  * @pre  The state of local Bluetooth must be #BT_ADAPTER_ENABLED.
- * @see  bt_adapter_enable()
  * @see  bt_gatt_set_characteristic_value()
  */
 int bt_gatt_get_characteristic_declaration(bt_gatt_attribute_h characteristic, char **uuid, unsigned char **value, int *value_length);
 
 /**
  * @ingroup  CAPI_NETWORK_BLUETOOTH_GATT_MODULE
- * @brief  Called when a characteristic value is written.
- * @param[in]  characteristic  The attribute handle of characteristic
- * @see bt_gatt_set_characteristic_value_request()
- */
-typedef void (*bt_gatt_characteristic_write_cb) (bt_gatt_attribute_h handle);
-/**
- * @ingroup  CAPI_NETWORK_BLUETOOTH_GATT_MODULE
  * @brief  Sets the value of characteristic.
+ * @since_tizen 2.3
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/bluetooth
  * @param[in]  characteristic  The attribute handle of characteristic
  * @param[in]  value  The value of characteristic (byte array)
  * @param[in]  value_length  The length of value
@@ -4016,36 +4069,42 @@ typedef void (*bt_gatt_characteristic_write_cb) (bt_gatt_attribute_h handle);
  * @retval  #BT_ERROR_NOT_INITIALIZED  Not initialized
  * @retval  #BT_ERROR_INVALID_PARAMETER  Invalid parameter
  * @retval  #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @retval  #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval  #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
  * @pre  The state of local Bluetooth must be #BT_ADAPTER_ENABLED.
- * @see  bt_adapter_enable()
  * @see  bt_gatt_get_characteristic_declaration()
  */
 int bt_gatt_set_characteristic_value(bt_gatt_attribute_h characteristic, const unsigned char *value, int value_length);
 
 /**
  * @ingroup  CAPI_NETWORK_BLUETOOTH_GATT_MODULE
- * @brief  Sets the value of characteristic.
+ * @brief  Sets the value of characteristic request.
+ * @since_tizen 2.3
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/bluetooth
  * @param[in]  characteristic  The attribute handle of characteristic
  * @param[in]  value  The value of characteristic (byte array)
  * @param[in]  value_length  The length of value
- * @param[in]  request  Request type or command type
- * @param[in]  callback  The result callback
+  * @param[in]  callback  The result callback
  * @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
+ * @retva l #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval  #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
  * @pre  The state of local Bluetooth must be #BT_ADAPTER_ENABLED.
- * @see  bt_adapter_enable()
  * @see  bt_gatt_get_characteristic_declaration()
  */
 int bt_gatt_set_characteristic_value_request(bt_gatt_attribute_h characteristic, const unsigned char *value,
-				int value_length, unsigned char request, bt_gatt_characteristic_write_cb callback);
-
+				int value_length, bt_gatt_characteristic_write_cb callback);
 
 /**
 * @ingroup  CAPI_NETWORK_BLUETOOTH_GATT_MODULE
 * @brief  Clones the attribute handle.
+* @since_tizen 2.3
 * @remarks  @a clone must be released with bt_gatt_destroy_attribute_handle().
 * @param[out]  clone  The cloned attribute handle
 * @param[in]  origin  The origin attribute handle
@@ -4053,6 +4112,8 @@ int bt_gatt_set_characteristic_value_request(bt_gatt_attribute_h characteristic,
 * @retval  #BT_ERROR_NONE  Successful
 * @retval  #BT_ERROR_INVALID_PARAMETER  Invalid parameter
 * @retval  #BT_ERROR_OUT_OF_MEMORY  Out of memory
+* @retval  #BT_ERROR_NOT_SUPPORTED  Not supported
+*
 * @see  bt_gatt_destroy_attribute_handle()
 */
 int bt_gatt_clone_attribute_handle(bt_gatt_attribute_h* clone, bt_gatt_attribute_h origin);
@@ -4060,44 +4121,395 @@ int bt_gatt_clone_attribute_handle(bt_gatt_attribute_h* clone, bt_gatt_attribute
 /**
 * @ingroup  CAPI_NETWORK_BLUETOOTH_GATT_MODULE
 * @brief  Destroys the attribute handle.
+* @since_tizen 2.3
 * @param[in]  handle  The attribute handle
 * @return  0 on success, otherwise negative error value.
 * @retval  #BT_ERROR_NONE  Successful
 * @retval  #BT_ERROR_INVALID_PARAMETER  Invalid parameter
+* @retval  #BT_ERROR_NOT_SUPPORTED  Not supported
+*
 * @see  bt_gatt_clone_attribute_handle()
 */
 int bt_gatt_destroy_attribute_handle(bt_gatt_attribute_h handle);
 
 /**
  * @ingroup  CAPI_NETWORK_BLUETOOTH_GATT_MODULE
- * @brief  Called when a characteristic value is read.
- * @param[in]  characteristic  The attribute handle of characteristic
- * @param[in]  value  The value of characteristic (byte array)
- * @param[in]  value_length  The length of value
- * @param[in]  user_data  The user data passed from the foreach function
- * @see bt_gatt_read_characteristic_value()
- */
-typedef void (*bt_gatt_characteristic_read_cb) (bt_gatt_attribute_h handle,
-		unsigned char *value, int value_length, void *user_data);
-
-/**
- * @ingroup  CAPI_NETWORK_BLUETOOTH_GATT_MODULE
  * @brief  Reads the value of characteristic from remote device
- * @param[in]  characteristic  The attribute handle of characteristic
+ * @since_tizen 2.3
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/bluetooth
+ * @param[in]  char_handle  The attribute handle of characteristic
  * @param[in]  callback  The result callback
  * @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
+ * @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
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
  * @pre  The state of local Bluetooth must be #BT_ADAPTER_ENABLED.
- * @see  bt_adapter_enable()
  * @see  bt_gatt_get_characteristic_declaration()
  */
 int bt_gatt_read_characteristic_value(bt_gatt_attribute_h char_handle,
 		bt_gatt_characteristic_read_cb callback);
 
 /**
+ * @ingroup  CAPI_NETWORK_BLUETOOTH_GATT_MODULE
+ * @brief  Discovers the characteristic descriptors of a characteristic within its definition, asynchronously.
+ * @since_tizen 2.3
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/bluetooth
+ * @param[in]  characteristic_handle  The attribute handle of characteristic
+ * @param[in]  callback  The result callback
+ * @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
+ * @retval  #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
+ * @pre  The state of local Bluetooth must be #BT_ADAPTER_ENABLED.
+ * @post  @a callback will be called.
+ * @see  bt_gatt_characteristic_descriptor_discovered_cb()
+ */
+int bt_gatt_discover_characteristic_descriptor(bt_gatt_attribute_h characteristic_handle,
+		bt_gatt_characteristic_descriptor_discovered_cb callback,
+		void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_GATT_MODULE
+ * @brief Connect to a specific LE based service on a remote bluetooth dievice address, asynchronously.
+ * @since_tizen 2.3
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/bluetooth
+ *
+ * @remarks A connection can be disconnected by bt_gatt_disconnect().
+ *
+ * @param[in] address The address of the remote Bluetooth device.
+ * @param[in] auto_connect The flag of the auto connection.
+ *
+ * @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 paramater
+ * @retval #BT_ERROR_OPERATION_FAILED Operation failed
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
+ * @pre The Bluetooth service must be initialized with bt_initialize().
+ * @pre The remote device must support le connection.
+ * @post This function invokes bt_gatt_connection_state_changed_cb().
+ *
+ * @see bt_initialize()
+ * @see bt_gatt_disconnect()
+ * @see bt_gatt_set_connection_state_changed_cb()
+ * @see bt_gatt_unset_connection_state_changed_cb()
+ * @see bt_gatt_connection_state_changed_cb()
+ */
+int bt_gatt_connect(const char *address, bool auto_connect);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_GATT_MODULE
+ * @brief Disconnect to LE connection with the given remote Bluetooth dievice address, asynchronously.
+ * @since_tizen 2.3
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/bluetooth
+ *
+ * @param[in] address The address of the remote Bluetooth 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 paramater
+ * @retval #BT_ERROR_OPERATION_FAILED Operation failed
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
+ * @pre The connection must be established.
+ * @post This function invokes bt_gatt_connection_state_changed_cb().
+ *
+ * @see bt_initialize()
+ * @see bt_gatt_connect()
+ * @see bt_gatt_set_connection_state_changed_cb()
+ * @see bt_gatt_unset_connection_state_changed_cb()
+ * @see bt_gatt_connection_state_changed_cb()
+ */
+int bt_gatt_disconnect(const char *address);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_GATT_MODULE
+ * @brief Registers a callback function that will be invoked when the connection state is changed.
+ * @since_tizen 2.3
+ *
+ * @param[in] callback The callback function to register.
+ * @param[in] user_data The user data to be passed  to the callback function.
+ *
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_INVALID_PARAMETER Invalid paramater
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
+ * @see bt_gatt_connect()
+ * @see bt_gatt_disconnect()
+ * @see bt_gatt_unset_connection_state_changed_cb()
+ */
+int bt_gatt_set_connection_state_changed_cb(bt_gatt_connection_state_changed_cb callback, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_GATT_MODULE
+ * @brief Unregisters a callback function that will be invoked when the connection state is changed.
+ * @since_tizen 2.3
+ *
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
+ * @see bt_gatt_connect()
+ * @see bt_gatt_disconnect()
+ * @see bt_gatt_connection_state_changed_cb()
+ */
+int bt_gatt_unset_connection_state_changed_cb(void);
+
+/**
+ * @internal
+ * @ingroup CAPI_NETWORK_BLUETOOTH_PAN_NAP_MODULE
+ * @brief Activates the NAP(Network Access Point).
+ * @since_tizen 2.3
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/bluetooth
+ * @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
+ * @retval #BT_ERROR_ALREADY_DONE  Operation is already done
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
+ * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED
+ * @see bt_nap_deactivate()
+ */
+int bt_nap_activate(void);
+
+/**
+ * @internal
+ * @ingroup CAPI_NETWORK_BLUETOOTH_PAN_NAP_MODULE
+ * @brief Deactivates the NAP(Network Access Point).
+ * @since_tizen 2.3
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/bluetooth
+ * @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
+ * @retval #BT_ERROR_ALREADY_DONE  Operation is already done
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
+ * @pre The Bluetooth NAP service must be activated with bt_nap_activate().
+ * @see bt_nap_activate()
+ */
+int bt_nap_deactivate(void);
+
+/**
+ * @internal
+ * @ingroup CAPI_NETWORK_BLUETOOTH_PAN_NAP_MODULE
+ * @brief Disconnects the all PANUs(Personal Area Networking User) which are connected to you.
+ * @since_tizen 2.3
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/bluetooth
+ * @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
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
+ * @pre The Bluetooth NAP service must be activated with bt_nap_activate().
+ * @see bt_nap_activate()
+ */
+int bt_nap_disconnect_all(void);
+
+/**
+ * @internal
+ * @ingroup CAPI_NETWORK_BLUETOOTH_PAN_NAP_MODULE
+ * @brief Disconnects the specified PANU(Personal Area Networking User) which is connected to you.
+ * @since_tizen 2.3
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/bluetooth
+ * @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_NOT_ENABLED  Not enabled
+ * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
+ * @pre The Bluetooth NAP service must be activated with bt_nap_activate().
+ * @see bt_nap_activate()
+ */
+int bt_nap_disconnect(const char *remote_address);
+
+/**
+ * @internal
+ * @ingroup CAPI_NETWORK_BLUETOOTH_PAN_NAP_MODULE
+ * @brief  Registers a callback function that will be invoked when the connection state changes.
+ * @since_tizen 2.3
+ * @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
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
+ * @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);
+
+/**
+ * @internal
+ * @ingroup CAPI_NETWORK_BLUETOOTH_PAN_NAP_MODULE
+ * @brief  Unregisters a callback function that will be invoked when the connection state changes.
+ * @since_tizen 2.3
+ * @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_SUPPORTED  Not supported
+ *
+ * @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);
+
+/**
+ * @internal
+ * @ingroup CAPI_NETWORK_BLUETOOTH_PAN_PANU_MODULE
+ * @brief  Registers a callback function that will be invoked when the connection state changes.
+ * @since_tizen 2.3
+ * @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
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
+ * @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);
+
+/**
+ * @internal
+ * @ingroup CAPI_NETWORK_BLUETOOTH_PAN_PANU_MODULE
+ * @brief  Unregisters a callback function that will be invoked when the connection state changes.
+ * @since_tizen 2.3
+ * @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_SUPPORTED  Not supported
+ *
+ * @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);
+
+/**
+ * @internal
+ * @ingroup CAPI_NETWORK_BLUETOOTH_PAN_PANU_MODULE
+ * @brief Connects the remote device with the PAN(Personal Area Networking) service, asynchronously.
+ * @since_tizen 2.3
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/bluetooth
+ * @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
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
+ * @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);
+
+/**
+ * @internal
+ * @ingroup CAPI_NETWORK_BLUETOOTH_PAN_PANU_MODULE
+ * @brief Disconnects the remote device with the PAN(Personal Area Networking) service, asynchronously.
+ * @since_tizen 2.3
+ * @privlevel public
+ * @privilege %http://tizen.org/privilege/bluetooth
+ * @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
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
+ * @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);
+
+/**
+ * @internal
+ * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
+ * @brief   update LE connection.
+ * @since_tizen 2.3
+ * @privlevel platform
+ * @privilege %http://tizen.org/privilege/bluetooth.admin
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE  Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
+ * @retval #BT_ERROR_PERMISSION_DENIED  Permission denied
+ * @retval #BT_ERROR_NOT_SUPPORTED  Not supported
+ *
+ * @pre The Bluetooth service must be initialized by bt_initialize().
+ * @pre The remote device must be connected with bt_gatt_connect().
+ */
+int bt_device_le_conn_update(const char *device_address,
+			     const bt_le_conn_update_s *parameters);
+
+
+/**
  * @}
  */
 
diff --git a/wearable/include/bluetooth_private.h b/include/bluetooth_private.h
index 4455f8e..ebff30f 100644
--- a/wearable/include/bluetooth_private.h
+++ b/include/bluetooth_private.h
@@ -48,9 +48,12 @@ extern "C" {
 typedef enum
 {
 	BT_EVENT_STATE_CHANGED = 0x00, /**< Adapter state is changed */
+	BT_EVENT_LE_STATE_CHANGED, /**< Adapter le state is changed */
 	BT_EVENT_NAME_CHANGED, /**< Adapter name is changed */
 	BT_EVENT_VISIBILITY_MODE_CHANGED, /**< Adapter visibility mode is changed */
+	BT_EVENT_VISIBILITY_DURATION_CHANGED, /**< Adapter visibility duration is changed */
 	BT_EVENT_DEVICE_DISCOVERY_STATE_CHANGED, /**< Device discovery state is changed */
+	BT_EVENT_LE_DEVICE_DISCOVERY_STATE_CHANGED, /**< LE Device discovery state is changed */
 	BT_EVENT_BOND_CREATED, /**< A bond is created */
 	BT_EVENT_BOND_DESTROYED, /**< A bond is destroyed */
 	BT_EVENT_AUTHORIZATION_CHANGED, /**< Authorization is changed */
@@ -77,6 +80,7 @@ typedef enum
 	BT_EVENT_AG_DTMF_TRANSMITTED, /**< Audio - DTMF tone sending request */
 	BT_EVENT_AG_MICROPHONE_GAIN_CHANGE, /**< Audio Microphone change callback */
 	BT_EVENT_AG_SPEAKER_GAIN_CHANGE, /**< Audio Speaker gain change callback */
+	BT_EVENT_AG_VENDOR_CMD, /**< Audio - XSAT Vendor cmd */
 	BT_EVENT_AVRCP_CONNECTION_STATUS, /**< AVRCP connection change callback */
 	BT_EVENT_AVRCP_EQUALIZER_STATE_CHANGED, /**< AVRCP equalizer state change callback */
 	BT_EVENT_AVRCP_REPEAT_MODE_CHANGED, /**< AVRCP repeat mode change callback */
@@ -84,25 +88,56 @@ typedef enum
 	BT_EVENT_AVRCP_SCAN_MODE_CHANGED, /**< AVRCP scan mode change callback */
 	BT_EVENT_HID_CONNECTION_STATUS, /**< HID connection status callback */
 	BT_EVENT_DEVICE_CONNECTION_STATUS, /**< Device connection status callback */
-	BT_EVENT_DEVICE_DISCONNECTED, /**< Device disconnected callback */
 	BT_EVENT_GATT_CONNECTION_STATUS, /** < GATT connection status callback */
 	BT_EVENT_GATT_CHARACTERISTIC_DISCOVERED, /**< GATT characteristic discovered callback */
+	BT_EVENT_GATT_CHARACTERISTIC_DESCRIPTOR_DISCOVERED, /**< GATT characteristic descriptor discovered callback */
 	BT_EVENT_GATT_VALUE_CHANGED, /**< GATT characteristic value changed callback */
 	BT_EVENT_GATT_READ_CHARACTERISTIC, /**< GATT characteristic value read callback */
 	BT_EVENT_GATT_WRITE_CHARACTERISTIC, /**< GATT characteristic value write callback */
 	BT_EVENT_ADVERTISING_STATE_CHANGED, /**< Advertising state changed callback */
-	BT_EVENT_ADVERTISING_MANUFACTURER_DATA_CHANGED, /**< Advertising manufacturer data changed callback */
+	BT_EVENT_MANUFACTURER_DATA_CHANGED, /**< Manufacturer data changed callback */
+	BT_EVENT_CONNECTABLE_CHANGED_EVENT, /**< Adapter connectable changed callback */
+	BT_EVENT_RSSI_ENABLED_EVENT, /**< RSSI Enabled callback */
+	BT_EVENT_RSSI_ALERT_EVENT, /**< RSSI Alert callback */
+	BT_EVENT_GET_RSSI_EVENT, /**< Get RSSI Strength callback */
+#ifdef TIZEN_WEARABLE
+	BT_EVENT_PBAP_CONNECTION_STATUS, /**< PBAP connection status callback */
+	BT_EVENT_PBAP_PHONEBOOK_SIZE, /**< PBAP Phonebook Size status callback */
+	BT_EVENT_PBAP_PHONEBOOK_PULL, /**< PBAP Phonebook Pull status callback */
+	BT_EVENT_PBAP_VCARD_LIST, /**< PBAP vCard List status callback */
+	BT_EVENT_PBAP_VCARD_PULL, /**< PBAP vCard Pull status callback */
+	BT_EVENT_PBAP_PHONEBOOK_SEARCH, /**< PBAP Phonebook Search status callback */
 	BT_EVENT_HF_SCO_CONNECTION_STATUS, /**< Audio - HF SCO Connection state change callback */
 	BT_EVENT_HF_SPEAKER_GAIN_CHANGE, /**< Audio - HF Speaker gain change callback */
 	BT_EVENT_HF_CALL_HANDLING_EVENT, /**< Audio - HF call event callback */
 	BT_EVENT_HF_VENDOR_DEP_CMD_EVENT, /**< Audio - HF Vendor Command callback */
 	BT_EVENT_HF_MULTI_CALL_HANDLING_EVENT, /**< Audio - HF 3-way call event callback */
-	BT_EVENT_CONNECTABLE_CHANGED_EVENT, /**< Adapter connectable changed callback */
+#endif
 } bt_event_e;
 
 /**
  * @internal
  */
+typedef struct {
+	int handle;
+
+	bt_adapter_le_advertising_state_changed_cb cb;
+	void *cb_data;
+
+	bt_adapter_le_advertising_params_s adv_params;
+
+	unsigned int adv_data_len;
+	char *adv_data;
+
+	unsigned int scan_rsp_data_len;
+	char *scan_rsp_data;
+
+	void *user_data;
+} bt_advertiser_s;
+
+/**
+ * @internal
+ */
 typedef struct bt_event_sig_event_slot_s
 {
     int event_type;
@@ -133,6 +168,18 @@ int _bt_check_init_status(void);
 
 /**
  * @internal
+ * @brief Initialize Bluetooth LE adapter
+ */
+int _bt_le_adapter_init(void);
+
+/**
+ * @internal
+ * @brief Deinitialize Bluetooth LE adapter
+ */
+int _bt_le_adapter_deinit(void);
+
+/**
+ * @internal
  * @brief Set the event callback.
  */
 void _bt_set_cb(int events, void *callback, void *user_data);
@@ -201,11 +248,14 @@ bt_adapter_visibility_mode_e _bt_get_bt_visibility_mode_e(bluetooth_discoverable
  */
 void _bt_audio_event_proxy(int event, bt_audio_event_param_t *param, void *user_data);
 
+#ifdef TIZEN_WEARABLE
 /**
  * @internal
  * @brief Since the HF call back and event proxy call backs have different prototype it is wrapper function.
  */
 void _bt_hf_event_proxy(int event, bt_hf_event_param_t *param, void *user_data);
+#endif
+
 /**
  * @internal
  * @brief Since the Telephony call back and event proxy call backs have different prototype it is wrapper function.
diff --git a/include/bluetooth_type.h b/include/bluetooth_type.h
new file mode 100755
index 0000000..d569dc6
--- /dev/null
+++ b/include/bluetooth_type.h
@@ -0,0 +1,1615 @@
+/*
+ * 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.
+ */
+
+
+#ifndef __TIZEN_NETWORK_BLUETOOTH_TYPE_H__
+#define __TIZEN_NETWORK_BLUETOOTH_TYPE_H__
+
+ #ifdef __cplusplus
+extern "C"
+{
+#endif /* __cplusplus */
+
+/**
+ * @file bluetooth_type.h
+ * @brief API to control the Bluetooth adapter, devices and communications.
+ * @ingroup     CAPI_NETWORK_BLUETOOTH_TYPE_MODULE
+ */
+
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_MODULE
+ * @brief Enumerations of Bluetooth error codes.
+ * @since_tizen 2.3
+ */
+typedef enum
+{
+	BT_ERROR_NONE = TIZEN_ERROR_NONE, /**< Successful*/
+	BT_ERROR_CANCELLED = TIZEN_ERROR_CANCELED, /**< Operation cancelled */
+	BT_ERROR_INVALID_PARAMETER = TIZEN_ERROR_INVALID_PARAMETER, /**< Invalid parameter */
+	BT_ERROR_OUT_OF_MEMORY = TIZEN_ERROR_OUT_OF_MEMORY, /**< Out of memory */
+	BT_ERROR_RESOURCE_BUSY = TIZEN_ERROR_RESOURCE_BUSY, /**< Device or resource busy */
+	BT_ERROR_TIMED_OUT = TIZEN_ERROR_TIMED_OUT, /**< Timeout error */
+	BT_ERROR_NOW_IN_PROGRESS = TIZEN_ERROR_NOW_IN_PROGRESS, /**< Operation now in progress */
+	BT_ERROR_NOT_SUPPORTED = TIZEN_ERROR_NOT_SUPPORTED, /**< Not Supported */
+	BT_ERROR_PERMISSION_DENIED = TIZEN_ERROR_PERMISSION_DENIED, /**< Permission denied */
+	BT_ERROR_QUOTA_EXCEEDED = TIZEN_ERROR_QUOTA_EXCEEDED, /**< Quota exceeded */
+	BT_ERROR_NOT_INITIALIZED = TIZEN_ERROR_BLUETOOTH|0x0101, /**< Local adapter not initialized */
+	BT_ERROR_NOT_ENABLED = TIZEN_ERROR_BLUETOOTH|0x0102, /**< Local adapter not enabled */
+	BT_ERROR_ALREADY_DONE = TIZEN_ERROR_BLUETOOTH|0x0103, /**< Operation already done  */
+	BT_ERROR_OPERATION_FAILED = TIZEN_ERROR_BLUETOOTH|0x0104, /**< Operation failed */
+	BT_ERROR_NOT_IN_PROGRESS = TIZEN_ERROR_BLUETOOTH|0x0105, /**< Operation not in progress */
+	BT_ERROR_REMOTE_DEVICE_NOT_BONDED = TIZEN_ERROR_BLUETOOTH|0x0106, /**< Remote device not bonded */
+	BT_ERROR_AUTH_REJECTED = TIZEN_ERROR_BLUETOOTH|0x0107, /**< Authentication rejected */
+	BT_ERROR_AUTH_FAILED = TIZEN_ERROR_BLUETOOTH|0x0108, /**< Authentication failed */
+	BT_ERROR_REMOTE_DEVICE_NOT_FOUND = TIZEN_ERROR_BLUETOOTH|0x0109, /**< Remote device not found */
+	BT_ERROR_SERVICE_SEARCH_FAILED = TIZEN_ERROR_BLUETOOTH|0x010A, /**< Service search failed */
+	BT_ERROR_REMOTE_DEVICE_NOT_CONNECTED = TIZEN_ERROR_BLUETOOTH|0x010B, /**< Remote device is not connected */
+	BT_ERROR_AGAIN = TIZEN_ERROR_BLUETOOTH|0x010C, /**< Resource temporarily unavailable */
+	BT_ERROR_SERVICE_NOT_FOUND = TIZEN_ERROR_BLUETOOTH|0x010D, /**< Service Not Found */
+} bt_error_e;
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
+ * @brief  Enumerations of the Bluetooth adapter state.
+ * @since_tizen 2.3
+ */
+typedef enum
+{
+	BT_ADAPTER_DISABLED = 0x00, /**< Bluetooth adapter is disabled */
+	BT_ADAPTER_ENABLED, /**< Bluetooth adapter is enabled */
+} bt_adapter_state_e;
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_LE_MODULE
+ * @brief  Enumerations of the Bluetooth adapter le state.
+ * @since_tizen 2.3
+ */
+typedef enum
+{
+	BT_ADAPTER_LE_DISABLED = 0x00, /**< Bluetooth le is disabled */
+	BT_ADAPTER_LE_ENABLED, /**< Bluetooth le is enabled */
+} bt_adapter_le_state_e;
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
+ * @brief Enumerations of the Bluetooth visibility mode.
+ * @since_tizen 2.3
+ */
+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,
+							    it is changed to #BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE.*/
+} bt_adapter_visibility_mode_e;
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
+ * @brief Enumerations of the discovery state of Bluetooth device.
+ * @since_tizen 2.3
+ */
+typedef enum
+{
+	BT_ADAPTER_DEVICE_DISCOVERY_STARTED, /**< Device discovery is started */
+	BT_ADAPTER_DEVICE_DISCOVERY_FINISHED, /**< Device discovery is finished */
+	BT_ADAPTER_DEVICE_DISCOVERY_FOUND, /**< The remote Bluetooth device is found */
+} bt_adapter_device_discovery_state_e;
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_LE_MODULE
+ * @brief Enumerations of the discovery state of Bluetooth LE device.
+ * @since_tizen 2.3
+ */
+typedef enum
+{
+	BT_ADAPTER_LE_DEVICE_DISCOVERY_STARTED, /**< LE device discovery is started */
+	BT_ADAPTER_LE_DEVICE_DISCOVERY_FINISHED, /**< LE device discovery is finished */
+	BT_ADAPTER_LE_DEVICE_DISCOVERY_FOUND, /**< The remote Bluetooth LE device is found */
+} bt_adapter_le_device_discovery_state_e;
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_LE_MODULE
+ * @brief  Enumerations of the Bluetooth advertising state.
+ * @since_tizen 2.3
+ */
+typedef enum {
+	BT_ADAPTER_LE_ADVERTISING_STOPPED = 0x00, /**< Bluetooth advertising is stopped */
+	BT_ADAPTER_LE_ADVERTISING_STARTED, /**< Bluetooth advertising is started */
+} bt_adapter_le_advertising_state_e;
+
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_LE_MODULE
+ * @brief  Enumerations of the Bluetooth advertising filter policy.
+ * @since_tizen 2.3
+ */
+typedef enum {
+	BT_ADAPTER_LE_ADVERTISING_FILTER_DEFAULT = 0x00, /**< White list is not in use */
+	BT_ADAPTER_LE_ADVERTISING_FILTER_ALLOW_SCAN_WL = 0x01, /**< Allow the scan
+					request that in the White list */
+	BT_ADAPTER_LE_ADVERTISING_FILTER_ALLOW_CONN_WL = 0x02, /**< Allow the connectoin
+					request that in the White list */
+	BT_ADAPTER_LE_ADVERTISING_FILTER_ALLOW_SCAN_CONN_WL = 0x03, /**< Allow the
+					scan and connectoin request that in the White list */
+} bt_adapter_le_advertising_filter_policy_e;
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_LE_MODULE
+ * @brief  Enumerations of the Bluetooth advertising type.
+ * @since_tizen 2.3
+ */
+typedef enum {
+	BT_ADAPTER_LE_ADVERTISING_CONNECTABLE = 0x00, /**< Connectable undirected advertising (ADV_IND) */
+	BT_ADAPTER_LE_ADVERTISING_CONNECTABLE_DIRECT_HIGH = 0x01, /**< Connectable high duty cycle directed advertising (ADV_DIRECT_IND) */
+	BT_ADAPTER_LE_ADVERTISING_SCANNABLE = 0x02, /**< Scannable undirected advertising (ADV_SCAN_IND) */
+	BT_ADAPTER_LE_ADVERTISING_NON_CONNECTABLE = 0x03, /**< Non connectable undirected advertising (ADV_NONCOND_IND) */
+	BT_ADAPTER_LE_ADVERTISING_CONNECTABLE_DIRECT_LOW = 0x04, /**< Connectable low duty cycle directed advertising (ADV_DIRECT_IND) */
+} bt_adapter_le_advertising_type_e;
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_LE_MODULE
+ * @brief  Enumerations of the Bluetooth LE packet type.
+ * @since_tizen 2.3
+ */
+typedef enum {
+	BT_ADAPTER_LE_PACKET_ADVERTISING, /**< Advertising packet */
+	BT_ADAPTER_LE_PACKET_SCAN_RESPONSE, /**< Sacn response packet */
+} bt_adapter_le_packet_type_e;
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_LE_MODULE
+ * @brief  Enumerations of the Bluetooth LE data type
+ *         that can be included in LE packets.
+ * @since_tizen 2.3
+ */
+typedef enum {
+	BT_ADAPTER_LE_PACKET_DATA_COMP_LIST_16_BIT_SERVICE_CLASS_UUIDS = 0x03, /**< 16 bit UUID */
+	BT_ADAPTER_LE_PACKET_DATA_MANUFACTURER_SPECIFIC_DATA = 0xff, /**< Manufacturer data */
+} bt_adapter_le_packet_data_type_e;
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
+ * @brief Enumerations of device disconnect reason.
+ * @since_tizen 2.3
+ */
+typedef enum
+{
+	BT_DEVICE_DISCONNECT_REASON_UNKNOWN, /**< Disconnected by unknown reason */
+	BT_DEVICE_DISCONNECT_REASON_TIMEOUT, /**< Disconnected by timeout */
+	BT_DEVICE_DISCONNECT_REASON_LOCAL_HOST, /**< Disconnected by local host */
+	BT_DEVICE_DISCONNECT_REASON_REMOTE, /**< Disconnected by remote */
+} bt_device_disconnect_reason_e;
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
+ * @brief Enumerations of connection link type.
+ * @since_tizen 2.3
+ */
+typedef enum
+{
+	BT_DEVICE_CONNECTION_LINK_BREDR, /**< BR/EDR link */
+	BT_DEVICE_CONNECTION_LINK_LE, /**< LE link */
+	BT_DEVICE_CONNECTION_LINK_DEFAULT = 0xFF, /**< The connection type defualt */
+} bt_device_connection_link_type_e;
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
+ * @brief Enumerations of device authorization state.
+ * @since_tizen 2.3
+ */
+typedef enum
+{
+	BT_DEVICE_AUTHORIZED, /**< The remote Bluetooth device is authorized */
+	BT_DEVICE_UNAUTHORIZED, /**< The remote Bluetooth device is unauthorized */
+} bt_device_authorization_e;
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
+ * @brief Enumerations of Bluetooth profile.
+ * @since_tizen 2.3
+ */
+typedef enum
+{
+    BT_PROFILE_RFCOMM = 0x01, /**< RFCOMM Profile */
+    BT_PROFILE_A2DP = 0x02, /**< Advanced Audio Distribution Profile */
+    BT_PROFILE_HSP = 0x04, /**< Headset Profile */
+    BT_PROFILE_HID = 0x08, /**< Human Interface Device Profile */
+    BT_PROFILE_NAP = 0x10, /**< Network Access Point Profile */
+    BT_PROFILE_AG = 0x20, /**< Audio Gateway Profile */
+    BT_PROFILE_GATT = 0x40, /**< Generic Attribute Profile */
+    BT_PROFILE_NAP_SERVER = 0x80, /**< NAP server Profile */
+} bt_profile_e;
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
+ * @brief Enumerations of device address type.
+ * @since_tizen 2.3
+ */
+typedef enum
+{
+	BT_DEVICE_PUBLIC_ADDRESS = 0x00, /**< Public address */
+	BT_DEVICE_RANDOM_ADDRESS, /**< Random address */
+} bt_device_address_type_e;
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
+ * @brief  Enumerations of service class.
+ * @since_tizen 2.3
+ */
+typedef enum {
+	BT_SC_NONE = 0, /**< No service class */
+	BT_SC_RES_SERVICE_MASK = 0x00000001, /**< RES service class */
+	BT_SC_SPP_SERVICE_MASK = 0x00000002, /**< SPP service class */
+	BT_SC_DUN_SERVICE_MASK = 0x00000004, /**< DUN service class */
+	BT_SC_FAX_SERVICE_MASK = 0x00000008, /**< FAX service class */
+	BT_SC_LAP_SERVICE_MASK = 0x00000010, /**< LAP service class */
+	BT_SC_HSP_SERVICE_MASK = 0x00000020, /**< HSP service class */
+	BT_SC_HFP_SERVICE_MASK = 0x00000040, /**< HFP service class */
+	BT_SC_OPP_SERVICE_MASK = 0x00000080, /**< OPP service class */
+	BT_SC_FTP_SERVICE_MASK = 0x00000100, /**< FTP service class */
+	BT_SC_CTP_SERVICE_MASK = 0x00000200, /**< CTP service class */
+	BT_SC_ICP_SERVICE_MASK = 0x00000400, /**< ICP service class */
+	BT_SC_SYNC_SERVICE_MASK = 0x00000800, /**< SYNC service class */
+	BT_SC_BPP_SERVICE_MASK = 0x00001000, /**< BPP service class */
+	BT_SC_BIP_SERVICE_MASK = 0x00002000, /**< BIP service class */
+	BT_SC_PANU_SERVICE_MASK = 0x00004000, /**< PANU service class */
+	BT_SC_NAP_SERVICE_MASK = 0x00008000, /**< NAP service class */
+	BT_SC_GN_SERVICE_MASK = 0x00010000, /**< GN service class */
+	BT_SC_SAP_SERVICE_MASK = 0x00020000, /**< SAP service class */
+	BT_SC_A2DP_SERVICE_MASK = 0x00040000, /**< A2DP service class */
+	BT_SC_AVRCP_SERVICE_MASK = 0x00080000, /**< AVRCP service class */
+	BT_SC_PBAP_SERVICE_MASK = 0x00100000, /**< PBAP service class */
+	BT_SC_HID_SERVICE_MASK = 0x00200000, /**< HID service class */
+	BT_SC_ALL_SERVICE_MASK = 0x00FFFFFF, /**< ALL service class */
+	BT_SC_MAX /**< MAX service class */
+} bt_service_class_t;
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
+ * @brief  Enumerations of major service class.
+ * @since_tizen 2.3
+ */
+typedef enum
+{
+	BT_MAJOR_SERVICE_CLASS_LIMITED_DISCOVERABLE_MODE  = 0x002000, /**< Limited discoverable mode */
+	BT_MAJOR_SERVICE_CLASS_POSITIONING                = 0x010000, /**< Positioning class */
+	BT_MAJOR_SERVICE_CLASS_NETWORKING                 = 0x020000, /**< Networking class */
+	BT_MAJOR_SERVICE_CLASS_RENDERING                  = 0x040000, /**< Rendering class */
+	BT_MAJOR_SERVICE_CLASS_CAPTURING                  = 0x080000, /**< Capturing class */
+	BT_MAJOR_SERVICE_CLASS_OBJECT_TRANSFER            = 0x100000, /**< Object transferring class */
+	BT_MAJOR_SERVICE_CLASS_AUDIO                      = 0x200000, /**< Audio class*/
+	BT_MAJOR_SERVICE_CLASS_TELEPHONY                  = 0x400000, /**< Telephony class */
+	BT_MAJOR_SERVICE_CLASS_INFORMATION                = 0x800000, /**< Information class */
+} bt_major_service_class_e;
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
+ * @brief  Enumerations of major device class.
+ * @since_tizen 2.3
+ */
+typedef enum
+{
+	BT_MAJOR_DEVICE_CLASS_MISC = 0x00, /**< Miscellaneous major device class*/
+	BT_MAJOR_DEVICE_CLASS_COMPUTER = 0x01, /**< Computer major device class */
+	BT_MAJOR_DEVICE_CLASS_PHONE = 0x02, /**< Phone major device class */
+	BT_MAJOR_DEVICE_CLASS_LAN_NETWORK_ACCESS_POINT = 0x03, /**< LAN/Network access point major device class */
+	BT_MAJOR_DEVICE_CLASS_AUDIO_VIDEO = 0x04, /**< Audio/Video major device class */
+	BT_MAJOR_DEVICE_CLASS_PERIPHERAL = 0x05, /**< Peripheral major device class */
+	BT_MAJOR_DEVICE_CLASS_IMAGING = 0x06, /**< Imaging major device class */
+	BT_MAJOR_DEVICE_CLASS_WEARABLE = 0x07, /**< Wearable device class */
+	BT_MAJOR_DEVICE_CLASS_TOY = 0x08, /**< Toy device class */
+	BT_MAJOR_DEVICE_CLASS_HEALTH = 0x09, /**< Health device class */
+	BT_MAJOR_DEVICE_CLASS_UNCATEGORIZED = 0x1F, /**< Uncategorized major device class */
+} bt_major_device_class_e;
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
+ * @brief  Enumerations of minor device class.
+ * @since_tizen 2.3
+ */
+typedef enum
+{
+	BT_MINOR_DEVICE_CLASS_COMPUTER_UNCATEGORIZED = 0x00, /**< Uncategorized minor device class of computer */
+	BT_MINOR_DEVICE_CLASS_COMPUTER_DESKTOP_WORKSTATION = 0x04, /**< Desktop workstation minor device class of computer */
+	BT_MINOR_DEVICE_CLASS_COMPUTER_SERVER_CLASS = 0x08, /**< Server minor device class of computer */
+	BT_MINOR_DEVICE_CLASS_COMPUTER_LAPTOP = 0x0C, /**< Laptop minor device class of computer */
+	BT_MINOR_DEVICE_CLASS_COMPUTER_HANDHELD_PC_OR_PDA = 0x10, /**< Handheld PC/PDA minor device class of computer */
+	BT_MINOR_DEVICE_CLASS_COMPUTER_PALM_SIZED_PC_OR_PDA = 0x14, /**< Palm sized PC/PDA minor device class of computer */
+	BT_MINOR_DEVICE_CLASS_COMPUTER_WEARABLE_COMPUTER = 0x18, /**< Wearable(watch sized) minor device class of computer */
+
+	BT_MINOR_DEVICE_CLASS_PHONE_UNCATEGORIZED = 0x00, /**< Uncategorized minor device class of phone */
+	BT_MINOR_DEVICE_CLASS_PHONE_CELLULAR = 0x04, /**< Cellular minor device class of phone */
+	BT_MINOR_DEVICE_CLASS_PHONE_CORDLESS = 0x08, /**< Cordless minor device class of phone */
+	BT_MINOR_DEVICE_CLASS_PHONE_SMART_PHONE = 0x0C, /**< Smart phone minor device class of phone */
+	BT_MINOR_DEVICE_CLASS_PHONE_WIRED_MODEM_OR_VOICE_GATEWAY = 0x10, /**< Wired modem or voice gateway minor device class of phone */
+	BT_MINOR_DEVICE_CLASS_PHONE_COMMON_ISDN_ACCESS = 0x14, /**< Common ISDN minor device class of phone */
+
+	BT_MINOR_DEVICE_CLASS_LAN_NETWORK_ACCESS_POINT_FULLY_AVAILABLE = 0x04, /**< Fully available minor device class of LAN/Network access point */
+	BT_MINOR_DEVICE_CLASS_LAN_NETWORK_ACCESS_POINT_1_TO_17_PERCENT_UTILIZED = 0x20, /**< 1-17% utilized minor device class of LAN/Network access point */
+	BT_MINOR_DEVICE_CLASS_LAN_NETWORK_ACCESS_POINT_17_TO_33_PERCENT_UTILIZED = 0x40, /**< 17-33% utilized minor device class of LAN/Network access point */
+	BT_MINOR_DEVICE_CLASS_LAN_NETWORK_ACCESS_POINT_33_TO_50_PERCENT_UTILIZED = 0x60, /**< 33-50% utilized minor device class of LAN/Network access point */
+	BT_MINOR_DEVICE_CLASS_LAN_NETWORK_ACCESS_POINT_50_to_67_PERCENT_UTILIZED = 0x80, /**< 50-67% utilized minor device class of LAN/Network access point */
+	BT_MINOR_DEVICE_CLASS_LAN_NETWORK_ACCESS_POINT_67_TO_83_PERCENT_UTILIZED = 0xA0, /**< 67-83% utilized minor device class of LAN/Network access point */
+	BT_MINOR_DEVICE_CLASS_LAN_NETWORK_ACCESS_POINT_83_TO_99_PERCENT_UTILIZED = 0xC0, /**< 83-99% utilized minor device class of LAN/Network access point */
+	BT_MINOR_DEVICE_CLASS_LAN_NETWORK_ACCESS_POINT_NO_SERVICE_AVAILABLE = 0xE0, /**< No service available minor device class of LAN/Network access point */
+
+	BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_UNCATEGORIZED = 0x00, /**< Uncategorized minor device class of audio/video */
+	BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_WEARABLE_HEADSET = 0x04, /**< Wearable headset minor device class of audio/video */
+	BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_HANDS_FREE = 0x08, /**< Hands-free minor device class of audio/video */
+	BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_MICROPHONE = 0x10, /**< Microphone minor device class of audio/video */
+	BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_LOUDSPEAKER = 0x14, /**< Loudspeaker minor device class of audio/video */
+	BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_HEADPHONES = 0x18, /**< Headphones minor device class of audio/video */
+	BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_PORTABLE_AUDIO = 0x1C, /**< Portable audio minor device class of audio/video */
+	BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_CAR_AUDIO = 0x20, /**< Car audio minor device class of audio/video */
+	BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_SET_TOP_BOX = 0x24, /**< Set-top box minor device class of audio/video */
+	BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_HIFI_AUDIO_DEVICE = 0x28, /**< Hifi audio minor device class of audio/video */
+	BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_VCR = 0x2C, /**< VCR minor device class of audio/video */
+	BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_VIDEO_CAMERA = 0x30, /**< Video camera minor device class of audio/video */
+	BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_CAMCORDER = 0x34, /**< Camcorder minor device class of audio/video */
+	BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_VIDEO_MONITOR = 0x38, /**< Video monitor minor device class of audio/video */
+	BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_VIDEO_DISPLAY_LOUDSPEAKER = 0x3C, /**< Video display and loudspeaker minor device class of audio/video */
+	BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_VIDEO_CONFERENCING = 0x40, /**< Video conferencing minor device class of audio/video */
+	BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_GAMING_TOY = 0x48, /**< Gaming/toy minor device class of audio/video */
+
+	BT_MINOR_DEVICE_CLASS_PERIPHERA_UNCATEGORIZED = 0x00, /**< Uncategorized minor device class of peripheral */
+	BT_MINOR_DEVICE_CLASS_PERIPHERAL_KEY_BOARD = 0x40, /**< Key board minor device class of peripheral */
+	BT_MINOR_DEVICE_CLASS_PERIPHERAL_POINTING_DEVICE = 0x80, /**< Pointing device minor device class of peripheral */
+	BT_MINOR_DEVICE_CLASS_PERIPHERAL_COMBO_KEYBOARD_POINTING_DEVICE = 0xC0, /**< Combo keyboard or pointing device minor device class of peripheral */
+	BT_MINOR_DEVICE_CLASS_PERIPHERAL_JOYSTICK = 0x04, /**< Joystick minor device class of peripheral */
+	BT_MINOR_DEVICE_CLASS_PERIPHERAL_GAME_PAD = 0x08, /**< Game pad minor device class of peripheral */
+	BT_MINOR_DEVICE_CLASS_PERIPHERAL_REMOTE_CONTROL = 0x0C, /**< Remote control minor device class of peripheral */
+	BT_MINOR_DEVICE_CLASS_PERIPHERAL_SENSING_DEVICE = 0x10, /**< Sensing device minor device class of peripheral */
+	BT_MINOR_DEVICE_CLASS_PERIPHERAL_DIGITIZER_TABLET = 0x14, /**< Digitizer minor device class of peripheral */
+	BT_MINOR_DEVICE_CLASS_PERIPHERAL_CARD_READER = 0x18, /**< Card reader minor device class of peripheral */
+	BT_MINOR_DEVICE_CLASS_PERIPHERAL_DIGITAL_PEN = 0x1C, /**< Digital pen minor device class of peripheral */
+	BT_MINOR_DEVICE_CLASS_PERIPHERAL_HANDHELD_SCANNER = 0x20, /**< Handheld scanner minor device class of peripheral */
+	BT_MINOR_DEVICE_CLASS_PERIPHERAL_HANDHELD_GESTURAL_INPUT_DEVICE = 0x24, /**< Handheld gestural input device minor device class of peripheral */
+
+	BT_MINOR_DEVICE_CLASS_IMAGING_DISPLAY = 0x10, /**< Display minor device class of imaging */
+	BT_MINOR_DEVICE_CLASS_IMAGING_CAMERA = 0x20, /**< Camera minor device class of imaging */
+	BT_MINOR_DEVICE_CLASS_IMAGING_SCANNER = 0x40, /**< Scanner minor device class of imaging */
+	BT_MINOR_DEVICE_CLASS_IMAGING_PRINTER = 0x80, /**< Printer minor device class of imaging */
+
+	BT_MINOR_DEVICE_CLASS_WEARABLE_WRIST_WATCH = 0x04, /**< Wrist watch minor device class of wearable */
+	BT_MINOR_DEVICE_CLASS_WEARABLE_PAGER = 0x08, /**< Pager minor device class of wearable */
+	BT_MINOR_DEVICE_CLASS_WEARABLE_JACKET = 0x0C, /**< Jacket minor device class of wearable */
+	BT_MINOR_DEVICE_CLASS_WEARABLE_HELMET = 0x10, /**< Helmet minor device class of wearable */
+	BT_MINOR_DEVICE_CLASS_WEARABLE_GLASSES = 0x14, /**< Glasses minor device class of wearable */
+
+	BT_MINOR_DEVICE_CLASS_TOY_ROBOT = 0x04, /**< Robot minor device class of toy */
+	BT_MINOR_DEVICE_CLASS_TOY_VEHICLE = 0x08, /**< Vehicle minor device class of toy */
+	BT_MINOR_DEVICE_CLASS_TOY_DOLL_ACTION = 0x0C, /**< Doll/Action minor device class of toy */
+	BT_MINOR_DEVICE_CLASS_TOY_CONTROLLER = 0x10, /**< Controller minor device class of toy */
+	BT_MINOR_DEVICE_CLASS_TOY_GAME = 0x14, /**< Game minor device class of toy */
+
+	BT_MINOR_DEVICE_CLASS_HEALTH_UNCATEGORIZED = 0x00, /**< Uncategorized minor device class of health */
+	BT_MINOR_DEVICE_CLASS_HEALTH_BLOOD_PRESSURE_MONITOR = 0x04, /**< Blood pressure monitor minor device class of health */
+	BT_MINOR_DEVICE_CLASS_HEALTH_THERMOMETER = 0x08, /**< Thermometer minor device class of health */
+	BT_MINOR_DEVICE_CLASS_HEALTH_WEIGHING_SCALE = 0x0C, /**< Weighing scale minor device class of health */
+	BT_MINOR_DEVICE_CLASS_HEALTH_GLUCOSE_METER = 0x10, /**< Glucose minor device class of health */
+	BT_MINOR_DEVICE_CLASS_HEALTH_PULSE_OXIMETER = 0x14, /**< Pulse oximeter minor device class of health */
+	BT_MINOR_DEVICE_CLASS_HEALTH_HEART_PULSE_RATE_MONITOR = 0x18, /**< Heart/Pulse rate monitor minor device class of health */
+	BT_MINOR_DEVICE_CLASS_HEALTH_DATA_DISPLAY = 0x1C, /**< Health data display minor device class of health */
+	BT_MINOR_DEVICE_CLASS_HEALTH_STEP_COUNTER = 0x20, /**< Step counter minor device class of health */
+	BT_MINOR_DEVICE_CLASS_HEALTH_BODY_COMPOSITION_ANALYZER = 0x24, /**< Body composition analyzer minor device class of health */
+	BT_MINOR_DEVICE_CLASS_HEALTH_PEAK_FLOW_MONITOR = 0x28, /**< Peak flow monitor minor device class of health */
+	BT_MINOR_DEVICE_CLASS_HEALTH_MEDICATION_MONITOR = 0x2C, /**< Medication monitor minor device class of health */
+	BT_MINOR_DEVICE_CLASS_HEALTH_KNEE_PROSTHESIS = 0x30, /**< Knee prosthesis minor device class of health */
+	BT_MINOR_DEVICE_CLASS_HEALTH_ANKLE_PROSTHESIS = 0x34, /**< Ankle prosthesis minor device class of health */
+} bt_minor_device_class_e;
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
+ * @brief  Enumerations of gap appearance type.
+ * @since_tizen 2.3
+ */
+typedef enum
+{
+	BT_APPEARANCE_TYPE_UNKNOWN = 0x00, /**< Unknown appearance type */
+	BT_APPEARANCE_TYPE_GENERIC_PHONE = 0x40, /**< Generic Phone type - Generic category */
+	BT_APPEARANCE_TYPE_GENERIC_COMPUTER = 0x80, /**< Generic Computer type - Generic category */
+	BT_APPEARANCE_TYPE_GENERIC_WATCH = 0xC0, /**< Generic Watch type - Generic category */
+} bt_appearance_type_e;
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE
+ * @brief  Enumerations of connected Bluetooth device event role.
+ * @since_tizen 2.3
+ */
+typedef enum
+{
+	BT_SOCKET_UNKNOWN = 0x00, /**< Unknown role*/
+	BT_SOCKET_SERVER , /**< Server role*/
+	BT_SOCKET_CLIENT, /**< Client role*/
+} bt_socket_role_e;
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE
+ * @brief  Enumerations of Bluetooth socket connection state.
+ * @since_tizen 2.3
+ */
+typedef enum
+{
+	BT_SOCKET_CONNECTED, /**< RFCOMM is connected */
+	BT_SOCKET_DISCONNECTED, /**< RFCOMM is disconnected */
+} bt_socket_connection_state_e;
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_MODULE
+ * @brief  Enumerations for the types of profiles related with audio
+ * @since_tizen 2.3
+ */
+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_AG,  /**< AG(Audio Gateway) */
+} bt_audio_profile_type_e;
+
+/**
+ * @internal
+ * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
+ * @brief  Enumerations for the call handling event
+ * @since_tizen 2.3
+ */
+typedef enum {
+    BT_AG_CALL_HANDLING_EVENT_ANSWER = 0x00,  /**< Request to answer an incoming call */
+    BT_AG_CALL_HANDLING_EVENT_RELEASE,  /**< Request to release a call */
+    BT_AG_CALL_HANDLING_EVENT_REJECT,  /**< Request to reject an incoming call */
+} bt_ag_call_handling_event_e;
+
+/**
+ * @internal
+ * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
+ * @brief  Enumerations for the multi call handling event
+ * @since_tizen 2.3
+ */
+typedef enum {
+    BT_AG_MULTI_CALL_HANDLING_EVENT_RELEASE_HELD_CALLS = 0x00,  /**< Request to release held calls */
+    BT_AG_MULTI_CALL_HANDLING_EVENT_RELEASE_ACTIVE_CALLS,  /**< Request to release active calls */
+    BT_AG_MULTI_CALL_HANDLING_EVENT_ACTIVATE_HELD_CALL,  /**< Request to put active calls into hold state and activate another (held or waiting) call */
+    BT_AG_MULTI_CALL_HANDLING_EVENT_MERGE_CALLS,  /**< Request to add a held call to the conversation */
+    BT_AG_MULTI_CALL_HANDLING_EVENT_EXPLICIT_CALL_TRANSFER,  /**< Request to let a user who has two calls to connect these two calls together and release its connections to both other parties */
+} bt_ag_multi_call_handling_event_e;
+
+/**
+ * @internal
+ * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
+ * @brief  Enumerations for the call state
+ * @since_tizen 2.3
+ */
+typedef enum {
+    BT_AG_CALL_EVENT_IDLE = 0x00,  /**< Idle */
+    BT_AG_CALL_EVENT_ANSWERED,  /**< Answered */
+    BT_AG_CALL_EVENT_HELD,  /**< Held */
+    BT_AG_CALL_EVENT_RETRIEVED,  /**< Retrieved */
+    BT_AG_CALL_EVENT_DIALING,  /**< Dialing */
+    BT_AG_CALL_EVENT_ALERTING,  /**< Alerting */
+    BT_AG_CALL_EVENT_INCOMING,  /**< Incoming */
+} bt_ag_call_event_e;
+
+/**
+ * @internal
+ * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
+ * @brief  Enumerations for the call state
+ * @since_tizen 2.3
+ */
+typedef enum {
+    BT_AG_CALL_STATE_IDLE = 0x00,  /**< Idle state */
+    BT_AG_CALL_STATE_ACTIVE,  /**< Active state */
+    BT_AG_CALL_STATE_HELD,  /**< Held state */
+    BT_AG_CALL_STATE_DIALING,  /**< Dialing state */
+    BT_AG_CALL_STATE_ALERTING,  /**< Alerting state */
+    BT_AG_CALL_STATE_INCOMING,  /**< Incoming state */
+    BT_AG_CALL_STATE_WAITING,  /**< Waiting for connected indication event after answering an incoming call*/
+} bt_ag_call_state_e;
+
+/**
+ * @internal
+ * @ingroup CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE
+ * @brief  Enumerations for the equalizer state
+ * @since_tizen 2.3
+ */
+typedef enum {
+    BT_AVRCP_EQUALIZER_STATE_OFF = 0x01,  /**< Equalizer Off */
+    BT_AVRCP_EQUALIZER_STATE_ON,  /**< Equalizer On */
+} bt_avrcp_equalizer_state_e;
+
+/**
+ * @internal
+ * @ingroup CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE
+ * @brief  Enumerations for the repeat mode
+ * @since_tizen 2.3
+ */
+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;
+
+/**
+ * @internal
+ * @ingroup CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE
+ * @brief  Enumerations for the shuffle mode
+ * @since_tizen 2.3
+ */
+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;
+
+/**
+ * @internal
+ * @ingroup CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE
+ * @brief  Enumerations for the scan mode
+ * @since_tizen 2.3
+ */
+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;
+
+/**
+ * @internal
+ * @ingroup CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE
+ * @brief  Enumerations for the player state
+ * @since_tizen 2.3
+ */
+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
+ * @since_tizen 2.3
+ */
+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_PAN_PANU_MODULE
+ * @brief  Enumerations for the types of PAN(Personal Area Networking) service
+ * @since_tizen 2.3
+ */
+typedef enum {
+    BT_PANU_SERVICE_TYPE_NAP = 0,  /**< Network Access Point */
+} bt_panu_service_type_e;
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_LE_MODULE
+ * @brief The handle to control Bluetooth LE advertising
+ * @since_tizen 2.3
+ */
+typedef void* bt_advertiser_h;
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_GATT_MODULE
+ * @brief  The attribute handle of GATT(Generic Attribute Profile)
+ * @since_tizen 2.3
+ */
+typedef void* bt_gatt_attribute_h;
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
+ * @brief  The handle of calls state
+ * @since_tizen 2.3
+ */
+typedef void* bt_call_list_h;
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
+ * @brief Class structure of device and service.
+ * @since_tizen 2.3
+ *
+ * @see #bt_device_info_s
+ * @see #bt_adapter_device_discovery_info_s
+ * @see bt_device_bond_created_cb()
+ * @see bt_adapter_device_discovery_state_changed_cb()
+ */
+typedef struct
+{
+	bt_major_device_class_e major_device_class;	/**< Major device class. */
+	bt_minor_device_class_e minor_device_class;	/**< Minor device class. */
+	int major_service_class_mask;	/**< Major service class mask.
+	This value can be a combination of #bt_major_service_class_e like #BT_MAJOR_SERVICE_CLASS_RENDERING | #BT_MAJOR_SERVICE_CLASS_AUDIO */
+} bt_class_s;
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
+ * @brief Structure of device discovery information.
+ * @since_tizen 2.3
+ *
+ * @see #bt_class_s
+ * @see bt_adapter_device_discovery_state_changed_cb()
+ */
+typedef struct
+{
+	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_appearance_type_e appearance;	/**< The Bluetooth appearance */
+	int manufacturer_data_len;	/**< manufacturer specific data length */
+	char *manufacturer_data;		/**< manufacturer specific data */
+} bt_adapter_device_discovery_info_s;
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_LE_MODULE
+ * @brief Structure of le device discovery information.
+ * @since_tizen 2.3
+ *
+ * @see #bt_class_s
+ * @see bt_adapter_le_device_discovery_state_changed_cb()
+ */
+typedef struct
+{
+	char *remote_address;	/**< The address of remote device */
+	int address_type;	/**< The address type of remote device */
+	int rssi;	/**< The strength indicator of received signal  */
+	int adv_data_len;		/**< advertising indication data length */
+	char *adv_data;			/**< advertising indication data */
+	int scan_data_len;		/**< scan response data length */
+	char *scan_data;		/**< scan response data */
+} bt_adapter_le_device_discovery_info_s;
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_LE_MODULE
+ * @brief Structure of advertising parameters
+ * @since_tizen 2.3
+ *
+ * @see #bt_class_s
+ * @see bt_adapter_le_advertising_state_changed_cb()
+ * @see bt_adapter_le_start_advertising()
+ */
+typedef struct {
+	float interval_min; /**< Minimum advertising interval for non-directed advertising.
+			      A multiple of 0.625ms is only allowed (Time range : 20ms to 10.24sec). */
+	float interval_max; /**< Maximum advertising interval for non-directed advertising.
+			      A multiple of 0.625ms is only allowed (Time range : 20ms to 10.24sec). */
+	char filter_policy; /* Advertising filter policy */
+	char type; /* Advertising type */
+} bt_adapter_le_advertising_params_s;
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
+ * @brief Device information structure used for identifying pear device.
+ * @since_tizen 2.3
+ *
+ * @see #bt_class_s
+ * @see bt_device_bond_created_cb()
+ */
+typedef struct
+{
+	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 */
+	int service_count;	/**< The number of services */
+	bool is_bonded;	/**< The bonding state */
+	bool is_connected;	/**< The connection state */
+	bool is_authorized;	/**< The authorization state */
+	int manufacturer_data_len;	/**< manufacturer specific data length */
+	char *manufacturer_data;		/**< manufacturer specific data */
+} bt_device_info_s;
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
+ * @brief Service Discovery Protocol (SDP) data structure.
+ * @since_tizen 2.3
+ *
+ * @details This protocol is used for discovering available services or pear device,
+ * and finding one to connect with.
+ *
+ * @see bt_device_service_searched_cb()
+ */
+typedef struct
+{
+	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;
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
+ * @brief Device connection information structure.
+ * @since_tizen 2.3
+ *
+ * @see bt_device_connection_state_changed_cb()
+ */
+typedef struct
+{
+	char *remote_address;   /**< The address of remote device */
+	bt_device_connection_link_type_e link;  /**< Link type */
+	bt_device_disconnect_reason_e disconn_reason;  /**< Disconnection reason */
+} bt_device_connection_info_s;
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
+ * @brief Device LE connection update structure.
+ * @since_tizen 2.3
+ *
+ * @see bt_device_le_conn_update()
+ */
+typedef struct
+{
+       unsigned int interval_min;   /**< Minimum value for the connection event interval (msec) */
+       unsigned int interval_max;   /**< Maximum value for the connection event interval (msec) */
+       unsigned int latency;   /**< Slave latency (msec) */
+       unsigned int time_out;   /**< Supervision timeout (msec) */
+} bt_le_conn_update_s;
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE
+ * @brief Rfcomm connection data used for exchanging data between Bluetooth devices.
+ * @since_tizen 2.3
+ *
+ * @see bt_socket_connection_state_changed_cb()
+ */
+typedef struct
+{
+	int socket_fd;	/**< The file descriptor of connected socket */
+	int server_fd;	/**< The file descriptor of the server socket or -1 for client connection */
+	bt_socket_role_e local_role;	/**< The local device role in this connection */
+	char *remote_address;	/**< The remote device address */
+	char *service_uuid;	/**< The service UUId */
+} bt_socket_connection_s;
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE
+ * @brief Structure of RFCOMM received data.
+ * @since_tizen 2.3
+ *
+ * @remarks User can use standard linux functions for reading/writing
+ * data from/to sockets.
+ *
+ * @see bt_socket_data_received_cb()
+ */
+typedef struct
+{
+	int socket_fd;	/**< The socket fd */
+	int data_size;	/**< The length of the received data */
+	char *data;	/**< The received data */
+} bt_socket_received_data_s;
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
+ * @brief  Called when the Bluetooth adapter state changes.
+ * @since_tizen 2.3
+ *
+ * @param[in]   result  The result of the adapter state changing
+ * @param[in]   adapter_state  The adapter state to be changed
+ * @param[in]   user_data  The user data passed from the callback registration function
+ * @see bt_adapter_set_state_changed_cb()
+ * @see bt_adapter_unset_state_changed_cb()
+ */
+typedef void (*bt_adapter_state_changed_cb)(int result, bt_adapter_state_e adapter_state, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
+ * @brief  Called when adapter name changes.
+ * @since_tizen 2.3
+ *
+ * @param[in]   device_name	The name of the Bluetooth device to be changed
+ * @param[in]   user_data	The user data passed from the callback registration function
+ * @pre This function will be invoked when the name of Bluetooth adapter changes
+ * if you register this callback using bt_adapter_set_name_changed_cb().
+ * @see bt_adapter_set_name()
+ * @see bt_adapter_set_name_changed_cb()
+ * @see bt_adapter_unset_name_changed_cb()
+ */
+typedef void (*bt_adapter_name_changed_cb)(char *device_name, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
+ * @brief  Called when the visibility mode changes.
+ * @since_tizen 2.3
+ *
+ * @param[in] result The result of the visibility mode changing
+ * @param[in] visibility_mode The visibility mode to be changed
+ * @param[in] user_data The user data passed from the callback registration function
+ *
+ * @pre This function will be invoked when the visibility of Bluetooth adapter changes
+ * if you register this callback using bt_adapter_set_visibility_mode_changed_cb().
+ *
+ * @see bt_adapter_set_visibility_mode_changed_cb()
+ * @see bt_adapter_unset_visibility_mode_changed_cb()
+ */
+typedef void (*bt_adapter_visibility_mode_changed_cb)
+	(int result, bt_adapter_visibility_mode_e visibility_mode, void *user_data);
+
+/**
+ * @ingroup  CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
+ * @brief  Called every second until the visibility mode is changed to #BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE.
+ * @since_tizen 2.3
+ *
+ * @remarks  This callback function is called only if visibility mode is #BT_ADAPTER_VISIBILITY_MODE_LIMITED_DISCOVERABLE.
+ * @param[in]  duration  The duration until the visibility mode is changed to #BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE (in seconds)
+ * @param[in]  user_data  The user data passed from the callback registration function
+ * @pre  This function will be invoked if you register this callback using bt_adapter_set_visibility_duration_changed_cb().
+ * @see  bt_adapter_set_visibility_duration_changed_cb()
+ * @see  bt_adapter_unset_visibility_duration_changed_cb()
+ */
+typedef void (*bt_adapter_visibility_duration_changed_cb)(int duration, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
+ * @brief  Called when the state of device discovery changes.
+ * @since_tizen 2.3
+ *
+ * @remarks If \a discovery_state is #BT_ADAPTER_DEVICE_DISCOVERY_FOUND,
+ * then you can get some information, such as remote device address, remote device name, rssi, and bonding state.
+ *
+ * @param[in] result The result of the device discovery
+ * @param[in] discovery_state The discovery state to be changed
+ * @param[in] discovery_info The information of the discovered device \n
+ *					If \a discovery_state is #BT_ADAPTER_DEVICE_DISCOVERY_STARTED or
+ * #BT_ADAPTER_DEVICE_DISCOVERY_FINISHED, then \a discovery_info is NULL.
+ * @param[in] user_data The user data passed from the callback registration function
+ *
+ * @pre Either bt_adapter_start_device_discovery() or bt_adapter_stop_device_discovery() will invoke this function
+ * if you register this callback using bt_adapter_set_device_discovery_state_changed_cb().
+ *
+ * @see bt_adapter_start_device_discovery()
+ * @see bt_adapter_stop_device_discovery()
+ * @see bt_adapter_set_device_discovery_state_changed_cb()
+ * @see bt_adapter_unset_device_discovery_state_changed_cb()
+ *
+ */
+typedef void (*bt_adapter_device_discovery_state_changed_cb)
+	(int result, bt_adapter_device_discovery_state_e discovery_state, bt_adapter_device_discovery_info_s *discovery_info, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
+ * @brief  Called when you get bonded devices repeatedly.
+ * @since_tizen 2.3
+ *
+ * @param[in] device_info The bonded device information
+ * @param[in] user_data The user data passed from the foreach function
+ * @return @c true to continue with the next iteration of the loop,
+ * \n @c false to break out of the loop.
+ * @pre bt_adapter_foreach_bonded_device() will invoke this function.
+ *
+ * @see bt_adapter_foreach_bonded_device()
+ *
+ */
+typedef bool (*bt_adapter_bonded_device_cb)(bt_device_info_s *device_info, void *user_data);
+
+/**
+ * @internal
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
+ * @brief  Called when the connectable state changes.
+ * @since_tizen 2.3
+ *
+ * @param[in] result The result of the connectable state changing
+ * @param[in] connectable The connectable to be changed
+ * @param[in] user_data The user data passed from the callback registration function
+ *
+ * @pre This function will be invoked when the connectable state of local Bluetooth adapter changes
+ * if you register this callback using bt_adapter_set_connectable_changed_cb().
+ *
+ * @see bt_adapter_set_connectable()
+ * @see bt_adapter_set_connectable_changed_cb()
+ * @see bt_adapter_unset_connectable_changed_cb()
+ */
+typedef void (*bt_adapter_connectable_changed_cb)
+	(int result, bool connectable, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_LE_MODULE
+ * @brief  Called when the state of LE device discovery changes.
+ * @since_tizen 2.3
+ *
+ * @remarks If \a discovery_state is #BT_ADAPTER_LE_DEVICE_DISCOVERY_FOUND,
+ * then you can get some information, such as remote LE device address, remote device name, rssi, and bonding state.
+ *
+ * @param[in] result The result of the LE device discovery
+ * @param[in] discovery_state The discovery state to be changed
+ * @param[in] discovery_info The information of the discovered LE device \n
+ *					If \a discovery_state is #BT_ADAPTER_LE_DEVICE_DISCOVERY_STARTED or
+ * #BT_ADAPTER_LE_DEVICE_DISCOVERY_FINISHED, then \a discovery_info is NULL.
+ * @param[in] user_data The user data passed from the callback registration function
+ *
+ * @pre Either bt_adapter_start_device_discovery() or bt_adapter_stop_device_discovery() will invoke this function
+ * if you register this callback using bt_adapter_set_device_discovery_state_changed_cb().
+ *
+ * @see bt_adapter_le_start_device_discovery()
+ * @see bt_adapter_le_stop_device_discovery()
+ * @see bt_adapter_le_set_device_discovery_state_changed_cb()
+ * @see bt_adapter_le_unset_device_discovery_state_changed_cb()
+ *
+ */
+typedef void (*bt_adapter_le_device_discovery_state_changed_cb)
+	(int result, bt_adapter_le_device_discovery_state_e discovery_state, bt_adapter_le_device_discovery_info_s *discovery_info, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_LE_MODULE
+ * @brief  Called when the state of advertiser changes.
+ * @since_tizen 2.3
+ *
+ * @param[out] result The result of the requested state change of advertiser
+ * @param[out] advertiser The handle of the state changed advertiser
+ * @param[out] adv_state The advertiser state to be changed
+ * @param[out] user_data The user data passed from the start function
+ *
+ * @see bt_adapter_le_start_advertising()
+ * @see bt_adapter_le_stop_advertising()
+ */
+typedef void (*bt_adapter_le_advertising_state_changed_cb)(int result,
+		bt_advertiser_h advertiser, bt_adapter_le_advertising_state_e adv_state, void *user_data);
+
+/**
+ * @internal
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_LE_MODULE
+ * @brief  Called when the Bluetooth adapter le state changes.
+ * @since_tizen 2.3
+ *
+ * @param[in]   result  The result of the adapter state changing
+ * @param[in]   adapter_le_state  The adapter le state to be changed
+ * @param[in]   user_data  The user data passed from the callback registration function
+ * @pre Either bt_adapter_le_enable() or bt_adapter_le_disable() will invoke this callback if you register this callback using bt_adapter_le_set_state_changed_cb().
+ * @see bt_adapter_le_enable()
+ * @see bt_adapter_le_disable()
+ * @see bt_adapter_le_set_state_changed_cb()
+ * @see bt_adapter_le_unset_state_changed_cb()
+ */
+typedef void (*bt_adapter_le_state_changed_cb)(int result, bt_adapter_le_state_e adapter_le_state, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
+ * @brief Called when the process of creating bond finishes.
+ * @since_tizen 2.3
+ *
+ * @remarks If the remote user does not respond within 60 seconds, a time out will happen with #BT_ERROR_TIMED_OUT result code.\n
+ * If bt_device_cancel_bonding() is called and it returns #BT_ERROR_NONE, then this callback function will be called
+ * with #BT_ERROR_CANCELLED result. \n
+ * If creating a bond succeeds but service search fails, then this callback will be called with #BT_ERROR_SERVICE_SEARCH_FAILED.
+ * In this case, you should try service search again by bt_device_start_service_search() to get the supported service list.
+ *
+ * @param[in] result The result of the bonding device
+ * @param[in] device_info The device information which you creates bond with
+ * @param[in] user_data The user data passed from the callback registration function
+ *
+ * @pre Either bt_device_create_bond() will invoke this function
+ * if you register this callback using bt_device_set_bond_created_cb().
+ *
+ * @see bt_device_create_bond()
+ * @see bt_device_cancel_bonding()
+ * @see bt_device_set_bond_created_cb()
+ * @see bt_device_unset_bond_created_cb()
+ */
+typedef void (*bt_device_bond_created_cb)(int result, bt_device_info_s *device_info, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
+ * @brief  Called when you get connected profiles repeatedly.
+ * @since_tizen 2.3
+ *
+ * @param[in] profile The connected Bluetooth profile
+ * @param[in] user_data The user data passed from the foreach function
+ * @return @c true to continue with the next iteration of the loop,
+ * \n @c false to break out of the loop.
+ * @pre bt_device_foreach_connected_profiles() will invoke this function.
+ * @see bt_device_foreach_connected_profiles()
+ */
+typedef bool (*bt_device_connected_profile)(bt_profile_e profile, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
+ * @brief  Called when the bond destroys.
+ * @since_tizen 2.3
+ *
+ * @param[in] result The result that a bond is destroyed
+ * @param[in] remote_address The address of the remote Bluetooth device to destroy bond with
+ * @param[in] user_data The user data passed from the callback registration function
+ * @pre bt_device_destroy_bond() will invoke this function
+ * if you register this callback using bt_device_set_bond_destroyed_cb().
+ *
+ * @see bt_device_destroy_bond()
+ * @see bt_device_set_bond_destroyed_cb()
+ * @see bt_device_unset_bond_destroyed_cb()
+ */
+typedef void (*bt_device_bond_destroyed_cb)(int result, char *remote_address, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
+ * @brief  Called when the authorization of device changes.
+ * @since_tizen 2.3
+ *
+ * @param[in] authorization The authorization of device
+ * @param[in] remote_address The address of the remote Bluetooth device which is (un)authorized
+ * @param[in] user_data The user data passed from the callback registration function
+ * @pre bt_device_set_authorization() will invoke this function if you register this callback using bt_device_set_authorization_changed_cb().
+ *
+ * @see bt_device_set_authorization()
+ * @see #bt_device_set_authorization_changed_cb()
+ * @see #bt_device_unset_authorization_changed_cb()
+ */
+typedef void (*bt_device_authorization_changed_cb)
+	(bt_device_authorization_e authorization, char *remote_address, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
+ * @brief
+ * @since_tizen 2.3
+ *
+ * @remark
+ *
+ * @param[in] result The result of the service searching
+ * @param[in] sdp_info The structure of service lists found on a device
+ * @param[in] user_data The user data passed from the callback registration function
+ * @pre Either bt_device_start_service_search() will invoke this function
+ * if you register this callback using  bt_device_set_service_searched_cb().
+ *
+ * @see bt_device_start_service_search()
+ * @see bt_device_set_service_searched_cb()
+ * @see bt_device_unset_service_searched_cb()
+ *
+ */
+typedef void (*bt_device_service_searched_cb)(int result, bt_device_sdp_info_s *sdp_info, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
+ * @brief  Called when the connection state is changed.
+ * @since_tizen 2.3
+ *
+ * @param[in] connected The connection status: (@c true = connected, @c false = disconnected)
+ * @param[in] conn_info The connection information
+ * @param[in] user_data The user data passed from the callback registration function
+ * @see bt_device_set_connection_state_changed_cb()
+ * @see bt_device_unset_connection_state_changed_cb()
+ */
+typedef void (*bt_device_connection_state_changed_cb)(bool connected, bt_device_connection_info_s *conn_info, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE
+ * @brief Called when you receive data.
+ * @since_tizen 2.3
+ *
+ * @param[in] data The received data from the remote device
+ * @param[in] user_data The user data passed from the callback registration function
+ *
+ * @pre When the connected remote Bluetooth device invokes bt_socket_send_data(),
+ *		this function will be invoked if you register this function using bt_socket_set_data_received_cb().
+ *
+ * @see bt_socket_set_data_received_cb()
+ * @see bt_socket_unset_data_received_cb()
+ * @see bt_socket_send_data()
+ */
+typedef void (*bt_socket_data_received_cb)(bt_socket_received_data_s *data, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE
+ * @brief  Called when the socket connection state changes.
+ * @since_tizen 2.3
+ *
+ * @param[in] result The result of connection state changing
+ * @param[in] connection_state The connection state
+ * @param[in] connection The connection information which is established or disconnected
+ * @param[in] user_data The user data passed from the callback registration function
+ * @pre Either bt_socket_connect_rfcomm() will invoke this function.
+ * In addtion, bt_socket_connection_state_changed_cb() will be invoked when the socket connection state is changed.
+ * @see bt_socket_listen_and_accept_rfcomm()
+ * @see bt_socket_connect_rfcomm()
+ * @see bt_socket_set_connection_state_changed_cb()
+ * @see bt_socket_unset_connection_state_changed_cb()
+ */
+typedef void (*bt_socket_connection_state_changed_cb)
+	(int result, bt_socket_connection_state_e connection_state, bt_socket_connection_s *connection, void *user_data);
+
+/**
+ * @internal
+ * @ingroup CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE
+ * @brief  Called when a RFCOMM connection is requested.
+ * @since_tizen 2.3
+ *
+ * @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);
+
+/**
+ * @internal
+ * @ingroup CAPI_NETWORK_BLUETOOTH_OPP_SERVER_MODULE
+ * @brief  Called when the push is requested.
+ * @since_tizen 2.3
+ *
+ * @details You must call bt_opp_server_accept() if you want to accept.
+ * Otherwise, you must call bt_opp_server_reject().
+ * @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.
+ * @since_tizen 2.3
+ *
+ * @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_accept()
+ * @see bt_opp_server_reject()
+ */
+typedef void (*bt_opp_server_connection_requested_cb)(const char *remote_address, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_OPP_SERVER_MODULE
+ * @brief  Called when a file is being transfered.
+ * @since_tizen 2.3
+ *
+ * @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()
+ * @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.
+ * @since_tizen 2.3
+ *
+ * @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()
+ * @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_CLIENT_MODULE
+ * @brief  Called when OPP server responds to the push request.
+ * @since_tizen 2.3
+ *
+ * @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.
+ * @since_tizen 2.3
+ *
+ * @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.
+ * @since_tizen 2.3
+ *
+ * @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_AUDIO_MODULE
+ * @brief  Called when the connection state is changed.
+ * @since_tizen 2.3
+ *
+ * @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_AG_MODULE
+ * @brief  Called when the SCO(Synchronous Connection Oriented link) state is changed.
+ * @since_tizen 2.3
+ *
+ * @details  This callback is called when the SCO state is changed.
+ * When you call bt_ag_open_sco() or bt_ag_close_sco(), this callback is also called with error result even though these functions failed.
+ * @param[in] result  The result of changing the connection state
+ * @param[in] opened  The state to be changed: (@c true = opened, @c  false = not opened)
+ * @param[in] user_data The user data passed from the callback registration function
+ * @see bt_ag_set_sco_state_changed_cb()
+ * @see bt_ag_unset_sco_state_changed_cb()
+ * @see bt_ag_open_sco()
+ * @see bt_ag_close_sco()
+ */
+typedef void (*bt_ag_sco_state_changed_cb) (int result, bool opened, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
+ * @brief  Called when a call handling event happened from Hands-Free.
+ * @since_tizen 2.3
+ *
+ * @param[in] event  The call handling event happened from Hands-Free
+ * @param[in] call_id  The call ID
+ * @param[in] user_data The user data passed from the callback registration function
+ * @see bt_ag_set_call_handling_event_cb()
+ * @see bt_ag_unset_call_handling_event_cb()
+ */
+typedef void (*bt_ag_call_handling_event_cb) (bt_ag_call_handling_event_e event, unsigned int call_id, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
+ * @brief  Called when a multi call handling event happened from Hands-Free.
+ * @since_tizen 2.3
+ *
+ * @param[in] event  The call handling event happened from Hands-Free
+ * @param[in] user_data The user data passed from the callback registration function
+ * @see bt_ag_set_multi_call_handling_event_cb()
+ * @see bt_ag_unset_multi_call_handling_event_cb()
+ */
+typedef void (*bt_ag_multi_call_handling_event_cb) (bt_ag_multi_call_handling_event_e event, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
+ * @brief  Called when a DTMF(Dual Tone Multi Frequency) is transmitted from Hands-Free.
+ * @since_tizen 2.3
+ *
+ * @param[in] dtmf  The DTMF transmitted from Hands-Free
+ * @param[in] user_data The user data passed from the callback registration function
+ * @see bt_ag_set_dtmf_transmitted_cb()
+ * @see bt_ag_unset_dtmf_transmitted_cb()
+ */
+typedef void (*bt_ag_dtmf_transmitted_cb) (const char *dtmf, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
+ * @brief  Called when the speaker gain of the remote device is changed.
+ * @since_tizen 2.3
+ *
+ * @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) (int gain, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
+ * @brief  Called when the microphone gain of the remote device is changed.
+ * @since_tizen 2.3
+ *
+ * @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) (int gain, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE
+ * @brief  Called when the connection state is changed.
+ * @since_tizen 2.3
+ *
+ * @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  Called when the equalizer state is changed by the remote control device.
+ * @since_tizen 2.3
+ *
+ * @param[in] equalizer The equalizer state
+ * @param[in] user_data The user data passed from the callback registration function
+ * @see bt_avrcp_set_equalizer_state_changed_cb()
+ * @see bt_avrcp_unset_equalizer_state_changed_cb()
+ */
+typedef void (*bt_avrcp_equalizer_state_changed_cb) (bt_avrcp_equalizer_state_e equalizer, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE
+ * @brief  Called when the repeat mode is changed by the remote control device.
+ * @since_tizen 2.3
+ *
+ * @param[in] repeat The repeat mode
+ * @param[in] user_data The user data passed from the callback registration function
+ * @see bt_avrcp_set_repeat_mode_changed_cb()
+ * @see bt_avrcp_unset_repeat_mode_changed_cb()
+ */
+typedef void (*bt_avrcp_repeat_mode_changed_cb) (bt_avrcp_repeat_mode_e repeat, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE
+ * @brief  Called when the shuffle mode is changed by the remote control device.
+ * @since_tizen 2.3
+ *
+ * @param[in] shuffle The shuffle mode
+ * @param[in] user_data The user data passed from the callback registration function
+ * @see bt_avrcp_set_shuffle_mode_changed_cb()
+ * @see bt_avrcp_unset_shuffle_mode_changed_cb()
+ */
+typedef void (*bt_avrcp_shuffle_mode_changed_cb) (bt_avrcp_shuffle_mode_e shuffle, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE
+ * @brief  Called when the scan mode is changed by the remote control device.
+ * @since_tizen 2.3
+ *
+ * @param[in] shuffle The shuffle mode
+ * @param[in] user_data The user data passed from the callback registration function
+ * @see bt_avrcp_set_scan_mode_changed_cb()
+ * @see bt_avrcp_unset_scan_mode_changed_cb()
+ */
+typedef void (*bt_avrcp_scan_mode_changed_cb) (bt_avrcp_scan_mode_e scan, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_HID_MODULE
+ * @brief  Called when the connection state is changed.
+ * @since_tizen 2.3
+ *
+ * @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_HDP_MODULE
+ * @brief  Called when the connection is established.
+ * @since_tizen 2.3
+ *
+ * @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.
+ * @since_tizen 2.3
+ *
+ * @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  Called when the you receive the data.
+ * @since_tizen 2.3
+ *
+ * @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_GATT_MODULE
+ * @brief  Called when you get the primary services repeatedly.
+ * @since_tizen 2.3
+ *
+ * @param[in]  service  The attribute handle of service
+ * @param[in]  user_data  The user data passed from the foreach function
+ * @return  @c true to continue with the next iteration of the loop,
+ * \n @c false to break out of the loop.
+ * @pre  bt_gatt_foreach_primary_services() will invoke this function.
+ * @see  bt_gatt_foreach_primary_services()
+ */
+typedef bool (*bt_gatt_primary_service_cb) (bt_gatt_attribute_h service, void *user_data);
+
+/**
+ * @ingroup  CAPI_NETWORK_BLUETOOTH_GATT_MODULE
+ * @brief  Called after the characteristics are discovered by bt_gatt_discover_characteristics().
+ * @since_tizen 2.3
+ *
+ * @remarks  If bt_gatt_discover_characteristics() failed, then this callback function is called only once with 0 totla and NULL characteristic_handle.
+ * @param[in]  result  The result of discovering
+ * @param[in]  index  The index of characteristics in a service, starts from 0
+ * @param[in]  total  The total number of characteristics in a service
+ * @param[in]  characteristic  The attribute handle of characteristic
+ * @param[in]  user_data  The user data passed from the request function
+ * @return  @c true to continue with the next iteration of the loop,
+ * \n @c false to break out of the loop.
+ * @pre  bt_gatt_discover_characteristics() will invoke this callback.
+ * @see  bt_gatt_discover_characteristics()
+ */
+typedef bool (*bt_gatt_characteristics_discovered_cb) (int result, int index, int total, bt_gatt_attribute_h characteristic, void *user_data);
+
+/**
+ * @ingroup  CAPI_NETWORK_BLUETOOTH_GATT_MODULE
+ * @brief  Called when you get the included services repeatedly.
+ * @since_tizen 2.3
+ *
+ * @param[in]  service  The attribute handle of service
+ * @param[in]  user_data  The user data passed from the foreach function
+ * @return  @c true to continue with the next iteration of the loop,
+ * \n @c false to break out of the loop.
+ * @pre  bt_gatt_foreach_included_services() will invoke this function.
+ * @see  bt_gatt_foreach_included_services()
+ */
+typedef bool (*bt_gatt_included_service_cb) (bt_gatt_attribute_h service, void *user_data);
+
+/**
+ * @ingroup  CAPI_NETWORK_BLUETOOTH_GATT_MODULE
+ * @brief  Called when a characteristic in service is changed.
+ * @since_tizen 2.3
+ *
+ * @param[in]  characteristic  The attribute handle of characteristic
+ * @param[in]  value  The value of characteristic (byte array)
+ * @param[in]  value_length  The length of value
+ * @param[in]  user_data  The user data passed from the callback registration function
+ * @see bt_gatt_set_characteristic_changed_cb()
+ * @see bt_gatt_unset_characteristic_changed_cb()
+ */
+typedef void (*bt_gatt_characteristic_changed_cb) (bt_gatt_attribute_h characteristic, unsigned char *value, int value_length, void *user_data);
+
+/**
+ * @ingroup  CAPI_NETWORK_BLUETOOTH_GATT_MODULE
+ * @brief  Called when a characteristic value is written.
+ * @since_tizen 2.3
+ *
+ * @see bt_gatt_set_characteristic_value()
+ */
+typedef void (*bt_gatt_characteristic_write_cb) (void *user_data);
+
+/**
+ * @ingroup  CAPI_NETWORK_BLUETOOTH_GATT_MODULE
+ * @brief  Called when a characteristic value is read.
+ * @since_tizen 2.3
+ *
+ * @param[in]  value  The value of characteristic (byte array)
+ * @param[in]  value_length  The length of value
+ * @param[in]  user_data  The user data passed from the foreach function
+ * @see bt_gatt_read_characteristic_value()
+ */
+typedef void (*bt_gatt_characteristic_read_cb) (unsigned char *value,
+			int value_length, void *user_data);
+
+/**
+ * @ingroup  CAPI_NETWORK_BLUETOOTH_GATT_MODULE
+ * @brief  Called after the characteristics descriptors are discovered by bt_gatt_discover_characteristic_descriptor().
+ * @since_tizen 2.3
+ *
+ * @param[in]  result  The result of discovering
+ * @param[in]  characteristic_format  The format of the information data.
+ *                        characteristic_format = 0x01 indicates UUIDs are 16-bits
+ *                        characteristic_format = 0x02 indicates UUIDs are 128-bits
+ * @param[in]  total  The total number of elements in characteristic_descriptor
+ * @param[in]  characteristic descriptor  The attribute handle and the UUID of characteristic descriptor
+ * @param[in]  user_data  The user data passed from the request function
+ * @see  bt_gatt_discover_characteristic_descriptor()
+ */
+typedef void (*bt_gatt_characteristic_descriptor_discovered_cb) (int result,
+		unsigned char characteristic_format, int total,
+		bt_gatt_attribute_h characteristic_descriptor, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_GATT_MODULE
+ * @brief Called when the connection state is changed.
+ * @since_tizen 2.3
+ *
+ * @details This callback is called when the connection state is changed.
+ * When you called bt_gatt_connect() or bt_gatt_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_gatt_connect()
+ * @see bt_gatt_disconnect()
+ * @see bt_gatt_set_connection_state_changed_cb()
+ * @see bt_gatt_unset_connection_state_changed_cb()
+ */
+typedef void (*bt_gatt_connection_state_changed_cb)(int result, bool connected, const char *remote_address, void *user_data);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_PAN_NAP_MODULE
+ * @brief  Called when the connection state is changed.
+ * @since_tizen 2.3
+ *
+ * @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_PANU_MODULE
+ * @brief  Called when the connection state is changed.
+ * @since_tizen 2.3
+ *
+ * @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);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif // __TIZEN_NETWORK_BLUETOOTH_TYPE_H__
diff --git a/mobile/CMakeLists.txt b/mobile/CMakeLists.txt
deleted file mode 100644
index 6ac39eb..0000000
--- a/mobile/CMakeLists.txt
+++ /dev/null
@@ -1,110 +0,0 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
-SET(fw_name "capi-network-bluetooth")
-
-PROJECT(${fw_name})
-
-SET(CMAKE_INSTALL_PREFIX /usr)
-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(pc_dependents "capi-base-common")
-
-INCLUDE(FindPkgConfig)
-pkg_check_modules(${fw_name} REQUIRED ${dependents})
-FOREACH(flag ${${fw_name}_CFLAGS})
-    SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}")
-ENDFOREACH(flag)
-
-SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS} -fPIC -Wall -Werror")
-SET(CMAKE_C_FLAGS_DEBUG "-O0 -g")
-
-IF("${ARCH}" STREQUAL "arm")
-    ADD_DEFINITIONS("-DTARGET")
-ENDIF("${ARCH}" STREQUAL "arm")
-
-ADD_DEFINITIONS("-DPREFIX=\"${CMAKE_INSTALL_PREFIX}\"")
-ADD_DEFINITIONS("-DTIZEN_DEBUG")
-
-SET(CMAKE_EXE_LINKER_FLAGS "-Wl,--as-needed -Wl,--rpath=${LIB_INSTALL_DIR}")
-
-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
-src/bluetooth-gatt.c
-)
-
-ADD_LIBRARY(${fw_name} SHARED ${SOURCES})
-
-TARGET_LINK_LIBRARIES(${fw_name} ${${fw_name}_LDFLAGS})
-
-SET_TARGET_PROPERTIES(${fw_name}
-     PROPERTIES
-     VERSION ${FULLVER}
-     SOVERSION ${MAJORVER}
-     CLEAN_DIRECT_OUTPUT 1
-)
-
-INSTALL(TARGETS ${fw_name} DESTINATION ${LIB_INSTALL_DIR})
-INSTALL(
-        DIRECTORY ${INC_DIR}/ DESTINATION include/network
-        FILES_MATCHING
-        PATTERN "*_private.h" EXCLUDE
-        PATTERN "${INC_DIR}/*.h"
-        )
-
-SET(PC_NAME ${fw_name})
-SET(PC_REQUIRED ${pc_dependents})
-SET(PC_LDFLAGS -l${fw_name})
-
-CONFIGURE_FILE(
-    capi-network-bluetooth.pc.in
-    ${CMAKE_CURRENT_SOURCE_DIR}/${fw_name}.pc
-    @ONLY
-)
-INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/${fw_name}.pc DESTINATION ${LIB_INSTALL_DIR}/pkgconfig)
-
-ADD_SUBDIRECTORY(test)
-
-IF(UNIX)
-
-ADD_CUSTOM_TARGET (distclean @echo cleaning for source distribution)
-ADD_CUSTOM_COMMAND(
-        DEPENDS clean 
-        COMMENT "distribution clean"
-        COMMAND find
-        ARGS    . 
-        -not -name config.cmake -and \(
-        -name tester.c -or
-        -name Testing -or
-        -name CMakeFiles -or
-        -name cmake.depends -or
-        -name cmake.check_depends -or
-        -name CMakeCache.txt -or
-        -name cmake.check_cache -or
-        -name *.cmake -or
-        -name Makefile -or
-        -name core -or
-        -name core.* -or
-        -name gmon.out -or
-        -name install_manifest.txt -or
-        -name *.pc -or
-        -name *~ \)
-        | grep -v TC | xargs rm -rf
-        TARGET  distclean
-        VERBATIM
-)
-
-ENDIF(UNIX)
-
diff --git a/mobile/LICENSE.APLv2 b/mobile/LICENSE.APLv2
deleted file mode 100644
index 6b0b127..0000000
--- a/mobile/LICENSE.APLv2
+++ /dev/null
@@ -1,203 +0,0 @@
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   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.
-
diff --git a/mobile/NOTICE b/mobile/NOTICE
deleted file mode 100644
index 0e0f016..0000000
--- a/mobile/NOTICE
+++ /dev/null
@@ -1,3 +0,0 @@
-Copyright (c) Samsung Electronics Co., Ltd. All rights reserved.
-Except as noted, this software is licensed under Apache License, Version 2.
-Please, see the LICENSE.APLv2 file for Apache License terms and conditions.
diff --git a/mobile/TC/config b/mobile/TC/config
deleted file mode 100644
index f919537..0000000
--- a/mobile/TC/config
+++ /dev/null
@@ -1,2 +0,0 @@
-TET_INSTALL_HOST_PATH=/home/bwlee/tools/TETware
-TET_INSTALL_TARGET_PATH=/home/bwlee/tools/TETware
diff --git a/mobile/TC/testcase/utc_network_bluetooth_adapter_negative.c b/mobile/TC/testcase/utc_network_bluetooth_adapter_negative.c
deleted file mode 100644
index 06fdea7..0000000
--- a/mobile/TC/testcase/utc_network_bluetooth_adapter_negative.c
+++ /dev/null
@@ -1,288 +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 <tet_api.h>
-#include <bluetooth.h>
-#include <stdlib.h>
-#include <stdbool.h>
-#include <glib.h>
-#include <time.h>
-
-enum {
-	POSITIVE_TC_IDX = 0x01,
-	NEGATIVE_TC_IDX,
-};
-
-static void startup(void);
-static void cleanup(void);
-bt_adapter_visibility_mode_e adapter_visibility_mode = BT_ADAPTER_VISIBILITY_MODE_LIMITED_DISCOVERABLE;
-char adapter_name[128] = "dts_test";
-
-void (*tet_startup) (void) = startup;
-void (*tet_cleanup) (void) = cleanup;
-
-static void utc_network_bluetooth_deinitialize_n(void);
-static void utc_network_bluetooth_adapter_set_state_changed_cb_n(void);
-static void utc_network_bluetooth_adapter_set_name_changed_cb_n(void);
-static void utc_network_bluetooth_adapter_set_visibility_mode_changed_cb_n(void);
-static void utc_network_bluetooth_adapter_enable_n(void);
-static void utc_network_bluetooth_adapter_get_state_n(void);
-static void utc_network_bluetooth_adapter_get_address_n(void);
-static void utc_network_bluetooth_adapter_set_name_n(void);
-static void utc_network_bluetooth_adapter_get_name_n(void);
-static void utc_network_bluetooth_adapter_set_visibility_n(void);
-static void utc_network_bluetooth_adapter_get_visibility_n(void);
-static void utc_network_bluetooth_adapter_disable_n(void);
-static void utc_network_bluetooth_adapter_unset_state_changed_cb_n(void);
-static void utc_network_bluetooth_adapter_unset_name_changed_cb_n(void);
-static void utc_network_bluetooth_adapter_unset_visibility_mode_changed_cb_n(void);
-
-void adapter_state_changed_cb_for_adapter_n(int result,
-					    bt_adapter_state_e adapter_state,
-					    void *user_data);
-void adapter_state_changed_cb_for_adapter_n(int result,
-					    bt_adapter_state_e adapter_state,
-					    void *user_data);
-void adapter_name_changed_cb_for_adapter_n(char *device_name, void *user_data);
-void adapter_visibility_mode_changed_cb_for_adpater_n(int result,
-						      bt_adapter_visibility_mode_e visibility_mode,
-						      void *user_data);
-void device_discovery_state_changed_cb_for_adapter_n(int result,
-						     bt_adapter_device_discovery_state_e discovery_state,
-						     bt_device_info_s *device_info,
-						     void *user_data);
-gboolean timeout_func(gpointer data);
-
-struct tet_testlist tet_testlist[] = {
-	{utc_network_bluetooth_adapter_disable_n, NEGATIVE_TC_IDX},
-	{utc_network_bluetooth_adapter_set_state_changed_cb_n, NEGATIVE_TC_IDX},
-	{utc_network_bluetooth_adapter_set_name_changed_cb_n, NEGATIVE_TC_IDX},
-	{utc_network_bluetooth_adapter_set_visibility_mode_changed_cb_n, NEGATIVE_TC_IDX},
-	{utc_network_bluetooth_adapter_get_state_n, NEGATIVE_TC_IDX},
-	{utc_network_bluetooth_adapter_get_address_n, NEGATIVE_TC_IDX},
-	{utc_network_bluetooth_adapter_set_name_n, NEGATIVE_TC_IDX},
-	{utc_network_bluetooth_adapter_get_name_n, NEGATIVE_TC_IDX},
-	{utc_network_bluetooth_adapter_get_visibility_n, NEGATIVE_TC_IDX},
-	{utc_network_bluetooth_adapter_set_visibility_n, NEGATIVE_TC_IDX},
-	{utc_network_bluetooth_deinitialize_n, NEGATIVE_TC_IDX},
-	{utc_network_bluetooth_adapter_enable_n, NEGATIVE_TC_IDX},
-	{utc_network_bluetooth_adapter_unset_state_changed_cb_n, NEGATIVE_TC_IDX},
-	{utc_network_bluetooth_adapter_unset_name_changed_cb_n, NEGATIVE_TC_IDX},
-	{utc_network_bluetooth_adapter_unset_visibility_mode_changed_cb_n, NEGATIVE_TC_IDX},
-	{NULL, 0},
-};
-
-static void startup(void)
-{
-	/* start of TC */
-	tet_printf("TC start.");
-	bt_initialize();
-}
-
-static void cleanup(void)
-{
-	/* end of TC */
-	tet_printf("TC end");
-}
-
-/**
- * @brief Negative test case of bt_deinitialize()
- */
-static void utc_network_bluetooth_deinitialize_n(void)
-{
-	int ret = bt_deinitialize();
-
-	if (ret == BT_ERROR_NONE) {
-		ret = bt_deinitialize();
-		dts_check_eq("bt_deinitialize", ret, BT_ERROR_NOT_INITIALIZED,
-			     "BT_ERROR_NOT_INITIALIZED must be returned.");
-	} else {
-		dts_fail("bt_deinitialize", "bt_deinitialize() failed.");
-	}
-}
-
-/**
- * @brief Negative test case of bt_adapter_disable()
- */
-static void utc_network_bluetooth_adapter_disable_n(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_adapter_disable();
-	dts_check_eq("bt_adapter_disable", ret, BT_ERROR_NOT_ENABLED,
-		     "BT_ERROR_NOT_ENABLED must be returned when BT is disabled");
-}
-
-/**
- * @brief Negative test case of bt_adapter_set_state_changed_cb()
- */
-static void utc_network_bluetooth_adapter_set_state_changed_cb_n(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_adapter_set_state_changed_cb(NULL, NULL);
-	dts_check_eq("bt_adapter_set_state_changed_cb", ret,
-		     BT_ERROR_INVALID_PARAMETER,
-		     "BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL.");
-}
-
-/**
- * @brief Negative test case of bt_adapter_set_name_changed_cb()
- */
-static void utc_network_bluetooth_adapter_set_name_changed_cb_n(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_adapter_set_name_changed_cb(NULL, NULL);
-	dts_check_eq("bt_adapter_set_name_changed_cb", ret,
-		     BT_ERROR_INVALID_PARAMETER,
-		     "BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL.");
-}
-
-/**
- * @brief Negative test case of bt_adapter_set_visibility_mode_changed_cb()
- */
-static void utc_network_bluetooth_adapter_set_visibility_mode_changed_cb_n(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_adapter_set_visibility_mode_changed_cb(NULL, NULL);
-	dts_check_eq("bt_adapter_set_visibility_mode_changed_cb", ret,
-		     BT_ERROR_INVALID_PARAMETER,
-		     "BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL.");
-}
-
-/**
- * @brief Negative test case of bt_adapter_get_state()
- */
-static void utc_network_bluetooth_adapter_get_state_n(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_adapter_get_state(NULL);
-	dts_check_eq("bt_adapter_get_state", ret, BT_ERROR_INVALID_PARAMETER,
-		     "BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL.");
-}
-
-/**
- * @brief Negative test case of bt_adapter_get_address().
- */
-static void utc_network_bluetooth_adapter_get_address_n(void)
-{
-	char *address = NULL;
-	int ret = bt_adapter_get_address(&address);
-
-	dts_check_eq("bt_adapter_get_address", ret, BT_ERROR_NOT_ENABLED,
-		     "BT_ERROR_NOT_ENABLED must be returned when BT is not enabled.");
-}
-
-/**
- * @brief Negative test case of bt_adapter_get_name().
- */
-static void utc_network_bluetooth_adapter_get_name_n(void)
-{
-	char *name = NULL;
-	int ret = bt_adapter_get_name(&name);
-
-	dts_check_eq("bt_adapter_get_name", ret, BT_ERROR_NOT_ENABLED,
-		     "BT_ERROR_NOT_ENABLED must be returned when BT is not enabled.");
-}
-
-/**
- * @brief Negative test case of bt_adapter_get_visibility().
- */
-static void utc_network_bluetooth_adapter_get_visibility_n(void)
-{
-	bt_adapter_visibility_mode_e mode =
-	    BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE;
-	int dur = 10;
-	int ret = bt_adapter_get_visibility(&mode, &dur);
-
-	dts_check_eq("bt_adapter_get_visibility", ret, BT_ERROR_NOT_ENABLED,
-		     "BT_ERROR_NOT_ENABLED must be returned when BT is not enabled.");
-}
-
-/**
- * @brief Negative test case of bt_adapter_set_name().
- */
-static void utc_network_bluetooth_adapter_set_name_n(void)
-{
-	int ret = bt_adapter_set_name(adapter_name);
-
-	dts_check_eq("bt_adapter_set_name", ret, BT_ERROR_NOT_ENABLED,
-		     "BT_ERROR_NOT_ENABLED must be returned when BT is not enabled.");
-}
-
-/**
- * @brief Negative test case of bt_adapter_set_visibility().
- */
-static void utc_network_bluetooth_adapter_set_visibility_n(void)
-{
-	int ret = bt_adapter_set_visibility(adapter_visibility_mode, 180);
-
-	dts_check_eq("bt_adapter_set_visibility", ret, BT_ERROR_NOT_ENABLED,
-		     "BT_ERROR_NOT_ENABLED must be returned when BT is not enabled.");
-}
-
-/**
- * @brief Negative test case of bt_adapter_unset_state_changed_cb()
- */
-static void utc_network_bluetooth_adapter_unset_state_changed_cb_n(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_adapter_unset_state_changed_cb();
-	dts_check_eq("bt_adapter_unset_state_changed_cb", ret,
-		     BT_ERROR_NOT_INITIALIZED,
-		     "BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized.");
-}
-
-/**
- * @brief Negative test case of bt_adapter_unset_name_changed_cb()
- */
-static void utc_network_bluetooth_adapter_unset_name_changed_cb_n(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_adapter_unset_name_changed_cb();
-	dts_check_eq("bt_adapter_unset_name_changed_cb", ret,
-		     BT_ERROR_NOT_INITIALIZED,
-		     "BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized.");
-}
-
-/**
- * @brief Negative test case of bt_adapter_unset_visibility_mode_changed_cb()
- */
-static void
-utc_network_bluetooth_adapter_unset_visibility_mode_changed_cb_n(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_adapter_unset_visibility_mode_changed_cb();
-	dts_check_eq("bt_adapter_unset_visibility_mode_changed_cb", ret,
-		     BT_ERROR_NOT_INITIALIZED,
-		     "BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized.");
-}
-
-/**
- * @brief Negative test case of bt_adapter_enable()
- */
-static void utc_network_bluetooth_adapter_enable_n(void)
-{
-	bt_error_e ret = bt_adapter_enable();
-	dts_check_eq("bt_adapter_enable", ret, BT_ERROR_NOT_INITIALIZED,
-		     "BT_ERROR_NOT_INITIALIZED must be returned.");
-}
diff --git a/mobile/capi-network-bluetooth.pc.in b/mobile/capi-network-bluetooth.pc.in
deleted file mode 100644
index 85a129a..0000000
--- a/mobile/capi-network-bluetooth.pc.in
+++ /dev/null
@@ -1,14 +0,0 @@
-# Package Information for pkg-config
-
-prefix=@PREFIX@
-exec_prefix=/usr
-libdir=@LIB_INSTALL_DIR@
-includedir=@INCLUDE_INSTALL_DIR@/network
-
-Name: @PC_NAME@
-Description: @PACKAGE_DESCRIPTION@
-Version: @VERSION@
-Requires: @PC_REQUIRED@ 
-Libs: -L${libdir} @PC_LDFLAGS@
-Cflags: -I${includedir}
-
diff --git a/mobile/debian/README b/mobile/debian/README
deleted file mode 100644
index e69de29..0000000
--- a/mobile/debian/README
+++ /dev/null
diff --git a/mobile/debian/capi-network-bluetooth-dev.install b/mobile/debian/capi-network-bluetooth-dev.install
deleted file mode 100644
index 761a28b..0000000
--- a/mobile/debian/capi-network-bluetooth-dev.install
+++ /dev/null
@@ -1,4 +0,0 @@
-/usr/include/*
-/usr/include/*/*
-/usr/lib/pkgconfig/*.pc
-
diff --git a/mobile/debian/capi-network-bluetooth-dev.postinst b/mobile/debian/capi-network-bluetooth-dev.postinst
deleted file mode 100644
index 1a24852..0000000
--- a/mobile/debian/capi-network-bluetooth-dev.postinst
+++ /dev/null
@@ -1 +0,0 @@
-#!/bin/sh
diff --git a/mobile/debian/capi-network-bluetooth.install b/mobile/debian/capi-network-bluetooth.install
deleted file mode 100644
index 4a755a4..0000000
--- a/mobile/debian/capi-network-bluetooth.install
+++ /dev/null
@@ -1 +0,0 @@
-/usr/lib/lib*.so*
diff --git a/mobile/debian/capi-network-bluetooth.postinst b/mobile/debian/capi-network-bluetooth.postinst
deleted file mode 100644
index 1a24852..0000000
--- a/mobile/debian/capi-network-bluetooth.postinst
+++ /dev/null
@@ -1 +0,0 @@
-#!/bin/sh
diff --git a/mobile/debian/changelog b/mobile/debian/changelog
deleted file mode 100644
index 62c177c..0000000
--- a/mobile/debian/changelog
+++ /dev/null
@@ -1,464 +0,0 @@
-capi-network-bluetooth (0.1.36-1) unstable; urgency=low
-
-  * Implement AVRCP callback functions
-  * Git: magnolia/framework/api/bluetooth
-  * Tag: capi-network-bluetooth_0.1.36-1
-
- -- DoHyun Pyun <dh79.pyun@samsung.com>  Wed, 28 Nov 2012 10:45:13 +0900
-
-capi-network-bluetooth (0.1.35-1) unstable; urgency=low
-
-  * Add GATT api for BTLE support
-  * Git: magnolia/framework/api/bluetooth
-  * Tag: capi-network-bluetooth_0.1.35-1
-
- -- Chethan T N <chethan.tn@samsung.com>  Fri, 23 Nov 2012 19:15:01 +0900
-
-capi-network-bluetooth (0.1.34-1) unstable; urgency=low
-
-  * Correct the spelling
-  * Git: magnolia/framework/api/bluetooth
-  * Tag: capi-network-bluetooth_0.1.34-1
-
- -- DoHyun Pyun <dh79.pyun@samsung.com>  Wed, 14 Nov 2012 17:16:04 +0900
-
-capi-network-bluetooth (0.1.33-1) unstable; urgency=low
-
-  * Implement bt_ag_is_nrec_enabled API
-  * Git: magnolia/framework/api/bluetooth
-  * Tag: capi-network-bluetooth_0.1.33-1
-
- -- DoHyun Pyun <dh79.pyun@samsung.com>  Wed, 14 Nov 2012 11:33:49 +0900
-
-capi-network-bluetooth (0.1.32-1) unstable; urgency=low
-
-  * Add the duration parameter in bt_adapter_get_visibility
-  * Git: magnolia/framework/api/bluetooth
-  * Tag: capi-network-bluetooth_0.1.32-1
-
- -- DoHyun Pyun <dh79.pyun@samsung.com>  Wed, 07 Nov 2012 17:30:49 +0900
-
-capi-network-bluetooth (0.1.31-1) unstable; urgency=low
-
-  * Update version number
-  * Git: magnolia/framework/api/bluetooth
-  * Tag: capi-network-bluetooth_0.1.31-1
-
- -- Jaekyun Lee <jkyun.lee@samsung.com>  Tue, 06 Nov 2012 17:28:40 +0900
-
-capi-network-bluetooth (0.1.30-1) unstable; urgency=low
-
-  * Implement bt_device_foreach_connected_profiles
-  * Git: slp/api/bluetooth
-  * Tag: capi-network-bluetooth_0.1.30-1
-
- -- DoHyun Pyun <dh79.pyun@samsung.com>  Tue, 06 Nov 2012 16:22:58 +0900
-
-capi-network-bluetooth (0.1.29-1) unstable; urgency=low
-
-  * Fix the build break
-  * Git: slp/api/bluetooth
-  * Tag: capi-network-bluetooth_0.1.29-1
-
- -- DoHyun Pyun <dh79.pyun@samsung.com>  Wed, 17 Oct 2012 14:24:53 +0900
-
-capi-network-bluetooth (0.1.28-1) unstable; urgency=low
-
-  * Add the device events
-  * Git: slp/api/bluetooth
-  * Tag: capi-network-bluetooth_0.1.28-1
-
- -- DoHyun Pyun <dh79.pyun@samsung.com>  Tue, 16 Oct 2012 11:17:10 +0900
-
-capi-network-bluetooth (0.1.27-1) unstable; urgency=low
-
-  * Add license file in each rpm
-  * Git: slp/api/bluetooth
-  * Tag: capi-network-bluetooth_0.1.27-1
-
- -- DoHyun Pyun <dh79.pyun@samsung.com>  Thu, 11 Oct 2012 16:08:24 +0900
-
-capi-network-bluetooth (0.1.26-1) unstable; urgency=low
-
-  * Assign the error code to result
-  * Git: slp/api/bluetooth
-  * Tag: capi-network-bluetooth_0.1.26-1
-
- -- DoHyun Pyun <dh79.pyun@samsung.com>  Wed, 26 Sep 2012 15:00:30 +0900
-
-capi-network-bluetooth (0.1.25-1) unstable; urgency=low
-
-  * Add the address parameter in network connected event
-  * Git: slp/api/bluetooth
-  * Tag: capi-network-bluetooth_0.1.25-1
-
- -- DoHyun Pyun <dh79.pyun@samsung.com>  Wed, 26 Sep 2012 13:09:45 +0900
-
-capi-network-bluetooth (0.1.24-1) unstable; urgency=low
-
-  * Tagging and upload the package
-  * Git: slp/api/bluetooth
-  * Tag: capi-network-bluetooth_0.1.24-1
-
- -- DoHyun Pyun <dh79.pyun@samsung.com>  Tue, 25 Sep 2012 15:11:44 +0900
-
-capi-network-bluetooth (0.1.23-1) unstable; urgency=low
-
-  * Tagging and upload the package
-  * Git: slp/api/bluetooth
-  * Tag: capi-network-bluetooth_0.1.23-1
-
- -- Sangki Park <sangki79.park@samsung.com>  Tue, 25 Sep 2012 10:48:46 +0900
-
-capi-network-bluetooth (0.1.22-1) unstable; urgency=low
-
-  * Apply smack manifest file
-  * slp/api/bluetooth
-  * Tag: capi-network-bluetooth_0.1.22-1
-
- -- Sangki Park <sangki79.park@samsung.com>  Fri, 21 Sep 2012 11:09:41 +0900
-
-capi-network-bluetooth (0.1.21-1) unstable; urgency=low
-
-  * Tagging and upload the package
-  * Git: slp/api/bluetooth
-  * Tag: capi-network-bluetooth_0.1.21-1
-
- -- DoHyun Pyun <dh79.pyun@samsung.com>  Tue, 18 Sep 2012 16:23:52 +0900
-
-capi-network-bluetooth (0.1.20-1) natty; urgency=low
-
-  * Tagging and upload the package
-  * Git: slp/api/bluetooth
-  * Tag: capi-network-bluetooth_0.1.20-1
-
- -- DoHyun Pyun <dh79.pyun@samsung.com>  Tue, 18 Sep 2012 13:52:44 +0900
-
-capi-network-bluetooth (0.1.19-1) unstable; urgency=low
-
-  * Tagging and upload the package
-  * Git: slp/api/bluetooth
-  * Tag: capi-network-bluetooth_0.1.19-1
-
- -- DoHyun Pyun <dh79.pyun@samsung.com>  Mon, 17 Sep 2012 15:31:29 +0900
-
-capi-network-bluetooth (0.1.17-1) unstable; urgency=low
-
-  * Tagging and upload the package
-  * Git: slp/api/bluetooth
-  * Tag: capi-network-bluetooth_0.1.17-1
-
- -- Sangki Park <sangki79.park@samsung.com>  Thu, 13 Sep 2012 12:47:12 +0900
-
-capi-network-bluetooth (0.1.16-1) unstable; urgency=low
-
-  * Tagging and upload the package
-  * Git: slp/api/bluetooth
-  * Tag: capi-network-bluetooth_0.1.16-1
-
- -- Sangki Park <sangki79.park@samsung.com>  Thu, 13 Sep 2012 11:03:33 +0900
-
-capi-network-bluetooth (0.1.15-1) unstable; urgency=low
-
-  * Tagging and upload the package
-  * Git: slp/api/bluetooth
-  * Tag: capi-network-bluetooth_0.1.15-1
-
- -- DoHyun Pyun <dh79.pyun@samsung.com>  Tue, 11 Sep 2012 16:08:53 +0900
-
-capi-network-bluetooth (0.1.14-1) unstable; urgency=low
-
-  * Tagging and upload the package
-  * Git: slp/api/bluetooth
-  * Tag: capi-network-bluetooth_0.1.14-1
-
- -- DoHyun Pyun <dh79.pyun@samsung.com>  Tue, 11 Sep 2012 09:56:47 +0900
-
-capi-network-bluetooth (0.1.13-1) unstable; urgency=low
-
-  * Tagging and upload the package
-  * Git: slp/api/bluetooth
-  * Tag: capi-network-bluetooth_0.1.13-1
-
- -- DoHyun Pyun <dh79.pyun@samsung.com>  Mon, 10 Sep 2012 12:56:50 +0900
-
-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: 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
-
-capi-network-bluetooth (0.1.1-1) unstable; urgency=low
-
-  * Fix the crash in DTS test
-  * 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
-
-capi-network-bluetooth (0.1.0-14) unstable; urgency=low
-
-  * Initialize the pointer to NULL after free
-  * 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
-
-capi-network-bluetooth (0.1.0-13) unstable; urgency=low
-
-  * Correct dependent package
-  * 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
-
-  * 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
-
-capi-network-bluetooth (0.1.0-11) unstable; urgency=low
-
-  * Add versioning of library
-  * 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
-
-  * Clean codes
-  * Git: slp/api/bluetooth
-  * Tag: capi-network-bluetooth_0.1.0-10
-
- -- ByungWoo Lee <bw1212.lee@samsung.com>  Thu, 02 Feb 2012 14:49:58 +0900
-
-capi-network-bluetooth (0.1.0-9) unstable; urgency=low
-
-  * 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>  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 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
-
diff --git a/mobile/debian/compat b/mobile/debian/compat
deleted file mode 100644
index 7ed6ff8..0000000
--- a/mobile/debian/compat
+++ /dev/null
@@ -1 +0,0 @@
-5
diff --git a/mobile/debian/control b/mobile/debian/control
deleted file mode 100644
index 7299ecb..0000000
--- a/mobile/debian/control
+++ /dev/null
@@ -1,21 +0,0 @@
-Source: capi-network-bluetooth
-Section: libs
-Priority: extra
-Maintainer: Kangho Hur <kangho.hur@samsung.com>, ByungWoo Lee <bw1212.lee@samsung.com>
-Build-Depends: debhelper (>= 5), dlog-dev, capi-base-common-dev, libglib2.0-dev, libbluetooth-frwk-dev
-
-Package: capi-network-bluetooth
-Architecture: any
-Depends: ${shlibs:Depends}, ${misc:Depends}
-Description: A Network Bluetooth library in Tizen Native API
-
-Package: capi-network-bluetooth-dev
-Architecture: any
-Depends: ${shlibs:Depends}, ${misc:Depends}, capi-network-bluetooth (= ${Source-Version}), capi-base-common-dev
-Description: A Network Bluetooth library in Tizen Native API (DEV)
-
-Package: capi-network-bluetooth-dbg
-Architecture: any
-Depends: ${shlibs:Depends}, ${misc:Depends}, capi-network-bluetooth (= ${Source-Version})
-Description: A Network Bluetooth library in Tizen Native API (DBG)
-
diff --git a/mobile/debian/rules b/mobile/debian/rules
deleted file mode 100755
index 9736f8b..0000000
--- a/mobile/debian/rules
+++ /dev/null
@@ -1,68 +0,0 @@
-#!/usr/bin/make -f
-
-FULLVER ?= $(shell dpkg-parsechangelog | grep Version: | cut -d ' ' -f 2 | cut -d '-' -f 1)
-MAJORVER ?= $(shell echo $(FULLVER) | cut -d '.' -f 1)
-
-CFLAGS = -Wall -g
-
-ifneq (,$(findstring noopt,$(DEB_BUILD_OPTIONS)))
-	CFLAGS += -O0
-else
-	CFLAGS += -O2
-endif
-CMAKE_ROOT_DIR ?= $(CURDIR)
-CMAKE_BUILD_DIR ?= $(CURDIR)/cmake_build_tmp
-
-configure: configure-stamp
-configure-stamp:
-	dh_testdir
-	mkdir -p $(CMAKE_BUILD_DIR) && cd $(CMAKE_BUILD_DIR) && cmake .. -DFULLVER=${FULLVER} -DMAJORVER=${MAJORVER}
-	touch configure-stamp
-
-
-build: build-stamp
-build-stamp: configure-stamp 
-	dh_testdir
-	cd $(CMAKE_BUILD_DIR) && $(MAKE)
-	touch $@
-
-clean:
-	cd $(CMAKE_ROOT_DIR)
-	dh_testdir
-	dh_testroot
-	rm -f build-stamp configure-stamp
-	rm -f `find . -name *.pc`
-	rm -rf $(CMAKE_BUILD_DIR)
-	dh_clean
-	
-install: build
-	dh_testdir
-	dh_testroot
-	dh_clean -k 
-	dh_installdirs
-
-	cd $(CMAKE_BUILD_DIR) && $(MAKE) DESTDIR=$(CURDIR)/debian/tmp install
-
-binary-indep: build install
-
-binary-arch: build install
-	dh_testdir
-	dh_testroot
-	dh_installchangelogs 
-	dh_installdocs
-	dh_installexamples
-	dh_install --sourcedir=debian/tmp
-	dh_installman
-	dh_link
-	dh_strip --dbg-package=capi-network-bluetooth-dbg
-	dh_fixperms
-	dh_makeshlibs
-	dh_installdeb
-	dh_shlibdeps
-	dh_gencontrol
-	dh_md5sums
-	dh_builddeb
-
-binary: binary-indep binary-arch
-.PHONY: build clean binary-indep binary-arch binary install configure
-
diff --git a/mobile/include/bluetooth_private.h b/mobile/include/bluetooth_private.h
deleted file mode 100644
index 11731cf..0000000
--- a/mobile/include/bluetooth_private.h
+++ /dev/null
@@ -1,219 +0,0 @@
-/*
- * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the License);
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an AS IS BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-
-#ifndef __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-telephony-api.h>
-#include <bluetooth-media-control.h>
-#include <bluetooth-hid-api.h>
-
-#include "bluetooth.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#undef LOG_TAG
-#define LOG_TAG "CAPI_NETWORK_BLUETOOTH"
-
-#define BT_INFO(fmt, args...) SLOGI(fmt, ##args)
-#define BT_DBG(fmt, args...) SLOGD(fmt, ##args)
-#define BT_ERR(fmt, args...) SLOGE(fmt, ##args)
-
-#define OPP_UUID "00001105-0000-1000-8000-00805f9b34fb"
-
-/**
- * @internal
- * @brief Bluetooth callback.
- */
-typedef enum
-{
-	BT_EVENT_STATE_CHANGED = 0x00, /**< Adapter state is changed */
-	BT_EVENT_NAME_CHANGED, /**< Adapter name is changed */
-	BT_EVENT_VISIBILITY_MODE_CHANGED, /**< Adapter visibility mode is changed */
-	BT_EVENT_DEVICE_DISCOVERY_STATE_CHANGED, /**< Device discovery state is changed */
-	BT_EVENT_BOND_CREATED, /**< A bond is created */
-	BT_EVENT_BOND_DESTROYED, /**< A bond is destroyed */
-	BT_EVENT_AUTHORIZATION_CHANGED, /**< Authorization is changed */
-	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_RECEIVED, /**< HDP Data receive Callabck */
-	BT_EVENT_AUDIO_CONNECTION_STATUS, /**< Audio Connection change callback */
-	BT_EVENT_AG_SCO_CONNECTION_STATUS, /**< Audio - AG SCO Connection state change callback */
-	BT_EVENT_AG_CALL_HANDLING_EVENT, /**< Audio - AG call event callback */
-	BT_EVENT_AG_MULTI_CALL_HANDLING_EVENT, /**< Audio - AG 3-way call event callback */
-	BT_EVENT_AG_DTMF_TRANSMITTED, /**< Audio - DTMF tone sending request */
-	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_AVRCP_EQUALIZER_STATE_CHANGED, /**< AVRCP equalizer state change callback */
-	BT_EVENT_AVRCP_REPEAT_MODE_CHANGED, /**< AVRCP repeat mode change callback */
-	BT_EVENT_AVRCP_SHUFFLE_MODE_CHANGED, /**< AVRCP equalizer mode change callback */
-	BT_EVENT_AVRCP_SCAN_MODE_CHANGED, /**< AVRCP scan mode change callback */
-	BT_EVENT_HID_CONNECTION_STATUS, /**< HID connection status callback */
-	BT_EVENT_DEVICE_CONNECTION_STATUS, /**< Device connection status callback */
-	BT_EVENT_GATT_CONNECTION_STATUS, /** < GATT connection status callback */
-	BT_EVENT_GATT_RSSI_VALUE, /** < RSSI value for remote device */
-	BT_EVENT_GATT_CHARACTERISTIC_DISCOVERED, /**< GATT characteristic discovered callback */
-	BT_EVENT_GATT_VALUE_CHANGED, /**< GATT characteristic value changed callback */
-	BT_EVENT_GATT_READ_CHARACTERISTIC, /**< GATT characteristic value read callback */
-	BT_EVENT_GATT_WRITE_CHARACTERISTIC, /**< GATT characteristic value read callback */
-} bt_event_e;
-
-/**
- * @internal
- */
-typedef struct bt_event_sig_event_slot_s
-{
-    int event_type;
-    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);
-
-
-/**
- * @internal
- * @brief Convert Bluetooth F/W bluetooth_device_info_t to capi bt_device_info_s.
- */
-int _bt_get_bt_device_info_s(bt_device_info_s **dest_dev, bluetooth_device_info_t *source_dev);
-
-
-/**
- * @internal
- * @brief Free bt_device_info_s.
- */
-void _bt_free_bt_device_info_s(bt_device_info_s *device_info);
-
-/**
- * @internal
- * @brief Convert Bluetooth F/W bluetooth_device_address_t to string.
- */
-int _bt_convert_address_to_string(char **addr_str, bluetooth_device_address_t *addr_hex);
-
-
-/**
- * @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);
-
-
-/**
- * @internal
- * @brief Convert error code to string.
- */
-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 Telephony call back and event proxy call backs have different prototype it is wrapper function.
- */
-void _bt_telephony_event_proxy(int event, telephony_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
-}
-#endif
-
-#endif /* __TIZEN_NETWORK_BLUETOOTH_PRIVATE_H__ */
diff --git a/mobile/src/bluetooth-adapter.c b/mobile/src/bluetooth-adapter.c
deleted file mode 100644
index ba125ce..0000000
--- a/mobile/src/bluetooth-adapter.c
+++ /dev/null
@@ -1,544 +0,0 @@
-/*
- * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
- *
- * 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"
-
-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) {
-		BT_ERR("%s(0x%08x)", _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) {
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code);
-	}
-	return error_code;
-}
-
-int bt_adapter_reset(void)
-{
-	int error_code = BT_ERROR_NONE;
-
-	BT_CHECK_INIT_STATUS();
-	error_code = _bt_get_error_code(bluetooth_reset_adapter());
-	if (error_code != BT_ERROR_NONE) {
-		BT_ERR("%s(0x%08x)", _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) {
-		BT_ERR("%s(0x%08x)", _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) {
-		BT_ERR("%s(0x%08x)", _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) {
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
-		return ret;
-	}
-
-	*name = strdup(loc_name.name);
-	if (*name == NULL) {
-		BT_ERR("OUT_OF_MEMORY(0x%08x)", 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) {
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
-	}
-
-	return ret;
-}
-
-int bt_adapter_get_visibility(bt_adapter_visibility_mode_e *mode, int *duration)
-{
-	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) {
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
-		return ret;
-	}
-
-	*mode = _bt_get_bt_visibility_mode_e(discoverable_mode);
-
-	if (duration)
-		*duration = 0;
-
-	if (discoverable_mode == BLUETOOTH_DISCOVERABLE_MODE_TIME_LIMITED_DISCOVERABLE) {
-		if (duration == NULL)
-			return BT_ERROR_NONE;
-		ret = bluetooth_get_timeout_value(duration);
-		if (ret != BT_ERROR_NONE) {
-			BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
-		}
-	}
-
-	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:
-		BT_ERR("INVALID_PARAMETER(0x%08x)", 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) {
-		BT_ERR("%s(0x%08x)", _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) {
-		BT_ERR("OUT_OF_MEMORY(0x%08x)", 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) {
-		BT_ERR("%s(0x%08x) : Failed to get bonded device list", _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) {
-				BT_ERR("%s(0x%08x) : Failed to get device info", _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 {
-			BT_ERR("OPERATION_FAILED(0x%08x)", BT_ERROR_OPERATION_FAILED);
-			ret = BT_ERROR_OPERATION_FAILED;
-			break;
-		}
-	}
-
-	if (dev_list != NULL) {
-		g_ptr_array_foreach(dev_list, (GFunc)g_free, 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) {
-		BT_ERR("%s(0x%08x) : Failed to run function",
-					_bt_convert_error_to_string(ret), ret);
-	} else {
-		ret = _bt_get_bt_device_info_s(device_info, info);
-		if (ret != BT_ERROR_NONE) {
-			BT_ERR("%s(0x%08x) : Failed to get device info",
-						_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) {
-		BT_ERR("%s(0x%08x) : Failed to run 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) {
-		BT_ERR("%s(0x%08x)", _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) {
-		BT_ERR("%s(0x%08x)", _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) {
-		BT_ERR("%s(0x%08x)", _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) {
-		BT_ERR("%s(0x%08x)", _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_set_visibility_duration_changed_cb(bt_adapter_visibility_duration_changed_cb callback, void *user_data)
-{
-	BT_CHECK_INIT_STATUS();
-
-	/* Will impelement it */
-
-	return BT_ERROR_NONE;
-}
-
-int bt_adapter_unset_visibility_duration_changed_cb(void)
-{
-	BT_CHECK_INIT_STATUS();
-
-	/* Will impelement it */
-
-	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) {
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code);
-	}
-	return error_code;
-}
-
-int bt_adapter_start_discover_devices(bt_adapter_discover_devices_type_e type)
-{
-	int error_code = BT_ERROR_NONE;
-
-	BT_CHECK_INIT_STATUS();
-	error_code = _bt_get_error_code(bluetooth_start_custom_discovery(type,
-					0, 0, BLUETOOTH_DEVICE_MAJOR_MASK_MISC));
-	if (error_code != BT_ERROR_NONE) {
-		BT_ERR("%s(0x%08x)", _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) {
-		BT_ERR("%s(0x%08x)", _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);
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
-		return ret;
-	}
-}
-
-int bt_adapter_get_local_oob_data(unsigned char **hash, unsigned char **randomizer,
-					int *hash_len, int *randomizer_len)
-{
-	int ret = BT_ERROR_NONE;
-
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(hash);
-	BT_CHECK_INPUT_PARAMETER(randomizer);
-	BT_CHECK_INPUT_PARAMETER(hash_len);
-	BT_CHECK_INPUT_PARAMETER(randomizer_len);
-
-	bt_oob_data_t oob_data;
-
-	ret = _bt_get_error_code(bluetooth_oob_read_local_data(&oob_data));
-	if (BT_ERROR_NONE == ret) {
-		*hash = g_memdup(oob_data.hash, BLUETOOTH_OOB_DATA_LENGTH);
-		*randomizer = g_memdup(oob_data.randomizer,
-						BLUETOOTH_OOB_DATA_LENGTH);
-		*hash_len = BLUETOOTH_OOB_DATA_LENGTH;
-		*randomizer_len = BLUETOOTH_OOB_DATA_LENGTH;
-	} else {
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
-	}
-	return ret;
-}
-
-int bt_adapter_set_remote_oob_data(const char *remote_address,
-				unsigned char *hash, unsigned char *randomizer,
-				int hash_len, int randomizer_len)
-{
-	int ret = BT_ERROR_NONE;
-	bluetooth_device_address_t addr_hex = { {0,} };
-	bt_oob_data_t oob_data = { {0},};
-
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(remote_address);
-
-	_bt_convert_address_to_hex(&addr_hex, remote_address);
-
-	if (hash != NULL && randomizer != NULL) {
-		memcpy(oob_data.hash, hash, hash_len);
-		memcpy(oob_data.randomizer, randomizer, randomizer_len);
-		oob_data.hash_len = hash_len;
-		oob_data.randomizer_len = randomizer_len;
-	}
-
-	ret = _bt_get_error_code(bluetooth_oob_add_remote_data(&addr_hex, &oob_data));
-	if (BT_ERROR_NONE != ret) {
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
-	}
-	return ret;
-}
-
-int bt_adapter_remove_remote_oob_data(const char *remote_address)
-{
-	int ret = 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);
-
-	ret = _bt_get_error_code(bluetooth_oob_remove_remote_data(&addr_hex));
-	if (BT_ERROR_NONE != ret) {
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
-	}
-	return ret;
-}
-
diff --git a/mobile/src/bluetooth-avrcp.c b/mobile/src/bluetooth-avrcp.c
deleted file mode 100644
index 9eb4cd6..0000000
--- a/mobile/src/bluetooth-avrcp.c
+++ /dev/null
@@ -1,229 +0,0 @@
-/*
- * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
- *
- * 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"
-
-/*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) {
-		BT_ERR("%s(0x%08x)", _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) {
-		BT_ERR("%s(0x%08x)", _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(EQUALIZER, state);
-	error = _bt_convert_avrcp_error_code(error);
-	error = _bt_get_error_code(error);
-	if (BT_ERROR_NONE != error) {
-		BT_ERR("%s(0x%08x)", _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) {
-		BT_ERR("%s(0x%08x)", _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) {
-		BT_ERR("%s(0x%08x)", _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) {
-		BT_ERR("%s(0x%08x)", _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) {
-		BT_ERR("%s(0x%08x)", _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) {
-		BT_ERR("%s(0x%08x)", _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) {
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error);
-	}
-	return error;
-}
-
-int bt_avrcp_set_equalizer_state_changed_cb(bt_avrcp_equalizer_state_changed_cb callback, void *user_data)
-{
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(callback);
-	_bt_set_cb(BT_EVENT_AVRCP_EQUALIZER_STATE_CHANGED, callback, user_data);
-	return BT_ERROR_NONE;
-}
-
-int bt_avrcp_unset_equalizer_state_changed_cb(void)
-{
-	_bt_unset_cb(BT_EVENT_AVRCP_EQUALIZER_STATE_CHANGED);
-	return BT_ERROR_NONE;
-}
-
-int bt_avrcp_set_repeat_mode_changed_cb(bt_avrcp_repeat_mode_changed_cb callback, void *user_data)
-{
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(callback);
-	_bt_set_cb(BT_EVENT_AVRCP_REPEAT_MODE_CHANGED, callback, user_data);
-	return BT_ERROR_NONE;
-}
-
-int bt_avrcp_unset_repeat_mode_changed_cb(void)
-{
-	_bt_unset_cb(BT_EVENT_AVRCP_REPEAT_MODE_CHANGED);
-	return BT_ERROR_NONE;
-}
-
-int bt_avrcp_set_shuffle_mode_changed_cb(bt_avrcp_shuffle_mode_changed_cb callback, void *user_data)
-{
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(callback);
-	_bt_set_cb(BT_EVENT_AVRCP_SHUFFLE_MODE_CHANGED, callback, user_data);
-	return BT_ERROR_NONE;
-}
-
-int bt_avrcp_unset_shuffle_mode_changed_cb(void)
-{
-	_bt_unset_cb(BT_EVENT_AVRCP_SHUFFLE_MODE_CHANGED);
-	return BT_ERROR_NONE;
-}
-
-int bt_avrcp_set_scan_mode_changed_cb(bt_avrcp_scan_mode_changed_cb callback, void *user_data)
-{
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(callback);
-	_bt_set_cb(BT_EVENT_AVRCP_SCAN_MODE_CHANGED, callback, user_data);
-	return BT_ERROR_NONE;
-}
-
-int bt_avrcp_unset_scan_mode_changed_cb(void)
-{
-	_bt_unset_cb(BT_EVENT_AVRCP_SCAN_MODE_CHANGED);
-	return BT_ERROR_NONE;
-}
-
diff --git a/mobile/src/bluetooth-common.c b/mobile/src/bluetooth-common.c
deleted file mode 100644
index 2126981..0000000
--- a/mobile/src/bluetooth-common.c
+++ /dev/null
@@ -1,1312 +0,0 @@
-/*
- * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
- *
- * 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"
-#include "bluetooth-telephony-api.h"
-
-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_RECEIVED, NULL, NULL},
-	{BT_EVENT_AUDIO_CONNECTION_STATUS, NULL, NULL},
-	{BT_EVENT_AG_SCO_CONNECTION_STATUS, NULL, NULL},
-	{BT_EVENT_AG_CALL_HANDLING_EVENT, NULL, NULL},
-	{BT_EVENT_AG_MULTI_CALL_HANDLING_EVENT, NULL, NULL},
-	{BT_EVENT_AG_DTMF_TRANSMITTED, NULL, NULL},
-	{BT_EVENT_AG_MICROPHONE_GAIN_CHANGE, NULL, NULL},
-	{BT_EVENT_AG_SPEAKER_GAIN_CHANGE, NULL, NULL},
-	{BT_EVENT_AVRCP_CONNECTION_STATUS, NULL, NULL},
-	{BT_EVENT_AVRCP_EQUALIZER_STATE_CHANGED, NULL, NULL},
-	{BT_EVENT_AVRCP_REPEAT_MODE_CHANGED, NULL, NULL},
-	{BT_EVENT_AVRCP_SHUFFLE_MODE_CHANGED, NULL, NULL},
-	{BT_EVENT_AVRCP_SCAN_MODE_CHANGED, NULL, NULL},
-	{BT_EVENT_HID_CONNECTION_STATUS, NULL, NULL},
-	{BT_EVENT_DEVICE_CONNECTION_STATUS, NULL, NULL},
-	{BT_EVENT_GATT_CHARACTERISTIC_DISCOVERED, NULL, NULL},
-	{BT_EVENT_GATT_VALUE_CHANGED, NULL, NULL},
-	{BT_EVENT_GATT_READ_CHARACTERISTIC, NULL, NULL},
-	{BT_EVENT_GATT_WRITE_CHARACTERISTIC, 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) {
-			BT_ERR("OPERATION_FAILED(0x%08x)", 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) {
-		BT_ERR("OPERATION_FAILED(0x%08x)", 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)
-	{
-		BT_ERR("NOT_INITIALIZED(0x%08x)", 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:
-	case BLUETOOTH_ERROR_ALREADY_INITIALIZED:
-	case BLUETOOTH_ERROR_AGENT_DOES_NOT_EXIST:
-		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_PERMISSION_DEINED :
-		return BT_ERROR_PERMISSION_DENIED;
-	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, };
-
-	BT_CHECK_INPUT_PARAMETER(addr_hex);
-
-	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, };
-
-	if (addr_str == NULL)
-		return;
-
-	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) {
-		BT_ERR("Invalid format string - %s", 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_telephony_event_proxy(int event, telephony_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)
-{
-	int i;
-	int call_id;
-	int *avrcp_mode;
-	int *le_conn_state;
-	short *rssi_value;
-	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;
-	telephony_event_callid_t *call_data = 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;
-	bt_gatt_discovered_char_t *svc_char = NULL;
-	bt_gatt_char_value_t *char_val = 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:
-		BT_INFO("bt_adapter_state_changed_cb() will be called with BT_ADAPTER_ENABLED");
-		((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:
-		BT_INFO("bt_adapter_state_changed_cb() will be called with BT_ADAPTER_DISABLED");
-		((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:
-		BT_INFO("bt_adapter_name_changed_cb() will be called");
-		((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:
-		BT_INFO("bt_adapter_visibility_mode_changed_cb() will be called");
-		((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:
-		BT_INFO("bt_adapter_device_discovery_state_changed_cb() will be called with BT_ADAPTER_DEVICE_DISCOVERY_STARTED");
-		((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:
-		BT_INFO("bt_adapter_device_discovery_state_changed_cb() will be called with BT_ADAPTER_DEVICE_DISCOVERY_FINISHED");
-		((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:
-	case BLUETOOTH_EVENT_REMOTE_DEVICE_FOUND:
-		BT_INFO("bt_adapter_device_discovery_state_changed_cb() will be called with BT_ADAPTER_DEVICE_DISCOVERY_FOUND");
-		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:
-		BT_INFO("bt_device_bond_created_cb() will be called");
-		_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:
-		BT_INFO("bt_device_bond_destroyed_cb() will be called");
-		_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:
-		BT_INFO("bt_device_authorization_changed_cb() will be called with BT_DEVICE_AUTHORIZED");
-		_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);
-		break;
-	case BLUETOOTH_EVENT_DEVICE_UNAUTHORIZED:
-		BT_INFO("bt_device_authorization_changed_cb() will be called with BT_DEVICE_UNAUTHORIZED");
-		_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);
-		break;
-	case BLUETOOTH_EVENT_DEVICE_CONNECTED:
-		BT_INFO("bt_device_connection_state_changed_cb() will be called");
-		_bt_convert_address_to_string(&device_addr, (bluetooth_device_address_t *)(param->param_data));
-		((bt_device_connection_state_changed_cb)bt_event_slot_container[event_index].callback)
-		    (true, device_addr, bt_event_slot_container[event_index].user_data);
-		if (device_addr != NULL)
-			free(device_addr);
-		break;
-	case BLUETOOTH_EVENT_DEVICE_DISCONNECTED:
-		BT_INFO("bt_device_connection_state_changed_cb() will be called");
-		_bt_convert_address_to_string(&device_addr, (bluetooth_device_address_t *)(param->param_data));
-		((bt_device_connection_state_changed_cb)bt_event_slot_container[event_index].callback)
-		    (false, device_addr, bt_event_slot_container[event_index].user_data);
-		if (device_addr != NULL)
-			free(device_addr);
-		break;
-	case BLUETOOTH_EVENT_SERVICE_SEARCHED:
-		BT_INFO("bt_device_service_searched_cb() will be called");
-		__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:
-		BT_INFO("bt_socket_data_received_cb() will be called");
-		((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:
-		BT_INFO("bt_socket_connection_state_changed_cb() will be called with BT_SOCKET_CONNECTED");
-		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);
-
-		if (connection_ind) {
-			rfcomm_connection.socket_fd = connection_ind->socket_fd;
-			rfcomm_connection.local_role = connection_ind->device_role;
-
-			if (strlen(connection_ind->uuid) > 0) {
-				rfcomm_connection.service_uuid = strdup(connection_ind->uuid);
-				BT_DBG("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:
-		BT_INFO("bt_socket_connection_state_changed_cb() will be called with BT_SOCKET_DISCONNECTED");
-
-		disconnection_ind = (bluetooth_rfcomm_disconnection_t *)(param->param_data);
-
-		if (disconnection_ind) {
-			rfcomm_connection.socket_fd = disconnection_ind->socket_fd;
-			rfcomm_connection.local_role = disconnection_ind->device_role;
-
-			if (strlen(disconnection_ind->uuid) > 0) {
-				rfcomm_connection.service_uuid = strdup(disconnection_ind->uuid);
-				BT_DBG("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:
-		BT_INFO("bt_socket_connection_requested_cb() will be called");
-		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:
-		BT_INFO("bt_opp_server_connection_requested_cb() will be called");
-		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:
-		BT_INFO("bt_opp_server_push_requested_cb() will be called");
-		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:
-		BT_INFO("bt_opp_server_transfer_started_cb() will be called");
-		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:
-		BT_INFO("bt_opp_server_transfer_in_progress_cb() will be called");
-		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:
-		BT_INFO("bt_opp_server_transfer_completed_cb() will be called");
-		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:
-		BT_INFO("bt_opp_client_push_responded_cb() will be called");
-		bd_addr = (bluetooth_device_address_t *)(param->param_data);
-		_bt_convert_address_to_string(&device_addr, bd_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);
-
-		if (device_addr != NULL)
-			free(device_addr);
-		break;
-
-	case BLUETOOTH_EVENT_OPC_DISCONNECTED:
-		BT_INFO("bt_opp_client_push_finished_cb() will be called");
-		bd_addr = (bluetooth_device_address_t *)(param->param_data);
-		_bt_convert_address_to_string(&device_addr, bd_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);
-
-		if (device_addr != NULL)
-			free(device_addr);
-		break;
-
-	case BLUETOOTH_EVENT_OPC_TRANSFER_STARTED:
-		BT_INFO("BLUETOOTH_EVENT_OPC_TRANSFER_STARTED");
-		/* This event don't be used in CAPI */
-		break;
-
-	case BLUETOOTH_EVENT_OPC_TRANSFER_PROGRESS:
-		BT_INFO("bt_opp_client_transfer_in_progress_cb() will be called");
-		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:
-		BT_INFO("BLUETOOTH_EVENT_OPC_TRANSFER_COMPLETE");
-		/* This event don't be used in CAPI */
-		break;
-
-	case BLUETOOTH_EVENT_NETWORK_SERVER_CONNECTED:
-		BT_INFO("BLUETOOTH_EVENT_NETWORK_SERVER_CONNECTED");
-		dev_info = (bluetooth_network_device_info_t *)(param->param_data);
-
-		if (param->result != BLUETOOTH_ERROR_NONE) {
-			BT_ERR("Fail to connect the network server");
-		}
-		_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);
-
-		if (device_addr != NULL)
-			free(device_addr);
-		break;
-
-	case BLUETOOTH_EVENT_NETWORK_SERVER_DISCONNECTED:
-		BT_INFO("BLUETOOTH_EVENT_NETWORK_SERVER_DISCONNECTED");
-		dev_info = (bluetooth_network_device_info_t *)(param->param_data);
-
-		if (param->result != BLUETOOTH_ERROR_NONE) {
-			BT_ERR("Fail to disconnect the network server");
-		}
-		_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);
-
-		if (device_addr != NULL)
-			free(device_addr);
-		break;
-	case BLUETOOTH_EVENT_NETWORK_DISCONNECTED:
-		BT_INFO("BLUETOOTH_EVENT_NETWORK_DISCONNECTED");
-		bd_addr = (bluetooth_device_address_t *)(param->param_data);
-		_bt_convert_address_to_string(&device_addr, bd_addr);
-
-		((bt_panu_connection_state_changed_cb)bt_event_slot_container[event_index].callback)
-		(_bt_get_error_code(param->result), FALSE, device_addr, BLUETOOTH_NETWORK_NAP_ROLE,
-		bt_event_slot_container[event_index].user_data);
-		if (device_addr != NULL)
-			free(device_addr);
-		break;
-
-	case BLUETOOTH_EVENT_NETWORK_CONNECTED:
-		BT_INFO("BLUETOOTH_EVENT_NETWORK_CONNECTED");
-		bd_addr = (bluetooth_device_address_t *)(param->param_data);
-		_bt_convert_address_to_string(&device_addr, bd_addr);
-
-		((bt_panu_connection_state_changed_cb)bt_event_slot_container[event_index].callback)
-		(_bt_get_error_code(param->result), TRUE, device_addr, BLUETOOTH_NETWORK_NAP_ROLE,
-		bt_event_slot_container[event_index].user_data);
-		if (device_addr != NULL)
-			free(device_addr);
-		break;
-
-	case BLUETOOTH_EVENT_HDP_CONNECTED:
-		BT_INFO("HDP Connected ");
-		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);
-
-		if (device_addr != NULL)
-			free(device_addr);
-		break;
-
-	case BLUETOOTH_EVENT_HDP_DISCONNECTED:
-		BT_INFO("HDP disconnected callback will be ");
-		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);
-
-		if (device_addr != NULL)
-			free(device_addr);
-		break;
-	case BLUETOOTH_EVENT_HDP_DATA_RECEIVED:
-		BT_INFO("HDP data recieved callback will be ");
-		hdp_data_ind = (bt_hdp_data_ind_t *)(param->param_data);
-		if (param->result != BLUETOOTH_ERROR_NONE) {
-			BT_ERR("Fail to receive HDP data");
-		}
-
-		((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:
-		BT_INFO("BLUETOOTH_EVENT_AG_CONNECTED ");
-		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:
-		BT_INFO("BLUETOOTH_EVENT_AG_DISCONNECTED ");
-		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_TELEPHONY_AUDIO_CONNECTED:
-		BT_INFO("BLUETOOTH_EVENT_TELEPHONY_AUDIO_CONNECTED ");
-		((bt_ag_sco_state_changed_cb)bt_event_slot_container[event_index].callback)
-		(_bt_get_error_code(param->result), TRUE,
-		bt_event_slot_container[event_index].user_data);
-		break;
-	case BLUETOOTH_EVENT_TELEPHONY_AUDIO_DISCONNECTED:
-		BT_INFO("BLUETOOTH_EVENT_TELEPHONY_AUDIO_DISCONNECTED ");
-		((bt_ag_sco_state_changed_cb)bt_event_slot_container[event_index].callback)
-		(_bt_get_error_code(param->result), FALSE,
-		bt_event_slot_container[event_index].user_data);
-		break;
-	case BLUETOOTH_EVENT_TELEPHONY_ANSWER_CALL:
-		call_data = (telephony_event_callid_t *)param->param_data;
-		call_id = call_data->callid;
-		BT_INFO("BLUETOOTH_EVENT_TELEPHONY_ANSWER_CALL ");
-		((bt_ag_call_handling_event_cb)bt_event_slot_container[event_index].callback)
-		(BT_AG_CALL_HANDLING_EVENT_ANSWER, call_id,
-		bt_event_slot_container[event_index].user_data);
-		break;
-	case BLUETOOTH_EVENT_TELEPHONY_RELEASE_CALL:
-		call_data = (telephony_event_callid_t *)param->param_data;
-		call_id = call_data->callid;
-		BT_INFO("BLUETOOTH_EVENT_TELEPHONY_RELEASE_CALL ");
-		((bt_ag_call_handling_event_cb)bt_event_slot_container[event_index].callback)
-		(BT_AG_CALL_HANDLING_EVENT_RELEASE, call_id,
-		bt_event_slot_container[event_index].user_data);
-		break;
-	case BLUETOOTH_EVENT_TELEPHONY_REJECT_CALL:
-		call_data = (telephony_event_callid_t *)param->param_data;
-		call_id = call_data->callid;
-		BT_INFO("BLUETOOTH_EVENT_TELEPHONY_REJECT_CALL ");
-		((bt_ag_call_handling_event_cb)bt_event_slot_container[event_index].callback)
-		(BT_AG_CALL_HANDLING_EVENT_REJECT, call_id,
-		bt_event_slot_container[event_index].user_data);
-		break;
-	case BLUETOOTH_EVENT_TELEPHONY_CHLD_0_RELEASE_ALL_HELD_CALL:
-		BT_INFO("BLUETOOTH_EVENT_TELEPHONY_CHLD_0_RELEASE_ALL_HELD_CALL ");
-		((bt_ag_multi_call_handling_event_cb)bt_event_slot_container[event_index].callback)
-		(BT_AG_MULTI_CALL_HANDLING_EVENT_RELEASE_HELD_CALLS,
-		bt_event_slot_container[event_index].user_data);
-		break;
-	case BLUETOOTH_EVENT_TELEPHONY_CHLD_1_RELEASE_ALL_ACTIVE_CALL:
-		BT_INFO("BLUETOOTH_EVENT_TELEPHONY_CHLD_1_RELEASE_ALL_ACTIVE_CALL ");
-		((bt_ag_multi_call_handling_event_cb)bt_event_slot_container[event_index].callback)
-		(BT_AG_MULTI_CALL_HANDLING_EVENT_RELEASE_ACTIVE_CALLS,
-		bt_event_slot_container[event_index].user_data);
-		break;
-	case BLUETOOTH_EVENT_TELEPHONY_CHLD_2_ACTIVE_HELD_CALL:
-		BT_INFO("BLUETOOTH_EVENT_TELEPHONY_CHLD_2_ACTIVE_HELD_CALL ");
-		((bt_ag_multi_call_handling_event_cb)bt_event_slot_container[event_index].callback)
-		(BT_AG_MULTI_CALL_HANDLING_EVENT_ACTIVATE_HELD_CALL,
-		bt_event_slot_container[event_index].user_data);
-		break;
-	case BLUETOOTH_EVENT_TELEPHONY_CHLD_3_MERGE_CALL:
-		BT_INFO("BLUETOOTH_EVENT_TELEPHONY_CHLD_3_MERGE_CALL ");
-		((bt_ag_multi_call_handling_event_cb)bt_event_slot_container[event_index].callback)
-		(BT_AG_MULTI_CALL_HANDLING_EVENT_MERGE_CALLS,
-		bt_event_slot_container[event_index].user_data);
-		break;
-	case BLUETOOTH_EVENT_TELEPHONY_CHLD_4_EXPLICIT_CALL_TRANSFER:
-		BT_INFO("BLUETOOTH_EVENT_TELEPHONY_CHLD_4_EXPLICIT_CALL_TRANSFER ");
-		((bt_ag_multi_call_handling_event_cb)bt_event_slot_container[event_index].callback)
-		(BT_AG_MULTI_CALL_HANDLING_EVENT_EXPLICIT_CALL_TRANSFER,
-		bt_event_slot_container[event_index].user_data);
-		break;
-	case BLUETOOTH_EVENT_TELEPHONY_SEND_DTMF: {
-		telephony_event_dtmf_t *call_data = param->param_data;
-
-		BT_INFO("BLUETOOTH_EVENT_TELEPHONY_SEND_DTMF ");
-		((bt_ag_dtmf_transmitted_cb)bt_event_slot_container[event_index].callback)
-		(call_data->dtmf, bt_event_slot_container[event_index].user_data);
-		break;
-	}
-	case BLUETOOTH_EVENT_AG_SPEAKER_GAIN:
-		BT_INFO("BLUETOOTH_EVENT_AG_SPEAKER_GAIN");
-		int *spk_gain = (int *)(param->param_data);
-		((bt_ag_speaker_gain_changed_cb)bt_event_slot_container[event_index].callback)
-		(*spk_gain, bt_event_slot_container[event_index].user_data);
-		break;
-	case BLUETOOTH_EVENT_AG_MIC_GAIN:
-		BT_INFO("BLUETOOTH_EVENT_AG_MIC_GAIN");
-		int *mik_gain = (int *)(param->param_data);
-		((bt_ag_microphone_gain_changed_cb)bt_event_slot_container[event_index].callback)
-		(*mik_gain, bt_event_slot_container[event_index].user_data);
-		break;
-	case BLUETOOTH_EVENT_AG_AUDIO_CONNECTED:
-		BT_INFO("BLUETOOTH_EVENT_AG_AUDIO_CONNECTED");
-		((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:
-		BT_INFO("BLUETOOTH_EVENT_AG_AUDIO_DISCONNECTED");
-		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:
-		BT_INFO("BLUETOOTH_EVENT_AV_CONNECTED ");
-		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:
-		BT_INFO("BLUETOOTH_EVENT_Av_DISCONNECTED ");
-		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_EVENT_AVRCP_CONNECTED:
-		BT_INFO("BLUETOOTH_EVENT_AVRCP_CONNECTED ");
-		device_addr = (char *)(param->param_data);
-		((bt_avrcp_target_connection_state_changed_cb)bt_event_slot_container[event_index].callback)
-		(TRUE, device_addr, bt_event_slot_container[event_index].user_data);
-		break;
-	case BLUETOOTH_EVENT_AVRCP_DISCONNECTED:
-		BT_INFO("BLUETOOTH_EVENT_AVRCP_DISCONNECTED ");
-		device_addr = (char *)(param->param_data);
-		((bt_avrcp_target_connection_state_changed_cb)bt_event_slot_container[event_index].callback)
-		(FALSE, device_addr, bt_event_slot_container[event_index].user_data);
-		break;
-	case BLUETOOTH_EVENT_AVRCP_SETTING_SHUFFLE_STATUS:
-		BT_INFO("BLUETOOTH_EVENT_AVRCP_SETTING_SHUFFLE_STATUS ");
-		avrcp_mode = (int *)(param->param_data);
-		((bt_avrcp_shuffle_mode_changed_cb)bt_event_slot_container[event_index].callback)
-		((bt_avrcp_shuffle_mode_e)*avrcp_mode, bt_event_slot_container[event_index].user_data);
-		break;
-	case BLUETOOTH_EVENT_AVRCP_SETTING_EQUALIZER_STATUS:
-		BT_INFO("BLUETOOTH_EVENT_AVRCP_SETTING_EQUALIZER_STATUS ");
-		avrcp_mode = (int *)(param->param_data);
-		((bt_avrcp_equalizer_state_changed_cb)bt_event_slot_container[event_index].callback)
-		((bt_avrcp_equalizer_state_e)*avrcp_mode, bt_event_slot_container[event_index].user_data);
-		break;
-	case BLUETOOTH_EVENT_AVRCP_SETTING_REPEAT_STATUS:
-		BT_INFO("BLUETOOTH_EVENT_AVRCP_SETTING_REPEAT_STATUS ");
-		avrcp_mode = (int *)(param->param_data);
-		((bt_avrcp_repeat_mode_changed_cb)bt_event_slot_container[event_index].callback)
-		((bt_avrcp_repeat_mode_e)*avrcp_mode, bt_event_slot_container[event_index].user_data);
-		break;
-	case BLUETOOTH_EVENT_AVRCP_SETTING_SCAN_STATUS:
-		BT_INFO("BLUETOOTH_EVENT_AVRCP_SETTING_SCAN_STATUS ");
-		avrcp_mode = (int *)(param->param_data);
-		((bt_avrcp_scan_mode_changed_cb)bt_event_slot_container[event_index].callback)
-		((bt_avrcp_scan_mode_e)*avrcp_mode, bt_event_slot_container[event_index].user_data);
-		break;
-	case BLUETOOTH_HID_CONNECTED:
-		BT_INFO("BLUETOOTH_HID_CONNECTED");
-		bd_addr = (bluetooth_device_address_t *)(param->param_data);
-		_bt_convert_address_to_string(&device_addr, bd_addr);
-		((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);
-
-		if (device_addr != NULL)
-			free(device_addr);
-		break;
-	case BLUETOOTH_HID_DISCONNECTED:
-		BT_INFO("BLUETOOTH_HID_DISCONNECTED");
-		bd_addr = (bluetooth_device_address_t *)(param->param_data);
-		_bt_convert_address_to_string(&device_addr, bd_addr);
-		((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);
-
-		if (device_addr != NULL)
-			free(device_addr);
-		break;
-	case BLUETOOTH_EVENT_GATT_CONNECTED:
-		BT_INFO("BLUETOOTH_EVENT_GATT_CONNECTED");
-		le_conn_state = (int *)(param->param_data);
-
-		((bt_device_gatt_state_changed_cb)bt_event_slot_container[event_index].callback)
-		 (*le_conn_state, bt_event_slot_container[event_index].user_data);
-		break;
-	case BLUETOOTH_EVENT_GATT_DISCONNECTED:
-		BT_INFO("BLUETOOTH_EVENT_GATT_DISCONNECTED");
-		le_conn_state = (int *)(param->param_data);
-
-		((bt_device_gatt_state_changed_cb)bt_event_slot_container[event_index].callback)
-		 (*le_conn_state, bt_event_slot_container[event_index].user_data);
-		break;
-	case BLUETOOTH_EVENT_GATT_RSSI:
-		BT_INFO("BLUETOOTH_EVENT_GATT_RSSI");
-		rssi_value = (short *)(param->param_data);
-
-		((bt_device_gatt_state_changed_cb)bt_event_slot_container[event_index].callback)
-		 (*rssi_value, bt_event_slot_container[event_index].user_data);
-		break;
-	case BLUETOOTH_EVENT_GATT_SVC_CHAR_DISCOVERED:
-		BT_INFO("BLUETOOTH_EVENT_GATT_SVC_CHAR_DISCOVERED");
-		svc_char = (bt_gatt_discovered_char_t *)(param->param_data);
-
-		if (svc_char == NULL)
-			return;
-
-		for (i = 1; i <= svc_char->handle_info.count; i++) {
-			((bt_gatt_characteristics_discovered_cb)bt_event_slot_container[event_index].callback)
-			 (_bt_get_error_code(param->result), i, svc_char->handle_info.count, svc_char->handle_info.handle[i-1],
-			  bt_event_slot_container[event_index].user_data);
-		}
-
-		_bt_unset_cb(BT_EVENT_GATT_CHARACTERISTIC_DISCOVERED);
-
-		break;
-	case BLUETOOTH_EVENT_GATT_CHAR_VAL_CHANGED:
-		BT_INFO("BLUETOOTH_EVENT_GATT_CHAR_VAL_CHANGED");
-		char_val = (bt_gatt_char_value_t *)(param->param_data);
-
-		if (char_val == NULL)
-			return;
-
-		((bt_gatt_characteristic_changed_cb)bt_event_slot_container[event_index].callback)
-		 (char_val->char_handle, char_val->char_value, char_val->val_len,
-		  bt_event_slot_container[event_index].user_data);
-
-		break;
-	case BLUETOOTH_EVENT_GATT_READ_CHAR:
-		BT_INFO("BLUETOOTH_EVENT_GATT_READ_CHAR");
-		break;
-	default:
-		BT_INFO("__bt_event_proxy default case %d",event);
-		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]);
-				}
-
-				BT_DBG("UUID: %s", (*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;
-	(*discovery_info)->device_type = (unsigned char)source_info->device_type;
-
-	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_DEVICE_CONNECTED:
-	case BLUETOOTH_EVENT_DEVICE_DISCONNECTED:
-		return BT_EVENT_DEVICE_CONNECTION_STATUS;
-	case BLUETOOTH_EVENT_GATT_CONNECTED:
-	case BLUETOOTH_EVENT_GATT_DISCONNECTED:
-		return BT_EVENT_GATT_CONNECTION_STATUS;
-	case BLUETOOTH_EVENT_GATT_RSSI:
-		return BT_EVENT_GATT_RSSI_VALUE;
-	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_RECEIVED;
-	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_TELEPHONY_AUDIO_CONNECTED:
-		return BT_EVENT_AG_SCO_CONNECTION_STATUS;
-	case BLUETOOTH_EVENT_TELEPHONY_AUDIO_DISCONNECTED:
-		return BT_EVENT_AG_SCO_CONNECTION_STATUS;
-	case BLUETOOTH_EVENT_TELEPHONY_ANSWER_CALL:
-	case BLUETOOTH_EVENT_TELEPHONY_RELEASE_CALL:
-	case BLUETOOTH_EVENT_TELEPHONY_REJECT_CALL:
-		return BT_EVENT_AG_CALL_HANDLING_EVENT;
-	case BLUETOOTH_EVENT_TELEPHONY_CHLD_0_RELEASE_ALL_HELD_CALL:
-	case BLUETOOTH_EVENT_TELEPHONY_CHLD_1_RELEASE_ALL_ACTIVE_CALL:
-	case BLUETOOTH_EVENT_TELEPHONY_CHLD_2_ACTIVE_HELD_CALL:
-	case BLUETOOTH_EVENT_TELEPHONY_CHLD_3_MERGE_CALL:
-	case BLUETOOTH_EVENT_TELEPHONY_CHLD_4_EXPLICIT_CALL_TRANSFER:
-		return BT_EVENT_AG_MULTI_CALL_HANDLING_EVENT;
-	case BLUETOOTH_EVENT_TELEPHONY_SEND_DTMF:
-		return BT_EVENT_AG_DTMF_TRANSMITTED;
-	case BLUETOOTH_EVENT_AV_CONNECTED:
-		return BT_EVENT_AUDIO_CONNECTION_STATUS;
-	case BLUETOOTH_EVENT_AV_DISCONNECTED:
-		return BT_EVENT_AUDIO_CONNECTION_STATUS;
-	case  BLUETOOTH_EVENT_AVRCP_CONNECTED:
-	case  BLUETOOTH_EVENT_AVRCP_DISCONNECTED:
-		return BT_EVENT_AVRCP_CONNECTION_STATUS;
-	case  BLUETOOTH_EVENT_AVRCP_SETTING_SHUFFLE_STATUS:
-		return BT_EVENT_AVRCP_SHUFFLE_MODE_CHANGED;
-	case  BLUETOOTH_EVENT_AVRCP_SETTING_EQUALIZER_STATUS:
-		return BT_EVENT_AVRCP_EQUALIZER_STATE_CHANGED;
-	case  BLUETOOTH_EVENT_AVRCP_SETTING_REPEAT_STATUS:
-		return BT_EVENT_AVRCP_REPEAT_MODE_CHANGED;
-	case  BLUETOOTH_EVENT_AVRCP_SETTING_SCAN_STATUS:
-		return BT_EVENT_AVRCP_SCAN_MODE_CHANGED;
-	case BLUETOOTH_HID_CONNECTED:
-		return  BT_EVENT_HID_CONNECTION_STATUS;
-	case BLUETOOTH_HID_DISCONNECTED:
-		return  BT_EVENT_HID_CONNECTION_STATUS;
-	case BLUETOOTH_EVENT_GATT_SVC_CHAR_DISCOVERED:
-		return	BT_EVENT_GATT_CHARACTERISTIC_DISCOVERED;
-	case BLUETOOTH_EVENT_GATT_CHAR_VAL_CHANGED:
-		return	BT_EVENT_GATT_VALUE_CHANGED;
-	case BLUETOOTH_EVENT_GATT_READ_CHAR:
-		return	BT_EVENT_GATT_READ_CHARACTERISTIC;
-	case BLUETOOTH_EVENT_GATT_WRITE_CHAR:
-		return	BT_EVENT_GATT_WRITE_CHARACTERISTIC;
-	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/mobile/src/bluetooth-device.c b/mobile/src/bluetooth-device.c
deleted file mode 100644
index 3c17967..0000000
--- a/mobile/src/bluetooth-device.c
+++ /dev/null
@@ -1,337 +0,0 @@
-/*
- * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
- *
- * 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"
-
-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) {
-		BT_ERR("%s(0x%08x)", _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) {
-		BT_ERR("%s(0x%08x)", _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) {
-		BT_ERR("%s(0x%08x)", _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) {
-		BT_ERR("%s(0x%08x)", _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) {
-		BT_ERR("%s(0x%08x)", _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) {
-		BT_ERR("%s(0x%08x)", _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) {
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
-	}
-
-	return ret;
-}
-
-int bt_device_foreach_connected_profiles(const char *remote_address, bt_device_connected_profile callback, void *user_data)
-{
-	bluetooth_device_address_t addr_hex = { {0,} };
-	gboolean is_connected = FALSE;
-	int ret;
-	int i = 0;
-	int profiles[] = {BT_PROFILE_RFCOMM, BT_PROFILE_A2DP,
-			BT_PROFILE_HSP, BT_PROFILE_HID, 0};
-
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(remote_address);
-	BT_CHECK_INPUT_PARAMETER(callback);
-
-	_bt_convert_address_to_hex(&addr_hex, remote_address);
-
-	while (profiles[i] != 0) {
-		ret = _bt_get_error_code(bluetooth_is_device_connected(&addr_hex,
-								profiles[i],
-								&is_connected));
-		if (ret != BT_ERROR_NONE) {
-			BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
-			return ret;
-		}
-
-		if (is_connected == TRUE) {
-			if (!callback(profiles[i], user_data))
-				break;
-		}
-
-		i++;
-	}
-
-	return BT_ERROR_NONE;
-}
-
-int bt_device_is_profile_connected(const char *remote_address, bt_profile_e bt_profile,
-				bool *connected_status)
-{
-	bluetooth_device_address_t addr_hex = { {0,} };
-	int ret;
-
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(remote_address);
-
-	_bt_convert_address_to_hex(&addr_hex, remote_address);
-
-	ret = _bt_get_error_code(bluetooth_is_device_connected(&addr_hex, bt_profile,
-								(gboolean *) connected_status));
-
-	if (ret != BT_ERROR_NONE) {
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
-		return ret;
-	}
-
-	return ret;
-
-}
-
-int bt_device_set_bond_created_cb(bt_device_bond_created_cb callback, void *user_data)
-{
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(callback);
-	_bt_set_cb(BT_EVENT_BOND_CREATED, callback, user_data);
-
-	return BT_ERROR_NONE;
-}
-
-int bt_device_set_bond_destroyed_cb(bt_device_bond_destroyed_cb callback, void *user_data)
-{
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(callback);
-	_bt_set_cb(BT_EVENT_BOND_DESTROYED, callback, user_data);
-
-	return BT_ERROR_NONE;
-}
-
-int bt_device_set_authorization_changed_cb(bt_device_authorization_changed_cb callback, void *user_data)
-{
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(callback);
-	_bt_set_cb(BT_EVENT_AUTHORIZATION_CHANGED, callback, user_data);
-
-	return BT_ERROR_NONE;
-}
-
-int bt_device_set_service_searched_cb(bt_device_service_searched_cb callback, void *user_data)
-{
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(callback);
-	_bt_set_cb(BT_EVENT_SERVICE_SEARCHED, callback, user_data);
-
-	return BT_ERROR_NONE;
-}
-
-int bt_device_set_connection_state_changed_cb(bt_device_connection_state_changed_cb callback, void *user_data)
-{
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(callback);
-	_bt_set_cb(BT_EVENT_DEVICE_CONNECTION_STATUS, callback, user_data);
-
-	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_device_unset_connection_state_changed_cb(void)
-{
-	BT_CHECK_INIT_STATUS();
-	_bt_unset_cb(BT_EVENT_DEVICE_CONNECTION_STATUS);
-	return BT_ERROR_NONE;
-}
-
-int bt_device_connect_le(bt_device_gatt_state_changed_cb callback, const char *address)
-{
-	int ret;
-	bluetooth_device_address_t bd_addr = { {0,} };
-
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(address);
-
-	_bt_set_cb(BT_EVENT_GATT_CONNECTION_STATUS, callback, NULL);
-
-	_bt_convert_address_to_hex(&bd_addr, address);
-
-	ret = _bt_get_error_code(bluetooth_connect_le(&bd_addr));
-
-	if (ret != BT_ERROR_NONE) {
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
-	}
-	return ret;
-}
-
-int bt_device_disconnect_le(bt_device_gatt_state_changed_cb callback, const char *address)
-{
-	int ret;
-	bluetooth_device_address_t bd_addr = { {0,} };
-
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(address);
-
-	_bt_convert_address_to_hex(&bd_addr, address);
-
-	_bt_set_cb(BT_EVENT_GATT_CONNECTION_STATUS, callback, NULL);
-
-	ret = _bt_get_error_code(bluetooth_disconnect_le(&bd_addr));
-
-	if (ret != BT_ERROR_NONE) {
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
-	}
-	return ret;
-}
-
-int bt_device_read_rssi_value(const char *address)
-{
-	int ret;
-	bluetooth_device_address_t bd_addr = { {0,} };
-
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(address);
-
-	_bt_convert_address_to_hex(&bd_addr, address);
-
-	ret = _bt_get_error_code(bluetooth_read_rssi(&bd_addr));
-
-	if (ret != BT_ERROR_NONE) {
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
-	}
-	return ret;
-}
diff --git a/mobile/src/bluetooth-gatt.c b/mobile/src/bluetooth-gatt.c
deleted file mode 100644
index 0e50c30..0000000
--- a/mobile/src/bluetooth-gatt.c
+++ /dev/null
@@ -1,330 +0,0 @@
-/*
- * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
- *
- * Licensed under the Apache License, Version 2.0 (the License);
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an AS IS BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <stdbool.h>
-#include <dlog.h>
-#include <bluetooth-api.h>
-
-#include "bluetooth.h"
-#include "bluetooth_private.h"
-
-int bt_gatt_foreach_primary_services(const char *remote_address,
-				bt_gatt_primary_service_cb callback,
-				void *user_data)
-{
-	int i;
-	int ret;
-	bool foreach_call = true;
-	bluetooth_device_address_t addr_hex = { {0,} };
-	bt_gatt_handle_info_t *prim_svc;
-
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(remote_address);
-	BT_CHECK_INPUT_PARAMETER(callback);
-
-	prim_svc = g_new0(bt_gatt_handle_info_t, 1);
-
-	_bt_convert_address_to_hex(&addr_hex, remote_address);
-
-	ret = _bt_get_error_code(bluetooth_gatt_get_primary_services(&addr_hex,
-								prim_svc));
-	if (ret != BT_ERROR_NONE) {
-		BT_ERR("%s(0x%08x) : Failed to run function",
-					_bt_convert_error_to_string(ret), ret);
-		g_free(prim_svc);
-		return ret;
-	}
-
-	for (i = 0; i < prim_svc->count; i++) {
-		if (prim_svc->handle[i] == NULL)
-			continue;
-
-		BT_DBG("handle: %s", prim_svc->handle[i]);
-
-		if (foreach_call == true &&
-		    !callback((bt_gatt_attribute_h)prim_svc->handle[i], user_data)) {
-			foreach_call = false;
-		}
-
-		/* Application should clone the handle using API in callback */
-		/* bt_gatt_clone_attribute_handle */
-		g_free(prim_svc->handle[i]);
-	}
-
-	g_free(prim_svc->handle);
-	g_free(prim_svc);
-
-	return ret;
-}
-
-int bt_gatt_discover_characteristics(bt_gatt_attribute_h service,
-				bt_gatt_characteristics_discovered_cb callback,
-				void *user_data)
-{
-	int ret;
-
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(service);
-	BT_CHECK_INPUT_PARAMETER(callback);
-
-	ret = _bt_get_error_code(bluetooth_gatt_discover_service_characteristics((const char *)service));
-
-	if (ret != BT_ERROR_NONE) {
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
-	} else {
-		_bt_set_cb(BT_EVENT_GATT_CHARACTERISTIC_DISCOVERED, callback, user_data);
-	}
-
-	return ret;
-}
-
-int bt_gatt_get_service_uuid(bt_gatt_attribute_h service, char **uuid)
-{
-	int i;
-	int ret;
-	bt_gatt_service_property_t property;
-
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(service);
-
-	memset(&property, 0x00, sizeof(bt_gatt_service_property_t));
-
-	ret = _bt_get_error_code(bluetooth_gatt_get_service_property((const char *)service, &property));
-
-	if (ret != BT_ERROR_NONE) {
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
-	} else {
-		*uuid = g_strdup(property.uuid);
-
-		if (property.handle_info.count != 0 && property.handle_info.handle) {
-			for (i = 0; i < property.handle_info.count; i++) {
-				g_free(property.handle_info.handle[i]);
-			}
-			g_free(property.handle_info.handle);
-		}
-	}
-
-	return ret;
-}
-
-int bt_gatt_foreach_included_services(bt_gatt_attribute_h service,
-				bt_gatt_included_service_cb callback,
-				void *user_data)
-{
-	int i;
-	int ret;
-	bool foreach_call = true;
-	bt_gatt_service_property_t property;
-
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(service);
-	BT_CHECK_INPUT_PARAMETER(callback);
-
-	memset(&property, 0x00, sizeof(bt_gatt_service_property_t));
-
-	ret = _bt_get_error_code(bluetooth_gatt_get_service_property((const char *)service, &property));
-
-	if (ret != BT_ERROR_NONE) {
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
-	} else {
-		if (property.handle_info.count == 0 ||
-		     property.handle_info.handle == NULL) {
-			return ret;
-		}
-
-		for (i = 0; i < property.handle_info.count; i++) {
-			if (property.handle_info.handle[i] == NULL)
-				continue;
-
-			if (foreach_call == true &&
-			    !callback((bt_gatt_attribute_h)property.handle_info.handle[i],
-					user_data)) {
-				foreach_call = false;
-			}
-
-			g_free(property.handle_info.handle[i]);
-		}
-		g_free(property.handle_info.handle);
-	}
-	return ret;
-}
-
-int bt_gatt_set_characteristic_changed_cb(bt_gatt_attribute_h service,
-				bt_gatt_characteristic_changed_cb callback,
-				void *user_data)
-{
-	int ret;
-
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(service);
-	BT_CHECK_INPUT_PARAMETER(callback);
-
-	ret = _bt_get_error_code(bluetooth_gatt_watch_characteristics((const char *)service));
-
-	if (ret != BT_ERROR_NONE) {
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
-	} else {
-		_bt_set_cb(BT_EVENT_GATT_VALUE_CHANGED, callback, user_data);
-	}
-
-	return ret;
-}
-
-int bt_gatt_unset_characteristic_changed_cb(bt_gatt_attribute_h service)
-{
-	int ret;
-
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(service);
-
-	ret = _bt_get_error_code(bluetooth_gatt_unwatch_characteristics((const char *)service));
-
-	if (ret != BT_ERROR_NONE) {
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
-	} else {
-		_bt_unset_cb(BT_EVENT_GATT_VALUE_CHANGED);
-	}
-
-	return ret;
-}
-
-int bt_gatt_get_characteristic_declaration(bt_gatt_attribute_h characteristic,
-				char **uuid, unsigned char **value,
-				int *value_length)
-{
-	int ret;
-	bt_gatt_char_property_t property;
-
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(characteristic);
-
-	memset(&property, 0x00, sizeof(bt_gatt_char_property_t));
-
-	ret = _bt_get_error_code(bluetooth_gatt_get_characteristics_property((const char *)characteristic, &property));
-
-	if (ret != BT_ERROR_NONE) {
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
-	} else {
-		if (property.uuid) {
-			*uuid = g_strdup(property.uuid);
-			g_free(property.uuid);
-		}
-
-		if (property.val && property.val_len != 0) {
-			*value = g_memdup(property.val, property.val_len);
-			*value_length = property.val_len;
-			g_free(property.val);
-		}
-
-		g_free(property.name);
-
-	}
-
-	return ret;
-}
-
-int bt_gatt_set_characteristic_value(bt_gatt_attribute_h characteristic,
-				const unsigned char *value,
-				int value_length)
-{
-	int ret;
-
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(characteristic);
-	BT_CHECK_INPUT_PARAMETER(value);
-
-	if (value_length <= 0)
-		return BT_ERROR_INVALID_PARAMETER;
-
-	ret = _bt_get_error_code(bluetooth_gatt_set_characteristics_value((const char *)characteristic,
-							(const guint8 *)value, value_length, 0));
-
-	if (ret != BT_ERROR_NONE) {
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
-	}
-
-	return ret;
-}
-
-int bt_gatt_set_characteristic_value_request(bt_gatt_attribute_h characteristic,
-				const unsigned char *value, int value_length,
-				unsigned char request, bt_gatt_characteristic_write_cb callback)
-{
-	int ret;
-
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(characteristic);
-	BT_CHECK_INPUT_PARAMETER(value);
-
-	if (value_length <= 0)
-		return BT_ERROR_INVALID_PARAMETER;
-
-	ret = _bt_get_error_code(bluetooth_gatt_set_characteristics_value((const char *)characteristic,
-							(const guint8 *)value, value_length, request));
-
-	if (ret != BT_ERROR_NONE) {
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
-	} else {
-		_bt_set_cb(BT_EVENT_GATT_WRITE_CHARACTERISTIC, callback, characteristic);
-	}
-
-	return ret;
-}
-
-int bt_gatt_clone_attribute_handle(bt_gatt_attribute_h *clone,
-				bt_gatt_attribute_h origin)
-{
-	int error = BT_ERROR_NONE;
-
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(origin);
-
-	*clone = g_strdup((char *)origin);
-
-	return error;
-}
-
-int bt_gatt_destroy_attribute_handle(bt_gatt_attribute_h handle)
-{
-	int error = BT_ERROR_NONE;
-
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(handle);
-
-	g_free(handle);
-
-	return error;
-}
-
-int bt_gatt_read_characteristic_value(bt_gatt_attribute_h characteristic,
-		bt_gatt_characteristic_read_cb callback)
-{
-	int ret;
-
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(characteristic);
-	BT_CHECK_INPUT_PARAMETER(callback);
-
-	ret = _bt_get_error_code(bluetooth_gatt_read_characteristic_value((const char *)characteristic));
-
-	if (ret != BT_ERROR_NONE) {
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
-	} else {
-		_bt_set_cb(BT_EVENT_GATT_READ_CHARACTERISTIC, callback, NULL);
-	}
-
-	return ret;
-}
diff --git a/mobile/src/bluetooth-hdp.c b/mobile/src/bluetooth-hdp.c
deleted file mode 100644
index 22947a3..0000000
--- a/mobile/src/bluetooth-hdp.c
+++ /dev/null
@@ -1,149 +0,0 @@
-/*
- * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
- *
- * 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"
-
-int bt_hdp_register_sink_app(unsigned short data_type, char **app_id)
-{
-	int error = BT_ERROR_NONE;
-	char *app_handle = NULL;
-
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(app_id);
-	error = bluetooth_hdp_activate(data_type, HDP_ROLE_SINK, HDP_QOS_ANY, &app_handle);
-	error = _bt_get_error_code(error);
-	if (BT_ERROR_NONE != error) {
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error);
-		return error;
-	}
-
-	*app_id = strdup(app_handle);
-	if (*app_id == NULL) {
-		return BT_ERROR_OUT_OF_MEMORY;
-	}
-
-	return BT_ERROR_NONE;
-}
-
-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) {
-		BT_ERR("%s(0x%08x)", _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) {
-		BT_ERR("%s", _bt_convert_error_to_string(BT_ERROR_INVALID_PARAMETER));
-	}
-	error = bluetooth_hdp_send_data(channel, data, size);
-	error = _bt_get_error_code(error);
-	if (BT_ERROR_NONE != error) {
-		BT_ERR("%s(0x%08x)", _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) {
-		BT_ERR("%s(0x%08x)", _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) {
-		BT_ERR("%s(0x%08x)", _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_RECEIVED, 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_RECEIVED) == true)
-		_bt_unset_cb(BT_EVENT_HDP_DATA_RECEIVED);
-	return BT_ERROR_NONE;
-}
diff --git a/mobile/src/bluetooth-hid.c b/mobile/src/bluetooth-hid.c
deleted file mode 100644
index 6d4503a..0000000
--- a/mobile/src/bluetooth-hid.c
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
- * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
- *
- * 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"
-
-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) {
-		BT_ERR("%s(0x%08x)", _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) {
-		BT_ERR("%s(0x%08x)", _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) {
-		BT_ERR("%s(0x%08x)", _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) {
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error);
-	}
-	return error;
-}
diff --git a/mobile/src/bluetooth-opp-client.c b/mobile/src/bluetooth-opp-client.c
deleted file mode 100644
index 5e91927..0000000
--- a/mobile/src/bluetooth-opp-client.c
+++ /dev/null
@@ -1,193 +0,0 @@
-/*
- * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
- *
- * 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"
-
-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++)
-		BT_DBG("file: %s", 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) {
-		BT_ERR("%s(0x%08x)", _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) {
-		BT_ERR("%s(0x%08x)", _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;
-		BT_ERR("%s(0x%08x)", _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) {
-		BT_ERR("%s(0x%08x)", _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) {
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code),
-				error_code);
-	}
-
-	return error_code;
-}
-
diff --git a/mobile/src/bluetooth-opp-server.c b/mobile/src/bluetooth-opp-server.c
deleted file mode 100644
index f6858da..0000000
--- a/mobile/src/bluetooth-opp-server.c
+++ /dev/null
@@ -1,178 +0,0 @@
-/*
- * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
- *
- * 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"
-
-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);
-
-	error_code = _bt_get_error_code(bluetooth_obex_server_init(destination));
-
-	if (error_code != BT_ERROR_NONE) {
-		BT_ERR("%s(0x%08x)", _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);
-
-	error_code = _bt_get_error_code(bluetooth_obex_server_init_without_agent(destination));
-
-	if (error_code != BT_ERROR_NONE) {
-		BT_ERR("%s(0x%08x)", _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) {
-		BT_ERR("%s(0x%08x)", _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) {
-		BT_ERR("%s(0x%08x)", _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) {
-		BT_ERR("%s(0x%08x)", _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) {
-		BT_ERR("%s(0x%08x)", _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) {
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code),
-				error_code);
-	}
-
-	return error_code;
-}
-
diff --git a/mobile/src/bluetooth-socket.c b/mobile/src/bluetooth-socket.c
deleted file mode 100644
index f3e4ec7..0000000
--- a/mobile/src/bluetooth-socket.c
+++ /dev/null
@@ -1,225 +0,0 @@
-/*
- * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
- *
- * 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"
-
-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);
-		BT_ERR("%s(0x%08x)", _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) {
-		BT_ERR("%s(0x%08x)", _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) {
-		BT_ERR("%s(0x%08x)", _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) {
-		BT_ERR("%s(0x%08x)", _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) {
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code),
-				error_code);
-	}
-
-	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) {
-		BT_ERR("%s(0x%08x)", _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) {
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code),
-				error_code);
-	}
-
-	return error_code;
-}
-
-int bt_socket_disconnect_rfcomm(int socket_fd)
-{
-	int error_code = BT_ERROR_NONE;
-
-	BT_CHECK_INIT_STATUS();
-
-	error_code = _bt_get_error_code(bluetooth_rfcomm_disconnect(socket_fd));
-	if (error_code != BT_ERROR_NONE) {
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code),
-				error_code);
-	}
-
-	return error_code;
-}
-
-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) {
-		BT_ERR("OPERATION_FAILED(0x%08x)", BT_ERROR_OPERATION_FAILED);
-		return BT_ERROR_OPERATION_FAILED;
-	}
-
-	ret = _bt_get_error_code(ret);
-	if (ret != BT_ERROR_NONE) {
-		BT_ERR("%s(0x%08x)", _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/mobile/test/CMakeLists.txt b/mobile/test/CMakeLists.txt
deleted file mode 100644
index 7715cac..0000000
--- a/mobile/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/mobile/test/bt_chat_client.c b/mobile/test/bt_chat_client.c
deleted file mode 100644
index 9413372..0000000
--- a/mobile/test/bt_chat_client.c
+++ /dev/null
@@ -1,453 +0,0 @@
-/*
- * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
- *
- * 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/mobile/test/bt_chat_server.c b/mobile/test/bt_chat_server.c
deleted file mode 100644
index 139e6f2..0000000
--- a/mobile/test/bt_chat_server.c
+++ /dev/null
@@ -1,283 +0,0 @@
-/*
- * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
- *
- * 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 (NULL == name)
-			return -1;
-
-		if(strncmp(name, "chat_server", strlen(name)) != 0)
-		{
-			if(bt_adapter_set_name("chat_server") != BT_ERROR_NONE)
-			{
-				if (NULL != name)
-					free(name);
-				LOGE("[%s] bt_adapter_set_name() failed.", __FUNCTION__);
-				return -1;
-			}
-		}
-		free(name);
-	}
-	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, NULL) != 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;
-}
diff --git a/mobile/test/bt_unit_test.c b/mobile/test/bt_unit_test.c
deleted file mode 100644
index 6976008..0000000
--- a/mobile/test/bt_unit_test.c
+++ /dev/null
@@ -1,1431 +0,0 @@
-/*
- * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
- *
- * 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.
- */
-
-/**
- * @file       bt_unit_test.c
- * @brief      This is the source file for capi unit test.
- */
-
-#include <stdio.h>
-#include <string.h>
-#include <glib.h>
-#include <dbus/dbus-glib.h>
-
-#include "bluetooth.h"
-#include "bluetooth-telephony-api.h"
-
-#define BUFFER_LEN 10
-#define MAX_SERVICES 10
-#define PRT(format, args...) printf("%s:%d() "format, __FUNCTION__, __LINE__, ##args)
-#define TC_PRT(format, args...) PRT(format"\n", ##args)
-
-#define DEVICE_ADDRESS "F6:FB:8F:D8:C8:7C"
-const char *spp_uuid = "00001101-0000-1000-8000-00805F9B34FB";
-const char *opp_uuid = "00001105-0000-1000-8000-00805f9b34fb";
-
-static int server_fd;
-static int client_fd;
-
-int service_index;
-int char_service_index;
-
-bt_gatt_attribute_h service_clone[MAX_SERVICES];
-bt_gatt_attribute_h characteristics[MAX_SERVICES];
-bt_gatt_attribute_h characteristics_services[MAX_SERVICES];
-
-static unsigned char *hash = NULL;
-static unsigned char *randomizer = NULL;
-int hash_len;
-int rand_len;
-
-bt_call_list_h call_list;
-GMainLoop *main_loop = NULL;
-
-typedef struct {
-	const char *tc_name;
-	int tc_code;
-} tc_table_t;
-
-tc_table_t tc_table[] = {
-	/* Adapter functions */
-	{"bt_initialize"			, 1},
-	{"bt_deinitialize"			, 2},
-	{"bt_adapter_get_state"			, 3},
-	{"bt_adapter_enable"			, 4},
-	{"bt_adapter_disable"			, 5},
-	{"bt_adapter_start_device_discovery"	, 6},
-	{"bt_adapter_stop_device_discovery"	, 7},
-	{"bt_adapter_is_discovering"		, 8},
-	{"bt_adapter_get_bonded_device_info"	, 9},
-	{"bt_adapter_is_service_used"		, 10},
-	{"bt_adapter_get_visibility"		, 11},
-	{"bt_adapter_set_device_discovery_state_changed_cb"	, 12},
-	{"bt_adapter_unset_device_discovery_state_changed_cb"	, 13},
-	{"bt_adapter_get_local_oob_data" , 14},
-	{"bt_adapter_set_remote_oob_data" , 15},
-	{"bt_adapter_remove_remote_oob_data"	, 16},
-	{"bt_adapter_start_discover_devices"	, 17},
-	{"bt_adapter_set_visibility_mode_changed_cb"    , 18},
-	{"bt_adapter_unset_visibility_mode_changed_cb"  , 19},
-
-
-	/* Socket functions */
-	{"bt_socket_create_rfcomm"		, 50},
-	{"bt_socket_destroy_rfcomm"		, 51},
-	{"bt_socket_listen_and_accept_rfcomm"	, 52},
-	{"bt_socket_listen"			, 53},
-	{"bt_socket_accept"			, 54},
-	{"bt_socket_reject"			, 55},
-	{"bt_socket_connect_rfcomm"		, 56},
-	{"bt_socket_disconnect_rfcomm"		, 57},
-	{"bt_socket_send_data"			, 58},
-	{"bt_socket_set_data_received_cb"	, 59},
-	{"bt_socket_unset_data_received_cb"	, 60},
-	{"bt_socket_set_connection_requested_cb"	, 61},
-	{"bt_socket_unset_connection_requested_cb"	, 62},
-	{"bt_socket_set_connection_state_changed_cb"	, 63},
-	{"bt_socket_unset_connection_state_changed_cb"	, 64},
-
-	/* OPP functions */
-	{"bt_opp_client_initialize"		, 70},
-	{"bt_opp_client_deinitialize"		, 71},
-	{"bt_opp_client_add_file"		, 72},
-	{"bt_opp_client_clear_files"		, 73},
-	{"bt_opp_client_push_files"		, 74},
-	{"bt_opp_client_cancel_push"		, 75},
-
-	/* AG functions */
-	{"bt_audio_initialize"		, 80},
-	{"bt_audio_deinitialize"		, 81},
-	{"bt_audio_connect"		, 82},
-	{"bt_audio_disconnect"		, 83},
-	{"bt_audio_set_connection_state_changed_cb",		84},
-	{"bt_audio_unset_connection_state_changed_cb", 	85},
-	{"bt_ag_open_sco" 		, 86},
-	{"bt_ag_close_sco" 		, 87},
-	{"bt_ag_is_sco_opened"	, 88},
-	{"bt_ag_set_sco_state_changed_cb"	, 89},
-	{"bt_ag_unset_sco_state_changed_cb"	, 90},
-	{"BT_AG_CALL_EVENT_IDLE"		, 91},
-	{"BT_AG_CALL_EVENT_ANSWERED"	, 92},
-	{"BT_AG_CALL_EVENT_DIALING"		, 93},
-	{"BT_AG_CALL_EVENT_ALERTING"	, 94},
-	{"BT_AG_CALL_EVENT_INCOMING"	, 95},
-	{"bt_call_list_create" 			, 96},
-	{"bt_call_list_destroy" 		, 97},
-	{"bt_call_list_reset" 			, 98},
-	{"bt_call_list_add"	 			, 99},
-	{"bt_ag_notify_call_list"			, 100},
-	{"bt_ag_set_call_handling_event_cb"	, 101},
-	{"bt_ag_is_nrec_enabled"	, 102},
-
-	/* Network functions */
-	{"bt_nap_activate"		, 110},
-	{"bt_nap_deactivate"		, 111},
-	{"bt_nap_disconnect_all"	, 112},
-	{"bt_nap_disconnect"            , 113},
-
-	/* Device functions */
-	{"bt_device_set_authorization (true)"	, 120},
-	{"bt_device_set_authorization (false)"	, 121},
-	{"bt_device_set_authorization_changed_cb"	, 122},
-	{"bt_device_unset_authorization_changed_cb"	, 123},
-	{"bt_device_set_connection_state_changed_cb"	, 124},
-	{"bt_device_unset_connection_state_changed_cb"	, 125},
-	{"bt_device_foreach_connected_profiles"	, 126},
-	{"bt_device_set_bond_created_cb" , 127},
-	{"bt_device_create_bond" , 128},
-	{"bt_device_connect_le" , 129},
-	{"bt_device_disconnect_le" , 130},
-	{"bt_device_read_rssi_value" , 131},
-	{"bt_device_is_connected_profiles", 132},
-
-	/* Gatt functions */
-	{"bt_gatt_foreach_primary_services"	, 140},
-	{"bt_gatt_discover_characteristics"	, 141},
-	{"bt_gatt_get_service_uuid"		, 142},
-	{"bt_gatt_foreach_included_services"		, 143},
-	{"bt_gatt_set_characteristic_changed_cb"	, 144},
-	{"bt_gatt_unset_characteristic_changed_cb"	, 145},
-	{"bt_gatt_get_characteristic_declaration"	, 146},
-	{"bt_gatt_set_characteristic_value"	, 147},
-	{"bt_gatt_read_characteristic_value"	 , 148},
-
-	/* AVRCP functions */
-	{"bt_avrcp_target_initialize"	, 160},
-	{"bt_avrcp_target_deinitialize"	, 161},
-	{"bt_avrcp_set_equalizer_state_changed_cb"	, 162},
-	{"bt_avrcp_set_repeat_mode_changed_cb"	, 163},
-	{"bt_avrcp_set_shuffle_mode_changed_cb"	, 164},
-	{"bt_avrcp_set_scan_mode_changed_cb"	, 165},
-	{"bt_avrcp_unset_equalizer_state_changed_cb"	, 166},
-	{"bt_avrcp_unset_repeat_mode_changed_cb"	, 167},
-	{"bt_avrcp_unset_shuffle_mode_changed_cb"	, 168},
-	{"bt_avrcp_unset_scan_mode_changed_cb"	, 169},
-
-	/* -----------------------------------------*/
-	{"Finish"				, 0x00ff},
-	{NULL					, 0x0000},
-};
-
-void tc_usage_print(void)
-{
-	int i = 0;
-
-	while (tc_table[i].tc_name) {
-		if (tc_table[i].tc_code != 0x00ff) {
-			TC_PRT("Key %d : usage %s", tc_table[i].tc_code,
-						tc_table[i].tc_name);
-		} else {
-			TC_PRT("Key %d : usage %s\n\n", 0x00ff,
-						tc_table[i].tc_name);
-		}
-
-		i++;
-	}
-}
-
-static void __bt_free_gatt_services(void)
-{
-	int i;
-
-	for (i = 0; i < service_index; i++) {
-		bt_gatt_destroy_attribute_handle(service_clone[i]);
-		service_clone[i] = NULL;
-	}
-
-	service_index = 0;
-}
-
-static void __bt_free_gatt_characteristics(void)
-{
-	int i;
-
-	for (i = 0; i < MAX_SERVICES; i++) {
-		if (characteristics[i] == NULL)
-			return;
-
-		bt_gatt_destroy_attribute_handle(characteristics[i]);
-		characteristics[i] = NULL;
-	}
-}
-
-static void __bt_free_gatt_characteristics_services(void)
-{
-	int i;
-
-	for (i = 0; i < char_service_index; i++) {
-		bt_gatt_destroy_attribute_handle(characteristics_services[i]);
-		characteristics_services[i] = NULL;
-	}
-	char_service_index = 0;
-}
-
-static void __bt_adapter_device_visibility_mode_changed_cb(int result,
-					bt_adapter_visibility_mode_e visibility_mode,
-					void *user_data)
-{
-       TC_PRT("visibility_mode: %d", visibility_mode);
-}
-
-
-static void __bt_adapter_device_discovery_state_changed_cb(int result,
-				bt_adapter_device_discovery_state_e discovery_state,
-				bt_adapter_device_discovery_info_s *discovery_info,
-				void *user_data)
-{
-	int i;
-
-	TC_PRT("discovery_state: %d", discovery_state);
-
-	if (discovery_info == NULL) {
-		TC_PRT("No discovery_info!");
-		return;
-	}
-
-	TC_PRT("remote_address: %s", discovery_info->remote_address);
-	TC_PRT("remote_name: %s", discovery_info->remote_name);
-	TC_PRT("rssi: %d", discovery_info->rssi);
-	TC_PRT("is_bonded: %d", discovery_info->is_bonded);
-	TC_PRT("service_count: %d", discovery_info->service_count);
-	TC_PRT("device type: %u", discovery_info->device_type);
-
-	if (discovery_info->service_uuid == NULL) {
-		TC_PRT("No uuids");
-		return;
-	}
-
-	for (i = 0; i < discovery_info->service_count; i++) {
-		TC_PRT("uuid: %s", discovery_info->service_uuid[i]);
-	}
-}
-
-static void __bt_socket_data_received_cb(bt_socket_received_data_s *data, void *user_data)
-{
-	TC_PRT("+");
-
-	if (data == NULL) {
-		TC_PRT("No recieved data!");
-		return;
-	}
-
-	TC_PRT("Socket fd: %d", data->socket_fd);
-	TC_PRT("Data: %s", data->data);
-	TC_PRT("Size: %d", data->data_size);
-}
-
-static void __bt_socket_connection_requested_cb(int socket_fd, const char *remote_address, void *user_data)
-{
-	TC_PRT("Socket fd: %d", socket_fd);
-	TC_PRT("remote_address: %s", remote_address);
-}
-
-static void __bt_socket_connection_state_changed_cb(int result,
-				bt_socket_connection_state_e connection_state,
-				bt_socket_connection_s *connection,
-				void *user_data)
-{
-	TC_PRT("result: %d", result);
-	TC_PRT("connection_state: %d", connection_state);
-
-	if (connection == NULL) {
-		TC_PRT("No connection data!");
-		return;
-	}
-
-	TC_PRT("socket fd: %d", connection->socket_fd);
-	TC_PRT("role: %d", connection->local_role);
-	TC_PRT("remote address: %s", connection->remote_address);
-	TC_PRT("service_uuid: %s", connection->service_uuid);
-}
-
-void __bt_opp_client_push_responded_cb(int result,
-					const char *remote_address,
-					void *user_data)
-{
-	TC_PRT("result: %d", result);
-	TC_PRT("remote_address: %s", remote_address);
-}
-
-void __bt_opp_client_push_progress_cb(const char *file,
-					long long size,
-					int percent,
-					void *user_data)
-{
-	TC_PRT("size: %ld", (long)size);
-	TC_PRT("percent: %d", percent);
-	TC_PRT("file: %s", file);
-}
-
-void __bt_opp_client_push_finished_cb(int result,
-				const char *remote_address,
-				void *user_data)
-{
-	TC_PRT("result: %d", result);
-	TC_PRT("remote_address: %s", remote_address);
-}
-
-void __bt_audio_connection_state_changed_cb(int result,
-					bool connected, const char *remote_address,
-					bt_audio_profile_type_e type, void *user_data)
-{
-	TC_PRT("connected [%d]", connected);
-	TC_PRT("address [%s]", remote_address);
-	TC_PRT("type [%d]", type);
-}
-
-void __bt_ag_sco_state_changed_cb(int result, bool opened, void *user_data)
-{
-	TC_PRT("opened [%s]", opened ? "YES" : "NO");
-}
-
-void __bt_ag_set_call_handling_event_cb(bt_ag_call_handling_event_e event,
-					unsigned int call_id, void *user_data)
-{
-	TC_PRT("event[%d] call_id[%d]", event, call_id);
-}
-
-void __bt_device_authorization_changed_cb(bt_device_authorization_e authorization,
-						char *remote_address, void *user_data)
-{
-	TC_PRT("__bt_device_authorization_changed_cb [%d]", authorization);
-	TC_PRT("address: %s", remote_address);
-}
-
-void __bt_device_connection_state_changed_cb(bool connected,
-						const char *remote_address,
-						void *user_data)
-{
-	TC_PRT("__bt_device_authorization_changed_cb [%d]", connected);
-	TC_PRT("address: %s", remote_address);
-}
-
-bool __bt_device_connected_profile(bt_profile_e profile, void *user_data)
-{
-	TC_PRT("__bt_device_connected_profile [%d]", profile);
-	return true;
-}
-
-void __bt_device_le_connection_status_cb(int result, void *user_data)
-{
-	TC_PRT("Callback: LE Conneciton Status %d", result);
-}
-
-void __bt_device_bond_created_cb(int result, bt_device_info_s *device_info, void *user_data)
-{
-	if(result == BT_ERROR_NONE)
-	{
-		TC_PRT("Callback: A bond with chat_server is created.");
-		TC_PRT("Callback: The number of service - %d.", device_info->service_count);
-
-		int i = 0;
-		for(i=0; i<device_info->service_count; i++)
-		{
-			TC_PRT("Callback: service[%d] - %s", i+1, device_info->service_uuid[i]);
-		}
-		TC_PRT("Callback: is_bonded - %d.", device_info->is_bonded);
-		TC_PRT("Callback: is_connected - %d.", device_info->is_connected);
-	}
-	else
-	{
-		TC_PRT("Callback: Creating a bond is failed.");
-	}
-}
-bool __bt_gatt_primary_service_cb(bt_gatt_attribute_h service, void *user_data)
-{
-	TC_PRT("__bt_gatt_primary_service_cb");
-	TC_PRT("service %s", (char *)service);
-	if (service_index >= MAX_SERVICES)
-		return true;
-
-	bt_gatt_clone_attribute_handle(&service_clone[service_index], service);
-	service_index++;
-	return true;
-}
-
-bool __bt_gatt_characteristics_discovered_cb(int result, int index, int total, bt_gatt_attribute_h characteristic, void *user_data)
-{
-	TC_PRT("__bt_gatt_characteristics_discovered_cb: %d", result);
-	TC_PRT("index %d", index);
-	TC_PRT("total %d", total);
-	TC_PRT("characteristic %s", (char *)characteristic);
-
-	if (index >= MAX_SERVICES)
-		return true;
-
-	bt_gatt_clone_attribute_handle(&characteristics[index], characteristic);
-	return true;
-}
-
-bool __bt_gatt_included_service_cb(bt_gatt_attribute_h service, void *user_data)
-{
-	char *uuid = NULL;
-	unsigned char *value = NULL;
-	int value_length = 0;
-
-	TC_PRT("__bt_gatt_included_service_cb");
-	TC_PRT("service %s", (char *)service);
-
-	if (char_service_index >= MAX_SERVICES)
-		return true;
-
-	bt_gatt_clone_attribute_handle(&characteristics_services[char_service_index], service);
-	char_service_index++;
-
-	bt_gatt_get_characteristic_declaration(service, &uuid, &value, &value_length);
-	TC_PRT("uuid %s", uuid);
-	return true;
-}
-
-void __bt_gatt_characteristic_changed_cb(bt_gatt_attribute_h characteristic, unsigned char *value, int value_length, void *user_data)
-{
-	int i;
-
-	TC_PRT("__bt_gatt_characteristic_changed_cb");
-	TC_PRT("service %s", (char *)characteristic);
-	TC_PRT("value_length %d", value_length);
-
-	for (i = 0; i < value_length; i++) {
-		TC_PRT("value %c", value[i]);
-	}
-
-	return;
-}
-
-void __bt_gatt_char_write_cb(bt_gatt_attribute_h handle)
-{
-	TC_PRT("__bt_gatt_char_write_cb");
-	return;
-}
-
-void __bt_gatt_char_read_cb(bt_gatt_attribute_h handle, unsigned char *value, int value_length, void *user_data)
-{
-	int i;
-
-	TC_PRT("__bt_gatt_char_read_cb");
-
-        TC_PRT("value_length %d", value_length);
-
-        for (i = 0; i < value_length; i++) {
-                TC_PRT("value %c", value[i]);
-        }
-
-	return;
-}
-
-void __bt_avrcp_target_connection_state_changed_cb(bool connected, const char *remote_address, void *user_data)
-{
-	TC_PRT("__bt_avrcp_target_connection_state_changed_cb");
-	TC_PRT("connected %d", connected);
-	TC_PRT("remote_address %s", remote_address);
-}
-
-void __bt_avrcp_equalizer_state_changed_cb(bt_avrcp_equalizer_state_e equalizer, void *user_data)
-{
-	TC_PRT("__bt_avrcp_equalizer_state_changed_cb");
-	TC_PRT("equalizer %d", equalizer);
-}
-
-void __bt_avrcp_repeat_mode_changed_cb(bt_avrcp_repeat_mode_e repeat, void *user_data)
-{
-	TC_PRT("__bt_avrcp_repeat_mode_changed_cb");
-	TC_PRT("repeat %d", repeat);
-}
-
-void __bt_avrcp_shuffle_mode_changed_cb(bt_avrcp_shuffle_mode_e shuffle, void *user_data)
-{
-	TC_PRT("__bt_avrcp_shuffle_mode_changed_cb");
-	TC_PRT("shuffle %d", shuffle);
-}
-
-void __bt_avrcp_scan_mode_changed_cb(bt_avrcp_scan_mode_e scan, void *user_data)
-{
-	TC_PRT("__bt_avrcp_scan_mode_changed_cb");
-	TC_PRT("equalizer %d", scan);
-}
-
-int test_input_callback(void *data)
-{
-	int ret = 0;
-	long test_id = (long)data;
-
-	switch (test_id) {
-	case 0x00ff:
-		TC_PRT("Finished");
-		g_main_loop_quit(main_loop);
-		break;
-
-	case 1:
-		ret = bt_initialize();
-		if (ret < BT_ERROR_NONE)
-			TC_PRT("failed with [0x%04x]", ret);
-		break;
-	case 2:
-		ret = bt_deinitialize();
-		if (ret < BT_ERROR_NONE)
-			TC_PRT("failed with [0x%04x]", ret);
-		break;
-	case 3: {
-		bt_adapter_state_e state = BT_ADAPTER_DISABLED;
-
-		ret = bt_adapter_get_state(&state);
-		if (ret < BT_ERROR_NONE)
-			TC_PRT("failed with [0x%04x]", ret);
-
-		TC_PRT("state: %d", state);
-		break;
-	}
-	case 4:
-		ret = bt_adapter_enable();
-		if (ret < BT_ERROR_NONE)
-			TC_PRT("failed with [0x%04x]", ret);
-		break;
-	case 5:
-		ret = bt_adapter_disable();
-		if (ret < BT_ERROR_NONE)
-			TC_PRT("failed with [0x%04x]", ret);
-		break;
-	case 6:
-		ret = bt_adapter_start_device_discovery();
-		if (ret < BT_ERROR_NONE)
-			TC_PRT("failed with [0x%04x]", ret);
-		break;
-	case 7:
-		ret = bt_adapter_stop_device_discovery();
-		if (ret < BT_ERROR_NONE)
-			TC_PRT("failed with [0x%04x]", ret);
-		break;
-	case 8: {
-		bool is_discovering = FALSE;
-		ret = bt_adapter_is_discovering(&is_discovering);
-		if (ret < BT_ERROR_NONE)
-			TC_PRT("failed with [0x%04x]", ret);
-		else
-			TC_PRT("is_discovering: %d", is_discovering);
-
-		break;
-	}
-	case 9: {
-		char *address;
-		bt_device_info_s *device_info = NULL;
-
-		address = g_strdup("00:19:0E:01:61:17");
-
-		ret = bt_adapter_get_bonded_device_info((const char *)address,
-							&device_info);
-		if (ret < BT_ERROR_NONE)
-			TC_PRT("failed with [0x%04x]", ret);
-
-		g_free(address);
-
-		if (device_info) {
-			TC_PRT("address: %s", device_info->remote_address);
-			TC_PRT("name: %s", device_info->remote_name);
-		}
-
-		bt_adapter_free_device_info(device_info);
-		break;
-	}
-	case 10: {
-		bool used = FALSE;
-
-		ret = bt_adapter_is_service_used(opp_uuid, &used);
-		if (ret < BT_ERROR_NONE)
-			TC_PRT("failed with [0x%04x]", ret);
-
-		TC_PRT("used: %d", used);
-		break;
-	}
-	case 11: {
-		bt_adapter_visibility_mode_e visibility_mode = BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE;
-		int time = 0;
-
-		ret = bt_adapter_get_visibility(&visibility_mode, &time);
-		if (ret < BT_ERROR_NONE)
-			TC_PRT("failed with [0x%04x]", ret);
-
-		TC_PRT("mode: %d", visibility_mode);
-		TC_PRT("time: %d", time);
-		break;
-	}
-	case 12:
-		ret = bt_adapter_set_device_discovery_state_changed_cb(__bt_adapter_device_discovery_state_changed_cb, NULL);
-		if (ret < BT_ERROR_NONE)
-			TC_PRT("failed with [0x%04x]", ret);
-		break;
-	case 13:
-		ret = bt_adapter_unset_device_discovery_state_changed_cb();
-		if (ret < BT_ERROR_NONE)
-			TC_PRT("failed with [0x%04x]", ret);
-		break;
-
-	case 14: {
-		ret = bt_adapter_get_local_oob_data(&hash, &randomizer, &hash_len, &rand_len);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		} else {
-			TC_PRT("hash = [%s]", hash);
-			TC_PRT("randomizer = [%s]", randomizer);
-		}
-		break;
-	}
-
-	case 15: {
-		char *address;
-
-		address = g_strdup("00:02:18:2F:78:32");
-
-		TC_PRT("remote address = [%s]", address);
-
-		ret = bt_adapter_set_remote_oob_data(address, hash, randomizer, hash_len, rand_len);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	}
-
-	case 16: {
-		char *address;
-
-		address = g_strdup("00:02:18:2F:78:32");
-
-		TC_PRT("remote address = [%s]", address);
-
-		ret = bt_adapter_remove_remote_oob_data(address);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	}
-
-	case 17: {
-		ret = bt_adapter_start_discover_devices(BT_ADAPTER_DEVICE_DISCOVERY_BREDR);
-		if (ret < BT_ERROR_NONE)
-			TC_PRT("failed with [0x%04x]", ret);
-		break;
-	}
-
-	case 18:
-		ret = bt_adapter_set_visibility_mode_changed_cb(__bt_adapter_device_visibility_mode_changed_cb, NULL);
-		if (ret < BT_ERROR_NONE)
-			TC_PRT("failed with [0x%04x]", ret);
-		break;
-	case 19:
-			ret = bt_adapter_unset_visibility_mode_changed_cb();
-		if (ret < BT_ERROR_NONE)
-			TC_PRT("failed with [0x%04x]", ret);
-		break;
-
-
-	/* Socket functions */
-	case 50: {
-		int socket_fd = 0;
-
-		ret = bt_socket_create_rfcomm(spp_uuid, &socket_fd);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		} else {
-			TC_PRT("socket_fd: %d", socket_fd);
-			server_fd = socket_fd;
-		}
-		break;
-	}
-	case 51:
-		ret = bt_socket_destroy_rfcomm(server_fd);
-		if (ret < BT_ERROR_NONE)
-			TC_PRT("failed with [0x%04x]", ret);
-		break;
-	case 52:
-		ret = bt_socket_listen_and_accept_rfcomm(server_fd, 1);
-		if (ret < BT_ERROR_NONE)
-			TC_PRT("failed with [0x%04x]", ret);
-		break;
-	case 53:
-		ret = bt_socket_listen(server_fd, 1);
-		if (ret < BT_ERROR_NONE)
-			TC_PRT("failed with [0x%04x]", ret);
-		break;
-	case 54: {
-		int socket_fd = 0;
-
-		ret = bt_socket_accept(server_fd, &socket_fd);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		} else {
-			TC_PRT("socket_fd: %d", socket_fd);
-			client_fd = socket_fd;
-		}
-		break;
-	}
-	case 55:
-		ret = bt_socket_reject(server_fd);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 56: {
-		char *address;
-
-		address = g_strdup("00:02:48:F4:3E:D2");
-
-		ret = bt_socket_connect_rfcomm(address, spp_uuid);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-
-		g_free(address);
-		break;
-	}
-	case 57:
-		ret = bt_socket_disconnect_rfcomm(client_fd);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 58:
-		ret = bt_socket_send_data(client_fd, "Sending test\0", 20);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 59:
-		ret = bt_socket_set_data_received_cb(__bt_socket_data_received_cb, NULL);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 60:
-		ret = bt_socket_unset_data_received_cb();
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 61:
-		ret = bt_socket_set_connection_requested_cb(__bt_socket_connection_requested_cb, NULL);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 62:
-		ret = bt_socket_unset_connection_requested_cb();
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 63:
-		ret = bt_socket_set_connection_state_changed_cb(__bt_socket_connection_state_changed_cb, NULL);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 64:
-		ret = bt_socket_unset_connection_state_changed_cb();
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 70:
-		ret = bt_opp_client_initialize();
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 71:
-		ret = bt_opp_client_deinitialize();
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 72:
-		ret = bt_opp_client_add_file("/opt/media/Images/image1.jpg");
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 73:
-		ret = bt_opp_client_clear_files();
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 74: {
-		char *address;
-
-		address = g_strdup("00:02:37:A9:17:9E");
-
-		ret = bt_opp_client_push_files(address,__bt_opp_client_push_responded_cb,
-					__bt_opp_client_push_progress_cb,
-					__bt_opp_client_push_finished_cb,
-					NULL);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	}
-	case 75:
-		ret = bt_opp_client_cancel_push();
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-
-	case 80:
-		ret = bt_audio_initialize();
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 81:
-		ret = bt_audio_deinitialize();
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 82: {
-		char *address;
-		address = g_strdup("11:11:22:33:33:33");
-
-		ret = bt_audio_connect(address,  BT_AUDIO_PROFILE_TYPE_HSP_HFP);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	}
-	case 83: {
-		char *address;
-		address = g_strdup("11:11:22:33:33:33");
-
-		ret = bt_audio_disconnect(address,  BT_AUDIO_PROFILE_TYPE_HSP_HFP);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	}
-	case 84:
-		ret = bt_audio_set_connection_state_changed_cb(
-					__bt_audio_connection_state_changed_cb, NULL);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 85:
-		ret = bt_audio_unset_connection_state_changed_cb();
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 86:
-		ret = bt_ag_open_sco();
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 87:
-		ret = bt_ag_close_sco();
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 88: {
-		bool opened = false;
-		ret = bt_ag_is_sco_opened(&opened);
-		TC_PRT("opend[%s]", opened ? "YES" : "NO");
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	}
-	case 89:
-		ret = bt_ag_set_sco_state_changed_cb(__bt_ag_sco_state_changed_cb, NULL);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 90:
-		ret = bt_ag_unset_sco_state_changed_cb();
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 91: {
-		unsigned int call_id = 1;
-
-		ret = bt_ag_notify_call_event(BT_AG_CALL_EVENT_IDLE, call_id, NULL);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	}
-	case 92: {
-		unsigned int call_id = 1;
-		bool sco_required = true;
-
-		ret = bt_ag_notify_call_event(BT_AG_CALL_EVENT_ANSWERED, call_id, NULL);
-		if (sco_required)
-			bt_ag_open_sco();
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	}
-	case 93: {
-		unsigned int call_id = 1;
-		bool sco_required = TRUE;
-		const char *phone_number;
-
-		phone_number = g_strdup("01046500173");
-		ret = bt_ag_notify_call_event(BT_AG_CALL_EVENT_DIALING,
-					call_id, phone_number);
-		if (sco_required)
-			bt_ag_open_sco();
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	}
-	case 94: {
-		unsigned int call_id = 1;
-
-		ret = bt_ag_notify_call_event(BT_AG_CALL_EVENT_ALERTING,
-					call_id, NULL);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	}
-	case 95: {
-		unsigned int call_id = 1;
-		const char *phone_number;
-
-		phone_number = g_strdup("01046500173");
-		ret = bt_ag_notify_call_event(BT_AG_CALL_EVENT_INCOMING,
-					call_id, phone_number);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	}
-	case 96:
-		ret = bt_call_list_create(&call_list);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 97:
-		ret = bt_call_list_destroy(call_list);
-		call_list = NULL;
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 98:
-		ret = bt_call_list_reset(call_list);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 99:
-		ret = bt_call_list_add(call_list, 1, BT_AG_CALL_STATE_ACTIVE);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 100:
-		ret = bt_ag_notify_call_list(call_list);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 101:
-		ret = bt_ag_set_call_handling_event_cb(
-					__bt_ag_set_call_handling_event_cb, NULL);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 102: {
-		bool enabled = false;
-		ret = bt_ag_is_nrec_enabled(&enabled);
-		TC_PRT("opend[%s]", enabled ? "YES" : "NO");
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	}
-	case 110:
-		ret = bt_nap_activate();
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-
-	case 111:
-		ret = bt_nap_deactivate();
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-
-	case 112:
-		ret = bt_nap_disconnect_all();
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-
-	case 113: {
-		char *address;
-
-		address = g_strdup("00:1B:66:01:23:1C");
-
-		ret = bt_nap_disconnect(address);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	}
-
-	case 120: {
-		char *address;
-
-		address = g_strdup("00:1B:66:01:23:1C");
-
-		ret = bt_device_set_authorization(address, BT_DEVICE_AUTHORIZED);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	}
-	case 121: {
-		char *address;
-
-		address = g_strdup("00:1B:66:01:23:1C");
-
-		ret = bt_device_set_authorization(address, BT_DEVICE_UNAUTHORIZED);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	}
-	case 122:
-		ret = bt_device_set_authorization_changed_cb(__bt_device_authorization_changed_cb, NULL);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-
-	case 123:
-		ret = bt_device_unset_authorization_changed_cb();
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-
-	case 124:
-		ret = bt_device_set_connection_state_changed_cb(__bt_device_connection_state_changed_cb, NULL);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-
-	case 125:
-		ret = bt_device_unset_connection_state_changed_cb();
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-
-	case 126: {
-		char *address;
-
-		address = g_strdup("00:1B:66:01:23:1C");
-
-		ret = bt_device_foreach_connected_profiles(address, __bt_device_connected_profile, NULL);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	}
-
-	case 127 : {
-		ret = bt_device_set_bond_created_cb(__bt_device_bond_created_cb,
-			NULL);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	}
-
-	case 128 : {
-		char *address;
-
-		address = g_strdup(DEVICE_ADDRESS);
-
-		ret = bt_device_create_bond(address);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	}
-
-	case 129 : {
-		char *address;
-
-		address = g_strdup(DEVICE_ADDRESS);
-		ret = bt_device_connect_le(__bt_device_le_connection_status_cb, address);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	}
-
-	case 130 : {
-		char *address;
-
-		address = g_strdup(DEVICE_ADDRESS);
-
-		ret = bt_device_disconnect_le(__bt_device_le_connection_status_cb,address);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	}
-	case 131 : {
-		char *address;
-		address = g_strdup(DEVICE_ADDRESS);
-		ret = bt_device_read_rssi_value(address);
-		if (ret < BT_ERROR_NONE)
-			TC_PRT("failed with [0x%04x]", ret);
-		break;
-	}
-
-	case 132 : {
-		char *address;
-		int i = 0;
-		bool is_connected_state = false;
-		address = g_strdup("D8:57:EF:C1:F4:ED");
-
-		int bt_profile[] = {BT_PROFILE_RFCOMM, BT_PROFILE_A2DP,
-			BT_PROFILE_HSP, BT_PROFILE_HID, BT_PROFILE_NAP, 0};
-
-		while (bt_profile[i] != 0) {
-			ret = bt_device_is_profile_connected(address, bt_profile[i],
-							&is_connected_state);
-
-			if (ret < BT_ERROR_NONE) {
-				TC_PRT("failed with [0x%04x]", ret);
-			} else {
-				TC_PRT("is_connected_state : [%d]", is_connected_state);
-			}
-			i++;
-		}
-		g_free(address);
-		break;
-	}
-
-	case 140: {
-		char *address;
-
-		address = g_strdup("D5:FE:81:38:39:B9");
-
-		__bt_free_gatt_services();
-
-		ret = bt_gatt_foreach_primary_services(address, __bt_gatt_primary_service_cb, NULL);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	}
-
-	case 141: {
-		__bt_free_gatt_characteristics();
-
-		ret = bt_gatt_discover_characteristics(service_clone[1], __bt_gatt_characteristics_discovered_cb, NULL);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	}
-
-	case 142: {
-		char *uuid = NULL;
-
-		ret = bt_gatt_get_service_uuid(service_clone[1], &uuid);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		} else {
-			TC_PRT("uuid: %s", uuid);
-			g_free(uuid);
-		}
-		break;
-	}
-
-	case 143: {
-		__bt_free_gatt_characteristics_services();
-
-		ret = bt_gatt_foreach_included_services(service_clone[1], __bt_gatt_included_service_cb, NULL);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	}
-
-	case 144: {
-		ret = bt_gatt_set_characteristic_changed_cb(service_clone[1], __bt_gatt_characteristic_changed_cb, NULL);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	}
-
-	case 145: {
-		ret = bt_gatt_unset_characteristic_changed_cb(service_clone[1]);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	}
-
-	case 146: {
-		int i;
-		char *uuid = NULL;
-		unsigned char *value = NULL;
-		int value_length = 0;
-
-		ret = bt_gatt_get_characteristic_declaration(characteristics_services[0], &uuid, &value, &value_length);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		} else {
-			TC_PRT("uuid: %s", uuid);
-
-			for (i = 0; i < value_length; i++) {
-				TC_PRT("value %c", value[i]);
-			}
-
-			g_free(uuid);
-			g_free(value);
-		}
-		break;
-	}
-
-	case 147: {
-		unsigned char value[5] = { 0, 1, 2, 3, 4 };
-
-		ret = bt_gatt_set_characteristic_value_request(characteristics_services[0], value, 5, 1,
-				__bt_gatt_char_write_cb);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	}
-
-	case 148 : {
-		ret = bt_gatt_read_characteristic_value(characteristics_services[0], __bt_gatt_char_read_cb);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	}
-
-	case 160:
-		ret = bt_avrcp_target_initialize(__bt_avrcp_target_connection_state_changed_cb, NULL);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-
-	case 161:
-		ret = bt_avrcp_target_deinitialize();
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-
-	case 162:
-		ret = bt_avrcp_set_equalizer_state_changed_cb(__bt_avrcp_equalizer_state_changed_cb, NULL);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-
-	case 163:
-		ret = bt_avrcp_set_repeat_mode_changed_cb(__bt_avrcp_repeat_mode_changed_cb, NULL);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-
-	case 164:
-		ret = bt_avrcp_set_shuffle_mode_changed_cb(__bt_avrcp_shuffle_mode_changed_cb, NULL);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-
-	case 165:
-		ret = bt_avrcp_set_scan_mode_changed_cb(__bt_avrcp_scan_mode_changed_cb, NULL);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-
-	case 166:
-		ret = bt_avrcp_unset_equalizer_state_changed_cb();
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-
-	case 167:
-		ret = bt_avrcp_unset_repeat_mode_changed_cb();
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-
-	case 168:
-		ret = bt_avrcp_unset_shuffle_mode_changed_cb();
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 169:
-		ret = bt_avrcp_unset_scan_mode_changed_cb();
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	default:
-		break;
-	}
-
-	return 0;
-}
-
-static gboolean key_event_cb(GIOChannel *chan,
-				GIOCondition cond,
-				gpointer data)
-{
-	char buf[BUFFER_LEN] = { 0 };
-
-	gsize len = 0;
-	long test_id;
-
-	memset(buf, 0, sizeof(buf));
-
-	if (g_io_channel_read_chars(chan, buf, sizeof(buf),
-				&len, NULL) == G_IO_STATUS_ERROR) {
-		TC_PRT("IO Channel read error");
-		return FALSE;
-	}
-
-	TC_PRT("%s", buf);
-	tc_usage_print();
-
-	test_id = atoi(buf);
-
-	if (test_id)
-		g_idle_add(test_input_callback, (void *)test_id);
-
-	return TRUE;
-}
-
-int main()
-{
-	GIOChannel *key_io;
-
-#if !GLIB_CHECK_VERSION(2,35,0)
-	g_type_init();
-#endif
-
-	key_io = g_io_channel_unix_new(fileno(stdin));
-
-	g_io_channel_set_encoding(key_io, NULL, NULL);
-	g_io_channel_set_flags(key_io, G_IO_FLAG_NONBLOCK, NULL);
-
-	g_io_add_watch(key_io, G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
-			key_event_cb, NULL);
-
-	g_io_channel_unref(key_io);
-
-	main_loop = g_main_loop_new(NULL, FALSE);
-
-	g_main_loop_run(main_loop);
-
-	bt_deinitialize();
-
-	return 0;
-}
diff --git a/packaging/capi-network-bluetooth.spec b/packaging/capi-network-bluetooth.spec
index 10a18b3..7d74f2e 100644
--- a/packaging/capi-network-bluetooth.spec
+++ b/packaging/capi-network-bluetooth.spec
@@ -1,7 +1,7 @@
 #sbs-git:slp/api/bluetooth capi-network-bluetooth 0.1.0 686c444083e4197845c768e5dd034022b1dfa250
 Name:       capi-network-bluetooth
 Summary:    Network Bluetooth Framework
-Version:    0.1.40
+Version:    0.1.52
 Release:    1
 Group:      TO_BE/FILLED_IN
 License:    Apache License, Version 2.0
@@ -15,6 +15,9 @@ BuildRequires:  pkgconfig(glib-2.0)
 BuildRequires:  pkgconfig(vconf)
 BuildRequires:  pkgconfig(bluetooth-api)
 BuildRequires:  pkgconfig(capi-base-common)
+%if "%{?tizen_profile_name}" == "wearable"
+BuildRequires:  pkgconfig(privacy-manager-client)
+%endif
 
 BuildRequires:  cmake
 
@@ -30,68 +33,79 @@ Requires:   %{name} = %{version}-%{release}
 %description devel
 Network Bluetooth Framework (DEV).
 
+%package test
+Summary: Network Bluetooth Framework test application
+Group:   TO_BE/FILLED
+Requires: %{name} = %{version}-%{release}
+
+%description test
+This package is C-API test application.
+
 %prep
 %setup -q
 
 %build
-%if %{_repository}=="wearable"
-%if 0%{?tizen_build_binary_release_type_eng}
+%if "%{?tizen_profile_name}" == "wearable"
+export CFLAGS="$CFLAGS -DTIZEN_WEARABLE"
+export CXXFLAGS="$CXXFLAGS -DTIZEN_WEARABLE"
+export FFLAGS="$FFLAGS -DTIZEN_WEARABLE"
+%endif
+
+#%if 0%{?sec_build_binary_debug_enable}
+export CFLAGS="$CFLAGS -DTIZEN_DEBUG_ENABLE"
+export CXXFLAGS="$CXXFLAGS -DTIZEN_DEBUG_ENABLE"
+export FFLAGS="$FFLAGS -DTIZEN_DEBUG_ENABLE"
+#%endif
+
+#%if 0%{?tizen_build_binary_release_type_eng}
 export CFLAGS="$CFLAGS -DTIZEN_ENGINEER_MODE"
 export CXXFLAGS="$CXXFLAGS -DTIZEN_ENGINEER_MODE"
 export FFLAGS="$FFLAGS -DTIZEN_ENGINEER_MODE"
+#%endif
+
+%if "%{?tizen_profile_name}" == "wearable"
+export CFLAGS+=" -DTELEPHONY_DISABLED"
+export CXXFLAGS+=" -DTELEPHONY_DISABLED"
+export FFLAGS+=" -DTELEPHONY_DISABLED"
 %endif
-%endif
-MAJORVER=`echo %{version} | awk 'BEGIN {FS="."}{print $1}'`
 
-%if %{_repository}=="wearable"
-cd wearable
-cmake . -DCMAKE_INSTALL_PREFIX=%{_prefix} -DFULLVER=%{version} -DMAJORVER=${MAJORVER}
-%elseif %{_repository}=="mobile"
-cd mobile
-%cmake . -DFULLVER=%{version} -DMAJORVER=${MAJORVER}
+%cmake \
+%if "%{?tizen_profile_name}" == "wearable"
+	-DTIZEN_WEARABLE=YES \
+%elseif "%{?tizen_profile_name}" == "mobile"
+	-DTIZEN_WEARABLE=NO \
 %endif
 
+MAJORVER=`echo %{version} | awk 'BEGIN {FS="."}{print $1}'`
+cmake . -DCMAKE_INSTALL_PREFIX=/usr -DFULLVER=%{version} -DMAJORVER=${MAJORVER}
+
 make %{?jobs:-j%jobs}
 
 %install
 rm -rf %{buildroot}
-
-%if %{_repository}=="wearable"
-cd wearable
-%elseif %{_repository}=="mobile"
-cd mobile
-%endif
-
 %make_install
-%if %{_repository}=="wearable"
-install -D -m 0644 LICENSE.APLv2 %{buildroot}%{_datadir}/license/capi-network-bluetooth
-install -D -m 0644 LICENSE.APLv2 %{buildroot}%{_datadir}/license/capi-network-bluetooth-devel
-%elseif %{_repository}=="mobile"
-mkdir -p %{buildroot}/usr/share/license
-cp LICENSE.APLv2 %{buildroot}/usr/share/license/%{name}
-%endif
+install -D -m 0644 LICENSE %{buildroot}%{_datadir}/license/capi-network-bluetooth
+install -D -m 0644 LICENSE %{buildroot}%{_datadir}/license/capi-network-bluetooth-devel
 
 %post -p /sbin/ldconfig
 
 %postun -p /sbin/ldconfig
 
 %files
-%if %{_repository}=="wearable"
-%manifest wearable/bluetooth.manifest
+%manifest bluetooth.manifest
 %{_libdir}/libcapi-network-bluetooth.so.*
 %{_datadir}/license/capi-network-bluetooth
+
+%files test
+%manifest bluetooth-test.manifest
 %{_bindir}/bt_unit_test
-%elseif %{_repository}=="mobile"
-%manifest wearable/bluetooth.manifest
-%{_libdir}/libcapi-network-bluetooth.so.*
-/usr/share/license/%{name}
-%endif
+%{_bindir}/bt_onoff
+/etc/smack/accesses.d/capi-network-bluetooth-test.efl
 
 %files devel
 %{_includedir}/network/bluetooth.h
+%{_includedir}/network/bluetooth_type.h
 %{_libdir}/pkgconfig/capi-network-bluetooth.pc
 %{_libdir}/libcapi-network-bluetooth.so
-%if %{_repository}=="wearable"
 %{_datadir}/license/capi-network-bluetooth-devel
-%endif
 
diff --git a/wearable/src/bluetooth-adapter.c b/src/bluetooth-adapter.c
index f156085..2cc9cb1 100755..100644
--- a/wearable/src/bluetooth-adapter.c
+++ b/src/bluetooth-adapter.c
@@ -21,6 +21,9 @@
 #include <dlog.h>
 #include <stdio.h>
 #include <stdbool.h>
+#ifdef TIZEN_WEARABLE
+#include <privacy_checker_client.h>
+#endif
 #include <bluetooth-api.h>
 
 #include "bluetooth.h"
@@ -29,6 +32,17 @@
 int bt_adapter_enable(void)
 {
 	int error_code = BT_ERROR_NONE;
+#ifdef TIZEN_WEARABLE
+	static const char* PRIVILEGE_ID_BLUETOOTH_ADMIN = "http://tizen.org/privilege/bluetooth.admin";
+
+	error_code =  privacy_checker_check_by_privilege(PRIVILEGE_ID_BLUETOOTH_ADMIN);
+	if (error_code != PRIV_MGR_ERROR_SUCCESS) {
+		privacy_checker_finalize();
+		BT_ERR("PERMISSION_DENIED(0x%08x)", error_code);
+		return BT_ERROR_PERMISSION_DENIED;
+	}
+	privacy_checker_finalize();
+#endif
 
 	BT_CHECK_INIT_STATUS();
 	error_code = _bt_get_error_code(bluetooth_enable_adapter());
@@ -50,6 +64,18 @@ int bt_adapter_disable(void)
 	return error_code;
 }
 
+int bt_adapter_recover(void)
+{
+	int error_code = BT_ERROR_NONE;
+
+	BT_CHECK_INIT_STATUS();
+	error_code = _bt_get_error_code(bluetooth_recover_adapter());
+	if (error_code != BT_ERROR_NONE) {
+		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code);
+	}
+	return error_code;
+}
+
 int bt_adapter_reset(void)
 {
 	int error_code = BT_ERROR_NONE;
@@ -71,6 +97,38 @@ int bt_adapter_get_state(bt_adapter_state_e *adapter_state)
 	return BT_ERROR_NONE;
 }
 
+int bt_adapter_le_enable(void)
+{
+	int error_code = BT_ERROR_NONE;
+
+	BT_CHECK_INIT_STATUS();
+	error_code = _bt_get_error_code(bluetooth_enable_adapter_le());
+	if (error_code != BT_ERROR_NONE) {
+		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code);
+	}
+	return error_code;
+}
+
+int bt_adapter_le_disable(void)
+{
+	int error_code = BT_ERROR_NONE;
+
+	BT_CHECK_INIT_STATUS();
+	error_code = _bt_get_error_code(bluetooth_disable_adapter_le());
+	if (error_code != BT_ERROR_NONE) {
+		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code);
+	}
+	return error_code;
+}
+
+int bt_adapter_le_get_state(bt_adapter_le_state_e *adapter_le_state)
+{
+	BT_CHECK_INPUT_PARAMETER(adapter_le_state);
+
+	*adapter_le_state = bluetooth_check_adapter_le();
+	return BT_ERROR_NONE;
+}
+
 int bt_adapter_get_address(char **address)
 {
 	bluetooth_device_address_t loc_address = { {0} };
@@ -94,6 +152,225 @@ int bt_adapter_get_address(char **address)
 	return BT_ERROR_NONE;
 }
 
+int bt_adapter_get_version(char **version)
+{
+	int ret = BT_ERROR_NONE;
+	bluetooth_version_t loc_ver = { { 0 } };
+
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(version);
+
+	ret = _bt_get_error_code(bluetooth_get_local_version(&loc_ver));
+	if (ret != BT_ERROR_NONE) {
+		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
+		return ret;
+	}
+
+	*version = strdup(loc_ver.version);
+	if (*version == NULL) {
+		BT_ERR("OUT_OF_MEMORY(0x%08x)", BT_ERROR_OUT_OF_MEMORY);
+		return BT_ERROR_OUT_OF_MEMORY;
+	}
+
+	return BT_ERROR_NONE;
+}
+
+#define BT_ADAPTER_FIRMWARE_INFO_FILE_PATH "/var/lib/bluetooth/bcmtool_log"
+#define BT_ADAPTER_STACK_INFO_FILE_PATH "/usr/etc/bluetooth/stack_info"
+
+int bt_adapter_get_local_info(char **chipset, char **firmware, char **stack_version, char **profiles)
+{
+	int ret = BT_ERROR_NONE;
+	FILE *fp = NULL;
+	char *buf = NULL;
+	long lsize;
+	size_t result;
+	char *info_start = NULL;
+	char *info_end = NULL;
+	long info_size;
+	char *local_chipset = NULL;
+	char *local_firmware = NULL;
+	char *local_stack_version = NULL;
+	char *local_profiles = NULL;
+
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(chipset);
+	BT_CHECK_INPUT_PARAMETER(firmware);
+	BT_CHECK_INPUT_PARAMETER(stack_version);
+	BT_CHECK_INPUT_PARAMETER(profiles);
+
+	if ((fp = fopen(BT_ADAPTER_FIRMWARE_INFO_FILE_PATH, "r")) == NULL) {
+		BT_ERR("fopen() is failed(%s)", BT_ADAPTER_FIRMWARE_INFO_FILE_PATH);
+
+		local_firmware = (char *)malloc(sizeof(char) * 1);
+		if (local_firmware == NULL) {
+			ret = BT_ERROR_OUT_OF_MEMORY;
+			BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
+			goto ERROR;
+		}
+		local_firmware[0] = '\0';
+		local_chipset = (char *)malloc(sizeof(char) * 1);
+		if (local_chipset == NULL) {
+			ret = BT_ERROR_OUT_OF_MEMORY;
+			BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
+			goto ERROR;
+		}
+		local_chipset[0] = '\0';
+	} else {
+		fseek(fp, 0, SEEK_END);
+		lsize = ftell(fp);
+		if (lsize < 0) {
+			ret = BT_ERROR_OPERATION_FAILED;
+			BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
+			goto ERROR;
+		}
+		buf = (char *)malloc(sizeof(char) * (lsize + 1));
+		if (buf == NULL) {
+			ret = BT_ERROR_OUT_OF_MEMORY;
+			BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
+			goto ERROR;
+		}
+		fseek(fp, 0, SEEK_SET);
+		result = fread(buf, 1, lsize, fp);
+		buf[lsize] = '\0';
+
+		if (result != lsize)
+			BT_ERR("fread() error");
+
+		info_start = strstr(buf, "bluetooth");
+		if (info_start == NULL) {
+			ret = BT_ERROR_OPERATION_FAILED;
+			BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
+			goto ERROR;
+		}
+		info_start += 10;
+		info_end = strstr(buf, "hcd");
+		if (info_end == NULL) {
+			ret = BT_ERROR_OPERATION_FAILED;
+			BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
+			goto ERROR;
+		}
+		info_size = info_end - info_start - 1;
+
+		local_firmware = (char *)malloc(sizeof(char) * (info_size + 1));
+		if (local_firmware == NULL) {
+			ret = BT_ERROR_OUT_OF_MEMORY;
+			BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
+			goto ERROR;
+		}
+
+		strncpy(local_firmware, info_start, info_size);
+		local_firmware[info_size] = '\0';
+
+		info_end = strchr(buf, '_');
+		if (info_end == NULL) {
+			ret = BT_ERROR_OPERATION_FAILED;
+			BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
+			goto ERROR;
+		}
+		info_size = info_end - info_start;
+
+		local_chipset = (char *)malloc(sizeof(char) * (info_size + 1));
+		if (local_chipset == NULL) {
+			ret = BT_ERROR_OUT_OF_MEMORY;
+			BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
+			goto ERROR;
+		}
+
+		strncpy(local_chipset, info_start, info_size);
+		local_chipset[info_size] = '\0';
+
+		if (buf)
+			free(buf);
+		buf = NULL;
+		fclose(fp);
+	}
+
+	if ((fp = fopen(BT_ADAPTER_STACK_INFO_FILE_PATH, "r")) == NULL) {
+		ret = BT_ERROR_OPERATION_FAILED;
+		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
+		goto ERROR;
+	}
+
+	fseek(fp, 0, SEEK_END);
+	lsize = ftell(fp);
+	if (lsize < 0) {
+		ret = BT_ERROR_OPERATION_FAILED;
+		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
+		goto ERROR;
+	}
+	buf = (char *)malloc(sizeof(char) * (lsize + 1));
+	if (buf == NULL) {
+		ret = BT_ERROR_OUT_OF_MEMORY;
+		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
+		goto ERROR;
+	}
+	fseek(fp, 0, SEEK_SET);
+	result = fread(buf, 1, lsize, fp);
+	buf[lsize] = '\0';
+
+	if (result != lsize)
+		BT_ERR("fread() error");
+
+	info_start = buf;
+	info_end = strchr(buf, ',');
+	if (info_end == NULL) {
+		ret = BT_ERROR_OPERATION_FAILED;
+		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
+		goto ERROR;
+	}
+	info_size = info_end - info_start;
+
+	local_stack_version = (char *)malloc(sizeof(char) * (info_size + 1));
+	if (local_stack_version == NULL) {
+		ret = BT_ERROR_OUT_OF_MEMORY;
+		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
+		goto ERROR;
+	}
+
+	strncpy(local_stack_version, info_start, info_size);
+	local_stack_version[info_size] = '\0';
+
+	info_start = info_end + 2;
+	info_size = lsize - info_size - 3;
+
+	local_profiles = (char *)malloc(sizeof(char) * (info_size + 1));
+	if (local_profiles == NULL) {
+		ret = BT_ERROR_OUT_OF_MEMORY;
+		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
+		goto ERROR;
+	}
+
+	strncpy(local_profiles, info_start, info_size);
+	local_profiles[info_size] = '\0';
+
+	if (buf)
+		free(buf);
+	fclose(fp);
+
+	*chipset = local_chipset;
+	*firmware = local_firmware;
+	*stack_version = local_stack_version;
+	*profiles = local_profiles;
+
+	return BT_ERROR_NONE;
+
+ERROR:
+	if (local_chipset)
+		free(local_chipset);
+	if (local_firmware)
+		free(local_firmware);
+	if (local_stack_version)
+		free(local_stack_version);
+	if (local_profiles)
+		free(local_profiles);
+	if (buf)
+		free(buf);
+	if (fp)
+		fclose(fp);
+	return ret;
+}
+
 int bt_adapter_get_name(char **name)
 {
 	int ret = BT_ERROR_NONE;
@@ -242,6 +519,8 @@ int bt_adapter_set_connectable(bool connectable)
 {
 	int error_code = BT_ERROR_NONE;
 
+	BT_CHECK_INIT_STATUS();
+
 	error_code = _bt_get_error_code(bluetooth_set_connectable(connectable));
 	if (error_code != BT_ERROR_NONE) {
 		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code);
@@ -348,6 +627,7 @@ int bt_adapter_free_device_info(bt_device_info_s *device_info)
 int bt_adapter_is_service_used(const char *service_uuid, bool *used)
 {
 	int ret = BT_ERROR_NONE;
+	gboolean is_used = FALSE;
 
 	BT_CHECK_INIT_STATUS();
 	BT_CHECK_INPUT_PARAMETER(service_uuid);
@@ -357,7 +637,8 @@ int bt_adapter_is_service_used(const char *service_uuid, bool *used)
 		*used = bluetooth_obex_server_is_activated();
 	} else {
 		ret = _bt_get_error_code(bluetooth_is_service_used(service_uuid,
-							(gboolean *)used));
+							&is_used));
+		*used = is_used ? true : false;
 	}
 
 	if (ret != BT_ERROR_NONE) {
@@ -369,6 +650,7 @@ int bt_adapter_is_service_used(const char *service_uuid, bool *used)
 
 int bt_adapter_set_state_changed_cb(bt_adapter_state_changed_cb callback, void *user_data)
 {
+	BT_DBG("");
 	int ret = BT_ERROR_NONE;
 
 	BT_CHECK_INIT_STATUS();
@@ -381,6 +663,16 @@ int bt_adapter_set_state_changed_cb(bt_adapter_state_changed_cb callback, void *
 	return ret;
 }
 
+int bt_adapter_le_set_state_changed_cb(bt_adapter_le_state_changed_cb callback, void *user_data)
+{
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(callback);
+
+	_bt_le_adapter_init();
+	_bt_set_cb(BT_EVENT_LE_STATE_CHANGED, callback, user_data);
+	return BT_ERROR_NONE;
+}
+
 int bt_adapter_set_name_changed_cb(bt_adapter_name_changed_cb callback, void *user_data)
 {
 	int ret = BT_ERROR_NONE;
@@ -423,6 +715,16 @@ int bt_adapter_set_device_discovery_state_changed_cb(bt_adapter_device_discovery
 	return ret;
 }
 
+int bt_adapter_le_set_device_discovery_state_changed_cb(bt_adapter_le_device_discovery_state_changed_cb callback, void *user_data)
+{
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(callback);
+
+	_bt_le_adapter_init();
+	_bt_set_cb(BT_EVENT_LE_DEVICE_DISCOVERY_STATE_CHANGED, callback, user_data);
+	return BT_ERROR_NONE;
+}
+
 int bt_adapter_unset_state_changed_cb(void)
 {
 	BT_CHECK_INIT_STATUS();
@@ -430,6 +732,14 @@ int bt_adapter_unset_state_changed_cb(void)
 	return BT_ERROR_NONE;
 }
 
+int bt_adapter_le_unset_state_changed_cb(void)
+{
+	BT_CHECK_INIT_STATUS();
+	_bt_unset_cb(BT_EVENT_LE_STATE_CHANGED);
+	_bt_le_adapter_deinit();
+	return BT_ERROR_NONE;
+}
+
 int bt_adapter_unset_name_changed_cb(void)
 {
 	BT_CHECK_INIT_STATUS();
@@ -446,19 +756,22 @@ int bt_adapter_unset_visibility_mode_changed_cb(void)
 
 int bt_adapter_set_visibility_duration_changed_cb(bt_adapter_visibility_duration_changed_cb callback, void *user_data)
 {
-	BT_CHECK_INIT_STATUS();
+	int ret = BT_ERROR_NONE;
 
-	/* Will impelement it */
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(callback);
+	_bt_set_cb(BT_EVENT_VISIBILITY_DURATION_CHANGED, callback, user_data);
+	if (ret != BT_ERROR_NONE) {
+		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
+	}
 
-	return BT_ERROR_NONE;
+	return ret;
 }
 
 int bt_adapter_unset_visibility_duration_changed_cb(void)
 {
 	BT_CHECK_INIT_STATUS();
-
-	/* Will impelement it */
-
+	_bt_unset_cb(BT_EVENT_VISIBILITY_DURATION_CHANGED);
 	return BT_ERROR_NONE;
 }
 
@@ -469,6 +782,14 @@ int bt_adapter_unset_device_discovery_state_changed_cb(void)
 	return BT_ERROR_NONE;
 }
 
+int bt_adapter_le_unset_device_discovery_state_changed_cb(void)
+{
+	BT_CHECK_INIT_STATUS();
+	_bt_unset_cb(BT_EVENT_LE_DEVICE_DISCOVERY_STATE_CHANGED);
+	_bt_le_adapter_deinit();
+	return BT_ERROR_NONE;
+}
+
 int bt_adapter_start_device_discovery(void)
 {
 	int error_code = BT_ERROR_NONE;
@@ -481,39 +802,68 @@ int bt_adapter_start_device_discovery(void)
 	return error_code;
 }
 
-int bt_adapter_start_discover_devices(bt_adapter_discover_devices_type_e type)
+int bt_adapter_stop_device_discovery(void)
 {
 	int error_code = BT_ERROR_NONE;
 
 	BT_CHECK_INIT_STATUS();
-	error_code = _bt_get_error_code(bluetooth_start_custom_discovery(type,
-					0, 0, BLUETOOTH_DEVICE_MAJOR_MASK_MISC));
+	error_code = _bt_get_error_code(bluetooth_cancel_discovery());
 	if (error_code != BT_ERROR_NONE) {
 		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code);
 	}
 	return error_code;
 }
 
-int bt_adapter_stop_device_discovery(void)
+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);
+		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
+		return ret;
+	}
+}
+
+int bt_adapter_le_start_device_discovery(void)
 {
 	int error_code = BT_ERROR_NONE;
 
 	BT_CHECK_INIT_STATUS();
-	error_code = _bt_get_error_code(bluetooth_cancel_discovery());
+	error_code = _bt_get_error_code(bluetooth_start_le_discovery());
 	if (error_code != BT_ERROR_NONE) {
 		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code);
 	}
 	return error_code;
 }
 
-int bt_adapter_is_discovering(bool *is_discovering)
+int bt_adapter_le_stop_device_discovery(void)
+{
+	int error_code = BT_ERROR_NONE;
+
+	BT_CHECK_INIT_STATUS();
+	error_code = _bt_get_error_code(bluetooth_stop_le_discovery());
+	if (error_code != BT_ERROR_NONE) {
+		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code);
+	}
+	return error_code;
+}
+
+int bt_adapter_le_is_discovering(bool *is_discovering)
 {
 	int ret = 0;
 
 	BT_CHECK_INIT_STATUS();
 	BT_CHECK_INPUT_PARAMETER(is_discovering);
 
-	ret = bluetooth_is_discovering();
+	ret = bluetooth_is_le_discovering();
 	if (ret >= BLUETOOTH_ERROR_BASE) {
 		*is_discovering = (ret == 1) ? true : false;
 		return BT_ERROR_NONE;
@@ -594,99 +944,47 @@ int bt_adapter_remove_remote_oob_data(const char *remote_address)
 	return ret;
 }
 
-int bt_adapter_set_advertising_state_changed_cb(bt_adapter_advertising_state_changed_cb callback, void *user_data)
+int bt_adapter_le_add_white_list(const char *address, bt_device_address_type_e address_type)
 {
-	int ret = BT_ERROR_NONE;
-
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(callback);
-	_bt_set_cb(BT_EVENT_ADVERTISING_STATE_CHANGED, callback, user_data);
-	if (ret != BT_ERROR_NONE) {
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
-	}
-
-	return ret;
-}
-
-int bt_adapter_unset_advertising_state_changed_cb(void)
-{
-	BT_CHECK_INIT_STATUS();
-	_bt_unset_cb(BT_EVENT_ADVERTISING_STATE_CHANGED);
-	return BT_ERROR_NONE;
-}
-
-int bt_adapter_start_advertising(bt_adapter_advertising_params_s *adv_params)
-{
-	BT_DBG("+");
-	int org_error_code = BLUETOOTH_ERROR_NONE;
 	int error_code = BT_ERROR_NONE;
+	bluetooth_device_address_t addr_hex = { {0,} };
 
 	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(address);
+	_bt_convert_address_to_hex(&addr_hex, address);
 
-	if (adv_params == NULL) {
-		org_error_code = bluetooth_set_advertising(TRUE);
-	} else {
-		org_error_code = bluetooth_set_custom_advertising(TRUE,
-				adv_params->interval_min,
-				adv_params->interval_max,
-				adv_params->filter_policy);
-	}
-	BT_DBG("org error code : 0x%04X", org_error_code);
-
-	error_code = _bt_get_error_code(org_error_code);
+	error_code = _bt_get_error_code(bluetooth_add_white_list(&addr_hex, address_type));
 	if (error_code != BT_ERROR_NONE) {
 		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code);
 	}
 
-	BT_DBG("-");
 	return error_code;
 }
 
-int bt_adapter_stop_advertising(void)
+int bt_adapter_le_remove_white_list(const char *address, bt_device_address_type_e address_type)
 {
-	BT_DBG("+");
 	int error_code = BT_ERROR_NONE;
+	bluetooth_device_address_t addr_hex = { {0,} };
 
 	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(address);
+	_bt_convert_address_to_hex(&addr_hex, address);
 
-	error_code = _bt_get_error_code(bluetooth_set_advertising(FALSE));
+	error_code = _bt_get_error_code(bluetooth_remove_white_list(&addr_hex, address_type));
 	if (error_code != BT_ERROR_NONE) {
 		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code);
 	}
 
-	BT_DBG("-");
 	return error_code;
 }
 
-int bt_adapter_is_advertising(bool *is_advertising)
-{
-	int ret;
-	gboolean advertising = FALSE;
-
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(is_advertising);
-
-	ret = bluetooth_is_advertising(&advertising);
-	if (ret >= BLUETOOTH_ERROR_BASE) {
-		*is_advertising = advertising ? true : false;
-		return BT_ERROR_NONE;
-	} else {
-		ret = _bt_get_error_code(ret);
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
-		return ret;
-	}
-}
-
-int bt_adapter_add_white_list(const char *address)
+int bt_adapter_le_clear_white_list(void)
 {
 	int error_code = BT_ERROR_NONE;
-	bluetooth_device_address_t addr_hex = { {0,} };
 
 	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(address);
-	_bt_convert_address_to_hex(&addr_hex, address);
 
-	error_code = _bt_get_error_code(bluetooth_add_white_list(&addr_hex));
+	error_code = _bt_get_error_code(bluetooth_clear_white_list());
 	if (error_code != BT_ERROR_NONE) {
 		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code);
 	}
@@ -694,49 +992,68 @@ int bt_adapter_add_white_list(const char *address)
 	return error_code;
 }
 
-int bt_adapter_remove_white_list(const char *address)
+int bt_adapter_le_create_advertiser(bt_advertiser_h *advertiser)
 {
-	int error_code = BT_ERROR_NONE;
-	bluetooth_device_address_t addr_hex = { {0,} };
+	int ret = BT_ERROR_NONE;
 
 	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(address);
-	_bt_convert_address_to_hex(&addr_hex, address);
+	BT_CHECK_INPUT_PARAMETER(advertiser);
 
-	error_code = _bt_get_error_code(bluetooth_remove_white_list(&addr_hex));
-	if (error_code != BT_ERROR_NONE) {
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code);
+	*advertiser = (bt_advertiser_h)g_malloc0(sizeof(bt_advertiser_s));
+	if (*advertiser == NULL) {
+		ret = BT_ERROR_OUT_OF_MEMORY;
+		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
 	}
 
-	return error_code;
+	return ret;
 }
 
-int bt_adapter_clear_white_list(void)
+int bt_adapter_le_destroy_advertiser(bt_advertiser_h advertiser)
 {
-	int error_code = BT_ERROR_NONE;
+	int ret = BT_ERROR_NONE;
+	int error_code;
+	bt_advertiser_s *__adv = (bt_advertiser_s *)advertiser;
 
 	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(advertiser);
 
-	error_code = _bt_get_error_code(bluetooth_clear_white_list());
-	if (error_code != BT_ERROR_NONE) {
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code);
+	_bt_unset_cb(BT_EVENT_ADVERTISING_STATE_CHANGED);
+
+#if 0
+	if (__adv->handle) {
+		error_code = bluetooth_stop_advertising(__adv->handle);
+		ret = _bt_get_error_code(error_code);
+		if (ret != BT_ERROR_NONE)
+			BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
+		__adv->handle = 0;
 	}
+#else
+	error_code = bluetooth_set_advertising(FALSE);
+	ret = _bt_get_error_code(error_code);
+	if (ret != BT_ERROR_NONE)
+		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
+#endif
 
-	return error_code;
+	/* Free advertising data */
+	if (__adv->adv_data)
+		free(__adv->adv_data);
+	if (__adv->scan_rsp_data)
+		free(__adv->scan_rsp_data);
+	free(__adv);
+
+	return BT_ERROR_NONE;
 }
 
-static int __bt_get_ad_data_by_type(char *in_data, int in_len,
-		char in_type, char **data, int *data_len)
+static int __bt_remove_ad_data_by_type(char *in_data, unsigned int in_len,
+		char in_type, char **data, unsigned int *data_len)
 {
 	if (in_data == NULL || data == NULL || data_len == NULL)
 		return BT_ERROR_OPERATION_FAILED;
 
-	if (in_len < 0)
-		return BT_ERROR_OPERATION_FAILED;
-
 	int i;
 	int len = 0;
 	int type = 0;
+	char *p;
 
 	for (i = 0; i < in_len; i++) {
 		len = in_data[i];
@@ -760,79 +1077,228 @@ static int __bt_get_ad_data_by_type(char *in_data, int in_len,
 		BT_ERR("Invalid advertising data");
 		return BT_ERROR_OPERATION_FAILED;
 	} else if (len == 0) {
-		BT_DBG("AD Type 0x%02x data is not set", in_type);
-		*data = NULL;
-		*data_len = 0;
-		return BT_ERROR_NONE;
+		BT_INFO("AD Type 0x%02x data is not set", in_type);
+		return BT_ERROR_OPERATION_FAILED;
 	}
 
-	*data = g_memdup(&in_data[i], len);
-	if (*data == NULL)
+	p = (char *)malloc(sizeof(char) * (in_len - len));
+	if (p == NULL) {
 		return BT_ERROR_OUT_OF_MEMORY;
-	*data_len = len;
+	}
+
+	memcpy(p, in_data, sizeof(char) * i);
+	memcpy(p + i, in_data + i + len, sizeof(char) * (in_len - len - i));
+
+	*data = p;
+	*data_len = in_len - len;
 
 	return BT_ERROR_NONE;
 }
 
+int bt_adapter_le_add_advertising_data(bt_advertiser_h advertiser,
+		bt_adapter_le_packet_type_e pkt_type, bt_adapter_le_packet_data_type_e data_type,
+		void *data, unsigned int data_size)
+{
+	int ret = BT_ERROR_NONE;
+	bt_advertiser_s *__adv = (bt_advertiser_s *)advertiser;
+	char **p;
+	unsigned int *len;
+	char *new_p;
 
-int bt_adapter_get_advertising_manufacturer_data(char **data, int *len)
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(advertiser);
+
+	switch (pkt_type) {
+	case BT_ADAPTER_LE_PACKET_ADVERTISING:
+		p = &__adv->adv_data;
+		len = &__adv->adv_data_len;
+		break;
+
+	case BT_ADAPTER_LE_PACKET_SCAN_RESPONSE:
+		p = &__adv->scan_rsp_data;
+		len = &__adv->scan_rsp_data_len;
+		break;
+
+	default:
+		BT_ERR("Unknown LE packet type : %d", pkt_type);
+		return BT_ERROR_INVALID_PARAMETER;
+	}
+
+	/* 2 bytes are required for Length and AD Type */
+	if (*len + data_size + 2 > 31) {
+		return BT_ERROR_QUOTA_EXCEEDED;
+	}
+
+	if (*len == 0)
+		*p = NULL;
+
+	new_p = realloc(*p, sizeof(char) * (*len + data_size + 2));
+	if (new_p == NULL) {
+		return BT_ERROR_OUT_OF_MEMORY;
+	}
+
+	new_p[*len] = data_size + 1;
+	new_p[*len + 1] = data_type;
+	memcpy(new_p + (*len + 2), data, data_size);
+
+	*p = new_p;
+	*len += data_size + 2;
+
+	return ret;
+}
+
+int bt_adapter_le_remove_advertising_data(bt_advertiser_h advertiser,
+		bt_adapter_le_packet_type_e pkt_type, bt_adapter_le_packet_data_type_e data_type)
 {
-	bluetooth_advertising_data_t adv = { {0} };
-	int adv_len = 0;
-	int ret;
+	int ret = BT_ERROR_NONE;
+	bt_advertiser_s *__adv = (bt_advertiser_s *)advertiser;
+	char **p;
+	unsigned int *len;
+	char *new_p = NULL;
+	unsigned int new_len = 0;
 
 	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(data);
-	BT_CHECK_INPUT_PARAMETER(len);
+	BT_CHECK_INPUT_PARAMETER(advertiser);
+
+	switch (pkt_type) {
+	case BT_ADAPTER_LE_PACKET_ADVERTISING:
+		p = &__adv->adv_data;
+		len = &__adv->adv_data_len;
+		break;
 
-	ret = _bt_get_error_code(bluetooth_get_advertising_data(&adv, &adv_len));
+	case BT_ADAPTER_LE_PACKET_SCAN_RESPONSE:
+		p = &__adv->scan_rsp_data;
+		len = &__adv->scan_rsp_data_len;
+		break;
+
+	default:
+		BT_ERR("Unknown LE packet type : %d", pkt_type);
+		return BT_ERROR_INVALID_PARAMETER;
+	}
+
+	ret = __bt_remove_ad_data_by_type(*p, *len, data_type, &new_p, &new_len);
 	if (ret != BT_ERROR_NONE) {
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
 		return ret;
 	}
 
-	ret = __bt_get_ad_data_by_type((char *)adv.data, adv_len, 0xff,
-			data, len);
-	if (ret != BT_ERROR_NONE)
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
+	free(*p);
+	*p = new_p;
+	*len = new_len;
 
 	return ret;
 }
 
-int bt_adapter_set_advertising_manufacturer_data(char *data, int len)
+int bt_adapter_le_clear_advertising_data(bt_advertiser_h advertiser,
+		bt_adapter_le_packet_type_e pkt_type)
 {
-	int ret;
-	bluetooth_advertising_data_t adv = { {0} };
+	int ret = BT_ERROR_NONE;
+	bt_advertiser_s *__adv = (bt_advertiser_s *)advertiser;
+	char **p;
+	unsigned int *len;
 
 	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(data);
+	BT_CHECK_INPUT_PARAMETER(advertiser);
+
+	switch (pkt_type) {
+	case BT_ADAPTER_LE_PACKET_ADVERTISING:
+		p = &__adv->adv_data;
+		len = &__adv->adv_data_len;
+		break;
 
-	if (len + 2 > sizeof(adv.data) || len < 0)
+	case BT_ADAPTER_LE_PACKET_SCAN_RESPONSE:
+		p = &__adv->scan_rsp_data;
+		len = &__adv->scan_rsp_data_len;
+		break;
+
+	default:
+		BT_ERR("Unknown LE packet type : %d", pkt_type);
 		return BT_ERROR_INVALID_PARAMETER;
+	}
 
-	adv.data[0] = len + 1;
-	adv.data[1] = 0xFF;
+	if (*p) {
+		free(*p);
+		*p = NULL;
+	}
+	*len = 0;
 
-	memcpy(&adv.data[2], data, len);
+	return ret;
+}
+
+int bt_adapter_le_start_advertising(bt_advertiser_h advertiser,
+		bt_adapter_le_advertising_params_s *adv_params,
+		bt_adapter_le_advertising_state_changed_cb cb, void *user_data)
+{
+	int ret = BT_ERROR_NONE;
+	int error_code;
+	bt_advertiser_s *__adv = (bt_advertiser_s *)advertiser;
+	bluetooth_advertising_data_t adv = { {0} };
+	bluetooth_scan_resp_data_t resp = { {0} };
+
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(advertiser);
+
+#if 0
+	error_code = bluetooth_start_advertising(__adv, cb, user_data);
+	ret = _bt_get_error_code(error_code);
+	if (ret != BT_ERROR_NONE) {
+		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
+	}
+#endif
+
+	if (__adv->adv_data_len > 0 && __adv->adv_data) {
+		memcpy(adv.data, __adv->adv_data, __adv->adv_data_len);
+		error_code = bluetooth_set_advertising_data(&adv, __adv->adv_data_len);
+		ret = _bt_get_error_code(error_code);
+		if (ret != BT_ERROR_NONE) {
+			BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
+			return ret;
+		}
+	}
+
+	if (__adv->scan_rsp_data_len > 0 && __adv->scan_rsp_data) {
+		memcpy(resp.data, __adv->scan_rsp_data, __adv->scan_rsp_data_len);
+		error_code = bluetooth_set_scan_response_data(&resp, __adv->scan_rsp_data_len);
+		ret = _bt_get_error_code(error_code);
+		if (ret != BT_ERROR_NONE) {
+			BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
+			return ret;
+		}
+	}
 
-	ret = _bt_get_error_code(bluetooth_set_advertising_data(&adv, len + 2));
+	if (adv_params == NULL) {
+		error_code = bluetooth_set_advertising(TRUE);
+	} else {
+		error_code = bluetooth_set_custom_advertising(TRUE,
+				(bluetooth_advertising_params_t *)adv_params);
+	}
+
+	ret = _bt_get_error_code(error_code);
 	if (ret != BT_ERROR_NONE) {
 		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
+		return ret;
 	}
 
+	_bt_set_cb(BT_EVENT_ADVERTISING_STATE_CHANGED, cb, user_data);
+
 	return ret;
 }
 
-int bt_adapter_set_advertising_manufacturer_data_changed_cb(
-		bt_adapter_advertising_manufacturer_data_changed_cb callback,
-		void *user_data)
+int bt_adapter_le_stop_advertising(bt_advertiser_h advertiser)
 {
 	int ret = BT_ERROR_NONE;
+//	bt_advertiser_s *__adv = (bt_advertiser_s *)advertiser;
 
 	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(callback);
-	_bt_set_cb(BT_EVENT_ADVERTISING_MANUFACTURER_DATA_CHANGED,
-			callback, user_data);
+
+#if 0
+	error_code = bluetooth_stop_advertising(__adv, cb, user_data);
+	ret = _bt_get_error_code(error_code);
+	if (ret != BT_ERROR_NONE) {
+		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
+	}
+#endif
+
+	ret = _bt_get_error_code(bluetooth_set_advertising(FALSE));
 	if (ret != BT_ERROR_NONE) {
 		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
 	}
@@ -840,9 +1306,17 @@ int bt_adapter_set_advertising_manufacturer_data_changed_cb(
 	return ret;
 }
 
-int bt_adapter_unset_advertising_manufacturer_data_changed_cb(void)
+int bt_adapter_le_enable_privacy(bool enable_privacy)
 {
+	int error_code = BT_ERROR_NONE;
+
 	BT_CHECK_INIT_STATUS();
-	_bt_unset_cb(BT_EVENT_ADVERTISING_MANUFACTURER_DATA_CHANGED);
-	return BT_ERROR_NONE;
+
+	error_code = _bt_get_error_code(bluetooth_enable_le_privacy(enable_privacy));
+
+	if (error_code != BT_ERROR_NONE) {
+		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code);
+	}
+	return error_code;
 }
+
diff --git a/mobile/src/bluetooth-audio.c b/src/bluetooth-audio.c
index fbef434..54b4e0b 100644
--- a/mobile/src/bluetooth-audio.c
+++ b/src/bluetooth-audio.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
+ * 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.
@@ -22,11 +22,31 @@
 #include "bluetooth_private.h"
 #include "bluetooth-audio-api.h"
 #include "bluetooth-telephony-api.h"
+#include "bluetooth-scmst-api.h"
 
 typedef struct _call_list_s {
 	GList *list;
 } call_list_s;
 
+static bool is_audio_initialized = false;
+
+#define BT_CHECK_AUDIO_INIT_STATUS() \
+	if (__bt_check_audio_init_status() == BT_ERROR_NOT_INITIALIZED) \
+	{ \
+		LOGE("[%s] NOT_INITIALIZED(0x%08x)", __FUNCTION__, BT_ERROR_NOT_INITIALIZED); \
+		return BT_ERROR_NOT_INITIALIZED; \
+	}
+
+int __bt_check_audio_init_status(void)
+{
+	if (is_audio_initialized != true) {
+		BT_ERR("NOT_INITIALIZED(0x%08x)", BT_ERROR_NOT_INITIALIZED);
+		return BT_ERROR_NOT_INITIALIZED;
+	}
+
+	return BT_ERROR_NONE;
+}
+
 /*The below API is just to convert the error from Telephony API's to CAPI error codes,
 * this is temporary change and changes to proper error code will be done in
 * subsequent check ins.*/
@@ -57,6 +77,8 @@ int _bt_convert_telephony_error_code(int error)
 	case BLUETOOTH_TELEPHONY_ERROR_I_O_ERROR:
 	case BLUETOOTH_TELEPHONY_ERROR_OPERATION_NOT_AVAILABLE:
 		return BT_ERROR_OPERATION_FAILED;
+	case BLUETOOTH_TELEPHONY_ERROR_PERMISSION_DENIED:
+		return BT_ERROR_PERMISSION_DENIED;
 	default:
 		return BT_ERROR_NONE;
 	}
@@ -73,13 +95,18 @@ int bt_audio_initialize(void)
 		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error);
 		return error;
 	}
+
+#ifndef TELEPHONY_DISABLED /* B2_3G */
 	error = bluetooth_telephony_init((void *)_bt_telephony_event_proxy, NULL);
 	error = _bt_convert_telephony_error_code(error);
 	if (BT_ERROR_NONE != error) {
-		BT_ERR("[%s] (0x%08x)",
-			_bt_convert_error_to_string(error), error);
+		BT_ERR("[%s] (0x%08x)", _bt_convert_error_to_string(error), error);
+		return error;
 	}
-	return error;
+#endif
+
+	is_audio_initialized = true;
+	return BT_ERROR_NONE;
 }
 
 int bt_audio_deinitialize(void)
@@ -87,18 +114,26 @@ int bt_audio_deinitialize(void)
 	int error;
 
 	BT_CHECK_INIT_STATUS();
+	BT_CHECK_AUDIO_INIT_STATUS();
+
 	error = bluetooth_audio_deinit();
 	error = _bt_get_error_code(error);
 	if (BT_ERROR_NONE != error) {
 		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error);
 		return error;
 	}
+
+#ifndef TELEPHONY_DISABLED /* B2_3G */
 	error = bluetooth_telephony_deinit();
 	error = _bt_convert_telephony_error_code(error);
 	if (BT_ERROR_NONE != error) {
 		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error);
+		return error;
 	}
-	return error;
+#endif
+
+	is_audio_initialized = false;
+	return BT_ERROR_NONE;
 }
 
 int bt_audio_connect(const char *remote_address, bt_audio_profile_type_e type)
@@ -107,6 +142,15 @@ int bt_audio_connect(const char *remote_address, bt_audio_profile_type_e type)
 	bluetooth_device_address_t addr_hex = { {0,} };
 
 	BT_CHECK_INIT_STATUS();
+	BT_CHECK_AUDIO_INIT_STATUS();
+
+#ifdef TELEPHONY_DISABLED
+	if (type == BT_AUDIO_PROFILE_TYPE_HSP_HFP) {
+		BT_ERR("NOT SUPPORTED(0x%08x)", BT_ERROR_NOT_SUPPORTED);
+		return BT_ERROR_NOT_SUPPORTED;
+	}
+#endif
+
 	BT_CHECK_INPUT_PARAMETER(remote_address);
 	_bt_convert_address_to_hex(&addr_hex, remote_address);
 	switch(type) {
@@ -134,6 +178,15 @@ int bt_audio_disconnect(const char *remote_address, bt_audio_profile_type_e type
 	bluetooth_device_address_t addr_hex = { {0,} };
 
 	BT_CHECK_INIT_STATUS();
+	BT_CHECK_AUDIO_INIT_STATUS();
+
+#ifdef TELEPHONY_DISABLED
+	if (type == BT_AUDIO_PROFILE_TYPE_HSP_HFP) {
+		BT_ERR("NOT SUPPORTED(0x%08x)", BT_ERROR_NOT_SUPPORTED);
+		return BT_ERROR_NOT_SUPPORTED;
+	}
+#endif
+
 	BT_CHECK_INPUT_PARAMETER(remote_address);
 	_bt_convert_address_to_hex(&addr_hex, remote_address);
 	switch(type) {
@@ -158,6 +211,7 @@ int bt_audio_disconnect(const char *remote_address, bt_audio_profile_type_e type
 int bt_audio_set_connection_state_changed_cb(bt_audio_connection_state_changed_cb callback, void *user_data)
 {
 	BT_CHECK_INIT_STATUS();
+	BT_CHECK_AUDIO_INIT_STATUS();
 	BT_CHECK_INPUT_PARAMETER(callback);
 	_bt_set_cb(BT_EVENT_AUDIO_CONNECTION_STATUS, callback, user_data);
 	return BT_ERROR_NONE;
@@ -166,6 +220,7 @@ int bt_audio_set_connection_state_changed_cb(bt_audio_connection_state_changed_c
 int bt_audio_unset_connection_state_changed_cb(void)
 {
 	BT_CHECK_INIT_STATUS();
+	BT_CHECK_AUDIO_INIT_STATUS();
 	if (_bt_check_cb(BT_EVENT_AUDIO_CONNECTION_STATUS) == true)
 		_bt_unset_cb(BT_EVENT_AUDIO_CONNECTION_STATUS);
 	return BT_ERROR_NONE;
@@ -173,22 +228,33 @@ int bt_audio_unset_connection_state_changed_cb(void)
 
 int bt_ag_notify_speaker_gain(int gain)
 {
+#ifdef TELEPHONY_DISABLED
+	BT_ERR("NOT SUPPORTED(0x%08x)", BT_ERROR_NOT_SUPPORTED);
+	return BT_ERROR_NOT_SUPPORTED;
+#else
 	int error;
 
 	BT_CHECK_INIT_STATUS();
+	BT_CHECK_AUDIO_INIT_STATUS();
 	error = bluetooth_telephony_set_speaker_gain((unsigned short)gain);
 	error = _bt_convert_telephony_error_code(error);
 	if (BT_ERROR_NONE != error) {
 		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error);
 	}
 	return error;
+#endif
 }
 
 int bt_ag_get_speaker_gain(int *gain)
 {
+#ifdef TELEPHONY_DISABLED
+	BT_ERR("NOT SUPPORTED(0x%08x)", BT_ERROR_NOT_SUPPORTED);
+	return BT_ERROR_NOT_SUPPORTED;
+#else
 	int error;
 
 	BT_CHECK_INIT_STATUS();
+	BT_CHECK_AUDIO_INIT_STATUS();
 	BT_CHECK_INPUT_PARAMETER(gain);
 	error = bluetooth_telephony_get_headset_volume((unsigned int *)gain);
 	error = _bt_convert_telephony_error_code(error);
@@ -196,14 +262,20 @@ int bt_ag_get_speaker_gain(int *gain)
 		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error);
 	}
 	return error;
+#endif
 }
 
 int bt_ag_is_nrec_enabled(bool *enabled)
 {
+#ifdef TELEPHONY_DISABLED
+	BT_ERR("NOT SUPPORTED(0x%08x)", BT_ERROR_NOT_SUPPORTED);
+	return BT_ERROR_NOT_SUPPORTED;
+#else
 	int error;
-	gboolean is_enabled = false;
+	gboolean is_enabled = FALSE;
 
 	BT_CHECK_INIT_STATUS();
+	BT_CHECK_AUDIO_INIT_STATUS();
 	BT_CHECK_INPUT_PARAMETER(enabled);
 
 	error = bluetooth_telephony_is_nrec_enabled(&is_enabled);
@@ -217,101 +289,162 @@ int bt_ag_is_nrec_enabled(bool *enabled)
 		*enabled = false;
 
 	return error;
+#endif
 }
 
 int bt_ag_set_microphone_gain_changed_cb(bt_ag_microphone_gain_changed_cb callback, void *user_data)
 {
+#ifdef TELEPHONY_DISABLED
+	BT_ERR("NOT SUPPORTED(0x%08x)", BT_ERROR_NOT_SUPPORTED);
+	return BT_ERROR_NOT_SUPPORTED;
+#else
 	BT_CHECK_INIT_STATUS();
+	BT_CHECK_AUDIO_INIT_STATUS();
 	BT_CHECK_INPUT_PARAMETER(callback);
 	_bt_set_cb(BT_EVENT_AG_MICROPHONE_GAIN_CHANGE, callback, user_data);
 	return BT_ERROR_NONE;
-
+#endif
 }
 
 int bt_ag_unset_microphone_gain_changed_cb(void)
 {
+#ifdef TELEPHONY_DISABLED
+	BT_ERR("NOT SUPPORTED(0x%08x)", BT_ERROR_NOT_SUPPORTED);
+	return BT_ERROR_NOT_SUPPORTED;
+#else
 	BT_CHECK_INIT_STATUS();
+	BT_CHECK_AUDIO_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;
+#endif
 }
 
 int bt_ag_set_speaker_gain_changed_cb(bt_ag_speaker_gain_changed_cb callback,
 					void *user_data)
 {
+#ifdef TELEPHONY_DISABLED
+	BT_ERR("NOT SUPPORTED(0x%08x)", BT_ERROR_NOT_SUPPORTED);
+	return BT_ERROR_NOT_SUPPORTED;
+#else
 	BT_CHECK_INIT_STATUS();
+	BT_CHECK_AUDIO_INIT_STATUS();
 	BT_CHECK_INPUT_PARAMETER(callback);
 	_bt_set_cb(BT_EVENT_AG_SPEAKER_GAIN_CHANGE, callback, user_data);
 	return BT_ERROR_NONE;
+#endif
 }
 
 int bt_ag_unset_speaker_gain_changed_cb(void)
 {
+#ifdef TELEPHONY_DISABLED
+	BT_ERR("NOT SUPPORTED(0x%08x)", BT_ERROR_NOT_SUPPORTED);
+	return BT_ERROR_NOT_SUPPORTED;
+#else
 	BT_CHECK_INIT_STATUS();
+	BT_CHECK_AUDIO_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;
+#endif
 }
 
 int bt_ag_open_sco(void)
 {
+#ifdef TELEPHONY_DISABLED
+	BT_ERR("NOT SUPPORTED(0x%08x)", BT_ERROR_NOT_SUPPORTED);
+	return BT_ERROR_NOT_SUPPORTED;
+#else
 	int error;
 
 	BT_CHECK_INIT_STATUS();
+	BT_CHECK_AUDIO_INIT_STATUS();
 	error = bluetooth_telephony_audio_open();
 	error = _bt_convert_telephony_error_code(error);
 	if (error != BT_ERROR_NONE) {
 		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error);
 	}
 	return error;
+#endif
 }
 
 int bt_ag_close_sco(void)
 {
+#ifdef TELEPHONY_DISABLED
+	BT_ERR("NOT SUPPORTED(0x%08x)", BT_ERROR_NOT_SUPPORTED);
+	return BT_ERROR_NOT_SUPPORTED;
+#else
 	int error;
 
 	BT_CHECK_INIT_STATUS();
+	BT_CHECK_AUDIO_INIT_STATUS();
 	error = bluetooth_telephony_audio_close();
 	error = _bt_convert_telephony_error_code(error);
 	if (error != BT_ERROR_NONE) {
 		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error);
 	}
 	return error;
+#endif
 }
 
 int bt_ag_is_sco_opened(bool *opened)
 {
+#ifdef TELEPHONY_DISABLED
+	BT_ERR("NOT SUPPORTED(0x%08x)", BT_ERROR_NOT_SUPPORTED);
+	return BT_ERROR_NOT_SUPPORTED;
+#else
 	BT_CHECK_INIT_STATUS();
+	BT_CHECK_AUDIO_INIT_STATUS();
 	BT_CHECK_INPUT_PARAMETER(opened);
 	if (bluetooth_telephony_is_sco_connected())
 		*opened = true;
 	else
 		*opened = false;
 	return BT_ERROR_NONE;
+#endif
 }
 
 int bt_ag_set_sco_state_changed_cb(bt_ag_sco_state_changed_cb callback,
 					void *user_data)
 {
+#ifdef TELEPHONY_DISABLED
+	BT_ERR("NOT SUPPORTED(0x%08x)", BT_ERROR_NOT_SUPPORTED);
+	return BT_ERROR_NOT_SUPPORTED;
+#else
 	BT_CHECK_INIT_STATUS();
+	BT_CHECK_AUDIO_INIT_STATUS();
 	BT_CHECK_INPUT_PARAMETER(callback);
 	_bt_set_cb(BT_EVENT_AG_SCO_CONNECTION_STATUS, callback, user_data);
 	return BT_ERROR_NONE;
+#endif
 }
 
 int bt_ag_unset_sco_state_changed_cb(void)
 {
+#ifdef TELEPHONY_DISABLED
+	BT_ERR("NOT SUPPORTED(0x%08x)", BT_ERROR_NOT_SUPPORTED);
+	return BT_ERROR_NOT_SUPPORTED;
+#else
 	BT_CHECK_INIT_STATUS();
+	BT_CHECK_AUDIO_INIT_STATUS();
 	if (_bt_check_cb(BT_EVENT_AG_SCO_CONNECTION_STATUS) == true)
 		_bt_unset_cb(BT_EVENT_AG_SCO_CONNECTION_STATUS);
 	return BT_ERROR_NONE;
+#endif
 }
 
 int bt_ag_notify_call_event(bt_ag_call_event_e event, unsigned int call_id, const char *phone_number)
 {
+#ifdef TELEPHONY_DISABLED
+	BT_ERR("NOT SUPPORTED(0x%08x)", BT_ERROR_NOT_SUPPORTED);
+	return BT_ERROR_NOT_SUPPORTED;
+#else
 	int error;
 
 	BT_CHECK_INIT_STATUS();
+	BT_CHECK_AUDIO_INIT_STATUS();
+	BT_INFO("call_id [%d] / event [%d]", call_id, event);
+
 	switch(event) {
 	case BT_AG_CALL_EVENT_IDLE:
 		error = bluetooth_telephony_call_end(call_id);
@@ -346,15 +479,21 @@ int bt_ag_notify_call_event(bt_ag_call_event_e event, unsigned int call_id, cons
 		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error);
 	}
 	return error;
+#endif
 }
 
 int bt_ag_notify_call_list(bt_call_list_h list)
 {
+#ifdef TELEPHONY_DISABLED
+	BT_ERR("NOT SUPPORTED(0x%08x)", BT_ERROR_NOT_SUPPORTED);
+	return BT_ERROR_NOT_SUPPORTED;
+#else
 	int error;
 	unsigned int call_count;
 	call_list_s *handle;
 
 	BT_CHECK_INIT_STATUS();
+	BT_CHECK_AUDIO_INIT_STATUS();
 	BT_CHECK_INPUT_PARAMETER(list);
 	handle = (call_list_s *)list;
 	call_count = g_list_length(handle->list);
@@ -364,13 +503,19 @@ int bt_ag_notify_call_list(bt_call_list_h list)
 		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error);
 	}
 	return error;
+#endif
 }
 
 int bt_ag_notify_voice_recognition_state(bool state)
 {
+#ifdef TELEPHONY_DISABLED
+	BT_ERR("NOT SUPPORTED(0x%08x)", BT_ERROR_NOT_SUPPORTED);
+	return BT_ERROR_NOT_SUPPORTED;
+#else
 	int error;
 
 	BT_CHECK_INIT_STATUS();
+	BT_CHECK_AUDIO_INIT_STATUS();
 	if (state)
 		error = bluetooth_telephony_start_voice_recognition();
 	else
@@ -380,59 +525,95 @@ int bt_ag_notify_voice_recognition_state(bool state)
 		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error);
 	}
 	return error;
+#endif
 }
 
 int bt_ag_set_call_handling_event_cb(bt_ag_call_handling_event_cb callback,
 					void *user_data)
 {
+#ifdef TELEPHONY_DISABLED
+	BT_ERR("NOT SUPPORTED(0x%08x)", BT_ERROR_NOT_SUPPORTED);
+	return BT_ERROR_NOT_SUPPORTED;
+#else
 	BT_CHECK_INIT_STATUS();
+	BT_CHECK_AUDIO_INIT_STATUS();
 	BT_CHECK_INPUT_PARAMETER(callback);
 	_bt_set_cb(BT_EVENT_AG_CALL_HANDLING_EVENT, callback, user_data);
 	return BT_ERROR_NONE;
-
+#endif
 }
 
 int bt_ag_unset_call_handling_event_cb(void)
 {
+#ifdef TELEPHONY_DISABLED
+	BT_ERR("NOT SUPPORTED(0x%08x)", BT_ERROR_NOT_SUPPORTED);
+	return BT_ERROR_NOT_SUPPORTED;
+#else
 	BT_CHECK_INIT_STATUS();
+	BT_CHECK_AUDIO_INIT_STATUS();
 	if (_bt_check_cb(BT_EVENT_AG_CALL_HANDLING_EVENT) == true)
 		_bt_unset_cb(BT_EVENT_AG_CALL_HANDLING_EVENT);
 	return BT_ERROR_NONE;
+#endif
 }
 
 int bt_ag_set_multi_call_handling_event_cb(
 					bt_ag_multi_call_handling_event_cb callback,
 					void *user_data)
 {
+#ifdef TELEPHONY_DISABLED
+	BT_ERR("NOT SUPPORTED(0x%08x)", BT_ERROR_NOT_SUPPORTED);
+	return BT_ERROR_NOT_SUPPORTED;
+#else
 	BT_CHECK_INIT_STATUS();
+	BT_CHECK_AUDIO_INIT_STATUS();
 	BT_CHECK_INPUT_PARAMETER(callback);
 	_bt_set_cb(BT_EVENT_AG_MULTI_CALL_HANDLING_EVENT, callback, user_data);
 	return BT_ERROR_NONE;
+#endif
 }
 
 int bt_ag_unset_multi_call_handling_event_cb(void)
 {
+#ifdef TELEPHONY_DISABLED
+	BT_ERR("NOT SUPPORTED(0x%08x)", BT_ERROR_NOT_SUPPORTED);
+	return BT_ERROR_NOT_SUPPORTED;
+#else
 	BT_CHECK_INIT_STATUS();
+	BT_CHECK_AUDIO_INIT_STATUS();
 	if (_bt_check_cb(BT_EVENT_AG_MULTI_CALL_HANDLING_EVENT) == true)
 		_bt_unset_cb(BT_EVENT_AG_MULTI_CALL_HANDLING_EVENT);
 	return BT_ERROR_NONE;
+#endif
 }
 
 int bt_ag_set_dtmf_transmitted_cb(bt_ag_dtmf_transmitted_cb callback,
 						void *user_data)
 {
+#ifdef TELEPHONY_DISABLED
+	BT_ERR("NOT SUPPORTED(0x%08x)", BT_ERROR_NOT_SUPPORTED);
+	return BT_ERROR_NOT_SUPPORTED;
+#else
 	BT_CHECK_INIT_STATUS();
+	BT_CHECK_AUDIO_INIT_STATUS();
 	BT_CHECK_INPUT_PARAMETER(callback);
 	_bt_set_cb(BT_EVENT_AG_DTMF_TRANSMITTED, callback, user_data);
 	return BT_ERROR_NONE;
+#endif
 }
 
 int bt_ag_unset_dtmf_transmitted_cb(void)
 {
+#ifdef TELEPHONY_DISABLED
+	BT_ERR("NOT SUPPORTED(0x%08x)", BT_ERROR_NOT_SUPPORTED);
+	return BT_ERROR_NOT_SUPPORTED;
+#else
 	BT_CHECK_INIT_STATUS();
+	BT_CHECK_AUDIO_INIT_STATUS();
 	if (_bt_check_cb(BT_EVENT_AG_DTMF_TRANSMITTED) == true)
 		_bt_unset_cb(BT_EVENT_AG_DTMF_TRANSMITTED);
 	return BT_ERROR_NONE;
+#endif
 }
 
 int bt_call_list_create(bt_call_list_h *list)
@@ -440,6 +621,8 @@ int bt_call_list_create(bt_call_list_h *list)
 	call_list_s *handle;
 
 	BT_CHECK_INIT_STATUS();
+	BT_CHECK_AUDIO_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(list);
 	if (*list != NULL) {
 		BT_ERR("BT_ERROR_ALREADY_DONE(0x%08x)", BT_ERROR_ALREADY_DONE);
 		return BT_ERROR_ALREADY_DONE;
@@ -455,6 +638,7 @@ int bt_call_list_destroy(bt_call_list_h list)
 	call_list_s *handle;
 
 	BT_CHECK_INIT_STATUS();
+	BT_CHECK_AUDIO_INIT_STATUS();
 	BT_CHECK_INPUT_PARAMETER(list);
 	handle = (call_list_s *)list;
 	result = bt_call_list_reset(list);
@@ -468,6 +652,7 @@ int bt_call_list_reset(bt_call_list_h list)
 	bt_telephony_call_status_info_t *call_status;
 
 	BT_CHECK_INIT_STATUS();
+	BT_CHECK_AUDIO_INIT_STATUS();
 	BT_CHECK_INPUT_PARAMETER(list);
 	handle = (call_list_s *)list;
 	do  {
@@ -475,22 +660,31 @@ int bt_call_list_reset(bt_call_list_h list)
 		if (call_status == NULL)
 			break;
 		handle->list = g_list_remove(handle->list, call_status);
+
+		if (NULL != call_status->phone_number)
+			g_free(call_status->phone_number);
+
 		g_free(call_status);
 	} while (1);
 	return BT_ERROR_NONE;
 }
 
-int bt_call_list_add(bt_call_list_h list, unsigned int call_id, bt_ag_call_state_e state)
+int bt_call_list_add(bt_call_list_h list, unsigned int call_id, bt_ag_call_state_e state, const char *phone_number)
 {
 	call_list_s *handle;
 	bt_telephony_call_status_info_t *call_status;
 
 	BT_CHECK_INIT_STATUS();
+	BT_CHECK_AUDIO_INIT_STATUS();
 	BT_CHECK_INPUT_PARAMETER(list);
+	BT_CHECK_INPUT_PARAMETER(phone_number);
+
 	handle = (call_list_s *)list;
 	call_status = g_malloc0(sizeof(bt_telephony_call_status_info_t));
 	call_status->call_id = call_id;
 	call_status->call_status = state;
+	call_status->phone_number = g_strdup(phone_number);
+
 	handle->list = g_list_append(handle->list, (gpointer)call_status);
 	return BT_ERROR_NONE;
 }
diff --git a/wearable/src/bluetooth-avrcp.c b/src/bluetooth-avrcp.c
index a7b7e19..118db9d 100644
--- a/wearable/src/bluetooth-avrcp.c
+++ b/src/bluetooth-avrcp.c
@@ -22,6 +22,25 @@
 #include "bluetooth-audio-api.h"
 #include "bluetooth-media-control.h"
 
+static bool is_avrcp_target_initialized = false;
+
+#define BT_CHECK_AVRCP_TARGET_INIT_STATUS() \
+	if (__bt_check_avrcp_target_init_status() == BT_ERROR_NOT_INITIALIZED) \
+	{ \
+		LOGE("[%s] NOT_INITIALIZED(0x%08x)", __FUNCTION__, BT_ERROR_NOT_INITIALIZED); \
+		return BT_ERROR_NOT_INITIALIZED; \
+	}
+
+int __bt_check_avrcp_target_init_status(void)
+{
+	if (is_avrcp_target_initialized != true) {
+		BT_ERR("NOT_INITIALIZED(0x%08x)", BT_ERROR_NOT_INITIALIZED);
+		return BT_ERROR_NOT_INITIALIZED;
+	}
+
+	return BT_ERROR_NONE;
+}
+
 /*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.*/
@@ -51,8 +70,11 @@ int bt_avrcp_target_initialize(bt_avrcp_target_connection_state_changed_cb callb
 	error = _bt_get_error_code(error);
 	if (BT_ERROR_NONE != error) {
 		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error);
+		return error;
 	}
-	return error;
+
+	is_avrcp_target_initialized = true;
+	return BT_ERROR_NONE;
 }
 
 int bt_avrcp_target_deinitialize(void)
@@ -60,6 +82,7 @@ int bt_avrcp_target_deinitialize(void)
 	int error;
 
 	BT_CHECK_INIT_STATUS();
+	BT_CHECK_AVRCP_TARGET_INIT_STATUS();
 	if (_bt_check_cb(BT_EVENT_AVRCP_CONNECTION_STATUS) == true)
 		_bt_unset_cb(BT_EVENT_AVRCP_CONNECTION_STATUS);
 
@@ -69,14 +92,18 @@ int bt_avrcp_target_deinitialize(void)
 	error = _bt_get_error_code(error);
 	if (BT_ERROR_NONE != error) {
 		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error);
+		return error;
 	}
-	return error;
+
+	is_avrcp_target_initialized = false;
+	return BT_ERROR_NONE;
 }
 
 int bt_avrcp_target_notify_equalizer_state(bt_avrcp_equalizer_state_e state)
 {
 	int error;
 	BT_CHECK_INIT_STATUS();
+	BT_CHECK_AVRCP_TARGET_INIT_STATUS();
 	error = bluetooth_media_player_change_property(EQUALIZER, state);
 	error = _bt_convert_avrcp_error_code(error);
 	error = _bt_get_error_code(error);
@@ -89,6 +116,7 @@ int bt_avrcp_target_notify_repeat_mode(bt_avrcp_repeat_mode_e mode)
 {
 	int error;
 	BT_CHECK_INIT_STATUS();
+	BT_CHECK_AVRCP_TARGET_INIT_STATUS();
 	error = bluetooth_media_player_change_property(REPEAT, mode);
 	error = _bt_convert_avrcp_error_code(error);
 	error = _bt_get_error_code(error);
@@ -102,6 +130,7 @@ int bt_avrcp_target_notify_shuffle_mode(bt_avrcp_shuffle_mode_e mode)
 {
 	int error;
 	BT_CHECK_INIT_STATUS();
+	BT_CHECK_AVRCP_TARGET_INIT_STATUS();
 	error = bluetooth_media_player_change_property(SHUFFLE, mode);
 	error = _bt_convert_avrcp_error_code(error);
 	error = _bt_get_error_code(error);
@@ -114,6 +143,7 @@ int bt_avrcp_target_notify_scan_mode(bt_avrcp_scan_mode_e mode)
 {
 	int error;
 	BT_CHECK_INIT_STATUS();
+	BT_CHECK_AVRCP_TARGET_INIT_STATUS();
 	error = bluetooth_media_player_change_property(SCAN, mode);
 	error = _bt_convert_avrcp_error_code(error);
 	error = _bt_get_error_code(error);
@@ -127,6 +157,7 @@ int bt_avrcp_target_notify_player_state(bt_avrcp_player_state_e state)
 {
 	int error;
 	BT_CHECK_INIT_STATUS();
+	BT_CHECK_AVRCP_TARGET_INIT_STATUS();
 	error = bluetooth_media_player_change_property(STATUS, state);
 	error = _bt_convert_avrcp_error_code(error);
 	error = _bt_get_error_code(error);
@@ -140,6 +171,7 @@ int bt_avrcp_target_notify_position(unsigned int position)
 {
 	int error;
 	BT_CHECK_INIT_STATUS();
+	BT_CHECK_AVRCP_TARGET_INIT_STATUS();
 	error = bluetooth_media_player_change_property(POSITION, position);
 	error = _bt_convert_avrcp_error_code(error);
 	error = _bt_get_error_code(error);
@@ -154,6 +186,7 @@ int bt_avrcp_target_notify_track(const char *title, const char *artist, const ch
 {
 	int error;
 	BT_CHECK_INIT_STATUS();
+	BT_CHECK_AVRCP_TARGET_INIT_STATUS();
 	media_metadata_attributes_t metadata;
 	metadata.title = title;
 	metadata.artist = artist;
@@ -181,6 +214,7 @@ int bt_avrcp_set_equalizer_state_changed_cb(bt_avrcp_equalizer_state_changed_cb
 
 int bt_avrcp_unset_equalizer_state_changed_cb(void)
 {
+	BT_CHECK_INIT_STATUS();
 	_bt_unset_cb(BT_EVENT_AVRCP_EQUALIZER_STATE_CHANGED);
 	return BT_ERROR_NONE;
 }
@@ -195,6 +229,7 @@ int bt_avrcp_set_repeat_mode_changed_cb(bt_avrcp_repeat_mode_changed_cb callback
 
 int bt_avrcp_unset_repeat_mode_changed_cb(void)
 {
+	BT_CHECK_INIT_STATUS();
 	_bt_unset_cb(BT_EVENT_AVRCP_REPEAT_MODE_CHANGED);
 	return BT_ERROR_NONE;
 }
@@ -209,6 +244,7 @@ int bt_avrcp_set_shuffle_mode_changed_cb(bt_avrcp_shuffle_mode_changed_cb callba
 
 int bt_avrcp_unset_shuffle_mode_changed_cb(void)
 {
+	BT_CHECK_INIT_STATUS();
 	_bt_unset_cb(BT_EVENT_AVRCP_SHUFFLE_MODE_CHANGED);
 	return BT_ERROR_NONE;
 }
@@ -223,6 +259,7 @@ int bt_avrcp_set_scan_mode_changed_cb(bt_avrcp_scan_mode_changed_cb callback, vo
 
 int bt_avrcp_unset_scan_mode_changed_cb(void)
 {
+	BT_CHECK_INIT_STATUS();
 	_bt_unset_cb(BT_EVENT_AVRCP_SCAN_MODE_CHANGED);
 	return BT_ERROR_NONE;
 }
diff --git a/wearable/src/bluetooth-common.c b/src/bluetooth-common.c
index 017d50e..f87a6d3 100644..100755
--- a/wearable/src/bluetooth-common.c
+++ b/src/bluetooth-common.c
@@ -29,11 +29,15 @@
 #include "bluetooth-telephony-api.h"
 
 static bool is_initialized = false;
+static bool is_le_initialized = false;
 static bt_event_sig_event_slot_s bt_event_slot_container[] = {
 	{BT_EVENT_STATE_CHANGED, NULL, NULL},
+	{BT_EVENT_LE_STATE_CHANGED, NULL, NULL},
 	{BT_EVENT_NAME_CHANGED, NULL, NULL},
 	{BT_EVENT_VISIBILITY_MODE_CHANGED, NULL, NULL},
+	{BT_EVENT_VISIBILITY_DURATION_CHANGED, NULL, NULL},
 	{BT_EVENT_DEVICE_DISCOVERY_STATE_CHANGED, NULL, NULL},
+	{BT_EVENT_LE_DEVICE_DISCOVERY_STATE_CHANGED, NULL, NULL},
 	{BT_EVENT_BOND_CREATED, NULL, NULL},
 	{BT_EVENT_BOND_DESTROYED, NULL, NULL},
 	{BT_EVENT_AUTHORIZATION_CHANGED, NULL, NULL},
@@ -67,33 +71,36 @@ static bt_event_sig_event_slot_s bt_event_slot_container[] = {
 	{BT_EVENT_AVRCP_SCAN_MODE_CHANGED, NULL, NULL},
 	{BT_EVENT_HID_CONNECTION_STATUS, NULL, NULL},
 	{BT_EVENT_DEVICE_CONNECTION_STATUS, NULL, NULL},
-	{BT_EVENT_DEVICE_DISCONNECTED, NULL, NULL},
 	{BT_EVENT_GATT_CONNECTION_STATUS, NULL, NULL},
 	{BT_EVENT_GATT_CHARACTERISTIC_DISCOVERED, NULL, NULL},
 	{BT_EVENT_GATT_VALUE_CHANGED, NULL, NULL},
 	{BT_EVENT_GATT_READ_CHARACTERISTIC, NULL, NULL},
 	{BT_EVENT_GATT_WRITE_CHARACTERISTIC, NULL, NULL},
+	{BT_EVENT_GATT_CHARACTERISTIC_DESCRIPTOR_DISCOVERED, NULL, NULL},
 	{BT_EVENT_ADVERTISING_STATE_CHANGED, NULL, NULL},
-	{BT_EVENT_ADVERTISING_MANUFACTURER_DATA_CHANGED, NULL, NULL},
-	{BT_EVENT_HF_SCO_CONNECTION_STATUS, NULL, NULL},
-	{BT_EVENT_HF_SPEAKER_GAIN_CHANGE, NULL, NULL},
-	{BT_EVENT_HF_CALL_HANDLING_EVENT, NULL, NULL},
-	{BT_EVENT_HF_VENDOR_DEP_CMD_EVENT, NULL, NULL},
-	{BT_EVENT_HF_MULTI_CALL_HANDLING_EVENT, NULL, NULL},
-	{BT_EVENT_CONNECTABLE_CHANGED_EVENT, NULL, NULL}
+	{BT_EVENT_MANUFACTURER_DATA_CHANGED, NULL, NULL},
+	{BT_EVENT_CONNECTABLE_CHANGED_EVENT, NULL, NULL},
+	{BT_EVENT_AG_VENDOR_CMD, NULL, NULL},
+	{BT_EVENT_RSSI_ENABLED_EVENT, NULL, NULL},
+	{BT_EVENT_RSSI_ALERT_EVENT, NULL, NULL},
+	{BT_EVENT_GET_RSSI_EVENT, NULL, NULL},
 };
 
 /*
  *  Internal Functions
  */
 static void __bt_event_proxy(int event, bluetooth_event_param_t * param, void *user_data);
+static void __bt_le_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_device_connection_info_s(bt_device_connection_info_s **dest, bt_connection_info_t *source);
+static void __bt_free_bt_device_connection_info_s(bt_device_connection_info_s *conn_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);
-
+static int __bt_get_bt_adapter_le_device_discovery_info_s(bt_adapter_le_device_discovery_info_s **le_discovery_info, bluetooth_le_device_info_t *source_info);
+static void __bt_free_bt_adapter_le_device_discovery_info_s(bt_adapter_le_device_discovery_info_s *discovery_info);
 
 /*
  *  Public Functions
@@ -124,14 +131,12 @@ int bt_deinitialize(void)
 	return BT_ERROR_NONE;
 }
 
-
 /*
  *  Common Functions
  */
 int _bt_check_init_status(void)
 {
-	if (is_initialized != true)
-	{
+	if (is_initialized != true) {
 		BT_ERR("NOT_INITIALIZED(0x%08x)", BT_ERROR_NOT_INITIALIZED);
 		return BT_ERROR_NOT_INITIALIZED;
 	}
@@ -158,6 +163,39 @@ bool _bt_check_cb(int events)
 	return (bt_event_slot_container[events].callback != NULL) ? true : false;
 }
 
+int _bt_le_adapter_init(void)
+{
+	if (is_le_initialized)
+		return BT_ERROR_NONE;
+
+	if (bluetooth_le_register_callback(&__bt_le_event_proxy, NULL) != BLUETOOTH_ERROR_NONE) {
+		BT_ERR("OPERATION_FAILED(0x%08x)", BT_ERROR_OPERATION_FAILED);
+		return BT_ERROR_OPERATION_FAILED;
+	}
+	is_le_initialized = true;
+
+	return BT_ERROR_NONE;
+}
+
+int _bt_le_adapter_deinit(void)
+{
+	if (!is_le_initialized) {
+		BT_ERR("NOT_INITIALIZED(0x%08x)", BT_ERROR_NOT_INITIALIZED);
+		return BT_ERROR_NOT_INITIALIZED;
+	}
+
+	if (!_bt_check_cb(BT_EVENT_LE_STATE_CHANGED) &&
+	    !_bt_check_cb(BT_EVENT_LE_DEVICE_DISCOVERY_STATE_CHANGED)) {
+		if (bluetooth_le_unregister_callback() != BLUETOOTH_ERROR_NONE) {
+			BT_ERR("OPERATION_FAILED(0x%08x)", BT_ERROR_OPERATION_FAILED);
+			return BT_ERROR_OPERATION_FAILED;
+		}
+		is_le_initialized = false;
+	}
+
+	return BT_ERROR_NONE;
+}
+
 int _bt_get_error_code(int origin_error)
 {
 	switch (origin_error) {
@@ -166,8 +204,9 @@ int _bt_get_error_code(int origin_error)
 	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_NOT_SUPPORT:
+		return BT_ERROR_NOT_SUPPORTED;
 	case BLUETOOTH_ERROR_MEMORY_ALLOCATION:
 	case BLUETOOTH_ERROR_OUT_OF_MEMORY:
 		return BT_ERROR_OUT_OF_MEMORY;
@@ -178,6 +217,7 @@ int _bt_get_error_code(int origin_error)
 	case BLUETOOTH_ERROR_DEVICE_ALREADY_ENABLED:
 	case BLUETOOTH_ERROR_ALREADY_INITIALIZED:
 	case BLUETOOTH_ERROR_AGENT_DOES_NOT_EXIST:
+	case BLUETOOTH_ERROR_ALREADY_DEACTIVATED:
 		return BT_ERROR_ALREADY_DONE;
 	case BLUETOOTH_ERROR_NOT_PAIRED:
 		return BT_ERROR_REMOTE_DEVICE_NOT_BONDED;
@@ -200,6 +240,8 @@ int _bt_get_error_code(int origin_error)
 		return BT_ERROR_PERMISSION_DENIED;
 	case BLUETOOTH_ERROR_SERVICE_NOT_FOUND:
 		return BT_ERROR_SERVICE_NOT_FOUND;
+	case BLUETOOTH_ERROR_NOT_INITIALIZED:
+		return BT_ERROR_NOT_INITIALIZED;
 	case BLUETOOTH_ERROR_PARING_FAILED:
 	case BLUETOOTH_ERROR_MAX_CONNECTION:
 	case BLUETOOTH_ERROR_ALREADY_CONNECT:
@@ -244,7 +286,9 @@ int _bt_get_bt_device_info_s(bt_device_info_s **dest_dev, bluetooth_device_info_
 		(*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]);
+				(*dest_dev)->service_uuid[i] =
+					g_strndup(source_dev->uuids[i],
+						BLUETOOTH_UUID_STRING_MAX - 1);
 				if ((*dest_dev)->service_uuid[i] != NULL) {
 					__bt_convert_lower_to_upper((*dest_dev)->service_uuid[i]);
 				}
@@ -258,6 +302,15 @@ int _bt_get_bt_device_info_s(bt_device_info_s **dest_dev, bluetooth_device_info_
 	(*dest_dev)->is_connected = (bool)source_dev->connected;
 	(*dest_dev)->is_authorized = (bool)source_dev->trust;
 
+	(*dest_dev)->manufacturer_data_len = source_dev->manufacturer_data.data_len;
+	if (source_dev->manufacturer_data.data_len > 0) {
+		(*dest_dev)->manufacturer_data = (char *)malloc(source_dev->manufacturer_data.data_len);
+		memcpy((*dest_dev)->manufacturer_data, source_dev->manufacturer_data.data, source_dev->manufacturer_data.data_len);
+	} else {
+		(*dest_dev)->manufacturer_data = (char *)malloc(1);
+		(*dest_dev)->manufacturer_data[0] = 0;
+	}
+
 	return BT_ERROR_NONE;
 }
 
@@ -277,11 +330,14 @@ void _bt_free_bt_device_info_s(bt_device_info_s *device_info)
 	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]);
+				g_free(device_info->service_uuid[i]);
 		}
 		free(device_info->service_uuid);
 	}
 
+	if (device_info->manufacturer_data != NULL)
+		free(device_info->manufacturer_data);
+
 	free(device_info);
 	device_info = NULL;
 }
@@ -355,6 +411,14 @@ char *_bt_convert_error_to_string(int error)
 		return "REMOTE_DEVICE_NOT_FOUND";
 	case BT_ERROR_SERVICE_SEARCH_FAILED:
 		return "SERVICE_SEARCH_FAILED";
+	case BT_ERROR_REMOTE_DEVICE_NOT_CONNECTED:
+		return "REMOTE_DEVICE_NOT_CONNECTED";
+	case BT_ERROR_PERMISSION_DENIED:
+		return "PERMISSION_DENIED";
+	case BT_ERROR_SERVICE_NOT_FOUND:
+		return "SERVICE_NOT_FOUND";
+	case BT_ERROR_NOT_SUPPORTED:
+		return "NOT_SUPPORTD";
 	default:
 		return "UNKNOWN";
 	}
@@ -380,10 +444,7 @@ static int __bt_get_bt_device_sdp_info_s(bt_device_sdp_info_s **dest, bt_sdp_inf
 {
 	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;
-	}
+	*dest = (bt_device_sdp_info_s *)g_malloc0(sizeof(bt_device_sdp_info_s));
 
 	if (_bt_convert_address_to_string(&((*dest)->remote_address), &(source->device_addr)) != BT_ERROR_NONE) {
 		__bt_free_bt_device_sdp_info_s(*dest);
@@ -431,21 +492,50 @@ static void __bt_free_bt_device_sdp_info_s(bt_device_sdp_info_s *sdp_info)
 		free(sdp_info->service_uuid);
 	}
 
-	free(sdp_info);
+	g_free(sdp_info);
 	sdp_info = NULL;
 }
 
-void _bt_audio_event_proxy(int event, bt_audio_event_param_t *param, void *user_data)
+static int __bt_get_bt_device_connection_info_s(bt_device_connection_info_s **dest, bt_connection_info_t *source)
 {
-	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);
+	*dest = (bt_device_connection_info_s *)g_malloc0(sizeof(bt_device_connection_info_s));
+
+	if (_bt_convert_address_to_string(&((*dest)->remote_address), &(source->device_addr)) != BT_ERROR_NONE) {
+		__bt_free_bt_device_connection_info_s(*dest);
+		return BT_ERROR_OUT_OF_MEMORY;
+	}
+
+	switch (source->addr_type) {
+	case 0:
+		(*dest)->link = BT_DEVICE_CONNECTION_LINK_BREDR;
+		break;
+	case 1:
+	case 2:
+		(*dest)->link = BT_DEVICE_CONNECTION_LINK_LE;
+		break;
+	default:
+		(*dest)->link = BT_DEVICE_CONNECTION_LINK_BREDR;
+		break;
+	}
+
+	(*dest)->disconn_reason = source->disc_reason;
+
+	return BT_ERROR_NONE;
 }
 
-void _bt_hf_event_proxy(int event, bt_hf_event_param_t *param, void *user_data)
+static void __bt_free_bt_device_connection_info_s(bt_device_connection_info_s *conn_info)
+{
+	if (conn_info == NULL)
+		return;
+
+	if (conn_info->remote_address != NULL)
+		free(conn_info->remote_address);
+
+	g_free(conn_info);
+	conn_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;
@@ -490,10 +580,12 @@ static void __bt_event_proxy(int event, bluetooth_event_param_t *param, void *us
 	int i;
 	int call_id;
 	int *avrcp_mode;
+	int *discoverable_timeout;
 	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_device_connection_info_s *conn_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;
@@ -511,12 +603,12 @@ static void __bt_event_proxy(int event, bluetooth_event_param_t *param, void *us
 	bt_hdp_data_ind_t *hdp_data_ind = NULL;
 	bt_gatt_discovered_char_t *svc_char = NULL;
 	bt_gatt_char_value_t *char_val = NULL;
+	bt_gatt_char_property_t *char_desc = 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) {
@@ -540,10 +632,16 @@ static void __bt_event_proxy(int event, bluetooth_event_param_t *param, void *us
 		((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_DISCOVERABLE_TIMEOUT_CHANGED:
+		BT_INFO("bt_adapter_visibility_duration_changed_cb() will be called");
+		discoverable_timeout = (int *)(param->param_data);
+		((bt_adapter_visibility_duration_changed_cb)bt_event_slot_container[event_index].callback)
+		    (*discoverable_timeout, bt_event_slot_container[event_index].user_data);
+		break;
 	case BLUETOOTH_EVENT_CONNECTABLE_CHANGED:
 		BT_INFO("bt_adapter_connectable_changed_cb() will be called");
 		((bt_adapter_connectable_changed_cb)bt_event_slot_container[event_index].callback)
-		    (_bt_get_error_code(param->result), *(bool *)(param->param_data), bt_event_slot_container[event_index].user_data);
+			(_bt_get_error_code(param->result), *(bool *)(param->param_data), bt_event_slot_container[event_index].user_data);
 		break;
 	case BLUETOOTH_EVENT_DISCOVERY_STARTED:
 		BT_INFO("bt_adapter_device_discovery_state_changed_cb() will be called with BT_ADAPTER_DEVICE_DISCOVERY_STARTED");
@@ -602,25 +700,17 @@ static void __bt_event_proxy(int event, bluetooth_event_param_t *param, void *us
 		break;
 	case BLUETOOTH_EVENT_DEVICE_CONNECTED:
 		BT_INFO("bt_device_connection_state_changed_cb() will be called");
-		_bt_convert_address_to_string(&device_addr, (bluetooth_device_address_t *)(param->param_data));
+		__bt_get_bt_device_connection_info_s(&conn_info, (bt_connection_info_t *)(param->param_data));
 		((bt_device_connection_state_changed_cb)bt_event_slot_container[event_index].callback)
-		    (true, device_addr, bt_event_slot_container[event_index].user_data);
-		if (device_addr != NULL)
-			free(device_addr);
+		    (true, conn_info, bt_event_slot_container[event_index].user_data);
+		__bt_free_bt_device_connection_info_s(conn_info);
 		break;
 	case BLUETOOTH_EVENT_DEVICE_DISCONNECTED:
 		BT_INFO("bt_device_connection_state_changed_cb() will be called");
-		_bt_convert_address_to_string(&device_addr, (bluetooth_device_address_t *)(param->param_data));
+		__bt_get_bt_device_connection_info_s(&conn_info, (bt_connection_info_t *)(param->param_data));
 		((bt_device_connection_state_changed_cb)bt_event_slot_container[event_index].callback)
-		    (false, device_addr, bt_event_slot_container[event_index].user_data);
-
-		if (_bt_check_cb(BT_EVENT_DEVICE_DISCONNECTED)) {
-			((bt_device_disconnected_cb)bt_event_slot_container[BT_EVENT_DEVICE_DISCONNECTED].callback)
-			(device_addr, param->result, bt_event_slot_container[BT_EVENT_DEVICE_DISCONNECTED].user_data);
-		}
-
-		if (device_addr != NULL)
-			free(device_addr);
+		    (false, conn_info, bt_event_slot_container[event_index].user_data);
+		__bt_free_bt_device_connection_info_s(conn_info);
 		break;
 	case BLUETOOTH_EVENT_SERVICE_SEARCHED:
 		BT_INFO("bt_device_service_searched_cb() will be called");
@@ -650,10 +740,11 @@ static void __bt_event_proxy(int event, bluetooth_event_param_t *param, void *us
 		if (connection_ind) {
 			rfcomm_connection.socket_fd = connection_ind->socket_fd;
 			rfcomm_connection.local_role = connection_ind->device_role;
+			rfcomm_connection.server_fd = connection_ind->server_id;
 
 			if (strlen(connection_ind->uuid) > 0) {
 				rfcomm_connection.service_uuid = strdup(connection_ind->uuid);
-				BT_DBG("uuid: [%s]", rfcomm_connection.service_uuid);
+				BT_INFO("uuid: [%s]", rfcomm_connection.service_uuid);
 			}
 
 			_bt_convert_address_to_string(&(rfcomm_connection.remote_address),
@@ -685,7 +776,7 @@ static void __bt_event_proxy(int event, bluetooth_event_param_t *param, void *us
 
 			if (strlen(disconnection_ind->uuid) > 0) {
 				rfcomm_connection.service_uuid = strdup(disconnection_ind->uuid);
-				BT_DBG("uuid: [%s]", rfcomm_connection.service_uuid);
+				BT_INFO("uuid: [%s]", rfcomm_connection.service_uuid);
 			}
 
 			_bt_convert_address_to_string(&(rfcomm_connection.remote_address),
@@ -974,79 +1065,6 @@ static void __bt_event_proxy(int event, bluetooth_event_param_t *param, void *us
 		(call_data->dtmf, bt_event_slot_container[event_index].user_data);
 		break;
 	}
-	case BLUETOOTH_EVENT_HF_CONNECTED:
-		BT_INFO("BLUETOOTH_EVENT_HF_CONNECTED");
-		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_AG,
-		bt_event_slot_container[event_index].user_data);
-		break;
-	case BLUETOOTH_EVENT_HF_DISCONNECTED:
-		BT_INFO("BLUETOOTH_EVENT_HF_DISCONNECTED");
-		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_AG,
-		bt_event_slot_container[event_index].user_data);
-		break;
-	case BLUETOOTH_EVENT_HF_AUDIO_CONNECTED:
-		BT_INFO("BLUETOOTH_EVENT_HF_AUDIO_CONNECTED");
-		device_addr = (char *)(param->param_data);
-		((bt_hf_sco_state_changed_cb)bt_event_slot_container[event_index].callback)
-		(_bt_get_error_code(param->result), FALSE,
-		bt_event_slot_container[event_index].user_data);
-		break;
-	case BLUETOOTH_EVENT_HF_AUDIO_DISCONNECTED:
-		BT_INFO("BLUETOOTH_EVENT_HF_AUDIO_DISCONNECTED");
-		device_addr = (char *)(param->param_data);
-		((bt_hf_sco_state_changed_cb)bt_event_slot_container[event_index].callback)
-		(_bt_get_error_code(param->result), FALSE,
-		bt_event_slot_container[event_index].user_data);
-		break;
-	case BLUETOOTH_EVENT_HF_RING_INDICATOR:
-		BT_INFO("BLUETOOTH_EVENT_HF_RING_INDICATOR");
-		char *phone_number = (char *)(param->param_data);
-		((bt_hf_call_handling_event_cb)bt_event_slot_container[event_index].callback)
-		(BT_HF_CALL_HANDLING_EVENT_RING, phone_number,
-		bt_event_slot_container[event_index].user_data);
-		break;
-	case BLUETOOTH_EVENT_HF_CALL_TERMINATED:
-		BT_INFO("BLUETOOTH_EVENT_HF_CALL_TERMINATED");
-		((bt_hf_call_handling_event_cb)bt_event_slot_container[event_index].callback)
-		(BT_HF_CALL_HANDLING_EVENT_RELEASE, NULL,
-		bt_event_slot_container[event_index].user_data);
-		break;
-	case BLUETOOTH_EVENT_HF_CALL_STARTED:
-		BT_INFO("BLUETOOTH_EVENT_HF_CALL_STARTED");
-		((bt_hf_call_handling_event_cb)bt_event_slot_container[event_index].callback)
-		(BT_HF_CALL_HANDLING_EVENT_CALL_STARTED, NULL,
-		bt_event_slot_container[event_index].user_data);
-		break;
-	case BLUETOOTH_EVENT_HF_CALL_ENDED:
-		BT_INFO("BLUETOOTH_EVENT_HF_CALL_ENDED");
-		((bt_hf_call_handling_event_cb)bt_event_slot_container[event_index].callback)
-		(BT_HF_CALL_HANDLING_EVENT_CALL_ENDED, NULL,
-		bt_event_slot_container[event_index].user_data);
-		break;
-	case BLUETOOTH_EVENT_HF_VOICE_RECOGNITION_ENABLED:
-		BT_INFO("BLUETOOTH_EVENT_HF_VOICE_RECOGNITION_ENABLED");
-		((bt_hf_call_handling_event_cb)bt_event_slot_container[event_index].callback)
-		(BT_HF_CALL_HANDLING_EVENT_VOICE_RECOGNITION_ENABLED, NULL,
-		bt_event_slot_container[event_index].user_data);
-		break;
-	case BLUETOOTH_EVENT_HF_VOICE_RECOGNITION_DISABLED:
-		BT_INFO("BLUETOOTH_EVENT_HF_VOICE_RECOGNITION_DISABLED");
-		((bt_hf_call_handling_event_cb)bt_event_slot_container[event_index].callback)
-		(BT_HF_CALL_HANDLING_EVENT_VOICE_RECOGNITION_DISABLED, NULL,
-		bt_event_slot_container[event_index].user_data);
-		break;
-	case BLUETOOTH_EVENT_HF_VOLUME_SPEAKER: {
-		BT_INFO("BLUETOOTH_EVENT_HF_VOLUME_SPEAKER");
-		int *spk_gain = (int *)(param->param_data);
-		((bt_hf_speaker_gain_changed_cb)bt_event_slot_container[event_index].callback)
-		(*spk_gain, bt_event_slot_container[event_index].user_data);
-		break;
-	}
-
 	case BLUETOOTH_EVENT_AG_SPEAKER_GAIN:
 		BT_INFO("BLUETOOTH_EVENT_AG_SPEAKER_GAIN");
 		int *spk_gain = (int *)(param->param_data);
@@ -1145,15 +1163,19 @@ static void __bt_event_proxy(int event, bluetooth_event_param_t *param, void *us
 		break;
 	case BLUETOOTH_EVENT_GATT_CONNECTED:
 		BT_INFO("BLUETOOTH_EVENT_GATT_CONNECTED");
-
-		((bt_device_gatt_state_changed_cb)bt_event_slot_container[event_index].callback)
-		(_bt_get_error_code(param->result), bt_event_slot_container[event_index].user_data);
+		bd_addr = (bluetooth_device_address_t *)(param->param_data);
+		_bt_convert_address_to_string(&device_addr, bd_addr);
+		((bt_gatt_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_EVENT_GATT_DISCONNECTED:
 		BT_INFO("BLUETOOTH_EVENT_GATT_DISCONNECTED");
-
-		((bt_device_gatt_state_changed_cb)bt_event_slot_container[event_index].callback)
-		(_bt_get_error_code(param->result), bt_event_slot_container[event_index].user_data);
+		bd_addr = (bluetooth_device_address_t *)(param->param_data);
+		_bt_convert_address_to_string(&device_addr, bd_addr);
+		((bt_gatt_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;
 	case BLUETOOTH_EVENT_GATT_SVC_CHAR_DISCOVERED:
 		BT_INFO("BLUETOOTH_EVENT_GATT_SVC_CHAR_DISCOVERED");
@@ -1203,30 +1225,86 @@ static void __bt_event_proxy(int event, bluetooth_event_param_t *param, void *us
 		_bt_unset_cb(BT_EVENT_GATT_WRITE_CHARACTERISTIC);
 
 		break;
+	case BLUETOOTH_EVENT_GATT_SVC_CHAR_DESC_DISCOVERED:
+		BT_INFO("BLUETOOTH_EVENT_GATT_SVC_CHAR_DESC_DISCOVERED");
+		char_desc = (bt_gatt_char_property_t *)(param->param_data);
+
+		if (char_desc == NULL)
+			return;
+
+		((bt_gatt_characteristic_descriptor_discovered_cb)
+			bt_event_slot_container[event_index].callback)(_bt_get_error_code(param->result),
+			char_desc->format.format, char_desc->val_len, char_desc->description,
+			bt_event_slot_container[event_index].user_data);
+
+		_bt_unset_cb(BT_EVENT_GATT_CHARACTERISTIC_DESCRIPTOR_DISCOVERED);
+
+		break;
 	case BLUETOOTH_EVENT_ADVERTISING_STARTED:
 		BT_INFO("BLUETOOTH_EVENT_ADVERTISING_STARTED");
 
-		((bt_adapter_advertising_state_changed_cb)bt_event_slot_container[event_index].callback)
-		 (_bt_get_error_code(param->result), BT_ADAPTER_ADVERTISING_STARTED,
-		  (bt_adapter_advertising_params_s *)param->param_data,
-		  bt_event_slot_container[event_index].user_data);
+		((bt_adapter_le_advertising_state_changed_cb)bt_event_slot_container[event_index].callback)
+			(_bt_get_error_code(param->result), NULL, BT_ADAPTER_LE_ADVERTISING_STARTED,
+			bt_event_slot_container[event_index].user_data);
 
 		break;
 	case BLUETOOTH_EVENT_ADVERTISING_STOPPED:
 		BT_INFO("BLUETOOTH_EVENT_ADVERTISING_STOPPED");
 
-		((bt_adapter_advertising_state_changed_cb)bt_event_slot_container[event_index].callback)
-		 (_bt_get_error_code(param->result), BT_ADAPTER_ADVERTISING_STOPPED, NULL,
-		  bt_event_slot_container[event_index].user_data);
+		((bt_adapter_le_advertising_state_changed_cb)bt_event_slot_container[event_index].callback)
+			(_bt_get_error_code(param->result), NULL, BT_ADAPTER_LE_ADVERTISING_STOPPED,
+			bt_event_slot_container[event_index].user_data);
 
 		break;
-	case BLUETOOTH_EVENT_ADVERTISING_MANUFACTURER_DATA_CHANGED:
-		BT_INFO("BLUETOOTH_EVENT_ADVERTISING_MANUFACTURER_DATA_CHANGED");
+	default:
+		break;
+	}
+}
 
-		((bt_adapter_advertising_manufacturer_data_changed_cb)bt_event_slot_container[event_index].callback)
-		 (param->param_data, param->result,
-		  bt_event_slot_container[event_index].user_data);
 
+static void __bt_le_event_proxy(int event, bluetooth_event_param_t *param, void *user_data)
+{
+	bt_socket_connection_s rfcomm_connection;
+	bt_adapter_le_device_discovery_info_s *discovery_info = NULL;
+	int event_index = -1;
+
+	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_LE_ENABLED:
+		BT_INFO("BLUETOOTH_EVENT_LE_ENABLED");
+		((bt_adapter_le_state_changed_cb) bt_event_slot_container[event_index].callback)
+		    (_bt_get_error_code(param->result), BT_ADAPTER_LE_ENABLED, bt_event_slot_container[event_index].user_data);
+		break;
+	case BLUETOOTH_EVENT_LE_DISABLED:
+		BT_INFO("BLUETOOTH_EVENT_LE_DISABLED");
+		((bt_adapter_le_state_changed_cb) bt_event_slot_container[event_index].callback)
+		    (_bt_get_error_code(param->result), BT_ADAPTER_LE_DISABLED, bt_event_slot_container[event_index].user_data);
+		break;
+	case BLUETOOTH_EVENT_LE_DISCOVERY_STARTED:
+		BT_INFO("BLUETOOTH_EVENT_LE_DISCOVERY_STARTED");
+		((bt_adapter_le_device_discovery_state_changed_cb) bt_event_slot_container[event_index].callback)
+			(_bt_get_error_code(param->result), BT_ADAPTER_LE_DEVICE_DISCOVERY_STARTED, NULL, bt_event_slot_container[event_index].user_data);
+		break;
+	case BLUETOOTH_EVENT_LE_DISCOVERY_FINISHED:
+		BT_INFO("BLUETOOTH_EVENT_LE_DISCOVERY_FINISHED");
+		((bt_adapter_le_device_discovery_state_changed_cb)bt_event_slot_container[event_index].callback)
+			(_bt_get_error_code(param->result), BT_ADAPTER_LE_DEVICE_DISCOVERY_FINISHED, NULL, bt_event_slot_container[event_index].user_data);
+		break;
+	case BLUETOOTH_EVENT_REMOTE_LE_DEVICE_FOUND:
+		BT_INFO("BLUETOOTH_EVENT_LE_DISCOVERY_FINISHED");
+		if (__bt_get_bt_adapter_le_device_discovery_info_s(&discovery_info, (bluetooth_le_device_info_t *)(param->param_data)) == BT_ERROR_NONE) {
+			((bt_adapter_le_device_discovery_state_changed_cb)bt_event_slot_container[event_index].callback)
+			    (_bt_get_error_code(param->result), BT_ADAPTER_LE_DEVICE_DISCOVERY_FOUND, discovery_info, bt_event_slot_container[event_index].user_data);
+			__bt_free_bt_adapter_le_device_discovery_info_s(discovery_info);
+		} else {
+			((bt_adapter_le_device_discovery_state_changed_cb)bt_event_slot_container[event_index].callback)
+			    (_bt_get_error_code(param->result), BT_ADAPTER_LE_DEVICE_DISCOVERY_FOUND, NULL, bt_event_slot_container[event_index].user_data);
+		}
 		break;
 	default:
 		break;
@@ -1264,7 +1342,7 @@ static int __bt_get_bt_adapter_device_discovery_info_s(bt_adapter_device_discove
 					__bt_convert_lower_to_upper((*discovery_info)->service_uuid[i]);
 				}
 
-				BT_DBG("UUID: %s", (*discovery_info)->service_uuid[i]);
+				BT_INFO("UUID: %s", (*discovery_info)->service_uuid[i]);
 			}
 		}
 	} else {
@@ -1275,6 +1353,51 @@ static int __bt_get_bt_adapter_device_discovery_info_s(bt_adapter_device_discove
 	(*discovery_info)->rssi = (int)source_info->rssi;
 	(*discovery_info)->is_bonded = (bool)source_info->paired;
 
+	(*discovery_info)->appearance = 0;
+
+	(*discovery_info)->manufacturer_data_len = source_info->manufacturer_data.data_len;
+	if ((*discovery_info)->manufacturer_data_len > 0) {
+		(*discovery_info)->manufacturer_data = malloc(source_info->manufacturer_data.data_len);
+		memcpy((*discovery_info)->manufacturer_data, source_info->manufacturer_data.data, source_info->manufacturer_data.data_len);
+	} else {
+		(*discovery_info)->manufacturer_data = NULL;
+	}
+
+	return BT_ERROR_NONE;
+}
+
+static int __bt_get_bt_adapter_le_device_discovery_info_s(
+			bt_adapter_le_device_discovery_info_s **le_discovery_info,
+			bluetooth_le_device_info_t *source_info)
+{
+
+	BT_CHECK_INPUT_PARAMETER(source_info);
+
+	*le_discovery_info = (bt_adapter_le_device_discovery_info_s *)malloc(sizeof(bt_adapter_le_device_discovery_info_s));
+	if (*le_discovery_info == NULL) {
+		return BT_ERROR_OUT_OF_MEMORY;
+	}
+
+	_bt_convert_address_to_string(&((*le_discovery_info)->remote_address), &(source_info->device_address));
+
+	(*le_discovery_info)->address_type = (int)source_info->addr_type;
+	(*le_discovery_info)->rssi = (int)source_info->rssi;
+	(*le_discovery_info)->adv_data_len = source_info->adv_ind_data.data_len;
+	if ((*le_discovery_info)->adv_data_len > 0) {
+		(*le_discovery_info)->adv_data = malloc(source_info->adv_ind_data.data_len);
+		memcpy((*le_discovery_info)->adv_data, source_info->adv_ind_data.data.data, source_info->adv_ind_data.data_len);
+	} else {
+		(*le_discovery_info)->adv_data = NULL;
+	}
+
+	(*le_discovery_info)->scan_data_len = source_info->scan_resp_data.data_len;
+	if ((*le_discovery_info)->scan_data_len > 0) {
+		(*le_discovery_info)->scan_data = malloc(source_info->scan_resp_data.data_len);
+		memcpy((*le_discovery_info)->scan_data, source_info->scan_resp_data.data.data, source_info->scan_resp_data.data_len);
+	} else {
+		(*le_discovery_info)->scan_data = NULL;
+	}
+
 	return BT_ERROR_NONE;
 }
 
@@ -1298,6 +1421,25 @@ static void __bt_free_bt_adapter_device_discovery_info_s(bt_adapter_device_disco
 		}
 		free(discovery_info->service_uuid);
 	}
+	if (discovery_info->manufacturer_data != NULL)
+		free(discovery_info->manufacturer_data);
+
+	free(discovery_info);
+	discovery_info = NULL;
+}
+
+static void __bt_free_bt_adapter_le_device_discovery_info_s(bt_adapter_le_device_discovery_info_s *discovery_info)
+{
+	if (discovery_info == NULL)
+		return;
+
+	if (discovery_info->remote_address != NULL)
+		free(discovery_info->remote_address);
+
+	if (discovery_info->adv_data != NULL)
+		free(discovery_info->adv_data);
+	if (discovery_info->scan_data != NULL)
+		free(discovery_info->scan_data);
 
 	free(discovery_info);
 	discovery_info = NULL;
@@ -1309,14 +1451,23 @@ static int __bt_get_cb_index(int event)
 	case BLUETOOTH_EVENT_ENABLED:
 	case BLUETOOTH_EVENT_DISABLED:
 		return BT_EVENT_STATE_CHANGED;
+	case BLUETOOTH_EVENT_LE_ENABLED:
+	case BLUETOOTH_EVENT_LE_DISABLED:
+		return BT_EVENT_LE_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_DISCOVERABLE_TIMEOUT_CHANGED:
+		return BT_EVENT_VISIBILITY_DURATION_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_LE_DISCOVERY_STARTED:
+	case BLUETOOTH_EVENT_LE_DISCOVERY_FINISHED:
+	case BLUETOOTH_EVENT_REMOTE_LE_DEVICE_FOUND:
+		return BT_EVENT_LE_DEVICE_DISCOVERY_STATE_CHANGED;
 	case BLUETOOTH_EVENT_BONDING_FINISHED:
 		return BT_EVENT_BOND_CREATED;
 	case BLUETOOTH_EVENT_BONDED_DEVICE_REMOVED:
@@ -1418,32 +1569,16 @@ static int __bt_get_cb_index(int event)
 	case BLUETOOTH_HID_DISCONNECTED:
 		return  BT_EVENT_HID_CONNECTION_STATUS;
 	case BLUETOOTH_EVENT_GATT_SVC_CHAR_DISCOVERED:
-		return	BT_EVENT_GATT_CHARACTERISTIC_DISCOVERED;
+		return BT_EVENT_GATT_CHARACTERISTIC_DISCOVERED;
 	case BLUETOOTH_EVENT_GATT_CHAR_VAL_CHANGED:
-		return	BT_EVENT_GATT_VALUE_CHANGED;
+		return BT_EVENT_GATT_VALUE_CHANGED;
+	case BLUETOOTH_EVENT_GATT_READ_CHAR:
+		return BT_EVENT_GATT_READ_CHARACTERISTIC;
+	case BLUETOOTH_EVENT_GATT_SVC_CHAR_DESC_DISCOVERED:
+		return BT_EVENT_GATT_CHARACTERISTIC_DESCRIPTOR_DISCOVERED;
 	case BLUETOOTH_EVENT_ADVERTISING_STARTED:
 	case BLUETOOTH_EVENT_ADVERTISING_STOPPED:
-		return	BT_EVENT_ADVERTISING_STATE_CHANGED;
-	case BLUETOOTH_EVENT_ADVERTISING_MANUFACTURER_DATA_CHANGED:
-		return	BT_EVENT_ADVERTISING_MANUFACTURER_DATA_CHANGED;
-	case BLUETOOTH_EVENT_HF_CONNECTED:
-		return BT_EVENT_AUDIO_CONNECTION_STATUS;
-	case BLUETOOTH_EVENT_HF_DISCONNECTED:
-		return BT_EVENT_AUDIO_CONNECTION_STATUS;
-	case BLUETOOTH_EVENT_HF_AUDIO_CONNECTED:
-		return BT_EVENT_HF_SCO_CONNECTION_STATUS;
-	case BLUETOOTH_EVENT_HF_AUDIO_DISCONNECTED:
-		return BT_EVENT_HF_SCO_CONNECTION_STATUS;
-	case BLUETOOTH_EVENT_HF_RING_INDICATOR:
-	case BLUETOOTH_EVENT_HF_CALL_TERMINATED:
-	case BLUETOOTH_EVENT_HF_CALL_STARTED:
-	case BLUETOOTH_EVENT_HF_CALL_ENDED:
-	case BLUETOOTH_EVENT_HF_VOICE_RECOGNITION_ENABLED:
-	case BLUETOOTH_EVENT_HF_VOICE_RECOGNITION_DISABLED:
-	case BLUETOOTH_EVENT_HF_VENDOR_DEP_CMD:
-		return BT_EVENT_HF_CALL_HANDLING_EVENT;
-	case BLUETOOTH_EVENT_HF_VOLUME_SPEAKER:
-		return BT_EVENT_HF_SPEAKER_GAIN_CHANGE;
+		return BT_EVENT_ADVERTISING_STATE_CHANGED;
 	case BLUETOOTH_EVENT_CONNECTABLE_CHANGED:
 		return BT_EVENT_CONNECTABLE_CHANGED_EVENT;
 	default:
diff --git a/wearable/src/bluetooth-device.c b/src/bluetooth-device.c
index 3d81708..1a132da 100755..100644
--- a/wearable/src/bluetooth-device.c
+++ b/src/bluetooth-device.c
@@ -39,6 +39,23 @@ int bt_device_create_bond(const char *device_address)
 	return error_code;
 }
 
+int bt_device_create_bond_by_type(const char *device_address,
+			bt_device_connection_link_type_e conn_type)
+{
+	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_by_type(&addr_hex, conn_type));
+	if (error_code != BT_ERROR_NONE) {
+		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code);
+	}
+
+	return error_code;
+}
+
 int bt_device_cancel_bonding(void)
 {
 	int error_code = BT_ERROR_NONE;
@@ -148,7 +165,8 @@ int bt_device_foreach_connected_profiles(const char *remote_address, bt_device_c
 	int i = 0;
 	int profiles[] = {BT_PROFILE_RFCOMM, BT_PROFILE_A2DP,
 			BT_PROFILE_HSP, BT_PROFILE_HID, BT_PROFILE_NAP,
-			BT_PROFILE_AG, BT_PROFILE_GATT, 0};
+			BT_PROFILE_AG, BT_PROFILE_GATT, BT_PROFILE_NAP_SERVER,
+			0};
 
 	BT_CHECK_INIT_STATUS();
 	BT_CHECK_INPUT_PARAMETER(remote_address);
@@ -181,6 +199,7 @@ int bt_device_is_profile_connected(const char *remote_address, bt_profile_e bt_p
 {
 	bluetooth_device_address_t addr_hex = { {0,} };
 	int ret;
+	gboolean is_connected = FALSE;
 
 	BT_CHECK_INIT_STATUS();
 	BT_CHECK_INPUT_PARAMETER(remote_address);
@@ -188,7 +207,8 @@ int bt_device_is_profile_connected(const char *remote_address, bt_profile_e bt_p
 	_bt_convert_address_to_hex(&addr_hex, remote_address);
 
 	ret = _bt_get_error_code(bluetooth_is_device_connected(&addr_hex, bt_profile,
-								(gboolean *) connected_status));
+								&is_connected));
+	*connected_status = is_connected ? true : false;
 
 	if (ret != BT_ERROR_NONE) {
 		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
@@ -244,15 +264,6 @@ int bt_device_set_connection_state_changed_cb(bt_device_connection_state_changed
 	return BT_ERROR_NONE;
 }
 
-int bt_device_set_disconnected_cb(bt_device_disconnected_cb callback, void *user_data)
-{
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(callback);
-	_bt_set_cb(BT_EVENT_DEVICE_DISCONNECTED, callback, user_data);
-
-	return BT_ERROR_NONE;
-}
-
 int bt_device_unset_bond_created_cb(void)
 {
 	BT_CHECK_INIT_STATUS();
@@ -288,49 +299,212 @@ int bt_device_unset_connection_state_changed_cb(void)
 	return BT_ERROR_NONE;
 }
 
-int bt_device_unset_disconnected_cb(void)
+int bt_device_le_conn_update(const char *device_address,
+            const bt_le_conn_update_s *parameters)
 {
-	BT_CHECK_INIT_STATUS();
-	_bt_unset_cb(BT_EVENT_DEVICE_DISCONNECTED);
-	return BT_ERROR_NONE;
-}
-
-int bt_device_connect_le(bt_device_gatt_state_changed_cb callback, const char *address)
-{
-	int ret;
-	bluetooth_device_address_t bd_addr = { {0,} };
+	bluetooth_device_address_t addr_hex = { {0,} };
+	bluetooth_le_conn_update_t param= { 0 };
+	int ret = BT_ERROR_NONE;
 
 	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(address);
-
-	_bt_set_cb(BT_EVENT_GATT_CONNECTION_STATUS, callback, NULL);
+	BT_CHECK_INPUT_PARAMETER(device_address);
+	BT_CHECK_INPUT_PARAMETER(parameters);
 
-	_bt_convert_address_to_hex(&bd_addr, address);
+	_bt_convert_address_to_hex(&addr_hex, device_address);
+	param.interval_min = parameters->interval_min;
+	param.interval_max = parameters->interval_max;
+	param.latency = parameters->latency;
+	param.time_out = parameters->time_out;
 
-	ret = _bt_get_error_code(bluetooth_connect_le(&bd_addr));
+	ret = _bt_get_error_code(bluetooth_le_conn_update(&addr_hex, &param));
 
-	if (ret != BT_ERROR_NONE) {
+	if (BT_ERROR_NONE != ret) {
 		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
 	}
+
 	return ret;
 }
 
-int bt_device_disconnect_le(bt_device_gatt_state_changed_cb callback, const char *address)
+int bt_device_get_service_mask_from_uuid_list(char **uuids,
+				      int no_of_service,
+				      bt_service_class_t *service_mask_list)
 {
-	int ret;
-	bluetooth_device_address_t bd_addr = { {0,} };
+	BT_DBG("Get service mask from uuid list");
+	BT_CHECK_INPUT_PARAMETER(uuids);
+	BT_CHECK_INPUT_PARAMETER(service_mask_list);
 
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(address);
+	int i = 0;
+	unsigned int service = 0;
+	char **parts = NULL;
+	bt_service_class_t service_mask = 0;
 
-	_bt_convert_address_to_hex(&bd_addr, address);
+	BT_DBG("no_of_service = %d", no_of_service);
 
-	_bt_set_cb(BT_EVENT_GATT_CONNECTION_STATUS, callback, NULL);
+	for (i = 0; i < no_of_service; i++) {
+		parts = g_strsplit(uuids[i], "-", -1);
 
-	ret = _bt_get_error_code(bluetooth_disconnect_le(&bd_addr));
+		if (parts == NULL || parts[0] == NULL) {
+			g_strfreev(parts);
+			continue;
+		}
+
+		service = g_ascii_strtoull(parts[0], NULL, 16);
+		g_strfreev(parts);
+
+		switch (service) {
+		case BLUETOOTH_SPP_PROFILE_UUID:
+			service_mask |= BT_SC_SPP_SERVICE_MASK;
+			break;
+
+		case BLUETOOTH_LAP_PROFILE_UUID:
+			service_mask |= BT_SC_LAP_SERVICE_MASK;
+			break;
+
+		case BLUETOOTH_DUN_PROFILE_UUID:
+			service_mask |= BT_SC_DUN_SERVICE_MASK;
+			break;
+
+		case BLUETOOTH_OBEX_IR_MC_SYNC_SERVICE_UUID:
+			service_mask |= BT_SC_SYNC_SERVICE_MASK;
+			break;
+
+		case BLUETOOTH_OBEX_OBJECT_PUSH_SERVICE_UUID:
+			service_mask |= BT_SC_OPP_SERVICE_MASK;
+			break;
+
+		case BLUETOOTH_OBEX_FILE_TRANSFER_UUID:
+			service_mask |= BT_SC_FTP_SERVICE_MASK;
+			break;
+
+		case BLUETOOTH_HS_PROFILE_UUID:
+			service_mask |= BT_SC_HSP_SERVICE_MASK;
+			break;
+
+		case BLUETOOTH_CTP_PROFILE_UUID:
+			service_mask |= BT_SC_CTP_SERVICE_MASK;
+			break;
+
+		case BLUETOOTH_AUDIO_SOURCE_UUID:
+			service_mask |= BT_SC_NONE;
+			break;
+
+		case BLUETOOTH_AUDIO_SINK_UUID:
+			service_mask |= BT_SC_A2DP_SERVICE_MASK;
+			break;
+
+		case BLUETOOTH_VIDEO_SOURCE_UUID:
+			service_mask |= BT_SC_NONE;
+			break;
+
+		case BLUETOOTH_VIDEO_SINK_UUID:
+			service_mask |= BT_SC_NONE;
+			break;
+
+		case BLUETOOTH_AV_REMOTE_CONTROL_TARGET_UUID:
+			service_mask |= BT_SC_NONE;
+			break;
+
+		case BLUETOOTH_ADVANCED_AUDIO_PROFILE_UUID:
+			service_mask |= BT_SC_A2DP_SERVICE_MASK;
+			break;
+
+		case BLUETOOTH_AV_REMOTE_CONTROL_UUID:
+			service_mask |= BT_SC_AVRCP_SERVICE_MASK;
+			break;
+
+		case BLUETOOTH_ICP_PROFILE_UUID:
+			service_mask |= BT_SC_ICP_SERVICE_MASK;
+			break;
+
+		case BLUETOOTH_FAX_PROFILE_UUID:
+			service_mask |= BT_SC_FAX_SERVICE_MASK;
+			break;
+
+		case BLUETOOTH_HEADSET_AG_SERVICE_UUID:
+			service_mask |= BT_SC_NONE; /* BT_SC_HSP_SERVICE_MASK */
+			break;
+
+		case BLUETOOTH_PAN_PANU_PROFILE_UUID:
+			service_mask |= BT_SC_PANU_SERVICE_MASK;
+			break;
+
+		case BLUETOOTH_PAN_NAP_PROFILE_UUID:
+			service_mask |= BT_SC_NAP_SERVICE_MASK;
+			break;
+
+		case BLUETOOTH_PAN_GN_PROFILE_UUID:
+			service_mask |= BT_SC_GN_SERVICE_MASK;
+			break;
+
+		case BLUETOOTH_REFERENCE_PRINTING:
+			service_mask |= BT_SC_NONE;
+			break;
+
+		case BLUETOOTH_OBEX_IMAGING_UUID:
+			service_mask |= BT_SC_NONE;
+			break;
+
+		case BLUETOOTH_OBEX_IMAGING_RESPONDER_UUID:
+			service_mask |= BT_SC_BIP_SERVICE_MASK;
+			break;
+
+		case BLUETOOTH_HF_PROFILE_UUID:
+			service_mask |= BT_SC_HFP_SERVICE_MASK;
+			break;
+
+		case BLUETOOTH_HFG_PROFILE_UUID:
+			service_mask |= BT_SC_NONE;
+			break;
+
+		case BLUETOOTH_DIRECT_PRINTING_REFERENCE_OBJ_UUID:
+			service_mask |= BT_SC_NONE;
+			break;
+
+		case BLUETOOTH_BASIC_PRINTING:
+			service_mask |= BT_SC_NONE;
+			break;
+
+		case BLUETOOTH_HID_PROFILE_UUID:
+			service_mask |= BT_SC_HID_SERVICE_MASK;
+			break;
+
+		case BLUETOOTH_SIM_ACCESS_PROFILE_UUID:
+			service_mask |= BT_SC_SAP_SERVICE_MASK;
+			break;
+
+		case BLUETOOTH_OBEX_PBA_PROFILE_UUID:
+			service_mask |= BT_SC_PBAP_SERVICE_MASK;
+			break;
+
+		case BLUETOOTH_OBEX_BPPS_PROFILE_UUID:
+			service_mask |= BT_SC_BPP_SERVICE_MASK;
+			break;
+
+		case BLUETOOTH_PNP_INFORMATION_UUID:
+			service_mask |= BT_SC_NONE;
+			break;
+
+		case BLUETOOTH_OBEX_PRINTING_STATUS_UUID:
+			service_mask |= BT_SC_BPP_SERVICE_MASK;
+			break;
+
+		case BLUETOOTH_HCR_PROFILE_UUID:
+			service_mask |= BT_SC_NONE;
+			break;
+
+		case BLUETOOTH_OBEX_SYNCML_TRANSFER_UUID:
+			service_mask |= BT_SC_NONE;
+			break;
+
+		default:
+			break;
+		}
 
-	if (ret != BT_ERROR_NONE) {
-	BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
 	}
-	return ret;
+
+	*service_mask_list = service_mask;
+	BT_DBG("service_mask = %x, service_mask_list = %x", service_mask,
+	       service_mask_list);
+
+	return BT_ERROR_NONE;
 }
diff --git a/wearable/src/bluetooth-gatt.c b/src/bluetooth-gatt.c
index ddc2cd2..d2fa1c4 100644..100755
--- a/wearable/src/bluetooth-gatt.c
+++ b/src/bluetooth-gatt.c
@@ -52,7 +52,7 @@ int bt_gatt_foreach_primary_services(const char *remote_address,
 		if (prim_svc->handle[i] == NULL)
 			continue;
 
-		BT_DBG("handle: %s", prim_svc->handle[i]);
+		BT_INFO("handle: %s", prim_svc->handle[i]);
 
 		if (foreach_call == true &&
 		    !callback((bt_gatt_attribute_h)prim_svc->handle[i], user_data)) {
@@ -340,3 +340,76 @@ int bt_gatt_read_characteristic_value(bt_gatt_attribute_h characteristic,
 
 	return ret;
 }
+
+int bt_gatt_discover_characteristic_descriptor(bt_gatt_attribute_h characteristic_handle,
+				bt_gatt_characteristic_descriptor_discovered_cb callback,
+				void *user_data)
+{
+	int ret;
+
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(characteristic_handle);
+	BT_CHECK_INPUT_PARAMETER(callback);
+
+	ret = _bt_get_error_code(bluetooth_gatt_discover_characteristic_descriptor
+							((const char *)characteristic_handle));
+
+	if (ret != BT_ERROR_NONE) {
+		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
+	} else {
+		_bt_set_cb(BT_EVENT_GATT_CHARACTERISTIC_DESCRIPTOR_DISCOVERED, callback, user_data);
+	}
+
+	return ret;
+}
+
+int bt_gatt_connect(const char *address, bool auto_connect)
+{
+	int ret;
+	bluetooth_device_address_t bd_addr = { {0,} };
+
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(address);
+	_bt_convert_address_to_hex(&bd_addr, address);
+
+	ret = _bt_get_error_code(bluetooth_connect_le(&bd_addr, auto_connect ? TRUE : FALSE));
+
+	if (ret != BT_ERROR_NONE) {
+		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
+	}
+	return ret;
+}
+
+int bt_gatt_disconnect(const char *address)
+{
+	int ret;
+	bluetooth_device_address_t bd_addr = { {0,} };
+
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(address);
+	_bt_convert_address_to_hex(&bd_addr, address);
+
+	ret = _bt_get_error_code(bluetooth_disconnect_le(&bd_addr));
+
+	if (ret != BT_ERROR_NONE) {
+		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret);
+	}
+	return ret;
+}
+
+int bt_gatt_set_connection_state_changed_cb(bt_gatt_connection_state_changed_cb callback, void *user_data)
+{
+	BT_CHECK_INIT_STATUS();
+	BT_CHECK_INPUT_PARAMETER(callback);
+	_bt_set_cb(BT_EVENT_GATT_CONNECTION_STATUS, callback, user_data);
+
+	return BT_ERROR_NONE;
+}
+
+int bt_gatt_unset_connection_state_changed_cb(void)
+{
+	BT_CHECK_INIT_STATUS();
+	_bt_unset_cb(BT_EVENT_GATT_CONNECTION_STATUS);
+	return BT_ERROR_NONE;
+}
+
diff --git a/wearable/src/bluetooth-hdp.c b/src/bluetooth-hdp.c
index 6a553d6..6a553d6 100644
--- a/wearable/src/bluetooth-hdp.c
+++ b/src/bluetooth-hdp.c
diff --git a/wearable/src/bluetooth-hid.c b/src/bluetooth-hid.c
index 8c00eba..b8a168a 100644
--- a/wearable/src/bluetooth-hid.c
+++ b/src/bluetooth-hid.c
@@ -25,6 +25,25 @@
 #include "bluetooth.h"
 #include "bluetooth_private.h"
 
+static bool is_hid_host_initialized = false;
+
+#define BT_CHECK_HID_HOST_INIT_STATUS() \
+	if (__bt_check_hid_host_init_status() == BT_ERROR_NOT_INITIALIZED) \
+	{ \
+		LOGE("[%s] NOT_INITIALIZED(0x%08x)", __FUNCTION__, BT_ERROR_NOT_INITIALIZED); \
+		return BT_ERROR_NOT_INITIALIZED; \
+	}
+
+int __bt_check_hid_host_init_status(void)
+{
+	if (is_hid_host_initialized != true) {
+		BT_ERR("NOT_INITIALIZED(0x%08x)", BT_ERROR_NOT_INITIALIZED);
+		return BT_ERROR_NOT_INITIALIZED;
+	}
+
+	return BT_ERROR_NONE;
+}
+
 int bt_hid_host_initialize(bt_hid_host_connection_state_changed_cb connection_cb,
 								void *user_data)
 {
@@ -37,10 +56,13 @@ int bt_hid_host_initialize(bt_hid_host_connection_state_changed_cb connection_cb
 	error = _bt_get_error_code(error);
 	if (BT_ERROR_NONE != error) {
 		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error);
-	} else {
-		_bt_set_cb(BT_EVENT_HID_CONNECTION_STATUS, connection_cb, user_data);
+		return error;
 	}
-	return error;
+
+	_bt_set_cb(BT_EVENT_HID_CONNECTION_STATUS, connection_cb, user_data);
+
+	is_hid_host_initialized = true;
+	return BT_ERROR_NONE;
 }
 
 int bt_hid_host_deinitialize()
@@ -48,16 +70,19 @@ int bt_hid_host_deinitialize()
 	int error;
 
 	BT_CHECK_INIT_STATUS();
+	BT_CHECK_HID_HOST_INIT_STATUS();
 
 	error = bluetooth_hid_deinit();
 	error = _bt_get_error_code(error);
 	if (BT_ERROR_NONE != error) {
 		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error);
-	} else {
-		_bt_unset_cb(BT_EVENT_HID_CONNECTION_STATUS);
+		return error;
 	}
 
-	return error;
+	_bt_unset_cb(BT_EVENT_HID_CONNECTION_STATUS);
+
+	is_hid_host_initialized = false;
+	return BT_ERROR_NONE;
 }
 
 int bt_hid_host_connect(const char *remote_address)
@@ -66,6 +91,7 @@ int bt_hid_host_connect(const char *remote_address)
 	bluetooth_device_address_t addr_hex = { {0,} };
 
 	BT_CHECK_INIT_STATUS();
+	BT_CHECK_HID_HOST_INIT_STATUS();
 	BT_CHECK_INPUT_PARAMETER(remote_address);
 
 	_bt_convert_address_to_hex(&addr_hex, remote_address);
@@ -84,6 +110,7 @@ int bt_hid_host_disconnect(const char *remote_address)
 	bluetooth_device_address_t addr_hex = { {0,} };
 
 	BT_CHECK_INIT_STATUS();
+	BT_CHECK_HID_HOST_INIT_STATUS();
 	BT_CHECK_INPUT_PARAMETER(remote_address);
 
 	_bt_convert_address_to_hex(&addr_hex, remote_address);
diff --git a/wearable/src/bluetooth-opp-client.c b/src/bluetooth-opp-client.c
index 4270379..6e870a1 100644
--- a/wearable/src/bluetooth-opp-client.c
+++ b/src/bluetooth-opp-client.c
@@ -25,6 +25,24 @@
 #include "bluetooth_private.h"
 
 GList *sending_files;
+static bool is_opp_client_initialized = false;
+
+#define BT_CHECK_OPP_CLIENT_INIT_STATUS() \
+	if (__bt_check_opp_client_init_status() == BT_ERROR_NOT_INITIALIZED) \
+	{ \
+		LOGE("[%s] NOT_INITIALIZED(0x%08x)", __FUNCTION__, BT_ERROR_NOT_INITIALIZED); \
+		return BT_ERROR_NOT_INITIALIZED; \
+	}
+
+int __bt_check_opp_client_init_status(void)
+{
+	if (is_opp_client_initialized != true) {
+		BT_ERR("NOT_INITIALIZED(0x%08x)", BT_ERROR_NOT_INITIALIZED);
+		return BT_ERROR_NOT_INITIALIZED;
+	}
+
+	return BT_ERROR_NONE;
+}
 
 char** __bt_opp_get_file_array(GList *file_list)
 {
@@ -71,9 +89,11 @@ int bt_opp_client_initialize(void)
 	if (error_code != BT_ERROR_NONE) {
 		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code),
 				error_code);
+		return error_code;
 	}
 
-	return error_code;
+	is_opp_client_initialized = true;
+	return BT_ERROR_NONE;
 }
 
 int bt_opp_client_deinitialize(void)
@@ -81,17 +101,19 @@ int bt_opp_client_deinitialize(void)
 	int error_code = BT_ERROR_NONE;
 
 	BT_CHECK_INIT_STATUS();
+	BT_CHECK_OPP_CLIENT_INIT_STATUS();
 
 	error_code = _bt_get_error_code(bluetooth_opc_deinit());
+	bt_opp_client_clear_files();
 
 	if (error_code != BT_ERROR_NONE) {
 		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code),
 				error_code);
+		return error_code;
 	}
 
-	bt_opp_client_clear_files();
-
-	return error_code;
+	is_opp_client_initialized = false;
+	return BT_ERROR_NONE;
 }
 
 int bt_opp_client_add_file(const char *file)
@@ -99,12 +121,16 @@ int bt_opp_client_add_file(const char *file)
 	int error_code = BT_ERROR_NONE;
 
 	BT_CHECK_INIT_STATUS();
+	BT_CHECK_OPP_CLIENT_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;
+		if (errno == EACCES || errno == EPERM)
+			error_code = BT_ERROR_PERMISSION_DENIED;
+		else
+			error_code = BT_ERROR_INVALID_PARAMETER;
 		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code),
 				error_code);
 	}
@@ -119,6 +145,7 @@ int bt_opp_client_clear_files(void)
 	char *c_file = NULL;
 
 	BT_CHECK_INIT_STATUS();
+	BT_CHECK_OPP_CLIENT_INIT_STATUS();
 
 	if (sending_files) {
 		file_num = g_list_length(sending_files);
@@ -150,6 +177,7 @@ int bt_opp_client_push_files(const char *remote_address,
 	char **files = NULL;
 
 	BT_CHECK_INIT_STATUS();
+	BT_CHECK_OPP_CLIENT_INIT_STATUS();
 	BT_CHECK_INPUT_PARAMETER(remote_address);
 
 	_bt_convert_address_to_hex(&addr_hex, remote_address);
@@ -180,6 +208,7 @@ int bt_opp_client_cancel_push(void)
 	int error_code = BT_ERROR_NONE;
 
 	BT_CHECK_INIT_STATUS();
+	BT_CHECK_OPP_CLIENT_INIT_STATUS();
 
 	error_code = _bt_get_error_code(bluetooth_opc_cancel_push());
 
diff --git a/wearable/src/bluetooth-opp-server.c b/src/bluetooth-opp-server.c
index f16d553..6b92619 100644
--- a/wearable/src/bluetooth-opp-server.c
+++ b/src/bluetooth-opp-server.c
@@ -22,6 +22,25 @@
 #include "bluetooth.h"
 #include "bluetooth_private.h"
 
+static bool is_opp_server_initialized = false;
+
+#define BT_CHECK_OPP_SERVER_INIT_STATUS() \
+	if (__bt_check_opp_server_init_status() == BT_ERROR_NOT_INITIALIZED) \
+	{ \
+		LOGE("[%s] NOT_INITIALIZED(0x%08x)", __FUNCTION__, BT_ERROR_NOT_INITIALIZED); \
+		return BT_ERROR_NOT_INITIALIZED; \
+	}
+
+int __bt_check_opp_server_init_status(void)
+{
+	if (is_opp_server_initialized != true) {
+		BT_ERR("NOT_INITIALIZED(0x%08x)", BT_ERROR_NOT_INITIALIZED);
+		return BT_ERROR_NOT_INITIALIZED;
+	}
+
+	return BT_ERROR_NONE;
+}
+
 int bt_opp_server_initialize(const char *destination,
 			bt_opp_server_push_requested_cb push_requested_cb,
 			void *user_data)
@@ -36,11 +55,13 @@ int bt_opp_server_initialize(const char *destination,
 	if (error_code != BT_ERROR_NONE) {
 		BT_ERR("%s(0x%08x)", _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;
 	}
 
-	return error_code;
+	_bt_set_cb(BT_EVENT_OPP_PUSH_REQUESTED, push_requested_cb, user_data);
+
+	is_opp_server_initialized = true;
+	return BT_ERROR_NONE;
 }
 
 int bt_opp_server_initialize_by_connection_request(const char *destination,
@@ -57,11 +78,13 @@ int bt_opp_server_initialize_by_connection_request(const char *destination,
 	if (error_code != BT_ERROR_NONE) {
 		BT_ERR("%s(0x%08x)", _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;
 	}
 
-	return error_code;
+	_bt_set_cb(BT_EVENT_OPP_CONNECTION_REQUESTED, connection_requested_cb, user_data);
+
+	is_opp_server_initialized = true;
+	return BT_ERROR_NONE;
 }
 
 int bt_opp_server_deinitialize(void)
@@ -69,6 +92,7 @@ int bt_opp_server_deinitialize(void)
 	int error_code = BT_ERROR_NONE;
 
 	BT_CHECK_INIT_STATUS();
+	BT_CHECK_OPP_SERVER_INIT_STATUS();
 
 	if (_bt_check_cb(BT_EVENT_OPP_CONNECTION_REQUESTED) == false) {
 		error_code = _bt_get_error_code(bluetooth_obex_server_deinit());
@@ -77,15 +101,17 @@ int bt_opp_server_deinitialize(void)
 		error_code = _bt_get_error_code(bluetooth_obex_server_deinit_without_agent());
 	}
 
+	_bt_unset_cb(BT_EVENT_OPP_CONNECTION_REQUESTED);
+	_bt_unset_cb(BT_EVENT_OPP_PUSH_REQUESTED);
+
 	if (error_code != BT_ERROR_NONE) {
 		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code),
 				error_code);
+		return error_code;
 	}
 
-	_bt_unset_cb(BT_EVENT_OPP_CONNECTION_REQUESTED);
-	_bt_unset_cb(BT_EVENT_OPP_PUSH_REQUESTED);
-
-	return error_code;
+	is_opp_server_initialized = false;
+	return BT_ERROR_NONE;
 }
 
 int bt_opp_server_accept(bt_opp_server_transfer_progress_cb progress_cb,
@@ -97,6 +123,7 @@ int bt_opp_server_accept(bt_opp_server_transfer_progress_cb progress_cb,
 	int error_code = BT_ERROR_NONE;
 
 	BT_CHECK_INIT_STATUS();
+	BT_CHECK_OPP_SERVER_INIT_STATUS();
 
 	/* Unset the transfer callbacks */
 	_bt_unset_cb(BT_EVENT_OPP_SERVER_TRANSFER_PROGRESS);
@@ -125,6 +152,7 @@ int bt_opp_server_reject(void)
 	int error_code = BT_ERROR_NONE;
 
 	BT_CHECK_INIT_STATUS();
+	BT_CHECK_OPP_SERVER_INIT_STATUS();
 
 	if (_bt_check_cb(BT_EVENT_OPP_CONNECTION_REQUESTED) == false) {
 		error_code = _bt_get_error_code(bluetooth_obex_server_reject_authorize());
@@ -150,6 +178,7 @@ int bt_opp_server_set_destination(const char *destination)
 	int error_code = BT_ERROR_NONE;
 
 	BT_CHECK_INIT_STATUS();
+	BT_CHECK_OPP_SERVER_INIT_STATUS();
 	BT_CHECK_INPUT_PARAMETER(destination);
 
 	error_code = _bt_get_error_code(bluetooth_obex_server_set_destination_path(destination));
@@ -166,6 +195,7 @@ int bt_opp_server_cancel_transfer(int transfer_id)
 	int error_code = BT_ERROR_NONE;
 
 	BT_CHECK_INIT_STATUS();
+	BT_CHECK_OPP_SERVER_INIT_STATUS();
 
 	error_code = _bt_get_error_code(bluetooth_obex_server_cancel_transfer(transfer_id));
 	if (error_code != BT_ERROR_NONE) {
diff --git a/mobile/src/bluetooth-pan.c b/src/bluetooth-pan.c
index 740b429..052d404 100644
--- a/mobile/src/bluetooth-pan.c
+++ b/src/bluetooth-pan.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
+ * 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.
@@ -82,7 +82,7 @@ int bt_nap_disconnect(const char *remote_address)
 	error = _bt_get_error_code(error);
 	if (error != BT_ERROR_NONE) {
 		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error),
-			error);
+				error);
 	}
 	return error;
 }
diff --git a/wearable/src/bluetooth-socket.c b/src/bluetooth-socket.c
index 4143306..22eb514 100644
--- a/wearable/src/bluetooth-socket.c
+++ b/src/bluetooth-socket.c
@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 
+#include <errno.h>
+#include <tizen.h>
 #include <dlog.h>
 #include <stdio.h>
 #include <bluetooth-api.h>
@@ -94,13 +96,13 @@ int bt_socket_listen(int socket_fd, int max_pending_connections)
 	return error_code;
 }
 
-int bt_socket_accept(int socket_fd, int *connected_socket_fd)
+int bt_socket_accept(int 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));
+	error_code = _bt_get_error_code(bluetooth_rfcomm_accept_connection(socket_fd));
 	if (error_code != BT_ERROR_NONE) {
 		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code),
 				error_code);
@@ -164,9 +166,24 @@ 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 <= 0)
+	if (ret <= 0) {
+		if (ret == -1) {
+			/* write fail case */
+			if (errno == EACCES || errno == EPERM)
+				set_last_result(BT_ERROR_PERMISSION_DENIED);
+			else if (errno == EAGAIN || errno == EWOULDBLOCK)
+				set_last_result(BT_ERROR_AGAIN);
+			else
+				set_last_result(BT_ERROR_OPERATION_FAILED);
+		} else {
+			ret = _bt_get_error_code(ret);
+			set_last_result(ret);
+		}
+
 		BT_ERR("Write failed, ret = %d", ret);
+	}
 
 	return ret;
 }
diff --git a/wearable/test/CMakeLists.txt b/test/CMakeLists.txt
index b4e8292..898754a 100644
--- a/wearable/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -17,4 +17,5 @@ FOREACH(src ${sources})
 ENDFOREACH()
 
 INSTALL(TARGETS bt_unit_test DESTINATION bin)
-
+INSTALL(TARGETS bt_onoff DESTINATION bin)
+INSTALL(FILES capi-network-bluetooth-test.efl DESTINATION /etc/smack/accesses.d/)
diff --git a/wearable/test/bt_chat_client.c b/test/bt_chat_client.c
index bfdd5e8..f7e3b47 100644..100755
--- a/wearable/test/bt_chat_client.c
+++ b/test/bt_chat_client.c
@@ -23,7 +23,7 @@
 #ifdef LOG_TAG
 #undef LOG_TAG
 #endif
-#define LOG_TAG "BT_CHAT_CLIENT"
+#define LOG_TAG "BLUETOOTH_CHAT_CLIENT"
 
 /**
  *   Variables
diff --git a/wearable/test/bt_chat_server.c b/test/bt_chat_server.c
index fdc2d19..787c3f7 100644..100755
--- a/wearable/test/bt_chat_server.c
+++ b/test/bt_chat_server.c
@@ -23,7 +23,7 @@
 #ifdef LOG_TAG
 #undef LOG_TAG
 #endif
-#define LOG_TAG "BT_CHAT_SERVER"
+#define LOG_TAG "BLUETOOTH_CHAT_SERVER"
 
 /**
  *   Variables
diff --git a/test/bt_onoff.c b/test/bt_onoff.c
new file mode 100644
index 0000000..f95106a
--- /dev/null
+++ b/test/bt_onoff.c
@@ -0,0 +1,131 @@
+/*
+ * 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.
+ */
+
+/**
+ * @file       bt_onoff.c
+ * @brief      This is the source file for bt activation/deactivation.
+ */
+
+#include <stdio.h>
+#include <glib.h>
+
+#include "bluetooth.h"
+
+#define PRT(format, args...) printf("%s:%d() "format, __FUNCTION__, __LINE__, ##args)
+#define TC_PRT(format, args...) PRT(format"\n", ##args)
+
+GMainLoop *main_loop = NULL;
+static guint onoff_timer = 0;
+
+static void __bt_adapter_state_changed_cb(int result, bt_adapter_state_e adapter_state, void *user_data)
+{
+	TC_PRT("state(%d), error(%d)", adapter_state, result);
+
+	if (onoff_timer)
+		g_source_remove(onoff_timer);
+	onoff_timer = 0;
+
+	if (result != BT_ERROR_NONE) {
+		char *argv[] = {NULL};
+		execv("all_log_dump.sh", argv);
+	}
+
+	if (main_loop)
+		g_main_loop_quit(main_loop);
+	else
+		exit(0);
+}
+
+static gboolean __bt_onoff_timeout_cb(gpointer data)
+{
+	TC_PRT("Timed out");
+
+	char *argv[] = {NULL};
+	execv("all_log_dump.sh", argv);
+
+	if (main_loop)
+		g_main_loop_quit(main_loop);
+	else
+		exit(0);
+
+	return FALSE;
+}
+
+int main(int argc, char* argv[])
+{
+	int ret;
+	bt_adapter_state_e state;
+
+	if(bt_initialize() != BT_ERROR_NONE)
+	{
+		TC_PRT("bt_initialize() failed.");
+		return -1;
+	}
+	if (bt_adapter_set_state_changed_cb(__bt_adapter_state_changed_cb, NULL) != BT_ERROR_NONE)
+	{
+		TC_PRT("bt_adapter_set_state_changed_cb() failed.");
+		goto DONE;
+	}
+
+	main_loop = g_main_loop_new(NULL, FALSE);
+
+	bt_adapter_get_state(&state);
+	ret = bt_adapter_get_state(&state);
+	TC_PRT("state(%d), error(%d)", state, ret);
+
+	onoff_timer = g_timeout_add(20000, (GSourceFunc)__bt_onoff_timeout_cb, NULL);
+
+	if (argc <= 1) {
+		if (state == BT_ADAPTER_DISABLED)
+			ret = bt_adapter_enable();
+		else
+			ret = bt_adapter_disable();
+		TC_PRT("bt_adapter_%s() error(%d)", state==BT_ADAPTER_DISABLED?"enable":"disable", ret);
+	} else {
+		if (argv[1][0] == '0') {
+			if (state == BT_ADAPTER_DISABLED) {
+				TC_PRT("Already disabled");
+				goto DONE;
+			} else {
+				ret = bt_adapter_disable();
+				TC_PRT("bt_adapter_disable() error(%d)", ret);
+				if (ret != BT_ERROR_NONE)
+					goto DONE;
+			}
+		} else {
+			if (state == BT_ADAPTER_ENABLED) {
+				TC_PRT("Already eabled");
+				goto DONE;
+			} else {
+				ret = bt_adapter_enable();
+				TC_PRT("bt_adapter_enable() error(%d)", ret);
+				if (ret != BT_ERROR_NONE)
+					goto DONE;
+			}
+		}
+	}
+
+	g_main_loop_run(main_loop);
+
+DONE:
+	if (onoff_timer)
+		g_source_remove(onoff_timer);
+	onoff_timer = 0;
+	bt_adapter_unset_state_changed_cb();
+	bt_deinitialize();
+
+	return 0;
+}
diff --git a/test/bt_unit_test.c b/test/bt_unit_test.c
new file mode 100644
index 0000000..0c225a7
--- /dev/null
+++ b/test/bt_unit_test.c
@@ -0,0 +1,2067 @@
+/*
+ * capi-network-bluetooth
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact:  Hocheol Seo <hocheol.seo@samsung.com>
+ *		 Girishashok Joshi <girish.joshi@samsung.com>
+ *		 Chanyeol Park <chanyeol.park@samsung.com>
+ *
+ * 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.
+ *
+ */
+
+/**
+ * @file       bt_unit_test.c
+ * @brief      This is the source file for capi unit test.
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <glib.h>
+#include <dbus/dbus-glib.h>
+
+#include "bluetooth.h"
+#include "bluetooth-telephony-api.h"
+#include "bt_unit_test.h"
+
+const char *spp_uuid = "00001101-0000-1000-8000-00805F9B34FB";
+const char *opp_uuid = "00001105-0000-1000-8000-00805f9b34fb";
+
+static bt_unit_test_table_e current_tc_table;
+static char remote_addr[18] = "F6:FB:8F:D8:C8:7C";
+static bool input_automated_test_delay = false;
+
+static int server_fd;
+static int client_fd;
+
+static gboolean is_sub_index = FALSE;
+int service_index;
+int char_service_index;
+static int selected_service_index = -1;
+static int selected_char_index = 0;
+
+bt_gatt_attribute_h service_clone[MAX_SERVICES];
+bt_gatt_attribute_h characteristics[MAX_SERVICES];
+bt_gatt_attribute_h characteristics_services[MAX_SERVICES];
+
+static unsigned char *hash = NULL;
+static unsigned char *randomizer = NULL;
+int hash_len;
+int rand_len;
+
+bt_call_list_h call_list;
+GMainLoop *main_loop = NULL;
+
+tc_table_t tc_main[] = {
+	/* Categories */
+	{"SET ADDRESS"				, BT_UNIT_TEST_FUNCTION_SET_ADDRESS},
+	{"bt_initialize"			, BT_UNIT_TEST_FUNCTION_INITIALIZE},
+	{"bt_deinitialize"			, BT_UNIT_TEST_FUNCTION_DEINITIALIZE},
+	{"Adapter"				, BT_UNIT_TEST_TABLE_ADAPTER},
+	{"Adapter LE"				, BT_UNIT_TEST_TABLE_ADAPTER_LE},
+	{"Device"				, BT_UNIT_TEST_TABLE_DEVICE},
+	{"Socket"				, BT_UNIT_TEST_TABLE_SOCKET},
+	{"Opp"					, BT_UNIT_TEST_TABLE_OPP},
+	{"Audio(ag, a2dp, call)"		, BT_UNIT_TEST_TABLE_AUDIO},
+	{"Pan(nap, panu)"			, BT_UNIT_TEST_TABLE_PAN},
+	{"Gatt"					, BT_UNIT_TEST_TABLE_GATT},
+	{"Avrcp"				, BT_UNIT_TEST_TABLE_AVRCP},
+	{"Hid"					, BT_UNIT_TEST_TABLE_HID},
+	{"Automated test"			, BT_UNIT_TEST_TABLE_AUTOMATED_TEST},
+	{"FINISH"				, 0x00ff},
+	{NULL					, 0x0000},
+};
+
+tc_table_t tc_adapter[] = {
+	/* Adapter functions */
+	{"BACK"								, BT_UNIT_TEST_FUNCTION_BACK},
+	{"bt_adapter_get_state"						, BT_UNIT_TEST_FUNCTION_ADAPTER_GET_STATE},
+	{"bt_adapter_enable"						, BT_UNIT_TEST_FUNCTION_ADAPTER_ENABLE},
+	{"bt_adapter_disable"						, BT_UNIT_TEST_FUNCTION_ADAPTER_DISABLE},
+	{"bt_adapter_recover"						, BT_UNIT_TEST_FUNCTION_ADAPTER_RECOVER},
+	{"bt_adapter_start_device_discovery"				, BT_UNIT_TEST_FUNCTION_ADAPTER_START_DEVICE_DISCOVERY},
+	{"bt_adapter_stop_device_discovery"				, BT_UNIT_TEST_FUNCTION_ADAPTER_STOP_DEVICE_DISCOVERY},
+	{"bt_adapter_is_discovering"					, BT_UNIT_TEST_FUNCTION_ADAPTER_IS_DISCOVERING},
+	{"bt_adapter_foreach_bonded_device"				, BT_UNIT_TEST_FUNCTION_ADAPTER_FOREACH_BONDED_DEVICE},
+	{"bt_adapter_get_bonded_device_info"				, BT_UNIT_TEST_FUNCTION_ADAPTER_GET_BONDED_DEVICE_INFO},
+	{"bt_adapter_is_service_used"					, BT_UNIT_TEST_FUNCTION_ADAPTER_IS_SERVICE_USED},
+	{"bt_adapter_get_visibility"					, BT_UNIT_TEST_FUNCTION_ADAPTER_GET_VISIBILITY},
+	{"bt_adapter_set_device_discovery_state_changed_cb"		, BT_UNIT_TEST_FUNCTION_ADAPTER_SET_DEVICE_DISCOVERY_STATE_CHANGED_CB},
+	{"bt_adapter_unset_device_discovery_state_changed_cb"		, BT_UNIT_TEST_FUNCTION_ADAPTER_UNSET_DEVICE_DISCOVERY_STATE_CHANGED_CB},
+	{"bt_adapter_get_local_oob_data"				, BT_UNIT_TEST_FUNCTION_ADAPTER_GET_LOCAL_OOB_DATA},
+	{"bt_adapter_set_remote_oob_data" 				, BT_UNIT_TEST_FUNCTION_ADAPTER_SET_LOCAL_OOB_DATA},
+	{"bt_adapter_remove_remote_oob_data"				, BT_UNIT_TEST_FUNCTION_ADAPTER_REMOVE_REMOTE_OOB_DATA},
+	{"bt_adapter_set_visibility_mode_changed_cb"			, BT_UNIT_TEST_FUNCTION_ADAPTER_SET_VISIBILITY_MODE_CHANGED_CB},
+	{"bt_adapter_unset_visibility_mode_changed_cb"			, BT_UNIT_TEST_FUNCTION_ADAPTER_UNSET_VISIBILITY_MODE_CHANGED_CB},
+	{"bt_adapter_set_visibility_duration_changed_cb"		, BT_UNIT_TEST_FUNCTION_ADAPTER_SET_VISIBILITY_DURATION_CHANGED_CB},
+	{"bt_adapter_unset_visibility_duration_changed_cb"		, BT_UNIT_TEST_FUNCTION_ADAPTER_UNSET_VISIBILITY_DURATION_CHANGED_CB},
+	{"bt_adapter_set_connectable_changed_cb"			, BT_UNIT_TEST_FUNCTION_ADAPTER_SET_CONNECTABLE_CHANGED_CB},
+	{"bt_adapter_unset_connectable_changed_cb"			, BT_UNIT_TEST_FUNCTION_ADAPTER_UNSET_CONNECTABLE_CHANGED_CB},
+	{"bt_adapter_get_connectable"					, BT_UNIT_TEST_FUNCTION_ADAPTER_GET_CONNECTABLE},
+	{"bt_adapter_set_connectable"					, BT_UNIT_TEST_FUNCTION_ADAPTER_SET_CONNECTABLE},
+	{"bt_adapter_get_version"					, BT_UNIT_TEST_FUNCTION_ADAPTER_GET_VERSION},
+	{"bt_adapter_get_local_info"					, BT_UNIT_TEST_FUNCTION_ADAPTER_GET_LOCAL_INFO},
+	{NULL					, 0x0000},
+};
+
+tc_table_t tc_adapter_le[] = {
+	/* Adapter functions */
+	{"BACK"								, BT_UNIT_TEST_FUNCTION_BACK},
+	{"bt_adapter_le_get_state"					, BT_UNIT_TEST_FUNCTION_ADAPTER_LE_GET_STATE},
+	{"bt_adapter_le_enable" 					, BT_UNIT_TEST_FUNCTION_ADAPTER_LE_ENABLE},
+	{"bt_adapter_le_disable"					, BT_UNIT_TEST_FUNCTION_ADAPTER_LE_DISABLE},
+	{"bt_adapter_le_start_device_discovery"				, BT_UNIT_TEST_FUNCTION_ADAPTER_LE_START_DEVICE_DISCOVERY},
+	{"bt_adapter_le_stop_device_discovery"				, BT_UNIT_TEST_FUNCTION_ADAPTER_LE_STOP_DEVICE_DISCOVERY},
+	{"bt_adapter_le_start_advertising"				, BT_UNIT_TEST_FUNCTION_ADAPTER_LE_START_ADVERTISING},
+	{"bt_adapter_le_stop_advertising"				, BT_UNIT_TEST_FUNCTION_ADAPTER_LE_STOP_ADVERTISING},
+	{"bt_adapter_le_add_white_list"					, BT_UNIT_TEST_FUNCTION_ADAPTER_LE_ADD_WHITE_LIST},
+	{"bt_adapter_le_remove_white_list"				, BT_UNIT_TEST_FUNCTION_ADAPTER_LE_REMOVE_WHITE_LIST},
+	{"bt_adapter_le_clear_white_list"				, BT_UNIT_TEST_FUNCTION_ADAPTER_LE_CLEAR_WHITE_LIST},
+	{"bt_adapter_le_enable_privacy"					, BT_UNIT_TEST_FUNCTION_ADAPTER_LE_ENABLE_PRIVACY},
+	{"bt_adapter_le_set_device_discovery_state_changed_cb"		, BT_UNIT_TEST_FUNCTION_ADAPTER_LE_SET_DEVICE_DISCOVERY_STATE_CHANGED_CB},
+	{"bt_adapter_le_unset_device_discovery_state_changed_cb"	, BT_UNIT_TEST_FUNCTION_ADAPTER_LE_UNSET_DEVICE_DISCOVERY_STATE_CHANGED_CB},
+	{NULL					, 0x0000},
+};
+
+tc_table_t tc_device[] = {
+	/* Device functions */
+	{"BACK"								, BT_UNIT_TEST_FUNCTION_BACK},
+	{"bt_device_set_authorization (true)"				, BT_UNIT_TEST_FUNCTION_DEVICE_SET_AUTHORIZATION_TRUE},
+	{"bt_device_set_authorization (false)"				, BT_UNIT_TEST_FUNCTION_DEVICE_SET_AUTHORIZATION_FALSE},
+	{"bt_device_set_authorization_changed_cb"			, BT_UNIT_TEST_FUNCTION_DEVICE_SET_AUTHORIZATION_CHANGED_CB},
+	{"bt_device_unset_authorization_changed_cb"			, BT_UNIT_TEST_FUNCTION_DEVICE_UNSET_AUTHORIZATION_CHANGED_CB},
+	{"bt_device_set_connection_state_changed_cb"			, BT_UNIT_TEST_FUNCTION_DEVICE_SET_CONNECTION_STAET_CHANGED_CB},
+	{"bt_device_unset_connection_state_changed_cb"			, BT_UNIT_TEST_FUNCTION_DEVICE_UNSET_CONNECTION_STAET_CHANGED_CB},
+	{"bt_device_foreach_connected_profiles"				, BT_UNIT_TEST_FUNCTION_DEVICE_FOREACH_CONNECTED_PROFILES},
+	{"bt_device_is_profile_connected"				, BT_UNIT_TEST_FUNCTION_DEVICE_IS_PROFILE_CONNECTED},
+	{"bt_device_set_bond_created_cb"				, BT_UNIT_TEST_FUNCTION_DEVICE_SET_BOND_CREATED_CB},
+	{"bt_device_create_bond" 					, BT_UNIT_TEST_FUNCTION_DEVICE_CREATE_BOND},
+	{"bt_device_create_bond_by_type"				, BT_UNIT_TEST_FUNCTION_DEVICE_CREATE_BOND_BY_TYPE},
+	{NULL					, 0x0000},
+};
+
+tc_table_t tc_socket[] = {
+	/* Socket functions */
+	{"BACK"								, BT_UNIT_TEST_FUNCTION_BACK},
+	{"bt_socket_create_rfcomm"					, BT_UNIT_TEST_FUNCTION_SOCKET_CREATE_RFCOMM},
+	{"bt_socket_destroy_rfcomm"					, BT_UNIT_TEST_FUNCTION_SOCKET_DESTROY_RFCOMM},
+	{"bt_socket_listen_and_accept_rfcomm"				, BT_UNIT_TEST_FUNCTION_SOCKET_LISTEN_AND_ACCEPT_RFCOMM},
+	{"bt_socket_listen"						, BT_UNIT_TEST_FUNCTION_SOCKET_LISTEN},
+	{"bt_socket_accept"						, BT_UNIT_TEST_FUNCTION_SOCKET_ACCEPT},
+	{"bt_socket_reject"						, BT_UNIT_TEST_FUNCTION_SOCKET_REJECT},
+	{"bt_socket_connect_rfcomm"					, BT_UNIT_TEST_FUNCTION_SOCKET_CONNECT_RFCOMM},
+	{"bt_socket_disconnect_rfcomm"					, BT_UNIT_TEST_FUNCTION_SOCKET_DISCONNECT_RFCOMM},
+	{"bt_socket_send_data"						, BT_UNIT_TEST_FUNCTION_SOCKET_SEND_DATA},
+	{"bt_socket_set_data_received_cb"				, BT_UNIT_TEST_FUNCTION_SOCKET_SET_DATA_RECEIVED_CB},
+	{"bt_socket_unset_data_received_cb"				, BT_UNIT_TEST_FUNCTION_SOCKET_UNSET_DATA_RECEIVED_CB},
+	{"bt_socket_set_connection_requested_cb"			, BT_UNIT_TEST_FUNCTION_SOCKET_SET_CONNECTION_REQUESTED_CB},
+	{"bt_socket_unset_connection_requested_cb"			, BT_UNIT_TEST_FUNCTION_SOCKET_UNSET_CONNECTION_REQUESTED_CB},
+	{"bt_socket_set_connection_state_changed_cb"			, BT_UNIT_TEST_FUNCTION_SOCKET_SET_CONNECTION_STATE_CHANGED_CB},
+	{"bt_socket_unset_connection_state_changed_cb"			, BT_UNIT_TEST_FUNCTION_SOCKET_UNSET_CONNECTION_STATE_CHANGED_CB},
+	{NULL					, 0x0000},
+};
+
+tc_table_t tc_opp[] = {
+	/* OPP functions */
+	{"BACK"								, BT_UNIT_TEST_FUNCTION_BACK},
+	{"bt_opp_client_initialize"					, BT_UNIT_TEST_FUNCTION_OPP_CLIENT_INITIALIZE},
+	{"bt_opp_client_deinitialize"					, BT_UNIT_TEST_FUNCTION_OPP_CLIENT_DEINITIALIZE},
+	{"bt_opp_client_add_file"					, BT_UNIT_TEST_FUNCTION_OPP_CLIENT_ADD_FILE},
+	{"bt_opp_client_clear_files"					, BT_UNIT_TEST_FUNCTION_OPP_CLIENT_CLEAR_FILES},
+	{"bt_opp_client_push_files"					, BT_UNIT_TEST_FUNCTION_OPP_CLIENT_PUSH_FILES},
+	{"bt_opp_client_cancel_push"					, BT_UNIT_TEST_FUNCTION_OPP_CLIENT_CANCEL_PUSH},
+	{NULL					, 0x0000},
+};
+
+tc_table_t tc_audio[] = {
+	/* AG functions */
+	{"BACK"								, BT_UNIT_TEST_FUNCTION_BACK},
+	{"bt_audio_initialize"						, BT_UNIT_TEST_FUNCTION_AUDIO_INITIALIZE},
+	{"bt_audio_deinitialize"					, BT_UNIT_TEST_FUNCTION_AUDIO_DEINITIALIZE},
+	{"bt_audio_connect"						, BT_UNIT_TEST_FUNCTION_AUDIO_CONNECT},
+	{"bt_audio_disconnect"						, BT_UNIT_TEST_FUNCTION_AUDIO_DISCONNECT},
+	{"bt_audio_set_connection_state_changed_cb"			, BT_UNIT_TEST_FUNCTION_AUDIO_SET_CONNECTION_STATE_CHANGED_CB},
+	{"bt_audio_unset_connection_state_changed_cb"			, BT_UNIT_TEST_FUNCTION_AUDIO_UNSET_CONNECTION_STATE_CHANGED_CB},
+	{"bt_ag_open_sco" 						, BT_UNIT_TEST_FUNCTION_AG_OPEN_SCO},
+	{"bt_ag_close_sco" 						, BT_UNIT_TEST_FUNCTION_AG_CLOSE_SCO},
+	{"bt_ag_is_sco_opened"						, BT_UNIT_TEST_FUNCTION_AG_IS_SCO_OPENED},
+	{"bt_ag_set_sco_state_changed_cb"				, BT_UNIT_TEST_FUNCTION_AG_SET_SCO_STATE_CHANGED_CB},
+	{"bt_ag_unset_sco_state_changed_cb"				, BT_UNIT_TEST_FUNCTION_AG_UNSET_SCO_STATE_CHANGED_CB},
+	{"BT_AG_CALL_EVENT_IDLE"					, BT_UNIT_TEST_FUNCTION_AG_CALL_EVENT_IDLE},
+	{"BT_AG_CALL_EVENT_ANSWERED"					, BT_UNIT_TEST_FUNCTION_AG_CALL_EVENT_ANSWERED},
+	{"BT_AG_CALL_EVENT_DIALING"					, BT_UNIT_TEST_FUNCTION_AG_CALL_EVENT_DIALING},
+	{"BT_AG_CALL_EVENT_ALERTING"					, BT_UNIT_TEST_FUNCTION_AG_CALL_EVENT_ALERTING},
+	{"BT_AG_CALL_EVENT_INCOMING"					, BT_UNIT_TEST_FUNCTION_AG_CALL_EVENT_INCOMING},
+	{"bt_call_list_create" 						, BT_UNIT_TEST_FUNCTION_CALL_LIST_CREATE},
+	{"bt_call_list_destroy" 					, BT_UNIT_TEST_FUNCTION_CALL_LIST_DESTROY},
+	{"bt_call_list_reset" 						, BT_UNIT_TEST_FUNCTION_CALL_LIST_RESET},
+	{"bt_call_list_add"	 					, BT_UNIT_TEST_FUNCTION_CALL_LIST_ADD},
+	{"bt_ag_notify_call_list"					, BT_UNIT_TEST_FUNCTION_AG_NOTIFY_CALL_LIST},
+	{"bt_ag_set_call_handling_event_cb"				, BT_UNIT_TEST_FUNCTION_AG_SET_CALL_HANDLING_EVENT_CB},
+	{"bt_ag_is_nrec_enabled"					, BT_UNIT_TEST_FUNCTION_AG_IS_NREC_ENABLED},
+	{NULL					, 0x0000},
+};
+
+tc_table_t tc_pan[] = {
+	/* Network functions */
+	{"BACK"								, BT_UNIT_TEST_FUNCTION_BACK},
+	{"bt_nap_activate"						, BT_UNIT_TEST_FUNCTION_NAP_ACTIVATE},
+	{"bt_nap_deactivate"						, BT_UNIT_TEST_FUNCTION_NAP_DEACTIVATE},
+	{"bt_nap_disconnect_all"					, BT_UNIT_TEST_FUNCTION_NAP_DISCONNECT_ALL},
+	{"bt_nap_disconnect"						, BT_UNIT_TEST_FUNCTION_NAP_DISCONNECT},
+	{"bt_panu_set_connection_state_changed_cb"			, BT_UNIT_TEST_FUNCTION_PANU_SET_CONNECTION_STATE_CHANGED_CB},
+	{"bt_panu_connect"						, BT_UNIT_TEST_FUNCTION_PANU_CONNECT},
+	{NULL					, 0x0000},
+};
+
+tc_table_t tc_gatt[] = {
+	/* Gatt functions */
+	{"BACK"								, BT_UNIT_TEST_FUNCTION_BACK},
+	{"bt_gatt_foreach_primary_services"				, BT_UNIT_TEST_FUNCTION_GATT_FOREACH_PRIMARY_SERVICES},
+	{"bt_gatt_discover_characteristics"				, BT_UNIT_TEST_FUNCTION_GATT_DISCOVER_CHARACTERISTICS},
+	{"bt_gatt_get_service_uuid"					, BT_UNIT_TEST_FUNCTION_GATT_GET_SERVICE_UUID},
+	{"bt_gatt_foreach_included_services"				, BT_UNIT_TEST_FUNCTION_GATT_FOREACH_INCLUDED_SERVICES},
+	{"bt_gatt_set_characteristic_changed_cb"			, BT_UNIT_TEST_FUNCTION_GATT_SET_CHARACTERISTIC_CHANGED_CB},
+	{"bt_gatt_unset_characteristic_changed_cb"			, BT_UNIT_TEST_FUNCTION_GATT_UNSET_CHARACTERISTIC_CHANGED_CB},
+	{"bt_gatt_get_characteristic_declaration"			, BT_UNIT_TEST_FUNCTION_GATT_GET_CHARACTERISTIC_DECLARATION},
+	{"bt_gatt_set_characteristic_value"				, BT_UNIT_TEST_FUNCTION_GATT_SET_CHARACTERISTIC_VALUE},
+	{"bt_gatt_read_characteristic_value"				, BT_UNIT_TEST_FUNCTION_GATT_READ_CHARACTERISTIC_VALUE},
+	{"bt_gatt_watch_characteristic_changes"				, BT_UNIT_TEST_FUNCTION_GATT_WATCH_CHARACTERISTIC_CHANGES},
+	{"bt_gatt_unwatch_characteristic_changes"			, BT_UNIT_TEST_FUNCTION_GATT_UNWATCH_CHARACTERISTIC_CHANGES},
+	{"bt_gatt_connect"						, BT_UNIT_TEST_FUNCTION_GATT_CONNECT},
+	{"bt_gatt_disconnect"						, BT_UNIT_TEST_FUNCTION_GATT_DISCONNECT},
+	{"bt_gatt_set_connection_state_changed_cb"			, BT_UNIT_TEST_FUNCTION_SET_GATT_CONNECTION_STATE_CHANGED_CB},
+	{"bt_gatt_unset_connection_state_changed_cb"			, BT_UNIT_TEST_FUNCTION_UNSET_GATT_CONNECTION_STATE_CHANGED_CB},
+	{NULL					, 0x0000},
+};
+
+tc_table_t tc_avrcp[] = {
+	/* AVRCP functions */
+	{"BACK"								, BT_UNIT_TEST_FUNCTION_BACK},
+	{"bt_avrcp_target_initialize"					, BT_UNIT_TEST_FUNCTION_AVRCP_TARGET_INITIALIZE},
+	{"bt_avrcp_target_deinitialize"					, BT_UNIT_TEST_FUNCTION_AVRCP_TARGET_DEINITIALIZE},
+	{"bt_avrcp_set_equalizer_state_changed_cb"			, BT_UNIT_TEST_FUNCTION_AVRCP_SET_EQUALIZER_STATE_CHANGED_CB},
+	{"bt_avrcp_set_repeat_mode_changed_cb"				, BT_UNIT_TEST_FUNCTION_AVRCP_SET_REPEAT_MODE_CHANGED_CB},
+	{"bt_avrcp_set_shuffle_mode_changed_cb"				, BT_UNIT_TEST_FUNCTION_AVRCP_SET_SHUFFLE_MODE_CHANGED_CB},
+	{"bt_avrcp_set_scan_mode_changed_cb"				, BT_UNIT_TEST_FUNCTION_AVRCP_SET_SCAN_MODE_CHANGED_CB},
+	{"bt_avrcp_unset_equalizer_state_changed_cb"			, BT_UNIT_TEST_FUNCTION_AVRCP_UNSET_EQUALIZER_STATE_CHANGED_CB},
+	{"bt_avrcp_unset_repeat_mode_changed_cb"			, BT_UNIT_TEST_FUNCTION_AVRCP_UNSET_REPEAT_MODE_CHANGED_CB},
+	{"bt_avrcp_unset_shuffle_mode_changed_cb"			, BT_UNIT_TEST_FUNCTION_AVRCP_UNSET_SHUFFLE_MODE_CHANGED_CB},
+	{"bt_avrcp_unset_scan_mode_changed_cb"				, BT_UNIT_TEST_FUNCTION_AVRCP_UNSET_SCAN_MODE_CHANGED_CB},
+	{NULL					, 0x0000},
+};
+
+tc_table_t tc_hid[] = {
+	/* HID functions */
+	{"BACK"								, BT_UNIT_TEST_FUNCTION_BACK},
+	{"bt_hid_host_initialize"					, BT_UNIT_TEST_FUNCTION_HID_HOST_INITIALIZE},
+	{"bt_hid_host_deinitialize"					, BT_UNIT_TEST_FUNCTION_HID_HOST_DEINITIALIZE},
+	{"bt_hid_host_connect"						, BT_UNIT_TEST_FUNCTION_HID_HOST_CONNECT},
+	{"bt_hid_host_disconnect"					, BT_UNIT_TEST_FUNCTION_HID_HOST_DISCONNECT},
+	{NULL					, 0x0000},
+};
+
+tc_table_t tc_automated_test[] = {
+	/* Automated test Functions*/
+	{"BACK"								, BT_UNIT_TEST_FUNCTION_BACK},
+	{"On/Off repeat test()"				, BT_UNIT_TEST_FUNCTION_ON_OFF_REPEAT_TEST},
+	{"On/Off repeat(1sec delay) test()" , BT_UNIT_TEST_FUNCTION_ON_OFF_REPEAT_TEST_1_SEC_DELAY},
+	{"On/Off repeat(Nsec delay) test()" , BT_UNIT_TEST_FUNCTION_ON_OFF_REPEAT_TEST_N_SEC_DELAY},
+	{NULL					, 0x0000},
+};
+
+void tc_usage_print(void)
+{
+	int i = 0;
+	tc_table_t* tc_table = NULL;
+
+	switch (current_tc_table) {
+	case BT_UNIT_TEST_TABLE_SET_ADDRESS:
+		TC_PRT("Key 0 : usage BACK");
+		TC_PRT("Input the address of remote device.(e.g., F6:FB:8F:D8:C8:7C)\n\n");
+		return;
+	case BT_UNIT_TEST_TABLE_ADAPTER:
+		tc_table = tc_adapter;
+		break;
+	case BT_UNIT_TEST_TABLE_ADAPTER_LE:
+		tc_table = tc_adapter_le;
+		break;
+	case BT_UNIT_TEST_TABLE_DEVICE:
+		tc_table = tc_device;
+		break;
+	case BT_UNIT_TEST_TABLE_SOCKET:
+		tc_table = tc_socket;
+		break;
+	case BT_UNIT_TEST_TABLE_OPP:
+		tc_table = tc_opp;
+		break;
+	case BT_UNIT_TEST_TABLE_AUDIO:
+		tc_table = tc_audio;
+		break;
+	case BT_UNIT_TEST_TABLE_PAN:
+		tc_table = tc_pan;
+		break;
+	case BT_UNIT_TEST_TABLE_GATT:
+		tc_table = tc_gatt;
+		break;
+	case BT_UNIT_TEST_TABLE_AVRCP:
+		tc_table = tc_avrcp;
+		break;
+	case BT_UNIT_TEST_TABLE_HID:
+		tc_table = tc_hid;
+		break;
+	case BT_UNIT_TEST_TABLE_AUTOMATED_TEST:
+		if (input_automated_test_delay == true) {
+			TC_PRT("Input the delay for automated test.(e.g., 10)\n\n");
+			return;
+		}
+		tc_table = tc_automated_test;
+		break;
+	case BT_UNIT_TEST_TABLE_MAIN:
+	default:
+		tc_table = tc_main;
+		break;
+	}
+
+	while (tc_table[i].tc_name) {
+		TC_PRT("Key %d : usage %s", tc_table[i].tc_code,
+						tc_table[i].tc_name);
+		i++;
+	}
+	printf("\n\n");
+}
+
+static const char* __bt_get_error_message(bt_error_e err)
+{
+	const char* err_str = NULL;
+
+	switch (err) {
+	case BT_ERROR_NONE:
+		err_str = "BT_ERROR_NONE";
+		break;
+	case BT_ERROR_CANCELLED:
+		err_str = "BT_ERROR_CANCELLED";
+		break;
+	case BT_ERROR_INVALID_PARAMETER:
+		err_str = "BT_ERROR_INVALID_PARAMETER";
+		break;
+	case BT_ERROR_OUT_OF_MEMORY:
+		err_str = "BT_ERROR_OUT_OF_MEMORY";
+		break;
+	case BT_ERROR_RESOURCE_BUSY:
+		err_str = "BT_ERROR_RESOURCE_BUSY";
+		break;
+	case BT_ERROR_TIMED_OUT:
+		err_str = "BT_ERROR_TIMED_OUT";
+		break;
+	case BT_ERROR_NOW_IN_PROGRESS:
+		err_str = "BT_ERROR_NOW_IN_PROGRESS";
+		break;
+	case BT_ERROR_NOT_INITIALIZED:
+		err_str = "BT_ERROR_NOT_INITIALIZED";
+		break;
+	case BT_ERROR_NOT_ENABLED:
+		err_str = "BT_ERROR_NOT_ENABLED";
+		break;
+	case BT_ERROR_ALREADY_DONE:
+		err_str = "BT_ERROR_ALREADY_DONE";
+		break;
+	case BT_ERROR_OPERATION_FAILED:
+		err_str = "BT_ERROR_OPERATION_FAILED";
+		break;
+	case BT_ERROR_NOT_IN_PROGRESS:
+		err_str = "BT_ERROR_NOT_IN_PROGRESS";
+		break;
+	case BT_ERROR_REMOTE_DEVICE_NOT_BONDED:
+		err_str = "BT_ERROR_REMOTE_DEVICE_NOT_BONDED";
+		break;
+	case BT_ERROR_AUTH_REJECTED:
+		err_str = "BT_ERROR_AUTH_REJECTED";
+		break;
+	case BT_ERROR_AUTH_FAILED:
+		err_str = "BT_ERROR_AUTH_FAILED";
+		break;
+	case BT_ERROR_REMOTE_DEVICE_NOT_FOUND:
+		err_str = "BT_ERROR_REMOTE_DEVICE_NOT_FOUND";
+		break;
+	case BT_ERROR_SERVICE_SEARCH_FAILED:
+		err_str = "BT_ERROR_SERVICE_SEARCH_FAILED";
+		break;
+	case BT_ERROR_REMOTE_DEVICE_NOT_CONNECTED:
+		err_str = "BT_ERROR_REMOTE_DEVICE_NOT_CONNECTED";
+		break;
+	case BT_ERROR_PERMISSION_DENIED:
+		err_str = "BT_ERROR_PERMISSION_DENIED";
+		break;
+	case BT_ERROR_SERVICE_NOT_FOUND:
+		err_str = "BT_ERROR_SERVICE_NOT_FOUND";
+		break;
+	case BT_ERROR_NOT_SUPPORTED:
+		err_str = "BT_ERROR_NOT_SUPPORTED";
+		break;
+	default:
+		err_str = "NOT Defined";
+		break;
+	}
+
+	return err_str;
+}
+
+static gboolean __select_index_cb(GIOChannel *chan,
+				GIOCondition cond,
+				gpointer data)
+{
+	char buf[BUFFER_LEN] = { 0 };
+	unsigned int len = 0;
+	int *index = data;
+
+	memset(buf, 0, sizeof(buf));
+
+	if (g_io_channel_read_chars(chan, buf, sizeof(buf),
+				&len, NULL) == G_IO_STATUS_ERROR) {
+		TC_PRT("IO Channel read error");
+		is_sub_index = FALSE;
+		return FALSE;
+	}
+
+	*index = atoi(buf);
+	is_sub_index = FALSE;
+
+	return FALSE;
+}
+
+static void __select_index(void *data)
+{
+	GIOChannel *key_io;
+
+	is_sub_index = TRUE;
+
+	TC_PRT("Select Index : ");
+
+	key_io = g_io_channel_unix_new(fileno(stdin));
+
+	g_io_channel_set_encoding(key_io, NULL, NULL);
+	g_io_channel_set_flags(key_io, G_IO_FLAG_NONBLOCK, NULL);
+
+	g_io_add_watch(key_io, G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
+			__select_index_cb, data);
+
+	g_io_channel_unref(key_io);
+}
+
+static void __bt_free_gatt_services(void)
+{
+	int i;
+
+	for (i = 0; i < service_index; i++) {
+		bt_gatt_destroy_attribute_handle(service_clone[i]);
+		service_clone[i] = NULL;
+	}
+
+	service_index = 0;
+}
+
+static void __bt_free_gatt_characteristics(void)
+{
+	int i;
+
+	for (i = 0; i < MAX_SERVICES; i++) {
+		if (characteristics[i] == NULL)
+			return;
+
+		bt_gatt_destroy_attribute_handle(characteristics[i]);
+		characteristics[i] = NULL;
+	}
+}
+
+static void __bt_free_gatt_characteristics_services(void)
+{
+	int i;
+
+	for (i = 0; i < char_service_index; i++) {
+		bt_gatt_destroy_attribute_handle(characteristics_services[i]);
+		characteristics_services[i] = NULL;
+	}
+	char_service_index = 0;
+}
+
+static void __bt_adapter_device_visibility_mode_changed_cb(int result,
+				bt_adapter_visibility_mode_e visibility_mode,
+				void *user_data)
+{
+	TC_PRT("result: %s", __bt_get_error_message(result));
+	TC_PRT("visibility_mode: %d", visibility_mode);
+}
+
+static void __bt_adapter_device_visibility_duration_changed_cb(int duration,
+				void *user_data)
+{
+	TC_PRT("visibility_duration: %d", duration);
+}
+
+static void __bt_adapter_connectable_changed_cb(int result,
+				bool connectable, void *user_data)
+{
+	if (result != BT_ERROR_NONE) {
+		TC_PRT("connectable change is failed : [0x%04x]", result);
+		return;
+	}
+
+	TC_PRT("%s", connectable ? "Connectable" : "Non-connectable");
+}
+
+static bool __bt_adapter_bonded_device_cb(bt_device_info_s *device_info, void *user_data)
+{
+	int i;
+
+	TC_PRT("remote_address: %s", device_info->remote_address);
+	TC_PRT("remote_name: %s", device_info->remote_name);
+	TC_PRT("service_count: %d", device_info->service_count);
+
+	if (device_info->service_uuid == NULL) {
+		TC_PRT("No uuids");
+	} else {
+		for (i = 0; i < device_info->service_count; i++) {
+			TC_PRT("uuid: %s", device_info->service_uuid[i]);
+		}
+	}
+
+	if (device_info->manufacturer_data_len > 0) {
+		TC_PRT("manufacturer specific data(len:%d)", device_info->manufacturer_data_len);
+		printf("data [");
+		for (i = 0; i < device_info->manufacturer_data_len; i++)
+			printf("%02x ", device_info->manufacturer_data[i]);
+		printf("]\n");
+	}
+
+	return true;
+}
+
+static void __bt_adapter_device_discovery_state_changed_cb(int result,
+				bt_adapter_device_discovery_state_e discovery_state,
+				bt_adapter_device_discovery_info_s *discovery_info,
+				void *user_data)
+{
+	int i;
+
+	TC_PRT("discovery_state: %d", discovery_state);
+
+	if (discovery_info == NULL) {
+		TC_PRT("No discovery_info!");
+		return;
+	}
+
+	TC_PRT("remote_address: %s", discovery_info->remote_address);
+	TC_PRT("remote_name: %s", discovery_info->remote_name);
+	TC_PRT("rssi: %d", discovery_info->rssi);
+	TC_PRT("is_bonded: %d", discovery_info->is_bonded);
+	TC_PRT("service_count: %d", discovery_info->service_count);
+
+	if (discovery_info->service_uuid == NULL) {
+		TC_PRT("No uuids");
+	} else {
+		for (i = 0; i < discovery_info->service_count; i++) {
+			TC_PRT("uuid: %s", discovery_info->service_uuid[i]);
+		}
+	}
+
+	if (discovery_info->manufacturer_data_len > 0) {
+		TC_PRT("manufacturer specific data(len:%d)", discovery_info->manufacturer_data_len);
+		printf("data [");
+		for (i = 0; i < discovery_info->manufacturer_data_len; i++)
+			printf("%02x ", discovery_info->manufacturer_data[i]);
+		printf("]\n");
+	}
+}
+
+static void __bt_adapter_le_device_discovery_state_changed_cb(int result,
+				bt_adapter_le_device_discovery_state_e discovery_state,
+				bt_adapter_le_device_discovery_info_s *discovery_info,
+				void *user_data)
+{
+//	int i;
+
+	if (discovery_info == NULL && discovery_state == BT_ADAPTER_LE_DEVICE_DISCOVERY_FOUND) {
+		TC_PRT("No discovery_info!");
+		return;
+	}
+
+	if (discovery_state != BT_ADAPTER_LE_DEVICE_DISCOVERY_FOUND) {
+		TC_PRT("LE discovery %s", discovery_state == BT_ADAPTER_LE_DEVICE_DISCOVERY_STARTED?
+				"Started" : "Finished");
+	} else {
+		TC_PRT("%s Adv %d Scan resp %d RSSI %d Addr_type %d", discovery_info->remote_address,
+				discovery_info->adv_data_len, discovery_info->scan_data_len, discovery_info->rssi,
+				discovery_info->address_type);
+
+		if (discovery_info->adv_data_len > 31 || discovery_info->scan_data_len > 31) {
+			TC_PRT("###################");
+			bt_adapter_le_stop_device_discovery();
+			TC_PRT("###################");
+			return;
+		}
+#if 0
+		/* LE ADV information */
+		TC_PRT("appearance: %d", discovery_info->appearance);
+		if (discovery_info->adv_data_len > 0)
+			for (i = 0; i < discovery_info->adv_data_len; i++)
+				TC_PRT("data[%d] : %x", i, discovery_info->adv_data[i]);
+		if (discovery_info->scan_data_len > 0)
+			for (i = 0; i < discovery_info->scan_data_len; i++)
+				TC_PRT("data[%d] : %x", i, discovery_info->scan_data[i]);
+
+		if (discovery_info->service_uuid == NULL) {
+			TC_PRT("No uuids");
+			return;
+		}
+
+		for (i = 0; i < discovery_info->service_count; i++) {
+			TC_PRT("uuid: %s", discovery_info->service_uuid[i]);
+		}
+#endif
+	}
+}
+
+static void __bt_socket_data_received_cb(bt_socket_received_data_s *data, void *user_data)
+{
+	TC_PRT("+");
+
+	if (data == NULL) {
+		TC_PRT("No recieved data!");
+		return;
+	}
+
+	TC_PRT("Socket fd: %d", data->socket_fd);
+	TC_PRT("Data: %s", data->data);
+	TC_PRT("Size: %d", data->data_size);
+}
+
+static void __bt_socket_connection_requested_cb(int socket_fd, const char *remote_address, void *user_data)
+{
+	TC_PRT("Socket fd: %d", socket_fd);
+	TC_PRT("remote_address: %s", remote_address);
+}
+
+static void __bt_socket_connection_state_changed_cb(int result,
+				bt_socket_connection_state_e connection_state,
+				bt_socket_connection_s *connection,
+				void *user_data)
+{
+	TC_PRT("result: %s", __bt_get_error_message(result));
+	TC_PRT("connection_state: %d", connection_state);
+
+	if (connection == NULL) {
+		TC_PRT("No connection data!");
+		return;
+	}
+
+	TC_PRT("socket fd: %d", connection->socket_fd);
+	TC_PRT("server socket fd: %d", connection->server_fd);
+	TC_PRT("role: %d", connection->local_role);
+	TC_PRT("remote address: %s", connection->remote_address);
+	TC_PRT("service_uuid: %s", connection->service_uuid);
+	client_fd = connection->socket_fd;
+}
+
+void __bt_opp_client_push_responded_cb(int result,
+					const char *remote_address,
+					void *user_data)
+{
+	TC_PRT("result: %s", __bt_get_error_message(result));
+	TC_PRT("remote_address: %s", remote_address);
+}
+
+void __bt_opp_client_push_progress_cb(const char *file,
+					long long size,
+					int percent,
+					void *user_data)
+{
+	TC_PRT("size: %ld", (long)size);
+	TC_PRT("percent: %d", percent);
+	TC_PRT("file: %s", file);
+}
+
+void __bt_opp_client_push_finished_cb(int result,
+				const char *remote_address,
+				void *user_data)
+{
+	TC_PRT("result: %s", __bt_get_error_message(result));
+	TC_PRT("remote_address: %s", remote_address);
+}
+
+void __bt_audio_connection_state_changed_cb(int result,
+					bool connected, const char *remote_address,
+					bt_audio_profile_type_e type, void *user_data)
+{
+	TC_PRT("result [%s]", __bt_get_error_message(result));
+	TC_PRT("connected [%d]", connected);
+	TC_PRT("address [%s]", remote_address);
+	TC_PRT("type [%d]", type);
+}
+
+void __bt_ag_sco_state_changed_cb(int result, bool opened, void *user_data)
+{
+	TC_PRT("result [%s]", __bt_get_error_message(result));
+	TC_PRT("opened [%s]", opened ? "YES" : "NO");
+}
+
+void __bt_ag_set_call_handling_event_cb(bt_ag_call_handling_event_e event,
+					unsigned int call_id, void *user_data)
+{
+	TC_PRT("event[%d] call_id[%d]", event, call_id);
+}
+
+void __bt_ag_set_vendor_cmd_event_cb(char *cmd, void *user_data)
+{
+	TC_PRT("Vendor command[%s]", cmd);
+}
+
+void __bt_device_authorization_changed_cb(bt_device_authorization_e authorization,
+						char *remote_address, void *user_data)
+{
+	TC_PRT("__bt_device_authorization_changed_cb [%d]", authorization);
+	TC_PRT("address: %s", remote_address);
+}
+
+void __bt_device_connection_state_changed_cb(bool connected,
+						bt_device_connection_info_s *conn_info,
+						void *user_data)
+{
+	TC_PRT("__bt_device_connection_state_changed_cb [%d]", connected);
+	TC_PRT("address [%s]", conn_info->remote_address);
+	TC_PRT("link type [%d]", conn_info->link);
+	TC_PRT("disconnection reason [%d]", conn_info->disconn_reason);
+}
+
+bool __bt_device_connected_profile(bt_profile_e profile, void *user_data)
+{
+	TC_PRT("__bt_device_connected_profile [%d]", profile);
+	return true;
+}
+
+void __bt_device_bond_created_cb(int result, bt_device_info_s *device_info, void *user_data)
+{
+	if(result == BT_ERROR_NONE)
+	{
+		TC_PRT("Callback: A bond with chat_server is created.");
+		TC_PRT("Callback: The number of service - %d.", device_info->service_count);
+
+		int i = 0;
+		for(i=0; i<device_info->service_count; i++) {
+			TC_PRT("Callback: service[%d] - %s", i+1, device_info->service_uuid[i]);
+		}
+		TC_PRT("Callback: is_bonded - %d.", device_info->is_bonded);
+		TC_PRT("Callback: is_connected - %d.", device_info->is_connected);
+
+		if (device_info->manufacturer_data_len > 0) {
+			TC_PRT("manufacturer specific data(len:%d)", device_info->manufacturer_data_len);
+			printf("data [");
+			for (i = 0; i < device_info->manufacturer_data_len; i++)
+				printf("%02x ", device_info->manufacturer_data[i]);
+			printf("]\n");
+		}
+	} else {
+		TC_PRT("result: %s", __bt_get_error_message(result));
+		TC_PRT("Callback: Creating a bond is failed.");
+	}
+}
+
+void __bt_gatt_connection_state_changed_cb(int result, bool connected, const char *remote_address, void *user_data)
+{
+	TC_PRT("result: %s", __bt_get_error_message(result));
+	if (connected) {
+		TC_PRT("LE connected");
+	} else {
+		TC_PRT("LE DISconnected");
+	}
+}
+
+bool __bt_gatt_primary_service_cb(bt_gatt_attribute_h service, void *user_data)
+{
+	TC_PRT("__bt_gatt_primary_service_cb");
+	TC_PRT("service %s", (char *)service);
+	if (service_index >= MAX_SERVICES)
+		return true;
+
+	bt_gatt_clone_attribute_handle(&service_clone[service_index], service);
+	service_index++;
+	return true;
+}
+
+bool __bt_gatt_characteristics_discovered_cb(int result, int index, int total, bt_gatt_attribute_h characteristic, void *user_data)
+{
+	TC_PRT("result: %s", __bt_get_error_message(result));
+	TC_PRT("index %d", index);
+	TC_PRT("total %d", total);
+	TC_PRT("characteristic %s", (char *)characteristic);
+
+	if (index >= MAX_SERVICES)
+		return true;
+
+	bt_gatt_clone_attribute_handle(&characteristics[index], characteristic);
+	return true;
+}
+
+bool __bt_gatt_included_service_cb(bt_gatt_attribute_h service, void *user_data)
+{
+	char *uuid = NULL;
+	unsigned char *value = NULL;
+	int value_length = 0;
+
+	TC_PRT("__bt_gatt_included_service_cb");
+	TC_PRT("service %s", (char *)service);
+
+	if (char_service_index >= MAX_SERVICES)
+		return true;
+
+	bt_gatt_clone_attribute_handle(&characteristics_services[char_service_index], service);
+	char_service_index++;
+
+	bt_gatt_get_characteristic_declaration(service, &uuid, &value, &value_length);
+	TC_PRT("uuid %s", uuid);
+	return true;
+}
+
+void __bt_gatt_characteristic_changed_cb(bt_gatt_attribute_h characteristic, unsigned char *value, int value_length, void *user_data)
+{
+	int i;
+
+	TC_PRT("__bt_gatt_characteristic_changed_cb");
+	TC_PRT("service %s", (char *)characteristic);
+	TC_PRT("value_length %d", value_length);
+
+	for (i = 0; i < value_length; i++) {
+		TC_PRT("value %c", value[i]);
+	}
+
+	return;
+}
+
+void __bt_gatt_char_write_cb(void *user_data)
+{
+	TC_PRT("__bt_gatt_char_write_cb");
+	return;
+}
+
+void __bt_gatt_char_read_cb(unsigned char *value, int value_length, void *user_data)
+{
+	int i;
+
+	TC_PRT("__bt_gatt_char_read_cb");
+
+        TC_PRT("value_length %d", value_length);
+
+        for (i = 0; i < value_length; i++) {
+                TC_PRT("value %u", value[i]);
+        }
+
+	return;
+}
+
+void __bt_avrcp_target_connection_state_changed_cb(bool connected, const char *remote_address, void *user_data)
+{
+	TC_PRT("__bt_avrcp_target_connection_state_changed_cb");
+	TC_PRT("connected %d", connected);
+	TC_PRT("remote_address %s", remote_address);
+}
+
+void __bt_avrcp_equalizer_state_changed_cb(bt_avrcp_equalizer_state_e equalizer, void *user_data)
+{
+	TC_PRT("__bt_avrcp_equalizer_state_changed_cb");
+	TC_PRT("equalizer %d", equalizer);
+}
+
+void __bt_avrcp_repeat_mode_changed_cb(bt_avrcp_repeat_mode_e repeat, void *user_data)
+{
+	TC_PRT("__bt_avrcp_repeat_mode_changed_cb");
+	TC_PRT("repeat %d", repeat);
+}
+
+void __bt_avrcp_shuffle_mode_changed_cb(bt_avrcp_shuffle_mode_e shuffle, void *user_data)
+{
+	TC_PRT("__bt_avrcp_shuffle_mode_changed_cb");
+	TC_PRT("shuffle %d", shuffle);
+}
+
+void __bt_avrcp_scan_mode_changed_cb(bt_avrcp_scan_mode_e scan, void *user_data)
+{
+	TC_PRT("__bt_avrcp_scan_mode_changed_cb");
+	TC_PRT("equalizer %d", scan);
+}
+
+void panu_conn_state_changed(int result, bool connected,
+					const char *remote_address,
+					bt_panu_service_type_e type,
+					void *user_data)
+{
+	TC_PRT("result [%s]", __bt_get_error_message(result));
+	TC_PRT("connected [%d]", connected);
+	TC_PRT("address [%s]", remote_address);
+	TC_PRT("type [%d]", type);
+
+}
+
+void __bt_hid_host_connection_state_changed_cb(int result,
+		bool connected, const char *remote_address, void *user_data)
+{
+	TC_PRT("__bt_hid_host_connection_state_changed_cb: called");
+	TC_PRT("result: %s", __bt_get_error_message(result));
+}
+
+char * get_bd_from_file(char *filename)
+{
+	int fd;
+	char *buf;
+
+	if ((fd = open(filename, O_RDONLY)) < 0) {
+		perror("Can't open file");
+		return NULL;
+	}
+
+	buf = g_malloc0(20);
+
+	if (read(fd, buf, 17) < 17) {
+		perror("read failed");
+		g_free(buf);
+		close(fd);
+		return NULL;
+	}
+
+	close(fd);
+
+	return buf;
+}
+
+void __bt_repeat_test_adapter_state_changed_cb(int result, bt_adapter_state_e adapter_state, void *user_data)
+{
+	unsigned int delay = *(unsigned int*)user_data;
+
+	TC_PRT("__bt_repeat_test_adapter_state_changed_cb");
+	TC_PRT("result: %s", __bt_get_error_message(result));
+	TC_PRT("state: %s, delay(%dsec)\n", (adapter_state == BT_ADAPTER_ENABLED)? "ENABLED" : "DISABLED", delay);
+
+	if (result != BT_ERROR_NONE) {
+		char *argv[] = {NULL};
+
+		execv("all_log_dump.sh", argv);
+		return;
+	} else {
+		if (delay)
+			sleep(delay);
+
+		if (adapter_state == BT_ADAPTER_DISABLED) {
+			bt_adapter_enable();
+		} else {
+			bt_adapter_disable();
+		}
+	}
+}
+
+int test_input_callback(void *data)
+{
+	int ret = 0;
+	int test_id = (int)data;
+
+	switch (current_tc_table) {
+	case BT_UNIT_TEST_TABLE_MAIN: {
+		switch (test_id) {
+		case 0x00ff:
+			TC_PRT("Finished");
+			g_main_loop_quit(main_loop);
+			break;
+
+		case BT_UNIT_TEST_FUNCTION_INITIALIZE:
+			ret = bt_initialize();
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		case BT_UNIT_TEST_FUNCTION_DEINITIALIZE:
+			ret = bt_deinitialize();
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		default:
+			break;
+		}
+
+		break;
+	}
+	case BT_UNIT_TEST_TABLE_ADAPTER: {
+		switch (test_id) {
+		case BT_UNIT_TEST_FUNCTION_ADAPTER_GET_STATE: {
+			bt_adapter_state_e state = BT_ADAPTER_DISABLED;
+
+			ret = bt_adapter_get_state(&state);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			TC_PRT("state: %d", state);
+			break;
+		}
+		case BT_UNIT_TEST_FUNCTION_ADAPTER_ENABLE:
+			ret = bt_adapter_enable();
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		case BT_UNIT_TEST_FUNCTION_ADAPTER_DISABLE:
+			ret = bt_adapter_disable();
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		case BT_UNIT_TEST_FUNCTION_ADAPTER_RECOVER:
+			ret = bt_adapter_recover();
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		case BT_UNIT_TEST_FUNCTION_ADAPTER_START_DEVICE_DISCOVERY:
+			ret = bt_adapter_start_device_discovery();
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		case BT_UNIT_TEST_FUNCTION_ADAPTER_STOP_DEVICE_DISCOVERY:
+			ret = bt_adapter_stop_device_discovery();
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		case BT_UNIT_TEST_FUNCTION_ADAPTER_IS_DISCOVERING: {
+			bool is_discovering = FALSE;
+			ret = bt_adapter_is_discovering(&is_discovering);
+			if (ret < BT_ERROR_NONE)
+				TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			else
+				TC_PRT("is_discovering: %d", is_discovering);
+
+			break;
+		}
+		case BT_UNIT_TEST_FUNCTION_ADAPTER_FOREACH_BONDED_DEVICE: {
+			ret = bt_adapter_foreach_bonded_device(__bt_adapter_bonded_device_cb, NULL);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		}
+		case BT_UNIT_TEST_FUNCTION_ADAPTER_GET_BONDED_DEVICE_INFO: {
+			bt_device_info_s *device_info = NULL;
+
+			ret = bt_adapter_get_bonded_device_info(remote_addr,
+								&device_info);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+
+			if (device_info) {
+				TC_PRT("address: %s", device_info->remote_address);
+				TC_PRT("name: %s", device_info->remote_name);
+			}
+
+			bt_adapter_free_device_info(device_info);
+			break;
+		}
+		case BT_UNIT_TEST_FUNCTION_ADAPTER_IS_SERVICE_USED: {
+			bool used = FALSE;
+
+			ret = bt_adapter_is_service_used(opp_uuid, &used);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			TC_PRT("used: %d", used);
+			break;
+		}
+		case BT_UNIT_TEST_FUNCTION_ADAPTER_GET_VISIBILITY: {
+			bt_adapter_visibility_mode_e visibility_mode = BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE;
+			int time = 0;
+
+			ret = bt_adapter_get_visibility(&visibility_mode, &time);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			TC_PRT("mode: %d", visibility_mode);
+			TC_PRT("time: %d", time);
+			break;
+		}
+		case BT_UNIT_TEST_FUNCTION_ADAPTER_SET_DEVICE_DISCOVERY_STATE_CHANGED_CB:
+			ret = bt_adapter_set_device_discovery_state_changed_cb(__bt_adapter_device_discovery_state_changed_cb, NULL);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		case BT_UNIT_TEST_FUNCTION_ADAPTER_UNSET_DEVICE_DISCOVERY_STATE_CHANGED_CB:
+			ret = bt_adapter_unset_device_discovery_state_changed_cb();
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+
+		case BT_UNIT_TEST_FUNCTION_ADAPTER_GET_LOCAL_OOB_DATA: {
+			ret = bt_adapter_get_local_oob_data(&hash, &randomizer, &hash_len, &rand_len);
+			if (ret < BT_ERROR_NONE) {
+				TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			} else {
+				TC_PRT("hash = [%s]", hash);
+				TC_PRT("randomizer = [%s]", randomizer);
+			}
+			break;
+		}
+
+		case BT_UNIT_TEST_FUNCTION_ADAPTER_SET_LOCAL_OOB_DATA: {
+			ret = bt_adapter_set_remote_oob_data(remote_addr, hash, randomizer, hash_len, rand_len);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		}
+
+		case BT_UNIT_TEST_FUNCTION_ADAPTER_REMOVE_REMOTE_OOB_DATA: {
+			ret = bt_adapter_remove_remote_oob_data(remote_addr);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		}
+
+		case BT_UNIT_TEST_FUNCTION_ADAPTER_SET_VISIBILITY_MODE_CHANGED_CB:
+			ret = bt_adapter_set_visibility_mode_changed_cb(__bt_adapter_device_visibility_mode_changed_cb, NULL);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		case BT_UNIT_TEST_FUNCTION_ADAPTER_UNSET_VISIBILITY_MODE_CHANGED_CB:
+			ret = bt_adapter_unset_visibility_mode_changed_cb();
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+
+		case BT_UNIT_TEST_FUNCTION_ADAPTER_SET_VISIBILITY_DURATION_CHANGED_CB:
+			ret = bt_adapter_set_visibility_duration_changed_cb(
+					__bt_adapter_device_visibility_duration_changed_cb, NULL);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		case BT_UNIT_TEST_FUNCTION_ADAPTER_UNSET_VISIBILITY_DURATION_CHANGED_CB:
+			ret = bt_adapter_unset_visibility_duration_changed_cb();
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+
+		case BT_UNIT_TEST_FUNCTION_ADAPTER_SET_CONNECTABLE_CHANGED_CB: {
+			ret = bt_adapter_set_connectable_changed_cb(__bt_adapter_connectable_changed_cb, NULL);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		}
+
+		case BT_UNIT_TEST_FUNCTION_ADAPTER_UNSET_CONNECTABLE_CHANGED_CB: {
+			ret = bt_adapter_unset_connectable_changed_cb();
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		}
+
+		case BT_UNIT_TEST_FUNCTION_ADAPTER_GET_CONNECTABLE: {
+			bool connectable = false;
+
+			ret = bt_adapter_get_connectable(&connectable);
+			if (ret < BT_ERROR_NONE) {
+				TC_PRT("returns %s\n", __bt_get_error_message(ret));
+				break;
+			}
+
+			TC_PRT("%s", connectable ? "Connectable" : "Non-connectable");
+			break;
+		}
+
+		case BT_UNIT_TEST_FUNCTION_ADAPTER_SET_CONNECTABLE: {
+			bool connectable = false;
+
+			bt_adapter_get_connectable(&connectable);
+
+			ret = bt_adapter_set_connectable(!connectable);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		}
+
+		case BT_UNIT_TEST_FUNCTION_ADAPTER_GET_VERSION: {
+			char *version = NULL;
+
+			ret = bt_adapter_get_version(&version);
+			if (ret < BT_ERROR_NONE)
+				TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			else {
+				TC_PRT("Version: [%s]",version);
+				g_free(version);
+			}
+			break;
+		}
+
+		case BT_UNIT_TEST_FUNCTION_ADAPTER_GET_LOCAL_INFO: {
+			char *chipset = NULL;
+			char *firmware = NULL;
+			char *stack_version = NULL;
+			char *profiles = NULL;
+
+			ret = bt_adapter_get_local_info(&chipset, &firmware, &stack_version, &profiles);
+			if (ret < BT_ERROR_NONE)
+				TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			else {
+				TC_PRT("Local info: [%s, %s, %s]", chipset, firmware, stack_version);
+				TC_PRT("Local info(Profiles):\n%s", profiles);
+				g_free(chipset);
+				g_free(firmware);
+				g_free(stack_version);
+				g_free(profiles);
+			}
+			break;
+		}
+
+		default:
+			break;
+		}
+
+		break;
+	}
+
+	case BT_UNIT_TEST_TABLE_ADAPTER_LE: {
+		switch (test_id) {
+		case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_GET_STATE: {
+			bt_adapter_le_state_e le_state = BT_ADAPTER_LE_DISABLED;
+			
+			ret = bt_adapter_le_get_state(&le_state);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			TC_PRT("le_state: %d", le_state);
+			break;
+		}
+
+		case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_ENABLE: {
+			ret = bt_adapter_le_enable();
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		}
+
+		case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_DISABLE: {
+			ret = bt_adapter_le_disable();
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		}
+
+		case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_START_DEVICE_DISCOVERY:
+			ret = bt_adapter_le_start_device_discovery();
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+
+		case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_STOP_DEVICE_DISCOVERY:
+			ret = bt_adapter_le_stop_device_discovery();
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+
+		case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_ADD_WHITE_LIST: {
+			ret = bt_adapter_le_add_white_list(remote_addr, BT_DEVICE_PUBLIC_ADDRESS);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		}
+		
+		case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_REMOVE_WHITE_LIST: {
+			ret = bt_adapter_le_remove_white_list(remote_addr, BT_DEVICE_PUBLIC_ADDRESS);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		}
+		
+		case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_CLEAR_WHITE_LIST: {
+			ret = bt_adapter_le_clear_white_list();
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		}
+
+		case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_ENABLE_PRIVACY: {
+			static bool enable_privacy = false;
+
+			if (enable_privacy == false)
+				enable_privacy = true;
+			else
+				enable_privacy = false;
+
+			ret = bt_adapter_le_enable_privacy(enable_privacy);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		}
+
+		case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_SET_DEVICE_DISCOVERY_STATE_CHANGED_CB:
+			ret = bt_adapter_le_set_device_discovery_state_changed_cb(__bt_adapter_le_device_discovery_state_changed_cb, NULL);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+
+		case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_UNSET_DEVICE_DISCOVERY_STATE_CHANGED_CB:
+			ret = bt_adapter_le_unset_device_discovery_state_changed_cb();
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+
+		default:
+			break;
+		}
+
+		break;
+	}
+
+	case BT_UNIT_TEST_TABLE_DEVICE: {
+		switch (test_id) {
+		case BT_UNIT_TEST_FUNCTION_DEVICE_SET_AUTHORIZATION_TRUE: {
+			ret = bt_device_set_authorization(remote_addr, BT_DEVICE_AUTHORIZED);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		}
+		case BT_UNIT_TEST_FUNCTION_DEVICE_SET_AUTHORIZATION_FALSE: {
+			ret = bt_device_set_authorization(remote_addr, BT_DEVICE_UNAUTHORIZED);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		}
+		case BT_UNIT_TEST_FUNCTION_DEVICE_SET_AUTHORIZATION_CHANGED_CB:
+			ret = bt_device_set_authorization_changed_cb(__bt_device_authorization_changed_cb, NULL);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+
+		case BT_UNIT_TEST_FUNCTION_DEVICE_UNSET_AUTHORIZATION_CHANGED_CB:
+			ret = bt_device_unset_authorization_changed_cb();
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+
+		case BT_UNIT_TEST_FUNCTION_DEVICE_SET_CONNECTION_STAET_CHANGED_CB:
+			ret = bt_device_set_connection_state_changed_cb(__bt_device_connection_state_changed_cb, NULL);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+
+		case BT_UNIT_TEST_FUNCTION_DEVICE_UNSET_CONNECTION_STAET_CHANGED_CB:
+			ret = bt_device_unset_connection_state_changed_cb();
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+
+		case BT_UNIT_TEST_FUNCTION_DEVICE_FOREACH_CONNECTED_PROFILES: {
+			ret = bt_device_foreach_connected_profiles(remote_addr, __bt_device_connected_profile, NULL);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		}
+
+		case BT_UNIT_TEST_FUNCTION_DEVICE_IS_PROFILE_CONNECTED: {
+			bool connected_status = false;
+
+			ret = bt_device_is_profile_connected(remote_addr, BT_PROFILE_HSP, &connected_status);
+			if (ret < BT_ERROR_NONE) {
+				TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			}
+			TC_PRT("Profile [%s]", connected_status ? "Connected" : "Disconnected");
+			break;
+		}
+
+		case BT_UNIT_TEST_FUNCTION_DEVICE_SET_BOND_CREATED_CB : {
+			ret = bt_device_set_bond_created_cb(__bt_device_bond_created_cb, NULL);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		}
+
+		case BT_UNIT_TEST_FUNCTION_DEVICE_CREATE_BOND : {
+			ret = bt_device_create_bond(remote_addr);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		}
+
+		case BT_UNIT_TEST_FUNCTION_DEVICE_CREATE_BOND_BY_TYPE : {
+			ret = bt_device_create_bond_by_type(remote_addr, BT_DEVICE_CONNECTION_LINK_LE);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		}
+
+		default:
+			break;
+		}
+
+		break;
+	}
+	case BT_UNIT_TEST_TABLE_SOCKET: {
+		switch (test_id) {
+		case BT_UNIT_TEST_FUNCTION_SOCKET_CREATE_RFCOMM: {
+			int socket_fd = 0;
+
+			ret = bt_socket_create_rfcomm(spp_uuid, &socket_fd);
+			if (ret < BT_ERROR_NONE) {
+				TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			} else {
+				TC_PRT("socket_fd: %d", socket_fd);
+				server_fd = socket_fd;
+			}
+			break;
+		}
+		case BT_UNIT_TEST_FUNCTION_SOCKET_DESTROY_RFCOMM:
+			ret = bt_socket_destroy_rfcomm(server_fd);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		case BT_UNIT_TEST_FUNCTION_SOCKET_LISTEN_AND_ACCEPT_RFCOMM:
+			ret = bt_socket_listen_and_accept_rfcomm(server_fd, 1);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		case BT_UNIT_TEST_FUNCTION_SOCKET_LISTEN:
+			ret = bt_socket_listen(server_fd, 1);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		case BT_UNIT_TEST_FUNCTION_SOCKET_ACCEPT: {
+			int socket_fd = 0;
+
+			ret = bt_socket_accept(server_fd);
+			if (ret < BT_ERROR_NONE) {
+				TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			} else {
+				TC_PRT("socket_fd: %d", socket_fd);
+				client_fd = socket_fd;
+			}
+			break;
+		}
+		case BT_UNIT_TEST_FUNCTION_SOCKET_REJECT:
+			ret = bt_socket_reject(server_fd);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		case BT_UNIT_TEST_FUNCTION_SOCKET_CONNECT_RFCOMM: {
+			ret = bt_socket_connect_rfcomm(remote_addr, spp_uuid);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		}
+		case BT_UNIT_TEST_FUNCTION_SOCKET_DISCONNECT_RFCOMM:
+			ret = bt_socket_disconnect_rfcomm(client_fd);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		case BT_UNIT_TEST_FUNCTION_SOCKET_SEND_DATA: {
+			char data[] = "Sending test";
+			ret = bt_socket_send_data(client_fd, data, sizeof(data));
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		}
+		case BT_UNIT_TEST_FUNCTION_SOCKET_SET_DATA_RECEIVED_CB:
+			ret = bt_socket_set_data_received_cb(__bt_socket_data_received_cb, NULL);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		case BT_UNIT_TEST_FUNCTION_SOCKET_UNSET_DATA_RECEIVED_CB:
+			ret = bt_socket_unset_data_received_cb();
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		case BT_UNIT_TEST_FUNCTION_SOCKET_SET_CONNECTION_REQUESTED_CB:
+			ret = bt_socket_set_connection_requested_cb(__bt_socket_connection_requested_cb, NULL);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		case BT_UNIT_TEST_FUNCTION_SOCKET_UNSET_CONNECTION_REQUESTED_CB:
+			ret = bt_socket_unset_connection_requested_cb();
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		case BT_UNIT_TEST_FUNCTION_SOCKET_SET_CONNECTION_STATE_CHANGED_CB:
+			ret = bt_socket_set_connection_state_changed_cb(__bt_socket_connection_state_changed_cb, NULL);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		case BT_UNIT_TEST_FUNCTION_SOCKET_UNSET_CONNECTION_STATE_CHANGED_CB:
+			ret = bt_socket_unset_connection_state_changed_cb();
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		default:
+			break;
+		}
+
+		break;
+	}
+	case BT_UNIT_TEST_TABLE_OPP: {
+		switch (test_id) {
+		case BT_UNIT_TEST_FUNCTION_OPP_CLIENT_INITIALIZE:
+			ret = bt_opp_client_initialize();
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		case BT_UNIT_TEST_FUNCTION_OPP_CLIENT_DEINITIALIZE:
+			ret = bt_opp_client_deinitialize();
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		case BT_UNIT_TEST_FUNCTION_OPP_CLIENT_ADD_FILE:
+			ret = bt_opp_client_add_file("/opt/media/Images/image1.jpg");
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		case BT_UNIT_TEST_FUNCTION_OPP_CLIENT_CLEAR_FILES:
+			ret = bt_opp_client_clear_files();
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		case BT_UNIT_TEST_FUNCTION_OPP_CLIENT_PUSH_FILES: {
+			ret = bt_opp_client_push_files(remote_addr,__bt_opp_client_push_responded_cb,
+						__bt_opp_client_push_progress_cb,
+						__bt_opp_client_push_finished_cb,
+						NULL);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		}
+		case BT_UNIT_TEST_FUNCTION_OPP_CLIENT_CANCEL_PUSH:
+			ret = bt_opp_client_cancel_push();
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		default:
+			break;
+		}
+
+		break;
+	}
+	case BT_UNIT_TEST_TABLE_AUDIO: {
+		switch (test_id) {
+		case BT_UNIT_TEST_FUNCTION_AUDIO_INITIALIZE:
+			ret = bt_audio_initialize();
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		case BT_UNIT_TEST_FUNCTION_AUDIO_DEINITIALIZE:
+			ret = bt_audio_deinitialize();
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		case BT_UNIT_TEST_FUNCTION_AUDIO_CONNECT: {
+			ret = bt_audio_connect(remote_addr,  BT_AUDIO_PROFILE_TYPE_HSP_HFP);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		}
+		case BT_UNIT_TEST_FUNCTION_AUDIO_DISCONNECT: {
+			ret = bt_audio_disconnect(remote_addr,  BT_AUDIO_PROFILE_TYPE_HSP_HFP);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		}
+		case BT_UNIT_TEST_FUNCTION_AUDIO_SET_CONNECTION_STATE_CHANGED_CB:
+			ret = bt_audio_set_connection_state_changed_cb(
+						__bt_audio_connection_state_changed_cb, NULL);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		case BT_UNIT_TEST_FUNCTION_AUDIO_UNSET_CONNECTION_STATE_CHANGED_CB:
+			ret = bt_audio_unset_connection_state_changed_cb();
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		case BT_UNIT_TEST_FUNCTION_AG_OPEN_SCO:
+			ret = bt_ag_open_sco();
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		case BT_UNIT_TEST_FUNCTION_AG_CLOSE_SCO:
+			ret = bt_ag_close_sco();
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		case BT_UNIT_TEST_FUNCTION_AG_IS_SCO_OPENED: {
+			bool opened = false;
+			ret = bt_ag_is_sco_opened(&opened);
+			TC_PRT("opend[%s]", opened ? "YES" : "NO");
+			if (ret < BT_ERROR_NONE) {
+				TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			}
+			break;
+		}
+		case BT_UNIT_TEST_FUNCTION_AG_SET_SCO_STATE_CHANGED_CB:
+			ret = bt_ag_set_sco_state_changed_cb(__bt_ag_sco_state_changed_cb, NULL);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		case BT_UNIT_TEST_FUNCTION_AG_UNSET_SCO_STATE_CHANGED_CB:
+			ret = bt_ag_unset_sco_state_changed_cb();
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		case BT_UNIT_TEST_FUNCTION_AG_CALL_EVENT_IDLE: {
+			unsigned int call_id = 1;
+
+			ret = bt_ag_notify_call_event(BT_AG_CALL_EVENT_IDLE, call_id, NULL);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		}
+		case BT_UNIT_TEST_FUNCTION_AG_CALL_EVENT_ANSWERED: {
+			unsigned int call_id = 1;
+			bool sco_required = true;
+
+			ret = bt_ag_notify_call_event(BT_AG_CALL_EVENT_ANSWERED, call_id, NULL);
+			if (sco_required)
+				bt_ag_open_sco();
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		}
+		case BT_UNIT_TEST_FUNCTION_AG_CALL_EVENT_DIALING: {
+			unsigned int call_id = 1;
+			bool sco_required = TRUE;
+			char *phone_number;
+
+			phone_number = g_strdup("01012345678");
+			ret = bt_ag_notify_call_event(BT_AG_CALL_EVENT_DIALING,
+						call_id, (const char*)phone_number);
+			if (sco_required)
+				bt_ag_open_sco();
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			g_free(phone_number);
+			break;
+		}
+		case BT_UNIT_TEST_FUNCTION_AG_CALL_EVENT_ALERTING: {
+			unsigned int call_id = 1;
+
+			ret = bt_ag_notify_call_event(BT_AG_CALL_EVENT_ALERTING,
+						call_id, NULL);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		}
+		case BT_UNIT_TEST_FUNCTION_AG_CALL_EVENT_INCOMING: {
+			unsigned int call_id = 1;
+			char *phone_number;
+
+			phone_number = g_strdup("01012345678");
+			ret = bt_ag_notify_call_event(BT_AG_CALL_EVENT_INCOMING,
+						call_id, (const char*)phone_number);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			g_free(phone_number);
+			break;
+		}
+		case BT_UNIT_TEST_FUNCTION_CALL_LIST_CREATE:
+			ret = bt_call_list_create(&call_list);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		case BT_UNIT_TEST_FUNCTION_CALL_LIST_DESTROY:
+			ret = bt_call_list_destroy(call_list);
+			call_list = NULL;
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		case BT_UNIT_TEST_FUNCTION_CALL_LIST_RESET:
+			ret = bt_call_list_reset(call_list);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		case BT_UNIT_TEST_FUNCTION_CALL_LIST_ADD: {
+			char *phone_number;
+
+			phone_number = g_strdup("01012345678");
+			ret = bt_call_list_add(call_list, 1, BT_AG_CALL_STATE_ACTIVE,
+						(const char*)phone_number);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			g_free(phone_number);
+			break;
+		}
+		case BT_UNIT_TEST_FUNCTION_AG_NOTIFY_CALL_LIST:
+			ret = bt_ag_notify_call_list(call_list);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		case BT_UNIT_TEST_FUNCTION_AG_SET_CALL_HANDLING_EVENT_CB:
+			ret = bt_ag_set_call_handling_event_cb(
+						__bt_ag_set_call_handling_event_cb, NULL);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		case BT_UNIT_TEST_FUNCTION_AG_IS_NREC_ENABLED: {
+			bool enabled = false;
+			ret = bt_ag_is_nrec_enabled(&enabled);
+			TC_PRT("opend[%s]", enabled ? "YES" : "NO");
+			if (ret < BT_ERROR_NONE) {
+				TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			}
+			break;
+		}
+		default:
+			break;
+		}
+
+		break;
+	}
+	case BT_UNIT_TEST_TABLE_PAN: {
+		switch (test_id) {
+		case BT_UNIT_TEST_FUNCTION_NAP_ACTIVATE:
+			ret = bt_nap_activate();
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+
+		case BT_UNIT_TEST_FUNCTION_NAP_DEACTIVATE:
+			ret = bt_nap_deactivate();
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+
+		case BT_UNIT_TEST_FUNCTION_NAP_DISCONNECT_ALL:
+			ret = bt_nap_disconnect_all();
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+
+		case BT_UNIT_TEST_FUNCTION_NAP_DISCONNECT: {
+			ret = bt_nap_disconnect(remote_addr);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		}
+
+		case BT_UNIT_TEST_FUNCTION_PANU_SET_CONNECTION_STATE_CHANGED_CB: {
+			ret = bt_panu_set_connection_state_changed_cb(panu_conn_state_changed,
+												   NULL);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		}
+		case BT_UNIT_TEST_FUNCTION_PANU_CONNECT: {
+			ret = bt_panu_connect(remote_addr, BT_PANU_SERVICE_TYPE_NAP);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		}
+		default:
+			break;
+		}
+
+		break;
+	}
+	case BT_UNIT_TEST_TABLE_GATT: {
+		switch (test_id) {
+		case BT_UNIT_TEST_FUNCTION_GATT_FOREACH_PRIMARY_SERVICES: {
+			__bt_free_gatt_services();
+
+			ret = bt_gatt_foreach_primary_services(remote_addr, __bt_gatt_primary_service_cb, NULL);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			if (ret == BT_ERROR_NONE)
+				__select_index(&selected_service_index);
+			break;
+		}
+
+		case BT_UNIT_TEST_FUNCTION_GATT_DISCOVER_CHARACTERISTICS: {
+			__bt_free_gatt_characteristics();
+
+			if (selected_service_index < 0) {
+				TC_PRT("Need to select primary service \n");
+				break;
+			}
+
+			ret = bt_gatt_discover_characteristics(service_clone[selected_service_index], __bt_gatt_characteristics_discovered_cb, NULL);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			if (ret == BT_ERROR_NONE)
+				__select_index(&selected_char_index);
+			break;
+		}
+
+		case BT_UNIT_TEST_FUNCTION_GATT_GET_SERVICE_UUID: {
+			char *uuid = NULL;
+
+			if (selected_service_index < 0) {
+				TC_PRT("Need to select primary service \n");
+				break;
+			}
+
+			ret = bt_gatt_get_service_uuid(service_clone[selected_service_index], &uuid);
+			if (ret < BT_ERROR_NONE) {
+				TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			} else {
+				TC_PRT("uuid: %s", uuid);
+				g_free(uuid);
+			}
+			break;
+		}
+
+		case BT_UNIT_TEST_FUNCTION_GATT_FOREACH_INCLUDED_SERVICES: {
+			__bt_free_gatt_characteristics_services();
+
+			if (selected_service_index < 0) {
+				TC_PRT("Need to select primary service \n");
+				break;
+			}
+
+			ret = bt_gatt_foreach_included_services(service_clone[selected_service_index], __bt_gatt_included_service_cb, NULL);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		}
+
+		case BT_UNIT_TEST_FUNCTION_GATT_SET_CHARACTERISTIC_CHANGED_CB: {
+			ret = bt_gatt_set_characteristic_changed_cb(__bt_gatt_characteristic_changed_cb, NULL);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		}
+
+		case BT_UNIT_TEST_FUNCTION_GATT_UNSET_CHARACTERISTIC_CHANGED_CB: {
+			ret = bt_gatt_unset_characteristic_changed_cb();
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		}
+
+		case BT_UNIT_TEST_FUNCTION_GATT_GET_CHARACTERISTIC_DECLARATION: {
+			int i;
+			char *uuid = NULL;
+			unsigned char *value = NULL;
+			int value_length = 0;
+
+			ret = bt_gatt_get_characteristic_declaration(characteristics_services[0], &uuid, &value, &value_length);
+			if (ret < BT_ERROR_NONE) {
+				TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			} else {
+				TC_PRT("uuid: %s", uuid);
+
+				for (i = 0; i < value_length; i++) {
+					TC_PRT("value %c", value[i]);
+				}
+
+				g_free(uuid);
+				g_free(value);
+			}
+			break;
+		}
+
+		case BT_UNIT_TEST_FUNCTION_GATT_SET_CHARACTERISTIC_VALUE: {
+			unsigned char value[] = { 1 };
+			if (selected_char_index == 0) {
+				TC_PRT("Need to select charateristic value \n");
+				break;
+			}
+
+			ret = bt_gatt_set_characteristic_value_request(characteristics[selected_char_index], value, 1,
+					__bt_gatt_char_write_cb);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		}
+
+		case BT_UNIT_TEST_FUNCTION_GATT_READ_CHARACTERISTIC_VALUE : {
+			if (selected_char_index == 0) {
+				TC_PRT("Need to select charateristic value \n");
+				break;
+			}
+
+			ret = bt_gatt_read_characteristic_value(characteristics[selected_char_index], __bt_gatt_char_read_cb);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		}
+
+		case BT_UNIT_TEST_FUNCTION_GATT_WATCH_CHARACTERISTIC_CHANGES: {
+			if (selected_service_index < 0) {
+				TC_PRT("Need to select primary service \n");
+				break;
+			}
+
+			ret = bt_gatt_watch_characteristic_changes(service_clone[selected_service_index]);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		}
+		case BT_UNIT_TEST_FUNCTION_GATT_UNWATCH_CHARACTERISTIC_CHANGES: {
+			ret = bt_gatt_unwatch_characteristic_changes(service_clone[selected_service_index]);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		}
+		case BT_UNIT_TEST_FUNCTION_GATT_CONNECT : {
+			ret = bt_gatt_connect(remote_addr, false);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		}
+		case BT_UNIT_TEST_FUNCTION_GATT_DISCONNECT : {
+			ret = bt_gatt_disconnect(remote_addr);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		}
+		case BT_UNIT_TEST_FUNCTION_SET_GATT_CONNECTION_STATE_CHANGED_CB : {
+			ret = bt_gatt_set_connection_state_changed_cb(__bt_gatt_connection_state_changed_cb, NULL);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		}
+		case BT_UNIT_TEST_FUNCTION_UNSET_GATT_CONNECTION_STATE_CHANGED_CB : {
+			ret = bt_gatt_unset_connection_state_changed_cb();
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		}
+		default:
+			break;
+		}
+
+		break;
+	}
+	case BT_UNIT_TEST_TABLE_AVRCP: {
+		switch (test_id) {
+		case BT_UNIT_TEST_FUNCTION_AVRCP_TARGET_INITIALIZE:
+			ret = bt_avrcp_target_initialize(__bt_avrcp_target_connection_state_changed_cb, NULL);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+
+		case BT_UNIT_TEST_FUNCTION_AVRCP_TARGET_DEINITIALIZE:
+			ret = bt_avrcp_target_deinitialize();
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+
+		case BT_UNIT_TEST_FUNCTION_AVRCP_SET_EQUALIZER_STATE_CHANGED_CB:
+			ret = bt_avrcp_set_equalizer_state_changed_cb(__bt_avrcp_equalizer_state_changed_cb, NULL);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+
+		case BT_UNIT_TEST_FUNCTION_AVRCP_SET_REPEAT_MODE_CHANGED_CB:
+			ret = bt_avrcp_set_repeat_mode_changed_cb(__bt_avrcp_repeat_mode_changed_cb, NULL);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+
+		case BT_UNIT_TEST_FUNCTION_AVRCP_SET_SHUFFLE_MODE_CHANGED_CB:
+			ret = bt_avrcp_set_shuffle_mode_changed_cb(__bt_avrcp_shuffle_mode_changed_cb, NULL);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+
+		case BT_UNIT_TEST_FUNCTION_AVRCP_SET_SCAN_MODE_CHANGED_CB:
+			ret = bt_avrcp_set_scan_mode_changed_cb(__bt_avrcp_scan_mode_changed_cb, NULL);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+
+		case BT_UNIT_TEST_FUNCTION_AVRCP_UNSET_EQUALIZER_STATE_CHANGED_CB:
+			ret = bt_avrcp_unset_equalizer_state_changed_cb();
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+
+		case BT_UNIT_TEST_FUNCTION_AVRCP_UNSET_REPEAT_MODE_CHANGED_CB:
+			ret = bt_avrcp_unset_repeat_mode_changed_cb();
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+
+		case BT_UNIT_TEST_FUNCTION_AVRCP_UNSET_SHUFFLE_MODE_CHANGED_CB:
+			ret = bt_avrcp_unset_shuffle_mode_changed_cb();
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+
+		case BT_UNIT_TEST_FUNCTION_AVRCP_UNSET_SCAN_MODE_CHANGED_CB:
+			ret = bt_avrcp_unset_scan_mode_changed_cb();
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		default:
+			break;
+		}
+
+		break;
+	}
+	case BT_UNIT_TEST_TABLE_HID: {
+		switch (test_id) {
+		case BT_UNIT_TEST_FUNCTION_HID_HOST_INITIALIZE:
+			ret = bt_hid_host_initialize(__bt_hid_host_connection_state_changed_cb,
+											NULL);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		case BT_UNIT_TEST_FUNCTION_HID_HOST_DEINITIALIZE:
+			ret = bt_hid_host_deinitialize();
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		case BT_UNIT_TEST_FUNCTION_HID_HOST_CONNECT: {
+			ret = bt_hid_host_connect(remote_addr);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		}
+		case BT_UNIT_TEST_FUNCTION_HID_HOST_DISCONNECT: {
+			ret = bt_hid_host_disconnect(remote_addr);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			break;
+		}
+		default:
+			break;
+		}
+
+		break;
+	}
+	case BT_UNIT_TEST_TABLE_AUTOMATED_TEST: {
+		static unsigned int delay = 0;
+
+		if (input_automated_test_delay == true) {
+			delay = test_id;
+			test_id = BT_UNIT_TEST_FUNCTION_ON_OFF_REPEAT_TEST_N_SEC_DELAY;
+		}
+
+		switch (test_id) {
+		/*Automated Test Cases */
+		case BT_UNIT_TEST_FUNCTION_ON_OFF_REPEAT_TEST: {
+			bt_adapter_state_e state = BT_ADAPTER_DISABLED;
+			delay = 0;
+
+			ret = bt_adapter_set_state_changed_cb(__bt_repeat_test_adapter_state_changed_cb, &delay);
+			TC_PRT("set_cb returns %s\n", __bt_get_error_message(ret));
+
+			ret = bt_adapter_get_state(&state);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			TC_PRT("Current state: %d", state);
+
+			if (state == BT_ADAPTER_DISABLED)
+				bt_adapter_enable();
+			else
+				bt_adapter_disable();
+			break;
+		}
+		case BT_UNIT_TEST_FUNCTION_ON_OFF_REPEAT_TEST_1_SEC_DELAY: {
+			bt_adapter_state_e state = BT_ADAPTER_DISABLED;
+			delay = 1;
+
+			ret = bt_adapter_set_state_changed_cb(__bt_repeat_test_adapter_state_changed_cb, &delay);
+			TC_PRT("set_cb returns %s\n", __bt_get_error_message(ret));
+
+			ret = bt_adapter_get_state(&state);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			TC_PRT("Current state: %d", state);
+
+			if (state == BT_ADAPTER_DISABLED)
+				bt_adapter_enable();
+			else
+				bt_adapter_disable();
+			break;
+		}
+		case BT_UNIT_TEST_FUNCTION_ON_OFF_REPEAT_TEST_N_SEC_DELAY: {
+			bt_adapter_state_e state = BT_ADAPTER_DISABLED;
+
+			input_automated_test_delay = false;
+
+			ret = bt_adapter_set_state_changed_cb(__bt_repeat_test_adapter_state_changed_cb, &delay);
+			TC_PRT("set_cb returns %s\n", __bt_get_error_message(ret));
+
+			ret = bt_adapter_get_state(&state);
+			TC_PRT("returns %s\n", __bt_get_error_message(ret));
+			TC_PRT("Current state: %d", state);
+
+			if (state == BT_ADAPTER_DISABLED)
+				bt_adapter_enable();
+			else
+				bt_adapter_disable();
+			break;
+		}
+		default:
+			break;
+		}
+
+		break;
+	}
+	default:
+		break;
+	}
+
+	return 0;
+}
+
+static gboolean key_event_cb(GIOChannel *chan,
+				GIOCondition cond,
+				gpointer data)
+{
+	char buf[BUFFER_LEN] = { 0 };
+
+	unsigned int len = 0;
+	int test_id;
+	bool is_call_api = false;
+
+	if (is_sub_index)
+		return TRUE;
+
+	memset(buf, 0, sizeof(buf));
+
+	if (g_io_channel_read_chars(chan, buf, sizeof(buf),
+				&len, NULL) == G_IO_STATUS_ERROR) {
+		TC_PRT("IO Channel read error");
+		return FALSE;
+	}
+
+	TC_PRT("%s", buf);
+
+	test_id = atoi(buf);
+
+	if (current_tc_table == BT_UNIT_TEST_TABLE_MAIN) {
+		if (buf[0] == '0' && buf[2] == 0)
+			current_tc_table = BT_UNIT_TEST_TABLE_SET_ADDRESS;
+		else if(test_id >= BT_UNIT_TEST_TABLE_ADAPTER && test_id < BT_UNIT_TEST_TABLE_END)
+			current_tc_table = test_id;
+		else
+			is_call_api = true;
+	}  else {
+		if (buf[0] == '0' && buf[2] == 0) {
+			current_tc_table = BT_UNIT_TEST_TABLE_MAIN;
+		} else if (current_tc_table == BT_UNIT_TEST_TABLE_AUTOMATED_TEST
+					&& test_id == BT_UNIT_TEST_FUNCTION_ON_OFF_REPEAT_TEST_N_SEC_DELAY
+					&& input_automated_test_delay == false) {
+				input_automated_test_delay = true;
+		} else {
+			is_call_api = true;
+		}
+	}
+
+	tc_usage_print();
+
+	if (current_tc_table == BT_UNIT_TEST_TABLE_SET_ADDRESS && is_call_api == true) {
+		memcpy (remote_addr, buf, 17);
+		remote_addr[17] = 0;
+	} else if (test_id && is_call_api)
+		g_idle_add(test_input_callback, (void *)test_id);
+
+	return TRUE;
+}
+
+int main()
+{
+	GIOChannel *key_io;
+
+	g_type_init();
+	current_tc_table = BT_UNIT_TEST_TABLE_MAIN;
+
+	key_io = g_io_channel_unix_new(fileno(stdin));
+
+	g_io_channel_set_encoding(key_io, NULL, NULL);
+	g_io_channel_set_flags(key_io, G_IO_FLAG_NONBLOCK, NULL);
+
+	g_io_add_watch(key_io, G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
+			key_event_cb, NULL);
+
+	g_io_channel_unref(key_io);
+
+	main_loop = g_main_loop_new(NULL, FALSE);
+
+	g_main_loop_run(main_loop);
+
+	bt_deinitialize();
+
+	return 0;
+}
diff --git a/test/bt_unit_test.h b/test/bt_unit_test.h
new file mode 100644
index 0000000..997a942
--- /dev/null
+++ b/test/bt_unit_test.h
@@ -0,0 +1,199 @@
+/*
+ *
+ * Copyright (c) 2000 - 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.
+ *
+ */
+
+#ifndef __TIZEN_NETWORK_BLUETOOTH_UNIT_TEST_H__
+#define __TIZEN_NETWORK_BLUETOOTH_UNIT_TEST_H__
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define BUFFER_LEN 19
+#define MAX_SERVICES 10
+#define PRT(format, args...) printf("%s:%d() "format, __FUNCTION__, __LINE__, ##args)
+#define TC_PRT(format, args...) PRT(format"\n", ##args)
+
+typedef enum
+{
+	BT_UNIT_TEST_TABLE_MAIN = 1,
+	BT_UNIT_TEST_TABLE_SET_ADDRESS,
+	BT_UNIT_TEST_TABLE_ADAPTER,
+	BT_UNIT_TEST_TABLE_ADAPTER_LE,
+	BT_UNIT_TEST_TABLE_DEVICE,
+	BT_UNIT_TEST_TABLE_SOCKET,
+	BT_UNIT_TEST_TABLE_OPP,
+	BT_UNIT_TEST_TABLE_AUDIO,
+	BT_UNIT_TEST_TABLE_PAN,
+	BT_UNIT_TEST_TABLE_GATT,
+	BT_UNIT_TEST_TABLE_AVRCP,
+	BT_UNIT_TEST_TABLE_HID,
+	BT_UNIT_TEST_TABLE_AUTOMATED_TEST,
+	BT_UNIT_TEST_TABLE_END,
+} bt_unit_test_table_e;
+
+typedef enum
+{
+	BT_UNIT_TEST_FUNCTION_BACK = 0,
+	BT_UNIT_TEST_FUNCTION_SET_ADDRESS = 0,
+	BT_UNIT_TEST_FUNCTION_INITIALIZE = 1,
+	BT_UNIT_TEST_FUNCTION_DEINITIALIZE,
+	BT_UNIT_TEST_FUNCTION_ADAPTER_GET_STATE = 1,
+	BT_UNIT_TEST_FUNCTION_ADAPTER_ENABLE,
+	BT_UNIT_TEST_FUNCTION_ADAPTER_DISABLE,
+	BT_UNIT_TEST_FUNCTION_ADAPTER_RECOVER,
+	BT_UNIT_TEST_FUNCTION_ADAPTER_START_DEVICE_DISCOVERY,
+	BT_UNIT_TEST_FUNCTION_ADAPTER_STOP_DEVICE_DISCOVERY,
+	BT_UNIT_TEST_FUNCTION_ADAPTER_IS_DISCOVERING,
+	BT_UNIT_TEST_FUNCTION_ADAPTER_FOREACH_BONDED_DEVICE,
+	BT_UNIT_TEST_FUNCTION_ADAPTER_GET_BONDED_DEVICE_INFO,
+	BT_UNIT_TEST_FUNCTION_ADAPTER_IS_SERVICE_USED,
+	BT_UNIT_TEST_FUNCTION_ADAPTER_GET_VISIBILITY,
+	BT_UNIT_TEST_FUNCTION_ADAPTER_SET_DEVICE_DISCOVERY_STATE_CHANGED_CB,
+	BT_UNIT_TEST_FUNCTION_ADAPTER_UNSET_DEVICE_DISCOVERY_STATE_CHANGED_CB,
+	BT_UNIT_TEST_FUNCTION_ADAPTER_GET_LOCAL_OOB_DATA,
+	BT_UNIT_TEST_FUNCTION_ADAPTER_SET_LOCAL_OOB_DATA,
+	BT_UNIT_TEST_FUNCTION_ADAPTER_REMOVE_REMOTE_OOB_DATA,
+	BT_UNIT_TEST_FUNCTION_ADAPTER_SET_VISIBILITY_MODE_CHANGED_CB,
+	BT_UNIT_TEST_FUNCTION_ADAPTER_UNSET_VISIBILITY_MODE_CHANGED_CB,
+	BT_UNIT_TEST_FUNCTION_ADAPTER_SET_VISIBILITY_DURATION_CHANGED_CB,
+	BT_UNIT_TEST_FUNCTION_ADAPTER_UNSET_VISIBILITY_DURATION_CHANGED_CB,
+	BT_UNIT_TEST_FUNCTION_ADAPTER_SET_CONNECTABLE_CHANGED_CB,
+	BT_UNIT_TEST_FUNCTION_ADAPTER_UNSET_CONNECTABLE_CHANGED_CB,
+	BT_UNIT_TEST_FUNCTION_ADAPTER_GET_CONNECTABLE,
+	BT_UNIT_TEST_FUNCTION_ADAPTER_SET_CONNECTABLE,
+	BT_UNIT_TEST_FUNCTION_ADAPTER_GET_VERSION,
+	BT_UNIT_TEST_FUNCTION_ADAPTER_GET_LOCAL_INFO,
+	BT_UNIT_TEST_FUNCTION_ADAPTER_LE_GET_STATE = 1,
+	BT_UNIT_TEST_FUNCTION_ADAPTER_LE_ENABLE,
+	BT_UNIT_TEST_FUNCTION_ADAPTER_LE_DISABLE,
+	BT_UNIT_TEST_FUNCTION_ADAPTER_LE_START_DEVICE_DISCOVERY,
+	BT_UNIT_TEST_FUNCTION_ADAPTER_LE_STOP_DEVICE_DISCOVERY,
+	BT_UNIT_TEST_FUNCTION_ADAPTER_LE_START_ADVERTISING,
+	BT_UNIT_TEST_FUNCTION_ADAPTER_LE_STOP_ADVERTISING,
+	BT_UNIT_TEST_FUNCTION_ADAPTER_LE_ADD_WHITE_LIST,
+	BT_UNIT_TEST_FUNCTION_ADAPTER_LE_REMOVE_WHITE_LIST,
+	BT_UNIT_TEST_FUNCTION_ADAPTER_LE_CLEAR_WHITE_LIST,
+	BT_UNIT_TEST_FUNCTION_ADAPTER_LE_ENABLE_PRIVACY,
+	BT_UNIT_TEST_FUNCTION_ADAPTER_LE_SET_DEVICE_DISCOVERY_STATE_CHANGED_CB,
+	BT_UNIT_TEST_FUNCTION_ADAPTER_LE_UNSET_DEVICE_DISCOVERY_STATE_CHANGED_CB,
+	BT_UNIT_TEST_FUNCTION_DEVICE_SET_AUTHORIZATION_TRUE = 1,
+	BT_UNIT_TEST_FUNCTION_DEVICE_SET_AUTHORIZATION_FALSE,
+	BT_UNIT_TEST_FUNCTION_DEVICE_SET_AUTHORIZATION_CHANGED_CB,
+	BT_UNIT_TEST_FUNCTION_DEVICE_UNSET_AUTHORIZATION_CHANGED_CB,
+	BT_UNIT_TEST_FUNCTION_DEVICE_SET_CONNECTION_STAET_CHANGED_CB,
+	BT_UNIT_TEST_FUNCTION_DEVICE_UNSET_CONNECTION_STAET_CHANGED_CB,
+	BT_UNIT_TEST_FUNCTION_DEVICE_FOREACH_CONNECTED_PROFILES,
+	BT_UNIT_TEST_FUNCTION_DEVICE_IS_PROFILE_CONNECTED,
+	BT_UNIT_TEST_FUNCTION_DEVICE_SET_BOND_CREATED_CB,
+	BT_UNIT_TEST_FUNCTION_DEVICE_CREATE_BOND,
+	BT_UNIT_TEST_FUNCTION_DEVICE_CREATE_BOND_BY_TYPE,
+	BT_UNIT_TEST_FUNCTION_SOCKET_CREATE_RFCOMM = 1,
+	BT_UNIT_TEST_FUNCTION_SOCKET_DESTROY_RFCOMM,
+	BT_UNIT_TEST_FUNCTION_SOCKET_LISTEN_AND_ACCEPT_RFCOMM,
+	BT_UNIT_TEST_FUNCTION_SOCKET_LISTEN,
+	BT_UNIT_TEST_FUNCTION_SOCKET_ACCEPT,
+	BT_UNIT_TEST_FUNCTION_SOCKET_REJECT,
+	BT_UNIT_TEST_FUNCTION_SOCKET_CONNECT_RFCOMM,
+	BT_UNIT_TEST_FUNCTION_SOCKET_DISCONNECT_RFCOMM,
+	BT_UNIT_TEST_FUNCTION_SOCKET_SEND_DATA,
+	BT_UNIT_TEST_FUNCTION_SOCKET_SET_DATA_RECEIVED_CB,
+	BT_UNIT_TEST_FUNCTION_SOCKET_UNSET_DATA_RECEIVED_CB,
+	BT_UNIT_TEST_FUNCTION_SOCKET_SET_CONNECTION_REQUESTED_CB,
+	BT_UNIT_TEST_FUNCTION_SOCKET_UNSET_CONNECTION_REQUESTED_CB,
+	BT_UNIT_TEST_FUNCTION_SOCKET_SET_CONNECTION_STATE_CHANGED_CB,
+	BT_UNIT_TEST_FUNCTION_SOCKET_UNSET_CONNECTION_STATE_CHANGED_CB,
+	BT_UNIT_TEST_FUNCTION_OPP_CLIENT_INITIALIZE = 1,
+	BT_UNIT_TEST_FUNCTION_OPP_CLIENT_DEINITIALIZE,
+	BT_UNIT_TEST_FUNCTION_OPP_CLIENT_ADD_FILE,
+	BT_UNIT_TEST_FUNCTION_OPP_CLIENT_CLEAR_FILES,
+	BT_UNIT_TEST_FUNCTION_OPP_CLIENT_PUSH_FILES,
+	BT_UNIT_TEST_FUNCTION_OPP_CLIENT_CANCEL_PUSH,
+	BT_UNIT_TEST_FUNCTION_AUDIO_INITIALIZE = 1,
+	BT_UNIT_TEST_FUNCTION_AUDIO_DEINITIALIZE,
+	BT_UNIT_TEST_FUNCTION_AUDIO_CONNECT,
+	BT_UNIT_TEST_FUNCTION_AUDIO_DISCONNECT,
+	BT_UNIT_TEST_FUNCTION_AUDIO_SET_CONNECTION_STATE_CHANGED_CB,
+	BT_UNIT_TEST_FUNCTION_AUDIO_UNSET_CONNECTION_STATE_CHANGED_CB,
+	BT_UNIT_TEST_FUNCTION_AG_OPEN_SCO,
+	BT_UNIT_TEST_FUNCTION_AG_CLOSE_SCO,
+	BT_UNIT_TEST_FUNCTION_AG_IS_SCO_OPENED,
+	BT_UNIT_TEST_FUNCTION_AG_SET_SCO_STATE_CHANGED_CB,
+	BT_UNIT_TEST_FUNCTION_AG_UNSET_SCO_STATE_CHANGED_CB,
+	BT_UNIT_TEST_FUNCTION_AG_CALL_EVENT_IDLE,
+	BT_UNIT_TEST_FUNCTION_AG_CALL_EVENT_ANSWERED,
+	BT_UNIT_TEST_FUNCTION_AG_CALL_EVENT_DIALING,
+	BT_UNIT_TEST_FUNCTION_AG_CALL_EVENT_ALERTING,
+	BT_UNIT_TEST_FUNCTION_AG_CALL_EVENT_INCOMING,
+	BT_UNIT_TEST_FUNCTION_CALL_LIST_CREATE,
+	BT_UNIT_TEST_FUNCTION_CALL_LIST_DESTROY,
+	BT_UNIT_TEST_FUNCTION_CALL_LIST_RESET,
+	BT_UNIT_TEST_FUNCTION_CALL_LIST_ADD,
+	BT_UNIT_TEST_FUNCTION_AG_NOTIFY_CALL_LIST,
+	BT_UNIT_TEST_FUNCTION_AG_SET_CALL_HANDLING_EVENT_CB,
+	BT_UNIT_TEST_FUNCTION_AG_IS_NREC_ENABLED,
+	BT_UNIT_TEST_FUNCTION_NAP_ACTIVATE = 1,
+	BT_UNIT_TEST_FUNCTION_NAP_DEACTIVATE,
+	BT_UNIT_TEST_FUNCTION_NAP_DISCONNECT_ALL,
+	BT_UNIT_TEST_FUNCTION_NAP_DISCONNECT,
+	BT_UNIT_TEST_FUNCTION_PANU_SET_CONNECTION_STATE_CHANGED_CB,
+	BT_UNIT_TEST_FUNCTION_PANU_CONNECT,
+	BT_UNIT_TEST_FUNCTION_GATT_FOREACH_PRIMARY_SERVICES = 1,
+	BT_UNIT_TEST_FUNCTION_GATT_DISCOVER_CHARACTERISTICS,
+	BT_UNIT_TEST_FUNCTION_GATT_GET_SERVICE_UUID,
+	BT_UNIT_TEST_FUNCTION_GATT_FOREACH_INCLUDED_SERVICES,
+	BT_UNIT_TEST_FUNCTION_GATT_SET_CHARACTERISTIC_CHANGED_CB,
+	BT_UNIT_TEST_FUNCTION_GATT_UNSET_CHARACTERISTIC_CHANGED_CB,
+	BT_UNIT_TEST_FUNCTION_GATT_GET_CHARACTERISTIC_DECLARATION,
+	BT_UNIT_TEST_FUNCTION_GATT_SET_CHARACTERISTIC_VALUE,
+	BT_UNIT_TEST_FUNCTION_GATT_READ_CHARACTERISTIC_VALUE,
+	BT_UNIT_TEST_FUNCTION_GATT_WATCH_CHARACTERISTIC_CHANGES,
+	BT_UNIT_TEST_FUNCTION_GATT_UNWATCH_CHARACTERISTIC_CHANGES,
+	BT_UNIT_TEST_FUNCTION_GATT_CONNECT,
+	BT_UNIT_TEST_FUNCTION_GATT_DISCONNECT,
+	BT_UNIT_TEST_FUNCTION_SET_GATT_CONNECTION_STATE_CHANGED_CB,
+	BT_UNIT_TEST_FUNCTION_UNSET_GATT_CONNECTION_STATE_CHANGED_CB,
+	BT_UNIT_TEST_FUNCTION_AVRCP_TARGET_INITIALIZE = 1,
+	BT_UNIT_TEST_FUNCTION_AVRCP_TARGET_DEINITIALIZE,
+	BT_UNIT_TEST_FUNCTION_AVRCP_SET_EQUALIZER_STATE_CHANGED_CB,
+	BT_UNIT_TEST_FUNCTION_AVRCP_SET_REPEAT_MODE_CHANGED_CB,
+	BT_UNIT_TEST_FUNCTION_AVRCP_SET_SHUFFLE_MODE_CHANGED_CB,
+	BT_UNIT_TEST_FUNCTION_AVRCP_SET_SCAN_MODE_CHANGED_CB,
+	BT_UNIT_TEST_FUNCTION_AVRCP_UNSET_EQUALIZER_STATE_CHANGED_CB,
+	BT_UNIT_TEST_FUNCTION_AVRCP_UNSET_REPEAT_MODE_CHANGED_CB,
+	BT_UNIT_TEST_FUNCTION_AVRCP_UNSET_SHUFFLE_MODE_CHANGED_CB,
+	BT_UNIT_TEST_FUNCTION_AVRCP_UNSET_SCAN_MODE_CHANGED_CB,
+	BT_UNIT_TEST_FUNCTION_HID_HOST_INITIALIZE = 1,
+	BT_UNIT_TEST_FUNCTION_HID_HOST_DEINITIALIZE,
+	BT_UNIT_TEST_FUNCTION_HID_HOST_CONNECT,
+	BT_UNIT_TEST_FUNCTION_HID_HOST_DISCONNECT,
+	BT_UNIT_TEST_FUNCTION_ON_OFF_REPEAT_TEST = 1,
+	BT_UNIT_TEST_FUNCTION_ON_OFF_REPEAT_TEST_1_SEC_DELAY,
+	BT_UNIT_TEST_FUNCTION_ON_OFF_REPEAT_TEST_N_SEC_DELAY
+} bt_unit_test_function_e;
+
+typedef struct {
+	const char *tc_name;
+	int tc_code;
+} tc_table_t;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __TIZEN_NETWORK_BLUETOOTH_UNIT_TEST_H__ */
diff --git a/test/capi-network-bluetooth-test b/test/capi-network-bluetooth-test
new file mode 100644
index 0000000..ec7331a
--- /dev/null
+++ b/test/capi-network-bluetooth-test
@@ -0,0 +1,4 @@
+root capi-network-bluetooth-test rw----
+_default_ capi-network-bluetooth-test rw----
+capi-network-bluetooth-test bt-service::platform rw----
+capi-network-bluetooth-test bt-service::public -w----
diff --git a/test/capi-network-bluetooth-test.efl b/test/capi-network-bluetooth-test.efl
new file mode 100644
index 0000000..ec7331a
--- /dev/null
+++ b/test/capi-network-bluetooth-test.efl
@@ -0,0 +1,4 @@
+root capi-network-bluetooth-test rw----
+_default_ capi-network-bluetooth-test rw----
+capi-network-bluetooth-test bt-service::platform rw----
+capi-network-bluetooth-test bt-service::public -w----
diff --git a/wearable/AUTHORS b/wearable/AUTHORS
deleted file mode 100644
index 0bb1836..0000000
--- a/wearable/AUTHORS
+++ /dev/null
@@ -1,2 +0,0 @@
-ByungWoo Lee <bw1212.lee@samsung.com>
-Kangho Hur <kangho.hur@samsung.com>
diff --git a/wearable/NOTICE b/wearable/NOTICE
deleted file mode 100644
index 0e0f016..0000000
--- a/wearable/NOTICE
+++ /dev/null
@@ -1,3 +0,0 @@
-Copyright (c) Samsung Electronics Co., Ltd. All rights reserved.
-Except as noted, this software is licensed under Apache License, Version 2.
-Please, see the LICENSE.APLv2 file for Apache License terms and conditions.
diff --git a/wearable/TC/READAME.txt b/wearable/TC/READAME.txt
deleted file mode 100644
index f0edad5..0000000
--- a/wearable/TC/READAME.txt
+++ /dev/null
@@ -1,5 +0,0 @@
-Before run DTS of bluetooth, BT should be disabled.
-This DTS needs another target and it must be set as the following:
- 1) BT is activated.
- 2) BT is discoverable.
- 3) BT name is set as "dts_test".
diff --git a/wearable/TC/_export_env.sh b/wearable/TC/_export_env.sh
deleted file mode 100755
index ac8f4a1..0000000
--- a/wearable/TC/_export_env.sh
+++ /dev/null
@@ -1,9 +0,0 @@
-#!/bin/sh
-
-. ./config
-export TET_INSTALL_PATH=$TET_INSTALL_HOST_PATH # tetware root path
-export TET_TARGET_PATH=$TET_INSTALL_PATH/tetware-target # tetware target path
-#export TET_TARGET_PATH=$TET_INSTALL_PATH/tetware-simulator # tetware simulator path
-export PATH=$TET_TARGET_PATH/bin:$PATH
-export LD_LIBRARY_PATH=$TET_TARGET_PATH/lib/tet3:$LD_LIBRARY_PATH
-export TET_ROOT=$TET_TARGET_PATH
diff --git a/wearable/TC/_export_target_env.sh b/wearable/TC/_export_target_env.sh
deleted file mode 100755
index c693f83..0000000
--- a/wearable/TC/_export_target_env.sh
+++ /dev/null
@@ -1,8 +0,0 @@
-#!/bin/sh
-. ./config
-export TET_INSTALL_PATH=$TET_INSTALL_TARGET_PATH # path to path
-export TET_TARGET_PATH=$TET_INSTALL_PATH/tetware-target
-#export TET_TARGET_PATH=$TET_INSTALL_PATH/tetware-simulator # tetware simulator path
-export PATH=$TET_TARGET_PATH/bin:$PATH
-export LD_LIBRARY_PATH=$TET_TARGET_PATH/lib/tet3:$LD_LIBRARY_PATH
-export TET_ROOT=$TET_TARGET_PATH
diff --git a/wearable/TC/build.sh b/wearable/TC/build.sh
deleted file mode 100755
index 72aad6c..0000000
--- a/wearable/TC/build.sh
+++ /dev/null
@@ -1,16 +0,0 @@
-#!/bin/sh
-
-. ./_export_env.sh                              # setting environment variables
-
-export TET_SUITE_ROOT=`pwd`
-FILE_NAME_EXTENSION=`date +%s`
-
-RESULT_DIR=results
-HTML_RESULT=$RESULT_DIR/build-tar-result-$FILE_NAME_EXTENSION.html
-JOURNAL_RESULT=$RESULT_DIR/build-tar-result-$FILE_NAME_EXTENSION.journal
-
-mkdir -p $RESULT_DIR
-
-tcc -c -p ./
-tcc -b -j $JOURNAL_RESULT -p ./
-grw -c 7 -f chtml -o $HTML_RESULT $JOURNAL_RESULT
diff --git a/wearable/TC/clean.sh b/wearable/TC/clean.sh
deleted file mode 100755
index 29743e0..0000000
--- a/wearable/TC/clean.sh
+++ /dev/null
@@ -1,11 +0,0 @@
-#!/bin/sh
-
-. ./_export_env.sh                              # setting environment variables
-
-export TET_SUITE_ROOT=`pwd`
-RESULT_DIR=results
-
-tcc -c -p ./                                # executing tcc, with clean option (-c)
-rm -r $RESULT_DIR
-rm -r tet_tmp_dir
-rm testcase/tet_captured
diff --git a/wearable/TC/config b/wearable/TC/config
deleted file mode 100644
index f919537..0000000
--- a/wearable/TC/config
+++ /dev/null
@@ -1,2 +0,0 @@
-TET_INSTALL_HOST_PATH=/home/bwlee/tools/TETware
-TET_INSTALL_TARGET_PATH=/home/bwlee/tools/TETware
diff --git a/wearable/TC/testcase/Makefile b/wearable/TC/testcase/Makefile
deleted file mode 100644
index 7d86802..0000000
--- a/wearable/TC/testcase/Makefile
+++ /dev/null
@@ -1,24 +0,0 @@
-CC ?= gcc
-
-C_FILES = $(shell ls *.c)
-	
-PKGS = capi-network-bluetooth glib-2.0
-
-LDFLAGS = `pkg-config --libs $(PKGS)`
-LDFLAGS += $(TET_ROOT)/lib/tet3/tcm_s.o
-LDFLAGS += -L$(TET_ROOT)/lib/tet3 -ltcm_s
-LDFLAGS += -L$(TET_ROOT)/lib/tet3 -lapi_s
-
-CFLAGS = -I. `pkg-config --cflags $(PKGS)`
-CFLAGS += -I$(TET_ROOT)/inc/tet3
-CFLAGS += -Wall
-
-TCS := $(shell ls -1 *.c | cut -d. -f1)
-
-all: $(TCS)
-
-%: %.c
-	$(CC) -o $@ $< $(CFLAGS) $(LDFLAGS)
-
-clean:
-	rm -f $(TCS)
diff --git a/wearable/TC/testcase/tslist b/wearable/TC/testcase/tslist
deleted file mode 100644
index f622ae2..0000000
--- a/wearable/TC/testcase/tslist
+++ /dev/null
@@ -1,11 +0,0 @@
-/testcase/utc_network_bluetooth_adapter_positive
-/testcase/utc_network_bluetooth_adapter_negative
-/testcase/utc_network_bluetooth_device_discovery_positive
-/testcase/utc_network_bluetooth_device_discovery_negative
-/testcase/utc_network_bluetooth_device_positive
-/testcase/utc_network_bluetooth_device_negative
-/testcase/utc_network_bluetooth_service_search_positive
-/testcase/utc_network_bluetooth_service_search_negative
-/testcase/utc_network_bluetooth_socket_positive
-/testcase/utc_network_bluetooth_socket_negative
-
diff --git a/wearable/TC/testcase/utc_network_bluetooth_adapter_negative.c b/wearable/TC/testcase/utc_network_bluetooth_adapter_negative.c
deleted file mode 100644
index d2d8e84..0000000
--- a/wearable/TC/testcase/utc_network_bluetooth_adapter_negative.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 <tet_api.h>
-#include <bluetooth.h>
-#include <stdlib.h>
-#include <stdbool.h>
-#include <glib.h>
-#include <time.h>
-
-enum {
-	POSITIVE_TC_IDX = 0x01,
-	NEGATIVE_TC_IDX,
-};
-
-static void startup(void);
-static void cleanup(void);
-bt_adapter_visibility_mode_e adapter_visibility_mode = BT_ADAPTER_VISIBILITY_MODE_LIMITED_DISCOVERABLE;
-char adapter_name[128] = "dts_test";
-
-void (*tet_startup)(void) = startup;
-void (*tet_cleanup)(void) = cleanup;
-
-
-static void utc_network_bluetooth_deinitialize_n(void);
-static void utc_network_bluetooth_adapter_set_state_changed_cb_n(void);
-static void utc_network_bluetooth_adapter_set_name_changed_cb_n(void);
-static void utc_network_bluetooth_adapter_set_visibility_mode_changed_cb_n(void);
-static void utc_network_bluetooth_adapter_enable_n(void);
-static void utc_network_bluetooth_adapter_get_state_n(void);
-static void utc_network_bluetooth_adapter_get_address_n(void);
-static void utc_network_bluetooth_adapter_set_name_n(void);
-static void utc_network_bluetooth_adapter_get_name_n(void);
-static void utc_network_bluetooth_adapter_set_visibility_n(void);
-static void utc_network_bluetooth_adapter_get_visibility_n(void);
-static void utc_network_bluetooth_adapter_disable_n(void);
-static void utc_network_bluetooth_adapter_unset_state_changed_cb_n(void);
-static void utc_network_bluetooth_adapter_unset_name_changed_cb_n(void);
-static void utc_network_bluetooth_adapter_unset_visibility_mode_changed_cb_n(void);
-
-void adapter_state_changed_cb_for_adapter_n(int result, bt_adapter_state_e adapter_state, void* user_data);
-void adapter_state_changed_cb_for_adapter_n(int result, bt_adapter_state_e adapter_state, void* user_data);
-void adapter_name_changed_cb_for_adapter_n(char* device_name, void* user_data);
-void adapter_visibility_mode_changed_cb_for_adpater_n(int result, bt_adapter_visibility_mode_e visibility_mode, void* user_data);
-void device_discovery_state_changed_cb_for_adapter_n(int result, \
-        bt_adapter_device_discovery_state_e discovery_state, bt_device_info_s *device_info, void* user_data);
-gboolean timeout_func(gpointer data);
-
-
-struct tet_testlist tet_testlist[] = {
-	{ utc_network_bluetooth_adapter_disable_n, NEGATIVE_TC_IDX },      
-	{ utc_network_bluetooth_adapter_set_state_changed_cb_n, NEGATIVE_TC_IDX },                        
-	{ utc_network_bluetooth_adapter_set_name_changed_cb_n, NEGATIVE_TC_IDX },                                        
-	{ utc_network_bluetooth_adapter_set_visibility_mode_changed_cb_n, NEGATIVE_TC_IDX },                        	
-	{ utc_network_bluetooth_adapter_get_state_n, NEGATIVE_TC_IDX },                        	
-	{ utc_network_bluetooth_adapter_get_address_n, NEGATIVE_TC_IDX },                        	
-	{ utc_network_bluetooth_adapter_set_name_n, NEGATIVE_TC_IDX },                        	
-	{ utc_network_bluetooth_adapter_get_name_n, NEGATIVE_TC_IDX },                        	
-	{ utc_network_bluetooth_adapter_get_visibility_n, NEGATIVE_TC_IDX },                        	
-	{ utc_network_bluetooth_adapter_set_visibility_n, NEGATIVE_TC_IDX },                        	
-	{ utc_network_bluetooth_deinitialize_n, NEGATIVE_TC_IDX },   				
-	{ utc_network_bluetooth_adapter_enable_n, NEGATIVE_TC_IDX },  
-	{ utc_network_bluetooth_adapter_unset_state_changed_cb_n, NEGATIVE_TC_IDX },                        	
-	{ utc_network_bluetooth_adapter_unset_name_changed_cb_n, NEGATIVE_TC_IDX },                        	
-	{ utc_network_bluetooth_adapter_unset_visibility_mode_changed_cb_n, NEGATIVE_TC_IDX },      		
-	{ NULL, 0 },
-};
-
-static void startup(void)
-{
-	/* start of TC */
-	tet_printf("TC start.");
-	bt_initialize();
-}
-
-static void cleanup(void)
-{
-	/* end of TC */
-	tet_printf("TC end");
-}
-
-
-/**
- * @brief Negative test case of bt_deinitialize()
- */
-static void utc_network_bluetooth_deinitialize_n(void)
-{
-	int ret = bt_deinitialize();
-
-	if( ret == BT_ERROR_NONE )
-	{
-		ret = bt_deinitialize();	
-		dts_check_eq("bt_deinitialize", ret, BT_ERROR_NOT_INITIALIZED, "BT_ERROR_NOT_INITIALIZED must be returned.");
-	}
-	else
-	{
-		dts_fail("bt_deinitialize", "bt_deinitialize() failed.");
-	}
-}
-
-
-/**
- * @brief Negative test case of bt_adapter_disable()
- */
-static void utc_network_bluetooth_adapter_disable_n(void)
-{
-	int ret = BT_ERROR_NONE;
-        
-	ret = bt_adapter_disable();
-	dts_check_eq("bt_adapter_disable", ret, BT_ERROR_NOT_ENABLED, 
-		"BT_ERROR_NOT_ENABLED must be returned when BT is disabled");
-}
-
-/**
- * @brief Negative test case of bt_adapter_set_state_changed_cb()
- */
-static void utc_network_bluetooth_adapter_set_state_changed_cb_n(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_adapter_set_state_changed_cb(NULL, NULL);
-        dts_check_eq("bt_adapter_set_state_changed_cb", ret, BT_ERROR_INVALID_PARAMETER, \
-                "BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL.");
-}
-
-/**
- * @brief Negative test case of bt_adapter_set_name_changed_cb()
- */
-static void utc_network_bluetooth_adapter_set_name_changed_cb_n(void)
-{
-	int ret = BT_ERROR_NONE;
-        
-	ret = bt_adapter_set_name_changed_cb(NULL, NULL);
-        dts_check_eq("bt_adapter_set_name_changed_cb", ret, BT_ERROR_INVALID_PARAMETER, \
-                "BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL.");
-}
-
-/**
- * @brief Negative test case of bt_adapter_set_visibility_mode_changed_cb()
- */
-static void utc_network_bluetooth_adapter_set_visibility_mode_changed_cb_n(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_adapter_set_visibility_mode_changed_cb(NULL, NULL);
-        dts_check_eq("bt_adapter_set_visibility_mode_changed_cb", ret, BT_ERROR_INVALID_PARAMETER, \
-                "BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL.");
-}
-
-/**
- * @brief Negative test case of bt_adapter_get_state()
- */
-static void utc_network_bluetooth_adapter_get_state_n(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_adapter_get_state(NULL);
-        dts_check_eq("bt_adapter_get_state", ret, BT_ERROR_INVALID_PARAMETER, \
-                "BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL.");
-}
-
-/**
- * @brief Negative test case of bt_adapter_get_address().
- */
-static void utc_network_bluetooth_adapter_get_address_n(void)
-{
-        char* address = NULL;
-        int ret = bt_adapter_get_address(&address);
-
-        dts_check_eq("bt_adapter_get_address", ret, BT_ERROR_NOT_ENABLED, \
-                "BT_ERROR_NOT_ENABLED must be returned when BT is not enabled.");
-}
-
-/**
- * @brief Negative test case of bt_adapter_get_name().
- */
-static void utc_network_bluetooth_adapter_get_name_n(void)
-{
-        char* name = NULL;
-        int ret = bt_adapter_get_name(&name);
-
-        dts_check_eq("bt_adapter_get_name", ret, BT_ERROR_NOT_ENABLED, \
-                "BT_ERROR_NOT_ENABLED must be returned when BT is not enabled.");
-}
-
-/**
- * @brief Negative test case of bt_adapter_get_visibility().
- */
-static void utc_network_bluetooth_adapter_get_visibility_n(void)
-{
-        bt_adapter_visibility_mode_e mode = BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE;
-        int ret = bt_adapter_get_visibility(&mode);
-
-        dts_check_eq("bt_adapter_get_visibility", ret, BT_ERROR_NOT_ENABLED, \
-                "BT_ERROR_NOT_ENABLED must be returned when BT is not enabled.");
-}
-
-/**
- * @brief Negative test case of bt_adapter_set_name().
- */
-static void utc_network_bluetooth_adapter_set_name_n(void)
-{
-        int ret = bt_adapter_set_name(adapter_name);
-
-        dts_check_eq("bt_adapter_set_name", ret, BT_ERROR_NOT_ENABLED, \
-                "BT_ERROR_NOT_ENABLED must be returned when BT is not enabled.");
-}
-
-/**
- * @brief Negative test case of bt_adapter_set_visibility().
- */
-static void utc_network_bluetooth_adapter_set_visibility_n(void)
-{
-        int ret = bt_adapter_set_visibility(adapter_visibility_mode, 180);
-
-        dts_check_eq("bt_adapter_set_visibility", ret, BT_ERROR_NOT_ENABLED, \
-                "BT_ERROR_NOT_ENABLED must be returned when BT is not enabled.");
-}
-
-
-/**
- * @brief Negative test case of bt_adapter_unset_state_changed_cb()
- */
-static void utc_network_bluetooth_adapter_unset_state_changed_cb_n(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_adapter_unset_state_changed_cb();
-        dts_check_eq("bt_adapter_unset_state_changed_cb", ret, BT_ERROR_NOT_INITIALIZED, \
-                "BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized.");
-}
-
-/**
- * @brief Negative test case of bt_adapter_unset_name_changed_cb()
- */
-static void utc_network_bluetooth_adapter_unset_name_changed_cb_n(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_adapter_unset_name_changed_cb();
-        dts_check_eq("bt_adapter_unset_name_changed_cb", ret, BT_ERROR_NOT_INITIALIZED, \
-                "BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized.");
-}
-
-/**
- * @brief Negative test case of bt_adapter_unset_visibility_mode_changed_cb()
- */
-static void utc_network_bluetooth_adapter_unset_visibility_mode_changed_cb_n(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_adapter_unset_visibility_mode_changed_cb();
-        dts_check_eq("bt_adapter_unset_visibility_mode_changed_cb", ret, BT_ERROR_NOT_INITIALIZED, \
-                "BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized.");
-}
-
-/**
- * @brief Negative test case of bt_adapter_enable()
- */
-static void utc_network_bluetooth_adapter_enable_n(void)
-{
-	bt_error_e ret = bt_adapter_enable();
-	dts_check_eq("bt_adapter_enable", ret, BT_ERROR_NOT_INITIALIZED, \
-		"BT_ERROR_NOT_INITIALIZED must be returned.");
-}
-
diff --git a/wearable/TC/testcase/utc_network_bluetooth_adapter_positive.c b/wearable/TC/testcase/utc_network_bluetooth_adapter_positive.c
deleted file mode 100644
index d608b14..0000000
--- a/wearable/TC/testcase/utc_network_bluetooth_adapter_positive.c
+++ /dev/null
@@ -1,519 +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 <tet_api.h>
-#include <bluetooth.h>
-#include <stdlib.h>
-#include <stdbool.h>
-#include <glib.h>
-#include <time.h>
-
-enum {
-	POSITIVE_TC_IDX = 0x01,
-	NEGATIVE_TC_IDX,
-};
-
-static void startup(void);
-static void cleanup(void);
-static GMainLoop* mainloop;
-static bool callback_result = false;
-bt_adapter_visibility_mode_e adapter_visibility_mode = BT_ADAPTER_VISIBILITY_MODE_LIMITED_DISCOVERABLE;
-char adapter_name[128] = "dts_test";
-
-void (*tet_startup)(void) = startup;
-void (*tet_cleanup)(void) = cleanup;
-
-static void utc_network_bluetooth_initialize_p(void);
-static void utc_network_bluetooth_deinitialize_p(void);
-static void utc_network_bluetooth_adapter_set_state_changed_cb_p(void);
-static void utc_network_bluetooth_adapter_set_name_changed_cb_p(void);
-static void utc_network_bluetooth_adapter_set_visibility_mode_changed_cb_p(void);
-static void utc_network_bluetooth_adapter_enable_p(void);
-static void utc_network_bluetooth_adapter_get_state_p(void);
-static void utc_network_bluetooth_adapter_get_address_p(void);
-static void utc_network_bluetooth_adapter_set_name_p(void);
-static void utc_network_bluetooth_adapter_get_name_p(void);
-static void utc_network_bluetooth_adapter_set_visibility_p(void);
-static void utc_network_bluetooth_adapter_get_visibility_p(void);
-static void utc_network_bluetooth_adapter_disable_p(void);
-static void utc_network_bluetooth_adapter_unset_state_changed_cb_p(void);
-static void utc_network_bluetooth_adapter_unset_name_changed_cb_p(void);
-static void utc_network_bluetooth_adapter_unset_visibility_mode_changed_cb_p(void);
-
-void adapter_state_changed_cb_for_adapter_p(int result, bt_adapter_state_e adapter_state, void* user_data);
-void adapter_state_changed_cb_for_adapter_p(int result, bt_adapter_state_e adapter_state, void* user_data);
-void adapter_name_changed_cb_for_adapter_p(char* device_name, void* user_data);
-void adapter_visibility_mode_changed_cb_for_adpater_p(int result, bt_adapter_visibility_mode_e visibility_mode, void* user_data);
-void device_discovery_state_changed_cb_for_adapter_p(int result, \
-		bt_adapter_device_discovery_state_e discovery_state, bt_device_info_s *device_info, void* user_data);
-gboolean timeout_func(gpointer data);
-
-
-struct tet_testlist tet_testlist[] = {
-	{ utc_network_bluetooth_initialize_p, POSITIVE_TC_IDX },	
-	{ utc_network_bluetooth_adapter_enable_p, POSITIVE_TC_IDX },
-	{ utc_network_bluetooth_adapter_set_state_changed_cb_p, POSITIVE_TC_IDX },     
-	{ utc_network_bluetooth_adapter_unset_state_changed_cb_p, POSITIVE_TC_IDX },                        			
-	{ utc_network_bluetooth_adapter_get_state_p, POSITIVE_TC_IDX },                        	
-	{ utc_network_bluetooth_adapter_get_address_p, POSITIVE_TC_IDX },                       
-	{ utc_network_bluetooth_adapter_get_name_p, POSITIVE_TC_IDX },                        			
-	{ utc_network_bluetooth_adapter_set_name_changed_cb_p, POSITIVE_TC_IDX },     				
-	{ utc_network_bluetooth_adapter_unset_name_changed_cb_p, POSITIVE_TC_IDX },                        			
-	{ utc_network_bluetooth_adapter_set_name_p, POSITIVE_TC_IDX },                        			
-	{ utc_network_bluetooth_adapter_set_visibility_mode_changed_cb_p, POSITIVE_TC_IDX },                        			
-	{ utc_network_bluetooth_adapter_unset_visibility_mode_changed_cb_p, POSITIVE_TC_IDX },                        	
-	{ utc_network_bluetooth_adapter_get_visibility_p, POSITIVE_TC_IDX },                        	
-	{ utc_network_bluetooth_adapter_set_visibility_p, POSITIVE_TC_IDX },                        	
-	{ utc_network_bluetooth_adapter_disable_p, POSITIVE_TC_IDX },    
-	{ utc_network_bluetooth_deinitialize_p, POSITIVE_TC_IDX },				
-	{ NULL, 0 },
-};
-
-static void startup(void)
-{
-	/* start of TC */
-	tet_printf("TC start.");
-	mainloop = g_main_loop_new(NULL, FALSE);       	
-}
-
-static void cleanup(void)
-{
-	/* end of TC */
-	tet_printf("TC end");
-}
-
-gboolean timeout_func(gpointer data)
-{
-	tet_printf("Callback: Timeout.");
-	g_main_loop_quit((GMainLoop*)data);
-	return FALSE;
-}
-
-
-/**
- * @brief Callback funtions
- */
-void adapter_state_changed_cb_for_adapter_p(int result, bt_adapter_state_e adapter_state, void* user_data)
-{
-	if( user_data != NULL ) 
-	{               
-		if( !strcmp((char*)user_data, "enable") )
-		{
-			if( adapter_state == BT_ADAPTER_ENABLED && result == BT_ERROR_NONE )
-			{
-				tet_printf("Callback: BT was enabled.");
-				callback_result = true;
-			} 
-			else
-			{
-				tet_printf("Callback: BT was not enabled.");
-			}						
-
-			if(mainloop)
-				g_main_loop_quit(mainloop);        						
-		}
-		else if( !strcmp((char*)user_data, "disable") )
-		{
-			if( adapter_state == BT_ADAPTER_DISABLED && result == BT_ERROR_NONE )
-			{
-				tet_printf("Callback: BT was disabled.");
-				callback_result = true;
-			} 
-			else
-			{
-				tet_printf("Callback: BT was not disabled.");
-			}
-
-			if( mainloop )
-			{
-				g_main_loop_quit(mainloop);                                
-			}                                                
-		}
-	}
-}
-
-void device_discovery_state_changed_cb_for_adapter_p(int result, \
-		bt_adapter_device_discovery_state_e discovery_state, bt_device_info_s *device_info, void* user_data)
-{        
-	tet_printf("bt_adapter_device_discovery_state_changed_cb was called");
-	if( (user_data != NULL) && (!strcmp((char*)user_data, "enable")) )
-	{
-		if( discovery_state == BT_ADAPTER_DEVICE_DISCOVERY_FINISHED )
-		{
-			tet_printf("Callback: bt_adapter_device_discovery_state_changed_cb_for_adapter_p was called \
-					and device discovery ends.");
-			if(mainloop) 
-			{
-				g_main_loop_quit(mainloop);                              
-			}
-		}
-	}
-}
-
-void adapter_name_changed_cb_for_adapter_p(char *device_name, void* user_data)
-{
-	tet_printf("bt_adapter_name_changed_cb_for_adapter_p was called: %s", (char *)device_name);
-
-	if( (user_data != NULL) && (!strcmp((char*)user_data, "set_name")) )
-	{
-		if( !strcmp(device_name, adapter_name) )
-			callback_result = true;
-	}
-
-	if(mainloop)
-		g_main_loop_quit(mainloop);        
-	
-}
-
-void adapter_visibility_mode_changed_cb_for_adpater_p(int result, bt_adapter_visibility_mode_e visibility_mode, void* user_data)
-{
-	tet_printf("bt_adapter_visibility_mode_changed_cb was called: %d", visibility_mode);
-
-	if( (user_data != NULL) && (!strcmp((char*)user_data, "set_visibility")) )
-	{
-		if( result == BT_ERROR_NONE )
-		{
-			if( visibility_mode == adapter_visibility_mode )
-			{
-				callback_result = true;
-			}
-			else
-			{
-				tet_printf("Callback: adapter_visibility_mode_changed_cb_for_adpater_p() was called but visibility mode is not same.");
-				tet_printf("Callback: actual visibility mode : %d", visibility_mode);
-				callback_result = false;
-			}
-		}
-		else
-		{
-			tet_printf("\n Callback: adapter_visibility_mode_changed_cb_for_adpater_p() was called but failed.");
-			callback_result = false;
-		}
-	}
-
-	if(mainloop)
-		g_main_loop_quit(mainloop);        
-}
-
-
-/**
- * @brief Positive test case of bt_initialize()
- */
-static void utc_network_bluetooth_initialize_p(void)
-{
-	int ret = bt_initialize();
-	dts_check_eq("bt_initialize", ret, BT_ERROR_NONE, "bt_initialize() failed.");
-}
-
-/**
- * @brief Positive test case of bt_deinitialize()
- */
-static void utc_network_bluetooth_deinitialize_p(void)
-{
-	int ret = bt_deinitialize();
-	dts_check_eq("bt_deinitialize", ret, BT_ERROR_NONE, "bt_deinitialize() failed.");
-}
-
-/**
- * @brief Positive test case of bt_adapter_set_state_changed_cb()
- */
-static void utc_network_bluetooth_adapter_set_state_changed_cb_p(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_adapter_p, NULL);
-	dts_check_eq("bt_adapter_set_state_changed_cb", ret, BT_ERROR_NONE, "bt_adapter_set_state_changed_cb failed.");
-}
-
-/**
- * @brief Positive test case of bt_adapter_set_name_changed_cb()
- */
-static void utc_network_bluetooth_adapter_set_name_changed_cb_p(void)
-{
-	int ret = BT_ERROR_NONE;
-	int timeout_id = 0;
-	
-	ret = bt_adapter_set_name_changed_cb(adapter_name_changed_cb_for_adapter_p, NULL);
-	if( ret == BT_ERROR_NONE )
-	{
-		timeout_id = g_timeout_add(10000, timeout_func, mainloop);
-		g_main_loop_run(mainloop); 
-		g_source_remove(timeout_id);
-	}	
-	dts_check_eq("bt_adapter_set_name_changed_cb", ret, BT_ERROR_NONE, 
-		"bt_adapter_set_name_changed_cb failed.");
-}
-
-/**
- * @brief Positive test case of bt_adapter_set_visibility_mode_changed_cb()
- */
-static void utc_network_bluetooth_adapter_set_visibility_mode_changed_cb_p(void)
-{
-	int ret = BT_ERROR_NONE;
-	int timeout_id = 0;	
-
-	ret = bt_adapter_set_visibility_mode_changed_cb(adapter_visibility_mode_changed_cb_for_adpater_p, NULL);
-	if( ret == BT_ERROR_NONE )
-	{
-		timeout_id = g_timeout_add(10000, timeout_func, mainloop);
-		g_main_loop_run(mainloop); 
-		g_source_remove(timeout_id);
-	}
-	dts_check_eq("bt_adapter_set_visibility_mode_changed_cb", ret, BT_ERROR_NONE, 
-		"bt_adapter_set_visibility_mode_changed_cb failed.");
-}
-
-/**
- * @brief Positive test case of bt_adapter_enable()
- */
-static void utc_network_bluetooth_adapter_enable_p(void)
-{
-	int timeout_id = 0;
-	callback_result = false;
-	bt_error_e ret = BT_ERROR_NONE;
-
-	if( bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_adapter_p, "enable") != BT_ERROR_NONE )
-	{
-		dts_fail("bt_adapter_enable", "bt_adapter_set_state_changed_cb() failed.");
-	}                
-
-	ret = bt_adapter_enable();
-	if( ret == BT_ERROR_NONE )
-	{
-		timeout_id = g_timeout_add(60000, timeout_func, mainloop);
-		g_main_loop_run(mainloop); 
-		g_source_remove(timeout_id);
-	}
-	else
-	{
-		dts_fail("bt_adapter_enable", "bt_adapter_enable() failed.");
-	}     
-
-	tet_printf("callback_result: %d", callback_result);
-	bt_adapter_unset_state_changed_cb();
-	dts_check_eq("bt_adapter_enable", callback_result, true, "BT was not enabled.");
-}
-
-/**
- * @brief Positive test case of bt_adapter_get_state()
- */
-static void utc_network_bluetooth_adapter_get_state_p(void)
-{
-	bt_adapter_state_e adapter_state = BT_ADAPTER_DISABLED;
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_adapter_get_state(&adapter_state);
-	if( ret == BT_ERROR_NONE && adapter_state == BT_ADAPTER_ENABLED )
-	{
-		dts_pass("bt_adapter_get_state", "bt_adapter_get_state() succeeded.");                
-	}
-	else
-	{
-		dts_fail("bt_adapter_get_state", "bt_adapter_get_state() failed.");                
-	}
-}
-
-/**
- * @brief Positive test case of bt_adapter_get_address().
- */
-static void utc_network_bluetooth_adapter_get_address_p(void)
-{
-	char* address = NULL;
-	int ret = bt_adapter_get_address(&address);
-
-	if(address != NULL)
-		tet_printf("device address: %s", address);
-
-	dts_check_eq("bt_adapter_get_address", ret, BT_ERROR_NONE, \
-			"bt_adapter_get_address() failed.");
-}
-
-/**
- * @brief Positive test case of bt_adapter_get_name().
- */
-static void utc_network_bluetooth_adapter_get_name_p(void)
-{
-	char* name = NULL;
-	int ret = bt_adapter_get_name(&name);
-
-	if(name != NULL)
-		tet_printf("device name : %s", name);
-
-	memset(adapter_name, 0x00, sizeof(adapter_name));
-	g_strlcpy(adapter_name, name, sizeof(adapter_name));
-
-	dts_check_eq("bt_adapter_get_name", ret, BT_ERROR_NONE, \
-			"bt_adapter_get_name() failed.");
-}
-
-/**
- * @brief Positive test case of bt_adapter_get_visibility().
- */
-static void utc_network_bluetooth_adapter_get_visibility_p(void)
-{
-	bt_adapter_visibility_mode_e mode = BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE;
-	int ret = bt_adapter_get_visibility(&mode);
-
-	tet_printf("visibility mode : %d", mode);
-	if ( mode == BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE )
-	{
-		adapter_visibility_mode = BT_ADAPTER_VISIBILITY_MODE_LIMITED_DISCOVERABLE;
-	}
-	else if( mode == BT_ADAPTER_VISIBILITY_MODE_GENERAL_DISCOVERABLE )
-	{
-		adapter_visibility_mode = BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE;
-	}
-	else
-		adapter_visibility_mode = BT_ADAPTER_VISIBILITY_MODE_GENERAL_DISCOVERABLE;
-
-	dts_check_eq("bt_adapter_get_visibility", ret, BT_ERROR_NONE, \
-			"bt_adapter_get_visibility() failed.");
-}
-
-/**
- * @brief Positive test case of bt_adapter_set_name().
- */
-static void utc_network_bluetooth_adapter_set_name_p(void)
-{
-	int timeout_id = 0;
-	char name[128] = "";
-
-	snprintf(name, 128, "%s_1", adapter_name);
-	strncpy(adapter_name, name, 128);	
-
-	if( bt_adapter_set_name_changed_cb(adapter_name_changed_cb_for_adapter_p, "set_name") != BT_ERROR_NONE )
-	{
-		dts_fail("bt_adapter_set_name", "bt_adapter_set_name_changed_cb() failed.");
-	}
-
-	if( bt_adapter_set_name(adapter_name) == BT_ERROR_NONE )
-	{
-		tet_printf("adapter_name_changed_cb_for_adapter_p() will be called");
-		timeout_id = g_timeout_add (60000, timeout_func, mainloop);
-		g_main_loop_run(mainloop);
-		g_source_remove(timeout_id);
-		bt_adapter_unset_name_changed_cb();
-		dts_check_eq("bt_adapter_set_name", callback_result, true, "The local adapter name was not set.");
-	}
-	else
-	{
-		dts_fail("bt_adapter_set_name", "bt_adapter_set_name() failed");
-	} 	
-}
-
-/**
- * @brief Positive test case of bt_adapter_set_visibility().
- */
-static void utc_network_bluetooth_adapter_set_visibility_p(void)
-{
-	callback_result = false;
-	int timeout = 0;
-	int timeout_id = 0;
-
-	if( bt_adapter_set_visibility_mode_changed_cb(adapter_visibility_mode_changed_cb_for_adpater_p, 
-		"set_visibility") != BT_ERROR_NONE )
-	{
-		dts_fail("bt_adapter_set_visibility", "bt_adapter_set_visibility_mode_changed_cb() failed.");
-	}
-
-	tet_printf("set visibility mode: %d", adapter_visibility_mode);
-	if( adapter_visibility_mode == BT_ADAPTER_VISIBILITY_MODE_LIMITED_DISCOVERABLE )
-	{
-		timeout = 90;
-		tet_printf("set timeout: %d", timeout);
-	}
-
-	if( bt_adapter_set_visibility(adapter_visibility_mode, timeout) == BT_ERROR_NONE )
-	{                                
-		tet_printf("bt_adapter_visibility_changed_cb() will be called");
-		timeout_id = g_timeout_add (60000, timeout_func, mainloop);
-		g_main_loop_run(mainloop);
-		g_source_remove(timeout_id);
-		bt_adapter_unset_visibility_mode_changed_cb();
-		dts_check_eq("bt_adapter_set_visibility", callback_result, true, "The visibility of BT was not set.");
-	}
-	else
-	{
-		dts_fail("bt_adapter_set_visibility", "bt_adapter_set_visibility() failed");
-	} 
-}
-
-/**
- * @brief Positive test case of bt_adapter_disable()
- */
-static void utc_network_bluetooth_adapter_disable_p(void)
-{
-	callback_result = false;
-	int timeout_id = 0;	
-
-	if( bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_adapter_p, "disable") != BT_ERROR_NONE )
-	{
-		dts_fail("bt_adapter_disable", "bt_adapter_set_state_changed_cb() failed.");
-	}                
-
-	if( bt_adapter_disable() == BT_ERROR_NONE )
-	{                                
-		tet_printf("bt_adapter_state_changed_cb() will be called");
-		timeout_id = g_timeout_add (60000, timeout_func, mainloop);
-		g_main_loop_run(mainloop);
-		g_source_remove(timeout_id);
-		bt_adapter_unset_state_changed_cb();
-		dts_check_eq("bt_adapter_disable", callback_result, true, "BT was not disabled");
-	}
-	else
-	{
-		dts_fail("bt_adapter_disable", "bt_adapter_disable() failed");
-	} 
-}
-
-/**
- * @brief Positive test case of bt_adapter_unset_state_changed_cb()
- */
-static void utc_network_bluetooth_adapter_unset_state_changed_cb_p(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_adapter_unset_state_changed_cb();
-	dts_check_eq("bt_adapter_unset_state_changed_cb", ret, BT_ERROR_NONE, \
-			"bt_adapter_unset_state_changed_cb() failed.");
-}
-
-/**
- * @brief Positive test case of bt_adapter_unset_name_changed_cb()
- */
-static void utc_network_bluetooth_adapter_unset_name_changed_cb_p(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_adapter_unset_name_changed_cb();
-	dts_check_eq("bt_adapter_unset_name_changed_cb", ret, BT_ERROR_NONE, \
-			"bt_adapter_unset_name_changed_cb() failed.");
-}
-
-/**
- * @brief Positive test case of bt_adapter_unset_visibility_mode_changed_cb()
- */
-static void utc_network_bluetooth_adapter_unset_visibility_mode_changed_cb_p(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_adapter_unset_visibility_mode_changed_cb();
-	dts_check_eq("bt_adapter_unset_visibility_mode_changed_cb", ret, BT_ERROR_NONE, \
-			"bt_adapter_unset_visibility_mode_changed_cb() failed.");
-}
-
-
diff --git a/wearable/TC/testcase/utc_network_bluetooth_device_discovery_negative.c b/wearable/TC/testcase/utc_network_bluetooth_device_discovery_negative.c
deleted file mode 100644
index 36f2078..0000000
--- a/wearable/TC/testcase/utc_network_bluetooth_device_discovery_negative.c
+++ /dev/null
@@ -1,206 +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 <tet_api.h>
-#include <bluetooth.h>
-#include <stdlib.h>
-#include <stdbool.h>
-#include <glib.h>
-
-enum {
-	POSITIVE_TC_IDX = 0x01,
-	NEGATIVE_TC_IDX,
-};
-
-static GMainLoop* mainloop;
-gboolean timeout_func(gpointer data);
-
-static void startup(void);
-static void cleanup(void);
-
-void (*tet_startup)(void) = startup;
-void (*tet_cleanup)(void) = cleanup;
-
-static void utc_network_bluetooth_device_discovery_cancel_n(void);
-static void utc_network_bluetooth_device_discovery_unset_state_changed_cb_n(void);
-static void utc_network_bluetooth_device_discovery_set_state_changed_cb_n(void);
-static void utc_network_bluetooth_device_discovery_start_n(void);
-static void utc_network_bluetooth_device_discovery_get_status_n(void);
-
-void adapter_state_changed_cb_for_discovery_n(int result, bt_adapter_state_e adapter_state, void* user_data);
-
-struct tet_testlist tet_testlist[] = {
-	{ utc_network_bluetooth_device_discovery_cancel_n, NEGATIVE_TC_IDX },	
-	{ utc_network_bluetooth_device_discovery_set_state_changed_cb_n, NEGATIVE_TC_IDX },	
-	{ utc_network_bluetooth_device_discovery_get_status_n, NEGATIVE_TC_IDX },	
-	{ utc_network_bluetooth_device_discovery_start_n, NEGATIVE_TC_IDX },	
-	{ utc_network_bluetooth_device_discovery_unset_state_changed_cb_n, NEGATIVE_TC_IDX },			
-	{ NULL, 0 },
-};
-
-
-
-static void startup(void)
-{
-	int ret = BT_ERROR_NONE;
-	int timeout_id = 0;
-
-	/* start of TC */
-	mainloop = g_main_loop_new(NULL, FALSE);       
-
-	bt_initialize();
-	if( bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_discovery_n, "startup") != BT_ERROR_NONE )
-	{
-		tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed");
-	}                
-
-	tet_printf("bt_adapter_disable() was called.");
-	ret = bt_adapter_disable();
-	if( ret == BT_ERROR_NONE )
-	{
-		tet_printf("bt_adapter_disable() succeeded.");    
-		timeout_id = g_timeout_add (60000, timeout_func, mainloop);
-		g_main_loop_run(mainloop);	
-		g_source_remove(timeout_id);
-	}
-	else if( ret == BT_ERROR_NOT_ENABLED )
-	{
-		tet_printf("Bluetooth adapter is not enabled.");    
-	}
-	else
-	{
-		tet_printf("DTS may fail because bt_adapter_disable() failed");    
-	}     
-
-	if( bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE )
-	{
-		tet_printf("bt_adapter_set_state_changed_cb() failed.");
-	}        
-
-	tet_printf("TC start");	
-}
-
-
-static void cleanup(void)
-{
-	/* end of TC */
-	bt_deinitialize();
-	tet_printf("TC end");
-}
-
-gboolean timeout_func(gpointer data)
-{
-	tet_printf("Callback: Timeout.");
-	g_main_loop_quit((GMainLoop*)data);
-	return FALSE;
-}
-
-
-/**
- * @brief Callback funtions
- */
-void adapter_state_changed_cb_for_discovery_n(int result, bt_adapter_state_e adapter_state, void* user_data)
-{
-	tet_printf("Callback: bt_adapter_state_changed_cb was called.");
-	if( (user_data != NULL) && !strcmp((char*)user_data, "startup") )
-	{
-		if( adapter_state == BT_ADAPTER_DISABLED && result == BT_ERROR_NONE )
-		{
-			tet_printf("Callback: BT was disabled. DTS will be started.");
-		} 
-		else
-		{
-			tet_printf("Callback: BT was not disabled. DTS will be started but DTS may fail.");
-		}
-
-		if( mainloop )
-		{
-			g_main_loop_quit(mainloop);                                
-		}                
-	}
-}
-
-
-/**
- * @brief Negative test case of bt_adapter_stop_device_discovery()
- */
-static void utc_network_bluetooth_device_discovery_cancel_n(void)
-{
-	int ret = bt_adapter_stop_device_discovery();
-
-	dts_check_eq("bt_adapter_stop_device_discovery", ret, BT_ERROR_NOT_ENABLED, 
-			"BT_ERROR_NOT_ENABLED must be returned when BT is not enabled");                
-}
-
-
-/**
- * @brief Negative test case of bt_adapter_unset_device_discovery_state_changed_cb()
- */
-static void utc_network_bluetooth_device_discovery_unset_state_changed_cb_n(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	if( bt_deinitialize() != BT_ERROR_NONE )
-	{
-		dts_fail("bt_adapter_unset_device_discovery_state_changed_cb", "bt_deinitialize() failed.");
-	}
-	ret = bt_adapter_unset_device_discovery_state_changed_cb();
-	dts_check_eq("bt_adapter_unset_device_discovery_state_changed_cb", ret, BT_ERROR_NOT_INITIALIZED, 
-                "BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized.");
-}
-
-
-/**
- * @brief Negative test case of bt_adapter_set_device_discovery_state_changed_cb()
- */
-static void utc_network_bluetooth_device_discovery_set_state_changed_cb_n(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_adapter_set_device_discovery_state_changed_cb(NULL, NULL);
-	dts_check_eq("bt_adapter_set_device_discovery_state_changed_cb", ret, BT_ERROR_INVALID_PARAMETER, 
-			"BT_ERROR_INVALID_PARAMETER must be returned when callback parameter is NULL");
-}
-
-
-/**
- * @brief Negative test case of bt_adapter_start_device_discovery()
- */
-static void utc_network_bluetooth_device_discovery_start_n(void)
-{
-	bt_error_e ret = BT_ERROR_NONE;
-
-	ret = bt_adapter_start_device_discovery();;
-	dts_check_eq("bt_adapter_start_device_discovery", ret, BT_ERROR_NOT_ENABLED, 
-			"BT_ERROR_NOT_ENABLED must be returned when BT is not enabled");    
-}
-
-
-/**
- * @brief Negative test case of bt_adapter_is_discovering()
- */
-static void utc_network_bluetooth_device_discovery_get_status_n(void)
-{
-	bt_error_e ret = BT_ERROR_NONE;
-	bool status = false;
-
-	ret = bt_adapter_is_discovering(&status);
-	dts_check_eq("bt_adapter_is_discovering", ret, BT_ERROR_NOT_ENABLED, 
-			"BT_ERROR_NOT_ENABLED must be returned when BT is not enabled");                
-}
-
-
diff --git a/wearable/TC/testcase/utc_network_bluetooth_device_discovery_positive.c b/wearable/TC/testcase/utc_network_bluetooth_device_discovery_positive.c
deleted file mode 100644
index dc65d71..0000000
--- a/wearable/TC/testcase/utc_network_bluetooth_device_discovery_positive.c
+++ /dev/null
@@ -1,285 +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 <tet_api.h>
-#include <bluetooth.h>
-#include <stdlib.h>
-#include <stdbool.h>
-#include <glib.h>
-
-enum {
-	POSITIVE_TC_IDX = 0x01,
-	NEGATIVE_TC_IDX,
-};
-
-static GMainLoop* mainloop;
-static bool callback_result = false;
-
-static void startup(void);
-static void cleanup(void);
-
-void (*tet_startup)(void) = startup;
-void (*tet_cleanup)(void) = cleanup;
-
-static void utc_network_bluetooth_device_discovery_get_status_p(void);
-static void utc_network_bluetooth_device_discovery_set_state_changed_cb_p(void);
-static void utc_network_bluetooth_device_discovery_start_p(void);
-static void utc_network_bluetooth_device_discovery_unset_state_changed_cb_p(void);
-static void utc_network_bluetooth_device_discovery_cancel_p(void);
-
-
-gboolean timeout_func(gpointer data);
-void adapter_state_changed_cb_for_discovery_p(int result, bt_adapter_state_e adapter_state, void* user_data);
-void device_discovery_state_changed_cb_for_discovery_p(int result, bt_adapter_device_discovery_state_e discovery_state, 
-		bt_adapter_device_discovery_info_s *discovery_info, void* user_data);
-
-
-struct tet_testlist tet_testlist[] = {
-	{ utc_network_bluetooth_device_discovery_get_status_p, POSITIVE_TC_IDX },
-	{ utc_network_bluetooth_device_discovery_set_state_changed_cb_p, POSITIVE_TC_IDX },
-	{ utc_network_bluetooth_device_discovery_start_p, POSITIVE_TC_IDX },
-	{ utc_network_bluetooth_device_discovery_unset_state_changed_cb_p, POSITIVE_TC_IDX },
-	{ utc_network_bluetooth_device_discovery_cancel_p, POSITIVE_TC_IDX },
-	{ NULL, 0 },
-};
-
-
-
-static void startup(void)
-{
-	bt_error_e ret = BT_ERROR_NONE;
-	int timeout_id = 0;	
-
-	/* start of TC */
-	mainloop = g_main_loop_new(NULL, FALSE);       
-
-	bt_initialize();
-
-	if( bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_discovery_p, "startup") != BT_ERROR_NONE )
-	{
-		tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed.");
-	}                
-
-	ret = bt_adapter_enable();
-	if( ret == BT_ERROR_NONE )
-	{
-		tet_printf("bt_adapter_enable() succeeded.");    
-		timeout_id = g_timeout_add (60000, timeout_func, mainloop);
-		g_main_loop_run(mainloop);	
-		g_source_remove(timeout_id);
-	}
-	else if( ret == BT_ERROR_ALREADY_DONE )
-	{
-		tet_printf("BT was already enabled.");    
-	}
-	else
-	{
-		tet_printf("DTS may fail because bt_adapter_enable() failed.");    
-	}     
-
-	if( bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE )
-	{
-		tet_printf("bt_adapter_unset_device_discovery_state_changed_cb() failed.");
-	}          
-
-	tet_printf("TC start");	
-}
-
-
-static void cleanup(void)
-{
-	/* end of TC */
-	tet_printf("TC end");
-	bt_deinitialize();
-}
-
-
-gboolean timeout_func(gpointer data)
-{
-	tet_printf("Callback: Timeout.");
-	g_main_loop_quit((GMainLoop*)data);
-	return FALSE;
-}
-
-
-/**
- * @brief Callback funtions
- */
-void adapter_state_changed_cb_for_discovery_p(int result, bt_adapter_state_e adapter_state, void* user_data)
-{
-	if( (user_data != NULL) && !strcmp((char*)user_data, "startup") )
-	{
-		if( adapter_state == BT_ADAPTER_ENABLED && result == BT_ERROR_NONE )
-		{
-			tet_printf("Callback: BT was enabled.");
-		}
-		else
-		{
-			tet_printf("Callback: bt_adapter_state_changed_cb() was \
-					called but bt_adapter_enable() failed.");  
-		}     
-
-		if(mainloop)
-		{
-			g_main_loop_quit(mainloop);                                
-		}				
-	}
-}
-
-void device_discovery_state_changed_cb_for_discovery_p(int result, bt_adapter_device_discovery_state_e discovery_state, 
-		bt_adapter_device_discovery_info_s *discovery_info, void* user_data)
-{
-	tet_printf("Callback: device_discovery_state_changed_cb_for_discovery_p is called");
-	
-	if( discovery_state == BT_ADAPTER_DEVICE_DISCOVERY_FOUND )
-	{
-		tet_printf("Callback: Devices were found");
-		tet_printf("Callback: Device name is %s", discovery_info->remote_name);
-		tet_printf("Callback: Service class: %x", discovery_info->bt_class.major_service_class_mask);
-		if( (user_data != NULL) && !strcmp((char*)user_data, "start") )
-		{
-			callback_result = true;
-			if(mainloop)
-			{
-				g_main_loop_quit(mainloop);                                
-			}
-		}                
-	}        
-	else if( discovery_state == BT_ADAPTER_DEVICE_DISCOVERY_FINISHED )
-	{
-		tet_printf("Callback: Device discovery finished");
-		if( user_data != NULL )
-		{
-			if( (user_data != NULL) && !strcmp((char*)user_data, "start") && callback_result == false )
-			{
-				tet_printf("You need a discoverable device");
-				tet_printf("utc_network_bluetooth_device_discovery_start_p and \
-						utc_network_bluetooth_device_discovery_cancel_p will fail");                        
-			}                
-			else if( !strcmp((char*)user_data, "cancel") )
-			{
-				if( result == BT_ERROR_CANCELLED )
-				{
-					callback_result = true;
-				}
-			} 
-		}
-		if(mainloop)
-		{
-			g_main_loop_quit(mainloop);                                
-		}
-	}
-}
-
-/**
- * @brief Positive test case of bt_adapter_is_discovering()
- */
-static void utc_network_bluetooth_device_discovery_get_status_p(void)
-{
-	bt_error_e ret = BT_ERROR_NONE;
-	bool status = false;
-
-	ret = bt_adapter_is_discovering(&status);
-	dts_check_eq("bt_adapter_is_discovering", ret, BT_ERROR_NONE, 
-		"bt_adapter_is_discovering() failed."); 
-}
-
-/**
- * @brief Positive test case of bt_adapter_set_device_discovery_state_changed_cb()
- */
-static void utc_network_bluetooth_device_discovery_set_state_changed_cb_p(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_adapter_set_device_discovery_state_changed_cb
-		(device_discovery_state_changed_cb_for_discovery_p, "start");
-	dts_check_eq("bt_adapter_set_device_discovery_state_changed_cb", ret, 
-		BT_ERROR_NONE, "bt_adapter_set_device_discovery_state_changed_cb() failed.");
-}
-
-/**
- * @brief Positive test case of bt_adapter_start_device_discovery()
- */
-static void utc_network_bluetooth_device_discovery_start_p(void)
-{
-	int ret = BT_ERROR_NONE;
-	int timeout_id = 0;	
-
-	callback_result = false;
-
-	ret = bt_adapter_start_device_discovery();
-	if( ret == BT_ERROR_NONE )
-	{       
-		tet_printf("bt_adapter_device_discovery_state_changed_cb_for_discovery_p() will be called.");   
-		timeout_id = g_timeout_add (60000, timeout_func, mainloop);
-		g_main_loop_run(mainloop);	
-		g_source_remove(timeout_id);
-		dts_check_eq("bt_adapter_start_device_discovery", callback_result, true, 
-			"Callback was called but failed.");
-	}
-	else
-	{
-		dts_fail("bt_adapter_start_device_discovery", "bt_adapter_start_device_discovery() failed.");
-	}
-}
-
-/**
- * @brief Positive test case of bt_adapter_unset_device_discovery_state_changed_cb()
- */
-static void utc_network_bluetooth_device_discovery_unset_state_changed_cb_p(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_adapter_unset_device_discovery_state_changed_cb();
-	dts_check_eq("bt_adapter_unset_device_discovery_state_changed_cb", ret, 
-		BT_ERROR_NONE, "bt_device_discovery_uset_state_changed_cb() failed");
-}
-
-/**
- * @brief Positive test case of bt_adapter_stop_device_discovery()
- */
-static void utc_network_bluetooth_device_discovery_cancel_p(void)
-{
-	int ret = BT_ERROR_NONE;
-	int timeout_id = 0;	
-
-	callback_result = false;
-
-	if( bt_adapter_set_device_discovery_state_changed_cb
-		(device_discovery_state_changed_cb_for_discovery_p, "cancel") != BT_ERROR_NONE )
-	{
-		dts_fail("bt_adapter_stop_device_discovery", 
-			"bt_adapter_set_device_discovery_state_changed_cb() failed");
-	}        
-
-	ret = bt_adapter_stop_device_discovery();
-	if( ret == BT_ERROR_NONE )
-	{       
-		tet_printf("bt_adapter_device_discovery_state_changed_cb_for_discovery_p() will be called");   
-		timeout_id = g_timeout_add (60000, timeout_func, mainloop);
-		g_main_loop_run(mainloop);	
-		g_source_remove(timeout_id);
-		bt_adapter_unset_device_discovery_state_changed_cb();
-		dts_check_eq("bt_adapter_stop_device_discovery", callback_result, true, "Callback was called but failed");
-	}
-	else
-	{
-		dts_fail("bt_adapter_stop_device_discovery", "bt_adapter_stop_device_discovery() failed");
-	}
-
-}
-
diff --git a/wearable/TC/testcase/utc_network_bluetooth_device_negative.c b/wearable/TC/testcase/utc_network_bluetooth_device_negative.c
deleted file mode 100644
index 9169ca3..0000000
--- a/wearable/TC/testcase/utc_network_bluetooth_device_negative.c
+++ /dev/null
@@ -1,300 +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 <tet_api.h>
-#include <bluetooth.h>
-#include <stdlib.h>
-#include <stdbool.h>
-#include <glib.h>
-
-enum {
-	POSITIVE_TC_IDX = 0x01,
-	NEGATIVE_TC_IDX,
-};
-
-static void startup(void);
-static void cleanup(void);
-
-static GMainLoop* mainloop;
-gboolean timeout_func(gpointer data);
-
-void (*tet_startup)(void) = startup;
-void (*tet_cleanup)(void) = cleanup;
-
-static void utc_network_bluetooth_device_set_bonded_cb_n(void);
-static void utc_network_bluetooth_device_set_unbonded_cb_n(void);
-static void utc_network_bluetooth_device_set_authorization_state_changed_cb_n(void);
-static void utc_network_bluetooth_device_cancel_bonding_n(void);
-static void utc_network_bluetooth_device_bond_n(void);
-static void utc_network_bluetooth_device_foreach_bonded_device_n(void);
-static void utc_network_bluetooth_device_set_alias_n(void);
-static void utc_network_bluetooth_device_set_authorization_n(void);
-static void utc_network_bluetooth_device_unbond_n(void);
-static void utc_network_bluetooth_device_unset_bonded_cb_n(void);
-static void utc_network_bluetooth_device_unset_unbonded_cb_n(void);
-static void utc_network_bluetooth_device_unset_authorization_state_changed_cb_n(void);
-
-void adapter_state_changed_cb_for_device_negative(int result, bt_adapter_state_e adapter_state, void* user_data);
-gboolean timeout_func(gpointer data);
-
-struct tet_testlist tet_testlist[] = {
-	{ utc_network_bluetooth_device_set_bonded_cb_n, NEGATIVE_TC_IDX },                        
-	{ utc_network_bluetooth_device_set_unbonded_cb_n, NEGATIVE_TC_IDX },                                        
-	{ utc_network_bluetooth_device_set_authorization_state_changed_cb_n, NEGATIVE_TC_IDX },                        	
-	{ utc_network_bluetooth_device_bond_n, NEGATIVE_TC_IDX },
-	{ utc_network_bluetooth_device_cancel_bonding_n, NEGATIVE_TC_IDX },                        	
-	{ utc_network_bluetooth_device_unbond_n, NEGATIVE_TC_IDX },  	
-	{ utc_network_bluetooth_device_foreach_bonded_device_n, NEGATIVE_TC_IDX },  		
-	{ utc_network_bluetooth_device_set_alias_n, NEGATIVE_TC_IDX }, 
-	{ utc_network_bluetooth_device_set_authorization_n, NEGATIVE_TC_IDX }, 	
-	{ utc_network_bluetooth_device_unset_bonded_cb_n, NEGATIVE_TC_IDX },                        	
-	{ utc_network_bluetooth_device_unset_unbonded_cb_n, NEGATIVE_TC_IDX },                        	
-	{ utc_network_bluetooth_device_unset_authorization_state_changed_cb_n, NEGATIVE_TC_IDX },                        	
-	{ NULL, 0 },
-};
-
-gboolean timeout_func(gpointer data)
-{
-	tet_printf("Callback: Timeout.");
-	g_main_loop_quit((GMainLoop*)data);
-	return FALSE;
-}
-
-
-static void startup(void)
-{
-	int ret = BT_ERROR_NONE;
-	int timeout_id = 0;
-
-	/* start of TC */
-	mainloop = g_main_loop_new(NULL, FALSE);       
-
-	bt_initialize();
-	if( bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_device_negative, "startup") != BT_ERROR_NONE )
-	{
-		tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed");
-	}                
-
-	tet_printf("bt_adapter_disable() was called.");
-	ret = bt_adapter_disable();
-	if( ret == BT_ERROR_NONE )
-	{
-		tet_printf("bt_adapter_disable() succeeded.");    
-		timeout_id = g_timeout_add (60000, timeout_func, mainloop);
-		g_main_loop_run(mainloop);	
-		g_source_remove(timeout_id);
-	}
-	else if( ret == BT_ERROR_NOT_ENABLED )
-	{
-		tet_printf("Bluetooth adapter is not enabled.");    
-	}
-	else
-	{
-		tet_printf("DTS may fail because bt_adapter_disable() failed");    
-	}     
-
-	if( bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE )
-	{
-		tet_printf("bt_adapter_set_state_changed_cb() failed.");
-	}        
-
-	tet_printf("TC start");	
-}
-
-
-static void cleanup(void)
-{
-	/* end of TC */
-	bt_deinitialize();	
-	tet_printf("TC end.");
-}
-
-
-/**
- * @brief Callback funtions
- */
-void adapter_state_changed_cb_for_device_negative(int result, bt_adapter_state_e adapter_state, void* user_data)
-{
-	tet_printf("Callback: bt_adapter_state_changed_cb was called.");
-	if( (user_data != NULL) && !strcmp((char*)user_data, "startup") )
-	{
-		if( adapter_state == BT_ADAPTER_DISABLED && result == BT_ERROR_NONE )
-		{
-			tet_printf("Callback: BT was disabled. DTS will be started.");
-		} 
-		else
-		{
-			tet_printf("Callback: BT was not disabled. DTS will be started but DTS may fail.");
-		}
-
-		if( mainloop )
-		{
-			g_main_loop_quit(mainloop);                                
-		}                
-	}
-}
-
-
-
-/**
- * @brief Negative test case of bt_device_set_bond_created_cb()
- */
-static void utc_network_bluetooth_device_set_bonded_cb_n(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_device_set_bond_created_cb(NULL, NULL);
-	dts_check_eq("bt_device_set_bond_created_cb", ret, BT_ERROR_INVALID_PARAMETER, 
-		"BT_ERROR_INVALID_PARAMETER must be returned when callback parameter is NULL");
-}
-
-/**
- * @brief Negative test case of bt_device_set_bond_destroyed_cb()
- */
-static void utc_network_bluetooth_device_set_unbonded_cb_n(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_device_set_bond_destroyed_cb(NULL, NULL);
-	dts_check_eq("bt_device_set_bond_destroyed_cb", ret, BT_ERROR_INVALID_PARAMETER, 
-		"BT_ERROR_INVALID_PARAMETER must be returned when callback parameter is NULL");
-}
-
-/**
- * @brief Negative test case of bt_device_set_authorization_changed_cb()
- */
-static void utc_network_bluetooth_device_set_authorization_state_changed_cb_n(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_device_set_authorization_changed_cb(NULL, NULL);
-	dts_check_eq("bt_device_set_authorization_changed_cb", ret, BT_ERROR_INVALID_PARAMETER, 
-		"BT_ERROR_INVALID_PARAMETER must be returned when callback parameter is NULL");
-}
-
-/**
- * @brief Negative test case of bt_device_unset_bond_created_cb()
- */
-static void utc_network_bluetooth_device_unset_bonded_cb_n(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	if( bt_deinitialize() != BT_ERROR_NONE )
-	{
-		dts_fail("bt_device_unset_bond_created_cb", "bt_deinitialize() failed.");
-	}	
-
-	ret = bt_device_unset_bond_created_cb();
-	dts_check_eq("bt_device_unset_bond_created_cb", ret, BT_ERROR_NOT_INITIALIZED, 
-		"BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized.");
-}
-
-	/**
-	 * @brief Negative test case of bt_device_unset_bond_destroyed_cb()
-	 */
-static void utc_network_bluetooth_device_unset_unbonded_cb_n(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_device_unset_bond_destroyed_cb();
-	dts_check_eq("bt_device_unset_bond_destroyed_cb", ret, BT_ERROR_NOT_INITIALIZED, 
-		"BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized.");
-}
-
-/**
- * @brief Negative test case of bt_device_unset_authorization_changed_cb()
- */
-static void utc_network_bluetooth_device_unset_authorization_state_changed_cb_n(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_device_unset_authorization_changed_cb();
-	dts_check_eq("bt_device_unset_authorization_changed_cb", ret, BT_ERROR_NOT_INITIALIZED, 
-		"BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized.");
-}
-
-	/**
-	 * @brief Negative test case of bt_device_create_bond()
-	 */
-static void utc_network_bluetooth_device_bond_n(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_device_create_bond(NULL);
-	dts_check_eq("bt_device_create_bond", ret, BT_ERROR_INVALID_PARAMETER, 
-		"BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized.");
-}
-
-	/**
-	 * @brief Negative test case of bt_device_cancel_bonding()
-	 */
-static void utc_network_bluetooth_device_cancel_bonding_n(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_device_cancel_bonding();
-	dts_check_eq("bt_device_cancel_bonding", ret, BT_ERROR_NOT_ENABLED, 
-		"BT_ERROR_NOT_ENABLED must be returned when BT is not enabled");
-}
-
-/**
- * @brief Negative test case of bt_device_destroy_bond()
- */
-static void utc_network_bluetooth_device_unbond_n(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_device_destroy_bond(NULL);
-	dts_check_eq("bt_device_destroy_bond", ret, BT_ERROR_INVALID_PARAMETER, 
-		"BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL");
-}
-
-/**
- * @brief Negative test case of bt_adapter_foreach_bonded_device()
- */
-static void utc_network_bluetooth_device_foreach_bonded_device_n(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_adapter_foreach_bonded_device(NULL, NULL);   
-	dts_check_eq("bt_adapter_foreach_bonded_device", ret, BT_ERROR_INVALID_PARAMETER, 
-		"BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL");
-}
-
-/**
- * @brief Negative test case of bt_device_set_alias()
- */
-static void utc_network_bluetooth_device_set_alias_n(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_device_set_alias(NULL, "dts_alias");   
-	dts_check_eq("bt_device_set_alias", ret, BT_ERROR_INVALID_PARAMETER, 
-		"BT_ERROR_INVALID_PARAMETER must be returned when address parameter is NULL");
-}
-
-/**
- * @brief Negative test case of bt_device_set_authorization()
- */
-static void utc_network_bluetooth_device_set_authorization_n(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_device_set_authorization(NULL, BT_DEVICE_AUTHORIZED);   
-	dts_check_eq("bt_device_set_authorization", ret, BT_ERROR_INVALID_PARAMETER, 
-		"BT_ERROR_INVALID_PARAMETER must be returned when address parameter is NULL");
-}
diff --git a/wearable/TC/testcase/utc_network_bluetooth_device_positive.c b/wearable/TC/testcase/utc_network_bluetooth_device_positive.c
deleted file mode 100644
index 0df13db..0000000
--- a/wearable/TC/testcase/utc_network_bluetooth_device_positive.c
+++ /dev/null
@@ -1,669 +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 <tet_api.h>
-#include <bluetooth.h>
-#include <stdlib.h>
-#include <stdbool.h>
-#include <glib.h>
-
-enum {
-	POSITIVE_TC_IDX = 0x01,
-	NEGATIVE_TC_IDX,
-};
-
-static void startup(void);
-static void cleanup(void);
-
-static GMainLoop* mainloop;
-static bool callback_result = false;
-char target_name[128] = "dts_test";
-char target_address[18] = "";
-bt_device_info_s* device_info = NULL;
-bool discovery_result = false;
-
-void (*tet_startup)(void) = startup;
-void (*tet_cleanup)(void) = cleanup;
-
-static void utc_network_bluetooth_device_set_bonded_cb_p(void);
-static void utc_network_bluetooth_device_set_unbonded_cb_p(void);
-static void utc_network_bluetooth_device_set_authorization_state_changed_cb_p(void);
-static void utc_network_bluetooth_device_cancel_bonding_p(void);
-static void utc_network_bluetooth_device_bond_p(void);
-static void utc_network_bluetooth_device_foreach_bonded_device_p(void);
-static void utc_network_bluetooth_device_set_alias_p(void);
-static void utc_network_bluetooth_device_set_authorization_p(void);
-static void utc_network_bluetooth_device_unbond_p(void);
-static void utc_network_bluetooth_device_unset_bonded_cb_p(void);
-static void utc_network_bluetooth_device_unset_unbonded_cb_p(void);
-static void utc_network_bluetooth_device_unset_authorization_state_changed_cb_p(void);
-
-gboolean timeout_func(gpointer data);
-void adapter_state_changed_cb_for_device_p(int result, bt_adapter_state_e adapter_state, void* user_data);
-void device_discovery_state_changed_cb_for_device_p(int result, bt_adapter_device_discovery_state_e discovery_state, 
-		bt_adapter_device_discovery_info_s* discovery_info, void* user_data);
-void device_bonded_cb(int result, bt_device_info_s *device_info, void* user_data);
-void device_unbonded_cb(int result, char* remote_address, void* user_data);
-void device_authorization_state_changed_cb(bt_device_authorization_e authorization_state, \
-		char *remote_address, void* user_data);
-bool bonded_device_cb_for_device_p(bt_device_info_s* dev_info, void *user_data);
-
-struct tet_testlist tet_testlist[] = {
-	{ utc_network_bluetooth_device_set_bonded_cb_p, POSITIVE_TC_IDX },                        
-	{ utc_network_bluetooth_device_unset_bonded_cb_p, POSITIVE_TC_IDX },                        	
-	{ utc_network_bluetooth_device_cancel_bonding_p, POSITIVE_TC_IDX },                        	
-	{ utc_network_bluetooth_device_bond_p, POSITIVE_TC_IDX },
-	{ utc_network_bluetooth_device_foreach_bonded_device_p, POSITIVE_TC_IDX },
-	{ utc_network_bluetooth_device_set_alias_p, POSITIVE_TC_IDX }, 
-	{ utc_network_bluetooth_device_set_authorization_state_changed_cb_p, POSITIVE_TC_IDX },                        		
-	{ utc_network_bluetooth_device_set_authorization_p, POSITIVE_TC_IDX }, 	
-	{ utc_network_bluetooth_device_unset_authorization_state_changed_cb_p, POSITIVE_TC_IDX },                        	
-	{ utc_network_bluetooth_device_set_unbonded_cb_p, POSITIVE_TC_IDX },                                        
-	{ utc_network_bluetooth_device_unbond_p, POSITIVE_TC_IDX },  		
-	{ utc_network_bluetooth_device_unset_unbonded_cb_p, POSITIVE_TC_IDX },                        	
-	{ NULL, 0 },
-};
-
-static void startup(void)
-{
-	bt_error_e ret = BT_ERROR_NONE;
-	int timeout_id = 0;	
-
-	/* start of TC */
-	callback_result = false;
-	discovery_result = false;
-	mainloop = g_main_loop_new(NULL, FALSE);       
-
-	bt_initialize();
-
-	if( bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_device_p, "startup") != BT_ERROR_NONE )
-	{
-		tet_printf("bt_adapter_set_state_changed_cb() failed.");
-	}                
-
-	if( bt_adapter_set_device_discovery_state_changed_cb(device_discovery_state_changed_cb_for_device_p, "startup") != BT_ERROR_NONE )
-	{
-		tet_printf("bt_adapter_set_device_discovery_state_changed_cb() failed.");
-	}        
-
-	ret = bt_adapter_enable();
-	if( ret == BT_ERROR_NONE )
-	{
-		tet_printf("bt_adapter_enable() succeeded.");        
-		timeout_id = g_timeout_add (60000, timeout_func, mainloop);
-		g_main_loop_run(mainloop);	
-		g_source_remove(timeout_id);
-
-		tet_printf("BT was enabled. Device discovery will be started");
-		if( bt_adapter_start_device_discovery() == BT_ERROR_NONE )
-		{
-			tet_printf("bt_adapter_start_device_discovery() succeeded.");        
-			timeout_id = g_timeout_add (60000, timeout_func, mainloop);
-			g_main_loop_run(mainloop);	
-			g_source_remove(timeout_id);
-		}
-		else
-		{
-			tet_printf("bt_adapter_start_device_discovery() failed.");
-		}
-	}
-	else if( ret == BT_ERROR_ALREADY_DONE )
-	{
-		tet_printf("BT was already enabled. Device discovery will be started");
-		if( bt_adapter_start_device_discovery() == BT_ERROR_NONE )
-		{
-			tet_printf("bt_adapter_start_device_discovery() succeeded.");        
-			timeout_id = g_timeout_add (60000, timeout_func, mainloop);
-			g_main_loop_run(mainloop);	
-			g_source_remove(timeout_id);
-		}
-		else
-		{
-			tet_printf("bt_adapter_start_device_discovery() failed.");
-		}
-	}
-	else
-	{
-		tet_printf("DTS may fail because bt_adapter_enable() failed.");    
-	}     
-
-	if( bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE )
-	{
-		tet_printf("bt_adapter_unset_state_changed_cb() failed.");
-	}      
-
-	if( bt_adapter_unset_device_discovery_state_changed_cb() != BT_ERROR_NONE )
-	{
-		tet_printf("bt_adapter_unset_device_discovery_state_changed_cb() failed.");
-	}      
-	
-	tet_printf("TC start.");	
-}
-
-static void cleanup(void)
-{
-	/* end of TC */
-	if( device_info != NULL )
-		free(device_info);
-
-	bt_deinitialize();
-	tet_printf("TC end");	
-}
-
-
-gboolean timeout_func(gpointer data)
-{
-	tet_printf("[%s] Callback: Timeout.", __FUNCTION__);
-	g_main_loop_quit((GMainLoop*)data);
-	return FALSE;
-}
-
-void adapter_state_changed_cb_for_device_p(int result, bt_adapter_state_e adapter_state, void* user_data)
-{
-	tet_printf("Callback: bt_adapter_state_changed_cb() was called");	
-	if( (user_data != NULL) && !strcmp((char *)user_data, "startup") )
-	{
-		if( adapter_state == BT_ADAPTER_ENABLED && result == BT_ERROR_NONE )
-		{
-			tet_printf("Callback: BT was enabled.");
-		}
-		else
-		{
-			tet_printf("Callback: BT was not enabled. DTS will be started but DTS may fail.");
-		}
-
-		if(mainloop)
-		{
-			g_main_loop_quit(mainloop);                                
-		}                		
-	}
-}
-
-void device_discovery_state_changed_cb_for_device_p(int result, bt_adapter_device_discovery_state_e discovery_state, 
-		bt_adapter_device_discovery_info_s* discovery_info, void* user_data)
-{
-	tet_printf("Callback: bt_adapter_device_discovery_state_changed_cb() was called");        	
-	if( (user_data != NULL) && !strcmp((char *)user_data, "startup") )
-	{
-		if( discovery_state == BT_ADAPTER_DEVICE_DISCOVERY_FINISHED )
-		{
-			tet_printf("Callback: Device discovery finished. DTS will be started.");
-			if(mainloop)
-			{
-				g_main_loop_quit(mainloop);                                
-			}                
-		}
-		else if( discovery_state == BT_ADAPTER_DEVICE_DISCOVERY_FOUND )
-		{
-			tet_printf("Callback: Devices were founded (%s)", discovery_info->remote_name);                
-			if( (discovery_info->remote_name != NULL) && !strcmp(discovery_info->remote_name, target_name) )
-			{
-				discovery_result = true;
-				tet_printf("Callback: dts_test device was found.");
-				strncpy(target_address, discovery_info->remote_address, 18);
-				tet_printf("Callback: device address: [%s]", discovery_info->remote_address); 
-				if( bt_adapter_stop_device_discovery() == BT_ERROR_NONE )
-				{
-					tet_printf("Callback: Device discovery will be stopped"); 
-				}
-			}
-		}
-	}
-}
-
-
-void device_bonded_cb(int result, bt_device_info_s *device_info, void* user_data)
-{
-	int i = 0;
-
-	tet_printf("Callback: bt_device_bond_created_cb() was called.");
-	if(result == BT_ERROR_TIMED_OUT)
-		tet_printf("result is BT_ERROR_TIMEOUT");
-	else if(result == BT_ERROR_CANCELLED)
-		tet_printf("result is BT_ERROR_CANCELLED");
-	else if(result == BT_ERROR_AUTH_FAILED)
-		tet_printf("result is BT_ERROR_AUTH_FAILED");
-	else if(result == BT_ERROR_OPERATION_FAILED)
-		tet_printf("result is BT_ERROR_OPERATION_FAILED");
-	else if(result == BT_ERROR_AUTH_REJECTED)
-		tet_printf("result is BT_ERROR_AUTH_REJECTED");
-	else if(result == BT_ERROR_REMOTE_DEVICE_NOT_FOUND)
-		tet_printf("result is BT_ERROR_REMOTE_DEVICE_NOT_FOUND");
-	else if(result == BT_ERROR_NONE)
-		tet_printf("result is BT_ERROR_NONE");
-	else
-		tet_printf("result is unknown: %s", _bt_convert_error_to_string(result));
-
-	// in case of bt_device_cancel_bonding()
-	if( (user_data != NULL) && !strcmp((char*)user_data, "cancel") )
-	{
-		if( result == BT_ERROR_CANCELLED)
-		{
-			tet_printf("Callback: Cancellation of bonding succeeded");
-			callback_result = true;
-		}
-		else
-		{
-			tet_printf("Callback: Cancellation of bonding failed");
-		}
-	}
-	// in case of bt_device_create_bond()
-	else if( (user_data != NULL) && !strcmp((char*)user_data, "bond") )
-	{
-		if (device_info == NULL) {
-			tet_printf("Callback data is NULL");
-
-			if (result == BT_ERROR_CANCELLED)
-				tet_printf("No user input in the peer device");
-
-			if (mainloop)
-				g_main_loop_quit(mainloop);
-
-			return;
-		}
-
-		if( (device_info->remote_name != NULL) && !strcmp(device_info->remote_name, target_name) )
-		{
-			if( result == BT_ERROR_NONE )
-			{
-				tet_printf("Callback: Bonding succeeded");
-				tet_printf("Callback: serivce count : %d", device_info->service_count);
-				callback_result = true;
-				for(i=0; i< device_info->service_count; i++)
-				{
-					tet_printf("Callback: service list[%d] - %s", i+1, device_info->service_uuid[i]);
-				}
-			}
-			else
-			{
-				tet_printf("Callback: Bonding failed");
-			}
-		}
-	}
-
-	if(mainloop)
-	{
-		g_main_loop_quit(mainloop);                                
-	}        
-}
-
-void device_unbonded_cb(int result, char* remote_address, void* user_data)
-{
-	tet_printf("Callback: bt_device_bond_destroyed_cb() was called.");
-	tet_printf("Callback: target address");
-	if( target_address != NULL )
-	{
-		tet_printf("device address: %s", target_address);
-	}
-	else
-		tet_printf("Callback: target address is NULL!");
-
-	tet_printf("Callback: address of unbonded device");
-	if( remote_address != NULL )
-	{
-		tet_printf("device address: %s", remote_address);
-	}
-	else
-		tet_printf("Callback: address of unbonded device is NULL!");
-
-	if( (remote_address != NULL) && \
-			!strcmp(remote_address, target_address) )
-	{
-		if( result == BT_ERROR_NONE )
-		{
-			tet_printf("Callback: Unbonding succeeded");
-			callback_result = true;
-		}
-		else
-		{
-			tet_printf("Callback: Unbonding failed");
-		}
-	}
-
-	if(mainloop)
-	{
-		g_main_loop_quit(mainloop);                                
-	}        
-
-}
-
-void device_authorization_state_changed_cb(bt_device_authorization_e authorization_state, \
-		char *address, void* user_data)
-{
-	if( authorization_state == BT_DEVICE_AUTHORIZED )
-	{
-		if( (address != NULL) && !strcmp(address, target_address) )
-		{
-			callback_result = true;
-			if(mainloop)
-			{
-				g_main_loop_quit(mainloop);                                
-			}        
-		}
-	}
-	else
-	{
-		if( (address != NULL) && !strcmp(address, target_address) )
-		{
-			callback_result = true;
-			if(mainloop)
-			{
-				g_main_loop_quit(mainloop);                                
-			}        
-		}
-	}
-}
-
-
-/**
- * @brief Positive test case of bt_device_set_bond_created_cb()
- */
-static void utc_network_bluetooth_device_set_bonded_cb_p(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	//  Normal operation test
-	ret = bt_device_set_bond_created_cb(device_bonded_cb, "cancel");
-	dts_check_eq("bt_device_set_bond_created_cb", ret, BT_ERROR_NONE, 
-		"bt_device_set_bond_created_cb() failed");
-}
-
-/**
- * @brief Positive test case of bt_device_set_bond_destroyed_cb()
- */
-static void utc_network_bluetooth_device_set_unbonded_cb_p(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	//  Normal operation test
-	ret = bt_device_set_bond_destroyed_cb(device_unbonded_cb, NULL);
-	dts_check_eq("bt_device_set_bond_destroyed_cb", ret, BT_ERROR_NONE, 
-		"bt_device_set_bond_destroyed_cb() failed");
-}
-
-/**
- * @brief Positive test case of bt_device_set_authorization_changed_cb()
- */
-static void utc_network_bluetooth_device_set_authorization_state_changed_cb_p(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	//  Normal operation test
-	ret = bt_device_set_authorization_changed_cb(device_authorization_state_changed_cb, NULL);
-	dts_check_eq("bt_device_set_authorization_changed_cb", ret, BT_ERROR_NONE, 
-		"bt_device_set_authorization_changed_cb() failed");
-}
-
-/**
- * @brief Positive test case of bt_device_cancel_bonding()
- */
-static void utc_network_bluetooth_device_cancel_bonding_p(void)
-{
-	int ret = BT_ERROR_NONE;
-	callback_result = false;
-	int timeout_id = 0;
-
-	if( bt_device_set_bond_created_cb(device_bonded_cb, "cancel") != BT_ERROR_NONE )
-	{
-		dts_fail("bt_device_cancel_bonding", "bt_device_set_bond_created_cb() failed");
-	}
-
-	// bond device
-	ret = bt_device_create_bond(target_address);
-	if( ret != BT_ERROR_NONE )
-	{
-		dts_fail("bt_device_cancel_bonding", "bt_device_create_bond failed");
-	}
-	tet_printf("bt_device_create_bond() was called");
-
-	// cancel bonding
-	ret = bt_device_cancel_bonding();
-	if( ret == BT_ERROR_NONE )
-	{       
-		tet_printf("bt_device_cancel_bonding() will be called");   
-		timeout_id = g_timeout_add (60000, timeout_func, mainloop);
-		g_main_loop_run(mainloop);	
-		g_source_remove(timeout_id);
-		bt_device_unset_bond_created_cb();
-		dts_check_eq("bt_device_cancel_bonding", callback_result, true, "Failed");
-	}
-	else
-	{
-		bt_device_unset_bond_created_cb();        
-		dts_fail("bt_device_cancel_bonding", "bt_device_cancel_bonding() failed");
-	}    
-}
-
-/**
- * @brief Positive test case of bt_device_unset_bond_created_cb()
- */
-static void utc_network_bluetooth_device_unset_bonded_cb_p(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	//  Normal operation test
-	ret = bt_device_unset_bond_created_cb();
-	dts_check_eq("bt_device_unset_bond_created_cb", ret, BT_ERROR_NONE, 
-		"bt_device_unset_bond_created_cb() failed");
-}
-
-/**
- * @brief Positive test case of bt_device_create_bond()
- */
-static void utc_network_bluetooth_device_bond_p(void)
-{
-	int ret = BT_ERROR_NONE;
-	int timeout_id = 0;
-	
-	callback_result = false;
-
-	// bond device
-	ret = bt_device_set_bond_created_cb(device_bonded_cb, "bond");
-	if( ret != BT_ERROR_NONE )
-	{
-		dts_fail("bt_device_create_bond", "bt_device_set_bond_created_cb() failed");
-	}
-
-	ret = bt_device_create_bond(target_address);
-	if( ret == BT_ERROR_NONE )
-	{       
-		tet_printf("bt_device_bond_created_cb() will be called");   
-		timeout_id = g_timeout_add (60000, timeout_func, mainloop);
-		g_main_loop_run(mainloop);	
-		g_source_remove(timeout_id);
-		bt_device_unset_bond_created_cb();
-		dts_check_eq("bt_device_create_bond", callback_result, true, "Failed");
-	}
-	else
-	{       
-		bt_device_unset_bond_created_cb();
-		dts_fail("bt_device_create_bond", "bt_device_create_bond() failed");
-	}    
-}
-
-
-bool bonded_device_cb_for_device_p(bt_device_info_s* dev_info, void *user_data)
-{
-	int i = 0;
-	device_info = (bt_device_info_s *)malloc(sizeof(bt_device_info_s));
-	if( device_info == NULL )
-	{
-		tet_printf("Callback: Memory allocation failed");; 
-	}        
-	else if( dev_info != NULL )
-	{
-		device_info->remote_address = strdup(dev_info->remote_address);
-		tet_printf("device address : %s", device_info->remote_address);
-		device_info->remote_name = strdup(dev_info->remote_name);
-		tet_printf("device name : %s", device_info->remote_name);
-		device_info->bt_class.major_device_class = dev_info->bt_class.major_device_class;
-		tet_printf("major clasee : %2.2X", device_info->bt_class.major_device_class);
-		device_info->bt_class.minor_device_class = dev_info->bt_class.minor_device_class;
-		tet_printf("minor clasee : %2.2X", device_info->bt_class.minor_device_class);
-		device_info->bt_class.major_service_class_mask = dev_info->bt_class.major_service_class_mask;
-		tet_printf("service clasee : %2.2X", device_info->bt_class.major_service_class_mask);
-		device_info->service_count = dev_info->service_count;
-		tet_printf("service count : %d", device_info->service_count);
-		if( device_info->service_count > 0 )
-		{
-			device_info->service_uuid = (char**)malloc(sizeof(char*) * device_info->service_count);
-			if( device_info->service_uuid == NULL )
-			{
-				tet_printf("Failed to allocate memory");
-			}
-			else
-			{
-				if( dev_info->service_uuid == NULL )
-				{
-					tet_printf("service_list is NULL");				
-				}
-				else
-				{
-					tet_printf("Copy service list");				
-					for(i=0; i< device_info->service_count; i++)
-					{
-						device_info->service_uuid[i] = strdup(dev_info->service_uuid[i]);						
-						tet_printf("Callback: service list[%d] - %s", i+1, device_info->service_uuid[i]);
-					}
-				}
-			}
-		}
-		else
-			device_info->service_uuid = NULL;
-		
-		device_info->is_bonded = dev_info->is_bonded;
-		tet_printf("is_bonded : %d", device_info->is_bonded);
-		device_info->is_connected = dev_info->is_connected;
-		tet_printf("is_connected : %d", device_info->is_connected);
-		tet_printf("Callback: device_info was selected.");
-	}
-
-	return false;               
-}
-
-/**
- * @brief Positive test case of bt_adapter_foreach_bonded_device()
- */
-static void utc_network_bluetooth_device_foreach_bonded_device_p(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_adapter_foreach_bonded_device(bonded_device_cb_for_device_p, NULL);
-	if (ret == BT_ERROR_NONE ) {
-		dts_pass("bt_adapter_foreach_bonded_device", "bt_adapter_foreach_bonded_device pass");
-	} else {
-		dts_fail("bt_adapter_foreach_bonded_device", "bt_adapter_foreach_bonded_device() failed");
-	}
-}
-
-
-/**
- * @brief Positive test case of bt_device_set_alias()
- */
-static void utc_network_bluetooth_device_set_alias_p(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	if (device_info == NULL) {
-		tet_printf("No device to alias");
-		dts_fail("bt_device_set_alias", "bt_device_set_alias() failed");
-		return;
-	}
-
-	ret = bt_device_set_alias(device_info->remote_address, "dts_alias");   
-	dts_check_eq("bt_device_set_alias", ret, BT_ERROR_NONE, "bt_device_set_alias() failed");       
-}
-
-/**
- * @brief Positive test case of bt_device_set_authorization()
- */
-static void utc_network_bluetooth_device_set_authorization_p(void)
-{
-	int ret = BT_ERROR_NONE;
-	int timeout_id = 0;
-	
-	callback_result = false;
-
-	ret = bt_device_set_authorization(target_address, BT_DEVICE_AUTHORIZED);   
-	if( ret == BT_ERROR_NONE )
-	{
-		tet_printf("device_authorization_state_changed_cb will be called");
-		timeout_id = g_timeout_add (60000, timeout_func, mainloop);
-		g_main_loop_run(mainloop);
-		g_source_remove(timeout_id);
-		dts_check_eq("bt_device_set_authorization", callback_result, true, "Callback was called but failed");
-		callback_result = false;
-	}
-	else
-	{
-		dts_fail("bt_device_set_authorization", "bt_device_set_authorization() failed");
-	}    
-}
-
-/**
- * @brief Positive test case of bt_device_destroy_bond()
- */
-static void utc_network_bluetooth_device_unbond_p(void)
-{
-	int ret = BT_ERROR_NONE;
-	int timeout_id = 0;
-	callback_result = false;
-
-	tet_printf("bt_device_destroy_bond() will start");   
-	ret = bt_device_destroy_bond(target_address);
-	if( ret == BT_ERROR_NONE ) 
-	{
-		tet_printf("bt_device_unbond_cb() will be called");   
-		timeout_id = g_timeout_add (60000, timeout_func, mainloop);
-		g_main_loop_run(mainloop);	
-		g_source_remove(timeout_id);
-		dts_check_eq("bt_device_destroy_bond", callback_result, true, "Failed");
-	}
-	else
-	{       
-		dts_fail("bt_device_destroy_bond", "bt_device_destroy_bond() failed");
-	}    
-}
-
-/**
- * @brief Positive test case of bt_device_unset_bond_destroyed_cb()
- */
-static void utc_network_bluetooth_device_unset_unbonded_cb_p(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	//  Normal operation test
-	ret = bt_device_unset_bond_destroyed_cb();
-	dts_check_eq("bt_device_unset_bond_destroyed_cb", ret, BT_ERROR_NONE, 
-		"bt_device_unset_bond_destroyed_cb() failed");
-}
-
-/**
- * @brief Positive test case of bt_device_unset_authorization_changed_cb()
- */
-static void utc_network_bluetooth_device_unset_authorization_state_changed_cb_p(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	//  Normal operation test
-	ret = bt_device_unset_authorization_changed_cb();
-	dts_check_eq("bt_device_unset_authorization_changed_cb", ret, BT_ERROR_NONE, 
-		"bt_device_unset_authorization_changed_cb() failed");
-}
-
-
-
diff --git a/wearable/TC/testcase/utc_network_bluetooth_service_search_negative.c b/wearable/TC/testcase/utc_network_bluetooth_service_search_negative.c
deleted file mode 100644
index 692e0f9..0000000
--- a/wearable/TC/testcase/utc_network_bluetooth_service_search_negative.c
+++ /dev/null
@@ -1,189 +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 <tet_api.h>
-#include <bluetooth.h>
-#include <stdlib.h>
-#include <stdbool.h>
-#include <glib.h>
-
-enum {
-	POSITIVE_TC_IDX = 0x01,
-	NEGATIVE_TC_IDX,
-};
-
-static void startup(void);
-static void cleanup(void);
-
-static GMainLoop* mainloop;
-
-void (*tet_startup)(void) = startup;
-void (*tet_cleanup)(void) = cleanup;
-
-static void utc_network_bluetooth_service_search_set_cb_n(void);
-static void utc_network_bluetooth_service_search_unset_cb_n(void);
-static void utc_network_bluetooth_service_search_n(void);
-static void utc_network_bluetooth_service_search_cancel_n(void);
-
-void adapter_state_changed_cb_for_service_search_n(int result, bt_adapter_state_e adapter_state, void* user_data);
-gboolean timeout_func(gpointer data);
-
-struct tet_testlist tet_testlist[] = {
-	{ utc_network_bluetooth_service_search_set_cb_n, NEGATIVE_TC_IDX },                        
-	{ utc_network_bluetooth_service_search_n, NEGATIVE_TC_IDX },                        	
-	{ utc_network_bluetooth_service_search_cancel_n, NEGATIVE_TC_IDX },                        	
-	{ utc_network_bluetooth_service_search_unset_cb_n, NEGATIVE_TC_IDX },                                        		
-	{ NULL, 0 },
-};
-
-
-static void startup(void)
-{
-	int ret = BT_ERROR_NONE;
-	int timeout_id = 0;
-
-	/* start of TC */
-	mainloop = g_main_loop_new(NULL, FALSE);       
-
-	bt_initialize();
-	if( bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_service_search_n, "startup") != BT_ERROR_NONE )
-	{
-		tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed");
-	}                
-
-	tet_printf("bt_adapter_disable() was called.");
-	ret = bt_adapter_disable();
-	if( ret == BT_ERROR_NONE )
-	{
-		tet_printf("bt_adapter_disable() succeeded.");    
-		timeout_id = g_timeout_add (60000, timeout_func, mainloop);
-		g_main_loop_run(mainloop);	
-		g_source_remove(timeout_id);
-	}
-	else if( ret == BT_ERROR_NOT_ENABLED )
-	{
-		tet_printf("Bluetooth adapter is not enabled.");    
-	}
-	else
-	{
-		tet_printf("DTS may fail because bt_adapter_disable() failed");    
-	}     
-
-	if( bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE )
-	{
-		tet_printf("bt_adapter_set_state_changed_cb() failed.");
-	}        
-
-	tet_printf("TC start");	
-}
-
-
-static void cleanup(void)
-{
-	/* end of TC */
-	bt_deinitialize();	
-	tet_printf("TC end.");
-}
-
-
-gboolean timeout_func(gpointer data)
-{
-	tet_printf("Callback: Timeout.");
-	g_main_loop_quit((GMainLoop*)data);
-	return FALSE;
-}
-
-
-/**
- * @brief Callback funtions
- */
-void adapter_state_changed_cb_for_service_search_n(int result, bt_adapter_state_e adapter_state, void* user_data)
-{
-	tet_printf("Callback: bt_adapter_state_changed_cb was called.");
-	if( (user_data != NULL) && !strcmp((char*)user_data, "startup") )
-	{
-		if( adapter_state == BT_ADAPTER_DISABLED && result == BT_ERROR_NONE )
-		{
-			tet_printf("Callback: BT was disabled. DTS will be started.");
-		} 
-		else
-		{
-			tet_printf("Callback: BT was not disabled. DTS will be started but DTS may fail.");
-		}
-
-		if( mainloop )
-		{
-			g_main_loop_quit(mainloop);                                
-		}                
-	}
-}
-
-
-
-/**
- * @brief Negative test case of bt_device_set_service_searched_cb()
- */
-static void utc_network_bluetooth_service_search_set_cb_n(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_device_set_service_searched_cb(NULL, NULL);
-	dts_check_eq("bt_device_set_service_searched_cb", ret, BT_ERROR_INVALID_PARAMETER, 
-		"BT_ERROR_INVALID_PARAMETER must be returned when callback parameter is NULL");
-}
-
-/**
- * @brief Negative test case of bt_device_unset_service_searched_cb()
- */
-static void utc_network_bluetooth_service_search_unset_cb_n(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	if( bt_deinitialize() != BT_ERROR_NONE )
-	{
-		dts_fail("bt_device_unset_service_searched_cb", "bt_deinitialize() failed.");
-	}	
-
-	ret = bt_device_unset_service_searched_cb();
-	dts_check_eq("bt_device_unset_service_searched_cb", ret, BT_ERROR_NOT_INITIALIZED, 
-		"BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized.");
-}
-
-/**
- * @brief Negative test case of bt_device_start_service_search()
- */
-static void utc_network_bluetooth_service_search_n(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_device_start_service_search(NULL);
-	dts_check_eq("bt_device_start_service_search", ret, BT_ERROR_INVALID_PARAMETER, 
-		"BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL");
-}
-
-/**
- * @brief Negative test case of bt_device_cancel_service_search()
- */
-static void utc_network_bluetooth_service_search_cancel_n(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_device_cancel_service_search();
-	dts_check_eq("bt_device_cancel_service_search", ret, BT_ERROR_NOT_ENABLED, 
-		"BT_ERROR_NOT_ENABLED must be returned when BT is not enabled");
-}
-
diff --git a/wearable/TC/testcase/utc_network_bluetooth_service_search_positive.c b/wearable/TC/testcase/utc_network_bluetooth_service_search_positive.c
deleted file mode 100644
index da55c62..0000000
--- a/wearable/TC/testcase/utc_network_bluetooth_service_search_positive.c
+++ /dev/null
@@ -1,410 +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 <tet_api.h>
-#include <bluetooth.h>
-#include <stdlib.h>
-#include <stdbool.h>
-#include <glib.h>
-enum {
-	POSITIVE_TC_IDX = 0x01,
-	NEGATIVE_TC_IDX,
-};
-
-static void startup(void);
-static void cleanup(void);
-
-void (*tet_startup)(void) = startup;
-void (*tet_cleanup)(void) = cleanup;
-
-char target_name[128] = "dts_test";
-char target_address[18] = "";
-bool callback_result = false;
-bool discovery_result = false;
-bool bonding_result = false;
-static GMainLoop* mainloop;
-
-static void utc_network_bluetooth_service_search_set_cb_p(void);
-static void utc_network_bluetooth_service_search_p(void);
-static void utc_network_bluetooth_service_search_cancel_p(void);
-static void utc_network_bluetooth_service_search_unset_cb_p(void);
-
-gboolean timeout_func(gpointer data);
-void adapter_state_changed_cb_for_service_search_p(int result, bt_adapter_state_e adapter_state, void* user_data);
-void device_discovery_state_changed_cb_for_service_search_p(int result, bt_adapter_device_discovery_state_e discovery_state,
-		bt_adapter_device_discovery_info_s* discovery_info, void* user_data);
-void service_searched_cb_for_service_search_p(int result, bt_device_sdp_info_s *sdp_info, void* user_data);
-void device_bonded_cb_for_service_search_p(int result, bt_device_info_s *device_info, void *user_data);
-void device_unbonded_cb(int result, char* remote_address, void *user_data);
-
-struct tet_testlist tet_testlist[] = {
-	{ utc_network_bluetooth_service_search_set_cb_p, POSITIVE_TC_IDX },
-	{ utc_network_bluetooth_service_search_p, POSITIVE_TC_IDX },
-	{ utc_network_bluetooth_service_search_cancel_p, POSITIVE_TC_IDX },
-	{ utc_network_bluetooth_service_search_unset_cb_p, POSITIVE_TC_IDX },
-	{ NULL, 0 },
-};
-
-
-static void startup(void)
-{
-	bt_error_e ret = BT_ERROR_NONE;
-	int timeout_id = 0;	
-
-	/* start of TC */
-	callback_result = false;
-	discovery_result = false;
-	mainloop = g_main_loop_new(NULL, FALSE);       
-
-	bt_initialize();
-
-	if( bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_service_search_p, "startup") != BT_ERROR_NONE )
-	{
-		tet_printf("bt_adapter_set_state_changed_cb() failed.");
-	}                
-
-	if( bt_adapter_set_device_discovery_state_changed_cb
-		(device_discovery_state_changed_cb_for_service_search_p, "startup") != BT_ERROR_NONE )
-	{
-		tet_printf("bt_adapter_set_device_discovery_state_changed_cb() failed.");
-	}        
-
-	ret = bt_adapter_enable();
-	if( ret == BT_ERROR_NONE )
-	{
-		tet_printf("bt_adapter_enable() succeeded.");        
-		timeout_id = g_timeout_add (60000, timeout_func, mainloop);
-		g_main_loop_run(mainloop);	
-		g_source_remove(timeout_id);
-
-		tet_printf("BT was enabled. Device discovery will be started");
-		if( bt_adapter_start_device_discovery() == BT_ERROR_NONE )
-		{
-			tet_printf("bt_adapter_start_device_discovery() succeeded.");        
-			timeout_id = g_timeout_add (60000, timeout_func, mainloop);
-			g_main_loop_run(mainloop);	
-			g_source_remove(timeout_id);
-		}
-		else
-		{
-			tet_printf("bt_adapter_start_device_discovery() failed.");
-		}
-	}
-	else if( ret == BT_ERROR_ALREADY_DONE )
-	{
-		tet_printf("BT was already enabled. Device discovery will be started");
-		if( bt_adapter_start_device_discovery() == BT_ERROR_NONE )
-		{
-			tet_printf("bt_adapter_start_device_discovery() succeeded.");        
-			timeout_id = g_timeout_add (60000, timeout_func, mainloop);
-			g_main_loop_run(mainloop);	
-			g_source_remove(timeout_id);
-		}
-		else
-		{
-			tet_printf("bt_adapter_start_device_discovery() failed.");
-		}
-	}
-	else
-	{
-		tet_printf("DTS may fail because bt_adapter_enable() failed.");    
-	}     
-
-	if( bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE )
-	{
-		tet_printf("bt_adapter_unset_state_changed_cb() failed.");
-	}      
-
-	if( bt_adapter_unset_device_discovery_state_changed_cb() != BT_ERROR_NONE )
-	{
-		tet_printf("bt_adapter_unset_device_discovery_state_changed_cb() failed.");
-	}      
-
-	tet_printf("TC start.");	
-}
-
-
-static void cleanup(void)
-{
-	/* end of TC */
-	int timeout_id = 0;
-
-	// Destroy a bond
-	bt_device_set_bond_destroyed_cb(device_unbonded_cb, NULL);
-	if( bt_device_destroy_bond(target_address) == BT_ERROR_NONE )
-	{
-		timeout_id = g_timeout_add (60000, timeout_func, mainloop);
-		g_main_loop_run(mainloop);	
-		g_source_remove(timeout_id);
-	}
-
-	bt_deinitialize();
-	tet_printf("TC end.");	
-}
-
-
-gboolean timeout_func(gpointer data)
-{
-	tet_printf("[%s] Callback: Timeout.", __FUNCTION__);
-	g_main_loop_quit((GMainLoop*)data);
-	return FALSE;
-}
-
-
-/**
- * @brief Callback funtions
- */
-void device_unbonded_cb(int result, char* remote_address, void *user_data)
-{
-	tet_printf("Callback: bt_device_bond_destroyed_cb() was called.");
-
-	if(mainloop)
-	{
-		g_main_loop_quit(mainloop);                                
-	}        
-
-}
-
-void adapter_state_changed_cb_for_service_search_p(int result, bt_adapter_state_e adapter_state, void* user_data)
-{
-	tet_printf("Callback: bt_adapter_state_changed_cb() was called");
-	if( (user_data != NULL) && !strcmp((char *)user_data, "startup") )
-	{
-		if( adapter_state == BT_ADAPTER_ENABLED && result == BT_ERROR_NONE )
-		{
-			tet_printf("Callback: BT was enabled.");
-		}
-		else
-		{
-			tet_printf("Callback: BT was not enabled. DTS will be started but DTS may fail.");
-		}
-
-		if(mainloop)
-		{
-			g_main_loop_quit(mainloop);                                
-		}                		
-	}
-}
-
-void device_discovery_state_changed_cb_for_service_search_p(int result, bt_adapter_device_discovery_state_e discovery_state,
-		bt_adapter_device_discovery_info_s* discovery_info, void* user_data)
-{
-	tet_printf("Callback: bt_adapter_device_discovery_state_changed_cb() was called");        
-	if( (user_data != NULL) && !strcmp((char *)user_data, "startup") )
-	{
-		if( discovery_state == BT_ADAPTER_DEVICE_DISCOVERY_FINISHED )
-		{
-			tet_printf("Callback: Device discovery finished. DTS will be started.");
-			if(mainloop)
-			{
-				g_main_loop_quit(mainloop);                                
-			}                
-		}
-		else if( discovery_state == BT_ADAPTER_DEVICE_DISCOVERY_FOUND )
-		{
-			tet_printf("Callback: Devices were founded (%s)", discovery_info->remote_name);                
-			if( (discovery_info->remote_name != NULL) && !strcmp(discovery_info->remote_name, target_name) )
-			{
-				discovery_result = true;
-				tet_printf("Callback: dts_test device was found.");
-				strncpy(target_address, discovery_info->remote_address, 18);
-				tet_printf("Callback: device address: %s", discovery_info->remote_address); 
-				if( bt_adapter_stop_device_discovery() == BT_ERROR_NONE )
-				{
-					tet_printf("Callback: Device discovery will be stopped"); 
-				}
-			}
-		}
-	}
-}
-
-void service_searched_cb_for_service_search_p(int result, bt_device_sdp_info_s *sdp_info, void* user_data)
-{
-	int i = 0;
-	
-	tet_printf("Callback: bt_device_service_searched_cb() was called.");
-	if( result == BT_ERROR_NONE )
-	{
-		if( (sdp_info != NULL) && (!strcmp(sdp_info->remote_address, target_address)) )
-		{
-			tet_printf("Callback: Service search succeeded.");
-			tet_printf("Callback: Service count : %d", sdp_info->service_count);
-			for(i=0; i< sdp_info->service_count; i++)
-			{
-				tet_printf("Callback: uuid[%d] - %s", i+1, sdp_info->service_uuid[i]);
-			}
-			
-			callback_result = true;
-		}
-	}
-	else if( result == BT_ERROR_CANCELLED )
-	{
-		if( (sdp_info != NULL) && (!strcmp(sdp_info->remote_address, target_address)) )
-		{
-			tet_printf("Callback: Calcellation of service search succeeded.");
-			callback_result = true;
-		}
-	}
-	else
-	{
-		tet_printf("Callback: Failed.");
-	}
-
-	if(mainloop)
-	{
-		g_main_loop_quit(mainloop);                                
-	}                        
-}
-
-void device_bonded_cb_for_service_search_p(int result, bt_device_info_s *device_info, void *user_data)
-{
-	if( (user_data != NULL) && !strcmp((char*)user_data, "startup") )
-	{
-		if( (device_info->remote_address != NULL) && !strcmp(device_info->remote_address, target_address) )
-		{
-			if( result == BT_ERROR_NONE )
-			{
-				tet_printf("Callback: Bonding succeeded");
-				bonding_result= true;
-			}
-			else
-			{
-				tet_printf("Callback: Bonding failed");
-			}
-		}
-	}
-
-	if(mainloop)
-	{
-		g_main_loop_quit(mainloop);                                
-	}              
-}
-
-
-/**
- * @brief Positive test case of bt_device_set_service_searched_cb()
- */
-static void utc_network_bluetooth_service_search_set_cb_p(void)
-{
-	int ret = BT_ERROR_NONE;
-	int timeout_id = 0;
-
-	ret = bt_device_set_service_searched_cb(service_searched_cb_for_service_search_p, NULL);
-	if( ret == BT_ERROR_NONE )
-	{
-		if( bt_device_set_bond_created_cb(device_bonded_cb_for_service_search_p, "startup") != BT_ERROR_NONE )
-		{
-			tet_printf("bt_device_set_bond_created_cb() failed.");
-		}  
-
-		if( (discovery_result == true) && (bt_device_create_bond(target_address) == BT_ERROR_NONE) )
-		{
-			tet_printf("bt_device_create_bond() succeeded.");        
-			timeout_id = g_timeout_add (60000, timeout_func, mainloop);
-			g_main_loop_run(mainloop);	
-			g_source_remove(timeout_id);
-		}
-		else
-		{
-			tet_printf("bt_device_create_bond() failed.");        
-		}
-	}
-	
-	dts_check_eq("bt_device_set_service_searched_cb", ret, BT_ERROR_NONE, 
-		"bt_device_set_service_searched_cb() failed.");
-}
-
-/**
- * @brief Positive test case of bt_device_start_service_search()
- */
-static void utc_network_bluetooth_service_search_p(void)
-{
-	int timeout_id = 0;
-	
-	if( discovery_result != true )
-	{
-		dts_fail("bt_device_start_service_search", "device discovery failed.");        
-	}
-
-	callback_result = false;
-	if( bt_device_start_service_search(target_address) == BT_ERROR_NONE )
-	{
-		tet_printf("bt_device_start_service_search() succeeded.");
-		tet_printf("service_searched_cb_for_service_search_p() will be called.");
-		timeout_id = g_timeout_add(60000, timeout_func, mainloop);
-		g_main_loop_run(mainloop);
-		g_source_remove(timeout_id);
-		dts_check_eq("bt_device_start_service_search", callback_result, true, "Service search failed.");                
-	}       
-	else
-	{
-		dts_fail("bt_device_start_service_search", "bt_device_start_service_search() failed.");
-	}
-}
-
-/**
- * @brief Positive test case of bt_device_cancel_service_search()
- */
-static void utc_network_bluetooth_service_search_cancel_p(void)
-{
-	int timeout_id = 0;
-	
-	if( discovery_result != true )
-	{
-		dts_fail("bt_device_cancel_service_search", "device discovery failed.");        
-	}
-
-	callback_result = false;
-	if( bt_device_start_service_search(target_address) != BT_ERROR_NONE )
-	{
-		dts_fail("bt_device_cancel_service_search", "bt_device_start_service_search() failed.");
-	}
-	else
-	{
-		tet_printf("bt_device_cancel_service_search", "bt_device_start_service_search() succeeded.");        
-	}
-
-	if( bt_device_cancel_service_search() == BT_ERROR_NONE )
-	{
-		tet_printf("bt_device_cancel_service_search() succeeded.");
-		tet_printf("service_searched_cb_for_service_search_p() will be called.");
-		timeout_id = g_timeout_add(60000, timeout_func, mainloop);
-		g_main_loop_run(mainloop);
-		g_source_remove(timeout_id);
-		dts_check_eq("bt_device_cancel_service_search", callback_result, 
-			true, "Cancellation of service search failed.");                
-	}       
-	else
-	{
-		dts_fail("bt_device_cancel_service_search", "bt_device_cancel_service_search() failed.");
-	}
-}
-
-/**
- * @brief Positive test case of bt_device_unset_service_searched_cb()
- */
-static void utc_network_bluetooth_service_search_unset_cb_p(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_device_unset_service_searched_cb();
-	dts_check_eq("bt_device_unset_service_searched_cb", ret, BT_ERROR_NONE, 
-		"bt_device_set_service_searched_cb() failed.");
-}
-
-
-
diff --git a/wearable/TC/testcase/utc_network_bluetooth_socket_negative.c b/wearable/TC/testcase/utc_network_bluetooth_socket_negative.c
deleted file mode 100644
index 2a6c855..0000000
--- a/wearable/TC/testcase/utc_network_bluetooth_socket_negative.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 <tet_api.h>
-#include <bluetooth.h>
-#include <stdlib.h>
-#include <stdbool.h>
-#include <glib.h>
-
-enum {
-	POSITIVE_TC_IDX = 0x01,
-	NEGATIVE_TC_IDX,
-};
-
-static void startup(void);
-static void cleanup(void);
-
-static GMainLoop* mainloop;
-
-void (*tet_startup)(void) = startup;
-void (*tet_cleanup)(void) = cleanup;
-
-static void utc_network_bluetooth_socket_set_data_received_cb_n(void);
-static void utc_network_bluetooth_socket_set_connection_state_changed_cb_n(void);
-static void utc_network_bluetooth_socket_unset_data_received_cb_n(void);
-static void utc_network_bluetooth_socket_unset_connection_state_changed_cb_n(void);
-static void utc_network_bluetooth_socket_create_rfcomm_n(void);
-static void utc_network_bluetooth_socket_destroy_rfcomm_n(void);
-static void utc_network_bluetooth_socket_listen_and_accept_rfcomm_n(void);
-static void utc_network_bluetooth_socket_connect_rfcomm_n(void);
-static void utc_network_bluetooth_socket_disconnect_rfcomm_n(void);
-static void utc_network_bluetooth_socket_send_data_n(void);
-
-void adapter_state_changed_cb_for_device_negative(int result, bt_adapter_state_e adapter_state, void* user_data);
-gboolean timeout_func(gpointer data);
-
-struct tet_testlist tet_testlist[] = {
-	{ utc_network_bluetooth_socket_set_data_received_cb_n, NEGATIVE_TC_IDX },                        
-	{ utc_network_bluetooth_socket_set_connection_state_changed_cb_n, NEGATIVE_TC_IDX },                                        
-	{ utc_network_bluetooth_socket_create_rfcomm_n, NEGATIVE_TC_IDX },                        	
-	{ utc_network_bluetooth_socket_destroy_rfcomm_n, NEGATIVE_TC_IDX },                        	
-	{ utc_network_bluetooth_socket_listen_and_accept_rfcomm_n, NEGATIVE_TC_IDX },
-	{ utc_network_bluetooth_socket_connect_rfcomm_n, NEGATIVE_TC_IDX },                        	
-	{ utc_network_bluetooth_socket_disconnect_rfcomm_n, NEGATIVE_TC_IDX },  		
-	{ utc_network_bluetooth_socket_send_data_n, NEGATIVE_TC_IDX }, 
-	{ utc_network_bluetooth_socket_unset_data_received_cb_n, NEGATIVE_TC_IDX },                        	
-	{ utc_network_bluetooth_socket_unset_connection_state_changed_cb_n, NEGATIVE_TC_IDX },                        			
-	{ NULL, 0 },
-};
-
-
-static void startup(void)
-{
-	int ret = BT_ERROR_NONE;
-	int timeout_id = 0;
-
-	/* start of TC */
-	mainloop = g_main_loop_new(NULL, FALSE);       
-
-	bt_initialize();
-	if( bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_device_negative, "startup") != BT_ERROR_NONE )
-	{
-		tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed");
-	}                
-
-	tet_printf("bt_adapter_disable() was called.");
-	ret = bt_adapter_disable();
-	if( ret == BT_ERROR_NONE )
-	{
-		tet_printf("bt_adapter_disable() succeeded.");    
-		timeout_id = g_timeout_add (60000, timeout_func, mainloop);
-		g_main_loop_run(mainloop);	
-		g_source_remove(timeout_id);
-	}
-	else if( ret == BT_ERROR_NOT_ENABLED )
-	{
-		tet_printf("Bluetooth adapter is not enabled.");    
-	}
-	else
-	{
-		tet_printf("DTS may fail because bt_adapter_disable() failed");    
-	}     
-
-	if( bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE )
-	{
-		tet_printf("bt_adapter_set_state_changed_cb() failed.");
-	}        
-
-	tet_printf("TC start");	
-}
-
-
-static void cleanup(void)
-{
-	/* end of TC */
-	bt_deinitialize();	
-	tet_printf("TC end.");
-}
-
-
-gboolean timeout_func(gpointer data)
-{
-	tet_printf("Callback: Timeout.");
-	g_main_loop_quit((GMainLoop*)data);
-	return FALSE;
-}
-
-
-/**
- * @brief Callback funtions
- */
-void adapter_state_changed_cb_for_device_negative(int result, bt_adapter_state_e adapter_state, void* user_data)
-{
-	tet_printf("Callback: bt_adapter_state_changed_cb was called.");
-	if( (user_data != NULL) && !strcmp((char*)user_data, "startup") )
-	{
-		if( adapter_state == BT_ADAPTER_DISABLED && result == BT_ERROR_NONE )
-		{
-			tet_printf("Callback: BT was disabled. DTS will be started.");
-		} 
-		else
-		{
-			tet_printf("Callback: BT was not disabled. DTS will be started but DTS may fail.");
-		}
-
-		if( mainloop )
-		{
-			g_main_loop_quit(mainloop);                                
-		}                
-	}
-}
-
-
-
-/**
- * @brief Negative test case of bt_socket_set_data_received_cb()
- */
-static void utc_network_bluetooth_socket_set_data_received_cb_n(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_socket_set_data_received_cb(NULL, NULL);
-	dts_check_eq("bt_socket_set_data_received_cb", ret, BT_ERROR_INVALID_PARAMETER, 
-		"BT_ERROR_INVALID_PARAMETER must be returned when callback parameter is NULL");
-}
-
-/**
- * @brief Negative test case of bt_socket_set_connection_state_changed_cb()
- */
-static void utc_network_bluetooth_socket_set_connection_state_changed_cb_n(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_socket_set_connection_state_changed_cb(NULL, NULL);
-	dts_check_eq("bt_socket_set_connection_state_changed_cb", ret, BT_ERROR_INVALID_PARAMETER, 
-		"BT_ERROR_INVALID_PARAMETER must be returned when callback parameter is NULL");
-}
-
-/**
- * @brief Negative test case of bt_socket_unset_data_received_cb()
- */
-static void utc_network_bluetooth_socket_unset_data_received_cb_n(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	if( bt_deinitialize() != BT_ERROR_NONE )
-	{
-		dts_fail("bt_socket_unset_data_received_cb", "bt_deinitialize() failed.");
-	}	
-
-	ret = bt_socket_unset_data_received_cb();
-	dts_check_eq("bt_socket_unset_data_received_cb", ret, BT_ERROR_NOT_INITIALIZED, 
-		"BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized.");
-}
-
-/**
- * @brief Negative test case of bt_socket_unset_connection_state_changed_cb()
- */
-static void utc_network_bluetooth_socket_unset_connection_state_changed_cb_n(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_socket_unset_connection_state_changed_cb();
-	dts_check_eq("bt_socket_unset_connection_state_changed_cb", ret, BT_ERROR_NOT_INITIALIZED, 
-		"BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized.");
-}
-
-/**
- * @brief Negative test case of bt_socket_create_rfcomm()
- */
-static void utc_network_bluetooth_socket_create_rfcomm_n(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_socket_create_rfcomm(NULL, NULL);
-	dts_check_eq("bt_socket_create_rfcomm", ret, BT_ERROR_INVALID_PARAMETER, 
-		"BT_ERROR_INVALID_PARAMETER must be returned when port_uuid parameter is NULL");
-}
-
-/**
- * @brief Negative test case of bt_socket_destroy_rfcomm()
- */
-static void utc_network_bluetooth_socket_destroy_rfcomm_n(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_socket_destroy_rfcomm(-1);
-	dts_check_eq("bt_socket_listen_and_accept_rfcomm", ret, BT_ERROR_INVALID_PARAMETER, 
-		"BT_ERROR_INVALID_PARAMETER must be returned when socket_fd is below 0");
-}
-
-
-/**
- * @brief Negative test case of bt_socket_listen_and_accept_rfcomm()
- */
-static void utc_network_bluetooth_socket_listen_and_accept_rfcomm_n(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_socket_listen_and_accept_rfcomm(1, 1);
-	dts_check_eq("bt_socket_listen_and_accept_rfcomm", ret, BT_ERROR_NOT_ENABLED, 
-		"BT_ERROR_NOT_ENABLED must be returned when BT is not enabled");
-}
-
-/**
- * @brief Negative test case of bt_socket_connect_rfcomm()
- */
-static void utc_network_bluetooth_socket_connect_rfcomm_n(void)
-{
-	int ret = BT_ERROR_NONE;
-	char* address = "";
-	char* uuid = "";
-
-	ret = bt_socket_connect_rfcomm(address, uuid);
-	dts_check_eq("bt_socket_connect_rfcomm", ret, BT_ERROR_NOT_ENABLED, 
-		"BT_ERROR_NOT_ENABLED must be returned when BT is not enabled");
-}
-
-/**
- * @brief Negative test case of bt_socket_disconnect_rfcomm()
- */
-static void utc_network_bluetooth_socket_disconnect_rfcomm_n(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_socket_disconnect_rfcomm(-1);
-	dts_check_eq("bt_socket_disconnect_rfcomm", ret, BT_ERROR_NOT_ENABLED, 
-		"BT_ERROR_NOT_ENABLED must be returned when BT is not enabled");
-}
-
-/**
- * @brief Negative test case of bt_socket_send_data()
- */
-static void utc_network_bluetooth_socket_send_data_n(void)
-{
-	int ret = BT_ERROR_NONE;
-	char* data = "dts_test";
-
-	ret = bt_socket_send_data(1, data, sizeof(data));
-	dts_check_eq("bt_socket_send_data", ret, BT_ERROR_NOT_ENABLED, 
-		"BT_ERROR_NOT_ENABLED must be returned when BT is not enabled");
-}
-
-
-
-
diff --git a/wearable/TC/testcase/utc_network_bluetooth_socket_positive.c b/wearable/TC/testcase/utc_network_bluetooth_socket_positive.c
deleted file mode 100644
index 12588bd..0000000
--- a/wearable/TC/testcase/utc_network_bluetooth_socket_positive.c
+++ /dev/null
@@ -1,476 +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 <tet_api.h>
-#include <bluetooth.h>
-#include <stdlib.h>
-#include <stdbool.h>
-#include <glib.h>
-enum {
-	POSITIVE_TC_IDX = 0x01,
-	NEGATIVE_TC_IDX,
-};
-
-static void startup(void);
-static void cleanup(void);
-
-void (*tet_startup)(void) = startup;
-void (*tet_cleanup)(void) = cleanup;
-
-const char target_name[128] = "dts_test";
-const char* rfcomm_test_uuid_spp = "00001101-0000-1000-8000-00805F9B34FB";
-char target_address[18] = "";
-int socket_fd = 0;
-bool callback_result = false;
-bool discovery_result = false;
-bool bonding_result = false;
-bool is_connecting = false;
-static GMainLoop* mainloop;
-
-static void utc_network_bluetooth_socket_set_data_received_cb_p(void);
-static void utc_network_bluetooth_socket_set_connection_state_changed_cb_p(void);
-
-static void utc_network_bluetooth_socket_create_rfcomm_p(void);
-static void utc_network_bluetooth_socket_destroy_rfcomm_p(void);
-static void utc_network_bluetooth_socket_listen_and_accept_rfcomm_p(void);
-static void utc_network_bluetooth_socket_connect_rfcomm_p(void);
-static void utc_network_bluetooth_socket_disconnect_rfcomm_p(void);
-static void utc_network_bluetooth_socket_send_data_p(void);
-static void utc_network_bluetooth_socket_unset_data_received_cb_p(void);
-static void utc_network_bluetooth_socket_unset_connection_state_changed_cb_p(void);
-
-gboolean timeout_func(gpointer data);
-void adapter_state_changed_cb_for_socket_p(int result, bt_adapter_state_e adapter_state, void* user_data);
-void device_discovery_state_changed_cb_for_socket_p(int result, bt_adapter_device_discovery_state_e discovery_state,
-		bt_adapter_device_discovery_info_s* discovery_info, void* user_data);
-void device_bonded_cb_for_socket_p(int result, bt_device_info_s *device_info, void* user_data);
-void socket_data_received_cb_for_socket_p(bt_socket_received_data_s *data, void* user_data);
-void socket_connection_state_changed_cb_for_socket_p(int result, \
-		bt_socket_connection_state_e connection_state, bt_socket_connection_s *connection, void* user_data);
-void device_unbonded_cb(int result, char* remote_address, void *user_data);
-
-struct tet_testlist tet_testlist[] = {
-	{ utc_network_bluetooth_socket_set_connection_state_changed_cb_p, POSITIVE_TC_IDX },
-	{ utc_network_bluetooth_socket_set_data_received_cb_p, POSITIVE_TC_IDX },                
-	{ utc_network_bluetooth_socket_create_rfcomm_p, POSITIVE_TC_IDX },
-	{ utc_network_bluetooth_socket_listen_and_accept_rfcomm_p, POSITIVE_TC_IDX },
-	{ utc_network_bluetooth_socket_destroy_rfcomm_p, POSITIVE_TC_IDX },
-	{ utc_network_bluetooth_socket_connect_rfcomm_p, POSITIVE_TC_IDX },
-	{ utc_network_bluetooth_socket_send_data_p, POSITIVE_TC_IDX },
-	{ utc_network_bluetooth_socket_disconnect_rfcomm_p, POSITIVE_TC_IDX },
-	{ utc_network_bluetooth_socket_unset_data_received_cb_p, POSITIVE_TC_IDX },
-	{ utc_network_bluetooth_socket_unset_connection_state_changed_cb_p, POSITIVE_TC_IDX },
-	{ NULL, 0 },
-};
-
-
-static void startup(void)
-{
-	bt_error_e ret = BT_ERROR_NONE;
-	int timeout_id = 0;
-
-	/* start of TC */
-	tet_printf("TC start.");
-	callback_result = false;
-	discovery_result = false;
-	bonding_result = false;
-	mainloop = g_main_loop_new(NULL, FALSE);  
-
-	bt_initialize();
-
-	if( bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_socket_p, "startup") != BT_ERROR_NONE )
-	{
-		tet_printf("bt_adapter_set_state_changed_cb() failed.");
-	}                
-
-	if( bt_adapter_set_device_discovery_state_changed_cb(device_discovery_state_changed_cb_for_socket_p, "startup") != BT_ERROR_NONE )
-	{
-		tet_printf("bt_adapter_set_device_discovery_state_changed_cb() failed.");
-	}     
-
-	if( bt_device_set_bond_created_cb(device_bonded_cb_for_socket_p, "startup") != BT_ERROR_NONE )
-	{
-		tet_printf("bt_device_set_bond_created_cb() failed.");
-	}  
-
-	ret = bt_adapter_enable();
-	if( ret == BT_ERROR_NONE )
-	{
-		tet_printf("bt_adapter_enable() succeeded.");        
-		timeout_id = g_timeout_add (60000, timeout_func, mainloop);
-		g_main_loop_run(mainloop);	
-		g_source_remove(timeout_id);
-
-		tet_printf("BT was enabled. Device discovery will be started");
-		if( bt_adapter_start_device_discovery() == BT_ERROR_NONE )
-		{
-			tet_printf("bt_adapter_start_device_discovery() succeeded.");        
-			timeout_id = g_timeout_add (60000, timeout_func, mainloop);
-			g_main_loop_run(mainloop);	
-			g_source_remove(timeout_id);
-		}
-		else
-		{
-			tet_printf("bt_adapter_start_device_discovery() failed.");
-		}
-	}
-	else if( ret == BT_ERROR_ALREADY_DONE )
-	{
-		tet_printf("BT was already enabled. Device discovery will be started");
-		if( bt_adapter_start_device_discovery() == BT_ERROR_NONE )
-		{
-			tet_printf("bt_adapter_start_device_discovery() succeeded.");        
-			timeout_id = g_timeout_add (60000, timeout_func, mainloop);
-			g_main_loop_run(mainloop);	
-			g_source_remove(timeout_id);
-		}
-		else
-		{
-			tet_printf("bt_adapter_start_device_discovery() failed.");
-		}
-	}
-	else
-	{
-		tet_printf("DTS may fail because bt_adapter_enable() failed.");    
-	}
-	
-	if( (discovery_result == true) && (bt_device_create_bond(target_address) == BT_ERROR_NONE) )
-	{
-		tet_printf("bt_device_create_bond() succeeded.");        
-		timeout_id = g_timeout_add(60000, timeout_func, mainloop);
-		g_main_loop_run(mainloop);
-		g_source_remove(timeout_id);	
-	}
-	else
-	{
-		tet_printf("bt_device_create_bond() failed.");        
-	}
-
-	if( bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE )
-	{
-		tet_printf("bt_adapter_unset_state_changed_cb() failed.");
-	}      
-
-	if( bt_adapter_unset_device_discovery_state_changed_cb() != BT_ERROR_NONE )
-	{
-		tet_printf("bt_adapter_unset_device_discovery_state_changed_cb() failed.");
-	}  
-
-	if( bt_device_unset_bond_created_cb() != BT_ERROR_NONE )
-	{
-		tet_printf("bt_device_unset_bond_created_cb() failed.");
-	} 
-
-}
-
-
-static void cleanup(void)
-{
-	/* end of TC */
-	int timeout_id = 0;
-
-	// Destroy a bond
-	bt_device_set_bond_destroyed_cb(device_unbonded_cb, NULL);
-	if( bt_device_destroy_bond(target_address) == BT_ERROR_NONE )
-	{
-		timeout_id = g_timeout_add (60000, timeout_func, mainloop);
-		g_main_loop_run(mainloop);	
-		g_source_remove(timeout_id);
-	}
-
-	bt_deinitialize();
-	tet_printf("TC end.");	
-}
-
-
-gboolean timeout_func(gpointer data)
-{
-	tet_printf("[%s] Callback: Timeout.", __FUNCTION__);
-	g_main_loop_quit((GMainLoop*)data);
-	return FALSE;
-}
-
-
-/**
- * @brief Callback funtions
- */
-void device_unbonded_cb(int result, char* remote_address, void *user_data)
-{
-	tet_printf("Callback: bt_device_bond_destroyed_cb() was called.");
-
-	if(mainloop)
-	{
-		g_main_loop_quit(mainloop);                                
-	}        
-
-}
-
-
-void adapter_state_changed_cb_for_socket_p(int result, bt_adapter_state_e adapter_state, void* user_data)
-{
-	if( (user_data != NULL) && !strcmp((char *)user_data, "startup") )
-	{
-		if( adapter_state == BT_ADAPTER_ENABLED && result == BT_ERROR_NONE )
-		{
-			tet_printf("Callback: BT was enabled.");
-			bt_adapter_start_device_discovery();
-		}
-		else
-		{
-			tet_printf("Callback: BT was not enabled. DTS will be started but DTS may fail.");
-			if(mainloop)
-			{
-				g_main_loop_quit(mainloop);                                
-			}                
-		}
-	}
-}
-
-void device_discovery_state_changed_cb_for_socket_p(int result, bt_adapter_device_discovery_state_e discovery_state,
-		bt_adapter_device_discovery_info_s* discovery_info, void* user_data)
-{
-	tet_printf("Callback: bt_adapter_device_discovery_state_changed_cb() was called");        	
-	if( (user_data != NULL) && !strcmp((char *)user_data, "startup") )
-	{
-		if( discovery_state == BT_ADAPTER_DEVICE_DISCOVERY_FINISHED )
-		{
-			tet_printf("Callback: Device discovery finished. DTS will be started.");
-			if(mainloop)
-			{
-				g_main_loop_quit(mainloop);                                
-			}                
-		}
-		else if( discovery_state == BT_ADAPTER_DEVICE_DISCOVERY_FOUND )
-		{
-			tet_printf("Callback: Devices were founded (%s)", discovery_info->remote_name);                
-			if( (discovery_info->remote_name != NULL) && !strcmp(discovery_info->remote_name, target_name) )
-			{
-				discovery_result = true;
-				tet_printf("Callback: dts_test device was found.");
-				strncpy(target_address, discovery_info->remote_address, 18);
-				tet_printf("Callback: device address: %s", discovery_info->remote_address); 
-				if( bt_adapter_stop_device_discovery() == BT_ERROR_NONE )
-				{
-					tet_printf("Callback: Device discovery will be stopped"); 
-				}
-			}
-		}
-	}
-}
-
-void device_bonded_cb_for_socket_p(int result, bt_device_info_s *device_info, void* user_data)
-{
-	if( (user_data != NULL) && !strcmp((char*)user_data, "startup") )
-	{
-		if( (device_info->remote_address != NULL) && !strcmp(device_info->remote_address, target_address) )
-		{
-			if( result == BT_ERROR_NONE )
-			{
-				tet_printf("Callback: Bonding succeeded");
-				bonding_result= true;
-			}
-			else
-			{
-				tet_printf("Callback: Bonding failed");
-			}
-		}
-	}
-
-	if(mainloop)
-	{
-		g_main_loop_quit(mainloop);                                
-	}              
-}
-
-void socket_data_received_cb_for_socket_p(bt_socket_received_data_s *data, void* user_data)
-{
-}
-
-void socket_connection_state_changed_cb_for_socket_p(int result, 
-		bt_socket_connection_state_e connection_state, bt_socket_connection_s *connection, void* user_data)
-{
-	tet_printf("Callback: bt_socket_connection_state_changed_cb() was called");
-	if( connection_state == BT_SOCKET_CONNECTED )
-		tet_printf("Callback: Connected");        
-	else
-		tet_printf("Callback: Disconnected");
-
-	if( connection_state == BT_SOCKET_CONNECTED )
-	{
-		tet_printf("Callback: [BT_SOCKET_CONNECTED] result = %d", result);
-		if( result == BT_ERROR_NONE && is_connecting == true )
-		{
-			callback_result = true;
-			socket_fd = connection->socket_fd;
-			tet_printf("Callback: socket_fd = %d", socket_fd);
-
-			if(mainloop)
-			{
-				g_main_loop_quit(mainloop);                                
-			}                
-		}                
-	}
-	else if( connection_state == BT_SOCKET_DISCONNECTED )
-	{
-		tet_printf("Callback: [BT_SOCKET_DISCONNECTED] result = %d", result);
-		if( result == BT_ERROR_NONE && is_connecting == false )
-		{
-			callback_result = true;
-			socket_fd = connection->socket_fd;
-			tet_printf("Callback: socket_fd = %d", socket_fd);
-
-			if(mainloop)
-			{
-				g_main_loop_quit(mainloop);                                
-			}                
-		}
-	}
-}
-
-
-/**
- * @brief Positive test case of bt_socket_set_data_received_cb()
- */
-static void utc_network_bluetooth_socket_set_data_received_cb_p(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_socket_set_data_received_cb(socket_data_received_cb_for_socket_p, NULL);
-	dts_check_eq("bt_socket_set_data_received_cb", ret, BT_ERROR_NONE, 
-		"bt_socket_set_data_received_cb() failed.");
-}
-
-/**
- * @brief Positive test case of bt_socket_set_connection_state_changed_cb()
- */
-static void utc_network_bluetooth_socket_set_connection_state_changed_cb_p(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_socket_set_connection_state_changed_cb(socket_connection_state_changed_cb_for_socket_p, NULL);
-	dts_check_eq("bt_socket_set_connection_state_changed_cb", ret, BT_ERROR_NONE, 
-		"bt_socket_set_connection_state_changed_cb() failed.");
-}
-
-/**
- * @brief Positive test case of bt_socket_create_rfcomm()
- */
-static void utc_network_bluetooth_socket_create_rfcomm_p(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_socket_create_rfcomm(rfcomm_test_uuid_spp, &socket_fd);
-	dts_check_eq("bt_socket_create_rfcomm", ret, BT_ERROR_NONE, 
-		"bt_socket_create_rfcomm() failed.");
-}
-
-/**
- * @brief Positive test case of bt_socket_listen_and_accept_rfcomm()
- */
-static void utc_network_bluetooth_socket_listen_and_accept_rfcomm_p(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_socket_listen_and_accept_rfcomm(socket_fd, 1);
-	dts_check_eq("bt_socket_listen_and_accept_rfcomm", ret, BT_ERROR_NONE, 
-		"bt_socket_listen_and_accept_rfcomm() failed.");
-}
-
-/**
- * @brief Positive test case of bt_socket_destroy_rfcomm()
- */
-static void utc_network_bluetooth_socket_destroy_rfcomm_p(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_socket_destroy_rfcomm(socket_fd);
-	dts_check_eq("bt_socket_destroy_rfcomm", ret, BT_ERROR_NONE, 
-		"bt_socket_destroy_rfcomm() failed.");
-}
-
-/**
- * @brief Positive test case of bt_socket_connect_rfcomm()
- */
-static void utc_network_bluetooth_socket_connect_rfcomm_p(void)
-{
-	int ret = BT_ERROR_NONE;
-	int timeout_id = 0;	
-
-	is_connecting = true;
-	callback_result = false;
-	ret = bt_socket_connect_rfcomm(target_address, rfcomm_test_uuid_spp);
-	if( ret == BT_ERROR_NONE )
-	{
-		tet_printf("bt_socket_connect_rfcomm() succeeded.");        
-		timeout_id = g_timeout_add(60000, timeout_func, mainloop);
-		g_main_loop_run(mainloop);
-		g_source_remove(timeout_id);
-	}       
-	else
-	{
-		dts_fail("bt_socket_connect_rfcomm", "bt_socket_connect_rfcomm() failed");
-	}
-	dts_check_eq("bt_socket_connect_rfcomm", callback_result, true, "connecting failed.");
-}
-
-/**
- * @brief Positive test case of bt_socket_disconnect_rfcomm()
- */
-static void utc_network_bluetooth_socket_disconnect_rfcomm_p(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_socket_disconnect_rfcomm(socket_fd);
-	dts_check_eq("bt_socket_disconnect_rfcomm", ret, BT_ERROR_NONE, "bt_socket_disconnect_rfcomm() failed.");
-}
-
-/**
- * @brief Positive test case of bt_socket_send_data()
- */
-static void utc_network_bluetooth_socket_send_data_p(void)
-{
-	int ret = BT_ERROR_NONE;
-	char* dts_test = "dts_test";
-
-	ret = bt_socket_send_data(socket_fd, "dts_test", sizeof(dts_test));
-	dts_check_eq("bt_socket_send_data", ret, BT_ERROR_NONE, "bt_socket_send_data() failed.");
-}
-
-/**
- * @brief Positive test case of bt_socket_unset_data_received_cb()
- */
-static void utc_network_bluetooth_socket_unset_data_received_cb_p(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_socket_unset_data_received_cb();
-	dts_check_eq("bt_socket_unset_data_received_cb", ret, BT_ERROR_NONE, 
-		"bt_socket_unset_data_received_cb() failed.");
-}
-
-/**
- * @brief Positive test case of bt_socket_unset_connection_state_changed_cb()
- */
-static void utc_network_bluetooth_socket_unset_connection_state_changed_cb_p(void)
-{
-	int ret = BT_ERROR_NONE;
-
-	ret = bt_socket_unset_connection_state_changed_cb();
-	dts_check_eq("bt_socket_unset_connection_state_changed_cb", ret, BT_ERROR_NONE, 
-		"bt_socket_unset_connection_state_changed_cb() failed.");
-}
-
diff --git a/wearable/TC/tet_scen b/wearable/TC/tet_scen
deleted file mode 100755
index 03f029a..0000000
--- a/wearable/TC/tet_scen
+++ /dev/null
@@ -1,7 +0,0 @@
-all
-	^TEST
-##### Scenarios for TEST #####
-
-# Test scenario
-TEST
-	:include:/testcase/tslist
diff --git a/wearable/TC/tetbuild.cfg b/wearable/TC/tetbuild.cfg
deleted file mode 100644
index f7eda55..0000000
--- a/wearable/TC/tetbuild.cfg
+++ /dev/null
@@ -1,5 +0,0 @@
-TET_OUTPUT_CAPTURE=True # capture option for build operation checking
-TET_BUILD_TOOL=make # build with using make command
-TET_BUILD_FILE=-f Makefile # execution file (Makefile) for build
-TET_API_COMPLIANT=True # use TET API in Test Case ?
-TET_PASS_TC_NAME=True # report passed TC name in Journal file?
diff --git a/wearable/TC/tetclean.cfg b/wearable/TC/tetclean.cfg
deleted file mode 100644
index 02d7030..0000000
--- a/wearable/TC/tetclean.cfg
+++ /dev/null
@@ -1,5 +0,0 @@
-TET_OUTPUT_CAPTURE=True # capture option
-TET_CLEAN_TOOL= make clean # clean tool
-TET_CLEAN_FILE= Makefile # file for clean
-TET_API_COMPLIANT=True # TET API useage 
-TET_PASS_TC_NAME=True # showing name , passed TC
diff --git a/wearable/TC/tetexec.cfg b/wearable/TC/tetexec.cfg
deleted file mode 100644
index ef3e452..0000000
--- a/wearable/TC/tetexec.cfg
+++ /dev/null
@@ -1,5 +0,0 @@
-TET_OUTPUT_CAPTURE=True # capturing execution or not
-TET_EXEC_TOOL=  # ex) exec : execution tool set up/ Optional
-TET_EXEC_FILE=   # ex) exectool : execution file/ Optional
-TET_API_COMPLIANT=True # Test case or Tool usesTET API?
-TET_PASS_TC_NAME=True # showing Passed TC name ?
diff --git a/wearable/bluetooth.manifest b/wearable/bluetooth.manifest
deleted file mode 100644
index 75b0fa5..0000000
--- a/wearable/bluetooth.manifest
+++ /dev/null
@@ -1,5 +0,0 @@
-<manifest>
-    <request>
-        <domain name="_"/>
-    </request>
-</manifest>
diff --git a/wearable/debian/README b/wearable/debian/README
deleted file mode 100644
index e69de29..0000000
--- a/wearable/debian/README
+++ /dev/null
diff --git a/wearable/debian/capi-network-bluetooth-dev.install b/wearable/debian/capi-network-bluetooth-dev.install
deleted file mode 100644
index 761a28b..0000000
--- a/wearable/debian/capi-network-bluetooth-dev.install
+++ /dev/null
@@ -1,4 +0,0 @@
-/usr/include/*
-/usr/include/*/*
-/usr/lib/pkgconfig/*.pc
-
diff --git a/wearable/debian/capi-network-bluetooth-dev.postinst b/wearable/debian/capi-network-bluetooth-dev.postinst
deleted file mode 100644
index 1a24852..0000000
--- a/wearable/debian/capi-network-bluetooth-dev.postinst
+++ /dev/null
@@ -1 +0,0 @@
-#!/bin/sh
diff --git a/wearable/debian/capi-network-bluetooth.install b/wearable/debian/capi-network-bluetooth.install
deleted file mode 100644
index 4a755a4..0000000
--- a/wearable/debian/capi-network-bluetooth.install
+++ /dev/null
@@ -1 +0,0 @@
-/usr/lib/lib*.so*
diff --git a/wearable/debian/capi-network-bluetooth.postinst b/wearable/debian/capi-network-bluetooth.postinst
deleted file mode 100644
index 1a24852..0000000
--- a/wearable/debian/capi-network-bluetooth.postinst
+++ /dev/null
@@ -1 +0,0 @@
-#!/bin/sh
diff --git a/wearable/debian/changelog b/wearable/debian/changelog
deleted file mode 100644
index 10dff27..0000000
--- a/wearable/debian/changelog
+++ /dev/null
@@ -1,496 +0,0 @@
-capi-network-bluetooth (0.1.40-1) unstable; urgency=low
-
-  * Implement bt_reset_adapter API
-  * Git: magnolia/framework/api/bluetooth
-  * Tag: capi-network-bluetooth_0.1.40-1
-
- -- DoHyun Pyun <dh79.pyun@samsung.com>  Mon, 04 Feb 2013 14:20:28 +0900
-
-capi-network-bluetooth (0.1.39-1) unstable; urgency=low
-
-  * Implement bt_reset_adapter API
-  * Git: magnolia/framework/api/bluetooth
-  * Tag: capi-network-bluetooth_0.1.39-1
-
- -- DoHyun Pyun <dh79.pyun@samsung.com>  Sat, 02 Feb 2013 13:42:02 +0900
-
-capi-network-bluetooth (0.1.38-1) unstable; urgency=low
-
-  * Implement bluetooth_nap_disconnect_all API
-  * Git: magnolia/framework/api/bluetooth
-  * Tag: capi-network-bluetooth_0.1.38-1
-
- -- DoHyun Pyun <dh79.pyun@samsung.com>  Mon, 21 Jan 2013 18:33:37 +0900
-
-capi-network-bluetooth (0.1.37-1) unstable; urgency=low
-
-  * Implement GATT API's and Prevent defect fix
-  * Git: magnolia/framework/api/bluetooth
-  * Tag: capi-network-bluetooth_0.1.37-1
-
- -- Chethan T N <chethan.tn@samsung.com>  Tue, 15 Jan 2013 18:16:50 +0530
-
-capi-network-bluetooth (0.1.36-1) unstable; urgency=low
-
-  * Implement AVRCP callback functions
-  * Git: magnolia/framework/api/bluetooth
-  * Tag: capi-network-bluetooth_0.1.36-1
-
- -- DoHyun Pyun <dh79.pyun@samsung.com>  Wed, 28 Nov 2012 10:45:13 +0900
-
-capi-network-bluetooth (0.1.35-1) unstable; urgency=low
-
-  * Add GATT api for BTLE support
-  * Git: magnolia/framework/api/bluetooth
-  * Tag: capi-network-bluetooth_0.1.35-1
-
- -- Chethan T N <chethan.tn@samsung.com>  Fri, 23 Nov 2012 19:15:01 +0900
-
-capi-network-bluetooth (0.1.34-1) unstable; urgency=low
-
-  * Correct the spelling
-  * Git: magnolia/framework/api/bluetooth
-  * Tag: capi-network-bluetooth_0.1.34-1
-
- -- DoHyun Pyun <dh79.pyun@samsung.com>  Wed, 14 Nov 2012 17:16:04 +0900
-
-capi-network-bluetooth (0.1.33-1) unstable; urgency=low
-
-  * Implement bt_ag_is_nrec_enabled API
-  * Git: magnolia/framework/api/bluetooth
-  * Tag: capi-network-bluetooth_0.1.33-1
-
- -- DoHyun Pyun <dh79.pyun@samsung.com>  Wed, 14 Nov 2012 11:33:49 +0900
-
-capi-network-bluetooth (0.1.32-1) unstable; urgency=low
-
-  * Add the duration parameter in bt_adapter_get_visibility
-  * Git: magnolia/framework/api/bluetooth
-  * Tag: capi-network-bluetooth_0.1.32-1
-
- -- DoHyun Pyun <dh79.pyun@samsung.com>  Wed, 07 Nov 2012 17:30:49 +0900
-
-capi-network-bluetooth (0.1.31-1) unstable; urgency=low
-
-  * Update version number
-  * Git: magnolia/framework/api/bluetooth
-  * Tag: capi-network-bluetooth_0.1.31-1
-
- -- Jaekyun Lee <jkyun.lee@samsung.com>  Tue, 06 Nov 2012 17:28:40 +0900
-
-capi-network-bluetooth (0.1.30-1) unstable; urgency=low
-
-  * Implement bt_device_foreach_connected_profiles
-  * Git: slp/api/bluetooth
-  * Tag: capi-network-bluetooth_0.1.30-1
-
- -- DoHyun Pyun <dh79.pyun@samsung.com>  Tue, 06 Nov 2012 16:22:58 +0900
-
-capi-network-bluetooth (0.1.29-1) unstable; urgency=low
-
-  * Fix the build break
-  * Git: slp/api/bluetooth
-  * Tag: capi-network-bluetooth_0.1.29-1
-
- -- DoHyun Pyun <dh79.pyun@samsung.com>  Wed, 17 Oct 2012 14:24:53 +0900
-
-capi-network-bluetooth (0.1.28-1) unstable; urgency=low
-
-  * Add the device events
-  * Git: slp/api/bluetooth
-  * Tag: capi-network-bluetooth_0.1.28-1
-
- -- DoHyun Pyun <dh79.pyun@samsung.com>  Tue, 16 Oct 2012 11:17:10 +0900
-
-capi-network-bluetooth (0.1.27-1) unstable; urgency=low
-
-  * Add license file in each rpm
-  * Git: slp/api/bluetooth
-  * Tag: capi-network-bluetooth_0.1.27-1
-
- -- DoHyun Pyun <dh79.pyun@samsung.com>  Thu, 11 Oct 2012 16:08:24 +0900
-
-capi-network-bluetooth (0.1.26-1) unstable; urgency=low
-
-  * Assign the error code to result
-  * Git: slp/api/bluetooth
-  * Tag: capi-network-bluetooth_0.1.26-1
-
- -- DoHyun Pyun <dh79.pyun@samsung.com>  Wed, 26 Sep 2012 15:00:30 +0900
-
-capi-network-bluetooth (0.1.25-1) unstable; urgency=low
-
-  * Add the address parameter in network connected event
-  * Git: slp/api/bluetooth
-  * Tag: capi-network-bluetooth_0.1.25-1
-
- -- DoHyun Pyun <dh79.pyun@samsung.com>  Wed, 26 Sep 2012 13:09:45 +0900
-
-capi-network-bluetooth (0.1.24-1) unstable; urgency=low
-
-  * Tagging and upload the package
-  * Git: slp/api/bluetooth
-  * Tag: capi-network-bluetooth_0.1.24-1
-
- -- DoHyun Pyun <dh79.pyun@samsung.com>  Tue, 25 Sep 2012 15:11:44 +0900
-
-capi-network-bluetooth (0.1.23-1) unstable; urgency=low
-
-  * Tagging and upload the package
-  * Git: slp/api/bluetooth
-  * Tag: capi-network-bluetooth_0.1.23-1
-
- -- Sangki Park <sangki79.park@samsung.com>  Tue, 25 Sep 2012 10:48:46 +0900
-
-capi-network-bluetooth (0.1.22-1) unstable; urgency=low
-
-  * Apply smack manifest file
-  * slp/api/bluetooth
-  * Tag: capi-network-bluetooth_0.1.22-1
-
- -- Sangki Park <sangki79.park@samsung.com>  Fri, 21 Sep 2012 11:09:41 +0900
-
-capi-network-bluetooth (0.1.21-1) unstable; urgency=low
-
-  * Tagging and upload the package
-  * Git: slp/api/bluetooth
-  * Tag: capi-network-bluetooth_0.1.21-1
-
- -- DoHyun Pyun <dh79.pyun@samsung.com>  Tue, 18 Sep 2012 16:23:52 +0900
-
-capi-network-bluetooth (0.1.20-1) natty; urgency=low
-
-  * Tagging and upload the package
-  * Git: slp/api/bluetooth
-  * Tag: capi-network-bluetooth_0.1.20-1
-
- -- DoHyun Pyun <dh79.pyun@samsung.com>  Tue, 18 Sep 2012 13:52:44 +0900
-
-capi-network-bluetooth (0.1.19-1) unstable; urgency=low
-
-  * Tagging and upload the package
-  * Git: slp/api/bluetooth
-  * Tag: capi-network-bluetooth_0.1.19-1
-
- -- DoHyun Pyun <dh79.pyun@samsung.com>  Mon, 17 Sep 2012 15:31:29 +0900
-
-capi-network-bluetooth (0.1.17-1) unstable; urgency=low
-
-  * Tagging and upload the package
-  * Git: slp/api/bluetooth
-  * Tag: capi-network-bluetooth_0.1.17-1
-
- -- Sangki Park <sangki79.park@samsung.com>  Thu, 13 Sep 2012 12:47:12 +0900
-
-capi-network-bluetooth (0.1.16-1) unstable; urgency=low
-
-  * Tagging and upload the package
-  * Git: slp/api/bluetooth
-  * Tag: capi-network-bluetooth_0.1.16-1
-
- -- Sangki Park <sangki79.park@samsung.com>  Thu, 13 Sep 2012 11:03:33 +0900
-
-capi-network-bluetooth (0.1.15-1) unstable; urgency=low
-
-  * Tagging and upload the package
-  * Git: slp/api/bluetooth
-  * Tag: capi-network-bluetooth_0.1.15-1
-
- -- DoHyun Pyun <dh79.pyun@samsung.com>  Tue, 11 Sep 2012 16:08:53 +0900
-
-capi-network-bluetooth (0.1.14-1) unstable; urgency=low
-
-  * Tagging and upload the package
-  * Git: slp/api/bluetooth
-  * Tag: capi-network-bluetooth_0.1.14-1
-
- -- DoHyun Pyun <dh79.pyun@samsung.com>  Tue, 11 Sep 2012 09:56:47 +0900
-
-capi-network-bluetooth (0.1.13-1) unstable; urgency=low
-
-  * Tagging and upload the package
-  * Git: slp/api/bluetooth
-  * Tag: capi-network-bluetooth_0.1.13-1
-
- -- DoHyun Pyun <dh79.pyun@samsung.com>  Mon, 10 Sep 2012 12:56:50 +0900
-
-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: 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
-
-capi-network-bluetooth (0.1.1-1) unstable; urgency=low
-
-  * Fix the crash in DTS test
-  * 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
-
-capi-network-bluetooth (0.1.0-14) unstable; urgency=low
-
-  * Initialize the pointer to NULL after free
-  * 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
-
-capi-network-bluetooth (0.1.0-13) unstable; urgency=low
-
-  * Correct dependent package
-  * 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
-
-  * 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
-
-capi-network-bluetooth (0.1.0-11) unstable; urgency=low
-
-  * Add versioning of library
-  * 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
-
-  * Clean codes
-  * Git: slp/api/bluetooth
-  * Tag: capi-network-bluetooth_0.1.0-10
-
- -- ByungWoo Lee <bw1212.lee@samsung.com>  Thu, 02 Feb 2012 14:49:58 +0900
-
-capi-network-bluetooth (0.1.0-9) unstable; urgency=low
-
-  * 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>  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 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
-
diff --git a/wearable/debian/compat b/wearable/debian/compat
deleted file mode 100644
index 7ed6ff8..0000000
--- a/wearable/debian/compat
+++ /dev/null
@@ -1 +0,0 @@
-5
diff --git a/wearable/debian/control b/wearable/debian/control
deleted file mode 100644
index 7299ecb..0000000
--- a/wearable/debian/control
+++ /dev/null
@@ -1,21 +0,0 @@
-Source: capi-network-bluetooth
-Section: libs
-Priority: extra
-Maintainer: Kangho Hur <kangho.hur@samsung.com>, ByungWoo Lee <bw1212.lee@samsung.com>
-Build-Depends: debhelper (>= 5), dlog-dev, capi-base-common-dev, libglib2.0-dev, libbluetooth-frwk-dev
-
-Package: capi-network-bluetooth
-Architecture: any
-Depends: ${shlibs:Depends}, ${misc:Depends}
-Description: A Network Bluetooth library in Tizen Native API
-
-Package: capi-network-bluetooth-dev
-Architecture: any
-Depends: ${shlibs:Depends}, ${misc:Depends}, capi-network-bluetooth (= ${Source-Version}), capi-base-common-dev
-Description: A Network Bluetooth library in Tizen Native API (DEV)
-
-Package: capi-network-bluetooth-dbg
-Architecture: any
-Depends: ${shlibs:Depends}, ${misc:Depends}, capi-network-bluetooth (= ${Source-Version})
-Description: A Network Bluetooth library in Tizen Native API (DBG)
-
diff --git a/wearable/debian/rules b/wearable/debian/rules
deleted file mode 100755
index 9736f8b..0000000
--- a/wearable/debian/rules
+++ /dev/null
@@ -1,68 +0,0 @@
-#!/usr/bin/make -f
-
-FULLVER ?= $(shell dpkg-parsechangelog | grep Version: | cut -d ' ' -f 2 | cut -d '-' -f 1)
-MAJORVER ?= $(shell echo $(FULLVER) | cut -d '.' -f 1)
-
-CFLAGS = -Wall -g
-
-ifneq (,$(findstring noopt,$(DEB_BUILD_OPTIONS)))
-	CFLAGS += -O0
-else
-	CFLAGS += -O2
-endif
-CMAKE_ROOT_DIR ?= $(CURDIR)
-CMAKE_BUILD_DIR ?= $(CURDIR)/cmake_build_tmp
-
-configure: configure-stamp
-configure-stamp:
-	dh_testdir
-	mkdir -p $(CMAKE_BUILD_DIR) && cd $(CMAKE_BUILD_DIR) && cmake .. -DFULLVER=${FULLVER} -DMAJORVER=${MAJORVER}
-	touch configure-stamp
-
-
-build: build-stamp
-build-stamp: configure-stamp 
-	dh_testdir
-	cd $(CMAKE_BUILD_DIR) && $(MAKE)
-	touch $@
-
-clean:
-	cd $(CMAKE_ROOT_DIR)
-	dh_testdir
-	dh_testroot
-	rm -f build-stamp configure-stamp
-	rm -f `find . -name *.pc`
-	rm -rf $(CMAKE_BUILD_DIR)
-	dh_clean
-	
-install: build
-	dh_testdir
-	dh_testroot
-	dh_clean -k 
-	dh_installdirs
-
-	cd $(CMAKE_BUILD_DIR) && $(MAKE) DESTDIR=$(CURDIR)/debian/tmp install
-
-binary-indep: build install
-
-binary-arch: build install
-	dh_testdir
-	dh_testroot
-	dh_installchangelogs 
-	dh_installdocs
-	dh_installexamples
-	dh_install --sourcedir=debian/tmp
-	dh_installman
-	dh_link
-	dh_strip --dbg-package=capi-network-bluetooth-dbg
-	dh_fixperms
-	dh_makeshlibs
-	dh_installdeb
-	dh_shlibdeps
-	dh_gencontrol
-	dh_md5sums
-	dh_builddeb
-
-binary: binary-indep binary-arch
-.PHONY: build clean binary-indep binary-arch binary install configure
-
diff --git a/wearable/include/bluetooth.h b/wearable/include/bluetooth.h
deleted file mode 100755
index 67b9020..0000000
--- a/wearable/include/bluetooth.h
+++ /dev/null
@@ -1,4844 +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.
- */
-
-
-#ifndef __TIZEN_NETWORK_BLUETOOTH_H__
-#define __TIZEN_NETWORK_BLUETOOTH_H__
-
-#include <stdlib.h>
-#include <unistd.h>
-#include <stdbool.h>
-#include <tizen_error.h>
-#include <glib.h>
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif /* __cplusplus */
-
-/**
- * @file        bluetooth.h
- * @brief       API to control the Bluetooth adapter and devices and communications.
- * @ingroup     CAPI_NETWORK_BLUETOOTH_MODULE
- */
-
-
-/**
- * @addtogroup CAPI_NETWORK_BLUETOOTH_MODULE
- * @{
- */
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE
- * @brief  Enumerations of connected Bluetooth device event role.
- */
-typedef enum
-{
-	BT_SOCKET_UNKNOWN = 0x00, /**< Unknown role*/
-	BT_SOCKET_SERVER , /**< Server role*/
-	BT_SOCKET_CLIENT, /**< Client role*/
-} bt_socket_role_e;
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_MODULE
- * @brief Enumerations of Bluetooth error codes.
- */
-typedef enum
-{
-	BT_ERROR_NONE = TIZEN_ERROR_NONE, /**< Successful*/
-	BT_ERROR_CANCELLED = TIZEN_ERROR_CANCELED, /**< Operation cancelled */
-	BT_ERROR_INVALID_PARAMETER = TIZEN_ERROR_INVALID_PARAMETER, /**< Invalid parameter */
-	BT_ERROR_OUT_OF_MEMORY = TIZEN_ERROR_OUT_OF_MEMORY, /**< Out of memory */
-	BT_ERROR_RESOURCE_BUSY = TIZEN_ERROR_RESOURCE_BUSY, /**< Device or resource busy */
-	BT_ERROR_TIMED_OUT = TIZEN_ERROR_TIMED_OUT, /**< Timeout error */
-	BT_ERROR_NOW_IN_PROGRESS = TIZEN_ERROR_NOW_IN_PROGRESS, /**< Operation now in progress */
-	BT_ERROR_NOT_INITIALIZED = TIZEN_ERROR_NETWORK_CLASS|0x0101, /**< Local adapter not initialized */
-	BT_ERROR_NOT_ENABLED = TIZEN_ERROR_NETWORK_CLASS|0x0102, /**< Local adapter not enabled */
-	BT_ERROR_ALREADY_DONE = TIZEN_ERROR_NETWORK_CLASS|0x0103, /**< Operation already done  */
-	BT_ERROR_OPERATION_FAILED = TIZEN_ERROR_NETWORK_CLASS|0x0104, /**< Operation failed */
-	BT_ERROR_NOT_IN_PROGRESS = TIZEN_ERROR_NETWORK_CLASS|0x0105, /**< Operation not in progress */
-	BT_ERROR_REMOTE_DEVICE_NOT_BONDED = TIZEN_ERROR_NETWORK_CLASS|0x0106, /**< Remote device not bonded */
-	BT_ERROR_AUTH_REJECTED = TIZEN_ERROR_NETWORK_CLASS|0x0107, /**< Authentication rejected */
-	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_PERMISSION_DENIED = TIZEN_ERROR_NETWORK_CLASS|0x010C, /**< Permission denied */
-	BT_ERROR_SERVICE_NOT_FOUND = TIZEN_ERROR_NETWORK_CLASS|0x010D, /**< Service Not Found */
-} bt_error_e;
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief  Enumerations of the Bluetooth adapter state.
- */
-typedef enum
-{
-	BT_ADAPTER_DISABLED = 0x00, /**< Bluetooth adapter is disabled */
-	BT_ADAPTER_ENABLED, /**< Bluetooth adapter is enabled */
-} bt_adapter_state_e;
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief Enumerations of the Bluetooth visibility mode.
- */
-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,
-							    it is changed to #BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE.*/
-} bt_adapter_visibility_mode_e;
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief Enumerations of the discovery state of Bluetooth device.
- *
- */
-typedef enum
-{
-	BT_ADAPTER_DEVICE_DISCOVERY_STARTED, /**< Device discovery is started */
-	BT_ADAPTER_DEVICE_DISCOVERY_FINISHED, /**< Device discovery is finished */
-	BT_ADAPTER_DEVICE_DISCOVERY_FOUND, /**< The remote Bluetooth device is found */
-} bt_adapter_device_discovery_state_e;
-
-typedef enum
-{
-	BT_ADAPTER_DEVICE_DISCOVERY_BREDR = 0x01, /**< Device discovery for BREDR devices only */
-	BT_ADAPTER_DEVICE_DISCOVERY_LE, /**< Device discovery for LE devices only */
-	BT_ADAPTER_DEVICE_DISCOVERY_LE_BREDR, /**< Device discovery for both LE and BREDR devices */
-} bt_adapter_discover_devices_type_e;
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
- * @brief Enumerations of device disconnect reason.
- */
-typedef enum
-{
-	BT_DEVICE_DISCONNECT_REASON_UNKNOWN,
-	BT_DEVICE_DISCONNECT_REASON_TIMEOUT,
-	BT_DEVICE_DISCONNECT_REASON_LOCAL_HOST,
-	BT_DEVICE_DISCONNECT_REASON_REMOTE,
-} bt_device_disconnect_reason_e;
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
- * @brief Enumerations of device authorization state.
- */
-typedef enum
-{
-	BT_DEVICE_AUTHORIZED, /**< The remote Bluetooth device is authorized */
-	BT_DEVICE_UNAUTHORIZED, /**< The remote Bluetooth device is unauthorized */
-} bt_device_authorization_e;
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
- * @brief Enumerations of Bluetooth profile.
- */
-typedef enum
-{
-    BT_PROFILE_RFCOMM = 0x01, /**< RFCOMM Profile */
-    BT_PROFILE_A2DP = 0x02, /**< Advanced Audio Distribution Profile */
-    BT_PROFILE_HSP = 0x04, /**< Headset Profile */
-    BT_PROFILE_HID = 0x08, /**< Human Interface Device Profile */
-    BT_PROFILE_NAP = 0x10, /**< Network Access Point Profile */
-    BT_PROFILE_AG = 0x20, /**< Audio Gateway Profile */
-    BT_PROFILE_GATT = 0x40, /**< Generic Attribute Profile */
-} bt_profile_e;
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE
- * @brief  Enumerations of Bluetooth socket connection state.
- */
-typedef enum
-{
-	BT_SOCKET_CONNECTED, /**< RFCOMM is connected */
-	BT_SOCKET_DISCONNECTED, /**< RFCOMM is disconnected */
-} bt_socket_connection_state_e;
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
- * @brief  Enumerations of major service class.
- */
-typedef enum
-{
-	BT_MAJOR_SERVICE_CLASS_LIMITED_DISCOVERABLE_MODE  = 0x002000, /**< Limited discoverable mode */
-	BT_MAJOR_SERVICE_CLASS_POSITIONING                = 0x010000, /**< Positioning class */
-	BT_MAJOR_SERVICE_CLASS_NETWORKING                 = 0x020000, /**< Networking class */
-	BT_MAJOR_SERVICE_CLASS_RENDERING                  = 0x040000, /**< Rendering class */
-	BT_MAJOR_SERVICE_CLASS_CAPTURING                  = 0x080000, /**< Capturing class */
-	BT_MAJOR_SERVICE_CLASS_OBJECT_TRANSFER            = 0x100000, /**< Object transferring class */
-	BT_MAJOR_SERVICE_CLASS_AUDIO                      = 0x200000, /**< Audio class*/
-	BT_MAJOR_SERVICE_CLASS_TELEPHONY                  = 0x400000, /**< Telephony class */
-	BT_MAJOR_SERVICE_CLASS_INFORMATION                = 0x800000, /**< Information class */
-} bt_major_service_class_e;
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
- * @brief  Enumerations of major device class.
- */
-typedef enum
-{
-	BT_MAJOR_DEVICE_CLASS_MISC = 0x00, /**< Miscellaneous major device class*/
-	BT_MAJOR_DEVICE_CLASS_COMPUTER = 0x01, /**< Computer major device class */
-	BT_MAJOR_DEVICE_CLASS_PHONE = 0x02, /**< Phone major device class */
-	BT_MAJOR_DEVICE_CLASS_LAN_NETWORK_ACCESS_POINT = 0x03, /**< LAN/Network access point major device class */
-	BT_MAJOR_DEVICE_CLASS_AUDIO_VIDEO = 0x04, /**< Audio/Video major device class */
-	BT_MAJOR_DEVICE_CLASS_PERIPHERAL = 0x05, /**< Peripheral major device class */
-	BT_MAJOR_DEVICE_CLASS_IMAGING = 0x06, /**< Imaging major device class */
-	BT_MAJOR_DEVICE_CLASS_WEARABLE = 0x07, /**< Wearable device class */
-	BT_MAJOR_DEVICE_CLASS_TOY = 0x08, /**< Toy device class */
-	BT_MAJOR_DEVICE_CLASS_HEALTH = 0x09, /**< Health device class */
-	BT_MAJOR_DEVICE_CLASS_UNCATEGORIZED = 0x1F, /**< Uncategorized major device class */
-} bt_major_device_class_e;
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
- * @brief  Enumerations of minor device class.
- */
-typedef enum
-{
-	BT_MINOR_DEVICE_CLASS_COMPUTER_UNCATEGORIZED = 0x00, /**< Uncategorized minor device class of computer */
-	BT_MINOR_DEVICE_CLASS_COMPUTER_DESKTOP_WORKSTATION = 0x04, /**< Desktop workstation minor device class of computer */
-	BT_MINOR_DEVICE_CLASS_COMPUTER_SERVER_CLASS = 0x08, /**< Server minor device class of computer */
-	BT_MINOR_DEVICE_CLASS_COMPUTER_LAPTOP = 0x0C, /**< Laptop minor device class of computer */
-	BT_MINOR_DEVICE_CLASS_COMPUTER_HANDHELD_PC_OR_PDA = 0x10, /**< Handheld PC/PDA minor device class of computer */
-	BT_MINOR_DEVICE_CLASS_COMPUTER_PALM_SIZED_PC_OR_PDA = 0x14, /**< Palm sized PC/PDA minor device class of computer */
-	BT_MINOR_DEVICE_CLASS_COMPUTER_WEARABLE_COMPUTER = 0x18, /**< Wearable(watch sized) minor device class of computer */
-
-	BT_MINOR_DEVICE_CLASS_PHONE_UNCATEGORIZED = 0x00, /**< Uncategorized minor device class of phone */
-	BT_MINOR_DEVICE_CLASS_PHONE_CELLULAR = 0x04, /**< Cellular minor device class of phone */
-	BT_MINOR_DEVICE_CLASS_PHONE_CORDLESS = 0x08, /**< Cordless minor device class of phone */
-	BT_MINOR_DEVICE_CLASS_PHONE_SMART_PHONE = 0x0C, /**< Smart phone minor device class of phone */
-	BT_MINOR_DEVICE_CLASS_PHONE_WIRED_MODEM_OR_VOICE_GATEWAY = 0x10, /**< Wired modem or voice gateway minor device class of phone */
-	BT_MINOR_DEVICE_CLASS_PHONE_COMMON_ISDN_ACCESS = 0x14, /**< Common ISDN minor device class of phone */
-
-	BT_MINOR_DEVICE_CLASS_LAN_NETWORK_ACCESS_POINT_FULLY_AVAILABLE = 0x04, /**< Fully available minor device class of LAN/Network access point */
-	BT_MINOR_DEVICE_CLASS_LAN_NETWORK_ACCESS_POINT_1_TO_17_PERCENT_UTILIZED = 0x20, /**< 1-17% utilized minor device class of LAN/Network access point */
-	BT_MINOR_DEVICE_CLASS_LAN_NETWORK_ACCESS_POINT_17_TO_33_PERCENT_UTILIZED = 0x40, /**< 17-33% utilized minor device class of LAN/Network access point */
-	BT_MINOR_DEVICE_CLASS_LAN_NETWORK_ACCESS_POINT_33_TO_50_PERCENT_UTILIZED = 0x60, /**< 33-50% utilized minor device class of LAN/Network access point */
-	BT_MINOR_DEVICE_CLASS_LAN_NETWORK_ACCESS_POINT_50_to_67_PERCENT_UTILIZED = 0x80, /**< 50-67% utilized minor device class of LAN/Network access point */
-	BT_MINOR_DEVICE_CLASS_LAN_NETWORK_ACCESS_POINT_67_TO_83_PERCENT_UTILIZED = 0xA0, /**< 67-83% utilized minor device class of LAN/Network access point */
-	BT_MINOR_DEVICE_CLASS_LAN_NETWORK_ACCESS_POINT_83_TO_99_PERCENT_UTILIZED = 0xC0, /**< 83-99% utilized minor device class of LAN/Network access point */
-	BT_MINOR_DEVICE_CLASS_LAN_NETWORK_ACCESS_POINT_NO_SERVICE_AVAILABLE = 0xE0, /**< No service available minor device class of LAN/Network access point */
-
-	BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_UNCATEGORIZED = 0x00, /**< Uncategorized minor device class of audio/video */
-	BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_WEARABLE_HEADSET = 0x04, /**< Wearable headset minor device class of audio/video */
-	BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_HANDS_FREE = 0x08, /**< Hands-free minor device class of audio/video */
-	BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_MICROPHONE = 0x10, /**< Microphone minor device class of audio/video */
-	BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_LOUDSPEAKER = 0x14, /**< Loudspeaker minor device class of audio/video */
-	BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_HEADPHONES = 0x18, /**< Headphones minor device class of audio/video */
-	BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_PORTABLE_AUDIO = 0x1C, /**< Portable audio minor device class of audio/video */
-	BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_CAR_AUDIO = 0x20, /**< Car audio minor device class of audio/video */
-	BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_SET_TOP_BOX = 0x24, /**< Set-top box minor device class of audio/video */
-	BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_HIFI_AUDIO_DEVICE = 0x28, /**< Hifi audio minor device class of audio/video */
-	BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_VCR = 0x2C, /**< VCR minor device class of audio/video */
-	BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_VIDEO_CAMERA = 0x30, /**< Video camera minor device class of audio/video */
-	BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_CAMCORDER = 0x34, /**< Camcorder minor device class of audio/video */
-	BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_VIDEO_MONITOR = 0x38, /**< Video monitor minor device class of audio/video */
-	BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_VIDEO_DISPLAY_LOUDSPEAKER = 0x3C, /**< Video display and loudspeaker minor device class of audio/video */
-	BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_VIDEO_CONFERENCING = 0x40, /**< Video conferencing minor device class of audio/video */
-	BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_GAMING_TOY = 0x48, /**< Gaming/toy minor device class of audio/video */
-
-	BT_MINOR_DEVICE_CLASS_PERIPHERA_UNCATEGORIZED = 0x00, /**< Uncategorized minor device class of peripheral */
-	BT_MINOR_DEVICE_CLASS_PERIPHERAL_KEY_BOARD = 0x40, /**< Key board minor device class of peripheral */
-	BT_MINOR_DEVICE_CLASS_PERIPHERAL_POINTING_DEVICE = 0x80, /**< Pointing device minor device class of peripheral */
-	BT_MINOR_DEVICE_CLASS_PERIPHERAL_COMBO_KEYBOARD_POINTING_DEVICE = 0xC0, /**< Combo keyboard or pointing device minor device class of peripheral */
-	BT_MINOR_DEVICE_CLASS_PERIPHERAL_JOYSTICK = 0x04, /**< Joystick minor device class of peripheral */
-	BT_MINOR_DEVICE_CLASS_PERIPHERAL_GAME_PAD = 0x08, /**< Game pad minor device class of peripheral */
-	BT_MINOR_DEVICE_CLASS_PERIPHERAL_REMOTE_CONTROL = 0x0C, /**< Remote control minor device class of peripheral */
-	BT_MINOR_DEVICE_CLASS_PERIPHERAL_SENSING_DEVICE = 0x10, /**< Sensing device minor device class of peripheral */
-	BT_MINOR_DEVICE_CLASS_PERIPHERAL_DIGITIZER_TABLET = 0x14, /**< Digitizer minor device class of peripheral */
-	BT_MINOR_DEVICE_CLASS_PERIPHERAL_CARD_READER = 0x18, /**< Card reader minor device class of peripheral */
-	BT_MINOR_DEVICE_CLASS_PERIPHERAL_DIGITAL_PEN = 0x1C, /**< Digital pen minor device class of peripheral */
-	BT_MINOR_DEVICE_CLASS_PERIPHERAL_HANDHELD_SCANNER = 0x20, /**< Handheld scanner minor device class of peripheral */
-	BT_MINOR_DEVICE_CLASS_PERIPHERAL_HANDHELD_GESTURAL_INPUT_DEVICE = 0x24, /**< Handheld gestural input device minor device class of peripheral */
-
-	BT_MINOR_DEVICE_CLASS_IMAGING_DISPLAY = 0x10, /**< Display minor device class of imaging */
-	BT_MINOR_DEVICE_CLASS_IMAGING_CAMERA = 0x20, /**< Camera minor device class of imaging */
-	BT_MINOR_DEVICE_CLASS_IMAGING_SCANNER = 0x40, /**< Scanner minor device class of imaging */
-	BT_MINOR_DEVICE_CLASS_IMAGING_PRINTER = 0x80, /**< Printer minor device class of imaging */
-
-	BT_MINOR_DEVICE_CLASS_WEARABLE_WRIST_WATCH = 0x04, /**< Wrist watch minor device class of wearable */
-	BT_MINOR_DEVICE_CLASS_WEARABLE_PAGER = 0x08, /**< Pager minor device class of wearable */
-	BT_MINOR_DEVICE_CLASS_WEARABLE_JACKET = 0x0C, /**< Jacket minor device class of wearable */
-	BT_MINOR_DEVICE_CLASS_WEARABLE_HELMET = 0x10, /**< Helmet minor device class of wearable */
-	BT_MINOR_DEVICE_CLASS_WEARABLE_GLASSES = 0x14, /**< Glasses minor device class of wearable */
-
-	BT_MINOR_DEVICE_CLASS_TOY_ROBOT = 0x04, /**< Robot minor device class of toy */
-	BT_MINOR_DEVICE_CLASS_TOY_VEHICLE = 0x08, /**< Vehicle minor device class of toy */
-	BT_MINOR_DEVICE_CLASS_TOY_DOLL_ACTION = 0x0C, /**< Doll/Action minor device class of toy */
-	BT_MINOR_DEVICE_CLASS_TOY_CONTROLLER = 0x10, /**< Controller minor device class of toy */
-	BT_MINOR_DEVICE_CLASS_TOY_GAME = 0x14, /**< Game minor device class of toy */
-
-	BT_MINOR_DEVICE_CLASS_HEATH_UNCATEGORIZED = 0x00, /**< Uncategorized minor device class of health */
-	BT_MINOR_DEVICE_CLASS_HEATH_BLOOD_PRESSURE_MONITOR = 0x04, /**< Blood pressure monitor minor device class of health */
-	BT_MINOR_DEVICE_CLASS_HEATH_THERMOMETER = 0x08, /**< Thermometer minor device class of health */
-	BT_MINOR_DEVICE_CLASS_HEATH_WEIGHING_SCALE = 0x0C, /**< Weighing scale minor device class of health */
-	BT_MINOR_DEVICE_CLASS_HEATH_GLUCOSE_METER = 0x10, /**< Glucose minor device class of health */
-	BT_MINOR_DEVICE_CLASS_HEATH_PULSE_OXIMETER = 0x14, /**< Pulse oximeter minor device class of health */
-	BT_MINOR_DEVICE_CLASS_HEATH_HEART_PULSE_RATE_MONITOR = 0x18, /**< Heart/Pulse rate monitor minor device class of health */
-	BT_MINOR_DEVICE_CLASS_HEATH_DATA_DISPLAY = 0x1C, /**< Health data display minor device class of health */
-	BT_MINOR_DEVICE_CLASS_HEATH_STEP_COUNTER = 0x20, /**< Step counter minor device class of health */
-	BT_MINOR_DEVICE_CLASS_HEATH_BODY_COMPOSITION_ANALYZER = 0x24, /**< Body composition analyzer minor device class of health */
-	BT_MINOR_DEVICE_CLASS_HEATH_PEAK_FLOW_MONITOR = 0x28, /**< Peak flow monitor minor device class of health */
-	BT_MINOR_DEVICE_CLASS_HEATH_MEDICATION_MONITOR = 0x2C, /**< Medication monitor minor device class of health */
-	BT_MINOR_DEVICE_CLASS_HEATH_KNEE_PROSTHESIS = 0x30, /**< Knee prosthesis minor device class of health */
-	BT_MINOR_DEVICE_CLASS_HEATH_ANKLE_PROSTHESIS = 0x34, /**< Ankle prosthesis minor device class of health */
-} 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_AG,  /**< AG(Audio Gateway) */
-} 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_AUDIO_AG_MODULE
- * @brief  Enumerations for the call state
- */
-typedef enum {
-    BT_AG_CALL_EVENT_IDLE = 0x00,  /**< Idle */
-    BT_AG_CALL_EVENT_ANSWERED,  /**< Answered */
-    BT_AG_CALL_EVENT_HELD,  /**< Held */
-    BT_AG_CALL_EVENT_RETRIEVED,  /**< Retrieved */
-    BT_AG_CALL_EVENT_DIALING,  /**< Dialing */
-    BT_AG_CALL_EVENT_ALERTING,  /**< Alerting */
-    BT_AG_CALL_EVENT_INCOMING,  /**< Incoming */
-} bt_ag_call_event_e;
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
- * @brief  Enumerations for the call state
- */
-typedef enum {
-    BT_AG_CALL_STATE_IDLE = 0x00,  /**< Idle state */
-    BT_AG_CALL_STATE_ACTIVE,  /**< Active state */
-    BT_AG_CALL_STATE_HELD,  /**< Held state */
-    BT_AG_CALL_STATE_DIALING,  /**< Dialing state */
-    BT_AG_CALL_STATE_ALERTING,  /**< Alerting state */
-    BT_AG_CALL_STATE_INCOMING,  /**< Incoming state */
-    BT_AG_CALL_STATE_WAITING,  /**< Waiting for connected indication event after answering an incoming call*/
-} bt_ag_call_state_e;
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
- * @brief  Enumerations for the call handling event
- */
-typedef enum {
-    BT_AG_CALL_HANDLING_EVENT_ANSWER = 0x00,  /**< Request to answer an incoming call */
-    BT_AG_CALL_HANDLING_EVENT_RELEASE,  /**< Request to release a call */
-    BT_AG_CALL_HANDLING_EVENT_REJECT,  /**< Request to reject an incoming call */
-} bt_ag_call_handling_event_e;
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_HF_MODULE
- * @brief  Enumerations for the call handling event
- */
-typedef enum {
-    BT_HF_CALL_HANDLING_EVENT_ANSWER = 0x00,  /**< Request to answer an incoming call */
-    BT_HF_CALL_HANDLING_EVENT_RELEASE,  /**< Request to release a call */
-    BT_HF_CALL_HANDLING_EVENT_REJECT,  /**< Request to reject an incoming call */
-    BT_HF_CALL_HANDLING_EVENT_RING,  /**< Request of ringing call */
-    BT_HF_CALL_HANDLING_EVENT_CALL_STARTED,  /**< Request of Call started */
-    BT_HF_CALL_HANDLING_EVENT_CALL_ENDED,  /**< Request of Call Ended */
-    BT_HF_CALL_HANDLING_EVENT_VOICE_RECOGNITION_ENABLED,  /**< Request of voice recognition enabled */
-    BT_HF_CALL_HANDLING_EVENT_VOICE_RECOGNITION_DISABLED,  /**< Request of voice recognition disabled */
-    BT_HF_CALL_HANDLING_EVENT_VENDOR_DEP_CMD,  /**< Request of Vendor command */
-} bt_hf_call_handling_event_e;
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
- * @brief  Enumerations for the multi call handling event
- */
-typedef enum {
-    BT_AG_MULTI_CALL_HANDLING_EVENT_RELEASE_HELD_CALLS = 0x00,  /**< Request to release held calls */
-    BT_AG_MULTI_CALL_HANDLING_EVENT_RELEASE_ACTIVE_CALLS,  /**< Request to release active calls */
-    BT_AG_MULTI_CALL_HANDLING_EVENT_ACTIVATE_HELD_CALL,  /**< Request to put active calls into hold state and activate another (held or waiting) call */
-    BT_AG_MULTI_CALL_HANDLING_EVENT_MERGE_CALLS,  /**< Request to add a held call to the conversation */
-    BT_AG_MULTI_CALL_HANDLING_EVENT_EXPLICIT_CALL_TRANSFER,  /**< Request to let a user who has two calls to connect these two calls together and release its connections to both other parties */
-} bt_ag_multi_call_handling_event_e;
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_HF_MODULE
- * @brief  Enumerations for the multi call handling event
- */
-typedef enum {
-    BT_HF_MULTI_CALL_HANDLING_EVENT_RELEASE_HELD_CALLS = 0x00,  /**< Request to release held calls */
-    BT_HF_MULTI_CALL_HANDLING_EVENT_RELEASE_ACTIVE_CALLS,  /**< Request to release active calls */
-    BT_HF_MULTI_CALL_HANDLING_EVENT_ACTIVATE_HELD_CALL,  /**< Request to put active calls into hold state and activate another (held or waiting) call */
-    BT_HF_MULTI_CALL_HANDLING_EVENT_MERGE_CALLS,  /**< Request to add a held call to the conversation */
-    BT_HF_MULTI_CALL_HANDLING_EVENT_EXPLICIT_CALL_TRANSFER,  /**< Request to let a user who has two calls to connect these two calls together and release its connections to both other parties */
-} bt_hf_multi_call_handling_event_e;
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_HF_MODULE
- * @brief  Enumerations for the call state
- */
-typedef enum {
-    BT_HF_CALL_EVENT_IDLE = 0x00,  /**< Idle */
-    BT_HF_CALL_EVENT_ANSWER,  /**< Answered */
-    BT_HF_CALL_EVENT_HOLD,  /**< Held */
-    BT_HF_CALL_EVENT_RETRIEVE,  /**< Retrieved */
-    BT_HF_CALL_EVENT_DIAL,  /**< Dialing */
-    BT_HF_CALL_EVENT_ALERT,  /**< Alerting */
-    BT_HF_CALL_EVENT_INCOMING,  /**< Incoming */
-    BT_HF_CALL_EVENT_REDIAL,  /**< Redialling */
-    BT_HF_CALL_EVENT_RELEASE_ALL_NONACTIVE_CALLS,  /**< Release all nonactive calls */
-    BT_HF_CALL_EVENT_ACCEPT_AND_RELEASE,  /**< Accept and Release */
-    BT_HF_CALL_EVENT_ACCEPT_AND_HOLD,  /**< Accept and Hold */
-    BT_HF_CALL_EVENT_ADD_TO_CONVERSATION,  /**< Add to the conversation */
-} bt_hf_call_event_e;
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
- * @brief  The handle of calls state
- */
-typedef void* bt_call_list_h;
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_GATT_MODULE
- * @brief  The attribute handle of GATT(Generic Attribute Profile)
- */
-typedef void* bt_gatt_attribute_h;
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
- * @brief Class structure of device and service.
- *
- * @see #bt_device_info_s
- * @see #bt_adapter_device_discovery_info_s
- * @see bt_device_bond_created_cb()
- * @see bt_adapter_device_discovery_state_changed_cb()
- */
-typedef struct
-{
-	bt_major_device_class_e major_device_class;	/**< Major device class. */
-	bt_minor_device_class_e minor_device_class;	/**< Minor device class. */
-	int major_service_class_mask;	/**< Major service class mask.
-	This value can be a combination of #bt_major_service_class_e like #BT_MAJOR_SERVICE_CLASS_RENDERING | #BT_MAJOR_SERVICE_CLASS_AUDIO */
-} bt_class_s;
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief Structure of device discovery information.
- *
- * @see #bt_class_s
- * @see bt_adapter_device_discovery_state_changed_cb()
- */
-typedef struct
-{
-	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;
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
- * @brief Device information structure used for identifying pear device.
- *
- * @see #bt_class_s
- * @see bt_device_bond_created_cb()
- */
-typedef struct
-{
-	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 */
-	int service_count;	/**< The number of services */
-	bool is_bonded;	/**< The bonding state */
-	bool is_connected;	/**< The connection state */
-	bool is_authorized;	/**< The authorization state */
-} bt_device_info_s;
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
- * @brief Service Discovery Protocol (SDP) data structure.
- *
- * @details This protocol is used for discovering available services or pear device,
- * and finding one to connect with.
- *
- * @see bt_device_service_searched_cb()
- */
-typedef struct
-{
-	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;
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE
- *
- * @brief Rfcomm connection data used for exchanging data between Bluetooth devices.
- *
- * @see bt_socket_connection_state_changed_cb()
- */
-typedef struct
-{
-	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 *service_uuid;	/**< The service UUId */
-} bt_socket_connection_s;
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE
- *
- * @brief Structure of RFCOMM received data.
- *
- * @remarks User can use standard linux functions for reading/writing
- * data from/to sockets.
- *
- * @see bt_socket_data_received_cb()
- */
-typedef struct
-{
-	int socket_fd;	/**< The socket fd */
-	int data_size;	/**< The length of the received data */
-	char *data;	/**< The received data */
-} bt_socket_received_data_s;
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief  Called when the Bluetooth adapter state changes.
- * @param[in]   result  The result of the adapter state changing
- * @param[in]   adapter_state  The adapter state to be changed
- * @param[in]   user_data  The user data passed from the callback registration function
- * @pre Either bt_adapter_enable() or bt_adapter_disable() will invoke this callback if you register this callback using bt_adapter_set_state_changed_cb().
- * @see bt_adapter_enable()
- * @see bt_adapter_disable()
- * @see bt_adapter_set_state_changed_cb()
- * @see bt_adapter_unset_state_changed_cb()
- */
-typedef void (*bt_adapter_state_changed_cb)(int result, bt_adapter_state_e adapter_state, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief  Called when adapter name changes.
- * @param[in]   device_name	The name of the Bluetooth device to be changed
- * @param[in]   user_data	The user data passed from the callback registration function
- * @pre This function will be invoked when the name of Bluetooth adapter changes
- * if you register this callback using bt_adapter_set_name_changed_cb().
- * @see bt_adapter_set_name()
- * @see bt_adapter_set_name_changed_cb()
- * @see bt_adapter_unset_name_changed_cb()
- */
-typedef void (*bt_adapter_name_changed_cb)(char *device_name, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief  Called when the visibility mode changes.
- * @param[in] result The result of the visibility mode changing
- * @param[in] visibility_mode The visibility mode to be changed
- * @param[in] user_data The user data passed from the callback registration function
- *
- * @pre This function will be invoked when the visibility of Bluetooth adapter changes
- * if you register this callback using bt_adapter_set_visibility_mode_changed_cb().
- *
- * @see bt_adapter_set_visibility()
- * @see bt_adapter_set_visibility_mode_changed_cb()
- * @see bt_adapter_unset_visibility_mode_changed_cb()
- */
-typedef void (*bt_adapter_visibility_mode_changed_cb)
-	(int result, bt_adapter_visibility_mode_e visibility_mode, void *user_data);
-
-/**
- * @ingroup  CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief  Called every second until the visibility mode is changed to #BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE.
- * @remarks  This callback function is called only if visibility mode is #BT_ADAPTER_VISIBILITY_MODE_LIMITED_DISCOVERABLE.
- * @param[in]  duration  The duration until the visibility mode is changed to #BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE (in seconds)
- * @param[in]  user_data  The user data passed from the callback registration function
- * @pre  This function will be invoked if you register this callback using bt_adapter_set_visibility_duration_changed_cb().
- * @see  bt_adapter_set_visibility_duration_changed_cb()
- * @see  bt_adapter_unset_visibility_duration_changed_cb()
- * @see  bt_adapter_set_visibility()
- */
-typedef void (*bt_adapter_visibility_duration_changed_cb)(int duration, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief  Called when the state of device discovery changes.
- *
- * @remarks If \a discovery_state is #BT_ADAPTER_DEVICE_DISCOVERY_FOUND,
- * then you can get some information, such as remote device address, remote device name, rssi, and bonding state.
- *
- * @param[in] result The result of the device discovery
- * @param[in] discovery_state The discovery state to be changed
- * @param[in] device_info The information of the discovered device \n
- *					If \a discovery_state is #BT_ADAPTER_DEVICE_DISCOVERY_STARTED or
- * #BT_ADAPTER_DEVICE_DISCOVERY_FINISHED, then \a device_info is NULL.
- * @param[in] user_data The user data passed from the callback registration function
- *
- * @pre Either bt_adapter_start_device_discovery() or bt_adapter_stop_device_discovery() will invoke this function
- * if you register this callback using bt_adapter_set_device_discovery_state_changed_cb().
- *
- * @see bt_adapter_start_device_discovery()
- * @see bt_adapter_stop_device_discovery()
- * @see bt_adapter_set_device_discovery_state_changed_cb()
- * @see bt_adapter_unset_device_discovery_state_changed_cb()
- *
- */
-typedef void (*bt_adapter_device_discovery_state_changed_cb)
-	(int result, bt_adapter_device_discovery_state_e discovery_state, bt_adapter_device_discovery_info_s *discovery_info, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief  Called when you get bonded devices repeatedly.
- *
- * @param[in] device_info The bonded device information
- * @param[in] user_data The user data passed from the foreach function
- * @return @c true to continue with the next iteration of the loop,
- * \n @c false to break out of the loop.
- * @pre bt_adapter_foreach_bonded_device() will invoke this function.
- *
- * @see bt_adapter_foreach_bonded_device()
- *
- */
-typedef bool (*bt_adapter_bonded_device_cb)(bt_device_info_s *device_info, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
- * @brief Called when the process of creating bond finishes.
- * @remarks If the remote user does not respond within 60 seconds, a time out will happen with #BT_ERROR_TIMED_OUT result code.\n
- * If bt_device_cancel_bonding() is called and it returns #BT_ERROR_NONE, then this callback function will be called
- * with #BT_ERROR_CANCELLED result. \n
- * If creating a bond succeeds but service search fails, then this callback will be called with #BT_ERROR_SERVICE_SEARCH_FAILED.
- * In this case, you should try service search again by bt_device_start_service_search() to get the supported service list.
- *
- * @param[in] result The result of the bonding device
- * @param[in] device_info The device information which you creates bond with
- * @param[in] user_data The user data passed from the callback registration function
- *
- * @pre Either bt_device_create_bond() will invoke this function
- * if you register this callback using bt_device_set_bond_created_cb().
- *
- * @see bt_device_create_bond()
- * @see bt_device_cancel_bonding()
- * @see bt_device_set_bond_created_cb()
- * @see bt_device_unset_bond_created_cb()
- */
-typedef void (*bt_device_bond_created_cb)(int result, bt_device_info_s *device_info, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
- * @brief  Called when you get connected profiles repeatedly.
- * @param[in] profile The connected Bluetooth profile
- * @param[in] user_data The user data passed from the foreach function
- * @return @c true to continue with the next iteration of the loop,
- * \n @c false to break out of the loop.
- * @pre bt_device_foreach_connected_profiles() will invoke this function.
- * @see bt_device_foreach_connected_profiles()
- */
-typedef bool (*bt_device_connected_profile)(bt_profile_e profile, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
- * @brief  Called when the bond destroys.
- * @param[in] result The result that a bond is destroyed
- * @param[in] remote_address The address of the remote Bluetooth device to destroy bond with
- * @param[in] user_data The user data passed from the callback registration function
- * @pre bt_device_destroy_bond() will invoke this function
- * if you register this callback using bt_device_set_bond_destroyed_cb().
- *
- * @see bt_device_destroy_bond()
- * @see bt_device_set_bond_destroyed_cb()
- * @see bt_device_unset_bond_destroyed_cb()
- */
-typedef void (*bt_device_bond_destroyed_cb)(int result, char *remote_address, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
- * @brief  Called when the authorization of device changes.
- * @param[in] authorization The authorization of device
- * @param[in] remote_address The address of the remote Bluetooth device which is (un)authorized
- * @param[in] user_data The user data passed from the callback registration function
- * @pre bt_device_set_authorization() will invoke this function if you register this callback using bt_device_set_authorization_changed_cb().
- *
- * @see bt_device_set_authorization()
- * @see #bt_device_set_authorization_changed_cb()
- * @see #bt_device_unset_authorization_changed_cb()
- */
-typedef void (*bt_device_authorization_changed_cb)
-	(bt_device_authorization_e authorization, char *remote_address, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
- * @brief  Called when the process of service search finishes.
- * @remark If bt_device_cancel_service_search() is called and it returns #BT_ERROR_NONE,
- * then this callback function will be called with #BT_ERROR_CANCELLED result.
- *
- * @param[in] result The result of the service searching
- * @param[in] sdp_info The structure of service lists found on a device
- * @param[in] user_data The user data passed from the callback registration function
- * @pre Either bt_device_start_service_search() will invoke this function
- * if you register this callback using  bt_device_set_service_searched_cb().
- *
- * @see bt_device_start_service_search()
- * @see bt_device_cancel_service_search()
- * @see bt_device_set_service_searched_cb()
- * @see bt_device_unset_service_searched_cb()
- *
- */
-typedef void (*bt_device_service_searched_cb)(int result, bt_device_sdp_info_s *sdp_info, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
- * @brief  Called when the connection state is changed.
- * @param[in] connected The connection status: (@c true = connected, @c false = disconnected)
- * @param[in] remote_address The address of the remote Bluetooth device
- * @param[in] user_data The user data passed from the callback registration function
- * @see bt_device_set_connection_state_changed_cb()
- * @see bt_device_unset_connection_state_changed_cb()
- */
-typedef void (*bt_device_connection_state_changed_cb)(bool connected, const char *remote_address, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
- * @brief  Called when the device gets disconnected.
- * @param[in] remote_address The address of the remote Bluetooth device
- * @param[in] disconn_reason The reason for device disconnection
- * @param[in] user_data The user data passed from the callback registration function
- * @see bt_device_set_disconnected_cb()
- * @see bt_device_unset_disconnected_cb()
- */
-typedef void (*bt_device_disconnected_cb)(const char *remote_address,
-			bt_device_disconnect_reason_e disconn_reason, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE
- * @brief Called when you receive data.
- *
- * @param[in] data The received data from the remote device
- * @param[in] user_data The user data passed from the callback registration function
- *
- * @pre When the connected remote Bluetooth device invokes bt_socket_send_data(),
- *		this function will be invoked if you register this function using bt_socket_set_data_received_cb().
- *
- * @see bt_socket_set_data_received_cb()
- * @see bt_socket_unset_data_received_cb()
- * @see bt_socket_send_data()
- */
-typedef void (*bt_socket_data_received_cb)(bt_socket_received_data_s *data, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE
- * @brief  Called when the socket connection state changes.
- * @param[in] result The result of connection state changing
- * @param[in] connection_state The connection state
- * @param[in] connection The connection information which is established or disconnected
- * @param[in] user_data The user data passed from the callback registration function
- * @pre Either bt_socket_connect_rfcomm() will invoke this function.
- * In addtion, bt_socket_connection_state_changed_cb() will be invoked when the socket connection state is changed.
- * @see bt_socket_listen_and_accept_rfcomm()
- * @see bt_socket_connect_rfcomm()
- * @see bt_socket_set_connection_state_changed_cb()
- * @see bt_socket_unset_connection_state_changed_cb()
- */
-typedef void (*bt_socket_connection_state_changed_cb)
-	(int result, bt_socket_connection_state_e connection_state, bt_socket_connection_s *connection, void *user_data);
-
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_MODULE
- * @brief Initializes the Bluetooth API.
- *
- * @remarks This function must be called before Bluetooth API starts. \n
- * You must free all resources of the Bluetooth service by calling bt_deinitialize() if Bluetooth service is no longer needed.
- *
- * @return 0 on success, otherwise a negative error value.
- * @retval #BT_ERROR_NONE  Successful
- * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
- *
- * @see  bt_deinitialize()
- */
-int bt_initialize(void);
-
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_MODULE
- * @brief Releases all resources of the Bluetooth API.
- *
- * @remarks This function must be called if Bluetooth API 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 Bluetooth API must be initialized with bt_initialize().
- *
- * @see bt_initialize()
- */
-int bt_deinitialize(void);
-
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief Enables the local Bluetooth adapter, asynchronously.
- *
- * @details This function enables Bluetooth protocol stack and hardware.
- *
- * @return 0 on success, otherwise a negative error value.
- * @retval #BT_ERROR_NONE  Successful
- * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
- * @retval #BT_ERROR_ALREADY_DONE  Already enabled
- * @retval #BT_ERROR_NOW_IN_PROGRESS  Operation now in progress
- *
- * @pre Bluetooth service must be initialized with bt_initialize().
- * @post This function invokes bt_adapter_state_changed_cb().
- *
- * @see bt_initialize()
- * @see bt_adapter_get_state()
- * @see bt_adapter_disable()
- * @see bt_adapter_set_state_changed_cb()
- * @see bt_adapter_unset_state_changed_cb()
- * @see bt_adapter_state_changed_cb()
- *
- */
-int bt_adapter_enable(void);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief Disables the local Bluetooth adapter, asynchronously.
- *
- * @details This function disables Bluetooth protocol stack and hardware.
- *
- * @remarks You should disable Bluetooth adapter to switch off Bluetooth chip, which is helpful for saving power.
- *
- * @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_NOW_IN_PROGRESS  Operation now in progress
- *
- * @pre Bluetooth API must be enabled with bt_adapter_enable().
- * @post This function invokes bt_adapter_state_changed_cb().
- *
- * @see bt_adapter_get_state()
- * @see bt_adapter_enable()
- * @see bt_adapter_state_changed_cb()
- * @see bt_adapter_set_state_changed_cb()
- * @see bt_adapter_unset_state_changed_cb ()
- *
- */
-int bt_adapter_disable(void);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief Reset the local Bluetooth adapter, synchronously.
- *
- * @details This function resets Bluetooth protocol and values.
- *
- * @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 Bluetooth service must be initialized with bt_initialize().
- * @post bt_adapter_state_changed_cb() will be invoked if The state of local Bluetooth was #BT_ADAPTER_ENABLED.
- *
- * @see bt_initialize()
- * @see bt_adapter_get_state()
- * @see bt_adapter_set_state_changed_cb()
- * @see bt_adapter_unset_state_changed_cb()
- * @see bt_adapter_state_changed_cb()
- *
- */
-int bt_adapter_reset(void);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief Gets the current state of local Bluetooth adapter.
- *
- * @param[out] adapter_state The current adapter 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
- *
- * @pre Bluetooth service must be initialized with bt_initialize().
- *
- * @see bt_initialize()
- * @see bt_adapter_enable()
- * @see bt_adapter_disable()
- */
-int bt_adapter_get_state(bt_adapter_state_e *adapter_state);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief Gets the address of local Bluetooth adapter.
- *
- * @remarks The @a local_address must be released with free() by you.
- *
- * @param[out] local_address The device address of local Bluetooth adapter
- *
- * @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_OUT_OF_MEMORY  Out of memory
- * @retval #BT_ERROR_OPERATION_FAILED Operation failed
- * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED with bt_adapter_enable().
- * @see bt_adapter_enable()
- * @see bt_adapter_get_name()
- */
-int bt_adapter_get_address(char **local_address);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief Gets the name of local Bluetooth adapter.
- *
- * @details Use this function to get the friendly name associated with Bluetooth
- * device, retrieved by the remote Bluetooth devices.
- *
- * @remarks The @a local_name must be released with free() by you.
- *
- * @param[out] local_name  The local device name
- *
- * @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_OUT_OF_MEMORY  Out of memory
- * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
- *
- * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED with bt_adapter_enable().
- *
- * @see bt_adapter_enable()
- * @see bt_adapter_set_name()
- */
-int bt_adapter_get_name(char **local_name);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief Sets the name of local Bluetooth adapter.
- *
- * @param[in] local_name The name of the Bluetooth device. \n
- *				The maximum length is 248 characters.
- *
- * @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 state of local Bluetooth must be #BT_ADAPTER_ENABLED with bt_adapter_enable().
- * @post bt_adapter_name_changed_cb() will be invoked if this function returns #BT_ERROR_NONE.
- *
- * @see bt_adapter_enable()
- * @see bt_adapter_get_name()
- * @see bt_adapter_name_changed_cb()
- * @see bt_adapter_set_name_changed_cb()
- * @see bt_adapter_unset_name_changed_cb()
- */
-int bt_adapter_set_name(const char *local_name);
-
-/**
- * @ingroup  CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief  Gets the visibility mode of local Bluetooth adapter.
- * @param[out] mode  The visibility mode of the Bluetooth device
- * @param[out] duration  The duration until the visibility mode is changed to #BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE (in seconds).
- * @a duration is valid only if @a mode is #BT_ADAPTER_VISIBILITY_MODE_LIMITED_DISCOVERABLE. This value can be NULL.
- * @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 state of local Bluetooth must be #BT_ADAPTER_ENABLED with bt_adapter_enable().
- * @see bt_adapter_enable()
- * @see bt_adapter_set_visibility()
- */
-int bt_adapter_get_visibility(bt_adapter_visibility_mode_e *mode, int *duration);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief Sets the visibility mode.
- *
- * @remarks #BT_ADAPTER_VISIBILITY_MODE_LIMITED_DISCOVERABLE will change to #BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE
- * after the given @a duration goes.
- *
- * @param[in] discoverable_mode The Bluetooth visibility mode to set
- * @param[in] duration The duration until the visibility mode is changed to #BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE (in seconds).
- * @a duration is used only for #BT_ADAPTER_VISIBILITY_MODE_LIMITED_DISCOVERABLE 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_NOT_ENABLED  Not enabled
- * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
- * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
- *
- * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED with bt_adapter_enable().
- * @post bt_adapter_visibility_mode_changed_cb() will be invoked if this function returns #BT_ERROR_NONE.
- *
- * @see bt_adapter_enable()
- * @see bt_adapter_get_visibility()
- * @see bt_adapter_visibility_mode_changed_cb()
- * @see bt_adapter_set_visibility_mode_changed_cb()
- * @see bt_adapter_unset_visibility_mode_changed_cb()
- */
-int bt_adapter_set_visibility(bt_adapter_visibility_mode_e discoverable_mode, int duration);
-
-typedef void (*bt_adapter_connectable_changed_cb)
-	(int result, bool connectable, void *user_data);
-
-int bt_adapter_set_connectable_changed_cb(bt_adapter_connectable_changed_cb callback, void *user_data);
-
-int bt_adapter_unset_connectable_changed_cb(void);
-
-int bt_adapter_get_connectable(bool *connectable);
-
-int bt_adapter_set_connectable(bool connectable);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief Starts the device discovery for a particular type, asynchronously. The various
- * supporting discovery types are BT_ADAPTER_DEVICE_DISCOVERY_BREDR, BT_ADAPTER_DEVICE_DISCOVERY_LE
- * and BT_ADAPTER_DEVICE_DISCOVERY_LE_BREDR.
- *
- * @details If a device is discovered for a particular type, bt_adapter_device_discovery_state_changed_cb()
-*  will be invoked with #BT_ADAPTER_DEVICE_DISCOVERY_FOUND, and then bt_adapter_device_discovery_state_changed_cb()
- * will be called with #BT_ADAPTER_DEVICE_DISCOVERY_FINISHED in case of the completion or cancellation of the discovery.
- *
- * @remarks To connect to peer Bluetooth device, you need to know its Bluetooth address. \n
- * The device discovery can be stopped by bt_adapter_stop_device_discovery(). This API is similar to
- * bt_adapter_start_device_discovery() but here we can specify the device type to be discovered which
- * could makes the discovery procedure faster.
- *
- * @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_NOW_IN_PROGRESS  Operation is now in progress
- * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
- *
- * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED with bt_adapter_enable().
- * @post This function invokes bt_adapter_device_discovery_state_changed_cb().
- *
- * @see bt_adapter_enable()
- * @see bt_adapter_is_discovering()
- * @see bt_adapter_stop_device_discovery()
- * @see bt_adapter_device_discovery_state_changed_cb()
- * @see bt_adapter_set_device_discovery_state_changed_cb()
- * @see bt_adapter_unset_device_discovery_state_changed_cb()
- */
-int bt_adapter_start_discover_devices(bt_adapter_discover_devices_type_e type);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief Starts the device discovery, asynchronously.
- *
- * @details If a device is discovered, bt_adapter_device_discovery_state_changed_cb() will be invoked
- * with #BT_ADAPTER_DEVICE_DISCOVERY_FOUND, and then bt_adapter_device_discovery_state_changed_cb()
- * will be called with #BT_ADAPTER_DEVICE_DISCOVERY_FINISHED in case of the completion or cancellation of the discovery.
- *
- * @remarks To connect to peer Bluetooth device, you need to know its Bluetooth address. \n
- * The device discovery can be stopped by bt_adapter_stop_device_discovery().
- *
- * @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_NOW_IN_PROGRESS  Operation is now in progress
- * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
- *
- * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED with bt_adapter_enable().
- * @post This function invokes bt_adapter_device_discovery_state_changed_cb().
- *
- * @see bt_adapter_enable()
- * @see bt_adapter_is_discovering()
- * @see bt_adapter_stop_device_discovery()
- * @see bt_adapter_device_discovery_state_changed_cb()
- * @see bt_adapter_set_device_discovery_state_changed_cb()
- * @see bt_adapter_unset_device_discovery_state_changed_cb()
- */
-int bt_adapter_start_device_discovery(void);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief Stops the device discovery, asynchronously.
- * @remarks The device discovery process will take 10 ~ 20 seconds to get all the devices in vicinity.
- *
- * @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_NOT_IN_PROGRESS  Operation is not in progress
- * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
- *
- * @pre The device discovery must be in progress with bt_adapter_start_device_discovery().
- * @post This function invokes bt_adapter_device_discovery_state_changed_cb().
- *
- * @see bt_adapter_is_discovering()
- * @see bt_adapter_start_device_discovery()
- * @see bt_adapter_set_device_discovery_state_changed_cb()
- * @see bt_adapter_unset_device_discovery_state_changed_cb()
- * @see bt_adapter_device_discovery_state_changed_cb()
- */
-int bt_adapter_stop_device_discovery(void);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief Checks for the device discovery is in progress or not.
- *
- * @remarks If Bluetooth discovery is in progress, other operations are not allowed and
- * you have to either stop the discovery operation, or wait for it to be finished,
- * before performing other operations.
-
- * @param[out] is_discovering The discovering status: (@c true = in progress , @c  false = not in progress )
- *
- * @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 state of local Bluetooth must be #BT_ADAPTER_ENABLED with bt_adapter_enable().
- *
- * @see bt_adapter_enable()
- * @see bt_adapter_start_device_discovery()
- * @see bt_adapter_stop_device_discovery()
- */
-int bt_adapter_is_discovering(bool *is_discovering);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief Retrieves the device information of all bonded devices.
- *
- * @param [in] callback The callback function to invoke
- * @param [in] user_data The user data passed from the foreach 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_OUT_OF_MEMORY  Out of memory
- * @retval #BT_ERROR_NOT_ENABLED  Not enabled
- * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
- *
- * @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_foreach_bonded_device(bt_adapter_bonded_device_cb callback, void *user_data);
-
-/**
- * @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
- * @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_adapter_state_changed_cb() will be invoked.
- *
- * @see bt_initialize()
- * @see bt_adapter_state_changed_cb()
- * @see bt_adapter_set_state_changed_cb()
- * @see bt_adapter_unset_state_changed_cb()
- */
-int bt_adapter_set_state_changed_cb(bt_adapter_state_changed_cb callback, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_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_adapter_set_state_changed_cb()
- */
-int bt_adapter_unset_state_changed_cb(void);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief  Registers a callback function to be invoked when the name of Bluetooth adapter changes.
- *
- * @param[in] callback The callback function to invoke
- * @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_adapter_name_changed_cb() will be invoked.
- *
- * @see bt_initialize()
- * @see bt_adapter_name_changed_cb()
- * @see bt_adapter_unset_name_changed_cb()
- */
-int bt_adapter_set_name_changed_cb(bt_adapter_name_changed_cb callback, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_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_adapter_set_name_changed_cb()
- */
-int bt_adapter_unset_name_changed_cb(void);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief  Registers a callback function to be invoked when the visibility mode 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_adapter_visibility_mode_changed_cb() will be invoked.
- *
- * @see bt_initialize()
- * @see bt_adapter_visibility_mode_changed_cb()
- * @see bt_adapter_unset_visibility_mode_changed_cb()
- */
-int bt_adapter_set_visibility_mode_changed_cb(bt_adapter_visibility_mode_changed_cb callback, void *user_data);
-
-/**
- * @ingroup  CAPI_NETWORK_BLUETOOTH_ADAPTER_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_adapter_set_visibility_mode_changed_cb()
- */
-int bt_adapter_unset_visibility_mode_changed_cb(void);
-
-/**
- * @ingroup  CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief  Registers a callback function to be invoked every second
- * until the visibility mode is changed from #BT_ADAPTER_VISIBILITY_MODE_LIMITED_DISCOVERABLE
- * to #BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE.
- * @details  When you set visibility mode as #BT_ADAPTER_VISIBILITY_MODE_LIMITED_DISCOVERABLE,
- * @a callback will be called every second until visibility mode is changed to #BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE.
- * @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 by bt_initialize().
- * @post  bt_adapter_visibility_duration_changed_cb() will be invoked.
- * @see  bt_initialize()
- * @see  bt_adapter_set_visibility()
- * @see  bt_adapter_visibility_duration_changed_cb()
- * @see  bt_adapter_unset_visibility_duration_changed_cb()
- */
-int bt_adapter_set_visibility_duration_changed_cb(bt_adapter_visibility_duration_changed_cb callback, void *user_data);
-
-/**
- * @ingroup  CAPI_NETWORK_BLUETOOTH_ADAPTER_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_adapter_set_visibility_duration_changed_cb()
- */
-int bt_adapter_unset_visibility_duration_changed_cb(void);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief  Registers a callback function to be invoked when the device discovery 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_adapter_device_discovery_state_changed_cb() will be invoked.
- *
- * @see bt_initialize()
- * @see bt_adapter_device_discovery_state_changed_cb()
- * @see bt_adapter_set_device_discovery_state_changed_cb()
- * @see bt_adapter_unset_device_discovery_state_changed_cb()
- */
-int bt_adapter_set_device_discovery_state_changed_cb(bt_adapter_device_discovery_state_changed_cb callback, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_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_adapter_set_device_discovery_state_changed_cb()
- */
-int bt_adapter_unset_device_discovery_state_changed_cb(void);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief Get the Hash and Randmoizer value, synchronously.
- *
- * @param[out] hash The hash value recieved from the controller
- * @param[out] randomizer The hash value recieved from the controller
- * @param[out] hash_len The length of the hash value
- * @param[out] randomizer_len The length of the randomizer value
- * @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 state of local Bluetooth must be #BT_ADAPTER_ENABLED with bt_adapter_enable().
- * @pre The Bluetooth service must be initialized with bt_initialize().
- * @see bt_initialize()
- */
-int bt_adapter_get_local_oob_data(unsigned char **hash, unsigned char **randomizer,
-					int *hash_len, int *randomizer_len);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief Sets  the Hash and Randmoizer value, synchronously.
- *
- * @param[in] remote_address Remote device address
- * @param[in] hash The hash value recieved from the controller
- * @param[in] randomizer The hash value recieved from the controller
- * @param[in] hash_len The length of the hash value
- * @param[in] randomizer_len The length of the randomizer value
- * @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 state of local Bluetooth must be #BT_ADAPTER_ENABLED with bt_adapter_enable().
- * @pre The Bluetooth service must be initialized with bt_initialize().
- * @see bt_initialize()
- */
-int bt_adapter_set_remote_oob_data(const char *remote_address,
-				unsigned char *hash, unsigned char *randomizer,
-				int hash_len, int randomizer_len);
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief Sets  the Hash and Randmoizer value, synchronously.
- *
- * @param[in] remote_address Remote device 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_OPERATION_FAILED  Operation failed
- *
- * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED with bt_adapter_enable().
- * @pre The Bluetooth service must be initialized with bt_initialize().
- * @see bt_initialize()
- */
-int bt_adapter_remove_remote_oob_data(const char *remote_address);
-
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
- * @brief Creates a bond with a remote Bluetooth device, asynchronously.
- *
- * @remarks A bond can be destroyed by bt_device_destroy_bond().\n
- * The bonding request can be cancelled by bt_device_cancel_bonding().
- *
- * @param[in] remote_address The address of the remote Bluetooth device with which the bond should be created
- *
- * @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_RESOURCE_BUSY  Device or resource busy
- * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
- *
- * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED with bt_adapter_enable()
- * @pre The remote device must be discoverable with bt_adapter_start_device_discovery().
- * @post This function invokes bt_device_bond_created_cb().
- *
- * @see bt_adapter_enable()
- * @see bt_adapter_start_device_discovery()
- * @see bt_device_bond_created_cb()
- * @see bt_device_cancel_bonding()
- * @see bt_device_destroy_bond()
- * @see bt_device_set_bond_created_cb()
- * @see bt_device_unset_bond_created_cb()
- */
-int bt_device_create_bond(const char *remote_address);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
- * @brief Cancels the bonding process.
- *
- * @remakrs Use this function when the remote Bluetooth device is not responding to the
- * bond request or you wish to cancel the bonding request.
- *
- * @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_NOT_IN_PROGRESS  Operation not in progress
- * @pre The creating a bond must be in progress by bt_device_create_bond().
- *
- * @see bt_device_create_bond()
- * @see bt_device_bond_created_cb()
- * @see bt_device_set_bond_created_cb()
- * @see bt_device_unset_bond_created_cb()
- */
-int bt_device_cancel_bonding(void);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
- * @brief Destroys the bond, asynchronously.
- *
- * @param[in] remote_address The address of the remote Bluetooth device to remove bonding
- *
- * @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_RESOURCE_BUSY  Device or resource busy
- * @retval #BT_ERROR_REMOTE_DEVICE_NOT_BONDED  Remote device not bonded
- * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
- *
- * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED with bt_adapter_enable().
- * @pre The bond with the remote device must be created with bt_device_create_bond().
- * @post This function invokes bt_device_bond_destroyed_cb().
- *
- * @see bt_adapter_enable()
- * @see bt_device_create_bond()
- * @see bt_device_bond_destroyed_cb()
- * @see bt_device_set_bond_destroyed_cb()
- * @see bt_device_unset_bond_destroyed_cb()
- */
-int bt_device_destroy_bond(const char *remote_address);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
- * @brief Sets an alias for the bonded device.
- *
- * @param[in] remote_address The address of the remote Bluetooth device
- * @param[in] alias The alias of the remote Bluetooth 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_INVALID_PARAMETER  Invalid parameter
- * @retval #BT_ERROR_NOT_ENABLED  Not enabled
- * @retval #BT_ERROR_REMOTE_DEVICE_NOT_BONDED  Remote device not bonded
- * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
- *
- * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED with bt_adapter_enable().
- * @pre The bond with the remote device must be created with bt_device_create_bond().
- *
- * @see bt_adapter_enable()
- * @see bt_device_create_bond()
- */
-int bt_device_set_alias(const char *remote_address, const char *alias);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
- * @brief Sets the authorization of a bonded device, asynchronously.
- *
- * @remarks Once a device is authorized, you don't need to receive a confirmation.
- *
- * @param[in] remote_address The address of the remote Bluetooth device to authorize
- * @param[in] authorization The Bluetooth authorization 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_REMOTE_DEVICE_NOT_BONDED  Remote device not bonded
- * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
- *
- * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED with bt_adapter_enable().
- * @pre The bond with the remote device must be created with bt_device_create_bond().
- * @post bt_device_authorization_changed_cb() will be invoked.
- *
- * @see bt_adapter_enable()
- * @see bt_device_create_bond()
- * @see bt_device_authorization_changed_cb()
- * @see bt_device_set_authorization_changed_cb()
- * @see bt_device_unset_authorization_changed_cb()
- */
-int bt_device_set_authorization(const char *remote_address, bt_device_authorization_e authorization_state);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
- * @brief Starts the search for services supported by the specified device, asynchronously.
- *
- * @remarks If creating a bond succeeds, which means bt_device_bond_created_cb() is called with result #BT_ERROR_NONE,
- * then you don't need to run this function.\n
- * The service search takes a couple of seconds to complete normally. \n
- * The service search can be canceled by bt_device_cancel_service_search().
- *
- * @param[in] remote_address The address of the remote Bluetooth device whose services need to be checked
- *
- * @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 not bonded
- * @retval #BT_ERROR_SERVICE_SEARCH_FAILED  Service search failed
- *
- * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED with bt_adapter_enable().
- * @pre The remote device must be discoverable with bt_adapter_start_device_discovery().
- * @pre The bond with the remote device must be created with bt_device_create_bond().
- * @post This function invokes bt_device_service_searched_cb().
- *
- * @see bt_adapter_enable()
- * @see bt_adapter_start_device_discovery()
- * @see bt_device_create_bond()
- * @see bt_device_bond_created_cb()
- * @see bt_device_service_searched_cb()
- * @see bt_device_cancel_service_search()
- * @see bt_device_set_service_searched_cb()
- * @see bt_device_unset_service_searched_cb()
- */
-int bt_device_start_service_search(const char *remote_address);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
- * @brief Cancels service search process.
- *
- * @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_REMOTE_DEVICE_NOT_BONDED  Remote device not bonded
- * @retval #BT_ERROR_NOT_IN_PROGRESS  Operation not in progress
- * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
- *
- * @pre The service search must be in progress by bt_device_start_service_search().
- *
- * @see bt_device_start_service_search()
- * @see bt_device_service_searched_cb()
- * @see bt_device_set_service_searched_cb()
- * @see bt_device_unset_service_searched_cb()
- */
-int bt_device_cancel_service_search(void);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
- * @brief Gets the connected profiles.
- * @param[in] remote_address The address of the remote device
- * @param[in] callback The callback function to invoke
- * @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_INVALID_PARAMETER  Invalid parameter
- * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
- * @retval #BT_ERROR_NOT_ENABLED  Not enabled
- * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED with bt_adapter_enable().
- * @post bt_device_connected_profile() will be invoked.
- * @see bt_adapter_enable()
- * @see bt_device_connected_profile()
- */
-int bt_device_foreach_connected_profiles(const char *remote_address, bt_device_connected_profile callback, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
- * @brief Gets the profile connected status.
- * @param[in] remote_address The address of the remote device
- * @param[in] bt_profile wish to know bt_profile
- * @param[out] connected_status the connected status
- * @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_REMOTE_DEVICE_NOT_BONDED	Remote device not bonded
- * @retval #BT_ERROR_OPERATION_FAILED	Operation failed
- * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED with bt_adapter_enable().
- * @see bt_adapter_enable()
- */
-int bt_device_is_profile_connected(const char *remote_address, bt_profile_e bt_profile,
-					bool *connected_status);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
- * @brief  Registers a callback function to be invoked when the bond creates.
- * @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_device_bond_created_cb() will be invoked.
- * @see bt_initialize()
- * @see bt_device_bond_created_cb()
- * @see bt_device_unset_bond_created_cb()
- */
-int bt_device_set_bond_created_cb(bt_device_bond_created_cb callback, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_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_device_set_bond_created_cb()
- */
-int bt_device_unset_bond_created_cb(void);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
- * @brief  Registers a callback function to be invoked when the bond destroys.
- * @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_device_bond_destroyed_cb() will be invoked.
- * @see bt_initialize()
- * @see bt_device_bond_destroyed_cb()
- * @see bt_device_unset_bond_destroyed_cb()
- */
-int bt_device_set_bond_destroyed_cb(bt_device_bond_destroyed_cb callback, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_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_device_set_bond_destroyed_cb()
- */
-int bt_device_unset_bond_destroyed_cb(void);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
- * @brief  Registers a callback function to be invoked when the authorization of device 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_device_authorization_changed_cb() will be invoked.
- * @see bt_initialize()
- * @see bt_device_authorization_changed_cb()
- * @see bt_device_set_authorization_changed_cb()
- * @see bt_device_unset_authorization_changed_cb()
- */
-int bt_device_set_authorization_changed_cb(bt_device_authorization_changed_cb callback, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_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_device_set_authorization_changed_cb()
- */
-int bt_device_unset_authorization_changed_cb(void);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
- * @brief  Registers a callback function to be invoked when the process of service search finishes.
- * @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_device_service_searched_cb() will be invoked.
- * @see bt_initialize()
- * @see bt_device_service_searched_cb()
- * @see bt_device_unset_service_searched_cb()
- */
-int bt_device_set_service_searched_cb(bt_device_service_searched_cb callback, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_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_device_set_service_searched_cb()
- */
-int bt_device_unset_service_searched_cb(void);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
- * @brief  Registers a callback function to 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 service must be initialized with bt_initialize().
- * @post bt_device_connection_state_changed_cb() will be invoked.
- * @see bt_initialize()
- * @see bt_device_connection_state_changed_cb()
- * @see bt_device_unset_connection_state_changed_cb()
- */
-int bt_device_set_connection_state_changed_cb(bt_device_connection_state_changed_cb callback, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
- * @brief	Unregisters the callback function to 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_initialize()
- * @see bt_device_set_connection_state_changed_cb()
- */
-int bt_device_unset_connection_state_changed_cb(void);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
- * @brief  Registers a callback function to be invoked when the device gets disconnected.
- * @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_device_disconnected_cb() will be invoked.
- * @see bt_initialize()
- * @see bt_device_disconnected_cb()
- * @see bt_device_unset_disconnected_cb()
- */
-int bt_device_set_disconnected_cb(bt_device_disconnected_cb callback, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE
- * @brief	Unregisters the callback function to be invoked when the device disconnection happens.
- * @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_device_set_disconnected_cb()
- */
-int bt_device_unset_disconnected_cb(void);
-
-typedef void (*bt_device_gatt_state_changed_cb)(int result, void *user_data);
-
-int bt_device_connect_le(bt_device_gatt_state_changed_cb callback, const char *address);
-
-int bt_device_disconnect_le(bt_device_gatt_state_changed_cb callback, const char *address);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE
- * @brief Registers a rfcomm socket with a specific UUID.
- *
- * @remarks A socket can be destroyed by bt_socket_destroy_rfcomm().
- *
- * @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
- * @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 state of local Bluetooth must be #BT_ADAPTER_ENABLED with bt_adapter_enable().
- *
- * @see bt_adapter_enable()
- * @see bt_socket_listen_and_accept_rfcomm()
- * @see bt_socket_destroy_rfcomm()
- */
-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.
- * @remarks If callback function bt_socket_connection_state_changed_cb() is set and the remote Bluetooth device is connected,
- * then bt_socket_connection_state_changed_cb() will be called when this function is finished successfully.
- *
- * @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
- * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
- * @retval #BT_ERROR_NOT_ENABLED  Not enabled
- * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
- *
- * @pre The socket must be created with bt_socket_create_rfcomm().
- * @post If callback function bt_socket_connection_state_changed_cb() is set and the remote Bluetooth device is connected,
- * then bt_socket_connection_state_changed_cb() will be called.
- * @see bt_socket_create_rfcomm()
- * @see bt_socket_connection_state_changed_cb()
- * @see bt_socket_set_connection_state_changed_cb()
- * @see bt_socket_unset_connection_state_changed_cb()
- */
-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.
- * @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 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.
- * @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 If callback function bt_socket_connection_state_changed_cb() is set,
- * then bt_socket_connection_state_changed_cb() will be called when the remote Bluetooth device is connected.
- * @see bt_socket_create_rfcomm()
- * @see bt_socket_connection_state_changed_cb()
- * @see bt_socket_set_connection_state_changed_cb()
- * @see bt_socket_unset_connection_state_changed_cb()
- */
-int bt_socket_listen_and_accept_rfcomm(int socket_fd, int max_pending_connections);
-
-/**
- * @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] 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
- * @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 not bonded
- * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
- *
- * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED with bt_adapter_enable().
- * @pre The remote device must be discoverable with bt_adapter_start_device_discovery().
- * @pre The bond with the remote device must be created with bt_device_create_bond().
- * @post This function invokes bt_socket_connection_state_changed_cb().
- *
- * @see bt_adapter_enable()
- * @see bt_device_create_bond()
- * @see bt_adapter_start_device_discovery()
- * @see bt_device_start_service_search()
- * @see bt_socket_disconnect_rfcomm()
- * @see bt_socket_connection_state_changed_cb()
- * @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 *service_uuid);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE
- * @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.
- */
-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 file descriptor of connected socket
- * @param[in] data The data to be sent
- * @param[in] length The length of data to be sent
- *
- * @return the number of bytes written (zero indicates nothing was written).
- * @retval On error, -1 is returned, and errno is set appropriately. See write 2 man page.
- *
- * @pre The connection must be established.
- */
-int bt_socket_send_data(int socket_fd, const char *data, int length);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE
- * @brief  Register a callback function that will be invoked when you receive 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().
- * @post  bt_socket_data_received_cb() will be invoked.
- * @see bt_initialize()
- * @see bt_socket_data_received_cb()
- * @see bt_socket_set_data_received_cb()
- * @see bt_socket_unset_data_received_cb()
- */
-int bt_socket_set_data_received_cb(bt_socket_data_received_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_data_received_cb()
- * @see bt_socket_set_data_received_cb()
- */
-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
- * @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_socket_connection_state_changed_cb() will be invoked.
- * @see bt_initialize()
- * @see bt_socket_connection_state_changed_cb()
- * @see bt_socket_unset_connection_state_changed_cb()
- */
-int bt_socket_set_connection_state_changed_cb(bt_socket_connection_state_changed_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_connection_state_changed_cb()
- * @see bt_socket_set_connection_state_changed_cb()
- */
-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() if you want to accept.
- * Otherwise, you must call bt_opp_server_reject().
- * @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()
- * @see  bt_opp_server_reject()
- */
-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()
- * @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()
- * @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()
- */
-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()
- */
-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
- * @retval #BT_ERROR_ALREADY_DONE  Operation is already done
- * @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
- * @retval #BT_ERROR_ALREADY_DONE  Operation is already done
- * @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 Disconnects the all PANUs(Personal Area Networking User) which are connected to you.
- * @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_disconnect_all(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 Opens a SCO(Synchronous Connection Oriented link) to connected remote device, 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_REMOTE_DEVICE_NOT_BONDED  Remote device is not bonded
- * @retval #BT_ERROR_REMOTE_DEVICE_NOT_CONNECTED  Remote device is not connected
- * @retval #BT_ERROR_ALREADY_DONE  Operation is already done
- * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
- * @pre The Bluetooth audio device must be connected with bt_audio_connect().
- * @post bt_ag_sco_state_changed_cb() will be invoked.
- * @see bt_ag_close_sco()
- * @see bt_ag_sco_state_changed_cb()
- * @see bt_audio_connect()
- */
-int bt_ag_open_sco(void);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
- * @brief Closes an opened SCO(Synchronous Connection Oriented link), 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_REMOTE_DEVICE_NOT_BONDED  Remote device is not bonded
- * @retval #BT_ERROR_REMOTE_DEVICE_NOT_CONNECTED  Remote device is not connected
- * @pre The SCO must be opened with bt_ag_open_sco().
- * @post bt_ag_sco_state_changed_cb() will be invoked.
- * @see bt_ag_open_sco()
- * @see bt_ag_sco_state_changed_cb()
- */
-int bt_ag_close_sco(void);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
- * @brief Checks whether an opened SCO(Synchronous Connection Oriented link) exists or not.
- * @param[out] opened The SCO status: (@c true = opened, @c  false = not opened)
- * @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
- * @pre The Bluetooth audio service must be initialized with bt_audio_initialize().
- * @see bt_adapter_enable()
- * @see bt_ag_open_sco()
- * @see bt_ag_close_sco()
- */
-int bt_ag_is_sco_opened(bool *opened);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
- * @brief  Called when the SCO(Synchronous Connection Oriented link) state is changed.
- * @details  This callback is called when the SCO state is changed.
- * When you call bt_ag_open_sco() or bt_ag_close_sco(), this callback is also called with error result even though these functions failed.
- * @param[in] result  The result of changing the connection state
- * @param[in] opened  The state to be changed: (@c true = opened, @c  false = not opened)
- * @param[in] user_data The user data passed from the callback registration function
- * @see bt_ag_set_sco_state_changed_cb()
- * @see bt_ag_unset_sco_state_changed_cb()
- * @see bt_ag_open_sco()
- * @see bt_ag_close_sco()
- */
-typedef void (*bt_ag_sco_state_changed_cb) (int result, bool opened, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
- * @brief  Registers a callback function that will be invoked when the SCO(Synchronous Connection Oriented link) 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_ag_sco_state_changed_cb()
- * @see bt_ag_unset_sco_state_changed_cb()
- */
-int bt_ag_set_sco_state_changed_cb(bt_ag_sco_state_changed_cb callback, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
- * @brief  Unregisters a callback function that will be invoked when the SCO(Synchronous Connection Oriented link) 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_ag_sco_state_changed_cb()
- * @see bt_ag_set_sco_state_changed_cb()
- */
-int bt_ag_unset_sco_state_changed_cb(void);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
- * @brief Notifies the call event to the remote bluetooth device.
- * @remarks Before notifying #BT_AG_CALL_EVENT_ANSWERED or #BT_AG_CALL_EVENT_DIALING, you should open SCO(Synchronous Connection Oriented link)
- * if Bluetooth Hands-Free need SCO connection.
- * @param[in] event  The call event
- * @param[in] call_id  The call ID
- * @param[in] phone_number  The phone number. You must set this value in case of #BT_AG_CALL_EVENT_DIALING and #BT_AG_CALL_EVENT_INCOMING.
- * In other cases, this value can be NULL.
- * @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_REMOTE_DEVICE_NOT_CONNECTED  Remote device is not connected
- * @pre The Bluetooth audio device must be connected with bt_audio_connect().
- * @see bt_audio_connect()
- */
-int bt_ag_notify_call_event(bt_ag_call_event_e event, unsigned int call_id, const char *phone_number);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
- * @brief Notifies the call list to the remote bluetooth device.
- * @param[in] list  The call list
- * @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_REMOTE_DEVICE_NOT_CONNECTED  Remote device is not connected
- * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
- * @pre The Bluetooth audio device must be connected with bt_audio_connect().
- * @see bt_audio_connect()
- */
-int bt_ag_notify_call_list(bt_call_list_h list);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
- * @brief Notifies the state of voice recognition.
- * @param[in] state  The state of voice recognition: (@c true = enabled, @c  false = disabled)
- * @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_REMOTE_DEVICE_NOT_CONNECTED  Remote device is not connected
- * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
- * @pre The Bluetooth audio device must be connected with bt_audio_connect().
- * @see bt_audio_connect()
- */
-int bt_ag_notify_voice_recognition_state(bool state);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
- * @brief  Called when a call handling event happened from Hands-Free.
- * @param[in] event  The call handling event happened from Hands-Free
- * @param[in] call_id  The call ID
- * @param[in] user_data The user data passed from the callback registration function
- * @see bt_ag_set_call_handling_event_cb()
- * @see bt_ag_unset_call_handling_event_cb()
- */
-typedef void (*bt_ag_call_handling_event_cb) (bt_ag_call_handling_event_e event, unsigned int call_id, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
- * @brief  Registers a callback function that will be invoked when a call handling event happened from Hands-Free.
- * @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_call_handling_event_cb()
- * @see bt_ag_unset_call_handling_event_cb()
- */
-int bt_ag_set_call_handling_event_cb(bt_ag_call_handling_event_cb callback, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
- * @brief  Unregisters a callback function that will be invoked when a call handling event happened from Hands-Free.
- * @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_ag_call_handling_event_cb()
- * @see bt_ag_set_call_handling_event_cb()
- */
-int bt_ag_unset_call_handling_event_cb(void);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_HF_MODULE
- * @brief  Called when the SCO(Synchronous Connection Oriented link) state is changed.
- * @details  This callback is called when the SCO state is changed.
- * When you call bt_ag_open_sco() or bt_ag_close_sco(), this callback is also called with error result even though these functions failed.
- * @param[in] result  The result of changing the connection state
- * @param[in] opened  The state to be changed: (@c true = opened, @c  false = not opened)
- * @param[in] user_data The user data passed from the callback registration function
- * @see bt_ag_set_sco_state_changed_cb()
- * @see bt_ag_unset_sco_state_changed_cb()
- * @see bt_ag_open_sco()
- * @see bt_ag_close_sco()
- */
-typedef void (*bt_hf_sco_state_changed_cb) (int result, bool opened, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_HF_MODULE
- * @brief  Registers a callback function that will be invoked when the SCO(Synchronous Connection Oriented link) 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_ag_sco_state_changed_cb()
- * @see bt_ag_unset_sco_state_changed_cb()
- */
-int bt_hf_set_sco_state_changed_cb(bt_hf_sco_state_changed_cb callback, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_HF_MODULE
- * @brief  Unregisters a callback function that will be invoked when the SCO(Synchronous Connection Oriented link) 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_ag_sco_state_changed_cb()
- * @see bt_ag_set_sco_state_changed_cb()
- */
-int bt_hf_unset_sco_state_changed_cb(void);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_HF_MODULE
- * @brief  Called when a call handling event happened from Hands-Free.
- * @param[in] event  The call handling event happened from Hands-Free
- * @param[in] call_id  The call ID
- * @param[in] user_data The user data passed from the callback registration function
- * @see bt_ag_set_call_handling_event_cb()
- * @see bt_ag_unset_call_handling_event_cb()
- */
-typedef void (*bt_hf_call_handling_event_cb) (bt_hf_call_handling_event_e event, char *phone_number, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_HF_MODULE
- * @brief  Registers a callback function that will be invoked when a call handling event happened from Hands-Free.
- * @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_call_handling_event_cb()
- * @see bt_ag_unset_call_handling_event_cb()
- */
-int bt_hf_set_call_handling_event_cb(bt_hf_call_handling_event_cb callback, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_HF_MODULE
- * @brief  Unregisters a callback function that will be invoked when a call handling event happened from Hands-Free.
- * @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_ag_call_handling_event_cb()
- * @see bt_ag_set_call_handling_event_cb()
- */
-int bt_hf_unset_call_handling_event_cb(void);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_HF_MODULE
- * @brief  Called when a multi call handling event happened from Hands-Free.
- * @param[in] event  The call handling event happened from Hands-Free
- * @param[in] user_data The user data passed from the callback registration function
- * @see bt_ag_set_multi_call_handling_event_cb()
- * @see bt_ag_unset_multi_call_handling_event_cb()
- */
-typedef void (*bt_hf_multi_call_handling_event_cb) (bt_hf_multi_call_handling_event_e event, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_HF_MODULE
- * @brief  Registers a callback function that will be invoked when a multi call handling event happened from Hands-Free.
- * @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_multi_call_handling_event_cb()
- * @see bt_ag_unset_multi_call_handling_event_cb()
- */
-int bt_hf_set_multi_call_handling_event_cb(bt_hf_multi_call_handling_event_cb callback, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_HF_MODULE
- * @brief  Unregisters a callback function that will be invoked when a multi call handling event happened from Hands-Free.
- * @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_ag_multi_call_handling_event_cb()
- * @see bt_ag_set_multi_call_handling_event_cb()
- */
-int bt_hf_unset_multi_call_handling_event_cb(void);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
- * @brief  Called when a multi call handling event happened from Hands-Free.
- * @param[in] event  The call handling event happened from Hands-Free
- * @param[in] user_data The user data passed from the callback registration function
- * @see bt_ag_set_multi_call_handling_event_cb()
- * @see bt_ag_unset_multi_call_handling_event_cb()
- */
-typedef void (*bt_ag_multi_call_handling_event_cb) (bt_ag_multi_call_handling_event_e event, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
- * @brief  Registers a callback function that will be invoked when a multi call handling event happened from Hands-Free.
- * @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_multi_call_handling_event_cb()
- * @see bt_ag_unset_multi_call_handling_event_cb()
- */
-int bt_ag_set_multi_call_handling_event_cb(bt_ag_multi_call_handling_event_cb callback, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
- * @brief  Unregisters a callback function that will be invoked when a multi call handling event happened from Hands-Free.
- * @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_ag_multi_call_handling_event_cb()
- * @see bt_ag_set_multi_call_handling_event_cb()
- */
-int bt_ag_unset_multi_call_handling_event_cb(void);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
- * @brief  Called when a DTMF(Dual Tone Multi Frequency) is transmitted from Hands-Free.
- * @param[in] dtmf  The DTMF transmitted from Hands-Free
- * @param[in] user_data The user data passed from the callback registration function
- * @see bt_ag_set_dtmf_transmitted_cb()
- * @see bt_ag_unset_dtmf_transmitted_cb()
- */
-typedef void (*bt_ag_dtmf_transmitted_cb) (const char *dtmf, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
- * @brief  Registers a callback function that will be invoked when a DTMF(Dual Tone Multi Frequency) is transmitted from Hands-Free.
- * @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_dtmf_transmitted_cb()
- * @see bt_ag_unset_dtmf_transmitted_cb()
- */
-int bt_ag_set_dtmf_transmitted_cb(bt_ag_dtmf_transmitted_cb callback, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
- * @brief  Unregisters a callback function that will be invoked when a DTMF(Dual Tone Multi Frequency) is transmitted from Hands-Free.
- * @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_ag_dtmf_transmitted_cb()
- * @see bt_ag_set_dtmf_transmitted_cb()
- */
-int bt_ag_unset_dtmf_transmitted_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] 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(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[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(int *gain);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
- * @brief Checks whether the remoted device enables NREC(Noise Reduction and Echo Canceling) or not.
- * @param[out] enabled The NREC status: (@c true = enabled, @c  false = not enabled)
- * @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_audio_connect()
- */
-int bt_ag_is_nrec_enabled(bool *enabled);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
- * @brief  Called when the speaker gain of the remote device is changed.
- * @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) (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_AG_MODULE
- * @brief  Called when the microphone gain of the remote device is changed.
- * @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) (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_AUDIO_A2DP_MODULE
-* @brief  Sets copy protection. streaming application that needs to have the copy protection for the streaming data, shall invoke this API.
-* @param[in] status - TRUE/FALSE
-* @return  0 on success, otherwise negative error value.
-* @retval  #BT_ERROR_NONE  Successful
-* @retval  #BT_ERROR_OPERATION_FAILED  on failure
-*/
-int bt_a2dp_set_content_protection(bool status);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_CALL_MODULE
- * @brief Creates a handle of call list.
- * @param[out] list  The handle of call list
- * @return 0 on success, otherwise a negative error value.
- * @retval #BT_ERROR_NONE  Successful
- * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
- * @retval #BT_ERROR_OUT_OF_MEMORY  Out of memory
- * @see bt_call_list_destroy()
- */
-int bt_call_list_create(bt_call_list_h *list);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_CALL_MODULE
- * @brief Destroys the handle of call list.
- * @param[in] list  The handle of call list
- * @return 0 on success, otherwise a negative error value.
- * @retval #BT_ERROR_NONE  Successful
- * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
- * @see bt_call_list_create()
- */
-int bt_call_list_destroy(bt_call_list_h list);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_CALL_MODULE
- * @brief Resets the handle of call list.
- * @param[in] list  The handle of call list
- * @return 0 on success, otherwise a negative error value.
- * @retval #BT_ERROR_NONE  Successful
- * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
- * @see bt_call_list_create()
- */
-int bt_call_list_reset(bt_call_list_h list);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_CALL_MODULE
- * @brief Adds a call to the handle of call list.
- * @param[in] list  The handle of call list
- * @return 0 on success, otherwise a negative error value.
- * @retval #BT_ERROR_NONE  Successful
- * @retval #BT_ERROR_INVALID_PARAMETER  Invalid parameter
- * @retval #BT_ERROR_OUT_OF_MEMORY  Out of memory
- * @see bt_call_list_create()
- */
-int bt_call_list_add(bt_call_list_h list, unsigned int call_id, bt_ag_call_state_e state);
-
-/**
- * @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  Notifies 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  Notifies 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  Notifies 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  Notifies 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  Notifies 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  Notifies 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  Notifies 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_AVRCP_MODULE
- * @brief  Called when the equalizer state is changed by the remote control device.
- * @param[in] equalizer The equalizer state
- * @param[in] user_data The user data passed from the callback registration function
- * @see bt_avrcp_set_equalizer_state_changed_cb()
- * @see bt_avrcp_unset_equalizer_state_changed_cb()
- */
-typedef void (*bt_avrcp_equalizer_state_changed_cb) (bt_avrcp_equalizer_state_e equalizer, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE
- * @brief  Registers a callback function that will be invoked when the equalizer state is changed by the remote control device.
- * @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 by bt_initialize().
- * @see bt_initialize()
- * @see bt_avrcp_unset_equalizer_state_changed_cb()
- */
-int bt_avrcp_set_equalizer_state_changed_cb(bt_avrcp_equalizer_state_changed_cb callback, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE
- * @brief  Unregisters a callback function that will be invoked when the equalizer state is changed by the remote control device.
- * @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 by bt_initialize().
- * @see bt_initialize()
- * @see bt_avrcp_set_equalizer_state_changed_cb()
- */
-int bt_avrcp_unset_equalizer_state_changed_cb(void);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE
- * @brief  Called when the repeat mode is changed by the remote control device.
- * @param[in] repeat The repeat mode
- * @param[in] user_data The user data passed from the callback registration function
- * @see bt_avrcp_set_repeat_mode_changed_cb()
- * @see bt_avrcp_unset_repeat_mode_changed_cb()
- */
-typedef void (*bt_avrcp_repeat_mode_changed_cb) (bt_avrcp_repeat_mode_e repeat, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE
- * @brief  Registers a callback function that will be invoked when the repeat mode is changed by the remote control device.
- * @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 by bt_initialize().
- * @see bt_initialize()
- * @see bt_avrcp_unset_repeat_mode_changed_cb()
- */
-int bt_avrcp_set_repeat_mode_changed_cb(bt_avrcp_repeat_mode_changed_cb callback, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE
- * @brief  Unregisters a callback function that will be invoked when the repeat mode is changed by the remote control device.
- * @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 by bt_initialize().
- * @see bt_initialize()
- * @see bt_avrcp_set_repeat_mode_changed_cb()
- */
-int bt_avrcp_unset_repeat_mode_changed_cb(void);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE
- * @brief  Called when the shuffle mode is changed by the remote control device.
- * @param[in] shuffle The shuffle mode
- * @param[in] user_data The user data passed from the callback registration function
- * @see bt_avrcp_set_shuffle_mode_changed_cb()
- * @see bt_avrcp_unset_shuffle_mode_changed_cb()
- */
-typedef void (*bt_avrcp_shuffle_mode_changed_cb) (bt_avrcp_shuffle_mode_e shuffle, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE
- * @brief  Registers a callback function that will be invoked when the shuffle mode is changed by the remote control device.
- * @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 by bt_initialize().
- * @see bt_initialize()
- * @see bt_avrcp_unset_shuffle_mode_changed_cb()
- */
-int bt_avrcp_set_shuffle_mode_changed_cb(bt_avrcp_shuffle_mode_changed_cb callback, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE
- * @brief  Unregisters a callback function that will be invoked when the shuffle mode is changed by the remote control device.
- * @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 by bt_initialize().
- * @see bt_initialize()
- * @see bt_avrcp_set_shuffle_mode_changed_cb()
- */
-int bt_avrcp_unset_shuffle_mode_changed_cb(void);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE
- * @brief  Called when the scan mode is changed by the remote control device.
- * @param[in] shuffle The shuffle mode
- * @param[in] user_data The user data passed from the callback registration function
- * @see bt_avrcp_set_scan_mode_changed_cb()
- * @see bt_avrcp_unset_scan_mode_changed_cb()
- */
-typedef void (*bt_avrcp_scan_mode_changed_cb) (bt_avrcp_scan_mode_e scan, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE
- * @brief  Registers a callback function that will be invoked when the scan mode is changed by the remote control device.
- * @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 by bt_initialize().
- * @see bt_initialize()
- * @see bt_avrcp_unset_scan_mode_changed_cb()
- */
-int bt_avrcp_set_scan_mode_changed_cb(bt_avrcp_scan_mode_changed_cb callback, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE
- * @brief  Unregisters a callback function that will be invoked when the scan mode is changed by the remote control device.
- * @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 by bt_initialize().
- * @see bt_initialize()
- * @see bt_avrcp_set_scan_mode_changed_cb()
- */
-int bt_avrcp_unset_scan_mode_changed_cb(void);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_HDP_MODULE
- * @brief Registers an application that acts as the @a Sink role of HDP(Health Device Profile).
- * @remarks The @a app_id must be released with free() by you.
- * @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_OUT_OF_MEMORY  Out of memory
- * @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);
-
-/**
- * @ingroup  CAPI_NETWORK_BLUETOOTH_GATT_MODULE
- * @brief  Called when you get the primary services repeatedly.
- * @param[in]  service  The attribute handle of service
- * @param[in]  user_data  The user data passed from the foreach function
- * @return  @c true to continue with the next iteration of the loop,
- * \n @c false to break out of the loop.
- * @pre  bt_gatt_foreach_primary_services() will invoke this function.
- * @see  bt_gatt_foreach_primary_services()
- */
-typedef bool (*bt_gatt_primary_service_cb) (bt_gatt_attribute_h service, void *user_data);
-
-/**
- * @ingroup  CAPI_NETWORK_BLUETOOTH_GATT_MODULE
- * @brief  Gets the primary services of GATT(Generic Attribute Profile).
- * @param[in]  remote_address  The address of the remote device
- * @param[in]  callback  The callback function to invoke
- * @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_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
- * @pre  The state of local Bluetooth must be #BT_ADAPTER_ENABLED.
- * @post  @a callback will be called if there are primary services.
- * @see  bt_adapter_enable()
- * @see  bt_gatt_primary_service_cb()
- */
-int bt_gatt_foreach_primary_services(const char *remote_address, bt_gatt_primary_service_cb callback, void *user_data);
-
-/**
- * @ingroup  CAPI_NETWORK_BLUETOOTH_GATT_MODULE
- * @brief  Called after the characteristics are discovered by bt_gatt_discover_characteristics().
- * @remakrs  If bt_gatt_discover_characteristics() failed, then this callback function is called only once with 0 totla and NULL characteristic_handle.
- * @param[in]  result  The result of discovering
- * @param[in]  index  The index of characteristics in a service, starts from 0
- * @param[in]  total  The total number of characteristics in a service
- * @param[in]  characteristic  The attribute handle of characteristic
- * @param[in]  user_data  The user data passed from the request function
- * @return  @c true to continue with the next iteration of the loop,
- * \n @c false to break out of the loop.
- * @pre  bt_gatt_discover_characteristics() will invoke this callback.
- * @see  bt_gatt_discover_characteristics()
- */
-typedef bool (*bt_gatt_characteristics_discovered_cb) (int result, int index, int total, bt_gatt_attribute_h characteristic, void *user_data);
-
-/**
- * @ingroup  CAPI_NETWORK_BLUETOOTH_GATT_MODULE
- * @brief  Discovers the characteristics in service, asynchronously.
- * @param[in]  service  The attribute handle of service
- * @param[in]  callback  The result callback
- * @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 state of local Bluetooth must be #BT_ADAPTER_ENABLED.
- * @post  @a callback will be called.
- * @see  bt_adapter_enable()
- * @see  bt_gatt_characteristics_discovered_cb()
- */
-int bt_gatt_discover_characteristics(bt_gatt_attribute_h service, bt_gatt_characteristics_discovered_cb callback, void *user_data);
-
-/**
- * @ingroup  CAPI_NETWORK_BLUETOOTH_GATT_MODULE
- * @brief  Gets the UUID of service.
- * @remarks  @a uuid must be released with free() by you.
- * @param[in]  service  The attribute handle of service
- * @param[out]  uuid  The UUID of 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_OPERATION_FAILED  Operation failed
- * @retval  #BT_ERROR_OUT_OF_MEMORY  Out of memory
- * @pre  The state of local Bluetooth must be #BT_ADAPTER_ENABLED.
- * @see  bt_adapter_enable()
- */
-int bt_gatt_get_service_uuid(bt_gatt_attribute_h service, char **uuid);
-
-/**
- * @ingroup  CAPI_NETWORK_BLUETOOTH_GATT_MODULE
- * @brief  Called when you get the included services repeatedly.
- * @param[in]  service  The attribute handle of service
- * @param[in]  user_data  The user data passed from the foreach function
- * @return  @c true to continue with the next iteration of the loop,
- * \n @c false to break out of the loop.
- * @pre  bt_gatt_foreach_included_services() will invoke this function.
- * @see  bt_gatt_foreach_included_services()
- */
-typedef bool (*bt_gatt_included_service_cb) (bt_gatt_attribute_h service, void *user_data);
-
-/**
- * @ingroup  CAPI_NETWORK_BLUETOOTH_GATT_MODULE
- * @brief  Gets the included services in service.
- * @param[in]  service  The attribute handle of service
- * @param[in]  callback  The callback function to invoke
- * @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_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
- * @pre  The state of local Bluetooth must be #BT_ADAPTER_ENABLED.
- * @post  @a callback will be called if there are included services.
- * @see  bt_adapter_enable()
- * @see  bt_gatt_included_service_cb()
- */
-int bt_gatt_foreach_included_services(bt_gatt_attribute_h service, bt_gatt_included_service_cb callback, void *user_data);
-
-/**
- * @ingroup  CAPI_NETWORK_BLUETOOTH_GATT_MODULE
- * @brief  Called when a characteristic in service is changed.
- * @param[in]  characteristic  The attribute handle of characteristic
- * @param[in]  value  The value of characteristic (byte array)
- * @param[in]  value_length  The length of value
- * @param[in]  user_data  The user data passed from the callback registration function
- * @see bt_gatt_set_characteristic_changed_cb()
- * @see bt_gatt_unset_characteristic_changed_cb()
- */
-typedef void (*bt_gatt_characteristic_changed_cb) (bt_gatt_attribute_h characteristic, unsigned char *value, int value_length, void *user_data);
-
-/**
- * @ingroup  CAPI_NETWORK_BLUETOOTH_GATT_MODULE
- * @brief  Registers a callback function that will be invoked when a characteristic value 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 service must be initialized with bt_initialize().
- * @see  bt_gatt_unset_characteristic_changed_cb()
- */
-int bt_gatt_set_characteristic_changed_cb(bt_gatt_characteristic_changed_cb callback, void *user_data);
-
-/**
- * @ingroup  CAPI_NETWORK_BLUETOOTH_GATT_MODULE
- * @brief  Unregisters a callback function that will be invoked when a characteristic 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_gatt_set_characteristic_changed_cb()
- */
-int bt_gatt_unset_characteristic_changed_cb(void);
-
-/**
- * @ingroup  CAPI_NETWORK_BLUETOOTH_GATT_MODULE
- * @brief  Watches all the characteristic value changes of the service
- * @param[in]  service  The attribute handle of service
- * @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_gatt_unset_characteristic_changed_cb()
- */
-int bt_gatt_watch_characteristic_changes(bt_gatt_attribute_h service);
-
-/**
- * @ingroup  CAPI_NETWORK_BLUETOOTH_GATT_MODULE
- * @brief  Remove watching of all the characteristic value changes of the service
- * @param[in]  service  The attribute handle of 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 service must be initialized with bt_initialize().
- * @see bt_gatt_set_characteristic_changed_cb()
- */
-int bt_gatt_unwatch_characteristic_changes(bt_gatt_attribute_h service);
-
-
-/**
- * @ingroup  CAPI_NETWORK_BLUETOOTH_GATT_MODULE
- * @brief  Gets the characteristic declaration.
- * @remarks  @a uuid and @a value must be released with free() by you.
- * @param[in]  characteristic  The attribute handle of characteristic
- * @param[out]  uuid  The UUID of service
- * @param[out]  value  The value of characteristic (byte array)
- * @param[out]  value_length  The length of value
- * @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
- * @retval  #BT_ERROR_OUT_OF_MEMORY  Out of memory
- * @pre  The state of local Bluetooth must be #BT_ADAPTER_ENABLED.
- * @see  bt_adapter_enable()
- * @see  bt_gatt_set_characteristic_value()
- */
-int bt_gatt_get_characteristic_declaration(bt_gatt_attribute_h characteristic, char **uuid, unsigned char **value, int *value_length);
-
-/**
- * @ingroup  CAPI_NETWORK_BLUETOOTH_GATT_MODULE
- * @brief  Sets the value of characteristic.
- * @param[in]  characteristic  The attribute handle of characteristic
- * @param[in]  value  The value of characteristic (byte array)
- * @param[in]  value_length  The length of value
- * @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 state of local Bluetooth must be #BT_ADAPTER_ENABLED.
- * @see  bt_adapter_enable()
- * @see  bt_gatt_get_characteristic_declaration()
- */
-int bt_gatt_set_characteristic_value(bt_gatt_attribute_h characteristic, const unsigned char *value, int value_length);
-
-/**
- * @ingroup  CAPI_NETWORK_BLUETOOTH_GATT_MODULE
- * @brief  Called when a characteristic value is written.
- * @see bt_gatt_set_characteristic_value()
- */
-typedef void (*bt_gatt_characteristic_write_cb) (void *user_data);
-
-/**
- * @ingroup  CAPI_NETWORK_BLUETOOTH_GATT_MODULE
- * @brief  Sets the value of characteristic request.
- * @param[in]  characteristic  The attribute handle of characteristic
- * @param[in]  value  The value of characteristic (byte array)
- * @param[in]  value_length  The length of value
-  * @param[in]  callback  The result callback
- * @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 state of local Bluetooth must be #BT_ADAPTER_ENABLED.
- * @see  bt_adapter_enable()
- * @see  bt_gatt_get_characteristic_declaration()
- */
-int bt_gatt_set_characteristic_value_request(bt_gatt_attribute_h characteristic, const unsigned char *value,
-				int value_length, bt_gatt_characteristic_write_cb callback);
-
-/**
-* @ingroup  CAPI_NETWORK_BLUETOOTH_GATT_MODULE
-* @brief  Clones the attribute handle.
-* @remarks  @a clone must be released with bt_gatt_destroy_attribute_handle().
-* @param[out]  clone  The cloned attribute handle
-* @param[in]  origin  The origin attribute handle
-* @return  0 on success, otherwise negative error value.
-* @retval  #BT_ERROR_NONE  Successful
-* @retval  #BT_ERROR_INVALID_PARAMETER  Invalid parameter
-* @retval  #BT_ERROR_OUT_OF_MEMORY  Out of memory
-* @see  bt_gatt_destroy_attribute_handle()
-*/
-int bt_gatt_clone_attribute_handle(bt_gatt_attribute_h* clone, bt_gatt_attribute_h origin);
-
-/**
-* @ingroup  CAPI_NETWORK_BLUETOOTH_GATT_MODULE
-* @brief  Destroys the attribute handle.
-* @param[in]  handle  The attribute handle
-* @return  0 on success, otherwise negative error value.
-* @retval  #BT_ERROR_NONE  Successful
-* @retval  #BT_ERROR_INVALID_PARAMETER  Invalid parameter
-* @see  bt_gatt_clone_attribute_handle()
-*/
-int bt_gatt_destroy_attribute_handle(bt_gatt_attribute_h handle);
-
-/**
- * @ingroup  CAPI_NETWORK_BLUETOOTH_GATT_MODULE
- * @brief  Called when a characteristic value is read.
- * @param[in]  value  The value of characteristic (byte array)
- * @param[in]  value_length  The length of value
- * @param[in]  user_data  The user data passed from the foreach function
- * @see bt_gatt_read_characteristic_value()
- */
-typedef void (*bt_gatt_characteristic_read_cb) (unsigned char *value,
-			int value_length, void *user_data);
-
-/**
- * @ingroup  CAPI_NETWORK_BLUETOOTH_GATT_MODULE
- * @brief  Reads the value of characteristic from remote device
- * @param[in]  characteristic  The attribute handle of characteristic
- * @param[in]  callback  The result callback
- * @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 state of local Bluetooth must be #BT_ADAPTER_ENABLED.
- * @see  bt_adapter_enable()
- * @see  bt_gatt_get_characteristic_declaration()
- */
-int bt_gatt_read_characteristic_value(bt_gatt_attribute_h char_handle,
-		bt_gatt_characteristic_read_cb callback);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief  Enumerations of the Bluetooth advertising state.
- */
-typedef enum {
-	BT_ADAPTER_ADVERTISING_STOPPED = 0x00, /**< Bluetooth advertising is stopped */
-	BT_ADAPTER_ADVERTISING_STARTED, /**< Bluetooth advertising is started */
-} bt_adapter_advertising_state_e;
-
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief  Enumerations of the Bluetooth advertising filter policy.
- */
-typedef enum {
-	BT_ADAPTER_ADVERTISING_FILTER_DEFAULT = 0x00, /**< White list is not in use */
-	BT_ADAPTER_ADVERTISING_FILTER_ALLOW_SCAN_WL = 0x01, /**< Allow the scan
-					request that in the White list */
-	BT_ADAPTER_ADVERTISING_FILTER_ALLOW_CONN_WL = 0x02, /**< Allow the connectoin
-					request that in the White list */
-	BT_ADAPTER_ADVERTISING_FILTER_ALLOW_SCAN_CONN_WL = 0x03, /**< Allow the
-					scan and connectoin request that in the White list */
-} bt_adapter_advertising_filter_policy_e;
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief Structure of advertising parameters
- *
- * @see #bt_class_s
- * @see bt_adapter_advertising_state_changed_cb()
- * @see bt_adapter_start_advertising()
- */
-typedef struct {
-	float interval_min; /**< Minimum advertising interval for non-directed advertising.
-			      A multiple of 0.625ms is only allowed (Time range : 20ms to 10.24sec). */
-	float interval_max; /**< Maximum advertising interval for non-directed advertising.
-			      A multiple of 0.625ms is only allowed (Time range : 20ms to 10.24sec). */
-	int filter_policy; /* Advertising filter policy */
-} bt_adapter_advertising_params_s;
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief  Called when the state of advertising changes.
- *
- * @param[in] result The result of the advertising
- * @param[in] adv_state The advertising state to be changed
- * @param[in] adv_params The parameters of advertising \n
- *				If \a adv_state is #BT_ADAPTER_ADVERTISING_STOPPED, then \a adv_params is NULL.
- * @param[in] user_data The user data passed from the callback registration function
- *
- * @pre Either bt_adapter_start_advertising() or bt_adapter_stop_stop_advertising() will invoke this function
- * if you register this callback using bt_adapter_set_advertising_state_changed_cb().
- *
- * @see bt_adapter_start_advertising(bt_adapter_advertising_params_s *adv_params)
- * @see bt_adapter_stop_advertising()
- * @see bt_adapter_set_advertising_state_changed_cb()
- * @see bt_adapter_unset_advertising_state_changed_cb()
- *
- */
-typedef void (*bt_adapter_advertising_state_changed_cb)(int result,
-		bt_adapter_advertising_state_e adv_state,
-		bt_adapter_advertising_params_s *adv_params, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief  Registers a callback function to be invoked when the advertising 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_adapter_advertising_state_changed_cb() will be invoked.
- *
- * @see bt_initialize()
- * @see bt_adapter_advertising_state_changed_cb()
- * @see bt_adapter_unset_advertising_state_changed_cb()
- */
-int bt_adapter_set_advertising_state_changed_cb(bt_adapter_advertising_state_changed_cb callback, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_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_adapter_set_advertising_state_changed_cb()
- */
-int bt_adapter_unset_advertising_state_changed_cb(void);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief Starts the advertising with passed parameters.
- *
- * @details Once Bluetooth advertising is started, nearby Bluetooth LE(Low Energy) supported
- * devices can know this device's existence. And one of them can make a connection reqeust,
- * if it is allowed.
- *
- * @param[in]  adv_params  The parameters of advertising \n
- *				If NULL is passed, default values which are defined in driver / controller are used.
- *
- * @retval #BT_ERROR_NONE  Successful
- * @retval #BT_ERROR_NOT_INITIALIZED  Not initialized
- * @retval #BT_ERROR_NOT_ENABLED  Not enabled
- * @retval #BT_ERROR_NOW_IN_PROGRESS  Operation is now in progress
- * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
- *
- * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED with bt_adapter_enable().
- * @post This function invokes bt_adapter_advertising_state_changed_cb().
- *
- * @see bt_adapter_enable()
- * @see bt_adapter_is_advertising()
- * @see bt_adapter_stop_advertising()
- * @see bt_adapter_advertising_state_changed_cb()
- * @see bt_adapter_set_advertising_state_changed_cb()
- * @see bt_adapter_unset_advertising_state_changed_cb()
- */
-int bt_adapter_start_advertising(bt_adapter_advertising_params_s *adv_params);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief Stops the advertising.
- *
- * @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_NOT_IN_PROGRESS  Operation is not in progress
- * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
- *
- * @pre The advertising must be going on with bt_adapter_start_advertising().
- * @post This function invokes bt_adapter_advertising_state_changed_cb().
- *
- * @see bt_adapter_is_advertising()
- * @see bt_adapter_start_advertising()
- * @see bt_adapter_set_advertising_state_changed_cb()
- * @see bt_adapter_unset_advertising_state_changed_cb()
- * @see bt_adapter_advertising_state_changed_cb()
- */
-int bt_adapter_stop_advertising(void);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief Checks for the advertising is going on or stopped.
- *
- * @remarks If Bluetooth advertising is going on, other LE devices are able to
- * search this device.
-
- * @param[out] is_advertising The advertising status: (@c true = going on, @c  false = stopped)
- *
- * @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 state of local Bluetooth must be #BT_ADAPTER_ENABLED with bt_adapter_enable().
- *
- * @see bt_adapter_enable()
- * @see bt_adapter_start_advertising()
- * @see bt_adapter_stop_advertising()
- */
-int bt_adapter_is_advertising(bool *is_advertising);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief add address to whitelist for accepting scanning request.
- *
- * @remarks If the adress is in the whitelist then other LE devices are able to
- * search this device. Before calling this API, make sure that the adapter is
- * enabled. There is no callback event for this API.
-
- * @param[in] address The other device's address
- *
- * @return 0 on success, otherwise a negative error value.
- * @retval #BT_ERROR_NONE  Successful
- * @retval #BT_ERROR_NOT_ENABLED  Adapter is not enabled
- *
- * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED with bt_adapter_enable().
- *
- * @see bt_adapter_enable()
- * @see bt_adapter_start_advertising()
- * @see bt_adapter_stop_advertising()
- */
-int bt_adapter_add_white_list(const char *address);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief remove address from the whitelist for not accepting scanning request.
- *
- * @remarks If the adress is in the whitelist then other LE devices are able to
- * search this device. Before calling this API, make sure that the adapter is
- * enabled. There is no callback event for this API.
- *
- * @param[in] address The other device's address
- *
- * @return 0 on success, otherwise a negative error value.
- * @retval #BT_ERROR_NONE  Successful
- * @retval #BT_ERROR_NOT_ENABLED  Adapter is not enabled
- *
- * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED with bt_adapter_enable().
- *
- * @see bt_adapter_enable()
- * @see bt_adapter_start_advertising()
- * @see bt_adapter_stop_advertising()
- */
-int bt_adapter_remove_white_list(const char *address);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief clear address from the whitelist for not accepting scanning request.
- *
- * @remarks If the adress is in the whitelist then other LE devices are able to
- * search this device. Before calling this API, make sure that the adapter is
- * enabled. There is no callback event for this API.
- *
- * @return 0 on success, otherwise a negative error value.
- * @retval #BT_ERROR_NONE  Successful
- * @retval #BT_ERROR_NOT_ENABLED  Adapter is not enabled
- *
- * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED with bt_adapter_enable().
- *
- * @see bt_adapter_enable()
- * @see bt_adapter_start_advertising()
- * @see bt_adapter_stop_advertising()
- */
-int bt_adapter_clear_white_list(void);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief Gets the manfucaturer specific data for advertising of local Bluetooth adapter.
- *
- * @details Use this function to get the manfucaturer specific data associated with Bluetooth
- * device, retrieved by the remote Bluetooth devices.
- *
- * @remarks The @a data must be released with free() by you.
- *
- * @param[out]   data	The manufacturer specific data
- * @param[out]   len	The length of @a data
- *
- * @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_OUT_OF_MEMORY  Out of memory
- * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
- *
- * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED with bt_adapter_enable().
- *
- * @see bt_adapter_enable()
- * @see bt_adapter_set_advertising_manufacturer_data()
- */
-int bt_adapter_get_advertising_manufacturer_data(char **data, int *len);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief Sets the manufacturer specific data for advertising of local Bluetooth adapter.
- *
- * @param[in]   data	The manufacturer specific data of the Bluetooth device.
- * @param[in]   len	The length of @a data. The maximum length is 26(bytes).
- *
- * @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 state of local Bluetooth must be #BT_ADAPTER_ENABLED with bt_adapter_enable().
- * @post bt_adapter_advertising_manufacturer_data_changed_cb() will be invoked
- * if this function returns #BT_ERROR_NONE.
- *
- * @see bt_adapter_enable()
- * @see bt_adapter_get_advertising_manufacturer_data()
- * @see bt_adapter_advertising_manufacturer_data_changed_cb()
- * @see bt_adapter_set_advertising_manufacturer_data_changed_cb()
- * @see bt_adapter_unset_advertising_manufacturer_data_changed_cb()
- */
-int bt_adapter_set_advertising_manufacturer_data(char *data, int len);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief  Called when the manufacturer specific data for advertising changes.
- * @param[in]   data		The manufacurer specific data of the Bluetooth device to be changed
- * @param[in]   len		The length of @a data
- * @param[in]   user_data	The user data passed from the callback registration function
- * @pre This function will be invoked when the manufacturer specific data of Bluetooth adapter changes
- * if you register this callback using bt_adapter_set_manufacturer_data_changed_cb().
- * @see bt_adapter_set_manufacturer_data()
- * @see bt_adapter_set_manufacturer_data_changed_cb()
- * @see bt_adapter_unset_manufacturer_data_changed_cb()
- */
-typedef void (*bt_adapter_advertising_manufacturer_data_changed_cb)(char *data,
-		int len, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
- * @brief  Registers a callback function to be invoked
- * when the manufacturer specific data for advertising of Bluetooth adapter changes.
- *
- * @param[in]   callback	The callback function to invoke
- * @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_adapter_advertising_manufacturer_data_changed_cb() will be invoked.
- *
- * @see bt_initialize()
- * @see bt_adapter_manufacturer_data_changed_cb()
- * @see bt_adapter_unset_manufacturer_data_changed_cb()
- */
-int bt_adapter_set_advertising_manufacturer_data_changed_cb(
-		bt_adapter_advertising_manufacturer_data_changed_cb callback,
-		void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_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_adapter_set_manufacturer_data_changed_cb()
- */
-int bt_adapter_unset_advertising_manufacturer_data_changed_cb(void);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_HF_MODULE
- * @brief Initializes the Bluetooth HF profile related with audio.
- * @remarks This function must be called before Bluetooth profiles related with audio starts.
- * @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_hf_deinitialize()
- */
-int bt_hf_initialize(void);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_HF_MODULE
- * @brief Deinitializes the Bluetooth HF profile 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_hf_deinitialize(void);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_HF_MODULE
- * @brief Notifies the call event to the remote bluetooth device.
- * @remarks Before notifying #BT_HF_CALL_EVENT_ANSWERED or #BT_HF_CALL_EVENT_DIALING, you should open SCO(Synchronous Connection Oriented link)
- * if Bluetooth Hands-Free need SCO connection.
- * @param[in] event  The call event
- * @param[in] call_id  The call ID
- * @param[in] phone_number  The phone number. You must set this value in case of #BT_HF_CALL_EVENT_DIALING and #BT_HF_CALL_EVENT_INCOMING.
- * In other cases, this value can be NULL.
- * @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_REMOTE_DEVICE_NOT_CONNECTED  Remote device is not connected
- * @pre The Bluetooth audio device must be connected with bt_audio_connect().
- * @see bt_audio_connect()
- */
-int bt_hf_notify_call_event(bt_hf_call_event_e event, char *phone_number);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_HF_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] 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_hf_get_speaker_gain()
- * @see bt_hf_set_speaker_gain_changed_cb()
- * @see bt_hf_unset_speaker_gain_changed_cb()
- */
-int bt_hf_notify_speaker_gain(int gain);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_HF_MODULE
- * @brief  Called when the speaker gain of the remote device is changed.
- * @param[in] gain The gain of speaker (0 ~ 15)
- * @param[in] user_data The user data passed from the callback registration function
- * @see bt_hf_set_speaker_gain_changed_cb()
- * @see bt_hf_unset_speaker_gain_changed_cb()
- */
-typedef void (*bt_hf_speaker_gain_changed_cb) (int gain, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_HF_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_hf_unset_speaker_gain_changed_cb()
- */
-int bt_hf_set_speaker_gain_changed_cb(bt_hf_speaker_gain_changed_cb callback, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_HF_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_hf_set_speaker_gain_changed_cb()
- */
-int bt_hf_unset_speaker_gain_changed_cb(void);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_HF_MODULE
- * @brief Notifies the state of voice recognition.
- * @param[in] state  The state of voice recognition: (@c true = enabled, @c  false = disabled)
- * @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_REMOTE_DEVICE_NOT_CONNECTED  Remote device is not connected
- * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
- * @pre The Bluetooth audio device must be connected with bt_audio_connect().
- * @see bt_audio_connect()
- */
-int bt_hf_notify_voice_recognition_state(bool state);
-
-/**
- * Samsung XSAT Vendor dependent command
- */
-typedef struct {
-	gint app_id;
-	char *message;
-} bluetooth_vendor_dep_at_cmd;
-
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_HF_MODULE
- * @brief  Called when a call handling event happened from Hands-Free.
- * @param[in] event  The call handling event happened from Hands-Free
- * @param[in] call_id  The call ID
- * @param[in] user_data The user data passed from the callback registration function
- * @see bt_hf_set_call_handling_event_cb()
- * @see bt_hf_unset_call_handling_event_cb()
- */
-typedef void (*bt_hf_vendor_dep_cmd_event_cb) (bluetooth_vendor_dep_at_cmd cmd);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_HF_MODULE
- * @brief  Registers a callback function that will be invoked when a call handling event happened from Hands-Free.
- * @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_hf_call_handling_event_cb()
- * @see bt_hf_unset_call_handling_event_cb()
- */
-int bt_hf_set_vendor_dep_cmd_event_cb(bt_hf_vendor_dep_cmd_event_cb callback, void *user_data);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_HF_MODULE
- * @brief Notifies the vendor commands.
- * @param[in] appid  The application id of the sender application
- * @param[in] msg  The message returned after given command
- * @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_REMOTE_DEVICE_NOT_CONNECTED  Remote device is not connected
- * @retval #BT_ERROR_OPERATION_FAILED  Operation failed
- * @pre The Bluetooth audio device must be connected with bt_audio_connect().
- * @see bt_audio_connect()
- */
-int bt_hf_notify_vendor_cmd(int appid, char *msg);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_HF_MODULE
- * @brief Closes an opened SCO(Synchronous Connection Oriented link), synchronously.
- * @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
- */
-int bt_hf_close_sco(void);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_HF_MODULE
- * @brief Sends the DTMF(Dual Tone Multi Frequency).
- * @param[in] dtmf  The DTMF to send
- * @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 device must be connected with bt_audio_connect().
- * @see bt_audio_connect()
- */
-int bt_hf_send_dtmf(char *dtmf);
-
-/**
- * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_HF_MODULE
- * @brief Gets the HF(Hands-Free) profile connected status.
- * @param[out] connected the connected status: (@c true = connected , @c  false = not connected )
- * @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
- * @pre The state of local Bluetooth must be #BT_ADAPTER_ENABLED with bt_adapter_enable().
- * @see bt_adapter_enable()
- */
-int bt_hf_is_hf_connected(bool *connected);
-
-
-/**
- * @}
- */
-
-
-#ifdef __cplusplus
-}
-#endif /* __cplusplus */
-
-#endif // __TIZEN_NETWORK_BLUETOOTH_H__
diff --git a/wearable/src/bluetooth-audio.c b/wearable/src/bluetooth-audio.c
deleted file mode 100755
index 67bc251..0000000
--- a/wearable/src/bluetooth-audio.c
+++ /dev/null
@@ -1,759 +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 <dlog.h>
-#include <stdbool.h>
-#include <bluetooth-api.h>
-#include <string.h>
-#include "bluetooth.h"
-#include "bluetooth_private.h"
-#include "bluetooth-audio-api.h"
-#include "bluetooth-telephony-api.h"
-#include "bluetooth-scmst-api.h"
-
-typedef struct _call_list_s {
-	GList *list;
-} call_list_s;
-
-/*The below API is just to convert the error from Telephony 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_telephony_error_code(int error)
-{
-	switch(error) {
-	case BLUETOOTH_TELEPHONY_ERROR_NONE:
-		return BT_ERROR_NONE;
-	case BLUETOOTH_TELEPHONY_ERROR_INVALID_PARAM:
-		return BT_ERROR_INVALID_PARAMETER;
-	case BLUETOOTH_TELEPHONY_ERROR_NOT_INITIALIZED:
-		return BT_ERROR_NOT_INITIALIZED;
-	case BLUETOOTH_TELEPHONY_ERROR_NOT_ENABLED:
-		return BT_ERROR_NOT_ENABLED;
-	case BLUETOOTH_TELEPHONY_ERROR_AUDIO_NOT_CONNECTED:
-	case BLUETOOTH_TELEPHONY_ERROR_NOT_CONNECTED:
-		return BT_ERROR_REMOTE_DEVICE_NOT_CONNECTED;
-	case BLUETOOTH_TELEPHONY_ERROR_BUSY:
-		return BT_ERROR_RESOURCE_BUSY;
-	case BLUETOOTH_TELEPHONY_ERROR_NO_MEMORY:
-		return BT_ERROR_OUT_OF_MEMORY;
-	case BLUETOOTH_TELEPHONY_ERROR_ALREADY_INITIALIZED:
-	case BLUETOOTH_TELEPHONY_ERROR_ALREADY_EXSIST:
-	case BLUETOOTH_TELEPHONY_ERROR_ALREADY_CONNECTED:
-		return BT_ERROR_ALREADY_DONE;
-	case BLUETOOTH_TELEPHONY_ERROR_INTERNAL:
-	case BLUETOOTH_TELEPHONY_ERROR_NOT_AVAILABLE:
-	case BLUETOOTH_TELEPHONY_ERROR_I_O_ERROR:
-	case BLUETOOTH_TELEPHONY_ERROR_OPERATION_NOT_AVAILABLE:
-		return BT_ERROR_OPERATION_FAILED;
-	default:
-		return BT_ERROR_NONE;
-	}
-}
-
-int bt_audio_initialize(void)
-{
-	int error;
-
-	BT_CHECK_INIT_STATUS();
-	error = bluetooth_audio_init(_bt_audio_event_proxy, NULL);
-	error = _bt_get_error_code(error);
-	if (BT_ERROR_NONE != error) {
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error);
-		return error;
-	}
-
-	error = bluetooth_hf_init(_bt_hf_event_proxy, NULL);
-	error = _bt_get_error_code(error);
-	if (BT_ERROR_NONE != error) {
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error);
-		return error;
-	}
-	return error;
-}
-
-int bt_audio_deinitialize(void)
-{
-	int error;
-
-	BT_CHECK_INIT_STATUS();
-	error = bluetooth_hf_deinit();
-	error = _bt_get_error_code(error);
-	if (BT_ERROR_NONE != error) {
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error);
-		return error;
-	}
-
-	error = bluetooth_audio_deinit();
-	error = _bt_get_error_code(error);
-	if (BT_ERROR_NONE != error) {
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error);
-		return error;
-	}
-	return error;
-}
-
-int bt_audio_connect(const char *remote_address, bt_audio_profile_type_e type)
-{
-	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);
-	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_AG:
-		error = bluetooth_hf_connect(&addr_hex);
-		break;
-	case BT_AUDIO_PROFILE_TYPE_ALL:
-	default:
-		error = bluetooth_audio_connect(&addr_hex);
-		break;
-	}
-	error = _bt_get_error_code(error);
-	if (error != BT_ERROR_NONE) {
-		BT_ERR("%s(0x%08x)", _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;
-	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_AG:
-		error = bluetooth_hf_disconnect(&addr_hex);
-		break;
-	case BT_AUDIO_PROFILE_TYPE_ALL:
-	default:
-		error = bluetooth_audio_disconnect(&addr_hex);
-		break;
-	}
-	error = _bt_get_error_code(error);
-	if (error != BT_ERROR_NONE) {
-		BT_ERR("%s(0x%08x)", _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(int gain)
-{
-	int error;
-
-	BT_CHECK_INIT_STATUS();
-	error = bluetooth_telephony_set_speaker_gain((unsigned short)gain);
-	error = _bt_convert_telephony_error_code(error);
-	if (BT_ERROR_NONE != error) {
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error);
-	}
-	return error;
-}
-
-int bt_ag_get_speaker_gain(int *gain)
-{
-	int error;
-
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(gain);
-	error = bluetooth_telephony_get_headset_volume((unsigned int *)gain);
-	error = _bt_convert_telephony_error_code(error);
-	if (BT_ERROR_NONE != error) {
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error);
-	}
-	return error;
-}
-
-int bt_ag_is_nrec_enabled(bool *enabled)
-{
-	int error;
-	gboolean is_enabled = false;
-
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(enabled);
-
-	error = bluetooth_telephony_is_nrec_enabled(&is_enabled);
-	error = _bt_convert_telephony_error_code(error);
-	if (BT_ERROR_NONE != error) {
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error);
-	}
-	if (is_enabled)
-		*enabled = true;
-	else
-		*enabled = false;
-
-	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;
-}
-
-int bt_ag_open_sco(void)
-{
-	int error;
-
-	BT_CHECK_INIT_STATUS();
-	error = bluetooth_telephony_audio_open();
-	error = _bt_convert_telephony_error_code(error);
-	if (error != BT_ERROR_NONE) {
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error);
-	}
-	return error;
-}
-
-int bt_ag_close_sco(void)
-{
-	int error;
-
-	BT_CHECK_INIT_STATUS();
-	error = bluetooth_telephony_audio_close();
-	error = _bt_convert_telephony_error_code(error);
-	if (error != BT_ERROR_NONE) {
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error);
-	}
-	return error;
-}
-
-int bt_ag_is_sco_opened(bool *opened)
-{
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(opened);
-	if (bluetooth_telephony_is_sco_connected())
-		*opened = true;
-	else
-		*opened = false;
-	return BT_ERROR_NONE;
-}
-
-int bt_ag_set_sco_state_changed_cb(bt_ag_sco_state_changed_cb callback,
-					void *user_data)
-{
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(callback);
-	_bt_set_cb(BT_EVENT_AG_SCO_CONNECTION_STATUS, callback, user_data);
-	return BT_ERROR_NONE;
-}
-
-int bt_ag_unset_sco_state_changed_cb(void)
-{
-	BT_CHECK_INIT_STATUS();
-	if (_bt_check_cb(BT_EVENT_AG_SCO_CONNECTION_STATUS) == true)
-		_bt_unset_cb(BT_EVENT_AG_SCO_CONNECTION_STATUS);
-	return BT_ERROR_NONE;
-}
-
-int bt_ag_notify_call_event(bt_ag_call_event_e event, unsigned int call_id, const char *phone_number)
-{
-	int error;
-
-	BT_CHECK_INIT_STATUS();
-	switch(event) {
-	case BT_AG_CALL_EVENT_IDLE:
-		error = bluetooth_telephony_call_end(call_id);
-		break;
-	case BT_AG_CALL_EVENT_ANSWERED:
-		error = bluetooth_telephony_call_answered(call_id, FALSE);
-		break;
-	case BT_AG_CALL_EVENT_HELD:
-		error = bluetooth_telephony_call_held(call_id);
-		break;
-	case BT_AG_CALL_EVENT_RETRIEVED:
-		error = bluetooth_telephony_call_retrieved(call_id);
-		break;
-	case BT_AG_CALL_EVENT_DIALING:
-		BT_CHECK_INPUT_PARAMETER(phone_number);
-		error = bluetooth_telephony_indicate_outgoing_call(
-					phone_number, call_id, FALSE);
-		break;
-	case BT_AG_CALL_EVENT_ALERTING:
-		error = bluetooth_telephony_call_remote_ringing(call_id);
-		break;
-	case BT_AG_CALL_EVENT_INCOMING:
-		BT_CHECK_INPUT_PARAMETER(phone_number);
-		error = bluetooth_telephony_indicate_incoming_call(phone_number,
-					call_id);
-		break;
-	default:
-		error = BT_ERROR_INVALID_PARAMETER;
-	}
-	error = _bt_convert_telephony_error_code(error);
-	if (error != BT_ERROR_NONE) {
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error);
-	}
-	return error;
-}
-
-int bt_ag_notify_call_list(bt_call_list_h list)
-{
-	int error;
-	unsigned int call_count;
-	call_list_s *handle;
-
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(list);
-	handle = (call_list_s *)list;
-	call_count = g_list_length(handle->list);
-	error = bluetooth_telephony_set_call_status((void *)handle->list, call_count);
-	error = _bt_convert_telephony_error_code(error);
-	if (error != BT_ERROR_NONE) {
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error);
-	}
-	return error;
-}
-
-int bt_ag_notify_voice_recognition_state(bool state)
-{
-	int error;
-
-	BT_CHECK_INIT_STATUS();
-	if (state)
-		error = bluetooth_telephony_start_voice_recognition();
-	else
-		error = bluetooth_telephony_stop_voice_recognition();
-	error = _bt_convert_telephony_error_code(error);
-	if (error != BT_ERROR_NONE) {
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error);
-	}
-	return error;
-}
-
-int bt_ag_set_call_handling_event_cb(bt_ag_call_handling_event_cb callback,
-					void *user_data)
-{
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(callback);
-	_bt_set_cb(BT_EVENT_AG_CALL_HANDLING_EVENT, callback, user_data);
-	return BT_ERROR_NONE;
-
-}
-
-int bt_ag_unset_call_handling_event_cb(void)
-{
-	BT_CHECK_INIT_STATUS();
-	if (_bt_check_cb(BT_EVENT_AG_CALL_HANDLING_EVENT) == true)
-		_bt_unset_cb(BT_EVENT_AG_CALL_HANDLING_EVENT);
-	return BT_ERROR_NONE;
-}
-
-int bt_hf_set_sco_state_changed_cb(bt_hf_sco_state_changed_cb callback,
-					void *user_data)
-{
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(callback);
-	_bt_set_cb(BT_EVENT_HF_SCO_CONNECTION_STATUS, callback, user_data);
-	return BT_ERROR_NONE;
-}
-
-int bt_hf_unset_sco_state_changed_cb(void)
-{
-	BT_CHECK_INIT_STATUS();
-	if (_bt_check_cb(BT_EVENT_HF_SCO_CONNECTION_STATUS) == true)
-		_bt_unset_cb(BT_EVENT_HF_SCO_CONNECTION_STATUS);
-	return BT_ERROR_NONE;
-}
-
-int bt_hf_set_call_handling_event_cb(bt_hf_call_handling_event_cb callback,
-					void *user_data)
-{
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(callback);
-	_bt_set_cb(BT_EVENT_HF_CALL_HANDLING_EVENT, callback, user_data);
-	return BT_ERROR_NONE;
-
-}
-
-int bt_hf_unset_call_handling_event_cb(void)
-{
-	BT_CHECK_INIT_STATUS();
-	if (_bt_check_cb(BT_EVENT_HF_CALL_HANDLING_EVENT) == true)
-		_bt_unset_cb(BT_EVENT_HF_CALL_HANDLING_EVENT);
-	return BT_ERROR_NONE;
-}
-
-int bt_hf_set_multi_call_handling_event_cb(
-					bt_hf_multi_call_handling_event_cb callback,
-					void *user_data)
-{
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(callback);
-	_bt_set_cb(BT_EVENT_HF_MULTI_CALL_HANDLING_EVENT, callback, user_data);
-	return BT_ERROR_NONE;
-}
-
-int bt_hf_unset_multi_call_handling_event_cb(void)
-{
-	BT_CHECK_INIT_STATUS();
-	if (_bt_check_cb(BT_EVENT_HF_MULTI_CALL_HANDLING_EVENT) == true)
-		_bt_unset_cb(BT_EVENT_HF_MULTI_CALL_HANDLING_EVENT);
-	return BT_ERROR_NONE;
-}
-
-int bt_ag_set_multi_call_handling_event_cb(
-					bt_ag_multi_call_handling_event_cb callback,
-					void *user_data)
-{
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(callback);
-	_bt_set_cb(BT_EVENT_AG_MULTI_CALL_HANDLING_EVENT, callback, user_data);
-	return BT_ERROR_NONE;
-}
-
-int bt_ag_unset_multi_call_handling_event_cb(void)
-{
-	BT_CHECK_INIT_STATUS();
-	if (_bt_check_cb(BT_EVENT_AG_MULTI_CALL_HANDLING_EVENT) == true)
-		_bt_unset_cb(BT_EVENT_AG_MULTI_CALL_HANDLING_EVENT);
-	return BT_ERROR_NONE;
-}
-
-int bt_ag_set_dtmf_transmitted_cb(bt_ag_dtmf_transmitted_cb callback,
-						void *user_data)
-{
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(callback);
-	_bt_set_cb(BT_EVENT_AG_DTMF_TRANSMITTED, callback, user_data);
-	return BT_ERROR_NONE;
-}
-
-int bt_ag_unset_dtmf_transmitted_cb(void)
-{
-	BT_CHECK_INIT_STATUS();
-	if (_bt_check_cb(BT_EVENT_AG_DTMF_TRANSMITTED) == true)
-		_bt_unset_cb(BT_EVENT_AG_DTMF_TRANSMITTED);
-	return BT_ERROR_NONE;
-}
-
-int bt_call_list_create(bt_call_list_h *list)
-{
-	call_list_s *handle;
-
-	BT_CHECK_INIT_STATUS();
-	if (*list != NULL) {
-		BT_ERR("BT_ERROR_ALREADY_DONE(0x%08x)", BT_ERROR_ALREADY_DONE);
-		return BT_ERROR_ALREADY_DONE;
-	}
-	handle = g_malloc0(sizeof(call_list_s));
-	*list = handle;
-	return BT_ERROR_NONE;
-}
-
-int bt_call_list_destroy(bt_call_list_h list)
-{
-	int result;
-	call_list_s *handle;
-
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(list);
-	handle = (call_list_s *)list;
-	result = bt_call_list_reset(list);
-	g_free(handle);
-	return result;
-}
-
-int bt_call_list_reset(bt_call_list_h list)
-{
-	call_list_s *handle;
-	bt_telephony_call_status_info_t *call_status;
-
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(list);
-	handle = (call_list_s *)list;
-	do  {
-		call_status = (bt_telephony_call_status_info_t *)g_list_nth_data(handle->list, 0);
-		if (call_status == NULL)
-			break;
-		handle->list = g_list_remove(handle->list, call_status);
-		g_free(call_status);
-	} while (1);
-	return BT_ERROR_NONE;
-}
-
-int bt_call_list_add(bt_call_list_h list, unsigned int call_id, bt_ag_call_state_e state)
-{
-	call_list_s *handle;
-	bt_telephony_call_status_info_t *call_status;
-
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(list);
-	handle = (call_list_s *)list;
-	call_status = g_malloc0(sizeof(bt_telephony_call_status_info_t));
-	call_status->call_id = call_id;
-	call_status->call_status = state;
-	handle->list = g_list_append(handle->list, (gpointer)call_status);
-	return BT_ERROR_NONE;
-}
-
-int bt_a2dp_set_content_protection(bool status)
-{
-	int error;
-
-	error = bluetooth_a2dp_set_content_protection(status);
-	error = _bt_get_error_code(error);
-	if (BT_ERROR_NONE != error) {
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error);
-		return error;
-	}
-	return error;
-}
-
-int bt_hf_initialize(void)
-{
-	int error;
-
-	BT_CHECK_INIT_STATUS();
-	error = bluetooth_hf_init(_bt_hf_event_proxy, NULL);
-	error = _bt_get_error_code(error);
-	if (BT_ERROR_NONE != error) {
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error);
-		return error;
-	}
-	return error;
-}
-
-int bt_hf_deinitialize(void)
-{
-	int error;
-
-	BT_CHECK_INIT_STATUS();
-	error = bluetooth_hf_deinit();
-	error = _bt_get_error_code(error);
-	if (BT_ERROR_NONE != error) {
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error);
-		return error;
-	}
-	return error;
-}
-
-int bt_hf_notify_call_event(bt_hf_call_event_e event, char *phone_number)
-{
-	int error = BT_ERROR_NONE;
-
-	BT_CHECK_INIT_STATUS();
-	BT_INFO("event [%d]", event);
-
-	switch(event) {
-	case BT_HF_CALL_EVENT_IDLE:
-		error = bluetooth_hf_terminate_call();
-		break;
-	case BT_HF_CALL_EVENT_ANSWER:
-		error = bluetooth_hf_answer_call();
-		break;
-	case BT_HF_CALL_EVENT_HOLD:
-		break;
-	case BT_HF_CALL_EVENT_RETRIEVE:
-		break;
-	case BT_HF_CALL_EVENT_DIAL:
-		BT_CHECK_INPUT_PARAMETER(phone_number);
-		error = bluetooth_hf_initiate_call(phone_number);
-		break;
-	case BT_HF_CALL_EVENT_REDIAL:
-		break;
-	case BT_HF_CALL_EVENT_RELEASE_ALL_NONACTIVE_CALLS:
-		error = bluetooth_hf_release_all_call();
-		break;
-	case BT_HF_CALL_EVENT_ACCEPT_AND_RELEASE:
-		error = bluetooth_hf_release_and_accept();
-		break;
-	case BT_HF_CALL_EVENT_ACCEPT_AND_HOLD:
-		error = bluetooth_hf_swap_call();
-		break;
-	case BT_HF_CALL_EVENT_ADD_TO_CONVERSATION:
-		error = bluetooth_hf_join_call();
-		break;
-	default:
-		error = BT_ERROR_INVALID_PARAMETER;
-		break;
-	}
-
-	error = _bt_get_error_code(error);
-	if (error != BT_ERROR_NONE) {
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error);
-	}
-	return error;
-}
-
-int bt_hf_notify_speaker_gain(int gain)
-{
-	int error;
-
-	BT_CHECK_INIT_STATUS();
-	error = bluetooth_hf_set_speaker_gain((unsigned int)gain);
-	error = _bt_get_error_code(error);
-	if (BT_ERROR_NONE != error)
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error);
-
-	return error;
-}
-
-int bt_hf_set_speaker_gain_changed_cb(bt_hf_speaker_gain_changed_cb callback, void *user_data)
-{
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(callback);
-	_bt_set_cb(BT_EVENT_HF_SPEAKER_GAIN_CHANGE, callback, user_data);
-	return BT_ERROR_NONE;
-}
-
-int bt_hf_unset_speaker_gain_changed_cb(void)
-{
-	BT_CHECK_INIT_STATUS();
-	if (_bt_check_cb(BT_EVENT_HF_SPEAKER_GAIN_CHANGE) == true)
-		_bt_unset_cb(BT_EVENT_HF_SPEAKER_GAIN_CHANGE);
-	return BT_ERROR_NONE;
-}
-
-int bt_hf_notify_voice_recognition_state(bool state)
-{
-	int error;
-
-	BT_CHECK_INIT_STATUS();
-	error = bluetooth_hf_voice_recognition(state);
-	error = _bt_get_error_code(error);
-	if (error != BT_ERROR_NONE)
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error);
-
-	return error;
-}
-
-int bt_hf_set_vendor_dep_cmd_event_cb(bt_hf_vendor_dep_cmd_event_cb callback, void *user_data)
-{
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(callback);
-	_bt_set_cb(BT_EVENT_HF_VENDOR_DEP_CMD_EVENT, callback, user_data);
-	return BT_ERROR_NONE;
-}
-
-int bt_hf_notify_vendor_cmd(int appid, char *msg)
-{
-	int error;
-
-	BT_CHECK_INIT_STATUS();
-	error = bluetooth_hf_send_xsat_cmd(appid, msg);
-	error = _bt_get_error_code(error);
-	if (error != BT_ERROR_NONE)
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error);
-
-	return error;
-}
-
-int bt_hf_close_sco(void)
-{
-	int error;
-
-	BT_CHECK_INIT_STATUS();
-	error = bluetooth_hf_audio_disconnect();
-	error = _bt_get_error_code(error);
-	if (error != BT_ERROR_NONE)
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error);
-
-	return error;
-}
-
-int bt_hf_send_dtmf(char *dtmf)
-{
-	int error;
-
-	BT_CHECK_INIT_STATUS();
-	error = bluetooth_hf_send_dtmf(dtmf);
-	error = _bt_get_error_code(error);
-	if (error != BT_ERROR_NONE)
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error);
-
-	return error;
-}
-
-int bt_hf_is_hf_connected(bool *connected)
-{
-	int error;
-	gboolean is_connected = false;
-
-	BT_CHECK_INIT_STATUS();
-	BT_CHECK_INPUT_PARAMETER(connected);
-
-	error = bluetooth_hf_is_hf_connected(&is_connected);
-	error = _bt_get_error_code(error);
-	if (error != BT_ERROR_NONE)
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error);
-
-	if (is_connected)
-		*connected = true;
-	else
-		*connected = false;
-
-	return error;
-}
-
diff --git a/wearable/src/bluetooth-pan.c b/wearable/src/bluetooth-pan.c
deleted file mode 100644
index d4f171a..0000000
--- a/wearable/src/bluetooth-pan.c
+++ /dev/null
@@ -1,142 +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 <dlog.h>
-#include <stdio.h>
-#include <stdbool.h>
-#include <string.h>
-#include <bluetooth-api.h>
-
-#include "bluetooth.h"
-#include "bluetooth_private.h"
-
-GList *sending_files;
-
-int bt_nap_activate(void)
-{
-	int error = BT_ERROR_NONE;
-
-	BT_CHECK_INIT_STATUS();
-	error = bluetooth_network_activate_server();
-	error = _bt_get_error_code(error);
-	if (error != BT_ERROR_NONE) {
-		BT_ERR("%s(0x%08x)", _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();
-	error = _bt_get_error_code(error);
-	if (error != BT_ERROR_NONE) {
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error);
-	}
-	return error;
-}
-
-/* bluez don't support the disconnect API about NAP server */
-/* So we implement this, deactivate the server and re-activate the server */
-int bt_nap_disconnect_all(void)
-{
-	int error = BT_ERROR_NONE;
-
-	BT_CHECK_INIT_STATUS();
-	error = bluetooth_network_deactivate_server();
-	error = _bt_get_error_code(error);
-	if (error != BT_ERROR_NONE) {
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error);
-	} else {
-		return bt_nap_activate();
-	}
-
-	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);
-		error = _bt_get_error_code(error);
-		if (error != BT_ERROR_NONE) {
-			BT_ERR("%s(0x%08x)", _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);
-	error = _bt_get_error_code(error);
-	if (error != BT_ERROR_NONE) {
-		BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error),
-				error);
-	}
-	return error;
-}
-
diff --git a/wearable/test/bt_unit_test.c b/wearable/test/bt_unit_test.c
deleted file mode 100644
index 0041102..0000000
--- a/wearable/test/bt_unit_test.c
+++ /dev/null
@@ -1,1838 +0,0 @@
-/*
- * capi-network-bluetooth
- *
- * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact:  Hocheol Seo <hocheol.seo@samsung.com>
- *		 Girishashok Joshi <girish.joshi@samsung.com>
- *		 Chanyeol Park <chanyeol.park@samsung.com>
- *
- * 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.
- *
- */
-
-/**
- * @file       bt_unit_test.c
- * @brief      This is the source file for capi unit test.
- */
-
-#include <stdio.h>
-#include <string.h>
-#include <fcntl.h>
-#include <unistd.h>
-#include <glib.h>
-#include <dbus/dbus-glib.h>
-
-#include "bluetooth.h"
-#include "bluetooth-telephony-api.h"
-
-#define BUFFER_LEN 10
-#define MAX_SERVICES 10
-#define PRT(format, args...) printf("%s:%d() "format, __FUNCTION__, __LINE__, ##args)
-#define TC_PRT(format, args...) PRT(format"\n", ##args)
-
-#define DEVICE_ADDRESS "F6:FB:8F:D8:C8:7C"
-const char *spp_uuid = "00001101-0000-1000-8000-00805F9B34FB";
-const char *opp_uuid = "00001105-0000-1000-8000-00805f9b34fb";
-
-static int server_fd;
-static int client_fd;
-
-int service_index;
-int char_service_index;
-
-bt_gatt_attribute_h service_clone[MAX_SERVICES];
-bt_gatt_attribute_h characteristics[MAX_SERVICES];
-bt_gatt_attribute_h characteristics_services[MAX_SERVICES];
-
-static unsigned char *hash = NULL;
-static unsigned char *randomizer = NULL;
-int hash_len;
-int rand_len;
-
-bt_call_list_h call_list;
-GMainLoop *main_loop = NULL;
-
-typedef struct {
-	const char *tc_name;
-	int tc_code;
-} tc_table_t;
-
-tc_table_t tc_table[] = {
-	/* Adapter functions */
-	{"bt_initialize"			, 1},
-	{"bt_deinitialize"			, 2},
-	{"bt_adapter_get_state"			, 3},
-	{"bt_adapter_enable"			, 4},
-	{"bt_adapter_disable"			, 5},
-	{"bt_adapter_start_device_discovery"	, 6},
-	{"bt_adapter_stop_device_discovery"	, 7},
-	{"bt_adapter_is_discovering"		, 8},
-	{"bt_adapter_get_bonded_device_info"	, 9},
-	{"bt_adapter_is_service_used"		, 10},
-	{"bt_adapter_get_visibility"		, 11},
-	{"bt_adapter_set_device_discovery_state_changed_cb"	, 12},
-	{"bt_adapter_unset_device_discovery_state_changed_cb"	, 13},
-	{"bt_adapter_get_local_oob_data" , 14},
-	{"bt_adapter_set_remote_oob_data" , 15},
-	{"bt_adapter_remove_remote_oob_data"	, 16},
-	{"bt_adapter_start_discover_devices"	, 17},
-	{"bt_adapter_set_visibility_mode_changed_cb"	, 18},
-	{"bt_adapter_unset_visibility_mode_changed_cb"	, 19},
-	{"bt_adapter_set_advertising_state_changed_cb"	, 20},
-	{"bt_adapter_unset_advertising_state_changed_cb"	, 21},
-	{"bt_adapter_start_advertising"	, 22},
-	{"bt_adapter_stop_advertising"	, 23},
-	{"bt_adapter_is_advertising"	, 24},
-	{"bt_adapter_add_white_list"	, 25},
-	{"bt_adapter_remove_white_list"	, 26},
-	{"bt_adapter_clear_white_list"	, 27},
-	{"bt_adapter_set_advertising_manufacturer_data_changed_cb"	, 28},
-	{"bt_adapter_unset_advertising_manufacturer_data_changed_cb"	, 29},
-	{"bt_adapter_set_advertising_manufacturer_data"	, 30},
-	{"bt_adapter_get_advertising_manufacturer_data"	, 31},
-	{"bt_adapter_set_advertising_manufacturer_data with zero length"	, 32},
-	{"bt_adapter_set_connectable_changed_cb"	, 33},
-	{"bt_adapter_unset_connectable_changed_cb"	, 34},
-	{"bt_adapter_get_connectable"	, 35},
-	{"bt_adapter_set_connectable"	, 36},
-
-	/* Socket functions */
-	{"bt_socket_create_rfcomm"		, 50},
-	{"bt_socket_destroy_rfcomm"		, 51},
-	{"bt_socket_listen_and_accept_rfcomm"	, 52},
-	{"bt_socket_listen"			, 53},
-	{"bt_socket_accept"			, 54},
-	{"bt_socket_reject"			, 55},
-	{"bt_socket_connect_rfcomm"		, 56},
-	{"bt_socket_disconnect_rfcomm"		, 57},
-	{"bt_socket_send_data"			, 58},
-	{"bt_socket_set_data_received_cb"	, 59},
-	{"bt_socket_unset_data_received_cb"	, 60},
-	{"bt_socket_set_connection_requested_cb"	, 61},
-	{"bt_socket_unset_connection_requested_cb"	, 62},
-	{"bt_socket_set_connection_state_changed_cb"	, 63},
-	{"bt_socket_unset_connection_state_changed_cb"	, 64},
-
-	/* OPP functions */
-	{"bt_opp_client_initialize"		, 70},
-	{"bt_opp_client_deinitialize"		, 71},
-	{"bt_opp_client_add_file"		, 72},
-	{"bt_opp_client_clear_files"		, 73},
-	{"bt_opp_client_push_files"		, 74},
-	{"bt_opp_client_cancel_push"		, 75},
-
-	/* AG functions */
-	{"bt_audio_initialize"		, 80},
-	{"bt_audio_deinitialize"		, 81},
-	{"bt_audio_connect"		, 82},
-	{"bt_audio_disconnect"		, 83},
-	{"bt_audio_set_connection_state_changed_cb",		84},
-	{"bt_audio_unset_connection_state_changed_cb", 	85},
-	{"bt_ag_open_sco" 		, 86},
-	{"bt_ag_close_sco" 		, 87},
-	{"bt_ag_is_sco_opened"	, 88},
-	{"bt_ag_set_sco_state_changed_cb"	, 89},
-	{"bt_ag_unset_sco_state_changed_cb"	, 90},
-	{"BT_AG_CALL_EVENT_IDLE"		, 91},
-	{"BT_AG_CALL_EVENT_ANSWERED"	, 92},
-	{"BT_AG_CALL_EVENT_DIALING"		, 93},
-	{"BT_AG_CALL_EVENT_ALERTING"	, 94},
-	{"BT_AG_CALL_EVENT_INCOMING"	, 95},
-	{"bt_call_list_create" 			, 96},
-	{"bt_call_list_destroy" 		, 97},
-	{"bt_call_list_reset" 			, 98},
-	{"bt_call_list_add"	 			, 99},
-	{"bt_ag_notify_call_list"			, 100},
-	{"bt_ag_set_call_handling_event_cb"	, 101},
-	{"bt_ag_is_nrec_enabled"	, 102},
-
-	/* Network functions */
-	{"bt_nap_activate"		, 110},
-	{"bt_nap_deactivate"		, 111},
-	{"bt_nap_disconnect_all"	, 112},
-	{"bt_panu_set_connection_state_changed_cb"		, 113},
-	{"bt_panu_connect"	, 114},
-
-	/* Device functions */
-	{"bt_device_set_authorization (true)"	, 120},
-	{"bt_device_set_authorization (false)"	, 121},
-	{"bt_device_set_authorization_changed_cb"	, 122},
-	{"bt_device_unset_authorization_changed_cb"	, 123},
-	{"bt_device_set_connection_state_changed_cb"	, 124},
-	{"bt_device_unset_connection_state_changed_cb"	, 125},
-	{"bt_device_foreach_connected_profiles"	, 126},
-	{"bt_device_set_bond_created_cb" , 127},
-	{"bt_device_create_bond" , 128},
-	{"bt_device_connect_le" , 129},
-	{"bt_device_disconnect_le" , 130},
-	{"bt_device_set_disconnected_cb" , 131},
-
-	/* Gatt functions */
-	{"bt_gatt_foreach_primary_services"	, 140},
-	{"bt_gatt_discover_characteristics"	, 141},
-	{"bt_gatt_get_service_uuid"		, 142},
-	{"bt_gatt_foreach_included_services"		, 143},
-	{"bt_gatt_set_characteristic_changed_cb"	, 144},
-	{"bt_gatt_unset_characteristic_changed_cb"	, 145},
-	{"bt_gatt_get_characteristic_declaration"	, 146},
-	{"bt_gatt_set_characteristic_value"	, 147},
-	{"bt_gatt_read_characteristic_value"	 , 148},
-	{"bt_gatt_watch_characteristic_changes"	 , 150},
-	{"bt_gatt_unwatch_characteristic_changes"	 , 151},
-
-	/* AVRCP functions */
-	{"bt_avrcp_target_initialize"	, 160},
-	{"bt_avrcp_target_deinitialize"	, 161},
-	{"bt_avrcp_set_equalizer_state_changed_cb"	, 162},
-	{"bt_avrcp_set_repeat_mode_changed_cb"	, 163},
-	{"bt_avrcp_set_shuffle_mode_changed_cb"	, 164},
-	{"bt_avrcp_set_scan_mode_changed_cb"	, 165},
-	{"bt_avrcp_unset_equalizer_state_changed_cb"	, 166},
-	{"bt_avrcp_unset_repeat_mode_changed_cb"	, 167},
-	{"bt_avrcp_unset_shuffle_mode_changed_cb"	, 168},
-	{"bt_avrcp_unset_scan_mode_changed_cb"	, 169},
-
-	/* A2DP SCMS-T functions */
-	{"bluetooth_a2dp_set_content_protection(enable)"	, 170},
-	{"bluetooth_a2dp_set_content_protection(disable)"	, 171},
-
-	/* HF functions */
-	{"bt_hf_initialize"	, 172},
-	{"bt_hf_deinitialize"	, 173},
-	{"bt_hf_notify_call_event(answer)"	, 174},
-	{"bt_hf_notify_speaker_gain"	, 175},
-	{"bt_hf_set_speaker_gain_changed_cb"	, 176},
-	{"bt_hf_unset_speaker_gain_changed_cb"	, 177},
-	{"bt_hf_notify_voice_recognition_state(true)"	, 178},
-	{"bt_hf_notify_vendor_cmd"	, 179},
-	{"bt_hf_notify_call_event(terminate)"	, 180},
-	{"bt_hf_notify_call_event(initiate)"	, 181},
-	{"bt_hf_notify_voice_recognition_state(false)"	, 182},
-	{"bt_hf_set_sco_state_changed_cb()"	, 183},
-	{"bt_hf_unset_sco_state_changed_cb()"	, 184},
-	{"bt_hf_set_call_handling_event_cb()"	, 185},
-	/* -----------------------------------------*/
-	{"Finish"				, 0x00ff},
-	{NULL					, 0x0000},
-};
-
-void tc_usage_print(void)
-{
-	int i = 0;
-
-	while (tc_table[i].tc_name) {
-		if (tc_table[i].tc_code != 0x00ff) {
-			TC_PRT("Key %d : usage %s", tc_table[i].tc_code,
-						tc_table[i].tc_name);
-		} else {
-			TC_PRT("Key %d : usage %s\n\n", 0x00ff,
-						tc_table[i].tc_name);
-		}
-
-		i++;
-	}
-}
-
-static void __bt_free_gatt_services(void)
-{
-	int i;
-
-	for (i = 0; i < service_index; i++) {
-		bt_gatt_destroy_attribute_handle(service_clone[i]);
-		service_clone[i] = NULL;
-	}
-
-	service_index = 0;
-}
-
-static void __bt_free_gatt_characteristics(void)
-{
-	int i;
-
-	for (i = 0; i < MAX_SERVICES; i++) {
-		if (characteristics[i] == NULL)
-			return;
-
-		bt_gatt_destroy_attribute_handle(characteristics[i]);
-		characteristics[i] = NULL;
-	}
-}
-
-static void __bt_free_gatt_characteristics_services(void)
-{
-	int i;
-
-	for (i = 0; i < char_service_index; i++) {
-		bt_gatt_destroy_attribute_handle(characteristics_services[i]);
-		characteristics_services[i] = NULL;
-	}
-	char_service_index = 0;
-}
-
-static void __bt_adapter_device_visibility_mode_changed_cb(int result,
-				bt_adapter_visibility_mode_e visibility_mode,
-				void *user_data)
-{
-	TC_PRT("visibility_mode: %d", visibility_mode);
-}
-
-static void __bt_adapter_connectable_changed_cb(int result,
-				bool connectable, void *user_data)
-{
-	if (result != BT_ERROR_NONE) {
-		TC_PRT("connectable change is failed : [0x%04x]", result);
-		return;
-	}
-
-	TC_PRT("%s", connectable ? "Connectable" : "Non-connectable");
-}
-
-static void __bt_adapter_advertising_state_changed_cb(int result,
-				bt_adapter_advertising_state_e adv_state,
-				bt_adapter_advertising_params_s *adv_params,
-				void *user_data)
-{
-	if (result != BT_ERROR_NONE) {
-		TC_PRT("advertising state change is failed : [0x%04x]", result);
-		return;
-	}
-
-	if (adv_state == BT_ADAPTER_ADVERTISING_STARTED) {
-		TC_PRT("advertising is started "
-				"(interval - min : %f, max : %f, filter: %x)",
-				adv_params->interval_min,
-				adv_params->interval_max,
-				adv_params->filter_policy);
-	} else
-		TC_PRT("advertising is stopped");
-}
-
-static void __bt_adapter_advertising_manufacturer_data_changed_cb(char *data,
-						int len, void *user_data)
-{
-	int i;
-
-	TC_PRT("advertising manufacturer data is changed");
-	for (i = 0; i < len; i++) {
-		TC_PRT("[%d] %02x", i, data[i]);
-	}
-}
-static void __bt_adapter_device_discovery_state_changed_cb(int result,
-				bt_adapter_device_discovery_state_e discovery_state,
-				bt_adapter_device_discovery_info_s *discovery_info,
-				void *user_data)
-{
-	int i;
-
-	TC_PRT("discovery_state: %d", discovery_state);
-
-	if (discovery_info == NULL) {
-		TC_PRT("No discovery_info!");
-		return;
-	}
-
-	TC_PRT("remote_address: %s", discovery_info->remote_address);
-	TC_PRT("remote_name: %s", discovery_info->remote_name);
-	TC_PRT("rssi: %d", discovery_info->rssi);
-	TC_PRT("is_bonded: %d", discovery_info->is_bonded);
-	TC_PRT("service_count: %d", discovery_info->service_count);
-
-	if (discovery_info->service_uuid == NULL) {
-		TC_PRT("No uuids");
-		return;
-	}
-
-	for (i = 0; i < discovery_info->service_count; i++) {
-		TC_PRT("uuid: %s", discovery_info->service_uuid[i]);
-	}
-}
-
-static void __bt_socket_data_received_cb(bt_socket_received_data_s *data, void *user_data)
-{
-	TC_PRT("+");
-
-	if (data == NULL) {
-		TC_PRT("No recieved data!");
-		return;
-	}
-
-	TC_PRT("Socket fd: %d", data->socket_fd);
-	TC_PRT("Data: %s", data->data);
-	TC_PRT("Size: %d", data->data_size);
-}
-
-static void __bt_socket_connection_requested_cb(int socket_fd, const char *remote_address, void *user_data)
-{
-	TC_PRT("Socket fd: %d", socket_fd);
-	TC_PRT("remote_address: %s", remote_address);
-}
-
-static void __bt_socket_connection_state_changed_cb(int result,
-				bt_socket_connection_state_e connection_state,
-				bt_socket_connection_s *connection,
-				void *user_data)
-{
-	TC_PRT("result: %d", result);
-	TC_PRT("connection_state: %d", connection_state);
-
-	if (connection == NULL) {
-		TC_PRT("No connection data!");
-		return;
-	}
-
-	TC_PRT("socket fd: %d", connection->socket_fd);
-	TC_PRT("role: %d", connection->local_role);
-	TC_PRT("remote address: %s", connection->remote_address);
-	TC_PRT("service_uuid: %s", connection->service_uuid);
-}
-
-void __bt_opp_client_push_responded_cb(int result,
-					const char *remote_address,
-					void *user_data)
-{
-	TC_PRT("result: %d", result);
-	TC_PRT("remote_address: %s", remote_address);
-}
-
-void __bt_opp_client_push_progress_cb(const char *file,
-					long long size,
-					int percent,
-					void *user_data)
-{
-	TC_PRT("size: %ld", (long)size);
-	TC_PRT("percent: %d", percent);
-	TC_PRT("file: %s", file);
-}
-
-void __bt_opp_client_push_finished_cb(int result,
-				const char *remote_address,
-				void *user_data)
-{
-	TC_PRT("result: %d", result);
-	TC_PRT("remote_address: %s", remote_address);
-}
-
-void __bt_audio_connection_state_changed_cb(int result,
-					bool connected, const char *remote_address,
-					bt_audio_profile_type_e type, void *user_data)
-{
-	TC_PRT("connected [%d]", connected);
-	TC_PRT("address [%s]", remote_address);
-	TC_PRT("type [%d]", type);
-}
-
-void __bt_ag_sco_state_changed_cb(int result, bool opened, void *user_data)
-{
-	TC_PRT("opened [%s]", opened ? "YES" : "NO");
-}
-
-void __bt_ag_set_call_handling_event_cb(bt_ag_call_handling_event_e event,
-					unsigned int call_id, void *user_data)
-{
-	TC_PRT("event[%d] call_id[%d]", event, call_id);
-}
-
-void __bt_hf_sco_state_changed_cb(int result, bool opened, void *user_data)
-{
-	TC_PRT("opened [%s]", opened ? "YES" : "NO");
-}
-
-void __bt_hf_set_call_handling_event_cb(bt_hf_call_handling_event_e event,
-		char *phone_number, void *user_data)
-{
-	TC_PRT("event[%d] phone_number[%s]", event, phone_number);
-}
-
-void __bt_device_authorization_changed_cb(bt_device_authorization_e authorization,
-						char *remote_address, void *user_data)
-{
-	TC_PRT("__bt_device_authorization_changed_cb [%d]", authorization);
-	TC_PRT("address: %s", remote_address);
-}
-
-void __bt_device_connection_state_changed_cb(bool connected,
-						const char *remote_address,
-						void *user_data)
-{
-	TC_PRT("__bt_device_connection_state_changed_cb [%d]", connected);
-	TC_PRT("address: %s", remote_address);
-}
-
-void __bt_device_disconnected_cb(const char *remote_address,
-						bt_device_disconnect_reason_e reason,
-						void *user_data)
-{
-	TC_PRT("address: %s", remote_address);
-	TC_PRT("Disconnect reason: %d", reason);
-}
-
-bool __bt_device_connected_profile(bt_profile_e profile, void *user_data)
-{
-	TC_PRT("__bt_device_connected_profile [%d]", profile);
-	return true;
-}
-
-void __bt_device_le_connection_status_cb(int result, void *user_data)
-{
-	TC_PRT("Callback: LE Conneciton Status %d", result);
-}
-
-void __bt_device_bond_created_cb(int result, bt_device_info_s *device_info, void *user_data)
-{
-	if(result == BT_ERROR_NONE)
-	{
-		TC_PRT("Callback: A bond with chat_server is created.");
-		TC_PRT("Callback: The number of service - %d.", device_info->service_count);
-
-		int i = 0;
-		for(i=0; i<device_info->service_count; i++)
-		{
-			TC_PRT("Callback: service[%d] - %s", i+1, device_info->service_uuid[i]);
-		}
-		TC_PRT("Callback: is_bonded - %d.", device_info->is_bonded);
-		TC_PRT("Callback: is_connected - %d.", device_info->is_connected);
-	}
-	else
-	{
-		TC_PRT("Callback: Creating a bond is failed.");
-	}
-}
-
-bool __bt_gatt_primary_service_cb(bt_gatt_attribute_h service, void *user_data)
-{
-	TC_PRT("__bt_gatt_primary_service_cb");
-	TC_PRT("service %s", (char *)service);
-	if (service_index >= MAX_SERVICES)
-		return true;
-
-	bt_gatt_clone_attribute_handle(&service_clone[service_index], service);
-	service_index++;
-	return true;
-}
-
-bool __bt_gatt_characteristics_discovered_cb(int result, int index, int total, bt_gatt_attribute_h characteristic, void *user_data)
-{
-	TC_PRT("__bt_gatt_characteristics_discovered_cb: %d", result);
-	TC_PRT("index %d", index);
-	TC_PRT("total %d", total);
-	TC_PRT("characteristic %s", (char *)characteristic);
-
-	if (index >= MAX_SERVICES)
-		return true;
-
-	bt_gatt_clone_attribute_handle(&characteristics[index], characteristic);
-	return true;
-}
-
-bool __bt_gatt_included_service_cb(bt_gatt_attribute_h service, void *user_data)
-{
-	char *uuid = NULL;
-	unsigned char *value = NULL;
-	int value_length = 0;
-
-	TC_PRT("__bt_gatt_included_service_cb");
-	TC_PRT("service %s", (char *)service);
-
-	if (char_service_index >= MAX_SERVICES)
-		return true;
-
-	bt_gatt_clone_attribute_handle(&characteristics_services[char_service_index], service);
-	char_service_index++;
-
-	bt_gatt_get_characteristic_declaration(service, &uuid, &value, &value_length);
-	TC_PRT("uuid %s", uuid);
-	return true;
-}
-
-void __bt_gatt_characteristic_changed_cb(bt_gatt_attribute_h characteristic, unsigned char *value, int value_length, void *user_data)
-{
-	int i;
-
-	TC_PRT("__bt_gatt_characteristic_changed_cb");
-	TC_PRT("service %s", (char *)characteristic);
-	TC_PRT("value_length %d", value_length);
-
-	for (i = 0; i < value_length; i++) {
-		TC_PRT("value %c", value[i]);
-	}
-
-	return;
-}
-
-void __bt_gatt_char_write_cb(void *user_data)
-{
-	TC_PRT("__bt_gatt_char_write_cb");
-	return;
-}
-
-void __bt_gatt_char_read_cb(unsigned char *value, int value_length, void *user_data)
-{
-	int i;
-
-	TC_PRT("__bt_gatt_char_read_cb");
-
-        TC_PRT("value_length %d", value_length);
-
-        for (i = 0; i < value_length; i++) {
-                TC_PRT("value %u", value[i]);
-        }
-
-	return;
-}
-
-void __bt_avrcp_target_connection_state_changed_cb(bool connected, const char *remote_address, void *user_data)
-{
-	TC_PRT("__bt_avrcp_target_connection_state_changed_cb");
-	TC_PRT("connected %d", connected);
-	TC_PRT("remote_address %s", remote_address);
-}
-
-void __bt_avrcp_equalizer_state_changed_cb(bt_avrcp_equalizer_state_e equalizer, void *user_data)
-{
-	TC_PRT("__bt_avrcp_equalizer_state_changed_cb");
-	TC_PRT("equalizer %d", equalizer);
-}
-
-void __bt_avrcp_repeat_mode_changed_cb(bt_avrcp_repeat_mode_e repeat, void *user_data)
-{
-	TC_PRT("__bt_avrcp_repeat_mode_changed_cb");
-	TC_PRT("repeat %d", repeat);
-}
-
-void __bt_avrcp_shuffle_mode_changed_cb(bt_avrcp_shuffle_mode_e shuffle, void *user_data)
-{
-	TC_PRT("__bt_avrcp_shuffle_mode_changed_cb");
-	TC_PRT("shuffle %d", shuffle);
-}
-
-void __bt_avrcp_scan_mode_changed_cb(bt_avrcp_scan_mode_e scan, void *user_data)
-{
-	TC_PRT("__bt_avrcp_scan_mode_changed_cb");
-	TC_PRT("equalizer %d", scan);
-}
-
-void panu_conn_state_changed(int result, bool connected,
-					const char *remote_address,
-					bt_panu_service_type_e type,
-					void *user_data)
-{
-        TC_PRT("connected [%d]", connected);
-        TC_PRT("address [%s]", remote_address);
-        TC_PRT("type [%d]", type);
-        TC_PRT("result [%d]", result);
-}
-
-char * get_bd_from_file(char *filename)
-{
-	int fd;
-	char *buf;
-
-	if ((fd = open(filename, O_RDONLY)) < 0) {
-		perror("Can't open file");
-		return NULL;
-	}
-
-	buf = g_malloc0(20);
-
-	if (read(fd, buf, 17) < 17) {
-		perror("read failed");
-		g_free(buf);
-		close(fd);
-		return NULL;
-	}
-
-	close(fd);
-
-	return buf;
-}
-
-void __bt_hf_speaker_gain_changed_cb(int gain, void *user_data)
-{
-	TC_PRT("__bt_hf_speaker_gain_changed_cb");
-	TC_PRT("Gain= %d", gain);
-}
-
-int test_input_callback(void *data)
-{
-	int ret = 0;
-	int test_id = (int)data;
-
-	switch (test_id) {
-	case 0x00ff:
-		TC_PRT("Finished");
-		g_main_loop_quit(main_loop);
-		break;
-
-	case 1:
-		ret = bt_initialize();
-		if (ret < BT_ERROR_NONE)
-			TC_PRT("failed with [0x%04x]", ret);
-		break;
-	case 2:
-		ret = bt_deinitialize();
-		if (ret < BT_ERROR_NONE)
-			TC_PRT("failed with [0x%04x]", ret);
-		break;
-	case 3: {
-		bt_adapter_state_e state = BT_ADAPTER_DISABLED;
-
-		ret = bt_adapter_get_state(&state);
-		if (ret < BT_ERROR_NONE)
-			TC_PRT("failed with [0x%04x]", ret);
-
-		TC_PRT("state: %d", state);
-		break;
-	}
-	case 4:
-		ret = bt_adapter_enable();
-		if (ret < BT_ERROR_NONE)
-			TC_PRT("failed with [0x%04x]", ret);
-		break;
-	case 5:
-		ret = bt_adapter_disable();
-		if (ret < BT_ERROR_NONE)
-			TC_PRT("failed with [0x%04x]", ret);
-		break;
-	case 6:
-		ret = bt_adapter_start_device_discovery();
-		if (ret < BT_ERROR_NONE)
-			TC_PRT("failed with [0x%04x]", ret);
-		break;
-	case 7:
-		ret = bt_adapter_stop_device_discovery();
-		if (ret < BT_ERROR_NONE)
-			TC_PRT("failed with [0x%04x]", ret);
-		break;
-	case 8: {
-		bool is_discovering = FALSE;
-		ret = bt_adapter_is_discovering(&is_discovering);
-		if (ret < BT_ERROR_NONE)
-			TC_PRT("failed with [0x%04x]", ret);
-		else
-			TC_PRT("is_discovering: %d", is_discovering);
-
-		break;
-	}
-	case 9: {
-		char *address;
-		bt_device_info_s *device_info = NULL;
-
-		address = g_strdup("00:19:0E:01:61:17");
-
-		ret = bt_adapter_get_bonded_device_info((const char *)address,
-							&device_info);
-		if (ret < BT_ERROR_NONE)
-			TC_PRT("failed with [0x%04x]", ret);
-
-		g_free(address);
-
-		if (device_info) {
-			TC_PRT("address: %s", device_info->remote_address);
-			TC_PRT("name: %s", device_info->remote_name);
-		}
-
-		bt_adapter_free_device_info(device_info);
-		break;
-	}
-	case 10: {
-		bool used = FALSE;
-
-		ret = bt_adapter_is_service_used(opp_uuid, &used);
-		if (ret < BT_ERROR_NONE)
-			TC_PRT("failed with [0x%04x]", ret);
-
-		TC_PRT("used: %d", used);
-		break;
-	}
-	case 11: {
-		bt_adapter_visibility_mode_e visibility_mode = BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE;
-		int time = 0;
-
-		ret = bt_adapter_get_visibility(&visibility_mode, &time);
-		if (ret < BT_ERROR_NONE)
-			TC_PRT("failed with [0x%04x]", ret);
-
-		TC_PRT("mode: %d", visibility_mode);
-		TC_PRT("time: %d", time);
-		break;
-	}
-	case 12:
-		ret = bt_adapter_set_device_discovery_state_changed_cb(__bt_adapter_device_discovery_state_changed_cb, NULL);
-		if (ret < BT_ERROR_NONE)
-			TC_PRT("failed with [0x%04x]", ret);
-		break;
-	case 13:
-		ret = bt_adapter_unset_device_discovery_state_changed_cb();
-		if (ret < BT_ERROR_NONE)
-			TC_PRT("failed with [0x%04x]", ret);
-		break;
-
-	case 14: {
-		ret = bt_adapter_get_local_oob_data(&hash, &randomizer, &hash_len, &rand_len);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		} else {
-			TC_PRT("hash = [%s]", hash);
-			TC_PRT("randomizer = [%s]", randomizer);
-		}
-		break;
-	}
-
-	case 15: {
-		char *address;
-
-		address = g_strdup("00:02:18:2F:78:32");
-
-		TC_PRT("remote address = [%s]", address);
-
-		ret = bt_adapter_set_remote_oob_data(address, hash, randomizer, hash_len, rand_len);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	}
-
-	case 16: {
-		char *address;
-
-		address = g_strdup("00:02:18:2F:78:32");
-
-		TC_PRT("remote address = [%s]", address);
-
-		ret = bt_adapter_remove_remote_oob_data(address);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	}
-
-	case 17: {
-		ret = bt_adapter_start_discover_devices(BT_ADAPTER_DEVICE_DISCOVERY_BREDR);
-		if (ret < BT_ERROR_NONE)
-			TC_PRT("failed with [0x%04x]", ret);
-		break;
-	}
-
-	case 18:
-		ret = bt_adapter_set_visibility_mode_changed_cb(__bt_adapter_device_visibility_mode_changed_cb, NULL);
-		if (ret < BT_ERROR_NONE)
-			TC_PRT("failed with [0x%04x]", ret);
-		break;
-	case 19:
-		ret = bt_adapter_unset_visibility_mode_changed_cb();
-		if (ret < BT_ERROR_NONE)
-			TC_PRT("failed with [0x%04x]", ret);
-		break;
-
-	case 20:
-		ret = bt_adapter_set_advertising_state_changed_cb(__bt_adapter_advertising_state_changed_cb, NULL);
-		if (ret < BT_ERROR_NONE)
-			TC_PRT("failed with [0x%04x]", ret);
-		break;
-
-	case 21:
-		ret = bt_adapter_unset_advertising_state_changed_cb();
-		if (ret < BT_ERROR_NONE)
-			TC_PRT("failed with [0x%04x]", ret);
-		break;
-
-	case 22:
-		ret = bt_adapter_start_advertising(NULL);
-		if (ret < BT_ERROR_NONE)
-			TC_PRT("failed with [0x%04x]", ret);
-		break;
-
-	case 23:
-		ret = bt_adapter_stop_advertising();
-		if (ret < BT_ERROR_NONE)
-			TC_PRT("failed with [0x%04x]", ret);
-		break;
-
-	case 24: {
-		bool is_advertising = FALSE;
-
-		ret = bt_adapter_is_advertising(&is_advertising);
-		if (ret < BT_ERROR_NONE)
-			TC_PRT("failed with [0x%04x]", ret);
-		else
-			TC_PRT("advertising is %s", is_advertising ? "started" : "stopped");
-		break;
-	}
-
-	case 25: {
-		ret = bt_adapter_add_white_list("11:22:33:44:55:66");
-		if (ret < BT_ERROR_NONE)
-			TC_PRT("failed with [0x%04x]", ret);
-		break;
-	}
-
-	case 26: {
-		ret = bt_adapter_remove_white_list("11:22:33:44:55:66");
-		if (ret < BT_ERROR_NONE)
-			TC_PRT("failed with [0x%04x]", ret);
-		break;
-	}
-
-	case 27: {
-		ret = bt_adapter_clear_white_list();
-		if (ret < BT_ERROR_NONE)
-			TC_PRT("failed with [0x%04x]", ret);
-		break;
-	}
-
-	case 28:
-		ret = bt_adapter_set_advertising_manufacturer_data_changed_cb(__bt_adapter_advertising_manufacturer_data_changed_cb, NULL);
-		if (ret < BT_ERROR_NONE)
-			TC_PRT("failed with [0x%04x]", ret);
-		break;
-
-	case 29:
-		ret = bt_adapter_unset_advertising_manufacturer_data_changed_cb();
-		if (ret < BT_ERROR_NONE)
-			TC_PRT("failed with [0x%04x]", ret);
-		break;
-
-	case 30: {
-		char data[2] = {0x00, 0x75};
-		ret = bt_adapter_set_advertising_manufacturer_data(data, sizeof(data));
-		if (ret < BT_ERROR_NONE)
-			TC_PRT("failed with [0x%04x]", ret);
-		break;
-	}
-
-	case 31: {
-		char *data = NULL;
-		int len = 0;
-		int i = 0;
-
-		ret = bt_adapter_get_advertising_manufacturer_data(&data, &len);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-			break;
-		}
-
-		for (i = 0; i < len; i++)
-			TC_PRT("[%d] %02x ", i, data[i]);
-		free(data);
-
-		break;
-	}
-
-	case 32: {
-		char data[0];
-		ret = bt_adapter_set_advertising_manufacturer_data(data, 0);
-		if (ret < BT_ERROR_NONE)
-			TC_PRT("failed with [0x%04x]", ret);
-		break;
-	}
-
-	case 33: {
-		ret = bt_adapter_set_connectable_changed_cb(__bt_adapter_connectable_changed_cb, NULL);
-		if (ret < BT_ERROR_NONE)
-			TC_PRT("failed with [0x%04x]", ret);
-		break;
-	 }
-
-	case 34: {
-		ret = bt_adapter_unset_connectable_changed_cb();
-		if (ret < BT_ERROR_NONE)
-			TC_PRT("failed with [0x%04x]", ret);
-		break;
-	 }
-
-	case 35: {
-		bool connectable = false;
-
-		ret = bt_adapter_get_connectable(&connectable);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-			break;
-		}
-
-		TC_PRT("%s", connectable ? "Connectable" : "Non-connectable");
-
-		break;
-	 }
-
-	case 36: {
-		bool connectable = false;
-
-		bt_adapter_get_connectable(&connectable);
-
-		ret = bt_adapter_set_connectable(!connectable);
-		if (ret < BT_ERROR_NONE)
-			TC_PRT("failed with [0x%04x]", ret);
-		break;
-	 }
-
-	/* Socket functions */
-	case 50: {
-		int socket_fd = 0;
-
-		ret = bt_socket_create_rfcomm(spp_uuid, &socket_fd);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		} else {
-			TC_PRT("socket_fd: %d", socket_fd);
-			server_fd = socket_fd;
-		}
-		break;
-	}
-	case 51:
-		ret = bt_socket_destroy_rfcomm(server_fd);
-		if (ret < BT_ERROR_NONE)
-			TC_PRT("failed with [0x%04x]", ret);
-		break;
-	case 52:
-		ret = bt_socket_listen_and_accept_rfcomm(server_fd, 1);
-		if (ret < BT_ERROR_NONE)
-			TC_PRT("failed with [0x%04x]", ret);
-		break;
-	case 53:
-		ret = bt_socket_listen(server_fd, 1);
-		if (ret < BT_ERROR_NONE)
-			TC_PRT("failed with [0x%04x]", ret);
-		break;
-	case 54: {
-		int socket_fd = 0;
-
-		ret = bt_socket_accept(server_fd, &socket_fd);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		} else {
-			TC_PRT("socket_fd: %d", socket_fd);
-			client_fd = socket_fd;
-		}
-		break;
-	}
-	case 55:
-		ret = bt_socket_reject(server_fd);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 56: {
-		char *address;
-
-		address = g_strdup("00:02:48:F4:3E:D2");
-
-		ret = bt_socket_connect_rfcomm(address, spp_uuid);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-
-		g_free(address);
-		break;
-	}
-	case 57:
-		ret = bt_socket_disconnect_rfcomm(client_fd);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 58:
-		ret = bt_socket_send_data(client_fd, "Sending test\0", 20);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 59:
-		ret = bt_socket_set_data_received_cb(__bt_socket_data_received_cb, NULL);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 60:
-		ret = bt_socket_unset_data_received_cb();
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 61:
-		ret = bt_socket_set_connection_requested_cb(__bt_socket_connection_requested_cb, NULL);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 62:
-		ret = bt_socket_unset_connection_requested_cb();
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 63:
-		ret = bt_socket_set_connection_state_changed_cb(__bt_socket_connection_state_changed_cb, NULL);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 64:
-		ret = bt_socket_unset_connection_state_changed_cb();
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 70:
-		ret = bt_opp_client_initialize();
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 71:
-		ret = bt_opp_client_deinitialize();
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 72:
-		ret = bt_opp_client_add_file("/opt/media/Images/image1.jpg");
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 73:
-		ret = bt_opp_client_clear_files();
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 74: {
-		char *address;
-
-		address = g_strdup("00:02:37:A9:17:9E");
-
-		ret = bt_opp_client_push_files(address,__bt_opp_client_push_responded_cb,
-					__bt_opp_client_push_progress_cb,
-					__bt_opp_client_push_finished_cb,
-					NULL);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	}
-	case 75:
-		ret = bt_opp_client_cancel_push();
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-
-	case 80:
-		ret = bt_audio_initialize();
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 81:
-		ret = bt_audio_deinitialize();
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 82: {
-		char *address;
-		address = g_strdup("11:11:22:33:33:33");
-
-		ret = bt_audio_connect(address,  BT_AUDIO_PROFILE_TYPE_HSP_HFP);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	}
-	case 83: {
-		char *address;
-		address = g_strdup("11:11:22:33:33:33");
-
-		ret = bt_audio_disconnect(address,  BT_AUDIO_PROFILE_TYPE_HSP_HFP);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	}
-	case 84:
-		ret = bt_audio_set_connection_state_changed_cb(
-					__bt_audio_connection_state_changed_cb, NULL);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 85:
-		ret = bt_audio_unset_connection_state_changed_cb();
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 86:
-		ret = bt_ag_open_sco();
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 87:
-		ret = bt_ag_close_sco();
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 88: {
-		bool opened = false;
-		ret = bt_ag_is_sco_opened(&opened);
-		TC_PRT("opend[%s]", opened ? "YES" : "NO");
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	}
-	case 89:
-		ret = bt_ag_set_sco_state_changed_cb(__bt_ag_sco_state_changed_cb, NULL);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 90:
-		ret = bt_ag_unset_sco_state_changed_cb();
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 91: {
-		unsigned int call_id = 1;
-
-		ret = bt_ag_notify_call_event(BT_AG_CALL_EVENT_IDLE, call_id, NULL);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	}
-	case 92: {
-		unsigned int call_id = 1;
-		bool sco_required = true;
-
-		ret = bt_ag_notify_call_event(BT_AG_CALL_EVENT_ANSWERED, call_id, NULL);
-		if (sco_required)
-			bt_ag_open_sco();
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	}
-	case 93: {
-		unsigned int call_id = 1;
-		bool sco_required = TRUE;
-		const char *phone_number;
-
-		phone_number = g_strdup("01046500173");
-		ret = bt_ag_notify_call_event(BT_AG_CALL_EVENT_DIALING,
-					call_id, phone_number);
-		if (sco_required)
-			bt_ag_open_sco();
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	}
-	case 94: {
-		unsigned int call_id = 1;
-
-		ret = bt_ag_notify_call_event(BT_AG_CALL_EVENT_ALERTING,
-					call_id, NULL);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	}
-	case 95: {
-		unsigned int call_id = 1;
-		const char *phone_number;
-
-		phone_number = g_strdup("01046500173");
-		ret = bt_ag_notify_call_event(BT_AG_CALL_EVENT_INCOMING,
-					call_id, phone_number);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	}
-	case 96:
-		ret = bt_call_list_create(&call_list);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 97:
-		ret = bt_call_list_destroy(call_list);
-		call_list = NULL;
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 98:
-		ret = bt_call_list_reset(call_list);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 99:
-		ret = bt_call_list_add(call_list, 1, BT_AG_CALL_STATE_ACTIVE);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 100:
-		ret = bt_ag_notify_call_list(call_list);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 101:
-		ret = bt_ag_set_call_handling_event_cb(
-					__bt_ag_set_call_handling_event_cb, NULL);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 102: {
-		bool enabled = false;
-		ret = bt_ag_is_nrec_enabled(&enabled);
-		TC_PRT("opend[%s]", enabled ? "YES" : "NO");
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	}
-	case 110:
-		ret = bt_nap_activate();
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-
-	case 111:
-		ret = bt_nap_deactivate();
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-
-	case 112:
-		ret = bt_nap_disconnect_all();
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 113:
-		ret = bt_panu_set_connection_state_changed_cb(panu_conn_state_changed,
-									NULL);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 114: {
-		char *address;
-
-		address = get_bd_from_file("/opt/addr-file");
-		if (address == NULL)
-			address = g_strdup("E4:32:CB:41:1D:7A");
-
-		TC_PRT("CONNECTING TO %s", address);
-		ret = bt_panu_connect(address, BT_PANU_SERVICE_TYPE_NAP);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-
-		g_free(address);
-	}
-		break;
-	case 120: {
-		char *address;
-
-		address = g_strdup("00:1B:66:01:23:1C");
-
-		ret = bt_device_set_authorization(address, BT_DEVICE_AUTHORIZED);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	}
-	case 121: {
-		char *address;
-
-		address = g_strdup("00:1B:66:01:23:1C");
-
-		ret = bt_device_set_authorization(address, BT_DEVICE_UNAUTHORIZED);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	}
-	case 122:
-		ret = bt_device_set_authorization_changed_cb(__bt_device_authorization_changed_cb, NULL);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-
-	case 123:
-		ret = bt_device_unset_authorization_changed_cb();
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-
-	case 124:
-		ret = bt_device_set_connection_state_changed_cb(__bt_device_connection_state_changed_cb, NULL);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-
-	case 125:
-		ret = bt_device_unset_connection_state_changed_cb();
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-
-	case 126: {
-		char *address;
-
-		address = g_strdup("00:1B:66:01:23:1C");
-
-		ret = bt_device_foreach_connected_profiles(address, __bt_device_connected_profile, NULL);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	}
-
-	case 127 : {
-		ret = bt_device_set_bond_created_cb(__bt_device_bond_created_cb,
-			NULL);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	}
-
-	case 128 : {
-		char *address;
-
-		address = g_strdup(DEVICE_ADDRESS);
-
-		ret = bt_device_create_bond(address);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	}
-	case 129 : {
-		char *address;
-
-		address = g_strdup(DEVICE_ADDRESS);
-
-		ret = bt_device_connect_le(__bt_device_le_connection_status_cb, address);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	}
-	case 130 : {
-		char *address;
-		address = g_strdup(DEVICE_ADDRESS);
-
-		ret = bt_device_disconnect_le(__bt_device_le_connection_status_cb,address);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	}
-	case 131:
-		ret = bt_device_set_disconnected_cb(__bt_device_disconnected_cb, NULL);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-
-	case 140: {
-		char *address;
-
-		address = g_strdup("D5:FE:81:38:39:B9");
-
-		__bt_free_gatt_services();
-
-		ret = bt_gatt_foreach_primary_services(address, __bt_gatt_primary_service_cb, NULL);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	}
-
-	case 141: {
-		__bt_free_gatt_characteristics();
-
-		ret = bt_gatt_discover_characteristics(service_clone[1], __bt_gatt_characteristics_discovered_cb, NULL);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	}
-
-	case 142: {
-		char *uuid = NULL;
-
-		ret = bt_gatt_get_service_uuid(service_clone[1], &uuid);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		} else {
-			TC_PRT("uuid: %s", uuid);
-			g_free(uuid);
-		}
-		break;
-	}
-
-	case 143: {
-		__bt_free_gatt_characteristics_services();
-
-		ret = bt_gatt_foreach_included_services(service_clone[1], __bt_gatt_included_service_cb, NULL);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	}
-
-	case 144: {
-		ret = bt_gatt_set_characteristic_changed_cb(__bt_gatt_characteristic_changed_cb, NULL);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	}
-
-	case 145: {
-		ret = bt_gatt_unset_characteristic_changed_cb();
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	}
-
-	case 146: {
-		int i;
-		char *uuid = NULL;
-		unsigned char *value = NULL;
-		int value_length = 0;
-
-		ret = bt_gatt_get_characteristic_declaration(characteristics_services[0], &uuid, &value, &value_length);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		} else {
-			TC_PRT("uuid: %s", uuid);
-
-			for (i = 0; i < value_length; i++) {
-				TC_PRT("value %c", value[i]);
-			}
-
-			g_free(uuid);
-			g_free(value);
-		}
-		break;
-	}
-
-	case 147: {
-		unsigned char value[] = { 1 };
-
-		ret = bt_gatt_set_characteristic_value_request(characteristics[2], value, 1,
-				__bt_gatt_char_write_cb);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	}
-
-	case 148 : {
-		ret = bt_gatt_read_characteristic_value(characteristics[2], __bt_gatt_char_read_cb);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	}
-
-	case 150: {
-		ret = bt_gatt_watch_characteristic_changes(service_clone[1]);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	}
-
-	case 151: {
-		ret = bt_gatt_unwatch_characteristic_changes(service_clone[1]);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	}
-
-	case 160:
-		ret = bt_avrcp_target_initialize(__bt_avrcp_target_connection_state_changed_cb, NULL);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-
-	case 161:
-		ret = bt_avrcp_target_deinitialize();
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-
-	case 162:
-		ret = bt_avrcp_set_equalizer_state_changed_cb(__bt_avrcp_equalizer_state_changed_cb, NULL);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-
-	case 163:
-		ret = bt_avrcp_set_repeat_mode_changed_cb(__bt_avrcp_repeat_mode_changed_cb, NULL);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-
-	case 164:
-		ret = bt_avrcp_set_shuffle_mode_changed_cb(__bt_avrcp_shuffle_mode_changed_cb, NULL);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-
-	case 165:
-		ret = bt_avrcp_set_scan_mode_changed_cb(__bt_avrcp_scan_mode_changed_cb, NULL);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-
-	case 166:
-		ret = bt_avrcp_unset_equalizer_state_changed_cb();
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-
-	case 167:
-		ret = bt_avrcp_unset_repeat_mode_changed_cb();
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-
-	case 168:
-		ret = bt_avrcp_unset_shuffle_mode_changed_cb();
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 169:
-		ret = bt_avrcp_unset_scan_mode_changed_cb();
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 170:
-		ret = bt_a2dp_set_content_protection(TRUE);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 171:
-		ret = bt_a2dp_set_content_protection(FALSE);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		}
-		break;
-	case 172:
-		ret = bt_hf_initialize();
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		} else if (ret == BT_ERROR_NONE) {
-			TC_PRT("Success");
-		}
-		break;
-	case 173:
-		ret = bt_hf_deinitialize();
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		} else if (ret == BT_ERROR_NONE) {
-			TC_PRT("Success");
-		}
-		break;
-	case 174:
-		ret = bt_hf_notify_call_event(BT_HF_CALL_EVENT_ANSWER, "9663868998");
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		} else if (ret == BT_ERROR_NONE) {
-			TC_PRT("Success");
-		}
-		break;
-	case 175:
-		ret = bt_hf_notify_speaker_gain(10);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		} else if (ret == BT_ERROR_NONE) {
-			TC_PRT("Success");
-		}
-		break;
-	case 176:
-		ret = bt_hf_set_speaker_gain_changed_cb(__bt_hf_speaker_gain_changed_cb, NULL);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		} else if (ret == BT_ERROR_NONE) {
-			TC_PRT("Success");
-		}
-		break;
-	case 177:
-		ret = bt_hf_unset_speaker_gain_changed_cb();
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		} else if (ret == BT_ERROR_NONE) {
-			TC_PRT("Success");
-		}
-		break;
-	case 178:
-		ret = bt_hf_notify_voice_recognition_state(true);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		} else if (ret == BT_ERROR_NONE) {
-			TC_PRT("Success");
-		}
-		break;
-	case 179:
-		ret = bt_hf_notify_vendor_cmd(1, "AT+XSAT=");
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		} else if (ret == BT_ERROR_NONE) {
-			TC_PRT("Success");
-		}
-		break;
-	case 180:
-		ret = bt_hf_notify_call_event(BT_HF_CALL_EVENT_IDLE, "9663868998");
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		} else if (ret == BT_ERROR_NONE) {
-			TC_PRT("Success");
-		}
-		break;
-	case 181:
-		ret = bt_hf_notify_call_event(BT_HF_CALL_EVENT_DIAL, "9663868998");
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		} else if (ret == BT_ERROR_NONE) {
-			TC_PRT("Success");
-		}
-		break;
-	case 182:
-		ret = bt_hf_notify_voice_recognition_state(false);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		} else if (ret == BT_ERROR_NONE) {
-			TC_PRT("Success");
-		}
-		break;
-	case 183:
-		ret = bt_hf_set_sco_state_changed_cb(
-				__bt_hf_sco_state_changed_cb, NULL);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		} else if (ret == BT_ERROR_NONE) {
-			TC_PRT("Success");
-		}
-		break;
-	case 184:
-		ret = bt_hf_unset_sco_state_changed_cb();
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		} else if (ret == BT_ERROR_NONE) {
-			TC_PRT("Success");
-		}
-		break;
-	case 185:
-		ret = bt_hf_set_call_handling_event_cb(__bt_hf_set_call_handling_event_cb, NULL);
-		if (ret < BT_ERROR_NONE) {
-			TC_PRT("failed with [0x%04x]", ret);
-		} else if (ret == BT_ERROR_NONE) {
-			TC_PRT("Success");
-		}
-		break;
-	default:
-		break;
-	}
-
-	return 0;
-}
-
-static gboolean key_event_cb(GIOChannel *chan,
-				GIOCondition cond,
-				gpointer data)
-{
-	char buf[BUFFER_LEN] = { 0 };
-
-	unsigned int len = 0;
-	int test_id;
-
-	memset(buf, 0, sizeof(buf));
-
-	if (g_io_channel_read_chars(chan, buf, sizeof(buf),
-				&len, NULL) == G_IO_STATUS_ERROR) {
-		TC_PRT("IO Channel read error");
-		return FALSE;
-	}
-
-	TC_PRT("%s", buf);
-	tc_usage_print();
-
-	test_id = atoi(buf);
-
-	if (test_id)
-		g_idle_add(test_input_callback, (void *)test_id);
-
-	return TRUE;
-}
-
-int main()
-{
-	GIOChannel *key_io;
-
-	g_type_init();
-
-	key_io = g_io_channel_unix_new(fileno(stdin));
-
-	g_io_channel_set_encoding(key_io, NULL, NULL);
-	g_io_channel_set_flags(key_io, G_IO_FLAG_NONBLOCK, NULL);
-
-	g_io_add_watch(key_io, G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
-			key_event_cb, NULL);
-
-	g_io_channel_unref(key_io);
-
-	main_loop = g_main_loop_new(NULL, FALSE);
-
-	g_main_loop_run(main_loop);
-
-	bt_deinitialize();
-
-	return 0;
-}