Implement A2DP source and AVRCP target binder servers
Bug: 64231556
Test: On device.
Change-Id: I57136d5550e8e52626a1e7eb26b7d8c02cd94eb5
diff --git a/service/avrcp_target.h b/service/avrcp_target.h
new file mode 100644
index 0000000..8c2bcce
--- /dev/null
+++ b/service/avrcp_target.h
@@ -0,0 +1,179 @@
+//
+// Copyright (C) 2017 Google, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at:
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#pragma once
+
+#include <mutex>
+#include <string>
+#include <vector>
+
+#include "base/macros.h"
+
+#include "service/common/bluetooth/avrcp_int_value.h"
+#include "service/common/bluetooth/avrcp_register_notification_response.h"
+#include "service/common/bluetooth/avrcp_string_value.h"
+
+#include "service/bluetooth_instance.h"
+#include "service/hal/bluetooth_avrcp_interface.h"
+
+namespace bluetooth {
+
+// Note: presently this only supports
+// (BTRC_FEAT_METADATA | BTRC_FEAT_ABSOLUTE_VOLUME)
+class AvrcpTarget : public BluetoothInstance,
+ private hal::BluetoothAvrcpInterface::TargetObserver {
+ public:
+ // We only allow one instance of this object at a time.
+ static const int kSingletonInstanceId;
+
+ class Delegate {
+ public:
+ virtual void OnGetRemoteFeatures(const std::string& addr,
+ int32_t features) = 0;
+ virtual void OnGetPlayStatus(const std::string& addr) = 0;
+ virtual void OnListPlayerAppAttr(const std::string& addr) = 0;
+ virtual void OnListPlayerAppValues(const std::string& addr,
+ int32_t attr_id) = 0;
+ virtual void OnGetPlayerAppValue(const std::string& addr,
+ const std::vector<int32_t>& attrs) = 0;
+ virtual void OnGetPlayerAppAttrsText(const std::string& addr,
+ const std::vector<int32_t>& attrs) = 0;
+ virtual void OnGetPlayerAppValuesText(
+ const std::string& addr, int32_t attr_id,
+ const std::vector<int32_t>& values) = 0;
+ virtual void OnSetPlayerAppValue(
+ const std::string& addr, const std::vector<AvrcpIntValue>& values) = 0;
+ virtual void OnGetElementAttrs(const std::string& addr,
+ const std::vector<int32_t>& attrs) = 0;
+ virtual void OnRegisterNotification(const std::string& addr,
+ int32_t event_id, uint32_t param) = 0;
+ virtual void OnVolumeChange(const std::string& addr, int32_t volume,
+ int32_t ctype) = 0;
+ virtual void OnPassThroughCommand(const std::string& addr, int32_t id,
+ int32_t key_state) = 0;
+
+ protected:
+ virtual ~Delegate() = default;
+ };
+
+ // The destructor automatically unregisters this instance from the stack.
+ ~AvrcpTarget() override;
+
+ // Assigns a delegate to this instance. |delegate| must out-live this
+ // AvrcpTarget instance.
+ void SetDelegate(Delegate* delegate);
+
+ // BluetoothClientInstace overrides:
+ const Uuid& GetAppIdentifier() const override;
+ int GetInstanceId() const override;
+
+ bool Enable();
+ void Disable();
+
+ bool GetPlayStatusResponse(const std::string& addr, int32_t play_status,
+ uint32_t song_len, uint32_t song_pos);
+
+ bool ListPlayerAppAttrResponse(const std::string& addr,
+ const std::vector<int32_t>& attrs);
+
+ bool GetPlayerAppValueResponse(const std::string& addr,
+ const std::vector<AvrcpIntValue>& values);
+
+ bool GetPlayerAppAttrTextResponse(const std::string& addr,
+ const std::vector<AvrcpStringValue>& attrs);
+
+ bool GetPlayerAppValueTextResponse(
+ const std::string& addr, const std::vector<AvrcpStringValue>& attrs);
+
+ bool GetElementAttrResponse(const std::string& addr,
+ const std::vector<AvrcpStringValue>& attrs);
+
+ bool SetPlayerAppValueResponse(const std::string& addr, int32_t rsp_status);
+
+ bool RegisterNotificationResponse(
+ int32_t event_id, int32_t type,
+ const AvrcpRegisterNotificationResponse& param);
+
+ bool SetVolume(int volume);
+
+ private:
+ friend class AvrcpTargetFactory;
+
+ // Constructor shouldn't be called directly as instances are meant to be
+ // obtained from the factory.
+ AvrcpTarget(const Uuid& uuid);
+
+ // hal::BluetoothAvrcpInterface::TargetObserver implementation:
+ void RemoteFeaturesCallback(const RawAddress& bd_addr,
+ btrc_remote_features_t features) override;
+ void GetPlayStatusCallback(const RawAddress& bd_addr) override;
+ void ListPlayerAppAttrCallback(const RawAddress& bd_addr) override;
+ void ListPlayerAppValuesCallback(btrc_player_attr_t attr_id,
+ const RawAddress& bd_addr) override;
+ void GetPlayerAppValueCallback(uint8_t num_attr, btrc_player_attr_t* p_attrs,
+ const RawAddress& bd_addr) override;
+ void GetPlayerAppAttrsTextCallback(uint8_t num_attr,
+ btrc_player_attr_t* p_attrs,
+ const RawAddress& bd_addr) override;
+ void GetPlayerAppValuesTextCallback(uint8_t attr_id, uint8_t num_val,
+ uint8_t* p_vals,
+ const RawAddress& bd_addr) override;
+ void SetPlayerAppValueCallback(btrc_player_settings_t* p_vals,
+ const RawAddress& bd_addr) override;
+ void GetElementAttrCallback(uint8_t num_attr, btrc_media_attr_t* p_attrs,
+ const RawAddress& bd_addr) override;
+ void RegisterNotificationCallback(btrc_event_id_t event_id, uint32_t param,
+ const RawAddress& bd_addr) override;
+ void VolumeChangeCallback(uint8_t volume, uint8_t ctype,
+ const RawAddress& bd_addr) override;
+ void PassthroughCmdCallback(int id, int key_state,
+ const RawAddress& bd_addr) override;
+
+ // See getters for documentation.
+ const Uuid app_identifier_;
+
+ // Mutex that synchronizes access to the entries below.
+ std::mutex mutex_;
+
+ // Raw handle to the Delegate, which must outlive this AvrcpTarget instance.
+ std::mutex delegate_mutex_;
+ Delegate* delegate_ = nullptr;
+
+ DISALLOW_COPY_AND_ASSIGN(AvrcpTarget);
+};
+
+// AvrcpTargetFactory is used to register and obtain a per-application
+// AvrcpTarget
+// instance. Users should call RegisterClient to obtain their own unique
+// AvrcpTarget instance that has been registered with the Bluetooth stack.
+class AvrcpTargetFactory
+ : public BluetoothInstanceFactory,
+ private hal::BluetoothAvrcpInterface::TargetObserver {
+ public:
+ // Don't construct/destruct directly except in tests. Instead, obtain a handle
+ // from an Adapter instance.
+ AvrcpTargetFactory();
+ ~AvrcpTargetFactory() override;
+
+ // BluetoothInstanceFactory override:
+ bool RegisterInstance(const Uuid& uuid,
+ const RegisterCallback& callback) override;
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(AvrcpTargetFactory);
+};
+
+} // namespace bluetooth