--- /dev/null
+ByungWoo Lee <bw1212.lee@samsung.com>
+Kangho Hur <kanho.hur@samsung.com>
--- /dev/null
+
+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")
+
+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=/usr/lib")
+
+aux_source_directory(src SOURCES)
+ADD_LIBRARY(${fw_name} SHARED ${SOURCES})
+
+TARGET_LINK_LIBRARIES(${fw_name} ${${fw_name}_LDFLAGS})
+
+INSTALL(TARGETS ${fw_name} DESTINATION lib)
+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 ${dependents})
+SET(PC_LDFLAGS -l${fw_name})
+SET(PC_CFLAGS -I\${includedir}/network)
+
+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/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)
+
--- /dev/null
+Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.\r
+\r
+ Apache License\r
+ Version 2.0, January 2004\r
+ http://www.apache.org/licenses/\r
+\r
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\r
+\r
+ 1. Definitions.\r
+\r
+ "License" shall mean the terms and conditions for use, reproduction,\r
+ and distribution as defined by Sections 1 through 9 of this document.\r
+\r
+ "Licensor" shall mean the copyright owner or entity authorized by\r
+ the copyright owner that is granting the License.\r
+\r
+ "Legal Entity" shall mean the union of the acting entity and all\r
+ other entities that control, are controlled by, or are under common\r
+ control with that entity. For the purposes of this definition,\r
+ "control" means (i) the power, direct or indirect, to cause the\r
+ direction or management of such entity, whether by contract or\r
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the\r
+ outstanding shares, or (iii) beneficial ownership of such entity.\r
+\r
+ "You" (or "Your") shall mean an individual or Legal Entity\r
+ exercising permissions granted by this License.\r
+\r
+ "Source" form shall mean the preferred form for making modifications,\r
+ including but not limited to software source code, documentation\r
+ source, and configuration files.\r
+\r
+ "Object" form shall mean any form resulting from mechanical\r
+ transformation or translation of a Source form, including but\r
+ not limited to compiled object code, generated documentation,\r
+ and conversions to other media types.\r
+\r
+ "Work" shall mean the work of authorship, whether in Source or\r
+ Object form, made available under the License, as indicated by a\r
+ copyright notice that is included in or attached to the work\r
+ (an example is provided in the Appendix below).\r
+\r
+ "Derivative Works" shall mean any work, whether in Source or Object\r
+ form, that is based on (or derived from) the Work and for which the\r
+ editorial revisions, annotations, elaborations, or other modifications\r
+ represent, as a whole, an original work of authorship. For the purposes\r
+ of this License, Derivative Works shall not include works that remain\r
+ separable from, or merely link (or bind by name) to the interfaces of,\r
+ the Work and Derivative Works thereof.\r
+\r
+ "Contribution" shall mean any work of authorship, including\r
+ the original version of the Work and any modifications or additions\r
+ to that Work or Derivative Works thereof, that is intentionally\r
+ submitted to Licensor for inclusion in the Work by the copyright owner\r
+ or by an individual or Legal Entity authorized to submit on behalf of\r
+ the copyright owner. For the purposes of this definition, "submitted"\r
+ means any form of electronic, verbal, or written communication sent\r
+ to the Licensor or its representatives, including but not limited to\r
+ communication on electronic mailing lists, source code control systems,\r
+ and issue tracking systems that are managed by, or on behalf of, the\r
+ Licensor for the purpose of discussing and improving the Work, but\r
+ excluding communication that is conspicuously marked or otherwise\r
+ designated in writing by the copyright owner as "Not a Contribution."\r
+\r
+ "Contributor" shall mean Licensor and any individual or Legal Entity\r
+ on behalf of whom a Contribution has been received by Licensor and\r
+ subsequently incorporated within the Work.\r
+\r
+ 2. Grant of Copyright License. Subject to the terms and conditions of\r
+ this License, each Contributor hereby grants to You a perpetual,\r
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable\r
+ copyright license to reproduce, prepare Derivative Works of,\r
+ publicly display, publicly perform, sublicense, and distribute the\r
+ Work and such Derivative Works in Source or Object form.\r
+\r
+ 3. Grant of Patent License. Subject to the terms and conditions of\r
+ this License, each Contributor hereby grants to You a perpetual,\r
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable\r
+ (except as stated in this section) patent license to make, have made,\r
+ use, offer to sell, sell, import, and otherwise transfer the Work,\r
+ where such license applies only to those patent claims licensable\r
+ by such Contributor that are necessarily infringed by their\r
+ Contribution(s) alone or by combination of their Contribution(s)\r
+ with the Work to which such Contribution(s) was submitted. If You\r
+ institute patent litigation against any entity (including a\r
+ cross-claim or counterclaim in a lawsuit) alleging that the Work\r
+ or a Contribution incorporated within the Work constitutes direct\r
+ or contributory patent infringement, then any patent licenses\r
+ granted to You under this License for that Work shall terminate\r
+ as of the date such litigation is filed.\r
+\r
+ 4. Redistribution. You may reproduce and distribute copies of the\r
+ Work or Derivative Works thereof in any medium, with or without\r
+ modifications, and in Source or Object form, provided that You\r
+ meet the following conditions:\r
+\r
+ (a) You must give any other recipients of the Work or\r
+ Derivative Works a copy of this License; and\r
+\r
+ (b) You must cause any modified files to carry prominent notices\r
+ stating that You changed the files; and\r
+\r
+ (c) You must retain, in the Source form of any Derivative Works\r
+ that You distribute, all copyright, patent, trademark, and\r
+ attribution notices from the Source form of the Work,\r
+ excluding those notices that do not pertain to any part of\r
+ the Derivative Works; and\r
+\r
+ (d) If the Work includes a "NOTICE" text file as part of its\r
+ distribution, then any Derivative Works that You distribute must\r
+ include a readable copy of the attribution notices contained\r
+ within such NOTICE file, excluding those notices that do not\r
+ pertain to any part of the Derivative Works, in at least one\r
+ of the following places: within a NOTICE text file distributed\r
+ as part of the Derivative Works; within the Source form or\r
+ documentation, if provided along with the Derivative Works; or,\r
+ within a display generated by the Derivative Works, if and\r
+ wherever such third-party notices normally appear. The contents\r
+ of the NOTICE file are for informational purposes only and\r
+ do not modify the License. You may add Your own attribution\r
+ notices within Derivative Works that You distribute, alongside\r
+ or as an addendum to the NOTICE text from the Work, provided\r
+ that such additional attribution notices cannot be construed\r
+ as modifying the License.\r
+\r
+ You may add Your own copyright statement to Your modifications and\r
+ may provide additional or different license terms and conditions\r
+ for use, reproduction, or distribution of Your modifications, or\r
+ for any such Derivative Works as a whole, provided Your use,\r
+ reproduction, and distribution of the Work otherwise complies with\r
+ the conditions stated in this License.\r
+\r
+ 5. Submission of Contributions. Unless You explicitly state otherwise,\r
+ any Contribution intentionally submitted for inclusion in the Work\r
+ by You to the Licensor shall be under the terms and conditions of\r
+ this License, without any additional terms or conditions.\r
+ Notwithstanding the above, nothing herein shall supersede or modify\r
+ the terms of any separate license agreement you may have executed\r
+ with Licensor regarding such Contributions.\r
+\r
+ 6. Trademarks. This License does not grant permission to use the trade\r
+ names, trademarks, service marks, or product names of the Licensor,\r
+ except as required for reasonable and customary use in describing the\r
+ origin of the Work and reproducing the content of the NOTICE file.\r
+\r
+ 7. Disclaimer of Warranty. Unless required by applicable law or\r
+ agreed to in writing, Licensor provides the Work (and each\r
+ Contributor provides its Contributions) on an "AS IS" BASIS,\r
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\r
+ implied, including, without limitation, any warranties or conditions\r
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A\r
+ PARTICULAR PURPOSE. You are solely responsible for determining the\r
+ appropriateness of using or redistributing the Work and assume any\r
+ risks associated with Your exercise of permissions under this License.\r
+\r
+ 8. Limitation of Liability. In no event and under no legal theory,\r
+ whether in tort (including negligence), contract, or otherwise,\r
+ unless required by applicable law (such as deliberate and grossly\r
+ negligent acts) or agreed to in writing, shall any Contributor be\r
+ liable to You for damages, including any direct, indirect, special,\r
+ incidental, or consequential damages of any character arising as a\r
+ result of this License or out of the use or inability to use the\r
+ Work (including but not limited to damages for loss of goodwill,\r
+ work stoppage, computer failure or malfunction, or any and all\r
+ other commercial damages or losses), even if such Contributor\r
+ has been advised of the possibility of such damages.\r
+\r
+ 9. Accepting Warranty or Additional Liability. While redistributing\r
+ the Work or Derivative Works thereof, You may choose to offer,\r
+ and charge a fee for, acceptance of support, warranty, indemnity,\r
+ or other liability obligations and/or rights consistent with this\r
+ License. However, in accepting such obligations, You may act only\r
+ on Your own behalf and on Your sole responsibility, not on behalf\r
+ of any other Contributor, and only if You agree to indemnify,\r
+ defend, and hold each Contributor harmless for any liability\r
+ incurred by, or claims asserted against, such Contributor by reason\r
+ of your accepting any such warranty or additional liability.\r
+\r
+ END OF TERMS AND CONDITIONS\r
+\r
+ APPENDIX: How to apply the Apache License to your work.\r
+\r
+ To apply the Apache License to your work, attach the following\r
+ boilerplate notice, with the fields enclosed by brackets "[]"\r
+ replaced with your own identifying information. (Don't include\r
+ the brackets!) The text should be enclosed in the appropriate\r
+ comment syntax for the file format. We also recommend that a\r
+ file or class name and description of purpose be included on the\r
+ same "printed page" as the copyright notice for easier\r
+ identification within third-party archives.\r
+\r
+ Copyright [yyyy] [name of copyright owner]\r
+\r
+ Licensed under the Apache License, Version 2.0 (the "License");\r
+ you may not use this file except in compliance with the License.\r
+ You may obtain a copy of the License at\r
+\r
+ http://www.apache.org/licenses/LICENSE-2.0\r
+\r
+ Unless required by applicable law or agreed to in writing, software\r
+ distributed under the License is distributed on an "AS IS" BASIS,\r
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+ See the License for the specific language governing permissions and\r
+ limitations under the License.\r
+\r
--- /dev/null
+
+# Package Information for pkg-config
+
+prefix=@PREFIX@
+exec_prefix=/usr
+libdir=/usr/lib
+includedir=/usr/include/network
+
+Name: @PC_NAME@
+Description: @PACKAGE_DESCRIPTION@
+Version: @VERSION@
+Requires: @PC_REQUIRED@
+Libs: -L${libdir} @PC_LDFLAGS@
+Cflags: -I${includedir} @PC_CFLAGS@
+
--- /dev/null
+/usr/include/*
+/usr/include/*/*
+/usr/lib/pkgconfig/*.pc
+
--- /dev/null
+/usr/lib/lib*.so*
--- /dev/null
+capi-network-bluetooth (0.1.0-9) unstable; urgency=low
+
+ * Update version
+ * Git: api/bluetooth
+ * Tag: capi-network-bluetooth_0.1.0-9
+
+ -- ByungWoo Lee <bw1212.lee@samsung.com> Thu, 15 Dec 2011 13:09:32 +0900
+
+capi-network-bluetooth (0.0.1-1) unstable; urgency=low
+
+ * Initial release.
+ * Git: api/bluetooth
+ * Tag: capi-network-bluetooth_0.0.1-1
+
+ -- ByungWoo Lee <bw1212.lee@samsung.com> Wed, 07 Dec 2011 12:48:41 +0900
--- /dev/null
+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: ${shilbs: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}), dlog-dev, capi-base-common-dev, libglib2.0-dev, libbluetooth-frwk-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)
+
--- /dev/null
+#!/usr/bin/make -f
+
+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 ..
+ 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
+
--- /dev/null
+/*
+ * 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>
+
+#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_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;
+
+/**
+ * @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_SOCKET_MODULE
+ * @brief Enumerations of Bluetooth socket connection state.
+ */
+typedef enum
+{
+ BT_SOCKET_CONNECTED, /**< Socket is connected */
+ BT_SOCKET_DISCONNECTED, /**< Socket 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_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 */
+} 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 socket fd */
+ bt_socket_role_e local_role; /**< The local device role in this connection */
+ char* remote_address; /**< The remote device address. */
+} 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;
+
+/**
+ * @addtogroup CAPI_NETWORK_BLUETOOTH_MODULE
+ * @{
+ */
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE
+ * @brief Called when the Bluetooth adapter state changes.
+ * @param[in] result The result of the adapter state changing
+ * @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 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 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_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.
+ * @remarks This function won't be invoked when you call bt_socket_disconnect_rfcomm(), which is synchronous function.
+ *
+ * @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_listen_and_accept_rfcomm() or bt_socket_connect_rfcomm() will invoke this function
+ * if you register this callback using bt_socket_set_connection_state_changed_cb(). \n
+ * If the remote Bluetooth device is connected when bt_socket_destroy_rfcomm() is called, then bt_socket_connection_state_changed_cb() will be invoked.
+ *
+ * @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 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
+ *
+ * @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);
+
+/**
+ * @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 timeout_sec goes.
+ *
+ * @param[in] discoverable_mode The Bluetooth discoverable mode to set
+ * @param[in] timeout_sec The discoverable time duration (in seconds)
+ * @a timeout_sec 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 timeout_sec);
+
+/**
+ * @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 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 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_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 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_SOCKET_MODULE
+ * @brief Registers a rfcomm socket with a specific UUID.
+ *
+ * @remarks A socket can be destroyed by bt_socket_destroy_rfcomm().
+ *
+ * @param[in] port_uuid The UUID of service to provide
+ * @param[out] socket_fd A socket file descriptor to be used to communicate
+ * @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* port_uuid, int *socket_fd);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE
+ * @brief Removes the rfcomm socket with the given socket file descriptor.
+ *
+ * @param[in] socket_fd The socket file descriptor 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, asynchronously.
+ *
+ * @param[in] socket_fd The socket file descriptor 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 This function invokes bt_socket_connection_state_changed_cb().
+ *
+ * @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 Connects to a specific RFCOMM based service on a remote Bluetooth device UUID, asynchronously.
+ *
+ * @remarks A connection can be disconnected by bt_socket_disconnect_rfcomm().
+ *
+ * @param[in] remote_address The address of the remote Bluetooth device
+ * @param[in] remote_port_uuid The UUID of service provided by the remote Bluetooth device
+ *
+ * @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* remote_port_uuid);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE
+ * @brief Disconnects the RFCOMM connection with the given socket file descriptor.
+ * @remarks Because this is a synchronous function, bt_socket_connection_state_changed_cb() won't be called
+ * even though a connection is disconnected successfully.
+ *
+ * @param[in] socket_fd The socket file descriptor to close
+ *
+ * @return 0 on success, otherwise a negative error value.
+ * @retval #BT_ERROR_NONE Successful
+ * @retval #BT_ERROR_NOT_INITIALIZED Not initialized
+ * @retval #BT_ERROR_NOT_ENABLED Not enabled
+ * @retval #BT_ERROR_INVALID_PARAMETER Invalid parameter
+ *
+ * @pre The connection must be established with bt_socket_connect_rfcomm().
+ *
+ * @see bt_socket_connect_rfcomm()
+ */
+int bt_socket_disconnect_rfcomm(int socket_fd);
+
+/**
+ * @ingroup CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE
+ * @brief Sends data to the connected device.
+ *
+ * @param[in] socket_fd The connected socket
+ * @param[in] 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
+ * @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 must be established with either bt_socket_connect_rfcomm() or bt_socket_listen_and_accept_rfcomm().
+ *
+ * @see bt_socket_connect_rfcomm()
+ * @see bt_socket_listen_and_accept_rfcomm()
+ */
+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 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);
+
+
+/**
+ * @}
+ */
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif // __TIZEN_NETWORK_BLUETOOTH_H__
--- /dev/null
+/*
+ * 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_PRIVATE_H__
+#define __TIZEN_NETWORK_BLUETOOTH_PRIVATE_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @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_e;
+
+/**
+ * @internal
+ */
+struct bt_event_sig_event_slot_s
+{
+ int event_type;
+ const void* callback;
+ void* user_data;
+};
+
+/**
+ * @internal
+ * @brief Proxy of platform events.
+ */
+void _bt_event_proxy(int event, bluetooth_event_param_t *param, void *user_data);
+
+/**
+ * @internal
+ * @brief Registers a new callback.
+ */
+void _bt_set_cb(int events, void *callback, void *user_data);
+
+/**
+ * @internal
+ * @brief Removes callback function form callback registry.
+ */
+void _bt_unset_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 Bluetooth F/W bt_sdp_info_t to capi bt_device_sdp_info_s.
+ */
+int _bt_get_bt_device_sdp_info_s(bt_device_sdp_info_s **dest, bt_sdp_info_t *source);
+
+
+/**
+ * @internal
+ * @brief Free bt_device_sdp_info_s.
+ */
+void _bt_free_bt_device_sdp_info_s(bt_device_sdp_info_s *sdp_info);
+
+/**
+ * @internal
+ * @brief Convert bluetooth_discoverable_mode_t into bt_adapter_visibility_mode_e.
+ */
+bt_adapter_visibility_mode_e _bt_get_bt_adapter_visibility_mode_e(bluetooth_discoverable_mode_t mode);
+
+/**
+ * @internal
+ * @brief Convert Bluetooth F/W bluetooth_device_info_t to capi bt_adapter_device_discovery_info_s.
+ */
+int _bt_get_bt_adapter_device_discovery_info_s
+ (bt_adapter_device_discovery_info_s **discovery_info, bluetooth_device_info_t *source_info);
+
+/**
+ * @internal
+ * @brief Free bt_adapter_device_discovery_info_s.
+ */
+void _bt_free_bt_adapter_device_discovery_info_s(bt_adapter_device_discovery_info_s *discovery_info);
+
+/**
+ * @internal
+ * @brief Get index of callback.
+ */
+int _bt_get_cb_index(int event);
+
+/**
+ * @internal
+ * @brief Copy service list.
+ */
+int _bt_copy_service_list(bt_device_info_s *bonded_device_info, bt_device_sdp_info_s *sdp_info);
+
+/**
+ * @internal
+ * @brief Convert error code to string.
+ */
+char* _bt_convert_error_to_string(int error);
+
+/**
+ * @internal
+ * @brief Convert lower case to upper case in origin.
+ */
+void _bt_convert_lower_to_upper(char* origin);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __TIZEN_NETWORK_BLUETOOTH_PRIVATE_H__ */
--- /dev/null
+Name: capi-network-bluetooth
+Summary: Network Bluetooth Framework
+Version: 0.1.0
+Release: 1
+Group: TO_BE/FILLED_IN
+License: TO BE FILLED IN
+Source0: %{name}-%{version}.tar.gz
+Requires(post): /sbin/ldconfig
+Requires(postun): /sbin/ldconfig
+
+BuildRequires: pkgconfig(dbus-glib-1)
+BuildRequires: pkgconfig(dlog)
+BuildRequires: pkgconfig(glib-2.0)
+BuildRequires: pkgconfig(vconf)
+BuildRequires: pkgconfig(bluetooth-api)
+BuildRequires: capi-base-common
+BuildRequires: cmake
+
+
+%description
+Network Bluetooth Framework
+
+%package devel
+Summary: Network Bluetooth Framework (DEV)
+Group: TO_BE/FILLED
+Requires: %{name} = %{version}-%{release}
+
+%description devel
+Network Bluetooth Framework (DEV).
+
+%prep
+%setup -q
+
+%build
+cmake . -DCMAKE_INSTALL_PREFIX=/usr
+
+make %{?jobs:-j%jobs}
+
+%install
+rm -rf %{buildroot}
+%make_install
+
+
+%post -p /sbin/ldconfig
+
+%postun -p /sbin/ldconfig
+
+%files
+/usr/lib/*.so
+
+%files devel
+/usr/include/*
+/usr/lib/pkgconfig/capi-network-bluetooth.pc
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+#include <glib.h>
+#include <string.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <dlog.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include <bluetooth.h>
+#include <bluetooth-api.h>
+#include <bluetooth_private.h>
+
+#ifdef LOG_TAG
+#undef LOG_TAG
+#endif
+#define LOG_TAG "TIZEN_N_BLUETOOTH"
+
+static bool is_initialized = false;
+static bool is_creating_bond = false;
+static bt_device_info_s* bonded_device = NULL;
+struct bt_event_sig_event_slot_s bt_event_slot_container[] =
+{
+ {BT_EVENT_STATE_CHANGED, NULL, NULL},
+ {BT_EVENT_NAME_CHANGED, NULL, NULL},
+ {BT_EVENT_VISIBILITY_MODE_CHANGED, NULL, NULL},
+ {BT_EVENT_DEVICE_DISCOVERY_STATE_CHANGED, NULL, NULL},
+ {BT_EVENT_BOND_CREATED, NULL, NULL},
+ {BT_EVENT_BOND_DESTROYED, NULL, NULL},
+ {BT_EVENT_AUTHORIZATION_CHANGED, NULL, NULL},
+ {BT_EVENT_SERVICE_SEARCHED, NULL, NULL},
+ {BT_EVENT_DATA_RECEIVED, NULL, NULL},
+ {BT_EVENT_CONNECTION_STATE_CHANGED, NULL, NULL},
+};
+
+
+/*
+ * Internal Macros
+ */
+#define BT_CHECK_INIT_STATUS() \
+ if( is_initialized != true ) \
+ { \
+ LOGE("[%s] NOT_INITIALIZED(0x%08x)", __FUNCTION__, BT_ERROR_NOT_INITIALIZED); \
+ return BT_ERROR_NOT_INITIALIZED; \
+ }
+
+#define BT_CHECK_INPUT_PARAMETER(arg) \
+ if( arg == NULL ) \
+ { \
+ LOGE("[%s] INVALID_PARAMETER(0x%08x)", __FUNCTION__, BT_ERROR_INVALID_PARAMETER); \
+ return BT_ERROR_INVALID_PARAMETER; \
+ }
+
+
+
+/*
+ * Public Functions
+ */
+int bt_initialize(void)
+{
+ if( is_initialized != true )
+ {
+ if( bluetooth_register_callback(&_bt_event_proxy, NULL) != BLUETOOTH_ERROR_NONE )
+ {
+ LOGE("[%s] OPERATION_FAILED(0x%08x)", __FUNCTION__, BT_ERROR_OPERATION_FAILED);
+ return BT_ERROR_OPERATION_FAILED;
+ }
+ is_initialized = true;
+ }
+
+ return BT_ERROR_NONE;
+}
+
+int bt_deinitialize(void)
+{
+ BT_CHECK_INIT_STATUS();
+ if( bluetooth_unregister_callback() != BLUETOOTH_ERROR_NONE )
+ {
+ LOGE("[%s] OPERATION_FAILED(0x%08x)", __FUNCTION__, BT_ERROR_OPERATION_FAILED);
+ return BT_ERROR_OPERATION_FAILED;
+ }
+ is_initialized = false;
+
+ return BT_ERROR_NONE;
+}
+
+
+int bt_adapter_enable(void)
+{
+ int error_code = BT_ERROR_NONE;
+
+ BT_CHECK_INIT_STATUS();
+ error_code = _bt_get_error_code( bluetooth_enable_adapter() );
+ if( error_code != BT_ERROR_NONE )
+ {
+ LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(error_code), error_code);
+ }
+ return error_code;
+}
+
+int bt_adapter_disable(void)
+{
+ int error_code = BT_ERROR_NONE;
+
+ BT_CHECK_INIT_STATUS();
+ error_code = _bt_get_error_code( bluetooth_disable_adapter() );
+ if( error_code != BT_ERROR_NONE )
+ {
+ LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(error_code), error_code);
+ }
+ return error_code;
+}
+
+int bt_adapter_get_state(bt_adapter_state_e *adapter_state)
+{
+ BT_CHECK_INIT_STATUS();
+ BT_CHECK_INPUT_PARAMETER(adapter_state);
+
+ *adapter_state = bluetooth_check_adapter();
+ return BT_ERROR_NONE;
+}
+
+int bt_adapter_get_address(char **address)
+{
+ bluetooth_device_address_t loc_address = { {0} };
+ int error_code = BT_ERROR_NONE;
+
+ BT_CHECK_INIT_STATUS();
+ BT_CHECK_INPUT_PARAMETER(address);
+
+ error_code = _bt_get_error_code( bluetooth_get_local_address(&loc_address) );
+ if( error_code != BT_ERROR_NONE )
+ {
+ LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(error_code), error_code);
+ return error_code;
+ }
+
+ error_code = _bt_convert_address_to_string(address, &loc_address);
+ if( error_code != BT_ERROR_NONE )
+ {
+ LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(error_code), error_code);
+ return error_code;
+ }
+
+ return BT_ERROR_NONE;
+}
+
+int bt_adapter_get_name(char** name)
+{
+ int ret = BT_ERROR_NONE;
+ bluetooth_device_name_t loc_name = { {0} };
+
+ BT_CHECK_INIT_STATUS();
+ BT_CHECK_INPUT_PARAMETER(name);
+
+ ret = _bt_get_error_code( bluetooth_get_local_name(&loc_name) );
+ if( ret != BT_ERROR_NONE )
+ {
+ LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
+ return ret;
+ }
+
+ *name = strdup(loc_name.name);
+ if( *name == NULL )
+ {
+ LOGE("[%s] OUT_OF_MEMORY(0x%08x)", __FUNCTION__, BT_ERROR_OUT_OF_MEMORY);
+ return BT_ERROR_OUT_OF_MEMORY;
+ }
+
+ return BT_ERROR_NONE;
+}
+
+int bt_adapter_set_name(const char* name)
+{
+ bluetooth_device_name_t loc_name = { {0} };
+ int ret = BT_ERROR_NONE;
+
+ BT_CHECK_INIT_STATUS();
+ BT_CHECK_INPUT_PARAMETER(name);
+
+ strncpy(loc_name.name, name, BLUETOOTH_DEVICE_NAME_LENGTH_MAX);
+ loc_name.name[BLUETOOTH_DEVICE_NAME_LENGTH_MAX] = '\0';
+
+ ret = _bt_get_error_code( bluetooth_set_local_name(&loc_name) );
+ if( ret != BT_ERROR_NONE )
+ {
+ LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
+ }
+
+ return ret;
+}
+
+int bt_adapter_get_visibility(bt_adapter_visibility_mode_e *mode)
+{
+ bluetooth_discoverable_mode_t discoverable_mode = BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE;
+ int ret = BT_ERROR_NONE;
+
+ BT_CHECK_INIT_STATUS();
+ BT_CHECK_INPUT_PARAMETER(mode);
+
+ ret = _bt_get_error_code( bluetooth_get_discoverable_mode(&discoverable_mode) );
+ if( ret != BT_ERROR_NONE )
+ {
+ LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
+ return ret;
+ }
+
+ *mode = _bt_get_bt_adapter_visibility_mode_e(discoverable_mode);
+ return BT_ERROR_NONE;
+}
+
+int bt_adapter_set_visibility(bt_adapter_visibility_mode_e visibility_mode, int timeout_sec)
+{
+ bluetooth_discoverable_mode_t discoverable_mode = BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE;
+ int error_code = BT_ERROR_NONE;
+
+ BT_CHECK_INIT_STATUS();
+ switch(visibility_mode)
+ {
+ case BT_ADAPTER_VISIBILITY_MODE_LIMITED_DISCOVERABLE :
+ discoverable_mode = BLUETOOTH_DISCOVERABLE_MODE_TIME_LIMITED_DISCOVERABLE;
+ break;
+ case BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE :
+ discoverable_mode = BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE;
+ timeout_sec = 0;
+ break;
+ case BT_ADAPTER_VISIBILITY_MODE_GENERAL_DISCOVERABLE :
+ discoverable_mode = BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE;
+ timeout_sec = 0;
+ break;
+ default:
+ LOGE("[%s] INVALID_PARAMETER(0x%08x)", __FUNCTION__, BT_ERROR_INVALID_PARAMETER);
+ return BT_ERROR_INVALID_PARAMETER;
+ }
+
+ error_code = _bt_get_error_code( bluetooth_set_discoverable_mode(discoverable_mode, timeout_sec) );
+ if( error_code != BT_ERROR_NONE )
+ {
+ LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(error_code), error_code);
+ }
+
+ return error_code;
+}
+
+int bt_device_create_bond(const char* device_address)
+{
+ bluetooth_device_address_t addr_hex = {{0,}};
+ int error_code = BT_ERROR_NONE;
+
+ BT_CHECK_INIT_STATUS();
+ BT_CHECK_INPUT_PARAMETER(device_address);
+
+ _bt_convert_address_to_hex(&addr_hex, device_address);
+ error_code = _bt_get_error_code( bluetooth_bond_device(&addr_hex) );
+ if( error_code != BT_ERROR_NONE )
+ {
+ LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(error_code), error_code);
+ }
+
+ return error_code;
+}
+
+int bt_device_cancel_bonding(void)
+{
+ int error_code = BT_ERROR_NONE;
+
+ BT_CHECK_INIT_STATUS();
+ error_code = _bt_get_error_code( bluetooth_cancel_bonding() );
+ if( error_code != BT_ERROR_NONE )
+ {
+ LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(error_code), error_code);
+ }
+
+ return error_code;
+}
+
+int bt_device_destroy_bond(const char *device_address)
+{
+ bluetooth_device_address_t addr_hex = {{0,}};
+ int error_code = BT_ERROR_NONE;
+
+ BT_CHECK_INIT_STATUS();
+ BT_CHECK_INPUT_PARAMETER(device_address);
+
+ _bt_convert_address_to_hex(&addr_hex, device_address);
+ error_code = _bt_get_error_code( bluetooth_unbond_device(&addr_hex) );
+ if( error_code != BT_ERROR_NONE )
+ {
+ LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(error_code), error_code);
+ }
+
+ return error_code;
+}
+
+int bt_adapter_foreach_bonded_device(bt_adapter_bonded_device_cb foreach_cb, void *user_data)
+{
+ GPtrArray* dev_list = NULL;
+ bt_device_info_s* dev_info = NULL;
+ bluetooth_device_info_t* ptr = NULL;
+ int ret = BT_ERROR_NONE;
+ int i = 0;
+
+ BT_CHECK_INIT_STATUS();
+ BT_CHECK_INPUT_PARAMETER(foreach_cb);
+
+ dev_list = g_ptr_array_new();
+ if( dev_list == NULL )
+ {
+ LOGE("[%s] OUT_OF_MEMORY(0x%08x)", __FUNCTION__, BT_ERROR_OUT_OF_MEMORY);
+ return BT_ERROR_OUT_OF_MEMORY;
+ }
+
+ ret = _bt_get_error_code( bluetooth_get_bonded_device_list(&dev_list) );
+ if(ret != BT_ERROR_NONE)
+ {
+ LOGE("[%s] %s(0x%08x) : Failed to get bonded device list", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
+ return ret;
+ }
+
+ for(i=0; i<dev_list->len; i++)
+ {
+ ptr = g_ptr_array_index(dev_list, i);
+ if( ptr != NULL )
+ {
+ ret = _bt_get_bt_device_info_s(&dev_info, (bluetooth_device_info_t*)ptr);
+ if( ret != BT_ERROR_NONE )
+ {
+ LOGE("[%s] %s(0x%08x) : Failed to get device info", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
+ break;
+ }
+
+ if( !foreach_cb(dev_info, user_data) )
+ {
+ _bt_free_bt_device_info_s(dev_info);
+ break;
+ }
+ _bt_free_bt_device_info_s(dev_info);
+ }
+ else
+ {
+ LOGE("[%s] OPERATION_FAILED(0x%08x)", __FUNCTION__, BT_ERROR_OPERATION_FAILED);
+ ret = BT_ERROR_OPERATION_FAILED;
+ break;
+ }
+ }
+
+ if(dev_list != NULL )
+ {
+ g_ptr_array_free(dev_list, TRUE);
+ }
+
+ return ret;
+}
+
+int bt_device_set_alias(const char* device_address, const char* alias)
+{
+ bluetooth_device_address_t addr_hex = {{0,}};
+ int error_code = BT_ERROR_NONE;
+
+ BT_CHECK_INIT_STATUS();
+ BT_CHECK_INPUT_PARAMETER(device_address);
+ BT_CHECK_INPUT_PARAMETER(alias);
+
+ _bt_convert_address_to_hex(&addr_hex, device_address);
+ error_code = _bt_get_error_code( bluetooth_set_alias(&addr_hex, alias) );
+ if( error_code != BT_ERROR_NONE )
+ {
+ LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(error_code), error_code);
+ }
+ return error_code;
+}
+
+int bt_device_set_authorization(const char *device_address, bt_device_authorization_e authorization)
+{
+ bluetooth_device_address_t addr_hex = {{0,}};
+ gboolean trusted = FALSE;
+ int error_code = BT_ERROR_NONE;
+
+ BT_CHECK_INIT_STATUS();
+ BT_CHECK_INPUT_PARAMETER(device_address);
+
+ _bt_convert_address_to_hex(&addr_hex, device_address);
+ if( authorization == BT_DEVICE_AUTHORIZED )
+ trusted = TRUE;
+
+ error_code = _bt_get_error_code( bluetooth_authorize_device(&addr_hex, trusted) );
+ if( error_code != BT_ERROR_NONE )
+ {
+ LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(error_code), error_code);
+ }
+ return error_code;
+}
+
+int bt_device_start_service_search(const char * device_address)
+{
+ bluetooth_device_address_t addr_hex = {{0,}};
+ int ret = 0;
+
+ BT_CHECK_INIT_STATUS();
+ BT_CHECK_INPUT_PARAMETER(device_address);
+
+ _bt_convert_address_to_hex(&addr_hex, device_address);
+ ret = _bt_get_error_code( bluetooth_search_service(&addr_hex) );
+
+ // In service search, BT_ERROR_SERVICE_SEARCH_FAILED is returned instead of BT_ERROR_OPERATION_FAILED.
+ if( ret == BT_ERROR_OPERATION_FAILED )
+ ret = BT_ERROR_SERVICE_SEARCH_FAILED;
+
+ if( ret != BT_ERROR_NONE )
+ {
+ LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
+ }
+ return ret;
+}
+
+int bt_device_cancel_service_search(void)
+{
+ int ret = 0;
+
+ BT_CHECK_INIT_STATUS();
+ ret = _bt_get_error_code( bluetooth_cancel_service_search() );
+ if( ret != BT_ERROR_NONE )
+ {
+ LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
+ }
+
+ return ret;
+}
+
+int bt_socket_create_rfcomm(const char* uuid, int *socket_fd)
+{
+ int ret = 0;
+
+ BT_CHECK_INIT_STATUS();
+ BT_CHECK_INPUT_PARAMETER(uuid);
+ BT_CHECK_INPUT_PARAMETER(socket_fd);
+
+ ret = bluetooth_rfcomm_create_socket(uuid);
+ if( ret < 0 )
+ {
+ ret = _bt_get_error_code(ret);
+ LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
+ return ret;
+ }
+ else
+ {
+ *socket_fd = ret;
+ return BT_ERROR_NONE;
+ }
+}
+
+int bt_socket_destroy_rfcomm(int socket_fd)
+{
+ int error_code = BT_ERROR_NONE;
+
+ BT_CHECK_INIT_STATUS();
+ error_code = _bt_get_error_code( bluetooth_rfcomm_remove_socket(socket_fd, 0) );
+ if( error_code != BT_ERROR_NONE )
+ {
+ LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(error_code), error_code);
+ }
+
+ return error_code;
+}
+
+int bt_socket_listen_and_accept_rfcomm(int socket_fd, int max_pending_connection)
+{
+ int ret = BT_ERROR_NONE;
+
+ BT_CHECK_INIT_STATUS();
+ ret = _bt_get_error_code( bluetooth_rfcomm_listen_and_accept(socket_fd,max_pending_connection) );
+ if( ret != BT_ERROR_NONE )
+ {
+ LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
+ }
+
+ return ret;
+}
+
+int bt_socket_connect_rfcomm(const char* remote_address, const char* remote_port_uuid)
+{
+ bluetooth_device_address_t addr_hex = {{0,}};
+ int error_code = BT_ERROR_NONE;
+
+ BT_CHECK_INIT_STATUS();
+ BT_CHECK_INPUT_PARAMETER(remote_address);
+ BT_CHECK_INPUT_PARAMETER(remote_port_uuid);
+
+ _bt_convert_address_to_hex(&addr_hex, remote_address);
+
+ error_code = _bt_get_error_code( bluetooth_rfcomm_connect(&addr_hex, remote_port_uuid) );
+ if( error_code != BT_ERROR_NONE )
+ {
+ LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(error_code), error_code);
+ }
+
+ return error_code;
+}
+
+int bt_socket_disconnect_rfcomm(int socket_fd)
+{
+ int ret = BT_ERROR_NONE;
+
+ BT_CHECK_INIT_STATUS();
+
+ ret = _bt_get_error_code( bluetooth_rfcomm_disconnect(socket_fd) );
+ if( ret != BT_ERROR_NONE )
+ {
+ LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
+ }
+
+ return ret;
+}
+
+int bt_socket_send_data(int socket_fd, const char* data, int length)
+{
+ int ret = 0;
+
+ BT_CHECK_INIT_STATUS();
+ ret = bluetooth_rfcomm_write(socket_fd, data, length);
+ if( ret == BLUETOOTH_ERROR_NOT_IN_OPERATION )
+ {
+ LOGE("[%s] OPERATION_FAILED(0x%08x)", __FUNCTION__, BT_ERROR_OPERATION_FAILED);
+ return BT_ERROR_OPERATION_FAILED;
+ }
+
+ ret = _bt_get_error_code(ret);
+ if( ret != BT_ERROR_NONE )
+ {
+ LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
+ }
+
+ return ret;
+}
+
+int bt_adapter_set_state_changed_cb(bt_adapter_state_changed_cb callback, void* user_data)
+{
+ int ret = BT_ERROR_NONE;
+
+ BT_CHECK_INIT_STATUS();
+ BT_CHECK_INPUT_PARAMETER(callback);
+ _bt_set_cb(BT_EVENT_STATE_CHANGED, callback, user_data);
+ if( ret != BT_ERROR_NONE )
+ {
+ LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
+ }
+
+ return ret;
+}
+
+int bt_adapter_set_name_changed_cb(bt_adapter_name_changed_cb callback, void* user_data)
+{
+ int ret = BT_ERROR_NONE;
+
+ BT_CHECK_INIT_STATUS();
+ BT_CHECK_INPUT_PARAMETER(callback);
+ _bt_set_cb(BT_EVENT_NAME_CHANGED, callback, user_data);
+ if( ret != BT_ERROR_NONE )
+ {
+ LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
+ }
+
+ return ret;
+}
+
+int bt_adapter_set_visibility_mode_changed_cb(bt_adapter_visibility_mode_changed_cb callback, void* user_data)
+{
+ int ret = BT_ERROR_NONE;
+
+ BT_CHECK_INIT_STATUS();
+ BT_CHECK_INPUT_PARAMETER(callback);
+ _bt_set_cb(BT_EVENT_VISIBILITY_MODE_CHANGED, callback, user_data);
+ if( ret != BT_ERROR_NONE )
+ {
+ LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
+ }
+
+ return ret;
+}
+
+int bt_adapter_set_device_discovery_state_changed_cb(bt_adapter_device_discovery_state_changed_cb callback, void* user_data)
+{
+ int ret = BT_ERROR_NONE;
+
+ BT_CHECK_INIT_STATUS();
+ BT_CHECK_INPUT_PARAMETER(callback);
+ _bt_set_cb(BT_EVENT_DEVICE_DISCOVERY_STATE_CHANGED, callback, user_data);
+ if( ret != BT_ERROR_NONE )
+ {
+ LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
+ }
+
+ return ret;
+}
+
+int bt_device_set_bond_created_cb(bt_device_bond_created_cb callback, void* user_data)
+{
+ int ret = BT_ERROR_NONE;
+
+ BT_CHECK_INIT_STATUS();
+ BT_CHECK_INPUT_PARAMETER(callback);
+ _bt_set_cb(BT_EVENT_BOND_CREATED, callback, user_data);
+ if( ret != BT_ERROR_NONE )
+ {
+ LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
+ }
+
+ return ret;
+}
+
+int bt_device_set_bond_destroyed_cb(bt_device_bond_destroyed_cb callback, void* user_data)
+{
+ int ret = BT_ERROR_NONE;
+
+ BT_CHECK_INIT_STATUS();
+ BT_CHECK_INPUT_PARAMETER(callback);
+ _bt_set_cb(BT_EVENT_BOND_DESTROYED, callback, user_data);
+ if( ret != BT_ERROR_NONE )
+ {
+ LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
+ }
+
+ return ret;
+}
+
+int bt_device_set_authorization_changed_cb(bt_device_authorization_changed_cb callback, void* user_data)
+{
+ int ret = BT_ERROR_NONE;
+
+ BT_CHECK_INIT_STATUS();
+ BT_CHECK_INPUT_PARAMETER(callback);
+ _bt_set_cb(BT_EVENT_AUTHORIZATION_CHANGED, callback, user_data);
+ if( ret != BT_ERROR_NONE )
+ {
+ LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
+ }
+
+ return ret;
+}
+
+int bt_device_set_service_searched_cb(bt_device_service_searched_cb callback, void* user_data)
+{
+ int ret = BT_ERROR_NONE;
+
+ BT_CHECK_INIT_STATUS();
+ BT_CHECK_INPUT_PARAMETER(callback);
+ _bt_set_cb(BT_EVENT_SERVICE_SEARCHED, callback, user_data);
+ if( ret != BT_ERROR_NONE )
+ {
+ LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
+ }
+
+ return ret;
+}
+
+int bt_socket_set_data_received_cb(bt_socket_data_received_cb callback, void* user_data)
+{
+ int ret = BT_ERROR_NONE;
+
+ BT_CHECK_INIT_STATUS();
+ BT_CHECK_INPUT_PARAMETER(callback);
+ _bt_set_cb(BT_EVENT_DATA_RECEIVED, callback, user_data);
+ if( ret != BT_ERROR_NONE )
+ {
+ LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
+ }
+
+ return ret;
+}
+
+int bt_socket_set_connection_state_changed_cb(bt_socket_connection_state_changed_cb callback, void* user_data)
+{
+ int ret = BT_ERROR_NONE;
+
+ BT_CHECK_INIT_STATUS();
+ BT_CHECK_INPUT_PARAMETER(callback);
+ _bt_set_cb(BT_EVENT_CONNECTION_STATE_CHANGED, callback, user_data);
+ if( ret != BT_ERROR_NONE )
+ {
+ LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
+ }
+
+ return ret;
+}
+
+int bt_adapter_unset_state_changed_cb(void)
+{
+ BT_CHECK_INIT_STATUS();
+ _bt_unset_cb(BT_EVENT_STATE_CHANGED);
+ return BT_ERROR_NONE;
+}
+
+int bt_adapter_unset_name_changed_cb(void)
+{
+ BT_CHECK_INIT_STATUS();
+ _bt_unset_cb(BT_EVENT_NAME_CHANGED);
+ return BT_ERROR_NONE;
+}
+
+int bt_adapter_unset_visibility_mode_changed_cb(void)
+{
+ BT_CHECK_INIT_STATUS();
+ _bt_unset_cb(BT_EVENT_VISIBILITY_MODE_CHANGED);
+ return BT_ERROR_NONE;
+}
+
+int bt_adapter_unset_device_discovery_state_changed_cb(void)
+{
+ BT_CHECK_INIT_STATUS();
+ _bt_unset_cb(BT_EVENT_DEVICE_DISCOVERY_STATE_CHANGED);
+ return BT_ERROR_NONE;
+}
+
+int bt_device_unset_bond_created_cb(void)
+{
+ BT_CHECK_INIT_STATUS();
+ _bt_unset_cb(BT_EVENT_BOND_CREATED);
+ return BT_ERROR_NONE;
+}
+
+int bt_device_unset_bond_destroyed_cb(void)
+{
+ BT_CHECK_INIT_STATUS();
+ _bt_unset_cb(BT_EVENT_BOND_DESTROYED);
+ return BT_ERROR_NONE;
+}
+
+int bt_device_unset_authorization_changed_cb(void)
+{
+ BT_CHECK_INIT_STATUS();
+ _bt_unset_cb(BT_EVENT_AUTHORIZATION_CHANGED);
+ return BT_ERROR_NONE;
+}
+
+int bt_device_unset_service_searched_cb(void)
+{
+ BT_CHECK_INIT_STATUS();
+ _bt_unset_cb(BT_EVENT_SERVICE_SEARCHED);
+ return BT_ERROR_NONE;
+}
+
+int bt_socket_unset_data_received_cb(void)
+{
+ BT_CHECK_INIT_STATUS();
+ _bt_unset_cb(BT_EVENT_DATA_RECEIVED);
+ return BT_ERROR_NONE;
+}
+
+int bt_socket_unset_connection_state_changed_cb(void)
+{
+ BT_CHECK_INIT_STATUS();
+ _bt_unset_cb(BT_EVENT_CONNECTION_STATE_CHANGED);
+ return BT_ERROR_NONE;
+}
+
+int bt_adapter_start_device_discovery(void)
+{
+ int error_code = BT_ERROR_NONE;
+
+ BT_CHECK_INIT_STATUS();
+ error_code = _bt_get_error_code( bluetooth_start_discovery(0, 0, BLUETOOTH_DEVICE_MAJOR_MASK_MISC) );
+ if( error_code != BT_ERROR_NONE )
+ {
+ LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(error_code), error_code);
+ }
+ return error_code;
+}
+
+int bt_adapter_stop_device_discovery(void)
+{
+ int error_code = BT_ERROR_NONE;
+
+ BT_CHECK_INIT_STATUS();
+ error_code = _bt_get_error_code( bluetooth_cancel_discovery() );
+ if( error_code != BT_ERROR_NONE )
+ {
+ LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(error_code), error_code);
+ }
+ return error_code;
+}
+
+int bt_adapter_is_discovering(bool* is_discovering)
+{
+ int ret = 0;
+
+ BT_CHECK_INIT_STATUS();
+ BT_CHECK_INPUT_PARAMETER(is_discovering);
+
+ ret = bluetooth_is_discovering();
+ if(ret >= BLUETOOTH_ERROR_BASE)
+ {
+ *is_discovering = (ret == 1)?true:false;
+ return BT_ERROR_NONE;
+ }
+ else
+ {
+ ret = _bt_get_error_code(ret);
+ LOGE("[%s] %s(0x%08x)", __FUNCTION__, _bt_convert_error_to_string(ret), ret);
+ return ret;
+ }
+}
+
+
+
+/*
+ * Internal Functions
+ */
+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;
+ }
+}
+
+int _bt_get_error_code(int origin_error)
+{
+ switch(origin_error)
+ {
+ case BLUETOOTH_ERROR_NONE:
+ return BT_ERROR_NONE;
+ case BLUETOOTH_ERROR_INVALID_DATA:
+ case BLUETOOTH_ERROR_INVALID_PARAM:
+ case BLUETOOTH_ERROR_NOT_CONNECTED:
+ case BLUETOOTH_ERROR_NOT_SUPPORT:
+ return BT_ERROR_INVALID_PARAMETER;
+ case BLUETOOTH_ERROR_MEMORY_ALLOCATION:
+ case BLUETOOTH_ERROR_OUT_OF_MEMORY:
+ return BT_ERROR_OUT_OF_MEMORY;
+ case BLUETOOTH_ERROR_TIMEOUT:
+ return BT_ERROR_TIMED_OUT;
+ case BLUETOOTH_ERROR_DEVICE_NOT_ENABLED:
+ return BT_ERROR_NOT_ENABLED;
+ case BLUETOOTH_ERROR_DEVICE_ALREADY_ENABLED:
+ return BT_ERROR_ALREADY_DONE;
+ case BLUETOOTH_ERROR_NOT_PAIRED:
+ return BT_ERROR_REMOTE_DEVICE_NOT_BONDED;
+ case BLUETOOTH_ERROR_NOT_IN_OPERATION:
+ return BT_ERROR_NOT_IN_PROGRESS;
+ case BLUETOOTH_ERROR_IN_PROGRESS:
+ return BT_ERROR_NOW_IN_PROGRESS;
+ case BLUETOOTH_ERROR_DEVICE_BUSY:
+ return BT_ERROR_RESOURCE_BUSY;
+ case BLUETOOTH_ERROR_CANCEL:
+ case BLUETOOTH_ERROR_CANCEL_BY_USER:
+ return BT_ERROR_CANCELLED;
+ case BLUETOOTH_ERROR_AUTHENTICATION_FAILED:
+ return BT_ERROR_AUTH_FAILED;
+ case BLUETOOTH_ERROR_HOST_DOWN:
+ return BT_ERROR_REMOTE_DEVICE_NOT_FOUND;
+ case BLUETOOTH_ERROR_SERVICE_SEARCH_ERROR:
+ return BT_ERROR_SERVICE_SEARCH_FAILED;
+ case BLUETOOTH_ERROR_SERVICE_NOT_FOUND:
+ case BLUETOOTH_ERROR_PARING_FAILED:
+ case BLUETOOTH_ERROR_MAX_CONNECTION:
+ case BLUETOOTH_ERROR_ALREADY_CONNECT:
+ case BLUETOOTH_ERROR_NO_RESOURCES:
+ case BLUETOOTH_ERROR_REGISTRATION_FAILED:
+ case BLUETOOTH_ERROR_CONNECTION_BUSY:
+ case BLUETOOTH_ERROR_MAX_CLIENT:
+ case BLUETOOTH_ERROR_INVALID_CALLBACK:
+ case BLUETOOTH_ERROR_NOT_FOUND:
+ case BLUETOOTH_ERROR_INTERNAL:
+ case BLUETOOTH_ERROR_CONNECTION_ERROR:
+ case BLUETOOTH_ERROR_ACCESS_DENIED:
+ default:
+ return BT_ERROR_OPERATION_FAILED;
+ }
+
+}
+
+int _bt_get_bt_device_info_s(bt_device_info_s** dest_dev, bluetooth_device_info_t* source_dev)
+{
+ int i = 0;
+
+ BT_CHECK_INPUT_PARAMETER(source_dev);
+
+ *dest_dev = (bt_device_info_s *)malloc(sizeof(bt_device_info_s));
+ if(*dest_dev == NULL)
+ {
+ return BT_ERROR_OUT_OF_MEMORY;
+ }
+
+ if( strlen(source_dev->device_name.name) > 0 )
+ {
+ (*dest_dev)->remote_name = strdup(source_dev->device_name.name);
+ }
+ else
+ {
+ (*dest_dev)->remote_name = NULL;
+ }
+
+ _bt_convert_address_to_string(&((*dest_dev)->remote_address), &(source_dev->device_address));
+
+ (*dest_dev)->bt_class.major_device_class = source_dev->device_class.major_class;
+ (*dest_dev)->bt_class.minor_device_class = source_dev->device_class.minor_class;
+ (*dest_dev)->bt_class.major_service_class_mask = source_dev->device_class.service_class;
+ if(source_dev->service_index > 0)
+ {
+ (*dest_dev)->service_uuid = (char**)malloc(sizeof(char*) * source_dev->service_index);
+ if( (*dest_dev)->service_uuid != NULL )
+ {
+ for(i=0; i<source_dev->service_index; i++)
+ {
+ (*dest_dev)->service_uuid[i] = strdup(source_dev->uuids[i]);
+ if( (*dest_dev)->service_uuid[i] != NULL )
+ {
+ _bt_convert_lower_to_upper((*dest_dev)->service_uuid[i]);
+ }
+ }
+ }
+ }
+ else
+ {
+ (*dest_dev)->service_uuid = NULL;
+ }
+ (*dest_dev)->service_count = source_dev->service_index;
+ (*dest_dev)->is_bonded = (bool)source_dev->paired;
+ (*dest_dev)->is_connected = (bool)source_dev->connected;
+ (*dest_dev)->is_authorized = (bool)source_dev->trust;
+
+ return BT_ERROR_NONE;
+}
+
+void _bt_free_bt_device_info_s(bt_device_info_s* device_info)
+{
+ int i = 0;
+
+ if(device_info == NULL)
+ return;
+
+ if(device_info->remote_name != NULL)
+ free(device_info->remote_name);
+
+ if(device_info->remote_address != NULL)
+ free(device_info->remote_address);
+
+ if( device_info->service_uuid != NULL )
+ {
+ for(i=0; i<device_info->service_count; i++)
+ {
+ if( device_info->service_uuid[i] != NULL )
+ free(device_info->service_uuid[i]);
+ }
+ free(device_info->service_uuid);
+ }
+
+ free(device_info);
+ device_info = NULL;
+}
+
+int _bt_convert_address_to_string(char** addr_str, bluetooth_device_address_t* addr_hex)
+{
+ char address[18] = {0,};
+
+ snprintf(address, 18, "%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X", \
+ addr_hex->addr[0],addr_hex->addr[1],addr_hex->addr[2],addr_hex->addr[3],addr_hex->addr[4],addr_hex->addr[5]);
+ *addr_str = strdup(address);
+
+ if(*addr_str != NULL)
+ {
+ return BT_ERROR_NONE;
+ }
+ else
+ {
+ return BT_ERROR_OUT_OF_MEMORY;
+ }
+}
+
+void _bt_convert_address_to_hex(bluetooth_device_address_t* addr_hex, const char* addr_str)
+{
+ int i = 0;
+ unsigned int addr[BLUETOOTH_ADDRESS_LENGTH] = {0,};
+
+ i = sscanf(addr_str, "%X:%X:%X:%X:%X:%X", &addr[0], &addr[1], &addr[2], &addr[3], &addr[4], &addr[5]);
+ if(i != BLUETOOTH_ADDRESS_LENGTH)
+ {
+ LOGI("[%s] Invalid format string - %s", __FUNCTION__, addr_str);
+ }
+
+ for(i=0; i<BLUETOOTH_ADDRESS_LENGTH; i++)
+ {
+ addr_hex->addr[i] = (unsigned char)addr[i];
+ }
+}
+
+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;
+}
+
+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;
+}
+
+bt_adapter_visibility_mode_e _bt_get_bt_adapter_visibility_mode_e(bluetooth_discoverable_mode_t mode)
+{
+ switch(mode)
+ {
+ case BLUETOOTH_DISCOVERABLE_MODE_TIME_LIMITED_DISCOVERABLE:
+ return BT_ADAPTER_VISIBILITY_MODE_LIMITED_DISCOVERABLE;
+ case BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE:
+ return BT_ADAPTER_VISIBILITY_MODE_GENERAL_DISCOVERABLE;
+ default:
+ return BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE;
+ }
+}
+
+
+void _bt_event_proxy(int event, bluetooth_event_param_t *param, void* user_data)
+{
+ bluetooth_rfcomm_connection_t* connection_ind = NULL;
+ bluetooth_rfcomm_disconnection_t* disconnection_ind = NULL;
+ bt_socket_connection_s rfcomm_connection;
+ bt_device_sdp_info_s* sdp_info = NULL;
+ bt_adapter_device_discovery_info_s* discovery_info = NULL;
+ char* device_addr = NULL;
+ int error_code = BT_ERROR_NONE;
+ int event_index = -1;
+
+ event_index = _bt_get_cb_index(event);
+ if( event_index == -1 || bt_event_slot_container[event_index].callback == NULL )
+ {
+ if( event_index == BT_EVENT_BOND_CREATED )
+ _bt_free_bt_device_info_s(bonded_device);
+ return;
+ }
+
+ /*
+ * BLUETOOTH_EVENT_SERVICE_SEARCHED is converted BLUETOOTH_EVENT_BONDING_FINISHED
+ * immediately after BLUETOOTH_EVENT_BONDING_FINISHED
+ */
+ if( event == BLUETOOTH_EVENT_BONDING_FINISHED )
+ {
+ if( param->result == BLUETOOTH_ERROR_NONE )
+ {
+ is_creating_bond = true;
+ }
+ error_code = param->result;
+ _bt_get_bt_device_info_s(&bonded_device, (bluetooth_device_info_t *)(param->param_data));
+ }
+ else if( is_creating_bond == true && event == BLUETOOTH_EVENT_SERVICE_SEARCHED )
+ {
+ is_creating_bond = false;
+ event = BLUETOOTH_EVENT_BONDING_FINISHED;
+
+ if( param->result == BLUETOOTH_ERROR_NONE &&
+ _bt_get_bt_device_sdp_info_s(&sdp_info, (bt_sdp_info_t*)(param->param_data)) == BT_ERROR_NONE )
+ {
+ error_code = BLUETOOTH_ERROR_NONE;
+ if( _bt_copy_service_list(bonded_device, sdp_info) != BT_ERROR_NONE )
+ {
+ error_code = BT_ERROR_SERVICE_SEARCH_FAILED;
+ }
+ _bt_free_bt_device_sdp_info_s(sdp_info);
+ }
+ else
+ {
+ error_code = BT_ERROR_SERVICE_SEARCH_FAILED;
+ }
+ }
+
+ switch(event)
+ {
+ case BLUETOOTH_EVENT_ENABLED:
+ LOGI("[%s] bt_adapter_state_changed_cb() will be called with BT_ADAPTER_ENABLED", __FUNCTION__);
+ ((bt_adapter_state_changed_cb)bt_event_slot_container[event_index].callback)
+ (_bt_get_error_code(param->result), BT_ADAPTER_ENABLED,
+ bt_event_slot_container[event_index].user_data);
+ break;
+ case BLUETOOTH_EVENT_DISABLED:
+ LOGI("[%s] bt_adapter_state_changed_cb() will be called with BT_ADAPTER_DISABLED", __FUNCTION__);
+ ((bt_adapter_state_changed_cb)bt_event_slot_container[event_index].callback)
+ (_bt_get_error_code(param->result), BT_ADAPTER_DISABLED,
+ bt_event_slot_container[event_index].user_data);
+ break;
+ case BLUETOOTH_EVENT_LOCAL_NAME_CHANGED:
+ LOGI("[%s] bt_adapter_name_changed_cb() will be called", __FUNCTION__);
+ ((bt_adapter_name_changed_cb)bt_event_slot_container[event_index].callback)
+ ((char*)(param->param_data), bt_event_slot_container[event_index].user_data);
+ break;
+ case BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED:
+ LOGI("[%s] bt_adapter_visibility_mode_changed_cb() will be called", __FUNCTION__);
+ ((bt_adapter_visibility_mode_changed_cb)bt_event_slot_container[event_index].callback)
+ (_bt_get_error_code(param->result),
+ _bt_get_bt_adapter_visibility_mode_e(*(bt_adapter_visibility_mode_e*)(param->param_data)),
+ bt_event_slot_container[event_index].user_data);
+ break;
+ case BLUETOOTH_EVENT_DISCOVERY_STARTED:
+ LOGI("[%s] bt_adapter_device_discovery_state_changed_cb() will be called with BT_ADAPTER_DEVICE_DISCOVERY_STARTED", __FUNCTION__);
+ ((bt_adapter_device_discovery_state_changed_cb)bt_event_slot_container[event_index].callback)
+ (_bt_get_error_code(param->result),
+ BT_ADAPTER_DEVICE_DISCOVERY_STARTED, NULL, bt_event_slot_container[event_index].user_data);
+ break;
+ case BLUETOOTH_EVENT_DISCOVERY_FINISHED:
+ LOGI("[%s] bt_adapter_device_discovery_state_changed_cb() will be called with BT_ADAPTER_DEVICE_DISCOVERY_FINISHED", __FUNCTION__);
+ ((bt_adapter_device_discovery_state_changed_cb)bt_event_slot_container[event_index].callback)
+ (_bt_get_error_code(param->result), BT_ADAPTER_DEVICE_DISCOVERY_FINISHED,
+ NULL, bt_event_slot_container[event_index].user_data);
+ break;
+ case BLUETOOTH_EVENT_REMOTE_DEVICE_NAME_UPDATED:
+ LOGI("[%s] bt_adapter_device_discovery_state_changed_cb() will be called with BT_ADAPTER_DEVICE_DISCOVERY_FOUND", __FUNCTION__);
+ if( _bt_get_bt_adapter_device_discovery_info_s(&discovery_info, (bluetooth_device_info_t *)(param->param_data)) == BT_ERROR_NONE )
+ {
+ ((bt_adapter_device_discovery_state_changed_cb)bt_event_slot_container[event_index].callback)
+ (_bt_get_error_code(param->result), BT_ADAPTER_DEVICE_DISCOVERY_FOUND,
+ discovery_info, bt_event_slot_container[event_index].user_data);
+ _bt_free_bt_adapter_device_discovery_info_s(discovery_info);
+ }
+ else
+ {
+ ((bt_adapter_device_discovery_state_changed_cb)bt_event_slot_container[event_index].callback)
+ (_bt_get_error_code(param->result), BT_ADAPTER_DEVICE_DISCOVERY_FOUND,
+ NULL, bt_event_slot_container[event_index].user_data);
+ }
+ break;
+ case BLUETOOTH_EVENT_BONDING_FINISHED:
+ if( is_creating_bond == false )
+ {
+ LOGI("[%s] bt_device_bond_created_cb() will be called", __FUNCTION__);
+ if( error_code != BT_ERROR_SERVICE_SEARCH_FAILED )
+ {
+ // In other case, BLUETOOTH_ERROR_ACCESS_DENIED will be changed to BT_ERROR_OPERATION_FAILED
+ if(error_code == BLUETOOTH_ERROR_ACCESS_DENIED)
+ error_code = BT_ERROR_AUTH_REJECTED;
+ else
+ error_code = _bt_get_error_code(error_code);
+ }
+ ((bt_device_bond_created_cb)bt_event_slot_container[event_index].callback)
+ (error_code, bonded_device, bt_event_slot_container[event_index].user_data);
+ _bt_free_bt_device_info_s(bonded_device);
+ }
+ else
+ LOGI("[%s] After finishing service search, bt_device_bond_created_cb() will be called", __FUNCTION__);
+ break;
+ case BLUETOOTH_EVENT_BONDED_DEVICE_REMOVED:
+ LOGI("[%s] bt_device_bond_destroyed_cb() will be called", __FUNCTION__);
+ _bt_convert_address_to_string(&device_addr, (bluetooth_device_address_t *)(param->param_data));
+ ((bt_device_bond_destroyed_cb)bt_event_slot_container[event_index].callback)
+ (_bt_get_error_code(param->result), device_addr,
+ bt_event_slot_container[event_index].user_data);
+ if(device_addr != NULL)
+ free(device_addr);
+ device_addr = NULL;
+ break;
+ case BLUETOOTH_EVENT_DEVICE_AUTHORIZED:
+ LOGI("[%s] bt_device_authorization_changed_cb() will be called with BT_DEVICE_AUTHORIZED", __FUNCTION__);
+ _bt_convert_address_to_string(&device_addr, (bluetooth_device_address_t *)(param->param_data));
+ ((bt_device_authorization_changed_cb)bt_event_slot_container[event_index].callback)
+ (BT_DEVICE_AUTHORIZED, device_addr, bt_event_slot_container[event_index].user_data);
+ if(device_addr != NULL)
+ free(device_addr);
+ device_addr = NULL;
+ break;
+ case BLUETOOTH_EVENT_DEVICE_UNAUTHORIZED:
+ LOGI("[%s] bt_device_authorization_changed_cb() will be called with BT_DEVICE_UNAUTHORIZED", __FUNCTION__);
+ _bt_convert_address_to_string(&device_addr, (bluetooth_device_address_t *)(param->param_data));
+ ((bt_device_authorization_changed_cb)bt_event_slot_container[event_index].callback)
+ (BT_DEVICE_UNAUTHORIZED, device_addr, bt_event_slot_container[event_index].user_data);
+ if(device_addr != NULL)
+ free(device_addr);
+ device_addr = NULL;
+ break;
+ case BLUETOOTH_EVENT_SERVICE_SEARCHED:
+ LOGI("[%s] bt_device_service_searched_cb() will be called", __FUNCTION__);
+ _bt_get_bt_device_sdp_info_s(&sdp_info, (bt_sdp_info_t*)(param->param_data));
+ error_code = _bt_get_error_code(param->result);
+ // In service search, BT_ERROR_SERVICE_SEARCH_FAILED is returned instead of BT_ERROR_OPERATION_FAILED.
+ if( error_code == BT_ERROR_OPERATION_FAILED )
+ error_code = BT_ERROR_SERVICE_SEARCH_FAILED;
+ ((bt_device_service_searched_cb)bt_event_slot_container[event_index].callback)
+ (error_code, sdp_info, bt_event_slot_container[event_index].user_data);
+ _bt_free_bt_device_sdp_info_s(sdp_info);
+ break;
+ case BLUETOOTH_EVENT_RFCOMM_DATA_RECEIVED:
+ LOGI("[%s] bt_socket_data_received_cb() will be called", __FUNCTION__);
+ ((bt_socket_data_received_cb)bt_event_slot_container[event_index].callback)
+ ((bt_socket_received_data_s*)(param->param_data), bt_event_slot_container[event_index].user_data);
+ break;
+ case BLUETOOTH_EVENT_RFCOMM_CONNECTED:
+ LOGI("[%s] bt_socket_connection_state_changed_cb() will be called with BT_SOCKET_CONNECTED", __FUNCTION__);
+ // In other case, BLUETOOTH_ERROR_INVALID_PARAM will be changed to BT_ERROR_INVALID_PARAM
+ if(param->result == BLUETOOTH_ERROR_INVALID_PARAM)
+ error_code = BT_ERROR_OPERATION_FAILED;
+ else
+ error_code = _bt_get_error_code(param->result);
+
+ connection_ind = (bluetooth_rfcomm_connection_t*)(param->param_data);
+ rfcomm_connection.socket_fd = connection_ind->socket_fd;
+ rfcomm_connection.local_role = connection_ind->device_role;
+ _bt_convert_address_to_string(&(rfcomm_connection.remote_address), &(connection_ind->device_addr));
+
+ ((bt_socket_connection_state_changed_cb)bt_event_slot_container[event_index].callback)
+ (error_code, BT_SOCKET_CONNECTED, &rfcomm_connection, bt_event_slot_container[event_index].user_data);
+
+ if( rfcomm_connection.remote_address != NULL )
+ {
+ free(rfcomm_connection.remote_address);
+ rfcomm_connection.remote_address = NULL;
+ }
+
+ break;
+ case BLUETOOTH_EVENT_RFCOMM_DISCONNECTED:
+ LOGI("[%s] bt_socket_connection_state_changed_cb() will be called with BT_SOCKET_DISCONNECTED", __FUNCTION__);
+ disconnection_ind = (bluetooth_rfcomm_disconnection_t*)(param->param_data);
+ rfcomm_connection.socket_fd = disconnection_ind->socket_fd;
+ rfcomm_connection.local_role = BT_SOCKET_UNKNOWN;
+ _bt_convert_address_to_string(&(rfcomm_connection.remote_address), &(disconnection_ind->device_addr));
+ ((bt_socket_connection_state_changed_cb)bt_event_slot_container[event_index].callback)
+ (_bt_get_error_code(param->result), BT_SOCKET_DISCONNECTED,
+ &rfcomm_connection, bt_event_slot_container[event_index].user_data);
+
+ if( rfcomm_connection.remote_address != NULL )
+ {
+ free(rfcomm_connection.remote_address);
+ rfcomm_connection.remote_address = NULL;
+ }
+ break;
+ }
+}
+
+
+int _bt_get_bt_adapter_device_discovery_info_s
+(bt_adapter_device_discovery_info_s** discovery_info, bluetooth_device_info_t* source_info)
+{
+ BT_CHECK_INPUT_PARAMETER(source_info);
+
+ *discovery_info = (bt_adapter_device_discovery_info_s *)malloc(sizeof(bt_adapter_device_discovery_info_s));
+ if(*discovery_info == NULL)
+ {
+ return BT_ERROR_OUT_OF_MEMORY;
+ }
+
+ if( strlen(source_info->device_name.name) > 0 )
+ {
+ (*discovery_info)->remote_name = strdup(source_info->device_name.name);
+ }
+ else
+ {
+ (*discovery_info)->remote_name = NULL;
+ }
+
+ _bt_convert_address_to_string(&((*discovery_info)->remote_address), &(source_info->device_address));
+
+ (*discovery_info)->bt_class.major_device_class = source_info->device_class.major_class;
+ (*discovery_info)->bt_class.minor_device_class = source_info->device_class.minor_class;
+ (*discovery_info)->bt_class.major_service_class_mask = source_info->device_class.service_class;
+
+ (*discovery_info)->rssi = (bool)source_info->rssi;
+ (*discovery_info)->is_bonded = (bool)source_info->paired;
+
+ return BT_ERROR_NONE;
+}
+
+void _bt_free_bt_adapter_device_discovery_info_s(bt_adapter_device_discovery_info_s* discovery_info)
+{
+ if(discovery_info == NULL)
+ return;
+
+ if(discovery_info->remote_name != NULL)
+ free(discovery_info->remote_name);
+
+ if(discovery_info->remote_address != NULL)
+ free(discovery_info->remote_address);
+
+ free(discovery_info);
+ discovery_info = NULL;
+}
+
+int _bt_get_cb_index(int event)
+{
+ switch(event)
+ {
+ case BLUETOOTH_EVENT_ENABLED:
+ case BLUETOOTH_EVENT_DISABLED:
+ return BT_EVENT_STATE_CHANGED;
+ case BLUETOOTH_EVENT_LOCAL_NAME_CHANGED:
+ return BT_EVENT_NAME_CHANGED;
+ case BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED:
+ return BT_EVENT_VISIBILITY_MODE_CHANGED;
+ case BLUETOOTH_EVENT_DISCOVERY_STARTED:
+ case BLUETOOTH_EVENT_DISCOVERY_FINISHED:
+ case BLUETOOTH_EVENT_REMOTE_DEVICE_NAME_UPDATED:
+ return BT_EVENT_DEVICE_DISCOVERY_STATE_CHANGED;
+ case BLUETOOTH_EVENT_BONDING_FINISHED:
+ return BT_EVENT_BOND_CREATED;
+ case BLUETOOTH_EVENT_BONDED_DEVICE_REMOVED:
+ return BT_EVENT_BOND_DESTROYED;
+ case BLUETOOTH_EVENT_DEVICE_AUTHORIZED:
+ case BLUETOOTH_EVENT_DEVICE_UNAUTHORIZED:
+ return BT_EVENT_AUTHORIZATION_CHANGED;
+ case BLUETOOTH_EVENT_SERVICE_SEARCHED:
+ if( is_creating_bond == true )
+ return BT_EVENT_BOND_CREATED;
+ else
+ return BT_EVENT_SERVICE_SEARCHED;
+ case BLUETOOTH_EVENT_RFCOMM_DATA_RECEIVED:
+ return BT_EVENT_DATA_RECEIVED;
+ case BLUETOOTH_EVENT_RFCOMM_CONNECTED:
+ case BLUETOOTH_EVENT_RFCOMM_DISCONNECTED:
+ return BT_EVENT_CONNECTION_STATE_CHANGED;
+ default:
+ return -1;
+ }
+}
+
+int _bt_copy_service_list(bt_device_info_s* bonded_device_info, bt_device_sdp_info_s* sdp_info)
+{
+ int i = 0;
+
+ BT_CHECK_INPUT_PARAMETER(bonded_device_info);
+ BT_CHECK_INPUT_PARAMETER(sdp_info);
+
+ if(sdp_info->service_count > 0)
+ {
+ bonded_device_info->service_uuid = (char**)malloc(sizeof(char*) * sdp_info->service_count);
+ if( bonded_device_info->service_uuid == NULL )
+ {
+ return BT_ERROR_OUT_OF_MEMORY;
+ }
+
+ for(i=0; i<sdp_info->service_count; i++)
+ {
+ bonded_device_info->service_uuid[i] = strdup(sdp_info->service_uuid[i]);
+ }
+ }
+ else
+ {
+ bonded_device_info->service_uuid = NULL;
+ }
+ bonded_device_info->service_count = sdp_info->service_count;
+
+ return BT_ERROR_NONE;
+}
+
+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";
+ }
+}
+
+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]);
+ }
+ }
+}
--- /dev/null
+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()
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+#include <bluetooth.h>
+#include <dlog.h>
+#include <glib.h>
+#include <string.h>
+
+#ifdef LOG_TAG
+#undef LOG_TAG
+#endif
+#define LOG_TAG "BT_CHAT_CLIENT"
+
+/**
+ * Variables
+ **/
+static GMainLoop* g_mainloop = NULL;
+static bt_adapter_state_e bt_state = BT_ADAPTER_DISABLED;
+static int socket_fd = -1;
+static char* bt_address = NULL;
+static char* server_name = "chat_server";
+static char quit_command[5] = "Quit";
+static int bonding_state = BT_ERROR_OPERATION_FAILED;
+
+
+/**
+ * Callback functions
+ **/
+gboolean timeout_func(gpointer data)
+{
+ LOGE("[%s] Callback: Timeout.", __FUNCTION__);
+ g_main_loop_quit((GMainLoop*)data);
+ return FALSE;
+}
+
+void bt_state_changed_impl(int result, bt_adapter_state_e adapter_state, void* user_data)
+{
+ if(adapter_state == BT_ADAPTER_ENABLED)
+ {
+ if(result == BT_ERROR_NONE)
+ {
+ LOGI("[%s] Callback: BT was enabled successfully.", __FUNCTION__);
+ bt_state = BT_ADAPTER_ENABLED;
+ }
+ else
+ {
+ LOGE("[%s] Callback: Failed to enable BT.", __FUNCTION__);
+ }
+ }
+
+ if(g_mainloop)
+ {
+ g_main_loop_quit(g_mainloop);
+ }
+}
+
+void bt_socket_connection_state_changed_impl(int result, bt_socket_connection_state_e connection_state,
+ bt_socket_connection_s *connection, void *user_data)
+{
+ if(result == BT_ERROR_NONE)
+ {
+ LOGI("[%s] Callback: Result is BT_ERROR_NONE.", __FUNCTION__);
+ }
+ else
+ {
+ LOGI("[%s] Callback: Result is not BT_ERROR_NONE.", __FUNCTION__);
+ }
+
+ if(connection_state == BT_SOCKET_CONNECTED)
+ {
+ LOGI("[%s] Callback: Connected.", __FUNCTION__);
+ if(result == BT_ERROR_NONE && connection != NULL)
+ {
+ socket_fd = connection->socket_fd;
+ LOGI("[%s] Callback: Socket of connection - %d.", __FUNCTION__, socket_fd);
+ LOGI("[%s] Callback: Role of connection - %d.", __FUNCTION__, connection->local_role);
+ LOGI("[%s] Callback: Address of connection - %s.", __FUNCTION__, connection->remote_address);
+
+ if(bt_socket_send_data(socket_fd, quit_command, strlen(quit_command)) == BT_ERROR_NONE)
+ {
+ LOGI("[%s] Callback: Send quit command.", __FUNCTION__);
+ }
+ else
+ {
+ LOGE("[%s] Callback: bt_socket_send_data() failed.", __FUNCTION__);
+ if(g_mainloop)
+ {
+ g_main_loop_quit(g_mainloop);
+ }
+ }
+ }
+ else
+ {
+ LOGI("[%s] Callback: Failed to connect", __FUNCTION__);
+ if(g_mainloop)
+ {
+ g_main_loop_quit(g_mainloop);
+ }
+ }
+ }
+ else
+ {
+ LOGI("[%s] Callback: Disconnected.", __FUNCTION__);
+ }
+}
+
+void bt_socket_data_received_impl(bt_socket_received_data_s *data, void *user_data)
+{
+ if(socket_fd == data->socket_fd)
+ {
+ if(data->data_size > 0)
+ {
+ if(!strncmp(data->data, quit_command, data->data_size))
+ {
+ LOGI("[%s] Callback: Quit command.", __FUNCTION__);
+ if(g_mainloop)
+ {
+ g_main_loop_quit(g_mainloop);
+ }
+ }
+ }
+ else
+ {
+ LOGE("[%s] Callback: No data.", __FUNCTION__);
+ }
+ }
+ else
+ {
+ LOGI("[%s] Callback: Another socket - %d.", __FUNCTION__, data->socket_fd);
+ }
+}
+
+bool bt_adapter_bonded_device_impl(bt_device_info_s *device_info, void *user_data)
+{
+ int i = 0;
+ if(device_info != NULL)
+ {
+ if(device_info->remote_name != NULL && !strcmp(device_info->remote_name, (char*)user_data))
+ {
+ LOGI("[%s] Callback: chat_server is found in bonded list.", __FUNCTION__);
+ if( device_info->remote_address != NULL )
+ {
+ LOGI("[%s] Callback: Address of chat_server - %s.", __FUNCTION__, device_info->remote_address);
+ bt_address = strdup(device_info->remote_address);
+ LOGI("[%s] Callback: The number of service_count - %d.", __FUNCTION__, device_info->service_count);
+ if(device_info->service_count <= 0)
+ {
+ bonding_state = BT_ERROR_SERVICE_SEARCH_FAILED;
+ }
+ else
+ {
+ bonding_state = BT_ERROR_NONE;
+ for(i=0; i<device_info->service_count; i++)
+ {
+ LOGI("[%s] Callback: service[%d] - %s", __FUNCTION__, i+1, device_info->service_uuid[i]);
+ }
+ LOGI("[%s] Callback: is_bonded - %d.", __FUNCTION__, device_info->is_bonded);
+ LOGI("[%s] Callback: is_connected - %d.", __FUNCTION__, device_info->is_connected);
+ LOGI("[%s] Callback: is_authorized - %d.", __FUNCTION__, device_info->is_authorized);
+ }
+ }
+ else
+ {
+ LOGE("[%s] Callback: Address of chat_server is NULL.", __FUNCTION__);
+ }
+
+ return false;
+ }
+ }
+
+ return true;
+}
+
+void bt_adapter_device_discovery_state_changed_impl(int result, bt_adapter_device_discovery_state_e discovery_state,
+ bt_adapter_device_discovery_info_s *discovery_info, void *user_data)
+{
+ if(discovery_state == BT_ADAPTER_DEVICE_DISCOVERY_FOUND)
+ {
+ if(discovery_info->remote_address != NULL && !strcmp(discovery_info->remote_name, server_name))
+ {
+ LOGI("[%s] Callback: chat_server is found.", __FUNCTION__);
+ LOGI("[%s] Callback: Address of chat_server - %s.", __FUNCTION__, discovery_info->remote_address);
+ LOGI("[%s] Callback: Device major class - %d.", __FUNCTION__, discovery_info->bt_class.major_device_class);
+ LOGI("[%s] Callback: Device minor class - %d.", __FUNCTION__, discovery_info->bt_class.minor_device_class);
+ LOGI("[%s] Callback: Service major class - %d.", __FUNCTION__, discovery_info->bt_class.major_service_class_mask);
+ bt_address = strdup(discovery_info->remote_address);
+ LOGI("[%s] Callback: is_bonded - %d.", __FUNCTION__, discovery_info->is_bonded);
+ bt_adapter_stop_device_discovery();
+ }
+ else
+ {
+ LOGE("[%s] Callback: Another device is found.", __FUNCTION__);
+ }
+ }
+ else if(discovery_state == BT_ADAPTER_DEVICE_DISCOVERY_FINISHED)
+ {
+ LOGI("[%s] Callback: device discovery finished.", __FUNCTION__);
+ if(g_mainloop)
+ {
+ g_main_loop_quit(g_mainloop);
+ }
+ }
+}
+
+void bt_device_bond_created_impl(int result, bt_device_info_s *device_info, void *user_data)
+{
+ if(device_info != NULL && !strcmp(device_info->remote_address, bt_address))
+ {
+ bonding_state = result;
+ if(result == BT_ERROR_NONE)
+ {
+ LOGI("[%s] Callback: A bond with chat_server is created.", __FUNCTION__);
+ LOGI("[%s] Callback: The number of service - %d.", __FUNCTION__, device_info->service_count);
+
+ int i = 0;
+ for(i=0; i<device_info->service_count; i++)
+ {
+ LOGI("[%s] Callback: service[%d] - %s", __FUNCTION__, i+1, device_info->service_uuid[i]);
+ }
+ LOGI("[%s] Callback: is_bonded - %d.", __FUNCTION__, device_info->is_bonded);
+ LOGI("[%s] Callback: is_connected - %d.", __FUNCTION__, device_info->is_connected);
+ }
+ else
+ {
+ LOGE("[%s] Callback: Creating a bond is failed.", __FUNCTION__);
+ }
+ }
+ else
+ {
+ LOGE("[%s] Callback: A bond with another device is created.", __FUNCTION__);
+ }
+
+ if(g_mainloop)
+ {
+ g_main_loop_quit(g_mainloop);
+ }
+}
+
+void bt_device_service_searched_impl(int result, bt_device_sdp_info_s* sdp_info, void* user_data)
+{
+ if(sdp_info != NULL && !strcmp(sdp_info->remote_address, bt_address))
+ {
+ bonding_state = result;
+ if(result == BT_ERROR_NONE)
+ {
+ LOGI("[%s] Callback: Services of chat_service are found.", __FUNCTION__);
+ LOGI("[%s] Callback: The number of service - %d.", __FUNCTION__, sdp_info->service_count);
+
+ int i = 0;
+ for(i = 0; i < sdp_info->service_count; i++)
+ {
+ LOGI("[%s] Callback: service[%d] - %s", __FUNCTION__, i+1, sdp_info->service_uuid[i]);
+ }
+ }
+ }
+ else
+ {
+ LOGE("[%s] Callback: Services of another device are found.", __FUNCTION__);
+ }
+
+ if(g_mainloop)
+ {
+ g_main_loop_quit(g_mainloop);
+ }
+}
+
+
+
+
+int main()
+{
+ g_mainloop = g_main_loop_new(NULL, FALSE);
+ const char* my_uuid="11011101-0000-1000-8000-00805F9B34FB";
+ int timeout_id = -1;
+
+ LOGI("[%s] Client starts.", __FUNCTION__);
+
+ if(bt_initialize() != BT_ERROR_NONE)
+ {
+ LOGE("[%s] bt_initialize() failed.", __FUNCTION__);
+ return -1;
+ }
+
+ if(bt_adapter_get_state(&bt_state) != BT_ERROR_NONE)
+ {
+ LOGE("[%s] bt_adapter_get_state() failed.", __FUNCTION__);
+ return -1;
+ }
+
+ // Enable BT
+ if(bt_state == BT_ADAPTER_DISABLED)
+ {
+ if(bt_adapter_set_state_changed_cb(bt_state_changed_impl, NULL) != BT_ERROR_NONE)
+ {
+ LOGE("[%s] bt_adapter_set_state_changed_cb() failed.", __FUNCTION__);
+ return -1;
+ }
+
+ if(bt_adapter_enable() == BT_ERROR_NONE)
+ {
+ LOGI("[%s] bt_adapter_state_changed_cb will be called.", __FUNCTION__);
+ timeout_id = g_timeout_add (60000, timeout_func, g_mainloop);
+ g_main_loop_run(g_mainloop);
+ g_source_remove(timeout_id);
+ }
+ else
+ {
+ LOGE("[%s] bt_adapter_enable() failed.", __FUNCTION__);
+ return -1;
+ }
+ }
+ else
+ {
+ LOGI("[%s] BT was already enabled.", __FUNCTION__);
+ }
+
+ // Device discovery
+ if(bt_state == BT_ADAPTER_ENABLED)
+ {
+ if(bt_adapter_foreach_bonded_device(bt_adapter_bonded_device_impl, server_name) != BT_ERROR_NONE)
+ {
+ LOGE("[%s] bt_adapter_foreach_bonded_device() failed.", __FUNCTION__);
+ return -1;
+ }
+
+ if(bt_address == NULL)
+ {
+ if(bt_adapter_set_device_discovery_state_changed_cb(bt_adapter_device_discovery_state_changed_impl, NULL)
+ != BT_ERROR_NONE )
+ {
+ LOGE("[%s] bt_adapter_set_device_discovery_state_changed_cb() failed.", __FUNCTION__);
+ return -1;
+ }
+
+ if(bt_adapter_start_device_discovery() == BT_ERROR_NONE)
+ {
+ LOGI("[%s] bt_adapter_device_discovery_state_changed_cb will be called.", __FUNCTION__);
+ g_main_loop_run(g_mainloop);
+ }
+ else
+ {
+ LOGE("[%s] bt_adapter_start_device_discovery() failed.", __FUNCTION__);
+ return -1;
+ }
+ }
+ else
+ {
+ LOGI("[%s] chat_server is found in bonded device list.", __FUNCTION__);
+ }
+ }
+ else
+ {
+ LOGE("[%s] BT is not enabled.", __FUNCTION__);
+ return -1;
+ }
+
+ // Create bond with a server
+ if(bonding_state == BT_ERROR_SERVICE_SEARCH_FAILED)
+ {
+ if(bt_device_set_service_searched_cb(bt_device_service_searched_impl, NULL) != BT_ERROR_NONE)
+ {
+ LOGE("[%s] bt_device_set_service_searched_cb() failed.", __FUNCTION__);
+ return -1;
+ }
+
+ if(bt_device_start_service_search(bt_address) == BT_ERROR_NONE)
+ {
+ LOGI("[%s] bt_device_service_searched_cb will be called.", __FUNCTION__);
+ g_main_loop_run(g_mainloop);
+ }
+ else
+ {
+ LOGE("[%s] bt_device_start_service_search() failed.", __FUNCTION__);
+ return -1;
+ }
+ }
+ else if(bonding_state != BT_ERROR_NONE)
+ {
+ if(bt_device_set_bond_created_cb(bt_device_bond_created_impl, NULL) != BT_ERROR_NONE)
+ {
+ LOGE("[%s] bt_device_set_bond_created_cb() failed.", __FUNCTION__);
+ return -1;
+ }
+
+ if(bt_device_create_bond(bt_address) == BT_ERROR_NONE)
+ {
+ LOGI("[%s] bt_device_bond_created_cb will be called.", __FUNCTION__);
+ g_main_loop_run(g_mainloop);
+ }
+ else
+ {
+ LOGE("[%s] bt_device_create_bond() failed.", __FUNCTION__);
+ return -1;
+ }
+ }
+
+ // Connecting socket as a client
+ if( bonding_state == BT_ERROR_NONE )
+ {
+ if( bt_socket_set_connection_state_changed_cb(bt_socket_connection_state_changed_impl, NULL) != BT_ERROR_NONE )
+ {
+ LOGE("[%s] bt_socket_set_connection_state_changed_cb() failed.", __FUNCTION__);
+ return -1;
+ }
+
+ if( bt_socket_set_data_received_cb(bt_socket_data_received_impl, NULL) != BT_ERROR_NONE )
+ {
+ LOGE("[%s] bt_socket_set_data_received_cb() failed.", __FUNCTION__);
+ return -1;
+ }
+
+ if( bt_socket_connect_rfcomm(bt_address, my_uuid) == BT_ERROR_NONE )
+ {
+ LOGI("[%s] bt_socket_connection_state_changed_cb will be called.", __FUNCTION__);
+ g_main_loop_run(g_mainloop);
+ }
+ else
+ {
+ LOGE("[%s] bt_socket_connect_rfcomm() failed.", __FUNCTION__);
+ return -1;
+ }
+
+ if( bt_socket_disconnect_rfcomm(socket_fd) != BT_ERROR_NONE )
+ {
+ LOGE("[%s] bt_socket_disconnect_rfcomm() failed.", __FUNCTION__);
+ return -1;
+ }
+ }
+ else
+ {
+ LOGE("[%s] Bond is not created.", __FUNCTION__);
+ return -1;
+ }
+
+ bt_deinitialize();
+
+ LOGI("[%s] Client ends.", __FUNCTION__);
+ return 0;
+}
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+#include <bluetooth.h>
+#include <dlog.h>
+#include <glib.h>
+#include <string.h>
+
+#ifdef LOG_TAG
+#undef LOG_TAG
+#endif
+#define LOG_TAG "BT_CHAT_SERVER"
+
+/**
+ * Variables
+ **/
+static GMainLoop* g_mainloop = NULL;
+static bt_adapter_visibility_mode_e visibility_mode = BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE;
+static bt_adapter_state_e bt_state = BT_ADAPTER_DISABLED;
+static int service_socket = -1;
+static int connected_socket = -1;
+static char* quit_command = "Quit";
+
+
+/**
+ * Callback functions
+ **/
+gboolean timeout_func(gpointer data)
+{
+ LOGE("[%s] Timeout.", __FUNCTION__);
+ if(g_mainloop)
+ {
+ g_main_loop_quit((GMainLoop*)data);
+ }
+
+ return FALSE;
+}
+
+void bt_state_changed_impl(int result, bt_adapter_state_e adapter_state, void* user_data)
+{
+ if( adapter_state == BT_ADAPTER_ENABLED )
+ {
+ if( result == BT_ERROR_NONE )
+ {
+ LOGI("[%s] Callback: BT was enabled successfully.", __FUNCTION__);
+ bt_state = BT_ADAPTER_ENABLED;
+ }
+ else
+ {
+ LOGE("[%s] Callback: Failed to enable BT.", __FUNCTION__);
+ }
+ }
+
+ if(g_mainloop)
+ {
+ g_main_loop_quit(g_mainloop);
+ }
+}
+
+void bt_socket_connection_state_changed_impl(int result, bt_socket_connection_state_e connection_state,
+ bt_socket_connection_s *connection, void *user_data)
+{
+ if( result == BT_ERROR_NONE )
+ {
+ LOGI("[%s] Callback: Result is BT_ERROR_NONE.", __FUNCTION__);
+ }
+ else
+ {
+ LOGI("[%s] Callback: Result is not BT_ERROR_NONE.", __FUNCTION__);
+ }
+
+ if( connection_state == BT_SOCKET_CONNECTED )
+ {
+ LOGI("[%s] Callback: Connected.", __FUNCTION__);
+ if( connection != NULL )
+ {
+ connected_socket = connection->socket_fd;
+ LOGI("[%s] Callback: Socket of connection - %d.", __FUNCTION__, connected_socket);
+ LOGI("[%s] Callback: Role of connection - %d.", __FUNCTION__, connection->local_role);
+ LOGI("[%s] Callback: Address of connection - %s.", __FUNCTION__, connection->remote_address);
+
+ }
+ else
+ {
+ LOGI("[%s] Callback: No connection data", __FUNCTION__);
+ }
+ }
+ else
+ {
+ LOGI("[%s] Callback: Disconnected.", __FUNCTION__);
+ LOGI("[%s] Callback: Socket of connection - %d.", __FUNCTION__, connected_socket);
+ LOGI("[%s] Callback: Role of connection - %d.", __FUNCTION__, connection->local_role);
+ LOGI("[%s] Callback: Address of connection - %s.", __FUNCTION__, connection->remote_address);
+ }
+}
+
+void bt_socket_data_received_impl(bt_socket_received_data_s *data, void *user_data)
+{
+ if( data->data_size > 0 )
+ {
+ if( !strncmp(data->data, quit_command, data->data_size) )
+ {
+ LOGI("[%s] Callback: Quit command.", __FUNCTION__);
+ if(g_mainloop)
+ {
+ g_main_loop_quit(g_mainloop);
+ }
+ }
+
+ if( bt_socket_send_data(connected_socket, quit_command, strlen(quit_command)) == BT_ERROR_NONE )
+ {
+ LOGI("[%s] Callback: Send quit command.", __FUNCTION__);
+ }
+ else
+ {
+ LOGE("[%s] Callback: bt_socket_send_data() failed.", __FUNCTION__);
+ }
+ }
+ else
+ {
+ LOGE("[%s] Callback: No data.", __FUNCTION__);
+ }
+}
+
+
+int main()
+{
+ g_mainloop = g_main_loop_new(NULL, FALSE);
+ const char* my_uuid="11011101-0000-1000-8000-00805F9B34FB";
+ int timeout_id = -1;
+
+ LOGI("[%s] Server starts.", __FUNCTION__);
+
+ if(bt_initialize() != BT_ERROR_NONE)
+ {
+ LOGE("[%s] bt_initialize() failed.", __FUNCTION__);
+ return -1;
+ }
+
+ if(bt_adapter_get_state(&bt_state) != BT_ERROR_NONE)
+ {
+ LOGE("[%s] bt_adapter_get_state() failed.", __FUNCTION__);
+ return -1;
+ }
+
+ // Enable BT
+ if(bt_state == BT_ADAPTER_DISABLED)
+ {
+ if(bt_adapter_set_state_changed_cb(bt_state_changed_impl, NULL) != BT_ERROR_NONE)
+ {
+ LOGE("[%s] bt_adapter_set_state_changed_cb() failed.", __FUNCTION__);
+ return -1;
+ }
+
+ if(bt_adapter_enable() == BT_ERROR_NONE)
+ {
+ LOGI("[%s] bt_adapter_state_changed_cb will be called.", __FUNCTION__);
+ timeout_id = g_timeout_add (60000, timeout_func, g_mainloop);
+ g_main_loop_run(g_mainloop);
+ g_source_remove(timeout_id);
+ }
+ else
+ {
+ LOGE("[%s] bt_adapter_enable() failed.", __FUNCTION__);
+ return -1;
+ }
+ }
+ else
+ {
+ LOGI("[%s] BT was already enabled.", __FUNCTION__);
+ }
+
+ // Set name as "chat_server"
+ if(bt_state == BT_ADAPTER_ENABLED)
+ {
+ char* name = NULL;
+ if(bt_adapter_get_name(&name) != BT_ERROR_NONE)
+ {
+ LOGE("[%s] bt_adapter_get_name() failed.", __FUNCTION__);
+ return -1;
+ }
+
+ if(strncmp(name, "chat_server", strlen(name)) != 0)
+ {
+ free(name);
+ if(bt_adapter_set_name("chat_server") != BT_ERROR_NONE)
+ {
+ LOGE("[%s] bt_adapter_set_name() failed.", __FUNCTION__);
+ return -1;
+ }
+ }
+ }
+ else
+ {
+ LOGE("[%s] BT is not enabled.", __FUNCTION__);
+ return -1;
+ }
+
+ // Set visibility as BT_ADAPTER_VISIBILITY_MODE_GENERAL_DISCOVERABLE
+ if(bt_adapter_get_visibility(&visibility_mode) != BT_ERROR_NONE)
+ {
+ LOGE("[%s] bt_adapter_get_visibility() failed.", __FUNCTION__);
+ return -1;
+ }
+
+ if(visibility_mode != BT_ADAPTER_VISIBILITY_MODE_GENERAL_DISCOVERABLE)
+ {
+ if(bt_adapter_set_visibility(BT_ADAPTER_VISIBILITY_MODE_GENERAL_DISCOVERABLE, 0) != BT_ERROR_NONE)
+ {
+ LOGE("[%s] bt_adapter_set_visibility() failed.", __FUNCTION__);
+ return -1;
+ }
+ visibility_mode = BT_ADAPTER_VISIBILITY_MODE_GENERAL_DISCOVERABLE;
+ }
+ else
+ {
+ LOGI("[%s] Visibility mode was already set as BT_ADAPTER_VISIBILITY_MODE_GENERAL_DISCOVERABLE.", __FUNCTION__);
+ }
+
+ // Connecting socket as a server
+ if(bt_socket_create_rfcomm(my_uuid, &service_socket) != BT_ERROR_NONE)
+ {
+ LOGE("[%s] bt_socket_create_rfcomm() failed.", __FUNCTION__);
+ return -1;
+ }
+ LOGI("[%s] socket is created - %d.", __FUNCTION__, service_socket);
+
+ if(bt_socket_set_connection_state_changed_cb(bt_socket_connection_state_changed_impl, NULL) != BT_ERROR_NONE)
+ {
+ LOGE("[%s] bt_socket_set_connection_state_changed_cb() failed.", __FUNCTION__);
+ return -1;
+ }
+
+ if(bt_socket_set_data_received_cb(bt_socket_data_received_impl, NULL) != BT_ERROR_NONE)
+ {
+ LOGE("[%s] bt_socket_set_data_received_cb() failed.", __FUNCTION__);
+ return -1;
+ }
+
+ if(bt_socket_listen_and_accept_rfcomm(service_socket, 5) == BT_ERROR_NONE)
+ {
+ LOGI("[%s] bt_socket_connection_state_changed_cb will be called.", __FUNCTION__);
+ g_main_loop_run(g_mainloop);
+ }
+ else
+ {
+ LOGE("[%s] bt_socket_listen_and_accept_rfcomm() failed.", __FUNCTION__);
+ return -1;
+ }
+
+ sleep(5); // Wait for completing delivery
+ if(bt_socket_destroy_rfcomm(service_socket) != BT_ERROR_NONE)
+ {
+ LOGE("[%s] bt_socket_destroy_rfcomm() failed.", __FUNCTION__);
+ return -1;
+ }
+ else
+ {
+ LOGE("[%s] bt_socket_destroy_rfcomm() succeeded.", __FUNCTION__);
+ }
+
+ bt_deinitialize();
+
+ LOGI("[%s] Server ends.", __FUNCTION__);
+ return 0;
+}
projects / framework / api / bluetooth.git / commitdiff