1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "audio_stream_manager_unit_test.h"
17
18 #include <chrono>
19 #include <thread>
20
21 #include "audio_capturer.h"
22 #include "audio_errors.h"
23 #include "audio_info.h"
24 #include "audio_log.h"
25 #include "audio_renderer.h"
26 #include "audio_stream_manager.h"
27
28 using namespace std;
29 using namespace std::chrono;
30 using namespace testing::ext;
31
32 namespace OHOS {
33 namespace AudioStandard {
34 namespace {
35 AudioStreamManager *g_audioManagerInstance = nullptr;
36 int g_isCallbackReceived = false;
37 constexpr uint32_t MIN_DEVICE_ID = 1;
38 constexpr int32_t VALUE_NEGATIVE = -1;
39 constexpr int32_t RENDERER_FLAG = 0;
40 constexpr int32_t CAPTURER_FLAG = 0;
41 constexpr int32_t WAIT_TIME = 2;
42 constexpr int32_t VALUE_HUNDRED = 100;
43 std::string g_callbackName("");
44 std::mutex g_mutex;
45 std::condition_variable g_condVar;
46 vector<unique_ptr<AudioRendererChangeInfo>> g_audioRendererChangeInfosRcvd;
47 vector<unique_ptr<AudioCapturerChangeInfo>> g_audioCapturerChangeInfosRcvd;
48 }
49
AudioRendererStateChangeCallbackTest(const std::string & testCaseName)50 AudioRendererStateChangeCallbackTest::AudioRendererStateChangeCallbackTest(const std::string &testCaseName)
51 : testCaseName_(testCaseName) {}
AudioCapturerStateChangeCallbackTest(const std::string & testCaseName)52 AudioCapturerStateChangeCallbackTest::AudioCapturerStateChangeCallbackTest(const std::string &testCaseName)
53 : testCaseName_(testCaseName) {}
54
SetUpTestCase(void)55 void AudioStreamManagerUnitTest::SetUpTestCase(void)
56 {
57 g_audioManagerInstance = AudioStreamManager::GetInstance();
58 if (g_audioManagerInstance == nullptr) {
59 AUDIO_ERR_LOG("AudioStreamManagerUnitTest: AudioStreamManager get instance fails");
60 return;
61 }
62 }
TearDownTestCase(void)63 void AudioStreamManagerUnitTest::TearDownTestCase(void) {}
SetUp(void)64 void AudioStreamManagerUnitTest::SetUp(void) {}
TearDown(void)65 void AudioStreamManagerUnitTest::TearDown(void) {}
66
InitializeRendererOptions(AudioRendererOptions & rendererOptions)67 void AudioStreamManagerUnitTest::InitializeRendererOptions(AudioRendererOptions &rendererOptions)
68 {
69 rendererOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_44100;
70 rendererOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
71 rendererOptions.streamInfo.format = AudioSampleFormat::SAMPLE_S16LE;
72 rendererOptions.streamInfo.channels = AudioChannel::STEREO;
73 rendererOptions.rendererInfo.contentType = ContentType::CONTENT_TYPE_MUSIC;
74 rendererOptions.rendererInfo.streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
75 rendererOptions.rendererInfo.rendererFlags = RENDERER_FLAG;
76 return;
77 }
78
OnRendererStateChange(const std::vector<std::unique_ptr<AudioRendererChangeInfo>> & audioRendererChangeInfos)79 void AudioRendererStateChangeCallbackTest::OnRendererStateChange(
80 const std::vector<std::unique_ptr<AudioRendererChangeInfo>> &audioRendererChangeInfos)
81 {
82 g_audioRendererChangeInfosRcvd.clear();
83 for (const auto &changeInfo : audioRendererChangeInfos) {
84 g_audioRendererChangeInfosRcvd.push_back(std::make_unique<AudioRendererChangeInfo>(*changeInfo));
85 }
86
87 g_isCallbackReceived = true;
88 }
89
WaitForCallback()90 void AudioStreamManagerUnitTest::WaitForCallback()
91 {
92 std::unique_lock<std::mutex> lock(g_mutex);
93 g_condVar.wait_until(lock, std::chrono::system_clock::now() + std::chrono::minutes(1),
94 []() { return g_isCallbackReceived == true; });
95 }
96
InitializeCapturerOptions(AudioCapturerOptions & capturerOptions)97 void AudioStreamManagerUnitTest::InitializeCapturerOptions(AudioCapturerOptions &capturerOptions)
98 {
99 capturerOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_96000;
100 capturerOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
101 capturerOptions.streamInfo.format = AudioSampleFormat::SAMPLE_U8;
102 capturerOptions.streamInfo.channels = AudioChannel::MONO;
103 capturerOptions.capturerInfo.sourceType = SourceType::SOURCE_TYPE_MIC;
104 capturerOptions.capturerInfo.capturerFlags = CAPTURER_FLAG;
105 return;
106 }
107
OnCapturerStateChange(const std::vector<std::unique_ptr<AudioCapturerChangeInfo>> & audioCapturerChangeInfos)108 void AudioCapturerStateChangeCallbackTest::OnCapturerStateChange(
109 const std::vector<std::unique_ptr<AudioCapturerChangeInfo>> &audioCapturerChangeInfos)
110 {
111 g_audioCapturerChangeInfosRcvd.clear();
112 for (const auto &changeInfo : audioCapturerChangeInfos) {
113 g_audioCapturerChangeInfosRcvd.push_back(std::make_unique<AudioCapturerChangeInfo>(*changeInfo));
114 }
115 g_isCallbackReceived = true;
116 }
117
118 /**
119 * @tc.name : Test RegisterAudioRendererEventListener API
120 * @tc.number: Audio_Stream_Change_Listner_RegisterAudioRendererEventListener_001
121 * @tc.desc : Test RegisterAudioRendererEventListener interface with valid parameters
122 */
123 HWTEST(AudioStreamManagerUnitTest, Audio_Stream_Change_Listner_RegisterAudioRendererEventListener_001, TestSize.Level0)
124 {
125 int callBackSetResult = -1;
126 std::string testCaseName("Audio_Stream_Change_Listner_RegisterAudioRendererEventListener_001");
127
128 vector<unique_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
129
130 auto audioRendererStateChangeCallbackTest = make_shared<AudioRendererStateChangeCallbackTest>(testCaseName);
131 callBackSetResult = g_audioManagerInstance->RegisterAudioRendererEventListener(getpid(),
132 audioRendererStateChangeCallbackTest);
133 EXPECT_EQ(SUCCESS, callBackSetResult);
134
135 g_audioManagerInstance->UnregisterAudioRendererEventListener(getpid());
136 }
137
138 /**
139 * @tc.name : Test RegisterAudioRendererEventListener API
140 * @tc.number: Audio_Stream_Change_Listner_RegisterAudioRendererEventListener_002
141 * @tc.desc : Test RegisterAudioRendererEventListener interface after unregister event
142 */
143 HWTEST(AudioStreamManagerUnitTest, Audio_Stream_Change_Listner_RegisterAudioRendererEventListener_002, TestSize.Level1)
144 {
145 int callBackSetResult = -1;
146 std::string testCaseName("Audio_Stream_Change_Listner_RegisterAudioRendererEventListener_002");
147
148 vector<unique_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
149
150 auto audioRendererStateChangeCallbackTest = make_shared<AudioRendererStateChangeCallbackTest>(testCaseName);
151 callBackSetResult = g_audioManagerInstance->RegisterAudioRendererEventListener(getpid(),
152 audioRendererStateChangeCallbackTest);
153 EXPECT_EQ(SUCCESS, callBackSetResult);
154
155 g_audioManagerInstance->UnregisterAudioRendererEventListener(getpid());
156
157 auto audioRendererStateChangeCallbackTest2 = make_shared<AudioRendererStateChangeCallbackTest>(testCaseName);
158 callBackSetResult = g_audioManagerInstance->RegisterAudioRendererEventListener(getpid(),
159 audioRendererStateChangeCallbackTest2);
160 EXPECT_EQ(SUCCESS, callBackSetResult);
161
162 g_audioManagerInstance->UnregisterAudioRendererEventListener(getpid());
163 }
164
165 /**
166 * @tc.name : Test RegisterAudioRendererEventListener API
167 * @tc.number: Audio_Stream_Change_Listner_RegisterAudioRendererEventListener_003
168 * @tc.desc : Test RegisterAudioRendererEventListener interface with null callback
169 */
170 HWTEST(AudioStreamManagerUnitTest, Audio_Stream_Change_Listner_RegisterAudioRendererEventListener_003, TestSize.Level1)
171 {
172 int callBackSetResult = -1;
173
174 callBackSetResult = g_audioManagerInstance->RegisterAudioRendererEventListener(getpid(), nullptr);
175 EXPECT_NE(SUCCESS, callBackSetResult);
176 }
177
178 /**
179 * @tc.name : Test RegisterAudioRendererEventListener API
180 * @tc.number: Audio_Stream_Change_Listner_RegisterAudioRendererEventListener_004
181 * @tc.desc : Test RegisterAudioRendererEventListener interface with valid parameter after nullptr callback
182 */
183 HWTEST(AudioStreamManagerUnitTest, Audio_Stream_Change_Listner_RegisterAudioRendererEventListener_004, TestSize.Level1)
184 {
185 int callBackSetResult = -1;
186 std::string testCaseName("Audio_Stream_Change_Listner_RegisterAudioRendererEventListener_004");
187
188 callBackSetResult = g_audioManagerInstance->RegisterAudioRendererEventListener(getpid(), nullptr);
189 EXPECT_NE(SUCCESS, callBackSetResult);
190
191 auto audioRendererStateChangeCallbackTest2 = make_shared<AudioRendererStateChangeCallbackTest>(testCaseName);
192 callBackSetResult = g_audioManagerInstance->RegisterAudioRendererEventListener(getpid(),
193 audioRendererStateChangeCallbackTest2);
194 EXPECT_EQ(SUCCESS, callBackSetResult);
195
196 g_audioManagerInstance->UnregisterAudioRendererEventListener(getpid());
197 }
198
199 /**
200 * @tc.name : Test UnregisterAudioRendererEventListener API
201 * @tc.number: Audio_Stream_Change_Listner_UnregisterAudioRendererEventListener_001
202 * @tc.desc : Test UnregisterAudioRendererEventListener interface with valid parameters
203 */
204 HWTEST(AudioStreamManagerUnitTest, Audio_Stream_Change_Listner_UnregisterAudioRendererEventListener_001,
205 TestSize.Level0)
206 {
207 int callBackSetResult = -1;
208 int callBackUnSetResult = -1;
209 std::string testCaseName("Audio_Stream_Change_Listner_UnregisterAudioRendererEventListener_001");
210
211 auto audioRendererStateChangeCallbackTest2 = make_shared<AudioRendererStateChangeCallbackTest>(testCaseName);
212 callBackSetResult = g_audioManagerInstance->RegisterAudioRendererEventListener(getpid(),
213 audioRendererStateChangeCallbackTest2);
214 EXPECT_EQ(SUCCESS, callBackSetResult);
215
216 callBackUnSetResult = g_audioManagerInstance->UnregisterAudioRendererEventListener(getpid());
217 EXPECT_EQ(SUCCESS, callBackUnSetResult);
218 }
219
220 /**
221 * @tc.name : Test UnregisterAudioRendererEventListener API
222 * @tc.number: Audio_Stream_Change_Listner_UnregisterAudioRendererEventListener_002
223 * @tc.desc : Test UnregisterAudioRendererEventListener interface without Register event
224 */
225 HWTEST(AudioStreamManagerUnitTest, Audio_Stream_Change_Listner_UnregisterAudioRendererEventListener_002,
226 TestSize.Level1)
227 {
228 int callBackUnSetResult = -1;
229
230 callBackUnSetResult = g_audioManagerInstance->UnregisterAudioRendererEventListener(getpid());
231 EXPECT_EQ(SUCCESS, callBackUnSetResult);
232
233 callBackUnSetResult = g_audioManagerInstance->UnregisterAudioRendererEventListener(VALUE_NEGATIVE);
234 EXPECT_EQ(SUCCESS, callBackUnSetResult);
235 }
236
237 /**
238 * @tc.name : Test UnregisterAudioRendererEventListener API
239 * @tc.number: Audio_Stream_Change_Listner_UnregisterAudioRendererEventListener_003
240 * @tc.desc : Test UnregisterAudioRendererEventListener interface multiple register and unregister calls
241 */
242 HWTEST(AudioStreamManagerUnitTest, Audio_Stream_Change_Listner_UnregisterAudioRendererEventListener_003,
243 TestSize.Level1)
244 {
245 int callBackSetResult = -1;
246 int callBackUnSetResult = -1;
247 std::string testCaseName("Audio_Stream_Change_Listner_UnregisterAudioRendererEventListener_003");
248
249 auto audioRendererStateChangeCallbackTest = make_shared<AudioRendererStateChangeCallbackTest>(testCaseName);
250 callBackSetResult = g_audioManagerInstance->RegisterAudioRendererEventListener(getpid(),
251 audioRendererStateChangeCallbackTest);
252 EXPECT_EQ(SUCCESS, callBackSetResult);
253
254 callBackUnSetResult = g_audioManagerInstance->UnregisterAudioRendererEventListener(getpid());
255 EXPECT_EQ(SUCCESS, callBackUnSetResult);
256
257 callBackSetResult = g_audioManagerInstance->RegisterAudioRendererEventListener(getpid(), nullptr);
258 EXPECT_NE(SUCCESS, callBackSetResult);
259
260 auto audioRendererStateChangeCallbackTest2 = make_shared<AudioRendererStateChangeCallbackTest>(testCaseName);
261 callBackSetResult = g_audioManagerInstance->RegisterAudioRendererEventListener(getpid(),
262 audioRendererStateChangeCallbackTest2);
263 EXPECT_EQ(SUCCESS, callBackSetResult);
264
265 callBackUnSetResult = g_audioManagerInstance->UnregisterAudioRendererEventListener(getpid());
266 EXPECT_EQ(SUCCESS, callBackUnSetResult);
267
268 callBackUnSetResult = g_audioManagerInstance->UnregisterAudioRendererEventListener(getpid());
269 EXPECT_EQ(SUCCESS, callBackUnSetResult);
270 }
271
272 /**
273 * @tc.name : Test GetCurrentRendererChangeInfos API
274 * @tc.number: Audio_Stream_Change_Listner_GetCurrentRendererChangeInfos_001
275 * @tc.desc : Test GetCurrentRendererChangeInfos interface for single active stream information in prepared state
276 * RENDERER_PREPARED:1, RENDERER_RUNNING:2, RENDERER_STOPPED:3, RENDERER_RELEASED:4, RENDERER_PAUSED:5
277 */
278 HWTEST(AudioStreamManagerUnitTest, Audio_Stream_Change_Listner_GetCurrentRendererChangeInfos_001, TestSize.Level0)
279 {
280 int32_t ret = -1;
281 AudioRendererOptions rendererOptions;
282 vector<unique_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
283
284 AudioStreamManagerUnitTest::InitializeRendererOptions(rendererOptions);
285 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
286 ASSERT_NE(nullptr, audioRenderer);
287
288 ret = AudioStreamManager::GetInstance()->GetCurrentRendererChangeInfos(audioRendererChangeInfos);
289 EXPECT_EQ(SUCCESS, ret);
290 EXPECT_EQ(1, static_cast<int32_t>(audioRendererChangeInfos.size()));
291 EXPECT_EQ(1, audioRendererChangeInfos[0]->rendererState);
292 audioRendererChangeInfos.clear();
293 bool isReleased = audioRenderer->Release();
294 EXPECT_EQ(true, isReleased);
295 std::this_thread::sleep_for(std::chrono::seconds(WAIT_TIME));
296 ret = AudioStreamManager::GetInstance()->GetCurrentRendererChangeInfos(audioRendererChangeInfos);
297 EXPECT_EQ(SUCCESS, ret);
298 EXPECT_EQ(0, static_cast<int32_t>(audioRendererChangeInfos.size()));
299 }
300
301 /**
302 * @tc.name : Test GetCurrentRendererChangeInfos API
303 * @tc.number: Audio_Stream_Change_Listner_GetCurrentRendererChangeInfos_002
304 * @tc.desc : Test GetCurrentRendererChangeInfos interface while no streams active
305 * RENDERER_PREPARED:1, RENDERER_RUNNING:2, RENDERER_STOPPED:3, RENDERER_RELEASED:4, RENDERER_PAUSED:5
306 */
307 HWTEST(AudioStreamManagerUnitTest, Audio_Stream_Change_Listner_GetCurrentRendererChangeInfos_002, TestSize.Level1)
308 {
309 int32_t ret = -1;
310 vector<unique_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
311
312 ret = AudioStreamManager::GetInstance()->GetCurrentRendererChangeInfos(audioRendererChangeInfos);
313 EXPECT_EQ(SUCCESS, ret);
314 EXPECT_EQ(0, static_cast<int32_t>(audioRendererChangeInfos.size()));
315 }
316
317 /**
318 * @tc.name : Test GetCurrentRendererChangeInfos API
319 * @tc.number: Audio_Stream_Change_Listner_GetCurrentRendererChangeInfos_003
320 * @tc.desc : Test GetCurrentRendererChangeInfos interface for single active renderer stream in running state
321 * RENDERER_PREPARED:1, RENDERER_RUNNING:2, RENDERER_STOPPED:3, RENDERER_RELEASED:4, RENDERER_PAUSED:5
322 */
323 HWTEST(AudioStreamManagerUnitTest, Audio_Stream_Change_Listner_GetCurrentRendererChangeInfos_003, TestSize.Level1)
324 {
325 int32_t ret = -1;
326 AudioRendererOptions rendererOptions;
327 vector<unique_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
328
329 AudioStreamManagerUnitTest::InitializeRendererOptions(rendererOptions);
330 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
331 ASSERT_NE(nullptr, audioRenderer);
332
333 bool isStarted = audioRenderer->Start();
334 EXPECT_EQ(true, isStarted);
335 ret = AudioStreamManager::GetInstance()->GetCurrentRendererChangeInfos(audioRendererChangeInfos);
336 EXPECT_EQ(SUCCESS, ret);
337 EXPECT_EQ(1, static_cast<int32_t>(audioRendererChangeInfos.size()));
338 EXPECT_EQ(2, audioRendererChangeInfos[0]->rendererState);
339
340 bool isStopped = audioRenderer->Stop();
341 EXPECT_EQ(true, isStopped);
342
343 bool isReleased = audioRenderer->Release();
344 EXPECT_EQ(true, isReleased);
345 audioRendererChangeInfos.clear();
346 std::this_thread::sleep_for(std::chrono::seconds(WAIT_TIME));
347 ret = AudioStreamManager::GetInstance()->GetCurrentRendererChangeInfos(audioRendererChangeInfos);
348 EXPECT_EQ(SUCCESS, ret);
349 EXPECT_EQ(0, static_cast<int32_t>(audioRendererChangeInfos.size()));
350 }
351
352 /**
353 * @tc.name : Test GetCurrentRendererChangeInfos API
354 * @tc.number: Audio_Stream_Change_Listner_GetCurrentRendererChangeInfos_004
355 * @tc.desc : Test GetCurrentRendererChangeInfos interface for single active renderer stream in stopped state
356 * RENDERER_PREPARED:1, RENDERER_RUNNING:2, RENDERER_STOPPED:3, RENDERER_RELEASED:4, RENDERER_PAUSED:5
357 */
358 HWTEST(AudioStreamManagerUnitTest, Audio_Stream_Change_Listner_GetCurrentRendererChangeInfos_004, TestSize.Level1)
359 {
360 int32_t ret = -1;
361 AudioRendererOptions rendererOptions;
362 vector<unique_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
363
364 AudioStreamManagerUnitTest::InitializeRendererOptions(rendererOptions);
365 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
366 ASSERT_NE(nullptr, audioRenderer);
367
368 bool isStarted = audioRenderer->Start();
369 EXPECT_EQ(true, isStarted);
370
371 bool isStopped = audioRenderer->Stop();
372 EXPECT_EQ(true, isStopped);
373 ret = AudioStreamManager::GetInstance()->GetCurrentRendererChangeInfos(audioRendererChangeInfos);
374 EXPECT_EQ(1, static_cast<int32_t>(audioRendererChangeInfos.size()));
375 EXPECT_EQ(3, audioRendererChangeInfos[0]->rendererState);
376
377 bool isReleased = audioRenderer->Release();
378 EXPECT_EQ(true, isReleased);
379 audioRendererChangeInfos.clear();
380 std::this_thread::sleep_for(std::chrono::seconds(WAIT_TIME));
381 ret = AudioStreamManager::GetInstance()->GetCurrentRendererChangeInfos(audioRendererChangeInfos);
382 EXPECT_EQ(SUCCESS, ret);
383 EXPECT_EQ(0, static_cast<int32_t>(audioRendererChangeInfos.size()));
384 }
385
386 /**
387 * @tc.name : Test GetCurrentRendererChangeInfos API
388 * @tc.number: Audio_Stream_Change_Listner_GetCurrentRendererChangeInfos_005
389 * @tc.desc : Test GetCurrentRendererChangeInfos interface for single active renderer stream in released state
390 * RENDERER_PREPARED:1, RENDERER_RUNNING:2, RENDERER_STOPPED:3, RENDERER_RELEASED:4, RENDERER_PAUSED:5
391 */
392 HWTEST(AudioStreamManagerUnitTest, Audio_Stream_Change_Listner_GetCurrentRendererChangeInfos_005, TestSize.Level1)
393 {
394 int32_t ret = -1;
395 AudioRendererOptions rendererOptions;
396 vector<unique_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
397
398 AudioStreamManagerUnitTest::InitializeRendererOptions(rendererOptions);
399 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
400 ASSERT_NE(nullptr, audioRenderer);
401
402 bool isStarted = audioRenderer->Start();
403 EXPECT_EQ(true, isStarted);
404
405 bool isStopped = audioRenderer->Stop();
406 EXPECT_EQ(true, isStopped);
407
408 bool isReleased = audioRenderer->Release();
409 EXPECT_EQ(true, isReleased);
410 std::this_thread::sleep_for(std::chrono::seconds(WAIT_TIME));
411 ret = AudioStreamManager::GetInstance()->GetCurrentRendererChangeInfos(audioRendererChangeInfos);
412 EXPECT_EQ(SUCCESS, ret);
413 EXPECT_EQ(0, static_cast<int32_t>(audioRendererChangeInfos.size()));
414 }
415
416 /**
417 * @tc.name : Test GetCurrentRendererChangeInfos API
418 * @tc.number: Audio_Stream_Change_Listner_GetCurrentRendererChangeInfos_006
419 * @tc.desc : Test GetCurrentRendererChangeInfos interface for two active renderer stream information
420 * RENDERER_PREPARED:1, RENDERER_RUNNING:2, RENDERER_STOPPED:3, RENDERER_RELEASED:4, RENDERER_PAUSED:5
421 */
422 HWTEST(AudioStreamManagerUnitTest, Audio_Stream_Change_Listner_GetCurrentRendererChangeInfos_006, TestSize.Level1)
423 {
424 int32_t ret = -1;
425 AudioRendererOptions rendererOptions;
426 vector<unique_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
427
428 AudioStreamManagerUnitTest::InitializeRendererOptions(rendererOptions);
429 unique_ptr<AudioRenderer> audioRenderer1 = AudioRenderer::Create(rendererOptions);
430 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
431 ASSERT_NE(nullptr, audioRenderer1);
432 ASSERT_NE(nullptr, audioRenderer);
433
434 bool isStarted = audioRenderer1->Start();
435 EXPECT_EQ(true, isStarted);
436 isStarted = audioRenderer->Start();
437 EXPECT_EQ(true, isStarted);
438
439 audioRendererChangeInfos.clear();
440 ret = AudioStreamManager::GetInstance()->GetCurrentRendererChangeInfos(audioRendererChangeInfos);
441 EXPECT_EQ(SUCCESS, ret);
442 EXPECT_EQ(2, static_cast<int32_t>(audioRendererChangeInfos.size()));
443 EXPECT_EQ(2, audioRendererChangeInfos[0]->rendererState);
444 EXPECT_EQ(2, audioRendererChangeInfos[1]->rendererState);
445
446 bool isStopped = audioRenderer1->Stop();
447 EXPECT_EQ(true, isStopped);
448
449 audioRendererChangeInfos.clear();
450 ret = AudioStreamManager::GetInstance()->GetCurrentRendererChangeInfos(audioRendererChangeInfos);
451 EXPECT_EQ(SUCCESS, ret);
452 EXPECT_EQ(2, static_cast<int32_t>(audioRendererChangeInfos.size()));
453 EXPECT_EQ(3, audioRendererChangeInfos[0]->rendererState);
454 EXPECT_EQ(2, audioRendererChangeInfos[1]->rendererState);
455
456 isStopped = audioRenderer->Stop();
457 EXPECT_EQ(true, isStopped);
458
459 bool isReleased = audioRenderer1->Release();
460 EXPECT_EQ(true, isReleased);
461
462 isReleased = audioRenderer->Release();
463 EXPECT_EQ(true, isReleased);
464
465 std::this_thread::sleep_for(std::chrono::seconds(WAIT_TIME));
466 audioRendererChangeInfos.clear();
467 ret = AudioStreamManager::GetInstance()->GetCurrentRendererChangeInfos(audioRendererChangeInfos);
468 EXPECT_EQ(SUCCESS, ret);
469 EXPECT_EQ(0, static_cast<int32_t>(audioRendererChangeInfos.size()));
470 }
471
472 /**
473 * @tc.name : Test GetCurrentRendererChangeInfos API
474 * @tc.number: Audio_Stream_Change_Listner_GetCurrentRendererChangeInfos_007
475 * @tc.desc : Test GetCurrentRendererChangeInfos interface to display streams details
476 * RENDERER_PREPARED:1, RENDERER_RUNNING:2, RENDERER_STOPPED:3, RENDERER_RELEASED:4, RENDERER_PAUSED:5
477 */
478 HWTEST(AudioStreamManagerUnitTest, Audio_Stream_Change_Listner_GetCurrentRendererChangeInfos_007, TestSize.Level1)
479 {
480 int32_t ret = -1;
481 vector<unique_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
482
483 ret = AudioStreamManager::GetInstance()->GetCurrentRendererChangeInfos(audioRendererChangeInfos);
484 EXPECT_EQ(SUCCESS, ret);
485
486 if (audioRendererChangeInfos.size() > 0) {
487 AUDIO_DEBUG_LOG("AudioStreamManagerTest: audioRendererChangeInfos Number of entries %{public}u",
488 static_cast<int32_t>(audioRendererChangeInfos.size()));
489 uint32_t index = 0;
490 for (auto it = audioRendererChangeInfos.begin(); it != audioRendererChangeInfos.end(); it++) {
491 AudioRendererChangeInfo audioRendererChangeInfo = **it;
492 AUDIO_DEBUG_LOG("audioRendererChangeInfos[%{public}d]", index++);
493 AUDIO_DEBUG_LOG("clientUID = %{public}d", audioRendererChangeInfo.clientUID);
494 AUDIO_DEBUG_LOG("sessionId = %{public}d", audioRendererChangeInfo.sessionId);
495 AUDIO_DEBUG_LOG("rendererState = %{public}d", audioRendererChangeInfo.rendererState);
496 }
497 } else {
498 AUDIO_DEBUG_LOG("AudioStreamManagerTest: audioRendererChangeInfos: No Active Streams");
499 }
500 }
501
502 /**
503 * @tc.name : Test GetCurrentRendererChangeInfos API
504 * @tc.number: Audio_Stream_Change_Listner_GetCurrentRendererChangeInfos_Stability_001
505 * @tc.desc : Test GetCurrentRendererChangeInfos interface for single active renderer stream in running state
506 * RENDERER_PREPARED:1, RENDERER_RUNNING:2, RENDERER_STOPPED:3, RENDERER_RELEASED:4, RENDERER_PAUSED:5
507 */
508 HWTEST(AudioStreamManagerUnitTest, Audio_Stream_Change_Listner_GetCurrentRendererChangeInfos_Stability_001,
509 TestSize.Level1)
510 {
511 int32_t ret = -1;
512 AudioRendererOptions rendererOptions;
513 vector<unique_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
514
515 AudioStreamManagerUnitTest::InitializeRendererOptions(rendererOptions);
516 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
517 ASSERT_NE(nullptr, audioRenderer);
518
519 bool isStarted = audioRenderer->Start();
520 EXPECT_EQ(true, isStarted);
521
522 for (int32_t i = 0; i < VALUE_HUNDRED; i++) {
523 ret = AudioStreamManager::GetInstance()->GetCurrentRendererChangeInfos(audioRendererChangeInfos);
524 EXPECT_EQ(SUCCESS, ret);
525 EXPECT_EQ(1, static_cast<int32_t>(audioRendererChangeInfos.size()));
526 EXPECT_EQ(2, audioRendererChangeInfos[0]->rendererState);
527 audioRendererChangeInfos.clear();
528 }
529
530 bool isStopped = audioRenderer->Stop();
531 EXPECT_EQ(true, isStopped);
532
533 bool isReleased = audioRenderer->Release();
534 EXPECT_EQ(true, isReleased);
535 audioRendererChangeInfos.clear();
536 std::this_thread::sleep_for(std::chrono::seconds(WAIT_TIME));
537 ret = AudioStreamManager::GetInstance()->GetCurrentRendererChangeInfos(audioRendererChangeInfos);
538 EXPECT_EQ(SUCCESS, ret);
539 EXPECT_EQ(0, static_cast<int32_t>(audioRendererChangeInfos.size()));
540 }
541
542 /**
543 * @tc.name : Test GetCurrentRendererChangeInfos API
544 * @tc.number: Audio_Stream_Change_Listner_GetCurrentRendererChangeDeviceInfos_001
545 * @tc.desc : Test GetCurrentRendererChangeInfos interface for getting device information for current stream
546 */
547 HWTEST(AudioStreamManagerUnitTest, Audio_Stream_Change_Listner_GetCurrentRendererChangeDeviceInfos_001,
548 TestSize.Level1)
549 {
550 int32_t ret = -1;
551 AudioRendererOptions rendererOptions;
552 vector<unique_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
553
554 AudioStreamManagerUnitTest::InitializeRendererOptions(rendererOptions);
555 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
556 ASSERT_NE(nullptr, audioRenderer);
557
558 bool isStarted = audioRenderer->Start();
559 EXPECT_EQ(true, isStarted);
560
561 for (int32_t i = 0; i < VALUE_HUNDRED; i++) {
562 ret = AudioStreamManager::GetInstance()->GetCurrentRendererChangeInfos(audioRendererChangeInfos);
563 EXPECT_EQ(SUCCESS, ret);
564 EXPECT_EQ(1, static_cast<int32_t>(audioRendererChangeInfos.size()));
565 EXPECT_EQ(2, audioRendererChangeInfos[0]->rendererState);
566 EXPECT_EQ(audioRendererChangeInfos[0]->outputDeviceInfo.deviceRole, DeviceRole::OUTPUT_DEVICE);
567 EXPECT_EQ(audioRendererChangeInfos[0]->outputDeviceInfo.deviceType, DeviceType::DEVICE_TYPE_SPEAKER);
568 EXPECT_GE(audioRendererChangeInfos[0]->outputDeviceInfo.deviceId, MIN_DEVICE_ID);
569 EXPECT_EQ(true, (audioRendererChangeInfos[0]->outputDeviceInfo.audioStreamInfo.samplingRate >= SAMPLE_RATE_8000)
570 || ((audioRendererChangeInfos[0]->outputDeviceInfo.audioStreamInfo.samplingRate <= SAMPLE_RATE_96000)));
571 EXPECT_EQ(audioRendererChangeInfos[0]->outputDeviceInfo.audioStreamInfo.encoding,
572 AudioEncodingType::ENCODING_PCM);
573 EXPECT_EQ(true, (audioRendererChangeInfos[0]->outputDeviceInfo.audioStreamInfo.channels >= MONO)
574 && ((audioRendererChangeInfos[0]->outputDeviceInfo.audioStreamInfo.channels <= CHANNEL_8)));
575 EXPECT_EQ(true, (audioRendererChangeInfos[0]->outputDeviceInfo.audioStreamInfo.format >= SAMPLE_U8)
576 && ((audioRendererChangeInfos[0]->outputDeviceInfo.audioStreamInfo.format <= SAMPLE_F32LE)));
577 audioRendererChangeInfos.clear();
578 }
579
580 bool isStopped = audioRenderer->Stop();
581 EXPECT_EQ(true, isStopped);
582
583 bool isReleased = audioRenderer->Release();
584 EXPECT_EQ(true, isReleased);
585 audioRendererChangeInfos.clear();
586 std::this_thread::sleep_for(std::chrono::seconds(WAIT_TIME));
587 ret = AudioStreamManager::GetInstance()->GetCurrentRendererChangeInfos(audioRendererChangeInfos);
588 EXPECT_EQ(SUCCESS, ret);
589 EXPECT_EQ(0, static_cast<int32_t>(audioRendererChangeInfos.size()));
590 }
591
592 /**
593 * @tc.name : Test Feature RendererStateChangeCallback
594 * @tc.number: Audio_Stream_Change_Listner_RendererStateChangeCallbackTest_001
595 * @tc.desc : Test RendererStateChangeCallback interface in prepared state
596 * RENDERER_PREPARED:1, RENDERER_RUNNING:2, RENDERER_STOPPED:3, RENDERER_RELEASED:4, RENDERER_PAUSED:5
597 */
598 HWTEST(AudioStreamManagerUnitTest, Audio_Stream_Change_Listner_RendererStateChangeCallbackTest_001, TestSize.Level0)
599 {
600 int32_t ret = -1;
601 int callBackSetResult;
602 std::string testCaseName("Audio_Stream_Change_Listner_RendererStateChangeCallbackTest_001");
603 vector<unique_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
604
605 g_callbackName = testCaseName;
606
607 auto audioRendererStateChangeCallbackTest = make_shared<AudioRendererStateChangeCallbackTest>(testCaseName);
608 callBackSetResult = g_audioManagerInstance->RegisterAudioRendererEventListener(getpid(),
609 audioRendererStateChangeCallbackTest);
610 EXPECT_EQ(SUCCESS, callBackSetResult);
611
612 AudioRendererOptions rendererOptions;
613 AudioStreamManagerUnitTest::InitializeRendererOptions(rendererOptions);
614 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
615 ASSERT_NE(nullptr, audioRenderer);
616 std::this_thread::sleep_for(std::chrono::seconds(WAIT_TIME));
617 if (audioRenderer != nullptr) {
618 // Wait here for callback. If not callback for 2 mintues, will skip this step
619 AudioStreamManagerUnitTest::WaitForCallback();
620 g_isCallbackReceived = false;
621 EXPECT_EQ(1, static_cast<int32_t>(g_audioRendererChangeInfosRcvd.size()));
622 EXPECT_EQ(1, g_audioRendererChangeInfosRcvd[0]->rendererState);
623 EXPECT_STREQ(g_callbackName.c_str(), testCaseName.c_str());
624 }
625
626 bool isStarted = audioRenderer->Start();
627 EXPECT_EQ(true, isStarted);
628
629 bool isStopped = audioRenderer->Stop();
630 EXPECT_EQ(true, isStopped);
631
632 bool isReleased = audioRenderer->Release();
633 EXPECT_EQ(true, isReleased);
634
635 std::this_thread::sleep_for(std::chrono::seconds(WAIT_TIME));
636 ret = AudioStreamManager::GetInstance()->GetCurrentRendererChangeInfos(audioRendererChangeInfos);
637 EXPECT_EQ(SUCCESS, ret);
638 EXPECT_EQ(0, static_cast<int32_t>(audioRendererChangeInfos.size()));
639
640 std::this_thread::sleep_for(std::chrono::seconds(WAIT_TIME));
641 g_audioManagerInstance->UnregisterAudioRendererEventListener(getpid());
642 }
643
644 /**
645 * @tc.name : Test Feature RendererStateChangeCallback
646 * @tc.number: Audio_Stream_Change_Listner_RendererStateChangeCallbackTest_002
647 * @tc.desc : Test RendererStateChangeCallback interface in running state
648 * RENDERER_PREPARED:1, RENDERER_RUNNING:2, RENDERER_STOPPED:3, RENDERER_RELEASED:4, RENDERER_PAUSED:5
649 */
650 HWTEST(AudioStreamManagerUnitTest, Audio_Stream_Change_Listner_RendererStateChangeCallbackTest_002, TestSize.Level1)
651 {
652 int32_t ret = -1;
653 int callBackSetResult;
654 std::string testCaseName("Audio_Stream_Change_Listner_RendererStateChangeCallbackTest_002");
655 vector<unique_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
656
657 g_callbackName = testCaseName;
658
659 auto audioRendererStateChangeCallbackTest = make_shared<AudioRendererStateChangeCallbackTest>(testCaseName);
660 callBackSetResult = g_audioManagerInstance->RegisterAudioRendererEventListener(getpid(),
661 audioRendererStateChangeCallbackTest);
662 EXPECT_EQ(SUCCESS, callBackSetResult);
663
664 AudioRendererOptions rendererOptions;
665 AudioStreamManagerUnitTest::InitializeRendererOptions(rendererOptions);
666 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
667 ASSERT_NE(nullptr, audioRenderer);
668
669 bool isStarted = audioRenderer->Start();
670 EXPECT_EQ(true, isStarted);
671 if (isStarted == SUCCESS) {
672 // Wait here for callback. If not callback for 2 mintues, will skip this step
673 AudioStreamManagerUnitTest::WaitForCallback();
674 g_isCallbackReceived = false;
675 EXPECT_EQ(SUCCESS, ret);
676 EXPECT_EQ(1, static_cast<int32_t>(g_audioRendererChangeInfosRcvd.size()));
677 EXPECT_EQ(2, g_audioRendererChangeInfosRcvd[0]->rendererState);
678 EXPECT_STREQ(g_callbackName.c_str(), testCaseName.c_str());
679 }
680
681 bool isStopped = audioRenderer->Stop();
682 EXPECT_EQ(true, isStopped);
683
684 bool isReleased = audioRenderer->Release();
685 EXPECT_EQ(true, isReleased);
686
687 ret = AudioStreamManager::GetInstance()->GetCurrentRendererChangeInfos(audioRendererChangeInfos);
688 EXPECT_EQ(SUCCESS, ret);
689 EXPECT_EQ(0, static_cast<int32_t>(audioRendererChangeInfos.size()));
690
691 std::this_thread::sleep_for(std::chrono::seconds(WAIT_TIME));
692 g_audioManagerInstance->UnregisterAudioRendererEventListener(getpid());
693 }
694
695 /**
696 * @tc.name : Test Feature RendererStateChangeCallback
697 * @tc.number: Audio_Stream_Change_Listner_RendererStateChangeCallbackTest_003
698 * @tc.desc : Test RendererStateChangeCallback interface in stop state
699 * RENDERER_PREPARED:1, RENDERER_RUNNING:2, RENDERER_STOPPED:3, RENDERER_RELEASED:4, RENDERER_PAUSED:5
700 */
701 HWTEST(AudioStreamManagerUnitTest, Audio_Stream_Change_Listner_RendererStateChangeCallbackTest_003, TestSize.Level1)
702 {
703 int32_t ret = -1;
704 int callBackSetResult;
705 std::string testCaseName("Audio_Stream_Change_Listner_RendererStateChangeCallbackTest_003");
706 AudioRendererOptions rendererOptions;
707 vector<unique_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
708
709 g_callbackName = testCaseName;
710
711 AudioStreamManagerUnitTest::InitializeRendererOptions(rendererOptions);
712 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
713 ASSERT_NE(nullptr, audioRenderer);
714
715 auto audioRendererStateChangeCallbackTest = make_shared<AudioRendererStateChangeCallbackTest>(testCaseName);
716 callBackSetResult = g_audioManagerInstance->RegisterAudioRendererEventListener(getpid(),
717 audioRendererStateChangeCallbackTest);
718
719 bool isStarted = audioRenderer->Start();
720 EXPECT_EQ(true, isStarted);
721
722 bool isStopped = audioRenderer->Stop();
723 EXPECT_EQ(true, isStopped);
724 if (isStopped == SUCCESS) {
725 // Wait here for callback. If not callback for 2 mintues, will skip this step
726 AudioStreamManagerUnitTest::WaitForCallback();
727 g_isCallbackReceived = false;
728 EXPECT_EQ(SUCCESS, ret);
729 EXPECT_EQ(1, static_cast<int32_t>(g_audioRendererChangeInfosRcvd.size()));
730 EXPECT_EQ(3, g_audioRendererChangeInfosRcvd[0]->rendererState);
731 EXPECT_STREQ(g_callbackName.c_str(), testCaseName.c_str());
732 }
733
734 bool isReleased = audioRenderer->Release();
735 EXPECT_EQ(true, isReleased);
736
737 ret = AudioStreamManager::GetInstance()->GetCurrentRendererChangeInfos(audioRendererChangeInfos);
738 EXPECT_EQ(SUCCESS, ret);
739 EXPECT_EQ(0, static_cast<int32_t>(audioRendererChangeInfos.size()));
740
741 std::this_thread::sleep_for(std::chrono::seconds(WAIT_TIME));
742 g_audioManagerInstance->UnregisterAudioRendererEventListener(getpid());
743 }
744
745 /**
746 * @tc.name : Test Feature RendererStateChangeCallback
747 * @tc.number: Audio_Stream_Change_Listner_RendererStateChangeCallbackTest_001
748 * @tc.desc : Test RendererStateChangeCallback interface in release state
749 * RENDERER_PREPARED:1, RENDERER_RUNNING:2, RENDERER_STOPPED:3, RENDERER_RELEASED:4, RENDERER_PAUSED:5
750 */
751 HWTEST(AudioStreamManagerUnitTest, Audio_Stream_Change_Listner_RendererStateChangeCallbackTest_004, TestSize.Level1)
752 {
753 int32_t ret = -1;
754 int callBackSetResult;
755 std::string testCaseName("Audio_Stream_Change_Listner_RendererStateChangeCallbackTest_004");
756 AudioRendererOptions rendererOptions;
757 vector<unique_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
758
759 g_callbackName = testCaseName;
760
761 AudioStreamManagerUnitTest::InitializeRendererOptions(rendererOptions);
762 unique_ptr<AudioRenderer> audioRenderer = AudioRenderer::Create(rendererOptions);
763 ASSERT_NE(nullptr, audioRenderer);
764
765 auto audioRendererStateChangeCallbackTest = make_shared<AudioRendererStateChangeCallbackTest>(testCaseName);
766 callBackSetResult = g_audioManagerInstance->RegisterAudioRendererEventListener(getpid(),
767 audioRendererStateChangeCallbackTest);
768
769 bool isStarted = audioRenderer->Start();
770 EXPECT_EQ(true, isStarted);
771
772 bool isStopped = audioRenderer->Stop();
773 EXPECT_EQ(true, isStopped);
774
775 bool isReleased = audioRenderer->Release();
776 EXPECT_EQ(true, isReleased);
777 if (isStarted == SUCCESS) {
778 // Wait here for callback. If not callback for 2 mintues, will skip this step
779 g_isCallbackReceived = false;
780 AudioStreamManagerUnitTest::WaitForCallback();
781 EXPECT_EQ(SUCCESS, ret);
782 EXPECT_EQ(1, static_cast<int32_t>(g_audioRendererChangeInfosRcvd.size()));
783 EXPECT_EQ(4, g_audioRendererChangeInfosRcvd[0]->rendererState);
784 EXPECT_STREQ(g_callbackName.c_str(), testCaseName.c_str());
785 }
786
787 ret = AudioStreamManager::GetInstance()->GetCurrentRendererChangeInfos(audioRendererChangeInfos);
788 EXPECT_EQ(SUCCESS, ret);
789 EXPECT_EQ(0, static_cast<int32_t>(audioRendererChangeInfos.size()));
790
791 std::this_thread::sleep_for(std::chrono::seconds(WAIT_TIME));
792 g_audioManagerInstance->UnregisterAudioRendererEventListener(getpid());
793 }
794
795 // Capturer Listener Unit Cases
796 /**
797 * @tc.name : Test RegisterAudioCapturerEventListener API
798 * @tc.number: Audio_Stream_Change_Listner_RegisterAudioCapturerEventListener_001
799 * @tc.desc : Test RegisterAudioCapturerEventListener interface with valid parameters
800 */
801 HWTEST(AudioStreamManagerUnitTest, Audio_Stream_Change_Listner_RegisterAudioCapturerEventListener_001, TestSize.Level0)
802 {
803 int callBackSetResult = -1;
804 std::string testCaseName("Audio_Stream_Change_Listner_RegisterAudioCapturerEventListener_001");
805
806 vector<unique_ptr<AudioCapturerChangeInfo>> audioCapturerChangeInfos;
807
808 auto audioCapturerStateChangeCallbackTest = make_shared<AudioCapturerStateChangeCallbackTest>(testCaseName);
809 callBackSetResult = g_audioManagerInstance->RegisterAudioCapturerEventListener(getpid(),
810 audioCapturerStateChangeCallbackTest);
811 EXPECT_EQ(SUCCESS, callBackSetResult);
812
813 g_audioManagerInstance->UnregisterAudioCapturerEventListener(getpid());
814 }
815
816 /**
817 * @tc.name : Test RegisterAudioCapturerEventListener API
818 * @tc.number: Audio_Stream_Change_Listner_RegisterAudioCapturerEventListener_002
819 * @tc.desc : Test RegisterAudioCapturerEventListener interface after unregister
820 */
821 HWTEST(AudioStreamManagerUnitTest, Audio_Stream_Change_Listner_RegisterAudioCapturerEventListener_002, TestSize.Level1)
822 {
823 int callBackSetResult = -1;
824 std::string testCaseName("Audio_Stream_Change_Listner_RegisterAudioCapturerEventListener_002");
825
826 vector<unique_ptr<AudioCapturerChangeInfo>> audioCapturerChangeInfos;
827
828 auto audioCapturerStateChangeCallbackTest = make_shared<AudioCapturerStateChangeCallbackTest>(testCaseName);
829 callBackSetResult = g_audioManagerInstance->RegisterAudioCapturerEventListener(getpid(),
830 audioCapturerStateChangeCallbackTest);
831 EXPECT_EQ(SUCCESS, callBackSetResult);
832
833 g_audioManagerInstance->UnregisterAudioCapturerEventListener(getpid());
834
835 auto audioCapturerStateChangeCallbackTest2 = make_shared<AudioCapturerStateChangeCallbackTest>(testCaseName);
836 callBackSetResult = g_audioManagerInstance->RegisterAudioCapturerEventListener(getpid(),
837 audioCapturerStateChangeCallbackTest2);
838 EXPECT_EQ(SUCCESS, callBackSetResult);
839
840 g_audioManagerInstance->UnregisterAudioCapturerEventListener(getpid());
841 }
842
843 /**
844 * @tc.name : Test RegisterAudioCapturerEventListener API
845 * @tc.number: Audio_Stream_Change_Listner_RegisterAudioCapturerEventListener_003
846 * @tc.desc : Test RegisterAudioCapturerEventListener interface with null callback
847 */
848 HWTEST(AudioStreamManagerUnitTest, Audio_Stream_Change_Listner_RegisterAudioCapturerEventListener_003, TestSize.Level1)
849 {
850 int callBackSetResult = -1;
851
852 callBackSetResult = g_audioManagerInstance->RegisterAudioCapturerEventListener(getpid(), nullptr);
853 EXPECT_NE(SUCCESS, callBackSetResult);
854 }
855
856 /**
857 * @tc.name : Test RegisterAudioCapturerEventListener API
858 * @tc.number: Audio_Stream_Change_Listner_RegisterAudioCapturerEventListener_004
859 * @tc.desc : Test RegisterAudioCapturerEventListener interface with valid parameter after nullptr callback
860 */
861 HWTEST(AudioStreamManagerUnitTest, Audio_Stream_Change_Listner_RegisterAudioCapturerEventListener_004, TestSize.Level1)
862 {
863 int callBackSetResult = -1;
864 std::string testCaseName("Audio_Stream_Change_Listner_RegisterAudioCapturerEventListener_004");
865
866 callBackSetResult = g_audioManagerInstance->RegisterAudioCapturerEventListener(getpid(), nullptr);
867 EXPECT_NE(SUCCESS, callBackSetResult);
868
869 auto audioCapturerStateChangeCallbackTest2 = make_shared<AudioCapturerStateChangeCallbackTest>(testCaseName);
870 callBackSetResult = g_audioManagerInstance->RegisterAudioCapturerEventListener(getpid(),
871 audioCapturerStateChangeCallbackTest2);
872 EXPECT_EQ(SUCCESS, callBackSetResult);
873
874 g_audioManagerInstance->UnregisterAudioCapturerEventListener(getpid());
875 }
876
877 /**
878 * @tc.name : Test UnregisterAudioCapturerEventListener API
879 * @tc.number: Audio_Stream_Change_Listner_UnregisterAudioCapturerEventListener_001
880 * @tc.desc : Test UnregisterAudioCapturerEventListener interface with valid parameters
881 */
882 HWTEST(AudioStreamManagerUnitTest, Audio_Stream_Change_Listner_UnregisterAudioCapturerEventListener_001,
883 TestSize.Level0)
884 {
885 int callBackSetResult = -1;
886 int callBackUnSetResult = -1;
887 std::string testCaseName("Audio_Stream_Change_Listner_UnregisterAudioCapturerEventListener_001");
888
889 vector<unique_ptr<AudioCapturerChangeInfo>> audioCapturerChangeInfos;
890
891 callBackSetResult = g_audioManagerInstance->RegisterAudioCapturerEventListener(getpid(), nullptr);
892 EXPECT_NE(SUCCESS, callBackSetResult);
893
894 auto audioCapturerStateChangeCallbackTest2 = make_shared<AudioCapturerStateChangeCallbackTest>(testCaseName);
895 callBackSetResult = g_audioManagerInstance->RegisterAudioCapturerEventListener(getpid(),
896 audioCapturerStateChangeCallbackTest2);
897 EXPECT_EQ(SUCCESS, callBackSetResult);
898
899 callBackUnSetResult = g_audioManagerInstance->UnregisterAudioCapturerEventListener(getpid());
900 EXPECT_EQ(SUCCESS, callBackUnSetResult);
901 }
902
903 /**
904 * @tc.name : Test UnregisterAudioCapturerEventListener API
905 * @tc.number: Audio_Stream_Change_Listner_UnregisterAudioCapturerEventListener_002
906 * @tc.desc : Test UnregisterAudioCapturerEventListener interface without register event
907 */
908 HWTEST(AudioStreamManagerUnitTest, Audio_Stream_Change_Listner_UnregisterAudioCapturerEventListener_002,
909 TestSize.Level1)
910 {
911 int callBackUnSetResult = -1;
912
913 callBackUnSetResult = g_audioManagerInstance->UnregisterAudioCapturerEventListener(getpid());
914 EXPECT_EQ(SUCCESS, callBackUnSetResult);
915
916 callBackUnSetResult = g_audioManagerInstance->UnregisterAudioCapturerEventListener(VALUE_NEGATIVE);
917 EXPECT_EQ(SUCCESS, callBackUnSetResult);
918 }
919
920 /**
921 * @tc.name : Test UnregisterAudioCapturerEventListener API
922 * @tc.number: Audio_Stream_Change_Listner_UnregisterAudioCapturerEventListener_003
923 * @tc.desc : Test UnregisterAudioCapturerEventListener interface with multiple register and unregister
924 */
925 HWTEST(AudioStreamManagerUnitTest, Audio_Stream_Change_Listner_UnregisterAudioCapturerEventListener_003,
926 TestSize.Level1)
927 {
928 int callBackSetResult = -1;
929 int callBackUnSetResult = -1;
930 std::string testCaseName("Audio_Stream_Change_Listner_UnregisterAudioCapturerEventListener_003");
931
932 auto audioCapturerStateChangeCallbackTest = make_shared<AudioCapturerStateChangeCallbackTest>(testCaseName);
933 callBackSetResult = g_audioManagerInstance->RegisterAudioCapturerEventListener(getpid(),
934 audioCapturerStateChangeCallbackTest);
935 EXPECT_EQ(SUCCESS, callBackSetResult);
936
937 callBackUnSetResult = g_audioManagerInstance->UnregisterAudioCapturerEventListener(getpid());
938 EXPECT_EQ(SUCCESS, callBackUnSetResult);
939
940 callBackSetResult = g_audioManagerInstance->RegisterAudioCapturerEventListener(getpid(), nullptr);
941 EXPECT_NE(SUCCESS, callBackSetResult);
942
943 auto audioCapturerStateChangeCallbackTest2 = make_shared<AudioCapturerStateChangeCallbackTest>(testCaseName);
944 callBackSetResult = g_audioManagerInstance->RegisterAudioCapturerEventListener(getpid(),
945 audioCapturerStateChangeCallbackTest2);
946 EXPECT_EQ(SUCCESS, callBackSetResult);
947
948 callBackUnSetResult = g_audioManagerInstance->UnregisterAudioCapturerEventListener(getpid());
949 EXPECT_EQ(SUCCESS, callBackUnSetResult);
950
951 callBackUnSetResult = g_audioManagerInstance->UnregisterAudioCapturerEventListener(getpid());
952 EXPECT_EQ(SUCCESS, callBackUnSetResult);
953 }
954
955 /**
956 * @tc.name : Test GetCurrentCapturerChangeInfos API
957 * @tc.number: Audio_Stream_Change_Listner_GetCurrentCapturerChangeInfos_001
958 * @tc.desc : Test GetCurrentCapturerChangeInfos interface for single active stream in prepared state
959 * CAPTURER_PREPARED:1 CAPTURER_RUNNING:2 CAPTURER_STOPPED:3 CAPTURER_RELEASED:4 CAPTURER_PAUSED:5
960 */
961 HWTEST(AudioStreamManagerUnitTest, Audio_Stream_Change_Listner_GetCurrentCapturerChangeInfos_001, TestSize.Level0)
962 {
963 int32_t ret = -1;
964 AudioCapturerOptions capturerOptions;
965 vector<unique_ptr<AudioCapturerChangeInfo>> audioCapturerChangeInfos;
966
967 AudioStreamManagerUnitTest::InitializeCapturerOptions(capturerOptions);
968 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
969 ASSERT_NE(nullptr, audioCapturer);
970
971 ret = AudioStreamManager::GetInstance()->GetCurrentCapturerChangeInfos(audioCapturerChangeInfos);
972 EXPECT_EQ(SUCCESS, ret);
973 EXPECT_EQ(1, static_cast<int32_t>(audioCapturerChangeInfos.size()));
974 EXPECT_EQ(1, audioCapturerChangeInfos[0]->capturerState);
975 audioCapturerChangeInfos.clear();
976 bool isReleased = audioCapturer->Release();
977 EXPECT_EQ(true, isReleased);
978 std::this_thread::sleep_for(std::chrono::seconds(WAIT_TIME));
979 ret = AudioStreamManager::GetInstance()->GetCurrentCapturerChangeInfos(audioCapturerChangeInfos);
980 EXPECT_EQ(SUCCESS, ret);
981 EXPECT_EQ(0, static_cast<int32_t>(audioCapturerChangeInfos.size()));
982 }
983
984 /**
985 * @tc.name : Test GetCurrentCapturerChangeInfos API
986 * @tc.number: Audio_Stream_Change_Listner_GetCurrentCapturerChangeInfos_002
987 * @tc.desc : Test GetCurrentCapturerChangeInfos interface while no stream active
988 * CAPTURER_PREPARED:1 CAPTURER_RUNNING:2 CAPTURER_STOPPED:3 CAPTURER_RELEASED:4 CAPTURER_PAUSED:5
989 */
990 HWTEST(AudioStreamManagerUnitTest, Audio_Stream_Change_Listner_GetCurrentCapturerChangeInfos_002, TestSize.Level1)
991 {
992 int32_t ret = -1;
993 vector<unique_ptr<AudioCapturerChangeInfo>> audioCapturerChangeInfos;
994
995 ret = AudioStreamManager::GetInstance()->GetCurrentCapturerChangeInfos(audioCapturerChangeInfos);
996 EXPECT_EQ(SUCCESS, ret);
997 EXPECT_EQ(0, static_cast<int32_t>(audioCapturerChangeInfos.size()));
998 }
999
1000 /**
1001 * @tc.name : Test GetCurrentCapturerChangeInfos API
1002 * @tc.number: Audio_Stream_Change_Listner_GetCurrentCapturerChangeInfos_003
1003 * @tc.desc : Test GetCurrentCapturerChangeInfos interface for single active stream in running state
1004 * CAPTURER_PREPARED:1 CAPTURER_RUNNING:2 CAPTURER_STOPPED:3 CAPTURER_RELEASED:4 CAPTURER_PAUSED:5
1005 */
1006 HWTEST(AudioStreamManagerUnitTest, Audio_Stream_Change_Listner_GetCurrentCapturerChangeInfos_003, TestSize.Level1)
1007 {
1008 int32_t ret = -1;
1009 AudioCapturerOptions capturerOptions;
1010 vector<unique_ptr<AudioCapturerChangeInfo>> audioCapturerChangeInfos;
1011
1012 AudioStreamManagerUnitTest::InitializeCapturerOptions(capturerOptions);
1013 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
1014 ASSERT_NE(nullptr, audioCapturer);
1015
1016 bool isStarted = audioCapturer->Start();
1017 EXPECT_EQ(true, isStarted);
1018 ret = AudioStreamManager::GetInstance()->GetCurrentCapturerChangeInfos(audioCapturerChangeInfos);
1019 EXPECT_EQ(SUCCESS, ret);
1020 EXPECT_EQ(1, static_cast<int32_t>(audioCapturerChangeInfos.size()));
1021 EXPECT_EQ(2, audioCapturerChangeInfos[0]->capturerState);
1022
1023 bool isStopped = audioCapturer->Stop();
1024 EXPECT_EQ(true, isStopped);
1025
1026 bool isReleased = audioCapturer->Release();
1027 EXPECT_EQ(true, isReleased);
1028 audioCapturerChangeInfos.clear();
1029 std::this_thread::sleep_for(std::chrono::seconds(WAIT_TIME));
1030 ret = AudioStreamManager::GetInstance()->GetCurrentCapturerChangeInfos(audioCapturerChangeInfos);
1031 EXPECT_EQ(SUCCESS, ret);
1032 EXPECT_EQ(0, static_cast<int32_t>(audioCapturerChangeInfos.size()));
1033 }
1034
1035 /**
1036 * @tc.name : Test GetCurrentCapturerChangeInfos API
1037 * @tc.number: Audio_Stream_Change_Listner_GetCurrentCapturerChangeInfos_004
1038 * @tc.desc : Test GetCurrentCapturerChangeInfos interface for single active stream in pause state
1039 * CAPTURER_PREPARED:1 CAPTURER_RUNNING:2 CAPTURER_STOPPED:3 CAPTURER_RELEASED:4 CAPTURER_PAUSED:5
1040 */
1041 HWTEST(AudioStreamManagerUnitTest, Audio_Stream_Change_Listner_GetCurrentCapturerChangeInfos_004, TestSize.Level1)
1042 {
1043 int32_t ret = -1;
1044 AudioCapturerOptions capturerOptions;
1045 vector<unique_ptr<AudioCapturerChangeInfo>> audioCapturerChangeInfos;
1046
1047 AudioStreamManagerUnitTest::InitializeCapturerOptions(capturerOptions);
1048 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
1049 ASSERT_NE(nullptr, audioCapturer);
1050
1051 bool isStarted = audioCapturer->Start();
1052 EXPECT_EQ(true, isStarted);
1053
1054 bool isPaused = audioCapturer->Pause();
1055 EXPECT_EQ(true, isPaused);
1056
1057 ret = AudioStreamManager::GetInstance()->GetCurrentCapturerChangeInfos(audioCapturerChangeInfos);
1058 EXPECT_EQ(SUCCESS, ret);
1059 EXPECT_EQ(1, static_cast<int32_t>(audioCapturerChangeInfos.size()));
1060 EXPECT_EQ(5, audioCapturerChangeInfos[0]->capturerState);
1061
1062 bool isReleased = audioCapturer->Release();
1063 EXPECT_EQ(true, isReleased);
1064 audioCapturerChangeInfos.clear();
1065 std::this_thread::sleep_for(std::chrono::seconds(4));
1066 ret = AudioStreamManager::GetInstance()->GetCurrentCapturerChangeInfos(audioCapturerChangeInfos);
1067 EXPECT_EQ(SUCCESS, ret);
1068 EXPECT_EQ(0, static_cast<int32_t>(audioCapturerChangeInfos.size()));
1069 }
1070
1071 /**
1072 * @tc.name : Test GetCurrentCapturerChangeInfos API
1073 * @tc.number: Audio_Stream_Change_Listner_GetCurrentCapturerChangeInfos_005
1074 * @tc.desc : Test GetCurrentCapturerChangeInfos interface for single active stream in stop state
1075 * CAPTURER_PREPARED:1 CAPTURER_RUNNING:2 CAPTURER_STOPPED:3 CAPTURER_RELEASED:4 CAPTURER_PAUSED:5
1076 */
1077 HWTEST(AudioStreamManagerUnitTest, Audio_Stream_Change_Listner_GetCurrentCapturerChangeInfos_005, TestSize.Level1)
1078 {
1079 int32_t ret = -1;
1080 AudioCapturerOptions capturerOptions;
1081 vector<unique_ptr<AudioCapturerChangeInfo>> audioCapturerChangeInfos;
1082
1083 AudioStreamManagerUnitTest::InitializeCapturerOptions(capturerOptions);
1084 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
1085 ASSERT_NE(nullptr, audioCapturer);
1086
1087 bool isStarted = audioCapturer->Start();
1088 EXPECT_EQ(true, isStarted);
1089
1090 bool isStopped = audioCapturer->Stop();
1091 EXPECT_EQ(true, isStopped);
1092 ret = AudioStreamManager::GetInstance()->GetCurrentCapturerChangeInfos(audioCapturerChangeInfos);
1093 EXPECT_EQ(1, static_cast<int32_t>(audioCapturerChangeInfos.size()));
1094 EXPECT_EQ(3, audioCapturerChangeInfos[0]->capturerState);
1095
1096 bool isReleased = audioCapturer->Release();
1097 EXPECT_EQ(true, isReleased);
1098 audioCapturerChangeInfos.clear();
1099 std::this_thread::sleep_for(std::chrono::seconds(WAIT_TIME));
1100 ret = AudioStreamManager::GetInstance()->GetCurrentCapturerChangeInfos(audioCapturerChangeInfos);
1101 EXPECT_EQ(SUCCESS, ret);
1102 EXPECT_EQ(0, static_cast<int32_t>(audioCapturerChangeInfos.size()));
1103 }
1104
1105 /**
1106 * @tc.name : Test GetCurrentCapturerChangeInfos API
1107 * @tc.number: Audio_Stream_Change_Listner_GetCurrentCapturerChangeInfos_006
1108 * @tc.desc : Test GetCurrentCapturerChangeInfos interface for single active stream in stop state in release state
1109 * CAPTURER_PREPARED:1 CAPTURER_RUNNING:2 CAPTURER_STOPPED:3 CAPTURER_RELEASED:4 CAPTURER_PAUSED:5
1110 */
1111 HWTEST(AudioStreamManagerUnitTest, Audio_Stream_Change_Listner_GetCurrentCapturerChangeInfos_006, TestSize.Level1)
1112 {
1113 int32_t ret = -1;
1114 AudioCapturerOptions capturerOptions;
1115 vector<unique_ptr<AudioCapturerChangeInfo>> audioCapturerChangeInfos;
1116
1117 AudioStreamManagerUnitTest::InitializeCapturerOptions(capturerOptions);
1118 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
1119 ASSERT_NE(nullptr, audioCapturer);
1120
1121 bool isStarted = audioCapturer->Start();
1122 EXPECT_EQ(true, isStarted);
1123
1124 bool isStopped = audioCapturer->Stop();
1125 EXPECT_EQ(true, isStopped);
1126
1127 bool isReleased = audioCapturer->Release();
1128 EXPECT_EQ(true, isReleased);
1129 std::this_thread::sleep_for(std::chrono::seconds(WAIT_TIME));
1130 ret = AudioStreamManager::GetInstance()->GetCurrentCapturerChangeInfos(audioCapturerChangeInfos);
1131 EXPECT_EQ(SUCCESS, ret);
1132 EXPECT_EQ(0, static_cast<int32_t>(audioCapturerChangeInfos.size()));
1133 }
1134
1135 /**
1136 * @tc.name : Test GetCurrentCapturerChangeInfos API
1137 * @tc.number: Audio_Stream_Change_Listner_GetCurrentCapturerChangeInfos_007
1138 * @tc.desc : Test GetCurrentCapturerChangeInfos interface. Returns current two active capturer stream information
1139 * CAPTURER_PREPARED:1 CAPTURER_RUNNING:2 CAPTURER_STOPPED:3 CAPTURER_RELEASED:4 CAPTURER_PAUSED:5
1140 */
1141 HWTEST(AudioStreamManagerUnitTest, Audio_Stream_Change_Listner_GetCurrentCapturerChangeInfos_007, TestSize.Level1)
1142 {
1143 int32_t ret = -1;
1144 AudioCapturerOptions capturerOptions;
1145 vector<unique_ptr<AudioCapturerChangeInfo>> audioCapturerChangeInfos;
1146
1147 AudioStreamManagerUnitTest::InitializeCapturerOptions(capturerOptions);
1148 unique_ptr<AudioCapturer> audioFirstCapturer = AudioCapturer::Create(capturerOptions);
1149 unique_ptr<AudioCapturer> audioSecondCapturer = AudioCapturer::Create(capturerOptions);
1150 ASSERT_NE(nullptr, audioFirstCapturer);
1151 ASSERT_NE(nullptr, audioSecondCapturer);
1152
1153 bool isStarted = audioFirstCapturer->Start();
1154 EXPECT_EQ(true, isStarted);
1155 isStarted = audioSecondCapturer->Start();
1156 EXPECT_EQ(true, isStarted);
1157
1158 audioCapturerChangeInfos.clear();
1159 ret = AudioStreamManager::GetInstance()->GetCurrentCapturerChangeInfos(audioCapturerChangeInfos);
1160 EXPECT_EQ(SUCCESS, ret);
1161 EXPECT_EQ(2, static_cast<int32_t>(audioCapturerChangeInfos.size()));
1162 EXPECT_EQ(2, audioCapturerChangeInfos[0]->capturerState);
1163 EXPECT_EQ(2, audioCapturerChangeInfos[1]->capturerState);
1164
1165 bool isStopped = audioFirstCapturer->Stop();
1166 EXPECT_EQ(true, isStopped);
1167
1168 isStopped = audioSecondCapturer->Stop();
1169 EXPECT_EQ(true, isStopped);
1170
1171 bool isReleased = audioFirstCapturer->Release();
1172 EXPECT_EQ(true, isReleased);
1173
1174 isReleased = audioSecondCapturer->Release();
1175 EXPECT_EQ(true, isReleased);
1176
1177 std::this_thread::sleep_for(std::chrono::seconds(WAIT_TIME));
1178 audioCapturerChangeInfos.clear();
1179 ret = AudioStreamManager::GetInstance()->GetCurrentCapturerChangeInfos(audioCapturerChangeInfos);
1180 EXPECT_EQ(SUCCESS, ret);
1181 EXPECT_EQ(0, static_cast<int32_t>(audioCapturerChangeInfos.size()));
1182 }
1183
1184 /**
1185 * @tc.name : TestGetCurrentCapturerChangeInfos API
1186 * @tc.number: Audio_Stream_Change_Listner_GetCurrentCapturerChangeInfos_008
1187 * @tc.desc : Test GetCurrentRendererChangeInfos interface to display streams details
1188 * CAPTURER_PREPARED:1 CAPTURER_RUNNING:2 CAPTURER_STOPPED:3 CAPTURER_RELEASED:4 CAPTURER_PAUSED:5
1189 */
1190 HWTEST(AudioStreamManagerUnitTest, Audio_Stream_Change_Listner_GetCurrentCapturerChangeInfos_008, TestSize.Level1)
1191 {
1192 int32_t ret = -1;
1193 vector<unique_ptr<AudioCapturerChangeInfo>> audioCapturerChangeInfos;
1194
1195 ret = AudioStreamManager::GetInstance()->GetCurrentCapturerChangeInfos(audioCapturerChangeInfos);
1196 EXPECT_EQ(SUCCESS, ret);
1197
1198 if (audioCapturerChangeInfos.size() > 0) {
1199 AUDIO_DEBUG_LOG("AudioStreamManagerTest: audioCapturerChangeInfos Number of entries %{public}u",
1200 static_cast<int32_t>(audioCapturerChangeInfos.size()));
1201 uint32_t index = 0;
1202 for (auto it = audioCapturerChangeInfos.begin(); it != audioCapturerChangeInfos.end(); it++) {
1203 AudioCapturerChangeInfo audioCapturerChangeInfo = **it;
1204 AUDIO_DEBUG_LOG("audioCapturerChangeInfos[%{public}d]", index++);
1205 AUDIO_DEBUG_LOG("clientUID = %{public}d", audioCapturerChangeInfo.clientUID);
1206 AUDIO_DEBUG_LOG("sessionId = %{public}d", audioCapturerChangeInfo.sessionId);
1207 AUDIO_DEBUG_LOG("capturerState = %{public}d", audioCapturerChangeInfo.capturerState);
1208 }
1209 } else {
1210 AUDIO_DEBUG_LOG("AudioStreamManagerTest: audioCapturerChangeInfos: No Active Streams");
1211 }
1212 }
1213
1214 /**
1215 * @tc.name : Test GetCurrentCapturerChangeInfos API
1216 * @tc.number: Audio_Audio_Stream_Change_Listner_GetCurrentCapturerChangeInfos__Stability_001
1217 * @tc.desc : Test GetCurrentCapturerChangeInfos interface stability
1218 * CAPTURER_PREPARED:1 CAPTURER_RUNNING:2 CAPTURER_STOPPED:3 CAPTURER_RELEASED:4 CAPTURER_PAUSED:5
1219 */
1220 HWTEST(AudioStreamManagerUnitTest, Audio_Stream_Change_Listner_GetCurrentCapturerChangeInfos__Stability_001,
1221 TestSize.Level1)
1222 {
1223 int32_t ret = -1;
1224 AudioCapturerOptions capturerOptions;
1225 vector<unique_ptr<AudioCapturerChangeInfo>> audioCapturerChangeInfos;
1226
1227 AudioStreamManagerUnitTest::InitializeCapturerOptions(capturerOptions);
1228 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
1229 ASSERT_NE(nullptr, audioCapturer);
1230
1231 bool isStarted = audioCapturer->Start();
1232 EXPECT_EQ(true, isStarted);
1233
1234 for (int32_t i = 0; i < VALUE_HUNDRED; i++) {
1235 ret = AudioStreamManager::GetInstance()->GetCurrentCapturerChangeInfos(audioCapturerChangeInfos);
1236 EXPECT_EQ(SUCCESS, ret);
1237 EXPECT_EQ(1, static_cast<int32_t>(audioCapturerChangeInfos.size()));
1238 EXPECT_EQ(2, audioCapturerChangeInfos[0]->capturerState);
1239 audioCapturerChangeInfos.clear();
1240 }
1241
1242 bool isStopped = audioCapturer->Stop();
1243 EXPECT_EQ(true, isStopped);
1244
1245 bool isReleased = audioCapturer->Release();
1246 EXPECT_EQ(true, isReleased);
1247 audioCapturerChangeInfos.clear();
1248 std::this_thread::sleep_for(std::chrono::seconds(WAIT_TIME));
1249 ret = AudioStreamManager::GetInstance()->GetCurrentCapturerChangeInfos(audioCapturerChangeInfos);
1250 EXPECT_EQ(SUCCESS, ret);
1251 EXPECT_EQ(0, static_cast<int32_t>(audioCapturerChangeInfos.size()));
1252 }
1253
1254 /**
1255 * @tc.name : Test GetCurrentCapturerChangeInfos API
1256 * @tc.number: Audio_Stream_Change_Listner_GetCurrentCapturerChangeDeviceInfos_001
1257 * @tc.desc : Test GetCurrentCapturerChangeInfos interface for getting device information for current stream
1258 */
1259 HWTEST(AudioStreamManagerUnitTest, Audio_Stream_Change_Listner_GetCurrentCapturerChangeDeviceInfos_001, TestSize.Level1)
1260 {
1261 int32_t ret = -1;
1262 AudioCapturerOptions capturerOptions;
1263 vector<unique_ptr<AudioCapturerChangeInfo>> audioCapturerChangeInfos;
1264
1265 AudioStreamManagerUnitTest::InitializeCapturerOptions(capturerOptions);
1266 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
1267 ASSERT_NE(nullptr, audioCapturer);
1268
1269 bool isStarted = audioCapturer->Start();
1270 EXPECT_EQ(true, isStarted);
1271 ret = AudioStreamManager::GetInstance()->GetCurrentCapturerChangeInfos(audioCapturerChangeInfos);
1272 EXPECT_EQ(SUCCESS, ret);
1273 EXPECT_EQ(1, static_cast<int32_t>(audioCapturerChangeInfos.size()));
1274 EXPECT_EQ(2, audioCapturerChangeInfos[0]->capturerState);
1275 EXPECT_EQ(audioCapturerChangeInfos[0]->inputDeviceInfo.deviceRole, DeviceRole::INPUT_DEVICE);
1276 EXPECT_EQ(audioCapturerChangeInfos[0]->inputDeviceInfo.deviceType, DeviceType::DEVICE_TYPE_MIC);
1277 EXPECT_GE(audioCapturerChangeInfos[0]->inputDeviceInfo.deviceId, MIN_DEVICE_ID);
1278 EXPECT_EQ(true, (audioCapturerChangeInfos[0]->inputDeviceInfo.audioStreamInfo.samplingRate >= SAMPLE_RATE_8000)
1279 || ((audioCapturerChangeInfos[0]->inputDeviceInfo.audioStreamInfo.samplingRate <= SAMPLE_RATE_96000)));
1280 EXPECT_EQ(audioCapturerChangeInfos[0]->inputDeviceInfo.audioStreamInfo.encoding, AudioEncodingType::ENCODING_PCM);
1281 EXPECT_EQ(true, (audioCapturerChangeInfos[0]->inputDeviceInfo.audioStreamInfo.channels >= MONO)
1282 && ((audioCapturerChangeInfos[0]->inputDeviceInfo.audioStreamInfo.channels <= CHANNEL_8)));
1283 EXPECT_EQ(true, (audioCapturerChangeInfos[0]->inputDeviceInfo.audioStreamInfo.format >= SAMPLE_U8)
1284 && ((audioCapturerChangeInfos[0]->inputDeviceInfo.audioStreamInfo.format <= SAMPLE_F32LE)));
1285
1286 bool isStopped = audioCapturer->Stop();
1287 EXPECT_EQ(true, isStopped);
1288
1289 bool isReleased = audioCapturer->Release();
1290 EXPECT_EQ(true, isReleased);
1291 audioCapturerChangeInfos.clear();
1292 std::this_thread::sleep_for(std::chrono::seconds(WAIT_TIME));
1293 ret = AudioStreamManager::GetInstance()->GetCurrentCapturerChangeInfos(audioCapturerChangeInfos);
1294 EXPECT_EQ(SUCCESS, ret);
1295 EXPECT_EQ(0, static_cast<int32_t>(audioCapturerChangeInfos.size()));
1296 }
1297
1298 /**
1299 * @tc.name : Test Feature CapturerStateChangeCallback
1300 * @tc.number: Audio_Stream_Change_Listner_CapturerStateChangeCallbackTest_001
1301 * @tc.desc : Test CapturerStateChangeCallback interface in prepared state
1302 * CAPTURER_PREPARED:1 CAPTURER_RUNNING:2 CAPTURER_STOPPED:3 CAPTURER_RELEASED:4 CAPTURER_PAUSED:5
1303 */
1304 HWTEST(AudioStreamManagerUnitTest, Audio_Stream_Change_Listner_CapturerStateChangeCallbackTest_001, TestSize.Level0)
1305 {
1306 int32_t ret = -1;
1307 int callBackSetResult;
1308 std::string testCaseName("Audio_Stream_Change_Listner_CapturerStateChangeCallbackTest_001");
1309 vector<unique_ptr<AudioCapturerChangeInfo>> audioCapturerChangeInfos;
1310
1311 g_callbackName = testCaseName;
1312
1313 auto audioCapturerStateChangeCallbackTest = make_shared<AudioCapturerStateChangeCallbackTest>(testCaseName);
1314 callBackSetResult = g_audioManagerInstance->RegisterAudioCapturerEventListener(getpid(),
1315 audioCapturerStateChangeCallbackTest);
1316 EXPECT_EQ(SUCCESS, callBackSetResult);
1317
1318 AudioCapturerOptions capturerOptions;
1319 AudioStreamManagerUnitTest::InitializeCapturerOptions(capturerOptions);
1320 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
1321 ASSERT_NE(nullptr, audioCapturer);
1322 std::this_thread::sleep_for(std::chrono::seconds(WAIT_TIME));
1323 if (audioCapturer != nullptr) {
1324 // Wait here for callback. If not callback for 2 mintues, will skip this step
1325 AudioStreamManagerUnitTest::WaitForCallback();
1326 g_isCallbackReceived = false;
1327 EXPECT_EQ(1, static_cast<int32_t>(g_audioCapturerChangeInfosRcvd.size()));
1328 EXPECT_EQ(1, g_audioCapturerChangeInfosRcvd[0]->capturerState);
1329 EXPECT_STREQ(g_callbackName.c_str(), testCaseName.c_str());
1330 }
1331
1332 bool isStarted = audioCapturer->Start();
1333 EXPECT_EQ(true, isStarted);
1334
1335 bool isStopped = audioCapturer->Stop();
1336 EXPECT_EQ(true, isStopped);
1337
1338 bool isReleased = audioCapturer->Release();
1339 EXPECT_EQ(true, isReleased);
1340
1341 std::this_thread::sleep_for(std::chrono::seconds(WAIT_TIME));
1342 ret = AudioStreamManager::GetInstance()->GetCurrentCapturerChangeInfos(audioCapturerChangeInfos);
1343 EXPECT_EQ(SUCCESS, ret);
1344 EXPECT_EQ(0, static_cast<int32_t>(audioCapturerChangeInfos.size()));
1345
1346 std::this_thread::sleep_for(std::chrono::seconds(WAIT_TIME));
1347 ret = g_audioManagerInstance->UnregisterAudioCapturerEventListener(getpid());
1348 EXPECT_EQ(SUCCESS, ret);
1349 std::this_thread::sleep_for(std::chrono::seconds(WAIT_TIME));
1350 audioCapturer.reset();
1351 }
1352
1353 /**
1354 * @tc.name : Test Feature CapturerStateChangeCallback
1355 * @tc.number: Audio_Stream_Change_Listner_CapturerStateChangeCallbackTest_002
1356 * @tc.desc : Test CapturerStateChangeCallbackT interface in running state
1357 * CAPTURER_PREPARED:1 CAPTURER_RUNNING:2 CAPTURER_STOPPED:3 CAPTURER_RELEASED:4 CAPTURER_PAUSED:5
1358 */
1359 HWTEST(AudioStreamManagerUnitTest, Audio_Stream_Change_Listner_CapturerStateChangeCallbackTest_002, TestSize.Level1)
1360 {
1361 int32_t ret = -1;
1362 int callBackSetResult;
1363 std::string testCaseName("Audio_Stream_Change_Listner_CapturerStateChangeCallbackTest_002");
1364 vector<unique_ptr<AudioCapturerChangeInfo>> audioCapturerChangeInfos;
1365
1366 g_callbackName = testCaseName;
1367
1368 auto audioCapturerStateChangeCallbackTest = make_shared<AudioCapturerStateChangeCallbackTest>(testCaseName);
1369 callBackSetResult = g_audioManagerInstance->RegisterAudioCapturerEventListener(getpid(),
1370 audioCapturerStateChangeCallbackTest);
1371 EXPECT_EQ(SUCCESS, callBackSetResult);
1372
1373 AudioCapturerOptions capturerOptions;
1374 AudioStreamManagerUnitTest::InitializeCapturerOptions(capturerOptions);
1375 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
1376 ASSERT_NE(nullptr, audioCapturer);
1377
1378 bool isStarted = audioCapturer->Start();
1379 EXPECT_EQ(true, isStarted);
1380 if (isStarted == SUCCESS) {
1381 // Wait here for callback. If not callback for 2 mintues, will skip this step
1382 AudioStreamManagerUnitTest::WaitForCallback();
1383 g_isCallbackReceived = false;
1384 EXPECT_EQ(SUCCESS, ret);
1385 EXPECT_EQ(1, static_cast<int32_t>(g_audioCapturerChangeInfosRcvd.size()));
1386 EXPECT_EQ(2, g_audioCapturerChangeInfosRcvd[0]->capturerState);
1387 EXPECT_STREQ(g_callbackName.c_str(), testCaseName.c_str());
1388 }
1389
1390 bool isStopped = audioCapturer->Stop();
1391 EXPECT_EQ(true, isStopped);
1392
1393 bool isReleased = audioCapturer->Release();
1394 EXPECT_EQ(true, isReleased);
1395
1396 std::this_thread::sleep_for(std::chrono::seconds(WAIT_TIME));
1397 ret = AudioStreamManager::GetInstance()->GetCurrentCapturerChangeInfos(audioCapturerChangeInfos);
1398 EXPECT_EQ(SUCCESS, ret);
1399 EXPECT_EQ(0, static_cast<int32_t>(audioCapturerChangeInfos.size()));
1400
1401 std::this_thread::sleep_for(std::chrono::seconds(WAIT_TIME));
1402 g_audioManagerInstance->UnregisterAudioCapturerEventListener(getpid());
1403 }
1404
1405 /**
1406 * @tc.name : Test Feature CapturerStateChangeCallback
1407 * @tc.number: Audio_Stream_Change_Listner_CapturerStateChangeCallbackTest_003
1408 * @tc.desc : Test CapturerStateChangeCallbackT interface in stop state
1409 * CAPTURER_PREPARED:1 CAPTURER_RUNNING:2 CAPTURER_STOPPED:3 CAPTURER_RELEASED:4 CAPTURER_PAUSED:5
1410 */
1411 HWTEST(AudioStreamManagerUnitTest, Audio_Stream_Change_Listner_CapturerStateChangeCallbackTest_003,
1412 TestSize.Level1)
1413 {
1414 int32_t ret = -1;
1415 int callBackSetResult;
1416 std::string testCaseName("Audio_Stream_Change_Listner_CapturerStateChangeCallbackTest_003");
1417 AudioCapturerOptions capturerOptions;
1418 vector<unique_ptr<AudioCapturerChangeInfo>> audioCapturerChangeInfos;
1419
1420 g_callbackName = testCaseName;
1421
1422 AudioStreamManagerUnitTest::InitializeCapturerOptions(capturerOptions);
1423 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
1424 ASSERT_NE(nullptr, audioCapturer);
1425
1426 auto audioCapturerStateChangeCallbackTest = make_shared<AudioCapturerStateChangeCallbackTest>(testCaseName);
1427 callBackSetResult = g_audioManagerInstance->RegisterAudioCapturerEventListener(getpid(),
1428 audioCapturerStateChangeCallbackTest);
1429
1430 bool isStarted = audioCapturer->Start();
1431 EXPECT_EQ(true, isStarted);
1432
1433 bool isStopped = audioCapturer->Stop();
1434 EXPECT_EQ(true, isStopped);
1435 if (isStopped == SUCCESS) {
1436 // Wait here for callback. If not callback for 2 mintues, will skip this step
1437 AudioStreamManagerUnitTest::WaitForCallback();
1438 g_isCallbackReceived = false;
1439 EXPECT_EQ(SUCCESS, ret);
1440 EXPECT_EQ(1, static_cast<int32_t>(g_audioCapturerChangeInfosRcvd.size()));
1441 EXPECT_EQ(3, g_audioCapturerChangeInfosRcvd[0]->capturerState);
1442 EXPECT_STREQ(g_callbackName.c_str(), testCaseName.c_str());
1443 }
1444
1445 bool isReleased = audioCapturer->Release();
1446 EXPECT_EQ(true, isReleased);
1447
1448 std::this_thread::sleep_for(std::chrono::seconds(WAIT_TIME));
1449 ret = AudioStreamManager::GetInstance()->GetCurrentCapturerChangeInfos(audioCapturerChangeInfos);
1450 EXPECT_EQ(SUCCESS, ret);
1451 EXPECT_EQ(0, static_cast<int32_t>(audioCapturerChangeInfos.size()));
1452
1453 std::this_thread::sleep_for(std::chrono::seconds(WAIT_TIME));
1454 g_audioManagerInstance->UnregisterAudioCapturerEventListener(getpid());
1455 }
1456
1457 /**
1458 * @tc.name : Test Feature CapturerStateChangeCallback
1459 * @tc.number: Audio_Stream_Change_Listner_CapturerStateChangeCallbackTest_004
1460 * @tc.desc : Test CapturerStateChangeCallbackT interface in stop state
1461 * CAPTURER_PREPARED:1 CAPTURER_RUNNING:2 CAPTURER_STOPPED:3 CAPTURER_RELEASED:4 CAPTURER_PAUSED:5
1462 */
1463 HWTEST(AudioStreamManagerUnitTest, Audio_Stream_Change_Listner_CapturerStateChangeCallbackTest_004, TestSize.Level1)
1464 {
1465 int32_t ret = -1;
1466 int callBackSetResult;
1467 std::string testCaseName("Audio_Stream_Change_Listner_CapturerStateChangeCallbackTest_004");
1468 AudioCapturerOptions capturerOptions;
1469 vector<unique_ptr<AudioCapturerChangeInfo>> audioCapturerChangeInfos;
1470
1471 g_callbackName = testCaseName;
1472
1473 AudioStreamManagerUnitTest::InitializeCapturerOptions(capturerOptions);
1474 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
1475 ASSERT_NE(nullptr, audioCapturer);
1476
1477 auto audioCapturerStateChangeCallbackTest = make_shared<AudioCapturerStateChangeCallbackTest>(testCaseName);
1478 callBackSetResult = g_audioManagerInstance->RegisterAudioCapturerEventListener(getpid(),
1479 audioCapturerStateChangeCallbackTest);
1480
1481 bool isStarted = audioCapturer->Start();
1482 EXPECT_EQ(true, isStarted);
1483
1484 bool isStopped = audioCapturer->Stop();
1485 EXPECT_EQ(true, isStopped);
1486
1487 bool isReleased = audioCapturer->Release();
1488 EXPECT_EQ(true, isReleased);
1489 if (isStarted == SUCCESS) {
1490 // Wait here for callback. If not callback for 2 mintues, will skip this step
1491 g_isCallbackReceived = false;
1492 AudioStreamManagerUnitTest::WaitForCallback();
1493 EXPECT_EQ(SUCCESS, ret);
1494 EXPECT_EQ(1, static_cast<int32_t>(g_audioCapturerChangeInfosRcvd.size()));
1495 EXPECT_EQ(4, g_audioCapturerChangeInfosRcvd[0]->capturerState);
1496 EXPECT_STREQ(g_callbackName.c_str(), testCaseName.c_str());
1497 }
1498
1499 std::this_thread::sleep_for(std::chrono::seconds(WAIT_TIME));
1500 ret = AudioStreamManager::GetInstance()->GetCurrentCapturerChangeInfos(audioCapturerChangeInfos);
1501 EXPECT_EQ(SUCCESS, ret);
1502 EXPECT_EQ(0, static_cast<int32_t>(audioCapturerChangeInfos.size()));
1503
1504 std::this_thread::sleep_for(std::chrono::seconds(WAIT_TIME));
1505 g_audioManagerInstance->UnregisterAudioCapturerEventListener(getpid());
1506 std::this_thread::sleep_for(std::chrono::seconds(10));
1507 }
1508 } // namespace AudioStandard
1509 } // namespace OHOS
1510