| /****************************************************************************** |
| * |
| * Copyright (C) 2014 Google, Inc. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at: |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| ******************************************************************************/ |
| |
| #include "support/adapter.h" |
| #include "base.h" |
| #include "btcore/include/bdaddr.h" |
| #include "btcore/include/property.h" |
| #include "support/callbacks.h" |
| |
| static bt_state_t state; |
| static int property_count = 0; |
| static bt_property_t* properties = NULL; |
| static bt_discovery_state_t discovery_state; |
| static bt_acl_state_t acl_state; |
| static bt_bond_state_t bond_state; |
| |
| static void parse_properties(int num_properties, bt_property_t* property); |
| |
| // Returns the current adapter state. |
| bt_state_t adapter_get_state() { return state; } |
| |
| // Returns the number of adapter properties. |
| int adapter_get_property_count() { return property_count; } |
| |
| // Returns the specified property. |
| bt_property_t* adapter_get_property(bt_property_type_t type) { |
| for (int i = 0; i < property_count; ++i) { |
| if (properties[i].type == type) { |
| return &properties[i]; |
| } |
| } |
| |
| return NULL; |
| } |
| |
| // Returns the device discovery state. |
| bt_discovery_state_t adapter_get_discovery_state() { return discovery_state; } |
| |
| // Returns the device acl state. |
| bt_acl_state_t adapter_get_acl_state() { return acl_state; } |
| |
| // Returns the device bond state. |
| bt_bond_state_t adapter_get_bond_state() { return bond_state; } |
| |
| // callback |
| void acl_state_changed(bt_status_t status, RawAddress* remote_bd_addr, |
| bt_acl_state_t state) { |
| acl_state = state; |
| CALLBACK_RET(); |
| } |
| |
| // callback |
| void adapter_properties(bt_status_t status, int num_properties, |
| bt_property_t* new_properties) { |
| property_free_array(properties, property_count); |
| properties = property_copy_array(new_properties, num_properties); |
| property_count = num_properties; |
| |
| CALLBACK_RET(); |
| } |
| |
| // callback |
| void adapter_state_changed(bt_state_t new_state) { |
| state = new_state; |
| CALLBACK_RET(); |
| } |
| |
| // callback |
| void bond_state_changed(bt_status_t status, RawAddress* bdaddr, |
| bt_bond_state_t state) { |
| char buf[18]; |
| bond_state = state; |
| |
| const char* state_name = "Bond state unknown"; |
| switch (bond_state) { |
| case BT_BOND_STATE_NONE: |
| state_name = "Bond state none"; |
| break; |
| |
| case BT_BOND_STATE_BONDING: |
| state_name = "Bond state bonding"; |
| break; |
| |
| case BT_BOND_STATE_BONDED: |
| state_name = "Bond state bonded"; |
| break; |
| |
| // default none |
| } |
| fprintf(stdout, "Bond state changed callback addr:%s state:%s\n", |
| bdaddr_to_string(bdaddr, buf, sizeof(buf)), state_name); |
| |
| CALLBACK_RET(); |
| } |
| |
| // callback |
| void device_found(int num_properties, bt_property_t* property) { |
| fprintf(stdout, "Device found num_properties:%d\n", num_properties); |
| parse_properties(num_properties, property); |
| |
| CALLBACK_RET(); |
| } |
| |
| // callback |
| void discovery_state_changed(bt_discovery_state_t state) { |
| const char* state_name = "Unknown"; |
| discovery_state = state; |
| |
| switch (discovery_state) { |
| case BT_DISCOVERY_STOPPED: |
| state_name = "Discovery stopped"; |
| break; |
| |
| case BT_DISCOVERY_STARTED: |
| state_name = "Discovery started"; |
| break; |
| |
| // default omitted |
| } |
| fprintf(stdout, "Discover state %s\n", state_name); |
| |
| CALLBACK_RET(); |
| } |
| |
| // callback |
| void remote_device_properties(bt_status_t status, RawAddress* bdaddr, |
| int num_properties, bt_property_t* properties) { |
| char buf[18]; |
| fprintf(stdout, "Device found bdaddr:%s num_properties:%d\n", |
| bdaddr_to_string(bdaddr, buf, sizeof(buf)), num_properties); |
| |
| parse_properties(num_properties, properties); |
| |
| CALLBACK_RET(); |
| } |
| |
| // callback |
| void ssp_request(RawAddress* remote_bd_addr, bt_bdname_t* bd_name, uint32_t cod, |
| bt_ssp_variant_t pairing_variant, uint32_t pass_key) { |
| char* pairing_variant_name = "Unknown"; |
| |
| switch (pairing_variant) { |
| case BT_SSP_VARIANT_PASSKEY_CONFIRMATION: |
| pairing_variant_name = "Passkey confirmation"; |
| break; |
| case BT_SSP_VARIANT_PASSKEY_ENTRY: |
| pairing_variant_name = "Passkey entry"; |
| break; |
| |
| case BT_SSP_VARIANT_CONSENT: |
| pairing_variant_name = "Passkey consent"; |
| break; |
| |
| case BT_SSP_VARIANT_PASSKEY_NOTIFICATION: |
| pairing_variant_name = "Passkey notification"; |
| break; |
| } |
| |
| fprintf(stdout, |
| "Got ssp request device_class:%u passkey:%x pairing_variant:%s\n", |
| cod, pass_key, pairing_variant_name); |
| char buf[18]; |
| fprintf(stdout, "Device found:%s %s\n", |
| bdaddr_to_string(remote_bd_addr, buf, sizeof(buf)), bd_name->name); |
| |
| fprintf(stdout, "auto-accepting bond\n"); |
| bool accept = true; |
| int rc = bt_interface->ssp_reply(remote_bd_addr, pairing_variant, |
| (uint8_t)accept, pass_key); |
| CALLBACK_RET(); |
| } |
| |
| // callback |
| void thread_evt(bt_cb_thread_evt evt) { CALLBACK_RET(); } |
| |
| static void parse_properties(int num_properties, bt_property_t* property) { |
| while (num_properties-- > 0) { |
| switch (property->type) { |
| case BT_PROPERTY_BDNAME: { |
| const bt_bdname_t* name = property_as_name(property); |
| if (name) fprintf(stdout, " name:%s\n", name->name); |
| } break; |
| |
| case BT_PROPERTY_BDADDR: { |
| char buf[18]; |
| const RawAddress* addr = property_as_addr(property); |
| if (addr) |
| fprintf(stdout, " addr:%s\n", |
| bdaddr_to_string(addr, buf, sizeof(buf))); |
| } break; |
| |
| case BT_PROPERTY_UUIDS: { |
| size_t num_uuid; |
| const bt_uuid_t* uuid = property_as_uuids(property, &num_uuid); |
| if (uuid) { |
| for (size_t i = 0; i < num_uuid; i++) { |
| fprintf(stdout, " uuid:%zd: ", i); |
| for (size_t j = 0; j < sizeof(uuid); j++) { |
| fprintf(stdout, "%02x", uuid->uu[j]); |
| } |
| fprintf(stdout, "\n"); |
| } |
| } |
| } break; |
| |
| case BT_PROPERTY_TYPE_OF_DEVICE: { |
| bt_device_type_t device_type = property_as_device_type(property); |
| if (device_type) { |
| const struct { |
| const char* device_type; |
| } device_type_lookup[] = { |
| {"Unknown"}, |
| {"Classic Only"}, |
| {"BLE Only"}, |
| {"Both Classic and BLE"}, |
| }; |
| int idx = (int)device_type; |
| if (idx > BT_DEVICE_DEVTYPE_DUAL) idx = 0; |
| fprintf(stdout, " device_type:%s\n", |
| device_type_lookup[idx].device_type); |
| } |
| } break; |
| |
| case BT_PROPERTY_CLASS_OF_DEVICE: { |
| const bt_device_class_t* dc = property_as_device_class(property); |
| int dc_int = device_class_to_int(dc); |
| fprintf(stdout, " device_class:0x%x\n", dc_int); |
| } break; |
| |
| case BT_PROPERTY_REMOTE_RSSI: { |
| int8_t rssi = property_as_rssi(property); |
| fprintf(stdout, " rssi:%d\n", rssi); |
| } break; |
| |
| case BT_PROPERTY_REMOTE_FRIENDLY_NAME: { |
| const bt_bdname_t* name = property_as_name(property); |
| if (name) fprintf(stdout, " remote_name:%s\n", name->name); |
| } break; |
| |
| case BT_PROPERTY_SERVICE_RECORD: |
| case BT_PROPERTY_ADAPTER_SCAN_MODE: |
| case BT_PROPERTY_ADAPTER_BONDED_DEVICES: |
| case BT_PROPERTY_ADAPTER_DISCOVERY_TIMEOUT: |
| case BT_PROPERTY_REMOTE_VERSION_INFO: |
| case BT_PROPERTY_LOCAL_LE_FEATURES: |
| case BT_PROPERTY_REMOTE_DEVICE_TIMESTAMP: |
| default: { |
| fprintf(stderr, "Unhandled property type:%d len:%d\n", property->type, |
| property->len); |
| uint8_t* p = (uint8_t*)property->val; |
| for (int i = 0; i < property->len; ++i, p++) { |
| fprintf(stderr, " %02x", *p); |
| } |
| if (property->len != 0) fprintf(stderr, "\n"); |
| } |
| } |
| property++; |
| } |
| } |