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 #ifndef LOG_TAG
16 #define LOG_TAG "HpaeManager"
17 #endif
18
19 #include "hpae_manager.h"
20 #include <string>
21 #include <atomic>
22 #include <unordered_map>
23 #include "audio_errors.h"
24 #include "audio_schedule.h"
25 #include "audio_utils.h"
26 #include "hpae_node_common.h"
27 #include "audio_setting_provider.h"
28 #include "system_ability_definition.h"
29 #include "hpae_co_buffer_node.h"
30 #include "audio_engine_log.h"
31
32 namespace OHOS {
33 namespace AudioStandard {
34 namespace HPAE {
35 namespace {
36 constexpr uint32_t DEFAULT_SUSPEND_TIME_IN_MS = 3000; // 3s to stop hdi
37 static inline const std::unordered_set<SourceType> INNER_SOURCE_TYPE_SET = {
38 SOURCE_TYPE_PLAYBACK_CAPTURE, SOURCE_TYPE_REMOTE_CAST};
39 } // namespace
40 static constexpr int32_t SINK_INVALID_ID = -1;
41 static const std::string BT_SINK_NAME = "Bt_Speaker";
42
~HpaeManagerThread()43 HpaeManagerThread::~HpaeManagerThread()
44 {
45 DeactivateThread();
46 }
47
ActivateThread(HpaeManager * hpaeManager)48 void HpaeManagerThread::ActivateThread(HpaeManager *hpaeManager)
49 {
50 m_hpaeManager = hpaeManager;
51 auto threadFunc = std::bind(&HpaeManagerThread::Run, this);
52 thread_ = std::thread(threadFunc);
53 pthread_setname_np(thread_.native_handle(), "HpaeManager");
54 }
55
Run()56 void HpaeManagerThread::Run()
57 {
58 running_.store(true);
59 ScheduleThreadInServer(getpid(), gettid());
60 while (running_.load() && m_hpaeManager != nullptr) {
61 {
62 std::unique_lock<std::mutex> lock(mutex_);
63 bool isProcessing = m_hpaeManager->IsMsgProcessing();
64 bool signal = recvSignal_.load();
65 Trace trace("runFunc:" + std::to_string(signal) + " isPorcessing:" + std::to_string(isProcessing));
66 condition_.wait(lock, [this] { return m_hpaeManager->IsMsgProcessing() || recvSignal_.load(); });
67 }
68 m_hpaeManager->HandleMsg();
69 recvSignal_.store(false);
70 }
71 UnscheduleThreadInServer(getpid(), gettid());
72 }
73
Notify()74 void HpaeManagerThread::Notify()
75 {
76 std::unique_lock<std::mutex> lock(mutex_);
77 recvSignal_.store(true);
78 condition_.notify_all();
79 }
80
DeactivateThread()81 void HpaeManagerThread::DeactivateThread()
82 {
83 Notify();
84 running_.store(false);
85 if (thread_.joinable()) {
86 thread_.join();
87 }
88 }
89
HpaeManager()90 HpaeManager::HpaeManager() : hpaeNoLockQueue_(CURRENT_REQUEST_COUNT) // todo Message queue exceeds the upper limit
91 {
92 RegisterHandler(UPDATE_STATUS, &HpaeManager::HandleUpdateStatus);
93 RegisterHandler(INIT_DEVICE_RESULT, &HpaeManager::HandleInitDeviceResult);
94 RegisterHandler(MOVE_SINK_INPUT, &HpaeManager::HandleMoveSinkInput);
95 RegisterHandler(MOVE_ALL_SINK_INPUT, &HpaeManager::HandleMoveAllSinkInputs);
96 RegisterHandler(MOVE_SOURCE_OUTPUT, &HpaeManager::HandleMoveSourceOutput);
97 RegisterHandler(MOVE_ALL_SOURCE_OUTPUT, &HpaeManager::HandleMoveAllSourceOutputs);
98 RegisterHandler(DUMP_SINK_INFO, &HpaeManager::HandleDumpSinkInfo);
99 RegisterHandler(DUMP_SOURCE_INFO, &HpaeManager::HandleDumpSourceInfo);
100 RegisterHandler(MOVE_SESSION_FAILED, &HpaeManager::HandleMoveSessionFailed);
101 RegisterHandler(RELOAD_AUDIO_SINK_RESULT, &HpaeManager::HandleReloadDeviceResult);
102 RegisterHandler(CONNECT_CO_BUFFER_NODE, &HpaeManager::HandleConnectCoBufferNode);
103 RegisterHandler(DISCONNECT_CO_BUFFER_NODE, &HpaeManager::HandleDisConnectCoBufferNode);
104 RegisterHandler(INIT_SOURCE_RESULT, &HpaeManager::HandleInitSourceResult);
105 }
106
~HpaeManager()107 HpaeManager::~HpaeManager()
108 {
109 if (IsInit()) {
110 DeInit();
111 }
112 }
113
Init()114 int32_t HpaeManager::Init()
115 {
116 sinkSourceIndex_ = 0;
117 hpaeManagerThread_ = std::make_unique<HpaeManagerThread>();
118 hpaeManagerThread_->ActivateThread(this);
119 isInit_.store(true);
120 return 0;
121 }
122
SuspendAudioDevice(std::string & audioPortName,bool isSuspend)123 int32_t HpaeManager::SuspendAudioDevice(std::string &audioPortName, bool isSuspend)
124 {
125 auto request = [this, audioPortName, isSuspend]() {
126 if (SafeGetMap(rendererManagerMap_, audioPortName)) {
127 rendererManagerMap_[audioPortName]->SuspendStreamManager(isSuspend);
128 } else if (SafeGetMap(capturerManagerMap_, audioPortName)) {
129 AUDIO_WARNING_LOG("capture not support suspend");
130 return;
131 } else {
132 AUDIO_WARNING_LOG("can not find sink: %{public}s", audioPortName.c_str());
133 return;
134 }
135 };
136 SendRequest(request, __func__);
137 return SUCCESS;
138 }
139
SetSinkMute(const std::string & sinkName,bool isMute,bool isSync)140 bool HpaeManager::SetSinkMute(const std::string &sinkName, bool isMute, bool isSync)
141 {
142 auto request = [this, sinkName, isMute, isSync]() {
143 // todo for device change
144 AUDIO_INFO_LOG("HpaeManager::SetSinkMute sinkName: %{public}s isMute: %{public}d, isSync: %{public}d",
145 sinkName.c_str(),
146 isMute,
147 isSync);
148 if (SafeGetMap(rendererManagerMap_, sinkName)) {
149 rendererManagerMap_[sinkName]->SetMute(isMute);
150 } else {
151 AUDIO_WARNING_LOG("can not find sink: %{public}s for mute:%{public}d", sinkName.c_str(), isMute);
152 }
153 if (auto serviceCallback = serviceCallback_.lock()) {
154 serviceCallback->OnSetSinkMuteCb(SUCCESS);
155 }
156 };
157 SendRequest(request, __func__);
158 return SUCCESS;
159 }
160
SetSourceOutputMute(int32_t uid,bool isMute)161 int32_t HpaeManager::SetSourceOutputMute(int32_t uid, bool isMute)
162 {
163 auto request = [this, uid, isMute]() {
164 AUDIO_INFO_LOG("SetSourceOutputMute uid: %{public}d setMute: %{public}d", uid, isMute);
165 for (const auto &sourceInfo : sourceOutputs_) {
166 CHECK_AND_CONTINUE(sourceInfo.second.uid == uid);
167 auto captureManager = GetCapturerManagerById(sourceInfo.first);
168 CHECK_AND_CONTINUE_LOG(captureManager != nullptr,
169 "mute can not find CaptureManager by id:%{public}u with uid:%{public}d", sourceInfo.first, uid);
170 captureManager->SetStreamMute(sourceInfo.first, isMute);
171 }
172 if (auto serviceCallback = serviceCallback_.lock()) {
173 serviceCallback->OnSetSourceOutputMuteCb(SUCCESS);
174 }
175 };
176 SendRequest(request, __func__);
177 return SUCCESS;
178 }
179
GetAllSinks()180 int32_t HpaeManager::GetAllSinks()
181 {
182 auto request = [this]() {
183 std::vector<SinkInfo> sinks;
184 // todo for device change
185 AUDIO_INFO_LOG("HpaeManager::GetAllSinks end");
186 if (auto serviceCallback = serviceCallback_.lock()) {
187 serviceCallback->OnGetAllSinksCb(SUCCESS, sinks);
188 }
189 };
190 SendRequest(request, __func__);
191 return SUCCESS;
192 }
193
DeInit()194 int32_t HpaeManager::DeInit()
195 {
196 if (hpaeManagerThread_ != nullptr) {
197 hpaeManagerThread_->DeactivateThread();
198 hpaeManagerThread_ = nullptr;
199 }
200 hpaeNoLockQueue_.HandleRequests(); // todo suspend
201 isInit_.store(false);
202 AUDIO_INFO_LOG("HpaeManager::DeInit end");
203 return SUCCESS;
204 }
205
RegisterSerivceCallback(const std::weak_ptr<AudioServiceHpaeCallback> & callback)206 int32_t HpaeManager::RegisterSerivceCallback(const std::weak_ptr<AudioServiceHpaeCallback> &callback)
207 {
208 auto request = [this, callback]() {
209 serviceCallback_ = callback;
210 AUDIO_INFO_LOG("HpaeManager::RegisterSerivceCallback end");
211 };
212 SendRequest(request, __func__);
213 return SUCCESS;
214 }
215
RegisterHpaeDumpCallback(const std::weak_ptr<AudioServiceHpaeDumpCallback> & callback)216 int32_t HpaeManager::RegisterHpaeDumpCallback(const std::weak_ptr<AudioServiceHpaeDumpCallback> &callback)
217 {
218 auto request = [this, callback]() {
219 dumpCallback_ = callback;
220 AUDIO_INFO_LOG("HpaeManager::RegisterHpaeDumpCallback end");
221 };
222 SendRequest(request, __func__);
223 return SUCCESS;
224 }
225
OnCallbackOpenOrReloadFailed(bool isReload)226 void HpaeManager::OnCallbackOpenOrReloadFailed(bool isReload)
227 {
228 if (auto serviceCallback = serviceCallback_.lock()) {
229 if (isReload) {
230 serviceCallback->OnReloadAudioPortCb(SINK_INVALID_ID);
231 } else {
232 serviceCallback->OnOpenAudioPortCb(SINK_INVALID_ID);
233 }
234 }
235 }
236
ReloadRenderManager(const AudioModuleInfo & audioModuleInfo,bool isReload)237 int32_t HpaeManager::ReloadRenderManager(const AudioModuleInfo &audioModuleInfo, bool isReload)
238 {
239 HpaeSinkInfo sinkInfo;
240 sinkInfo.sinkId = sinkNameSinkIdMap_[audioModuleInfo.name];
241 sinkInfo.suspendTime = DEFAULT_SUSPEND_TIME_IN_MS;
242 int32_t ret = TransModuleInfoToHpaeSinkInfo(audioModuleInfo, sinkInfo);
243 if (ret != SUCCESS) {
244 OnCallbackOpenOrReloadFailed(isReload);
245 return ret;
246 }
247 if (isReload) {
248 sinkIdSinkNameMap_.erase(sinkNameSinkIdMap_[audioModuleInfo.name]);
249 uint32_t sinkSourceIndex = static_cast<uint32_t>(sinkSourceIndex_.load());
250 sinkInfo.sinkId = sinkSourceIndex;
251 sinkSourceIndex_.fetch_add(1);
252 sinkIdSinkNameMap_[sinkSourceIndex] = audioModuleInfo.name;
253 sinkNameSinkIdMap_[audioModuleInfo.name] = sinkSourceIndex;
254 }
255 rendererManagerMap_[audioModuleInfo.name]->ReloadRenderManager(sinkInfo, isReload);
256 return SUCCESS;
257 }
258
CreateRendererManager(const AudioModuleInfo & audioModuleInfo,uint32_t sinkSourceIndex,bool isReload)259 int32_t HpaeManager::CreateRendererManager(const AudioModuleInfo &audioModuleInfo,
260 uint32_t sinkSourceIndex, bool isReload)
261 {
262 sinkSourceIndex_.fetch_add(1);
263 HpaeSinkInfo sinkInfo;
264 sinkInfo.sinkId = sinkSourceIndex;
265 sinkInfo.suspendTime = DEFAULT_SUSPEND_TIME_IN_MS;
266 int32_t ret = TransModuleInfoToHpaeSinkInfo(audioModuleInfo, sinkInfo);
267 if (ret != SUCCESS) {
268 OnCallbackOpenOrReloadFailed(isReload);
269 return ret;
270 }
271 auto rendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
272 rendererManager->RegisterSendMsgCallback(weak_from_this());
273 rendererManagerMap_[audioModuleInfo.name] = rendererManager;
274 sinkNameSinkIdMap_[audioModuleInfo.name] = sinkSourceIndex;
275 sinkIdSinkNameMap_[sinkSourceIndex] = audioModuleInfo.name;
276 if (defaultSink_ == "" && coreSink_ == "") {
277 defaultSink_ = audioModuleInfo.name;
278 coreSink_ = audioModuleInfo.name;
279 AUDIO_INFO_LOG("SetDefaultSink name: %{public}s", defaultSink_.c_str());
280 }
281 rendererManager->Init(isReload);
282 AUDIO_INFO_LOG(
283 "open sink name: %{public}s end sinkIndex is %{public}u", audioModuleInfo.name.c_str(), sinkSourceIndex);
284 return SUCCESS;
285 }
286
OpenOutputAudioPort(const AudioModuleInfo & audioModuleInfo,uint32_t sinkSourceIndex)287 int32_t HpaeManager::OpenOutputAudioPort(const AudioModuleInfo &audioModuleInfo, uint32_t sinkSourceIndex)
288 {
289 if (SafeGetMap(rendererManagerMap_, audioModuleInfo.name)) {
290 AUDIO_INFO_LOG("sink name: %{public}s already open", audioModuleInfo.name.c_str());
291 if (!rendererManagerMap_[audioModuleInfo.name]->IsInit()) {
292 if (ReloadRenderManager(audioModuleInfo) != SUCCESS) {
293 return ERROR;
294 }
295 } else if (auto serviceCallback = serviceCallback_.lock()) {
296 serviceCallback->OnOpenAudioPortCb(sinkNameSinkIdMap_[audioModuleInfo.name]);
297 }
298 return sinkNameSinkIdMap_[audioModuleInfo.name];
299 }
300
301 return CreateRendererManager(audioModuleInfo, sinkSourceIndex);
302 }
303
OpenInputAudioPort(const AudioModuleInfo & audioModuleInfo,uint32_t sinkSourceIndex)304 int32_t HpaeManager::OpenInputAudioPort(const AudioModuleInfo &audioModuleInfo, uint32_t sinkSourceIndex)
305 {
306 HpaeSourceInfo sourceInfo;
307 int32_t ret = TransModuleInfoToHpaeSourceInfo(audioModuleInfo, sourceInfo);
308 if (ret != SUCCESS) {
309 if (auto serviceCallback = serviceCallback_.lock()) {
310 serviceCallback->OnOpenAudioPortCb(SINK_INVALID_ID);
311 }
312 return ret;
313 }
314 if (SafeGetMap(capturerManagerMap_, audioModuleInfo.name)) {
315 HpaeSourceInfo oldInfo = capturerManagerMap_[audioModuleInfo.name]->GetSourceInfo();
316 if (CheckSourceInfoIsDifferent(sourceInfo, oldInfo)) {
317 AUDIO_INFO_LOG("source name: %{public}s need reload", audioModuleInfo.name.c_str());
318 sourceInfo.sourceId = oldInfo.sourceId;
319 capturerManagerMap_[audioModuleInfo.name]->ReloadCaptureManager(sourceInfo);
320 return sourceNameSourceIdMap_[audioModuleInfo.name];
321 }
322 AUDIO_INFO_LOG("source name: %{public}s already open", audioModuleInfo.name.c_str());
323 if (!capturerManagerMap_[audioModuleInfo.name]->IsInit()) {
324 capturerManagerMap_[audioModuleInfo.name]->Init();
325 } else if (auto serviceCallback = serviceCallback_.lock()) {
326 serviceCallback->OnOpenAudioPortCb(sourceNameSourceIdMap_[audioModuleInfo.name]);
327 }
328 return sourceNameSourceIdMap_[audioModuleInfo.name];
329 }
330 sinkSourceIndex_.fetch_add(1);
331 sourceInfo.sourceId = sinkSourceIndex;
332 auto capturerManager = std::make_shared<HpaeCapturerManager>(sourceInfo);
333 capturerManager->RegisterSendMsgCallback(weak_from_this());
334 capturerManagerMap_[audioModuleInfo.name] = capturerManager;
335 sourceNameSourceIdMap_[audioModuleInfo.name] = sinkSourceIndex;
336 sourceIdSourceNameMap_[sinkSourceIndex] = audioModuleInfo.name;
337 capturerManagerMap_[audioModuleInfo.name]->Init();
338 AUDIO_INFO_LOG(
339 "open source name: %{public}s end sourceIndex is %{public}u", audioModuleInfo.name.c_str(), sinkSourceIndex);
340 return SUCCESS;
341 }
342
OpenVirtualAudioPort(const AudioModuleInfo & audioModuleInfo,uint32_t sinkSourceIndex)343 int32_t HpaeManager::OpenVirtualAudioPort(const AudioModuleInfo &audioModuleInfo, uint32_t sinkSourceIndex)
344 {
345 if (SafeGetMap(rendererManagerMap_, audioModuleInfo.name)) {
346 AUDIO_INFO_LOG("inner capture name: %{public}s already open", audioModuleInfo.name.c_str());
347 if (!rendererManagerMap_[audioModuleInfo.name]->IsInit()) {
348 rendererManagerMap_[audioModuleInfo.name]->Init();
349 } else if (auto serviceCallback = serviceCallback_.lock()) {
350 serviceCallback->OnOpenAudioPortCb(sinkNameSinkIdMap_[audioModuleInfo.name]);
351 }
352 return sinkNameSinkIdMap_[audioModuleInfo.name];
353 }
354 sinkSourceIndex_.fetch_add(1);
355 HpaeSinkInfo sinkInfo;
356 sinkInfo.sinkId = sinkSourceIndex;
357 int32_t ret = TransModuleInfoToHpaeSinkInfo(audioModuleInfo, sinkInfo);
358 sinkInfo.deviceClass = audioModuleInfo.name;
359 sinkInfo.adapterName = audioModuleInfo.name;
360 if (ret != SUCCESS) {
361 if (auto serviceCallback = serviceCallback_.lock()) {
362 serviceCallback->OnOpenAudioPortCb(SINK_INVALID_ID);
363 }
364 return ret;
365 }
366 auto rendererManager = IHpaeRendererManager::CreateRendererManager(sinkInfo);
367 rendererManager->RegisterSendMsgCallback(weak_from_this());
368 rendererManagerMap_[audioModuleInfo.name] = rendererManager;
369 sinkNameSinkIdMap_[audioModuleInfo.name] = sinkSourceIndex;
370 sinkIdSinkNameMap_[sinkSourceIndex] = audioModuleInfo.name;
371 rendererManagerMap_[audioModuleInfo.name]->Init();
372 AUDIO_INFO_LOG("HpaeManager::OpenAudioPort name: %{public}s end sinkIndex is %{public}u",
373 audioModuleInfo.name.c_str(),
374 sinkSourceIndex);
375 return SUCCESS;
376 }
377
OpenAudioPortInner(const AudioModuleInfo & audioModuleInfo)378 int32_t HpaeManager::OpenAudioPortInner(const AudioModuleInfo &audioModuleInfo)
379 {
380 uint32_t sinkSourceIndex = static_cast<uint32_t>(sinkSourceIndex_.load());
381 if ((audioModuleInfo.lib != "libmodule-hdi-source.z.so") &&
382 (audioModuleInfo.lib != "libmodule-inner-capturer-sink.z.so")) {
383 OpenOutputAudioPort(audioModuleInfo, sinkSourceIndex);
384 } else if (audioModuleInfo.lib == "libmodule-hdi-source.z.so") {
385 OpenInputAudioPort(audioModuleInfo, sinkSourceIndex);
386 } else {
387 OpenVirtualAudioPort(audioModuleInfo, sinkSourceIndex);
388 }
389 return sinkSourceIndex;
390 }
391
OpenAudioPort(const AudioModuleInfo & audioModuleInfo)392 uint32_t HpaeManager::OpenAudioPort(const AudioModuleInfo &audioModuleInfo)
393 {
394 auto request = [this, audioModuleInfo]() {
395 PrintAudioModuleInfo(audioModuleInfo);
396 OpenAudioPortInner(audioModuleInfo);
397 };
398 SendRequest(request, __func__);
399 return SUCCESS;
400 }
401
ReloadAudioPort(const AudioModuleInfo & audioModuleInfo)402 uint32_t HpaeManager::ReloadAudioPort(const AudioModuleInfo &audioModuleInfo)
403 {
404 auto request = [this, audioModuleInfo]() {
405 if (audioModuleInfo.lib != "libmodule-hdi-sink.z.so") {
406 AUDIO_ERR_LOG("currect device:%{public}s not support reload.", audioModuleInfo.name.c_str());
407 OnCallbackOpenOrReloadFailed(true);
408 return;
409 }
410
411 PrintAudioModuleInfo(audioModuleInfo);
412 if (SafeGetMap(rendererManagerMap_, audioModuleInfo.name)) {
413 ReloadRenderManager(audioModuleInfo, true);
414 return;
415 }
416
417 AUDIO_INFO_LOG("currect device:%{public}s not exist.", audioModuleInfo.name.c_str());
418 uint32_t sinkSourceIndex = static_cast<uint32_t>(sinkSourceIndex_.load());
419 CreateRendererManager(audioModuleInfo, sinkSourceIndex, true);
420 };
421 SendRequest(request, __func__);
422 return SUCCESS;
423 }
424
DumpSinkInfo(std::string deviceName)425 void HpaeManager::DumpSinkInfo(std::string deviceName)
426 {
427 auto request = [this, deviceName]() {
428 AUDIO_INFO_LOG("DumpSinkInfo %{public}s", deviceName.c_str());
429 if (!SafeGetMap(rendererManagerMap_, deviceName) ||
430 rendererManagerMap_[deviceName]->DumpSinkInfo() != SUCCESS) {
431 AUDIO_WARNING_LOG("dump sink %{public}s info error", deviceName.c_str());
432 if (auto callback = dumpCallback_.lock()) {
433 std::string dumpStr;
434 callback->OnDumpSinkInfoCb(dumpStr, ERROR);
435 }
436 }
437 };
438 SendRequest(request, __func__);
439 }
440
DumpSourceInfo(std::string deviceName)441 void HpaeManager::DumpSourceInfo(std::string deviceName)
442 {
443 auto request = [this, deviceName]() {
444 AUDIO_INFO_LOG("DumpSourceInfo %{public}s", deviceName.c_str());
445 if (!SafeGetMap(capturerManagerMap_, deviceName) ||
446 capturerManagerMap_[deviceName]->DumpSourceInfo() != SUCCESS) {
447 AUDIO_WARNING_LOG("dump source %{public}s info error", deviceName.c_str());
448 if (auto callback = dumpCallback_.lock()) {
449 std::string dumpStr;
450 callback->OnDumpSourceInfoCb(dumpStr, ERROR);
451 }
452 }
453 };
454 SendRequest(request, __func__);
455 }
456
DumpAllAvailableDevice(HpaeDeviceInfo & devicesInfo)457 void HpaeManager::DumpAllAvailableDevice(HpaeDeviceInfo &devicesInfo)
458 {
459 auto request = [this, &devicesInfo]() {
460 AUDIO_INFO_LOG("DumpAllAvailableDevice");
461 devicesInfo.sinkInfos.clear();
462 for (auto rendererPair : rendererManagerMap_) {
463 devicesInfo.sinkInfos.emplace_back(
464 HpaeSinkSourceInfo{rendererPair.first, rendererPair.second->GetDeviceHDFDumpInfo()});
465 }
466 devicesInfo.sourceInfos.clear();
467 for (auto capturerPair : capturerManagerMap_) {
468 devicesInfo.sourceInfos.emplace_back(
469 HpaeSinkSourceInfo{capturerPair.first, capturerPair.second->GetDeviceHDFDumpInfo()});
470 }
471 if (auto callback = dumpCallback_.lock()) {
472 callback->OnDumpAllAvailableDeviceCb(SUCCESS);
473 }
474 };
475 SendRequest(request, __func__);
476 }
477
DumpSinkInputsInfo()478 void HpaeManager::DumpSinkInputsInfo()
479 {
480 auto request = [this]() {
481 AUDIO_INFO_LOG("DumpSinkInputsInfo");
482 std::vector<HpaeInputOutputInfo> sinkInputs;
483 TransStreamInfoToStreamDumpInfo(rendererIdStreamInfoMap_, sinkInputs);
484 if (auto callback = dumpCallback_.lock()) {
485 callback->OnDumpSinkInputsInfoCb(sinkInputs, SUCCESS);
486 }
487 };
488 SendRequest(request, __func__);
489 }
490
DumpSourceOutputsInfo()491 void HpaeManager::DumpSourceOutputsInfo()
492 {
493 auto request = [this]() {
494 AUDIO_INFO_LOG("DumpSourceOutputsInfo");
495 std::vector<HpaeInputOutputInfo> sourceOutputs;
496 TransStreamInfoToStreamDumpInfo(capturerIdStreamInfoMap_, sourceOutputs);
497 if (auto callback = dumpCallback_.lock()) {
498 callback->OnDumpSourceOutputsInfoCb(sourceOutputs, SUCCESS);
499 }
500 };
501 SendRequest(request, __func__);
502 }
503
AddPreferSinkForDefaultChange(bool isAdd,const std::string & sinkName)504 void HpaeManager::AddPreferSinkForDefaultChange(bool isAdd, const std::string &sinkName)
505 {
506 if (!isAdd) {
507 return;
508 }
509 for (const auto& sinkinput : rendererIdSinkNameMap_) {
510 if (sinkinput.second == sinkName) {
511 idPreferSinkNameMap_[sinkinput.first] = sinkName;
512 }
513 }
514 }
515
CloseOutAudioPort(std::string sinkName)516 int32_t HpaeManager::CloseOutAudioPort(std::string sinkName)
517 {
518 if (!SafeGetMap(rendererManagerMap_, sinkName)) {
519 AUDIO_WARNING_LOG("can not find sinkName: %{public}s in rendererManagerMap_", sinkName.c_str());
520 return SUCCESS;
521 }
522 bool isChangeDefaultSink = false;
523 if (sinkName == defaultSink_ && defaultSink_ != coreSink_) {
524 if (GetRendererManagerByName(coreSink_) != nullptr) {
525 AUDIO_INFO_LOG("reset default sink to core sink.");
526 defaultSink_ = coreSink_;
527 isChangeDefaultSink = true;
528 } else {
529 AUDIO_ERR_LOG("can not find core sink to replace default sink.");
530 }
531 }
532 AddPreferSinkForDefaultChange(isChangeDefaultSink, sinkName);
533 rendererManagerMap_[sinkName]->DeInit(sinkName != defaultSink_);
534 if (sinkName != defaultSink_) {
535 rendererManagerMap_.erase(sinkName);
536 sinkIdSinkNameMap_.erase(sinkNameSinkIdMap_[sinkName]);
537 sinkNameSinkIdMap_.erase(sinkName);
538 }
539 return SUCCESS;
540 }
541
CloseInAudioPort(std::string sourceName)542 int32_t HpaeManager::CloseInAudioPort(std::string sourceName)
543 {
544 if (!SafeGetMap(capturerManagerMap_, sourceName)) {
545 AUDIO_WARNING_LOG("can not find sourceName: %{public}s in capturerManagerMap_", sourceName.c_str());
546 return SUCCESS;
547 }
548 capturerManagerMap_[sourceName]->DeInit(sourceName != defaultSource_);
549 if (sourceName != defaultSource_) {
550 capturerManagerMap_.erase(sourceName);
551 sourceIdSourceNameMap_.erase(sourceNameSourceIdMap_[sourceName]);
552 sourceNameSourceIdMap_.erase(sourceName);
553 }
554 return SUCCESS;
555 }
556
CloseAudioPort(int32_t audioHandleIndex)557 int32_t HpaeManager::CloseAudioPort(int32_t audioHandleIndex)
558 {
559 auto request = [this, audioHandleIndex]() {
560 int32_t ret = -1;
561 if (sinkIdSinkNameMap_.find(audioHandleIndex) != sinkIdSinkNameMap_.end()) {
562 AUDIO_INFO_LOG("CloseAudioPort index: %{public}d name %{public}s",
563 audioHandleIndex, sinkIdSinkNameMap_[audioHandleIndex].c_str());
564 ret = CloseOutAudioPort(sinkIdSinkNameMap_[audioHandleIndex]);
565 } else {
566 AUDIO_INFO_LOG("CloseAudioPort index: %{public}d name %{public}s",
567 audioHandleIndex, sourceIdSourceNameMap_[audioHandleIndex].c_str());
568 ret = CloseInAudioPort(sourceIdSourceNameMap_[audioHandleIndex]);
569 }
570 if (auto serviceCallback = serviceCallback_.lock()) {
571 serviceCallback->OnCloseAudioPortCb(ret);
572 }
573 };
574 SendRequest(request, __func__);
575 return SUCCESS;
576 }
577
GetSinkInfoByIdx(const int32_t & sinkIdx,std::function<void (const HpaeSinkInfo & sinkInfo,int32_t result)> callback)578 int32_t HpaeManager::GetSinkInfoByIdx(const int32_t &sinkIdx,
579 std::function<void(const HpaeSinkInfo &sinkInfo, int32_t result)> callback)
580 {
581 auto request = [this, sinkIdx, callback]() {
582 if (sinkIdSinkNameMap_.find(sinkIdx) == sinkIdSinkNameMap_.end() ||
583 rendererManagerMap_.find(sinkIdSinkNameMap_[sinkIdx]) == rendererManagerMap_.end()) {
584 AUDIO_ERR_LOG("GetSinkInfoByIdx err, sink[%{public}d] not open", sinkIdx);
585 callback(HpaeSinkInfo{}, ERROR);
586 return;
587 }
588 callback(rendererManagerMap_[sinkIdSinkNameMap_[sinkIdx]]->GetSinkInfo(), SUCCESS);
589 };
590 SendRequest(request, __func__);
591 return SUCCESS;
592 }
593
GetSourceInfoByIdx(const int32_t & sourceIdx,std::function<void (const HpaeSourceInfo & sourceInfo,int32_t result)> callback)594 int32_t HpaeManager::GetSourceInfoByIdx(const int32_t &sourceIdx,
595 std::function<void(const HpaeSourceInfo &sourceInfo, int32_t result)> callback)
596 {
597 auto request = [this, sourceIdx, callback]() {
598 if (sourceIdSourceNameMap_.find(sourceIdx) == sourceIdSourceNameMap_.end() ||
599 capturerManagerMap_.find(sourceIdSourceNameMap_[sourceIdx]) == capturerManagerMap_.end()) {
600 AUDIO_ERR_LOG("GetSourceInfoByIdx err, source[%{public}d] not open", sourceIdx);
601 callback(HpaeSourceInfo{}, ERROR);
602 return;
603 }
604 callback(capturerManagerMap_[sourceIdSourceNameMap_[sourceIdx]]->GetSourceInfo(), SUCCESS);
605 };
606 SendRequest(request, __func__);
607 return SUCCESS;
608 }
609
SetDefaultSink(std::string name)610 int32_t HpaeManager::SetDefaultSink(std::string name)
611 {
612 CHECK_AND_RETURN_RET_LOG(!name.empty(), ERROR_INVALID_PARAM, "invalid sink name");
613 AUDIO_INFO_LOG("HpaeManager::SetDefaultSink name: %{public}s", name.c_str());
614 auto request = [this, name]() {
615 AUDIO_INFO_LOG("SetDefaultSink name: %{public}s", name.c_str());
616 if (name == defaultSink_) {
617 AUDIO_INFO_LOG("sink is same as default sink");
618 return;
619 }
620 if (!SafeGetMap(rendererManagerMap_, name)) {
621 AUDIO_WARNING_LOG("sink: %{public}s not exist, do not change default sink", name.c_str());
622 return;
623 }
624 std::shared_ptr<IHpaeRendererManager> rendererManager = GetRendererManagerByName(defaultSink_);
625 if (rendererManager == nullptr) {
626 AUDIO_INFO_LOG("default sink not exist, set default sink direct");
627 defaultSink_ = name;
628 return;
629 }
630 std::vector<uint32_t> sessionIds;
631 rendererManager->MoveAllStream(name, sessionIds, MOVE_ALL);
632 std::string oldDefaultSink = defaultSink_;
633 defaultSink_ = name;
634 if (!rendererManager->IsInit()) {
635 rendererManagerMap_.erase(oldDefaultSink);
636 sinkIdSinkNameMap_.erase(sinkNameSinkIdMap_[oldDefaultSink]);
637 sinkNameSinkIdMap_.erase(oldDefaultSink);
638 }
639 };
640 SendRequest(request, __func__);
641 return SUCCESS;
642 }
643
SetDefaultSource(std::string name)644 int32_t HpaeManager::SetDefaultSource(std::string name)
645 {
646 CHECK_AND_RETURN_RET_LOG(!name.empty(), ERROR_INVALID_PARAM, "invalid source name");
647 auto request = [this, name]() {
648 if (name == defaultSource_) {
649 AUDIO_INFO_LOG("source is same as default source");
650 return;
651 }
652 if (!SafeGetMap(capturerManagerMap_, name)) {
653 AUDIO_WARNING_LOG("source: %{public}s not exist, do not change default source", name.c_str());
654 return;
655 }
656 std::shared_ptr<IHpaeCapturerManager> capturerManager = GetCapturerManagerByName(defaultSource_);
657 if (capturerManager == nullptr) {
658 AUDIO_INFO_LOG("default source not exist, set default source direct");
659 defaultSource_ = name;
660 return;
661 }
662 std::vector<uint32_t> sessionIds;
663 capturerManager->MoveAllStream(name, sessionIds, MOVE_ALL);
664 std::string oldDefaultSource_ = defaultSource_;
665 defaultSource_ = name;
666 if (!capturerManager->IsInit()) {
667 capturerManagerMap_.erase(oldDefaultSource_);
668 sourceIdSourceNameMap_.erase(sourceNameSourceIdMap_[oldDefaultSource_]);
669 sourceNameSourceIdMap_.erase(oldDefaultSource_);
670 }
671 };
672 SendRequest(request, __func__);
673 return SUCCESS;
674 }
675
GetAllSinkInputs()676 int32_t HpaeManager::GetAllSinkInputs()
677 {
678 AUDIO_INFO_LOG("GetAllSinkInputs");
679 auto request = [this]() {
680 std::vector<SinkInput> results;
681 std::transform(sinkInputs_.begin(), sinkInputs_.end(), std::back_inserter(results), [](const auto &pair) {
682 return pair.second;
683 });
684 AUDIO_INFO_LOG("sink input number:%{public}zu", results.size());
685 if (auto serviceCallback = serviceCallback_.lock()) {
686 serviceCallback->OnGetAllSinkInputsCb(SUCCESS, results);
687 }
688 };
689 SendRequest(request, __func__);
690 return SUCCESS;
691 }
692
MoveToPreferSink(const std::string & name,std::shared_ptr<AudioServiceHpaeCallback> & serviceCallback)693 void HpaeManager::MoveToPreferSink(const std::string &name, std::shared_ptr<AudioServiceHpaeCallback> &serviceCallback)
694 {
695 AUDIO_INFO_LOG("enter in");
696 std::vector<uint32_t> sessionIds;
697 for (const auto &id : idPreferSinkNameMap_) {
698 if (id.second == name && rendererIdStreamInfoMap_[id.first].state == HPAE_SESSION_RUNNING &&
699 rendererIdSinkNameMap_[id.first] != id.second && rendererIdSinkNameMap_[id.first] == defaultSink_) {
700 sessionIds.emplace_back(id.first);
701 movingIds_.emplace(id.first, HPAE_SESSION_RUNNING);
702 }
703 }
704 if (sessionIds.size() == 0) {
705 serviceCallback->OnOpenAudioPortCb(sinkNameSinkIdMap_[name]);
706 return;
707 }
708 auto request = [this, name, sessionIds, serviceCallback]() {
709 AUDIO_INFO_LOG("Move %{public}s To Prefer Sink: %{public}s", defaultSink_.c_str(), name.c_str());
710 if (!SafeGetMap(rendererManagerMap_, defaultSink_)) {
711 AUDIO_ERR_LOG("can not find default sink: %{public}s", defaultSink_.c_str());
712 serviceCallback->OnOpenAudioPortCb(sinkNameSinkIdMap_[name]);
713 return;
714 }
715 rendererManagerMap_[defaultSink_]->MoveAllStream(name, sessionIds, MOVE_PREFER);
716 };
717 SendRequest(request, __func__);
718 }
719
GetAllSourceOutputs()720 int32_t HpaeManager::GetAllSourceOutputs()
721 {
722 AUDIO_INFO_LOG("GetAllSourceOutputs");
723 auto request = [this]() {
724 std::vector<SourceOutput> results;
725 std::transform(sourceOutputs_.begin(), sourceOutputs_.end(), std::back_inserter(results), [](const auto &pair) {
726 return pair.second;
727 });
728 AUDIO_INFO_LOG("source output number:%{public}zu", results.size());
729 if (auto serviceCallback = serviceCallback_.lock()) {
730 serviceCallback->OnGetAllSourceOutputsCb(SUCCESS, results);
731 }
732 };
733 SendRequest(request, __func__);
734 return SUCCESS;
735 }
736
MoveSourceOutputByIndexOrName(uint32_t sourceOutputId,uint32_t sourceIndex,std::string sourceName)737 int32_t HpaeManager::MoveSourceOutputByIndexOrName(
738 uint32_t sourceOutputId, uint32_t sourceIndex, std::string sourceName)
739 {
740 auto request = [this, sourceOutputId, sourceName]() {
741 if (!CheckMoveSourceOutput(sourceOutputId, sourceName)) {
742 if (auto serviceCallback = serviceCallback_.lock()) {
743 serviceCallback->OnMoveSourceOutputByIndexOrNameCb(ERROR_INVALID_PARAM);
744 }
745 return;
746 }
747 std::string name = capturerIdSourceNameMap_[sourceOutputId];
748 if (sourceName == name) {
749 AUDIO_INFO_LOG("move session:%{public}u,source:%{public}s is the same, no need move",
750 sourceOutputId, sourceName.c_str());
751 if (auto serviceCallback = serviceCallback_.lock()) {
752 serviceCallback->OnMoveSourceOutputByIndexOrNameCb(SUCCESS);
753 }
754 return;
755 }
756 std::shared_ptr<IHpaeCapturerManager> oldCaptureManager = GetCapturerManagerById(sourceOutputId);
757 AUDIO_INFO_LOG("start move session:%{public}u, [%{public}s] --> [%{public}s], state:%{public}d",
758 sourceOutputId, name.c_str(), sourceName.c_str(), capturerIdStreamInfoMap_[sourceOutputId].state);
759 movingIds_.emplace(sourceOutputId, capturerIdStreamInfoMap_[sourceOutputId].state);
760 oldCaptureManager->MoveStream(sourceOutputId, sourceName);
761 };
762 SendRequest(request, __func__);
763 return SUCCESS;
764 }
765
CheckMoveSourceOutput(uint32_t sourceOutputId,const std::string & sourceName)766 bool HpaeManager::CheckMoveSourceOutput(uint32_t sourceOutputId, const std::string &sourceName)
767 {
768 if (sourceName.empty()) {
769 AUDIO_ERR_LOG("move session:%{public}u failed,source name is empty.", sourceOutputId);
770 return false;
771 }
772 std::shared_ptr<IHpaeCapturerManager> captureManager = GetCapturerManagerByName(sourceName);
773 if (captureManager == nullptr || !captureManager->IsInit()) {
774 AUDIO_ERR_LOG("move session:%{public}u failed, can not find source:%{public}s or source is not open.",
775 sourceOutputId, sourceName.c_str());
776 return false;
777 }
778 std::shared_ptr<IHpaeCapturerManager> oldCaptureManager = GetCapturerManagerById(sourceOutputId);
779 if (oldCaptureManager == nullptr) {
780 AUDIO_ERR_LOG("move session:%{public}u failed,can not find source.", sourceOutputId);
781 return false;
782 }
783 if (capturerIdStreamInfoMap_.find(sourceOutputId) == capturerIdStreamInfoMap_.end()) {
784 AUDIO_ERR_LOG("move session:%{public}u failed,can not find session.", sourceOutputId);
785 return false;
786 }
787 if (!capturerIdStreamInfoMap_[sourceOutputId].streamInfo.isMoveAble) {
788 AUDIO_ERR_LOG("move session:%{public}u failed,session is not moveable.", sourceOutputId);
789 return false;
790 }
791 return true;
792 }
793
CheckMoveSinkInput(uint32_t sinkInputId,const std::string & sinkName)794 bool HpaeManager::CheckMoveSinkInput(uint32_t sinkInputId, const std::string &sinkName)
795 {
796 if (sinkName.empty()) {
797 AUDIO_ERR_LOG("move session:%{public}u failed,sink name is empty.", sinkInputId);
798 return false;
799 }
800 std::shared_ptr<IHpaeRendererManager> rendererManager = GetRendererManagerByName(sinkName);
801 if (rendererManager == nullptr || !rendererManager->IsInit()) {
802 AUDIO_ERR_LOG("move session:%{public}u failed, can not find sink:%{public}s or sink is not open.",
803 sinkInputId, sinkName.c_str());
804 return false;
805 }
806 std::shared_ptr<IHpaeRendererManager> oldRendererManager = GetRendererManagerById(sinkInputId);
807 if (oldRendererManager == nullptr) {
808 AUDIO_ERR_LOG("move session:%{public}u failed,can not find sink", sinkInputId);
809 return false;
810 }
811 if (rendererIdStreamInfoMap_.find(sinkInputId) == rendererIdStreamInfoMap_.end()) {
812 AUDIO_ERR_LOG("move session:%{public}u failed,can not find session", sinkInputId);
813 return false;
814 }
815 if (!rendererIdStreamInfoMap_[sinkInputId].streamInfo.isMoveAble) {
816 AUDIO_ERR_LOG("move session:%{public}u failed,session is not moveable.", sinkInputId);
817 return false;
818 }
819 return true;
820 }
821
MoveSinkInputByIndexOrName(uint32_t sinkInputId,uint32_t sinkIndex,std::string sinkName)822 int32_t HpaeManager::MoveSinkInputByIndexOrName(uint32_t sinkInputId, uint32_t sinkIndex, std::string sinkName)
823 {
824 auto request = [this, sinkInputId, sinkName]() {
825 if (!CheckMoveSinkInput(sinkInputId, sinkName)) {
826 if (auto serviceCallback = serviceCallback_.lock()) {
827 serviceCallback->OnMoveSinkInputByIndexOrNameCb(ERROR_INVALID_PARAM);
828 }
829 return;
830 }
831
832 std::string name = rendererIdSinkNameMap_[sinkInputId];
833 if (sinkName == name) {
834 AUDIO_INFO_LOG("sink:%{public}s is the same, no need move session:%{public}u", sinkName.c_str(),
835 sinkInputId);
836 if (auto serviceCallback = serviceCallback_.lock()) {
837 serviceCallback->OnMoveSinkInputByIndexOrNameCb(SUCCESS);
838 }
839 return;
840 }
841
842 std::shared_ptr<IHpaeRendererManager> oldRendererManager = GetRendererManagerById(sinkInputId);
843 AUDIO_INFO_LOG("start move session:%{public}u, [%{public}s] --> [%{public}s],state:%{public}d",
844 sinkInputId, name.c_str(), sinkName.c_str(), rendererIdStreamInfoMap_[sinkInputId].state);
845 movingIds_.emplace(sinkInputId, rendererIdStreamInfoMap_[sinkInputId].state);
846 oldRendererManager->MoveStream(sinkInputId, sinkName);
847 };
848 SendRequest(request, __func__);
849 return SUCCESS;
850 }
851
HandleMsg()852 void HpaeManager::HandleMsg()
853 {
854 hpaeNoLockQueue_.HandleRequests();
855 }
856
IsInit()857 bool HpaeManager::IsInit()
858 {
859 return isInit_.load();
860 }
861
IsRunning()862 bool HpaeManager::IsRunning()
863 {
864 if (hpaeManagerThread_ == nullptr) {
865 return false;
866 }
867 return hpaeManagerThread_->IsRunning();
868 }
869
IsMsgProcessing()870 bool HpaeManager::IsMsgProcessing()
871 {
872 return !hpaeNoLockQueue_.IsFinishProcess();
873 }
874
GetMsgCount()875 int32_t HpaeManager::GetMsgCount()
876 {
877 return receiveMsgCount_.load();
878 }
879
Invoke(HpaeMsgCode cmdID,const std::any & args)880 void HpaeManager::Invoke(HpaeMsgCode cmdID, const std::any &args)
881 {
882 auto it = handlers_.find(cmdID);
883 if (it != handlers_.end()) {
884 auto request = [it, args]() { it->second(args); };
885 SendRequest(request, __func__);
886 return;
887 };
888 AUDIO_ERR_LOG("HpaeManager::Invoke cmdID %{public}d not found", (int32_t)cmdID);
889 }
890
891 template <typename... Args>
RegisterHandler(HpaeMsgCode cmdID,void (HpaeManager::* func)(Args...))892 void HpaeManager::RegisterHandler(HpaeMsgCode cmdID, void (HpaeManager::*func)(Args...))
893 {
894 handlers_[cmdID] = [this, cmdID, func](const std::any &packedArgs) {
895 // unpack args
896 auto args = std::any_cast<std::tuple<Args...>>(&packedArgs);
897 // print log if args parse error
898 CHECK_AND_RETURN_LOG(args != nullptr, "cmdId %{public}d type mismatched", cmdID);
899 std::apply(
900 [this, func](
901 auto &&...unpackedArgs) { (this->*func)(std::forward<decltype(unpackedArgs)>(unpackedArgs)...); },
902 *args);
903 };
904 }
905
MovingSinkStateChange(uint32_t sessionId,const std::shared_ptr<HpaeSinkInputNode> & sinkInput)906 bool HpaeManager::MovingSinkStateChange(uint32_t sessionId, const std::shared_ptr<HpaeSinkInputNode>& sinkInput)
907 {
908 if (movingIds_.find(sessionId) != movingIds_.end()) {
909 if (movingIds_[sessionId] == HPAE_SESSION_RELEASED) {
910 rendererIdSinkNameMap_.erase(sessionId);
911 rendererIdStreamInfoMap_.erase(sessionId);
912 if (auto serviceCallback = serviceCallback_.lock()) {
913 serviceCallback->OnMoveSinkInputByIndexOrNameCb(SUCCESS);
914 }
915 movingIds_.erase(sessionId);
916 return true;
917 }
918 if (movingIds_[sessionId] != rendererIdStreamInfoMap_[sessionId].state) {
919 sinkInput->SetState(movingIds_[sessionId]);
920 }
921 sinkInput->SetOffloadEnabled(rendererIdStreamInfoMap_[sessionId].offloadEnable);
922 sinkInput->SetSpeed(rendererIdStreamInfoMap_[sessionId].speed);
923 movingIds_.erase(sessionId);
924 }
925 return false;
926 }
927
HandleMoveSinkInput(const std::shared_ptr<HpaeSinkInputNode> sinkInputNode,std::string sinkName)928 void HpaeManager::HandleMoveSinkInput(const std::shared_ptr<HpaeSinkInputNode> sinkInputNode, std::string sinkName)
929 {
930 uint32_t sessionId = sinkInputNode->GetNodeInfo().sessionId;
931 AUDIO_INFO_LOG("handle move session:%{public}u to new sink:%{public}s", sessionId, sinkName.c_str());
932 if (MovingSinkStateChange(sessionId, sinkInputNode)) {
933 return;
934 }
935 std::shared_ptr<IHpaeRendererManager> rendererManager = GetRendererManagerByName(sinkName);
936 if (rendererManager == nullptr) {
937 AUDIO_ERR_LOG("handle move session:%{public}u failed,can not find sink by name:%{public}s",
938 sessionId, sinkName.c_str());
939 if (auto serviceCallback = serviceCallback_.lock()) {
940 serviceCallback->OnMoveSinkInputByIndexOrNameCb(ERROR_INVALID_PARAM);
941 }
942 return;
943 }
944 rendererManager->AddNodeToSink(sinkInputNode);
945 rendererIdSinkNameMap_[sessionId] = sinkName;
946 rendererIdStreamInfoMap_[sessionId].streamInfo.deviceName = sinkName;
947 if (sinkName != defaultSink_) {
948 idPreferSinkNameMap_[sessionId] = sinkName;
949 }
950 if (sinkInputs_.find(sessionId) != sinkInputs_.end()) {
951 sinkInputs_[sessionId].deviceSinkId = sinkNameSinkIdMap_[sinkName];
952 sinkInputs_[sessionId].sinkName = sinkName;
953 }
954 if (auto serviceCallback = serviceCallback_.lock()) {
955 serviceCallback->OnMoveSinkInputByIndexOrNameCb(SUCCESS);
956 }
957 }
958
HandleMoveSourceOutput(HpaeCaptureMoveInfo moveInfo,std::string sourceName)959 void HpaeManager::HandleMoveSourceOutput(HpaeCaptureMoveInfo moveInfo, std::string sourceName)
960 {
961 uint32_t sessionId = moveInfo.sessionId;
962 AUDIO_INFO_LOG("handle move session:%{public}u to new source:%{public}s", sessionId, sourceName.c_str());
963 if (movingIds_.find(sessionId) != movingIds_.end()) {
964 if (movingIds_[sessionId] == HPAE_SESSION_RELEASED) {
965 capturerIdSourceNameMap_.erase(sessionId);
966 capturerIdStreamInfoMap_.erase(sessionId);
967 if (auto serviceCallback = serviceCallback_.lock()) {
968 serviceCallback->OnMoveSourceOutputByIndexOrNameCb(SUCCESS);
969 }
970 movingIds_.erase(sessionId);
971 return;
972 }
973 if (movingIds_[sessionId] != capturerIdStreamInfoMap_[sessionId].state) {
974 moveInfo.sessionInfo.state = movingIds_[sessionId];
975 }
976 movingIds_.erase(sessionId);
977 }
978 std::shared_ptr<IHpaeCapturerManager> catpureManager = GetCapturerManagerByName(sourceName);
979 if (catpureManager == nullptr) {
980 AUDIO_ERR_LOG("handle move session:%{public}u failed,can not find source by name:%{public}s",
981 sessionId, sourceName.c_str());
982 if (auto serviceCallback = serviceCallback_.lock()) {
983 serviceCallback->OnMoveSourceOutputByIndexOrNameCb(ERROR_INVALID_PARAM);
984 }
985 return;
986 }
987 catpureManager->AddNodeToSource(moveInfo);
988 capturerIdSourceNameMap_[sessionId] = sourceName;
989 capturerIdStreamInfoMap_[sessionId].streamInfo.deviceName = sourceName;
990 if (sourceOutputs_.find(sessionId) != sourceOutputs_.end()) {
991 sourceOutputs_[sessionId].deviceSourceId = sourceNameSourceIdMap_[sourceName];
992 }
993 if (auto serviceCallback = serviceCallback_.lock()) {
994 serviceCallback->OnMoveSourceOutputByIndexOrNameCb(SUCCESS);
995 }
996 }
997
HandleMoveAllSinkInputs(std::vector<std::shared_ptr<HpaeSinkInputNode>> sinkInputs,std::string sinkName,MoveSessionType moveType)998 void HpaeManager::HandleMoveAllSinkInputs(
999 std::vector<std::shared_ptr<HpaeSinkInputNode>> sinkInputs, std::string sinkName, MoveSessionType moveType)
1000 {
1001 AUDIO_INFO_LOG("handle move session count:%{public}zu to name:%{public}s", sinkInputs.size(), sinkName.c_str());
1002 if (moveType == MOVE_PREFER) {
1003 for (auto it = sinkInputs.begin(); it != sinkInputs.end();) {
1004 CHECK_AND_CONTINUE_LOG(*it, "sinkInput is nullptr");
1005 uint32_t sessionId = (*it)->GetNodeInfo().sessionId;
1006 if (MovingSinkStateChange(sessionId, *it)) {
1007 sinkInputs.erase(it);
1008 continue;
1009 }
1010 it++;
1011 }
1012 }
1013 if (sinkName.empty()) {
1014 AUDIO_INFO_LOG("sink name is empty, move to default sink:%{public}s", defaultSink_.c_str());
1015 sinkName = defaultSink_;
1016 }
1017 if (!SafeGetMap(rendererManagerMap_, sinkName)) {
1018 AUDIO_WARNING_LOG("can not find sink: %{public}s", sinkName.c_str());
1019 if (moveType == MOVE_PREFER) {
1020 if (auto serviceCallback = serviceCallback_.lock()) {
1021 serviceCallback->OnOpenAudioPortCb(sinkNameSinkIdMap_[sinkName]);
1022 }
1023 }
1024 return;
1025 }
1026 rendererManagerMap_[sinkName]->AddAllNodesToSink(sinkInputs, true);
1027 for (const auto &sinkInput : sinkInputs) {
1028 CHECK_AND_CONTINUE_LOG(sinkInput, "sinkInput is nullptr");
1029 uint32_t sessionId = sinkInput->GetNodeInfo().sessionId;
1030 rendererIdSinkNameMap_[sessionId] = sinkName;
1031 rendererIdStreamInfoMap_[sessionId].streamInfo.deviceName = sinkName;
1032 if (sinkInputs_.find(sessionId) != sinkInputs_.end()) {
1033 sinkInputs_[sessionId].deviceSinkId = sinkNameSinkIdMap_[sinkName];
1034 sinkInputs_[sessionId].sinkName = sinkName;
1035 }
1036 }
1037 if (moveType == MOVE_PREFER) {
1038 if (auto serviceCallback = serviceCallback_.lock()) {
1039 serviceCallback->OnOpenAudioPortCb(sinkNameSinkIdMap_[sinkName]);
1040 }
1041 }
1042 }
1043
HandleMoveAllSourceOutputs(const std::vector<HpaeCaptureMoveInfo> moveInfos,std::string sourceName)1044 void HpaeManager::HandleMoveAllSourceOutputs(const std::vector<HpaeCaptureMoveInfo> moveInfos, std::string sourceName)
1045 {
1046 AUDIO_INFO_LOG("handle move session count:%{public}zu to name:%{public}s", moveInfos.size(), sourceName.c_str());
1047 if (sourceName.empty()) {
1048 AUDIO_INFO_LOG("source is empty, move to default source:%{public}s", defaultSource_.c_str());
1049 sourceName = defaultSource_;
1050 }
1051 if (!SafeGetMap(capturerManagerMap_, sourceName)) {
1052 AUDIO_WARNING_LOG("can not find source: %{public}s", sourceName.c_str());
1053 return;
1054 }
1055 capturerManagerMap_[sourceName]->AddAllNodesToSource(moveInfos, true);
1056 for (const auto &it : moveInfos) {
1057 capturerIdSourceNameMap_[it.sessionId] = sourceName;
1058 capturerIdStreamInfoMap_[it.sessionId].streamInfo.deviceName = sourceName;
1059 if (sourceOutputs_.find(it.sessionId) != sourceOutputs_.end()) {
1060 sourceOutputs_[it.sessionId].deviceSourceId = sourceNameSourceIdMap_[sourceName];
1061 }
1062 }
1063 }
1064
HandleMoveSessionFailed(HpaeStreamClassType streamClassType,uint32_t sessionId,MoveSessionType moveType,std::string name)1065 void HpaeManager::HandleMoveSessionFailed(
1066 HpaeStreamClassType streamClassType, uint32_t sessionId, MoveSessionType moveType, std::string name)
1067 {
1068 AUDIO_INFO_LOG("handle move session:%{public}u failed to %{public}s", sessionId, name.c_str());
1069 movingIds_.erase(sessionId);
1070 if (moveType != MOVE_SINGLE) {
1071 return;
1072 }
1073 if (streamClassType == HPAE_STREAM_CLASS_TYPE_PLAY) {
1074 if (auto serviceCallback = serviceCallback_.lock()) {
1075 serviceCallback->OnMoveSinkInputByIndexOrNameCb(ERROR_INVALID_PARAM);
1076 }
1077 } else if (streamClassType == HPAE_STREAM_CLASS_TYPE_RECORD) {
1078 if (auto serviceCallback = serviceCallback_.lock()) {
1079 serviceCallback->OnMoveSourceOutputByIndexOrNameCb(ERROR_INVALID_PARAM);
1080 }
1081 }
1082 }
1083
HandleUpdateStatus(HpaeStreamClassType streamClassType,uint32_t sessionId,HpaeSessionState status,IOperation operation)1084 void HpaeManager::HandleUpdateStatus(
1085 HpaeStreamClassType streamClassType, uint32_t sessionId, HpaeSessionState status, IOperation operation)
1086 {
1087 // log limit
1088 if (operation != OPERATION_UNDERFLOW) {
1089 AUDIO_INFO_LOG("HpaeManager::HandleUpdateStatus sessionid:%{public}u "
1090 "status:%{public}d operation:%{public}d",
1091 sessionId,
1092 status,
1093 operation);
1094 }
1095 if (operation == OPERATION_INVALID) {
1096 // maybe dosomething while move sink inputs
1097 return;
1098 }
1099 auto it = streamClassType == HPAE_STREAM_CLASS_TYPE_PLAY ? rendererIdStreamInfoMap_.find(sessionId)
1100 : capturerIdStreamInfoMap_.find(sessionId);
1101 if (it != rendererIdStreamInfoMap_.end() && it != capturerIdStreamInfoMap_.end()) {
1102 UpdateStatus(it->second.statusCallback, operation, sessionId);
1103 }
1104 }
1105
UpdateStatus(const std::weak_ptr<IStreamStatusCallback> & callback,IOperation operation,uint32_t sessionId)1106 void HpaeManager::UpdateStatus(const std::weak_ptr<IStreamStatusCallback> &callback,
1107 IOperation operation, uint32_t sessionId)
1108 {
1109 if (auto lock = callback.lock()) {
1110 lock->OnStatusUpdate(operation, sessionId);
1111 } else {
1112 AUDIO_WARNING_LOG("sessionId: %{public}u, statusCallback is nullptr", sessionId);
1113 }
1114 }
1115
HandleDumpSinkInfo(std::string deviceName,std::string dumpStr)1116 void HpaeManager::HandleDumpSinkInfo(std::string deviceName, std::string dumpStr)
1117 {
1118 AUDIO_INFO_LOG("HpaeManager::HandleDumpSinkInfo deviceName:%{public}s dumpStr:%{public}s",
1119 deviceName.c_str(),
1120 dumpStr.c_str());
1121 if (auto ptr = dumpCallback_.lock()) {
1122 ptr->OnDumpSinkInfoCb(dumpStr, SUCCESS);
1123 }
1124 }
1125
HandleDumpSourceInfo(std::string deviceName,std::string dumpStr)1126 void HpaeManager::HandleDumpSourceInfo(std::string deviceName, std::string dumpStr)
1127 {
1128 AUDIO_INFO_LOG("HpaeManager::HandleDumpSourceInfo deviceName:%{public}s dumpStr:%{public}s",
1129 deviceName.c_str(),
1130 dumpStr.c_str());
1131 if (auto ptr = dumpCallback_.lock()) {
1132 ptr->OnDumpSourceInfoCb(dumpStr, SUCCESS);
1133 }
1134 }
1135
HandleReloadDeviceResult(std::string deviceName,int32_t result)1136 void HpaeManager::HandleReloadDeviceResult(std::string deviceName, int32_t result)
1137 {
1138 AUDIO_INFO_LOG("deviceName:%{public}s result:%{public}d ", deviceName.c_str(), result);
1139 auto serviceCallback = serviceCallback_.lock();
1140 if (serviceCallback && result == SUCCESS) {
1141 if (sinkNameSinkIdMap_.find(deviceName) != sinkNameSinkIdMap_.end()) {
1142 serviceCallback->OnReloadAudioPortCb(sinkNameSinkIdMap_[deviceName]);
1143 } else {
1144 AUDIO_ERR_LOG("device:%{public}s is not exist.", deviceName.c_str());
1145 serviceCallback->OnReloadAudioPortCb(SINK_INVALID_ID);
1146 }
1147 } else if (serviceCallback) {
1148 serviceCallback->OnReloadAudioPortCb(SINK_INVALID_ID);
1149 AUDIO_INFO_LOG("deviceName:%{public}s result:%{public}d error",
1150 deviceName.c_str(), result);
1151 } else {
1152 AUDIO_INFO_LOG("OnReloadAudioPortCb is nullptr");
1153 }
1154 }
1155
HandleInitDeviceResult(std::string deviceName,int32_t result)1156 void HpaeManager::HandleInitDeviceResult(std::string deviceName, int32_t result)
1157 {
1158 AUDIO_INFO_LOG("deviceName:%{public}s result:%{public}d ", deviceName.c_str(), result);
1159 auto serviceCallback = serviceCallback_.lock();
1160 if (serviceCallback && result == SUCCESS) {
1161 if (sinkNameSinkIdMap_.find(deviceName) != sinkNameSinkIdMap_.end()) {
1162 MoveToPreferSink(deviceName, serviceCallback);
1163 } else if (sourceNameSourceIdMap_.find(deviceName) != sourceNameSourceIdMap_.end()) {
1164 serviceCallback->OnOpenAudioPortCb(sourceNameSourceIdMap_[deviceName]);
1165 } else {
1166 AUDIO_ERR_LOG("device:%{public}s is not exist.", deviceName.c_str());
1167 serviceCallback->OnOpenAudioPortCb(SINK_INVALID_ID);
1168 }
1169 } else if (serviceCallback) {
1170 serviceCallback->OnOpenAudioPortCb(SINK_INVALID_ID);
1171 AUDIO_INFO_LOG("HandleInitDeviceResult deviceName:%{public}s "
1172 "result:%{public}d error",
1173 deviceName.c_str(),
1174 result);
1175 } else {
1176 AUDIO_INFO_LOG("OnOpenAudioPortCb is nullptr");
1177 }
1178 }
1179
HandleInitSourceResult(SourceType sourceType)1180 void HpaeManager::HandleInitSourceResult(SourceType sourceType)
1181 {
1182 if (sourceType == SOURCE_TYPE_LIVE && (effectLiveState_ == "NROFF" || effectLiveState_ == "NRON")) {
1183 const std::string combinedParam = "live_effect_enable=" + effectLiveState_;
1184 HpaePolicyManager::GetInstance().SetAudioParameter("primary",
1185 AudioParamKey::PARAM_KEY_STATE, "", combinedParam);
1186 }
1187 }
1188
SendRequest(Request && request,std::string funcName)1189 void HpaeManager::SendRequest(Request &&request, std::string funcName)
1190 {
1191 Trace trace("sendrequest::" + funcName);
1192 hpaeNoLockQueue_.PushRequest(std::move(request));
1193 CHECK_AND_RETURN_LOG(hpaeManagerThread_, "hpaeManagerThread_ is nullptr");
1194 hpaeManagerThread_->Notify();
1195 }
1196 // play and record stream interface
CreateStream(const HpaeStreamInfo & streamInfo)1197 int32_t HpaeManager::CreateStream(const HpaeStreamInfo &streamInfo)
1198 {
1199 auto request = [this, streamInfo]() {
1200 AUDIO_INFO_LOG("streamType is %{public}d sessionId %{public}u sourceType is %{public}d",
1201 streamInfo.streamType,
1202 streamInfo.sessionId,
1203 streamInfo.sourceType);
1204 if (INNER_SOURCE_TYPE_SET.count(streamInfo.sourceType) != 0) {
1205 return CreateStreamForCapInner(streamInfo);
1206 } else if (streamInfo.streamClassType == HPAE_STREAM_CLASS_TYPE_PLAY) {
1207 std::string deviceName = streamInfo.deviceName == "" ? defaultSink_ : streamInfo.deviceName;
1208 AUDIO_INFO_LOG("devicename:%{public}s, sessionId:%{public}u", deviceName.c_str(), streamInfo.sessionId);
1209 CHECK_AND_RETURN_LOG(SafeGetMap(rendererManagerMap_, deviceName),
1210 "can not find sink[%{public}s] in rendererManagerMap_",
1211 deviceName.c_str());
1212 rendererIdSinkNameMap_[streamInfo.sessionId] = deviceName;
1213 rendererManagerMap_[deviceName]->CreateStream(streamInfo);
1214 rendererIdStreamInfoMap_[streamInfo.sessionId].streamInfo = streamInfo;
1215 rendererIdStreamInfoMap_[streamInfo.sessionId].state = HPAE_SESSION_NEW;
1216 AddStreamToCollection(streamInfo, deviceName);
1217 } else if (streamInfo.streamClassType == HPAE_STREAM_CLASS_TYPE_RECORD) {
1218 std::string deviceName = streamInfo.deviceName == "" ? defaultSource_ : streamInfo.deviceName;
1219 AUDIO_INFO_LOG("source:%{public}s, sessionId:%{public}u", deviceName.c_str(), streamInfo.sessionId);
1220 CHECK_AND_RETURN_LOG(SafeGetMap(capturerManagerMap_, deviceName),
1221 "can not find source[%{public}s] in capturerManagerMap_",
1222 deviceName.c_str());
1223 capturerIdSourceNameMap_[streamInfo.sessionId] = deviceName;
1224 capturerManagerMap_[deviceName]->CreateStream(streamInfo);
1225 capturerIdStreamInfoMap_[streamInfo.sessionId].streamInfo = streamInfo;
1226 capturerIdStreamInfoMap_[streamInfo.sessionId].state = HPAE_SESSION_NEW;
1227 AddStreamToCollection(streamInfo, deviceName);
1228 } else {
1229 AUDIO_WARNING_LOG(
1230 "can not find default sink or source streamClassType %{public}d", streamInfo.streamClassType);
1231 }
1232 };
1233 SendRequest(request, __func__);
1234 AUDIO_INFO_LOG("defaultSink_ is %{public}s defaultSource_ is %{public}s streamClassType %{public}u",
1235 defaultSink_.c_str(), defaultSource_.c_str(), streamInfo.streamClassType);
1236 return SUCCESS;
1237 }
1238
AddStreamToCollection(const HpaeStreamInfo & streamInfo,const std::string & name)1239 void HpaeManager::AddStreamToCollection(const HpaeStreamInfo &streamInfo, const std::string &name)
1240 {
1241 auto now = std::chrono::system_clock::now();
1242 auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch());
1243 if (streamInfo.streamClassType == HPAE_STREAM_CLASS_TYPE_PLAY) {
1244 SinkInput sinkInput;
1245 sinkInput.streamId = streamInfo.sessionId;
1246 sinkInput.paStreamId = streamInfo.sessionId;
1247 sinkInput.streamType = streamInfo.streamType;
1248 sinkInput.sinkName = name;
1249 sinkInput.deviceSinkId = sinkNameSinkIdMap_[name];
1250 sinkInput.pid = streamInfo.pid;
1251 sinkInput.uid = streamInfo.uid;
1252 sinkInput.startTime = static_cast<uint64_t>(ms.count());
1253 sinkInputs_[streamInfo.sessionId] = sinkInput;
1254 rendererIdStreamInfoMap_[streamInfo.sessionId].startTime = static_cast<uint64_t>(ms.count());
1255 } else if (streamInfo.streamClassType == HPAE_STREAM_CLASS_TYPE_RECORD) {
1256 SourceOutput sourceOutputInfo;
1257 sourceOutputInfo.streamId = streamInfo.sessionId;
1258 sourceOutputInfo.paStreamId = streamInfo.sessionId;
1259 sourceOutputInfo.streamType = streamInfo.streamType;
1260 sourceOutputInfo.deviceSourceId = sourceNameSourceIdMap_[name];
1261 sourceOutputInfo.pid = streamInfo.pid;
1262 sourceOutputInfo.uid = streamInfo.uid;
1263 sourceOutputInfo.startTime = static_cast<uint64_t>(ms.count());
1264 sourceOutputs_[streamInfo.sessionId] = sourceOutputInfo;
1265 capturerIdStreamInfoMap_[streamInfo.sessionId].startTime = static_cast<uint64_t>(ms.count());
1266 }
1267 }
1268
DestroyCapture(uint32_t sessionId)1269 void HpaeManager::DestroyCapture(uint32_t sessionId)
1270 {
1271 if (capturerIdSourceNameMap_.find(sessionId) == capturerIdSourceNameMap_.end()) {
1272 AUDIO_WARNING_LOG("can not find capture by id:%{public}u", sessionId);
1273 return;
1274 }
1275 std::string captureName = capturerIdSourceNameMap_[sessionId];
1276 if (INNER_SOURCE_TYPE_SET.count(capturerIdStreamInfoMap_[sessionId].streamInfo.sourceType) != 0) {
1277 std::shared_ptr<IHpaeRendererManager> renderManager = GetRendererManagerByName(captureName);
1278 if (renderManager != nullptr) {
1279 renderManager->DestroyStream(sessionId);
1280 }
1281 } else {
1282 std::shared_ptr<IHpaeCapturerManager> capManager = GetCapturerManagerByName(captureName);
1283 if (capManager != nullptr) {
1284 capManager->DestroyStream(sessionId);
1285 }
1286 }
1287 }
1288
SetMovingStreamState(HpaeStreamClassType streamType,uint32_t sessionId,HpaeSessionState status,HpaeSessionState state,IOperation operation)1289 bool HpaeManager::SetMovingStreamState(HpaeStreamClassType streamType, uint32_t sessionId,
1290 HpaeSessionState status, HpaeSessionState state, IOperation operation)
1291 {
1292 if (movingIds_.find(sessionId) == movingIds_.end()) {
1293 return false;
1294 }
1295 AUDIO_INFO_LOG("sessionId:%{public}u is moving", sessionId);
1296 if (operation != OPERATION_FLUSHED && operation != OPERATION_DRAINED) {
1297 movingIds_[sessionId] = status;
1298 if (streamType == HPAE_STREAM_CLASS_TYPE_PLAY) {
1299 rendererIdStreamInfoMap_[sessionId].state = state;
1300 } else {
1301 capturerIdStreamInfoMap_[sessionId].state = state;
1302 }
1303 }
1304 if (streamType == HPAE_STREAM_CLASS_TYPE_PLAY) {
1305 UpdateStatus(rendererIdStreamInfoMap_[sessionId].statusCallback, operation, sessionId);
1306 if (operation == OPERATION_RELEASED) {
1307 sinkInputs_.erase(sessionId);
1308 idPreferSinkNameMap_.erase(sessionId);
1309 }
1310 } else {
1311 UpdateStatus(capturerIdStreamInfoMap_[sessionId].statusCallback, operation, sessionId);
1312 if (operation == OPERATION_RELEASED) {
1313 sourceOutputs_.erase(sessionId);
1314 if (auto serviceCallback = serviceCallback_.lock()) {
1315 serviceCallback->HandleSourceAudioStreamRemoved(sessionId);
1316 }
1317 } else if (operation == OPERATION_STARTED) {
1318 if (capturerIdStreamInfoMap_[sessionId].streamInfo.sourceType == SOURCE_TYPE_LIVE &&
1319 (effectLiveState_ == "NROFF" || effectLiveState_ == "NRON")) {
1320 const std::string combinedParam = "live_effect_enable=" + effectLiveState_;
1321 HpaePolicyManager::GetInstance().SetAudioParameter("primary",
1322 AudioParamKey::PARAM_KEY_STATE, "", combinedParam);
1323 }
1324 }
1325 }
1326 return true;
1327 }
1328
DestroyStream(HpaeStreamClassType streamClassType,uint32_t sessionId)1329 int32_t HpaeManager::DestroyStream(HpaeStreamClassType streamClassType, uint32_t sessionId)
1330 {
1331 auto request = [this, streamClassType, sessionId]() {
1332 AUDIO_INFO_LOG("DestroyStream streamClassType %{public}d, sessionId %{public}u", streamClassType, sessionId);
1333 if (SetMovingStreamState(streamClassType, sessionId, HPAE_SESSION_RELEASED,
1334 HPAE_SESSION_RELEASED, OPERATION_RELEASED)) {
1335 return;
1336 }
1337 if (streamClassType == HPAE_STREAM_CLASS_TYPE_PLAY) {
1338 std::shared_ptr<IHpaeRendererManager> renderManager = GetRendererManagerById(sessionId);
1339 if (renderManager!= nullptr) {
1340 renderManager->DestroyStream(sessionId);
1341 }
1342 rendererIdSinkNameMap_.erase(sessionId);
1343 rendererIdStreamInfoMap_.erase(sessionId);
1344 sinkInputs_.erase(sessionId);
1345 idPreferSinkNameMap_.erase(sessionId);
1346 } else if (streamClassType == HPAE_STREAM_CLASS_TYPE_RECORD) {
1347 DestroyCapture(sessionId);
1348 capturerIdSourceNameMap_.erase(sessionId);
1349 capturerIdStreamInfoMap_.erase(sessionId);
1350 sourceOutputs_.erase(sessionId);
1351 if (auto serviceCallback = serviceCallback_.lock()) {
1352 serviceCallback->HandleSourceAudioStreamRemoved(sessionId);
1353 }
1354 } else {
1355 AUDIO_WARNING_LOG(
1356 "can not find sessionId streamClassType %{public}d, sessionId %{public}u", streamClassType, sessionId);
1357 }
1358 };
1359 SendRequest(request, __func__);
1360 return SUCCESS;
1361 }
1362
ShouldNotSkipProcess(const HpaeStreamClassType & streamType,const uint32_t & sessionId)1363 bool HpaeManager::ShouldNotSkipProcess(const HpaeStreamClassType &streamType, const uint32_t &sessionId)
1364 {
1365 if (streamType == HPAE_STREAM_CLASS_TYPE_PLAY) {
1366 CHECK_AND_RETURN_RET_LOG(rendererIdStreamInfoMap_.find(sessionId) != rendererIdStreamInfoMap_.end() &&
1367 rendererIdStreamInfoMap_[sessionId].state != HPAE_SESSION_RELEASED, false,
1368 "renderer session: %{public}u already released", sessionId);
1369 } else if (streamType == HPAE_STREAM_CLASS_TYPE_RECORD) {
1370 CHECK_AND_RETURN_RET_LOG(capturerIdStreamInfoMap_.find(sessionId) != capturerIdStreamInfoMap_.end() &&
1371 capturerIdStreamInfoMap_[sessionId].state != HPAE_SESSION_RELEASED, false,
1372 "capturer session: %{public}u already released", sessionId);
1373 } else {
1374 AUDIO_WARNING_LOG("streamType[%{public}d] is invalid", streamType);
1375 return false;
1376 }
1377 return true;
1378 }
1379
Start(HpaeStreamClassType streamClassType,uint32_t sessionId)1380 int32_t HpaeManager::Start(HpaeStreamClassType streamClassType, uint32_t sessionId)
1381 {
1382 auto request = [this, streamClassType, sessionId]() {
1383 CHECK_AND_RETURN_LOG(ShouldNotSkipProcess(streamClassType, sessionId),
1384 "Start session: %{public}u failed, session already released", sessionId);
1385 AUDIO_INFO_LOG(
1386 "HpaeManager::Start sessionId: %{public}u streamClassType:%{public}d", sessionId, streamClassType);
1387 if (SetMovingStreamState(streamClassType, sessionId, HPAE_SESSION_RUNNING,
1388 HPAE_SESSION_RUNNING, OPERATION_STARTED)) {
1389 return;
1390 }
1391 if (streamClassType == HPAE_STREAM_CLASS_TYPE_PLAY &&
1392 rendererIdSinkNameMap_.find(sessionId) != rendererIdSinkNameMap_.end()) {
1393 AUDIO_INFO_LOG("renderer Start sessionId: %{public}u deviceName:%{public}s",
1394 sessionId, rendererIdSinkNameMap_[sessionId].c_str());
1395 CHECK_AND_RETURN_LOG(SafeGetMap(rendererManagerMap_, rendererIdSinkNameMap_[sessionId]),
1396 "cannot find device:%{public}s", rendererIdSinkNameMap_[sessionId].c_str());
1397 rendererManagerMap_[rendererIdSinkNameMap_[sessionId]]->Start(sessionId);
1398 rendererIdStreamInfoMap_[sessionId].state = HPAE_SESSION_RUNNING;
1399 UpdateStatus(rendererIdStreamInfoMap_[sessionId].statusCallback, OPERATION_STARTED, sessionId);
1400 } else if (streamClassType == HPAE_STREAM_CLASS_TYPE_RECORD &&
1401 capturerIdSourceNameMap_.find(sessionId) != capturerIdSourceNameMap_.end()) {
1402 AUDIO_INFO_LOG("capturer Start sessionId: %{public}u deviceName:%{public}s",
1403 sessionId, capturerIdSourceNameMap_[sessionId].c_str());
1404 if (INNER_SOURCE_TYPE_SET.count(capturerIdStreamInfoMap_[sessionId].streamInfo.sourceType) != 0) {
1405 CHECK_AND_RETURN_LOG(SafeGetMap(rendererManagerMap_, capturerIdSourceNameMap_[sessionId]),
1406 "cannot find device:%{public}s", capturerIdSourceNameMap_[sessionId].c_str());
1407 rendererManagerMap_[capturerIdSourceNameMap_[sessionId]]->Start(sessionId);
1408 UpdateStatus(capturerIdStreamInfoMap_[sessionId].statusCallback, OPERATION_STARTED, sessionId);
1409 } else {
1410 CHECK_AND_RETURN_LOG(SafeGetMap(capturerManagerMap_, capturerIdSourceNameMap_[sessionId]),
1411 "cannot find device:%{public}s", capturerIdSourceNameMap_[sessionId].c_str());
1412 capturerManagerMap_[capturerIdSourceNameMap_[sessionId]]->Start(sessionId);
1413 UpdateStatus(capturerIdStreamInfoMap_[sessionId].statusCallback, OPERATION_STARTED, sessionId);
1414 }
1415 capturerIdStreamInfoMap_[sessionId].state = HPAE_SESSION_RUNNING;
1416 } else {
1417 AUDIO_WARNING_LOG("Start can not find sessionId streamClassType %{public}d, sessionId %{public}u",
1418 streamClassType, sessionId);
1419 }
1420 };
1421 SendRequest(request, __func__);
1422 return SUCCESS;
1423 }
1424
StartWithSyncId(HpaeStreamClassType streamClassType,uint32_t sessionId,int32_t syncId)1425 int32_t HpaeManager::StartWithSyncId(HpaeStreamClassType streamClassType, uint32_t sessionId, int32_t syncId)
1426 {
1427 auto request = [this, streamClassType, sessionId, syncId]() {
1428 CHECK_AND_RETURN_LOG(ShouldNotSkipProcess(streamClassType, sessionId),
1429 "StartWithSyncId session: %{public}u failed, session already released", sessionId);
1430 AUDIO_INFO_LOG(
1431 "HpaeManager::StartWithSyncId sessionId: %{public}u streamClassType:%{public}d syncId: %{public}d",
1432 sessionId, streamClassType, syncId);
1433 if (SetMovingStreamState(streamClassType, sessionId, HPAE_SESSION_RUNNING,
1434 HPAE_SESSION_RUNNING, OPERATION_STARTED)) {
1435 return;
1436 }
1437 if (streamClassType == HPAE_STREAM_CLASS_TYPE_PLAY &&
1438 rendererIdSinkNameMap_.find(sessionId) != rendererIdSinkNameMap_.end()) {
1439 AUDIO_INFO_LOG("renderer StartWithSyncId sessionId: %{public}u deviceName:%{public}s",
1440 sessionId, rendererIdSinkNameMap_[sessionId].c_str());
1441 CHECK_AND_RETURN_LOG(SafeGetMap(rendererManagerMap_, rendererIdSinkNameMap_[sessionId]),
1442 "cannot find device:%{public}s", rendererIdSinkNameMap_[sessionId].c_str());
1443 rendererManagerMap_[rendererIdSinkNameMap_[sessionId]]->StartWithSyncId(sessionId, syncId);
1444 rendererIdStreamInfoMap_[sessionId].state = HPAE_SESSION_RUNNING;
1445 UpdateStatus(rendererIdStreamInfoMap_[sessionId].statusCallback, OPERATION_STARTED, sessionId);
1446 } else {
1447 AUDIO_WARNING_LOG("StartWithSyncId can not find sessionId streamClassType %{public}d,"
1448 "sessionId %{public}u, syncId: %{public}d",
1449 streamClassType, sessionId, syncId);
1450 }
1451 };
1452 SendRequest(request, __func__);
1453 return SUCCESS;
1454 }
1455
Pause(HpaeStreamClassType streamClassType,uint32_t sessionId)1456 int32_t HpaeManager::Pause(HpaeStreamClassType streamClassType, uint32_t sessionId)
1457 {
1458 auto request = [this, streamClassType, sessionId]() {
1459 CHECK_AND_RETURN_LOG(ShouldNotSkipProcess(streamClassType, sessionId),
1460 "Pause session: %{public}u failed, session already released", sessionId);
1461 AUDIO_INFO_LOG(
1462 "HpaeManager::Pause sessionId: %{public}u streamClassType:%{public}d", sessionId, streamClassType);
1463 if (SetMovingStreamState(streamClassType, sessionId, HPAE_SESSION_PAUSED,
1464 HPAE_SESSION_PAUSING, OPERATION_PAUSED)) {
1465 return;
1466 }
1467 if (streamClassType == HPAE_STREAM_CLASS_TYPE_PLAY &&
1468 rendererIdSinkNameMap_.find(sessionId) != rendererIdSinkNameMap_.end()) {
1469 AUDIO_INFO_LOG("renderer Pause sessionId: %{public}u deviceName:%{public}s",
1470 sessionId, rendererIdSinkNameMap_[sessionId].c_str());
1471 CHECK_AND_RETURN_LOG(SafeGetMap(rendererManagerMap_, rendererIdSinkNameMap_[sessionId]),
1472 "cannot find device:%{public}s", rendererIdSinkNameMap_[sessionId].c_str());
1473 rendererManagerMap_[rendererIdSinkNameMap_[sessionId]]->Pause(sessionId);
1474 rendererIdStreamInfoMap_[sessionId].state = HPAE_SESSION_PAUSING;
1475 } else if (streamClassType == HPAE_STREAM_CLASS_TYPE_RECORD &&
1476 capturerIdSourceNameMap_.find(sessionId) != capturerIdSourceNameMap_.end()) {
1477 AUDIO_INFO_LOG("capturer Pause sessionId: %{public}u deviceName:%{public}s",
1478 sessionId, capturerIdSourceNameMap_[sessionId].c_str());
1479 if (INNER_SOURCE_TYPE_SET.count(capturerIdStreamInfoMap_[sessionId].streamInfo.sourceType) != 0) {
1480 CHECK_AND_RETURN_LOG(SafeGetMap(rendererManagerMap_, capturerIdSourceNameMap_[sessionId]),
1481 "cannot find device:%{public}s", capturerIdSourceNameMap_[sessionId].c_str());
1482 rendererManagerMap_[capturerIdSourceNameMap_[sessionId]]->Pause(sessionId);
1483 } else {
1484 CHECK_AND_RETURN_LOG(SafeGetMap(capturerManagerMap_, capturerIdSourceNameMap_[sessionId]),
1485 "cannot find device:%{public}s", capturerIdSourceNameMap_[sessionId].c_str());
1486 capturerManagerMap_[capturerIdSourceNameMap_[sessionId]]->Pause(sessionId);
1487 }
1488 capturerIdStreamInfoMap_[sessionId].state = HPAE_SESSION_PAUSING;
1489 } else {
1490 AUDIO_WARNING_LOG("Pause can not find sessionId streamClassType %{public}d, sessionId %{public}u",
1491 streamClassType, sessionId);
1492 }
1493 };
1494 SendRequest(request, __func__);
1495 return SUCCESS;
1496 }
1497
Flush(HpaeStreamClassType streamClassType,uint32_t sessionId)1498 int32_t HpaeManager::Flush(HpaeStreamClassType streamClassType, uint32_t sessionId)
1499 {
1500 auto request = [this, streamClassType, sessionId]() {
1501 CHECK_AND_RETURN_LOG(ShouldNotSkipProcess(streamClassType, sessionId),
1502 "Flush session: %{public}u failed, session already released", sessionId);
1503 AUDIO_INFO_LOG(
1504 "HpaeManager::Flush sessionId: %{public}u streamClassType:%{public}d", sessionId, streamClassType);
1505 if (SetMovingStreamState(streamClassType, sessionId,
1506 HPAE_SESSION_INVALID, HPAE_SESSION_INVALID, OPERATION_FLUSHED)) {
1507 return;
1508 }
1509 if (streamClassType == HPAE_STREAM_CLASS_TYPE_PLAY &&
1510 rendererIdSinkNameMap_.find(sessionId) != rendererIdSinkNameMap_.end()) {
1511 AUDIO_INFO_LOG("renderer Flush sessionId: %{public}u deviceName:%{public}s",
1512 sessionId, rendererIdSinkNameMap_[sessionId].c_str());
1513 CHECK_AND_RETURN_LOG(SafeGetMap(rendererManagerMap_, rendererIdSinkNameMap_[sessionId]),
1514 "cannot find device:%{public}s", rendererIdSinkNameMap_[sessionId].c_str());
1515 rendererManagerMap_[rendererIdSinkNameMap_[sessionId]]->Flush(sessionId);
1516 UpdateStatus(rendererIdStreamInfoMap_[sessionId].statusCallback, OPERATION_FLUSHED, sessionId);
1517 } else if (streamClassType == HPAE_STREAM_CLASS_TYPE_RECORD &&
1518 capturerIdSourceNameMap_.find(sessionId) != capturerIdSourceNameMap_.end()) {
1519 AUDIO_INFO_LOG("capturer Flush sessionId: %{public}u deviceName:%{public}s",
1520 sessionId,
1521 capturerIdSourceNameMap_[sessionId].c_str());
1522 if (INNER_SOURCE_TYPE_SET.count(capturerIdStreamInfoMap_[sessionId].streamInfo.sourceType) != 0) {
1523 CHECK_AND_RETURN_LOG(SafeGetMap(rendererManagerMap_, capturerIdSourceNameMap_[sessionId]),
1524 "cannot find device:%{public}s", capturerIdSourceNameMap_[sessionId].c_str());
1525 rendererManagerMap_[capturerIdSourceNameMap_[sessionId]]->Flush(sessionId);
1526 } else {
1527 CHECK_AND_RETURN_LOG(SafeGetMap(capturerManagerMap_, capturerIdSourceNameMap_[sessionId]),
1528 "cannot find device:%{public}s", capturerIdSourceNameMap_[sessionId].c_str());
1529 capturerManagerMap_[capturerIdSourceNameMap_[sessionId]]->Flush(sessionId);
1530 }
1531 UpdateStatus(capturerIdStreamInfoMap_[sessionId].statusCallback, OPERATION_FLUSHED, sessionId);
1532 } else {
1533 AUDIO_WARNING_LOG("Flush can not find sessionId streamClassType %{public}d, sessionId %{public}u",
1534 streamClassType, sessionId);
1535 }
1536 };
1537 SendRequest(request, __func__);
1538 return SUCCESS;
1539 }
1540
Drain(HpaeStreamClassType streamClassType,uint32_t sessionId)1541 int32_t HpaeManager::Drain(HpaeStreamClassType streamClassType, uint32_t sessionId)
1542 {
1543 auto request = [this, streamClassType, sessionId]() {
1544 CHECK_AND_RETURN_LOG(ShouldNotSkipProcess(streamClassType, sessionId),
1545 "Drain session: %{public}u failed, session already released", sessionId);
1546 AUDIO_INFO_LOG(
1547 "HpaeManager::Drain sessionId: %{public}u streamClassType:%{public}d", sessionId, streamClassType);
1548 if (SetMovingStreamState(streamClassType, sessionId,
1549 HPAE_SESSION_INVALID, HPAE_SESSION_INVALID, OPERATION_DRAINED)) {
1550 return;
1551 }
1552 if (streamClassType == HPAE_STREAM_CLASS_TYPE_PLAY &&
1553 rendererIdSinkNameMap_.find(sessionId) != rendererIdSinkNameMap_.end()) {
1554 AUDIO_INFO_LOG("renderer Drain sessionId: %{public}u deviceName:%{public}s",
1555 sessionId, rendererIdSinkNameMap_[sessionId].c_str());
1556 CHECK_AND_RETURN_LOG(SafeGetMap(rendererManagerMap_, rendererIdSinkNameMap_[sessionId]),
1557 "cannot find device:%{public}s", rendererIdSinkNameMap_[sessionId].c_str());
1558 rendererManagerMap_[rendererIdSinkNameMap_[sessionId]]->Drain(sessionId);
1559 } else if (streamClassType == HPAE_STREAM_CLASS_TYPE_RECORD &&
1560 capturerIdSourceNameMap_.find(sessionId) != capturerIdSourceNameMap_.end()) {
1561 AUDIO_INFO_LOG("capturer Drain sessionId: %{public}u deviceName:%{public}s",
1562 sessionId,
1563 capturerIdSourceNameMap_[sessionId].c_str());
1564 if (INNER_SOURCE_TYPE_SET.count(capturerIdStreamInfoMap_[sessionId].streamInfo.sourceType) != 0) {
1565 CHECK_AND_RETURN_LOG(SafeGetMap(rendererManagerMap_, capturerIdSourceNameMap_[sessionId]),
1566 "cannot find device:%{public}s", capturerIdSourceNameMap_[sessionId].c_str());
1567 rendererManagerMap_[capturerIdSourceNameMap_[sessionId]]->Drain(sessionId);
1568 } else {
1569 CHECK_AND_RETURN_LOG(SafeGetMap(capturerManagerMap_, capturerIdSourceNameMap_[sessionId]),
1570 "cannot find device:%{public}s", capturerIdSourceNameMap_[sessionId].c_str());
1571 capturerManagerMap_[capturerIdSourceNameMap_[sessionId]]->Drain(sessionId);
1572 }
1573 } else {
1574 AUDIO_WARNING_LOG("Drain can not find sessionId streamClassType %{public}d, sessionId %{public}u",
1575 streamClassType, sessionId);
1576 }
1577 };
1578 SendRequest(request, __func__);
1579 return SUCCESS;
1580 }
1581
Stop(HpaeStreamClassType streamClassType,uint32_t sessionId)1582 int32_t HpaeManager::Stop(HpaeStreamClassType streamClassType, uint32_t sessionId)
1583 {
1584 auto request = [this, streamClassType, sessionId]() {
1585 CHECK_AND_RETURN_LOG(ShouldNotSkipProcess(streamClassType, sessionId),
1586 "Stop session: %{public}u failed, session already released", sessionId);
1587 AUDIO_INFO_LOG(
1588 "HpaeManager::Stop sessionId: %{public}u streamClassType:%{public}d", sessionId, streamClassType);
1589 if (SetMovingStreamState(streamClassType, sessionId, HPAE_SESSION_STOPPED,
1590 HPAE_SESSION_STOPPING, OPERATION_STOPPED)) {
1591 return;
1592 }
1593 if (streamClassType == HPAE_STREAM_CLASS_TYPE_PLAY &&
1594 rendererIdSinkNameMap_.find(sessionId) != rendererIdSinkNameMap_.end()) {
1595 AUDIO_INFO_LOG("renderer Stop sessionId: %{public}u deviceName:%{public}s",
1596 sessionId, rendererIdSinkNameMap_[sessionId].c_str());
1597 CHECK_AND_RETURN_LOG(SafeGetMap(rendererManagerMap_, rendererIdSinkNameMap_[sessionId]),
1598 "cannot find device:%{public}s", rendererIdSinkNameMap_[sessionId].c_str());
1599 rendererManagerMap_[rendererIdSinkNameMap_[sessionId]]->Stop(sessionId);
1600 rendererIdStreamInfoMap_[sessionId].state = HPAE_SESSION_STOPPING;
1601 } else if (streamClassType == HPAE_STREAM_CLASS_TYPE_RECORD &&
1602 capturerIdSourceNameMap_.find(sessionId) != capturerIdSourceNameMap_.end()) {
1603 AUDIO_INFO_LOG("capturer Stop sessionId: %{public}u deviceName:%{public}s",
1604 sessionId, capturerIdSourceNameMap_[sessionId].c_str());
1605 if (INNER_SOURCE_TYPE_SET.count(capturerIdStreamInfoMap_[sessionId].streamInfo.sourceType) != 0) {
1606 CHECK_AND_RETURN_LOG(SafeGetMap(rendererManagerMap_, capturerIdSourceNameMap_[sessionId]),
1607 "cannot find device:%{public}s", capturerIdSourceNameMap_[sessionId].c_str());
1608 rendererManagerMap_[capturerIdSourceNameMap_[sessionId]]->Stop(sessionId);
1609 } else {
1610 CHECK_AND_RETURN_LOG(SafeGetMap(capturerManagerMap_, capturerIdSourceNameMap_[sessionId]),
1611 "cannot find device:%{public}s", capturerIdSourceNameMap_[sessionId].c_str());
1612 capturerManagerMap_[capturerIdSourceNameMap_[sessionId]]->Stop(sessionId);
1613 }
1614 capturerIdStreamInfoMap_[sessionId].state = HPAE_SESSION_STOPPING;
1615 } else {
1616 AUDIO_WARNING_LOG("Stop can not find sessionId streamClassType %{public}d, sessionId %{public}u",
1617 streamClassType, sessionId);
1618 }
1619 };
1620 SendRequest(request, __func__);
1621 return SUCCESS;
1622 }
1623
Release(HpaeStreamClassType streamClassType,uint32_t sessionId)1624 int32_t HpaeManager::Release(HpaeStreamClassType streamClassType, uint32_t sessionId)
1625 {
1626 DestroyStream(streamClassType, sessionId);
1627 return SUCCESS;
1628 }
1629
RegisterStatusCallback(HpaeStreamClassType streamClassType,uint32_t sessionId,const std::weak_ptr<IStreamStatusCallback> & callback)1630 int32_t HpaeManager::RegisterStatusCallback(HpaeStreamClassType streamClassType, uint32_t sessionId,
1631 const std::weak_ptr<IStreamStatusCallback> &callback)
1632 {
1633 auto request = [this, streamClassType, sessionId, callback]() {
1634 AUDIO_INFO_LOG(
1635 "RegisterStatusCallback streamClassType %{public}d, sessionId %{public}u", streamClassType, sessionId);
1636 if (streamClassType == HPAE_STREAM_CLASS_TYPE_PLAY &&
1637 rendererIdSinkNameMap_.find(sessionId) != rendererIdSinkNameMap_.end()) {
1638 AUDIO_INFO_LOG("renderer RegisterStatusCallback sessionId: %{public}u deviceName:%{public}s",
1639 sessionId,
1640 rendererIdSinkNameMap_[sessionId].c_str());
1641 rendererIdStreamInfoMap_[sessionId].statusCallback = callback;
1642 } else if (streamClassType == HPAE_STREAM_CLASS_TYPE_RECORD &&
1643 capturerIdSourceNameMap_.find(sessionId) != capturerIdSourceNameMap_.end()) {
1644 AUDIO_INFO_LOG("capturer RegisterStatusCallback sessionId: %{public}u deviceName:%{public}s",
1645 sessionId,
1646 capturerIdSourceNameMap_[sessionId].c_str());
1647 capturerIdStreamInfoMap_[sessionId].statusCallback = callback;
1648 } else {
1649 AUDIO_WARNING_LOG(
1650 "RegisterStatusCallback can not find sessionId streamClassType %{public}d, sessionId %{public}u",
1651 streamClassType,
1652 sessionId);
1653 }
1654 };
1655 SendRequest(request, __func__);
1656 return SUCCESS;
1657 }
1658
1659 // record stream interface
RegisterReadCallback(uint32_t sessionId,const std::weak_ptr<ICapturerStreamCallback> & callback)1660 int32_t HpaeManager::RegisterReadCallback(uint32_t sessionId, const std::weak_ptr<ICapturerStreamCallback> &callback)
1661 {
1662 auto request = [this, sessionId, callback]() {
1663 AUDIO_INFO_LOG("RegisterReadCallback sessionId %{public}u", sessionId);
1664 if (capturerIdSourceNameMap_.find(sessionId) != capturerIdSourceNameMap_.end()) {
1665 AUDIO_INFO_LOG("capturer RegisterReadCallback sessionId: %{public}u deviceName:%{public}s",
1666 sessionId,
1667 capturerIdSourceNameMap_[sessionId].c_str());
1668 if (INNER_SOURCE_TYPE_SET.count(capturerIdStreamInfoMap_[sessionId].streamInfo.sourceType) != 0) {
1669 CHECK_AND_RETURN_LOG(SafeGetMap(rendererManagerMap_, capturerIdSourceNameMap_[sessionId]),
1670 "cannot find device:%{public}s", capturerIdSourceNameMap_[sessionId].c_str());
1671 rendererManagerMap_[capturerIdSourceNameMap_[sessionId]]->RegisterReadCallback(sessionId, callback);
1672 } else {
1673 CHECK_AND_RETURN_LOG(SafeGetMap(capturerManagerMap_, capturerIdSourceNameMap_[sessionId]),
1674 "cannot find device:%{public}s", capturerIdSourceNameMap_[sessionId].c_str());
1675 capturerManagerMap_[capturerIdSourceNameMap_[sessionId]]->RegisterReadCallback(sessionId, callback);
1676 }
1677 } else {
1678 AUDIO_WARNING_LOG("RegisterReadCallback can not find sessionId, sessionId %{public}u", sessionId);
1679 }
1680 };
1681 SendRequest(request, __func__);
1682 return SUCCESS;
1683 }
1684
GetSourceOutputInfo(uint32_t sessionId,HpaeStreamInfo & streamInfo)1685 int32_t HpaeManager::GetSourceOutputInfo(uint32_t sessionId, HpaeStreamInfo &streamInfo)
1686 {
1687 // to do
1688 return SUCCESS;
1689 }
1690
1691 // play stream interface
SetClientVolume(uint32_t sessionId,float volume)1692 int32_t HpaeManager::SetClientVolume(uint32_t sessionId, float volume)
1693 {
1694 auto request = [this, sessionId, volume]() {
1695 AUDIO_INFO_LOG("SetClientVolume sessionId %{public}u %{public}f", sessionId, volume);
1696 if (rendererIdSinkNameMap_.find(sessionId) != rendererIdSinkNameMap_.end()) {
1697 CHECK_AND_RETURN_LOG(SafeGetMap(rendererManagerMap_, rendererIdSinkNameMap_[sessionId]),
1698 "cannot find device:%{public}s", rendererIdSinkNameMap_[sessionId].c_str());
1699 rendererManagerMap_[rendererIdSinkNameMap_[sessionId]]->SetClientVolume(sessionId, volume);
1700 } else {
1701 AUDIO_WARNING_LOG("SetClientVolume can not find sessionId, sessionId %{public}u", sessionId);
1702 }
1703 };
1704 SendRequest(request, __func__);
1705 return SUCCESS;
1706 }
1707
SetLoudnessGain(uint32_t sessionId,float loudnessGain)1708 int32_t HpaeManager::SetLoudnessGain(uint32_t sessionId, float loudnessGain)
1709 {
1710 auto request = [this, sessionId, loudnessGain]() {
1711 AUDIO_INFO_LOG("SetLoudnessGain sessionId %{public}u %{public}f", sessionId, loudnessGain);
1712 if (rendererIdSinkNameMap_.find(sessionId) != rendererIdSinkNameMap_.end()) {
1713 CHECK_AND_RETURN_LOG(SafeGetMap(rendererManagerMap_, rendererIdSinkNameMap_[sessionId]),
1714 "cannot find device:%{public}s", rendererIdSinkNameMap_[sessionId].c_str());
1715 rendererManagerMap_[rendererIdSinkNameMap_[sessionId]]->SetLoudnessGain(sessionId, loudnessGain);
1716 } else {
1717 AUDIO_WARNING_LOG("SetLoudnessGain can not find sessionId, sessionId %{public}u", sessionId);
1718 }
1719 };
1720 SendRequest(request, __func__);
1721 return SUCCESS;
1722 }
1723
SetRate(uint32_t sessionId,int32_t rate)1724 int32_t HpaeManager::SetRate(uint32_t sessionId, int32_t rate)
1725 {
1726 auto request = [this, sessionId, rate]() {
1727 AUDIO_INFO_LOG("SetRate sessionId %{public}u %{public}d", sessionId, rate);
1728 if (rendererIdSinkNameMap_.find(sessionId) != rendererIdSinkNameMap_.end()) {
1729 CHECK_AND_RETURN_LOG(SafeGetMap(rendererManagerMap_, rendererIdSinkNameMap_[sessionId]),
1730 "cannot find device:%{public}s", rendererIdSinkNameMap_[sessionId].c_str());
1731 rendererManagerMap_[rendererIdSinkNameMap_[sessionId]]->SetRate(sessionId, rate);
1732 } else {
1733 AUDIO_WARNING_LOG("SetRate can not find sessionId, sessionId %{public}u", sessionId);
1734 }
1735 };
1736 SendRequest(request, __func__);
1737 return SUCCESS;
1738 }
1739
SetAudioEffectMode(uint32_t sessionId,int32_t effectMode)1740 int32_t HpaeManager::SetAudioEffectMode(uint32_t sessionId, int32_t effectMode)
1741 {
1742 auto request = [this, sessionId, effectMode]() {
1743 AUDIO_INFO_LOG("SetAudioEffectMode sessionId %{public}u %{public}d", sessionId, effectMode);
1744 if (rendererIdSinkNameMap_.find(sessionId) != rendererIdSinkNameMap_.end()) {
1745 CHECK_AND_RETURN_LOG(SafeGetMap(rendererManagerMap_, rendererIdSinkNameMap_[sessionId]),
1746 "cannot find device:%{public}s", rendererIdSinkNameMap_[sessionId].c_str());
1747 rendererManagerMap_[rendererIdSinkNameMap_[sessionId]]->SetAudioEffectMode(sessionId, effectMode);
1748 } else {
1749 AUDIO_WARNING_LOG("SetAudioEffectMode can not find sessionId, sessionId %{public}u", sessionId);
1750 }
1751 };
1752 SendRequest(request, __func__);
1753 return SUCCESS;
1754 }
1755
GetAudioEffectMode(uint32_t sessionId,int32_t & effectMode)1756 int32_t HpaeManager::GetAudioEffectMode(uint32_t sessionId, int32_t &effectMode)
1757 {
1758 return SUCCESS;
1759 }
1760
SetPrivacyType(uint32_t sessionId,int32_t privacyType)1761 int32_t HpaeManager::SetPrivacyType(uint32_t sessionId, int32_t privacyType)
1762 {
1763 auto request = [this, sessionId, privacyType]() {
1764 if (rendererIdSinkNameMap_.find(sessionId) != rendererIdSinkNameMap_.end()) {
1765 CHECK_AND_RETURN_LOG(SafeGetMap(rendererManagerMap_, rendererIdSinkNameMap_[sessionId]),
1766 "cannot find device:%{public}s", rendererIdSinkNameMap_[sessionId].c_str());
1767 rendererManagerMap_[rendererIdSinkNameMap_[sessionId]]->SetPrivacyType(sessionId, privacyType);
1768 } else {
1769 AUDIO_WARNING_LOG("SetPrivacyType can not find sessionId, sessionId %{public}u", sessionId);
1770 }
1771 };
1772 SendRequest(request, __func__);
1773 return SUCCESS;
1774 }
1775
GetPrivacyType(uint32_t sessionId,int32_t & privacyType)1776 int32_t HpaeManager::GetPrivacyType(uint32_t sessionId, int32_t &privacyType)
1777 {
1778 return SUCCESS;
1779 }
1780
RegisterWriteCallback(uint32_t sessionId,const std::weak_ptr<IStreamCallback> & callback)1781 int32_t HpaeManager::RegisterWriteCallback(uint32_t sessionId, const std::weak_ptr<IStreamCallback> &callback)
1782 {
1783 auto request = [this, sessionId, callback]() {
1784 AUDIO_INFO_LOG("RegisterWriteCallback sessionId %{public}u", sessionId);
1785 if (rendererIdSinkNameMap_.find(sessionId) != rendererIdSinkNameMap_.end()) {
1786 AUDIO_INFO_LOG("renderer RegisterWriteCallback sessionId: %{public}u deviceName:%{public}s",
1787 sessionId,
1788 rendererIdSinkNameMap_[sessionId].c_str());
1789 CHECK_AND_RETURN_LOG(SafeGetMap(rendererManagerMap_, rendererIdSinkNameMap_[sessionId]),
1790 "cannot find device:%{public}s", rendererIdSinkNameMap_[sessionId].c_str());
1791 rendererManagerMap_[rendererIdSinkNameMap_[sessionId]]->RegisterWriteCallback(sessionId, callback);
1792 } else {
1793 AUDIO_WARNING_LOG("RegisterWriteCallback can not find sessionId, sessionId %{public}u", sessionId);
1794 }
1795 };
1796 SendRequest(request, __func__);
1797 return SUCCESS;
1798 }
1799
SetOffloadPolicy(uint32_t sessionId,int32_t state)1800 int32_t HpaeManager::SetOffloadPolicy(uint32_t sessionId, int32_t state)
1801 {
1802 auto request = [this, sessionId, state]() {
1803 AUDIO_INFO_LOG("SetOffloadPolicy sessionId %{public}u %{public}d", sessionId, state);
1804 if (rendererIdStreamInfoMap_.find(sessionId) != rendererIdStreamInfoMap_.end()) {
1805 rendererIdStreamInfoMap_[sessionId].offloadType = state;
1806 rendererIdStreamInfoMap_[sessionId].offloadEnable = state != OFFLOAD_DEFAULT;
1807 } else {
1808 AUDIO_WARNING_LOG("rendererIdStreamInfoMap_ can not find sessionId %{public}u", sessionId);
1809 }
1810 if (movingIds_.find(sessionId) != movingIds_.end()) { return ; }
1811 auto rendererManager = GetRendererManagerById(sessionId);
1812 if (rendererManager != nullptr) {
1813 rendererManager->SetOffloadPolicy(sessionId, state);
1814 } else {
1815 AUDIO_WARNING_LOG("SetOffloadPolicy can not find sessionId, sessionId %{public}u", sessionId);
1816 }
1817 };
1818 SendRequest(request, __func__);
1819 return SUCCESS;
1820 }
1821
GetWritableSize(uint32_t sessionId)1822 size_t HpaeManager::GetWritableSize(uint32_t sessionId)
1823 {
1824 return SUCCESS;
1825 }
1826
UpdateSpatializationState(uint32_t sessionId,bool spatializationEnabled,bool headTrackingEnabled)1827 int32_t HpaeManager::UpdateSpatializationState(uint32_t sessionId, bool spatializationEnabled, bool headTrackingEnabled)
1828 {
1829 auto request = [this, sessionId, spatializationEnabled, headTrackingEnabled]() {
1830 AUDIO_INFO_LOG("UpdateSpatializationState sessionId %{public}u spatializationEnabled %{public}d "
1831 "headTrackingEnabled %{public}d",
1832 sessionId,
1833 spatializationEnabled,
1834 headTrackingEnabled);
1835 if (rendererIdSinkNameMap_.find(sessionId) != rendererIdSinkNameMap_.end()) {
1836 CHECK_AND_RETURN_LOG(SafeGetMap(rendererManagerMap_, rendererIdSinkNameMap_[sessionId]),
1837 "cannot find device:%{public}s", rendererIdSinkNameMap_[sessionId].c_str());
1838 rendererManagerMap_[rendererIdSinkNameMap_[sessionId]]->UpdateSpatializationState(
1839 sessionId, spatializationEnabled, headTrackingEnabled);
1840 } else {
1841 AUDIO_WARNING_LOG("UpdateSpatializationState can not find sessionId, sessionId %{public}u", sessionId);
1842 }
1843 };
1844 SendRequest(request, __func__);
1845 return SUCCESS;
1846 }
1847
UpdateMaxLength(uint32_t sessionId,uint32_t maxLength)1848 int32_t HpaeManager::UpdateMaxLength(uint32_t sessionId, uint32_t maxLength)
1849 {
1850 auto request = [this, sessionId, maxLength]() {
1851 if (rendererIdSinkNameMap_.find(sessionId) != rendererIdSinkNameMap_.end()) {
1852 CHECK_AND_RETURN_LOG(SafeGetMap(rendererManagerMap_, rendererIdSinkNameMap_[sessionId]),
1853 "cannot find device:%{public}s", rendererIdSinkNameMap_[sessionId].c_str());
1854 rendererManagerMap_[rendererIdSinkNameMap_[sessionId]]->UpdateMaxLength(sessionId, maxLength);
1855 } else {
1856 AUDIO_WARNING_LOG("UpdateMaxLength can not find sessionId, sessionId %{public}u", sessionId);
1857 }
1858 };
1859 SendRequest(request, __func__);
1860 return SUCCESS;
1861 }
1862
SetOffloadRenderCallbackType(uint32_t sessionId,int32_t type)1863 int32_t HpaeManager::SetOffloadRenderCallbackType(uint32_t sessionId, int32_t type)
1864 {
1865 auto request = [this, sessionId, type]() {
1866 AUDIO_INFO_LOG("SetOffloadRenderCallbackType sessionId %{public}u %{public}d", sessionId, type);
1867 auto rendererManager = GetRendererManagerById(sessionId);
1868 if (rendererManager != nullptr) {
1869 rendererManager->SetOffloadRenderCallbackType(sessionId, type);
1870 } else {
1871 AUDIO_WARNING_LOG("SetOffloadRenderCallbackType can not find sessionId, sessionId %{public}u", sessionId);
1872 }
1873 };
1874 SendRequest(request, __func__);
1875 return SUCCESS;
1876 }
1877
SetSpeed(uint32_t sessionId,float speed)1878 void HpaeManager::SetSpeed(uint32_t sessionId, float speed)
1879 {
1880 auto request = [this, sessionId, speed]() {
1881 AUDIO_INFO_LOG("SetSpeed sessionId %{public}u %{public}f", sessionId, speed);
1882 CHECK_AND_RETURN_LOG(rendererIdStreamInfoMap_.find(sessionId) != rendererIdStreamInfoMap_.end(),
1883 "rendererIdStreamInfoMap_ can not find sessionId %{public}u", sessionId);
1884 rendererIdStreamInfoMap_[sessionId].speed = speed;
1885 CHECK_AND_RETURN_LOG(movingIds_.find(sessionId) == movingIds_.end(), "moving sessionId: %{public}u", sessionId);
1886 auto rendererManager = GetRendererManagerById(sessionId);
1887 CHECK_AND_RETURN_LOG(rendererManager != nullptr, "SetSpeed cannot find sessionId: %{public}u", sessionId);
1888 rendererManager->SetSpeed(sessionId, speed);
1889 };
1890 SendRequest(request, __func__);
1891 }
1892
1893 // only interface for unit test
GetSessionInfo(HpaeStreamClassType streamClassType,uint32_t sessionId,HpaeSessionInfo & sessionInfo)1894 int32_t HpaeManager::GetSessionInfo(
1895 HpaeStreamClassType streamClassType, uint32_t sessionId, HpaeSessionInfo &sessionInfo)
1896 {
1897 if (streamClassType == HPAE_STREAM_CLASS_TYPE_PLAY &&
1898 rendererIdStreamInfoMap_.find(sessionId) != rendererIdStreamInfoMap_.end()) {
1899 sessionInfo = rendererIdStreamInfoMap_[sessionId];
1900 } else if (streamClassType == HPAE_STREAM_CLASS_TYPE_RECORD &&
1901 capturerIdStreamInfoMap_.find(sessionId) != capturerIdStreamInfoMap_.end()) {
1902 sessionInfo = capturerIdStreamInfoMap_[sessionId];
1903 } else {
1904 return ERROR;
1905 }
1906 return SUCCESS;
1907 }
1908
GetRendererManagerByName(const std::string & sinkName)1909 std::shared_ptr<IHpaeRendererManager> HpaeManager::GetRendererManagerByName(const std::string &sinkName)
1910 {
1911 if (!SafeGetMap(rendererManagerMap_, sinkName)) {
1912 AUDIO_WARNING_LOG("can not find sinkName: %{public}s ", sinkName.c_str());
1913 return nullptr;
1914 }
1915 return rendererManagerMap_[sinkName];
1916 }
1917
GetCapturerManagerByName(const std::string & sourceName)1918 std::shared_ptr<IHpaeCapturerManager> HpaeManager::GetCapturerManagerByName(const std::string &sourceName)
1919 {
1920 if (!SafeGetMap(capturerManagerMap_, sourceName)) {
1921 AUDIO_WARNING_LOG("can not find sourceName: %{public}s ", sourceName.c_str());
1922 return nullptr;
1923 }
1924 return capturerManagerMap_[sourceName];
1925 }
1926
GetRendererManagerById(uint32_t sessionId)1927 std::shared_ptr<IHpaeRendererManager> HpaeManager::GetRendererManagerById(uint32_t sessionId)
1928 {
1929 if (rendererIdSinkNameMap_.find(sessionId) != rendererIdSinkNameMap_.end()) {
1930 return GetRendererManagerByName(rendererIdSinkNameMap_[sessionId]);
1931 }
1932 AUDIO_WARNING_LOG("can not find renderer by sessionId: %{public}u", sessionId);
1933 return nullptr;
1934 }
1935
GetCapturerManagerById(uint32_t sessionId)1936 std::shared_ptr<IHpaeCapturerManager> HpaeManager::GetCapturerManagerById(uint32_t sessionId)
1937 {
1938 if (capturerIdSourceNameMap_.find(sessionId) != capturerIdSourceNameMap_.end()) {
1939 return GetCapturerManagerByName(capturerIdSourceNameMap_[sessionId]);
1940 }
1941 AUDIO_WARNING_LOG("can not find capture by sessionId: %{public}u", sessionId);
1942 return nullptr;
1943 }
1944
InitAudioEffectChainManager(const std::vector<EffectChain> & effectChains,const EffectChainManagerParam & effectChainManagerParam,const std::vector<std::shared_ptr<AudioEffectLibEntry>> & effectLibraryList)1945 void HpaeManager::InitAudioEffectChainManager(const std::vector<EffectChain> &effectChains,
1946 const EffectChainManagerParam &effectChainManagerParam,
1947 const std::vector<std::shared_ptr<AudioEffectLibEntry>> &effectLibraryList)
1948 {
1949 auto request = [effectChains, effectChainManagerParam, effectLibraryList]() {
1950 HpaePolicyManager::GetInstance().InitAudioEffectChainManager(effectChains,
1951 effectChainManagerParam, effectLibraryList);
1952 };
1953 SendRequest(request, __func__);
1954 }
1955
SetOutputDeviceSink(int32_t device,const std::string & sinkName)1956 void HpaeManager::SetOutputDeviceSink(int32_t device, const std::string &sinkName)
1957 {
1958 auto request = [this, device, sinkName]() {
1959 HpaePolicyManager::GetInstance().SetOutputDeviceSink(device, sinkName);
1960 std::shared_ptr<IHpaeRendererManager> rendererManager = GetRendererManagerByName(sinkName);
1961 CHECK_AND_RETURN_LOG(rendererManager, "can not find sink[%{public}s] in rendererManagerMap_", sinkName.c_str());
1962 rendererManager->RefreshProcessClusterByDevice();
1963 };
1964 SendRequest(request, __func__);
1965 }
1966
UpdateSpatializationState(AudioSpatializationState spatializationState)1967 int32_t HpaeManager::UpdateSpatializationState(AudioSpatializationState spatializationState)
1968 {
1969 auto request = [spatializationState]() {
1970 HpaePolicyManager::GetInstance().UpdateSpatializationState(spatializationState);
1971 };
1972 SendRequest(request, __func__);
1973 return SUCCESS;
1974 }
1975
UpdateSpatialDeviceType(AudioSpatialDeviceType spatialDeviceType)1976 int32_t HpaeManager::UpdateSpatialDeviceType(AudioSpatialDeviceType spatialDeviceType)
1977 {
1978 auto request = [spatialDeviceType]() {
1979 HpaePolicyManager::GetInstance().UpdateSpatialDeviceType(spatialDeviceType);
1980 };
1981 SendRequest(request, __func__);
1982 return SUCCESS;
1983 }
1984
SetSpatializationSceneType(AudioSpatializationSceneType spatializationSceneType)1985 int32_t HpaeManager::SetSpatializationSceneType(AudioSpatializationSceneType spatializationSceneType)
1986 {
1987 auto request = [spatializationSceneType]() {
1988 HpaePolicyManager::GetInstance().SetSpatializationSceneType(spatializationSceneType);
1989 };
1990 SendRequest(request, __func__);
1991 return SUCCESS;
1992 }
1993
EffectRotationUpdate(const uint32_t rotationState)1994 int32_t HpaeManager::EffectRotationUpdate(const uint32_t rotationState)
1995 {
1996 auto request = [rotationState]() {
1997 HpaePolicyManager::GetInstance().EffectRotationUpdate(rotationState);
1998 };
1999 SendRequest(request, __func__);
2000 return SUCCESS;
2001 }
2002
SetEffectSystemVolume(const int32_t systemVolumeType,const float systemVolume)2003 int32_t HpaeManager::SetEffectSystemVolume(const int32_t systemVolumeType, const float systemVolume)
2004 {
2005 auto request = [systemVolumeType, systemVolume]() {
2006 HpaePolicyManager::GetInstance().SetEffectSystemVolume(systemVolumeType, systemVolume);
2007 };
2008 SendRequest(request, __func__);
2009 return SUCCESS;
2010 }
2011
SetAbsVolumeStateToEffect(const bool absVolumeState)2012 int32_t HpaeManager::SetAbsVolumeStateToEffect(const bool absVolumeState)
2013 {
2014 auto request = [absVolumeState]() {
2015 HpaePolicyManager::GetInstance().SetAbsVolumeStateToEffect(absVolumeState);
2016 };
2017 SendRequest(request, __func__);
2018 return SUCCESS;
2019 }
2020
SetAudioEffectProperty(const AudioEffectPropertyArrayV3 & propertyArray)2021 int32_t HpaeManager::SetAudioEffectProperty(const AudioEffectPropertyArrayV3 &propertyArray)
2022 {
2023 auto request = [propertyArray]() {
2024 HpaePolicyManager::GetInstance().SetAudioEffectProperty(propertyArray);
2025 };
2026 SendRequest(request, __func__);
2027 return SUCCESS;
2028 }
2029
GetAudioEffectProperty(AudioEffectPropertyArrayV3 & propertyArray)2030 int32_t HpaeManager::GetAudioEffectProperty(AudioEffectPropertyArrayV3 &propertyArray)
2031 {
2032 auto request = [this, &propertyArray]() {
2033 HpaePolicyManager::GetInstance().GetAudioEffectProperty(propertyArray);
2034 if (auto serviceCallback = serviceCallback_.lock()) {
2035 serviceCallback->OnGetAudioEffectPropertyCbV3(SUCCESS);
2036 }
2037 };
2038 SendRequest(request, __func__);
2039 return SUCCESS;
2040 }
2041
SetAudioEffectProperty(const AudioEffectPropertyArray & propertyArray)2042 int32_t HpaeManager::SetAudioEffectProperty(const AudioEffectPropertyArray &propertyArray)
2043 {
2044 auto request = [propertyArray]() {
2045 HpaePolicyManager::GetInstance().SetAudioEffectProperty(propertyArray);
2046 };
2047 SendRequest(request, __func__);
2048 return SUCCESS;
2049 }
2050
GetAudioEffectProperty(AudioEffectPropertyArray & propertyArray)2051 int32_t HpaeManager::GetAudioEffectProperty(AudioEffectPropertyArray &propertyArray)
2052 {
2053 auto request = [this, &propertyArray]() {
2054 HpaePolicyManager::GetInstance().GetAudioEffectProperty(propertyArray);
2055 if (auto serviceCallback = serviceCallback_.lock()) {
2056 serviceCallback->OnGetAudioEffectPropertyCb(SUCCESS);
2057 }
2058 };
2059 SendRequest(request, __func__);
2060 return SUCCESS;
2061 }
2062
InitHdiState()2063 void HpaeManager::InitHdiState()
2064 {
2065 auto request = []() {
2066 HpaePolicyManager::GetInstance().InitHdiState();
2067 };
2068 SendRequest(request, __func__);
2069 }
2070
UpdateEffectBtOffloadSupported(const bool & isSupported)2071 void HpaeManager::UpdateEffectBtOffloadSupported(const bool &isSupported)
2072 {
2073 auto request = [isSupported]() {
2074 HpaePolicyManager::GetInstance().UpdateEffectBtOffloadSupported(isSupported);
2075 };
2076 SendRequest(request, __func__);
2077 }
2078
UpdateParamExtra(const std::string & mainkey,const std::string & subkey,const std::string & value)2079 void HpaeManager::UpdateParamExtra(const std::string &mainkey, const std::string &subkey, const std::string &value)
2080 {
2081 auto request = [mainkey, subkey, value]() {
2082 HpaePolicyManager::GetInstance().UpdateParamExtra(mainkey, subkey, value);
2083 };
2084 SendRequest(request, __func__);
2085 }
2086
HandleRendererManager(const std::string & sinkName,const HpaeStreamInfo & streamInfo)2087 void HpaeManager::HandleRendererManager(const std::string &sinkName, const HpaeStreamInfo &streamInfo)
2088 {
2089 auto rendererManager = SafeGetMap(rendererManagerMap_, sinkName);
2090 CHECK_AND_RETURN_LOG(rendererManager, "can not find sink[%{public}s] in rendererManagerMap_", sinkName.c_str());
2091 rendererManager->CreateStream(streamInfo);
2092 if (streamInfo.streamClassType == HPAE_STREAM_CLASS_TYPE_PLAY) {
2093 rendererIdSinkNameMap_[streamInfo.sessionId] = sinkName;
2094 rendererIdStreamInfoMap_[streamInfo.sessionId] = {streamInfo, HPAE_SESSION_NEW};
2095 } else if (streamInfo.streamClassType == HPAE_STREAM_CLASS_TYPE_RECORD) {
2096 capturerIdSourceNameMap_[streamInfo.sessionId] = sinkName;
2097 capturerIdStreamInfoMap_[streamInfo.sessionId] = {streamInfo, HPAE_SESSION_NEW};
2098 }
2099 }
2100
CreateStreamForCapInner(const HpaeStreamInfo & streamInfo)2101 void HpaeManager::CreateStreamForCapInner(const HpaeStreamInfo &streamInfo)
2102 {
2103 if (streamInfo.streamClassType == HPAE_STREAM_CLASS_TYPE_INVALID) {
2104 AUDIO_INFO_LOG("streamInfo.streamClassType == HPAE_STREAM_CLASS_TYPE_INVALID");
2105 return;
2106 }
2107 std::string deviceName = streamInfo.deviceName;
2108 HandleRendererManager(deviceName, streamInfo);
2109 AddStreamToCollection(streamInfo, deviceName);
2110 return;
2111 }
2112
InitAudioEnhanceChainManager(const std::vector<EffectChain> & enhanceChains,const EffectChainManagerParam & managerParam,const std::vector<std::shared_ptr<AudioEffectLibEntry>> & enhanceLibraryList)2113 void HpaeManager::InitAudioEnhanceChainManager(const std::vector<EffectChain> &enhanceChains,
2114 const EffectChainManagerParam &managerParam,
2115 const std::vector<std::shared_ptr<AudioEffectLibEntry>> &enhanceLibraryList)
2116 {
2117 auto request = [enhanceChains, managerParam, enhanceLibraryList]() {
2118 HpaePolicyManager::GetInstance().InitAudioEnhanceChainManager(enhanceChains, managerParam, enhanceLibraryList);
2119 };
2120 SendRequest(request, __func__);
2121 }
2122
SetOutputDevice(const uint32_t & renderId,const DeviceType & outputDevice)2123 int32_t HpaeManager::SetOutputDevice(const uint32_t &renderId, const DeviceType &outputDevice)
2124 {
2125 auto request = [renderId, outputDevice]() {
2126 HpaePolicyManager::GetInstance().SetOutputDevice(renderId, outputDevice);
2127 };
2128 SendRequest(request, __func__);
2129 return SUCCESS;
2130 }
2131
SetVolumeInfo(const AudioVolumeType & volumeType,const float & systemVol)2132 int32_t HpaeManager::SetVolumeInfo(const AudioVolumeType &volumeType, const float &systemVol)
2133 {
2134 auto request = [volumeType, systemVol]() {
2135 HpaePolicyManager::GetInstance().SetVolumeInfo(volumeType, systemVol);
2136 };
2137 SendRequest(request, __func__);
2138 return SUCCESS;
2139 }
2140
SetMicrophoneMuteInfo(const bool & isMute)2141 int32_t HpaeManager::SetMicrophoneMuteInfo(const bool &isMute)
2142 {
2143 auto request = [isMute]() {
2144 HpaePolicyManager::GetInstance().SetMicrophoneMuteInfo(isMute);
2145 };
2146 SendRequest(request, __func__);
2147 return SUCCESS;
2148 }
2149
SetStreamVolumeInfo(const uint32_t & sessionId,const float & streamVol)2150 int32_t HpaeManager::SetStreamVolumeInfo(const uint32_t &sessionId, const float &streamVol)
2151 {
2152 auto request = [sessionId, streamVol]() {
2153 HpaePolicyManager::GetInstance().SetStreamVolumeInfo(sessionId, streamVol);
2154 };
2155 SendRequest(request, __func__);
2156 return SUCCESS;
2157 }
2158
SetAudioEnhanceProperty(const AudioEffectPropertyArrayV3 & propertyArray,DeviceType deviceType)2159 int32_t HpaeManager::SetAudioEnhanceProperty(const AudioEffectPropertyArrayV3 &propertyArray, DeviceType deviceType)
2160 {
2161 auto request = [propertyArray, deviceType]() {
2162 HpaePolicyManager::GetInstance().SetAudioEnhanceProperty(propertyArray, deviceType);
2163 };
2164 SendRequest(request, __func__);
2165 return SUCCESS;
2166 }
2167
GetAudioEnhanceProperty(AudioEffectPropertyArrayV3 & propertyArray,DeviceType deviceType)2168 int32_t HpaeManager::GetAudioEnhanceProperty(AudioEffectPropertyArrayV3 &propertyArray, DeviceType deviceType)
2169 {
2170 auto request = [this, &propertyArray, deviceType]() {
2171 HpaePolicyManager::GetInstance().GetAudioEnhanceProperty(propertyArray, deviceType);
2172 auto serviceCallback = serviceCallback_.lock();
2173 CHECK_AND_RETURN_LOG(serviceCallback != nullptr, "serviceCallback is nullptr");
2174 serviceCallback->OnGetAudioEnhancePropertyCbV3(SUCCESS);
2175 };
2176 SendRequest(request, __func__);
2177 return SUCCESS;
2178 }
2179
SetAudioEnhanceProperty(const AudioEnhancePropertyArray & propertyArray,DeviceType deviceType)2180 int32_t HpaeManager::SetAudioEnhanceProperty(const AudioEnhancePropertyArray &propertyArray, DeviceType deviceType)
2181 {
2182 auto request = [propertyArray, deviceType]() {
2183 HpaePolicyManager::GetInstance().SetAudioEnhanceProperty(propertyArray, deviceType);
2184 };
2185 SendRequest(request, __func__);
2186 return SUCCESS;
2187 }
2188
GetAudioEnhanceProperty(AudioEnhancePropertyArray & propertyArray,DeviceType deviceType)2189 int32_t HpaeManager::GetAudioEnhanceProperty(AudioEnhancePropertyArray &propertyArray, DeviceType deviceType)
2190 {
2191 auto request = [this, &propertyArray, deviceType]() {
2192 HpaePolicyManager::GetInstance().GetAudioEnhanceProperty(propertyArray, deviceType);
2193 auto serviceCallback = serviceCallback_.lock();
2194 CHECK_AND_RETURN_LOG(serviceCallback != nullptr, "serviceCallback is nullptr");
2195 serviceCallback->OnGetAudioEnhancePropertyCb(SUCCESS);
2196 };
2197 SendRequest(request, __func__);
2198 return SUCCESS;
2199 }
2200
UpdateExtraSceneType(const std::string & mainkey,const std::string & subkey,const std::string & extraSceneType)2201 void HpaeManager::UpdateExtraSceneType(
2202 const std::string &mainkey, const std::string &subkey, const std::string &extraSceneType)
2203 {
2204 auto request = [mainkey, subkey, extraSceneType]() {
2205 HpaePolicyManager::GetInstance().UpdateExtraSceneType(mainkey, subkey, extraSceneType);
2206 };
2207 SendRequest(request, __func__);
2208 return;
2209 }
2210
NotifySettingsDataReady()2211 void HpaeManager::NotifySettingsDataReady()
2212 {
2213 HpaePolicyManager::GetInstance().LoadEffectProperties();
2214 LoadEffectLive();
2215 }
2216
NotifyAccountsChanged()2217 void HpaeManager::NotifyAccountsChanged()
2218 {
2219 HpaePolicyManager::GetInstance().LoadEffectProperties();
2220 LoadEffectLive();
2221 }
2222
IsAcousticEchoCancelerSupported(SourceType sourceType)2223 bool HpaeManager::IsAcousticEchoCancelerSupported(SourceType sourceType)
2224 {
2225 if (sourceType == SOURCE_TYPE_VOICE_COMMUNICATION || sourceType == SOURCE_TYPE_VOICE_TRANSCRIPTION) {
2226 return true;
2227 }
2228 if (sourceType != SOURCE_TYPE_LIVE) {
2229 return false;
2230 }
2231 std::string value = HpaePolicyManager::GetInstance().GetAudioParameter("primary", AudioParamKey::PARAM_KEY_STATE,
2232 "source_type_live_aec_supported");
2233 AUDIO_INFO_LOG("live_aec_supported: %{public}s", value.c_str());
2234 if (value == "true") {
2235 return true;
2236 }
2237 return false;
2238 }
2239
LoadEffectLive()2240 void HpaeManager::LoadEffectLive()
2241 {
2242 AudioSettingProvider &settingProvider = AudioSettingProvider::GetInstance(AUDIO_POLICY_SERVICE_ID);
2243 ErrCode ret = ERROR;
2244 if (!settingProvider.CheckOsAccountReady()) {
2245 AUDIO_ERR_LOG("OS account not ready");
2246 } else {
2247 std::string configValue;
2248 ret = settingProvider.GetStringValue("live_effect_enable", configValue, "system");
2249 if (ret == SUCCESS && !configValue.empty()) {
2250 effectLiveState_ = configValue;
2251 return;
2252 }
2253 }
2254 std::string state = HpaePolicyManager::GetInstance().GetAudioParameter(
2255 "primary", AudioParamKey::PARAM_KEY_STATE, "live_effect_supported");
2256 AUDIO_INFO_LOG("EffectLive %{public}s", effectLiveState_.c_str());
2257 if (state != "true") {
2258 effectLiveState_ = "NoSupport";
2259 return;
2260 } else {
2261 effectLiveState_ = "NROFF";
2262 }
2263 if (settingProvider.CheckOsAccountReady()) {
2264 settingProvider.PutStringValue("live_effect_enable", effectLiveState_, "system");
2265 }
2266 }
2267
SetEffectLiveParameter(const std::vector<std::pair<std::string,std::string>> & params)2268 bool HpaeManager::SetEffectLiveParameter(const std::vector<std::pair<std::string, std::string>> ¶ms)
2269 {
2270 CHECK_AND_RETURN_RET_LOG(!params.empty(), false, "params is empty");
2271 const auto &[paramKey, paramValue] = params[0];
2272 if (paramKey != "live_effect_enable" || (paramValue != "NRON" && paramValue != "NROFF")) {
2273 AUDIO_ERR_LOG("Parameter Error");
2274 return false;
2275 }
2276
2277 if (effectLiveState_ == "") {
2278 LoadEffectLive();
2279 }
2280
2281 if (effectLiveState_ == "NoSupport") {
2282 AUDIO_ERR_LOG("effectLive not supported");
2283 return false;
2284 }
2285
2286 const std::string combinedParam = paramKey + "=" + paramValue;
2287 HpaePolicyManager::GetInstance().SetAudioParameter("primary", AudioParamKey::PARAM_KEY_STATE, "", combinedParam);
2288 effectLiveState_ = paramValue;
2289 AudioSettingProvider &settingProvider = AudioSettingProvider::GetInstance(AUDIO_POLICY_SERVICE_ID);
2290 if (!settingProvider.CheckOsAccountReady()) {
2291 AUDIO_ERR_LOG("OS account not ready");
2292 return false;
2293 }
2294
2295 ErrCode ret = settingProvider.PutStringValue(paramKey, paramValue, "system");
2296 if (ret != SUCCESS) {
2297 AUDIO_ERR_LOG("Failed to set system value");
2298 return false;
2299 }
2300 return true;
2301 }
2302
GetEffectLiveParameter(const std::vector<std::string> & subKeys,std::vector<std::pair<std::string,std::string>> & result)2303 bool HpaeManager::GetEffectLiveParameter(const std::vector<std::string> &subKeys,
2304 std::vector<std::pair<std::string, std::string>> &result)
2305 {
2306 std::string targetKey = subKeys.empty() ? "live_effect_supported" : subKeys[0];
2307 if (targetKey != "live_effect_supported") {
2308 AUDIO_ERR_LOG("Parameter Error");
2309 return false;
2310 }
2311 if (effectLiveState_ != "") {
2312 result.emplace_back(targetKey, effectLiveState_);
2313 return true;
2314 }
2315 LoadEffectLive();
2316 result.emplace_back(targetKey, effectLiveState_);
2317 return true;
2318 }
2319
UpdateCollaborativeState(bool isCollaborationEnabled)2320 int32_t HpaeManager::UpdateCollaborativeState(bool isCollaborationEnabled)
2321 {
2322 auto request = [this, isCollaborationEnabled]() {
2323 std::shared_ptr<IHpaeRendererManager> rendererManager = GetRendererManagerByName(BT_SINK_NAME);
2324 CHECK_AND_RETURN_LOG(rendererManager != nullptr,
2325 "can not find sink[%{public}s] in rendererManagerMap_", BT_SINK_NAME.c_str());
2326 rendererManager->UpdateCollaborativeState(isCollaborationEnabled);
2327 };
2328 SendRequest(request, __func__);
2329 return SUCCESS;
2330 }
2331
HandleConnectCoBufferNode(std::shared_ptr<HpaeCoBufferNode> hpaeCoBufferNode)2332 void HpaeManager::HandleConnectCoBufferNode(std::shared_ptr<HpaeCoBufferNode> hpaeCoBufferNode)
2333 {
2334 auto request = [this, hpaeCoBufferNode]() {
2335 AUDIO_INFO_LOG("HandleConnectCoBufferNode");
2336 std::shared_ptr<IHpaeRendererManager> defaultRendererManager = GetRendererManagerByName(coreSink_);
2337 CHECK_AND_RETURN_LOG(defaultRendererManager != nullptr,
2338 "can not find sink[%{public}s] in rendererManagerMap_", coreSink_.c_str());
2339 CHECK_AND_RETURN_LOG(hpaeCoBufferNode != nullptr, "hpaeCoBufferNode is nullptr");
2340 defaultRendererManager->ConnectCoBufferNode(hpaeCoBufferNode);
2341 };
2342 SendRequest(request, __func__);
2343 }
2344
HandleDisConnectCoBufferNode(std::shared_ptr<HpaeCoBufferNode> hpaeCoBufferNode)2345 void HpaeManager::HandleDisConnectCoBufferNode(std::shared_ptr<HpaeCoBufferNode> hpaeCoBufferNode)
2346 {
2347 auto request = [this, hpaeCoBufferNode]() {
2348 AUDIO_INFO_LOG("HandleDisConnectCoBufferNode");
2349 std::shared_ptr<IHpaeRendererManager> defaultRendererManager = GetRendererManagerByName(coreSink_);
2350 CHECK_AND_RETURN_LOG(defaultRendererManager != nullptr,
2351 "can not find sink[%{public}s] in rendererManagerMap_", coreSink_.c_str());
2352 CHECK_AND_RETURN_LOG(hpaeCoBufferNode != nullptr, "hpaeCoBufferNode is nullptr");
2353 defaultRendererManager->DisConnectCoBufferNode(hpaeCoBufferNode);
2354 };
2355 SendRequest(request, __func__);
2356 }
2357
AddStreamVolumeToEffect(const std::string stringSessionID,const float streamVolume)2358 void HpaeManager::AddStreamVolumeToEffect(const std::string stringSessionID, const float streamVolume)
2359 {
2360 auto request = [stringSessionID, streamVolume]() {
2361 HpaePolicyManager::GetInstance().AddStreamVolumeToEffect(stringSessionID, streamVolume);
2362 };
2363 SendRequest(request, __func__);
2364 }
2365
DeleteStreamVolumeToEffect(const std::string stringSessionID)2366 void HpaeManager::DeleteStreamVolumeToEffect(const std::string stringSessionID)
2367 {
2368 auto request = [stringSessionID]() {
2369 HpaePolicyManager::GetInstance().DeleteStreamVolumeToEffect(stringSessionID);
2370 };
2371 SendRequest(request, __func__);
2372 }
2373 } // namespace HPAE
2374 } // namespace AudioStandard
2375 } // namespace OHOS
2376