Bluetooth: mac: Working on macOS descriptor implementation.

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"
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/sys_string_conversions.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_gatt_notify_session.h"
+#include "device/bluetooth/bluetooth_remote_gatt_descriptor_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 98 matching lines @@
     const {
   return static_cast<BluetoothRemoteGattService*>(gatt_service_);
 }
 
 bool BluetoothRemoteGattCharacteristicMac::IsNotifying() const {
   return cb_characteristic_.get().isNotifying == YES;
 }
 
 std::vector<BluetoothRemoteGattDescriptor*>
 BluetoothRemoteGattCharacteristicMac::GetDescriptors() const {
-  NOTIMPLEMENTED();
-  return std::vector<BluetoothRemoteGattDescriptor*>();
+  std::vector<BluetoothRemoteGattDescriptor*> gatt_descriptors;
+  for (const auto& iter : gatt_descriptor_macs_) {
+    BluetoothRemoteGattDescriptor* gatt_descriptor =
+        static_cast<BluetoothRemoteGattDescriptor*>(iter.second.get());
+    gatt_descriptors.push_back(gatt_descriptor);
+  }
+  return gatt_descriptors;
 }
 
 BluetoothRemoteGattDescriptor*
 BluetoothRemoteGattCharacteristicMac::GetDescriptor(
     const std::string& identifier) const {
-  NOTIMPLEMENTED();
-  return nullptr;
+  auto searched_pair = gatt_descriptor_macs_.find(identifier);
+  if (searched_pair == gatt_descriptor_macs_.end()) {
+    return nullptr;
+  }
+  return static_cast<BluetoothRemoteGattDescriptor*>(
+      searched_pair->second.get());
 }
 
 void BluetoothRemoteGattCharacteristicMac::StartNotifySession(
     const NotifySessionCallback& callback,
     const ErrorCallback& error_callback) {
   if (IsNotifying()) {
     VLOG(2) << "Already notifying. Creating notify session.";
     std::unique_ptr<BluetoothGattNotifySession> notify_session(
         new BluetoothGattNotifySession(weak_ptr_factory_.GetWeakPtr()));
     base::ThreadTaskRunnerHandle::Get()->PostTask(
@@ skipping 12 matching lines @@
 
   start_notify_session_callbacks_.push_back(
       std::make_pair(callback, error_callback));
 
   if (start_notifications_in_progress_) {
     VLOG(2) << "Start Notifications already in progress. "
             << "Request has been queued.";
     return;
   }
 
-  [gatt_service_->GetCBPeripheral() setNotifyValue:YES
-                                 forCharacteristic:cb_characteristic_.get()];
+  [GetCBPeripheral() setNotifyValue:YES
+                  forCharacteristic:cb_characteristic_.get()];
   start_notifications_in_progress_ = true;
 }
 
 void BluetoothRemoteGattCharacteristicMac::StopNotifySession(
     BluetoothGattNotifySession* session,
     const base::Closure& callback) {
   // TODO(http://crbug.com/633191): Remove this method and use the base version.
   //   Instead, we should implement SubscribeToNotifications and
   //   UnsubscribeFromNotifications.
   base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, callback);
@@ skipping 12 matching lines @@
   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_];
+  [GetCBPeripheral() readValueForCharacteristic:cb_characteristic_];
 }
 
 void BluetoothRemoteGattCharacteristicMac::WriteRemoteCharacteristic(
     const std::vector<uint8_t>& value,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   if (!IsWritable()) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(error_callback,
                    BluetoothRemoteGattService::GATT_ERROR_NOT_PERMITTED));
     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;
   write_characteristic_value_callbacks_ =
       std::make_pair(callback, error_callback);
   base::scoped_nsobject<NSData> nsdata_value(
       [[NSData alloc] initWithBytes:value.data() length:value.size()]);
   CBCharacteristicWriteType write_type = GetCBWriteType();
