From: h.sandeep Date: Thu, 19 Feb 2015 14:48:23 +0000 (+0530) Subject: Code Sync [Tizen3.0]: Merged Tizen2.4 spin code to tizen.org X-Git-Tag: submit/tizen_mobile/20150401.025803~3 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=refs%2Fchanges%2F26%2F35626%2F1;p=platform%2Fcore%2Fapi%2Fbluetooth.git Code Sync [Tizen3.0]: Merged Tizen2.4 spin code to tizen.org Spin code from project: platform/core/api/bluetooth branch: tizen_2.4 Change-Id: Icd609e57fd0fa67754c37352ac2ed1504c6f2b5e Fix build issues Change-Id: I69f9ebd7c24853a7c31679e0ddd8cd1ba0a2c14a Signed-off-by: h.sandeep --- diff --git a/AUTHORS b/AUTHORS old mode 100644 new mode 100755 diff --git a/CMakeLists.txt b/CMakeLists.txt old mode 100644 new mode 100755 index 6ac39eb..57156d0 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -9,7 +9,11 @@ SET(PREFIX ${CMAKE_INSTALL_PREFIX}) SET(INC_DIR include) INCLUDE_DIRECTORIES(${INC_DIR}) +IF (TIZEN_WEARABLE) +SET(dependents "dlog glib-2.0 capi-base-common bluetooth-api privacy-manager-client") +ELSE () SET(dependents "dlog glib-2.0 capi-base-common bluetooth-api") +ENDIF (TIZEN_WEARABLE) SET(pc_dependents "capi-base-common") INCLUDE(FindPkgConfig) diff --git a/LICENSE b/LICENSE old mode 100644 new mode 100755 diff --git a/LICENSE.APLv2 b/LICENSE.APLv2 old mode 100644 new mode 100755 diff --git a/NOTICE b/NOTICE old mode 100644 new mode 100755 diff --git a/TC/READAME.txt b/TC/READAME.txt new file mode 100755 index 0000000..f0edad5 --- /dev/null +++ b/TC/READAME.txt @@ -0,0 +1,5 @@ +Before run DTS of bluetooth, BT should be disabled. +This DTS needs another target and it must be set as the following: + 1) BT is activated. + 2) BT is discoverable. + 3) BT name is set as "dts_test". diff --git a/TC/_export_env.sh b/TC/_export_env.sh new file mode 100755 index 0000000..ac8f4a1 --- /dev/null +++ b/TC/_export_env.sh @@ -0,0 +1,9 @@ +#!/bin/sh + +. ./config +export TET_INSTALL_PATH=$TET_INSTALL_HOST_PATH # tetware root path +export TET_TARGET_PATH=$TET_INSTALL_PATH/tetware-target # tetware target path +#export TET_TARGET_PATH=$TET_INSTALL_PATH/tetware-simulator # tetware simulator path +export PATH=$TET_TARGET_PATH/bin:$PATH +export LD_LIBRARY_PATH=$TET_TARGET_PATH/lib/tet3:$LD_LIBRARY_PATH +export TET_ROOT=$TET_TARGET_PATH diff --git a/TC/_export_target_env.sh b/TC/_export_target_env.sh new file mode 100755 index 0000000..c693f83 --- /dev/null +++ b/TC/_export_target_env.sh @@ -0,0 +1,8 @@ +#!/bin/sh +. ./config +export TET_INSTALL_PATH=$TET_INSTALL_TARGET_PATH # path to path +export TET_TARGET_PATH=$TET_INSTALL_PATH/tetware-target +#export TET_TARGET_PATH=$TET_INSTALL_PATH/tetware-simulator # tetware simulator path +export PATH=$TET_TARGET_PATH/bin:$PATH +export LD_LIBRARY_PATH=$TET_TARGET_PATH/lib/tet3:$LD_LIBRARY_PATH +export TET_ROOT=$TET_TARGET_PATH diff --git a/TC/build.sh b/TC/build.sh new file mode 100755 index 0000000..72aad6c --- /dev/null +++ b/TC/build.sh @@ -0,0 +1,16 @@ +#!/bin/sh + +. ./_export_env.sh # setting environment variables + +export TET_SUITE_ROOT=`pwd` +FILE_NAME_EXTENSION=`date +%s` + +RESULT_DIR=results +HTML_RESULT=$RESULT_DIR/build-tar-result-$FILE_NAME_EXTENSION.html +JOURNAL_RESULT=$RESULT_DIR/build-tar-result-$FILE_NAME_EXTENSION.journal + +mkdir -p $RESULT_DIR + +tcc -c -p ./ +tcc -b -j $JOURNAL_RESULT -p ./ +grw -c 7 -f chtml -o $HTML_RESULT $JOURNAL_RESULT diff --git a/TC/clean.sh b/TC/clean.sh new file mode 100755 index 0000000..29743e0 --- /dev/null +++ b/TC/clean.sh @@ -0,0 +1,11 @@ +#!/bin/sh + +. ./_export_env.sh # setting environment variables + +export TET_SUITE_ROOT=`pwd` +RESULT_DIR=results + +tcc -c -p ./ # executing tcc, with clean option (-c) +rm -r $RESULT_DIR +rm -r tet_tmp_dir +rm testcase/tet_captured diff --git a/TC/config b/TC/config new file mode 100755 index 0000000..bdfec87 --- /dev/null +++ b/TC/config @@ -0,0 +1,4 @@ +PKG_NAME=capi-network-bluetooth +TET_INSTALL_HOST_PATH=/var/tmp/dts_fw/TC/TETware +TET_INSTALL_TARGET_PATH=/opt/home/$PKG_NAME/TETware + diff --git a/TC/execute.sh b/TC/execute.sh new file mode 100755 index 0000000..0fe02e2 --- /dev/null +++ b/TC/execute.sh @@ -0,0 +1,15 @@ +#!/bin/sh + +. ./_export_target_env.sh # setting environment variables + +export TET_SUITE_ROOT=`pwd` +FILE_NAME_EXTENSION=`date +%s` + +RESULT_DIR=results +HTML_RESULT=$RESULT_DIR/exec-tar-result-$FILE_NAME_EXTENSION.html +JOURNAL_RESULT=$RESULT_DIR/exec-tar-result-$FILE_NAME_EXTENSION.journal + +mkdir -p $RESULT_DIR + +tcc -e -j $JOURNAL_RESULT -p ./ +grw -c 7 -f chtml -o $HTML_RESULT $JOURNAL_RESULT diff --git a/TC/push.sh b/TC/push.sh new file mode 100755 index 0000000..5eb9510 --- /dev/null +++ b/TC/push.sh @@ -0,0 +1,13 @@ +#!/bin/sh + +. ./config + +TC_PATH=/opt/home/$PKG_NAME + +echo $TC_PATH + +sdb shell "mkdir -p $TC_PATH" + +sdb push . $TC_PATH + + diff --git a/TC/run.sh b/TC/run.sh new file mode 100755 index 0000000..cec5778 --- /dev/null +++ b/TC/run.sh @@ -0,0 +1,15 @@ +#!/bin/sh + +source ./_export_target_env.sh + +export TET_SUITE_ROOT=`pwd` +FILE_NAME_EXTENSION=`date +%s` + +RESULT_DIR=results +HTML_RESULT=$RESULT_DIR/exec-tar-result-$FILE_NAME_EXTENSION.html +JOURNAL_RESULT=$RESULT_DIR/exec-tar-result-$FILE_NAME_EXTENSION.journal + +mkdir -p $RESULT_DIR + +tcc -e -j $JOURNAL_RESULT -p ./ +grw -c 7 -f chtml -o $HTML_RESULT $JOURNAL_RESULT diff --git a/TC/testcase/Makefile b/TC/testcase/Makefile new file mode 100755 index 0000000..7d86802 --- /dev/null +++ b/TC/testcase/Makefile @@ -0,0 +1,24 @@ +CC ?= gcc + +C_FILES = $(shell ls *.c) + +PKGS = capi-network-bluetooth glib-2.0 + +LDFLAGS = `pkg-config --libs $(PKGS)` +LDFLAGS += $(TET_ROOT)/lib/tet3/tcm_s.o +LDFLAGS += -L$(TET_ROOT)/lib/tet3 -ltcm_s +LDFLAGS += -L$(TET_ROOT)/lib/tet3 -lapi_s + +CFLAGS = -I. `pkg-config --cflags $(PKGS)` +CFLAGS += -I$(TET_ROOT)/inc/tet3 +CFLAGS += -Wall + +TCS := $(shell ls -1 *.c | cut -d. -f1) + +all: $(TCS) + +%: %.c + $(CC) -o $@ $< $(CFLAGS) $(LDFLAGS) + +clean: + rm -f $(TCS) diff --git a/TC/testcase/tslist b/TC/testcase/tslist new file mode 100755 index 0000000..c3d5dd0 --- /dev/null +++ b/TC/testcase/tslist @@ -0,0 +1,28 @@ +/testcase/utc_network_bluetooth_adapter_positive +/testcase/utc_network_bluetooth_adapter_negative +/testcase/utc_network_bluetooth_audio_negative +/testcase/utc_network_bluetooth_audio_positive +/testcase/utc_network_bluetooth_device_positive +/testcase/utc_network_bluetooth_device_negative +/testcase/utc_network_bluetooth_device_discovery_positive +/testcase/utc_network_bluetooth_device_discovery_negative +/testcase/utc_network_bluetooth_service_search_positive +/testcase/utc_network_bluetooth_service_search_negative +/testcase/utc_network_bluetooth_socket_positive +/testcase/utc_network_bluetooth_socket_negative +/testcase/utc_network_bluetooth_gatt_negative +/testcase/utc_network_bluetooth_gatt_positive +/testcase/utc_network_bluetooth_hid_negative +/testcase/utc_network_bluetooth_hid_positive +/testcase/utc_network_bluetooth_hdp_negative +/testcase/utc_network_bluetooth_hdp_positive +/testcase/utc_network_bluetooth_opp-server_negative +/testcase/utc_network_bluetooth_opp-server_positive +/testcase/utc_network_bluetooth_opp-client_negative +/testcase/utc_network_bluetooth_opp-client_positive +/testcase/utc_network_bluetooth_pan_negative +/testcase/utc_network_bluetooth_pan_positive +/testcase/utc_network_bluetooth_avrcp_negative +/testcase/utc_network_bluetooth_avrcp_positive +/testcase/utc_network_bluetooth_common_negative +/testcase/utc_network_bluetooth_common_positive \ No newline at end of file diff --git a/TC/testcase/utc_network_bluetooth_adapter_negative.c b/TC/testcase/utc_network_bluetooth_adapter_negative.c new file mode 100755 index 0000000..a7e2750 --- /dev/null +++ b/TC/testcase/utc_network_bluetooth_adapter_negative.c @@ -0,0 +1,429 @@ +/* + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + +#include +#include +#include +#include +#include +#include + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static void startup(void); +static void cleanup(void); +bt_adapter_visibility_mode_e adapter_visibility_mode = + BT_ADAPTER_VISIBILITY_MODE_LIMITED_DISCOVERABLE; +char adapter_name[128] = "dts_test"; + +void (*tet_startup)(void) = startup; +void (*tet_cleanup)(void) = cleanup; + + +static void utc_network_bluetooth_deinitialize_n(void); +static void utc_network_bluetooth_adapter_set_state_changed_cb_n(void); +static void utc_network_bluetooth_adapter_set_name_changed_cb_n(void); +static void utc_network_bluetooth_adapter_set_visibility_mode_changed_cb_n(void); +static void utc_network_bluetooth_adapter_set_connectable_changed_cb_n(void); +static void utc_network_bluetooth_adapter_enable_n(void); +static void utc_network_bluetooth_adapter_get_state_n(void); +static void utc_network_bluetooth_adapter_get_address_n(void); +static void utc_network_bluetooth_adapter_set_name_n(void); +static void utc_network_bluetooth_adapter_get_name_n(void); +static void utc_network_bluetooth_adapter_set_visibility_n(void); +static void utc_network_bluetooth_adapter_get_visibility_n(void); +static void utc_network_bluetooth_adapter_add_white_list_n(void); +static void utc_network_bluetooth_adapter_clear_white_list_n(void); +static void utc_network_bluetooth_adapter_remove_white_list_n(void); +static void utc_network_bluetooth_adapter_set_connectable_n(void); +static void utc_network_bluetooth_adapter_get_connectable_n(void); +static void utc_network_bluetooth_adapter_disable_n(void); +static void utc_network_bluetooth_adapter_unset_state_changed_cb_n(void); +static void utc_network_bluetooth_adapter_unset_name_changed_cb_n(void); +static void utc_network_bluetooth_adapter_unset_visibility_mode_changed_cb_n(void); +static void utc_network_bluetooth_adapter_unset_connectable_changed_cb_n(void); +static void utc_network_bluetooth_adapter_set_le_state_changed_cb_n(void); +static void utc_network_bluetooth_adapter_unset_le_state_changed_cb_n(void); +static void utc_network_bluetooth_adapter_le_enable_n(void); +static void utc_network_bluetooth_adapter_get_le_state_n(void); +static void utc_network_bluetooth_adapter_le_disable_n(void); + +void adapter_state_changed_cb_for_adapter_n(int result, + bt_adapter_state_e adapter_state, + void *user_data); +gboolean timeout_func(gpointer data); + +struct tet_testlist tet_testlist[] = { + {utc_network_bluetooth_adapter_disable_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_adapter_set_state_changed_cb_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_adapter_set_name_changed_cb_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_adapter_set_visibility_mode_changed_cb_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_adapter_set_connectable_changed_cb_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_adapter_get_state_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_adapter_get_address_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_adapter_set_name_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_adapter_get_name_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_adapter_get_visibility_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_adapter_set_visibility_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_adapter_le_disable_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_adapter_add_white_list_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_adapter_remove_white_list_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_adapter_clear_white_list_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_adapter_get_connectable_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_deinitialize_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_adapter_set_connectable_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_adapter_enable_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_adapter_unset_connectable_changed_cb_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_adapter_unset_state_changed_cb_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_adapter_unset_name_changed_cb_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_adapter_unset_visibility_mode_changed_cb_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_adapter_set_le_state_changed_cb_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_adapter_get_le_state_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_adapter_le_enable_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_adapter_unset_le_state_changed_cb_n, NEGATIVE_TC_IDX}, + {NULL, 0}, +}; + +static void startup(void) +{ + /* start of TC */ + tet_printf("TC start."); + bt_initialize(); +} + +static void cleanup(void) +{ + /* end of TC */ + tet_printf("TC end"); +} + +/** + * @brief Negative test case of bt_deinitialize() + */ +static void utc_network_bluetooth_deinitialize_n(void) +{ + int ret = bt_deinitialize(); + + if (ret == BT_ERROR_NONE) { + ret = bt_deinitialize(); + dts_check_eq("bt_deinitialize", ret, BT_ERROR_NOT_INITIALIZED, + "BT_ERROR_NOT_INITIALIZED must be returned."); + } else { + dts_fail("bt_deinitialize", "bt_deinitialize() failed."); + } +} + +/** + * @brief Negative test case of bt_adapter_disable() + */ +static void utc_network_bluetooth_adapter_disable_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_adapter_disable(); + dts_check_eq("bt_adapter_disable", ret, BT_ERROR_NOT_ENABLED, + "BT_ERROR_NOT_ENABLED must be returned when BT is disabled"); +} + +/** + * @brief Negative test case of bt_adapter_set_state_changed_cb() + */ +static void utc_network_bluetooth_adapter_set_state_changed_cb_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_adapter_set_state_changed_cb(NULL, NULL); + dts_check_eq("bt_adapter_set_state_changed_cb", ret, + BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL."); +} + +/** + * @brief Negative test case of bt_adapter_set_name_changed_cb() + */ +static void utc_network_bluetooth_adapter_set_name_changed_cb_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_adapter_set_name_changed_cb(NULL, NULL); + dts_check_eq("bt_adapter_set_name_changed_cb", ret, + BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL."); +} + +/** + * @brief Negative test case of bt_adapter_set_visibility_mode_changed_cb() + */ +static void utc_network_bluetooth_adapter_set_visibility_mode_changed_cb_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_adapter_set_visibility_mode_changed_cb(NULL, NULL); + dts_check_eq("bt_adapter_set_visibility_mode_changed_cb", ret, + BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL."); +} + +/** + * @brief Negative test case of bt_adapter_set_connectable_changed_cb() + */ +static void utc_network_bluetooth_adapter_set_connectable_changed_cb_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_adapter_set_connectable_changed_cb(NULL, NULL); + dts_check_eq("bt_adapter_set_connectable_changed_cb", ret, + BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL."); +} + +/** + * @brief Negative test case of bt_adapter_get_state() + */ +static void utc_network_bluetooth_adapter_get_state_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_adapter_get_state(NULL); + dts_check_eq("bt_adapter_get_state", ret, BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL."); +} + +/** + * @brief Negative test case of bt_adapter_get_address(). + */ +static void utc_network_bluetooth_adapter_get_address_n(void) +{ + char *address = NULL; + int ret = bt_adapter_get_address(&address); + + dts_check_eq("bt_adapter_get_address", ret, BT_ERROR_NOT_ENABLED, + "BT_ERROR_NOT_ENABLED must be returned when BT is not enabled."); +} + +/** + * @brief Negative test case of bt_adapter_get_name(). + */ +static void utc_network_bluetooth_adapter_get_name_n(void) +{ + char *name = NULL; + int ret = bt_adapter_get_name(&name); + + dts_check_eq("bt_adapter_get_name", ret, BT_ERROR_NOT_ENABLED, + "BT_ERROR_NOT_ENABLED must be returned when BT is not enabled."); +} + +/** + * @brief Negative test case of bt_adapter_get_visibility(). + */ +static void utc_network_bluetooth_adapter_get_visibility_n(void) +{ + int dur = 10; + int ret = bt_adapter_get_visibility(NULL, &dur); + + dts_check_eq("bt_adapter_get_visibility", ret, BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL."); +} + +/** + * @brief Negative test case of bt_adapter_set_name(). + */ +static void utc_network_bluetooth_adapter_set_name_n(void) +{ + int ret = bt_adapter_set_name(NULL); + dts_check_eq("bt_adapter_set_name", ret, BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL."); +} + +/** + * @brief Negative test case of bt_adapter_set_visibility(). + */ +static void utc_network_bluetooth_adapter_set_visibility_n(void) +{ + int ret = bt_adapter_set_visibility(adapter_visibility_mode, 180); + + dts_check_eq("bt_adapter_set_visibility", ret, BT_ERROR_NOT_ENABLED, + "BT_ERROR_NOT_ENABLED must be returned when BT is not enabled."); +} + +/** + * @brief Negative test case of bt_adapter_le_add_white_list + */ +static void utc_network_bluetooth_adapter_add_white_list_n(void) +{ + int ret = bt_adapter_le_add_white_list(NULL); + dts_check_eq("bt_adapter_le_add_white_list", ret, BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL."); +} + +/** + * @brief Negative test case of bt_adapter_clear_white_list + */ +static void utc_network_bluetooth_adapter_clear_white_list_n(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_adapter_clear_white_list(); + dts_check_eq("bt_adapter_clear_white_list", ret, BT_ERROR_NOT_ENABLED, + "BT_ERROR_NOT_ENABLED must be returned when BT is not enabled."); +} + +/** + * @brief Negative test case of bt_adapter_le_add_white_list + */ +static void utc_network_bluetooth_adapter_remove_white_list_n(void) +{ + int ret = bt_adapter_le_remove_white_list(NULL); + dts_check_eq("bt_adapter_le_remove_white_list", ret, BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL."); +} + +/** + * @brief Negative test case of bt_adapter_get_connectable + */ +static void utc_network_bluetooth_adapter_get_connectable_n(void) +{ + int ret = bt_adapter_get_connectable(NULL); + dts_check_eq("bt_adapter_get_connectable", ret, BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL."); +} + +/** + * @brief Negative test case of bt_adapter_set_connectable + */ +static void utc_network_bluetooth_adapter_set_connectable_n(void) +{ + int ret = bt_adapter_set_connectable(NULL); + dts_check_eq("bt_adapter_set_connectable", ret, BT_ERROR_NOT_INITIALIZED, + "BT_ERROR_NOT_INITIALIZED must be returned when BT is not initialized."); +} + +/** + * @brief Negative test case of bt_adapter_unset_state_changed_cb() + */ +static void utc_network_bluetooth_adapter_unset_state_changed_cb_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_adapter_unset_state_changed_cb(); + dts_check_eq("bt_adapter_unset_state_changed_cb", ret, + BT_ERROR_NOT_INITIALIZED, + "BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized."); +} + +/** + * @brief Negative test case of bt_adapter_unset_name_changed_cb() + */ +static void utc_network_bluetooth_adapter_unset_name_changed_cb_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_adapter_unset_name_changed_cb(); + dts_check_eq("bt_adapter_unset_name_changed_cb", ret, + BT_ERROR_NOT_INITIALIZED, + "BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized."); +} + +/** + * @brief Negative test case of bt_adapter_unset_visibility_mode_changed_cb() + */ +static void +utc_network_bluetooth_adapter_unset_visibility_mode_changed_cb_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_adapter_unset_visibility_mode_changed_cb(); + dts_check_eq("bt_adapter_unset_visibility_mode_changed_cb", ret, + BT_ERROR_NOT_INITIALIZED, + "BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized."); +} + +/** + * @brief Negative test case of bt_adapter_enable() + */ +static void utc_network_bluetooth_adapter_enable_n(void) +{ + bt_error_e ret = bt_adapter_enable(); + dts_check_eq("bt_adapter_enable", ret, BT_ERROR_NOT_INITIALIZED, + "BT_ERROR_NOT_INITIALIZED must be returned."); +} + +/** + * @brief Negative test case of bt_adapter_unset_connectable_changed_cb() + */ +static void utc_network_bluetooth_adapter_unset_connectable_changed_cb_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_adapter_unset_connectable_changed_cb(); + dts_check_eq("bt_adapter_unset_connectable_changed_cb", ret, + BT_ERROR_NOT_INITIALIZED, + "bt_adapter_unset_connectable_changed_cb() failed."); +} + +/** + * @brief Negative test case of bt_adapter_le_set_state_changed_cb() + */ +static void utc_network_bluetooth_adapter_set_le_state_changed_cb_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_adapter_le_set_state_changed_cb(NULL, NULL); + dts_check_eq("bt_adapter_le_set_state_changed_cb", ret, + BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL."); +} + +static void utc_network_bluetooth_adapter_le_enable_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_adapter_le_enable(); + dts_check_eq("bt_adapter_le_enable", ret, + BT_ERROR_NOT_INITIALIZED, + "BT_ERROR_NOT_INITIALIZED must be returned."); +} + +static void utc_network_bluetooth_adapter_le_disable_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_adapter_le_disable(); + dts_check_eq("bt_adapter_disable", ret, BT_ERROR_NOT_ENABLED, + "BT_ERROR_NOT_ENABLED must be returned when BT is disabled"); +} + +static void utc_network_bluetooth_adapter_get_le_state_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_adapter_le_get_state(NULL); + dts_check_eq("bt_adapter_get_state", ret, BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL."); +} + +static void utc_network_bluetooth_adapter_unset_le_state_changed_cb_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_adapter_le_unset_state_changed_cb(); + dts_check_eq("bt_adapter_unset_state_changed_cb", ret, + BT_ERROR_NOT_INITIALIZED, + "BT_ERROR_NOT_INITIALIZED must be returned"); +} diff --git a/TC/testcase/utc_network_bluetooth_adapter_positive.c b/TC/testcase/utc_network_bluetooth_adapter_positive.c new file mode 100755 index 0000000..6ad6815 --- /dev/null +++ b/TC/testcase/utc_network_bluetooth_adapter_positive.c @@ -0,0 +1,796 @@ +/* + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + +#include +#include +#include +#include +#include +#include + +#define CONFIG_FILE_PATH "/opt/home/capi-network-bluetooth/tetware.conf" + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static void startup(void); +static void cleanup(void); +char *remote_address; +static GMainLoop *mainloop; +static bool callback_result = false; +bt_adapter_visibility_mode_e adapter_visibility_mode = + BT_ADAPTER_VISIBILITY_MODE_LIMITED_DISCOVERABLE; +char adapter_name[128] = "dts_test"; + +void (*tet_startup)(void) = startup; +void (*tet_cleanup)(void) = cleanup; + +static void utc_network_bluetooth_initialize_p(void); +static void utc_network_bluetooth_deinitialize_p(void); +static void utc_network_bluetooth_adapter_set_state_changed_cb_p(void); +static void utc_network_bluetooth_adapter_set_name_changed_cb_p(void); +static void utc_network_bluetooth_adapter_set_visibility_mode_changed_cb_p(void); +static void utc_network_bluetooth_adapter_set_connectable_changed_cb_p(void); +static void utc_network_bluetooth_adapter_enable_p(void); +static void utc_network_bluetooth_adapter_get_state_p(void); +static void utc_network_bluetooth_adapter_get_address_p(void); +static void utc_network_bluetooth_adapter_set_name_p(void); +static void utc_network_bluetooth_adapter_get_name_p(void); +static void utc_network_bluetooth_adapter_set_visibility_p(void); +static void utc_network_bluetooth_adapter_get_visibility_p(void); +static void utc_network_bluetooth_adapter_add_white_list_p(void); +static void utc_network_bluetooth_adapter_remove_white_list_p(void); +static void utc_network_bluetooth_adapter_clear_white_list_p(void); +static void utc_network_bluetooth_adapter_set_connectable_p(void); +static void utc_network_bluetooth_adapter_get_connectable_p(void); +static void utc_network_bluetooth_adapter_disable_p(void); +static void utc_network_bluetooth_adapter_unset_state_changed_cb_p(void); +static void utc_network_bluetooth_adapter_unset_name_changed_cb_p(void); +static void utc_network_bluetooth_adapter_unset_visibility_mode_changed_cb_p(void); +static void utc_network_bluetooth_adapter_unset_connectable_changed_cb_p(void); +static void utc_network_bluetooth_adapter_set_le_state_changed_cb_p(void); +static void utc_network_bluetooth_adapter_le_enable_p(void); +static void utc_network_bluetooth_adapter_get_le_state_p(void); +static void utc_network_bluetooth_adapter_le_disable_p(void); +static void utc_network_bluetooth_adapter_unset_le_state_changed_cb_p(void); + +void adapter_state_changed_cb_for_adapter_p(int result, + bt_adapter_state_e adapter_state, + void *user_data); +void adapter_state_changed_cb_for_adapter_p(int result, + bt_adapter_state_e adapter_state, + void *user_data); +void adapter_name_changed_cb_for_adapter_p(char *device_name, void *user_data); +void adapter_visibility_mode_changed_cb_for_adpater_p(int result, + bt_adapter_visibility_mode_e visibility_mode, + void *user_data); +void device_discovery_state_changed_cb_for_adapter_p(int result, + bt_adapter_device_discovery_state_e discovery_state, + bt_device_info_s *device_info, + void *user_data); +void adapter_connectable_changed_cb_for_adpater_p(int result, + bool connectable, void *user_data); +gboolean timeout_func(gpointer data); + +struct tet_testlist tet_testlist[] = { + {utc_network_bluetooth_initialize_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_adapter_enable_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_adapter_set_state_changed_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_adapter_unset_state_changed_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_adapter_get_state_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_adapter_get_address_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_adapter_get_name_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_adapter_set_name_changed_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_adapter_unset_name_changed_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_adapter_set_connectable_changed_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_adapter_set_name_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_adapter_set_visibility_mode_changed_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_adapter_unset_visibility_mode_changed_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_adapter_get_visibility_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_adapter_set_visibility_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_adapter_get_connectable_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_adapter_set_connectable_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_adapter_unset_connectable_changed_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_adapter_le_enable_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_adapter_add_white_list_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_adapter_remove_white_list_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_adapter_clear_white_list_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_adapter_set_le_state_changed_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_adapter_unset_le_state_changed_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_adapter_get_le_state_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_adapter_le_disable_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_adapter_disable_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_deinitialize_p, POSITIVE_TC_IDX}, + {NULL, 0}, +}; + +int get_value_from_file(void) +{ + FILE *fp; + char *token; + char buf[100]; + + fp = fopen(CONFIG_FILE_PATH, "r"); + if (fp == NULL) { + tet_printf("Default configuration is used\n"); + return -1; + } + while (fgets(buf, sizeof(buf), fp)) { + if (buf[0] == '#' || buf[0] == '\n') + continue; + + token = strrchr(buf, '\n'); + if (token == NULL) { + tet_printf("g_conf is too long\n"); + break; + } + *token = '\0'; + + token = strtok(buf, "="); + if (token == NULL) { + continue; + } + if (strcasecmp(token, "BT_ADDR_MOBILE") == 0) { + token = strtok(NULL, "="); + remote_address = strdup(token); + fclose(fp); + return 0; + } + } + return -1; +} + +static void startup(void) +{ + if(get_value_from_file() == -1) { + tet_printf("Failed to read."); + } + + /* start of TC */ + tet_printf("TC start."); + mainloop = g_main_loop_new(NULL, FALSE); +} + +static void cleanup(void) +{ + /* end of TC */ + tet_printf("TC end"); +} + +gboolean timeout_func(gpointer data) +{ + tet_printf("Callback: Timeout."); + g_main_loop_quit((GMainLoop *)data); + return FALSE; +} + +/** + * @brief Callback funtions + */ +void adapter_state_changed_cb_for_adapter_p(int result, + bt_adapter_state_e adapter_state, + void *user_data) +{ + if (user_data != NULL && !strcmp((char *)user_data, "enable")) { + if (adapter_state == BT_ADAPTER_ENABLED && result == BT_ERROR_NONE) { + tet_printf("Callback: BT was enabled."); + callback_result = true; + } else { + tet_printf("Callback: BT was not enabled."); + } + + if (mainloop) + g_main_loop_quit(mainloop); + } else if (user_data != NULL && !strcmp((char *)user_data, "disable")) { + if (adapter_state == BT_ADAPTER_DISABLED && result == BT_ERROR_NONE) { + tet_printf("Callback: BT was disabled."); + callback_result = true; + } else { + tet_printf("Callback: BT was not disabled."); + } + + if (mainloop) { + g_main_loop_quit(mainloop); + } + } +} + +void adapter_le_state_changed_cb_for_adapter_p(int result, + bt_adapter_le_state_e adapter_le_state, + void *user_data) +{ + if (user_data != NULL && !strcmp((char *)user_data, "enable")) { + if (adapter_le_state == BT_ADAPTER_LE_ENABLED && result == BT_ERROR_NONE) { + tet_printf("Callback: BT LE was enabled."); + callback_result = true; + } else { + tet_printf("Callback: BT LE was not enabled."); + } + + if (mainloop) + g_main_loop_quit(mainloop); + } else if (user_data != NULL && !strcmp((char *)user_data, "disable")) { + if (adapter_le_state == BT_ADAPTER_LE_DISABLED && result == BT_ERROR_NONE) { + tet_printf("Callback: BT LEwas disabled."); + callback_result = true; + } else { + tet_printf("Callback: BT LE was not disabled."); + } + + if (mainloop) { + g_main_loop_quit(mainloop); + } + } +} + +void device_discovery_state_changed_cb_for_adapter_p(int result, + bt_adapter_device_discovery_state_e discovery_state, + bt_device_info_s *device_info, + void *user_data) +{ + tet_printf("bt_adapter_device_discovery_state_changed_cb was called"); + + if (user_data != NULL && !strcmp((char *)user_data, "enable")) { + if (discovery_state == BT_ADAPTER_DEVICE_DISCOVERY_FINISHED) { + tet_printf("Callback: bt_adapter_device_discovery_state_changed_cb_for_adapter_p was called \ + and device discovery ends."); + if (mainloop) { + g_main_loop_quit(mainloop); + } + } + } +} + +void adapter_name_changed_cb_for_adapter_p(char *device_name, void *user_data) +{ + tet_printf("bt_adapter_name_changed_cb_for_adapter_p was called: %s", + (char *)device_name); + + if (user_data != NULL && !strcmp((char *)user_data, "set_name")) { + if (!strcmp(device_name, adapter_name)) + callback_result = true; + } + + if (mainloop) + g_main_loop_quit(mainloop); + +} + +void adapter_visibility_mode_changed_cb_for_adpater_p(int result, + bt_adapter_visibility_mode_e visibility_mode, + void *user_data) +{ + tet_printf("bt_adapter_visibility_mode_changed_cb was called: %d", visibility_mode); + + if (user_data != NULL && !strcmp((char *)user_data, "set_visibility")) { + if (result == BT_ERROR_NONE) { + if (visibility_mode == adapter_visibility_mode) { + callback_result = true; + } else { + tet_printf("Callback: adapter_visibility_mode_changed_cb_for_adpater_p() was called but visibility mode is not same."); + tet_printf("Callback: actual visibility mode : %d", visibility_mode); + callback_result = false; + } + } else { + tet_printf("\n Callback: adapter_visibility_mode_changed_cb_for_adpater_p() was called but failed."); + callback_result = false; + } + } + + if (mainloop) + g_main_loop_quit(mainloop); +} + +void adapter_connectable_changed_cb_for_adpater_p(int result, bool connectable, + void *user_data) +{ + tet_printf("adapter_connectable_changed_cb_for_adapter_p was called."); + if (result == BT_ERROR_NONE) { + tet_printf("Callback: Connectable Changed"); + tet_printf("%s", connectable ? "Connectable" : "Non-connectable"); + callback_result = true; + } else { + tet_printf("Callback: adapter_connectable_changed_cb_for_adpater_p() was called but failed."); + callback_result = false; + } + if (mainloop) + g_main_loop_quit(mainloop); +} + +/** + * @brief Positive test case of bt_initialize() + */ +static void utc_network_bluetooth_initialize_p(void) +{ + int ret = bt_initialize(); + dts_check_eq("bt_initialize", ret, BT_ERROR_NONE, + "bt_initialize() failed."); +} + +/** + * @brief Positive test case of bt_deinitialize() + */ +static void utc_network_bluetooth_deinitialize_p(void) +{ + int ret = bt_deinitialize(); + dts_check_eq("bt_deinitialize", ret, + BT_ERROR_NONE, "bt_deinitialize() failed."); +} + +/** + * @brief Positive test case of bt_adapter_set_state_changed_cb() + */ +static void utc_network_bluetooth_adapter_set_state_changed_cb_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_adapter_p, NULL); + dts_check_eq("bt_adapter_set_state_changed_cb", ret, BT_ERROR_NONE, + "bt_adapter_set_state_changed_cb failed."); +} + +/** + * @brief Positive test case of bt_adapter_set_name_changed_cb() + */ +static void utc_network_bluetooth_adapter_set_name_changed_cb_p(void) +{ + int ret = BT_ERROR_NONE; + int timeout_id = 0; + + ret = bt_adapter_set_name_changed_cb(adapter_name_changed_cb_for_adapter_p, NULL); + if (ret == BT_ERROR_NONE) { + timeout_id = g_timeout_add(10000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } + dts_check_eq("bt_adapter_set_name_changed_cb", ret, BT_ERROR_NONE, + "bt_adapter_set_name_changed_cb failed."); +} + +/** + * @brief Positive test case of bt_adapter_set_visibility_mode_changed_cb() + */ +static void utc_network_bluetooth_adapter_set_visibility_mode_changed_cb_p(void) +{ + int ret = BT_ERROR_NONE; + int timeout_id = 0; + + ret = bt_adapter_set_visibility_mode_changed_cb( + adapter_visibility_mode_changed_cb_for_adpater_p, NULL); + if (ret == BT_ERROR_NONE) { + timeout_id = g_timeout_add(10000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } + dts_check_eq("bt_adapter_set_visibility_mode_changed_cb", ret, + BT_ERROR_NONE, + "bt_adapter_set_visibility_mode_changed_cb failed."); +} + +static void utc_network_bluetooth_adapter_set_connectable_changed_cb_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_adapter_set_connectable_changed_cb( + adapter_connectable_changed_cb_for_adpater_p, NULL); + dts_check_eq("bt_adapter_set_connectable_changed_cb", ret, + BT_ERROR_NONE, + "bt_adapter_set_connectable_changed_cb failed."); +} + +/** + * @brief Positive test case of bt_adapter_enable() + */ +static void utc_network_bluetooth_adapter_enable_p(void) +{ + int timeout_id = 0; + callback_result = false; + bt_error_e ret = BT_ERROR_NONE; + + if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_adapter_p, "enable") != BT_ERROR_NONE) { + dts_fail("bt_adapter_enable", + "bt_adapter_set_state_changed_cb() failed."); + } + + ret = bt_adapter_enable(); + if (ret == BT_ERROR_NONE) { + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else if (ret == BT_ERROR_ALREADY_DONE) { + callback_result = true; + } else { + dts_fail("bt_adapter_enable", "bt_adapter_enable() failed."); + bt_adapter_unset_state_changed_cb(); + return; + } + + tet_printf("callback_result: %d", callback_result); + bt_adapter_unset_state_changed_cb(); + dts_check_eq("bt_adapter_enable", callback_result, true, + "BT was not enabled."); +} + +/** + * @brief Positive test case of bt_adapter_get_state() + */ +static void utc_network_bluetooth_adapter_get_state_p(void) +{ + bt_adapter_state_e adapter_state = BT_ADAPTER_DISABLED; + int ret = BT_ERROR_NONE; + + ret = bt_adapter_get_state(&adapter_state); + if (ret == BT_ERROR_NONE && adapter_state == BT_ADAPTER_ENABLED) { + dts_pass("bt_adapter_get_state", + "bt_adapter_get_state() succeeded."); + } else { + dts_fail("bt_adapter_get_state", + "bt_adapter_get_state() failed."); + } +} + +/** + * @brief Positive test case of bt_adapter_get_address(). + */ +static void utc_network_bluetooth_adapter_get_address_p(void) +{ + char *address = NULL; + int ret = bt_adapter_get_address(&address); + + if (address != NULL) + tet_printf("device address: %s", address); + + dts_check_eq("bt_adapter_get_address", ret, BT_ERROR_NONE, + "bt_adapter_get_address() failed."); +} + +/** + * @brief Positive test case of bt_adapter_get_name(). + */ +static void utc_network_bluetooth_adapter_get_name_p(void) +{ + char *name = NULL; + int ret = bt_adapter_get_name(&name); + + if (name != NULL) + tet_printf("device name : %s", name); + + memset(adapter_name, 0x00, sizeof(adapter_name)); + g_strlcpy(adapter_name, name, sizeof(adapter_name)); + + dts_check_eq("bt_adapter_get_name", ret, BT_ERROR_NONE, \ + "bt_adapter_get_name() failed."); +} + +/** + * @brief Positive test case of bt_adapter_get_visibility(). + */ +static void utc_network_bluetooth_adapter_get_visibility_p(void) +{ + bt_adapter_visibility_mode_e mode = BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE; + int dur = 1; + int ret = bt_adapter_get_visibility(&mode, &dur); + + tet_printf("visibility mode : %d", mode); + if (mode == BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE) { + adapter_visibility_mode = BT_ADAPTER_VISIBILITY_MODE_LIMITED_DISCOVERABLE; + } else if (mode == BT_ADAPTER_VISIBILITY_MODE_GENERAL_DISCOVERABLE) { + adapter_visibility_mode = BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE; + } else + adapter_visibility_mode = BT_ADAPTER_VISIBILITY_MODE_GENERAL_DISCOVERABLE; + + dts_check_eq("bt_adapter_get_visibility", ret, BT_ERROR_NONE, + "bt_adapter_get_visibility() failed."); +} + +/** + * @brief Positive test case of bt_adapter_set_name(). + */ +static void utc_network_bluetooth_adapter_set_name_p(void) +{ + int timeout_id = 0; + char name[128] = ""; + + snprintf(name, 128, "%s_1", adapter_name); + strncpy(adapter_name, name, 128); + + if (bt_adapter_set_name_changed_cb(adapter_name_changed_cb_for_adapter_p, "set_name") != BT_ERROR_NONE) { + dts_fail("bt_adapter_set_name", + "bt_adapter_set_name_changed_cb() failed."); + } + + if (bt_adapter_set_name(adapter_name) == BT_ERROR_NONE) { + tet_printf("adapter_name_changed_cb_for_adapter_p() will be called"); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + bt_adapter_unset_name_changed_cb(); + dts_check_eq("bt_adapter_set_name", callback_result, true, + "The local adapter name was not set."); + } else { + dts_fail("bt_adapter_set_name", "bt_adapter_set_name() failed"); + } +} + +/** + * @brief Positive test case of bt_adapter_set_visibility(). + */ +static void utc_network_bluetooth_adapter_set_visibility_p(void) +{ + callback_result = false; + int timeout = 0; + int timeout_id = 0; + + if (bt_adapter_set_visibility_mode_changed_cb(adapter_visibility_mode_changed_cb_for_adpater_p, "set_visibility") != BT_ERROR_NONE) { + dts_fail("bt_adapter_set_visibility", + "bt_adapter_set_visibility_mode_changed_cb() failed."); + } + + tet_printf("set visibility mode: %d", adapter_visibility_mode); + if (adapter_visibility_mode == BT_ADAPTER_VISIBILITY_MODE_LIMITED_DISCOVERABLE) { + timeout = 90; + tet_printf("set timeout: %d", timeout); + } + + if (bt_adapter_set_visibility(adapter_visibility_mode, timeout) == BT_ERROR_NONE) { + tet_printf("bt_adapter_visibility_changed_cb() will be called"); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + bt_adapter_unset_visibility_mode_changed_cb(); + dts_check_eq("bt_adapter_set_visibility", callback_result, true, + "The visibility of BT was not set."); + } else { + dts_fail("bt_adapter_set_visibility", + "bt_adapter_set_visibility() failed"); + } +} + +/** + * @brief Positive test case of bt_adapter_le_add_white_list + */ +static void utc_network_bluetooth_adapter_add_white_list_p(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_adapter_le_add_white_list(remote_address); + dts_check_eq("bt_adapter_le_add_white_list", ret, BT_ERROR_NONE, + "bt_adapter_le_add_white_list() failed."); +} + +/** + * @brief Positive test case of bt_adapter_le_clear_white_list + */ +static void utc_network_bluetooth_adapter_clear_white_list_p(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_adapter_le_clear_white_list(); + dts_check_eq("bt_adapter_le_clear_white_list", ret, BT_ERROR_NONE, + "bt_adapter_le_clear_white_list() failed."); +} + +/** + * @brief Positive test case of bt_adapter_le_remove_white_list + */ +static void utc_network_bluetooth_adapter_remove_white_list_p(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_adapter_le_remove_white_list(remote_address); + dts_check_eq("bt_adapter_le_remove_white_list", ret, BT_ERROR_NONE, + "bt_adapter_le_remove_white_list() failed."); +} + +/** + * @brief Positive test case of bt_adapter_get_connectable + */ +static void utc_network_bluetooth_adapter_get_connectable_p(void) +{ + int ret = BT_ERROR_NONE; + bool connectable = false; + ret = bt_adapter_get_connectable(&connectable); + dts_check_eq("bt_adapter_get_connectable", ret, BT_ERROR_NONE, + "bt_adapter_get_connectable() failed."); +} + +/** + * @brief Positive test case of bt_adapter_set_connectable + */ +static void utc_network_bluetooth_adapter_set_connectable_p(void) +{ + int ret = BT_ERROR_NONE; + bool connectable = false; + int timeout_id = 0; + callback_result = false; + + ret = bt_adapter_get_connectable(&connectable); + ret = bt_adapter_set_connectable(!connectable); + if (ret == BT_ERROR_NONE) { + tet_printf("adapter_connectable_changed_cb will be called"); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + dts_check_eq("bt_adapter_set_connectable", ret, BT_ERROR_NONE, + "bt_adapter_set_connectable() failed."); + } +} + +/** + * @brief Positive test case of bt_adapter_disable() + */ +static void utc_network_bluetooth_adapter_disable_p(void) +{ + callback_result = false; + int timeout_id = 0; + + if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_adapter_p, "disable") != BT_ERROR_NONE) { + dts_fail("bt_adapter_disable", + "bt_adapter_set_state_changed_cb() failed."); + } + + if (bt_adapter_disable() == BT_ERROR_NONE) { + tet_printf("bt_adapter_state_changed_cb() will be called"); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + bt_adapter_unset_state_changed_cb(); + dts_check_eq("bt_adapter_disable", callback_result, true, + "BT was not disabled"); + } else { + dts_fail("bt_adapter_disable", "bt_adapter_disable() failed"); + } +} + +/** + * @brief Positive test case of bt_adapter_unset_state_changed_cb() + */ +static void utc_network_bluetooth_adapter_unset_state_changed_cb_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_adapter_unset_state_changed_cb(); + dts_check_eq("bt_adapter_unset_state_changed_cb", ret, BT_ERROR_NONE, + "bt_adapter_unset_state_changed_cb() failed."); +} + +/** + * @brief Positive test case of bt_adapter_unset_name_changed_cb() + */ +static void utc_network_bluetooth_adapter_unset_name_changed_cb_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_adapter_unset_name_changed_cb(); + dts_check_eq("bt_adapter_unset_name_changed_cb", ret, BT_ERROR_NONE, + "bt_adapter_unset_name_changed_cb() failed."); +} + +/** + * @brief Positive test case of bt_adapter_unset_visibility_mode_changed_cb() + */ +static void utc_network_bluetooth_adapter_unset_visibility_mode_changed_cb_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_adapter_unset_visibility_mode_changed_cb(); + dts_check_eq("bt_adapter_unset_visibility_mode_changed_cb", ret, + BT_ERROR_NONE, + "bt_adapter_unset_visibility_mode_changed_cb() failed."); +} + +/** + * @brief Positive test case of bt_adapter_unset_connectable_changed_cb() + */ +static void utc_network_bluetooth_adapter_unset_connectable_changed_cb_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_adapter_unset_connectable_changed_cb(); + dts_check_eq("bt_adapter_unset_connectable_changed_cb", ret, + BT_ERROR_NONE, + "bt_adapter_unset_connectable_changed_cb() failed."); +} + +/** + * @brief Positive test case of bt_adapter_le_set_state_changed_cb() + */ +static void utc_network_bluetooth_adapter_set_le_state_changed_cb_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_adapter_le_set_state_changed_cb( + adapter_le_state_changed_cb_for_adapter_p, NULL); + dts_check_eq("bt_adapter_le_set_state_changed_cb", ret, BT_ERROR_NONE, + "bt_adapter_set_state_le_state_changed_cb failed."); +} + +static void utc_network_bluetooth_adapter_le_enable_p(void) +{ + int timeout_id = 0; + callback_result = false; + bt_error_e ret = BT_ERROR_NONE; + + if (bt_adapter_le_set_state_changed_cb(adapter_le_state_changed_cb_for_adapter_p, "enable") != BT_ERROR_NONE) { + dts_fail("bt_adapter_le_enable", + "bt_adapter_le_set_state_changed_cb() failed."); + } + + ret = bt_adapter_le_enable(); + if (ret == BT_ERROR_NONE) { + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else if (ret == BT_ERROR_ALREADY_DONE) { + callback_result = true; + } else { + dts_fail("bt_adapter_le_enable", "bt_adapter_le_enable() failed."); + bt_adapter_le_unset_state_changed_cb(); + return; + } + + tet_printf("callback_result: %d", callback_result); + bt_adapter_le_unset_state_changed_cb(); + dts_check_eq("bt_adapter_le_enable", callback_result, true, + "BT LE was not enabled."); +} + +static void utc_network_bluetooth_adapter_le_disable_p(void) +{ + callback_result = false; + int timeout_id = 0; + + if (bt_adapter_le_set_state_changed_cb(adapter_le_state_changed_cb_for_adapter_p, "disable") != BT_ERROR_NONE) { + dts_fail("bt_adapter_le_disable", + "bt_adapter_le_set_state_changed_cb() failed."); + } + + if (bt_adapter_le_disable() == BT_ERROR_NONE) { + tet_printf("bt_adapter_le_state_changed_cb() will be called"); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + bt_adapter_le_unset_state_changed_cb(); + dts_check_eq("bt_adapter_le_disable", callback_result, true, + "BT LE was not disabled"); + } else { + dts_fail("bt_adapter_le_disable", "bt_adapter_le_disable() failed"); + } +} + +static void utc_network_bluetooth_adapter_get_le_state_p(void) +{ + bt_adapter_le_state_e adapter_le_state = BT_ADAPTER_LE_DISABLED; + int ret = BT_ERROR_NONE; + + ret = bt_adapter_le_get_state(&adapter_le_state); + if (ret == BT_ERROR_NONE && adapter_le_state == BT_ADAPTER_LE_ENABLED) { + dts_pass("bt_adapter_le_get_state", + "bt_adapter_le_get_state() succeeded."); + } else { + dts_fail("bt_adapter_le_get_state", + "bt_adapter_le_get_state() failed."); + } +} + +static void utc_network_bluetooth_adapter_unset_le_state_changed_cb_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_adapter_le_unset_state_changed_cb(); + dts_check_eq("bt_adapter_le_unset_state_changed_cb", ret, BT_ERROR_NONE, + "bt_adapter_unset_state_le_changed_cb() failed."); +} diff --git a/TC/testcase/utc_network_bluetooth_audio_negative.c b/TC/testcase/utc_network_bluetooth_audio_negative.c new file mode 100755 index 0000000..438b166 --- /dev/null +++ b/TC/testcase/utc_network_bluetooth_audio_negative.c @@ -0,0 +1,383 @@ +/* + * utc_network_bluetooth_audio_negative.c + * + * Created on: 19-Sep-2013 + * Author: mrinal.m + */ + +#include +#include +#include + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static void startup(void); +static void cleanup(void); + +static GMainLoop *mainloop; + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_network_bluetooth_audio_connect_n(void); +static void utc_network_bluetooth_audio_disconnect_n(void); +static void utc_network_bluetooth_audio_set_connection_n(void); +static void utc_network_bluetooth_ag_get_speaker_gain_n(void); +static void utc_network_bluetooth_ag_is_nrec_enabled_n(void); +static void utc_network_bluetooth_ag_set_microphone_gain_changed_n(void); +static void utc_network_bluetooth_ag_set_speaker_gain_changed_n(void); +static void utc_network_bluetooth_ag_is_sco_opened_n(void); +static void utc_network_bluetooth_ag_set_sco_state_changed_n(void); +static void utc_network_bluetooth_ag_notify_call_event_n(void); +static void utc_network_bluetooth_ag_notify_call_list_n(void); +static void utc_network_bluetooth_ag_set_call_handling_event_cb_n(void); +static void utc_network_bluetooth_ag_set_multi_call_handling_event_cb_n(void); +static void utc_network_bluetooth_ag_set_vendor_cmd_cb_n(void); +static void utc_network_bluetooth_ag_unset_vendor_cmd_cb_n(void); +static void utc_network_bluetooth_ag_unset_multi_call_handling_event_cb_n(void); +static void utc_network_bluetooth_ag_unset_dtmf_transmitted_cb_n(void); +static void utc_network_bluetooth_ag_call_list_destroy_n(void); +static void utc_network_bluetooth_ag_call_list_reset_n(void); +static void utc_network_bluetooth_ag_call_list_add_n(void); +static void utc_network_bluetooth_ag_set_dtmf_transmitted_cb_n(void); + +void adapter_state_changed_cb_for_audio_negative(int result, + bt_adapter_state_e adapter_state, + void *user_data); +gboolean timeout_func(gpointer data); + +struct tet_testlist tet_testlist[] = { + {utc_network_bluetooth_audio_connect_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_audio_disconnect_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_audio_set_connection_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_ag_get_speaker_gain_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_ag_is_nrec_enabled_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_ag_set_microphone_gain_changed_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_ag_set_speaker_gain_changed_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_ag_is_sco_opened_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_ag_set_sco_state_changed_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_ag_notify_call_event_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_ag_notify_call_list_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_ag_set_call_handling_event_cb_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_ag_set_multi_call_handling_event_cb_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_ag_set_vendor_cmd_cb_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_ag_set_dtmf_transmitted_cb_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_ag_call_list_destroy_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_ag_call_list_reset_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_ag_call_list_add_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_ag_unset_vendor_cmd_cb_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_ag_unset_multi_call_handling_event_cb_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_ag_unset_dtmf_transmitted_cb_n, NEGATIVE_TC_IDX}, + {NULL, 0}, +}; + +static void startup(void) +{ + int ret = BT_ERROR_NONE; + int timeout_id = 0; + + /* start of TC */ + mainloop = g_main_loop_new(NULL, FALSE); + + bt_initialize(); + + if (bt_audio_initialize() != BT_ERROR_NONE) + tet_printf("bt_audio_initialize failed"); + + if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_audio_negative, "startup") != BT_ERROR_NONE) { + tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed"); + } + + tet_printf("bt_adapter_disable() was called."); + ret = bt_adapter_disable(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_adapter_disable() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else if (ret == BT_ERROR_NOT_ENABLED) { + tet_printf("Bluetooth adapter is not enabled."); + } else { + tet_printf("DTS may fail because bt_adapter_disable() failed"); + } + + if (bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE) { + tet_printf("bt_adapter_set_state_changed_cb() failed."); + } + + tet_printf("TC start"); +} + +static void cleanup(void) +{ + /* end of TC */ + bt_deinitialize(); + tet_printf("TC end."); +} + +gboolean timeout_func(gpointer data) +{ + tet_printf("Callback: Timeout."); + g_main_loop_quit((GMainLoop *) data); + return FALSE; +} + +/** + * @brief Callback funtions + */ +void adapter_state_changed_cb_for_audio_negative(int result, + bt_adapter_state_e adapter_state, + void *user_data) +{ + tet_printf("Callback: bt_adapter_state_changed_cb was called."); + if (user_data != NULL && !strcmp((char *)user_data, "startup")) { + if (adapter_state == BT_ADAPTER_DISABLED && result == BT_ERROR_NONE) { + tet_printf("Callback: BT was disabled. DTS will be started."); + } else { + tet_printf("Callback: BT was not disabled. DTS will be started but DTS may fail."); + } + + if (mainloop) { + g_main_loop_quit(mainloop); + } + } +} + +/** + * @brief Negative test case of bt_audio_connect() + */ +static void utc_network_bluetooth_audio_connect_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_audio_connect(NULL, BT_AUDIO_PROFILE_TYPE_HSP_HFP); + dts_check_eq("bt_audio_connect", ret, + BT_ERROR_INVALID_PARAMETER, "bt_audio_connect() failed."); +} + +/** + * @brief Negative test case of bt_audio_disconnect() + */ +static void utc_network_bluetooth_audio_disconnect_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_audio_disconnect(NULL, BT_AUDIO_PROFILE_TYPE_A2DP); + dts_check_eq("bt_audio_disconnect", ret, + BT_ERROR_INVALID_PARAMETER, + "bt_audio_disconnect() failed."); +} + +/** + * @brief Negative test case of bt_audio_set_connection_state_changed_cb() + */ +static void utc_network_bluetooth_audio_set_connection_n(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_audio_set_connection_state_changed_cb(NULL, NULL); + dts_check_eq("bt_audio_set_connection_state_changed_cb", ret, + BT_ERROR_INVALID_PARAMETER, + "bt_audio_set_connection_state_changed_cb() failed."); +} + +/** + * @brief Negative test case of bt_ag_get_speaker_gain() + */ +static void utc_network_bluetooth_ag_get_speaker_gain_n(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_ag_get_speaker_gain(NULL); + dts_check_eq("bt_ag_get_speaker_gain", ret, + BT_ERROR_INVALID_PARAMETER, + "bt_ag_get_speaker_gain() failed."); +} + +/** + * @brief Negative test case of bt_ag_is_nrec_enabled() + */ +static void utc_network_bluetooth_ag_is_nrec_enabled_n(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_ag_is_nrec_enabled(NULL); + dts_check_eq("bt_ag_is_nrec_enabled", ret, + BT_ERROR_INVALID_PARAMETER, + "bt_ag_is_nrec_enabled() failed."); +} + +/** + * @brief Negative test case of bt_ag_set_microphone_gain_changed_cb() + */ +static void utc_network_bluetooth_ag_set_microphone_gain_changed_n(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_ag_set_microphone_gain_changed_cb(NULL, NULL); + dts_check_eq("bt_ag_set_microphone_gain_changed_cb", ret, + BT_ERROR_INVALID_PARAMETER, + "bt_ag_set_microphone_gain_changed_cb() failed."); +} + +/** + * @brief Negative test case of bt_ag_set_speaker_gain_changed_cb() + */ +static void utc_network_bluetooth_ag_set_speaker_gain_changed_n(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_ag_set_speaker_gain_changed_cb(NULL, NULL); + dts_check_eq("bt_ag_set_speaker_gain_changed_cb", ret, + BT_ERROR_INVALID_PARAMETER, + "bt_ag_set_speaker_gain_changed_cb() failed."); +} + +/** + * @brief Negative test case of bt_ag_is_sco_opened() + */ +static void utc_network_bluetooth_ag_is_sco_opened_n(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_ag_is_sco_opened(NULL); + dts_check_eq("bt_ag_is_sco_opened", ret, + BT_ERROR_INVALID_PARAMETER, + "bt_ag_is_sco_opened() failed."); +} + +/** + * @brief Negative test case of bt_ag_set_sco_state_changed_cb() + */ +static void utc_network_bluetooth_ag_set_sco_state_changed_n(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_ag_set_sco_state_changed_cb(NULL, NULL); + dts_check_eq("bt_ag_set_sco_state_changed_cb", ret, + BT_ERROR_INVALID_PARAMETER, + "bt_ag_set_sco_state_changed_cb() failed."); +} + +/** + * @brief Negative test case of bt_ag_notify_call_event() + */ +static void utc_network_bluetooth_ag_notify_call_event_n(void) +{ + int ret = BT_ERROR_NONE; + unsigned int call_id = 0; + ret = bt_ag_notify_call_event(BT_AG_CALL_EVENT_INCOMING, call_id, NULL); + dts_check_eq("bt_ag_notify_call_event", ret, + BT_ERROR_INVALID_PARAMETER, + "bt_ag_notify_call_event() failed."); +} + +/** + * @brief Negative test case of bt_ag_notify_call_list() + */ +static void utc_network_bluetooth_ag_notify_call_list_n(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_ag_notify_call_list(NULL); + dts_check_eq("bt_ag_notify_call_list", ret, + BT_ERROR_INVALID_PARAMETER, + "bt_ag_notify_call_list() failed."); +} + +/** + * @brief Negative test case of bt_ag_set_call_handling_event_cb() + */ +static void utc_network_bluetooth_ag_set_call_handling_event_cb_n(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_ag_set_call_handling_event_cb(NULL, NULL); + dts_check_eq("bt_ag_set_call_handling_event_cb", ret, + BT_ERROR_INVALID_PARAMETER, + "bt_ag_set_call_handling_event_cb() failed."); +} + +/** + * @brief Negative test case of bt_ag_set_multi_call_handling_event_cb() + */ +static void utc_network_bluetooth_ag_set_multi_call_handling_event_cb_n(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_ag_set_multi_call_handling_event_cb(NULL, NULL); + dts_check_eq("bt_ag_set_multi_call_handling_event_cb", ret, + BT_ERROR_INVALID_PARAMETER, + "bt_ag_set_multi_call_handling_event_cb() failed."); +} + +/** + * @brief Negative test case of bt_ag_set_dtmf_transmitted_cb() + */ +static void utc_network_bluetooth_ag_set_dtmf_transmitted_cb_n(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_ag_set_dtmf_transmitted_cb(NULL, NULL); + dts_check_eq("bt_ag_set_dtmf_transmitted_cb", ret, + BT_ERROR_INVALID_PARAMETER, + "bt_ag_set_dtmf_transmitted_cb() failed."); + +} + +/** + * @brief Negative test case of bt_ag_unset_multi_call_handling_event_cb() + */ +static void utc_network_bluetooth_ag_unset_multi_call_handling_event_cb_n(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_deinitialize(); + ret = bt_ag_unset_multi_call_handling_event_cb(); + dts_check_eq("bt_ag_unset_multi_call_handling_event_cb", ret, + BT_ERROR_NOT_INITIALIZED, + "BT_ERROR_NOT_INITIALIZED must be returned when BT is not initialized."); +} + +/** + * @brief Negative test case of bt_ag_unset_dtmf_transmitted_cb() + */ +static void utc_network_bluetooth_ag_unset_dtmf_transmitted_cb_n(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_deinitialize(); + ret = bt_ag_unset_dtmf_transmitted_cb(); + dts_check_eq("bt_ag_unset_dtmf_transmitted_cb", ret, + BT_ERROR_NOT_INITIALIZED, + "BT_ERROR_NOT_INITIALIZED must be returned when BT is not initialized."); +} + +/** + * @brief Negative test case of bt_call_list_destroy() + */ +static void utc_network_bluetooth_ag_call_list_destroy_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_call_list_destroy(NULL); + dts_check_eq("bt_call_list_destroy", ret, BT_ERROR_INVALID_PARAMETER, + "bt_call_list_destroy() failed."); +} + +/** + * @brief Negative test case of bt_call_list_reset() + */ +static void utc_network_bluetooth_ag_call_list_reset_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_call_list_reset(NULL); + dts_check_eq("bt_call_list_reset", ret, BT_ERROR_INVALID_PARAMETER, + "bt_call_list_reset() failed."); +} + +/** + * @brief Negative test case of bt_call_list_add() + */ +static void utc_network_bluetooth_ag_call_list_add_n(void) +{ + int ret = BT_ERROR_NONE; + unsigned int call_id = 0; + const char *phone_number = "9663868998"; + + ret = bt_call_list_add(NULL, call_id, BT_AG_CALL_STATE_INCOMING, phone_number); + dts_check_eq("bt_call_list_add", ret, BT_ERROR_INVALID_PARAMETER, + "bt_call_list_add() failed."); + +} diff --git a/TC/testcase/utc_network_bluetooth_audio_positive.c b/TC/testcase/utc_network_bluetooth_audio_positive.c new file mode 100755 index 0000000..d1fffbc --- /dev/null +++ b/TC/testcase/utc_network_bluetooth_audio_positive.c @@ -0,0 +1,666 @@ +/* + * utc_network_bluetooth_audio_positive.c + * + * Created on: 19-Sep-2013 + * Author: mrinal.m + */ + +#include +#include +#include + +#define CONFIG_FILE_PATH "/opt/home/capi-network-bluetooth/tetware.conf" + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +char *remote_address; +static GMainLoop *mainloop; + +static void utc_network_bluetooth_audio_initialize_p(void); +static void utc_network_bluetooth_audio_deinitialize_p(void); +static void utc_network_bluetooth_audio_connect_p(void); +static void utc_network_bluetooth_audio_disconnect_p(void); +static void utc_network_bluetooth_audio_set_connection_p(void); +static void utc_network_bluetooth_audio_unset_connection_p(void); +static void utc_network_bluetooth_ag_notify_speaker_gain_p(void); +static void utc_network_bluetooth_ag_get_speaker_gain_p(void); +static void utc_network_bluetooth_ag_is_nrec_enabled_p(void); +static void utc_network_bluetooth_ag_set_microphone_gain_changed_p(void); +static void utc_network_bluetooth_ag_unset_microphone_gain_changed_p(void); +static void utc_network_bluetooth_ag_set_speaker_gain_changed_p(void); +static void utc_network_bluetooth_ag_unset_speaker_gain_changed_p(void); +static void utc_network_bluetooth_ag_open_sco_p(void); +static void utc_network_bluetooth_ag_close_sco_p(void); +static void utc_network_bluetooth_ag_is_sco_opened_p(void); +static void utc_network_bluetooth_ag_set_sco_state_changed_p(void); +static void utc_network_bluetooth_ag_unset_sco_state_changed_p(void); +static void utc_network_bluetooth_ag_notify_call_event_p(void); +static void utc_network_bluetooth_ag_notify_call_list_p(void); +static void utc_network_bluetooth_ag_notify_voice_recognition_state_p(void); +static void utc_network_bluetooth_ag_set_call_handling_event_cb_p(void); +static void utc_network_bluetooth_ag_unset_call_handling_event_cb_p(void); +static void utc_network_bluetooth_ag_set_multi_call_handling_event_cb_p(void); +static void utc_network_bluetooth_ag_unset_multi_call_handling_event_cb_p(void); +static void utc_network_bluetooth_ag_set_dtmf_transmitted_cb_p(void); +static void utc_network_bluetooth_ag_unset_dtmf_transmitted_cb_p(void); +static void utc_network_bluetooth_ag_set_vendor_cmd_cb_p(void); +static void utc_network_bluetooth_ag_unset_vendor_cmd_cb_p(void); +static void utc_network_bluetooth_ag_call_list_create_p(void); +static void utc_network_bluetooth_ag_call_list_destroy_p(void); +static void utc_network_bluetooth_ag_call_list_reset_p(void); +static void utc_network_bluetooth_ag_call_list_add_p(void); +static void utc_network_bluetooth_ag_ca2dp_set_content_protection_p(void); + +void connection_state_changed_cb_for_audio_p(int result, bool connected, + const char *remote_address, + bt_audio_profile_type_e type, + void *user_data); +void dtmf_transmitted_cb_for_ag_p(const char *dtmf, void *user_data); +void multi_call_handling_event_cb_for_ag_p(bt_ag_multi_call_handling_event_e event, void *user_data); +void call_handling_event_cb_for_ag_p(bt_ag_call_handling_event_e event, + unsigned int call_id, void *user_data); +void sco_state_changed_cb_for_ag_p(int result, bool opened, void *user_data); +void speaker_gain_changed_cb_for_ag_p(int gain, void *user_data); +void microphone_gain_changed_cb_for_ag_p(int gain, void *user_data); +void adapter_state_changed_cb_for_audio_p(int result, + bt_adapter_state_e adapter_state, + void *user_data); + +gboolean timeout_func(gpointer data); + +struct tet_testlist tet_testlist[] = { + {utc_network_bluetooth_audio_initialize_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_audio_set_connection_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_audio_connect_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_ag_open_sco_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_ag_set_microphone_gain_changed_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_ag_set_speaker_gain_changed_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_ag_notify_speaker_gain_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_ag_get_speaker_gain_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_ag_is_nrec_enabled_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_ag_unset_microphone_gain_changed_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_ag_unset_speaker_gain_changed_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_ag_set_sco_state_changed_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_ag_set_vendor_cmd_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_ag_unset_vendor_cmd_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_ag_is_sco_opened_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_ag_close_sco_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_ag_notify_call_event_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_ag_notify_call_list_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_ag_notify_voice_recognition_state_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_ag_set_call_handling_event_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_ag_unset_call_handling_event_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_ag_set_multi_call_handling_event_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_ag_unset_multi_call_handling_event_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_ag_set_dtmf_transmitted_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_ag_unset_dtmf_transmitted_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_ag_unset_sco_state_changed_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_ag_call_list_create_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_ag_call_list_destroy_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_ag_call_list_reset_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_ag_call_list_add_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_ag_ca2dp_set_content_protection_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_audio_disconnect_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_audio_unset_connection_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_audio_deinitialize_p, POSITIVE_TC_IDX}, + {NULL, 0}, +}; + +int get_value_from_file(void) +{ + FILE *fp; + char *token; + char buf[100]; + + fp = fopen(CONFIG_FILE_PATH, "r"); + if (fp == NULL) { + tet_printf("Default configuration is used\n"); + return -1; + } + while (fgets(buf, sizeof(buf), fp)) { + if (buf[0] == '#' || buf[0] == '\n') + continue; + + token = strrchr(buf, '\n'); + if (token == NULL) { + tet_printf("g_conf is too long\n"); + break; + } + *token = '\0'; + + token = strtok(buf, "="); + if (token == NULL) { + continue; + } + if (strcasecmp(token, "BT_ADDR_HEADSET") == 0) { + token = strtok(NULL, "="); + remote_address = strdup(token); + fclose(fp); + return 0; + } + } + return -1; +} + +static void startup(void) +{ + bt_error_e ret = BT_ERROR_NONE; + int timeout_id = 0; + + if(get_value_from_file() == -1) { + tet_printf("Failed to read."); + } + + /* start of TC */ + tet_printf("TC start."); + mainloop = g_main_loop_new(NULL, FALSE); + + bt_initialize(); + + if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_audio_p, "startup") != BT_ERROR_NONE) { + tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed"); + } + + tet_printf("bt_adapter_enable() was called."); + ret = bt_adapter_enable(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_adapter_enable() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else if (ret != BT_ERROR_ALREADY_DONE) { + tet_printf("DTS may fail because bt_adapter_disable() failed"); + } + + if (bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE) { + tet_printf("bt_adapter_set_state_changed_cb() failed."); + } + + tet_printf("TC start"); +} + +static void cleanup(void) +{ + /* end of TC */ + bt_deinitialize(); + tet_printf("TC end."); +} + +gboolean timeout_func(gpointer data) +{ + tet_printf("[%s] Callback: Timeout.", __FUNCTION__); + g_main_loop_quit((GMainLoop *) data); + return FALSE; +} + +/** + * @brief Callback funtions + */ + +void adapter_state_changed_cb_for_audio_p(int result, + bt_adapter_state_e adapter_state, + void *user_data) +{ + +} + +void connection_state_changed_cb_for_audio_p(int result, bool connected, + const char *remote_address, + bt_audio_profile_type_e type, + void *user_data) +{ + +} + +void microphone_gain_changed_cb_for_ag_p(int gain, void *user_data) +{ + +} + +void speaker_gain_changed_cb_for_ag_p(int gain, void *user_data) +{ + +} + +void sco_state_changed_cb_for_ag_p(int result, bool opened, void *user_data) +{ + +} + +void call_handling_event_cb_for_ag_p(bt_ag_call_handling_event_e event, + unsigned int call_id, void *user_data) +{ + +} + +void multi_call_handling_event_cb_for_ag_p(bt_ag_multi_call_handling_event_e event, void *user_data) +{ + +} + +void dtmf_transmitted_cb_for_ag_p(const char *dtmf, void *user_data) +{ + +} + +void vendor_cmd_event_cb_for_ag_p(char *cmd, void *user_data) +{ + tet_printf("Callback : vendor_cmd_cb was called."); + tet_printf("Vendor Command[%s]", cmd); +} + +/** + * @brief Positive test case of bt_audio_initialize() + */ +static void utc_network_bluetooth_audio_initialize_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_audio_initialize(); + dts_check_eq("bt_audio_initialize", ret, BT_ERROR_NONE, + "bt_audio_initialize() failed. %x", ret); + +} + +/** + * @brief Positive test case of bt_audio_connect() + */ +static void utc_network_bluetooth_audio_connect_p(void) +{ + int ret = BT_ERROR_NONE; + const char *remote_address = "00:23:78:AB:C4:20"; + ret = bt_audio_connect(remote_address, BT_AUDIO_PROFILE_TYPE_HSP_HFP); + dts_check_eq("bt_audio_connect", ret, BT_ERROR_NONE, + "bt_audio_connect() failed. %x", ret); +} + +/** + * @brief Positive test case of bt_audio_disconnect() + */ +static void utc_network_bluetooth_audio_disconnect_p(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_audio_disconnect(remote_address, BT_AUDIO_PROFILE_TYPE_HSP_HFP); + dts_check_eq("bt_audio_disconnect", ret, BT_ERROR_NONE, + "bt_audio_disconnect() failed. %x", ret); +} + +/** + * @brief Positive test case of bt_audio_set_connection_state_changed_cb() + */ +static void utc_network_bluetooth_audio_set_connection_p(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_audio_set_connection_state_changed_cb + (connection_state_changed_cb_for_audio_p, NULL); + dts_check_eq("bt_audio_set_connection_state_changed_cb", ret, + BT_ERROR_NONE, + "bt_audio_set_connection_state_changed_cb() failed."); +} + +/** + * @brief Positive test case of bt_audio_unset_connection_state_changed_cb() + */ +static void utc_network_bluetooth_audio_unset_connection_p(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_audio_unset_connection_state_changed_cb(); + dts_check_eq("bt_audio_set_connection_state_changed_cb", ret, + BT_ERROR_NONE, + "bt_audio_set_connection_state_changed_cb() failed."); +} + +/** + * @brief Positive test case of bt_ag_notify_speaker_gain() + */ +static void utc_network_bluetooth_ag_notify_speaker_gain_p(void) +{ + int ret = BT_ERROR_NONE; + int gain = 10; + ret = bt_ag_notify_speaker_gain(gain); + dts_check_eq("bt_ag_notify_speaker_gain", ret, BT_ERROR_NONE, + "bt_ag_notify_speaker_gain() failed.%x", ret); +} + +/** + * @brief Positive test case of bt_ag_get_speaker_gain() + */ +static void utc_network_bluetooth_ag_get_speaker_gain_p(void) +{ + int ret = BT_ERROR_NONE; + int gain = 0; + ret = bt_ag_get_speaker_gain(&gain); + dts_check_eq("bt_ag_get_speaker_gain", ret, BT_ERROR_NONE, + "bt_ag_get_speaker_gain() failed."); + +} + +/** + * @brief Positive test case of bt_ag_is_nrec_enabled() + */ +static void utc_network_bluetooth_ag_is_nrec_enabled_p(void) +{ + int ret = BT_ERROR_NONE; + bool enabled = 1; + ret = bt_ag_is_nrec_enabled(&enabled); + dts_check_eq("bt_ag_is_nrec_enabled", ret, BT_ERROR_NONE, + "bt_ag_is_nrec_enabled() failed."); + +} + +/** + * @brief Positive test case of bt_ag_set_microphone_gain_changed_cb() + */ +static void utc_network_bluetooth_ag_set_microphone_gain_changed_p(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_ag_set_microphone_gain_changed_cb(microphone_gain_changed_cb_for_ag_p, NULL); + dts_check_eq("bt_ag_set_microphone_gain_changed_cb", ret, BT_ERROR_NONE, + "bt_ag_set_microphone_gain_changed_cb() failed."); + +} + +/** + * @brief Positive test case of bt_ag_unset_microphone_gain_changed_cb() + */ +static void utc_network_bluetooth_ag_unset_microphone_gain_changed_p(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_ag_unset_microphone_gain_changed_cb(); + dts_check_eq("bt_ag_unset_microphone_gain_changed_cb", ret, + BT_ERROR_NONE, + "bt_ag_unset_microphone_gain_changed_cb() failed."); + +} + +/** + * @brief Positive test case of bt_ag_set_speaker_gain_changed_cb() + */ +static void utc_network_bluetooth_ag_set_speaker_gain_changed_p(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_ag_set_speaker_gain_changed_cb(speaker_gain_changed_cb_for_ag_p, NULL); + dts_check_eq("bt_ag_set_speaker_gain_changed_cb", ret, BT_ERROR_NONE, + "bt_ag_set_speaker_gain_changed_cb() failed."); + +} + +/** + * @brief Positive test case of bt_ag_unset_speaker_gain_changed_cb() + */ +static void utc_network_bluetooth_ag_unset_speaker_gain_changed_p(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_ag_unset_speaker_gain_changed_cb(); + dts_check_eq("bt_ag_unset_speaker_gain_changed_cb", ret, BT_ERROR_NONE, + "bt_ag_unset_speaker_gain_changed_cb() failed."); + +} + +/** + * @brief Positive test case of bt_ag_open_sco() + */ +static void utc_network_bluetooth_ag_open_sco_p(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_ag_open_sco(); + dts_check_eq("bt_ag_open_sco", ret, BT_ERROR_NONE, + "bt_ag_open_sco() failed."); + +} + +/** + * @brief Positive test case of bt_ag_close_sco() + */ +static void utc_network_bluetooth_ag_close_sco_p(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_ag_close_sco(); + dts_check_eq("bt_ag_close_sco", ret, BT_ERROR_NONE, + "bt_ag_close_sco() failed."); + +} + +/** + * @brief Positive test case of bt_ag_is_sco_opened() + */ +static void utc_network_bluetooth_ag_is_sco_opened_p(void) +{ + int ret = BT_ERROR_NONE; + bool opened = 1; + ret = bt_ag_is_sco_opened(&opened); + dts_check_eq("bt_ag_is_sco_opened", ret, BT_ERROR_NONE, + "bt_ag_is_sco_opened() failed."); + +} + +/** + * @brief Positive test case of bt_ag_set_sco_state_changed_cb() + */ +static void utc_network_bluetooth_ag_set_sco_state_changed_p(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_ag_set_sco_state_changed_cb(sco_state_changed_cb_for_ag_p, NULL); + dts_check_eq("bt_ag_set_sco_state_changed_cb", ret, BT_ERROR_NONE, + "bt_ag_set_sco_state_changed_cb() failed."); + +} + +/** + * @brief Positive test case of bt_ag_unset_sco_state_changed_cb() + */ +static void utc_network_bluetooth_ag_unset_sco_state_changed_p(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_ag_unset_sco_state_changed_cb(); + dts_check_eq("bt_ag_unset_sco_state_changed_cb", ret, BT_ERROR_NONE, + "bt_ag_unset_sco_state_changed_cb() failed."); + +} + +/** + * @brief Positive test case of bt_ag_notify_call_event() + */ +static void utc_network_bluetooth_ag_notify_call_event_p(void) +{ + int ret = BT_ERROR_NONE; + const char *phone_number = "9663868998"; + unsigned int call_id = 0; + ret = bt_ag_notify_call_event(BT_AG_CALL_EVENT_INCOMING, + call_id, phone_number); + dts_check_eq("bt_ag_notify_call_event", ret, BT_ERROR_NONE, + "bt_ag_notify_call_event() failed."); + +} + +/** + * @brief Positive test case of bt_ag_notify_call_list() + */ +static void utc_network_bluetooth_ag_notify_call_list_p(void) +{ + int ret = BT_ERROR_NONE; + bt_call_list_h handle; + const char *phone_number = "9663868998"; + + handle = g_malloc0(sizeof(bt_call_list_h)); + bt_call_list_add(handle, 1, BT_AG_CALL_STATE_ACTIVE, phone_number); + ret = bt_ag_notify_call_list(handle); + dts_check_eq("bt_ag_notify_call_list", ret, BT_ERROR_NONE, + "bt_ag_notify_call_list() failed."); + +} + +/** + * @brief Positive test case of bt_ag_notify_voice_recognition_state() + */ +static void utc_network_bluetooth_ag_notify_voice_recognition_state_p(void) +{ + int ret = BT_ERROR_NONE; + bool state = 1; + + ret = bt_ag_notify_voice_recognition_state(state); + dts_check_eq("bt_ag_notify_voice_recognition_state", ret, BT_ERROR_NONE, + "bt_ag_notify_voice_recognition_state() failed."); + +} + +/** + * @brief Positive test case of bt_ag_set_call_handling_event_cb() + */ +static void utc_network_bluetooth_ag_set_call_handling_event_cb_p(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_ag_set_call_handling_event_cb(call_handling_event_cb_for_ag_p, + NULL); + dts_check_eq("bt_ag_set_call_handling_event_cb", ret, BT_ERROR_NONE, + "bt_ag_set_call_handling_event_cb() failed."); + +} + +/** + * @brief Positive test case of bt_ag_unset_call_handling_event_cb() + */ +static void utc_network_bluetooth_ag_unset_call_handling_event_cb_p(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_ag_unset_call_handling_event_cb(); + dts_check_eq("bt_ag_unset_call_handling_event_cb", ret, BT_ERROR_NONE, + "bt_ag_unset_call_handling_event_cb() failed."); + +} + +/** + * @brief Positive test case of bt_ag_set_multi_call_handling_event_cb() + */ +static void utc_network_bluetooth_ag_set_multi_call_handling_event_cb_p(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_ag_set_multi_call_handling_event_cb(multi_call_handling_event_cb_for_ag_p, NULL); + dts_check_eq("bt_ag_set_multi_call_handling_event_cb", ret, + BT_ERROR_NONE, + "bt_ag_set_multi_call_handling_event_cb() failed."); + +} + +/** + * @brief Positive test case of bt_ag_unset_multi_call_handling_event_cb() + */ +static void utc_network_bluetooth_ag_unset_multi_call_handling_event_cb_p(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_ag_unset_multi_call_handling_event_cb(); + dts_check_eq("bt_ag_unset_multi_call_handling_event_cb", ret, + BT_ERROR_NONE, + "bt_ag_unset_multi_call_handling_event_cb() failed."); + +} + +/** + * @brief Positive test case of bt_ag_set_dtmf_transmitted_cb() + */ +static void utc_network_bluetooth_ag_set_dtmf_transmitted_cb_p(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_ag_set_dtmf_transmitted_cb(dtmf_transmitted_cb_for_ag_p, NULL); + dts_check_eq("bt_ag_set_dtmf_transmitted_cb", ret, BT_ERROR_NONE, + "bt_ag_set_dtmf_transmitted_cb() failed."); + +} + +/** + * @brief Positive test case of bt_ag_unset_dtmf_transmitted_cb() + */ +static void utc_network_bluetooth_ag_unset_dtmf_transmitted_cb_p(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_ag_unset_dtmf_transmitted_cb(); + dts_check_eq("bt_ag_unset_dtmf_transmitted_cb", ret, BT_ERROR_NONE, + "bt_ag_unset_dtmf_transmitted_cb() failed."); + +} + +/** + * @brief Positive test case of bt_call_list_create() + */ +static void utc_network_bluetooth_ag_call_list_create_p(void) +{ + int ret = BT_ERROR_NONE; + bt_call_list_h handle; + const char *phone_number = "9663868998"; + + ret = bt_call_list_create(&handle); + ret = bt_call_list_add(handle, 1, BT_AG_CALL_STATE_ACTIVE, phone_number); + + dts_check_eq("bt_call_list_create", ret, BT_ERROR_NONE, + "bt_call_list_create() failed."); +} + +/** + * @brief Positive test case of bt_call_list_destroy() + */ +static void utc_network_bluetooth_ag_call_list_destroy_p(void) +{ + int ret = BT_ERROR_NONE; + bt_call_list_h handle; + const char *phone_number = "9663868998"; + + handle = g_malloc0(sizeof(bt_call_list_h)); + bt_call_list_add(handle, 1, BT_AG_CALL_STATE_ACTIVE, phone_number); + ret = bt_call_list_destroy(handle); + dts_check_eq("bt_call_list_destroy", ret, BT_ERROR_NONE, + "bt_call_list_destroy() failed."); +} + +/** + * @brief Positive test case of bt_call_list_reset() + */ +static void utc_network_bluetooth_ag_call_list_reset_p(void) +{ + int ret = BT_ERROR_NONE; + bt_call_list_h handle; + const char *phone_number = "9663868998"; + + handle = g_malloc0(sizeof(bt_call_list_h)); + bt_call_list_add(handle, 1, BT_AG_CALL_STATE_ACTIVE, phone_number); + ret = bt_call_list_reset(handle); + dts_check_eq("bt_call_list_reset", ret, BT_ERROR_NONE, + "bt_call_list_reset() failed."); +} + +/** + * @brief Positive test case of bt_call_list_add() + */ +static void utc_network_bluetooth_ag_call_list_add_p(void) +{ + int ret = BT_ERROR_NONE; + unsigned int call_id = 0; + bt_call_list_h handle; + const char *phone_number = "9663868998"; + + handle = g_malloc0(sizeof(bt_call_list_h)); + bt_call_list_add(handle, 1, BT_AG_CALL_STATE_ACTIVE, phone_number); + ret = bt_call_list_add(handle, call_id, BT_AG_CALL_STATE_INCOMING, phone_number); + dts_check_eq("bt_call_list_add", ret, BT_ERROR_NONE, + "bt_call_list_add() failed."); +} + +/** + * @brief Positive test case of bt_audio_deinitialize() + */ +static void utc_network_bluetooth_audio_deinitialize_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_audio_deinitialize(); + dts_check_eq("bt_audio_deinitialize", ret, BT_ERROR_NONE, + "bt_audio_deinitialize() failed."); +} diff --git a/TC/testcase/utc_network_bluetooth_avrcp_negative.c b/TC/testcase/utc_network_bluetooth_avrcp_negative.c new file mode 100755 index 0000000..a62c7b4 --- /dev/null +++ b/TC/testcase/utc_network_bluetooth_avrcp_negative.c @@ -0,0 +1,174 @@ +/* + * utc_network_bluetooth_avrcp_negative.c + * + * Created on: 20-Sep-2013 + * Author: mrinal.m + */ + +#include "bluetooth.h" +#include +#include + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +const char target_name[128] = "dts_test"; +char target_address[18] = ""; + +static GMainLoop *mainloop; + +static void utc_network_bluetooth_audio_initialize_n(void); +static void utc_network_bluetooth_avrcp_set_equalizer_state_changed_n(void); +static void utc_network_bluetooth_avrcp_set_repeat_mode_changed_n(void); +static void utc_network_bluetooth_avrcp_set_shuffle_mode_changed_n(void); +static void utc_network_bluetooth_avrcp_set_scan_mode_changed_n(void); + + +void adapter_state_changed_cb_for_avrcp_n(int result, + bt_adapter_state_e adapter_state, + void *user_data); +gboolean timeout_func(gpointer data); + + +struct tet_testlist tet_testlist[] = { + {utc_network_bluetooth_audio_initialize_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_avrcp_set_equalizer_state_changed_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_avrcp_set_repeat_mode_changed_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_avrcp_set_shuffle_mode_changed_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_avrcp_set_scan_mode_changed_n, NEGATIVE_TC_IDX}, + {NULL, 0}, +}; + + +static void startup(void) +{ + int ret = BT_ERROR_NONE; + int timeout_id = 0; + + /* start of TC */ + mainloop = g_main_loop_new(NULL, FALSE); + + bt_initialize(); + if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_avrcp_n, "startup") != BT_ERROR_NONE) { + tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed"); + } + + tet_printf("bt_adapter_disable() was called."); + ret = bt_adapter_disable(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_adapter_disable() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else if (ret == BT_ERROR_NOT_ENABLED) { + tet_printf("Bluetooth adapter is not enabled."); + } else { + tet_printf("DTS may fail because bt_adapter_disable() failed"); + } + + if (bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE) { + tet_printf("bt_adapter_set_state_changed_cb() failed."); + } + + tet_printf("TC start"); +} + +static void cleanup(void) +{ + /* end of TC */ + bt_deinitialize(); + tet_printf("TC end."); +} + +gboolean timeout_func(gpointer data) +{ + tet_printf("Callback: Timeout."); + g_main_loop_quit((GMainLoop *) data); + return FALSE; +} + +/** + * @brief Negative test case of bt_avrcp_target_initialize() + */ + +void adapter_state_changed_cb_for_avrcp_n(int result, + bt_adapter_state_e adapter_state, + void *user_data) +{ + +} + +static void utc_network_bluetooth_audio_initialize_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_avrcp_target_initialize(NULL, NULL); + dts_check_eq("bt_avrcp_target_initialize", ret, + BT_ERROR_INVALID_PARAMETER, + "bt_avrcp_target_initialize() failed."); + +} + +/** + * @brief Negative test case of bt_avrcp_set_equalizer_state_changed_cb() + */ +static void utc_network_bluetooth_avrcp_set_equalizer_state_changed_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_avrcp_set_equalizer_state_changed_cb(NULL, NULL); + dts_check_eq("bt_avrcp_set_equalizer_state_changed_cb", ret, + BT_ERROR_INVALID_PARAMETER, + "bt_avrcp_set_equalizer_state_changed_cb() failed."); + +} + +/** + * @brief Negative test case of bt_avrcp_set_repeat_mode_changed_cb() + */ +static void utc_network_bluetooth_avrcp_set_repeat_mode_changed_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_avrcp_set_repeat_mode_changed_cb(NULL, NULL); + dts_check_eq("bt_avrcp_set_repeat_mode_changed_cb", ret, + BT_ERROR_INVALID_PARAMETER, + "bt_avrcp_set_repeat_mode_changed_cb() failed."); + +} + +/** + * @brief Negative test case of bt_avrcp_set_shuffle_mode_changed_cb() + */ +static void utc_network_bluetooth_avrcp_set_shuffle_mode_changed_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_avrcp_set_shuffle_mode_changed_cb(NULL, NULL); + dts_check_eq("bt_avrcp_set_shuffle_mode_changed_cb", ret, + BT_ERROR_INVALID_PARAMETER, + "bt_avrcp_set_shuffle_mode_changed_cb() failed."); + +} + +/** + * @brief Negative test case of bt_avrcp_set_scan_mode_changed_cb() + */ +static void utc_network_bluetooth_avrcp_set_scan_mode_changed_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_avrcp_set_scan_mode_changed_cb(NULL, NULL); + dts_check_eq("bt_avrcp_set_scan_mode_changed_cb", ret, + BT_ERROR_INVALID_PARAMETER, + "bt_avrcp_set_scan_mode_changed_cb() failed."); + +} diff --git a/TC/testcase/utc_network_bluetooth_avrcp_positive.c b/TC/testcase/utc_network_bluetooth_avrcp_positive.c new file mode 100755 index 0000000..79e0688 --- /dev/null +++ b/TC/testcase/utc_network_bluetooth_avrcp_positive.c @@ -0,0 +1,398 @@ +/* + * utc_network_bluetooth_avrcp_positive.c + * + * Created on: 20-Sep-2013 + * Author: mrinal.m + */ + +#include +#include +#include + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static void startup(void); +static void cleanup(void); + +static GMainLoop *mainloop; + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +void target_connection_state_changed_cb_for_avrcp_p(bool connected, + const char *remote_address, + void *user_data); +void equalizer_state_changed_cb_for_avrcp_p(bt_avrcp_equalizer_state_e equalizer, + void *user_data); +void repeat_mode_changed_cb_for_avrcp_p(bt_avrcp_repeat_mode_e repeat, + void *user_data); +void shuffle_mode_changed_cb_for_avrcp_p(bt_avrcp_shuffle_mode_e shuffle, + void *user_data); +void scan_mode_changed_cb_for_avrcp_p(bt_avrcp_scan_mode_e scan, + void *user_data); + +static void utc_network_bluetooth_avrcp_targe_initialize_p(void); +static void utc_network_bluetooth_avrcp_target_deinitialize_p(void); +static void utc_network_bluetooth_avrcp_target_notify_equalizer_state_p(void); +static void utc_network_bluetooth_avrcp_target_notify_repeat_mode_p(void); +static void utc_network_bluetooth_avrcp_target_notify_shuffle_mode_p(void); +static void utc_network_bluetooth_avrcp_target_notify_scan_mode_p(void); +static void utc_network_bluetooth_avrcp_target_notify_player_state_p(void); +static void utc_network_bluetooth_avrcp_target_notify_position_p(void); +static void utc_network_bluetooth_avrcp_target_notify_track_p(void); +static void utc_network_bluetooth_avrcp_set_equalizer_state_changed_p(void); +static void utc_network_bluetooth_avrcp_unset_equalizer_state_changed_p(void); +static void utc_network_bluetooth_avrcp_set_repeat_mode_changed_p(void); +static void utc_network_bluetooth_avrcp_unset_repeat_mode_changed_p(void); +static void utc_network_bluetooth_avrcp_set_shuffle_mode_changed_p(void); +static void utc_network_bluetooth_avrcp_unset_shuffle_mode_changed_p(void); +static void utc_network_bluetooth_avrcp_set_scan_mode_changed_p(void); +static void utc_network_bluetooth_avrcp_unset_scan_mode_changed_p(void); + +void adapter_state_changed_cb_for_avrcp_p(int result, + bt_adapter_state_e adapter_state, + void *user_data); +gboolean timeout_func(gpointer data); + +struct tet_testlist tet_testlist[] = { + {utc_network_bluetooth_avrcp_targe_initialize_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_avrcp_target_notify_equalizer_state_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_avrcp_target_notify_repeat_mode_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_avrcp_target_notify_shuffle_mode_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_avrcp_target_notify_scan_mode_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_avrcp_target_notify_player_state_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_avrcp_target_notify_position_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_avrcp_target_notify_track_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_avrcp_set_equalizer_state_changed_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_avrcp_unset_equalizer_state_changed_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_avrcp_set_repeat_mode_changed_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_avrcp_unset_repeat_mode_changed_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_avrcp_set_shuffle_mode_changed_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_avrcp_unset_shuffle_mode_changed_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_avrcp_set_scan_mode_changed_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_avrcp_unset_scan_mode_changed_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_avrcp_target_deinitialize_p, POSITIVE_TC_IDX}, + {NULL, 0}, +}; + +static void startup(void) +{ + int ret = BT_ERROR_NONE; + int timeout_id = 0; + + /* start of TC */ + mainloop = g_main_loop_new(NULL, FALSE); + + bt_initialize(); + if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_avrcp_p, "startup") != BT_ERROR_NONE) { + tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed"); + } + + tet_printf("bt_adapter_enable() was called."); + ret = bt_adapter_enable(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_adapter_enable() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else if (ret != BT_ERROR_ALREADY_DONE) { + tet_printf("DTS may fail because bt_adapter_disable() failed"); + } else if (ret == BT_ERROR_NOT_ENABLED) { + tet_printf("Bluetooth adapter is not enabled."); + } else { + tet_printf("DTS may fail because bt_adapter_disable() failed"); + } + + if (bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE) { + tet_printf("bt_adapter_set_state_changed_cb() failed."); + } + + tet_printf("TC start"); +} + +static void cleanup(void) +{ + /* end of TC */ + bt_deinitialize(); + tet_printf("TC end."); +} + +gboolean timeout_func(gpointer data) +{ + tet_printf("Callback: Timeout."); + g_main_loop_quit((GMainLoop *) data); + return FALSE; +} + +/** + * @brief Callback funtions + */ + +void adapter_state_changed_cb_for_avrcp_p(int result, + bt_adapter_state_e adapter_state, + void *user_data) +{ + +} + +void target_connection_state_changed_cb_for_avrcp_p(bool connected, + const char *remote_address, + void *user_data) +{ + +} + +void equalizer_state_changed_cb_for_avrcp_p( + bt_avrcp_equalizer_state_e equalizer, + void *user_data) +{ + +} + +void repeat_mode_changed_cb_for_avrcp_p(bt_avrcp_repeat_mode_e repeat, + void *user_data) +{ + +} + +void shuffle_mode_changed_cb_for_avrcp_p(bt_avrcp_shuffle_mode_e shuffle, + void *user_data) +{ + +} + +void scan_mode_changed_cb_for_avrcp_p(bt_avrcp_scan_mode_e scan, + void *user_data) +{ + +} + +/** + * @brief Positive test case of bt_avrcp_target_initialize() + */ +static void utc_network_bluetooth_avrcp_targe_initialize_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_avrcp_target_initialize( + target_connection_state_changed_cb_for_avrcp_p, + NULL); + dts_check_eq("bt_avrcp_target_initialize", ret, BT_ERROR_NONE, + "bt_avrcp_target_initialize() failed."); + +} + +/** + * @brief Positive test case of bt_avrcp_target_deinitialize() + */ +static void utc_network_bluetooth_avrcp_target_deinitialize_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_avrcp_target_deinitialize(); + dts_check_eq("bt_avrcp_target_deinitialize", ret, BT_ERROR_NONE, + "bt_avrcp_target_deinitialize() failed."); + +} + +/** + * @brief Positive test case of bt_avrcp_target_notify_equalizer_state() + */ +static void utc_network_bluetooth_avrcp_target_notify_equalizer_state_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_avrcp_target_notify_equalizer_state(BT_AVRCP_EQUALIZER_STATE_ON); + dts_check_eq("bt_avrcp_target_notify_equalizer_state", ret, + BT_ERROR_NONE, + "bt_avrcp_target_notify_equalizer_state() failed."); + +} + +/** + * @brief Positive test case of bt_avrcp_target_notify_repeat_mode() + */ +static void utc_network_bluetooth_avrcp_target_notify_repeat_mode_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_avrcp_target_notify_repeat_mode(BT_AVRCP_REPEAT_MODE_ALL_TRACK); + dts_check_eq("bt_avrcp_target_notify_repeat_mode", ret, BT_ERROR_NONE, + "bt_avrcp_target_notify_repeat_mode() failed."); + +} + +/** + * @brief Positive test case of bt_avrcp_target_notify_shuffle_mode() + */ +static void utc_network_bluetooth_avrcp_target_notify_shuffle_mode_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_avrcp_target_notify_shuffle_mode(BT_AVRCP_SHUFFLE_MODE_ALL_TRACK); + dts_check_eq("bt_avrcp_target_notify_shuffle_mode", ret, BT_ERROR_NONE, + "bt_avrcp_target_notify_shuffle_mode() failed."); + +} + +/** + * @brief Positive test case of bt_avrcp_target_notify_scan_mode() + */ +static void utc_network_bluetooth_avrcp_target_notify_scan_mode_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_avrcp_target_notify_scan_mode(BT_AVRCP_SCAN_MODE_ALL_TRACK); + dts_check_eq("bt_avrcp_target_notify_scan_mode", ret, BT_ERROR_NONE, + "bt_avrcp_target_notify_scan_mode() failed."); +} + +/** + * @brief Positive test case of bt_avrcp_target_notify_player_state() + */ +static void utc_network_bluetooth_avrcp_target_notify_player_state_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_avrcp_target_notify_player_state(BT_AVRCP_PLAYER_STATE_PLAYING); + dts_check_eq("bt_avrcp_target_notify_player_state", ret, BT_ERROR_NONE, + "bt_avrcp_target_notify_player_state() failed."); +} + +/** + * @brief Positive test case of bt_avrcp_target_notify_position() + */ +static void utc_network_bluetooth_avrcp_target_notify_position_p(void) +{ + int ret = BT_ERROR_NONE; + unsigned int position = 0; + ret = bt_avrcp_target_notify_position(position); + dts_check_eq("bt_avrcp_target_notify_position", ret, BT_ERROR_NONE, + "bt_avrcp_target_notify_position() failed."); +} + +/** + * @brief Positive test case of bt_avrcp_target_notify_track() + */ +static void utc_network_bluetooth_avrcp_target_notify_track_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_avrcp_target_notify_track("title", "artist", "album", "genre", 5, 20, 2); + dts_check_eq("bt_avrcp_target_notify_track", ret, BT_ERROR_NONE, + "bt_avrcp_target_notify_track() failed."); +} + +/** + * @brief Positive test case of bt_avrcp_set_equalizer_state_changed_cb() + */ +static void utc_network_bluetooth_avrcp_set_equalizer_state_changed_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_avrcp_set_equalizer_state_changed_cb( + equalizer_state_changed_cb_for_avrcp_p, + NULL); + dts_check_eq("bt_avrcp_set_equalizer_state_changed_cb", ret, BT_ERROR_NONE, + "bt_avrcp_set_equalizer_state_changed_cb() failed."); + +} + +/** + * @brief Positive test case of bt_avrcp_unset_equalizer_state_changed_cb() + */ +static void utc_network_bluetooth_avrcp_unset_equalizer_state_changed_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_avrcp_unset_equalizer_state_changed_cb(); + dts_check_eq("bt_avrcp_unset_equalizer_state_changed_cb", ret, + BT_ERROR_NONE, + "bt_avrcp_unset_equalizer_state_changed_cb() failed."); + +} + +/** + * @brief Positive test case of bt_avrcp_set_repeat_mode_changed_cb() + */ +static void utc_network_bluetooth_avrcp_set_repeat_mode_changed_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_avrcp_set_repeat_mode_changed_cb(repeat_mode_changed_cb_for_avrcp_p, NULL); + dts_check_eq("bt_avrcp_set_repeat_mode_changed_cb", ret, BT_ERROR_NONE, + "bt_avrcp_set_repeat_mode_changed_cb() failed."); + +} + +/** + * @brief Positive test case of bt_avrcp_unset_repeat_mode_changed_cb() + */ +static void utc_network_bluetooth_avrcp_unset_repeat_mode_changed_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_avrcp_unset_repeat_mode_changed_cb(); + dts_check_eq("bt_avrcp_unset_repeat_mode_changed_cb", ret, + BT_ERROR_NONE, + "bt_avrcp_unset_repeat_mode_changed_cb() failed."); + +} + +/** + * @brief Positive test case of bt_avrcp_set_shuffle_mode_changed_cb() + */ +static void utc_network_bluetooth_avrcp_set_shuffle_mode_changed_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_avrcp_set_shuffle_mode_changed_cb( + shuffle_mode_changed_cb_for_avrcp_p, + NULL); + dts_check_eq("bt_avrcp_set_shuffle_mode_changed_cb", ret, BT_ERROR_NONE, + "bt_avrcp_set_shuffle_mode_changed_cb() failed."); +} + +/** + * @brief Positive test case of bt_avrcp_unset_shuffle_mode_changed_cb() + */ +static void utc_network_bluetooth_avrcp_unset_shuffle_mode_changed_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_avrcp_unset_shuffle_mode_changed_cb(); + dts_check_eq("bt_avrcp_unset_shuffle_mode_changed_cb", ret, + BT_ERROR_NONE, + "bt_avrcp_unset_shuffle_mode_changed_cb() failed."); +} + +/** + * @brief Positive test case of bt_avrcp_set_scan_mode_changed_cb() + */ +static void utc_network_bluetooth_avrcp_set_scan_mode_changed_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_avrcp_set_scan_mode_changed_cb(scan_mode_changed_cb_for_avrcp_p, + NULL); + dts_check_eq("bt_avrcp_set_scan_mode_changed_cb", ret, BT_ERROR_NONE, + "bt_avrcp_set_scan_mode_changed_cb() failed."); + +} + +/** + * @brief Positive test case of bt_avrcp_unset_scan_mode_changed_cb() + */ +static void utc_network_bluetooth_avrcp_unset_scan_mode_changed_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_avrcp_unset_scan_mode_changed_cb(); + dts_check_eq("bt_avrcp_unset_scan_mode_changed_cb", ret, BT_ERROR_NONE, + "bt_avrcp_unset_scan_mode_changed_cb() failed."); + +} + diff --git a/TC/testcase/utc_network_bluetooth_common_negative.c b/TC/testcase/utc_network_bluetooth_common_negative.c new file mode 100755 index 0000000..4d2eb6e --- /dev/null +++ b/TC/testcase/utc_network_bluetooth_common_negative.c @@ -0,0 +1,84 @@ +/* + * utc_network_bluetooth_common_negative.c + * + * Created on: 20-Sep-2013 + * Author: mrinal.m + */ + +#include "bluetooth.h" +#include +#include + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static void startup(void); +static void cleanup(void); + +static GMainLoop *mainloop; +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; +void adapter_state_changed_cb_for_common_n(int result, + bt_adapter_state_e adapter_state, + void *user_data); +gboolean timeout_func(gpointer data); + +struct tet_testlist tet_testlist[] = { + {NULL, 0}, +}; + +static void startup(void) +{ + int ret = BT_ERROR_NONE; + int timeout_id = 0; + + /* start of TC */ + mainloop = g_main_loop_new(NULL, FALSE); + + bt_initialize(); + if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_common_n, "startup") != BT_ERROR_NONE) { + tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed"); + } + + tet_printf("bt_adapter_disable() was called."); + ret = bt_adapter_disable(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_adapter_disable() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else if (ret == BT_ERROR_NOT_ENABLED) { + tet_printf("Bluetooth adapter is not enabled."); + } else { + tet_printf("DTS may fail because bt_adapter_disable() failed"); + } + + if (bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE) { + tet_printf("bt_adapter_set_state_changed_cb() failed."); + } + + tet_printf("TC start"); +} + +static void cleanup(void) +{ + /* end of TC */ + bt_deinitialize(); + tet_printf("TC end."); +} + +gboolean timeout_func(gpointer data) +{ + tet_printf("Callback: Timeout."); + g_main_loop_quit((GMainLoop *) data); + return FALSE; +} + +void adapter_state_changed_cb_for_common_n(int result, + bt_adapter_state_e adapter_state, + void *user_data) +{ + +} diff --git a/TC/testcase/utc_network_bluetooth_common_positive.c b/TC/testcase/utc_network_bluetooth_common_positive.c new file mode 100755 index 0000000..bf775cf --- /dev/null +++ b/TC/testcase/utc_network_bluetooth_common_positive.c @@ -0,0 +1,122 @@ +/* + * utc_network_bluetooth_common_positive.c + * + * Created on: 20-Sep-2013 + * Author: mrinal.m + */ + +#include +#include +#include + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static void startup(void); +static void cleanup(void); + +static GMainLoop *mainloop; + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +void adapter_state_changed_cb_for_common_p(int result, + bt_adapter_state_e adapter_state, + void *user_data); +gboolean timeout_func(gpointer data); + +static void utc_network_bluetooth_bt_initialize_p(void); +static void utc_network_bluetooth_bt_deinitialize_p(void); + +struct tet_testlist tet_testlist[] = { + {utc_network_bluetooth_bt_initialize_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_bt_deinitialize_p, POSITIVE_TC_IDX}, + {NULL, 0}, +}; + +static void startup(void) +{ + int ret = BT_ERROR_NONE; + int timeout_id = 0; + + /* start of TC */ + mainloop = g_main_loop_new(NULL, FALSE); + + bt_initialize(); + if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_common_p, "startup") != BT_ERROR_NONE) { + tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed"); + } + + tet_printf("bt_adapter_enable() was called."); + ret = bt_adapter_enable(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_adapter_enable() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else if (ret != BT_ERROR_ALREADY_DONE) { + tet_printf("DTS may fail because bt_adapter_disable() failed"); + } else if (ret == BT_ERROR_NOT_ENABLED) { + tet_printf("Bluetooth adapter is not enabled."); + } else { + tet_printf("DTS may fail because bt_adapter_disable() failed"); + } + + if (bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE) { + tet_printf("bt_adapter_set_state_changed_cb() failed."); + } + + tet_printf("TC start"); +} + +static void cleanup(void) +{ + /* end of TC */ + bt_deinitialize(); + tet_printf("TC end."); +} + +gboolean timeout_func(gpointer data) +{ + tet_printf("Callback: Timeout."); + g_main_loop_quit((GMainLoop *) data); + return FALSE; +} + +void adapter_state_changed_cb_for_common_p(int result, + bt_adapter_state_e adapter_state, + void *user_data) +{ + +} + +/** + * @brief Positive test case of bt_initialize() + */ +static void utc_network_bluetooth_bt_initialize_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_initialize(); + dts_check_eq("bt_initialize", ret, BT_ERROR_NONE, + "bt_initialize() failed."); + +} + +/** + * @brief Positive test case of bt_deinitialize() + */ +static void utc_network_bluetooth_bt_deinitialize_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_deinitialize(); + dts_check_eq("bt_deinitialize", ret, BT_ERROR_NONE, + "bt_deinitialize() failed."); + +} + + + diff --git a/TC/testcase/utc_network_bluetooth_device_discovery_negative.c b/TC/testcase/utc_network_bluetooth_device_discovery_negative.c new file mode 100755 index 0000000..48b22d3 --- /dev/null +++ b/TC/testcase/utc_network_bluetooth_device_discovery_negative.c @@ -0,0 +1,191 @@ +/* + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static GMainLoop *mainloop; +gboolean timeout_func(gpointer data); + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_network_bluetooth_device_discovery_cancel_n(void); +static void utc_network_bluetooth_device_discovery_unset_state_changed_cb_n(void); +static void utc_network_bluetooth_device_discovery_set_state_changed_cb_n(void); +static void utc_network_bluetooth_device_discovery_start_n(void); +static void utc_network_bluetooth_device_discovery_get_status_n(void); + +void adapter_state_changed_cb_for_discovery_n(int result, + bt_adapter_state_e adapter_state, + void *user_data); + +struct tet_testlist tet_testlist[] = { + {utc_network_bluetooth_device_discovery_cancel_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_device_discovery_set_state_changed_cb_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_device_discovery_get_status_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_device_discovery_start_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_device_discovery_unset_state_changed_cb_n, NEGATIVE_TC_IDX}, + {NULL, 0}, +}; + +static void startup(void) +{ + int ret = BT_ERROR_NONE; + int timeout_id = 0; + + /* start of TC */ + mainloop = g_main_loop_new(NULL, FALSE); + + bt_initialize(); + if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_discovery_n, "startup") != BT_ERROR_NONE) { + tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed"); + } + + tet_printf("bt_adapter_disable() was called."); + ret = bt_adapter_disable(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_adapter_disable() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else if (ret == BT_ERROR_NOT_ENABLED) { + tet_printf("Bluetooth adapter is not enabled."); + } else { + tet_printf("DTS may fail because bt_adapter_disable() failed"); + } + + if (bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE) { + tet_printf("bt_adapter_set_state_changed_cb() failed."); + } + + tet_printf("TC start"); +} + +static void cleanup(void) +{ + /* end of TC */ + bt_deinitialize(); + tet_printf("TC end"); +} + +gboolean timeout_func(gpointer data) +{ + tet_printf("Callback: Timeout."); + g_main_loop_quit((GMainLoop *) data); + return FALSE; +} + +/** + * @brief Callback funtions + */ +void adapter_state_changed_cb_for_discovery_n(int result, + bt_adapter_state_e adapter_state, + void *user_data) +{ + tet_printf("Callback: bt_adapter_state_changed_cb was called."); + if (user_data != NULL && !strcmp((char *)user_data, "startup")) { + if (adapter_state == BT_ADAPTER_DISABLED && + result == BT_ERROR_NONE) { + tet_printf("Callback: BT was disabled. DTS will be started."); + } else { + tet_printf("Callback: BT was not disabled. DTS will be started but DTS may fail."); + } + + if (mainloop) { + g_main_loop_quit(mainloop); + } + } +} + +/** + *@brief Negative test case of bt_adapter_stop_device_discovery() + */ +static void utc_network_bluetooth_device_discovery_cancel_n(void) +{ + int ret = bt_adapter_stop_device_discovery(); + + dts_check_eq("bt_adapter_stop_device_discovery", ret, + BT_ERROR_NOT_ENABLED, + "BT_ERROR_NOT_ENABLED must be returned when BT is not enabled"); +} + +/** + *@brief Negative test case of bt_adapter_unset_device_discovery_state_changed_cb() + */ +static void utc_network_bluetooth_device_discovery_unset_state_changed_cb_n(void) +{ + int ret = BT_ERROR_NONE; + + if (bt_deinitialize() != BT_ERROR_NONE) { + dts_fail("bt_adapter_unset_device_discovery_state_changed_cb", + "bt_deinitialize() failed."); + } + ret = bt_adapter_unset_device_discovery_state_changed_cb(); + dts_check_eq("bt_adapter_unset_device_discovery_state_changed_cb", ret, + BT_ERROR_NOT_INITIALIZED, + "BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized."); +} + +/** + *@brief Negative test case of bt_adapter_set_device_discovery_state_changed_cb() + */ +static void utc_network_bluetooth_device_discovery_set_state_changed_cb_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_adapter_set_device_discovery_state_changed_cb(NULL, NULL); + dts_check_eq("bt_adapter_set_device_discovery_state_changed_cb", ret, + BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when callback parameter is NULL"); +} + +/** + *@brief Negative test case of bt_adapter_start_device_discovery() + */ +static void utc_network_bluetooth_device_discovery_start_n(void) +{ + bt_error_e ret = BT_ERROR_NONE; + + ret = bt_adapter_start_device_discovery();; + dts_check_eq("bt_adapter_start_device_discovery", ret, + BT_ERROR_NOT_ENABLED, + "BT_ERROR_NOT_ENABLED must be returned when BT is not enabled"); +} + +/** + *@brief Negative test case of bt_adapter_is_discovering() + */ +static void utc_network_bluetooth_device_discovery_get_status_n(void) +{ + bt_error_e ret = BT_ERROR_NONE; + bool status = false; + + ret = bt_adapter_is_discovering(&status); + dts_check_eq("bt_adapter_is_discovering", ret, BT_ERROR_NOT_ENABLED, + "BT_ERROR_NOT_ENABLED must be returned when BT is not enabled"); +} diff --git a/TC/testcase/utc_network_bluetooth_device_discovery_positive.c b/TC/testcase/utc_network_bluetooth_device_discovery_positive.c new file mode 100755 index 0000000..76caf9f --- /dev/null +++ b/TC/testcase/utc_network_bluetooth_device_discovery_positive.c @@ -0,0 +1,262 @@ +/* + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static GMainLoop *mainloop; +static bool callback_result = false; + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_network_bluetooth_device_discovery_get_status_p(void); +static void utc_network_bluetooth_device_discovery_set_state_changed_cb_p(void); +static void utc_network_bluetooth_device_discovery_start_p(void); +static void utc_network_bluetooth_device_discovery_unset_state_changed_cb_p(void); +static void utc_network_bluetooth_device_discovery_cancel_p(void); + +gboolean timeout_func(gpointer data); +void adapter_state_changed_cb_for_discovery_p(int result, + bt_adapter_state_e adapter_state, + void *user_data); +void device_discovery_state_changed_cb_for_discovery_p(int result, + bt_adapter_device_discovery_state_e discovery_state, + bt_adapter_device_discovery_info_s *discovery_info, + void *user_data); + +struct tet_testlist tet_testlist[] = { + {utc_network_bluetooth_device_discovery_get_status_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_device_discovery_set_state_changed_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_device_discovery_start_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_device_discovery_unset_state_changed_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_device_discovery_cancel_p, POSITIVE_TC_IDX}, + {NULL, 0}, +}; + +static void startup(void) +{ + bt_error_e ret = BT_ERROR_NONE; + int timeout_id = 0; + + /* start of TC */ + mainloop = g_main_loop_new(NULL, FALSE); + + bt_initialize(); + + if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_discovery_p, "startup") != BT_ERROR_NONE) { + tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed."); + } + + ret = bt_adapter_enable(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_adapter_enable() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else if (ret == BT_ERROR_ALREADY_DONE) { + tet_printf("BT was already enabled."); + } else { + tet_printf("DTS may fail because bt_adapter_enable() failed."); + } + + if (bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE) { + tet_printf + ("bt_adapter_unset_device_discovery_state_changed_cb() failed."); + } + + tet_printf("TC start"); +} + +static void cleanup(void) +{ + /* end of TC */ + tet_printf("TC end"); + bt_deinitialize(); +} + +gboolean timeout_func(gpointer data) +{ + tet_printf("Callback: Timeout."); + g_main_loop_quit((GMainLoop *) data); + return FALSE; +} + +/** + * @brief Callback funtions + */ +void adapter_state_changed_cb_for_discovery_p(int result, + bt_adapter_state_e adapter_state, + void *user_data) +{ + if (user_data != NULL && !strcmp((char *)user_data, "startup")) { + if (adapter_state == BT_ADAPTER_ENABLED && + result == BT_ERROR_NONE) { + tet_printf("Callback: BT was enabled."); + } else { + tet_printf("Callback: bt_adapter_state_changed_cb() was \ + called but bt_adapter_enable() failed."); + } + + if (mainloop) { + g_main_loop_quit(mainloop); + } + } +} + +void device_discovery_state_changed_cb_for_discovery_p(int result, + bt_adapter_device_discovery_state_e discovery_state, + bt_adapter_device_discovery_info_s *discovery_info, + void *user_data) +{ + tet_printf("Callback: device_discovery_state_changed_cb_for_discovery_p is called"); + + if (discovery_state == BT_ADAPTER_DEVICE_DISCOVERY_FOUND) { + tet_printf("Callback: Devices were found"); + tet_printf("Callback: Device name is %s", discovery_info->remote_name); + tet_printf("Callback: Service class: %x", discovery_info->bt_class.major_service_class_mask); + if (user_data != NULL && !strcmp((char *)user_data, "start")) { + callback_result = true; + if (mainloop) { + g_main_loop_quit(mainloop); + } + } + } else if (discovery_state == BT_ADAPTER_DEVICE_DISCOVERY_FINISHED) { + tet_printf("Callback: Device discovery finished"); + if (user_data != NULL) { + if (!strcmp((char *)user_data, "start") && callback_result == false) { + tet_printf("You need a discoverable device"); + tet_printf("utc_network_bluetooth_device_discovery_start_p and \ + utc_network_bluetooth_device_discovery_cancel_p will fail"); + } else if (!strcmp((char *)user_data, "cancel")) { + if (result == BT_ERROR_CANCELLED) { + callback_result = true; + } + } + } + if (mainloop) { + g_main_loop_quit(mainloop); + } + } +} + +/** + * @brief Positive test case of bt_adapter_is_discovering() + */ +static void utc_network_bluetooth_device_discovery_get_status_p(void) +{ + bt_error_e ret = BT_ERROR_NONE; + bool status = false; + + ret = bt_adapter_is_discovering(&status); + dts_check_eq("bt_adapter_is_discovering", ret, BT_ERROR_NONE, + "bt_adapter_is_discovering() failed."); +} + +/** + * @brief Positive test case of bt_adapter_set_device_discovery_state_changed_cb() + */ +static void utc_network_bluetooth_device_discovery_set_state_changed_cb_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_adapter_set_device_discovery_state_changed_cb(device_discovery_state_changed_cb_for_discovery_p, "start"); + dts_check_eq("bt_adapter_set_device_discovery_state_changed_cb", ret, + BT_ERROR_NONE, + "bt_adapter_set_device_discovery_state_changed_cb() failed."); +} + +/** + * @brief Positive test case of bt_adapter_start_device_discovery() + */ +static void utc_network_bluetooth_device_discovery_start_p(void) +{ + int ret = BT_ERROR_NONE; + int timeout_id = 0; + + callback_result = false; + + ret = bt_adapter_start_device_discovery(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_adapter_device_discovery_state_changed_cb_for_discovery_p() will be called."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + dts_check_eq("bt_adapter_start_device_discovery", + callback_result, true, + "Callback was called but failed."); + } else { + dts_fail("bt_adapter_start_device_discovery", + "bt_adapter_start_device_discovery() failed."); + } +} + +/** + * @brief Positive test case of bt_adapter_unset_device_discovery_state_changed_cb() + */ +static void utc_network_bluetooth_device_discovery_unset_state_changed_cb_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_adapter_unset_device_discovery_state_changed_cb(); + dts_check_eq("bt_adapter_unset_device_discovery_state_changed_cb", ret, + BT_ERROR_NONE, + "bt_device_discovery_uset_state_changed_cb() failed"); +} + +/** + * @brief Positive test case of bt_adapter_stop_device_discovery() + */ +static void utc_network_bluetooth_device_discovery_cancel_p(void) +{ + int ret = BT_ERROR_NONE; + int timeout_id = 0; + + callback_result = false; + + if (bt_adapter_set_device_discovery_state_changed_cb + (device_discovery_state_changed_cb_for_discovery_p, "cancel") != BT_ERROR_NONE) { + dts_fail("bt_adapter_stop_device_discovery", + "bt_adapter_set_device_discovery_state_changed_cb() failed"); + } + + ret = bt_adapter_stop_device_discovery(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_adapter_device_discovery_state_changed_cb_for_discovery_p() will be called"); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + bt_adapter_unset_device_discovery_state_changed_cb(); + dts_check_eq("bt_adapter_stop_device_discovery", callback_result, true, + "Callback was called but failed"); + } else { + dts_fail("bt_adapter_stop_device_discovery", + "bt_adapter_stop_device_discovery() failed"); + } + +} + diff --git a/TC/testcase/utc_network_bluetooth_device_negative.c b/TC/testcase/utc_network_bluetooth_device_negative.c new file mode 100755 index 0000000..9915c99 --- /dev/null +++ b/TC/testcase/utc_network_bluetooth_device_negative.c @@ -0,0 +1,300 @@ +/* + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static void startup(void); +static void cleanup(void); + +static GMainLoop *mainloop; +gboolean timeout_func(gpointer data); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_network_bluetooth_device_set_bonded_cb_n(void); +static void utc_network_bluetooth_device_set_unbonded_cb_n(void); +static void utc_network_bluetooth_device_set_authorization_state_changed_cb_n(void); +static void utc_network_bluetooth_device_cancel_bonding_n(void); +static void utc_network_bluetooth_device_bond_n(void); +static void utc_network_bluetooth_device_foreach_bonded_device_n(void); +static void utc_network_bluetooth_device_set_alias_n(void); +static void utc_network_bluetooth_device_set_authorization_n(void); +static void utc_network_bluetooth_device_unbond_n(void); +static void utc_network_bluetooth_device_unset_bonded_cb_n(void); +static void utc_network_bluetooth_device_unset_unbonded_cb_n(void); +static void utc_network_bluetooth_device_unset_authorization_state_changed_cb_n(void); +static void utc_network_bluetooth_device_get_rssi_strength_n(void); +static void utc_network_bluetooth_device_disable_rssi_monitor_n(void); +static void utc_network_bluetooth_device_enable_rssi_monitor_n(void); +static void utc_network_bluetooth_device_unset_rssi_alert_cb_n(void); + +void adapter_state_changed_cb_for_device_negative(int result, + bt_adapter_state_e adapter_state, + void *user_data); +gboolean timeout_func(gpointer data); + +struct tet_testlist tet_testlist[] = { + {utc_network_bluetooth_device_set_bonded_cb_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_device_set_unbonded_cb_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_device_set_authorization_state_changed_cb_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_device_bond_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_device_cancel_bonding_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_device_unbond_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_device_foreach_bonded_device_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_device_set_alias_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_device_set_authorization_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_device_get_rssi_strength_n, NEGATIVE_TC_IDX }, + {utc_network_bluetooth_device_enable_rssi_monitor_n, NEGATIVE_TC_IDX }, + {utc_network_bluetooth_device_disable_rssi_monitor_n, NEGATIVE_TC_IDX }, + {utc_network_bluetooth_device_unset_rssi_alert_cb_n, NEGATIVE_TC_IDX }, + {utc_network_bluetooth_device_unset_bonded_cb_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_device_unset_unbonded_cb_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_device_unset_authorization_state_changed_cb_n, NEGATIVE_TC_IDX}, + {NULL, 0}, +}; + +gboolean timeout_func(gpointer data) +{ + tet_printf("Callback: Timeout."); + g_main_loop_quit((GMainLoop *) data); + return FALSE; +} + +static void startup(void) +{ + int ret = BT_ERROR_NONE; + int timeout_id = 0; + + /* start of TC */ + mainloop = g_main_loop_new(NULL, FALSE); + + bt_initialize(); + if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_device_negative, "startup") != BT_ERROR_NONE) { + tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed"); + } + + tet_printf("bt_adapter_disable() was called."); + ret = bt_adapter_disable(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_adapter_disable() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else if (ret == BT_ERROR_NOT_ENABLED) { + tet_printf("Bluetooth adapter is not enabled."); + } else { + tet_printf("DTS may fail because bt_adapter_disable() failed"); + } + + if (bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE) { + tet_printf("bt_adapter_set_state_changed_cb() failed."); + } + + tet_printf("TC start"); +} + +static void cleanup(void) +{ + /* end of TC */ + bt_deinitialize(); + tet_printf("TC end."); +} + +/** + * @brief Callback funtions + */ +void adapter_state_changed_cb_for_device_negative(int result, + bt_adapter_state_e adapter_state, + void *user_data) +{ + tet_printf("Callback: bt_adapter_state_changed_cb was called."); + if ((user_data != NULL) && !strcmp((char *)user_data, "startup")) { + if (adapter_state == BT_ADAPTER_DISABLED && result == BT_ERROR_NONE) { + tet_printf("Callback: BT was disabled. DTS will be started."); + } else { + tet_printf("Callback: BT was not disabled. DTS will be started but DTS may fail."); + } + + if (mainloop) { + g_main_loop_quit(mainloop); + } + } +} + +/** + * @brief Negative test case of bt_device_set_bond_created_cb() + */ +static void utc_network_bluetooth_device_set_bonded_cb_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_device_set_bond_created_cb(NULL, NULL); + dts_check_eq("bt_device_set_bond_created_cb", ret, + BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when callback parameter is NULL"); +} + +/** + * @brief Negative test case of bt_device_set_bond_destroyed_cb() + */ +static void utc_network_bluetooth_device_set_unbonded_cb_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_device_set_bond_destroyed_cb(NULL, NULL); + dts_check_eq("bt_device_set_bond_destroyed_cb", ret, + BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when callback parameter is NULL"); +} + +/** + * @brief Negative test case of bt_device_set_authorization_changed_cb() + */ +static void +utc_network_bluetooth_device_set_authorization_state_changed_cb_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_device_set_authorization_changed_cb(NULL, NULL); + dts_check_eq("bt_device_set_authorization_changed_cb", ret, + BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when callback parameter is NULL"); +} + +/** + * @brief Negative test case of bt_device_unset_bond_created_cb() + */ +static void utc_network_bluetooth_device_unset_bonded_cb_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_deinitialize(); + + ret = bt_device_unset_bond_created_cb(); + dts_check_eq("bt_device_unset_bond_created_cb", ret, + BT_ERROR_NOT_INITIALIZED, + "BT_ERROR_NOT_INITIALIZED must be returned when BT is not initialized."); +} + + /** + * @brief Negative test case of bt_device_unset_bond_destroyed_cb() + */ +static void utc_network_bluetooth_device_unset_unbonded_cb_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_device_unset_bond_destroyed_cb(); + dts_check_eq("bt_device_unset_bond_destroyed_cb", ret, + BT_ERROR_NOT_INITIALIZED, + "BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized."); +} + +/** + * @brief Negative test case of bt_device_unset_authorization_changed_cb() + */ +static void +utc_network_bluetooth_device_unset_authorization_state_changed_cb_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_device_unset_authorization_changed_cb(); + dts_check_eq("bt_device_unset_authorization_changed_cb", ret, + BT_ERROR_NOT_INITIALIZED, + "BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized."); +} + + /** + * @brief Negative test case of bt_device_create_bond() + */ +static void utc_network_bluetooth_device_bond_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_device_create_bond(NULL); + dts_check_eq("bt_device_create_bond", ret, BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized."); +} + + /** + * @brief Negative test case of bt_device_cancel_bonding() + */ +static void utc_network_bluetooth_device_cancel_bonding_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_device_cancel_bonding(); + dts_check_eq("bt_device_cancel_bonding", ret, BT_ERROR_NOT_ENABLED, + "BT_ERROR_NOT_ENABLED must be returned when BT is not enabled"); +} + +/** + * @brief Negative test case of bt_device_destroy_bond() + */ +static void utc_network_bluetooth_device_unbond_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_device_destroy_bond(NULL); + dts_check_eq("bt_device_destroy_bond", ret, BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL"); +} + +/** + * @brief Negative test case of bt_adapter_foreach_bonded_device() + */ +static void utc_network_bluetooth_device_foreach_bonded_device_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_adapter_foreach_bonded_device(NULL, NULL); + dts_check_eq("bt_adapter_foreach_bonded_device", ret, BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL"); +} + +/** + * @brief Negative test case of bt_device_set_alias() + */ +static void utc_network_bluetooth_device_set_alias_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_device_set_alias(NULL, "dts_alias"); + dts_check_eq("bt_device_set_alias", ret, BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when address parameter is NULL"); +} + +/** + * @brief Negative test case of bt_device_set_authorization() + */ +static void utc_network_bluetooth_device_set_authorization_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_device_set_authorization(NULL, BT_DEVICE_AUTHORIZED); + dts_check_eq("bt_device_set_authorization", ret, + BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when address parameter is NULL"); +} diff --git a/TC/testcase/utc_network_bluetooth_device_positive.c b/TC/testcase/utc_network_bluetooth_device_positive.c new file mode 100755 index 0000000..1ee789e --- /dev/null +++ b/TC/testcase/utc_network_bluetooth_device_positive.c @@ -0,0 +1,694 @@ +/* + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include + +#define CONFIG_FILE_PATH "/opt/home/capi-network-bluetooth/tetware.conf" + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static void startup(void); +static void cleanup(void); + +static GMainLoop *mainloop; +static bool callback_result = false; +char target_name[128] = "dts_test"; +char *target_address; +bt_device_info_s *device_info = NULL; +bool discovery_result = false; + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_network_bluetooth_device_set_bonded_cb_p(void); +static void utc_network_bluetooth_device_set_unbonded_cb_p(void); +static void utc_network_bluetooth_device_set_authorization_state_changed_cb_p(void); +static void utc_network_bluetooth_device_cancel_bonding_p(void); +static void utc_network_bluetooth_device_bond_p(void); +static void utc_network_bluetooth_device_foreach_bonded_device_p(void); +static void utc_network_bluetooth_device_set_alias_p(void); +static void utc_network_bluetooth_device_set_authorization_p(void); +static void utc_network_bluetooth_device_unbond_p(void); +static void utc_network_bluetooth_device_unset_bonded_cb_p(void); +static void utc_network_bluetooth_device_unset_unbonded_cb_p(void); +static void utc_network_bluetooth_device_unset_authorization_state_changed_cb_p(void); +static void utc_network_bluetooth_device_get_rssi_strength_p(void); +static void utc_network_bluetooth_device_disable_rssi_monitor_p(void); +static void utc_network_bluetooth_device_enable_rssi_monitor_p(void); +static void utc_network_bluetooth_device_unset_rssi_alert_cb_p(void); + +gboolean timeout_func(gpointer data); +void adapter_state_changed_cb_for_device_p(int result, + bt_adapter_state_e adapter_state, + void *user_data); +void device_discovery_state_changed_cb_for_device_p(int result, + bt_adapter_device_discovery_state_e discovery_state, + bt_adapter_device_discovery_info_s *discovery_info, + void *user_data); +void device_bonded_cb(int result, bt_device_info_s *device_info, + void *user_data); +void device_unbonded_cb(int result, char *remote_address, void *user_data); +void device_authorization_state_changed_cb(bt_device_authorization_e authorization_state, \ + char *remote_address, void *user_data); +bool bonded_device_cb_for_device_p(bt_device_info_s *dev_info, + void *user_data); +void device_get_rssi_strength_cb(char *bt_address, + bt_device_connection_link_type_e link_type, + int rssi_dbm, void *user_data); +static void device_rssi_enabled_cb(const char *address, + bt_device_connection_link_type_e link_type, + int rssi_enabled, void *user_data); +static void device_rssi_alert_cb(char *bt_address, + bt_device_connection_link_type_e link_type, + int rssi_alert_type, int rssi_alert_dbm, void *user_data); + +struct tet_testlist tet_testlist[] = { + { utc_network_bluetooth_device_set_bonded_cb_p, POSITIVE_TC_IDX }, + { utc_network_bluetooth_device_bond_p, POSITIVE_TC_IDX }, + { utc_network_bluetooth_device_foreach_bonded_device_p, POSITIVE_TC_IDX }, + { utc_network_bluetooth_device_set_alias_p, POSITIVE_TC_IDX }, + { utc_network_bluetooth_device_set_authorization_state_changed_cb_p, POSITIVE_TC_IDX }, + { utc_network_bluetooth_device_set_authorization_p, POSITIVE_TC_IDX }, + { utc_network_bluetooth_device_unset_bonded_cb_p, POSITIVE_TC_IDX }, + { utc_network_bluetooth_device_unset_authorization_state_changed_cb_p, POSITIVE_TC_IDX }, + { utc_network_bluetooth_device_get_rssi_strength_p, POSITIVE_TC_IDX }, + { utc_network_bluetooth_device_enable_rssi_monitor_p, POSITIVE_TC_IDX }, + { utc_network_bluetooth_device_disable_rssi_monitor_p, POSITIVE_TC_IDX }, + { utc_network_bluetooth_device_unset_rssi_alert_cb_p, POSITIVE_TC_IDX }, + { utc_network_bluetooth_device_set_unbonded_cb_p, POSITIVE_TC_IDX }, + { utc_network_bluetooth_device_cancel_bonding_p, POSITIVE_TC_IDX }, + { utc_network_bluetooth_device_unbond_p, POSITIVE_TC_IDX }, + { utc_network_bluetooth_device_unset_unbonded_cb_p, POSITIVE_TC_IDX }, + { NULL, 0 }, +}; + +int get_value_from_file(void) +{ + FILE *fp; + char *token; + char buf[100]; + + fp = fopen(CONFIG_FILE_PATH, "r"); + if (fp == NULL) { + tet_printf("Default configuration is used\n"); + return -1; + } + while (fgets(buf, sizeof(buf), fp)) { + if (buf[0] == '#' || buf[0] == '\n') + continue; + + token = strrchr(buf, '\n'); + if (token == NULL) { + tet_printf("g_conf is too long\n"); + break; + } + *token = '\0'; + + token = strtok(buf, "="); + if (token == NULL) { + continue; + } + if (strcasecmp(token, "BT_ADDR_MOBILE") == 0) { + token = strtok(NULL, "="); + target_address = strdup(token); + fclose(fp); + return 0; + } + } + return -1; +} + +static void startup(void) +{ + bt_error_e ret = BT_ERROR_NONE; + int timeout_id = 0; + + if(get_value_from_file() == -1) { + tet_printf("Failed to read."); + } + + /* start of TC */ + callback_result = false; + discovery_result = false; + mainloop = g_main_loop_new(NULL, FALSE); + + bt_initialize(); + + if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_device_p, "startup") != BT_ERROR_NONE) { + tet_printf("bt_adapter_set_state_changed_cb() failed."); + } + + if (bt_adapter_set_device_discovery_state_changed_cb(device_discovery_state_changed_cb_for_device_p, "startup") != BT_ERROR_NONE) { + tet_printf("bt_adapter_set_device_discovery_state_changed_cb() failed."); + } + + ret = bt_adapter_enable(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_adapter_enable() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + + tet_printf("BT was enabled. Device discovery will be started"); + if (bt_adapter_start_device_discovery() == BT_ERROR_NONE) { + tet_printf("bt_adapter_start_device_discovery() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else { + tet_printf("bt_adapter_start_device_discovery() failed."); + } + } else if (ret == BT_ERROR_ALREADY_DONE) { + tet_printf("BT was already enabled. Device discovery will be started"); + if (bt_adapter_start_device_discovery() == BT_ERROR_NONE) { + tet_printf("bt_adapter_start_device_discovery() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else { + tet_printf("bt_adapter_start_device_discovery() failed."); + } + } else { + tet_printf("DTS may fail because bt_adapter_enable() failed."); + } + + if (bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE) { + tet_printf("bt_adapter_unset_state_changed_cb() failed."); + } + + if (bt_adapter_unset_device_discovery_state_changed_cb() != + BT_ERROR_NONE) { + tet_printf("bt_adapter_unset_device_discovery_state_changed_cb() failed."); + } + + tet_printf("TC start."); +} + +static void cleanup(void) +{ + /* end of TC */ + if (device_info != NULL) + free(device_info); + + bt_deinitialize(); + tet_printf("TC end"); +} + +gboolean timeout_func(gpointer data) +{ + tet_printf("[%s] Callback: Timeout.", __FUNCTION__); + g_main_loop_quit((GMainLoop *) data); + return FALSE; +} + +void adapter_state_changed_cb_for_device_p(int result, + bt_adapter_state_e adapter_state, + void *user_data) +{ + tet_printf("Callback: bt_adapter_state_changed_cb() was called"); + if (user_data != NULL && !strcmp((char *)user_data, "startup")) { + if (adapter_state == BT_ADAPTER_ENABLED && result == BT_ERROR_NONE) { + tet_printf("Callback: BT was enabled."); + } else { + tet_printf("Callback: BT was not enabled. DTS will be started but DTS may fail."); + } + + if (mainloop) { + g_main_loop_quit(mainloop); + } + } +} + +void device_discovery_state_changed_cb_for_device_p(int result, + bt_adapter_device_discovery_state_e discovery_state, + bt_adapter_device_discovery_info_s *discovery_info, + void *user_data) +{ + tet_printf("Callback: bt_adapter_device_discovery_state_changed_cb() was called"); + if (user_data != NULL && !strcmp((char *)user_data, "startup")) { + if (discovery_state == BT_ADAPTER_DEVICE_DISCOVERY_FINISHED) { + tet_printf("Callback: Device discovery finished. DTS will be started."); + if (mainloop) { + g_main_loop_quit(mainloop); + } + } else if (discovery_state == BT_ADAPTER_DEVICE_DISCOVERY_FOUND) { + tet_printf("Callback: Devices were founded (%s)", discovery_info->remote_name); + if (discovery_info->remote_name != NULL && !strcmp(discovery_info->remote_name, target_name)) { + discovery_result = true; + tet_printf("Callback: dts_test device was found."); + strncpy(target_address, discovery_info->remote_address, 18); + tet_printf("Callback: device address: [%s]", discovery_info->remote_address); + if (bt_adapter_stop_device_discovery() == BT_ERROR_NONE) { + tet_printf("Callback: Device discovery will be stopped"); + } + } + } + } +} + +void device_bonded_cb(int result, bt_device_info_s * device_info, + void *user_data) +{ + int i = 0; + + tet_printf("Callback: bt_device_bond_created_cb() was called."); + if (result == BT_ERROR_TIMED_OUT) + tet_printf("result is BT_ERROR_TIMEOUT"); + else if (result == BT_ERROR_CANCELLED) + tet_printf("result is BT_ERROR_CANCELLED"); + else if (result == BT_ERROR_AUTH_FAILED) + tet_printf("result is BT_ERROR_AUTH_FAILED"); + else if (result == BT_ERROR_OPERATION_FAILED) + tet_printf("result is BT_ERROR_OPERATION_FAILED"); + else if (result == BT_ERROR_AUTH_REJECTED) + tet_printf("result is BT_ERROR_AUTH_REJECTED"); + else if (result == BT_ERROR_REMOTE_DEVICE_NOT_FOUND) + tet_printf("result is BT_ERROR_REMOTE_DEVICE_NOT_FOUND"); + else if (result == BT_ERROR_NONE) + tet_printf("result is BT_ERROR_NONE"); + else + tet_printf("result is unknown: %s", + _bt_convert_error_to_string(result)); + + /* in case of bt_device_cancel_bonding() */ + if (user_data != NULL && !strcmp((char *)user_data, "cancel")) { + if (result == BT_ERROR_CANCELLED) { + tet_printf("Callback: Cancellation of bonding succeeded"); + callback_result = true; + } else { + tet_printf("Callback: Cancellation of bonding failed"); + } + } /* in case of bt_device_create_bond() */ + else if (user_data != NULL && !strcmp((char *)user_data, "bond")) { + if (device_info == NULL) { + tet_printf("Callback data is NULL"); + + if (result == BT_ERROR_CANCELLED) + tet_printf("No user input in the peer device"); + + if (mainloop) + g_main_loop_quit(mainloop); + + return; + } + + if (device_info->remote_name != NULL && !strcmp(device_info->remote_name, target_name)) { + if (result == BT_ERROR_NONE) { + tet_printf("Callback: Bonding succeeded"); + tet_printf("Callback: serivce count : %d", device_info->service_count); + callback_result = true; + for (i = 0; i < device_info->service_count; i++) { + tet_printf("Callback: service list[%d] - %s", i + 1, device_info->service_uuid[i]); + } + } else { + tet_printf("Callback: Bonding failed"); + } + } + } + + if (mainloop) { + g_main_loop_quit(mainloop); + } +} + +void device_unbonded_cb(int result, char *remote_address, void *user_data) +{ + tet_printf("Callback: bt_device_bond_destroyed_cb() was called."); + tet_printf("Callback: target address"); + if (target_address != NULL) { + tet_printf("device address: %s", target_address); + } else + tet_printf("Callback: target address is NULL!"); + + tet_printf("Callback: address of unbonded device"); + if (remote_address != NULL) { + tet_printf("device address: %s", remote_address); + } else + tet_printf("Callback: address of unbonded device is NULL!"); + + if ((remote_address != NULL) && \ + !strcmp(remote_address, target_address)) { + if (result == BT_ERROR_NONE) { + tet_printf("Callback: Unbonding succeeded"); + callback_result = true; + } else { + tet_printf("Callback: Unbonding failed"); + } + } + + if (mainloop) { + g_main_loop_quit(mainloop); + } + +} + +void device_authorization_state_changed_cb(bt_device_authorization_e authorization_state, \ + char *address, void *user_data) +{ + if (authorization_state == BT_DEVICE_AUTHORIZED) { + if (address != NULL && !strcmp(address, target_address)) { + callback_result = true; + if (mainloop) { + g_main_loop_quit(mainloop); + } + } + } else { + if (address != NULL && !strcmp(address, target_address)) { + callback_result = true; + if (mainloop) { + g_main_loop_quit(mainloop); + } + } + } +} + +void device_get_rssi_strength_cb(char *bt_address, + bt_device_connection_link_type_e link_type, + int rssi_dbm, void *user_data) +{ + tet_printf("Callback:Rssi_strength_cb is called."); + tet_printf("RSSI Strength: [Address %s][Link Type %d][RSSI dBm %d]", + bt_address, link_type, rssi_dbm); +} + +static void device_rssi_enabled_cb(const char *address, + bt_device_connection_link_type_e link_type, + int rssi_enabled, void *user_data) +{ + tet_printf("Callback:Rssi_enabled_cb is called."); + tet_printf("RSSI Enabled: %s %d %d", address, link_type, rssi_enabled); +} + +static void device_rssi_alert_cb(char *bt_address, + bt_device_connection_link_type_e link_type, + int rssi_alert_type, int rssi_alert_dbm, void *user_data) +{ + tet_printf("Callback:rssi_alert_cb is called."); + tet_printf("RSSI Alert: [Address:%s LinkType:%d][RSSI Alert Type:%d dBm:%d]", + bt_address, link_type, rssi_alert_type, rssi_alert_dbm); +} + +/** + * @brief Positive test case of bt_device_set_bond_created_cb() + */ +static void utc_network_bluetooth_device_set_bonded_cb_p(void) +{ + int ret = BT_ERROR_NONE; + + /* Normal operation test */ + ret = bt_device_set_bond_created_cb(device_bonded_cb, "cancel"); + dts_check_eq("bt_device_set_bond_created_cb", ret, BT_ERROR_NONE, + "bt_device_set_bond_created_cb() failed"); +} + +/** + * @brief Positive test case of bt_device_set_bond_destroyed_cb() + */ +static void utc_network_bluetooth_device_set_unbonded_cb_p(void) +{ + int ret = BT_ERROR_NONE; + + /* Normal operation test */ + ret = bt_device_set_bond_destroyed_cb(device_unbonded_cb, NULL); + dts_check_eq("bt_device_set_bond_destroyed_cb", ret, BT_ERROR_NONE, + "bt_device_set_bond_destroyed_cb() failed"); +} + +/** + * @brief Positive test case of bt_device_set_authorization_changed_cb() + */ +static void +utc_network_bluetooth_device_set_authorization_state_changed_cb_p(void) +{ + int ret = BT_ERROR_NONE; + + /* Normal operation test */ + ret = bt_device_set_authorization_changed_cb(device_authorization_state_changed_cb, NULL); + dts_check_eq("bt_device_set_authorization_changed_cb", ret, + BT_ERROR_NONE, + "bt_device_set_authorization_changed_cb() failed"); +} + +/** + * @brief Positive test case of bt_device_cancel_bonding() + */ +static void utc_network_bluetooth_device_cancel_bonding_p(void) +{ + int ret = BT_ERROR_NONE; + callback_result = false; + int timeout_id = 0; + + if (bt_device_set_bond_created_cb(device_bonded_cb, "cancel") != + BT_ERROR_NONE) { + dts_fail("bt_device_cancel_bonding", + "bt_device_set_bond_created_cb() failed"); + } + + /* bond device */ + ret = bt_device_create_bond(target_address); + if (ret != BT_ERROR_NONE) { + dts_fail("bt_device_cancel_bonding", + "bt_device_create_bond failed"); + } + tet_printf("bt_device_create_bond() was called"); + + /* cancel bonding */ + ret = bt_device_cancel_bonding(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_device_cancel_bonding() will be called"); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + bt_device_unset_bond_created_cb(); + dts_check_eq("bt_device_cancel_bonding", callback_result, true, + "Failed"); + } else { + bt_device_unset_bond_created_cb(); + dts_fail("bt_device_cancel_bonding", + "bt_device_cancel_bonding() failed"); + } +} + +/** + * @brief Positive test case of bt_device_unset_bond_created_cb() + */ +static void utc_network_bluetooth_device_unset_bonded_cb_p(void) +{ + int ret = BT_ERROR_NONE; + + /* Normal operation test */ + ret = bt_device_unset_bond_created_cb(); + dts_check_eq("bt_device_unset_bond_created_cb", ret, BT_ERROR_NONE, + "bt_device_unset_bond_created_cb() failed"); +} + +/** + * @brief Positive test case of bt_device_create_bond() + */ +static void utc_network_bluetooth_device_bond_p(void) +{ + int ret = BT_ERROR_NONE; + int timeout_id = 0; + + callback_result = false; + + /* bond device */ + ret = bt_device_set_bond_created_cb(device_bonded_cb, "bond"); + if (ret != BT_ERROR_NONE) { + tet_printf("bt_device_set_bond_created_cb was called"); + } + + ret = bt_device_create_bond(target_address); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_device_bond_created_cb() will be called"); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + bt_device_unset_bond_created_cb(); + dts_check_eq("bt_device_create_bond", ret, BT_ERROR_NONE, + "bt_device_create_bond() failed."); + } else { + bt_device_unset_bond_created_cb(); + dts_fail("bt_device_create_bond", + "bt_device_create_bond() failed"); + } +} + + +bool bonded_device_cb_for_device_p(bt_device_info_s *dev_info, void *user_data) +{ + int i = 0; + device_info = (bt_device_info_s *) malloc(sizeof(bt_device_info_s)); + if (device_info == NULL) { + tet_printf("Callback: Memory allocation failed"); + } else if (dev_info != NULL) { + device_info->remote_address = strdup(dev_info->remote_address); + tet_printf("device address : %s", device_info->remote_address); + device_info->remote_name = strdup(dev_info->remote_name); + tet_printf("device name : %s", device_info->remote_name); + device_info->bt_class.major_device_class = dev_info->bt_class.major_device_class; + tet_printf("major clasee : %2.2X", device_info->bt_class.major_device_class); + device_info->bt_class.minor_device_class = dev_info->bt_class.minor_device_class; + tet_printf("minor clasee : %2.2X", device_info->bt_class.minor_device_class); + device_info->bt_class.major_service_class_mask = dev_info->bt_class.major_service_class_mask; + tet_printf("service clasee : %2.2X", device_info->bt_class.major_service_class_mask); + device_info->service_count = dev_info->service_count; + tet_printf("service count : %d", device_info->service_count); + if (device_info->service_count > 0) { + device_info->service_uuid = (char **)malloc(sizeof(char *) * device_info->service_count); + if (device_info->service_uuid == NULL) { + tet_printf("Failed to allocate memory"); + } else { + if (dev_info->service_uuid == NULL) { + tet_printf("service_list is NULL"); + } else { + tet_printf("Copy service list"); + for (i = 0; i < device_info->service_count; i++) { + device_info->service_uuid[i] = strdup(dev_info->service_uuid[i]); + tet_printf("Callback: service list[%d] - %s", i + 1, device_info->service_uuid[i]); + } + } + } + } else + device_info->service_uuid = NULL; + + device_info->is_bonded = dev_info->is_bonded; + tet_printf("is_bonded : %d", device_info->is_bonded); + device_info->is_connected = dev_info->is_connected; + tet_printf("is_connected : %d", device_info->is_connected); + tet_printf("Callback: device_info was selected."); + } + + return false; +} + +/** + * @brief Positive test case of bt_adapter_foreach_bonded_device() + */ +static void utc_network_bluetooth_device_foreach_bonded_device_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_adapter_foreach_bonded_device(bonded_device_cb_for_device_p, NULL); + if (ret == BT_ERROR_NONE) { + dts_pass("bt_adapter_foreach_bonded_device", + "bt_adapter_foreach_bonded_device pass"); + } else { + dts_fail("bt_adapter_foreach_bonded_device", + "bt_adapter_foreach_bonded_device() failed"); + } +} + +/** + * @brief Positive test case of bt_device_set_alias() + */ +static void utc_network_bluetooth_device_set_alias_p(void) +{ + int ret = BT_ERROR_NONE; + + if (device_info == NULL) { + tet_printf("No device to alias"); + dts_fail("bt_device_set_alias", "bt_device_set_alias() failed"); + return; + } + + ret = bt_device_set_alias(device_info->remote_address, "dts_alias"); + dts_check_eq("bt_device_set_alias", ret, BT_ERROR_NONE, + "bt_device_set_alias() failed"); +} + +/** + * @brief Positive test case of bt_device_set_authorization() + */ +static void utc_network_bluetooth_device_set_authorization_p(void) +{ + int ret = BT_ERROR_NONE; + int timeout_id = 0; + + callback_result = false; + + ret = bt_device_set_authorization(target_address, BT_DEVICE_AUTHORIZED); + if (ret == BT_ERROR_NONE) { + tet_printf("device_authorization_state_changed_cb will be called"); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + dts_check_eq("bt_device_set_authorization", ret, BT_ERROR_NONE, + "bt_device_set_authorization() failed."); + callback_result = false; + } else { + dts_fail("bt_device_set_authorization", + "bt_device_set_authorization() failed"); + } +} + +/** + * @brief Positive test case of bt_device_destroy_bond() + */ +static void utc_network_bluetooth_device_unbond_p(void) +{ + int ret = BT_ERROR_NONE; + int timeout_id = 0; + callback_result = false; + + tet_printf("bt_device_destroy_bond() will start"); + ret = bt_device_destroy_bond(target_address); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_device_unbond_cb() will be called"); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + dts_check_eq("bt_device_destroy_bond", ret, BT_ERROR_NONE, + "bt_device_destroy_bond() failed."); + } else { + dts_fail("bt_device_destroy_bond", + "bt_device_destroy_bond() failed"); + } +} + +/** + * @brief Positive test case of bt_device_unset_bond_destroyed_cb() + */ +static void utc_network_bluetooth_device_unset_unbonded_cb_p(void) +{ + int ret = BT_ERROR_NONE; + + /* Normal operation test */ + ret = bt_device_unset_bond_destroyed_cb(); + dts_check_eq("bt_device_unset_bond_destroyed_cb", ret, BT_ERROR_NONE, + "bt_device_unset_bond_destroyed_cb() failed"); +} + +/** + * @brief Positive test case of bt_device_unset_authorization_changed_cb() + */ +static void utc_network_bluetooth_device_unset_authorization_state_changed_cb_p(void) +{ + int ret = BT_ERROR_NONE; + + /* Normal operation test */ + ret = bt_device_unset_authorization_changed_cb(); + dts_check_eq("bt_device_unset_authorization_changed_cb", ret, + BT_ERROR_NONE, + "bt_device_unset_authorization_changed_cb() failed"); +} diff --git a/TC/testcase/utc_network_bluetooth_gatt_negative.c b/TC/testcase/utc_network_bluetooth_gatt_negative.c new file mode 100755 index 0000000..e15467d --- /dev/null +++ b/TC/testcase/utc_network_bluetooth_gatt_negative.c @@ -0,0 +1,298 @@ +/* + * utc_network_bluetooth_gatt_negative.c + * + * Created on: 23-Sep-2013 + * Author: shagun.garg + */ + +#include +#include +#include +#include +#include + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static void startup(void); +static void cleanup(void); + +static GMainLoop *mainloop; + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_network_bluetooth_gatt_foreach_primary_services_n(void); +static void utc_network_bluetooth_gatt_discover_characteristics_n(void); +static void utc_network_bluetooth_gatt_get_service_uuid_n(void); +static void utc_network_bluetooth_gatt_foreach_included_services_n(void); +static void utc_network_bluetooth_gatt_set_characteristic_changed_cb_n(void); +static void utc_network_bluetooth_gatt_unset_characteristic_changed_cb_n(void); +static void utc_network_bluetooth_gatt_get_characteristic_declaration_n(void); +static void utc_network_bluetooth_gatt_set_characteristic_value_n(void); +static void utc_network_bluetooth_gatt_clone_attribute_handle_n(void); +static void utc_network_bluetooth_gatt_destroy_attribute_handle_n(void); +static void utc_network_bluetooth_gatt_connect_n(void); +static void utc_network_bluetooth_gatt_disconnect_n(void); +static void utc_network_bluetooth_set_gatt_connection_state_changed_cb_n(void); +static void utc_network_bluetooth_unset_gatt_connection_state_changed_cb_n(void); + +void adapter_state_changed_cb_for_gatt_n(int result, + bt_adapter_state_e adapter_state, void *user_data); +gboolean timeout_func(gpointer data); + +struct tet_testlist tet_testlist[] = { + {utc_network_bluetooth_gatt_foreach_primary_services_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_gatt_discover_characteristics_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_gatt_get_service_uuid_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_gatt_foreach_included_services_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_gatt_set_characteristic_changed_cb_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_set_gatt_connection_state_changed_cb_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_gatt_connect_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_gatt_disconnect_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_gatt_get_characteristic_declaration_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_gatt_set_characteristic_value_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_gatt_clone_attribute_handle_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_gatt_destroy_attribute_handle_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_unset_gatt_connection_state_changed_cb_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_gatt_unset_characteristic_changed_cb_n, NEGATIVE_TC_IDX}, + {NULL, 0}, +}; + +static void startup(void) +{ + int ret = BT_ERROR_NONE; + int timeout_id = 0; + + /* start of TC */ + mainloop = g_main_loop_new(NULL, FALSE); + + bt_initialize(); + if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_gatt_n, "startup") != BT_ERROR_NONE) { + tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed"); + } + + tet_printf("bt_adapter_disable() was called."); + ret = bt_adapter_disable(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_adapter_disable() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else if (ret == BT_ERROR_NOT_ENABLED) { + tet_printf("Bluetooth adapter is not enabled."); + } else { + tet_printf("DTS may fail because bt_adapter_disable() failed"); + } + + if (bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE) { + tet_printf("bt_adapter_set_state_changed_cb() failed."); + } + + tet_printf("TC start"); +} + +static void cleanup(void) +{ + /* end of TC */ + bt_deinitialize(); + tet_printf("TC end."); +} + +gboolean timeout_func(gpointer data) +{ + tet_printf("Callback: Timeout."); + g_main_loop_quit((GMainLoop *) data); + return FALSE; +} + +/** + * @brief Callback funtions + */ +void adapter_state_changed_cb_for_gatt_n(int result, + bt_adapter_state_e adapter_state, void *user_data) +{ + tet_printf("Callback: bt_adapter_state_changed_cb was called."); + if ((user_data != NULL) && !strcmp((char *)user_data, "startup")) { + if (adapter_state == BT_ADAPTER_DISABLED && result == BT_ERROR_NONE) { + tet_printf("Callback: BT was disabled. DTS will be started."); + } else { + tet_printf("Callback: BT was not disabled. DTS will be started but DTS may fail."); + } + + if (mainloop) { + g_main_loop_quit(mainloop); + } + } +} + + +/** + * @brief Negative test case of bt_gatt_foreach_primary_services() + */ +static void utc_network_bluetooth_gatt_foreach_primary_services_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_gatt_foreach_primary_services(NULL, NULL, NULL); + dts_check_eq("bt_gatt_foreach_primary_services", ret, + BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when remote address and callback parameters are NULL."); +} + +/** + * @brief Negative test case of bt_gatt_discover_characteristics() + */ +static void utc_network_bluetooth_gatt_discover_characteristics_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_gatt_discover_characteristics(NULL, NULL, NULL); + dts_check_eq("bt_gatt_discover_characteristics", ret, + BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when service and callback parameters are NULL."); +} + +/** + * @brief Negative test case of bt_gatt_get_service_uuid() + */ +static void utc_network_bluetooth_gatt_get_service_uuid_n(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_gatt_get_service_uuid(NULL, NULL); + dts_check_eq("bt_gatt_get_service_uuid", ret, BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when service parameter is NULL."); +} + +/** + * @brief Negative test case of bt_gatt_foreach_included_services() + */ +static void utc_network_bluetooth_gatt_foreach_included_services_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_gatt_foreach_included_services(NULL, NULL, NULL); + dts_check_eq("bt_socket_unset_connection_state_changed_cb", ret, + BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when service and callback parameters are NULL."); +} + +/** + * @brief Negative test case of bt_gatt_set_characteristic_changed_cb() + */ +static void utc_network_bluetooth_gatt_set_characteristic_changed_cb_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_gatt_set_characteristic_changed_cb(NULL, NULL); + dts_check_eq("bt_gatt_set_characteristic_changed_cb", ret, + BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when service and callback parameters are NULL."); +} + +/** + * @brief Negative test case of bt_gatt_unset_characteristic_changed_cb() + */ +static void utc_network_bluetooth_gatt_unset_characteristic_changed_cb_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_gatt_unset_characteristic_changed_cb(); + dts_check_eq("bt_gatt_unset_characteristic_changed_cb", ret, + BT_ERROR_NOT_INITIALIZED, + "BT_ERROR_NOT_INITIALIZED must be returned when BT is not initialized."); +} + + +/** + * @brief Negative test case of bt_gatt_get_characteristic_declaration() + */ +static void utc_network_bluetooth_gatt_get_characteristic_declaration_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_gatt_get_characteristic_declaration(NULL, NULL, NULL, 0); + dts_check_eq("bt_gatt_get_characteristic_declaration", ret, + BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when characteristic parameter is NULL."); +} + +/** + * @brief Negative test case of bt_gatt_set_characteristic_value() + */ +static void utc_network_bluetooth_gatt_set_characteristic_value_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_gatt_set_characteristic_value(NULL, NULL, -1); + dts_check_eq("bt_socket_connect_rfcomm", ret, BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when characteristic and value parameters are NULL."); +} + +/** + * @brief Negative test case of bt_gatt_clone_attribute_handle() + */ +static void utc_network_bluetooth_gatt_clone_attribute_handle_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_gatt_clone_attribute_handle(NULL, NULL); + dts_check_eq("bt_gatt_clone_attribute_handle", ret, + BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when origin parameter is NULL."); +} + +/** + * @brief Negative test case of bt_gatt_destroy_attribute_handle() + */ +static void utc_network_bluetooth_gatt_destroy_attribute_handle_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_gatt_destroy_attribute_handle(NULL); + dts_check_eq("bt_gatt_destroy_attribute_handle", ret, + BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when handle parameter is NULL."); +} + +static void utc_network_bluetooth_gatt_connect_n(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_gatt_connect(NULL, false); + dts_check_eq("bt_gatt_connect", ret, + BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when address is NULL."); + +} + +static void utc_network_bluetooth_gatt_disconnect_n(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_gatt_disconnect(NULL); + dts_check_eq("bt_gatt_connect", ret, + BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when address is NULL."); + +} + +static void utc_network_bluetooth_set_gatt_connection_state_changed_cb_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_gatt_set_connection_state_changed_cb(NULL, NULL); + dts_check_eq("bt_gatt_set_connection_state_changed_cb", ret, + BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when address is NULL."); +} + +static void utc_network_bluetooth_unset_gatt_connection_state_changed_cb_n(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_deinitialize(); + ret = bt_gatt_unset_connection_state_changed_cb(); + dts_check_eq("bt_gatt_unset_connection_state_changed_cb", ret, + BT_ERROR_NOT_INITIALIZED, + "BT_ERROR_NOT_INITIALIZED must be returned when BT is not initialized."); +} diff --git a/TC/testcase/utc_network_bluetooth_gatt_positive.c b/TC/testcase/utc_network_bluetooth_gatt_positive.c new file mode 100755 index 0000000..b45ecca --- /dev/null +++ b/TC/testcase/utc_network_bluetooth_gatt_positive.c @@ -0,0 +1,405 @@ +/* + * utc_network_bluetooth_gatt_positive.c + * + * Created on: 23-Sep-2013 + * Author: shagun.garg + */ + +#include +#include +#include +#include +#include + +#define CONFIG_FILE_PATH "/opt/home/capi-network-bluetooth/tetware.conf" + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +char *remote_address; +static GMainLoop *mainloop; + +static void utc_network_bluetooth_gatt_foreach_primary_services_p(void); +static void utc_network_bluetooth_gatt_discover_characteristics_p(void); + +static void utc_network_bluetooth_gatt_get_service_uuid_p(void); +static void utc_network_bluetooth_gatt_foreach_included_services_p(void); +static void utc_network_bluetooth_gatt_set_characteristic_changed_cb_p(void); +static void utc_network_bluetooth_gatt_unset_characteristic_changed_cb_p(void); +static void utc_network_bluetooth_gatt_get_characteristic_declaration_p(void); +static void utc_network_bluetooth_gatt_set_characteristic_value_p(void); +static void utc_network_bluetooth_gatt_clone_attribute_handle_p(void); +static void utc_network_bluetooth_gatt_destroy_attribute_handle_p(void); +static void utc_network_bluetooth_gatt_connect_p(void); +static void utc_network_bluetooth_gatt_disconnect_p(void); +static void utc_network_bluetooth_set_gatt_connection_state_changed_cb_p(void); +static void utc_network_bluetooth_unset_gatt_connection_state_changed_cb_p(void); + +gboolean timeout_func(gpointer data); +void adapter_state_changed_cb_for_gatt_p(int result, bt_adapter_state_e adapter_state, + void *user_data); +void adapter_le_state_changed_cb_for_gatt_p(int result, bt_adapter_le_state_e adapter_state, + void *user_data); + +bool primary_service_cb_for_gatt_p(bt_gatt_attribute_h service, void *user_data); +bool included_service_cb_for_gatt_p(bt_gatt_attribute_h service, void *user_data); +bool characteristics_discovered_cb_for_gatt_p(int result, int index, int total, bt_gatt_attribute_h characteristic, + void *user_data); +void characteristics_changed_cb_for_gatt_p(bt_gatt_attribute_h characteristic, unsigned char *value, int value_length, + void *user_data); +void gatt_connection_state_changed_cb(int result, bool connected, + const char *remote_address, void *user_data); + +struct tet_testlist tet_testlist[] = { + {utc_network_bluetooth_gatt_foreach_primary_services_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_gatt_discover_characteristics_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_gatt_get_service_uuid_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_gatt_foreach_included_services_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_gatt_set_characteristic_changed_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_set_gatt_connection_state_changed_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_gatt_connect_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_gatt_disconnect_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_unset_gatt_connection_state_changed_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_gatt_unset_characteristic_changed_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_gatt_get_characteristic_declaration_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_gatt_set_characteristic_value_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_gatt_clone_attribute_handle_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_gatt_destroy_attribute_handle_p, POSITIVE_TC_IDX}, + {NULL, 0}, +}; + +int get_value_from_file(void) +{ + FILE *fp; + char *token; + char buf[100]; + + fp = fopen(CONFIG_FILE_PATH, "r"); + if (fp == NULL) { + tet_printf("Default configuration is used\n"); + return -1; + } + while (fgets(buf, sizeof(buf), fp)) { + if (buf[0] == '#' || buf[0] == '\n') + continue; + + token = strrchr(buf, '\n'); + if (token == NULL) { + tet_printf("g_conf is too long\n"); + break; + } + *token = '\0'; + + token = strtok(buf, "="); + if (token == NULL) { + continue; + } + if (strcasecmp(token, "BT_ADDR_LE") == 0) { + token = strtok(NULL, "="); + remote_address = strdup(token); + return 0; + } + } + return -1; +} + +static void startup(void) +{ + bt_error_e ret = BT_ERROR_NONE; + int timeout_id = 0; + + if(get_value_from_file() == -1) { + tet_printf("Failed to read."); + } + + /* start of TC */ + tet_printf("TC start."); + mainloop = g_main_loop_new(NULL, FALSE); + + bt_initialize(); + + if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_gatt_p, "startup") != BT_ERROR_NONE) { + tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed"); + } + + if (bt_adapter_le_set_state_changed_cb(adapter_le_state_changed_cb_for_gatt_p, "enable") != BT_ERROR_NONE) { + dts_fail("bt_adapter_le_enable", + "bt_adapter_le_set_state_changed_cb() failed."); + } + + tet_printf("bt_adapter_enable() was called."); + ret = bt_adapter_enable(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_adapter_enable() succeeded."); + tet_printf("bt_adapter_le_enable() was called."); + ret = bt_adapter_le_enable(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_adapter_le_enable() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } + else { + tet_printf("DTS may fail because bt_adapter_le_enable failed"); + bt_adapter_le_unset_state_changed_cb(); + } + } else if (ret == BT_ERROR_NOT_ENABLED) { + tet_printf("Bluetooth adapter is not enabled."); + } else { + tet_printf("DTS may fail because bt_adapter_enable failed"); + } + + if (bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE) { + tet_printf("bt_adapter_set_state_changed_cb() failed."); + } + + tet_printf("TC start"); +} + +static void cleanup(void) +{ + /* end of TC */ + bt_deinitialize(); + tet_printf("TC end."); +} + +gboolean timeout_func(gpointer data) +{ + tet_printf("[%s] Callback: Timeout.", __FUNCTION__); + g_main_loop_quit((GMainLoop *) data); + return FALSE; +} + + + +void adapter_state_changed_cb_for_gatt_p(int result, bt_adapter_state_e adapter_state, void* user_data) +{ + +} +void adapter_le_state_changed_cb_for_gatt_p(int result, bt_adapter_le_state_e adapter_le__state, void* user_data) +{ + +} + +bool primary_service_cb_for_gatt_p(bt_gatt_attribute_h service, void *user_data) +{ + return false; +} + +bool characteristics_discovered_cb_for_gatt_p(int result, int index, int total, bt_gatt_attribute_h characteristic, + void *user_data) +{ + return false; +} + +bool included_service_cb_for_gatt_p(bt_gatt_attribute_h service, void *user_data) +{ + return false; +} + +void characteristics_changed_cb_for_gatt_p(bt_gatt_attribute_h characteristic, unsigned char *value, int value_length, + void *user_data) +{ + +} + +void gatt_connection_state_changed_cb(int result, bool connected, + const char *remote_address, void *user_data) +{ + tet_printf("bt_gatt_connection_state_changed_cb : %d", result); + if (connected) + tet_printf("LE Connected"); + else + tet_printf("LE Disconnected"); +} + +/** + * @brief Positive test case of bt_gatt_foreach_primary_services() + */ +static void utc_network_bluetooth_gatt_foreach_primary_services_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_gatt_foreach_primary_services(remote_address, primary_service_cb_for_gatt_p, NULL); + dts_check_eq("bt_gatt_foreach_primary_services", ret, BT_ERROR_NONE, + "bt_gatt_foreach_primary_services() failed."); +} + + +/** + * @brief Positive test case of bt_gatt_discover_characteristics() + */ +static void utc_network_bluetooth_gatt_discover_characteristics_p(void) +{ + int ret = BT_ERROR_NONE; + bt_gatt_attribute_h gatt_serv; + gatt_serv = g_malloc0(sizeof(bt_gatt_attribute_h)); + + ret = bt_gatt_discover_characteristics(gatt_serv, characteristics_discovered_cb_for_gatt_p, NULL); + dts_check_eq("bt_gatt_discover_characteristics", ret, BT_ERROR_NONE, "bt_gatt_discover_characteristics() failed."); +} + + +/** + * @brief Positive test case of bt_gatt_get_service_uuid() + */ +static void utc_network_bluetooth_gatt_get_service_uuid_p(void) +{ + int ret = BT_ERROR_NONE; + char *uid = "dts_uid"; + bt_gatt_attribute_h gatt_serv; + gatt_serv = g_malloc0(sizeof(bt_gatt_attribute_h)); + + ret = bt_gatt_get_service_uuid(gatt_serv, &uid); + dts_check_eq("bt_gatt_get_service_uuid", ret, BT_ERROR_NONE, + "bt_gatt_get_service_uuid() failed."); +} + +/** + * @brief Positive test case of bt_gatt_foreach_included_services() + */ +static void utc_network_bluetooth_gatt_foreach_included_services_p(void) +{ + int ret = BT_ERROR_NONE; + bt_gatt_attribute_h gatt_serv; + gatt_serv = g_malloc0(sizeof(bt_gatt_attribute_h)); + ret = bt_gatt_foreach_included_services(gatt_serv, included_service_cb_for_gatt_p, NULL); + dts_check_eq("bt_gatt_foreach_included_services", ret, BT_ERROR_NONE, + "bt_gatt_foreach_included_services() failed."); +} + + +/** + * @brief Positive test case of bt_gatt_set_characteristic_changed_cb() + */ +static void utc_network_bluetooth_gatt_set_characteristic_changed_cb_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_gatt_set_characteristic_changed_cb(characteristics_changed_cb_for_gatt_p, NULL); + dts_check_eq("bt_gatt_set_characteristic_changed_cb", ret, BT_ERROR_NONE, + "bt_gatt_set_characteristic_changed_cb() failed."); +} + + +/** + * @brief Positive test case of bt_gatt_unset_characteristic_changed_cb() + */ +static void utc_network_bluetooth_gatt_unset_characteristic_changed_cb_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_gatt_unset_characteristic_changed_cb(); + dts_check_eq("bt_gatt_unset_characteristic_changed_cb", ret, BT_ERROR_NONE, + "bt_gatt_unset_characteristic_changed_cb() failed."); + +} + + +/** + * @brief Positive test case of bt_gatt_get_characteristic_declaration() + */ +static void utc_network_bluetooth_gatt_get_characteristic_declaration_p(void) +{ + int ret = BT_ERROR_NONE; + char **uid = "dts_uid"; + unsigned char **val = "dts_value"; + int l = 1; + bt_gatt_attribute_h gatt_charac; + gatt_charac = g_malloc0(sizeof(bt_gatt_attribute_h)); + ret = bt_gatt_get_characteristic_declaration(gatt_charac, uid, val, &l); + dts_check_eq("bt_gatt_get_characteristic_declaration", ret, BT_ERROR_NONE, + "gatt_get_characteristic_declaration() failed."); +} + + +/** + * @brief Positive test case of bt_gatt_set_characteristic_value() + */ +static void utc_network_bluetooth_gatt_set_characteristic_value_p(void) +{ + int ret = BT_ERROR_NONE; + bt_gatt_attribute_h gatt_charac; + gatt_charac = g_malloc0(sizeof(bt_gatt_attribute_h)); + const unsigned char *gatt_value = "dts_value"; + ret = bt_gatt_set_characteristic_value(gatt_charac, gatt_value, strlen("dts_value")); + dts_check_eq("bt_gatt_set_characteristic_value", ret, BT_ERROR_NONE, + "bt_gatt_set_characteristic_value() failed."); +} + + +/** + * @brief Positive test case of bt_gatt_clone_attribute_handle() + */ +static void utc_network_bluetooth_gatt_clone_attribute_handle_p(void) +{ + int ret = BT_ERROR_NONE; + bt_gatt_attribute_h gatt_origin; + bt_gatt_attribute_h gatt_clone; + gatt_origin = g_malloc0(sizeof(bt_gatt_attribute_h)); + gatt_clone = g_malloc0(sizeof(bt_gatt_attribute_h)); + + ret = bt_gatt_clone_attribute_handle(&gatt_clone, gatt_origin); + dts_check_eq("bt_gatt_clone_attribute_handle", ret, BT_ERROR_NONE, + "bt_gatt_clone_attribute_handle() failed."); +} + + +/** + * @brief Positive test case of bt_gatt_destroy_attribute_handle() + */ +static void utc_network_bluetooth_gatt_destroy_attribute_handle_p(void) +{ + int ret = BT_ERROR_NONE; + bt_gatt_attribute_h gatt_handle; + gatt_handle = g_malloc0(sizeof(bt_gatt_attribute_h)); + + ret = bt_gatt_destroy_attribute_handle(gatt_handle); + dts_check_eq("bt_gatt_destroy_attribute_handle", ret, BT_ERROR_NONE, + "bt_gatt_destroy_attribute_handle() failed."); +} + +static void utc_network_bluetooth_gatt_connect_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_gatt_connect(remote_address, false); + dts_check_eq("bt_gatt_connect", ret, BT_ERROR_NONE, + "bt_gatt_connect() failed."); + +} + +static void utc_network_bluetooth_gatt_disconnect_p(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_gatt_disconnect(remote_address); + dts_check_eq("bt_gatt_connect", ret, BT_ERROR_NONE, + "bt_gatt_connect() failed."); + +} + +static void utc_network_bluetooth_set_gatt_connection_state_changed_cb_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_gatt_set_connection_state_changed_cb(gatt_connection_state_changed_cb, NULL); + dts_check_eq("bt_gatt_set_connection_state_changed_cb", ret, BT_ERROR_NONE, + "bt_gatt_set_connection_state_changed_cb() failed."); +} + +static void utc_network_bluetooth_unset_gatt_connection_state_changed_cb_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_gatt_unset_connection_state_changed_cb(); + dts_check_eq("bt_gatt_unset_connection_state_changed_cb", ret, BT_ERROR_NONE, + "bt_gatt_unset_connection_state_changed_cb() failed."); +} diff --git a/TC/testcase/utc_network_bluetooth_hdp_negative.c b/TC/testcase/utc_network_bluetooth_hdp_negative.c new file mode 100755 index 0000000..d157a1f --- /dev/null +++ b/TC/testcase/utc_network_bluetooth_hdp_negative.c @@ -0,0 +1,201 @@ +/* + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static void startup(void); +static void cleanup(void); + +static GMainLoop *mainloop; + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_network_bluetooth_hdp_register_sink_app_n(void); +static void utc_network_bluetooth_hdp_unregister_sink_app_n(void); +static void utc_network_bluetooth_hdp_connect_to_source_n(void); +static void utc_network_bluetooth_hdp_disconnect_n(void); +static void utc_network_bluetooth_hdp_send_data_n(void); +static void utc_network_bluetooth_hdp_set_connection_state_changed_cb_n(void); +static void utc_network_bluetooth_hdp_set_data_received_cb_n(void); + +void adapter_state_changed_cb_for_hdp_n(int result, + bt_adapter_state_e adapter_state, void *user_data); +gboolean timeout_func(gpointer data); + +struct tet_testlist tet_testlist[] = { + { utc_network_bluetooth_hdp_register_sink_app_n, NEGATIVE_TC_IDX }, + { utc_network_bluetooth_hdp_connect_to_source_n, NEGATIVE_TC_IDX }, + { utc_network_bluetooth_hdp_send_data_n, NEGATIVE_TC_IDX }, + { utc_network_bluetooth_hdp_set_connection_state_changed_cb_n, NEGATIVE_TC_IDX }, + { utc_network_bluetooth_hdp_set_data_received_cb_n, NEGATIVE_TC_IDX }, + { utc_network_bluetooth_hdp_disconnect_n, NEGATIVE_TC_IDX }, + { utc_network_bluetooth_hdp_unregister_sink_app_n, NEGATIVE_TC_IDX }, + { NULL, 0 }, +}; + +static void startup(void) +{ + int ret = BT_ERROR_NONE; + int timeout_id = 0; + + /* start of TC */ + mainloop = g_main_loop_new(NULL, FALSE); + + bt_initialize(); + if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_hdp_n, "startup") != BT_ERROR_NONE) { + tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed"); + } + + tet_printf("bt_adapter_disable() was called."); + ret = bt_adapter_disable(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_adapter_disable() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else if (ret == BT_ERROR_NOT_ENABLED) { + tet_printf("Bluetooth adapter is not enabled."); + } else { + tet_printf("DTS may fail because bt_adapter_disable() failed"); + } + + if (bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE) { + tet_printf("bt_adapter_set_state_changed_cb() failed."); + } + + tet_printf("TC start"); +} + +static void cleanup(void) +{ + /* end of TC */ + bt_deinitialize(); + tet_printf("TC end."); +} + +gboolean timeout_func(gpointer data) +{ + tet_printf("Callback: Timeout."); + g_main_loop_quit((GMainLoop *) data); + return FALSE; +} + +/** + * @brief Callback funtions + */ +void adapter_state_changed_cb_for_hdp_n(int result, + bt_adapter_state_e adapter_state, void *user_data) +{ + +} + + +/** + * @brief Negative test case of bt_hdp_set_data_received_cb() + */ +static void utc_network_bluetooth_hdp_set_data_received_cb_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_hdp_set_data_received_cb(NULL, NULL); + dts_check_eq("bt_hdp_set_data_received_cb", ret, BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER is returned when cb parameters are NULL"); +} + +/** + * @brief Negative test case of bt_hdp_set_connection_state_changed_cb() + */ +static void utc_network_bluetooth_hdp_set_connection_state_changed_cb_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_hdp_set_connection_state_changed_cb(NULL, NULL, NULL); + dts_check_eq("bt_hdp_set_connection_state_changed_cb", ret, + BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER is returned when cb parameters are NULL"); +} + + +/** + * @brief Negative test case of bt_hdp_disconnect() + */ +static void utc_network_bluetooth_hdp_disconnect_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_hdp_disconnect(NULL, 1); + dts_check_eq("bt_hdp_disconnect", ret, BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when remote address parameter is NULL"); +} + +/** + * @brief Negative test case of bt_hdp_connect_to_source() + */ +static void utc_network_bluetooth_hdp_connect_to_source_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_hdp_connect_to_source(NULL, NULL); + dts_check_eq("bt_hdp_connect_to_source", ret, BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when remote address and app_id parameter are NULL"); +} + +/** + * @brief Negative test case of bt_hdp_register_sink_app() + */ +static void utc_network_bluetooth_hdp_register_sink_app_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_hdp_register_sink_app(1, NULL); + dts_check_eq("bt_hdp_register_sink_app", ret, BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when app_id parameter is NULL"); +} + +/** + * @brief Negative test case of bt_hdp_unregister_sink_appe() + */ +static void utc_network_bluetooth_hdp_unregister_sink_app_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_hdp_unregister_sink_app(NULL); + dts_check_eq("bt_shdp_unregister_sink", ret, BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when app_id parameter is NULL"); +} + +/** + * @brief Negative test case of bt_hdp_send_data() + */ +static void utc_network_bluetooth_hdp_send_data_n(void) +{ + int ret = BT_ERROR_NONE; + char *data = "dts_test"; + + ret = bt_hdp_send_data(1, data, sizeof(data)); + dts_check_eq("bt_hdp_send_data", ret, BT_ERROR_NOT_ENABLED, + "BT_ERROR_NOT_ENABLED must be returned when BT is not enabled"); +} diff --git a/TC/testcase/utc_network_bluetooth_hdp_positive.c b/TC/testcase/utc_network_bluetooth_hdp_positive.c new file mode 100755 index 0000000..b99e6f5 --- /dev/null +++ b/TC/testcase/utc_network_bluetooth_hdp_positive.c @@ -0,0 +1,242 @@ +/* + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static void startup(void); +static void cleanup(void); + +static GMainLoop *mainloop; + +void(*tet_startup)(void) = startup; +void(*tet_cleanup)(void) = cleanup; + +const char *appid = "/org/bluez/health_app_2"; +const char *remote_adr = "00:22:58:07:77:BB"; + +static void utc_network_bluetooth_hdp_register_sink_app_p(void); +static void utc_network_bluetooth_hdp_unregister_sink_app_p(void); +static void utc_network_bluetooth_hdp_connect_to_source_p(void); +static void utc_network_bluetooth_hdp_disconnect_p(void); +static void utc_network_bluetooth_hdp_send_data_p(void); +static void utc_network_bluetooth_hdp_set_connection_state_changed_cb_p(void); +static void utc_network_bluetooth_hdp_unset_connection_state_changed_cb_p(void); +static void utc_network_bluetooth_hdp_set_data_received_cb_p(void); +static void utc_network_bluetooth_hdp_unset_data_received_cb_p(void); + +void data_received_cb_for_hdp_p(unsigned int channel, const char *data, + unsigned int size, void *user_data); +void connected_cb_for_hdp_p(int result, const char *remote_address, + const char *app_id, + bt_hdp_channel_type_e type, unsigned int channel, void *user_data); +void disconnected_cb_for_hdp_p(int result, const char *remote_address, + unsigned int channel, void *user_data); + + + +void adapter_state_changed_cb_for_hdp_p(int result, + bt_adapter_state_e adapter_state, void *user_data); +gboolean timeout_func(gpointer data); + +struct tet_testlist tet_testlist[] = { + {utc_network_bluetooth_hdp_register_sink_app_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_hdp_set_connection_state_changed_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_hdp_set_data_received_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_hdp_connect_to_source_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_hdp_send_data_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_hdp_disconnect_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_hdp_unset_connection_state_changed_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_hdp_unset_data_received_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_hdp_unregister_sink_app_p, POSITIVE_TC_IDX}, + {NULL, 0}, +}; + + +static void startup(void) +{ + int ret = BT_ERROR_NONE; + int timeout_id = 0; + + /* start of TC */ + mainloop = g_main_loop_new(NULL, FALSE); + + bt_initialize(); + if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_hdp_p, "startup") != BT_ERROR_NONE) { + tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed"); + } + + tet_printf("bt_adapter_enable() was called."); + ret = bt_adapter_enable(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_adapter_enable() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else if (ret != BT_ERROR_ALREADY_DONE) { + tet_printf("DTS may fail because bt_adapter_disable() failed"); + } else if (ret == BT_ERROR_NOT_ENABLED) { + tet_printf("Bluetooth adapter is not enabled."); + } else { + tet_printf("DTS may fail because bt_adapter_disable() failed"); + } + + if (bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE) { + tet_printf("bt_adapter_set_state_changed_cb() failed."); + } + + tet_printf("TC start"); +} + +static void cleanup(void) +{ + /* end of TC */ + bt_deinitialize(); + tet_printf("TC end."); +} + +gboolean timeout_func(gpointer data) +{ + tet_printf("Callback: Timeout."); + g_main_loop_quit((GMainLoop *) data); + return FALSE; +} + +void adapter_state_changed_cb_for_hdp_p(int result, + bt_adapter_state_e adapter_state, void *user_data) +{ + +} + +void data_received_cb_for_hdp_p(unsigned int channel, const char *data, + unsigned int size, void *user_data) +{ + +} + +void connected_cb_for_hdp_p(int result, const char *remote_address, + const char *app_id, + bt_hdp_channel_type_e type, unsigned int channel, void *user_data) +{ + +} + +void disconnected_cb_for_hdp_p(int result, const char *remote_address, + unsigned int channel, void *user_data) +{ + +} + +static void utc_network_bluetooth_hdp_set_data_received_cb_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_hdp_set_data_received_cb(data_received_cb_for_hdp_p, NULL); + dts_check_eq("bt_hdp_set_data_received_cb", ret, BT_ERROR_NONE, + "bt_hdp_set_data_received_cb() failed."); +} + + +static void utc_network_bluetooth_hdp_unset_data_received_cb_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_hdp_unset_data_received_cb(); + dts_check_eq("bt_hdp_unset_data_received_cb", ret, BT_ERROR_NONE, + "bt_hdp_unset_data_received_cb() failed."); +} + +static void utc_network_bluetooth_hdp_set_connection_state_changed_cb_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_hdp_set_connection_state_changed_cb(connected_cb_for_hdp_p, + disconnected_cb_for_hdp_p, NULL); + dts_check_eq("bt_hdp_set_connection_state_changed_cb", ret, BT_ERROR_NONE, + "bt_hdp_set_connection_state_changed_cb() failed."); +} + +static void utc_network_bluetooth_hdp_unset_connection_state_changed_cb_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_hdp_unset_connection_state_changed_cb(); + dts_check_eq("bt_hdp_unset_connection_state_changed_cb", ret, BT_ERROR_NONE, + "bt_hdp_unset_connection_state_changed_cb() failed."); +} + +static void utc_network_bluetooth_hdp_send_data_p(void) +{ + int ret = BT_ERROR_NONE; + char *dts_test = "dts_test"; + + ret = bt_hdp_send_data(1, "dts_test", sizeof(dts_test)); + dts_check_eq("bt_hdp_send_data", ret, BT_ERROR_NONE, + "bt_hdp_send_data() failed."); +} + +static void utc_network_bluetooth_hdp_disconnect_p(void) +{ + int ret = BT_ERROR_NONE; + char *remote_adr = "00:22:58:07:77:BB"; + + ret = bt_hdp_disconnect(remote_adr, 0); + dts_check_eq("bt_hdp_disconnect", ret, BT_ERROR_NONE, + "bt_hdp_disconnect() failed."); +} + +static void utc_network_bluetooth_hdp_connect_to_source_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_hdp_connect_to_source(remote_adr, appid); + dts_check_eq("bt_hdp_connect_to_source", ret, BT_ERROR_NONE, + "bt_hdp_connect_to_source() failed."); + +} + +static void utc_network_bluetooth_hdp_unregister_sink_app_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_hdp_unregister_sink_app(appid); + dts_check_eq("bt_hdp_unregister_sink_app", ret, BT_ERROR_NONE, + "bt_hdp_unregister_sink_app() failed."); + +} + +static void utc_network_bluetooth_hdp_register_sink_app_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_hdp_register_sink_app(1, &appid); + dts_check_eq("bt_hdp_register_sink_app", ret, BT_ERROR_NONE, + "bt_hdp_register_sink_app() failed."); + +} + + + + + diff --git a/TC/testcase/utc_network_bluetooth_hid_negative.c b/TC/testcase/utc_network_bluetooth_hid_negative.c new file mode 100755 index 0000000..e8cb5f8 --- /dev/null +++ b/TC/testcase/utc_network_bluetooth_hid_negative.c @@ -0,0 +1,142 @@ +/* + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static void startup(void); +static void cleanup(void); + +static GMainLoop *mainloop; + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_network_bluetooth_hid_host_initialize_n(void); +static void utc_network_bluetooth_hid_host_connect_n(void); +static void utc_network_bluetooth_hid_host_disconnect_n(void); + +void adapter_state_changed_cb_for_hid_n(int result, + bt_adapter_state_e adapter_state, void *user_data); +gboolean timeout_func(gpointer data); + +struct tet_testlist tet_testlist[] = { + {utc_network_bluetooth_hid_host_initialize_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_hid_host_connect_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_hid_host_disconnect_n, NEGATIVE_TC_IDX}, + {NULL, 0}, +}; + + +static void startup(void) +{ + int ret = BT_ERROR_NONE; + int timeout_id = 0; + + /* start of TC */ + mainloop = g_main_loop_new(NULL, FALSE); + + bt_initialize(); + if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_hid_n, "startup") != BT_ERROR_NONE) { + tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed"); + } + + tet_printf("bt_adapter_disable() was called."); + ret = bt_adapter_disable(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_adapter_disable() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else if (ret == BT_ERROR_NOT_ENABLED) { + tet_printf("Bluetooth adapter is not enabled."); + } else { + tet_printf("DTS may fail because bt_adapter_disable() failed"); + } + + if (bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE) { + tet_printf("bt_adapter_set_state_changed_cb() failed."); + } + + tet_printf("TC start"); +} + + +static void cleanup(void) +{ + /* end of TC */ + bt_deinitialize(); + tet_printf("TC end."); +} + + +gboolean timeout_func(gpointer data) +{ + tet_printf("Callback: Timeout."); + g_main_loop_quit((GMainLoop *) data); + return FALSE; +} + +void adapter_state_changed_cb_for_hid_n(int result, + bt_adapter_state_e adapter_state, void *user_data) +{ + +} +void host_connection_state_changed_cb_for_hid_p(int result, + bool connected, const char *remote_address, void *user_data) +{ + +} + +static void utc_network_bluetooth_hid_host_initialize_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_hid_host_initialize(NULL, NULL); + dts_check_eq("bt_hid_host_initialize", ret, + BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when callback parameter is NULL."); +} + + +static void utc_network_bluetooth_hid_host_connect_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_hid_host_initialize(host_connection_state_changed_cb_for_hid_p, NULL); + + ret = bt_hid_host_connect(NULL); + dts_check_eq("bt_hid_host_connect", ret, BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when remote address parameter is NULL."); +} + + +static void utc_network_bluetooth_hid_host_disconnect_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_hid_host_disconnect(NULL); + dts_check_eq("bt_hid_host_disconnect", ret, BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when remote address parameter is NULL."); +} diff --git a/TC/testcase/utc_network_bluetooth_hid_positive.c b/TC/testcase/utc_network_bluetooth_hid_positive.c new file mode 100755 index 0000000..95e7db1 --- /dev/null +++ b/TC/testcase/utc_network_bluetooth_hid_positive.c @@ -0,0 +1,159 @@ +/* + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static void startup(void); +static void cleanup(void); + +static GMainLoop *mainloop; + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_network_bluetooth_hid_host_initialize_p(void); +static void utc_network_bluetooth_hid_host_deinitialize_p(void); +static void utc_network_bluetooth_hid_host_connect_p(void); +static void utc_network_bluetooth_hid_host_disconnect_p(void); + +void adapter_state_changed_cb_for_hid_p(int result, + bt_adapter_state_e adapter_state, void *user_data); +void host_connection_state_changed_cb_for_hid_p(int result, + bool connected, const char *remote_address, void *user_data); +gboolean timeout_func(gpointer data); + +struct tet_testlist tet_testlist[] = { + {utc_network_bluetooth_hid_host_initialize_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_hid_host_connect_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_hid_host_disconnect_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_hid_host_deinitialize_p, POSITIVE_TC_IDX}, + {NULL, 0}, +}; + + +static void startup(void) +{ + int ret = BT_ERROR_NONE; + int timeout_id = 0; + + /* start of TC */ + mainloop = g_main_loop_new(NULL, FALSE); + + bt_initialize(); + if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_hid_p, "startup") != BT_ERROR_NONE) { + tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed"); + } + + tet_printf("bt_adapter_enable() was called."); + ret = bt_adapter_enable(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_adapter_enable() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else if (ret != BT_ERROR_ALREADY_DONE) { + tet_printf("DTS may fail because bt_adapter_disable() failed"); + } else if (ret == BT_ERROR_NOT_ENABLED) { + tet_printf("Bluetooth adapter is not enabled."); + } else { + tet_printf("DTS may fail because bt_adapter_disable() failed"); + } + + if (bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE) { + tet_printf("bt_adapter_set_state_changed_cb() failed."); + } + + tet_printf("TC start"); +} + + +static void cleanup(void) +{ + /* end of TC */ + bt_deinitialize(); + tet_printf("TC end."); +} + + +gboolean timeout_func(gpointer data) +{ + tet_printf("Callback: Timeout."); + g_main_loop_quit((GMainLoop *) data); + return FALSE; +} + +void adapter_state_changed_cb_for_hid_p(int result, + bt_adapter_state_e adapter_state, void *user_data) +{ + +} + +void host_connection_state_changed_cb_for_hid_p(int result, + bool connected, const char *remote_address, void *user_data) +{ + +} + + +static void utc_network_bluetooth_hid_host_initialize_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_hid_host_initialize(host_connection_state_changed_cb_for_hid_p, NULL); + dts_check_eq("bt_hid_host_initialize", ret, BT_ERROR_NONE, + "bt_hid_host_initialize() failed."); +} + + +static void utc_network_bluetooth_hid_host_deinitialize_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_hid_host_deinitialize(); + dts_check_eq("bt_hid_host_deinitialize", ret, BT_ERROR_NONE, + "bt_hid_host_deinitialize() failed."); +} + + +static void utc_network_bluetooth_hid_host_connect_p(void) +{ + int ret = BT_ERROR_NONE; + char *remote_addr = "dts_addr"; + + ret = bt_hid_host_connect(remote_addr); + dts_check_eq("bt_hid_host_connect", ret, BT_ERROR_NONE, + "bt_hid_host_connect() failed."); +} + + +static void utc_network_bluetooth_hid_host_disconnect_p(void) +{ + int ret = BT_ERROR_NONE; + char *remote_addr = "dts_addr"; + + ret = bt_hid_host_disconnect(remote_addr); + dts_check_eq("bt_hid_host_disconnect", ret, BT_ERROR_NONE, + "bt_hid_host_disconnect() failed."); +} diff --git a/TC/testcase/utc_network_bluetooth_opp-client_negative.c b/TC/testcase/utc_network_bluetooth_opp-client_negative.c new file mode 100755 index 0000000..77ecc79 --- /dev/null +++ b/TC/testcase/utc_network_bluetooth_opp-client_negative.c @@ -0,0 +1,136 @@ +/* + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static void startup(void); +static void cleanup(void); + +static GMainLoop *mainloop; + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_network_bluetooth_opp_client_add_file_n(void); +static void utc_network_bluetooth_opp_client_push_files_n(void); + +void adapter_state_changed_cb_for_opp_client_n(int result, + bt_adapter_state_e adapter_state, void *user_data); +gboolean timeout_func(gpointer data); + +struct tet_testlist tet_testlist[] = { + {utc_network_bluetooth_opp_client_add_file_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_opp_client_push_files_n, NEGATIVE_TC_IDX}, + {NULL, 0}, +}; + + +static void startup(void) +{ + int ret = BT_ERROR_NONE; + int timeout_id = 0; + + /* start of TC */ + mainloop = g_main_loop_new(NULL, FALSE); + + bt_initialize(); + bt_opp_client_initialize(); + if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_opp_client_n, "startup") != BT_ERROR_NONE) { + tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed"); + } + + tet_printf("bt_adapter_disable() was called."); + ret = bt_adapter_disable(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_adapter_disable() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else if (ret == BT_ERROR_NOT_ENABLED) { + tet_printf("Bluetooth adapter is not enabled."); + } else { + tet_printf("DTS may fail because bt_adapter_disable() failed"); + } + + if (bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE) { + tet_printf("bt_adapter_set_state_changed_cb() failed."); + } + + tet_printf("TC start"); +} + + +static void cleanup(void) +{ + /* end of TC */ + bt_deinitialize(); + tet_printf("TC end."); +} + + +gboolean timeout_func(gpointer data) +{ + tet_printf("Callback: Timeout."); + g_main_loop_quit((GMainLoop *) data); + return FALSE; +} + +void adapter_state_changed_cb_for_opp_client_n(int result, + bt_adapter_state_e adapter_state, void *user_data) +{ + if (user_data != NULL && !strcmp((char *)user_data, "startup")) { + if (adapter_state == BT_ADAPTER_ENABLED && result == BT_ERROR_NONE) { + tet_printf("Callback: BT was enabled."); + bt_adapter_start_device_discovery(); + } else { + tet_printf("Callback: BT was not enabled. DTS will be started but DTS may fail."); + if (mainloop) { + g_main_loop_quit(mainloop); + } + } + } +} + + +static void utc_network_bluetooth_opp_client_add_file_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_opp_client_add_file(NULL); + dts_check_eq("bt_opp_client_add_file", ret, BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when file parameter is NULL"); +} + + +static void utc_network_bluetooth_opp_client_push_files_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_opp_client_push_files(NULL, NULL, NULL, NULL, NULL); + dts_check_eq("bt_opp_client_push_files", ret, BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when parameters are NULL"); +} + + diff --git a/TC/testcase/utc_network_bluetooth_opp-client_positive.c b/TC/testcase/utc_network_bluetooth_opp-client_positive.c new file mode 100755 index 0000000..b50baea --- /dev/null +++ b/TC/testcase/utc_network_bluetooth_opp-client_positive.c @@ -0,0 +1,260 @@ +/* + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include +#include +#include +#include + +#define CONFIG_FILE_PATH "/opt/home/capi-network-bluetooth/tetware.conf" +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static void startup(void); +static void cleanup(void); + +static GMainLoop *mainloop; + +void(*tet_startup)(void) = startup; +void(*tet_cleanup)(void) = cleanup; + +char *remote_address; + +static void utc_network_bluetooth_opp_client_initialize_p(void); +static void utc_network_bluetooth_opp_client_deinitialize_p(void); +static void utc_network_bluetooth_opp_client_add_file_p(void); +static void utc_network_bluetooth_opp_client_clear_files_p(void); +static void utc_network_bluetooth_opp_client_push_files_p(void); +static void utc_network_bluetooth_opp_client_cancel_push_p(void); + +void push_responded_cb_for_opp_client_p(int result, + const char *remote_address, void *user_data); +void push_progress_cb_for_opp_client_p(const char *file, + long long size, int percent, void *user_data); +void push_finished_cb_for_opp_client_p(int result, + const char *remote_address, void *user_data); +void adapter_state_changed_cb_for_opp_client_p(int result, + bt_adapter_state_e adapter_state, void *user_data); +gboolean timeout_func(gpointer data); + +struct tet_testlist tet_testlist[] = { + {utc_network_bluetooth_opp_client_initialize_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_opp_client_add_file_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_opp_client_push_files_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_opp_client_cancel_push_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_opp_client_clear_files_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_opp_client_deinitialize_p, POSITIVE_TC_IDX}, + {NULL, 0}, +}; + +int get_value_from_file(void) +{ + FILE *fp; + char *token; + char buf[100]; + + fp = fopen(CONFIG_FILE_PATH, "r"); + if (fp == NULL) { + tet_printf("Default configuration is used\n"); + return -1; + } + while (fgets(buf, sizeof(buf), fp)) { + if (buf[0] == '#' || buf[0] == '\n') + continue; + + token = strrchr(buf, '\n'); + if (token == NULL) { + tet_printf("g_conf is too long\n"); + break; + } + *token = '\0'; + + token = strtok(buf, "="); + if (token == NULL) { + continue; + } + if (strcasecmp(token, "BT_ADDR_MOBILE") == 0) { + token = strtok(NULL, "="); + remote_address = strdup(token); + fclose(fp); + return 0; + } + } + return -1; +} + +static void startup(void) +{ + int ret = BT_ERROR_NONE; + int timeout_id = 0; + + if(get_value_from_file() == -1) { + tet_printf("Failed to read."); + } + + /* start of TC */ + mainloop = g_main_loop_new(NULL, FALSE); + + bt_initialize(); + if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_opp_client_p, "startup") != BT_ERROR_NONE) { + tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed"); + } + + tet_printf("bt_adapter_enable() was called."); + ret = bt_adapter_enable(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_adapter_enable() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else if (ret != BT_ERROR_ALREADY_DONE) { + tet_printf("DTS may fail because bt_adapter_disable() failed"); + } else if (ret == BT_ERROR_NOT_ENABLED) { + tet_printf("Bluetooth adapter is not enabled."); + } else { + tet_printf("DTS may fail because bt_adapter_disable() failed"); + } + + if (bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE) { + tet_printf("bt_adapter_set_state_changed_cb() failed."); + } + + tet_printf("TC start"); +} + +static void cleanup(void) +{ + /* end of TC */ + bt_deinitialize(); + tet_printf("TC end."); +} + +gboolean timeout_func(gpointer data) +{ + tet_printf("Callback: Timeout."); + g_main_loop_quit((GMainLoop *) data); + return FALSE; +} + +void adapter_state_changed_cb_for_opp_client_p(int result, + bt_adapter_state_e adapter_state, void *user_data) +{ + if ((user_data != NULL) && !strcmp((char *)user_data, "startup")) { + if (adapter_state == BT_ADAPTER_ENABLED && result == BT_ERROR_NONE) { + tet_printf("Callback: BT was enabled."); + bt_adapter_start_device_discovery(); + } else { + tet_printf("Callback: BT was not enabled. DTS will be started but DTS may fail."); + if (mainloop) { + g_main_loop_quit(mainloop); + } + } + } +} + +void push_responded_cb_for_opp_client_p(int result, + const char *remote_address, void *user_data) +{ + +} + + +void push_progress_cb_for_opp_client_p(const char *file, long long size, + int percent, void *user_data) +{ + +} + + +void push_finished_cb_for_opp_client_p(int result, + const char *remote_address, void *user_data) +{ + +} + + +static void utc_network_bluetooth_opp_client_initialize_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_opp_client_initialize(); + dts_check_eq("bt_opp_client_initialize", ret, + BT_ERROR_NONE, "bt_opp_client_initialize() failed."); +} + +static void utc_network_bluetooth_opp_client_deinitialize_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_opp_client_deinitialize(); + dts_check_eq("bt_opp_client_deinitialize", ret, + BT_ERROR_NONE, "bt_opp_client_deinitialize() failed."); + +} + +static void utc_network_bluetooth_opp_client_add_file_p(void) +{ + int ret = BT_ERROR_NONE; + int fd = 0; + const char *file = "/tmp/a.txt"; + + if (access("/tmp/a.txt", F_OK) < 0) { + fd = open("/tmp/a.txt", O_RDWR|O_CREAT,0666); + write(fd, "hey", 3); + } + + ret = bt_opp_client_add_file(file); + dts_check_eq("bt_opp_client_add_file", ret, + BT_ERROR_NONE, "bt_opp_client_add_file() failed"); +} + + +static void utc_network_bluetooth_opp_client_clear_files_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_opp_client_clear_files(); + dts_check_eq("bt_opp_client_clear_files", ret, + BT_ERROR_NONE, "bt_opp_client_clear_files() failed."); + +} + + +static void utc_network_bluetooth_opp_client_push_files_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_opp_client_push_files(remote_address, push_responded_cb_for_opp_client_p, + push_progress_cb_for_opp_client_p, push_finished_cb_for_opp_client_p, NULL); + + dts_check_eq("bt_opp_client_push_files", ret, + BT_ERROR_NONE, "bt_opp_client_push_files() failed"); +} + +static void utc_network_bluetooth_opp_client_cancel_push_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_opp_client_cancel_push(); + dts_check_eq("bt_opp_client_cancel_push", ret, + BT_ERROR_NONE, "bt_opp_client_cancel_push() failed."); +} diff --git a/TC/testcase/utc_network_bluetooth_opp-server_negative.c b/TC/testcase/utc_network_bluetooth_opp-server_negative.c new file mode 100755 index 0000000..a7d911d --- /dev/null +++ b/TC/testcase/utc_network_bluetooth_opp-server_negative.c @@ -0,0 +1,191 @@ +/* + * + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static void startup(void); +static void cleanup(void); + +static GMainLoop *mainloop; +const char *dest = "/tmp"; + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_network_bluetooth_opp_server_initialize_n(void); +static void utc_network_bluetooth_opp_server_initialize_by_connection_request_n(void); +static void utc_network_bluetooth_opp_server_accept_n(void); +static void utc_network_bluetooth_opp_server_set_destination_n(void); + +void adapter_state_changed_cb_for_opp_server_n(int result, + bt_adapter_state_e adapter_state, void *user_data); +void transfer_progress_cb_for_opp_server(const char *file, long long size, + int percent, void *user_data); +void transfer_finished_cb_for_opp_server(int result, const char *file, + long long size, void *user_data); +void push_requested_cb_for_opp_server(const char *file, int size, void *user_data); + +gboolean timeout_func(gpointer data); + +struct tet_testlist tet_testlist[] = { + {utc_network_bluetooth_opp_server_initialize_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_opp_server_initialize_by_connection_request_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_opp_server_set_destination_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_opp_server_accept_n, NEGATIVE_TC_IDX}, + {NULL, 0}, +}; + +static void startup(void) +{ + int ret = BT_ERROR_NONE; + int timeout_id = 0; + + /* start of TC */ + mainloop = g_main_loop_new(NULL, FALSE); + + bt_initialize(); + if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_opp_server_n, "startup") != BT_ERROR_NONE) { + tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed"); + } + + tet_printf("bt_adapter_disable() was called."); + ret = bt_adapter_disable(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_adapter_disable() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else if (ret == BT_ERROR_NOT_ENABLED) { + tet_printf("Bluetooth adapter is not enabled."); + } else { + tet_printf("DTS may fail because bt_adapter_disable() failed"); + } + + if (bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE) { + tet_printf("bt_adapter_set_state_changed_cb() failed."); + } + + tet_printf("TC start"); +} + + +static void cleanup(void) +{ + /* end of TC */ + bt_deinitialize(); + tet_printf("TC end."); +} + + +gboolean timeout_func(gpointer data) +{ + tet_printf("Callback: Timeout."); + g_main_loop_quit((GMainLoop *)data); + return FALSE; +} + +void push_requested_cb_for_opp_server(const char *file, int size, + void *user_data) +{ + +} + +void transfer_progress_cb_for_opp_server(const char *file, long long size, + int percent, void *user_data) +{ + +} + +void transfer_finished_cb_for_opp_server(int result, const char *file, + long long size, void *user_data) +{ + +} + +/** + * @brief Callback funtions + */ +void adapter_state_changed_cb_for_opp_server_n(int result, + bt_adapter_state_e adapter_state, void *user_data) +{ + tet_printf("Callback: bt_adapter_state_changed_cb was called."); + if ((user_data != NULL) && !strcmp((char *)user_data, "startup")) { + if (adapter_state == BT_ADAPTER_DISABLED && result == BT_ERROR_NONE) { + tet_printf("Callback: BT was disabled. DTS will be started."); + } else { + tet_printf("Callback: BT was not disabled. DTS will be started but DTS may fail."); + } + + if (mainloop) { + g_main_loop_quit(mainloop); + } + } +} + +static void utc_network_bluetooth_opp_server_initialize_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_opp_server_initialize(NULL, NULL, NULL); + dts_check_eq("bt_opp_server_initialize", ret, BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when destination parameter is NULL"); +} + + +static void utc_network_bluetooth_opp_server_accept_n(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_opp_server_accept(transfer_progress_cb_for_opp_server, + transfer_finished_cb_for_opp_server, NULL, NULL, NULL); + dts_check_eq("bt_opp_server_accept", ret, BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_NOT_INITIALIZED must be returned."); + +} + + +static void utc_network_bluetooth_opp_server_set_destination_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_opp_server_initialize(dest, push_requested_cb_for_opp_server_p, + NULL); + + ret = bt_opp_server_set_destination(NULL); + dts_check_eq("bt_opp_server_set_destination", ret, + BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned destination parameter is NULL"); +} + +static void utc_network_bluetooth_opp_server_initialize_by_connection_request_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_opp_server_initialize_by_connection_request(NULL, NULL, NULL); + dts_check_eq("bt_opp_server_initialize_by_connection_request", ret, + BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned destination parameter is NULL"); + +} diff --git a/TC/testcase/utc_network_bluetooth_opp-server_positive.c b/TC/testcase/utc_network_bluetooth_opp-server_positive.c new file mode 100755 index 0000000..39efb77 --- /dev/null +++ b/TC/testcase/utc_network_bluetooth_opp-server_positive.c @@ -0,0 +1,224 @@ +/* + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static void startup(void); +static void cleanup(void); + +static GMainLoop *mainloop; +const char *dest = "/tmp"; + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_network_bluetooth_opp_server_initialize_p(void); +static void utc_network_bluetooth_opp_server_initialize_by_connection_request_p(void); +static void utc_network_bluetooth_opp_server_deinitialize_p(void); +static void utc_network_bluetooth_opp_server_accept_p(void); +static void utc_network_bluetooth_opp_server_reject_p(void); +static void utc_network_bluetooth_opp_server_set_destination_p(void); + +void push_requested_cb_for_opp_server_p(const char *file, int size, void *user_data); +void connection_requested_cb_for_opp_server_p(const char *remote_address, + void *user_data); +void adapter_state_changed_cb_for_opp_server_p(int result, + bt_adapter_state_e adapter_state, void *user_data); +void transfer_finished_cb_for_opp_server_p(int result, const char *file, + long long size, void *user_data); +void transfer_progress_cb_for_opp_server_p(int result, const char *file, + long long size, void *user_data); + + +gboolean timeout_func(gpointer data); + + +struct tet_testlist tet_testlist[] = { + {utc_network_bluetooth_opp_server_initialize_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_opp_server_initialize_by_connection_request_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_opp_server_set_destination_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_opp_server_accept_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_opp_server_reject_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_opp_server_deinitialize_p, POSITIVE_TC_IDX}, + {NULL, 0}, +}; + +static void startup(void) +{ + int ret = BT_ERROR_NONE; + int timeout_id = 0; + + /* start of TC */ + mainloop = g_main_loop_new(NULL, FALSE); + + bt_initialize(); + if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_opp_server_p, "startup") != BT_ERROR_NONE) { + tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed"); + } + + tet_printf("bt_adapter_enable() was called."); + ret = bt_adapter_enable(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_adapter_enable() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else if (ret != BT_ERROR_ALREADY_DONE) { + tet_printf("DTS may fail because bt_adapter_disable() failed"); + } else if (ret == BT_ERROR_NOT_ENABLED) { + tet_printf("Bluetooth adapter is not enabled."); + } else { + tet_printf("DTS may fail because bt_adapter_disable() failed"); + } + + if (bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE) { + tet_printf("bt_adapter_set_state_changed_cb() failed."); + } + + tet_printf("TC start"); +} + + +static void cleanup(void) +{ + /* end of TC */ + bt_deinitialize(); + tet_printf("TC end."); +} + + +gboolean timeout_func(gpointer data) +{ + tet_printf("Callback: Timeout."); + g_main_loop_quit((GMainLoop *)data); + return FALSE; +} + + +void adapter_state_changed_cb_for_opp_server_p(int result, + bt_adapter_state_e adapter_state, void *user_data) +{ + +} + + +void push_requested_cb_for_opp_server_p(const char *file, int size, + void *user_data) +{ + +} + +void connection_requested_cb_for_opp_server_p(const char *remote_address, + void *user_data) +{ + +} + +void transfer_progress_cb_for_opp_server_p(int result, const char *file, + long long size, void *user_data) +{ + +} + +void transfer_finished_cb_for_opp_server_p(int result, const char *file, + long long size, void *user_data) +{ + +} + +static void utc_network_bluetooth_opp_server_initialize_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_opp_server_initialize(dest, push_requested_cb_for_opp_server_p, + NULL); + + if (ret != BT_ERROR_RESOURCE_BUSY) { + dts_check_eq("bt_opp_server_initialize", ret, BT_ERROR_NONE, + "bt_opp_server_initialize() failed"); + } else { + dts_check_eq("bt_opp_server_initialize", ret, BT_ERROR_RESOURCE_BUSY, + "bt_opp_server_initialize() failed"); + } + + +} + +static void utc_network_bluetooth_opp_server_deinitialize_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_opp_server_deinitialize(); + dts_check_eq("bt_opp_server_deinitialize", ret, BT_ERROR_NONE, + "bt_opp_server_deinitialize() failed."); +} + +static void utc_network_bluetooth_opp_server_accept_p(void) +{ + int ret = BT_ERROR_NONE; + int tid = 0; + const char *name = "abc"; + ret = bt_opp_server_accept(transfer_progress_cb_for_opp_server_p, + transfer_finished_cb_for_opp_server_p, name, NULL, &tid); + dts_check_eq("bt_opp_server_accept", ret, + BT_ERROR_NONE, "bt_opp_server_accept() failed."); + +} + +static void utc_network_bluetooth_opp_server_reject_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_opp_server_reject(); + dts_check_eq("bt_opp_server_reject", ret, + BT_ERROR_NONE, "bt_opp_server_reject() failed."); +} + +static void utc_network_bluetooth_opp_server_set_destination_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_opp_server_set_destination(dest); + dts_check_eq("bt_opp_server_set_destination", ret, + BT_ERROR_NONE, "bt_opp_server_destination() failed"); +} + +static void utc_network_bluetooth_opp_server_initialize_by_connection_request_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_opp_server_initialize_by_connection_request(dest, + connection_requested_cb_for_opp_server_p, NULL); + dts_check_eq("bt_opp_server_initialize_by_connection_request", ret, + BT_ERROR_NONE, + "bt_opp_server_initialize_by_connection_request() failed"); + +} + + + + + + diff --git a/TC/testcase/utc_network_bluetooth_pan_negative.c b/TC/testcase/utc_network_bluetooth_pan_negative.c new file mode 100755 index 0000000..ec9db0c --- /dev/null +++ b/TC/testcase/utc_network_bluetooth_pan_negative.c @@ -0,0 +1,166 @@ +/* + * utc_network_bluetooth_pan_negative.c + * + * Created on: 20-Sep-2013 + * Author: mrinal.m + */ + +#include "bluetooth.h" +#include +#include + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static void startup(void); +static void cleanup(void); + +static GMainLoop *mainloop; + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_network_bluetooth_nap_set_connection_state_changed_n(void); +static void utc_network_bluetooth_panu_set_connection_state_changed_n(void); +static void utc_network_bluetooth_panu_connect_n(void); +static void utc_network_bluetooth_nap_disconnect_n(void); +static void utc_network_bluetooth_panu_disconnect_n(void); + +void adapter_state_changed_cb_for_pan_n(int result, + bt_adapter_state_e adapter_state, void *user_data); +gboolean timeout_func(gpointer data); + + +struct tet_testlist tet_testlist[] = { + {utc_network_bluetooth_nap_set_connection_state_changed_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_panu_set_connection_state_changed_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_panu_connect_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_nap_disconnect_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_panu_disconnect_n, NEGATIVE_TC_IDX}, + {NULL, 0}, +}; + +static void startup(void) +{ + int ret = BT_ERROR_NONE; + int timeout_id = 0; + + /* start of TC */ + mainloop = g_main_loop_new(NULL, FALSE); + + bt_initialize(); + if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_pan_n, "startup") != BT_ERROR_NONE) { + tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed"); + } + + tet_printf("bt_adapter_disable() was called."); + ret = bt_adapter_disable(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_adapter_disable() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else if (ret == BT_ERROR_NOT_ENABLED) { + tet_printf("Bluetooth adapter is not enabled."); + } else { + tet_printf("DTS may fail because bt_adapter_disable() failed"); + } + + if (bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE) { + tet_printf("bt_adapter_set_state_changed_cb() failed."); + } + + tet_printf("TC start"); +} + + +static void cleanup(void) +{ + /* end of TC */ + bt_deinitialize(); + tet_printf("TC end."); +} + + +gboolean timeout_func(gpointer data) +{ + tet_printf("Callback: Timeout."); + g_main_loop_quit((GMainLoop *)data); + return FALSE; +} + + + + +/** + * @brief Negative test case of bt_nap_set_connection_state_changed_cb() + */ + +void adapter_state_changed_cb_for_pan_n(int result, + bt_adapter_state_e adapter_state, + void *user_data) +{ + +} + +static void utc_network_bluetooth_nap_set_connection_state_changed_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_nap_set_connection_state_changed_cb(NULL, NULL); + dts_check_eq("bt_nap_set_connection_state_changed_cb", ret, + BT_ERROR_INVALID_PARAMETER, + "bt_nap_set_connection_state_changed_cb() failed."); + +} + +/** + * @brief Negative test case of bt_panu_set_connection_state_changed_cb() + */ +static void utc_network_bluetooth_panu_set_connection_state_changed_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_panu_set_connection_state_changed_cb(NULL, NULL); + dts_check_eq("bt_panu_set_connection_state_changed_cb", ret, + BT_ERROR_INVALID_PARAMETER, + "bt_panu_set_connection_state_changed_cb() failed."); + +} + +/** + * @brief Negative test case of bt_panu_connect() + */ +static void utc_network_bluetooth_panu_connect_n(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_panu_connect(NULL, BT_PANU_SERVICE_TYPE_NAP); + dts_check_eq("bt_panu_connect", ret, BT_ERROR_INVALID_PARAMETER, + "bt_panu_connect() failed."); + +} + +/** + * @brief Negative test case of bt_nap_disconnect() + */ +static void utc_network_bluetooth_nap_disconnect_n(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_nap_disconnect(NULL); + dts_check_eq("bt_nap_disconnect", ret, BT_ERROR_INVALID_PARAMETER, + "bt_nap_disconnect() failed."); + +} +/** + * @brief Negative test case of bt_panu_disconnect() + */ +static void utc_network_bluetooth_panu_disconnect_n(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_panu_disconnect(NULL); + dts_check_eq("bt_panu_disconnect", ret, BT_ERROR_INVALID_PARAMETER, + "bt_panu_disconnect() failed."); + +} diff --git a/TC/testcase/utc_network_bluetooth_pan_positive.c b/TC/testcase/utc_network_bluetooth_pan_positive.c new file mode 100755 index 0000000..4526508 --- /dev/null +++ b/TC/testcase/utc_network_bluetooth_pan_positive.c @@ -0,0 +1,265 @@ +/* + * utc_network_bluetooth_pan_positive.c + * + * Created on: 20-Sep-2013 + * Author: mrinal.m + */ + +#include +#include +#include + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static void startup(void); +static void cleanup(void); + +static GMainLoop *mainloop; + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_network_bluetooth_nap_activate_p(void); +static void utc_network_bluetooth_nap_deactivate_p(void); +static void utc_network_bluetooth_nap_disconnect_all_p(void); +static void utc_network_bluetooth_nap_set_connection_state_changed_p(void); +static void utc_network_bluetooth_nap_unset_connection_state_changed_p(void); +static void utc_network_bluetooth_panu_set_connection_state_changed_p(void); +static void utc_network_bluetooth_panu_unset_connection_state_changed_p(void); +static void utc_network_bluetooth_panu_connect_p(void); +static void utc_network_bluetooth_nap_disconnect_p(void); +static void utc_network_bluetooth_panu_disconnect_p(void); + +void connection_state_changed_cb_for_nap_p(bool connected, + const char *remote_address, + const char *interface_name, + void *user_data); +void connection_state_changed_cb_for_panu_p(int result, + bool connected, + const char *remote_address, + bt_panu_service_type_e type, + void *user_data); + +void adapter_state_changed_cb_for_pan_p(int result, + bt_adapter_state_e adapter_state, + void *user_data); +gboolean timeout_func(gpointer data); + +struct tet_testlist tet_testlist[] = { + {utc_network_bluetooth_nap_activate_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_nap_set_connection_state_changed_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_nap_unset_connection_state_changed_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_nap_deactivate_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_nap_disconnect_all_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_panu_connect_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_panu_set_connection_state_changed_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_panu_unset_connection_state_changed_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_nap_disconnect_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_panu_disconnect_p, POSITIVE_TC_IDX}, + {NULL, 0}, +}; + + +static void startup(void) +{ + int ret = BT_ERROR_NONE; + int timeout_id = 0; + + /* start of TC */ + mainloop = g_main_loop_new(NULL, FALSE); + + bt_initialize(); + if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_pan_p, "startup") != BT_ERROR_NONE) { + tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed"); + } + + tet_printf("bt_adapter_enable() was called."); + + ret = bt_adapter_enable(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_adapter_enable() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else if (ret != BT_ERROR_ALREADY_DONE) { + tet_printf("DTS may fail because bt_adapter_disable() failed"); + } + + if (bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE) { + tet_printf("bt_adapter_set_state_changed_cb() failed."); + } + + tet_printf("TC start"); +} + +static void cleanup(void) +{ + /* end of TC */ + bt_deinitialize(); + tet_printf("TC end."); +} + +gboolean timeout_func(gpointer data) +{ + tet_printf("Callback: Timeout."); + g_main_loop_quit((GMainLoop *) data); + return FALSE; +} + +/** + * @brief Callback funtions +*/ + +void adapter_state_changed_cb_for_pan_p(int result, + bt_adapter_state_e adapter_state, + void *user_data) +{ + +} + +void connection_state_changed_cb_for_nap_p(bool connected, + const char *remote_address, + const char *interface_name, + void *user_data) +{ + +} + +void connection_state_changed_cb_for_panu_p(int result, + bool connected, + const char *remote_address, + bt_panu_service_type_e type, + void *user_data) +{ + +} + +/** + * @brief Positive test case of bt_nap_activate() +*/ +static void utc_network_bluetooth_nap_activate_p(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_nap_activate(); + if (ret != BT_ERROR_ALREADY_DONE) { + dts_check_eq("bt_nap_activate", ret, BT_ERROR_NONE, "bt_nap_activate() failed."); + } else { + dts_check_eq("bt_nap_activate", ret, BT_ERROR_ALREADY_DONE, + "bt_nap_activate() failed."); + } +} + +/** + * @brief Positive test case of bt_nap_deactivate() +*/ +static void utc_network_bluetooth_nap_deactivate_p(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_nap_deactivate(); + dts_check_eq("bt_nap_deactivate", ret, BT_ERROR_NONE, + "bt_nap_deactivate() failed."); + +} + +/** + * @brief Positive test case of bt_nap_disconnect_all() + */ +static void utc_network_bluetooth_nap_disconnect_all_p(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_nap_disconnect_all(); + dts_check_eq("bt_nap_disconnect_all", ret, BT_ERROR_NONE, + "bt_nap_disconnect_all() failed."); +} + +/** + * @brief Positive test case of bt_nap_set_connection_state_changed_cb() + */ +static void utc_network_bluetooth_nap_set_connection_state_changed_p(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_nap_set_connection_state_changed_cb(connection_state_changed_cb_for_nap_p, NULL); + dts_check_eq("bt_nap_set_connection_state_changed_cb", ret, BT_ERROR_NONE, + "bt_nap_set_connection_state_changed_cb() failed."); +} + + +/** + * @brief Positive test case of bt_nap_unset_connection_state_changed_cb() +*/ +static void utc_network_bluetooth_nap_unset_connection_state_changed_p(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_nap_unset_connection_state_changed_cb(); + dts_check_eq("bt_nap_unset_connection_state_changed_cb", ret, BT_ERROR_NONE, + "bt_nap_unset_connection_state_changed_cb() failed."); +} + + +/** + * @brief Positive test case of bt_panu_set_connection_state_changed_cb() +*/ +static void utc_network_bluetooth_panu_set_connection_state_changed_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_panu_set_connection_state_changed_cb(connection_state_changed_cb_for_panu_p, NULL); + dts_check_eq("bt_panu_set_connection_state_changed_cb", ret, BT_ERROR_NONE, + "bt_panu_set_connection_state_changed_cb() failed."); + +} + + +/** + * @brief Positive test case of bt_panu_unset_connection_state_changed_cb() +*/ +static void utc_network_bluetooth_panu_unset_connection_state_changed_p(void) +{ + int ret = BT_ERROR_NONE; + ret = bt_panu_unset_connection_state_changed_cb(); + dts_check_eq("bt_panu_unset_connection_state_changed_cb", ret, BT_ERROR_NONE, + "bt_panu_unset_connection_state_changed_cb() failed."); + +} + +/** + * @brief Positive test case of bt_panu_connect() +*/ +static void utc_network_bluetooth_panu_connect_p(void) +{ + int ret = BT_ERROR_NONE; + const char *remote_address = "00:00:00:00:00:00"; + ret = bt_panu_connect(remote_address, BT_PANU_SERVICE_TYPE_NAP); + dts_check_eq("bt_panu_connect", ret, BT_ERROR_NONE, + "bt_panu_connect() failed."); + +} + +/** + * @brief Positive test case of bt_nap_disconnect() +*/ +static void utc_network_bluetooth_nap_disconnect_p(void) +{ + int ret = BT_ERROR_NONE; + const char *remote_address = "00:00:00:00:00:00"; + ret = bt_nap_disconnect(remote_address); + dts_check_eq("bt_nap_disconnect", ret, BT_ERROR_NONE, + "bt_nap_disconnect() failed."); + +} + +/** + * @brief Positive test case of bt_panu_disconnect() +*/ +static void utc_network_bluetooth_panu_disconnect_p(void) +{ + int ret = BT_ERROR_NONE; + const char *remote_address = "00:00:00:00:00:00"; + ret = bt_panu_disconnect(remote_address); + dts_check_eq("bt_panu_disconnect", ret, BT_ERROR_NONE, + "bt_panu_disconnect() failed."); + +} diff --git a/TC/testcase/utc_network_bluetooth_service_search_negative.c b/TC/testcase/utc_network_bluetooth_service_search_negative.c new file mode 100755 index 0000000..ce4dd7d --- /dev/null +++ b/TC/testcase/utc_network_bluetooth_service_search_negative.c @@ -0,0 +1,179 @@ +/* + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static void startup(void); +static void cleanup(void); + +static GMainLoop *mainloop; + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_network_bluetooth_service_search_set_cb_n(void); +static void utc_network_bluetooth_service_search_unset_cb_n(void); +static void utc_network_bluetooth_service_search_n(void); +static void utc_network_bluetooth_service_search_cancel_n(void); + +void adapter_state_changed_cb_for_service_search_n(int result, + bt_adapter_state_e adapter_state, + void *user_data); +gboolean timeout_func(gpointer data); + +struct tet_testlist tet_testlist[] = { + {utc_network_bluetooth_service_search_set_cb_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_service_search_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_service_search_cancel_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_service_search_unset_cb_n, NEGATIVE_TC_IDX}, + {NULL, 0}, +}; + +static void startup(void) +{ + int ret = BT_ERROR_NONE; + int timeout_id = 0; + + /* start of TC */ + mainloop = g_main_loop_new(NULL, FALSE); + + bt_initialize(); + if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_service_search_n, "startup") != BT_ERROR_NONE) { + tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed"); + } + + tet_printf("bt_adapter_disable() was called."); + ret = bt_adapter_disable(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_adapter_disable() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else if (ret == BT_ERROR_NOT_ENABLED) { + tet_printf("Bluetooth adapter is not enabled."); + } else { + tet_printf("DTS may fail because bt_adapter_disable() failed"); + } + + if (bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE) { + tet_printf("bt_adapter_set_state_changed_cb() failed."); + } + + tet_printf("TC start"); +} + + +static void cleanup(void) +{ + /* end of TC */ + bt_deinitialize(); + tet_printf("TC end."); +} + + +gboolean timeout_func(gpointer data) +{ + tet_printf("Callback: Timeout."); + g_main_loop_quit((GMainLoop *) data); + return FALSE; +} + + +/** + * @brief Callback funtions + */ +void adapter_state_changed_cb_for_service_search_n(int result, + bt_adapter_state_e adapter_state, + void *user_data) +{ + tet_printf("Callback: bt_adapter_state_changed_cb was called."); + if (user_data != NULL && !strcmp((char *)user_data, "startup")) { + if (adapter_state == BT_ADAPTER_DISABLED && result == BT_ERROR_NONE) { + tet_printf("Callback: BT was disabled. DTS will be started."); + } else { + tet_printf("Callback: BT was not disabled. DTS will be started but DTS may fail."); + } + + if (mainloop) { + g_main_loop_quit(mainloop); + } + } +} + +/** + * @brief Negative test case of bt_device_set_service_searched_cb() + */ +static void utc_network_bluetooth_service_search_set_cb_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_device_set_service_searched_cb(NULL, NULL); + dts_check_eq("bt_device_set_service_searched_cb", ret, + BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when callback parameter is NULL"); +} + +/** + * @brief Negative test case of bt_device_unset_service_searched_cb() + */ +static void utc_network_bluetooth_service_search_unset_cb_n(void) +{ + int ret = BT_ERROR_NONE; + + if (bt_deinitialize() != BT_ERROR_NONE) { + dts_fail("bt_device_unset_service_searched_cb", + "bt_deinitialize() failed."); + } + + ret = bt_device_unset_service_searched_cb(); + dts_check_eq("bt_device_unset_service_searched_cb", ret, + BT_ERROR_NOT_INITIALIZED, + "BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized."); +} + +/** + * @brief Negative test case of bt_device_start_service_search() + */ +static void utc_network_bluetooth_service_search_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_device_start_service_search(NULL); + dts_check_eq("bt_device_start_service_search", ret, + BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL"); +} + +/** + * @brief Negative test case of bt_device_cancel_service_search() + */ +static void utc_network_bluetooth_service_search_cancel_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_device_cancel_service_search(); + dts_check_eq("bt_device_cancel_service_search", ret, BT_ERROR_NOT_ENABLED, + "BT_ERROR_NOT_ENABLED must be returned when BT is not enabled"); +} diff --git a/TC/testcase/utc_network_bluetooth_service_search_positive.c b/TC/testcase/utc_network_bluetooth_service_search_positive.c new file mode 100755 index 0000000..b0c5e70 --- /dev/null +++ b/TC/testcase/utc_network_bluetooth_service_search_positive.c @@ -0,0 +1,406 @@ +/* + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include + +#define CONFIG_FILE_PATH "/opt/home/capi-network-bluetooth/tetware.conf" +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +char target_name[128] = "dts_test"; +char *target_address; +bool callback_result = false; +bool discovery_result = false; +bool bonding_result = false; +static GMainLoop *mainloop; + +static void utc_network_bluetooth_service_search_set_cb_p(void); +static void utc_network_bluetooth_service_search_p(void); +static void utc_network_bluetooth_service_search_cancel_p(void); +static void utc_network_bluetooth_service_search_unset_cb_p(void); + +gboolean timeout_func(gpointer data); +void adapter_state_changed_cb_for_service_search_p(int result, + bt_adapter_state_e adapter_state, void *user_data); +void device_discovery_state_changed_cb_for_service_search_p(int result, + bt_adapter_device_discovery_state_e discovery_state, + bt_adapter_device_discovery_info_s *discovery_info, void *user_data); +void service_searched_cb_for_service_search_p(int result, + bt_device_sdp_info_s *sdp_info, void *user_data); +void device_bonded_cb_for_service_search_p(int result, + bt_device_info_s *device_info, void *user_data); +void device_unbonded_cb(int result, char *remote_address, void *user_data); + +struct tet_testlist tet_testlist[] = { + {utc_network_bluetooth_service_search_set_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_service_search_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_service_search_cancel_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_service_search_unset_cb_p, POSITIVE_TC_IDX}, + {NULL, 0}, +}; + +int get_value_from_file(void) +{ + FILE *fp; + char *token; + char buf[100]; + + fp = fopen(CONFIG_FILE_PATH, "r"); + if (fp == NULL) { + tet_printf("Default configuration is used\n"); + return -1; + } + while (fgets(buf, sizeof(buf), fp)) { + if (buf[0] == '#' || buf[0] == '\n') + continue; + + token = strrchr(buf, '\n'); + if (token == NULL) { + tet_printf("g_conf is too long\n"); + break; + } + *token = '\0'; + + token = strtok(buf, "="); + if (token == NULL) { + continue; + } + if (strcasecmp(token, "BT_ADDR_MOBILE") == 0) { + token = strtok(NULL, "="); + target_address = strdup(token); + fclose(fp); + return 0; + } + } + return -1; +} + +static void startup(void) +{ + bt_error_e ret = BT_ERROR_NONE; + int timeout_id = 0; + + if(get_value_from_file() == -1) { + tet_printf("Failed to read."); + } + + /* start of TC */ + callback_result = false; + discovery_result = false; + mainloop = g_main_loop_new(NULL, FALSE); + + bt_initialize(); + + if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_service_search_p, "startup") != BT_ERROR_NONE) { + tet_printf("bt_adapter_set_state_changed_cb() failed."); + } + + if (bt_adapter_set_device_discovery_state_changed_cb + (device_discovery_state_changed_cb_for_service_search_p, "startup") != BT_ERROR_NONE) { + tet_printf("bt_adapter_set_device_discovery_state_changed_cb() failed."); + } + + ret = bt_adapter_enable(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_adapter_enable() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + + tet_printf("BT was enabled. Device discovery will be started"); + if (bt_adapter_start_device_discovery() == BT_ERROR_NONE) { + tet_printf("bt_adapter_start_device_discovery() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else { + tet_printf("bt_adapter_start_device_discovery() failed."); + } + } else if (ret == BT_ERROR_ALREADY_DONE) { + tet_printf("BT was already enabled. Device discovery will be started"); + if (bt_adapter_start_device_discovery() == BT_ERROR_NONE) { + tet_printf("bt_adapter_start_device_discovery() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else { + tet_printf("bt_adapter_start_device_discovery() failed."); + } + } else { + tet_printf("DTS may fail because bt_adapter_enable() failed."); + } + + if (bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE) { + tet_printf("bt_adapter_unset_state_changed_cb() failed."); + } + + if (bt_adapter_unset_device_discovery_state_changed_cb() != BT_ERROR_NONE) { + tet_printf("bt_adapter_unset_device_discovery_state_changed_cb() failed."); + } + + tet_printf("TC start."); +} + + +static void cleanup(void) +{ + /* end of TC */ + int timeout_id = 0; + + /* Destroy a bond */ + bt_device_set_bond_destroyed_cb(device_unbonded_cb, NULL); + if (bt_device_destroy_bond(target_address) == BT_ERROR_NONE) { + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } + + bt_deinitialize(); + tet_printf("TC end."); +} + + +gboolean timeout_func(gpointer data) +{ + tet_printf("[%s] Callback: Timeout.", __FUNCTION__); + g_main_loop_quit((GMainLoop *) data); + return FALSE; +} + + +/** + * @brief Callback funtions + */ +void device_unbonded_cb(int result, char *remote_address, void *user_data) +{ + tet_printf("Callback: bt_device_bond_destroyed_cb() was called."); + + if (mainloop) { + g_main_loop_quit(mainloop); + } + +} + +void adapter_state_changed_cb_for_service_search_p(int result, + bt_adapter_state_e adapter_state, void *user_data) +{ + tet_printf("Callback: bt_adapter_state_changed_cb() was called"); + if (user_data != NULL && !strcmp((char *)user_data, "startup")) { + if (adapter_state == BT_ADAPTER_ENABLED && result == BT_ERROR_NONE) { + tet_printf("Callback: BT was enabled."); + } else { + tet_printf("Callback: BT was not enabled. DTS will be started but DTS may fail."); + } + + if (mainloop) { + g_main_loop_quit(mainloop); + } + } +} + +void device_discovery_state_changed_cb_for_service_search_p(int result, + bt_adapter_device_discovery_state_e discovery_state, + bt_adapter_device_discovery_info_s *discovery_info, void *user_data) +{ + tet_printf("Callback: bt_adapter_device_discovery_state_changed_cb() was called"); + if (user_data != NULL && !strcmp((char *)user_data, "startup")) { + if (discovery_state == BT_ADAPTER_DEVICE_DISCOVERY_FINISHED) { + tet_printf("Callback: Device discovery finished. DTS will be started."); + if (mainloop) { + g_main_loop_quit(mainloop); + } + } else if (discovery_state == BT_ADAPTER_DEVICE_DISCOVERY_FOUND) { + tet_printf("Callback: Devices were founded (%s)", + discovery_info->remote_name); + if (discovery_info->remote_name != NULL && !strcmp(discovery_info->remote_name, target_name)) { + discovery_result = true; + tet_printf("Callback: dts_test device was found."); + strncpy(target_address, discovery_info->remote_address, 18); + tet_printf("Callback: device address: %s", discovery_info->remote_address); + if (bt_adapter_stop_device_discovery() == BT_ERROR_NONE) { + tet_printf("Callback: Device discovery will be stopped"); + } + } + } + } +} + +void service_searched_cb_for_service_search_p(int result, + bt_device_sdp_info_s *sdp_info, + void *user_data) +{ + int i = 0; + + tet_printf("Callback: bt_device_service_searched_cb() was called."); + if (result == BT_ERROR_NONE) { + if (sdp_info != NULL && !strcmp(sdp_info->remote_address, target_address)) { + tet_printf("Callback: Service search succeeded."); + tet_printf("Callback: Service count : %d", sdp_info->service_count); + for (i = 0; i < sdp_info->service_count; i++) { + tet_printf("Callback: uuid[%d] - %s", i + 1, sdp_info->service_uuid[i]); + } + + callback_result = true; + } + } else if (result == BT_ERROR_CANCELLED) { + if (sdp_info != NULL && !strcmp(sdp_info->remote_address, target_address)) { + tet_printf("Callback: Calcellation of service search succeeded."); + callback_result = true; + } + } else { + tet_printf("Callback: Failed."); + } + + if (mainloop) { + g_main_loop_quit(mainloop); + } +} + +void device_bonded_cb_for_service_search_p(int result, + bt_device_info_s *device_info, void *user_data) +{ + if (user_data != NULL && !strcmp((char *)user_data, "startup")) { + if (device_info->remote_address != NULL && !strcmp(device_info->remote_address, target_address)) { + if (result == BT_ERROR_NONE) { + tet_printf("Callback: Bonding succeeded"); + bonding_result = true; + } else { + tet_printf("Callback: Bonding failed"); + } + } + } + + if (mainloop) { + g_main_loop_quit(mainloop); + } +} + +/** + * @brief Positive test case of bt_device_set_service_searched_cb() + */ +static void utc_network_bluetooth_service_search_set_cb_p(void) +{ + int ret = BT_ERROR_NONE; + int timeout_id = 0; + + ret = bt_device_set_service_searched_cb(service_searched_cb_for_service_search_p, NULL); + if (ret == BT_ERROR_NONE) { + if (bt_device_set_bond_created_cb(device_bonded_cb_for_service_search_p, "startup") != BT_ERROR_NONE) { + tet_printf("bt_device_set_bond_created_cb() failed."); + } + + if (discovery_result == true && bt_device_create_bond(target_address) == BT_ERROR_NONE) { + tet_printf("bt_device_create_bond() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else { + tet_printf("bt_device_create_bond() failed."); + } + } + + dts_check_eq("bt_device_set_service_searched_cb", ret, BT_ERROR_NONE, + "bt_device_set_service_searched_cb() failed."); +} + +/** + * @brief Positive test case of bt_device_start_service_search() + */ +static void utc_network_bluetooth_service_search_p(void) +{ + int timeout_id = 0; + int ret = BT_ERROR_NONE; + + if (discovery_result != true) { + tet_printf("bt_device_start_service_search failed."); + } + + callback_result = false; + ret = bt_device_start_service_search(target_address); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_device_start_service_search() succeeded."); + tet_printf("service_searched_cb_for_service_search_p() will be called."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + dts_check_eq("bt_device_start_service_search", ret, BT_ERROR_NONE, + "bt_device_start_service_search() failed."); + } else { + dts_fail("bt_device_start_service_search", + "bt_device_start_service_search() failed."); + } +} + +/** + * @brief Positive test case of bt_device_cancel_service_search() + */ +static void utc_network_bluetooth_service_search_cancel_p(void) +{ + int timeout_id = 0; + int ret = BT_ERROR_NONE; + + if (discovery_result != true) { + tet_printf("t_device_cancel_service_search failed."); + } + + callback_result = false; + if (bt_device_start_service_search(target_address) != BT_ERROR_NONE) { + tet_printf("t_device_start_service_search failed."); + + } else { + tet_printf("bt_device_cancel_service_search", + "bt_device_start_service_search() succeeded."); + } + + ret = bt_device_cancel_service_search(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_device_cancel_service_search() succeeded."); + tet_printf("service_searched_cb_for_service_search_p() will be called."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + dts_check_eq("bt_device_cancel_service_search", ret, BT_ERROR_NONE, + "bt_device_cancel_service_search() failed."); + + } else { + dts_fail("bt_device_cancel_service_search", + "bt_device_cancel_service_search() failed."); + } +} + +/** + * @brief Positive test case of bt_device_unset_service_searched_cb() + */ +static void utc_network_bluetooth_service_search_unset_cb_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_device_unset_service_searched_cb(); + dts_check_eq("bt_device_unset_service_searched_cb", ret, BT_ERROR_NONE, + "bt_device_set_service_searched_cb() failed."); +} diff --git a/TC/testcase/utc_network_bluetooth_socket_negative.c b/TC/testcase/utc_network_bluetooth_socket_negative.c new file mode 100755 index 0000000..dea118f --- /dev/null +++ b/TC/testcase/utc_network_bluetooth_socket_negative.c @@ -0,0 +1,268 @@ +/* + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static void startup(void); +static void cleanup(void); + +static GMainLoop *mainloop; + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +static void utc_network_bluetooth_socket_set_data_received_cb_n(void); +static void utc_network_bluetooth_socket_set_connection_state_changed_cb_n(void); +static void utc_network_bluetooth_socket_unset_data_received_cb_n(void); +static void utc_network_bluetooth_socket_unset_connection_state_changed_cb_n(void); +static void utc_network_bluetooth_socket_create_rfcomm_n(void); +static void utc_network_bluetooth_socket_destroy_rfcomm_n(void); +static void utc_network_bluetooth_socket_listen_and_accept_rfcomm_n(void); +static void utc_network_bluetooth_socket_connect_rfcomm_n(void); +static void utc_network_bluetooth_socket_disconnect_rfcomm_n(void); +static void utc_network_bluetooth_socket_send_data_n(void); + +void adapter_state_changed_cb_for_device_negative(int result, + bt_adapter_state_e adapter_state, void *user_data); +gboolean timeout_func(gpointer data); + +struct tet_testlist tet_testlist[] = { + {utc_network_bluetooth_socket_create_rfcomm_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_socket_set_connection_state_changed_cb_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_socket_listen_and_accept_rfcomm_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_socket_set_data_received_cb_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_socket_connect_rfcomm_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_socket_send_data_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_socket_disconnect_rfcomm_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_socket_destroy_rfcomm_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_socket_unset_data_received_cb_n, NEGATIVE_TC_IDX}, + {utc_network_bluetooth_socket_unset_connection_state_changed_cb_n, NEGATIVE_TC_IDX}, + {NULL, 0}, +}; + +static void startup(void) +{ + int ret = BT_ERROR_NONE; + int timeout_id = 0; + + /* start of TC */ + mainloop = g_main_loop_new(NULL, FALSE); + + bt_initialize(); + if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_device_negative, "startup") != BT_ERROR_NONE) { + tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed"); + } + + tet_printf("bt_adapter_disable() was called."); + ret = bt_adapter_disable(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_adapter_disable() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else if (ret == BT_ERROR_NOT_ENABLED) { + tet_printf("Bluetooth adapter is not enabled."); + } else { + tet_printf("DTS may fail because bt_adapter_disable() failed"); + } + + if (bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE) { + tet_printf("bt_adapter_set_state_changed_cb() failed."); + } + + tet_printf("TC start"); +} + +static void cleanup(void) +{ + /* end of TC */ + bt_deinitialize(); + tet_printf("TC end."); +} + +gboolean timeout_func(gpointer data) +{ + tet_printf("Callback: Timeout."); + g_main_loop_quit((GMainLoop *) data); + return FALSE; +} + +/** + * @brief Callback funtions + */ +void adapter_state_changed_cb_for_device_negative(int result, + bt_adapter_state_e adapter_state, + void *user_data) +{ + tet_printf("Callback: bt_adapter_state_changed_cb was called."); + if (user_data != NULL && !strcmp((char *)user_data, "startup")) { + if (adapter_state == BT_ADAPTER_DISABLED && result == BT_ERROR_NONE) { + tet_printf("Callback: BT was disabled. DTS will be started."); + } else { + tet_printf("Callback: BT was not disabled. DTS will be started but DTS may fail."); + } + + if (mainloop) { + g_main_loop_quit(mainloop); + } + } +} + + + +/** + * @brief Negative test case of bt_socket_set_data_received_cb() + */ +static void utc_network_bluetooth_socket_set_data_received_cb_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_socket_set_data_received_cb(NULL, NULL); + dts_check_eq("bt_socket_set_data_received_cb", ret, + BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when callback parameter is NULL"); +} + +/** + * @brief Negative test case of bt_socket_set_connection_state_changed_cb() + */ +static void utc_network_bluetooth_socket_set_connection_state_changed_cb_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_socket_set_connection_state_changed_cb(NULL, NULL); + dts_check_eq("bt_socket_set_connection_state_changed_cb", ret, + BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when callback parameter is NULL"); +} + +/** + * @brief Negative test case of bt_socket_unset_data_received_cb() + */ +static void utc_network_bluetooth_socket_unset_data_received_cb_n(void) +{ + int ret = BT_ERROR_NONE; + + if (bt_deinitialize() != BT_ERROR_NONE) { + dts_fail("bt_socket_unset_data_received_cb", + "bt_deinitialize() failed."); + } + + ret = bt_socket_unset_data_received_cb(); + dts_check_eq("bt_socket_unset_data_received_cb", ret, + BT_ERROR_NOT_INITIALIZED, + "BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized."); +} + +/** + * @brief Negative test case of bt_socket_unset_connection_state_changed_cb() + */ +static void utc_network_bluetooth_socket_unset_connection_state_changed_cb_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_socket_unset_connection_state_changed_cb(); + dts_check_eq("bt_socket_unset_connection_state_changed_cb", ret, + BT_ERROR_NOT_INITIALIZED, + "BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized."); +} + +/** + * @brief Negative test case of bt_socket_create_rfcomm() + */ +static void utc_network_bluetooth_socket_create_rfcomm_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_socket_create_rfcomm(NULL, NULL); + dts_check_eq("bt_socket_create_rfcomm", ret, BT_ERROR_INVALID_PARAMETER, + "BT_ERROR_INVALID_PARAMETER must be returned when port_uuid parameter is NULL"); +} + +/** + * @brief Negative test case of bt_socket_destroy_rfcomm() + */ +static void utc_network_bluetooth_socket_destroy_rfcomm_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_socket_destroy_rfcomm(NULL); + dts_check_eq("bt_socket_listen_and_accept_rfcomm", ret, + BT_ERROR_NOT_ENABLED, + "BT_ERROR_INVALID_PARAMETER must be returned when socket_fd is below 0"); +} + + +/** + * @brief Negative test case of bt_socket_listen_and_accept_rfcomm() + */ +static void utc_network_bluetooth_socket_listen_and_accept_rfcomm_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_socket_listen_and_accept_rfcomm(1, 1); + dts_check_eq("bt_socket_listen_and_accept_rfcomm", ret, + BT_ERROR_NOT_ENABLED, + "BT_ERROR_NOT_ENABLED must be returned when BT is not enabled"); +} + +/** + * @brief Negative test case of bt_socket_connect_rfcomm() + */ +static void utc_network_bluetooth_socket_connect_rfcomm_n(void) +{ + int ret = BT_ERROR_NONE; + char *address = "00:02:79:AC:7D:FD"; + char *uuid = ""; + + ret = bt_socket_connect_rfcomm(address, uuid); + dts_check_eq("bt_socket_connect_rfcomm", ret, BT_ERROR_NOT_ENABLED, + "BT_ERROR_NOT_ENABLED must be returned when BT is not enabled"); +} + +/** + * @brief Negative test case of bt_socket_disconnect_rfcomm() + */ +static void utc_network_bluetooth_socket_disconnect_rfcomm_n(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_socket_disconnect_rfcomm(-1); + dts_check_eq("bt_socket_disconnect_rfcomm", ret, BT_ERROR_NOT_ENABLED, + "BT_ERROR_NOT_ENABLED must be returned when BT is not enabled"); +} + +/** + * @brief Negative test case of bt_socket_send_data() + */ +static void utc_network_bluetooth_socket_send_data_n(void) +{ + int ret = BT_ERROR_NONE; + char *data = "dts_test"; + + ret = bt_socket_send_data(1, data, sizeof(data)); + dts_check_eq("bt_socket_send_data", ret, BT_ERROR_NOT_ENABLED, + "BT_ERROR_NOT_ENABLED must be returned when BT is not enabled"); +} diff --git a/TC/testcase/utc_network_bluetooth_socket_positive.c b/TC/testcase/utc_network_bluetooth_socket_positive.c new file mode 100755 index 0000000..acaf2f9 --- /dev/null +++ b/TC/testcase/utc_network_bluetooth_socket_positive.c @@ -0,0 +1,477 @@ +/* + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include +#include +#include +#include + +#define CONFIG_FILE_PATH "/opt/home/capi-network-bluetooth/tetware.conf" + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +static void startup(void); +static void cleanup(void); + +void (*tet_startup) (void) = startup; +void (*tet_cleanup) (void) = cleanup; + +const char target_name[128] = "dts_test"; +const char *rfcomm_test_uuid_spp = "00001101-0000-1000-8000-00805F9B34FB"; +char *target_address; +int socket_fd = 0; +bool callback_result = false; +bool discovery_result = false; +bool bonding_result = false; +bool is_connecting = false; +static GMainLoop *mainloop; + +static void utc_network_bluetooth_socket_set_data_received_cb_p(void); +static void utc_network_bluetooth_socket_set_connection_state_changed_cb_p(void); + +static void utc_network_bluetooth_socket_create_rfcomm_p(void); +static void utc_network_bluetooth_socket_destroy_rfcomm_p(void); +static void utc_network_bluetooth_socket_listen_and_accept_rfcomm_p(void); +static void utc_network_bluetooth_socket_connect_rfcomm_p(void); +static void utc_network_bluetooth_socket_disconnect_rfcomm_p(void); +static void utc_network_bluetooth_socket_send_data_p(void); +static void utc_network_bluetooth_socket_unset_data_received_cb_p(void); +static void utc_network_bluetooth_socket_unset_connection_state_changed_cb_p(void); + +gboolean timeout_func(gpointer data); +void adapter_state_changed_cb_for_socket_p(int result, + bt_adapter_state_e adapter_state, void *user_data); +void device_discovery_state_changed_cb_for_socket_p(int result, + bt_adapter_device_discovery_state_e discovery_state, + bt_adapter_device_discovery_info_s *discovery_info, void *user_data); +void device_bonded_cb_for_socket_p(int result, bt_device_info_s *device_info, + void *user_data); +void socket_data_received_cb_for_socket_p(bt_socket_received_data_s *data, + void *user_data); +void socket_connection_state_changed_cb_for_socket_p(int result, + bt_socket_connection_state_e connection_state, + bt_socket_connection_s *connection, void *user_data); +void device_unbonded_cb(int result, char *remote_address, void *user_data); + +struct tet_testlist tet_testlist[] = { + {utc_network_bluetooth_socket_create_rfcomm_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_socket_set_connection_state_changed_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_socket_listen_and_accept_rfcomm_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_socket_set_data_received_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_socket_connect_rfcomm_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_socket_send_data_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_socket_disconnect_rfcomm_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_socket_destroy_rfcomm_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_socket_unset_data_received_cb_p, POSITIVE_TC_IDX}, + {utc_network_bluetooth_socket_unset_connection_state_changed_cb_p, POSITIVE_TC_IDX}, + {NULL, 0}, +}; + +int get_value_from_file(void) +{ + FILE *fp; + char *token; + char buf[100]; + + fp = fopen(CONFIG_FILE_PATH, "r"); + if (fp == NULL) { + tet_printf("Default configuration is used\n"); + return -1; + } + while (fgets(buf, sizeof(buf), fp)) { + if (buf[0] == '#' || buf[0] == '\n') + continue; + + token = strrchr(buf, '\n'); + if (token == NULL) { + tet_printf("g_conf is too long\n"); + break; + } + *token = '\0'; + + token = strtok(buf, "="); + if (token == NULL) { + continue; + } + if (strcasecmp(token, "BT_ADDR_MOBILE") == 0) { + token = strtok(NULL, "="); + target_address = strdup(token); + fclose(fp); + return 0; + } + } + return -1; +} + +static void startup(void) +{ + bt_error_e ret = BT_ERROR_NONE; + int timeout_id = 0; + + if(get_value_from_file() == -1) { + tet_printf("Failed to read."); + } + + /* start of TC */ + tet_printf("TC start."); + callback_result = false; + discovery_result = false; + bonding_result = false; + mainloop = g_main_loop_new(NULL, FALSE); + + bt_initialize(); + + if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_socket_p, "startup") != BT_ERROR_NONE) { + tet_printf("bt_adapter_set_state_changed_cb() failed."); + } + + if (bt_adapter_set_device_discovery_state_changed_cb(device_discovery_state_changed_cb_for_socket_p, "startup") != BT_ERROR_NONE) { + tet_printf("bt_adapter_set_device_discovery_state_changed_cb() failed."); + } + + if (bt_device_set_bond_created_cb(device_bonded_cb_for_socket_p, "startup") != BT_ERROR_NONE) { + tet_printf("bt_device_set_bond_created_cb() failed."); + } + + ret = bt_adapter_enable(); + if (ret == BT_ERROR_NONE) { + tet_printf("bt_adapter_enable() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + + tet_printf("BT was enabled. Device discovery will be started"); + if (bt_adapter_start_device_discovery() == BT_ERROR_NONE) { + tet_printf("bt_adapter_start_device_discovery() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else { + tet_printf("bt_adapter_start_device_discovery() failed."); + } + } else if (ret == BT_ERROR_ALREADY_DONE) { + tet_printf("BT was already enabled. Device discovery will be started"); + if (bt_adapter_start_device_discovery() == BT_ERROR_NONE) { + tet_printf("bt_adapter_start_device_discovery() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else { + tet_printf("bt_adapter_start_device_discovery() failed."); + } + } else { + tet_printf("DTS may fail because bt_adapter_enable() failed."); + } + + if (discovery_result == true && bt_device_create_bond(target_address) == BT_ERROR_NONE) { + tet_printf("bt_device_create_bond() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else { + tet_printf("bt_device_create_bond() failed."); + } + + if (bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE) { + tet_printf("bt_adapter_unset_state_changed_cb() failed."); + } + + if (bt_adapter_unset_device_discovery_state_changed_cb() != BT_ERROR_NONE) { + tet_printf("bt_adapter_unset_device_discovery_state_changed_cb() failed."); + } + + if (bt_device_unset_bond_created_cb() != BT_ERROR_NONE) { + tet_printf("bt_device_unset_bond_created_cb() failed."); + } + +} + +static void cleanup(void) +{ + /* end of TC */ + int timeout_id = 0; + + /* Destroy a bond */ + bt_device_set_bond_destroyed_cb(device_unbonded_cb, NULL); + if (bt_device_destroy_bond(target_address) == BT_ERROR_NONE) { + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } + + bt_deinitialize(); + tet_printf("TC end."); +} + +gboolean timeout_func(gpointer data) +{ + tet_printf("[%s] Callback: Timeout.", __FUNCTION__); + g_main_loop_quit((GMainLoop *) data); + return FALSE; +} + +/** + * @brief Callback funtions + */ +void device_unbonded_cb(int result, char *remote_address, void *user_data) +{ + tet_printf("Callback: bt_device_bond_destroyed_cb() was called."); + + if (mainloop) { + g_main_loop_quit(mainloop); + } + +} + +void adapter_state_changed_cb_for_socket_p(int result, + bt_adapter_state_e adapter_state, void *user_data) +{ + if (user_data != NULL && !strcmp((char *)user_data, "startup")) { + if (adapter_state == BT_ADAPTER_ENABLED && result == BT_ERROR_NONE) { + tet_printf("Callback: BT was enabled."); + bt_adapter_start_device_discovery(); + } else { + tet_printf("Callback: BT was not enabled. DTS will be started but DTS may fail."); + if (mainloop) { + g_main_loop_quit(mainloop); + } + } + } +} + +void device_discovery_state_changed_cb_for_socket_p(int result, + bt_adapter_device_discovery_state_e discovery_state, + bt_adapter_device_discovery_info_s *discovery_info, void *user_data) +{ + tet_printf("Callback: bt_adapter_device_discovery_state_changed_cb() was called"); + if (user_data != NULL && !strcmp((char *)user_data, "startup")) { + if (discovery_state == BT_ADAPTER_DEVICE_DISCOVERY_FINISHED) { + tet_printf("Callback: Device discovery finished. DTS will be started."); + if (mainloop) { + g_main_loop_quit(mainloop); + } + } else if (discovery_state == BT_ADAPTER_DEVICE_DISCOVERY_FOUND) { + tet_printf("Callback: Devices were founded (%s)", discovery_info->remote_name); + if (discovery_info->remote_name != NULL && !strcmp(discovery_info->remote_name, target_name)) { + discovery_result = true; + tet_printf("Callback: dts_test device was found."); + strncpy(target_address, discovery_info->remote_address, 18); + tet_printf("Callback: device address: %s", discovery_info->remote_address); + if (bt_adapter_stop_device_discovery() == BT_ERROR_NONE) { + tet_printf("Callback: Device discovery will be stopped"); + } + } + } + } +} + +void device_bonded_cb_for_socket_p(int result, bt_device_info_s *device_info, void *user_data) +{ + if ((user_data != NULL) && !strcmp((char *)user_data, "startup")) { + if ((device_info->remote_address != NULL) && + !strcmp(device_info->remote_address, target_address)) { + if (result == BT_ERROR_NONE) { + tet_printf("Callback: Bonding succeeded"); + bonding_result = true; + } else { + tet_printf("Callback: Bonding failed"); + } + } + } + + if (mainloop) { + g_main_loop_quit(mainloop); + } +} + +void socket_data_received_cb_for_socket_p(bt_socket_received_data_s *data, + void *user_data) +{ +} + +void socket_connection_state_changed_cb_for_socket_p(int result, + bt_socket_connection_state_e connection_state, + bt_socket_connection_s *connection, void *user_data) +{ + tet_printf("Callback: bt_socket_connection_state_changed_cb() was called"); + if (connection_state == BT_SOCKET_CONNECTED) + tet_printf("Callback: Connected"); + else + tet_printf("Callback: Disconnected"); + + if (connection_state == BT_SOCKET_CONNECTED) { + tet_printf("Callback: [BT_SOCKET_CONNECTED] result = %d", result); + if (result == BT_ERROR_NONE && is_connecting == true) { + callback_result = true; + socket_fd = connection->socket_fd; + tet_printf("Callback: socket_fd = %d", socket_fd); + + if (mainloop) { + g_main_loop_quit(mainloop); + } + } + } else if (connection_state == BT_SOCKET_DISCONNECTED) { + tet_printf("Callback: [BT_SOCKET_DISCONNECTED] result = %d", result); + if (result == BT_ERROR_NONE && is_connecting == false) { + callback_result = true; + socket_fd = connection->socket_fd; + tet_printf("Callback: socket_fd = %d", socket_fd); + + if (mainloop) { + g_main_loop_quit(mainloop); + } + } + } +} + +/** + * @brief Positive test case of bt_socket_set_data_received_cb() + */ +static void utc_network_bluetooth_socket_set_data_received_cb_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_socket_set_data_received_cb(socket_data_received_cb_for_socket_p, NULL); + dts_check_eq("bt_socket_set_data_received_cb", ret, BT_ERROR_NONE, + "bt_socket_set_data_received_cb() failed."); +} + +/** + * @brief Positive test case of bt_socket_set_connection_state_changed_cb() + */ +static void utc_network_bluetooth_socket_set_connection_state_changed_cb_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_socket_set_connection_state_changed_cb(socket_connection_state_changed_cb_for_socket_p, NULL); + dts_check_eq("bt_socket_set_connection_state_changed_cb", ret, + BT_ERROR_NONE, + "bt_socket_set_connection_state_changed_cb() failed."); +} + +/** + * @brief Positive test case of bt_socket_create_rfcomm() + */ +static void utc_network_bluetooth_socket_create_rfcomm_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_socket_create_rfcomm(rfcomm_test_uuid_spp, &socket_fd); + dts_check_eq("bt_socket_create_rfcomm", ret, BT_ERROR_NONE, + "bt_socket_create_rfcomm() failed."); +} + +/** + * @brief Positive test case of bt_socket_listen_and_accept_rfcomm() + */ +static void utc_network_bluetooth_socket_listen_and_accept_rfcomm_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_socket_listen_and_accept_rfcomm(socket_fd, 1); + dts_check_eq("bt_socket_listen_and_accept_rfcomm", ret, BT_ERROR_NONE, + "bt_socket_listen_and_accept_rfcomm() failed."); +} + +/** + * @brief Positive test case of bt_socket_destroy_rfcomm() + */ +static void utc_network_bluetooth_socket_destroy_rfcomm_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_socket_destroy_rfcomm(socket_fd); + dts_check_eq("bt_socket_destroy_rfcomm", ret, BT_ERROR_NONE, + "bt_socket_destroy_rfcomm() failed."); +} + +/** + * @brief Positive test case of bt_socket_connect_rfcomm() + */ +static void utc_network_bluetooth_socket_connect_rfcomm_p(void) +{ + int ret = BT_ERROR_NONE; + int timeout_id = 0; + + is_connecting = true; + callback_result = false; + ret = bt_socket_connect_rfcomm(target_address, rfcomm_test_uuid_spp); + if (ret == BT_ERROR_NONE) { + dts_check_eq("bt_socket_connect_rfcomm", ret, BT_ERROR_NONE, + "bt_socket_connect_rfcomm() failed."); + tet_printf("bt_socket_connect_rfcomm() succeeded."); + timeout_id = g_timeout_add(60000, timeout_func, mainloop); + g_main_loop_run(mainloop); + g_source_remove(timeout_id); + } else { + dts_fail("bt_socket_connect_rfcomm", + "bt_socket_connect_rfcomm() failed"); + } +} + +/** + * @brief Positive test case of bt_socket_disconnect_rfcomm() + */ +static void utc_network_bluetooth_socket_disconnect_rfcomm_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_socket_disconnect_rfcomm(socket_fd); + dts_check_eq("bt_socket_disconnect_rfcomm", ret, BT_ERROR_NONE, + "bt_socket_disconnect_rfcomm() failed."); +} + +/** + * @brief Positive test case of bt_socket_send_data() + */ +static void utc_network_bluetooth_socket_send_data_p(void) +{ + int ret = BT_ERROR_NONE; + char *dts_test = "dts_test"; + int socket_fd = 1; + ret = bt_socket_send_data(socket_fd, "dts_test", sizeof(dts_test)); + dts_check_eq("bt_socket_send_data", ret, BT_ERROR_NONE, + "bt_socket_send_data() failed."); +} + +/** + * @brief Positive test case of bt_socket_unset_data_received_cb() + */ +static void utc_network_bluetooth_socket_unset_data_received_cb_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_socket_unset_data_received_cb(); + dts_check_eq("bt_socket_unset_data_received_cb", ret, BT_ERROR_NONE, + "bt_socket_unset_data_received_cb() failed."); +} + +/** + * @brief Positive test case of bt_socket_unset_connection_state_changed_cb() + */ +static void utc_network_bluetooth_socket_unset_connection_state_changed_cb_p(void) +{ + int ret = BT_ERROR_NONE; + + ret = bt_socket_unset_connection_state_changed_cb(); + dts_check_eq("bt_socket_unset_connection_state_changed_cb", ret, + BT_ERROR_NONE, + "bt_socket_unset_connection_state_changed_cb() failed."); +} diff --git a/TC/tet_scen b/TC/tet_scen new file mode 100755 index 0000000..03f029a --- /dev/null +++ b/TC/tet_scen @@ -0,0 +1,7 @@ +all + ^TEST +##### Scenarios for TEST ##### + +# Test scenario +TEST + :include:/testcase/tslist diff --git a/TC/tetbuild.cfg b/TC/tetbuild.cfg new file mode 100755 index 0000000..f7eda55 --- /dev/null +++ b/TC/tetbuild.cfg @@ -0,0 +1,5 @@ +TET_OUTPUT_CAPTURE=True # capture option for build operation checking +TET_BUILD_TOOL=make # build with using make command +TET_BUILD_FILE=-f Makefile # execution file (Makefile) for build +TET_API_COMPLIANT=True # use TET API in Test Case ? +TET_PASS_TC_NAME=True # report passed TC name in Journal file? diff --git a/TC/tetclean.cfg b/TC/tetclean.cfg new file mode 100755 index 0000000..02d7030 --- /dev/null +++ b/TC/tetclean.cfg @@ -0,0 +1,5 @@ +TET_OUTPUT_CAPTURE=True # capture option +TET_CLEAN_TOOL= make clean # clean tool +TET_CLEAN_FILE= Makefile # file for clean +TET_API_COMPLIANT=True # TET API useage +TET_PASS_TC_NAME=True # showing name , passed TC diff --git a/TC/tetexec.cfg b/TC/tetexec.cfg new file mode 100755 index 0000000..ef3e452 --- /dev/null +++ b/TC/tetexec.cfg @@ -0,0 +1,5 @@ +TET_OUTPUT_CAPTURE=True # capturing execution or not +TET_EXEC_TOOL= # ex) exec : execution tool set up/ Optional +TET_EXEC_FILE= # ex) exectool : execution file/ Optional +TET_API_COMPLIANT=True # Test case or Tool usesTET API? +TET_PASS_TC_NAME=True # showing Passed TC name ? diff --git a/TC/tetware.conf b/TC/tetware.conf new file mode 100755 index 0000000..4d0c237 --- /dev/null +++ b/TC/tetware.conf @@ -0,0 +1,5 @@ +BT_ADDR_HEADSET=00:21:19:14:29:52 +BT_ADDR_MOBILE=E4:32:CB:41:1D:7A +BT_ADDR_HDP=00:22:58:07:77:BB +BT_ADDR_LE=E4:32:CB:41:1F:A6 + diff --git a/bluetooth-test.manifest b/bluetooth-test.manifest new file mode 100755 index 0000000..0c26ff0 --- /dev/null +++ b/bluetooth-test.manifest @@ -0,0 +1,12 @@ + + + + + + + + + + + + diff --git a/bluetooth.manifest b/bluetooth.manifest new file mode 100755 index 0000000..75b0fa5 --- /dev/null +++ b/bluetooth.manifest @@ -0,0 +1,5 @@ + + + + + diff --git a/capi-network-bluetooth.pc.in b/capi-network-bluetooth.pc.in old mode 100644 new mode 100755 diff --git a/debian/README b/debian/README old mode 100644 new mode 100755 diff --git a/debian/capi-network-bluetooth-dev.install b/debian/capi-network-bluetooth-dev.install old mode 100644 new mode 100755 diff --git a/debian/capi-network-bluetooth-dev.postinst b/debian/capi-network-bluetooth-dev.postinst old mode 100644 new mode 100755 diff --git a/debian/capi-network-bluetooth.install b/debian/capi-network-bluetooth.install old mode 100644 new mode 100755 diff --git a/debian/capi-network-bluetooth.postinst b/debian/capi-network-bluetooth.postinst old mode 100644 new mode 100755 diff --git a/debian/changelog b/debian/changelog old mode 100644 new mode 100755 diff --git a/debian/compat b/debian/compat old mode 100644 new mode 100755 diff --git a/debian/control b/debian/control old mode 100644 new mode 100755 diff --git a/doc/bluetooth_doc.h b/doc/bluetooth_doc.h new file mode 100755 index 0000000..1dfd984 --- /dev/null +++ b/doc/bluetooth_doc.h @@ -0,0 +1,695 @@ +/* + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + +#ifndef __TIZEN_NETWORK_BLUETOOTH_DOC_H__ +#define __TIZEN_NETWORK_BLUETOOTH_DOC_H__ + +/** + * @defgroup CAPI_NETWORK_BLUETOOTH_MODULE Bluetooth + * @brief Bluetooth Service provides API to manage Bluetooth device. + * @ingroup CAPI_NETWORK_FRAMEWORK + * + * @section CAPI_NETWORK_BLUETOOTH_MODULE_HEADER Required Header + * \#include + * + * @section CAPI_NETWORK_BLUETOOTH_MODULE_OVERVIEW Overview + * Bluetooth Service consists of @ref CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE, @ref CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE and @ref CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE. + * + *
+ * In order to use the above APIs, you must call #bt_initialize() in advance. + * In addition, #bt_deinitialize() should be called when Bluetooth Service is no longer needed. + * Please refer Bluetooth Tutorial if you want to get more detailed usages and information of this api. + * + * @section CAPI_NETWORK_BLUETOOTH_MODULE_FEATURE Related Features + * This API is related with the following features:\n + * - http://tizen.org/feature/network.bluetooth\n + * + * It is recommended to design feature related codes in your application for reliability.\n + * + * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE,thereby controlling the procedure of your application.\n + * + * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n + * + * More details on featuring your application can be found from Feature Element. + * + */ + +/** + * @defgroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE Bluetooth Adapter + * @brief Bluetooth Adapter API provides functions for setting up Bluetooth and discovering other devices. + * @ingroup CAPI_NETWORK_BLUETOOTH_MODULE + * + * @section CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE_HEADER Required Header + * \#include + * + * @section CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE_OVERVIEW Overview + * This set of function is used to control a bluetooth adapter. + * You can also control visibility of the device, its appearance for others (adapter name). + * In addition, this api is used to discover neighboring bluetooth devices. + * This process is asynchronous, so it is up to you to build and hold list of devices in the neighborhood + * - the api does not provide this list. + * Before starting a device discovery, you can find a device from the connected devices. + * This functionality is implemented by foreach loop. + * + * @section CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE_FEATURE Related Features + * This API is related with the following features:\n + * - http://tizen.org/feature/network.bluetooth\n + * + * It is recommended to design feature related codes in your application for reliability.\n + * + * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE,thereby controlling the procedure of your application.\n + * + * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n + * + * More details on featuring your application can be found from Feature Element. + * + * @section CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE_ASYNCHRONOUS_OPERATIONS Asynchronous Operations + *
+ * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + *
FUNCTIONCALLBACKDESCRIPTION
bt_adapter_set_name()bt_adapter_name_changed_cb()Used to set adapter name.
bt_adapter_visibility_mode_changed_cb()Used to set visibility mode (#bt_adapter_visibility_mode_e).
bt_adapter_start_device_discovery()
+ * bt_adapter_stop_device_discovery()		bt_adapter_device_discovery_state_changed_cb()Used to start or cancel device discovery.
+ * + * @section CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE_CALLBACK_OPERATIONS Callback(Event) Operations + *
+ * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + *
REGISTERUNREGISTERCALLBACKDESCRIPTION
bt_adapter_set_state_changed_cb()bt_adapter_unset_state_changed_cb()bt_adapter_state_changed_cb()Used to be notified of state change (enable or disable).
bt_adapter_set_name_changed_cb()bt_adapter_unset_name_changed_cb()bt_adapter_name_changed_cb()Used to be notified of name change.
bt_adapter_set_visibility_mode_changed_cb()bt_adapter_unset_visibility_mode_changed_cb()bt_adapter_visibility_mode_changed_cb()Used to be notified of change of visibility mode (#bt_adapter_visibility_mode_e).
bt_adapter_set_device_discovery_state_changed_cb()bt_adapter_unset_device_discovery_state_changed_cb()bt_adapter_device_discovery_state_changed_cb()Used to be notified of change of device discovery state (#bt_adapter_device_discovery_state_e).
+ * + * @section CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE_FOREACH_OPERATIONS Foreach Operations + *
+ * + * + * + * + * + * + * + * + * + * + *
FOREACHCALLBACKDESCRIPTION
bt_adapter_foreach_bonded_device()bt_adapter_bonded_device_cb()Used to get bonded devices.
+ * + *
+ * Please refer Bluetooth Tutorial if you want to get more detailed usages and information of this api. + */ + +/** + * @defgroup CAPI_NETWORK_BLUETOOTH_ADAPTER_LE_MODULE Bluetooth LE Adapter + * @brief Bluetooth LE API provides functions for managing bonds with other devices for LE and searching for supported LE services. + * @ingroup CAPI_NETWORK_BLUETOOTH_MODULE + * + * @section CAPI_NETWORK_BLUETOOTH_ADAPTER_LE_MODULE_HEADER Required Header + * \#include + * + * @section CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE_OVERVIEW Overview + * + * @section CAPI_NETWORK_BLUETOOTH_ADAPTER_LE_MODULE_MODULE_FEATURE Related Features + * This API is related with the following features:\n + * - http://tizen.org/feature/network.bluetooth\n + * - http://tizen.org/feature/network.bluetooth.le\n + * + * It is recommended to design feature related codes in your application for reliability.\n + * + * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE,thereby controlling the procedure of your application.\n + * + * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n + * + * More details on featuring your application can be found from Feature Element. + * + */ + +/** + * @defgroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE Bluetooth Device + * @brief Bluetooth Device API provides functions for managing bonds with other devices and searching for supported services. + * @ingroup CAPI_NETWORK_BLUETOOTH_MODULE + * + * @section CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE_HEADER Required Header + * \#include + * + * @section CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE_OVERVIEW Overview + * This set of functions is used to handle the connection with other devices. + * Connected devices exchange keys needed for encrypted communication, + * but each connection has to be approved by the latest application user. + * You can also set authorization of other devices. + * Authorized devices are connected, and it is connected automatically without the latest user + * being asked for authorization. + * In addition, this is used to search for services available on remote devices. + * + * @section CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE_FEATURE Related Features + * This API is related with the following features:\n + * - http://tizen.org/feature/network.bluetooth\n + * - http://tizen.org/feature/network.bluetooth.le\n + * + * It is recommended to design feature related codes in your application for reliability.\n + * + * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE,thereby controlling the procedure of your application.\n + * + * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n + * + * More details on featuring your application can be found from Feature Element. + * + * @section CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE_ASYNCHRONOUS_OPERATIONS Asynchronous Operations + *
+ * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + *
FUNCTIONCALLBACKDESCRIPTION
bt_device_create_bond()
+ * bt_device_cancel_bonding()		bt_device_bond_created_cb()Used to create bond or cancel creating bond.
bt_device_destroy_bond()bt_device_bond_destroyed_cb()Used to destroy bond.
bt_device_set_authorization()bt_device_authorization_changed_cb()Used to set as authorized or unauthorized device.
bt_device_start_service_search()bt_device_service_searched_cb()Used to start or cancel service search.
+ * + * @section CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE_CALLBACK_OPERATIONS Callback(Event) Operations + *
+ * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + *
REGISTERUNREGISTERCALLBACKDESCRIPTION
bt_device_set_bond_created_cb()bt_device_unset_bond_created_cb()bt_device_bond_created_cb()Used to be notified of the result of creating bond.
bt_device_set_bond_destroyed_cb()bt_device_unset_bond_destroyed_cb()bt_device_bond_destroyed_cb()Used to be notified of the result of destroying bond.
bt_device_set_authorization_changed_cb()bt_device_unset_authorization_changed_cb()bt_device_authorization_changed_cb()Used to be notified of change of authorization.
bt_device_set_service_searched_cb()bt_device_unset_service_searched_cb()bt_device_service_searched_cb()Used to be notified of change of service search state.
+ * + *
+ * Please refer Bluetooth Tutorial if you want to get more detailed usages and information of this api. + */ + + +/** + * @defgroup CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE Bluetooth Socket + * @brief Bluetooth Socket API provides functions for managing connections to other devices and exchanging data. + * @ingroup CAPI_NETWORK_BLUETOOTH_MODULE + * + * @section CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE_HEADER Required Header + * \#include + * + * @section CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE_OVERVIEW Overview + * This set of functions is used for exchanging data between two bluetooth + * devices, our device can have both roles as server (service provider) and client + * (service user). + * Depending on the role, there is difference in creating a connection. + * After that, processes of exchanging data and disconnection are same. + * + * To start communication, you should first register for #bt_socket_set_connection_state_changed_cb() + * and #bt_socket_set_data_received_cb(). + * Next step depends on the role of your application.\n + * If you want to be \b server \b role, application should create socket + * (#bt_socket_create_rfcomm()), and start listening and accepting incoming connections + * (#bt_socket_listen_and_accept_rfcomm()). + * If you want to connect to specific device and use it's services (\a client \a role), + * you have to start connection with #bt_socket_connect_rfcomm() and wait for connection.\n + * After connection has been established (information is passed to your program with + * #bt_socket_connection_state_changed_cb() function call), you can exchange data by + * calling #bt_socket_send_data(). \n + * If you receive data from remote device, #bt_socket_data_received_cb() functions will be called. + * When you finish exchanging data, you should disconnect connection + * with #bt_socket_disconnect_rfcomm() and unregister callback functions (with using + * #bt_socket_unset_data_received_cb(), #bt_socket_unset_connection_state_changed_cb()). + * + * @section CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE_FEATURE Related Features + * This API is related with the following features:\n + * - http://tizen.org/feature/network.bluetooth\n + * + * It is recommended to design feature related codes in your application for reliability.\n + * + * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE,thereby controlling the procedure of your application.\n + * + * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n + * + * More details on featuring your application can be found from Feature Element. + * + * @section CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE_ASYNCHRONOUS_OPERATIONS Asynchronous Operations + *
+ * + * + * + * + * + * + * + * + * + * + *
FUNCTIONCALLBACKDESCRIPTION
bt_socket_listen_and_accept_rfcomm()
+ * bt_socket_connect_rfcomm()		bt_socket_connection_state_changed_cb()Used to connect a device.
+ * + * @section CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE_CALLBACK_OPERATIONS Callback(Event) Operations + *
+ * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + * + *
REGISTERUNREGISTERCALLBACKDESCRIPTION
bt_socket_set_data_received_cb()bt_socket_unset_data_received_cb()bt_socket_data_received_cb()Used to be notified of received data.
bt_socket_set_connection_state_changed_cb()bt_socket_unset_connection_state_changed_cb()bt_socket_connection_state_changed_cb()Used to be notified when the state of connection changes.
+ * + *
+ * Please refer Bluetooth Tutorial if you want to get more detailed usages and information of this api. + */ + + +/** + * @defgroup CAPI_NETWORK_BLUETOOTH_OPP_MODULE Bluetooth OPP + * @brief Bluetooth OPP(Object Push Profile) API provides functions for exchanging objects such as pictures. + * @ingroup CAPI_NETWORK_BLUETOOTH_MODULE + * + * @section CAPI_NETWORK_BLUETOOTH_OPP_MODULE_HEADER Required Header + * \#include + * + * @section CAPI_NETWORK_BLUETOOTH_OPP_MODULE_OVERVIEW Overview + * OPP profile let users exchange objects between two devices. + * + */ + +/** + * @defgroup CAPI_NETWORK_BLUETOOTH_OPP_SERVER_MODULE Bluetooth OPP Server + * @brief Bluetooth OPP(Object Push Profile) Server API provides functions for accepting objects such as pictures. + * @ingroup CAPI_NETWORK_BLUETOOTH_OPP_MODULE + * + * @section CAPI_NETWORK_BLUETOOTH_OPP_SERVER_MODULE_HEADER Required Header + * \#include + * + * @section CAPI_NETWORK_BLUETOOTH_OPP_SERVER_MODULE_OVERVIEW Overview + * This is OPP server APIs. + * + * @section CAPI_NETWORK_BLUETOOTH_OPP_SERVER_MODULE_FEATURE Related Features + * This API is related with the following features:\n + * - http://tizen.org/feature/network.bluetooth.opp\n + * + * It is recommended to design feature related codes in your application for reliability.\n + * + * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE,thereby controlling the procedure of your application.\n + * + * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n + * + * More details on featuring your application can be found from Feature Element. + * + */ + +/** + * @defgroup CAPI_NETWORK_BLUETOOTH_OPP_CLIENT_MODULE Bluetooth OPP Client + * @brief Bluetooth OPP(Object Push Profile) Client API provides functions for pushing objects such as pictures. + * @ingroup CAPI_NETWORK_BLUETOOTH_OPP_MODULE + * + * @section CAPI_NETWORK_BLUETOOTH_OPP_CLIENT_MODULE_HEADER Required Header + * \#include + * + * @section CAPI_NETWORK_BLUETOOTH_OPP_CLIENT_MODULE_OVERVIEW Overview + * This is OPP Client APIs. + * + * @section CAPI_NETWORK_BLUETOOTH_OPP_CLIENT_MODULE_FEATURE Related Features + * This API is related with the following features:\n + * - http://tizen.org/feature/network.bluetooth.opp\n + * + * It is recommended to design feature related codes in your application for reliability.\n + * + * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE,thereby controlling the procedure of your application.\n + * + * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n + * + * More details on featuring your application can be found from Feature Element. + * + */ + +/** + * @internal + * @defgroup CAPI_NETWORK_BLUETOOTH_PAN_MODULE Bluetooth PAN + * @brief Bluetooth PAN(Personal Area Networking) API provides functions for connecting to a higher level network and the Internet. + * @ingroup CAPI_NETWORK_BLUETOOTH_MODULE + * + * @section CAPI_NETWORK_BLUETOOTH_PAN_MODULE_OVERVIEW Overview + * The PAN Profile describe how two or more Bluetooth enabled devices can form an ad-hoc network and how the same mechanism can be + * used to access a remote network through a network access point. But this API only supports network access point service. + * + * @section CAPI_NETWORK_BLUETOOTH_PAN_MODULE_FEATURE Related Features + * This API is related with the following features:\n + * - http://tizen.org/feature/network.tethering.bluetooth\n + * + * It is recommended to design feature related codes in your application for reliability.\n + * + * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE,thereby controlling the procedure of your application.\n + * + * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n + * + * More details on featuring your application can be found from Feature Element. + * + */ + +/** + * @internal + * @defgroup CAPI_NETWORK_BLUETOOTH_PAN_NAP_MODULE Bluetooth NAP + * @brief Bluetooth NAP(Network Access Point) API provides functions for an Ethernet bridge to support network services. + * @ingroup CAPI_NETWORK_BLUETOOTH_PAN_MODULE + * + * @section CAPI_NETWORK_BLUETOOTH_PAN_NAP_MODULE_HEADER Required Header + * \#include + * + * @section CAPI_NETWORK_BLUETOOTH_PAN_NAP_MODULE_OVERVIEW Overview + * A Bluetooth device that supports the NAP service is a Bluetooth device that provides some of the features of an Ethernet bridge to support network services. + * + * @section CAPI_NETWORK_BLUETOOTH_PAN_NAP_MODULE_FEATURE Related Features + * This API is related with the following features:\n + * - http://tizen.org/feature/network.tethering.bluetooth\n + * + * It is recommended to design feature related codes in your application for reliability.\n + * + * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE, thereby controlling the procedure of your application.\n + * + * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n + * + * More details on featuring your application can be found from Feature Element. + * + */ + +/** + * @internal + * @defgroup CAPI_NETWORK_BLUETOOTH_PAN_PANU_MODULE Bluetooth PANU + * @brief Bluetooth PANU(Personal Area Networking User) API provides functions for client of both the NAP(Network Access Point). + * @ingroup CAPI_NETWORK_BLUETOOTH_PAN_MODULE + * + * @section CAPI_NETWORK_BLUETOOTH_PAN_PANU_MODULE_HEADER Required Header + * \#include + * + * @section CAPI_NETWORK_BLUETOOTH_PAN_PANU_MODULE_OVERVIEW Overview + * In PAN Profile, PANU can uses either the NAP or GN service, but this API only supports NAP service. + * + * @section CAPI_NETWORK_BLUETOOTH_PAN_PANU_MODULE_FEATURE Related Features + * This API is related with the following features:\n + * - http://tizen.org/feature/network.tethering.bluetooth\n + * + * It is recommended to design feature related codes in your application for reliability.\n + * + * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE, thereby controlling the procedure of your application.\n + * + * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n + * + * More details on featuring your application can be found from Feature Element. + * + */ + +/** + * @defgroup CAPI_NETWORK_BLUETOOTH_HID_MODULE Bluetooth HID + * @brief Bluetooth HID(Human Interface Device) API provides functions for connecting to Bluetooth HID such as keyboards and mouse. + * @ingroup CAPI_NETWORK_BLUETOOTH_MODULE + * + * @section CAPI_NETWORK_BLUETOOTH_HID_MODULE_HEADER Required Header + * \#include + * + * @section CAPI_NETWORK_BLUETOOTH_HID_MODULE_OVERVIEW Overview + * In HID Profile, there are two roles - @a Host and @a Device. + * The @a Host is a device that uses or requests the services of a HID. The @a Device is a device that provides the service of human data input and output to and from the @a Host. + * This API only supports @a Host role. + * + * @section CAPI_NETWORK_BLUETOOTH_HID_MODULE_FEATURE Related Features + * This API is related with the following features:\n + * - http://tizen.org/feature/network.bluetooth.hid\n + * + * It is recommended to design feature related codes in your application for reliability.\n + * + * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE, thereby controlling the procedure of your application.\n + * + * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n + * + * More details on featuring your application can be found from Feature Element. + * + */ + +/** + * @defgroup CAPI_NETWORK_BLUETOOTH_AUDIO_MODULE Bluetooth Audio + * @brief Bluetooth Audio API provides functions for connecting to Bluetooth audio devices such as headset, hand-free and headphone. + * @ingroup CAPI_NETWORK_BLUETOOTH_MODULE + * + * @section CAPI_NETWORK_BLUETOOTH_AUDIO_MODULE_HEADER Required Header + * \#include + * + * @section CAPI_NETWORK_BLUETOOTH_AUDIO_MODULE_OVERVIEW Overview + * This API supports the HFP(Hands-Free Profile), HSP(Headset Profile) and A2DP(Advanced Audio Distribution Profile). + * + * @section CAPI_NETWORK_BLUETOOTH_AUDIO_MODULE_FEATURE Related Features + * This API is related with the following features:\n + * - http://tizen.org/feature/network.bluetooth.audio.call\n + * - http://tizen.org/feature/network.bluetooth.audio.media\n + * + * It is recommended to design feature related codes in your application for reliability.\n + * + * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE, thereby controlling the procedure of your application.\n + * + * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n + * + * More details on featuring your application can be found from Feature Element. + * + */ + +/** + * @internal + * @defgroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE Bluetooth AG + * @brief Bluetooth AG(Audio Gateway) API provides functions for controling the remote audio device. + * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_MODULE + * + * @section CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE_HEADER Required Header + * \#include + * + * @section CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE_OVERVIEW Overview + * This API supports the @a Audio @a Gateway role in HSP and HFP. + * Audio Gateway is the devie that is the gateway of the audio, both for input and output, typically a mobile phone or PC. + * + * @section CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE_FEATURE Related Features + * This API is related with the following features:\n + * - http://tizen.org/feature/network.bluetooth.audio.call\n + * - http://tizen.org/feature/network.bluetooth.audio.media\n + * + * It is recommended to design feature related codes in your application for reliability.\n + * + * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE, thereby controlling the procedure of your application.\n + * + * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n + * + * More details on featuring your application can be found from Feature Element. + * + */ + +/** + * @internal + * @defgroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_CALL_MODULE Call List + * @brief Bluetooth AG(Audio Gateway) API provides functions for managing the handler of call list. + * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE + * + * @section CAPI_NETWORK_BLUETOOTH_AUDIO_AG_CALL_MODULE_HEADER Required Header + * \#include + * + * @section CAPI_NETWORK_BLUETOOTH_AUDIO_AG_CALL_OVERVIEW Overview + * This set of functions is used for managing the handler of call list. + * This handler is used for notifying the call list to the remote bluetooth device which supports HFP(Hands-Free Profile). + * + * @section CAPI_NETWORK_BLUETOOTH_AUDIO_AG_CALL_MODULE_FEATURE Related Features + * This API is related with the following features:\n + * - http://tizen.org/feature/network.bluetooth.audio.call\n + * - http://tizen.org/feature/network.bluetooth.audio.media\n + * + * It is recommended to design feature related codes in your application for reliability.\n + * + * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE, thereby controlling the procedure of your application.\n + * + * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n + * + * More details on featuring your application can be found from Feature Element. + * + */ + +/** + * @internal + * @defgroup CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE Bluetooth AVRCP + * @brief Bluetooth AVRCP(Audio/Video Remote Control Profile) API provides functions for notifying the change of target device to the control device. + * @ingroup CAPI_NETWORK_BLUETOOTH_MODULE + * + * @section CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE_HEADER Required Header + * \#include + * + * @section CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE_OVERVIEW Overview + * This API supports the @a Target role in AVRCP spec. + * The @a Target is the device whose characteristics are being altered. + * In a "walkman" type media player scenario, the @a Control device may be a headset that allows tracks to be skipped and the @a Target device would be the actual medial player. + * + * @section CAPI_NETWORK_BLUETOOTH_AVRCP__MODULE_FEATURE Related Features + * This API is related with the following features:\n + * - http://tizen.org/feature/network.bluetooth.audio.media\n + * + * It is recommended to design feature related codes in your application for reliability.\n + * + * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE, thereby controlling the procedure of your application.\n + * + * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n + * + * More details on featuring your application can be found from Feature Element. + * + */ + +/** + * @defgroup CAPI_NETWORK_BLUETOOTH_HDP_MODULE Bluetooth HDP + * @brief Bluetooth HDP(Health Device Profile) API provides functions for managing connections to health devices and exchanging data. + * @ingroup CAPI_NETWORK_BLUETOOTH_MODULE + * + * @section CAPI_NETWORK_BLUETOOTH_HDP_MODULE_HEADER Required Header + * \#include + * + * @section CAPI_NETWORK_BLUETOOTH_HDP_MODULE_OVERVIEW Overview + * The @a Source is a transmitter of application data that is to be transferred to a @a Sink. The @a Sink is a receiver of application data delivered from a @a Source. + * This API supports the @a Sink role in HDP spec. + * + * @section CAPI_NETWORK_BLUETOOTH_HDP_MODULE_FEATURE Related Features + * This API is related with the following features:\n + * - http://tizen.org/feature/network.bluetooth.health\n + * + * It is recommended to design feature related codes in your application for reliability.\n + * + * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE, thereby controlling the procedure of your application.\n + * + * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n + * + * More details on featuring your application can be found from Feature Element. + * + */ + +/** + * @defgroup CAPI_NETWORK_BLUETOOTH_GATT_MODULE Bluetooth GATT + * @brief Bluetooth GATT(Generic Attribute Profile) API provides functions for discovering, reading and modifying attributes. + * @ingroup CAPI_NETWORK_BLUETOOTH_MODULE + * + * @section CAPI_NETWORK_BLUETOOTH_GATT_MODULE_HEADER Required Header + * \#include + * + * @section CAPI_NETWORK_BLUETOOTH_GATT_MODULE_OVERVIEW Overview + * Two roles are defined for devices that implement GATT. + * The @a Server is the device that accepts incoming commands and requests from the client and sends responses, indications and notifications to a client. + * The @a Client is the device that initiates commands and requests towards the server and can receive responses, indications and notifications sent by the server. + * This API supports the @a Client role in GATT. + * + * @section CAPI_NETWORK_BLUETOOTH_GATT_MODULE_FEATURE Related Features + * This API is related with the following features:\n + * - http://tizen.org/feature/network.bluetooth.le\n + * + * It is recommended to design feature related codes in your application for reliability.\n + * + * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE, thereby controlling the procedure of your application.\n + * + * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n + * + * More details on featuring your application can be found from Feature Element. + * + */ + +#endif /* __TIZEN_NETWORK_BLUETOOTH_DOC_H__ */ diff --git a/include/bluetooth.h b/include/bluetooth.h old mode 100644 new mode 100755 diff --git a/include/bluetooth_private.h b/include/bluetooth_private.h old mode 100644 new mode 100755 index c5692ca..ebff30f --- a/include/bluetooth_private.h +++ b/include/bluetooth_private.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved * * Licensed under the Apache License, Version 2.0 (the License); * you may not use this file except in compliance with the License. @@ -100,7 +100,19 @@ typedef enum BT_EVENT_RSSI_ENABLED_EVENT, /**< RSSI Enabled callback */ BT_EVENT_RSSI_ALERT_EVENT, /**< RSSI Alert callback */ BT_EVENT_GET_RSSI_EVENT, /**< Get RSSI Strength callback */ - +#ifdef TIZEN_WEARABLE + BT_EVENT_PBAP_CONNECTION_STATUS, /**< PBAP connection status callback */ + BT_EVENT_PBAP_PHONEBOOK_SIZE, /**< PBAP Phonebook Size status callback */ + BT_EVENT_PBAP_PHONEBOOK_PULL, /**< PBAP Phonebook Pull status callback */ + BT_EVENT_PBAP_VCARD_LIST, /**< PBAP vCard List status callback */ + BT_EVENT_PBAP_VCARD_PULL, /**< PBAP vCard Pull status callback */ + BT_EVENT_PBAP_PHONEBOOK_SEARCH, /**< PBAP Phonebook Search status callback */ + BT_EVENT_HF_SCO_CONNECTION_STATUS, /**< Audio - HF SCO Connection state change callback */ + BT_EVENT_HF_SPEAKER_GAIN_CHANGE, /**< Audio - HF Speaker gain change callback */ + BT_EVENT_HF_CALL_HANDLING_EVENT, /**< Audio - HF call event callback */ + BT_EVENT_HF_VENDOR_DEP_CMD_EVENT, /**< Audio - HF Vendor Command callback */ + BT_EVENT_HF_MULTI_CALL_HANDLING_EVENT, /**< Audio - HF 3-way call event callback */ +#endif } bt_event_e; /** @@ -236,6 +248,14 @@ bt_adapter_visibility_mode_e _bt_get_bt_visibility_mode_e(bluetooth_discoverable */ void _bt_audio_event_proxy(int event, bt_audio_event_param_t *param, void *user_data); +#ifdef TIZEN_WEARABLE +/** + * @internal + * @brief Since the HF call back and event proxy call backs have different prototype it is wrapper function. + */ +void _bt_hf_event_proxy(int event, bt_hf_event_param_t *param, void *user_data); +#endif + /** * @internal * @brief Since the Telephony call back and event proxy call backs have different prototype it is wrapper function. diff --git a/include/bluetooth_type.h b/include/bluetooth_type.h old mode 100644 new mode 100755 index 8935102..d569dc6 --- a/include/bluetooth_type.h +++ b/include/bluetooth_type.h @@ -44,22 +44,22 @@ typedef enum BT_ERROR_RESOURCE_BUSY = TIZEN_ERROR_RESOURCE_BUSY, /**< Device or resource busy */ BT_ERROR_TIMED_OUT = TIZEN_ERROR_TIMED_OUT, /**< Timeout error */ BT_ERROR_NOW_IN_PROGRESS = TIZEN_ERROR_NOW_IN_PROGRESS, /**< Operation now in progress */ - BT_ERROR_NOT_SUPPORTED = TIZEN_ERROR_NETWORK_CLASS|0x0111, /**< Not Supported */ - BT_ERROR_PERMISSION_DENIED = TIZEN_ERROR_NETWORK_CLASS|0x0112, /**< Permission denied */ - BT_ERROR_QUOTA_EXCEEDED = TIZEN_ERROR_NETWORK_CLASS|0x0113, /**< Quota exceeded */ - BT_ERROR_NOT_INITIALIZED = TIZEN_ERROR_NETWORK_CLASS|0x0101, /**< Local adapter not initialized */ - BT_ERROR_NOT_ENABLED = TIZEN_ERROR_NETWORK_CLASS|0x0102, /**< Local adapter not enabled */ - BT_ERROR_ALREADY_DONE = TIZEN_ERROR_NETWORK_CLASS|0x0103, /**< Operation already done */ - BT_ERROR_OPERATION_FAILED = TIZEN_ERROR_NETWORK_CLASS|0x0104, /**< Operation failed */ - BT_ERROR_NOT_IN_PROGRESS = TIZEN_ERROR_NETWORK_CLASS|0x0105, /**< Operation not in progress */ - BT_ERROR_REMOTE_DEVICE_NOT_BONDED = TIZEN_ERROR_NETWORK_CLASS|0x0106, /**< Remote device not bonded */ - BT_ERROR_AUTH_REJECTED = TIZEN_ERROR_NETWORK_CLASS|0x0107, /**< Authentication rejected */ - BT_ERROR_AUTH_FAILED = TIZEN_ERROR_NETWORK_CLASS|0x0108, /**< Authentication failed */ - BT_ERROR_REMOTE_DEVICE_NOT_FOUND = TIZEN_ERROR_NETWORK_CLASS|0x0109, /**< Remote device not found */ - BT_ERROR_SERVICE_SEARCH_FAILED = TIZEN_ERROR_NETWORK_CLASS|0x010A, /**< Service search failed */ - BT_ERROR_REMOTE_DEVICE_NOT_CONNECTED = TIZEN_ERROR_NETWORK_CLASS|0x010B, /**< Remote device is not connected */ - BT_ERROR_AGAIN = TIZEN_ERROR_NETWORK_CLASS|0x010C, /**< Resource temporarily unavailable */ - BT_ERROR_SERVICE_NOT_FOUND = TIZEN_ERROR_NETWORK_CLASS|0x010D, /**< Service Not Found */ + BT_ERROR_NOT_SUPPORTED = TIZEN_ERROR_NOT_SUPPORTED, /**< Not Supported */ + BT_ERROR_PERMISSION_DENIED = TIZEN_ERROR_PERMISSION_DENIED, /**< Permission denied */ + BT_ERROR_QUOTA_EXCEEDED = TIZEN_ERROR_QUOTA_EXCEEDED, /**< Quota exceeded */ + BT_ERROR_NOT_INITIALIZED = TIZEN_ERROR_BLUETOOTH|0x0101, /**< Local adapter not initialized */ + BT_ERROR_NOT_ENABLED = TIZEN_ERROR_BLUETOOTH|0x0102, /**< Local adapter not enabled */ + BT_ERROR_ALREADY_DONE = TIZEN_ERROR_BLUETOOTH|0x0103, /**< Operation already done */ + BT_ERROR_OPERATION_FAILED = TIZEN_ERROR_BLUETOOTH|0x0104, /**< Operation failed */ + BT_ERROR_NOT_IN_PROGRESS = TIZEN_ERROR_BLUETOOTH|0x0105, /**< Operation not in progress */ + BT_ERROR_REMOTE_DEVICE_NOT_BONDED = TIZEN_ERROR_BLUETOOTH|0x0106, /**< Remote device not bonded */ + BT_ERROR_AUTH_REJECTED = TIZEN_ERROR_BLUETOOTH|0x0107, /**< Authentication rejected */ + BT_ERROR_AUTH_FAILED = TIZEN_ERROR_BLUETOOTH|0x0108, /**< Authentication failed */ + BT_ERROR_REMOTE_DEVICE_NOT_FOUND = TIZEN_ERROR_BLUETOOTH|0x0109, /**< Remote device not found */ + BT_ERROR_SERVICE_SEARCH_FAILED = TIZEN_ERROR_BLUETOOTH|0x010A, /**< Service search failed */ + BT_ERROR_REMOTE_DEVICE_NOT_CONNECTED = TIZEN_ERROR_BLUETOOTH|0x010B, /**< Remote device is not connected */ + BT_ERROR_AGAIN = TIZEN_ERROR_BLUETOOTH|0x010C, /**< Resource temporarily unavailable */ + BT_ERROR_SERVICE_NOT_FOUND = TIZEN_ERROR_BLUETOOTH|0x010D, /**< Service Not Found */ } bt_error_e; /** diff --git a/packaging/capi-network-bluetooth-devel.manifest b/packaging/capi-network-bluetooth-devel.manifest old mode 100644 new mode 100755 diff --git a/packaging/capi-network-bluetooth.changes b/packaging/capi-network-bluetooth.changes old mode 100644 new mode 100755 diff --git a/packaging/capi-network-bluetooth.manifest b/packaging/capi-network-bluetooth.manifest old mode 100644 new mode 100755 diff --git a/packaging/capi-network-bluetooth.spec b/packaging/capi-network-bluetooth.spec old mode 100644 new mode 100755 index 3af2ec3..1441171 --- a/packaging/capi-network-bluetooth.spec +++ b/packaging/capi-network-bluetooth.spec @@ -1,18 +1,25 @@ +#sbs-git:slp/api/bluetooth capi-network-bluetooth 0.1.0 686c444083e4197845c768e5dd034022b1dfa250 Name: capi-network-bluetooth Summary: Network Bluetooth Framework -Version: 0.1.39 +Version: 0.1.52 Release: 1 Group: Connectivity/API -License: Apache-2.0 +License: Apache License, Version 2.0 Source0: %{name}-%{version}.tar.gz Source1001: %{name}.manifest Source1002: %{name}-devel.manifest +Requires(post): /sbin/ldconfig +Requires(postun): /sbin/ldconfig + BuildRequires: pkgconfig(dbus-glib-1) BuildRequires: pkgconfig(dlog) BuildRequires: pkgconfig(glib-2.0) BuildRequires: pkgconfig(vconf) BuildRequires: pkgconfig(bluetooth-api) BuildRequires: pkgconfig(capi-base-common) +%if "%{?tizen_profile_name}" == "wearable" +BuildRequires: pkgconfig(privacy-manager-client) +%endif BuildRequires: cmake @@ -26,7 +33,15 @@ Group: Development/Connectivit Requires: %{name} = %{version}-%{release} %description devel -Network Bluetooth Framework. +Network Bluetooth Framework (DEV). + +%package test +Summary: Network Bluetooth Framework test application +Group: Development/Connectivit +Requires: %{name} = %{version}-%{release} + +%description test +This package is C-API test application. %devel_desc @@ -35,14 +50,49 @@ Network Bluetooth Framework. cp %{SOURCE1001} %{SOURCE1002} . %build +%if "%{?tizen_profile_name}" == "wearable" +export CFLAGS="$CFLAGS -DTIZEN_WEARABLE" +export CXXFLAGS="$CXXFLAGS -DTIZEN_WEARABLE" +export FFLAGS="$FFLAGS -DTIZEN_WEARABLE" +%endif + +#%if 0%{?sec_build_binary_debug_enable} +export CFLAGS="$CFLAGS -DTIZEN_DEBUG_ENABLE" +export CXXFLAGS="$CXXFLAGS -DTIZEN_DEBUG_ENABLE" +export FFLAGS="$FFLAGS -DTIZEN_DEBUG_ENABLE" +#%endif + +#%if 0%{?tizen_build_binary_release_type_eng} +export CFLAGS="$CFLAGS -DTIZEN_ENGINEER_MODE" +export CXXFLAGS="$CXXFLAGS -DTIZEN_ENGINEER_MODE" +export FFLAGS="$FFLAGS -DTIZEN_ENGINEER_MODE" +#%endif + +%if "%{?tizen_profile_name}" == "wearable" +export CFLAGS+=" -DTELEPHONY_DISABLED" +export CXXFLAGS+=" -DTELEPHONY_DISABLED" +export FFLAGS+=" -DTELEPHONY_DISABLED" +%endif + +%cmake \ +%if "%{?tizen_profile_name}" == "wearable" + -DTIZEN_WEARABLE=YES \ +%else +%if "%{?tizen_profile_name}" == "mobile" + -DTIZEN_WEARABLE=NO \ +%endif +%endif + MAJORVER=`echo %{version} | awk 'BEGIN {FS="."}{print $1}'` -%cmake . -DFULLVER=%{version} -DMAJORVER=${MAJORVER} +cmake . -DCMAKE_INSTALL_PREFIX=/usr -DFULLVER=%{version} -DMAJORVER=${MAJORVER} make %{?jobs:-j%jobs} %install +rm -rf %{buildroot} %make_install - +install -D -m 0644 LICENSE %{buildroot}%{_datadir}/license/capi-network-bluetooth +install -D -m 0644 LICENSE %{buildroot}%{_datadir}/license/capi-network-bluetooth-devel %post -p /sbin/ldconfig @@ -52,6 +102,13 @@ make %{?jobs:-j%jobs} %manifest %{name}.manifest %license LICENSE.APLv2 LICENSE %{_libdir}/libcapi-network-bluetooth.so.* +%{_datadir}/license/capi-network-bluetooth + +%files test +%manifest bluetooth-test.manifest +%{_bindir}/bt_unit_test +%{_bindir}/bt_onoff +/etc/smack/accesses.d/capi-network-bluetooth-test.efl %files devel %manifest %{name}-devel.manifest @@ -59,4 +116,5 @@ make %{?jobs:-j%jobs} %{_includedir}/network/bluetooth_type.h %{_libdir}/pkgconfig/capi-network-bluetooth.pc %{_libdir}/libcapi-network-bluetooth.so +%{_datadir}/license/capi-network-bluetooth-devel diff --git a/src/bluetooth-adapter.c b/src/bluetooth-adapter.c old mode 100644 new mode 100755 index cba5d43..2cc9cb1 --- a/src/bluetooth-adapter.c +++ b/src/bluetooth-adapter.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved * * Licensed under the Apache License, Version 2.0 (the License); * you may not use this file except in compliance with the License. @@ -21,6 +21,9 @@ #include #include #include +#ifdef TIZEN_WEARABLE +#include +#endif #include #include "bluetooth.h" @@ -28,7 +31,18 @@ int bt_adapter_enable(void) { - int error_code; + int error_code = BT_ERROR_NONE; +#ifdef TIZEN_WEARABLE + static const char* PRIVILEGE_ID_BLUETOOTH_ADMIN = "http://tizen.org/privilege/bluetooth.admin"; + + error_code = privacy_checker_check_by_privilege(PRIVILEGE_ID_BLUETOOTH_ADMIN); + if (error_code != PRIV_MGR_ERROR_SUCCESS) { + privacy_checker_finalize(); + BT_ERR("PERMISSION_DENIED(0x%08x)", error_code); + return BT_ERROR_PERMISSION_DENIED; + } + privacy_checker_finalize(); +#endif BT_CHECK_INIT_STATUS(); error_code = _bt_get_error_code(bluetooth_enable_adapter()); @@ -40,7 +54,7 @@ int bt_adapter_enable(void) int bt_adapter_disable(void) { - int error_code; + int error_code = BT_ERROR_NONE; BT_CHECK_INIT_STATUS(); error_code = _bt_get_error_code(bluetooth_disable_adapter()); @@ -52,12 +66,19 @@ int bt_adapter_disable(void) int bt_adapter_recover(void) { - return BT_ERROR_NOT_SUPPORTED; + int error_code = BT_ERROR_NONE; + + BT_CHECK_INIT_STATUS(); + error_code = _bt_get_error_code(bluetooth_recover_adapter()); + if (error_code != BT_ERROR_NONE) { + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code); + } + return error_code; } int bt_adapter_reset(void) { - int error_code; + int error_code = BT_ERROR_NONE; BT_CHECK_INIT_STATUS(); error_code = _bt_get_error_code(bluetooth_reset_adapter()); @@ -78,23 +99,40 @@ int bt_adapter_get_state(bt_adapter_state_e *adapter_state) int bt_adapter_le_enable(void) { - return BT_ERROR_NOT_SUPPORTED; + int error_code = BT_ERROR_NONE; + + BT_CHECK_INIT_STATUS(); + error_code = _bt_get_error_code(bluetooth_enable_adapter_le()); + if (error_code != BT_ERROR_NONE) { + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code); + } + return error_code; } int bt_adapter_le_disable(void) { - return BT_ERROR_NOT_SUPPORTED; + int error_code = BT_ERROR_NONE; + + BT_CHECK_INIT_STATUS(); + error_code = _bt_get_error_code(bluetooth_disable_adapter_le()); + if (error_code != BT_ERROR_NONE) { + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code); + } + return error_code; } int bt_adapter_le_get_state(bt_adapter_le_state_e *adapter_le_state) { - return BT_ERROR_NOT_SUPPORTED; + BT_CHECK_INPUT_PARAMETER(adapter_le_state); + + *adapter_le_state = bluetooth_check_adapter_le(); + return BT_ERROR_NONE; } int bt_adapter_get_address(char **address) { bluetooth_device_address_t loc_address = { {0} }; - int error_code; + int error_code = BT_ERROR_NONE; BT_CHECK_INIT_STATUS(); BT_CHECK_INPUT_PARAMETER(address); @@ -116,18 +154,226 @@ int bt_adapter_get_address(char **address) int bt_adapter_get_version(char **version) { - return BT_ERROR_NOT_SUPPORTED; + int ret = BT_ERROR_NONE; + bluetooth_version_t loc_ver = { { 0 } }; + + BT_CHECK_INIT_STATUS(); + BT_CHECK_INPUT_PARAMETER(version); + + ret = _bt_get_error_code(bluetooth_get_local_version(&loc_ver)); + if (ret != BT_ERROR_NONE) { + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); + return ret; + } + + *version = strdup(loc_ver.version); + if (*version == NULL) { + BT_ERR("OUT_OF_MEMORY(0x%08x)", BT_ERROR_OUT_OF_MEMORY); + return BT_ERROR_OUT_OF_MEMORY; + } + + return BT_ERROR_NONE; } +#define BT_ADAPTER_FIRMWARE_INFO_FILE_PATH "/var/lib/bluetooth/bcmtool_log" +#define BT_ADAPTER_STACK_INFO_FILE_PATH "/usr/etc/bluetooth/stack_info" int bt_adapter_get_local_info(char **chipset, char **firmware, char **stack_version, char **profiles) { - return BT_ERROR_NOT_SUPPORTED; + int ret = BT_ERROR_NONE; + FILE *fp = NULL; + char *buf = NULL; + long lsize; + size_t result; + char *info_start = NULL; + char *info_end = NULL; + long info_size; + char *local_chipset = NULL; + char *local_firmware = NULL; + char *local_stack_version = NULL; + char *local_profiles = NULL; + + BT_CHECK_INIT_STATUS(); + BT_CHECK_INPUT_PARAMETER(chipset); + BT_CHECK_INPUT_PARAMETER(firmware); + BT_CHECK_INPUT_PARAMETER(stack_version); + BT_CHECK_INPUT_PARAMETER(profiles); + + if ((fp = fopen(BT_ADAPTER_FIRMWARE_INFO_FILE_PATH, "r")) == NULL) { + BT_ERR("fopen() is failed(%s)", BT_ADAPTER_FIRMWARE_INFO_FILE_PATH); + + local_firmware = (char *)malloc(sizeof(char) * 1); + if (local_firmware == NULL) { + ret = BT_ERROR_OUT_OF_MEMORY; + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); + goto ERROR; + } + local_firmware[0] = '\0'; + local_chipset = (char *)malloc(sizeof(char) * 1); + if (local_chipset == NULL) { + ret = BT_ERROR_OUT_OF_MEMORY; + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); + goto ERROR; + } + local_chipset[0] = '\0'; + } else { + fseek(fp, 0, SEEK_END); + lsize = ftell(fp); + if (lsize < 0) { + ret = BT_ERROR_OPERATION_FAILED; + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); + goto ERROR; + } + buf = (char *)malloc(sizeof(char) * (lsize + 1)); + if (buf == NULL) { + ret = BT_ERROR_OUT_OF_MEMORY; + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); + goto ERROR; + } + fseek(fp, 0, SEEK_SET); + result = fread(buf, 1, lsize, fp); + buf[lsize] = '\0'; + + if (result != lsize) + BT_ERR("fread() error"); + + info_start = strstr(buf, "bluetooth"); + if (info_start == NULL) { + ret = BT_ERROR_OPERATION_FAILED; + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); + goto ERROR; + } + info_start += 10; + info_end = strstr(buf, "hcd"); + if (info_end == NULL) { + ret = BT_ERROR_OPERATION_FAILED; + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); + goto ERROR; + } + info_size = info_end - info_start - 1; + + local_firmware = (char *)malloc(sizeof(char) * (info_size + 1)); + if (local_firmware == NULL) { + ret = BT_ERROR_OUT_OF_MEMORY; + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); + goto ERROR; + } + + strncpy(local_firmware, info_start, info_size); + local_firmware[info_size] = '\0'; + + info_end = strchr(buf, '_'); + if (info_end == NULL) { + ret = BT_ERROR_OPERATION_FAILED; + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); + goto ERROR; + } + info_size = info_end - info_start; + + local_chipset = (char *)malloc(sizeof(char) * (info_size + 1)); + if (local_chipset == NULL) { + ret = BT_ERROR_OUT_OF_MEMORY; + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); + goto ERROR; + } + + strncpy(local_chipset, info_start, info_size); + local_chipset[info_size] = '\0'; + + if (buf) + free(buf); + buf = NULL; + fclose(fp); + } + + if ((fp = fopen(BT_ADAPTER_STACK_INFO_FILE_PATH, "r")) == NULL) { + ret = BT_ERROR_OPERATION_FAILED; + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); + goto ERROR; + } + + fseek(fp, 0, SEEK_END); + lsize = ftell(fp); + if (lsize < 0) { + ret = BT_ERROR_OPERATION_FAILED; + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); + goto ERROR; + } + buf = (char *)malloc(sizeof(char) * (lsize + 1)); + if (buf == NULL) { + ret = BT_ERROR_OUT_OF_MEMORY; + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); + goto ERROR; + } + fseek(fp, 0, SEEK_SET); + result = fread(buf, 1, lsize, fp); + buf[lsize] = '\0'; + + if (result != lsize) + BT_ERR("fread() error"); + + info_start = buf; + info_end = strchr(buf, ','); + if (info_end == NULL) { + ret = BT_ERROR_OPERATION_FAILED; + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); + goto ERROR; + } + info_size = info_end - info_start; + + local_stack_version = (char *)malloc(sizeof(char) * (info_size + 1)); + if (local_stack_version == NULL) { + ret = BT_ERROR_OUT_OF_MEMORY; + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); + goto ERROR; + } + + strncpy(local_stack_version, info_start, info_size); + local_stack_version[info_size] = '\0'; + + info_start = info_end + 2; + info_size = lsize - info_size - 3; + + local_profiles = (char *)malloc(sizeof(char) * (info_size + 1)); + if (local_profiles == NULL) { + ret = BT_ERROR_OUT_OF_MEMORY; + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); + goto ERROR; + } + + strncpy(local_profiles, info_start, info_size); + local_profiles[info_size] = '\0'; + + if (buf) + free(buf); + fclose(fp); + + *chipset = local_chipset; + *firmware = local_firmware; + *stack_version = local_stack_version; + *profiles = local_profiles; + + return BT_ERROR_NONE; + +ERROR: + if (local_chipset) + free(local_chipset); + if (local_firmware) + free(local_firmware); + if (local_stack_version) + free(local_stack_version); + if (local_profiles) + free(local_profiles); + if (buf) + free(buf); + if (fp) + fclose(fp); + return ret; } int bt_adapter_get_name(char **name) { - int ret; + int ret = BT_ERROR_NONE; bluetooth_device_name_t loc_name = { {0} }; BT_CHECK_INIT_STATUS(); @@ -151,7 +397,7 @@ int bt_adapter_get_name(char **name) int bt_adapter_set_name(const char *name) { bluetooth_device_name_t loc_name = { {0} }; - int ret; + int ret = BT_ERROR_NONE; BT_CHECK_INIT_STATUS(); BT_CHECK_INPUT_PARAMETER(name); @@ -170,7 +416,7 @@ int bt_adapter_set_name(const char *name) int bt_adapter_get_visibility(bt_adapter_visibility_mode_e *mode, int *duration) { bluetooth_discoverable_mode_t discoverable_mode = BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE; - int ret; + int ret = BT_ERROR_NONE; BT_CHECK_INIT_STATUS(); BT_CHECK_INPUT_PARAMETER(mode); @@ -231,22 +477,56 @@ int bt_adapter_set_visibility(bt_adapter_visibility_mode_e visibility_mode, int int bt_adapter_set_connectable_changed_cb(bt_adapter_connectable_changed_cb callback, void *user_data) { - return BT_ERROR_NOT_SUPPORTED; + int ret = BT_ERROR_NONE; + + BT_CHECK_INIT_STATUS(); + BT_CHECK_INPUT_PARAMETER(callback); + _bt_set_cb(BT_EVENT_CONNECTABLE_CHANGED_EVENT, callback, user_data); + if (ret != BT_ERROR_NONE) { + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); + } + + return ret; } int bt_adapter_unset_connectable_changed_cb(void) { - return BT_ERROR_NOT_SUPPORTED; + BT_CHECK_INIT_STATUS(); + _bt_unset_cb(BT_EVENT_CONNECTABLE_CHANGED_EVENT); + return BT_ERROR_NONE; } int bt_adapter_get_connectable(bool *connectable) { - return BT_ERROR_NOT_SUPPORTED; + gboolean is_connectable = FALSE; + int ret = BT_ERROR_NONE; + + BT_CHECK_INIT_STATUS(); + BT_CHECK_INPUT_PARAMETER(connectable); + + ret = _bt_get_error_code(bluetooth_is_connectable(&is_connectable)); + if (ret != BT_ERROR_NONE) { + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); + return ret; + } + + *connectable = is_connectable ? true : false; + + return BT_ERROR_NONE; } int bt_adapter_set_connectable(bool connectable) { - return BT_ERROR_NOT_SUPPORTED; + int error_code = BT_ERROR_NONE; + + BT_CHECK_INIT_STATUS(); + + error_code = _bt_get_error_code(bluetooth_set_connectable(connectable)); + if (error_code != BT_ERROR_NONE) { + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code); + } + + return error_code; } int bt_adapter_foreach_bonded_device(bt_adapter_bonded_device_cb foreach_cb, void *user_data) @@ -294,6 +574,7 @@ int bt_adapter_foreach_bonded_device(bt_adapter_bonded_device_cb foreach_cb, voi } if (dev_list != NULL) { + g_ptr_array_foreach(dev_list, (GFunc)g_free, NULL); g_ptr_array_free(dev_list, TRUE); } @@ -346,6 +627,7 @@ int bt_adapter_free_device_info(bt_device_info_s *device_info) int bt_adapter_is_service_used(const char *service_uuid, bool *used) { int ret = BT_ERROR_NONE; + gboolean is_used = FALSE; BT_CHECK_INIT_STATUS(); BT_CHECK_INPUT_PARAMETER(service_uuid); @@ -355,7 +637,8 @@ int bt_adapter_is_service_used(const char *service_uuid, bool *used) *used = bluetooth_obex_server_is_activated(); } else { ret = _bt_get_error_code(bluetooth_is_service_used(service_uuid, - (gboolean *)used)); + &is_used)); + *used = is_used ? true : false; } if (ret != BT_ERROR_NONE) { @@ -382,7 +665,12 @@ int bt_adapter_set_state_changed_cb(bt_adapter_state_changed_cb callback, void * int bt_adapter_le_set_state_changed_cb(bt_adapter_le_state_changed_cb callback, void *user_data) { - return BT_ERROR_NOT_SUPPORTED; + BT_CHECK_INIT_STATUS(); + BT_CHECK_INPUT_PARAMETER(callback); + + _bt_le_adapter_init(); + _bt_set_cb(BT_EVENT_LE_STATE_CHANGED, callback, user_data); + return BT_ERROR_NONE; } int bt_adapter_set_name_changed_cb(bt_adapter_name_changed_cb callback, void *user_data) @@ -429,7 +717,12 @@ int bt_adapter_set_device_discovery_state_changed_cb(bt_adapter_device_discovery int bt_adapter_le_set_device_discovery_state_changed_cb(bt_adapter_le_device_discovery_state_changed_cb callback, void *user_data) { - return BT_ERROR_NOT_SUPPORTED; + BT_CHECK_INIT_STATUS(); + BT_CHECK_INPUT_PARAMETER(callback); + + _bt_le_adapter_init(); + _bt_set_cb(BT_EVENT_LE_DEVICE_DISCOVERY_STATE_CHANGED, callback, user_data); + return BT_ERROR_NONE; } int bt_adapter_unset_state_changed_cb(void) @@ -441,7 +734,10 @@ int bt_adapter_unset_state_changed_cb(void) int bt_adapter_le_unset_state_changed_cb(void) { - return BT_ERROR_NOT_SUPPORTED; + BT_CHECK_INIT_STATUS(); + _bt_unset_cb(BT_EVENT_LE_STATE_CHANGED); + _bt_le_adapter_deinit(); + return BT_ERROR_NONE; } int bt_adapter_unset_name_changed_cb(void) @@ -460,12 +756,23 @@ int bt_adapter_unset_visibility_mode_changed_cb(void) int bt_adapter_set_visibility_duration_changed_cb(bt_adapter_visibility_duration_changed_cb callback, void *user_data) { - return BT_ERROR_NOT_SUPPORTED; + int ret = BT_ERROR_NONE; + + BT_CHECK_INIT_STATUS(); + BT_CHECK_INPUT_PARAMETER(callback); + _bt_set_cb(BT_EVENT_VISIBILITY_DURATION_CHANGED, callback, user_data); + if (ret != BT_ERROR_NONE) { + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); + } + + return ret; } int bt_adapter_unset_visibility_duration_changed_cb(void) { - return BT_ERROR_NOT_SUPPORTED; + BT_CHECK_INIT_STATUS(); + _bt_unset_cb(BT_EVENT_VISIBILITY_DURATION_CHANGED); + return BT_ERROR_NONE; } int bt_adapter_unset_device_discovery_state_changed_cb(void) @@ -477,12 +784,15 @@ int bt_adapter_unset_device_discovery_state_changed_cb(void) int bt_adapter_le_unset_device_discovery_state_changed_cb(void) { - return BT_ERROR_NOT_SUPPORTED; + BT_CHECK_INIT_STATUS(); + _bt_unset_cb(BT_EVENT_LE_DEVICE_DISCOVERY_STATE_CHANGED); + _bt_le_adapter_deinit(); + return BT_ERROR_NONE; } int bt_adapter_start_device_discovery(void) { - int error_code; + int error_code = BT_ERROR_NONE; BT_CHECK_INIT_STATUS(); error_code = _bt_get_error_code(bluetooth_start_discovery(0, 0, BLUETOOTH_DEVICE_MAJOR_MASK_MISC)); @@ -494,7 +804,7 @@ int bt_adapter_start_device_discovery(void) int bt_adapter_stop_device_discovery(void) { - int error_code; + int error_code = BT_ERROR_NONE; BT_CHECK_INIT_STATUS(); error_code = _bt_get_error_code(bluetooth_cancel_discovery()); @@ -524,95 +834,489 @@ int bt_adapter_is_discovering(bool *is_discovering) int bt_adapter_le_start_device_discovery(void) { - return BT_ERROR_NOT_SUPPORTED; + int error_code = BT_ERROR_NONE; + + BT_CHECK_INIT_STATUS(); + error_code = _bt_get_error_code(bluetooth_start_le_discovery()); + if (error_code != BT_ERROR_NONE) { + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code); + } + return error_code; } int bt_adapter_le_stop_device_discovery(void) { - return BT_ERROR_NOT_SUPPORTED; + int error_code = BT_ERROR_NONE; + + BT_CHECK_INIT_STATUS(); + error_code = _bt_get_error_code(bluetooth_stop_le_discovery()); + if (error_code != BT_ERROR_NONE) { + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code); + } + return error_code; } int bt_adapter_le_is_discovering(bool *is_discovering) { - return BT_ERROR_NOT_SUPPORTED; + int ret = 0; + + BT_CHECK_INIT_STATUS(); + BT_CHECK_INPUT_PARAMETER(is_discovering); + + ret = bluetooth_is_le_discovering(); + if (ret >= BLUETOOTH_ERROR_BASE) { + *is_discovering = (ret == 1) ? true : false; + return BT_ERROR_NONE; + } else { + ret = _bt_get_error_code(ret); + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); + return ret; + } } int bt_adapter_get_local_oob_data(unsigned char **hash, unsigned char **randomizer, int *hash_len, int *randomizer_len) { - return BT_ERROR_NOT_SUPPORTED; + int ret = BT_ERROR_NONE; + + BT_CHECK_INIT_STATUS(); + BT_CHECK_INPUT_PARAMETER(hash); + BT_CHECK_INPUT_PARAMETER(randomizer); + BT_CHECK_INPUT_PARAMETER(hash_len); + BT_CHECK_INPUT_PARAMETER(randomizer_len); + + bt_oob_data_t oob_data; + + ret = _bt_get_error_code(bluetooth_oob_read_local_data(&oob_data)); + if (BT_ERROR_NONE == ret) { + *hash = g_memdup(oob_data.hash, BLUETOOTH_OOB_DATA_LENGTH); + *randomizer = g_memdup(oob_data.randomizer, + BLUETOOTH_OOB_DATA_LENGTH); + *hash_len = BLUETOOTH_OOB_DATA_LENGTH; + *randomizer_len = BLUETOOTH_OOB_DATA_LENGTH; + } else { + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); + } + return ret; } int bt_adapter_set_remote_oob_data(const char *remote_address, unsigned char *hash, unsigned char *randomizer, int hash_len, int randomizer_len) { - return BT_ERROR_NOT_SUPPORTED; + int ret = BT_ERROR_NONE; + bluetooth_device_address_t addr_hex = { {0,} }; + bt_oob_data_t oob_data = { {0},}; + + BT_CHECK_INIT_STATUS(); + BT_CHECK_INPUT_PARAMETER(remote_address); + + _bt_convert_address_to_hex(&addr_hex, remote_address); + + if (hash != NULL && randomizer != NULL) { + memcpy(oob_data.hash, hash, hash_len); + memcpy(oob_data.randomizer, randomizer, randomizer_len); + oob_data.hash_len = hash_len; + oob_data.randomizer_len = randomizer_len; + } + + ret = _bt_get_error_code(bluetooth_oob_add_remote_data(&addr_hex, &oob_data)); + if (BT_ERROR_NONE != ret) { + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); + } + return ret; } int bt_adapter_remove_remote_oob_data(const char *remote_address) { - return BT_ERROR_NOT_SUPPORTED; + int ret = BT_ERROR_NONE; + bluetooth_device_address_t addr_hex = { {0,} }; + + BT_CHECK_INIT_STATUS(); + BT_CHECK_INPUT_PARAMETER(remote_address); + + _bt_convert_address_to_hex(&addr_hex, remote_address); + + ret = _bt_get_error_code(bluetooth_oob_remove_remote_data(&addr_hex)); + if (BT_ERROR_NONE != ret) { + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); + } + return ret; } int bt_adapter_le_add_white_list(const char *address, bt_device_address_type_e address_type) { - return BT_ERROR_NOT_SUPPORTED; + int error_code = BT_ERROR_NONE; + bluetooth_device_address_t addr_hex = { {0,} }; + + BT_CHECK_INIT_STATUS(); + BT_CHECK_INPUT_PARAMETER(address); + _bt_convert_address_to_hex(&addr_hex, address); + + error_code = _bt_get_error_code(bluetooth_add_white_list(&addr_hex, address_type)); + if (error_code != BT_ERROR_NONE) { + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code); + } + + return error_code; } int bt_adapter_le_remove_white_list(const char *address, bt_device_address_type_e address_type) { - return BT_ERROR_NOT_SUPPORTED; + int error_code = BT_ERROR_NONE; + bluetooth_device_address_t addr_hex = { {0,} }; + + BT_CHECK_INIT_STATUS(); + BT_CHECK_INPUT_PARAMETER(address); + _bt_convert_address_to_hex(&addr_hex, address); + + error_code = _bt_get_error_code(bluetooth_remove_white_list(&addr_hex, address_type)); + if (error_code != BT_ERROR_NONE) { + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code); + } + + return error_code; } int bt_adapter_le_clear_white_list(void) { - return BT_ERROR_NOT_SUPPORTED; + int error_code = BT_ERROR_NONE; + + BT_CHECK_INIT_STATUS(); + + error_code = _bt_get_error_code(bluetooth_clear_white_list()); + if (error_code != BT_ERROR_NONE) { + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code); + } + + return error_code; } int bt_adapter_le_create_advertiser(bt_advertiser_h *advertiser) { - return BT_ERROR_NOT_SUPPORTED; + int ret = BT_ERROR_NONE; + + BT_CHECK_INIT_STATUS(); + BT_CHECK_INPUT_PARAMETER(advertiser); + + *advertiser = (bt_advertiser_h)g_malloc0(sizeof(bt_advertiser_s)); + if (*advertiser == NULL) { + ret = BT_ERROR_OUT_OF_MEMORY; + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); + } + + return ret; } int bt_adapter_le_destroy_advertiser(bt_advertiser_h advertiser) { - return BT_ERROR_NOT_SUPPORTED; + int ret = BT_ERROR_NONE; + int error_code; + bt_advertiser_s *__adv = (bt_advertiser_s *)advertiser; + + BT_CHECK_INIT_STATUS(); + BT_CHECK_INPUT_PARAMETER(advertiser); + + _bt_unset_cb(BT_EVENT_ADVERTISING_STATE_CHANGED); + +#if 0 + if (__adv->handle) { + error_code = bluetooth_stop_advertising(__adv->handle); + ret = _bt_get_error_code(error_code); + if (ret != BT_ERROR_NONE) + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); + __adv->handle = 0; + } +#else + error_code = bluetooth_set_advertising(FALSE); + ret = _bt_get_error_code(error_code); + if (ret != BT_ERROR_NONE) + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); +#endif + + /* Free advertising data */ + if (__adv->adv_data) + free(__adv->adv_data); + if (__adv->scan_rsp_data) + free(__adv->scan_rsp_data); + free(__adv); + + return BT_ERROR_NONE; +} + +static int __bt_remove_ad_data_by_type(char *in_data, unsigned int in_len, + char in_type, char **data, unsigned int *data_len) +{ + if (in_data == NULL || data == NULL || data_len == NULL) + return BT_ERROR_OPERATION_FAILED; + + int i; + int len = 0; + int type = 0; + char *p; + + for (i = 0; i < in_len; i++) { + len = in_data[i]; + if (len <= 0 || i + 1 >= in_len) { + BT_ERR("Invalid advertising data"); + return BT_ERROR_OPERATION_FAILED; + } + + type = in_data[i + 1]; + if (type == in_type) { + i = i + 2; + len--; + break; + } + + i += len; + len = 0; + } + + if (i + len > in_len) { + BT_ERR("Invalid advertising data"); + return BT_ERROR_OPERATION_FAILED; + } else if (len == 0) { + BT_INFO("AD Type 0x%02x data is not set", in_type); + return BT_ERROR_OPERATION_FAILED; + } + + p = (char *)malloc(sizeof(char) * (in_len - len)); + if (p == NULL) { + return BT_ERROR_OUT_OF_MEMORY; + } + + memcpy(p, in_data, sizeof(char) * i); + memcpy(p + i, in_data + i + len, sizeof(char) * (in_len - len - i)); + + *data = p; + *data_len = in_len - len; + + return BT_ERROR_NONE; } int bt_adapter_le_add_advertising_data(bt_advertiser_h advertiser, bt_adapter_le_packet_type_e pkt_type, bt_adapter_le_packet_data_type_e data_type, void *data, unsigned int data_size) { - return BT_ERROR_NOT_SUPPORTED; + int ret = BT_ERROR_NONE; + bt_advertiser_s *__adv = (bt_advertiser_s *)advertiser; + char **p; + unsigned int *len; + char *new_p; + + BT_CHECK_INIT_STATUS(); + BT_CHECK_INPUT_PARAMETER(advertiser); + + switch (pkt_type) { + case BT_ADAPTER_LE_PACKET_ADVERTISING: + p = &__adv->adv_data; + len = &__adv->adv_data_len; + break; + + case BT_ADAPTER_LE_PACKET_SCAN_RESPONSE: + p = &__adv->scan_rsp_data; + len = &__adv->scan_rsp_data_len; + break; + + default: + BT_ERR("Unknown LE packet type : %d", pkt_type); + return BT_ERROR_INVALID_PARAMETER; + } + + /* 2 bytes are required for Length and AD Type */ + if (*len + data_size + 2 > 31) { + return BT_ERROR_QUOTA_EXCEEDED; + } + + if (*len == 0) + *p = NULL; + + new_p = realloc(*p, sizeof(char) * (*len + data_size + 2)); + if (new_p == NULL) { + return BT_ERROR_OUT_OF_MEMORY; + } + + new_p[*len] = data_size + 1; + new_p[*len + 1] = data_type; + memcpy(new_p + (*len + 2), data, data_size); + + *p = new_p; + *len += data_size + 2; + + return ret; } int bt_adapter_le_remove_advertising_data(bt_advertiser_h advertiser, bt_adapter_le_packet_type_e pkt_type, bt_adapter_le_packet_data_type_e data_type) { - return BT_ERROR_NOT_SUPPORTED; + int ret = BT_ERROR_NONE; + bt_advertiser_s *__adv = (bt_advertiser_s *)advertiser; + char **p; + unsigned int *len; + char *new_p = NULL; + unsigned int new_len = 0; + + BT_CHECK_INIT_STATUS(); + BT_CHECK_INPUT_PARAMETER(advertiser); + + switch (pkt_type) { + case BT_ADAPTER_LE_PACKET_ADVERTISING: + p = &__adv->adv_data; + len = &__adv->adv_data_len; + break; + + case BT_ADAPTER_LE_PACKET_SCAN_RESPONSE: + p = &__adv->scan_rsp_data; + len = &__adv->scan_rsp_data_len; + break; + + default: + BT_ERR("Unknown LE packet type : %d", pkt_type); + return BT_ERROR_INVALID_PARAMETER; + } + + ret = __bt_remove_ad_data_by_type(*p, *len, data_type, &new_p, &new_len); + if (ret != BT_ERROR_NONE) { + return ret; + } + + free(*p); + *p = new_p; + *len = new_len; + + return ret; } int bt_adapter_le_clear_advertising_data(bt_advertiser_h advertiser, bt_adapter_le_packet_type_e pkt_type) { - return BT_ERROR_NOT_SUPPORTED; + int ret = BT_ERROR_NONE; + bt_advertiser_s *__adv = (bt_advertiser_s *)advertiser; + char **p; + unsigned int *len; + + BT_CHECK_INIT_STATUS(); + BT_CHECK_INPUT_PARAMETER(advertiser); + + switch (pkt_type) { + case BT_ADAPTER_LE_PACKET_ADVERTISING: + p = &__adv->adv_data; + len = &__adv->adv_data_len; + break; + + case BT_ADAPTER_LE_PACKET_SCAN_RESPONSE: + p = &__adv->scan_rsp_data; + len = &__adv->scan_rsp_data_len; + break; + + default: + BT_ERR("Unknown LE packet type : %d", pkt_type); + return BT_ERROR_INVALID_PARAMETER; + } + + if (*p) { + free(*p); + *p = NULL; + } + *len = 0; + + return ret; } int bt_adapter_le_start_advertising(bt_advertiser_h advertiser, bt_adapter_le_advertising_params_s *adv_params, bt_adapter_le_advertising_state_changed_cb cb, void *user_data) { - return BT_ERROR_NOT_SUPPORTED; + int ret = BT_ERROR_NONE; + int error_code; + bt_advertiser_s *__adv = (bt_advertiser_s *)advertiser; + bluetooth_advertising_data_t adv = { {0} }; + bluetooth_scan_resp_data_t resp = { {0} }; + + BT_CHECK_INIT_STATUS(); + BT_CHECK_INPUT_PARAMETER(advertiser); + +#if 0 + error_code = bluetooth_start_advertising(__adv, cb, user_data); + ret = _bt_get_error_code(error_code); + if (ret != BT_ERROR_NONE) { + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); + } +#endif + + if (__adv->adv_data_len > 0 && __adv->adv_data) { + memcpy(adv.data, __adv->adv_data, __adv->adv_data_len); + error_code = bluetooth_set_advertising_data(&adv, __adv->adv_data_len); + ret = _bt_get_error_code(error_code); + if (ret != BT_ERROR_NONE) { + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); + return ret; + } + } + + if (__adv->scan_rsp_data_len > 0 && __adv->scan_rsp_data) { + memcpy(resp.data, __adv->scan_rsp_data, __adv->scan_rsp_data_len); + error_code = bluetooth_set_scan_response_data(&resp, __adv->scan_rsp_data_len); + ret = _bt_get_error_code(error_code); + if (ret != BT_ERROR_NONE) { + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); + return ret; + } + } + + if (adv_params == NULL) { + error_code = bluetooth_set_advertising(TRUE); + } else { + error_code = bluetooth_set_custom_advertising(TRUE, + (bluetooth_advertising_params_t *)adv_params); + } + + ret = _bt_get_error_code(error_code); + if (ret != BT_ERROR_NONE) { + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); + return ret; + } + + _bt_set_cb(BT_EVENT_ADVERTISING_STATE_CHANGED, cb, user_data); + + return ret; } int bt_adapter_le_stop_advertising(bt_advertiser_h advertiser) { - return BT_ERROR_NOT_SUPPORTED; + int ret = BT_ERROR_NONE; +// bt_advertiser_s *__adv = (bt_advertiser_s *)advertiser; + + BT_CHECK_INIT_STATUS(); + +#if 0 + error_code = bluetooth_stop_advertising(__adv, cb, user_data); + ret = _bt_get_error_code(error_code); + if (ret != BT_ERROR_NONE) { + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); + } +#endif + + ret = _bt_get_error_code(bluetooth_set_advertising(FALSE)); + if (ret != BT_ERROR_NONE) { + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); + } + + return ret; } int bt_adapter_le_enable_privacy(bool enable_privacy) { - return BT_ERROR_NOT_SUPPORTED; + int error_code = BT_ERROR_NONE; + + BT_CHECK_INIT_STATUS(); + + error_code = _bt_get_error_code(bluetooth_enable_le_privacy(enable_privacy)); + + if (error_code != BT_ERROR_NONE) { + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code); + } + return error_code; } diff --git a/src/bluetooth-audio.c b/src/bluetooth-audio.c old mode 100644 new mode 100755 index 990f2e1..54b4e0b --- a/src/bluetooth-audio.c +++ b/src/bluetooth-audio.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved * * Licensed under the Apache License, Version 2.0 (the License); * you may not use this file except in compliance with the License. @@ -22,11 +22,31 @@ #include "bluetooth_private.h" #include "bluetooth-audio-api.h" #include "bluetooth-telephony-api.h" +#include "bluetooth-scmst-api.h" typedef struct _call_list_s { GList *list; } call_list_s; +static bool is_audio_initialized = false; + +#define BT_CHECK_AUDIO_INIT_STATUS() \ + if (__bt_check_audio_init_status() == BT_ERROR_NOT_INITIALIZED) \ + { \ + LOGE("[%s] NOT_INITIALIZED(0x%08x)", __FUNCTION__, BT_ERROR_NOT_INITIALIZED); \ + return BT_ERROR_NOT_INITIALIZED; \ + } + +int __bt_check_audio_init_status(void) +{ + if (is_audio_initialized != true) { + BT_ERR("NOT_INITIALIZED(0x%08x)", BT_ERROR_NOT_INITIALIZED); + return BT_ERROR_NOT_INITIALIZED; + } + + return BT_ERROR_NONE; +} + /*The below API is just to convert the error from Telephony API's to CAPI error codes, * this is temporary change and changes to proper error code will be done in * subsequent check ins.*/ @@ -57,6 +77,8 @@ int _bt_convert_telephony_error_code(int error) case BLUETOOTH_TELEPHONY_ERROR_I_O_ERROR: case BLUETOOTH_TELEPHONY_ERROR_OPERATION_NOT_AVAILABLE: return BT_ERROR_OPERATION_FAILED; + case BLUETOOTH_TELEPHONY_ERROR_PERMISSION_DENIED: + return BT_ERROR_PERMISSION_DENIED; default: return BT_ERROR_NONE; } @@ -73,14 +95,18 @@ int bt_audio_initialize(void) BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); return error; } + +#ifndef TELEPHONY_DISABLED /* B2_3G */ error = bluetooth_telephony_init((void *)_bt_telephony_event_proxy, NULL); error = _bt_convert_telephony_error_code(error); - error = _bt_get_error_code(error); if (BT_ERROR_NONE != error) { - BT_ERR("[%s] (0x%08x)", - _bt_convert_error_to_string(error), error); + BT_ERR("[%s] (0x%08x)", _bt_convert_error_to_string(error), error); + return error; } - return error; +#endif + + is_audio_initialized = true; + return BT_ERROR_NONE; } int bt_audio_deinitialize(void) @@ -88,19 +114,26 @@ int bt_audio_deinitialize(void) int error; BT_CHECK_INIT_STATUS(); + BT_CHECK_AUDIO_INIT_STATUS(); + error = bluetooth_audio_deinit(); error = _bt_get_error_code(error); if (BT_ERROR_NONE != error) { BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); return error; } + +#ifndef TELEPHONY_DISABLED /* B2_3G */ error = bluetooth_telephony_deinit(); error = _bt_convert_telephony_error_code(error); - error = _bt_get_error_code(error); if (BT_ERROR_NONE != error) { BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); + return error; } - return error; +#endif + + is_audio_initialized = false; + return BT_ERROR_NONE; } int bt_audio_connect(const char *remote_address, bt_audio_profile_type_e type) @@ -109,6 +142,15 @@ int bt_audio_connect(const char *remote_address, bt_audio_profile_type_e type) bluetooth_device_address_t addr_hex = { {0,} }; BT_CHECK_INIT_STATUS(); + BT_CHECK_AUDIO_INIT_STATUS(); + +#ifdef TELEPHONY_DISABLED + if (type == BT_AUDIO_PROFILE_TYPE_HSP_HFP) { + BT_ERR("NOT SUPPORTED(0x%08x)", BT_ERROR_NOT_SUPPORTED); + return BT_ERROR_NOT_SUPPORTED; + } +#endif + BT_CHECK_INPUT_PARAMETER(remote_address); _bt_convert_address_to_hex(&addr_hex, remote_address); switch(type) { @@ -136,6 +178,15 @@ int bt_audio_disconnect(const char *remote_address, bt_audio_profile_type_e type bluetooth_device_address_t addr_hex = { {0,} }; BT_CHECK_INIT_STATUS(); + BT_CHECK_AUDIO_INIT_STATUS(); + +#ifdef TELEPHONY_DISABLED + if (type == BT_AUDIO_PROFILE_TYPE_HSP_HFP) { + BT_ERR("NOT SUPPORTED(0x%08x)", BT_ERROR_NOT_SUPPORTED); + return BT_ERROR_NOT_SUPPORTED; + } +#endif + BT_CHECK_INPUT_PARAMETER(remote_address); _bt_convert_address_to_hex(&addr_hex, remote_address); switch(type) { @@ -160,6 +211,7 @@ int bt_audio_disconnect(const char *remote_address, bt_audio_profile_type_e type int bt_audio_set_connection_state_changed_cb(bt_audio_connection_state_changed_cb callback, void *user_data) { BT_CHECK_INIT_STATUS(); + BT_CHECK_AUDIO_INIT_STATUS(); BT_CHECK_INPUT_PARAMETER(callback); _bt_set_cb(BT_EVENT_AUDIO_CONNECTION_STATUS, callback, user_data); return BT_ERROR_NONE; @@ -168,6 +220,7 @@ int bt_audio_set_connection_state_changed_cb(bt_audio_connection_state_changed_c int bt_audio_unset_connection_state_changed_cb(void) { BT_CHECK_INIT_STATUS(); + BT_CHECK_AUDIO_INIT_STATUS(); if (_bt_check_cb(BT_EVENT_AUDIO_CONNECTION_STATUS) == true) _bt_unset_cb(BT_EVENT_AUDIO_CONNECTION_STATUS); return BT_ERROR_NONE; @@ -175,139 +228,223 @@ int bt_audio_unset_connection_state_changed_cb(void) int bt_ag_notify_speaker_gain(int gain) { +#ifdef TELEPHONY_DISABLED + BT_ERR("NOT SUPPORTED(0x%08x)", BT_ERROR_NOT_SUPPORTED); + return BT_ERROR_NOT_SUPPORTED; +#else int error; BT_CHECK_INIT_STATUS(); + BT_CHECK_AUDIO_INIT_STATUS(); error = bluetooth_telephony_set_speaker_gain((unsigned short)gain); - error = _bt_get_error_code(error); + error = _bt_convert_telephony_error_code(error); if (BT_ERROR_NONE != error) { BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); } return error; +#endif } int bt_ag_get_speaker_gain(int *gain) { +#ifdef TELEPHONY_DISABLED + BT_ERR("NOT SUPPORTED(0x%08x)", BT_ERROR_NOT_SUPPORTED); + return BT_ERROR_NOT_SUPPORTED; +#else int error; BT_CHECK_INIT_STATUS(); + BT_CHECK_AUDIO_INIT_STATUS(); BT_CHECK_INPUT_PARAMETER(gain); error = bluetooth_telephony_get_headset_volume((unsigned int *)gain); - error = _bt_get_error_code(error); + error = _bt_convert_telephony_error_code(error); if (BT_ERROR_NONE != error) { BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); } return error; +#endif } int bt_ag_is_nrec_enabled(bool *enabled) { +#ifdef TELEPHONY_DISABLED + BT_ERR("NOT SUPPORTED(0x%08x)", BT_ERROR_NOT_SUPPORTED); + return BT_ERROR_NOT_SUPPORTED; +#else int error; + gboolean is_enabled = FALSE; BT_CHECK_INIT_STATUS(); + BT_CHECK_AUDIO_INIT_STATUS(); BT_CHECK_INPUT_PARAMETER(enabled); - error = bluetooth_telephony_is_nrec_enabled((gboolean *)enabled); - error = _bt_get_error_code(error); + error = bluetooth_telephony_is_nrec_enabled(&is_enabled); + error = _bt_convert_telephony_error_code(error); if (BT_ERROR_NONE != error) { BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); } + if (is_enabled) + *enabled = true; + else + *enabled = false; return error; +#endif } int bt_ag_set_microphone_gain_changed_cb(bt_ag_microphone_gain_changed_cb callback, void *user_data) { +#ifdef TELEPHONY_DISABLED + BT_ERR("NOT SUPPORTED(0x%08x)", BT_ERROR_NOT_SUPPORTED); + return BT_ERROR_NOT_SUPPORTED; +#else BT_CHECK_INIT_STATUS(); + BT_CHECK_AUDIO_INIT_STATUS(); BT_CHECK_INPUT_PARAMETER(callback); _bt_set_cb(BT_EVENT_AG_MICROPHONE_GAIN_CHANGE, callback, user_data); return BT_ERROR_NONE; - +#endif } int bt_ag_unset_microphone_gain_changed_cb(void) { +#ifdef TELEPHONY_DISABLED + BT_ERR("NOT SUPPORTED(0x%08x)", BT_ERROR_NOT_SUPPORTED); + return BT_ERROR_NOT_SUPPORTED; +#else BT_CHECK_INIT_STATUS(); + BT_CHECK_AUDIO_INIT_STATUS(); if (_bt_check_cb(BT_EVENT_AG_MICROPHONE_GAIN_CHANGE) == true) _bt_unset_cb(BT_EVENT_AG_MICROPHONE_GAIN_CHANGE); return BT_ERROR_NONE; +#endif } int bt_ag_set_speaker_gain_changed_cb(bt_ag_speaker_gain_changed_cb callback, void *user_data) { +#ifdef TELEPHONY_DISABLED + BT_ERR("NOT SUPPORTED(0x%08x)", BT_ERROR_NOT_SUPPORTED); + return BT_ERROR_NOT_SUPPORTED; +#else BT_CHECK_INIT_STATUS(); + BT_CHECK_AUDIO_INIT_STATUS(); BT_CHECK_INPUT_PARAMETER(callback); _bt_set_cb(BT_EVENT_AG_SPEAKER_GAIN_CHANGE, callback, user_data); return BT_ERROR_NONE; +#endif } int bt_ag_unset_speaker_gain_changed_cb(void) { +#ifdef TELEPHONY_DISABLED + BT_ERR("NOT SUPPORTED(0x%08x)", BT_ERROR_NOT_SUPPORTED); + return BT_ERROR_NOT_SUPPORTED; +#else BT_CHECK_INIT_STATUS(); + BT_CHECK_AUDIO_INIT_STATUS(); if (_bt_check_cb(BT_EVENT_AG_SPEAKER_GAIN_CHANGE) == true) _bt_unset_cb(BT_EVENT_AG_SPEAKER_GAIN_CHANGE); return BT_ERROR_NONE; +#endif } int bt_ag_open_sco(void) { +#ifdef TELEPHONY_DISABLED + BT_ERR("NOT SUPPORTED(0x%08x)", BT_ERROR_NOT_SUPPORTED); + return BT_ERROR_NOT_SUPPORTED; +#else int error; BT_CHECK_INIT_STATUS(); + BT_CHECK_AUDIO_INIT_STATUS(); error = bluetooth_telephony_audio_open(); error = _bt_convert_telephony_error_code(error); - error = _bt_get_error_code(error); if (error != BT_ERROR_NONE) { BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); } return error; +#endif } int bt_ag_close_sco(void) { +#ifdef TELEPHONY_DISABLED + BT_ERR("NOT SUPPORTED(0x%08x)", BT_ERROR_NOT_SUPPORTED); + return BT_ERROR_NOT_SUPPORTED; +#else int error; BT_CHECK_INIT_STATUS(); + BT_CHECK_AUDIO_INIT_STATUS(); error = bluetooth_telephony_audio_close(); error = _bt_convert_telephony_error_code(error); - error = _bt_get_error_code(error); if (error != BT_ERROR_NONE) { BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); } return error; +#endif } int bt_ag_is_sco_opened(bool *opened) { +#ifdef TELEPHONY_DISABLED + BT_ERR("NOT SUPPORTED(0x%08x)", BT_ERROR_NOT_SUPPORTED); + return BT_ERROR_NOT_SUPPORTED; +#else BT_CHECK_INIT_STATUS(); + BT_CHECK_AUDIO_INIT_STATUS(); BT_CHECK_INPUT_PARAMETER(opened); - *opened = bluetooth_telephony_is_sco_connected(); + if (bluetooth_telephony_is_sco_connected()) + *opened = true; + else + *opened = false; return BT_ERROR_NONE; +#endif } int bt_ag_set_sco_state_changed_cb(bt_ag_sco_state_changed_cb callback, void *user_data) { +#ifdef TELEPHONY_DISABLED + BT_ERR("NOT SUPPORTED(0x%08x)", BT_ERROR_NOT_SUPPORTED); + return BT_ERROR_NOT_SUPPORTED; +#else BT_CHECK_INIT_STATUS(); + BT_CHECK_AUDIO_INIT_STATUS(); BT_CHECK_INPUT_PARAMETER(callback); _bt_set_cb(BT_EVENT_AG_SCO_CONNECTION_STATUS, callback, user_data); return BT_ERROR_NONE; +#endif } int bt_ag_unset_sco_state_changed_cb(void) { +#ifdef TELEPHONY_DISABLED + BT_ERR("NOT SUPPORTED(0x%08x)", BT_ERROR_NOT_SUPPORTED); + return BT_ERROR_NOT_SUPPORTED; +#else BT_CHECK_INIT_STATUS(); + BT_CHECK_AUDIO_INIT_STATUS(); if (_bt_check_cb(BT_EVENT_AG_SCO_CONNECTION_STATUS) == true) _bt_unset_cb(BT_EVENT_AG_SCO_CONNECTION_STATUS); return BT_ERROR_NONE; +#endif } int bt_ag_notify_call_event(bt_ag_call_event_e event, unsigned int call_id, const char *phone_number) { +#ifdef TELEPHONY_DISABLED + BT_ERR("NOT SUPPORTED(0x%08x)", BT_ERROR_NOT_SUPPORTED); + return BT_ERROR_NOT_SUPPORTED; +#else int error; BT_CHECK_INIT_STATUS(); + BT_CHECK_AUDIO_INIT_STATUS(); + BT_INFO("call_id [%d] / event [%d]", call_id, event); + switch(event) { case BT_AG_CALL_EVENT_IDLE: error = bluetooth_telephony_call_end(call_id); @@ -338,100 +475,145 @@ int bt_ag_notify_call_event(bt_ag_call_event_e event, unsigned int call_id, cons error = BT_ERROR_INVALID_PARAMETER; } error = _bt_convert_telephony_error_code(error); - error = _bt_get_error_code(error); if (error != BT_ERROR_NONE) { BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); } return error; +#endif } int bt_ag_notify_call_list(bt_call_list_h list) { +#ifdef TELEPHONY_DISABLED + BT_ERR("NOT SUPPORTED(0x%08x)", BT_ERROR_NOT_SUPPORTED); + return BT_ERROR_NOT_SUPPORTED; +#else int error; unsigned int call_count; call_list_s *handle; BT_CHECK_INIT_STATUS(); + BT_CHECK_AUDIO_INIT_STATUS(); BT_CHECK_INPUT_PARAMETER(list); handle = (call_list_s *)list; call_count = g_list_length(handle->list); error = bluetooth_telephony_set_call_status((void *)handle->list, call_count); error = _bt_convert_telephony_error_code(error); - error = _bt_get_error_code(error); if (error != BT_ERROR_NONE) { BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); } return error; +#endif } int bt_ag_notify_voice_recognition_state(bool state) { +#ifdef TELEPHONY_DISABLED + BT_ERR("NOT SUPPORTED(0x%08x)", BT_ERROR_NOT_SUPPORTED); + return BT_ERROR_NOT_SUPPORTED; +#else int error; BT_CHECK_INIT_STATUS(); + BT_CHECK_AUDIO_INIT_STATUS(); if (state) error = bluetooth_telephony_start_voice_recognition(); else error = bluetooth_telephony_stop_voice_recognition(); error = _bt_convert_telephony_error_code(error); - error = _bt_get_error_code(error); if (error != BT_ERROR_NONE) { BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); } return error; +#endif } int bt_ag_set_call_handling_event_cb(bt_ag_call_handling_event_cb callback, void *user_data) { +#ifdef TELEPHONY_DISABLED + BT_ERR("NOT SUPPORTED(0x%08x)", BT_ERROR_NOT_SUPPORTED); + return BT_ERROR_NOT_SUPPORTED; +#else BT_CHECK_INIT_STATUS(); + BT_CHECK_AUDIO_INIT_STATUS(); BT_CHECK_INPUT_PARAMETER(callback); _bt_set_cb(BT_EVENT_AG_CALL_HANDLING_EVENT, callback, user_data); return BT_ERROR_NONE; - +#endif } int bt_ag_unset_call_handling_event_cb(void) { +#ifdef TELEPHONY_DISABLED + BT_ERR("NOT SUPPORTED(0x%08x)", BT_ERROR_NOT_SUPPORTED); + return BT_ERROR_NOT_SUPPORTED; +#else BT_CHECK_INIT_STATUS(); + BT_CHECK_AUDIO_INIT_STATUS(); if (_bt_check_cb(BT_EVENT_AG_CALL_HANDLING_EVENT) == true) _bt_unset_cb(BT_EVENT_AG_CALL_HANDLING_EVENT); return BT_ERROR_NONE; +#endif } int bt_ag_set_multi_call_handling_event_cb( bt_ag_multi_call_handling_event_cb callback, void *user_data) { +#ifdef TELEPHONY_DISABLED + BT_ERR("NOT SUPPORTED(0x%08x)", BT_ERROR_NOT_SUPPORTED); + return BT_ERROR_NOT_SUPPORTED; +#else BT_CHECK_INIT_STATUS(); + BT_CHECK_AUDIO_INIT_STATUS(); BT_CHECK_INPUT_PARAMETER(callback); _bt_set_cb(BT_EVENT_AG_MULTI_CALL_HANDLING_EVENT, callback, user_data); return BT_ERROR_NONE; +#endif } int bt_ag_unset_multi_call_handling_event_cb(void) { +#ifdef TELEPHONY_DISABLED + BT_ERR("NOT SUPPORTED(0x%08x)", BT_ERROR_NOT_SUPPORTED); + return BT_ERROR_NOT_SUPPORTED; +#else BT_CHECK_INIT_STATUS(); + BT_CHECK_AUDIO_INIT_STATUS(); if (_bt_check_cb(BT_EVENT_AG_MULTI_CALL_HANDLING_EVENT) == true) _bt_unset_cb(BT_EVENT_AG_MULTI_CALL_HANDLING_EVENT); return BT_ERROR_NONE; +#endif } int bt_ag_set_dtmf_transmitted_cb(bt_ag_dtmf_transmitted_cb callback, void *user_data) { +#ifdef TELEPHONY_DISABLED + BT_ERR("NOT SUPPORTED(0x%08x)", BT_ERROR_NOT_SUPPORTED); + return BT_ERROR_NOT_SUPPORTED; +#else BT_CHECK_INIT_STATUS(); + BT_CHECK_AUDIO_INIT_STATUS(); BT_CHECK_INPUT_PARAMETER(callback); _bt_set_cb(BT_EVENT_AG_DTMF_TRANSMITTED, callback, user_data); return BT_ERROR_NONE; +#endif } int bt_ag_unset_dtmf_transmitted_cb(void) { +#ifdef TELEPHONY_DISABLED + BT_ERR("NOT SUPPORTED(0x%08x)", BT_ERROR_NOT_SUPPORTED); + return BT_ERROR_NOT_SUPPORTED; +#else BT_CHECK_INIT_STATUS(); + BT_CHECK_AUDIO_INIT_STATUS(); if (_bt_check_cb(BT_EVENT_AG_DTMF_TRANSMITTED) == true) _bt_unset_cb(BT_EVENT_AG_DTMF_TRANSMITTED); return BT_ERROR_NONE; +#endif } int bt_call_list_create(bt_call_list_h *list) @@ -439,6 +621,8 @@ int bt_call_list_create(bt_call_list_h *list) call_list_s *handle; BT_CHECK_INIT_STATUS(); + BT_CHECK_AUDIO_INIT_STATUS(); + BT_CHECK_INPUT_PARAMETER(list); if (*list != NULL) { BT_ERR("BT_ERROR_ALREADY_DONE(0x%08x)", BT_ERROR_ALREADY_DONE); return BT_ERROR_ALREADY_DONE; @@ -454,6 +638,7 @@ int bt_call_list_destroy(bt_call_list_h list) call_list_s *handle; BT_CHECK_INIT_STATUS(); + BT_CHECK_AUDIO_INIT_STATUS(); BT_CHECK_INPUT_PARAMETER(list); handle = (call_list_s *)list; result = bt_call_list_reset(list); @@ -467,6 +652,7 @@ int bt_call_list_reset(bt_call_list_h list) bt_telephony_call_status_info_t *call_status; BT_CHECK_INIT_STATUS(); + BT_CHECK_AUDIO_INIT_STATUS(); BT_CHECK_INPUT_PARAMETER(list); handle = (call_list_s *)list; do { @@ -474,6 +660,10 @@ int bt_call_list_reset(bt_call_list_h list) if (call_status == NULL) break; handle->list = g_list_remove(handle->list, call_status); + + if (NULL != call_status->phone_number) + g_free(call_status->phone_number); + g_free(call_status); } while (1); return BT_ERROR_NONE; @@ -485,11 +675,16 @@ int bt_call_list_add(bt_call_list_h list, unsigned int call_id, bt_ag_call_state bt_telephony_call_status_info_t *call_status; BT_CHECK_INIT_STATUS(); + BT_CHECK_AUDIO_INIT_STATUS(); BT_CHECK_INPUT_PARAMETER(list); + BT_CHECK_INPUT_PARAMETER(phone_number); + handle = (call_list_s *)list; call_status = g_malloc0(sizeof(bt_telephony_call_status_info_t)); call_status->call_id = call_id; call_status->call_status = state; + call_status->phone_number = g_strdup(phone_number); + handle->list = g_list_append(handle->list, (gpointer)call_status); return BT_ERROR_NONE; } diff --git a/src/bluetooth-avrcp.c b/src/bluetooth-avrcp.c old mode 100644 new mode 100755 index 9eb4cd6..118db9d --- a/src/bluetooth-avrcp.c +++ b/src/bluetooth-avrcp.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved * * Licensed under the Apache License, Version 2.0 (the License); * you may not use this file except in compliance with the License. @@ -22,6 +22,25 @@ #include "bluetooth-audio-api.h" #include "bluetooth-media-control.h" +static bool is_avrcp_target_initialized = false; + +#define BT_CHECK_AVRCP_TARGET_INIT_STATUS() \ + if (__bt_check_avrcp_target_init_status() == BT_ERROR_NOT_INITIALIZED) \ + { \ + LOGE("[%s] NOT_INITIALIZED(0x%08x)", __FUNCTION__, BT_ERROR_NOT_INITIALIZED); \ + return BT_ERROR_NOT_INITIALIZED; \ + } + +int __bt_check_avrcp_target_init_status(void) +{ + if (is_avrcp_target_initialized != true) { + BT_ERR("NOT_INITIALIZED(0x%08x)", BT_ERROR_NOT_INITIALIZED); + return BT_ERROR_NOT_INITIALIZED; + } + + return BT_ERROR_NONE; +} + /*The below API is just to conver the error from Audio API's to CAPI error codes, * this is temporary change and changes to proper error code will be done in * subsequent check ins.*/ @@ -51,8 +70,11 @@ int bt_avrcp_target_initialize(bt_avrcp_target_connection_state_changed_cb callb error = _bt_get_error_code(error); if (BT_ERROR_NONE != error) { BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); + return error; } - return error; + + is_avrcp_target_initialized = true; + return BT_ERROR_NONE; } int bt_avrcp_target_deinitialize(void) @@ -60,6 +82,7 @@ int bt_avrcp_target_deinitialize(void) int error; BT_CHECK_INIT_STATUS(); + BT_CHECK_AVRCP_TARGET_INIT_STATUS(); if (_bt_check_cb(BT_EVENT_AVRCP_CONNECTION_STATUS) == true) _bt_unset_cb(BT_EVENT_AVRCP_CONNECTION_STATUS); @@ -69,14 +92,18 @@ int bt_avrcp_target_deinitialize(void) error = _bt_get_error_code(error); if (BT_ERROR_NONE != error) { BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); + return error; } - return error; + + is_avrcp_target_initialized = false; + return BT_ERROR_NONE; } int bt_avrcp_target_notify_equalizer_state(bt_avrcp_equalizer_state_e state) { int error; BT_CHECK_INIT_STATUS(); + BT_CHECK_AVRCP_TARGET_INIT_STATUS(); error = bluetooth_media_player_change_property(EQUALIZER, state); error = _bt_convert_avrcp_error_code(error); error = _bt_get_error_code(error); @@ -89,6 +116,7 @@ int bt_avrcp_target_notify_repeat_mode(bt_avrcp_repeat_mode_e mode) { int error; BT_CHECK_INIT_STATUS(); + BT_CHECK_AVRCP_TARGET_INIT_STATUS(); error = bluetooth_media_player_change_property(REPEAT, mode); error = _bt_convert_avrcp_error_code(error); error = _bt_get_error_code(error); @@ -102,6 +130,7 @@ int bt_avrcp_target_notify_shuffle_mode(bt_avrcp_shuffle_mode_e mode) { int error; BT_CHECK_INIT_STATUS(); + BT_CHECK_AVRCP_TARGET_INIT_STATUS(); error = bluetooth_media_player_change_property(SHUFFLE, mode); error = _bt_convert_avrcp_error_code(error); error = _bt_get_error_code(error); @@ -114,6 +143,7 @@ int bt_avrcp_target_notify_scan_mode(bt_avrcp_scan_mode_e mode) { int error; BT_CHECK_INIT_STATUS(); + BT_CHECK_AVRCP_TARGET_INIT_STATUS(); error = bluetooth_media_player_change_property(SCAN, mode); error = _bt_convert_avrcp_error_code(error); error = _bt_get_error_code(error); @@ -127,6 +157,7 @@ int bt_avrcp_target_notify_player_state(bt_avrcp_player_state_e state) { int error; BT_CHECK_INIT_STATUS(); + BT_CHECK_AVRCP_TARGET_INIT_STATUS(); error = bluetooth_media_player_change_property(STATUS, state); error = _bt_convert_avrcp_error_code(error); error = _bt_get_error_code(error); @@ -140,6 +171,7 @@ int bt_avrcp_target_notify_position(unsigned int position) { int error; BT_CHECK_INIT_STATUS(); + BT_CHECK_AVRCP_TARGET_INIT_STATUS(); error = bluetooth_media_player_change_property(POSITION, position); error = _bt_convert_avrcp_error_code(error); error = _bt_get_error_code(error); @@ -154,6 +186,7 @@ int bt_avrcp_target_notify_track(const char *title, const char *artist, const ch { int error; BT_CHECK_INIT_STATUS(); + BT_CHECK_AVRCP_TARGET_INIT_STATUS(); media_metadata_attributes_t metadata; metadata.title = title; metadata.artist = artist; @@ -181,6 +214,7 @@ int bt_avrcp_set_equalizer_state_changed_cb(bt_avrcp_equalizer_state_changed_cb int bt_avrcp_unset_equalizer_state_changed_cb(void) { + BT_CHECK_INIT_STATUS(); _bt_unset_cb(BT_EVENT_AVRCP_EQUALIZER_STATE_CHANGED); return BT_ERROR_NONE; } @@ -195,6 +229,7 @@ int bt_avrcp_set_repeat_mode_changed_cb(bt_avrcp_repeat_mode_changed_cb callback int bt_avrcp_unset_repeat_mode_changed_cb(void) { + BT_CHECK_INIT_STATUS(); _bt_unset_cb(BT_EVENT_AVRCP_REPEAT_MODE_CHANGED); return BT_ERROR_NONE; } @@ -209,6 +244,7 @@ int bt_avrcp_set_shuffle_mode_changed_cb(bt_avrcp_shuffle_mode_changed_cb callba int bt_avrcp_unset_shuffle_mode_changed_cb(void) { + BT_CHECK_INIT_STATUS(); _bt_unset_cb(BT_EVENT_AVRCP_SHUFFLE_MODE_CHANGED); return BT_ERROR_NONE; } @@ -223,6 +259,7 @@ int bt_avrcp_set_scan_mode_changed_cb(bt_avrcp_scan_mode_changed_cb callback, vo int bt_avrcp_unset_scan_mode_changed_cb(void) { + BT_CHECK_INIT_STATUS(); _bt_unset_cb(BT_EVENT_AVRCP_SCAN_MODE_CHANGED); return BT_ERROR_NONE; } diff --git a/src/bluetooth-common.c b/src/bluetooth-common.c old mode 100644 new mode 100755 index 5ca557c..1ee14df --- a/src/bluetooth-common.c +++ b/src/bluetooth-common.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved * * Licensed under the Apache License, Version 2.0 (the License); * you may not use this file except in compliance with the License. @@ -29,11 +29,15 @@ #include "bluetooth-telephony-api.h" static bool is_initialized = false; +static bool is_le_initialized = false; static bt_event_sig_event_slot_s bt_event_slot_container[] = { {BT_EVENT_STATE_CHANGED, NULL, NULL}, + {BT_EVENT_LE_STATE_CHANGED, NULL, NULL}, {BT_EVENT_NAME_CHANGED, NULL, NULL}, {BT_EVENT_VISIBILITY_MODE_CHANGED, NULL, NULL}, + {BT_EVENT_VISIBILITY_DURATION_CHANGED, NULL, NULL}, {BT_EVENT_DEVICE_DISCOVERY_STATE_CHANGED, NULL, NULL}, + {BT_EVENT_LE_DEVICE_DISCOVERY_STATE_CHANGED, NULL, NULL}, {BT_EVENT_BOND_CREATED, NULL, NULL}, {BT_EVENT_BOND_DESTROYED, NULL, NULL}, {BT_EVENT_AUTHORIZATION_CHANGED, NULL, NULL}, @@ -67,20 +71,36 @@ static bt_event_sig_event_slot_s bt_event_slot_container[] = { {BT_EVENT_AVRCP_SCAN_MODE_CHANGED, NULL, NULL}, {BT_EVENT_HID_CONNECTION_STATUS, NULL, NULL}, {BT_EVENT_DEVICE_CONNECTION_STATUS, NULL, NULL}, + {BT_EVENT_GATT_CONNECTION_STATUS, NULL, NULL}, {BT_EVENT_GATT_CHARACTERISTIC_DISCOVERED, NULL, NULL}, - {BT_EVENT_GATT_VALUE_CHANGED, NULL, NULL} + {BT_EVENT_GATT_VALUE_CHANGED, NULL, NULL}, + {BT_EVENT_GATT_READ_CHARACTERISTIC, NULL, NULL}, + {BT_EVENT_GATT_WRITE_CHARACTERISTIC, NULL, NULL}, + {BT_EVENT_GATT_CHARACTERISTIC_DESCRIPTOR_DISCOVERED, NULL, NULL}, + {BT_EVENT_ADVERTISING_STATE_CHANGED, NULL, NULL}, + {BT_EVENT_MANUFACTURER_DATA_CHANGED, NULL, NULL}, + {BT_EVENT_CONNECTABLE_CHANGED_EVENT, NULL, NULL}, + {BT_EVENT_AG_VENDOR_CMD, NULL, NULL}, + {BT_EVENT_RSSI_ENABLED_EVENT, NULL, NULL}, + {BT_EVENT_RSSI_ALERT_EVENT, NULL, NULL}, + {BT_EVENT_GET_RSSI_EVENT, NULL, NULL}, }; /* * Internal Functions */ static void __bt_event_proxy(int event, bluetooth_event_param_t * param, void *user_data); +static void __bt_le_event_proxy(int event, bluetooth_event_param_t *param, void *user_data); static int __bt_get_cb_index(int event); static void __bt_convert_lower_to_upper(char *origin); static int __bt_get_bt_device_sdp_info_s(bt_device_sdp_info_s **dest, bt_sdp_info_t *source); static void __bt_free_bt_device_sdp_info_s(bt_device_sdp_info_s *sdp_info); +static int __bt_get_bt_device_connection_info_s(bt_device_connection_info_s **dest, bt_connection_info_t *source); +static void __bt_free_bt_device_connection_info_s(bt_device_connection_info_s *conn_info); static int __bt_get_bt_adapter_device_discovery_info_s(bt_adapter_device_discovery_info_s **discovery_info, bluetooth_device_info_t *source_info); static void __bt_free_bt_adapter_device_discovery_info_s(bt_adapter_device_discovery_info_s *discovery_info); +static int __bt_get_bt_adapter_le_device_discovery_info_s(bt_adapter_le_device_discovery_info_s **le_discovery_info, bluetooth_le_device_info_t *source_info); +static void __bt_free_bt_adapter_le_device_discovery_info_s(bt_adapter_le_device_discovery_info_s *discovery_info); /* * Public Functions @@ -111,14 +131,12 @@ int bt_deinitialize(void) return BT_ERROR_NONE; } - /* * Common Functions */ int _bt_check_init_status(void) { - if (is_initialized != true) - { + if (is_initialized != true) { BT_ERR("NOT_INITIALIZED(0x%08x)", BT_ERROR_NOT_INITIALIZED); return BT_ERROR_NOT_INITIALIZED; } @@ -147,12 +165,35 @@ bool _bt_check_cb(int events) int _bt_le_adapter_init(void) { - return BT_ERROR_NOT_SUPPORTED; + if (is_le_initialized) + return BT_ERROR_NONE; + + if (bluetooth_le_register_callback(&__bt_le_event_proxy, NULL) != BLUETOOTH_ERROR_NONE) { + BT_ERR("OPERATION_FAILED(0x%08x)", BT_ERROR_OPERATION_FAILED); + return BT_ERROR_OPERATION_FAILED; + } + is_le_initialized = true; + + return BT_ERROR_NONE; } int _bt_le_adapter_deinit(void) { - return BT_ERROR_NOT_SUPPORTED; + if (!is_le_initialized) { + BT_ERR("NOT_INITIALIZED(0x%08x)", BT_ERROR_NOT_INITIALIZED); + return BT_ERROR_NOT_INITIALIZED; + } + + if (!_bt_check_cb(BT_EVENT_LE_STATE_CHANGED) && + !_bt_check_cb(BT_EVENT_LE_DEVICE_DISCOVERY_STATE_CHANGED)) { + if (bluetooth_le_unregister_callback() != BLUETOOTH_ERROR_NONE) { + BT_ERR("OPERATION_FAILED(0x%08x)", BT_ERROR_OPERATION_FAILED); + return BT_ERROR_OPERATION_FAILED; + } + is_le_initialized = false; + } + + return BT_ERROR_NONE; } int _bt_get_error_code(int origin_error) @@ -176,6 +217,7 @@ int _bt_get_error_code(int origin_error) case BLUETOOTH_ERROR_DEVICE_ALREADY_ENABLED: case BLUETOOTH_ERROR_ALREADY_INITIALIZED: case BLUETOOTH_ERROR_AGENT_DOES_NOT_EXIST: + case BLUETOOTH_ERROR_ALREADY_DEACTIVATED: return BT_ERROR_ALREADY_DONE; case BLUETOOTH_ERROR_NOT_PAIRED: return BT_ERROR_REMOTE_DEVICE_NOT_BONDED; @@ -194,8 +236,12 @@ int _bt_get_error_code(int origin_error) return BT_ERROR_REMOTE_DEVICE_NOT_FOUND; case BLUETOOTH_ERROR_SERVICE_SEARCH_ERROR: return BT_ERROR_SERVICE_SEARCH_FAILED; + case BLUETOOTH_ERROR_PERMISSION_DEINED : + return BT_ERROR_PERMISSION_DENIED; case BLUETOOTH_ERROR_SERVICE_NOT_FOUND: return BT_ERROR_SERVICE_NOT_FOUND; + case BLUETOOTH_ERROR_NOT_INITIALIZED: + return BT_ERROR_NOT_INITIALIZED; case BLUETOOTH_ERROR_PARING_FAILED: case BLUETOOTH_ERROR_MAX_CONNECTION: case BLUETOOTH_ERROR_ALREADY_CONNECT: @@ -240,7 +286,9 @@ int _bt_get_bt_device_info_s(bt_device_info_s **dest_dev, bluetooth_device_info_ (*dest_dev)->service_uuid = (char **)malloc(sizeof(char *) * source_dev->service_index); if ((*dest_dev)->service_uuid != NULL) { for (i = 0; i < source_dev->service_index; i++) { - (*dest_dev)->service_uuid[i] = strdup(source_dev->uuids[i]); + (*dest_dev)->service_uuid[i] = + g_strndup(source_dev->uuids[i], + BLUETOOTH_UUID_STRING_MAX - 1); if ((*dest_dev)->service_uuid[i] != NULL) { __bt_convert_lower_to_upper((*dest_dev)->service_uuid[i]); } @@ -254,6 +302,15 @@ int _bt_get_bt_device_info_s(bt_device_info_s **dest_dev, bluetooth_device_info_ (*dest_dev)->is_connected = (bool)source_dev->connected; (*dest_dev)->is_authorized = (bool)source_dev->trust; + (*dest_dev)->manufacturer_data_len = source_dev->manufacturer_data.data_len; + if (source_dev->manufacturer_data.data_len > 0) { + (*dest_dev)->manufacturer_data = (char *)malloc(source_dev->manufacturer_data.data_len); + memcpy((*dest_dev)->manufacturer_data, source_dev->manufacturer_data.data, source_dev->manufacturer_data.data_len); + } else { + (*dest_dev)->manufacturer_data = (char *)malloc(1); + (*dest_dev)->manufacturer_data[0] = 0; + } + return BT_ERROR_NONE; } @@ -273,11 +330,14 @@ void _bt_free_bt_device_info_s(bt_device_info_s *device_info) if (device_info->service_uuid != NULL) { for (i = 0; i < device_info->service_count; i++) { if (device_info->service_uuid[i] != NULL) - free(device_info->service_uuid[i]); + g_free(device_info->service_uuid[i]); } free(device_info->service_uuid); } + if (device_info->manufacturer_data != NULL) + free(device_info->manufacturer_data); + free(device_info); device_info = NULL; } @@ -303,12 +363,12 @@ void _bt_convert_address_to_hex(bluetooth_device_address_t *addr_hex, const char int i = 0; unsigned int addr[BLUETOOTH_ADDRESS_LENGTH] = { 0, }; - if (addr_str == NULL) + if (addr_str == NULL || addr_str[0] == '\0') return; i = sscanf(addr_str, "%X:%X:%X:%X:%X:%X", &addr[0], &addr[1], &addr[2], &addr[3], &addr[4], &addr[5]); if (i != BLUETOOTH_ADDRESS_LENGTH) { - BT_ERR("Invalid format string - %s", addr_str); + BT_ERR("Invalid format string - [%s]", addr_str); } for (i = 0; i < BLUETOOTH_ADDRESS_LENGTH; i++) { @@ -384,10 +444,7 @@ static int __bt_get_bt_device_sdp_info_s(bt_device_sdp_info_s **dest, bt_sdp_inf { int i = 0; - *dest = (bt_device_sdp_info_s *)malloc(sizeof(bt_device_sdp_info_s)); - if (*dest == NULL) { - return BT_ERROR_OUT_OF_MEMORY; - } + *dest = (bt_device_sdp_info_s *)g_malloc0(sizeof(bt_device_sdp_info_s)); if (_bt_convert_address_to_string(&((*dest)->remote_address), &(source->device_addr)) != BT_ERROR_NONE) { __bt_free_bt_device_sdp_info_s(*dest); @@ -435,10 +492,49 @@ static void __bt_free_bt_device_sdp_info_s(bt_device_sdp_info_s *sdp_info) free(sdp_info->service_uuid); } - free(sdp_info); + g_free(sdp_info); sdp_info = NULL; } +static int __bt_get_bt_device_connection_info_s(bt_device_connection_info_s **dest, bt_connection_info_t *source) +{ + *dest = (bt_device_connection_info_s *)g_malloc0(sizeof(bt_device_connection_info_s)); + + if (_bt_convert_address_to_string(&((*dest)->remote_address), &(source->device_addr)) != BT_ERROR_NONE) { + __bt_free_bt_device_connection_info_s(*dest); + return BT_ERROR_OUT_OF_MEMORY; + } + + switch (source->addr_type) { + case 0: + (*dest)->link = BT_DEVICE_CONNECTION_LINK_BREDR; + break; + case 1: + case 2: + (*dest)->link = BT_DEVICE_CONNECTION_LINK_LE; + break; + default: + (*dest)->link = BT_DEVICE_CONNECTION_LINK_BREDR; + break; + } + + (*dest)->disconn_reason = source->disc_reason; + + return BT_ERROR_NONE; +} + +static void __bt_free_bt_device_connection_info_s(bt_device_connection_info_s *conn_info) +{ + if (conn_info == NULL) + return; + + if (conn_info->remote_address != NULL) + free(conn_info->remote_address); + + g_free(conn_info); + conn_info = NULL; +} + void _bt_audio_event_proxy(int event, bt_audio_event_param_t *param, void *user_data) { bluetooth_event_param_t new_param; @@ -484,10 +580,12 @@ static void __bt_event_proxy(int event, bluetooth_event_param_t *param, void *us int i; int call_id; int *avrcp_mode; + int *discoverable_timeout; bluetooth_rfcomm_connection_t *connection_ind = NULL; bluetooth_rfcomm_disconnection_t *disconnection_ind = NULL; bt_socket_connection_s rfcomm_connection; bt_device_sdp_info_s *sdp_info = NULL; + bt_device_connection_info_s *conn_info = NULL; bt_adapter_device_discovery_info_s *discovery_info = NULL; bt_device_info_s *bonded_device = NULL; bluetooth_rfcomm_connection_request_t *reqeust_ind = NULL; @@ -496,22 +594,21 @@ static void __bt_event_proxy(int event, bluetooth_event_param_t *param, void *us bt_opc_transfer_info_t *client_info = NULL; bluetooth_device_address_t *bd_addr = NULL; telephony_event_callid_t *call_data = NULL; - bt_device_connection_info_s *conn_info = NULL; char *device_addr = NULL; int error_code = BT_ERROR_NONE; - int event_index; + int event_index = -1; bluetooth_network_device_info_t *dev_info = NULL; bt_hdp_connected_t *hdp_conn_info = NULL; bt_hdp_disconnected_t *hdp_disconn_info = NULL; bt_hdp_data_ind_t *hdp_data_ind = NULL; bt_gatt_discovered_char_t *svc_char = NULL; bt_gatt_char_value_t *char_val = NULL; - event_index = __bt_get_cb_index(event); + bt_gatt_char_property_t *char_desc = NULL; + event_index = __bt_get_cb_index(event); if (event_index == -1 || bt_event_slot_container[event_index].callback == NULL) { return; } - memset(&rfcomm_connection, 0x00, sizeof(bt_socket_connection_s)); switch (event) { @@ -535,6 +632,17 @@ static void __bt_event_proxy(int event, bluetooth_event_param_t *param, void *us ((bt_adapter_visibility_mode_changed_cb)bt_event_slot_container[event_index].callback) (_bt_get_error_code(param->result), _bt_get_bt_visibility_mode_e(*(bt_adapter_visibility_mode_e *)(param->param_data)), bt_event_slot_container[event_index].user_data); break; + case BLUETOOTH_EVENT_DISCOVERABLE_TIMEOUT_CHANGED: + BT_INFO("bt_adapter_visibility_duration_changed_cb() will be called"); + discoverable_timeout = (int *)(param->param_data); + ((bt_adapter_visibility_duration_changed_cb)bt_event_slot_container[event_index].callback) + (*discoverable_timeout, bt_event_slot_container[event_index].user_data); + break; + case BLUETOOTH_EVENT_CONNECTABLE_CHANGED: + BT_INFO("bt_adapter_connectable_changed_cb() will be called"); + ((bt_adapter_connectable_changed_cb)bt_event_slot_container[event_index].callback) + (_bt_get_error_code(param->result), *(bool *)(param->param_data), bt_event_slot_container[event_index].user_data); + break; case BLUETOOTH_EVENT_DISCOVERY_STARTED: BT_INFO("bt_adapter_device_discovery_state_changed_cb() will be called with BT_ADAPTER_DEVICE_DISCOVERY_STARTED"); ((bt_adapter_device_discovery_state_changed_cb) bt_event_slot_container[event_index].callback) @@ -543,7 +651,7 @@ static void __bt_event_proxy(int event, bluetooth_event_param_t *param, void *us case BLUETOOTH_EVENT_DISCOVERY_FINISHED: BT_INFO("bt_adapter_device_discovery_state_changed_cb() will be called with BT_ADAPTER_DEVICE_DISCOVERY_FINISHED"); ((bt_adapter_device_discovery_state_changed_cb)bt_event_slot_container[event_index].callback) - (BT_ERROR_NONE, BT_ADAPTER_DEVICE_DISCOVERY_FINISHED, NULL, bt_event_slot_container[event_index].user_data); + (_bt_get_error_code(param->result), BT_ADAPTER_DEVICE_DISCOVERY_FINISHED, NULL, bt_event_slot_container[event_index].user_data); break; case BLUETOOTH_EVENT_REMOTE_DEVICE_NAME_UPDATED: BT_INFO("bt_adapter_device_discovery_state_changed_cb() will be called with BT_ADAPTER_DEVICE_DISCOVERY_FOUND"); @@ -556,8 +664,6 @@ static void __bt_event_proxy(int event, bluetooth_event_param_t *param, void *us (_bt_get_error_code(param->result), BT_ADAPTER_DEVICE_DISCOVERY_FOUND, NULL, bt_event_slot_container[event_index].user_data); } break; - case BLUETOOTH_EVENT_REMOTE_DEVICE_DISAPPEARED: - break; case BLUETOOTH_EVENT_BONDING_FINISHED: BT_INFO("bt_device_bond_created_cb() will be called"); _bt_get_bt_device_info_s(&bonded_device, (bluetooth_device_info_t *)(param->param_data)); @@ -594,19 +700,17 @@ static void __bt_event_proxy(int event, bluetooth_event_param_t *param, void *us break; case BLUETOOTH_EVENT_DEVICE_CONNECTED: BT_INFO("bt_device_connection_state_changed_cb() will be called"); - _bt_convert_address_to_string(&device_addr, (bluetooth_device_address_t *)(param->param_data)); + __bt_get_bt_device_connection_info_s(&conn_info, (bt_connection_info_t *)(param->param_data)); ((bt_device_connection_state_changed_cb)bt_event_slot_container[event_index].callback) (true, conn_info, bt_event_slot_container[event_index].user_data); - if (device_addr != NULL) - free(device_addr); + __bt_free_bt_device_connection_info_s(conn_info); break; case BLUETOOTH_EVENT_DEVICE_DISCONNECTED: BT_INFO("bt_device_connection_state_changed_cb() will be called"); - _bt_convert_address_to_string(&device_addr, (bluetooth_device_address_t *)(param->param_data)); + __bt_get_bt_device_connection_info_s(&conn_info, (bt_connection_info_t *)(param->param_data)); ((bt_device_connection_state_changed_cb)bt_event_slot_container[event_index].callback) (false, conn_info, bt_event_slot_container[event_index].user_data); - if (device_addr != NULL) - free(device_addr); + __bt_free_bt_device_connection_info_s(conn_info); break; case BLUETOOTH_EVENT_SERVICE_SEARCHED: BT_INFO("bt_device_service_searched_cb() will be called"); @@ -1056,6 +1160,22 @@ static void __bt_event_proxy(int event, bluetooth_event_param_t *param, void *us if (device_addr != NULL) free(device_addr); break; + case BLUETOOTH_EVENT_GATT_CONNECTED: + BT_INFO("BLUETOOTH_EVENT_GATT_CONNECTED"); + bd_addr = (bluetooth_device_address_t *)(param->param_data); + _bt_convert_address_to_string(&device_addr, bd_addr); + ((bt_gatt_connection_state_changed_cb)bt_event_slot_container[event_index].callback) + (_bt_get_error_code(param->result), TRUE, device_addr, + bt_event_slot_container[event_index].user_data); + break; + case BLUETOOTH_EVENT_GATT_DISCONNECTED: + BT_INFO("BLUETOOTH_EVENT_GATT_DISCONNECTED"); + bd_addr = (bluetooth_device_address_t *)(param->param_data); + _bt_convert_address_to_string(&device_addr, bd_addr); + ((bt_gatt_connection_state_changed_cb)bt_event_slot_container[event_index].callback) + (_bt_get_error_code(param->result), FALSE, device_addr, + bt_event_slot_container[event_index].user_data); + break; case BLUETOOTH_EVENT_GATT_SVC_CHAR_DISCOVERED: BT_INFO("BLUETOOTH_EVENT_GATT_SVC_CHAR_DISCOVERED"); svc_char = (bt_gatt_discovered_char_t *)(param->param_data); @@ -1083,6 +1203,107 @@ static void __bt_event_proxy(int event, bluetooth_event_param_t *param, void *us (char_val->char_handle, char_val->char_value, char_val->val_len, bt_event_slot_container[event_index].user_data); + break; + case BLUETOOTH_EVENT_GATT_READ_CHAR: + BT_INFO("BLUETOOTH_EVENT_GATT_READ_CHAR"); + + char_val = (bt_gatt_char_value_t *)(param->param_data); + ((bt_gatt_characteristic_read_cb)bt_event_slot_container[event_index].callback) + (char_val->char_value, char_val->val_len, + bt_event_slot_container[event_index].user_data); + + _bt_unset_cb(BT_EVENT_GATT_READ_CHARACTERISTIC); + + break; + case BLUETOOTH_EVENT_GATT_WRITE_CHAR: + BT_INFO("BLUETOOTH_EVENT_GATT_WRITE_CHAR"); + + ((bt_gatt_characteristic_write_cb)bt_event_slot_container[event_index].callback) + (bt_event_slot_container[event_index].user_data); + + _bt_unset_cb(BT_EVENT_GATT_WRITE_CHARACTERISTIC); + + break; + case BLUETOOTH_EVENT_GATT_SVC_CHAR_DESC_DISCOVERED: + BT_INFO("BLUETOOTH_EVENT_GATT_SVC_CHAR_DESC_DISCOVERED"); + char_desc = (bt_gatt_char_property_t *)(param->param_data); + + if (char_desc == NULL) + return; + + ((bt_gatt_characteristic_descriptor_discovered_cb) + bt_event_slot_container[event_index].callback)(_bt_get_error_code(param->result), + char_desc->format.format, char_desc->val_len, char_desc->description, + bt_event_slot_container[event_index].user_data); + + _bt_unset_cb(BT_EVENT_GATT_CHARACTERISTIC_DESCRIPTOR_DISCOVERED); + + break; + case BLUETOOTH_EVENT_ADVERTISING_STARTED: + BT_INFO("BLUETOOTH_EVENT_ADVERTISING_STARTED"); + + ((bt_adapter_le_advertising_state_changed_cb)bt_event_slot_container[event_index].callback) + (_bt_get_error_code(param->result), NULL, BT_ADAPTER_LE_ADVERTISING_STARTED, + bt_event_slot_container[event_index].user_data); + + break; + case BLUETOOTH_EVENT_ADVERTISING_STOPPED: + BT_INFO("BLUETOOTH_EVENT_ADVERTISING_STOPPED"); + + ((bt_adapter_le_advertising_state_changed_cb)bt_event_slot_container[event_index].callback) + (_bt_get_error_code(param->result), NULL, BT_ADAPTER_LE_ADVERTISING_STOPPED, + bt_event_slot_container[event_index].user_data); + + break; + default: + break; + } +} + + +static void __bt_le_event_proxy(int event, bluetooth_event_param_t *param, void *user_data) +{ + bt_socket_connection_s rfcomm_connection; + bt_adapter_le_device_discovery_info_s *discovery_info = NULL; + int event_index = -1; + + event_index = __bt_get_cb_index(event); + if (event_index == -1 || bt_event_slot_container[event_index].callback == NULL) { + return; + } + memset(&rfcomm_connection, 0x00, sizeof(bt_socket_connection_s)); + + switch (event) { + case BLUETOOTH_EVENT_LE_ENABLED: + BT_INFO("BLUETOOTH_EVENT_LE_ENABLED"); + ((bt_adapter_le_state_changed_cb) bt_event_slot_container[event_index].callback) + (_bt_get_error_code(param->result), BT_ADAPTER_LE_ENABLED, bt_event_slot_container[event_index].user_data); + break; + case BLUETOOTH_EVENT_LE_DISABLED: + BT_INFO("BLUETOOTH_EVENT_LE_DISABLED"); + ((bt_adapter_le_state_changed_cb) bt_event_slot_container[event_index].callback) + (_bt_get_error_code(param->result), BT_ADAPTER_LE_DISABLED, bt_event_slot_container[event_index].user_data); + break; + case BLUETOOTH_EVENT_LE_DISCOVERY_STARTED: + BT_INFO("BLUETOOTH_EVENT_LE_DISCOVERY_STARTED"); + ((bt_adapter_le_device_discovery_state_changed_cb) bt_event_slot_container[event_index].callback) + (_bt_get_error_code(param->result), BT_ADAPTER_LE_DEVICE_DISCOVERY_STARTED, NULL, bt_event_slot_container[event_index].user_data); + break; + case BLUETOOTH_EVENT_LE_DISCOVERY_FINISHED: + BT_INFO("BLUETOOTH_EVENT_LE_DISCOVERY_FINISHED"); + ((bt_adapter_le_device_discovery_state_changed_cb)bt_event_slot_container[event_index].callback) + (_bt_get_error_code(param->result), BT_ADAPTER_LE_DEVICE_DISCOVERY_FINISHED, NULL, bt_event_slot_container[event_index].user_data); + break; + case BLUETOOTH_EVENT_REMOTE_LE_DEVICE_FOUND: + BT_INFO("BLUETOOTH_EVENT_LE_DISCOVERY_FINISHED"); + if (__bt_get_bt_adapter_le_device_discovery_info_s(&discovery_info, (bluetooth_le_device_info_t *)(param->param_data)) == BT_ERROR_NONE) { + ((bt_adapter_le_device_discovery_state_changed_cb)bt_event_slot_container[event_index].callback) + (_bt_get_error_code(param->result), BT_ADAPTER_LE_DEVICE_DISCOVERY_FOUND, discovery_info, bt_event_slot_container[event_index].user_data); + __bt_free_bt_adapter_le_device_discovery_info_s(discovery_info); + } else { + ((bt_adapter_le_device_discovery_state_changed_cb)bt_event_slot_container[event_index].callback) + (_bt_get_error_code(param->result), BT_ADAPTER_LE_DEVICE_DISCOVERY_FOUND, NULL, bt_event_slot_container[event_index].user_data); + } break; default: break; @@ -1131,6 +1352,51 @@ static int __bt_get_bt_adapter_device_discovery_info_s(bt_adapter_device_discove (*discovery_info)->rssi = (int)source_info->rssi; (*discovery_info)->is_bonded = (bool)source_info->paired; + (*discovery_info)->appearance = 0; + + (*discovery_info)->manufacturer_data_len = source_info->manufacturer_data.data_len; + if ((*discovery_info)->manufacturer_data_len > 0) { + (*discovery_info)->manufacturer_data = malloc(source_info->manufacturer_data.data_len); + memcpy((*discovery_info)->manufacturer_data, source_info->manufacturer_data.data, source_info->manufacturer_data.data_len); + } else { + (*discovery_info)->manufacturer_data = NULL; + } + + return BT_ERROR_NONE; +} + +static int __bt_get_bt_adapter_le_device_discovery_info_s( + bt_adapter_le_device_discovery_info_s **le_discovery_info, + bluetooth_le_device_info_t *source_info) +{ + + BT_CHECK_INPUT_PARAMETER(source_info); + + *le_discovery_info = (bt_adapter_le_device_discovery_info_s *)malloc(sizeof(bt_adapter_le_device_discovery_info_s)); + if (*le_discovery_info == NULL) { + return BT_ERROR_OUT_OF_MEMORY; + } + + _bt_convert_address_to_string(&((*le_discovery_info)->remote_address), &(source_info->device_address)); + + (*le_discovery_info)->address_type = (int)source_info->addr_type; + (*le_discovery_info)->rssi = (int)source_info->rssi; + (*le_discovery_info)->adv_data_len = source_info->adv_ind_data.data_len; + if ((*le_discovery_info)->adv_data_len > 0) { + (*le_discovery_info)->adv_data = malloc(source_info->adv_ind_data.data_len); + memcpy((*le_discovery_info)->adv_data, source_info->adv_ind_data.data.data, source_info->adv_ind_data.data_len); + } else { + (*le_discovery_info)->adv_data = NULL; + } + + (*le_discovery_info)->scan_data_len = source_info->scan_resp_data.data_len; + if ((*le_discovery_info)->scan_data_len > 0) { + (*le_discovery_info)->scan_data = malloc(source_info->scan_resp_data.data_len); + memcpy((*le_discovery_info)->scan_data, source_info->scan_resp_data.data.data, source_info->scan_resp_data.data_len); + } else { + (*le_discovery_info)->scan_data = NULL; + } + return BT_ERROR_NONE; } @@ -1154,6 +1420,25 @@ static void __bt_free_bt_adapter_device_discovery_info_s(bt_adapter_device_disco } free(discovery_info->service_uuid); } + if (discovery_info->manufacturer_data != NULL) + free(discovery_info->manufacturer_data); + + free(discovery_info); + discovery_info = NULL; +} + +static void __bt_free_bt_adapter_le_device_discovery_info_s(bt_adapter_le_device_discovery_info_s *discovery_info) +{ + if (discovery_info == NULL) + return; + + if (discovery_info->remote_address != NULL) + free(discovery_info->remote_address); + + if (discovery_info->adv_data != NULL) + free(discovery_info->adv_data); + if (discovery_info->scan_data != NULL) + free(discovery_info->scan_data); free(discovery_info); discovery_info = NULL; @@ -1165,15 +1450,24 @@ static int __bt_get_cb_index(int event) case BLUETOOTH_EVENT_ENABLED: case BLUETOOTH_EVENT_DISABLED: return BT_EVENT_STATE_CHANGED; + case BLUETOOTH_EVENT_LE_ENABLED: + case BLUETOOTH_EVENT_LE_DISABLED: + return BT_EVENT_LE_STATE_CHANGED; case BLUETOOTH_EVENT_LOCAL_NAME_CHANGED: return BT_EVENT_NAME_CHANGED; case BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED: return BT_EVENT_VISIBILITY_MODE_CHANGED; + case BLUETOOTH_EVENT_DISCOVERABLE_TIMEOUT_CHANGED: + return BT_EVENT_VISIBILITY_DURATION_CHANGED; case BLUETOOTH_EVENT_DISCOVERY_STARTED: case BLUETOOTH_EVENT_DISCOVERY_FINISHED: case BLUETOOTH_EVENT_REMOTE_DEVICE_NAME_UPDATED: case BLUETOOTH_EVENT_REMOTE_DEVICE_DISAPPEARED: return BT_EVENT_DEVICE_DISCOVERY_STATE_CHANGED; + case BLUETOOTH_EVENT_LE_DISCOVERY_STARTED: + case BLUETOOTH_EVENT_LE_DISCOVERY_FINISHED: + case BLUETOOTH_EVENT_REMOTE_LE_DEVICE_FOUND: + return BT_EVENT_LE_DEVICE_DISCOVERY_STATE_CHANGED; case BLUETOOTH_EVENT_BONDING_FINISHED: return BT_EVENT_BOND_CREATED; case BLUETOOTH_EVENT_BONDED_DEVICE_REMOVED: @@ -1184,6 +1478,9 @@ static int __bt_get_cb_index(int event) case BLUETOOTH_EVENT_DEVICE_CONNECTED: case BLUETOOTH_EVENT_DEVICE_DISCONNECTED: return BT_EVENT_DEVICE_CONNECTION_STATUS; + case BLUETOOTH_EVENT_GATT_CONNECTED: + case BLUETOOTH_EVENT_GATT_DISCONNECTED: + return BT_EVENT_GATT_CONNECTION_STATUS; case BLUETOOTH_EVENT_SERVICE_SEARCHED: return BT_EVENT_SERVICE_SEARCHED; case BLUETOOTH_EVENT_RFCOMM_DATA_RECEIVED: @@ -1272,9 +1569,18 @@ static int __bt_get_cb_index(int event) case BLUETOOTH_HID_DISCONNECTED: return BT_EVENT_HID_CONNECTION_STATUS; case BLUETOOTH_EVENT_GATT_SVC_CHAR_DISCOVERED: - return BT_EVENT_GATT_CHARACTERISTIC_DISCOVERED; + return BT_EVENT_GATT_CHARACTERISTIC_DISCOVERED; case BLUETOOTH_EVENT_GATT_CHAR_VAL_CHANGED: - return BT_EVENT_GATT_VALUE_CHANGED; + return BT_EVENT_GATT_VALUE_CHANGED; + case BLUETOOTH_EVENT_GATT_READ_CHAR: + return BT_EVENT_GATT_READ_CHARACTERISTIC; + case BLUETOOTH_EVENT_GATT_SVC_CHAR_DESC_DISCOVERED: + return BT_EVENT_GATT_CHARACTERISTIC_DESCRIPTOR_DISCOVERED; + case BLUETOOTH_EVENT_ADVERTISING_STARTED: + case BLUETOOTH_EVENT_ADVERTISING_STOPPED: + return BT_EVENT_ADVERTISING_STATE_CHANGED; + case BLUETOOTH_EVENT_CONNECTABLE_CHANGED: + return BT_EVENT_CONNECTABLE_CHANGED_EVENT; default: return -1; } diff --git a/src/bluetooth-device.c b/src/bluetooth-device.c old mode 100644 new mode 100755 index 79acd35..1a132da --- a/src/bluetooth-device.c +++ b/src/bluetooth-device.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved * * Licensed under the Apache License, Version 2.0 (the License); * you may not use this file except in compliance with the License. @@ -42,7 +42,18 @@ int bt_device_create_bond(const char *device_address) int bt_device_create_bond_by_type(const char *device_address, bt_device_connection_link_type_e conn_type) { - return BT_ERROR_NOT_SUPPORTED; + bluetooth_device_address_t addr_hex = { {0,} }; + int error_code = BT_ERROR_NONE; + BT_CHECK_INIT_STATUS(); + BT_CHECK_INPUT_PARAMETER(device_address); + + _bt_convert_address_to_hex(&addr_hex, device_address); + error_code = _bt_get_error_code(bluetooth_bond_device_by_type(&addr_hex, conn_type)); + if (error_code != BT_ERROR_NONE) { + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code); + } + + return error_code; } int bt_device_cancel_bonding(void) @@ -153,7 +164,9 @@ int bt_device_foreach_connected_profiles(const char *remote_address, bt_device_c int ret; int i = 0; int profiles[] = {BT_PROFILE_RFCOMM, BT_PROFILE_A2DP, - BT_PROFILE_HSP, BT_PROFILE_HID, 0}; + BT_PROFILE_HSP, BT_PROFILE_HID, BT_PROFILE_NAP, + BT_PROFILE_AG, BT_PROFILE_GATT, BT_PROFILE_NAP_SERVER, + 0}; BT_CHECK_INIT_STATUS(); BT_CHECK_INPUT_PARAMETER(remote_address); @@ -184,7 +197,26 @@ int bt_device_foreach_connected_profiles(const char *remote_address, bt_device_c int bt_device_is_profile_connected(const char *remote_address, bt_profile_e bt_profile, bool *connected_status) { - return BT_ERROR_NOT_SUPPORTED; + bluetooth_device_address_t addr_hex = { {0,} }; + int ret; + gboolean is_connected = FALSE; + + BT_CHECK_INIT_STATUS(); + BT_CHECK_INPUT_PARAMETER(remote_address); + + _bt_convert_address_to_hex(&addr_hex, remote_address); + + ret = _bt_get_error_code(bluetooth_is_device_connected(&addr_hex, bt_profile, + &is_connected)); + *connected_status = is_connected ? true : false; + + if (ret != BT_ERROR_NONE) { + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); + return ret; + } + + return ret; + } int bt_device_set_bond_created_cb(bt_device_bond_created_cb callback, void *user_data) @@ -270,12 +302,209 @@ int bt_device_unset_connection_state_changed_cb(void) int bt_device_le_conn_update(const char *device_address, const bt_le_conn_update_s *parameters) { - return BT_ERROR_NOT_SUPPORTED; + bluetooth_device_address_t addr_hex = { {0,} }; + bluetooth_le_conn_update_t param= { 0 }; + int ret = BT_ERROR_NONE; + + BT_CHECK_INIT_STATUS(); + BT_CHECK_INPUT_PARAMETER(device_address); + BT_CHECK_INPUT_PARAMETER(parameters); + + _bt_convert_address_to_hex(&addr_hex, device_address); + param.interval_min = parameters->interval_min; + param.interval_max = parameters->interval_max; + param.latency = parameters->latency; + param.time_out = parameters->time_out; + + ret = _bt_get_error_code(bluetooth_le_conn_update(&addr_hex, ¶m)); + + if (BT_ERROR_NONE != ret) { + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); + } + + return ret; } int bt_device_get_service_mask_from_uuid_list(char **uuids, int no_of_service, bt_service_class_t *service_mask_list) { - return BT_ERROR_NOT_SUPPORTED; + BT_DBG("Get service mask from uuid list"); + BT_CHECK_INPUT_PARAMETER(uuids); + BT_CHECK_INPUT_PARAMETER(service_mask_list); + + int i = 0; + unsigned int service = 0; + char **parts = NULL; + bt_service_class_t service_mask = 0; + + BT_DBG("no_of_service = %d", no_of_service); + + for (i = 0; i < no_of_service; i++) { + parts = g_strsplit(uuids[i], "-", -1); + + if (parts == NULL || parts[0] == NULL) { + g_strfreev(parts); + continue; + } + + service = g_ascii_strtoull(parts[0], NULL, 16); + g_strfreev(parts); + + switch (service) { + case BLUETOOTH_SPP_PROFILE_UUID: + service_mask |= BT_SC_SPP_SERVICE_MASK; + break; + + case BLUETOOTH_LAP_PROFILE_UUID: + service_mask |= BT_SC_LAP_SERVICE_MASK; + break; + + case BLUETOOTH_DUN_PROFILE_UUID: + service_mask |= BT_SC_DUN_SERVICE_MASK; + break; + + case BLUETOOTH_OBEX_IR_MC_SYNC_SERVICE_UUID: + service_mask |= BT_SC_SYNC_SERVICE_MASK; + break; + + case BLUETOOTH_OBEX_OBJECT_PUSH_SERVICE_UUID: + service_mask |= BT_SC_OPP_SERVICE_MASK; + break; + + case BLUETOOTH_OBEX_FILE_TRANSFER_UUID: + service_mask |= BT_SC_FTP_SERVICE_MASK; + break; + + case BLUETOOTH_HS_PROFILE_UUID: + service_mask |= BT_SC_HSP_SERVICE_MASK; + break; + + case BLUETOOTH_CTP_PROFILE_UUID: + service_mask |= BT_SC_CTP_SERVICE_MASK; + break; + + case BLUETOOTH_AUDIO_SOURCE_UUID: + service_mask |= BT_SC_NONE; + break; + + case BLUETOOTH_AUDIO_SINK_UUID: + service_mask |= BT_SC_A2DP_SERVICE_MASK; + break; + + case BLUETOOTH_VIDEO_SOURCE_UUID: + service_mask |= BT_SC_NONE; + break; + + case BLUETOOTH_VIDEO_SINK_UUID: + service_mask |= BT_SC_NONE; + break; + + case BLUETOOTH_AV_REMOTE_CONTROL_TARGET_UUID: + service_mask |= BT_SC_NONE; + break; + + case BLUETOOTH_ADVANCED_AUDIO_PROFILE_UUID: + service_mask |= BT_SC_A2DP_SERVICE_MASK; + break; + + case BLUETOOTH_AV_REMOTE_CONTROL_UUID: + service_mask |= BT_SC_AVRCP_SERVICE_MASK; + break; + + case BLUETOOTH_ICP_PROFILE_UUID: + service_mask |= BT_SC_ICP_SERVICE_MASK; + break; + + case BLUETOOTH_FAX_PROFILE_UUID: + service_mask |= BT_SC_FAX_SERVICE_MASK; + break; + + case BLUETOOTH_HEADSET_AG_SERVICE_UUID: + service_mask |= BT_SC_NONE; /* BT_SC_HSP_SERVICE_MASK */ + break; + + case BLUETOOTH_PAN_PANU_PROFILE_UUID: + service_mask |= BT_SC_PANU_SERVICE_MASK; + break; + + case BLUETOOTH_PAN_NAP_PROFILE_UUID: + service_mask |= BT_SC_NAP_SERVICE_MASK; + break; + + case BLUETOOTH_PAN_GN_PROFILE_UUID: + service_mask |= BT_SC_GN_SERVICE_MASK; + break; + + case BLUETOOTH_REFERENCE_PRINTING: + service_mask |= BT_SC_NONE; + break; + + case BLUETOOTH_OBEX_IMAGING_UUID: + service_mask |= BT_SC_NONE; + break; + + case BLUETOOTH_OBEX_IMAGING_RESPONDER_UUID: + service_mask |= BT_SC_BIP_SERVICE_MASK; + break; + + case BLUETOOTH_HF_PROFILE_UUID: + service_mask |= BT_SC_HFP_SERVICE_MASK; + break; + + case BLUETOOTH_HFG_PROFILE_UUID: + service_mask |= BT_SC_NONE; + break; + + case BLUETOOTH_DIRECT_PRINTING_REFERENCE_OBJ_UUID: + service_mask |= BT_SC_NONE; + break; + + case BLUETOOTH_BASIC_PRINTING: + service_mask |= BT_SC_NONE; + break; + + case BLUETOOTH_HID_PROFILE_UUID: + service_mask |= BT_SC_HID_SERVICE_MASK; + break; + + case BLUETOOTH_SIM_ACCESS_PROFILE_UUID: + service_mask |= BT_SC_SAP_SERVICE_MASK; + break; + + case BLUETOOTH_OBEX_PBA_PROFILE_UUID: + service_mask |= BT_SC_PBAP_SERVICE_MASK; + break; + + case BLUETOOTH_OBEX_BPPS_PROFILE_UUID: + service_mask |= BT_SC_BPP_SERVICE_MASK; + break; + + case BLUETOOTH_PNP_INFORMATION_UUID: + service_mask |= BT_SC_NONE; + break; + + case BLUETOOTH_OBEX_PRINTING_STATUS_UUID: + service_mask |= BT_SC_BPP_SERVICE_MASK; + break; + + case BLUETOOTH_HCR_PROFILE_UUID: + service_mask |= BT_SC_NONE; + break; + + case BLUETOOTH_OBEX_SYNCML_TRANSFER_UUID: + service_mask |= BT_SC_NONE; + break; + + default: + break; + } + + } + + *service_mask_list = service_mask; + BT_DBG("service_mask = %x, service_mask_list = %x", service_mask, + service_mask_list); + + return BT_ERROR_NONE; } diff --git a/src/bluetooth-gatt.c b/src/bluetooth-gatt.c old mode 100644 new mode 100755 index 3f7c254..d2fa1c4 --- a/src/bluetooth-gatt.c +++ b/src/bluetooth-gatt.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved * * Licensed under the Apache License, Version 2.0 (the License); * you may not use this file except in compliance with the License. @@ -165,22 +165,51 @@ int bt_gatt_foreach_included_services(bt_gatt_attribute_h service, int bt_gatt_set_characteristic_changed_cb(bt_gatt_characteristic_changed_cb callback, void *user_data) { - return BT_ERROR_NOT_SUPPORTED; + BT_CHECK_INIT_STATUS(); + BT_CHECK_INPUT_PARAMETER(callback); + + _bt_set_cb(BT_EVENT_GATT_VALUE_CHANGED, callback, user_data); + + return BT_ERROR_NONE; } int bt_gatt_unset_characteristic_changed_cb() { - return BT_ERROR_NOT_SUPPORTED; + BT_CHECK_INIT_STATUS(); + + _bt_unset_cb(BT_EVENT_GATT_VALUE_CHANGED); + + return BT_ERROR_NONE; } int bt_gatt_watch_characteristic_changes(bt_gatt_attribute_h service) { - return BT_ERROR_NOT_SUPPORTED; + int ret; + + BT_CHECK_INIT_STATUS(); + BT_CHECK_INPUT_PARAMETER(service); + + ret = _bt_get_error_code(bluetooth_gatt_watch_characteristics((const char *)service)); + + if (ret != BT_ERROR_NONE) + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); + + return ret; } int bt_gatt_unwatch_characteristic_changes(bt_gatt_attribute_h service) { - return BT_ERROR_NOT_SUPPORTED; + int ret; + + BT_CHECK_INIT_STATUS(); + BT_CHECK_INPUT_PARAMETER(service); + + ret = _bt_get_error_code(bluetooth_gatt_unwatch_characteristics((const char *)service)); + + if (ret != BT_ERROR_NONE) + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); + + return ret; } int bt_gatt_get_characteristic_declaration(bt_gatt_attribute_h characteristic, @@ -245,7 +274,26 @@ int bt_gatt_set_characteristic_value_request(bt_gatt_attribute_h characteristic, const unsigned char *value, int value_length, bt_gatt_characteristic_write_cb callback) { - return BT_ERROR_NOT_SUPPORTED; + int ret; + + BT_CHECK_INIT_STATUS(); + BT_CHECK_INPUT_PARAMETER(characteristic); + BT_CHECK_INPUT_PARAMETER(value); + + if (value_length <= 0) + return BT_ERROR_INVALID_PARAMETER; + + ret = _bt_get_error_code(bluetooth_gatt_set_characteristics_value_request( + (const char *)characteristic, + (const guint8 *)value, value_length)); + + if (ret != BT_ERROR_NONE) { + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); + } else { + _bt_set_cb(BT_EVENT_GATT_WRITE_CHARACTERISTIC, callback, characteristic); + } + + return ret; } int bt_gatt_clone_attribute_handle(bt_gatt_attribute_h *clone, @@ -276,33 +324,92 @@ int bt_gatt_destroy_attribute_handle(bt_gatt_attribute_h handle) int bt_gatt_read_characteristic_value(bt_gatt_attribute_h characteristic, bt_gatt_characteristic_read_cb callback) { - return BT_ERROR_NOT_SUPPORTED; + int ret; + + BT_CHECK_INIT_STATUS(); + BT_CHECK_INPUT_PARAMETER(characteristic); + BT_CHECK_INPUT_PARAMETER(callback); + + ret = _bt_get_error_code(bluetooth_gatt_read_characteristic_value((const char *)characteristic)); + + if (ret != BT_ERROR_NONE) { + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); + } else { + _bt_set_cb(BT_EVENT_GATT_READ_CHARACTERISTIC, callback, NULL); + } + + return ret; } int bt_gatt_discover_characteristic_descriptor(bt_gatt_attribute_h characteristic_handle, bt_gatt_characteristic_descriptor_discovered_cb callback, void *user_data) { - return BT_ERROR_NOT_SUPPORTED; + int ret; + + BT_CHECK_INIT_STATUS(); + BT_CHECK_INPUT_PARAMETER(characteristic_handle); + BT_CHECK_INPUT_PARAMETER(callback); + + ret = _bt_get_error_code(bluetooth_gatt_discover_characteristic_descriptor + ((const char *)characteristic_handle)); + + if (ret != BT_ERROR_NONE) { + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); + } else { + _bt_set_cb(BT_EVENT_GATT_CHARACTERISTIC_DESCRIPTOR_DISCOVERED, callback, user_data); + } + + return ret; } int bt_gatt_connect(const char *address, bool auto_connect) { - return BT_ERROR_NOT_SUPPORTED; + int ret; + bluetooth_device_address_t bd_addr = { {0,} }; + + BT_CHECK_INIT_STATUS(); + BT_CHECK_INPUT_PARAMETER(address); + _bt_convert_address_to_hex(&bd_addr, address); + + ret = _bt_get_error_code(bluetooth_connect_le(&bd_addr, auto_connect ? TRUE : FALSE)); + + if (ret != BT_ERROR_NONE) { + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); + } + return ret; } int bt_gatt_disconnect(const char *address) { - return BT_ERROR_NOT_SUPPORTED; + int ret; + bluetooth_device_address_t bd_addr = { {0,} }; + + BT_CHECK_INIT_STATUS(); + BT_CHECK_INPUT_PARAMETER(address); + _bt_convert_address_to_hex(&bd_addr, address); + + ret = _bt_get_error_code(bluetooth_disconnect_le(&bd_addr)); + + if (ret != BT_ERROR_NONE) { + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); + } + return ret; } int bt_gatt_set_connection_state_changed_cb(bt_gatt_connection_state_changed_cb callback, void *user_data) { - return BT_ERROR_NOT_SUPPORTED; + BT_CHECK_INIT_STATUS(); + BT_CHECK_INPUT_PARAMETER(callback); + _bt_set_cb(BT_EVENT_GATT_CONNECTION_STATUS, callback, user_data); + + return BT_ERROR_NONE; } int bt_gatt_unset_connection_state_changed_cb(void) { - return BT_ERROR_NOT_SUPPORTED; + BT_CHECK_INIT_STATUS(); + _bt_unset_cb(BT_EVENT_GATT_CONNECTION_STATUS); + return BT_ERROR_NONE; } diff --git a/src/bluetooth-hdp.c b/src/bluetooth-hdp.c old mode 100644 new mode 100755 index b79ec9d..6a553d6 --- a/src/bluetooth-hdp.c +++ b/src/bluetooth-hdp.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved * * Licensed under the Apache License, Version 2.0 (the License); * you may not use this file except in compliance with the License. @@ -65,7 +65,7 @@ int bt_hdp_send_data(unsigned int channel, const char *data, unsigned int size) int error = BT_ERROR_NONE; BT_CHECK_INIT_STATUS(); - if (NULL == data) { + if (NULL == data || 0 >= size) { BT_ERR("%s", _bt_convert_error_to_string(BT_ERROR_INVALID_PARAMETER)); } error = bluetooth_hdp_send_data(channel, data, size); diff --git a/src/bluetooth-hid.c b/src/bluetooth-hid.c old mode 100644 new mode 100755 index 9f59a0f..b8a168a --- a/src/bluetooth-hid.c +++ b/src/bluetooth-hid.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved * * Licensed under the Apache License, Version 2.0 (the License); * you may not use this file except in compliance with the License. @@ -25,6 +25,25 @@ #include "bluetooth.h" #include "bluetooth_private.h" +static bool is_hid_host_initialized = false; + +#define BT_CHECK_HID_HOST_INIT_STATUS() \ + if (__bt_check_hid_host_init_status() == BT_ERROR_NOT_INITIALIZED) \ + { \ + LOGE("[%s] NOT_INITIALIZED(0x%08x)", __FUNCTION__, BT_ERROR_NOT_INITIALIZED); \ + return BT_ERROR_NOT_INITIALIZED; \ + } + +int __bt_check_hid_host_init_status(void) +{ + if (is_hid_host_initialized != true) { + BT_ERR("NOT_INITIALIZED(0x%08x)", BT_ERROR_NOT_INITIALIZED); + return BT_ERROR_NOT_INITIALIZED; + } + + return BT_ERROR_NONE; +} + int bt_hid_host_initialize(bt_hid_host_connection_state_changed_cb connection_cb, void *user_data) { @@ -37,10 +56,13 @@ int bt_hid_host_initialize(bt_hid_host_connection_state_changed_cb connection_cb error = _bt_get_error_code(error); if (BT_ERROR_NONE != error) { BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); - } else { - _bt_set_cb(BT_EVENT_HID_CONNECTION_STATUS, connection_cb, user_data); + return error; } - return error; + + _bt_set_cb(BT_EVENT_HID_CONNECTION_STATUS, connection_cb, user_data); + + is_hid_host_initialized = true; + return BT_ERROR_NONE; } int bt_hid_host_deinitialize() @@ -48,15 +70,19 @@ int bt_hid_host_deinitialize() int error; BT_CHECK_INIT_STATUS(); + BT_CHECK_HID_HOST_INIT_STATUS(); error = bluetooth_hid_deinit(); error = _bt_get_error_code(error); if (BT_ERROR_NONE != error) { BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), error); - } else { - _bt_unset_cb(BT_EVENT_HID_CONNECTION_STATUS); + return error; } - return error; + + _bt_unset_cb(BT_EVENT_HID_CONNECTION_STATUS); + + is_hid_host_initialized = false; + return BT_ERROR_NONE; } int bt_hid_host_connect(const char *remote_address) @@ -65,6 +91,7 @@ int bt_hid_host_connect(const char *remote_address) bluetooth_device_address_t addr_hex = { {0,} }; BT_CHECK_INIT_STATUS(); + BT_CHECK_HID_HOST_INIT_STATUS(); BT_CHECK_INPUT_PARAMETER(remote_address); _bt_convert_address_to_hex(&addr_hex, remote_address); @@ -83,6 +110,7 @@ int bt_hid_host_disconnect(const char *remote_address) bluetooth_device_address_t addr_hex = { {0,} }; BT_CHECK_INIT_STATUS(); + BT_CHECK_HID_HOST_INIT_STATUS(); BT_CHECK_INPUT_PARAMETER(remote_address); _bt_convert_address_to_hex(&addr_hex, remote_address); diff --git a/src/bluetooth-opp-client.c b/src/bluetooth-opp-client.c old mode 100644 new mode 100755 index 5e91927..6e870a1 --- a/src/bluetooth-opp-client.c +++ b/src/bluetooth-opp-client.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved * * Licensed under the Apache License, Version 2.0 (the License); * you may not use this file except in compliance with the License. @@ -25,6 +25,24 @@ #include "bluetooth_private.h" GList *sending_files; +static bool is_opp_client_initialized = false; + +#define BT_CHECK_OPP_CLIENT_INIT_STATUS() \ + if (__bt_check_opp_client_init_status() == BT_ERROR_NOT_INITIALIZED) \ + { \ + LOGE("[%s] NOT_INITIALIZED(0x%08x)", __FUNCTION__, BT_ERROR_NOT_INITIALIZED); \ + return BT_ERROR_NOT_INITIALIZED; \ + } + +int __bt_check_opp_client_init_status(void) +{ + if (is_opp_client_initialized != true) { + BT_ERR("NOT_INITIALIZED(0x%08x)", BT_ERROR_NOT_INITIALIZED); + return BT_ERROR_NOT_INITIALIZED; + } + + return BT_ERROR_NONE; +} char** __bt_opp_get_file_array(GList *file_list) { @@ -71,9 +89,11 @@ int bt_opp_client_initialize(void) if (error_code != BT_ERROR_NONE) { BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code); + return error_code; } - return error_code; + is_opp_client_initialized = true; + return BT_ERROR_NONE; } int bt_opp_client_deinitialize(void) @@ -81,17 +101,19 @@ int bt_opp_client_deinitialize(void) int error_code = BT_ERROR_NONE; BT_CHECK_INIT_STATUS(); + BT_CHECK_OPP_CLIENT_INIT_STATUS(); error_code = _bt_get_error_code(bluetooth_opc_deinit()); + bt_opp_client_clear_files(); if (error_code != BT_ERROR_NONE) { BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code); + return error_code; } - bt_opp_client_clear_files(); - - return error_code; + is_opp_client_initialized = false; + return BT_ERROR_NONE; } int bt_opp_client_add_file(const char *file) @@ -99,12 +121,16 @@ int bt_opp_client_add_file(const char *file) int error_code = BT_ERROR_NONE; BT_CHECK_INIT_STATUS(); + BT_CHECK_OPP_CLIENT_INIT_STATUS(); BT_CHECK_INPUT_PARAMETER(file); if (access(file, F_OK) == 0) { sending_files = g_list_append(sending_files, strdup(file)); } else { - error_code = BT_ERROR_INVALID_PARAMETER; + if (errno == EACCES || errno == EPERM) + error_code = BT_ERROR_PERMISSION_DENIED; + else + error_code = BT_ERROR_INVALID_PARAMETER; BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code); } @@ -119,6 +145,7 @@ int bt_opp_client_clear_files(void) char *c_file = NULL; BT_CHECK_INIT_STATUS(); + BT_CHECK_OPP_CLIENT_INIT_STATUS(); if (sending_files) { file_num = g_list_length(sending_files); @@ -150,6 +177,7 @@ int bt_opp_client_push_files(const char *remote_address, char **files = NULL; BT_CHECK_INIT_STATUS(); + BT_CHECK_OPP_CLIENT_INIT_STATUS(); BT_CHECK_INPUT_PARAMETER(remote_address); _bt_convert_address_to_hex(&addr_hex, remote_address); @@ -180,6 +208,7 @@ int bt_opp_client_cancel_push(void) int error_code = BT_ERROR_NONE; BT_CHECK_INIT_STATUS(); + BT_CHECK_OPP_CLIENT_INIT_STATUS(); error_code = _bt_get_error_code(bluetooth_opc_cancel_push()); diff --git a/src/bluetooth-opp-server.c b/src/bluetooth-opp-server.c old mode 100644 new mode 100755 index f6858da..6b92619 --- a/src/bluetooth-opp-server.c +++ b/src/bluetooth-opp-server.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved * * Licensed under the Apache License, Version 2.0 (the License); * you may not use this file except in compliance with the License. @@ -22,6 +22,25 @@ #include "bluetooth.h" #include "bluetooth_private.h" +static bool is_opp_server_initialized = false; + +#define BT_CHECK_OPP_SERVER_INIT_STATUS() \ + if (__bt_check_opp_server_init_status() == BT_ERROR_NOT_INITIALIZED) \ + { \ + LOGE("[%s] NOT_INITIALIZED(0x%08x)", __FUNCTION__, BT_ERROR_NOT_INITIALIZED); \ + return BT_ERROR_NOT_INITIALIZED; \ + } + +int __bt_check_opp_server_init_status(void) +{ + if (is_opp_server_initialized != true) { + BT_ERR("NOT_INITIALIZED(0x%08x)", BT_ERROR_NOT_INITIALIZED); + return BT_ERROR_NOT_INITIALIZED; + } + + return BT_ERROR_NONE; +} + int bt_opp_server_initialize(const char *destination, bt_opp_server_push_requested_cb push_requested_cb, void *user_data) @@ -36,11 +55,13 @@ int bt_opp_server_initialize(const char *destination, if (error_code != BT_ERROR_NONE) { BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code); - } else { - _bt_set_cb(BT_EVENT_OPP_PUSH_REQUESTED, push_requested_cb, user_data); + return error_code; } - return error_code; + _bt_set_cb(BT_EVENT_OPP_PUSH_REQUESTED, push_requested_cb, user_data); + + is_opp_server_initialized = true; + return BT_ERROR_NONE; } int bt_opp_server_initialize_by_connection_request(const char *destination, @@ -57,11 +78,13 @@ int bt_opp_server_initialize_by_connection_request(const char *destination, if (error_code != BT_ERROR_NONE) { BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code); - } else { - _bt_set_cb(BT_EVENT_OPP_CONNECTION_REQUESTED, connection_requested_cb, user_data); + return error_code; } - return error_code; + _bt_set_cb(BT_EVENT_OPP_CONNECTION_REQUESTED, connection_requested_cb, user_data); + + is_opp_server_initialized = true; + return BT_ERROR_NONE; } int bt_opp_server_deinitialize(void) @@ -69,6 +92,7 @@ int bt_opp_server_deinitialize(void) int error_code = BT_ERROR_NONE; BT_CHECK_INIT_STATUS(); + BT_CHECK_OPP_SERVER_INIT_STATUS(); if (_bt_check_cb(BT_EVENT_OPP_CONNECTION_REQUESTED) == false) { error_code = _bt_get_error_code(bluetooth_obex_server_deinit()); @@ -77,15 +101,17 @@ int bt_opp_server_deinitialize(void) error_code = _bt_get_error_code(bluetooth_obex_server_deinit_without_agent()); } + _bt_unset_cb(BT_EVENT_OPP_CONNECTION_REQUESTED); + _bt_unset_cb(BT_EVENT_OPP_PUSH_REQUESTED); + if (error_code != BT_ERROR_NONE) { BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), error_code); + return error_code; } - _bt_unset_cb(BT_EVENT_OPP_CONNECTION_REQUESTED); - _bt_unset_cb(BT_EVENT_OPP_PUSH_REQUESTED); - - return error_code; + is_opp_server_initialized = false; + return BT_ERROR_NONE; } int bt_opp_server_accept(bt_opp_server_transfer_progress_cb progress_cb, @@ -97,6 +123,7 @@ int bt_opp_server_accept(bt_opp_server_transfer_progress_cb progress_cb, int error_code = BT_ERROR_NONE; BT_CHECK_INIT_STATUS(); + BT_CHECK_OPP_SERVER_INIT_STATUS(); /* Unset the transfer callbacks */ _bt_unset_cb(BT_EVENT_OPP_SERVER_TRANSFER_PROGRESS); @@ -125,6 +152,7 @@ int bt_opp_server_reject(void) int error_code = BT_ERROR_NONE; BT_CHECK_INIT_STATUS(); + BT_CHECK_OPP_SERVER_INIT_STATUS(); if (_bt_check_cb(BT_EVENT_OPP_CONNECTION_REQUESTED) == false) { error_code = _bt_get_error_code(bluetooth_obex_server_reject_authorize()); @@ -150,6 +178,7 @@ int bt_opp_server_set_destination(const char *destination) int error_code = BT_ERROR_NONE; BT_CHECK_INIT_STATUS(); + BT_CHECK_OPP_SERVER_INIT_STATUS(); BT_CHECK_INPUT_PARAMETER(destination); error_code = _bt_get_error_code(bluetooth_obex_server_set_destination_path(destination)); @@ -166,6 +195,7 @@ int bt_opp_server_cancel_transfer(int transfer_id) int error_code = BT_ERROR_NONE; BT_CHECK_INIT_STATUS(); + BT_CHECK_OPP_SERVER_INIT_STATUS(); error_code = _bt_get_error_code(bluetooth_obex_server_cancel_transfer(transfer_id)); if (error_code != BT_ERROR_NONE) { diff --git a/src/bluetooth-pan.c b/src/bluetooth-pan.c old mode 100644 new mode 100755 index 947d605..052d404 --- a/src/bluetooth-pan.c +++ b/src/bluetooth-pan.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved * * Licensed under the Apache License, Version 2.0 (the License); * you may not use this file except in compliance with the License. @@ -72,7 +72,19 @@ int bt_nap_disconnect_all(void) int bt_nap_disconnect(const char *remote_address) { - return BT_ERROR_NOT_SUPPORTED; + int error = BT_ERROR_INVALID_PARAMETER; + bluetooth_device_address_t addr_hex = { {0,} }; + + BT_CHECK_INIT_STATUS(); + BT_CHECK_INPUT_PARAMETER(remote_address); + _bt_convert_address_to_hex(&addr_hex, remote_address); + error = bluetooth_network_server_disconnect(&addr_hex); + error = _bt_get_error_code(error); + if (error != BT_ERROR_NONE) { + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error), + error); + } + return error; } int bt_nap_set_connection_state_changed_cb( diff --git a/src/bluetooth-socket.c b/src/bluetooth-socket.c old mode 100644 new mode 100755 index c459ae0..8ba0adc --- a/src/bluetooth-socket.c +++ b/src/bluetooth-socket.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved * * Licensed under the Apache License, Version 2.0 (the License); * you may not use this file except in compliance with the License. @@ -98,7 +98,21 @@ int bt_socket_listen(int socket_fd, int max_pending_connections) int bt_socket_accept(int socket_fd) { +#ifdef ENABLE_TIZEN_2_4 + int error_code = BT_ERROR_NONE; + + BT_CHECK_INIT_STATUS(); + + error_code = _bt_get_error_code(bluetooth_rfcomm_accept_connection(socket_fd)); + if (error_code != BT_ERROR_NONE) { + BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(error_code), + error_code); + } + + return error_code; +#else return BT_ERROR_NOT_SUPPORTED; +#endif } int bt_socket_reject(int socket_fd) @@ -156,15 +170,23 @@ int bt_socket_send_data(int socket_fd, const char *data, int length) int ret = 0; BT_CHECK_INIT_STATUS(); - ret = bluetooth_rfcomm_write(socket_fd, data, length); - if (ret == BLUETOOTH_ERROR_NOT_IN_OPERATION) { - BT_ERR("OPERATION_FAILED(0x%08x)", BT_ERROR_OPERATION_FAILED); - return BT_ERROR_OPERATION_FAILED; - } - ret = _bt_get_error_code(ret); - if (ret != BT_ERROR_NONE) { - BT_ERR("%s(0x%08x)", _bt_convert_error_to_string(ret), ret); + ret = bluetooth_rfcomm_write(socket_fd, data, length); + if (ret <= 0) { + if (ret == -1) { + /* write fail case */ + if (errno == EACCES || errno == EPERM) + set_last_result(BT_ERROR_PERMISSION_DENIED); + else if (errno == EAGAIN || errno == EWOULDBLOCK) + set_last_result(BT_ERROR_AGAIN); + else + set_last_result(BT_ERROR_OPERATION_FAILED); + } else { + ret = _bt_get_error_code(ret); + set_last_result(ret); + } + + BT_ERR("Write failed, ret = %d", ret); } return ret; diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt old mode 100644 new mode 100755 index 7715cac..898754a --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -15,3 +15,7 @@ FOREACH(src ${sources}) ADD_EXECUTABLE(${src_name} ${src}) TARGET_LINK_LIBRARIES(${src_name} ${fw_name} ${${fw_test}_LDFLAGS}) ENDFOREACH() + +INSTALL(TARGETS bt_unit_test DESTINATION bin) +INSTALL(TARGETS bt_onoff DESTINATION bin) +INSTALL(FILES capi-network-bluetooth-test.efl DESTINATION /etc/smack/accesses.d/) diff --git a/test/bt_chat_client.c b/test/bt_chat_client.c old mode 100644 new mode 100755 index 9413372..f7e3b47 --- a/test/bt_chat_client.c +++ b/test/bt_chat_client.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved * * Licensed under the Apache License, Version 2.0 (the License); * you may not use this file except in compliance with the License. @@ -23,7 +23,7 @@ #ifdef LOG_TAG #undef LOG_TAG #endif -#define LOG_TAG "BT_CHAT_CLIENT" +#define LOG_TAG "BLUETOOTH_CHAT_CLIENT" /** * Variables diff --git a/test/bt_chat_server.c b/test/bt_chat_server.c old mode 100644 new mode 100755 index 139e6f2..787c3f7 --- a/test/bt_chat_server.c +++ b/test/bt_chat_server.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved * * Licensed under the Apache License, Version 2.0 (the License); * you may not use this file except in compliance with the License. @@ -23,7 +23,7 @@ #ifdef LOG_TAG #undef LOG_TAG #endif -#define LOG_TAG "BT_CHAT_SERVER" +#define LOG_TAG "BLUETOOTH_CHAT_SERVER" /** * Variables diff --git a/test/bt_onoff.c b/test/bt_onoff.c new file mode 100755 index 0000000..f95106a --- /dev/null +++ b/test/bt_onoff.c @@ -0,0 +1,131 @@ +/* + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved + * + * Licensed under the Apache License, Version 2.0 (the License); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an AS IS BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @file bt_onoff.c + * @brief This is the source file for bt activation/deactivation. + */ + +#include +#include + +#include "bluetooth.h" + +#define PRT(format, args...) printf("%s:%d() "format, __FUNCTION__, __LINE__, ##args) +#define TC_PRT(format, args...) PRT(format"\n", ##args) + +GMainLoop *main_loop = NULL; +static guint onoff_timer = 0; + +static void __bt_adapter_state_changed_cb(int result, bt_adapter_state_e adapter_state, void *user_data) +{ + TC_PRT("state(%d), error(%d)", adapter_state, result); + + if (onoff_timer) + g_source_remove(onoff_timer); + onoff_timer = 0; + + if (result != BT_ERROR_NONE) { + char *argv[] = {NULL}; + execv("all_log_dump.sh", argv); + } + + if (main_loop) + g_main_loop_quit(main_loop); + else + exit(0); +} + +static gboolean __bt_onoff_timeout_cb(gpointer data) +{ + TC_PRT("Timed out"); + + char *argv[] = {NULL}; + execv("all_log_dump.sh", argv); + + if (main_loop) + g_main_loop_quit(main_loop); + else + exit(0); + + return FALSE; +} + +int main(int argc, char* argv[]) +{ + int ret; + bt_adapter_state_e state; + + if(bt_initialize() != BT_ERROR_NONE) + { + TC_PRT("bt_initialize() failed."); + return -1; + } + if (bt_adapter_set_state_changed_cb(__bt_adapter_state_changed_cb, NULL) != BT_ERROR_NONE) + { + TC_PRT("bt_adapter_set_state_changed_cb() failed."); + goto DONE; + } + + main_loop = g_main_loop_new(NULL, FALSE); + + bt_adapter_get_state(&state); + ret = bt_adapter_get_state(&state); + TC_PRT("state(%d), error(%d)", state, ret); + + onoff_timer = g_timeout_add(20000, (GSourceFunc)__bt_onoff_timeout_cb, NULL); + + if (argc <= 1) { + if (state == BT_ADAPTER_DISABLED) + ret = bt_adapter_enable(); + else + ret = bt_adapter_disable(); + TC_PRT("bt_adapter_%s() error(%d)", state==BT_ADAPTER_DISABLED?"enable":"disable", ret); + } else { + if (argv[1][0] == '0') { + if (state == BT_ADAPTER_DISABLED) { + TC_PRT("Already disabled"); + goto DONE; + } else { + ret = bt_adapter_disable(); + TC_PRT("bt_adapter_disable() error(%d)", ret); + if (ret != BT_ERROR_NONE) + goto DONE; + } + } else { + if (state == BT_ADAPTER_ENABLED) { + TC_PRT("Already eabled"); + goto DONE; + } else { + ret = bt_adapter_enable(); + TC_PRT("bt_adapter_enable() error(%d)", ret); + if (ret != BT_ERROR_NONE) + goto DONE; + } + } + } + + g_main_loop_run(main_loop); + +DONE: + if (onoff_timer) + g_source_remove(onoff_timer); + onoff_timer = 0; + bt_adapter_unset_state_changed_cb(); + bt_deinitialize(); + + return 0; +} diff --git a/test/bt_unit_test.c b/test/bt_unit_test.c old mode 100644 new mode 100755 index 1ddc3b0..ea2e28c --- a/test/bt_unit_test.c +++ b/test/bt_unit_test.c @@ -1,17 +1,24 @@ /* - * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd. + * capi-network-bluetooth * - * Licensed under the Apache License, Version 2.0 (the License); + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: Hocheol Seo + * Girishashok Joshi + * Chanyeol Park + * + * 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 + * 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, + * 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. + * */ /** @@ -21,161 +28,438 @@ #include #include +#include +#include #include #include #include "bluetooth.h" #include "bluetooth-telephony-api.h" - -#define BUFFER_LEN 10 -#define MAX_SERVICES 10 -#define PRT(format, args...) printf("%s:%d() "format, __FUNCTION__, __LINE__, ##args) -#define TC_PRT(format, args...) PRT(format"\n", ##args) +#include "bt_unit_test.h" const char *spp_uuid = "00001101-0000-1000-8000-00805F9B34FB"; const char *opp_uuid = "00001105-0000-1000-8000-00805f9b34fb"; +static bt_unit_test_table_e current_tc_table; +static char remote_addr[18] = "F6:FB:8F:D8:C8:7C"; +static bool input_automated_test_delay = false; + static int server_fd; static int client_fd; +static gboolean is_sub_index = FALSE; int service_index; int char_service_index; +static int selected_service_index = -1; +static int selected_char_index = 0; bt_gatt_attribute_h service_clone[MAX_SERVICES]; bt_gatt_attribute_h characteristics[MAX_SERVICES]; bt_gatt_attribute_h characteristics_services[MAX_SERVICES]; +static unsigned char *hash = NULL; +static unsigned char *randomizer = NULL; +int hash_len; +int rand_len; bt_call_list_h call_list; GMainLoop *main_loop = NULL; -typedef struct { - const char *tc_name; - int tc_code; -} tc_table_t; +tc_table_t tc_main[] = { + /* Categories */ + {"SET ADDRESS" , BT_UNIT_TEST_FUNCTION_SET_ADDRESS}, + {"bt_initialize" , BT_UNIT_TEST_FUNCTION_INITIALIZE}, + {"bt_deinitialize" , BT_UNIT_TEST_FUNCTION_DEINITIALIZE}, + {"Adapter" , BT_UNIT_TEST_TABLE_ADAPTER}, + {"Adapter LE" , BT_UNIT_TEST_TABLE_ADAPTER_LE}, + {"Device" , BT_UNIT_TEST_TABLE_DEVICE}, + {"Socket" , BT_UNIT_TEST_TABLE_SOCKET}, + {"Opp" , BT_UNIT_TEST_TABLE_OPP}, + {"Audio(ag, a2dp, call)" , BT_UNIT_TEST_TABLE_AUDIO}, + {"Pan(nap, panu)" , BT_UNIT_TEST_TABLE_PAN}, + {"Gatt" , BT_UNIT_TEST_TABLE_GATT}, + {"Avrcp" , BT_UNIT_TEST_TABLE_AVRCP}, + {"Hid" , BT_UNIT_TEST_TABLE_HID}, + {"Automated test" , BT_UNIT_TEST_TABLE_AUTOMATED_TEST}, + {"FINISH" , 0x00ff}, + {NULL , 0x0000}, +}; -tc_table_t tc_table[] = { +tc_table_t tc_adapter[] = { /* Adapter functions */ - {"bt_initialize" , 1}, - {"bt_deinitialize" , 2}, - {"bt_adapter_get_state" , 3}, - {"bt_adapter_enable" , 4}, - {"bt_adapter_disable" , 5}, - {"bt_adapter_start_device_discovery" , 6}, - {"bt_adapter_stop_device_discovery" , 7}, - {"bt_adapter_is_discovering" , 8}, - {"bt_adapter_get_bonded_device_info" , 9}, - {"bt_adapter_is_service_used" , 10}, - {"bt_adapter_get_visibility" , 11}, - {"bt_adapter_set_device_discovery_state_changed_cb" , 12}, - {"bt_adapter_unset_device_discovery_state_changed_cb" , 13}, + {"BACK" , BT_UNIT_TEST_FUNCTION_BACK}, + {"bt_adapter_get_state" , BT_UNIT_TEST_FUNCTION_ADAPTER_GET_STATE}, + {"bt_adapter_enable" , BT_UNIT_TEST_FUNCTION_ADAPTER_ENABLE}, + {"bt_adapter_disable" , BT_UNIT_TEST_FUNCTION_ADAPTER_DISABLE}, + {"bt_adapter_recover" , BT_UNIT_TEST_FUNCTION_ADAPTER_RECOVER}, + {"bt_adapter_start_device_discovery" , BT_UNIT_TEST_FUNCTION_ADAPTER_START_DEVICE_DISCOVERY}, + {"bt_adapter_stop_device_discovery" , BT_UNIT_TEST_FUNCTION_ADAPTER_STOP_DEVICE_DISCOVERY}, + {"bt_adapter_is_discovering" , BT_UNIT_TEST_FUNCTION_ADAPTER_IS_DISCOVERING}, + {"bt_adapter_foreach_bonded_device" , BT_UNIT_TEST_FUNCTION_ADAPTER_FOREACH_BONDED_DEVICE}, + {"bt_adapter_get_bonded_device_info" , BT_UNIT_TEST_FUNCTION_ADAPTER_GET_BONDED_DEVICE_INFO}, + {"bt_adapter_is_service_used" , BT_UNIT_TEST_FUNCTION_ADAPTER_IS_SERVICE_USED}, + {"bt_adapter_get_visibility" , BT_UNIT_TEST_FUNCTION_ADAPTER_GET_VISIBILITY}, + {"bt_adapter_set_device_discovery_state_changed_cb" , BT_UNIT_TEST_FUNCTION_ADAPTER_SET_DEVICE_DISCOVERY_STATE_CHANGED_CB}, + {"bt_adapter_unset_device_discovery_state_changed_cb" , BT_UNIT_TEST_FUNCTION_ADAPTER_UNSET_DEVICE_DISCOVERY_STATE_CHANGED_CB}, + {"bt_adapter_get_local_oob_data" , BT_UNIT_TEST_FUNCTION_ADAPTER_GET_LOCAL_OOB_DATA}, + {"bt_adapter_set_remote_oob_data" , BT_UNIT_TEST_FUNCTION_ADAPTER_SET_LOCAL_OOB_DATA}, + {"bt_adapter_remove_remote_oob_data" , BT_UNIT_TEST_FUNCTION_ADAPTER_REMOVE_REMOTE_OOB_DATA}, + {"bt_adapter_set_visibility_mode_changed_cb" , BT_UNIT_TEST_FUNCTION_ADAPTER_SET_VISIBILITY_MODE_CHANGED_CB}, + {"bt_adapter_unset_visibility_mode_changed_cb" , BT_UNIT_TEST_FUNCTION_ADAPTER_UNSET_VISIBILITY_MODE_CHANGED_CB}, + {"bt_adapter_set_visibility_duration_changed_cb" , BT_UNIT_TEST_FUNCTION_ADAPTER_SET_VISIBILITY_DURATION_CHANGED_CB}, + {"bt_adapter_unset_visibility_duration_changed_cb" , BT_UNIT_TEST_FUNCTION_ADAPTER_UNSET_VISIBILITY_DURATION_CHANGED_CB}, + {"bt_adapter_set_connectable_changed_cb" , BT_UNIT_TEST_FUNCTION_ADAPTER_SET_CONNECTABLE_CHANGED_CB}, + {"bt_adapter_unset_connectable_changed_cb" , BT_UNIT_TEST_FUNCTION_ADAPTER_UNSET_CONNECTABLE_CHANGED_CB}, + {"bt_adapter_get_connectable" , BT_UNIT_TEST_FUNCTION_ADAPTER_GET_CONNECTABLE}, + {"bt_adapter_set_connectable" , BT_UNIT_TEST_FUNCTION_ADAPTER_SET_CONNECTABLE}, + {"bt_adapter_get_version" , BT_UNIT_TEST_FUNCTION_ADAPTER_GET_VERSION}, + {"bt_adapter_get_local_info" , BT_UNIT_TEST_FUNCTION_ADAPTER_GET_LOCAL_INFO}, + {NULL , 0x0000}, +}; + +tc_table_t tc_adapter_le[] = { + /* Adapter functions */ + {"BACK" , BT_UNIT_TEST_FUNCTION_BACK}, + {"bt_adapter_le_get_state" , BT_UNIT_TEST_FUNCTION_ADAPTER_LE_GET_STATE}, + {"bt_adapter_le_enable" , BT_UNIT_TEST_FUNCTION_ADAPTER_LE_ENABLE}, + {"bt_adapter_le_disable" , BT_UNIT_TEST_FUNCTION_ADAPTER_LE_DISABLE}, + {"bt_adapter_le_start_device_discovery" , BT_UNIT_TEST_FUNCTION_ADAPTER_LE_START_DEVICE_DISCOVERY}, + {"bt_adapter_le_stop_device_discovery" , BT_UNIT_TEST_FUNCTION_ADAPTER_LE_STOP_DEVICE_DISCOVERY}, + {"bt_adapter_le_start_advertising" , BT_UNIT_TEST_FUNCTION_ADAPTER_LE_START_ADVERTISING}, + {"bt_adapter_le_stop_advertising" , BT_UNIT_TEST_FUNCTION_ADAPTER_LE_STOP_ADVERTISING}, + {"bt_adapter_le_add_white_list" , BT_UNIT_TEST_FUNCTION_ADAPTER_LE_ADD_WHITE_LIST}, + {"bt_adapter_le_remove_white_list" , BT_UNIT_TEST_FUNCTION_ADAPTER_LE_REMOVE_WHITE_LIST}, + {"bt_adapter_le_clear_white_list" , BT_UNIT_TEST_FUNCTION_ADAPTER_LE_CLEAR_WHITE_LIST}, + {"bt_adapter_le_enable_privacy" , BT_UNIT_TEST_FUNCTION_ADAPTER_LE_ENABLE_PRIVACY}, + {"bt_adapter_le_set_device_discovery_state_changed_cb" , BT_UNIT_TEST_FUNCTION_ADAPTER_LE_SET_DEVICE_DISCOVERY_STATE_CHANGED_CB}, + {"bt_adapter_le_unset_device_discovery_state_changed_cb" , BT_UNIT_TEST_FUNCTION_ADAPTER_LE_UNSET_DEVICE_DISCOVERY_STATE_CHANGED_CB}, + {NULL , 0x0000}, +}; +tc_table_t tc_device[] = { + /* Device functions */ + {"BACK" , BT_UNIT_TEST_FUNCTION_BACK}, + {"bt_device_set_authorization (true)" , BT_UNIT_TEST_FUNCTION_DEVICE_SET_AUTHORIZATION_TRUE}, + {"bt_device_set_authorization (false)" , BT_UNIT_TEST_FUNCTION_DEVICE_SET_AUTHORIZATION_FALSE}, + {"bt_device_set_authorization_changed_cb" , BT_UNIT_TEST_FUNCTION_DEVICE_SET_AUTHORIZATION_CHANGED_CB}, + {"bt_device_unset_authorization_changed_cb" , BT_UNIT_TEST_FUNCTION_DEVICE_UNSET_AUTHORIZATION_CHANGED_CB}, + {"bt_device_set_connection_state_changed_cb" , BT_UNIT_TEST_FUNCTION_DEVICE_SET_CONNECTION_STAET_CHANGED_CB}, + {"bt_device_unset_connection_state_changed_cb" , BT_UNIT_TEST_FUNCTION_DEVICE_UNSET_CONNECTION_STAET_CHANGED_CB}, + {"bt_device_foreach_connected_profiles" , BT_UNIT_TEST_FUNCTION_DEVICE_FOREACH_CONNECTED_PROFILES}, + {"bt_device_is_profile_connected" , BT_UNIT_TEST_FUNCTION_DEVICE_IS_PROFILE_CONNECTED}, + {"bt_device_set_bond_created_cb" , BT_UNIT_TEST_FUNCTION_DEVICE_SET_BOND_CREATED_CB}, + {"bt_device_create_bond" , BT_UNIT_TEST_FUNCTION_DEVICE_CREATE_BOND}, + {"bt_device_create_bond_by_type" , BT_UNIT_TEST_FUNCTION_DEVICE_CREATE_BOND_BY_TYPE}, + {NULL , 0x0000}, +}; + +tc_table_t tc_socket[] = { /* Socket functions */ - {"bt_socket_create_rfcomm" , 50}, - {"bt_socket_destroy_rfcomm" , 51}, - {"bt_socket_listen_and_accept_rfcomm" , 52}, - {"bt_socket_listen" , 53}, - {"bt_socket_accept" , 54}, - {"bt_socket_reject" , 55}, - {"bt_socket_connect_rfcomm" , 56}, - {"bt_socket_disconnect_rfcomm" , 57}, - {"bt_socket_send_data" , 58}, - {"bt_socket_set_data_received_cb" , 59}, - {"bt_socket_unset_data_received_cb" , 60}, - {"bt_socket_set_connection_requested_cb" , 61}, - {"bt_socket_unset_connection_requested_cb" , 62}, - {"bt_socket_set_connection_state_changed_cb" , 63}, - {"bt_socket_unset_connection_state_changed_cb" , 64}, + {"BACK" , BT_UNIT_TEST_FUNCTION_BACK}, + {"bt_socket_create_rfcomm" , BT_UNIT_TEST_FUNCTION_SOCKET_CREATE_RFCOMM}, + {"bt_socket_destroy_rfcomm" , BT_UNIT_TEST_FUNCTION_SOCKET_DESTROY_RFCOMM}, + {"bt_socket_listen_and_accept_rfcomm" , BT_UNIT_TEST_FUNCTION_SOCKET_LISTEN_AND_ACCEPT_RFCOMM}, + {"bt_socket_listen" , BT_UNIT_TEST_FUNCTION_SOCKET_LISTEN}, + {"bt_socket_accept" , BT_UNIT_TEST_FUNCTION_SOCKET_ACCEPT}, + {"bt_socket_reject" , BT_UNIT_TEST_FUNCTION_SOCKET_REJECT}, + {"bt_socket_connect_rfcomm" , BT_UNIT_TEST_FUNCTION_SOCKET_CONNECT_RFCOMM}, + {"bt_socket_disconnect_rfcomm" , BT_UNIT_TEST_FUNCTION_SOCKET_DISCONNECT_RFCOMM}, + {"bt_socket_send_data" , BT_UNIT_TEST_FUNCTION_SOCKET_SEND_DATA}, + {"bt_socket_set_data_received_cb" , BT_UNIT_TEST_FUNCTION_SOCKET_SET_DATA_RECEIVED_CB}, + {"bt_socket_unset_data_received_cb" , BT_UNIT_TEST_FUNCTION_SOCKET_UNSET_DATA_RECEIVED_CB}, + {"bt_socket_set_connection_requested_cb" , BT_UNIT_TEST_FUNCTION_SOCKET_SET_CONNECTION_REQUESTED_CB}, + {"bt_socket_unset_connection_requested_cb" , BT_UNIT_TEST_FUNCTION_SOCKET_UNSET_CONNECTION_REQUESTED_CB}, + {"bt_socket_set_connection_state_changed_cb" , BT_UNIT_TEST_FUNCTION_SOCKET_SET_CONNECTION_STATE_CHANGED_CB}, + {"bt_socket_unset_connection_state_changed_cb" , BT_UNIT_TEST_FUNCTION_SOCKET_UNSET_CONNECTION_STATE_CHANGED_CB}, + {NULL , 0x0000}, +}; +tc_table_t tc_opp[] = { /* OPP functions */ - {"bt_opp_client_initialize" , 70}, - {"bt_opp_client_deinitialize" , 71}, - {"bt_opp_client_add_file" , 72}, - {"bt_opp_client_clear_files" , 73}, - {"bt_opp_client_push_files" , 74}, - {"bt_opp_client_cancel_push" , 75}, + {"BACK" , BT_UNIT_TEST_FUNCTION_BACK}, + {"bt_opp_client_initialize" , BT_UNIT_TEST_FUNCTION_OPP_CLIENT_INITIALIZE}, + {"bt_opp_client_deinitialize" , BT_UNIT_TEST_FUNCTION_OPP_CLIENT_DEINITIALIZE}, + {"bt_opp_client_add_file" , BT_UNIT_TEST_FUNCTION_OPP_CLIENT_ADD_FILE}, + {"bt_opp_client_clear_files" , BT_UNIT_TEST_FUNCTION_OPP_CLIENT_CLEAR_FILES}, + {"bt_opp_client_push_files" , BT_UNIT_TEST_FUNCTION_OPP_CLIENT_PUSH_FILES}, + {"bt_opp_client_cancel_push" , BT_UNIT_TEST_FUNCTION_OPP_CLIENT_CANCEL_PUSH}, + {NULL , 0x0000}, +}; +tc_table_t tc_audio[] = { /* AG functions */ - {"bt_audio_initialize" , 80}, - {"bt_audio_deinitialize" , 81}, - {"bt_audio_connect" , 82}, - {"bt_audio_disconnect" , 83}, - {"bt_audio_set_connection_state_changed_cb", 84}, - {"bt_audio_unset_connection_state_changed_cb", 85}, - {"bt_ag_open_sco" , 86}, - {"bt_ag_close_sco" , 87}, - {"bt_ag_is_sco_opened" , 88}, - {"bt_ag_set_sco_state_changed_cb" , 89}, - {"bt_ag_unset_sco_state_changed_cb" , 90}, - {"BT_AG_CALL_EVENT_IDLE" , 91}, - {"BT_AG_CALL_EVENT_ANSWERED" , 92}, - {"BT_AG_CALL_EVENT_DIALING" , 93}, - {"BT_AG_CALL_EVENT_ALERTING" , 94}, - {"BT_AG_CALL_EVENT_INCOMING" , 95}, - {"bt_call_list_create" , 96}, - {"bt_call_list_destroy" , 97}, - {"bt_call_list_reset" , 98}, - {"bt_call_list_add" , 99}, - {"bt_ag_notify_call_list" , 100}, - {"bt_ag_set_call_handling_event_cb" , 101}, - {"bt_ag_is_nrec_enabled" , 102}, + {"BACK" , BT_UNIT_TEST_FUNCTION_BACK}, + {"bt_audio_initialize" , BT_UNIT_TEST_FUNCTION_AUDIO_INITIALIZE}, + {"bt_audio_deinitialize" , BT_UNIT_TEST_FUNCTION_AUDIO_DEINITIALIZE}, + {"bt_audio_connect" , BT_UNIT_TEST_FUNCTION_AUDIO_CONNECT}, + {"bt_audio_disconnect" , BT_UNIT_TEST_FUNCTION_AUDIO_DISCONNECT}, + {"bt_audio_set_connection_state_changed_cb" , BT_UNIT_TEST_FUNCTION_AUDIO_SET_CONNECTION_STATE_CHANGED_CB}, + {"bt_audio_unset_connection_state_changed_cb" , BT_UNIT_TEST_FUNCTION_AUDIO_UNSET_CONNECTION_STATE_CHANGED_CB}, + {"bt_ag_open_sco" , BT_UNIT_TEST_FUNCTION_AG_OPEN_SCO}, + {"bt_ag_close_sco" , BT_UNIT_TEST_FUNCTION_AG_CLOSE_SCO}, + {"bt_ag_is_sco_opened" , BT_UNIT_TEST_FUNCTION_AG_IS_SCO_OPENED}, + {"bt_ag_set_sco_state_changed_cb" , BT_UNIT_TEST_FUNCTION_AG_SET_SCO_STATE_CHANGED_CB}, + {"bt_ag_unset_sco_state_changed_cb" , BT_UNIT_TEST_FUNCTION_AG_UNSET_SCO_STATE_CHANGED_CB}, + {"BT_AG_CALL_EVENT_IDLE" , BT_UNIT_TEST_FUNCTION_AG_CALL_EVENT_IDLE}, + {"BT_AG_CALL_EVENT_ANSWERED" , BT_UNIT_TEST_FUNCTION_AG_CALL_EVENT_ANSWERED}, + {"BT_AG_CALL_EVENT_DIALING" , BT_UNIT_TEST_FUNCTION_AG_CALL_EVENT_DIALING}, + {"BT_AG_CALL_EVENT_ALERTING" , BT_UNIT_TEST_FUNCTION_AG_CALL_EVENT_ALERTING}, + {"BT_AG_CALL_EVENT_INCOMING" , BT_UNIT_TEST_FUNCTION_AG_CALL_EVENT_INCOMING}, + {"bt_call_list_create" , BT_UNIT_TEST_FUNCTION_CALL_LIST_CREATE}, + {"bt_call_list_destroy" , BT_UNIT_TEST_FUNCTION_CALL_LIST_DESTROY}, + {"bt_call_list_reset" , BT_UNIT_TEST_FUNCTION_CALL_LIST_RESET}, + {"bt_call_list_add" , BT_UNIT_TEST_FUNCTION_CALL_LIST_ADD}, + {"bt_ag_notify_call_list" , BT_UNIT_TEST_FUNCTION_AG_NOTIFY_CALL_LIST}, + {"bt_ag_set_call_handling_event_cb" , BT_UNIT_TEST_FUNCTION_AG_SET_CALL_HANDLING_EVENT_CB}, + {"bt_ag_is_nrec_enabled" , BT_UNIT_TEST_FUNCTION_AG_IS_NREC_ENABLED}, + {NULL , 0x0000}, +}; +tc_table_t tc_pan[] = { /* Network functions */ - {"bt_nap_activate" , 110}, - {"bt_nap_deactivate" , 111}, - {"bt_nap_disconnect_all" , 112}, - - /* Device functions */ - {"bt_device_set_authorization (true)" , 120}, - {"bt_device_set_authorization (false)" , 121}, - {"bt_device_set_authorization_changed_cb" , 122}, - {"bt_device_unset_authorization_changed_cb" , 123}, - {"bt_device_set_connection_state_changed_cb" , 124}, - {"bt_device_unset_connection_state_changed_cb" , 125}, - {"bt_device_foreach_connected_profiles" , 126}, + {"BACK" , BT_UNIT_TEST_FUNCTION_BACK}, + {"bt_nap_activate" , BT_UNIT_TEST_FUNCTION_NAP_ACTIVATE}, + {"bt_nap_deactivate" , BT_UNIT_TEST_FUNCTION_NAP_DEACTIVATE}, + {"bt_nap_disconnect_all" , BT_UNIT_TEST_FUNCTION_NAP_DISCONNECT_ALL}, + {"bt_nap_disconnect" , BT_UNIT_TEST_FUNCTION_NAP_DISCONNECT}, + {"bt_panu_set_connection_state_changed_cb" , BT_UNIT_TEST_FUNCTION_PANU_SET_CONNECTION_STATE_CHANGED_CB}, + {"bt_panu_connect" , BT_UNIT_TEST_FUNCTION_PANU_CONNECT}, + {NULL , 0x0000}, +}; +tc_table_t tc_gatt[] = { /* Gatt functions */ - {"bt_gatt_foreach_primary_services" , 140}, - {"bt_gatt_discover_characteristics" , 141}, - {"bt_gatt_get_service_uuid" , 142}, - {"bt_gatt_foreach_included_services" , 143}, - {"bt_gatt_set_characteristic_changed_cb" , 144}, - {"bt_gatt_unset_characteristic_changed_cb" , 145}, - {"bt_gatt_get_characteristic_declaration" , 146}, - {"bt_gatt_set_characteristic_value" , 147}, + {"BACK" , BT_UNIT_TEST_FUNCTION_BACK}, + {"bt_gatt_foreach_primary_services" , BT_UNIT_TEST_FUNCTION_GATT_FOREACH_PRIMARY_SERVICES}, + {"bt_gatt_discover_characteristics" , BT_UNIT_TEST_FUNCTION_GATT_DISCOVER_CHARACTERISTICS}, + {"bt_gatt_get_service_uuid" , BT_UNIT_TEST_FUNCTION_GATT_GET_SERVICE_UUID}, + {"bt_gatt_foreach_included_services" , BT_UNIT_TEST_FUNCTION_GATT_FOREACH_INCLUDED_SERVICES}, + {"bt_gatt_set_characteristic_changed_cb" , BT_UNIT_TEST_FUNCTION_GATT_SET_CHARACTERISTIC_CHANGED_CB}, + {"bt_gatt_unset_characteristic_changed_cb" , BT_UNIT_TEST_FUNCTION_GATT_UNSET_CHARACTERISTIC_CHANGED_CB}, + {"bt_gatt_get_characteristic_declaration" , BT_UNIT_TEST_FUNCTION_GATT_GET_CHARACTERISTIC_DECLARATION}, + {"bt_gatt_set_characteristic_value" , BT_UNIT_TEST_FUNCTION_GATT_SET_CHARACTERISTIC_VALUE}, + {"bt_gatt_read_characteristic_value" , BT_UNIT_TEST_FUNCTION_GATT_READ_CHARACTERISTIC_VALUE}, + {"bt_gatt_watch_characteristic_changes" , BT_UNIT_TEST_FUNCTION_GATT_WATCH_CHARACTERISTIC_CHANGES}, + {"bt_gatt_unwatch_characteristic_changes" , BT_UNIT_TEST_FUNCTION_GATT_UNWATCH_CHARACTERISTIC_CHANGES}, + {"bt_gatt_connect" , BT_UNIT_TEST_FUNCTION_GATT_CONNECT}, + {"bt_gatt_disconnect" , BT_UNIT_TEST_FUNCTION_GATT_DISCONNECT}, + {"bt_gatt_set_connection_state_changed_cb" , BT_UNIT_TEST_FUNCTION_SET_GATT_CONNECTION_STATE_CHANGED_CB}, + {"bt_gatt_unset_connection_state_changed_cb" , BT_UNIT_TEST_FUNCTION_UNSET_GATT_CONNECTION_STATE_CHANGED_CB}, + {NULL , 0x0000}, +}; +tc_table_t tc_avrcp[] = { /* AVRCP functions */ - {"bt_avrcp_target_initialize" , 160}, - {"bt_avrcp_target_deinitialize" , 161}, - {"bt_avrcp_set_equalizer_state_changed_cb" , 162}, - {"bt_avrcp_set_repeat_mode_changed_cb" , 163}, - {"bt_avrcp_set_shuffle_mode_changed_cb" , 164}, - {"bt_avrcp_set_scan_mode_changed_cb" , 165}, - {"bt_avrcp_unset_equalizer_state_changed_cb" , 166}, - {"bt_avrcp_unset_repeat_mode_changed_cb" , 167}, - {"bt_avrcp_unset_shuffle_mode_changed_cb" , 168}, - {"bt_avrcp_unset_scan_mode_changed_cb" , 169}, - - /* -----------------------------------------*/ - {"Finish" , 0x00ff}, + {"BACK" , BT_UNIT_TEST_FUNCTION_BACK}, + {"bt_avrcp_target_initialize" , BT_UNIT_TEST_FUNCTION_AVRCP_TARGET_INITIALIZE}, + {"bt_avrcp_target_deinitialize" , BT_UNIT_TEST_FUNCTION_AVRCP_TARGET_DEINITIALIZE}, + {"bt_avrcp_set_equalizer_state_changed_cb" , BT_UNIT_TEST_FUNCTION_AVRCP_SET_EQUALIZER_STATE_CHANGED_CB}, + {"bt_avrcp_set_repeat_mode_changed_cb" , BT_UNIT_TEST_FUNCTION_AVRCP_SET_REPEAT_MODE_CHANGED_CB}, + {"bt_avrcp_set_shuffle_mode_changed_cb" , BT_UNIT_TEST_FUNCTION_AVRCP_SET_SHUFFLE_MODE_CHANGED_CB}, + {"bt_avrcp_set_scan_mode_changed_cb" , BT_UNIT_TEST_FUNCTION_AVRCP_SET_SCAN_MODE_CHANGED_CB}, + {"bt_avrcp_unset_equalizer_state_changed_cb" , BT_UNIT_TEST_FUNCTION_AVRCP_UNSET_EQUALIZER_STATE_CHANGED_CB}, + {"bt_avrcp_unset_repeat_mode_changed_cb" , BT_UNIT_TEST_FUNCTION_AVRCP_UNSET_REPEAT_MODE_CHANGED_CB}, + {"bt_avrcp_unset_shuffle_mode_changed_cb" , BT_UNIT_TEST_FUNCTION_AVRCP_UNSET_SHUFFLE_MODE_CHANGED_CB}, + {"bt_avrcp_unset_scan_mode_changed_cb" , BT_UNIT_TEST_FUNCTION_AVRCP_UNSET_SCAN_MODE_CHANGED_CB}, + {NULL , 0x0000}, +}; + +tc_table_t tc_hid[] = { + /* HID functions */ + {"BACK" , BT_UNIT_TEST_FUNCTION_BACK}, + {"bt_hid_host_initialize" , BT_UNIT_TEST_FUNCTION_HID_HOST_INITIALIZE}, + {"bt_hid_host_deinitialize" , BT_UNIT_TEST_FUNCTION_HID_HOST_DEINITIALIZE}, + {"bt_hid_host_connect" , BT_UNIT_TEST_FUNCTION_HID_HOST_CONNECT}, + {"bt_hid_host_disconnect" , BT_UNIT_TEST_FUNCTION_HID_HOST_DISCONNECT}, + {NULL , 0x0000}, +}; + +tc_table_t tc_automated_test[] = { + /* Automated test Functions*/ + {"BACK" , BT_UNIT_TEST_FUNCTION_BACK}, + {"On/Off repeat test()" , BT_UNIT_TEST_FUNCTION_ON_OFF_REPEAT_TEST}, + {"On/Off repeat(1sec delay) test()" , BT_UNIT_TEST_FUNCTION_ON_OFF_REPEAT_TEST_1_SEC_DELAY}, + {"On/Off repeat(Nsec delay) test()" , BT_UNIT_TEST_FUNCTION_ON_OFF_REPEAT_TEST_N_SEC_DELAY}, {NULL , 0x0000}, }; void tc_usage_print(void) { int i = 0; + tc_table_t* tc_table = NULL; - while (tc_table[i].tc_name) { - if (tc_table[i].tc_code != 0x00ff) { - TC_PRT("Key %d : usage %s", tc_table[i].tc_code, - tc_table[i].tc_name); - } else { - TC_PRT("Key %d : usage %s\n\n", 0x00ff, - tc_table[i].tc_name); + switch (current_tc_table) { + case BT_UNIT_TEST_TABLE_SET_ADDRESS: + TC_PRT("Key 0 : usage BACK"); + TC_PRT("Input the address of remote device.(e.g., F6:FB:8F:D8:C8:7C)\n\n"); + return; + case BT_UNIT_TEST_TABLE_ADAPTER: + tc_table = tc_adapter; + break; + case BT_UNIT_TEST_TABLE_ADAPTER_LE: + tc_table = tc_adapter_le; + break; + case BT_UNIT_TEST_TABLE_DEVICE: + tc_table = tc_device; + break; + case BT_UNIT_TEST_TABLE_SOCKET: + tc_table = tc_socket; + break; + case BT_UNIT_TEST_TABLE_OPP: + tc_table = tc_opp; + break; + case BT_UNIT_TEST_TABLE_AUDIO: + tc_table = tc_audio; + break; + case BT_UNIT_TEST_TABLE_PAN: + tc_table = tc_pan; + break; + case BT_UNIT_TEST_TABLE_GATT: + tc_table = tc_gatt; + break; + case BT_UNIT_TEST_TABLE_AVRCP: + tc_table = tc_avrcp; + break; + case BT_UNIT_TEST_TABLE_HID: + tc_table = tc_hid; + break; + case BT_UNIT_TEST_TABLE_AUTOMATED_TEST: + if (input_automated_test_delay == true) { + TC_PRT("Input the delay for automated test.(e.g., 10)\n\n"); + return; } + tc_table = tc_automated_test; + break; + case BT_UNIT_TEST_TABLE_MAIN: + default: + tc_table = tc_main; + break; + } + while (tc_table[i].tc_name) { + TC_PRT("Key %d : usage %s", tc_table[i].tc_code, + tc_table[i].tc_name); i++; } + printf("\n\n"); +} + +static const char* __bt_get_error_message(bt_error_e err) +{ + const char* err_str = NULL; + + switch (err) { + case BT_ERROR_NONE: + err_str = "BT_ERROR_NONE"; + break; + case BT_ERROR_CANCELLED: + err_str = "BT_ERROR_CANCELLED"; + break; + case BT_ERROR_INVALID_PARAMETER: + err_str = "BT_ERROR_INVALID_PARAMETER"; + break; + case BT_ERROR_OUT_OF_MEMORY: + err_str = "BT_ERROR_OUT_OF_MEMORY"; + break; + case BT_ERROR_RESOURCE_BUSY: + err_str = "BT_ERROR_RESOURCE_BUSY"; + break; + case BT_ERROR_TIMED_OUT: + err_str = "BT_ERROR_TIMED_OUT"; + break; + case BT_ERROR_NOW_IN_PROGRESS: + err_str = "BT_ERROR_NOW_IN_PROGRESS"; + break; + case BT_ERROR_NOT_INITIALIZED: + err_str = "BT_ERROR_NOT_INITIALIZED"; + break; + case BT_ERROR_NOT_ENABLED: + err_str = "BT_ERROR_NOT_ENABLED"; + break; + case BT_ERROR_ALREADY_DONE: + err_str = "BT_ERROR_ALREADY_DONE"; + break; + case BT_ERROR_OPERATION_FAILED: + err_str = "BT_ERROR_OPERATION_FAILED"; + break; + case BT_ERROR_NOT_IN_PROGRESS: + err_str = "BT_ERROR_NOT_IN_PROGRESS"; + break; + case BT_ERROR_REMOTE_DEVICE_NOT_BONDED: + err_str = "BT_ERROR_REMOTE_DEVICE_NOT_BONDED"; + break; + case BT_ERROR_AUTH_REJECTED: + err_str = "BT_ERROR_AUTH_REJECTED"; + break; + case BT_ERROR_AUTH_FAILED: + err_str = "BT_ERROR_AUTH_FAILED"; + break; + case BT_ERROR_REMOTE_DEVICE_NOT_FOUND: + err_str = "BT_ERROR_REMOTE_DEVICE_NOT_FOUND"; + break; + case BT_ERROR_SERVICE_SEARCH_FAILED: + err_str = "BT_ERROR_SERVICE_SEARCH_FAILED"; + break; + case BT_ERROR_REMOTE_DEVICE_NOT_CONNECTED: + err_str = "BT_ERROR_REMOTE_DEVICE_NOT_CONNECTED"; + break; + case BT_ERROR_PERMISSION_DENIED: + err_str = "BT_ERROR_PERMISSION_DENIED"; + break; + case BT_ERROR_SERVICE_NOT_FOUND: + err_str = "BT_ERROR_SERVICE_NOT_FOUND"; + break; + case BT_ERROR_NOT_SUPPORTED: + err_str = "BT_ERROR_NOT_SUPPORTED"; + break; + default: + err_str = "NOT Defined"; + break; + } + + return err_str; +} + +static gboolean __select_index_cb(GIOChannel *chan, + GIOCondition cond, + gpointer data) +{ + char buf[BUFFER_LEN] = { 0 }; + unsigned int len = 0; + int *index = data; + + memset(buf, 0, sizeof(buf)); + + if (g_io_channel_read_chars(chan, buf, sizeof(buf), + &len, NULL) == G_IO_STATUS_ERROR) { + TC_PRT("IO Channel read error"); + is_sub_index = FALSE; + return FALSE; + } + + *index = atoi(buf); + is_sub_index = FALSE; + + return FALSE; +} + +static void __select_index(void *data) +{ + GIOChannel *key_io; + + is_sub_index = TRUE; + + TC_PRT("Select Index : "); + + key_io = g_io_channel_unix_new(fileno(stdin)); + + g_io_channel_set_encoding(key_io, NULL, NULL); + g_io_channel_set_flags(key_io, G_IO_FLAG_NONBLOCK, NULL); + + g_io_add_watch(key_io, G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL, + __select_index_cb, data); + + g_io_channel_unref(key_io); } static void __bt_free_gatt_services(void) @@ -214,6 +498,57 @@ static void __bt_free_gatt_characteristics_services(void) char_service_index = 0; } +static void __bt_adapter_device_visibility_mode_changed_cb(int result, + bt_adapter_visibility_mode_e visibility_mode, + void *user_data) +{ + TC_PRT("result: %s", __bt_get_error_message(result)); + TC_PRT("visibility_mode: %d", visibility_mode); +} + +static void __bt_adapter_device_visibility_duration_changed_cb(int duration, + void *user_data) +{ + TC_PRT("visibility_duration: %d", duration); +} + +static void __bt_adapter_connectable_changed_cb(int result, + bool connectable, void *user_data) +{ + if (result != BT_ERROR_NONE) { + TC_PRT("connectable change is failed : [0x%04x]", result); + return; + } + + TC_PRT("%s", connectable ? "Connectable" : "Non-connectable"); +} + +static bool __bt_adapter_bonded_device_cb(bt_device_info_s *device_info, void *user_data) +{ + int i; + + TC_PRT("remote_address: %s", device_info->remote_address); + TC_PRT("remote_name: %s", device_info->remote_name); + TC_PRT("service_count: %d", device_info->service_count); + + if (device_info->service_uuid == NULL) { + TC_PRT("No uuids"); + } else { + for (i = 0; i < device_info->service_count; i++) { + TC_PRT("uuid: %s", device_info->service_uuid[i]); + } + } + + if (device_info->manufacturer_data_len > 0) { + TC_PRT("manufacturer specific data(len:%d)", device_info->manufacturer_data_len); + printf("data ["); + for (i = 0; i < device_info->manufacturer_data_len; i++) + printf("%02x ", device_info->manufacturer_data[i]); + printf("]\n"); + } + + return true; +} static void __bt_adapter_device_discovery_state_changed_cb(int result, bt_adapter_device_discovery_state_e discovery_state, @@ -237,11 +572,66 @@ static void __bt_adapter_device_discovery_state_changed_cb(int result, if (discovery_info->service_uuid == NULL) { TC_PRT("No uuids"); + } else { + for (i = 0; i < discovery_info->service_count; i++) { + TC_PRT("uuid: %s", discovery_info->service_uuid[i]); + } + } + + if (discovery_info->manufacturer_data_len > 0) { + TC_PRT("manufacturer specific data(len:%d)", discovery_info->manufacturer_data_len); + printf("data ["); + for (i = 0; i < discovery_info->manufacturer_data_len; i++) + printf("%02x ", discovery_info->manufacturer_data[i]); + printf("]\n"); + } +} + +static void __bt_adapter_le_device_discovery_state_changed_cb(int result, + bt_adapter_le_device_discovery_state_e discovery_state, + bt_adapter_le_device_discovery_info_s *discovery_info, + void *user_data) +{ +// int i; + + if (discovery_info == NULL && discovery_state == BT_ADAPTER_LE_DEVICE_DISCOVERY_FOUND) { + TC_PRT("No discovery_info!"); return; } - for (i = 0; i < discovery_info->service_count; i++) { - TC_PRT("uuid: %s", discovery_info->service_uuid[i]); + if (discovery_state != BT_ADAPTER_LE_DEVICE_DISCOVERY_FOUND) { + TC_PRT("LE discovery %s", discovery_state == BT_ADAPTER_LE_DEVICE_DISCOVERY_STARTED? + "Started" : "Finished"); + } else { + TC_PRT("%s Adv %d Scan resp %d RSSI %d Addr_type %d", discovery_info->remote_address, + discovery_info->adv_data_len, discovery_info->scan_data_len, discovery_info->rssi, + discovery_info->address_type); + + if (discovery_info->adv_data_len > 31 || discovery_info->scan_data_len > 31) { + TC_PRT("###################"); + bt_adapter_le_stop_device_discovery(); + TC_PRT("###################"); + return; + } +#if 0 + /* LE ADV information */ + TC_PRT("appearance: %d", discovery_info->appearance); + if (discovery_info->adv_data_len > 0) + for (i = 0; i < discovery_info->adv_data_len; i++) + TC_PRT("data[%d] : %x", i, discovery_info->adv_data[i]); + if (discovery_info->scan_data_len > 0) + for (i = 0; i < discovery_info->scan_data_len; i++) + TC_PRT("data[%d] : %x", i, discovery_info->scan_data[i]); + + if (discovery_info->service_uuid == NULL) { + TC_PRT("No uuids"); + return; + } + + for (i = 0; i < discovery_info->service_count; i++) { + TC_PRT("uuid: %s", discovery_info->service_uuid[i]); + } +#endif } } @@ -270,7 +660,7 @@ static void __bt_socket_connection_state_changed_cb(int result, bt_socket_connection_s *connection, void *user_data) { - TC_PRT("result: %d", result); + TC_PRT("result: %s", __bt_get_error_message(result)); TC_PRT("connection_state: %d", connection_state); if (connection == NULL) { @@ -279,16 +669,18 @@ static void __bt_socket_connection_state_changed_cb(int result, } TC_PRT("socket fd: %d", connection->socket_fd); + TC_PRT("server socket fd: %d", connection->server_fd); TC_PRT("role: %d", connection->local_role); TC_PRT("remote address: %s", connection->remote_address); TC_PRT("service_uuid: %s", connection->service_uuid); + client_fd = connection->socket_fd; } void __bt_opp_client_push_responded_cb(int result, const char *remote_address, void *user_data) { - TC_PRT("result: %d", result); + TC_PRT("result: %s", __bt_get_error_message(result)); TC_PRT("remote_address: %s", remote_address); } @@ -306,7 +698,7 @@ void __bt_opp_client_push_finished_cb(int result, const char *remote_address, void *user_data) { - TC_PRT("result: %d", result); + TC_PRT("result: %s", __bt_get_error_message(result)); TC_PRT("remote_address: %s", remote_address); } @@ -314,6 +706,7 @@ void __bt_audio_connection_state_changed_cb(int result, bool connected, const char *remote_address, bt_audio_profile_type_e type, void *user_data) { + TC_PRT("result [%s]", __bt_get_error_message(result)); TC_PRT("connected [%d]", connected); TC_PRT("address [%s]", remote_address); TC_PRT("type [%d]", type); @@ -321,6 +714,7 @@ void __bt_audio_connection_state_changed_cb(int result, void __bt_ag_sco_state_changed_cb(int result, bool opened, void *user_data) { + TC_PRT("result [%s]", __bt_get_error_message(result)); TC_PRT("opened [%s]", opened ? "YES" : "NO"); } @@ -330,6 +724,11 @@ void __bt_ag_set_call_handling_event_cb(bt_ag_call_handling_event_e event, TC_PRT("event[%d] call_id[%d]", event, call_id); } +void __bt_ag_set_vendor_cmd_event_cb(char *cmd, void *user_data) +{ + TC_PRT("Vendor command[%s]", cmd); +} + void __bt_device_authorization_changed_cb(bt_device_authorization_e authorization, char *remote_address, void *user_data) { @@ -338,11 +737,13 @@ void __bt_device_authorization_changed_cb(bt_device_authorization_e authorizatio } void __bt_device_connection_state_changed_cb(bool connected, - const char *remote_address, + bt_device_connection_info_s *conn_info, void *user_data) { - TC_PRT("__bt_device_authorization_changed_cb [%d]", connected); - TC_PRT("address: %s", remote_address); + TC_PRT("__bt_device_connection_state_changed_cb [%d]", connected); + TC_PRT("address [%s]", conn_info->remote_address); + TC_PRT("link type [%d]", conn_info->link); + TC_PRT("disconnection reason [%d]", conn_info->disconn_reason); } bool __bt_device_connected_profile(bt_profile_e profile, void *user_data) @@ -351,6 +752,43 @@ bool __bt_device_connected_profile(bt_profile_e profile, void *user_data) return true; } +void __bt_device_bond_created_cb(int result, bt_device_info_s *device_info, void *user_data) +{ + if(result == BT_ERROR_NONE) + { + TC_PRT("Callback: A bond with chat_server is created."); + TC_PRT("Callback: The number of service - %d.", device_info->service_count); + + int i = 0; + for(i=0; iservice_count; i++) { + TC_PRT("Callback: service[%d] - %s", i+1, device_info->service_uuid[i]); + } + TC_PRT("Callback: is_bonded - %d.", device_info->is_bonded); + TC_PRT("Callback: is_connected - %d.", device_info->is_connected); + + if (device_info->manufacturer_data_len > 0) { + TC_PRT("manufacturer specific data(len:%d)", device_info->manufacturer_data_len); + printf("data ["); + for (i = 0; i < device_info->manufacturer_data_len; i++) + printf("%02x ", device_info->manufacturer_data[i]); + printf("]\n"); + } + } else { + TC_PRT("result: %s", __bt_get_error_message(result)); + TC_PRT("Callback: Creating a bond is failed."); + } +} + +void __bt_gatt_connection_state_changed_cb(int result, bool connected, const char *remote_address, void *user_data) +{ + TC_PRT("result: %s", __bt_get_error_message(result)); + if (connected) { + TC_PRT("LE connected"); + } else { + TC_PRT("LE DISconnected"); + } +} + bool __bt_gatt_primary_service_cb(bt_gatt_attribute_h service, void *user_data) { TC_PRT("__bt_gatt_primary_service_cb"); @@ -365,7 +803,7 @@ bool __bt_gatt_primary_service_cb(bt_gatt_attribute_h service, void *user_data) bool __bt_gatt_characteristics_discovered_cb(int result, int index, int total, bt_gatt_attribute_h characteristic, void *user_data) { - TC_PRT("__bt_gatt_characteristics_discovered_cb: %d", result); + TC_PRT("result: %s", __bt_get_error_message(result)); TC_PRT("index %d", index); TC_PRT("total %d", total); TC_PRT("characteristic %s", (char *)characteristic); @@ -412,6 +850,27 @@ void __bt_gatt_characteristic_changed_cb(bt_gatt_attribute_h characteristic, uns return; } +void __bt_gatt_char_write_cb(void *user_data) +{ + TC_PRT("__bt_gatt_char_write_cb"); + return; +} + +void __bt_gatt_char_read_cb(unsigned char *value, int value_length, void *user_data) +{ + int i; + + TC_PRT("__bt_gatt_char_read_cb"); + + TC_PRT("value_length %d", value_length); + + for (i = 0; i < value_length; i++) { + TC_PRT("value %u", value[i]); + } + + return; +} + void __bt_avrcp_target_connection_state_changed_cb(bool connected, const char *remote_address, void *user_data) { TC_PRT("__bt_avrcp_target_connection_state_changed_cb"); @@ -443,707 +902,1082 @@ void __bt_avrcp_scan_mode_changed_cb(bt_avrcp_scan_mode_e scan, void *user_data) TC_PRT("equalizer %d", scan); } -int test_input_callback(void *data) +void panu_conn_state_changed(int result, bool connected, + const char *remote_address, + bt_panu_service_type_e type, + void *user_data) { - int ret = 0; - long test_id = (long)data; + TC_PRT("result [%s]", __bt_get_error_message(result)); + TC_PRT("connected [%d]", connected); + TC_PRT("address [%s]", remote_address); + TC_PRT("type [%d]", type); - switch (test_id) { - case 0x00ff: - TC_PRT("Finished"); - g_main_loop_quit(main_loop); - break; +} - case 1: - ret = bt_initialize(); - if (ret < BT_ERROR_NONE) - TC_PRT("failed with [0x%04x]", ret); - break; - case 2: - ret = bt_deinitialize(); - if (ret < BT_ERROR_NONE) - TC_PRT("failed with [0x%04x]", ret); - break; - case 3: { - bt_adapter_state_e state = BT_ADAPTER_DISABLED; +void __bt_hid_host_connection_state_changed_cb(int result, + bool connected, const char *remote_address, void *user_data) +{ + TC_PRT("__bt_hid_host_connection_state_changed_cb: called"); + TC_PRT("result: %s", __bt_get_error_message(result)); +} - ret = bt_adapter_get_state(&state); - if (ret < BT_ERROR_NONE) - TC_PRT("failed with [0x%04x]", ret); +char * get_bd_from_file(char *filename) +{ + int fd; + char *buf; - TC_PRT("state: %d", state); - break; + if ((fd = open(filename, O_RDONLY)) < 0) { + perror("Can't open file"); + return NULL; } - case 4: - ret = bt_adapter_enable(); - if (ret < BT_ERROR_NONE) - TC_PRT("failed with [0x%04x]", ret); - break; - case 5: - ret = bt_adapter_disable(); - if (ret < BT_ERROR_NONE) - TC_PRT("failed with [0x%04x]", ret); - break; - case 6: - ret = bt_adapter_start_device_discovery(); - if (ret < BT_ERROR_NONE) - TC_PRT("failed with [0x%04x]", ret); - break; - case 7: - ret = bt_adapter_stop_device_discovery(); - if (ret < BT_ERROR_NONE) - TC_PRT("failed with [0x%04x]", ret); - break; - case 8: { - bool is_discovering = FALSE; - ret = bt_adapter_is_discovering(&is_discovering); - if (ret < BT_ERROR_NONE) - TC_PRT("failed with [0x%04x]", ret); - else - TC_PRT("is_discovering: %d", is_discovering); - break; + buf = g_malloc0(20); + + if (read(fd, buf, 17) < 17) { + perror("read failed"); + g_free(buf); + close(fd); + return NULL; } - case 9: { - char *address; - bt_device_info_s *device_info = NULL; - address = g_strdup("00:19:0E:01:61:17"); + close(fd); - ret = bt_adapter_get_bonded_device_info((const char *)address, - &device_info); - if (ret < BT_ERROR_NONE) - TC_PRT("failed with [0x%04x]", ret); + return buf; +} - g_free(address); +void __bt_repeat_test_adapter_state_changed_cb(int result, bt_adapter_state_e adapter_state, void *user_data) +{ + unsigned int delay = *(unsigned int*)user_data; - if (device_info) { - TC_PRT("address: %s", device_info->remote_address); - TC_PRT("name: %s", device_info->remote_name); - } + TC_PRT("__bt_repeat_test_adapter_state_changed_cb"); + TC_PRT("result: %s", __bt_get_error_message(result)); + TC_PRT("state: %s, delay(%dsec)\n", (adapter_state == BT_ADAPTER_ENABLED)? "ENABLED" : "DISABLED", delay); - bt_adapter_free_device_info(device_info); - break; - } - case 10: { - bool used = FALSE; + if (result != BT_ERROR_NONE) { + char *argv[] = {NULL}; - ret = bt_adapter_is_service_used(opp_uuid, &used); - if (ret < BT_ERROR_NONE) - TC_PRT("failed with [0x%04x]", ret); + execv("all_log_dump.sh", argv); + return; + } else { + if (delay) + sleep(delay); - TC_PRT("used: %d", used); - break; + if (adapter_state == BT_ADAPTER_DISABLED) { + bt_adapter_enable(); + } else { + bt_adapter_disable(); + } } - case 11: { - bt_adapter_visibility_mode_e visibility_mode = BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE; - int time = 0; - - ret = bt_adapter_get_visibility(&visibility_mode, &time); - if (ret < BT_ERROR_NONE) - TC_PRT("failed with [0x%04x]", ret); +} - TC_PRT("mode: %d", visibility_mode); - TC_PRT("time: %d", time); - break; - } - case 12: - ret = bt_adapter_set_device_discovery_state_changed_cb(__bt_adapter_device_discovery_state_changed_cb, NULL); - if (ret < BT_ERROR_NONE) - TC_PRT("failed with [0x%04x]", ret); - break; - case 13: - ret = bt_adapter_unset_device_discovery_state_changed_cb(); - if (ret < BT_ERROR_NONE) - TC_PRT("failed with [0x%04x]", ret); - break; +int test_input_callback(void *data) +{ + int ret = 0; + int test_id = (int)data; - /* Socket functions */ - case 50: { - int socket_fd = 0; + switch (current_tc_table) { + case BT_UNIT_TEST_TABLE_MAIN: { + switch (test_id) { + case 0x00ff: + TC_PRT("Finished"); + g_main_loop_quit(main_loop); + break; - ret = bt_socket_create_rfcomm(spp_uuid, &socket_fd); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); - } else { - TC_PRT("socket_fd: %d", socket_fd); - server_fd = socket_fd; + case BT_UNIT_TEST_FUNCTION_INITIALIZE: + ret = bt_initialize(); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + case BT_UNIT_TEST_FUNCTION_DEINITIALIZE: + ret = bt_deinitialize(); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + default: + break; } + break; } - case 51: - ret = bt_socket_destroy_rfcomm(server_fd); - if (ret < BT_ERROR_NONE) - TC_PRT("failed with [0x%04x]", ret); - break; - case 52: - ret = bt_socket_listen_and_accept_rfcomm(server_fd, 1); - if (ret < BT_ERROR_NONE) - TC_PRT("failed with [0x%04x]", ret); - break; - case 53: - ret = bt_socket_listen(server_fd, 1); - if (ret < BT_ERROR_NONE) - TC_PRT("failed with [0x%04x]", ret); - break; - case 54: { - int socket_fd = 0; + case BT_UNIT_TEST_TABLE_ADAPTER: { + switch (test_id) { + case BT_UNIT_TEST_FUNCTION_ADAPTER_GET_STATE: { + bt_adapter_state_e state = BT_ADAPTER_DISABLED; + + ret = bt_adapter_get_state(&state); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + TC_PRT("state: %d", state); + break; + } + case BT_UNIT_TEST_FUNCTION_ADAPTER_ENABLE: + ret = bt_adapter_enable(); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + case BT_UNIT_TEST_FUNCTION_ADAPTER_DISABLE: + ret = bt_adapter_disable(); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + case BT_UNIT_TEST_FUNCTION_ADAPTER_RECOVER: + ret = bt_adapter_recover(); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + case BT_UNIT_TEST_FUNCTION_ADAPTER_START_DEVICE_DISCOVERY: + ret = bt_adapter_start_device_discovery(); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + case BT_UNIT_TEST_FUNCTION_ADAPTER_STOP_DEVICE_DISCOVERY: + ret = bt_adapter_stop_device_discovery(); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + case BT_UNIT_TEST_FUNCTION_ADAPTER_IS_DISCOVERING: { + bool is_discovering = FALSE; + ret = bt_adapter_is_discovering(&is_discovering); + if (ret < BT_ERROR_NONE) + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + else + TC_PRT("is_discovering: %d", is_discovering); + + break; + } + case BT_UNIT_TEST_FUNCTION_ADAPTER_FOREACH_BONDED_DEVICE: { + ret = bt_adapter_foreach_bonded_device(__bt_adapter_bonded_device_cb, NULL); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + } + case BT_UNIT_TEST_FUNCTION_ADAPTER_GET_BONDED_DEVICE_INFO: { + bt_device_info_s *device_info = NULL; + + ret = bt_adapter_get_bonded_device_info(remote_addr, + &device_info); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + + if (device_info) { + TC_PRT("address: %s", device_info->remote_address); + TC_PRT("name: %s", device_info->remote_name); + } - ret = bt_socket_accept(server_fd); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); - } else { - TC_PRT("socket_fd: %d", socket_fd); - client_fd = socket_fd; + bt_adapter_free_device_info(device_info); + break; + } + case BT_UNIT_TEST_FUNCTION_ADAPTER_IS_SERVICE_USED: { + bool used = FALSE; + + ret = bt_adapter_is_service_used(opp_uuid, &used); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + TC_PRT("used: %d", used); + break; + } + case BT_UNIT_TEST_FUNCTION_ADAPTER_GET_VISIBILITY: { + bt_adapter_visibility_mode_e visibility_mode = BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE; + int time = 0; + + ret = bt_adapter_get_visibility(&visibility_mode, &time); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + TC_PRT("mode: %d", visibility_mode); + TC_PRT("time: %d", time); + break; + } + case BT_UNIT_TEST_FUNCTION_ADAPTER_SET_DEVICE_DISCOVERY_STATE_CHANGED_CB: + ret = bt_adapter_set_device_discovery_state_changed_cb(__bt_adapter_device_discovery_state_changed_cb, NULL); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + case BT_UNIT_TEST_FUNCTION_ADAPTER_UNSET_DEVICE_DISCOVERY_STATE_CHANGED_CB: + ret = bt_adapter_unset_device_discovery_state_changed_cb(); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + + case BT_UNIT_TEST_FUNCTION_ADAPTER_GET_LOCAL_OOB_DATA: { + ret = bt_adapter_get_local_oob_data(&hash, &randomizer, &hash_len, &rand_len); + if (ret < BT_ERROR_NONE) { + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + } else { + TC_PRT("hash = [%s]", hash); + TC_PRT("randomizer = [%s]", randomizer); + } + break; } - break; - } - case 55: - ret = bt_socket_reject(server_fd); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); + + case BT_UNIT_TEST_FUNCTION_ADAPTER_SET_LOCAL_OOB_DATA: { + ret = bt_adapter_set_remote_oob_data(remote_addr, hash, randomizer, hash_len, rand_len); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + } + + case BT_UNIT_TEST_FUNCTION_ADAPTER_REMOVE_REMOTE_OOB_DATA: { + ret = bt_adapter_remove_remote_oob_data(remote_addr); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; } - break; - case 56: { - char *address; - address = g_strdup("00:02:48:F4:3E:D2"); + case BT_UNIT_TEST_FUNCTION_ADAPTER_SET_VISIBILITY_MODE_CHANGED_CB: + ret = bt_adapter_set_visibility_mode_changed_cb(__bt_adapter_device_visibility_mode_changed_cb, NULL); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + case BT_UNIT_TEST_FUNCTION_ADAPTER_UNSET_VISIBILITY_MODE_CHANGED_CB: + ret = bt_adapter_unset_visibility_mode_changed_cb(); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; - ret = bt_socket_connect_rfcomm(address, spp_uuid); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); + case BT_UNIT_TEST_FUNCTION_ADAPTER_SET_VISIBILITY_DURATION_CHANGED_CB: + ret = bt_adapter_set_visibility_duration_changed_cb( + __bt_adapter_device_visibility_duration_changed_cb, NULL); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + case BT_UNIT_TEST_FUNCTION_ADAPTER_UNSET_VISIBILITY_DURATION_CHANGED_CB: + ret = bt_adapter_unset_visibility_duration_changed_cb(); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + + case BT_UNIT_TEST_FUNCTION_ADAPTER_SET_CONNECTABLE_CHANGED_CB: { + ret = bt_adapter_set_connectable_changed_cb(__bt_adapter_connectable_changed_cb, NULL); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; } - g_free(address); - break; - } - case 57: - ret = bt_socket_disconnect_rfcomm(client_fd); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); + case BT_UNIT_TEST_FUNCTION_ADAPTER_UNSET_CONNECTABLE_CHANGED_CB: { + ret = bt_adapter_unset_connectable_changed_cb(); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; } - break; - case 58: - ret = bt_socket_send_data(client_fd, "Sending test\0", 20); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); + + case BT_UNIT_TEST_FUNCTION_ADAPTER_GET_CONNECTABLE: { + bool connectable = false; + + ret = bt_adapter_get_connectable(&connectable); + if (ret < BT_ERROR_NONE) { + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + } + + TC_PRT("%s", connectable ? "Connectable" : "Non-connectable"); + break; } - break; - case 59: - ret = bt_socket_set_data_received_cb(__bt_socket_data_received_cb, NULL); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); + + case BT_UNIT_TEST_FUNCTION_ADAPTER_SET_CONNECTABLE: { + bool connectable = false; + + bt_adapter_get_connectable(&connectable); + + ret = bt_adapter_set_connectable(!connectable); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; } - break; - case 60: - ret = bt_socket_unset_data_received_cb(); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); + + case BT_UNIT_TEST_FUNCTION_ADAPTER_GET_VERSION: { + char *version = NULL; + + ret = bt_adapter_get_version(&version); + if (ret < BT_ERROR_NONE) + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + else { + TC_PRT("Version: [%s]",version); + g_free(version); + } + break; + } + + case BT_UNIT_TEST_FUNCTION_ADAPTER_GET_LOCAL_INFO: { + char *chipset = NULL; + char *firmware = NULL; + char *stack_version = NULL; + char *profiles = NULL; + + ret = bt_adapter_get_local_info(&chipset, &firmware, &stack_version, &profiles); + if (ret < BT_ERROR_NONE) + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + else { + TC_PRT("Local info: [%s, %s, %s]", chipset, firmware, stack_version); + TC_PRT("Local info(Profiles):\n%s", profiles); + g_free(chipset); + g_free(firmware); + g_free(stack_version); + g_free(profiles); + } + break; } - break; - case 61: - ret = bt_socket_set_connection_requested_cb(__bt_socket_connection_requested_cb, NULL); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); + + default: + break; } + break; - case 62: - ret = bt_socket_unset_connection_requested_cb(); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); + } + + case BT_UNIT_TEST_TABLE_ADAPTER_LE: { + switch (test_id) { + case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_GET_STATE: { + bt_adapter_le_state_e le_state = BT_ADAPTER_LE_DISABLED; + + ret = bt_adapter_le_get_state(&le_state); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + TC_PRT("le_state: %d", le_state); + break; } - break; - case 63: - ret = bt_socket_set_connection_state_changed_cb(__bt_socket_connection_state_changed_cb, NULL); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); + + case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_ENABLE: { + ret = bt_adapter_le_enable(); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; } - break; - case 64: - ret = bt_socket_unset_connection_state_changed_cb(); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); + + case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_DISABLE: { + ret = bt_adapter_le_disable(); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; } - break; - case 70: - ret = bt_opp_client_initialize(); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); + + case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_START_DEVICE_DISCOVERY: + ret = bt_adapter_le_start_device_discovery(); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + + case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_STOP_DEVICE_DISCOVERY: + ret = bt_adapter_le_stop_device_discovery(); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + + case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_ADD_WHITE_LIST: { + ret = bt_adapter_le_add_white_list(remote_addr, BT_DEVICE_PUBLIC_ADDRESS); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; } - break; - case 71: - ret = bt_opp_client_deinitialize(); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); + + case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_REMOVE_WHITE_LIST: { + ret = bt_adapter_le_remove_white_list(remote_addr, BT_DEVICE_PUBLIC_ADDRESS); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; } - break; - case 72: - ret = bt_opp_client_add_file("/opt/media/Images/image1.jpg"); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); + + case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_CLEAR_WHITE_LIST: { + ret = bt_adapter_le_clear_white_list(); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; } - break; - case 73: - ret = bt_opp_client_clear_files(); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); + + case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_ENABLE_PRIVACY: { + static bool enable_privacy = false; + + if (enable_privacy == false) + enable_privacy = true; + else + enable_privacy = false; + + ret = bt_adapter_le_enable_privacy(enable_privacy); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; } - break; - case 74: { - char *address; - address = g_strdup("00:02:37:A9:17:9E"); + case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_SET_DEVICE_DISCOVERY_STATE_CHANGED_CB: + ret = bt_adapter_le_set_device_discovery_state_changed_cb(__bt_adapter_le_device_discovery_state_changed_cb, NULL); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + + case BT_UNIT_TEST_FUNCTION_ADAPTER_LE_UNSET_DEVICE_DISCOVERY_STATE_CHANGED_CB: + ret = bt_adapter_le_unset_device_discovery_state_changed_cb(); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; - ret = bt_opp_client_push_files(address,__bt_opp_client_push_responded_cb, - __bt_opp_client_push_progress_cb, - __bt_opp_client_push_finished_cb, - NULL); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); + default: + break; } + break; } - case 75: - ret = bt_opp_client_cancel_push(); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); + + case BT_UNIT_TEST_TABLE_DEVICE: { + switch (test_id) { + case BT_UNIT_TEST_FUNCTION_DEVICE_SET_AUTHORIZATION_TRUE: { + ret = bt_device_set_authorization(remote_addr, BT_DEVICE_AUTHORIZED); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + } + case BT_UNIT_TEST_FUNCTION_DEVICE_SET_AUTHORIZATION_FALSE: { + ret = bt_device_set_authorization(remote_addr, BT_DEVICE_UNAUTHORIZED); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + } + case BT_UNIT_TEST_FUNCTION_DEVICE_SET_AUTHORIZATION_CHANGED_CB: + ret = bt_device_set_authorization_changed_cb(__bt_device_authorization_changed_cb, NULL); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + + case BT_UNIT_TEST_FUNCTION_DEVICE_UNSET_AUTHORIZATION_CHANGED_CB: + ret = bt_device_unset_authorization_changed_cb(); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + + case BT_UNIT_TEST_FUNCTION_DEVICE_SET_CONNECTION_STAET_CHANGED_CB: + ret = bt_device_set_connection_state_changed_cb(__bt_device_connection_state_changed_cb, NULL); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + + case BT_UNIT_TEST_FUNCTION_DEVICE_UNSET_CONNECTION_STAET_CHANGED_CB: + ret = bt_device_unset_connection_state_changed_cb(); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + + case BT_UNIT_TEST_FUNCTION_DEVICE_FOREACH_CONNECTED_PROFILES: { + ret = bt_device_foreach_connected_profiles(remote_addr, __bt_device_connected_profile, NULL); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + } + + case BT_UNIT_TEST_FUNCTION_DEVICE_IS_PROFILE_CONNECTED: { + bool connected_status = false; + + ret = bt_device_is_profile_connected(remote_addr, BT_PROFILE_HSP, &connected_status); + if (ret < BT_ERROR_NONE) { + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + } + TC_PRT("Profile [%s]", connected_status ? "Connected" : "Disconnected"); + break; } - break; - case 80: - ret = bt_audio_initialize(); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); + case BT_UNIT_TEST_FUNCTION_DEVICE_SET_BOND_CREATED_CB : { + ret = bt_device_set_bond_created_cb(__bt_device_bond_created_cb, NULL); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; } - break; - case 81: - ret = bt_audio_deinitialize(); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); + + case BT_UNIT_TEST_FUNCTION_DEVICE_CREATE_BOND : { + ret = bt_device_create_bond(remote_addr); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; } - break; - case 82: { - char *address; - address = g_strdup("11:11:22:33:33:33"); - ret = bt_audio_connect(address, BT_AUDIO_PROFILE_TYPE_HSP_HFP); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); + case BT_UNIT_TEST_FUNCTION_DEVICE_CREATE_BOND_BY_TYPE : { + ret = bt_device_create_bond_by_type(remote_addr, BT_DEVICE_CONNECTION_LINK_LE); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; } - break; - } - case 83: { - char *address; - address = g_strdup("11:11:22:33:33:33"); - ret = bt_audio_disconnect(address, BT_AUDIO_PROFILE_TYPE_HSP_HFP); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); + default: + break; } + break; } - case 84: - ret = bt_audio_set_connection_state_changed_cb( - __bt_audio_connection_state_changed_cb, NULL); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); - } - break; - case 85: - ret = bt_audio_unset_connection_state_changed_cb(); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); - } - break; - case 86: - ret = bt_ag_open_sco(); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); - } - break; - case 87: - ret = bt_ag_close_sco(); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); - } - break; - case 88: { - bool opened = false; - ret = bt_ag_is_sco_opened(&opened); - TC_PRT("opend[%s]", opened ? "YES" : "NO"); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); + case BT_UNIT_TEST_TABLE_SOCKET: { + switch (test_id) { + case BT_UNIT_TEST_FUNCTION_SOCKET_CREATE_RFCOMM: { + int socket_fd = 0; + + ret = bt_socket_create_rfcomm(spp_uuid, &socket_fd); + if (ret < BT_ERROR_NONE) { + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + } else { + TC_PRT("socket_fd: %d", socket_fd); + server_fd = socket_fd; + } + break; + } + case BT_UNIT_TEST_FUNCTION_SOCKET_DESTROY_RFCOMM: + ret = bt_socket_destroy_rfcomm(server_fd); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + case BT_UNIT_TEST_FUNCTION_SOCKET_LISTEN_AND_ACCEPT_RFCOMM: + ret = bt_socket_listen_and_accept_rfcomm(server_fd, 1); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + case BT_UNIT_TEST_FUNCTION_SOCKET_LISTEN: + ret = bt_socket_listen(server_fd, 1); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + case BT_UNIT_TEST_FUNCTION_SOCKET_ACCEPT: { + int socket_fd = 0; + + ret = bt_socket_accept(server_fd); + if (ret < BT_ERROR_NONE) { + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + } else { + TC_PRT("socket_fd: %d", socket_fd); + client_fd = socket_fd; + } + break; + } + case BT_UNIT_TEST_FUNCTION_SOCKET_REJECT: + ret = bt_socket_reject(server_fd); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + case BT_UNIT_TEST_FUNCTION_SOCKET_CONNECT_RFCOMM: { + ret = bt_socket_connect_rfcomm(remote_addr, spp_uuid); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + } + case BT_UNIT_TEST_FUNCTION_SOCKET_DISCONNECT_RFCOMM: + ret = bt_socket_disconnect_rfcomm(client_fd); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + case BT_UNIT_TEST_FUNCTION_SOCKET_SEND_DATA: { + char data[] = "Sending test"; + ret = bt_socket_send_data(client_fd, data, sizeof(data)); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + } + case BT_UNIT_TEST_FUNCTION_SOCKET_SET_DATA_RECEIVED_CB: + ret = bt_socket_set_data_received_cb(__bt_socket_data_received_cb, NULL); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + case BT_UNIT_TEST_FUNCTION_SOCKET_UNSET_DATA_RECEIVED_CB: + ret = bt_socket_unset_data_received_cb(); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + case BT_UNIT_TEST_FUNCTION_SOCKET_SET_CONNECTION_REQUESTED_CB: + ret = bt_socket_set_connection_requested_cb(__bt_socket_connection_requested_cb, NULL); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + case BT_UNIT_TEST_FUNCTION_SOCKET_UNSET_CONNECTION_REQUESTED_CB: + ret = bt_socket_unset_connection_requested_cb(); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + case BT_UNIT_TEST_FUNCTION_SOCKET_SET_CONNECTION_STATE_CHANGED_CB: + ret = bt_socket_set_connection_state_changed_cb(__bt_socket_connection_state_changed_cb, NULL); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + case BT_UNIT_TEST_FUNCTION_SOCKET_UNSET_CONNECTION_STATE_CHANGED_CB: + ret = bt_socket_unset_connection_state_changed_cb(); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + default: + break; } + break; } - case 89: - ret = bt_ag_set_sco_state_changed_cb(__bt_ag_sco_state_changed_cb, NULL); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); - } - break; - case 90: - ret = bt_ag_unset_sco_state_changed_cb(); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); + case BT_UNIT_TEST_TABLE_OPP: { + switch (test_id) { + case BT_UNIT_TEST_FUNCTION_OPP_CLIENT_INITIALIZE: + ret = bt_opp_client_initialize(); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + case BT_UNIT_TEST_FUNCTION_OPP_CLIENT_DEINITIALIZE: + ret = bt_opp_client_deinitialize(); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + case BT_UNIT_TEST_FUNCTION_OPP_CLIENT_ADD_FILE: + ret = bt_opp_client_add_file("/opt/media/Images/image1.jpg"); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + case BT_UNIT_TEST_FUNCTION_OPP_CLIENT_CLEAR_FILES: + ret = bt_opp_client_clear_files(); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + case BT_UNIT_TEST_FUNCTION_OPP_CLIENT_PUSH_FILES: { + ret = bt_opp_client_push_files(remote_addr,__bt_opp_client_push_responded_cb, + __bt_opp_client_push_progress_cb, + __bt_opp_client_push_finished_cb, + NULL); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + } + case BT_UNIT_TEST_FUNCTION_OPP_CLIENT_CANCEL_PUSH: + ret = bt_opp_client_cancel_push(); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + default: + break; } - break; - case 91: { - unsigned int call_id = 1; - ret = bt_ag_notify_call_event(BT_AG_CALL_EVENT_IDLE, call_id, NULL); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); - } break; } - case 92: { - unsigned int call_id = 1; - bool sco_required = true; - - ret = bt_ag_notify_call_event(BT_AG_CALL_EVENT_ANSWERED, call_id, NULL); - if (sco_required) - bt_ag_open_sco(); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); + case BT_UNIT_TEST_TABLE_AUDIO: { + switch (test_id) { + case BT_UNIT_TEST_FUNCTION_AUDIO_INITIALIZE: + ret = bt_audio_initialize(); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + case BT_UNIT_TEST_FUNCTION_AUDIO_DEINITIALIZE: + ret = bt_audio_deinitialize(); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + case BT_UNIT_TEST_FUNCTION_AUDIO_CONNECT: { + ret = bt_audio_connect(remote_addr, BT_AUDIO_PROFILE_TYPE_HSP_HFP); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + } + case BT_UNIT_TEST_FUNCTION_AUDIO_DISCONNECT: { + ret = bt_audio_disconnect(remote_addr, BT_AUDIO_PROFILE_TYPE_HSP_HFP); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + } + case BT_UNIT_TEST_FUNCTION_AUDIO_SET_CONNECTION_STATE_CHANGED_CB: + ret = bt_audio_set_connection_state_changed_cb( + __bt_audio_connection_state_changed_cb, NULL); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + case BT_UNIT_TEST_FUNCTION_AUDIO_UNSET_CONNECTION_STATE_CHANGED_CB: + ret = bt_audio_unset_connection_state_changed_cb(); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + case BT_UNIT_TEST_FUNCTION_AG_OPEN_SCO: + ret = bt_ag_open_sco(); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + case BT_UNIT_TEST_FUNCTION_AG_CLOSE_SCO: + ret = bt_ag_close_sco(); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + case BT_UNIT_TEST_FUNCTION_AG_IS_SCO_OPENED: { + bool opened = false; + ret = bt_ag_is_sco_opened(&opened); + TC_PRT("opend[%s]", opened ? "YES" : "NO"); + if (ret < BT_ERROR_NONE) { + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + } + break; + } + case BT_UNIT_TEST_FUNCTION_AG_SET_SCO_STATE_CHANGED_CB: + ret = bt_ag_set_sco_state_changed_cb(__bt_ag_sco_state_changed_cb, NULL); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + case BT_UNIT_TEST_FUNCTION_AG_UNSET_SCO_STATE_CHANGED_CB: + ret = bt_ag_unset_sco_state_changed_cb(); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + case BT_UNIT_TEST_FUNCTION_AG_CALL_EVENT_IDLE: { + unsigned int call_id = 1; + + ret = bt_ag_notify_call_event(BT_AG_CALL_EVENT_IDLE, call_id, NULL); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + } + case BT_UNIT_TEST_FUNCTION_AG_CALL_EVENT_ANSWERED: { + unsigned int call_id = 1; + bool sco_required = true; + + ret = bt_ag_notify_call_event(BT_AG_CALL_EVENT_ANSWERED, call_id, NULL); + if (sco_required) + bt_ag_open_sco(); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + } + case BT_UNIT_TEST_FUNCTION_AG_CALL_EVENT_DIALING: { + unsigned int call_id = 1; + bool sco_required = TRUE; + char *phone_number; + + phone_number = g_strdup("01012345678"); + ret = bt_ag_notify_call_event(BT_AG_CALL_EVENT_DIALING, + call_id, (const char*)phone_number); + if (sco_required) + bt_ag_open_sco(); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + g_free(phone_number); + break; + } + case BT_UNIT_TEST_FUNCTION_AG_CALL_EVENT_ALERTING: { + unsigned int call_id = 1; + + ret = bt_ag_notify_call_event(BT_AG_CALL_EVENT_ALERTING, + call_id, NULL); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + } + case BT_UNIT_TEST_FUNCTION_AG_CALL_EVENT_INCOMING: { + unsigned int call_id = 1; + char *phone_number; + + phone_number = g_strdup("01012345678"); + ret = bt_ag_notify_call_event(BT_AG_CALL_EVENT_INCOMING, + call_id, (const char*)phone_number); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + g_free(phone_number); + break; + } + case BT_UNIT_TEST_FUNCTION_CALL_LIST_CREATE: + ret = bt_call_list_create(&call_list); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + case BT_UNIT_TEST_FUNCTION_CALL_LIST_DESTROY: + ret = bt_call_list_destroy(call_list); + call_list = NULL; + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + case BT_UNIT_TEST_FUNCTION_CALL_LIST_RESET: + ret = bt_call_list_reset(call_list); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + case BT_UNIT_TEST_FUNCTION_CALL_LIST_ADD: { + char *phone_number; + + phone_number = g_strdup("01012345678"); + ret = bt_call_list_add(call_list, 1, BT_AG_CALL_STATE_ACTIVE, + (const char*)phone_number); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + g_free(phone_number); + break; + } + case BT_UNIT_TEST_FUNCTION_AG_NOTIFY_CALL_LIST: + ret = bt_ag_notify_call_list(call_list); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + case BT_UNIT_TEST_FUNCTION_AG_SET_CALL_HANDLING_EVENT_CB: + ret = bt_ag_set_call_handling_event_cb( + __bt_ag_set_call_handling_event_cb, NULL); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + case BT_UNIT_TEST_FUNCTION_AG_IS_NREC_ENABLED: { + bool enabled = false; + ret = bt_ag_is_nrec_enabled(&enabled); + TC_PRT("opend[%s]", enabled ? "YES" : "NO"); + if (ret < BT_ERROR_NONE) { + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + } + break; } - break; - } - case 93: { - unsigned int call_id = 1; - bool sco_required = TRUE; - const char *phone_number; - - phone_number = g_strdup("01046500173"); - ret = bt_ag_notify_call_event(BT_AG_CALL_EVENT_DIALING, - call_id, phone_number); - if (sco_required) - bt_ag_open_sco(); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); + default: + break; } - break; - } - case 94: { - unsigned int call_id = 1; - ret = bt_ag_notify_call_event(BT_AG_CALL_EVENT_ALERTING, - call_id, NULL); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); - } break; } - case 95: { - unsigned int call_id = 1; - const char *phone_number; + case BT_UNIT_TEST_TABLE_PAN: { + switch (test_id) { + case BT_UNIT_TEST_FUNCTION_NAP_ACTIVATE: + ret = bt_nap_activate(); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; - phone_number = g_strdup("01046500173"); - ret = bt_ag_notify_call_event(BT_AG_CALL_EVENT_INCOMING, - call_id, phone_number); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); - } - break; - } - case 96: - ret = bt_call_list_create(&call_list); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); - } - break; - case 97: - ret = bt_call_list_destroy(call_list); - call_list = NULL; - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); - } - break; - case 98: - ret = bt_call_list_reset(call_list); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); - } - break; - case 99: { - const char *phone_number; - phone_number = g_strdup("01012345678"); - ret = bt_call_list_add(call_list, 1, BT_AG_CALL_STATE_ACTIVE, phone_number); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); + case BT_UNIT_TEST_FUNCTION_NAP_DEACTIVATE: + ret = bt_nap_deactivate(); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + + case BT_UNIT_TEST_FUNCTION_NAP_DISCONNECT_ALL: + ret = bt_nap_disconnect_all(); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + + case BT_UNIT_TEST_FUNCTION_NAP_DISCONNECT: { + ret = bt_nap_disconnect(remote_addr); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; } - break; - } - case 100: - ret = bt_ag_notify_call_list(call_list); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); + + case BT_UNIT_TEST_FUNCTION_PANU_SET_CONNECTION_STATE_CHANGED_CB: { + ret = bt_panu_set_connection_state_changed_cb(panu_conn_state_changed, + NULL); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; } - break; - case 101: - ret = bt_ag_set_call_handling_event_cb( - __bt_ag_set_call_handling_event_cb, NULL); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); + case BT_UNIT_TEST_FUNCTION_PANU_CONNECT: { + ret = bt_panu_connect(remote_addr, BT_PANU_SERVICE_TYPE_NAP); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; } - break; - case 102: { - bool enabled = false; - ret = bt_ag_is_nrec_enabled(&enabled); - TC_PRT("opend[%s]", enabled ? "YES" : "NO"); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); + default: + break; } + break; } - case 110: - ret = bt_nap_activate(); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); - } - break; + case BT_UNIT_TEST_TABLE_GATT: { + switch (test_id) { + case BT_UNIT_TEST_FUNCTION_GATT_FOREACH_PRIMARY_SERVICES: { + __bt_free_gatt_services(); - case 111: - ret = bt_nap_deactivate(); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); + ret = bt_gatt_foreach_primary_services(remote_addr, __bt_gatt_primary_service_cb, NULL); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + if (ret == BT_ERROR_NONE) + __select_index(&selected_service_index); + break; } - break; - case 112: - ret = bt_nap_disconnect_all(); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); + case BT_UNIT_TEST_FUNCTION_GATT_DISCOVER_CHARACTERISTICS: { + __bt_free_gatt_characteristics(); + + if (selected_service_index < 0) { + TC_PRT("Need to select primary service \n"); + break; + } + + ret = bt_gatt_discover_characteristics(service_clone[selected_service_index], __bt_gatt_characteristics_discovered_cb, NULL); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + if (ret == BT_ERROR_NONE) + __select_index(&selected_char_index); + break; } - break; - case 120: { - char *address; + case BT_UNIT_TEST_FUNCTION_GATT_GET_SERVICE_UUID: { + char *uuid = NULL; - address = g_strdup("00:1B:66:01:23:1C"); + if (selected_service_index < 0) { + TC_PRT("Need to select primary service \n"); + break; + } - ret = bt_device_set_authorization(address, BT_DEVICE_AUTHORIZED); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); + ret = bt_gatt_get_service_uuid(service_clone[selected_service_index], &uuid); + if (ret < BT_ERROR_NONE) { + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + } else { + TC_PRT("uuid: %s", uuid); + g_free(uuid); + } + break; } - break; - } - case 121: { - char *address; - address = g_strdup("00:1B:66:01:23:1C"); + case BT_UNIT_TEST_FUNCTION_GATT_FOREACH_INCLUDED_SERVICES: { + __bt_free_gatt_characteristics_services(); - ret = bt_device_set_authorization(address, BT_DEVICE_UNAUTHORIZED); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); - } - break; - } - case 122: - ret = bt_device_set_authorization_changed_cb(__bt_device_authorization_changed_cb, NULL); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); - } - break; + if (selected_service_index < 0) { + TC_PRT("Need to select primary service \n"); + break; + } - case 123: - ret = bt_device_unset_authorization_changed_cb(); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); + ret = bt_gatt_foreach_included_services(service_clone[selected_service_index], __bt_gatt_included_service_cb, NULL); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; } - break; - case 124: -#if 0 - ret = bt_device_set_connection_state_changed_cb(__bt_device_connection_state_changed_cb, NULL); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); - } - break; -#endif - case 125: - ret = bt_device_unset_connection_state_changed_cb(); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); + case BT_UNIT_TEST_FUNCTION_GATT_SET_CHARACTERISTIC_CHANGED_CB: { + ret = bt_gatt_set_characteristic_changed_cb(__bt_gatt_characteristic_changed_cb, NULL); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; } - break; - - case 126: { - char *address; - address = g_strdup("00:1B:66:01:23:1C"); - - ret = bt_device_foreach_connected_profiles(address, __bt_device_connected_profile, NULL); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); + case BT_UNIT_TEST_FUNCTION_GATT_UNSET_CHARACTERISTIC_CHANGED_CB: { + ret = bt_gatt_unset_characteristic_changed_cb(); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; } - break; - } - case 140: { - char *address; + case BT_UNIT_TEST_FUNCTION_GATT_GET_CHARACTERISTIC_DECLARATION: { + int i; + char *uuid = NULL; + unsigned char *value = NULL; + int value_length = 0; - address = g_strdup("D5:FE:81:38:39:B9"); + ret = bt_gatt_get_characteristic_declaration(characteristics_services[0], &uuid, &value, &value_length); + if (ret < BT_ERROR_NONE) { + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + } else { + TC_PRT("uuid: %s", uuid); - __bt_free_gatt_services(); + for (i = 0; i < value_length; i++) { + TC_PRT("value %c", value[i]); + } - ret = bt_gatt_foreach_primary_services(address, __bt_gatt_primary_service_cb, NULL); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); + g_free(uuid); + g_free(value); + } + break; } - break; - } - case 141: { - __bt_free_gatt_characteristics(); + case BT_UNIT_TEST_FUNCTION_GATT_SET_CHARACTERISTIC_VALUE: { + unsigned char value[] = { 1 }; + if (selected_char_index == 0) { + TC_PRT("Need to select charateristic value \n"); + break; + } - ret = bt_gatt_discover_characteristics(service_clone[1], __bt_gatt_characteristics_discovered_cb, NULL); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); + ret = bt_gatt_set_characteristic_value_request(characteristics[selected_char_index], value, 1, + __bt_gatt_char_write_cb); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; } - break; - } - case 142: { - char *uuid = NULL; + case BT_UNIT_TEST_FUNCTION_GATT_READ_CHARACTERISTIC_VALUE : { + if (selected_char_index == 0) { + TC_PRT("Need to select charateristic value \n"); + break; + } - ret = bt_gatt_get_service_uuid(service_clone[1], &uuid); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); - } else { - TC_PRT("uuid: %s", uuid); - g_free(uuid); + ret = bt_gatt_read_characteristic_value(characteristics[selected_char_index], __bt_gatt_char_read_cb); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; } - break; - } - case 143: { - __bt_free_gatt_characteristics_services(); + case BT_UNIT_TEST_FUNCTION_GATT_WATCH_CHARACTERISTIC_CHANGES: { + if (selected_service_index < 0) { + TC_PRT("Need to select primary service \n"); + break; + } - ret = bt_gatt_foreach_included_services(service_clone[1], __bt_gatt_included_service_cb, NULL); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); + ret = bt_gatt_watch_characteristic_changes(service_clone[selected_service_index]); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + } + case BT_UNIT_TEST_FUNCTION_GATT_UNWATCH_CHARACTERISTIC_CHANGES: { + ret = bt_gatt_unwatch_characteristic_changes(service_clone[selected_service_index]); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + } + case BT_UNIT_TEST_FUNCTION_GATT_CONNECT : { + ret = bt_gatt_connect(remote_addr, false); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + } + case BT_UNIT_TEST_FUNCTION_GATT_DISCONNECT : { + ret = bt_gatt_disconnect(remote_addr); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + } + case BT_UNIT_TEST_FUNCTION_SET_GATT_CONNECTION_STATE_CHANGED_CB : { + ret = bt_gatt_set_connection_state_changed_cb(__bt_gatt_connection_state_changed_cb, NULL); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; } + case BT_UNIT_TEST_FUNCTION_UNSET_GATT_CONNECTION_STATE_CHANGED_CB : { + ret = bt_gatt_unset_connection_state_changed_cb(); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + } + default: + break; + } + break; } - - case 144: { - ret = bt_gatt_set_characteristic_changed_cb(__bt_gatt_characteristic_changed_cb, NULL); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); + case BT_UNIT_TEST_TABLE_AVRCP: { + switch (test_id) { + case BT_UNIT_TEST_FUNCTION_AVRCP_TARGET_INITIALIZE: + ret = bt_avrcp_target_initialize(__bt_avrcp_target_connection_state_changed_cb, NULL); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + + case BT_UNIT_TEST_FUNCTION_AVRCP_TARGET_DEINITIALIZE: + ret = bt_avrcp_target_deinitialize(); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + + case BT_UNIT_TEST_FUNCTION_AVRCP_SET_EQUALIZER_STATE_CHANGED_CB: + ret = bt_avrcp_set_equalizer_state_changed_cb(__bt_avrcp_equalizer_state_changed_cb, NULL); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + + case BT_UNIT_TEST_FUNCTION_AVRCP_SET_REPEAT_MODE_CHANGED_CB: + ret = bt_avrcp_set_repeat_mode_changed_cb(__bt_avrcp_repeat_mode_changed_cb, NULL); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + + case BT_UNIT_TEST_FUNCTION_AVRCP_SET_SHUFFLE_MODE_CHANGED_CB: + ret = bt_avrcp_set_shuffle_mode_changed_cb(__bt_avrcp_shuffle_mode_changed_cb, NULL); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + + case BT_UNIT_TEST_FUNCTION_AVRCP_SET_SCAN_MODE_CHANGED_CB: + ret = bt_avrcp_set_scan_mode_changed_cb(__bt_avrcp_scan_mode_changed_cb, NULL); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + + case BT_UNIT_TEST_FUNCTION_AVRCP_UNSET_EQUALIZER_STATE_CHANGED_CB: + ret = bt_avrcp_unset_equalizer_state_changed_cb(); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + + case BT_UNIT_TEST_FUNCTION_AVRCP_UNSET_REPEAT_MODE_CHANGED_CB: + ret = bt_avrcp_unset_repeat_mode_changed_cb(); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + + case BT_UNIT_TEST_FUNCTION_AVRCP_UNSET_SHUFFLE_MODE_CHANGED_CB: + ret = bt_avrcp_unset_shuffle_mode_changed_cb(); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + + case BT_UNIT_TEST_FUNCTION_AVRCP_UNSET_SCAN_MODE_CHANGED_CB: + ret = bt_avrcp_unset_scan_mode_changed_cb(); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + default: + break; } + break; } - - case 145: { - ret = bt_gatt_unset_characteristic_changed_cb(); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); + case BT_UNIT_TEST_TABLE_HID: { + switch (test_id) { + case BT_UNIT_TEST_FUNCTION_HID_HOST_INITIALIZE: + ret = bt_hid_host_initialize(__bt_hid_host_connection_state_changed_cb, + NULL); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + case BT_UNIT_TEST_FUNCTION_HID_HOST_DEINITIALIZE: + ret = bt_hid_host_deinitialize(); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + case BT_UNIT_TEST_FUNCTION_HID_HOST_CONNECT: { + ret = bt_hid_host_connect(remote_addr); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + } + case BT_UNIT_TEST_FUNCTION_HID_HOST_DISCONNECT: { + ret = bt_hid_host_disconnect(remote_addr); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + break; + } + default: + break; } + break; } + case BT_UNIT_TEST_TABLE_AUTOMATED_TEST: { + static unsigned int delay = 0; - case 146: { - int i; - char *uuid = NULL; - unsigned char *value = NULL; - int value_length = 0; - - ret = bt_gatt_get_characteristic_declaration(characteristics_services[0], &uuid, &value, &value_length); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); - } else { - TC_PRT("uuid: %s", uuid); - - for (i = 0; i < value_length; i++) { - TC_PRT("value %c", value[i]); - } - - g_free(uuid); - g_free(value); + if (input_automated_test_delay == true) { + delay = test_id; + test_id = BT_UNIT_TEST_FUNCTION_ON_OFF_REPEAT_TEST_N_SEC_DELAY; } - break; - } - case 147: { - unsigned char value[5] = { 0, 1, 2, 3, 4 }; + switch (test_id) { + /*Automated Test Cases */ + case BT_UNIT_TEST_FUNCTION_ON_OFF_REPEAT_TEST: { + bt_adapter_state_e state = BT_ADAPTER_DISABLED; + delay = 0; - ret = bt_gatt_set_characteristic_value(characteristics_services[0], value, 5); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); - } - break; - } + ret = bt_adapter_set_state_changed_cb(__bt_repeat_test_adapter_state_changed_cb, &delay); + TC_PRT("set_cb returns %s\n", __bt_get_error_message(ret)); - case 160: - ret = bt_avrcp_target_initialize(__bt_avrcp_target_connection_state_changed_cb, NULL); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); - } - break; + ret = bt_adapter_get_state(&state); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + TC_PRT("Current state: %d", state); - case 161: - ret = bt_avrcp_target_deinitialize(); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); + if (state == BT_ADAPTER_DISABLED) + bt_adapter_enable(); + else + bt_adapter_disable(); + break; } - break; + case BT_UNIT_TEST_FUNCTION_ON_OFF_REPEAT_TEST_1_SEC_DELAY: { + bt_adapter_state_e state = BT_ADAPTER_DISABLED; + delay = 1; - case 162: - ret = bt_avrcp_set_equalizer_state_changed_cb(__bt_avrcp_equalizer_state_changed_cb, NULL); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); - } - break; + ret = bt_adapter_set_state_changed_cb(__bt_repeat_test_adapter_state_changed_cb, &delay); + TC_PRT("set_cb returns %s\n", __bt_get_error_message(ret)); - case 163: - ret = bt_avrcp_set_repeat_mode_changed_cb(__bt_avrcp_repeat_mode_changed_cb, NULL); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); - } - break; + ret = bt_adapter_get_state(&state); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + TC_PRT("Current state: %d", state); - case 164: - ret = bt_avrcp_set_shuffle_mode_changed_cb(__bt_avrcp_shuffle_mode_changed_cb, NULL); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); + if (state == BT_ADAPTER_DISABLED) + bt_adapter_enable(); + else + bt_adapter_disable(); + break; } - break; + case BT_UNIT_TEST_FUNCTION_ON_OFF_REPEAT_TEST_N_SEC_DELAY: { + bt_adapter_state_e state = BT_ADAPTER_DISABLED; - case 165: - ret = bt_avrcp_set_scan_mode_changed_cb(__bt_avrcp_scan_mode_changed_cb, NULL); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); - } - break; + input_automated_test_delay = false; - case 166: - ret = bt_avrcp_unset_equalizer_state_changed_cb(); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); - } - break; + ret = bt_adapter_set_state_changed_cb(__bt_repeat_test_adapter_state_changed_cb, &delay); + TC_PRT("set_cb returns %s\n", __bt_get_error_message(ret)); - case 167: - ret = bt_avrcp_unset_repeat_mode_changed_cb(); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); - } - break; + ret = bt_adapter_get_state(&state); + TC_PRT("returns %s\n", __bt_get_error_message(ret)); + TC_PRT("Current state: %d", state); - case 168: - ret = bt_avrcp_unset_shuffle_mode_changed_cb(); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); + if (state == BT_ADAPTER_DISABLED) + bt_adapter_enable(); + else + bt_adapter_disable(); + break; } - break; - case 169: - ret = bt_avrcp_unset_scan_mode_changed_cb(); - if (ret < BT_ERROR_NONE) { - TC_PRT("failed with [0x%04x]", ret); + default: + break; } - break; + break; + } default: break; } @@ -1157,8 +1991,12 @@ static gboolean key_event_cb(GIOChannel *chan, { char buf[BUFFER_LEN] = { 0 }; - gsize len = 0; - long test_id; + unsigned int len = 0; + int test_id; + bool is_call_api = false; + + if (is_sub_index) + return TRUE; memset(buf, 0, sizeof(buf)); @@ -1169,11 +2007,34 @@ static gboolean key_event_cb(GIOChannel *chan, } TC_PRT("%s", buf); - tc_usage_print(); test_id = atoi(buf); - if (test_id) + if (current_tc_table == BT_UNIT_TEST_TABLE_MAIN) { + if (buf[0] == '0' && buf[2] == 0) + current_tc_table = BT_UNIT_TEST_TABLE_SET_ADDRESS; + else if(test_id >= BT_UNIT_TEST_TABLE_ADAPTER && test_id < BT_UNIT_TEST_TABLE_END) + current_tc_table = test_id; + else + is_call_api = true; + } else { + if (buf[0] == '0' && buf[2] == 0) { + current_tc_table = BT_UNIT_TEST_TABLE_MAIN; + } else if (current_tc_table == BT_UNIT_TEST_TABLE_AUTOMATED_TEST + && test_id == BT_UNIT_TEST_FUNCTION_ON_OFF_REPEAT_TEST_N_SEC_DELAY + && input_automated_test_delay == false) { + input_automated_test_delay = true; + } else { + is_call_api = true; + } + } + + tc_usage_print(); + + if (current_tc_table == BT_UNIT_TEST_TABLE_SET_ADDRESS && is_call_api == true) { + memcpy (remote_addr, buf, 17); + remote_addr[17] = 0; + } else if (test_id && is_call_api) g_idle_add(test_input_callback, (void *)test_id); return TRUE; @@ -1186,6 +2047,7 @@ int main() #if !GLIB_CHECK_VERSION(2,35,0) g_type_init(); #endif + current_tc_table = BT_UNIT_TEST_TABLE_MAIN; key_io = g_io_channel_unix_new(fileno(stdin)); diff --git a/test/bt_unit_test.h b/test/bt_unit_test.h new file mode 100755 index 0000000..997a942 --- /dev/null +++ b/test/bt_unit_test.h @@ -0,0 +1,199 @@ +/* + * + * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * + */ + +#ifndef __TIZEN_NETWORK_BLUETOOTH_UNIT_TEST_H__ +#define __TIZEN_NETWORK_BLUETOOTH_UNIT_TEST_H__ + + +#ifdef __cplusplus +extern "C" { +#endif + +#define BUFFER_LEN 19 +#define MAX_SERVICES 10 +#define PRT(format, args...) printf("%s:%d() "format, __FUNCTION__, __LINE__, ##args) +#define TC_PRT(format, args...) PRT(format"\n", ##args) + +typedef enum +{ + BT_UNIT_TEST_TABLE_MAIN = 1, + BT_UNIT_TEST_TABLE_SET_ADDRESS, + BT_UNIT_TEST_TABLE_ADAPTER, + BT_UNIT_TEST_TABLE_ADAPTER_LE, + BT_UNIT_TEST_TABLE_DEVICE, + BT_UNIT_TEST_TABLE_SOCKET, + BT_UNIT_TEST_TABLE_OPP, + BT_UNIT_TEST_TABLE_AUDIO, + BT_UNIT_TEST_TABLE_PAN, + BT_UNIT_TEST_TABLE_GATT, + BT_UNIT_TEST_TABLE_AVRCP, + BT_UNIT_TEST_TABLE_HID, + BT_UNIT_TEST_TABLE_AUTOMATED_TEST, + BT_UNIT_TEST_TABLE_END, +} bt_unit_test_table_e; + +typedef enum +{ + BT_UNIT_TEST_FUNCTION_BACK = 0, + BT_UNIT_TEST_FUNCTION_SET_ADDRESS = 0, + BT_UNIT_TEST_FUNCTION_INITIALIZE = 1, + BT_UNIT_TEST_FUNCTION_DEINITIALIZE, + BT_UNIT_TEST_FUNCTION_ADAPTER_GET_STATE = 1, + BT_UNIT_TEST_FUNCTION_ADAPTER_ENABLE, + BT_UNIT_TEST_FUNCTION_ADAPTER_DISABLE, + BT_UNIT_TEST_FUNCTION_ADAPTER_RECOVER, + BT_UNIT_TEST_FUNCTION_ADAPTER_START_DEVICE_DISCOVERY, + BT_UNIT_TEST_FUNCTION_ADAPTER_STOP_DEVICE_DISCOVERY, + BT_UNIT_TEST_FUNCTION_ADAPTER_IS_DISCOVERING, + BT_UNIT_TEST_FUNCTION_ADAPTER_FOREACH_BONDED_DEVICE, + BT_UNIT_TEST_FUNCTION_ADAPTER_GET_BONDED_DEVICE_INFO, + BT_UNIT_TEST_FUNCTION_ADAPTER_IS_SERVICE_USED, + BT_UNIT_TEST_FUNCTION_ADAPTER_GET_VISIBILITY, + BT_UNIT_TEST_FUNCTION_ADAPTER_SET_DEVICE_DISCOVERY_STATE_CHANGED_CB, + BT_UNIT_TEST_FUNCTION_ADAPTER_UNSET_DEVICE_DISCOVERY_STATE_CHANGED_CB, + BT_UNIT_TEST_FUNCTION_ADAPTER_GET_LOCAL_OOB_DATA, + BT_UNIT_TEST_FUNCTION_ADAPTER_SET_LOCAL_OOB_DATA, + BT_UNIT_TEST_FUNCTION_ADAPTER_REMOVE_REMOTE_OOB_DATA, + BT_UNIT_TEST_FUNCTION_ADAPTER_SET_VISIBILITY_MODE_CHANGED_CB, + BT_UNIT_TEST_FUNCTION_ADAPTER_UNSET_VISIBILITY_MODE_CHANGED_CB, + BT_UNIT_TEST_FUNCTION_ADAPTER_SET_VISIBILITY_DURATION_CHANGED_CB, + BT_UNIT_TEST_FUNCTION_ADAPTER_UNSET_VISIBILITY_DURATION_CHANGED_CB, + BT_UNIT_TEST_FUNCTION_ADAPTER_SET_CONNECTABLE_CHANGED_CB, + BT_UNIT_TEST_FUNCTION_ADAPTER_UNSET_CONNECTABLE_CHANGED_CB, + BT_UNIT_TEST_FUNCTION_ADAPTER_GET_CONNECTABLE, + BT_UNIT_TEST_FUNCTION_ADAPTER_SET_CONNECTABLE, + BT_UNIT_TEST_FUNCTION_ADAPTER_GET_VERSION, + BT_UNIT_TEST_FUNCTION_ADAPTER_GET_LOCAL_INFO, + BT_UNIT_TEST_FUNCTION_ADAPTER_LE_GET_STATE = 1, + BT_UNIT_TEST_FUNCTION_ADAPTER_LE_ENABLE, + BT_UNIT_TEST_FUNCTION_ADAPTER_LE_DISABLE, + BT_UNIT_TEST_FUNCTION_ADAPTER_LE_START_DEVICE_DISCOVERY, + BT_UNIT_TEST_FUNCTION_ADAPTER_LE_STOP_DEVICE_DISCOVERY, + BT_UNIT_TEST_FUNCTION_ADAPTER_LE_START_ADVERTISING, + BT_UNIT_TEST_FUNCTION_ADAPTER_LE_STOP_ADVERTISING, + BT_UNIT_TEST_FUNCTION_ADAPTER_LE_ADD_WHITE_LIST, + BT_UNIT_TEST_FUNCTION_ADAPTER_LE_REMOVE_WHITE_LIST, + BT_UNIT_TEST_FUNCTION_ADAPTER_LE_CLEAR_WHITE_LIST, + BT_UNIT_TEST_FUNCTION_ADAPTER_LE_ENABLE_PRIVACY, + BT_UNIT_TEST_FUNCTION_ADAPTER_LE_SET_DEVICE_DISCOVERY_STATE_CHANGED_CB, + BT_UNIT_TEST_FUNCTION_ADAPTER_LE_UNSET_DEVICE_DISCOVERY_STATE_CHANGED_CB, + BT_UNIT_TEST_FUNCTION_DEVICE_SET_AUTHORIZATION_TRUE = 1, + BT_UNIT_TEST_FUNCTION_DEVICE_SET_AUTHORIZATION_FALSE, + BT_UNIT_TEST_FUNCTION_DEVICE_SET_AUTHORIZATION_CHANGED_CB, + BT_UNIT_TEST_FUNCTION_DEVICE_UNSET_AUTHORIZATION_CHANGED_CB, + BT_UNIT_TEST_FUNCTION_DEVICE_SET_CONNECTION_STAET_CHANGED_CB, + BT_UNIT_TEST_FUNCTION_DEVICE_UNSET_CONNECTION_STAET_CHANGED_CB, + BT_UNIT_TEST_FUNCTION_DEVICE_FOREACH_CONNECTED_PROFILES, + BT_UNIT_TEST_FUNCTION_DEVICE_IS_PROFILE_CONNECTED, + BT_UNIT_TEST_FUNCTION_DEVICE_SET_BOND_CREATED_CB, + BT_UNIT_TEST_FUNCTION_DEVICE_CREATE_BOND, + BT_UNIT_TEST_FUNCTION_DEVICE_CREATE_BOND_BY_TYPE, + BT_UNIT_TEST_FUNCTION_SOCKET_CREATE_RFCOMM = 1, + BT_UNIT_TEST_FUNCTION_SOCKET_DESTROY_RFCOMM, + BT_UNIT_TEST_FUNCTION_SOCKET_LISTEN_AND_ACCEPT_RFCOMM, + BT_UNIT_TEST_FUNCTION_SOCKET_LISTEN, + BT_UNIT_TEST_FUNCTION_SOCKET_ACCEPT, + BT_UNIT_TEST_FUNCTION_SOCKET_REJECT, + BT_UNIT_TEST_FUNCTION_SOCKET_CONNECT_RFCOMM, + BT_UNIT_TEST_FUNCTION_SOCKET_DISCONNECT_RFCOMM, + BT_UNIT_TEST_FUNCTION_SOCKET_SEND_DATA, + BT_UNIT_TEST_FUNCTION_SOCKET_SET_DATA_RECEIVED_CB, + BT_UNIT_TEST_FUNCTION_SOCKET_UNSET_DATA_RECEIVED_CB, + BT_UNIT_TEST_FUNCTION_SOCKET_SET_CONNECTION_REQUESTED_CB, + BT_UNIT_TEST_FUNCTION_SOCKET_UNSET_CONNECTION_REQUESTED_CB, + BT_UNIT_TEST_FUNCTION_SOCKET_SET_CONNECTION_STATE_CHANGED_CB, + BT_UNIT_TEST_FUNCTION_SOCKET_UNSET_CONNECTION_STATE_CHANGED_CB, + BT_UNIT_TEST_FUNCTION_OPP_CLIENT_INITIALIZE = 1, + BT_UNIT_TEST_FUNCTION_OPP_CLIENT_DEINITIALIZE, + BT_UNIT_TEST_FUNCTION_OPP_CLIENT_ADD_FILE, + BT_UNIT_TEST_FUNCTION_OPP_CLIENT_CLEAR_FILES, + BT_UNIT_TEST_FUNCTION_OPP_CLIENT_PUSH_FILES, + BT_UNIT_TEST_FUNCTION_OPP_CLIENT_CANCEL_PUSH, + BT_UNIT_TEST_FUNCTION_AUDIO_INITIALIZE = 1, + BT_UNIT_TEST_FUNCTION_AUDIO_DEINITIALIZE, + BT_UNIT_TEST_FUNCTION_AUDIO_CONNECT, + BT_UNIT_TEST_FUNCTION_AUDIO_DISCONNECT, + BT_UNIT_TEST_FUNCTION_AUDIO_SET_CONNECTION_STATE_CHANGED_CB, + BT_UNIT_TEST_FUNCTION_AUDIO_UNSET_CONNECTION_STATE_CHANGED_CB, + BT_UNIT_TEST_FUNCTION_AG_OPEN_SCO, + BT_UNIT_TEST_FUNCTION_AG_CLOSE_SCO, + BT_UNIT_TEST_FUNCTION_AG_IS_SCO_OPENED, + BT_UNIT_TEST_FUNCTION_AG_SET_SCO_STATE_CHANGED_CB, + BT_UNIT_TEST_FUNCTION_AG_UNSET_SCO_STATE_CHANGED_CB, + BT_UNIT_TEST_FUNCTION_AG_CALL_EVENT_IDLE, + BT_UNIT_TEST_FUNCTION_AG_CALL_EVENT_ANSWERED, + BT_UNIT_TEST_FUNCTION_AG_CALL_EVENT_DIALING, + BT_UNIT_TEST_FUNCTION_AG_CALL_EVENT_ALERTING, + BT_UNIT_TEST_FUNCTION_AG_CALL_EVENT_INCOMING, + BT_UNIT_TEST_FUNCTION_CALL_LIST_CREATE, + BT_UNIT_TEST_FUNCTION_CALL_LIST_DESTROY, + BT_UNIT_TEST_FUNCTION_CALL_LIST_RESET, + BT_UNIT_TEST_FUNCTION_CALL_LIST_ADD, + BT_UNIT_TEST_FUNCTION_AG_NOTIFY_CALL_LIST, + BT_UNIT_TEST_FUNCTION_AG_SET_CALL_HANDLING_EVENT_CB, + BT_UNIT_TEST_FUNCTION_AG_IS_NREC_ENABLED, + BT_UNIT_TEST_FUNCTION_NAP_ACTIVATE = 1, + BT_UNIT_TEST_FUNCTION_NAP_DEACTIVATE, + BT_UNIT_TEST_FUNCTION_NAP_DISCONNECT_ALL, + BT_UNIT_TEST_FUNCTION_NAP_DISCONNECT, + BT_UNIT_TEST_FUNCTION_PANU_SET_CONNECTION_STATE_CHANGED_CB, + BT_UNIT_TEST_FUNCTION_PANU_CONNECT, + BT_UNIT_TEST_FUNCTION_GATT_FOREACH_PRIMARY_SERVICES = 1, + BT_UNIT_TEST_FUNCTION_GATT_DISCOVER_CHARACTERISTICS, + BT_UNIT_TEST_FUNCTION_GATT_GET_SERVICE_UUID, + BT_UNIT_TEST_FUNCTION_GATT_FOREACH_INCLUDED_SERVICES, + BT_UNIT_TEST_FUNCTION_GATT_SET_CHARACTERISTIC_CHANGED_CB, + BT_UNIT_TEST_FUNCTION_GATT_UNSET_CHARACTERISTIC_CHANGED_CB, + BT_UNIT_TEST_FUNCTION_GATT_GET_CHARACTERISTIC_DECLARATION, + BT_UNIT_TEST_FUNCTION_GATT_SET_CHARACTERISTIC_VALUE, + BT_UNIT_TEST_FUNCTION_GATT_READ_CHARACTERISTIC_VALUE, + BT_UNIT_TEST_FUNCTION_GATT_WATCH_CHARACTERISTIC_CHANGES, + BT_UNIT_TEST_FUNCTION_GATT_UNWATCH_CHARACTERISTIC_CHANGES, + BT_UNIT_TEST_FUNCTION_GATT_CONNECT, + BT_UNIT_TEST_FUNCTION_GATT_DISCONNECT, + BT_UNIT_TEST_FUNCTION_SET_GATT_CONNECTION_STATE_CHANGED_CB, + BT_UNIT_TEST_FUNCTION_UNSET_GATT_CONNECTION_STATE_CHANGED_CB, + BT_UNIT_TEST_FUNCTION_AVRCP_TARGET_INITIALIZE = 1, + BT_UNIT_TEST_FUNCTION_AVRCP_TARGET_DEINITIALIZE, + BT_UNIT_TEST_FUNCTION_AVRCP_SET_EQUALIZER_STATE_CHANGED_CB, + BT_UNIT_TEST_FUNCTION_AVRCP_SET_REPEAT_MODE_CHANGED_CB, + BT_UNIT_TEST_FUNCTION_AVRCP_SET_SHUFFLE_MODE_CHANGED_CB, + BT_UNIT_TEST_FUNCTION_AVRCP_SET_SCAN_MODE_CHANGED_CB, + BT_UNIT_TEST_FUNCTION_AVRCP_UNSET_EQUALIZER_STATE_CHANGED_CB, + BT_UNIT_TEST_FUNCTION_AVRCP_UNSET_REPEAT_MODE_CHANGED_CB, + BT_UNIT_TEST_FUNCTION_AVRCP_UNSET_SHUFFLE_MODE_CHANGED_CB, + BT_UNIT_TEST_FUNCTION_AVRCP_UNSET_SCAN_MODE_CHANGED_CB, + BT_UNIT_TEST_FUNCTION_HID_HOST_INITIALIZE = 1, + BT_UNIT_TEST_FUNCTION_HID_HOST_DEINITIALIZE, + BT_UNIT_TEST_FUNCTION_HID_HOST_CONNECT, + BT_UNIT_TEST_FUNCTION_HID_HOST_DISCONNECT, + BT_UNIT_TEST_FUNCTION_ON_OFF_REPEAT_TEST = 1, + BT_UNIT_TEST_FUNCTION_ON_OFF_REPEAT_TEST_1_SEC_DELAY, + BT_UNIT_TEST_FUNCTION_ON_OFF_REPEAT_TEST_N_SEC_DELAY +} bt_unit_test_function_e; + +typedef struct { + const char *tc_name; + int tc_code; +} tc_table_t; + +#ifdef __cplusplus +} +#endif + +#endif /* __TIZEN_NETWORK_BLUETOOTH_UNIT_TEST_H__ */ diff --git a/test/capi-network-bluetooth-test b/test/capi-network-bluetooth-test new file mode 100755 index 0000000..ec7331a --- /dev/null +++ b/test/capi-network-bluetooth-test @@ -0,0 +1,4 @@ +root capi-network-bluetooth-test rw---- +_default_ capi-network-bluetooth-test rw---- +capi-network-bluetooth-test bt-service::platform rw---- +capi-network-bluetooth-test bt-service::public -w---- diff --git a/test/capi-network-bluetooth-test.efl b/test/capi-network-bluetooth-test.efl new file mode 100755 index 0000000..ec7331a --- /dev/null +++ b/test/capi-network-bluetooth-test.efl @@ -0,0 +1,4 @@ +root capi-network-bluetooth-test rw---- +_default_ capi-network-bluetooth-test rw---- +capi-network-bluetooth-test bt-service::platform rw---- +capi-network-bluetooth-test bt-service::public -w----