Enumerate Bluetooth LE services and expose them to chrome.bluetooth API.

device/bluetooth/bluetooth_low_energy_win.cc

 // Copyright 2014 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_low_energy_win.h"
 
-#include <cfg.h>
-#define INITGUID  // For DEVPKEY_Xxxx guid/pid pairs
-#include <devpkey.h>
-
+#include "base/files/file.h"
 #include "base/logging.h"
 #include "base/strings/sys_string_conversions.h"
+#include "base/win/scoped_handle.h"
 #include "base/win/windows_version.h"
 
 namespace {
 
 using device::win::DeviceRegistryPropertyValue;
 using device::win::DevicePropertyValue;
+using device::win::BluetoothLowEnergyDeviceInfo;
+using device::win::BluetoothLowEnergyServiceInfo;
 
 const char kPlatformNotSupported[] =
     "Bluetooth Low energy is only supported on Windows 8 and later.";
 const char kDeviceEnumError[] = "Error enumerating Bluetooth LE devices.";
 const char kDeviceInfoError[] =
     "Error retrieving Bluetooth LE device information.";
 const char kDeviceAddressError[] =
     "Device instance ID value does not seem to contain a Bluetooth Adapter "
     "address.";
 const char kDeviceFriendlyNameError[] = "Device name is not valid.";
@@ skipping 73 matching lines @@
 
   HRESULT hr = HRESULT_FROM_WIN32(GetLastError());
   if (hr != HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER)) {
     *error = FormatBluetoothError(message, hr);
     return false;
   }
 
   return true;
 }
 
-bool CheckSuccess(HRESULT hr, const char* message, std::string* error) {
+bool CheckHResult(HRESULT hr, const char* message, std::string* error) {
   if (FAILED(hr)) {
     *error = FormatBluetoothError(message, hr);
     return false;
   }
 
   return true;
 }
 
+bool CheckSuccess(bool success, const char* message, std::string* error) {
+  if (!success) {
+    CheckHResult(HRESULT_FROM_WIN32(GetLastError()), message, error);
+    return false;
+  }
+
+  return true;
+}
+
+bool CheckNoData(HRESULT hr, size_t length) {
+  if (hr == HRESULT_FROM_WIN32(ERROR_NOT_FOUND))
+    return true;
+
+  if (SUCCEEDED(hr) && length == 0)
+    return true;
+
+  return false;
+}
+
+bool CheckMoreData(HRESULT hr, const char* message, std::string* error) {
+  if (SUCCEEDED(hr)) {
+    *error = FormatBluetoothError(message, hr);
+    return false;
+  }
+
+  if (hr != HRESULT_FROM_WIN32(ERROR_MORE_DATA)) {
+    *error = FormatBluetoothError(message, hr);
+    return false;
+  }
+
+  return true;
+}
+
 bool CheckExpectedLength(size_t actual_length,
                          size_t expected_length,
                          const char* message,
                          std::string* error) {
   if (actual_length != expected_length) {
     *error = FormatBluetoothError(message, E_FAIL);
     return false;
   }
 
   return true;
@@ skipping 105 matching lines @@
   }
 
   if (actual_length >= 1) {
     // Ensure string is zero terminated.
     instance_id.get()[actual_length - 1] = 0;
     device_info->id = base::SysWideToUTF8(instance_id.get());
   }
   return true;
 }
 