-  [gatt_service_->GetCBPeripheral() writeValue:nsdata_value
-                             forCharacteristic:cb_characteristic_
-                                          type:write_type];
+  [GetCBPeripheral() writeValue:nsdata_value
+              forCharacteristic:cb_characteristic_
+                           type:write_type];
   if (write_type == CBCharacteristicWriteWithoutResponse) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(&BluetoothRemoteGattCharacteristicMac::DidWriteValue,
                    base::Unretained(this), nil));
   }
 }
 
 void BluetoothRemoteGattCharacteristicMac::SubscribeToNotifications(
     BluetoothRemoteGattDescriptor* ccc_descriptor,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   // TODO(http://crbug.com/633191): Implement this method
   NOTIMPLEMENTED();
 }
 
 void BluetoothRemoteGattCharacteristicMac::UnsubscribeFromNotifications(
     BluetoothRemoteGattDescriptor* ccc_descriptor,
     const base::Closure& callback,
     const ErrorCallback& error_callback) {
   // TODO(http://crbug.com/633191): Implement this method
   NOTIMPLEMENTED();
 }
 
+void BluetoothRemoteGattCharacteristicMac::DiscoverDescriptors() {
+  is_discovery_complete_ = false;
+  [GetCBPeripheral()
+      discoverDescriptorsForCharacteristic:cb_characteristic_.get()];
+}
+
 void BluetoothRemoteGattCharacteristicMac::DidUpdateValue(NSError* error) {
-  CHECK_EQ(gatt_service_->GetCBPeripheral().state, CBPeripheralStateConnected);
+  CHECK_EQ(GetCBPeripheral().state, CBPeripheralStateConnected);
   // This method is called when the characteristic is read and when a
   // notification is received.
   if (characteristic_value_read_or_write_in_progress_) {
     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: "
               << base::SysNSStringToUTF8(error.domain)
               << ", error code: " << error.code;
@@ skipping 16 matching lines @@
 
 void BluetoothRemoteGattCharacteristicMac::UpdateValueAndNotify() {
   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_);
 }
 
 void BluetoothRemoteGattCharacteristicMac::DidWriteValue(NSError* error) {
-  CHECK_EQ(gatt_service_->GetCBPeripheral().state, CBPeripheralStateConnected);
+  CHECK_EQ(GetCBPeripheral().state, CBPeripheralStateConnected);
   if (!characteristic_value_read_or_write_in_progress_) {
     // In case of buggy device, nothing should be done if receiving extra
     // write confirmation.
     VLOG(1) << "Write notification while no write operation pending.";
     return;
   }
   std::pair<base::Closure, ErrorCallback> callbacks;
   callbacks.swap(write_characteristic_value_callbacks_);
   characteristic_value_read_or_write_in_progress_ = false;
   if (error) {
@@ skipping 26 matching lines @@
       callback.second.Run(error_code);
     }
     return;
   }
   for (const auto& callback : reentrant_safe_callbacks) {
     callback.first.Run(base::MakeUnique<BluetoothGattNotifySession>(
         weak_ptr_factory_.GetWeakPtr()));
   }
 }
 
