components/arc: implement multi advertising

components/arc/bluetooth/arc_bluetooth_bridge.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 "components/arc/bluetooth/arc_bluetooth_bridge.h"
 
 #include <bluetooth/bluetooth.h>
 #include <fcntl.h>
 #include <stddef.h>
 #include <sys/socket.h>
@@ skipping 49 matching lines @@
     BluetoothGattCharacteristic::Permission::PERMISSION_READ |
     BluetoothGattCharacteristic::Permission::PERMISSION_READ_ENCRYPTED |
     BluetoothGattCharacteristic::Permission::
         PERMISSION_READ_ENCRYPTED_AUTHENTICATED;
 constexpr uint32_t kGattWritePermission =
     BluetoothGattCharacteristic::Permission::PERMISSION_WRITE |
     BluetoothGattCharacteristic::Permission::PERMISSION_WRITE_ENCRYPTED |
     BluetoothGattCharacteristic::Permission::
         PERMISSION_WRITE_ENCRYPTED_AUTHENTICATED;
 constexpr int32_t kInvalidGattAttributeHandle = -1;
+constexpr int32_t kInvalidAdvertisementHandle = -1;
 // Bluetooth Specification Version 4.2 Vol 3 Part F Section 3.2.2
 // An attribute handle of value 0xFFFF is known as the maximum attribute handle.
 constexpr int32_t kMaxGattAttributeHandle = 0xFFFF;
 // Bluetooth Specification Version 4.2 Vol 3 Part F Section 3.2.9
 // The maximum length of an attribute value shall be 512 octets.
 constexpr int kMaxGattAttributeLength = 512;
 // Copied from Android at system/bt/stack/btm/btm_ble_int.h
 // https://goo.gl/k7PM6u
 constexpr uint16_t kAndroidMBluetoothVersionNumber = 95;
-constexpr uint16_t kMaxAdvertisement = 5;
 
 using GattStatusCallback =
     base::Callback<void(arc::mojom::BluetoothGattStatus)>;
 using GattReadCallback =
     base::Callback<void(arc::mojom::BluetoothGattValuePtr)>;
 
 // Example of identifier: /org/bluez/hci0/dev_E0_CF_65_8C_86_1A/service001a
 // Convert the last 4 characters of |identifier| to an
 // int, by interpreting them as hexadecimal digits.
 int ConvertGattIdentifierToId(const std::string identifier) {
@@ skipping 1295 matching lines @@
   OnGattOperationDone(callback);
 }
 
 void ArcBluetoothBridge::SendIndication(
     int32_t attribute_handle,
     mojom::BluetoothAddressPtr address,
     bool confirm,
     mojo::Array<uint8_t> value,
     const SendIndicationCallback& callback) {}
 
+bool ArcBluetoothBridge::GetAdvertisementHandle(int32_t* adv_handle) {
+  for (int i = 0; i < kMaxAdvertisements; i++) {
+    if (advertisements_.find(i) == advertisements_.end()) {
+      *adv_handle = i;
+      return true;
+    }
+  }
+  return false;
+}
+
+void ArcBluetoothBridge::ReserveAdvertisementHandle(
+    const ReserveAdvertisementHandleCallback& callback) {
+  DCHECK(CalledOnValidThread());
+  // Find an empty advertisement slot.
+  int32_t adv_handle;
+  if (!GetAdvertisementHandle(&adv_handle)) {
+    LOG(WARNING) << "Out of space for advertisement data";
+    callback.Run(mojom::BluetoothGattStatus::GATT_FAILURE,
+                 kInvalidAdvertisementHandle);
+    return;
+  }
+
+  // We have a handle. Put an entry in the map to reserve it.
+  advertisements_[adv_handle] = scoped_refptr<device::BluetoothAdvertisement>();

[rickyz (no longer on Chrome), 2016/08/29 01:09:23]

nit: = nullptr for consistency with below

+
+  // The advertisement will be registered when we get the call
+  // to SetAdvertisingData. For now, just return the adv_handle.
+  callback.Run(mojom::BluetoothGattStatus::GATT_SUCCESS, adv_handle);
+}
+
+void ArcBluetoothBridge::BroadcastAdvertisement(
+    int32_t adv_handle,
+    mojom::BluetoothAdvertisementPtr advertisement,
+    const BroadcastAdvertisementCallback& callback) {
+  DCHECK(CalledOnValidThread());
+  if (advertisements_.find(adv_handle) == advertisements_.end()) {
+    callback.Run(mojom::BluetoothGattStatus::GATT_FAILURE);
+    return;
+  }
+
+  auto adv_data =
+      advertisement.To<std::unique_ptr<device::BluetoothAdvertisement::Data>>();
+  if (!adv_data) {
+    LOG(WARNING) << "Tried to broadcast malformed advertisement data for "
+                 << "handle " << adv_handle;
+    callback.Run(mojom::BluetoothGattStatus::GATT_FAILURE);
+    return;
+  }
+
+  if (!advertisements_[adv_handle]) {
+    OnReadyToRegisterAdvertisement(callback, adv_handle, std::move(adv_data));
+    return;
+  }
+
+  advertisements_[adv_handle]->Unregister(
+      base::Bind(&ArcBluetoothBridge::OnReadyToRegisterAdvertisement,
+                 weak_factory_.GetWeakPtr(), callback, adv_handle,
+                 base::Passed(std::move(adv_data))),
+      base::Bind(&ArcBluetoothBridge::OnRegisterAdvertisementError,
+                 weak_factory_.GetWeakPtr(), callback, adv_handle));
+}
+
+void ArcBluetoothBridge::ReleaseAdvertisementHandle(
+    int32_t adv_handle,
+    const ReleaseAdvertisementHandleCallback& callback) {
+  DCHECK(CalledOnValidThread());
+  if (advertisements_.find(adv_handle) == advertisements_.end()) {
+    callback.Run(mojom::BluetoothGattStatus::GATT_FAILURE);
+    return;
+  }
+
+  if (!advertisements_[adv_handle]) {
+    advertisements_.erase(adv_handle);
+    callback.Run(mojom::BluetoothGattStatus::GATT_SUCCESS);
+    return;
+  }
+
+  advertisements_[adv_handle]->Unregister(
+      base::Bind(&ArcBluetoothBridge::OnUnregisterAdvertisementDone,
+                 weak_factory_.GetWeakPtr(), callback, adv_handle),
+      base::Bind(&ArcBluetoothBridge::OnUnregisterAdvertisementError,
+                 weak_factory_.GetWeakPtr(), callback, adv_handle));
+}
+
+void ArcBluetoothBridge::OnReadyToRegisterAdvertisement(
+    const BroadcastAdvertisementCallback& callback,
+    int32_t adv_handle,
+    std::unique_ptr<device::BluetoothAdvertisement::Data> data) {
+  bluetooth_adapter_->RegisterAdvertisement(
+      std::move(data),
+      base::Bind(&ArcBluetoothBridge::OnRegisterAdvertisementDone,
+                 weak_factory_.GetWeakPtr(), callback, adv_handle),
+      base::Bind(&ArcBluetoothBridge::OnRegisterAdvertisementError,
+                 weak_factory_.GetWeakPtr(), callback, adv_handle));
+}
+
+void ArcBluetoothBridge::OnRegisterAdvertisementDone(
+    const BroadcastAdvertisementCallback& callback,
+    int32_t adv_handle,
+    scoped_refptr<BluetoothAdvertisement> advertisement) {
+  advertisements_[adv_handle] = advertisement;

[rickyz (no longer on Chrome), 2016/08/24 21:47:30]

Can std::move advertisement

[Eric Caruso, 2016/08/24 22:24:42]

Since it's a scoped_refptr, it seems kind of superfluous to do that. At best
it's a minor optimization.

[Eric Caruso, 2016/08/24 22:26:11]

(Do we do this with std::move elsewhere?)

[rickyz (no longer on Chrome), 2016/08/29 01:09:23]

Yeah, we do - it's a minor optimization (avoids an unnecessary
increment/decrement), but it's the idiomatic thing to do.

