1 /*
2 * Copyright 2019 HIMSA II K/S - www.himsa.com. Represented by EHIMA -
3 * www.ehima.com
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18 #include <base/functional/bind.h>
19 #include <base/logging.h>
20 #include <hardware/bluetooth.h>
21 #include <hardware/bt_le_audio.h>
22
23 #include "audio_hal_interface/hal_version_manager.h"
24 #include "bta_le_audio_api.h"
25 #include "bta_le_audio_broadcaster_api.h"
26 #include "btif_common.h"
27 #include "stack/include/btu.h"
28
29 using base::Bind;
30 using base::Unretained;
31 using bluetooth::le_audio::BroadcastId;
32 using bluetooth::le_audio::BroadcastState;
33 using bluetooth::le_audio::LeAudioBroadcasterCallbacks;
34 using bluetooth::le_audio::LeAudioBroadcasterInterface;
35
36 namespace {
37 class LeAudioBroadcasterInterfaceImpl;
38 std::unique_ptr<LeAudioBroadcasterInterface> leAudioBroadcasterInstance;
39
40 class LeAudioBroadcasterInterfaceImpl : public LeAudioBroadcasterInterface,
41 public LeAudioBroadcasterCallbacks {
42 ~LeAudioBroadcasterInterfaceImpl() override = default;
43
Initialize(LeAudioBroadcasterCallbacks * callbacks)44 void Initialize(LeAudioBroadcasterCallbacks* callbacks) override {
45 this->callbacks_ = callbacks;
46 do_in_main_thread(
47 FROM_HERE,
48 Bind(&LeAudioBroadcaster::Initialize, this, base::Bind([]() -> bool {
49 return LeAudioHalVerifier::SupportsLeAudioBroadcast();
50 })));
51 }
52
CreateBroadcast(bool is_public,std::string broadcast_name,std::optional<bluetooth::le_audio::BroadcastCode> broadcast_code,std::vector<uint8_t> public_metadata,std::vector<uint8_t> subgroup_quality,std::vector<std::vector<uint8_t>> subgroup_metadata)53 void CreateBroadcast(
54 bool is_public, std::string broadcast_name,
55 std::optional<bluetooth::le_audio::BroadcastCode> broadcast_code,
56 std::vector<uint8_t> public_metadata,
57 std::vector<uint8_t> subgroup_quality,
58 std::vector<std::vector<uint8_t>> subgroup_metadata) override {
59 DVLOG(2) << __func__;
60 do_in_main_thread(FROM_HERE, Bind(&LeAudioBroadcaster::CreateAudioBroadcast,
61 Unretained(LeAudioBroadcaster::Get()),
62 is_public, broadcast_name, broadcast_code,
63 std::move(public_metadata),
64 std::move(subgroup_quality),
65 std::move(subgroup_metadata)));
66 }
67
UpdateMetadata(uint32_t broadcast_id,std::string broadcast_name,std::vector<uint8_t> public_metadata,std::vector<std::vector<uint8_t>> subgroup_metadata)68 void UpdateMetadata(
69 uint32_t broadcast_id, std::string broadcast_name,
70 std::vector<uint8_t> public_metadata,
71 std::vector<std::vector<uint8_t>> subgroup_metadata) override {
72 DVLOG(2) << __func__;
73 do_in_main_thread(FROM_HERE,
74 Bind(&LeAudioBroadcaster::UpdateMetadata,
75 Unretained(LeAudioBroadcaster::Get()), broadcast_id,
76 broadcast_name, std::move(public_metadata),
77 std::move(subgroup_metadata)));
78 }
79
StartBroadcast(uint32_t broadcast_id)80 void StartBroadcast(uint32_t broadcast_id) override {
81 DVLOG(2) << __func__;
82 do_in_main_thread(
83 FROM_HERE, Bind(&LeAudioBroadcaster::StartAudioBroadcast,
84 Unretained(LeAudioBroadcaster::Get()), broadcast_id));
85 }
86
StopBroadcast(uint32_t broadcast_id)87 void StopBroadcast(uint32_t broadcast_id) override {
88 DVLOG(2) << __func__;
89 do_in_main_thread(
90 FROM_HERE, Bind(&LeAudioBroadcaster::StopAudioBroadcast,
91 Unretained(LeAudioBroadcaster::Get()), broadcast_id));
92 }
93
PauseBroadcast(uint32_t broadcast_id)94 void PauseBroadcast(uint32_t broadcast_id) override {
95 DVLOG(2) << __func__;
96 do_in_main_thread(
97 FROM_HERE, Bind(&LeAudioBroadcaster::SuspendAudioBroadcast,
98 Unretained(LeAudioBroadcaster::Get()), broadcast_id));
99 }
100
DestroyBroadcast(uint32_t broadcast_id)101 void DestroyBroadcast(uint32_t broadcast_id) override {
102 DVLOG(2) << __func__;
103 do_in_main_thread(
104 FROM_HERE, Bind(&LeAudioBroadcaster::DestroyAudioBroadcast,
105 Unretained(LeAudioBroadcaster::Get()), broadcast_id));
106 }
107
GetBroadcastMetadata(uint32_t broadcast_id)108 void GetBroadcastMetadata(uint32_t broadcast_id) override {
109 DVLOG(2) << __func__;
110 do_in_main_thread(
111 FROM_HERE, Bind(&LeAudioBroadcaster::GetBroadcastMetadata,
112 Unretained(LeAudioBroadcaster::Get()), broadcast_id));
113 }
114
OnBroadcastCreated(uint32_t broadcast_id,bool success)115 void OnBroadcastCreated(uint32_t broadcast_id, bool success) override {
116 DVLOG(2) << __func__;
117 do_in_jni_thread(FROM_HERE,
118 Bind(&LeAudioBroadcasterCallbacks::OnBroadcastCreated,
119 Unretained(callbacks_), broadcast_id, success));
120 }
121
OnBroadcastDestroyed(uint32_t broadcast_id)122 void OnBroadcastDestroyed(uint32_t broadcast_id) override {
123 DVLOG(2) << __func__;
124 do_in_jni_thread(FROM_HERE,
125 Bind(&LeAudioBroadcasterCallbacks::OnBroadcastDestroyed,
126 Unretained(callbacks_), broadcast_id));
127 }
128
OnBroadcastStateChanged(uint32_t broadcast_id,BroadcastState state)129 void OnBroadcastStateChanged(uint32_t broadcast_id,
130 BroadcastState state) override {
131 DVLOG(2) << __func__;
132 do_in_jni_thread(FROM_HERE,
133 Bind(&LeAudioBroadcasterCallbacks::OnBroadcastStateChanged,
134 Unretained(callbacks_), broadcast_id, state));
135 }
136
OnBroadcastMetadataChanged(uint32_t broadcast_id,const bluetooth::le_audio::BroadcastMetadata & broadcast_metadata)137 void OnBroadcastMetadataChanged(uint32_t broadcast_id,
138 const bluetooth::le_audio::BroadcastMetadata&
139 broadcast_metadata) override {
140 DVLOG(2) << __func__;
141 do_in_jni_thread(
142 FROM_HERE,
143 Bind(&LeAudioBroadcasterCallbacks::OnBroadcastMetadataChanged,
144 Unretained(callbacks_), broadcast_id, broadcast_metadata));
145 }
146
Stop(void)147 void Stop(void) override {
148 do_in_main_thread(FROM_HERE, Bind(&LeAudioBroadcaster::Stop));
149 }
150
Cleanup(void)151 void Cleanup(void) override {
152 do_in_main_thread(FROM_HERE, Bind(&LeAudioBroadcaster::Cleanup));
153 }
154
155 private:
156 LeAudioBroadcasterCallbacks* callbacks_;
157 };
158
159 } /* namespace */
160
btif_le_audio_broadcaster_get_interface()161 LeAudioBroadcasterInterface* btif_le_audio_broadcaster_get_interface() {
162 if (!leAudioBroadcasterInstance) {
163 leAudioBroadcasterInstance.reset(new LeAudioBroadcasterInterfaceImpl());
164 }
165
166 return leAudioBroadcasterInstance.get();
167 }
168