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         g_type_init();
1232         main_loop = g_main_loop_new(NULL, FALSE);
1233 }
1234
1235 void cleanup()
1236 {
1237         TC_PRT("bluetooth framework TC cleanup");
1238         if( main_loop!= NULL)
1239         {
1240                 g_main_loop_unref(main_loop);
1241         }
1242 }
1243
1244 void bt_hid_event_callback(int event, hid_event_param_t* param, void *user_data)
1245 {
1246         TC_PRT(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
1247         TC_PRT("bt event callback 0x%04x", event);
1248
1249
1250
1251 }
1252
1253 void bt_audio_event_callback(int event, bt_audio_event_param_t* param, void *user_data)
1254 {
1255         TC_PRT(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
1256         TC_PRT("bt event callback 0x%04x", event);
1257
1258
1259
1260 }
1261
1262 void bt_event_callback(int event, bluetooth_event_param_t* param, void *user_data)
1263 {
1264         TC_PRT(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
1265         TC_PRT("bt event callback 0x%04x", event);
1266         switch(event)
1267         {
1268                 case BLUETOOTH_EVENT_ENABLED:
1269                         TC_PRT("BLUETOOTH_EVENT_ENABLED, result [0x%04x]", param->result);
1270                         break;
1271
1272                 case BLUETOOTH_EVENT_DISABLED:
1273                         TC_PRT("BLUETOOTH_EVENT_DISABLED, result [0x%04x]", param->result);
1274                         break;
1275
1276                 case BLUETOOTH_EVENT_LOCAL_NAME_CHANGED:
1277                         TC_PRT("BLUETOOTH_EVENT_LOCAL_NAME_CHANGED, result [0x%04x]", param->result);
1278                         if (param->result == BLUETOOTH_ERROR_NONE)
1279                         {
1280                                 bluetooth_device_name_t *local_name = (bluetooth_device_name_t *)param->param_data;
1281                                 tc_result(TC_PASS, 6);
1282                                 TC_PRT("Changed Name : [%s]", local_name->name);
1283                         }
1284                         else
1285                         {
1286                                 tc_result(TC_FAIL, 6);
1287                         }
1288                         break;
1289
1290
1291                 case BLUETOOTH_EVENT_DISCOVERY_STARTED:
1292                         TC_PRT("BLUETOOTH_EVENT_DISCOVERY_STARTED, result [0x%04x]", param->result);
1293                         break;
1294
1295                 case BLUETOOTH_EVENT_REMOTE_DEVICE_FOUND:
1296                 {
1297                         bluetooth_device_info_t *device_info = NULL;
1298                         TC_PRT("BLUETOOTH_EVENT_REMOTE_DEVICE_FOUND, result [0x%04x]", param->result);
1299                         device_info  = (bluetooth_device_info_t *)param->param_data;
1300                         memcpy(&searched_device, &device_info->device_address, sizeof(bluetooth_device_address_t));
1301                         TC_PRT("dev [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]", \
1302                                 device_info->device_address.addr[0], device_info->device_address.addr[1], device_info->device_address.addr[2], \
1303                                 device_info->device_address.addr[3], device_info->device_address.addr[4], device_info->device_address.addr[5]);
1304                         break;
1305                 }
1306
1307                 case BLUETOOTH_EVENT_REMOTE_LE_DEVICE_FOUND:
1308                 {
1309                         int i;
1310                         bluetooth_le_device_info_t *le_device_info = NULL;
1311                         TC_PRT("BLUETOOTH_EVENT_REMOTE_LE_DEVICE_FOUND, result [0x%04x]", param->result);
1312                         le_device_info  = (bluetooth_le_device_info_t *)param->param_data;
1313                         TC_PRT("dev[%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]", \
1314                                 le_device_info->device_address.addr[0], le_device_info->device_address.addr[1], le_device_info->device_address.addr[2], \
1315                                 le_device_info->device_address.addr[3], le_device_info->device_address.addr[4], le_device_info->device_address.addr[5]);
1316                         TC_PRT("addr_type : %d", le_device_info->addr_type);
1317                         TC_PRT("rssi : %d", le_device_info->rssi);
1318                         TC_PRT("adv_ind_data_len :%d" , le_device_info->adv_ind_data.data_len);
1319                         TC_PRT("scan_resp_data_len :%d" , le_device_info->scan_resp_data.data_len);
1320
1321                         for (i=0; i<le_device_info->adv_ind_data.data_len; i++)
1322                                 TC_PRT("adv_ind_data[%d] : [0x%x]",i ,le_device_info->adv_ind_data.data.data[i]);
1323                         for (i=0; i<le_device_info->scan_resp_data.data_len; i++)
1324                                 TC_PRT("scan_resp_data[%d] : [0x%x]",i ,le_device_info->scan_resp_data.data.data[i]);
1325                         break;
1326                 }
1327
1328                 case BLUETOOTH_EVENT_REMOTE_DEVICE_NAME_UPDATED:
1329                 {
1330                         bluetooth_device_info_t *device_info = NULL;
1331                         TC_PRT("BLUETOOTH_EVENT_REMOTE_DEVICE_NAME_UPDATED, result [0x%04x]", param->result);
1332                         device_info  = (bluetooth_device_info_t *)param->param_data;
1333                         memcpy(&searched_device, &device_info->device_address, sizeof(bluetooth_device_address_t));
1334                         TC_PRT("dev [%s] [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]", device_info->device_name.name, \
1335                                 device_info->device_address.addr[0], device_info->device_address.addr[1], device_info->device_address.addr[2], \
1336                                 device_info->device_address.addr[3], device_info->device_address.addr[4], device_info->device_address.addr[5]);
1337                         break;
1338                 }
1339
1340                 case BLUETOOTH_EVENT_DISCOVERY_FINISHED:
1341                         TC_PRT("BLUETOOTH_EVENT_DISCOVERY_FINISHED, result [0x%04x]", param->result);
1342                         break;
1343
1344                 case BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED:
1345                 {
1346                         int *mode = (int *)param->param_data;
1347                         TC_PRT("BT_DISCOVERABLE_MODE_CHANGED, result [0x%04x]", param->result);
1348                         TC_PRT("mode [%d]", *mode);
1349                         break;
1350                 }
1351                 case BLUETOOTH_EVENT_DISCOVERABLE_TIMEOUT_CHANGED:
1352                 {
1353                         int *timeout = (int *)param->param_data;
1354                         TC_PRT("BLUETOOTH_EVENT_DISCOVERABLE_TIMEOUT_CHANGED, result [0x%04x]", param->result);
1355                         TC_PRT("timeout [%d]", *timeout);
1356                         break;
1357                 }
1358                 case BLUETOOTH_EVENT_BONDING_FINISHED:
1359                 {
1360                         TC_PRT("BLUETOOTH_EVENT_BONDING_FINISHED, result [0x%04x]", param->result);
1361                         if (param->result >= BLUETOOTH_ERROR_NONE)
1362                         {
1363                                 bluetooth_device_info_t *device_info = NULL;
1364                                 tc_result(TC_PASS, 12);
1365                                 device_info  = (bluetooth_device_info_t *)param->param_data;
1366                                 if (device_info == NULL)
1367                                         break;
1368
1369                                 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, \
1370                                         device_info->device_address.addr[0], device_info->device_address.addr[1], device_info->device_address.addr[2], \
1371                                         device_info->device_address.addr[3], device_info->device_address.addr[4], device_info->device_address.addr[5], \
1372                                         device_info->device_class.major_class, device_info->device_class.minor_class, device_info->device_class.service_class);
1373                         }
1374                         else
1375                         {
1376                                 tc_result(TC_FAIL, 12);
1377                         }
1378                         break;
1379                 }
1380
1381                 case BLUETOOTH_EVENT_BONDED_DEVICE_FOUND:
1382                 {
1383                         // bluetooth_get_bonded_device_list is changed as synchronous API. This event is not used any more.
1384                         // 2011.01.06
1385 #if 0
1386 //                      int i = 0;
1387                         TC_PRT("BLUETOOTH_EVENT_BONDED_DEVICE_FOUND, result [0x%04x]", param->result);
1388                         if (param->result >= BLUETOOTH_ERROR_NONE)
1389                         {
1390                                 ///tc_result(TC_PASS, 15);
1391                                 bluetooth_device_info_t * bt_dev_info= (bluetooth_device_info_t*)param->param_data;
1392
1393                                 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,
1394                                         bt_dev_info->device_address.addr[0], bt_dev_info->device_address.addr[1], bt_dev_info->device_address.addr[2], \
1395                                         bt_dev_info->device_address.addr[3], bt_dev_info->device_address.addr[4], bt_dev_info->device_address.addr[5], \
1396                                         bt_dev_info->device_class.major_class, bt_dev_info->device_class.minor_class, bt_dev_info->device_class.service_class);
1397
1398                         }
1399                         else
1400                         if(param->result == BLUETOOTH_ERROR_END_OF_DEVICE_LIST) /*End of the Device found indication*/
1401                         {
1402                                 tc_result(TC_PASS, 15);
1403                                 TC_PRT("*****<<No more BLUETOOTH_EVENT_BONDED_DEVICE_FOUND indication>>***** ");
1404                         }
1405                         else
1406                         {
1407                                 tc_result(TC_FAIL, 15);
1408                                 TC_PRT("*****API failed ***** ");
1409                         }
1410                         break;
1411 #endif
1412                 }
1413                 case BLUETOOTH_EVENT_SERVICE_SEARCHED:
1414                 {
1415                         int i = 0;
1416                         TC_PRT("BLUETOOTH_EVENT_SERVICE_SEARCHED, result [0x%04x]", param->result);
1417                         if (param->result >= BLUETOOTH_ERROR_NONE)
1418                         {
1419                                 tc_result(TC_PASS, 18);
1420                                 bt_sdp_info_t * bt_sdp_info=param->param_data;
1421
1422                                 TC_PRT("Dev add = %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n",
1423                                         bt_sdp_info->device_addr.addr[0], bt_sdp_info->device_addr.addr[1], bt_sdp_info->device_addr.addr[2], \
1424                                         bt_sdp_info->device_addr.addr[3], bt_sdp_info->device_addr.addr[4], bt_sdp_info->device_addr.addr[5]);
1425
1426                                         TC_PRT("Supported service list:\n");
1427                                         for(i=0; i<bt_sdp_info->service_index; i++)
1428                                                 TC_PRT("[%#x]\n", bt_sdp_info->service_list_array[i]);
1429
1430                         }
1431                         else
1432                         {
1433                                 tc_result(TC_FAIL, 18);
1434                         }
1435                         break;
1436                 }
1437                 case BLUETOOTH_EVENT_RFCOMM_DATA_RECEIVED:
1438                 {
1439                         TC_PRT("BLUETOOTH_EVENT_RFCOMM_DATA_RECEIVED, result [0x%04x]", param->result);
1440                         bluetooth_rfcomm_received_data_t *rx_data = param->param_data;
1441                         printf("\n FD = %d \nBuffer len = %d ", rx_data->socket_fd, rx_data->buffer_size);
1442                         if (rx_data->buffer_size < sizeof(oob_data_t))
1443                                 TC_PRT("Complete oob data is not recivedn");
1444                         else
1445                                 memcpy(&g_remote_oob_data,rx_data->buffer, sizeof(oob_data_t));
1446                         //tc_result(TC_PASS, 21);
1447                         break;
1448                 }
1449                 case BLUETOOTH_EVENT_RFCOMM_CONNECTED:
1450                 {
1451                         bluetooth_rfcomm_connection_t *con_ind = (bluetooth_rfcomm_connection_t *)param->param_data;
1452                         TC_PRT("BLUETOOTH_EVENT_RFCOMM_CONNECTED, result [0x%04x], fd = %d, device add = 0x%X:%X:%X:%X:%X:%X, Role = %s", param->result,
1453                                                                 con_ind->socket_fd,
1454                                                                 con_ind->device_addr.addr[0], con_ind->device_addr.addr[1], con_ind->device_addr.addr[2],
1455                                                                 con_ind->device_addr.addr[3], con_ind->device_addr.addr[4], con_ind->device_addr.addr[5],
1456                                                                 (con_ind->device_role == RFCOMM_ROLE_SERVER)? "SERVER":"CLIENT");
1457                         //tc_result(TC_PASS, 22);
1458                         if((con_ind->device_role == RFCOMM_ROLE_CLIENT) && (con_ind->socket_fd > 0))
1459                         {
1460                                 g_ret_client_fd1 = con_ind->socket_fd;
1461                         }
1462
1463                         if((con_ind->device_role == RFCOMM_ROLE_SERVER) && (con_ind->socket_fd > 0))
1464                         {
1465                                 client_fd = con_ind->socket_fd;
1466                         }
1467
1468                         break;
1469                 }
1470                 case BLUETOOTH_EVENT_RFCOMM_DISCONNECTED:
1471                 {
1472                         bluetooth_rfcomm_disconnection_t *disconnection_ind = (bluetooth_rfcomm_disconnection_t *)param->param_data;;
1473                         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,
1474                                                                                                                 disconnection_ind->device_addr.addr[0], disconnection_ind->device_addr.addr[1], disconnection_ind->device_addr.addr[2],
1475                                                                                                                 disconnection_ind->device_addr.addr[3], disconnection_ind->device_addr.addr[4], disconnection_ind->device_addr.addr[5] );
1476                         //tc_result(TC_PASS, 22);
1477                         break;
1478                 }
1479                 case BLUETOOTH_EVENT_NETWORK_SERVER_CONNECTED:
1480                 {
1481                         bluetooth_network_device_info_t *dev_info = (bluetooth_network_device_info_t *)param->param_data;
1482
1483                         TC_PRT("BLUETOOTH_EVENT_RFCOMM_DISCONNECTED, result [0x%04x]", param->result);
1484                         TC_PRT("interface name: %s", dev_info->interface_name);
1485
1486                         TC_PRT("device add = %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n",
1487                                                                 dev_info->device_address.addr[0], dev_info->device_address.addr[1], dev_info->device_address.addr[2],
1488                                                                 dev_info->device_address.addr[3], dev_info->device_address.addr[4], dev_info->device_address.addr[5] );
1489                         break;
1490                 }
1491                 case BLUETOOTH_EVENT_NETWORK_SERVER_DISCONNECTED:
1492                 {
1493                         bluetooth_network_device_info_t *dev_info = (bluetooth_network_device_info_t *)param->param_data;
1494
1495                         TC_PRT("BLUETOOTH_EVENT_RFCOMM_DISCONNECTED, result [0x%04x]", param->result);
1496                         TC_PRT("interface name: %s", dev_info->interface_name);
1497
1498                         TC_PRT("device add = %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n",
1499                                                                 dev_info->device_address.addr[0], dev_info->device_address.addr[1], dev_info->device_address.addr[2],
1500                                                                 dev_info->device_address.addr[3], dev_info->device_address.addr[4], dev_info->device_address.addr[5] );
1501                         break;
1502                 }
1503
1504                 case BLUETOOTH_EVENT_HDP_CONNECTED:
1505                 {
1506                         bt_hdp_connected_t *conn_ind = (bt_hdp_connected_t *)param->param_data;
1507
1508                         TC_PRT("BLUETOOTH_EVENT_HDP_CONNECTED, Result = %s\n", (param->result == 0)? "BLUETOOTH_ERROR_NONE": "BLUETOOTH_ERROR_XXXX");
1509                         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");
1510                         TC_PRT("device add = %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n",
1511                                                                 conn_ind->device_address.addr[0], conn_ind->device_address.addr[1], conn_ind->device_address.addr[2],
1512                                                                 conn_ind->device_address.addr[3], conn_ind->device_address.addr[4], conn_ind->device_address.addr[5] );
1513
1514                         g_ret_client_fd1 = conn_ind->channel_id;
1515                         break;
1516                 }
1517
1518                 case BLUETOOTH_EVENT_HDP_DISCONNECTED:
1519                 {
1520                         bt_hdp_disconnected_t *dis_ind = (bt_hdp_disconnected_t *)param->param_data;
1521
1522                         TC_PRT("BLUETOOTH_EVENT_HDP_DISCONNECTED, Result = %s\n", (param->result == 0)? "BLUETOOTH_ERROR_NONE": "BLUETOOTH_ERROR_XXXX");
1523                         TC_PRT("Channel = %d, Add = device add = %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n", dis_ind->channel_id,
1524                                                                 dis_ind->device_address.addr[0], dis_ind->device_address.addr[1], dis_ind->device_address.addr[2],
1525                                                                 dis_ind->device_address.addr[3], dis_ind->device_address.addr[4], dis_ind->device_address.addr[5]);
1526                         break;
1527                 }
1528
1529                 case BLUETOOTH_EVENT_HDP_DATA_RECEIVED:
1530                 {
1531                         bt_hdp_data_ind_t *data_ind = (bt_hdp_data_ind_t *)param->param_data;
1532
1533                         TC_PRT("BLUETOOTH_EVENT_HDP_DATA_RECEIVED, Result = %s\n", (param->result == 0)? "BLUETOOTH_ERROR_NONE": "BLUETOOTH_ERROR_XXXX");
1534                         TC_PRT("Data received from channel id = %d and  size =%d, buff =[%s]\n",  data_ind->channel_id, data_ind->size, data_ind->buffer);
1535
1536                         break;
1537                 }
1538
1539                 case BLUETOOTH_EVENT_OPC_CONNECTED:
1540                         TC_PRT("BLUETOOTH_EVENT_OPC_CONNECTED");
1541                         break;
1542
1543                 case BLUETOOTH_EVENT_OPC_DISCONNECTED:
1544                         TC_PRT("BLUETOOTH_EVENT_OPC_DISCONNECTED");
1545                         break;
1546                 case BLUETOOTH_EVENT_OPC_TRANSFER_STARTED:
1547                 {
1548                         TC_PRT("BLUETOOTH_EVENT_OPC_TRANSFER_STARTED");
1549                         if (param->param_data) {
1550                                 bt_opc_transfer_info_t *info = param->param_data;
1551                                 TC_PRT("file %s", info->filename);
1552                                 TC_PRT("size %ld", info->size);
1553                         }
1554                         break;
1555                 }
1556                 case BLUETOOTH_EVENT_OPC_TRANSFER_PROGRESS:
1557                 {
1558                         TC_PRT("BLUETOOTH_EVENT_OPC_TRANSFER_PROGRESS");
1559                         break;
1560                 }
1561                 case BLUETOOTH_EVENT_OPC_TRANSFER_COMPLETE:
1562                 {
1563                         TC_PRT("BLUETOOTH_EVENT_OPC_TRANSFER_COMPLETE");
1564                         bt_opc_transfer_info_t *info = param->param_data;
1565                         TC_PRT("file %s", info->filename);
1566                         TC_PRT("size %ld", info->size);
1567                         break;
1568                 }
1569
1570                 case BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_AUTHORIZE:
1571                         TC_PRT("BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_AUTHORIZE");
1572                         break;
1573
1574                 case BLUETOOTH_EVENT_OBEX_SERVER_CONNECTION_AUTHORIZE:
1575                         TC_PRT("BLUETOOTH_EVENT_OBEX_SERVER_CONNECTION_AUTHORIZE");
1576                         break;
1577
1578                 case BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_STARTED:
1579                         TC_PRT("BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_STARTED");
1580                         bt_obex_server_transfer_info_t *info = param->param_data;
1581                         current_transfer_id = info->transfer_id;
1582                         break;
1583
1584                 case BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_PROGRESS:
1585                         TC_PRT("BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_PROGRESS");
1586                         break;
1587
1588                 case BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_COMPLETED:
1589                         TC_PRT("BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_COMPLETED");
1590                         break;
1591                 case BLUETOOTH_EVENT_MANUFACTURER_DATA_CHANGED:
1592                 {       TC_PRT("BLUETOOTH_EVENT_MANUFACTURER_DATA_CHANGED");
1593                         break;
1594                 }
1595 #if 0
1596                 case BLUETOOTH_EVENT_GATT_PRIM_SVC_DISCOVERED:
1597                 {
1598                         TC_PRT("BLUETOOTH_EVENT_GATT_PRIM_SVC_DISCOVERED");
1599                         bt_gatt_handle_info_t *prim_svc = param->param_data;
1600                         int i;
1601
1602                         if (prim_svc == NULL) {
1603                                 TC_PRT("prim_svc is NULL");
1604                                 break;
1605                         }
1606
1607                         for (i = 0; i < prim_svc->count; i++) {
1608                                 TC_PRT("prim_svc[%d] = %s\n", i, prim_svc->handle[i]);
1609                         }
1610
1611                         break;
1612                 }
1613
1614                 case BLUETOOTH_EVENT_GATT_SVC_CHAR_DISCOVERED:
1615                 {
1616                         TC_PRT("BLUETOOTH_EVENT_GATT_SVC_CHAR_DISCOVERED");
1617                         bt_gatt_discovered_char_t *svc_char = param->param_data;
1618                         int i = 0;
1619
1620                         if (svc_char == NULL) {
1621                                 TC_PRT("svc_char is NULL");
1622                                 break;
1623                         }
1624
1625                         if (svc_char->service_handle != NULL) {
1626                                 TC_PRT("svc_char->service_handle %s \n", svc_char->service_handle);
1627                         }
1628
1629                         for (i = 0; i < svc_char->handle_info.count; i++) {
1630                                 TC_PRT("svc_char.handle_info.handle[%d] = %s\n", i, svc_char->handle_info.handle[i]);
1631                         }
1632
1633                         break;
1634                 }
1635
1636                 case BLUETOOTH_EVENT_GATT_SVC_PROP_RECEIVED:
1637                 {
1638                         TC_PRT("BLUETOOTH_EVENT_GATT_SVC_PROP_RECEIVED");
1639                         bt_gatt_service_property_t *svc_pty = param->param_data;
1640                         int i;
1641
1642                         if (svc_pty == NULL) {
1643                                 TC_PRT("char_pty is NULL \n");
1644                                 break;
1645                         }
1646
1647                         if (svc_pty->service_handle != NULL) {
1648                                 TC_PRT("svc_pty->service_handle %s \n", svc_pty->service_handle);
1649                         }
1650
1651                         if (svc_pty->uuid != NULL) {
1652                                 TC_PRT("svc_pty->uuid %s \n", svc_pty->uuid);
1653                         }
1654
1655                         for (i = 0; i < svc_pty->handle_info.count; i++) {
1656                                 TC_PRT("svc_char[%d] = %s\n", i, svc_pty->handle_info.handle[i]);
1657                         }
1658
1659                         break;
1660                 }
1661
1662                 case BLUETOOTH_EVENT_GATT_CHAR_PROP_RECEIVED:
1663                 {
1664                         TC_PRT("BLUETOOTH_EVENT_GATT_CHAR_PROP_RECEIVED");
1665                         bt_gatt_char_property_t *char_pty = param->param_data;
1666                         int i = 0;
1667
1668                         if (char_pty->char_handle != NULL) {
1669                                 TC_PRT("char_pty->char_handle %s \n", char_pty->char_handle);
1670                         }
1671
1672                         if (char_pty->uuid != NULL) {
1673                                 TC_PRT("char_pty->uuid %s \n", char_pty->uuid);
1674                         }
1675
1676                         if (char_pty == NULL) {
1677                                 TC_PRT("char_pty is NULL \n");
1678                                 break;
1679                         }
1680
1681                         if (char_pty->name != NULL) {
1682                                 TC_PRT("char_pty->name %s \n", char_pty->name);
1683                         }
1684
1685                         if (char_pty->description != NULL) {
1686                                 TC_PRT("char_pty->description %s \n", char_pty->description);
1687                         }
1688
1689                         if (char_pty->val != NULL) {
1690                                 TC_PRT("char_pty->val_len %d \n", char_pty->val_len);
1691
1692                                 for (i = 0; i < char_pty->val_len; i ++)
1693                                         TC_PRT("char_pty->val %02x \n", char_pty->val[i]);
1694                         }
1695
1696                         break;
1697                 }
1698 #endif
1699                 case BLUETOOTH_EVENT_KEYBOARD_PASSKEY_DISPLAY:
1700                 {
1701                         bluetooth_authentication_request_info_t *auth_info = param->param_data;
1702
1703                         TC_PRT("BLUETOOTH_EVENT_KEYBOARD_PASSKEY_DISPLAY");
1704                         TC_PRT("Device Address: [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]",
1705                                 auth_info->device_address.addr[0], auth_info->device_address.addr[1],
1706                                 auth_info->device_address.addr[2], auth_info->device_address.addr[3],
1707                                 auth_info->device_address.addr[4], auth_info->device_address.addr[5]);
1708                         TC_PRT("Device Name : [%s]", auth_info->device_name.name);
1709                         TC_PRT("Passkey: [%s]", auth_info->str_passkey);
1710                         break;
1711                 }
1712                 case BLUETOOTH_EVENT_PIN_REQUEST:
1713                 {
1714                         bluetooth_authentication_request_info_t *auth_info = param->param_data;
1715
1716                         TC_PRT("BLUETOOTH_EVENT_PIN_REQUEST");
1717                         TC_PRT("Device Address: [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]",
1718                                 auth_info->device_address.addr[0], auth_info->device_address.addr[1],
1719                                 auth_info->device_address.addr[2], auth_info->device_address.addr[3],
1720                                 auth_info->device_address.addr[4], auth_info->device_address.addr[5]);
1721                         TC_PRT("Device Name : [%s]", auth_info->device_name.name);
1722
1723                         TC_PRT("bluetooth_passkey_reply(\"0000\", TRUE)");
1724                         bluetooth_passkey_reply("0000", TRUE);
1725                         break;
1726                 }
1727                 case BLUETOOTH_EVENT_PASSKEY_REQUEST:
1728                 {
1729                         bluetooth_authentication_request_info_t *auth_info = param->param_data;
1730
1731                         TC_PRT("BLUETOOTH_EVENT_PASSKEY_REQUEST");
1732                         TC_PRT("Device Address: [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]",
1733                                 auth_info->device_address.addr[0], auth_info->device_address.addr[1],
1734                                 auth_info->device_address.addr[2], auth_info->device_address.addr[3],
1735                                 auth_info->device_address.addr[4], auth_info->device_address.addr[5]);
1736                         TC_PRT("Device Name : [%s]", auth_info->device_name.name);
1737
1738                         TC_PRT("bluetooth_passkey_reply(\"0000\", TRUE)");
1739                         bluetooth_passkey_reply("0000", TRUE);
1740                         break;
1741                 }
1742                 case BLUETOOTH_EVENT_PASSKEY_CONFIRM_REQUEST:
1743                 {
1744                         bluetooth_authentication_request_info_t *auth_info = param->param_data;
1745
1746                         TC_PRT("BLUETOOTH_EVENT_PASSKEY_CONFIRM_REQUEST");
1747                         TC_PRT("Device Address: [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]",
1748                                 auth_info->device_address.addr[0], auth_info->device_address.addr[1],
1749                                 auth_info->device_address.addr[2], auth_info->device_address.addr[3],
1750                                 auth_info->device_address.addr[4], auth_info->device_address.addr[5]);
1751                         TC_PRT("Device Name : [%s]", auth_info->device_name.name);
1752                         TC_PRT("Passkey: [%s]", auth_info->str_passkey);
1753
1754                         TC_PRT("bluetooth_passkey_confirmation_reply: TRUE");
1755                         bluetooth_passkey_confirmation_reply(TRUE);
1756                         break;
1757                 }
1758                 default:
1759                         TC_PRT("received event [0x%04x]", event);
1760                         break;
1761         }
1762         TC_PRT("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<");
1763 }
1764
1765 static gboolean key_event_cb(GIOChannel * chan, GIOCondition cond , gpointer data)
1766 {
1767         char buf[10] = {0};
1768
1769         unsigned int len=0;
1770         int test_id;
1771         memset(buf, 0, sizeof(buf));
1772
1773         if(g_io_channel_read_chars(chan, buf, sizeof(buf),
1774                                 &len, NULL) == G_IO_STATUS_ERROR) {
1775                 TC_PRT("IO Channel read error");
1776                 return FALSE;
1777         }
1778
1779         printf("%s\n",buf);
1780         tc_usage_print();
1781
1782         test_id=atoi(buf);
1783
1784         if(test_id)
1785                 g_idle_add(test_input_callback, (void*)test_id);
1786
1787         return TRUE;
1788 }
1789
1790 int main(void)
1791 {
1792         startup();
1793
1794         GIOChannel *key_io;
1795         key_io=g_io_channel_unix_new(fileno(stdin));
1796
1797         g_io_channel_set_encoding(key_io, NULL, NULL);
1798         g_io_channel_set_flags(key_io, G_IO_FLAG_NONBLOCK, NULL);
1799
1800         g_io_add_watch(key_io, G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
1801                         key_event_cb, NULL);
1802         g_io_channel_unref(key_io);
1803
1804         g_main_loop_run(main_loop);
1805
1806         cleanup();
1807         return 0;
1808 }
1809