test/le-adv/bluetooth-advertising-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-gatt-test.c
  26  * @brief      This is the source file for bluetooth framework test suite.
  27  */
  28
  29 #include <stdio.h>
  30 #include <errno.h>
  31 #include <ctype.h>
  32 #include <fcntl.h>
  33 #include <unistd.h>
  34 #include <stdint.h>
  35 #include <string.h>
  36 #include <glib.h>
  37 #include <dbus/dbus-glib.h>
  38
  39 #include "bluetooth-api.h"
  40
  41
  42 #define PRT(format, args...) printf("%s:%d() "format, __FUNCTION__, __LINE__, ##args)
  43 #define TC_PRT(format, args...) PRT(format"\n", ##args)
  44
  45 #define TC_PASS 1
  46 #define TC_FAIL 0
  47
  48 GMainLoop *main_loop = NULL;
  49
  50 typedef struct
  51 {
  52         const char *tc_name;
  53         int tc_code;
  54 } tc_table_t;
  55
  56 tc_table_t tc_table[] =
  57 {
  58         {"SetAdvertising ON"            , 1},
  59         {"SetAdvertising OFF"           , 2},
  60         {"SetCustomAdvertising ON, filter 0x03"         , 3},
  61         {"SetCustomAdvertising ON, filter 0x00"         , 4},
  62         {"SetAdvertisingData"           , 5},
  63         {"SetScanParameters"            ,6},
  64         {"SetScanResponseData"  ,7},
  65         {"Start LE Scan"                ,8},
  66         {"Stop LE Scan"         ,9},
  67         {"IsAdvertising"        ,10},
  68         {"Add White List"       ,11},
  69         {"Remove White List"    ,12},
  70         {"Clear White List"     ,13},
  71         {"Set Connectable ON"   ,14},
  72         {"Set Connectable OFF"  ,15},
  73
  74         /* -----------------------------------------*/
  75         {"Finish"                                       , 0x00ff},
  76         {NULL                                   , 0x0000},
  77
  78 };
  79
  80 #define tc_result(success, tc_index) \
  81         TC_PRT("Test case [%d - %s] %s", tc_table[tc_index].tc_code, tc_table[tc_index].tc_name, ((success == TC_PASS)?"Success":"Failed"));
  82
  83
  84 void tc_usage_print(void)
  85 {
  86         int i = 0;
  87
  88         while (tc_table[i].tc_name) {
  89                 if (tc_table[i].tc_code != 0x00ff) {
  90                         TC_PRT("Key %d : usage %s", tc_table[i].tc_code,
  91                                                         tc_table[i].tc_name);
  92                 } else {
  93                         TC_PRT("Key %d : usage %s\n\n", 0x00ff,
  94                                                         tc_table[i].tc_name);
  95                 }
  96
  97                 i++;
  98         }
  99 }
 100
 101 int test_input_callback(void *data)
 102 {
 103         int ret = 0;
 104         int test_id = (int)data;
 105         bluetooth_advertising_params_t params;
 106
 107         switch (test_id) {
 108         case 0x00ff:
 109                 TC_PRT("Finished");
 110                 g_main_loop_quit(main_loop);
 111                 break;
 112         case 1:
 113                 TC_PRT("SetAdvertising ON");
 114                 ret = bluetooth_set_advertising(TRUE);
 115                 break;
 116         case 2:
 117                 TC_PRT("SetAdvertising OFF");
 118                 ret = bluetooth_set_advertising(FALSE);
 119                 break;
 120         case 3:
 121                 TC_PRT("SetCustomAdvertising ON, Filter 0x03");
 122                 params.interval_min = 1280;
 123                 params.interval_max = 1280;
 124                 params.filter_policy = 0x03;
 125                 params.type = 0x00;
 126                 ret = bluetooth_set_custom_advertising(TRUE, &params);
 127                 break;
 128         case 4:
 129                 TC_PRT("SetCustomAdvertising ON, Filter 0x00");
 130                 params.interval_min = 1280;
 131                 params.interval_max = 1280;
 132                 params.filter_policy = 0x00;
 133                 params.type = 0x00;
 134                 ret = bluetooth_set_custom_advertising(TRUE, &params);
 135                 break;
 136         case 5: {
 137                 TC_PRT("SetAdvertisingData");
 138                 bluetooth_advertising_data_t adv;
 139                 guint8 data[6]  = {0x05, 0xFF, 0x02, 0x03, 0x04, 0x05};
 140
 141                 TC_PRT("%x %x %x %x %x %x", data[0], data[1], data[2], data[3],
 142                                 data[4], data[5]);
 143                 memcpy(adv.data, data, sizeof(data));
 144                 ret = bluetooth_set_advertising_data(&adv, sizeof(data));
 145                 break;
 146         }
 147         case 6:
 148                 TC_PRT("SetScanParameters");
 149         //      ret = bluetooth_set_scan_parameters(1280, 160 /* 80 */);
 150                 break;
 151         case 7: {
 152                 TC_PRT("SetScanResponseData");
 153                 bluetooth_scan_resp_data_t rsp;
 154                 guint8 data[7]  = {0x06, 0xFF, 0x02, 0x03, 0x04, 0x05, 0x06};
 155
 156                 TC_PRT("%x %x %x %x %x %x %x", data[0], data[1], data[2],
 157                                 data[3], data[4], data[5], data[6]);
 158                 memcpy(rsp.data, data, sizeof(data));
 159                 ret = bluetooth_set_scan_response_data(&rsp, sizeof(data));
 160                 break;
 161         }
 162         case 8:
 163                 TC_PRT("Start LE Scan");
 164                 ret = bluetooth_start_le_discovery();
 165                 break;
 166         case 9:
 167                 TC_PRT("Stop LE Scan");
 168                 ret = bluetooth_stop_le_discovery();
 169                 break;
 170         case 10: {
 171                 TC_PRT("IsAdvertising");
 172                 gboolean advertising = FALSE;
 173                 int ret;
 174
 175                 ret = bluetooth_is_advertising(&advertising);
 176                 if (ret == BLUETOOTH_ERROR_NONE)
 177                         TC_PRT("Advertising is %s", advertising ? "started" : "stopped");
 178                 else
 179                         TC_PRT("bluetooth_is_advertising failed with [%d]", ret);
 180                 break;
 181         }
 182         case 11: {
 183                 bluetooth_device_address_t device_address={{0x00,0x19,0x0E,0x11,0x56,0x06}};
 184
 185                 TC_PRT("Add White List");
 186
 187                 ret = bluetooth_add_white_list(&device_address, BLUETOOTH_DEVICE_PUBLIC_ADDRESS);
 188                 if (ret != BLUETOOTH_ERROR_NONE)
 189                         TC_PRT("bluetooth_add_white_list failed with [%d]", ret);
 190
 191                 break;
 192         }
 193         case 12: {
 194                 bluetooth_device_address_t device_address={{0x00,0x19,0x0E,0x11,0x56,0x06}};
 195
 196                 TC_PRT("Remove White List");
 197
 198                 ret = bluetooth_remove_white_list(&device_address, BLUETOOTH_DEVICE_PUBLIC_ADDRESS);
 199                 if (ret != BLUETOOTH_ERROR_NONE)
 200                         TC_PRT("bluetooth_remove_white_list failed with [%d]", ret);
 201
 202                 break;
 203         }
 204         case 13: {
 205                 TC_PRT("Clear White List");
 206
 207                 ret = bluetooth_clear_white_list();
 208                 if (ret != BLUETOOTH_ERROR_NONE)
 209                         TC_PRT("bluetooth_clear_white_list failed with [%d]", ret);
 210
 211                 break;
 212         }
 213         case 14: {
 214                 TC_PRT("Set Connectable ON");
 215
 216                 ret = bluetooth_set_connectable(TRUE);
 217                 if (ret != BLUETOOTH_ERROR_NONE)
 218                         TC_PRT("bt_adapter_set_connectable failed with [%d]", ret);
 219
 220                 break;
 221         }
 222         case 15: {
 223                 TC_PRT("Set Connectable OFF");
 224
 225                 ret = bluetooth_set_connectable(FALSE);
 226                 if (ret != BLUETOOTH_ERROR_NONE)
 227                         TC_PRT("bt_adapter_set_connectable failed with [%d]", ret);
 228
 229                 break;
 230         }
 231
 232         default:
 233                 break;
 234         }
 235
 236         TC_PRT("Result : %d", ret);
 237         return 0;
 238 }
 239
 240 void startup()
 241 {
 242         TC_PRT("bluetooth framework TC startup");
 243
 244         if (!g_thread_supported())
 245                 g_thread_init(NULL);
 246
 247         dbus_g_thread_init();
 248
 249         g_type_init();
 250         main_loop = g_main_loop_new(NULL, FALSE);
 251 }
 252
 253 void cleanup()
 254 {
 255         TC_PRT("bluetooth framework TC cleanup");
 256         if ( main_loop != NULL)
 257                 g_main_loop_unref(main_loop);
 258 }
 259
 260 void bt_event_callback(int event, bluetooth_event_param_t* param,
 261                                                         void *user_data)
 262 {
 263         TC_PRT(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>");
 264         TC_PRT("bt event callback 0x%04x", event);
 265         switch(event) {
 266         case BLUETOOTH_EVENT_DISCOVERY_STARTED:
 267                 TC_PRT("BLUETOOTH_EVENT_DISCOVERY_STARTED, result [0x%04x]", param->result);
 268                 break;
 269
 270         case BLUETOOTH_EVENT_LE_DISCOVERY_STARTED:
 271                 TC_PRT("BLUETOOTH_EVENT_LE_DISCOVERY_STARTED, result [0x%04x]", param->result);
 272                 break;
 273
 274         case BLUETOOTH_EVENT_LE_DISCOVERY_FINISHED:
 275                 TC_PRT("BLUETOOTH_EVENT_LE_DISCOVERY_FINISHED, result [0x%04x]", param->result);
 276                 break;
 277
 278         case BLUETOOTH_EVENT_REMOTE_LE_DEVICE_FOUND:
 279                 TC_PRT("LE device founded");
 280                 bluetooth_le_device_info_t *le_device_info = NULL;
 281                 le_device_info  = (bluetooth_le_device_info_t *)param->param_data;
 282                 TC_PRT("dev [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]", \
 283                         le_device_info->device_address.addr[0], le_device_info->device_address.addr[1], le_device_info->device_address.addr[2], \
 284                         le_device_info->device_address.addr[3], le_device_info->device_address.addr[4], le_device_info->device_address.addr[5]);
 285
 286                 break;
 287
 288         case BLUETOOTH_EVENT_REMOTE_DEVICE_FOUND:
 289         {
 290                 bluetooth_device_info_t *device_info = NULL;
 291                 TC_PRT("BLUETOOTH_EVENT_REMOTE_DEVICE_FOUND, result [0x%04x]", param->result);
 292                 device_info  = (bluetooth_device_info_t *)param->param_data;
 293                 TC_PRT("dev [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]", \
 294                         device_info->device_address.addr[0], device_info->device_address.addr[1], device_info->device_address.addr[2], \
 295                         device_info->device_address.addr[3], device_info->device_address.addr[4], device_info->device_address.addr[5]);
 296                 break;
 297         }
 298
 299         case BLUETOOTH_EVENT_REMOTE_DEVICE_NAME_UPDATED:
 300         {
 301                 bluetooth_device_info_t *device_info = NULL;
 302                 TC_PRT("BLUETOOTH_EVENT_REMOTE_DEVICE_NAME_UPDATED, result [0x%04x]", param->result);
 303                 device_info  = (bluetooth_device_info_t *)param->param_data;
 304                 TC_PRT("dev [%s] [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]", device_info->device_name.name, \
 305                         device_info->device_address.addr[0], device_info->device_address.addr[1], device_info->device_address.addr[2], \
 306                         device_info->device_address.addr[3], device_info->device_address.addr[4], device_info->device_address.addr[5]);
 307                 break;
 308         }
 309
 310         case BLUETOOTH_EVENT_DISCOVERY_FINISHED:
 311                 TC_PRT("BLUETOOTH_EVENT_DISCOVERY_FINISHED, result [0x%04x]", param->result);
 312                 break;
 313
 314         case BLUETOOTH_EVENT_ADVERTISING_STARTED:
 315                 TC_PRT("BLUETOOTH_EVENT_ADVERTISING_STARTED, result [0x%04x], "
 316                                 "interval_min [%f ms], interval_max [%f ms]",
 317                                 param->result,
 318                                 ((bluetooth_advertising_params_t *)param->param_data)->interval_min,
 319                                 ((bluetooth_advertising_params_t *)param->param_data)->interval_max);
 320                 break;
 321
 322         case BLUETOOTH_EVENT_ADVERTISING_STOPPED:
 323                 TC_PRT("BLUETOOTH_EVENT_ADVERTISING_STOPPED, result [0x%04x]", param->result);
 324                 break;
 325
 326         default:
 327                 TC_PRT("received event [0x%04x]", event);
 328                 break;
 329         }
 330         TC_PRT("<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<");
 331 }
 332
 333 static gboolean key_event_cb(GIOChannel *chan, GIOCondition cond, gpointer data)
 334 {
 335         char buf[10] = {0};
 336         unsigned int len = 0;
 337         int test_id;
 338
 339         if (g_io_channel_read(chan, buf, sizeof(buf), &len) !=
 340                                                         G_IO_ERROR_NONE) {
 341                 printf("IO Channel read error");
 342                 return FALSE;
 343         }
 344         printf("%s\n",buf);
 345         tc_usage_print();
 346
 347         test_id = atoi(buf);
 348
 349         if (test_id)
 350                 g_idle_add(test_input_callback, (void*)test_id);
 351
 352         return TRUE;
 353 }
 354
 355 int main()
 356 {
 357         int ret_val;
 358         GIOChannel *key_io;
 359
 360         startup();
 361
 362         /* Register callback function */
 363         TC_PRT("TC : %s", tc_table[0].tc_name);
 364         ret_val = bluetooth_register_callback(bt_event_callback, NULL);
 365         if (ret_val >= BLUETOOTH_ERROR_NONE) {
 366                 TC_PRT("bluetooth_register_callback returned Success");
 367                 tc_result(TC_PASS, 0);
 368         } else {
 369                 TC_PRT("bluetooth_register_callback returned failiure [0x%04x]", ret_val);
 370                 tc_result(TC_FAIL, 0);
 371                 return 0;
 372         }
 373
 374         ret_val = bluetooth_check_adapter();
 375         if (ret_val < BLUETOOTH_ERROR_NONE) {
 376                 TC_PRT("bluetooth_check_adapter returned failiure [0x%04x]", ret_val);
 377                 tc_result(TC_FAIL, 3);
 378         } else {
 379                 TC_PRT("BT state [0x%04x]", ret_val);
 380                 tc_result(TC_PASS, 3);
 381         }
 382
 383         key_io = g_io_channel_unix_new(fileno(stdin));
 384
 385         g_io_add_watch(key_io, G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
 386                         key_event_cb, NULL);
 387         g_io_channel_unref(key_io);
 388
 389         g_main_loop_run(main_loop);
 390
 391         cleanup();
 392         return 0;
 393 }