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)
--- /dev/null
+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".
--- /dev/null
+#!/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
--- /dev/null
+#!/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
--- /dev/null
+#!/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
--- /dev/null
+#!/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
--- /dev/null
+PKG_NAME=capi-network-bluetooth
+TET_INSTALL_HOST_PATH=/var/tmp/dts_fw/TC/TETware
+TET_INSTALL_TARGET_PATH=/opt/home/$PKG_NAME/TETware
+
--- /dev/null
+#!/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
--- /dev/null
+#!/bin/sh
+
+. ./config
+
+TC_PATH=/opt/home/$PKG_NAME
+
+echo $TC_PATH
+
+sdb shell "mkdir -p $TC_PATH"
+
+sdb push . $TC_PATH
+
+
--- /dev/null
+#!/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
--- /dev/null
+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)
--- /dev/null
+/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
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+#include <tet_api.h>
+#include <bluetooth.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <glib.h>
+#include <time.h>
+
+enum {
+ POSITIVE_TC_IDX = 0x01,
+ NEGATIVE_TC_IDX,
+};
+
+static void startup(void);
+static void cleanup(void);
+bt_adapter_visibility_mode_e adapter_visibility_mode =
+ BT_ADAPTER_VISIBILITY_MODE_LIMITED_DISCOVERABLE;
+char adapter_name[128] = "dts_test";
+
+void (*tet_startup)(void) = startup;
+void (*tet_cleanup)(void) = cleanup;
+
+
+static void utc_network_bluetooth_deinitialize_n(void);
+static void utc_network_bluetooth_adapter_set_state_changed_cb_n(void);
+static void utc_network_bluetooth_adapter_set_name_changed_cb_n(void);
+static void utc_network_bluetooth_adapter_set_visibility_mode_changed_cb_n(void);
+static void utc_network_bluetooth_adapter_set_connectable_changed_cb_n(void);
+static void utc_network_bluetooth_adapter_enable_n(void);
+static void utc_network_bluetooth_adapter_get_state_n(void);
+static void utc_network_bluetooth_adapter_get_address_n(void);
+static void utc_network_bluetooth_adapter_set_name_n(void);
+static void utc_network_bluetooth_adapter_get_name_n(void);
+static void utc_network_bluetooth_adapter_set_visibility_n(void);
+static void utc_network_bluetooth_adapter_get_visibility_n(void);
+static void utc_network_bluetooth_adapter_add_white_list_n(void);
+static void utc_network_bluetooth_adapter_clear_white_list_n(void);
+static void utc_network_bluetooth_adapter_remove_white_list_n(void);
+static void utc_network_bluetooth_adapter_set_connectable_n(void);
+static void utc_network_bluetooth_adapter_get_connectable_n(void);
+static void utc_network_bluetooth_adapter_disable_n(void);
+static void utc_network_bluetooth_adapter_unset_state_changed_cb_n(void);
+static void utc_network_bluetooth_adapter_unset_name_changed_cb_n(void);
+static void utc_network_bluetooth_adapter_unset_visibility_mode_changed_cb_n(void);
+static void utc_network_bluetooth_adapter_unset_connectable_changed_cb_n(void);
+static void utc_network_bluetooth_adapter_set_le_state_changed_cb_n(void);
+static void utc_network_bluetooth_adapter_unset_le_state_changed_cb_n(void);
+static void utc_network_bluetooth_adapter_le_enable_n(void);
+static void utc_network_bluetooth_adapter_get_le_state_n(void);
+static void utc_network_bluetooth_adapter_le_disable_n(void);
+
+void adapter_state_changed_cb_for_adapter_n(int result,
+ bt_adapter_state_e adapter_state,
+ void *user_data);
+gboolean timeout_func(gpointer data);
+
+struct tet_testlist tet_testlist[] = {
+ {utc_network_bluetooth_adapter_disable_n, NEGATIVE_TC_IDX},
+ {utc_network_bluetooth_adapter_set_state_changed_cb_n, NEGATIVE_TC_IDX},
+ {utc_network_bluetooth_adapter_set_name_changed_cb_n, NEGATIVE_TC_IDX},
+ {utc_network_bluetooth_adapter_set_visibility_mode_changed_cb_n, NEGATIVE_TC_IDX},
+ {utc_network_bluetooth_adapter_set_connectable_changed_cb_n, NEGATIVE_TC_IDX},
+ {utc_network_bluetooth_adapter_get_state_n, NEGATIVE_TC_IDX},
+ {utc_network_bluetooth_adapter_get_address_n, NEGATIVE_TC_IDX},
+ {utc_network_bluetooth_adapter_set_name_n, NEGATIVE_TC_IDX},
+ {utc_network_bluetooth_adapter_get_name_n, NEGATIVE_TC_IDX},
+ {utc_network_bluetooth_adapter_get_visibility_n, NEGATIVE_TC_IDX},
+ {utc_network_bluetooth_adapter_set_visibility_n, NEGATIVE_TC_IDX},
+ {utc_network_bluetooth_adapter_le_disable_n, NEGATIVE_TC_IDX},
+ {utc_network_bluetooth_adapter_add_white_list_n, NEGATIVE_TC_IDX},
+ {utc_network_bluetooth_adapter_remove_white_list_n, NEGATIVE_TC_IDX},
+ {utc_network_bluetooth_adapter_clear_white_list_n, NEGATIVE_TC_IDX},
+ {utc_network_bluetooth_adapter_get_connectable_n, NEGATIVE_TC_IDX},
+ {utc_network_bluetooth_deinitialize_n, NEGATIVE_TC_IDX},
+ {utc_network_bluetooth_adapter_set_connectable_n, NEGATIVE_TC_IDX},
+ {utc_network_bluetooth_adapter_enable_n, NEGATIVE_TC_IDX},
+ {utc_network_bluetooth_adapter_unset_connectable_changed_cb_n, NEGATIVE_TC_IDX},
+ {utc_network_bluetooth_adapter_unset_state_changed_cb_n, NEGATIVE_TC_IDX},
+ {utc_network_bluetooth_adapter_unset_name_changed_cb_n, NEGATIVE_TC_IDX},
+ {utc_network_bluetooth_adapter_unset_visibility_mode_changed_cb_n, NEGATIVE_TC_IDX},
+ {utc_network_bluetooth_adapter_set_le_state_changed_cb_n, NEGATIVE_TC_IDX},
+ {utc_network_bluetooth_adapter_get_le_state_n, NEGATIVE_TC_IDX},
+ {utc_network_bluetooth_adapter_le_enable_n, NEGATIVE_TC_IDX},
+ {utc_network_bluetooth_adapter_unset_le_state_changed_cb_n, NEGATIVE_TC_IDX},
+ {NULL, 0},
+};
+
+static void startup(void)
+{
+ /* start of TC */
+ tet_printf("TC start.");
+ bt_initialize();
+}
+
+static void cleanup(void)
+{
+ /* end of TC */
+ tet_printf("TC end");
+}
+
+/**
+ * @brief Negative test case of bt_deinitialize()
+ */
+static void utc_network_bluetooth_deinitialize_n(void)
+{
+ int ret = bt_deinitialize();
+
+ if (ret == BT_ERROR_NONE) {
+ ret = bt_deinitialize();
+ dts_check_eq("bt_deinitialize", ret, BT_ERROR_NOT_INITIALIZED,
+ "BT_ERROR_NOT_INITIALIZED must be returned.");
+ } else {
+ dts_fail("bt_deinitialize", "bt_deinitialize() failed.");
+ }
+}
+
+/**
+ * @brief Negative test case of bt_adapter_disable()
+ */
+static void utc_network_bluetooth_adapter_disable_n(void)
+{
+ int ret = BT_ERROR_NONE;
+
+ ret = bt_adapter_disable();
+ dts_check_eq("bt_adapter_disable", ret, BT_ERROR_NOT_ENABLED,
+ "BT_ERROR_NOT_ENABLED must be returned when BT is disabled");
+}
+
+/**
+ * @brief Negative test case of bt_adapter_set_state_changed_cb()
+ */
+static void utc_network_bluetooth_adapter_set_state_changed_cb_n(void)
+{
+ int ret = BT_ERROR_NONE;
+
+ ret = bt_adapter_set_state_changed_cb(NULL, NULL);
+ dts_check_eq("bt_adapter_set_state_changed_cb", ret,
+ BT_ERROR_INVALID_PARAMETER,
+ "BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL.");
+}
+
+/**
+ * @brief Negative test case of bt_adapter_set_name_changed_cb()
+ */
+static void utc_network_bluetooth_adapter_set_name_changed_cb_n(void)
+{
+ int ret = BT_ERROR_NONE;
+
+ ret = bt_adapter_set_name_changed_cb(NULL, NULL);
+ dts_check_eq("bt_adapter_set_name_changed_cb", ret,
+ BT_ERROR_INVALID_PARAMETER,
+ "BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL.");
+}
+
+/**
+ * @brief Negative test case of bt_adapter_set_visibility_mode_changed_cb()
+ */
+static void utc_network_bluetooth_adapter_set_visibility_mode_changed_cb_n(void)
+{
+ int ret = BT_ERROR_NONE;
+
+ ret = bt_adapter_set_visibility_mode_changed_cb(NULL, NULL);
+ dts_check_eq("bt_adapter_set_visibility_mode_changed_cb", ret,
+ BT_ERROR_INVALID_PARAMETER,
+ "BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL.");
+}
+
+/**
+ * @brief Negative test case of bt_adapter_set_connectable_changed_cb()
+ */
+static void utc_network_bluetooth_adapter_set_connectable_changed_cb_n(void)
+{
+ int ret = BT_ERROR_NONE;
+
+ ret = bt_adapter_set_connectable_changed_cb(NULL, NULL);
+ dts_check_eq("bt_adapter_set_connectable_changed_cb", ret,
+ BT_ERROR_INVALID_PARAMETER,
+ "BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL.");
+}
+
+/**
+ * @brief Negative test case of bt_adapter_get_state()
+ */
+static void utc_network_bluetooth_adapter_get_state_n(void)
+{
+ int ret = BT_ERROR_NONE;
+
+ ret = bt_adapter_get_state(NULL);
+ dts_check_eq("bt_adapter_get_state", ret, BT_ERROR_INVALID_PARAMETER,
+ "BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL.");
+}
+
+/**
+ * @brief Negative test case of bt_adapter_get_address().
+ */
+static void utc_network_bluetooth_adapter_get_address_n(void)
+{
+ char *address = NULL;
+ int ret = bt_adapter_get_address(&address);
+
+ dts_check_eq("bt_adapter_get_address", ret, BT_ERROR_NOT_ENABLED,
+ "BT_ERROR_NOT_ENABLED must be returned when BT is not enabled.");
+}
+
+/**
+ * @brief Negative test case of bt_adapter_get_name().
+ */
+static void utc_network_bluetooth_adapter_get_name_n(void)
+{
+ char *name = NULL;
+ int ret = bt_adapter_get_name(&name);
+
+ dts_check_eq("bt_adapter_get_name", ret, BT_ERROR_NOT_ENABLED,
+ "BT_ERROR_NOT_ENABLED must be returned when BT is not enabled.");
+}
+
+/**
+ * @brief Negative test case of bt_adapter_get_visibility().
+ */
+static void utc_network_bluetooth_adapter_get_visibility_n(void)
+{
+ int dur = 10;
+ int ret = bt_adapter_get_visibility(NULL, &dur);
+
+ dts_check_eq("bt_adapter_get_visibility", ret, BT_ERROR_INVALID_PARAMETER,
+ "BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL.");
+}
+
+/**
+ * @brief Negative test case of bt_adapter_set_name().
+ */
+static void utc_network_bluetooth_adapter_set_name_n(void)
+{
+ int ret = bt_adapter_set_name(NULL);
+ dts_check_eq("bt_adapter_set_name", ret, BT_ERROR_INVALID_PARAMETER,
+ "BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL.");
+}
+
+/**
+ * @brief Negative test case of bt_adapter_set_visibility().
+ */
+static void utc_network_bluetooth_adapter_set_visibility_n(void)
+{
+ int ret = bt_adapter_set_visibility(adapter_visibility_mode, 180);
+
+ dts_check_eq("bt_adapter_set_visibility", ret, BT_ERROR_NOT_ENABLED,
+ "BT_ERROR_NOT_ENABLED must be returned when BT is not enabled.");
+}
+
+/**
+ * @brief Negative test case of bt_adapter_le_add_white_list
+ */
+static void utc_network_bluetooth_adapter_add_white_list_n(void)
+{
+ int ret = bt_adapter_le_add_white_list(NULL);
+ dts_check_eq("bt_adapter_le_add_white_list", ret, BT_ERROR_INVALID_PARAMETER,
+ "BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL.");
+}
+
+/**
+ * @brief Negative test case of bt_adapter_clear_white_list
+ */
+static void utc_network_bluetooth_adapter_clear_white_list_n(void)
+{
+ int ret = BT_ERROR_NONE;
+ ret = bt_adapter_clear_white_list();
+ dts_check_eq("bt_adapter_clear_white_list", ret, BT_ERROR_NOT_ENABLED,
+ "BT_ERROR_NOT_ENABLED must be returned when BT is not enabled.");
+}
+
+/**
+ * @brief Negative test case of bt_adapter_le_add_white_list
+ */
+static void utc_network_bluetooth_adapter_remove_white_list_n(void)
+{
+ int ret = bt_adapter_le_remove_white_list(NULL);
+ dts_check_eq("bt_adapter_le_remove_white_list", ret, BT_ERROR_INVALID_PARAMETER,
+ "BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL.");
+}
+
+/**
+ * @brief Negative test case of bt_adapter_get_connectable
+ */
+static void utc_network_bluetooth_adapter_get_connectable_n(void)
+{
+ int ret = bt_adapter_get_connectable(NULL);
+ dts_check_eq("bt_adapter_get_connectable", ret, BT_ERROR_INVALID_PARAMETER,
+ "BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL.");
+}
+
+/**
+ * @brief Negative test case of bt_adapter_set_connectable
+ */
+static void utc_network_bluetooth_adapter_set_connectable_n(void)
+{
+ int ret = bt_adapter_set_connectable(NULL);
+ dts_check_eq("bt_adapter_set_connectable", ret, BT_ERROR_NOT_INITIALIZED,
+ "BT_ERROR_NOT_INITIALIZED must be returned when BT is not initialized.");
+}
+
+/**
+ * @brief Negative test case of bt_adapter_unset_state_changed_cb()
+ */
+static void utc_network_bluetooth_adapter_unset_state_changed_cb_n(void)
+{
+ int ret = BT_ERROR_NONE;
+
+ ret = bt_adapter_unset_state_changed_cb();
+ dts_check_eq("bt_adapter_unset_state_changed_cb", ret,
+ BT_ERROR_NOT_INITIALIZED,
+ "BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized.");
+}
+
+/**
+ * @brief Negative test case of bt_adapter_unset_name_changed_cb()
+ */
+static void utc_network_bluetooth_adapter_unset_name_changed_cb_n(void)
+{
+ int ret = BT_ERROR_NONE;
+
+ ret = bt_adapter_unset_name_changed_cb();
+ dts_check_eq("bt_adapter_unset_name_changed_cb", ret,
+ BT_ERROR_NOT_INITIALIZED,
+ "BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized.");
+}
+
+/**
+ * @brief Negative test case of bt_adapter_unset_visibility_mode_changed_cb()
+ */
+static void
+utc_network_bluetooth_adapter_unset_visibility_mode_changed_cb_n(void)
+{
+ int ret = BT_ERROR_NONE;
+
+ ret = bt_adapter_unset_visibility_mode_changed_cb();
+ dts_check_eq("bt_adapter_unset_visibility_mode_changed_cb", ret,
+ BT_ERROR_NOT_INITIALIZED,
+ "BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized.");
+}
+
+/**
+ * @brief Negative test case of bt_adapter_enable()
+ */
+static void utc_network_bluetooth_adapter_enable_n(void)
+{
+ bt_error_e ret = bt_adapter_enable();
+ dts_check_eq("bt_adapter_enable", ret, BT_ERROR_NOT_INITIALIZED,
+ "BT_ERROR_NOT_INITIALIZED must be returned.");
+}
+
+/**
+ * @brief Negative test case of bt_adapter_unset_connectable_changed_cb()
+ */
+static void utc_network_bluetooth_adapter_unset_connectable_changed_cb_n(void)
+{
+ int ret = BT_ERROR_NONE;
+
+ ret = bt_adapter_unset_connectable_changed_cb();
+ dts_check_eq("bt_adapter_unset_connectable_changed_cb", ret,
+ BT_ERROR_NOT_INITIALIZED,
+ "bt_adapter_unset_connectable_changed_cb() failed.");
+}
+
+/**
+ * @brief Negative test case of bt_adapter_le_set_state_changed_cb()
+ */
+static void utc_network_bluetooth_adapter_set_le_state_changed_cb_n(void)
+{
+ int ret = BT_ERROR_NONE;
+
+ ret = bt_adapter_le_set_state_changed_cb(NULL, NULL);
+ dts_check_eq("bt_adapter_le_set_state_changed_cb", ret,
+ BT_ERROR_INVALID_PARAMETER,
+ "BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL.");
+}
+
+static void utc_network_bluetooth_adapter_le_enable_n(void)
+{
+ int ret = BT_ERROR_NONE;
+
+ ret = bt_adapter_le_enable();
+ dts_check_eq("bt_adapter_le_enable", ret,
+ BT_ERROR_NOT_INITIALIZED,
+ "BT_ERROR_NOT_INITIALIZED must be returned.");
+}
+
+static void utc_network_bluetooth_adapter_le_disable_n(void)
+{
+ int ret = BT_ERROR_NONE;
+
+ ret = bt_adapter_le_disable();
+ dts_check_eq("bt_adapter_disable", ret, BT_ERROR_NOT_ENABLED,
+ "BT_ERROR_NOT_ENABLED must be returned when BT is disabled");
+}
+
+static void utc_network_bluetooth_adapter_get_le_state_n(void)
+{
+ int ret = BT_ERROR_NONE;
+
+ ret = bt_adapter_le_get_state(NULL);
+ dts_check_eq("bt_adapter_get_state", ret, BT_ERROR_INVALID_PARAMETER,
+ "BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL.");
+}
+
+static void utc_network_bluetooth_adapter_unset_le_state_changed_cb_n(void)
+{
+ int ret = BT_ERROR_NONE;
+
+ ret = bt_adapter_le_unset_state_changed_cb();
+ dts_check_eq("bt_adapter_unset_state_changed_cb", ret,
+ BT_ERROR_NOT_INITIALIZED,
+ "BT_ERROR_NOT_INITIALIZED must be returned");
+}
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+#include <tet_api.h>
+#include <bluetooth.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <glib.h>
+#include <time.h>
+
+#define CONFIG_FILE_PATH "/opt/home/capi-network-bluetooth/tetware.conf"
+
+enum {
+ POSITIVE_TC_IDX = 0x01,
+ NEGATIVE_TC_IDX,
+};
+
+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.");
+}
--- /dev/null
+/*
+ * utc_network_bluetooth_audio_negative.c
+ *
+ * Created on: 19-Sep-2013
+ * Author: mrinal.m
+ */
+
+#include <tet_api.h>
+#include <bluetooth.h>
+#include <glib.h>
+
+enum {
+ POSITIVE_TC_IDX = 0x01,
+ NEGATIVE_TC_IDX,
+};
+
+static void startup(void);
+static void cleanup(void);
+
+static GMainLoop *mainloop;
+
+void (*tet_startup) (void) = startup;
+void (*tet_cleanup) (void) = cleanup;
+
+static void utc_network_bluetooth_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.");
+
+}
--- /dev/null
+/*
+ * utc_network_bluetooth_audio_positive.c
+ *
+ * Created on: 19-Sep-2013
+ * Author: mrinal.m
+ */
+
+#include <tet_api.h>
+#include <bluetooth.h>
+#include <glib.h>
+
+#define CONFIG_FILE_PATH "/opt/home/capi-network-bluetooth/tetware.conf"
+
+enum {
+ POSITIVE_TC_IDX = 0x01,
+ NEGATIVE_TC_IDX,
+};
+
+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.");
+}
--- /dev/null
+/*
+ * utc_network_bluetooth_avrcp_negative.c
+ *
+ * Created on: 20-Sep-2013
+ * Author: mrinal.m
+ */
+
+#include "bluetooth.h"
+#include <tet_api.h>
+#include <glib.h>
+
+enum {
+ POSITIVE_TC_IDX = 0x01,
+ NEGATIVE_TC_IDX,
+};
+
+static void startup(void);
+static void cleanup(void);
+
+void (*tet_startup) (void) = startup;
+void (*tet_cleanup) (void) = cleanup;
+
+const char target_name[128] = "dts_test";
+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.");
+
+}
--- /dev/null
+/*
+ * utc_network_bluetooth_avrcp_positive.c
+ *
+ * Created on: 20-Sep-2013
+ * Author: mrinal.m
+ */
+
+#include <bluetooth.h>
+#include <tet_api.h>
+#include <glib.h>
+
+enum {
+ POSITIVE_TC_IDX = 0x01,
+ NEGATIVE_TC_IDX,
+};
+
+static void startup(void);
+static void cleanup(void);
+
+static GMainLoop *mainloop;
+
+void (*tet_startup) (void) = startup;
+void (*tet_cleanup) (void) = cleanup;
+
+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.");
+
+}
+
--- /dev/null
+/*
+ * utc_network_bluetooth_common_negative.c
+ *
+ * Created on: 20-Sep-2013
+ * Author: mrinal.m
+ */
+
+#include "bluetooth.h"
+#include <tet_api.h>
+#include <glib.h>
+
+enum {
+ POSITIVE_TC_IDX = 0x01,
+ NEGATIVE_TC_IDX,
+};
+
+static void startup(void);
+static void cleanup(void);
+
+static GMainLoop *mainloop;
+void (*tet_startup) (void) = startup;
+void (*tet_cleanup) (void) = cleanup;
+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)
+{
+
+}
--- /dev/null
+/*
+ * utc_network_bluetooth_common_positive.c
+ *
+ * Created on: 20-Sep-2013
+ * Author: mrinal.m
+ */
+
+#include <bluetooth.h>
+#include <tet_api.h>
+#include <glib.h>
+
+enum {
+ POSITIVE_TC_IDX = 0x01,
+ NEGATIVE_TC_IDX,
+};
+
+static void startup(void);
+static void cleanup(void);
+
+static GMainLoop *mainloop;
+
+void (*tet_startup) (void) = startup;
+void (*tet_cleanup) (void) = cleanup;
+
+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.");
+
+}
+
+
+
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <tet_api.h>
+#include <bluetooth.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <glib.h>
+
+enum {
+ POSITIVE_TC_IDX = 0x01,
+ NEGATIVE_TC_IDX,
+};
+
+static GMainLoop *mainloop;
+gboolean timeout_func(gpointer data);
+
+static void startup(void);
+static void cleanup(void);
+
+void (*tet_startup) (void) = startup;
+void (*tet_cleanup) (void) = cleanup;
+
+static void utc_network_bluetooth_device_discovery_cancel_n(void);
+static void utc_network_bluetooth_device_discovery_unset_state_changed_cb_n(void);
+static void utc_network_bluetooth_device_discovery_set_state_changed_cb_n(void);
+static void utc_network_bluetooth_device_discovery_start_n(void);
+static void utc_network_bluetooth_device_discovery_get_status_n(void);
+
+void adapter_state_changed_cb_for_discovery_n(int result,
+ bt_adapter_state_e adapter_state,
+ void *user_data);
+
+struct tet_testlist tet_testlist[] = {
+ {utc_network_bluetooth_device_discovery_cancel_n, NEGATIVE_TC_IDX},
+ {utc_network_bluetooth_device_discovery_set_state_changed_cb_n, NEGATIVE_TC_IDX},
+ {utc_network_bluetooth_device_discovery_get_status_n, NEGATIVE_TC_IDX},
+ {utc_network_bluetooth_device_discovery_start_n, NEGATIVE_TC_IDX},
+ {utc_network_bluetooth_device_discovery_unset_state_changed_cb_n, NEGATIVE_TC_IDX},
+ {NULL, 0},
+};
+
+static void startup(void)
+{
+ int ret = BT_ERROR_NONE;
+ int timeout_id = 0;
+
+ /* start of TC */
+ mainloop = g_main_loop_new(NULL, FALSE);
+
+ bt_initialize();
+ if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_discovery_n, "startup") != BT_ERROR_NONE) {
+ tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed");
+ }
+
+ tet_printf("bt_adapter_disable() was called.");
+ ret = bt_adapter_disable();
+ if (ret == BT_ERROR_NONE) {
+ tet_printf("bt_adapter_disable() succeeded.");
+ timeout_id = g_timeout_add(60000, timeout_func, mainloop);
+ g_main_loop_run(mainloop);
+ g_source_remove(timeout_id);
+ } else if (ret == BT_ERROR_NOT_ENABLED) {
+ tet_printf("Bluetooth adapter is not enabled.");
+ } else {
+ tet_printf("DTS may fail because bt_adapter_disable() failed");
+ }
+
+ if (bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE) {
+ tet_printf("bt_adapter_set_state_changed_cb() failed.");
+ }
+
+ tet_printf("TC start");
+}
+
+static void cleanup(void)
+{
+ /* end of TC */
+ bt_deinitialize();
+ tet_printf("TC end");
+}
+
+gboolean timeout_func(gpointer data)
+{
+ tet_printf("Callback: Timeout.");
+ g_main_loop_quit((GMainLoop *) data);
+ return FALSE;
+}
+
+/**
+ * @brief Callback funtions
+ */
+void adapter_state_changed_cb_for_discovery_n(int result,
+ bt_adapter_state_e adapter_state,
+ void *user_data)
+{
+ tet_printf("Callback: bt_adapter_state_changed_cb was called.");
+ if (user_data != NULL && !strcmp((char *)user_data, "startup")) {
+ if (adapter_state == BT_ADAPTER_DISABLED &&
+ result == BT_ERROR_NONE) {
+ tet_printf("Callback: BT was disabled. DTS will be started.");
+ } else {
+ tet_printf("Callback: BT was not disabled. DTS will be started but DTS may fail.");
+ }
+
+ if (mainloop) {
+ g_main_loop_quit(mainloop);
+ }
+ }
+}
+
+/**
+ *@brief Negative test case of bt_adapter_stop_device_discovery()
+ */
+static void utc_network_bluetooth_device_discovery_cancel_n(void)
+{
+ int ret = bt_adapter_stop_device_discovery();
+
+ dts_check_eq("bt_adapter_stop_device_discovery", ret,
+ BT_ERROR_NOT_ENABLED,
+ "BT_ERROR_NOT_ENABLED must be returned when BT is not enabled");
+}
+
+/**
+ *@brief Negative test case of bt_adapter_unset_device_discovery_state_changed_cb()
+ */
+static void utc_network_bluetooth_device_discovery_unset_state_changed_cb_n(void)
+{
+ int ret = BT_ERROR_NONE;
+
+ if (bt_deinitialize() != BT_ERROR_NONE) {
+ dts_fail("bt_adapter_unset_device_discovery_state_changed_cb",
+ "bt_deinitialize() failed.");
+ }
+ ret = bt_adapter_unset_device_discovery_state_changed_cb();
+ dts_check_eq("bt_adapter_unset_device_discovery_state_changed_cb", ret,
+ BT_ERROR_NOT_INITIALIZED,
+ "BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized.");
+}
+
+/**
+ *@brief Negative test case of bt_adapter_set_device_discovery_state_changed_cb()
+ */
+static void utc_network_bluetooth_device_discovery_set_state_changed_cb_n(void)
+{
+ int ret = BT_ERROR_NONE;
+
+ ret = bt_adapter_set_device_discovery_state_changed_cb(NULL, NULL);
+ dts_check_eq("bt_adapter_set_device_discovery_state_changed_cb", ret,
+ BT_ERROR_INVALID_PARAMETER,
+ "BT_ERROR_INVALID_PARAMETER must be returned when callback parameter is NULL");
+}
+
+/**
+ *@brief Negative test case of bt_adapter_start_device_discovery()
+ */
+static void utc_network_bluetooth_device_discovery_start_n(void)
+{
+ bt_error_e ret = BT_ERROR_NONE;
+
+ ret = bt_adapter_start_device_discovery();;
+ dts_check_eq("bt_adapter_start_device_discovery", ret,
+ BT_ERROR_NOT_ENABLED,
+ "BT_ERROR_NOT_ENABLED must be returned when BT is not enabled");
+}
+
+/**
+ *@brief Negative test case of bt_adapter_is_discovering()
+ */
+static void utc_network_bluetooth_device_discovery_get_status_n(void)
+{
+ bt_error_e ret = BT_ERROR_NONE;
+ bool status = false;
+
+ ret = bt_adapter_is_discovering(&status);
+ dts_check_eq("bt_adapter_is_discovering", ret, BT_ERROR_NOT_ENABLED,
+ "BT_ERROR_NOT_ENABLED must be returned when BT is not enabled");
+}
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <tet_api.h>
+#include <bluetooth.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <glib.h>
+
+enum {
+ POSITIVE_TC_IDX = 0x01,
+ NEGATIVE_TC_IDX,
+};
+
+static GMainLoop *mainloop;
+static bool callback_result = false;
+
+static void startup(void);
+static void cleanup(void);
+
+void (*tet_startup) (void) = startup;
+void (*tet_cleanup) (void) = cleanup;
+
+static void utc_network_bluetooth_device_discovery_get_status_p(void);
+static void utc_network_bluetooth_device_discovery_set_state_changed_cb_p(void);
+static void utc_network_bluetooth_device_discovery_start_p(void);
+static void utc_network_bluetooth_device_discovery_unset_state_changed_cb_p(void);
+static void utc_network_bluetooth_device_discovery_cancel_p(void);
+
+gboolean timeout_func(gpointer data);
+void adapter_state_changed_cb_for_discovery_p(int result,
+ bt_adapter_state_e adapter_state,
+ void *user_data);
+void device_discovery_state_changed_cb_for_discovery_p(int result,
+ bt_adapter_device_discovery_state_e discovery_state,
+ bt_adapter_device_discovery_info_s *discovery_info,
+ void *user_data);
+
+struct tet_testlist tet_testlist[] = {
+ {utc_network_bluetooth_device_discovery_get_status_p, POSITIVE_TC_IDX},
+ {utc_network_bluetooth_device_discovery_set_state_changed_cb_p, POSITIVE_TC_IDX},
+ {utc_network_bluetooth_device_discovery_start_p, POSITIVE_TC_IDX},
+ {utc_network_bluetooth_device_discovery_unset_state_changed_cb_p, POSITIVE_TC_IDX},
+ {utc_network_bluetooth_device_discovery_cancel_p, POSITIVE_TC_IDX},
+ {NULL, 0},
+};
+
+static void startup(void)
+{
+ bt_error_e ret = BT_ERROR_NONE;
+ int timeout_id = 0;
+
+ /* start of TC */
+ mainloop = g_main_loop_new(NULL, FALSE);
+
+ bt_initialize();
+
+ if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_discovery_p, "startup") != BT_ERROR_NONE) {
+ tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed.");
+ }
+
+ ret = bt_adapter_enable();
+ if (ret == BT_ERROR_NONE) {
+ tet_printf("bt_adapter_enable() succeeded.");
+ timeout_id = g_timeout_add(60000, timeout_func, mainloop);
+ g_main_loop_run(mainloop);
+ g_source_remove(timeout_id);
+ } else if (ret == BT_ERROR_ALREADY_DONE) {
+ tet_printf("BT was already enabled.");
+ } else {
+ tet_printf("DTS may fail because bt_adapter_enable() failed.");
+ }
+
+ if (bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE) {
+ tet_printf
+ ("bt_adapter_unset_device_discovery_state_changed_cb() failed.");
+ }
+
+ tet_printf("TC start");
+}
+
+static void cleanup(void)
+{
+ /* end of TC */
+ tet_printf("TC end");
+ bt_deinitialize();
+}
+
+gboolean timeout_func(gpointer data)
+{
+ tet_printf("Callback: Timeout.");
+ g_main_loop_quit((GMainLoop *) data);
+ return FALSE;
+}
+
+/**
+ * @brief Callback funtions
+ */
+void adapter_state_changed_cb_for_discovery_p(int result,
+ bt_adapter_state_e adapter_state,
+ void *user_data)
+{
+ if (user_data != NULL && !strcmp((char *)user_data, "startup")) {
+ if (adapter_state == BT_ADAPTER_ENABLED &&
+ result == BT_ERROR_NONE) {
+ tet_printf("Callback: BT was enabled.");
+ } else {
+ tet_printf("Callback: bt_adapter_state_changed_cb() was \
+ called but bt_adapter_enable() failed.");
+ }
+
+ if (mainloop) {
+ g_main_loop_quit(mainloop);
+ }
+ }
+}
+
+void device_discovery_state_changed_cb_for_discovery_p(int result,
+ bt_adapter_device_discovery_state_e discovery_state,
+ bt_adapter_device_discovery_info_s *discovery_info,
+ void *user_data)
+{
+ tet_printf("Callback: device_discovery_state_changed_cb_for_discovery_p is called");
+
+ if (discovery_state == BT_ADAPTER_DEVICE_DISCOVERY_FOUND) {
+ tet_printf("Callback: Devices were found");
+ tet_printf("Callback: Device name is %s", discovery_info->remote_name);
+ tet_printf("Callback: Service class: %x", discovery_info->bt_class.major_service_class_mask);
+ if (user_data != NULL && !strcmp((char *)user_data, "start")) {
+ callback_result = true;
+ if (mainloop) {
+ g_main_loop_quit(mainloop);
+ }
+ }
+ } else if (discovery_state == BT_ADAPTER_DEVICE_DISCOVERY_FINISHED) {
+ tet_printf("Callback: Device discovery finished");
+ if (user_data != NULL) {
+ if (!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");
+ }
+
+}
+
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <tet_api.h>
+#include <bluetooth.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <glib.h>
+
+enum {
+ POSITIVE_TC_IDX = 0x01,
+ NEGATIVE_TC_IDX,
+};
+
+static void startup(void);
+static void cleanup(void);
+
+static GMainLoop *mainloop;
+gboolean timeout_func(gpointer data);
+
+void (*tet_startup) (void) = startup;
+void (*tet_cleanup) (void) = cleanup;
+
+static void utc_network_bluetooth_device_set_bonded_cb_n(void);
+static void utc_network_bluetooth_device_set_unbonded_cb_n(void);
+static void utc_network_bluetooth_device_set_authorization_state_changed_cb_n(void);
+static void utc_network_bluetooth_device_cancel_bonding_n(void);
+static void utc_network_bluetooth_device_bond_n(void);
+static void utc_network_bluetooth_device_foreach_bonded_device_n(void);
+static void utc_network_bluetooth_device_set_alias_n(void);
+static void utc_network_bluetooth_device_set_authorization_n(void);
+static void utc_network_bluetooth_device_unbond_n(void);
+static void utc_network_bluetooth_device_unset_bonded_cb_n(void);
+static void utc_network_bluetooth_device_unset_unbonded_cb_n(void);
+static void utc_network_bluetooth_device_unset_authorization_state_changed_cb_n(void);
+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");
+}
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <tet_api.h>
+#include <bluetooth.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <glib.h>
+
+#define CONFIG_FILE_PATH "/opt/home/capi-network-bluetooth/tetware.conf"
+
+enum {
+ POSITIVE_TC_IDX = 0x01,
+ NEGATIVE_TC_IDX,
+};
+
+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");
+}
--- /dev/null
+/*
+ * utc_network_bluetooth_gatt_negative.c
+ *
+ * Created on: 23-Sep-2013
+ * Author: shagun.garg
+ */
+
+#include <tet_api.h>
+#include <bluetooth.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <glib.h>
+
+enum {
+ POSITIVE_TC_IDX = 0x01,
+ NEGATIVE_TC_IDX,
+};
+
+static void startup(void);
+static void cleanup(void);
+
+static GMainLoop *mainloop;
+
+void (*tet_startup) (void) = startup;
+void (*tet_cleanup) (void) = cleanup;
+
+static void utc_network_bluetooth_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.");
+}
--- /dev/null
+/*
+ * utc_network_bluetooth_gatt_positive.c
+ *
+ * Created on: 23-Sep-2013
+ * Author: shagun.garg
+ */
+
+#include <tet_api.h>
+#include <bluetooth.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <glib.h>
+
+#define CONFIG_FILE_PATH "/opt/home/capi-network-bluetooth/tetware.conf"
+
+enum {
+ POSITIVE_TC_IDX = 0x01,
+ NEGATIVE_TC_IDX,
+};
+
+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.");
+}
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <tet_api.h>
+#include <bluetooth.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <glib.h>
+
+enum {
+ POSITIVE_TC_IDX = 0x01,
+ NEGATIVE_TC_IDX,
+};
+
+static void startup(void);
+static void cleanup(void);
+
+static GMainLoop *mainloop;
+
+void (*tet_startup) (void) = startup;
+void (*tet_cleanup) (void) = cleanup;
+
+static void utc_network_bluetooth_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");
+}
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <tet_api.h>
+#include <bluetooth.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <glib.h>
+
+enum {
+ POSITIVE_TC_IDX = 0x01,
+ NEGATIVE_TC_IDX,
+};
+
+static void startup(void);
+static void cleanup(void);
+
+static GMainLoop *mainloop;
+
+void(*tet_startup)(void) = startup;
+void(*tet_cleanup)(void) = cleanup;
+
+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.");
+
+}
+
+
+
+
+
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <tet_api.h>
+#include <bluetooth.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <glib.h>
+
+enum {
+ POSITIVE_TC_IDX = 0x01,
+ NEGATIVE_TC_IDX,
+};
+
+static void startup(void);
+static void cleanup(void);
+
+static GMainLoop *mainloop;
+
+void (*tet_startup) (void) = startup;
+void (*tet_cleanup) (void) = cleanup;
+
+static void utc_network_bluetooth_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.");
+}
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <tet_api.h>
+#include <bluetooth.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <glib.h>
+
+enum {
+ POSITIVE_TC_IDX = 0x01,
+ NEGATIVE_TC_IDX,
+};
+
+static void startup(void);
+static void cleanup(void);
+
+static GMainLoop *mainloop;
+
+void (*tet_startup) (void) = startup;
+void (*tet_cleanup) (void) = cleanup;
+
+static void utc_network_bluetooth_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.");
+}
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <tet_api.h>
+#include <bluetooth.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <glib.h>
+
+enum {
+ POSITIVE_TC_IDX = 0x01,
+ NEGATIVE_TC_IDX,
+};
+
+static void startup(void);
+static void cleanup(void);
+
+static GMainLoop *mainloop;
+
+void (*tet_startup) (void) = startup;
+void (*tet_cleanup) (void) = cleanup;
+
+static void utc_network_bluetooth_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");
+}
+
+
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <tet_api.h>
+#include <bluetooth.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <glib.h>
+
+#define CONFIG_FILE_PATH "/opt/home/capi-network-bluetooth/tetware.conf"
+enum {
+ POSITIVE_TC_IDX = 0x01,
+ NEGATIVE_TC_IDX,
+};
+
+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.");
+}
--- /dev/null
+/*
+ *
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <tet_api.h>
+#include <bluetooth.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <glib.h>
+
+enum {
+ POSITIVE_TC_IDX = 0x01,
+ NEGATIVE_TC_IDX,
+};
+
+static void startup(void);
+static void cleanup(void);
+
+static GMainLoop *mainloop;
+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");
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <tet_api.h>
+#include <bluetooth.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <glib.h>
+
+enum {
+ POSITIVE_TC_IDX = 0x01,
+ NEGATIVE_TC_IDX,
+};
+
+static void startup(void);
+static void cleanup(void);
+
+static GMainLoop *mainloop;
+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");
+
+}
+
+
+
+
+
+
--- /dev/null
+/*
+ * utc_network_bluetooth_pan_negative.c
+ *
+ * Created on: 20-Sep-2013
+ * Author: mrinal.m
+ */
+
+#include "bluetooth.h"
+#include <tet_api.h>
+#include <glib.h>
+
+enum {
+ POSITIVE_TC_IDX = 0x01,
+ NEGATIVE_TC_IDX,
+};
+
+static void startup(void);
+static void cleanup(void);
+
+static GMainLoop *mainloop;
+
+void (*tet_startup) (void) = startup;
+void (*tet_cleanup) (void) = cleanup;
+
+static void utc_network_bluetooth_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.");
+
+}
--- /dev/null
+/*
+ * utc_network_bluetooth_pan_positive.c
+ *
+ * Created on: 20-Sep-2013
+ * Author: mrinal.m
+ */
+
+#include <bluetooth.h>
+#include <tet_api.h>
+#include <glib.h>
+
+enum {
+ POSITIVE_TC_IDX = 0x01,
+ NEGATIVE_TC_IDX,
+};
+
+static void startup(void);
+static void cleanup(void);
+
+static GMainLoop *mainloop;
+
+void (*tet_startup) (void) = startup;
+void (*tet_cleanup) (void) = cleanup;
+
+static void utc_network_bluetooth_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.");
+
+}
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <tet_api.h>
+#include <bluetooth.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <glib.h>
+
+enum {
+ POSITIVE_TC_IDX = 0x01,
+ NEGATIVE_TC_IDX,
+};
+
+static void startup(void);
+static void cleanup(void);
+
+static GMainLoop *mainloop;
+
+void (*tet_startup) (void) = startup;
+void (*tet_cleanup) (void) = cleanup;
+
+static void utc_network_bluetooth_service_search_set_cb_n(void);
+static void utc_network_bluetooth_service_search_unset_cb_n(void);
+static void utc_network_bluetooth_service_search_n(void);
+static void utc_network_bluetooth_service_search_cancel_n(void);
+
+void adapter_state_changed_cb_for_service_search_n(int result,
+ bt_adapter_state_e adapter_state,
+ void *user_data);
+gboolean timeout_func(gpointer data);
+
+struct tet_testlist tet_testlist[] = {
+ {utc_network_bluetooth_service_search_set_cb_n, NEGATIVE_TC_IDX},
+ {utc_network_bluetooth_service_search_n, NEGATIVE_TC_IDX},
+ {utc_network_bluetooth_service_search_cancel_n, NEGATIVE_TC_IDX},
+ {utc_network_bluetooth_service_search_unset_cb_n, NEGATIVE_TC_IDX},
+ {NULL, 0},
+};
+
+static void startup(void)
+{
+ int ret = BT_ERROR_NONE;
+ int timeout_id = 0;
+
+ /* start of TC */
+ mainloop = g_main_loop_new(NULL, FALSE);
+
+ bt_initialize();
+ if (bt_adapter_set_state_changed_cb(adapter_state_changed_cb_for_service_search_n, "startup") != BT_ERROR_NONE) {
+ tet_printf("DTS may fail because bt_adapter_set_state_changed_cb() failed");
+ }
+
+ tet_printf("bt_adapter_disable() was called.");
+ ret = bt_adapter_disable();
+ if (ret == BT_ERROR_NONE) {
+ tet_printf("bt_adapter_disable() succeeded.");
+ timeout_id = g_timeout_add(60000, timeout_func, mainloop);
+ g_main_loop_run(mainloop);
+ g_source_remove(timeout_id);
+ } else if (ret == BT_ERROR_NOT_ENABLED) {
+ tet_printf("Bluetooth adapter is not enabled.");
+ } else {
+ tet_printf("DTS may fail because bt_adapter_disable() failed");
+ }
+
+ if (bt_adapter_unset_state_changed_cb() != BT_ERROR_NONE) {
+ tet_printf("bt_adapter_set_state_changed_cb() failed.");
+ }
+
+ tet_printf("TC start");
+}
+
+
+static void cleanup(void)
+{
+ /* end of TC */
+ bt_deinitialize();
+ tet_printf("TC end.");
+}
+
+
+gboolean timeout_func(gpointer data)
+{
+ tet_printf("Callback: Timeout.");
+ g_main_loop_quit((GMainLoop *) data);
+ return FALSE;
+}
+
+
+/**
+ * @brief Callback funtions
+ */
+void adapter_state_changed_cb_for_service_search_n(int result,
+ bt_adapter_state_e adapter_state,
+ void *user_data)
+{
+ tet_printf("Callback: bt_adapter_state_changed_cb was called.");
+ if (user_data != NULL && !strcmp((char *)user_data, "startup")) {
+ if (adapter_state == BT_ADAPTER_DISABLED && result == BT_ERROR_NONE) {
+ tet_printf("Callback: BT was disabled. DTS will be started.");
+ } else {
+ tet_printf("Callback: BT was not disabled. DTS will be started but DTS may fail.");
+ }
+
+ if (mainloop) {
+ g_main_loop_quit(mainloop);
+ }
+ }
+}
+
+/**
+ * @brief Negative test case of bt_device_set_service_searched_cb()
+ */
+static void utc_network_bluetooth_service_search_set_cb_n(void)
+{
+ int ret = BT_ERROR_NONE;
+
+ ret = bt_device_set_service_searched_cb(NULL, NULL);
+ dts_check_eq("bt_device_set_service_searched_cb", ret,
+ BT_ERROR_INVALID_PARAMETER,
+ "BT_ERROR_INVALID_PARAMETER must be returned when callback parameter is NULL");
+}
+
+/**
+ * @brief Negative test case of bt_device_unset_service_searched_cb()
+ */
+static void utc_network_bluetooth_service_search_unset_cb_n(void)
+{
+ int ret = BT_ERROR_NONE;
+
+ if (bt_deinitialize() != BT_ERROR_NONE) {
+ dts_fail("bt_device_unset_service_searched_cb",
+ "bt_deinitialize() failed.");
+ }
+
+ ret = bt_device_unset_service_searched_cb();
+ dts_check_eq("bt_device_unset_service_searched_cb", ret,
+ BT_ERROR_NOT_INITIALIZED,
+ "BT_ERROR_NOT_INITIALIZED must be returned when BT service is not initialized.");
+}
+
+/**
+ * @brief Negative test case of bt_device_start_service_search()
+ */
+static void utc_network_bluetooth_service_search_n(void)
+{
+ int ret = BT_ERROR_NONE;
+
+ ret = bt_device_start_service_search(NULL);
+ dts_check_eq("bt_device_start_service_search", ret,
+ BT_ERROR_INVALID_PARAMETER,
+ "BT_ERROR_INVALID_PARAMETER must be returned when parameter is NULL");
+}
+
+/**
+ * @brief Negative test case of bt_device_cancel_service_search()
+ */
+static void utc_network_bluetooth_service_search_cancel_n(void)
+{
+ int ret = BT_ERROR_NONE;
+
+ ret = bt_device_cancel_service_search();
+ dts_check_eq("bt_device_cancel_service_search", ret, BT_ERROR_NOT_ENABLED,
+ "BT_ERROR_NOT_ENABLED must be returned when BT is not enabled");
+}
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <tet_api.h>
+#include <bluetooth.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <glib.h>
+
+#define CONFIG_FILE_PATH "/opt/home/capi-network-bluetooth/tetware.conf"
+enum {
+ POSITIVE_TC_IDX = 0x01,
+ NEGATIVE_TC_IDX,
+};
+
+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.");
+}
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <tet_api.h>
+#include <bluetooth.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <glib.h>
+
+enum {
+ POSITIVE_TC_IDX = 0x01,
+ NEGATIVE_TC_IDX,
+};
+
+static void startup(void);
+static void cleanup(void);
+
+static GMainLoop *mainloop;
+
+void (*tet_startup) (void) = startup;
+void (*tet_cleanup) (void) = cleanup;
+
+static void utc_network_bluetooth_socket_set_data_received_cb_n(void);
+static void utc_network_bluetooth_socket_set_connection_state_changed_cb_n(void);
+static void utc_network_bluetooth_socket_unset_data_received_cb_n(void);
+static void utc_network_bluetooth_socket_unset_connection_state_changed_cb_n(void);
+static void utc_network_bluetooth_socket_create_rfcomm_n(void);
+static void utc_network_bluetooth_socket_destroy_rfcomm_n(void);
+static void utc_network_bluetooth_socket_listen_and_accept_rfcomm_n(void);
+static void utc_network_bluetooth_socket_connect_rfcomm_n(void);
+static void utc_network_bluetooth_socket_disconnect_rfcomm_n(void);
+static void utc_network_bluetooth_socket_send_data_n(void);
+
+void adapter_state_changed_cb_for_device_negative(int result,
+ bt_adapter_state_e adapter_state, void *user_data);
+gboolean timeout_func(gpointer data);
+
+struct tet_testlist tet_testlist[] = {
+ {utc_network_bluetooth_socket_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");
+}
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <tet_api.h>
+#include <bluetooth.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <glib.h>
+
+#define CONFIG_FILE_PATH "/opt/home/capi-network-bluetooth/tetware.conf"
+
+enum {
+ POSITIVE_TC_IDX = 0x01,
+ NEGATIVE_TC_IDX,
+};
+
+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.");
+}
--- /dev/null
+all
+ ^TEST
+##### Scenarios for TEST #####
+
+# Test scenario
+TEST
+ :include:/testcase/tslist
--- /dev/null
+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?
--- /dev/null
+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
--- /dev/null
+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 ?
--- /dev/null
+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
+
--- /dev/null
+<manifest>
+ <define>
+ <domain name="capi-network-bluetooth-test"/>
+ <request>
+ <smack request="bt-service::public" type="w"/>
+ <smack request="bt-service::platform" type="rw"/>
+ </request>
+ </define>
+ <request>
+ <domain name="capi-network-bluetooth-test"/>
+ </request>
+</manifest>
--- /dev/null
+<manifest>
+ <request>
+ <domain name="_"/>
+ </request>
+</manifest>
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+#ifndef __TIZEN_NETWORK_BLUETOOTH_DOC_H__
+#define __TIZEN_NETWORK_BLUETOOTH_DOC_H__
+
+/**
+ * @defgroup CAPI_NETWORK_BLUETOOTH_MODULE Bluetooth
+ * @brief Bluetooth Service provides API to manage Bluetooth device.
+ * @ingroup CAPI_NETWORK_FRAMEWORK
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_MODULE_HEADER Required Header
+ * \#include <bluetooth.h>
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_MODULE_OVERVIEW Overview
+ * Bluetooth Service consists of @ref CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE, @ref CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE and @ref CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE.
+ *
+ *<BR>
+ * In order to use the above APIs, you must call #bt_initialize() in advance.
+ * In addition, #bt_deinitialize() should be called when Bluetooth Service is no longer needed.
+ * Please refer Bluetooth Tutorial if you want to get more detailed usages and information of this api.
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_MODULE_FEATURE Related Features
+ * This API is related with the following features:\n
+ * - http://tizen.org/feature/network.bluetooth\n
+ *
+ * It is recommended to design feature related codes in your application for reliability.\n
+ *
+ * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE,thereby controlling the procedure of your application.\n
+ *
+ * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n
+ *
+ * More details on featuring your application can be found from <a href="../org.tizen.mobile.native.appprogramming/html/ide_sdk_tools/feature_element.htm"><b>Feature Element</b>.</a>
+ *
+ */
+
+/**
+ * @defgroup CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE Bluetooth Adapter
+ * @brief Bluetooth Adapter API provides functions for setting up Bluetooth and discovering other devices.
+ * @ingroup CAPI_NETWORK_BLUETOOTH_MODULE
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE_HEADER Required Header
+ * \#include <bluetooth.h>
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE_OVERVIEW Overview
+ * This set of function is used to control a bluetooth adapter.
+ * You can also control visibility of the device, its appearance for others (adapter name).
+ * In addition, this api is used to discover neighboring bluetooth devices.
+ * This process is asynchronous, so it is up to you to build and hold list of devices in the neighborhood
+ * - the api does not provide this list.
+ * Before starting a device discovery, you can find a device from the connected devices.
+ * This functionality is implemented by foreach loop.
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE_FEATURE Related Features
+ * This API is related with the following features:\n
+ * - http://tizen.org/feature/network.bluetooth\n
+ *
+ * It is recommended to design feature related codes in your application for reliability.\n
+ *
+ * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE,thereby controlling the procedure of your application.\n
+ *
+ * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n
+ *
+ * More details on featuring your application can be found from <a href="../org.tizen.mobile.native.appprogramming/html/ide_sdk_tools/feature_element.htm"><b>Feature Element</b>.</a>
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE_ASYNCHRONOUS_OPERATIONS Asynchronous Operations
+ * <div><table class="doxtable" >
+ * <tr>
+ * <th><b>FUNCTION</b></th>
+ * <th><b>CALLBACK</b></th>
+ * <th><b>DESCRIPTION</b></th>
+ * </tr>
+ * <tr>
+ * <td>bt_adapter_set_name()</td>
+ * <td>bt_adapter_name_changed_cb()</td>
+ * <td>Used to set adapter name. </td>
+ * </tr>
+ * <tr>
+ * <td>bt_adapter_visibility_mode_changed_cb()</td>
+ * <td>Used to set visibility mode (#bt_adapter_visibility_mode_e). </td>
+ * </tr>
+ * <tr>
+ * <td>bt_adapter_start_device_discovery()<br>
+ * bt_adapter_stop_device_discovery()</td>
+ * <td>bt_adapter_device_discovery_state_changed_cb()</td>
+ * <td>Used to start or cancel device discovery. </td>
+ * </tr>
+ *</table></div>
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE_CALLBACK_OPERATIONS Callback(Event) Operations
+ * <div><table class="doxtable" >
+ * <tr>
+ * <th><b>REGISTER</b></th>
+ * <th><b>UNREGISTER</b></th>
+ * <th><b>CALLBACK</b></th>
+ * <th><b>DESCRIPTION</b></th>
+ * </tr>
+ * <tr>
+ * <td>bt_adapter_set_state_changed_cb()</td>
+ * <td>bt_adapter_unset_state_changed_cb()</td>
+ * <td>bt_adapter_state_changed_cb()</td>
+ * <td>Used to be notified of state change (enable or disable). </td>
+ * </tr>
+ * <tr>
+ * <td>bt_adapter_set_name_changed_cb()</td>
+ * <td>bt_adapter_unset_name_changed_cb()</td>
+ * <td>bt_adapter_name_changed_cb()</td>
+ * <td>Used to be notified of name change. </td>
+ * </tr>
+ * <tr>
+ * <td>bt_adapter_set_visibility_mode_changed_cb()</td>
+ * <td>bt_adapter_unset_visibility_mode_changed_cb()</td>
+ * <td>bt_adapter_visibility_mode_changed_cb()</td>
+ * <td>Used to be notified of change of visibility mode (#bt_adapter_visibility_mode_e). </td>
+ * </tr>
+ * <tr>
+ * <td>bt_adapter_set_device_discovery_state_changed_cb()</td>
+ * <td>bt_adapter_unset_device_discovery_state_changed_cb()</td>
+ * <td>bt_adapter_device_discovery_state_changed_cb()</td>
+ * <td>Used to be notified of change of device discovery state (#bt_adapter_device_discovery_state_e). </td>
+ * </tr>
+ *</table></div>
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_ADAPTER_MODULE_FOREACH_OPERATIONS Foreach Operations
+ * <div><table class="doxtable" >
+ * <tr>
+ * <th><b>FOREACH</b></th>
+ * <th><b>CALLBACK</b></th>
+ * <th><b>DESCRIPTION</b></th>
+ * </tr>
+ * <tr>
+ * <td>bt_adapter_foreach_bonded_device()</td>
+ * <td>bt_adapter_bonded_device_cb()</td>
+ * <td>Used to get bonded devices.</td>
+ * </tr>
+ *</table></div>
+ *
+ *<BR>
+ * Please refer Bluetooth Tutorial if you want to get more detailed usages and information of this api.
+ */
+
+/**
+ * @defgroup CAPI_NETWORK_BLUETOOTH_ADAPTER_LE_MODULE Bluetooth LE Adapter
+ * @brief Bluetooth LE API provides functions for managing bonds with other devices for LE and searching for supported LE services.
+ * @ingroup CAPI_NETWORK_BLUETOOTH_MODULE
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_ADAPTER_LE_MODULE_HEADER Required Header
+ * \#include <bluetooth.h>
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE_OVERVIEW Overview
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_ADAPTER_LE_MODULE_MODULE_FEATURE Related Features
+ * This API is related with the following features:\n
+ * - http://tizen.org/feature/network.bluetooth\n
+ * - http://tizen.org/feature/network.bluetooth.le\n
+ *
+ * It is recommended to design feature related codes in your application for reliability.\n
+ *
+ * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE,thereby controlling the procedure of your application.\n
+ *
+ * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n
+ *
+ * More details on featuring your application can be found from <a href="../org.tizen.mobile.native.appprogramming/html/ide_sdk_tools/feature_element.htm"><b>Feature Element</b>.</a>
+ *
+ */
+
+/**
+ * @defgroup CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE Bluetooth Device
+ * @brief Bluetooth Device API provides functions for managing bonds with other devices and searching for supported services.
+ * @ingroup CAPI_NETWORK_BLUETOOTH_MODULE
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE_HEADER Required Header
+ * \#include <bluetooth.h>
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE_OVERVIEW Overview
+ * This set of functions is used to handle the connection with other devices.
+ * Connected devices exchange keys needed for encrypted communication,
+ * but each connection has to be approved by the latest application user.
+ * You can also set authorization of other devices.
+ * Authorized devices are connected, and it is connected automatically without the latest user
+ * being asked for authorization.
+ * In addition, this is used to search for services available on remote devices.
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE_FEATURE Related Features
+ * This API is related with the following features:\n
+ * - http://tizen.org/feature/network.bluetooth\n
+ * - http://tizen.org/feature/network.bluetooth.le\n
+ *
+ * It is recommended to design feature related codes in your application for reliability.\n
+ *
+ * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE,thereby controlling the procedure of your application.\n
+ *
+ * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n
+ *
+ * More details on featuring your application can be found from <a href="../org.tizen.mobile.native.appprogramming/html/ide_sdk_tools/feature_element.htm"><b>Feature Element</b>.</a>
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE_ASYNCHRONOUS_OPERATIONS Asynchronous Operations
+ * <div><table class="doxtable" >
+ * <tr>
+ * <th><b>FUNCTION</b></th>
+ * <th><b>CALLBACK</b></th>
+ * <th><b>DESCRIPTION</b></th>
+ * </tr>
+ * <tr>
+ * <td>bt_device_create_bond()<br>
+ * bt_device_cancel_bonding()</td>
+ * <td>bt_device_bond_created_cb()</td>
+ * <td>Used to create bond or cancel creating bond. </td>
+ * </tr>
+ * <tr>
+ * <td>bt_device_destroy_bond()</td>
+ * <td>bt_device_bond_destroyed_cb()</td>
+ * <td>Used to destroy bond. </td>
+ * </tr>
+ * <tr>
+ * <td>bt_device_set_authorization()</td>
+ * <td>bt_device_authorization_changed_cb()</td>
+ * <td>Used to set as authorized or unauthorized device. </td>
+ * </tr>
+ * <tr>
+ * <td>bt_device_start_service_search()</td>
+ * <td>bt_device_service_searched_cb()</td>
+ * <td>Used to start or cancel service search. </td>
+ * </tr>
+ *</table></div>
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_DEVICE_MODULE_CALLBACK_OPERATIONS Callback(Event) Operations
+ * <div><table class="doxtable" >
+ * <tr>
+ * <th><b>REGISTER</b></th>
+ * <th><b>UNREGISTER</b></th>
+ * <th><b>CALLBACK</b></th>
+ * <th><b>DESCRIPTION</b></th>
+ * </tr>
+ * <tr>
+ * <td>bt_device_set_bond_created_cb()</td>
+ * <td>bt_device_unset_bond_created_cb()</td>
+ * <td>bt_device_bond_created_cb()</td>
+ * <td>Used to be notified of the result of creating bond. </td>
+ * </tr>
+ * <tr>
+ * <td>bt_device_set_bond_destroyed_cb()</td>
+ * <td>bt_device_unset_bond_destroyed_cb()</td>
+ * <td>bt_device_bond_destroyed_cb()</td>
+ * <td>Used to be notified of the result of destroying bond. </td>
+ * </tr>
+ * <tr>
+ * <td>bt_device_set_authorization_changed_cb()</td>
+ * <td>bt_device_unset_authorization_changed_cb()</td>
+ * <td>bt_device_authorization_changed_cb()</td>
+ * <td>Used to be notified of change of authorization. </td>
+ * </tr>
+ * <tr>
+ * <td>bt_device_set_service_searched_cb()</td>
+ * <td>bt_device_unset_service_searched_cb()</td>
+ * <td>bt_device_service_searched_cb()</td>
+ * <td>Used to be notified of change of service search state. </td>
+ * </tr>
+ *</table></div>
+ *
+ *<BR>
+ * Please refer Bluetooth Tutorial if you want to get more detailed usages and information of this api.
+ */
+
+
+/**
+ * @defgroup CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE Bluetooth Socket
+ * @brief Bluetooth Socket API provides functions for managing connections to other devices and exchanging data.
+ * @ingroup CAPI_NETWORK_BLUETOOTH_MODULE
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE_HEADER Required Header
+ * \#include <bluetooth.h>
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE_OVERVIEW Overview
+ * This set of functions is used for exchanging data between two bluetooth
+ * devices, our device can have both roles as server (service provider) and client
+ * (service user).
+ * Depending on the role, there is difference in creating a connection.
+ * After that, processes of exchanging data and disconnection are same.
+ *
+ * To start communication, you should first register for #bt_socket_set_connection_state_changed_cb()
+ * and #bt_socket_set_data_received_cb().
+ * Next step depends on the role of your application.\n
+ * If you want to be \b server \b role, application should create socket
+ * (#bt_socket_create_rfcomm()), and start listening and accepting incoming connections
+ * (#bt_socket_listen_and_accept_rfcomm()).
+ * If you want to connect to specific device and use it's services (\a client \a role),
+ * you have to start connection with #bt_socket_connect_rfcomm() and wait for connection.\n
+ * After connection has been established (information is passed to your program with
+ * #bt_socket_connection_state_changed_cb() function call), you can exchange data by
+ * calling #bt_socket_send_data(). \n
+ * If you receive data from remote device, #bt_socket_data_received_cb() functions will be called.
+ * When you finish exchanging data, you should disconnect connection
+ * with #bt_socket_disconnect_rfcomm() and unregister callback functions (with using
+ * #bt_socket_unset_data_received_cb(), #bt_socket_unset_connection_state_changed_cb()).
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE_FEATURE Related Features
+ * This API is related with the following features:\n
+ * - http://tizen.org/feature/network.bluetooth\n
+ *
+ * It is recommended to design feature related codes in your application for reliability.\n
+ *
+ * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE,thereby controlling the procedure of your application.\n
+ *
+ * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n
+ *
+ * More details on featuring your application can be found from <a href="../org.tizen.mobile.native.appprogramming/html/ide_sdk_tools/feature_element.htm"><b>Feature Element</b>.</a>
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE_ASYNCHRONOUS_OPERATIONS Asynchronous Operations
+ * <div><table class="doxtable" >
+ * <tr>
+ * <th><b>FUNCTION</b></th>
+ * <th><b>CALLBACK</b></th>
+ * <th><b>DESCRIPTION</b></th>
+ * </tr>
+ * <tr>
+ * <td>bt_socket_listen_and_accept_rfcomm()<br>
+ * bt_socket_connect_rfcomm()</td>
+ * <td>bt_socket_connection_state_changed_cb()</td>
+ * <td>Used to connect a device. </td>
+ * </tr>
+ *</table></div>
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_SOCKET_MODULE_CALLBACK_OPERATIONS Callback(Event) Operations
+ * <div><table class="doxtable" >
+ * <tr>
+ * <th><b>REGISTER</b></th>
+ * <th><b>UNREGISTER</b></th>
+ * <th><b>CALLBACK</b></th>
+ * <th><b>DESCRIPTION</b></th>
+ * </tr>
+ * <tr>
+ * <td>bt_socket_set_data_received_cb()</td>
+ * <td>bt_socket_unset_data_received_cb()</td>
+ * <td>bt_socket_data_received_cb()</td>
+ * <td>Used to be notified of received data. </td>
+ * </tr>
+ * <tr>
+ * <td>bt_socket_set_connection_state_changed_cb()</td>
+ * <td>bt_socket_unset_connection_state_changed_cb()</td>
+ * <td>bt_socket_connection_state_changed_cb()</td>
+ * <td>Used to be notified when the state of connection changes. </td>
+ * </tr>
+ *</table></div>
+ *
+ *<BR>
+ * Please refer Bluetooth Tutorial if you want to get more detailed usages and information of this api.
+ */
+
+
+/**
+ * @defgroup CAPI_NETWORK_BLUETOOTH_OPP_MODULE Bluetooth OPP
+ * @brief Bluetooth OPP(Object Push Profile) API provides functions for exchanging objects such as pictures.
+ * @ingroup CAPI_NETWORK_BLUETOOTH_MODULE
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_OPP_MODULE_HEADER Required Header
+ * \#include <bluetooth.h>
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_OPP_MODULE_OVERVIEW Overview
+ * OPP profile let users exchange objects between two devices.
+ *
+ */
+
+/**
+ * @defgroup CAPI_NETWORK_BLUETOOTH_OPP_SERVER_MODULE Bluetooth OPP Server
+ * @brief Bluetooth OPP(Object Push Profile) Server API provides functions for accepting objects such as pictures.
+ * @ingroup CAPI_NETWORK_BLUETOOTH_OPP_MODULE
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_OPP_SERVER_MODULE_HEADER Required Header
+ * \#include <bluetooth.h>
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_OPP_SERVER_MODULE_OVERVIEW Overview
+ * This is OPP server APIs.
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_OPP_SERVER_MODULE_FEATURE Related Features
+ * This API is related with the following features:\n
+ * - http://tizen.org/feature/network.bluetooth.opp\n
+ *
+ * It is recommended to design feature related codes in your application for reliability.\n
+ *
+ * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE,thereby controlling the procedure of your application.\n
+ *
+ * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n
+ *
+ * More details on featuring your application can be found from <a href="../org.tizen.mobile.native.appprogramming/html/ide_sdk_tools/feature_element.htm"><b>Feature Element</b>.</a>
+ *
+ */
+
+/**
+ * @defgroup CAPI_NETWORK_BLUETOOTH_OPP_CLIENT_MODULE Bluetooth OPP Client
+ * @brief Bluetooth OPP(Object Push Profile) Client API provides functions for pushing objects such as pictures.
+ * @ingroup CAPI_NETWORK_BLUETOOTH_OPP_MODULE
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_OPP_CLIENT_MODULE_HEADER Required Header
+ * \#include <bluetooth.h>
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_OPP_CLIENT_MODULE_OVERVIEW Overview
+ * This is OPP Client APIs.
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_OPP_CLIENT_MODULE_FEATURE Related Features
+ * This API is related with the following features:\n
+ * - http://tizen.org/feature/network.bluetooth.opp\n
+ *
+ * It is recommended to design feature related codes in your application for reliability.\n
+ *
+ * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE,thereby controlling the procedure of your application.\n
+ *
+ * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n
+ *
+ * More details on featuring your application can be found from <a href="../org.tizen.mobile.native.appprogramming/html/ide_sdk_tools/feature_element.htm"><b>Feature Element</b>.</a>
+ *
+ */
+
+/**
+ * @internal
+ * @defgroup CAPI_NETWORK_BLUETOOTH_PAN_MODULE Bluetooth PAN
+ * @brief Bluetooth PAN(Personal Area Networking) API provides functions for connecting to a higher level network and the Internet.
+ * @ingroup CAPI_NETWORK_BLUETOOTH_MODULE
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_PAN_MODULE_OVERVIEW Overview
+ * The PAN Profile describe how two or more Bluetooth enabled devices can form an ad-hoc network and how the same mechanism can be
+ * used to access a remote network through a network access point. But this API only supports network access point service.
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_PAN_MODULE_FEATURE Related Features
+ * This API is related with the following features:\n
+ * - http://tizen.org/feature/network.tethering.bluetooth\n
+ *
+ * It is recommended to design feature related codes in your application for reliability.\n
+ *
+ * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE,thereby controlling the procedure of your application.\n
+ *
+ * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n
+ *
+ * More details on featuring your application can be found from <a href="../org.tizen.mobile.native.appprogramming/html/ide_sdk_tools/feature_element.htm"><b>Feature Element</b>.</a>
+ *
+ */
+
+/**
+ * @internal
+ * @defgroup CAPI_NETWORK_BLUETOOTH_PAN_NAP_MODULE Bluetooth NAP
+ * @brief Bluetooth NAP(Network Access Point) API provides functions for an Ethernet bridge to support network services.
+ * @ingroup CAPI_NETWORK_BLUETOOTH_PAN_MODULE
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_PAN_NAP_MODULE_HEADER Required Header
+ * \#include <bluetooth.h>
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_PAN_NAP_MODULE_OVERVIEW Overview
+ * A Bluetooth device that supports the NAP service is a Bluetooth device that provides some of the features of an Ethernet bridge to support network services.
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_PAN_NAP_MODULE_FEATURE Related Features
+ * This API is related with the following features:\n
+ * - http://tizen.org/feature/network.tethering.bluetooth\n
+ *
+ * It is recommended to design feature related codes in your application for reliability.\n
+ *
+ * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE, thereby controlling the procedure of your application.\n
+ *
+ * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n
+ *
+ * More details on featuring your application can be found from <a href="../org.tizen.mobile.native.appprogramming/html/ide_sdk_tools/feature_element.htm"><b>Feature Element</b>.</a>
+ *
+ */
+
+/**
+ * @internal
+ * @defgroup CAPI_NETWORK_BLUETOOTH_PAN_PANU_MODULE Bluetooth PANU
+ * @brief Bluetooth PANU(Personal Area Networking User) API provides functions for client of both the NAP(Network Access Point).
+ * @ingroup CAPI_NETWORK_BLUETOOTH_PAN_MODULE
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_PAN_PANU_MODULE_HEADER Required Header
+ * \#include <bluetooth.h>
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_PAN_PANU_MODULE_OVERVIEW Overview
+ * In PAN Profile, PANU can uses either the NAP or GN service, but this API only supports NAP service.
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_PAN_PANU_MODULE_FEATURE Related Features
+ * This API is related with the following features:\n
+ * - http://tizen.org/feature/network.tethering.bluetooth\n
+ *
+ * It is recommended to design feature related codes in your application for reliability.\n
+ *
+ * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE, thereby controlling the procedure of your application.\n
+ *
+ * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n
+ *
+ * More details on featuring your application can be found from <a href="../org.tizen.mobile.native.appprogramming/html/ide_sdk_tools/feature_element.htm"><b>Feature Element</b>.</a>
+ *
+ */
+
+/**
+ * @defgroup CAPI_NETWORK_BLUETOOTH_HID_MODULE Bluetooth HID
+ * @brief Bluetooth HID(Human Interface Device) API provides functions for connecting to Bluetooth HID such as keyboards and mouse.
+ * @ingroup CAPI_NETWORK_BLUETOOTH_MODULE
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_HID_MODULE_HEADER Required Header
+ * \#include <bluetooth.h>
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_HID_MODULE_OVERVIEW Overview
+ * In HID Profile, there are two roles - @a Host and @a Device.
+ * The @a Host is a device that uses or requests the services of a HID. The @a Device is a device that provides the service of human data input and output to and from the @a Host.
+ * This API only supports @a Host role.
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_HID_MODULE_FEATURE Related Features
+ * This API is related with the following features:\n
+ * - http://tizen.org/feature/network.bluetooth.hid\n
+ *
+ * It is recommended to design feature related codes in your application for reliability.\n
+ *
+ * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE, thereby controlling the procedure of your application.\n
+ *
+ * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n
+ *
+ * More details on featuring your application can be found from <a href="../org.tizen.mobile.native.appprogramming/html/ide_sdk_tools/feature_element.htm"><b>Feature Element</b>.</a>
+ *
+ */
+
+/**
+ * @defgroup CAPI_NETWORK_BLUETOOTH_AUDIO_MODULE Bluetooth Audio
+ * @brief Bluetooth Audio API provides functions for connecting to Bluetooth audio devices such as headset, hand-free and headphone.
+ * @ingroup CAPI_NETWORK_BLUETOOTH_MODULE
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_AUDIO_MODULE_HEADER Required Header
+ * \#include <bluetooth.h>
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_AUDIO_MODULE_OVERVIEW Overview
+ * This API supports the HFP(Hands-Free Profile), HSP(Headset Profile) and A2DP(Advanced Audio Distribution Profile).
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_AUDIO_MODULE_FEATURE Related Features
+ * This API is related with the following features:\n
+ * - http://tizen.org/feature/network.bluetooth.audio.call\n
+ * - http://tizen.org/feature/network.bluetooth.audio.media\n
+ *
+ * It is recommended to design feature related codes in your application for reliability.\n
+ *
+ * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE, thereby controlling the procedure of your application.\n
+ *
+ * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n
+ *
+ * More details on featuring your application can be found from <a href="../org.tizen.mobile.native.appprogramming/html/ide_sdk_tools/feature_element.htm"><b>Feature Element</b>.</a>
+ *
+ */
+
+/**
+ * @internal
+ * @defgroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE Bluetooth AG
+ * @brief Bluetooth AG(Audio Gateway) API provides functions for controling the remote audio device.
+ * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_MODULE
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE_HEADER Required Header
+ * \#include <bluetooth.h>
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE_OVERVIEW Overview
+ * This API supports the @a Audio @a Gateway role in HSP and HFP.
+ * Audio Gateway is the devie that is the gateway of the audio, both for input and output, typically a mobile phone or PC.
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE_FEATURE Related Features
+ * This API is related with the following features:\n
+ * - http://tizen.org/feature/network.bluetooth.audio.call\n
+ * - http://tizen.org/feature/network.bluetooth.audio.media\n
+ *
+ * It is recommended to design feature related codes in your application for reliability.\n
+ *
+ * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE, thereby controlling the procedure of your application.\n
+ *
+ * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n
+ *
+ * More details on featuring your application can be found from <a href="../org.tizen.mobile.native.appprogramming/html/ide_sdk_tools/feature_element.htm"><b>Feature Element</b>.</a>
+ *
+ */
+
+/**
+ * @internal
+ * @defgroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_CALL_MODULE Call List
+ * @brief Bluetooth AG(Audio Gateway) API provides functions for managing the handler of call list.
+ * @ingroup CAPI_NETWORK_BLUETOOTH_AUDIO_AG_MODULE
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_AUDIO_AG_CALL_MODULE_HEADER Required Header
+ * \#include <bluetooth.h>
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_AUDIO_AG_CALL_OVERVIEW Overview
+ * This set of functions is used for managing the handler of call list.
+ * This handler is used for notifying the call list to the remote bluetooth device which supports HFP(Hands-Free Profile).
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_AUDIO_AG_CALL_MODULE_FEATURE Related Features
+ * This API is related with the following features:\n
+ * - http://tizen.org/feature/network.bluetooth.audio.call\n
+ * - http://tizen.org/feature/network.bluetooth.audio.media\n
+ *
+ * It is recommended to design feature related codes in your application for reliability.\n
+ *
+ * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE, thereby controlling the procedure of your application.\n
+ *
+ * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n
+ *
+ * More details on featuring your application can be found from <a href="../org.tizen.mobile.native.appprogramming/html/ide_sdk_tools/feature_element.htm"><b>Feature Element</b>.</a>
+ *
+ */
+
+/**
+ * @internal
+ * @defgroup CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE Bluetooth AVRCP
+ * @brief Bluetooth AVRCP(Audio/Video Remote Control Profile) API provides functions for notifying the change of target device to the control device.
+ * @ingroup CAPI_NETWORK_BLUETOOTH_MODULE
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE_HEADER Required Header
+ * \#include <bluetooth.h>
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_AVRCP_MODULE_OVERVIEW Overview
+ * This API supports the @a Target role in AVRCP spec.
+ * The @a Target is the device whose characteristics are being altered.
+ * In a "walkman" type media player scenario, the @a Control device may be a headset that allows tracks to be skipped and the @a Target device would be the actual medial player.
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_AVRCP__MODULE_FEATURE Related Features
+ * This API is related with the following features:\n
+ * - http://tizen.org/feature/network.bluetooth.audio.media\n
+ *
+ * It is recommended to design feature related codes in your application for reliability.\n
+ *
+ * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE, thereby controlling the procedure of your application.\n
+ *
+ * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n
+ *
+ * More details on featuring your application can be found from <a href="../org.tizen.mobile.native.appprogramming/html/ide_sdk_tools/feature_element.htm"><b>Feature Element</b>.</a>
+ *
+ */
+
+/**
+ * @defgroup CAPI_NETWORK_BLUETOOTH_HDP_MODULE Bluetooth HDP
+ * @brief Bluetooth HDP(Health Device Profile) API provides functions for managing connections to health devices and exchanging data.
+ * @ingroup CAPI_NETWORK_BLUETOOTH_MODULE
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_HDP_MODULE_HEADER Required Header
+ * \#include <bluetooth.h>
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_HDP_MODULE_OVERVIEW Overview
+ * The @a Source is a transmitter of application data that is to be transferred to a @a Sink. The @a Sink is a receiver of application data delivered from a @a Source.
+ * This API supports the @a Sink role in HDP spec.
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_HDP_MODULE_FEATURE Related Features
+ * This API is related with the following features:\n
+ * - http://tizen.org/feature/network.bluetooth.health\n
+ *
+ * It is recommended to design feature related codes in your application for reliability.\n
+ *
+ * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE, thereby controlling the procedure of your application.\n
+ *
+ * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n
+ *
+ * More details on featuring your application can be found from <a href="../org.tizen.mobile.native.appprogramming/html/ide_sdk_tools/feature_element.htm"><b>Feature Element</b>.</a>
+ *
+ */
+
+/**
+ * @defgroup CAPI_NETWORK_BLUETOOTH_GATT_MODULE Bluetooth GATT
+ * @brief Bluetooth GATT(Generic Attribute Profile) API provides functions for discovering, reading and modifying attributes.
+ * @ingroup CAPI_NETWORK_BLUETOOTH_MODULE
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_GATT_MODULE_HEADER Required Header
+ * \#include <bluetooth.h>
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_GATT_MODULE_OVERVIEW Overview
+ * Two roles are defined for devices that implement GATT.
+ * The @a Server is the device that accepts incoming commands and requests from the client and sends responses, indications and notifications to a client.
+ * The @a Client is the device that initiates commands and requests towards the server and can receive responses, indications and notifications sent by the server.
+ * This API supports the @a Client role in GATT.
+ *
+ * @section CAPI_NETWORK_BLUETOOTH_GATT_MODULE_FEATURE Related Features
+ * This API is related with the following features:\n
+ * - http://tizen.org/feature/network.bluetooth.le\n
+ *
+ * It is recommended to design feature related codes in your application for reliability.\n
+ *
+ * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE, thereby controlling the procedure of your application.\n
+ *
+ * To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n
+ *
+ * More details on featuring your application can be found from <a href="../org.tizen.mobile.native.appprogramming/html/ide_sdk_tools/feature_element.htm"><b>Feature Element</b>.</a>
+ *
+ */
+
+#endif /* __TIZEN_NETWORK_BLUETOOTH_DOC_H__ */
/*
- * 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.
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;
/**
*/
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.
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;
/**
+#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
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
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
%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
%{_includedir}/network/bluetooth_type.h
%{_libdir}/pkgconfig/capi-network-bluetooth.pc
%{_libdir}/libcapi-network-bluetooth.so
+%{_datadir}/license/capi-network-bluetooth-devel
/*
- * 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.
#include <dlog.h>
#include <stdio.h>
#include <stdbool.h>
+#ifdef TIZEN_WEARABLE
+#include <privacy_checker_client.h>
+#endif
#include <bluetooth-api.h>
#include "bluetooth.h"
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());
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());
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());
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);
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();
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);
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);
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)
}
if (dev_list != NULL) {
+ g_ptr_array_foreach(dev_list, (GFunc)g_free, NULL);
g_ptr_array_free(dev_list, TRUE);
}
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);
*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) {
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)
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)
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)
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)
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));
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());
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;
}
/*
- * 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.
#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.*/
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;
}
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)
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)
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) {
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) {
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;
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;
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);
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)
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;
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);
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 {
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;
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;
}
/*
- * 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.
#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.*/
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)
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);
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);
{
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);
{
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);
{
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);
{
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);
{
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);
{
int error;
BT_CHECK_INIT_STATUS();
+ BT_CHECK_AVRCP_TARGET_INIT_STATUS();
media_metadata_attributes_t metadata;
metadata.title = title;
metadata.artist = artist;
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;
}
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;
}
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;
}
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;
}
/*
- * 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.
#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},
{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
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;
}
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)
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;
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:
(*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]);
}
(*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;
}
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;
}
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++) {
{
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);
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;
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;
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) {
((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)
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");
(_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));
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");
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);
(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;
(*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;
}
}
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;
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:
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:
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;
}
/*
- * 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.
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)
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);
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)
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;
}
/*
- * 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.
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,
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,
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;
}
/*
- * 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.
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);
/*
- * 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.
#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)
{
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()
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)
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);
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);
/*
- * 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.
#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)
{
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)
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)
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);
}
char *c_file = NULL;
BT_CHECK_INIT_STATUS();
+ BT_CHECK_OPP_CLIENT_INIT_STATUS();
if (sending_files) {
file_num = g_list_length(sending_files);
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);
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());
/*
- * 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.
#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)
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,
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)
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());
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,
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);
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());
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));
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) {
/*
- * 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.
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(
/*
- * 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.
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)
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;
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/)
/*
- * 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.
#ifdef LOG_TAG
#undef LOG_TAG
#endif
-#define LOG_TAG "BT_CHAT_CLIENT"
+#define LOG_TAG "BLUETOOTH_CHAT_CLIENT"
/**
* Variables
/*
- * 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.
#ifdef LOG_TAG
#undef LOG_TAG
#endif
-#define LOG_TAG "BT_CHAT_SERVER"
+#define LOG_TAG "BLUETOOTH_CHAT_SERVER"
/**
* Variables
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an AS IS BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @file bt_onoff.c
+ * @brief This is the source file for bt activation/deactivation.
+ */
+
+#include <stdio.h>
+#include <glib.h>
+
+#include "bluetooth.h"
+
+#define PRT(format, args...) printf("%s:%d() "format, __FUNCTION__, __LINE__, ##args)
+#define TC_PRT(format, args...) PRT(format"\n", ##args)
+
+GMainLoop *main_loop = NULL;
+static guint onoff_timer = 0;
+
+static void __bt_adapter_state_changed_cb(int result, bt_adapter_state_e adapter_state, void *user_data)
+{
+ TC_PRT("state(%d), error(%d)", adapter_state, result);
+
+ if (onoff_timer)
+ g_source_remove(onoff_timer);
+ onoff_timer = 0;
+
+ if (result != BT_ERROR_NONE) {
+ char *argv[] = {NULL};
+ execv("all_log_dump.sh", argv);
+ }
+
+ if (main_loop)
+ g_main_loop_quit(main_loop);
+ else
+ exit(0);
+}
+
+static gboolean __bt_onoff_timeout_cb(gpointer data)
+{
+ TC_PRT("Timed out");
+
+ char *argv[] = {NULL};
+ execv("all_log_dump.sh", argv);
+
+ if (main_loop)
+ g_main_loop_quit(main_loop);
+ else
+ exit(0);
+
+ return FALSE;
+}
+
+int main(int argc, char* argv[])
+{
+ int ret;
+ bt_adapter_state_e state;
+
+ if(bt_initialize() != BT_ERROR_NONE)
+ {
+ TC_PRT("bt_initialize() failed.");
+ return -1;
+ }
+ if (bt_adapter_set_state_changed_cb(__bt_adapter_state_changed_cb, NULL) != BT_ERROR_NONE)
+ {
+ TC_PRT("bt_adapter_set_state_changed_cb() failed.");
+ goto DONE;
+ }
+
+ main_loop = g_main_loop_new(NULL, FALSE);
+
+ bt_adapter_get_state(&state);
+ ret = bt_adapter_get_state(&state);
+ TC_PRT("state(%d), error(%d)", state, ret);
+
+ onoff_timer = g_timeout_add(20000, (GSourceFunc)__bt_onoff_timeout_cb, NULL);
+
+ if (argc <= 1) {
+ if (state == BT_ADAPTER_DISABLED)
+ ret = bt_adapter_enable();
+ else
+ ret = bt_adapter_disable();
+ TC_PRT("bt_adapter_%s() error(%d)", state==BT_ADAPTER_DISABLED?"enable":"disable", ret);
+ } else {
+ if (argv[1][0] == '0') {
+ if (state == BT_ADAPTER_DISABLED) {
+ TC_PRT("Already disabled");
+ goto DONE;
+ } else {
+ ret = bt_adapter_disable();
+ TC_PRT("bt_adapter_disable() error(%d)", ret);
+ if (ret != BT_ERROR_NONE)
+ goto DONE;
+ }
+ } else {
+ if (state == BT_ADAPTER_ENABLED) {
+ TC_PRT("Already eabled");
+ goto DONE;
+ } else {
+ ret = bt_adapter_enable();
+ TC_PRT("bt_adapter_enable() error(%d)", ret);
+ if (ret != BT_ERROR_NONE)
+ goto DONE;
+ }
+ }
+ }
+
+ g_main_loop_run(main_loop);
+
+DONE:
+ if (onoff_timer)
+ g_source_remove(onoff_timer);
+ onoff_timer = 0;
+ bt_adapter_unset_state_changed_cb();
+ bt_deinitialize();
+
+ return 0;
+}
/*
- * 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 <hocheol.seo@samsung.com>
+ * Girishashok Joshi <girish.joshi@samsung.com>
+ * Chanyeol Park <chanyeol.park@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
- * http://www.apache.org/licenses/LICENSE-2.0
+ * 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.
+ *
*/
/**
#include <stdio.h>
#include <string.h>
+#include <fcntl.h>
+#include <unistd.h>
#include <glib.h>
#include <dbus/dbus-glib.h>
#include "bluetooth.h"
#include "bluetooth-telephony-api.h"
-
-#define BUFFER_LEN 10
-#define MAX_SERVICES 10
-#define PRT(format, args...) printf("%s:%d() "format, __FUNCTION__, __LINE__, ##args)
-#define TC_PRT(format, args...) PRT(format"\n", ##args)
+#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)
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,
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
}
}
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) {
}
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);
}
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);
}
bool connected, const char *remote_address,
bt_audio_profile_type_e type, void *user_data)
{
+ TC_PRT("result [%s]", __bt_get_error_message(result));
TC_PRT("connected [%d]", connected);
TC_PRT("address [%s]", remote_address);
TC_PRT("type [%d]", type);
void __bt_ag_sco_state_changed_cb(int result, bool opened, void *user_data)
{
+ TC_PRT("result [%s]", __bt_get_error_message(result));
TC_PRT("opened [%s]", opened ? "YES" : "NO");
}
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)
{
}
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)
return true;
}
+void __bt_device_bond_created_cb(int result, bt_device_info_s *device_info, void *user_data)
+{
+ if(result == BT_ERROR_NONE)
+ {
+ TC_PRT("Callback: A bond with chat_server is created.");
+ TC_PRT("Callback: The number of service - %d.", device_info->service_count);
+
+ int i = 0;
+ for(i=0; i<device_info->service_count; i++) {
+ TC_PRT("Callback: service[%d] - %s", i+1, device_info->service_uuid[i]);
+ }
+ TC_PRT("Callback: is_bonded - %d.", device_info->is_bonded);
+ TC_PRT("Callback: is_connected - %d.", device_info->is_connected);
+
+ if (device_info->manufacturer_data_len > 0) {
+ TC_PRT("manufacturer specific data(len:%d)", device_info->manufacturer_data_len);
+ printf("data [");
+ for (i = 0; i < device_info->manufacturer_data_len; i++)
+ printf("%02x ", device_info->manufacturer_data[i]);
+ printf("]\n");
+ }
+ } else {
+ TC_PRT("result: %s", __bt_get_error_message(result));
+ TC_PRT("Callback: Creating a bond is failed.");
+ }
+}
+
+void __bt_gatt_connection_state_changed_cb(int result, bool connected, const char *remote_address, void *user_data)
+{
+ TC_PRT("result: %s", __bt_get_error_message(result));
+ if (connected) {
+ TC_PRT("LE connected");
+ } else {
+ TC_PRT("LE DISconnected");
+ }
+}
+
bool __bt_gatt_primary_service_cb(bt_gatt_attribute_h service, void *user_data)
{
TC_PRT("__bt_gatt_primary_service_cb");
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);
return;
}
+void __bt_gatt_char_write_cb(void *user_data)
+{
+ TC_PRT("__bt_gatt_char_write_cb");
+ return;
+}
+
+void __bt_gatt_char_read_cb(unsigned char *value, int value_length, void *user_data)
+{
+ int i;
+
+ TC_PRT("__bt_gatt_char_read_cb");
+
+ TC_PRT("value_length %d", value_length);
+
+ for (i = 0; i < value_length; i++) {
+ TC_PRT("value %u", value[i]);
+ }
+
+ return;
+}
+
void __bt_avrcp_target_connection_state_changed_cb(bool connected, const char *remote_address, void *user_data)
{
TC_PRT("__bt_avrcp_target_connection_state_changed_cb");
TC_PRT("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;
}
{
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));
}
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;
#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));
--- /dev/null
+/*
+ *
+ * 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__ */
--- /dev/null
+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----
--- /dev/null
+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----
projects / platform / core / api / bluetooth.git / commitdiff