4 * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
10 * http://www.apache.org/licenses/LICENSE-2.0
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
21 * @file bluetooth-frwk-test.c
22 * @brief This is the source file for bluetooth framework test suite.
28 #include <dbus/dbus-glib.h>
31 #include "bluetooth-api.h"
32 #include "bluetooth-hid-api.h"
33 #include "bluetooth-audio-api.h"
36 bluetooth_device_address_t searched_device = {{0}};
38 #define TC_TIMEOUT 30000
40 #define BT_DEFAULT_DEV_NAME "SLP-BT-TEST-TARGET"
41 #define DISCOVER_TIMEOUT 20
42 #define DISCOVER_CANCEL_INTERVAL 3
44 #define PRT(format, args...) printf("%s:%d() "format, __FUNCTION__, __LINE__, ##args)
45 #define TC_PRT(format, args...) PRT(format"\n", ##args)
51 int g_ret_client_fd1 = -1, g_ret_client_fd2 = -1;
52 const char *g_hdp_app_handle1 = NULL;
53 const char *g_hdp_app_handle2 = NULL;
55 int hdp_manual_mode = 1;
56 const char * rfcomm_test_uuid_spp ="00001101-0000-1000-8000-00805F9B34FB";
57 const char * rfcomm_test_uuid_dun = "00001103-0000-1000-8000-00805F9B34FB";
58 const char * rfcomm_test_uuid_custom ="26b2831b-2c2d-4f9c-914a-c0ab142351b7";
61 GMainLoop *main_loop = NULL;
62 static int timeout_status = 0;
64 int current_transfer_id = 0;
67 bluetooth_device_address_t address;
68 bt_oob_data_t oob_data;
71 oob_data_t g_local_oob_data;
72 oob_data_t g_remote_oob_data;
81 void bt_event_callback(int event, bluetooth_event_param_t* param, void *user_data);
82 void bt_hid_event_callback(int event, hid_event_param_t* param, void *user_data);
83 void bt_audio_event_callback(int event, bt_audio_event_param_t* param, void *user_data);
86 tc_table_t tc_table[] =
88 {"bluetooth_register_callback" , 1},
89 {"bluetooth_unregister_callback" , 2},
90 {"bluetooth_enable_adapter" , 3},
91 {"bluetooth_disable_adapter" , 4},
92 {"bluetooth_check_adapter" , 5},
93 {"bluetooth_get_local_address" , 6},
94 {"bluetooth_get_local_name" , 7},
95 {"bluetooth_set_local_name" , 8},
96 {"bluetooth_is_service_used" , 9},
97 {"bluetooth_get_discoverable_mode" , 10},
98 {"bluetooth_set_discoverable_mode(CONNECTABLE)" , 11},
99 {"bluetooth_set_discoverable_mode(GENERAL_DISCOVERABLE)" , 12},
100 {"bluetooth_set_discoverable_mode(TIME_LIMITED_DISCOVERABLE)" , 13},
101 {"bluetooth_start_discovery" , 14},
102 {"bluetooth_cancel_discovery" , 15},
103 {"bluetooth_is_discovering" , 16},
104 {"bluetooth_get_bonded_device_list" , 17},
105 {"bluetooth_bond_device" , 18},
106 {"bluetooth_cancel_bonding" , 19},
107 {"bluetooth_unbond_device" , 20},
108 {"bluetooth_get_bonded_device" , 21},
109 {"bluetooth_set_alias" , 22},
110 {"bluetooth_authorize_device (TRUE)" , 23},
111 {"bluetooth_authorize_device (FALSE)" , 24},
112 {"bluetooth_search_service" , 25},
113 {"bluetooth_cancel_service_search" , 26},
114 {"bluetooth_is_device_connected" , 27},
115 {"bluetooth_reset_adapter" , 28},
117 {"bluetooth_audio_init" , 29},
118 {"bluetooth_audio_deinit" , 30},
119 {"bluetooth_audio_connect" , 31},
120 {"bluetooth_audio_disconnect" , 32},
121 {"bluetooth_ag_connect" , 33},
122 {"bluetooth_ag_disconnect" , 34},
123 {"bluetooth_av_connect" , 35},
124 {"bluetooth_av_disconnect" , 36},
125 {"bluetooth_ag_get_headset_volume" , 37},
126 {"bluetooth_ag_set_speaker_gain" , 38},
128 {"bluetooth_oob_read_local_data" , 39},
129 {"bluetooth_oob_add_remote_data" , 40},
130 {"bluetooth_oob_remove_remote_data" , 41},
132 {"bluetooth_opc_init" , 42},
133 {"bluetooth_opc_deinit" , 43},
134 {"bluetooth_opc_push_files" , 44},
135 {"bluetooth_opc_cancel_push" , 45},
136 {"bluetooth_opc_session_is_exist" , 46},
138 {"bluetooth_network_activate_server" , 47},
139 {"bluetooth_network_deactivate_server" , 48},
140 {"bluetooth_network_connect" , 49},
141 {"bluetooth_network_disconnect" , 50},
143 {"bluetooth_obex_server_init" , 51},
144 {"bluetooth_obex_server_deinit" , 52},
145 {"bluetooth_obex_server_init_without_agent" , 53},
146 {"bluetooth_obex_server_deinit_without_agent" , 54},
147 {"bluetooth_obex_server_is_activated" , 55},
148 {"bluetooth_obex_server_accept_connection" , 56},
149 {"bluetooth_obex_server_reject_connection" , 57},
150 {"bluetooth_obex_server_accept_authorize" , 58},
151 {"bluetooth_obex_server_reject_authorize" , 59},
152 {"bluetooth_obex_server_set_destination_path" , 60},
153 {"bluetooth_obex_server_set_root" , 61},
154 {"bluetooth_obex_server_cancel_transfer" , 62},
155 {"bluetooth_obex_server_cancel_all_transfers" , 63},
157 {"bluetooth_hid_init" , 65},
158 {"bluetooth_hid_deinit" , 66},
159 {"bluetooth_hid_connect" , 67},
160 {"bluetooth_hid_disconnect" , 68},
162 {"bluetooth_rfcomm_connect" , 70},
163 {"bluetooth_rfcomm_disconnect (cancel)" , 71},
164 {"bluetooth_rfcomm_disconnect" , 72},
165 {"bluetooth_rfcomm_write" , 73},
166 {"bluetooth_rfcomm_is_client_connected" , 74},
168 {"bluetooth_rfcomm_create_socket" , 80},
169 {"bluetooth_rfcomm_create_socket (Custom UUID)" , 81},
170 {"bluetooth_rfcomm_remove_socket" , 82},
171 {"bluetooth_rfcomm_listen_and_accept" , 83},
172 {"bluetooth_rfcomm_listen (OSP)" , 84},
173 {"bluetooth_rfcomm_server_disconnect" , 85},
174 {"bluetooth_rfcomm_is_server_uuid_available" , 86},
175 {"bluetooth_rfcomm_accept_connection" , 87},
176 {"bluetooth_rfcomm_reject_connection" , 88},
180 {"bluetooth_rfcomm_is_server_uuid_available" , 26},
182 {"bluetooth_hdp_activate" , 30},
183 {"bluetooth_hdp_deactivate" , 31},
184 {"bluetooth_hdp_connect" , 32},
185 {"bluetooth_hdp_disconnect" , 33},
186 {"bluetooth_hdp_send_data" , 34},
188 {"bluetooth_opc_init" , 35},
189 {"bluetooth_opc_push_file" , 36},
190 {"bluetooth_opc_cancel_push" , 37},
191 {"bluetooth_opc_deinit" , 38},
192 {"bluetooth_obex_server_init" , 39},
193 {"bluetooth_obex_server_deinit" , 40},
194 {"bluetooth_obex_server_accept_authorize" , 41},
195 {"bluetooth_obex_server_reject_authorize" , 42},
196 {"bluetooth_is_supported" , 43},
197 {"bluetooth_opc_session_is_exist" , 46},
198 {"bluetooth_obex_server_is_activated" , 47},
199 {"bluetooth_obex_server_cancel_transfer" , 48},
201 {"bluetooth_oob_read_local_data" , 50},
202 {"bluetooth_oob_add_remote_data" , 51},
203 {"bluetooth_oob_remove_remote_data" , 52},
205 {"bluetooth_network_activate_server" , 60},
206 {"bluetooth_network_deactivate_server" , 61},
207 {"bluetooth_network_connect" , 62},
208 {"bluetooth_network_disconnect" , 63},
210 {"bluetooth_gatt_discover_primary_services", 64},
211 {"bluetooth_gatt_discover_service_characteristics", 65},
212 {"bluetooth_gatt_get_service_property", 66},
213 {"bluetooth_gatt_get_characteristics_value", 67},
214 {"bluetooth_gatt_set_characteristics_value", 68},
216 /* -----------------------------------------*/
222 #define tc_result(success, tc_index) \
223 TC_PRT("Test case [%d - %s] %s", tc_table[tc_index].tc_code, tc_table[tc_index].tc_name, ((success == TC_PASS)?"Success":"Failed"));
225 bluetooth_device_info_t bond_dev;
226 int is_bond_device = FALSE;
228 void tc_usage_print(void)
232 while (tc_table[i].tc_name) {
233 if (tc_table[i].tc_code != 0x00ff) {
234 TC_PRT("Key %d : usage %s", tc_table[i].tc_code, tc_table[i].tc_name);
236 TC_PRT("Key %d : usage %s\n\n", 0x00ff, tc_table[i].tc_name);
243 int test_input_callback(void *data)
246 int test_id = (int)data;
252 g_main_loop_quit(main_loop);
256 TC_PRT("TC : %s", tc_table[0].tc_name);
257 bluetooth_register_callback(bt_event_callback, NULL);
260 TC_PRT("%s failed with [0x%04x]", tc_table[0].tc_name, ret);
261 tc_result(TC_FAIL, 1);
266 TC_PRT("TC : %s", tc_table[1].tc_name);
267 bluetooth_unregister_callback();
270 TC_PRT("%s failed with [0x%04x]", tc_table[1].tc_name, ret);
271 tc_result(TC_FAIL, 1);
276 TC_PRT("TC : %s", tc_table[2].tc_name);
277 ret = bluetooth_enable_adapter();
280 TC_PRT("%s failed with [0x%04x]", tc_table[2].tc_name, ret);
281 tc_result(TC_FAIL, 1);
286 TC_PRT("TC : %s", tc_table[3].tc_name);
287 ret = bluetooth_disable_adapter();
290 TC_PRT("%s failed with [0x%04x]", tc_table[3].tc_name, ret);
291 tc_result(TC_FAIL, 2);
297 TC_PRT("TC : %s", tc_table[4].tc_name);
298 ret = bluetooth_check_adapter();
299 TC_PRT("state: %d", ret);
305 bluetooth_device_address_t address = {{0}};
307 TC_PRT("TC : %s", tc_table[5].tc_name);
308 ret = bluetooth_get_local_address(&address);
311 TC_PRT("%s failed with [0x%04x]", tc_table[5].tc_name, ret);
313 TC_PRT("dev [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]", \
314 address.addr[0], address.addr[1], address.addr[2], \
315 address.addr[3], address.addr[4], address.addr[5]);
322 bluetooth_device_name_t local_name = {{0}};
324 TC_PRT("TC : %s", tc_table[6].tc_name);
325 ret = bluetooth_get_local_name(&local_name);
328 TC_PRT("%s failed with [0x%04x]", tc_table[6].tc_name, ret);
330 TC_PRT("name: %s", local_name.name);
337 bluetooth_device_name_t local_name = {{0}};
338 snprintf(local_name.name, sizeof(local_name.name),
339 "bt-frwk-pid-%d", getpid());
341 TC_PRT("TC : %s", tc_table[7].tc_name);
342 ret = bluetooth_set_local_name(&local_name);
345 TC_PRT("%s failed with [0x%04x]", tc_table[7].tc_name, ret);
352 gboolean used = FALSE;
354 TC_PRT("TC : %s", tc_table[8].tc_name);
355 ret = bluetooth_is_service_used(rfcomm_test_uuid_spp, &used);
358 TC_PRT("%s failed with [0x%04x]", tc_table[8].tc_name, ret);
360 TC_PRT("used: %d", used);
367 bluetooth_discoverable_mode_t mode;
368 TC_PRT("TC : %s", tc_table[9].tc_name);
369 ret = bluetooth_get_discoverable_mode(&mode);
372 TC_PRT("%s failed with [0x%04x]", tc_table[9].tc_name, ret);
376 TC_PRT("BT Get Discoverable mode [%d]", mode);
383 bluetooth_discoverable_mode_t mode = BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE;
384 TC_PRT("TC : %s", tc_table[10].tc_name);
385 ret = bluetooth_set_discoverable_mode(mode, 0);
388 TC_PRT("%s failed with [0x%04x]", tc_table[10].tc_name, ret);
392 TC_PRT("BT Set Discoverable mode [%d]", mode);
399 bluetooth_discoverable_mode_t mode = BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE;
400 TC_PRT("TC : %s", tc_table[11].tc_name);
401 ret = bluetooth_set_discoverable_mode(mode, 0);
404 TC_PRT("%s failed with [0x%04x]", tc_table[11].tc_name, ret);
408 TC_PRT("BT Set Discoverable mode [%d]", mode);
415 bluetooth_discoverable_mode_t mode = BLUETOOTH_DISCOVERABLE_MODE_TIME_LIMITED_DISCOVERABLE;
416 TC_PRT("TC : %s", tc_table[12].tc_name);
417 ret = bluetooth_set_discoverable_mode(mode, 5);
420 TC_PRT("%s failed with [0x%04x]", tc_table[12].tc_name, ret);
424 TC_PRT("BT Set Discoverable mode [%d]", mode);
430 TC_PRT("TC : %s", tc_table[13].tc_name);
431 ret = bluetooth_start_discovery(0,0,0);
434 TC_PRT("%s failed with [0x%04x]", tc_table[13].tc_name, ret);
439 TC_PRT("TC : %s", tc_table[14].tc_name);
440 ret = bluetooth_cancel_discovery();
443 TC_PRT("%s failed with [0x%04x]", tc_table[14].tc_name, ret);
449 TC_PRT("TC : %s", tc_table[15].tc_name);
450 ret = bluetooth_is_discovering();
453 TC_PRT("%s failed with [0x%04x]", tc_table[15].tc_name, ret);
457 TC_PRT("Discovering [%d]", ret);
462 case 17: /*Get paired device list */
465 TC_PRT("TC : %s", tc_table[16].tc_name);
467 GPtrArray *devinfo = NULL;
468 devinfo = g_ptr_array_new();
469 TC_PRT("g pointer arrary count : [%d]", devinfo->len);
471 ret = bluetooth_get_bonded_device_list(&devinfo);
474 TC_PRT("%s failed with [0x%04x]", tc_table[16].tc_name, ret);
479 bluetooth_device_info_t *ptr;
480 TC_PRT("g pointer arrary count : [%d]", devinfo->len);
482 for(i=0; i<devinfo->len;i++)
484 ptr = g_ptr_array_index(devinfo, i);
487 TC_PRT("Name [%s]", ptr->device_name.name);
488 TC_PRT("Major Class [%d]", ptr->device_class.major_class);
489 TC_PRT("Minor Class [%d]", ptr->device_class.minor_class);
490 TC_PRT("Service Class [%d]", ptr->device_class.service_class);
491 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]);
496 g_ptr_array_free(devinfo, TRUE);
503 /* Apple wireless keyboard */
504 //bluetooth_device_address_t device_address={{0xE8,0x06,0x88,0x3B,0x18,0xBA}};
505 //bluetooth_device_address_t device_address={{0x00,0x19,0x0E,0x01,0x61,0x17}}; /* DO-DH79-PYUN04 */
506 //bluetooth_device_address_t device_address={{0x00,0x16,0x38,0xC3,0x1F,0xD2}}; /* DO-DH79-PYUN03 */
507 //bluetooth_device_address_t device_address={{0x58,0x17,0x0C,0xEC,0x6A,0xF3}}; /* MW600 */
508 bluetooth_device_address_t device_address={{0x00,0x0D,0xFD,0x24,0x5E,0xFF}}; /* Motorola S9 */
510 TC_PRT("TC : %s", tc_table[17].tc_name);
512 TC_PRT("dev [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]", \
513 device_address.addr[0], device_address.addr[1], device_address.addr[2], \
514 device_address.addr[3], device_address.addr[4], device_address.addr[5]);
516 ret = bluetooth_bond_device(&device_address);
519 TC_PRT("%s failed with [0x%04x]", tc_table[17].tc_name, ret);
525 case 19: /*Cancel bonding */
528 TC_PRT("TC : %s", tc_table[18].tc_name);
529 ret = bluetooth_cancel_bonding();
532 TC_PRT("%s failed with [0x%04x]", tc_table[18].tc_name, ret);
538 case 20: /*unbonding */
540 bluetooth_device_address_t device_address={{0x00,0x19,0x0E,0x01,0x61,0x17}}; /* DO-DH79-PYUN04 */
541 //bluetooth_device_address_t device_address={{0x00,0x16,0x38,0xC3,0x1F,0xD2}};
543 TC_PRT("TC : %s", tc_table[19].tc_name);
544 ret = bluetooth_unbond_device(&device_address);
547 TC_PRT("%s failed with [0x%04x]", tc_table[19].tc_name, ret);
553 case 21: /*Get paired device */
555 bluetooth_device_info_t devinfo;
556 bluetooth_device_address_t device_address={{0x00,0x16,0x38,0xC3,0x1F,0xD2}};
558 memset(&devinfo, 0x00, sizeof(bluetooth_device_info_t));
560 ret = bluetooth_get_bonded_device(&device_address, &devinfo);
561 if (ret != BLUETOOTH_ERROR_NONE)
563 TC_PRT("bluetooth_get_bonded_device failed with [%d]",ret);
567 TC_PRT("Name [%s]", devinfo.device_name.name);
568 TC_PRT("Major Class [%d]", devinfo.device_class.major_class);
569 TC_PRT("Minor Class [%d]", devinfo.device_class.minor_class);
570 TC_PRT("Service Class [%d]", devinfo.device_class.service_class);
571 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]);
577 case 22: /*set alias for bonded device */
579 bluetooth_device_address_t device_address={{0x00,0x16,0x38,0xC3,0x1F,0xD2}};
581 TC_PRT("TC : %s", tc_table[21].tc_name);
583 ret = bluetooth_set_alias(&device_address, "Renamed device");
585 TC_PRT("%s failed with [0x%04x]", tc_table[21].tc_name, ret);
591 bluetooth_device_address_t device_address={{0x00,0x16,0x38,0xC3,0x1F,0xD2}};
593 TC_PRT("TC : %s", tc_table[22].tc_name);
595 ret = bluetooth_authorize_device(&device_address, TRUE);
597 TC_PRT("%s failed with [0x%04x]", tc_table[22].tc_name, ret);
602 bluetooth_device_address_t device_address={{0x00,0x16,0x38,0xC3,0x1F,0xD2}};
604 TC_PRT("TC : %s", tc_table[23].tc_name);
606 ret = bluetooth_authorize_device(&device_address, FALSE);
608 TC_PRT("%s failed with [0x%04x]", tc_table[23].tc_name, ret);
613 bluetooth_device_address_t device_address={{0x00,0x19,0x0E,0x01,0x61,0x17}}; /* DO-DH79-PYUN04 */
615 TC_PRT("TC : %s", tc_table[24].tc_name);
617 ret = bluetooth_search_service(&device_address);
619 TC_PRT("%s failed with [0x%04x]", tc_table[24].tc_name, ret);
624 TC_PRT("TC : %s", tc_table[25].tc_name);
626 ret = bluetooth_cancel_service_search();
628 TC_PRT("%s failed with [0x%04x]", tc_table[24].tc_name, ret);
633 gboolean connected = FALSE;
634 bluetooth_device_address_t device_address={{0x00,0x1B,0x66,0x01,0x23,0x1C}}; /* Gennheiser PX210BT */
636 TC_PRT("TC : %s", tc_table[26].tc_name);
638 ret = bluetooth_is_device_connected(&device_address, BLUETOOTH_A2DP_SERVICE, &connected);
640 TC_PRT("%s failed with [0x%04x]", tc_table[24].tc_name, ret);
642 TC_PRT("connected : %d", connected);
647 TC_PRT("TC : %s", tc_table[27].tc_name);
649 ret = bluetooth_reset_adapter();
651 TC_PRT("%s failed with [0x%04x]", tc_table[27].tc_name, ret);
657 TC_PRT("TC : %s", tc_table[28].tc_name);
659 ret = bluetooth_audio_init(bt_audio_event_callback, NULL);
661 TC_PRT("%s failed with [0x%04x]", tc_table[28].tc_name, ret);
666 TC_PRT("TC : %s", tc_table[29].tc_name);
668 ret = bluetooth_audio_deinit();
670 TC_PRT("%s failed with [0x%04x]", tc_table[29].tc_name, ret);
676 //bluetooth_device_address_t device_address={{0x58,0x17,0x0C,0xEC,0x6A,0xF3}};
677 bluetooth_device_address_t device_address={{0x00,0x0D,0xFD,0x24,0x5E,0xFF}}; /* Motorola S9 */
679 TC_PRT("TC : %s", tc_table[30].tc_name);
681 ret = bluetooth_audio_connect(&device_address);
683 TC_PRT("%s failed with [0x%04x]", tc_table[30].tc_name, ret);
689 //bluetooth_device_address_t device_address={{0x58,0x17,0x0C,0xEC,0x6A,0xF3}};
690 bluetooth_device_address_t device_address={{0x00,0x0D,0xFD,0x24,0x5E,0xFF}}; /* Motorola S9 */
692 TC_PRT("TC : %s", tc_table[31].tc_name);
694 ret = bluetooth_audio_disconnect(&device_address);
696 TC_PRT("%s failed with [0x%04x]", tc_table[31].tc_name, ret);
702 bluetooth_device_address_t device_address={{0x58,0x17,0x0C,0xEC,0x6A,0xF3}};
704 TC_PRT("TC : %s", tc_table[32].tc_name);
706 ret = bluetooth_ag_connect(&device_address);
708 TC_PRT("%s failed with [0x%04x]", tc_table[32].tc_name, ret);
714 bluetooth_device_address_t device_address={{0x58,0x17,0x0C,0xEC,0x6A,0xF3}};
716 TC_PRT("TC : %s", tc_table[33].tc_name);
718 ret = bluetooth_ag_disconnect(&device_address);
720 TC_PRT("%s failed with [0x%04x]", tc_table[33].tc_name, ret);
726 bluetooth_device_address_t device_address={{0x58,0x17,0x0C,0xEC,0x6A,0xF3}};
728 TC_PRT("TC : %s", tc_table[34].tc_name);
730 ret = bluetooth_av_connect(&device_address);
732 TC_PRT("%s failed with [0x%04x]", tc_table[34].tc_name, ret);
738 bluetooth_device_address_t device_address={{0x58,0x17,0x0C,0xEC,0x6A,0xF3}};
740 TC_PRT("TC : %s", tc_table[35].tc_name);
742 ret = bluetooth_av_disconnect(&device_address);
744 TC_PRT("%s failed with [0x%04x]", tc_table[35].tc_name, ret);
749 unsigned int volume = 0;
751 ret = bluetooth_ag_get_headset_volume(&volume);
753 TC_PRT("failed with [0x%04x]", ret);
755 TC_PRT("volume: %u", volume);
760 ret = bluetooth_ag_set_speaker_gain(10);
762 TC_PRT("failed with [0x%04x]", ret);
768 if (bluetooth_oob_read_local_data(&g_local_oob_data.oob_data))
769 TC_PRT("ERROR in bluetooth_oob_read_local_data\n");
771 TC_PRT("SUCESS in bluetooth_oob_read_local_data\n");
772 TC_PRT("hash = [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X"
773 "%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]\n",
774 g_local_oob_data.oob_data.hash[0],
775 g_local_oob_data.oob_data.hash[1],
776 g_local_oob_data.oob_data.hash[2],
777 g_local_oob_data.oob_data.hash[3],
778 g_local_oob_data.oob_data.hash[4],
779 g_local_oob_data.oob_data.hash[5],
780 g_local_oob_data.oob_data.hash[6],
781 g_local_oob_data.oob_data.hash[7],
782 g_local_oob_data.oob_data.hash[8],
783 g_local_oob_data.oob_data.hash[9],
784 g_local_oob_data.oob_data.hash[10],
785 g_local_oob_data.oob_data.hash[11],
786 g_local_oob_data.oob_data.hash[12],
787 g_local_oob_data.oob_data.hash[13],
788 g_local_oob_data.oob_data.hash[14],
789 g_local_oob_data.oob_data.hash[15]);
791 TC_PRT("randomizer = [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X"
792 "%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]\n",
793 g_local_oob_data.oob_data.randomizer[0],
794 g_local_oob_data.oob_data.randomizer[1],
795 g_local_oob_data.oob_data.randomizer[2],
796 g_local_oob_data.oob_data.randomizer[3],
797 g_local_oob_data.oob_data.randomizer[4],
798 g_local_oob_data.oob_data.randomizer[5],
799 g_local_oob_data.oob_data.randomizer[6],
800 g_local_oob_data.oob_data.randomizer[7],
801 g_local_oob_data.oob_data.randomizer[8],
802 g_local_oob_data.oob_data.randomizer[9],
803 g_local_oob_data.oob_data.randomizer[10],
804 g_local_oob_data.oob_data.randomizer[11],
805 g_local_oob_data.oob_data.randomizer[12],
806 g_local_oob_data.oob_data.randomizer[13],
807 g_local_oob_data.oob_data.randomizer[14],
808 g_local_oob_data.oob_data.randomizer[15]);
810 TC_PRT("hash_len: %d\n", g_local_oob_data.oob_data.hash_len);
811 TC_PRT("randomizer_len: %d\n", g_local_oob_data.oob_data.randomizer_len);
817 TC_PRT("hash_len: %d\n", g_local_oob_data.oob_data.hash_len);
818 TC_PRT("randomizer_len: %d\n", g_local_oob_data.oob_data.randomizer_len);
820 if (bluetooth_oob_add_remote_data(&g_local_oob_data.address,
821 &g_local_oob_data.oob_data))
822 TC_PRT("ERROR in bluetooth_oob_add_remote_data\n");
824 TC_PRT(" bluetooth_oob_add_remote_data SUCCESS\n");
830 if (bluetooth_oob_remove_remote_data(&g_local_oob_data.address))
831 TC_PRT("ERROR in bluetooth_oob_remove_remote_data\n");
833 TC_PRT(" bluetooth_oob_remove_remote_data SUCCESS\n");
838 bluetooth_opc_init();
843 bluetooth_opc_deinit();
848 bluetooth_device_address_t remote_address = {{0}};
851 remote_address.addr[0] = 0x00; remote_address.addr[1] = 0x02; remote_address.addr[2] = 0x70;
852 remote_address.addr[3] = 0x2B; remote_address.addr[4] = 0xD3; remote_address.addr[5]= 0xAF;
854 char *files[5] = {NULL};
856 files[0] = "/opt/media/Images/image1.jpg";
857 // files[1] = "/opt/media/Images/image2.jpg";
858 // files[2] = "/opt/media/Images/image3.jpg";
859 bluetooth_opc_push_files(&remote_address, files);
864 bluetooth_opc_cancel_push();
870 exist = bluetooth_opc_session_is_exist();
871 TC_PRT("exist: %d", exist);
876 bluetooth_network_activate_server();
881 bluetooth_network_deactivate_server();
886 bluetooth_device_address_t device_address = {{0x00, 0x02, 0xA2, 0x14, 0x40, 0x51}};
887 bluetooth_network_connect(&device_address, BLUETOOTH_NETWORK_NAP_ROLE, NULL);
892 bluetooth_device_address_t device_address = {{0x00, 0x02, 0xA2, 0x14, 0x40, 0x51}};
893 bluetooth_network_disconnect(&device_address);
898 bluetooth_obex_server_init("/opt/media/Downloads");
903 bluetooth_obex_server_deinit();
908 bluetooth_obex_server_init_without_agent("/opt/media/Downloads");
913 bluetooth_obex_server_deinit_without_agent();
918 bluetooth_obex_server_is_activated();
923 bluetooth_obex_server_accept_connection();
924 TC_PRT(" bluetooth_obex_server_accept_connection SUCCESS\n");
929 bluetooth_obex_server_reject_connection();
934 bluetooth_obex_server_accept_authorize("abc");
939 bluetooth_obex_server_reject_authorize();
944 bluetooth_obex_server_set_destination_path("/opt/media");
949 bluetooth_obex_server_set_root("/opt/media");
954 bluetooth_obex_server_cancel_transfer(0);
959 bluetooth_obex_server_cancel_all_transfers();
965 ret = bluetooth_hid_init(bt_hid_event_callback, NULL);
967 TC_PRT("Failed with [0x%04x]", ret);
972 ret = bluetooth_hid_deinit();
974 TC_PRT("Failed with [0x%04x]", ret);
979 /* Apple wireless keyboard */
980 hid_device_address_t device_address={{0xE8,0x06,0x88,0x3B,0x18,0xBA}};
982 ret = bluetooth_hid_connect(&device_address);
984 TC_PRT("Failed with [0x%04x]", ret);
989 /* Apple wireless keyboard */
990 hid_device_address_t device_address={{0xE8,0x06,0x88,0x3B,0x18,0xBA}};
992 ret = bluetooth_hid_disconnect(&device_address);
994 TC_PRT("Failed with [0x%04x]", ret);
1000 bluetooth_device_address_t device_address = {{0x00, 0x02, 0x2F, 0x92, 0x7B, 0xF5}};
1002 ret = bluetooth_rfcomm_connect(&device_address, rfcomm_test_uuid_spp);
1003 //ret = bluetooth_rfcomm_connect(&device_address, "1");
1006 TC_PRT("Failed with [0x%04x]", ret);
1011 ret = bluetooth_rfcomm_disconnect(-1);
1014 TC_PRT("Failed with [0x%04x]", ret);
1019 ret = bluetooth_rfcomm_disconnect(g_ret_client_fd1);
1022 TC_PRT("Failed with [0x%04x]", ret);
1027 ret = bluetooth_rfcomm_write(g_ret_client_fd1, "123456789 12345", 20);
1030 TC_PRT("Failed with [0x%04x]", ret);
1035 gboolean is_connected;
1037 is_connected = bluetooth_rfcomm_is_client_connected();
1039 TC_PRT("Connected: %d", is_connected);
1044 ret = bluetooth_rfcomm_create_socket(rfcomm_test_uuid_spp);
1046 TC_PRT("Failed with [0x%04x]", ret);
1048 TC_PRT("Returned FD = %d", ret);
1054 ret = bluetooth_rfcomm_create_socket(rfcomm_test_uuid_custom);
1056 TC_PRT("Failed with [0x%04x]", ret);
1058 TC_PRT("Returned FD = %d", ret);
1064 ret = bluetooth_rfcomm_remove_socket(server_fd);
1066 TC_PRT("Failed with [0x%04x]", ret);
1069 case 83: /*Listen and accept */
1072 ret = bluetooth_rfcomm_listen_and_accept(server_fd, 1);
1074 TC_PRT("Failed with [0x%04x]", ret);
1076 TC_PRT("result = %d", ret);
1079 case 84: /*Listen */
1082 ret = bluetooth_rfcomm_listen(server_fd, 1);
1084 TC_PRT("Failed with [0x%04x]", ret);
1086 TC_PRT("result = %d", ret);
1091 ret = bluetooth_rfcomm_server_disconnect(client_fd);
1093 TC_PRT("Failed with [0x%04x]", ret);
1100 available = bluetooth_rfcomm_is_server_uuid_available(rfcomm_test_uuid_spp);
1102 TC_PRT("available: %d", available);
1107 ret = bluetooth_rfcomm_accept_connection(server_fd, &client_fd);
1109 TC_PRT("Failed with [0x%04x]", ret);
1110 TC_PRT("client fd: %d", client_fd);
1115 ret = bluetooth_rfcomm_reject_connection(server_fd);
1117 TC_PRT("Failed with [0x%04x]", ret);
1129 TC_PRT("bluetooth framework TC startup");
1131 if(!g_thread_supported())
1133 g_thread_init(NULL);
1136 dbus_g_thread_init();
1139 main_loop = g_main_loop_new(NULL, FALSE);
1144 TC_PRT("bluetooth framework TC cleanup");
1145 if( main_loop!= NULL)
1147 g_main_loop_unref(main_loop);
1151 int timeout_callback(void *data)
1153 TC_PRT("timeout callback");
1154 timeout_status = -1;
1156 g_main_loop_quit(main_loop);
1162 void bt_hid_event_callback(int event, hid_event_param_t* param, void *user_data)
1164 TC_PRT(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
1165 TC_PRT("bt event callback 0x%04x", event);
1171 void bt_audio_event_callback(int event, bt_audio_event_param_t* param, void *user_data)
1173 TC_PRT(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
1174 TC_PRT("bt event callback 0x%04x", event);
1180 void bt_event_callback(int event, bluetooth_event_param_t* param, void *user_data)
1182 TC_PRT(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
1183 TC_PRT("bt event callback 0x%04x", event);
1186 case BLUETOOTH_EVENT_ENABLED:
1187 TC_PRT("BLUETOOTH_EVENT_ENABLED, result [0x%04x]", param->result);
1190 case BLUETOOTH_EVENT_DISABLED:
1191 TC_PRT("BLUETOOTH_EVENT_DISABLED, result [0x%04x]", param->result);
1194 case BLUETOOTH_EVENT_LOCAL_NAME_CHANGED:
1195 TC_PRT("BLUETOOTH_EVENT_LOCAL_NAME_CHANGED, result [0x%04x]", param->result);
1196 if (param->result == BLUETOOTH_ERROR_NONE)
1198 bluetooth_device_name_t *local_name = (bluetooth_device_name_t *)param->param_data;
1199 tc_result(TC_PASS, 6);
1200 TC_PRT("Changed Name : [%s]", local_name->name);
1204 tc_result(TC_FAIL, 6);
1209 case BLUETOOTH_EVENT_DISCOVERY_STARTED:
1210 TC_PRT("BLUETOOTH_EVENT_DISCOVERY_STARTED, result [0x%04x]", param->result);
1213 case BLUETOOTH_EVENT_REMOTE_DEVICE_FOUND:
1215 bluetooth_device_info_t *device_info = NULL;
1216 TC_PRT("BLUETOOTH_EVENT_REMOTE_DEVICE_FOUND, result [0x%04x]", param->result);
1217 device_info = (bluetooth_device_info_t *)param->param_data;
1218 memcpy(&searched_device, &device_info->device_address, sizeof(bluetooth_device_address_t));
1219 TC_PRT("dev [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]", \
1220 device_info->device_address.addr[0], device_info->device_address.addr[1], device_info->device_address.addr[2], \
1221 device_info->device_address.addr[3], device_info->device_address.addr[4], device_info->device_address.addr[5]);
1225 case BLUETOOTH_EVENT_REMOTE_DEVICE_NAME_UPDATED:
1227 bluetooth_device_info_t *device_info = NULL;
1228 TC_PRT("BLUETOOTH_EVENT_REMOTE_DEVICE_NAME_UPDATED, result [0x%04x]", param->result);
1229 device_info = (bluetooth_device_info_t *)param->param_data;
1230 memcpy(&searched_device, &device_info->device_address, sizeof(bluetooth_device_address_t));
1231 TC_PRT("dev [%s] [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]", device_info->device_name.name, \
1232 device_info->device_address.addr[0], device_info->device_address.addr[1], device_info->device_address.addr[2], \
1233 device_info->device_address.addr[3], device_info->device_address.addr[4], device_info->device_address.addr[5]);
1237 case BLUETOOTH_EVENT_DISCOVERY_FINISHED:
1238 TC_PRT("BLUETOOTH_EVENT_DISCOVERY_FINISHED, result [0x%04x]", param->result);
1241 case BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED:
1243 int *mode = (int *)param->param_data;
1244 TC_PRT("BT_DISCOVERABLE_MODE_CHANGED, result [0x%04x]", param->result);
1245 TC_PRT("mode [%d]", *mode);
1248 case BLUETOOTH_EVENT_DISCOVERABLE_TIMEOUT_CHANGED:
1250 int *timeout = (int *)param->param_data;
1251 TC_PRT("BLUETOOTH_EVENT_DISCOVERABLE_TIMEOUT_CHANGED, result [0x%04x]", param->result);
1252 TC_PRT("timeout [%d]", *timeout);
1255 case BLUETOOTH_EVENT_BONDING_FINISHED:
1257 TC_PRT("BLUETOOTH_EVENT_BONDING_FINISHED, result [0x%04x]", param->result);
1258 if (param->result >= BLUETOOTH_ERROR_NONE)
1260 bluetooth_device_info_t *device_info = NULL;
1261 tc_result(TC_PASS, 12);
1262 device_info = (bluetooth_device_info_t *)param->param_data;
1263 if (device_info == NULL)
1266 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, \
1267 device_info->device_address.addr[0], device_info->device_address.addr[1], device_info->device_address.addr[2], \
1268 device_info->device_address.addr[3], device_info->device_address.addr[4], device_info->device_address.addr[5], \
1269 device_info->device_class.major_class, device_info->device_class.minor_class, device_info->device_class.service_class);
1273 tc_result(TC_FAIL, 12);
1278 case BLUETOOTH_EVENT_BONDED_DEVICE_FOUND:
1280 // bluetooth_get_bonded_device_list is changed as synchronous API. This event is not used any more.
1284 TC_PRT("BLUETOOTH_EVENT_BONDED_DEVICE_FOUND, result [0x%04x]", param->result);
1285 if (param->result >= BLUETOOTH_ERROR_NONE)
1287 ///tc_result(TC_PASS, 15);
1288 bluetooth_device_info_t * bt_dev_info= (bluetooth_device_info_t*)param->param_data;
1290 TC_PRT("Dev Name = %s, Dev add = %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X, COD (major,minor,service)= 0x%x:%x:%x\n", bt_dev_info->device_name.name,
1291 bt_dev_info->device_address.addr[0], bt_dev_info->device_address.addr[1], bt_dev_info->device_address.addr[2], \
1292 bt_dev_info->device_address.addr[3], bt_dev_info->device_address.addr[4], bt_dev_info->device_address.addr[5], \
1293 bt_dev_info->device_class.major_class, bt_dev_info->device_class.minor_class, bt_dev_info->device_class.service_class);
1297 if(param->result == BLUETOOTH_ERROR_END_OF_DEVICE_LIST) /*End of the Device found indication*/
1299 tc_result(TC_PASS, 15);
1300 TC_PRT("*****<<No more BLUETOOTH_EVENT_BONDED_DEVICE_FOUND indication>>***** ");
1304 tc_result(TC_FAIL, 15);
1305 TC_PRT("*****API failed ***** ");
1310 case BLUETOOTH_EVENT_SERVICE_SEARCHED:
1313 TC_PRT("BLUETOOTH_EVENT_SERVICE_SEARCHED, result [0x%04x]", param->result);
1314 if (param->result >= BLUETOOTH_ERROR_NONE)
1316 tc_result(TC_PASS, 18);
1317 bt_sdp_info_t * bt_sdp_info=param->param_data;
1319 TC_PRT("Dev add = %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n",
1320 bt_sdp_info->device_addr.addr[0], bt_sdp_info->device_addr.addr[1], bt_sdp_info->device_addr.addr[2], \
1321 bt_sdp_info->device_addr.addr[3], bt_sdp_info->device_addr.addr[4], bt_sdp_info->device_addr.addr[5]);
1323 TC_PRT("Supported service list:\n");
1324 for(i=0; i<bt_sdp_info->service_index; i++)
1325 TC_PRT("[%#x]\n", bt_sdp_info->service_list_array[i]);
1330 tc_result(TC_FAIL, 18);
1334 case BLUETOOTH_EVENT_RFCOMM_DATA_RECEIVED:
1336 TC_PRT("BLUETOOTH_EVENT_RFCOMM_DATA_RECEIVED, result [0x%04x]", param->result);
1337 bluetooth_rfcomm_received_data_t *rx_data = param->param_data;
1338 printf("\n FD = %d \nBuffer len = %d ", rx_data->socket_fd, rx_data->buffer_size);
1339 if (rx_data->buffer_size < sizeof(oob_data_t))
1340 TC_PRT("Complete oob data is not recivedn");
1342 memcpy(&g_remote_oob_data,rx_data->buffer, sizeof(oob_data_t));
1343 //tc_result(TC_PASS, 21);
1346 case BLUETOOTH_EVENT_RFCOMM_CONNECTED:
1348 bluetooth_rfcomm_connection_t *con_ind = (bluetooth_rfcomm_connection_t *)param->param_data;
1349 TC_PRT("BLUETOOTH_EVENT_RFCOMM_CONNECTED, result [0x%04x], fd = %d, device add = 0x%X:%X:%X:%X:%X:%X, Role = %s", param->result,
1351 con_ind->device_addr.addr[0], con_ind->device_addr.addr[1], con_ind->device_addr.addr[2],
1352 con_ind->device_addr.addr[3], con_ind->device_addr.addr[4], con_ind->device_addr.addr[5],
1353 (con_ind->device_role == RFCOMM_ROLE_SERVER)? "SERVER":"CLIENT");
1354 //tc_result(TC_PASS, 22);
1355 if((con_ind->device_role == RFCOMM_ROLE_CLIENT) && (con_ind->socket_fd > 0))
1357 g_ret_client_fd1 = con_ind->socket_fd;
1360 if((con_ind->device_role == RFCOMM_ROLE_SERVER) && (con_ind->socket_fd > 0))
1362 client_fd = con_ind->socket_fd;
1367 case BLUETOOTH_EVENT_RFCOMM_DISCONNECTED:
1369 bluetooth_rfcomm_disconnection_t *disconnection_ind = (bluetooth_rfcomm_disconnection_t *)param->param_data;;
1370 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,
1371 disconnection_ind->device_addr.addr[0], disconnection_ind->device_addr.addr[1], disconnection_ind->device_addr.addr[2],
1372 disconnection_ind->device_addr.addr[3], disconnection_ind->device_addr.addr[4], disconnection_ind->device_addr.addr[5] );
1373 //tc_result(TC_PASS, 22);
1376 case BLUETOOTH_EVENT_NETWORK_SERVER_CONNECTED:
1378 bluetooth_network_device_info_t *dev_info = (bluetooth_network_device_info_t *)param->param_data;
1380 TC_PRT("BLUETOOTH_EVENT_RFCOMM_DISCONNECTED, result [0x%04x]", param->result);
1381 TC_PRT("interface name: %s", dev_info->interface_name);
1383 TC_PRT("device add = %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n",
1384 dev_info->device_address.addr[0], dev_info->device_address.addr[1], dev_info->device_address.addr[2],
1385 dev_info->device_address.addr[3], dev_info->device_address.addr[4], dev_info->device_address.addr[5] );
1388 case BLUETOOTH_EVENT_NETWORK_SERVER_DISCONNECTED:
1390 bluetooth_network_device_info_t *dev_info = (bluetooth_network_device_info_t *)param->param_data;
1392 TC_PRT("BLUETOOTH_EVENT_RFCOMM_DISCONNECTED, result [0x%04x]", param->result);
1393 TC_PRT("interface name: %s", dev_info->interface_name);
1395 TC_PRT("device add = %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n",
1396 dev_info->device_address.addr[0], dev_info->device_address.addr[1], dev_info->device_address.addr[2],
1397 dev_info->device_address.addr[3], dev_info->device_address.addr[4], dev_info->device_address.addr[5] );
1401 case BLUETOOTH_EVENT_HDP_CONNECTED:
1403 bt_hdp_connected_t *conn_ind = (bt_hdp_connected_t *)param->param_data;
1405 TC_PRT("BLUETOOTH_EVENT_HDP_CONNECTED, Result = %s\n", (param->result == 0)? "BLUETOOTH_ERROR_NONE": "BLUETOOTH_ERROR_XXXX");
1406 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");
1407 TC_PRT("device add = %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n",
1408 conn_ind->device_address.addr[0], conn_ind->device_address.addr[1], conn_ind->device_address.addr[2],
1409 conn_ind->device_address.addr[3], conn_ind->device_address.addr[4], conn_ind->device_address.addr[5] );
1411 g_ret_client_fd1 = conn_ind->channel_id;
1415 case BLUETOOTH_EVENT_HDP_DISCONNECTED:
1417 bt_hdp_disconnected_t *dis_ind = (bt_hdp_disconnected_t *)param->param_data;
1419 TC_PRT("BLUETOOTH_EVENT_HDP_DISCONNECTED, Result = %s\n", (param->result == 0)? "BLUETOOTH_ERROR_NONE": "BLUETOOTH_ERROR_XXXX");
1420 TC_PRT("Channel = %d, Add = device add = %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n", dis_ind->channel_id,
1421 dis_ind->device_address.addr[0], dis_ind->device_address.addr[1], dis_ind->device_address.addr[2],
1422 dis_ind->device_address.addr[3], dis_ind->device_address.addr[4], dis_ind->device_address.addr[5]);
1426 case BLUETOOTH_EVENT_HDP_DATA_RECEIVED:
1428 bt_hdp_data_ind_t *data_ind = (bt_hdp_data_ind_t *)param->param_data;
1430 TC_PRT("BLUETOOTH_EVENT_HDP_DATA_RECEIVED, Result = %s\n", (param->result == 0)? "BLUETOOTH_ERROR_NONE": "BLUETOOTH_ERROR_XXXX");
1431 TC_PRT("Data received from channel id = %d and size =%d, buff =[%s]\n", data_ind->channel_id, data_ind->size, data_ind->buffer);
1436 case BLUETOOTH_EVENT_OPC_CONNECTED:
1437 TC_PRT("BLUETOOTH_EVENT_OPC_CONNECTED");
1440 case BLUETOOTH_EVENT_OPC_DISCONNECTED:
1441 TC_PRT("BLUETOOTH_EVENT_OPC_DISCONNECTED");
1443 case BLUETOOTH_EVENT_OPC_TRANSFER_STARTED:
1445 TC_PRT("BLUETOOTH_EVENT_OPC_TRANSFER_STARTED");
1446 if (param->param_data) {
1447 bt_opc_transfer_info_t *info = param->param_data;
1448 TC_PRT("file %s", info->filename);
1449 TC_PRT("size %ld", info->size);
1453 case BLUETOOTH_EVENT_OPC_TRANSFER_PROGRESS:
1455 TC_PRT("BLUETOOTH_EVENT_OPC_TRANSFER_PROGRESS");
1458 case BLUETOOTH_EVENT_OPC_TRANSFER_COMPLETE:
1460 TC_PRT("BLUETOOTH_EVENT_OPC_TRANSFER_COMPLETE");
1461 bt_opc_transfer_info_t *info = param->param_data;
1462 TC_PRT("file %s", info->filename);
1463 TC_PRT("size %ld", info->size);
1467 case BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_AUTHORIZE:
1468 TC_PRT("BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_AUTHORIZE");
1471 case BLUETOOTH_EVENT_OBEX_SERVER_CONNECTION_AUTHORIZE:
1472 TC_PRT("BLUETOOTH_EVENT_OBEX_SERVER_CONNECTION_AUTHORIZE");
1475 case BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_STARTED:
1476 TC_PRT("BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_STARTED");
1477 bt_obex_server_transfer_info_t *info = param->param_data;
1478 current_transfer_id = info->transfer_id;
1481 case BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_PROGRESS:
1482 TC_PRT("BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_PROGRESS");
1485 case BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_COMPLETED:
1486 TC_PRT("BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_COMPLETED");
1490 case BLUETOOTH_EVENT_GATT_PRIM_SVC_DISCOVERED:
1492 TC_PRT("BLUETOOTH_EVENT_GATT_PRIM_SVC_DISCOVERED");
1493 bt_gatt_handle_info_t *prim_svc = param->param_data;
1496 if (prim_svc == NULL) {
1497 TC_PRT("prim_svc is NULL");
1501 for (i = 0; i < prim_svc->count; i++) {
1502 TC_PRT("prim_svc[%d] = %s\n", i, prim_svc->handle[i]);
1508 case BLUETOOTH_EVENT_GATT_SVC_CHAR_DISCOVERED:
1510 TC_PRT("BLUETOOTH_EVENT_GATT_SVC_CHAR_DISCOVERED");
1511 bt_gatt_discovered_char_t *svc_char = param->param_data;
1514 if (svc_char == NULL) {
1515 TC_PRT("svc_char is NULL");
1519 if (svc_char->service_handle != NULL) {
1520 TC_PRT("svc_char->service_handle %s \n", svc_char->service_handle);
1523 for (i = 0; i < svc_char->handle_info.count; i++) {
1524 TC_PRT("svc_char.handle_info.handle[%d] = %s\n", i, svc_char->handle_info.handle[i]);
1530 case BLUETOOTH_EVENT_GATT_SVC_PROP_RECEIVED:
1532 TC_PRT("BLUETOOTH_EVENT_GATT_SVC_PROP_RECEIVED");
1533 bt_gatt_service_property_t *svc_pty = param->param_data;
1536 if (svc_pty == NULL) {
1537 TC_PRT("char_pty is NULL \n");
1541 if (svc_pty->service_handle != NULL) {
1542 TC_PRT("svc_pty->service_handle %s \n", svc_pty->service_handle);
1545 if (svc_pty->uuid != NULL) {
1546 TC_PRT("svc_pty->uuid %s \n", svc_pty->uuid);
1549 for (i = 0; i < svc_pty->handle_info.count; i++) {
1550 TC_PRT("svc_char[%d] = %s\n", i, svc_pty->handle_info.handle[i]);
1556 case BLUETOOTH_EVENT_GATT_CHAR_PROP_RECEIVED:
1558 TC_PRT("BLUETOOTH_EVENT_GATT_CHAR_PROP_RECEIVED");
1559 bt_gatt_char_property_t *char_pty = param->param_data;
1562 if (char_pty->char_handle != NULL) {
1563 TC_PRT("char_pty->char_handle %s \n", char_pty->char_handle);
1566 if (char_pty->uuid != NULL) {
1567 TC_PRT("char_pty->uuid %s \n", char_pty->uuid);
1570 if (char_pty == NULL) {
1571 TC_PRT("char_pty is NULL \n");
1575 if (char_pty->name != NULL) {
1576 TC_PRT("char_pty->name %s \n", char_pty->name);
1579 if (char_pty->description != NULL) {
1580 TC_PRT("char_pty->description %s \n", char_pty->description);
1583 if (char_pty->val != NULL) {
1584 TC_PRT("char_pty->val_len %d \n", char_pty->val_len);
1586 for (i = 0; i < char_pty->val_len; i ++)
1587 TC_PRT("char_pty->val %02x \n", char_pty->val[i]);
1594 TC_PRT("received event [0x%04x]", event);
1597 TC_PRT("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<");
1600 static gboolean key_event_cb(GIOChannel * chan, GIOCondition cond , gpointer data)
1606 memset(buf, 0, sizeof(buf));
1608 if(g_io_channel_read_chars(chan, buf, sizeof(buf),
1609 &len, NULL) == G_IO_STATUS_ERROR) {
1610 TC_PRT("IO Channel read error");
1620 g_idle_add(test_input_callback, (void*)test_id);
1630 key_io=g_io_channel_unix_new(fileno(stdin));
1632 g_io_channel_set_encoding(key_io, NULL, NULL);
1633 g_io_channel_set_flags(key_io, G_IO_FLAG_NONBLOCK, NULL);
1635 g_io_add_watch(key_io, G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
1636 key_event_cb, NULL);
1637 g_io_channel_unref(key_io);
1639 g_main_loop_run(main_loop);