You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
180 lines
7.1 KiB
180 lines
7.1 KiB
//
|
|
// 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
|