1 // 2 // Copyright 2015 Google, Inc. 3 // 4 // Licensed under the Apache License, Version 2.0 (the "License"); 5 // you may not use this file except in compliance with the License. 6 // You may obtain a copy of the License at: 7 // 8 // http://www.apache.org/licenses/LICENSE-2.0 9 // 10 // Unless required by applicable law or agreed to in writing, software 11 // distributed under the License is distributed on an "AS IS" BASIS, 12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 // See the License for the specific language governing permissions and 14 // limitations under the License. 15 // 16 17 #pragma once 18 19 #include <base/macros.h> 20 #include <hardware/bluetooth.h> 21 22 namespace bluetooth { 23 namespace hal { 24 25 // This class represents the HAL Bluetooth adapter interface, wrapping around 26 // the underlying bt_interface_t structure, its methods, and callbacks. A single 27 // instance of this class exists per application and it allows multiple classes 28 // to interface with the global HAL interface by multiplexing callbacks among 29 // registered clients. 30 // 31 // This is declared as an abstract interface so that a fake implementation can 32 // be injected for testing the upper layer. 33 // 34 // TODO: (expose callback types directly but via redirection) methods for 35 // initialize, clean up, and set for testing. 36 class BluetoothInterface { 37 public: 38 // The standard Bluetooth adapter management callback interface. The HAL 39 // interface doesn't allow registering "user data" that carries context beyond 40 // the callback parameters, forcing implementations to deal with global 41 // variables. The Observer interface is to redirect these events to interested 42 // parties in an object-oriented manner. 43 // 44 // TODO(armansito): We should fix this in the HAL. 45 class Observer { 46 public: 47 virtual ~Observer() = default; 48 49 // All of the events below correspond to callbacks defined in 50 // "bt_callbacks_t" in the HAL API definitions. 51 52 virtual void AdapterStateChangedCallback(bt_state_t state); 53 virtual void AdapterPropertiesCallback(bt_status_t status, 54 int num_properties, 55 bt_property_t* properties); 56 virtual void RemoteDevicePropertiesCallback(bt_status_t status, 57 RawAddress* remote_bd_addr, 58 int num_properties, 59 bt_property_t* properties); 60 virtual void DeviceFoundCallback(int num_properties, 61 bt_property_t* properties); 62 virtual void DiscoveryStateChangedCallback(bt_discovery_state_t state); 63 virtual void PinRequestCallback(RawAddress* remote_bd_addr, 64 bt_bdname_t* bd_name, uint32_t cod, 65 bool min_16_digit); 66 virtual void SSPRequestCallback(RawAddress* remote_bd_addr, 67 bt_bdname_t* bd_name, uint32_t cod, 68 bt_ssp_variant_t pairing_variant, 69 uint32_t pass_key); 70 virtual void BondStateChangedCallback(bt_status_t status, 71 RawAddress* remote_bd_addr, 72 bt_bond_state_t state); 73 virtual void AclStateChangedCallback(bt_status_t status, 74 const RawAddress& remote_bdaddr, 75 bt_acl_state_t state); 76 77 // TODO(armansito): Complete the list of callbacks. 78 }; 79 80 // Initialize and clean up the BluetoothInterface singleton. Returns false if 81 // the underlying HAL interface failed to initialize, and true on success. 82 static bool Initialize(); 83 84 // Shuts down and cleans up the interface. CleanUp must be called on the same 85 // thread that called Initialize. 86 static void CleanUp(); 87 88 // Returns true if the interface was initialized and a global singleton has 89 // been created. 90 static bool IsInitialized(); 91 92 // Initialize for testing. Use this to inject a test version of 93 // BlueoothInterface. To be used from unit tests only. 94 static void InitializeForTesting(BluetoothInterface* test_instance); 95 96 // Returns the BluetoothInterface singleton. If the interface has not been 97 // initialized, returns nullptr. 98 static BluetoothInterface* Get(); 99 100 // Add or remove an observer that is interested in notifications from us. 101 virtual void AddObserver(Observer* observer) = 0; 102 virtual void RemoveObserver(Observer* observer) = 0; 103 104 // The HAL module pointer that represents the standard Bluetooth adapter 105 // management interface. This is implemented in and provided by the shared 106 // Bluetooth library, so this isn't owned by us. 107 // 108 // Upper layers can make bt_interface_t API calls through this structure. 109 // However, DO NOT call the "init" function as this is called and managed by 110 // us. The behavior is undefined if "init" is called directly by upper layers. 111 virtual const bt_interface_t* GetHALInterface() const = 0; 112 113 // Returns the HAL callbacks that have been initialized previously. 114 virtual bt_callbacks_t* GetHALCallbacks() const = 0; 115 116 protected: 117 BluetoothInterface() = default; 118 virtual ~BluetoothInterface() = default; 119 120 private: 121 DISALLOW_COPY_AND_ASSIGN(BluetoothInterface); 122 }; 123 124 } // namespace hal 125 } // namespace bluetooth 126