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