+void BluetoothRemoteGattCharacteristicMac::DidDiscoverDescriptors() {
+  DCHECK(!is_discovery_complete_);
+  std::unordered_set<std::string> descriptor_identifier_to_remove;
+  for (const auto& iter : gatt_descriptor_macs_) {
+    descriptor_identifier_to_remove.insert(iter.first);
+  }
+
+  for (CBDescriptor* cb_descriptor in cb_characteristic_.get().descriptors) {
+    BluetoothRemoteGattDescriptorMac* gatt_descriptor_mac =
+        GetBluetoothRemoteGattDescriptorMac(cb_descriptor);
+    if (gatt_descriptor_mac) {
+      const std::string& identifier = gatt_descriptor_mac->GetIdentifier();
+      descriptor_identifier_to_remove.erase(identifier);
+      continue;
+    }
+    gatt_descriptor_mac =
+        new BluetoothRemoteGattDescriptorMac(this, cb_descriptor);
+    const std::string& identifier = gatt_descriptor_mac->GetIdentifier();
+    auto result_iter = gatt_descriptor_macs_.insert(
+        {identifier, base::WrapUnique(gatt_descriptor_mac)});
+    DCHECK(result_iter.second);
+    GetMacAdapter()->NotifyGattDescriptorAdded(gatt_descriptor_mac);
+  }
+
+  for (const std::string& identifier : descriptor_identifier_to_remove) {
+    auto pair_to_remove = gatt_descriptor_macs_.find(identifier);
+    std::unique_ptr<BluetoothRemoteGattDescriptorMac> descriptor_to_remove;
+    pair_to_remove->second.swap(descriptor_to_remove);
+    gatt_descriptor_macs_.erase(pair_to_remove);
+    GetMacAdapter()->NotifyGattDescriptorRemoved(descriptor_to_remove.get());
+  }
+  is_discovery_complete_ = true;
+}
+
 bool BluetoothRemoteGattCharacteristicMac::IsReadable() const {
   return GetProperties() & BluetoothGattCharacteristic::PROPERTY_READ;
 }
 
 bool BluetoothRemoteGattCharacteristicMac::IsWritable() const {
   BluetoothGattCharacteristic::Properties properties = GetProperties();
   return (properties & BluetoothGattCharacteristic::PROPERTY_WRITE) ||
          (properties & PROPERTY_WRITE_WITHOUT_RESPONSE);
 }
 
 bool BluetoothRemoteGattCharacteristicMac::SupportsNotificationsOrIndications()
     const {
   BluetoothGattCharacteristic::Properties properties = GetProperties();
   return (properties & PROPERTY_NOTIFY) || (properties & PROPERTY_INDICATE);
 }
 
 CBCharacteristicWriteType BluetoothRemoteGattCharacteristicMac::GetCBWriteType()
     const {
   return (GetProperties() & BluetoothGattCharacteristic::PROPERTY_WRITE)
              ? CBCharacteristicWriteWithResponse
              : CBCharacteristicWriteWithoutResponse;
 }
 
 CBCharacteristic* BluetoothRemoteGattCharacteristicMac::GetCBCharacteristic()
     const {
   return cb_characteristic_.get();
 }
 
-bool BluetoothRemoteGattCharacteristicMac::IsDiscoveryComplete() const {
-  // TODO: Needs to replace this implementation with a boolean to monitor when
-  // descriptors are discovered. Right now, the characteristic is fully
-  // discovered as soon as it has been created.
-  return true;
+BluetoothAdapterMac* BluetoothRemoteGattCharacteristicMac::GetMacAdapter()
+    const {
+  return gatt_service_->GetMacAdapter();
 }
 
+CBPeripheral* BluetoothRemoteGattCharacteristicMac::GetCBPeripheral() const {
+  return gatt_service_->GetCBPeripheral();
+}
+
+bool BluetoothRemoteGattCharacteristicMac::IsDiscoveryComplete() const {
+  return is_discovery_complete_;
+}
+
+BluetoothRemoteGattDescriptorMac*
+BluetoothRemoteGattCharacteristicMac::GetBluetoothRemoteGattDescriptorMac(
+    CBDescriptor* cb_descriptor) const {
+  auto found = std::find_if(
+      gatt_descriptor_macs_.begin(), gatt_descriptor_macs_.end(),
+      [cb_descriptor](
+          const std::pair<const std::string,
+                          std::unique_ptr<BluetoothRemoteGattDescriptorMac>>&
+              pair) {
+        return pair.second->GetCBDescriptor() == cb_descriptor;
+      });
+  if (found == gatt_descriptor_macs_.end()) {
+    return nullptr;
+  } else {
+    return found->second.get();
+  }
+}
 }  // namespace device.