From 7c3c71cee13f1a58e5242fe9d6d2d4be65559646 Mon Sep 17 00:00:00 2001 From: Kibum Kim Date: Sat, 7 Jan 2012 00:42:16 +0900 Subject: [PATCH] Git init --- AUTHORS | 2 + CMakeLists.txt | 90 ++ LICENSE | 204 ++++ capi-network-bluetooth.pc.in | 15 + debian/README | 0 debian/capi-network-bluetooth-dev.install | 4 + debian/capi-network-bluetooth-dev.postinst | 1 + debian/capi-network-bluetooth.install | 1 + debian/capi-network-bluetooth.postinst | 1 + debian/changelog | 15 + debian/compat | 1 + debian/control | 21 + debian/rules | 65 ++ include/bluetooth.h | 1560 ++++++++++++++++++++++++++++ include/bluetooth_private.h | 166 +++ packaging/capi-network-bluetooth.spec | 53 + src/bluetooth.c | 1471 ++++++++++++++++++++++++++ test/CMakeLists.txt | 17 + test/bt_chat_client.c | 453 ++++++++ test/bt_chat_server.c | 280 +++++ 20 files changed, 4420 insertions(+) create mode 100644 AUTHORS create mode 100644 CMakeLists.txt create mode 100644 LICENSE create mode 100644 capi-network-bluetooth.pc.in create mode 100644 debian/README create mode 100644 debian/capi-network-bluetooth-dev.install create mode 100644 debian/capi-network-bluetooth-dev.postinst create mode 100644 debian/capi-network-bluetooth.install create mode 100644 debian/capi-network-bluetooth.postinst create mode 100644 debian/changelog create mode 100644 debian/compat create mode 100644 debian/control create mode 100755 debian/rules create mode 100644 include/bluetooth.h create mode 100644 include/bluetooth_private.h create mode 100644 packaging/capi-network-bluetooth.spec create mode 100644 src/bluetooth.c create mode 100644 test/CMakeLists.txt create mode 100644 test/bt_chat_client.c create mode 100644 test/bt_chat_server.c diff --git a/AUTHORS b/AUTHORS new file mode 100644 index 0000000..5ecc5e2 --- /dev/null +++ b/AUTHORS @@ -0,0 +1,2 @@ +ByungWoo Lee +Kangho Hur diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..0b34ac4 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,90 @@ + +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) + diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..9c13a9b --- /dev/null +++ b/LICENSE @@ -0,0 +1,204 @@ +Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. + diff --git a/capi-network-bluetooth.pc.in b/capi-network-bluetooth.pc.in new file mode 100644 index 0000000..fd41dbb --- /dev/null +++ b/capi-network-bluetooth.pc.in @@ -0,0 +1,15 @@ + +# 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@ + diff --git a/debian/README b/debian/README new file mode 100644 index 0000000..e69de29 diff --git a/debian/capi-network-bluetooth-dev.install b/debian/capi-network-bluetooth-dev.install new file mode 100644 index 0000000..761a28b --- /dev/null +++ b/debian/capi-network-bluetooth-dev.install @@ -0,0 +1,4 @@ +/usr/include/* +/usr/include/*/* +/usr/lib/pkgconfig/*.pc + diff --git a/debian/capi-network-bluetooth-dev.postinst b/debian/capi-network-bluetooth-dev.postinst new file mode 100644 index 0000000..1a24852 --- /dev/null +++ b/debian/capi-network-bluetooth-dev.postinst @@ -0,0 +1 @@ +#!/bin/sh diff --git a/debian/capi-network-bluetooth.install b/debian/capi-network-bluetooth.install new file mode 100644 index 0000000..4a755a4 --- /dev/null +++ b/debian/capi-network-bluetooth.install @@ -0,0 +1 @@ +/usr/lib/lib*.so* diff --git a/debian/capi-network-bluetooth.postinst b/debian/capi-network-bluetooth.postinst new file mode 100644 index 0000000..1a24852 --- /dev/null +++ b/debian/capi-network-bluetooth.postinst @@ -0,0 +1 @@ +#!/bin/sh diff --git a/debian/changelog b/debian/changelog new file mode 100644 index 0000000..65d7b52 --- /dev/null +++ b/debian/changelog @@ -0,0 +1,15 @@ +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 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 Wed, 07 Dec 2011 12:48:41 +0900 diff --git a/debian/compat b/debian/compat new file mode 100644 index 0000000..7ed6ff8 --- /dev/null +++ b/debian/compat @@ -0,0 +1 @@ +5 diff --git a/debian/control b/debian/control new file mode 100644 index 0000000..3cffddf --- /dev/null +++ b/debian/control @@ -0,0 +1,21 @@ +Source: capi-network-bluetooth +Section: libs +Priority: extra +Maintainer: Kangho Hur , ByungWoo Lee +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) + diff --git a/debian/rules b/debian/rules new file mode 100755 index 0000000..4a0f519 --- /dev/null +++ b/debian/rules @@ -0,0 +1,65 @@ +#!/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 + diff --git a/include/bluetooth.h b/include/bluetooth.h new file mode 100644 index 0000000..3950e99 --- /dev/null +++ b/include/bluetooth.h @@ -0,0 +1,1560 @@ +/* + * 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 +#include +#include +#include + +#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__ diff --git a/include/bluetooth_private.h b/include/bluetooth_private.h new file mode 100644 index 0000000..f7dfa78 --- /dev/null +++ b/include/bluetooth_private.h @@ -0,0 +1,166 @@ +/* + * 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__ */ diff --git a/packaging/capi-network-bluetooth.spec b/packaging/capi-network-bluetooth.spec new file mode 100644 index 0000000..b99a09a --- /dev/null +++ b/packaging/capi-network-bluetooth.spec @@ -0,0 +1,53 @@ +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 diff --git a/src/bluetooth.c b/src/bluetooth.c new file mode 100644 index 0000000..dc14da5 --- /dev/null +++ b/src/bluetooth.c @@ -0,0 +1,1471 @@ +/* + * 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#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; ilen; 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; iservice_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; iservice_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; iaddr[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; iservice_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; iservice_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; iservice_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 +#include +#include +#include + +#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; iservice_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; iservice_count; i++) + { + LOGI("[%s] Callback: service[%d] - %s", __FUNCTION__, i+1, device_info->service_uuid[i]); + } + LOGI("[%s] Callback: is_bonded - %d.", __FUNCTION__, device_info->is_bonded); + LOGI("[%s] Callback: is_connected - %d.", __FUNCTION__, device_info->is_connected); + } + else + { + LOGE("[%s] Callback: Creating a bond is failed.", __FUNCTION__); + } + } + else + { + LOGE("[%s] Callback: A bond with another device is created.", __FUNCTION__); + } + + if(g_mainloop) + { + g_main_loop_quit(g_mainloop); + } +} + +void bt_device_service_searched_impl(int result, bt_device_sdp_info_s* sdp_info, void* user_data) +{ + if(sdp_info != NULL && !strcmp(sdp_info->remote_address, bt_address)) + { + bonding_state = result; + if(result == BT_ERROR_NONE) + { + LOGI("[%s] Callback: Services of chat_service are found.", __FUNCTION__); + LOGI("[%s] Callback: The number of service - %d.", __FUNCTION__, sdp_info->service_count); + + int i = 0; + for(i = 0; i < sdp_info->service_count; i++) + { + LOGI("[%s] Callback: service[%d] - %s", __FUNCTION__, i+1, sdp_info->service_uuid[i]); + } + } + } + else + { + LOGE("[%s] Callback: Services of another device are found.", __FUNCTION__); + } + + if(g_mainloop) + { + g_main_loop_quit(g_mainloop); + } +} + + + + +int main() +{ + g_mainloop = g_main_loop_new(NULL, FALSE); + const char* my_uuid="11011101-0000-1000-8000-00805F9B34FB"; + int timeout_id = -1; + + LOGI("[%s] Client starts.", __FUNCTION__); + + if(bt_initialize() != BT_ERROR_NONE) + { + LOGE("[%s] bt_initialize() failed.", __FUNCTION__); + return -1; + } + + if(bt_adapter_get_state(&bt_state) != BT_ERROR_NONE) + { + LOGE("[%s] bt_adapter_get_state() failed.", __FUNCTION__); + return -1; + } + + // Enable BT + if(bt_state == BT_ADAPTER_DISABLED) + { + if(bt_adapter_set_state_changed_cb(bt_state_changed_impl, NULL) != BT_ERROR_NONE) + { + LOGE("[%s] bt_adapter_set_state_changed_cb() failed.", __FUNCTION__); + return -1; + } + + if(bt_adapter_enable() == BT_ERROR_NONE) + { + LOGI("[%s] bt_adapter_state_changed_cb will be called.", __FUNCTION__); + timeout_id = g_timeout_add (60000, timeout_func, g_mainloop); + g_main_loop_run(g_mainloop); + g_source_remove(timeout_id); + } + else + { + LOGE("[%s] bt_adapter_enable() failed.", __FUNCTION__); + return -1; + } + } + else + { + LOGI("[%s] BT was already enabled.", __FUNCTION__); + } + + // Device discovery + if(bt_state == BT_ADAPTER_ENABLED) + { + if(bt_adapter_foreach_bonded_device(bt_adapter_bonded_device_impl, server_name) != BT_ERROR_NONE) + { + LOGE("[%s] bt_adapter_foreach_bonded_device() failed.", __FUNCTION__); + return -1; + } + + if(bt_address == NULL) + { + if(bt_adapter_set_device_discovery_state_changed_cb(bt_adapter_device_discovery_state_changed_impl, NULL) + != BT_ERROR_NONE ) + { + LOGE("[%s] bt_adapter_set_device_discovery_state_changed_cb() failed.", __FUNCTION__); + return -1; + } + + if(bt_adapter_start_device_discovery() == BT_ERROR_NONE) + { + LOGI("[%s] bt_adapter_device_discovery_state_changed_cb will be called.", __FUNCTION__); + g_main_loop_run(g_mainloop); + } + else + { + LOGE("[%s] bt_adapter_start_device_discovery() failed.", __FUNCTION__); + return -1; + } + } + else + { + LOGI("[%s] chat_server is found in bonded device list.", __FUNCTION__); + } + } + else + { + LOGE("[%s] BT is not enabled.", __FUNCTION__); + return -1; + } + + // Create bond with a server + if(bonding_state == BT_ERROR_SERVICE_SEARCH_FAILED) + { + if(bt_device_set_service_searched_cb(bt_device_service_searched_impl, NULL) != BT_ERROR_NONE) + { + LOGE("[%s] bt_device_set_service_searched_cb() failed.", __FUNCTION__); + return -1; + } + + if(bt_device_start_service_search(bt_address) == BT_ERROR_NONE) + { + LOGI("[%s] bt_device_service_searched_cb will be called.", __FUNCTION__); + g_main_loop_run(g_mainloop); + } + else + { + LOGE("[%s] bt_device_start_service_search() failed.", __FUNCTION__); + return -1; + } + } + else if(bonding_state != BT_ERROR_NONE) + { + if(bt_device_set_bond_created_cb(bt_device_bond_created_impl, NULL) != BT_ERROR_NONE) + { + LOGE("[%s] bt_device_set_bond_created_cb() failed.", __FUNCTION__); + return -1; + } + + if(bt_device_create_bond(bt_address) == BT_ERROR_NONE) + { + LOGI("[%s] bt_device_bond_created_cb will be called.", __FUNCTION__); + g_main_loop_run(g_mainloop); + } + else + { + LOGE("[%s] bt_device_create_bond() failed.", __FUNCTION__); + return -1; + } + } + + // Connecting socket as a client + if( bonding_state == BT_ERROR_NONE ) + { + if( bt_socket_set_connection_state_changed_cb(bt_socket_connection_state_changed_impl, NULL) != BT_ERROR_NONE ) + { + LOGE("[%s] bt_socket_set_connection_state_changed_cb() failed.", __FUNCTION__); + return -1; + } + + if( bt_socket_set_data_received_cb(bt_socket_data_received_impl, NULL) != BT_ERROR_NONE ) + { + LOGE("[%s] bt_socket_set_data_received_cb() failed.", __FUNCTION__); + return -1; + } + + if( bt_socket_connect_rfcomm(bt_address, my_uuid) == BT_ERROR_NONE ) + { + LOGI("[%s] bt_socket_connection_state_changed_cb will be called.", __FUNCTION__); + g_main_loop_run(g_mainloop); + } + else + { + LOGE("[%s] bt_socket_connect_rfcomm() failed.", __FUNCTION__); + return -1; + } + + if( bt_socket_disconnect_rfcomm(socket_fd) != BT_ERROR_NONE ) + { + LOGE("[%s] bt_socket_disconnect_rfcomm() failed.", __FUNCTION__); + return -1; + } + } + else + { + LOGE("[%s] Bond is not created.", __FUNCTION__); + return -1; + } + + bt_deinitialize(); + + LOGI("[%s] Client ends.", __FUNCTION__); + return 0; +} diff --git a/test/bt_chat_server.c b/test/bt_chat_server.c new file mode 100644 index 0000000..44edd83 --- /dev/null +++ b/test/bt_chat_server.c @@ -0,0 +1,280 @@ +/* + * 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 +#include +#include +#include + +#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; +} -- 2.7.4