| /* |
| * 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 |