test/bluetooth-frwk-test.c

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