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#include "service/hal/bluetooth_gatt_interface.h"
18
19#include <mutex>
20#include <shared_mutex>
21
22#include <base/logging.h>
23#include <base/observer_list.h>
24
25#include "service/hal/bluetooth_interface.h"
26#include "service/logging_helpers.h"
27
28using std::lock_guard;
29using std::unique_lock;
30using std::shared_lock;
31using std::mutex;
32#if defined(OS_GENERIC) && defined(_LIBCPP_VERSION) && (_LIBCPP_VERSION < 3500)
33using shared_mutex_impl = std::shared_mutex;
34#else
35using shared_mutex_impl = std::shared_timed_mutex;
36#endif
37
38namespace bluetooth {
39namespace hal {
40
41namespace {
42
43// The global BluetoothGattInterface instance.
44BluetoothGattInterface* g_interface = nullptr;
45
46// Mutex used by callbacks to access |g_interface|. If we initialize or clean it
47// use unique_lock. If only accessing |g_interface| use shared lock.
48// TODO(jpawlowski): this should be just shared_mutex, as we currently don't use
49// timed methods. Change to shared_mutex when we upgrade to C++14
50shared_mutex_impl g_instance_lock;
51
52// Helper for obtaining the observer lists. This is forward declared here
53// and defined below since it depends on BluetoothInterfaceImpl.
54base::ObserverList<BluetoothGattInterface::ScannerObserver>*
55GetScannerObservers();
56base::ObserverList<BluetoothGattInterface::ClientObserver>*
57GetClientObservers();
58base::ObserverList<BluetoothGattInterface::ServerObserver>*
59GetServerObservers();
60
61#define FOR_EACH_SCANNER_OBSERVER(func)                      \
62  FOR_EACH_OBSERVER(BluetoothGattInterface::ScannerObserver, \
63                    *GetScannerObservers(), func)
64
65#define FOR_EACH_CLIENT_OBSERVER(func)                      \
66  FOR_EACH_OBSERVER(BluetoothGattInterface::ClientObserver, \
67                    *GetClientObservers(), func)
68
69#define FOR_EACH_SERVER_OBSERVER(func)                      \
70  FOR_EACH_OBSERVER(BluetoothGattInterface::ServerObserver, \
71                    *GetServerObservers(), func)
72
73#define VERIFY_INTERFACE_OR_RETURN()                                   \
74  do {                                                                 \
75    if (!g_interface) {                                                \
76      LOG(WARNING) << "Callback received while |g_interface| is NULL"; \
77      return;                                                          \
78    }                                                                  \
79  } while (0)
80
81void RegisterClientCallback(int status, int client_if,
82                            const bt_uuid_t& app_uuid) {
83  shared_lock<shared_mutex_impl> lock(g_instance_lock);
84  VLOG(2) << __func__ << " - status: " << status << " client_if: " << client_if;
85  VERIFY_INTERFACE_OR_RETURN();
86
87  FOR_EACH_CLIENT_OBSERVER(
88      RegisterClientCallback(g_interface, status, client_if, app_uuid));
89}
90
91void ScanResultCallback(
92    uint16_t ble_evt_type, uint8_t addr_type, RawAddress* bda,
93    uint8_t ble_primary_phy, uint8_t ble_secondary_phy,
94    uint8_t ble_advertising_sid, int8_t ble_tx_power, int8_t rssi,
95    uint16_t ble_periodic_adv_int,
96    std::vector<uint8_t> adv_data) {  // NOLINT(pass-by-value)
97  shared_lock<shared_mutex_impl> lock(g_instance_lock);
98  VERIFY_INTERFACE_OR_RETURN();
99  CHECK(bda);
100
101  VLOG(2) << __func__ << " - BD_ADDR: " << BtAddrString(bda)
102          << " RSSI: " << rssi;
103  FOR_EACH_SCANNER_OBSERVER(
104      ScanResultCallback(g_interface, *bda, rssi, adv_data));
105}
106
107void ConnectCallback(int conn_id, int status, int client_if,
108                     const RawAddress& bda) {
109  shared_lock<shared_mutex_impl> lock(g_instance_lock);
110  VERIFY_INTERFACE_OR_RETURN();
111
112  VLOG(2) << __func__ << " - status: " << status << " client_if: " << client_if
113          << " - BD_ADDR: " << BtAddrString(&bda) << " - conn_id: " << conn_id;
114
115  FOR_EACH_CLIENT_OBSERVER(
116      ConnectCallback(g_interface, conn_id, status, client_if, bda));
117}
118
119void DisconnectCallback(int conn_id, int status, int client_if,
120                        const RawAddress& bda) {
121  shared_lock<shared_mutex_impl> lock(g_instance_lock);
122  VERIFY_INTERFACE_OR_RETURN();
123
124  VLOG(2) << __func__ << " - conn_id: " << conn_id << " - status: " << status
125          << " client_if: " << client_if
126          << " - BD_ADDR: " << BtAddrString(&bda);
127  FOR_EACH_CLIENT_OBSERVER(
128      DisconnectCallback(g_interface, conn_id, status, client_if, bda));
129}
130
131void SearchCompleteCallback(int conn_id, int status) {
132  shared_lock<shared_mutex_impl> lock(g_instance_lock);
133  VERIFY_INTERFACE_OR_RETURN();
134
135  VLOG(2) << __func__ << " - conn_id: " << conn_id << " - status: " << status;
136  FOR_EACH_CLIENT_OBSERVER(
137      SearchCompleteCallback(g_interface, conn_id, status));
138}
139
140void RegisterForNotificationCallback(int conn_id, int registered, int status,
141                                     uint16_t handle) {
142  shared_lock<shared_mutex_impl> lock(g_instance_lock);
143  VERIFY_INTERFACE_OR_RETURN();
144
145  LOG(INFO) << __func__ << " - conn_id: " << conn_id << " - status: " << status
146            << " - registered: " << registered << " - handle: " << handle;
147  FOR_EACH_CLIENT_OBSERVER(RegisterForNotificationCallback(
148      g_interface, conn_id, status, registered, handle));
149}
150
151void NotifyCallback(int conn_id, const btgatt_notify_params_t& p_data) {
152  shared_lock<shared_mutex_impl> lock(g_instance_lock);
153  VERIFY_INTERFACE_OR_RETURN();
154
155  VLOG(2) << __func__ << " - conn_id: " << conn_id
156          << " - address: " << BtAddrString(&p_data.bda)
157          << " - handle: " << p_data.handle << " - len: " << p_data.len
158          << " - is_notify: " << p_data.is_notify;
159
160  FOR_EACH_CLIENT_OBSERVER(NotifyCallback(g_interface, conn_id, p_data));
161}
162
163void WriteCharacteristicCallback(int conn_id, int status, uint16_t handle) {
164  shared_lock<shared_mutex_impl> lock(g_instance_lock);
165  VERIFY_INTERFACE_OR_RETURN();
166
167  VLOG(2) << __func__ << " - conn_id: " << conn_id << " - status: " << status;
168
169  FOR_EACH_CLIENT_OBSERVER(
170      WriteCharacteristicCallback(g_interface, conn_id, status, handle));
171}
172
173void WriteDescriptorCallback(int conn_id, int status, uint16_t handle) {
174  shared_lock<shared_mutex_impl> lock(g_instance_lock);
175  VERIFY_INTERFACE_OR_RETURN();
176
177  VLOG(2) << __func__ << " - conn_id: " << conn_id << " - status: " << status;
178
179  FOR_EACH_CLIENT_OBSERVER(
180      WriteDescriptorCallback(g_interface, conn_id, status, handle));
181}
182
183void MtuChangedCallback(int conn_id, int status, int mtu) {
184  shared_lock<shared_mutex_impl> lock(g_instance_lock);
185  VERIFY_INTERFACE_OR_RETURN();
186
187  VLOG(2) << __func__ << " - conn_id: " << conn_id << " status: " << status
188          << " mtu: " << mtu;
189
190  FOR_EACH_CLIENT_OBSERVER(
191      MtuChangedCallback(g_interface, conn_id, status, mtu));
192}
193
194void GetGattDbCallback(int conn_id, const btgatt_db_element_t* db, int size) {
195  shared_lock<shared_mutex_impl> lock(g_instance_lock);
196  VLOG(2) << __func__ << " - conn_id: " << conn_id << " size: " << size;
197  VERIFY_INTERFACE_OR_RETURN();
198
199  FOR_EACH_CLIENT_OBSERVER(GetGattDbCallback(g_interface, conn_id, db, size));
200}
201
202void ServicesRemovedCallback(int conn_id, uint16_t start_handle,
203                             uint16_t end_handle) {
204  shared_lock<shared_mutex_impl> lock(g_instance_lock);
205  VLOG(2) << __func__ << " - conn_id: " << conn_id
206          << " start_handle: " << start_handle << " end_handle: " << end_handle;
207  VERIFY_INTERFACE_OR_RETURN();
208
209  FOR_EACH_CLIENT_OBSERVER(
210      ServicesRemovedCallback(g_interface, conn_id, start_handle, end_handle));
211}
212
213void ServicesAddedCallback(int conn_id, const btgatt_db_element_t& added,
214                           int added_count) {
215  shared_lock<shared_mutex_impl> lock(g_instance_lock);
216  VLOG(2) << __func__ << " - conn_id: " << conn_id
217          << " added_count: " << added_count;
218  VERIFY_INTERFACE_OR_RETURN();
219
220  FOR_EACH_CLIENT_OBSERVER(
221      ServicesAddedCallback(g_interface, conn_id, added, added_count));
222}
223
224void RegisterServerCallback(int status, int server_if,
225                            const bt_uuid_t& app_uuid) {
226  shared_lock<shared_mutex_impl> lock(g_instance_lock);
227  VLOG(2) << __func__ << " - status: " << status << " server_if: " << server_if;
228  VERIFY_INTERFACE_OR_RETURN();
229
230  FOR_EACH_SERVER_OBSERVER(
231      RegisterServerCallback(g_interface, status, server_if, app_uuid));
232}
233
234void ConnectionCallback(int conn_id, int server_if, int connected,
235                        const RawAddress& bda) {
236  shared_lock<shared_mutex_impl> lock(g_instance_lock);
237  VLOG(2) << __func__ << " - conn_id: " << conn_id
238          << " server_if: " << server_if << " connected: " << connected;
239  VERIFY_INTERFACE_OR_RETURN();
240
241  FOR_EACH_SERVER_OBSERVER(
242      ConnectionCallback(g_interface, conn_id, server_if, connected, bda));
243}
244
245void ServiceAddedCallback(
246    int status, int server_if,
247    std::vector<btgatt_db_element_t> service) {  // NOLINT(pass-by-value)
248  shared_lock<shared_mutex_impl> lock(g_instance_lock);
249  VLOG(2) << __func__ << " - status: " << status << " server_if: " << server_if
250          << " count: " << service.size();
251  VERIFY_INTERFACE_OR_RETURN();
252  CHECK(service.size());
253
254  FOR_EACH_SERVER_OBSERVER(
255      ServiceAddedCallback(g_interface, status, server_if, service));
256}
257
258void ServiceStoppedCallback(int status, int server_if, int srvc_handle) {
259  shared_lock<shared_mutex_impl> lock(g_instance_lock);
260  VLOG(2) << __func__ << " - status: " << status << " server_if: " << server_if
261          << " handle: " << srvc_handle;
262  VERIFY_INTERFACE_OR_RETURN();
263
264  FOR_EACH_SERVER_OBSERVER(
265      ServiceStoppedCallback(g_interface, status, server_if, srvc_handle));
266}
267
268void ServiceDeletedCallback(int status, int server_if, int srvc_handle) {
269  shared_lock<shared_mutex_impl> lock(g_instance_lock);
270  VLOG(2) << __func__ << " - status: " << status << " server_if: " << server_if
271          << " handle: " << srvc_handle;
272  VERIFY_INTERFACE_OR_RETURN();
273
274  FOR_EACH_SERVER_OBSERVER(
275      ServiceDeletedCallback(g_interface, status, server_if, srvc_handle));
276}
277
278void RequestReadCharacteristicCallback(int conn_id, int trans_id,
279                                       const RawAddress& bda, int attr_handle,
280                                       int offset, bool is_long) {
281  shared_lock<shared_mutex_impl> lock(g_instance_lock);
282  VLOG(2) << __func__ << " - conn_id: " << conn_id << " trans_id: " << trans_id
283          << " attr_handle: " << attr_handle << " offset: " << offset
284          << " is_long: " << is_long;
285  VERIFY_INTERFACE_OR_RETURN();
286
287  FOR_EACH_SERVER_OBSERVER(RequestReadCharacteristicCallback(
288      g_interface, conn_id, trans_id, bda, attr_handle, offset, is_long));
289}
290
291void RequestReadDescriptorCallback(int conn_id, int trans_id,
292                                   const RawAddress& bda, int attr_handle,
293                                   int offset, bool is_long) {
294  shared_lock<shared_mutex_impl> lock(g_instance_lock);
295  VLOG(2) << __func__ << " - conn_id: " << conn_id << " trans_id: " << trans_id
296          << " attr_handle: " << attr_handle << " offset: " << offset
297          << " is_long: " << is_long;
298  VERIFY_INTERFACE_OR_RETURN();
299
300  FOR_EACH_SERVER_OBSERVER(RequestReadDescriptorCallback(
301      g_interface, conn_id, trans_id, bda, attr_handle, offset, is_long));
302}
303
304void RequestWriteCharacteristicCallback(int conn_id, int trans_id,
305                                        const RawAddress& bda, int attr_handle,
306                                        int offset, bool need_rsp, bool is_prep,
307                                        std::vector<uint8_t> value) {
308  shared_lock<shared_mutex_impl> lock(g_instance_lock);
309  VLOG(2) << __func__ << " - conn_id: " << conn_id << " trans_id: " << trans_id
310          << " attr_handle: " << attr_handle << " offset: " << offset
311          << " length: " << value.size() << " need_rsp: " << need_rsp
312          << " is_prep: " << is_prep;
313  VERIFY_INTERFACE_OR_RETURN();
314
315  FOR_EACH_SERVER_OBSERVER(RequestWriteCharacteristicCallback(
316      g_interface, conn_id, trans_id, bda, attr_handle, offset, need_rsp,
317      is_prep, value));
318}
319
320void RequestWriteDescriptorCallback(
321    int conn_id, int trans_id, const RawAddress& bda, int attr_handle,
322    int offset, bool need_rsp, bool is_prep,
323    std::vector<uint8_t> value) {  // NOLINT(pass-by-value)
324  shared_lock<shared_mutex_impl> lock(g_instance_lock);
325  VLOG(2) << __func__ << " - conn_id: " << conn_id << " trans_id: " << trans_id
326          << " attr_handle: " << attr_handle << " offset: " << offset
327          << " length: " << value.size() << " need_rsp: " << need_rsp
328          << " is_prep: " << is_prep;
329  VERIFY_INTERFACE_OR_RETURN();
330
331  FOR_EACH_SERVER_OBSERVER(RequestWriteDescriptorCallback(
332      g_interface, conn_id, trans_id, bda, attr_handle, offset, need_rsp,
333      is_prep, value));
334}
335
336void RequestExecWriteCallback(int conn_id, int trans_id, const RawAddress& bda,
337                              int exec_write) {
338  shared_lock<shared_mutex_impl> lock(g_instance_lock);
339  VLOG(2) << __func__ << " - conn_id: " << conn_id << " trans_id: " << trans_id
340          << " exec_write: " << exec_write;
341  VERIFY_INTERFACE_OR_RETURN();
342
343  FOR_EACH_SERVER_OBSERVER(RequestExecWriteCallback(g_interface, conn_id,
344                                                    trans_id, bda, exec_write));
345}
346
347void ResponseConfirmationCallback(int status, int handle) {
348  shared_lock<shared_mutex_impl> lock(g_instance_lock);
349  VLOG(2) << __func__ << " - status: " << status << " handle: " << handle;
350  VERIFY_INTERFACE_OR_RETURN();
351
352  FOR_EACH_SERVER_OBSERVER(
353      ResponseConfirmationCallback(g_interface, status, handle));
354}
355
356void IndicationSentCallback(int conn_id, int status) {
357  shared_lock<shared_mutex_impl> lock(g_instance_lock);
358  VLOG(2) << __func__ << " - conn_id: " << conn_id << " status: " << status;
359  VERIFY_INTERFACE_OR_RETURN();
360
361  FOR_EACH_SERVER_OBSERVER(
362      IndicationSentCallback(g_interface, conn_id, status));
363}
364
365void MtuChangedCallback(int conn_id, int mtu) {
366  shared_lock<shared_mutex_impl> lock(g_instance_lock);
367  VLOG(2) << __func__ << " - conn_id: " << conn_id << " mtu: " << mtu;
368  VERIFY_INTERFACE_OR_RETURN();
369
370  FOR_EACH_SERVER_OBSERVER(MtuChangedCallback(g_interface, conn_id, mtu));
371}
372
373// The HAL Bluetooth GATT client interface callbacks. These signal a mixture of
374// GATT client-role and GAP events.
375
376const btgatt_scanner_callbacks_t gatt_scanner_callbacks = {
377    ScanResultCallback,
378    nullptr,  // batchscan_reports_cb
379    nullptr,  // batchscan_threshold_cb
380    nullptr,  // track_adv_event_cb
381};
382
383const btgatt_client_callbacks_t gatt_client_callbacks = {
384    RegisterClientCallback,
385    ConnectCallback,
386    DisconnectCallback,
387    SearchCompleteCallback,
388    RegisterForNotificationCallback,
389    NotifyCallback,
390    nullptr,  // read_characteristic_cb
391    WriteCharacteristicCallback,
392    nullptr,  // read_descriptor_cb
393    WriteDescriptorCallback,
394    nullptr,  // execute_write_cb
395    nullptr,  // read_remote_rssi_cb
396    MtuChangedCallback,
397    nullptr,  // congestion_cb
398    GetGattDbCallback,
399    ServicesRemovedCallback,
400    ServicesAddedCallback,
401    nullptr,
402    nullptr,
403};
404
405const btgatt_server_callbacks_t gatt_server_callbacks = {
406    RegisterServerCallback,
407    ConnectionCallback,
408    ServiceAddedCallback,
409    ServiceStoppedCallback,
410    ServiceDeletedCallback,
411    RequestReadCharacteristicCallback,
412    RequestReadDescriptorCallback,
413    RequestWriteCharacteristicCallback,
414    RequestWriteDescriptorCallback,
415    RequestExecWriteCallback,
416    ResponseConfirmationCallback,
417    IndicationSentCallback,
418    nullptr,  // congestion_cb
419    MtuChangedCallback,
420    nullptr,
421    nullptr,
422};
423
424const btgatt_callbacks_t gatt_callbacks = {
425    sizeof(btgatt_callbacks_t), &gatt_client_callbacks, &gatt_server_callbacks,
426    &gatt_scanner_callbacks,
427};
428
429}  // namespace
430
431// BluetoothGattInterface implementation for production.
432class BluetoothGattInterfaceImpl : public BluetoothGattInterface {
433 public:
434  BluetoothGattInterfaceImpl() : hal_iface_(nullptr) {}
435
436  ~BluetoothGattInterfaceImpl() override {
437    if (hal_iface_) hal_iface_->cleanup();
438  }
439
440  void AddScannerObserver(ScannerObserver* observer) override {
441    scanner_observers_.AddObserver(observer);
442  }
443
444  void RemoveScannerObserver(ScannerObserver* observer) override {
445    scanner_observers_.RemoveObserver(observer);
446  }
447
448  void AddClientObserver(ClientObserver* observer) override {
449    client_observers_.AddObserver(observer);
450  }
451
452  void RemoveClientObserver(ClientObserver* observer) override {
453    client_observers_.RemoveObserver(observer);
454  }
455
456  void AddServerObserver(ServerObserver* observer) override {
457    server_observers_.AddObserver(observer);
458  }
459
460  void RemoveServerObserver(ServerObserver* observer) override {
461    server_observers_.RemoveObserver(observer);
462  }
463
464  BleAdvertiserInterface* GetAdvertiserHALInterface() const override {
465    return hal_iface_->advertiser;
466  }
467
468  BleScannerInterface* GetScannerHALInterface() const override {
469    return hal_iface_->scanner;
470  }
471
472  const btgatt_client_interface_t* GetClientHALInterface() const override {
473    return hal_iface_->client;
474  }
475
476  const btgatt_server_interface_t* GetServerHALInterface() const override {
477    return hal_iface_->server;
478  }
479
480  // Initialize the interface.
481  bool Initialize() {
482    const bt_interface_t* bt_iface =
483        BluetoothInterface::Get()->GetHALInterface();
484    CHECK(bt_iface);
485
486    const btgatt_interface_t* gatt_iface =
487        reinterpret_cast<const btgatt_interface_t*>(
488            bt_iface->get_profile_interface(BT_PROFILE_GATT_ID));
489    if (!gatt_iface) {
490      LOG(ERROR) << "Failed to obtain HAL GATT interface handle";
491      return false;
492    }
493
494    bt_status_t status = gatt_iface->init(&gatt_callbacks);
495    if (status != BT_STATUS_SUCCESS) {
496      LOG(ERROR) << "Failed to initialize HAL GATT interface";
497      return false;
498    }
499
500    hal_iface_ = gatt_iface;
501
502    return true;
503  }
504
505  base::ObserverList<ScannerObserver>* scanner_observers() {
506    return &scanner_observers_;
507  }
508
509  base::ObserverList<ClientObserver>* client_observers() {
510    return &client_observers_;
511  }
512
513  base::ObserverList<ServerObserver>* server_observers() {
514    return &server_observers_;
515  }
516
517 private:
518  // List of observers that are interested in notifications from us.
519  // We're not using a base::ObserverListThreadSafe, which it posts observer
520  // events automatically on the origin threads, as we want to avoid that
521  // overhead and simply forward the events to the upper layer.
522  base::ObserverList<ScannerObserver> scanner_observers_;
523  base::ObserverList<ClientObserver> client_observers_;
524  base::ObserverList<ServerObserver> server_observers_;
525
526  // The HAL handle obtained from the shared library. We hold a weak reference
527  // to this since the actual data resides in the shared Bluetooth library.
528  const btgatt_interface_t* hal_iface_;
529
530  DISALLOW_COPY_AND_ASSIGN(BluetoothGattInterfaceImpl);
531};
532
533namespace {
534
535base::ObserverList<BluetoothGattInterface::ScannerObserver>*
536GetScannerObservers() {
537  CHECK(g_interface);
538  return static_cast<BluetoothGattInterfaceImpl*>(g_interface)
539      ->scanner_observers();
540}
541
542base::ObserverList<BluetoothGattInterface::ClientObserver>*
543GetClientObservers() {
544  CHECK(g_interface);
545  return static_cast<BluetoothGattInterfaceImpl*>(g_interface)
546      ->client_observers();
547}
548
549base::ObserverList<BluetoothGattInterface::ServerObserver>*
550GetServerObservers() {
551  CHECK(g_interface);
552  return static_cast<BluetoothGattInterfaceImpl*>(g_interface)
553      ->server_observers();
554}
555
556}  // namespace
557
558// Default observer implementations. These are provided so that the methods
559// themselves are optional.
560
561void BluetoothGattInterface::ScannerObserver::ScanResultCallback(
562    BluetoothGattInterface* /* gatt_iface */, const RawAddress& /* bda */,
563    int /* rssi */,
564    std::vector<uint8_t> /* adv_data */) {  // NOLINT(pass-by-value)
565  // Do Nothing.
566}
567
568void BluetoothGattInterface::ClientObserver::RegisterClientCallback(
569    BluetoothGattInterface* /* gatt_iface */, int /* status */,
570    int /* client_if */, const bt_uuid_t& /* app_uuid */) {
571  // Do nothing.
572}
573
574void BluetoothGattInterface::ClientObserver::ConnectCallback(
575    BluetoothGattInterface* /* gatt_iface */, int /* conn_id */,
576    int /* status */, int /* client_if */, const RawAddress& /* bda */) {
577  // Do nothing
578}
579
580void BluetoothGattInterface::ClientObserver::DisconnectCallback(
581    BluetoothGattInterface* /* gatt_iface */, int /* conn_id */,
582    int /* status */, int /* client_if */, const RawAddress& /* bda */) {
583  // Do nothing
584}
585
586void BluetoothGattInterface::ClientObserver::SearchCompleteCallback(
587    BluetoothGattInterface* /* gatt_iface */, int /* conn_id */,
588    int /* status */) {
589  // Do nothing
590}
591
592void BluetoothGattInterface::ClientObserver::RegisterForNotificationCallback(
593    BluetoothGattInterface* /* gatt_iface */, int /* conn_id */,
594    int /* status */, int /* registered */, uint16_t /* handle */) {
595  // Do nothing
596}
597
598void BluetoothGattInterface::ClientObserver::NotifyCallback(
599    BluetoothGattInterface* /* gatt_iface */, int /* conn_id */,
600    const btgatt_notify_params_t& /* p_data */) {
601  // Do nothing
602}
603
604void BluetoothGattInterface::ClientObserver::WriteCharacteristicCallback(
605    BluetoothGattInterface* /* gatt_iface */, int /* conn_id */,
606    int /* status */, uint16_t /* handle */) {
607  // Do nothing
608}
609
610void BluetoothGattInterface::ClientObserver::WriteDescriptorCallback(
611    BluetoothGattInterface* /* gatt_iface */, int /* conn_id */,
612    int /* status */, uint16_t /* handle */) {
613  // Do nothing
614}
615
616void BluetoothGattInterface::ClientObserver::MtuChangedCallback(
617    BluetoothGattInterface* /* gatt_iface */, int /* conn_id */,
618    int /* statis*/, int /* mtu */) {
619  // Do nothing.
620}
621
622void BluetoothGattInterface::ClientObserver::GetGattDbCallback(
623    BluetoothGattInterface* /* gatt_iface */, int /* conn_id */,
624    const btgatt_db_element_t* /* gatt_db */, int /* size */) {
625  // Do nothing.
626}
627
628void BluetoothGattInterface::ClientObserver::ServicesRemovedCallback(
629    BluetoothGattInterface* /* gatt_iface */, int /* conn_id */,
630    uint16_t /* start_handle */, uint16_t /* end_handle */) {
631  // Do nothing.
632}
633
634void BluetoothGattInterface::ClientObserver::ServicesAddedCallback(
635    BluetoothGattInterface* /* gatt_iface */, int /* conn_id */,
636    const btgatt_db_element_t& /* added */, int /* added_count */) {
637  // Do nothing.
638}
639
640void BluetoothGattInterface::ServerObserver::RegisterServerCallback(
641    BluetoothGattInterface* /* gatt_iface */, int /* status */,
642    int /* server_if */, const bt_uuid_t& /* app_uuid */) {
643  // Do nothing.
644}
645
646void BluetoothGattInterface::ServerObserver::ConnectionCallback(
647    BluetoothGattInterface* /* gatt_iface */, int /* conn_id */,
648    int /* server_if */, int /* connected */, const RawAddress& /* bda */) {
649  // Do nothing.
650}
651
652void BluetoothGattInterface::ServerObserver::ServiceAddedCallback(
653    BluetoothGattInterface* /* gatt_iface */, int /* status */,
654    int /* server_if */,
655    std::vector<btgatt_db_element_t> /* service */) {  // NOLINT(pass-by-value)
656  // Do nothing.
657}
658
659void BluetoothGattInterface::ServerObserver::ServiceStoppedCallback(
660    BluetoothGattInterface* /* gatt_iface */, int /* status */,
661    int /* server_if */, int /* srvc_handle */) {
662  // Do nothing.
663}
664
665void BluetoothGattInterface::ServerObserver::ServiceDeletedCallback(
666    BluetoothGattInterface* /* gatt_iface */, int /* status */,
667    int /* server_if */, int /* srvc_handle */) {
668  // Do nothing.
669}
670
671void BluetoothGattInterface::ServerObserver::RequestReadCharacteristicCallback(
672    BluetoothGattInterface* /* gatt_iface */, int /* conn_id */,
673    int /* trans_id */, const RawAddress& /* bda */, int /* attr_handle */,
674    int /* offset */, bool /* is_long */) {
675  // Do nothing.
676}
677
678void BluetoothGattInterface::ServerObserver::RequestReadDescriptorCallback(
679    BluetoothGattInterface* /* gatt_iface */, int /* conn_id */,
680    int /* trans_id */, const RawAddress& /* bda */, int /* attr_handle */,
681    int /* offset */, bool /* is_long */) {
682  // Do nothing.
683}
684
685void BluetoothGattInterface::ServerObserver::RequestWriteCharacteristicCallback(
686    BluetoothGattInterface* /* gatt_iface */, int /* conn_id */,
687    int /* trans_id */, const RawAddress& /* bda */, int /* attr_handle */,
688    int /* offset */, bool /* need_rsp */, bool /* is_prep */,
689    std::vector<uint8_t> /* value */) {  // NOLINT(pass-by-value)
690  // Do nothing.
691}
692
693void BluetoothGattInterface::ServerObserver::RequestWriteDescriptorCallback(
694    BluetoothGattInterface* /* gatt_iface */, int /* conn_id */,
695    int /* trans_id */, const RawAddress& /* bda */, int /* attr_handle */,
696    int /* offset */, bool /* need_rsp */, bool /* is_prep */,
697    std::vector<uint8_t> /* value */) {  // NOLINT(pass-by-value)
698  // Do nothing.
699}
700
701void BluetoothGattInterface::ServerObserver::RequestExecWriteCallback(
702    BluetoothGattInterface* /* gatt_iface */, int /* conn_id */,
703    int /* trans_id */, const RawAddress& /* bda */, int /* exec_write */) {
704  // Do nothing.
705}
706
707void BluetoothGattInterface::ServerObserver::ResponseConfirmationCallback(
708    BluetoothGattInterface* /* gatt_iface */, int /* status */,
709    int /* handle */) {
710  // Do nothing
711}
712
713void BluetoothGattInterface::ServerObserver::IndicationSentCallback(
714    BluetoothGattInterface* /* gatt_iface */, int /* conn_id */,
715    int /* status */) {
716  // Do nothing.
717}
718
719void BluetoothGattInterface::ServerObserver::MtuChangedCallback(
720    BluetoothGattInterface* /* gatt_iface */, int /* conn_id */,
721    int /* mtu */) {
722  // Do nothing.
723}
724
725// static
726bool BluetoothGattInterface::Initialize() {
727  unique_lock<shared_mutex_impl> lock(g_instance_lock);
728  CHECK(!g_interface);
729
730  std::unique_ptr<BluetoothGattInterfaceImpl> impl(
731      new BluetoothGattInterfaceImpl());
732  if (!impl->Initialize()) {
733    LOG(ERROR) << "Failed to initialize BluetoothGattInterface";
734    return false;
735  }
736
737  g_interface = impl.release();
738
739  return true;
740}
741
742// static
743void BluetoothGattInterface::CleanUp() {
744  unique_lock<shared_mutex_impl> lock(g_instance_lock);
745  CHECK(g_interface);
746
747  delete g_interface;
748  g_interface = nullptr;
749}
750
751// static
752bool BluetoothGattInterface::IsInitialized() {
753  shared_lock<shared_mutex_impl> lock(g_instance_lock);
754
755  return g_interface != nullptr;
756}
757
758// static
759BluetoothGattInterface* BluetoothGattInterface::Get() {
760  shared_lock<shared_mutex_impl> lock(g_instance_lock);
761  CHECK(g_interface);
762  return g_interface;
763}
764
765// static
766void BluetoothGattInterface::InitializeForTesting(
767    BluetoothGattInterface* test_instance) {
768  unique_lock<shared_mutex_impl> lock(g_instance_lock);
769  CHECK(test_instance);
770  CHECK(!g_interface);
771
772  g_interface = test_instance;
773}
774
775bt_status_t BluetoothGattInterface::StartScan(int client_id) {
776  lock_guard<mutex> lock(scan_clients_lock_);
777
778  // Scan already initiated for this client.
779  if (scan_client_set_.find(client_id) != scan_client_set_.end()) {
780    // Assume starting scan multiple times is not error, but warn user.
781    LOG(WARNING) << "Scan already initiated for client";
782    return BT_STATUS_SUCCESS;
783  }
784
785  // If this is the first scan client, then make a call into the stack. We
786  // only do this when the reference count changes to or from 0.
787  if (scan_client_set_.empty()) {
788    GetScannerHALInterface()->Scan(true);
789  }
790
791  scan_client_set_.insert(client_id);
792
793  return BT_STATUS_SUCCESS;
794}
795
796bt_status_t BluetoothGattInterface::StopScan(int client_id) {
797  lock_guard<mutex> lock(scan_clients_lock_);
798
799  // Scan not initiated for this client.
800  auto iter = scan_client_set_.find(client_id);
801  if (iter == scan_client_set_.end()) {
802    // Assume stopping scan multiple times is not error, but warn user.
803    LOG(WARNING) << "Scan already stopped or not initiated for client";
804    return BT_STATUS_SUCCESS;
805  }
806
807  if (scan_client_set_.size() == 1) {
808    GetScannerHALInterface()->Scan(false);
809  }
810
811  scan_client_set_.erase(iter);
812  return BT_STATUS_SUCCESS;
813}
814
815}  // namespace hal
816}  // namespace bluetooth
817