1 //
2 //  Copyright (C) 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 <mutex>
20 #include <unordered_set>
21 #include <vector>
22 
23 #include <base/macros.h>
24 #include <hardware/bluetooth.h>
25 #include <hardware/bt_gatt.h>
26 
27 namespace bluetooth {
28 namespace hal {
29 
30 // This class represents the standard BT-GATT interface. This class combines
31 // GATT profile server and client role operations with general GAP profile
32 // operations of various roles (central, scanner, peripheral, advertiser),
33 // wrapping around the underlying bt_gatt_interface_t structure. A single
34 // instance of this class exists per application and it allows multiple classes
35 // to interface with the global HAL interface by multiplexing callbacks among
36 // registered clients.
37 //
38 // This is declared as an abstract interface so that a fake implementation can
39 // be injected for testing the upper layer.
40 class BluetoothGattInterface {
41  public:
42   // The standard BT-GATT client callback interface. The HAL interface doesn't
43   // allow registering "user data" that carries context beyond the callback
44   // parameters, forcing implementations to deal with global variables. The
45   // Observer interface is to redirect these events to interested parties in an
46   // object-oriented manner.
47   class ClientObserver {
48    public:
49     virtual ~ClientObserver() = default;
50 
51     // All of the events below correspond to callbacks defined in
52     // "bt_gatt_client_callbacks_t" in the HAL API definitions.
53 
54     virtual void RegisterClientCallback(
55         BluetoothGattInterface* gatt_iface,
56         int status, int client_if,
57         const bt_uuid_t& app_uuid);
58 
59     virtual void ScanResultCallback(
60         BluetoothGattInterface* gatt_iface,
61         const bt_bdaddr_t& bda, int rssi,
62         uint8_t* adv_data);
63 
64     virtual void ConnectCallback(
65         BluetoothGattInterface* gatt_iface,
66         int conn_id,
67         int status,
68         int client_if,
69         const bt_bdaddr_t& bda);
70 
71     virtual void DisconnectCallback(
72         BluetoothGattInterface* gatt_iface,
73         int conn_id,
74         int status,
75         int client_if,
76         const bt_bdaddr_t& bda);
77 
78     virtual void SearchCompleteCallback(
79         BluetoothGattInterface* gatt_iface,
80         int conn_id,
81         int status);
82 
83     virtual void RegisterForNotificationCallback(
84         BluetoothGattInterface* gatt_iface,
85         int conn_id, int status, int registered, uint16_t handle);
86 
87     virtual void NotifyCallback(
88         BluetoothGattInterface* gatt_iface,
89         int conn_id, btgatt_notify_params_t* p_data);
90 
91     virtual void WriteCharacteristicCallback(
92         BluetoothGattInterface* gatt_iface,
93         int conn_id, int status, uint16_t handle);
94 
95     virtual void WriteDescriptorCallback(
96         BluetoothGattInterface* gatt_iface,
97         int conn_id, int status, uint16_t handle);
98 
99     virtual void ListenCallback(
100         BluetoothGattInterface* gatt_iface,
101         int status, int client_if);
102 
103     virtual void MtuChangedCallback(
104         BluetoothGattInterface* gatt_iface,
105         int conn_id, int status, int mtu);
106 
107     virtual void MultiAdvEnableCallback(
108         BluetoothGattInterface* gatt_iface,
109         int client_if, int status);
110 
111     virtual void MultiAdvUpdateCallback(
112         BluetoothGattInterface* gatt_iface,
113         int client_if, int status);
114 
115     virtual void MultiAdvDataCallback(
116         BluetoothGattInterface* gatt_iface,
117         int client_if, int status);
118 
119     virtual void MultiAdvDisableCallback(
120         BluetoothGattInterface* gatt_iface,
121         int client_if, int status);
122 
123     virtual void GetGattDbCallback(
124         BluetoothGattInterface* gatt_iface,
125         int conn_id,
126         btgatt_db_element_t* gatt_db,
127         int size);
128 
129     virtual void ServicesRemovedCallback(
130         BluetoothGattInterface* gatt_iface,
131         int conn_id,
132         uint16_t start_handle,
133         uint16_t end_handle);
134 
135     virtual void ServicesAddedCallback(
136         BluetoothGattInterface* gatt_iface,
137         int conn_id,
138         btgatt_db_element_t *added,
139         int added_count);
140   };
141 
142   // The standard BT-GATT server callback interface.
143   class ServerObserver {
144    public:
145     virtual ~ServerObserver() = default;
146 
147     virtual void RegisterServerCallback(
148         BluetoothGattInterface* gatt_iface,
149         int status, int server_if,
150         const bt_uuid_t& app_uuid);
151 
152     virtual void ConnectionCallback(
153         BluetoothGattInterface* gatt_iface,
154         int conn_id, int server_if,
155         int connected,
156         const bt_bdaddr_t& bda);
157 
158     virtual void ServiceAddedCallback(
159         BluetoothGattInterface* gatt_iface,
160         int status, int server_if,
161         const btgatt_srvc_id_t& srvc_id,
162         int srvc_handle);
163 
164     virtual void CharacteristicAddedCallback(
165         BluetoothGattInterface* gatt_iface,
166         int status, int server_if,
167         const bt_uuid_t& uuid,
168         int srvc_handle,
169         int char_handle);
170 
171     virtual void DescriptorAddedCallback(
172         BluetoothGattInterface* gatt_iface,
173         int status, int server_if,
174         const bt_uuid_t& uuid,
175         int srvc_handle,
176         int desc_handle);
177 
178     virtual void ServiceStartedCallback(
179         BluetoothGattInterface* gatt_iface,
180         int status, int server_if,
181         int srvc_handle);
182 
183     virtual void ServiceStoppedCallback(
184         BluetoothGattInterface* gatt_iface,
185         int status, int server_if,
186         int srvc_handle);
187 
188     virtual void ServiceDeletedCallback(
189         BluetoothGattInterface* gatt_iface,
190         int status, int server_if,
191         int srvc_handle);
192 
193     virtual void RequestReadCallback(
194         BluetoothGattInterface* gatt_iface,
195         int conn_id, int trans_id,
196         const bt_bdaddr_t& bda,
197         int attr_handle, int offset,
198         bool is_long);
199 
200     virtual void RequestWriteCallback(
201         BluetoothGattInterface* gatt_iface,
202         int conn_id, int trans_id,
203         const bt_bdaddr_t& bda,
204         int attr_handle, int offset, int length,
205         bool need_rsp, bool is_prep, uint8_t* value);
206 
207     virtual void RequestExecWriteCallback(
208         BluetoothGattInterface* gatt_iface,
209         int conn_id, int trans_id,
210         const bt_bdaddr_t& bda, int exec_write);
211 
212     virtual void ResponseConfirmationCallback(
213         BluetoothGattInterface* gatt_iface,
214         int status,
215         int handle);
216 
217     virtual void IndicationSentCallback(
218         BluetoothGattInterface* gatt_iface, int conn_id, int status);
219 
220     virtual void MtuChangedCallback(
221         BluetoothGattInterface* gatt_iface, int conn_id, int mtu);
222   };
223 
224   // Initialize and clean up the BluetoothInterface singleton. Returns false if
225   // the underlying HAL interface failed to initialize, and true on success.
226   static bool Initialize();
227 
228   // Shuts down and cleans up the interface. CleanUp must be called on the same
229   // thread that called Initialize.
230   static void CleanUp();
231 
232   // Returns true if the interface was initialized and a global singleton has
233   // been created.
234   static bool IsInitialized();
235 
236   // Initialize for testing. Use this to inject a test version of
237   // BluetoothGattInterface. To be used from unit tests only.
238   static void InitializeForTesting(BluetoothGattInterface* test_instance);
239 
240   // Returns the BluetoothGattInterface singleton. If the interface has
241   // not been initialized, returns nullptr. This method is thread-safe, in that
242   // it will block if the internal lock is being held by another thread. Don't
243   // call this re-entrantly from an observer event as this may cause a deadlock.
244   static BluetoothGattInterface* Get();
245 
246   // Add or remove an observer that is interested in GATT client interface
247   // notifications from us. Thread-safety is guaranteed by ObserverList.
248   virtual void AddClientObserver(ClientObserver* observer) = 0;
249   virtual void RemoveClientObserver(ClientObserver* observer) = 0;
250 
251   // Add or remove an observer that is interested in GATT server interface
252   // notifications from us. Thread-safety is guaranteed by ObserverList.
253   virtual void AddServerObserver(ServerObserver* observer) = 0;
254   virtual void RemoveServerObserver(ServerObserver* observer) = 0;
255 
256   // The HAL module pointer that represents the standard BT-GATT client
257   // interface. This is implemented in and provided by the shared Bluetooth
258   // library, so this isn't owned by us.
259   //
260   // Upper layers can make btgatt_client_interface_t API calls through this
261   // structure.
262   virtual const btgatt_client_interface_t* GetClientHALInterface() const = 0;
263 
264   // The HAL module pointer that represents the standard BT-GATT server
265   // interface. This is implemented in and provided by the shared Bluetooth
266   // library, so this isn't owned by us.
267   //
268   // Upper layers can make btgatt_server_interface_t API calls through this
269   // structure.
270   virtual const btgatt_server_interface_t* GetServerHALInterface() const = 0;
271 
272   // Initiates a regular BLE device scan. This is called internally from each
273   // LowEnergyClient. This function synchronizes the scan requests and maintains
274   // an internal reference count for each scan client that is interested.
275   bt_status_t StartScan(int client_id);
276   bt_status_t StopScan(int client_id);
277 
278  protected:
279   BluetoothGattInterface() = default;
280   virtual ~BluetoothGattInterface() = default;
281 
282  private:
283   // Used to keep a reference count for the different BLE scan clients.
284   std::mutex scan_clients_lock_;
285   std::unordered_set<int> scan_client_set_;
286 
287   DISALLOW_COPY_AND_ASSIGN(BluetoothGattInterface);
288 };
289 
290 }  // namespace hal
291 }  // namespace bluetooth
292