BLE GATT service implementation in Chrome for Windows 8 and later

device/bluetooth/bluetooth_device_win.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "device/bluetooth/bluetooth_device_win.h"
 
 #include <string>
 
 #include "base/containers/scoped_ptr_hash_map.h"
 #include "base/logging.h"
 #include "base/memory/scoped_vector.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/stringprintf.h"
 #include "device/bluetooth/bluetooth_adapter_win.h"
+#include "device/bluetooth/bluetooth_remote_gatt_service_win.h"
 #include "device/bluetooth/bluetooth_service_record_win.h"
 #include "device/bluetooth/bluetooth_socket_thread.h"
 #include "device/bluetooth/bluetooth_socket_win.h"
 #include "device/bluetooth/bluetooth_task_manager_win.h"
 #include "device/bluetooth/bluetooth_uuid.h"
 
 namespace {
 
 const char kApiUnavailable[] = "This API is not implemented on this platform.";
 
@@ skipping 147 matching lines @@
   socket->Connect(this, uuid, base::Bind(callback, socket), error_callback);
 }
 
 void BluetoothDeviceWin::ConnectToServiceInsecurely(
     const BluetoothUUID& uuid,
     const ConnectToServiceCallback& callback,
     const ConnectToServiceErrorCallback& error_callback) {
   error_callback.Run(kApiUnavailable);
 }
 
 void BluetoothDeviceWin::CreateGattConnection(

[ortuno, 2016/01/21 19:00:42]

I noticed you didn't implement CreateGattConnection or DisconnectGatt. Is that
because there are no APIs to control connection in windows?

[gogerald1, 2016/01/21 20:00:20]

Yes, I searched it for a while, haven't found any clew to do that, but bonded
(manually) BLE device could auto re-connect to each other when trying to write
data or register event. We could add it later when it is available. 

       const GattConnectionCallback& callback,
       const ConnectErrorCallback& error_callback) {
   // TODO(armansito): Implement.
   error_callback.Run(ERROR_UNSUPPORTED_DEVICE);
 }
 
 const BluetoothServiceRecordWin* BluetoothDeviceWin::GetServiceRecord(
     const device::BluetoothUUID& uuid) const {
   for (ServiceRecordList::const_iterator iter = service_record_list_.begin();
        iter != service_record_list_.end();
@@ skipping 100 matching lines @@
 
   for (ScopedVector<BluetoothTaskManagerWin::ServiceRecordState>::const_iterator
            iter = device_state.service_record_states.begin();
        iter != device_state.service_record_states.end(); ++iter) {
     BluetoothServiceRecordWin* service_record =
         new BluetoothServiceRecordWin(device_state.address, (*iter)->name,
                                       (*iter)->sdp_bytes, (*iter)->gatt_uuid);
     service_record_list_.push_back(service_record);
     uuids_.push_back(service_record->uuid());
   }
+
+  if (!device_state.is_bluetooth_classic())
+    UpdateGattServices(device_state);
+}
+
+void BluetoothDeviceWin::UpdateGattServices(
+    const BluetoothTaskManagerWin::DeviceState& device_state) {
+  // Remove no longer exist gatt services first.
+  if (gatt_services_.size() != 0) {
+    std::vector<std::string> removed_services;
+    for (auto gatt_service : gatt_services_) {
+      BluetoothUUID uuid = gatt_service.second->GetUUID();
+      ScopedVector<BluetoothTaskManagerWin::ServiceRecordState>::const_iterator
+          iter = device_state.service_record_states.begin();
+      for (; iter != device_state.service_record_states.end(); ++iter) {
+        if (uuid == (*iter)->gatt_uuid)
+          break;
+      }
+      if (iter == device_state.service_record_states.end()) {
+        removed_services.push_back(gatt_service.first);
+      }
+    }
+    for (auto key : removed_services) {
+      gatt_services_.erase(key);
+    }
+    // Update previously discovered services.
+    for (auto gatt_service : gatt_services_) {
+      static_cast<BluetoothRemoteGattServiceWin*>(gatt_service.second)
+          ->Update();
+    }
+  }
+
+  // Return if no new services have been added.
+  if (gatt_services_.size() == device_state.service_record_states.size())
+    return;
+
+  // Add new services.
+  for (ScopedVector<BluetoothTaskManagerWin::ServiceRecordState>::const_iterator
+           iter = device_state.service_record_states.begin();
+       iter != device_state.service_record_states.end(); ++iter) {
+    GattServiceMap::iterator it = gatt_services_.begin();
+    for (; it != gatt_services_.end(); it++) {
+      if ((*iter)->gatt_uuid == it->second->GetUUID())
+        break;
+    }
+    if (it == gatt_services_.end()) {
+      BluetoothRemoteGattServiceWin* primary_service =
+          new BluetoothRemoteGattServiceWin(
+              this, (*iter)->path, (*iter)->gatt_uuid,
+              (*iter)->gatt_attribute_handle, true, nullptr, ui_task_runner_);
+      gatt_services_.add(primary_service->GetIdentifier(),
+                         scoped_ptr<BluetoothGattService>(primary_service));
+      static_cast<BluetoothAdapterWin*>(adapter_)
+          ->NotifyGattServiceAdded(this, primary_service);
+    }
+  }
+
+  static_cast<BluetoothAdapterWin*>(adapter_)
+      ->NotifyGattServicesDiscovered(this);
 }
 
 }  // namespace device