+  callback.Run(mojom::BluetoothGattStatus::GATT_SUCCESS);
+}
+
+void ArcBluetoothBridge::OnRegisterAdvertisementError(
+    const BroadcastAdvertisementCallback& callback,
+    int32_t adv_handle,
+    BluetoothAdvertisement::ErrorCode error_code) {
+  LOG(WARNING) << "Failed to register advertisement for handle " << adv_handle
+               << ", error code = " << error_code;
+  advertisements_[adv_handle] = nullptr;
+  callback.Run(mojom::BluetoothGattStatus::GATT_FAILURE);
+}
+
+void ArcBluetoothBridge::OnUnregisterAdvertisementDone(
+    const ReleaseAdvertisementHandleCallback& callback,
+    int32_t adv_handle) {
+  advertisements_.erase(adv_handle);
+  callback.Run(mojom::BluetoothGattStatus::GATT_SUCCESS);
+}
+
+void ArcBluetoothBridge::OnUnregisterAdvertisementError(
+    const ReleaseAdvertisementHandleCallback& callback,
+    int32_t adv_handle,
+    BluetoothAdvertisement::ErrorCode error_code) {
+  LOG(WARNING) << "Failed to unregister advertisement for handle " << adv_handle
+               << ", error code = " << error_code;
+  advertisements_.erase(adv_handle);
+  callback.Run(mojom::BluetoothGattStatus::GATT_FAILURE);
+}
+
 void ArcBluetoothBridge::OnDiscoveryError() {
   LOG(WARNING) << "failed to change discovery state";
 }
 
 void ArcBluetoothBridge::OnPairing(mojom::BluetoothAddressPtr addr) const {
   if (!HasBluetoothInstance())
     return;
 
   arc_bridge_service()->bluetooth()->instance()->OnBondStateChanged(
       mojom::BluetoothStatus::SUCCESS, std::move(addr),
@@ skipping 184 matching lines @@
     properties.push_back(std::move(btp));
   }
   if (type == mojom::BluetoothPropertyType::ALL ||
       type == mojom::BluetoothPropertyType::LOCAL_LE_FEATURES) {
     // TODO(crbug.com/637171) Investigate all the le_features.
     mojom::BluetoothPropertyPtr btp = mojom::BluetoothProperty::New();
     mojom::BluetoothLocalLEFeaturesPtr le_features =
         mojom::BluetoothLocalLEFeatures::New();
     le_features->version_supported = kAndroidMBluetoothVersionNumber;
     le_features->local_privacy_enabled = 0;
-    le_features->max_adv_instance = kMaxAdvertisement;
+    le_features->max_adv_instance = kMaxAdvertisements;
     le_features->rpa_offload_supported = 0;
     le_features->max_irk_list_size = 0;
     le_features->max_adv_filter_supported = 0;
     le_features->activity_energy_info_supported = 0;
     le_features->scan_result_storage_size = 0;
     le_features->total_trackable_advertisers = 0;
     le_features->extended_scan_support = false;
     le_features->debug_logging_supported = false;
     btp->set_local_le_features(std::move(le_features));
     properties.push_back(std::move(btp));
@@ skipping 141 matching lines @@
   LOG(WARNING) << "Bluetooth instance is too old (version " << version
                << ") need version " << version_need;
   return false;
 }
 
 bool ArcBluetoothBridge::CalledOnValidThread() {
   return thread_checker_.CalledOnValidThread();
 }
 
 }  // namespace arc