blob: 76c5be0db897a03b6e3025c5369892f31a245c7e [file] [log] [blame]
//
// 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 "service/bluetooth_instance.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/hal/bluetooth_avrcp_interface.h"
#include "types/raw_address.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;
};
AvrcpTarget(const AvrcpTarget&) = delete;
AvrcpTarget& operator=(const AvrcpTarget&) = delete;
// 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;
};
// 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(const AvrcpTargetFactory&) = delete;
AvrcpTargetFactory& operator=(const AvrcpTargetFactory&) = delete;
~AvrcpTargetFactory() override;
// BluetoothInstanceFactory override:
bool RegisterInstance(const Uuid& uuid,
const RegisterCallback& callback) override;
};
} // namespace bluetooth