device/bluetooth:Implement BluetoothMediaEndpointServiceProvider delegate and media-related overrid…

chromeos/dbus/bluetooth_media_endpoint_service_provider.cc

 // Copyright 2014 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 "chromeos/dbus/bluetooth_media_endpoint_service_provider.h"
 
-#include <string>
-
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/threading/platform_thread.h"
+#include "chromeos/dbus/bluetooth_media_transport_client.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/fake_bluetooth_media_endpoint_service_provider.h"
 #include "dbus/bus.h"
 #include "dbus/exported_object.h"
 #include "dbus/message.h"
 
 namespace {
 
 // TODO(mcchou): Move these constants to dbus/service_constants.h.
 // Bluetooth Media Endpoint service identifier.
 const char kBluetoothMediaEndpointInterface[] = "org.bluez.MediaEndpoint1";
 
-// Bluetooth Media Endpoint methods.
+// Method names in Bluetooth Media Endpoint interface.
 const char kSetConfiguration[] = "SetConfiguration";
 const char kSelectConfiguration[] = "SelectConfiguration";
 const char kClearConfiguration[] = "ClearConfiguration";
 const char kRelease[] = "Release";
 
+const uint8_t kInvalidCodec = 0xff;
+const char kInvalidState[] = "unknown";

[armansito, 2015/02/12 05:20:44]

I would move these two to the header as static class members, since other code
has no way to compare against these otherwise, unless you think that other code
won't ever see these.

[Miao, 2015/02/12 19:08:03]

In SetConfiguration, we compare the values of state and codec with these two
constants. If they match, the delegate won't be invoked anyway, so other code
won't need these.

+
 }  // namespace
 
 namespace chromeos {
 
 // The BluetoothMediaEndopintServiceProvider implementation used in production.
 class CHROMEOS_EXPORT BluetoothMediaEndpointServiceProviderImpl
     : public BluetoothMediaEndpointServiceProvider {
  public:
   BluetoothMediaEndpointServiceProviderImpl(dbus::Bus* bus,
                                             const dbus::ObjectPath& object_path,
@@ skipping 69 matching lines @@
   }
 
   // Called by dbus:: when the remote device connects to the Media Endpoint.
   void SetConfiguration(dbus::MethodCall* method_call,
                         dbus::ExportedObject::ResponseSender response_sender) {
     DCHECK(OnOriginThread());
     DCHECK(delegate_);
 
     dbus::MessageReader reader(method_call);
     dbus::ObjectPath transport_path;
-    dbus::MessageReader properties(method_call);
+    dbus::MessageReader property_reader(method_call);
     if (!reader.PopObjectPath(&transport_path) ||
-        !reader.PopArray(&properties)) {
+        !reader.PopArray(&property_reader)) {
       LOG(WARNING) << "SetConfiguration called with incorrect parameters: "
                    << method_call->ToString();
       return;
     }
 
-    delegate_->SetConfiguration(transport_path, properties);
+    // Parses |properties| and passes the property set as a
+    // Delegate::TransportProperties structure to |delegate_|.
+    Delegate::TransportProperties properties;
+    while (property_reader.HasMoreData()) {
+      dbus::MessageReader dict_entry_reader(nullptr);
+      std::string key;
+      if (!property_reader.PopDictEntry(&dict_entry_reader) ||
+          !dict_entry_reader.PopString(&key)) {
+        LOG(WARNING) << "SetConfiguration called with incorrect parameters: "
+                     << method_call->ToString();
+      } else if (key == BluetoothMediaTransportClient::kDeviceProperty) {
+        dict_entry_reader.PopVariantOfObjectPath(&properties.device);
+      } else if (key == BluetoothMediaTransportClient::kUUIDProperty) {
+        dict_entry_reader.PopVariantOfString(&properties.uuid);
+      } else if (key == BluetoothMediaTransportClient::kCodecProperty) {
+        dict_entry_reader.PopVariantOfByte(&properties.codec);
+      } else if (key == BluetoothMediaTransportClient::kConfigurationProperty) {
+        dbus::MessageReader variant_reader(nullptr);
+        const uint8_t* bytes = nullptr;
+        size_t length = 0;
+        dict_entry_reader.PopVariant(&variant_reader);
+        variant_reader.PopArrayOfBytes(&bytes, &length);
+        properties.configuration.assign(bytes, bytes + length);
+      } else if (key == BluetoothMediaTransportClient::kStateProperty) {
+        dict_entry_reader.PopVariantOfString(&properties.state);
+      } else if (key == BluetoothMediaTransportClient::kDelayProperty) {
+        properties.delay.reset(new uint16_t());
+        dict_entry_reader.PopVariantOfUint16(properties.delay.get());
+      } else if (key == BluetoothMediaTransportClient::kVolumeProperty) {
+        properties.volume.reset(new uint16_t());
+        dict_entry_reader.PopVariantOfUint16(properties.volume.get());
+      }
+    }
+
+    if (properties.codec != kInvalidCodec &&
+        properties.state != kInvalidState) {

[armansito, 2015/02/12 05:20:44]

nit: You should log something here in the case of an error.

[Miao, 2015/02/12 19:08:03]

Done.

+      delegate_->SetConfiguration(transport_path, properties);
+    }
 
     response_sender.Run(dbus::Response::FromMethodCall(method_call));

[armansito, 2015/02/12 05:20:44]

I thought this method had no response?

[Miao, 2015/02/12 19:08:03]

It is an empty response, just like the response of Release().

   }
 
   // Called by dbus:: when the remote device receives the configuration for
   // media transport.
   void SelectConfiguration(
       dbus::MethodCall* method_call,
       dbus::ExportedObject::ResponseSender response_sender) {
     DCHECK(OnOriginThread());
     DCHECK(delegate_);
 
@@ skipping 39 matching lines @@
     response_sender.Run(dbus::Response::FromMethodCall(method_call));
   }
 
   // Called by Bluetooth daemon to do the clean up after unregistering the Media
   // Endpoint.
   void Release(dbus::MethodCall* method_call,
                dbus::ExportedObject::ResponseSender response_sender) {
     DCHECK(OnOriginThread());
     DCHECK(delegate_);
 
-    delegate_->Release();
+    delegate_->Released();
 
     response_sender.Run(dbus::Response::FromMethodCall(method_call));
   }
 
   // Called by Delegate to response to a method requiring transport
   // configuration.
   void OnConfiguration(dbus::MethodCall* method_call,
                        dbus::ExportedObject::ResponseSender response_sender,
                        const std::vector<uint8_t>& configuration) {
     DCHECK(OnOriginThread());
@@ skipping 32 matching lines @@
   // Weak pointer factory for generating 'this' printers that might live longer
   // than we do.
   // Note This should remain the last member so it'll be destroyed and
   // invalidate it's weak pointers before any other members are destroyed.
   base::WeakPtrFactory<BluetoothMediaEndpointServiceProviderImpl>
       weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(BluetoothMediaEndpointServiceProviderImpl);
 };
 
+BluetoothMediaEndpointServiceProvider::Delegate::TransportProperties::
+    TransportProperties()
+    : codec(kInvalidCodec),
+      state(kInvalidState) {
+}
+
+BluetoothMediaEndpointServiceProvider::Delegate::TransportProperties::
+    ~TransportProperties() {
+}
+
 BluetoothMediaEndpointServiceProvider::BluetoothMediaEndpointServiceProvider() {
 }
 
-BluetoothMediaEndpointServiceProvider::~BluetoothMediaEndpointServiceProvider()
-{}
+BluetoothMediaEndpointServiceProvider::
+    ~BluetoothMediaEndpointServiceProvider() {
+}
 
 BluetoothMediaEndpointServiceProvider*
     BluetoothMediaEndpointServiceProvider::Create(
     dbus::Bus* bus,
     const dbus::ObjectPath& object_path,
     Delegate* delegate) {
   // Returns a real implementation.
   if (!DBusThreadManager::Get()->IsUsingStub(DBusClientBundle::BLUETOOTH)) {
     return new BluetoothMediaEndpointServiceProviderImpl(
         bus, object_path, delegate);
   }
   // Returns a fake implementation.
   return new FakeBluetoothMediaEndpointServiceProvider(object_path, delegate);
 }
 
 }  // namespace chromeos