tools/bdtool/adapter.c - platform/system/bt - Git at Google

 /******************************************************************************
  *
  *  Copyright 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/property.h"
 #include "support/callbacks.h"
 #include "types/bluetooth/uuid.h"
 #include "types/raw_address.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 Uuid* 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++;
   }
 }
	/******************************************************************************
	*
	* Copyright 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/property.h"
	#include "support/callbacks.h"
	#include "types/bluetooth/uuid.h"
	#include "types/raw_address.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 Uuid* 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++;
	}
	}