Read characteristic implementation on macOS

device/bluetooth/bluetooth_remote_gatt_characteristic_mac.mm

 // 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_mac.h"
 
 #import <CoreBluetooth/CoreBluetooth.h>
 
+#include "base/bind.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "device/bluetooth/bluetooth_adapter_mac.h"
+#include "device/bluetooth/bluetooth_device_mac.h"
 #include "device/bluetooth/bluetooth_remote_gatt_service_mac.h"
 
 namespace device {
 
 namespace {
 
 static BluetoothGattCharacteristic::Properties ConvertProperties(
     CBCharacteristicProperties cb_property) {
   BluetoothGattCharacteristic::Properties result =
       BluetoothGattCharacteristic::PROPERTY_NONE;
@@ skipping 38 matching lines @@
     result |= BluetoothGattCharacteristic::PROPERTY_INDICATE;
   }
   return result;
 }
 }  // namespace
 
 BluetoothRemoteGattCharacteristicMac::BluetoothRemoteGattCharacteristicMac(
     BluetoothRemoteGattServiceMac* gatt_service,
     CBCharacteristic* cb_characteristic)
     : gatt_service_(gatt_service),
-      cb_characteristic_(cb_characteristic, base::scoped_policy::RETAIN) {
+      cb_characteristic_(cb_characteristic, base::scoped_policy::RETAIN),
+      characteristic_value_read_or_write_in_progress_(false) {
   uuid_ = BluetoothAdapterMac::BluetoothUUIDWithCBUUID(
       [cb_characteristic_.get() UUID]);
   identifier_ =
       [NSString stringWithFormat:@"%s-%p", uuid_.canonical_value().c_str(),
                                  (void*)cb_characteristic_]
           .UTF8String;
 }
 
 BluetoothRemoteGattCharacteristicMac::~BluetoothRemoteGattCharacteristicMac() {}
 
@@ skipping 47 matching lines @@
 
 void BluetoothRemoteGattCharacteristicMac::StartNotifySession(
     const NotifySessionCallback& callback,
     const ErrorCallback& error_callback) {
   NOTIMPLEMENTED();
 }
 
 void BluetoothRemoteGattCharacteristicMac::ReadRemoteCharacteristic(
     const ValueCallback& callback,
     const ErrorCallback& error_callback) {
-  NOTIMPLEMENTED();
+  if (!IsReadable()) {
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE,
+        base::Bind(error_callback,
+                   BluetoothRemoteGattService::GATT_ERROR_NOT_SUPPORTED));
+    return;
+  }
+  if (characteristic_value_read_or_write_in_progress_) {
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE,
+        base::Bind(error_callback,
+                   BluetoothRemoteGattService::GATT_ERROR_IN_PROGRESS));
+    return;
+  }
+  characteristic_value_read_or_write_in_progress_ = true;
+  read_characteristic_value_callbacks_ =
+      std::make_pair(callback, error_callback);
+  [gatt_service_->GetCBPeripheral()
+      readValueForCharacteristic:cb_characteristic_];
 }
 
 void BluetoothRemoteGattCharacteristicMac::WriteRemoteCharacteristic(
     const std::vector<uint8_t>& new_value,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   NOTIMPLEMENTED();
 }
 
+void BluetoothRemoteGattCharacteristicMac::DidUpdateValue(NSError* error) {
+  if (!characteristic_value_read_or_write_in_progress_) {
+    return;
+  }
+  std::pair<ValueCallback, ErrorCallback> callbacks;
+  callbacks.swap(read_characteristic_value_callbacks_);
+  characteristic_value_read_or_write_in_progress_ = false;
+  if (error) {
+    VLOG(1) << "Bluetooth error while reading for characteristic, domain: "
+            << error.domain.UTF8String << ", error code: " << error.code;
+    BluetoothGattService::GattErrorCode error_code =
+        BluetoothDeviceMac::GetGattErrorCodeFromNSError(error);
+    callbacks.second.Run(error_code);
+    return;
+  }
+  NSData* nsdata_value = cb_characteristic_.get().value;
+  const uint8_t* buffer = static_cast<const uint8_t*>(nsdata_value.bytes);
+  value_.assign(buffer, buffer + nsdata_value.length);
+  gatt_service_->GetMacAdapter()->NotifyGattCharacteristicValueChanged(this,
+                                                                       value_);
+  callbacks.first.Run(value_);
+}
+
+bool BluetoothRemoteGattCharacteristicMac::IsReadable() const {
+  return GetProperties() & BluetoothGattCharacteristic::PROPERTY_READ;
+}
+
 CBCharacteristic* BluetoothRemoteGattCharacteristicMac::GetCBCharacteristic()
     const {
   return cb_characteristic_.get();
 }
 
 }  // namespace device.