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