Adapter changes for implementing local GATT attributes and tests.

device/bluetooth/bluez/bluetooth_adapter_bluez.cc

 // Copyright 2013 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/bluez/bluetooth_adapter_bluez.h"
 
 #include <memory>
 #include <set>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/stringprintf.h"
 #include "base/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "device/bluetooth/bluetooth_device.h"
 #include "device/bluetooth/bluetooth_discovery_session_outcome.h"
 #include "device/bluetooth/bluetooth_socket_thread.h"
 #include "device/bluetooth/bluetooth_uuid.h"
 #include "device/bluetooth/bluez/bluetooth_adapter_profile_bluez.h"
 #include "device/bluetooth/bluez/bluetooth_advertisement_bluez.h"
 #include "device/bluetooth/bluez/bluetooth_audio_sink_bluez.h"
 #include "device/bluetooth/bluez/bluetooth_device_bluez.h"
+#include "device/bluetooth/bluez/bluetooth_gatt_service_bluez.h"
 #include "device/bluetooth/bluez/bluetooth_local_gatt_service_bluez.h"
 #include "device/bluetooth/bluez/bluetooth_pairing_bluez.h"
 #include "device/bluetooth/bluez/bluetooth_socket_bluez.h"
 #include "device/bluetooth/dbus/bluetooth_adapter_client.h"
 #include "device/bluetooth/dbus/bluetooth_agent_manager_client.h"
 #include "device/bluetooth/dbus/bluetooth_agent_service_provider.h"
 #include "device/bluetooth/dbus/bluetooth_device_client.h"
+#include "device/bluetooth/dbus/bluetooth_gatt_application_service_provider.h"
+#include "device/bluetooth/dbus/bluetooth_gatt_manager_client.h"
 #include "device/bluetooth/dbus/bluetooth_input_client.h"
 #include "device/bluetooth/dbus/bluez_dbus_manager.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 #if defined(OS_CHROMEOS)
 #include "chromeos/system/devicetype.h"
 #endif
 
 using device::BluetoothAdapter;
 using device::BluetoothAudioSink;
 using device::BluetoothDevice;
 using device::BluetoothDiscoveryFilter;
 using device::BluetoothSocket;
 using device::BluetoothUUID;
 using device::UMABluetoothDiscoverySessionOutcome;
 
 namespace {
 
 // The agent path is relatively meaningless since BlueZ only permits one to
 // exist per D-Bus connection, it just has to be unique within Chromium.
 const char kAgentPath[] = "/org/chromium/bluetooth_agent";
+const char kGattApplicationObjectPath[] = "/gatt_application";
 
 void OnUnregisterAgentError(const std::string& error_name,
                             const std::string& error_message) {
   // It's okay if the agent didn't exist, it means we never saw an adapter.
   if (error_name == bluetooth_agent_manager::kErrorDoesNotExist)
     return;
 
   LOG(WARNING) << "Failed to unregister pairing agent: " << error_name << ": "
                << error_message;
 }
@@ skipping 25 matching lines @@
 // static
 base::WeakPtr<BluetoothAdapter> BluetoothAdapter::CreateAdapter(
     const InitCallback& init_callback) {
   return bluez::BluetoothAdapterBlueZ::CreateAdapter(init_callback);
 }
 
 }  // namespace device
 
 namespace bluez {
 
+namespace {
+
+void OnRegisterationErrorCallback(
+    const device::BluetoothGattService::ErrorCallback& error_callback,
+    const std::string& error_name,
+    const std::string& error_message) {
+  VLOG(1) << "Failed to [Un]register service: " << error_name << ", "
+          << error_message;
+  error_callback.Run(
+      BluetoothGattServiceBlueZ::DBusErrorToServiceError(error_name));
+}
+
+}  // namespace
+
 // static
 base::WeakPtr<BluetoothAdapter> BluetoothAdapterBlueZ::CreateAdapter(
     const InitCallback& init_callback) {
   BluetoothAdapterBlueZ* adapter = new BluetoothAdapterBlueZ(init_callback);
   return adapter->weak_ptr_factory_.GetWeakPtr();
 }
 
 void BluetoothAdapterBlueZ::Shutdown() {
   if (dbus_is_shutdown_)
     return;
@@ skipping 927 matching lines @@
   }
   delete iter->second;
   released_profiles_.erase(iter);
 }
 
 void BluetoothAdapterBlueZ::AddLocalGattService(
     std::unique_ptr<BluetoothLocalGattServiceBlueZ> service) {
   owned_gatt_services_.push_back(std::move(service));
 }
 
