test/bluetooth-frwk-test.c

   1 /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   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
   7  *
   8  *              http://www.apache.org/licenses/LICENSE-2.0
   9  *
  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.
  15  *
  16  */
  17
  18 /**
  19  * @file       bluetooth-frwk-test.c
  20  * @brief      This is the source file for bluetooth framework test suite.
  21  */
  22
  23 #include <stdio.h>
  24 #include <string.h>
  25 #include <glib.h>
  26 #include <dbus/dbus-glib.h>
  27 #include <pthread.h>
  28 #include <dbus/dbus.h>
  29
  30 #include "bluetooth-api.h"
  31 #include "bluetooth-hid-api.h"
  32 #include "bluetooth-audio-api.h"
  33
  34
  35 bluetooth_device_address_t searched_device = { {0} };
  36
  37 #define TC_TIMEOUT      30000
  38
  39 #define BT_DEFAULT_DEV_NAME "SLP-BT-TEST-TARGET"
  40 #define DISCOVER_TIMEOUT 20
  41 #define DISCOVER_CANCEL_INTERVAL 3
  42
  43 #define PRT(format, args...) printf("%s:%d() "format, __FUNCTION__, __LINE__, ##args)
  44 #define TC_PRT(format, args...) PRT(format"\n", ##args)
  45
  46 #define TC_PASS 1
  47 #define TC_FAIL 0
  48 int client_fd = 0;
  49 int server_fd = 0;
  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;
  53
  54 char *svc_obj_path = NULL;
  55 char *char_obj_path = NULL;
  56 char *desc_obj_path = NULL;
  57
  58 int selection;
  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";
  63
  64
  65 GMainLoop *main_loop = NULL;
  66
  67 int current_transfer_id = 0;
  68
  69 typedef struct {
  70         bluetooth_device_address_t address;
  71         bt_oob_data_t oob_data;
  72 } oob_data_t;
  73
  74 oob_data_t g_local_oob_data;
  75 oob_data_t g_remote_oob_data;
  76
  77
  78 typedef struct {
  79         const char *tc_name;
  80         int tc_code;
  81 } tc_table_t;
  82
  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);
  86
  87
  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},
 119
 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},
 130
 131         {"bluetooth_oob_read_local_data"        , 39},
 132         {"bluetooth_oob_add_remote_data" , 40},
 133         {"bluetooth_oob_remove_remote_data" , 41},
 134
 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},
 140
 141         {"bluetooth_network_activate_server"    , 47},
 142         {"bluetooth_network_deactivate_server" , 48},
 143         {"bluetooth_network_connect" , 49},
 144         {"bluetooth_network_disconnect" , 50},
 145
 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},
 159
 160         {"bluetooth_hid_init"   , 65},
 161         {"bluetooth_hid_deinit" , 66},
 162         {"bluetooth_hid_connect"        , 67},
 163         {"bluetooth_hid_disconnect"     , 68},
 164
 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},
 170
 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},
 181
 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},
 191
 192 #if 0
 193         {"bluetooth_rfcomm_is_server_uuid_available"    , 26},
 194
 195         {"bluetooth_hdp_activate"       , 30},
 196         {"bluetooth_hdp_deactivate"     , 31},
 197         {"bluetooth_hdp_connect"        , 32},
 198         {"bluetooth_hdp_disconnect"     , 33},
 199         {"bluetooth_hdp_send_data"      , 34},
 200
 201         {"bluetooth_opc_init"           , 35},
 202         {"bluetooth_opc_push_file"      , 36},
 203         {"bluetooth_opc_cancel_push"    , 37},
 204         {"bluetooth_opc_deinit"         , 38},
 205         {"bluetooth_obex_server_init"   , 39},
 206         {"bluetooth_obex_server_deinit" , 40},
 207         {"bluetooth_obex_server_accept_authorize"       , 41},
 208         {"bluetooth_obex_server_reject_authorize"       , 42},
 209         {"bluetooth_is_supported"       , 43},
 210         {"bluetooth_opc_session_is_exist"       , 46},
 211         {"bluetooth_obex_server_is_activated"   , 47},
 212         {"bluetooth_obex_server_cancel_transfer"        , 48},
 213
 214         {"bluetooth_oob_read_local_data"        , 50},
 215         {"bluetooth_oob_add_remote_data"        , 51},
 216         {"bluetooth_oob_remove_remote_data"     , 52},
 217
 218         {"bluetooth_network_activate_server"    , 60},
 219         {"bluetooth_network_deactivate_server"  , 61},
 220         {"bluetooth_network_connect"    , 62},
 221         {"bluetooth_network_disconnect" , 63},
 222
 223         {"bluetooth_gatt_discover_primary_services", 64},
 224         {"bluetooth_gatt_discover_service_characteristics",     65},
 225         {"bluetooth_gatt_get_service_property",         66},
 226         {"bluetooth_gatt_get_characteristics_value",    67},
 227         {"bluetooth_gatt_set_characteristics_value",    68},
 228 #endif
 229         /* -----------------------------------------*/
 230         {"Finish"                                                       , 0x00ff},
 231         {NULL                                                           , 0x0000},
 232
 233 };
 234
 235 #define tc_result(success, tc_index) \
 236         TC_PRT("Test case [%d - %s] %s", tc_table[tc_index].tc_code, tc_table[tc_index].tc_name, ((success == TC_PASS) ? "Success" : "Failed"));
 237
 238 bluetooth_device_info_t bond_dev;
 239 int is_bond_device = FALSE;
 240
 241 void tc_usage_print(void)
 242 {
 243         int i = 0;
 244
 245         while (tc_table[i].tc_name) {
 246                 if (tc_table[i].tc_code != 0x00ff) {
 247                         TC_PRT("Key %d : usage %s", tc_table[i].tc_code, tc_table[i].tc_name);
 248                 } else {
 249                         TC_PRT("Key %d : usage %s\n\n", 0x00ff, tc_table[i].tc_name);
 250                 }
 251
 252                 i++;
 253         }
 254 }
 255
 256 int find_tc_number(int input)
 257 {
 258         int i = 0;
 259
 260         while (tc_table[i].tc_code != 0x0000) {
 261                 if (tc_table[i].tc_code == input)
 262                         return i;
 263                 i++;
 264         }
 265
 266         return -1;
 267 }
 268
 269 int test_input_callback(void *data)
 270 {
 271         int ret = 0;
 272         int test_id;
 273
 274         test_id = find_tc_number((int)data);
 275         TC_PRT("TC : %s[%d]", tc_table[test_id].tc_name, tc_table[test_id].tc_code);
 276
 277         switch (tc_table[test_id].tc_code) {
 278                 case 0x00ff:
 279                         TC_PRT("Finished");
 280                         g_main_loop_quit(main_loop);
 281                         break;
 282
 283                 case 1:
 284                         bluetooth_register_callback(bt_event_callback, NULL);
 285                         if (ret < 0) {
 286                                 TC_PRT("%s failed with [0x%04x]", tc_table[0].tc_name, ret);
 287                                 tc_result(TC_FAIL, 1);
 288                         }
 289                         break;
 290
 291                 case 2:
 292                         bluetooth_unregister_callback();
 293                         if (ret < 0) {
 294                                 TC_PRT("%s failed with [0x%04x]", tc_table[1].tc_name, ret);
 295                                 tc_result(TC_FAIL, 1);
 296                         }
 297                         break;
 298
 299                 case 3:
 300                         ret = bluetooth_enable_adapter();
 301                         if (ret < 0) {
 302                                 TC_PRT("%s failed with [0x%04x]", tc_table[2].tc_name, ret);
 303                                 tc_result(TC_FAIL, 1);
 304                         }
 305                         break;
 306
 307                 case 4:
 308                         ret = bluetooth_disable_adapter();
 309                         if (ret < 0) {
 310                                 TC_PRT("%s failed with [0x%04x]", tc_table[3].tc_name, ret);
 311                                 tc_result(TC_FAIL, 2);
 312                         }
 313                         break;
 314
 315                 case 5:
 316                 {
 317                         ret = bluetooth_check_adapter();
 318                         TC_PRT("state: %d", ret);
 319                         break;
 320                 }
 321
 322                 case 6:
 323                 {
 324                         bluetooth_device_address_t address = { {0} };
 325                         ret = bluetooth_get_local_address(&address);
 326                         if (ret < 0) {
 327                                 TC_PRT("%s failed with [0x%04x]", tc_table[5].tc_name, ret);
 328                         } else {
 329                                 TC_PRT("dev [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]", \
 330                                         address.addr[0], address.addr[1], address.addr[2], \
 331                                         address.addr[3], address.addr[4], address.addr[5]);
 332                         }
 333                         break;
 334                 }
 335
 336                 case 7:
 337                 {
 338                         bluetooth_device_name_t local_name = { {0} };
 339
 340                         ret = bluetooth_get_local_name(&local_name);
 341                         if (ret < 0) {
 342                                 TC_PRT("%s failed with [0x%04x]", tc_table[6].tc_name, ret);
 343                         } else {
 344                                 TC_PRT("name: %s", local_name.name);
 345                         }
 346                         break;
 347                 }
 348
 349                 case 8:
 350                 {
 351                         bluetooth_device_name_t local_name = { {0} };
 352                         snprintf(local_name.name, sizeof(local_name.name),
 353                                         "bt-frwk-pid-%d", getpid());
 354
 355                         ret = bluetooth_set_local_name(&local_name);
 356                         if (ret < 0) {
 357                                 TC_PRT("%s failed with [0x%04x]", tc_table[7].tc_name, ret);
 358                         }
 359                         break;
 360                 }
 361
 362                 case 90:
 363                 {
 364                         bluetooth_version_t local_version = { {0} };
 365                         snprintf(local_version.version, sizeof(local_version.version),
 366                                         "version%d", getpid());
 367
 368                         ret = bluetooth_get_local_version(&local_version);
 369                         if (ret < 0)
 370                                 TC_PRT("%s failed with [0x%04x]", tc_table[89].tc_name, ret);
 371                         else
 372                                 TC_PRT("version: %s", local_version.version);
 373                         break;
 374                 }
 375
 376                 case 9:
 377                 {
 378                         gboolean used = FALSE;
 379
 380                         ret = bluetooth_is_service_used(rfcomm_test_uuid_spp, &used);
 381                         if (ret < 0)
 382                                 TC_PRT("%s failed with [0x%04x]", tc_table[8].tc_name, ret);
 383                         else
 384                                 TC_PRT("used: %d", used);
 385                         break;
 386                 }
 387
 388                 case 10:
 389                 {
 390                         bluetooth_discoverable_mode_t mode;
 391                         ret = bluetooth_get_discoverable_mode(&mode);
 392                         if (ret < 0)
 393                                 TC_PRT("%s failed with [0x%04x]", tc_table[9].tc_name, ret);
 394                         else
 395                                 TC_PRT("BT Get Discoverable mode [%d]", mode);
 396                         break;
 397                 }
 398
 399                 case 11:
 400                 {
 401                         bluetooth_discoverable_mode_t mode = BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE;
 402                         ret = bluetooth_set_discoverable_mode(mode, 0);
 403                         if (ret < 0)
 404                                 TC_PRT("%s failed with [0x%04x]", tc_table[10].tc_name, ret);
 405                         else
 406                                 TC_PRT("BT Set Discoverable mode [%d]", mode);
 407                         break;
 408                 }
 409
 410                 case 12:
 411                 {
 412                         bluetooth_discoverable_mode_t mode = BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE;
 413                         ret = bluetooth_set_discoverable_mode(mode, 0);
 414                         if (ret < 0)
 415                                 TC_PRT("%s failed with [0x%04x]", tc_table[11].tc_name, ret);
 416                         else
 417                                 TC_PRT("BT Set Discoverable mode [%d]", mode);
 418                         break;
 419                 }
 420
 421                 case 13:
 422                 {
 423                         bluetooth_discoverable_mode_t mode = BLUETOOTH_DISCOVERABLE_MODE_TIME_LIMITED_DISCOVERABLE;
 424                         ret = bluetooth_set_discoverable_mode(mode, 5);
 425                         if (ret < 0)
 426                                 TC_PRT("%s failed with [0x%04x]", tc_table[12].tc_name, ret);
 427                         else
 428                                 TC_PRT("BT Set Discoverable mode [%d]", mode);
 429                         break;
 430                 }
 431
 432                 case 14:
 433                         ret = bluetooth_start_discovery(0, 0, 0);
 434                         if (ret < 0)
 435                                 TC_PRT("%s failed with [0x%04x]", tc_table[13].tc_name, ret);
 436                         break;
 437
 438                 case 15:
 439                         ret = bluetooth_cancel_discovery();
 440                         if (ret < 0)
 441                                 TC_PRT("%s failed with [0x%04x]", tc_table[14].tc_name, ret);
 442                         break;
 443
 444                 case 16:
 445                 {
 446                         ret = bluetooth_is_discovering();
 447                         if (ret < 0)
 448                                 TC_PRT("%s failed with [0x%04x]", tc_table[15].tc_name, ret);
 449                         else
 450                                 TC_PRT("Discovering [%d]", ret);
 451                         break;
 452                 }
 453
 454                 case 17: /*Get paired device list */
 455                 {
 456                         GPtrArray *devinfo = NULL;
 457                         devinfo = g_ptr_array_new();
 458                         TC_PRT("g pointer arrary count : [%d]", devinfo->len);
 459
 460                         ret = bluetooth_get_bonded_device_list(&devinfo);
 461                         if (ret < 0) {
 462                                 TC_PRT("%s failed with [0x%04x]", tc_table[16].tc_name, ret);
 463                         } else {
 464                                 int i;
 465                                 bluetooth_device_info_t *ptr;
 466                                 TC_PRT("g pointer arrary count : [%d]", devinfo->len);
 467
 468                                 for (i = 0; i < devinfo->len; i++) {
 469                                         ptr = g_ptr_array_index(devinfo, i);
 470                                         if (ptr != NULL) {
 471                                                 TC_PRT("Name [%s]", ptr->device_name.name);
 472                                                 TC_PRT("Major Class [%d]", ptr->device_class.major_class);
 473                                                 TC_PRT("Minor Class [%d]", ptr->device_class.minor_class);
 474                                                 TC_PRT("Service Class [%d]", ptr->device_class.service_class);
 475                                                 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]);
 476                                                 TC_PRT("\n");
 477                                         }
 478                                 }
 479                         }
 480                         g_ptr_array_free(devinfo, TRUE);
 481
 482                         break;
 483                 }
 484
 485                 case 18:
 486                 {
 487                         bluetooth_device_address_t device_address = { {0xDC, 0x2C, 0x26, 0xD0, 0xF3, 0xC1} }; /* BT Keyboard */
 488
 489                         TC_PRT("dev [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]", \
 490                                 device_address.addr[0], device_address.addr[1], device_address.addr[2], \
 491                                 device_address.addr[3], device_address.addr[4], device_address.addr[5]);
 492
 493                         ret = bluetooth_bond_device(&device_address);
 494                         if (ret < 0)
 495                                 TC_PRT("%s failed with [0x%04x]", tc_table[17].tc_name, ret);
 496                         break;
 497                 }
 498
 499
 500                 case 19: /*Cancel bonding */
 501                 {
 502                         ret = bluetooth_cancel_bonding();
 503                         if (ret < 0)
 504                                 TC_PRT("%s failed with [0x%04x]", tc_table[18].tc_name, ret);
 505
 506                         break;
 507                 }
 508
 509                 case 20: /*unbonding */
 510                 {
 511                         bluetooth_device_address_t device_address = { {0x00, 0x19, 0x0E, 0x01, 0x61, 0x17} }; /* DO-DH79-PYUN04 */
 512                         ret = bluetooth_unbond_device(&device_address);
 513                         if (ret < 0)
 514                                 TC_PRT("%s failed with [0x%04x]", tc_table[19].tc_name, ret);
 515
 516                         break;
 517                 }
 518
 519                 case 21: /*Get paired device */
 520                 {
 521                         bluetooth_device_info_t devinfo;
 522                         bluetooth_device_address_t device_address = { {0x00, 0x16, 0x38, 0xC3, 0x1F, 0xD2} };
 523
 524                         memset(&devinfo, 0x00, sizeof(bluetooth_device_info_t));
 525
 526                         ret = bluetooth_get_bonded_device(&device_address, &devinfo);
 527                         if (ret != BLUETOOTH_ERROR_NONE) {
 528                                 TC_PRT("bluetooth_get_bonded_device failed with [%d]", ret);
 529                         } else {
 530                                 TC_PRT("Name [%s]", devinfo.device_name.name);
 531                                 TC_PRT("Major Class [%d]", devinfo.device_class.major_class);
 532                                 TC_PRT("Minor Class [%d]", devinfo.device_class.minor_class);
 533                                 TC_PRT("Service Class [%d]", devinfo.device_class.service_class);
 534                                 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]);
 535                         }
 536
 537                         break;
 538                 }
 539
 540                 case 22: /*set alias for bonded device */
 541                 {
 542                         bluetooth_device_address_t device_address = { {0x00, 0x16, 0x38, 0xC3, 0x1F, 0xD2} };
 543
 544                         ret = bluetooth_set_alias(&device_address, "Renamed device");
 545                         if (ret < 0)
 546                                 TC_PRT("%s failed with [0x%04x]", tc_table[21].tc_name, ret);
 547                         break;
 548                 }
 549
 550                 case 23:
 551                 {
 552                         bluetooth_device_address_t device_address = { {0x00, 0x16, 0x38, 0xC3, 0x1F, 0xD2} };
 553
 554                         ret = bluetooth_authorize_device(&device_address, TRUE);
 555                         if (ret < 0)
 556                                 TC_PRT("%s failed with [0x%04x]", tc_table[22].tc_name, ret);
 557                         break;
 558                 }
 559                 case 24:
 560                 {
 561                         bluetooth_device_address_t device_address = { {0x00, 0x16, 0x38, 0xC3, 0x1F, 0xD2} };
 562
 563                         ret = bluetooth_authorize_device(&device_address, FALSE);
 564                         if (ret < 0)
 565                                 TC_PRT("%s failed with [0x%04x]", tc_table[23].tc_name, ret);
 566                         break;
 567                 }
 568                 case 25:
 569                 {
 570                         bluetooth_device_address_t device_address = { {0x00, 0x16, 0x38, 0xC3, 0x1F, 0xD2} };
 571
 572                         ret = bluetooth_search_service(&device_address);
 573                         if (ret < 0)
 574                                 TC_PRT("%s failed with [0x%04x]", tc_table[24].tc_name, ret);
 575                         break;
 576                 }
 577                 case 26:
 578                 {
 579                         ret = bluetooth_cancel_service_search();
 580                         if (ret < 0)
 581                                 TC_PRT("%s failed with [0x%04x]", tc_table[24].tc_name, ret);
 582                         break;
 583                 }
 584                 case 27:
 585                 {
 586                         gboolean connected = FALSE;
 587                         bluetooth_device_address_t device_address = { {0x00, 0x1B, 0x66, 0x01, 0x23, 0x1C} }; /* Gennheiser PX210BT */
 588
 589                         ret = bluetooth_is_device_connected(&device_address, BLUETOOTH_A2DP_SERVICE, &connected);
 590                         if (ret < 0)
 591                                 TC_PRT("%s failed with [0x%04x]", tc_table[24].tc_name, ret);
 592
 593                         TC_PRT("connected : %d", connected);
 594                         break;
 595                 }
 596                 case 28:
 597                 {
 598                         ret = bluetooth_reset_adapter();
 599                         if (ret < 0)
 600                                 TC_PRT("%s failed with [0x%04x]", tc_table[27].tc_name, ret);
 601                         break;
 602                 }
 603                 case 91:
 604                 {
 605                         bluetooth_manufacturer_data_t m_data;
 606                         guint8 data[6]  = {0x05, 0xFF, 0x02, 0x03, 0x04, 0x05};
 607
 608                         TC_PRT("%x %x %x %x %x %x", data[0], data[1], data[2], data[3],
 609                                         data[4], data[5]);
 610                         memcpy(m_data.data, data, sizeof(data));
 611                         m_data.data_len = sizeof(data) - 2;
 612                         ret = bluetooth_set_manufacturer_data(&m_data);
 613                         if (ret < 0)
 614                                 TC_PRT("%s failed with [0x%04x]", tc_table[90].tc_name, ret);
 615                         break;
 616                 }
 617                 case 29:
 618                 {
 619                         ret = bluetooth_audio_init(bt_audio_event_callback, NULL);
 620                         if (ret < 0)
 621                                 TC_PRT("%s failed with [0x%04x]", tc_table[28].tc_name, ret);
 622                         break;
 623                 }
 624                 case 30:
 625                 {
 626                         ret = bluetooth_audio_deinit();
 627                         if (ret < 0)
 628                                 TC_PRT("%s failed with [0x%04x]", tc_table[29].tc_name, ret);
 629                         break;
 630                 }
 631                 case 31:
 632                 {
 633                         bluetooth_device_address_t device_address = { {0x00, 0x0D, 0xFD, 0x24, 0x5E, 0xFF} }; /* Motorola S9 */
 634
 635                         ret = bluetooth_audio_connect(&device_address);
 636                         if (ret < 0)
 637                                 TC_PRT("%s failed with [0x%04x]", tc_table[30].tc_name, ret);
 638                         break;
 639                 }
 640                 case 32:
 641                 {
 642                         bluetooth_device_address_t device_address = { {0x00, 0x0D, 0xFD, 0x24, 0x5E, 0xFF} }; /* Motorola S9 */
 643
 644                         ret = bluetooth_audio_disconnect(&device_address);
 645                         if (ret < 0)
 646                                 TC_PRT("%s failed with [0x%04x]", tc_table[31].tc_name, ret);
 647                         break;
 648                 }
 649                 case 33:
 650                 {
 651                         /* MW600 */
 652                         bluetooth_device_address_t device_address = { {0x58, 0x17, 0x0C, 0xEC, 0x6A, 0xF3} };
 653
 654                         ret = bluetooth_ag_connect(&device_address);
 655                         if (ret < 0)
 656                                 TC_PRT("%s failed with [0x%04x]", tc_table[32].tc_name, ret);
 657                         break;
 658                 }
 659                 case 34:
 660                 {
 661                         /* MW600 */
 662                         bluetooth_device_address_t device_address = { {0x58, 0x17, 0x0C, 0xEC, 0x6A, 0xF3} };
 663
 664                         ret = bluetooth_ag_disconnect(&device_address);
 665                         if (ret < 0)
 666                                 TC_PRT("%s failed with [0x%04x]", tc_table[33].tc_name, ret);
 667                         break;
 668                 }
 669                 case 35:
 670                 {
 671                         /* MW600 */
 672                         bluetooth_device_address_t device_address = { {0x58, 0x17, 0x0C, 0xEC, 0x6A, 0xF3} };
 673
 674                         ret = bluetooth_av_connect(&device_address);
 675                         if (ret < 0)
 676                                 TC_PRT("%s failed with [0x%04x]", tc_table[34].tc_name, ret);
 677                         break;
 678                 }
 679                 case 36:
 680                 {
 681                         /* MW600 */
 682                         bluetooth_device_address_t device_address = { {0x58, 0x17, 0x0C, 0xEC, 0x6A, 0xF3} };
 683
 684                         ret = bluetooth_av_disconnect(&device_address);
 685                         if (ret < 0)
 686                                 TC_PRT("%s failed with [0x%04x]", tc_table[35].tc_name, ret);
 687                         break;
 688                 }
 689                 case 37:
 690                 {
 691                         unsigned int volume = 0;
 692
 693                         ret = bluetooth_ag_get_headset_volume(&volume);
 694                         if (ret < 0)
 695                                 TC_PRT("failed with [0x%04x]", ret);
 696
 697                         TC_PRT("volume: %d", volume);
 698                         break;
 699                 }
 700                 case 38:
 701                 {
 702                         ret = bluetooth_ag_set_speaker_gain(10);
 703                         if (ret < 0)
 704                                 TC_PRT("failed with [0x%04x]", ret);
 705                         break;
 706                 }
 707
 708                 case 39:
 709                 {
 710                         if (bluetooth_oob_read_local_data(&g_local_oob_data.oob_data)) {
 711                                 TC_PRT("ERROR in bluetooth_oob_read_local_data\n");
 712                         } else {
 713                                 TC_PRT("SUCESS in bluetooth_oob_read_local_data\n");
 714                                 TC_PRT("hash = [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X"
 715                                         "%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]\n",
 716                                         g_local_oob_data.oob_data.hash[0],
 717                                         g_local_oob_data.oob_data.hash[1],
 718                                         g_local_oob_data.oob_data.hash[2],
 719                                         g_local_oob_data.oob_data.hash[3],
 720                                         g_local_oob_data.oob_data.hash[4],
 721                                         g_local_oob_data.oob_data.hash[5],
 722                                         g_local_oob_data.oob_data.hash[6],
 723                                         g_local_oob_data.oob_data.hash[7],
 724                                         g_local_oob_data.oob_data.hash[8],
 725                                         g_local_oob_data.oob_data.hash[9],
 726                                         g_local_oob_data.oob_data.hash[10],
 727                                         g_local_oob_data.oob_data.hash[11],
 728                                         g_local_oob_data.oob_data.hash[12],
 729                                         g_local_oob_data.oob_data.hash[13],
 730                                         g_local_oob_data.oob_data.hash[14],
 731                                         g_local_oob_data.oob_data.hash[15]);
 732
 733                                 TC_PRT("randomizer = [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X"
 734                                         "%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]\n",
 735                                         g_local_oob_data.oob_data.randomizer[0],
 736                                         g_local_oob_data.oob_data.randomizer[1],
 737                                         g_local_oob_data.oob_data.randomizer[2],
 738                                         g_local_oob_data.oob_data.randomizer[3],
 739                                         g_local_oob_data.oob_data.randomizer[4],
 740                                         g_local_oob_data.oob_data.randomizer[5],
 741                                         g_local_oob_data.oob_data.randomizer[6],
 742                                         g_local_oob_data.oob_data.randomizer[7],
 743                                         g_local_oob_data.oob_data.randomizer[8],
 744                                         g_local_oob_data.oob_data.randomizer[9],
 745                                         g_local_oob_data.oob_data.randomizer[10],
 746                                         g_local_oob_data.oob_data.randomizer[11],
 747                                         g_local_oob_data.oob_data.randomizer[12],
 748                                         g_local_oob_data.oob_data.randomizer[13],
 749                                         g_local_oob_data.oob_data.randomizer[14],
 750                                         g_local_oob_data.oob_data.randomizer[15]);
 751
 752                                 TC_PRT("hash_len: %d\n", g_local_oob_data.oob_data.hash_len);
 753                                 TC_PRT("randomizer_len: %d\n", g_local_oob_data.oob_data.randomizer_len);
 754                         }
 755                         break;
 756                 }
 757                 case 40:
 758                 {
 759                         ret = bluetooth_get_local_address(&g_local_oob_data.address);
 760                         TC_PRT("hash_len: %d\n", g_local_oob_data.oob_data.hash_len);
 761                         TC_PRT("randomizer_len: %d\n", g_local_oob_data.oob_data.randomizer_len);
 762
 763                         if (bluetooth_oob_add_remote_data(&g_local_oob_data.address,
 764                                 &g_local_oob_data.oob_data))
 765                                 TC_PRT("ERROR in bluetooth_oob_add_remote_data\n");
 766                         else
 767                                 TC_PRT(" bluetooth_oob_add_remote_data SUCCESS\n");
 768                         break;
 769                 }
 770
 771                 case 41:
 772                 {
 773                         if (bluetooth_oob_remove_remote_data(&g_local_oob_data.address))
 774                                 TC_PRT("ERROR in bluetooth_oob_remove_remote_data\n");
 775                         else
 776                                 TC_PRT(" bluetooth_oob_remove_remote_data SUCCESS\n");
 777                         break;
 778                 }
 779                 case 42:
 780                 {
 781                         bluetooth_opc_init();
 782                         break;
 783                 }
 784                 case 43:
 785                 {
 786                         bluetooth_opc_deinit();
 787                         break;
 788                 }
 789                 case 44:
 790                 {
 791                         bluetooth_device_address_t remote_address = { {0} };
 792
 793                         /* Grey dongle */
 794                         remote_address.addr[0] = 0x00; remote_address.addr[1] = 0x02; remote_address.addr[2] = 0x70;
 795                         remote_address.addr[3] = 0x2B; remote_address.addr[4] = 0xD3; remote_address.addr[5] = 0xAF;
 796
 797                         char *files[5] = {NULL};
 798
 799                         files[0] = "/opt/media/Images/image1.jpg";
 800 //                      files[1] = "/opt/media/Images/image2.jpg";
 801 //                      files[2] = "/opt/media/Images/image3.jpg";
 802                         bluetooth_opc_push_files(&remote_address, files);
 803                         break;
 804                 }
 805                 case 45:
 806                 {
 807                         bluetooth_opc_cancel_push();
 808                         break;
 809                 }
 810                 case 46:
 811                 {
 812                         gboolean exist;
 813                         exist = bluetooth_opc_session_is_exist();
 814                         TC_PRT("exist: %d", exist);
 815                         break;
 816                 }
 817                 case 47:
 818                 {
 819                         bluetooth_network_activate_server();
 820                         break;
 821                 }
 822                 case 48:
 823                 {
 824                         bluetooth_network_deactivate_server();
 825                         break;
 826                 }
 827                 case 49:
 828                 {
 829                         bluetooth_device_address_t device_address = { {0x00, 0x02, 0xA2, 0x14, 0x40, 0x51} };
 830                         bluetooth_network_connect(&device_address, BLUETOOTH_NETWORK_NAP_ROLE, NULL);
 831                         break;
 832                 }
 833                 case 50:
 834                 {
 835                         bluetooth_device_address_t device_address = { {0x00, 0x02, 0xA2, 0x14, 0x40, 0x51} };
 836                         bluetooth_network_disconnect(&device_address);
 837                         break;
 838                 }
 839                 case 51:
 840                 {
 841                         bluetooth_obex_server_init("/opt/media/Downloads");
 842                         break;
 843                 }
 844                 case 52:
 845                 {
 846                         bluetooth_obex_server_deinit();
 847                         break;
 848                 }
 849                 case 53:
 850                 {
 851                         bluetooth_obex_server_init_without_agent("/opt/media/Downloads");
 852                         break;
 853                 }
 854                 case 54:
 855                 {
 856                         bluetooth_obex_server_deinit_without_agent();
 857                         break;
 858                 }
 859                 case 55:
 860                 {
 861                         bluetooth_obex_server_is_activated();
 862                         break;
 863                 }
 864                 case 56:
 865                 {
 866                         bluetooth_obex_server_accept_connection();
 867                         TC_PRT(" bluetooth_obex_server_accept_connection SUCCESS\n");
 868                         break;
 869                 }
 870                 case 57:
 871                 {
 872                         bluetooth_obex_server_reject_connection();
 873                         break;
 874                 }
 875                 case 58:
 876                 {
 877                         bluetooth_obex_server_accept_authorize("abc");
 878                         break;
 879                 }
 880                 case 59:
 881                 {
 882                         bluetooth_obex_server_reject_authorize();
 883                         break;
 884                 }
 885                 case 60:
 886                 {
 887                         bluetooth_obex_server_set_destination_path("/opt/media");
 888                         break;
 889                 }
 890                 case 61:
 891                 {
 892                         bluetooth_obex_server_set_root("/opt/media");
 893                         break;
 894                 }
 895                 case 62:
 896                 {
 897                         bluetooth_obex_server_cancel_transfer(0);
 898                         break;
 899                 }
 900                 case 63:
 901                 {
 902                         bluetooth_obex_server_cancel_all_transfers();
 903                         break;
 904                 }
 905
 906                 case 65:
 907                 {
 908                         ret = bluetooth_hid_init(bt_hid_event_callback, NULL);
 909                         if (ret < 0)
 910                                 TC_PRT("Failed with [0x%04x]", ret);
 911                         break;
 912                 }
 913                 case 66:
 914                 {
 915                         ret = bluetooth_hid_deinit();
 916                         if (ret < 0)
 917                                 TC_PRT("Failed with [0x%04x]", ret);
 918                         break;
 919                 }
 920                 case 67:
 921                 {
 922                         /* Apple wireless keyboard */
 923                         hid_device_address_t device_address = { {0xE8, 0x06, 0x88, 0x3B, 0x18, 0xBA} };
 924
 925                         ret = bluetooth_hid_connect(&device_address);
 926                         if (ret < 0)
 927                                 TC_PRT("Failed with [0x%04x]", ret);
 928                         break;
 929                 }
 930                 case 68:
 931                 {
 932                         /* Apple wireless keyboard */
 933                         hid_device_address_t device_address = { {0xE8, 0x06, 0x88, 0x3B, 0x18, 0xBA} };
 934
 935                         ret = bluetooth_hid_disconnect(&device_address);
 936                         if (ret < 0)
 937                                 TC_PRT("Failed with [0x%04x]", ret);
 938                         break;
 939                 }
 940
 941                 case 70:
 942                 {
 943                         bluetooth_device_address_t device_address = { {0x00, 0x02, 0x2F, 0x92, 0x7B, 0xF5} };
 944
 945                         ret = bluetooth_rfcomm_connect(&device_address, rfcomm_test_uuid_spp);
 946                         //ret = bluetooth_rfcomm_connect(&device_address, "1");
 947
 948                         if (ret < 0)
 949                                 TC_PRT("Failed with [0x%04x]", ret);
 950                         break;
 951                 }
 952                 case 71:
 953                 {
 954                         ret = bluetooth_rfcomm_disconnect(-1);
 955
 956                         if (ret < 0)
 957                                 TC_PRT("Failed with [0x%04x]", ret);
 958                         break;
 959                 }
 960                 case 72:
 961                 {
 962                         ret = bluetooth_rfcomm_disconnect(g_ret_client_fd1);
 963
 964                         if (ret < 0)
 965                                 TC_PRT("Failed with [0x%04x]", ret);
 966                         break;
 967                 }
 968                 case 73:
 969                 {
 970                         const char rd_data[] = "123456789 12345";
 971                         ret = bluetooth_rfcomm_write(g_ret_client_fd1, rd_data, sizeof(rd_data));
 972
 973                         if (ret < 0)
 974                                 TC_PRT("Failed with [0x%04x]", ret);
 975                         break;
 976                 }
 977                 case 74:
 978                 {
 979                         gboolean is_connected;
 980
 981                         is_connected = bluetooth_rfcomm_is_client_connected();
 982
 983                         TC_PRT("Connected: %d", is_connected);
 984                         break;
 985                 }
 986                 case 80:
 987                 {
 988                         ret = bluetooth_rfcomm_create_socket(rfcomm_test_uuid_spp);
 989                         if (ret < 0)
 990                                 TC_PRT("Failed with [0x%04x]", ret);
 991
 992                         TC_PRT("Returned FD = %d", ret);
 993                         server_fd = ret;
 994                         break;
 995                 }
 996                 case 81:
 997                 {
 998                         ret = bluetooth_rfcomm_create_socket(rfcomm_test_uuid_custom);
 999                         if (ret < 0)
1000                                 TC_PRT("Failed with [0x%04x]", ret);
1001
1002                         TC_PRT("Returned FD = %d", ret);
1003                         server_fd = ret;
1004                         break;
1005                 }
1006                 case 82:
1007                 {
1008                         ret = bluetooth_rfcomm_remove_socket(server_fd);
1009                         if (ret < 0)
1010                                 TC_PRT("Failed with [0x%04x]", ret);
1011                         break;
1012                 }
1013                 case 83: /*Listen and accept */
1014                 {
1015
1016                         ret = bluetooth_rfcomm_listen_and_accept(server_fd, 1);
1017                         if (ret < 0)
1018                                 TC_PRT("Failed with [0x%04x]", ret);
1019
1020                         TC_PRT("result = %d", ret);
1021                         break;
1022                 }
1023                 case 84: /*Listen */
1024                 {
1025
1026                         ret = bluetooth_rfcomm_listen(server_fd, 1);
1027                         if (ret < 0)
1028                                 TC_PRT("Failed with [0x%04x]", ret);
1029
1030                         TC_PRT("result = %d", ret);
1031                         break;
1032                 }
1033                 case 85:
1034                 {
1035                         ret = bluetooth_rfcomm_server_disconnect(client_fd);
1036                         if (ret < 0)
1037                                 TC_PRT("Failed with [0x%04x]", ret);
1038                         break;
1039                 }
1040                 case 86:
1041                 {
1042                         gboolean available;
1043
1044                         available = bluetooth_rfcomm_is_server_uuid_available(rfcomm_test_uuid_spp);
1045
1046                         TC_PRT("available: %d", available);
1047                         break;
1048                 }
1049                 case 87:
1050                 {
1051                         ret = bluetooth_rfcomm_accept_connection(server_fd);
1052                         if (ret < 0)
1053                                 TC_PRT("Failed with [0x%04x]", ret);
1054                         TC_PRT("client fd: %d", client_fd);
1055                         break;
1056                 }
1057                 case 88:
1058                 {
1059                         ret = bluetooth_rfcomm_reject_connection(server_fd);
1060                         if (ret < 0)
1061                                 TC_PRT("Failed with [0x%04x]", ret);
1062                         break;
1063                 }
1064                 case 89:
1065                         ret = bluetooth_start_custom_discovery(DISCOVERY_ROLE_LE,
1066                                                                         0, 0, 0);
1067                         if (ret < 0)
1068                                 TC_PRT("failed with [0x%04x]", ret);
1069                         break;
1070                 case 92: {
1071                         ret = bluetooth_gatt_init();
1072                         if (ret < 0)
1073                                 TC_PRT("gatt init failed with [0x%04x]", ret);
1074                         break;
1075                 }
1076                 case 93: {
1077                         ret = bluetooth_gatt_deinit();
1078                         if (ret < 0)
1079                                 TC_PRT("gatt deinit failed with [0x%04x]", ret);
1080                         break;
1081                 }
1082                 case 94: {
1083                         char *service_uuid = g_strdup("00001802-0000-1000-8000-00805f9b34fb");
1084
1085                         ret = bluetooth_gatt_add_service(service_uuid,
1086                                 &svc_obj_path);
1087
1088                         TC_PRT("service obj_path is %s", svc_obj_path);
1089                         }
1090                         break;
1091
1092                 case 95: {
1093                         /* testing with dummy values*/
1094                         char *char_uuid = g_strdup("00002a06-0000-1000-8000-00805f9b34fb");
1095                         bt_gatt_permission_t perms = 0;
1096                         bt_gatt_characteristic_property_t props = BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_READ |
1097                                         BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_WRITE |
1098                                         BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_NOTIFY |
1099                                         BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_INDICATE;
1100
1101                         ret = bluetooth_gatt_add_new_characteristic(
1102                                 svc_obj_path, char_uuid,
1103                                 perms, props, &char_obj_path);
1104
1105                         TC_PRT("characteristic obj_path is %s", char_obj_path);
1106
1107                         break;
1108                 }
1109
1110                 case 96: {
1111                         char *desc_uuid = g_strdup("000026ff-0000-1000-8000-00805f9b34fb");
1112                         bt_gatt_permission_t perms = BLUETOOTH_GATT_PERMISSION_READ |
1113                                         BLUETOOTH_GATT_PERMISSION_WRITE;
1114
1115                         ret = bluetooth_gatt_add_descriptor(char_obj_path,
1116                                 desc_uuid, perms, &desc_obj_path);
1117
1118                         TC_PRT("add descriptor error is %d", ret);
1119
1120                         break;
1121                 }
1122                 case 97: {
1123                         ret = bluetooth_gatt_register_service(svc_obj_path);
1124
1125                         TC_PRT("register service error is %d", ret);
1126
1127                         break;
1128                 }
1129                 case 98: {
1130                         ret = bluetooth_gatt_register_application();
1131
1132                         TC_PRT("register service error is %d", ret);
1133
1134                         break;
1135                 }
1136                 case 99: {
1137                         char char_data[4] = {10, 20, 30, 40};
1138                         int char_length = 4;
1139                         ret = bluetooth_gatt_update_characteristic(char_obj_path,
1140                                                 char_data, char_length);
1141
1142                         TC_PRT("update_characteristic error is %d", ret);
1143
1144                         break;
1145                 }
1146                 case 100: {
1147                         ret = bluetooth_gatt_unregister_service(svc_obj_path);
1148
1149                         TC_PRT("service removed with error is %d", ret);
1150
1151                         break;
1152                 }
1153                 case 101: {
1154                         ret = bluetooth_gatt_delete_services();
1155
1156                         TC_PRT("services deleted with error is %d", ret);
1157
1158                         break;
1159                 }
1160                 default:
1161                         break;
1162         }
1163
1164         return 0;
1165 }
1166
1167 void startup()
1168 {
1169         TC_PRT("bluetooth framework TC startup");
1170
1171         dbus_threads_init_default();
1172
1173         main_loop = g_main_loop_new(NULL, FALSE);
1174 }
1175
1176 void cleanup()
1177 {
1178         TC_PRT("bluetooth framework TC cleanup");
1179         if (main_loop != NULL)
1180                 g_main_loop_unref(main_loop);
1181 }
1182
1183 void bt_hid_event_callback(int event, hid_event_param_t* param, void *user_data)
1184 {
1185         TC_PRT(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
1186         TC_PRT("bt event callback 0x%04x", event);
1187 }
1188
1189 void bt_audio_event_callback(int event, bt_audio_event_param_t* param, void *user_data)
1190 {
1191         TC_PRT(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
1192         TC_PRT("bt event callback 0x%04x", event);
1193
1194
1195
1196 }
1197
1198 void bt_event_callback(int event, bluetooth_event_param_t* param, void *user_data)
1199 {
1200         TC_PRT(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
1201         TC_PRT("bt event callback 0x%04x", event);
1202         switch (event) {
1203                 case BLUETOOTH_EVENT_ENABLED:
1204                         TC_PRT("BLUETOOTH_EVENT_ENABLED, result [0x%04x]", param->result);
1205                         break;
1206
1207                 case BLUETOOTH_EVENT_DISABLED:
1208                         TC_PRT("BLUETOOTH_EVENT_DISABLED, result [0x%04x]", param->result);
1209                         break;
1210
1211                 case BLUETOOTH_EVENT_LOCAL_NAME_CHANGED:
1212                         TC_PRT("BLUETOOTH_EVENT_LOCAL_NAME_CHANGED, result [0x%04x]", param->result);
1213                         if (param->result == BLUETOOTH_ERROR_NONE) {
1214                                 bluetooth_device_name_t *local_name = (bluetooth_device_name_t *)param->param_data;
1215                                 tc_result(TC_PASS, 6);
1216                                 TC_PRT("Changed Name : [%s]", local_name->name);
1217                         } else {
1218                                 tc_result(TC_FAIL, 6);
1219                         }
1220                         break;
1221
1222
1223                 case BLUETOOTH_EVENT_DISCOVERY_STARTED:
1224                         TC_PRT("BLUETOOTH_EVENT_DISCOVERY_STARTED, result [0x%04x]", param->result);
1225                         break;
1226
1227                 case BLUETOOTH_EVENT_REMOTE_DEVICE_FOUND:
1228                 {
1229                         bluetooth_device_info_t *device_info = NULL;
1230                         TC_PRT("BLUETOOTH_EVENT_REMOTE_DEVICE_FOUND, result [0x%04x]", param->result);
1231                         device_info  = (bluetooth_device_info_t *)param->param_data;
1232                         memcpy(&searched_device, &device_info->device_address, sizeof(bluetooth_device_address_t));
1233                         TC_PRT("dev [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]", \
1234                                 device_info->device_address.addr[0], device_info->device_address.addr[1], device_info->device_address.addr[2], \
1235                                 device_info->device_address.addr[3], device_info->device_address.addr[4], device_info->device_address.addr[5]);
1236                         break;
1237                 }
1238
1239                 case BLUETOOTH_EVENT_REMOTE_LE_DEVICE_FOUND:
1240                 {
1241                         int i;
1242                         bluetooth_le_device_info_t *le_device_info = NULL;
1243                         TC_PRT("BLUETOOTH_EVENT_REMOTE_LE_DEVICE_FOUND, result [0x%04x]", param->result);
1244                         le_device_info  = (bluetooth_le_device_info_t *)param->param_data;
1245                         TC_PRT("dev[%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]", \
1246                                 le_device_info->device_address.addr[0], le_device_info->device_address.addr[1], le_device_info->device_address.addr[2], \
1247                                 le_device_info->device_address.addr[3], le_device_info->device_address.addr[4], le_device_info->device_address.addr[5]);
1248                         TC_PRT("addr_type : %d", le_device_info->addr_type);
1249                         TC_PRT("rssi : %d", le_device_info->rssi);
1250                         TC_PRT("adv_ind_data_len :%d" , le_device_info->adv_ind_data.data_len);
1251                         TC_PRT("scan_resp_data_len :%d" , le_device_info->scan_resp_data.data_len);
1252
1253                         for (i = 0; i < le_device_info->adv_ind_data.data_len; i++)
1254                                 TC_PRT("adv_ind_data[%d] : [0x%x]", i, le_device_info->adv_ind_data.data.data[i]);
1255
1256                         for (i = 0; i < le_device_info->scan_resp_data.data_len; i++)
1257                                 TC_PRT("scan_resp_data[%d] : [0x%x]", i, le_device_info->scan_resp_data.data.data[i]);
1258
1259                         break;
1260                 }
1261
1262                 case BLUETOOTH_EVENT_REMOTE_DEVICE_NAME_UPDATED:
1263                 {
1264                         bluetooth_device_info_t *device_info = NULL;
1265                         TC_PRT("BLUETOOTH_EVENT_REMOTE_DEVICE_NAME_UPDATED, result [0x%04x]", param->result);
1266                         device_info  = (bluetooth_device_info_t *)param->param_data;
1267                         memcpy(&searched_device, &device_info->device_address, sizeof(bluetooth_device_address_t));
1268                         TC_PRT("dev [%s] [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]", device_info->device_name.name, \
1269                                 device_info->device_address.addr[0], device_info->device_address.addr[1], device_info->device_address.addr[2], \
1270                                 device_info->device_address.addr[3], device_info->device_address.addr[4], device_info->device_address.addr[5]);
1271                         break;
1272                 }
1273
1274                 case BLUETOOTH_EVENT_DISCOVERY_FINISHED:
1275                         TC_PRT("BLUETOOTH_EVENT_DISCOVERY_FINISHED, result [0x%04x]", param->result);
1276                         break;
1277
1278                 case BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED:
1279                 {
1280                         int *mode = (int *)param->param_data;
1281                         TC_PRT("BT_DISCOVERABLE_MODE_CHANGED, result [0x%04x]", param->result);
1282                         TC_PRT("mode [%d]", *mode);
1283                         break;
1284                 }
1285                 case BLUETOOTH_EVENT_DISCOVERABLE_TIMEOUT_CHANGED:
1286                 {
1287                         int *timeout = (int *)param->param_data;
1288                         TC_PRT("BLUETOOTH_EVENT_DISCOVERABLE_TIMEOUT_CHANGED, result [0x%04x]", param->result);
1289                         TC_PRT("timeout [%d]", *timeout);
1290                         break;
1291                 }
1292                 case BLUETOOTH_EVENT_BONDING_FINISHED:
1293                 {
1294                         TC_PRT("BLUETOOTH_EVENT_BONDING_FINISHED, result [0x%04x]", param->result);
1295                         if (param->result >= BLUETOOTH_ERROR_NONE) {
1296                                 bluetooth_device_info_t *device_info = NULL;
1297                                 tc_result(TC_PASS, 12);
1298                                 device_info = (bluetooth_device_info_t *)param->param_data;
1299                                 if (device_info == NULL)
1300                                         break;
1301
1302                                 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, \
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], \
1305                                         device_info->device_class.major_class, device_info->device_class.minor_class, device_info->device_class.service_class);
1306                         } else {
1307                                 tc_result(TC_FAIL, 12);
1308                         }
1309                         break;
1310                 }
1311
1312                 case BLUETOOTH_EVENT_BONDED_DEVICE_FOUND:
1313                 {
1314                         // bluetooth_get_bonded_device_list is changed as synchronous API. This event is not used any more.
1315                         // 2011.01.06
1316 #if 0
1317 //                      int i = 0;
1318                         TC_PRT("BLUETOOTH_EVENT_BONDED_DEVICE_FOUND, result [0x%04x]", param->result);
1319                         if (param->result >= BLUETOOTH_ERROR_NONE) {
1320                                 ///tc_result(TC_PASS, 15);
1321                                 bluetooth_device_info_t * bt_dev_info = (bluetooth_device_info_t*)param->param_data;
1322
1323                                 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,
1324                                         bt_dev_info->device_address.addr[0], bt_dev_info->device_address.addr[1], bt_dev_info->device_address.addr[2], \
1325                                         bt_dev_info->device_address.addr[3], bt_dev_info->device_address.addr[4], bt_dev_info->device_address.addr[5], \
1326                                         bt_dev_info->device_class.major_class, bt_dev_info->device_class.minor_class, bt_dev_info->device_class.service_class);
1327
1328                         } else if (param->result == BLUETOOTH_ERROR_END_OF_DEVICE_LIST) /*End of the Device found indication*/ {
1329                                 tc_result(TC_PASS, 15);
1330                                 TC_PRT("*****<<No more BLUETOOTH_EVENT_BONDED_DEVICE_FOUND indication>>***** ");
1331                         } else {
1332                                 tc_result(TC_FAIL, 15);
1333                                 TC_PRT("*****API failed ***** ");
1334                         }
1335                         break;
1336 #endif
1337                 }
1338                 case BLUETOOTH_EVENT_SERVICE_SEARCHED:
1339                 {
1340                         int i = 0;
1341                         TC_PRT("BLUETOOTH_EVENT_SERVICE_SEARCHED, result [0x%04x]", param->result);
1342                         if (param->result >= BLUETOOTH_ERROR_NONE) {
1343                                 tc_result(TC_PASS, 18);
1344                                 bt_sdp_info_t *bt_sdp_info = param->param_data;
1345
1346                                 TC_PRT("Dev add = %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n",
1347                                         bt_sdp_info->device_addr.addr[0], bt_sdp_info->device_addr.addr[1], bt_sdp_info->device_addr.addr[2], \
1348                                         bt_sdp_info->device_addr.addr[3], bt_sdp_info->device_addr.addr[4], bt_sdp_info->device_addr.addr[5]);
1349
1350                                         TC_PRT("Supported service list:\n");
1351                                         for (i = 0; i < bt_sdp_info->service_index; i++)
1352                                                 TC_PRT("[%#x]\n", bt_sdp_info->service_list_array[i]);
1353
1354                         } else {
1355                                 tc_result(TC_FAIL, 18);
1356                         }
1357                         break;
1358                 }
1359                 case BLUETOOTH_EVENT_RFCOMM_DATA_RECEIVED:
1360                 {
1361                         TC_PRT("BLUETOOTH_EVENT_RFCOMM_DATA_RECEIVED, result [0x%04x]", param->result);
1362                         bluetooth_rfcomm_received_data_t *rx_data = param->param_data;
1363                         printf("\n FD = %d \nBuffer len = %d ", rx_data->socket_fd, rx_data->buffer_size);
1364                         if (rx_data->buffer_size < sizeof(oob_data_t))
1365                                 TC_PRT("Complete oob data is not recivedn");
1366                         else
1367                                 memcpy(&g_remote_oob_data, rx_data->buffer, sizeof(oob_data_t));
1368                         //tc_result(TC_PASS, 21);
1369                         break;
1370                 }
1371                 case BLUETOOTH_EVENT_RFCOMM_CONNECTED:
1372                 {
1373                         bluetooth_rfcomm_connection_t *con_ind = (bluetooth_rfcomm_connection_t *)param->param_data;
1374                         TC_PRT("BLUETOOTH_EVENT_RFCOMM_CONNECTED, result [0x%04x], fd = %d, device add = 0x%X:%X:%X:%X:%X:%X, Role = %s", param->result,
1375                                                                 con_ind->socket_fd,
1376                                                                 con_ind->device_addr.addr[0], con_ind->device_addr.addr[1], con_ind->device_addr.addr[2],
1377                                                                 con_ind->device_addr.addr[3], con_ind->device_addr.addr[4], con_ind->device_addr.addr[5],
1378                                                                 (con_ind->device_role == RFCOMM_ROLE_SERVER) ? "SERVER" : "CLIENT");
1379                         //tc_result(TC_PASS, 22);
1380                         if ((con_ind->device_role == RFCOMM_ROLE_CLIENT) && (con_ind->socket_fd > 0))
1381                                 g_ret_client_fd1 = con_ind->socket_fd;
1382
1383                         if ((con_ind->device_role == RFCOMM_ROLE_SERVER) && (con_ind->socket_fd > 0))
1384                                 client_fd = con_ind->socket_fd;
1385
1386                         break;
1387                 }
1388                 case BLUETOOTH_EVENT_RFCOMM_DISCONNECTED:
1389                 {
1390                         bluetooth_rfcomm_disconnection_t *disconnection_ind = (bluetooth_rfcomm_disconnection_t *)param->param_data;;
1391                         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,
1392                                                                                                                 disconnection_ind->device_addr.addr[0], disconnection_ind->device_addr.addr[1], disconnection_ind->device_addr.addr[2],
1393                                                                                                                 disconnection_ind->device_addr.addr[3], disconnection_ind->device_addr.addr[4], disconnection_ind->device_addr.addr[5]);
1394                         //tc_result(TC_PASS, 22);
1395                         break;
1396                 }
1397                 case BLUETOOTH_EVENT_NETWORK_SERVER_CONNECTED:
1398                 {
1399                         bluetooth_network_device_info_t *dev_info = (bluetooth_network_device_info_t *)param->param_data;
1400
1401                         TC_PRT("BLUETOOTH_EVENT_RFCOMM_DISCONNECTED, result [0x%04x]", param->result);
1402                         TC_PRT("interface name: %s", dev_info->interface_name);
1403
1404                         TC_PRT("device add = %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n",
1405                                                                 dev_info->device_address.addr[0], dev_info->device_address.addr[1], dev_info->device_address.addr[2],
1406                                                                 dev_info->device_address.addr[3], dev_info->device_address.addr[4], dev_info->device_address.addr[5]);
1407                         break;
1408                 }
1409                 case BLUETOOTH_EVENT_NETWORK_SERVER_DISCONNECTED:
1410                 {
1411                         bluetooth_network_device_info_t *dev_info = (bluetooth_network_device_info_t *)param->param_data;
1412
1413                         TC_PRT("BLUETOOTH_EVENT_RFCOMM_DISCONNECTED, result [0x%04x]", param->result);
1414                         TC_PRT("interface name: %s", dev_info->interface_name);
1415
1416                         TC_PRT("device add = %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n",
1417                                                                 dev_info->device_address.addr[0], dev_info->device_address.addr[1], dev_info->device_address.addr[2],
1418                                                                 dev_info->device_address.addr[3], dev_info->device_address.addr[4], dev_info->device_address.addr[5]);
1419                         break;
1420                 }
1421
1422                 case BLUETOOTH_EVENT_HDP_CONNECTED:
1423                 {
1424                         bt_hdp_connected_t *conn_ind = (bt_hdp_connected_t *)param->param_data;
1425
1426                         TC_PRT("BLUETOOTH_EVENT_HDP_CONNECTED, Result = %s\n", (param->result == 0) ? "BLUETOOTH_ERROR_NONE" : "BLUETOOTH_ERROR_XXXX");
1427                         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");
1428                         TC_PRT("device add = %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n",
1429                                                                 conn_ind->device_address.addr[0], conn_ind->device_address.addr[1], conn_ind->device_address.addr[2],
1430                                                                 conn_ind->device_address.addr[3], conn_ind->device_address.addr[4], conn_ind->device_address.addr[5]);
1431
1432                         g_ret_client_fd1 = conn_ind->channel_id;
1433                         break;
1434                 }
1435
1436                 case BLUETOOTH_EVENT_HDP_DISCONNECTED:
1437                 {
1438                         bt_hdp_disconnected_t *dis_ind = (bt_hdp_disconnected_t *)param->param_data;
1439
1440                         TC_PRT("BLUETOOTH_EVENT_HDP_DISCONNECTED, Result = %s\n", (param->result == 0) ? "BLUETOOTH_ERROR_NONE" : "BLUETOOTH_ERROR_XXXX");
1441                         TC_PRT("Channel = %d, Add = device add = %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n", dis_ind->channel_id,
1442                                                                 dis_ind->device_address.addr[0], dis_ind->device_address.addr[1], dis_ind->device_address.addr[2],
1443                                                                 dis_ind->device_address.addr[3], dis_ind->device_address.addr[4], dis_ind->device_address.addr[5]);
1444                         break;
1445                 }
1446
1447                 case BLUETOOTH_EVENT_HDP_DATA_RECEIVED:
1448                 {
1449                         bt_hdp_data_ind_t *data_ind = (bt_hdp_data_ind_t *)param->param_data;
1450
1451                         TC_PRT("BLUETOOTH_EVENT_HDP_DATA_RECEIVED, Result = %s\n", (param->result == 0) ? "BLUETOOTH_ERROR_NONE" : "BLUETOOTH_ERROR_XXXX");
1452                         TC_PRT("Data received from channel id = %d and  size =%d, buff =[%s]\n",  data_ind->channel_id, data_ind->size, data_ind->buffer);
1453
1454                         break;
1455                 }
1456
1457                 case BLUETOOTH_EVENT_OPC_CONNECTED:
1458                         TC_PRT("BLUETOOTH_EVENT_OPC_CONNECTED");
1459                         break;
1460
1461                 case BLUETOOTH_EVENT_OPC_DISCONNECTED:
1462                         TC_PRT("BLUETOOTH_EVENT_OPC_DISCONNECTED");
1463                         break;
1464                 case BLUETOOTH_EVENT_OPC_TRANSFER_STARTED:
1465                 {
1466                         TC_PRT("BLUETOOTH_EVENT_OPC_TRANSFER_STARTED");
1467                         if (param->param_data) {
1468                                 bt_opc_transfer_info_t *info = param->param_data;
1469                                 TC_PRT("file %s", info->filename);
1470                                 TC_PRT("size %ld", info->size);
1471                         }
1472                         break;
1473                 }
1474                 case BLUETOOTH_EVENT_OPC_TRANSFER_PROGRESS:
1475                 {
1476                         TC_PRT("BLUETOOTH_EVENT_OPC_TRANSFER_PROGRESS");
1477                         break;
1478                 }
1479                 case BLUETOOTH_EVENT_OPC_TRANSFER_COMPLETE:
1480                 {
1481                         TC_PRT("BLUETOOTH_EVENT_OPC_TRANSFER_COMPLETE");
1482                         bt_opc_transfer_info_t *info = param->param_data;
1483                         TC_PRT("file %s", info->filename);
1484                         TC_PRT("size %ld", info->size);
1485                         break;
1486                 }
1487
1488                 case BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_AUTHORIZE:
1489                         TC_PRT("BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_AUTHORIZE");
1490                         break;
1491
1492                 case BLUETOOTH_EVENT_OBEX_SERVER_CONNECTION_AUTHORIZE:
1493                         TC_PRT("BLUETOOTH_EVENT_OBEX_SERVER_CONNECTION_AUTHORIZE");
1494                         break;
1495
1496                 case BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_STARTED:
1497                         TC_PRT("BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_STARTED");
1498                         bt_obex_server_transfer_info_t *info = param->param_data;
1499                         current_transfer_id = info->transfer_id;
1500                         break;
1501
1502                 case BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_PROGRESS:
1503                         TC_PRT("BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_PROGRESS");
1504                         break;
1505
1506                 case BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_COMPLETED:
1507                         TC_PRT("BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_COMPLETED");
1508                         break;
1509                 case BLUETOOTH_EVENT_MANUFACTURER_DATA_CHANGED:
1510                 {       TC_PRT("BLUETOOTH_EVENT_MANUFACTURER_DATA_CHANGED");
1511                         break;
1512                 }
1513 #if 0
1514                 case BLUETOOTH_EVENT_GATT_PRIM_SVC_DISCOVERED:
1515                 {
1516                         TC_PRT("BLUETOOTH_EVENT_GATT_PRIM_SVC_DISCOVERED");
1517                         bt_gatt_handle_info_t *prim_svc = param->param_data;
1518                         int i;
1519
1520                         if (prim_svc == NULL) {
1521                                 TC_PRT("prim_svc is NULL");
1522                                 break;
1523                         }
1524
1525                         for (i = 0; i < prim_svc->count; i++) {
1526                                 TC_PRT("prim_svc[%d] = %s\n", i, prim_svc->handle[i]);
1527                         }
1528
1529                         break;
1530                 }
1531
1532                 case BLUETOOTH_EVENT_GATT_SVC_CHAR_DISCOVERED:
1533                 {
1534                         TC_PRT("BLUETOOTH_EVENT_GATT_SVC_CHAR_DISCOVERED");
1535                         bt_gatt_discovered_char_t *svc_char = param->param_data;
1536                         int i = 0;
1537
1538                         if (svc_char == NULL) {
1539                                 TC_PRT("svc_char is NULL");
1540                                 break;
1541                         }
1542
1543                         if (svc_char->service_handle != NULL) {
1544                                 TC_PRT("svc_char->service_handle %s \n", svc_char->service_handle);
1545                         }
1546
1547                         for (i = 0; i < svc_char->handle_info.count; i++) {
1548                                 TC_PRT("svc_char.handle_info.handle[%d] = %s\n", i, svc_char->handle_info.handle[i]);
1549                         }
1550
1551                         break;
1552                 }
1553
1554                 case BLUETOOTH_EVENT_GATT_SVC_PROP_RECEIVED:
1555                 {
1556                         TC_PRT("BLUETOOTH_EVENT_GATT_SVC_PROP_RECEIVED");
1557                         bt_gatt_service_property_t *svc_pty = param->param_data;
1558                         int i;
1559
1560                         if (svc_pty == NULL) {
1561                                 TC_PRT("char_pty is NULL \n");
1562                                 break;
1563                         }
1564
1565                         if (svc_pty->service_handle != NULL) {
1566                                 TC_PRT("svc_pty->service_handle %s \n", svc_pty->service_handle);
1567                         }
1568
1569                         if (svc_pty->uuid != NULL) {
1570                                 TC_PRT("svc_pty->uuid %s \n", svc_pty->uuid);
1571                         }
1572
1573                         for (i = 0; i < svc_pty->handle_info.count; i++) {
1574                                 TC_PRT("svc_char[%d] = %s\n", i, svc_pty->handle_info.handle[i]);
1575                         }
1576
1577                         break;
1578                 }
1579
1580                 case BLUETOOTH_EVENT_GATT_CHAR_PROP_RECEIVED:
1581                 {
1582                         TC_PRT("BLUETOOTH_EVENT_GATT_CHAR_PROP_RECEIVED");
1583                         bt_gatt_char_property_t *char_pty = param->param_data;
1584                         int i = 0;
1585
1586                         if (char_pty->char_handle != NULL) {
1587                                 TC_PRT("char_pty->char_handle %s \n", char_pty->char_handle);
1588                         }
1589
1590                         if (char_pty->uuid != NULL) {
1591                                 TC_PRT("char_pty->uuid %s \n", char_pty->uuid);
1592                         }
1593
1594                         if (char_pty == NULL) {
1595                                 TC_PRT("char_pty is NULL \n");
1596                                 break;
1597                         }
1598
1599                         if (char_pty->name != NULL) {
1600                                 TC_PRT("char_pty->name %s \n", char_pty->name);
1601                         }
1602
1603                         if (char_pty->description != NULL) {
1604                                 TC_PRT("char_pty->description %s \n", char_pty->description);
1605                         }
1606
1607                         if (char_pty->val != NULL) {
1608                                 TC_PRT("char_pty->val_len %d \n", char_pty->val_len);
1609
1610                                 for (i = 0; i < char_pty->val_len; i++)
1611                                         TC_PRT("char_pty->val %02x \n", char_pty->val[i]);
1612                         }
1613
1614                         break;
1615                 }
1616 #endif
1617                 case BLUETOOTH_EVENT_KEYBOARD_PASSKEY_DISPLAY:
1618                 {
1619                         bluetooth_authentication_request_info_t *auth_info = param->param_data;
1620
1621                         TC_PRT("BLUETOOTH_EVENT_KEYBOARD_PASSKEY_DISPLAY");
1622                         TC_PRT("Device Address: [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]",
1623                                 auth_info->device_address.addr[0], auth_info->device_address.addr[1],
1624                                 auth_info->device_address.addr[2], auth_info->device_address.addr[3],
1625                                 auth_info->device_address.addr[4], auth_info->device_address.addr[5]);
1626                         TC_PRT("Device Name : [%s]", auth_info->device_name.name);
1627                         TC_PRT("Passkey: [%s]", auth_info->str_passkey);
1628                         break;
1629                 }
1630                 case BLUETOOTH_EVENT_PIN_REQUEST:
1631                 {
1632                         bluetooth_authentication_request_info_t *auth_info = param->param_data;
1633
1634                         TC_PRT("BLUETOOTH_EVENT_PIN_REQUEST");
1635                         TC_PRT("Device Address: [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]",
1636                                 auth_info->device_address.addr[0], auth_info->device_address.addr[1],
1637                                 auth_info->device_address.addr[2], auth_info->device_address.addr[3],
1638                                 auth_info->device_address.addr[4], auth_info->device_address.addr[5]);
1639                         TC_PRT("Device Name : [%s]", auth_info->device_name.name);
1640
1641                         TC_PRT("bluetooth_passkey_reply(\"0000\", TRUE)");
1642                         bluetooth_passkey_reply("0000", TRUE);
1643                         break;
1644                 }
1645                 case BLUETOOTH_EVENT_PASSKEY_REQUEST:
1646                 {
1647                         bluetooth_authentication_request_info_t *auth_info = param->param_data;
1648
1649                         TC_PRT("BLUETOOTH_EVENT_PASSKEY_REQUEST");
1650                         TC_PRT("Device Address: [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]",
1651                                 auth_info->device_address.addr[0], auth_info->device_address.addr[1],
1652                                 auth_info->device_address.addr[2], auth_info->device_address.addr[3],
1653                                 auth_info->device_address.addr[4], auth_info->device_address.addr[5]);
1654                         TC_PRT("Device Name : [%s]", auth_info->device_name.name);
1655
1656                         TC_PRT("bluetooth_passkey_reply(\"0000\", TRUE)");
1657                         bluetooth_passkey_reply("0000", TRUE);
1658                         break;
1659                 }
1660                 case BLUETOOTH_EVENT_PASSKEY_CONFIRM_REQUEST:
1661                 {
1662                         bluetooth_authentication_request_info_t *auth_info = param->param_data;
1663
1664                         TC_PRT("BLUETOOTH_EVENT_PASSKEY_CONFIRM_REQUEST");
1665                         TC_PRT("Device Address: [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]",
1666                                 auth_info->device_address.addr[0], auth_info->device_address.addr[1],
1667                                 auth_info->device_address.addr[2], auth_info->device_address.addr[3],
1668                                 auth_info->device_address.addr[4], auth_info->device_address.addr[5]);
1669                         TC_PRT("Device Name : [%s]", auth_info->device_name.name);
1670                         TC_PRT("Passkey: [%s]", auth_info->str_passkey);
1671
1672                         TC_PRT("bluetooth_passkey_confirmation_reply: TRUE");
1673                         bluetooth_passkey_confirmation_reply(TRUE);
1674                         break;
1675                 }
1676                 default:
1677                         TC_PRT("received event [0x%04x]", event);
1678                         break;
1679         }
1680         TC_PRT("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<");
1681 }
1682
1683 static gboolean key_event_cb(GIOChannel * chan, GIOCondition cond , gpointer data)
1684 {
1685         char buf[10] = {0};
1686
1687         unsigned int len = 0;
1688         int test_id;
1689         memset(buf, 0, sizeof(buf));
1690
1691         if (g_io_channel_read_chars(chan, buf, sizeof(buf),
1692                                 &len, NULL) == G_IO_STATUS_ERROR) {
1693                 TC_PRT("IO Channel read error");
1694                 return FALSE;
1695         }
1696
1697         printf("%s\n", buf);
1698         tc_usage_print();
1699
1700         test_id = atoi(buf);
1701
1702         if (test_id)
1703                 g_idle_add(test_input_callback, (void*)test_id);
1704
1705         return TRUE;
1706 }
1707
1708 int main(void)
1709 {
1710         startup();
1711
1712         GIOChannel *key_io;
1713         key_io = g_io_channel_unix_new(fileno(stdin));
1714
1715         g_io_channel_set_encoding(key_io, NULL, NULL);
1716         g_io_channel_set_flags(key_io, G_IO_FLAG_NONBLOCK, NULL);
1717
1718         g_io_add_watch(key_io, G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
1719                         key_event_cb, NULL);
1720         g_io_channel_unref(key_io);
1721
1722         g_main_loop_run(main_loop);
1723
1724         cleanup();
1725         return 0;
1726 }
1727