1 // 2 // Copyright (C) 2017 Google, Inc. 3 // 4 // Licensed under the Apache License, Version 2.0 (the "License"); 5 // you may not use this file except in compliance with the License. 6 // You may obtain a copy of the License at: 7 // 8 // http://www.apache.org/licenses/LICENSE-2.0 9 // 10 // Unless required by applicable law or agreed to in writing, software 11 // distributed under the License is distributed on an "AS IS" BASIS, 12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 // See the License for the specific language governing permissions and 14 // limitations under the License. 15 // 16 17 #pragma once 18 19 #include <atomic> 20 #include <mutex> 21 22 #include "base/macros.h" 23 24 #include "bluetooth/uuid.h" 25 #include "service/bluetooth_instance.h" 26 #include "service/common/bluetooth/avrcp_media_attr.h" 27 #include "service/common/bluetooth/service.h" 28 #include "service/hal/bluetooth_avrcp_interface.h" 29 30 namespace bluetooth { 31 32 class AvrcpControl : public BluetoothInstance, 33 private hal::BluetoothAvrcpInterface::ControlObserver { 34 public: 35 class Delegate { 36 public: 37 virtual void OnConnectionState(bool rc_connect, bool bt_connect, 38 const std::string& device_address) = 0; 39 40 virtual void OnTrackChanged(const std::string& device_address, 41 const AvrcpMediaAttr& attr) = 0; 42 43 virtual void OnSetAbsVolumeRequest(const std::string& device_address, 44 int32_t abs_vol, int32_t label) = 0; 45 46 virtual void OnRegisterForAbsVolumeCallbackRequest( 47 const std::string& device_address, int32_t label) = 0; 48 49 protected: 50 virtual ~Delegate() = default; 51 }; 52 53 // The destructor automatically unregisters this instance from the stack. 54 ~AvrcpControl() override; 55 56 // Assigns a delegate to this instance. |delegate| must out-live this 57 // AvrcpControl instance. 58 void SetDelegate(Delegate* delegate); 59 60 // BluetoothClientInstace overrides: 61 const Uuid& GetAppIdentifier() const override; 62 int GetInstanceId() const override; 63 64 bool Enable(); 65 void Disable(); 66 67 // Send a remote control button command. Commands which can be sent 68 // are defined here: 69 // http://1394ta.org/wp-content/uploads/2015/07/2007001.pdf 70 bool SendPassThroughCommand(const std::string& device_address, 71 uint8_t key_code, bool key_pressed); 72 73 // Send a response to a request to change absolute volume. 74 bool SetAbsVolumeResponse(const std::string& device_address, int32_t abs_vol, 75 int32_t label); 76 77 // Send a response to a register for absolute volume change callback. 78 bool RegisterForAbsVolumeCallbackResponse(const std::string& device_address, 79 int32_t response_type, 80 int32_t abs_vol, int32_t label); 81 82 private: 83 friend class AvrcpControlFactory; 84 85 // Constructor shouldn't be called directly as instances are meant to be 86 // obtained from the factory. 87 AvrcpControl(const Uuid& uuid, int control_id); 88 89 // hal::BluetoothAvrcpInterface::ControlObserver implementation: 90 void ConnectionStateCallback(bool rc_connect, bool bt_connect, 91 const RawAddress& bd_addr) override; 92 void CtrlSetabsvolCmdCallback(const RawAddress& bd_addr, uint8_t abs_vol, 93 uint8_t label) override; 94 void CtrlRegisternotificationAbsVolCallback(const RawAddress& bd_addr, 95 uint8_t label) override; 96 void CtrlTrackChangedCallback(const RawAddress& bd_addr, uint8_t num_attr, 97 btrc_element_attr_val_t* p_attrs) override; 98 99 // See getters for documentation. 100 const Uuid app_identifier_; 101 const int control_id_; 102 103 // Mutex that synchronizes access to the entries below. 104 std::mutex mutex_; 105 106 // Raw handle to the Delegate, which must outlive this AvrcpControl instance. 107 std::mutex delegate_mutex_; 108 Delegate* delegate_ = nullptr; 109 110 DISALLOW_COPY_AND_ASSIGN(AvrcpControl); 111 }; 112 113 // AvrcpControlFactory is used to register and obtain a per-application 114 // AvrcpControl 115 // instance. Users should call RegisterClient to obtain their own unique 116 // AvrcpControl instance that has been registered with the Bluetooth stack. 117 class AvrcpControlFactory 118 : public BluetoothInstanceFactory, 119 private hal::BluetoothAvrcpInterface::ControlObserver { 120 public: 121 // Don't construct/destruct directly except in tests. Instead, obtain a handle 122 // from an Adapter instance. 123 AvrcpControlFactory(); 124 ~AvrcpControlFactory() override; 125 126 // BluetoothInstanceFactory override: 127 bool RegisterInstance(const Uuid& uuid, 128 const RegisterCallback& callback) override; 129 130 private: 131 std::atomic<int> next_control_id_{0}; 132 DISALLOW_COPY_AND_ASSIGN(AvrcpControlFactory); 133 }; 134 135 } // namespace bluetooth 136