+void BluetoothAdapterBlueZ::RegisterGattService(
+    BluetoothLocalGattServiceBlueZ* service,
+    const base::Closure& callback,
+    const device::BluetoothGattService::ErrorCallback& error_callback) {
+  if (registered_gatt_services_.count(service->object_path()) > 0) {
+    LOG(WARNING) << "Re-registering a service that is already registered!";
+    error_callback.Run(device::BluetoothGattService::GATT_ERROR_FAILED);
+    return;
+  }
+
+  registered_gatt_services_[service->object_path()] = service;
+  gatt_application_provider_ = BluetoothGattApplicationServiceProvider::Create(
+      bluez::BluezDBusManager::Get()->GetSystemBus(),
+      GetApplicationObjectPath(), registered_gatt_services_);
+
+  RegisterApplication(callback, error_callback);
+}
+
+void BluetoothAdapterBlueZ::UnregisterGattService(
+    BluetoothLocalGattServiceBlueZ* service,
+    const base::Closure& callback,
+    const device::BluetoothGattService::ErrorCallback& error_callback) {
+  DCHECK(bluez::BluezDBusManager::Get());
+
+  if (registered_gatt_services_.count(service->object_path()) == 0) {
+    LOG(WARNING) << "Unregistering a service that isn't registered! path: "
+                 << service->object_path().value();
+    error_callback.Run(device::BluetoothGattService::GATT_ERROR_FAILED);
+    return;
+  }
+
+  registered_gatt_services_.erase(service->object_path());
+
+  // If we have no GATT services left, unregister our application.
+  if (registered_gatt_services_.size() == 0) {
+    bluez::BluezDBusManager::Get()
+        ->GetBluetoothGattManagerClient()
+        ->UnregisterApplication(
+            GetApplicationObjectPath(), callback,
+            base::Bind(&OnRegisterationErrorCallback, error_callback));
+    return;
+  }
+
+  // Otherwise, this is tricky (since at the moment, BlueZ does not support
+  // adding/removing services individually). We need to update our list of
+  // services, then unregister our application, then re-register it with the
+  // updated services. TODO(rkc): Fix this once BlueZ is fixed.
+  gatt_application_provider_ = BluetoothGattApplicationServiceProvider::Create(
+      bluez::BluezDBusManager::Get()->GetSystemBus(), object_path_,
+      registered_gatt_services_);
+
+  // Unregister our current application. If we are successful, make a call to
+  // register the application again with the current set of services.
+  bluez::BluezDBusManager::Get()
+      ->GetBluetoothGattManagerClient()
+      ->UnregisterApplication(
+          GetApplicationObjectPath(),
+          base::Bind(&BluetoothAdapterBlueZ::RegisterApplication,
+                     weak_ptr_factory_.GetWeakPtr(), callback, error_callback),
+          base::Bind(&OnRegisterationErrorCallback, error_callback));
+}
+
+// Returns the object path of the adapter.
+dbus::ObjectPath BluetoothAdapterBlueZ::GetApplicationObjectPath() const {
+  return dbus::ObjectPath(object_path_.value() + kGattApplicationObjectPath);
+}
+
 void BluetoothAdapterBlueZ::OnRegisterProfile(
     const BluetoothUUID& uuid,
     std::unique_ptr<BluetoothAdapterProfileBlueZ> profile) {
   profiles_[uuid] = profile.release();
 
   if (profile_queues_.find(uuid) == profile_queues_.end())
     return;
 
   for (auto& it : *profile_queues_[uuid])
     it.first.Run();
@@ skipping 414 matching lines @@
                         std::get<2>(params));
 
     // If the queued request resulted in a pending call, then let it
     // asynchonously process the remaining queued requests once the pending
     // call returns.
     if (discovery_request_pending_)
       return;
   }
 }
 
+void BluetoothAdapterBlueZ::RegisterApplication(
+    const base::Closure& callback,
+    const device::BluetoothGattService::ErrorCallback& error_callback) {
+  DCHECK(bluez::BluezDBusManager::Get());
+  bluez::BluezDBusManager::Get()
+      ->GetBluetoothGattManagerClient()
+      ->RegisterApplication(
+          GetApplicationObjectPath(), BluetoothGattManagerClient::Options(),
+          callback, base::Bind(&OnRegisterationErrorCallback, error_callback));
+}
+
 }  // namespace bluez