1 /*
2 * Copyright (c) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #ifndef ST_PRO_AUDIO_SERVICE_ADAPTER_IMPL_H
17 #define ST_PRO_AUDIO_SERVICE_ADAPTER_IMPL_H
18 #ifndef LOG_TAG
19 #define LOG_TAG "ProAudioServiceAdapterImpl"
20 #endif
21
22 #include "pro_audio_service_adapter_impl.h"
23 #if defined(_WIN32) || defined(_WIN64)
24 #include <windows.h>
25 #endif
26 #include <sstream>
27 #include <thread>
28
29 #include "audio_errors.h"
30 #include "audio_common_log.h"
31 #include "audio_info.h"
32 #include "audio_utils.h"
33 #include <set>
34 #include <unordered_map>
35 #include "i_hpae_manager.h"
36
37 using namespace std;
38 using namespace OHOS::AudioStandard::HPAE;
39 namespace OHOS {
40 namespace AudioStandard {
41 static unique_ptr<AudioServiceAdapterCallback> g_audioServiceAdapterCallback;
42 static const int32_t OPERATION_TIMEOUT_IN_MS = 10000; // 10s
43 static const int32_t HPAE_SERVICE_IMPL_TIMEOUT = 10; // 10s is better
44
45 ProAudioServiceAdapterImpl::~ProAudioServiceAdapterImpl() = default;
46
ProAudioServiceAdapterImpl(unique_ptr<AudioServiceAdapterCallback> & cb)47 ProAudioServiceAdapterImpl::ProAudioServiceAdapterImpl(unique_ptr<AudioServiceAdapterCallback> &cb)
48 {
49 g_audioServiceAdapterCallback = move(cb);
50 }
51
Connect()52 bool ProAudioServiceAdapterImpl::Connect()
53 {
54 AUDIO_INFO_LOG("Connected RegiesterServiceCallback");
55 IHpaeManager::GetHpaeManager().RegisterSerivceCallback(shared_from_this());
56 CHECK_AND_RETURN_RET_LOG(g_audioServiceAdapterCallback != nullptr, false,
57 "g_audioServiceAdapterCallback is nullptr");
58 g_audioServiceAdapterCallback->OnSetVolumeDbCb();
59 return true;
60 }
61
OpenAudioPort(string audioPortName,string moduleArgs)62 uint32_t ProAudioServiceAdapterImpl::OpenAudioPort(string audioPortName, string moduleArgs)
63 {
64 AUDIO_PRERELEASE_LOGI("ERROR OpenAudioPort enter.");
65 return SUCCESS;
66 }
67
ReloadAudioPort(const std::string & audioPortName,const AudioModuleInfo & audioModuleInfo)68 int32_t ProAudioServiceAdapterImpl::ReloadAudioPort(const std::string &audioPortName,
69 const AudioModuleInfo &audioModuleInfo)
70 {
71 AUDIO_PRERELEASE_LOGI("ReloadAudioPort enter.");
72 AudioXCollie audioXCollie("ProAudioServiceAdapterImpl::ReloadAudioPort", HPAE_SERVICE_IMPL_TIMEOUT,
73 [](void *) {
74 AUDIO_ERR_LOG("[xcollie] ReloadAudioPort timeout");
75 }, nullptr, AUDIO_XCOLLIE_FLAG_LOG | AUDIO_XCOLLIE_FLAG_RECOVERY);
76 Trace trace("ReloadAudioPort");
77 lock_guard<mutex> lock(lock_);
78 isFinishReloadAudioPort_ = false;
79 IHpaeManager::GetHpaeManager().ReloadAudioPort(audioModuleInfo);
80 std::unique_lock<std::mutex> waitLock(callbackMutex_);
81 bool stopWaiting = callbackCV_.wait_for(waitLock, std::chrono::milliseconds(OPERATION_TIMEOUT_IN_MS), [this] {
82 return isFinishReloadAudioPort_; // will be true when got notified.
83 });
84 if (!stopWaiting) {
85 AUDIO_ERR_LOG("ReloadAudioPort timeout");
86 return ERROR;
87 }
88 AUDIO_INFO_LOG("ReloadAudioPort leave");
89 return AudioPortIndex_;
90 }
91
OpenAudioPort(string audioPortName,const AudioModuleInfo & audioModuleInfo)92 int32_t ProAudioServiceAdapterImpl::OpenAudioPort(string audioPortName, const AudioModuleInfo &audioModuleInfo)
93 {
94 AUDIO_PRERELEASE_LOGI("OpenAudioPort enter.");
95 AudioXCollie audioXCollie("ProAudioServiceAdapterImpl::OpenAudioPort", HPAE_SERVICE_IMPL_TIMEOUT,
96 [](void *) {
97 AUDIO_ERR_LOG("[xcollie] OpenAudioPort timeout");
98 }, nullptr, AUDIO_XCOLLIE_FLAG_LOG | AUDIO_XCOLLIE_FLAG_RECOVERY);
99 lock_guard<mutex> lock(lock_);
100 Trace trace("OpenAudioPort");
101 isFinishOpenAudioPort_ = false;
102 IHpaeManager::GetHpaeManager().OpenAudioPort(audioModuleInfo);
103 std::unique_lock<std::mutex> waitLock(callbackMutex_);
104 bool stopWaiting = callbackCV_.wait_for(waitLock, std::chrono::milliseconds(OPERATION_TIMEOUT_IN_MS), [this] {
105 return isFinishOpenAudioPort_; // will be true when got notified.
106 });
107 if (!stopWaiting) {
108 AUDIO_ERR_LOG("OpenAudioPort timeout");
109 return ERROR;
110 }
111 AUDIO_INFO_LOG("OpenAudioPort leave");
112 return AudioPortIndex_;
113 }
114
CloseAudioPort(int32_t audioHandleIndex)115 int32_t ProAudioServiceAdapterImpl::CloseAudioPort(int32_t audioHandleIndex)
116 {
117 if (audioHandleIndex <= 0) {
118 AUDIO_ERR_LOG("Core modules, not allowed to close!");
119 return ERROR;
120 }
121 AUDIO_INFO_LOG("CloseAudioPort:audioHandleIndex:%{public}d", audioHandleIndex);
122 AudioXCollie audioXCollie("ProAudioServiceAdapterImpl::CloseAudioPort", HPAE_SERVICE_IMPL_TIMEOUT,
123 [](void *) {
124 AUDIO_ERR_LOG("[xcollie] CloseAudioPort timeout");
125 }, nullptr, AUDIO_XCOLLIE_FLAG_LOG | AUDIO_XCOLLIE_FLAG_RECOVERY);
126 Trace trace("CloseAudioPort");
127 lock_guard<mutex> lock(lock_);
128
129 isFinishCloseAudioPort_ = false;
130 IHpaeManager::GetHpaeManager().CloseAudioPort(audioHandleIndex);
131 std::unique_lock<std::mutex> waitLock(callbackMutex_);
132 bool stopWaiting = callbackCV_.wait_for(waitLock, std::chrono::milliseconds(OPERATION_TIMEOUT_IN_MS), [this] {
133 return isFinishCloseAudioPort_; // will be true when got notified.
134 });
135 if (!stopWaiting) {
136 AUDIO_ERR_LOG("CloseAudioPort timeout");
137 return ERROR;
138 }
139
140 AUDIO_INFO_LOG("CloseAudioPort leave");
141 return SUCCESS;
142 }
143
SuspendAudioDevice(string & audioPortName,bool isSuspend)144 int32_t ProAudioServiceAdapterImpl::SuspendAudioDevice(string &audioPortName, bool isSuspend)
145 {
146 lock_guard<mutex> lock(lock_);
147 Trace trace("SuspendAudioDevice");
148 AUDIO_INFO_LOG("SuspendAudioDevice [%{public}s] : [%{public}d]", audioPortName.c_str(), isSuspend);
149 IHpaeManager::GetHpaeManager().SuspendAudioDevice(audioPortName, isSuspend);
150 return SUCCESS;
151 }
152
SetSinkMute(const std::string & sinkName,bool isMute,bool isSync)153 bool ProAudioServiceAdapterImpl::SetSinkMute(const std::string &sinkName, bool isMute, bool isSync)
154 {
155 AUDIO_INFO_LOG("SetSinkMute: [%{public}s] : [%{public}d] isSync [%{public}d]", sinkName.c_str(), isMute, isSync);
156 AudioXCollie audioXCollie("ProAudioServiceAdapterImpl::SetSinkMute", HPAE_SERVICE_IMPL_TIMEOUT,
157 [](void *) {
158 AUDIO_ERR_LOG("[xcollie] SetSinkMute timeout");
159 }, nullptr, AUDIO_XCOLLIE_FLAG_LOG | AUDIO_XCOLLIE_FLAG_RECOVERY);
160 lock_guard<mutex> lock(lock_);
161 Trace trace("SetSinkMute:" + sinkName + "isMute:" + std::to_string(isMute));
162 if (isSync) {
163 isFinishSetSinkMute_ = false;
164 IHpaeManager::GetHpaeManager().SetSinkMute(sinkName, isMute, isSync);
165 std::unique_lock<std::mutex> waitLock(callbackMutex_);
166 bool stopWaiting = callbackCV_.wait_for(waitLock, std::chrono::milliseconds(OPERATION_TIMEOUT_IN_MS), [this] {
167 return isFinishSetSinkMute_; // will be true when got notified.
168 });
169 if (!stopWaiting) {
170 AUDIO_ERR_LOG("SetSinkMute timeout");
171 return ERROR;
172 }
173 } else {
174 IHpaeManager::GetHpaeManager().SetSinkMute(sinkName, isMute, isSync);
175 }
176 AUDIO_INFO_LOG("SetSinkMute leave");
177 return SUCCESS;
178 }
179
SetDefaultSink(string name)180 int32_t ProAudioServiceAdapterImpl::SetDefaultSink(string name)
181 {
182 lock_guard<mutex> lock(lock_);
183 Trace trace("SetDefaultSink:" + name);
184 IHpaeManager::GetHpaeManager().SetDefaultSink(name);
185 AUDIO_INFO_LOG("SetDefaultSink: [%{public}s]", name.c_str());
186 return SUCCESS;
187 }
188
SetDefaultSource(string name)189 int32_t ProAudioServiceAdapterImpl::SetDefaultSource(string name)
190 {
191 lock_guard<mutex> lock(lock_);
192 Trace trace("SetDefaultSource:" + name);
193 IHpaeManager::GetHpaeManager().SetDefaultSource(name);
194 AUDIO_INFO_LOG("SetDefaultSource: [%{public}s]", name.c_str());
195 return SUCCESS;
196 }
197
GetAllSinks()198 std::vector<SinkInfo> ProAudioServiceAdapterImpl::GetAllSinks()
199 {
200 AUDIO_INFO_LOG("GetAllSinks: enter");
201 AudioXCollie audioXCollie("ProAudioServiceAdapterImpl::GetAllSinks", HPAE_SERVICE_IMPL_TIMEOUT,
202 [](void *) {
203 AUDIO_ERR_LOG("[xcollie] GetAllSinks timeout");
204 }, nullptr, AUDIO_XCOLLIE_FLAG_LOG | AUDIO_XCOLLIE_FLAG_RECOVERY);
205 lock_guard<mutex> lock(lock_);
206 Trace trace("GetAllSinks");
207 isFinishGetAllSinks_ = false;
208 IHpaeManager::GetHpaeManager().GetAllSinks();
209 std::unique_lock<std::mutex> waitLock(callbackMutex_);
210 bool stopWaiting = callbackCV_.wait_for(waitLock, std::chrono::milliseconds(OPERATION_TIMEOUT_IN_MS), [this] {
211 return isFinishGetAllSinks_; // will be true when got notified.
212 });
213 if (!stopWaiting) {
214 AUDIO_ERR_LOG("GetAllSinks timeout");
215 sinks_.clear();
216 }
217 AUDIO_INFO_LOG("GetAllSinks leave");
218 return sinks_;
219 }
220
GetTargetSinks(std::string adapterName)221 std::vector<uint32_t> ProAudioServiceAdapterImpl::GetTargetSinks(std::string adapterName)
222 {
223 std::vector<SinkInfo> sinkInfos = GetAllSinks();
224 Trace trace("GetTargetSinks:" + adapterName);
225 std::vector<uint32_t> targetSinkIds = {};
226 for (size_t i = 0; i < sinkInfos.size(); i++) {
227 if (sinkInfos[i].adapterName == adapterName) {
228 targetSinkIds.push_back(sinkInfos[i].sinkId);
229 }
230 }
231 AUDIO_INFO_LOG("GetTargetSinks: adapterName %{public}s", adapterName.c_str());
232 return targetSinkIds;
233 }
234
SetLocalDefaultSink(std::string name)235 int32_t ProAudioServiceAdapterImpl::SetLocalDefaultSink(std::string name)
236 {
237 AUDIO_INFO_LOG("SetLocalDefaultSink sink name: %{public}s", name.c_str());
238 return SUCCESS;
239 }
240
MoveSinkInputByIndexOrName(uint32_t sinkInputId,uint32_t sinkIndex,std::string sinkName)241 int32_t ProAudioServiceAdapterImpl::MoveSinkInputByIndexOrName(
242 uint32_t sinkInputId, uint32_t sinkIndex, std::string sinkName)
243 {
244 AUDIO_INFO_LOG("sinkInputId %{public}d, sinkIndex %{public}d, sinkName %{public}s",
245 sinkInputId,
246 sinkIndex,
247 sinkName.c_str());
248 AudioXCollie audioXCollie("ProAudioServiceAdapterImpl::MoveSinkInputByIndexOrName", HPAE_SERVICE_IMPL_TIMEOUT,
249 [](void *) {
250 AUDIO_ERR_LOG("[xcollie] MoveSinkInputByIndexOrName timeout");
251 }, nullptr, AUDIO_XCOLLIE_FLAG_LOG | AUDIO_XCOLLIE_FLAG_RECOVERY);
252 lock_guard<mutex> lock(lock_);
253 Trace trace("MoveSinkInputByIndexOrName: " + std::to_string(sinkInputId) + " index:" + std::to_string(sinkIndex) +
254 " sink:" + sinkName);
255 isFinishMoveSinkInputByIndexOrName_ = false;
256 IHpaeManager::GetHpaeManager().MoveSinkInputByIndexOrName(sinkInputId, sinkIndex, sinkName);
257 std::unique_lock<std::mutex> waitLock(callbackMutex_);
258 bool stopWaiting = callbackCV_.wait_for(waitLock, std::chrono::milliseconds(OPERATION_TIMEOUT_IN_MS), [this] {
259 return isFinishMoveSinkInputByIndexOrName_; // will be true when got notified.
260 });
261 if (!stopWaiting) {
262 AUDIO_ERR_LOG("MoveSinkInputByIndexOrName timeout");
263 return ERROR;
264 }
265 return SUCCESS;
266 }
267
MoveSourceOutputByIndexOrName(uint32_t sourceOutputId,uint32_t sourceIndex,std::string sourceName)268 int32_t ProAudioServiceAdapterImpl::MoveSourceOutputByIndexOrName(
269 uint32_t sourceOutputId, uint32_t sourceIndex, std::string sourceName)
270 {
271 AUDIO_INFO_LOG(
272 "MoveSourceOutputByIndexOrName sourceOutputId %{public}d, sourceIndex %{public}d, sourceName %{public}s",
273 sourceOutputId,
274 sourceIndex,
275 sourceName.c_str());
276 AudioXCollie audioXCollie("ProAudioServiceAdapterImpl::MoveSourceOutputByIndexOrName", HPAE_SERVICE_IMPL_TIMEOUT,
277 [](void *) {
278 AUDIO_ERR_LOG("[xcollie] MoveSourceOutputByIndexOrName timeout");
279 }, nullptr, AUDIO_XCOLLIE_FLAG_LOG | AUDIO_XCOLLIE_FLAG_RECOVERY);
280 lock_guard<mutex> lock(lock_);
281 Trace trace("MoveSourceOutputByIndexOrName: " + std::to_string(sourceOutputId) +
282 " index:" + std::to_string(sourceIndex) + " source:" + sourceName);
283 isFinishMoveSourceOutputByIndexOrName_ = false;
284 IHpaeManager::GetHpaeManager().MoveSourceOutputByIndexOrName(sourceOutputId, sourceIndex, sourceName);
285 std::unique_lock<std::mutex> waitLock(callbackMutex_);
286 bool stopWaiting = callbackCV_.wait_for(waitLock, std::chrono::milliseconds(OPERATION_TIMEOUT_IN_MS), [this] {
287 return isFinishMoveSourceOutputByIndexOrName_; // will be true when got notified.
288 });
289 if (!stopWaiting) {
290 AUDIO_ERR_LOG("MoveSourceOutputByIndexOrName timeout");
291 return ERROR;
292 }
293 return SUCCESS;
294 }
295
SetSourceOutputMute(int32_t uid,bool setMute)296 int32_t ProAudioServiceAdapterImpl::SetSourceOutputMute(int32_t uid, bool setMute)
297 {
298 AUDIO_INFO_LOG("SetSourceOutputMute uid %{public}d, setMute %{public}d", uid, setMute);
299 lock_guard<mutex> lock(lock_);
300 isFinishSetSourceOutputMute_ = false;
301 SourceOutputMuteStreamSet_ = 0;
302 IHpaeManager::GetHpaeManager().SetSourceOutputMute(uid, setMute);
303 std::unique_lock<std::mutex> waitLock(callbackMutex_);
304 bool stopWaiting = callbackCV_.wait_for(waitLock, std::chrono::milliseconds(OPERATION_TIMEOUT_IN_MS), [this] {
305 return isFinishSetSourceOutputMute_; // will be true when got notified.
306 });
307 if (!stopWaiting) {
308 AUDIO_ERR_LOG("SetSourceOutputMute timeout");
309 return ERROR;
310 }
311 AUDIO_INFO_LOG("SetSourceOutputMute leave");
312 return SourceOutputMuteStreamSet_;
313 }
314
GetAllSinkInputs()315 std::vector<SinkInput> ProAudioServiceAdapterImpl::GetAllSinkInputs()
316 {
317 AUDIO_INFO_LOG("Enter");
318 AudioXCollie audioXCollie("ProAudioServiceAdapterImpl::GetAllSinkInputs", HPAE_SERVICE_IMPL_TIMEOUT,
319 [](void *) {
320 AUDIO_ERR_LOG("[xcollie] GetAllSinkInputs timeout");
321 }, nullptr, AUDIO_XCOLLIE_FLAG_LOG | AUDIO_XCOLLIE_FLAG_RECOVERY);
322 lock_guard<mutex> lock(lock_);
323 isFinishGetAllSinkInputs_ = false;
324 IHpaeManager::GetHpaeManager().GetAllSinkInputs();
325 std::unique_lock<std::mutex> waitLock(callbackMutex_);
326 bool stopWaiting = callbackCV_.wait_for(waitLock, std::chrono::milliseconds(OPERATION_TIMEOUT_IN_MS), [this] {
327 return isFinishGetAllSinkInputs_; // will be true when got notified.
328 });
329 if (!stopWaiting) {
330 AUDIO_ERR_LOG("GetAllSinkInputs timeout");
331 sinkInputs_.clear();
332 }
333 AUDIO_INFO_LOG("GetAllSinkInputs leave");
334 return sinkInputs_;
335 }
336
GetAllSourceOutputs()337 std::vector<SourceOutput> ProAudioServiceAdapterImpl::GetAllSourceOutputs()
338 {
339 AUDIO_INFO_LOG("GetAllSourceOutputs");
340 AudioXCollie audioXCollie("ProAudioServiceAdapterImpl::GetAllSourceOutputs", HPAE_SERVICE_IMPL_TIMEOUT,
341 [](void *) {
342 AUDIO_ERR_LOG("[xcollie] GetAllSourceOutputs timeout");
343 }, nullptr, AUDIO_XCOLLIE_FLAG_LOG | AUDIO_XCOLLIE_FLAG_RECOVERY);
344 lock_guard<mutex> lock(lock_);
345 isFinishGetAllSourceOutputs_ = false;
346 IHpaeManager::GetHpaeManager().GetAllSourceOutputs();
347 std::unique_lock<std::mutex> waitLock(callbackMutex_);
348 bool stopWaiting = callbackCV_.wait_for(waitLock, std::chrono::milliseconds(OPERATION_TIMEOUT_IN_MS), [this] {
349 return isFinishGetAllSourceOutputs_; // will be true when got notified.
350 });
351 if (!stopWaiting) {
352 AUDIO_ERR_LOG("GetAllSourceOutputs timeout");
353 sourceOutputs_.clear();
354 }
355 AUDIO_INFO_LOG("GetAllSourceOutputs leave");
356 return sourceOutputs_;
357 }
358
Disconnect()359 void ProAudioServiceAdapterImpl::Disconnect()
360 {
361 AUDIO_INFO_LOG("Disconnect not support");
362 }
363
GetAudioEffectProperty(AudioEffectPropertyArrayV3 & propertyArray)364 int32_t ProAudioServiceAdapterImpl::GetAudioEffectProperty(AudioEffectPropertyArrayV3 &propertyArray)
365 {
366 AUDIO_INFO_LOG("GetAudioEffectProperty");
367 lock_guard<mutex> lock(lock_);
368 isFinishGetAudioEffectPropertyV3_ = false;
369 IHpaeManager::GetHpaeManager().GetAudioEffectProperty(propertyArray);
370 std::unique_lock<std::mutex> waitLock(callbackMutex_);
371 bool stopWaiting = callbackCV_.wait_for(waitLock, std::chrono::milliseconds(OPERATION_TIMEOUT_IN_MS), [this] {
372 return isFinishGetAudioEffectPropertyV3_;
373 });
374 if (!stopWaiting) {
375 AUDIO_WARNING_LOG("wait for notify timeout");
376 }
377 return SUCCESS;
378 }
379
GetAudioEffectProperty(AudioEffectPropertyArray & propertyArray)380 int32_t ProAudioServiceAdapterImpl::GetAudioEffectProperty(AudioEffectPropertyArray &propertyArray)
381 {
382 AUDIO_INFO_LOG("GetAudioEffectProperty");
383 lock_guard<mutex> lock(lock_);
384 isFinishGetAudioEffectProperty_ = false;
385 IHpaeManager::GetHpaeManager().GetAudioEffectProperty(propertyArray);
386 std::unique_lock<std::mutex> waitLock(callbackMutex_);
387 bool stopWaiting = callbackCV_.wait_for(waitLock, std::chrono::milliseconds(OPERATION_TIMEOUT_IN_MS), [this] {
388 return isFinishGetAudioEffectProperty_;
389 });
390 if (!stopWaiting) {
391 AUDIO_WARNING_LOG("wait for notify timeout");
392 }
393 return SUCCESS;
394 }
395
GetAudioEnhanceProperty(AudioEffectPropertyArrayV3 & propertyArray,DeviceType deviceType)396 int32_t ProAudioServiceAdapterImpl::GetAudioEnhanceProperty(AudioEffectPropertyArrayV3 &propertyArray,
397 DeviceType deviceType)
398 {
399 AUDIO_INFO_LOG("GetAudioEnhancePropertyV3");
400 lock_guard<mutex> lock(lock_);
401 isFinishGetAudioEnhancePropertyV3_ = false;
402 IHpaeManager::GetHpaeManager().GetAudioEnhanceProperty(propertyArray);
403 std::unique_lock<std::mutex> waitLock(callbackMutex_);
404 bool stopWaiting = callbackCV_.wait_for(waitLock, std::chrono::milliseconds(OPERATION_TIMEOUT_IN_MS), [this] {
405 return isFinishGetAudioEnhancePropertyV3_;
406 });
407 if (!stopWaiting) {
408 AUDIO_WARNING_LOG("wait for notify timeout");
409 }
410 return SUCCESS;
411 }
412
GetAudioEnhanceProperty(AudioEnhancePropertyArray & propertyArray,DeviceType deviceType)413 int32_t ProAudioServiceAdapterImpl::GetAudioEnhanceProperty(AudioEnhancePropertyArray &propertyArray,
414 DeviceType deviceType)
415 {
416 AUDIO_INFO_LOG("GetAudioEnhanceProperty");
417 lock_guard<mutex> lock(lock_);
418 isFinishGetAudioEnhanceProperty_ = false;
419 IHpaeManager::GetHpaeManager().GetAudioEnhanceProperty(propertyArray);
420 std::unique_lock<std::mutex> waitLock(callbackMutex_);
421 bool stopWaiting = callbackCV_.wait_for(waitLock, std::chrono::milliseconds(OPERATION_TIMEOUT_IN_MS), [this] {
422 return isFinishGetAudioEnhanceProperty_;
423 });
424 if (!stopWaiting) {
425 AUDIO_WARNING_LOG("wait for notify timeout");
426 }
427 return SUCCESS;
428 }
429
OnReloadAudioPortCb(int32_t portId)430 void ProAudioServiceAdapterImpl::OnReloadAudioPortCb(int32_t portId)
431 {
432 AUDIO_INFO_LOG("OnReloadAudioPortCb portId: %{public}d", portId);
433 std::unique_lock<std::mutex> waitLock(callbackMutex_);
434 isFinishReloadAudioPort_= true;
435 AudioPortIndex_ = portId;
436 callbackCV_.notify_all();
437 }
438
OnOpenAudioPortCb(int32_t portId)439 void ProAudioServiceAdapterImpl::OnOpenAudioPortCb(int32_t portId)
440 {
441 std::unique_lock<std::mutex> waitLock(callbackMutex_);
442 AUDIO_INFO_LOG("OnOpenAudioPortCb portId: %{public}d", portId);
443 isFinishOpenAudioPort_ = true;
444 AudioPortIndex_ = portId;
445 callbackCV_.notify_all();
446 }
447
OnCloseAudioPortCb(int32_t result)448 void ProAudioServiceAdapterImpl::OnCloseAudioPortCb(int32_t result)
449 {
450 std::unique_lock<std::mutex> waitLock(callbackMutex_);
451 AUDIO_INFO_LOG("OnCloseAudioPortCb result: %{public}d", result);
452 isFinishCloseAudioPort_ = true;
453 callbackCV_.notify_all();
454 }
455
OnSetSinkMuteCb(int32_t result)456 void ProAudioServiceAdapterImpl::OnSetSinkMuteCb(int32_t result)
457 {
458 std::unique_lock<std::mutex> waitLock(callbackMutex_);
459 AUDIO_INFO_LOG("OnSetSinkMuteCb result: %{public}d", result);
460 isFinishSetSinkMute_ = true;
461 callbackCV_.notify_all();
462 }
463
OnGetAllSinkInputsCb(int32_t result,std::vector<SinkInput> & sinkInputs)464 void ProAudioServiceAdapterImpl::OnGetAllSinkInputsCb(int32_t result, std::vector<SinkInput> &sinkInputs)
465 {
466 std::unique_lock<std::mutex> waitLock(callbackMutex_);
467 AUDIO_INFO_LOG("OnGetAllSinkInputsCb result: %{public}d", result);
468 isFinishGetAllSinkInputs_ = true;
469 sinkInputs_ = sinkInputs;
470 callbackCV_.notify_all();
471 }
472
OnSetSourceOutputMuteCb(int32_t result)473 void ProAudioServiceAdapterImpl::OnSetSourceOutputMuteCb(int32_t result)
474 {
475 std::unique_lock<std::mutex> waitLock(callbackMutex_);
476 AUDIO_INFO_LOG("OnSetSourceOutputMuteCb result: %{public}d", result);
477 isFinishSetSourceOutputMute_ = true;
478 SourceOutputMuteStreamSet_ = result;
479 callbackCV_.notify_all();
480 }
481
OnGetAllSourceOutputsCb(int32_t result,std::vector<SourceOutput> & sourceOutputs)482 void ProAudioServiceAdapterImpl::OnGetAllSourceOutputsCb(int32_t result, std::vector<SourceOutput> &sourceOutputs)
483 {
484 std::unique_lock<std::mutex> waitLock(callbackMutex_);
485 AUDIO_INFO_LOG("OnGetAllSourceOutputsCb result: %{public}d", result);
486 isFinishGetAllSourceOutputs_ = true;
487 sourceOutputs_ = sourceOutputs;
488 callbackCV_.notify_all();
489 }
OnGetAllSinksCb(int32_t result,std::vector<SinkInfo> & sinks)490 void ProAudioServiceAdapterImpl::OnGetAllSinksCb(int32_t result, std::vector<SinkInfo> &sinks)
491 {
492 std::unique_lock<std::mutex> waitLock(callbackMutex_);
493 AUDIO_INFO_LOG("OnGetAllSinksCb result: %{public}d", result);
494 isFinishGetAllSinks_ = true;
495 sinks_ = sinks;
496 callbackCV_.notify_all();
497 }
498
OnMoveSinkInputByIndexOrNameCb(int32_t result)499 void ProAudioServiceAdapterImpl::OnMoveSinkInputByIndexOrNameCb(int32_t result)
500 {
501 std::unique_lock<std::mutex> waitLock(callbackMutex_);
502 AUDIO_INFO_LOG("OnMoveSinkInputByIndexOrNameCb result: %{public}d", result);
503 isFinishMoveSinkInputByIndexOrName_ = true;
504 callbackCV_.notify_all();
505 }
OnMoveSourceOutputByIndexOrNameCb(int32_t result)506 void ProAudioServiceAdapterImpl::OnMoveSourceOutputByIndexOrNameCb(int32_t result)
507 {
508 std::unique_lock<std::mutex> waitLock(callbackMutex_);
509 AUDIO_INFO_LOG("OnMoveSourceOutputByIndexOrNameCb result: %{public}d", result);
510 isFinishMoveSourceOutputByIndexOrName_ = true;
511 callbackCV_.notify_all();
512 }
513
OnGetAudioEffectPropertyCbV3(int32_t result)514 void ProAudioServiceAdapterImpl::OnGetAudioEffectPropertyCbV3(int32_t result)
515 {
516 std::unique_lock<std::mutex> waitLock(callbackMutex_);
517 AUDIO_INFO_LOG("OnGetAudioEffectPropertyCbV3 result: %{public}d", result);
518 isFinishGetAudioEffectPropertyV3_ = true;
519 callbackCV_.notify_all();
520 }
521
OnGetAudioEffectPropertyCb(int32_t result)522 void ProAudioServiceAdapterImpl::OnGetAudioEffectPropertyCb(int32_t result)
523 {
524 std::unique_lock<std::mutex> waitLock(callbackMutex_);
525 AUDIO_INFO_LOG("OnGetAudioEffectPropertyCb result: %{public}d", result);
526 isFinishGetAudioEffectProperty_ = true;
527 callbackCV_.notify_all();
528 }
529
OnGetAudioEnhancePropertyCbV3(int32_t result)530 void ProAudioServiceAdapterImpl::OnGetAudioEnhancePropertyCbV3(int32_t result)
531 {
532 std::unique_lock<std::mutex> waitLock(callbackMutex_);
533 AUDIO_INFO_LOG("OnGetAudioEnhancePropertyCbV3 result: %{public}d", result);
534 isFinishGetAudioEnhancePropertyV3_ = true;
535 callbackCV_.notify_all();
536 }
537
OnGetAudioEnhancePropertyCb(int32_t result)538 void ProAudioServiceAdapterImpl::OnGetAudioEnhancePropertyCb(int32_t result)
539 {
540 std::unique_lock<std::mutex> waitLock(callbackMutex_);
541 AUDIO_INFO_LOG("OnGetAudioEnhancePropertyCb result: %{public}d", result);
542 isFinishGetAudioEnhanceProperty_ = true;
543 callbackCV_.notify_all();
544 }
545
HandleSourceAudioStreamRemoved(uint32_t sessionId)546 void ProAudioServiceAdapterImpl::HandleSourceAudioStreamRemoved(uint32_t sessionId)
547 {
548 // todo: code check
549 CHECK_AND_RETURN_LOG(g_audioServiceAdapterCallback != nullptr, "g_audioServiceAdapterCallback is nullptr");
550 g_audioServiceAdapterCallback->OnAudioStreamRemoved(sessionId);
551 }
552
UpdateCollaborativeState(bool isCollaborationEnabled)553 int32_t ProAudioServiceAdapterImpl::UpdateCollaborativeState(bool isCollaborationEnabled)
554 {
555 AUDIO_INFO_LOG("UpdateCollaborativeState, state %{public}d", isCollaborationEnabled);
556 lock_guard<mutex> lock(lock_);
557 IHpaeManager::GetHpaeManager().UpdateCollaborativeState(isCollaborationEnabled);
558 return SUCCESS;
559 }
560
SetAbsVolumeStateToEffect(const bool absVolumeState)561 int32_t ProAudioServiceAdapterImpl::SetAbsVolumeStateToEffect(const bool absVolumeState)
562 {
563 AUDIO_INFO_LOG("SetAbsVolumeStateToEffect, state %{public}d", absVolumeState);
564 lock_guard<mutex> lock(lock_);
565 IHpaeManager::GetHpaeManager().SetAbsVolumeStateToEffect(absVolumeState);
566 return SUCCESS;
567 }
568 } // namespace AudioStandard
569 } // namespace OHOS
570
571 #endif // ST_PULSEAUDIO_AUDIO_SERVICE_ADAPTER_IMPL_H
572