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