service/avrcp_target.h

   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 <mutex>
  20 #include <string>
  21 #include <vector>
  22
  23 #include "base/macros.h"
  24
  25 #include "service/common/bluetooth/avrcp_int_value.h"
  26 #include "service/common/bluetooth/avrcp_register_notification_response.h"
  27 #include "service/common/bluetooth/avrcp_string_value.h"
  28
  29 #include "service/bluetooth_instance.h"
  30 #include "service/hal/bluetooth_avrcp_interface.h"
  31
  32 namespace bluetooth {
  33
  34 // Note: presently this only supports
  35 // (BTRC_FEAT_METADATA | BTRC_FEAT_ABSOLUTE_VOLUME)
  36 class AvrcpTarget : public BluetoothInstance,
  37                     private hal::BluetoothAvrcpInterface::TargetObserver {
  38  public:
  39   // We only allow one instance of this object at a time.
  40   static const int kSingletonInstanceId;
  41
  42   class Delegate {
  43    public:
  44     virtual void OnGetRemoteFeatures(const std::string& addr,
  45                                      int32_t features) = 0;
  46     virtual void OnGetPlayStatus(const std::string& addr) = 0;
  47     virtual void OnListPlayerAppAttr(const std::string& addr) = 0;
  48     virtual void OnListPlayerAppValues(const std::string& addr,
  49                                        int32_t attr_id) = 0;
  50     virtual void OnGetPlayerAppValue(const std::string& addr,
  51                                      const std::vector<int32_t>& attrs) = 0;
  52     virtual void OnGetPlayerAppAttrsText(const std::string& addr,
  53                                          const std::vector<int32_t>& attrs) = 0;
  54     virtual void OnGetPlayerAppValuesText(
  55         const std::string& addr, int32_t attr_id,
  56         const std::vector<int32_t>& values) = 0;
  57     virtual void OnSetPlayerAppValue(
  58         const std::string& addr, const std::vector<AvrcpIntValue>& values) = 0;
  59     virtual void OnGetElementAttrs(const std::string& addr,
  60                                    const std::vector<int32_t>& attrs) = 0;
  61     virtual void OnRegisterNotification(const std::string& addr,
  62                                         int32_t event_id, uint32_t param) = 0;
  63     virtual void OnVolumeChange(const std::string& addr, int32_t volume,
  64                                 int32_t ctype) = 0;
  65     virtual void OnPassThroughCommand(const std::string& addr, int32_t id,
  66                                       int32_t key_state) = 0;
  67
  68    protected:
  69     virtual ~Delegate() = default;
  70   };
  71
  72   // The destructor automatically unregisters this instance from the stack.
  73   ~AvrcpTarget() override;
  74
  75   // Assigns a delegate to this instance. |delegate| must out-live this
  76   // AvrcpTarget instance.
  77   void SetDelegate(Delegate* delegate);
  78
  79   // BluetoothClientInstace overrides:
  80   const Uuid& GetAppIdentifier() const override;
  81   int GetInstanceId() const override;
  82
  83   bool Enable();
  84   void Disable();
  85
  86   bool GetPlayStatusResponse(const std::string& addr, int32_t play_status,
  87                              uint32_t song_len, uint32_t song_pos);
  88
  89   bool ListPlayerAppAttrResponse(const std::string& addr,
  90                                  const std::vector<int32_t>& attrs);
  91
  92   bool GetPlayerAppValueResponse(const std::string& addr,
  93                                  const std::vector<AvrcpIntValue>& values);
  94
  95   bool GetPlayerAppAttrTextResponse(const std::string& addr,
  96                                     const std::vector<AvrcpStringValue>& attrs);
  97
  98   bool GetPlayerAppValueTextResponse(
  99       const std::string& addr, const std::vector<AvrcpStringValue>& attrs);
 100
 101   bool GetElementAttrResponse(const std::string& addr,
 102                               const std::vector<AvrcpStringValue>& attrs);
 103
 104   bool SetPlayerAppValueResponse(const std::string& addr, int32_t rsp_status);
 105
 106   bool RegisterNotificationResponse(
 107       int32_t event_id, int32_t type,
 108       const AvrcpRegisterNotificationResponse& param);
 109
 110   bool SetVolume(int volume);
 111
 112  private:
 113   friend class AvrcpTargetFactory;
 114
 115   // Constructor shouldn't be called directly as instances are meant to be
 116   // obtained from the factory.
 117   AvrcpTarget(const Uuid& uuid);
 118
 119   // hal::BluetoothAvrcpInterface::TargetObserver implementation:
 120   void RemoteFeaturesCallback(const RawAddress& bd_addr,
 121                               btrc_remote_features_t features) override;
 122   void GetPlayStatusCallback(const RawAddress& bd_addr) override;
 123   void ListPlayerAppAttrCallback(const RawAddress& bd_addr) override;
 124   void ListPlayerAppValuesCallback(btrc_player_attr_t attr_id,
 125                                    const RawAddress& bd_addr) override;
 126   void GetPlayerAppValueCallback(uint8_t num_attr, btrc_player_attr_t* p_attrs,
 127                                  const RawAddress& bd_addr) override;
 128   void GetPlayerAppAttrsTextCallback(uint8_t num_attr,
 129                                      btrc_player_attr_t* p_attrs,
 130                                      const RawAddress& bd_addr) override;
 131   void GetPlayerAppValuesTextCallback(uint8_t attr_id, uint8_t num_val,
 132                                       uint8_t* p_vals,
 133                                       const RawAddress& bd_addr) override;
 134   void SetPlayerAppValueCallback(btrc_player_settings_t* p_vals,
 135                                  const RawAddress& bd_addr) override;
 136   void GetElementAttrCallback(uint8_t num_attr, btrc_media_attr_t* p_attrs,
 137                               const RawAddress& bd_addr) override;
 138   void RegisterNotificationCallback(btrc_event_id_t event_id, uint32_t param,
 139                                     const RawAddress& bd_addr) override;
 140   void VolumeChangeCallback(uint8_t volume, uint8_t ctype,
 141                             const RawAddress& bd_addr) override;
 142   void PassthroughCmdCallback(int id, int key_state,
 143                               const RawAddress& bd_addr) override;
 144
 145   // See getters for documentation.
 146   const Uuid app_identifier_;
 147
 148   // Mutex that synchronizes access to the entries below.
 149   std::mutex mutex_;
 150
 151   // Raw handle to the Delegate, which must outlive this AvrcpTarget instance.
 152   std::mutex delegate_mutex_;
 153   Delegate* delegate_ = nullptr;
 154
 155   DISALLOW_COPY_AND_ASSIGN(AvrcpTarget);
 156 };
 157
 158 // AvrcpTargetFactory is used to register and obtain a per-application
 159 // AvrcpTarget
 160 // instance. Users should call RegisterClient to obtain their own unique
 161 // AvrcpTarget instance that has been registered with the Bluetooth stack.
 162 class AvrcpTargetFactory
 163     : public BluetoothInstanceFactory,
 164       private hal::BluetoothAvrcpInterface::TargetObserver {
 165  public:
 166   // Don't construct/destruct directly except in tests. Instead, obtain a handle
 167   // from an Adapter instance.
 168   AvrcpTargetFactory();
 169   ~AvrcpTargetFactory() override;
 170
 171   // BluetoothInstanceFactory override:
 172   bool RegisterInstance(const Uuid& uuid,
 173                         const RegisterCallback& callback) override;
 174
 175  private:
 176   DISALLOW_COPY_AND_ASSIGN(AvrcpTargetFactory);
 177 };
 178
 179 }  // namespace bluetooth