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