Implement read & write remote GATT characteristic value for Windows

device/bluetooth/bluetooth_remote_gatt_characteristic_win.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_remote_gatt_characteristic_win.h"
 
 #include "base/bind.h"
 #include "device/bluetooth/bluetooth_adapter_win.h"
 #include "device/bluetooth/bluetooth_remote_gatt_descriptor_win.h"
 #include "device/bluetooth/bluetooth_remote_gatt_service_win.h"
@@ skipping 38 matching lines @@
 
 BluetoothUUID BluetoothRemoteGattCharacteristicWin::GetUUID() const {
   return characteristic_uuid_;
 }
 
 bool BluetoothRemoteGattCharacteristicWin::IsLocal() const {
   return false;
 }
 
 std::vector<uint8_t>& BluetoothRemoteGattCharacteristicWin::GetValue() const {
-  NOTIMPLEMENTED();
   return const_cast<std::vector<uint8_t>&>(characteristic_value_);
 }
 
 BluetoothGattService* BluetoothRemoteGattCharacteristicWin::GetService() const {
   return parent_service_;
 }
 
 BluetoothGattCharacteristic::Properties
 BluetoothRemoteGattCharacteristicWin::GetProperties() const {
   BluetoothGattCharacteristic::Properties properties = PROPERTY_NONE;
@@ skipping 70 matching lines @@
 void BluetoothRemoteGattCharacteristicWin::StartNotifySession(
     const NotifySessionCallback& callback,
     const ErrorCallback& error_callback) {
   NOTIMPLEMENTED();
   error_callback.Run(BluetoothGattService::GATT_ERROR_NOT_SUPPORTED);
 }
 
 void BluetoothRemoteGattCharacteristicWin::ReadRemoteCharacteristic(
     const ValueCallback& callback,
     const ErrorCallback& error_callback) {
-  NOTIMPLEMENTED();
-  error_callback.Run(BluetoothGattService::GATT_ERROR_NOT_SUPPORTED);
+  DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+
+  if (!characteristic_info_.get()->IsReadable) {
+    error_callback.Run(BluetoothGattService::GATT_ERROR_NOT_PERMITTED);
+    return;
+  }
+
+  read_remote_characteristic_value_callbacks_.push_back(

[scheib, 2016/03/02 05:59:05]

Android is supporting only one outstanding read operation at a time. What if the
device returns a counter value, [1,2,3,4,5,...] for each read. If code calls 3
reads and then the first one is returned, then 3 more, it would receive
[1,1,1,4,4,4,...]. What do you think of only one callback being stored per
characteristic and returning GATT_ERROR_IN_PROGRESS otherwise?

[gogerald1, 2016/03/02 23:56:29]

Done.

+      std::make_pair(callback, error_callback));
+  task_manager_->PostReadGattCharacteristicValue(
+      parent_service_->GetServicePath(), characteristic_info_.get(),
+      base::Bind(&BluetoothRemoteGattCharacteristicWin::
+                     OnReadRemoteCharacteristicValueCallback,
+                 weak_ptr_factory_.GetWeakPtr()));
 }
 
 void BluetoothRemoteGattCharacteristicWin::WriteRemoteCharacteristic(
     const std::vector<uint8_t>& new_value,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
-  NOTIMPLEMENTED();
-  error_callback.Run(BluetoothGattService::GATT_ERROR_NOT_SUPPORTED);
+  DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+
+  if (!characteristic_info_.get()->IsWritable) {
+    error_callback.Run(BluetoothGattService::GATT_ERROR_NOT_PERMITTED);
+    return;
+  }
+
+  write_remote_characteristic_value_callbacks_.push_back(
+      std::make_pair(callback, error_callback));
+  task_manager_->PostWriteGattCharacteristicValue(
+      parent_service_->GetServicePath(), characteristic_info_.get(), new_value,
+      base::Bind(&BluetoothRemoteGattCharacteristicWin::
+                     OnWriteRemoteCharacteristicValueCallback,
+                 weak_ptr_factory_.GetWeakPtr()));
 }
 
 void BluetoothRemoteGattCharacteristicWin::Update() {
   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
 
   task_manager_->PostGetGattIncludedDescriptors(
       parent_service_->GetServicePath(), characteristic_info_.get(),
       base::Bind(&BluetoothRemoteGattCharacteristicWin::
                      OnGetIncludedDescriptorsCallback,
                  weak_ptr_factory_.GetWeakPtr()));
@@ skipping 76 matching lines @@
         BluetoothTaskManagerWin::BluetoothLowEnergyUuidToBluetoothUuid(
             descriptors[i].DescriptorUuid);
     if (descriptor->GetUUID() == uuid &&
         descriptor->GetAttributeHandle() == descriptors[i].AttributeHandle) {
       return true;
     }
   }
   return false;
 }
 
+void BluetoothRemoteGattCharacteristicWin::
+    OnReadRemoteCharacteristicValueCallback(
+        scoped_ptr<BTH_LE_GATT_CHARACTERISTIC_VALUE> value,
+        HRESULT hr) {
+  DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+
+  if (FAILED(hr)) {
+    for (const auto& callback : read_remote_characteristic_value_callbacks_)
+      callback.second.Run(HRESULTToGattErrorCode(hr));
+  } else {
+    characteristic_value_.clear();
+    for (ULONG i = 0; i < value->DataSize; i++)
+      characteristic_value_.push_back(value->Data[i]);
+    for (const auto& callback : read_remote_characteristic_value_callbacks_)

[scheib, 2016/03/02 05:59:05]

When running callbacks always clear the member variable of the callback in case
the callback ends up being reentrant:

OnReadRemoteCharacteristicValueCallback
 calls CallbackFoo
 calls ReadRemoteCharacteristic
 changes read_remote_characteristic_value_callbacks_

[gogerald1, 2016/03/02 23:56:29]

Done.

+      callback.first.Run(characteristic_value_);
+  }
+
+  read_remote_characteristic_value_callbacks_.clear();
+}
+
+void BluetoothRemoteGattCharacteristicWin::
+    OnWriteRemoteCharacteristicValueCallback(HRESULT hr) {
+  DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
+
+  if (FAILED(hr)) {
+    for (const auto& callback : write_remote_characteristic_value_callbacks_)
+      callback.second.Run(HRESULTToGattErrorCode(hr));
+  } else {
+    for (const auto& callback : write_remote_characteristic_value_callbacks_)
+      callback.first.Run();
+  }
+
+  write_remote_characteristic_value_callbacks_.clear();
+}
+
+BluetoothGattService::GattErrorCode
+BluetoothRemoteGattCharacteristicWin::HRESULTToGattErrorCode(HRESULT hr) {
+  switch (hr) {
+    case E_BLUETOOTH_ATT_READ_NOT_PERMITTED:
+    case E_BLUETOOTH_ATT_WRITE_NOT_PERMITTED:
+      return BluetoothGattService::GATT_ERROR_NOT_PERMITTED;
+    case E_BLUETOOTH_ATT_UNKNOWN_ERROR:
+      return BluetoothGattService::GATT_ERROR_UNKNOWN;
+    case ERROR_INVALID_USER_BUFFER:
+    case E_BLUETOOTH_ATT_INVALID_ATTRIBUTE_VALUE_LENGTH:
+      return BluetoothGattService::GATT_ERROR_INVALID_LENGTH;
+    default:
+      return BluetoothGattService::GATT_ERROR_FAILED;
+  }
+}
+
 }  // namespace device.