Home | History | Annotate | Download | only in bdtool 
      1 /******************************************************************************
      2  *
      3  *  Copyright (C) 2014 Google, Inc.
      4  *
      5  *  Licensed under the Apache License, Version 2.0 (the "License");
      6  *  you may not use this file except in compliance with the License.
      7  *  You may obtain a copy of the License at:
      8  *
      9  *  http://www.apache.org/licenses/LICENSE-2.0
     10  *
     11  *  Unless required by applicable law or agreed to in writing, software
     12  *  distributed under the License is distributed on an "AS IS" BASIS,
     13  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     14  *  See the License for the specific language governing permissions and
     15  *  limitations under the License.
     16  *
     17  ******************************************************************************/
     18 
     19 #include "base.h"
     20 #include "btcore/include/bdaddr.h"
     21 #include "btcore/include/property.h"
     22 #include "support/adapter.h"
     23 #include "support/callbacks.h"
     24 
     25 static bt_state_t state;
     26 static int property_count = 0;
     27 static bt_property_t *properties = NULL;
     28 static bt_discovery_state_t discovery_state;
     29 static bt_acl_state_t acl_state;
     30 static bt_bond_state_t bond_state;
     31 
     32 static void parse_properties(int num_properties, bt_property_t *property);
     33 
     34 // Returns the current adapter state.
     35 bt_state_t adapter_get_state() {
     36   return state;
     37 }
     38 
     39 // Returns the number of adapter properties.
     40 int adapter_get_property_count() {
     41   return property_count;
     42 }
     43 
     44 // Returns the specified property.
     45 bt_property_t *adapter_get_property(bt_property_type_t type) {
     46   for (int i = 0; i < property_count; ++i) {
     47     if (properties[i].type == type) {
     48       return &properties[i];
     49     }
     50   }
     51 
     52   return NULL;
     53 }
     54 
     55 // Returns the device discovery state.
     56 bt_discovery_state_t adapter_get_discovery_state() {
     57   return discovery_state;
     58 }
     59 
     60 // Returns the device acl state.
     61 bt_acl_state_t adapter_get_acl_state() {
     62   return acl_state;
     63 }
     64 
     65 // Returns the device bond state.
     66 bt_bond_state_t adapter_get_bond_state() {
     67   return bond_state;
     68 }
     69 
     70 // callback
     71 void acl_state_changed(bt_status_t status, bt_bdaddr_t *remote_bd_addr, bt_acl_state_t state) {
     72   acl_state = state;
     73   CALLBACK_RET();
     74 }
     75 
     76 // callback
     77 void adapter_properties(bt_status_t status,
     78     int num_properties,
     79     bt_property_t *new_properties) {
     80   property_free_array(properties, property_count);
     81   properties = property_copy_array(new_properties, num_properties);
     82   property_count = num_properties;
     83 
     84   CALLBACK_RET();
     85 }
     86 
     87 // callback
     88 void adapter_state_changed(bt_state_t new_state) {
     89   state = new_state;
     90   CALLBACK_RET();
     91 }
     92 
     93 // callback
     94 void bond_state_changed(bt_status_t status,
     95     bt_bdaddr_t *bdaddr,
     96     bt_bond_state_t state) {
     97   char buf[18];
     98   bond_state = state;
     99 
    100   const char *state_name = "Bond state unknown";
    101   switch (bond_state) {
    102     case BT_BOND_STATE_NONE:
    103       state_name = "Bond state none";
    104       break;
    105 
    106     case BT_BOND_STATE_BONDING:
    107       state_name = "Bond state bonding";
    108       break;
    109 
    110     case BT_BOND_STATE_BONDED:
    111       state_name = "Bond state bonded";
    112       break;
    113 
    114       // default none
    115   }
    116   fprintf(stdout, "Bond state changed callback addr:%s state:%s\n", bdaddr_to_string(bdaddr, buf, sizeof(buf)), state_name);
    117 
    118   CALLBACK_RET();
    119 }
    120 
    121 // callback
    122 void device_found(int num_properties, bt_property_t *property) {
    123   fprintf(stdout, "Device found num_properties:%d\n", num_properties);
    124   parse_properties(num_properties, property);
    125 
    126   CALLBACK_RET();
    127 }
    128 
    129 // callback
    130 void discovery_state_changed(bt_discovery_state_t state) {
    131   const char *state_name = "Unknown";
    132   discovery_state = state;
    133 
    134   switch (discovery_state) {
    135     case BT_DISCOVERY_STOPPED:
    136       state_name = "Discovery stopped";
    137       break;
    138 
    139     case BT_DISCOVERY_STARTED:
    140       state_name = "Discovery started";
    141       break;
    142 
    143       // default omitted
    144   }
    145   fprintf(stdout, "Discover state %s\n", state_name);
    146 
    147   CALLBACK_RET();
    148 }
    149 
    150 // callback
    151 void remote_device_properties(bt_status_t status,
    152     bt_bdaddr_t *bdaddr,
    153     int num_properties,
    154     bt_property_t *properties) {
    155   char buf[18];
    156   fprintf(stdout, "Device found bdaddr:%s num_properties:%d\n",
    157       bdaddr_to_string(bdaddr, buf, sizeof(buf)), num_properties);
    158 
    159   parse_properties(num_properties, properties);
    160 
    161   CALLBACK_RET();
    162 }
    163 
    164 // callback
    165 void ssp_request(
    166     bt_bdaddr_t *remote_bd_addr,
    167     bt_bdname_t *bd_name,
    168     uint32_t cod,
    169     bt_ssp_variant_t pairing_variant,
    170     uint32_t pass_key) {
    171   char *pairing_variant_name = "Unknown";
    172 
    173   switch (pairing_variant) {
    174     case BT_SSP_VARIANT_PASSKEY_CONFIRMATION:
    175       pairing_variant_name = "Passkey confirmation";
    176       break;
    177     case BT_SSP_VARIANT_PASSKEY_ENTRY:
    178       pairing_variant_name = "Passkey entry";
    179       break;
    180 
    181     case BT_SSP_VARIANT_CONSENT:
    182       pairing_variant_name = "Passkey consent";
    183       break;
    184 
    185     case BT_SSP_VARIANT_PASSKEY_NOTIFICATION:
    186       pairing_variant_name = "Passkey notification";
    187       break;
    188   }
    189 
    190   fprintf(stdout, "Got ssp request device_class:%u passkey:%x pairing_variant:%s\n", cod, pass_key, pairing_variant_name);
    191   char buf[18];
    192   fprintf(stdout, "Device found:%s %s\n", bdaddr_to_string(remote_bd_addr, buf, sizeof(buf)), bd_name->name);
    193 
    194 
    195   fprintf(stdout, "auto-accepting bond\n");
    196   bool accept = true;
    197   int rc = bt_interface->ssp_reply(remote_bd_addr, pairing_variant,
    198       (uint8_t)accept, pass_key);
    199   CALLBACK_RET();
    200 }
    201 
    202 // callback
    203 void thread_evt(bt_cb_thread_evt evt) {
    204   CALLBACK_RET();
    205 }
    206 
    207 static void parse_properties(int num_properties, bt_property_t *property) {
    208   while (num_properties-- > 0) {
    209     switch(property->type) {
    210       case BT_PROPERTY_BDNAME:
    211         {
    212           const bt_bdname_t *name = property_as_name(property);
    213           if (name)
    214             fprintf(stdout, " name:%s\n", name->name);
    215         }
    216         break;
    217 
    218       case BT_PROPERTY_BDADDR:
    219         {
    220           char buf[18];
    221           const bt_bdaddr_t *addr = property_as_addr(property);
    222           if (addr)
    223             fprintf(stdout, " addr:%s\n", bdaddr_to_string(addr, buf, sizeof(buf)));
    224         }
    225         break;
    226 
    227       case BT_PROPERTY_UUIDS:
    228         {
    229           size_t num_uuid;
    230           const bt_uuid_t *uuid = property_as_uuids(property, &num_uuid);
    231           if (uuid) {
    232             for (size_t i = 0; i < num_uuid; i++) {
    233               fprintf(stdout, " uuid:%zd: ", i);
    234               for (size_t j = 0; j < sizeof(uuid); j++) {
    235                 fprintf(stdout, "%02x", uuid->uu[j]);
    236               }
    237               fprintf(stdout, "\n");
    238             }
    239           }
    240         }
    241         break;
    242 
    243       case BT_PROPERTY_TYPE_OF_DEVICE:
    244         {
    245           bt_device_type_t device_type = property_as_device_type(property);
    246           if (device_type) {
    247             const struct {
    248               const char * device_type;
    249             } device_type_lookup[] = {
    250               { "Unknown" },
    251               { "Classic Only" },
    252               { "BLE Only" },
    253               { "Both Classic and BLE" },
    254             };
    255             int idx = (int)device_type;
    256             if (idx > BT_DEVICE_DEVTYPE_DUAL)
    257               idx = 0;
    258             fprintf(stdout, " device_type:%s\n", device_type_lookup[idx].device_type);
    259           }
    260         }
    261         break;
    262 
    263       case BT_PROPERTY_CLASS_OF_DEVICE:
    264         {
    265           const bt_device_class_t *dc = property_as_device_class(property);
    266           int dc_int = device_class_to_int(dc);
    267           fprintf(stdout, " device_class:0x%x\n", dc_int);
    268         }
    269         break;
    270 
    271       case BT_PROPERTY_REMOTE_RSSI:
    272         {
    273           int8_t rssi = property_as_rssi(property);
    274           fprintf(stdout, " rssi:%d\n", rssi);
    275         }
    276         break;
    277 
    278       case BT_PROPERTY_REMOTE_FRIENDLY_NAME:
    279         {
    280           const bt_bdname_t *name = property_as_name(property);
    281           if (name)
    282             fprintf(stdout, " remote_name:%s\n", name->name);
    283         }
    284         break;
    285 
    286       case BT_PROPERTY_SERVICE_RECORD:
    287       case BT_PROPERTY_ADAPTER_SCAN_MODE:
    288       case BT_PROPERTY_ADAPTER_BONDED_DEVICES:
    289       case BT_PROPERTY_ADAPTER_DISCOVERY_TIMEOUT:
    290       case BT_PROPERTY_REMOTE_VERSION_INFO:
    291       case BT_PROPERTY_LOCAL_LE_FEATURES:
    292       case BT_PROPERTY_REMOTE_DEVICE_TIMESTAMP:
    293       default:
    294         {
    295           fprintf(stderr, "Unhandled property type:%d len:%d\n", property->type, property->len);
    296           uint8_t *p = (uint8_t *)property->val;
    297           for (int i = 0; i < property->len; ++i, p++) {
    298             fprintf(stderr, " %02x", *p);
    299           }
    300           if (property->len != 0)
    301             fprintf(stderr, "\n");
    302         }
    303     }
    304     property++;
    305   }
    306 }
    307