Implement read & write remote GATT characteristic value for Windows

device/bluetooth/bluetooth_low_energy_win_fake.cc

 // Copyright 2016 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_fake.h"
 
 #include "base/strings/stringprintf.h"
 #include "device/bluetooth/bluetooth_low_energy_defs_win.h"
 
 namespace {
 const char kPlatformNotSupported[] =
     "Bluetooth Low energy is only supported on Windows 8 and later.";
 }  // namespace
 
 namespace device {
 namespace win {
 
 BLEDevice::BLEDevice() {}
 BLEDevice::~BLEDevice() {}
 
 GattService::GattService() {}
 GattService::~GattService() {}
 
 GattCharacteristic::GattCharacteristic() {}
 GattCharacteristic::~GattCharacteristic() {}
 
 GattDescriptor::GattDescriptor() {}
 GattDescriptor::~GattDescriptor() {}
 
-BluetoothLowEnergyWrapperFake::BluetoothLowEnergyWrapperFake() {}
+BluetoothLowEnergyWrapperFake::BluetoothLowEnergyWrapperFake()
+    : observer_(nullptr) {}
 BluetoothLowEnergyWrapperFake::~BluetoothLowEnergyWrapperFake() {}
 
 bool BluetoothLowEnergyWrapperFake::IsBluetoothLowEnergySupported() {
   return true;
 }
 
 bool BluetoothLowEnergyWrapperFake::EnumerateKnownBluetoothLowEnergyDevices(
     ScopedVector<BluetoothLowEnergyDeviceInfo>* devices,
     std::string* error) {
   if (!IsBluetoothLowEnergySupported()) {
@@ skipping 79 matching lines @@
   return true;
 }
 
 HRESULT BluetoothLowEnergyWrapperFake::ReadCharacteristicsOfAService(
     base::FilePath& service_path,
     const PBTH_LE_GATT_SERVICE service,
     scoped_ptr<BTH_LE_GATT_CHARACTERISTIC>* out_included_characteristics,
     USHORT* out_counts) {
   base::string16 device_address =
       ExtractDeviceAddressFromDevicePath(service_path.value());
+  BLEDevice* target_device = GetSimulatedBLEDevice(
+      std::string(device_address.begin(), device_address.end()));
+  if (target_device == nullptr)
+    return HRESULT_FROM_WIN32(ERROR_NOT_FOUND);
   const std::vector<std::string> service_att_handles =
       ExtractServiceAttributeHandlesFromDevicePath(service_path.value());
-  GattService* target_service = GetSimulatedGattService(
-      GetSimulatedBLEDevice(
-          std::string(device_address.begin(), device_address.end())),
-      service_att_handles);
+  GattService* target_service =
+      GetSimulatedGattService(target_device, service_att_handles);
   if (target_service == nullptr)
     return HRESULT_FROM_WIN32(ERROR_NOT_FOUND);
 
   std::size_t number_of_included_characteristic =
       target_service->included_characteristics.size();
   if (number_of_included_characteristic) {
     *out_counts = (USHORT)number_of_included_characteristic;
     out_included_characteristics->reset(
         new BTH_LE_GATT_CHARACTERISTIC[number_of_included_characteristic]);
     std::size_t i = 0;
@@ skipping 24 matching lines @@
   *out_counts = USHORT(number_of_included_descriptors);
   std::size_t i = 0;
   for (const auto& d : target_characteristic->included_descriptors) {
     win_descriptors_info[i] = *(d.second->descriptor_info);
     i++;
   }
   out_included_descriptors->reset(win_descriptors_info);
   return S_OK;
 }
 
+HRESULT BluetoothLowEnergyWrapperFake::ReadTheValueOfACharacteristic(
+    base::FilePath& service_path,
+    const PBTH_LE_GATT_CHARACTERISTIC characteristic,
+    scoped_ptr<BTH_LE_GATT_CHARACTERISTIC_VALUE>* out_value) {
+  GattCharacteristic* target_characteristic =
+      GetSimulatedGattCharacteristic(service_path, characteristic);
+  if (target_characteristic == nullptr)
+    return HRESULT_FROM_WIN32(ERROR_NOT_FOUND);
+
+  // Return error simulated by SimulateGattCharacteristicReadError.
+  if (target_characteristic->read_errors.size()) {
+    HRESULT hr = target_characteristic->read_errors[0];
+    target_characteristic->read_errors.erase(
+        target_characteristic->read_errors.begin());
+    return hr;
+  }
+
+  PBTH_LE_GATT_CHARACTERISTIC_VALUE ret_value =
+      (PBTH_LE_GATT_CHARACTERISTIC_VALUE)(
+          new UCHAR[sizeof(ULONG) + target_characteristic->value->DataSize]);
+  ret_value->DataSize = target_characteristic->value->DataSize;
+  for (ULONG i = 0; i < ret_value->DataSize; i++)
+    ret_value->Data[i] = target_characteristic->value->Data[i];
+  out_value->reset(ret_value);
+  return S_OK;
+}
+
+HRESULT BluetoothLowEnergyWrapperFake::WriteTheValueOfACharacteristic(
+    base::FilePath& service_path,
+    const PBTH_LE_GATT_CHARACTERISTIC characteristic,
+    PBTH_LE_GATT_CHARACTERISTIC_VALUE new_value) {
+  GattCharacteristic* target_characteristic =
+      GetSimulatedGattCharacteristic(service_path, characteristic);
+  if (target_characteristic == nullptr)
+    return ERROR_NOT_FOUND;
+
+  // Return error simulated by SimulateGattCharacteristicWriteError.
+  if (target_characteristic->write_errors.size()) {
+    HRESULT hr = *(target_characteristic->write_errors.begin());
+    target_characteristic->write_errors.erase(
+        target_characteristic->write_errors.begin());
+    return hr;
+  }
+
+  PBTH_LE_GATT_CHARACTERISTIC_VALUE win_value =
+      (PBTH_LE_GATT_CHARACTERISTIC_VALUE)(
+          new UCHAR[new_value->DataSize + sizeof(ULONG)]);
+  for (ULONG i = 0; i < new_value->DataSize; i++)
+    win_value->Data[i] = new_value->Data[i];
+  win_value->DataSize = new_value->DataSize;
+  target_characteristic->value.reset(win_value);
+  if (observer_)
+    observer_->onWriteGattCharacteristicValue(win_value);
+  return S_OK;
+}
+
 BLEDevice* BluetoothLowEnergyWrapperFake::SimulateBLEDevice(
     std::string device_name,
     BLUETOOTH_ADDRESS device_address) {
   BLEDevice* device = new BLEDevice();
   BluetoothLowEnergyDeviceInfo* device_info =
       new BluetoothLowEnergyDeviceInfo();
   std::string string_device_address =
       BluetoothAddressToCanonicalString(device_address);
   device_info->path =
       base::FilePath(GenerateBLEDevicePath(string_device_address));
   device_info->friendly_name = device_name;
   device_info->address = device_address;
   device->device_info.reset(device_info);
   simulated_devices_[string_device_address] = make_scoped_ptr(device);
   return device;
 }
 
 BLEDevice* BluetoothLowEnergyWrapperFake::GetSimulatedBLEDevice(
     std::string device_address) {
   BLEDevicesMap::iterator it_d = simulated_devices_.find(device_address);
   if (it_d == simulated_devices_.end())
     return nullptr;
   return it_d->second.get();
 }
 
+void BluetoothLowEnergyWrapperFake::RemoveSimulatedBLEDevice(
+    std::string device_address) {
+  simulated_devices_.erase(device_address);
+}
+
 GattService* BluetoothLowEnergyWrapperFake::SimulateGattService(
     BLEDevice* device,
     GattService* parent_service,
     const BTH_LE_UUID& uuid) {
   CHECK(device);
 
   GattService* service = new GattService();
   PBTH_LE_GATT_SERVICE service_info = new BTH_LE_GATT_SERVICE[1];
   std::string string_device_address =
       BluetoothAddressToCanonicalString(device->device_info->address);
@@ skipping 78 matching lines @@
     GattService* parent_service,
     std::string attribute_handle) {
   CHECK(parent_service);
   GattCharacteristicsMap::iterator it =
       parent_service->included_characteristics.find(attribute_handle);
   if (it != parent_service->included_characteristics.end())
     return it->second.get();
   return nullptr;
 }
 
+void BluetoothLowEnergyWrapperFake::SimulateGattCharacteristicValue(
+    GattCharacteristic* characteristic,
+    const std::vector<uint8_t>& value) {
+  CHECK(characteristic);
+  PBTH_LE_GATT_CHARACTERISTIC_VALUE win_value =
+      (PBTH_LE_GATT_CHARACTERISTIC_VALUE)(
+          new UCHAR[value.size() + sizeof(ULONG)]);
+  win_value->DataSize = (ULONG)value.size();
+  for (std::size_t i = 0; i < value.size(); i++)
+    win_value->Data[i] = value[i];
+  characteristic->value.reset(win_value);
+}
+
+void BluetoothLowEnergyWrapperFake::SimulateGattCharacteristicReadError(
+    GattCharacteristic* characteristic,
+    HRESULT error) {
+  CHECK(characteristic);
+  characteristic->read_errors.push_back(error);
+}
+
+void BluetoothLowEnergyWrapperFake::SimulateGattCharacteristicWriteError(
+    GattCharacteristic* characteristic,
+    HRESULT error) {
+  CHECK(characteristic);
+  characteristic->write_errors.push_back(error);
+}
+
 void BluetoothLowEnergyWrapperFake::SimulateGattDescriptor(
     std::string device_address,
     GattCharacteristic* characteristic,
     const BTH_LE_UUID& uuid) {
   scoped_ptr<GattDescriptor> descriptor(new GattDescriptor());
   descriptor->descriptor_info.reset(new BTH_LE_GATT_DESCRIPTOR[1]);
   descriptor->descriptor_info->DescriptorUuid = uuid;
   descriptor->descriptor_info->AttributeHandle =
       GenerateAUniqueAttributeHandle(device_address);
   characteristic->included_descriptors[std::to_string(
       descriptor->descriptor_info->AttributeHandle)] = std::move(descriptor);
 }
 
+void BluetoothLowEnergyWrapperFake::AddObserver(Observer* observer) {
+  observer_ = observer;
+}
+
 GattCharacteristic*
 BluetoothLowEnergyWrapperFake::GetSimulatedGattCharacteristic(
     base::FilePath& service_path,
     const PBTH_LE_GATT_CHARACTERISTIC characteristic) {
   base::string16 device_address =
       ExtractDeviceAddressFromDevicePath(service_path.value());
   BLEDevice* target_device = GetSimulatedBLEDevice(
       std::string(device_address.begin(), device_address.end()));
   if (target_device == nullptr)
     return nullptr;
@@ skipping 87 matching lines @@
 std::string BluetoothLowEnergyWrapperFake::BluetoothAddressToCanonicalString(
     const BLUETOOTH_ADDRESS& btha) {
   std::string result = base::StringPrintf(
       "%02X:%02X:%02X:%02X:%02X:%02X", btha.rgBytes[5], btha.rgBytes[4],
       btha.rgBytes[3], btha.rgBytes[2], btha.rgBytes[1], btha.rgBytes[0]);
   return result;
 }
 
 }  // namespace win
 }  // namespace device