From 0b0f195fbc4015a323b3eb1e896c77ca663943b2 Mon Sep 17 00:00:00 2001 From: HyungKyu Song Date: Fri, 15 Feb 2013 15:09:14 +0900 Subject: [PATCH] Tizen 2.0 Release --- CMakeLists.txt | 117 ++ LICENSE.APLv2.0 | 202 +++ NOTICE | 5 + inc/FNetBluetooth.h | 67 + inc/FNetBtBluetoothDevice.h | 269 +++ inc/FNetBtBluetoothHealth.h | 226 +++ inc/FNetBtBluetoothManager.h | 594 +++++++ inc/FNetBtBluetoothOppClient.h | 179 ++ inc/FNetBtBluetoothOppServer.h | 257 +++ inc/FNetBtBluetoothSppAcceptor.h | 257 +++ inc/FNetBtBluetoothSppInitiator.h | 214 +++ inc/FNetBtBluetoothTypes.h | 630 +++++++ inc/FNetBtIBluetoothDeviceEventListener.h | 206 +++ inc/FNetBtIBluetoothHealthEventListener.h | 139 ++ inc/FNetBtIBluetoothManagerEventListener.h | 119 ++ inc/FNetBtIBluetoothOppClientEventListener.h | 115 ++ inc/FNetBtIBluetoothOppServerEventListener.h | 108 ++ inc/FNetBtIBluetoothSppAcceptorEventListener.h | 105 ++ inc/FNetBtIBluetoothSppInitiatorEventListener.h | 96 + osp-bluetooth.manifest | 5 + osp-bluetooth.pc.in | 14 + packaging/osp-bluetooth.spec | 91 + src/FNetBtBluetoothDevice.cpp | 469 +++++ src/FNetBtBluetoothHealth.cpp | 151 ++ src/FNetBtBluetoothManager.cpp | 371 ++++ src/FNetBtBluetoothOppClient.cpp | 111 ++ src/FNetBtBluetoothOppServer.cpp | 168 ++ src/FNetBtBluetoothSppAcceptor.cpp | 168 ++ src/FNetBtBluetoothSppInitiator.cpp | 125 ++ src/FNetBt_BluetoothAdapterUtility.cpp | 911 ++++++++++ src/FNetBt_BluetoothConnectionEvent.cpp | 78 + src/FNetBt_BluetoothConnectionEvent.h | 84 + src/FNetBt_BluetoothConnectionEventArg.cpp | 59 + src/FNetBt_BluetoothConnectionEventArg.h | 101 ++ src/FNetBt_BluetoothDeviceEvent.cpp | 124 ++ src/FNetBt_BluetoothDeviceEvent.h | 84 + src/FNetBt_BluetoothDeviceEventArg.cpp | 136 ++ src/FNetBt_BluetoothDeviceEventArg.h | 170 ++ src/FNetBt_BluetoothDeviceImpl.cpp | 345 ++++ src/FNetBt_BluetoothGapSystemAdapter.cpp | 973 +++++++++++ src/FNetBt_BluetoothGapSystemAdapter.h | 323 ++++ src/FNetBt_BluetoothHdpSystemAdapter.cpp | 439 +++++ src/FNetBt_BluetoothHdpSystemAdapter.h | 164 ++ src/FNetBt_BluetoothHealthEvent.cpp | 97 ++ src/FNetBt_BluetoothHealthEvent.h | 85 + src/FNetBt_BluetoothHealthEventArg.cpp | 133 ++ src/FNetBt_BluetoothHealthEventArg.h | 175 ++ src/FNetBt_BluetoothHealthImpl.cpp | 697 ++++++++ src/FNetBt_BluetoothIpcMessages.cpp | 44 + src/FNetBt_BluetoothIpcProxy.cpp | 158 ++ src/FNetBt_BluetoothIpcProxy.h | 77 + src/FNetBt_BluetoothManagerEvent.cpp | 78 + src/FNetBt_BluetoothManagerEvent.h | 83 + src/FNetBt_BluetoothManagerEventArg.cpp | 64 + src/FNetBt_BluetoothManagerEventArg.h | 114 ++ src/FNetBt_BluetoothManagerImpl.cpp | 1841 ++++++++++++++++++++ src/FNetBt_BluetoothOppClientEvent.cpp | 81 + src/FNetBt_BluetoothOppClientEvent.h | 81 + src/FNetBt_BluetoothOppClientEventArg.cpp | 110 ++ src/FNetBt_BluetoothOppClientEventArg.h | 153 ++ src/FNetBt_BluetoothOppClientImpl.cpp | 583 +++++++ src/FNetBt_BluetoothOppServerEvent.cpp | 87 + src/FNetBt_BluetoothOppServerEvent.h | 78 + src/FNetBt_BluetoothOppServerEventArg.cpp | 113 ++ src/FNetBt_BluetoothOppServerEventArg.h | 151 ++ src/FNetBt_BluetoothOppServerImpl.cpp | 663 +++++++ src/FNetBt_BluetoothOppSystemAdapter.cpp | 380 ++++ src/FNetBt_BluetoothOppSystemAdapter.h | 209 +++ src/FNetBt_BluetoothSppAcceptorEvent.cpp | 93 + src/FNetBt_BluetoothSppAcceptorEvent.h | 78 + src/FNetBt_BluetoothSppAcceptorEventArg.cpp | 102 ++ src/FNetBt_BluetoothSppAcceptorEventArg.h | 137 ++ src/FNetBt_BluetoothSppAcceptorImpl.cpp | 642 +++++++ src/FNetBt_BluetoothSppInitiatorEvent.cpp | 89 + src/FNetBt_BluetoothSppInitiatorEvent.h | 78 + src/FNetBt_BluetoothSppInitiatorEventArg.cpp | 84 + src/FNetBt_BluetoothSppInitiatorEventArg.h | 124 ++ src/FNetBt_BluetoothSppInitiatorImpl.cpp | 608 +++++++ src/FNetBt_BluetoothSppSystemAdapter.cpp | 528 ++++++ src/FNetBt_BluetoothSppSystemAdapter.h | 203 +++ src/inc/FNetBt_BluetoothAdapterUtility.h | 73 + src/inc/FNetBt_BluetoothDeviceImpl.h | 318 ++++ src/inc/FNetBt_BluetoothHealthImpl.h | 218 +++ src/inc/FNetBt_BluetoothManagerImpl.h | 529 ++++++ src/inc/FNetBt_BluetoothOppClientImpl.h | 177 ++ src/inc/FNetBt_BluetoothOppServerImpl.h | 224 +++ src/inc/FNetBt_BluetoothSppAcceptorImpl.h | 212 +++ src/inc/FNetBt_BluetoothSppInitiatorImpl.h | 184 ++ src/inc/FNetBt_ConnectivityIpcMessages.h | 37 + src/inc/FNetBt_IBluetoothConnectionEventListener.h | 76 + src/inc/FNetBt_IBluetoothDeviceEventListener.h | 130 ++ src/inc/FNetBt_IBluetoothManagerEventListener.h | 74 + src/inc/FNetBt_IBluetoothSocketListener.h | 90 + 93 files changed, 21012 insertions(+) create mode 100755 CMakeLists.txt create mode 100755 LICENSE.APLv2.0 create mode 100755 NOTICE create mode 100755 inc/FNetBluetooth.h create mode 100755 inc/FNetBtBluetoothDevice.h create mode 100755 inc/FNetBtBluetoothHealth.h create mode 100755 inc/FNetBtBluetoothManager.h create mode 100755 inc/FNetBtBluetoothOppClient.h create mode 100755 inc/FNetBtBluetoothOppServer.h create mode 100755 inc/FNetBtBluetoothSppAcceptor.h create mode 100755 inc/FNetBtBluetoothSppInitiator.h create mode 100755 inc/FNetBtBluetoothTypes.h create mode 100755 inc/FNetBtIBluetoothDeviceEventListener.h create mode 100755 inc/FNetBtIBluetoothHealthEventListener.h create mode 100755 inc/FNetBtIBluetoothManagerEventListener.h create mode 100755 inc/FNetBtIBluetoothOppClientEventListener.h create mode 100755 inc/FNetBtIBluetoothOppServerEventListener.h create mode 100755 inc/FNetBtIBluetoothSppAcceptorEventListener.h create mode 100755 inc/FNetBtIBluetoothSppInitiatorEventListener.h create mode 100644 osp-bluetooth.manifest create mode 100755 osp-bluetooth.pc.in create mode 100755 packaging/osp-bluetooth.spec create mode 100755 src/FNetBtBluetoothDevice.cpp create mode 100644 src/FNetBtBluetoothHealth.cpp create mode 100644 src/FNetBtBluetoothManager.cpp create mode 100644 src/FNetBtBluetoothOppClient.cpp create mode 100644 src/FNetBtBluetoothOppServer.cpp create mode 100644 src/FNetBtBluetoothSppAcceptor.cpp create mode 100644 src/FNetBtBluetoothSppInitiator.cpp create mode 100755 src/FNetBt_BluetoothAdapterUtility.cpp create mode 100644 src/FNetBt_BluetoothConnectionEvent.cpp create mode 100644 src/FNetBt_BluetoothConnectionEvent.h create mode 100644 src/FNetBt_BluetoothConnectionEventArg.cpp create mode 100644 src/FNetBt_BluetoothConnectionEventArg.h create mode 100644 src/FNetBt_BluetoothDeviceEvent.cpp create mode 100644 src/FNetBt_BluetoothDeviceEvent.h create mode 100755 src/FNetBt_BluetoothDeviceEventArg.cpp create mode 100644 src/FNetBt_BluetoothDeviceEventArg.h create mode 100755 src/FNetBt_BluetoothDeviceImpl.cpp create mode 100755 src/FNetBt_BluetoothGapSystemAdapter.cpp create mode 100644 src/FNetBt_BluetoothGapSystemAdapter.h create mode 100755 src/FNetBt_BluetoothHdpSystemAdapter.cpp create mode 100644 src/FNetBt_BluetoothHdpSystemAdapter.h create mode 100644 src/FNetBt_BluetoothHealthEvent.cpp create mode 100644 src/FNetBt_BluetoothHealthEvent.h create mode 100755 src/FNetBt_BluetoothHealthEventArg.cpp create mode 100644 src/FNetBt_BluetoothHealthEventArg.h create mode 100755 src/FNetBt_BluetoothHealthImpl.cpp create mode 100644 src/FNetBt_BluetoothIpcMessages.cpp create mode 100755 src/FNetBt_BluetoothIpcProxy.cpp create mode 100644 src/FNetBt_BluetoothIpcProxy.h create mode 100644 src/FNetBt_BluetoothManagerEvent.cpp create mode 100644 src/FNetBt_BluetoothManagerEvent.h create mode 100644 src/FNetBt_BluetoothManagerEventArg.cpp create mode 100644 src/FNetBt_BluetoothManagerEventArg.h create mode 100755 src/FNetBt_BluetoothManagerImpl.cpp create mode 100644 src/FNetBt_BluetoothOppClientEvent.cpp create mode 100644 src/FNetBt_BluetoothOppClientEvent.h create mode 100644 src/FNetBt_BluetoothOppClientEventArg.cpp create mode 100644 src/FNetBt_BluetoothOppClientEventArg.h create mode 100755 src/FNetBt_BluetoothOppClientImpl.cpp create mode 100644 src/FNetBt_BluetoothOppServerEvent.cpp create mode 100644 src/FNetBt_BluetoothOppServerEvent.h create mode 100755 src/FNetBt_BluetoothOppServerEventArg.cpp create mode 100644 src/FNetBt_BluetoothOppServerEventArg.h create mode 100755 src/FNetBt_BluetoothOppServerImpl.cpp create mode 100755 src/FNetBt_BluetoothOppSystemAdapter.cpp create mode 100644 src/FNetBt_BluetoothOppSystemAdapter.h create mode 100644 src/FNetBt_BluetoothSppAcceptorEvent.cpp create mode 100644 src/FNetBt_BluetoothSppAcceptorEvent.h create mode 100755 src/FNetBt_BluetoothSppAcceptorEventArg.cpp create mode 100644 src/FNetBt_BluetoothSppAcceptorEventArg.h create mode 100755 src/FNetBt_BluetoothSppAcceptorImpl.cpp create mode 100644 src/FNetBt_BluetoothSppInitiatorEvent.cpp create mode 100644 src/FNetBt_BluetoothSppInitiatorEvent.h create mode 100755 src/FNetBt_BluetoothSppInitiatorEventArg.cpp create mode 100644 src/FNetBt_BluetoothSppInitiatorEventArg.h create mode 100755 src/FNetBt_BluetoothSppInitiatorImpl.cpp create mode 100755 src/FNetBt_BluetoothSppSystemAdapter.cpp create mode 100644 src/FNetBt_BluetoothSppSystemAdapter.h create mode 100644 src/inc/FNetBt_BluetoothAdapterUtility.h create mode 100755 src/inc/FNetBt_BluetoothDeviceImpl.h create mode 100644 src/inc/FNetBt_BluetoothHealthImpl.h create mode 100755 src/inc/FNetBt_BluetoothManagerImpl.h create mode 100644 src/inc/FNetBt_BluetoothOppClientImpl.h create mode 100644 src/inc/FNetBt_BluetoothOppServerImpl.h create mode 100644 src/inc/FNetBt_BluetoothSppAcceptorImpl.h create mode 100644 src/inc/FNetBt_BluetoothSppInitiatorImpl.h create mode 100644 src/inc/FNetBt_ConnectivityIpcMessages.h create mode 100644 src/inc/FNetBt_IBluetoothConnectionEventListener.h create mode 100644 src/inc/FNetBt_IBluetoothDeviceEventListener.h create mode 100644 src/inc/FNetBt_IBluetoothManagerEventListener.h create mode 100644 src/inc/FNetBt_IBluetoothSocketListener.h diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100755 index 0000000..6818a4d --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,117 @@ +CMAKE_MINIMUM_REQUIRED(VERSION 2.6) + +SET (this_target osp-bluetooth) + +SET(LIBRARY_OUTPUT_PATH ${CMAKE_SOURCE_DIR}/cmake_build_tmp/output) + +INCLUDE_DIRECTORIES( + inc + src + src/inc + /usr/include/chromium + /usr/include/glib-2.0 + /usr/lib/glib-2.0/include + /usr/include/system + /usr/include/network + /usr/include/osp + /usr/include/osp/app + /usr/include/osp/base + /usr/include/osp/io + /usr/include/osp/net + /usr/include/osp/security + /usr/include/osp/system +) + +SET (${this_target}_SOURCE_FILES + src/FNetBtBluetoothDevice.cpp + src/FNetBtBluetoothManager.cpp + src/FNetBtBluetoothOppClient.cpp + src/FNetBtBluetoothOppServer.cpp + src/FNetBtBluetoothSppInitiator.cpp + src/FNetBtBluetoothSppAcceptor.cpp + src/FNetBtBluetoothSppInitiator.cpp + src/FNetBtBluetoothHealth.cpp + src/FNetBt_BluetoothAdapterUtility.cpp + src/FNetBt_BluetoothConnectionEvent.cpp + src/FNetBt_BluetoothConnectionEventArg.cpp + src/FNetBt_BluetoothDeviceEvent.cpp + src/FNetBt_BluetoothDeviceEventArg.cpp + src/FNetBt_BluetoothDeviceImpl.cpp + src/FNetBt_BluetoothGapSystemAdapter.cpp + src/FNetBt_BluetoothHealthEvent.cpp + src/FNetBt_BluetoothHealthEventArg.cpp + src/FNetBt_BluetoothHealthImpl.cpp + src/FNetBt_BluetoothHdpSystemAdapter.cpp + src/FNetBt_BluetoothIpcMessages.cpp + src/FNetBt_BluetoothIpcProxy.cpp + src/FNetBt_BluetoothManagerEvent.cpp + src/FNetBt_BluetoothManagerEventArg.cpp + src/FNetBt_BluetoothManagerImpl.cpp + src/FNetBt_BluetoothOppClientEvent.cpp + src/FNetBt_BluetoothOppClientEventArg.cpp + src/FNetBt_BluetoothOppClientImpl.cpp + src/FNetBt_BluetoothOppServerEvent.cpp + src/FNetBt_BluetoothOppServerEventArg.cpp + src/FNetBt_BluetoothOppServerImpl.cpp + src/FNetBt_BluetoothOppSystemAdapter.cpp + src/FNetBt_BluetoothSppAcceptorEvent.cpp + src/FNetBt_BluetoothSppAcceptorEventArg.cpp + src/FNetBt_BluetoothSppAcceptorImpl.cpp + src/FNetBt_BluetoothSppInitiatorEvent.cpp + src/FNetBt_BluetoothSppInitiatorEventArg.cpp + src/FNetBt_BluetoothSppInitiatorImpl.cpp + src/FNetBt_BluetoothSppSystemAdapter.cpp + ) + +SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} -Wall" ) + +## SET C COMPILER FLAGS +SET(CMAKE_C_FLAGS "${OSP_DEBUG_FLAGS} ${OSP_OPT_FLAGS} ${CMAKE_C_FLAGS} ${EXTRA_CFLAGS} ${OSP_COMPILER_FLAGS}") + +## SET CPP COMPILER FLAGS +SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility=hidden") +SET(CMAKE_CXX_FLAGS "${OSP_DEBUG_FLAGS} ${OSP_OPT_FLAGS} ${CMAKE_CXX_FLAGS} ${EXTRA_CFLAGS} ${OSP_COMPILER_FLAGS}") + +## Create Library +ADD_LIBRARY (${this_target} SHARED ${${this_target}_SOURCE_FILES}) + +## SET LINKER FLAGS +SET(CMAKE_SHARED_LINKER_FLAGS -Wl,--no-undefined) + +TARGET_LINK_LIBRARIES(${this_target} "-lchromium" ) +TARGET_LINK_LIBRARIES(${this_target} "-lpthread" ) +TARGET_LINK_LIBRARIES(${this_target} "-L/usr/lib/osp -losp-appfw -losp-net" ) +TARGET_LINK_LIBRARIES(${this_target} "-lcapi-network-bluetooth" ) + +SET_TARGET_PROPERTIES(${this_target} + PROPERTIES + VERSION ${FULLVER} + SOVERSION ${MAJORVER} + CLEAN_DIRECT_OUTPUT 1 + ) + +ADD_CUSTOM_COMMAND(TARGET ${this_target} + POST_BUILD + COMMAND ${CMAKE_COMMAND} -E copy ${LIBRARY_OUTPUT_PATH}/${CMAKE_SHARED_LIBRARY_PREFIX}${this_target}${CMAKE_SHARED_LIBRARY_SUFFIX} ${LIBRARY_OUTPUT_PATH}/debug/${CMAKE_SHARED_LIBRARY_PREFIX}${this_target}${CMAKE_SHARED_LIBRARY_SUFFIX}.${FULLVER} + COMMAND ${CMAKE_COMMAND} -E create_symlink ${CMAKE_SHARED_LIBRARY_PREFIX}${this_target}${CMAKE_SHARED_LIBRARY_SUFFIX}.${FULLVER} ${LIBRARY_OUTPUT_PATH}/debug/${CMAKE_SHARED_LIBRARY_PREFIX}${this_target}${CMAKE_SHARED_LIBRARY_SUFFIX}.${MAJORVER} + COMMAND ${CMAKE_STRIP} --strip-unneeded ${LIBRARY_OUTPUT_PATH}/${CMAKE_SHARED_LIBRARY_PREFIX}${this_target}${CMAKE_SHARED_LIBRARY_SUFFIX} + COMMENT "strip ${this_target}" + ) + +INSTALL(DIRECTORY ${LIBRARY_OUTPUT_PATH}/ DESTINATION lib/osp + FILES_MATCHING PATTERN "*.so*" + PERMISSIONS OWNER_EXECUTE OWNER_WRITE OWNER_READ + GROUP_EXECUTE GROUP_READ + WORLD_EXECUTE WORLD_READ) +INSTALL(DIRECTORY ${LIBRARY_OUTPUT_PATH}/debug/ DESTINATION lib/osp/debug + FILES_MATCHING PATTERN "*.so*" + PERMISSIONS OWNER_EXECUTE OWNER_WRITE OWNER_READ + GROUP_EXECUTE GROUP_READ + WORLD_EXECUTE WORLD_READ) + +INSTALL(DIRECTORY ${CMAKE_SOURCE_DIR}/inc/ DESTINATION include/osp FILES_MATCHING PATTERN "*.h") +INSTALL(DIRECTORY ${CMAKE_SOURCE_DIR}/src/inc/ DESTINATION include/osp/net FILES_MATCHING PATTERN "*.h") + +# pkgconfig file +CONFIGURE_FILE(${this_target}.pc.in ${CMAKE_SOURCE_DIR}/${this_target}.pc @ONLY) +INSTALL(FILES ${CMAKE_SOURCE_DIR}/${this_target}.pc DESTINATION lib/pkgconfig) \ No newline at end of file diff --git a/LICENSE.APLv2.0 b/LICENSE.APLv2.0 new file mode 100755 index 0000000..d645695 --- /dev/null +++ b/LICENSE.APLv2.0 @@ -0,0 +1,202 @@ + + 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/NOTICE b/NOTICE new file mode 100755 index 0000000..4443889 --- /dev/null +++ b/NOTICE @@ -0,0 +1,5 @@ +Copyright (c) Samsung Electronics Co., Ltd. All rights reserved. +Except as noted, this software is licensed under Apache License, Version 2. +Please, see the LICENSE file for Apache License terms and conditions. + + diff --git a/inc/FNetBluetooth.h b/inc/FNetBluetooth.h new file mode 100755 index 0000000..afaf686 --- /dev/null +++ b/inc/FNetBluetooth.h @@ -0,0 +1,67 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +/** + * @file FNetBluetooth.h + * @brief This is the header file for the %Bluetooth namespace. + * + * This header file contains the declarations and descriptions of the %Tizen::Net::Bluetooth namespace. + */ +#ifndef _FNET_BLUETOOTH_H_ +#define _FNET_BLUETOOTH_H_ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace Tizen { namespace Net +{ +/** + * @namespace Tizen::Net::Bluetooth + * @brief This namespace contains the classes and interfaces for %Bluetooth services. + * @since 2.0 + * + * @remarks @b Header @b %file: @b \#include @b @n + * @b Library : @b osp-bluetooth @n + * + * The %Bluetooth namespace contains the classes and interfaces for %Bluetooth services that provide the mechanisms for + * peer-to-peer communication involving connecting, sending, and receiving data over a %Bluetooth connection. It + * consists of the submodules that support different profiles such as GAP, OPP, and SPP. + * @n + * For more information on the %Bluetooth namespace features, see + * Bluetooth Guide. + * + * The following diagram illustrates the relationships between the classes within the %Bluetooth namespace. + * @image html net_bluetooth_using_the_apis_classdiagram.png + * + */ +namespace Bluetooth +{ +} } } // Tizen::Net::Bluetooth +#endif // _FNET_BLUETOOTH_H_ diff --git a/inc/FNetBtBluetoothDevice.h b/inc/FNetBtBluetoothDevice.h new file mode 100755 index 0000000..5448190 --- /dev/null +++ b/inc/FNetBtBluetoothDevice.h @@ -0,0 +1,269 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +/** + * @file FNetBtBluetoothDevice.h + * @brief This is the header file for the %BluetoothDevice class. + * + * This header file contains the declarations of the %BluetoothDevice class. + */ +#ifndef _FNET_BT_BLUETOOTH_DEVICE_H_ +#define _FNET_BT_BLUETOOTH_DEVICE_H_ + +#include +#include +#include + +// forward declarations +namespace Tizen { namespace Base +{ +class ByteBuffer; +class String; +namespace Collection +{ +class IList; +} +} } + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +// forward declarations +class _BluetoothDeviceImpl; + +/** + * @class BluetoothDevice + * @brief This class provides information about a remote %Bluetooth device. + * @since 2.0 + * + * The %BluetoothDevice class provides information about a remote %Bluetooth device. + * + * For more information on the class features, see + * Bluetooth Guide. + */ +class _OSP_EXPORT_ BluetoothDevice + : public Tizen::Base::Object +{ +public: + /** + * This is the default constructor for this class. + * + * @since 2.0 + */ + BluetoothDevice(void); + + /** + * @if OSPDEPREC + * Initializes an instance of %BluetoothDevice with the specified parameters. + * + * @brief [Deprecated] + * @deprecated This constructor is deprecated because most of the information is generated internally. + * Therefore, creating a %BluetoothDevice instance directly by the application is not recommended. + * Instead of using this method for copying an instance, the copy constructor is recommended. + * @since 2.0 + * + * @param[in] address The %Bluetooth device address + * @param[in] deviceName The name of the device + * @param[in] majorClassType The major class type of a %Bluetooth device + * @param[in] minorClassType The minor class type of a %Bluetooth device + * @param[in] serviceClassList The service class type list + * @param[in] serviceList The service type list + * @remarks The @c serviceClassList parameter consists of Bluetooth::BluetoothServiceClassType values, which are + * joined by the logical OR operator. @n + * The @c serviceList parameter consists of Bluetooth::BluetoothServiceType values which are joined by the + * logical OR operator. + * @endif + */ + BluetoothDevice(const Tizen::Base::ByteBuffer& address, const Tizen::Base::String& deviceName, BluetoothMajorDeviceClassType majorClassType, BluetoothMinorDeviceClassType minorClassType, unsigned long serviceClassList, unsigned long serviceList); + + /** + * Copying of objects using this copy constructor is allowed. + * + * @since 2.0 + * + * @param[in] value An instance of %BluetoothDevice + */ + BluetoothDevice(const BluetoothDevice& value); + + /** + * This destructor overrides Tizen::Base::Object::~Object(). + * + * @since 2.0 + */ + virtual ~BluetoothDevice(void); + + /** + * Gets the address of a %Bluetooth device which consists of 6 bytes. + * + * @since 2.0 + * + * @return The address of a %Bluetooth device + */ + const Tizen::Base::ByteBuffer* GetAddress(void) const; + + /** + * Sets the address of a %Bluetooth device. + * + * @since 2.0 + * + * @return An error code + * @param[in] address An address of the %Bluetooth device + * @exception E_SUCCESS The method is successful. + * @exception E_INVALID_ARG The specified address is invalid @n + * The size of the address should be 6 bytes. + * @remarks @c address must have 6 byte data (remaining elements). @n + * Setting the address of the %BluetoothDevice instance which is obtained from the paired list does not + * affect the information of the paired list in the system. + */ + result SetAddress(const Tizen::Base::ByteBuffer& address); + + /** + * Gets the %Bluetooth device name. + * + * @since 2.0 + * + * @return The %Bluetooth device name + */ + Tizen::Base::String GetName(void) const; + + /** + * Checks whether this device is paired with the local device. + * + * @since 2.0 + * + * @return @c true if this device is paired with the local device, @n + * else @c false + */ + bool IsPaired(void) const; + + /** + * Gets the Received Signal Strength Indication (RSSI) value of a device at the time of device discovery (scan). + * + * @since 2.0 + * + * @return The RSSI value in dBm + */ + int GetRssi(void) const; + + /** + * Gets the major device class. + * + * @since 2.0 + * + * @return The major device class + */ + BluetoothMajorDeviceClassType GetMajorDeviceClassType(void) const; + + /** + * Gets the minor device class. + * + * @since 2.0 + * + * @return The minor device class + */ + BluetoothMinorDeviceClassType GetMinorDeviceClassType(void) const; + + /** + * Gets the service class of the %Bluetooth device. @n + * This service class list consists of Bluetooth::BluetoothServiceClassType values, which are joined by the logical OR + * operator. + * + * @since 2.0 + * + * @return The service class of the device + * @remarks This operation is not supported in the local device acquired by BluetoothManager::GetLocalDevice(). + */ + unsigned long GetServiceClassList(void) const; + + /** + * Gets the %Bluetooth device service list. @n + * This service list consists of Bluetooth::BluetoothServiceType values, which are joined by the logical OR operator. + * + * @since 2.0 + * + * @return The %Bluetooth device service list + * @remarks This operation is not supported in the local device acquired by BluetoothManager::GetLocalDevice(). + */ + unsigned long GetServiceList(void) const; + + /** + * Gets the %Bluetooth device service UUID list. @n + * This service list consists of Tizen::Base::UuId instances that represent service UUIDs that the device supports. + * + * @since 2.0 + * + * @return The %Bluetooth device service UUID list + * @remarks This operation returns @c null, if it is called in the local device acquired by + * BluetoothManager::GetLocalDevice(). + */ + const Tizen::Base::Collection::IList* GetServiceUuidList(void) const; + + /** + * Compares the calling instance with the specified instance. + * + * @since 2.0 + * @return @c true if both the instances are equal, @n + * else @c false + * @param[in] obj The object to compare + */ + virtual bool Equals(const Tizen::Base::Object& obj) const; + + /** + * Gets the hash value of the current instance. + * + * @since 2.0 + * + * @return The hash value of the current instance + */ + virtual int GetHashCode(void) const; + + /** + * Gets a new instance of %BluetoothDevice generated using the result of the %Bluetooth AppControl. + * + * @since 2.0 + * @return The %Bluetooth device containing the specified information extracted from the input data if successful, + * @n + * else @c null + * @param[in] appControlResult The data list, which is the result of the %Bluetooth AppControl + * @exception E_SUCCESS The method is successful. + * @exception E_INVALID_ARG The specified @c appControlResult contains an invalid value. @n + * The result of %Bluetooth AppControl is only permitted to be used as an input + * argument. + * @exception E_OUT_OF_MEMORY The memory is insufficient. + * @remarks The specific error code can be accessed using the GetLastResult() method. + */ + static BluetoothDevice* GetInstanceFromAppControlResultN(const Tizen::Base::Collection::IList& appControlResult); + + /** + * Copying of objects using this copy assignment operator is allowed. + * + * @since 2.0 + * + * @return A reference to the %BluetoothDevice instance + * @param[in] rhs A reference to the %BluetoothDevice instance to copy + */ + BluetoothDevice& operator =(const BluetoothDevice& rhs); + +private: + _BluetoothDeviceImpl* __pImpl; + + friend class _BluetoothDeviceImpl; + +}; // BluetoothDevice + +} } } +#endif // _FNET_BT_BLUETOOTH_DEVICE_H_ diff --git a/inc/FNetBtBluetoothHealth.h b/inc/FNetBtBluetoothHealth.h new file mode 100755 index 0000000..36762cf --- /dev/null +++ b/inc/FNetBtBluetoothHealth.h @@ -0,0 +1,226 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +/** + * @file FNetBtBluetoothHealth.h + * @brief This is the header file for the %BluetoothHealth class. + * + * This header file contains the declarations of the %BluetoothHealth class. + */ +#ifndef _FNET_BT_BLUETOOTH_HEALTH_H_ +#define _FNET_BT_BLUETOOTH_HEALTH_H_ + +#include +#include +#include + +namespace Tizen { namespace Base +{ +class ByteBuffer; +} } + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +class BluetoothDevice; +class IBluetoothHealthEventListener; +class _BluetoothHealthImpl; + +/** + * @class BluetoothHealth + * @brief This class provides the methods to handle the %Bluetooth Health Device Profile (HDP), such as the + * establishing a connection and exchanging data through the data channel. + * @since 2.0 + * + * @final This class is not intended for extension. + * + * This %BluetoothHealth class provides the methods to handle the %Bluetooth Health Device Profile (HDP), which is a + * profile that defines the requirements for qualified %Bluetooth healthcare and fitness (referred to as 'health') + * device implementations. @n + * This class allows Sink device such as mobile phone to establish a connection and exchange data to Source devices + * such as blood pressure monitors, weight scales, glucose meters, thermometers, and pulse oximeters. + * + * For more information on the class features, see + * Bluetooth Guide. + */ +class _OSP_EXPORT_ BluetoothHealth + : public Tizen::Base::Object +{ +public: + /** + * The object is not fully constructed after this constructor is called. For full construction, the Construct() + * method must be called right after calling this constructor. + * + * @since 2.0 + */ + BluetoothHealth(void); + + /** + * This destructor overrides Tizen::Base::Object::~Object(). + * + * @since 2.0 + */ + virtual ~BluetoothHealth(void); + + /** + * Constructs an instance of %BluetoothHealth with the specified listener. + * + * @since 2.0 + * + * @return An error code + * @param[in] listener The event listener for the %BluetoothHealth. @n + * Listener must be allocated at heap, not stack. + * @exception E_SUCCESS The method is successful. + * @exception E_OUT_OF_MEMORY The memory is insufficient. + * @exception E_UNSUPPORTED_OPERATION The device does not support the %Bluetooth feature. + * @exception E_OPERATION_FAILED The method has failed. + */ + result Construct(IBluetoothHealthEventListener& listener); + + /** + * Starts %Bluetooth health as a role of sink with the specified data type. + * + * @since 2.0 + * @privilege http://tizen.org/privilege/bluetooth.health + * + * @return An error code + * @param[in] dataType The type of data used in communication which is defined in ISO/IEEE + * 11073-20601 and represents type of health device such as thermometer, + * heart rate monitor, weight scale, and so on + * @exception E_SUCCESS The method is successful. + * @exception E_INVALID_STATE %Bluetooth is not activated. + * @exception E_IN_PROGRESS The sink role with the specified data type has already started. + * @exception E_INVALID_OPERATION The current state of the instance prohibits the execution of the specified + * operation. @n + * For example, the sink role already started with another data type. + * @exception E_SERVICE_UNAVAILABLE The sink role with the specified data type is currently busy with another + * instance or application. + * @exception E_PRIVILEGE_DENIED The application does not have the privilege to call this method. + * @exception E_OPERATION_FAILED The method has failed. + * @remarks One %BluetoothHealth instance supports only a sink role with the specific data type at one time and + * only one sink role for the specific data type can be enabled system-widely. For providing sink + * roles with various data types, make multiple %BluetoothHealth instances with different data types. + */ + result StartAsSink(int dataType); + + /** + * Stops %Bluetooth health as a role of sink. @n + * This method disconnects all established channels before stop. + * + * @since 2.0 + * @privilege http://tizen.org/privilege/bluetooth.health + * + * @return An error code + * @exception E_SUCCESS The method is successful. + * @exception E_INVALID_STATE %Bluetooth is not activated. + * @exception E_INVALID_OPERATION The current state of the instance prohibits the execution of the specified + * operation. @n + * For example, the sink role is not started yet. + * @exception E_PRIVILEGE_DENIED The application does not have the privilege to call this method. + * @exception E_OPERATION_FAILED The method has failed. + */ + result Stop(void); + + /** + * Connects to a new channel with a remote health device which has source role. @n + * This method establishes a channel after the source device accepts the request. + * + * @since 2.0 + * @privilege http://tizen.org/privilege/bluetooth.health + * + * @return An error code + * @param[in] remoteDevice The remote device to connect + * @exception E_SUCCESS The method is successful. + * @exception E_INVALID_STATE %Bluetooth is not activated. + * @exception E_INVALID_OPERATION The current state of the instance prohibits the execution of the specified + * operation. @n + * For example, the sink role is not started yet. + * @exception E_DEVICE_BUSY The pairing and connection process is in progress. + * @exception E_PRIVILEGE_DENIED The application does not have the privilege to call this method. + * @exception E_OPERATION_FAILED The method has failed. + * @see IBluetoothHealthEventListener::OnHealthConnected() + * @remarks If the local device is not paired with the specified target device, the pairing process starts + * internally before the connect request is sent. + */ + result ConnectToSource(const BluetoothDevice& remoteDevice); + + /** + * Disconnects the connection which has the specified channel ID. @n + * After calling this method, the IBluetoothHealthEventListener::OnHealthDisconnected() is called regardless of + * whether this method is called during connection or before connection is established. + * + * @since 2.0 + * @privilege http://tizen.org/privilege/bluetooth.health + * + * @return An error code + * @param[in] channelId The ID of the specified channel to disconnect + * @exception E_SUCCESS The method is successful. + * @exception E_INVALID_STATE %Bluetooth is not activated. + * @exception E_INVALID_OPERATION The current state of the instance prohibits the execution of the specified + * operation. @n + * For example, there is no connection with the specified channel ID. + * @exception E_PRIVILEGE_DENIED The application does not have the privilege to call this method. + * @exception E_OPERATION_FAILED The method has failed. + * @see IBluetoothHealthEventListener::OnHealthDisconnected() + * @remarks @c channelId value can be obtained by IBluetoothHealthEventListener::OnHealthConnected() after the + * specific channel is established. + */ + result Disconnect(int channelId); + + /** + * Sends the specified data on the specified channel. + * + * @since 2.0 + * @privilege http://tizen.org/privilege/bluetooth.health + * + * @return An error code + * @param[in] channelId The ID of the specified channel on which the data is sent + * @param[in] buffer The data to send + * @exception E_SUCCESS The method is successful. + * @exception E_INVALID_STATE %Bluetooth is not activated. + * @exception E_INVALID_OPERATION The current state of the instance prohibits the execution of the specified + * operation. @n + * For example, there is no connection with the specified channel ID. + * @exception E_INVALID_ARG The input buffer has no data. + * @exception E_PRIVILEGE_DENIED The application does not have the privilege to call this method. + * @exception E_OPERATION_FAILED The operation has failed. + * @see IBluetoothHealthEventListener::OnHealthDataReceived() + * @remarks @c channelId value can be obtained by IBluetoothHealthEventListener::OnHealthConnected() after the + * specific channel is established. + */ + result SendData(int channelId, const Tizen::Base::ByteBuffer& buffer); + +private: + // + // The implementation of this copy constructor is intentionally blank and declared as private to prohibit copying + // of objects. + // + BluetoothHealth(const BluetoothHealth& value); + + // + // The implementation of this copy assignment operator is intentionally blank and declared as private to prohibit + // copying of objects. + // + BluetoothHealth& operator =(const BluetoothHealth& rhs); + +private: + _BluetoothHealthImpl* __pImpl; + +}; // BluetoothHealth + +} } } +#endif // _FNET_BT_BLUETOOTH_HEALTH_H_ diff --git a/inc/FNetBtBluetoothManager.h b/inc/FNetBtBluetoothManager.h new file mode 100755 index 0000000..f1dc6c3 --- /dev/null +++ b/inc/FNetBtBluetoothManager.h @@ -0,0 +1,594 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +/** + * @file FNetBtBluetoothManager.h + * @brief This is the header file for the %BluetoothManager class. + * + * This header file contains the declarations of the %BluetoothManager class. + */ +#ifndef _FNET_BT_BLUETOOTH_MANAGER_H_ +#define _FNET_BT_BLUETOOTH_MANAGER_H_ + +#include +#include +#include + +namespace Tizen { namespace Base +{ +class String; +class ByteBuffer; +namespace Collection +{ +class IList; +} +} } + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +// forward declarations +class BluetoothDevice; +class IBluetoothManagerEventListener; +class IBluetoothDeviceEventListener; +class _BluetoothManagerImpl; + +/** + * @class BluetoothManager + * @brief This class is used to obtain information about the local device or the paired devices, and to configure + * the %Bluetooth stack. + * @since 2.0 + * + * The %BluetoothManager class is used to obtain information about the local device or the paired devices and to configure the + * %Bluetooth stack. + * + * For more information on the class features, see + * Bluetooth Guide. + */ +class _OSP_EXPORT_ BluetoothManager + : public Tizen::Base::Object +{ +public: + /** + * The object is not fully constructed after this constructor is called. For full construction, the Construct() + * method must be called right after calling this constructor. + * + * @since 2.0 + */ + BluetoothManager(void); + + /** + * This destructor overrides Tizen::Base::Object::~Object(). + * + * @since 2.0 + */ + virtual ~BluetoothManager(void); + + /** + * Constructs and initializes an instance of the %BluetoothManager class with the specified listener. + * + * @since 2.0 + * + * @return An error code + * @param[in] listener The listener to handle the %BluetoothManager event + * @exception E_SUCCESS The method is successful. + * @exception E_OUT_OF_MEMORY The memory is insufficient. + * @exception E_UNSUPPORTED_OPERATION This operation is not supported. + * @exception E_SYSTEM A system error has occurred. + */ + result Construct(IBluetoothManagerEventListener& listener); + + /** + * Activates %Bluetooth on a device. + * + * @since 2.0 + * @privilege http://tizen.org/privilege/bluetooth.admin + * + * @return An error code + * @exception E_SUCCESS The method is successful. + * @exception E_IN_PROGRESS The %Bluetooth activation process is in progress. + * @exception E_INVALID_OPERATION The current state of the instance prohibits the execution of the + * specified operation. @n + * For example, %Bluetooth is already activated. + * @exception E_OUT_OF_MEMORY The memory is insufficient. + * @exception E_PRIVILEGE_DENIED The application does not have the privilege to call this method. + * @exception E_SYSTEM A system error has occurred. + * @see IBluetoothManagerEventListener::OnBluetoothActivated() + */ + result Activate(void); + + /** + * Deactivates %Bluetooth on a device. + * + * @since 2.0 + * @privilege http://tizen.org/privilege/bluetooth.admin + * + * @return An error code + * @exception E_SUCCESS The method is successful. + * @exception E_IN_PROGRESS The %Bluetooth deactivation process is in progress. + * @exception E_INVALID_OPERATION The current state of the instance prohibits the execution of the + * specified operation. @n + * For example, the %Bluetooth is already deactivated. + * @exception E_OUT_OF_MEMORY The memory is insufficient. + * @exception E_PRIVILEGE_DENIED The application does not have the privilege to call this method. + * @exception E_SYSTEM A system error has occurred. + * @see IBluetoothManagerEventListener::OnBluetoothDeactivated() + */ + result Deactivate(void); + + /** + * @if OSPDEPREC + * Checks whether a %Bluetooth-specific profile is available. + * + * @brief [Deprecated] + * @deprecated This method is deprecated because multiple clients as well as multiple SPP servers with unique + * service UUIDs are supported. In case of OPP server, invoke + * BluetoothOppServer::StartService() directly without checking OPP server's availability. + * If a new OPP server is not available, the method returns the E_SERVICE_UNAVAILABLE exception. + * @since 2.0 + * + * @return @c true if the specified type of connection is available, @n + * else @c false + * @param[in] type The connection type + * + * @endif + */ + bool IsAvailable(BluetoothConnectionType type) const; + + /** + * @if OSPDEPREC + * Gets the local device information. + * + * @brief [Deprecated] + * @deprecated This method is deprecated because the return value of this method is a dangling pointer if this + * instance of %BluetoothManager is deleted. In addition to this, the %BluetoothDevice class + * represents only remote devices since 2.0. Instead of using this method, the GetLocalDeviceAddress() + * and GetLocalDeviceName() methods are recommended. + * @since 2.0 + * + * @return The local device information + * @exception E_SUCCESS The method is successful. + * @exception E_OUT_OF_MEMORY The memory is insufficient. + * @exception E_SYSTEM A system error has occurred. + * @remarks The specific error code can be accessed using the GetLastResult() method. + * @endif + */ + const BluetoothDevice* GetLocalDevice(void) const; + + /** + * Gets the local %Bluetooth device address. + * + * @since 2.0 + * + * @return The local %Bluetooth device address + * @remarks The address is expressed as a @c 6 byte hexadecimal value delimited by colons. @n + * For example, "00:3D:47:EF:8A:03". + */ + Tizen::Base::String GetLocalDeviceAddress(void) const; + + /** + * Gets the local %Bluetooth device name. + * + * @since 2.0 + * + * @return The local %Bluetooth device name + */ + Tizen::Base::String GetLocalDeviceName(void) const; + + /** + * @if OSPDEPREC + * Gets the operational mode of the %Bluetooth unit. + * + * @brief [Deprecated] + * @deprecated %BluetoothDeviceStateType is deprecated. Therefore, this method is also deprecated, because the + * return value of this method is of type %BluetoothDeviceStateType. Instead of using this method, the + * IsActivated() and GetDiscoverableMode() methods are recommended. + * + * @since 2.0 + * + * @return The operational mode + * @endif + */ + BluetoothDeviceStateType GetLocalDeviceState(void) const; + + /** + * Checks whether the local %Bluetooth is activated. + * + * @since 2.0 + * + * @return @c true if the local %Bluetooth is activated, @n + * else @c false + */ + bool IsActivated(void) const; + + /** + * Gets the discoverable mode of the local device. + * + * @if OSPCOMPAT + * @brief [Compatibility] + * @endif + * @since 2.0 + * @if OSPCOMPAT + * @compatibility This method has compatibility issues@n + * For more information, see @ref BluetoothManagerGetDiscoverableModePage "here". + * + * @endif + * @return The discoverable mode of the local device + */ + BluetoothDiscoverableMode GetDiscoverableMode(void) const; + + /** + * @if OSPCOMPAT + * @page BluetoothManagerGetDiscoverableModePage Compatibility for GetDiscoverableMode() + * + * @section BluetoothManagerGetDiscoverableModePageIssueSection Issues + * Implementation of this method in API versions prior to 2.0 has the following issue: @n + * + * -# The always discoverable mode and the discoverable mode with a certain amount of time cannot be + * differentiated. BT_DISC_MODE_DISCOVERABLE of BluetoothDiscoverableMode means both. + * + * @section BluetoothManagerGetDiscoverableModePageSolutionSection Resolutions + * The issue mentioned above is resolved in API version 2.0, and it is recommended to use API version + * 3.0 or above. @n + * + * -# The new element, BT_DISC_MODE_TIME_LIMITED_DISCOVERABLE, is added into BluetoothDiscoverableMode + * in API version 2.0, Therefore, BT_DISC_MODE_DISCOVERABLE means the always discoverable mode and + * BT_DISC_MODE_TIME_LIMITED_DISCOVERABLE means the discoverable mode with a certain amount of time. + * @endif + */ + + /** + * Gets the remaining time, in seconds, until the discoverable mode is changed from + * @c BT_DISC_MODE_TIME_LIMITED_DISCOVERABLE to be @c BT_DISC_MODE_NOT_DISCOVERABLE. @n + * This method is valid only if the current discoverable mode is @c BT_DISC_MODE_TIME_LIMITED_DISCOVERABLE. + * + * @since 2.0 + * + * @return The remaining time, in seconds, until the local device to be not discoverable. + * @remarks 0 will be returned if the current discoverable mode is not @c BT_DISC_MODE_TIME_LIMITED_DISCOVERABLE. + */ + int GetRemainingTimeAsDiscoverable(void) const; + + /** + * Checks whether the device discovery is in progress. + * + * @since 2.0 + * + * @return @c true if the device discovery is in progress, @n + * else @c false + */ + bool IsDiscoveryInProgress(void) const; + + /** + * Sets the name of the local device. + * + * @since 2.0 + * @privilege http://tizen.org/privilege/bluetooth.admin + * + * @return An error code + * @param[in] deviceName The new device name + * @exception E_SUCCESS The method is successful. + * @exception E_INVALID_ARG The specified device name is an empty string. + * @exception E_PRIVILEGE_DENIED The application does not have the privilege to call this method. + * @exception E_SYSTEM A system error has occurred. + * @remarks This method does not affect the system settings. The device name is only valid while an application + * is active. The searching device detects the local devices in close proximity based on the specified + * device name. The specified device name is automatically truncated if its size is greater than @c 64 + * bytes. + */ + result SetLocalDeviceName(const Tizen::Base::String& deviceName); + + /** + * @if VISPARTNER-MANUFACTURER + * Sets the discoverable mode of the local device. + * + * @since 2.0 + * @visibility partner-manufacturer + * @privilege http://tizen.org/privilege/bluetoothmanager + * + * @return An error code + * @param[in] mode The new discoverable mode + * @param[in] seconds The duration in seconds for which the local device is discoverable + * @exception E_SUCCESS The method is successful. + * @exception E_INVALID_ARG The specified @c seconds should be greater than 0 if the specified + * @c mode is @c BT_DISC_MODE_TIME_LIMITED_DISCOVERABLE. + * @exception E_INVALID_OPERATION %Bluetooth is not activated. + * @exception E_PRIVILEGE_DENIED The application does not have the privilege to call this method. + * @exception E_SYSTEM A system error has occurred. + * @see IBluetoothManagerEventListener::OnBluetoothDiscoverableModeChanged() + * @remarks @c seconds is adopted only if the specified @c mode is @c BT_DISC_MODE_TIME_LIMITED_DISCOVERABLE. + * @endif + */ + result SetDiscoverableMode(BluetoothDiscoverableMode mode, int seconds = 0); + + /** + * @if OSPDEPREC + * Refreshes the paired device list. + * + * @brief [Deprecated] + * @deprecated This method is deprecated because the paired device list of this instance of %BluetoothManager is + * refreshed automatically. An application should not call this method to refresh the list. + * @since 2.0 + * + * @return An error code + * @exception E_SUCCESS The method is successful. + * @exception E_OUT_OF_MEMORY The memory is insufficient. + * @exception E_SYSTEM A system error has occurred. + * @endif + */ + result RefreshPairedDeviceList(void); + + /** + * @if OSPDEPREC + * Searches for an element that matches a %Bluetooth address. + * + * @brief [Deprecated] + * @deprecated This method is deprecated because the return value of this method is a dangling pointer, if this + * instance of %BluetoothManager is deleted. In addition to this, it is also an invalid pointer if the + * paired device list is updated internally. Instead of using this method, GetPairedDeviceByAddressN() + * is recommended. + * @since 2.0 + * + * @return The instance of %BluetoothDevice containing the specified address, @n + * else @c null if the search is not successful + * @param[in] deviceAddress The address to locate + * @exception E_SUCCESS The method is successful. + * @exception E_OBJ_NOT_FOUND The specified device is not found in the paired device list. + * @remarks The specific error code can be accessed using the GetLastResult() method. + * @endif + */ + const BluetoothDevice* GetPairedDeviceByAddress(const Tizen::Base::ByteBuffer& deviceAddress) const; + + /** + * Gets an element that matches a %Bluetooth address. + * + * @since 2.0 + * + * @return The instance of %BluetoothDevice containing the specified address, @n + * else @c null if the search is not successful + * @param[in] deviceAddress The address to locate + * @exception E_SUCCESS The method is successful. + * @exception E_OBJ_NOT_FOUND The specified device is not found in the paired device list. + * @exception E_OUT_OF_MEMORY The memory is insufficient. + * @remarks The specific error code can be accessed using the GetLastResult() method. + */ + BluetoothDevice* GetPairedDeviceByAddressN(const Tizen::Base::ByteBuffer& deviceAddress) const; + + /** + * Gets the elements matching a device name in the paired device list. + * + * @since 2.0 + * + * @return A list containing the matching devices, @n + * else @c null if the search is not successful + * @param[in] deviceName The name of the device to locate + * @exception E_SUCCESS The method is successful. + * @exception E_OBJ_NOT_FOUND The specified device is not found in the paired device list. + * @exception E_OUT_OF_MEMORY The memory is insufficient. + * @remarks The specific error code can be accessed using the GetLastResult() method. + */ + Tizen::Base::Collection::IList* GetPairedDeviceByNameN(const Tizen::Base::String& deviceName) const; + + /** + * @if OSPDEPREC + * Gets the element at the specified index. + * + * @brief [Deprecated] + * @deprecated This method is deprecated because the return value of this method is a dangling pointer, if this + * instance of %BluetoothManager is deleted. In addition to this, it is also an invalid pointer if the + * paired device list is updated internally. Instead of using this method, GetPairedDeviceListN() and + * Tizen::Base::Collection::IList::GetAt() are recommended. + * @since 2.0 + * + * @return The instance of %BluetoothDevice at the specified index, @n + * else @c null if there is no element + * @param[in] index The index in the list + * @exception E_SUCCESS The method is successful. + * @exception E_OBJ_NOT_FOUND The specified index is not found in the paired device list. + * @remarks The specific error code can be accessed using the GetLastResult() method. + * @endif + */ + const BluetoothDevice* GetPairedDeviceAt(int index) const; + + /** + * @if OSPDEPREC + * Gets the paired device list. + * + * @brief [Deprecated] + * @deprecated This method is deprecated because the return value of this method is a dangling pointer, if this + * instance of %BluetoothManager is deleted. In addition to this, some elements of the list may also + * be invalid pointers if the paired device list is updated internally. Instead of using this method, + * GetPairedDeviceListN() is recommended. + * @since 2.0 + * + * @return A pointer to the paired device list on success, @n + * else @c null + * @exception E_SUCCESS The method is successful. + * @remarks The specific error code can be accessed using the GetLastResult() method. + * @endif + */ + const Tizen::Base::Collection::IList* GetPairedDeviceList(void) const; + + /** + * Gets the paired device list. + * + * @since 2.0 + * + * @return A pointer to the paired device list on success, @n + * else @c null + * @exception E_SUCCESS The method is successful. + * @exception E_OUT_OF_MEMORY The memory is insufficient. + * @remarks The specific error code can be accessed using the GetLastResult() method. + */ + Tizen::Base::Collection::IList* GetPairedDeviceListN(void) const; + + /** + * Sets a remote device event listener for searching devices and services. + * + * @since 2.0 + * + * @return An error code + * @param[in] pListener The device event listener to add + * @exception E_SUCCESS The method is successful. + * @exception E_SYSTEM A system error has occurred. + * @remarks Only one event listener can be set. If the input parameter is @c null, the listener currently set + * is unregistered. + */ + result SetBluetoothDeviceListener(IBluetoothDeviceEventListener* pListener); + + /** + * Starts the device discovery process. + * + * @since 2.0 + * @privilege http://tizen.org/privilege/bluetooth.gap + * + * @return An error code + * @exception E_SUCCESS The method is successful. + * @exception E_IN_PROGRESS The device discovery process is in progress. + * @exception E_INVALID_OPERATION The current state of the instance prohibits the execution of this + * operation. + * @exception E_PRIVILEGE_DENIED The application does not have the privilege to call this method. + * @exception E_SYSTEM A system error has occurred. + * @see IBluetoothDeviceEventListener::OnBluetoothDiscoveryStarted() + * @see IBluetoothDeviceEventListener::OnBluetoothRemoteDeviceFoundN() + * @see IBluetoothDeviceEventListener::OnBluetoothDiscoveryDone() + */ + result StartDiscovery(void); + + /** + * Cancels the device discovery process. + * + * @since 2.0 + * @privilege http://tizen.org/privilege/bluetooth.gap + * + * @return An error code + * @exception E_SUCCESS The method is successful. + * @exception E_IN_PROGRESS The termination of the device discovery process is in progress. + * @exception E_INVALID_OPERATION The current state of the instance prohibits the execution of this + * operation. @n + * For example, the discovery has not started as yet. + * @exception E_PRIVILEGE_DENIED The application does not have the privilege to call this method. + * @exception E_SYSTEM A system error has occurred. + * @see IBluetoothDeviceEventListener::OnBluetoothDiscoveryDone() + */ + result CancelDiscovery(void); + + /** + * Retrieves the service list from a remote device. + * + * @since 2.0 + * @privilege http://tizen.org/privilege/bluetooth.gap + * + * @return An error code + * @param[in] pairedDevice A remote device that is already paired with the local device + * @exception E_SUCCESS The method is successful. + * @exception E_IN_PROGRESS The retrieving is in progress. + * @exception E_INVALID_OPERATION The current state of the instance prohibits the execution of this + * operation. @n + * For example, the discovery is in progress. + * @exception E_NOT_PAIRED The input device is not found in the paired device list. + * @exception E_PRIVILEGE_DENIED The application does not have the privilege to call this method. + * @exception E_SYSTEM A system error has occurred. + * @remarks The target remote device should be a paired device. + * @see IBluetoothDeviceEventListener::OnBluetoothServiceListReceived() + */ + result RetrieveServiceList(const BluetoothDevice& pairedDevice); + + /** + * Pairs with the specified remote device. + * + * @since 2.0 + * @privilege http://tizen.org/privilege/bluetooth.gap + * + * @return An error code + * @param[in] remoteDevice The remote %Bluetooth device to pair with + * @exception E_SUCCESS The method is successful. + * @exception E_INVALID_OPERATION The current state of the instance prohibits the execution of this + * operation. @n + * For example, the %Bluetooth is not activated. + * @exception E_DEVICE_BUSY The device cannot be approached because other operation is in progress. + * @exception E_PRIVILEGE_DENIED The application does not have the privilege to call this method. + * @exception E_SYSTEM A system error has occurred. + * @remarks IBluetoothDeviceEventListener::OnBluetoothPaired() is called if the pairing is successful, @n + * IBluetoothDeviceEventListener::OnBluetoothPairingFailed() if the pairing has failed. + */ + result Pair(const BluetoothDevice& remoteDevice); + + /** + * Stops the pairing process. + * + * @since 2.0 + * @privilege http://tizen.org/privilege/bluetooth.gap + * + * @return An error code + * @exception E_SUCCESS The method is successful. + * @exception E_INVALID_OPERATION The current state of the instance prohibits the execution of this + * operation. @n + * For example, the pairing process is not in progress. + * @exception E_IN_PROGRESS The termination of the pairing process is in progress. + * @exception E_PRIVILEGE_DENIED The application does not have the privilege to call this method. + * @exception E_SYSTEM A system error has occurred. + * @remarks If the canceling of the pairing process is successful, + * IBluetoothDeviceEventListener::OnBluetoothPairingFailed() is called with E_OPERATION_CANCELED. + */ + result CancelPair(void); + + /** + * Unpairs with the paired device. + * + * @since 2.0 + * @privilege http://tizen.org/privilege/bluetooth.gap + * + * @return An error code + * @param[in] pairedDevice The paired device to unpair + * @exception E_SUCCESS The method is successful. + * @exception E_INVALID_OPERATION The current state of the instance prohibits the execution of this + * operation. @n + * For example, the %Bluetooth is not activated, or retrieving the service + * list is in progress. + * @exception E_NOT_PAIRED The input device is not found in the paired device list. + * @exception E_PRIVILEGE_DENIED The application does not have the privilege to call this method. + * @exception E_SYSTEM A system error has occurred. + * @remarks The process of unpairing is to remove the specified device from the paired device list. No + * notification is transmitted to the remote device. @n + * This method is synchronous. Only when the result of this method is E_SUCCESS, the unpaired event is + * fired. + * @see IBluetoothDeviceEventListener::OnBluetoothUnpaired() + */ + result Unpair(const BluetoothDevice& pairedDevice); + +private: + // + // The implementation of this copy constructor is intentionally blank and declared as private to prohibit copying + // of objects. + // + BluetoothManager(const BluetoothManager& value); + // + // The implementation of this copy assignment operator is intentionally blank and declared as private to prohibit + // copying of objects. + // + BluetoothManager& operator =(const BluetoothManager& value); + +private: + _BluetoothManagerImpl* __pImpl; + + friend class _BluetoothManagerImpl; + +}; // BluetoothManager + +} } } +#endif // _FNET_BT_BLUETOOTH_MANAGER_H_ diff --git a/inc/FNetBtBluetoothOppClient.h b/inc/FNetBtBluetoothOppClient.h new file mode 100755 index 0000000..a0d5312 --- /dev/null +++ b/inc/FNetBtBluetoothOppClient.h @@ -0,0 +1,179 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +/** + * @file FNetBtBluetoothOppClient.h + * @brief This is the header file for the %BluetoothOppClient class. + * + * This header file contains the declarations of the %BluetoothOppClient class. + */ +#ifndef _FNET_BT_BLUETOOTH_OPP_CLIENT_H_ +#define _FNET_BT_BLUETOOTH_OPP_CLIENT_H_ + +#include +#include + +namespace Tizen { namespace Base +{ +class String; +} } + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +// forward declarations +class BluetoothDevice; +class IBluetoothOppClientEventListener; +class _BluetoothOppClientImpl; + +/** + * @class BluetoothOppClient + * @brief This class provides methods to handle the %Bluetooth Object Push Profile (OPP) client, such as the + * outgoing connection requests. + * + * @since 2.0 + * + * The %BluetoothOppClient class provides methods to handle the %Bluetooth Object Push Profile (OPP) client, such as the outgoing + * connection requests. + * @n + * For more information on the class features, see + * Bluetooth Guide. + */ +class _OSP_EXPORT_ BluetoothOppClient + : public Tizen::Base::Object +{ +public: + /** + * The object is not fully constructed after this constructor is called. For full construction, the Construct() method + * must be called right after calling this constructor. + * + * @since 2.0 + */ + BluetoothOppClient(void); + + /** + * This destructor overrides Tizen::Base::Object::~Object(). + * + * @since 2.0 + */ + virtual ~BluetoothOppClient(void); + + /** + * Constructs and initializes this instance of %BluetoothOppClient with the specified listener. + * + * @since 2.0 + * + * @return An error code + * @param[in] listener The event listener for the OPP client + * @exception E_SUCCESS The method is successful. + * @exception E_OUT_OF_MEMORY The memory is insufficient. + * @exception E_UNSUPPORTED_OPERATION This operation is not supported. + * @exception E_SYSTEM A system error has occurred. + */ + result Construct(IBluetoothOppClientEventListener& listener); + + /** + * Pushes a file to a remote OPP server. @n + * The file transfer starts when the OPP server accepts the request. + * + * @if OSPCOMPAT + * @brief [Compatibility] + * @endif + * @since 2.0 + * @if OSPCOMPAT + * @compatibility This method has compatibility issues@n + * For more information, see @ref CompIoPathPage "here". + * @endif + * @privilege http://tizen.org/privilege/bluetooth.opp + * + * @return An error code + * @param[in] remoteDevice The remote OPP server + * @param[in] filePath The path of the source file + * @exception E_SUCCESS The method is successful. + * @exception E_INVALID_STATE This instance is in an invalid state. @n + * For example, %Bluetooth is not activated. + * @exception E_IN_PROGRESS The push process is in progress. + * @exception E_PRIVILEGE_DENIED The application does not have the privilege to call this method. + * @exception E_SERVICE_UNAVAILABLE The OPP service is unavailable. + * @exception E_INACCESSIBLE_PATH The specified @c filePath is inaccessible. + * @exception E_REMOTE_DEVICE_NOT_FOUND The input device is not found. @n + * This exception is currently not in use. + * @exception E_FAILURE The method has failed. + * @see IBluetoothOppServerEventListener::OnOppPushRequested() + * @remarks If the local device is not paired with the specified target device, the pairing process starts + * internally before the push request is sent. + */ + result PushFile(const BluetoothDevice& remoteDevice, const Tizen::Base::String& filePath); + + /** + * Cancels the file push request in progress. @n + * If this method is called before the OPP server accepts the push request, the + * IBluetoothOppClientEventListener::OnOppPushResponded() method is called and the exception E_SYSTEM is thrown. @n + * If this method is called during the file transfer, the IBluetoothOppClientEventListener::OnOppTransferDone() + * method is called with @c isCompleted as @c false. + * + * @since 2.0 + * @privilege http://tizen.org/privilege/bluetooth.opp + * + * @return An error code + * @exception E_SUCCESS The method is successful. + * @exception E_INVALID_STATE This instance is in an invalid state. @n + * For example, %Bluetooth is not activated. + * @exception E_INVALID_OPERATION The current state of the instance prohibits the execution of the specified + * operation. @n + * For example, the push request is not sent or accepted by a remote device. + * @exception E_PRIVILEGE_DENIED The application does not have the privilege to call this method. + * @exception E_FAILURE The method has failed. + * @see IBluetoothOppClientEventListener::OnOppPushResponded() + * @see IBluetoothOppClientEventListener::OnOppTransferDone() + */ + result CancelPush(void); + + /** + * Sets the minimum interval of invocation of IBluetoothOppClientEventListener::OnOppTransferInProgress() in + * percentage. @n + * The default value is @c 5. + * + * @since 2.0 + * + * @return An error code + * @param[in] percent The minimum period of progress interval as a percentage value + * @exception E_SUCCESS The method is successful. + * @exception E_OUT_OF_RANGE The value of an argument is outside the valid range defined by the method. + * @see IBluetoothOppClientEventListener::OnOppTransferInProgress() + */ + result SetMinProgressInterval(int percent); + +private: + // + // The implementation of this copy constructor is intentionally blank and declared as private to prohibit copying + // of objects. + // + BluetoothOppClient(const BluetoothOppClient& value); + // + // The implementation of this copy assignment operator is intentionally blank and declared as private to prohibit + // copying of objects. + // + BluetoothOppClient& operator =(const BluetoothOppClient& value); + +private: + _BluetoothOppClientImpl* __pImpl; + +}; // BluetoothOppClient + +} } } +#endif // _FNET_BT_BLUETOOTH_OPP_CLIENT_H_ diff --git a/inc/FNetBtBluetoothOppServer.h b/inc/FNetBtBluetoothOppServer.h new file mode 100755 index 0000000..d0ed262 --- /dev/null +++ b/inc/FNetBtBluetoothOppServer.h @@ -0,0 +1,257 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +/** + * @file FNetBtBluetoothOppServer.h + * @brief This is the header file for the %BluetoothOppServer class. + * + * This header file contains the declarations of the %BluetoothOppServer class. + */ +#ifndef _FNET_BT_BLUETOOTH_OPP_SERVER_H_ +#define _FNET_BT_BLUETOOTH_OPP_SERVER_H_ + +#include +#include + +namespace Tizen { namespace Base +{ +class String; +} } + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +// forward declarations +class IBluetoothOppServerEventListener; +class _BluetoothOppServerImpl; + +/** + * @class BluetoothOppServer + * @brief This class provides methods to handle the %Bluetooth Object Push Profile (OPP) server, such as the + * incoming connection requests. + * + * @since 2.0 + * + * The %BluetoothOppServer class provides methods to handle the %Bluetooth Object Push Profile (OPP) server, such as the incoming + * connection requests. + * + * For more information on the class features, see + * Bluetooth Guide. + */ +class _OSP_EXPORT_ BluetoothOppServer + : public Tizen::Base::Object +{ +public: + /** + * The object is not fully constructed after this constructor is called. For full construction, the Construct() + * method must be called right after calling this constructor. + * + * @since 2.0 + */ + BluetoothOppServer(void); + + /** + * This destructor overrides Tizen::Base::Object::~Object(). + * + * @since 2.0 + */ + virtual ~BluetoothOppServer(void); + + /** + * Constructs and initializes this instance of %BluetoothOppServer with the specified listener. + * + * @since 2.0 + * + * @return An error code + * @param[in] listener The event listener for the OPP server + * @exception E_SUCCESS The method is successful. + * @exception E_OUT_OF_MEMORY The memory is insufficient. + * @exception E_UNSUPPORTED_OPERATION This operation is not supported. + * @exception E_SYSTEM A system error has occurred. + */ + result Construct(IBluetoothOppServerEventListener& listener); + + /** + * Accepts a push request from a remote OPP client. @n + * This method starts the file transfer. + * + * @since 2.0 + * @privilege http://tizen.org/privilege/bluetooth.opp + * + * @return An error code + * @exception E_SUCCESS The method is successful. + * @exception E_INVALID_STATE This instance is in an invalid state. @n + * For example, this instance has not been constructed as yet or %Bluetooth is + * not activated. + * @exception E_INVALID_OPERATION The current state of the instance prohibits the execution of the specified + * operation. @n + * For example, the service is not started yet or a push request is not + * received from a remote device. + * @exception E_PRIVILEGE_DENIED The application does not have the privilege to call this method. + * @exception E_FAILURE The method has failed. + * @see IBluetoothOppClientEventListener::OnOppPushResponded() + */ + result AcceptPush(void); + + /** + * Rejects a push request from a remote OPP client. + * + * @since 2.0 + * @privilege http://tizen.org/privilege/bluetooth.opp + * + * @return An error code + * @exception E_SUCCESS The method is successful. + * @exception E_INVALID_STATE This instance is in an invalid state. @n + * For example, this instance has not been constructed as yet or %Bluetooth is + * not activated. + * @exception E_INVALID_OPERATION The current state of the instance prohibits the execution of the specified + * operation. @n + * For example, the service is not started yet or a push request is not + * received from a remote device. + * @exception E_PRIVILEGE_DENIED The application does not have the privilege to call this method. + * @exception E_FAILURE The method has failed. + * @see IBluetoothOppClientEventListener::OnOppPushResponded() + */ + result RejectPush(void); + + /** + * Sets the destination path of the file to be received. + * + * @if OSPCOMPAT + * @brief [Compatibility] + * @endif + * @since 2.0 + * @if OSPCOMPAT + * @compatibility This method has compatibility issues. @n + * For more information, see @ref CompIoPathPage "here". + * + * @endif + * @return An error code + * @param[in] dstPath The new destination file path + * @exception E_SUCCESS The method is successful. + * @exception E_INVALID_OPERATION The current state of the instance prohibits the execution of the specified + * operation. @n + * For example, trying to change the path on Push transition is prohibited. + * @exception E_INACCESSIBLE_PATH The specified @c dstPath is inaccessible. + * @exception E_FAILURE The method has failed. + */ + result SetDestinationPath(const Tizen::Base::String& dstPath); + + /** + * Starts the OPP service and associates a listener with it. + * + * @if OSPCOMPAT + * @brief [Compatibility] + * @endif + * @since 2.0 + * @if OSPCOMPAT + * @compatibility This method has compatibility issues. @n + * For more information, see @ref CompIoPathPage "here". + * @endif + * @privilege http://tizen.org/privilege/bluetooth.opp + * + * @return An error code + * @param[in] dstPath The new destination file path + * @exception E_SUCCESS The method is successful. + * @exception E_INVALID_STATE This instance is in an invalid state. @n + * For example, %Bluetooth is not activated. + * @exception E_IN_PROGRESS The service has already started. + * @exception E_PRIVILEGE_DENIED The application does not have the privilege to call this method. + * @exception E_SERVICE_UNAVAILABLE The OPP service is unavailable. + * @exception E_INACCESSIBLE_PATH The specified @c dstPath is inaccessible. + * @exception E_INVALID_OPERATION The current state of the instance prohibits the execution of the specified + * operation. @n + * For example, The stop process is in progress. + * @exception E_FAILURE The method has failed. + */ + result StartService(const Tizen::Base::String& dstPath); + + /** + * Stops the OPP service. @n + * This method cancels the file transfer before stopping the service. + * + * @since 2.0 + * @privilege http://tizen.org/privilege/bluetooth.opp + * + * @return An error code + * @exception E_SUCCESS The method is successful. + * @exception E_INVALID_STATE This instance is in an invalid state. @n + * For example, %Bluetooth is not activated. + * @exception E_INVALID_OPERATION The current state of the instance prohibits the execution of the specified + * operation. @n + * For example, the service is not started as yet. + * @exception E_PRIVILEGE_DENIED The application does not have the privilege to call this method. + * @exception E_IN_PROGRESS The stop process is in progress. + * @exception E_FAILURE The method has failed. + */ + result StopService(void); + + /** + * Stops the file transfer in progress which was started by the client. @n + * If this method is called during the file transfer, the IBluetoothOppServerEventListener::OnOppTransferDone() + * method is called with @c isCompleted as @c false. + * + * @since 2.0 + * @privilege http://tizen.org/privilege/bluetooth.opp + * + * @return An error code + * @exception E_SUCCESS The method is successful. + * @exception E_INVALID_STATE This instance is in an invalid state. @n + * For example, %Bluetooth is not activated. + * @exception E_INVALID_OPERATION The current state of the instance prohibits the execution of the specified + * operation. @n + * For example, the file transfer is not in progress. + * @exception E_PRIVILEGE_DENIED The application does not have the privilege to call this method. + * @exception E_OPERATION_FAILED The operation has failed. + * @see IBluetoothOppServerEventListener::OnOppTransferDone() + */ + result StopTransfer(void); + + /** + * Sets the minimum interval of invocation of IBluetoothOppServerEventListener::OnOppTransferInProgress() in + * percentage. @n + * The default value is @c 5. + * + * @since 2.0 + * + * @return An error code + * @param[in] percent The minimum period of progress interval as a percentage value + * @exception E_SUCCESS The method is successful. + * @exception E_OUT_OF_RANGE The value of the argument is outside the valid range defined by the method. + * @see IBluetoothOppServerEventListener::OnOppTransferInProgress() + */ + result SetMinProgressInterval(int percent); + +private: + // + // The implementation of this copy constructor is intentionally blank and declared as private to prohibit copying + // of objects. + // + BluetoothOppServer(const BluetoothOppServer& value); + // + // The implementation of this copy assignment operator is intentionally blank and declared as private to prohibit + // copying of objects. + // + BluetoothOppServer& operator =(const BluetoothOppServer& value); + +private: + _BluetoothOppServerImpl* __pImpl; + +}; // BluetoothOppServer + +} } } +#endif // _FNET_BT_BLUETOOTH_OPP_SERVER_H_ diff --git a/inc/FNetBtBluetoothSppAcceptor.h b/inc/FNetBtBluetoothSppAcceptor.h new file mode 100755 index 0000000..0983502 --- /dev/null +++ b/inc/FNetBtBluetoothSppAcceptor.h @@ -0,0 +1,257 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +/** + * @file FNetBtBluetoothSppAcceptor.h + * @brief This is the header file for the %BluetoothSppAcceptor class. + * + * This header file contains the declarations of the %BluetoothSppAcceptor class. + */ +#ifndef _FNET_BT_BLUETOOTH_SPP_ACCEPTOR_H_ +#define _FNET_BT_BLUETOOTH_SPP_ACCEPTOR_H_ + +#include +#include +#include +#include + +namespace Tizen { namespace Base +{ +class ByteBuffer; +} } + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +// forward declarations +class IBluetoothSppAcceptorEventListener; +class _BluetoothSppAcceptorImpl; + +/** + * @class BluetoothSppAcceptor + * @brief This class provides the methods to handle the %Bluetooth Serial Port Profile (SPP) acceptor, such as an + * incoming connection request. + * @since 2.0 + * + * The %BluetoothSppAcceptor class provides the methods to handle the %Bluetooth Serial Port Profile (SPP) acceptor, such as an + * incoming connection request. + * + * For more information on the class features, see + * Bluetooth Guide. + */ +class _OSP_EXPORT_ BluetoothSppAcceptor + : public Tizen::Base::Object +{ +public: + /** + * The object is not fully constructed after this constructor is called. For full construction, the Construct() + * method must be called right after calling this constructor. + * + * @since 2.0 + */ + BluetoothSppAcceptor(void); + + /** + * This destructor overrides Tizen::Base::Object::~Object(). + * + * @since 2.0 + */ + virtual ~BluetoothSppAcceptor(void); + + /** + * Initializes this instance of %BluetoothSppAcceptor with the specified listener. + * + * @since 2.0 + * + * @return An error code + * @param[in] listener The event listener for SPP acceptor + * @exception E_SUCCESS The method is successful. + * @exception E_OUT_OF_MEMORY The memory is insufficient. + * @exception E_UNSUPPORTED_OPERATION This operation is not supported. + * @exception E_SYSTEM A system error has occurred. + */ + result Construct(IBluetoothSppAcceptorEventListener& listener); + + /** + * Accepts a connection request from a remote SPP initiator. @n + * This method establishes a connection. + * + * @since 2.0 + * @privilege http://tizen.org/privilege/bluetooth.spp + * + * @return An error code + * @exception E_SUCCESS The method is successful. + * @exception E_INVALID_STATE This instance is in an invalid state. @n + * For example, this instance has not been constructed as yet or %Bluetooth is + * not activated. + * @exception E_INVALID_OPERATION The current state of the instance prohibits the execution of the specified + * operation. @n + * For example, the service is not started yet or the connection request is + * not yet received from a remote device. + * @exception E_PRIVILEGE_DENIED The application does not have the privilege to call this method. + * @exception E_FAILURE The method has failed. + * @see IBluetoothSppInitiatorEventListener::OnSppConnectionResponded() + */ + result AcceptConnection(void); + + /** + * Rejects a connection request from a remote SPP initiator. + * + * @since 2.0 + * @privilege http://tizen.org/privilege/bluetooth.spp + * + * @return An error code + * @exception E_SUCCESS The method is successful. + * @exception E_INVALID_STATE This instance is in an invalid state. @n + * For example, this instance has not been constructed as yet or %Bluetooth is + * not activated. + * @exception E_INVALID_OPERATION The current state of the instance prohibits the execution of the specified + * operation. @n + * For example, the service is not started yet or the connection request is + * not yet received from a remote device. + * @exception E_PRIVILEGE_DENIED The application does not have the privilege to call this method. + * @exception E_FAILURE The method has failed. + * @see IBluetoothSppInitiatorEventListener::OnSppConnectionResponded() + */ + result RejectConnection(void); + + /** + * Starts the SPP service with the default service UUID - BT_SVC_UUID_SPP. + * + * @since 2.0 + * @privilege http://tizen.org/privilege/bluetooth.spp + * + * @return An error code + * @exception E_SUCCESS The method is successful. + * @exception E_INVALID_STATE This instance is in an invalid state. @n + * For example, this instance has not been constructed as yet or %Bluetooth is + * not activated. + * @exception E_IN_PROGRESS The service has already started. + * @exception E_ALREADY_CONNECTED The connection with an SPP initiator has already been established. + * @exception E_PRIVILEGE_DENIED The application does not have the privilege to call this method. + * @exception E_SERVICE_UNAVAILABLE The SPP service with the specified UUId is unavailable. + * @exception E_FAILURE The method has failed. + */ + result StartService(void); + + /** + * Starts the SPP service with the specified service UUID. + * + * @since 2.0 + * @privilege http://tizen.org/privilege/bluetooth.spp + * + * @return An error code + * @param[in] serviceUuid The UUID of SPP service + * @exception E_SUCCESS The method is successful. + * @exception E_INVALID_STATE This instance is in an invalid state. @n + * For example, this instance has not been constructed as yet or %Bluetooth is + * not activated. + * @exception E_INVALID_ARG The specified input parameter is invalid. + * @exception E_IN_PROGRESS The service has already started. + * @exception E_ALREADY_CONNECTED The connection with an SPP initiator has already been established. + * @exception E_PRIVILEGE_DENIED The application does not have the privilege to call this method. + * @exception E_SERVICE_UNAVAILABLE The SPP service with the specified UUId is unavailable. + * @exception E_FAILURE The method has failed. + */ + result StartService(const Tizen::Base::UuId& serviceUuid); + + /** + * Stops the SPP service. @n + * This method disconnects the current connection before stopping the service. + * + * @since 2.0 + * @privilege http://tizen.org/privilege/bluetooth.spp + * + * @return An error code + * @exception E_SUCCESS The method is successful. + * @exception E_INVALID_STATE This instance is in an invalid state. @n + * For example, this instance has not been constructed as yet or %Bluetooth is + * not activated. + * @exception E_INVALID_OPERATION The current state of the instance prohibits the execution of the specified + * operation. @n + * For example, the service is not started yet. + * @exception E_PRIVILEGE_DENIED The application does not have the privilege to call this method. + * @exception E_FAILURE The method has failed. + */ + result StopService(void); + + /** + * Disconnects the current connection. + * + * @since 2.0 + * @privilege http://tizen.org/privilege/bluetooth.spp + * + * @return An error code + * @exception E_SUCCESS The method is successful. + * @exception E_INVALID_STATE This instance is in an invalid state. @n + * For example, this instance has not been constructed as yet or %Bluetooth is + * not activated. + * @exception E_INVALID_OPERATION The current state of the instance prohibits the execution of the specified + * operation. @n + * For example, the service is not started yet or a connection with a remote + * device is not established. + * @exception E_PRIVILEGE_DENIED The application does not have the privilege to call this method. + * @exception E_FAILURE The method has failed. + * @see IBluetoothSppAcceptorEventListener::OnSppDisconnected() + * @see IBluetoothSppInitiatorEventListener::OnSppDisconnected() + */ + result Disconnect(void); + + /** + * Sends the data. + * + * @since 2.0 + * @privilege http://tizen.org/privilege/bluetooth.spp + * + * @return An error code + * @param[in] buffer The data to send + * @exception E_SUCCESS The method is successful. + * @exception E_INVALID_STATE This instance is in an invalid state. @n + * For example, this instance has not been constructed as yet or %Bluetooth is + * not activated. + * @exception E_INVALID_OPERATION The current state of the instance prohibits the execution of the specified + * operation. @n + * For example, the service is not started yet or a connection with a remote + * device is not established. + * @exception E_INVALID_ARG The specified @c buffer is empty. + * @exception E_SYSTEM A system error has occurred. + * @exception E_PRIVILEGE_DENIED The application does not have the privilege to call this method. + * @exception E_FAILURE The method has failed. + * @remarks The size of the buffer should not exceed @c 1000 bytes. + * @see IBluetoothSppInitiatorEventListener::OnSppDataReceived() + */ + result SendData(const Tizen::Base::ByteBuffer& buffer); + +private: + // + // The implementation of this copy constructor is intentionally blank and declared as private to prohibit copying + // of objects. + // + BluetoothSppAcceptor(const BluetoothSppAcceptor& value); + // + // The implementation of this copy assignment operator is intentionally blank and declared as private to prohibit + // copying of objects. + // + BluetoothSppAcceptor& operator =(const BluetoothSppAcceptor& value); + +private: + _BluetoothSppAcceptorImpl* __pImpl; + +}; // BluetoothSppAcceptor + +} } } +#endif // _FNET_BT_BLUETOOTH_SPP_ACCEPTOR_H_ diff --git a/inc/FNetBtBluetoothSppInitiator.h b/inc/FNetBtBluetoothSppInitiator.h new file mode 100755 index 0000000..da159e0 --- /dev/null +++ b/inc/FNetBtBluetoothSppInitiator.h @@ -0,0 +1,214 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +/** + * @file FNetBtBluetoothSppInitiator.h + * @brief This is the header file for the %BluetoothSppInitiator class. + * + * This header file contains the declarations of the %BluetoothSppInitiator class. + */ +#ifndef _FNET_BT_BLUETOOTH_SPP_INITIATOR_H_ +#define _FNET_BT_BLUETOOTH_SPP_INITIATOR_H_ + +#include +#include +#include +#include + +namespace Tizen { namespace Base +{ +class ByteBuffer; +} } + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +// forward declarations +class BluetoothDevice; +class IBluetoothSppInitiatorEventListener; +class _BluetoothSppInitiatorImpl; + +/** + * @class BluetoothSppInitiator + * @brief This class provides the methods to handle the %Bluetooth Serial Port Profile (SPP) initiator, such as the + * outgoing connection requests. + * @since 2.0 + * + * The %BluetoothSppInitiator class provides the methods to handle the %Bluetooth Serial Port Profile (SPP) initiator, such as + * the outgoing connection requests. + * + * For more information on the class features, see + * Bluetooth Guide. + */ +class _OSP_EXPORT_ BluetoothSppInitiator + : public Tizen::Base::Object +{ +public: + /** + * The object is not fully constructed after this constructor is called. For full construction, the Construct() + * method must be called right after calling this constructor. + * + * @since 2.0 + */ + BluetoothSppInitiator(void); + + /** + * This destructor overrides Tizen::Base::Object::~Object(). + * + * @since 2.0 + */ + virtual ~BluetoothSppInitiator(void); + + /** + * Constructs and initializes this instance of %BluetoothSppInitiator with the specified listener. + * + * @since 2.0 + * + * @return An error code + * @param[in] listener The event listener for the SPP initiator + * @exception E_SUCCESS The method is successful. + * @exception E_OUT_OF_MEMORY The memory is insufficient. + * @exception E_UNSUPPORTED_OPERATION This operation is not supported. + * @exception E_SYSTEM A system error has occurred. + */ + result Construct(IBluetoothSppInitiatorEventListener& listener); + + /** + * Connects to a remote SPP acceptor with the default service UUID - BT_SVC_UUID_SPP. @n + * This method establishes a connection after the SPP acceptor accepts the request. + * + * @since 2.0 + * @privilege http://tizen.org/privilege/bluetooth.spp + * + * @return An error code + * @param[in] remoteDevice The remote device to connect + * @exception E_SUCCESS The method is successful. + * @exception E_INVALID_STATE This instance is in an invalid state. @n + * For example, this instance has not been constructed as yet or + * %Bluetooth is not activated. + * @exception E_IN_PROGRESS The connection process is in progress. + * @exception E_ALREADY_CONNECTED The connection with an SPP acceptor has already been established. + * @exception E_PRIVILEGE_DENIED The application does not have the privilege to call this method. + * @exception E_SERVICE_UNAVAILABLE The SPP connection is unavailable. + * @exception E_REMOTE_DEVICE_NOT_FOUND The input device is not found. @n + * This exception is currently not in use. + * @exception E_FAILURE The method has failed. + * @see IBluetoothSppAcceptorEventListener::OnSppConnectionRequested() + * @remarks If the local device is not paired with the specified target device, the pairing process starts + * internally before the connect request is sent. + */ + result Connect(const BluetoothDevice& remoteDevice); + + /** + * Connects to a remote SPP acceptor with the specified service UUID. @n + * This method establishes a connection after the SPP acceptor accepts the request. + * + * @since 2.0 + * @privilege http://tizen.org/privilege/bluetooth.spp + * + * @return An error code + * @param[in] remoteDevice The remote device to connect + * @param[in] serviceUuid The UUID of SPP service to connect + * @exception E_SUCCESS The method is successful. + * @exception E_INVALID_STATE This instance is in an invalid state. @n + * For example, this instance has not been constructed as yet or + * %Bluetooth is not activated. + * @exception E_INVALID_ARG A specified input parameter is invalid. + * @exception E_IN_PROGRESS The connection process is in progress. + * @exception E_ALREADY_CONNECTED The connection with an SPP acceptor has already been established. + * @exception E_PRIVILEGE_DENIED The application does not have the privilege to call this method. + * @exception E_SERVICE_UNAVAILABLE The SPP connection is unavailable. + * @exception E_REMOTE_DEVICE_NOT_FOUND The input device is not found. @n + * This exception is currently not in use. + * @exception E_FAILURE The method has failed. + * @see IBluetoothSppAcceptorEventListener::OnSppConnectionRequested() + * @remarks If the local device is not paired with the specified target device, the pairing process starts + * internally before the connect request is sent. + */ + result Connect(const BluetoothDevice& remoteDevice, const Tizen::Base::UuId& serviceUuid); + + /** + * Disconnects the current connection. @n + * If this method is called before the SPP acceptor accepts the connection request, the + * IBluetoothSppInitiatorEventListener::OnSppConnectionResponded() and E_SYSTEM is thrown. @n + * If this method is called on connection, the IBluetoothSppInitiatorEventListener::OnSppDisconnected() and + * E_SUCCESS is thrown. + * + * @since 2.0 + * @privilege http://tizen.org/privilege/bluetooth.spp + * + * @return An error code + * @exception E_SUCCESS The method is successful. + * @exception E_INVALID_STATE This instance is in an invalid state. @n + * For example, this instance has not been constructed as yet or %Bluetooth is + * not activated. + * @exception E_INVALID_OPERATION The current state of the instance prohibits the execution of the specified + * operation. @n + * For example, the connection request is not sent or a connection with a + * remote device is not established yet. + * @exception E_PRIVILEGE_DENIED The application does not have the privilege to call this method. + * @exception E_FAILURE The method has failed. + * @see IBluetoothSppInitiatorEventListener::OnSppConnectionResponded() + * @see IBluetoothSppInitiatorEventListener::OnSppDisconnected() + * @see IBluetoothSppAcceptorEventListener::OnSppDisconnected() + */ + result Disconnect(void); + + /** + * Sends the specified data. + * + * @since 2.0 + * @privilege http://tizen.org/privilege/bluetooth.spp + * + * @return An error code + * @param[in] buffer The data to send + * @exception E_SUCCESS The method is successful. + * @exception E_INVALID_STATE This instance is in an invalid state. @n + * For example, this instance has not been constructed as yet or %Bluetooth is + * not activated. + * @exception E_INVALID_OPERATION The current state of the instance prohibits the execution of the specified + * operation. @n + * For example, the connection request is not sent or a connection with a + * remote device is not established yet. + * @exception E_INVALID_ARG The argument has no data. + * @exception E_SYSTEM A system error has occurred. + * @exception E_PRIVILEGE_DENIED The application does not have the privilege to call this method. + * @exception E_FAILURE The method has failed. + * @remarks The size of the buffer should not exceed @c 1000 bytes. + * @see IBluetoothSppAcceptorEventListener::OnSppDataReceived() + */ + result SendData(const Tizen::Base::ByteBuffer& buffer); + +private: + // + // The implementation of this copy constructor is intentionally blank and declared as private to prohibit copying + // of objects. + // + BluetoothSppInitiator(const BluetoothSppInitiator& value); + // + // The implementation of this copy assignment operator is intentionally blank and declared as private to prohibit + // copying of objects. + // + BluetoothSppInitiator& operator =(const BluetoothSppInitiator& value); + +private: + _BluetoothSppInitiatorImpl* __pImpl; + +}; // BluetoothSppInitiator + +} } } +#endif // _FNET_BT_BLUETOOTH_SPP_INITIATOR_H_ diff --git a/inc/FNetBtBluetoothTypes.h b/inc/FNetBtBluetoothTypes.h new file mode 100755 index 0000000..b3e2fda --- /dev/null +++ b/inc/FNetBtBluetoothTypes.h @@ -0,0 +1,630 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +/** + * @file FNetBtBluetoothTypes.h + * @brief This is the header file for the enumerations in the Bluetooth namespace. + * + * This header file contains the declarations and descriptions of the enumerations in the Bluetooth namespace. + */ +#ifndef _FNET_BT_BLUETOOTH_TYPES_H_ +#define _FNET_BT_BLUETOOTH_TYPES_H_ + +#include + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +/** + * @if OSPDEPREC + * @enum BluetoothDeviceStateType + * Defines the states of the local %Bluetooth device. + * + * @brief [Deprecated] + * @deprecated This enum type is deprecated because the on/off states and the discoverable mode are not orthogonal. + * All the methods that use this enum type are also deprecated. Instead of using this enum type, it is + * recommended to use BluetoothManager::IsActivated() and the enum + * Bluetooth::BluetoothDiscoverableMode. + * @since 2.0 + * @endif + */ +enum BluetoothDeviceStateType +{ + BT_DEVICE_STATE_OFF, /**< The OFF state */ + BT_DEVICE_STATE_DISCOVERABLE, /**< The DISCOVERABLE state */ + BT_DEVICE_STATE_NOT_DISCOVERABLE /**< The NOT DISCOVERABLE state*/ +}; + +/** + * @enum BluetoothDiscoverableMode + * Defines the discoverable mode of the local %Bluetooth device. + * + * @since 2.0 + */ +enum BluetoothDiscoverableMode +{ + BT_DISC_MODE_NOT_DISCOVERABLE, /**< The mode NOT DISCOVERABLE by other devices */ + BT_DISC_MODE_DISCOVERABLE, /**< The mode DISCOVERABLE by other devices */ + BT_DISC_MODE_TIME_LIMITED_DISCOVERABLE /**< The mode DISCOVERABLE by other devices during a certain amount of time + * @b Since: @b 2.0 + */ +}; + +/** + * @enum BluetoothConnectionType + * Defines the %Bluetooth connection types. + * + * @since 2.0 + */ +enum BluetoothConnectionType +{ + BT_CONNECTION_GENERIC, /**< The GENERIC CONNECTION + * @if OSPDEPREC + * @deprecated This enumeration field is deprecated. @n + * @endif + */ + BT_CONNECTION_SPP_ACCEPTOR, /**< The SPP ACCEPTOR CONNECTION */ + BT_CONNECTION_SPP_INITIATOR, /**< The SPP INITIATOR CONNECTION */ + BT_CONNECTION_OPP_SERVER, /**< The OPP SERVER CONNECTION */ + BT_CONNECTION_OPP_CLIENT, /**< The OPP CLIENT CONNECTION */ + BT_CONNECTION_MAX +}; + +/** + * @enum BluetoothHealthDataChannelType + * Defines the transmission type of %BluetoothHealth data channel. + * + * @since 2.0 + */ +enum BluetoothHealthDataChannelType +{ + BT_HEALTH_DATA_CHANNEL_NONE, /**< The any type of data channel */ + BT_HEALTH_DATA_CHANNEL_RELIABLE, /**< The data channel type for transmitting data with the reliable manner of + * which the confidence in the exchange is at its highest (e.g. measurement + * and alert information) + */ + BT_HEALTH_DATA_CHANNEL_STREAMING /**< The data channel type for transmitting data when the timeliness of the + * delivery of each frame is more important than the reliable delivery of + * every frame (e.g. an ECG waveform, where low latency is critical) + */ +}; + +/** + * @enum BluetoothServiceClassType + * Defines the service class type (part of the class of the device), returned from the device discovery. + * + * @since 2.0 + */ +enum BluetoothServiceClassType +{ + BT_COD_SVC_LIMITED_DISCOVERABLE_MODE = 0x0020, /**< The LIMITED DISCOVERABLE MODE */ + BT_COD_SVC_POSITIONING = 0x0100, /**< The POSITIONING service class type */ + BT_COD_SVC_NETWORKING = 0x0200, /**< The NETWORKING service class type */ + BT_COD_SVC_RENDERING = 0x0400, /**< The RENDERING service class type */ + BT_COD_SVC_CAPTURING = 0x0800, /**< The CAPTURING service class type */ + BT_COD_SVC_OBJECT_TRANSFER = 0x1000, /**< The OBJECT TRANSFER service class type */ + BT_COD_SVC_AUDIO = 0x2000, /**< The AUDIO service class type */ + BT_COD_SVC_TELEPHONY = 0x4000, /**< The TELEPHONY service class type */ + BT_COD_SVC_INFORMATION = 0x8000, /**< The INFORMATION service class type */ + BT_COD_SVC_ALL = 0x01FF, /**< The ALL services class type */ + BT_COD_SVC_UNKNOWN = 0x0000 /**< The UNKNOWN service class type */ +}; + +/** + * @enum BluetoothMajorDeviceClassType + * Defines the major device class (part of the class of the device). + * + * @since 2.0 + */ +enum BluetoothMajorDeviceClassType +{ + BT_COD_MAJ_DEV_CLS_MISC = 0x00, /**< The MISC major device class type */ + BT_COD_MAJ_DEV_CLS_COMPUTER = 0x01, /**< The COMPUTER major device class type */ + BT_COD_MAJ_DEV_CLS_PHONE = 0x02, /**< The PHONE major device class type */ + BT_COD_MAJ_DEV_CLS_LAN_ACCESS_POINT = 0x03, /**< The LAN ACCESS POINT major device class type */ + BT_COD_MAJ_DEV_CLS_AUDIO = 0x04, /**< The AUDIO major device class type */ + BT_COD_MAJ_DEV_CLS_PERIPHERAL = 0x05, /**< The PERIPHERAL major device class type */ + BT_COD_MAJ_DEV_CLS_IMAGING = 0x06, /**< The IMAGING major device class type */ + BT_COD_MAJ_DEV_CLS_UNCLASSIFIED = 0x1F /**< The UNCLASSIFIED major device class type */ +}; + +/** + * @enum BluetoothMinorDeviceClassType + * Defines the minor device class (part of the class of the device). + * + * @since 2.0 + */ +enum BluetoothMinorDeviceClassType +{ + BT_COD_MIN_DEV_CLS_UNCLASSIFIED = 0x00, /**< The UNCLASSIFIED minor device class type */ + + BT_COD_MIN_DEV_CLS_DESKTOP_WORKSTATION = 0x04, /**< The DESKTOP WORKSTATION minor device class type */ + BT_COD_MIN_DEV_CLS_SERVER_CLASS_COMPUTER = 0x08, /**< The SERVER CLASS COMPUTER minor device class type */ + BT_COD_MIN_DEV_CLS_LAPTOP = 0x0C, /**< The LAPTOP minor device class type */ + BT_COD_MIN_DEV_CLS_HANDHELD_PC_OR_PDA = 0x10, /**< The HANDHELD PC OR PDA minor device class type */ + BT_COD_MIN_DEV_CLS_PALM_SIZED_PC_OR_PDA = 0x14, /**< The PALM SIZED PC OR PDA minor device class type */ + BT_COD_MIN_DEV_CLS_WEARABLE_COMPUTER = 0x18, /**< The WEARABLE COMPUTER minor device class type */ + + BT_COD_MIN_DEV_CLS_CELLULAR = 0x04, /**< The CELLULAR minor device class type */ + BT_COD_MIN_DEV_CLS_CORDLESS = 0x08, /**< The CORDLESS minor device class type */ + BT_COD_MIN_DEV_CLS_SMART_PHONE = 0x0C, /**< The SMART PHONE minor device class type */ + BT_COD_MIN_DEV_CLS_WIRED_MODEM_OR_VOICE_GATEWAY = 0x10, /**< The WIRED MODEM OR VOICE GATEWAY minor device class type */ + BT_COD_MIN_DEV_CLS_COMMON_ISDN_ACCESS = 0x14, /**< The COMMON ISDN ACCESS minor device class type */ + + BT_COD_MIN_DEV_CLS_FULLY_AVAILABLE = 0x04, /**< The FULLY AVAILABLE minor device class type */ + BT_COD_MIN_DEV_CLS_1_TO_17_PERCENT_UTILIZED = 0x20, /**< The 1_TO_17_PERCENT_UTILIZED minor device class type */ + BT_COD_MIN_DEV_CLS_17_TO_33_PERCENT_UTILIZED = 0x40, /**< The 17_TO_33_PERCENT_UTILIZED minor device class type */ + BT_COD_MIN_DEV_CLS_33_TO_50_PERCENT_UTILIZED = 0x60, /**< The 33_TO_50_PERCENT_UTILIZED minor device class type */ + BT_COD_MIN_DEV_CLS_50_to_67_PERCENT_UTILIZED = 0x80, /**< The 50_to_67_PERCENT_UTILIZED minor device class type */ + BT_COD_MIN_DEV_CLS_67_TO_83_PERCENT_UTILIZED = 0xA0, /**< The 67_TO_83_PERCENT_UTILIZED minor device class type */ + BT_COD_MIN_DEV_CLS_83_TO_99_PERCENT_UTILIZED = 0xC0, /**< The 83_TO_99_PERCENT_UTILIZED minor device class type */ + BT_COD_MIN_DEV_CLS_NO_SERVICE_AVAILABLE = 0xE0, /**< The NO SERVICE AVAILABLE minor device class type */ + + BT_COD_MIN_DEV_CLS_HEADSET_PROFILE = 0x04, /**< The HEADSET PROFILE minor device class type */ + BT_COD_MIN_DEV_CLS_HANDSFREE = 0x08, /**< The HANDSFREE minor device class type */ + BT_COD_MIN_DEV_CLS_SIM_CARD_READER = 0x18, /**< The SIM CARD READER minor device class type */ + +}; + +/** + * @enum BluetoothServiceType + * Defines the %Bluetooth service type. + * + * @since 2.0 + */ +enum BluetoothServiceType +{ + BT_SVC_RES_SERVICE = 0x00000001, /**< The Reserved service type */ + BT_SVC_SPP_SERVICE = 0x00000002, /**< The Serial port profile service type */ + BT_SVC_DUN_SERVICE = 0x00000004, /**< The Dial-up networking profile service type */ + BT_SVC_FAX_SERVICE = 0x00000008, /**< The Fax profile service type */ + BT_SVC_LAP_SERVICE = 0x00000010, /**< The LAN access profile service type */ + BT_SVC_HSP_SERVICE = 0x00000020, /**< The Headset profile service type */ + BT_SVC_HFP_SERVICE = 0x00000040, /**< The Hands-free profile service type */ + BT_SVC_OPP_SERVICE = 0x00000080, /**< The Object push service type */ + BT_SVC_FTP_SERVICE = 0x00000100, /**< The File transfer service type */ + BT_SVC_CTP_SERVICE = 0x00000200, /**< The Cordless Terminal service type */ + BT_SVC_ICP_SERVICE = 0x00000400, /**< The Intercom Terminal service type */ + BT_SVC_SYNC_SERVICE = 0x00000800, /**< The Synchronization service type */ + BT_SVC_BPP_SERVICE = 0x00001000, /**< The Print server service type */ + BT_SVC_BIP_SERVICE = 0x00002000, /**< The Basic Imaging service type */ + BT_SVC_PANU_SERVICE = 0x00004000, /**< The PAN User service type */ + BT_SVC_NAP_SERVICE = 0x00008000, /**< The PAN Network access point service type */ + BT_SVC_GN_SERVICE = 0x00010000, /**< The PAN Group Ad-hoc networks service type */ + BT_SVC_SAP_SERVICE = 0x00020000, /**< The SIM Access Profile service type */ + BT_SVC_A2DP_SERVICE = 0x00040000, /**< An advanced audio distribution service type */ + BT_SVC_AVRCP_SERVICE = 0x00080000, /**< An A/V remote control service type */ + BT_SVC_HID_SERVICE = 0x00100000, /**< The HID profile service type */ + BT_SVC_VDP_SERVICE = 0x00200000, /**< The VDP profile service type */ + BT_SVC_PBAP_SERVICE = 0x00400000, /**< The PhoneBook Access service type */ + BT_SVC_HSP_HS_SERVICE = 0x00800000, /**< The Headset service type */ + BT_SVC_HFP_HS_SERVICE = 0x01000000, /**< The Hands-free Headset service type */ + BT_SVC_HCRP_SERVICE = 0x02000000, /**< The Hardcopy cable replacement profile service type + * @b Since: @b 2.0 + */ + BT_SVC_DID_SERVICE = 0x04000000, /**< The device identification profile service type + * @b Since: @b 2.0 + */ + BT_SVC_HDP_SERVICE = 0x08000000, /**< The health device profile service type + * @b Since: @b 2.0 + */ + BT_SVC_MAP_SERVICE = 0x10000000, /**< The message access profile service type + * @b Since: @b 2.0 + */ + BT_SVC_ALL_SERVICE = 0x01FFFFFF, /**< The All-services-supported-by-BTA service type + * @if OSPDEPREC + * @deprecated This enumeration field is deprecated. + * @endif + + */ + BT_SVC_NONE = 0 /**< The No service or unknown service type */ +}; + +/** + * The serial port profile UUID (00001101-0000-1000-8000-00805F9B34FB). + * + * @since 2.0 + */ +_OSP_EXPORT_ extern const byte BT_SVC_UUID_SPP[]; + +/** + * The LAN access profile UUID (00001102-0000-1000-8000-00805F9B34FB). + * + * @since 2.0 + */ +_OSP_EXPORT_ extern const byte BT_SVC_UUID_LAP[]; + +/** + * The dial-up networking profile UUID (00001103-0000-1000-8000-00805F9B34FB). + * + * @since 2.0 + */ +_OSP_EXPORT_ extern const byte BT_SVC_UUID_DUN[]; + +/** + * The synchronization profile UUID (00001104-0000-1000-8000-00805F9B34FB). + * + * @since 2.0 + */ +_OSP_EXPORT_ extern const byte BT_SVC_UUID_SYNC[]; + +/** + * The object push profile UUID (00001105-0000-1000-8000-00805F9B34FB). + * + * @since 2.0 + */ +_OSP_EXPORT_ extern const byte BT_SVC_UUID_OPP[]; + +/** + * The file transfer profile UUID (00001106-0000-1000-8000-00805F9B34FB). + * + * @since 2.0 + */ +_OSP_EXPORT_ extern const byte BT_SVC_UUID_FTP[]; + +/** + * The synchronization profile UUID (00001107-0000-1000-8000-00805F9B34FB). + * + * @since 2.0 + */ +_OSP_EXPORT_ extern const byte BT_SVC_UUID_SYNC_COMMAND[]; + +/** + * The headset profile UUID (00001108-0000-1000-8000-00805F9B34FB). + * + * @since 2.0 + */ +_OSP_EXPORT_ extern const byte BT_SVC_UUID_HSP[]; + +/** + * The cordless telephony profile UUID (00001109-0000-1000-8000-00805F9B34FB). + * + * @since 2.0 + */ +_OSP_EXPORT_ extern const byte BT_SVC_UUID_CTP[]; + +/** + * The advanced audio distribution profile source UUID (0000110A-0000-1000-8000-00805F9B34FB). + * + * @since 2.0 + */ +_OSP_EXPORT_ extern const byte BT_SVC_UUID_A2DP_SOURCE[]; + +/** + * The advanced audio distribution profile - sink UUID (0000110B-0000-1000-8000-00805F9B34FB). + * + * @since 2.0 + */ +_OSP_EXPORT_ extern const byte BT_SVC_UUID_A2DP_SINK[]; + +/** + * The audio/video remote control profile - target UUID (0000110C-0000-1000-8000-00805F9B34FB). + * + * @since 2.0 + */ +_OSP_EXPORT_ extern const byte BT_SVC_UUID_AVRCP_TARGET[]; + +/** + * The advanced audio distribution profile UUID (0000110D-0000-1000-8000-00805F9B34FB). + * + * @since 2.0 + */ +_OSP_EXPORT_ extern const byte BT_SVC_UUID_A2DP[]; + +/** + * The audio/video remote control profile UUID (0000110E-0000-1000-8000-00805F9B34FB). + * + * @since 2.0 + */ +_OSP_EXPORT_ extern const byte BT_SVC_UUID_AVRCP[]; + +/** + * The audio/video remote control profile - controller UUID (0000110F-0000-1000-8000-00805F9B34FB). + * + * @since 2.0 + */ +_OSP_EXPORT_ extern const byte BT_SVC_UUID_AVRCP_CONTROLLER[]; + +/** + * The intercom profile UUID (00001110-0000-1000-8000-00805F9B34FB). + * + * @since 2.0 + */ +_OSP_EXPORT_ extern const byte BT_SVC_UUID_ICP[]; + +/** + * The fax profile UUID (00001111-0000-1000-8000-00805F9B34FB). + * + * @since 2.0 + */ +_OSP_EXPORT_ extern const byte BT_SVC_UUID_FAX[]; + +/** + * The headset profile audio gateway UUID (00001112-0000-1000-8000-00805F9B34FB). + * + * @since 2.0 + */ +_OSP_EXPORT_ extern const byte BT_SVC_UUID_HSP_AG[]; + +/** + * The personal area networking profile - user UUID (00001115-0000-1000-8000-00805F9B34FB). + * + * @since 2.0 + */ +_OSP_EXPORT_ extern const byte BT_SVC_UUID_PAN_PANU[]; + +/** + * The personal area networking profile - network access point UUID (00001116-0000-1000-8000-00805F9B34FB). + * + * @since 2.0 + */ +_OSP_EXPORT_ extern const byte BT_SVC_UUID_PAN_NAP[]; + +/** + * The personal area networking profile - group ad-hoc networks UUID (00001117-0000-1000-8000-00805F9B34FB). + * + * @since 2.0 + */ +_OSP_EXPORT_ extern const byte BT_SVC_UUID_PAN_GN[]; + +/** + * The basic printing profile - direct printing UUID (00001118-0000-1000-8000-00805F9B34FB). + * + * @since 2.0 + */ +_OSP_EXPORT_ extern const byte BT_SVC_UUID_BPP_DIRECT_PRINTING[]; + +/** + * The basic printing profile - reference printing UUID (00001119-0000-1000-8000-00805F9B34FB). + * + * @since 2.0 + */ +_OSP_EXPORT_ extern const byte BT_SVC_UUID_BPP_REFERENCE_PRINTING[]; + +/** + * The basic imaging profile UUID (0000111A-0000-1000-8000-00805F9B34FB). + * + * @since 2.0 + */ +_OSP_EXPORT_ extern const byte BT_SVC_UUID_BIP[]; + +/** + * The basic imaging profile - imaging responder UUID (0000111B-0000-1000-8000-00805F9B34FB). + * + * @since 2.0 + */ +_OSP_EXPORT_ extern const byte BT_SVC_UUID_BIP_RESPONDER[]; + +/** + * The basic imaging profile - imaging automatic archive UUID (0000111C-0000-1000-8000-00805F9B34FB). + * + * @since 2.0 + */ +_OSP_EXPORT_ extern const byte BT_SVC_UUID_BIP_AUTOMATIC_ARCHIVE[]; + +/** + * The basic imaging profile - imaging referenced objects UUID (0000111D-0000-1000-8000-00805F9B34FB). + * + * @since 2.0 + */ +_OSP_EXPORT_ extern const byte BT_SVC_UUID_BIP_REFERENCED_OBJECTS[]; + +/** + * The hands-free profile UUID (0000111E-0000-1000-8000-00805F9B34FB). + * + * @since 2.0 + */ +_OSP_EXPORT_ extern const byte BT_SVC_UUID_HFP[]; + +/** + * The hands-free profile - audio gateway UUID (0000111F-0000-1000-8000-00805F9B34FB). + * + * @since 2.0 + */ +_OSP_EXPORT_ extern const byte BT_SVC_UUID_HFP_AG[]; + +/** + * The basic printing profile - direct printing referenced objects UUID (00001120-0000-1000-8000-00805F9B34FB). + * + * @since 2.0 + */ +_OSP_EXPORT_ extern const byte BT_SVC_UUID_BPP_DIRECT_PRINTING_RO[]; + +/** + * The basic printing profile - reflected UI UUID (00001121-0000-1000-8000-00805F9B34FB). + * + * @since 2.0 + */ +_OSP_EXPORT_ extern const byte BT_SVC_UUID_BPP_REFLECTED_UI[]; + +/** + * The basic printing profile - basic printing UUID (00001122-0000-1000-8000-00805F9B34FB). + * + * @since 2.0 + */ +_OSP_EXPORT_ extern const byte BT_SVC_UUID_BPP_BASIC_PRINTING[]; + +/** + * The basic printing profile - printing status UUID (00001123-0000-1000-8000-00805F9B34FB). + * + * @since 2.0 + */ +_OSP_EXPORT_ extern const byte BT_SVC_UUID_BPP_PRINTING_STATUS[]; + +/** + * The human interface device profile UUID (00001124-0000-1000-8000-00805F9B34FB). + * + * @since 2.0 + */ +_OSP_EXPORT_ extern const byte BT_SVC_UUID_HID[]; + +/** + * The hardcopy cable replacement profile UUID (00001125-0000-1000-8000-00805F9B34FB). + * + * @since 2.0 + */ +_OSP_EXPORT_ extern const byte BT_SVC_UUID_HCRP[]; + +/** + * The hardcopy cable replacement profile - print UUID (00001126-0000-1000-8000-00805F9B34FB). + * + * @since 2.0 + */ +_OSP_EXPORT_ extern const byte BT_SVC_UUID_HCRP_PRINT[]; + +/** + * The hardcopy cable replacement profile - scan UUID (00001127-0000-1000-8000-00805F9B34FB). + * + * @since 2.0 + */ +_OSP_EXPORT_ extern const byte BT_SVC_UUID_HCRP_SCAN[]; + +/** + * The SIM access profile UUID (0000112D-0000-1000-8000-00805F9B34FB). + * + * @since 2.0 + */ +_OSP_EXPORT_ extern const byte BT_SVC_UUID_SAP[]; + +/** + * The phone book access - client equipment UUID (0000112E-0000-1000-8000-00805F9B34FB). + * + * @since 2.0 + */ +_OSP_EXPORT_ extern const byte BT_SVC_UUID_PBAP_PCE[]; + +/** + * The phone book access - server equipment UUID (0000112F-0000-1000-8000-00805F9B34FB). + * + * @since 2.0 + */ +_OSP_EXPORT_ extern const byte BT_SVC_UUID_PBAP_PSE[]; + +/** + * The phone book access UUID (00001130-0000-1000-8000-00805F9B34FB). + * + * @since 2.0 + */ +_OSP_EXPORT_ extern const byte BT_SVC_UUID_PBAP[]; + +/** + * The headset profile - headset UUID (00001131-0000-1000-8000-00805F9B34FB). + * + * @since 2.0 + */ +_OSP_EXPORT_ extern const byte BT_SVC_UUID_HSP_HS[]; + +/** + * The message access profile - message access server UUID (00001132-0000-1000-8000-00805F9B34FB). + * + * @since 2.0 + */ +_OSP_EXPORT_ extern const byte BT_SVC_UUID_MAP_ACCESS_SERVER[]; + +/** + * The message access profile - message notification server UUID (00001133-0000-1000-8000-00805F9B34FB). + * + * @since 2.0 + */ +_OSP_EXPORT_ extern const byte BT_SVC_UUID_MAP_NOTIFICATION_SERVER[]; + +/** + * The message access profile - message access profile UUID (00001134-0000-1000-8000-00805F9B34FB). + * + * @since 2.0 + */ +_OSP_EXPORT_ extern const byte BT_SVC_UUID_MAP_ACCESS_PROFILE[]; + +/** + * The device identification profile - PNP information UUID (00001200-0000-1000-8000-00805F9B34FB). + * + * @since 2.0 + */ +_OSP_EXPORT_ extern const byte BT_SVC_UUID_DID_PNP_INFORMATION[]; + +/** + * The generic networking UUID (00001201-0000-1000-8000-00805F9B34FB). + * + * @since 2.0 + */ +_OSP_EXPORT_ extern const byte BT_SVC_UUID_GENERIC_NETWORKING[]; + +/** + * The generic file transfer UUID (00001202-0000-1000-8000-00805F9B34FB). + * + * @since 2.0 + */ +_OSP_EXPORT_ extern const byte BT_SVC_UUID_GENERIC_FILE_TRANSFER[]; + +/** + * The generic audio UUID (00001203-0000-1000-8000-00805F9B34FB). + * + * @since 2.0 + */ +_OSP_EXPORT_ extern const byte BT_SVC_UUID_GENERIC_AUDIO[]; + +/** + * The generic telephony UUID. (00001204-0000-1000-8000-00805F9B34FB) + * + * @since 2.0 + */ +_OSP_EXPORT_ extern const byte BT_SVC_UUID_GENERIC_TELEPHONY[]; + +/** + * The video distribution profile - source UUID (00001303-0000-1000-8000-00805F9B34FB). + * + * @since 2.0 + */ +_OSP_EXPORT_ extern const byte BT_SVC_UUID_VDP_SOURCE[]; + +/** + * The video distribution profile - sink UUID (00001304-0000-1000-8000-00805F9B34FB). + * + * @since 2.0 + */ +_OSP_EXPORT_ extern const byte BT_SVC_UUID_VDP_SINK[]; + +/** + * The video distribution profile - distribution UUID (00001305-0000-1000-8000-00805F9B34FB). + * + * @since 2.0 + */ +_OSP_EXPORT_ extern const byte BT_SVC_UUID_VDP_DISTRIBUTION[]; + +/** + * The health device profile UUID (00001400-0000-1000-8000-00805F9B34FB). + * + * @since 2.0 + */ +_OSP_EXPORT_ extern const byte BT_SVC_UUID_HDP[]; + +/** + * The health device profile - source UUID (00001401-0000-1000-8000-00805F9B34FB). + * + * @since 2.0 + */ +_OSP_EXPORT_ extern const byte BT_SVC_UUID_HDP_SOURCE[]; + +/** + * The health device profile - sink UUID (00001402-0000-1000-8000-00805F9B34FB). + * + * @since 2.0 + */ +_OSP_EXPORT_ extern const byte BT_SVC_UUID_HDP_SINK[]; + +} } } +#endif // _FNET_BT_BLUETOOTH_TYPES_H_ diff --git a/inc/FNetBtIBluetoothDeviceEventListener.h b/inc/FNetBtIBluetoothDeviceEventListener.h new file mode 100755 index 0000000..23f0eb8 --- /dev/null +++ b/inc/FNetBtIBluetoothDeviceEventListener.h @@ -0,0 +1,206 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +/** + * @file FNetBtIBluetoothDeviceEventListener.h + * @brief This is the header file for the %IBluetoothDeviceEventListener interface. + * + * This header file contains the declarations of the %IBluetoothDeviceEventListener interface. + */ +#ifndef _FNET_BT_IBLUETOOTH_DEVICE_EVENT_LISTENER_H_ +#define _FNET_BT_IBLUETOOTH_DEVICE_EVENT_LISTENER_H_ + +#include +#include + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +// forward declaration +class BluetoothDevice; + +/** + * @interface IBluetoothDeviceEventListener + * @brief This interface implements the listener for %Bluetooth remote device events. + * + * @since 2.0 + * + * The %IBluetoothDeviceEventListener interface specifies the methods used to create notifications for the different + * kinds of %Bluetooth remote device events, including device discovery, service discovery, and pairing of the devices. + * When a %Bluetooth device event is generated, one of these methods is called. + * + * For more information on the class features, see + * Bluetooth Guide. + */ +class _OSP_EXPORT_ IBluetoothDeviceEventListener + : public Base::Runtime::IEventListener +{ +public: + /** + * This polymorphic destructor should be overridden if required. This way, the destructors of the derived classes + * are called when the destructor of this interface is called. + * + * @since 2.0 + */ + virtual ~IBluetoothDeviceEventListener(void) {} + + /** + * Called when the device discovery process for finding the nearby %Bluetooth devices has started. + * + * @since 2.0 + * + * @param[in] r The start status + * @exception E_SUCCESS The device discovery process is launched successfully. + * @exception E_SYSTEM A system error has occurred. + * @see BluetoothManager::StartDiscovery() + */ + virtual void OnBluetoothDiscoveryStarted(result r) = 0; + + /** + * Called when a remote device is found during the device discovery process. + * + * @since 2.0 + * + * @param[in] pFoundDevice The remote device that is found + * @remarks This event may be issued only if the device discovery process has started successfully. + * @see BluetoothManager::StartDiscovery() + */ + virtual void OnBluetoothRemoteDeviceFoundN(BluetoothDevice* pFoundDevice) = 0; + + /** + * Called when the device discovery process for finding the nearby %Bluetooth devices has completed. + * + * @since 2.0 + * + * @param[in] isCompleted Set to @c true if the device discovery process is successfully completed, @n + * else @c false @n + * For example, the discovery is canceled. + * @remarks This event must be issued only if the discovery starts successfully. + * @see BluetoothManager::CancelDiscovery() + */ + virtual void OnBluetoothDiscoveryDone(bool isCompleted) = 0; + + /** + * Called when a service list is received from a remote device using the service discovery process. + * + * @since 2.0 + * + * @param[in] targetDevice The remote device that sends its service list + * @param[in] serviceList The service list that is received + * @param[in] r The result of receiving the service list + * @exception E_SUCCESS The method is successful. + * @exception E_REMOTE_SERVICE_NOT_FOUND The service list of the remote device is not found. + * @exception E_SYSTEM A system error has occurred. + * @remarks @c serviceList consists of Bluetooth::BluetoothServiceType values which are joined by OR + * operator. + */ + virtual void OnBluetoothServiceListReceived(const BluetoothDevice& targetDevice, unsigned long serviceList, result r) = 0; + + /** + * Called when a new remote device is paired with this local device. + * + * @since 2.0 + * + * @param[in] pairedDevice The device to pair with the local device + * @remarks This method is able to be called even though the specified device already exists in the paired + * device list. Because the authorized key with the remote device is no more valid. @n + * @c pairedDevice may have no service list value and elements in the service UUID list because the + * retrieving the service list from the remote device fails. In that case, call + * BluetoothManager::RetrieveServiceList() to get the service list from the paired device. @n + * If the pairing is explicitly requested by BluetoothManager::Pair() and the request fails, + * IBluetoothDeviceEventListener::OnBluetoothPairingFailed() is called instead of this method. + * @see BluetoothManager::Pair() + * @see OnBluetoothPairingFailed() + */ + virtual void OnBluetoothPaired(const BluetoothDevice& pairedDevice) = 0; + + /** + * Called when the already paired device is unpaired with this local device. + * + * @since 2.0 + * + * @param[in] unpairedDevice The device to unpair with the local device + */ + virtual void OnBluetoothUnpaired(const BluetoothDevice& unpairedDevice) = 0; + + /** + * Called when the pairing request with the specific remote device fails. + * + * @since 2.0 + * + * @param[in] r The error result of the pairing request. @n + * One of the following exception is thrown. + * @exception E_OPERATION_CANCELED The pairing operation is canceled explicitly. + * @exception E_TIMEOUT The pairing request has timed out because the remote device does not + * respond within 60 seconds. + * @exception E_OPERATION_FAILED The operation has failed. + * @see BluetoothManager::Pair() + * @see BluetoothManager::CancelPair() + * @see OnBluetoothPaired() + */ + virtual void OnBluetoothPairingFailed(result r) {} + +protected: + // + // This method is for internal use only. Using this method can cause behavioral, security-related, and consistency-related issues in the application. + // + // This method is reserved and may change its name at any time without prior notice. + // + // @since 2.0 + // + virtual void IBluetoothDeviceEventListener_Reserved1(void) {} + + // + // This method is for internal use only. Using this method can cause behavioral, security-related, and consistency-related issues in the application. + // + // This method is reserved and may change its name at any time without prior notice. + // + // @since 2.0 + // + virtual void IBluetoothDeviceEventListener_Reserved2(void) {} + + // + // + // This method is for internal use only. Using this method can cause behavioral, security-related, and consistency-related issues in the application. + // + // This method is reserved and may change its name at any time without prior notice. + // + // @since 2.0 + // + virtual void IBluetoothDeviceEventListener_Reserved3(void) {} + + // + // This method is for internal use only. Using this method can cause behavioral, security-related, and consistency-related issues in the application. + // + // This method is reserved and may change its name at any time without prior notice. + // + // @since 2.0 + // + virtual void IBluetoothDeviceEventListener_Reserved4(void) {} + + // + // This method is for internal use only. Using this method can cause behavioral, security-related, and consistency-related issues in the application. + // + // This method is reserved and may change its name at any time without prior notice. + // + // @since 2.0 + // + virtual void IBluetoothDeviceEventListener_Reserved5(void) {} +}; // IBluetoothDeviceEventListener + +} } } +#endif // _FNET_BT_IBLUETOOTH_DEVICE_EVENT_LISTENER_H_ diff --git a/inc/FNetBtIBluetoothHealthEventListener.h b/inc/FNetBtIBluetoothHealthEventListener.h new file mode 100755 index 0000000..90ab3ec --- /dev/null +++ b/inc/FNetBtIBluetoothHealthEventListener.h @@ -0,0 +1,139 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +/** + * @file FNetBtIBluetoothHealthEventListener.h + * @brief This is the header file for the %IBluetoothHealthEventListener interface. + * + * This header file contains the declarations of the %IBluetoothHealthEventListener interface. + */ +#ifndef _FNET_BT_IBLUETOOTH_HEALTH_EVENT_LISTENER_H_ +#define _FNET_BT_IBLUETOOTH_HEALTH_EVENT_LISTENER_H_ + +#include +#include +#include + +namespace Tizen { namespace Base +{ +class ByteBuffer; +} } + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +class BluetoothDevice; + +/** + * @interface IBluetoothHealthEventListener + * @brief This interface provides a listener for the %BluetoothHealth events. + * @since 2.0 + * + * The %IBluetoothHealthEventListener interface specifies the methods used for creating notifications about the + * different kinds of BluetoothHealth events. When a %BluetoothHealth event is generated, one of these methods is called. + * + * For more information on the class features, see + * Bluetooth Guide. + */ +class _OSP_EXPORT_ IBluetoothHealthEventListener + : virtual public Base::Runtime::IEventListener +{ +public: + /** + * This polymorphic destructor should be overridden if required. This way, the destructors of the derived classes + * are called when the destructor of this interface is called. + * + * @since 2.0 + */ + virtual ~IBluetoothHealthEventListener(void) {} + + /** + * Called to notify when a connection with a health device is established. + * + * @since 2.0 + * @param[in] channelId The channel ID of the established connection, @n + * else an invalid ID (-1) if the method is not successful + * @param[in] dataType The type of data used in the established connection which is defined in + * ISO/IEEE 11073-20601 and represents type of health device such as thermometer, + * heart rate monitor, weight scale, and so on + * @param[in] channelType The data channel type of the established connection + * @param[in] pRemoteDevice The remote health device to connect with the local device, @n + * else @c null if the method is not successful + * @param[in] r The result of the connection request. @n + * One of the following exception is thrown. + * @exception E_SUCCESS The connection is established successfully. + * @exception E_OPERATION_FAILED The connection request has failed. + */ + virtual void OnHealthConnected(int channelId, int dataType, BluetoothHealthDataChannelType channelType, + const BluetoothDevice* pRemoteDevice, result r) = 0; + + /** + * Called to notify that the connection with the specified channel ID is disconnected. + * + * @since 2.0 + * + * @param[in] channelId The channel ID of the terminated connection + * @param[in] r The disconnection status. @n + * One of the following exception is thrown. + * @exception E_SUCCESS The specified connection (channel) is terminated successfully. + * @exception E_OPERATION_FAILED The method has failed to disconnect. + */ + virtual void OnHealthDisconnected(int channelId, result r) = 0; + + /** + * Called to notify when the data has been received on the specified channel. + * + * @since 2.0 + * + * @param[in] channelId The channel ID of the connection to receive data + * @param[in] buffer The data to receive + */ + virtual void OnHealthDataReceived(int channelId, Tizen::Base::ByteBuffer& buffer) = 0; + +protected: + // + // This method is for internal use only. Using this method can cause behavioral, security-related, and + // consistency-related issues in the application. + // This method is reserved and may change its name at any time without prior notice. + // + // @since 2.0 + // + virtual void IBluetoothHealthEventListener_Reserved1(void) {}; + + // + // This method is for internal use only. Using this method can cause behavioral, security-related, and + // consistency-related issues in the application. + // This method is reserved and may change its name at any time without prior notice. + // + // @since 2.0 + // + virtual void IBluetoothHealthEventListener_Reserved2(void) {}; + + // + // + // This method is for internal use only. Using this method can cause behavioral, security-related, and + // consistency-relatedissues in the application. + // This method is reserved and may change its name at any time without prior notice. + // + // @since 2.0 + // + virtual void IBluetoothHealthEventListener_Reserved3(void) {}; + +}; // IBluetoothHealthEventListener + +} } } +#endif // _FNET_BT_IBLUETOOTH_HEALTH_EVENT_LISTENER_H_ diff --git a/inc/FNetBtIBluetoothManagerEventListener.h b/inc/FNetBtIBluetoothManagerEventListener.h new file mode 100755 index 0000000..0b56853 --- /dev/null +++ b/inc/FNetBtIBluetoothManagerEventListener.h @@ -0,0 +1,119 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +/** + * @file FNetBtIBluetoothManagerEventListener.h + * @brief This is the header file for the %IBluetoothManagerEventListener interface. + * + * This header file contains the declarations of the %IBluetoothManagerEventListener interface. + */ +#ifndef _FNET_BT_IBLUETOOTH_MANAGER_EVENT_LISTENER_H_ +#define _FNET_BT_IBLUETOOTH_MANAGER_EVENT_LISTENER_H_ + +#include +#include + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +/** + * @interface IBluetoothManagerEventListener + * @brief This interface implements the listener for the %BluetoothManager events. + * + * @since 2.0 + * + * The %IBluetoothManagerEventListener interface specifies the methods used for creating notifications about the + * different kinds of BluetoothManager events. When a BluetoothManager event is generated, one of these methods is + * called. + * + * For more information on the class features, see + * Bluetooth Guide. + */ +class _OSP_EXPORT_ IBluetoothManagerEventListener + : public Base::Runtime::IEventListener +{ +public: + /** + * This polymorphic destructor should be overridden if required. This way, the destructors of the derived classes + * are called when the destructor of this interface is called. + * + * @since 2.0 + */ + virtual ~IBluetoothManagerEventListener(void) {} + + /** + * Called when %Bluetooth is activated on the device. + * + * @since 2.0 + * + * @param[in] r The activation status + * @exception E_SUCCESS The method is successful. + * @exception E_SYSTEM A system error has occurred. + */ + virtual void OnBluetoothActivated(result r) = 0; + + /** + * Called when %Bluetooth is deactivated on the device. + * + * @since 2.0 + * + * @param[in] r The deactivation status + * @exception E_SUCCESS The method is successful. + * @exception E_SYSTEM A system error has occurred. + */ + virtual void OnBluetoothDeactivated(result r) = 0; + + /** + * Called when the discoverable mode is changed on the device. + * + * @since 2.0 + * + * @param[in] mode The new discoverable mode to change + */ + virtual void OnBluetoothDiscoverableModeChanged(BluetoothDiscoverableMode mode) {} + +protected: + // + // This method is for internal use only. Using this method can cause behavioral, security-related, and consistency-related issues in the application. + // + // This method is reserved and may change its name at any time without prior notice. + // + // @since 2.0 + // + virtual void IBluetoothManagerEventListener_Reserved1(void) {}; + + // + // This method is for internal use only. Using this method can cause behavioral, security-related, and consistency-related issues in the application. + // + // This method is reserved and may change its name at any time without prior notice. + // + // @since 2.0 + // + virtual void IBluetoothManagerEventListener_Reserved2(void) {}; + + // + // This method is for internal use only. Using this method can cause behavioral, security-related, and consistency-related issues in the application. + // + // This method is reserved and may change its name at any time without prior notice. + // + // @since 2.0 + // + virtual void IBluetoothManagerEventListener_Reserved3(void) {}; +}; // IBluetoothManagerEventListener + +} } } +#endif // _FNET_BT_IBLUETOOTH_MANAGER_EVENT_LISTENER_H_ diff --git a/inc/FNetBtIBluetoothOppClientEventListener.h b/inc/FNetBtIBluetoothOppClientEventListener.h new file mode 100755 index 0000000..0835e26 --- /dev/null +++ b/inc/FNetBtIBluetoothOppClientEventListener.h @@ -0,0 +1,115 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +/** + * @file FNetBtIBluetoothOppClientEventListener.h + * @brief This is the header file for the %IBluetoothOppClientEventListener interface. + * + * This header file contains the declarations of the %IBluetoothOppClientEventListener interface. + */ +#ifndef _FNET_BT_IBLUETOOTH_OPP_CLIENT_EVENT_LISTENER_H_ +#define _FNET_BT_IBLUETOOTH_OPP_CLIENT_EVENT_LISTENER_H_ + +#include +#include + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +/** + * @interface IBluetoothOppClientEventListener + * @brief This interface provides a listener for the %BluetoothOppClient events. + * + * @since 2.0 + * + * The %IBluetoothOppClientEventListener interface specifies the methods used for creating notifications about the + * different kinds of BluetoothOppClient events. When a BluetoothOppClient event is generated, one of these methods + * is called. + * + * For more information on the class features, see + * Bluetooth Guide. + */ +class _OSP_EXPORT_ IBluetoothOppClientEventListener + : public Base::Runtime::IEventListener +{ +public: + /** + * This polymorphic destructor should be overridden if required. This way, the destructors of the derived classes + * are called when the destructor of this interface is called. + * + * @since 2.0 + */ + virtual ~IBluetoothOppClientEventListener(void) {} + + /** + * Called when the OPP server responded to the push request. + * + * @since 2.0 + * + * @param[in] r The response status + * @exception E_SUCCESS The push request is accepted by the OPP server and the file transfer has begun. + * @exception E_REJECTED The push request is rejected by the OPP server. @n + * This exception is currently not in use. + * @exception E_TIMEOUT The push request is out of time. + * @exception E_SYSTEM A failure has occurred from the underlying system. @n + * This failure includes the rejection by the OPP server. + */ + virtual void OnOppPushResponded(result r) = 0; + + /** + * Called when the file is being transferred. @n + * Gets the progress information of the file transfer. + * + * @since 2.0 + * + * @param[in] percent The progress in percentage ranging from @c 1 to @c 100 percent + * @see BluetoothOppClient::SetMinProgressInterval() + */ + virtual void OnOppTransferInProgress(int percent) = 0; + + /** + * Called when the file transfer has finished. + * + * @if OSPCOMPAT + * @brief [Compatibility] + * @endif + * @since 2.0 + * @if OSPCOMPAT + * @compatibility This method has compatibility issues. @n + * For more information, see @ref CompIoPathPage "here". + * + * @endif + * @param[in] filePath The path of the file (including the file name) to transfer + * @param[in] fileSize The size of the file to transfer + * @param[in] isCompleted Set to @c true if the transfer is successfully completed, @n + * else @c false + */ + virtual void OnOppTransferDone(const Tizen::Base::String& filePath, int fileSize, bool isCompleted) = 0; + +protected: + // + // This method is for internal use only. Using this method can cause behavioral, security-related, and consistency-related issues in the application. + // + // This method is reserved and may change its name at any time without prior notice. + // + // @since 2.0 + // + virtual void IBluetoothOppClientEventListener_Reserved1(void) {}; +}; // IBluetoothOppClientEventListener + +} } } +#endif // _FNET_BT_IBLUETOOTH_OPP_CLIENT_EVENT_LISTENER_H_ diff --git a/inc/FNetBtIBluetoothOppServerEventListener.h b/inc/FNetBtIBluetoothOppServerEventListener.h new file mode 100755 index 0000000..2f5bf70 --- /dev/null +++ b/inc/FNetBtIBluetoothOppServerEventListener.h @@ -0,0 +1,108 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +/** + * @file FNetBtIBluetoothOppServerEventListener.h + * @brief This is the header file for the %IBluetoothOppServerEventListener interface. + * + * This header file contains the declarations of the %IBluetoothOppServerEventListener interface. + */ +#ifndef _FNET_BT_IBLUETOOTH_OPP_SERVER_EVENT_LISTENER_H_ +#define _FNET_BT_IBLUETOOTH_OPP_SERVER_EVENT_LISTENER_H_ + +#include + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +// forward declaration +class BluetoothOppServer; +class BluetoothDevice; +/** + * @interface IBluetoothOppServerEventListener + * @brief This interface provides a listener for the %BluetoothOppServer events. + * + * @since 2.0 + * + * The %IBluetoothOppServerEventListener interface specifies the methods used for creating notifications about the + * different kinds of BluetoothOppServer events. When a BluetoothOppServer event is generated, one of these methods + * is called. + * @n + * For more information on the class features, see + * Bluetooth Guide. + */ +class _OSP_EXPORT_ IBluetoothOppServerEventListener + : public Tizen::Base::Runtime::IEventListener +{ +public: + /** + * This polymorphic destructor should be overridden if required. This way, the destructors of the derived classes + * are called when the destructor of this interface is called. + * + * @since 2.0 + */ + virtual ~IBluetoothOppServerEventListener(void) {} + + /** + * Called when an incoming push request is received from a remote OPP client. + * + * @since 2.0 + * + * @param[in] device The remote device to request the connection + */ + virtual void OnOppPushRequested(const BluetoothDevice& device) = 0; + + /** + * Called when the file is being transferred. @n + * Gets the progress information of the file transfer. + * + * @since 2.0 + * + * @param[in] percent The progress in percentage ranging from @c 1 to @c 100 percent + * @see BluetoothOppServer::SetMinProgressInterval() + */ + virtual void OnOppTransferInProgress(int percent) = 0; + + /** + * Called when the file transfer has finished. + * + * @since 2.0 + * + * @param[in] fileName The name of the file to transfer + * @param[in] fileSize The size of the file to transfer + * @param[in] isCompleted Set to @c true if the transfer is successfully completed, @n + * else @c false + * @remarks If the name of the received file already exists in the destination path, the received file is renamed + * automatically and @c isCompleted is set to @c true. For renaming, the specified postfix is appended to + * the original file name. The postfix consists of an underscore and three digit sequence numbers starting + * from 001. For example, "MySong.mp3" may be changed to "MySong_001.mp3". + */ + virtual void OnOppTransferDone(const Tizen::Base::String& fileName, int fileSize, bool isCompleted) = 0; + +protected: + // + // This method is for internal use only. Using this method can cause behavioral, security-related, and consistency-related issues in the application. + // + // This method is reserved and may change its name at any time without prior notice. + // + // @since 2.0 + // + virtual void IBluetoothOppServerEventListener_Reserved1(void) {}; +}; // IBluetoothOppServerEventListener + +} } } +#endif // _FNET_BT_IBLUETOOTH_OPP_SERVER_EVENT_LISTENER_H_ diff --git a/inc/FNetBtIBluetoothSppAcceptorEventListener.h b/inc/FNetBtIBluetoothSppAcceptorEventListener.h new file mode 100755 index 0000000..7298a41 --- /dev/null +++ b/inc/FNetBtIBluetoothSppAcceptorEventListener.h @@ -0,0 +1,105 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +/** + * @file FNetBtIBluetoothSppAcceptorEventListener.h + * @brief This is the header file for the %IBluetoothSppAcceptorEventListener interface. + * + * This header file contains the declarations of the %IBluetoothSppAcceptorEventListener interface. + */ +#ifndef _FNET_BT_IBLUETOOTH_SPP_ACCEPTOR_EVENT_LISTENER_H_ +#define _FNET_BT_IBLUETOOTH_SPP_ACCEPTOR_EVENT_LISTENER_H_ + +#include +#include + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +// forward declaration +class BluetoothSppAcceptor; +class BluetoothDevice; + +/** + * @interface IBluetoothSppAcceptorEventListener + * @brief This interface provides a listener for the %BluetoothSppAcceptor events. + * + * @since 2.0 + * + * The %IBluetoothSppAcceptorEventListener interface specifies the methods used for creating notifications about the + * different kinds of BluetoothSppAcceptor events. When a BluetoothSppAcceptor event is generated, one of these methods + * is called. + * + * For more information on the class features, see + * Bluetooth Guide. + */ +class _OSP_EXPORT_ IBluetoothSppAcceptorEventListener + : public Base::Runtime::IEventListener +{ +public: + /** + * This polymorphic destructor should be overridden if required. This way, the destructors of the derived classes + * are called when the destructor of this interface is called. + * + * @since 2.0 + */ + virtual ~IBluetoothSppAcceptorEventListener(void) {} + + /** + * Called to notify an incoming connection request from a remote SPP initiator. + * + * @since 2.0 + * + * @param[in] device The remote device to request the connection + * @remarks If BluetoothSppAcceptor::SendData() is invoked in this callback, it does not work as expected. + * Therefore, it must be invoked outside this callback thread. + */ + virtual void OnSppConnectionRequested(const BluetoothDevice& device) = 0; + + /** + * Called to notify that the connection is disconnected. + * + * @since 2.0 + * + * @param[in] r The disconnection status + * @exception E_SUCCESS The connection is terminated successfully. + * @exception E_SYSTEM The method has failed to disconnect. + */ + virtual void OnSppDisconnected(result r) = 0; + + /** + * Called to notify when the data is received. + * + * @since 2.0 + * + * @param[in] buffer The data to receive as a Tizen::Base::ByteBuffer + */ + virtual void OnSppDataReceived(Tizen::Base::ByteBuffer& buffer) = 0; + +protected: + // + // This method is for internal use only. Using this method can cause behavioral, security-related, and consistency-related issues in the application. + // + // This method is reserved and may change its name at any time without prior notice. + // + // @since 2.0 + // + virtual void IBluetoothSppAcceptorEventListener_Reserved1(void) {}; +}; // IBluetoothSppAcceptorEventListener + +} } } +#endif // _FNET_BT_IBLUETOOTH_SPP_ACCEPTOR_EVENT_LISTENER_H_ diff --git a/inc/FNetBtIBluetoothSppInitiatorEventListener.h b/inc/FNetBtIBluetoothSppInitiatorEventListener.h new file mode 100755 index 0000000..f78ce6e --- /dev/null +++ b/inc/FNetBtIBluetoothSppInitiatorEventListener.h @@ -0,0 +1,96 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +/** + * @file FNetBtIBluetoothSppInitiatorEventListener.h + * @brief This is the header file for the %IBluetoothSppInitiatorEventListener interface. + * + * This header file contains the declarations of the %IBluetoothSppInitiatorEventListener interface. + */ +#ifndef _FNET_BT_IBLUETOOTH_SPP_INITIATOR_EVENT_LISTENER_H_ +#define _FNET_BT_IBLUETOOTH_SPP_INITIATOR_EVENT_LISTENER_H_ + +#include +#include + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +/** + * @interface IBluetoothSppInitiatorEventListener + * @brief This interface provides a listener for the %BluetoothSppInitiator events. + * + * @since 2.0 + * + * The %IBluetoothSppInitiatorEventListener interface specifies the methods used for creating notifications about the + * different kinds of BluetoothSppInitiator events. When a BluetoothSppInitiator event is generated, one of these + * methods is called. + * + * For more information on the class features, see + * Bluetooth Guide. + */ +class _OSP_EXPORT_ IBluetoothSppInitiatorEventListener + : public Base::Runtime::IEventListener +{ +public: + /** + * This polymorphic destructor should be overridden if required. This way, the destructors of the derived classes + * are called when the destructor of this interface is called. + * + * @since 2.0 + */ + virtual ~IBluetoothSppInitiatorEventListener(void) {} + + /** + * Called to notify when an SPP acceptor responds to the connection request. + * + * @since 2.0 + * + * @param[in] r The status of the connection response + * @exception E_SUCCESS The connection request is accepted by the SPP acceptor and the file transfer has + * begun. + * @exception E_REJECTED The connection request is rejected by the SPP acceptor. @n + * This exception is currently not in use. + * @exception E_TIMEOUT The connection request has timed out. + * @exception E_SYSTEM A failure has occurred from the underlying system. @n + * This failure includes the rejection by the SPP acceptor. + */ + virtual void OnSppConnectionResponded(result r) = 0; + + /** + * Called to notify that the connection is disconnected. + * + * @since 2.0 + * + * @param[in] r The disconnection status + * @exception E_SUCCESS The connection is terminated successfully. + * @exception E_SYSTEM The method has failed to disconnect. + */ + virtual void OnSppDisconnected(result r) = 0; + + /** + * Called to notify when the data has been received. + * + * @since 2.0 + * + * @param[in] buffer The data to receive + */ + virtual void OnSppDataReceived(Tizen::Base::ByteBuffer& buffer) = 0; +}; // IBluetoothSppInitiatorEventListener + +} } } +#endif // _FNET_BT_IBLUETOOTH_SPP_INITIATOR_EVENT_LISTENER_H_ diff --git a/osp-bluetooth.manifest b/osp-bluetooth.manifest new file mode 100644 index 0000000..ae3e6f7 --- /dev/null +++ b/osp-bluetooth.manifest @@ -0,0 +1,5 @@ + + + + + \ No newline at end of file diff --git a/osp-bluetooth.pc.in b/osp-bluetooth.pc.in new file mode 100755 index 0000000..eb6c3b7 --- /dev/null +++ b/osp-bluetooth.pc.in @@ -0,0 +1,14 @@ +# Package Information for pkg-config + +prefix=@PREFIX@ +exec_prefix=/usr +libdir=/usr/lib/osp +includedir=/usr/include/osp + +Name: @PC_NAME@ +Description: @PACKAGE_DESCRIPTION@ +Version: @VERSION@ +Requires: @PC_REQUIRED@ +Libs: -L${libdir} @PC_LDFLAGS@ +Cflags: -I${includedir} + diff --git a/packaging/osp-bluetooth.spec b/packaging/osp-bluetooth.spec new file mode 100755 index 0000000..4576329 --- /dev/null +++ b/packaging/osp-bluetooth.spec @@ -0,0 +1,91 @@ +%define debug_package %{nil} +%define __strip /bin/true + +Name: osp-bluetooth +Summary: osp bluetooth library +Version: 1.2.1.0 +Release: 2 +Group: System/Libraries +License: TO_BE/FILLED_IN +Source0: %{name}-%{version}.tar.gz +BuildRequires: cmake +BuildRequires: pkgconfig(chromium) +BuildRequires: pkgconfig(glib-2.0) +BuildRequires: pkgconfig(capi-system-info) +BuildRequires: pkgconfig(capi-system-device) +BuildRequires: pkgconfig(capi-network-bluetooth) +BuildRequires: pkgconfig(osp-appfw) +BuildRequires: osp-appfw-internal-devel +BuildRequires: pkgconfig(osp-net) +BuildRequires: osp-net-internal-devel + +# runtime requires +Requires: osp-appfw +Requires: osp-net + +%description +osp bluetooth library + +%package devel +Summary: osp bluetooth library (Development) +Group: TO_BE/FILLED_IN +Requires: %{name} = %{version}-%{release} + +%description devel +osp bluetooth library (DEV) + +%package internal-devel +Summary: osp bluetooth library (Internal) +Group: TO_BE/FILLED_IN +Requires: %{name} = %{version}-%{release} + +%description internal-devel +osp bluetooth library (Internal-DEV) + +%package debug +Summary: osp bluetooth library (Development) +Group: TO_BE/FILLED_IN +Requires: %{name} = %{version}-%{release} + +%description debug +osp bluetooth library (DEV) + +%prep +%setup -q + +%build +MAJORVER=`echo %{version} | awk 'BEGIN {FS="."}{print $1}'` +%ifarch %{ix86} +CXXFLAGS="$CXXFLAGS -D_OSP_DEBUG_ -D_OSP_X86_ -D_OSP_EMUL_" cmake . -DCMAKE_INSTALL_PREFIX=%{_prefix} -DFULLVER=%{version} -DMAJORVER=${MAJORVER} +%else +CXXFLAGS="-O2 -g -pipe -Wall -fno-exceptions -Wformat -Wformat-security -Wl,--as-needed -fmessage-length=0 -march=armv7-a -mtune=cortex-a8 -mlittle-endian -mfpu=neon -mfloat-abi=softfp -D__SOFTFP__ -mthumb -Wa,-mimplicit-it=thumb -funwind-tables -D_OSP_DEBUG_ -D_OSP_ARMEL_" cmake . -DCMAKE_INSTALL_PREFIX=%{_prefix} -DFULLVER=%{version} -DMAJORVER=${MAJORVER} +%endif + +# Call make instruction with smp support +make %{?jobs:-j%jobs} + +%install +rm -rf %{buildroot} +mkdir -p %{buildroot}/usr/share/license +cp %{_builddir}/%{name}-%{version}/LICENSE.APLv2.0 %{buildroot}/usr/share/license/%{name} + +%make_install + +%post -p /sbin/ldconfig + +%postun -p /sbin/ldconfig + +%files +%manifest osp-bluetooth.manifest +/usr/share/license/%{name} +%{_libdir}/osp/*.so* + +%files devel +%{_includedir}/osp/*.h +%{_libdir}/pkgconfig/osp-bluetooth.pc + +%files internal-devel +%{_includedir}/osp/net/*.h + +%files debug +%{_libdir}/osp/debug/*.so* diff --git a/src/FNetBtBluetoothDevice.cpp b/src/FNetBtBluetoothDevice.cpp new file mode 100755 index 0000000..3221c7b --- /dev/null +++ b/src/FNetBtBluetoothDevice.cpp @@ -0,0 +1,469 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// @file FNetBtBluetoothDevice.cpp +// @brief This is the implementation file for the BluetoothDevice class. +// + +#include +#include +#include +#include +#include +#include +#include +#include "FNetBt_BluetoothDeviceImpl.h" + +using namespace Tizen::Base; +using namespace Tizen::Base::Runtime; + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +// The serial port profile UUID. (00001101-0000-1000-8000-00805F9B34FB) +const byte BT_SVC_UUID_SPP[] = {0x00, 0x00, 0x11, 0x01, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}; + +// The LAN access profile UUID. (00001102-0000-1000-8000-00805F9B34FB) +const byte BT_SVC_UUID_LAP[] = {0x00, 0x00, 0x11, 0x02, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}; + +// The dial-up networking profile UUID. (00001103-0000-1000-8000-00805F9B34FB) +const byte BT_SVC_UUID_DUN[] = {0x00, 0x00, 0x11, 0x03, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}; + +// The synchronization profile UUID. (00001104-0000-1000-8000-00805F9B34FB) +const byte BT_SVC_UUID_SYNC[] = {0x00, 0x00, 0x11, 0x04, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}; + +// The object push profile UUID. (00001105-0000-1000-8000-00805F9B34FB) +const byte BT_SVC_UUID_OPP[] = {0x00, 0x00, 0x11, 0x05, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}; + +// The file transfer profile UUID. (00001106-0000-1000-8000-00805F9B34FB) +const byte BT_SVC_UUID_FTP[] = {0x00, 0x00, 0x11, 0x06, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}; + +// The synchronization profile UUID. (00001107-0000-1000-8000-00805F9B34FB) +const byte BT_SVC_UUID_SYNC_COMMAND[] = {0x00, 0x00, 0x11, 0x07, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}; + +// The headset profile UUID. (00001108-0000-1000-8000-00805F9B34FB) +const byte BT_SVC_UUID_HSP[] = {0x00, 0x00, 0x11, 0x08, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}; + +// The cordless telephony profile UUID. (00001109-0000-1000-8000-00805F9B34FB) +const byte BT_SVC_UUID_CTP[] = {0x00, 0x00, 0x11, 0x09, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}; + +// The advanced audio distribution profile - source UUID. (0000110A-0000-1000-8000-00805F9B34FB) +const byte BT_SVC_UUID_A2DP_SOURCE[] = {0x00, 0x00, 0x11, 0x0A, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}; + +// The advanced audio distribution profile - sink UUID. (0000110B-0000-1000-8000-00805F9B34FB) +const byte BT_SVC_UUID_A2DP_SINK[] = {0x00, 0x00, 0x11, 0x0B, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}; + +// The audio/video remote control profile - target UUID. (0000110C-0000-1000-8000-00805F9B34FB) +const byte BT_SVC_UUID_AVRCP_TARGET[] = {0x00, 0x00, 0x11, 0x0C, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}; + +// The advanced audio distribution profile UUID. (0000110D-0000-1000-8000-00805F9B34FB) +const byte BT_SVC_UUID_A2DP[] = {0x00, 0x00, 0x11, 0x0D, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}; + +// The audio/video remote control profile UUID. (0000110E-0000-1000-8000-00805F9B34FB) +const byte BT_SVC_UUID_AVRCP[] = {0x00, 0x00, 0x11, 0x0E, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}; + +// The audio/video remote control profile - controller UUID. (0000110F-0000-1000-8000-00805F9B34FB) +const byte BT_SVC_UUID_AVRCP_CONTROLLER[] = {0x00, 0x00, 0x11, 0x0F, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}; + +// The intercom profile UUID. (00001110-0000-1000-8000-00805F9B34FB) +const byte BT_SVC_UUID_ICP[] = {0x00, 0x00, 0x11, 0x10, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}; + +// The fax profile UUID. (00001111-0000-1000-8000-00805F9B34FB) +const byte BT_SVC_UUID_FAX[] = {0x00, 0x00, 0x11, 0x11, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}; + +// The headset profile - audio gateway UUID. (00001112-0000-1000-8000-00805F9B34FB) +const byte BT_SVC_UUID_HSP_AG[] = {0x00, 0x00, 0x11, 0x12, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}; + +// The personal area networking profile - user UUID. (00001115-0000-1000-8000-00805F9B34FB) +const byte BT_SVC_UUID_PAN_PANU[] = {0x00, 0x00, 0x11, 0x15, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}; + +// The personal area networking profile - network access point UUID. (00001116-0000-1000-8000-00805F9B34FB) +const byte BT_SVC_UUID_PAN_NAP[] = {0x00, 0x00, 0x11, 0x16, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}; + +// The personal area networking profile - group ad-hoc networks UUID. (00001117-0000-1000-8000-00805F9B34FB) +const byte BT_SVC_UUID_PAN_GN[] = {0x00, 0x00, 0x11, 0x17, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}; + +// The basic printing profile - direct printing UUID. (00001118-0000-1000-8000-00805F9B34FB) +const byte BT_SVC_UUID_BPP_DIRECT_PRINTING[] = {0x00, 0x00, 0x11, 0x18, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}; + +// The basic printing profile - reference printing UUID. (00001119-0000-1000-8000-00805F9B34FB) +const byte BT_SVC_UUID_BPP_REFERENCE_PRINTING[] = {0x00, 0x00, 0x11, 0x19, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}; + +// The basic imaging profile UUID. (0000111A-0000-1000-8000-00805F9B34FB) +const byte BT_SVC_UUID_BIP[] = {0x00, 0x00, 0x11, 0x1A, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}; + +// The basic imaging profile - imaging responder UUID. (0000111B-0000-1000-8000-00805F9B34FB) +const byte BT_SVC_UUID_BIP_RESPONDER[] = {0x00, 0x00, 0x11, 0x1B, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}; + +// The basic imaging profile - imaging automatic archive UUID. (0000111C-0000-1000-8000-00805F9B34FB) +const byte BT_SVC_UUID_BIP_AUTOMATIC_ARCHIVE[] = {0x00, 0x00, 0x11, 0x1C, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}; + +// The basic imaging profile - imaging referenced objects UUID. (0000111D-0000-1000-8000-00805F9B34FB) +const byte BT_SVC_UUID_BIP_REFERENCED_OBJECTS[] = {0x00, 0x00, 0x11, 0x1D, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}; + +// The hands-free profile UUID. (0000111E-0000-1000-8000-00805F9B34FB) +const byte BT_SVC_UUID_HFP[] = {0x00, 0x00, 0x11, 0x1E, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}; + +// The hands-free profile - audio gateway UUID. (0000111F-0000-1000-8000-00805F9B34FB) +const byte BT_SVC_UUID_HFP_AG[] = {0x00, 0x00, 0x11, 0x1F, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}; + +// The basic printing profile - direct printing referenced objects UUID. (00001120-0000-1000-8000-00805F9B34FB) +const byte BT_SVC_UUID_BPP_DIRECT_PRINTING_RO[] = {0x00, 0x00, 0x11, 0x20, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}; + +// The basic printing profile - reflected UI UUID. (00001121-0000-1000-8000-00805F9B34FB) +const byte BT_SVC_UUID_BPP_REFLECTED_UI[] = {0x00, 0x00, 0x11, 0x21, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}; + +// The basic printing profile - basic printing UUID. (00001122-0000-1000-8000-00805F9B34FB) +const byte BT_SVC_UUID_BPP_BASIC_PRINTING[] = {0x00, 0x00, 0x11, 0x22, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}; + +// The basic printing profile - printing status UUID. (00001123-0000-1000-8000-00805F9B34FB) +const byte BT_SVC_UUID_BPP_PRINTING_STATUS[] = {0x00, 0x00, 0x11, 0x23, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}; + +// The human interface device profile UUID. (00001124-0000-1000-8000-00805F9B34FB) +const byte BT_SVC_UUID_HID[] = {0x00, 0x00, 0x11, 0x24, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}; + +// The hardcopy cable replacement profile UUID. (00001125-0000-1000-8000-00805F9B34FB) +const byte BT_SVC_UUID_HCRP[] = {0x00, 0x00, 0x11, 0x25, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}; + +// The hardcopy cable replacement profile - print UUID. (00001126-0000-1000-8000-00805F9B34FB) +const byte BT_SVC_UUID_HCRP_PRINT[] = {0x00, 0x00, 0x11, 0x26, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}; + +// The hardcopy cable replacement profile - scan UUID. (00001127-0000-1000-8000-00805F9B34FB) +const byte BT_SVC_UUID_HCRP_SCAN[] = {0x00, 0x00, 0x11, 0x27, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}; + +// The SIM access profile UUID. (0000112D-0000-1000-8000-00805F9B34FB) +const byte BT_SVC_UUID_SAP[] = {0x00, 0x00, 0x11, 0x2D, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}; + +// The phone book access - client equipment UUID. (0000112E-0000-1000-8000-00805F9B34FB) +const byte BT_SVC_UUID_PBAP_PCE[] = {0x00, 0x00, 0x11, 0x2E, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}; + +// The phone book access - server equipment UUID. (0000112F-0000-1000-8000-00805F9B34FB) +const byte BT_SVC_UUID_PBAP_PSE[] = {0x00, 0x00, 0x11, 0x2F, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}; + +// The phone book access UUID. (00001130-0000-1000-8000-00805F9B34FB) +const byte BT_SVC_UUID_PBAP[] = {0x00, 0x00, 0x11, 0x30, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}; + +// The headset profile - headset UUID. (00001131-0000-1000-8000-00805F9B34FB) +const byte BT_SVC_UUID_HSP_HS[] = {0x00, 0x00, 0x11, 0x31, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}; + +// The message access profile - message access server UUID. (00001132-0000-1000-8000-00805F9B34FB) +const byte BT_SVC_UUID_MAP_ACCESS_SERVER[] = {0x00, 0x00, 0x11, 0x32, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}; + +// The message access profile - message notification server UUID. (00001133-0000-1000-8000-00805F9B34FB) +const byte BT_SVC_UUID_MAP_NOTIFICATION_SERVER[] = {0x00, 0x00, 0x11, 0x33, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}; + +// The message access profile - message access profile UUID. (00001134-0000-1000-8000-00805F9B34FB) +const byte BT_SVC_UUID_MAP_ACCESS_PROFILE[] = {0x00, 0x00, 0x11, 0x34, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}; + +// The device identification profile - PNP information UUID. (00001200-0000-1000-8000-00805F9B34FB) +const byte BT_SVC_UUID_DID_PNP_INFORMATION[] = {0x00, 0x00, 0x12, 0x00, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}; + +// The generic networking UUID. (00001201-0000-1000-8000-00805F9B34FB) +const byte BT_SVC_UUID_GENERIC_NETWORKING[] = {0x00, 0x00, 0x12, 0x01, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}; + +// The generic file transfer UUID. (00001202-0000-1000-8000-00805F9B34FB) +const byte BT_SVC_UUID_GENERIC_FILE_TRANSFER[] = {0x00, 0x00, 0x12, 0x02, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}; + +// The generic audio UUID. (00001203-0000-1000-8000-00805F9B34FB) +const byte BT_SVC_UUID_GENERIC_AUDIO[] = {0x00, 0x00, 0x12, 0x03, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}; + +// The generic telephony UUID. (00001204-0000-1000-8000-00805F9B34FB) +const byte BT_SVC_UUID_GENERIC_TELEPHONY[] = {0x00, 0x00, 0x12, 0x04, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}; + +// The video distribution profile - source UUID. (00001303-0000-1000-8000-00805F9B34FB) +const byte BT_SVC_UUID_VDP_SOURCE[] = {0x00, 0x00, 0x13, 0x03, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}; + +// The video distribution profile - sink UUID. (00001304-0000-1000-8000-00805F9B34FB) +const byte BT_SVC_UUID_VDP_SINK[] = {0x00, 0x00, 0x13, 0x04, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}; + +// The video distribution profile - distribution UUID. (00001305-0000-1000-8000-00805F9B34FB) +const byte BT_SVC_UUID_VDP_DISTRIBUTION[] = {0x00, 0x00, 0x13, 0x05, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}; + +// The health device profile UUID. (00001400-0000-1000-8000-00805F9B34FB) +const byte BT_SVC_UUID_HDP[] = {0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}; + +// The health device profile - source UUID. (00001401-0000-1000-8000-00805F9B34FB) +const byte BT_SVC_UUID_HDP_SOURCE[] = {0x00, 0x00, 0x14, 0x01, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}; + +// The health device profile - sink UUID. (00001402-0000-1000-8000-00805F9B34FB) +const byte BT_SVC_UUID_HDP_SINK[] = {0x00, 0x00, 0x14, 0x02, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}; + + +BluetoothDevice::BluetoothDevice(void) + : __pImpl(null) +{ + __pImpl = new (std::nothrow) _BluetoothDeviceImpl(); + SysTryReturnVoidResult(NID_NET_BT, __pImpl, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient."); +} + +BluetoothDevice::BluetoothDevice(const Tizen::Base::ByteBuffer& address, const Base::String& deviceName, BluetoothMajorDeviceClassType majorClassType, BluetoothMinorDeviceClassType minorClassType, unsigned long serviceClassList, unsigned long serviceList) + : __pImpl(null) +{ + __pImpl = new (std::nothrow) _BluetoothDeviceImpl(address, deviceName, majorClassType, minorClassType, serviceClassList, serviceList); + SysTryReturnVoidResult(NID_NET_BT, __pImpl, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient."); +} + +BluetoothDevice::BluetoothDevice(const BluetoothDevice& value) + : __pImpl(null) +{ + __pImpl = new (std::nothrow) _BluetoothDeviceImpl(*value.__pImpl); + SysTryReturnVoidResult(NID_NET_BT, __pImpl, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient."); +} + +BluetoothDevice::~BluetoothDevice(void) +{ + delete __pImpl; +} + +BluetoothDevice& +BluetoothDevice::operator =(const BluetoothDevice& rhs) +{ + if (this != &rhs) + { + *__pImpl = *rhs.__pImpl; + } + + return *this; +} + +const Tizen::Base::ByteBuffer* +BluetoothDevice::GetAddress(void) const +{ + return __pImpl->GetAddress(); +} + +result +BluetoothDevice::SetAddress(const Tizen::Base::ByteBuffer& address) +{ + return __pImpl->SetAddress(address); +} + +String +BluetoothDevice::GetName(void) const +{ + return __pImpl->GetName(); +} + +bool +BluetoothDevice::IsPaired(void) const +{ + return __pImpl->IsPaired(); +} + +int +BluetoothDevice::GetRssi(void) const +{ + return __pImpl->GetRssi(); +} + +BluetoothMajorDeviceClassType +BluetoothDevice::GetMajorDeviceClassType(void) const +{ + return __pImpl->GetMajorDeviceClassType(); +} + +BluetoothMinorDeviceClassType +BluetoothDevice::GetMinorDeviceClassType(void) const +{ + return __pImpl->GetMinorDeviceClassType(); +} + +unsigned long +BluetoothDevice::GetServiceClassList(void) const +{ + return __pImpl->GetServiceClassList(); +} + +unsigned long +BluetoothDevice::GetServiceList(void) const +{ + return __pImpl->GetServiceList(); +} + +const Tizen::Base::Collection::IList* +BluetoothDevice::GetServiceUuidList(void) const +{ + return __pImpl->GetServiceUuidList(); +} + +bool +BluetoothDevice::Equals(const Tizen::Base::Object& obj) const +{ + const BluetoothDevice* pOther = dynamic_cast (&obj); + + if (pOther == null) + { + return false; + } + + if (pOther == this) + { + return true; + } + + return(__pImpl->Equals(*(pOther->__pImpl))); +} + +int +BluetoothDevice::GetHashCode(void) const +{ + return __pImpl->GetHashCode(); +} + +BluetoothDevice* +BluetoothDevice::GetInstanceFromAppControlResultN(const Tizen::Base::Collection::IList& appControlResult) +{ + BluetoothDevice* pNewBtDevice = null; + String* pResultStrPtr = null; + String keywordStr; + String dataStr; + ByteBuffer btAddrBytes; + String deviceName; + long majClassType = 0; + long minClassType = 0; + long svcClassType = 0; + long svcType = 0; + + ClearLastResult(); + + if (appControlResult.GetCount() != 7) + { + goto CATCH; + } + + pResultStrPtr = (String*) appControlResult.GetAt(0); + if (pResultStrPtr->Equals(String(Tizen::App::APPCONTROL_RESULT_SUCCEEDED)) == false) + { + goto CATCH; + } + + // Gets the address from index 1 as a String. E.g. 00-1E-2B-72-08-DB + pResultStrPtr = (String*) appControlResult.GetAt(1); + if ((pResultStrPtr->SubString(0, 9, keywordStr) != E_SUCCESS) || + (keywordStr.Equals(String("addr_val:")) == false) || + (pResultStrPtr->SubString(9, dataStr) != E_SUCCESS)) + { + goto CATCH; + } + + // Convert the type of the address to ByteBuffer + btAddrBytes.Construct(6); + if (_BluetoothDeviceImpl::GetAddressByteBuffer(dataStr, L"-", btAddrBytes) != E_SUCCESS) + { + goto CATCH; + } + + keywordStr.Clear(); + dataStr.Clear(); + + // Gets the name from index 2 + pResultStrPtr = (String*) appControlResult.GetAt(2); + if ((pResultStrPtr->SubString(0, 9, keywordStr) != E_SUCCESS) || + (keywordStr.Equals(String("dev_name:")) == false) || + (pResultStrPtr->SubString(9, deviceName) != E_SUCCESS)) + { + goto CATCH; + } + + keywordStr.Clear(); + + // Gets the major device class from index 3 + pResultStrPtr = (String*) appControlResult.GetAt(3); + if ((pResultStrPtr->SubString(0, 13, keywordStr) != E_SUCCESS) || + (keywordStr.Equals(String("maj_cls_type:")) == false) || + (pResultStrPtr->SubString(13, dataStr) != E_SUCCESS)) + { + goto CATCH; + } + + if (Long::Decode(dataStr, majClassType) != E_SUCCESS) + { + goto CATCH; + } + + keywordStr.Clear(); + dataStr.Clear(); + + // Gets the minor device class from index 4 + pResultStrPtr = (String*) appControlResult.GetAt(4); + if ((pResultStrPtr->SubString(0, 13, keywordStr) != E_SUCCESS) || + (keywordStr.Equals(String("min_cls_type:")) == false) || + (pResultStrPtr->SubString(13, dataStr) != E_SUCCESS)) + { + goto CATCH; + } + + if (Long::Decode(dataStr, minClassType) != E_SUCCESS) + { + goto CATCH; + } + + keywordStr.Clear(); + dataStr.Clear(); + + // Gets the service classes as a bit-mask from index 5 + pResultStrPtr = (String*) appControlResult.GetAt(5); + if ((pResultStrPtr->SubString(0, 13, keywordStr) != E_SUCCESS) || + (keywordStr.Equals(String("svc_cls_type:")) == false) || + (pResultStrPtr->SubString(13, dataStr) != E_SUCCESS)) + { + goto CATCH; + } + + if (Long::Decode(dataStr, svcClassType) != E_SUCCESS) + { + goto CATCH; + } + + keywordStr.Clear(); + dataStr.Clear(); + + // Gets the service types as a bit-mask from index 6 + pResultStrPtr = (String*) appControlResult.GetAt(6); + if ((pResultStrPtr->SubString(0, 9, keywordStr) != E_SUCCESS) || + (keywordStr.Equals(String("svc_type:")) == false) || + (pResultStrPtr->SubString(9, dataStr) != E_SUCCESS)) + { + goto CATCH; + } + + if (Long::Decode(dataStr, svcType) != E_SUCCESS) + { + goto CATCH; + } + + // Create an instance of BluetoothDevice. + pNewBtDevice = + new (std::nothrow) BluetoothDevice(btAddrBytes, deviceName, (BluetoothMajorDeviceClassType) majClassType, + (BluetoothMinorDeviceClassType) minClassType, svcClassType, + svcType); + if (pNewBtDevice == null) + { + SysLogException(NID_NET_BT, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] exception occurred on creating BluetoothDevice."); + SetLastResult(E_OUT_OF_MEMORY); + } + + return pNewBtDevice; + +CATCH: + + SysLogException(NID_NET_BT, E_INVALID_ARG, "[E_INVALID_ARG] exception occurred on parsing input data."); + SetLastResult(E_INVALID_ARG); + + return null; +} + +} } } // Tizen::Net::Bluetooth diff --git a/src/FNetBtBluetoothHealth.cpp b/src/FNetBtBluetoothHealth.cpp new file mode 100644 index 0000000..24fa8e8 --- /dev/null +++ b/src/FNetBtBluetoothHealth.cpp @@ -0,0 +1,151 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// @file FNetBtBluetoothHealth.cpp +// @brief This is the implementation file for the BluetoothHealth class. +// + +#include +#include +#include +#include +#include +#include +#include +#include "FNetBt_BluetoothHealthImpl.h" + +using namespace Tizen::Security; + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +BluetoothHealth::BluetoothHealth(void) + : __pImpl(null) +{ +} + +BluetoothHealth::~BluetoothHealth(void) +{ + delete __pImpl; +} + +result +BluetoothHealth::Construct(IBluetoothHealthEventListener& listener) +{ + result r = E_SUCCESS; + bool isBtSupported = false; + + Tizen::System::_SystemInfoImpl::GetSysInfo(L"http://tizen.org/feature/network.bluetooth", isBtSupported); + SysTryReturnResult(NID_NET_BT, isBtSupported == true, E_UNSUPPORTED_OPERATION, "Bluetooth is not supported."); + + SysAssertf(__pImpl == null, + "Already constructed. Calling Construct() twice or more on a same instance is not allowed for this class."); + + __pImpl = new (std::nothrow) _BluetoothHealthImpl; + SysTryReturnResult(NID_NET_BT, __pImpl != null, E_OUT_OF_MEMORY, "Creation of a _BluetoothHealthImpl instance failed."); + + r = __pImpl->Construct(listener); + + if (r != E_SUCCESS) + { + delete __pImpl; + __pImpl = null; + } + + return r; +} + +result +BluetoothHealth::StartAsSink(int dataType) +{ + result r = E_SUCCESS; + + // Privilege check + r = _AccessController::CheckUserPrivilege(_PRV_BLUETOOTH_HEALTH); + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_PRIVILEGE_DENIED, + "The application does not have the privilege to call this method."); + + // Check Construct + SysAssertf(__pImpl != null, "Not yet constructed. Construct() should be called before use."); + + return __pImpl->StartAsSink(dataType); +} + +result +BluetoothHealth::Stop(void) +{ + result r = E_SUCCESS; + + // Privilege check + r = _AccessController::CheckUserPrivilege(_PRV_BLUETOOTH_HEALTH); + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_PRIVILEGE_DENIED, + "The application does not have the privilege to call this method."); + + // Check Construct + SysAssertf(__pImpl != null, "Not yet constructed. Construct() should be called before use."); + + return __pImpl->Stop(); +} + +result +BluetoothHealth::ConnectToSource(const BluetoothDevice& remoteDevice) +{ + result r = E_SUCCESS; + + // Privilege check + r = _AccessController::CheckUserPrivilege(_PRV_BLUETOOTH_HEALTH); + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_PRIVILEGE_DENIED, + "The application does not have the privilege to call this method."); + + // Check Construct + SysAssertf(__pImpl != null, "Not yet constructed. Construct() should be called before use."); + + return __pImpl->ConnectToSource(remoteDevice); +} + +result +BluetoothHealth::Disconnect(int channelId) +{ + result r = E_SUCCESS; + + // Privilege check + r = _AccessController::CheckUserPrivilege(_PRV_BLUETOOTH_HEALTH); + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_PRIVILEGE_DENIED, + "The application does not have the privilege to call this method."); + + // Check Construct + SysAssertf(__pImpl != null, "Not yet constructed. Construct() should be called before use."); + + return __pImpl->Disconnect(channelId); +} + +result +BluetoothHealth::SendData(int channelId, const Tizen::Base::ByteBuffer& buffer) +{ + result r = E_SUCCESS; + + // Privilege check + r = _AccessController::CheckUserPrivilege(_PRV_BLUETOOTH_HEALTH); + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_PRIVILEGE_DENIED, + "The application does not have the privilege to call this method."); + + // Check Construct + SysAssertf(__pImpl != null, "Not yet constructed. Construct() should be called before use."); + + return __pImpl->SendData(channelId, buffer); +} + +} } } // Tizen::Net::Bluetooth diff --git a/src/FNetBtBluetoothManager.cpp b/src/FNetBtBluetoothManager.cpp new file mode 100644 index 0000000..e0bffbd --- /dev/null +++ b/src/FNetBtBluetoothManager.cpp @@ -0,0 +1,371 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// @file FNetBtBluetoothManager.cpp +// @brief This is the implementation file for the BluetoothManager class. +// + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "FNetBt_BluetoothManagerImpl.h" + +using namespace Tizen::Base; +using namespace Tizen::Base::Runtime; +using namespace Tizen::Base::Collection; +using namespace Tizen::Security; + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +BluetoothManager::BluetoothManager(void) + : __pImpl(null) +{ +} + +BluetoothManager::~BluetoothManager(void) +{ + delete __pImpl; +} + +result +BluetoothManager::Construct(IBluetoothManagerEventListener& listener) +{ + result r = E_SUCCESS; + bool isBtSupported = false; + + r = Tizen::System::_SystemInfoImpl::GetSysInfo(L"http://tizen.org/feature/network.bluetooth", isBtSupported); + SysTryReturnResult(NID_NET_BT, (r == E_SUCCESS) && (isBtSupported == true), E_UNSUPPORTED_OPERATION, + "Bluetooth is not supported."); + + SysAssertf(__pImpl == null, + "Already constructed. Calling Construct() twice or more on a same instance is not allowed for this class."); + + __pImpl = new (std::nothrow) _BluetoothManagerImpl; + + SysTryReturnResult(NID_NET_BT, __pImpl != null, E_OUT_OF_MEMORY, "Creation of a __pImpl instance failed."); + + r = __pImpl->Construct(listener); + + if (r != E_SUCCESS) + { + delete __pImpl; + __pImpl = null; + } + + return r; +} + +result +BluetoothManager::Activate(void) +{ + result r = E_SUCCESS; + + // Privilege check + r = _AccessController::CheckUserPrivilege(_PRV_BLUETOOTH_ADMIN); + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_PRIVILEGE_DENIED, + "The application does not have the privilege to call this method."); + + SysAssertf(__pImpl != null, "Not yet constructed. Construct() should be called before use."); + + return __pImpl->Activate(); +} + +result +BluetoothManager::Deactivate(void) +{ + result r = E_SUCCESS; + + // Privilege check + r = _AccessController::CheckUserPrivilege(_PRV_BLUETOOTH_ADMIN); + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_PRIVILEGE_DENIED, + "The application does not have the privilege to call this method."); + + SysAssertf(__pImpl != null, "Not yet constructed. Construct() should be called before use."); + + return __pImpl->Deactivate(); +} + +bool +BluetoothManager::IsAvailable(BluetoothConnectionType type) const +{ + SysAssertf(__pImpl != null, "Not yet constructed. Construct() should be called before use."); + + return __pImpl->IsAvailable(type); +} + +const BluetoothDevice* +BluetoothManager::GetLocalDevice(void) const +{ + ClearLastResult(); + SysAssertf(__pImpl != null, "Not yet constructed. Construct() should be called before use."); + + return __pImpl->GetLocalDevice(); +} + +Tizen::Base::String +BluetoothManager::GetLocalDeviceAddress(void) const +{ + SysAssertf(__pImpl != null, "Not yet constructed. Construct() should be called before use."); + + return __pImpl->GetLocalDeviceAddress(); +} + +Tizen::Base::String +BluetoothManager::GetLocalDeviceName(void) const +{ + SysAssertf(__pImpl != null, "Not yet constructed. Construct() should be called before use."); + + return __pImpl->GetLocalDeviceName(); +} + +BluetoothDeviceStateType +BluetoothManager::GetLocalDeviceState() const +{ + SysAssertf(__pImpl != null, "Not yet constructed. Construct() should be called before use."); + + return __pImpl->GetLocalDeviceState(); +} + +bool +BluetoothManager::IsActivated(void) const +{ + SysAssertf(__pImpl != null, "Not yet constructed. Construct() should be called before use."); + + return __pImpl->IsActivated(); +} + +BluetoothDiscoverableMode +BluetoothManager::GetDiscoverableMode(void) const +{ + SysAssertf(__pImpl != null, "Not yet constructed. Construct() should be called before use."); + + return __pImpl->GetDiscoverableMode(); +} + +int +BluetoothManager::GetRemainingTimeAsDiscoverable(void) const +{ + SysAssertf(__pImpl != null, "Not yet constructed. Construct() should be called before use."); + + return __pImpl->GetRemainingTimeAsDiscoverable(); +} + +bool +BluetoothManager::IsDiscoveryInProgress(void) const +{ + SysAssertf(__pImpl != null, "Not yet constructed. Construct() should be called before use."); + + return __pImpl->IsDiscoveryInProgress(); +} + +result +BluetoothManager::SetLocalDeviceName(const Tizen::Base::String& deviceName) +{ + result r = E_SUCCESS; + + // Privilege check + r = _AccessController::CheckUserPrivilege(_PRV_BLUETOOTH_ADMIN); + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_PRIVILEGE_DENIED, + "The application does not have the privilege to call this method."); + + SysAssertf(__pImpl != null, "Not yet constructed. Construct() should be called before use."); + + return __pImpl->SetLocalDeviceName(deviceName); +} + +result +BluetoothManager::SetDiscoverableMode(BluetoothDiscoverableMode mode, int seconds) +{ + SysAssertf(__pImpl != null, "Not yet constructed. Construct() should be called before use."); + + // Privilege check will be done by Impl class + return __pImpl->SetDiscoverableMode(mode, seconds); +} + +result +BluetoothManager::RefreshPairedDeviceList(void) +{ + SysAssertf(__pImpl != null, "Not yet constructed. Construct() should be called before use."); + + return __pImpl->RefreshPairedDeviceList(); +} + +const BluetoothDevice* +BluetoothManager::GetPairedDeviceByAddress(const Tizen::Base::ByteBuffer& deviceAddress) const +{ + ClearLastResult(); + + SysAssertf(__pImpl != null, "Not yet constructed. Construct() should be called before use."); + + return __pImpl->GetPairedDeviceByAddress(deviceAddress); +} + +BluetoothDevice* +BluetoothManager::GetPairedDeviceByAddressN(const Tizen::Base::ByteBuffer& deviceAddress) const +{ + ClearLastResult(); + + SysAssertf(__pImpl != null, "Not yet constructed. Construct() should be called before use."); + + return __pImpl->GetPairedDeviceByAddressN(deviceAddress); +} + +Tizen::Base::Collection::IList* +BluetoothManager::GetPairedDeviceByNameN(const Base::String& deviceName) const +{ + ClearLastResult(); + + SysAssertf(__pImpl != null, "Not yet constructed. Construct() should be called before use."); + + return __pImpl->GetPairedDeviceByNameN(deviceName); +} + +const BluetoothDevice* +BluetoothManager::GetPairedDeviceAt(int index) const +{ + ClearLastResult(); + + SysAssertf(__pImpl != null, "Not yet constructed. Construct() should be called before use."); + + return __pImpl->GetPairedDeviceAt(index); +} + +const Tizen::Base::Collection::IList* +BluetoothManager::GetPairedDeviceList(void) const +{ + ClearLastResult(); + + SysAssertf(__pImpl != null, "Not yet constructed. Construct() should be called before use."); + + return __pImpl->GetPairedDeviceList(); +} + +Tizen::Base::Collection::IList* +BluetoothManager::GetPairedDeviceListN(void) const +{ + ClearLastResult(); + + SysAssertf(__pImpl != null, "Not yet constructed. Construct() should be called before use."); + + return __pImpl->GetPairedDeviceListN(); +} + +result +BluetoothManager::SetBluetoothDeviceListener(IBluetoothDeviceEventListener* pListener) +{ + SysAssertf(__pImpl != null, "Not yet constructed. Construct() should be called before use."); + + return __pImpl->SetBluetoothDeviceListener(pListener); +} + +result +BluetoothManager::StartDiscovery(void) +{ + result r = E_SUCCESS; + + // Privilege check + r = _AccessController::CheckUserPrivilege(_PRV_BLUETOOTH_GAP); + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_PRIVILEGE_DENIED, + "The application does not have the privilege to call this method."); + + SysAssertf(__pImpl != null, "Not yet constructed. Construct() should be called before use."); + + return __pImpl->StartDiscovery(); +} + +result +BluetoothManager::CancelDiscovery(void) +{ + result r = E_SUCCESS; + + // Privilege check + r = _AccessController::CheckUserPrivilege(_PRV_BLUETOOTH_GAP); + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_PRIVILEGE_DENIED, + "The application does not have the privilege to call this method."); + + SysAssertf(__pImpl != null, "Not yet constructed. Construct() should be called before use."); + + return __pImpl->CancelDiscovery(); +} + +result +BluetoothManager::RetrieveServiceList(const BluetoothDevice& pairedDevice) +{ + result r = E_SUCCESS; + + // Privilege check + r = _AccessController::CheckUserPrivilege(_PRV_BLUETOOTH_GAP); + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_PRIVILEGE_DENIED, + "The application does not have the privilege to call this method."); + + SysAssertf(__pImpl != null, "Not yet constructed. Construct() should be called before use."); + + return __pImpl->RetrieveServiceList(pairedDevice); +} + +result +BluetoothManager::Pair(const BluetoothDevice& remoteDevice) +{ + result r = E_SUCCESS; + + // Privilege check + r = _AccessController::CheckUserPrivilege(_PRV_BLUETOOTH_GAP); + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_PRIVILEGE_DENIED, + "The application does not have the privilege to call this method."); + + SysAssertf(__pImpl != null, "Not yet constructed. Construct() should be called before use."); + + return __pImpl->Pair(remoteDevice); +} + +result +BluetoothManager::CancelPair(void) +{ + result r = E_SUCCESS; + + // Privilege check + r = _AccessController::CheckUserPrivilege(_PRV_BLUETOOTH_GAP); + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_PRIVILEGE_DENIED, + "The application does not have the privilege to call this method."); + + SysAssertf(__pImpl != null, "Not yet constructed. Construct() should be called before use."); + + return __pImpl->CancelPair(); +} + +result +BluetoothManager::Unpair(const BluetoothDevice& pairedDevice) +{ + result r = E_SUCCESS; + + // Privilege check + r = _AccessController::CheckUserPrivilege(_PRV_BLUETOOTH_GAP); + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_PRIVILEGE_DENIED, + "The application does not have the privilege to call this method."); + + SysAssertf(__pImpl != null, "Not yet constructed. Construct() should be called before use."); + + return __pImpl->Unpair(pairedDevice); +} + +} } } // Tizen::Net::Bluetooth diff --git a/src/FNetBtBluetoothOppClient.cpp b/src/FNetBtBluetoothOppClient.cpp new file mode 100644 index 0000000..bd33dc0 --- /dev/null +++ b/src/FNetBtBluetoothOppClient.cpp @@ -0,0 +1,111 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// @file FNetBtBluetoothOppClient.cpp +// @brief This is the implementation file for the BluetoothOppClient class. +// + +#include +#include +#include +#include +#include +#include +#include +#include "FNetBt_BluetoothOppClientImpl.h" + +using namespace Tizen::Security; + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +BluetoothOppClient::BluetoothOppClient(void) + : __pImpl(null) +{ +} + +BluetoothOppClient::~BluetoothOppClient(void) +{ + delete __pImpl; +} + +result +BluetoothOppClient::Construct(IBluetoothOppClientEventListener& listener) +{ + result r = E_SUCCESS; + bool isBtSupported = false; + + Tizen::System::_SystemInfoImpl::GetSysInfo(L"http://tizen.org/feature/network.bluetooth", isBtSupported); + SysTryReturnResult(NID_NET_BT, isBtSupported == true, E_UNSUPPORTED_OPERATION, "Bluetooth is not supported."); + + SysAssertf(__pImpl == null, "Already constructed. Calling Construct() twice or more on a same instance is not allowed for this class."); + + __pImpl = new (std::nothrow) _BluetoothOppClientImpl; + + SysTryReturnResult(NID_NET_BT, __pImpl != null, E_OUT_OF_MEMORY, "Creation of a _BluetoothOppClientImpl instance failed."); + + r = __pImpl->Construct(listener); + + if (r != E_SUCCESS) + { + delete __pImpl; + __pImpl = null; + } + + return r; +} + + +result +BluetoothOppClient::PushFile(const BluetoothDevice& remoteDevice, const Base::String& filePath) +{ + result r = E_SUCCESS; + + // Privilege check + r = _AccessController::CheckUserPrivilege(_PRV_BLUETOOTH_OPP); + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_PRIVILEGE_DENIED, "The application does not have the privilege to call this method."); + + // Check Construct + SysAssertf(__pImpl != null, "Not yet constructed. Construct() should be called before use."); + + return __pImpl->PushFile(remoteDevice, filePath); +} + +result +BluetoothOppClient::CancelPush(void) +{ + result r = E_SUCCESS; + + // Privilege check + r = _AccessController::CheckUserPrivilege(_PRV_BLUETOOTH_OPP); + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_PRIVILEGE_DENIED, "The application does not have the privilege to call this method."); + + // Check Construct + SysAssertf(__pImpl != null, "Not yet constructed. Construct() should be called before use."); + + return __pImpl->CancelPush(); +} + +result +BluetoothOppClient::SetMinProgressInterval(int percent) +{ + // Check Construct + SysAssertf(__pImpl != null, "Not yet constructed. Construct() should be called before use."); + + return __pImpl->SetMinProgressInterval(percent); +} + +} } } // Tizen::Net::Bluetooth diff --git a/src/FNetBtBluetoothOppServer.cpp b/src/FNetBtBluetoothOppServer.cpp new file mode 100644 index 0000000..6408760 --- /dev/null +++ b/src/FNetBtBluetoothOppServer.cpp @@ -0,0 +1,168 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// @file FNetBtBluetoothOppServer.cpp +// @brief This is the implementation file for the BluetoothOppServer class. +// + +#include +#include +#include +#include +#include +#include +#include "FNetBt_BluetoothOppServerImpl.h" + +using namespace Tizen::Security; + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +BluetoothOppServer::BluetoothOppServer(void) + : __pImpl(null) +{ +} + +BluetoothOppServer::~BluetoothOppServer(void) +{ + delete __pImpl; +} + +result +BluetoothOppServer::Construct(IBluetoothOppServerEventListener& listener) +{ + result r = E_SUCCESS; + bool isBtSupported = false; + + Tizen::System::_SystemInfoImpl::GetSysInfo(L"http://tizen.org/feature/network.bluetooth", isBtSupported); + SysTryReturnResult(NID_NET_BT, isBtSupported == true, E_UNSUPPORTED_OPERATION, "Bluetooth is not supported."); + + SysAssertf(__pImpl == null, + "Already constructed. Calling Construct() twice or more on a same instance is not allowed for this class."); + + __pImpl = new (std::nothrow) _BluetoothOppServerImpl; + SysTryReturnResult(NID_NET_BT, __pImpl != null, E_OUT_OF_MEMORY, "Creation of a _BluetoothOppServerImpl instance failed."); + + r = __pImpl->Construct(listener); + + if (r != E_SUCCESS) + { + delete __pImpl; + __pImpl = null; + } + + return r; +} + +result +BluetoothOppServer::AcceptPush(void) +{ + result r = E_SUCCESS; + + // Privilege check + r = _AccessController::CheckUserPrivilege(_PRV_BLUETOOTH_OPP); + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_PRIVILEGE_DENIED, + "The application does not have the privilege to call this method."); + + // Check Construct + SysAssertf(__pImpl != null, "Not yet constructed. Construct() should be called before use."); + + return __pImpl->AcceptPush(); +} + +result +BluetoothOppServer::RejectPush(void) +{ + result r = E_SUCCESS; + + // Privilege check + r = _AccessController::CheckUserPrivilege(_PRV_BLUETOOTH_OPP); + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_PRIVILEGE_DENIED, + "The application does not have the privilege to call this method."); + + // Check Construct + SysAssertf(__pImpl != null, "Not yet constructed. Construct() should be called before use."); + + return __pImpl->RejectPush(); +} + +result +BluetoothOppServer::SetDestinationPath(const Tizen::Base::String& dstPath) +{ + // Check Construct + SysAssertf(__pImpl != null, "Not yet constructed. Construct() should be called before use."); + + return __pImpl->SetDestinationPath(dstPath); +} + +result +BluetoothOppServer::SetMinProgressInterval(int percent) +{ + // Check Construct + SysAssertf(__pImpl != null, "Not yet constructed. Construct() should be called before use."); + + return __pImpl->SetMinProgressInterval(percent); +} + +result +BluetoothOppServer::StartService(const Tizen::Base::String& dstPath) +{ + result r = E_SUCCESS; + + // Privilege check + r = _AccessController::CheckUserPrivilege(_PRV_BLUETOOTH_OPP); + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_PRIVILEGE_DENIED, + "The application does not have the privilege to call this method."); + + // Check Construct + SysAssertf(__pImpl != null, "Not yet constructed. Construct() should be called before use."); + + return __pImpl->StartService(dstPath); +} + +result +BluetoothOppServer::StopService(void) +{ + result r = E_SUCCESS; + + // Privilege check + r = _AccessController::CheckUserPrivilege(_PRV_BLUETOOTH_OPP); + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_PRIVILEGE_DENIED, + "The application does not have the privilege to call this method."); + + // Check Construct + SysAssertf(__pImpl != null, "Not yet constructed. Construct() should be called before use."); + + return __pImpl->StopService(); +} + +result +BluetoothOppServer::StopTransfer(void) +{ + result r = E_SUCCESS; + + // Privilege check + r = _AccessController::CheckUserPrivilege(_PRV_BLUETOOTH_OPP); + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_PRIVILEGE_DENIED, + "The application does not have the privilege to call this method."); + + // Check Construct + SysAssertf(__pImpl != null, "Not yet constructed. Construct() should be called before use."); + + return __pImpl->StopTransfer(); +} + +} } } // Tizen::Net::Bluetooth diff --git a/src/FNetBtBluetoothSppAcceptor.cpp b/src/FNetBtBluetoothSppAcceptor.cpp new file mode 100644 index 0000000..658c6ca --- /dev/null +++ b/src/FNetBtBluetoothSppAcceptor.cpp @@ -0,0 +1,168 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// @file FNetBtBluetoothSppAcceptor.cpp +// @brief This is the implementation file for the BluetoothSppAcceptor class. +// + +#include +#include +#include +#include +#include +#include +#include +#include "FNetBt_BluetoothSppAcceptorImpl.h" + +using namespace Tizen::Security; + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +BluetoothSppAcceptor::BluetoothSppAcceptor(void) + : __pImpl(null) +{ +} + +BluetoothSppAcceptor::~BluetoothSppAcceptor(void) +{ + delete __pImpl; +} + +result +BluetoothSppAcceptor::Construct(IBluetoothSppAcceptorEventListener& listener) +{ + result r = E_SUCCESS; + bool isBtSupported = false; + + Tizen::System::_SystemInfoImpl::GetSysInfo(L"http://tizen.org/feature/network.bluetooth", isBtSupported); + SysTryReturnResult(NID_NET_BT, isBtSupported == true, E_UNSUPPORTED_OPERATION, "Bluetooth is not supported."); + + SysAssertf(__pImpl == null, + "Already constructed. Calling Construct() twice or more on a same instance is not allowed for this class."); + + __pImpl = new (std::nothrow) _BluetoothSppAcceptorImpl; + SysTryReturnResult(NID_NET_BT, __pImpl != null, E_OUT_OF_MEMORY, "Creation of a _BluetoothSppAcceptorImpl instance failed."); + + r = __pImpl->Construct(listener); + + if (r != E_SUCCESS) + { + delete __pImpl; + __pImpl = null; + } + + return r; +} + +result +BluetoothSppAcceptor::AcceptConnection(void) +{ + result r = E_SUCCESS; + + // Privilege check + r = _AccessController::CheckUserPrivilege(_PRV_BLUETOOTH_SPP); + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_PRIVILEGE_DENIED, "The application does not have the privilege to call this method."); + + // Check Construct + SysAssertf(__pImpl != null, "Not yet constructed. Construct() should be called before use."); + + return __pImpl->AcceptConnection(); +} + +result +BluetoothSppAcceptor::RejectConnection() +{ + result r = E_SUCCESS; + + // Privilege check + r = _AccessController::CheckUserPrivilege(_PRV_BLUETOOTH_SPP); + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_PRIVILEGE_DENIED, "The application does not have the privilege to call this method."); + + // Check Construct + SysAssertf(__pImpl != null, "Not yet constructed. Construct() should be called before use."); + + return __pImpl->RejectConnection(); +} + +result +BluetoothSppAcceptor::StartService(void) +{ + // Actually, E_INVALID_ARG never occur because the fixed SPP UUID is used. + return StartService(Tizen::Base::UuId(BT_SVC_UUID_SPP)); +} + +result +BluetoothSppAcceptor::StartService(const Tizen::Base::UuId& serviceUuid) +{ + result r = E_SUCCESS; + + // Privilege check + r = _AccessController::CheckUserPrivilege(_PRV_BLUETOOTH_SPP); + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_PRIVILEGE_DENIED, "The application does not have the privilege to call this method."); + + // Check Construct + SysAssertf(__pImpl != null, "Not yet constructed. Construct() should be called before use."); + + return __pImpl->StartService(serviceUuid); +} + +result +BluetoothSppAcceptor::StopService(void) +{ + result r = E_SUCCESS; + + // Privilege check + r = _AccessController::CheckUserPrivilege(_PRV_BLUETOOTH_SPP); + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_PRIVILEGE_DENIED, "The application does not have the privilege to call this method."); + + // Check Construct + SysAssertf(__pImpl != null, "Not yet constructed. Construct() should be called before use."); + + return __pImpl->StopService(); +} + +result +BluetoothSppAcceptor::SendData(const Tizen::Base::ByteBuffer& buffer) +{ + result r = E_SUCCESS; + + // Privilege check + r = _AccessController::CheckUserPrivilege(_PRV_BLUETOOTH_SPP); + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_PRIVILEGE_DENIED, "The application does not have the privilege to call this method."); + + // Check Construct + SysAssertf(__pImpl != null, "Not yet constructed. Construct() should be called before use."); + + return __pImpl->SendData(buffer); +} + +result +BluetoothSppAcceptor::Disconnect(void) +{ + result r = E_SUCCESS; + + // Privilege check + r = _AccessController::CheckUserPrivilege(_PRV_BLUETOOTH_SPP); + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_PRIVILEGE_DENIED, "The application does not have the privilege to call this method."); + + // Check Construct + SysAssertf(__pImpl != null, "Not yet constructed. Construct() should be called before use."); + + return __pImpl->Disconnect(); +} + +} } } // Tizen::Net::Bluetooth diff --git a/src/FNetBtBluetoothSppInitiator.cpp b/src/FNetBtBluetoothSppInitiator.cpp new file mode 100644 index 0000000..ecdf810 --- /dev/null +++ b/src/FNetBtBluetoothSppInitiator.cpp @@ -0,0 +1,125 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// @file FNetBtBluetoothSppInitiator.cpp +// @brief This is the implementation file for the BluetoothSppInitiator class. +// + +#include +#include +#include +#include +#include +#include +#include +#include +#include "FNetBt_BluetoothSppInitiatorImpl.h" + +using namespace Tizen::Security; + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +BluetoothSppInitiator::BluetoothSppInitiator(void) + : __pImpl(null) +{ +} + +BluetoothSppInitiator::~BluetoothSppInitiator(void) +{ + delete __pImpl; +} + +result +BluetoothSppInitiator::Construct(IBluetoothSppInitiatorEventListener& listener) +{ + result r = E_SUCCESS; + bool isBtSupported = false; + + Tizen::System::_SystemInfoImpl::GetSysInfo(L"http://tizen.org/feature/network.bluetooth", isBtSupported); + SysTryReturnResult(NID_NET_BT, isBtSupported == true, E_UNSUPPORTED_OPERATION, "Bluetooth is not supported."); + + SysAssertf(__pImpl == null, + "Already constructed. Calling Construct() twice or more on a same instance is not allowed for this class."); + + __pImpl = new (std::nothrow) _BluetoothSppInitiatorImpl; + SysTryReturnResult(NID_NET_BT, __pImpl != null, E_OUT_OF_MEMORY, + "Creation of a _BluetoothSppInitiatorImpl instance failed."); + + r = __pImpl->Construct(listener); + + if (r != E_SUCCESS) + { + delete __pImpl; + __pImpl = null; + } + + return r; +} + +result +BluetoothSppInitiator::SendData(const Tizen::Base::ByteBuffer& buffer) +{ + result r = E_SUCCESS; + + // Privilege check + r = _AccessController::CheckUserPrivilege(_PRV_BLUETOOTH_SPP); + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_PRIVILEGE_DENIED, "The application does not have the privilege to call this method."); + + // Check Construct + SysAssertf(__pImpl != null, "Not yet constructed. Construct() should be called before use."); + + return __pImpl->SendData(buffer); +} + +result +BluetoothSppInitiator::Connect(const BluetoothDevice& remoteDevice) +{ + // Actually, E_INVALID_ARG never occur because the fixed SPP UUID is used. + return Connect(remoteDevice, Tizen::Base::UuId(BT_SVC_UUID_SPP)); +} + +result +BluetoothSppInitiator::Connect(const BluetoothDevice& remoteDevice, const Tizen::Base::UuId& serviceUuid) +{ + result r = E_SUCCESS; + + // Privilege check + r = _AccessController::CheckUserPrivilege(_PRV_BLUETOOTH_SPP); + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_PRIVILEGE_DENIED, "The application does not have the privilege to call this method."); + + // Check Construct + SysAssertf(__pImpl != null, "Not yet constructed. Construct() should be called before use."); + + return __pImpl->Connect(remoteDevice, serviceUuid); +} + +result +BluetoothSppInitiator::Disconnect(void) +{ + result r = E_SUCCESS; + + // Privilege check + r = _AccessController::CheckUserPrivilege(_PRV_BLUETOOTH_SPP); + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_PRIVILEGE_DENIED, "The application does not have the privilege to call this method."); + + // Check Construct + SysAssertf(__pImpl != null, "Not yet constructed. Construct() should be called before use."); + + return __pImpl->Disconnect(); +} + +} } } // Tizen::Net::Bluetooth diff --git a/src/FNetBt_BluetoothAdapterUtility.cpp b/src/FNetBt_BluetoothAdapterUtility.cpp new file mode 100755 index 0000000..6a0f958 --- /dev/null +++ b/src/FNetBt_BluetoothAdapterUtility.cpp @@ -0,0 +1,911 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// @file FNetBt_BluetoothAdapterUtility.cpp +// @brief This is the implementation file for the _BluetoothAdapterUtility class. +// + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "FNetBt_BluetoothAdapterUtility.h" + +using namespace std; +using namespace Tizen::Base; +using namespace Tizen::Base::Collection; +using namespace Tizen::Base::Utility; + + +namespace Tizen { namespace Net { namespace Bluetooth +{ +class _BluetoothUuidMap; + +static _BluetoothUuidMap* pMapSingleton = null; + +/* + * @class _BluetoothUuidMap + * @brief The _BluetoothUuidMap class provides the method which converts UUID string to the long type value of + * BluetoothServiceType defined "FNetBtBluetoothTypes.h". + */ +class _BluetoothUuidMap + : public Tizen::Base::Object +{ +public: + _BluetoothUuidMap(void) {} + + virtual ~_BluetoothUuidMap(void) + { + //Clear all entries in the map + (void) __uuidMap.RemoveAll(true); + } + + static _BluetoothUuidMap* GetInstance(void) + { + static _BluetoothUuidMap uuidMap; + + // TODO: this singleton pattern to use a local static instance is not thread-safe. + if (!pMapSingleton) + { + if (uuidMap.Initialise() == E_SUCCESS) + { + pMapSingleton = &uuidMap; + } + } + + return pMapSingleton; + } + + long GetUuidLong(const Tizen::Base::String& uuidString) const + { + UuId uuid; + UuId::Parse(uuidString, uuid); + const Long* pUuidLongValue = null; + + pUuidLongValue = dynamic_cast (__uuidMap.GetValue(uuid)); + SysTryReturn(NID_NET_BT, pUuidLongValue != null, 0, E_SYSTEM, + "Getting UUID(%ls) value from map has failed.", uuidString.GetPointer()); + + return pUuidLongValue->ToLong(); + } + +private: + _BluetoothUuidMap(const _BluetoothUuidMap& value); + _BluetoothUuidMap& operator =(const _BluetoothUuidMap& value); + + result Initialise(void) + { + result r = E_SUCCESS; + + r = __uuidMap.Construct(); + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_SYSTEM, "Construction of map has failed."); + + __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_SPP)), *(new Long((long)(BT_SVC_SPP_SERVICE)))); + __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_LAP)), *(new Long((long) BT_SVC_LAP_SERVICE))); + __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_DUN)), *(new Long((long) BT_SVC_DUN_SERVICE))); + __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_SYNC)), *(new Long((long) BT_SVC_SYNC_SERVICE))); + __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_OPP)), *(new Long((long) BT_SVC_OPP_SERVICE))); + __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_FTP)), *(new Long((long) BT_SVC_FTP_SERVICE))); + __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_SYNC_COMMAND)), *(new Long((long) BT_SVC_SYNC_SERVICE))); + __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_HSP)), *(new Long((long) BT_SVC_HSP_SERVICE))); + __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_CTP)), *(new Long((long) BT_SVC_CTP_SERVICE))); + __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_A2DP_SOURCE)), *(new Long((long) BT_SVC_A2DP_SERVICE))); + __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_A2DP_SINK)), *(new Long((long) BT_SVC_A2DP_SERVICE))); + __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_AVRCP_TARGET)), *(new Long((long) BT_SVC_AVRCP_SERVICE))); + __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_A2DP)), *(new Long((long) BT_SVC_A2DP_SERVICE))); + __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_AVRCP)), *(new Long((long) BT_SVC_AVRCP_SERVICE))); + __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_AVRCP_CONTROLLER)), *(new Long((long) BT_SVC_AVRCP_SERVICE))); + __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_ICP)), *(new Long((long) BT_SVC_ICP_SERVICE))); + __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_FAX)), *(new Long((long) BT_SVC_FAX_SERVICE))); + __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_HSP_AG)), *(new Long((long) BT_SVC_HSP_SERVICE))); + __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_PAN_PANU)), *(new Long((long) BT_SVC_PANU_SERVICE))); + __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_PAN_NAP)), *(new Long((long) BT_SVC_NAP_SERVICE))); + __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_PAN_GN)), *(new Long((long) BT_SVC_GN_SERVICE))); + __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_BPP_DIRECT_PRINTING)), *(new Long((long) BT_SVC_BPP_SERVICE))); + __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_BPP_REFERENCE_PRINTING)), *(new Long((long) BT_SVC_BPP_SERVICE))); + __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_BIP)), *(new Long((long) BT_SVC_BIP_SERVICE))); + __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_BIP_RESPONDER)), *(new Long((long) BT_SVC_BIP_SERVICE))); + __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_BIP_AUTOMATIC_ARCHIVE)), *(new Long((long) BT_SVC_BIP_SERVICE))); + __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_BIP_REFERENCED_OBJECTS)), *(new Long((long) BT_SVC_BIP_SERVICE))); + __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_HFP)), *(new Long((long) BT_SVC_HFP_HS_SERVICE))); + __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_HFP_AG)), *(new Long((long) BT_SVC_HFP_SERVICE))); + __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_BPP_DIRECT_PRINTING_RO)), *(new Long((long) BT_SVC_BPP_SERVICE))); + __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_BPP_REFLECTED_UI)), *(new Long((long) BT_SVC_BPP_SERVICE))); + __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_BPP_BASIC_PRINTING)), *(new Long((long) BT_SVC_BPP_SERVICE))); + __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_BPP_PRINTING_STATUS)), *(new Long((long) BT_SVC_BPP_SERVICE))); + __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_HID)), *(new Long((long) BT_SVC_HID_SERVICE))); + __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_HCRP)), *(new Long((long) BT_SVC_HCRP_SERVICE))); + __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_HCRP_PRINT)), *(new Long((long) BT_SVC_HCRP_SERVICE))); + __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_HCRP_SCAN)), *(new Long((long) BT_SVC_HCRP_SERVICE))); + __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_SAP)), *(new Long((long) BT_SVC_SAP_SERVICE))); + __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_PBAP_PCE)), *(new Long((long) BT_SVC_PBAP_SERVICE))); + __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_PBAP_PSE)), *(new Long((long) BT_SVC_PBAP_SERVICE))); + __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_PBAP)), *(new Long((long) BT_SVC_PBAP_SERVICE))); + __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_HSP_HS)), *(new Long((long) BT_SVC_HSP_HS_SERVICE))); + __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_MAP_ACCESS_SERVER)), *(new Long((long) BT_SVC_MAP_SERVICE))); + __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_MAP_NOTIFICATION_SERVER)), *(new Long((long) BT_SVC_MAP_SERVICE))); + __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_MAP_ACCESS_PROFILE)), *(new Long((long) BT_SVC_MAP_SERVICE))); + __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_DID_PNP_INFORMATION)), *(new Long((long) BT_SVC_DID_SERVICE))); + __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_GENERIC_NETWORKING)), *(new Long((long) BT_SVC_NONE))); + __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_GENERIC_FILE_TRANSFER)), *(new Long((long) BT_SVC_NONE))); + __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_GENERIC_AUDIO)), *(new Long((long) BT_SVC_NONE))); + __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_GENERIC_TELEPHONY)), *(new Long((long) BT_SVC_NONE))); + __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_VDP_SOURCE)), *(new Long((long) BT_SVC_VDP_SERVICE))); + __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_VDP_SINK)), *(new Long((long) BT_SVC_VDP_SERVICE))); + __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_VDP_DISTRIBUTION)), *(new Long((long) BT_SVC_VDP_SERVICE))); + __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_HDP)), *(new Long((long) BT_SVC_HDP_SERVICE))); + __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_HDP_SOURCE)), *(new Long((long) BT_SVC_HDP_SERVICE))); + __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_HDP_SINK)), *(new Long((long) BT_SVC_HDP_SERVICE))); + + return E_SUCCESS; + } + +private: + Tizen::Base::Collection::HashMap __uuidMap; + +}; //_BluetoothUuidMap + +// defines local methods +void PrintMajorDeviceClass(BluetoothMajorDeviceClassType type); +void PrintMinorDeviceClass(BluetoothMajorDeviceClassType majType, BluetoothMinorDeviceClassType minType); +void PrintServiceClassList(unsigned long type); + + +_BluetoothAdapterUtility::_BluetoothAdapterUtility(void) +{ +} + +_BluetoothAdapterUtility::~_BluetoothAdapterUtility(void) +{ +} + + +BluetoothMajorDeviceClassType +_BluetoothAdapterUtility::ConvertToMajorDeviceClassType(bt_major_device_class_e majorClass) +{ + BluetoothMajorDeviceClassType convertedType = BT_COD_MAJ_DEV_CLS_UNCLASSIFIED; + + switch (majorClass) + { + case BT_MAJOR_DEVICE_CLASS_MISC: + convertedType = BT_COD_MAJ_DEV_CLS_MISC; + break; + + case BT_MAJOR_DEVICE_CLASS_COMPUTER: + convertedType = BT_COD_MAJ_DEV_CLS_COMPUTER; + break; + + case BT_MAJOR_DEVICE_CLASS_PHONE: + convertedType = BT_COD_MAJ_DEV_CLS_PHONE; + break; + + case BT_MAJOR_DEVICE_CLASS_LAN_NETWORK_ACCESS_POINT: + convertedType = BT_COD_MAJ_DEV_CLS_LAN_ACCESS_POINT; + break; + + case BT_MAJOR_DEVICE_CLASS_AUDIO_VIDEO: + convertedType = BT_COD_MAJ_DEV_CLS_AUDIO; + break; + + case BT_MAJOR_DEVICE_CLASS_PERIPHERAL: + convertedType = BT_COD_MAJ_DEV_CLS_PERIPHERAL; + break; + + case BT_MAJOR_DEVICE_CLASS_IMAGING: + convertedType = BT_COD_MAJ_DEV_CLS_IMAGING; + break; + + case BT_MAJOR_DEVICE_CLASS_WEARABLE: + case BT_MAJOR_DEVICE_CLASS_TOY: + case BT_MAJOR_DEVICE_CLASS_HEALTH: + case BT_MAJOR_DEVICE_CLASS_UNCATEGORIZED: + default: + convertedType = BT_COD_MAJ_DEV_CLS_UNCLASSIFIED; + break; + } + + return convertedType; +} + +BluetoothMinorDeviceClassType +_BluetoothAdapterUtility::ConvertToMinorDeviceClassType(bt_major_device_class_e majorClass, bt_minor_device_class_e minorClass) +{ + BluetoothMinorDeviceClassType convertedType = BT_COD_MIN_DEV_CLS_UNCLASSIFIED; + + if (majorClass == BT_MAJOR_DEVICE_CLASS_COMPUTER) + { + switch (minorClass) + { + case BT_MINOR_DEVICE_CLASS_COMPUTER_DESKTOP_WORKSTATION: + convertedType = BT_COD_MIN_DEV_CLS_DESKTOP_WORKSTATION; + break; + + case BT_MINOR_DEVICE_CLASS_COMPUTER_SERVER_CLASS: + convertedType = BT_COD_MIN_DEV_CLS_SERVER_CLASS_COMPUTER; + break; + + case BT_MINOR_DEVICE_CLASS_COMPUTER_LAPTOP: + convertedType = BT_COD_MIN_DEV_CLS_LAPTOP; + break; + + case BT_MINOR_DEVICE_CLASS_COMPUTER_HANDHELD_PC_OR_PDA: + convertedType = BT_COD_MIN_DEV_CLS_HANDHELD_PC_OR_PDA; + break; + + case BT_MINOR_DEVICE_CLASS_COMPUTER_PALM_SIZED_PC_OR_PDA: + convertedType = BT_COD_MIN_DEV_CLS_PALM_SIZED_PC_OR_PDA; + break; + + case BT_MINOR_DEVICE_CLASS_COMPUTER_WEARABLE_COMPUTER: + convertedType = BT_COD_MIN_DEV_CLS_WEARABLE_COMPUTER; + break; + + default: + convertedType = BT_COD_MIN_DEV_CLS_UNCLASSIFIED; + break; + } + } + else if (majorClass == BT_MAJOR_DEVICE_CLASS_PHONE) + { + switch (minorClass) + { + case BT_MINOR_DEVICE_CLASS_PHONE_CELLULAR: + convertedType = BT_COD_MIN_DEV_CLS_CELLULAR; + break; + + case BT_MINOR_DEVICE_CLASS_PHONE_CORDLESS: + convertedType = BT_COD_MIN_DEV_CLS_CORDLESS; + break; + + case BT_MINOR_DEVICE_CLASS_PHONE_SMART_PHONE: + convertedType = BT_COD_MIN_DEV_CLS_SMART_PHONE; + break; + + case BT_MINOR_DEVICE_CLASS_PHONE_WIRED_MODEM_OR_VOICE_GATEWAY: + convertedType = BT_COD_MIN_DEV_CLS_WIRED_MODEM_OR_VOICE_GATEWAY; + break; + + case BT_MINOR_DEVICE_CLASS_PHONE_COMMON_ISDN_ACCESS: + convertedType = BT_COD_MIN_DEV_CLS_COMMON_ISDN_ACCESS; + break; + + default: + convertedType = BT_COD_MIN_DEV_CLS_UNCLASSIFIED; + break; + } + } + else if (majorClass == BT_MAJOR_DEVICE_CLASS_LAN_NETWORK_ACCESS_POINT) + { + switch (minorClass) + { + case BT_MINOR_DEVICE_CLASS_LAN_NETWORK_ACCESS_POINT_FULLY_AVAILABLE: + convertedType = BT_COD_MIN_DEV_CLS_FULLY_AVAILABLE; + break; + + case BT_MINOR_DEVICE_CLASS_LAN_NETWORK_ACCESS_POINT_1_TO_17_PERCENT_UTILIZED: + convertedType = BT_COD_MIN_DEV_CLS_1_TO_17_PERCENT_UTILIZED; + break; + + case BT_MINOR_DEVICE_CLASS_LAN_NETWORK_ACCESS_POINT_17_TO_33_PERCENT_UTILIZED: + convertedType = BT_COD_MIN_DEV_CLS_17_TO_33_PERCENT_UTILIZED; + break; + + case BT_MINOR_DEVICE_CLASS_LAN_NETWORK_ACCESS_POINT_33_TO_50_PERCENT_UTILIZED : + convertedType = BT_COD_MIN_DEV_CLS_33_TO_50_PERCENT_UTILIZED; + break; + + case BT_MINOR_DEVICE_CLASS_LAN_NETWORK_ACCESS_POINT_50_to_67_PERCENT_UTILIZED: + convertedType = BT_COD_MIN_DEV_CLS_50_to_67_PERCENT_UTILIZED; + break; + + case BT_MINOR_DEVICE_CLASS_LAN_NETWORK_ACCESS_POINT_67_TO_83_PERCENT_UTILIZED: + convertedType = BT_COD_MIN_DEV_CLS_67_TO_83_PERCENT_UTILIZED; + break; + + case BT_MINOR_DEVICE_CLASS_LAN_NETWORK_ACCESS_POINT_83_TO_99_PERCENT_UTILIZED: + convertedType = BT_COD_MIN_DEV_CLS_83_TO_99_PERCENT_UTILIZED; + break; + + case BT_MINOR_DEVICE_CLASS_LAN_NETWORK_ACCESS_POINT_NO_SERVICE_AVAILABLE : + convertedType = BT_COD_MIN_DEV_CLS_NO_SERVICE_AVAILABLE; + break; + + default: + convertedType = BT_COD_MIN_DEV_CLS_UNCLASSIFIED; + break; + } + } + else if (majorClass == BT_MAJOR_DEVICE_CLASS_AUDIO_VIDEO) + { + switch (minorClass) + { + case BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_WEARABLE_HEADSET: + convertedType = BT_COD_MIN_DEV_CLS_HEADSET_PROFILE; + break; + + case BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_HANDS_FREE : + convertedType = BT_COD_MIN_DEV_CLS_HANDSFREE; + break; + + case BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_MICROPHONE: + case BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_LOUDSPEAKER: + case BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_HEADPHONES: + case BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_PORTABLE_AUDIO: + case BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_CAR_AUDIO: + case BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_SET_TOP_BOX: + case BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_HIFI_AUDIO_DEVICE: + case BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_VCR: + case BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_VIDEO_CAMERA: + case BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_CAMCORDER : + case BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_VIDEO_MONITOR: + case BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_VIDEO_DISPLAY_LOUDSPEAKER: + case BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_VIDEO_CONFERENCING: + case BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_GAMING_TOY: + default: + convertedType = BT_COD_MIN_DEV_CLS_UNCLASSIFIED; + break; + } + } + else if (majorClass == BT_MAJOR_DEVICE_CLASS_PERIPHERAL) + { + switch (minorClass) + { + case BT_MINOR_DEVICE_CLASS_PERIPHERAL_KEY_BOARD: + case BT_MINOR_DEVICE_CLASS_PERIPHERAL_POINTING_DEVICE: + case BT_MINOR_DEVICE_CLASS_PERIPHERAL_COMBO_KEYBOARD_POINTING_DEVICE : + case BT_MINOR_DEVICE_CLASS_PERIPHERAL_JOYSTICK: + case BT_MINOR_DEVICE_CLASS_PERIPHERAL_GAME_PAD: + case BT_MINOR_DEVICE_CLASS_PERIPHERAL_REMOTE_CONTROL: + case BT_MINOR_DEVICE_CLASS_PERIPHERAL_SENSING_DEVICE: + case BT_MINOR_DEVICE_CLASS_PERIPHERAL_DIGITIZER_TABLET: + case BT_MINOR_DEVICE_CLASS_PERIPHERAL_CARD_READER: + convertedType = BT_COD_MIN_DEV_CLS_SIM_CARD_READER; + break; + + case BT_MINOR_DEVICE_CLASS_PERIPHERAL_DIGITAL_PEN: + case BT_MINOR_DEVICE_CLASS_PERIPHERAL_HANDHELD_SCANNER: + case BT_MINOR_DEVICE_CLASS_PERIPHERAL_HANDHELD_GESTURAL_INPUT_DEVICE : + default: + convertedType = BT_COD_MIN_DEV_CLS_UNCLASSIFIED; + break; + } + } + else if (majorClass == BT_MAJOR_DEVICE_CLASS_IMAGING) + { + switch (minorClass) + { + case BT_MINOR_DEVICE_CLASS_IMAGING_DISPLAY: + case BT_MINOR_DEVICE_CLASS_IMAGING_CAMERA: + case BT_MINOR_DEVICE_CLASS_IMAGING_SCANNER: + case BT_MINOR_DEVICE_CLASS_IMAGING_PRINTER: + default: + convertedType = BT_COD_MIN_DEV_CLS_UNCLASSIFIED; + break; + } + } + else if (majorClass == BT_MAJOR_DEVICE_CLASS_WEARABLE) + { + switch (minorClass) + { + case BT_MINOR_DEVICE_CLASS_WEARABLE_WRIST_WATCH: + case BT_MINOR_DEVICE_CLASS_WEARABLE_PAGER: + case BT_MINOR_DEVICE_CLASS_WEARABLE_JACKET: + case BT_MINOR_DEVICE_CLASS_WEARABLE_HELMET: + case BT_MINOR_DEVICE_CLASS_WEARABLE_GLASSES: + default: + convertedType = BT_COD_MIN_DEV_CLS_UNCLASSIFIED; + break; + } + } + else if (majorClass == BT_MAJOR_DEVICE_CLASS_TOY) + { + switch (minorClass) + { + case BT_MINOR_DEVICE_CLASS_TOY_ROBOT: + case BT_MINOR_DEVICE_CLASS_TOY_VEHICLE: + case BT_MINOR_DEVICE_CLASS_TOY_DOLL_ACTION: + case BT_MINOR_DEVICE_CLASS_TOY_CONTROLLER: + case BT_MINOR_DEVICE_CLASS_TOY_GAME: + default: + convertedType = BT_COD_MIN_DEV_CLS_UNCLASSIFIED; + break; + } + } + else if (majorClass == BT_MAJOR_DEVICE_CLASS_HEALTH) + { + switch (minorClass) + { + case BT_MINOR_DEVICE_CLASS_HEATH_BLOOD_PRESSURE_MONITOR: + case BT_MINOR_DEVICE_CLASS_HEATH_THERMOMETER : + case BT_MINOR_DEVICE_CLASS_HEATH_WEIGHING_SCALE: + case BT_MINOR_DEVICE_CLASS_HEATH_GLUCOSE_METER: + case BT_MINOR_DEVICE_CLASS_HEATH_PULSE_OXIMETER: + case BT_MINOR_DEVICE_CLASS_HEATH_HEART_PULSE_RATE_MONITOR: + case BT_MINOR_DEVICE_CLASS_HEATH_DATA_DISPLAY: + case BT_MINOR_DEVICE_CLASS_HEATH_STEP_COUNTER: + case BT_MINOR_DEVICE_CLASS_HEATH_BODY_COMPOSITION_ANALYZER: + case BT_MINOR_DEVICE_CLASS_HEATH_PEAK_FLOW_MONITOR: + case BT_MINOR_DEVICE_CLASS_HEATH_MEDICATION_MONITOR : + case BT_MINOR_DEVICE_CLASS_HEATH_KNEE_PROSTHESIS: + case BT_MINOR_DEVICE_CLASS_HEATH_ANKLE_PROSTHESIS: + default: + convertedType = BT_COD_MIN_DEV_CLS_UNCLASSIFIED; + break; + } + } + else + { + convertedType = BT_COD_MIN_DEV_CLS_UNCLASSIFIED; + } + + return convertedType; +} + +unsigned long +_BluetoothAdapterUtility::ConvertToServiceClassList(int serviceClass) +{ + unsigned long serviceClassMask = 0; + + bt_major_service_class_e origianlClassList[] = + { + BT_MAJOR_SERVICE_CLASS_INFORMATION, + BT_MAJOR_SERVICE_CLASS_TELEPHONY, + BT_MAJOR_SERVICE_CLASS_AUDIO, + BT_MAJOR_SERVICE_CLASS_OBJECT_TRANSFER, + BT_MAJOR_SERVICE_CLASS_CAPTURING, + BT_MAJOR_SERVICE_CLASS_RENDERING, + BT_MAJOR_SERVICE_CLASS_NETWORKING, + BT_MAJOR_SERVICE_CLASS_POSITIONING, + BT_MAJOR_SERVICE_CLASS_LIMITED_DISCOVERABLE_MODE + }; + + BluetoothServiceClassType convertedClassList[] = + { + BT_COD_SVC_INFORMATION, + BT_COD_SVC_TELEPHONY, + BT_COD_SVC_AUDIO, + BT_COD_SVC_OBJECT_TRANSFER, + BT_COD_SVC_CAPTURING, + BT_COD_SVC_RENDERING, + BT_COD_SVC_NETWORKING, + BT_COD_SVC_POSITIONING, + BT_COD_SVC_LIMITED_DISCOVERABLE_MODE + }; + + for (int i = 0; i < 9; i++) + { + // checks the input value, 'serviceClass', has each value of the class list using bit masking + if (origianlClassList[i] == (serviceClass & origianlClassList[i])) + { + serviceClassMask += convertedClassList[i]; + } + } + + return serviceClassMask; +} + +unsigned long +_BluetoothAdapterUtility::ConvertToServiceList(char** pServiceUuid, int& serviceUuidCount) +{ + unsigned long serviceListMask = 0; + _BluetoothUuidMap* pMap = null; + + pMap = _BluetoothUuidMap::GetInstance(); + SysTryReturn(NID_NET_BT, pMap != null, 0, E_SYSTEM, "Converting UUID strings to a masked BluetoothServiceType value faild."); + + for (int i = 0; i < serviceUuidCount; i++) + { + String uuidString(pServiceUuid[i]); + long uuidLongValue = pMap->GetUuidLong(uuidString); + + serviceListMask |= uuidLongValue; + } + + return serviceListMask; +} + +Tizen::Base::Collection::IList* +_BluetoothAdapterUtility::ConvertServiceUuidListN(char** pServiceUuid, int& serviceUuidCount) +{ + unique_ptr pList; + UuId* pUuid = null; + + pList.reset(new (std::nothrow) ArrayList()); + SysTryReturn(NID_NET_BT, pList != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient."); + + for (int i = 0; i < serviceUuidCount; i++) + { + String uuidString(pServiceUuid[i]); + pUuid = new (std::nothrow) UuId(); + SysTryReturn(NID_NET_BT, pUuid != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient."); + uuidString.ToUpperCase(); + UuId::Parse(uuidString, *pUuid); + + pList->Add(*pUuid); + } + + return pList.release(); +} + +void +_BluetoothAdapterUtility::PrintDeviceInfo(const BluetoothDevice& device) +{ + SysLog(NID_NET_BT, "Bluetooth Device Information ============="); + SysLog(NID_NET_BT, "+ Address: [%ls]", _BluetoothDeviceImpl::GetAddressString(*(device.GetAddress())).GetPointer()); + SysLog(NID_NET_BT, "+ Name: %ls", device.GetName().GetPointer()); + SysLog(NID_NET_BT, "+ %s", device.IsPaired() ? "Paired" : "Not Paired"); + SysLog(NID_NET_BT, "+ RSSI: %d", device.GetRssi()); + PrintMajorDeviceClass(device.GetMajorDeviceClassType()); + PrintMinorDeviceClass(device.GetMajorDeviceClassType(), device.GetMinorDeviceClassType()); + PrintServiceClassList(device.GetServiceClassList()); + PrintServiceList(device.GetServiceList()); + PrintServiceUuidList(device.GetServiceUuidList()); +} + +void +_BluetoothAdapterUtility::PrintServiceList(unsigned long type) +{ + int index = 0; + unsigned long typeList[] = + { + BT_SVC_MAP_SERVICE, + BT_SVC_HDP_SERVICE, + BT_SVC_DID_SERVICE, + BT_SVC_HCRP_SERVICE, + BT_SVC_HFP_HS_SERVICE, + BT_SVC_HSP_HS_SERVICE, + BT_SVC_PBAP_SERVICE, + BT_SVC_VDP_SERVICE, + BT_SVC_HID_SERVICE, + BT_SVC_AVRCP_SERVICE, + BT_SVC_A2DP_SERVICE, + BT_SVC_SAP_SERVICE, + BT_SVC_GN_SERVICE, + BT_SVC_NAP_SERVICE, + BT_SVC_PANU_SERVICE, + BT_SVC_BIP_SERVICE, + BT_SVC_BPP_SERVICE, + BT_SVC_SYNC_SERVICE, + BT_SVC_ICP_SERVICE, + BT_SVC_CTP_SERVICE, + BT_SVC_FTP_SERVICE, + BT_SVC_OPP_SERVICE, + BT_SVC_HFP_SERVICE, + BT_SVC_HSP_SERVICE, + BT_SVC_LAP_SERVICE, + BT_SVC_FAX_SERVICE, + BT_SVC_DUN_SERVICE, + BT_SVC_SPP_SERVICE, + BT_SVC_RES_SERVICE + }; + const char* typeStrList[] = + { + "BT_SVC_MAP_SERVICE", + "BT_SVC_HDP_SERVICE", + "BT_SVC_DID_SERVICE", + "BT_SVC_HCRP_SERVICE", + "BT_SVC_HFP_HS_SERVICE", + "BT_SVC_HSP_HS_SERVICE", + "BT_SVC_PBAP_SERVICE", + "BT_SVC_VDP_SERVICE", + "BT_SVC_HID_SERVICE", + "BT_SVC_AVRCP_SERVICE", + "BT_SVC_A2DP_SERVICE", + "BT_SVC_SAP_SERVICE", + "BT_SVC_GN_SERVICE", + "BT_SVC_NAP_SERVICE", + "BT_SVC_PANU_SERVICE", + "BT_SVC_BIP_SERVICE", + "BT_SVC_BPP_SERVICE", + "BT_SVC_SYNC_SERVICE", + "BT_SVC_ICP_SERVICE", + "BT_SVC_CTP_SERVICE", + "BT_SVC_FTP_SERVICE", + "BT_SVC_OPP_SERVICE", + "BT_SVC_HFP_SERVICE", + "BT_SVC_HSP_SERVICE", + "BT_SVC_LAP_SERVICE", + "BT_SVC_FAX_SERVICE", + "BT_SVC_DUN_SERVICE", + "BT_SVC_SPP_SERVICE", + "BT_SVC_RES_SERVICE" + }; + + for (int i = 0; i < 29; i++) + { + // checks the input value, 'type', has each value of the service list using bit masking + if (typeList[i] == (type & typeList[i])) + { + SysLog(NID_NET_BT, "+ Service List[%d]: %s", index++, typeStrList[i]); + } + } +} + +void +_BluetoothAdapterUtility::PrintServiceUuidList(const Tizen::Base::Collection::IList* pList) +{ + int count = 0; + const UuId* pUuid = null; + + if (pList == null) + { + SysLog(NID_NET_BT, "+ No Service UUID (with error)"); + } + else + { + count = pList->GetCount(); + + if (count == 0) + { + SysLog(NID_NET_BT, "+ No Service UUID"); + } + + for (int i = 0; i < count; i++) + { + pUuid = dynamic_cast(pList->GetAt(i)); + if (pUuid != null) + { + SysLog(NID_NET_BT, "+ Service UUID[%d]: %ls", i, pUuid->ToString().GetPointer()); + } + } + } +} + +void PrintMajorDeviceClass(BluetoothMajorDeviceClassType type) +{ + const char* pTypeString = null; + + switch (type) + { + case BT_COD_MAJ_DEV_CLS_MISC: + pTypeString = "BT_COD_MAJ_DEV_CLS_MISC"; + break; + + case BT_COD_MAJ_DEV_CLS_COMPUTER: + pTypeString = "BT_COD_MAJ_DEV_CLS_COMPUTER"; + break; + + case BT_COD_MAJ_DEV_CLS_PHONE: + pTypeString = "BT_COD_MAJ_DEV_CLS_PHONE"; + break; + + case BT_COD_MAJ_DEV_CLS_LAN_ACCESS_POINT: + pTypeString = "BT_COD_MAJ_DEV_CLS_LAN_ACCESS_POINT"; + break; + + case BT_COD_MAJ_DEV_CLS_AUDIO: + pTypeString = "BT_COD_MAJ_DEV_CLS_AUDIO"; + break; + + case BT_COD_MAJ_DEV_CLS_PERIPHERAL: + pTypeString = "BT_COD_MAJ_DEV_CLS_PERIPHERAL"; + break; + + case BT_COD_MAJ_DEV_CLS_IMAGING: + pTypeString = "BT_COD_MAJ_DEV_CLS_IMAGING"; + break; + + case BT_COD_MAJ_DEV_CLS_UNCLASSIFIED: + pTypeString = "BT_COD_MAJ_DEV_CLS_UNCLASSIFIED"; + break; + + default: + pTypeString = "Unknown"; + break; + } + + SysLog(NID_NET_BT, "+ Major Device Type: %s", pTypeString); +} + +void PrintMinorDeviceClass(BluetoothMajorDeviceClassType majType, BluetoothMinorDeviceClassType minType) +{ + const char* pTypeString = null; + + switch (majType) + { + case BT_COD_MAJ_DEV_CLS_COMPUTER: + switch (minType) + { + case BT_COD_MIN_DEV_CLS_DESKTOP_WORKSTATION: + pTypeString = "BT_COD_MIN_DEV_CLS_DESKTOP_WORKSTATION"; + break; + + case BT_COD_MIN_DEV_CLS_SERVER_CLASS_COMPUTER: + pTypeString = "BT_COD_MIN_DEV_CLS_SERVER_CLASS_COMPUTER"; + break; + + case BT_COD_MIN_DEV_CLS_LAPTOP: + pTypeString = "BT_COD_MIN_DEV_CLS_LAPTOP"; + break; + + case BT_COD_MIN_DEV_CLS_HANDHELD_PC_OR_PDA: + pTypeString = "BT_COD_MIN_DEV_CLS_HANDHELD_PC_OR_PDA"; + break; + + case BT_COD_MIN_DEV_CLS_PALM_SIZED_PC_OR_PDA: + pTypeString = "BT_COD_MIN_DEV_CLS_PALM_SIZED_PC_OR_PDA"; + break; + + case BT_COD_MIN_DEV_CLS_WEARABLE_COMPUTER: + pTypeString = "BT_COD_MIN_DEV_CLS_WEARABLE_COMPUTER"; + break; + + default: + pTypeString = "Unclassified"; + break; + } + break; + + case BT_COD_MAJ_DEV_CLS_PHONE: + switch (minType) + { + case BT_COD_MIN_DEV_CLS_CELLULAR: + pTypeString = "BT_COD_MIN_DEV_CLS_CELLULAR"; + break; + + case BT_COD_MIN_DEV_CLS_CORDLESS: + pTypeString = "BT_COD_MIN_DEV_CLS_CORDLESS"; + break; + + case BT_COD_MIN_DEV_CLS_SMART_PHONE: + pTypeString = "BT_COD_MIN_DEV_CLS_SMART_PHONE"; + break; + + case BT_COD_MIN_DEV_CLS_WIRED_MODEM_OR_VOICE_GATEWAY: + pTypeString = "BT_COD_MIN_DEV_CLS_WIRED_MODEM_OR_VOICE_GATEWAY"; + break; + + case BT_COD_MIN_DEV_CLS_COMMON_ISDN_ACCESS: + pTypeString = "BT_COD_MIN_DEV_CLS_COMMON_ISDN_ACCESS"; + break; + + default: + pTypeString = "Unclassified"; + break; + } + break; + + case BT_COD_MAJ_DEV_CLS_LAN_ACCESS_POINT: + switch (minType) + { + case BT_COD_MIN_DEV_CLS_FULLY_AVAILABLE: + pTypeString = "BT_COD_MAJ_DEV_CLS_LAN_ACCESS_POINT"; + break; + + case BT_COD_MIN_DEV_CLS_1_TO_17_PERCENT_UTILIZED: + pTypeString = "BT_COD_MIN_DEV_CLS_1_TO_17_PERCENT_UTILIZED"; + break; + + case BT_COD_MIN_DEV_CLS_17_TO_33_PERCENT_UTILIZED: + pTypeString = "BT_COD_MIN_DEV_CLS_17_TO_33_PERCENT_UTILIZED"; + break; + + case BT_COD_MIN_DEV_CLS_33_TO_50_PERCENT_UTILIZED: + pTypeString = "BT_COD_MIN_DEV_CLS_33_TO_50_PERCENT_UTILIZED"; + break; + + case BT_COD_MIN_DEV_CLS_50_to_67_PERCENT_UTILIZED: + pTypeString = "BT_COD_MIN_DEV_CLS_50_to_67_PERCENT_UTILIZED"; + break; + + case BT_COD_MIN_DEV_CLS_67_TO_83_PERCENT_UTILIZED: + pTypeString = "BT_COD_MIN_DEV_CLS_67_TO_83_PERCENT_UTILIZED"; + break; + + case BT_COD_MIN_DEV_CLS_83_TO_99_PERCENT_UTILIZED: + pTypeString = "BT_COD_MIN_DEV_CLS_83_TO_99_PERCENT_UTILIZED"; + break; + + case BT_COD_MIN_DEV_CLS_NO_SERVICE_AVAILABLE: + pTypeString = "BT_COD_MIN_DEV_CLS_NO_SERVICE_AVAILABLE"; + break; + + default: + pTypeString = "Unclassified"; + break; + } + break; + + case BT_COD_MAJ_DEV_CLS_AUDIO: + switch (minType) + { + case BT_COD_MIN_DEV_CLS_HEADSET_PROFILE: + pTypeString = "BT_COD_MIN_DEV_CLS_HEADSET_PROFILE"; + break; + + case BT_COD_MIN_DEV_CLS_HANDSFREE: + pTypeString = "BT_COD_MIN_DEV_CLS_HANDSFREE"; + break; + + default: + pTypeString = "Unclassified"; + break; + } + break; + + case BT_COD_MAJ_DEV_CLS_PERIPHERAL: + switch (minType) + { + case BT_COD_MIN_DEV_CLS_SIM_CARD_READER: + pTypeString = "BT_COD_MIN_DEV_CLS_SIM_CARD_READER"; + break; + + default: + pTypeString = "Unclassified"; + break; + } + break; + + case BT_COD_MAJ_DEV_CLS_IMAGING: + case BT_COD_MAJ_DEV_CLS_MISC: + case BT_COD_MAJ_DEV_CLS_UNCLASSIFIED: + default: + pTypeString = "Unclassified"; + break; + } + + SysLog(NID_NET_BT, "+ Minor Device Type: %s", pTypeString); +} + +void PrintServiceClassList(unsigned long type) +{ + int index = 0; + unsigned long typeList[] = + { + BT_COD_SVC_INFORMATION, + BT_COD_SVC_TELEPHONY, + BT_COD_SVC_AUDIO, + BT_COD_SVC_OBJECT_TRANSFER, + BT_COD_SVC_CAPTURING, + BT_COD_SVC_RENDERING, + BT_COD_SVC_NETWORKING, + BT_COD_SVC_POSITIONING, + BT_COD_SVC_LIMITED_DISCOVERABLE_MODE + }; + const char* typeStrList[] = + { + "BT_COD_SVC_INFORMATION", + "BT_COD_SVC_TELEPHONY", + "BT_COD_SVC_AUDIO", + "BT_COD_SVC_OBJECT_TRANSFER", + "BT_COD_SVC_CAPTURING", + "BT_COD_SVC_RENDERING", + "BT_COD_SVC_NETWORKING", + "BT_COD_SVC_POSITIONING", + "BT_COD_SVC_LIMITED_DISCOVERABLE_MODE" + }; + + for (int i = 0; i < 9; i++) + { + if (typeList[i] == (type & typeList[i])) + { + // checks the input value, 'type', has each value of the service class list using bit masking + SysLog(NID_NET_BT, "+ Service Class List[%d]: %s", index++, typeStrList[i]); + } + } +} + +} } } // Tizen::Net::Bluetooth diff --git a/src/FNetBt_BluetoothConnectionEvent.cpp b/src/FNetBt_BluetoothConnectionEvent.cpp new file mode 100644 index 0000000..1bf160c --- /dev/null +++ b/src/FNetBt_BluetoothConnectionEvent.cpp @@ -0,0 +1,78 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// @file FNetBt_BluetoothConnectionEvent.cpp +// @brief This is the implementation file for the _BluetoothDeviceEvent class. +// + +#include +#include +#include +#include "FNetBt_BluetoothConnectionEvent.h" +#include "FNetBt_BluetoothConnectionEventArg.h" +#include "FNetBt_IBluetoothConnectionEventListener.h" + + +using namespace Tizen::Base; + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +_BluetoothConnectionEvent::_BluetoothConnectionEvent(void) + : __listenerCount(0) +{ +} + +_BluetoothConnectionEvent::~_BluetoothConnectionEvent(void) +{ +} + +result +_BluetoothConnectionEvent::Construct(void) +{ + return _Event::Initialize(); +} + +void +_BluetoothConnectionEvent::FireImpl(Tizen::Base::Runtime::IEventListener& listener, const Tizen::Base::Runtime::IEventArg& arg) +{ + _IBluetoothConnectionEventListener* pEventListener = dynamic_cast <_IBluetoothConnectionEventListener*>(&listener); + SysTryReturnVoidResult(NID_NET_BT, pEventListener != null, E_INVALID_ARG, + "[E_INVALID_ARG] The listener argument is invalid."); + + const _BluetoothConnectionEventArg* pEventArg = dynamic_cast (&arg); + SysTryReturnVoidResult(NID_NET_BT, pEventArg != null, E_INVALID_ARG, "[E_INVALID_ARG] The event argument is invalid type."); + + _BluetoothConnectionEventType eventType = pEventArg->GetEventType(); + + switch (eventType) + { + case _BT_CONNECTION_EVENT_CONNECTED: + SysLog(NID_NET_BT, "Firing Bluetooth Connection state changed Event (Type: _BT_CONNECTION_EVENT_CONNECTED)"); + pEventListener->OnBluetoothDeviceConnected(*pEventArg->GetRemoteAddress()); + break; + + case _BT_CONNECTION_EVENT_DISCONNECTED: + SysLog(NID_NET_BT, "Firing Bluetooth Connection state changed Event (Type: _BT_CONNECTION_EVENT_DISCONNECTED)"); + pEventListener->OnBluetoothDeviceDisconnected(*pEventArg->GetRemoteAddress()); + break; + + default: + break; + } +} + +} } } // Tizen::Net::Bluetooth diff --git a/src/FNetBt_BluetoothConnectionEvent.h b/src/FNetBt_BluetoothConnectionEvent.h new file mode 100644 index 0000000..bbeb028 --- /dev/null +++ b/src/FNetBt_BluetoothConnectionEvent.h @@ -0,0 +1,84 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +/** + * @file FNetBt_BluetoothConnectionEvent.h + * @brief This is the header file for the _BluetoothConnectionEvent class. + * + * This header file contains the declarations of the _BluetoothConnectionEvent class. + * The _BluetoothConnectionEvent class can call a method of a listener (IBluetoothConnectionEventListener object). + * So, when a device event is occurred, listener instances can handle it appropriately. + */ +#ifndef _FNET_BT_INTERNAL_BLUETOOTH_CONNECTION_EVENT_H_ +#define _FNET_BT_INTERNAL_BLUETOOTH_CONNECTION_EVENT_H_ + +#include +#include +#include + +// Forward declaration +namespace Tizen { namespace Base { namespace Runtime +{ +class IEventListener; +class IEventArg; +} } } + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +// +// @class _BluetoothConnectionEvent +// @brief This class handles Bluetooth connection events. +// +class _BluetoothConnectionEvent + : public Tizen::Base::Runtime::_Event +{ +public: + /** + * This is the default constructor. + */ + _BluetoothConnectionEvent(void); + + /** + * This is the class destructor. + */ + virtual ~_BluetoothConnectionEvent(void); + result Construct(void); + +protected: + /** + * Checks the argument and finds out the type of event. After that, this method calls appropriate pListener's method. + * + * @return A result code. + * @param[in] pListener An event listener related to this Bluetooth device event. + * @param[in] arg An event argument including information to be passed to the event listeners + * @exception E_SUCCESS The method is successful. + * @exception E_INVALID_ARG The argument passed to a method contains invalid values. + * @exception E_SYSTEM A system error occurred. + */ + virtual void FireImpl(Tizen::Base::Runtime::IEventListener& listener, const Tizen::Base::Runtime::IEventArg& arg); + +private: + _BluetoothConnectionEvent(const _BluetoothConnectionEvent& value); + _BluetoothConnectionEvent& operator =(const _BluetoothConnectionEvent& rhs); + +private: + int __listenerCount; + +}; // _BluetoothConnectionEvent + +} } } +#endif // _FNET_BT_INTERNAL_BLUETOOTH_CONNECTION_EVENT_H_ diff --git a/src/FNetBt_BluetoothConnectionEventArg.cpp b/src/FNetBt_BluetoothConnectionEventArg.cpp new file mode 100644 index 0000000..5390071 --- /dev/null +++ b/src/FNetBt_BluetoothConnectionEventArg.cpp @@ -0,0 +1,59 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// @file FNetBt_BluetoothConnectionEventArg.cpp +// @brief This is the implementation file for the _BluetoothConnectionEventArg class. +// + +#include +#include "FNetBt_BluetoothConnectionEventArg.h" + + +using namespace Tizen::Base; +using namespace Tizen::Base::Collection; + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +// +// This is a class constructor for _BT_CONNECTION_EVENT_CONNECTED and _BT_CONNECTION_EVENT_DISCONNECTED event. +// +_BluetoothConnectionEventArg::_BluetoothConnectionEventArg(_BluetoothConnectionEventType type, const Tizen::Base::ByteBuffer& address) + : __evtType(type) + , __pRemoteAddress(null) +{ + __pRemoteAddress = new (std::nothrow) ByteBuffer(); + __pRemoteAddress->Construct(address); +} + +_BluetoothConnectionEventArg::~_BluetoothConnectionEventArg(void) +{ + delete __pRemoteAddress; +} + +_BluetoothConnectionEventType +_BluetoothConnectionEventArg::GetEventType(void) const +{ + return __evtType; +} + +const ByteBuffer* +_BluetoothConnectionEventArg::GetRemoteAddress(void) const +{ + return __pRemoteAddress; +} + +} } } // Tizen::Net::Bluetooth diff --git a/src/FNetBt_BluetoothConnectionEventArg.h b/src/FNetBt_BluetoothConnectionEventArg.h new file mode 100644 index 0000000..154d88d --- /dev/null +++ b/src/FNetBt_BluetoothConnectionEventArg.h @@ -0,0 +1,101 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +/** + * @file FNetBt_BluetoothConnectionEventArg.h + * @brief This is the header file for the _BluetoothConnectionEventArg class. + * + * This header file contains the declarations of the _BluetoothConnectionEventArg class which includes information to be + * passed to the event listeners + */ +#ifndef _FNET_BT_INTERNAL_BLUETOOTH_CONNECTION_EVENT_ARG_H_ +#define _FNET_BT_INTERNAL_BLUETOOTH_CONNECTION_EVENT_ARG_H_ + +#include +#include +#include + +namespace Tizen { namespace Base +{ +class ByteBuffer; +} } + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +/** + * @enum _BluetoothConnectionEventType + * Type for specifying the type of _BluetoothConnectionEvent + */ +enum _BluetoothConnectionEventType +{ + _BT_CONNECTION_EVENT_CONNECTED, /**< For notifying that the device is connected */ + _BT_CONNECTION_EVENT_DISCONNECTED, /**< For notifying that the device is disconnected */ +}; + +/** + * @class _BluetoothConnectionEventArg + * @brief This class is used as an argument for callback methods of the _IBluetoothConnectionEventListener class. + * + * When a _BluetoothConnectionEvent occurs, the _BluetoothConnectionEvent finds a _IBluetoothConnectionEventListener instance + * which is registered for the _BluetoothConnectionEvent and calls an appropriate method of the listener. + * @see _IBluetoothConnectionEventListener + */ +class _BluetoothConnectionEventArg + : public Tizen::Base::Object + , public Tizen::Base::Runtime::IEventArg +{ +public: + + /** + * This is a class constructor for _BT_CONNECTION_EVENT_CONNECTED and _BT_CONNECTION_EVENT_DISCONNECTED event. + * + * @param[in] address the remote device address to be observed regarding connection + */ + _BluetoothConnectionEventArg(_BluetoothConnectionEventType type, const Tizen::Base::ByteBuffer& address); + + /** + * This is the class destructor. + */ + ~_BluetoothConnectionEventArg(void); + + /** + * Gets the type of this event. + * + * @return The type of the event + */ + _BluetoothConnectionEventType GetEventType(void) const; + + /** + * Gets the remote device address. + * + * @return the pointer of the remote device address which is a connected or disconnected device + */ + const Tizen::Base::ByteBuffer* GetRemoteAddress(void) const; + +private: + _BluetoothConnectionEventArg(void); + _BluetoothConnectionEventArg(const _BluetoothConnectionEventArg& eventArg); + _BluetoothConnectionEventArg& operator =(const _BluetoothConnectionEventArg& rValue); + +private: + _BluetoothConnectionEventType __evtType; + Tizen::Base::ByteBuffer* __pRemoteAddress; + +}; // _BluetoothConnectionEventArg + +} } } +#endif // _FNET_BT_INTERNAL_BLUETOOTH_CONNECTION_EVENT_ARG_H_ diff --git a/src/FNetBt_BluetoothDeviceEvent.cpp b/src/FNetBt_BluetoothDeviceEvent.cpp new file mode 100644 index 0000000..8fcd982 --- /dev/null +++ b/src/FNetBt_BluetoothDeviceEvent.cpp @@ -0,0 +1,124 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// @file FNetBt_BluetoothDeviceEvent.cpp +// @brief This is the implementation file for the _BluetoothDeviceEvent class. +// + +#include +#include +#include +#include +#include "FNetBt_BluetoothDeviceEvent.h" +#include "FNetBt_BluetoothDeviceEventArg.h" +#include "FNetBtIBluetoothDeviceEventListener.h" + + +using namespace Tizen::Base; + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +_BluetoothDeviceEvent::_BluetoothDeviceEvent(void) +{ +} + +_BluetoothDeviceEvent::~_BluetoothDeviceEvent(void) +{ +} + +result +_BluetoothDeviceEvent::Construct(void) +{ + return _Event::Initialize(); +} + +void +_BluetoothDeviceEvent::FireImpl(Tizen::Base::Runtime::IEventListener& listener, const Tizen::Base::Runtime::IEventArg& arg) +{ + const BluetoothDevice* pDevice = null; + + IBluetoothDeviceEventListener* pEventListener = dynamic_cast (&listener); + SysTryReturnVoidResult(NID_NET_BT, pEventListener != null, E_INVALID_ARG, + "[E_INVALID_ARG] The listener argument is invalid."); + + const _BluetoothDeviceEventArg* pEventArg = dynamic_cast (&arg); + SysTryReturnVoidResult(NID_NET_BT, pEventArg != null, E_INVALID_ARG, "[E_INVALID_ARG] The event argument is invalid type."); + + _BluetoothDeviceEventType eventType = pEventArg->GetEventType(); + + switch (eventType) + { + case _BT_DEVICE_EVENT_DISCOVERY_STARTED: + SysLog(NID_NET_BT, "Firing Bluetooth Device Event (Type: _BT_DEVICE_EVENT_DEVDISCOVERY_STARTED)"); + pEventListener->OnBluetoothDiscoveryStarted(pEventArg->GetErrorResult()); + break; + + case _BT_DEVICE_EVENT_DEVICE_FOUND: + pDevice = pEventArg->GetRemoteDevice(); + if (pDevice != null) + { + BluetoothDevice* pFoundDevice = new (std::nothrow) BluetoothDevice(*pDevice); + SysTryReturnVoidResult(NID_NET_BT, pFoundDevice != null, E_SYSTEM, + "[E_SYSTEM] Failed to copy the BluetoothDevice instance."); + + SysLog(NID_NET_BT, "Firing Bluetooth Device Event (Type: _BT_DEVICE_EVENT_DEVICE_FOUND)"); + pEventListener->OnBluetoothRemoteDeviceFoundN(pFoundDevice); + } + break; + + case _BT_DEVICE_EVENT_DISCOVERY_DONE: + SysLog(NID_NET_BT, "Firing Bluetooth Device Event (Type: _BT_DEVICE_EVENT_DEVDISCOVERY_DONE)"); + pEventListener->OnBluetoothDiscoveryDone(pEventArg->IsDiscoveryCompleted()); + break; + + case _BT_DEVICE_EVENT_SVCLIST_RECEIVED: + pDevice = pEventArg->GetRemoteDevice(); + if (pDevice != null) + { + SysLog(NID_NET_BT, "Firing Bluetooth Device Event (Type: _BT_DEVICE_EVENT_SVCLIST_RECEIVED)"); + pEventListener->OnBluetoothServiceListReceived(*pDevice, pEventArg->GetServiceList(), pEventArg->GetErrorResult()); + } + break; + + case _BT_DEVICE_EVENT_PAIRED: + SysLog(NID_NET_BT, "Firing Bluetooth Device Event (Type: _BT_DEVICE_EVENT_PAIRED)"); + pDevice = pEventArg->GetRemoteDevice(); + if (pDevice != null) + { + pEventListener->OnBluetoothPaired(*pDevice); + } + else + { + pEventListener->OnBluetoothPairingFailed(pEventArg->GetErrorResult()); + } + break; + + case _BT_DEVICE_EVENT_UNPAIRED: + pDevice = pEventArg->GetRemoteDevice(); + if (pDevice != null) + { + SysLog(NID_NET_BT, "Firing Bluetooth Device Event (Type: _BT_DEVICE_EVENT_UNPAIRED)"); + pEventListener->OnBluetoothUnpaired(*pDevice); + } + break; + + default: + break; + } +} + +} } } // Tizen::Net::Bluetooth diff --git a/src/FNetBt_BluetoothDeviceEvent.h b/src/FNetBt_BluetoothDeviceEvent.h new file mode 100644 index 0000000..d6d151c --- /dev/null +++ b/src/FNetBt_BluetoothDeviceEvent.h @@ -0,0 +1,84 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +/** + * @file FNetBt_BluetoothDeviceEvent.h + * @brief This is the header file for the _BluetoothDeviceEvent class. + * + * This header file contains the declarations of the _BluetoothDeviceEvent class. + * The _BluetoothDeviceEvent class can call a method of a listener (IBluetoothDeviceEventListener object). + * So, when a device event is occurred, listener instances can handle it appropriately. + */ +#ifndef _FNET_BT_INTERNAL_BLUETOOTH_DEVICE_EVENT_H_ +#define _FNET_BT_INTERNAL_BLUETOOTH_DEVICE_EVENT_H_ + +#include +#include +#include + +// Forward declaration +namespace Tizen { namespace Base { namespace Runtime +{ +class IEventListener; +class IEventArg; +} } } + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +// +// @class _BluetoothDeviceEvent +// @brief This class handles Bluetooth device events. +// +// When a Bluetooth device event occurs, the _BluetoothDeviceEvent object finds a IBluetoothDeviceEventListener object +// and calls an appropriate method of the listener. +// +class _BluetoothDeviceEvent + : public Tizen::Base::Runtime::_Event +{ +public: + /** + * This is the default constructor. + */ + _BluetoothDeviceEvent(void); + + /** + * This is the class destructor. + */ + virtual ~_BluetoothDeviceEvent(void); + result Construct(void); + +protected: + /** + * Checks the argument and finds out the type of event. After that, this method calls appropriate pListener's method. + * + * @return A result code. + * @param[in] pListener An event listener related to this Bluetooth device event. + * @param[in] arg An event argument including information to be passed to the event listeners + * @exception E_SUCCESS The method is successful. + * @exception E_INVALID_ARG The argument passed to a method contains invalid values. + * @exception E_SYSTEM A system error occurred. + */ + virtual void FireImpl(Tizen::Base::Runtime::IEventListener& listener, const Tizen::Base::Runtime::IEventArg& arg); + +private: + _BluetoothDeviceEvent(const _BluetoothDeviceEvent& value); + _BluetoothDeviceEvent& operator =(const _BluetoothDeviceEvent& rhs); + +}; // _BluetoothDeviceEvent + +} } } +#endif // _FNET_BT_INTERNAL_BLUETOOTH_DEVICE_EVENT_H_ diff --git a/src/FNetBt_BluetoothDeviceEventArg.cpp b/src/FNetBt_BluetoothDeviceEventArg.cpp new file mode 100755 index 0000000..57c996c --- /dev/null +++ b/src/FNetBt_BluetoothDeviceEventArg.cpp @@ -0,0 +1,136 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// @file FNetBt_BluetoothDeviceEventArg.cpp +// @brief This is the implementation file for the _BluetoothDeviceEventArg class. +// + +#include +#include +#include "FNetBt_BluetoothDeviceEventArg.h" + + +using namespace Tizen::Base; +using namespace Tizen::Base::Collection; + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +// +// This is a class constructor for _BT_DEVICE_EVENT_DISCOVERY_STARTED event. +// +_BluetoothDeviceEventArg::_BluetoothDeviceEventArg(result r) + : __evtType(_BT_DEVICE_EVENT_DISCOVERY_STARTED) + , __pRemoteDevice(null) + , __isCompleted(false) + , __serviceList(0) + , __result(r) +{ +} + +// +// This is a class constructor for _BT_DEVICE_EVENT_DISCOVERY_DONE event. +// +_BluetoothDeviceEventArg::_BluetoothDeviceEventArg(bool isCompleted) + : __evtType(_BT_DEVICE_EVENT_DISCOVERY_DONE) + , __pRemoteDevice(null) + , __isCompleted(isCompleted) + , __serviceList(0) + , __result(E_SUCCESS) +{ +} + +// +// This is a class constructor for _BT_DEVICE_EVENT_SVCLIST_RECEIVED event. +// +_BluetoothDeviceEventArg::_BluetoothDeviceEventArg(const BluetoothDevice& device, unsigned long serviceList, result r) + : __evtType(_BT_DEVICE_EVENT_SVCLIST_RECEIVED) + , __pRemoteDevice(null) + , __isCompleted(false) + , __serviceList(serviceList) + , __result(r) +{ + __pRemoteDevice = new (std::nothrow) BluetoothDevice(device); + SysTryReturnVoidResult(NID_NET_BT, __pRemoteDevice != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient."); +} + +// +// This is a class constructor for _BT_DEVICE_EVENT_DEVICE_FOUND and _BT_DEVICE_EVENT_UNPAIRED event. +// +_BluetoothDeviceEventArg::_BluetoothDeviceEventArg(_BluetoothDeviceEventType type, const BluetoothDevice& device) + : __evtType(type) + , __pRemoteDevice(null) + , __isCompleted(false) + , __serviceList(0) + , __result(E_SUCCESS) +{ + __pRemoteDevice = new (std::nothrow) BluetoothDevice(device); + SysTryReturnVoidResult(NID_NET_BT, __pRemoteDevice != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient."); +} + +// +// This is a class constructor for _BT_DEVICE_EVENT_PAIRED event. +// +_BluetoothDeviceEventArg::_BluetoothDeviceEventArg(const BluetoothDevice* pDevice, result r) + : __evtType(_BT_DEVICE_EVENT_PAIRED) + , __pRemoteDevice(null) + , __isCompleted(false) + , __serviceList(0) + , __result(r) +{ + if (pDevice != null) + { + __pRemoteDevice = new (std::nothrow) BluetoothDevice(*pDevice); + SysTryReturnVoidResult(NID_NET_BT, __pRemoteDevice != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient."); + } +} + +_BluetoothDeviceEventArg::~_BluetoothDeviceEventArg(void) +{ + delete __pRemoteDevice; +} + +_BluetoothDeviceEventType +_BluetoothDeviceEventArg::GetEventType(void) const +{ + return __evtType; +} + +const BluetoothDevice* +_BluetoothDeviceEventArg::GetRemoteDevice(void) const +{ + return __pRemoteDevice; +} + +bool +_BluetoothDeviceEventArg::IsDiscoveryCompleted(void) const +{ + return __isCompleted; +} + +unsigned long +_BluetoothDeviceEventArg::GetServiceList(void) const +{ + return __serviceList; +} + +result +_BluetoothDeviceEventArg::GetErrorResult(void) const +{ + return __result; +} + +} } } // Tizen::Net::Bluetooth diff --git a/src/FNetBt_BluetoothDeviceEventArg.h b/src/FNetBt_BluetoothDeviceEventArg.h new file mode 100644 index 0000000..af93a97 --- /dev/null +++ b/src/FNetBt_BluetoothDeviceEventArg.h @@ -0,0 +1,170 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +/** + * @file FNetBt_BluetoothDeviceEventArg.h + * @brief This is the header file for the _BluetoothDeviceEventArg class. + * + * This header file contains the declarations of the _BluetoothDeviceEventArg class which includes information to be + * passed to the event listeners + */ +#ifndef _FNET_BT_INTERNAL_BLUETOOTH_DEVICE_EVENT_ARG_H_ +#define _FNET_BT_INTERNAL_BLUETOOTH_DEVICE_EVENT_ARG_H_ + +#include +#include +#include +#include + + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +// Forward declaration +class BluetoothDevice; + +/** + * @enum _BluetoothDeviceEventType + * Type for specifying the type of _BluetoothDeviceEvent + */ +enum _BluetoothDeviceEventType +{ + _BT_DEVICE_EVENT_DISCOVERY_STARTED, /**< For notifying that the device discovery process is started */ + _BT_DEVICE_EVENT_DEVICE_FOUND, /**< For notifying that a new remote device is found */ + _BT_DEVICE_EVENT_DISCOVERY_DONE, /**< For notifying that the device discovery process is done */ + _BT_DEVICE_EVENT_SVCLIST_RECEIVED, /**< For notifying that the service list is received from a remote device */ + _BT_DEVICE_EVENT_PAIRED, /**< For notifying that the local device is newly paired with a remote device */ + _BT_DEVICE_EVENT_UNPAIRED, /**< For notifying that the local device is unpaired with the paired device */ +}; + +/** + * @class _BluetoothDeviceEventArg + * @brief This class is used as an argument for callback methods of the _IBluetoothDeviceEventListener class. + * + * When a _BluetoothDeviceEvent occurs, the _BluetoothDeviceEvent finds a _IBluetoothDeviceEventListener instance + * which is registered for the _BluetoothDeviceEvent and calls an appropriate method of the listener. + * @see _IBluetoothDeviceEventListener + */ +class _BluetoothDeviceEventArg + : public Tizen::Base::Object + , public Tizen::Base::Runtime::IEventArg +{ +public: + /** + * This is a class constructor for _BT_DEVICE_EVENT_DISCOVERY_STARTED event. + * + * @param[in] r The result of the event + * @exception E_SUCCESS The action was successful. + * @exception E_SYSTEM The action failed due to a system error. + */ + _BluetoothDeviceEventArg(result r); + + /** + * This is a class constructor for _BT_DEVICE_EVENT_DISCOVERY_DONE event. + * + * @param[in] isCompleted @c true, if the discovery is completely done @n + * @c false, otherwise + */ + _BluetoothDeviceEventArg(bool isCompleted); + + /** + * This is a class constructor for _BT_DEVICE_EVENT_SVCLIST_RECEIVED event. + * + * @param[in] device The target device which sent its service list + * @param[in] serviceList The service list received from the remote device + * @param[in] r The result of the event + * @exception E_SUCCESS The action was successful. + * @exception E_REMOTE_SERVICE_NOT_FOUND The action failed because the service list of the remote device is not found. + * @exception E_SYSTEM The action failed due to a system error. + */ + _BluetoothDeviceEventArg(const BluetoothDevice& device, unsigned long serviceList, result r); + + /** + * This is a class constructor for _BT_DEVICE_EVENT_DEVICE_FOUND and _BT_DEVICE_EVENT_UNPAIRED event. + * + * @param[in] type The type of the event - only _BT_DEVICE_EVENT_DEVICE_FOUND and + * _BT_DEVICE_EVENT_UNPAIRED are allowed + * @param[in] device The remote device + */ + _BluetoothDeviceEventArg(_BluetoothDeviceEventType type, const BluetoothDevice& device); + + /** + * This is a class constructor for _BT_DEVICE_EVENT_PAIRED. + * + * @param[in] pDevice The paired device + * @param[in] r The result of pairing + * @exception E_SUCCESS The method is successful. + * @exception E_SYSTEM A system error occurred. + */ + _BluetoothDeviceEventArg(const BluetoothDevice* pDevice, result r); + + /** + * This is the class destructor. + */ + ~_BluetoothDeviceEventArg(void); + + /** + * Gets the type of this event. + * + * @return The type of the event + */ + _BluetoothDeviceEventType GetEventType(void) const; + + /** + * Gets the remote device. + * + * @return The pointer of the remote device which is a found device, a paired, or an unpaired device + */ + const BluetoothDevice* GetRemoteDevice(void) const; + + /** + * Checks if the discovery is completely done. + * + * @return @c true, if the discovery is completely done @n + * @c false, otherwise + */ + bool IsDiscoveryCompleted(void) const; + + /** + * Gets the service list retrieved from a remote device. + * + * @return the service list which consists of masked BluetoothServiceType values + */ + unsigned long GetServiceList(void) const; + + /** + * Gets the error result of this event. + * + * @return The result of the event + */ + result GetErrorResult(void) const; + +private: + _BluetoothDeviceEventArg(void); + _BluetoothDeviceEventArg(const _BluetoothDeviceEventArg& eventArg); + _BluetoothDeviceEventArg& operator =(const _BluetoothDeviceEventArg& rValue); + +private: + _BluetoothDeviceEventType __evtType; + BluetoothDevice* __pRemoteDevice; + bool __isCompleted; + unsigned long __serviceList; + result __result; + +}; // _BluetoothDeviceEventArg + +} } } +#endif // _FNET_BT_INTERNAL_BLUETOOTH_DEVICE_EVENT_ARG_H_ diff --git a/src/FNetBt_BluetoothDeviceImpl.cpp b/src/FNetBt_BluetoothDeviceImpl.cpp new file mode 100755 index 0000000..4b7af09 --- /dev/null +++ b/src/FNetBt_BluetoothDeviceImpl.cpp @@ -0,0 +1,345 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// @file FNetBt_BluetoothDeviceImpl.cpp +// @brief This is the implementation file for the _BluetoothDeviceImpl class. +// + +#include +#include +#include +#include +#include +#include +#include "FNetBt_BluetoothDeviceImpl.h" + + +using namespace std; +using namespace Tizen::Base; +using namespace Tizen::Base::Utility; +using namespace Tizen::Base::Collection; + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +_BluetoothDeviceImpl::_BluetoothDeviceImpl(void) + : __deviceAddress() + , __deviceName() + , __isPaired(false) + , __rssi(0) + , __majorClassType(BT_COD_MAJ_DEV_CLS_MISC) + , __minorClassType(BT_COD_MIN_DEV_CLS_UNCLASSIFIED) + , __serviceClassList(BT_COD_SVC_UNKNOWN) + , __serviceList(BT_SVC_NONE) + , __pServiceUuidList(null) +{ + (void) __deviceAddress.Construct(BT_ADDRESS_LENGTH); + (void) __deviceAddress.SetPosition(0); +} + +_BluetoothDeviceImpl::_BluetoothDeviceImpl(const Tizen::Base::ByteBuffer& address, const Tizen::Base::String& deviceName, BluetoothMajorDeviceClassType majorClassType, BluetoothMinorDeviceClassType minorClassType, unsigned long serviceClassList, unsigned long serviceList) + : __deviceAddress() + , __deviceName(deviceName) + , __isPaired(false) + , __rssi(0) + , __majorClassType(majorClassType) + , __minorClassType(minorClassType) + , __serviceClassList(serviceClassList) + , __serviceList(serviceList) + , __pServiceUuidList(null) +{ + (void) __deviceAddress.Construct(address); + (void) __deviceAddress.SetPosition(0); +} + +_BluetoothDeviceImpl::_BluetoothDeviceImpl(const _BluetoothDeviceImpl& value) + : __deviceAddress() + , __deviceName(value.__deviceName) + , __isPaired(value.__isPaired) + , __rssi(value.__rssi) + , __majorClassType(value.__majorClassType) + , __minorClassType(value.__minorClassType) + , __serviceClassList(value.__serviceClassList) + , __serviceList(value.__serviceList) + , __pServiceUuidList(null) +{ + (void) __deviceAddress.Construct(value.__deviceAddress); + (void) __deviceAddress.SetPosition(0); + (void) SetServiceUuidList(value.__pServiceUuidList.get(), true); +} + +_BluetoothDeviceImpl::~_BluetoothDeviceImpl(void) +{ +} + +const Tizen::Base::ByteBuffer* +_BluetoothDeviceImpl::GetAddress(void) const +{ + return &__deviceAddress; +} + +Tizen::Base::String +_BluetoothDeviceImpl::GetName(void) const +{ + return __deviceName; +} + +bool +_BluetoothDeviceImpl::IsPaired(void) const +{ + return __isPaired; +} + +int +_BluetoothDeviceImpl::GetRssi(void) const +{ + return __rssi; +} + +BluetoothMajorDeviceClassType +_BluetoothDeviceImpl::GetMajorDeviceClassType(void) const +{ + return __majorClassType; +} + +BluetoothMinorDeviceClassType +_BluetoothDeviceImpl::GetMinorDeviceClassType(void) const +{ + return __minorClassType; +} + +unsigned long +_BluetoothDeviceImpl::GetServiceClassList(void) const +{ + return __serviceClassList; +} + +unsigned long +_BluetoothDeviceImpl::GetServiceList(void) const +{ + return __serviceList; +} + +const Tizen::Base::Collection::IList* +_BluetoothDeviceImpl::GetServiceUuidList(void) const +{ + return __pServiceUuidList.get(); +} + +bool +_BluetoothDeviceImpl::Equals(const Tizen::Base::Object& obj) const +{ + const _BluetoothDeviceImpl* pOther = dynamic_cast (&obj); + + if (pOther == null) + { + return false; + } + + if (pOther == this) + { + return true; + } + + return __deviceAddress.Equals(pOther->__deviceAddress); +} + +int +_BluetoothDeviceImpl::GetHashCode(void) const +{ + return GetAddressString(__deviceAddress).GetHashCode(); +} + +_BluetoothDeviceImpl& +_BluetoothDeviceImpl::operator =(const _BluetoothDeviceImpl& rhs) +{ + if (this != &rhs) + { + (void) __deviceAddress.SetArray(rhs.__deviceAddress.GetPointer(), 0, BT_ADDRESS_LENGTH); + (void) __deviceAddress.SetPosition(0); + + __deviceName = rhs.__deviceName; + __majorClassType = rhs.__majorClassType; + __minorClassType = rhs.__minorClassType; + __serviceClassList = rhs.__serviceClassList; + __serviceList = rhs.__serviceList; + (void) SetServiceUuidList(rhs.__pServiceUuidList.get(), true); + } + + return *this; +} + +result +_BluetoothDeviceImpl::SetAddress(const Tizen::Base::ByteBuffer& address) +{ + result r = E_SUCCESS; + + if ((address.GetLimit() < BT_ADDRESS_LENGTH) || (__deviceAddress.GetCapacity() < BT_ADDRESS_LENGTH)) + { + r = E_INVALID_ARG; + } + else + { + for (int i = 0; i < BT_ADDRESS_LENGTH; i++) + { + byte value = 0x00; + (void) address.GetByte(i, value); + (void) __deviceAddress.SetByte(i, value); + } + } + + return r; +} + +void +_BluetoothDeviceImpl::SetName(const Tizen::Base::String& name) +{ + __deviceName = name; +} + +void +_BluetoothDeviceImpl::SetMajorDeviceClassType(BluetoothMajorDeviceClassType type) +{ + __majorClassType = type; +} + +void +_BluetoothDeviceImpl::SetMinorDeviceClassType(BluetoothMinorDeviceClassType type) +{ + __minorClassType = type; +} + +void +_BluetoothDeviceImpl::SetServiceClassList(unsigned long listValue) +{ + __serviceClassList = listValue; +} + +void +_BluetoothDeviceImpl::SetServiceList(unsigned long serviceList) +{ + __serviceList = serviceList; +} + +void +_BluetoothDeviceImpl::SetPaired(bool isPaired) +{ + __isPaired = isPaired; +} + +void +_BluetoothDeviceImpl::SetRssi(int rssi) +{ + __rssi = rssi; +} + +result +_BluetoothDeviceImpl::SetServiceUuidList(const Tizen::Base::Collection::IList* pSrcUuidList, bool isDeepCopy) +{ + int count = 0; + unique_ptr pTempList; + + if (isDeepCopy == true) + { + if (pSrcUuidList != null) + { + pTempList.reset(new (std::nothrow) ArrayList()); + SysTryReturnResult(NID_NET_BT, pTempList != null, E_OUT_OF_MEMORY, "The memory is insufficient."); + + count = pSrcUuidList->GetCount(); + (void) pTempList->Construct(count); + + for (int i = 0; i < count; i++) + { + const UuId* pSrcUuid = dynamic_cast(pSrcUuidList->GetAt(i)); + SysTryReturnResult(NID_NET_BT, pSrcUuid != null, E_SYSTEM, "A failure occurred when copying an internal variable."); + + unique_ptr pNewUuid(new (std::nothrow) UuId(*pSrcUuid)); + SysTryReturnResult(NID_NET_BT, pNewUuid != null, E_OUT_OF_MEMORY, "The memory is insufficient."); + + pTempList->Add(*pNewUuid.release()); + } + } + + __pServiceUuidList.reset(pTempList.release()); + } + else + { + __pServiceUuidList.reset(const_cast(pSrcUuidList)); + } + + return E_SUCCESS; +} + +result +_BluetoothDeviceImpl::GetAddressByteBuffer(const Tizen::Base::String& srcAddr, const Tizen::Base::String& delimiters, Tizen::Base::ByteBuffer& dstAddr) +{ + result r = E_SUCCESS; + StringTokenizer strTok(srcAddr, delimiters); + int tokCount = strTok.GetTokenCount(); + String token; + short digit = 0; + + SysTryReturnResult(NID_NET_BT, tokCount == BT_ADDRESS_LENGTH, E_SYSTEM, "The address format is invalid."); + + for (int i = 0; i < BT_ADDRESS_LENGTH; i++) + { + (void) strTok.GetNextToken(token); + token.Insert(L"0X", 0); + r = Short::Decode(token, digit); + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_SYSTEM, "Parsing address has failed."); + r = dstAddr.SetByte(i, Short(digit).ToChar()); + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_SYSTEM, "The ByteBuffer argument is invalid."); + } + + SysLog(NID_NET_BT, "Translated address is [%ls]", GetAddressString(dstAddr).GetPointer()); + + return E_SUCCESS; +} + +Tizen::Base::String +_BluetoothDeviceImpl::GetAddressString(const Tizen::Base::ByteBuffer& address) +{ + String addressString(BT_ADDRESS_LENGTH * 3); + String hex; + byte value = 0x00; + + for (int i = 0; i < BT_ADDRESS_LENGTH; i++) + { + (void) address.GetByte(i, value); + (void) hex.Format(4, L"%02X:", value); + (void) addressString.Append(hex); + } + + // Removes the last delimiter + (void) addressString.Remove(addressString.GetLength() - 1, 1); + + return addressString; +} + +_BluetoothDeviceImpl* +_BluetoothDeviceImpl::GetInstance(BluetoothDevice& bluetoothDevice) +{ + return bluetoothDevice.__pImpl; +} + +const _BluetoothDeviceImpl* +_BluetoothDeviceImpl::GetInstance(const BluetoothDevice& bluetoothDevice) +{ + return bluetoothDevice.__pImpl; +} + +} } } // Tizen::Net::Bluetooth diff --git a/src/FNetBt_BluetoothGapSystemAdapter.cpp b/src/FNetBt_BluetoothGapSystemAdapter.cpp new file mode 100755 index 0000000..fa49bc1 --- /dev/null +++ b/src/FNetBt_BluetoothGapSystemAdapter.cpp @@ -0,0 +1,973 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// @file FNetBt_BluetoothGapSystemAdapter.cpp +// @brief This is the implementation file for the _BluetoothGapSystemAdapter class. +// + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "FNetBt_BluetoothGapSystemAdapter.h" +#include "FNetBt_BluetoothDeviceImpl.h" +#include "FNetBt_IBluetoothDeviceEventListener.h" +#include "FNetBt_IBluetoothManagerEventListener.h" +#include "FNetBt_BluetoothAdapterUtility.h" + +using namespace std; +using namespace Tizen::App; +using namespace Tizen::Base; +using namespace Tizen::Base::Collection; +using namespace Tizen::Base::Utility; +using namespace Tizen::Io; + +static const Tizen::Base::String _BT_ADDRESS_FILE_PATH(L"/opt/etc/.bd_addr"); + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +struct _DeviceInfoDeleter +{ + template + void operator()(bt_device_info_s* pDeviceInfo) + { + bt_adapter_free_device_info(pDeviceInfo); + } +}; + +_BluetoothGapSystemAdapter* _BluetoothGapSystemAdapter::__pInstance = null; + +_BluetoothGapSystemAdapter::_BluetoothGapSystemAdapter(void) + : __mgrEvtListenerList() + , __devEvtListenerList() +{ +} + +_BluetoothGapSystemAdapter::~_BluetoothGapSystemAdapter(void) +{ + // unset all the system callback methods + bt_adapter_unset_state_changed_cb(); + bt_adapter_unset_device_discovery_state_changed_cb(); + bt_adapter_unset_visibility_mode_changed_cb(); + bt_device_unset_bond_created_cb(); + bt_device_unset_bond_destroyed_cb(); + bt_device_unset_service_searched_cb(); + bt_device_unset_connection_state_changed_cb(); +} + +void +_BluetoothGapSystemAdapter::InitSingleton(void) +{ + bool isConstructed = false; + static _BluetoothGapSystemAdapter inst; + + isConstructed = inst.Construct(); + SysTryReturnVoidResult(NID_NET_BT, isConstructed == true, E_SYSTEM, + "[E_SYSTEM] Construction of _BluetoothGapSystemAdpater fails."); + + __pInstance = &inst; +} + +_BluetoothGapSystemAdapter* +_BluetoothGapSystemAdapter::GetInstance(void) +{ + static pthread_once_t onceBlock = PTHREAD_ONCE_INIT; + + if (__pInstance == null) + { + ClearLastResult(); + pthread_once(&onceBlock, InitSingleton); + result r = GetLastResult(); + if (IsFailed(r)) + { + onceBlock = PTHREAD_ONCE_INIT; + } + } + + return __pInstance; +} + +bool +_BluetoothGapSystemAdapter::Construct(void) +{ + if (bt_initialize() == BT_ERROR_NONE) + { + //register all the call backs. + if ((bt_adapter_set_state_changed_cb(&OnAdapterStateChanged, NULL) == BT_ERROR_NONE) && + (bt_adapter_set_visibility_mode_changed_cb(&OnVisibilityModeChanged, NULL) == BT_ERROR_NONE) && + (bt_device_set_bond_created_cb(&OnPairingCompleted, NULL) == BT_ERROR_NONE) && + (bt_device_set_bond_destroyed_cb(&OnPairedDeviceRemoved, NULL) == BT_ERROR_NONE) && + (bt_adapter_set_device_discovery_state_changed_cb(&OnDeviceDiscoveryStateChanged, NULL) == BT_ERROR_NONE) && + (bt_device_set_service_searched_cb(&OnServiceDiscoveryCompleted, NULL) == BT_ERROR_NONE) && + (bt_device_set_connection_state_changed_cb(&OnConnectionStateChanged, NULL) == BT_ERROR_NONE)) + { + return true; + } + } + SysLog(NID_NET_BT, "Initialising the Bluetooth subsystem has failed"); + + return false; +} + +result +_BluetoothGapSystemAdapter::RegisterManagerEventListener(const _IBluetoothManagerEventListener& listener, bool isHighPriority) +{ + if (isHighPriority == true) + { + // insert the specified event listener at the begin of the list + return __mgrEvtListenerList.InsertAt(const_cast<_IBluetoothManagerEventListener*>(&listener), 0); + } + else + { + // insert the specified event listener at the end of the list + return __mgrEvtListenerList.Add(const_cast<_IBluetoothManagerEventListener*>(&listener)); + } +} + +result +_BluetoothGapSystemAdapter::UnregisterManagerEventListener(const _IBluetoothManagerEventListener& listener) +{ + + return __mgrEvtListenerList.Remove(const_cast<_IBluetoothManagerEventListener*>(&listener)); +} + +result +_BluetoothGapSystemAdapter::RegisterDeviceEventListener(const _IBluetoothDeviceEventListener& listener) +{ + return __devEvtListenerList.Add(const_cast<_IBluetoothDeviceEventListener*>(&listener)); +} + +result +_BluetoothGapSystemAdapter::UnregisterDeviceEventListener(const _IBluetoothDeviceEventListener& listener) +{ + return __devEvtListenerList.Remove(const_cast<_IBluetoothDeviceEventListener*>(&listener)); +} + +result +_BluetoothGapSystemAdapter::Activate(void) +{ + if (bt_adapter_enable() == BT_ERROR_NONE) + { + return E_SUCCESS; + } + return E_SYSTEM; +} + +result +_BluetoothGapSystemAdapter::Deactivate(void) +{ + if (bt_adapter_disable() == BT_ERROR_NONE) + { + return E_SUCCESS; + } + return E_SYSTEM; +} + +bool +_BluetoothGapSystemAdapter::IsActivated(void) const +{ + bt_adapter_state_e btAdapterState = BT_ADAPTER_DISABLED; + + if (bt_adapter_get_state(&btAdapterState) == BT_ERROR_NONE) + { + if (btAdapterState == BT_ADAPTER_ENABLED) + { + return true; + } + } + return false; +} + +bool +_BluetoothGapSystemAdapter::IsAvailable(BluetoothConnectionType type) const +{ + bool isAvailable = false; + bool isUsed = true; + char* pUuidStr = null; + + if (!IsActivated()) + { + SysLog(NID_NET_BT, "All connection type is not available because Bluetooth is not activated."); + return false; + } + + switch (type) + { + case BT_CONNECTION_GENERIC: + isAvailable = true; + break; + + case BT_CONNECTION_SPP_ACCEPTOR: + pUuidStr = _StringConverter::CopyToCharArrayN(UuId(BT_SVC_UUID_SPP).ToString()); + // TODO: meaning of bt_adapter_is_service_used() method is quite wrong + if ((pUuidStr != null) && (bt_adapter_is_service_used(pUuidStr, &isUsed) == BT_ERROR_NONE)) + { + SysLog(NID_NET_BT, "SPP(default UUID) server is %s.", isUsed ? "used" : "available"); + } + + isAvailable = isUsed ? false : true; + + delete[] pUuidStr; + break; + + case BT_CONNECTION_OPP_SERVER: + pUuidStr = _StringConverter::CopyToCharArrayN(UuId(BT_SVC_UUID_OPP).ToString()); + // TODO: meaning of bt_adapter_is_service_used() method is quite wrong + if ((pUuidStr != null) && (bt_adapter_is_service_used(pUuidStr, &isUsed) == BT_ERROR_NONE)) + { + SysLog(NID_NET_BT, "OPP server is %s.", isUsed ? "used" : "available"); + } + + isAvailable = isUsed ? false : true; + + delete[] pUuidStr; + break; + + // This is always true, because multiple SPP initiators can be run simultaneously since 3.0 + case BT_CONNECTION_SPP_INITIATOR: + isAvailable = true; + break; + + // The only one OPP client can be run per process. + case BT_CONNECTION_OPP_CLIENT: + isAvailable = true; + break; + + default: + break; + } + + return isAvailable; +} + +Tizen::Base::String +_BluetoothGapSystemAdapter::GetLocalDeviceAddress(void) const +{ + result r = E_SUCCESS; + int ret = 0; + ByteBuffer addressBuffer; + String localAddrString(_BT_ADDRESS_LENGTH*3); + char* pLocalAddr = null; + + ret = bt_adapter_get_address(&pLocalAddr); + + if (ret == BT_ERROR_NONE) + { + localAddrString = String(pLocalAddr); + } + else + { + File file; + int bufLimit; + byte curByte; + + // Opens the local cache file and gets the local address from it. + r = file.Construct(_BT_ADDRESS_FILE_PATH, L"r"); + SysTryReturn(NID_NET_BT, r == E_SUCCESS, localAddrString, E_SYSTEM, "Construction of the address info file has failed."); + + (void) file.Seek(FILESEEKPOSITION_BEGIN, 0); + + addressBuffer.Construct(_BT_ADDRESS_LENGTH*3); + r = file.Read(addressBuffer); + SysTryReturn(NID_NET_BT, r == E_SUCCESS, localAddrString, E_SYSTEM, "Read the address from the info file has failed."); + + bufLimit = addressBuffer.GetLimit(); + + for (int i = 0, addressIndex = 0 ; i < bufLimit ; i++) + { + addressBuffer.GetByte(i, curByte); + if ((curByte >= '0' && curByte <= '9') || + (curByte >= 'a' && curByte <= 'f') || + (curByte >= 'A' && curByte <= 'F')) + { + localAddrString.Append((char)curByte); + addressIndex++; + if ((addressIndex % 3 == 2) && (addressIndex < (_BT_ADDRESS_LENGTH * 3 - 1 ))) + { + // append ":" int the localAddrString to form a correct BT address format[aa:bb:cc:dd:ee:ff] + localAddrString.Append(':'); + addressIndex++; + } + } + } + + localAddrString.ToUpperCase(); + } + + return localAddrString; +} + +BluetoothDiscoverableMode +_BluetoothGapSystemAdapter::GetDiscoverableMode(void) const +{ + bt_adapter_visibility_mode_e visMode = BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE; + BluetoothDiscoverableMode discMode = BT_DISC_MODE_NOT_DISCOVERABLE; + + // CONNECTABLE is actually not exactly the same as NONE mode but dealt with as the same values herein. + // TODO: resolve the problem about failure when the BT adapter is disabled + if (bt_adapter_get_visibility(&visMode, null)== BT_ERROR_NONE) + { + if (visMode == BT_ADAPTER_VISIBILITY_MODE_GENERAL_DISCOVERABLE) + { + discMode = BT_DISC_MODE_DISCOVERABLE; + } + else if (visMode == BT_ADAPTER_VISIBILITY_MODE_LIMITED_DISCOVERABLE) + { + if (_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat()) + { + discMode = BT_DISC_MODE_DISCOVERABLE; + } + else + { + discMode = BT_DISC_MODE_TIME_LIMITED_DISCOVERABLE; + } + } + // BT_DISC_MODE_NOT_DISCOVERABLE, otherwise. + } + + return discMode; +} + +int +_BluetoothGapSystemAdapter::GetRemainingTimeAsDiscoverable(void) const +{ + bt_adapter_visibility_mode_e visMode = BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE; + int duration = 0; + int ret = 0; + + ret = bt_adapter_get_visibility(&visMode, &duration); + + if ((ret != BT_ERROR_NONE) || (visMode != BT_ADAPTER_VISIBILITY_MODE_LIMITED_DISCOVERABLE)) + { + SysLog(NID_NET_BT, "Not the time-limited discoverable mode! Remaining time is 0."); + } + + return duration; +} + +Tizen::Base::Collection::IList* +_BluetoothGapSystemAdapter::GetAllPairedDeviceListN(void) const +{ + ArrayList* pPairedDeviceList = null; + SysLog(NID_NET_BT, "Getting all paired device list..."); + + pPairedDeviceList = new (std::nothrow) ArrayList(); + + bt_adapter_state_e btAdapterState; + if (bt_adapter_get_state(&btAdapterState) == BT_ERROR_NONE) + { + if (btAdapterState == BT_ADAPTER_ENABLED) + { + if (bt_adapter_foreach_bonded_device(&OnPairedDeviceFound, pPairedDeviceList) != BT_ERROR_NONE) + { + pPairedDeviceList->RemoveAll(true); + delete pPairedDeviceList; + return null; + } + } + else //BT_ADAPTER_DISABLED + { + SysLog(NID_NET_BT, "Cannot get the paired device list because the Bluetooth apdater is disabled!!"); + } + } + + return pPairedDeviceList; +} + +result +_BluetoothGapSystemAdapter::Pair(const Tizen::Base::ByteBuffer& deviceAddress) +{ + result r = E_SYSTEM; + char* pPairDevAddr = null; + + SysTryReturnResult(NID_NET_BT, deviceAddress.GetRemaining() == _BT_ADDRESS_LENGTH, E_SYSTEM, + "The address of the remote device is incorrect."); + + pPairDevAddr = _StringConverter::CopyToCharArrayN(_BluetoothDeviceImpl::GetAddressString(deviceAddress)); + SysTryReturnResult(NID_NET_BT, pPairDevAddr != null, E_SYSTEM, "Address converting fails."); + + if (bt_device_create_bond(pPairDevAddr) == BT_ERROR_NONE) + { + r = E_SUCCESS; + } + + SysLog(NID_NET_BT, "Pairing with [%ls] %s.", _BluetoothDeviceImpl::GetAddressString(deviceAddress).GetPointer(), + r == E_SUCCESS ? "is successful" : "fails"); + + delete[] pPairDevAddr; + return r; +} + +result +_BluetoothGapSystemAdapter::CancelPair(void) +{ + result r = E_SYSTEM; + + if (bt_device_cancel_bonding() == BT_ERROR_NONE) + { + r = E_SUCCESS; + } + + SysLog(NID_NET_BT, "Cancel of bonding %s.", r == E_SUCCESS ? "is successful" : "fails"); + + return r; +} + +result +_BluetoothGapSystemAdapter::Unpair(const Tizen::Base::ByteBuffer& deviceAddress) +{ + result r = E_SYSTEM; + char* pUnpairDevAddr = null; + + SysTryReturnResult(NID_NET_BT, deviceAddress.GetRemaining() == _BT_ADDRESS_LENGTH, E_SYSTEM, + "The address of the remote device is incorrect."); + + pUnpairDevAddr = _StringConverter::CopyToCharArrayN(_BluetoothDeviceImpl::GetAddressString(deviceAddress)); + SysTryReturnResult(NID_NET_BT, pUnpairDevAddr != null, E_SYSTEM, "Address converting fails."); + + if (bt_device_destroy_bond(pUnpairDevAddr) == BT_ERROR_NONE) + { + r = E_SUCCESS; + } + + SysLog(NID_NET_BT, "Unpairing with [%ls] %s.", _BluetoothDeviceImpl::GetAddressString(deviceAddress).GetPointer(), + r == E_SUCCESS ? "is successful" : "fails"); + + delete[] pUnpairDevAddr; + return r; +} + +bool +_BluetoothGapSystemAdapter::IsPaired(const Tizen::Base::ByteBuffer& deviceAddress) const +{ + bool isPaired = false; + + if (deviceAddress.GetRemaining() != _BT_ADDRESS_LENGTH) + { + SysLog(NID_NET_BT, "The address of the remote device is incorrect."); + return false; + } + + char* pRemoteDevAddress = _StringConverter::CopyToCharArrayN(_BluetoothDeviceImpl::GetAddressString(deviceAddress)); + bt_device_info_s* pDeviceInfo = null; + + if (bt_adapter_get_bonded_device_info(pRemoteDevAddress, &pDeviceInfo) == BT_ERROR_NONE) + { + if (pDeviceInfo) + { + if (pDeviceInfo->is_bonded) + { + isPaired = true; + } + bt_adapter_free_device_info(pDeviceInfo); + } + } + + delete[] pRemoteDevAddress; + return isPaired; +} + +result +_BluetoothGapSystemAdapter::StartDiscovery(void) +{ + result r = E_SYSTEM; + + if (bt_adapter_start_device_discovery() == BT_ERROR_NONE) + { + r = E_SUCCESS; + } + + SysLog(NID_NET_BT, "Start of discovery %s.", r == E_SUCCESS ? "is successful" : "fails"); + + return r; +} + +result +_BluetoothGapSystemAdapter::CancelDiscovery(void) +{ + result r = E_SYSTEM; + + if (bt_adapter_stop_device_discovery() == BT_ERROR_NONE) + { + r = E_SUCCESS; + } + + SysLog(NID_NET_BT, "Cancel of discovery %s.", r == E_SUCCESS ? "is successful" : "fails"); + + return r; +} + +bool +_BluetoothGapSystemAdapter::IsDiscoveryInProgress(void) const +{ + bool is_discovering = false; + + (void) bt_adapter_is_discovering(&is_discovering); + + return is_discovering; +} + +result +_BluetoothGapSystemAdapter::RetrieveServiceList(const Tizen::Base::ByteBuffer& deviceAddress) +{ + result r = E_SYSTEM; + char* pDevAddr = null; + + SysTryReturnResult(NID_NET_BT, deviceAddress.GetRemaining() == _BT_ADDRESS_LENGTH, E_SYSTEM, + "The address of the remote device is incorrect."); + + pDevAddr = _StringConverter::CopyToCharArrayN(_BluetoothDeviceImpl::GetAddressString(deviceAddress)); + SysTryReturnResult(NID_NET_BT, pDevAddr != null, E_SYSTEM, "Address converting fails."); + + if (bt_device_start_service_search(pDevAddr) == BT_ERROR_NONE) + { + r = E_SUCCESS; + } + + SysLog(NID_NET_BT, "Retrieving the service list from [%ls] %s.", + _BluetoothDeviceImpl::GetAddressString(deviceAddress).GetPointer(), r == E_SUCCESS ? "is successful" : "fails"); + + delete[] pDevAddr; + return r; +} + +result +_BluetoothGapSystemAdapter::GetPairedDevice(const ByteBuffer& address, BluetoothDevice& pairedDevice) +{ + int err = BT_ERROR_NONE; + unique_ptr pDevAddr; + bt_device_info_s* pDeviceInfo = null; + unique_ptr pDeviceInfoPtr; + _BluetoothDeviceImpl* pDevImpl = null; + String convertedName; + + pDevAddr.reset(_StringConverter::CopyToCharArrayN(_BluetoothDeviceImpl::GetAddressString(address))); + SysTryReturnResult(NID_NET_BT, pDevAddr != null, E_SYSTEM, "Address converting fails."); + + err = bt_adapter_get_bonded_device_info(pDevAddr.get(), &pDeviceInfo); + SysTryReturnResult(NID_NET_BT, err == BT_ERROR_NONE, E_SYSTEM, "Getting paired device infomation has failed."); + pDeviceInfoPtr.reset(pDeviceInfo); + + pDevImpl = _BluetoothDeviceImpl::GetInstance(pairedDevice); + + // converts the UTF8 multibyte string to Unicode String + (void) StringUtil::Utf8ToString(pDeviceInfoPtr->remote_name, convertedName); + + pDevImpl->SetAddress(address); + pDevImpl->SetName(convertedName); + pDevImpl->SetPaired(pDeviceInfoPtr->is_bonded); + pDevImpl->SetMajorDeviceClassType(_BluetoothAdapterUtility::ConvertToMajorDeviceClassType( + pDeviceInfoPtr->bt_class.major_device_class)); + pDevImpl->SetMinorDeviceClassType(_BluetoothAdapterUtility::ConvertToMinorDeviceClassType( + pDeviceInfoPtr->bt_class.major_device_class, pDeviceInfoPtr->bt_class.minor_device_class)); + pDevImpl->SetServiceClassList(_BluetoothAdapterUtility::ConvertToServiceClassList( + pDeviceInfoPtr->bt_class.major_service_class_mask)); + pDevImpl->SetServiceList(_BluetoothAdapterUtility::ConvertToServiceList( + pDeviceInfoPtr->service_uuid, pDeviceInfoPtr->service_count)); + pDevImpl->SetServiceUuidList(_BluetoothAdapterUtility::ConvertServiceUuidListN( + pDeviceInfoPtr->service_uuid, pDeviceInfoPtr->service_count), false); + + return E_SUCCESS; +} + +void +_BluetoothGapSystemAdapter::OnAdapterStateChanged(int status, bt_adapter_state_e adapterState, void* pUserdata) +{ + result r = E_SUCCESS; + _IBluetoothManagerEventListener* pMgrEvtListener = null; + IEnumeratorT<_IBluetoothManagerEventListener*>* pEnum = null; + _BluetoothGapSystemAdapter* pGapAdapter = _BluetoothGapSystemAdapter::GetInstance(); + + if (status != BT_ERROR_NONE) + { + r = E_SYSTEM; + } + + pEnum = pGapAdapter->__mgrEvtListenerList.GetEnumeratorN(); + while (pEnum->MoveNext() == E_SUCCESS) + { + pEnum->GetCurrent(pMgrEvtListener); + if(adapterState == BT_ADAPTER_ENABLED) + { + pMgrEvtListener->OnBluetoothActivated(r); + } + else + { + pMgrEvtListener->OnBluetoothDeactivated(r); + } + } + + delete pEnum; +} + +void +_BluetoothGapSystemAdapter::OnVisibilityModeChanged(int result, bt_adapter_visibility_mode_e mode, void* pUserdata) +{ + _IBluetoothManagerEventListener* pMgrEvtListener = null; + IEnumeratorT<_IBluetoothManagerEventListener*>* pEnum = null; + _BluetoothGapSystemAdapter* pGapAdapter = _BluetoothGapSystemAdapter::GetInstance(); + BluetoothDiscoverableMode changedMode = BT_DISC_MODE_NOT_DISCOVERABLE; + + if (result == BT_ERROR_NONE) + { + switch (mode) + { + case BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE: + changedMode = BT_DISC_MODE_NOT_DISCOVERABLE; + break; + + case BT_ADAPTER_VISIBILITY_MODE_GENERAL_DISCOVERABLE: + changedMode = BT_DISC_MODE_DISCOVERABLE; + break; + + case BT_ADAPTER_VISIBILITY_MODE_LIMITED_DISCOVERABLE: + changedMode = BT_DISC_MODE_TIME_LIMITED_DISCOVERABLE; + break; + + default: + return; + } + + pEnum = pGapAdapter->__mgrEvtListenerList.GetEnumeratorN(); + while (pEnum->MoveNext() == E_SUCCESS) + { + pEnum->GetCurrent(pMgrEvtListener); + pMgrEvtListener->OnBluetoothDiscoverableModeChanged(changedMode); + } + + delete pEnum; + } +} + +void +_BluetoothGapSystemAdapter::OnDeviceDiscoveryStateChanged(int status, bt_adapter_device_discovery_state_e discoveryState, + bt_adapter_device_discovery_info_s* pDiscoveryInfo, void* pUserData) +{ + result r = E_SUCCESS; + _IBluetoothDeviceEventListener* pDevEventListener = null; + IEnumeratorT<_IBluetoothDeviceEventListener*>* pEnum = null; + _BluetoothGapSystemAdapter* pGapAdapter = _BluetoothGapSystemAdapter::GetInstance(); + + pEnum = pGapAdapter->__devEvtListenerList.GetEnumeratorN(); + + switch(discoveryState) + { + case BT_ADAPTER_DEVICE_DISCOVERY_STARTED: + { + if (status != BT_ERROR_NONE) + { + r = E_SYSTEM; + } + + while (pEnum->MoveNext() == E_SUCCESS) + { + pEnum->GetCurrent(pDevEventListener); + pDevEventListener->OnBluetoothDiscoveryStarted(r); + } + } + break; + + case BT_ADAPTER_DEVICE_DISCOVERY_FOUND: + { + BluetoothDevice foundDevice; + ByteBuffer deviceAddress; + deviceAddress.Construct(_BT_ADDRESS_LENGTH); + String convertedName; + + String tempDevAddr(pDiscoveryInfo->remote_address); + _BluetoothDeviceImpl::GetAddressByteBuffer(tempDevAddr, L":", deviceAddress); + + // converts the UTF8 multibyte string to Unicode String + (void) StringUtil::Utf8ToString(pDiscoveryInfo->remote_name, convertedName); + + _BluetoothDeviceImpl* pDevImpl = _BluetoothDeviceImpl::GetInstance(foundDevice); + + pDevImpl->SetAddress(deviceAddress); + pDevImpl->SetName(convertedName); + pDevImpl->SetPaired(pDiscoveryInfo->is_bonded); + pDevImpl->SetRssi(pDiscoveryInfo->rssi); + pDevImpl->SetMajorDeviceClassType(_BluetoothAdapterUtility::ConvertToMajorDeviceClassType( + pDiscoveryInfo->bt_class.major_device_class)); + pDevImpl->SetMinorDeviceClassType(_BluetoothAdapterUtility::ConvertToMinorDeviceClassType( + pDiscoveryInfo->bt_class.major_device_class, pDiscoveryInfo->bt_class.minor_device_class)); + pDevImpl->SetServiceClassList(_BluetoothAdapterUtility::ConvertToServiceClassList( + pDiscoveryInfo->bt_class.major_service_class_mask)); + pDevImpl->SetServiceList(_BluetoothAdapterUtility::ConvertToServiceList( + pDiscoveryInfo->service_uuid, pDiscoveryInfo->service_count)); + pDevImpl->SetServiceUuidList(_BluetoothAdapterUtility::ConvertServiceUuidListN( + pDiscoveryInfo->service_uuid, pDiscoveryInfo->service_count), false); + + _BluetoothAdapterUtility::PrintDeviceInfo(foundDevice); + + while (pEnum->MoveNext() == E_SUCCESS) + { + pEnum->GetCurrent(pDevEventListener); + pDevEventListener->OnBluetoothRemoteDeviceFound(foundDevice); + } + } + break; + + case BT_ADAPTER_DEVICE_DISCOVERY_FINISHED: + { + bool isCompleted = false; + + if (status == BT_ERROR_NONE) + { + isCompleted = true; // isCompleted is false in other cases including BT_ERROR_CANCEL + } + + while (pEnum->MoveNext() == E_SUCCESS) + { + pEnum->GetCurrent(pDevEventListener); + pDevEventListener->OnBluetoothDiscoveryDone(isCompleted); + } + } + break; + + default: + break; + } + + delete pEnum; +} + +void +_BluetoothGapSystemAdapter::OnServiceDiscoveryCompleted(int status, bt_device_sdp_info_s* pSdpInfo, void* pUserData) +{ + result r = E_SUCCESS; + _IBluetoothDeviceEventListener* pDevEventListener = null; + IEnumeratorT<_IBluetoothDeviceEventListener*>* pEnum = null; + ByteBuffer deviceAddress; + deviceAddress.Construct(_BT_ADDRESS_LENGTH); + unsigned long serviceList = 0; + Tizen::Base::Collection::IList* pServiceUuidList= null; + _BluetoothGapSystemAdapter* pGapAdapter = _BluetoothGapSystemAdapter::GetInstance(); + + String tempDevAddr(pSdpInfo->remote_address); + r = _BluetoothDeviceImpl::GetAddressByteBuffer(tempDevAddr, L":", deviceAddress); + + if (status != BT_ERROR_NONE) + { + r = E_SYSTEM; + } + else + { + pServiceUuidList = _BluetoothAdapterUtility::ConvertServiceUuidListN( + pSdpInfo->service_uuid, pSdpInfo->service_count); + if (pServiceUuidList == null) + { + r = E_SYSTEM; + } + else + { + serviceList = _BluetoothAdapterUtility::ConvertToServiceList(pSdpInfo->service_uuid, pSdpInfo->service_count); + SysLog(NID_NET_BT, "Searched Service List ================="); + _BluetoothAdapterUtility::PrintServiceList(serviceList); + + SysLog(NID_NET_BT, "Searched Service UUID List ============"); + _BluetoothAdapterUtility::PrintServiceUuidList(pServiceUuidList); + } + } + + pEnum = pGapAdapter->__devEvtListenerList.GetEnumeratorN(); + + while (pEnum->MoveNext() == E_SUCCESS) + { + pEnum->GetCurrent(pDevEventListener); + pDevEventListener->OnBluetoothServiceListReceived(deviceAddress, serviceList, pServiceUuidList, r); + } + + delete pEnum; + // The ownership of UuId instances in the list is transferred to _BluetoothDeviceEventArg. + // Therefore, only the list except its elements is deleted here. + delete pServiceUuidList; +} + +void +_BluetoothGapSystemAdapter::OnPairingCompleted(int status, bt_device_info_s* pDeviceInfo, void* pUserdata) +{ + result r = E_SUCCESS; + _IBluetoothDeviceEventListener* pDevEventListener = null; + IEnumeratorT<_IBluetoothDeviceEventListener*>* pEnum = null; + BluetoothDevice pairingDevice; + _BluetoothGapSystemAdapter* pGapAdapter = _BluetoothGapSystemAdapter::GetInstance(); + ByteBuffer deviceAddress; + deviceAddress.Construct(_BT_ADDRESS_LENGTH); + String convertedName; + + SysTryReturnVoidResult(NID_NET_BT, pDeviceInfo != null, E_SYSTEM, + "[E_SYSTEM] the input param, DeviceInfo on callback is null."); + + String tempDevAddr(pDeviceInfo->remote_address); + (void) _BluetoothDeviceImpl::GetAddressByteBuffer(tempDevAddr, L":", deviceAddress); + + // converts the UTF8 multibyte string to Unicode String + (void) StringUtil::Utf8ToString(pDeviceInfo->remote_name, convertedName); + + _BluetoothDeviceImpl* pDevImpl = _BluetoothDeviceImpl::GetInstance(pairingDevice); + + pDevImpl->SetAddress(deviceAddress); + pDevImpl->SetName(convertedName); + pDevImpl->SetPaired(true); + pDevImpl->SetRssi(0); + pDevImpl->SetMajorDeviceClassType(_BluetoothAdapterUtility::ConvertToMajorDeviceClassType( + pDeviceInfo->bt_class.major_device_class)); + pDevImpl->SetMinorDeviceClassType(_BluetoothAdapterUtility::ConvertToMinorDeviceClassType( + pDeviceInfo->bt_class.major_device_class, pDeviceInfo->bt_class.minor_device_class)); + pDevImpl->SetServiceClassList(_BluetoothAdapterUtility::ConvertToServiceClassList( + pDeviceInfo->bt_class.major_service_class_mask)); + pDevImpl->SetServiceList(_BluetoothAdapterUtility::ConvertToServiceList( + pDeviceInfo->service_uuid, pDeviceInfo->service_count)); + pDevImpl->SetServiceUuidList(_BluetoothAdapterUtility::ConvertServiceUuidListN( + pDeviceInfo->service_uuid, pDeviceInfo->service_count), false); + + switch (status) + { + case BT_ERROR_NONE: + r = E_SUCCESS; + break; + case BT_ERROR_CANCELLED: + r = E_OPERATION_CANCELED; + break; + case BT_ERROR_TIMED_OUT: + r = E_TIMEOUT; + break; + default: + r = E_OPERATION_FAILED; + break; + } + + pEnum = pGapAdapter->__devEvtListenerList.GetEnumeratorN(); + while (pEnum->MoveNext() == E_SUCCESS) + { + pEnum->GetCurrent(pDevEventListener); + pDevEventListener->OnBluetoothPaired(&pairingDevice, r); + } + delete pEnum; +} + +void +_BluetoothGapSystemAdapter::OnPairedDeviceRemoved(int status, char* pRemoteAddress, void* pUserData) +{ + _IBluetoothDeviceEventListener* pDevEventListener = null; + IEnumeratorT<_IBluetoothDeviceEventListener*>* pEnum = null; + _BluetoothGapSystemAdapter* pGapAdapter = _BluetoothGapSystemAdapter::GetInstance(); + ByteBuffer deviceAddress; + deviceAddress.Construct(_BT_ADDRESS_LENGTH); + + if (status == BT_ERROR_NONE) + { + String tempDevAddr(pRemoteAddress); + _BluetoothDeviceImpl::GetAddressByteBuffer(tempDevAddr, L":", deviceAddress); + + pEnum = pGapAdapter->__devEvtListenerList.GetEnumeratorN(); + + while (pEnum->MoveNext() == E_SUCCESS) + { + pEnum->GetCurrent(pDevEventListener); + pDevEventListener->OnBluetoothUnpaired(deviceAddress); + } + + delete pEnum; + } + else + { + SysLog(NID_NET_BT, "Error in removing the Paired Device is %d", status); + } +} + +bool +_BluetoothGapSystemAdapter::OnPairedDeviceFound(bt_device_info_s* pDeviceInfo, void* pUserdata) +{ + ArrayList* pPairedDeviceList = static_cast(pUserdata); + + ByteBuffer btAddress; + btAddress.Construct(_BT_ADDRESS_LENGTH); + BluetoothDevice* pPairedDevice = null; + String convertedName; + + pPairedDevice = new (std::nothrow) BluetoothDevice(); + SysTryReturn(NID_NET_BT, pPairedDevice != null, false, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient."); + + String tempDevAddr(pDeviceInfo->remote_address); + _BluetoothDeviceImpl::GetAddressByteBuffer(tempDevAddr, L":", btAddress); + + // converts the UTF8 multibyte string to Unicode String + (void) StringUtil::Utf8ToString(pDeviceInfo->remote_name, convertedName); + + SysLog(NID_NET_BT, "Paired Device - (name: %ls)", convertedName.GetPointer()); + + _BluetoothDeviceImpl* pDevImpl = _BluetoothDeviceImpl::GetInstance(*pPairedDevice); + + pDevImpl->SetAddress(btAddress); + pDevImpl->SetName(convertedName); + pDevImpl->SetPaired(true); + pDevImpl->SetRssi(0); + pDevImpl->SetMajorDeviceClassType(_BluetoothAdapterUtility::ConvertToMajorDeviceClassType( + pDeviceInfo->bt_class.major_device_class)); + pDevImpl->SetMinorDeviceClassType(_BluetoothAdapterUtility::ConvertToMinorDeviceClassType( + pDeviceInfo->bt_class.major_device_class, pDeviceInfo->bt_class.minor_device_class)); + pDevImpl->SetServiceClassList(_BluetoothAdapterUtility::ConvertToServiceClassList( + pDeviceInfo->bt_class.major_service_class_mask)); + pDevImpl->SetServiceList(_BluetoothAdapterUtility::ConvertToServiceList( + pDeviceInfo->service_uuid, pDeviceInfo->service_count)); + pDevImpl->SetServiceUuidList(_BluetoothAdapterUtility::ConvertServiceUuidListN( + pDeviceInfo->service_uuid, pDeviceInfo->service_count), false); + + pPairedDeviceList->Add(*pPairedDevice); + + return true; +} + +void +_BluetoothGapSystemAdapter::OnConnectionStateChanged(bool isConnected, const char* pRemoteAddress, void* pUserdata) +{ + _IBluetoothDeviceEventListener* pDevEventListener = null; + IEnumeratorT<_IBluetoothDeviceEventListener*>* pEnum = null; + _BluetoothGapSystemAdapter* pGapAdapter = _BluetoothGapSystemAdapter::GetInstance(); + ByteBuffer deviceAddress; + deviceAddress.Construct(_BT_ADDRESS_LENGTH); + + String tempDevAddr(pRemoteAddress); + _BluetoothDeviceImpl::GetAddressByteBuffer(tempDevAddr, L":", deviceAddress); + + pEnum = pGapAdapter->__devEvtListenerList.GetEnumeratorN(); + + while (pEnum->MoveNext() == E_SUCCESS) + { + pEnum->GetCurrent(pDevEventListener); + if (isConnected) + { + pDevEventListener->OnBluetoothDeviceConnected(deviceAddress); + } + else + { + pDevEventListener->OnBluetoothDeviceDisconnected(deviceAddress); + } + } + + delete pEnum; +} + +} } } // Tizen::Net::Bluetooth diff --git a/src/FNetBt_BluetoothGapSystemAdapter.h b/src/FNetBt_BluetoothGapSystemAdapter.h new file mode 100644 index 0000000..68d5798 --- /dev/null +++ b/src/FNetBt_BluetoothGapSystemAdapter.h @@ -0,0 +1,323 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +/** + * @file FNetBt_BluetoothGapSystemAdapter.h + * @brief This is the header file for the _BluetoothGapSystemAdapter class. + * + * This header file contains the declaration of the _BluetoothGapSystemAdapter class. + */ +#ifndef _FNET_BT_INTERNAL_BLUETOOTH_GAP_SYSTEM_ADAPTER_H_ +#define _FNET_BT_INTERNAL_BLUETOOTH_GAP_SYSTEM_ADAPTER_H_ + +#include +#include +#include +#include +#include + +static const int _BT_ADDRESS_LENGTH = 6; + +// forward declarations +namespace Tizen { namespace Base { namespace Collection +{ +class IList; +} } } + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +// forward declarations +class BluetoothDevice; +class _IBluetoothDeviceEventListener; +class _IBluetoothManagerEventListener; +class _BluetoothIpcProxy; + +/** + * @class _BluetoothGapSystemAdapter + * @brief This class provides functions related to deliver the system events to the listeners such as + * _BluetoothManagerImpl. This class is a type of singleton, therefore only one instance should be allowed. + */ +class _BluetoothGapSystemAdapter + : public Tizen::Base::Object +{ +public: + /** + * Creates an instance of this class if there is no instance in this application context. + * Gets the exist instance because this class is a singleton, otherwise. + * + * @return the instance of this class + */ + static _BluetoothGapSystemAdapter* GetInstance(void); + + + /** + * Register an instance of _IBluetoothManagerEventListener interface into the internal list. + * + * @return An error code + * @param[in] listener The instance of _IBluetoothManagerEventListener to be registered + * @param[in] isHighPriority Set to @c true to register with the high priority, @n + * else @c false + * @exception E_SUCCESS The method is successful. + * @exception E_OUT_OF_MEMORY The memory is insufficient. + */ + result RegisterManagerEventListener(const _IBluetoothManagerEventListener& listener, bool isHighPriority); + + /** + * Unregister an instance of _IBluetoothManagerEventListener interface from the internal list. + * + * @return An error code + * @param[in] listener The instance of _IBluetoothManagerEventListener to be unregistered + * @exception E_SUCCESS The method is successful. + * @exception E_OBJ_NOT_FOUND The input instance is not registered. + */ + result UnregisterManagerEventListener(const _IBluetoothManagerEventListener& listener); + + /** + * Register an instance of _IBluetoothDeviceEventListener interface into the internal list. + * + * @return An error code + * @param[in] listener The instance of _IBluetoothDeviceEventListener to be registered + * @exception E_SUCCESS The method is successful. + * @exception E_OUT_OF_MEMORY The memory is insufficient. + */ + result RegisterDeviceEventListener(const _IBluetoothDeviceEventListener& listener); + + /** + * Unregister an instance of _IBluetoothDeviceEventListener interface from the internal list. + * + * @return An error code + * @param[in] listener The instance of _IBluetoothDeviceEventListener to be unregistered + * @exception E_SUCCESS The method is successful. + * @exception E_OBJ_NOT_FOUND The input instance is not registered. + */ + result UnregisterDeviceEventListener(const _IBluetoothDeviceEventListener& listener); + + /** + * Activates %Bluetooth module. + * + * @return An error code + * @exception E_SUCCESS The method is successful. + * @exception E_FAILURE The method failed. + */ + result Activate(void); + + /** + * Deactivates %Bluetooth module. + * + * @return An error code + * @exception E_SUCCESS The method is successful. + * @exception E_FAILURE The method failed. + */ + result Deactivate(void); + + /** + * Checks whether the %Bluetooth is activated or not. + * + * @return @c true, if activated @n + * @c false, otherwise + */ + bool IsActivated(void) const; + + /** + * Checks if the Bluetooth-specific profile is available. + * + * @return @c true if connection is available @n + * @c false, otherwise + * @param[in] type The connection type to check availability + */ + bool IsAvailable(BluetoothConnectionType type) const; + + /** + * Gets the local %Bluetooth device address. + * + * @return The local %Bluetooth device address + */ + Tizen::Base::String GetLocalDeviceAddress(void) const; + + /** + * Gets the discoverable mode of the local device. + * + * @return The discoverable mode of the local device + */ + BluetoothDiscoverableMode GetDiscoverableMode(void) const; + + /** + * Gets the remaining time, in seconds, until the local device is not discoverable. + * + * @return The remaining time, in seconds, until the local device to be not discoverable. + */ + int GetRemainingTimeAsDiscoverable(void) const; + + /** + * Gets all Paired Device list. + * + * @return Pointer to the paired device list on success @n + * @c null, otherwise. + * @remarks It is caller's responsibility that deletes the result list. + */ + Tizen::Base::Collection::IList* GetAllPairedDeviceListN(void) const; + + /** + * Pairs(Bonds) with the specified remote device. + * + * @return An error code + * @param[in] deviceAddress The address of a remote device to pair with + * @exception E_SUCCESS The method is successful. + * @exception E_SYSTEM A system error occurred. + */ + result Pair(const Tizen::Base::ByteBuffer& deviceAddress); + + /** + * Cancels the pairing in progress. + * + * @return An error code + * @exception E_SUCCESS The method is successful. + * @exception E_SYSTEM A system error occurred. + */ + result CancelPair(void); + + /** + * Unpairs(Unbonds) with the specified paired device. + * + * @return An error code + * @param[in] deviceAddress The address of the paired device to unpair with + * @exception E_SUCCESS The method is successful. + * @exception E_SYSTEM A system error occurred. + */ + result Unpair(const Tizen::Base::ByteBuffer& deviceAddress); + + /** + * Checks if this device is paired with the specified remote device. + * + * @return @c true if the device is paired @n + * @c false, otherwise + * @param[in] deviceAddress The address of a remote device to check + * @exception E_SUCCESS The method is successful. + * @exception E_SYSTEM A system error occurred. + */ + bool IsPaired(const Tizen::Base::ByteBuffer& deviceAddress) const; + + /** + * Starts a device discovery process. + * + * @return An error code + * @exception E_SUCCESS The method is successful. + * @exception E_SYSTEM A system error occurred. + */ + result StartDiscovery(void); + + /** + * Stops the discovery in progress. + * + * @return An error code + * @exception E_SUCCESS The method is successful. + * @exception E_SYSTEM A system error occurred. + */ + result CancelDiscovery(void); + + /** + * Checks whether the device discovery is in progress or not. + * + * @return @c true, if in progress @n + * @c false, otherwise + */ + bool IsDiscoveryInProgress(void) const; + + /** + * Retrieves the service list from a remote device. + * + * @return An error code + * @param[in] deviceAddress The address of a remote device which the service list is retrieved from + * @exception E_SUCCESS The method is successful. + * @exception E_SYSTEM A system error occurred. + */ + result RetrieveServiceList(const Tizen::Base::ByteBuffer& deviceAddress); + + + /** + * Gets the information of the specified paired device. + * + * @return An error code + * @param[in] address The address of a paired device + * @param[out] pairedDevice The remote device instance whose information to be filled in + * @exception E_SUCCESS The method is successful. + * @exception E_SYSTEM A system error occurred. + */ + static result GetPairedDevice(const Tizen::Base::ByteBuffer& address, BluetoothDevice& pairedDevice); + + /** + * Callback to notify the change in the state of Bluetooth adapter. + */ + static void OnAdapterStateChanged(int status, bt_adapter_state_e adapterState, void* pUserdata); + + /** + * Callback to notify the change in the visibility mode of Bluetooth adapter. + */ + static void OnVisibilityModeChanged(int result, bt_adapter_visibility_mode_e mode, void* pUserdata); + + /** + * Callback to notify when you get bonded devices repeatedly. + */ + static bool OnPairedDeviceFound(bt_device_info_s* pDeviceInfo, void* pUserdata); + + /** + * Callback to notify when the state of the device discovery changes. + */ + static void OnDeviceDiscoveryStateChanged(int status, bt_adapter_device_discovery_state_e discoveryState, + bt_adapter_device_discovery_info_s* pDiscoveryInfo, void* pUserdata); + + /** + * Callback to notify when the process of service discovery is completed. + */ + static void OnServiceDiscoveryCompleted(int status, bt_device_sdp_info_s* pSdpInfo, void* pUserdata); + + /** + * Callback to notify that a new remote device is paired with this local device. + */ + static void OnPairingCompleted(int status, bt_device_info_s* pDeviceInfo, void* pUserdata); + + /** + * Callback to notify that the already paired device is unpaired with this local device. + */ + static void OnPairedDeviceRemoved(int status, char* pRemoteAddress, void* pUserdata); + + /** + * Callback to notify when the state of the device connection changes. + */ + static void OnConnectionStateChanged(bool isConnected, const char* pRemoteAddress, void* pUserdata); + + +private: + _BluetoothGapSystemAdapter(void); + ~_BluetoothGapSystemAdapter(void); + + _BluetoothGapSystemAdapter(const _BluetoothGapSystemAdapter& value); + _BluetoothGapSystemAdapter& operator =(const _BluetoothGapSystemAdapter& value); + + bool Construct(void); + + static void InitSingleton(void); + +private: + Tizen::Base::Collection::LinkedListT<_IBluetoothManagerEventListener*> __mgrEvtListenerList; + Tizen::Base::Collection::LinkedListT<_IBluetoothDeviceEventListener*> __devEvtListenerList; + static _BluetoothGapSystemAdapter* __pInstance; + +}; // _BluetoothGapSystemAdapter + +} } } +#endif // _FNET_BT_INTERNAL_BLUETOOTH_GAP_SYSTEM_ADAPTER_H_ diff --git a/src/FNetBt_BluetoothHdpSystemAdapter.cpp b/src/FNetBt_BluetoothHdpSystemAdapter.cpp new file mode 100755 index 0000000..0ea320a --- /dev/null +++ b/src/FNetBt_BluetoothHdpSystemAdapter.cpp @@ -0,0 +1,439 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// @file FNetBt_BluetoothHdpSystemAdapter.cpp +// @brief This is the implementation file for the _BluetoothHdpSystemAdapter class. +// + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "FNetBt_BluetoothHealthImpl.h" +#include "FNetBt_BluetoothHdpSystemAdapter.h" +#include "FNetBt_BluetoothGapSystemAdapter.h" +#include "FNetBt_BluetoothDeviceImpl.h" + +using namespace std; +using namespace Tizen::Base; +using namespace Tizen::Base::Collection; +using namespace Tizen::Base::Utility; + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +/* + * @class _BluetoothAddressComparer + * @brief The _BluetoothAddressComparer class provides the comparer about two specified String + * which consists of Bluetooth address and service UUID. + */ +class _BluetoothAddressComparer + : public Tizen::Base::Collection::IComparerT + , public Tizen::Base::Object +{ +public: + _BluetoothAddressComparer(void) {} + virtual ~_BluetoothAddressComparer(void) {} + + virtual result Compare(const Tizen::Base::String& obj1, const Tizen::Base::String& obj2, int& cmp) const + { + cmp = obj1.CompareTo(obj2); + return E_SUCCESS; + } + +private: + _BluetoothAddressComparer(const _BluetoothAddressComparer& value); + _BluetoothAddressComparer& operator =(const _BluetoothAddressComparer& value); + +}; //_BluetoothAddressComparer + +/* + * @class _BluetoothAddressHashCodeProviderT + * @brief The _BluetoothAddressHashCodeProviderT class provides the hash code of a specified String + * which consists of Bluetooth address and service UUID. + */ +class _BluetoothAddressHashCodeProvider + : public Tizen::Base::Collection::IHashCodeProviderT +{ +public: + _BluetoothAddressHashCodeProvider(void) {} + virtual ~_BluetoothAddressHashCodeProvider(void) {} + virtual int GetHashCode(const Tizen::Base::String& obj) const + { + return obj.GetHashCode(); + } + +private: + _BluetoothAddressHashCodeProvider(const _BluetoothAddressHashCodeProvider& value); + _BluetoothAddressHashCodeProvider& operator =(const _BluetoothAddressHashCodeProvider& value); + +}; //_BluetoothAddressHashCodeProvider + + +static _BluetoothAddressComparer _btAddressComparer; +static _BluetoothAddressHashCodeProvider _btAddressHashCodeProvider; + +_BluetoothHdpSystemAdapter* _BluetoothHdpSystemAdapter::__pInstance = null; + +_BluetoothHdpSystemAdapter::_BluetoothHdpSystemAdapter(void) + : __pAppHealthMap(null) + , __pChannelHealthMap(null) + , __pChannelAddressMap(null) +{ +} + +_BluetoothHdpSystemAdapter::~_BluetoothHdpSystemAdapter(void) +{ + // unregister the callback methods from the underlying layer + int err = bt_hdp_unset_connection_state_changed_cb(); + SysLog(NID_NET_BT, "[0x%x] error in unregistering the connection state change callback method", err); + + err = bt_hdp_unset_data_received_cb(); + SysLog(NID_NET_BT, "[0x%x] error in unregistering the data received state change callback method", err); +} + +void +_BluetoothHdpSystemAdapter::InitSingleton(void) +{ + bool r = false; + static _BluetoothHdpSystemAdapter inst; + + r = inst.Construct(); + SysTryReturnVoidResult(NID_NET_BT, r == true, E_SYSTEM, "[E_SYSTEM] Propagating."); + + __pInstance = &inst; +} + +_BluetoothHdpSystemAdapter* +_BluetoothHdpSystemAdapter::GetInstance(void) +{ + static pthread_once_t onceBlock = PTHREAD_ONCE_INIT; + + if (__pInstance == null) + { + ClearLastResult(); + pthread_once(&onceBlock, InitSingleton); + result r = GetLastResult(); + if (IsFailed(r)) + { + onceBlock = PTHREAD_ONCE_INIT; + } + } + + return __pInstance; +} + +bool +_BluetoothHdpSystemAdapter::Construct(void) +{ + int err = BT_ERROR_NONE; + result r = E_SUCCESS; + unique_ptr > pAppHealthMap; + unique_ptr > pChannelHealthMap; + unique_ptr > pChannelAddressMap; + + pAppHealthMap.reset(new (std::nothrow) HashMapT); + SysTryReturn(NID_NET_BT, pAppHealthMap != null, false, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient."); + + //Constructing the hashmap template with the default capacity(16) and loadFactor(0.75f) + r = pAppHealthMap->Construct(16, 0.75f, _btAddressHashCodeProvider, _btAddressComparer); + SysTryReturn(NID_NET_BT, r == E_SUCCESS, false, r, "[%s] Propagating.", GetErrorMessage(r)); + + pChannelHealthMap.reset(new (std::nothrow) HashMapT); + SysTryReturn(NID_NET_BT, pChannelHealthMap != null, false, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient."); + + r = pChannelHealthMap->Construct(); + SysTryReturn(NID_NET_BT, r == E_SUCCESS, false, r, "[%s] Propagating.", GetErrorMessage(r)); + + pChannelAddressMap.reset(new (std::nothrow) HashMapT); + SysTryReturn(NID_NET_BT, pChannelAddressMap != null, false, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient."); + + r = pChannelAddressMap->Construct(); + SysTryReturn(NID_NET_BT, r == E_SUCCESS, false, r, "[%s] Propagating.", GetErrorMessage(r)); + + //register a call back to be invoked when connection state of the Sink device changes + err = bt_hdp_set_connection_state_changed_cb(&OnHdpConnected, &OnHdpDisconnected, null); + SysTryReturn(NID_NET_BT, err == BT_ERROR_NONE, false, E_SYSTEM, "[E_SYSTEM] Registering the callback method has failed."); + + //register a callback to be invoked when any health data is received by the Sink device + err = bt_hdp_set_data_received_cb(&OnHdpDataReceived, null); + if (err != BT_ERROR_NONE) + { + int errUnset = bt_hdp_unset_connection_state_changed_cb(); + SysLog(NID_NET_BT, "[0x%x] error in unregistering the connection state change callback method", errUnset); + } + SysTryReturn(NID_NET_BT, err == BT_ERROR_NONE, false, E_SYSTEM, "[E_SYSTEM] Registering the callback method has failed."); + + __pAppHealthMap = move(pAppHealthMap); + __pChannelHealthMap = move(pChannelHealthMap); + __pChannelAddressMap = move(pChannelAddressMap); + + return true; +} + +result +_BluetoothHdpSystemAdapter::StartSinkService(int dataType, _BluetoothHealthImpl& implListener, char** pAppId) +{ + result r = E_OPERATION_FAILED; + int err = BT_ERROR_NONE; + + char* pUuidStr; + bool isUsed = false; + + // check HDP service availability + pUuidStr = _StringConverter::CopyToCharArrayN(UuId(BT_SVC_UUID_HDP).ToString()); + err = bt_adapter_is_service_used(pUuidStr, &isUsed); + delete[] pUuidStr; + SysTryReturnResult(NID_NET_BT, (err == BT_ERROR_NONE) && !isUsed, E_SERVICE_UNAVAILABLE, + "[E_SERVICE_UNAVAILABLE] HDP sink service for the specified UUID is not available."); + + err = bt_hdp_register_sink_app(dataType, pAppId); + SysTryReturnResult(NID_NET_BT, err == BT_ERROR_NONE, E_OPERATION_FAILED, + "[E_OPERATION_FAILED] Registering Sink role application for specified HDP data type is failed"); + SysLog(NID_NET_BT, "Registering the HDP Sink role is successful [%d].", err); + + String appIdString(*pAppId); + + // Add the _BluetoothHealthImpl pointer to the event map using appIdString as the key. + r = __pAppHealthMap->Add(appIdString, &implListener); + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_OPERATION_FAILED, + "[E_OPERATION_FAILED] Failed to add the _BluetoothHealthImpl instance to the map"); + return E_SUCCESS; +} + +result +_BluetoothHdpSystemAdapter::StopService(const char* pAppId) +{ + int err = BT_ERROR_NONE; + result r = E_OPERATION_FAILED; + + String appIdString(pAppId); + + err = bt_hdp_unregister_sink_app(pAppId); + SysTryReturnResult(NID_NET_BT, err == BT_ERROR_NONE, E_OPERATION_FAILED, + "[E_OPERATION_FAILED] Failed to unregister the given Sink Role HDP application"); + SysLog(NID_NET_BT, "The Sink role HDP app is successfully unregistered"); + + // remove the specified appIdString from the application event map. + r = __pAppHealthMap->Remove(appIdString); + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_OPERATION_FAILED, + "[E_OPERATION_FAILED] failed to remove the appId from the event map."); + + return E_SUCCESS; +} + +result +_BluetoothHdpSystemAdapter::ConnectToSource(const Tizen::Base::ByteBuffer& sourceAddress, const char* pAppId) +{ + int err = BT_ERROR_NONE; + result r = E_OPERATION_FAILED; + + char* pSourceAddress = null; + + SysTryReturnResult(NID_NET_BT, sourceAddress.GetRemaining() == _BT_ADDRESS_LENGTH, E_OPERATION_FAILED, + "The address of the remote Source device is incorrect."); + + pSourceAddress = _StringConverter::CopyToCharArrayN(_BluetoothDeviceImpl::GetAddressString(sourceAddress)); + SysTryReturnResult(NID_NET_BT, pSourceAddress != null, E_OPERATION_FAILED, "Converting address to char* fails."); + + err = bt_hdp_connect_to_source(pSourceAddress, pAppId); + SysLog(NID_NET_BT, "Connecting to the remote source device [%s] %s.", pSourceAddress, + err == BT_ERROR_NONE ? "is successful" : "fails"); + if (err == BT_ERROR_NONE) + { + r = E_SUCCESS; + } + + delete[] pSourceAddress; + return r; +} + +result +_BluetoothHdpSystemAdapter::Disconnect(int channelId) +{ + int err = BT_ERROR_NONE; + result r = E_OPERATION_FAILED; + + String connectedAddress; + char* pSourceAddress = null; + + r = __pChannelAddressMap->GetValue(channelId, connectedAddress); + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_OPERATION_FAILED, "The channel ID is invalid."); + + pSourceAddress = _StringConverter::CopyToCharArrayN(connectedAddress); + SysTryReturnResult(NID_NET_BT, pSourceAddress != null, E_OPERATION_FAILED, "Address converting fails."); + + err = bt_hdp_disconnect(pSourceAddress, channelId); + SysLog(NID_NET_BT, "Disconnecting from the remote source device [%s] with channel id [%d] %s.", pSourceAddress, channelId, + err == BT_ERROR_NONE ? "is successful" : "fails"); + if (err == BT_ERROR_NONE) + { + r = E_SUCCESS; + } + + delete[] pSourceAddress; + return r; +} + +result +_BluetoothHdpSystemAdapter::SendData(int channelId, const Tizen::Base::ByteBuffer& data) +{ + int err = BT_ERROR_NONE; + result r = E_OPERATION_FAILED; + + const byte* pHealthData = null; + int healthDataLength = 0; + + pHealthData = data.GetPointer(); + pHealthData += data.GetPosition(); + healthDataLength = data.GetRemaining(); + + err = bt_hdp_send_data(channelId, (char*)pHealthData, healthDataLength); + SysLog(NID_NET_BT, "Sending data to the remote source with channel id [%d] of length [%d] %s.", channelId, healthDataLength, + err == BT_ERROR_NONE ? "is successful" : "fails"); + if (err == BT_ERROR_NONE) + { + r = E_SUCCESS; + } + + return r; +} + +void +_BluetoothHdpSystemAdapter::OnHdpConnected(int status, const char* pRemoteAddress, const char* pAppId, + bt_hdp_channel_type_e channelType, unsigned int channelId, void* pUserData) +{ + result r = E_OPERATION_FAILED; + + BluetoothDevice btDevice; + ByteBuffer deviceAddress; + String remoteDeviceAddrStr(pRemoteAddress); + BluetoothHealthDataChannelType hdpchannelType = BT_HEALTH_DATA_CHANNEL_NONE; + + _BluetoothHealthImpl* pHealthImpl = null; + String appIdString(pAppId); + + _BluetoothHdpSystemAdapter* pHdpAdapter = _BluetoothHdpSystemAdapter::GetInstance(); + + // retrieve the _BluetoothHealthImpl instance from the __pAppHealthMap by using appIdString as key + r = pHdpAdapter->__pAppHealthMap->GetValue(appIdString, pHealthImpl); + SysTryReturnVoidResult(NID_NET_BT, r == E_SUCCESS, E_OPERATION_FAILED, + "[E_OPERATION_FAILED] The application Id is unknown."); + + r = deviceAddress.Construct(_BT_ADDRESS_LENGTH); + SysTryReturnVoidResult(NID_NET_BT, r == E_SUCCESS, E_OPERATION_FAILED, + "[E_OPERATION_FAILED] Failed to construct the address buffer"); + + (void) _BluetoothDeviceImpl::GetAddressByteBuffer(remoteDeviceAddrStr, L":", deviceAddress); + + r = _BluetoothGapSystemAdapter::GetPairedDevice(deviceAddress, btDevice); + SysTryReturnVoidResult(NID_NET_BT, r == E_SUCCESS, E_OPERATION_FAILED, + "[E_OPERATION_FAILED] Getting information of the source health device has failed."); + + if (status == BT_ERROR_NONE) + { + // insert the pHealthImpl into __pChannelHealthMap by using the specified channelId as key + r = pHdpAdapter->__pChannelHealthMap->Add(channelId, pHealthImpl); + if (r != E_SUCCESS) + { + SysLogException(NID_NET_BT, E_OPERATION_FAILED, "[%s] Propagating.", GetErrorMessage(r)); + r = E_OPERATION_FAILED; + } + + // insert the pRemoteAddress into __pChannelAddressMap by using the specified channelId as key + r = pHdpAdapter->__pChannelAddressMap->Add(channelId, remoteDeviceAddrStr); + if (r != E_SUCCESS) + { + SysLogException(NID_NET_BT, E_OPERATION_FAILED, "[%s] Propagating.", GetErrorMessage(r)); + r = E_OPERATION_FAILED; + } + } + else + { + SysLog(NID_NET_BT, "[E_OPERATION_FAILED] Connection request failure is reported by the underlying system."); + r = E_OPERATION_FAILED; + } + + hdpchannelType = ((channelType == BT_HDP_CHANNEL_TYPE_RELIABLE)? + BT_HEALTH_DATA_CHANNEL_RELIABLE : BT_HEALTH_DATA_CHANNEL_STREAMING); + + // Fire the connect event using the _BluetoothHealthImpl handle + pHealthImpl->OnBluetoothHealthConnected(channelId, hdpchannelType, &btDevice, r); +} + +void +_BluetoothHdpSystemAdapter::OnHdpDisconnected(int status, const char* pRemoteAddress, unsigned int channelId, void* pUserData) +{ + result r = E_SYSTEM; + + BluetoothDevice btDevice; + ByteBuffer deviceAddress; + String remoteDeviceAddrStr(pRemoteAddress); + + _BluetoothHealthImpl* pHealthImpl = null; + + _BluetoothHdpSystemAdapter* pHdpAdapter = _BluetoothHdpSystemAdapter::GetInstance(); + + // get the pointer of the _BluetoothHealthImpl from __pChannelHealthMap by using the specified channelId as a key + r = pHdpAdapter->__pChannelHealthMap->GetValue(channelId, pHealthImpl); + SysTryReturnVoidResult(NID_NET_BT, r == E_SUCCESS, E_OPERATION_FAILED, "[E_OPERATION_FAILED] The channel Id is unknown."); + + if (status == BT_ERROR_NONE) + { + (void) pHdpAdapter->__pChannelHealthMap->Remove(channelId); + pHdpAdapter->__pChannelAddressMap->Remove(channelId); + } + else + { + SysLog(NID_NET_BT, "[E_OPERATION_FAILED] Disconnection request failure is reported by the underlying system [%d].", status); + r = E_OPERATION_FAILED; + } + + // Fire the Disconnect event using the _BluetoothHealthImpl handle + pHealthImpl->OnBluetoothHealthDisconnected(channelId, r); +} + +void +_BluetoothHdpSystemAdapter::OnHdpDataReceived(unsigned int channelId, const char* pData, unsigned int dataSize, void* pUserData) +{ + result r = E_SUCCESS; + ByteBuffer dataBuffer; + + _BluetoothHealthImpl* pHealthImpl = null; + + _BluetoothHdpSystemAdapter* pHdpAdapter = _BluetoothHdpSystemAdapter::GetInstance(); + + // find the appropriate _BluetoothHealthImpl handle with the given channelId + r = pHdpAdapter->__pChannelHealthMap->GetValue(channelId, pHealthImpl); + SysTryReturnVoidResult(NID_NET_BT, r == E_SUCCESS, E_OPERATION_FAILED, "[E_OPERATION_FAILED] unknown channelId."); + + dataBuffer.Construct(dataSize); + dataBuffer.SetArray((byte*) pData, 0, dataSize); + dataBuffer.SetPosition(0); + + // Fire the data received event using the _BluetoothHealthImpl handle + pHealthImpl->OnBluetoothHealthDataReceived(channelId, dataBuffer); + SysLog(NID_NET_BT, " Received Health data of (%d bytes) through the channel (ID: %d) is received.", dataSize, channelId); +} + +} } } // Tizen::Net::Bluetooth diff --git a/src/FNetBt_BluetoothHdpSystemAdapter.h b/src/FNetBt_BluetoothHdpSystemAdapter.h new file mode 100644 index 0000000..22a55ad --- /dev/null +++ b/src/FNetBt_BluetoothHdpSystemAdapter.h @@ -0,0 +1,164 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +/** + * @file FNetBt_BluetoothHdpSystemAdapter.h + * @brief This is the header file for the _BluetoothHdpSystemAdapter class. + * + * This header file contains the declaration of the _BluetoothHdpSystemAdapter class. + */ +#ifndef _FNET_BT_INTERNAL_BLUETOOTH_HDP_SYSTEM_ADAPTER_H_ +#define _FNET_BT_INTERNAL_BLUETOOTH_HDP_SYSTEM_ADAPTER_H_ + +#include +#include +#include +#include + +// forward declarations +namespace Tizen { namespace Base { +class ByteBuffer; + +namespace Collection { +template class HashMapT; +} +} } + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +// Forward declarations +class BluetoothDevice; +class _BluetoothHealthImpl; + +/** + * @class _BluetoothHdpSystemAdapter + * @brief This class provides functions related to HDP (Health Device Profile) and have a role of adaptation OSP classes and + * the underlying subsystem. This class is a type of singleton, therefore only one instance should be allowed. + */ +class _BluetoothHdpSystemAdapter + : public Tizen::Base::Object +{ +public: + /** + * Creates an instance of this class if there is no instance in this application context. + * Gets the exist instance because this class is a singleton, otherwise. + * + * @return the instance of this class + */ + static _BluetoothHdpSystemAdapter* GetInstance(void); + + /** + * Create and initialize a sink service, and start to listen the health events. @n + * An instance of _BluetoothHealthImpl class is registered internally. + * + * @return An error code + * @param[in] dataType The type of data used in communication, refer to ISO/IEEE 11073-20601 for data types + * @param[in] implListener The instance of _BluetoothHealthImpl to be registered in map + * @param[out] pAppId The application ID + * @exception E_SUCCESS The method is successful. + * @exception E_SERVICE_UNAVAILABLE The HDP service with the specified data type is unavailable. + * @exception E_OPERATION_FAILED The method has failed. + */ + result StartSinkService(int dataType, _BluetoothHealthImpl& implListener, char** pAppId); + + /** + * Close the specified sink service. @n + * + * @return An error code + * @param[in] pAppId The application ID + * @exception E_SUCCESS The method is successful. + * @exception E_OPERATION_FAILED The method has failed. + */ + result StopService(const char* pAppId); + + /** + * Sets up a new connection (channel) with a remote health device which has source role. @n + * + * @return An error code + * @param[in] sourceAddress The address of the source device + * @param[in] pAppId The application ID + * @exception E_SUCCESS The method is successful. + * @exception E_OPERATION_FAILED The method has failed. + */ + result ConnectToSource(const Tizen::Base::ByteBuffer& sourceAddress, const char* pAppId); + + /** + * Close the connection with the remote HDP source device. + * + * @return An error code + * @param[in] channelId The ID of the specified channel to be disconnected + * @exception E_SUCCESS The method is successful. + * @exception E_OPERATION_FAILED The method has failed. + */ + result Disconnect(int channelId); + + /** + * Sends the specified data on the specified HDP channel. + * + * @return An error code + * @param[in] channelId The ID of the specified channel to send data on + * @param[in] data The health data to be sent over the connected channel + * @exception E_SUCCESS The method is successful. + * @exception E_OPERATION_FAILED The method has failed. + */ + result SendData(int channelId, const Tizen::Base::ByteBuffer& buffer); + + + //----------------------------------------------------------------------------------------------------------------- + // Callback methods for the HDP events + //----------------------------------------------------------------------------------------------------------------- + + /** + * Callback called by the underlying system to notify that an HDP connection is established. + */ + static void OnHdpConnected(int status, const char* pRemoteAddress, const char* appId, bt_hdp_channel_type_e channelType, + unsigned int channelId, void* pUserData); + + /** + * Callback called by the underlying system to notify that the specific HDP connection is disconnected. + */ + static void OnHdpDisconnected(int status, const char* pRemoteAddress, unsigned int channelId, void* pUserData); + + /** + * Callback used by the underlying system to notify that data is received on the established HDP connection. + */ + static void OnHdpDataReceived(unsigned int channelId, const char* pData, unsigned int dataSize, void* pUserData); + +private: + _BluetoothHdpSystemAdapter(void); + ~_BluetoothHdpSystemAdapter(void); + + _BluetoothHdpSystemAdapter(const _BluetoothHdpSystemAdapter& value); + _BluetoothHdpSystemAdapter& operator =(const _BluetoothHdpSystemAdapter& value); + + bool Construct(void); + + static void InitSingleton(void); + +private: + // hash map of HDP applications and the _BluetoothHealthImpl + std::unique_ptr > __pAppHealthMap; + // hash map of HDP channel Ids and the _BluetoothHealthImpl + std::unique_ptr > __pChannelHealthMap; + // hash map of HDP channel Ids and the connected device address + std::unique_ptr > __pChannelAddressMap; + static _BluetoothHdpSystemAdapter* __pInstance; + +}; // _BluetoothHdpSystemAdapter + +} } } +#endif // _FNET_BT_INTERNAL_BLUETOOTH_HDP_SYSTEM_ADAPTER_H_ diff --git a/src/FNetBt_BluetoothHealthEvent.cpp b/src/FNetBt_BluetoothHealthEvent.cpp new file mode 100644 index 0000000..07f014c --- /dev/null +++ b/src/FNetBt_BluetoothHealthEvent.cpp @@ -0,0 +1,97 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// @file FNetBt_BluetoothHealthEvent.cpp +// @brief This is the implementation file for the _BluetoothHealthEvent class. +// + +#include +#include +#include +#include "FNetBt_BluetoothHealthEvent.h" +#include "FNetBt_BluetoothHealthEventArg.h" +#include "FNetBtIBluetoothHealthEventListener.h" + + +using namespace Tizen::Base; + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +_BluetoothHealthEvent::_BluetoothHealthEvent(void) +{ +} + +_BluetoothHealthEvent::~_BluetoothHealthEvent(void) +{ +} + +result +_BluetoothHealthEvent::Construct(void) +{ + return _Event::Initialize(); +} + +void +_BluetoothHealthEvent::FireImpl(Tizen::Base::Runtime::IEventListener& listener, const Tizen::Base::Runtime::IEventArg& arg) +{ + const BluetoothDevice* pDevice = null; + ByteBuffer* pData = null; + int channelId = -1; + result r = E_SUCCESS; + + IBluetoothHealthEventListener* pListener = dynamic_cast (&listener); + SysTryReturnVoidResult(NID_NET_BT, pListener != null, E_INVALID_ARG, + "[E_INVALID_ARG] The listener argument is invalid."); + + const _BluetoothHealthEventArg* pEventArg = dynamic_cast (&arg); + SysTryReturnVoidResult(NID_NET_BT, pEventArg != null, E_INVALID_ARG, "[E_INVALID_ARG] The event argument is invalid type."); + + _BluetoothHealthEventType eventType = pEventArg->GetEventType(); + channelId = pEventArg->GetChannelId(); + r = pEventArg->GetErrorResult(); + + switch (eventType) + { + case _BT_HEALTH_EVENT_CONNECTED: + pDevice = pEventArg->GetSourceDevice(); + if (pDevice) + { + SysLog(NID_NET_BT, "Firing Bluetooth Health Event (Type: _BT_HEALTH_EVENT_CONNECTED)"); + pListener->OnHealthConnected(channelId, pEventArg->GetDataType(), pEventArg->GetChannelType(), pDevice, r); + } + break; + + case _BT_HEALTH_EVENT_DISCONNECTED: + SysLog(NID_NET_BT, "Firing Bluetooth Health Event (Type: _BT_HEALTH_EVENT_DISCONNECTED)"); + pListener->OnHealthDisconnected(channelId, r); + break; + + case _BT_HEALTH_EVENT_DATA_RECEIVED: + pData = pEventArg->GetReceivedData(); + if (pData) + { + SysLog(NID_NET_BT, "Firing Bluetooth socket Event (Type: _BT_HEALTH_EVENT_DATA_RECEIVED)"); + pListener->OnHealthDataReceived(channelId, *pData); + } + break; + + default: + break; + } +} + +} } } // Tizen::Net::Bluetooth diff --git a/src/FNetBt_BluetoothHealthEvent.h b/src/FNetBt_BluetoothHealthEvent.h new file mode 100644 index 0000000..d2073e5 --- /dev/null +++ b/src/FNetBt_BluetoothHealthEvent.h @@ -0,0 +1,85 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +/** + * @file FNetBt_BluetoothHealthEvent.h + * @brief This is the header file for the _BluetoothHealthEvent class. + * + * This header file contains the declarations of the _BluetoothHealthEvent class. + * The _BluetoothHealthEvent class can call a method of a listener (_IBluetoothHealthEventListener object). + * So, when a device event is occurred, listener instances can handle it appropriately. + */ +#ifndef _FNET_BT_INTERNAL_BLUETOOTH_HEALTH_EVENT_H_ +#define _FNET_BT_INTERNAL_BLUETOOTH_HEALTH_EVENT_H_ + +#include +#include +#include + +// Forward declaration +namespace Tizen { namespace Base { namespace Runtime +{ +class IEventListener; +class IEventArg; +} } } + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +// +// @class _BluetoothHealthEvent +// @brief This class handles Bluetooth Health events. +// +// When a Bluetooth device event occurs, the _BluetoothHealthEvent object finds a _IBluetoothHealthEventListener object +// and calls an appropriate method of the listener. +// +class _BluetoothHealthEvent + : public Tizen::Base::Runtime::_Event +{ +public: + /** + * This is the default constructor. + */ + _BluetoothHealthEvent(void); + + /** + * This is the class destructor. + */ + virtual ~_BluetoothHealthEvent(void); + + result Construct(void); + +protected: + /** + * Checks the argument and finds out the type of event. After that, this method calls appropriate Listener's method. + * + * @return A result code. + * @param[in] pListener An event listener related to this Bluetooth health event. + * @param[in] arg An event argument including information to be passed to the event listeners + * @exception E_SUCCESS The method is successful. + * @exception E_INVALID_ARG The argument passed to a method contains invalid values. + * @exception E_SYSTEM A system error occurred. + */ + virtual void FireImpl(Tizen::Base::Runtime::IEventListener& listener, const Tizen::Base::Runtime::IEventArg& arg); + +private: + _BluetoothHealthEvent(const _BluetoothHealthEvent& value); + _BluetoothHealthEvent& operator =(const _BluetoothHealthEvent& rhs); + +}; // _BluetoothHealthEvent + +} } } +#endif // _FNET_BT_INTERNAL_BLUETOOTH_HEALTH_EVENT_H_ diff --git a/src/FNetBt_BluetoothHealthEventArg.cpp b/src/FNetBt_BluetoothHealthEventArg.cpp new file mode 100755 index 0000000..990fcb7 --- /dev/null +++ b/src/FNetBt_BluetoothHealthEventArg.cpp @@ -0,0 +1,133 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// @file FNetBt_BluetoothHealthEventArg.cpp +// @brief This is the implementation file for the _BluetoothHealthEventArg class. +// + +#include +#include +#include +#include "FNetBt_BluetoothHealthEventArg.h" + + +using namespace Tizen::Base; + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +// +// This is a class constructor for _BT_HEALTH_EVENT_CONNECTED event. +// +_BluetoothHealthEventArg::_BluetoothHealthEventArg(int channelId, int dataType, BluetoothHealthDataChannelType channelType, + const BluetoothDevice* pDevice, result r) + : __evtType(_BT_HEALTH_EVENT_CONNECTED) + , __pTargetDevice(null) + , __channelId(channelId) + , __dataType(dataType) + , __channelType(channelType) + , __result(r) + , __pData(null) +{ + if (pDevice != null) + { + __pTargetDevice = new (std::nothrow) BluetoothDevice(*pDevice); + SysTryReturnVoidResult(NID_NET_BT, __pTargetDevice != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient."); + } +} + +// +// This is a class constructor for _BT_HEALTH_EVENT_DISCONNECTED event. +// +_BluetoothHealthEventArg::_BluetoothHealthEventArg(int channelId, result r) + : __evtType(_BT_HEALTH_EVENT_DISCONNECTED) + , __pTargetDevice(null) + , __channelId(channelId) + , __dataType(0) + , __channelType(BT_HEALTH_DATA_CHANNEL_NONE) + , __result(r) + , __pData(null) +{ +} + +// +// This is a class constructor for _BT_HEALTH_EVENT_DATA_RECEIVED event. +// +_BluetoothHealthEventArg::_BluetoothHealthEventArg(int channelId, const Tizen::Base::ByteBuffer& buffer) + : __evtType(_BT_HEALTH_EVENT_DATA_RECEIVED) + , __pTargetDevice(null) + , __channelId(channelId) + , __dataType(0) + , __channelType(BT_HEALTH_DATA_CHANNEL_NONE) + , __result(E_SUCCESS) + , __pData(null) +{ + __pData = new (std::nothrow) ByteBuffer(); + SysTryReturnVoidResult(NID_NET_BT, __pData != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient."); + + __pData->Construct(buffer); + __pData->SetPosition(0); +} + +_BluetoothHealthEventArg::~_BluetoothHealthEventArg(void) +{ + delete __pTargetDevice; + delete __pData; +} + +_BluetoothHealthEventType +_BluetoothHealthEventArg::GetEventType(void) const +{ + return __evtType; +} + +const BluetoothDevice* +_BluetoothHealthEventArg::GetSourceDevice(void) const +{ + return __pTargetDevice; +} + +int +_BluetoothHealthEventArg::GetChannelId(void) const +{ + return __channelId; +} + +int +_BluetoothHealthEventArg::GetDataType(void) const +{ + return __dataType; +} + +BluetoothHealthDataChannelType +_BluetoothHealthEventArg::GetChannelType(void) const +{ + return __channelType; +} + +result +_BluetoothHealthEventArg::GetErrorResult(void) const +{ + return __result; +} + +Tizen::Base::ByteBuffer* +_BluetoothHealthEventArg::GetReceivedData(void) const +{ + return __pData; +} + +} } } // Tizen::Net::Bluetooth diff --git a/src/FNetBt_BluetoothHealthEventArg.h b/src/FNetBt_BluetoothHealthEventArg.h new file mode 100644 index 0000000..f9621c2 --- /dev/null +++ b/src/FNetBt_BluetoothHealthEventArg.h @@ -0,0 +1,175 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +/** + * @file FNetBt_BluetoothHealthEventArg.h + * @brief This is the header file for the _BluetoothHealthEventArg class. + * + * This header file contains the declarations of the _BluetoothHealthEventArg class which includes information to be + * passed to the event listeners + */ +#ifndef _FNET_BT_INTERNAL_BLUETOOTH_HEALTH_EVENT_ARG_H_ +#define _FNET_BT_INTERNAL_BLUETOOTH_HEALTH_EVENT_ARG_H_ + +#include +#include +#include +#include + +// Forward declaration +namespace Tizen { namespace Base { +class ByteBuffer; +} } + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +// Forward declaration +class BluetoothDevice; + +/** + * @enum _BluetoothHealthEventType + * Type for specifying the type of _BluetoothHealthEvent + */ +enum _BluetoothHealthEventType +{ + _BT_HEALTH_EVENT_CONNECTED, /**< For notifying that the connection is established */ + _BT_HEALTH_EVENT_DISCONNECTED, /**< For notifying that the connection is disconnected */ + _BT_HEALTH_EVENT_DATA_RECEIVED, /**< For notifying that the data has been received */ +}; + +/** + * @class _BluetoothHealthEventArg + * @brief This class is used as an argument for callback methods of the IBluetoothHealthEventListener class. + * + * When a _BluetoothHealthEvent occurs, the _BluetoothHealthEvent finds a IBluetoothHealthEventListener instance + * which is registered for the _BluetoothHealthEvent and calls an appropriate method of the listener. + * @see IBluetoothHealthEventListener + */ +class _BluetoothHealthEventArg + : public Tizen::Base::Object + , public Tizen::Base::Runtime::IEventArg +{ +public: + /** + * This is a class constructor for _BT_HEALTH_EVENT_CONNECTED event. + * + * @param[in] channelId The channel ID of the established connection, @n + * else an invalid ID (-1) if the method is not successful + * @param[in] dataType dataType represents the type of health device (eg thermometer, BP device) + * and is defined in ISO/IEEE 11073-20601 standard + * @param[in] channelType The data channel type of the established connection + * @param[in] pRemoteDevice The remote health device which the local device connects with, @n + * else @c null if the method is not successful + * @param[in] r The result of the connection request + * @exception E_SUCCESS The connection request is accepted by the target health device. + * @exception E_REJECTED The connection request is rejected by the target health device. + * @exception E_TIMEOUT The connection request has timed out. + * @exception E_OPERATION_FAILED The connection request has failed. + */ + _BluetoothHealthEventArg(int channelId, int dataType, BluetoothHealthDataChannelType channelType, + const BluetoothDevice* pDevice, result r); + + /** + * This is a class constructor for _BT_HEALTH_EVENT_DISCONNECTED event. + * + * @param[in] channelId The channel ID of the terminated connection + * @param[in] r The disconnection status + * @exception E_SUCCESS The specified connection (channel) is terminated successfully. + * @exception E_OPERATION_FAILED The method has failed to disconnect. + */ + _BluetoothHealthEventArg(int channelId, result r); + + /** + * This is a class constructor for _BT_HEALTH_EVENT_DATA_RECEIVED event. + * + * @param[in] channelId The channel ID of the conneciton which data is received on + * @param[in] buffer The received data + */ + _BluetoothHealthEventArg(int channelId, const Tizen::Base::ByteBuffer& buffer); + + /** + * This is the class destructor. + */ + ~_BluetoothHealthEventArg(void); + + /** + * Gets the type of this event. + * + * @return The type of the event + */ + _BluetoothHealthEventType GetEventType(void) const; + + /** + * Gets the socket client device. + * + * @return The pointer of the source device which is connect with + */ + const BluetoothDevice* GetSourceDevice(void) const; + + /** + * Gets the channel ID. + * + * @return The channel ID + */ + int GetChannelId(void) const; + + /** + * Gets the Data Type. + * + * @return The Data Type + */ + int GetDataType(void) const; + + /** + * Gets the data channel type. + * + * @return The data channel type + */ + BluetoothHealthDataChannelType GetChannelType(void) const; + + /** + * Gets the error result of this event. + * + * @return The result of the event + */ + result GetErrorResult(void) const; + + /** + * Gets The received data. + * + * @return The received data + */ + Tizen::Base::ByteBuffer* GetReceivedData(void) const; + +private: + _BluetoothHealthEventArg(void); + _BluetoothHealthEventArg(const _BluetoothHealthEventArg& eventArg); + _BluetoothHealthEventArg& operator =(const _BluetoothHealthEventArg& rValue); + +private: + _BluetoothHealthEventType __evtType; + BluetoothDevice* __pTargetDevice; + int __channelId; + int __dataType; + BluetoothHealthDataChannelType __channelType; + result __result; + Tizen::Base::ByteBuffer* __pData; + +}; // _BluetoothHealthEventArg + +} } } +#endif // _FNET_BT_INTERNAL_BLUETOOTH_HEALTH_EVENT_ARG_H_ diff --git a/src/FNetBt_BluetoothHealthImpl.cpp b/src/FNetBt_BluetoothHealthImpl.cpp new file mode 100755 index 0000000..b6a17a6 --- /dev/null +++ b/src/FNetBt_BluetoothHealthImpl.cpp @@ -0,0 +1,697 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// @file FNetBt_BluetoothHealthImpl.cpp +// @brief This is the implementation file for the _BluetoothHealthImpl class. +// + +#include +#include +#include +#include +#include "FNetBt_BluetoothHealthEvent.h" +#include "FNetBt_BluetoothHealthEventArg.h" +#include "FNetBt_BluetoothGapSystemAdapter.h" +#include "FNetBt_BluetoothHdpSystemAdapter.h" +#include "FNetBt_BluetoothHealthImpl.h" + +using namespace std; +using namespace Tizen::Base; +using namespace Tizen::Base::Runtime; + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +_BluetoothHealthImpl::_BluetoothHealthImpl(void) + : __pGapAdapter(null) + , __pHdpAdapter(null) + , __pEvent(null) + , __stateMutex() + , __currentState(_BT_HEALTH_STATE_DISABLED) + , __channelIdList() + , __pairingTargetAddress() + , __pAppId(null) + , __dataType(_BT_INVALID_DATA_TYPE) +{ +} + +_BluetoothHealthImpl::~_BluetoothHealthImpl(void) +{ + int count = 0; + int channelId = 0; + + if (__pHdpAdapter != null) + { + count = __channelIdList.GetCount(); + for (int i=0; iDisconnect(channelId); + } + } + + if (__pGapAdapter != null) + { + __pGapAdapter->UnregisterManagerEventListener(*this); + __pGapAdapter->UnregisterDeviceEventListener(*this); + } +} + +result +_BluetoothHealthImpl::Construct(IBluetoothHealthEventListener& listener) +{ + result r = E_SUCCESS; + unique_ptr<_BluetoothHealthEvent> pEvent; + + r = __stateMutex.Create(); + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_OPERATION_FAILED, "Failed to create the state mutex."); + + r = __pairingTargetAddress.Construct(_BT_ADDRESS_LENGTH); + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_OPERATION_FAILED, "Failed to construct the address for pairing."); + + __pGapAdapter = _BluetoothGapSystemAdapter::GetInstance(); + SysTryReturnResult(NID_NET_BT, __pGapAdapter != null, E_OPERATION_FAILED, + "Failed to invoke _BluetoothGapSystemAdapter::GetInstance()."); + + __pHdpAdapter = _BluetoothHdpSystemAdapter::GetInstance(); + SysTryReturnResult(NID_NET_BT, __pHdpAdapter != null, E_OPERATION_FAILED, + "Failed to invoke _BluetoothHdpSystemAdapter::GetInstance()."); + + pEvent.reset(new (std::nothrow) _BluetoothHealthEvent()); + SysTryReturnResult(NID_NET_BT, pEvent != null, E_OUT_OF_MEMORY, "The memory is insufficient."); + r = pEvent->Construct(); + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_OPERATION_FAILED, "Failed to construct the event."); + // add IBluetoothHealthEventListener instance to the newly created _BluetoothHealthEvent. + r = pEvent->AddListener(listener, true); + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_OPERATION_FAILED, "Propagating. Failed to add the application listener for health device"); + + // registers this callback listener to the system adapter for activation/deactivation event + r = __pGapAdapter->RegisterManagerEventListener(*this, true); + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_OPERATION_FAILED, "Failed to register the callback listener to _BluetoothGapSystemAdapter."); + + // registers this callback listener to the system adapter for paired event + r = __pGapAdapter->RegisterDeviceEventListener(*this); + if (r != E_SUCCESS) + { + __pGapAdapter->UnregisterManagerEventListener(*this); + } + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_OPERATION_FAILED, "Failed to register the callback listener to _BluetoothGapSystemAdapter."); + + // checks whether the Bluetooth is available + __stateMutex.Acquire(); + + if (__pGapAdapter->IsActivated() == true) + { + __currentState = _BT_HEALTH_STATE_IDLE; + } + + __stateMutex.Release(); + + __pEvent = move(pEvent); + + return E_SUCCESS; +} + +result +_BluetoothHealthImpl::StartAsSink(int dataType) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s]", GetStringOfCurrentState()); + + result r = E_SUCCESS; + char* pAppId = null; + + __stateMutex.Acquire(); + + switch (__currentState) + { + case _BT_HEALTH_STATE_DISABLED: + r = E_INVALID_STATE; + break; + + case _BT_HEALTH_STATE_IDLE: + r = __pHdpAdapter->StartSinkService(dataType, *this, &pAppId); + if (r == E_SUCCESS) + { + __currentState = _BT_HEALTH_STATE_ON_SERVICE; + __dataType = dataType; + __pAppId.reset(pAppId); + } + break; + + case _BT_HEALTH_STATE_ON_SERVICE: + case _BT_HEALTH_STATE_BONDING: + case _BT_HEALTH_STATE_BOND_CANCELING: + if (__dataType == dataType) + { + r = E_IN_PROGRESS; + } + else + { + r = E_INVALID_OPERATION; + } + break; + + default: + r = E_OPERATION_FAILED; + break; + } + + __stateMutex.Release(); + + if (r != E_SUCCESS) + { + SysLogException(NID_NET_BT, r, "[%s] exception occurred on starting Health sink role.", GetErrorMessage(r)); + } + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [ActionResult:%s]", GetStringOfCurrentState(), GetErrorMessage(r)); + + return r; +} + +result +_BluetoothHealthImpl::Stop(void) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s]", GetStringOfCurrentState()); + + result r = E_SUCCESS; + + __stateMutex.Acquire(); + + switch (__currentState) + { + case _BT_HEALTH_STATE_DISABLED: + r = E_INVALID_STATE; + break; + + case _BT_HEALTH_STATE_IDLE: + case _BT_HEALTH_STATE_BOND_CANCELING: + r = E_INVALID_OPERATION; + break; + + case _BT_HEALTH_STATE_ON_SERVICE: + r = __pHdpAdapter->StopService(__pAppId.get()); + if (r == E_SUCCESS) + { + __currentState = _BT_HEALTH_STATE_IDLE; + __pAppId.reset(null); + __dataType = _BT_INVALID_DATA_TYPE; + } + break; + + case _BT_HEALTH_STATE_BONDING: + if (__pGapAdapter->CancelPair() == E_SUCCESS) + { + r = E_SUCCESS; + __currentState = _BT_HEALTH_STATE_BOND_CANCELING; + } + // It will be changed to IDLE after receiving the OnBluetoothPaired event. + break; + + default: + r = E_OPERATION_FAILED; + break; + } + + __stateMutex.Release(); + + if (r != E_SUCCESS) + { + SysLogException(NID_NET_BT, r, "[%s] exception occurred on stopping Health sink role.", GetErrorMessage(r)); + } + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [ActionResult:%s]", GetStringOfCurrentState(), GetErrorMessage(r)); + + return r; +} + +result +_BluetoothHealthImpl::ConnectToSource(const BluetoothDevice& remoteDevice) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s]", GetStringOfCurrentState()); + + result r = E_OPERATION_FAILED; + + __stateMutex.Acquire(); + + switch (__currentState) + { + case _BT_HEALTH_STATE_DISABLED: + r = E_INVALID_STATE; + break; + + case _BT_HEALTH_STATE_IDLE: + r = E_INVALID_OPERATION; + break; + + case _BT_HEALTH_STATE_ON_SERVICE: + if (__pGapAdapter->IsPaired(*(remoteDevice.GetAddress())) == true) + { + r = __pHdpAdapter->ConnectToSource(*(remoteDevice.GetAddress()), __pAppId.get()); + } + else + { + // start the pairing process + if (__pGapAdapter->Pair(*(remoteDevice.GetAddress())) == E_SUCCESS) + { + // copy the address of the pairing device to the local variable + __pairingTargetAddress.SetArray(remoteDevice.GetAddress()->GetPointer(), 0, _BT_ADDRESS_LENGTH); + __pairingTargetAddress.SetPosition(0); + + r = E_SUCCESS; + __currentState = _BT_HEALTH_STATE_BONDING; + } + else + { + r = E_OPERATION_FAILED; + } + } + break; + + case _BT_HEALTH_STATE_BONDING: + case _BT_HEALTH_STATE_BOND_CANCELING: + r = E_DEVICE_BUSY; + break; + + default: + r = E_OPERATION_FAILED; + break; + } + + __stateMutex.Release(); + + if (r != E_SUCCESS) + { + SysLogException(NID_NET_BT, r, "[%s] exception occurred on requesting a connection to the source device.", GetErrorMessage(r)); + } + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [ActionResult:%s]", GetStringOfCurrentState(), GetErrorMessage(r)); + + return r; +} + +result +_BluetoothHealthImpl::Disconnect(int channelId) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s]", GetStringOfCurrentState()); + + result r = E_OPERATION_FAILED; + + __stateMutex.Acquire(); + + switch (__currentState) + { + case _BT_HEALTH_STATE_DISABLED: + r = E_INVALID_STATE; + break; + + case _BT_HEALTH_STATE_IDLE: + r = E_INVALID_OPERATION; + break; + + case _BT_HEALTH_STATE_ON_SERVICE: + case _BT_HEALTH_STATE_BONDING: + case _BT_HEALTH_STATE_BOND_CANCELING: + if (__channelIdList.Contains(channelId) == true) + { + if (__pHdpAdapter->Disconnect(channelId) == E_SUCCESS) + { + r = E_SUCCESS; + } + else + { + r = E_OPERATION_FAILED; + } + } + else + { + r = E_INVALID_OPERATION; + } + break; + + default: + r = E_OPERATION_FAILED; + break; + } + + __stateMutex.Release(); + + if (r != E_SUCCESS) + { + SysLogException(NID_NET_BT, r, "[%s] exception occurred on disconnecting the connection.", GetErrorMessage(r)); + } + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [ActionResult:%s]", GetStringOfCurrentState(), GetErrorMessage(r)); + + return r; +} + +result +_BluetoothHealthImpl::SendData(int channelId, const Tizen::Base::ByteBuffer& buffer) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s]", GetStringOfCurrentState()); + + result r = E_OPERATION_FAILED; + + __stateMutex.Acquire(); + + switch (__currentState) + { + case _BT_HEALTH_STATE_DISABLED: + r = E_INVALID_STATE; + break; + + case _BT_HEALTH_STATE_IDLE: + r = E_INVALID_OPERATION; + break; + + case _BT_HEALTH_STATE_ON_SERVICE: + case _BT_HEALTH_STATE_BONDING: + case _BT_HEALTH_STATE_BOND_CANCELING: + if (__channelIdList.Contains(channelId) == true) + { + if (buffer.GetRemaining() > 0) + { + r = __pHdpAdapter->SendData(channelId, buffer); + } + else + { + r = E_INVALID_ARG; + } + } + else + { + r = E_INVALID_OPERATION; + } + break; + + default: + r = E_OPERATION_FAILED; + break; + } + + __stateMutex.Release(); + + if (r != E_SUCCESS) + { + SysLogException(NID_NET_BT, r, "[%s] exception occurred on sending data.", GetErrorMessage(r)); + } + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [ActionResult:%s]", GetStringOfCurrentState(), GetErrorMessage(r)); + + return r; +} + +void +_BluetoothHealthImpl::OnBluetoothActivated(result r) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s]", GetStringOfCurrentState()); + + __stateMutex.Acquire(); + + if ((__currentState == _BT_HEALTH_STATE_DISABLED) && (r == E_SUCCESS)) + { + __currentState = _BT_HEALTH_STATE_IDLE; + } + + __stateMutex.Release(); + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [ActionResult:%s]", GetStringOfCurrentState(), GetErrorMessage(r)); +} + +void +_BluetoothHealthImpl::OnBluetoothDeactivated(result r) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s], [ActionResult:%s]", GetStringOfCurrentState(), GetErrorMessage(r)); + + __stateMutex.Acquire(); + + if (r == E_SUCCESS) + { + __currentState = _BT_HEALTH_STATE_DISABLED; + } + + __stateMutex.Release(); + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s]", GetStringOfCurrentState()); +} + +void +_BluetoothHealthImpl::OnBluetoothPaired(const BluetoothDevice* pPairedDevice, result r) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s], [ActionResult:%s]", GetStringOfCurrentState(), GetErrorMessage(r)); + + bool isFired = false; + result responseResult = E_SYSTEM; + + __stateMutex.Acquire(); + + if (pPairedDevice->GetAddress()->Equals(__pairingTargetAddress)) + { + if (__currentState == _BT_HEALTH_STATE_BONDING) + { + if (r == E_SUCCESS) + { + if (__pHdpAdapter->ConnectToSource(__pairingTargetAddress, __pAppId.get()) != E_SUCCESS) + { + // callback responded with E_SYSTEM + isFired = true; + responseResult = E_SYSTEM; + } + } + else + { + // callback responded with r + isFired = true; + responseResult = r; + } + + __currentState = _BT_HEALTH_STATE_ON_SERVICE; + __pairingTargetAddress.Clear(); + } + else if (__currentState == _BT_HEALTH_STATE_BOND_CANCELING) + { + // callback responded with E_SYSTEM or E_OPERATION_CANCELED + isFired = true; + __currentState = _BT_HEALTH_STATE_IDLE; + responseResult = E_SYSTEM; + } + // ignore other cases + } + // ignored otherwise + + __stateMutex.Release(); + + if (isFired) + { + _BluetoothHealthEventArg* pArg = new (std::nothrow) _BluetoothHealthEventArg(-1, + _BT_INVALID_DATA_TYPE, BT_HEALTH_DATA_CHANNEL_NONE, pPairedDevice, E_OPERATION_FAILED); + if (pArg == null) + { + SysLogException(NID_NET_BT, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient."); + isFired = false; + } + else // send the connected event in case of failure of pairing + { + __pEvent->FireAsync(*pArg); + } + } + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [CONNECTED_Event:%s]", GetStringOfCurrentState(), + isFired ? "Fired" : "NotFired"); +} + +void +_BluetoothHealthImpl::OnBluetoothHealthConnected(int channelId, BluetoothHealthDataChannelType channelType, + const BluetoothDevice* pRemoteDevice, result r) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s], [channelId:%d], [ActionResult:%s]", GetStringOfCurrentState(), + channelId, GetErrorMessage(r)); + + bool isFired = false; + + __stateMutex.Acquire(); + + if ((__currentState == _BT_HEALTH_STATE_ON_SERVICE) + || (__currentState == _BT_HEALTH_STATE_BONDING) + || (__currentState == _BT_HEALTH_STATE_BOND_CANCELING)) + { + if (r == E_SUCCESS) + { + __channelIdList.Add(channelId); + } + else + { + SysLogException(NID_NET_BT, r, "[%s] exception occurred on the response of the Health connect request.", GetErrorMessage(r)); + } + + isFired = true; + } + // ignore other cases + + __stateMutex.Release(); + + if (isFired) + { + _BluetoothHealthEventArg* pArg = new (std::nothrow) _BluetoothHealthEventArg(channelId, __dataType, channelType, + pRemoteDevice, r); + if (pArg == null) + { + SysLogException(NID_NET_BT, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient."); + isFired = false; + } + else + { + __pEvent->FireAsync(*pArg); + } + } + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [CONNECTED_Event:%s]", GetStringOfCurrentState(), + isFired ? "Fired" : "NotFired"); +} + +void +_BluetoothHealthImpl::OnBluetoothHealthDisconnected(int channelId, result r) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s], [channelId:%d], [ActionResult:%s]", GetStringOfCurrentState(), + channelId, GetErrorMessage(r)); + + bool isFired = false; + + __stateMutex.Acquire(); + + if ((__currentState == _BT_HEALTH_STATE_ON_SERVICE) + || (__currentState == _BT_HEALTH_STATE_BONDING) + || (__currentState == _BT_HEALTH_STATE_BOND_CANCELING)) + { + if (r == E_SUCCESS) + { + if (__channelIdList.Contains(channelId) == true) + { + __channelIdList.Remove(channelId); + isFired = true; + } + else + { + SysLog(NID_NET_BT, "channelId(%d) is NOT exist.", channelId); + } + } + else + { + SysLogException(NID_NET_BT, r, "[%s] exception occurred on the response of the Health disconnect request.", GetErrorMessage(r)); + } + } + // ignore other cases + + __stateMutex.Release(); + + if (isFired) + { + _BluetoothHealthEventArg* pArg = new (std::nothrow) _BluetoothHealthEventArg(channelId, r); + if (pArg == null) + { + SysLogException(NID_NET_BT, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient."); + isFired = false; + } + else + { + __pEvent->FireAsync(*pArg); + } + } + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [DISCONNECTED_Event:%s]", GetStringOfCurrentState(), + isFired ? "Fired" : "NotFired"); +} + +void +_BluetoothHealthImpl::OnBluetoothHealthDataReceived(int channelId, Tizen::Base::ByteBuffer& buffer) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s]", GetStringOfCurrentState()); + + bool isFired = false; + + __stateMutex.Acquire(); + + if ((__currentState == _BT_HEALTH_STATE_ON_SERVICE) + || (__currentState == _BT_HEALTH_STATE_BONDING) + || (__currentState == _BT_HEALTH_STATE_BOND_CANCELING)) + { + if (__channelIdList.Contains(channelId) == true) + { + isFired = true; + } + else + { + SysLog(NID_NET_BT, "channelId(%d) is NOT exist.", channelId); + } + } + // ignore other cases + + __stateMutex.Release(); + + if (isFired) + { + _BluetoothHealthEventArg* pArg = new (std::nothrow) _BluetoothHealthEventArg(channelId, buffer); + if (pArg == null) + { + SysLogException(NID_NET_BT, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient."); + isFired = false; + } + else + { + // use Fire() instead of FireAsync() to improve the transfer rate. + __pEvent->Fire(*pArg); + } + } + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [DATA_RECIEVED_Event:%s]", GetStringOfCurrentState(), + isFired ? "Fired" : "NotFired"); +} + +const char* +_BluetoothHealthImpl::GetStringOfCurrentState(void) const +{ + const char* pStateString = null; + + switch (__currentState) + { + case _BT_HEALTH_STATE_DISABLED: + pStateString = "DISABLED"; + break; + + case _BT_HEALTH_STATE_IDLE: + pStateString = "IDLE"; + break; + + case _BT_HEALTH_STATE_ON_SERVICE: + pStateString = "ON_SERVICE"; + break; + + case _BT_HEALTH_STATE_BONDING: + pStateString = "BONDING"; + break; + + case _BT_HEALTH_STATE_BOND_CANCELING: + pStateString = "BOND_CANCELING"; + break; + + default: + pStateString = "Unknown"; + break; + } + + return pStateString; +} + +} } } // Tizen::Net::Bluetooth diff --git a/src/FNetBt_BluetoothIpcMessages.cpp b/src/FNetBt_BluetoothIpcMessages.cpp new file mode 100644 index 0000000..5f364d2 --- /dev/null +++ b/src/FNetBt_BluetoothIpcMessages.cpp @@ -0,0 +1,44 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +/** + * @file FNetBt_BluetoothIpcMessages.cpp + * @brief This is the generator of IPC messages for the Connectivity daemon service. + */ + +#define IPC_MESSAGE_IMPL +#include "FNetBt_ConnectivityIpcMessages.h" + +// Generate constructors. +#include +#include "FNetBt_ConnectivityIpcMessages.h" + +// Generate destructors. +#include +#include "FNetBt_ConnectivityIpcMessages.h" + +// Generate param traits write methods. +#include +namespace IPC { +#include "FNetBt_ConnectivityIpcMessages.h" +} // namespace IPC + +// Generate param traits read methods. +#include +namespace IPC { +#include "FNetBt_ConnectivityIpcMessages.h" +} // namespace IPC diff --git a/src/FNetBt_BluetoothIpcProxy.cpp b/src/FNetBt_BluetoothIpcProxy.cpp new file mode 100755 index 0000000..5fa6056 --- /dev/null +++ b/src/FNetBt_BluetoothIpcProxy.cpp @@ -0,0 +1,158 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// @file FNetBt_BluetoothIpcProxy.cpp +// @brief This is the implementation file for the %_BluetoothIpcProxy class. +// +// This file contains the implementation of the %_BluetoothIpcProxy class. +// + +#include +#include +#include +#include "FNetBt_BluetoothIpcProxy.h" +#include "FNetBt_ConnectivityIpcMessages.h" + +using namespace Tizen::Base; +using namespace Tizen::Io; + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +_BluetoothIpcProxy* _BluetoothIpcProxy::__pInstance = null; + +_BluetoothIpcProxy::_BluetoothIpcProxy(void) : + __pIpcClient(null) +{ +} + +_BluetoothIpcProxy::~_BluetoothIpcProxy(void) +{ + delete __pIpcClient; +} + +result +_BluetoothIpcProxy::Construct(void) +{ + result r = E_SUCCESS; + + __pIpcClient = new (std::nothrow) _IpcClient; + SysTryReturnResult(NID_NET_BT, __pIpcClient != null, E_OUT_OF_MEMORY, "The memory is insufficient."); + + r = __pIpcClient->Construct(BLUETOOTH_CONNECTIVITY_IPC_SERVER_NAME, null); + if (IsFailed(r)) + { + delete __pIpcClient; + __pIpcClient = null; + + SysLog(NID_NET_BT, "[%s] Construction of the IPC client for the Bluetooth proxy has failed.", GetErrorMessage(r)); + } + + return r; +} + +void +_BluetoothIpcProxy::InitSingleton(void) +{ + result r = E_SUCCESS; + static _BluetoothIpcProxy inst; + + r = inst.Construct(); + SysTryReturnVoidResult(NID_NET_BT, r == E_SUCCESS, r, "[%s] Propagating.", GetErrorMessage(r)); + + __pInstance = &inst; +} + +_BluetoothIpcProxy* +_BluetoothIpcProxy::GetInstance(void) +{ + static pthread_once_t onceBlock = PTHREAD_ONCE_INIT; + + if (__pInstance == null) + { + ClearLastResult(); + pthread_once(&onceBlock, InitSingleton); + result r = GetLastResult(); + if (IsFailed(r)) + { + onceBlock = PTHREAD_ONCE_INIT; + } + } + + return __pInstance; +} + +result +_BluetoothIpcProxy::GetLocalDeviceName(Tizen::Base::String& deviceName) const +{ + result r = E_SUCCESS; + IPC::Message* pMessage = null; + unsigned long ret = 0; + + pMessage = new (std::nothrow) ConnectivityBluetoothServiceMsg_getLocalDeviceName(&deviceName, &ret); + SysTryReturnResult(NID_NET_BT, pMessage != null, E_OUT_OF_MEMORY, "The memory is insufficient."); + + r = __pIpcClient->SendRequest(*pMessage); + delete pMessage; + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_SYSTEM, "A system error occurred."); + SysTryReturnResult(NID_NET_BT, ret == E_SUCCESS, ret, "Propagating."); + + SysLog(NID_NET_BT, "The Bluetooth name obtained through IPC is [%ls].", deviceName.GetPointer()); + + return E_SUCCESS; +} + +result +_BluetoothIpcProxy::SetLocalDeviceName(const Tizen::Base::String& deviceName) const +{ + result r = E_SUCCESS; + IPC::Message* pMessage = null; + unsigned long ret = 0; + + pMessage = new (std::nothrow) ConnectivityBluetoothServiceMsg_setLocalDeviceName(deviceName, &ret); + SysTryReturnResult(NID_NET_BT, pMessage != null, E_OUT_OF_MEMORY, "The memory is insufficient."); + + r = __pIpcClient->SendRequest(*pMessage); + delete pMessage; + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_SYSTEM, "A system error occurred."); + SysTryReturnResult(NID_NET_BT, ret == E_SUCCESS, ret, "Propagating."); + + SysLog(NID_NET_BT, "Setting the Bluetooth name through IPC is successful."); + + return E_SUCCESS; +} + +result +_BluetoothIpcProxy::SetDiscoverableMode(int mode, int seconds) const +{ + result r = E_SUCCESS; + IPC::Message* pMessage = null; + unsigned long ret = 0; + + pMessage = new (std::nothrow) ConnectivityBluetoothServiceMsg_setDiscoverableMode(mode, seconds, &ret); + SysTryReturnResult(NID_NET_BT, pMessage != null, E_OUT_OF_MEMORY, "The memory is insufficient."); + + r = __pIpcClient->SendRequest(*pMessage); + delete pMessage; + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_SYSTEM, "A system error occurred."); + SysTryReturnResult(NID_NET_BT, ret == E_SUCCESS, ret, "Propagating."); + + SysLog(NID_NET_BT, "Setting the Bluetooth discoverable mode through IPC is successful."); + + return E_SUCCESS; +} + +} } } // Tizen::Net::Bluetooth diff --git a/src/FNetBt_BluetoothIpcProxy.h b/src/FNetBt_BluetoothIpcProxy.h new file mode 100644 index 0000000..567399e --- /dev/null +++ b/src/FNetBt_BluetoothIpcProxy.h @@ -0,0 +1,77 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +/** + * @file FNetBt_BluetoothIpcProxy.h + * @brief This is the header file for the %_BluetoothIpcProxy class. + * + * This header file contains the declarations of the %_BluetoothIpcProxy class. + */ + +#ifndef _FNET_BT_INTERNAL_BLUETOOTH_IPC_PROXY_H_ +#define _FNET_BT_INTERNAL_BLUETOOTH_IPC_PROXY_H_ + +#include + +// Forward declaration +namespace Tizen { namespace Base +{ +class String; +} } + +namespace Tizen { namespace Io +{ +class _IpcClient; +} } + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +/** + * @class _BluetoothIpcProxy + * @brief This class represents an IPC proxy for %Bluetooth service. + * + * This class represents an IPC proxy for %Bluetooth service to communicate with Connectivity service daemon. + */ +class _BluetoothIpcProxy + : public Tizen::Base::Object +{ +public: + static _BluetoothIpcProxy* GetInstance(void); + + result GetLocalDeviceName(Tizen::Base::String& deviceName) const; + result SetLocalDeviceName(const Tizen::Base::String& deviceName) const; + result SetDiscoverableMode(int mode, int seconds) const; + +private: + _BluetoothIpcProxy(void); + virtual ~_BluetoothIpcProxy(void); + result Construct(void); + + + _BluetoothIpcProxy(const _BluetoothIpcProxy& value); + _BluetoothIpcProxy& operator =(const _BluetoothIpcProxy& rhs); + + static void InitSingleton(void); + +private: + Tizen::Io::_IpcClient* __pIpcClient; + static _BluetoothIpcProxy* __pInstance; + +}; // _BluetoothIpcProxy + +} } } +#endif // _FNET_BT_INTERNAL_BLUETOOTH_IPC_PROXY_H_ diff --git a/src/FNetBt_BluetoothManagerEvent.cpp b/src/FNetBt_BluetoothManagerEvent.cpp new file mode 100644 index 0000000..a5fa2c5 --- /dev/null +++ b/src/FNetBt_BluetoothManagerEvent.cpp @@ -0,0 +1,78 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// @file FNetBt_BluetoothManagerEvent.cpp +// @brief This is the implementation file for the _BluetoothManagerEvent class. +// + +#include +#include +#include +#include "FNetBt_BluetoothManagerEvent.h" +#include "FNetBt_BluetoothManagerEventArg.h" +#include "FNetBtIBluetoothManagerEventListener.h" + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +_BluetoothManagerEvent::_BluetoothManagerEvent(void) +{ +} + +_BluetoothManagerEvent::~_BluetoothManagerEvent(void) +{ +} + +result +_BluetoothManagerEvent::Construct(void) +{ + return _Event::Initialize(); +} + +void +_BluetoothManagerEvent::FireImpl(Tizen::Base::Runtime::IEventListener& listener, const Tizen::Base::Runtime::IEventArg& arg) +{ + IBluetoothManagerEventListener* pEventListener = dynamic_cast (&listener); + SysTryReturnVoidResult(NID_NET_BT, pEventListener != null, E_INVALID_ARG, "[E_INVALID_ARG] The listener argument is invalid."); + + const _BluetoothManagerEventArg* pEventArg = dynamic_cast (&arg); + SysTryReturnVoidResult(NID_NET_BT, pEventArg != null, E_INVALID_ARG, "[E_INVALID_ARG] The event argument is invalid type."); + + _BluetoothMangerEventType eventType = pEventArg->GetEventType(); + + switch (eventType) + { + case _BT_MANAGER_EVENT_ACTIVATED: + SysLog(NID_NET_BT, "Firing Bluetooth Manager Event (Type: _BT_MANAGER_EVENT_ACTIVATED)"); + pEventListener->OnBluetoothActivated(pEventArg->GetErrorResult()); + break; + + case _BT_MANAGER_EVENT_DEACTIVATED: + SysLog(NID_NET_BT, "Firing Bluetooth Manager Event (Type: _BT_MANAGER_EVENT_DEACTIVATED)"); + pEventListener->OnBluetoothDeactivated(pEventArg->GetErrorResult()); + break; + + case _BT_MANAGER_EVENT_DISCOVERABLE: + SysLog(NID_NET_BT, "Firing Bluetooth Manager Event (Type: _BT_MANAGER_EVENT_DISCOVERABLE)"); + pEventListener->OnBluetoothDiscoverableModeChanged(pEventArg->GetDiscoverableMode()); + break; + + default: + break; + } +} + +} } } // Tizen::Net::Bluetooth diff --git a/src/FNetBt_BluetoothManagerEvent.h b/src/FNetBt_BluetoothManagerEvent.h new file mode 100644 index 0000000..6f54926 --- /dev/null +++ b/src/FNetBt_BluetoothManagerEvent.h @@ -0,0 +1,83 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +/** + * @file FNetBt_BluetoothManagerEvent.h + * @brief This is the header file for the _BluetoothManagerEvent class. + * + * This header file contains the declarations of the _BluetoothManagerEvent class. + * The _BluetoothManagerEvent class can call a method of a listener (IBluetoothManagerEventListener object). + * So, when a device event is occurred, listener instances can handle it appropriately. + */ +#ifndef _FNET_BT_INTERNAL_BLUETOOTH_MANAGER_EVENT_H_ +#define _FNET_BT_INTERNAL_BLUETOOTH_MANAGER_EVENT_H_ + +#include +#include +#include + +namespace Tizen { namespace Base { namespace Runtime +{ +class IEventListener; +class IEventArg; +} } } + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +/** + * @class _BluetoothManagerEvent + * @brief This class handles Bluetooth manager events. + * + * When a Bluetooth manager event occurs, the _BluetoothManagerEvent object finds a IBluetoothManagerEventListener object + * and calls an appropriate method of the listener. + */ +class _BluetoothManagerEvent + : public Base::Runtime::_Event +{ +public: + /** + * This is the default constructor. + */ + _BluetoothManagerEvent(void); + + /** + * This is the class destructor. + */ + virtual ~_BluetoothManagerEvent(void); + result Construct(void); + +protected: + /** + * Checks the argument and finds out the type of event. After that, this method calls appropriate pListener's method. + * + * @return A result code. + * @param[in] pListener An event listener related to this Bluetooth manger event. + * @param[in] arg An event argument including information to be passed to the event listeners + * @exception E_SUCCESS The method is successful. + * @exception E_INVALID_ARG The argument passed to a method contains invalid values. + * @exception E_SYSTEM A system error occurred. + */ + virtual void FireImpl(Tizen::Base::Runtime::IEventListener& listener, const Tizen::Base::Runtime::IEventArg& arg); + +private: + _BluetoothManagerEvent(const _BluetoothManagerEvent& value); + _BluetoothManagerEvent& operator =(const _BluetoothManagerEvent& rhs); + +}; // _BluetoothManagerEvent + +} } } +#endif // _FNET_BT_INTERNAL_BLUETOOTH_MANAGER_EVENT_H_ diff --git a/src/FNetBt_BluetoothManagerEventArg.cpp b/src/FNetBt_BluetoothManagerEventArg.cpp new file mode 100644 index 0000000..bb40bca --- /dev/null +++ b/src/FNetBt_BluetoothManagerEventArg.cpp @@ -0,0 +1,64 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// @file FNetBt_BluetoothManagerEventArg.cpp +// @brief This is the implementation file for the _BluetoothManagerEventArg class. +// + +#include "FNetBt_BluetoothManagerEventArg.h" + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +// This is a class constructor for _BT_MANAGER_EVENT_ACTIVATED or _BT_MANAGER_EVENT_DEACTIVATED. +_BluetoothManagerEventArg::_BluetoothManagerEventArg(_BluetoothMangerEventType evt, result r) + : __evt(evt) + , __result(r) + , __mode(BT_DISC_MODE_NOT_DISCOVERABLE) +{ +} + +// This is a class constructor for _BT_MANAGER_EVENT_DISCOVERABLE. +_BluetoothManagerEventArg::_BluetoothManagerEventArg(BluetoothDiscoverableMode mode) + : __evt(_BT_MANAGER_EVENT_DISCOVERABLE) + , __result(E_SUCCESS) + , __mode(mode) +{ +} + +_BluetoothManagerEventArg::~_BluetoothManagerEventArg(void) +{ +} + +_BluetoothMangerEventType +_BluetoothManagerEventArg::GetEventType(void) const +{ + return __evt; +} + +result +_BluetoothManagerEventArg::GetErrorResult(void) const +{ + return __result; +} + +BluetoothDiscoverableMode +_BluetoothManagerEventArg::GetDiscoverableMode(void) const +{ + return __mode; +} + +} } } // Tizen::Net::Bluetooth diff --git a/src/FNetBt_BluetoothManagerEventArg.h b/src/FNetBt_BluetoothManagerEventArg.h new file mode 100644 index 0000000..48a73af --- /dev/null +++ b/src/FNetBt_BluetoothManagerEventArg.h @@ -0,0 +1,114 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +/** + * @file FNetBt_BluetoothManagerEventArg.h + * @brief This is the header file for the _BluetoothManagerEventArg class. + * + * This header file contains the declarations of the _BluetoothManagerEventArg class which includes information to be + * passed to the event listeners + */ +#ifndef _FNET_BT_INTERNAL_BLUETOOTH_MANAGER_EVENT_ARG_H_ +#define _FNET_BT_INTERNAL_BLUETOOTH_MANAGER_EVENT_ARG_H_ + +#include +#include +#include +#include +#include + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +/** + * @enum _BluetoothMangerEventType + * Type for specifying the type of _BluetoothMangerEvent + */ +enum _BluetoothMangerEventType +{ + _BT_MANAGER_EVENT_ACTIVATED, /**< For notifying that Bluetooth is activated */ + _BT_MANAGER_EVENT_DEACTIVATED, /**< For notifying that Bluetooth is deactivated */ + _BT_MANAGER_EVENT_DISCOVERABLE /**< For notifying that Bluetooth discoverable mode is changed */ +}; + +/** + * @class _BluetoothManagerEventArg + * @brief This class is used as an argument for callback methods of the IBluetoothManagerEventListener class. + * + * When a _BluetoothManagerEvent occurs, the _BluetoothManagerEvent finds a IBluetoothManagerEventListener instance + * which is registered for the _BluetoothManagerEvent and calls an appropriate method of the listener. + * @see IBluetoothManagerEventListener + */ +class _BluetoothManagerEventArg + : public Tizen::Base::Object + , public Tizen::Base::Runtime::IEventArg +{ +public: + /** + * This is a class constructor for _BT_MANAGER_EVENT_ACTIVATED or _BT_MANAGER_EVENT_DEACTIVATED. + * + * @param[in] evt The type of the event + * @param[in] r The result of the event + */ + _BluetoothManagerEventArg(_BluetoothMangerEventType evt, result r); + + /** + * This is a class constructor for _BT_MANAGER_EVENT_DISCOVERABLE. + * + * @param[in] mode The changed discoverable mode + */ + _BluetoothManagerEventArg(BluetoothDiscoverableMode mode); + + /** + * This is the class destructor. + */ + ~_BluetoothManagerEventArg(void); + + /** + * Gets the type of this event. + * + * @return The type of the event + */ + _BluetoothMangerEventType GetEventType(void) const; + + /** + * Gets the error result of this event. + * + * @return The result of the event + */ + result GetErrorResult(void) const; + + /** + * Gets the discoverable mode of this event. + * + * @return The discoverable mode + */ + BluetoothDiscoverableMode GetDiscoverableMode(void) const; + +private: + _BluetoothManagerEventArg(void); + _BluetoothManagerEventArg(const _BluetoothManagerEventArg& eventArg); + _BluetoothManagerEventArg& operator =(const _BluetoothManagerEventArg& rValue); + +private: + _BluetoothMangerEventType __evt; + result __result; + BluetoothDiscoverableMode __mode; + +}; // _BluetoothManagerEventArg + +} } } +#endif // _FNET_BT_INTERNAL_BLUETOOTH_MANAGER_EVENT_ARG_H_ diff --git a/src/FNetBt_BluetoothManagerImpl.cpp b/src/FNetBt_BluetoothManagerImpl.cpp new file mode 100755 index 0000000..01c3f24 --- /dev/null +++ b/src/FNetBt_BluetoothManagerImpl.cpp @@ -0,0 +1,1841 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// @file FNetBt_BluetoothManagerImpl.cpp +// @brief This is the implementation file for the _BluetoothManagerImpl class. +// + +#include +#include +#include +#include +#include +#include +#include +#include "FNetBt_BluetoothGapSystemAdapter.h" +#include "FNetBt_BluetoothDeviceImpl.h" +#include "FNetBt_BluetoothManagerImpl.h" +#include "FNetBt_BluetoothIpcProxy.h" +#include "FNetBt_BluetoothManagerEvent.h" +#include "FNetBt_BluetoothManagerEventArg.h" +#include "FNetBt_BluetoothDeviceEvent.h" +#include "FNetBt_BluetoothDeviceEventArg.h" +#include "FNetBt_BluetoothConnectionEvent.h" +#include "FNetBt_BluetoothConnectionEventArg.h" + +using namespace std; +using namespace Tizen::Base; +using namespace Tizen::Base::Runtime; +using namespace Tizen::Base::Collection; + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +_BluetoothManagerImpl::_BluetoothManagerImpl(void) + : __pIpcProxy(null) + , __pGapAdapter(null) + , __pMgrEvent(null) + , __pDevEvent(null) + , __pConEvent(null) + , __pDevEvtListener(null) + , __pConEvtListener(null) + , __pLocalDevice(null) + , __pairedDeviceList() + , __pairedDeviceMap() + , __stateMutex() + , __pairedDevMapMutex() + , __currentState(_BT_MGR_STATE_DEACTIVATED) + , __pairingState(_BT_PAIRING_STATE_NONE) + , __pairingTargetAddress() + , __discoveredDeviceList() +{ +} + +_BluetoothManagerImpl::~_BluetoothManagerImpl(void) +{ + if (__pGapAdapter != null) + { + if ((__currentState == _BT_MGR_STATE_DISCOVERY_REQUESTED) + || (__currentState == _BT_MGR_STATE_ON_DISCOVERY)) + { + SysLog(NID_NET_BT, "Cancel the device discovery for resource clean."); + (void) CancelDiscovery(); + } + + __pGapAdapter->UnregisterManagerEventListener(*this); + __pGapAdapter->UnregisterDeviceEventListener(*this); + } +} + +result +_BluetoothManagerImpl::Construct(IBluetoothManagerEventListener& listener) +{ + result r = E_SUCCESS; + unique_ptr<_BluetoothManagerEvent> pMgrEvent; + unique_ptr<_BluetoothDeviceEvent> pDevEvent; + unique_ptr<_BluetoothConnectionEvent> pConEvent; + + r = __stateMutex.Create(); + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_SYSTEM, "Failed to create the state mutex."); + + r = __pairedDevMapMutex.Create(); + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_SYSTEM, "Failed to create the map mutex."); + + r = __pairingTargetAddress.Construct(_BT_ADDRESS_LENGTH); + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_SYSTEM, "Failed to construct the address for pairing."); + + __pIpcProxy = _BluetoothIpcProxy::GetInstance(); + SysTryReturnResult(NID_NET_BT, __pIpcProxy != null, E_SYSTEM, "Failed to get an instance of _BluetoothIpcProxy."); + + __pGapAdapter = _BluetoothGapSystemAdapter::GetInstance(); + SysTryReturnResult(NID_NET_BT, __pGapAdapter != null, E_SYSTEM, "Failed to get an instance of _BluetoothGapSystemAdapter."); + + pMgrEvent.reset(new (std::nothrow) _BluetoothManagerEvent()); + SysTryReturnResult(NID_NET_BT, pMgrEvent != null, E_OUT_OF_MEMORY, "The memory is insufficient."); + r = pMgrEvent->Construct(); + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_SYSTEM, "Failed to construct the event."); + + pDevEvent.reset(new (std::nothrow) _BluetoothDeviceEvent()); + SysTryReturnResult(NID_NET_BT, pDevEvent != null, E_OUT_OF_MEMORY, "The memory is insufficient."); + r = pDevEvent->Construct(); + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_SYSTEM, "Failed to construct the event."); + + pConEvent.reset(new (std::nothrow) _BluetoothConnectionEvent()); + SysTryReturnResult(NID_NET_BT, pConEvent != null, E_OUT_OF_MEMORY, "The memory is insufficient."); + r = pConEvent->Construct(); + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_SYSTEM, "Failed to construct the event."); + + // add the IBluetoothManagerEventListener instance to a new created _BluetoothManagerEvent. + r = pMgrEvent->AddListener(listener, true); + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_SYSTEM, + "Failed to add the application listener for BluetoothManager event"); + + // initialize the paired device list which is used for old version APIs + __pairedDeviceList.Construct(); + r = RefreshPairedDeviceList(); + SysTryReturn(NID_NET_BT, r == E_SUCCESS, r, r, "[%s] Failed to make the paired device list.", GetErrorMessage(r)); + + // initialize the paired device map which is used since 2.0 + __pairedDeviceMap.Construct(); + r = RefreshPairedDeviceMap(); + SysTryReturn(NID_NET_BT, r == E_SUCCESS, r, r, "[%s] Failed to make the paired device map.", GetErrorMessage(r)); + + // registers this listener to the manager event of the system adapter for activation/deactivation + r = __pGapAdapter->RegisterManagerEventListener(*this, false); + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_SYSTEM, + "Failed to register the manager event listener to _BluetoothSystemAdapter."); + + // registers this listener to the device event of the system adapter for device/service discovery + r = __pGapAdapter->RegisterDeviceEventListener(*this); + if (r != E_SUCCESS) + { + __pGapAdapter->UnregisterManagerEventListener(*this); + SysLogException(NID_NET_BT, E_SYSTEM, + "[E_SYSTEM] Failed to register the device event listener to _BluetoothSystemAdapter."); + return E_SYSTEM; + } + + // checks the initial state of local Bluetooth + __stateMutex.Acquire(); + + if (__pGapAdapter->IsActivated() == true) + { + if (__pGapAdapter->IsDiscoveryInProgress() == true) + { + __currentState = _BT_MGR_STATE_ON_DISCOVERY_BY_SYSTEM; + } + else + { + __currentState = _BT_MGR_STATE_ACTIVATED; + } + } + + __stateMutex.Release(); + + __pMgrEvent = move(pMgrEvent); + __pDevEvent = move(pDevEvent); + __pConEvent = move(pConEvent); + + return E_SUCCESS; +} + +result +_BluetoothManagerImpl::Activate(void) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s]", GetStringOfCurrentState()); + + result r = E_SUCCESS; + + __stateMutex.Acquire(); + + switch (__currentState) + { + case _BT_MGR_STATE_DEACTIVATED: + r = __pGapAdapter->Activate(); + if (r == E_SUCCESS) + { + __currentState = _BT_MGR_STATE_ACTIVATING; + } + break; + + case _BT_MGR_STATE_ACTIVATING: + r = E_IN_PROGRESS; + break; + + default: + r = E_INVALID_OPERATION; + break; + } + __stateMutex.Release(); + + if (r != E_SUCCESS) + { + SysLogException(NID_NET_BT, r, "[%s] exception occurred on activating Bluetooth.", GetErrorMessage(r)); + } + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [result:%s]", GetStringOfCurrentState(), GetErrorMessage(r)); + + return r; +} + +result +_BluetoothManagerImpl::Deactivate(void) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s]", GetStringOfCurrentState()); + + result r = E_SUCCESS; + + __stateMutex.Acquire(); + + switch (__currentState) + { + case _BT_MGR_STATE_DEACTIVATED: + case _BT_MGR_STATE_ACTIVATING: + r = E_INVALID_OPERATION; + break; + + case _BT_MGR_STATE_DEACTIVATING: + r = E_IN_PROGRESS; + break; + + default: + r = __pGapAdapter->Deactivate(); + if (r == E_SUCCESS) + { + __currentState = _BT_MGR_STATE_DEACTIVATING; + } + break; + } + __stateMutex.Release(); + + if (r != E_SUCCESS) + { + SysLogException(NID_NET_BT, r, "[%s] exception occurred on deactivating Bluetooth.", GetErrorMessage(r)); + } + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [result:%s]", GetStringOfCurrentState(), GetErrorMessage(r)); + + return r; +} + +bool +_BluetoothManagerImpl::IsAvailable(BluetoothConnectionType type) const +{ + return __pGapAdapter->IsAvailable(type); +} + +const BluetoothDevice* +_BluetoothManagerImpl::GetLocalDevice(void) +{ + ByteBuffer localAddr; + String localAddrStr; + String localName; + result r = E_SUCCESS; + _BluetoothDeviceImpl* pImpl = null; + + // Gets the Bluetooth address. + localAddrStr = __pGapAdapter->GetLocalDeviceAddress(); + localAddr.Construct(_BT_ADDRESS_LENGTH); + r = _BluetoothDeviceImpl::GetAddressByteBuffer(localAddrStr, L":", localAddr); + SysTryReturn(NID_NET_BT, r == E_SUCCESS, null, E_SYSTEM, "[E_SYSTEM] Getting the Bluetooth address has failed."); + + // Gets the Bluetooth local name. + localName = GetLocalDeviceName(); + + if (__pLocalDevice == null) + { + __pLocalDevice = new (std::nothrow) BluetoothDevice(); + if (__pLocalDevice == null) + { + SysLogException(NID_NET_BT, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient on creation of BluetoothDevice."); + SetLastResult(E_OUT_OF_MEMORY); + return null; + } + + pImpl = _BluetoothDeviceImpl::GetInstance(*__pLocalDevice); + pImpl->SetAddress(localAddr); + pImpl->SetName(localName); + pImpl->SetMajorDeviceClassType(BT_COD_MAJ_DEV_CLS_PHONE); + pImpl->SetMinorDeviceClassType(BT_COD_MIN_DEV_CLS_CELLULAR); + pImpl->SetServiceClassList(BT_COD_SVC_UNKNOWN); + pImpl->SetServiceList(BT_SVC_NONE); + } + else + { + r = _BluetoothDeviceImpl::GetInstance(*__pLocalDevice)->SetAddress(localAddr); + if (r == E_SUCCESS) + { + _BluetoothDeviceImpl::GetInstance(*__pLocalDevice)->SetName(localName); + } + else + { + SysLogException(NID_NET_BT, E_SYSTEM, "[E_SYSTEM] A system error occurred."); + SetLastResult(E_SYSTEM); + return null; + } + } + + SetLastResult(E_SUCCESS); + + return __pLocalDevice; +} + +Tizen::Base::String +_BluetoothManagerImpl::GetLocalDeviceAddress(void) const +{ + return __pGapAdapter->GetLocalDeviceAddress(); +} + +Tizen::Base::String +_BluetoothManagerImpl::GetLocalDeviceName(void) const +{ + result r = E_SUCCESS; + String localName; + + // Get the local name from osp-connectivity-service. + r = __pIpcProxy->GetLocalDeviceName(localName); + SysTryLog(NID_NET_BT, r == E_SUCCESS, "Getting the local name through osp-connectivity-service has failed."); + // Ignores other cases + + return localName; +} + +BluetoothDeviceStateType +_BluetoothManagerImpl::GetLocalDeviceState() const +{ + if (__pGapAdapter->IsActivated() == true) + { + if (__pGapAdapter->GetDiscoverableMode() == BT_DISC_MODE_DISCOVERABLE) + { + return BT_DEVICE_STATE_DISCOVERABLE; + } + + return BT_DEVICE_STATE_NOT_DISCOVERABLE; + } + + return BT_DEVICE_STATE_OFF; +} + +int +_BluetoothManagerImpl::GetRemainingTimeAsDiscoverable(void) const +{ + return __pGapAdapter->GetRemainingTimeAsDiscoverable(); +} + +bool +_BluetoothManagerImpl::IsActivated(void) const +{ + return __pGapAdapter->IsActivated(); +} + +BluetoothDiscoverableMode +_BluetoothManagerImpl::GetDiscoverableMode(void) const +{ + return __pGapAdapter->GetDiscoverableMode(); +} + +bool +_BluetoothManagerImpl::IsDiscoveryInProgress(void) const +{ + return __pGapAdapter->IsDiscoveryInProgress(); +} + +result +_BluetoothManagerImpl::SetLocalDeviceName(const Tizen::Base::String& deviceName) +{ + result r = E_SUCCESS; + + SysTryReturn(NID_NET_BT, deviceName.GetLength() > 0, E_INVALID_ARG, E_INVALID_ARG, + "[E_INVALID_ARG] The specified input name is an empty string."); + + // Sets the local name through osp-connectivity-service. + r = __pIpcProxy->SetLocalDeviceName(deviceName); + SysTryReturn(NID_NET_BT, r == E_SUCCESS, r, r, + "[%s] Setting the local device name through osp-connectivity-service has failed.", GetErrorMessage(r)); + + return E_SUCCESS; +} + +result +_BluetoothManagerImpl::SetDiscoverableMode(BluetoothDiscoverableMode mode, int seconds) +{ + result r = E_SUCCESS; + + // Sets the discoverable mode through osp-connectivity-service. + r = __pIpcProxy->SetDiscoverableMode((int)mode, seconds); + SysTryReturnResult(NID_NET_BT, r != E_PRIVILEGE_DENIED, E_PRIVILEGE_DENIED, + "The application does not have the privilege to call this method."); + SysTryReturn(NID_NET_BT, r == E_SUCCESS, r, r, + "[%s] Setting the the discoverable mode through osp-connectivity-service has failed.", GetErrorMessage(r)); + + return E_SUCCESS; +} + +result +_BluetoothManagerImpl::RefreshPairedDeviceList(void) +{ + result r = E_SUCCESS; + IList* pList = null; + BluetoothDevice* pPairedDevice = null; + int numOfElements = 0; + + pList = __pGapAdapter->GetAllPairedDeviceListN(); + + if (pList != null) + { + __pairedDeviceList.RemoveAll(true); + numOfElements = pList->GetCount(); + + for (int i = 0; i < numOfElements; i++) + { + pPairedDevice = (BluetoothDevice*) pList->GetAt(i); + + if (pPairedDevice != null) + { + r = __pairedDeviceList.Add(*pPairedDevice); + + // propagates all kinds of exception as E_SYSTEM + // except E_OUT_OF_MEMORY + r = TransExceptionsExclusive(r, E_SYSTEM, E_OUT_OF_MEMORY); + } + else + { + r = E_SYSTEM; + } + + if (r != E_SUCCESS) + { + pList->RemoveAll(true); + __pairedDeviceList.RemoveAll(false); + break; + } + } + + delete pList; + } + else + { + r = E_SYSTEM; + } + + if (r != E_SUCCESS) + { + SysLogException(NID_NET_BT, r, "[%s] Internal error occurred on getting all paired device list from system.", GetErrorMessage(r)); + } + + return r; +} + +const BluetoothDevice* +_BluetoothManagerImpl::GetPairedDeviceByAddress(const Tizen::Base::ByteBuffer& deviceAddress) const +{ + const ByteBuffer* pAddress = null; + int numOfElements = 0; + + numOfElements = __pairedDeviceList.GetCount(); + + for (int i = 0; i < numOfElements; i++) + { + BluetoothDevice* pListDevice = (BluetoothDevice*) __pairedDeviceList.GetAt(i); + + if (pListDevice != null) + { + pAddress = pListDevice->GetAddress(); + + if (pAddress->Equals(deviceAddress)) + { + return pListDevice; + } + } + } + + SysLogException(NID_NET_BT, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] No device is matched by the input address."); + SetLastResult(E_OBJ_NOT_FOUND); + + return null; +} + +BluetoothDevice* +_BluetoothManagerImpl::GetPairedDeviceByAddressN(const Tizen::Base::ByteBuffer& deviceAddress) const +{ + BluetoothDevice* pResultDevice = null; + const BluetoothDevice* pListedDevice = null; + result r = E_SUCCESS; + + (const_cast<_BluetoothManagerImpl*>(this))->__pairedDevMapMutex.Acquire(); + + pListedDevice = dynamic_cast(__pairedDeviceMap.GetValue(deviceAddress)); + if (pListedDevice != null) + { + pResultDevice = new (std::nothrow) BluetoothDevice(*pListedDevice); + if (pResultDevice == null) + { + r = GetLastResult(); + } + } + else + { + r = E_OBJ_NOT_FOUND; + } + + (const_cast<_BluetoothManagerImpl*>(this))->__pairedDevMapMutex.Release(); + + if (r != E_SUCCESS) + { + SysLogException(NID_NET_BT, r, "[%s] exception occurred.", GetErrorMessage(r)); + SetLastResult(r); + } + + return pResultDevice; +} + +Tizen::Base::Collection::IList* +_BluetoothManagerImpl::GetPairedDeviceByNameN(const Base::String& deviceName) const +{ + unique_ptr pSearchedList; + BluetoothDevice* pListedDevice = null; + BluetoothDevice* pResultDevice = null; + result r = E_SUCCESS; + + pSearchedList.reset(new (std::nothrow) ArrayList); + + if (pSearchedList != null) + { + // initialize the capacity of the result list + pSearchedList->Construct(2); + (const_cast<_BluetoothManagerImpl*>(this))->__pairedDevMapMutex.Acquire(); + + IMapEnumerator* pMapEnum = __pairedDeviceMap.GetMapEnumeratorN(); + + if (pMapEnum) + { + while (pMapEnum->MoveNext() == E_SUCCESS) + { + pListedDevice = dynamic_cast(pMapEnum->GetValue()); + if (pListedDevice != null) + { + String listedDeviceName = pListedDevice->GetName(); + int indexOf = 0; + + if (listedDeviceName.IndexOf(deviceName, 0, indexOf) == E_SUCCESS) + { + pResultDevice = new (std::nothrow) BluetoothDevice(*pListedDevice); + if (pResultDevice == null) + { + r = GetLastResult(); + break; + } + + // doesn't check the result of Add() method to avoid the versioning issue + (void) pSearchedList->Add(*pResultDevice); + } + } + } + + delete pMapEnum; + } + else + { + r = E_OUT_OF_MEMORY; + } + + (const_cast<_BluetoothManagerImpl*>(this))->__pairedDevMapMutex.Release(); + } + else + { + r = E_OUT_OF_MEMORY; + } + + if ((r == E_SUCCESS) && (pSearchedList->GetCount() <= 0)) + { + r = E_OBJ_NOT_FOUND; + } + + if (r != E_SUCCESS) + { + SysLogException(NID_NET_BT, r, "[%s] exception occurred.", GetErrorMessage(r)); + SetLastResult(r); + return null; + } + + return pSearchedList.release(); +} + +const BluetoothDevice* +_BluetoothManagerImpl::GetPairedDeviceAt(int index) const +{ + BluetoothDevice* pResultDevice = null; + + if ((index >= 0) && (index < __pairedDeviceList.GetCount())) + { + pResultDevice = (BluetoothDevice*) __pairedDeviceList.GetAt(index); + } + + if (pResultDevice == null) + { + SysLogException(NID_NET_BT, E_OBJ_NOT_FOUND, "[E_OBJ_NOT_FOUND] Index is not available."); + SetLastResult(E_OBJ_NOT_FOUND); + } + + return pResultDevice; +} + +const Tizen::Base::Collection::IList* +_BluetoothManagerImpl::GetPairedDeviceList(void) const +{ + return &__pairedDeviceList; +} + +Tizen::Base::Collection::IList* +_BluetoothManagerImpl::GetPairedDeviceListN(void) const +{ + unique_ptr pResultList; + BluetoothDevice* pListedDevice = null; + BluetoothDevice* pResultDevice = null; + result r = E_SUCCESS; + int resultCount = 0; + + pResultList.reset(new (std::nothrow) ArrayList); + + if (pResultList) + { + (const_cast<_BluetoothManagerImpl*>(this))->__pairedDevMapMutex.Acquire(); + + // initialize the capacity of the result list + resultCount = __pairedDeviceMap.GetCount(); + pResultList->Construct(resultCount); + + IMapEnumerator* pMapEnum = __pairedDeviceMap.GetMapEnumeratorN(); + + if (pMapEnum) + { + while (pMapEnum->MoveNext() == E_SUCCESS) + { + pListedDevice = dynamic_cast(pMapEnum->GetValue()); + if (pListedDevice != null) + { + pResultDevice = new (std::nothrow) BluetoothDevice(*pListedDevice); + if (pResultDevice == null) + { + r = GetLastResult(); + break; + } + + // doesn't check the result of Add() method to avoid the versioning issue + (void) pResultList->Add(*pResultDevice); + } + } + + delete pMapEnum; + } + else + { + r = E_OUT_OF_MEMORY; + } + + (const_cast<_BluetoothManagerImpl*>(this))->__pairedDevMapMutex.Release(); + } + else + { + r = E_OUT_OF_MEMORY; + } + + SysTryReturn(NID_NET_BT, r == E_SUCCESS, null, r, "[%s] error occurred.", GetErrorMessage(r)); + + return pResultList.release(); +} + +result +_BluetoothManagerImpl::SetBluetoothDeviceListener(IBluetoothDeviceEventListener* pListener) +{ + result r = E_SUCCESS; + + SysTryReturnResult(NID_NET_BT, __pDevEvtListener != pListener, E_SUCCESS, "the listener instance is already registered."); + + if (__pDevEvtListener != null) + { + // remove the previous IBluetoothDeviceEventListener instance from the _BluetoothDeviceEvent. + r = __pDevEvent->RemoveListener(*__pDevEvtListener); + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_SYSTEM, "Failed to remove the previous IBluetoothDeviceEventListener."); + SysLog(NID_NET_BT, "Removing the previous IBluetoothDeviceEventListener is successful."); + __pDevEvtListener = null; + } + + if (pListener != null) + { + // add the specified new IBluetoothDeviceEventListener instance to the _BluetoothDeviceEvent. + r = __pDevEvent->AddListener(*pListener, true); + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_SYSTEM, "Failed to add the new IBluetoothDeviceEventListener."); + SysLog(NID_NET_BT, "Adding the new IBluetoothDeviceEventListener is successful."); + __pDevEvtListener = pListener; + } + + return r; +} + +result +_BluetoothManagerImpl::SetBluetoothConnectionListener(_IBluetoothConnectionEventListener* pListener) +{ + result r = E_SUCCESS; + + SysTryReturnResult(NID_NET_BT, __pConEvtListener != pListener, E_SUCCESS, "the listener instance is already registered."); + + if (__pConEvtListener != null) + { + // remove the previous IBluetoothDeviceEventListener instance from the _BluetoothDeviceEvent. + r = __pMgrEvent->RemoveListener(*__pConEvtListener); + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_SYSTEM, "Failed to remove the previous _IBluetoothConnectionEventListener."); + SysLog(NID_NET_BT, "Removing the previous _IBluetoothConnectionEventListener is successful."); + __pConEvtListener = null; + } + + if (pListener != null) + { + // add the specified new IBluetoothDeviceEventListener instance to the _BluetoothDeviceEvent. + r = __pMgrEvent->AddListener(*pListener, true); + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_SYSTEM, "Failed to add the new _IBluetoothConnectionEventListener."); + SysLog(NID_NET_BT, "Adding the new _IBluetoothConnectionEventListener is successful."); + __pConEvtListener = pListener; + } + + return r; +} + +result +_BluetoothManagerImpl::StartDiscovery(void) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s]", GetStringOfCurrentState()); + + result r = E_SUCCESS; + + __discoveredDeviceList.RemoveAll(true); + + __stateMutex.Acquire(); + + switch (__currentState) + { + case _BT_MGR_STATE_ACTIVATED: + r = __pGapAdapter->StartDiscovery(); + if (r == E_SUCCESS) + { + __currentState = _BT_MGR_STATE_DISCOVERY_REQUESTED; + } + break; + + case _BT_MGR_STATE_DISCOVERY_REQUESTED: + case _BT_MGR_STATE_ON_DISCOVERY: + case _BT_MGR_STATE_ON_DISCOVERY_BY_SYSTEM: + r = E_IN_PROGRESS; + break; + + default: + r = E_INVALID_OPERATION; + break; + } + + __stateMutex.Release(); + + if (r != E_SUCCESS) + { + SysLogException(NID_NET_BT, r, "[%s] exception occurred on starting the device discovery.", GetErrorMessage(r)); + } + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [result:%s]", GetStringOfCurrentState(), GetErrorMessage(r)); + + return r; +} + +result +_BluetoothManagerImpl::CancelDiscovery(void) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s]", GetStringOfCurrentState()); + + result r = E_SUCCESS; + + __stateMutex.Acquire(); + + switch (__currentState) + { + case _BT_MGR_STATE_DISCOVERY_REQUESTED: + case _BT_MGR_STATE_ON_DISCOVERY: + r = __pGapAdapter->CancelDiscovery(); + if (r == E_SUCCESS) + { + __currentState = _BT_MGR_STATE_DISCOVERY_CANCELING; + } + break; + + case _BT_MGR_STATE_DISCOVERY_CANCELING: + r = E_IN_PROGRESS; + break; + + default: + r = E_INVALID_OPERATION; + break; + } + + __stateMutex.Release(); + + if (r != E_SUCCESS) + { + SysLogException(NID_NET_BT, r, "[%s] exception occurred on canceling the device discovery.", GetErrorMessage(r)); + } + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [result:%s]", GetStringOfCurrentState(), GetErrorMessage(r)); + + return r; +} + +result +_BluetoothManagerImpl::RetrieveServiceList(const BluetoothDevice& pairedDevice) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s]", GetStringOfCurrentState()); + + result r = E_SUCCESS; + const ByteBuffer* pKeyAddress = null; + BluetoothDevice* pListedDevice = null; + + __stateMutex.Acquire(); + + switch (__currentState) + { + case _BT_MGR_STATE_ACTIVATED: + // check paredDevice really exists in the paired device list + pKeyAddress = pairedDevice.GetAddress(); + + __pairedDevMapMutex.Acquire(); + + // TODO: move to the following logic to _BluetoothSystemAdapter::IsPaired() + pListedDevice = (BluetoothDevice*) __pairedDeviceMap.GetValue(*pKeyAddress); + if (pListedDevice) + { + r = __pGapAdapter->RetrieveServiceList(*pKeyAddress); + } + else + { + r = E_NOT_PAIRED; + } + + __pairedDevMapMutex.Release(); + + if (r == E_SUCCESS) + { + __currentState = _BT_MGR_STATE_SERVICE_RETRIEVING; + } + break; + + case _BT_MGR_STATE_SERVICE_RETRIEVING: + r = E_IN_PROGRESS; + break; + + default: + r = E_INVALID_OPERATION; + break; + } + + __stateMutex.Release(); + + if (r != E_SUCCESS) + { + SysLogException(NID_NET_BT, r, "[%s] exception occurred on retrieving the service list from the remote device.", GetErrorMessage(r)); + } + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [result:%s]", GetStringOfCurrentState(), GetErrorMessage(r)); + + return r; +} + +result +_BluetoothManagerImpl::Pair(const BluetoothDevice& remoteDevice) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s], [PairingState:%s]", GetStringOfCurrentState(), GetStringOfPairingState()); + + result r = E_SUCCESS; + const ByteBuffer* pAddress = null; + + __stateMutex.Acquire(); + + switch (__currentState) + { + case _BT_MGR_STATE_ACTIVATED: + case _BT_MGR_STATE_DISCOVERY_REQUESTED: + case _BT_MGR_STATE_ON_DISCOVERY: + case _BT_MGR_STATE_DISCOVERY_CANCELING: + case _BT_MGR_STATE_ON_DISCOVERY_BY_SYSTEM: + case _BT_MGR_STATE_SERVICE_RETRIEVING: + if (__pairingState == _BT_PAIRING_STATE_NONE) + { + pAddress = remoteDevice.GetAddress(); + r = __pGapAdapter->Pair(*pAddress); + if (r == E_SUCCESS) + { + // copy the address of the pairing device to the local variable + __pairingTargetAddress.SetArray(pAddress->GetPointer(), 0, _BT_ADDRESS_LENGTH); + __pairingTargetAddress.SetPosition(0); + + __pairingState = _BT_PAIRING_STATE_PAIRING; + } + } + else + { + r = E_DEVICE_BUSY; + } + break; + + default: + r = E_INVALID_OPERATION; + break; + } + + __stateMutex.Release(); + + if (r != E_SUCCESS) + { + SysLogException(NID_NET_BT, r, "[%s] exception occurred on pairing with the remote device.", GetErrorMessage(r)); + } + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [PairingState:%s], [result:%s]", GetStringOfCurrentState(), + GetStringOfPairingState(), GetErrorMessage(r)); + + return r; +} + +result +_BluetoothManagerImpl::CancelPair(void) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s], [PairingState:%s]", GetStringOfCurrentState(), GetStringOfPairingState()); + + result r = E_SUCCESS; + + __stateMutex.Acquire(); + + switch (__currentState) + { + case _BT_MGR_STATE_ACTIVATED: + case _BT_MGR_STATE_DISCOVERY_REQUESTED: + case _BT_MGR_STATE_ON_DISCOVERY: + case _BT_MGR_STATE_DISCOVERY_CANCELING: + case _BT_MGR_STATE_ON_DISCOVERY_BY_SYSTEM: + case _BT_MGR_STATE_SERVICE_RETRIEVING: + if (__pairingState == _BT_PAIRING_STATE_PAIRING) + { + r = __pGapAdapter->CancelPair(); + if (r == E_SUCCESS) + { + __pairingState = _BT_PAIRING_STATE_CANCELING; + } + } + else if (__pairingState == _BT_PAIRING_STATE_CANCELING) + { + r = E_IN_PROGRESS; + } + else + { + r = E_INVALID_OPERATION; + } + break; + + default: + r = E_INVALID_OPERATION; + break; + } + + __stateMutex.Release(); + + if (r != E_SUCCESS) + { + SysLogException(NID_NET_BT, r, "[%s] exception occurred on canceling the pairing process.", GetErrorMessage(r)); + } + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [PairingState:%s], [result:%s]", GetStringOfCurrentState(), + GetStringOfPairingState(), GetErrorMessage(r)); + + return r; +} + +result +_BluetoothManagerImpl::Unpair(const BluetoothDevice& pairedDevice) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s], [PairingState:%s]", GetStringOfCurrentState(), GetStringOfPairingState()); + + result r = E_SUCCESS; + const ByteBuffer* pKeyAddress = null; + BluetoothDevice* pListedDevice = null; + + __stateMutex.Acquire(); + + switch (__currentState) + { + case _BT_MGR_STATE_ACTIVATED: + case _BT_MGR_STATE_DISCOVERY_REQUESTED: + case _BT_MGR_STATE_ON_DISCOVERY: + case _BT_MGR_STATE_DISCOVERY_CANCELING: + case _BT_MGR_STATE_ON_DISCOVERY_BY_SYSTEM: + case _BT_MGR_STATE_SERVICE_RETRIEVING: + // check paredDevice really exists in the paired device list + pKeyAddress = pairedDevice.GetAddress(); + + __pairedDevMapMutex.Acquire(); + + // TODO: move to the following logic to _BluetoothSystemAdapter::IsPaired() + pListedDevice = (BluetoothDevice*) __pairedDeviceMap.GetValue(*pKeyAddress); + if (pListedDevice) + { + r = __pGapAdapter->Unpair(*pKeyAddress); + } + else + { + r = E_NOT_PAIRED; + } + + __pairedDevMapMutex.Release(); + + break; + + default: + r = E_INVALID_OPERATION; + break; + } + + __stateMutex.Release(); + + if (r != E_SUCCESS) + { + SysLogException(NID_NET_BT, r, "[%s] exception occurred on unpairing with the remote device.", GetErrorMessage(r)); + } + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [PairingState:%s], [result:%s]", GetStringOfCurrentState(), + GetStringOfPairingState(), GetErrorMessage(r)); + + return r; +} + +void +_BluetoothManagerImpl::OnBluetoothActivated(result r) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s], [result:%s]", GetStringOfCurrentState(), GetErrorMessage(r)); + + bool isFired = false; + result resRefresh = E_SUCCESS; + + __stateMutex.Acquire(); + + switch (__currentState) + { + case _BT_MGR_STATE_DEACTIVATED: + if (r == E_SUCCESS) + { + __currentState = _BT_MGR_STATE_ACTIVATED; + isFired = true; + } + break; + + case _BT_MGR_STATE_ACTIVATING: + if (r == E_SUCCESS) + { + __currentState = _BT_MGR_STATE_ACTIVATED; + } + else + { + __currentState = _BT_MGR_STATE_DEACTIVATED; + } + isFired = true; + break; + + default: + // ignore other cases + break; + } + + __stateMutex.Release(); + + // refresh the paired device list + resRefresh = RefreshPairedDeviceList(); + SysLog(NID_NET_BT, "Refreshing the paired device list %s.", (resRefresh == E_SUCCESS) ? "is successful" : "fails"); + + // refresh the paired device map which is used since 2.0 + resRefresh = RefreshPairedDeviceMap(); + SysLog(NID_NET_BT, "Refreshing the paired device map %s.", (resRefresh == E_SUCCESS) ? "is successful" : "fails"); + + if (isFired) + { + _BluetoothManagerEventArg* pArg = new (std::nothrow) _BluetoothManagerEventArg(_BT_MANAGER_EVENT_ACTIVATED, r); + if (pArg == null) + { + SysLogException(NID_NET_BT, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient."); + isFired = false; + } + else + { + __pMgrEvent->FireAsync(*pArg); + } + } + + if ((isFired) && (r != E_SUCCESS)) + { + SysLogException(NID_NET_BT, r, "[%s] exception occurred in Bluetooth activation callback.", GetErrorMessage(r)); + } + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [ACTIVATED_Event:%s]", + GetStringOfCurrentState(), isFired ? "Fired" : "NotFired"); +} + +void +_BluetoothManagerImpl::OnBluetoothDeactivated(result r) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s], [result:%s]", GetStringOfCurrentState(), GetErrorMessage(r)); + + bool isFired = false; + + __stateMutex.Acquire(); + + switch (__currentState) + { + case _BT_MGR_STATE_ACTIVATED: + case _BT_MGR_STATE_DISCOVERY_REQUESTED: + case _BT_MGR_STATE_ON_DISCOVERY: + case _BT_MGR_STATE_DISCOVERY_CANCELING: + case _BT_MGR_STATE_ON_DISCOVERY_BY_SYSTEM: + case _BT_MGR_STATE_SERVICE_RETRIEVING: + if (r == E_SUCCESS) + { + __currentState = _BT_MGR_STATE_DEACTIVATED; + isFired = true; + } + break; + + case _BT_MGR_STATE_DEACTIVATING: + if (r == E_SUCCESS) + { + __currentState = _BT_MGR_STATE_DEACTIVATED; + } + else + { + __currentState = _BT_MGR_STATE_ACTIVATED; + } + isFired = true; + break; + + default: + // ignore other cases + break; + } + + __stateMutex.Release(); + + if (isFired) + { + _BluetoothManagerEventArg* pArg = new (std::nothrow) _BluetoothManagerEventArg(_BT_MANAGER_EVENT_DEACTIVATED, r); + if (pArg == null) + { + SysLogException(NID_NET_BT, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient."); + isFired = false; + } + else + { + __pMgrEvent->FireAsync(*pArg); + } + } + + if ((isFired) && (r != E_SUCCESS)) + { + SysLogException(NID_NET_BT, r, "[%s] exception occurred in Bluetooth deactivation callback.", GetErrorMessage(r)); + } + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [ACTIVATED_Event:%s]", + GetStringOfCurrentState(), isFired ? "Fired" : "NotFired"); +} + +void +_BluetoothManagerImpl::OnBluetoothDiscoverableModeChanged(BluetoothDiscoverableMode mode) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s]", GetStringOfCurrentState()); + + bool isFired = false; + + _BluetoothManagerEventArg* pArg = new (std::nothrow) _BluetoothManagerEventArg(mode); + if (pArg == null) + { + SysLogException(NID_NET_BT, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient."); + } + else + { + __pMgrEvent->FireAsync(*pArg); + isFired = true; + } + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [VISIBILITY_Event:%s]", + GetStringOfCurrentState(), isFired ? "Fired" : "NotFired"); +} + +void +_BluetoothManagerImpl::OnBluetoothDiscoveryStarted(result r) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s], [result:%s]", GetStringOfCurrentState(), GetErrorMessage(r)); + + bool isFired = false; + + __stateMutex.Acquire(); + + switch (__currentState) + { + case _BT_MGR_STATE_ACTIVATED: + if (r == E_SUCCESS) + { + __currentState = _BT_MGR_STATE_ON_DISCOVERY_BY_SYSTEM; + } + break; + + case _BT_MGR_STATE_DISCOVERY_REQUESTED: + if (r == E_SUCCESS) + { + __currentState = _BT_MGR_STATE_ON_DISCOVERY; + } + else + { + __currentState = _BT_MGR_STATE_ACTIVATED; + } + + isFired = true; + break; + + case _BT_MGR_STATE_DISCOVERY_CANCELING: + if (r == E_SUCCESS) + { + // the current status is not changed while firing + isFired = true; + } + break; + + default: + // ignore other cases + break; + } + + __stateMutex.Release(); + + if (isFired) + { + _BluetoothDeviceEventArg* pArg = new (std::nothrow) _BluetoothDeviceEventArg(r); + if (pArg == null) + { + SysLogException(NID_NET_BT, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient."); + isFired = false; + } + else + { + __pDevEvent->FireAsync(*pArg); + } + + if (r != E_SUCCESS) + { + SysLogException(NID_NET_BT, r, "[%s] exception occurred in the discovery discovery callback.", GetErrorMessage(r)); + } + } + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [DISCOVERY_STARTED_Event:%s]", + GetStringOfCurrentState(), isFired ? "Fired" : "NotFired"); +} + +void +_BluetoothManagerImpl::OnBluetoothRemoteDeviceFound(const BluetoothDevice& foundDevice) +{ + bool isFired = false; + unique_ptr pFoundDeviceAddress; + _BluetoothDeviceEventArg* pArg = null; + + switch (__currentState) + { + case _BT_MGR_STATE_ON_DISCOVERY: + case _BT_MGR_STATE_DISCOVERY_CANCELING: + pFoundDeviceAddress.reset(new (std::nothrow) ByteBuffer()); + if(pFoundDeviceAddress == null) + { + SysLogException(NID_NET_BT, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient."); + break; + } + pFoundDeviceAddress->Construct(*foundDevice.GetAddress()); + + if(__discoveredDeviceList.Contains(*pFoundDeviceAddress.get()) == true) + { + SysLog(NID_NET_BT, "The found device already exist."); + break; + } + + (void) __discoveredDeviceList.Add(*pFoundDeviceAddress.release()); + + pArg = new (std::nothrow) _BluetoothDeviceEventArg(_BT_DEVICE_EVENT_DEVICE_FOUND, + foundDevice); + if (pArg == null) + { + SysLogException(NID_NET_BT, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient."); + } + else + { + __pDevEvent->FireAsync(*pArg); + isFired = true; + } + break; + + default: + // ignore other cases + break; + } + + SysLog(NID_NET_BT, "[CurrentState:%s], [DEVICE_FOUND_Event:%s]", GetStringOfCurrentState(), isFired ? "Fired" : "NotFired"); +} + +void +_BluetoothManagerImpl::OnBluetoothDiscoveryDone(bool isCompleted) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s], [DiscoveryDone:%s]", + GetStringOfCurrentState(), isCompleted ? "Completed" : "NotCompleted"); + + bool isFired = false; + + __stateMutex.Acquire(); + + switch (__currentState) + { + case _BT_MGR_STATE_ON_DISCOVERY: + case _BT_MGR_STATE_DISCOVERY_CANCELING: + __currentState = _BT_MGR_STATE_ACTIVATED; + isFired = true; + break; + + case _BT_MGR_STATE_ON_DISCOVERY_BY_SYSTEM: + __currentState = _BT_MGR_STATE_ACTIVATED; + break; + + default: + // ignore other cases + break; + } + + __stateMutex.Release(); + + if (isFired) + { + _BluetoothDeviceEventArg* pArg = new (std::nothrow) _BluetoothDeviceEventArg(isCompleted); + if (pArg == null) + { + SysLogException(NID_NET_BT, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient."); + isFired = false; + } + else + { + __pDevEvent->FireAsync(*pArg); + } + } + + __discoveredDeviceList.RemoveAll(true); + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [DISCOVERY_DONE_Event:%s]", + GetStringOfCurrentState(), isFired ? "Fired" : "NotFired"); +} + +void +_BluetoothManagerImpl::OnBluetoothServiceListReceived(const Tizen::Base::ByteBuffer& address, unsigned long serviceList, + const Tizen::Base::Collection::IList* pServiceUuidList, result r) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s], [ServiceList:%ld], [result:%s]", + GetStringOfCurrentState(), serviceList, GetErrorMessage(r)); + + bool isFired = false; + BluetoothDevice* pListedDevice = null; + BluetoothDevice* pResultDevice = null; + + __stateMutex.Acquire(); + + switch (__currentState) + { + case _BT_MGR_STATE_SERVICE_RETRIEVING: + __currentState = _BT_MGR_STATE_ACTIVATED; + isFired = true; + break; + + default: + // ignore other cases + break; + } + + __stateMutex.Release(); + + // updates internal information regardless of the current status if r is E_SUCCESS + __pairedDevMapMutex.Acquire(); + + pListedDevice = (BluetoothDevice*) __pairedDeviceMap.GetValue(address); + + if (pListedDevice != null) + { + if ((r == E_SUCCESS) && (pServiceUuidList != null)) + { + _BluetoothDeviceImpl* pDevImpl = _BluetoothDeviceImpl::GetInstance(*pListedDevice); + pDevImpl->SetServiceList(serviceList); + pDevImpl->SetServiceUuidList(pServiceUuidList, true); + } + + if (isFired == true) + { + // target device instance should be copied + // because the original instance in the list is able to be removed out of the mutex span. + pResultDevice = new (std::nothrow) BluetoothDevice(*pListedDevice); + if (pResultDevice == null) + { + r = E_SYSTEM; + } + } + } + else + { + r = E_SYSTEM; + } + + __pairedDevMapMutex.Release(); + + if (r != E_SUCCESS) + { + serviceList = 0; + SysLogException(NID_NET_BT, r, "[%s] exception occurred in the service list reception callback.", GetErrorMessage(r)); + } + + if (isFired) + { + _BluetoothDeviceEventArg* pArg = null; + if (pResultDevice == null) + { + // It is almost impossible for this case to occur. + // The only case is that the paired device is unpaired and removed from the paired list + // during the service discovery. + // So, the below code is just to prevent system fault at some undefined exceptional cases. + BluetoothDevice dummyDevice(address, String("Dummy"), BT_COD_MAJ_DEV_CLS_UNCLASSIFIED, + BT_COD_MIN_DEV_CLS_UNCLASSIFIED, 0, 0); + pArg = new (std::nothrow) _BluetoothDeviceEventArg(dummyDevice, serviceList, r); + } + else + { + pArg = new (std::nothrow) _BluetoothDeviceEventArg(*pResultDevice, serviceList, r); + delete pResultDevice; + } + + if (pArg == null) + { + SysLogException(NID_NET_BT, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient."); + isFired = false; + } + else + { + __pDevEvent->FireAsync(*pArg); + } + } + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [result:%s], [SERVICELIST_RECEIVED_Event:%s]", + GetStringOfCurrentState(), GetErrorMessage(r), isFired ? "Fired" : "NotFired"); +} + +void +_BluetoothManagerImpl::OnBluetoothPaired(const BluetoothDevice* pPairedDevice, result r) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s], [PairingState:%s], [result:%s]", + GetStringOfCurrentState(), GetStringOfPairingState(), GetErrorMessage(r)); + + result res = E_SUCCESS; + bool isFired = false; + const ByteBuffer* pKeyAddress = null; + BluetoothDevice* pListedDevice = null; + ByteBuffer* pCloneAddress = null; + BluetoothDevice* pCloneDevice = null; + _BluetoothDeviceEventArg* pArg = null; + + pKeyAddress = pPairedDevice->GetAddress(); + + // update the paired list regardless whether the pairing operation is issued by this instance or not + // when the pairing process is finished successfully. + if (r == E_SUCCESS) + { + __pairedDevMapMutex.Acquire(); + + pListedDevice = dynamic_cast (__pairedDeviceMap.GetValue(*pKeyAddress)); + res = GetLastResult(); + + // insert the clone instance of the paired device into the paired device list + if ((pListedDevice == null) && (res == E_OBJ_NOT_FOUND)) + { + pCloneAddress = new (std::nothrow) ByteBuffer(); + if (pCloneAddress) + { + pCloneAddress->Construct(*pKeyAddress); + pCloneDevice = new (std::nothrow) BluetoothDevice(*pPairedDevice); + if (pCloneDevice) + { + r = __pairedDeviceMap.Add(*pCloneAddress, *pCloneDevice); + // TODO: the following statement should be replaced by the special MACRO function. + r = (r == E_SUCCESS) ? E_SUCCESS : E_OPERATION_FAILED; + } + else + { + delete pCloneAddress; + r = E_OUT_OF_MEMORY; + } + } + else + { + r = E_OUT_OF_MEMORY; + } + } + // If the device is already contained in the paired list, the BluetoothDevice instance is updated. + else if (pListedDevice != null) + { + *pListedDevice = *pPairedDevice; + } + + __pairedDevMapMutex.Release(); + } + + // send event if the pairing process is finished successfully. + if (r == E_SUCCESS) + { + __pairingState = _BT_PAIRING_STATE_NONE; + pArg = new (std::nothrow) _BluetoothDeviceEventArg(pPairedDevice, E_SUCCESS); + SysTryReturnVoidResult(NID_NET_BT, pArg != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient." ); + isFired = true; + } + // send event if the pairing operation is issued by this instance although the pairing process fails. + else if ((__pairingState != _BT_PAIRING_STATE_NONE) && (pPairedDevice->GetAddress()->Equals(__pairingTargetAddress))) + { + SysLogException(NID_NET_BT, r, "[%s] exception occurred in the paired callback.", GetErrorMessage(r)); + __pairingState = _BT_PAIRING_STATE_NONE; + pArg = new (std::nothrow) _BluetoothDeviceEventArg(null, r); + SysTryReturnVoidResult(NID_NET_BT, pArg != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient." ); + isFired = true; + } + + if (isFired == true) + { + __pDevEvent->FireAsync(*pArg); + } + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [PairingState:%s], [PAIRED_Event:%s]", + GetStringOfCurrentState(), GetStringOfPairingState(), isFired ? "Fired" : "NotFired"); +} + +void +_BluetoothManagerImpl::OnBluetoothUnpaired(const Tizen::Base::ByteBuffer& address) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s], [PairingState:%s]", GetStringOfCurrentState(), GetStringOfPairingState()); + + result r = E_SUCCESS; + bool isFired = false; + BluetoothDevice* pListedDevice = null; + BluetoothDevice* pResultDevice = null; + + __pairedDevMapMutex.Acquire(); + + pListedDevice = (BluetoothDevice*) __pairedDeviceMap.GetValue(address); + if (pListedDevice != null) + { + // target device instance should be copied + // because the original instance in the list will be removed from the list and deleted below. + pResultDevice = new (std::nothrow) BluetoothDevice(*pListedDevice); + if (pResultDevice != null) + { + isFired = true; + } + + // Removes the unpaired device from the paired device list regardless whether the listener exists or not. + (void) __pairedDeviceMap.Remove(address, true); + } + else + { + r = GetLastResult(); + } + + __pairedDevMapMutex.Release(); + + if (isFired) + { + _BluetoothDeviceEventArg* pArg = new (std::nothrow) _BluetoothDeviceEventArg(_BT_DEVICE_EVENT_UNPAIRED, *pResultDevice); + if (pArg == null) + { + SysLogException(NID_NET_BT, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient."); + isFired = false; + } + else + { + __pDevEvent->FireAsync(*pArg); + } + } + + delete pResultDevice; + + if (r != E_SUCCESS) + { + SysLogException(NID_NET_BT, r, "[%s] exception occurred in the unpaired callback.", GetErrorMessage(r)); + } + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [PairingState:%s], [UNPAIRED_Event:%s]", + GetStringOfCurrentState(), GetStringOfPairingState(), isFired ? "Fired" : "NotFired"); +} + +void +_BluetoothManagerImpl::OnBluetoothDeviceConnected(const Tizen::Base::ByteBuffer& address) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s]", GetStringOfCurrentState()); + + bool isFired = false; + + _BluetoothConnectionEventArg* pArg = new (std::nothrow) _BluetoothConnectionEventArg(_BT_CONNECTION_EVENT_CONNECTED, address); + if (pArg == null) + { + SysLogException(NID_NET_BT, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient."); + } + else + { + __pConEvent->FireAsync(*pArg); + isFired = true; + } + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [CONNECTED_Event:%s]", + GetStringOfCurrentState(), isFired ? "Fired" : "NotFired"); +} + +void +_BluetoothManagerImpl::OnBluetoothDeviceDisconnected(const Tizen::Base::ByteBuffer& address) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s]", GetStringOfCurrentState()); + + bool isFired = false; + + _BluetoothConnectionEventArg* pArg = new (std::nothrow) _BluetoothConnectionEventArg(_BT_CONNECTION_EVENT_DISCONNECTED, address); + if (pArg == null) + { + SysLogException(NID_NET_BT, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient."); + } + else + { + __pConEvent->FireAsync(*pArg); + isFired = true; + } + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [DISCONNECTED_Event:%s]", + GetStringOfCurrentState(), isFired ? "Fired" : "NotFired"); +} + +result +_BluetoothManagerImpl::RefreshPairedDeviceMap(void) +{ + result r = E_SUCCESS; + BluetoothDevice* pPairedDevice = null; + ByteBuffer* pKeyAddress = null; + IList* pList = null; + + pList = __pGapAdapter->GetAllPairedDeviceListN(); + SysTryReturn(NID_NET_BT, pList != null, E_SYSTEM, E_SYSTEM, + "[E_SYSTEM] Internal error occurred on getting all paired device list from system."); + + __pairedDevMapMutex.Acquire(); + + // remove all BluetoothDevice instance which the paired device map contains + __pairedDeviceMap.RemoveAll(true); + + for (int i = 0; i < pList->GetCount(); i++) + { + pPairedDevice = (BluetoothDevice*) pList->GetAt(i); + + pKeyAddress = new (std::nothrow) ByteBuffer(); + + if (pKeyAddress) + { + pKeyAddress->Construct(*(pPairedDevice->GetAddress())); + + r = __pairedDeviceMap.Add(*pKeyAddress, *pPairedDevice); + if (r != E_SUCCESS) + { + // determines the exception type to be passed to the application. + // propagates only E_OUT_OF_MEMORY exception. + if (r != E_OUT_OF_MEMORY) + { + r = E_SYSTEM; + } + + delete pKeyAddress; + break; + } + } + else + { + r = E_OUT_OF_MEMORY; + break; + } + } + + if (r != E_SUCCESS) + { + SysLogException(NID_NET_BT, r, "[%s] Internal error occurred on getting all paired device list from system.", GetErrorMessage(r)); + __pairedDeviceMap.RemoveAll(true); + } + + __pairedDevMapMutex.Release(); + + delete pList; + + return r; +} + +const char* +_BluetoothManagerImpl::GetStringOfCurrentState(void) const +{ + const char* pStateString = null; + + switch (__currentState) + { + case _BT_MGR_STATE_DEACTIVATED: + pStateString = "DEACTIVATED"; + break; + + case _BT_MGR_STATE_ACTIVATING: + pStateString = "ACTIVATING"; + break; + + case _BT_MGR_STATE_DEACTIVATING: + pStateString = "DEACTIVATING"; + break; + + case _BT_MGR_STATE_ACTIVATED: + pStateString = "ACTIVATED"; + break; + + case _BT_MGR_STATE_DISCOVERY_REQUESTED: + pStateString = "DISCOVERY_REQUESTED"; + break; + + case _BT_MGR_STATE_ON_DISCOVERY: + pStateString = "ON_DISCOVERY"; + break; + + case _BT_MGR_STATE_DISCOVERY_CANCELING: + pStateString = "DISCOVERY_CANCELING"; + break; + + case _BT_MGR_STATE_ON_DISCOVERY_BY_SYSTEM: + pStateString = "ON_DISCOVERY_BY_SYSTEM"; + break; + + case _BT_MGR_STATE_SERVICE_RETRIEVING: + pStateString = "SERVICE_RETRIEVING"; + break; + + default: + pStateString = "Unknown"; + break; + } + + return pStateString; +} + +const char* +_BluetoothManagerImpl::GetStringOfPairingState(void) const +{ + const char* pStateString = null; + + switch (__pairingState) + { + case _BT_PAIRING_STATE_NONE: + pStateString = "NONE"; + break; + + case _BT_PAIRING_STATE_PAIRING: + pStateString = "PAIRING"; + break; + + case _BT_PAIRING_STATE_CANCELING: + pStateString = "CANCELING"; + break; + + default: + pStateString = "Unknown"; + break; + } + + return pStateString; +} + +_BluetoothManagerImpl* +_BluetoothManagerImpl::GetInstance(BluetoothManager& bluetoothManager) +{ + return bluetoothManager.__pImpl; +} + +const _BluetoothManagerImpl* +_BluetoothManagerImpl::GetInstance(const BluetoothManager& bluetoothManager) +{ + return bluetoothManager.__pImpl; +} + +} } } // Tizen::Net::Bluetooth + + +#ifdef __cplusplus +extern "C" +{ +#endif + +_OSP_EXPORT_ result +_BluetoothManagerImpl_Activate(void) +{ + Tizen::Net::Bluetooth::_BluetoothGapSystemAdapter* pGapAdapter = + Tizen::Net::Bluetooth::_BluetoothGapSystemAdapter::GetInstance(); + SysTryReturnResult(NID_NET_BT, pGapAdapter != null, E_OUT_OF_MEMORY, + "Failed to get an instance of _BluetoothGapSystemAdapter."); + + return pGapAdapter->Activate(); +} + +_OSP_EXPORT_ result +_BluetoothManagerImpl_Deactivate(void) +{ + Tizen::Net::Bluetooth::_BluetoothGapSystemAdapter* pGapAdapter = + Tizen::Net::Bluetooth::_BluetoothGapSystemAdapter::GetInstance(); + SysTryReturnResult(NID_NET_BT, pGapAdapter != null, E_OUT_OF_MEMORY, + "Failed to get an instance of _BluetoothGapSystemAdapter."); + + return pGapAdapter->Deactivate(); +} + +#ifdef __cplusplus +} +#endif + diff --git a/src/FNetBt_BluetoothOppClientEvent.cpp b/src/FNetBt_BluetoothOppClientEvent.cpp new file mode 100644 index 0000000..4aa4c83 --- /dev/null +++ b/src/FNetBt_BluetoothOppClientEvent.cpp @@ -0,0 +1,81 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// @file FNetBt_BluetoothOppClientEvent.cpp +// @brief This is the implementation file for the _BluetoothOppClientEvent class. +// + +#include +#include +#include +#include "FNetBt_BluetoothOppClientEvent.h" +#include "FNetBt_BluetoothOppClientEventArg.h" +#include "FNetBtIBluetoothOppClientEventListener.h" + + +using namespace Tizen::Base; + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +_BluetoothOppClientEvent::_BluetoothOppClientEvent(void) +{ +} + +_BluetoothOppClientEvent::~_BluetoothOppClientEvent(void) +{ +} + +result +_BluetoothOppClientEvent::Construct(void) +{ + return _Event::Initialize(); +} + +void +_BluetoothOppClientEvent::FireImpl(Tizen::Base::Runtime::IEventListener& listener, const Tizen::Base::Runtime::IEventArg& arg) +{ + IBluetoothOppClientEventListener* pListener = dynamic_cast (&listener); + SysTryReturnVoidResult(NID_NET_BT, pListener != null, E_INVALID_ARG, "[E_INVALID_ARG] The listener argument is invalid."); + + const _BluetoothOppClientEventArg* pEventArg = dynamic_cast (&arg); + SysTryReturnVoidResult(NID_NET_BT, pEventArg != null, E_INVALID_ARG, "[E_INVALID_ARG] The event argument is invalid type."); + + _BluetoothOppClientEventType eventType = pEventArg->GetEventType(); + + switch (eventType) + { + case _BT_OPP_CLIENT_EVENT_PUSH_RESPONDED: + SysLog(NID_NET_BT, "Firing Bluetooth OPP Client Event (Type: _BT_OPP_CLIENT_EVENT_PUSH_RESPONDED)"); + pListener->OnOppPushResponded(pEventArg->GetErrorResult()); + break; + + case _BT_OPP_CLIENT_EVENT_TRANSFER_DONE: + SysLog(NID_NET_BT, "Firing Bluetooth OPP Client Event (Type: _BT_OPP_CLIENT_EVENT_TRANSFER_DONE)"); + pListener->OnOppTransferDone(pEventArg->GetFilePath(), pEventArg->GetFileSize(), pEventArg->IsTransferCompleted()); + break; + + case _BT_OPP_CLIENT_EVENT_TRANSFER_PROGRESS: + SysLog(NID_NET_BT, "Firing Bluetooth OPP Client Event (Type: _BT_OPP_CLIENT_EVENT_TRANSFER_PROGRESS)"); + pListener->OnOppTransferInProgress(pEventArg->GetPercent()); + break; + + default: + break; + } +} + +} } } // Tizen::Net::Bluetooth diff --git a/src/FNetBt_BluetoothOppClientEvent.h b/src/FNetBt_BluetoothOppClientEvent.h new file mode 100644 index 0000000..0285569 --- /dev/null +++ b/src/FNetBt_BluetoothOppClientEvent.h @@ -0,0 +1,81 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +/** + * @file FNetBt_BluetoothOppClientEvent.h + * @brief This is the header file for the _BluetoothOppClientEvent class. + * + * This header file contains the declarations of the _BluetoothOppClientEvent class. + * The _BluetoothOppClientEvent class can call a method of a listener (IBluetoothOppClientEventListener object). + * So, when a device event is occurred, listener instances can handle it appropriately. + */ +#ifndef _FNET_BT_INTERNAL_BLUETOOTH_OPP_CLIENT_EVENT_H_ +#define _FNET_BT_INTERNAL_BLUETOOTH_OPP_CLIENT_EVENT_H_ + +#include +#include +#include + +// Forward declaration +namespace Tizen { namespace Base { namespace Runtime +{ +class IEventListener; +class IEventArg; +} } } + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +// +// @class _BluetoothOppClientEvent +// @brief This class handles Bluetooth OPP Client events. +// +// When a Bluetooth device event occurs, the _BluetoothOppClientEvent object finds a IBluetoothOppClientEventListener +// object and calls an appropriate method of the listener. +// +class _BluetoothOppClientEvent + : public Tizen::Base::Runtime::_Event +{ +public: + _BluetoothOppClientEvent(void); + virtual ~_BluetoothOppClientEvent(void); + + result Construct(void); + +protected: + /** + * Checks the argument and finds out the type of event. After that, this method calls appropriate pListener's method. + * + * @return A result code. + * @param[in] pListener An event listener related to this Bluetooth OPP Client event. + * @param[in] arg An event argument including information to be passed to the event listeners + * @exception E_SUCCESS The method is successful. + * @exception E_INVALID_ARG The argument passed to a method contains invalid values. + * @exception E_SYSTEM A system error occurred. + */ + virtual void FireImpl(Tizen::Base::Runtime::IEventListener& listener, const Tizen::Base::Runtime::IEventArg& arg); + +private: + _BluetoothOppClientEvent(const _BluetoothOppClientEvent& value); + _BluetoothOppClientEvent& operator =(const _BluetoothOppClientEvent& rhs); + +private: + bool __isServerEvent; + +}; // _BluetoothOppClientEvent + +} } } +#endif // _FNET_BT_INTERNAL_BLUETOOTH_OPP_CLIENT_EVENT_H_ diff --git a/src/FNetBt_BluetoothOppClientEventArg.cpp b/src/FNetBt_BluetoothOppClientEventArg.cpp new file mode 100644 index 0000000..8871e8e --- /dev/null +++ b/src/FNetBt_BluetoothOppClientEventArg.cpp @@ -0,0 +1,110 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// @file FNetBt_BluetoothOppClientEventArg.cpp +// @brief This is the implementation file for the _BluetoothOppClientEventArg class. +// + +#include +#include +#include "FNetBt_BluetoothOppClientEventArg.h" + + +using namespace Tizen::Base; + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +// +// This is a class constructor for _BT_OPP_CLIENT_EVENT_PUSH_RESPONDED event. +// +_BluetoothOppClientEventArg::_BluetoothOppClientEventArg(result r) + : __evtType(_BT_OPP_CLIENT_EVENT_PUSH_RESPONDED) + , __result(r) + , __filePath() + , __fileSize(0) + , __isCompleted(true) + , __percent(0) +{ +} + +// +// This is a class constructor for _BT_OPP_CLIENT_EVENT_TRANSFER_DONE event. +// +_BluetoothOppClientEventArg::_BluetoothOppClientEventArg(const Tizen::Base::String& filePath, int fileSize, bool isCompleted) + : __evtType(_BT_OPP_CLIENT_EVENT_TRANSFER_DONE) + , __result(E_SUCCESS) + , __filePath(filePath) + , __fileSize(fileSize) + , __isCompleted(isCompleted) + , __percent(0) +{ +} + +// +// This is a class constructor for _BT_OPP_CLIENT_EVENT_TRANSFER_PROGRESS event. +// +_BluetoothOppClientEventArg::_BluetoothOppClientEventArg(int percent) + : __evtType(_BT_OPP_CLIENT_EVENT_TRANSFER_PROGRESS) + , __result(E_SUCCESS) + , __filePath() + , __fileSize(0) + , __isCompleted(true) + , __percent(percent) +{ +} + +_BluetoothOppClientEventArg::~_BluetoothOppClientEventArg(void) +{ +} + +_BluetoothOppClientEventType +_BluetoothOppClientEventArg::GetEventType(void) const +{ + return __evtType; +} + +result +_BluetoothOppClientEventArg::GetErrorResult(void) const +{ + return __result; +} + +Tizen::Base::String +_BluetoothOppClientEventArg::GetFilePath(void) const +{ + return __filePath; +} + +int +_BluetoothOppClientEventArg::GetFileSize(void) const +{ + return __fileSize; +} + +bool +_BluetoothOppClientEventArg::IsTransferCompleted(void) const +{ + return __isCompleted; +} + +int +_BluetoothOppClientEventArg::GetPercent(void) const +{ + return __percent; +} + +} } } // Tizen::Net::Bluetooth diff --git a/src/FNetBt_BluetoothOppClientEventArg.h b/src/FNetBt_BluetoothOppClientEventArg.h new file mode 100644 index 0000000..22988de --- /dev/null +++ b/src/FNetBt_BluetoothOppClientEventArg.h @@ -0,0 +1,153 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +/** + * @file FNetBt_BluetoothOppClientEventArg.h + * @brief This is the header file for the _BluetoothOppClientEventArg class. + * + * This header file contains the declarations of the _BluetoothOppClientEventArg class which includes information to be + * passed to the event listeners + */ +#ifndef _FNET_BT_INTERNAL_BLUETOOTH_OPP_CLIENT_EVENT_ARG_H_ +#define _FNET_BT_INTERNAL_BLUETOOTH_OPP_CLIENT_EVENT_ARG_H_ + +#include +#include +#include +#include +#include + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +// Forward declaration +class BluetoothDevice; + +/** + * @enum _BluetoothOppClientEventType + * Type for specifying the type of _BluetoothOppClientEvent + */ +enum _BluetoothOppClientEventType +{ + _BT_OPP_CLIENT_EVENT_PUSH_RESPONDED, /**< For notifying the OPP server responded to the push request */ + _BT_OPP_CLIENT_EVENT_TRANSFER_DONE, /**< For notifying the file transfer has finished */ + _BT_OPP_CLIENT_EVENT_TRANSFER_PROGRESS, /**< For notifying the file is being transferred */ +}; + +/** + * @class _BluetoothOppClientEventArg + * @brief This class is used as an argument for callback methods of the _IBluetoothOppClientEventListener class. + * + * When a _BluetoothOppClientEvent occurs, the _BluetoothOppClientEvent finds a _IBluetoothOppClientEventListener instance + * which is registered for the _BluetoothOppClientEvent and calls an appropriate method of the listener. + * @see _IBluetoothOppClientEventListener + */ +class _BluetoothOppClientEventArg + : public Tizen::Base::Object + , public Tizen::Base::Runtime::IEventArg +{ +public: + /** + * This is a class constructor for _BT_OPP_CLIENT_EVENT_PUSH_RESPONDED event. + * + * @param[in] r The result of the event + * @exception E_SUCCESS The connection is established successfully. + * @exception E_SYSTEM The connection fails. + */ + _BluetoothOppClientEventArg(result r); + + /** + * This is a class constructor for _BT_OPP_CLIENT_EVENT_TRANSFER_DONE event. + * + * @param[in] filePath The path of the transferred file + * @param[in] fileSize The size of the transferred file + * @param[in] isCompleted Set to @c true if the transfer is successfully completed, @n + * else @c false + */ + _BluetoothOppClientEventArg(const Tizen::Base::String& filePath, int fileSize, bool isCompleted); + + /** + * This is a class constructor for _BT_OPP_CLIENT_EVENT_TRANSFER_PROGRESS event. + * + * @param[in] percent The progress in percentage ranging from @c 1 to @c 100 percent + */ + _BluetoothOppClientEventArg(int percent); + + /** + * This is the class destructor. + */ + ~_BluetoothOppClientEventArg(void); + + /** + * Gets the type of this event. + * + * @return The type of the event + */ + _BluetoothOppClientEventType GetEventType(void) const; + + /** + * Gets the error result of this event. + * + * @return The result of the event + */ + result GetErrorResult(void) const; + + /** + * Gets the sent file path. + * + * @return The sent file path + */ + Tizen::Base::String GetFilePath(void) const; + + /** + * Gets the sent file size. + * + * @return The sent file size + */ + int GetFileSize(void) const; + + /** + * Is the file transfer completed. + * + * @return @c true if the transfer is successfully completed, @n + * else @c false + */ + bool IsTransferCompleted(void) const; + + /** + * Gets the progress information as a type of percentage. + * + * @return The percentage that represents the progress of file transfer + */ + int GetPercent(void) const; + +private: + _BluetoothOppClientEventArg(void); + _BluetoothOppClientEventArg(const _BluetoothOppClientEventArg& eventArg); + _BluetoothOppClientEventArg& operator =(const _BluetoothOppClientEventArg& rValue); + +private: + _BluetoothOppClientEventType __evtType; + result __result; + Tizen::Base::String __filePath; + int __fileSize; + bool __isCompleted; + int __percent; + +}; // _BluetoothOppClientEventArg + +} } } +#endif // _FNET_BT_INTERNAL_BLUETOOTH_OPP_CLIENT_EVENT_ARG_H_ diff --git a/src/FNetBt_BluetoothOppClientImpl.cpp b/src/FNetBt_BluetoothOppClientImpl.cpp new file mode 100755 index 0000000..7ca3029 --- /dev/null +++ b/src/FNetBt_BluetoothOppClientImpl.cpp @@ -0,0 +1,583 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// @file FNetBtBluetoothOppClientImpl.cpp +// @brief This is the implementation file for the _BluetoothOppClientImpl class. +// + +#include +#include +#include +#include +#include +#include +#include "FNetBt_BluetoothOppClientImpl.h" +#include "FNetBt_BluetoothOppSystemAdapter.h" +#include "FNetBt_BluetoothGapSystemAdapter.h" +#include "FNetBt_BluetoothOppClientEvent.h" +#include "FNetBt_BluetoothOppClientEventArg.h" + +using namespace std; +using namespace Tizen::App; +using namespace Tizen::Base; +using namespace Tizen::Base::Runtime; + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +_BluetoothOppClientImpl::_BluetoothOppClientImpl(void) + : __pGapAdapter(null) + , __pOppAdapter(null) + , __pEvent(null) + , __stateMutex() + , __currentState(_BT_OPP_CLI_STATE_DISABLED) + , __pairingAddress() + , __pushedFilePath() + , __minProgressInterval(__defaultProgressInterval) + , __previousProgress(0) +{ +} + +_BluetoothOppClientImpl::~_BluetoothOppClientImpl(void) +{ + if (__pOppAdapter != null) + { + if ((__currentState == _BT_OPP_CLI_STATE_PUSH_READY) + || (__currentState == _BT_OPP_CLI_STATE_ON_TRANSFER)) + { + (void) CancelPush(); + } + } + + if (__pGapAdapter != null) + { + __pGapAdapter->UnregisterManagerEventListener(*this); + __pGapAdapter->UnregisterDeviceEventListener(*this); + } +} + +result +_BluetoothOppClientImpl::Construct(IBluetoothOppClientEventListener& listener) +{ + result r = E_SUCCESS; + std::unique_ptr<_BluetoothOppClientEvent> pEvent; + + r = __stateMutex.Create(); + SysTryReturn(NID_NET_BT, r == E_SUCCESS, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Failed to create the state mutex."); + + r = __pairingAddress.Construct(_BT_ADDRESS_LENGTH); + SysTryReturn(NID_NET_BT, r == E_SUCCESS, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Failed to construct the address for pairing."); + + __pGapAdapter = _BluetoothGapSystemAdapter::GetInstance(); + SysTryReturn(NID_NET_BT, __pGapAdapter != null, E_SYSTEM, E_SYSTEM, + "[E_SYSTEM] Failed to invoke _BluetoothGapSystemAdapter::GetInstance()."); + + __pOppAdapter = _BluetoothOppSystemAdapter::GetInstance(); + + pEvent.reset(new (std::nothrow) _BluetoothOppClientEvent()); + SysTryReturn(NID_NET_BT, pEvent != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient."); + r = pEvent->Construct(); + SysTryReturn(NID_NET_BT, r == E_SUCCESS, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Failed to construct the event."); + // add the IBluetoothOppClientEventListener instance to a new created _BluetoothOppClientEvent. + r = pEvent->AddListener(listener, true); + SysTryReturn(NID_NET_BT, r == E_SUCCESS, E_SYSTEM, E_SYSTEM, + "[%s] Propagating. Failed to add the application listener for OPP client", GetErrorMessage(r)); + + // registers this callback listener to the system adapter for activation/deactivation event + r = __pGapAdapter->RegisterManagerEventListener(*this, true); + SysTryReturn(NID_NET_BT, r == E_SUCCESS, E_SYSTEM, E_SYSTEM, + "[E_SYSTEM] Failed to register the callback listener to _BluetoothGapSystemAdapter."); + + // registers this callback listener to the system adapter for paired event + r = __pGapAdapter->RegisterDeviceEventListener(*this); + if (r != E_SUCCESS) + { + __pGapAdapter->UnregisterManagerEventListener(*this); + } + SysTryReturn(NID_NET_BT, r == E_SUCCESS, E_SYSTEM, E_SYSTEM, + "[E_SYSTEM] Failed to register the callback listener to _BluetoothGapSystemAdapter."); + + // checks whether the Bluetooth is available + __stateMutex.Acquire(); + + if (__pGapAdapter->IsActivated() == true) + { + __currentState = _BT_OPP_CLI_STATE_IDLE; + } + + __stateMutex.Release(); + + __pEvent = move(pEvent); + + return E_SUCCESS; +} + + +result +_BluetoothOppClientImpl::PushFile(const BluetoothDevice& remoteDevice, const Base::String& filePath) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s]", GetStringOfCurrentState()); + + result r = E_FAILURE; + String physicalPath; + + __stateMutex.Acquire(); + + switch (__currentState) + { + case _BT_OPP_CLI_STATE_DISABLED: + r = E_INVALID_STATE; + break; + + case _BT_OPP_CLI_STATE_IDLE: + if (_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat()) + { + if (Tizen::Io::_FileImpl::ConvertVirtualToPhysicalPath(filePath, physicalPath) != E_SUCCESS) + { + r = E_INACCESSIBLE_PATH; + break; + } + } + else + { + physicalPath = filePath; + } + + if (__pGapAdapter->IsPaired(*(remoteDevice.GetAddress())) == true) + { + r = __pOppAdapter->PushOppFile(*this, *(remoteDevice.GetAddress()), physicalPath); + if (r == E_SUCCESS) + { + __currentState = _BT_OPP_CLI_STATE_PUSH_READY; + } + } + else + { + // start the pairing process + if (__pGapAdapter->Pair(*(remoteDevice.GetAddress())) == E_SUCCESS) + { + // copy the address of the pairing device to the local variable + __pairingAddress.SetArray(remoteDevice.GetAddress()->GetPointer(), 0, _BT_ADDRESS_LENGTH); + __pairingAddress.SetPosition(0); + // copy the file path to the local variable + __pushedFilePath.Clear(); + __pushedFilePath = physicalPath; + + r = E_SUCCESS; + __currentState = _BT_OPP_CLI_STATE_BONDING; + } + else + { + r = E_FAILURE; + } + } + break; + + case _BT_OPP_CLI_STATE_BONDING: + case _BT_OPP_CLI_STATE_PUSH_READY: + case _BT_OPP_CLI_STATE_REQ_CANCELING: //TODO: this state should return E_INVALID_OPERATION. (Versioning) + case _BT_OPP_CLI_STATE_ON_TRANSFER: + case _BT_OPP_CLI_STATE_TRANS_CANCELING: //TODO: this state should return E_INVALID_OPERATION. (Versioning) + r = E_IN_PROGRESS; + break; + + default: + // ignore other cases + break; + } + + __stateMutex.Release(); + + if (r != E_SUCCESS) + { + SysLogException(NID_NET_BT, r, "[%s] exception occurred on pushing a file.", GetErrorMessage(r)); + } + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [ActionResult:%s]", GetStringOfCurrentState(), GetErrorMessage(r)); + + return r; +} + +result +_BluetoothOppClientImpl::CancelPush() +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s]", GetStringOfCurrentState()); + + result r = E_FAILURE; + + __stateMutex.Acquire(); + + switch (__currentState) + { + case _BT_OPP_CLI_STATE_DISABLED: + r = E_INVALID_STATE; + break; + + case _BT_OPP_CLI_STATE_IDLE: + r = E_INVALID_OPERATION; + break; + + case _BT_OPP_CLI_STATE_REQ_CANCELING: + case _BT_OPP_CLI_STATE_TRANS_CANCELING: + r = E_IN_PROGRESS; + break; + + case _BT_OPP_CLI_STATE_BONDING: //TODO: Versioning check + if (__pGapAdapter->CancelPair() == E_SUCCESS) + { + r = E_SUCCESS; + __currentState = _BT_OPP_CLI_STATE_REQ_CANCELING; + } + // It will be changed to IDLE after receiving the OnBluetoothPaired event. + break; + + case _BT_OPP_CLI_STATE_PUSH_READY: + r = __pOppAdapter->CancelOppPush(); + + if (r == E_SUCCESS) + { + __currentState = _BT_OPP_CLI_STATE_REQ_CANCELING; + } + // It will be changed to IDLE after receiving the OnOppTransferDone event. + break; + + case _BT_OPP_CLI_STATE_ON_TRANSFER: + r = __pOppAdapter->CancelOppPush(); + + if (r == E_SUCCESS) + { + __currentState = _BT_OPP_CLI_STATE_TRANS_CANCELING; + } + // It will be changed to IDLE after receiving the OnOppTransferDone event. + break; + + default: + // ignore other cases + break; + } + + __stateMutex.Release(); + + if (r != E_SUCCESS) + { + SysLogException(NID_NET_BT, r, "[%s] exception occurred on canceling the push.", GetErrorMessage(r)); + } + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [ActionResult:%s]", GetStringOfCurrentState(), GetErrorMessage(r)); + + return r; +} + +result +_BluetoothOppClientImpl::SetMinProgressInterval(int percent) +{ + result r = E_SUCCESS; + + if ((percent < 1) || (percent > 100)) + { + r = E_OUT_OF_RANGE; + SysLogException(NID_NET_BT, E_OUT_OF_RANGE, "[E_OUT_OF_RANGE] The input argument - percent - is outside the valid range."); + } + else + { + __minProgressInterval = percent; + } + + return r; +} + +void +_BluetoothOppClientImpl::OnBluetoothActivated(result r) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s], [ActionResult:%s]", GetStringOfCurrentState(), GetErrorMessage(r)); + + __stateMutex.Acquire(); + + if ((__currentState == _BT_OPP_CLI_STATE_DISABLED) + && (r == E_SUCCESS)) + { + __currentState = _BT_OPP_CLI_STATE_IDLE; + } + + __stateMutex.Release(); + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s]", GetStringOfCurrentState()); +} + +void +_BluetoothOppClientImpl::OnBluetoothDeactivated(result r) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s], [ActionResult:%s]", GetStringOfCurrentState(), GetErrorMessage(r)); + + __stateMutex.Acquire(); + + if (r == E_SUCCESS) + { + __currentState = _BT_OPP_CLI_STATE_DISABLED; + } + + __stateMutex.Release(); + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s]", GetStringOfCurrentState()); +} + +void +_BluetoothOppClientImpl::OnOppPushResponded(result r) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s], [ActionResult:%s]", GetStringOfCurrentState(), GetErrorMessage(r)); + + bool isFired = false; + + __stateMutex.Acquire(); + + if ((__currentState == _BT_OPP_CLI_STATE_PUSH_READY) || (__currentState == _BT_OPP_CLI_STATE_REQ_CANCELING)) + { + if (r == E_SUCCESS) + { + __currentState = _BT_OPP_CLI_STATE_ON_TRANSFER; + } + else // including both cases of being canceled by the user and rejected by the remote device + { + __currentState = _BT_OPP_CLI_STATE_IDLE; + SysLogException(NID_NET_BT, r, "[%s] exception occurred on the response of the OPP push request.", GetErrorMessage(r)); + } + + isFired = true; + } + + __stateMutex.Release(); + + if (isFired) + { + _BluetoothOppClientEventArg* pArg = new (std::nothrow) _BluetoothOppClientEventArg(r); + if (pArg == null) + { + SysLogException(NID_NET_BT, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient."); + isFired = false; + } + else + { + __pEvent->FireAsync(*pArg); + } + } + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [PUSH_RESPONDED_Event:%s]", + GetStringOfCurrentState(), isFired ? "Fired" : "NotFired"); +} + +void +_BluetoothOppClientImpl::OnOppTransferInProgress(int percent) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s], [Progress:%d]", GetStringOfCurrentState(), percent); + + bool isFired = false; + + __stateMutex.Acquire(); + + if ((__currentState == _BT_OPP_CLI_STATE_ON_TRANSFER) || (__currentState == _BT_OPP_CLI_STATE_TRANS_CANCELING)) + { + if (((percent - __previousProgress) >= __minProgressInterval) || (percent >= 100)) + { + isFired = true; + __previousProgress = percent; + } + } + + __stateMutex.Release(); + + if (isFired) + { + _BluetoothOppClientEventArg* pArg = new (std::nothrow) _BluetoothOppClientEventArg(percent); + if (pArg == null) + { + SysLogException(NID_NET_BT, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient."); + isFired = false; + } + else + { + __pEvent->FireAsync(*pArg); + } + } + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [TRANSFER_IN_PROGRESS_Event:%s]", + GetStringOfCurrentState(), isFired ? "Fired" : "NotFired"); +} + +void +_BluetoothOppClientImpl::OnOppTransferDone(const Tizen::Base::String& filePath, int fileSize, bool isCompleted) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s], [filePath:%ls], [fileSize:%d], [%s]", + GetStringOfCurrentState(), filePath.GetPointer(), fileSize, isCompleted ? "Completed" : "Incompleted"); + + bool isFired = false; + String pushedFilePath; + result r = E_SUCCESS; + + __stateMutex.Acquire(); + + if ((__currentState == _BT_OPP_CLI_STATE_ON_TRANSFER) || (__currentState == _BT_OPP_CLI_STATE_TRANS_CANCELING)) + { + __currentState = _BT_OPP_CLI_STATE_IDLE; + isFired = true; + __previousProgress = 0; // initialization for the next push transaction + } + + __stateMutex.Release(); + + if (_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat()) + { + r = Tizen::Io::_FileImpl::ConvertPhysicalToVirtualPath(__pushedFilePath, pushedFilePath); + if(r != E_SUCCESS) + { + SysLogException(NID_NET_BT, r, "[%s] exception occurred on converting the file path from physical to virtual.", GetErrorMessage(r)); + pushedFilePath = __pushedFilePath; + } + } + else + { + pushedFilePath = __pushedFilePath; + } + + if (isFired) + { + _BluetoothOppClientEventArg* pArg = new (std::nothrow) _BluetoothOppClientEventArg(pushedFilePath, fileSize, isCompleted); + if (pArg == null) + { + SysLogException(NID_NET_BT, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient."); + isFired = false; + } + else + { + __pEvent->FireAsync(*pArg); + } + } + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [TRANSFER_DONE_Event:%s]", + GetStringOfCurrentState(), isFired ? "Fired" : "NotFired"); +} + +void +_BluetoothOppClientImpl::OnBluetoothPaired(const BluetoothDevice* pPairedDevice, result r) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s], [ActionResult:%s]", GetStringOfCurrentState(), GetErrorMessage(r)); + + bool isFired = false; + result responseResult = E_SYSTEM; + + __stateMutex.Acquire(); + + if (pPairedDevice->GetAddress()->Equals(__pairingAddress)) + { + if (__currentState == _BT_OPP_CLI_STATE_BONDING) + { + if (r == E_SUCCESS) + { + if (__pOppAdapter->PushOppFile(*this, __pairingAddress, __pushedFilePath) == E_SUCCESS) + { + __currentState = _BT_OPP_CLI_STATE_PUSH_READY; + } + else + { + // callback responded with E_SYSTEM + isFired = true; + __currentState = _BT_OPP_CLI_STATE_IDLE; + responseResult = E_SYSTEM; + } + } + else + { + // callback responded with r + isFired = true; + __currentState = _BT_OPP_CLI_STATE_IDLE; + responseResult = r; + } + + __pairingAddress.Clear(); + } + else if (__currentState == _BT_OPP_CLI_STATE_REQ_CANCELING) + { + // callback responded with E_SYSTEM or E_OPERATION_CANCELED + isFired = true; + __currentState = _BT_OPP_CLI_STATE_IDLE; + responseResult = E_SYSTEM; + } + } + // ignored otherwise + + __stateMutex.Release(); + + if (isFired) + { + _BluetoothOppClientEventArg* pArg = new (std::nothrow) _BluetoothOppClientEventArg(responseResult); + if (pArg == null) + { + SysLogException(NID_NET_BT, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient."); + isFired = false; + } + else + { + __pEvent->FireAsync(*pArg); + } + } + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [PUSH_RESPONDED_Event:%s]", + GetStringOfCurrentState(), isFired ? "Fired" : "NotFired"); +} + +const char* +_BluetoothOppClientImpl::GetStringOfCurrentState(void) const +{ + const char* pStateString = null; + + switch (__currentState) + { + case _BT_OPP_CLI_STATE_DISABLED: + pStateString = "DISABLED"; + break; + + case _BT_OPP_CLI_STATE_IDLE: + pStateString = "IDLE"; + break; + + case _BT_OPP_CLI_STATE_BONDING: + pStateString = "BONDING"; + break; + + case _BT_OPP_CLI_STATE_PUSH_READY: + pStateString = "PUSH_READY"; + break; + + case _BT_OPP_CLI_STATE_REQ_CANCELING: + pStateString = "REQ_CANCELING"; + break; + + case _BT_OPP_CLI_STATE_ON_TRANSFER: + pStateString = "ON_TRANSFER"; + break; + + case _BT_OPP_CLI_STATE_TRANS_CANCELING: + pStateString = "TRANS_CANCELING"; + break; + + default: + pStateString = "Unknown"; + break; + } + + return pStateString; +} + +} } } // Tizen::Net::Bluetooth diff --git a/src/FNetBt_BluetoothOppServerEvent.cpp b/src/FNetBt_BluetoothOppServerEvent.cpp new file mode 100644 index 0000000..0d51dac --- /dev/null +++ b/src/FNetBt_BluetoothOppServerEvent.cpp @@ -0,0 +1,87 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// @file FNetBt_BluetoothOppServerEvent.cpp +// @brief This is the implementation file for the _BluetoothOppServerEvent class. +// + +#include +#include +#include +#include "FNetBt_BluetoothOppServerEvent.h" +#include "FNetBt_BluetoothOppServerEventArg.h" +#include "FNetBtIBluetoothOppServerEventListener.h" + + +using namespace Tizen::Base; + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +_BluetoothOppServerEvent::_BluetoothOppServerEvent(void) +{ +} + +_BluetoothOppServerEvent::~_BluetoothOppServerEvent(void) +{ +} + +result +_BluetoothOppServerEvent::Construct(void) +{ + return _Event::Initialize(); +} + +void +_BluetoothOppServerEvent::FireImpl(Tizen::Base::Runtime::IEventListener& listener, const Tizen::Base::Runtime::IEventArg& arg) +{ + const BluetoothDevice* pDevice = null; + + IBluetoothOppServerEventListener* pListener = dynamic_cast (&listener); + SysTryReturnVoidResult(NID_NET_BT, pListener != null, E_INVALID_ARG, "[E_INVALID_ARG] The listener argument is invalid."); + + const _BluetoothOppServerEventArg* pEventArg = dynamic_cast (&arg); + SysTryReturnVoidResult(NID_NET_BT, pEventArg != null, E_INVALID_ARG, "[E_INVALID_ARG] The event argument is invalid type."); + + _BluetoothOppServerEventType eventType = pEventArg->GetEventType(); + + switch (eventType) + { + case _BT_OPP_SERVER_EVENT_PUSH_REQUESTED: + pDevice = pEventArg->GetRequester(); + if (pDevice != null) + { + SysLog(NID_NET_BT, "Firing Bluetooth OPP Server Event (Type: _BT_OPP_SERVER_EVENT_PUSH_REQUESTED)"); + pListener->OnOppPushRequested(*pDevice); + } + break; + + case _BT_OPP_SERVER_EVENT_TRANSFER_DONE: + SysLog(NID_NET_BT, "Firing Bluetooth OPP Server Event (Type: _BT_OPP_SERVER_EVENT_TRANSFER_DONE)"); + pListener->OnOppTransferDone(pEventArg->GetFileName(), pEventArg->GetFileSize(), pEventArg->IsTransferCompleted()); + break; + + case _BT_OPP_SERVER_EVENT_TRANSFER_PROGRESS: + SysLog(NID_NET_BT, "Firing Bluetooth OPP Server Event (Type: _BT_OPP_SERVER_EVENT_TRANSFER_PROGRESS)"); + pListener->OnOppTransferInProgress(pEventArg->GetPercent()); + break; + + default: + break; + } +} + +} } } // Tizen::Net::Bluetooth diff --git a/src/FNetBt_BluetoothOppServerEvent.h b/src/FNetBt_BluetoothOppServerEvent.h new file mode 100644 index 0000000..df6cd3b --- /dev/null +++ b/src/FNetBt_BluetoothOppServerEvent.h @@ -0,0 +1,78 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +/** + * @file FNetBt_BluetoothOppServerEvent.h + * @brief This is the header file for the _BluetoothOppServerEvent class. + * + * This header file contains the declarations of the _BluetoothOppServerEvent class. + * The _BluetoothOppServerEvent class can call a method of a listener (_IBluetoothOppServerEventListener object). + * So, when a device event is occurred, listener instances can handle it appropriately. + */ +#ifndef _FNET_BT_INTERNAL_BLUETOOTH_OPP_SERVER_EVENT_H_ +#define _FNET_BT_INTERNAL_BLUETOOTH_OPP_SERVER_EVENT_H_ + +#include +#include +#include + +// Forward declaration +namespace Tizen { namespace Base { namespace Runtime +{ +class IEventListener; +class IEventArg; +} } } + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +// +// @class _BluetoothOppServerEvent +// @brief This class handles Bluetooth OPP Server events. +// +// When a Bluetooth device event occurs, the _BluetoothOppServerEvent object finds a _IBluetoothOppServerEventListener object +// and calls an appropriate method of the listener. +// +class _BluetoothOppServerEvent + : public Tizen::Base::Runtime::_Event +{ +public: + _BluetoothOppServerEvent(void); + virtual ~_BluetoothOppServerEvent(void); + + result Construct(void); + +protected: + /** + * Checks the argument and finds out the type of event. After that, this method calls appropriate pListener's method. + * + * @return A result code. + * @param[in] pListener An event listener related to this Bluetooth SPP Acceptor event. + * @param[in] arg An event argument including information to be passed to the event listeners + * @exception E_SUCCESS The method is successful. + * @exception E_INVALID_ARG The argument passed to a method contains invalid values. + * @exception E_SYSTEM A system error occurred. + */ + virtual void FireImpl(Tizen::Base::Runtime::IEventListener& listener, const Tizen::Base::Runtime::IEventArg& arg); + +private: + _BluetoothOppServerEvent(const _BluetoothOppServerEvent& value); + _BluetoothOppServerEvent& operator =(const _BluetoothOppServerEvent& rhs); + +}; // _BluetoothOppServerEvent + +} } } +#endif // _FNET_BT_INTERNAL_BLUETOOTH_OPP_SERVER_EVENT_H_ diff --git a/src/FNetBt_BluetoothOppServerEventArg.cpp b/src/FNetBt_BluetoothOppServerEventArg.cpp new file mode 100755 index 0000000..577184c --- /dev/null +++ b/src/FNetBt_BluetoothOppServerEventArg.cpp @@ -0,0 +1,113 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// @file FNetBt_BluetoothOppServerEventArg.cpp +// @brief This is the implementation file for the _BluetoothOppServerEventArg class. +// + +#include +#include +#include "FNetBt_BluetoothOppServerEventArg.h" + + +using namespace Tizen::Base; + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +// +// This is a class constructor for _BT_OPP_SERVER_EVENT_PUSH_REQUESTED event. +// +_BluetoothOppServerEventArg::_BluetoothOppServerEventArg(const BluetoothDevice& device) + : __evtType(_BT_OPP_SERVER_EVENT_PUSH_REQUESTED) + , __pRequester(null) + , __fileName() + , __fileSize(0) + , __isCompleted(true) + , __percent(0) +{ + __pRequester = new (std::nothrow) BluetoothDevice(device); + SysTryReturnVoidResult(NID_NET_BT, __pRequester != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient."); +} + +// +// This is a class constructor for _BT_OPP_SERVER_EVENT_TRANSFER_DONE event. +// +_BluetoothOppServerEventArg::_BluetoothOppServerEventArg(const Tizen::Base::String& fileName, int fileSize, bool isCompleted) + : __evtType(_BT_OPP_SERVER_EVENT_TRANSFER_DONE) + , __pRequester(null) + , __fileName(fileName) + , __fileSize(fileSize) + , __isCompleted(isCompleted) + , __percent(0) +{ +} + +// +// This is a class constructor for _BT_OPP_SERVER_EVENT_TRANSFER_PROGRESS event. +// +_BluetoothOppServerEventArg::_BluetoothOppServerEventArg(int percent) + : __evtType(_BT_OPP_SERVER_EVENT_TRANSFER_PROGRESS) + , __pRequester(null) + , __fileName() + , __fileSize(0) + , __isCompleted(true) + , __percent(percent) +{ +} + +_BluetoothOppServerEventArg::~_BluetoothOppServerEventArg(void) +{ + delete __pRequester; +} + +_BluetoothOppServerEventType +_BluetoothOppServerEventArg::GetEventType(void) const +{ + return __evtType; +} + +const BluetoothDevice* +_BluetoothOppServerEventArg::GetRequester(void) const +{ + return __pRequester; +} + +Tizen::Base::String +_BluetoothOppServerEventArg::GetFileName(void) const +{ + return __fileName; +} + +int +_BluetoothOppServerEventArg::GetFileSize(void) const +{ + return __fileSize; +} + +bool +_BluetoothOppServerEventArg::IsTransferCompleted(void) const +{ + return __isCompleted; +} + +int +_BluetoothOppServerEventArg::GetPercent(void) const +{ + return __percent; +} + +} } } // Tizen::Net::Bluetooth diff --git a/src/FNetBt_BluetoothOppServerEventArg.h b/src/FNetBt_BluetoothOppServerEventArg.h new file mode 100644 index 0000000..4160b4f --- /dev/null +++ b/src/FNetBt_BluetoothOppServerEventArg.h @@ -0,0 +1,151 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +/** + * @file FNetBt_BluetoothOppServerEventArg.h + * @brief This is the header file for the _BluetoothOppServerEventArg class. + * + * This header file contains the declarations of the _BluetoothOppServerEventArg class which includes information to be + * passed to the event listeners + */ +#ifndef _FNET_BT_INTERNAL_BLUETOOTH_OPP_SERVER_EVENT_ARG_H_ +#define _FNET_BT_INTERNAL_BLUETOOTH_OPP_SERVER_EVENT_ARG_H_ + +#include +#include +#include +#include +#include + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +// Forward declaration +class BluetoothDevice; + +/** + * @enum _BluetoothOppServerEventType + * Type for specifying the type of _BluetoothOppServerEvent + */ +enum _BluetoothOppServerEventType +{ + _BT_OPP_SERVER_EVENT_PUSH_REQUESTED, /**< For notifying an incoming push request is received from a remote OPP client */ + _BT_OPP_SERVER_EVENT_TRANSFER_PROGRESS, /**< For notifying the file transfer has finished */ + _BT_OPP_SERVER_EVENT_TRANSFER_DONE /**< For notifying the file is being transferred */ +}; + +/** + * @class _BluetoothOppServerEventArg + * @brief This class is used as an argument for callback methods of the IBluetoothOppServerEventListener class. + * + * When a _BluetoothOppServerEvent occurs, the _BluetoothOppServerEvent finds a IBluetoothOppServerEventListener instance + * which is registered for the _BluetoothOppServerEvent and calls an appropriate method of the listener. + * @see IBluetoothOppServerEventListener + */ +class _BluetoothOppServerEventArg + : public Tizen::Base::Object + , public Tizen::Base::Runtime::IEventArg +{ +public: + /** + * This is a class constructor for _BT_OPP_SERVER_EVENT_PUSH_REQUESTED event. + * + * @param[in] device The OPP client device that requests the connection + */ + _BluetoothOppServerEventArg(const BluetoothDevice& device); + + /** + * This is a class constructor for _BT_OPP_SERVER_EVENT_TRANSFER_DONE event. + * + * @param[in] fileName The name of the transferred file + * @param[in] fileSize The size of the transferred file + * @param[in] isCompleted Set to @c true if the transfer is successfully completed, @n + * else @c false + */ + _BluetoothOppServerEventArg(const Tizen::Base::String& fileName, int fileSize, bool isCompleted); + + /** + * This is a class constructor for _BT_OPP_SERVER_EVENT_TRANSFER_PROGRESS event. + * + * @param[in] percent The progress in percentage ranging from @c 1 to @c 100 percent + */ + _BluetoothOppServerEventArg(int percent); + + /** + * This is the class destructor. + */ + ~_BluetoothOppServerEventArg(void); + + /** + * Gets the type of this event. + * + * @return The type of the event + */ + _BluetoothOppServerEventType GetEventType(void) const; + + /** + * Gets the OPP client device. + * + * @return The pointer of the OPP client device which request to connect + */ + const BluetoothDevice* GetRequester(void) const; + + /** + * Gets the received file name. + * + * @return The received file name + */ + Tizen::Base::String GetFileName(void) const; + + /** + * Gets the received file size. + * + * @return The received file size + */ + int GetFileSize(void) const; + + /** + * Is the file transfer completed. + * + * @return @c true if the transfer is successfully completed, @n + * else @c false + */ + bool IsTransferCompleted(void) const; + + /** + * Gets the progress information as a type of percentage. + * + * @return The percentage that represents the progress of file transfer + */ + int GetPercent(void) const; + +private: + _BluetoothOppServerEventArg(void); + _BluetoothOppServerEventArg(const _BluetoothOppServerEventArg& eventArg); + _BluetoothOppServerEventArg& operator =(const _BluetoothOppServerEventArg& rValue); + +private: + _BluetoothOppServerEventType __evtType; + BluetoothDevice* __pRequester; + Tizen::Base::String __fileName; + int __fileSize; + bool __isCompleted; + int __percent; + +}; // _BluetoothOppServerEventArg + +} } } +#endif // _FNET_BT_INTERNAL_BLUETOOTH_OPP_SERVER_EVENT_ARG_H_ diff --git a/src/FNetBt_BluetoothOppServerImpl.cpp b/src/FNetBt_BluetoothOppServerImpl.cpp new file mode 100755 index 0000000..814c0ac --- /dev/null +++ b/src/FNetBt_BluetoothOppServerImpl.cpp @@ -0,0 +1,663 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// @file FNetBt_BluetoothOppServerImpl.cpp +// @brief This is the implementation file for the _BluetoothOppServerImpl class. +// + +#include +#include +#include +#include +#include +#include +#include "FNetBt_BluetoothOppServerImpl.h" +#include "FNetBt_BluetoothOppSystemAdapter.h" +#include "FNetBt_BluetoothGapSystemAdapter.h" +#include "FNetBt_BluetoothOppServerEvent.h" +#include "FNetBt_BluetoothOppServerEventArg.h" + +using namespace std; +using namespace Tizen::App; +using namespace Tizen::Base; +using namespace Tizen::Base::Runtime; + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +_BluetoothOppServerImpl::_BluetoothOppServerImpl(void) + : __pGapAdapter(null) + , __pOppAdapter(null) + , __pEvent(null) + , __stateMutex() + , __currentState(_BT_OPP_SVR_STATE_DISABLED) + , __pushedFileName() + , __minProgressInterval(__defaultProgressInterval) + , __previousProgress(0) +{ +} + +_BluetoothOppServerImpl::~_BluetoothOppServerImpl(void) +{ + if (__pOppAdapter != null) + { + if ((__currentState == _BT_OPP_SVR_STATE_ON_SERVICE) + || (__currentState == _BT_OPP_SVR_STATE_PUSH_REQUESTED) + || (__currentState == _BT_OPP_SVR_STATE_ON_TRANSFER)) + { + (void) StopService(); // Ignores the result of this function. + } + __pOppAdapter = null; + } + + if (__pGapAdapter != null) + { + __pGapAdapter->UnregisterManagerEventListener(*this); + __pGapAdapter = null; + } +} + +result +_BluetoothOppServerImpl::Construct(IBluetoothOppServerEventListener& listener) +{ + result r = E_SUCCESS; + unique_ptr<_BluetoothOppServerEvent> pEvent; + + r = __stateMutex.Create(); + SysTryReturn(NID_NET_BT, r == E_SUCCESS, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Failed to create the state mutex."); + + __pGapAdapter = _BluetoothGapSystemAdapter::GetInstance(); + SysTryReturn(NID_NET_BT, __pGapAdapter != null, E_SYSTEM, E_SYSTEM, + "[E_SYSTEM] Failed to invoke _BluetoothSysteAdapter::GetInstance()."); + + __pOppAdapter = _BluetoothOppSystemAdapter::GetInstance(); + + pEvent.reset(new (std::nothrow) _BluetoothOppServerEvent()); + SysTryReturn(NID_NET_BT, pEvent != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient."); + r = pEvent->Construct(); + SysTryReturn(NID_NET_BT, r == E_SUCCESS, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Failed to construct the event."); + // add the IBluetoothOppServerEventListener instance to a new created _BluetoothOppServerEvent. + r = pEvent->AddListener(listener, true); + SysTryReturn(NID_NET_BT, r == E_SUCCESS, E_SYSTEM, E_SYSTEM, + "[%s] Propagating. Failed to add the application listener for OPP Server", GetErrorMessage(r)); + + // registers this callback listener to the system adapter for activation/deactivation event + r = __pGapAdapter->RegisterManagerEventListener(*this, true); + SysTryReturn(NID_NET_BT, r == E_SUCCESS, E_SYSTEM, E_SYSTEM, + "[E_SYSTEM] Failed to register the callback listener to _BluetoothSystemAdapter."); + + // check whether the Bluetooth is available + __stateMutex.Acquire(); + + if (__pGapAdapter->IsActivated() == true) + { + __currentState = _BT_OPP_SVR_STATE_IDLE; + } + + __stateMutex.Release(); + + __pEvent = move(pEvent); + + return E_SUCCESS; +} + +result +_BluetoothOppServerImpl::AcceptPush(void) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s]", GetStringOfCurrentState()); + + result r = E_FAILURE; + + __stateMutex.Acquire(); + + switch (__currentState) + { + case _BT_OPP_SVR_STATE_DISABLED: + r = E_INVALID_STATE; + break; + + case _BT_OPP_SVR_STATE_IDLE: + case _BT_OPP_SVR_STATE_ON_SERVICE: + case _BT_OPP_SVR_STATE_ON_TRANSFER: + case _BT_OPP_SVR_STATE_ON_STOPPING: + r = E_INVALID_OPERATION; + break; + + case _BT_OPP_SVR_STATE_PUSH_REQUESTED: + r = __pOppAdapter->AcceptOppPush(__pushedFileName); + + if (r == E_SUCCESS) + { + __currentState = _BT_OPP_SVR_STATE_ON_TRANSFER; + } + else + { + __currentState = _BT_OPP_SVR_STATE_ON_SERVICE; + } + break; + + default: + // ignore other cases + break; + } + + __stateMutex.Release(); + + if (r != E_SUCCESS) + { + SysLogException(NID_NET_BT, r, "[%s] exception occurred on accepting a push request.", GetErrorMessage(r)); + } + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [ActionResult:%s]", GetStringOfCurrentState(), GetErrorMessage(r)); + + return r; +} + +result +_BluetoothOppServerImpl::RejectPush(void) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s]", GetStringOfCurrentState()); + + result r = E_FAILURE; + + __stateMutex.Acquire(); + + switch (__currentState) + { + case _BT_OPP_SVR_STATE_DISABLED: + r = E_INVALID_STATE; + break; + + case _BT_OPP_SVR_STATE_IDLE: + case _BT_OPP_SVR_STATE_ON_SERVICE: + case _BT_OPP_SVR_STATE_ON_TRANSFER: + case _BT_OPP_SVR_STATE_ON_STOPPING: + r = E_INVALID_OPERATION; + break; + + case _BT_OPP_SVR_STATE_PUSH_REQUESTED: + r = __pOppAdapter->RejectOppPush(); + + // change the state into ON_SERVICE regardless of the result + __currentState = _BT_OPP_SVR_STATE_ON_SERVICE; + break; + + default: + // ignore other cases + break; + } + + __stateMutex.Release(); + + if (r != E_SUCCESS) + { + SysLogException(NID_NET_BT, r, "[%s] exception occurred on rejecting a push request.", GetErrorMessage(r)); + } + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [ActionResult:%s]", GetStringOfCurrentState(), GetErrorMessage(r)); + + return r; +} + +result +_BluetoothOppServerImpl::SetDestinationPath(const Tizen::Base::String& dstPath) +{ + result r = E_INVALID_OPERATION; + String physicalPath; + + if ((__currentState != _BT_OPP_SVR_STATE_ON_TRANSFER) && + (__currentState != _BT_OPP_SVR_STATE_ON_STOPPING)) + { + if (_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat()) + { + if (Tizen::Io::_FileImpl::ConvertVirtualToPhysicalPath(dstPath, physicalPath) != E_SUCCESS) + { + r = E_INACCESSIBLE_PATH; + } + else + { + r = __pOppAdapter->SetOppReceivePath(physicalPath); + } + } + else + { + r = __pOppAdapter->SetOppReceivePath(dstPath); + } + } + + if (r != E_SUCCESS) + { + SysLogException(NID_NET_BT, r, "[%s] exception occurred on setting the destination path.", GetErrorMessage(r)); + } + + return r; +} + +result +_BluetoothOppServerImpl::SetMinProgressInterval(int percent) +{ + result r = E_SUCCESS; + + if ((percent < 1) || (percent > 100)) + { + r = E_OUT_OF_RANGE; + SysLogException(NID_NET_BT, E_OUT_OF_RANGE, "[E_OUT_OF_RANGE] The input argument - percent - is outside the valid range."); + } + else + { + __minProgressInterval = percent; + } + + return r; +} + +result +_BluetoothOppServerImpl::StartService(const Tizen::Base::String& dstPath) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s]", GetStringOfCurrentState()); + + result r = E_FAILURE; + String physicalPath; + + __stateMutex.Acquire(); + + switch (__currentState) + { + case _BT_OPP_SVR_STATE_DISABLED: + r = E_INVALID_STATE; + break; + + case _BT_OPP_SVR_STATE_IDLE: + if (_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat()) + { + if (Tizen::Io::_FileImpl::ConvertVirtualToPhysicalPath(dstPath, physicalPath) != E_SUCCESS) + { + r = E_INACCESSIBLE_PATH; + break; + } + } + else + { + physicalPath = dstPath; + } + + r = __pOppAdapter->StartOppServer(*this, physicalPath); + + if (r == E_SUCCESS) + { + __currentState = _BT_OPP_SVR_STATE_ON_SERVICE; + } + break; + + case _BT_OPP_SVR_STATE_ON_SERVICE: + case _BT_OPP_SVR_STATE_PUSH_REQUESTED: + case _BT_OPP_SVR_STATE_ON_TRANSFER: + r = E_IN_PROGRESS; + break; + + case _BT_OPP_SVR_STATE_ON_STOPPING: + r = E_INVALID_OPERATION; + break; + + default: + // ignore other cases + break; + } + + __stateMutex.Release(); + + if (r != E_SUCCESS) + { + SysLogException(NID_NET_BT, r, "[%s] exception occurred on starting OPP service.", GetErrorMessage(r)); + } + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [ActionResult:%s]", GetStringOfCurrentState(), GetErrorMessage(r)); + + return r; +} + +result +_BluetoothOppServerImpl::StopService(void) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s]", GetStringOfCurrentState()); + + result r = E_FAILURE; + + __stateMutex.Acquire(); + + switch (__currentState) + { + case _BT_OPP_SVR_STATE_DISABLED: + r = E_INVALID_STATE; + break; + + case _BT_OPP_SVR_STATE_IDLE: + r = E_INVALID_OPERATION; + break; + + case _BT_OPP_SVR_STATE_ON_SERVICE: + case _BT_OPP_SVR_STATE_ON_STOPPING: + r = __pOppAdapter->StopOppServer(); + if (r == E_SUCCESS) + { + __currentState = _BT_OPP_SVR_STATE_IDLE; + } + break; + + case _BT_OPP_SVR_STATE_PUSH_REQUESTED: + r = __pOppAdapter->RejectOppPush(); + if (r == E_SUCCESS) + { + r = __pOppAdapter->StopOppServer(); + if (r == E_SUCCESS) + { + __currentState = _BT_OPP_SVR_STATE_IDLE; + } + else + { + __currentState = _BT_OPP_SVR_STATE_ON_SERVICE; + } + } + // Stays in the current status, if the rejection fails + break; + + case _BT_OPP_SVR_STATE_ON_TRANSFER: + r = __pOppAdapter->StopOppTransfer(); + r = TransExceptionsInclusive(r ,E_FAILURE, E_OPERATION_FAILED); + if (r == E_SUCCESS) + { + r = __pOppAdapter->StopOppServer(); + if (r == E_SUCCESS) + { + __currentState = _BT_OPP_SVR_STATE_IDLE; + } + else + { + __currentState = _BT_OPP_SVR_STATE_ON_SERVICE; + } + } + // Stays in the current status, if the terminating file transfer fails + break; + + default: + // ignore other cases + break; + } + + __stateMutex.Release(); + + if (r != E_SUCCESS) + { + SysLogException(NID_NET_BT, r, "[%s] exception occurred on stopping OPP service.", GetErrorMessage(r)); + } + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [ActionResult:%s]", GetStringOfCurrentState(), GetErrorMessage(r)); + + return r; +} + +result +_BluetoothOppServerImpl::StopTransfer(void) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s]", GetStringOfCurrentState()); + + result r = E_OPERATION_FAILED; + + __stateMutex.Acquire(); + + switch (__currentState) + { + case _BT_OPP_SVR_STATE_DISABLED: + r = E_INVALID_STATE; + break; + + case _BT_OPP_SVR_STATE_IDLE: + case _BT_OPP_SVR_STATE_ON_SERVICE: + case _BT_OPP_SVR_STATE_PUSH_REQUESTED: + case _BT_OPP_SVR_STATE_ON_STOPPING: + r = E_INVALID_OPERATION; + break; + + case _BT_OPP_SVR_STATE_ON_TRANSFER: + r = __pOppAdapter->StopOppTransfer(); + if (r == E_SUCCESS) + { + __currentState = _BT_OPP_SVR_STATE_ON_STOPPING; + } + // It will be changed to IDLE after receiving the TransferDone event. + break; + + default: + // ignore other cases + break; + } + + __stateMutex.Release(); + + if (r != E_SUCCESS) + { + SysLogException(NID_NET_BT, r, "[%s] exception occurred on stopping OPP service.", GetErrorMessage(r)); + } + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [ActionResult:%s]", GetStringOfCurrentState(), GetErrorMessage(r)); + + return r; +} + +void +_BluetoothOppServerImpl::OnBluetoothActivated(result r) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s], [ActionResult:%s]", GetStringOfCurrentState(), GetErrorMessage(r)); + + __stateMutex.Acquire(); + + if ((__currentState == _BT_OPP_SVR_STATE_DISABLED) && (r == E_SUCCESS)) + { + __currentState = _BT_OPP_SVR_STATE_IDLE; + } + + __stateMutex.Release(); + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s]", GetStringOfCurrentState()); +} + +void +_BluetoothOppServerImpl::OnBluetoothDeactivated(result r) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s], [ActionResult:%s]", GetStringOfCurrentState(), GetErrorMessage(r)); + + __stateMutex.Acquire(); + + if (r == E_SUCCESS) + { + __currentState = _BT_OPP_SVR_STATE_DISABLED; + } + + __stateMutex.Release(); + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s]", GetStringOfCurrentState()); +} + +void +_BluetoothOppServerImpl::OnOppPushRequested(const BluetoothDevice& device) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s]", GetStringOfCurrentState()); + + bool isFired = false; + + __stateMutex.Acquire(); + + if (__currentState == _BT_OPP_SVR_STATE_ON_SERVICE) + { + __currentState = _BT_OPP_SVR_STATE_PUSH_REQUESTED; + isFired = true; + } + else if ((__currentState == _BT_OPP_SVR_STATE_PUSH_REQUESTED) + || (__currentState == _BT_OPP_SVR_STATE_ON_TRANSFER) + || (__currentState == _BT_OPP_SVR_STATE_ON_STOPPING)) + { + (void) __pOppAdapter->RejectOppPush(); // ignore the result + } + // ignore other cases + + __stateMutex.Release(); + + if (isFired) + { + _BluetoothOppServerEventArg* pArg = new (std::nothrow) _BluetoothOppServerEventArg(device); + if (pArg == null) + { + SysLogException(NID_NET_BT, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient."); + isFired = false; + } + else + { + __pEvent->FireAsync(*pArg); + } + } + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [PUSH_REQUESTED_Event:%s]", + GetStringOfCurrentState(), isFired ? "Fired" : "NotFired"); +} + +void +_BluetoothOppServerImpl::OnOppTransferInProgress(int percent) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s], [Progress:%d]", GetStringOfCurrentState(), percent); + + bool isFired = false; + + __stateMutex.Acquire(); + + if ((__currentState == _BT_OPP_SVR_STATE_ON_TRANSFER) || (__currentState == _BT_OPP_SVR_STATE_ON_STOPPING)) + { + if (((percent - __previousProgress) >= __minProgressInterval) || (percent >= 100)) + { + isFired = true; + __previousProgress = percent; + } + } + // ignore other scases + + __stateMutex.Release(); + + if (isFired) + { + _BluetoothOppServerEventArg* pArg = new (std::nothrow) _BluetoothOppServerEventArg(percent); + if (pArg == null) + { + SysLogException(NID_NET_BT, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient."); + isFired = false; + } + else + { + __pEvent->FireAsync(*pArg); + } + } + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [TRANSFER_IN_PROGRESS_Event:%s]", + GetStringOfCurrentState(), isFired ? "Fired" : "NotFired"); +} + +void +_BluetoothOppServerImpl::OnOppTransferDone(const Tizen::Base::String& filePath, int fileSize, bool isCompleted) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s], [TransferDone:%s]", + GetStringOfCurrentState(), isCompleted ? "Completed" : "NotCompleted"); + + result r = E_SUCCESS; + bool isFired = false; + + __stateMutex.Acquire(); + + if (__currentState == _BT_OPP_SVR_STATE_IDLE) + { + isFired = true; + __previousProgress = 0; // initialization for the next push transaction + } + else if ((__currentState == _BT_OPP_SVR_STATE_ON_TRANSFER) || (__currentState == _BT_OPP_SVR_STATE_ON_STOPPING)) + { + __currentState = _BT_OPP_SVR_STATE_ON_SERVICE; + isFired = true; + __previousProgress = 0; // initialization for the next push transaction + } + // ignore other cases + + __stateMutex.Release(); + + if (isFired) + { + _BluetoothOppServerEventArg* pArg = new (std::nothrow) _BluetoothOppServerEventArg(filePath, fileSize, isCompleted); + if (pArg == null) + { + SysLogException(NID_NET_BT, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient."); + isFired = false; + } + else + { + __pEvent->FireAsync(*pArg); + } + } + + if ((isFired) && (r != E_SUCCESS)) + { + SysLogException(NID_NET_BT, r, "[%s] exception occurred on stopping OPP service in the transfer-done callback.", GetErrorMessage(r)); + } + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [ActionResult:%s], [TRANSFER_DONE_Event:%s]", + GetStringOfCurrentState(), GetErrorMessage(r), isFired ? "Fired" : "NotFired"); +} + +const char* +_BluetoothOppServerImpl::GetStringOfCurrentState(void) const +{ + const char* pStateString = null; + + switch (__currentState) + { + case _BT_OPP_SVR_STATE_DISABLED: + pStateString = "DISABLED"; + break; + + case _BT_OPP_SVR_STATE_IDLE: + pStateString = "IDLE"; + break; + + case _BT_OPP_SVR_STATE_ON_SERVICE: + pStateString = "ON_SERVICE"; + break; + + case _BT_OPP_SVR_STATE_PUSH_REQUESTED: + pStateString = "PUSH_REQUESTED"; + break; + + case _BT_OPP_SVR_STATE_ON_TRANSFER: + pStateString = "ON_TRANSFER"; + break; + + case _BT_OPP_SVR_STATE_ON_STOPPING: + pStateString = "ON_STOPPING"; + break; + + default: + pStateString = "Unknown"; + break; + } + + return pStateString; +} + +} } } // Tizen::Net::Bluetooth diff --git a/src/FNetBt_BluetoothOppSystemAdapter.cpp b/src/FNetBt_BluetoothOppSystemAdapter.cpp new file mode 100755 index 0000000..e3d126d --- /dev/null +++ b/src/FNetBt_BluetoothOppSystemAdapter.cpp @@ -0,0 +1,380 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// @file FNetBt_BluetoothOppSystemAdapter.cpp +// @brief This is the implementation file for the _BluetoothOppSystemAdapter class. +// + +#include +#include +#include +#include +#include +#include +#include +#include +#include "FNetBt_BluetoothOppSystemAdapter.h" +#include "FNetBt_BluetoothGapSystemAdapter.h" +#include "FNetBt_BluetoothDeviceImpl.h" +#include "FNetBt_BluetoothOppClientImpl.h" +#include "FNetBt_BluetoothOppServerImpl.h" + +using namespace std; +using namespace Tizen::Base; +using namespace Tizen::Base::Collection; +using namespace Tizen::Base::Utility; + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +_BluetoothOppSystemAdapter* _BluetoothOppSystemAdapter::__pInstance = null; + +_BluetoothOppSystemAdapter::_BluetoothOppSystemAdapter(void) + : __pOppServerImpl(null) + , __pOppClientImpl(null) + , __serverTransferId(0) + , __serverRecvFileName() + , __serverRecvFileSize(0) +{ +} + +_BluetoothOppSystemAdapter::~_BluetoothOppSystemAdapter(void) +{ +} + +void +_BluetoothOppSystemAdapter::InitSingleton(void) +{ + static _BluetoothOppSystemAdapter inst = _BluetoothOppSystemAdapter(); + + __pInstance = &inst; +} + +_BluetoothOppSystemAdapter* +_BluetoothOppSystemAdapter::GetInstance(void) +{ + static pthread_once_t onceBlock = PTHREAD_ONCE_INIT; + + if (__pInstance == null) + { + ClearLastResult(); + pthread_once(&onceBlock, InitSingleton); + result r = GetLastResult(); + if (IsFailed(r)) + { + onceBlock = PTHREAD_ONCE_INIT; + } + } + + return __pInstance; +} + +result +_BluetoothOppSystemAdapter::StartOppServer(const _BluetoothOppServerImpl& impl, const Tizen::Base::String& dstPath) +{ + unique_ptr pUuidStr; + bool isUsed = false; + unique_ptr pConvertedDestPath; + result r = E_SUCCESS; + int ret = BT_ERROR_NONE; + + // check OPP server's availability + pUuidStr.reset(_StringConverter::CopyToCharArrayN(UuId(BT_SVC_UUID_OPP).ToString())); + ret = bt_adapter_is_service_used(pUuidStr.get() , &isUsed); + SysTryReturnResult(NID_NET_BT, (ret == BT_ERROR_NONE) && !isUsed, E_SERVICE_UNAVAILABLE, "OPP Server is not available. [0x%08X]", ret); + + pConvertedDestPath.reset(_StringConverter::CopyToCharArrayN(dstPath)); + SysTryReturnResult(NID_NET_BT, pConvertedDestPath != null, E_INACCESSIBLE_PATH, "The file path is invalid."); + + ret = bt_opp_server_initialize_by_connection_request(pConvertedDestPath.get(), &OnOppServerConnectionRequested, null); + SysLog(NID_NET_BT, "Starting the OPP Server %s. [0x%-04X]", ret == BT_ERROR_NONE ? "is successful" : "fails", ret); + + if (ret == BT_ERROR_NONE) + { + __pOppServerImpl = const_cast <_BluetoothOppServerImpl*>(&impl); + } + else + { + r = E_FAILURE; + } + + return r; +} + +result +_BluetoothOppSystemAdapter::StopOppServer(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_opp_server_deinitialize(); + SysLog(NID_NET_BT, "Stop the OPP Server %s. [0x%08X]", ret == BT_ERROR_NONE ? "is successful" : "fails", ret); + + if (ret == BT_ERROR_NONE) + { + __pOppServerImpl = null; + return E_SUCCESS; + } + + return E_FAILURE; +} + +result +_BluetoothOppSystemAdapter::SetOppReceivePath(const Tizen::Base::String& dstPath) +{ + char* pConvertedDestPath = NULL; + result r = E_FAILURE; + int ret = BT_ERROR_NONE; + + pConvertedDestPath = _StringConverter::CopyToCharArrayN(dstPath); + SysTryReturnResult(NID_NET_BT, pConvertedDestPath != null, E_INACCESSIBLE_PATH, "The file path is invalid."); + + ret = bt_opp_server_set_destination(pConvertedDestPath); + SysLog(NID_NET_BT, "Setting the receive path of the OPP Server %s. [0x%08X]", + ret == BT_ERROR_NONE ? "is successful" : "fails", ret); + + if (ret == BT_ERROR_NONE) + { + r = E_SUCCESS; + } + + delete[] pConvertedDestPath; + return r; +} + +result +_BluetoothOppSystemAdapter::AcceptOppPush(const Tizen::Base::String& fileName) +{ + result r = E_FAILURE; + int ret = BT_ERROR_NONE; + + char* pConvertedfileName = _StringConverter::CopyToCharArrayN(fileName); + SysTryReturnResult(NID_NET_BT, pConvertedfileName != null, E_FAILURE, "The file name is invalid."); + + ret = bt_opp_server_accept(&OnOppServerTransferInProgress, &OnOppServerTransferCompleted, pConvertedfileName, null, + &__serverTransferId); + SysLog(NID_NET_BT, "Accepting the OPP push request %s. [0x%08X]", ret == BT_ERROR_NONE ? "is successful" : "fails", ret); + + if (ret == BT_ERROR_NONE) + { + r = E_SUCCESS; + } + + delete[] pConvertedfileName; + return r; +} + +result +_BluetoothOppSystemAdapter::RejectOppPush(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_opp_server_reject(); + SysLog(NID_NET_BT, "Rejecting the OPP push request %s. [0x%08X]", ret == BT_ERROR_NONE ? "is successful" : "fails", ret); + + if (ret == BT_ERROR_NONE) + { + return E_SUCCESS; + } + + return E_FAILURE; +} + +result +_BluetoothOppSystemAdapter::StopOppTransfer(void) +{ + int ret = BT_ERROR_NONE; + + // if a file transfer is not started yet, the default transfer ID (0) is used for terminating the OPP server. + ret = bt_opp_server_cancel_transfer(__serverTransferId); + SysLog(NID_NET_BT, "Stop the OPP file transfer (ID:%d) %s. [0x%08X]", __serverTransferId, + ret == BT_ERROR_NONE ? "is successful" : "fails", ret); + + if (ret == BT_ERROR_NONE) + { + return E_SUCCESS; + } + + return E_OPERATION_FAILED; +} + +result +_BluetoothOppSystemAdapter::PushOppFile(const _BluetoothOppClientImpl& impl, const Tizen::Base::ByteBuffer& serverAddress, + const Tizen::Base::String& filePath) +{ + result r = E_FAILURE; + int ret = BT_ERROR_NONE; + unique_ptr pServerDevAddr; + unique_ptr pFileName; + + SysTryReturnResult(NID_NET_BT, __pOppClientImpl == null, E_SERVICE_UNAVAILABLE, "The already OPP client is running."); + SysTryReturnResult(NID_NET_BT, serverAddress.GetRemaining() == _BT_ADDRESS_LENGTH, E_FAILURE, + "The address of the remote device is incorrect."); + + pFileName.reset(_StringConverter::CopyToCharArrayN(filePath)); + SysTryReturnResult(NID_NET_BT, pFileName != null, E_INACCESSIBLE_PATH, "The file path is invalid."); + pServerDevAddr.reset(_StringConverter::CopyToCharArrayN(_BluetoothDeviceImpl::GetAddressString(serverAddress))); + SysTryReturnResult(NID_NET_BT, pServerDevAddr != null, E_FAILURE, "The server address is invalid."); + + if (bt_opp_client_initialize() == BT_ERROR_NONE) + { + (void) bt_opp_client_add_file(pFileName.get()); + ret = bt_opp_client_push_files(pServerDevAddr.get(), &OnOppClientConnectionResponded, &OnOppClientTransferInProgress, + &OnOppClientTransferCompleted, null); + SysLog(NID_NET_BT, "Sending a push request to device [%s] %s. [0x%08X]", pServerDevAddr.get(), + ret == BT_ERROR_NONE ? "is successful" : "fails", ret); + + if (ret == BT_ERROR_NONE) + { + __pOppClientImpl = const_cast<_BluetoothOppClientImpl*>(&impl); + r = E_SUCCESS; + } + else + { + bt_opp_client_deinitialize(); + } + } + + return r; +} + +result +_BluetoothOppSystemAdapter::CancelOppPush(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_opp_client_cancel_push(); + SysLog(NID_NET_BT, "Cancel the OPP file transfer %s. [0x%08X]", ret == BT_ERROR_NONE ? "is successful" : "fails", ret); + + if (ret == BT_ERROR_NONE) + { + return E_SUCCESS; + } + + return E_FAILURE; +} + +void +_BluetoothOppSystemAdapter::OnOppClientConnectionResponded(int status, const char* pRemoteAddress, void* pUserData) +{ + _BluetoothOppSystemAdapter* pOppAdapter = _BluetoothOppSystemAdapter::GetInstance(); + + if (pOppAdapter->__pOppClientImpl) + { + if (status == BT_ERROR_NONE) + { + pOppAdapter->__pOppClientImpl->OnOppPushResponded(E_SUCCESS); + } + else + { + pOppAdapter->__pOppClientImpl->OnOppPushResponded(E_SYSTEM); + pOppAdapter->__pOppClientImpl = null; + bt_opp_client_deinitialize(); + } + } +} + +void +_BluetoothOppSystemAdapter::OnOppClientTransferInProgress(const char* pFilePath, long long fileSize, int progress, void* pUserData) +{ + _BluetoothOppSystemAdapter* pOppAdapter = _BluetoothOppSystemAdapter::GetInstance(); + + pOppAdapter->__serverRecvFileSize = fileSize; + // converts the UTF8 multibyte string to Unicode String + (void) StringUtil::Utf8ToString(pFilePath, pOppAdapter->__serverRecvFileName); + + if (pOppAdapter->__pOppClientImpl) + { + pOppAdapter->__pOppClientImpl->OnOppTransferInProgress(progress); + } +} + +void +_BluetoothOppSystemAdapter::OnOppClientTransferCompleted(int status, const char* pRemoteAddress, void* pUserData) +{ + bool isCompleted = true; + _BluetoothOppSystemAdapter* pOppAdapter = _BluetoothOppSystemAdapter::GetInstance(); + + if (pOppAdapter->__pOppClientImpl) + { + if (status != BT_ERROR_NONE) + { + isCompleted = false; + } + + pOppAdapter->__pOppClientImpl->OnOppTransferDone(pOppAdapter->__serverRecvFileName, pOppAdapter->__serverRecvFileSize, + isCompleted); + pOppAdapter->__pOppClientImpl = null; + // TODO: Is it right that the following statement is located in the next of callback? + bt_opp_client_deinitialize(); + } +} + +void +_BluetoothOppSystemAdapter::OnOppServerConnectionRequested(const char* pRemoteAddress, void* pUserData) +{ + result r = E_SUCCESS; + BluetoothDevice requester; + ByteBuffer deviceAddress; + String deviceAddressStr(pRemoteAddress); + _BluetoothOppSystemAdapter* pOppAdapter = _BluetoothOppSystemAdapter::GetInstance(); + + if (pOppAdapter->__pOppServerImpl) + { + deviceAddress.Construct(_BT_ADDRESS_LENGTH); + (void) _BluetoothDeviceImpl::GetAddressByteBuffer(deviceAddressStr, L":", deviceAddress); + + r = _BluetoothGapSystemAdapter::GetPairedDevice(deviceAddress, requester); + SysTryReturnVoidResult(NID_NET_BT, r == E_SUCCESS, E_SYSTEM, "[E_SYSTEM] Getting information of the request has failed."); + + pOppAdapter->__pOppServerImpl->OnOppPushRequested(requester); + } +} + +void +_BluetoothOppSystemAdapter::OnOppServerTransferInProgress(const char* pFilePath, long long fileSize, int progress, void* pUserData) +{ + _BluetoothOppSystemAdapter* pOppAdapter = _BluetoothOppSystemAdapter::GetInstance(); + + if (pOppAdapter->__pOppServerImpl) + { + pOppAdapter->__pOppServerImpl->OnOppTransferInProgress(progress); + } +} + +void +_BluetoothOppSystemAdapter::OnOppServerTransferCompleted(int status, const char* pFilePath, long long fileSize, void* pUserData) +{ + bool isCompleted = true; + String convertedFilePath; + + _BluetoothOppSystemAdapter* pOppAdapter = _BluetoothOppSystemAdapter::GetInstance(); + + if (pOppAdapter->__pOppServerImpl) + { + pOppAdapter->__serverTransferId = 0; + + if (status != BT_ERROR_NONE) + { + isCompleted = false; + } + // TODO: not file name but file path + // converts the UTF8 multibyte string to Unicode String + (void) StringUtil::Utf8ToString(pFilePath, convertedFilePath); + pOppAdapter->__pOppServerImpl->OnOppTransferDone(convertedFilePath, fileSize, isCompleted); + } +} + +} } } // Tizen::Net::Bluetooth diff --git a/src/FNetBt_BluetoothOppSystemAdapter.h b/src/FNetBt_BluetoothOppSystemAdapter.h new file mode 100644 index 0000000..05ca2d3 --- /dev/null +++ b/src/FNetBt_BluetoothOppSystemAdapter.h @@ -0,0 +1,209 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +/** + * @file FNetBt_BluetoothOppSystemAdapter.h + * @brief This is the header file for the _BluetoothOppSystemAdapter class. + * + * This header file contains the declaration of the _BluetoothOppSystemAdapter class. + */ +#ifndef _FNET_BT_INTERNAL_BLUETOOTH_OPP_SYSTEM_ADAPTER_H_ +#define _FNET_BT_INTERNAL_BLUETOOTH_OPP_SYSTEM_ADAPTER_H_ + +#include +#include +#include +#include +#include + +namespace Tizen { namespace Base { +class ByteBuffer; +} } + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +// forward declarations +class BluetoothDevice; +class _BluetoothOppClientImpl; +class _BluetoothOppServerImpl; + +/** + * @class _BluetoothOppSystemAdapter + * @brief This class provides functions related to deliver the system events to the listeners such as + * _BluetoothManagerImpl. This class is a type of singleton, therefore only one instance should be allowed. + */ +class _BluetoothOppSystemAdapter + : public Tizen::Base::Object +{ +public: + /** + * Creates an instance of this class if there is no instance in this application context. + * Gets the exist instance because this class is a singleton, otherwise. + * + * @return the instance of this class + */ + static _BluetoothOppSystemAdapter* GetInstance(void); + + //----------------------------------------------------------------------------------------------------------------- + // OPP Server + //----------------------------------------------------------------------------------------------------------------- + + /** + * Start the OPP server and register an instance of _BluetoothOppServerImpl class into the internal. + * Currently, the only one instance can be registered. + * + * @return An error code + * @param[in] impl The instance of _BluetoothOppServerImpl to be registered + * @param[in] dstPath The new destination file path + * @exception E_SUCCESS The method is successful. + * @exception E_SERVICE_UNAVAILABLE OPP Server service is not available because the number of registered instances + * are exceeded to the max number. + * @exception E_SYSTEM A system error has occurred. + */ + result StartOppServer(const _BluetoothOppServerImpl& impl, const Tizen::Base::String& dstPath); + + /** + * Stop the running OPP server and unset the registered instance of _BluetoothOppServerImpl class. + * + * @return An error code + * @param[in] impl The instance of _BluetoothOppServerImpl to be unregistered + * @exception E_SUCCESS The method is successful. + * @exception E_SYSTEM A system error has occurred. + */ + result StopOppServer(void); + + /** + * Sets the destination path of the file to be received. + * + * @return An error code + * @param[in] dstPath The new destination file path + * @exception E_SUCCESS The method is successful. + * @exception E_INACCESSIBLE_PATH The specified @c path contains an invalid value. + * @exception E_FAILURE The method failed. + */ + result SetOppReceivePath(const Tizen::Base::String& dstPath); + + /** + * Accepts an OPP Push request from a remote device. + * + * @return An error code + * @param[in] fileName The name of the file to be saved which is received from the request device. + * @exception E_SUCCESS The method is successful. + * @exception E_FAILURE The method failed. + */ + result AcceptOppPush(const Tizen::Base::String& fileName); + + /** + * Rejects an OPP Push request from a remote device. + * + * @return An error code + * @exception E_SUCCESS The method is successful. + * @exception E_FAILURE The method failed. + */ + result RejectOppPush(void); + + /** + * Disconnects OPP connection and stops the file transfer in progress at the server side. + * + * @return An error code + * @exception E_SUCCESS The method is successful. + * @exception E_FAILURE The method failed. + */ + result StopOppTransfer(void); + + //----------------------------------------------------------------------------------------------------------------- + // OPP Client + //----------------------------------------------------------------------------------------------------------------- + + /** + * Request a push request after creating an OPP client. + * + * @return An error code + * @param[in] impl The instance of _BluetoothOppClientImpl to be registered + * @param[in] serverAddress The address of the target OPP server + * @param[in] filePath The path of the source file to be pushed + * @exception E_SUCCESS The method is successful. + * @exception E_SYSTEM A system error has occurred. + */ + result PushOppFile(const _BluetoothOppClientImpl& impl, const Tizen::Base::ByteBuffer& serverAddress, + const Tizen::Base::String& filePath); + + /** + * Cancels the Push request sent previously or stops the file transfer in progress. + * + * @return An error code + * @exception E_SUCCESS The method is successful. + * @exception E_FAILURE The method failed. + */ + result CancelOppPush(void); + + //----------------------------------------------------------------------------------------------------------------- + // Callback method + //----------------------------------------------------------------------------------------------------------------- + + /** + * Callback to notify that a push request is responded from the requested OPP server. + */ + static void OnOppClientConnectionResponded(int status, const char* pRemoteAddress, void* pUserData); + + /** + * Callback to notify the progress information of the client side during the file transfer. + */ + static void OnOppClientTransferInProgress(const char* pFilePath, long long fileSize, int progress, void* pUserData); + + /** + * Callback to notify that the file transfer of the client side is completed. + */ + static void OnOppClientTransferCompleted(int status, const char* pRemoteAddress, void* pUserData); + + /** + * Callback to notify that a push request is received from a remote OPP client. + */ + static void OnOppServerConnectionRequested(const char* pRemoteAddress, void* pUserData); + + /** + * Callback to notify the progress information of the server side during the file transfer. + */ + static void OnOppServerTransferInProgress(const char* pFilePath, long long fileSize, int progress, void* pUserData); + + /** + * Callback to notify that the file transfer of the server side is completed. + */ + static void OnOppServerTransferCompleted(int status, const char* pFilePath, long long fileSize, void* pUserData); + + +private: + _BluetoothOppSystemAdapter(void); + ~_BluetoothOppSystemAdapter(void); + + _BluetoothOppSystemAdapter(const _BluetoothOppSystemAdapter& value); + _BluetoothOppSystemAdapter& operator =(const _BluetoothOppSystemAdapter& value); + + static void InitSingleton(void); + +private: + _BluetoothOppServerImpl* __pOppServerImpl; + _BluetoothOppClientImpl* __pOppClientImpl; + int __serverTransferId; + Tizen::Base::String __serverRecvFileName; + long long __serverRecvFileSize; + static _BluetoothOppSystemAdapter* __pInstance; + +}; // _BluetoothOppSystemAdapter + +} } } +#endif // _FNET_BT_INTERNAL_BLUETOOTH_OPP_SYSTEM_ADAPTER_H_ diff --git a/src/FNetBt_BluetoothSppAcceptorEvent.cpp b/src/FNetBt_BluetoothSppAcceptorEvent.cpp new file mode 100644 index 0000000..d98c38b --- /dev/null +++ b/src/FNetBt_BluetoothSppAcceptorEvent.cpp @@ -0,0 +1,93 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// @file FNetBt_BluetoothSppAcceptorEvent.cpp +// @brief This is the implementation file for the _BluetoothSppAcceptorEvent class. +// + +#include +#include +#include +#include +#include "FNetBt_BluetoothSppAcceptorEvent.h" +#include "FNetBt_BluetoothSppAcceptorEventArg.h" +#include "FNetBtIBluetoothSppAcceptorEventListener.h" + + +using namespace Tizen::Base; + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +_BluetoothSppAcceptorEvent::_BluetoothSppAcceptorEvent(void) +{ +} + +_BluetoothSppAcceptorEvent::~_BluetoothSppAcceptorEvent(void) +{ +} + +result +_BluetoothSppAcceptorEvent::Construct(void) +{ + return _Event::Initialize(); +} + +void +_BluetoothSppAcceptorEvent::FireImpl(Tizen::Base::Runtime::IEventListener& listener, const Tizen::Base::Runtime::IEventArg& arg) +{ + const BluetoothDevice* pDevice = null; + ByteBuffer* pData = null; + + IBluetoothSppAcceptorEventListener* pListener = dynamic_cast (&listener); + SysTryReturnVoidResult(NID_NET_BT, pListener != null, E_INVALID_ARG, "[E_INVALID_ARG] The listener argument is invalid."); + + const _BluetoothSppAcceptorEventArg* pEventArg = dynamic_cast (&arg); + SysTryReturnVoidResult(NID_NET_BT, pEventArg != null, E_INVALID_ARG, "[E_INVALID_ARG] The event argument is invalid type."); + + _BluetoothSppAcceptorEventType eventType = pEventArg->GetEventType(); + + switch (eventType) + { + case _BT_SPP_ACCEPTOR_EVENT_CONN_REQUESTED: + pDevice = pEventArg->GetRequester(); + if (pDevice != null) + { + SysLog(NID_NET_BT, "Firing Bluetooth SPP Acceptor Event (Type: _BT_SPP_ACCEPTOR_EVENT_CONN_REQUESTED)"); + pListener->OnSppConnectionRequested(*pDevice); + } + break; + + case _BT_SPP_ACCEPTOR_EVENT_DISCONNECTED: + SysLog(NID_NET_BT, "Firing Bluetooth SPP Acceptor Event (Type: _BT_SPP_ACCEPTOR_EVENT_DISCONNECTED)"); + pListener->OnSppDisconnected(pEventArg->GetErrorResult()); + break; + + case _BT_SPP_ACCEPTOR_EVENT_DATA_RECEIVED: + pData = pEventArg->GetReceivedData(); + if (pData != null) + { + SysLog(NID_NET_BT, "Firing Bluetooth SPP Acceptor Event (Type: _BT_SPP_ACCEPTOR_EVENT_DATA_RECEIVED)"); + pListener->OnSppDataReceived(*pData); + } + break; + + default: + break; + } +} + +} } } // Tizen::Net::Bluetooth diff --git a/src/FNetBt_BluetoothSppAcceptorEvent.h b/src/FNetBt_BluetoothSppAcceptorEvent.h new file mode 100644 index 0000000..f200c99 --- /dev/null +++ b/src/FNetBt_BluetoothSppAcceptorEvent.h @@ -0,0 +1,78 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +/** + * @file FNetBt_BluetoothSppAcceptorEvent.h + * @brief This is the header file for the _BluetoothSppAcceptorEvent class. + * + * This header file contains the declarations of the _BluetoothSppAcceptorEvent class. + * The _BluetoothSppAcceptorEvent class can call a method of a listener (_IBluetoothSppAcceptorEventListener object). + * So, when a device event is occurred, listener instances can handle it appropriately. + */ +#ifndef _FNET_BT_INTERNAL_BLUETOOTH_SPP_ACCEPTOR_EVENT_H_ +#define _FNET_BT_INTERNAL_BLUETOOTH_SPP_ACCEPTOR_EVENT_H_ + +#include +#include +#include + +// Forward declaration +namespace Tizen { namespace Base { namespace Runtime +{ +class IEventListener; +class IEventArg; +} } } + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +// +// @class _BluetoothSppAcceptorEvent +// @brief This class handles Bluetooth SPP Acceptor events. +// +// When a Bluetooth device event occurs, the _BluetoothSppAcceptorEvent object finds a _IBluetoothSppAcceptorEventListener object +// and calls an appropriate method of the listener. +// +class _BluetoothSppAcceptorEvent + : public Tizen::Base::Runtime::_Event +{ +public: + _BluetoothSppAcceptorEvent(void); + virtual ~_BluetoothSppAcceptorEvent(void); + + result Construct(void); + +protected: + /** + * Checks the argument and finds out the type of event. After that, this method calls appropriate pListener's method. + * + * @return A result code. + * @param[in] pListener An event listener related to this Bluetooth SPP Acceptor event. + * @param[in] arg An event argument including information to be passed to the event listeners + * @exception E_SUCCESS The method is successful. + * @exception E_INVALID_ARG The argument passed to a method contains invalid values. + * @exception E_SYSTEM A system error occurred. + */ + virtual void FireImpl(Tizen::Base::Runtime::IEventListener& listener, const Tizen::Base::Runtime::IEventArg& arg); + +private: + _BluetoothSppAcceptorEvent(const _BluetoothSppAcceptorEvent& value); + _BluetoothSppAcceptorEvent& operator =(const _BluetoothSppAcceptorEvent& rhs); + +}; // _BluetoothSppAcceptorEvent + +} } } +#endif // _FNET_BT_INTERNAL_BLUETOOTH_SPP_ACCEPTOR_EVENT_H_ diff --git a/src/FNetBt_BluetoothSppAcceptorEventArg.cpp b/src/FNetBt_BluetoothSppAcceptorEventArg.cpp new file mode 100755 index 0000000..841ed81 --- /dev/null +++ b/src/FNetBt_BluetoothSppAcceptorEventArg.cpp @@ -0,0 +1,102 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// @file FNetBt_BluetoothSppAcceptorEventArg.cpp +// @brief This is the implementation file for the _BluetoothSppAcceptorEventArg class. +// + +#include +#include +#include +#include "FNetBt_BluetoothSppAcceptorEventArg.h" + + +using namespace Tizen::Base; + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +// +// This is a class constructor for _BT_SPP_ACCEPTOR_EVENT_CONN_REQUESTED event. +// +_BluetoothSppAcceptorEventArg::_BluetoothSppAcceptorEventArg(const BluetoothDevice& device) + : __evtType(_BT_SPP_ACCEPTOR_EVENT_CONN_REQUESTED) + , __pRequester(null) + , __result(E_SUCCESS) + , __pData(null) +{ + __pRequester = new (std::nothrow) BluetoothDevice(device); + SysTryReturnVoidResult(NID_NET_BT, __pRequester != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient."); +} + +// +// This is a class constructor for _BT_SPP_ACCEPTOR_EVENT_DISCONNECTED event. +// +_BluetoothSppAcceptorEventArg::_BluetoothSppAcceptorEventArg(result r) + : __evtType(_BT_SPP_ACCEPTOR_EVENT_DISCONNECTED) + , __pRequester(null) + , __result(r) + , __pData(null) +{ +} + +// +// This is a class constructor for _BT_SPP_ACCEPTOR_EVENT_DATA_RECEIVED event. +// +_BluetoothSppAcceptorEventArg::_BluetoothSppAcceptorEventArg(const Tizen::Base::ByteBuffer& buffer) + : __evtType(_BT_SPP_ACCEPTOR_EVENT_DATA_RECEIVED) + , __pRequester(null) + , __result(E_SUCCESS) + , __pData(null) +{ + __pData = new (std::nothrow) ByteBuffer(); + SysTryReturnVoidResult(NID_NET_BT, __pData != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient."); + + __pData->Construct(buffer); + __pData->SetPosition(0); +} + +_BluetoothSppAcceptorEventArg::~_BluetoothSppAcceptorEventArg(void) +{ + delete __pRequester; + delete __pData; +} + +_BluetoothSppAcceptorEventType +_BluetoothSppAcceptorEventArg::GetEventType(void) const +{ + return __evtType; +} + +const BluetoothDevice* +_BluetoothSppAcceptorEventArg::GetRequester(void) const +{ + return __pRequester; +} + +result +_BluetoothSppAcceptorEventArg::GetErrorResult(void) const +{ + return __result; +} + +Tizen::Base::ByteBuffer* +_BluetoothSppAcceptorEventArg::GetReceivedData(void) const +{ + return __pData; +} + +} } } // Tizen::Net::Bluetooth diff --git a/src/FNetBt_BluetoothSppAcceptorEventArg.h b/src/FNetBt_BluetoothSppAcceptorEventArg.h new file mode 100644 index 0000000..de30e57 --- /dev/null +++ b/src/FNetBt_BluetoothSppAcceptorEventArg.h @@ -0,0 +1,137 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +/** + * @file FNetBt_BluetoothSppAcceptorEventArg.h + * @brief This is the header file for the _BluetoothSppAcceptorEventArg class. + * + * This header file contains the declarations of the _BluetoothSppAcceptorEventArg class which includes information to be + * passed to the event listeners + */ +#ifndef _FNET_BT_INTERNAL_BLUETOOTH_SPP_ACCEPTOR_EVENT_ARG_H_ +#define _FNET_BT_INTERNAL_BLUETOOTH_SPP_ACCEPTOR_EVENT_ARG_H_ + +#include +#include +#include +#include + +// Forward declaration +namespace Tizen { namespace Base { +class ByteBuffer; +} } + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +// Forward declaration +class BluetoothDevice; + +/** + * @enum _BluetoothSppAcceptorEventType + * Type for specifying the type of _BluetoothSppAcceptorEvent + */ +enum _BluetoothSppAcceptorEventType +{ + _BT_SPP_ACCEPTOR_EVENT_CONN_REQUESTED, /**< For notifying that a new connection request is received */ + _BT_SPP_ACCEPTOR_EVENT_DISCONNECTED, /**< For notifying that the connection is disconnected */ + _BT_SPP_ACCEPTOR_EVENT_DATA_RECEIVED, /**< For notifying that the data has been received */ +}; + +/** + * @class _BluetoothSppAcceptorEventArg + * @brief This class is used as an argument for callback methods of the IBluetoothSppAcceptorEventListener class. + * + * When a _BluetoothSppAcceptorEvent occurs, the _BluetoothSppAcceptorEvent finds a IBluetoothSppAcceptorEventListener instance + * which is registered for the _BluetoothSppAcceptorEvent and calls an appropriate method of the listener. + * @see IBluetoothSppAcceptorEventListener + */ +class _BluetoothSppAcceptorEventArg + : public Tizen::Base::Object + , public Tizen::Base::Runtime::IEventArg +{ +public: + /** + * This is a class constructor for _BT_SPP_ACCEPTOR_EVENT_CONN_REQUESTED event. + * + * @param[in] device The SPP initiator device + */ + _BluetoothSppAcceptorEventArg(const BluetoothDevice& device); + + /** + * This is a class constructor for _BT_SPP_ACCEPTOR_EVENT_DISCONNECTED event. + * + * @param[in] r The result of the event + * @exception E_SUCCESS The connection is terminated successfully. + * @exception E_SYSTEM The method has failed to disconnect. + */ + _BluetoothSppAcceptorEventArg(result r); + + /** + * This is a class constructor for _BT_SPP_ACCEPTOR_EVENT_DATA_RECEIVED event. + * + * @param[in] buffer The received data + */ + _BluetoothSppAcceptorEventArg(const Tizen::Base::ByteBuffer& buffer); + + /** + * This is the class destructor. + */ + ~_BluetoothSppAcceptorEventArg(void); + + /** + * Gets the type of this event. + * + * @return The type of the event + */ + _BluetoothSppAcceptorEventType GetEventType(void) const; + + /** + * Gets the SPP initiator device. + * + * @return The pointer of the SPP initiator device which request to connect + */ + const BluetoothDevice* GetRequester(void) const; + + /** + * Gets the error result of this event. + * + * @return The result of the event + */ + result GetErrorResult(void) const; + + /** + * Gets The received data. + * + * @return The received data + */ + Tizen::Base::ByteBuffer* GetReceivedData(void) const; + +private: + _BluetoothSppAcceptorEventArg(void); + _BluetoothSppAcceptorEventArg(const _BluetoothSppAcceptorEventArg& eventArg); + _BluetoothSppAcceptorEventArg& operator =(const _BluetoothSppAcceptorEventArg& rValue); + +private: + _BluetoothSppAcceptorEventType __evtType; + BluetoothDevice* __pRequester; + result __result; + Tizen::Base::ByteBuffer* __pData; + +}; // _BluetoothSppAcceptorEventArg + +} } } +#endif // _FNET_BT_INTERNAL_BLUETOOTH_SPP_ACCEPTOR_EVENT_ARG_H_ diff --git a/src/FNetBt_BluetoothSppAcceptorImpl.cpp b/src/FNetBt_BluetoothSppAcceptorImpl.cpp new file mode 100755 index 0000000..fcbfc48 --- /dev/null +++ b/src/FNetBt_BluetoothSppAcceptorImpl.cpp @@ -0,0 +1,642 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// @file FNetBt_BluetoothSppAcceptorImpl.cpp +// @brief This is the implementation file for the _BluetoothSppAcceptorImpl class. +// + +#include +#include +#include +#include +#include +#include +#include +#include "FNetBt_BluetoothSppAcceptorEvent.h" +#include "FNetBt_BluetoothSppAcceptorEventArg.h" +#include "FNetBt_BluetoothSppAcceptorImpl.h" +#include "FNetBt_BluetoothSppSystemAdapter.h" +#include "FNetBt_BluetoothGapSystemAdapter.h" + +using namespace std; +using namespace Tizen::Base; +using namespace Tizen::Base::Runtime; + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +_BluetoothSppAcceptorImpl::_BluetoothSppAcceptorImpl(void) + : __pGapAdapter(null) + , __pSppAdapter(null) + , __pEvent(null) + , __stateMutex() + , __currentState(_BT_SPP_ACC_STATE_DISABLED) + , __parentSocketFd(_BT_INVALID_SOCKET_FD) + , __childSocketFd(_BT_INVALID_SOCKET_FD) +{ +} + +_BluetoothSppAcceptorImpl::~_BluetoothSppAcceptorImpl(void) +{ + if (__pSppAdapter != null) + { + if ((__currentState == _BT_SPP_ACC_STATE_ON_SERVICE) || + (__currentState == _BT_SPP_ACC_STATE_CONNECT_REQUESTED) || + (__currentState == _BT_SPP_ACC_STATE_CONNECTED)) + { + (void) StopService(); // Ignores the result of this function. + } + } + + if (__pGapAdapter != null) + { + __pGapAdapter->UnregisterManagerEventListener(*this); + } +} + +result +_BluetoothSppAcceptorImpl::Construct(IBluetoothSppAcceptorEventListener& listener) +{ + result r = E_SUCCESS; + std::unique_ptr<_BluetoothSppAcceptorEvent> pEvent; + + r = __stateMutex.Create(); + SysTryReturn(NID_NET_BT, r == E_SUCCESS, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Failed to create the state mutex."); + + __pGapAdapter = _BluetoothGapSystemAdapter::GetInstance(); + SysTryReturn(NID_NET_BT, __pGapAdapter != null, E_SYSTEM, E_SYSTEM, + "[E_SYSTEM] Failed to invoke _BluetoothGapSystemAdapter::GetInstance()."); + + __pSppAdapter = _BluetoothSppSystemAdapter::GetInstance(); + SysTryReturn(NID_NET_BT, __pSppAdapter != null, E_SYSTEM, E_SYSTEM, + "[E_SYSTEM] Failed to invoke _BluetoothSppSystemAdapter::GetInstance()."); + + pEvent.reset(new (std::nothrow) _BluetoothSppAcceptorEvent()); + SysTryReturn(NID_NET_BT, pEvent != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient."); + r = pEvent->Construct(); + SysTryReturn(NID_NET_BT, r == E_SUCCESS, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Failed to construct the event."); + // add the IBluetoothSppAcceptorEventListener instance to a new created _BluetoothSppAcceptorEvent. + r = pEvent->AddListener(listener, true); + SysTryReturn(NID_NET_BT, r == E_SUCCESS, E_SYSTEM, E_SYSTEM, + "[%s] Propagating. Failed to add the application listener for SPP Acceptor", GetErrorMessage(r)); + + // registers this callback listener to the system adapter for activation/deactivation event + r = __pGapAdapter->RegisterManagerEventListener(*this, true); + SysTryReturn(NID_NET_BT, r == E_SUCCESS, E_SYSTEM, E_SYSTEM, + "[E_SYSTEM] Failed to register the callback listener to _BluetoothGapSystemAdapter."); + + // check whether the Bluetooth is available + __stateMutex.Acquire(); + + if (__pGapAdapter->IsActivated() == true) + { + __currentState = _BT_SPP_ACC_STATE_IDLE; + } + + __stateMutex.Release(); + + __pEvent = move(pEvent); + + return E_SUCCESS; +} + +result +_BluetoothSppAcceptorImpl::AcceptConnection(void) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s]", GetStringOfCurrentState()); + + result r = E_SUCCESS; + int clientSocketFd = _BT_INVALID_SOCKET_FD; + + __stateMutex.Acquire(); + + switch (__currentState) + { + case _BT_SPP_ACC_STATE_DISABLED: + r = E_INVALID_STATE; + break; + + case _BT_SPP_ACC_STATE_IDLE: + case _BT_SPP_ACC_STATE_ON_SERVICE: + case _BT_SPP_ACC_STATE_CONNECTED: + r = E_INVALID_OPERATION; + break; + + case _BT_SPP_ACC_STATE_CONNECT_REQUESTED: + r = __pSppAdapter->AcceptSocketRequest(__parentSocketFd, clientSocketFd); + + if (r == E_SUCCESS) + { + __currentState = _BT_SPP_ACC_STATE_CONNECTED; + __childSocketFd = clientSocketFd; + } + else + { + __currentState = _BT_SPP_ACC_STATE_ON_SERVICE; + } + break; + + default: + r = E_FAILURE; + break; + } + + __stateMutex.Release(); + + if (r != E_SUCCESS) + { + SysLogException(NID_NET_BT, r, "[%s] exception occurred on accepting a connection request.", GetErrorMessage(r)); + } + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [ActionResult:%s]", GetStringOfCurrentState(), GetErrorMessage(r)); + + return r; +} + +result +_BluetoothSppAcceptorImpl::RejectConnection() +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s]", GetStringOfCurrentState()); + + result r = E_SUCCESS; + + __stateMutex.Acquire(); + + switch (__currentState) + { + case _BT_SPP_ACC_STATE_DISABLED: + r = E_INVALID_STATE; + break; + + case _BT_SPP_ACC_STATE_IDLE: + case _BT_SPP_ACC_STATE_ON_SERVICE: + case _BT_SPP_ACC_STATE_CONNECTED: + r = E_INVALID_OPERATION; + break; + + case _BT_SPP_ACC_STATE_CONNECT_REQUESTED: + r = __pSppAdapter->RejectSocketRequest(__parentSocketFd); + __currentState = _BT_SPP_ACC_STATE_ON_SERVICE; + break; + + default: + r = E_FAILURE; + break; + } + + __stateMutex.Release(); + + if (r != E_SUCCESS) + { + SysLogException(NID_NET_BT, r, "[%s] exception occurred on rejecting a connection request.", GetErrorMessage(r)); + } + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [ActionResult:%s]", GetStringOfCurrentState(), GetErrorMessage(r)); + + return r; +} + +result +_BluetoothSppAcceptorImpl::StartService(const Tizen::Base::UuId& serviceUuid) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s]", GetStringOfCurrentState()); + + result r = E_SUCCESS; + int serverSocketFd = _BT_INVALID_SOCKET_FD; + + __stateMutex.Acquire(); + + switch (__currentState) + { + case _BT_SPP_ACC_STATE_DISABLED: + r = E_INVALID_STATE; + break; + + case _BT_SPP_ACC_STATE_IDLE: + r = __pSppAdapter->OpenServerSocket(serviceUuid, *this, serverSocketFd); + if (r == E_SUCCESS) + { + __currentState = _BT_SPP_ACC_STATE_ON_SERVICE; + __parentSocketFd = serverSocketFd; + } + break; + + case _BT_SPP_ACC_STATE_ON_SERVICE: + case _BT_SPP_ACC_STATE_CONNECT_REQUESTED: + r = E_IN_PROGRESS; + break; + + case _BT_SPP_ACC_STATE_CONNECTED: + r = E_ALREADY_CONNECTED; + break; + + default: + r = E_FAILURE; + break; + } + + __stateMutex.Release(); + + if (r != E_SUCCESS) + { + SysLogException(NID_NET_BT, r, "[%s] exception occurred on starting SPP service.", GetErrorMessage(r)); + } + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [ActionResult:%s]", GetStringOfCurrentState(), GetErrorMessage(r)); + + return r; +} + +result +_BluetoothSppAcceptorImpl::StopService(void) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s]", GetStringOfCurrentState()); + + result r = E_SUCCESS; + result resDisconnect = E_SUCCESS; + + __stateMutex.Acquire(); + + switch (__currentState) + { + case _BT_SPP_ACC_STATE_DISABLED: + r = E_INVALID_STATE; + break; + + case _BT_SPP_ACC_STATE_IDLE: + r = E_INVALID_OPERATION; + break; + + case _BT_SPP_ACC_STATE_ON_SERVICE: + r = __pSppAdapter->CloseServerSocket(__parentSocketFd); + if (r == E_SUCCESS) + { + __currentState = _BT_SPP_ACC_STATE_IDLE; + __parentSocketFd = _BT_INVALID_SOCKET_FD; + } + break; + + // Stays in the current status, if StopSppServer() fails + case _BT_SPP_ACC_STATE_CONNECT_REQUESTED: + r = __pSppAdapter->RejectSocketRequest(__parentSocketFd); + if (r == E_SUCCESS) + { + r = __pSppAdapter->CloseServerSocket(__parentSocketFd); + if (r == E_SUCCESS) + { + __currentState = _BT_SPP_ACC_STATE_IDLE; + __parentSocketFd = _BT_INVALID_SOCKET_FD; + } + else + { + __currentState = _BT_SPP_ACC_STATE_ON_SERVICE; + } + } + break; + + case _BT_SPP_ACC_STATE_CONNECTED: + resDisconnect = ProcessAsyncDisconnect(); + // stop server socket regardless whether disconnection is successful + r = __pSppAdapter->CloseServerSocket(__parentSocketFd); + if (r == E_SUCCESS) + { + __currentState = _BT_SPP_ACC_STATE_IDLE; + __parentSocketFd = _BT_INVALID_SOCKET_FD; + } + else if (resDisconnect == E_SUCCESS) + { + __currentState = _BT_SPP_ACC_STATE_ON_SERVICE; + } + break; + + default: + r = E_FAILURE; + break; + } + + __stateMutex.Release(); + + if (r != E_SUCCESS) + { + SysLogException(NID_NET_BT, r, "[%s] exception occurred on stopping SPP service.", GetErrorMessage(r)); + } + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [ActionResult:%s]", GetStringOfCurrentState(), GetErrorMessage(r)); + + return r; +} + +result +_BluetoothSppAcceptorImpl::SendData(const Tizen::Base::ByteBuffer& buffer) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s]", GetStringOfCurrentState()); + + result r = E_SUCCESS; + + __stateMutex.Acquire(); + + switch (__currentState) + { + case _BT_SPP_ACC_STATE_DISABLED: + r = E_INVALID_STATE; + break; + + case _BT_SPP_ACC_STATE_IDLE: + case _BT_SPP_ACC_STATE_ON_SERVICE: + case _BT_SPP_ACC_STATE_CONNECT_REQUESTED: + r = E_INVALID_OPERATION; + break; + + case _BT_SPP_ACC_STATE_CONNECTED: + if (buffer.GetRemaining() > 0) + { + r = __pSppAdapter->SendSocketData(__childSocketFd, buffer); + } + else + { + r = E_INVALID_ARG; + } + break; + + default: + r = E_FAILURE; + break; + } + + __stateMutex.Release(); + + if (r != E_SUCCESS) + { + SysLogException(NID_NET_BT, r, "[%s] exception occurred on sending data.", GetErrorMessage(r)); + } + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [ActionResult:%s]", GetStringOfCurrentState(), GetErrorMessage(r)); + + return r; +} + +result +_BluetoothSppAcceptorImpl::Disconnect() +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s]", GetStringOfCurrentState()); + + result r = E_SUCCESS; + + __stateMutex.Acquire(); + + switch (__currentState) + { + case _BT_SPP_ACC_STATE_DISABLED: + r = E_INVALID_STATE; + break; + + case _BT_SPP_ACC_STATE_IDLE: + case _BT_SPP_ACC_STATE_ON_SERVICE: + case _BT_SPP_ACC_STATE_CONNECT_REQUESTED: + r = E_INVALID_OPERATION; + break; + + case _BT_SPP_ACC_STATE_CONNECTED: + // send a disconnected event here if the disconnect method is successful + // because the disconnect method of the underlying system is sync call. (transform sync into async) + r = ProcessAsyncDisconnect(); + if (r == E_SUCCESS) + { + __currentState = _BT_SPP_ACC_STATE_ON_SERVICE; + } + break; + + default: + r = E_FAILURE; + break; + } + + __stateMutex.Release(); + + if (r != E_SUCCESS) + { + SysLogException(NID_NET_BT, r, "[%s] exception occurred on disconnecting the connection.", GetErrorMessage(r)); + } + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [ActionResult:%s]", GetStringOfCurrentState(), GetErrorMessage(r)); + + return r; +} + +void +_BluetoothSppAcceptorImpl::OnBluetoothActivated(result r) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s], [ActionResult:%s]", GetStringOfCurrentState(), GetErrorMessage(r)); + + __stateMutex.Acquire(); + + if ((__currentState == _BT_SPP_ACC_STATE_DISABLED) && (r == E_SUCCESS)) + { + __currentState = _BT_SPP_ACC_STATE_IDLE; + } + __stateMutex.Release(); + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s]", GetStringOfCurrentState()); +} + +void +_BluetoothSppAcceptorImpl::OnBluetoothDeactivated(result r) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s], [ActionResult:%s]", GetStringOfCurrentState(), GetErrorMessage(r)); + + __stateMutex.Acquire(); + + if (r == E_SUCCESS) + { + __currentState = _BT_SPP_ACC_STATE_DISABLED; + } + + __stateMutex.Release(); + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s]", GetStringOfCurrentState()); +} + +void +_BluetoothSppAcceptorImpl::OnSocketConnectionRequested(const BluetoothDevice& device) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s]", GetStringOfCurrentState()); + + bool isFired = false; + + __stateMutex.Acquire(); + + if (__currentState == _BT_SPP_ACC_STATE_ON_SERVICE) + { + __currentState = _BT_SPP_ACC_STATE_CONNECT_REQUESTED; + isFired = true; + } + else if ((__currentState == _BT_SPP_ACC_STATE_CONNECT_REQUESTED) || + (__currentState == _BT_SPP_ACC_STATE_CONNECTED)) + { + (void) __pSppAdapter->RejectSocketRequest(__parentSocketFd); + } + // ignore othre cases + + __stateMutex.Release(); + + if (isFired) + { + _BluetoothSppAcceptorEventArg* pArg = new (std::nothrow) _BluetoothSppAcceptorEventArg(device); + if (pArg == null) + { + SysLogException(NID_NET_BT, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient."); + isFired = false; + } + else + { + __pEvent->FireAsync(*pArg); + } + } + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [CONNECT_REQUESTED_Event:%s]", + GetStringOfCurrentState(), isFired ? "Fired" : "NotFired"); +} + +void +_BluetoothSppAcceptorImpl::OnSocketDisconnected(result r) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s], [ActionResult:%s]", GetStringOfCurrentState(), GetErrorMessage(r)); + + bool isFired = false; + + __stateMutex.Acquire(); + + if ((__currentState == _BT_SPP_ACC_STATE_CONNECT_REQUESTED) || + (__currentState == _BT_SPP_ACC_STATE_CONNECTED)) + { + if (r == E_SUCCESS) + { + __currentState = _BT_SPP_ACC_STATE_ON_SERVICE; + __childSocketFd = _BT_INVALID_SOCKET_FD; + + isFired = true; + } + } + // ignore other cases + + __stateMutex.Release(); + + if (isFired) + { + _BluetoothSppAcceptorEventArg* pArg = new (std::nothrow) _BluetoothSppAcceptorEventArg(r); + if (pArg == null) + { + SysLogException(NID_NET_BT, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient."); + isFired = false; + } + else + { + __pEvent->FireAsync(*pArg); + if (r != E_SUCCESS) + { + SysLogException(NID_NET_BT, r, "[%s] exception occurred on SPP-disconnect callback.", GetErrorMessage(r)); + } + } + } + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [DISCONNECTED_Event:%s]", + GetStringOfCurrentState(), isFired ? "Fired" : "NotFired"); +} + +void +_BluetoothSppAcceptorImpl::OnSocketDataReceived(Tizen::Base::ByteBuffer& buffer) +{ + bool isFired = false; + + if (__currentState == _BT_SPP_ACC_STATE_CONNECTED) + { + _BluetoothSppAcceptorEventArg* pArg = new (std::nothrow) _BluetoothSppAcceptorEventArg(buffer); + if (pArg == null) + { + SysLogException(NID_NET_BT, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient."); + } + else + { + // use Fire() instead of FireAsync() to improve the transfer rate. + __pEvent->Fire(*pArg); + isFired = true; + } + } + + SysLog(NID_NET_BT, "[CurrentState:%s], [DATA_RECEIVED_Event:%s]", + GetStringOfCurrentState(), isFired ? "Fired" : "NotFired"); +} + +result +_BluetoothSppAcceptorImpl::ProcessAsyncDisconnect(void) +{ + result r = E_SUCCESS; + + r = __pSppAdapter->DisconnectSocket(__childSocketFd); + + // send a disconnected event here if the disconnect method is successful + // because the disconnect method of the underlying system is sync call. (transform sync into async) + if (r == E_SUCCESS) + { + __childSocketFd = _BT_INVALID_SOCKET_FD; + + _BluetoothSppAcceptorEventArg* pArg = new (std::nothrow) _BluetoothSppAcceptorEventArg(r); + if (pArg != null) + { + __pEvent->FireAsync(*pArg); + SysLog(NID_NET_BT, "[DISCONNECTED_Event:Fired]"); + } + } + + return r; +} + +const char* +_BluetoothSppAcceptorImpl::GetStringOfCurrentState(void) const +{ + const char* pStateString = null; + + switch (__currentState) + { + case _BT_SPP_ACC_STATE_DISABLED: + pStateString = "DISABLED"; + break; + + case _BT_SPP_ACC_STATE_IDLE: + pStateString = "IDLE"; + break; + + case _BT_SPP_ACC_STATE_ON_SERVICE: + pStateString = "ON_SERVICE"; + break; + + case _BT_SPP_ACC_STATE_CONNECT_REQUESTED: + pStateString = "CONNECT_REQUESTED"; + break; + + case _BT_SPP_ACC_STATE_CONNECTED: + pStateString = "CONNECTED"; + break; + + default: + pStateString = "Unknown"; + break; + } + + return pStateString; +} + +} } } // Tizen::Net::Bluetooth diff --git a/src/FNetBt_BluetoothSppInitiatorEvent.cpp b/src/FNetBt_BluetoothSppInitiatorEvent.cpp new file mode 100644 index 0000000..e96c6c2 --- /dev/null +++ b/src/FNetBt_BluetoothSppInitiatorEvent.cpp @@ -0,0 +1,89 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// @file FNetBt_BluetoothSppInitiatorEvent.cpp +// @brief This is the implementation file for the _BluetoothSppInitiatorEvent class. +// + +#include +#include +#include +#include +#include "FNetBt_BluetoothSppInitiatorEvent.h" +#include "FNetBt_BluetoothSppInitiatorEventArg.h" +#include "FNetBtIBluetoothSppInitiatorEventListener.h" + + +using namespace Tizen::Base; + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +_BluetoothSppInitiatorEvent::_BluetoothSppInitiatorEvent(void) +{ +} + +_BluetoothSppInitiatorEvent::~_BluetoothSppInitiatorEvent(void) +{ +} + +result +_BluetoothSppInitiatorEvent::Construct(void) +{ + return _Event::Initialize(); +} + +void +_BluetoothSppInitiatorEvent::FireImpl(Tizen::Base::Runtime::IEventListener& listener, const Tizen::Base::Runtime::IEventArg& arg) +{ + ByteBuffer* pData = null; + + IBluetoothSppInitiatorEventListener* pListener = dynamic_cast (&listener); + SysTryReturnVoidResult(NID_NET_BT, pListener != null, E_INVALID_ARG, + "[E_INVALID_ARG] The listener argument is invalid."); + + const _BluetoothSppInitiatorEventArg* pEventArg = dynamic_cast (&arg); + SysTryReturnVoidResult(NID_NET_BT, pEventArg != null, E_INVALID_ARG, "[E_INVALID_ARG] The event argument is invalid type."); + + _BluetoothSppInitiatorEventType eventType = pEventArg->GetEventType(); + + switch (eventType) + { + case _BT_SPP_INITIATOR_EVENT_CONN_RESPONDED: + SysLog(NID_NET_BT, "Firing Bluetooth SPP Initiator Event (Type: _BT_SPP_INITIATOR_EVENT_CONN_RESPONDED)"); + pListener->OnSppConnectionResponded(pEventArg->GetErrorResult()); + break; + + case _BT_SPP_INITIATOR_EVENT_DISCONNECTED: + SysLog(NID_NET_BT, "Firing Bluetooth SPP Initiator Event (Type: _BT_SPP_INITIATOR_EVENT_DISCONNECTED)"); + pListener->OnSppDisconnected(pEventArg->GetErrorResult()); + break; + + case _BT_SPP_INITIATOR_EVENT_DATA_RECEIVED: + pData = pEventArg->GetReceivedData(); + if (pData != null) + { + SysLog(NID_NET_BT, "Firing Bluetooth SPP Initiator Event (Type: _BT_SPP_INITIATOR_EVENT_DATA_RECEIVED)"); + pListener->OnSppDataReceived(*pData); + } + break; + + default: + break; + } +} + +} } } // Tizen::Net::Bluetooth diff --git a/src/FNetBt_BluetoothSppInitiatorEvent.h b/src/FNetBt_BluetoothSppInitiatorEvent.h new file mode 100644 index 0000000..c5dd923 --- /dev/null +++ b/src/FNetBt_BluetoothSppInitiatorEvent.h @@ -0,0 +1,78 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +/** + * @file FNetBt_BluetoothSppInitiatorEvent.h + * @brief This is the header file for the _BluetoothSppInitiatorEvent class. + * + * This header file contains the declarations of the _BluetoothSppInitiatorEvent class. + * The _BluetoothSppInitiatorEvent class can call a method of a listener (IBluetoothSppInitiatorEventListener object). + * So, when a device event is occurred, listener instances can handle it appropriately. + */ +#ifndef _FNET_BT_INTERNAL_BLUETOOTH_SPP_INITIATOR_EVENT_H_ +#define _FNET_BT_INTERNAL_BLUETOOTH_SPP_INITIATOR_EVENT_H_ + +#include +#include +#include + +// Forward declaration +namespace Tizen { namespace Base { namespace Runtime +{ +class IEventListener; +class IEventArg; +} } } + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +// +// @class _BluetoothSppInitiatorEvent +// @brief This class handles Bluetooth SPP Initiator events. +// +// When a Bluetooth device event occurs, the _BluetoothSppInitiatorEvent object finds a IBluetoothSppInitiatorEventListener +// object and calls an appropriate method of the listener. +// +class _BluetoothSppInitiatorEvent + : public Tizen::Base::Runtime::_Event +{ +public: + _BluetoothSppInitiatorEvent(void); + virtual ~_BluetoothSppInitiatorEvent(void); + + result Construct(void); + +protected: + /** + * Checks the argument and finds out the type of event. After that, this method calls appropriate pListener's method. + * + * @return A result code. + * @param[in] pListener An event listener related to this Bluetooth SPP Initiator event. + * @param[in] arg An event argument including information to be passed to the event listeners + * @exception E_SUCCESS The method is successful. + * @exception E_INVALID_ARG The argument passed to a method contains invalid values. + * @exception E_SYSTEM A system error occurred. + */ + virtual void FireImpl(Tizen::Base::Runtime::IEventListener& listener, const Tizen::Base::Runtime::IEventArg& arg); + +private: + _BluetoothSppInitiatorEvent(const _BluetoothSppInitiatorEvent& value); + _BluetoothSppInitiatorEvent& operator =(const _BluetoothSppInitiatorEvent& rhs); + +}; // _BluetoothSppInitiatorEvent + +} } } +#endif // _FNET_BT_INTERNAL_BLUETOOTH_SPP_INITIATOR_EVENT_H_ diff --git a/src/FNetBt_BluetoothSppInitiatorEventArg.cpp b/src/FNetBt_BluetoothSppInitiatorEventArg.cpp new file mode 100755 index 0000000..530bd76 --- /dev/null +++ b/src/FNetBt_BluetoothSppInitiatorEventArg.cpp @@ -0,0 +1,84 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// @file FNetBt_BluetoothSppInitiatorEventArg.cpp +// @brief This is the implementation file for the _BluetoothSppInitiatorEventArg class. +// + +#include +#include +#include +#include "FNetBt_BluetoothSppInitiatorEventArg.h" + + +using namespace Tizen::Base; + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +// +// This is a class constructor for _BT_SPP_INITIATOR_EVENT_CONN_RESPONDED and _BT_SPP_INITIATOR_EVENT_DISCONNECTED event. +// +_BluetoothSppInitiatorEventArg::_BluetoothSppInitiatorEventArg(bool isResponse, result r) + : __evtType(_BT_SPP_INITIATOR_EVENT_CONN_RESPONDED) + , __result(r) + , __pData(null) +{ + if (!isResponse) + { + __evtType = _BT_SPP_INITIATOR_EVENT_DISCONNECTED; + } +} + +// +// This is a class constructor for _BT_SPP_INITIATOR_EVENT_DATA_RECEIVED event. +// +_BluetoothSppInitiatorEventArg::_BluetoothSppInitiatorEventArg(const Tizen::Base::ByteBuffer& buffer) + : __evtType(_BT_SPP_INITIATOR_EVENT_DATA_RECEIVED) + , __result(E_SUCCESS) + , __pData(null) +{ + __pData = new (std::nothrow) ByteBuffer(); + SysTryReturnVoidResult(NID_NET_BT, __pData != null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient."); + + __pData->Construct(buffer); + __pData->SetPosition(0); +} + +_BluetoothSppInitiatorEventArg::~_BluetoothSppInitiatorEventArg(void) +{ + delete __pData; +} + +_BluetoothSppInitiatorEventType +_BluetoothSppInitiatorEventArg::GetEventType(void) const +{ + return __evtType; +} + +result +_BluetoothSppInitiatorEventArg::GetErrorResult(void) const +{ + return __result; +} + +Tizen::Base::ByteBuffer* +_BluetoothSppInitiatorEventArg::GetReceivedData(void) const +{ + return __pData; +} + +} } } // Tizen::Net::Bluetooth diff --git a/src/FNetBt_BluetoothSppInitiatorEventArg.h b/src/FNetBt_BluetoothSppInitiatorEventArg.h new file mode 100644 index 0000000..b98a76d --- /dev/null +++ b/src/FNetBt_BluetoothSppInitiatorEventArg.h @@ -0,0 +1,124 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +/** + * @file FNetBt_BluetoothSppInitiatorEventArg.h + * @brief This is the header file for the _BluetoothSppInitiatorEventArg class. + * + * This header file contains the declarations of the _BluetoothSppInitiatorEventArg class which includes information to be + * passed to the event listeners + */ +#ifndef _FNET_BT_INTERNAL_BLUETOOTH_SPP_INITIATOR_EVENT_ARG_H_ +#define _FNET_BT_INTERNAL_BLUETOOTH_SPP_INITIATOR_EVENT_ARG_H_ + +#include +#include +#include +#include + +// Forward declaration +namespace Tizen { namespace Base { +class ByteBuffer; +} } + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +// Forward declaration +class BluetoothDevice; + +/** + * @enum _BluetoothSppInitiatorEventType + * Type for specifying the type of _BluetoothSppInitiatorEvent + */ +enum _BluetoothSppInitiatorEventType +{ + _BT_SPP_INITIATOR_EVENT_CONN_RESPONDED, /**< For notifying that the response of the connection request is received */ + _BT_SPP_INITIATOR_EVENT_DISCONNECTED, /**< For notifying that the connection is disconnected */ + _BT_SPP_INITIATOR_EVENT_DATA_RECEIVED, /**< For notifying that the data has been received */ +}; + +/** + * @class _BluetoothSppInitiatorEventArg + * @brief This class is used as an argument for callback methods of the _IBluetoothSppInitiatorEventListener class. + * + * When a _BluetoothSppInitiatorEvent occurs, the _BluetoothSppInitiatorEvent finds a _IBluetoothSppInitiatorEventListener instance + * which is registered for the _BluetoothSppInitiatorEvent and calls an appropriate method of the listener. + * @see _IBluetoothSppInitiatorEventListener + */ +class _BluetoothSppInitiatorEventArg + : public Tizen::Base::Object + , public Tizen::Base::Runtime::IEventArg +{ +public: + /** + * This is a class constructor for _BT_SPP_INITIATOR_EVENT_CONN_RESPONDED and _BT_SPP_INITIATOR_EVENT_DISCONNECTED event. + * + * @param[in] isResponse @c true if the event is a connection response, + * else @c false + * @param[in] r The result of the event + * @exception E_SUCCESS The connection is established successfully. + * @exception E_SYSTEM The connection fails. + */ + _BluetoothSppInitiatorEventArg(bool isResponse, result r); + + /** + * This is a class constructor for _BT_SPP_INITIATOR_EVENT_DATA_RECEIVED event. + * + * @param[in] buffer The received data + */ + _BluetoothSppInitiatorEventArg(const Tizen::Base::ByteBuffer& buffer); + + /** + * This is the class destructor. + */ + ~_BluetoothSppInitiatorEventArg(void); + + /** + * Gets the type of this event. + * + * @return The type of the event + */ + _BluetoothSppInitiatorEventType GetEventType(void) const; + + /** + * Gets the error result of this event. + * + * @return The result of the event + */ + result GetErrorResult(void) const; + + /** + * Gets The received data. + * + * @return The received data + */ + Tizen::Base::ByteBuffer* GetReceivedData(void) const; + +private: + _BluetoothSppInitiatorEventArg(void); + _BluetoothSppInitiatorEventArg(const _BluetoothSppInitiatorEventArg& eventArg); + _BluetoothSppInitiatorEventArg& operator =(const _BluetoothSppInitiatorEventArg& rValue); + +private: + _BluetoothSppInitiatorEventType __evtType; + result __result; + Tizen::Base::ByteBuffer* __pData; + +}; // _BluetoothSppInitiatorEventArg + +} } } +#endif // _FNET_BT_INTERNAL_BLUETOOTH_SPP_INITIATOR_EVENT_ARG_H_ diff --git a/src/FNetBt_BluetoothSppInitiatorImpl.cpp b/src/FNetBt_BluetoothSppInitiatorImpl.cpp new file mode 100755 index 0000000..5614e57 --- /dev/null +++ b/src/FNetBt_BluetoothSppInitiatorImpl.cpp @@ -0,0 +1,608 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// @file FNetBt_BluetoothSppInitiatorImpl.cpp +// @brief This is the implementation file for the _BluetoothSppInitiatorImpl class. +// + +#include +#include +#include +#include +#include +#include +#include "FNetBt_BluetoothSppInitiatorEvent.h" +#include "FNetBt_BluetoothSppInitiatorEventArg.h" +#include "FNetBt_BluetoothGapSystemAdapter.h" +#include "FNetBt_BluetoothSppSystemAdapter.h" +#include "FNetBt_BluetoothSppInitiatorImpl.h" + +using namespace std; +using namespace Tizen::Base; +using namespace Tizen::Base::Runtime; + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +_BluetoothSppInitiatorImpl::_BluetoothSppInitiatorImpl(void) + : __pGapAdapter(null) + , __pSppAdapter(null) + , __pEvent(null) + , __stateMutex() + , __currentState(_BT_SPP_INI_STATE_DISABLED) + , __pairingAddress() + , __pairingUuid() + , __socketFd(_BT_INVALID_SOCKET_FD) +{ +} + +_BluetoothSppInitiatorImpl::~_BluetoothSppInitiatorImpl(void) +{ + if (__pSppAdapter != null) + { + if ((__currentState == _BT_SPP_INI_STATE_BONDING) + || (__currentState == _BT_SPP_INI_STATE_CONNECT_READY) + || (__currentState == _BT_SPP_INI_STATE_CONNECTED)) + { + (void) ProcessAsyncDisconnect(); // Ignores the result of this function. + } + } + + if (__pGapAdapter != null) + { + __pGapAdapter->UnregisterManagerEventListener(*this); + __pGapAdapter->UnregisterDeviceEventListener(*this); + } +} + +result +_BluetoothSppInitiatorImpl::Construct(IBluetoothSppInitiatorEventListener& listener) +{ + result r = E_SUCCESS; + std::unique_ptr<_BluetoothSppInitiatorEvent> pEvent; + + r = __stateMutex.Create(); + SysTryReturn(NID_NET_BT, r == E_SUCCESS, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Failed to create the state mutex."); + + r = __pairingAddress.Construct(_BT_ADDRESS_LENGTH); + SysTryReturn(NID_NET_BT, r == E_SUCCESS, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Failed to construct the address for pairing."); + + __pGapAdapter = _BluetoothGapSystemAdapter::GetInstance(); + SysTryReturn(NID_NET_BT, __pGapAdapter != null, E_SYSTEM, E_SYSTEM, + "[E_SYSTEM] Failed to invoke _BluetoothGapSystemAdapter::GetInstance()."); + + __pSppAdapter = _BluetoothSppSystemAdapter::GetInstance(); + SysTryReturn(NID_NET_BT, __pSppAdapter != null, E_SYSTEM, E_SYSTEM, + "[E_SYSTEM] Failed to invoke _BluetoothSppSystemAdapter::GetInstance()."); + + pEvent.reset(new (std::nothrow) _BluetoothSppInitiatorEvent()); + SysTryReturn(NID_NET_BT, pEvent != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient."); + pEvent->Construct(); + SysTryReturn(NID_NET_BT, r == E_SUCCESS, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Failed to construct the event."); + // add the IBluetoothSppInitiatorEventListener instance to a new created _BluetoothSppInitiatorEvent. + r = pEvent->AddListener(listener, true); + SysTryReturn(NID_NET_BT, r == E_SUCCESS, E_SYSTEM, E_SYSTEM, + "[%s] Propagating. Failed to add the application listener for SPP Initiator", GetErrorMessage(r)); + + // registers this callback listener to the system adapter for activation/deactivation event + r = __pGapAdapter->RegisterManagerEventListener(*this, true); + SysTryReturn(NID_NET_BT, r == E_SUCCESS, E_SYSTEM, E_SYSTEM, + "[E_SYSTEM] Failed to register the callback listener to _BluetoothGapSystemAdapter."); + + // registers this callback listener to the system adapter for paired event + r = __pGapAdapter->RegisterDeviceEventListener(*this); + if (r != E_SUCCESS) + { + __pGapAdapter->UnregisterManagerEventListener(*this); + } + SysTryReturn(NID_NET_BT, r == E_SUCCESS, E_SYSTEM, E_SYSTEM, + "[E_SYSTEM] Failed to register the callback listener to _BluetoothGapSystemAdapter."); + + // checks whether the Bluetooth is available + __stateMutex.Acquire(); + + if (__pGapAdapter->IsActivated() == true) + { + __currentState = _BT_SPP_INI_STATE_IDLE; + } + + __stateMutex.Release(); + + __pEvent = move(pEvent); + + return E_SUCCESS; +} + +result +_BluetoothSppInitiatorImpl::SendData(const Tizen::Base::ByteBuffer& buffer) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s]", GetStringOfCurrentState()); + + result r = E_FAILURE; + + __stateMutex.Acquire(); + + switch (__currentState) + { + case _BT_SPP_INI_STATE_DISABLED: + r = E_INVALID_STATE; + break; + + case _BT_SPP_INI_STATE_IDLE: + case _BT_SPP_INI_STATE_BONDING: //TODO: this state should return E_INVALID_OPERATION. Versioning + case _BT_SPP_INI_STATE_CONNECT_READY: + case _BT_SPP_INI_STATE_REQ_CANCELING: //TODO: this state should return E_INVALID_OPERATION. Versioning + r = E_INVALID_OPERATION; + break; + + case _BT_SPP_INI_STATE_CONNECTED: + if (buffer.GetRemaining() > 0) + { + r = __pSppAdapter->SendSocketData(__socketFd, buffer); + } + else + { + r = E_INVALID_ARG; + } + break; + + default: + r = E_FAILURE; + break; + } + + __stateMutex.Release(); + + if (r != E_SUCCESS) + { + SysLogException(NID_NET_BT, r, "[%s] exception occurred on sending data.", GetErrorMessage(r)); + } + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [ActionResult:%s]", GetStringOfCurrentState(), GetErrorMessage(r)); + + return r; +} + +result +_BluetoothSppInitiatorImpl::Connect(const BluetoothDevice& remoteDevice, const Tizen::Base::UuId& serviceUuid) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s]", GetStringOfCurrentState()); + + result r = E_FAILURE; + + __stateMutex.Acquire(); + + switch (__currentState) + { + case _BT_SPP_INI_STATE_DISABLED: + case _BT_SPP_INI_STATE_REQ_CANCELING: + r = E_INVALID_STATE; + break; + + case _BT_SPP_INI_STATE_IDLE: + if (__pGapAdapter->IsPaired(*(remoteDevice.GetAddress())) == true) + { + r = __pSppAdapter->ConnectSocket(*(remoteDevice.GetAddress()), serviceUuid, *this); + if (r == E_SUCCESS) + { + __currentState = _BT_SPP_INI_STATE_CONNECT_READY; + } + } + else + { + // start the pairing process + if (__pGapAdapter->Pair(*(remoteDevice.GetAddress())) == E_SUCCESS) + { + // copy the address of the pairing device to the local variable + __pairingAddress.SetArray(remoteDevice.GetAddress()->GetPointer(), 0, _BT_ADDRESS_LENGTH); + __pairingAddress.SetPosition(0); + __pairingUuid = serviceUuid; + + r = E_SUCCESS; + __currentState = _BT_SPP_INI_STATE_BONDING; + } + else + { + r = E_FAILURE; + } + } + break; + + case _BT_SPP_INI_STATE_BONDING: //TODO: Versioning check + case _BT_SPP_INI_STATE_CONNECT_READY: + r = E_IN_PROGRESS; + break; + + case _BT_SPP_INI_STATE_CONNECTED: + r = E_ALREADY_CONNECTED; + break; + + default: + r = E_FAILURE; + break; + } + + __stateMutex.Release(); + + if (r != E_SUCCESS) + { + SysLogException(NID_NET_BT, r, "[%s] exception occurred on requesting a connection.", GetErrorMessage(r)); + } + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [ActionResult:%s]", GetStringOfCurrentState(), GetErrorMessage(r)); + + return r; +} + +result +_BluetoothSppInitiatorImpl::Disconnect(void) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s]", GetStringOfCurrentState()); + + result r = E_FAILURE; + + __stateMutex.Acquire(); + + switch (__currentState) + { + case _BT_SPP_INI_STATE_DISABLED: + r = E_INVALID_STATE; + break; + + case _BT_SPP_INI_STATE_IDLE: + r = E_INVALID_OPERATION; + break; + + case _BT_SPP_INI_STATE_BONDING: //TODO: Versioning check + if (__pGapAdapter->CancelPair() == E_SUCCESS) + { + r = E_SUCCESS; + __currentState = _BT_SPP_INI_STATE_REQ_CANCELING; + } + // It will be changed to IDLE after receiving the OnBluetoothPaired event. + break; + + case _BT_SPP_INI_STATE_CONNECT_READY: + // TODO: how does it cancel to request the connection? __socketFd is not determined at this time. + r = ProcessAsyncDisconnect(); + if (r == E_SUCCESS) + { + __currentState = _BT_SPP_INI_STATE_REQ_CANCELING; + } + // It will be changed to IDLE after receiving the OnSppDisconnected event. + break; + + case _BT_SPP_INI_STATE_REQ_CANCELING: + r = E_IN_PROGRESS; + break; + + case _BT_SPP_INI_STATE_CONNECTED: + r = ProcessAsyncDisconnect(); + if (r == E_SUCCESS) + { + __currentState = _BT_SPP_INI_STATE_IDLE; + } + // It will be changed to IDLE after receiving the OnSppDisconnected event. + break; + + default: + r = E_FAILURE; + break; + } + + __stateMutex.Release(); + + if (r != E_SUCCESS) + { + SysLogException(NID_NET_BT, r, "[%s] exception occurred on disconnecting the connection.", GetErrorMessage(r)); + } + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [ActionResult:%s]", GetStringOfCurrentState(), GetErrorMessage(r)); + + return r; +} + +void +_BluetoothSppInitiatorImpl::OnBluetoothActivated(result r) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s], [ActionResult:%s]", GetStringOfCurrentState(), GetErrorMessage(r)); + + __stateMutex.Acquire(); + + if ((__currentState == _BT_SPP_INI_STATE_DISABLED) && (r == E_SUCCESS)) + { + __currentState = _BT_SPP_INI_STATE_IDLE; + } + __stateMutex.Release(); + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s]", GetStringOfCurrentState()); +} + +void +_BluetoothSppInitiatorImpl::OnBluetoothDeactivated(result r) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s], [ActionResult:%s]", GetStringOfCurrentState(), GetErrorMessage(r)); + + __stateMutex.Acquire(); + + if (r == E_SUCCESS) + { + __currentState = _BT_SPP_INI_STATE_DISABLED; + } + + __stateMutex.Release(); + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s]", GetStringOfCurrentState()); +} + +void +_BluetoothSppInitiatorImpl::OnSocketConnectionResponded(int socketFd, result r) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s], [ActionResult:%s]", GetStringOfCurrentState(), GetErrorMessage(r)); + + bool isFired = false; + + __stateMutex.Acquire(); + + if ((__currentState == _BT_SPP_INI_STATE_CONNECT_READY) + || (__currentState == _BT_SPP_INI_STATE_REQ_CANCELING)) + { + if (r == E_SUCCESS) + { + __currentState = _BT_SPP_INI_STATE_CONNECTED; + __socketFd = socketFd; + } + else + { + // including the cases as r == E_REJECTED or r == E_MAX_EXCEEDED + // E_MAX_EXCEEDED is originated in the previous version. + __currentState = _BT_SPP_INI_STATE_IDLE; + SysLogException(NID_NET_BT, r, "[%s] exception occurred on the response of the SPP connect request.", GetErrorMessage(r)); + } + + isFired = true; + } + // ignore other cases + + __stateMutex.Release(); + + if (isFired) + { + _BluetoothSppInitiatorEventArg* pArg = new (std::nothrow) _BluetoothSppInitiatorEventArg(true, r); + if (pArg == null) + { + SysLogException(NID_NET_BT, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient."); + isFired = false; + } + else + { + __pEvent->FireAsync(*pArg); + } + } + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [CONNECT_RESPONDED_Event:%s]", + GetStringOfCurrentState(), isFired ? "Fired" : "NotFired"); +} + +void +_BluetoothSppInitiatorImpl::OnSocketDisconnected(result r) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s], [ActionResult:%s]", GetStringOfCurrentState(), GetErrorMessage(r)); + + bool isFired = false; + + __stateMutex.Acquire(); + + if (__currentState == _BT_SPP_INI_STATE_CONNECTED) + { + if (r == E_SUCCESS) + { + __currentState = _BT_SPP_INI_STATE_IDLE; + __socketFd = _BT_INVALID_SOCKET_FD; + isFired = true; + } + } + // ignore other cases + + __stateMutex.Release(); + + if (isFired) + { + _BluetoothSppInitiatorEventArg* pArg = new (std::nothrow) _BluetoothSppInitiatorEventArg(false, r); + if (pArg == null) + { + SysLogException(NID_NET_BT, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient."); + isFired = false; + } + else + { + __pEvent->FireAsync(*pArg); + } + } + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [DISCONNECTED_Event:%s]", + GetStringOfCurrentState(), isFired ? "Fired" : "NotFired"); +} + +void +_BluetoothSppInitiatorImpl::OnSocketDataReceived(Tizen::Base::ByteBuffer& buffer) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s]", GetStringOfCurrentState()); + + bool isFired = false; + + __stateMutex.Acquire(); + + if (__currentState == _BT_SPP_INI_STATE_CONNECTED) + { + isFired = true; + } + // ignore other cases + + __stateMutex.Release(); + + if (isFired) + { + _BluetoothSppInitiatorEventArg* pArg = new (std::nothrow) _BluetoothSppInitiatorEventArg(buffer); + if (pArg == null) + { + SysLogException(NID_NET_BT, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient."); + isFired = false; + } + else + { + // use Fire() instead of FireAsync() to improve the transfer rate. + __pEvent->Fire(*pArg); + } + } + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [DATA_RECIEVED_Event:%s]", + GetStringOfCurrentState(), isFired ? "Fired" : "NotFired"); +} + +void +_BluetoothSppInitiatorImpl::OnBluetoothPaired(const BluetoothDevice* pPairedDevice, result r) +{ + SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s], [ActionResult:%s]", GetStringOfCurrentState(), GetErrorMessage(r)); + + bool isFired = false; + result responseResult = E_SYSTEM; + + __stateMutex.Acquire(); + + if (pPairedDevice->GetAddress()->Equals(__pairingAddress)) + { + if (__currentState == _BT_SPP_INI_STATE_BONDING) + { + if (r == E_SUCCESS) + { + if (__pSppAdapter->ConnectSocket(__pairingAddress, __pairingUuid, *this) == E_SUCCESS) + { + __currentState = _BT_SPP_INI_STATE_CONNECT_READY; + } + else + { + // callback responded with E_SYSTEM + isFired = true; + __currentState = _BT_SPP_INI_STATE_IDLE; + responseResult = E_SYSTEM; + } + } + else + { + // callback responded with r + isFired = true; + __currentState = _BT_SPP_INI_STATE_IDLE; + responseResult = r; + } + + __pairingAddress.Clear(); + } + else if (__currentState == _BT_SPP_INI_STATE_REQ_CANCELING) + { + // callback responded with E_SYSTEM or E_OPERATION_CANCELED + isFired = true; + __currentState = _BT_SPP_INI_STATE_IDLE; + responseResult = E_SYSTEM; + } + // ignore other cases + } + // ignored otherwise + + __stateMutex.Release(); + + if (isFired) + { + _BluetoothSppInitiatorEventArg* pArg = new (std::nothrow) _BluetoothSppInitiatorEventArg(true, responseResult); + if (pArg == null) + { + SysLogException(NID_NET_BT, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient."); + isFired = false; + } + else + { + __pEvent->FireAsync(*pArg); + } + } + + SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [CONNECT_RESPONDED_Event:%s]", + GetStringOfCurrentState(), isFired ? "Fired" : "NotFired"); +} + +result +_BluetoothSppInitiatorImpl::ProcessAsyncDisconnect(void) +{ + result r = E_SUCCESS; + + r = __pSppAdapter->DisconnectSocket(__socketFd); + + // send a disconnected event here if the disconnect method is successful + // because the disconnect method of the underlying system is sync call. (transform sync into async) + if (r == E_SUCCESS) + { + __socketFd = _BT_INVALID_SOCKET_FD; + + _BluetoothSppInitiatorEventArg* pArg = new (std::nothrow) _BluetoothSppInitiatorEventArg(false, r); + if (pArg != null) + { + __pEvent->FireAsync(*pArg); + SysLog(NID_NET_BT, "[DISCONNECTED_Event:Fired]"); + } + } + + return r; +} + +const char* +_BluetoothSppInitiatorImpl::GetStringOfCurrentState(void) const +{ + const char* pStateString = null; + + switch (__currentState) + { + case _BT_SPP_INI_STATE_DISABLED: + pStateString = "DISABLED"; + break; + + case _BT_SPP_INI_STATE_IDLE: + pStateString = "IDLE"; + break; + + case _BT_SPP_INI_STATE_BONDING: + pStateString = "BONDING"; + break; + + case _BT_SPP_INI_STATE_CONNECT_READY: + pStateString = "CONNECT_READY"; + break; + + case _BT_SPP_INI_STATE_REQ_CANCELING: + pStateString = "REQ_CANCELING"; + break; + + case _BT_SPP_INI_STATE_CONNECTED: + pStateString = "CONNECTED"; + break; + + default: + pStateString = "Unknown"; + break; + } + + return pStateString; +} + +} } } // Tizen::Net::Bluetooth diff --git a/src/FNetBt_BluetoothSppSystemAdapter.cpp b/src/FNetBt_BluetoothSppSystemAdapter.cpp new file mode 100755 index 0000000..11fcc36 --- /dev/null +++ b/src/FNetBt_BluetoothSppSystemAdapter.cpp @@ -0,0 +1,528 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +// @file FNetBt_BluetoothSppSystemAdapter.cpp +// @brief This is the implementation file for the _BluetoothSppSystemAdapter class. +// + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "FNetBt_BluetoothSppSystemAdapter.h" +#include "FNetBt_BluetoothGapSystemAdapter.h" +#include "FNetBt_BluetoothDeviceImpl.h" +#include "FNetBt_IBluetoothSocketListener.h" + +using namespace std; +using namespace Tizen::Base; +using namespace Tizen::Base::Collection; +using namespace Tizen::Base::Utility; + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +struct _SocketFdDeleter +{ + void operator()(int* serverSocketFd) + { + (void) bt_socket_destroy_rfcomm(*serverSocketFd); + } +}; + +/* + * @class _BluetoothAddressComparer + * @brief The _BluetoothAddressComparer class provides the comparer about two specified String + * which consists of Bluetooth address and service UUID. + */ +class _BluetoothAddressComparer + : public Tizen::Base::Collection::IComparerT + , public Tizen::Base::Object +{ +public: + _BluetoothAddressComparer(void){} + virtual ~_BluetoothAddressComparer(void){} + + virtual result Compare(const Tizen::Base::String& obj1, const Tizen::Base::String& obj2, int& cmp) const + { + cmp = obj1.CompareTo(obj2); + return E_SUCCESS; + } + +private: + _BluetoothAddressComparer(const _BluetoothAddressComparer& value); + _BluetoothAddressComparer& operator =(const _BluetoothAddressComparer& value); + +}; //_BluetoothAddressComparer + +/* + * @class _BluetoothAddressHashCodeProviderT + * @brief The _BluetoothAddressHashCodeProviderT class provides the hash code of a specified String + * which consists of Bluetooth address and service UUID. + */ +class _BluetoothAddressHashCodeProvider + : public Tizen::Base::Collection::IHashCodeProviderT +{ +public: + _BluetoothAddressHashCodeProvider(void) {} + virtual ~_BluetoothAddressHashCodeProvider(void) {} + virtual int GetHashCode(const Tizen::Base::String& obj) const + { + return obj.GetHashCode(); + } + +private: + _BluetoothAddressHashCodeProvider(const _BluetoothAddressHashCodeProvider& value); + _BluetoothAddressHashCodeProvider& operator =(const _BluetoothAddressHashCodeProvider& value); + +}; //_BluetoothAddressHashCodeProvider + + +static _BluetoothAddressComparer _btAddressComparer; +static _BluetoothAddressHashCodeProvider _btAddressHashCodeProvider; + +_BluetoothSppSystemAdapter* _BluetoothSppSystemAdapter::__pInstance = null; + +_BluetoothSppSystemAdapter::_BluetoothSppSystemAdapter(void) + : __pServerSocketMap(null) + , __pSocketMap(null) + , __pClientSocketMap(null) +{ +} + +_BluetoothSppSystemAdapter::~_BluetoothSppSystemAdapter(void) +{ + // unregister the callback methods from the underlying layer + (void) bt_socket_unset_connection_state_changed_cb(); + (void) bt_socket_unset_data_received_cb(); + (void) bt_socket_unset_connection_requested_cb(); +} + +void +_BluetoothSppSystemAdapter::InitSingleton(void) +{ + bool r = false; + static _BluetoothSppSystemAdapter inst; + + r = inst.Construct(); + SysTryReturnVoidResult(NID_NET_BT, r == true, E_SYSTEM, "[E_SYSTEM] Propagating."); + + __pInstance = &inst; +} + +_BluetoothSppSystemAdapter* +_BluetoothSppSystemAdapter::GetInstance(void) +{ + static pthread_once_t onceBlock = PTHREAD_ONCE_INIT; + + if (__pInstance == null) + { + ClearLastResult(); + pthread_once(&onceBlock, InitSingleton); + result r = GetLastResult(); + if (IsFailed(r)) + { + onceBlock = PTHREAD_ONCE_INIT; + } + } + + return __pInstance; +} + +bool +_BluetoothSppSystemAdapter::Construct(void) +{ + result r = E_SUCCESS; + int err = BT_ERROR_NONE; + unique_ptr< Tizen::Base::Collection::HashMapT > pServerSocketMap; + unique_ptr< Tizen::Base::Collection::HashMapT > pSocketMap; + unique_ptr< Tizen::Base::Collection::HashMapT > pClientSocketMap; + + pServerSocketMap.reset(new (std::nothrow) HashMapT); + SysTryReturn(NID_NET_BT, pServerSocketMap != null, false, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient."); + r = pServerSocketMap->Construct(); + SysTryReturn(NID_NET_BT, r == E_SUCCESS, false, r, "[%s] Propagating.", GetErrorMessage(r)); + + pSocketMap.reset(new (std::nothrow) HashMapT); + SysTryReturn(NID_NET_BT, pSocketMap != null, false, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient."); + r = pSocketMap->Construct(); + SysTryReturn(NID_NET_BT, r == E_SUCCESS, false, r, "[%s] Propagating.", GetErrorMessage(r)); + + pClientSocketMap.reset(new (std::nothrow) HashMapT); + SysTryReturn(NID_NET_BT, pClientSocketMap != null, false, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient."); + //construct map with default capacity(16) and loadFactor(0.75f) value. + r = pClientSocketMap->Construct(16, 0.75f, _btAddressHashCodeProvider, _btAddressComparer); + SysTryReturn(NID_NET_BT, r == E_SUCCESS, false, r, "[%s] Propagating.", GetErrorMessage(r)); + + err = bt_socket_set_connection_state_changed_cb(&OnSocketConnectionStateChanged, null); + SysTryReturn(NID_NET_BT, err == BT_ERROR_NONE, false, E_SYSTEM, "[E_SYSTEM] Registering the callback method has failed."); + + err = bt_socket_set_data_received_cb(&OnSocketDataReceived, null); + if (err != BT_ERROR_NONE) + { + (void) bt_socket_unset_connection_state_changed_cb(); + } + SysTryReturn(NID_NET_BT, err == BT_ERROR_NONE, false, E_SYSTEM, "[E_SYSTEM] Registering the callback method has failed."); + + err = bt_socket_set_connection_requested_cb(&OnSocketConnectionRequested, null); + if (err != BT_ERROR_NONE) + { + (void) bt_socket_unset_connection_state_changed_cb(); + (void) bt_socket_unset_data_received_cb(); + } + SysTryReturn(NID_NET_BT, err == BT_ERROR_NONE, false, E_SYSTEM, "[E_SYSTEM] Registering the callback method has failed."); + + __pServerSocketMap = move(pServerSocketMap); + __pSocketMap = move(pSocketMap); + __pClientSocketMap = move(pClientSocketMap); + + return true; +} + +result +_BluetoothSppSystemAdapter::OpenServerSocket(const UuId& serviceUuid, _IBluetoothSocketListener& listener, int& serverSocketFd) +{ + int err = BT_ERROR_NONE; + result r = E_FAILURE; + unique_ptr pUuidStr; + unique_ptr pSocketFd(&serverSocketFd); + bool isUsed = false; + + pUuidStr.reset(_StringConverter::CopyToCharArrayN(serviceUuid.ToString())); + SysTryReturnResult(NID_NET_BT, pUuidStr != null, E_INVALID_ARG, "The service UUID is invalid."); + + err = bt_adapter_is_service_used(pUuidStr.get(), &isUsed); + SysTryReturnResult(NID_NET_BT, (err == BT_ERROR_NONE) && !isUsed, E_SERVICE_UNAVAILABLE, + "Server socket with the specified service UUID is not available."); + + err = bt_socket_create_rfcomm(pUuidStr.get(), &serverSocketFd); + SysTryReturnResult(NID_NET_BT, err == BT_ERROR_NONE, E_FAILURE, "Creating a server socket has failed."); + + err = bt_socket_listen(serverSocketFd, 1); + SysTryReturnResult(NID_NET_BT, err == BT_ERROR_NONE, E_FAILURE, "Listen of the server socket has failed."); + + SysLog(NID_NET_BT, "A rfcomm server socket (FD: %d) is created.", serverSocketFd); + + // add the _IBluetoothSocketListener pointer to the server socket map. + r = __pServerSocketMap->Add(serverSocketFd, &listener); + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_FAILURE, "Propagating."); + + pSocketFd.release(); + + return E_SUCCESS; +} + +result +_BluetoothSppSystemAdapter::CloseServerSocket(const int serverSocketFd) +{ + int err = BT_ERROR_NONE; + result r = E_SUCCESS; + + err = bt_socket_destroy_rfcomm(serverSocketFd); + SysTryReturnResult(NID_NET_BT, err == BT_ERROR_NONE, E_FAILURE, "Closing the server socket has failed."); + SysLog(NID_NET_BT, "The server socket (FD: %d) is closed.", serverSocketFd); + + // remove the _IBluetoothSocketListener pointer related to the specified socket FD from the server socket map. + r = __pServerSocketMap->Remove(serverSocketFd); + if (r != E_SUCCESS) + { + SysLog(NID_NET_BT, "But the server socket could not be removed from the server socket map."); + // 'r', the error result generated after destroying the socket successfully, is NOT propagated + } + + return E_SUCCESS; +} + +result +_BluetoothSppSystemAdapter::AcceptSocketRequest(int serverSocketFd, int& socketFd) +{ + int err = BT_ERROR_NONE; + result r = E_SUCCESS; + _IBluetoothSocketListener* pListener = null; + + // find the appropriate _IBluetoothSocketListener pointer with the server socket FD. + r = __pServerSocketMap->GetValue(serverSocketFd, pListener); + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_FAILURE, "The server socket number is unknown."); + + err = bt_socket_accept(serverSocketFd, &socketFd); + SysTryReturnResult(NID_NET_BT, err == BT_ERROR_NONE, E_FAILURE, "Accepting the connection request has failed."); + + SysLog(NID_NET_BT, "The connection request to the server socket (FD: %d) is accepted. (child socket FD: %d)", + serverSocketFd, socketFd); + + // add the _IBluetoothSocketListener pointer to the socket map. + // In case for server socket event, _IBluetoothSocketListener pointer is copied from __pServerSocketMap to __pSocketMap + r = __pSocketMap->Add(socketFd, pListener); + if (r != E_SUCCESS) + { + (void) bt_socket_disconnect_rfcomm(socketFd); + } + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_FAILURE, "Propagating."); + + return E_SUCCESS; +} + +result +_BluetoothSppSystemAdapter::RejectSocketRequest(int serverSocketFd) +{ + result r = E_FAILURE; + + if (bt_socket_reject(serverSocketFd) == BT_ERROR_NONE) + { + r = E_SUCCESS; + } + + SysLog(NID_NET_BT, "Rejecting the connection request to the server socket (FD: %d) ", serverSocketFd, + r == E_SUCCESS ? "is successful." : "has failed."); + + return r; +} + +result +_BluetoothSppSystemAdapter::ConnectSocket(const ByteBuffer& serverAddress, const UuId& serviceUuid, + _IBluetoothSocketListener& listener) +{ + result r = E_SUCCESS; + unique_ptr pAddressStr; + unique_ptr pUuidStr; + int err = BT_ERROR_NONE; + String address; + String uuid; + String key; + + SysTryReturnResult(NID_NET_BT, serverAddress.GetRemaining() == _BT_ADDRESS_LENGTH, E_INVALID_ARG, + "The address of the remote device is incorrect."); + + uuid = serviceUuid.ToString(); + pUuidStr.reset(_StringConverter::CopyToCharArrayN(uuid)); + SysTryReturnResult(NID_NET_BT, pUuidStr != null, E_INVALID_ARG, "The service UUID is invalid."); + + address = _BluetoothDeviceImpl::GetAddressString(serverAddress); + pAddressStr.reset(_StringConverter::CopyToCharArrayN(address)); + SysTryReturnResult(NID_NET_BT, pAddressStr != null, E_INVALID_ARG, "The service UUID is invalid."); + + err = bt_socket_connect_rfcomm(pAddressStr.get(), pUuidStr.get()); + SysTryReturnResult(NID_NET_BT, err == BT_ERROR_NONE, E_FAILURE, "Connecting to the server has failed."); + + SysLog(NID_NET_BT, "Sending a connection request to [%s] is successful.", pAddressStr.get()); + + // add the _IBluetoothSocketListener pointer to the client socket map. + key = address + String(L"+") + uuid; + r = __pClientSocketMap->Add(key, &listener); + if (r != E_SUCCESS) + { + // TODO: check the feature that cancels the connection request. + (void) bt_socket_disconnect_rfcomm(_BT_INVALID_SOCKET_FD); + } + SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_FAILURE, "Propagating."); + + return E_SUCCESS; +} + +result +_BluetoothSppSystemAdapter::DisconnectSocket(int socketFd) +{ + result r = E_SUCCESS; + int err = BT_ERROR_NONE; + + // TODO: more detailed error resolution is needed + err = bt_socket_disconnect_rfcomm(socketFd); + SysTryReturnResult(NID_NET_BT, err == BT_ERROR_NONE, E_FAILURE, "Disconnecting the rfcomm socket has failed."); + + SysLog(NID_NET_BT, "Disconnecting the rfcomm socket (FD: %d) is successful.", socketFd); + + r = __pSocketMap->Remove(socketFd); + if (r != E_SUCCESS) + { + SysLog(NID_NET_BT, "But, The socket (FD: %d) could not be removed from the socket map.", socketFd); + // 'r', the error result generated after destroying the socket successfully, is NOT propagated + } + + return E_SUCCESS; +} + +result +_BluetoothSppSystemAdapter::SendSocketData(int socketFd, const Tizen::Base::ByteBuffer& data) +{ + result r = E_SUCCESS; + const byte* pSendData = null; + int dataLength = 0; + + pSendData = data.GetPointer(); + pSendData += data.GetPosition(); + dataLength = data.GetRemaining(); + + if (bt_socket_send_data(socketFd, (char*) pSendData, dataLength) == BT_ERROR_NONE) + { + r = E_SUCCESS; + } + else + { + r = E_SYSTEM; + } + + SysLog(NID_NET_BT, "Sending data (%d bytes) through the rfcomm socket (FD: %d) %s", dataLength, socketFd, + r == E_SUCCESS ?"is successful." : "has failed."); + + return r; +} + +void +_BluetoothSppSystemAdapter::OnSocketConnectionRequested(int serverSocketFd, const char* pRemoteAddress, void* pUserData) +{ + result r = E_SUCCESS; + ByteBuffer deviceAddress; + BluetoothDevice requester; + String deviceAddressStr(pRemoteAddress); + _IBluetoothSocketListener* pListener = null; + _BluetoothSppSystemAdapter* pSppAdapter = _BluetoothSppSystemAdapter::GetInstance(); + + // find the appropriate _IBluetoothSocketListener pointer with the server socket FD. + // the server socket FD is used for distinguishing the recipient from the registered server sockets. + r = pSppAdapter->__pServerSocketMap->GetValue(serverSocketFd, pListener); + SysTryReturnVoidResult(NID_NET_BT, r == E_SUCCESS, E_SYSTEM, "[E_SYSTEM] The socket number is unknown."); + + deviceAddress.Construct(_BT_ADDRESS_LENGTH); + (void) _BluetoothDeviceImpl::GetAddressByteBuffer(deviceAddressStr, L":", deviceAddress); + + r = _BluetoothGapSystemAdapter::GetPairedDevice(deviceAddress, requester); + SysTryReturnVoidResult(NID_NET_BT, r == E_SUCCESS, E_SYSTEM, "[E_SYSTEM] Getting information of the request has failed."); + + pListener->OnSocketConnectionRequested(requester); +} + +void +_BluetoothSppSystemAdapter::OnSocketConnectionStateChanged(int status, bt_socket_connection_state_e connectionState, + bt_socket_connection_s* pConnectionInfo, void* pUserData) +{ + result r = E_SUCCESS; + _IBluetoothSocketListener* pListener = null; + _BluetoothSppSystemAdapter* pSppAdapter = _BluetoothSppSystemAdapter::GetInstance(); + + switch (connectionState) + { + case BT_SOCKET_CONNECTED: + if (pConnectionInfo->local_role == BT_SOCKET_CLIENT) + { + SysLog(NID_NET_BT, "Connected event from [address: %s, uuid: %s] is received.", + pConnectionInfo->remote_address, pConnectionInfo->service_uuid); + + String address(pConnectionInfo->remote_address); + String uuid(pConnectionInfo->service_uuid); + String key = address + String(L"+") + uuid; + + // find the appropriate _IBluetoothSocketListener pointer with the server address and the service UUID. + r = pSppAdapter->__pClientSocketMap->GetValue(key, pListener); + SysTryReturnVoidResult(NID_NET_BT, r == E_SUCCESS, E_SYSTEM, "[E_SYSTEM] The server address or the service UUID is unknown."); + + // TODO: more detailed error resolution is needed + if (status == BT_ERROR_NONE) + { + // add the _IBluetoothSocketListener pointer to the socket map. + // In case for client socket event, the _IBluetoothSocketListener ponter is moved + // from __pClientSocketMap to __pSocketMap + r = pSppAdapter->__pSocketMap->Add(pConnectionInfo->socket_fd, pListener); + if (r != E_SUCCESS) + { + SysLogException(NID_NET_BT, E_SYSTEM, "[%s] Propagating. the socket could not be added to the socket map.", + GetErrorMessage(r)); + r = E_SYSTEM; + } + } + else + { + SysLog(NID_NET_BT, "[E_SYSTEM] Connection request failure is reported by the subsystem."); + r = E_SYSTEM; + } + + pListener->OnSocketConnectionResponded(pConnectionInfo->socket_fd, r); + + // remove the _IBluetoothSocketListener pointer related to the specified server address and UUID + // from the client socket map. + r = pSppAdapter->__pClientSocketMap->Remove(key); + if (r != E_SUCCESS) + { + SysLog(NID_NET_BT, "But the socket could not be removed from the client socket map."); + // 'r', the error result is ignored. + } + + } + // this event is ignored in case of SERVER ROLE. + + break; + + case BT_SOCKET_DISCONNECTED: + SysLog(NID_NET_BT, "Disconnected event with [socket fd: %d] is received.", pConnectionInfo->socket_fd); + + // find the appropriate _IBluetoothSocketListener pointer with the socket FD + r = pSppAdapter->__pSocketMap->GetValue(pConnectionInfo->socket_fd, pListener); + SysTryReturnVoidResult(NID_NET_BT, r == E_SUCCESS, E_SYSTEM, "[E_SYSTEM] The socket number is unknown."); + + // TODO: more detailed error resolution is needed + r = ((status == BT_ERROR_NONE) ? E_SUCCESS : E_SYSTEM); + + pListener->OnSocketDisconnected(r); + + // remove the _IBluetoothSocketListener pointer related to the specified socket FD from the socket map. + r = pSppAdapter->__pSocketMap->Remove(pConnectionInfo->socket_fd); + if (r != E_SUCCESS) + { + SysLog(NID_NET_BT, "But the socket (FD: %d) could not be removed from the socket map.", + pConnectionInfo->socket_fd); + // 'r', the error result is ignored. + } + + break; + + default: + // ignore other cases + SysLog(NID_NET_BT, "The connection state is invalid."); + break; + } +} + +void +_BluetoothSppSystemAdapter::OnSocketDataReceived(bt_socket_received_data_s* pData, void* pUserData) +{ + result r = E_SUCCESS; + ByteBuffer dataBuffer; + _IBluetoothSocketListener* pListener = null; + _BluetoothSppSystemAdapter* pSppAdapter = _BluetoothSppSystemAdapter::GetInstance(); + + SysLog(NID_NET_BT, "Data (%d bytes) through the socket (FD: %d) is received.", pData->data_size, pData->socket_fd); + + // find the appropriate _IBluetoothSocketListener pointer with the socket FD + r = pSppAdapter->__pSocketMap->GetValue(pData->socket_fd, pListener); + SysTryReturnVoidResult(NID_NET_BT, r == E_SUCCESS, E_SYSTEM, "[E_SYSTEM] The socket number is unknown."); + + // TODO: The deep copy should be modified to a shallow copy for better performance + dataBuffer.Construct(pData->data_size); + dataBuffer.SetArray((byte*) pData->data, 0, pData->data_size); + dataBuffer.SetPosition(0); + + pListener->OnSocketDataReceived(dataBuffer); +} + +} } } // Tizen::Net::Bluetooth diff --git a/src/FNetBt_BluetoothSppSystemAdapter.h b/src/FNetBt_BluetoothSppSystemAdapter.h new file mode 100644 index 0000000..d741a9c --- /dev/null +++ b/src/FNetBt_BluetoothSppSystemAdapter.h @@ -0,0 +1,203 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +/** + * @file FNetBt_BluetoothSppSystemAdapter.h + * @brief This is the header file for the _BluetoothSppSystemAdapter class. + * + * This header file contains the declaration of the _BluetoothSppSystemAdapter class. + */ +#ifndef _FNET_BT_INTERNAL_BLUETOOTH_SPP_SYSTEM_ADAPTER_H_ +#define _FNET_BT_INTERNAL_BLUETOOTH_SPP_SYSTEM_ADAPTER_H_ + +#include +#include +#include +#include +#include + +static const int _BT_INVALID_SOCKET_FD = -1; + +// forward declarations +namespace Tizen { namespace Base { +class ByteBuffer; +class String; +class UuId; + +namespace Collection { +class ArrayList; +template class HashMapT; +} +} } + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +// forward declarations +class BluetoothDevice; +class _IBluetoothSocketListener; + +/** + * @class _BluetoothSppSystemAdapter + * @brief This class provides functions related to RFCOMM socket (SPP) and have a role of adaptation OSP classes and the + * underlying subsystem. This class is a type of singleton, therefore only one instance should be allowed. + */ +class _BluetoothSppSystemAdapter + : public Tizen::Base::Object +{ +public: + /** + * Creates an instance of this class if there is no instance in this application context. + * Gets the exist instance because this class is a singleton, otherwise. + * + * @return the instance of this class + */ + static _BluetoothSppSystemAdapter* GetInstance(void); + + + //----------------------------------------------------------------------------------------------------------------- + // Server Socket + //----------------------------------------------------------------------------------------------------------------- + + /** + * Create and initialize a server socket, and start to listen the socket events. @n + * An instance of _IBluetoothSocketListener class is registered internally. + * + * @return An error code + * @param[in] serviceUuid The service UUID + * @param[in] listener The instance of _IBluetoothSocketListener to be registered + * @param[out] serverSocketFd The server socket FD + * @exception E_SUCCESS The method is successful. + * @exception E_SERVICE_UNAVAILABLE The service is not available. + * @exception E_SYSTEM A system error has occurred. + */ + result OpenServerSocket(const Tizen::Base::UuId& serviceUuid, _IBluetoothSocketListener& listener, int& serverSocketFd); + + /** + * Close the specified server socket. @n + * All child sockets involved in this server socket will be automatically disconnected. + * + * @return An error code + * @param[in] serverSocketFd The server socket FD + * @exception E_SUCCESS The method is successful. + * @exception E_SYSTEM A system error has occurred. + */ + result CloseServerSocket(int serverSocketFd); + + /** + * Accept the connection request received to the specified server socket. @n + * A new child socket is created if the accept is successful. + * + * @return An error code + * @param[in] serverSocketFd The server socket FD + * @param[out] socketFd The child socket FD for the connection + * @exception E_SUCCESS The method is successful. + * @exception E_SYSTEM A system error has occurred. + */ + result AcceptSocketRequest(int serverSocketFd, int& socketFd); + + /** + * Reject the connection request received to the specified server socket. + * + * @return An error code + * @param[in] serverSocketFd The server socket FD + * @exception E_SUCCESS The method is successful. + * @exception E_SYSTEM A system error has occurred. + */ + result RejectSocketRequest(int serverSocketFd); + + + //----------------------------------------------------------------------------------------------------------------- + // socket + //----------------------------------------------------------------------------------------------------------------- + + /** + * Connect with the specified server. @n + * A new socket FD can be acquired on + * OnSocketConnected() callback method invoked when the connection is completely established. + * + * @return An error code + * @param[in] serverAddress The address of the server + * @param[in] serviceUuid The service UUID + * @param[in] listener The socket event listener + * @exception E_SUCCESS The method is successful. + * @exception E_SYSTEM A system error has occurred. + */ + result ConnectSocket(const Tizen::Base::ByteBuffer& serverAddress, const Tizen::Base::UuId& serviceUuid, + _IBluetoothSocketListener& listener); + + /** + * Close the connection related to the specified socket. @n + * + * @return An error code + * @param[in] socketFd The socket FD + * @exception E_SUCCESS The method is successful. + * @exception E_SYSTEM A system error has occurred. + */ + result DisconnectSocket(int socketFd); + + /** + * Send data through the connection related to the specified socket. @n + * + * @return An error code + * @param[in] socketFd The socket FD + * @param[in] data The data to be sent + * @exception E_SUCCESS The method is successful. + * @exception E_SYSTEM A system error has occurred. + */ + result SendSocketData(int socketFd, const Tizen::Base::ByteBuffer& data); + + + //----------------------------------------------------------------------------------------------------------------- + // Callback methods + //----------------------------------------------------------------------------------------------------------------- + + /** + * Callback called by the underlying system to notify that the RFCOMM server socket is received the connection request. + */ + static void OnSocketConnectionRequested(int serverSocketFd, const char* pRemoteAddress, void* pUserData); + + /** + * Callback called by the underlying system to notify that the connection state has changed to connected or disconnected. + */ + static void OnSocketConnectionStateChanged(int status, bt_socket_connection_state_e connectionState, + bt_socket_connection_s* pConnectionInfo, void* pUserData); + + /** + * Callback used by the underlying system to notify that data is received on the established connection. + */ + static void OnSocketDataReceived(bt_socket_received_data_s* pData, void* pUserData); + +private: + _BluetoothSppSystemAdapter(void); + ~_BluetoothSppSystemAdapter(void); + + _BluetoothSppSystemAdapter(const _BluetoothSppSystemAdapter& value); + _BluetoothSppSystemAdapter& operator =(const _BluetoothSppSystemAdapter& value); + + bool Construct(void); + + static void InitSingleton(void); + +private: + std::unique_ptr< Tizen::Base::Collection::HashMapT > __pServerSocketMap; + std::unique_ptr< Tizen::Base::Collection::HashMapT > __pSocketMap; + std::unique_ptr< Tizen::Base::Collection::HashMapT > __pClientSocketMap; + static _BluetoothSppSystemAdapter* __pInstance; +}; // _BluetoothSppSystemAdapter + +} } } +#endif // _FNET_BT_INTERNAL_BLUETOOTH_SPP_SYSTEM_ADAPTER_H_ diff --git a/src/inc/FNetBt_BluetoothAdapterUtility.h b/src/inc/FNetBt_BluetoothAdapterUtility.h new file mode 100644 index 0000000..6bc47de --- /dev/null +++ b/src/inc/FNetBt_BluetoothAdapterUtility.h @@ -0,0 +1,73 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +/** + * @file FNetBt_BluetoothAdapterUtility.h + * @brief This is the header file for the _BluetoothAdapterUtility class. + * + * This header file contains the declaration of the _BluetoothAdapterUtility class. + */ +#ifndef _FNET_BT_INTERNAL_BLUETOOTH_ADAPTER_UTILITY_H_ +#define _FNET_BT_INTERNAL_BLUETOOTH_ADAPTER_UTILITY_H_ + +#include +#include +#include + +// forward declarations +namespace Tizen { namespace Base +{ +class ByteBuffer; + +namespace Collection +{ +class IList; +} +} } + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +// forward declarations +class BluetoothDevice; + +/** + * @class _BluetoothAdapterUtility + * @brief This class provides utilitiy functions such as converting data structure to other data class, and printing data class. + */ +class _OSP_EXPORT_ _BluetoothAdapterUtility +{ +public: + static BluetoothMajorDeviceClassType ConvertToMajorDeviceClassType(bt_major_device_class_e majorClass); + static BluetoothMinorDeviceClassType ConvertToMinorDeviceClassType(bt_major_device_class_e majorClass, bt_minor_device_class_e minorClass); + static unsigned long ConvertToServiceClassList(int serviceClass); + static unsigned long ConvertToServiceList(char** pServiceUuid, int& serviceUuidCount); + static Tizen::Base::Collection::IList* ConvertServiceUuidListN(char** pServiceUuid, int& serviceUuidCount); + static void PrintDeviceInfo(const BluetoothDevice& device); + static void PrintServiceList(unsigned long type); + static void PrintServiceUuidList(const Tizen::Base::Collection::IList* pList); + +private: + _BluetoothAdapterUtility(void); + ~_BluetoothAdapterUtility(void); + + _BluetoothAdapterUtility(const _BluetoothAdapterUtility& value); + _BluetoothAdapterUtility& operator =(const _BluetoothAdapterUtility& value); + +}; // _BluetoothAdapterUtility + +} } } +#endif // _FNET_BT_INTERNAL_BLUETOOTH_ADAPTER_UTILITY_H_ diff --git a/src/inc/FNetBt_BluetoothDeviceImpl.h b/src/inc/FNetBt_BluetoothDeviceImpl.h new file mode 100755 index 0000000..bc3c9cd --- /dev/null +++ b/src/inc/FNetBt_BluetoothDeviceImpl.h @@ -0,0 +1,318 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +/** + * @file FNetBt_BluetoothDeviceImpl.h + * @brief This is the header file for the _BluetoothDeviceImpl Class. + * + * This header file contains the declarations of the _BluetoothDeviceImpl Class. + */ +#ifndef _FNET_BT_INTERNAL_BLUETOOTH_DEVICE_IMPL_H_ +#define _FNET_BT_INTERNAL_BLUETOOTH_DEVICE_IMPL_H_ + +#include +#include +#include +#include +#include +#include +#include + +// forward declarations +namespace Tizen { namespace Base { namespace Collection +{ +class IList; +} } } + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +// forward declarations +class BluetoothDevice; + +/** + * @class _BluetoothDeviceImpl + * @brief This class provides extended methods for BluetoothDevice class. + * + * The detailed description will be located here (TBD) + */ +class _OSP_EXPORT_ _BluetoothDeviceImpl + : public Tizen::Base::Object +{ +public: + /** + * This is the default constructor for this class. + */ + _BluetoothDeviceImpl(void); + + /** + * Initializes this instance of BluetoothDevice with the specified parameters. + * + * @deprecated This constructor is deprecated because most of the information is generated internally. + * Therefore, creating a %BluetoothDevice instance directly by the application is not recommended. + * Instead of using this method for copying an instance, the copy constructor is recommended. + * + * @param[in] address The %Bluetooth device address + * @param[in] deviceName The name of the device + * @param[in] majorClassType The major class type of a %Bluetooth device + * @param[in] minorClassType The minor class type of a %Bluetooth device + * @param[in] serviceClassList The service class type list + * @param[in] serviceList The service type list + * @remarks The @c serviceClassList parameter consists of Tizen::Net::Bluetooth::BluetoothServiceClassType values + * which are joined by the logical OR operator. @n + * The @c serviceList parameter consists of Tizen::Net::Bluetooth::BluetoothServiceType values which are + * joined by the logical OR operator. + */ + _BluetoothDeviceImpl(const Tizen::Base::ByteBuffer& address, const Tizen::Base::String& deviceName, BluetoothMajorDeviceClassType majorClassType, BluetoothMinorDeviceClassType minorClassType, unsigned long serviceClassList, unsigned long serviceList); + + /** + * This is the copy constructor for the %_BluetoothDeviceImpl class. @n + * + * @param[in] value An instance of %_BluetoothDeviceImpl + */ + _BluetoothDeviceImpl(const _BluetoothDeviceImpl& value); + + /** + * This is the destructor for this class. + */ + ~_BluetoothDeviceImpl(void); + + /** + * Gets the %Bluetooth device's address. + * + * @return The address of the %Bluetooth device + */ + const Tizen::Base::ByteBuffer* GetAddress(void) const; + + /** + * Gets the %Bluetooth device name. + * + * @return The %Bluetooth device name + */ + Tizen::Base::String GetName(void) const; + + /** + * Checks whether this device is paired with the local device. + * + * @return @c true if this device is paired with the local device, @n + * else @c false + */ + bool IsPaired(void) const; + + /** + * Gets the Received Signal Strength Indication (RSSI) value of the device at the time of device discovery (scan). + * + * @return The RSSI value in dbm + */ + int GetRssi(void) const; + + /** + * Gets the major device class. + * + * @return The major device class + */ + BluetoothMajorDeviceClassType GetMajorDeviceClassType(void) const; + + /* + * Gets the minor device class. + * + * @return The minor device class + */ + BluetoothMinorDeviceClassType GetMinorDeviceClassType(void) const; + + /** + * Gets the service class of the %Bluetooth device. @n + * This service class list consists of Tizen::Net::Bluetooth::BluetoothServiceClassType values which are joined by + * the logical OR operator. + * + * @return The service class of the device + * @remarks This operation is not supported in the local device acquired by BluetoothManager::GetLocalDevice(). + */ + unsigned long GetServiceClassList(void) const; + + /** + * Gets the %Bluetooth device service list. @n + * This service list consists of Tizen::Net::Bluetooth::BluetoothServiceType values which are joined by the logical + * OR operator. + * + * @return The %Bluetooth device serviceList + * @remarks This operation is not supported in the local device acquired by BluetoothManager::GetLocalDevice(). + */ + unsigned long GetServiceList(void) const; + + /** + * Gets the %Bluetooth device service UUID list. @n + * This service list consists of Tizen::Base::UuId instances, which represents service UUIDs the device supports. + * + * @return The %Bluetooth device service UUID list + * @remarks This operation returns @c null, if it is called in the local device acquired by + * BluetoothManager::GetLocalDevice(). + */ + const Tizen::Base::Collection::IList* GetServiceUuidList(void) const; + + /** + * Compares the calling instance with the specified instance. + * + * @return @c true, if both the instances are equal @n + * @c false, otherwise + * @param[in] obj The object to compare + */ + virtual bool Equals(const Tizen::Base::Object& obj) const; + + /** + * Gets the hash value of the current instance. + * + * @return The hash value of the current instance + * @remarks Two equal instances return the same hash value. + */ + virtual int GetHashCode(void) const; + + /** + * Sets the address of the %Bluetooth device. + * + * @return An error code + * @param[in] address The Bluetooth device address + * @exception E_SUCCESS The method is successful. + * @exception E_INVALID_ARG The argument is invalid. + */ + result SetAddress(const Tizen::Base::ByteBuffer& address); + + /** + * Sets the name of the %Bluetooth device. + * + * @param[in] name The Bluetooth device address + */ + void SetName(const Tizen::Base::String& name); + + /** + * Sets the major device class. + * + * @param[in] type The major device class + */ + void SetMajorDeviceClassType(BluetoothMajorDeviceClassType type); + + /** + * Sets the minor device class. + * + * @param[in] type The minor device class + */ + void SetMinorDeviceClassType(BluetoothMinorDeviceClassType type); + + /** + * Sets the service class of the %Bluetooth device. @n + * This service class list should consist of Tizen::Net::Bluetooth::BluetoothServiceClassType values which are joined by + * the logical OR operator. + * + * @param[in] listValue The service class of the device + */ + void SetServiceClassList(unsigned long listValue); + + /** + * Sets the service list value of the %Bluetooth device. + * + * @param[in] serviceList The service type list + */ + void SetServiceList(unsigned long serviceList); + + /** + * Sets the service UUID list of the %Bluetooth device. + * + * @param[in] pSrcUuidList The service UUID list + * @param[in] isDeepCopy Set to @c true if the UUID list should be copied deeply @n + * else @c false + * @exception E_SUCCESS The method is successful. + * @exception E_OUT_OF_MEMORY Insufficient memory. + * @exception E_SYSTEM A system error occurred. + */ + result SetServiceUuidList(const Tizen::Base::Collection::IList* pSrcUuidList, bool isDeepCopy); + + /** + * Sets the service list value of the %Bluetooth device. + * + * @param[in] isPaired The service type list + */ + void SetPaired(bool isPaired); + + /** + * Sets the service list value of the %Bluetooth device. + * + * @param[in] rssi The service type list + */ + void SetRssi(int rssi); + + /** + * Transforms the %Bluetooth address from the string type to the byte type. + * + * @return An error code + * @param[in] srcAddr The original %Bluetooth address to be converted + * @param[in] delimiters The delimiters + * @param[out] dstAddr The converted %Bluetooth address as the byte type + * @exception E_SUCCESS The method is successful. + * @exception E_SYSTEM A system error occurred. + */ + static result GetAddressByteBuffer(const Tizen::Base::String& srcAddr, const Tizen::Base::String& delimiters, Tizen::Base::ByteBuffer& dstAddr); + + /** + * Transforms the %Bluetooth address from the byte type to the string type. + * + * @return The converted address string + * @param[in] address The original %Bluetooth address to be converted as the byte type + */ + static Tizen::Base::String GetAddressString(const Tizen::Base::ByteBuffer& address); + + /** + * This assignment operator copies the information from the specified instance of %_BluetoothDeviceImpl to the + * calling instance of %_BluetoothDeviceImpl. + * + * @return A reference to the %_BluetoothDeviceImpl instance + * @param[in] rhs A reference to the %_BluetoothDeviceImpl instance to copy + */ + _BluetoothDeviceImpl& operator =(const _BluetoothDeviceImpl& rhs); + +public: + /** + * Gets the Impl instance. + * + * @return The pointer to _BluetoothDeviceImpl + * @param[in] pBluetoothDevice An instance of BluetoothDevice + */ + static _BluetoothDeviceImpl* GetInstance(BluetoothDevice& bluetoothDevice); + + /** + * Gets the Impl instance. + * + * @return The pointer to _BluetoothDeviceImpl + * @param[in] pBluetoothDevice An instance of BluetoothDevice + */ + static const _BluetoothDeviceImpl* GetInstance(const BluetoothDevice& bluetoothDevice); + +private: + Tizen::Base::ByteBuffer __deviceAddress; + Tizen::Base::String __deviceName; + bool __isPaired; + int __rssi; + BluetoothMajorDeviceClassType __majorClassType; + BluetoothMinorDeviceClassType __minorClassType; + unsigned long __serviceClassList; + unsigned long __serviceList; + std::unique_ptr __pServiceUuidList; + + static const int BT_ADDRESS_LENGTH = 6; + +}; // _BluetoothDeviceImpl + +} } } +#endif // _FNET_BT_INTERNAL_BLUETOOTH_DEVICE_IMPL_H_ diff --git a/src/inc/FNetBt_BluetoothHealthImpl.h b/src/inc/FNetBt_BluetoothHealthImpl.h new file mode 100644 index 0000000..7575721 --- /dev/null +++ b/src/inc/FNetBt_BluetoothHealthImpl.h @@ -0,0 +1,218 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +/** + * @file FNetBt_BluetoothHealthImpl.h + * @brief This is the header file for the _BluetoothHealthImpl class. + * + * This header file contains the declaration of the _BluetoothHealthImpl class. + */ +#ifndef _FNET_BT_INTERNAL_BLUETOOTH_HEALTH_IMPL_H_ +#define _FNET_BT_INTERNAL_BLUETOOTH_HEALTH_IMPL_H_ + +#include +#include +#include +#include +#include +#include +#include "FNetBt_IBluetoothManagerEventListener.h" +#include "FNetBt_IBluetoothDeviceEventListener.h" + +namespace Tizen { namespace Net { namespace Bluetooth +{ +struct _CharDeleter +{ + void operator()(char* pChar) + { + free(pChar); + } +}; + +// Forward declarations +class BluetoothDevice; +class IBluetoothHealthEventListener; +class _BluetoothGapSystemAdapter; +class _BluetoothHdpSystemAdapter; +class _BluetoothHealthEvent; + +/** + * @class _BluetoothHealthImpl + * @brief TBD + */ +class _OSP_EXPORT_ _BluetoothHealthImpl + : public Tizen::Base::Object + , public _IBluetoothManagerEventListener + , public _IBluetoothDeviceEventListener +{ +/** + * @enum _BluetoothHealthStateType + * Defines the states of the Bluetooth Health service. + */ + enum _BluetoothHealthStateType + { + _BT_HEALTH_STATE_DISABLED, + _BT_HEALTH_STATE_IDLE, + _BT_HEALTH_STATE_ON_SERVICE, + _BT_HEALTH_STATE_BONDING, + _BT_HEALTH_STATE_BOND_CANCELING + } ; + +public: + /** + * This is the default constructor for this class. + * + * @remarks After creating an instance of this class, you must explicitly call + * construction method to initialize the instance. + * @see Construct() + */ + _BluetoothHealthImpl(void); + + /** + * This is the destructor for this class. + */ + ~_BluetoothHealthImpl(void); + + /** + * Constructs a BluetoothHealth and attaches a listener to it. + * + * @return An error code + * @param[in] listener The event listener for the %BluetoothHealth + * @exception E_SUCCESS The method is successful. + * @exception E_OUT_OF_MEMORY The memory is insufficient. + * @exception E_OPERATION_FAILED The method has failed. + */ + result Construct(IBluetoothHealthEventListener& listener); + + /** + * Starts %Bluetooth health as a role of sink with the specified data type. + * + * @return An error code + * @param[in] dataType The type of data used in communication which is defined in ISO/IEEE + * 11073-20601 and represents type of health device such as thermometer, + * heart rate monitor, weight scale, and so on + * @exception E_SUCCESS The method is successful. + * @exception E_INVALID_STATE %Bluetooth is not activated. + * @exception E_IN_PROGRESS The sink role with the specified data type has already started. + * @exception E_INVALID_OPERATION The current state of the instance prohibits the execution of the specified + * operation. @n + * For example, the sink role already started with another data type. + * @exception E_SERVICE_UNAVAILABLE The sink role with the specified data type is unavailable now because it + * has started by other instance or application. + * @exception E_OPERATION_FAILED The method has failed. + */ + result StartAsSink(int dataType); + + /** + * Stops %Bluetooth health as a role of sink. @n + * This method disconnects all established channels before stop. + * + * @return An error code + * @exception E_SUCCESS The method is successful. + * @exception E_INVALID_STATE %Bluetooth is not activated. + * @exception E_INVALID_OPERATION The current state of the instance prohibits the execution of the specified + * operation. @n + * For example, the sink role is not started yet. + * @exception E_OPERATION_FAILED The method has failed. + */ + result Stop(void); + + /** + * Sets up a new connection (channel) with a remote health device which has source role. @n + * This method establishes a channel after the source device accepts the request. + * + * @return An error code + * @param[in] remoteDevice The remote device to be connected with + * @exception E_SUCCESS The method is successful. + * @exception E_INVALID_STATE %Bluetooth is not activated. + * @exception E_INVALID_OPERATION The current state of the instance prohibits the execution of the specified + * operation. @n + * For example, the sink role is not started yet. + * @exception E_DEVICE_BUSY The pairing and connection process is in progress. + * @exception E_OPERATION_FAILED The method has failed. + */ + result ConnectToSource(const BluetoothDevice& remoteDevice); + + /** + * Disconnects the connection which has the specified channel ID. @n + * + * @return An error code + * @param[in] channelId The ID of the specified channel to be disconnected + * @exception E_SUCCESS The method is successful. + * @exception E_INVALID_STATE %Bluetooth is not activated. + * @exception E_INVALID_OPERATION The current state of the instance prohibits the execution of the specified + * operation. @n + * For example, there is no connection with the specified channel ID. + * @exception E_OPERATION_FAILED The method has failed. + */ + result Disconnect(int channelId); + + /** + * Sends the specified data on the specified channel. + * + * @return An error code + * @param[in] channelId The ID of the specified channel to send data on + * @param[in] buffer The data to be sent + * @exception E_SUCCESS The method is successful. + * @exception E_INVALID_STATE %Bluetooth is not activated. + * @exception E_INVALID_OPERATION The current state of the instance prohibits the execution of the specified + * operation. @n + * For example, there is no connection with the specified channel ID. + * @exception E_INVALID_ARG The input buffer has no data. + * @exception E_OPERATION_FAILED The operation has failed. + */ + result SendData(int channelId, const Tizen::Base::ByteBuffer& buffer); + + virtual void OnBluetoothActivated(result r); + virtual void OnBluetoothDeactivated(result r); + virtual void OnBluetoothDiscoverableModeChanged(BluetoothDiscoverableMode mode) {} + virtual void OnBluetoothDiscoveryStarted(result r) {} + virtual void OnBluetoothRemoteDeviceFound(const BluetoothDevice& foundDevice) {} + virtual void OnBluetoothDiscoveryDone(bool isCompleted) {} + virtual void OnBluetoothServiceListReceived(const Tizen::Base::ByteBuffer& address, unsigned long serviceList, + const Tizen::Base::Collection::IList* pServiceUuidList, result r) {}; + virtual void OnBluetoothPaired(const BluetoothDevice* pPairedDevice, result r); + virtual void OnBluetoothUnpaired(const Tizen::Base::ByteBuffer& address) {} + virtual void OnBluetoothDeviceConnected(const Tizen::Base::ByteBuffer& address) {} + virtual void OnBluetoothDeviceDisconnected(const Tizen::Base::ByteBuffer& address) {} + void OnBluetoothHealthConnected(int channelId, BluetoothHealthDataChannelType channelType, + const BluetoothDevice* pRemoteDevice, result r); + void OnBluetoothHealthDisconnected(int channelId, result r); + void OnBluetoothHealthDataReceived(int channelId, Tizen::Base::ByteBuffer& buffer); + +private: + _BluetoothHealthImpl(const _BluetoothHealthImpl& value); + _BluetoothHealthImpl& operator =(const _BluetoothHealthImpl& value); + + const char* GetStringOfCurrentState(void) const; + +private: + _BluetoothGapSystemAdapter* __pGapAdapter; + _BluetoothHdpSystemAdapter* __pHdpAdapter; + std::unique_ptr<_BluetoothHealthEvent> __pEvent; + Tizen::Base::Runtime::Mutex __stateMutex; + _BluetoothHealthStateType __currentState; + Tizen::Base::Collection::LinkedListT __channelIdList; + Tizen::Base::ByteBuffer __pairingTargetAddress; + std::unique_ptr __pAppId; + int __dataType; + + static const int _BT_INVALID_DATA_TYPE = 0; + +}; // _BluetoothHealthImpl + +} } } +#endif // _FNET_BT_INTERNAL_BLUETOOTH_HEALTH_IMPL_H_ diff --git a/src/inc/FNetBt_BluetoothManagerImpl.h b/src/inc/FNetBt_BluetoothManagerImpl.h new file mode 100755 index 0000000..89d57d1 --- /dev/null +++ b/src/inc/FNetBt_BluetoothManagerImpl.h @@ -0,0 +1,529 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +/** + * @file FNetBt_BluetoothManagerImpl.h + * @brief This is the header file for the _BluetoothManagerImpl class. + * + * This header file contains the declaration of the _BluetoothManagerImpl class. + */ + +#ifndef _FNET_BT_INTERNAL_BLUETOOTH_MANAGER_IMPL_H_ +#define _FNET_BT_INTERNAL_BLUETOOTH_MANAGER_IMPL_H_ + +#include +#include +#include +#include +#include +#include +#include +#include +#include "FNetBt_IBluetoothManagerEventListener.h" +#include "FNetBt_IBluetoothDeviceEventListener.h" +#include "FNetBt_IBluetoothConnectionEventListener.h" + + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +// Forward declaration +class BluetoothDevice; +class IBluetoothManagerEventListener; +class IBluetoothDeviceEventListener; +class _BluetoothManagerEvent; +class _BluetoothDeviceEvent; +class _BluetoothConnectionEvent; +class _BluetoothIpcProxy; +class _BluetoothGapSystemAdapter; + +/** + * @class BluetoothManager + * @brief This class is used to get information about devices and discover objects, as well as to configure the + * Bluetooth stack. + */ +class _OSP_EXPORT_ _BluetoothManagerImpl + : public Tizen::Base::Object + , public _IBluetoothManagerEventListener + , public _IBluetoothDeviceEventListener + , public _IBluetoothConnectionEventListener +{ + /** + * @enum _BluetoothManagerStateType + * Defines the states of the Bluetooth Manager. + */ + enum _BluetoothManagerStateType + { + _BT_MGR_STATE_DEACTIVATED, + _BT_MGR_STATE_ACTIVATING, + _BT_MGR_STATE_DEACTIVATING, + _BT_MGR_STATE_ACTIVATED, + _BT_MGR_STATE_DISCOVERY_REQUESTED, + _BT_MGR_STATE_ON_DISCOVERY, + _BT_MGR_STATE_DISCOVERY_CANCELING, + _BT_MGR_STATE_ON_DISCOVERY_BY_SYSTEM, + _BT_MGR_STATE_SERVICE_RETRIEVING + }; + + /** + * @enum _BluetoothPairingStateType + * Defines the states which is related to pairing. + */ + enum _BluetoothPairingStateType + { + _BT_PAIRING_STATE_NONE, + _BT_PAIRING_STATE_PAIRING, + _BT_PAIRING_STATE_CANCELING + }; + +public: + /** + * This is the default constructor for this class. + * + * @remarks After creating an instance of this class, you must explicitly call + * the Construct() method to initialize the instance. + * @see Construct() + */ + _BluetoothManagerImpl(void); + + /** + * This is the destructor for this class. + */ + ~_BluetoothManagerImpl(void); + + /** + * Initializes a BluetoothManager instance. + * + * @return An error code + * @param[in] listener The listener to handle %Bluetooth manager event + * @exception E_SUCCESS The method is successful. + * @exception E_OUT_OF_MEMORY Insufficient memory. + * @exception E_SYSTEM A system error occurred. + */ + result Construct(IBluetoothManagerEventListener& listener); + + /** + * Activates %Bluetooth on the device. + * + * @return An error code + * @exception E_SUCCESS The method is successful. + * @exception E_IN_PROGRESS The %Bluetooth activation process is in progress. + * @exception E_INVALID_OPERATION The current state of the instance prohibits the execution of the + * specified operation. @n + * For example, the %Bluetooth is already activated. + * @exception E_SYSTEM A system error occurred. + */ + result Activate(void); + + /** + * Deactivates Bluetooth. + * + * @return An error code + * @exception E_SUCCESS The method is successful. + * @exception E_IN_PROGRESS The %Bluetooth deactivation process is in progress. + * @exception E_INVALID_OPERATION The current state of the instance prohibits the execution of the + * specified operation. @n + * For example, the %Bluetooth is already deactivated. + * @exception E_SYSTEM A system error occurred. + */ + result Deactivate(void); + + /** + * Checks whether the Bluetooth-specific profile is available. + * + * @deprecated This method is deprecated because multiple clients as well as multiple SPP servers with unique + * service UUIDs are supported. Instead of using this method for OPP server, + * BluetoothOppServer::StartService() without checking the OPP server connection's availability is + * recommended. If a new OPP server is not available, the method returns the E_SERVICE_UNAVAILABLE + * exception. + * + * @return @c true if connection is available @n + * @c false, otherwise + * @param[in] type The connection type + * + */ + bool IsAvailable(BluetoothConnectionType type) const; + + /** + * Gets the local device information. + * + * @deprecated This method is deprecated because the return value of this method is a dangling pointer if this + * instance of BluetoothManagerInpl is deleted. Instead of using this method, GetLocalDeviceAddress() and + * GetLocalDeviceName() are recommended. + * + * @return The local device information as a BluetoothDevice instance + * @exception E_SUCCESS The method is successful. + * @exception E_OUT_OF_MEMORY Insufficient memory. + * @exception E_SYSTEM A system error occurred. + */ + const BluetoothDevice* GetLocalDevice(void); + + /** + * Gets the local %Bluetooth device address. + * + * @return The local %Bluetooth device address + * @remarks The address is expressed as a 6 byte hexadecimal value delimited by colon. @n + * For example, "00:3D:47:EF:8A:03". + */ + Tizen::Base::String GetLocalDeviceAddress(void) const; + + /** + * Gets the local %Bluetooth device name. + * + * @return The local %Bluetooth device name + */ + Tizen::Base::String GetLocalDeviceName(void) const; + + /** + * Gets the operational mode of the %Bluetooth unit. + * + * @deprecated BluetoothDeviceStateType is deprecated. Therefore, this method is also deprecated, because the + * return value of this method is of type BluetoothDeviceStateType. Instead of using this method, + * IsActivated() and GetDiscoverableMode() are recommended. + * + * @return The operational mode + */ + BluetoothDeviceStateType GetLocalDeviceState(void) const; + + /** + * Checks whether the local %Bluetooth is activated. + * + * @deprecated This method is deprecated because multiple clients as well as multiple SPP servers with unique + * service UUIDs are supported. Instead of using this method, + * BluetoothOppServer::StartService() without checking the OPP server connection's availability is + * recommended. If a new OPP server is not available, the method returns the E_SERVICE_UNAVAILABLE + * exception. + * + * @return @c true, if the local %Bluetooth is activated @n + * @c false, otherwise + */ + bool IsActivated(void) const; + + /** + * Gets the discoverable mode of the local device. + * + * @return The discoverable mode of the local device + */ + BluetoothDiscoverableMode GetDiscoverableMode(void) const; + + /** + * Gets the remaining time, in seconds, until the discoverable mode is changed from + * BT_DISC_MODE_TIME_LIMITED_DISCOVERABLE to be BT_DISC_MODE_NOT_DISCOVERABLE. @n + * This method is valid only if the current discoverable mode is BT_DISC_MODE_TIME_LIMITED_DISCOVERABLE. + * + * @return The remaining time, in seconds, until the local device to be not discoverable. + * @remarks 0 will be returned if the current discoverable mode is not BT_DISC_MODE_TIME_LIMITED_DISCOVERABLE. + */ + int GetRemainingTimeAsDiscoverable(void) const; + + /** + * Checks whether the device discovery is in progress. + * + * @return @c true, if the device discovery is in progress @n + * @c false, otherwise + */ + bool IsDiscoveryInProgress(void) const; + + /** + * Sets the name of local device. + * + * @return An error code + * @param[in] deviceName The new device name + * @exception E_SUCCESS The method is successful. + * @exception E_INVALID_ARG The specified device name is an empty string. + * @exception E_SYSTEM A system error occurred. + * @remarks This method does not affect system settings. The device name is only valid while an application is + * active. The searching device detects the local devices in close proximity based on the specified + * device name. @n + * The specified device name is automatically truncated if its size is greater than 64 bytes. + */ + result SetLocalDeviceName(const Tizen::Base::String& deviceName); + + /** + * Sets the discoverable mode of the local device. + * + * @visibility partner-manufacturer + * @privlevel system + * @privilege http://tizen.org/privilege/bluetoothmanager + * + * @return An error code + * @param[in] mode The new discoverable mode + * @param[in] seconds The duration in seconds for which the local device is discoverable + * @exception E_SUCCESS The method is successful. + * @exception E_INVALID_ARG The specified @c seconds should be greater than 0 if the specified + * @c mode is BT_DISC_MODE_TIME_LIMITED_DISCOVERABLE. + * @exception E_INVALID_OPERATION %Bluetooth is not activated. + * @exception E_PRIVILEGE_DENIED The application does not have the privilege to call this method. + * @exception E_SYSTEM A system error has occurred. + * @see IBluetoothManagerEventListener::OnBluetoothDiscoverableModeChanged() + * @remarks @c seconds is adopted only if the specified @c mode is BT_DISC_MODE_TIME_LIMITED_DISCOVERABLE. + */ + result SetDiscoverableMode(BluetoothDiscoverableMode mode, int seconds = 0); + + /** + * Refreshes the paired device list. + * + * @deprecated This method is deprecated because the paired device list is refreshed automatically. + * + * @return An error code + * @exception E_SUCCESS The method is successful. + * @exception E_OUT_OF_MEMORY Insufficient memory. + * @exception E_SYSTEM A system error occurred. + */ + result RefreshPairedDeviceList(void); + + /** + * Searches for an element that matches a %Bluetooth address. + * + * @deprecated This API is deprecated because the return value of this API is a dangling pointer. + * Instead of using this API, it recommended to use GetPairedDeviceByAddressN(). + * + * @return The BluetoothDevice containing the specified address if successful @n + * @c null, otherwise + * @param[in] deviceAddress The address to locate + * @exception E_SUCCESS The method is successful. + * @exception E_OBJ_NOT_FOUND The specified device was not found in the paired device list. + * @remarks The specific error code can be accessed using the GetLastResult() method. + */ + const BluetoothDevice* GetPairedDeviceByAddress(const Tizen::Base::ByteBuffer& deviceAddress) const; + + /** + * Searches for an element that matches a %Bluetooth address. + * + * @return The BluetoothDevice containing the specified address if successful @n + * @c null, otherwise + * @param[in] deviceAddress The address to locate + * @exception E_SUCCESS The method is successful. + * @exception E_OBJ_NOT_FOUND The specified device was not found in the paired device list. + * @exception E_OUT_OF_MEMORY Insufficient memory. + * @remarks The specific error code can be accessed using the GetLastResult() method. + */ + BluetoothDevice* GetPairedDeviceByAddressN(const Tizen::Base::ByteBuffer& deviceAddress) const; + + /** + * Searches for elements matching a device name in the paired devices list. + * + * @return A list containing the matching device if successful @n + * @c null, otherwise + * @param[in] deviceName The name of the device to locate + * @exception E_SUCCESS The method is successful. + * @exception E_OBJ_NOT_FOUND The specified device was not found in the paired device list. + * @exception E_OUT_OF_MEMORY Insufficient memory. + * @remarks The specific error code can be accessed using the GetLastResult() method. + */ + Tizen::Base::Collection::IList* GetPairedDeviceByNameN(const Tizen::Base::String& deviceName) const; + + /** + * Gets the element at the specified index. + * + * @deprecated This API is deprecated because the return value of this API is a dangling pointer. + * Instead of using this API, it recommended to use GetPairedDeviceListN() and + * Tizen::Base::Collection::IList operations. + * + * @return The BluetoothDevice at the given index, if successful @n + * @c null, otherwise + * @param[in] index The index in the list + * @exception E_SUCCESS The method is successful. + * @exception E_OBJ_NOT_FOUND The specified index was not found in the PairedDevice list. + */ + const BluetoothDevice* GetPairedDeviceAt(int index) const; + + /** + * Gets the paired device list. + * + * @deprecated This API is deprecated because the return value of this API is a dangling pointer. + * Instead of using this API, it recommended to use GetPairedDeviceListN(). + * + * @return Pointer to the paired device list on success @n + * @c null, otherwise + */ + const Tizen::Base::Collection::IList* GetPairedDeviceList(void) const; + + /** + * Gets the paired device list. + * + * @return A pointer to the paired device list on success @n + * @c null, otherwise + * @exception E_SUCCESS The method is successful. + * @exception E_OUT_OF_MEMORY Insufficient memory. + * @remarks The specific error code can be accessed using the GetLastResult() method. + */ + Tizen::Base::Collection::IList* GetPairedDeviceListN(void) const; + + /** + * Sets a Device event listener for searching devices and services. + * + * @return An error code + * @param[in] pListener The Device event listener to be added + * @exception E_SUCCESS The method is successful. + * @exception E_SYSTEM A system error occurred. + */ + result SetBluetoothDeviceListener(IBluetoothDeviceEventListener* pListener); + + /** + * Sets a Connection event listener. + * + * @return An error code + * @param[in] pListener The Connection event listener to be added + * @exception E_SUCCESS The method is successful. + * @exception E_SYSTEM A system error occurred. + */ + result SetBluetoothConnectionListener(_IBluetoothConnectionEventListener* pListener); + + /** + * Starts a device discovery process. + * + * @return An error code + * @exception E_SUCCESS The method is successful. + * @exception E_IN_PROGRESS The discovery process is in progress. + * @exception E_INVALID_OPERATION The current state of the instance prohibits the execution of this operation. + * @exception E_SYSTEM A system error occurred. + */ + result StartDiscovery(void); + + /** + * Stops the device discovery process. + * + * @return An error code + * @exception E_SUCCESS The method is successful. + * @exception E_IN_PROGRESS The canceling is in progress. + * @exception E_INVALID_OPERATION The current state of the instance prohibits the execution of this operation. E.g. Discovery is not started. + * @exception E_SYSTEM A system error occurred. + */ + result CancelDiscovery(void); + + /** + * Retrieves the service list from a remote device. + * + * @return An error code + * @param[in] pairedDevice A remote device which is already paired with this local device + * @exception E_SUCCESS The method is successful. + * @exception E_IN_PROGRESS The retrieving is in progress. + * @exception E_INVALID_OPERATION The current state of the instance prohibits the execution of this + * operation. @n + * For example, the discovery is in progress. + * @exception E_NOT_PAIRED The input device is not found in the paired device list. + * @exception E_SYSTEM A system error occurred. + */ + result RetrieveServiceList(const BluetoothDevice& pairedDevice); + + /** + * Pairs with the specified remote device. + * + * @return An error code + * @param[in] remoteDevice The remote %Bluetooth device to be paired with + * @exception E_SUCCESS The method is successful. + * @exception E_INVALID_OPERATION The current state of the instance prohibits the execution of this + * operation. @n + * For example, the %Bluetooth is not activated. + * @exception E_DEVICE_BUSY The device cannot be approached because other operation is in progress. + * @exception E_SYSTEM A system error has occurred. + */ + result Pair(const BluetoothDevice& remoteDevice); + + /** + * Stops the pairing process. + * + * @return An error code + * @exception E_SUCCESS The method is successful. + * @exception E_INVALID_OPERATION The current state of the instance prohibits the execution of this + * operation. @n + * For example, the pairing process is not in progress. + * @exception E_IN_PROGRESS The termination of the pairing process is in progress. + * @exception E_SYSTEM A system error has occurred. + */ + result CancelPair(void); + + /** + * Unpairs the paired devices. + * + * @return An error code + * @param[in] pairedDevice The paired device to unpair + * @exception E_SUCCESS The method is successful. + * @exception E_INVALID_OPERATION The current state of the instance prohibits the execution of this + * operation. @n + * For example, the %Bluetooth is not activated or retrieving the service + * list is in progress. + * @exception E_NOT_PAIRED The input device is not found in the paired device list. + * @exception E_SYSTEM A system error occurred. + * @remarks The process of unpairing is to remove the specified device from the paired device list. No + * notification is transmitted to the remote device. @n + * This method is synchronous. When the result of this method is E_SUCCESS, the unpaired event is + * fired. @n + */ + result Unpair(const BluetoothDevice& pairedDevice); + + + // Callback functions which called by _BluetoothSystemAdapter + virtual void OnBluetoothActivated(result r); + virtual void OnBluetoothDeactivated(result r); + virtual void OnBluetoothDiscoverableModeChanged(BluetoothDiscoverableMode mode); + virtual void OnBluetoothDiscoveryStarted(result r); + virtual void OnBluetoothRemoteDeviceFound(const BluetoothDevice& foundDevice); + virtual void OnBluetoothDiscoveryDone(bool isCompleted); + virtual void OnBluetoothServiceListReceived(const Tizen::Base::ByteBuffer& address, unsigned long serviceList, + const Tizen::Base::Collection::IList* pServiceUuidList, result r); + virtual void OnBluetoothPaired(const BluetoothDevice* pPairedDevice, result r); + virtual void OnBluetoothUnpaired(const Tizen::Base::ByteBuffer& address); + virtual void OnBluetoothDeviceConnected(const Tizen::Base::ByteBuffer& address); + virtual void OnBluetoothDeviceDisconnected(const Tizen::Base::ByteBuffer& address); + +private: + _BluetoothManagerImpl(const _BluetoothManagerImpl& value); + _BluetoothManagerImpl& operator =(const _BluetoothManagerImpl& value); + + result RefreshPairedDeviceMap(void); + const char* GetStringOfCurrentState(void) const; + const char* GetStringOfPairingState(void) const; + +public: + /** + * Gets the Impl instance. + * + * @return The pointer to _BluetoothManagerImpl + * @param[in] bluetoothManager An instance of BluetoothManager + */ + static _BluetoothManagerImpl* GetInstance(BluetoothManager& bluetoothManager); + + /** + * Gets the Impl instance. + * + * @return The pointer to _BluetoothDeviceImpl + * @param[in] bluetoothManager An instance of BluetoothManager + */ + static const _BluetoothManagerImpl* GetInstance(const BluetoothManager& bluetoothManager); + +private: + _BluetoothIpcProxy* __pIpcProxy; + _BluetoothGapSystemAdapter* __pGapAdapter; + std::unique_ptr<_BluetoothManagerEvent> __pMgrEvent; + std::unique_ptr<_BluetoothDeviceEvent> __pDevEvent; + std::unique_ptr<_BluetoothConnectionEvent> __pConEvent; + const IBluetoothDeviceEventListener* __pDevEvtListener; + const _IBluetoothConnectionEventListener* __pConEvtListener; + BluetoothDevice* __pLocalDevice; + Tizen::Base::Collection::ArrayList __pairedDeviceList; // for APIs prior to 2.0 + Tizen::Base::Collection::HashMap __pairedDeviceMap; + Tizen::Base::Runtime::Mutex __stateMutex; + Tizen::Base::Runtime::Mutex __pairedDevMapMutex; + _BluetoothManagerStateType __currentState; + _BluetoothPairingStateType __pairingState; + Tizen::Base::ByteBuffer __pairingTargetAddress; + Tizen::Base::Collection::LinkedList __discoveredDeviceList; +}; // _BluetoothManagerImpl + +} } } +#endif // _FNET_BT_INTERNAL_BLUETOOTH_MANAGER_IMPL_H_ diff --git a/src/inc/FNetBt_BluetoothOppClientImpl.h b/src/inc/FNetBt_BluetoothOppClientImpl.h new file mode 100644 index 0000000..3f5ed4e --- /dev/null +++ b/src/inc/FNetBt_BluetoothOppClientImpl.h @@ -0,0 +1,177 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +/** + * @file FNetBt_BluetoothOppClientImpl.h + * @brief This is the header file for the _BluetoothOppClientImpl class. + * + * This header file contains the declaration of the _BluetoothOppClientImpl class. + */ +#ifndef _FNET_BT_INTERNAL_BLUETOOTH_OPP_CLIENT_IMPL_H_ +#define _FNET_BT_INTERNAL_BLUETOOTH_OPP_CLIENT_IMPL_H_ + +#include +#include +#include +#include +#include +#include +#include +#include "FNetBt_IBluetoothManagerEventListener.h" +#include "FNetBt_IBluetoothDeviceEventListener.h" + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +// forward declarations +class BluetoothDevice; +class IBluetoothOppClientEventListener; +class _BluetoothGapSystemAdapter; +class _BluetoothOppSystemAdapter; +class _BluetoothOppClientEvent; + +/** + * @class _BluetoothOppClientImpl + * @brief TBD. + */ +class _OSP_EXPORT_ _BluetoothOppClientImpl + : public Tizen::Base::Object + , public _IBluetoothManagerEventListener + , public _IBluetoothDeviceEventListener +{ +/** + * @enum _BluetoothOppClientStateType + * Defines the states of the Bluetooth Opp client. + */ + enum _BluetoothOppClientStateType + { + _BT_OPP_CLI_STATE_DISABLED, + _BT_OPP_CLI_STATE_IDLE, + _BT_OPP_CLI_STATE_BONDING, + _BT_OPP_CLI_STATE_PUSH_READY, + _BT_OPP_CLI_STATE_REQ_CANCELING, + _BT_OPP_CLI_STATE_ON_TRANSFER, + _BT_OPP_CLI_STATE_TRANS_CANCELING + }; + +public: + /** + * This is the default constructor for this class. + * + * @remarks After creating an instance of this class, you must explicitly call + * construction method to initialize the instance. + * @see Construct() + */ + _BluetoothOppClientImpl(void); + + /** + * This is the destructor for this class. + */ + ~_BluetoothOppClientImpl(void); + + /** + * Constructs a BluetoothOppClient and attaches a listener to it. + * + * @return An error code + * @param[in] listener The event listener for OPP client. + * @exception E_SUCCESS The method is successful. + * @exception E_OUT_OF_MEMORY Insufficient memory. + * @exception E_SYSTEM A system error has occurred. + */ + result Construct(IBluetoothOppClientEventListener& listener); + + /** + * Pushes a file to a remote OPP server. + * + * @return An error code + * @param[in] remoteDevice The remote OPP server. + * @param[in] filePath The path of the source file + * @exception E_SUCCESS The method is successful. + * @exception E_FAILURE The method has failed. + * @exception E_IN_PROGRESS The push process is in progress. + * @exception E_INVALID_STATE Bluetooth has been deactivated. + * @exception E_INACCESSIBLE_PATH The specified @c filePath is inaccessible. + * @exception E_SERVICE_UNAVAILABLE OPP service is not available. + */ + result PushFile(const BluetoothDevice& remoteDevice, const Tizen::Base::String& filePath); + + /** + * Cancels the file push request in progress. + * + * @return An error code + * @exception E_SUCCESS The method is successful. + * @exception E_FAILURE The method failed. + * @exception E_INVALID_STATE Bluetooth has been deactivated. + * @exception E_IN_PROGRESS The canceling process is in progress. + * @exception E_INVALID_OPERATION The current state of the instance prohibits the execution of the specified + * operation. @n + * For example, the push request is not sent or accepted by a remote device. + */ + result CancelPush(void); + + /** + * Specifies the minimum interval of invocation of OnOppTransferInProgress() in percentage. + * The default value is 5. + * + * @return An error code + * @param[in] percent The minimum period of progress interval as a percentage value + * @exception E_SUCCESS The method is successful. + * @exception E_OUT_OF_RANGE The value of the argument is outside the valid range defined by the method. + * + * @see IBluetoothOppClientEventListener::OnOppTransferInProgress() + */ + result SetMinProgressInterval(int percent); + + + // Callback functions which called by _BluetoothOppSystemAdapter + virtual void OnBluetoothActivated(result r); + virtual void OnBluetoothDeactivated(result r); + virtual void OnBluetoothDiscoverableModeChanged(BluetoothDiscoverableMode mode) {} + virtual void OnBluetoothDiscoveryStarted(result r) {} + virtual void OnBluetoothRemoteDeviceFound(const BluetoothDevice& foundDevice) {} + virtual void OnBluetoothDiscoveryDone(bool isCompleted) {} + virtual void OnBluetoothServiceListReceived(const Tizen::Base::ByteBuffer& address, unsigned long serviceList, + const Tizen::Base::Collection::IList* pServiceUuidList, result r) {}; + virtual void OnBluetoothPaired(const BluetoothDevice* pPairedDevice, result r); + virtual void OnBluetoothUnpaired(const Tizen::Base::ByteBuffer& address) {} + virtual void OnBluetoothDeviceConnected(const Tizen::Base::ByteBuffer& address) {} + virtual void OnBluetoothDeviceDisconnected(const Tizen::Base::ByteBuffer& address) {} + void OnOppPushResponded(result r); + void OnOppTransferInProgress(int percent); + void OnOppTransferDone(const Tizen::Base::String& filePath, int fileSize, bool isCompleted); + +private: + _BluetoothOppClientImpl(const _BluetoothOppClientImpl& value); + _BluetoothOppClientImpl& operator =(const _BluetoothOppClientImpl& value); + + const char* GetStringOfCurrentState(void) const; + +private: + const static int __defaultProgressInterval = 5; + + _BluetoothGapSystemAdapter* __pGapAdapter; + _BluetoothOppSystemAdapter* __pOppAdapter; + std::unique_ptr<_BluetoothOppClientEvent> __pEvent; + Tizen::Base::Runtime::Mutex __stateMutex; + _BluetoothOppClientStateType __currentState; + Tizen::Base::ByteBuffer __pairingAddress; + Tizen::Base::String __pushedFilePath; + int __minProgressInterval; + int __previousProgress; +}; // _BluetoothOppClientImpl + +} } } +#endif // _FNET_BT_INTERNAL_BLUETOOTH_OPP_CLIENT_IMPL_H_ diff --git a/src/inc/FNetBt_BluetoothOppServerImpl.h b/src/inc/FNetBt_BluetoothOppServerImpl.h new file mode 100644 index 0000000..bb26a49 --- /dev/null +++ b/src/inc/FNetBt_BluetoothOppServerImpl.h @@ -0,0 +1,224 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +/** + * @file FNetBt_BluetoothOppServerImpl.h + * @brief This is the header file for the _BluetoothOppServerImpl Class. + * + * This header file contains the declaration of the _BluetoothOppServerImpl Class. + */ +#ifndef _FNET_BT_INTERNAL_BLUETOOTH_OPP_SERVER_IMPL_H_ +#define _FNET_BT_INTERNAL_BLUETOOTH_OPP_SERVER_IMPL_H_ + +#include +#include +#include +#include +#include +#include +#include "FNetBt_IBluetoothManagerEventListener.h" + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +// forward declarations +class BluetoothDevice; +class IBluetoothOppServerEventListener; +class _BluetoothGapSystemAdapter; +class _BluetoothOppSystemAdapter; +class _BluetoothOppServerEvent; + +/** + * @class _BluetoothOppServerImpl + * @brief TBD. + */ +class _OSP_EXPORT_ _BluetoothOppServerImpl + : public Tizen::Base::Object + , public _IBluetoothManagerEventListener +{ +/** + * @enum _BluetoothOppServerStateType + * Defines the states of the Bluetooth SPP Acceptor. + */ + enum _BluetoothOppServerStateType + { + _BT_OPP_SVR_STATE_DISABLED, + _BT_OPP_SVR_STATE_IDLE, + _BT_OPP_SVR_STATE_ON_SERVICE, + _BT_OPP_SVR_STATE_PUSH_REQUESTED, + _BT_OPP_SVR_STATE_ON_TRANSFER, + _BT_OPP_SVR_STATE_ON_STOPPING + }; + +public: + /** + * This is the default constructor for this class. + * + * @remarks After creating an instance of this class, you must explicitly call + * construction method to initialize the instance. + * @see Construct() + */ + _BluetoothOppServerImpl(void); + + /** + * This is the destructor for this class. + */ + ~_BluetoothOppServerImpl(void); + + /** + * Constructs a BluetoothOppServer and attaches a listener to it. + * + * @return An error code + * @param[in] listener The event listener for OPP server + * @exception E_SUCCESS The method is successful. + * @exception E_OUT_OF_MEMORY Insufficient memory. + * @exception E_SYSTEM A system error has occurred. + */ + result Construct(IBluetoothOppServerEventListener& listener); + + /** + * Accepts a push request from a remote OPP client. + * + * @return An error code + * @exception E_SUCCESS The method is successful. + * @exception E_FAILURE The method failed. + * @exception E_INVALID_STATE Bluetooth has been deactivated. + * @exception E_INVALID_OPERATION The current state of the instance prohibits the execution of the specified + * operation. @n + * For example, the service is not started yet or a push request is not + * received from a remote device. + */ + result AcceptPush(void); + + /** + * Rejects a push request from a remote OPP client. + * + * @return An error code + * @exception E_SUCCESS The method is successful. + * @exception E_FAILURE The method failed. + * @exception E_INVALID_STATE Bluetooth has been deactivated. + * @exception E_INVALID_OPERATION The current state of the instance prohibits the execution of the specified + * operation. @n + * For example, the service is not started yet or a push request is not + * received from a remote device. + */ + result RejectPush(void); + + /** + * Sets the destination path of the file to be received. + * + * @return An error code + * @param[in] dstPath The new destination file path + * @exception E_SUCCESS The method is successful. + * @exception E_INVALID_OPERATION The current state of the instance prohibits the execution of the specified + * operation. @n + * For example, trying to change the path on Push transition is prohibited. + * @exception E_INACCESSIBLE_PATH The specified @c dstPath is inaccessible. + * @exception E_FAILURE The method has failed. + */ + result SetDestinationPath(const Tizen::Base::String& dstPath); + + /** + * Starts the OPP service and associates a listener with it. + * + * @return An error code + * @param[in] dstPath The new destination file path + * @exception E_SUCCESS The method is successful. + * @exception E_FAILURE The method failed. + * @exception E_IN_PROGRESS The service has already started. + * @exception E_INVALID_STATE Bluetooth has been deactivated. + * @exception E_INVALID_OPERATION The current state of the instance prohibits the execution of the specified + * operation. @n + * For example, The stop process is in progress. + * @exception E_INACCESSIBLE_PATH The specified @c dstPath is inaccessible. + * @exception E_SERVICE_UNAVAILABLE OPP service is not available. + */ + result StartService(const Tizen::Base::String& dstPath); + + /** + * Stops the OPP service. + * + * @return An error code + * @exception E_SUCCESS The method is successful. + * @exception E_FAILURE The method failed. + * @exception E_INVALID_STATE Bluetooth has been deactivated. + * @exception E_INVALID_OPERATION The current state of the instance prohibits the execution of the specified + * operation. @n + * For example, the service is not started as yet. + */ + result StopService(void); + + /** + * Stops the file transfer in progress which was started by the client. @n + * If this method is called during the file transfer, the IBluetoothOppServerEventListener::OnOppTransferDone() + * method is called with @c isCompleted as @c false. + * + * @return An error code + * @exception E_SUCCESS The method is successful. + * @exception E_INVALID_STATE This instance is in an invalid state. @n + * For example, %Bluetooth is not activated. + * @exception E_INVALID_OPERATION The current state of the instance prohibits the execution of the specified + * operation. @n + * For example, the file transfer is not in progress. + * @exception E_OPERATION_FAILED The operation has failed. + * @see IBluetoothOppServerEventListener::OnOppTransferDone() + */ + result StopTransfer(void); + + /** + * Specifies the minimum interval of invocation of OnOppTransferInProgress() in percentage. + * The default value is 5. + * + * @return An error code + * @param[in] percent The minimum period of progress interval as a percentage value + * @exception E_SUCCESS The method is successful. + * @exception E_OUT_OF_RANGE The value of the argument is outside the valid range defined by the method. + * + * @see IBluetoothOppServerEventListener::OnOppTransferInProgress() + */ + result SetMinProgressInterval(int percent); + + + // Callback functions which called by _BluetoothSystemAdapter + virtual void OnBluetoothActivated(result r); + virtual void OnBluetoothDeactivated(result r); + virtual void OnBluetoothDiscoverableModeChanged(BluetoothDiscoverableMode mode) {} + void OnOppPushRequested(const BluetoothDevice& device); + void OnOppTransferInProgress(int percent); + void OnOppTransferDone(const Tizen::Base::String& filePath, int fileSize, bool isCompleted); + +private: + _BluetoothOppServerImpl(const _BluetoothOppServerImpl& value); + _BluetoothOppServerImpl& operator =(const _BluetoothOppServerImpl& value); + + const char* GetStringOfCurrentState(void) const; + +private: + const static int __defaultProgressInterval = 5; + + _BluetoothGapSystemAdapter* __pGapAdapter; + _BluetoothOppSystemAdapter* __pOppAdapter; + std::unique_ptr<_BluetoothOppServerEvent> __pEvent; + Tizen::Base::Runtime::Mutex __stateMutex; + _BluetoothOppServerStateType __currentState; + Tizen::Base::String __pushedFileName; + int __minProgressInterval; + int __previousProgress; + +}; // _BluetoothOppServerImpl + +} } } +#endif // _FNET_BT_INTERNAL_BLUETOOTH_OPP_SERVER_IMPL_H_ diff --git a/src/inc/FNetBt_BluetoothSppAcceptorImpl.h b/src/inc/FNetBt_BluetoothSppAcceptorImpl.h new file mode 100644 index 0000000..9286254 --- /dev/null +++ b/src/inc/FNetBt_BluetoothSppAcceptorImpl.h @@ -0,0 +1,212 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +/** + * @file FNetBt_BluetoothSppAcceptorImpl.h + * @brief This is the header file for the _BluetoothSppAcceptorImpl class. + * + * This header file contains the declaration of the _BluetoothSppAcceptorImpl class. + */ +#ifndef _FNET_BT_INTERNAL_BLUETOOTH_SPP_ACCEPTOR_IMPL_H_ +#define _FNET_BT_INTERNAL_BLUETOOTH_SPP_ACCEPTOR_IMPL_H_ + +#include +#include +#include +#include +#include "FNetBt_IBluetoothManagerEventListener.h" +#include "FNetBt_IBluetoothSocketListener.h" + +//Forward declarations +namespace Tizen { namespace Base +{ +class ByteBuffer; +class UuId; +} } + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +// forward declarations +class BluetoothDevice; +class IBluetoothSppAcceptorEventListener; +class _BluetoothSppAcceptorEvent; +class _BluetoothGapSystemAdapter; +class _BluetoothSppSystemAdapter; + +/** + * @class _BluetoothSppAcceptorImpl + * @brief TBD. + */ +class _OSP_EXPORT_ _BluetoothSppAcceptorImpl + : public Tizen::Base::Object + , public _IBluetoothManagerEventListener + , public _IBluetoothSocketListener +{ +/** + * @enum _BluetoothSppAcceptorStateType + * Defines the states of the Bluetooth SPP Acceptor. + */ + enum _BluetoothSppAcceptorStateType + { + _BT_SPP_ACC_STATE_DISABLED, + _BT_SPP_ACC_STATE_IDLE, + _BT_SPP_ACC_STATE_ON_SERVICE, + _BT_SPP_ACC_STATE_CONNECT_REQUESTED, + _BT_SPP_ACC_STATE_CONNECTED + }; + +public: + /** + * This is the default constructor for this class. + * + * @remarks After creating an instance of this class, you must explicitly call + * construction method to initialize the instance. + * @see Construct() + */ + _BluetoothSppAcceptorImpl(void); + + /** + * This is the destructor for this class. + */ + ~_BluetoothSppAcceptorImpl(void); + + /** + * Constructs a BluetoothSppAcceptor and attaches a listener to it. + * + * @return An error code + * @param[in] listener The event listener for SPP accepter. + * @exception E_SUCCESS The method is successful. + * @exception E_OUT_OF_MEMORY Insufficient memory. + * @exception E_SYSTEM A system error has occurred. + */ + result Construct(IBluetoothSppAcceptorEventListener& listener); + + /** + * Accepts a connection request from a remote SPP initiator. + * + * @return An error code + * @exception E_SUCCESS The method is successful. + * @exception E_FAILURE The method failed. + * @exception E_INVALID_STATE Bluetooth has been deactivated. + * @exception E_INVALID_OPERATION The current state of the instance prohibits the execution of the specified + * operation. @n + * For example, the service is not started yet or the connection request is + * not yet received from a remote device. + */ + result AcceptConnection(void); + + /** + * Rejects a connection request from a remote SPP initiator. + * + * @return An error code + * @exception E_SUCCESS The method is successful. + * @exception E_FAILURE The method failed. + * @exception E_INVALID_STATE Bluetooth has been deactivated. + * @exception E_INVALID_OPERATION The current state of the instance prohibits the execution of the specified + * operation. @n + * For example, the service is not started yet or the connection request is + * not yet received from a remote device. + */ + result RejectConnection(void); + + /** + * Starts SPP service with the specified service UUID. + * + * @return An error code + * @param[in] serviceUuid The UUID of SPP service + * @exception E_SUCCESS The method is successful. + * @exception E_FAILURE The method failed. + * @exception E_INVALID_STATE Bluetooth has been deactivated. + * @exception E_SERVICE_UNAVAILABLE SPP service with the specified UUID is not available. + * @exception E_INVALID_ARG The specified input parameter is invalid. + * @exception E_IN_PROGRESS The service has already started. + * @exception E_ALREADY_CONNECTED The connection with an SPP initiator has already been established. + */ + result StartService(const Tizen::Base::UuId& serviceUuid); + + /** + * Stops the SPP service. + * + * @return An error code + * @exception E_SUCCESS The method is successful. + * @exception E_FAILURE The method failed. + * @exception E_INVALID_STATE Bluetooth has been deactivated. + * @exception E_INVALID_OPERATION The current state of the instance prohibits the execution of the specified + * operation. @n + * For example, the service is not started yet. + */ + result StopService(void); + + /** + * Disconnects the current connection. + * + * @return An error code + * @exception E_SUCCESS The method is successful. + * @exception E_FAILURE The method failed. + * @exception E_INVALID_STATE Bluetooth has been deactivated. + * @exception E_INVALID_OPERATION The current state of the instance prohibits the execution of the specified + * operation. @n + * For example, the service is not started yet or a connection with a remote + * device is not established. + */ + result Disconnect(void); + + /** + * Sends data. + * + * @return An error code + * @param[in] buffer The data to send + * @exception E_SUCCESS The method is successful. + * @exception E_FAILURE The method has failed. + * @exception E_INVALID_STATE Bluetooth has been deactivated. + * @exception E_INVALID_ARG The argument is null or contains an invalid value. + * @exception E_INVALID_OPERATION The current state of the instance prohibits the execution of the specified + * operation. @n + * For example, the service is not started yet or a connection with a remote + * device is not established. + * @exception E_SYSTEM A system error occurred. + */ + result SendData(const Tizen::Base::ByteBuffer& buffer); + + virtual void OnBluetoothActivated(result r); + virtual void OnBluetoothDeactivated(result r); + virtual void OnBluetoothDiscoverableModeChanged(BluetoothDiscoverableMode mode) {} + virtual void OnSocketConnectionRequested(const BluetoothDevice& device); + virtual void OnSocketConnectionResponded(int socketFd, result r) {} + virtual void OnSocketDisconnected(result r); + virtual void OnSocketDataReceived(Tizen::Base::ByteBuffer& buffer); + +private: + _BluetoothSppAcceptorImpl(const _BluetoothSppAcceptorImpl& value); + _BluetoothSppAcceptorImpl& operator =(const _BluetoothSppAcceptorImpl& value); + + const char* GetStringOfCurrentState(void) const; + result ProcessAsyncDisconnect(void); + +private: + _BluetoothGapSystemAdapter* __pGapAdapter; + _BluetoothSppSystemAdapter* __pSppAdapter; + std::unique_ptr<_BluetoothSppAcceptorEvent> __pEvent; + Tizen::Base::Runtime::Mutex __stateMutex; + _BluetoothSppAcceptorStateType __currentState; + int __parentSocketFd; + int __childSocketFd; + +}; // _BluetoothSppAcceptorImpl + +} } } +#endif // _FNET_BT_INTERNAL_BLUETOOTH_SPP_ACCEPTOR_IMPL_H_ diff --git a/src/inc/FNetBt_BluetoothSppInitiatorImpl.h b/src/inc/FNetBt_BluetoothSppInitiatorImpl.h new file mode 100644 index 0000000..8e3bfe6 --- /dev/null +++ b/src/inc/FNetBt_BluetoothSppInitiatorImpl.h @@ -0,0 +1,184 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +/** + * @file FNetBt_BluetoothSppInitiatorImpl.h + * @brief This is the header file for the _BluetoothSppInitiatorImpl class. + * + * This header file contains the declaration of the _BluetoothSppInitiatorImpl class. + */ +#ifndef _FNET_BT_INTERNAL_BLUETOOTH_SPP_INITIATOR_IMPL_H_ +#define _FNET_BT_INTERNAL_BLUETOOTH_SPP_INITIATOR_IMPL_H_ + +#include +#include +#include +#include +#include +#include +#include "FNetBt_IBluetoothManagerEventListener.h" +#include "FNetBt_IBluetoothDeviceEventListener.h" +#include "FNetBt_IBluetoothSocketListener.h" + +//Forward declarations +namespace Tizen { namespace Base +{ +class UuId; +} } + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +// forward declarations +class BluetoothDevice; +class IBluetoothSppInitiatorEventListener; +class _BluetoothSppInitiatorEvent; +class _BluetoothGapSystemAdapter; +class _BluetoothSppSystemAdapter; + +/** + * @class _BluetoothSppInitiatorImpl + * @brief TBD + */ +class _OSP_EXPORT_ _BluetoothSppInitiatorImpl + : public Tizen::Base::Object + , public _IBluetoothManagerEventListener + , public _IBluetoothDeviceEventListener + , public _IBluetoothSocketListener +{ +/** + * @enum _BluetoothSppInitiatorStateType + * Defines the states of the Bluetooth SPP Acceptor. + */ + enum _BluetoothSppInitiatorStateType + { + _BT_SPP_INI_STATE_DISABLED, + _BT_SPP_INI_STATE_IDLE, + _BT_SPP_INI_STATE_BONDING, + _BT_SPP_INI_STATE_CONNECT_READY, + _BT_SPP_INI_STATE_REQ_CANCELING, + _BT_SPP_INI_STATE_CONNECTED + } ; + +public: + /** + * This is the default constructor for this class. + * + * @remarks After creating an instance of this class, you must explicitly call + * construction method to initialize the instance. + * @see Construct() + */ + _BluetoothSppInitiatorImpl(void); + + /** + * This is the destructor for this class. + */ + ~_BluetoothSppInitiatorImpl(void); + + /** + * Constructs a BluetoothSppInitiator and attaches a listener to it. + * + * @return An error code + * @param[in] listener The event listener for SPP initiator. + * @exception E_SUCCESS The method is successful. + * @exception E_OUT_OF_MEMORY Insufficient memory. + */ + result Construct(IBluetoothSppInitiatorEventListener& listener); + + /** + * Sets up a connection to a remote SPP acceptor. + * + * @return An error code + * @param[in] remoteDevice The remote device to be connected + * @param[in] serviceUuid The UUID of SPP service to be connected + * @exception E_SUCCESS The method is successful. + * @exception E_FAILURE The method failed. + * @exception E_INVALID_ARG A specified input parameter is invalid. + * @exception E_INVALID_STATE Bluetooth has been deactivated. + * @exception E_IN_PROGRESS The connection process is in progress. + * @exception E_ALREADY_CONNECTED The connection with an SPP acceptor has already been established. + */ + result Connect(const BluetoothDevice& remoteDevice, const Tizen::Base::UuId& serviceUuid); + + /** + * Disconnects the current connection. + * + * @return An error code + * @exception E_SUCCESS The method is successful. + * @exception E_FAILURE The method failed. + * @exception E_INVALID_STATE Bluetooth has been deactivated. + * @exception E_INVALID_OPERATION The current state of the instance prohibits the execution of the specified + * operation. @n + * For example, the connection request is not sent or a connection with a + * remote device is not established yet. + */ + result Disconnect(void); + + /** + * Sends data. + * + * @return An error code + * @param[in] buffer The data to send + * @exception E_SUCCESS The method is successful. + * @exception E_FAILURE The method has failed. + * @exception E_INVALID_STATE Bluetooth has been deactivated. + * @exception E_INVALID_ARG The argument is null or contains an invalid value. + * @exception E_INVALID_OPERATION The current state of the instance prohibits the execution of the specified + * operation. @n + * For example, the connection request is not sent or a connection with a + * remote device is not established yet. + * @exception E_SYSTEM A system error occurred. + */ + result SendData(const Tizen::Base::ByteBuffer& buffer); + + virtual void OnBluetoothActivated(result r); + virtual void OnBluetoothDeactivated(result r); + virtual void OnBluetoothDiscoverableModeChanged(BluetoothDiscoverableMode mode) {} + virtual void OnBluetoothDiscoveryStarted(result r) {} + virtual void OnBluetoothRemoteDeviceFound(const BluetoothDevice& foundDevice) {} + virtual void OnBluetoothDiscoveryDone(bool isCompleted) {} + virtual void OnBluetoothServiceListReceived(const Tizen::Base::ByteBuffer& address, unsigned long serviceList, + const Tizen::Base::Collection::IList* pServiceUuidList, result r) {}; + virtual void OnBluetoothPaired(const BluetoothDevice* pPairedDevice, result r); + virtual void OnBluetoothUnpaired(const Tizen::Base::ByteBuffer& address) {} + virtual void OnBluetoothDeviceConnected(const Tizen::Base::ByteBuffer& address) {} + virtual void OnBluetoothDeviceDisconnected(const Tizen::Base::ByteBuffer& address) {} + virtual void OnSocketConnectionRequested(const BluetoothDevice& device) {} + virtual void OnSocketConnectionResponded(int socketFd, result r); + virtual void OnSocketDisconnected(result r); + virtual void OnSocketDataReceived(Tizen::Base::ByteBuffer& buffer); + +private: + _BluetoothSppInitiatorImpl(const _BluetoothSppInitiatorImpl& value); + _BluetoothSppInitiatorImpl& operator =(const _BluetoothSppInitiatorImpl& value); + + const char* GetStringOfCurrentState(void) const; + result ProcessAsyncDisconnect(void); + +private: + _BluetoothGapSystemAdapter* __pGapAdapter; + _BluetoothSppSystemAdapter* __pSppAdapter; + std::unique_ptr<_BluetoothSppInitiatorEvent> __pEvent; + Tizen::Base::Runtime::Mutex __stateMutex; + _BluetoothSppInitiatorStateType __currentState; + Tizen::Base::ByteBuffer __pairingAddress; + Tizen::Base::UuId __pairingUuid; + int __socketFd; + +}; // _BluetoothSppInitiatorImpl + +} } } +#endif // _FNET_BT_INTERNAL_BLUETOOTH_SPP_INITIATOR_IMPL_H_ diff --git a/src/inc/FNetBt_ConnectivityIpcMessages.h b/src/inc/FNetBt_ConnectivityIpcMessages.h new file mode 100644 index 0000000..4d52b1a --- /dev/null +++ b/src/inc/FNetBt_ConnectivityIpcMessages.h @@ -0,0 +1,37 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +/** + * @file FNetBt_ConnectivityIpcMessages.h + * @brief This is the header file for the Connectivity service daemon's IPC messages. + * + * This header file contains the declarations of the IPC messages for the Connectivity service daemon. + */ + +#include +#include +#include + +#ifndef BLUETOOTH_CONNECTIVITY_IPC_SERVER_NAME +#define BLUETOOTH_CONNECTIVITY_IPC_SERVER_NAME "osp.net.bluetooth.ipcserver.connectivity" +#endif + +#define IPC_MESSAGE_START ConnectivityBluetoothServiceMsgStart + +// Client -> Server (sync) +IPC_SYNC_MESSAGE_CONTROL0_2(ConnectivityBluetoothServiceMsg_getLocalDeviceName, Tizen::Base::String /* local name */, unsigned long /* result */) +IPC_SYNC_MESSAGE_CONTROL1_1(ConnectivityBluetoothServiceMsg_setLocalDeviceName, Tizen::Base::String /* local name */, unsigned long /* result */) +IPC_SYNC_MESSAGE_CONTROL2_1(ConnectivityBluetoothServiceMsg_setDiscoverableMode, int /* mode */, int /* seconds */ , unsigned long /* result */) diff --git a/src/inc/FNetBt_IBluetoothConnectionEventListener.h b/src/inc/FNetBt_IBluetoothConnectionEventListener.h new file mode 100644 index 0000000..7956f2e --- /dev/null +++ b/src/inc/FNetBt_IBluetoothConnectionEventListener.h @@ -0,0 +1,76 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +/** + * @file FNetBt_IBluetoothConnectionEventListener.h + * @brief This is the header file for the _IBluetoothConnectionEventListener interface. + * + * This header file contains the declaration of the _IBluetoothConnectionEventListener interface. + * + */ +#ifndef _FNET_BT_INTERNAL_IBLUETOOTH_CONNECTION_EVENT_LISTENER_H_ +#define _FNET_BT_INTERNAL_IBLUETOOTH_CONNECTION_EVENT_LISTENER_H_ + +#include + +namespace Tizen { namespace Base +{ +class ByteBuffer; +namespace Collection +{ +class IList; +} +} } + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +// forward declaration +class BluetoothDevice; + +/** + * @interface _IBluetoothConnectionEventListener + * @brief This interface specifies the methods used for notifying the change of connection with local device + */ +class _OSP_EXPORT_ _IBluetoothConnectionEventListener + : public Base::Runtime::IEventListener +{ +public: + /** + * This is the virtual destructor for this class. + */ + virtual ~_IBluetoothConnectionEventListener(void) {} + + /** + * Callback used to notify that the paired device is connected. + * + * @param[in] isCompleted @c true, if the transfer is successfully completed @n + * @c false, otherwise. + */ + virtual void OnBluetoothDeviceConnected(const Tizen::Base::ByteBuffer& address) = 0; + + /** + * Callback used to notify that the paired device is disconnected. + * + * @param[in] isCompleted @c true, if the transfer is successfully completed @n + * @c false, otherwise. + */ + virtual void OnBluetoothDeviceDisconnected(const Tizen::Base::ByteBuffer& address) = 0; + +}; // _IBluetoothConnectionEventListener + +} } } +#endif // _FNET_BT_INTERNAL_IBLUETOOTH_CONNECTION_EVENT_LISTENER_H_ diff --git a/src/inc/FNetBt_IBluetoothDeviceEventListener.h b/src/inc/FNetBt_IBluetoothDeviceEventListener.h new file mode 100644 index 0000000..0559233 --- /dev/null +++ b/src/inc/FNetBt_IBluetoothDeviceEventListener.h @@ -0,0 +1,130 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +/** + * @file FNetBt_IBluetoothDeviceEventListener.h + * @brief This is the header file for the _IBluetoothDeviceEventListener interface. + * + * This header file contains the declaration of the _IBluetoothDeviceEventListener interface. + * + */ +#ifndef _FNET_BT_INTERNAL_IBLUETOOTH_DEVICE_EVENT_LISTENER_H_ +#define _FNET_BT_INTERNAL_IBLUETOOTH_DEVICE_EVENT_LISTENER_H_ + +#include + +namespace Tizen { namespace Base +{ +class ByteBuffer; +namespace Collection +{ +class IList; +} +} } + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +// forward declaration +class BluetoothDevice; + +/** + * @interface _IBluetoothDeviceEventListener + * @brief This interface specifies the methods used for notifying different kinds of Bluetooth remote device related + * events such as search result. + */ +class _OSP_EXPORT_ _IBluetoothDeviceEventListener + : public Base::Runtime::IEventListener +{ +public: + /** + * This is the virtual destructor for this class. + */ + virtual ~_IBluetoothDeviceEventListener(void) {} + + /** + * Callback used to notify that the device discovery process is started. + * + * @param[in] r The result of the event + * @exception E_SUCCESS The discovery was started successfully. + * @exception E_SYSTEM A failure occurred from the underlying system. + */ + virtual void OnBluetoothDiscoveryStarted(result r) = 0; + + /** + * Callback used to notify that a new remote device is found. + * + * @param[in] foundDevice A remote device which is found. + */ + virtual void OnBluetoothRemoteDeviceFound(const BluetoothDevice& foundDevice) = 0; + + /** + * Callback used to notify that the device discovery process is done. + * + * @param[in] isCompleted @c true, if the transfer is successfully completed @n + * @c false, otherwise. + */ + virtual void OnBluetoothDiscoveryDone(bool isCompleted) = 0; + + /** + * Callback used to notify that the service list is received from a remote device. + * + * @param[in] address The address of the remote device which sent its service list + * @param[in] serviceList The received service list + * @param[in] pServiceUuidList The received service UUID list + * @param[in] r The result of receiving service list + * @exception E_SUCCESS The method is successful. + * @exception E_REMOTE_SERVICE_NOT_FOUND The service list of the remote device is not found. + * @exception E_SYSTEM A system error occurred. + */ + virtual void OnBluetoothServiceListReceived(const Tizen::Base::ByteBuffer& address, unsigned long serviceList, + const Tizen::Base::Collection::IList* pServiceUuidList, result r) = 0; + + /** + * Callback used to notify that a new remote device is paired with this local device. + * + * @param[in] pPairedDevice The device which the local device is paired with + * @param[in] r The result of pairing + * @exception E_SUCCESS The method is successful. + * @exception E_SYSTEM A system error occurred. + */ + virtual void OnBluetoothPaired(const BluetoothDevice* pPairedDevice, result r) = 0; + + /** + * Callback used to notify that the already paired device is unpaired with this local device. + * + * @param[in] address The address of the device which the local device is unpaired with + */ + virtual void OnBluetoothUnpaired(const Tizen::Base::ByteBuffer& address) = 0; + + /** + * Callback used to notify that the paired device is connected. + * + * @param[in] address The address of the device which the local device is connected with + */ + virtual void OnBluetoothDeviceConnected(const Tizen::Base::ByteBuffer& address) = 0; + + /** + * Callback used to notify that the paired device is disconnected. + * + * @param[in] address The address of the device which the local device is disconnected with + */ + virtual void OnBluetoothDeviceDisconnected(const Tizen::Base::ByteBuffer& address) = 0; + +}; // _IBluetoothDeviceEventListener + +} } } +#endif // _FNET_BT_INTERNAL_IBLUETOOTH_DEVICE_EVENT_LISTENER_H_ diff --git a/src/inc/FNetBt_IBluetoothManagerEventListener.h b/src/inc/FNetBt_IBluetoothManagerEventListener.h new file mode 100644 index 0000000..2e6b2ce --- /dev/null +++ b/src/inc/FNetBt_IBluetoothManagerEventListener.h @@ -0,0 +1,74 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +/** + * @file FNetBt_IBluetoothManagerEventListener.h + * @brief This is the header file for the _IBluetoothManagerEventListener interface. + * + * This header file contains the declaration of the _IBluetoothManagerEventListener interface. + * + */ +#ifndef _FNET_BT_INTERNAL_IBLUETOOTH_MANAGER_EVENT_LISTENER_H_ +#define _FNET_BT_INTERNAL_IBLUETOOTH_MANAGER_EVENT_LISTENER_H_ + +#include +#include + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +/** + * @interface _IBluetoothManagerEventListener + * @brief This interface specifies the methods used for notifying different kinds of Bluetooth manager(adapter) + * related events such as activation and deactivation. + */ +class _OSP_EXPORT_ _IBluetoothManagerEventListener + : public Base::Runtime::IEventListener +{ +public: + /** + * This is the virtual destructor for this class. + */ + virtual ~_IBluetoothManagerEventListener(void) {} + + + /** + * Callback used to notify that Bluetooth is activated on the device. + * + * @exception E_SUCCESS The method is successful. + * @exception E_SYSTEM A system error occurred. + */ + virtual void OnBluetoothActivated(result r) = 0; + + /** + * Callback used to notify that Bluetooth is deactivated on the device. + * + * @exception E_SUCCESS The method is successful. + * @exception E_SYSTEM A system error occurred. + */ + virtual void OnBluetoothDeactivated(result r) = 0; + + /** + * Callback used to notify that Bluetooth is deactivated on the device. + * + * @param[in] mode The changed discoverable mode + */ + virtual void OnBluetoothDiscoverableModeChanged(BluetoothDiscoverableMode mode) = 0; + +}; // _IBluetoothManagerEventListener + +} } } +#endif // _FNET_BT_INTERNAL_IBLUETOOTH_MANAGER_EVENT_LISTENER_H_ diff --git a/src/inc/FNetBt_IBluetoothSocketListener.h b/src/inc/FNetBt_IBluetoothSocketListener.h new file mode 100644 index 0000000..b35e063 --- /dev/null +++ b/src/inc/FNetBt_IBluetoothSocketListener.h @@ -0,0 +1,90 @@ +// +// Open Service Platform +// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. +// +// Licensed under the Apache License, Version 2.0 (the License); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// +/** + * @file FNetBt_IBluetoothSocketListener.h + * @brief This is the header file for the _IBluetoothSocketListener interface. + * + * This header file contains the declaration of the _IBluetoothSocketListener interface. + * + */ +#ifndef _FNET_BT_INTERNAL_IBLUETOOTH_SOCKET_LISTENER_H_ +#define _FNET_BT_INTERNAL_IBLUETOOTH_SOCKET_LISTENER_H_ + +#include + +namespace Tizen { namespace Base +{ +class ByteBuffer; +} } + +namespace Tizen { namespace Net { namespace Bluetooth +{ + +// forward declaration +class BluetoothDevice; + +/** + * @interface _IBluetoothSocketListener + * @brief This interface specifies the methods used for notifying different kinds of Bluetooth socket (SPP) related + * events such as connection and disconnection. + */ +class _OSP_EXPORT_ _IBluetoothSocketListener + : public Base::Runtime::IEventListener +{ +public: + /** + * This is the virtual destructor for this class. + */ + virtual ~_IBluetoothSocketListener(void) {} + + /** + * Callback used to notify that a new connection request is received from the socket client. + * + * @param[in] device The socket client device + */ + virtual void OnSocketConnectionRequested(const BluetoothDevice& device) = 0; + + /** + * Callback used to notify that the response of the connection request is received from the socket server. + * + * @param[in] socketFd The new generated client socket FD + * @param[in] r The result of the event + * @exception E_SUCCESS The connection is established successfully. + * @exception E_SYSTEM The connection fails. + */ + virtual void OnSocketConnectionResponded(int socketFd, result r) = 0; + + /** + * Callback used to notify that the connection is disconnected. + * + * @param[in] r The result of the event + * @exception E_SUCCESS The connection is terminated successfully. + * @exception E_SYSTEM The method has failed to disconnect. + */ + virtual void OnSocketDisconnected(result r) = 0; + + /** + * Callback used to notify that the data has been received. + * + * @param[in] buffer The received data + */ + virtual void OnSocketDataReceived(Tizen::Base::ByteBuffer& buffer) = 0; + +}; // _IBluetoothSocketListener + +} } } +#endif // _FNET_BT_INTERNAL_IBLUETOOTH_SOCKET_LISTENER_H_ -- 2.7.4