2 * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
19 * @file bluetooth-frwk-test.c
20 * @brief This is the source file for bluetooth framework test suite.
30 #include "bluetooth-api.h"
31 #include "bluetooth-hid-api.h"
32 #include "bluetooth-audio-api.h"
35 bluetooth_device_address_t searched_device = { {0} };
37 #define TC_TIMEOUT 30000
39 #define BT_DEFAULT_DEV_NAME "SLP-BT-TEST-TARGET"
40 #define DISCOVER_TIMEOUT 20
41 #define DISCOVER_CANCEL_INTERVAL 3
43 #define PRT(format, args...) printf("%s:() "format, __FUNCTION__, ##args)
44 #define TC_PRT(format, args...) PRT(format"\n", ##args)
50 int g_ret_client_fd1 = -1, g_ret_client_fd2 = -1;
51 const char *g_hdp_app_handle1 = NULL;
52 const char *g_hdp_app_handle2 = NULL;
54 char *svc_obj_path = NULL;
55 char *char_obj_path = NULL;
56 char *desc_obj_path = NULL;
59 int hdp_manual_mode = 1;
60 const char *rfcomm_test_uuid_spp = "00001101-0000-1000-8000-00805F9B34FB";
61 const char *rfcomm_test_uuid_dun = "00001103-0000-1000-8000-00805F9B34FB";
62 const char *rfcomm_test_uuid_custom = "26b2831b-2c2d-4f9c-914a-c0ab142351b7";
65 GMainLoop *main_loop = NULL;
67 int current_transfer_id = 0;
70 bluetooth_device_address_t address;
71 bt_oob_data_t oob_data;
74 oob_data_t g_local_oob_data;
75 oob_data_t g_remote_oob_data;
83 void bt_event_callback(int event, bluetooth_event_param_t* param, void *user_data);
84 void bt_hid_event_callback(int event, hid_event_param_t* param, void *user_data);
85 void bt_audio_event_callback(int event, bt_audio_event_param_t* param, void *user_data);
88 tc_table_t tc_table[] = {
89 {"bluetooth_register_callback" , 1},
90 {"bluetooth_unregister_callback" , 2},
91 {"bluetooth_enable_adapter" , 3},
92 {"bluetooth_disable_adapter" , 4},
93 {"bluetooth_check_adapter" , 5},
94 {"bluetooth_get_local_address" , 6},
95 {"bluetooth_get_local_name" , 7},
96 {"bluetooth_set_local_name" , 8},
97 {"bluetooth_get_local_version" , 90},
98 {"bluetooth_is_service_used" , 9},
99 {"bluetooth_get_discoverable_mode" , 10},
100 {"bluetooth_set_discoverable_mode(CONNECTABLE)" , 11},
101 {"bluetooth_set_discoverable_mode(GENERAL_DISCOVERABLE)" , 12},
102 {"bluetooth_set_discoverable_mode(TIME_LIMITED_DISCOVERABLE)" , 13},
103 {"bluetooth_start_discovery" , 14},
104 {"bluetooth_cancel_discovery" , 15},
105 {"bluetooth_is_discovering" , 16},
106 {"bluetooth_get_bonded_device_list" , 17},
107 {"bluetooth_bond_device" , 18},
108 {"bluetooth_cancel_bonding" , 19},
109 {"bluetooth_unbond_device" , 20},
110 {"bluetooth_get_bonded_device" , 21},
111 {"bluetooth_set_alias" , 22},
112 {"bluetooth_authorize_device (TRUE)" , 23},
113 {"bluetooth_authorize_device (FALSE)" , 24},
114 {"bluetooth_search_service" , 25},
115 {"bluetooth_cancel_service_search" , 26},
116 {"bluetooth_is_device_connected" , 27},
117 {"bluetooth_reset_adapter" , 28},
118 {"bluetooth_set_manufacturer_data" , 91},
120 {"bluetooth_audio_init" , 29},
121 {"bluetooth_audio_deinit" , 30},
122 {"bluetooth_audio_connect" , 31},
123 {"bluetooth_audio_disconnect" , 32},
124 {"bluetooth_ag_connect" , 33},
125 {"bluetooth_ag_disconnect" , 34},
126 {"bluetooth_av_connect" , 35},
127 {"bluetooth_av_disconnect" , 36},
128 {"bluetooth_ag_get_headset_volume" , 37},
129 {"bluetooth_ag_set_speaker_gain" , 38},
131 {"bluetooth_oob_read_local_data" , 39},
132 {"bluetooth_oob_add_remote_data" , 40},
133 {"bluetooth_oob_remove_remote_data" , 41},
135 {"bluetooth_opc_init" , 42},
136 {"bluetooth_opc_deinit" , 43},
137 {"bluetooth_opc_push_files" , 44},
138 {"bluetooth_opc_cancel_push" , 45},
139 {"bluetooth_opc_session_is_exist" , 46},
141 {"bluetooth_network_activate_server" , 47},
142 {"bluetooth_network_deactivate_server" , 48},
143 {"bluetooth_network_connect" , 49},
144 {"bluetooth_network_disconnect" , 50},
146 {"bluetooth_obex_server_init" , 51},
147 {"bluetooth_obex_server_deinit" , 52},
148 {"bluetooth_obex_server_init_without_agent" , 53},
149 {"bluetooth_obex_server_deinit_without_agent" , 54},
150 {"bluetooth_obex_server_is_activated" , 55},
151 {"bluetooth_obex_server_accept_connection" , 56},
152 {"bluetooth_obex_server_reject_connection" , 57},
153 {"bluetooth_obex_server_accept_authorize" , 58},
154 {"bluetooth_obex_server_reject_authorize" , 59},
155 {"bluetooth_obex_server_set_destination_path" , 60},
156 {"bluetooth_obex_server_set_root" , 61},
157 {"bluetooth_obex_server_cancel_transfer" , 62},
158 {"bluetooth_obex_server_cancel_all_transfers" , 63},
160 {"bluetooth_hid_init" , 65},
161 {"bluetooth_hid_deinit" , 66},
162 {"bluetooth_hid_connect" , 67},
163 {"bluetooth_hid_disconnect" , 68},
165 {"bluetooth_rfcomm_connect" , 70},
166 {"bluetooth_rfcomm_disconnect (cancel)" , 71},
167 {"bluetooth_rfcomm_disconnect" , 72},
168 {"bluetooth_rfcomm_write" , 73},
169 {"bluetooth_rfcomm_is_client_connected" , 74},
171 {"bluetooth_rfcomm_create_socket" , 80},
172 {"bluetooth_rfcomm_create_socket (Custom UUID)" , 81},
173 {"bluetooth_rfcomm_remove_socket" , 82},
174 {"bluetooth_rfcomm_listen_and_accept" , 83},
175 {"bluetooth_rfcomm_listen (OSP)" , 84},
176 {"bluetooth_rfcomm_server_disconnect" , 85},
177 {"bluetooth_rfcomm_is_server_uuid_available" , 86},
178 {"bluetooth_rfcomm_accept_connection" , 87},
179 {"bluetooth_rfcomm_reject_connection" , 88},
180 {"bluetooth_start_custom_discovery" , 89},
182 {"bluetooth_gatt_init", 92},
183 {"bluetooth_gatt_deinit", 93},
184 {"bluetooth_gatt_add_service", 94},
185 {"bluetooth_gatt_add_characteristics", 95},
186 {"bluetooth_gatt_add_descriptor", 96},
187 {"bluetooth_gatt_register_service", 97},
188 {"bluetooth_gatt_update_characteristic", 98},
189 {"bluetooth_gatt_unregister_service", 99},
190 {"bluetooth_gatt_delete_services", 100},
192 /* -----------------------------------------*/
198 #define tc_result(success, tc_index)
200 bluetooth_device_info_t bond_dev;
201 int is_bond_device = FALSE;
203 void tc_usage_print(void)
207 while (tc_table[i].tc_name) {
208 if (tc_table[i].tc_code != 0x00ff)
209 TC_PRT("Key %d : usage %s", tc_table[i].tc_code, tc_table[i].tc_name);
211 TC_PRT("Key %d : usage %s\n\n", 0x00ff, tc_table[i].tc_name);
217 int find_tc_number(int input)
221 while (tc_table[i].tc_code != 0x0000) {
222 if (tc_table[i].tc_code == input)
230 int test_input_callback(void *data)
236 test_id = find_tc_number((uintptr_t)data);
238 test_id = find_tc_number((int)data);
243 TC_PRT("TC : %s[%d]", tc_table[test_id].tc_name, tc_table[test_id].tc_code);
245 switch (tc_table[test_id].tc_code) {
248 g_main_loop_quit(main_loop);
252 ret = bluetooth_register_callback(bt_event_callback, NULL);
254 TC_PRT("%s failed with [0x%04x]", tc_table[0].tc_name, ret);
255 tc_result(TC_FAIL, 1);
260 ret = bluetooth_unregister_callback();
262 TC_PRT("%s failed with [0x%04x]", tc_table[1].tc_name, ret);
263 tc_result(TC_FAIL, 1);
268 ret = bluetooth_enable_adapter();
270 TC_PRT("%s failed with [0x%04x]", tc_table[2].tc_name, ret);
271 tc_result(TC_FAIL, 1);
276 ret = bluetooth_disable_adapter();
278 TC_PRT("%s failed with [0x%04x]", tc_table[3].tc_name, ret);
279 tc_result(TC_FAIL, 2);
285 ret = bluetooth_check_adapter();
286 TC_PRT("state: %d", ret);
292 bluetooth_device_address_t address = { {0} };
293 ret = bluetooth_get_local_address(&address);
295 TC_PRT("%s failed with [0x%04x]", tc_table[5].tc_name, ret);
297 TC_PRT("dev [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]", \
298 address.addr[0], address.addr[1], address.addr[2], \
299 address.addr[3], address.addr[4], address.addr[5]);
306 bluetooth_device_name_t local_name = { {0} };
307 ret = bluetooth_get_local_name(&local_name);
309 TC_PRT("%s failed with [0x%04x]", tc_table[6].tc_name, ret);
311 TC_PRT("name: %s", local_name.name);
318 bluetooth_device_name_t local_name = { {0} };
319 snprintf(local_name.name, sizeof(local_name.name),
320 "bt-frwk-pid-%d", getpid());
321 ret = bluetooth_set_local_name(&local_name);
323 TC_PRT("%s failed with [0x%04x]", tc_table[7].tc_name, ret);
330 bluetooth_version_t local_version = { {0} };
331 snprintf(local_version.version, sizeof(local_version.version),
332 "version%d", getpid());
333 ret = bluetooth_get_local_version(&local_version);
335 TC_PRT("%s failed with [0x%04x]", tc_table[89].tc_name, ret);
337 TC_PRT("version: %s", local_version.version);
343 gboolean used = FALSE;
344 ret = bluetooth_is_service_used(rfcomm_test_uuid_spp, &used);
346 TC_PRT("%s failed with [0x%04x]", tc_table[8].tc_name, ret);
348 TC_PRT("used: %d", used);
354 bluetooth_discoverable_mode_t mode;
355 ret = bluetooth_get_discoverable_mode(&mode);
357 TC_PRT("%s failed with [0x%04x]", tc_table[9].tc_name, ret);
359 TC_PRT("BT Get Discoverable mode [%d]", mode);
365 bluetooth_discoverable_mode_t mode = BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE;
366 ret = bluetooth_set_discoverable_mode(mode, 0);
368 TC_PRT("%s failed with [0x%04x]", tc_table[10].tc_name, ret);
370 TC_PRT("BT Set Discoverable mode [%d]", mode);
376 bluetooth_discoverable_mode_t mode = BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE;
377 ret = bluetooth_set_discoverable_mode(mode, 0);
379 TC_PRT("%s failed with [0x%04x]", tc_table[11].tc_name, ret);
381 TC_PRT("BT Set Discoverable mode [%d]", mode);
387 bluetooth_discoverable_mode_t mode = BLUETOOTH_DISCOVERABLE_MODE_TIME_LIMITED_DISCOVERABLE;
388 ret = bluetooth_set_discoverable_mode(mode, 5);
390 TC_PRT("%s failed with [0x%04x]", tc_table[12].tc_name, ret);
392 TC_PRT("BT Set Discoverable mode [%d]", mode);
397 ret = bluetooth_start_discovery(0, 0, 0);
399 TC_PRT("%s failed with [0x%04x]", tc_table[13].tc_name, ret);
403 ret = bluetooth_cancel_discovery();
405 TC_PRT("%s failed with [0x%04x]", tc_table[14].tc_name, ret);
410 ret = bluetooth_is_discovering();
412 TC_PRT("%s failed with [0x%04x]", tc_table[15].tc_name, ret);
414 TC_PRT("Discovering [%d]", ret);
418 case 17: /*Get paired device list */
420 GPtrArray *devinfo = NULL;
421 devinfo = g_ptr_array_new();
422 TC_PRT("g pointer arrary count : [%d]", devinfo->len);
424 ret = bluetooth_get_bonded_device_list(&devinfo);
426 TC_PRT("%s failed with [0x%04x]", tc_table[16].tc_name, ret);
429 bluetooth_device_info_t *ptr;
430 TC_PRT("g pointer arrary count : [%d]", devinfo->len);
431 for (i = 0; i < devinfo->len; i++) {
432 ptr = g_ptr_array_index(devinfo, i);
434 TC_PRT("Name [%s]", ptr->device_name.name);
435 TC_PRT("Major Class [%d]", ptr->device_class.major_class);
436 TC_PRT("Minor Class [%d]", ptr->device_class.minor_class);
437 TC_PRT("Service Class [%d]", ptr->device_class.service_class);
438 TC_PRT("%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X", ptr->device_address.addr[0], ptr->device_address.addr[1], ptr->device_address.addr[2], ptr->device_address.addr[3], ptr->device_address.addr[4], ptr->device_address.addr[5]);
443 g_ptr_array_free(devinfo, TRUE);
450 bluetooth_device_address_t device_address = { {0xDC, 0x2C, 0x26, 0xD0, 0xF3, 0xC1} }; /* BT Keyboard */
451 TC_PRT("dev [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]", \
452 device_address.addr[0], device_address.addr[1], device_address.addr[2], \
453 device_address.addr[3], device_address.addr[4], device_address.addr[5]);
454 ret = bluetooth_bond_device(&device_address);
456 TC_PRT("%s failed with [0x%04x]", tc_table[17].tc_name, ret);
460 case 19: /*Cancel bonding */
462 ret = bluetooth_cancel_bonding();
464 TC_PRT("%s failed with [0x%04x]", tc_table[18].tc_name, ret);
468 case 20: /*unbonding */
470 bluetooth_device_address_t device_address = { {0x00, 0x19, 0x0E, 0x01, 0x61, 0x17} }; /* DO-DH79-PYUN04 */
471 ret = bluetooth_unbond_device(&device_address);
473 TC_PRT("%s failed with [0x%04x]", tc_table[19].tc_name, ret);
477 case 21: /*Get paired device */
479 bluetooth_device_info_t devinfo;
480 bluetooth_device_address_t device_address = { {0x00, 0x16, 0x38, 0xC3, 0x1F, 0xD2} };
481 memset(&devinfo, 0x00, sizeof(bluetooth_device_info_t));
482 ret = bluetooth_get_bonded_device(&device_address, &devinfo);
483 if (ret != BLUETOOTH_ERROR_NONE) {
484 TC_PRT("bluetooth_get_bonded_device failed with [%d]", ret);
486 TC_PRT("Name [%s]", devinfo.device_name.name);
487 TC_PRT("Major Class [%d]", devinfo.device_class.major_class);
488 TC_PRT("Minor Class [%d]", devinfo.device_class.minor_class);
489 TC_PRT("Service Class [%d]", devinfo.device_class.service_class);
490 TC_PRT("%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X", devinfo.device_address.addr[0], devinfo.device_address.addr[1], devinfo.device_address.addr[2], devinfo.device_address.addr[3], devinfo.device_address.addr[4], devinfo.device_address.addr[5]);
496 case 22: /*set alias for bonded device */
498 bluetooth_device_address_t device_address = { {0x00, 0x16, 0x38, 0xC3, 0x1F, 0xD2} };
500 ret = bluetooth_set_alias(&device_address, "Renamed device");
502 TC_PRT("%s failed with [0x%04x]", tc_table[21].tc_name, ret);
509 bluetooth_device_address_t device_address = { {0x00, 0x16, 0x38, 0xC3, 0x1F, 0xD2} };
510 ret = bluetooth_authorize_device(&device_address, TRUE);
512 TC_PRT("%s failed with [0x%04x]", tc_table[22].tc_name, ret);
519 bluetooth_device_address_t device_address = { {0x00, 0x16, 0x38, 0xC3, 0x1F, 0xD2} };
520 ret = bluetooth_authorize_device(&device_address, FALSE);
522 TC_PRT("%s failed with [0x%04x]", tc_table[23].tc_name, ret);
527 bluetooth_device_address_t device_address = { {0x00, 0x16, 0x38, 0xC3, 0x1F, 0xD2} };
529 ret = bluetooth_search_service(&device_address);
531 TC_PRT("%s failed with [0x%04x]", tc_table[24].tc_name, ret);
538 ret = bluetooth_cancel_service_search();
540 TC_PRT("%s failed with [0x%04x]", tc_table[24].tc_name, ret);
546 gboolean connected = FALSE;
547 bluetooth_device_address_t device_address = { {0x00, 0x1B, 0x66, 0x01, 0x23, 0x1C} }; /* Gennheiser PX210BT */
549 ret = bluetooth_is_device_connected(&device_address, BLUETOOTH_A2DP_SERVICE, &connected);
551 TC_PRT("%s failed with [0x%04x]", tc_table[24].tc_name, ret);
552 TC_PRT("connected : %d", connected);
560 ret = bluetooth_reset_adapter();
562 TC_PRT("%s failed with [0x%04x]", tc_table[27].tc_name, ret);
569 bluetooth_manufacturer_data_t m_data;
570 guint8 data[6] = {0x05, 0xFF, 0x02, 0x03, 0x04, 0x05};
571 TC_PRT("%x %x %x %x %x %x", data[0], data[1], data[2], data[3],
574 memcpy(m_data.data, data, sizeof(data));
575 m_data.data_len = sizeof(data) - 2;
576 ret = bluetooth_set_manufacturer_data(&m_data);
578 TC_PRT("%s failed with [0x%04x]", tc_table[90].tc_name, ret);
584 ret = bluetooth_audio_init(bt_audio_event_callback, NULL);
586 TC_PRT("%s failed with [0x%04x]", tc_table[28].tc_name, ret);
593 ret = bluetooth_audio_deinit();
595 TC_PRT("%s failed with [0x%04x]", tc_table[29].tc_name, ret);
602 bluetooth_device_address_t device_address = { {0x00, 0x0D, 0xFD, 0x24, 0x5E, 0xFF} }; /* Motorola S9 */
604 ret = bluetooth_audio_connect(&device_address);
606 TC_PRT("%s failed with [0x%04x]", tc_table[30].tc_name, ret);
613 bluetooth_device_address_t device_address = { {0x00, 0x0D, 0xFD, 0x24, 0x5E, 0xFF} }; /* Motorola S9 */
615 ret = bluetooth_audio_disconnect(&device_address);
617 TC_PRT("%s failed with [0x%04x]", tc_table[31].tc_name, ret);
624 bluetooth_device_address_t device_address = { {0x58, 0x17, 0x0C, 0xEC, 0x6A, 0xF3} };
626 ret = bluetooth_ag_connect(&device_address);
628 TC_PRT("%s failed with [0x%04x]", tc_table[32].tc_name, ret);
634 bluetooth_device_address_t device_address = { {0x58, 0x17, 0x0C, 0xEC, 0x6A, 0xF3} };
636 ret = bluetooth_ag_disconnect(&device_address);
638 TC_PRT("%s failed with [0x%04x]", tc_table[33].tc_name, ret);
645 bluetooth_device_address_t device_address = { {0x58, 0x17, 0x0C, 0xEC, 0x6A, 0xF3} };
647 ret = bluetooth_av_connect(&device_address);
649 TC_PRT("%s failed with [0x%04x]", tc_table[34].tc_name, ret);
656 bluetooth_device_address_t device_address = { {0x58, 0x17, 0x0C, 0xEC, 0x6A, 0xF3} };
658 ret = bluetooth_av_disconnect(&device_address);
660 TC_PRT("%s failed with [0x%04x]", tc_table[35].tc_name, ret);
667 unsigned int volume = 0;
669 ret = bluetooth_ag_get_headset_volume(&volume);
671 TC_PRT("failed with [0x%04x]", ret);
672 TC_PRT("volume: %d", volume);
680 ret = bluetooth_ag_set_speaker_gain(10);
682 TC_PRT("failed with [0x%04x]", ret);
689 if (bluetooth_oob_read_local_data(&g_local_oob_data.oob_data)) {
690 TC_PRT("ERROR in bluetooth_oob_read_local_data\n");
692 TC_PRT("SUCESS in bluetooth_oob_read_local_data\n");
693 TC_PRT("hash = [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X"
694 "%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]\n",
695 g_local_oob_data.oob_data.hash[0],
696 g_local_oob_data.oob_data.hash[1],
697 g_local_oob_data.oob_data.hash[2],
698 g_local_oob_data.oob_data.hash[3],
699 g_local_oob_data.oob_data.hash[4],
700 g_local_oob_data.oob_data.hash[5],
701 g_local_oob_data.oob_data.hash[6],
702 g_local_oob_data.oob_data.hash[7],
703 g_local_oob_data.oob_data.hash[8],
704 g_local_oob_data.oob_data.hash[9],
705 g_local_oob_data.oob_data.hash[10],
706 g_local_oob_data.oob_data.hash[11],
707 g_local_oob_data.oob_data.hash[12],
708 g_local_oob_data.oob_data.hash[13],
709 g_local_oob_data.oob_data.hash[14],
710 g_local_oob_data.oob_data.hash[15]);
712 TC_PRT("randomizer = [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X"
713 "%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]\n",
714 g_local_oob_data.oob_data.randomizer[0],
715 g_local_oob_data.oob_data.randomizer[1],
716 g_local_oob_data.oob_data.randomizer[2],
717 g_local_oob_data.oob_data.randomizer[3],
718 g_local_oob_data.oob_data.randomizer[4],
719 g_local_oob_data.oob_data.randomizer[5],
720 g_local_oob_data.oob_data.randomizer[6],
721 g_local_oob_data.oob_data.randomizer[7],
722 g_local_oob_data.oob_data.randomizer[8],
723 g_local_oob_data.oob_data.randomizer[9],
724 g_local_oob_data.oob_data.randomizer[10],
725 g_local_oob_data.oob_data.randomizer[11],
726 g_local_oob_data.oob_data.randomizer[12],
727 g_local_oob_data.oob_data.randomizer[13],
728 g_local_oob_data.oob_data.randomizer[14],
729 g_local_oob_data.oob_data.randomizer[15]);
731 TC_PRT("hash_len: %d\n", g_local_oob_data.oob_data.hash_len);
732 TC_PRT("randomizer_len: %d\n", g_local_oob_data.oob_data.randomizer_len);
740 ret = bluetooth_get_local_address(&g_local_oob_data.address);
741 TC_PRT("hash_len: %d\n", g_local_oob_data.oob_data.hash_len);
742 TC_PRT("randomizer_len: %d\n", g_local_oob_data.oob_data.randomizer_len);
744 if (bluetooth_oob_add_remote_data(&g_local_oob_data.address,
745 BLUETOOTH_BDADDR_BREDR,
746 &g_local_oob_data.oob_data))
747 TC_PRT("ERROR in bluetooth_oob_add_remote_data\n");
749 TC_PRT(" bluetooth_oob_add_remote_data SUCCESS\n");
756 if (bluetooth_oob_remove_remote_data(&g_local_oob_data.address))
757 TC_PRT("ERROR in bluetooth_oob_remove_remote_data\n");
759 TC_PRT(" bluetooth_oob_remove_remote_data SUCCESS\n");
765 bluetooth_opc_init();
771 bluetooth_opc_deinit();
777 bluetooth_device_address_t remote_address = { {0} };
780 remote_address.addr[0] = 0x00; remote_address.addr[1] = 0x02; remote_address.addr[2] = 0x70;
781 remote_address.addr[3] = 0x2B; remote_address.addr[4] = 0xD3; remote_address.addr[5] = 0xAF;
783 char *files[5] = {NULL};
785 files[0] = "/opt/media/Images/image1.jpg";
786 // files[1] = "/opt/media/Images/image2.jpg";
787 // files[2] = "/opt/media/Images/image3.jpg";
788 bluetooth_opc_push_files(&remote_address, files);
794 bluetooth_opc_cancel_push();
801 exist = bluetooth_opc_session_is_exist();
802 TC_PRT("exist: %d", exist);
808 bluetooth_network_activate_server();
814 bluetooth_network_deactivate_server();
820 bluetooth_device_address_t device_address = { {0x00, 0x02, 0xA2, 0x14, 0x40, 0x51} };
821 bluetooth_network_connect(&device_address, BLUETOOTH_NETWORK_NAP_ROLE, NULL);
827 bluetooth_device_address_t device_address = { {0x00, 0x02, 0xA2, 0x14, 0x40, 0x51} };
828 bluetooth_network_disconnect(&device_address);
834 bluetooth_obex_server_init("/opt/media/Downloads");
840 bluetooth_obex_server_deinit();
846 bluetooth_obex_server_init_without_agent("/opt/media/Downloads");
852 bluetooth_obex_server_deinit_without_agent();
858 bluetooth_obex_server_is_activated();
864 bluetooth_obex_server_accept_connection();
865 TC_PRT(" bluetooth_obex_server_accept_connection SUCCESS\n");
871 bluetooth_obex_server_reject_connection();
877 bluetooth_obex_server_accept_authorize("abc");
883 bluetooth_obex_server_reject_authorize();
889 bluetooth_obex_server_set_destination_path("/opt/media");
895 bluetooth_obex_server_set_root("/opt/media");
901 bluetooth_obex_server_cancel_transfer(0);
907 bluetooth_obex_server_cancel_all_transfers();
913 ret = bluetooth_hid_init(bt_hid_event_callback, NULL);
915 TC_PRT("Failed with [0x%04x]", ret);
922 ret = bluetooth_hid_deinit();
924 TC_PRT("Failed with [0x%04x]", ret);
931 /* Apple wireless keyboard */
932 hid_device_address_t device_address = { {0xE8, 0x06, 0x88, 0x3B, 0x18, 0xBA} };
934 ret = bluetooth_hid_connect(&device_address);
936 TC_PRT("Failed with [0x%04x]", ret);
943 /* Apple wireless keyboard */
944 hid_device_address_t device_address = { {0xE8, 0x06, 0x88, 0x3B, 0x18, 0xBA} };
946 ret = bluetooth_hid_disconnect(&device_address);
948 TC_PRT("Failed with [0x%04x]", ret);
955 bluetooth_device_address_t device_address = { {0x00, 0x02, 0x2F, 0x92, 0x7B, 0xF5} };
957 ret = bluetooth_rfcomm_connect(&device_address, rfcomm_test_uuid_spp);
958 //ret = bluetooth_rfcomm_connect(&device_address, "1");
961 TC_PRT("Failed with [0x%04x]", ret);
968 ret = bluetooth_rfcomm_disconnect(-1);
970 TC_PRT("Failed with [0x%04x]", ret);
977 ret = bluetooth_rfcomm_disconnect(g_ret_client_fd1);
979 TC_PRT("Failed with [0x%04x]", ret);
986 const char rd_data[] = "123456789 12345";
987 ret = bluetooth_rfcomm_write(g_ret_client_fd1, rd_data, sizeof(rd_data));
989 TC_PRT("Failed with [0x%04x]", ret);
996 gboolean is_connected;
997 is_connected = bluetooth_rfcomm_is_client_connected();
998 TC_PRT("Connected: %d", is_connected);
1005 ret = bluetooth_rfcomm_create_socket(rfcomm_test_uuid_spp);
1007 TC_PRT("Failed with [0x%04x]", ret);
1008 TC_PRT("Returned FD = %d", ret);
1017 ret = bluetooth_rfcomm_create_socket(rfcomm_test_uuid_custom);
1019 TC_PRT("Failed with [0x%04x]", ret);
1020 TC_PRT("Returned FD = %d", ret);
1029 ret = bluetooth_rfcomm_remove_socket(server_fd);
1031 TC_PRT("Failed with [0x%04x]", ret);
1036 case 83: /*Listen and accept */
1038 ret = bluetooth_rfcomm_listen_and_accept(server_fd, 1);
1040 TC_PRT("Failed with [0x%04x]", ret);
1041 TC_PRT("result = %d", ret);
1047 case 84: /*Listen */
1049 ret = bluetooth_rfcomm_listen(server_fd, 1);
1051 TC_PRT("Failed with [0x%04x]", ret);
1052 TC_PRT("result = %d", ret);
1060 ret = bluetooth_rfcomm_server_disconnect(client_fd);
1062 TC_PRT("Failed with [0x%04x]", ret);
1070 available = bluetooth_rfcomm_is_server_uuid_available(rfcomm_test_uuid_spp);
1071 TC_PRT("available: %d", available);
1078 ret = bluetooth_rfcomm_accept_connection(server_fd);
1080 TC_PRT("Failed with [0x%04x]", ret);
1081 TC_PRT("client fd: %d", client_fd);
1089 ret = bluetooth_rfcomm_reject_connection(server_fd);
1091 TC_PRT("Failed with [0x%04x]", ret);
1096 ret = bluetooth_start_custom_discovery(DISCOVERY_ROLE_LE,
1099 TC_PRT("failed with [0x%04x]", ret);
1107 ret = bluetooth_gatt_init();
1109 TC_PRT("gatt init failed with [0x%04x]", ret);
1119 ret = bluetooth_gatt_deinit();
1121 TC_PRT("gatt deinit failed with [0x%04x]", ret);
1131 char *service_uuid = g_strdup("00001802-0000-1000-8000-00805f9b34fb");
1133 ret = bluetooth_gatt_add_service(service_uuid,
1136 TC_PRT("service obj_path is %s", svc_obj_path);
1145 /* testing with dummy values*/
1147 char *char_uuid = g_strdup("00002a06-0000-1000-8000-00805f9b34fb");
1148 bt_gatt_permission_t perms = 0;
1149 bt_gatt_characteristic_property_t props = BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_READ |
1150 BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_WRITE |
1151 BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_NOTIFY |
1152 BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_INDICATE;
1154 ret = bluetooth_gatt_add_new_characteristic(
1155 svc_obj_path, char_uuid,
1156 perms, props, &char_obj_path);
1158 TC_PRT("characteristic obj_path is %s", char_obj_path);
1167 char *desc_uuid = g_strdup("000026ff-0000-1000-8000-00805f9b34fb");
1168 bt_gatt_permission_t perms = BLUETOOTH_GATT_PERMISSION_READ |
1169 BLUETOOTH_GATT_PERMISSION_WRITE;
1171 ret = bluetooth_gatt_add_descriptor(char_obj_path,
1172 desc_uuid, perms, &desc_obj_path);
1173 TC_PRT("add descriptor error is %d", ret);
1182 ret = bluetooth_gatt_register_service(svc_obj_path);
1183 TC_PRT("register service error is %d", ret);
1192 ret = bluetooth_gatt_register_application();
1194 TC_PRT("register service error is %d", ret);
1203 char char_data[4] = {10, 20, 30, 40};
1204 int char_length = 4;
1205 ret = bluetooth_gatt_update_characteristic(char_obj_path,
1206 char_data, char_length);
1208 TC_PRT("update_characteristic error is %d", ret);
1217 ret = bluetooth_gatt_unregister_service(svc_obj_path);
1218 TC_PRT("service removed with error is %d", ret);
1227 ret = bluetooth_gatt_delete_services();
1228 TC_PRT("services deleted with error is %d", ret);
1241 TC_PRT("bluetooth framework TC startup");
1243 main_loop = g_main_loop_new(NULL, FALSE);
1248 TC_PRT("bluetooth framework TC cleanup");
1249 if (main_loop != NULL)
1250 g_main_loop_unref(main_loop);
1253 void bt_hid_event_callback(int event, hid_event_param_t* param, void *user_data)
1255 TC_PRT(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
1256 TC_PRT("bt event callback 0x%04x", event);
1259 void bt_audio_event_callback(int event, bt_audio_event_param_t* param, void *user_data)
1261 TC_PRT(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
1262 TC_PRT("bt event callback 0x%04x", event);
1268 void bt_event_callback(int event, bluetooth_event_param_t* param, void *user_data)
1270 TC_PRT(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
1271 TC_PRT("bt event callback 0x%04x", event);
1273 case BLUETOOTH_EVENT_ENABLED:
1274 TC_PRT("BLUETOOTH_EVENT_ENABLED, result [0x%04x]", param->result);
1277 case BLUETOOTH_EVENT_DISABLED:
1278 TC_PRT("BLUETOOTH_EVENT_DISABLED, result [0x%04x]", param->result);
1281 case BLUETOOTH_EVENT_LOCAL_NAME_CHANGED:
1282 TC_PRT("BLUETOOTH_EVENT_LOCAL_NAME_CHANGED, result [0x%04x]", param->result);
1283 if (param->result == BLUETOOTH_ERROR_NONE) {
1284 bluetooth_device_name_t *local_name = (bluetooth_device_name_t *)param->param_data;
1285 tc_result(TC_PASS, 6);
1286 TC_PRT("Changed Name : [%s]", local_name->name);
1288 tc_result(TC_FAIL, 6);
1292 case BLUETOOTH_EVENT_DISCOVERY_STARTED:
1293 TC_PRT("BLUETOOTH_EVENT_DISCOVERY_STARTED, result [0x%04x]", param->result);
1296 case BLUETOOTH_EVENT_REMOTE_DEVICE_FOUND:
1298 bluetooth_device_info_t *device_info = NULL;
1299 TC_PRT("BLUETOOTH_EVENT_REMOTE_DEVICE_FOUND, result [0x%04x]", param->result);
1300 device_info = (bluetooth_device_info_t *)param->param_data;
1301 memcpy(&searched_device, &device_info->device_address, sizeof(bluetooth_device_address_t));
1302 TC_PRT("dev [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]", \
1303 device_info->device_address.addr[0], device_info->device_address.addr[1], device_info->device_address.addr[2], \
1304 device_info->device_address.addr[3], device_info->device_address.addr[4], device_info->device_address.addr[5]);
1308 case BLUETOOTH_EVENT_REMOTE_LE_DEVICE_FOUND:
1311 bluetooth_le_device_info_t *le_device_info = NULL;
1312 TC_PRT("BLUETOOTH_EVENT_REMOTE_LE_DEVICE_FOUND, result [0x%04x]", param->result);
1313 le_device_info = (bluetooth_le_device_info_t *)param->param_data;
1314 TC_PRT("dev[%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]", \
1315 le_device_info->device_address.addr[0], le_device_info->device_address.addr[1], le_device_info->device_address.addr[2], \
1316 le_device_info->device_address.addr[3], le_device_info->device_address.addr[4], le_device_info->device_address.addr[5]);
1317 TC_PRT("addr_type : %d", le_device_info->addr_type);
1318 TC_PRT("rssi : %d", le_device_info->rssi);
1319 TC_PRT("adv_ind_data_len :%d" , le_device_info->adv_ind_data.data_len);
1320 TC_PRT("scan_resp_data_len :%d" , le_device_info->scan_resp_data.data_len);
1321 for (i = 0; i < le_device_info->adv_ind_data.data_len; i++)
1322 TC_PRT("adv_ind_data[%d] : [0x%x]", i, le_device_info->adv_ind_data.data.data[i]);
1323 for (i = 0; i < le_device_info->scan_resp_data.data_len; i++)
1324 TC_PRT("scan_resp_data[%d] : [0x%x]", i, le_device_info->scan_resp_data.data.data[i]);
1328 case BLUETOOTH_EVENT_REMOTE_DEVICE_NAME_UPDATED:
1330 bluetooth_device_info_t *device_info = NULL;
1331 TC_PRT("BLUETOOTH_EVENT_REMOTE_DEVICE_NAME_UPDATED, result [0x%04x]", param->result);
1332 device_info = (bluetooth_device_info_t *)param->param_data;
1333 memcpy(&searched_device, &device_info->device_address, sizeof(bluetooth_device_address_t));
1334 TC_PRT("dev [%s] [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]", device_info->device_name.name, \
1335 device_info->device_address.addr[0], device_info->device_address.addr[1], device_info->device_address.addr[2], \
1336 device_info->device_address.addr[3], device_info->device_address.addr[4], device_info->device_address.addr[5]);
1340 case BLUETOOTH_EVENT_DISCOVERY_FINISHED:
1341 TC_PRT("BLUETOOTH_EVENT_DISCOVERY_FINISHED, result [0x%04x]", param->result);
1344 case BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED:
1346 int *mode = (int *)param->param_data;
1347 TC_PRT("BT_DISCOVERABLE_MODE_CHANGED, result [0x%04x]", param->result);
1348 TC_PRT("mode [%d]", *mode);
1352 case BLUETOOTH_EVENT_DISCOVERABLE_TIMEOUT_CHANGED:
1354 int *timeout = (int *)param->param_data;
1355 TC_PRT("BLUETOOTH_EVENT_DISCOVERABLE_TIMEOUT_CHANGED, result [0x%04x]", param->result);
1356 TC_PRT("timeout [%d]", *timeout);
1360 case BLUETOOTH_EVENT_BONDING_FINISHED:
1362 TC_PRT("BLUETOOTH_EVENT_BONDING_FINISHED, result [0x%04x]", param->result);
1363 if (param->result >= BLUETOOTH_ERROR_NONE) {
1364 bluetooth_device_info_t *device_info = NULL;
1365 tc_result(TC_PASS, 12);
1366 device_info = (bluetooth_device_info_t *)param->param_data;
1367 if (device_info == NULL)
1369 TC_PRT("dev [%s] [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X] mjr[%#x] min[%#x] srv[%#x]", device_info->device_name.name, \
1370 device_info->device_address.addr[0], device_info->device_address.addr[1], device_info->device_address.addr[2], \
1371 device_info->device_address.addr[3], device_info->device_address.addr[4], device_info->device_address.addr[5], \
1372 device_info->device_class.major_class, device_info->device_class.minor_class, device_info->device_class.service_class);
1374 tc_result(TC_FAIL, 12);
1379 case BLUETOOTH_EVENT_BONDED_DEVICE_FOUND:
1381 // bluetooth_get_bonded_device_list is changed as synchronous API. This event is not used any more.
1386 case BLUETOOTH_EVENT_SERVICE_SEARCHED:
1389 TC_PRT("BLUETOOTH_EVENT_SERVICE_SEARCHED, result [0x%04x]", param->result);
1390 if (param->result >= BLUETOOTH_ERROR_NONE) {
1391 tc_result(TC_PASS, 18);
1392 bt_sdp_info_t *bt_sdp_info = param->param_data;
1394 TC_PRT("Dev add = %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n",
1395 bt_sdp_info->device_addr.addr[0], bt_sdp_info->device_addr.addr[1], bt_sdp_info->device_addr.addr[2], \
1396 bt_sdp_info->device_addr.addr[3], bt_sdp_info->device_addr.addr[4], bt_sdp_info->device_addr.addr[5]);
1398 TC_PRT("Supported service list:\n");
1399 for (i = 0; i < bt_sdp_info->service_index; i++)
1400 TC_PRT("[%#x]\n", bt_sdp_info->service_list_array[i]);
1403 tc_result(TC_FAIL, 18);
1408 case BLUETOOTH_EVENT_RFCOMM_DATA_RECEIVED:
1410 TC_PRT("BLUETOOTH_EVENT_RFCOMM_DATA_RECEIVED, result [0x%04x]", param->result);
1411 bluetooth_rfcomm_received_data_t *rx_data = param->param_data;
1412 printf("\n FD = %d \nBuffer len = %d ", rx_data->socket_fd, rx_data->buffer_size);
1413 if (rx_data->buffer_size < sizeof(oob_data_t))
1414 TC_PRT("Complete oob data is not recivedn");
1416 memcpy(&g_remote_oob_data, rx_data->buffer, sizeof(oob_data_t));
1417 //tc_result(TC_PASS, 21);
1421 case BLUETOOTH_EVENT_RFCOMM_CONNECTED:
1423 bluetooth_rfcomm_connection_t *con_ind = (bluetooth_rfcomm_connection_t *)param->param_data;
1424 TC_PRT("BLUETOOTH_EVENT_RFCOMM_CONNECTED, result [0x%04x], fd = %d, device add = 0x%X:%X:%X:%X:%X:%X, Role = %s", param->result,
1426 con_ind->device_addr.addr[0], con_ind->device_addr.addr[1], con_ind->device_addr.addr[2],
1427 con_ind->device_addr.addr[3], con_ind->device_addr.addr[4], con_ind->device_addr.addr[5],
1428 (con_ind->device_role == RFCOMM_ROLE_SERVER) ? "SERVER" : "CLIENT");
1429 //tc_result(TC_PASS, 22);
1430 if ((con_ind->device_role == RFCOMM_ROLE_CLIENT) && (con_ind->socket_fd > 0))
1431 g_ret_client_fd1 = con_ind->socket_fd;
1433 if ((con_ind->device_role == RFCOMM_ROLE_SERVER) && (con_ind->socket_fd > 0))
1434 client_fd = con_ind->socket_fd;
1439 case BLUETOOTH_EVENT_RFCOMM_DISCONNECTED:
1441 bluetooth_rfcomm_disconnection_t *disconnection_ind = (bluetooth_rfcomm_disconnection_t *)param->param_data;;
1442 TC_PRT("BLUETOOTH_EVENT_RFCOMM_DISCONNECTED, result [0x%04x] Fd = %d, device add = 0x%X:%X:%X:%X:%X:%X\n", param->result, disconnection_ind->socket_fd,
1443 disconnection_ind->device_addr.addr[0], disconnection_ind->device_addr.addr[1], disconnection_ind->device_addr.addr[2],
1444 disconnection_ind->device_addr.addr[3], disconnection_ind->device_addr.addr[4], disconnection_ind->device_addr.addr[5]);
1445 //tc_result(TC_PASS, 22);
1449 case BLUETOOTH_EVENT_NETWORK_SERVER_CONNECTED:
1451 bluetooth_network_device_info_t *dev_info = (bluetooth_network_device_info_t *)param->param_data;
1453 TC_PRT("BLUETOOTH_EVENT_RFCOMM_DISCONNECTED, result [0x%04x]", param->result);
1454 TC_PRT("interface name: %s", dev_info->interface_name);
1456 TC_PRT("device add = %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n",
1457 dev_info->device_address.addr[0], dev_info->device_address.addr[1], dev_info->device_address.addr[2],
1458 dev_info->device_address.addr[3], dev_info->device_address.addr[4], dev_info->device_address.addr[5]);
1462 case BLUETOOTH_EVENT_NETWORK_SERVER_DISCONNECTED:
1464 bluetooth_network_device_info_t *dev_info = (bluetooth_network_device_info_t *)param->param_data;
1466 TC_PRT("BLUETOOTH_EVENT_RFCOMM_DISCONNECTED, result [0x%04x]", param->result);
1467 TC_PRT("interface name: %s", dev_info->interface_name);
1469 TC_PRT("device add = %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n",
1470 dev_info->device_address.addr[0], dev_info->device_address.addr[1], dev_info->device_address.addr[2],
1471 dev_info->device_address.addr[3], dev_info->device_address.addr[4], dev_info->device_address.addr[5]);
1475 case BLUETOOTH_EVENT_HDP_CONNECTED:
1477 bt_hdp_connected_t *conn_ind = (bt_hdp_connected_t *)param->param_data;
1479 TC_PRT("BLUETOOTH_EVENT_HDP_CONNECTED, Result = %s\n", (param->result == 0) ? "BLUETOOTH_ERROR_NONE" : "BLUETOOTH_ERROR_XXXX");
1480 TC_PRT("App handler = %s, channel id = %d, type = %s", conn_ind->app_handle, conn_ind->channel_id, (conn_ind->type == HDP_QOS_RELIABLE) ? "Reliable" : "Streaming");
1481 TC_PRT("device add = %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n",
1482 conn_ind->device_address.addr[0], conn_ind->device_address.addr[1], conn_ind->device_address.addr[2],
1483 conn_ind->device_address.addr[3], conn_ind->device_address.addr[4], conn_ind->device_address.addr[5]);
1485 g_ret_client_fd1 = conn_ind->channel_id;
1489 case BLUETOOTH_EVENT_HDP_DISCONNECTED:
1491 bt_hdp_disconnected_t *dis_ind = (bt_hdp_disconnected_t *)param->param_data;
1493 TC_PRT("BLUETOOTH_EVENT_HDP_DISCONNECTED, Result = %s\n", (param->result == 0) ? "BLUETOOTH_ERROR_NONE" : "BLUETOOTH_ERROR_XXXX");
1494 TC_PRT("Channel = %d, Add = device add = %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n", dis_ind->channel_id,
1495 dis_ind->device_address.addr[0], dis_ind->device_address.addr[1], dis_ind->device_address.addr[2],
1496 dis_ind->device_address.addr[3], dis_ind->device_address.addr[4], dis_ind->device_address.addr[5]);
1500 case BLUETOOTH_EVENT_HDP_DATA_RECEIVED:
1502 bt_hdp_data_ind_t *data_ind = (bt_hdp_data_ind_t *)param->param_data;
1504 TC_PRT("BLUETOOTH_EVENT_HDP_DATA_RECEIVED, Result = %s\n", (param->result == 0) ? "BLUETOOTH_ERROR_NONE" : "BLUETOOTH_ERROR_XXXX");
1505 TC_PRT("Data received from channel id = %d and size =%d, buff =[%s]\n", data_ind->channel_id, data_ind->size, data_ind->buffer);
1510 case BLUETOOTH_EVENT_OPC_CONNECTED:
1511 TC_PRT("BLUETOOTH_EVENT_OPC_CONNECTED");
1514 case BLUETOOTH_EVENT_OPC_DISCONNECTED:
1515 TC_PRT("BLUETOOTH_EVENT_OPC_DISCONNECTED");
1517 case BLUETOOTH_EVENT_OPC_TRANSFER_STARTED:
1519 TC_PRT("BLUETOOTH_EVENT_OPC_TRANSFER_STARTED");
1520 if (param->param_data) {
1521 bt_opc_transfer_info_t *info = param->param_data;
1522 TC_PRT("file %s", info->filename);
1523 TC_PRT("size %ld", info->size);
1527 case BLUETOOTH_EVENT_OPC_TRANSFER_PROGRESS:
1529 TC_PRT("BLUETOOTH_EVENT_OPC_TRANSFER_PROGRESS");
1532 case BLUETOOTH_EVENT_OPC_TRANSFER_COMPLETE:
1534 TC_PRT("BLUETOOTH_EVENT_OPC_TRANSFER_COMPLETE");
1535 bt_opc_transfer_info_t *info = param->param_data;
1536 TC_PRT("file %s", info->filename);
1537 TC_PRT("size %ld", info->size);
1541 case BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_AUTHORIZE:
1542 TC_PRT("BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_AUTHORIZE");
1545 case BLUETOOTH_EVENT_OBEX_SERVER_CONNECTION_AUTHORIZE:
1546 TC_PRT("BLUETOOTH_EVENT_OBEX_SERVER_CONNECTION_AUTHORIZE");
1549 case BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_STARTED:
1550 TC_PRT("BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_STARTED");
1551 bt_obex_server_transfer_info_t *info = param->param_data;
1552 current_transfer_id = info->transfer_id;
1555 case BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_PROGRESS:
1556 TC_PRT("BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_PROGRESS");
1559 case BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_COMPLETED:
1560 TC_PRT("BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_COMPLETED");
1562 case BLUETOOTH_EVENT_MANUFACTURER_DATA_CHANGED:
1563 { TC_PRT("BLUETOOTH_EVENT_MANUFACTURER_DATA_CHANGED");
1566 case BLUETOOTH_EVENT_KEYBOARD_PASSKEY_DISPLAY:
1568 bluetooth_authentication_request_info_t *auth_info = param->param_data;
1570 TC_PRT("BLUETOOTH_EVENT_KEYBOARD_PASSKEY_DISPLAY");
1571 TC_PRT("Device Address: [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]",
1572 auth_info->device_address.addr[0], auth_info->device_address.addr[1],
1573 auth_info->device_address.addr[2], auth_info->device_address.addr[3],
1574 auth_info->device_address.addr[4], auth_info->device_address.addr[5]);
1575 TC_PRT("Device Name : [%s]", auth_info->device_name.name);
1576 TC_PRT("Passkey: [%s]", auth_info->str_passkey);
1579 case BLUETOOTH_EVENT_PIN_REQUEST:
1581 bluetooth_authentication_request_info_t *auth_info = param->param_data;
1583 TC_PRT("BLUETOOTH_EVENT_PIN_REQUEST");
1584 TC_PRT("Device Address: [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]",
1585 auth_info->device_address.addr[0], auth_info->device_address.addr[1],
1586 auth_info->device_address.addr[2], auth_info->device_address.addr[3],
1587 auth_info->device_address.addr[4], auth_info->device_address.addr[5]);
1588 TC_PRT("Device Name : [%s]", auth_info->device_name.name);
1590 TC_PRT("bluetooth_passkey_reply(\"0000\", TRUE)");
1591 bluetooth_passkey_reply("0000", TRUE);
1594 case BLUETOOTH_EVENT_PASSKEY_REQUEST:
1596 bluetooth_authentication_request_info_t *auth_info = param->param_data;
1598 TC_PRT("BLUETOOTH_EVENT_PASSKEY_REQUEST");
1599 TC_PRT("Device Address: [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]",
1600 auth_info->device_address.addr[0], auth_info->device_address.addr[1],
1601 auth_info->device_address.addr[2], auth_info->device_address.addr[3],
1602 auth_info->device_address.addr[4], auth_info->device_address.addr[5]);
1603 TC_PRT("Device Name : [%s]", auth_info->device_name.name);
1605 TC_PRT("bluetooth_passkey_reply(\"0000\", TRUE)");
1606 bluetooth_passkey_reply("0000", TRUE);
1609 case BLUETOOTH_EVENT_PASSKEY_CONFIRM_REQUEST:
1611 bluetooth_authentication_request_info_t *auth_info = param->param_data;
1613 TC_PRT("BLUETOOTH_EVENT_PASSKEY_CONFIRM_REQUEST");
1614 TC_PRT("Device Address: [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]",
1615 auth_info->device_address.addr[0], auth_info->device_address.addr[1],
1616 auth_info->device_address.addr[2], auth_info->device_address.addr[3],
1617 auth_info->device_address.addr[4], auth_info->device_address.addr[5]);
1618 TC_PRT("Device Name : [%s]", auth_info->device_name.name);
1619 TC_PRT("Passkey: [%s]", auth_info->str_passkey);
1621 TC_PRT("bluetooth_passkey_confirmation_reply: TRUE");
1622 bluetooth_passkey_confirmation_reply(TRUE);
1626 TC_PRT("received event [0x%04x]", event);
1629 TC_PRT("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<");
1632 static gboolean key_event_cb(GIOChannel * chan, GIOCondition cond , gpointer data)
1637 unsigned long len = 0;
1639 unsigned int len = 0;
1642 memset(buf, 0, sizeof(buf));
1644 if (g_io_channel_read_chars(chan, buf, sizeof(buf),
1645 &len, NULL) == G_IO_STATUS_ERROR) {
1646 TC_PRT("IO Channel read error");
1650 printf("%s\n", buf);
1653 test_id = atoi(buf);
1656 g_idle_add(test_input_callback, (void *)(uintptr_t)test_id);
1658 g_idle_add(test_input_callback, (void *)test_id);
1669 key_io = g_io_channel_unix_new(fileno(stdin));
1671 g_io_channel_set_encoding(key_io, NULL, NULL);
1672 g_io_channel_set_flags(key_io, G_IO_FLAG_NONBLOCK, NULL);
1674 g_io_add_watch(key_io, G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
1675 key_event_cb, NULL);
1676 g_io_channel_unref(key_io);
1678 g_main_loop_run(main_loop);