-bool CollectDeviceFriendlyName(
+bool CollectBluetoothLowEnergyDeviceFriendlyName(
     const ScopedDeviceInfoSetHandle& device_info_handle,
     PSP_DEVINFO_DATA device_info_data,
     scoped_ptr<device::win::BluetoothLowEnergyDeviceInfo>& device_info,
     std::string* error) {
   scoped_ptr<DeviceRegistryPropertyValue> property_value;
   if (!CollectBluetoothLowEnergyDeviceRegistryProperty(device_info_handle,
                                                        device_info_data,
                                                        SPDRP_FRIENDLYNAME,
                                                        &property_value,
                                                        error)) {
@@ skipping 66 matching lines @@
 
   device_info->connected = !(value->AsUint32() & DN_DEVICE_DISCONNECTED);
   // Windows 8 exposes BLE devices only if they are visible and paired. This
   // might change in the future if Windows offers a public API for discovering
   // and pairing BLE devices.
   device_info->visible = true;
   device_info->authenticated = true;
   return true;
 }
 
+bool CollectBluetoothLowEnergyDeviceServices(
+    const base::FilePath& device_path,
+    ScopedVector<BluetoothLowEnergyServiceInfo>* services,
+    std::string* error) {
+  base::File file(device_path, base::File::FLAG_OPEN | base::File::FLAG_READ);
+  if (!file.IsValid()) {
+    *error = file.ErrorToString(file.error_details());
+    return false;
+  }
+
+  USHORT required_length;
+  HRESULT hr = BluetoothGATTGetServices(file.GetPlatformFile(),
+                                        0,
+                                        NULL,
+                                        &required_length,
+                                        BLUETOOTH_GATT_FLAG_NONE);
+  if (CheckNoData(hr, required_length))
+    return true;
+  if (!CheckMoreData(hr, kDeviceInfoError, error))
+    return false;
+
+  scoped_ptr<BTH_LE_GATT_SERVICE[]> gatt_services(
+      new BTH_LE_GATT_SERVICE[required_length]);
+  USHORT actual_length = required_length;
+  hr = BluetoothGATTGetServices(file.GetPlatformFile(),
+                                actual_length,
+                                gatt_services.get(),
+                                &required_length,
+                                BLUETOOTH_GATT_FLAG_NONE);
+  if (!CheckHResult(hr, kDeviceInfoError, error))
+    return false;
+  if (!CheckExpectedLength(
+          actual_length, required_length, kDeviceInfoError, error)) {
+    return false;
+  }
+
+  for (USHORT i = 0; i < actual_length; ++i) {
+    BTH_LE_GATT_SERVICE& gatt_service(gatt_services.get()[i]);
+    BluetoothLowEnergyServiceInfo* service_info =
+        new BluetoothLowEnergyServiceInfo();
+    service_info->uuid = gatt_service.ServiceUuid;
+    services->push_back(service_info);
+  }
+
+  return true;
+}
+
 bool CollectBluetoothLowEnergyDeviceInfo(
     const ScopedDeviceInfoSetHandle& device_info_handle,
     PSP_DEVICE_INTERFACE_DATA device_interface_data,
     scoped_ptr<device::win::BluetoothLowEnergyDeviceInfo>* device_info,
     std::string* error) {
   // Retrieve required # of bytes for interface details
   ULONG required_length = 0;
   BOOL success = SetupDiGetDeviceInterfaceDetail(device_info_handle,
                                                  device_interface_data,
                                                  NULL,
@@ skipping 29 matching lines @@
   }
 
   scoped_ptr<device::win::BluetoothLowEnergyDeviceInfo> result(
       new device::win::BluetoothLowEnergyDeviceInfo());
   result->path =
       base::FilePath(std::wstring(device_interface_detail_data->DevicePath));
   if (!CollectBluetoothLowEnergyDeviceInstanceId(
           device_info_handle, &device_info_data, result, error)) {
     return false;
   }
-  if (!CollectDeviceFriendlyName(
+  if (!CollectBluetoothLowEnergyDeviceFriendlyName(
           device_info_handle, &device_info_data, result, error)) {
     return false;
   }
   if (!CollectBluetoothLowEnergyDeviceAddress(
           device_info_handle, &device_info_data, result, error)) {
     return false;
   }
   if (!CollectBluetoothLowEnergyDeviceStatus(
           device_info_handle, &device_info_data, result, error)) {
     return false;
@@ skipping 123 matching lines @@
       value_(value.Pass()),
       value_size_(value_size) {
 }
 
 uint32_t DevicePropertyValue::AsUint32() const {
   CHECK_EQ(property_type_, static_cast<DEVPROPTYPE>(DEVPROP_TYPE_UINT32));
   CHECK_EQ(value_size_, sizeof(uint32_t));
   return *reinterpret_cast<uint32_t*>(value_.get());
 }
 
+BluetoothLowEnergyServiceInfo::BluetoothLowEnergyServiceInfo() {
+}
+
+BluetoothLowEnergyServiceInfo::~BluetoothLowEnergyServiceInfo() {
+}
+
 BluetoothLowEnergyDeviceInfo::BluetoothLowEnergyDeviceInfo()
     : visible(false), authenticated(false), connected(false) {
   address.ullLong = BLUETOOTH_NULL_ADDRESS;
 }
 
 BluetoothLowEnergyDeviceInfo::~BluetoothLowEnergyDeviceInfo() {
 }
 
 bool IsBluetoothLowEnergySupported() {
   return base::win::GetVersion() >= base::win::VERSION_WIN8;
@@ skipping 22 matching lines @@
       case kNoMoreDevices:
         return true;
       case kError:
         return false;
       case kOk:
         devices->push_back(device_info.release());
     }
   }
 }
 
+bool EnumerateKnownBluetoothLowEnergyServices(
+    BluetoothLowEnergyDeviceInfo* device_info,
+    ScopedVector<BluetoothLowEnergyServiceInfo>* services,
+    std::string* error) {
+  return CollectBluetoothLowEnergyDeviceServices(
+      device_info->path, services, error);
+}
+
 bool ExtractBluetoothAddressFromDeviceInstanceIdForTesting(
     const std::string& instance_id,
     BLUETOOTH_ADDRESS* btha,
     std::string* error) {
   return ExtractBluetoothAddressFromDeviceInstanceId(instance_id, btha, error);
 }
 
 }  // namespace win
 }  // namespace device