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 #include <string>
16 #include <thread>
17 #include <chrono>
18 #include <cstdio>
19 #include <fstream>
20 #include <streambuf>
21 #include <algorithm>
22 #include <unistd.h>
23 #include "test_case_common.h"
24 #include "audio_errors.h"
25 #include "hpae_audio_service_dump_callback_unit_test.h"
26 #include "hpae_manager_unit_test.h"
27 #include "hpae_manager.h"
28
29 using namespace OHOS;
30 using namespace AudioStandard;
31 using namespace HPAE;
32 using namespace testing::ext;
33 using namespace testing;
34
35 namespace {
36 static std::string g_rootPath = "/data/";
37 const std::string ROOT_PATH = "/data/source_file_io_48000_2_s16le.pcm";
38 constexpr int32_t FRAME_LENGTH = 882;
39 constexpr int32_t TEST_STREAM_SESSION_ID = 123456;
40 constexpr int32_t TEST_STREAM_UID = 111111;
41 constexpr int32_t TEST_SLEEP_TIME_20 = 20;
42 constexpr int32_t TEST_SLEEP_TIME_40 = 40;
43 constexpr int32_t SESSION_ID_NOEXIST = 100000;
44
45 class HpaeManagerUnitTest : public testing::Test {
46 public:
47 void SetUp();
48 void TearDown();
49 std::shared_ptr<HpaeManager> hpaeManager_ = nullptr;
50 };
SetUp()51 void HpaeManagerUnitTest::SetUp()
52 {
53 hpaeManager_ = std::make_shared<HPAE::HpaeManager>();
54 }
55
TearDown()56 void HpaeManagerUnitTest::TearDown()
57 {
58 hpaeManager_->DeInit();
59 hpaeManager_ = nullptr;
60 }
61
WaitForMsgProcessing(std::shared_ptr<HpaeManager> & hpaeManager)62 void WaitForMsgProcessing(std::shared_ptr<HpaeManager> &hpaeManager)
63 {
64 int waitCount = 0;
65 const int waitCountThd = 5;
66 while (hpaeManager->IsMsgProcessing()) {
67 std::this_thread::sleep_for(std::chrono::milliseconds(TEST_SLEEP_TIME_20));
68 waitCount++;
69 if (waitCount >= waitCountThd) {
70 break;
71 }
72 }
73 std::this_thread::sleep_for(std::chrono::milliseconds(TEST_SLEEP_TIME_40));
74 EXPECT_EQ(hpaeManager->IsMsgProcessing(), false);
75 EXPECT_EQ(waitCount < waitCountThd, true);
76 }
77
GetSinkAudioModeInfo(std::string name="Speaker_File")78 AudioModuleInfo GetSinkAudioModeInfo(std::string name = "Speaker_File")
79 {
80 AudioModuleInfo audioModuleInfo;
81 audioModuleInfo.lib = "libmodule-hdi-sink.z.so";
82 audioModuleInfo.channels = "2";
83 audioModuleInfo.rate = "48000";
84 audioModuleInfo.name = name;
85 audioModuleInfo.adapterName = "file_io";
86 audioModuleInfo.className = "file_io";
87 audioModuleInfo.bufferSize = "7680";
88 audioModuleInfo.format = "s32le";
89 audioModuleInfo.fixedLatency = "1";
90 audioModuleInfo.offloadEnable = "0";
91 audioModuleInfo.networkId = "LocalDevice";
92 audioModuleInfo.fileName = g_rootPath + audioModuleInfo.adapterName + "_" + audioModuleInfo.rate + "_" +
93 audioModuleInfo.channels + "_" + audioModuleInfo.format + ".pcm";
94 audioModuleInfo.needEmptyChunk = true;
95 std::stringstream typeValue;
96 typeValue << static_cast<int32_t>(DEVICE_TYPE_SPEAKER);
97 audioModuleInfo.deviceType = typeValue.str();
98 return audioModuleInfo;
99 }
100
GetSourceAudioModeInfo(std::string name="mic")101 AudioModuleInfo GetSourceAudioModeInfo(std::string name = "mic")
102 {
103 AudioModuleInfo audioModuleInfo;
104 audioModuleInfo.lib = "libmodule-hdi-source.z.so";
105 audioModuleInfo.channels = "2";
106 audioModuleInfo.rate = "48000";
107 audioModuleInfo.name = name;
108 audioModuleInfo.adapterName = "file_io";
109 audioModuleInfo.className = "file_io";
110 audioModuleInfo.bufferSize = "3840";
111 audioModuleInfo.format = "s16le";
112 audioModuleInfo.fixedLatency = "1";
113 audioModuleInfo.offloadEnable = "0";
114 audioModuleInfo.networkId = "LocalDevice";
115 audioModuleInfo.fileName = g_rootPath + "source_" + audioModuleInfo.adapterName + "_" + audioModuleInfo.rate + "_" +
116 audioModuleInfo.channels + "_" + audioModuleInfo.format + ".pcm";
117 std::stringstream typeValue;
118 typeValue << static_cast<int32_t>(DEVICE_TYPE_FILE_SOURCE);
119 audioModuleInfo.deviceType = typeValue.str();
120 return audioModuleInfo;
121 }
122
GetRenderStreamInfo()123 HpaeStreamInfo GetRenderStreamInfo()
124 {
125 HpaeStreamInfo streamInfo;
126 streamInfo.channels = STEREO;
127 streamInfo.samplingRate = SAMPLE_RATE_44100;
128 streamInfo.format = SAMPLE_S16LE;
129 streamInfo.frameLen = FRAME_LENGTH;
130 streamInfo.sessionId = TEST_STREAM_SESSION_ID;
131 streamInfo.streamType = STREAM_MUSIC;
132 streamInfo.streamClassType = HPAE_STREAM_CLASS_TYPE_PLAY;
133 streamInfo.uid = TEST_STREAM_UID;
134 return streamInfo;
135 }
136
GetCaptureStreamInfo()137 HpaeStreamInfo GetCaptureStreamInfo()
138 {
139 HpaeStreamInfo streamInfo;
140 streamInfo.channels = STEREO;
141 streamInfo.samplingRate = SAMPLE_RATE_48000;
142 streamInfo.format = SAMPLE_S16LE;
143 streamInfo.frameLen = FRAME_LENGTH;
144 streamInfo.sessionId = TEST_STREAM_SESSION_ID;
145 streamInfo.streamType = STREAM_MUSIC;
146 streamInfo.streamClassType = HPAE_STREAM_CLASS_TYPE_RECORD;
147 streamInfo.uid = TEST_STREAM_UID;
148 return streamInfo;
149 }
150
151 HWTEST_F(HpaeManagerUnitTest, constructHpaeManagerTest, TestSize.Level0)
152 {
153 EXPECT_NE(hpaeManager_, nullptr);
154 hpaeManager_->Init();
155 EXPECT_EQ(hpaeManager_->IsInit(), true);
156 sleep(1);
157 EXPECT_EQ(hpaeManager_->IsRunning(), true);
158 hpaeManager_->DeInit();
159 EXPECT_EQ(hpaeManager_->IsInit(), false);
160 sleep(1);
161 EXPECT_EQ(hpaeManager_->IsRunning(), false);
162 }
163
164 HWTEST_F(HpaeManagerUnitTest, GetHpaeRenderManagerTest, TestSize.Level1)
165 {
166 EXPECT_NE(hpaeManager_, nullptr);
167 hpaeManager_->Init();
168 EXPECT_EQ(hpaeManager_->IsInit(), true);
169 sleep(1);
170 EXPECT_EQ(hpaeManager_->IsRunning(), true);
171
172 std::shared_ptr<HpaeAudioServiceCallbackUnitTest> callback = std::make_shared<HpaeAudioServiceCallbackUnitTest>();
173 hpaeManager_->RegisterSerivceCallback(callback);
174 AudioModuleInfo audioModuleInfo = GetSinkAudioModeInfo();
175 EXPECT_EQ(hpaeManager_->OpenAudioPort(audioModuleInfo), SUCCESS);
176 WaitForMsgProcessing(hpaeManager_);
177 int32_t portId = callback->GetPortId();
178
179 hpaeManager_->CloseAudioPort(portId);
180 WaitForMsgProcessing(hpaeManager_);
181 EXPECT_EQ(callback->GetCloseAudioPortResult(), SUCCESS);
182
183 hpaeManager_->DeInit();
184 EXPECT_EQ(hpaeManager_->IsInit(), false);
185 EXPECT_EQ(hpaeManager_->IsRunning(), false);
186 }
187
188 HWTEST_F(HpaeManagerUnitTest, IHpaeRenderManagerTest, TestSize.Level1)
189 {
190 IHpaeManager::GetHpaeManager().Init();
191 EXPECT_EQ(IHpaeManager::GetHpaeManager().IsInit(), true);
192 sleep(1);
193 EXPECT_EQ(IHpaeManager::GetHpaeManager().IsRunning(), true);
194
195 AudioModuleInfo audioModuleInfo = GetSinkAudioModeInfo();
196 EXPECT_EQ(IHpaeManager::GetHpaeManager().OpenAudioPort(audioModuleInfo), SUCCESS);
197 IHpaeManager::GetHpaeManager().DeInit();
198 EXPECT_EQ(IHpaeManager::GetHpaeManager().IsInit(), false);
199 EXPECT_EQ(IHpaeManager::GetHpaeManager().IsRunning(), false);
200 }
201
202 HWTEST_F(HpaeManagerUnitTest, IHpaeRenderStreamManagerTest, TestSize.Level1)
203 {
204 EXPECT_NE(hpaeManager_, nullptr);
205 hpaeManager_->Init();
206 EXPECT_EQ(hpaeManager_->IsInit(), true);
207 sleep(1);
208 AudioModuleInfo audioModuleInfo = GetSinkAudioModeInfo();
209 std::shared_ptr<HpaeAudioServiceCallbackUnitTest> callback = std::make_shared<HpaeAudioServiceCallbackUnitTest>();
210 int32_t result = hpaeManager_->RegisterSerivceCallback(callback);
211 EXPECT_EQ(result, SUCCESS);
212 EXPECT_EQ(hpaeManager_->OpenAudioPort(audioModuleInfo), SUCCESS);
213 hpaeManager_->SetDefaultSink(audioModuleInfo.name);
214 WaitForMsgProcessing(hpaeManager_);
215 HpaeStreamInfo streamInfo = GetRenderStreamInfo();
216 hpaeManager_->CreateStream(streamInfo);
217 WaitForMsgProcessing(hpaeManager_);
218
219 EXPECT_EQ(hpaeManager_->SetSinkMute(audioModuleInfo.name, true, true), SUCCESS);
220 WaitForMsgProcessing(hpaeManager_);
221 EXPECT_EQ(callback->GetSetSinkMuteResult(), SUCCESS);
222 EXPECT_EQ(hpaeManager_->SetSinkMute(audioModuleInfo.name, false, true), SUCCESS);
223 WaitForMsgProcessing(hpaeManager_);
224 EXPECT_EQ(callback->GetSetSinkMuteResult(), SUCCESS);
225
226 EXPECT_EQ(hpaeManager_->SuspendAudioDevice(audioModuleInfo.name, true), SUCCESS);
227 EXPECT_EQ(hpaeManager_->SuspendAudioDevice(audioModuleInfo.name, false), SUCCESS);
228
229 EXPECT_EQ(hpaeManager_->GetAllSinkInputs(), SUCCESS);
230 WaitForMsgProcessing(hpaeManager_);
231 EXPECT_EQ(callback->GetGetAllSinkInputsResult(), SUCCESS);
232 std::vector<SinkInput> sinkInputs = callback->GetSinkInputs();
233 EXPECT_EQ(sinkInputs.size(), 1);
234 for (const auto &it : sinkInputs) {
235 std::cout << "sinkInputs.sinkName:" << it.sinkName << std::endl;
236 EXPECT_EQ(it.paStreamId, streamInfo.sessionId);
237 EXPECT_EQ(it.sinkName, audioModuleInfo.name);
238 }
239 hpaeManager_->Release(streamInfo.streamClassType, streamInfo.sessionId);
240 WaitForMsgProcessing(hpaeManager_);
241
242 EXPECT_EQ(hpaeManager_->GetAllSinkInputs(), SUCCESS);
243 WaitForMsgProcessing(hpaeManager_);
244 EXPECT_EQ(callback->GetGetAllSinkInputsResult(), SUCCESS);
245 sinkInputs = callback->GetSinkInputs();
246 EXPECT_EQ(sinkInputs.size(), 0);
247 }
248
249 HWTEST_F(HpaeManagerUnitTest, IHpaeCaptureStreamManagerTest, TestSize.Level1)
250 {
251 EXPECT_NE(hpaeManager_, nullptr);
252 hpaeManager_->Init();
253 EXPECT_EQ(hpaeManager_->IsInit(), true);
254 sleep(1);
255 std::shared_ptr<HpaeAudioServiceCallbackUnitTest> callback = std::make_shared<HpaeAudioServiceCallbackUnitTest>();
256 int32_t result = hpaeManager_->RegisterSerivceCallback(callback);
257 EXPECT_EQ(result, SUCCESS);
258
259 AudioModuleInfo audioModuleInfo = GetSourceAudioModeInfo();
260 EXPECT_EQ(hpaeManager_->OpenAudioPort(audioModuleInfo), SUCCESS);
261 WaitForMsgProcessing(hpaeManager_);
262 hpaeManager_->SetDefaultSource(audioModuleInfo.name);
263 int32_t portId = callback->GetPortId();
264 HpaeStreamInfo streamInfo = GetCaptureStreamInfo();
265 hpaeManager_->CreateStream(streamInfo);
266 WaitForMsgProcessing(hpaeManager_);
267
268 EXPECT_EQ(hpaeManager_->SetSourceOutputMute(TEST_STREAM_UID, true), SUCCESS);
269 WaitForMsgProcessing(hpaeManager_);
270 EXPECT_EQ(callback->GetSetSourceOutputMuteResult(), SUCCESS);
271 EXPECT_EQ(hpaeManager_->SetSourceOutputMute(TEST_STREAM_UID, true), SUCCESS);
272 WaitForMsgProcessing(hpaeManager_);
273 EXPECT_EQ(hpaeManager_->SetSourceOutputMute(TEST_STREAM_UID, false), SUCCESS);
274 WaitForMsgProcessing(hpaeManager_);
275 EXPECT_EQ(callback->GetSetSourceOutputMuteResult(), SUCCESS);
276
277 EXPECT_EQ(hpaeManager_->GetAllSourceOutputs(), SUCCESS);
278 WaitForMsgProcessing(hpaeManager_);
279 EXPECT_EQ(callback->GetGetAllSourceOutputsResult(), SUCCESS);
280 std::vector<SourceOutput> sourceOutputs = callback->GetSourceOutputs();
281 EXPECT_EQ(sourceOutputs.size(), 1);
282 for (const auto &it : sourceOutputs) {
283 std::cout << "deviceSourceId:" << it.deviceSourceId << std::endl;
284 EXPECT_EQ(it.paStreamId, streamInfo.sessionId);
285 EXPECT_EQ(it.deviceSourceId, portId);
286 }
287
288 hpaeManager_->Release(streamInfo.streamClassType, streamInfo.sessionId);
289 WaitForMsgProcessing(hpaeManager_);
290 }
291
292 HWTEST_F(HpaeManagerUnitTest, IHpaeRenderStreamManagerTest002, TestSize.Level1)
293 {
294 EXPECT_NE(hpaeManager_, nullptr);
295 hpaeManager_->Init();
296 EXPECT_EQ(hpaeManager_->IsInit(), true);
297 sleep(1);
298 AudioModuleInfo audioModuleInfo = GetSinkAudioModeInfo();
299 EXPECT_EQ(hpaeManager_->OpenAudioPort(audioModuleInfo), SUCCESS);
300 hpaeManager_->SetDefaultSink(audioModuleInfo.name);
301 WaitForMsgProcessing(hpaeManager_);
302 HpaeStreamInfo streamInfo = GetRenderStreamInfo();
303 hpaeManager_->CreateStream(streamInfo);
304 WaitForMsgProcessing(hpaeManager_);
305 int32_t fixedNum = 100;
306 std::shared_ptr<WriteFixedValueCb> writeFixedValueCb = std::make_shared<WriteFixedValueCb>(SAMPLE_S16LE, fixedNum);
307 hpaeManager_->RegisterWriteCallback(streamInfo.sessionId, writeFixedValueCb);
308 std::shared_ptr<StatusChangeCb> statusChangeCb = std::make_shared<StatusChangeCb>();
309 hpaeManager_->RegisterStatusCallback(HPAE_STREAM_CLASS_TYPE_PLAY, streamInfo.sessionId, statusChangeCb);
310 WaitForMsgProcessing(hpaeManager_);
311 HpaeSessionInfo sessionInfo;
312 EXPECT_EQ(hpaeManager_->GetSessionInfo(streamInfo.streamClassType, streamInfo.sessionId, sessionInfo), SUCCESS);
313 EXPECT_EQ(sessionInfo.streamInfo.sessionId, streamInfo.sessionId);
314 EXPECT_EQ(sessionInfo.streamInfo.streamType, streamInfo.streamType);
315 EXPECT_EQ(sessionInfo.streamInfo.frameLen, streamInfo.frameLen);
316 EXPECT_EQ(sessionInfo.streamInfo.format, streamInfo.format);
317 EXPECT_EQ(sessionInfo.streamInfo.samplingRate, streamInfo.samplingRate);
318 EXPECT_EQ(sessionInfo.streamInfo.channels, streamInfo.channels);
319 EXPECT_EQ(sessionInfo.streamInfo.streamClassType, streamInfo.streamClassType);
320 EXPECT_EQ(sessionInfo.state, HPAE_SESSION_NEW);
321
322 hpaeManager_->Start(streamInfo.streamClassType, streamInfo.sessionId);
323 WaitForMsgProcessing(hpaeManager_);
324 hpaeManager_->GetSessionInfo(streamInfo.streamClassType, streamInfo.sessionId, sessionInfo);
325 EXPECT_EQ(sessionInfo.state, HPAE_SESSION_RUNNING);
326 EXPECT_EQ(statusChangeCb->GetStatus(), I_STATUS_STARTED);
327
328 int32_t syncId = 123;
329 hpaeManager_->StartWithSyncId(streamInfo.streamClassType, streamInfo.sessionId, syncId);
330 WaitForMsgProcessing(hpaeManager_);
331 hpaeManager_->GetSessionInfo(streamInfo.streamClassType, streamInfo.sessionId, sessionInfo);
332 EXPECT_EQ(sessionInfo.state, HPAE_SESSION_RUNNING);
333 EXPECT_EQ(statusChangeCb->GetStatus(), I_STATUS_STARTED);
334
335 hpaeManager_->Pause(streamInfo.streamClassType, streamInfo.sessionId);
336 WaitForMsgProcessing(hpaeManager_);
337 EXPECT_EQ(hpaeManager_->GetSessionInfo(streamInfo.streamClassType, streamInfo.sessionId, sessionInfo), SUCCESS);
338 EXPECT_EQ(sessionInfo.state, HPAE_SESSION_PAUSING);
339 EXPECT_EQ(statusChangeCb->GetStatus(), I_STATUS_PAUSED);
340
341 hpaeManager_->Stop(streamInfo.streamClassType, streamInfo.sessionId);
342 WaitForMsgProcessing(hpaeManager_);
343 EXPECT_EQ(hpaeManager_->GetSessionInfo(streamInfo.streamClassType, streamInfo.sessionId, sessionInfo), SUCCESS);
344 EXPECT_EQ(sessionInfo.state, HPAE_SESSION_STOPPING);
345 EXPECT_EQ(statusChangeCb->GetStatus(), I_STATUS_STOPPED);
346
347 hpaeManager_->Release(streamInfo.streamClassType, streamInfo.sessionId);
348 WaitForMsgProcessing(hpaeManager_);
349 EXPECT_EQ(hpaeManager_->GetSessionInfo(streamInfo.streamClassType, streamInfo.sessionId, sessionInfo), ERROR);
350 }
351
352 HWTEST_F(HpaeManagerUnitTest, IHpaeRenderStreamManagerTest003, TestSize.Level1)
353 {
354 EXPECT_NE(hpaeManager_, nullptr);
355 hpaeManager_->Init();
356 EXPECT_EQ(hpaeManager_->IsInit(), true);
357 sleep(1);
358 AudioModuleInfo audioModuleInfo = GetSinkAudioModeInfo();
359 EXPECT_EQ(hpaeManager_->OpenAudioPort(audioModuleInfo), SUCCESS);
360 hpaeManager_->SetDefaultSink(audioModuleInfo.name);
361 WaitForMsgProcessing(hpaeManager_);
362 HpaeStreamInfo streamInfo = GetRenderStreamInfo();
363 hpaeManager_->CreateStream(streamInfo);
364 WaitForMsgProcessing(hpaeManager_);
365 int32_t fixedNum = 100;
366 std::shared_ptr<WriteFixedValueCb> writeFixedValueCb = std::make_shared<WriteFixedValueCb>(SAMPLE_S16LE, fixedNum);
367 hpaeManager_->RegisterWriteCallback(streamInfo.sessionId, writeFixedValueCb);
368 std::shared_ptr<StatusChangeCb> statusChangeCb = std::make_shared<StatusChangeCb>();
369 hpaeManager_->RegisterStatusCallback(HPAE_STREAM_CLASS_TYPE_PLAY, streamInfo.sessionId, statusChangeCb);
370 WaitForMsgProcessing(hpaeManager_);
371 HpaeSessionInfo sessionInfo;
372 EXPECT_EQ(hpaeManager_->GetSessionInfo(streamInfo.streamClassType, streamInfo.sessionId, sessionInfo), SUCCESS);
373 EXPECT_EQ(sessionInfo.streamInfo.sessionId, streamInfo.sessionId);
374 EXPECT_EQ(sessionInfo.streamInfo.streamType, streamInfo.streamType);
375 EXPECT_EQ(sessionInfo.streamInfo.frameLen, streamInfo.frameLen);
376 EXPECT_EQ(sessionInfo.streamInfo.format, streamInfo.format);
377 EXPECT_EQ(sessionInfo.streamInfo.samplingRate, streamInfo.samplingRate);
378 EXPECT_EQ(sessionInfo.streamInfo.channels, streamInfo.channels);
379 EXPECT_EQ(sessionInfo.streamInfo.streamClassType, streamInfo.streamClassType);
380 EXPECT_EQ(sessionInfo.state, HPAE_SESSION_NEW);
381
382 int32_t syncId = 123;
383 hpaeManager_->StartWithSyncId(streamInfo.streamClassType, streamInfo.sessionId, syncId);
384 WaitForMsgProcessing(hpaeManager_);
385 hpaeManager_->GetSessionInfo(streamInfo.streamClassType, streamInfo.sessionId, sessionInfo);
386 EXPECT_EQ(sessionInfo.state, HPAE_SESSION_RUNNING);
387 EXPECT_EQ(statusChangeCb->GetStatus(), I_STATUS_STARTED);
388
389 hpaeManager_->Pause(streamInfo.streamClassType, streamInfo.sessionId);
390 WaitForMsgProcessing(hpaeManager_);
391 EXPECT_EQ(hpaeManager_->GetSessionInfo(streamInfo.streamClassType, streamInfo.sessionId, sessionInfo), SUCCESS);
392 EXPECT_EQ(sessionInfo.state, HPAE_SESSION_PAUSING);
393 EXPECT_EQ(statusChangeCb->GetStatus(), I_STATUS_PAUSED);
394
395 hpaeManager_->Stop(streamInfo.streamClassType, streamInfo.sessionId);
396 WaitForMsgProcessing(hpaeManager_);
397 EXPECT_EQ(hpaeManager_->GetSessionInfo(streamInfo.streamClassType, streamInfo.sessionId, sessionInfo), SUCCESS);
398 EXPECT_EQ(sessionInfo.state, HPAE_SESSION_STOPPING);
399 EXPECT_EQ(statusChangeCb->GetStatus(), I_STATUS_STOPPED);
400
401 hpaeManager_->Release(streamInfo.streamClassType, streamInfo.sessionId);
402 WaitForMsgProcessing(hpaeManager_);
403 EXPECT_EQ(hpaeManager_->GetSessionInfo(streamInfo.streamClassType, streamInfo.sessionId, sessionInfo), ERROR);
404 }
405
406 HWTEST_F(HpaeManagerUnitTest, IHpaeRenderStreamManagerTest004, TestSize.Level1)
407 {
408 EXPECT_NE(hpaeManager_, nullptr);
409 hpaeManager_->Init();
410 EXPECT_EQ(hpaeManager_->IsInit(), true);
411 AudioModuleInfo audioModuleInfo = GetSinkAudioModeInfo();
412 EXPECT_EQ(hpaeManager_->OpenAudioPort(audioModuleInfo), SUCCESS);
413 hpaeManager_->SetDefaultSink(audioModuleInfo.name);
414 WaitForMsgProcessing(hpaeManager_);
415 HpaeStreamInfo streamInfo = GetRenderStreamInfo();
416 hpaeManager_->CreateStream(streamInfo);
417 WaitForMsgProcessing(hpaeManager_);
418 int32_t fixedNum = 100;
419 std::shared_ptr<WriteFixedValueCb> writeFixedValueCb = std::make_shared<WriteFixedValueCb>(SAMPLE_S16LE, fixedNum);
420 hpaeManager_->RegisterWriteCallback(streamInfo.sessionId, writeFixedValueCb);
421 WaitForMsgProcessing(hpaeManager_);
422 HpaeSessionInfo sessionInfo;
423 EXPECT_EQ(hpaeManager_->GetSessionInfo(streamInfo.streamClassType, streamInfo.sessionId, sessionInfo), SUCCESS);
424 EXPECT_EQ(sessionInfo.streamInfo.sessionId, streamInfo.sessionId);
425 EXPECT_EQ(sessionInfo.streamInfo.streamType, streamInfo.streamType);
426 EXPECT_EQ(sessionInfo.streamInfo.frameLen, streamInfo.frameLen);
427 EXPECT_EQ(sessionInfo.streamInfo.format, streamInfo.format);
428 EXPECT_EQ(sessionInfo.streamInfo.samplingRate, streamInfo.samplingRate);
429 EXPECT_EQ(sessionInfo.streamInfo.channels, streamInfo.channels);
430 EXPECT_EQ(sessionInfo.streamInfo.streamClassType, streamInfo.streamClassType);
431 EXPECT_EQ(sessionInfo.state, HPAE_SESSION_NEW);
432
433 hpaeManager_->Start(streamInfo.streamClassType, streamInfo.sessionId);
434 WaitForMsgProcessing(hpaeManager_);
435 hpaeManager_->GetSessionInfo(streamInfo.streamClassType, streamInfo.sessionId, sessionInfo);
436 EXPECT_EQ(sessionInfo.state, HPAE_SESSION_RUNNING);
437
438 int32_t syncId = 123;
439 hpaeManager_->StartWithSyncId(streamInfo.streamClassType, streamInfo.sessionId, syncId);
440 WaitForMsgProcessing(hpaeManager_);
441 hpaeManager_->GetSessionInfo(streamInfo.streamClassType, streamInfo.sessionId, sessionInfo);
442 EXPECT_EQ(sessionInfo.state, HPAE_SESSION_RUNNING);
443
444 hpaeManager_->Pause(streamInfo.streamClassType, streamInfo.sessionId);
445 WaitForMsgProcessing(hpaeManager_);
446 EXPECT_EQ(hpaeManager_->GetSessionInfo(streamInfo.streamClassType, streamInfo.sessionId, sessionInfo), SUCCESS);
447 EXPECT_EQ(sessionInfo.state, HPAE_SESSION_PAUSING);
448
449 hpaeManager_->Stop(streamInfo.streamClassType, streamInfo.sessionId);
450 WaitForMsgProcessing(hpaeManager_);
451 EXPECT_EQ(hpaeManager_->GetSessionInfo(streamInfo.streamClassType, streamInfo.sessionId, sessionInfo), SUCCESS);
452 EXPECT_EQ(sessionInfo.state, HPAE_SESSION_STOPPING);
453
454 hpaeManager_->Release(streamInfo.streamClassType, streamInfo.sessionId);
455 WaitForMsgProcessing(hpaeManager_);
456 EXPECT_EQ(hpaeManager_->GetSessionInfo(streamInfo.streamClassType, streamInfo.sessionId, sessionInfo), ERROR);
457 }
458
459 HWTEST_F(HpaeManagerUnitTest, IHpaeRenderStreamManagerMoveTest001, TestSize.Level1)
460 {
461 EXPECT_NE(hpaeManager_, nullptr);
462 hpaeManager_->Init();
463 EXPECT_EQ(hpaeManager_->IsInit(), true);
464 sleep(1);
465 AudioModuleInfo audioModuleInfo = GetSinkAudioModeInfo();
466 EXPECT_EQ(hpaeManager_->OpenAudioPort(audioModuleInfo), SUCCESS);
467 hpaeManager_->SetDefaultSink(audioModuleInfo.name);
468 AudioModuleInfo audioModuleInfo1 = GetSinkAudioModeInfo("Speaker_File1");
469 EXPECT_EQ(hpaeManager_->OpenAudioPort(audioModuleInfo1), SUCCESS);
470 WaitForMsgProcessing(hpaeManager_);
471 HpaeStreamInfo streamInfo = GetRenderStreamInfo();
472 hpaeManager_->CreateStream(streamInfo);
473 WaitForMsgProcessing(hpaeManager_);
474 int32_t fixedNum = 100;
475 std::shared_ptr<WriteFixedValueCb> writeFixedValueCb = std::make_shared<WriteFixedValueCb>(SAMPLE_S16LE, fixedNum);
476 hpaeManager_->RegisterWriteCallback(streamInfo.sessionId, writeFixedValueCb);
477 std::shared_ptr<StatusChangeCb> statusChangeCb = std::make_shared<StatusChangeCb>();
478 hpaeManager_->RegisterStatusCallback(HPAE_STREAM_CLASS_TYPE_PLAY, streamInfo.sessionId, statusChangeCb);
479 WaitForMsgProcessing(hpaeManager_);
480 HpaeSessionInfo sessionInfo;
481 EXPECT_EQ(hpaeManager_->GetSessionInfo(streamInfo.streamClassType, streamInfo.sessionId, sessionInfo), SUCCESS);
482 EXPECT_EQ(sessionInfo.streamInfo.sessionId, streamInfo.sessionId);
483 EXPECT_EQ(sessionInfo.streamInfo.streamType, streamInfo.streamType);
484 EXPECT_EQ(sessionInfo.streamInfo.frameLen, streamInfo.frameLen);
485 EXPECT_EQ(sessionInfo.streamInfo.format, streamInfo.format);
486 EXPECT_EQ(sessionInfo.streamInfo.samplingRate, streamInfo.samplingRate);
487 EXPECT_EQ(sessionInfo.streamInfo.channels, streamInfo.channels);
488 EXPECT_EQ(sessionInfo.streamInfo.streamClassType, streamInfo.streamClassType);
489 EXPECT_EQ(sessionInfo.state, HPAE_SESSION_NEW);
490
491 hpaeManager_->MoveSinkInputByIndexOrName(streamInfo.sessionId, 1, "Speaker_File1");
492 hpaeManager_->Start(streamInfo.streamClassType, streamInfo.sessionId);
493 WaitForMsgProcessing(hpaeManager_);
494 hpaeManager_->GetSessionInfo(streamInfo.streamClassType, streamInfo.sessionId, sessionInfo);
495 EXPECT_EQ(sessionInfo.state, HPAE_SESSION_RUNNING);
496 EXPECT_EQ(statusChangeCb->GetStatus(), I_STATUS_STARTED);
497
498 hpaeManager_->MoveSinkInputByIndexOrName(streamInfo.sessionId, 0, "Speaker_File");
499 hpaeManager_->Pause(streamInfo.streamClassType, streamInfo.sessionId);
500 WaitForMsgProcessing(hpaeManager_);
501 EXPECT_EQ(hpaeManager_->GetSessionInfo(streamInfo.streamClassType, streamInfo.sessionId, sessionInfo), SUCCESS);
502 EXPECT_EQ(sessionInfo.state, HPAE_SESSION_PAUSING);
503 EXPECT_EQ(statusChangeCb->GetStatus(), I_STATUS_PAUSED);
504
505 hpaeManager_->MoveSinkInputByIndexOrName(streamInfo.sessionId, 1, "Speaker_File1");
506 hpaeManager_->Stop(streamInfo.streamClassType, streamInfo.sessionId);
507 WaitForMsgProcessing(hpaeManager_);
508 EXPECT_EQ(hpaeManager_->GetSessionInfo(streamInfo.streamClassType, streamInfo.sessionId, sessionInfo), SUCCESS);
509 EXPECT_EQ(sessionInfo.state, HPAE_SESSION_STOPPING);
510 EXPECT_EQ(statusChangeCb->GetStatus(), I_STATUS_STOPPED);
511
512 hpaeManager_->MoveSinkInputByIndexOrName(streamInfo.sessionId, 0, "Speaker_File");
513 hpaeManager_->Release(streamInfo.streamClassType, streamInfo.sessionId);
514 WaitForMsgProcessing(hpaeManager_);
515 EXPECT_EQ(hpaeManager_->GetSessionInfo(streamInfo.streamClassType, streamInfo.sessionId, sessionInfo), ERROR);
516 }
517
518 HWTEST_F(HpaeManagerUnitTest, IHpaeRenderStreamManagerMoveTest002, TestSize.Level1)
519 {
520 EXPECT_NE(hpaeManager_, nullptr);
521 hpaeManager_->Init();
522 EXPECT_EQ(hpaeManager_->IsInit(), true);
523 sleep(1);
524 AudioModuleInfo audioModuleInfo = GetSinkAudioModeInfo();
525 EXPECT_EQ(hpaeManager_->OpenAudioPort(audioModuleInfo), SUCCESS);
526 hpaeManager_->SetDefaultSink(audioModuleInfo.name);
527 AudioModuleInfo audioModuleInfo1 = GetSinkAudioModeInfo("Speaker_File1");
528 EXPECT_EQ(hpaeManager_->OpenAudioPort(audioModuleInfo1), SUCCESS);
529 WaitForMsgProcessing(hpaeManager_);
530 HpaeStreamInfo streamInfo = GetRenderStreamInfo();
531 hpaeManager_->CreateStream(streamInfo);
532 WaitForMsgProcessing(hpaeManager_);
533 int32_t fixedNum = 100;
534 std::shared_ptr<WriteFixedValueCb> writeFixedValueCb = std::make_shared<WriteFixedValueCb>(SAMPLE_S16LE, fixedNum);
535 hpaeManager_->RegisterWriteCallback(streamInfo.sessionId, writeFixedValueCb);
536 std::shared_ptr<StatusChangeCb> statusChangeCb = std::make_shared<StatusChangeCb>();
537 hpaeManager_->RegisterStatusCallback(HPAE_STREAM_CLASS_TYPE_PLAY, streamInfo.sessionId, statusChangeCb);
538 WaitForMsgProcessing(hpaeManager_);
539 HpaeSessionInfo sessionInfo;
540 EXPECT_EQ(hpaeManager_->GetSessionInfo(streamInfo.streamClassType, streamInfo.sessionId, sessionInfo), SUCCESS);
541 EXPECT_EQ(sessionInfo.streamInfo.sessionId, streamInfo.sessionId);
542 EXPECT_EQ(sessionInfo.streamInfo.streamType, streamInfo.streamType);
543 EXPECT_EQ(sessionInfo.streamInfo.frameLen, streamInfo.frameLen);
544 EXPECT_EQ(sessionInfo.streamInfo.format, streamInfo.format);
545 EXPECT_EQ(sessionInfo.streamInfo.samplingRate, streamInfo.samplingRate);
546 EXPECT_EQ(sessionInfo.streamInfo.channels, streamInfo.channels);
547 EXPECT_EQ(sessionInfo.streamInfo.streamClassType, streamInfo.streamClassType);
548 EXPECT_EQ(sessionInfo.state, HPAE_SESSION_NEW);
549
550 hpaeManager_->MoveSinkInputByIndexOrName(streamInfo.sessionId, 1, "Speaker_File1");
551 hpaeManager_->Start(streamInfo.streamClassType, streamInfo.sessionId);
552 WaitForMsgProcessing(hpaeManager_);
553 hpaeManager_->GetSessionInfo(streamInfo.streamClassType, streamInfo.sessionId, sessionInfo);
554 EXPECT_EQ(sessionInfo.state, HPAE_SESSION_RUNNING);
555 EXPECT_EQ(statusChangeCb->GetStatus(), I_STATUS_STARTED);
556
557 hpaeManager_->MoveSinkInputByIndexOrName(streamInfo.sessionId, 0, "Speaker_File");
558 hpaeManager_->Pause(streamInfo.streamClassType, streamInfo.sessionId);
559 hpaeManager_->Start(streamInfo.streamClassType, streamInfo.sessionId);
560 WaitForMsgProcessing(hpaeManager_);
561 EXPECT_EQ(hpaeManager_->GetSessionInfo(streamInfo.streamClassType, streamInfo.sessionId, sessionInfo), SUCCESS);
562 EXPECT_EQ(sessionInfo.state, HPAE_SESSION_RUNNING);
563 EXPECT_EQ(statusChangeCb->GetStatus(), I_STATUS_STARTED);
564
565 hpaeManager_->MoveSinkInputByIndexOrName(streamInfo.sessionId, 1, "Speaker_File1");
566 hpaeManager_->Stop(streamInfo.streamClassType, streamInfo.sessionId);
567 hpaeManager_->Start(streamInfo.streamClassType, streamInfo.sessionId);
568 WaitForMsgProcessing(hpaeManager_);
569 EXPECT_EQ(hpaeManager_->GetSessionInfo(streamInfo.streamClassType, streamInfo.sessionId, sessionInfo), SUCCESS);
570 EXPECT_EQ(sessionInfo.state, HPAE_SESSION_RUNNING);
571 EXPECT_EQ(statusChangeCb->GetStatus(), I_STATUS_STARTED);
572
573 hpaeManager_->MoveSinkInputByIndexOrName(streamInfo.sessionId, 0, "Speaker_File");
574 hpaeManager_->Stop(streamInfo.streamClassType, streamInfo.sessionId);
575 hpaeManager_->Release(streamInfo.streamClassType, streamInfo.sessionId);
576 WaitForMsgProcessing(hpaeManager_);
577 EXPECT_EQ(hpaeManager_->GetSessionInfo(streamInfo.streamClassType, streamInfo.sessionId, sessionInfo), ERROR);
578 }
579
580 HWTEST_F(HpaeManagerUnitTest, IHpaeRenderStreamManagerMoveTest003, TestSize.Level1)
581 {
582 EXPECT_NE(hpaeManager_, nullptr);
583 hpaeManager_->Init();
584 EXPECT_EQ(hpaeManager_->IsInit(), true);
585 sleep(1);
586 AudioModuleInfo audioModuleInfo = GetSinkAudioModeInfo();
587 EXPECT_EQ(hpaeManager_->OpenAudioPort(audioModuleInfo), SUCCESS);
588 hpaeManager_->SetDefaultSink(audioModuleInfo.name);
589 AudioModuleInfo audioModuleInfo1 = GetSinkAudioModeInfo("Speaker_File1");
590 EXPECT_EQ(hpaeManager_->OpenAudioPort(audioModuleInfo1), SUCCESS);
591 WaitForMsgProcessing(hpaeManager_);
592 HpaeStreamInfo streamInfo = GetRenderStreamInfo();
593 hpaeManager_->CreateStream(streamInfo);
594 WaitForMsgProcessing(hpaeManager_);
595 int32_t fixedNum = 100;
596 int32_t syncId = 123;
597 std::shared_ptr<WriteFixedValueCb> writeFixedValueCb = std::make_shared<WriteFixedValueCb>(SAMPLE_S16LE, fixedNum);
598 hpaeManager_->RegisterWriteCallback(streamInfo.sessionId, writeFixedValueCb);
599 std::shared_ptr<StatusChangeCb> statusChangeCb = std::make_shared<StatusChangeCb>();
600 hpaeManager_->RegisterStatusCallback(HPAE_STREAM_CLASS_TYPE_PLAY, streamInfo.sessionId, statusChangeCb);
601 WaitForMsgProcessing(hpaeManager_);
602 HpaeSessionInfo sessionInfo;
603 EXPECT_EQ(hpaeManager_->GetSessionInfo(streamInfo.streamClassType, streamInfo.sessionId, sessionInfo), SUCCESS);
604 EXPECT_EQ(sessionInfo.streamInfo.sessionId, streamInfo.sessionId);
605 EXPECT_EQ(sessionInfo.streamInfo.streamType, streamInfo.streamType);
606 EXPECT_EQ(sessionInfo.streamInfo.frameLen, streamInfo.frameLen);
607 EXPECT_EQ(sessionInfo.streamInfo.format, streamInfo.format);
608 EXPECT_EQ(sessionInfo.streamInfo.samplingRate, streamInfo.samplingRate);
609 EXPECT_EQ(sessionInfo.streamInfo.channels, streamInfo.channels);
610 EXPECT_EQ(sessionInfo.streamInfo.streamClassType, streamInfo.streamClassType);
611 EXPECT_EQ(sessionInfo.state, HPAE_SESSION_NEW);
612
613 hpaeManager_->MoveSinkInputByIndexOrName(streamInfo.sessionId, 1, "Speaker_File1");
614 hpaeManager_->StartWithSyncId(streamInfo.streamClassType, streamInfo.sessionId, syncId);
615 WaitForMsgProcessing(hpaeManager_);
616 hpaeManager_->GetSessionInfo(streamInfo.streamClassType, streamInfo.sessionId, sessionInfo);
617 EXPECT_EQ(sessionInfo.state, HPAE_SESSION_RUNNING);
618 EXPECT_EQ(statusChangeCb->GetStatus(), I_STATUS_STARTED);
619
620 hpaeManager_->MoveSinkInputByIndexOrName(streamInfo.sessionId, 0, "Speaker_File");
621 hpaeManager_->Pause(streamInfo.streamClassType, streamInfo.sessionId);
622 hpaeManager_->StartWithSyncId(streamInfo.streamClassType, streamInfo.sessionId, syncId);
623 WaitForMsgProcessing(hpaeManager_);
624 EXPECT_EQ(hpaeManager_->GetSessionInfo(streamInfo.streamClassType, streamInfo.sessionId, sessionInfo), SUCCESS);
625 EXPECT_EQ(sessionInfo.state, HPAE_SESSION_RUNNING);
626 EXPECT_EQ(statusChangeCb->GetStatus(), I_STATUS_STARTED);
627
628 hpaeManager_->MoveSinkInputByIndexOrName(streamInfo.sessionId, 1, "Speaker_File1");
629 hpaeManager_->Stop(streamInfo.streamClassType, streamInfo.sessionId);
630 hpaeManager_->StartWithSyncId(streamInfo.streamClassType, streamInfo.sessionId, syncId);
631 WaitForMsgProcessing(hpaeManager_);
632 EXPECT_EQ(hpaeManager_->GetSessionInfo(streamInfo.streamClassType, streamInfo.sessionId, sessionInfo), SUCCESS);
633 EXPECT_EQ(sessionInfo.state, HPAE_SESSION_RUNNING);
634 EXPECT_EQ(statusChangeCb->GetStatus(), I_STATUS_STARTED);
635
636 hpaeManager_->MoveSinkInputByIndexOrName(streamInfo.sessionId, 0, "Speaker_File");
637 hpaeManager_->Stop(streamInfo.streamClassType, streamInfo.sessionId);
638 hpaeManager_->Release(streamInfo.streamClassType, streamInfo.sessionId);
639 WaitForMsgProcessing(hpaeManager_);
640 EXPECT_EQ(hpaeManager_->GetSessionInfo(streamInfo.streamClassType, streamInfo.sessionId, sessionInfo), ERROR);
641 }
642
643 HWTEST_F(HpaeManagerUnitTest, IHpaeCaptureStreamManagerTest002, TestSize.Level1)
644 {
645 EXPECT_NE(hpaeManager_, nullptr);
646 hpaeManager_->Init();
647 EXPECT_EQ(hpaeManager_->IsInit(), true);
648 sleep(1);
649 AudioModuleInfo audioModuleInfo = GetSourceAudioModeInfo();
650 EXPECT_EQ(hpaeManager_->OpenAudioPort(audioModuleInfo), SUCCESS);
651 WaitForMsgProcessing(hpaeManager_);
652 hpaeManager_->SetDefaultSource(audioModuleInfo.name);
653 HpaeStreamInfo streamInfo = GetCaptureStreamInfo();
654 hpaeManager_->CreateStream(streamInfo);
655 WaitForMsgProcessing(hpaeManager_);
656 int32_t fixedNum = 100;
657 std::shared_ptr<HpaeAudioServiceCallbackUnitTest> callback = std::make_shared<HpaeAudioServiceCallbackUnitTest>();
658 int32_t result = hpaeManager_->RegisterSerivceCallback(callback);
659 EXPECT_EQ(result, SUCCESS);
660 std::shared_ptr<WriteFixedValueCb> writeFixedValueCb = std::make_shared<WriteFixedValueCb>(SAMPLE_S16LE, fixedNum);
661 hpaeManager_->RegisterWriteCallback(streamInfo.sessionId, writeFixedValueCb);
662 std::shared_ptr<StatusChangeCb> statusChangeCb = std::make_shared<StatusChangeCb>();
663 hpaeManager_->RegisterStatusCallback(HPAE_STREAM_CLASS_TYPE_RECORD, streamInfo.sessionId, statusChangeCb);
664 WaitForMsgProcessing(hpaeManager_);
665 HpaeSessionInfo sessionInfo;
666 EXPECT_EQ(hpaeManager_->GetSessionInfo(streamInfo.streamClassType, streamInfo.sessionId, sessionInfo), SUCCESS);
667 EXPECT_EQ(sessionInfo.streamInfo.sessionId, streamInfo.sessionId);
668 EXPECT_EQ(sessionInfo.streamInfo.streamType, streamInfo.streamType);
669 EXPECT_EQ(sessionInfo.streamInfo.frameLen, streamInfo.frameLen);
670 EXPECT_EQ(sessionInfo.streamInfo.streamClassType, streamInfo.streamClassType);
671 EXPECT_EQ(sessionInfo.state, HPAE_SESSION_NEW);
672 hpaeManager_->Start(streamInfo.streamClassType, streamInfo.sessionId);
673 WaitForMsgProcessing(hpaeManager_);
674 hpaeManager_->GetSessionInfo(streamInfo.streamClassType, streamInfo.sessionId, sessionInfo);
675 EXPECT_EQ(sessionInfo.state, HPAE_SESSION_RUNNING);
676 EXPECT_EQ(statusChangeCb->GetStatus(), I_STATUS_STARTED);
677
678 EXPECT_EQ(hpaeManager_->SetSourceOutputMute(TEST_STREAM_UID, true), SUCCESS);
679 WaitForMsgProcessing(hpaeManager_);
680 EXPECT_EQ(callback->GetSetSourceOutputMuteResult(), SUCCESS);
681 EXPECT_EQ(hpaeManager_->SetSourceOutputMute(TEST_STREAM_UID, true), SUCCESS);
682 WaitForMsgProcessing(hpaeManager_);
683 EXPECT_EQ(hpaeManager_->SetSourceOutputMute(TEST_STREAM_UID, false), SUCCESS);
684 WaitForMsgProcessing(hpaeManager_);
685 EXPECT_EQ(callback->GetSetSourceOutputMuteResult(), SUCCESS);
686
687 hpaeManager_->Pause(streamInfo.streamClassType, streamInfo.sessionId);
688 WaitForMsgProcessing(hpaeManager_);
689 EXPECT_EQ(hpaeManager_->GetSessionInfo(streamInfo.streamClassType, streamInfo.sessionId, sessionInfo), SUCCESS);
690 EXPECT_EQ(sessionInfo.state, HPAE_SESSION_PAUSING);
691 EXPECT_EQ(statusChangeCb->GetStatus(), I_STATUS_PAUSED);
692 hpaeManager_->Stop(streamInfo.streamClassType, streamInfo.sessionId);
693 WaitForMsgProcessing(hpaeManager_);
694 EXPECT_EQ(hpaeManager_->GetSessionInfo(streamInfo.streamClassType, streamInfo.sessionId, sessionInfo), SUCCESS);
695 EXPECT_EQ(sessionInfo.state, HPAE_SESSION_STOPPING);
696 EXPECT_EQ(statusChangeCb->GetStatus(), I_STATUS_STOPPED);
697 hpaeManager_->Release(streamInfo.streamClassType, streamInfo.sessionId);
698 WaitForMsgProcessing(hpaeManager_);
699 EXPECT_EQ(hpaeManager_->GetSessionInfo(streamInfo.streamClassType, streamInfo.sessionId, sessionInfo), ERROR);
700 }
701
702 HWTEST_F(HpaeManagerUnitTest, IHpaeCaptureStreamManagerTest003, TestSize.Level1)
703 {
704 EXPECT_NE(hpaeManager_, nullptr);
705 hpaeManager_->Init();
706 EXPECT_EQ(hpaeManager_->IsInit(), true);
707 sleep(1);
708 std::shared_ptr<HpaeAudioServiceCallbackUnitTest> callback = std::make_shared<HpaeAudioServiceCallbackUnitTest>();
709 int32_t result = hpaeManager_->RegisterSerivceCallback(callback);
710 EXPECT_EQ(result, SUCCESS);
711
712 AudioModuleInfo audioModuleInfo = GetSourceAudioModeInfo();
713 audioModuleInfo.sourceType = "17";
714 hpaeManager_->effectLiveState_ = "Nosupport";
715 EXPECT_EQ(hpaeManager_->OpenAudioPort(audioModuleInfo), SUCCESS);
716 WaitForMsgProcessing(hpaeManager_);
717 }
718
719 HWTEST_F(HpaeManagerUnitTest, IHpaeCaptureStreamManagerTest004, TestSize.Level1)
720 {
721 EXPECT_NE(hpaeManager_, nullptr);
722 hpaeManager_->Init();
723 EXPECT_EQ(hpaeManager_->IsInit(), true);
724 sleep(1);
725 std::shared_ptr<HpaeAudioServiceCallbackUnitTest> callback = std::make_shared<HpaeAudioServiceCallbackUnitTest>();
726 int32_t result = hpaeManager_->RegisterSerivceCallback(callback);
727 EXPECT_EQ(result, SUCCESS);
728
729 AudioModuleInfo audioModuleInfo = GetSourceAudioModeInfo();
730 audioModuleInfo.sourceType = "17";
731 hpaeManager_->effectLiveState_ = "NRON";
732 EXPECT_EQ(hpaeManager_->OpenAudioPort(audioModuleInfo), SUCCESS);
733 WaitForMsgProcessing(hpaeManager_);
734 }
735
736 HWTEST_F(HpaeManagerUnitTest, IHpaeCaptureStreamManagerTest005, TestSize.Level1)
737 {
738 EXPECT_NE(hpaeManager_, nullptr);
739 hpaeManager_->Init();
740 EXPECT_EQ(hpaeManager_->IsInit(), true);
741 sleep(1);
742 std::shared_ptr<HpaeAudioServiceCallbackUnitTest> callback = std::make_shared<HpaeAudioServiceCallbackUnitTest>();
743 int32_t result = hpaeManager_->RegisterSerivceCallback(callback);
744 EXPECT_EQ(result, SUCCESS);
745
746 AudioModuleInfo audioModuleInfo = GetSourceAudioModeInfo();
747 audioModuleInfo.sourceType = "17";
748 hpaeManager_->effectLiveState_ = "NROFF";
749 EXPECT_EQ(hpaeManager_->OpenAudioPort(audioModuleInfo), SUCCESS);
750 WaitForMsgProcessing(hpaeManager_);
751 }
752
753 HWTEST_F(HpaeManagerUnitTest, IHpaeCaptureStreamManagerMoveTest001, TestSize.Level1)
754 {
755 EXPECT_NE(hpaeManager_, nullptr);
756 hpaeManager_->Init();
757 EXPECT_EQ(hpaeManager_->IsInit(), true);
758 sleep(1);
759 AudioModuleInfo audioModuleInfo = GetSourceAudioModeInfo();
760 EXPECT_EQ(hpaeManager_->OpenAudioPort(audioModuleInfo), SUCCESS);
761 AudioModuleInfo audioModuleInfo1 = GetSourceAudioModeInfo("mic1");
762 EXPECT_EQ(hpaeManager_->OpenAudioPort(audioModuleInfo1), SUCCESS);
763 WaitForMsgProcessing(hpaeManager_);
764 hpaeManager_->SetDefaultSource(audioModuleInfo.name);
765 HpaeStreamInfo streamInfo = GetCaptureStreamInfo();
766 hpaeManager_->CreateStream(streamInfo);
767 WaitForMsgProcessing(hpaeManager_);
768 int32_t fixedNum = 100;
769 std::shared_ptr<WriteFixedValueCb> writeFixedValueCb = std::make_shared<WriteFixedValueCb>(SAMPLE_S16LE, fixedNum);
770 hpaeManager_->RegisterWriteCallback(streamInfo.sessionId, writeFixedValueCb);
771 std::shared_ptr<StatusChangeCb> statusChangeCb = std::make_shared<StatusChangeCb>();
772 hpaeManager_->RegisterStatusCallback(HPAE_STREAM_CLASS_TYPE_RECORD, streamInfo.sessionId, statusChangeCb);
773 WaitForMsgProcessing(hpaeManager_);
774 HpaeSessionInfo sessionInfo;
775 EXPECT_EQ(hpaeManager_->GetSessionInfo(streamInfo.streamClassType, streamInfo.sessionId, sessionInfo), SUCCESS);
776 EXPECT_EQ(sessionInfo.streamInfo.sessionId, streamInfo.sessionId);
777 EXPECT_EQ(sessionInfo.streamInfo.streamType, streamInfo.streamType);
778 EXPECT_EQ(sessionInfo.streamInfo.frameLen, streamInfo.frameLen);
779 EXPECT_EQ(sessionInfo.streamInfo.streamClassType, streamInfo.streamClassType);
780 EXPECT_EQ(sessionInfo.state, HPAE_SESSION_NEW);
781
782 hpaeManager_->MoveSourceOutputByIndexOrName(streamInfo.sessionId, 1, "mic1");
783 hpaeManager_->Start(streamInfo.streamClassType, streamInfo.sessionId);
784 WaitForMsgProcessing(hpaeManager_);
785 hpaeManager_->GetSessionInfo(streamInfo.streamClassType, streamInfo.sessionId, sessionInfo);
786 EXPECT_EQ(sessionInfo.state, HPAE_SESSION_RUNNING);
787 EXPECT_EQ(statusChangeCb->GetStatus(), I_STATUS_STARTED);
788
789 hpaeManager_->MoveSourceOutputByIndexOrName(streamInfo.sessionId, 0, "mic");
790 hpaeManager_->Pause(streamInfo.streamClassType, streamInfo.sessionId);
791 WaitForMsgProcessing(hpaeManager_);
792 EXPECT_EQ(hpaeManager_->GetSessionInfo(streamInfo.streamClassType, streamInfo.sessionId, sessionInfo), SUCCESS);
793 EXPECT_EQ(sessionInfo.state, HPAE_SESSION_PAUSING);
794 EXPECT_EQ(statusChangeCb->GetStatus(), I_STATUS_PAUSED);
795
796 hpaeManager_->MoveSourceOutputByIndexOrName(streamInfo.sessionId, 1, "mic1");
797 hpaeManager_->Stop(streamInfo.streamClassType, streamInfo.sessionId);
798 WaitForMsgProcessing(hpaeManager_);
799 EXPECT_EQ(hpaeManager_->GetSessionInfo(streamInfo.streamClassType, streamInfo.sessionId, sessionInfo), SUCCESS);
800 EXPECT_EQ(sessionInfo.state, HPAE_SESSION_STOPPING);
801 EXPECT_EQ(statusChangeCb->GetStatus(), I_STATUS_STOPPED);
802
803 hpaeManager_->MoveSourceOutputByIndexOrName(streamInfo.sessionId, 0, "mic");
804 hpaeManager_->Release(streamInfo.streamClassType, streamInfo.sessionId);
805 WaitForMsgProcessing(hpaeManager_);
806 EXPECT_EQ(hpaeManager_->GetSessionInfo(streamInfo.streamClassType, streamInfo.sessionId, sessionInfo), ERROR);
807 }
808
809 HWTEST_F(HpaeManagerUnitTest, IHpaeCaptureStreamManagerMoveTest002, TestSize.Level1)
810 {
811 EXPECT_NE(hpaeManager_, nullptr);
812 hpaeManager_->Init();
813 EXPECT_EQ(hpaeManager_->IsInit(), true);
814 sleep(1);
815 AudioModuleInfo audioModuleInfo = GetSourceAudioModeInfo();
816 EXPECT_EQ(hpaeManager_->OpenAudioPort(audioModuleInfo), SUCCESS);
817 AudioModuleInfo audioModuleInfo1 = GetSourceAudioModeInfo("mic1");
818 EXPECT_EQ(hpaeManager_->OpenAudioPort(audioModuleInfo1), SUCCESS);
819 WaitForMsgProcessing(hpaeManager_);
820 hpaeManager_->SetDefaultSource(audioModuleInfo.name);
821 HpaeStreamInfo streamInfo = GetCaptureStreamInfo();
822 hpaeManager_->CreateStream(streamInfo);
823 WaitForMsgProcessing(hpaeManager_);
824 int32_t fixedNum = 100;
825 std::shared_ptr<WriteFixedValueCb> writeFixedValueCb = std::make_shared<WriteFixedValueCb>(SAMPLE_S16LE, fixedNum);
826 hpaeManager_->RegisterWriteCallback(streamInfo.sessionId, writeFixedValueCb);
827 std::shared_ptr<StatusChangeCb> statusChangeCb = std::make_shared<StatusChangeCb>();
828 hpaeManager_->RegisterStatusCallback(HPAE_STREAM_CLASS_TYPE_RECORD, streamInfo.sessionId, statusChangeCb);
829 WaitForMsgProcessing(hpaeManager_);
830 HpaeSessionInfo sessionInfo;
831 EXPECT_EQ(hpaeManager_->GetSessionInfo(streamInfo.streamClassType, streamInfo.sessionId, sessionInfo), SUCCESS);
832 EXPECT_EQ(sessionInfo.streamInfo.sessionId, streamInfo.sessionId);
833 EXPECT_EQ(sessionInfo.streamInfo.streamType, streamInfo.streamType);
834 EXPECT_EQ(sessionInfo.streamInfo.frameLen, streamInfo.frameLen);
835 EXPECT_EQ(sessionInfo.streamInfo.streamClassType, streamInfo.streamClassType);
836 EXPECT_EQ(sessionInfo.state, HPAE_SESSION_NEW);
837
838 hpaeManager_->MoveSourceOutputByIndexOrName(streamInfo.sessionId, 1, "mic1");
839 hpaeManager_->Start(streamInfo.streamClassType, streamInfo.sessionId);
840 WaitForMsgProcessing(hpaeManager_);
841 hpaeManager_->GetSessionInfo(streamInfo.streamClassType, streamInfo.sessionId, sessionInfo);
842 EXPECT_EQ(sessionInfo.state, HPAE_SESSION_RUNNING);
843 EXPECT_EQ(statusChangeCb->GetStatus(), I_STATUS_STARTED);
844
845 hpaeManager_->MoveSourceOutputByIndexOrName(streamInfo.sessionId, 0, "mic");
846 hpaeManager_->Pause(streamInfo.streamClassType, streamInfo.sessionId);
847 hpaeManager_->Start(streamInfo.streamClassType, streamInfo.sessionId);
848 WaitForMsgProcessing(hpaeManager_);
849 EXPECT_EQ(hpaeManager_->GetSessionInfo(streamInfo.streamClassType, streamInfo.sessionId, sessionInfo), SUCCESS);
850 EXPECT_EQ(sessionInfo.state, HPAE_SESSION_RUNNING);
851 EXPECT_EQ(statusChangeCb->GetStatus(), I_STATUS_STARTED);
852
853 hpaeManager_->MoveSourceOutputByIndexOrName(streamInfo.sessionId, 1, "mic1");
854 hpaeManager_->Stop(streamInfo.streamClassType, streamInfo.sessionId);
855 hpaeManager_->Start(streamInfo.streamClassType, streamInfo.sessionId);
856 WaitForMsgProcessing(hpaeManager_);
857 EXPECT_EQ(hpaeManager_->GetSessionInfo(streamInfo.streamClassType, streamInfo.sessionId, sessionInfo), SUCCESS);
858 EXPECT_EQ(sessionInfo.state, HPAE_SESSION_RUNNING);
859 EXPECT_EQ(statusChangeCb->GetStatus(), I_STATUS_STARTED);
860
861 hpaeManager_->MoveSourceOutputByIndexOrName(streamInfo.sessionId, 0, "mic");
862 hpaeManager_->Release(streamInfo.streamClassType, streamInfo.sessionId);
863 WaitForMsgProcessing(hpaeManager_);
864 EXPECT_EQ(hpaeManager_->GetSessionInfo(streamInfo.streamClassType, streamInfo.sessionId, sessionInfo), ERROR);
865 }
866
867 HWTEST_F(HpaeManagerUnitTest, IsAcousticEchoCancelerSupported001, TestSize.Level0)
868 {
869 EXPECT_NE(hpaeManager_, nullptr);
870 bool result = hpaeManager_->IsAcousticEchoCancelerSupported(SOURCE_TYPE_VOICE_COMMUNICATION);
871 EXPECT_EQ(result, true);
872 }
873
874 HWTEST_F(HpaeManagerUnitTest, IsAcousticEchoCancelerSupported002, TestSize.Level0)
875 {
876 EXPECT_NE(hpaeManager_, nullptr);
877 hpaeManager_->Init();
878 EXPECT_EQ(hpaeManager_->IsInit(), true);
879 sleep(1);
880 bool result = hpaeManager_->IsAcousticEchoCancelerSupported(SOURCE_TYPE_VOICE_COMMUNICATION);
881 EXPECT_EQ(result, true);
882 result = hpaeManager_->IsAcousticEchoCancelerSupported(SOURCE_TYPE_VOICE_TRANSCRIPTION);
883 EXPECT_EQ(result, true);
884 result = hpaeManager_->IsAcousticEchoCancelerSupported(SOURCE_TYPE_MIC);
885 EXPECT_EQ(result, false);
886 }
887
888 HWTEST_F(HpaeManagerUnitTest, SetEffectLiveParameter001, TestSize.Level0)
889 {
890 EXPECT_NE(hpaeManager_, nullptr);
891 std::vector<std::pair<std::string, std::string>> params;
892 bool result = hpaeManager_->SetEffectLiveParameter(params);
893 EXPECT_EQ(result, false);
894 }
895
896 HWTEST_F(HpaeManagerUnitTest, SetEffectLiveParameter002, TestSize.Level0)
897 {
898 EXPECT_NE(hpaeManager_, nullptr);
899 hpaeManager_->Init();
900 EXPECT_EQ(hpaeManager_->IsInit(), true);
901 sleep(1);
902 std::vector<std::pair<std::string, std::string>> params;
903 params.push_back({"invalidKey", "invalidValue"});
904 bool result = hpaeManager_->SetEffectLiveParameter(params);
905 EXPECT_EQ(result, false);
906 params.clear();
907 params.push_back({"live_effect_enable", "invalidValue"});
908 result = hpaeManager_->SetEffectLiveParameter(params);
909 EXPECT_EQ(result, false);
910 }
911
912 HWTEST_F(HpaeManagerUnitTest, SetEffectLiveParameter003, TestSize.Level0)
913 {
914 EXPECT_NE(hpaeManager_, nullptr);
915 hpaeManager_->Init();
916 EXPECT_EQ(hpaeManager_->IsInit(), true);
917 sleep(1);
918 std::vector<std::pair<std::string, std::string>> params;
919 params.push_back({"live_effect_enable", "NRON"});
920 hpaeManager_->effectLiveState_ = "NoSupport";
921 bool result = hpaeManager_->SetEffectLiveParameter(params);
922 EXPECT_EQ(result, false);
923 }
924
925 HWTEST_F(HpaeManagerUnitTest, GetEffectLiveParameter001, TestSize.Level0)
926 {
927 EXPECT_NE(hpaeManager_, nullptr);
928 std::vector<std::string> subKeys;
929 std::vector<std::pair<std::string, std::string>> result;
930 bool res = hpaeManager_->GetEffectLiveParameter(subKeys, result);
931 EXPECT_EQ(res, true);
932 }
933
934 HWTEST_F(HpaeManagerUnitTest, GetEffectLiveParameter002, TestSize.Level0)
935 {
936 EXPECT_NE(hpaeManager_, nullptr);
937 hpaeManager_->Init();
938 EXPECT_EQ(hpaeManager_->IsInit(), true);
939 sleep(1);
940 std::vector<std::string> subKeys;
941 std::vector<std::pair<std::string, std::string>> result;
942 subKeys.push_back("invalidKey");
943 bool res = hpaeManager_->GetEffectLiveParameter(subKeys, result);
944 EXPECT_EQ(res, false);
945 }
946
947 HWTEST_F(HpaeManagerUnitTest, GetEffectLiveParameter003, TestSize.Level0)
948 {
949 EXPECT_NE(hpaeManager_, nullptr);
950 hpaeManager_->Init();
951 EXPECT_EQ(hpaeManager_->IsInit(), true);
952 sleep(1);
953 std::vector<std::string> subKeys;
954 std::vector<std::pair<std::string, std::string>> result;
955 subKeys.push_back("live_effect_supported");
956 hpaeManager_->effectLiveState_ = "NoSupport";
957 bool res = hpaeManager_->GetEffectLiveParameter(subKeys, result);
958 EXPECT_EQ(res, true);
959 EXPECT_EQ(subKeys[0], result[0].first);
960 EXPECT_EQ("NoSupport", result[0].second);
961 }
962
963 HWTEST_F(HpaeManagerUnitTest, IHpaeRenderStreamManagerMoveTest004, TestSize.Level1)
964 {
965 EXPECT_NE(hpaeManager_, nullptr);
966 hpaeManager_->Init();
967 EXPECT_EQ(hpaeManager_->IsInit(), true);
968 sleep(1);
969 AudioModuleInfo audioModuleInfo = GetSinkAudioModeInfo();
970 EXPECT_EQ(hpaeManager_->OpenAudioPort(audioModuleInfo), SUCCESS);
971 hpaeManager_->SetDefaultSink(audioModuleInfo.name);
972 AudioModuleInfo audioModuleInfo1 = GetSinkAudioModeInfo("Speaker_File1");
973 EXPECT_EQ(hpaeManager_->OpenAudioPort(audioModuleInfo1), SUCCESS);
974 WaitForMsgProcessing(hpaeManager_);
975 HpaeStreamInfo streamInfo = GetRenderStreamInfo();
976 hpaeManager_->CreateStream(streamInfo);
977 WaitForMsgProcessing(hpaeManager_);
978 int32_t fixedNum = 100;
979 std::shared_ptr<WriteFixedValueCb> writeFixedValueCb = std::make_shared<WriteFixedValueCb>(SAMPLE_S16LE, fixedNum);
980 hpaeManager_->RegisterWriteCallback(streamInfo.sessionId, writeFixedValueCb);
981 std::shared_ptr<StatusChangeCb> statusChangeCb = std::make_shared<StatusChangeCb>();
982 hpaeManager_->RegisterStatusCallback(HPAE_STREAM_CLASS_TYPE_PLAY, streamInfo.sessionId, statusChangeCb);
983 WaitForMsgProcessing(hpaeManager_);
984 HpaeSessionInfo sessionInfo;
985 EXPECT_EQ(hpaeManager_->GetSessionInfo(streamInfo.streamClassType, streamInfo.sessionId, sessionInfo), SUCCESS);
986 EXPECT_EQ(sessionInfo.streamInfo.sessionId, streamInfo.sessionId);
987 EXPECT_EQ(sessionInfo.streamInfo.streamType, streamInfo.streamType);
988 EXPECT_EQ(sessionInfo.streamInfo.frameLen, streamInfo.frameLen);
989 EXPECT_EQ(sessionInfo.streamInfo.format, streamInfo.format);
990 EXPECT_EQ(sessionInfo.streamInfo.samplingRate, streamInfo.samplingRate);
991 EXPECT_EQ(sessionInfo.streamInfo.channels, streamInfo.channels);
992 EXPECT_EQ(sessionInfo.streamInfo.streamClassType, streamInfo.streamClassType);
993 EXPECT_EQ(sessionInfo.state, HPAE_SESSION_NEW);
994
995 EXPECT_EQ(hpaeManager_->MoveSinkInputByIndexOrName(streamInfo.sessionId, 1, ""), SUCCESS);
996 WaitForMsgProcessing(hpaeManager_);
997 EXPECT_EQ(hpaeManager_->MoveSinkInputByIndexOrName(streamInfo.sessionId, 1, "virtual1"), SUCCESS);
998 WaitForMsgProcessing(hpaeManager_);
999 EXPECT_EQ(hpaeManager_->MoveSinkInputByIndexOrName(SESSION_ID_NOEXIST, 1, "Speaker_File1"), SUCCESS);
1000 WaitForMsgProcessing(hpaeManager_);
1001 EXPECT_EQ(hpaeManager_->MoveSinkInputByIndexOrName(streamInfo.sessionId, 1, "Speaker_File"), SUCCESS);
1002 WaitForMsgProcessing(hpaeManager_);
1003 hpaeManager_->rendererIdStreamInfoMap_[streamInfo.sessionId].streamInfo.isMoveAble = false;
1004 EXPECT_EQ(hpaeManager_->MoveSinkInputByIndexOrName(streamInfo.sessionId, 1, "Speaker_File1"), SUCCESS);
1005 WaitForMsgProcessing(hpaeManager_);
1006
1007 hpaeManager_->rendererIdStreamInfoMap_[streamInfo.sessionId].streamInfo.isMoveAble = true;
1008 EXPECT_EQ(hpaeManager_->MoveSinkInputByIndexOrName(streamInfo.sessionId, 1, "Speaker_File1"), SUCCESS);
1009 WaitForMsgProcessing(hpaeManager_);
1010
1011 int32_t syncId = 123;
1012 hpaeManager_->rendererIdStreamInfoMap_[streamInfo.sessionId].state = HPAE_SESSION_RELEASED;
1013 EXPECT_EQ(hpaeManager_->Start(streamInfo.streamClassType, streamInfo.sessionId), SUCCESS);
1014 WaitForMsgProcessing(hpaeManager_);
1015 hpaeManager_->rendererIdStreamInfoMap_[streamInfo.sessionId].state = HPAE_SESSION_RELEASED;
1016 EXPECT_EQ(hpaeManager_->StartWithSyncId(streamInfo.streamClassType, streamInfo.sessionId, syncId), SUCCESS);
1017 WaitForMsgProcessing(hpaeManager_);
1018 EXPECT_EQ(hpaeManager_->Pause(streamInfo.streamClassType, streamInfo.sessionId), SUCCESS);
1019 WaitForMsgProcessing(hpaeManager_);
1020 EXPECT_EQ(hpaeManager_->Stop(streamInfo.streamClassType, streamInfo.sessionId), SUCCESS);
1021 WaitForMsgProcessing(hpaeManager_);
1022 EXPECT_EQ(hpaeManager_->Drain(streamInfo.streamClassType, streamInfo.sessionId), SUCCESS);
1023 WaitForMsgProcessing(hpaeManager_);
1024 EXPECT_EQ(hpaeManager_->Flush(streamInfo.streamClassType, streamInfo.sessionId), SUCCESS);
1025 WaitForMsgProcessing(hpaeManager_);
1026 EXPECT_EQ(hpaeManager_->Release(streamInfo.streamClassType, streamInfo.sessionId), SUCCESS);
1027 WaitForMsgProcessing(hpaeManager_);
1028
1029 EXPECT_EQ(hpaeManager_->Start(streamInfo.streamClassType, SESSION_ID_NOEXIST), SUCCESS);
1030 WaitForMsgProcessing(hpaeManager_);
1031 EXPECT_EQ(hpaeManager_->Pause(streamInfo.streamClassType, SESSION_ID_NOEXIST), SUCCESS);
1032 WaitForMsgProcessing(hpaeManager_);
1033 EXPECT_EQ(hpaeManager_->Stop(streamInfo.streamClassType, SESSION_ID_NOEXIST), SUCCESS);
1034 WaitForMsgProcessing(hpaeManager_);
1035 EXPECT_EQ(hpaeManager_->Drain(streamInfo.streamClassType, SESSION_ID_NOEXIST), SUCCESS);
1036 WaitForMsgProcessing(hpaeManager_);
1037 EXPECT_EQ(hpaeManager_->Flush(streamInfo.streamClassType, SESSION_ID_NOEXIST), SUCCESS);
1038 WaitForMsgProcessing(hpaeManager_);
1039 EXPECT_EQ(hpaeManager_->Release(streamInfo.streamClassType, SESSION_ID_NOEXIST), SUCCESS);
1040 WaitForMsgProcessing(hpaeManager_);
1041
1042 hpaeManager_->rendererIdStreamInfoMap_[streamInfo.sessionId].state = HPAE_SESSION_PREPARED;
1043 EXPECT_EQ(hpaeManager_->Start(streamInfo.streamClassType, streamInfo.sessionId), SUCCESS);
1044 WaitForMsgProcessing(hpaeManager_);
1045 EXPECT_EQ(hpaeManager_->GetSessionInfo(streamInfo.streamClassType, streamInfo.sessionId, sessionInfo), SUCCESS);
1046
1047 EXPECT_EQ(hpaeManager_->SetClientVolume(SESSION_ID_NOEXIST, 1.0f), SUCCESS);
1048 WaitForMsgProcessing(hpaeManager_);
1049 EXPECT_EQ(hpaeManager_->SetClientVolume(streamInfo.sessionId, 1.0f), SUCCESS);
1050 WaitForMsgProcessing(hpaeManager_);
1051
1052 EXPECT_EQ(hpaeManager_->SetOffloadPolicy(SESSION_ID_NOEXIST, 1), SUCCESS);
1053 WaitForMsgProcessing(hpaeManager_);
1054 hpaeManager_->movingIds_.emplace(streamInfo.sessionId, HPAE_SESSION_RUNNING);
1055 EXPECT_EQ(hpaeManager_->SetOffloadPolicy(streamInfo.sessionId, 1), SUCCESS);
1056 WaitForMsgProcessing(hpaeManager_);
1057 hpaeManager_->movingIds_.erase(streamInfo.sessionId);
1058 EXPECT_EQ(hpaeManager_->SetOffloadPolicy(streamInfo.sessionId, 1), SUCCESS);
1059 WaitForMsgProcessing(hpaeManager_);
1060
1061 hpaeManager_->SetSpeed(SESSION_ID_NOEXIST, 1.0f);
1062 WaitForMsgProcessing(hpaeManager_);
1063 hpaeManager_->movingIds_.emplace(streamInfo.sessionId, HPAE_SESSION_RUNNING);
1064 hpaeManager_->SetSpeed(streamInfo.sessionId, 1.0f);
1065 WaitForMsgProcessing(hpaeManager_);
1066 hpaeManager_->movingIds_.erase(streamInfo.sessionId);
1067 hpaeManager_->SetSpeed(streamInfo.sessionId, 1.0f);
1068 WaitForMsgProcessing(hpaeManager_);
1069
1070 EXPECT_EQ(hpaeManager_->Drain(streamInfo.streamClassType, streamInfo.sessionId), SUCCESS);
1071 WaitForMsgProcessing(hpaeManager_);
1072 EXPECT_EQ(hpaeManager_->Flush(streamInfo.streamClassType, streamInfo.sessionId), SUCCESS);
1073 WaitForMsgProcessing(hpaeManager_);
1074
1075 EXPECT_EQ(hpaeManager_->CloseOutAudioPort("Speaker_File1"), SUCCESS);
1076 WaitForMsgProcessing(hpaeManager_);
1077
1078 EXPECT_EQ(hpaeManager_->OpenAudioPort(audioModuleInfo1), SUCCESS);
1079 WaitForMsgProcessing(hpaeManager_);
1080
1081 hpaeManager_->Release(streamInfo.streamClassType, streamInfo.sessionId);
1082 WaitForMsgProcessing(hpaeManager_);
1083 EXPECT_EQ(hpaeManager_->GetSessionInfo(streamInfo.streamClassType, streamInfo.sessionId, sessionInfo), ERROR);
1084 }
1085
1086 HWTEST_F(HpaeManagerUnitTest, IHpaeCaptureStreamManagerMoveTest003, TestSize.Level1)
1087 {
1088 EXPECT_NE(hpaeManager_, nullptr);
1089 hpaeManager_->Init();
1090 EXPECT_EQ(hpaeManager_->IsInit(), true);
1091 sleep(1);
1092 AudioModuleInfo audioModuleInfo = GetSourceAudioModeInfo();
1093 EXPECT_EQ(hpaeManager_->OpenAudioPort(audioModuleInfo), SUCCESS);
1094 AudioModuleInfo audioModuleInfo1 = GetSourceAudioModeInfo("mic1");
1095 EXPECT_EQ(hpaeManager_->OpenAudioPort(audioModuleInfo1), SUCCESS);
1096 WaitForMsgProcessing(hpaeManager_);
1097 hpaeManager_->SetDefaultSource(audioModuleInfo.name);
1098 HpaeStreamInfo streamInfo = GetCaptureStreamInfo();
1099 hpaeManager_->CreateStream(streamInfo);
1100 WaitForMsgProcessing(hpaeManager_);
1101 int32_t fixedNum = 100;
1102 std::shared_ptr<WriteFixedValueCb> writeFixedValueCb = std::make_shared<WriteFixedValueCb>(SAMPLE_S16LE, fixedNum);
1103 hpaeManager_->RegisterWriteCallback(streamInfo.sessionId, writeFixedValueCb);
1104 std::shared_ptr<StatusChangeCb> statusChangeCb = std::make_shared<StatusChangeCb>();
1105 hpaeManager_->RegisterStatusCallback(HPAE_STREAM_CLASS_TYPE_RECORD, streamInfo.sessionId, statusChangeCb);
1106 WaitForMsgProcessing(hpaeManager_);
1107 HpaeSessionInfo sessionInfo;
1108 EXPECT_EQ(hpaeManager_->GetSessionInfo(streamInfo.streamClassType, streamInfo.sessionId, sessionInfo), SUCCESS);
1109 EXPECT_EQ(sessionInfo.streamInfo.sessionId, streamInfo.sessionId);
1110 EXPECT_EQ(sessionInfo.streamInfo.streamType, streamInfo.streamType);
1111 EXPECT_EQ(sessionInfo.streamInfo.frameLen, streamInfo.frameLen);
1112 EXPECT_EQ(sessionInfo.streamInfo.streamClassType, streamInfo.streamClassType);
1113 EXPECT_EQ(sessionInfo.state, HPAE_SESSION_NEW);
1114
1115 std::shared_ptr<ReadDataCb> readDataCb = std::make_shared<ReadDataCb>(ROOT_PATH);
1116 EXPECT_EQ(hpaeManager_->RegisterReadCallback(SESSION_ID_NOEXIST, readDataCb), SUCCESS);
1117 WaitForMsgProcessing(hpaeManager_);
1118 EXPECT_EQ(hpaeManager_->RegisterReadCallback(streamInfo.sessionId, readDataCb), SUCCESS);
1119 WaitForMsgProcessing(hpaeManager_);
1120
1121 EXPECT_EQ(hpaeManager_->MoveSourceOutputByIndexOrName(streamInfo.sessionId, 1, ""), SUCCESS);
1122 WaitForMsgProcessing(hpaeManager_);
1123 EXPECT_EQ(hpaeManager_->MoveSourceOutputByIndexOrName(streamInfo.sessionId, 1, "virtual1"), SUCCESS);
1124 WaitForMsgProcessing(hpaeManager_);
1125 EXPECT_EQ(hpaeManager_->MoveSourceOutputByIndexOrName(SESSION_ID_NOEXIST, 1, "mic1"), SUCCESS);
1126 WaitForMsgProcessing(hpaeManager_);
1127 EXPECT_EQ(hpaeManager_->MoveSourceOutputByIndexOrName(streamInfo.sessionId, 1, "mic"), SUCCESS);
1128 WaitForMsgProcessing(hpaeManager_);
1129 hpaeManager_->capturerIdStreamInfoMap_[streamInfo.sessionId].streamInfo.isMoveAble = false;
1130 EXPECT_EQ(hpaeManager_->MoveSourceOutputByIndexOrName(streamInfo.sessionId, 1, "mic1"), SUCCESS);
1131 WaitForMsgProcessing(hpaeManager_);
1132
1133 hpaeManager_->capturerIdStreamInfoMap_[streamInfo.sessionId].streamInfo.isMoveAble = true;
1134 EXPECT_EQ(hpaeManager_->MoveSourceOutputByIndexOrName(streamInfo.sessionId, 1, "mic1"), SUCCESS);
1135 WaitForMsgProcessing(hpaeManager_);
1136
1137 hpaeManager_->capturerIdStreamInfoMap_[streamInfo.sessionId].state = HPAE_SESSION_RELEASED;
1138 EXPECT_EQ(hpaeManager_->Start(streamInfo.streamClassType, streamInfo.sessionId), SUCCESS);
1139 WaitForMsgProcessing(hpaeManager_);
1140 EXPECT_EQ(hpaeManager_->Pause(streamInfo.streamClassType, streamInfo.sessionId), SUCCESS);
1141 WaitForMsgProcessing(hpaeManager_);
1142 EXPECT_EQ(hpaeManager_->Stop(streamInfo.streamClassType, streamInfo.sessionId), SUCCESS);
1143 WaitForMsgProcessing(hpaeManager_);
1144 EXPECT_EQ(hpaeManager_->Drain(streamInfo.streamClassType, streamInfo.sessionId), SUCCESS);
1145 WaitForMsgProcessing(hpaeManager_);
1146 EXPECT_EQ(hpaeManager_->Flush(streamInfo.streamClassType, streamInfo.sessionId), SUCCESS);
1147 WaitForMsgProcessing(hpaeManager_);
1148 EXPECT_EQ(hpaeManager_->Release(streamInfo.streamClassType, streamInfo.sessionId), SUCCESS);
1149 WaitForMsgProcessing(hpaeManager_);
1150
1151 EXPECT_EQ(hpaeManager_->Start(streamInfo.streamClassType, SESSION_ID_NOEXIST), SUCCESS);
1152 WaitForMsgProcessing(hpaeManager_);
1153 EXPECT_EQ(hpaeManager_->Pause(streamInfo.streamClassType, SESSION_ID_NOEXIST), SUCCESS);
1154 WaitForMsgProcessing(hpaeManager_);
1155 EXPECT_EQ(hpaeManager_->Stop(streamInfo.streamClassType, SESSION_ID_NOEXIST), SUCCESS);
1156 WaitForMsgProcessing(hpaeManager_);
1157 EXPECT_EQ(hpaeManager_->Drain(streamInfo.streamClassType, SESSION_ID_NOEXIST), SUCCESS);
1158 WaitForMsgProcessing(hpaeManager_);
1159 EXPECT_EQ(hpaeManager_->Flush(streamInfo.streamClassType, SESSION_ID_NOEXIST), SUCCESS);
1160 WaitForMsgProcessing(hpaeManager_);
1161 EXPECT_EQ(hpaeManager_->Release(streamInfo.streamClassType, SESSION_ID_NOEXIST), SUCCESS);
1162 WaitForMsgProcessing(hpaeManager_);
1163
1164 hpaeManager_->capturerIdStreamInfoMap_[streamInfo.sessionId].state = HPAE_SESSION_PREPARED;
1165 EXPECT_EQ(hpaeManager_->Start(streamInfo.streamClassType, streamInfo.sessionId), SUCCESS);
1166 WaitForMsgProcessing(hpaeManager_);
1167 EXPECT_EQ(hpaeManager_->GetSessionInfo(streamInfo.streamClassType, streamInfo.sessionId, sessionInfo), SUCCESS);
1168
1169 EXPECT_EQ(hpaeManager_->Drain(streamInfo.streamClassType, streamInfo.sessionId), SUCCESS);
1170 WaitForMsgProcessing(hpaeManager_);
1171 EXPECT_EQ(hpaeManager_->Flush(streamInfo.streamClassType, streamInfo.sessionId), SUCCESS);
1172 WaitForMsgProcessing(hpaeManager_);
1173
1174 EXPECT_EQ(hpaeManager_->CloseInAudioPort("mic1"), SUCCESS);
1175 WaitForMsgProcessing(hpaeManager_);
1176
1177 EXPECT_EQ(hpaeManager_->OpenAudioPort(audioModuleInfo1), SUCCESS);
1178 WaitForMsgProcessing(hpaeManager_);
1179
1180 hpaeManager_->Release(streamInfo.streamClassType, streamInfo.sessionId);
1181 WaitForMsgProcessing(hpaeManager_);
1182 EXPECT_EQ(hpaeManager_->GetSessionInfo(streamInfo.streamClassType, streamInfo.sessionId, sessionInfo), ERROR);
1183 }
1184
1185 HWTEST_F(HpaeManagerUnitTest, GetAllSinks003, TestSize.Level1)
1186 {
1187 EXPECT_NE(hpaeManager_, nullptr);
1188 hpaeManager_->Init();
1189 EXPECT_EQ(hpaeManager_->IsInit(), true);
1190 sleep(1);
1191 std::shared_ptr<HpaeAudioServiceCallbackUnitTest> callback = std::make_shared<HpaeAudioServiceCallbackUnitTest>();
1192 hpaeManager_->RegisterSerivceCallback(callback);
1193 std::shared_ptr<HpaeAudioServiceDumpCallbackUnitTest> dumpCallback =
1194 std::make_shared<HpaeAudioServiceDumpCallbackUnitTest>();
1195 hpaeManager_->RegisterHpaeDumpCallback(dumpCallback);
1196
1197 AudioModuleInfo audioModuleInfo = GetSinkAudioModeInfo();
1198 EXPECT_EQ(hpaeManager_->OpenAudioPort(audioModuleInfo), SUCCESS);
1199 hpaeManager_->SetDefaultSink(audioModuleInfo.name);
1200 WaitForMsgProcessing(hpaeManager_);
1201
1202 int32_t ret = hpaeManager_->ReloadRenderManager(audioModuleInfo);
1203 EXPECT_EQ(ret, SUCCESS);
1204
1205 hpaeManager_->DumpSinkInfo(audioModuleInfo.name);
1206 hpaeManager_->DumpSinkInfo("virtual1");
1207 WaitForMsgProcessing(hpaeManager_);
1208
1209 EXPECT_EQ(hpaeManager_->OpenVirtualAudioPort(audioModuleInfo, TEST_STREAM_SESSION_ID), SUCCESS);
1210 AudioModuleInfo audioModuleInfo1 = GetSinkAudioModeInfo("Speaker_File1");
1211 EXPECT_EQ(hpaeManager_->OpenVirtualAudioPort(audioModuleInfo1, TEST_STREAM_SESSION_ID), SUCCESS);
1212 WaitForMsgProcessing(hpaeManager_);
1213
1214 ret = hpaeManager_->GetAllSinks();
1215 WaitForMsgProcessing(hpaeManager_);
1216 EXPECT_EQ(ret, SUCCESS);
1217
1218 audioModuleInfo1 = GetSourceAudioModeInfo();
1219 EXPECT_EQ(hpaeManager_->OpenAudioPort(audioModuleInfo1), SUCCESS);
1220 WaitForMsgProcessing(hpaeManager_);
1221
1222 hpaeManager_->DumpSourceInfo(audioModuleInfo1.name);
1223 hpaeManager_->DumpSourceInfo("virtual1");
1224
1225 HpaeDeviceInfo devicesInfo_;
1226 hpaeManager_->DumpAllAvailableDevice(devicesInfo_);
1227 WaitForMsgProcessing(hpaeManager_);
1228 EXPECT_EQ(devicesInfo_.sinkInfos.size() > 0, true);
1229 EXPECT_EQ(devicesInfo_.sourceInfos.size() > 0, true);
1230 }
1231
1232 HWTEST_F(HpaeManagerUnitTest, IHpaeManagerSetDefaultSink001, TestSize.Level1)
1233 {
1234 EXPECT_NE(hpaeManager_, nullptr);
1235 hpaeManager_->Init();
1236 EXPECT_EQ(hpaeManager_->IsInit(), true);
1237 sleep(1);
1238 AudioModuleInfo audioModuleInfo = GetSinkAudioModeInfo();
1239 EXPECT_EQ(hpaeManager_->SetDefaultSink(audioModuleInfo.name), SUCCESS);
1240 WaitForMsgProcessing(hpaeManager_);
1241 EXPECT_EQ(hpaeManager_->OpenAudioPort(audioModuleInfo), SUCCESS);
1242 WaitForMsgProcessing(hpaeManager_);
1243 EXPECT_EQ(hpaeManager_->SetDefaultSink("virtual1"), SUCCESS);
1244 WaitForMsgProcessing(hpaeManager_);
1245 EXPECT_EQ(hpaeManager_->SetDefaultSink(audioModuleInfo.name), SUCCESS);
1246 WaitForMsgProcessing(hpaeManager_);
1247 AudioModuleInfo audioModuleInfo1 = GetSinkAudioModeInfo("Speaker_File1");
1248 EXPECT_EQ(hpaeManager_->OpenAudioPort(audioModuleInfo1), SUCCESS);
1249 WaitForMsgProcessing(hpaeManager_);
1250 EXPECT_EQ(hpaeManager_->SetDefaultSink("Speaker_File1"), SUCCESS);
1251 WaitForMsgProcessing(hpaeManager_);
1252 EXPECT_EQ(hpaeManager_->OpenAudioPort(audioModuleInfo1), SUCCESS);
1253 WaitForMsgProcessing(hpaeManager_);
1254 EXPECT_EQ(hpaeManager_->CloseOutAudioPort("Speaker_File2"), SUCCESS);
1255 EXPECT_EQ(hpaeManager_->CloseOutAudioPort("Speaker_File1"), SUCCESS);
1256 EXPECT_EQ(hpaeManager_->CloseOutAudioPort("Speaker_File"), SUCCESS);
1257 EXPECT_EQ(hpaeManager_->OpenAudioPort(audioModuleInfo), SUCCESS);
1258 WaitForMsgProcessing(hpaeManager_);
1259 }
1260
1261 HWTEST_F(HpaeManagerUnitTest, IHpaeManagerSetDefaultSink002, TestSize.Level1)
1262 {
1263 EXPECT_NE(hpaeManager_, nullptr);
1264 hpaeManager_->Init();
1265 EXPECT_EQ(hpaeManager_->IsInit(), true);
1266 sleep(1);
1267 AudioModuleInfo audioModuleInfo = GetSinkAudioModeInfo();
1268 EXPECT_EQ(hpaeManager_->OpenAudioPort(audioModuleInfo), SUCCESS);
1269 WaitForMsgProcessing(hpaeManager_);
1270 hpaeManager_->defaultSink_ = "virtual1";
1271 EXPECT_EQ(hpaeManager_->SetDefaultSink(audioModuleInfo.name), SUCCESS);
1272 WaitForMsgProcessing(hpaeManager_);
1273 EXPECT_EQ(hpaeManager_->CloseOutAudioPort("Speaker_File"), SUCCESS);
1274 WaitForMsgProcessing(hpaeManager_);
1275 }
1276
1277 HWTEST_F(HpaeManagerUnitTest, IHpaeManagerSetDefaultSource001, TestSize.Level1)
1278 {
1279 EXPECT_NE(hpaeManager_, nullptr);
1280 hpaeManager_->Init();
1281 EXPECT_EQ(hpaeManager_->IsInit(), true);
1282 sleep(1);
1283 AudioModuleInfo audioModuleInfo = GetSourceAudioModeInfo();
1284 EXPECT_EQ(hpaeManager_->SetDefaultSource(audioModuleInfo.name), SUCCESS);
1285 WaitForMsgProcessing(hpaeManager_);
1286 EXPECT_EQ(hpaeManager_->OpenAudioPort(audioModuleInfo), SUCCESS);
1287 WaitForMsgProcessing(hpaeManager_);
1288 EXPECT_EQ(hpaeManager_->SetDefaultSource("virtual1"), SUCCESS);
1289 WaitForMsgProcessing(hpaeManager_);
1290 EXPECT_EQ(hpaeManager_->SetDefaultSource(audioModuleInfo.name), SUCCESS);
1291 WaitForMsgProcessing(hpaeManager_);
1292 EXPECT_EQ(hpaeManager_->SetDefaultSource(audioModuleInfo.name), SUCCESS);
1293 WaitForMsgProcessing(hpaeManager_);
1294
1295 AudioModuleInfo audioModuleInfo1 = GetSourceAudioModeInfo("mic1");
1296 EXPECT_EQ(hpaeManager_->OpenAudioPort(audioModuleInfo1), SUCCESS);
1297 WaitForMsgProcessing(hpaeManager_);
1298 EXPECT_EQ(hpaeManager_->SetDefaultSource("Speaker_File1"), SUCCESS);
1299 WaitForMsgProcessing(hpaeManager_);
1300 EXPECT_EQ(hpaeManager_->OpenAudioPort(audioModuleInfo1), SUCCESS);
1301 WaitForMsgProcessing(hpaeManager_);
1302 EXPECT_EQ(hpaeManager_->CloseInAudioPort("Speaker_File2"), SUCCESS);
1303 EXPECT_EQ(hpaeManager_->CloseOutAudioPort("mic1"), SUCCESS);
1304 EXPECT_EQ(hpaeManager_->CloseOutAudioPort("mic"), SUCCESS);
1305 EXPECT_EQ(hpaeManager_->OpenAudioPort(audioModuleInfo), SUCCESS);
1306 WaitForMsgProcessing(hpaeManager_);
1307 }
1308
1309 HWTEST_F(HpaeManagerUnitTest, IHpaeManagerEffectTest001, TestSize.Level1)
1310 {
1311 EXPECT_NE(hpaeManager_, nullptr);
1312 hpaeManager_->Init();
1313 EXPECT_EQ(hpaeManager_->IsInit(), true);
1314 sleep(1);
1315 AudioModuleInfo audioModuleInfo = GetSinkAudioModeInfo();
1316 EXPECT_EQ(hpaeManager_->OpenAudioPort(audioModuleInfo), SUCCESS);
1317 hpaeManager_->SetDefaultSink(audioModuleInfo.name);
1318 AudioModuleInfo audioModuleInfo1 = GetSinkAudioModeInfo("Speaker_File1");
1319 EXPECT_EQ(hpaeManager_->OpenAudioPort(audioModuleInfo1), SUCCESS);
1320 WaitForMsgProcessing(hpaeManager_);
1321 HpaeStreamInfo streamInfo = GetRenderStreamInfo();
1322 hpaeManager_->CreateStream(streamInfo);
1323 WaitForMsgProcessing(hpaeManager_);
1324 int32_t fixedNum = 100;
1325 std::shared_ptr<WriteFixedValueCb> writeFixedValueCb = std::make_shared<WriteFixedValueCb>(SAMPLE_S16LE, fixedNum);
1326 hpaeManager_->RegisterWriteCallback(streamInfo.sessionId, writeFixedValueCb);
1327 std::shared_ptr<StatusChangeCb> statusChangeCb = std::make_shared<StatusChangeCb>();
1328 hpaeManager_->RegisterStatusCallback(HPAE_STREAM_CLASS_TYPE_PLAY, streamInfo.sessionId, statusChangeCb);
1329 WaitForMsgProcessing(hpaeManager_);
1330 HpaeSessionInfo sessionInfo;
1331 EXPECT_EQ(hpaeManager_->GetSessionInfo(streamInfo.streamClassType, streamInfo.sessionId, sessionInfo), SUCCESS);
1332 EXPECT_EQ(sessionInfo.streamInfo.sessionId, streamInfo.sessionId);
1333 EXPECT_EQ(sessionInfo.streamInfo.streamType, streamInfo.streamType);
1334 EXPECT_EQ(sessionInfo.streamInfo.frameLen, streamInfo.frameLen);
1335 EXPECT_EQ(sessionInfo.streamInfo.format, streamInfo.format);
1336 EXPECT_EQ(sessionInfo.streamInfo.samplingRate, streamInfo.samplingRate);
1337 EXPECT_EQ(sessionInfo.streamInfo.channels, streamInfo.channels);
1338 EXPECT_EQ(sessionInfo.streamInfo.streamClassType, streamInfo.streamClassType);
1339 EXPECT_EQ(sessionInfo.state, HPAE_SESSION_NEW);
1340 EXPECT_EQ(hpaeManager_->SetRate(streamInfo.sessionId, RENDER_RATE_DOUBLE), SUCCESS);
1341 WaitForMsgProcessing(hpaeManager_);
1342 int32_t effectMode = 0;
1343 EXPECT_EQ(hpaeManager_->GetAudioEffectMode(streamInfo.sessionId, effectMode), SUCCESS);
1344 int32_t privacyType = 0;
1345 EXPECT_EQ(hpaeManager_->SetPrivacyType(streamInfo.sessionId, privacyType), SUCCESS);
1346 WaitForMsgProcessing(hpaeManager_);
1347 EXPECT_EQ(hpaeManager_->GetPrivacyType(streamInfo.sessionId, privacyType), SUCCESS);
1348 EXPECT_EQ(hpaeManager_->GetWritableSize(streamInfo.sessionId), SUCCESS);
1349 EXPECT_EQ(hpaeManager_->UpdateSpatializationState(streamInfo.sessionId + 1, true, false), SUCCESS);
1350 WaitForMsgProcessing(hpaeManager_);
1351 EXPECT_EQ(hpaeManager_->UpdateSpatializationState(streamInfo.sessionId, true, false), SUCCESS);
1352 WaitForMsgProcessing(hpaeManager_);
1353 EXPECT_EQ(hpaeManager_->UpdateMaxLength(streamInfo.sessionId, TEST_SLEEP_TIME_20), SUCCESS);
1354 WaitForMsgProcessing(hpaeManager_);
1355 EXPECT_EQ(hpaeManager_->SetOffloadRenderCallbackType(streamInfo.sessionId, CB_FLUSH_COMPLETED), SUCCESS);
1356 WaitForMsgProcessing(hpaeManager_);
1357
1358 hpaeManager_->Release(streamInfo.streamClassType, streamInfo.sessionId);
1359 WaitForMsgProcessing(hpaeManager_);
1360 EXPECT_EQ(hpaeManager_->GetSessionInfo(streamInfo.streamClassType, streamInfo.sessionId, sessionInfo), ERROR);
1361 EXPECT_EQ(hpaeManager_->CloseOutAudioPort("Speaker_File1"), SUCCESS);
1362 EXPECT_EQ(hpaeManager_->CloseOutAudioPort("Speaker_File"), SUCCESS);
1363 }
1364
1365 HWTEST_F(HpaeManagerUnitTest, IHpaeManagerEffectTest002, TestSize.Level1)
1366 {
1367 EXPECT_NE(hpaeManager_, nullptr);
1368 hpaeManager_->Init();
1369 EXPECT_EQ(hpaeManager_->IsInit(), true);
1370 sleep(1);
1371 AudioModuleInfo audioModuleInfo = GetSinkAudioModeInfo();
1372 EXPECT_EQ(hpaeManager_->OpenAudioPort(audioModuleInfo), SUCCESS);
1373 hpaeManager_->SetDefaultSink(audioModuleInfo.name);
1374 AudioModuleInfo audioModuleInfo1 = GetSinkAudioModeInfo("Speaker_File1");
1375 EXPECT_EQ(hpaeManager_->OpenAudioPort(audioModuleInfo1), SUCCESS);
1376 WaitForMsgProcessing(hpaeManager_);
1377
1378 AudioSpatializationState stateInfo;
1379 stateInfo.headTrackingEnabled = false;
1380 stateInfo.spatializationEnabled = false;
1381 EXPECT_EQ(hpaeManager_->UpdateSpatializationState(stateInfo), SUCCESS);
1382 WaitForMsgProcessing(hpaeManager_);
1383
1384 EXPECT_EQ(hpaeManager_->UpdateSpatialDeviceType(EARPHONE_TYPE_INEAR), SUCCESS);
1385 WaitForMsgProcessing(hpaeManager_);
1386
1387 AudioEffectPropertyArrayV3 propertyV3;
1388 EXPECT_EQ(hpaeManager_->GetAudioEffectProperty(propertyV3), SUCCESS);
1389 WaitForMsgProcessing(hpaeManager_);
1390
1391 EXPECT_EQ(hpaeManager_->SetAudioEffectProperty(propertyV3), SUCCESS);
1392 WaitForMsgProcessing(hpaeManager_);
1393
1394 AudioEffectPropertyArray property;
1395 EXPECT_EQ(hpaeManager_->GetAudioEffectProperty(property), SUCCESS);
1396 WaitForMsgProcessing(hpaeManager_);
1397
1398 hpaeManager_->UpdateEffectBtOffloadSupported(true);
1399 EXPECT_EQ(hpaeManager_->SetOutputDevice(TEST_STREAM_SESSION_ID, DEVICE_TYPE_SPEAKER), SUCCESS);
1400 WaitForMsgProcessing(hpaeManager_);
1401
1402 EXPECT_EQ(hpaeManager_->SetMicrophoneMuteInfo(false), SUCCESS);
1403 WaitForMsgProcessing(hpaeManager_);
1404
1405 EXPECT_EQ(hpaeManager_->GetAudioEnhanceProperty(propertyV3, DEVICE_TYPE_SPEAKER), SUCCESS);
1406 WaitForMsgProcessing(hpaeManager_);
1407
1408 EXPECT_EQ(hpaeManager_->SetAudioEnhanceProperty(propertyV3, DEVICE_TYPE_SPEAKER), SUCCESS);
1409 WaitForMsgProcessing(hpaeManager_);
1410
1411 AudioEnhancePropertyArray propertyEn;
1412 EXPECT_EQ(hpaeManager_->GetAudioEnhanceProperty(propertyEn, DEVICE_TYPE_SPEAKER), SUCCESS);
1413 WaitForMsgProcessing(hpaeManager_);
1414
1415 EXPECT_EQ(hpaeManager_->SetAudioEnhanceProperty(propertyEn, DEVICE_TYPE_SPEAKER), SUCCESS);
1416 hpaeManager_->UpdateExtraSceneType("123", "456", "789");
1417 WaitForMsgProcessing(hpaeManager_);
1418 }
1419
1420 HWTEST_F(HpaeManagerUnitTest, IHpaeManagerSuspend002, TestSize.Level0)
1421 {
1422 EXPECT_NE(hpaeManager_, nullptr);
1423 hpaeManager_->Init();
1424 EXPECT_EQ(hpaeManager_->IsInit(), true);
1425 sleep(1);
1426 std::string deviceName = "virtual1";
1427 EXPECT_EQ(hpaeManager_->SuspendAudioDevice(deviceName, true), SUCCESS);
1428 EXPECT_EQ(hpaeManager_->SetSinkMute(deviceName, true), SUCCESS);
1429 EXPECT_EQ(hpaeManager_->SetSourceOutputMute(TEST_STREAM_SESSION_ID, true), SUCCESS);
1430 }
1431
1432 HWTEST_F(HpaeManagerUnitTest, IHpaeManagerMoveFailed002, TestSize.Level0)
1433 {
1434 EXPECT_NE(hpaeManager_, nullptr);
1435 hpaeManager_->Init();
1436 EXPECT_EQ(hpaeManager_->IsInit(), true);
1437 sleep(1);
1438 hpaeManager_->movingIds_.emplace(TEST_STREAM_SESSION_ID, HPAE_SESSION_RUNNING);
1439 hpaeManager_->HandleMoveSessionFailed(HPAE_STREAM_CLASS_TYPE_PLAY, TEST_STREAM_SESSION_ID,
1440 MOVE_SINGLE, "Speaker_File1");
1441 EXPECT_EQ(hpaeManager_->movingIds_.size(), 0);
1442
1443 hpaeManager_->movingIds_.emplace(TEST_STREAM_SESSION_ID, HPAE_SESSION_RUNNING);
1444 hpaeManager_->HandleMoveSessionFailed(HPAE_STREAM_CLASS_TYPE_RECORD, TEST_STREAM_SESSION_ID,
1445 MOVE_SINGLE, "Speaker_File1");
1446 EXPECT_EQ(hpaeManager_->movingIds_.size(), 0);
1447
1448 hpaeManager_->movingIds_.emplace(TEST_STREAM_SESSION_ID, HPAE_SESSION_RUNNING);
1449 hpaeManager_->HandleMoveSessionFailed(HPAE_STREAM_CLASS_TYPE_RECORD, TEST_STREAM_SESSION_ID,
1450 MOVE_PREFER, "Speaker_File1");
1451 EXPECT_EQ(hpaeManager_->movingIds_.size(), 0);
1452 }
1453
1454 HWTEST_F(HpaeManagerUnitTest, IHpaeManagerAddPreferSink001, TestSize.Level0)
1455 {
1456 EXPECT_NE(hpaeManager_, nullptr);
1457 hpaeManager_->rendererIdSinkNameMap_.emplace(TEST_STREAM_SESSION_ID, "speaker_file");
1458 hpaeManager_->AddPreferSinkForDefaultChange(false, "speaker_file");
1459 EXPECT_EQ(hpaeManager_->idPreferSinkNameMap_.size() == 0, true);
1460 hpaeManager_->AddPreferSinkForDefaultChange(true, "speaker_file");
1461 EXPECT_EQ(hpaeManager_->idPreferSinkNameMap_.size() == 1, true);
1462 }
1463
1464 HWTEST_F(HpaeManagerUnitTest, HpaeRenderManagerReloadTest001, TestSize.Level1)
1465 {
1466 EXPECT_NE(hpaeManager_, nullptr);
1467 hpaeManager_->Init();
1468 EXPECT_EQ(hpaeManager_->IsInit(), true);
1469 sleep(1);
1470 EXPECT_EQ(hpaeManager_->IsRunning(), true);
1471
1472 std::shared_ptr<HpaeAudioServiceCallbackUnitTest> callback = std::make_shared<HpaeAudioServiceCallbackUnitTest>();
1473 hpaeManager_->RegisterSerivceCallback(callback);
1474 AudioModuleInfo audioModuleInfo = GetSinkAudioModeInfo();
1475 EXPECT_EQ(hpaeManager_->ReloadAudioPort(audioModuleInfo), SUCCESS);
1476 WaitForMsgProcessing(hpaeManager_);
1477 int32_t portId = callback->GetPortId();
1478
1479 EXPECT_EQ(hpaeManager_->ReloadAudioPort(audioModuleInfo), SUCCESS);
1480 WaitForMsgProcessing(hpaeManager_);
1481 portId = callback->GetPortId();
1482
1483 hpaeManager_->CloseAudioPort(portId);
1484 WaitForMsgProcessing(hpaeManager_);
1485 EXPECT_EQ(callback->GetCloseAudioPortResult(), SUCCESS);
1486
1487 EXPECT_EQ(hpaeManager_->ReloadAudioPort(audioModuleInfo), SUCCESS);
1488 WaitForMsgProcessing(hpaeManager_);
1489 portId = callback->GetPortId();
1490
1491 hpaeManager_->DeInit();
1492 EXPECT_EQ(hpaeManager_->IsInit(), false);
1493 EXPECT_EQ(hpaeManager_->IsRunning(), false);
1494 }
1495
1496 HWTEST_F(HpaeManagerUnitTest, HpaeRenderManagerReloadTest002, TestSize.Level1)
1497 {
1498 EXPECT_NE(hpaeManager_, nullptr);
1499 hpaeManager_->Init();
1500 EXPECT_EQ(hpaeManager_->IsInit(), true);
1501 sleep(1);
1502 EXPECT_EQ(hpaeManager_->IsRunning(), true);
1503
1504 std::shared_ptr<HpaeAudioServiceCallbackUnitTest> callback = std::make_shared<HpaeAudioServiceCallbackUnitTest>();
1505 hpaeManager_->RegisterSerivceCallback(callback);
1506 AudioModuleInfo audioModuleInfo = GetSourceAudioModeInfo();
1507 EXPECT_EQ(hpaeManager_->ReloadAudioPort(audioModuleInfo), SUCCESS);
1508 WaitForMsgProcessing(hpaeManager_);
1509 }
1510
1511 /**
1512 * @tc.name : Test UpdateCollaborativeState
1513 * @tc.type : FUNC
1514 * @tc.number: UpdateCollaborativeState_001
1515 * @tc.desc : Test UpdateCollaborativeState when config in vaild.
1516 */
1517 HWTEST_F(HpaeManagerUnitTest, UpdateCollaborativeState_001, TestSize.Level1)
1518 {
1519 EXPECT_NE(hpaeManager_, nullptr);
1520 hpaeManager_->Init();
1521 EXPECT_EQ(hpaeManager_->IsInit(), true);
1522 int32_t ret = hpaeManager_->UpdateCollaborativeState(true);
1523 EXPECT_EQ(ret, SUCCESS);
1524 WaitForMsgProcessing(hpaeManager_);
1525 ret = hpaeManager_->UpdateCollaborativeState(false);
1526 EXPECT_EQ(ret, SUCCESS);
1527 }
1528
1529 HWTEST_F(HpaeManagerUnitTest, IHpaeManagerDumpStreamInfoTest, TestSize.Level1)
1530 {
1531 EXPECT_NE(hpaeManager_, nullptr);
1532 hpaeManager_->Init();
1533 sleep(1);
1534 EXPECT_EQ(hpaeManager_->IsInit(), true);
1535 std::shared_ptr<HpaeAudioServiceCallbackUnitTest> callback = std::make_shared<HpaeAudioServiceCallbackUnitTest>();
1536 EXPECT_EQ(hpaeManager_->RegisterSerivceCallback(callback), SUCCESS);
1537
1538 AudioModuleInfo sinkAudioModuleInfo = GetSinkAudioModeInfo();
1539 EXPECT_EQ(hpaeManager_->OpenAudioPort(sinkAudioModuleInfo), SUCCESS);
1540 WaitForMsgProcessing(hpaeManager_);
1541 int32_t sinkPortId = callback->GetPortId();
1542 AudioModuleInfo sourceAudioModuleInfo = GetSourceAudioModeInfo();
1543 EXPECT_EQ(hpaeManager_->OpenAudioPort(sourceAudioModuleInfo), SUCCESS);
1544 WaitForMsgProcessing(hpaeManager_);
1545 int32_t sourcePortId = callback->GetPortId();
1546
1547 std::shared_ptr<HpaeAudioServiceDumpCallbackUnitTest> dumpCallback =
1548 std::make_shared<HpaeAudioServiceDumpCallbackUnitTest>();
1549 EXPECT_EQ(hpaeManager_->RegisterHpaeDumpCallback(dumpCallback), SUCCESS);
1550 WaitForMsgProcessing(hpaeManager_);
1551
1552 HpaeStreamInfo rendererStreamInfo = GetRenderStreamInfo();
1553 hpaeManager_->CreateStream(rendererStreamInfo);
1554 WaitForMsgProcessing(hpaeManager_);
1555 hpaeManager_->DumpSinkInputsInfo();
1556 WaitForMsgProcessing(hpaeManager_);
1557 EXPECT_EQ(dumpCallback->GetSinkInputsSize(), 1);
1558 EXPECT_EQ(
1559 hpaeManager_->ShouldNotSkipProcess(rendererStreamInfo.streamClassType, rendererStreamInfo.sessionId), true);
1560
1561
1562 HpaeStreamInfo capturerStreamInfo = GetCaptureStreamInfo();
1563 capturerStreamInfo.deviceName = sourceAudioModuleInfo.name;
1564 hpaeManager_->CreateStream(capturerStreamInfo);
1565 WaitForMsgProcessing(hpaeManager_);
1566 hpaeManager_->DumpSourceOutputsInfo();
1567 WaitForMsgProcessing(hpaeManager_);
1568 EXPECT_EQ(dumpCallback->GetSourceOutputsSize(), 1);
1569 EXPECT_EQ(
1570 hpaeManager_->ShouldNotSkipProcess(capturerStreamInfo.streamClassType, capturerStreamInfo.sessionId), true);
1571
1572 EXPECT_EQ(hpaeManager_->ShouldNotSkipProcess(HPAE_STREAM_CLASS_TYPE_INVALID, TEST_STREAM_SESSION_ID), false);
1573 hpaeManager_->CloseAudioPort(sinkPortId);
1574 WaitForMsgProcessing(hpaeManager_);
1575 hpaeManager_->CloseAudioPort(sourcePortId);
1576 WaitForMsgProcessing(hpaeManager_);
1577 }
1578
1579 HWTEST_F(HpaeManagerUnitTest, IHpaeManagerTestHidumperWithoutCallback, TestSize.Level1)
1580 {
1581 EXPECT_NE(hpaeManager_, nullptr);
1582 hpaeManager_->Init();
1583 sleep(1);
1584 EXPECT_EQ(hpaeManager_->IsInit(), true);
1585 std::shared_ptr<HpaeAudioServiceCallbackUnitTest> callback = std::make_shared<HpaeAudioServiceCallbackUnitTest>();
1586 EXPECT_EQ(hpaeManager_->RegisterSerivceCallback(callback), SUCCESS);
1587
1588 AudioModuleInfo sinkAudioModuleInfo = GetSinkAudioModeInfo();
1589 EXPECT_EQ(hpaeManager_->OpenAudioPort(sinkAudioModuleInfo), SUCCESS);
1590 WaitForMsgProcessing(hpaeManager_);
1591 int32_t sinkPortId = callback->GetPortId();
1592 AudioModuleInfo sourceAudioModuleInfo = GetSourceAudioModeInfo();
1593 EXPECT_EQ(hpaeManager_->OpenAudioPort(sourceAudioModuleInfo), SUCCESS);
1594 WaitForMsgProcessing(hpaeManager_);
1595 int32_t sourcePortId = callback->GetPortId();
1596
1597 hpaeManager_->DumpSinkInfo(sinkAudioModuleInfo.name);
1598 WaitForMsgProcessing(hpaeManager_);
1599 hpaeManager_->DumpSourceInfo(sourceAudioModuleInfo.name);
1600 WaitForMsgProcessing(hpaeManager_);
1601 HpaeDeviceInfo deviceInfo;
1602 hpaeManager_->DumpAllAvailableDevice(deviceInfo);
1603 WaitForMsgProcessing(hpaeManager_);
1604 EXPECT_EQ(deviceInfo.sinkInfos.size() > 0, true);
1605 EXPECT_EQ(deviceInfo.sourceInfos.size() > 0, true);
1606 hpaeManager_->DumpSinkInputsInfo();
1607 WaitForMsgProcessing(hpaeManager_);
1608 hpaeManager_->DumpSourceOutputsInfo();
1609 WaitForMsgProcessing(hpaeManager_);
1610
1611 hpaeManager_->CloseAudioPort(sinkPortId);
1612 WaitForMsgProcessing(hpaeManager_);
1613 hpaeManager_->CloseAudioPort(sourcePortId);
1614 WaitForMsgProcessing(hpaeManager_);
1615 }
1616
1617 HWTEST_F(HpaeManagerUnitTest, IHpaeManagerGetSinkAndSourceInfoTest_001, TestSize.Level1)
1618 {
1619 EXPECT_NE(hpaeManager_, nullptr);
1620 hpaeManager_->Init();
1621 sleep(1);
1622 EXPECT_EQ(hpaeManager_->IsInit(), true);
1623 HpaeSinkInfo sinkInfo;
1624 HpaeSourceInfo sourceInfo;
1625
1626 int32_t ret = -1;
1627 EXPECT_EQ(hpaeManager_->GetSinkInfoByIdx(0,
__anonf2df1df20202(const HpaeSinkInfo &sinkInfoRet, int32_t result) 1628 [&sinkInfo, &ret](const HpaeSinkInfo &sinkInfoRet, int32_t result) {
1629 sinkInfo = sinkInfoRet;
1630 ret = result;
1631 }), SUCCESS);
1632 WaitForMsgProcessing(hpaeManager_);
1633 EXPECT_EQ(ret, ERROR);
1634
1635 ret = -1;
1636 EXPECT_EQ(hpaeManager_->GetSourceInfoByIdx(0,
__anonf2df1df20302(const HpaeSourceInfo &sourceInfoRet, int32_t result) 1637 [&sourceInfo, &ret](const HpaeSourceInfo &sourceInfoRet, int32_t result) {
1638 sourceInfo = sourceInfoRet;
1639 ret = result;
1640 }), SUCCESS);
1641 WaitForMsgProcessing(hpaeManager_);
1642 EXPECT_EQ(ret, ERROR);
1643 }
1644
1645 HWTEST_F(HpaeManagerUnitTest, IHpaeManagerGetSinkAndSourceInfoTest_002, TestSize.Level1)
1646 {
1647 EXPECT_NE(hpaeManager_, nullptr);
1648 hpaeManager_->Init();
1649 sleep(1);
1650 EXPECT_EQ(hpaeManager_->IsInit(), true);
1651 std::shared_ptr<HpaeAudioServiceCallbackUnitTest> callback = std::make_shared<HpaeAudioServiceCallbackUnitTest>();
1652 hpaeManager_->RegisterSerivceCallback(callback);
1653 HpaeSinkInfo sinkInfo;
1654 HpaeSourceInfo sourceInfo;
1655
1656 AudioModuleInfo audioModuleInfo1 = GetSinkAudioModeInfo();
1657 EXPECT_EQ(hpaeManager_->OpenAudioPort(audioModuleInfo1), SUCCESS);
1658 WaitForMsgProcessing(hpaeManager_);
1659 int32_t portId = callback->GetPortId();
1660 int32_t ret = -1;
1661 EXPECT_EQ(hpaeManager_->GetSinkInfoByIdx(portId,
__anonf2df1df20402(const HpaeSinkInfo &sinkInfoRet, int32_t result) 1662 [&sinkInfo, &ret](const HpaeSinkInfo &sinkInfoRet, int32_t result) {
1663 sinkInfo = sinkInfoRet;
1664 ret = result;
1665 }), SUCCESS);
1666 WaitForMsgProcessing(hpaeManager_);
1667 EXPECT_EQ(ret, SUCCESS);
1668 EXPECT_EQ(std::to_string(sinkInfo.channels) == audioModuleInfo1.channels, true);
1669 EXPECT_EQ(std::to_string(sinkInfo.samplingRate) == audioModuleInfo1.rate, true);
1670 hpaeManager_->CloseAudioPort(portId);
1671 WaitForMsgProcessing(hpaeManager_);
1672
1673 AudioModuleInfo audioModuleInfo2 = GetSourceAudioModeInfo();
1674 EXPECT_EQ(hpaeManager_->OpenAudioPort(audioModuleInfo2), SUCCESS);
1675 WaitForMsgProcessing(hpaeManager_);
1676 portId = callback->GetPortId();
1677 ret = -1;
1678 EXPECT_EQ(hpaeManager_->GetSourceInfoByIdx(portId,
__anonf2df1df20502(const HpaeSourceInfo &sourceInfoRet, int32_t result) 1679 [&sourceInfo, &ret](const HpaeSourceInfo &sourceInfoRet, int32_t result) {
1680 sourceInfo = sourceInfoRet;
1681 ret = result;
1682 }), SUCCESS);
1683 WaitForMsgProcessing(hpaeManager_);
1684 EXPECT_EQ(ret, SUCCESS);
1685 EXPECT_EQ(std::to_string(sourceInfo.channels) == audioModuleInfo2.channels, true);
1686 EXPECT_EQ(std::to_string(sourceInfo.samplingRate) == audioModuleInfo2.rate, true);
1687 hpaeManager_->CloseAudioPort(portId);
1688 WaitForMsgProcessing(hpaeManager_);
1689 }
1690 } // namespace