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 25static bt_state_t state; 26static int property_count = 0; 27static bt_property_t *properties = NULL; 28static bt_discovery_state_t discovery_state; 29static bt_acl_state_t acl_state; 30static bt_bond_state_t bond_state; 31 32static void parse_properties(int num_properties, bt_property_t *property); 33 34// Returns the current adapter state. 35bt_state_t adapter_get_state() { 36 return state; 37} 38 39// Returns the number of adapter properties. 40int adapter_get_property_count() { 41 return property_count; 42} 43 44// Returns the specified property. 45bt_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. 56bt_discovery_state_t adapter_get_discovery_state() { 57 return discovery_state; 58} 59 60// Returns the device acl state. 61bt_acl_state_t adapter_get_acl_state() { 62 return acl_state; 63} 64 65// Returns the device bond state. 66bt_bond_state_t adapter_get_bond_state() { 67 return bond_state; 68} 69 70// callback 71void 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 77void 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 88void adapter_state_changed(bt_state_t new_state) { 89 state = new_state; 90 CALLBACK_RET(); 91} 92 93// callback 94void 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 122void 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 130void 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 151void 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 165void 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 203void thread_evt(bt_cb_thread_evt evt) { 204 CALLBACK_RET(); 205} 206 207static 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