blob: 63bc8a064669c40c0b54f0b67a587c7790d5451b [file] [log] [blame]
/*
* Copyright 2018 The Android Open Source Project
*
* 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 <base/bind.h>
#include <base/memory/weak_ptr.h>
#include <map>
#include <memory>
#include "avrcp_internal.h"
#include "avrcp_packet.h"
#include "device.h"
#include "packet.h"
#include "raw_address.h"
namespace bluetooth {
namespace avrcp {
// TODO: Remove the singleton design structure for this class.
// AvrcpTargetService is already a singleton and can manage the lifetime of this
// object. multiple singleton objects can lead to code that is hard to test and
// have hard to debug lifetimes.
// TODO (apanicke): Use a device factory instead of just the constructor in
// order to create device objects. This will allow us to create specific device
// classes that can provide interop fixes for certain badly behaving devices.
/**
* ConnectionHandler handles SDP, connecting to remote AVRCP devices
* and multiplexing/delivering messages to devices.
*/
class ConnectionHandler {
public:
/**
* This callback is used to return a new device after a connection attempt.
* A reference to the new Avrcp device is located in the shared_ptr.
* If there was an issue during connection the pointer value will be null.
*/
using ConnectionCallback = base::Callback<void(std::shared_ptr<Device>)>;
/**
* Initializes the singleton instance and sets up SDP. Also Opens the
* AVRCP Acceptor to receive connection requests from a remote device.
*
* Params:
* callback - A callback that gets called any time a new AVRCP Device
* is connected. Will return nullpointer if a device fails
* to connect via ConnectDevice();
*
* TODO: Add message loop to determine which thread events are posted to
*/
static bool Initialize(const ConnectionCallback& callback,
AvrcpInterface* avrcp, SdpInterface* sdp,
VolumeInterface* vol);
/**
* Clears the singleton and tears down SDP
*/
static bool CleanUp();
/**
* Get the singleton instance of Connection Handler
*/
static ConnectionHandler* Get();
/**
* Attempt to connect AVRCP on a device. The callback will be called with
* either a smart pointer pointing to the connected AVRCP device or null
* if the connection failed.
*
* The order of operations for this function is as follows.
* 1. Perform SDP on remote device
* 2. Connect the AVCTP Channel
* 2. (Optional) If supported connect the AVCTP Browse channel
* 4. Call the provided callback with the new
*
* Params:
* bdaddr - Bluetooth address of device to connect to
* callback - The function that gets called when a connection succeeds or
* fails. The pointer being cleared implies that the connection
* failed.
*
* Returns:
* true if the connection attempt starts, false if there are no resources to
* connect AVRCP
*/
virtual bool ConnectDevice(const RawAddress& bdaddr);
/**
* Disconnects AVRCP from a device that was successfully connected too using
* ConnectionHandler::ConnectDevice
*
* Returns:
* true if the AVRCP was successfully disconnected for the device or false
* if the device was already disconnected or in an invalid state
*/
virtual bool DisconnectDevice(const RawAddress& bdaddr);
virtual std::vector<std::shared_ptr<Device>> GetListOfDevices() const;
/**
* Provide a custom ConnectionHandler that will be returned by Get().
* Initialize and CleanUp should not be called as the owner of the handler
* determines its lifetime.
*/
static void InitForTesting(ConnectionHandler* handler);
private:
AvrcpInterface* avrc_;
SdpInterface* sdp_;
VolumeInterface* vol_;
ConnectionCallback connection_cb_;
std::map<uint8_t, std::shared_ptr<Device>> device_map_;
// TODO (apanicke): Replace the features with a class that has individual
// fields.
std::map<RawAddress, uint16_t> feature_map_;
static ConnectionHandler* instance_;
using SdpCallback = base::Callback<void(uint16_t status, uint16_t version,
uint16_t features)>;
virtual bool SdpLookup(const RawAddress& bdaddr, SdpCallback cb);
void SdpCb(const RawAddress& bdaddr, SdpCallback cb,
tSDP_DISCOVERY_DB* disc_db, uint16_t status);
virtual bool AvrcpConnect(bool initiator, const RawAddress& bdaddr);
// Callbacks when connecting to a device
void InitiatorControlCb(uint8_t handle, uint8_t event, uint16_t result,
const RawAddress* peer_addr);
void AcceptorControlCb(uint8_t handle, uint8_t event, uint16_t result,
const RawAddress* peer_addr);
void MessageCb(uint8_t handle, uint8_t label, uint8_t opcode,
tAVRC_MSG* p_msg);
ConnectionHandler() : weak_ptr_factory_(this){};
virtual ~ConnectionHandler() = default;
// Callback for when sending a response to a device
void SendMessage(uint8_t handle, uint8_t label, bool browse,
std::unique_ptr<::bluetooth::PacketBuilder> message);
base::WeakPtrFactory<ConnectionHandler> weak_ptr_factory_;
DISALLOW_COPY_AND_ASSIGN(ConnectionHandler);
};
} // namespace avrcp
} // namespace bluetooth