1 /*
2 * Copyright (c) 2024-2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "audio_stream_collector_unit_test.h"
17 #include "audio_system_manager.h"
18 #include "audio_client_tracker_callback_proxy.h"
19 #include "audio_spatialization_service.h"
20 #include "audio_policy_log.h"
21 #include "audio_errors.h"
22 #include <thread>
23 #include <string>
24 #include <memory>
25 #include <vector>
26 #include <sys/socket.h>
27 #include <cerrno>
28 #include <fstream>
29 #include <algorithm>
30 using namespace std;
31 using namespace std::chrono;
32 using namespace testing::ext;
33
34 namespace OHOS {
35 namespace AudioStandard {
36
SetUpTestCase(void)37 void AudioStreamCollectorUnitTest::SetUpTestCase(void) {}
TearDownTestCase(void)38 void AudioStreamCollectorUnitTest::TearDownTestCase(void) {}
SetUp(void)39 void AudioStreamCollectorUnitTest::SetUp(void) {}
TearDown(void)40 void AudioStreamCollectorUnitTest::TearDown(void) {}
41
42
43 #define PRINT_LINE printf("debug __LINE__:%d\n", __LINE__)
44
45 /**
46 * @tc.name : Test AudioStreamCollector.
47 * @tc.number: AudioStreamCollector_001
48 * @tc.desc : Test CheckRendererStateInfoChanged.
49 */
50 HWTEST_F(AudioStreamCollectorUnitTest, AudioStreamCollector_001, TestSize.Level1)
51 {
52 AudioStreamCollector audioStreamCollector_;
53 AudioStreamChangeInfo streamChangeInfo;
54 streamChangeInfo.audioRendererChangeInfo.clientUID = 1001;
55 streamChangeInfo.audioRendererChangeInfo.sessionId = 2001;
56 streamChangeInfo.audioRendererChangeInfo.rendererState = RendererState::RENDERER_RUNNING;
57 // Test case 1: New client (not in the queue)
58 EXPECT_TRUE(audioStreamCollector_.CheckRendererStateInfoChanged(streamChangeInfo));
59 // Add the client to the queue
60 audioStreamCollector_.rendererStatequeue_[std::make_pair(1001, 2001)] = 1;
61 // Test case 2: Existing client with same state
62 EXPECT_TRUE(audioStreamCollector_.CheckRendererStateInfoChanged(streamChangeInfo));
63 // Test case 3: Existing client with different state
64 streamChangeInfo.audioRendererChangeInfo.rendererState = RendererState::RENDERER_PAUSED;
65 EXPECT_TRUE(audioStreamCollector_.CheckRendererStateInfoChanged(streamChangeInfo));
66 // Test case 4: Different client
67 streamChangeInfo.audioRendererChangeInfo.clientUID = 1002;
68 EXPECT_TRUE(audioStreamCollector_.CheckRendererStateInfoChanged(streamChangeInfo));
69 // Test case 5: Different session ID
70 streamChangeInfo.audioRendererChangeInfo.clientUID = 1001;
71 streamChangeInfo.audioRendererChangeInfo.sessionId = 2002;
72 EXPECT_TRUE(audioStreamCollector_.CheckRendererStateInfoChanged(streamChangeInfo));
73 }
74
75 /**
76 * @tc.name : Test AudioStreamCollector.
77 * @tc.number: AudioStreamCollector_002
78 * @tc.desc : Test UpdateRendererDeviceInfo.
79 */
80 HWTEST_F(AudioStreamCollectorUnitTest, AudioStreamCollector_002, TestSize.Level1)
81 {
82 AudioStreamCollector audioStreamCollector_;
83 AudioDeviceDescriptor outputDeviceInfo(AudioDeviceDescriptor::DEVICE_INFO);
84 outputDeviceInfo.deviceType_ = DeviceType::DEVICE_TYPE_SPEAKER;
85 auto info1 = std::make_unique<AudioRendererChangeInfo>();
86 info1->outputDeviceInfo.deviceType_ = DeviceType::DEVICE_TYPE_EARPIECE;
87 audioStreamCollector_.audioRendererChangeInfos_.push_back(std::move(info1));
88 auto info2 = std::make_unique<AudioRendererChangeInfo>();
89 info2->outputDeviceInfo.deviceType_ = DeviceType::DEVICE_TYPE_SPEAKER;
90 audioStreamCollector_.audioRendererChangeInfos_.push_back(std::move(info2));
91 int32_t result = audioStreamCollector_.UpdateRendererDeviceInfo(outputDeviceInfo);
92 EXPECT_EQ(result, SUCCESS);
93 EXPECT_EQ(audioStreamCollector_.audioRendererChangeInfos_.size(), 2);
94 EXPECT_EQ(
95 audioStreamCollector_.audioRendererChangeInfos_[0]->outputDeviceInfo.deviceType_,
96 DeviceType::DEVICE_TYPE_SPEAKER
97 );
98 EXPECT_EQ(
99 audioStreamCollector_.audioRendererChangeInfos_[1]->outputDeviceInfo.deviceType_,
100 DeviceType::DEVICE_TYPE_SPEAKER
101 );
102 AudioDeviceDescriptor sameDeviceInfo(AudioDeviceDescriptor::DEVICE_INFO);
103 sameDeviceInfo.deviceType_ = DeviceType::DEVICE_TYPE_SPEAKER;
104 result = audioStreamCollector_.UpdateRendererDeviceInfo(sameDeviceInfo);
105
106 EXPECT_EQ(result, SUCCESS);
107 EXPECT_EQ(
108 audioStreamCollector_.audioRendererChangeInfos_[0]->outputDeviceInfo.deviceType_,
109 DeviceType::DEVICE_TYPE_SPEAKER
110 );
111 EXPECT_EQ(
112 audioStreamCollector_.audioRendererChangeInfos_[1]->outputDeviceInfo.deviceType_,
113 DeviceType::DEVICE_TYPE_SPEAKER
114 );
115 }
116
117 /**
118 * @tc.name : Test AudioStreamCollector.
119 * @tc.number: AudioStreamCollector_003
120 * @tc.desc : Test UpdateCapturerDeviceInfo.
121 */
122 HWTEST_F(AudioStreamCollectorUnitTest, AudioStreamCollector_003, TestSize.Level1)
123 {
124 AudioStreamCollector audioStreamCollector_;
125 AudioDeviceDescriptor inputDeviceInfo(AudioDeviceDescriptor::DEVICE_INFO);
126 inputDeviceInfo.deviceType_ = DeviceType::DEVICE_TYPE_MIC;
127 auto info1 = std::make_unique<AudioCapturerChangeInfo>();
128 info1->inputDeviceInfo.deviceType_ = DeviceType::DEVICE_TYPE_WIRED_HEADSET;
129 audioStreamCollector_.audioCapturerChangeInfos_.push_back(std::move(info1));
130 auto info2 = std::make_unique<AudioCapturerChangeInfo>();
131 info2->inputDeviceInfo.deviceType_ = DeviceType::DEVICE_TYPE_MIC;
132 audioStreamCollector_.audioCapturerChangeInfos_.push_back(std::move(info2));
133 int32_t result = audioStreamCollector_.UpdateCapturerDeviceInfo(inputDeviceInfo);
134 EXPECT_EQ(result, SUCCESS);
135 EXPECT_EQ(audioStreamCollector_.audioCapturerChangeInfos_.size(), 2);
136 EXPECT_EQ(
137 audioStreamCollector_.audioCapturerChangeInfos_[0]->inputDeviceInfo.deviceType_,
138 DeviceType::DEVICE_TYPE_MIC);
139 EXPECT_EQ(
140 audioStreamCollector_.audioCapturerChangeInfos_[1]->inputDeviceInfo.deviceType_,
141 DeviceType::DEVICE_TYPE_MIC
142 );
143 AudioDeviceDescriptor sameDeviceInfo(AudioDeviceDescriptor::DEVICE_INFO);
144 sameDeviceInfo.deviceType_ = DeviceType::DEVICE_TYPE_MIC;
145 result = audioStreamCollector_.UpdateCapturerDeviceInfo(sameDeviceInfo);
146 EXPECT_EQ(result, SUCCESS);
147 EXPECT_EQ(
148 audioStreamCollector_.audioCapturerChangeInfos_[0]->inputDeviceInfo.deviceType_,
149 DeviceType::DEVICE_TYPE_MIC
150 );
151 EXPECT_EQ(
152 audioStreamCollector_.audioCapturerChangeInfos_[1]->inputDeviceInfo.deviceType_,
153 DeviceType::DEVICE_TYPE_MIC
154 );
155 }
156
157 /**
158 * @tc.name : Test AudioStreamCollector.
159 * @tc.number: AudioStreamCollector_004
160 * @tc.desc : Test GetAndCompareStreamType.
161 */
162 HWTEST_F(AudioStreamCollectorUnitTest, AudioStreamCollector_004, TestSize.Level1)
163 {
164 AudioStreamCollector audioStreamCollector_;
165 // Test case 1: Match between target usage and renderer info
166 {
167 StreamUsage targetUsage = STREAM_USAGE_MEDIA;
168 AudioRendererInfo rendererInfo;
169 rendererInfo.contentType = CONTENT_TYPE_UNKNOWN;
170 rendererInfo.streamUsage = STREAM_USAGE_MEDIA;
171 bool result = audioStreamCollector_.GetAndCompareStreamType(targetUsage, rendererInfo);
172 EXPECT_TRUE(result);
173 }
174 // Test case 2: Mismatch between target usage and renderer info
175 {
176 StreamUsage targetUsage = STREAM_USAGE_ALARM;
177 AudioRendererInfo rendererInfo;
178 rendererInfo.contentType = CONTENT_TYPE_UNKNOWN;
179 rendererInfo.streamUsage = STREAM_USAGE_MEDIA;
180 bool result = audioStreamCollector_.GetAndCompareStreamType(targetUsage, rendererInfo);
181 EXPECT_FALSE(result);
182 }
183 // Test case 3: Unknown content type and stream usage
184 {
185 StreamUsage targetUsage = STREAM_USAGE_UNKNOWN;
186 AudioRendererInfo rendererInfo;
187 rendererInfo.contentType = CONTENT_TYPE_UNKNOWN;
188 rendererInfo.streamUsage = STREAM_USAGE_UNKNOWN;
189 bool result = audioStreamCollector_.GetAndCompareStreamType(targetUsage, rendererInfo);
190 EXPECT_TRUE(result);
191 }
192 // Test case 4: Voice communication
193 {
194 StreamUsage targetUsage = STREAM_USAGE_VOICE_COMMUNICATION;
195 AudioRendererInfo rendererInfo;
196 rendererInfo.contentType = CONTENT_TYPE_UNKNOWN;
197 rendererInfo.streamUsage = STREAM_USAGE_VOICE_COMMUNICATION;
198 bool result = audioStreamCollector_.GetAndCompareStreamType(targetUsage, rendererInfo);
199 EXPECT_TRUE(result);
200 }
201 // Test case 5: Media stream type (should be converted to STREAM_MUSIC)
202 {
203 StreamUsage targetUsage = STREAM_USAGE_MEDIA;
204 AudioRendererInfo rendererInfo;
205 rendererInfo.contentType = CONTENT_TYPE_UNKNOWN;
206 rendererInfo.streamUsage = STREAM_USAGE_MEDIA;
207 bool result = audioStreamCollector_.GetAndCompareStreamType(targetUsage, rendererInfo);
208 EXPECT_TRUE(result);
209 }
210 }
211
212 /**
213 * @tc.name : Test AudioStreamCollector.
214 * @tc.number: AudioStreamCollector_005
215 * @tc.desc : Test UpdateStreamState.
216 */
217 HWTEST_F(AudioStreamCollectorUnitTest, AudioStreamCollector_005, TestSize.Level1)
218 {
219 AudioStreamCollector audioStreamCollector_;
220 int32_t clientUid = 1001;
221 StreamSetStateEventInternal event;
222 event.streamSetState = StreamSetState::STREAM_PAUSE;
223 event.streamUsage = STREAM_USAGE_MEDIA;
224 // Create and add AudioRendererChangeInfo
225 auto changeInfo = std::make_unique<AudioRendererChangeInfo>();
226 changeInfo->clientUID = clientUid;
227 changeInfo->rendererInfo.streamUsage = STREAM_USAGE_MEDIA;
228 changeInfo->sessionId = 1;
229 audioStreamCollector_.audioRendererChangeInfos_.push_back(std::move(changeInfo));
230 int32_t result = audioStreamCollector_.UpdateStreamState(clientUid, event);
231 EXPECT_EQ(result, SUCCESS);
232 event.streamSetState = StreamSetState::STREAM_RESUME;
233 result = audioStreamCollector_.UpdateStreamState(clientUid, event);
234 EXPECT_EQ(result, SUCCESS);
235 event.streamSetState = StreamSetState::STREAM_MUTE;
236 result = audioStreamCollector_.UpdateStreamState(clientUid, event);
237 EXPECT_EQ(result, SUCCESS);
238 event.streamSetState = StreamSetState::STREAM_UNMUTE;
239 result = audioStreamCollector_.UpdateStreamState(clientUid, event);
240 EXPECT_EQ(result, SUCCESS);
241 event.streamUsage = STREAM_USAGE_VOICE_COMMUNICATION;
242 event.streamSetState = StreamSetState::STREAM_MUTE;
243 result = audioStreamCollector_.UpdateStreamState(clientUid, event);
244 EXPECT_EQ(result, SUCCESS);
245 // The tests do not match clientUid
246 result = audioStreamCollector_.UpdateStreamState(9999, event);
247 //The function should still return SUCCESS, but no callbacks should be called
248 EXPECT_EQ(result, SUCCESS);
249 // Test empty callback
250 audioStreamCollector_.clientTracker_.clear();
251 result = audioStreamCollector_.UpdateStreamState(clientUid, event);
252 EXPECT_EQ(result, SUCCESS);
253 }
254
255 /**
256 * @tc.name : Test AudioStreamCollector.
257 * @tc.number: AudioStreamCollector_006
258 * @tc.desc : Test GetRunningStream.
259 */
260 HWTEST_F(AudioStreamCollectorUnitTest, AudioStreamCollector_006, TestSize.Level1)
261 {
262 std::unique_ptr<AudioStreamCollector> collector = std::make_unique<AudioStreamCollector>();
263 AudioRendererInfo rendererInfo1 = {
264 .contentType = CONTENT_TYPE_MUSIC, .streamUsage = STREAM_USAGE_MEDIA
265 };
266 AudioRendererInfo rendererInfo2 = {
267 .contentType = CONTENT_TYPE_SPEECH, .streamUsage = STREAM_USAGE_VOICE_COMMUNICATION
268 };
269 AudioRendererInfo rendererInfo3 = {
270 .contentType = CONTENT_TYPE_MOVIE, .streamUsage = STREAM_USAGE_MEDIA
271 };
272 std::unique_ptr<AudioRendererChangeInfo> info1 = std::make_unique<AudioRendererChangeInfo>();
273 info1->sessionId = 1;
274 info1->rendererState = RENDERER_RUNNING;
275 info1->rendererInfo = rendererInfo1;
276 info1->channelCount = 2;
277 std::unique_ptr<AudioRendererChangeInfo> info2 = std::make_unique<AudioRendererChangeInfo>();
278 info2->sessionId = 2;
279 info2->rendererState = RENDERER_RUNNING;
280 info2->rendererInfo = rendererInfo2;
281 info2->channelCount = 1;
282 std::unique_ptr<AudioRendererChangeInfo> info3 = std::make_unique<AudioRendererChangeInfo>();
283 info3->sessionId = 3;
284 info3->rendererState = RENDERER_PAUSED;
285 info3->rendererInfo = rendererInfo3;
286 info3->channelCount = 2;
287 collector->audioRendererChangeInfos_.push_back(std::move(info1));
288 collector->audioRendererChangeInfos_.push_back(std::move(info2));
289 collector->audioRendererChangeInfos_.push_back(std::move(info3));
290 // Test case 1: Default stream type and channel count
291 EXPECT_EQ(collector->GetRunningStream(STREAM_DEFAULT, 0), 1);
292 // Test case 2: Specific stream type (STREAM_MUSIC) and default channel count
293 EXPECT_EQ(collector->GetRunningStream(STREAM_MUSIC, 0), 1);
294 // Test case 3: Specific stream type (STREAM_VOICE_COMMUNICATION) and default channel count
295 EXPECT_EQ(collector->GetRunningStream(STREAM_VOICE_COMMUNICATION, 0), 2);
296 // Test case 4: Specific stream type (STREAM_MUSIC) and specific channel count (2)
297 EXPECT_EQ(collector->GetRunningStream(STREAM_MUSIC, 2), 1);
298 // Test case 5: Specific stream type (STREAM_VOICE_COMMUNICATION) and specific channel count (1)
299 EXPECT_EQ(collector->GetRunningStream(STREAM_VOICE_COMMUNICATION, 1), 2);
300 // Test case 6: Non-existent stream type
301 EXPECT_EQ(collector->GetRunningStream(STREAM_ALARM, 0), -1);
302 // Test case 7: Existing stream type but non-matching channel count
303 EXPECT_EQ(collector->GetRunningStream(STREAM_MUSIC, 1), -1);
304 // Test case 8: Existing stream type and matching channel count, but not in RUNNING state
305 EXPECT_EQ(collector->GetRunningStream(STREAM_MUSIC, 2), 1); // Should still return 1, not 3
306 }
307
CreateChangeInfo(int32_t sessionId,RendererState state,ContentType contentType,StreamUsage streamUsage,int32_t channelCount)308 std::unique_ptr<AudioRendererChangeInfo> CreateChangeInfo(
309 int32_t sessionId,
310 RendererState state,
311 ContentType contentType,
312 StreamUsage streamUsage,
313 int32_t channelCount)
314 {
315 auto info = std::make_unique<AudioRendererChangeInfo>();
316 info->sessionId = sessionId;
317 info->rendererState = state;
318 info->rendererInfo.contentType = contentType;
319 info->rendererInfo.streamUsage = streamUsage;
320 info->channelCount = channelCount;
321 return info;
322 }
323
324 /**
325 * @tc.name : Test AudioStreamCollector.
326 * @tc.number: AudioStreamCollector_007
327 * @tc.desc : Test GetRunningStream.
328 */
329 HWTEST_F(AudioStreamCollectorUnitTest, AudioStreamCollector_007, TestSize.Level1)
330 {
331 std::unique_ptr<AudioStreamCollector> collector = std::make_unique<AudioStreamCollector>();
332 std::vector<std::unique_ptr<AudioRendererChangeInfo>> testInfos;
333 testInfos.emplace_back(
334 CreateChangeInfo(1, RendererState::RENDERER_RUNNING, ContentType::CONTENT_TYPE_MUSIC,
335 StreamUsage::STREAM_USAGE_MEDIA, 2));
336 testInfos.emplace_back(
337 CreateChangeInfo(2, RendererState::RENDERER_RUNNING, ContentType::CONTENT_TYPE_SPEECH,
338 StreamUsage::STREAM_USAGE_VOICE_COMMUNICATION, 1));
339 testInfos.emplace_back(
340 CreateChangeInfo(3, RendererState::RENDERER_PAUSED, ContentType::CONTENT_TYPE_MOVIE,
341 StreamUsage::STREAM_USAGE_MEDIA, 2));
342 testInfos.emplace_back(
343 CreateChangeInfo(4, RendererState::RENDERER_RUNNING, ContentType::CONTENT_TYPE_PROMPT,
344 StreamUsage::STREAM_USAGE_NOTIFICATION, 1));
345 testInfos.emplace_back(
346 CreateChangeInfo(5, RendererState::RENDERER_RUNNING, ContentType::CONTENT_TYPE_DTMF,
347 StreamUsage::STREAM_USAGE_VIDEO_COMMUNICATION, 1));
348 testInfos.emplace_back(
349 CreateChangeInfo(6, RendererState::RENDERER_RUNNING, ContentType::CONTENT_TYPE_UNKNOWN,
350 StreamUsage::STREAM_USAGE_ALARM, 2));
351 for (auto& info : testInfos) {
352 collector->audioRendererChangeInfos_.push_back(std::move(info));
353 }
354
355 // Test case 1: Default stream type and channel count
356 EXPECT_EQ(collector->GetRunningStream(STREAM_DEFAULT, 0), 1);
357 // Test case 2: Specific stream type (STREAM_MUSIC) and default channel count
358 EXPECT_EQ(collector->GetRunningStream(STREAM_MUSIC, 0), 1);
359 // Test case 3: Specific stream type (STREAM_VOICE_COMMUNICATION) and default channel count
360 EXPECT_EQ(collector->GetRunningStream(STREAM_VOICE_COMMUNICATION, 0), 2);
361 // Test case 4: Specific stream type (STREAM_MUSIC) and specific channel count (2)
362 EXPECT_EQ(collector->GetRunningStream(STREAM_MUSIC, 2), 1);
363 // Test case 5: Specific stream type (STREAM_VOICE_COMMUNICATION) and specific channel count (1)
364 EXPECT_EQ(collector->GetRunningStream(STREAM_VOICE_COMMUNICATION, 1), 2);
365 // Test case 6: Non-existent stream type
366 EXPECT_EQ(collector->GetRunningStream(STREAM_VOICE_CALL, 0), -1);
367 // Test case 7: Existing stream type but non-matching channel count
368 EXPECT_NE(collector->GetRunningStream(STREAM_MUSIC, 1), -1);
369 // Test case 8: Existing stream type and matching channel count, but not in RUNNING state
370 EXPECT_EQ(collector->GetRunningStream(STREAM_MOVIE, 2), -1);
371 // Test case 9: STREAM_NOTIFICATION
372 EXPECT_EQ(collector->GetRunningStream(STREAM_NOTIFICATION, 0), 4);
373 // Test case 10: STREAM_DTMF
374 EXPECT_NE(collector->GetRunningStream(STREAM_DTMF, 0), 5);
375 // Test case 11: STREAM_ALARM (mapped from UNKNOWN content type)
376 EXPECT_EQ(collector->GetRunningStream(STREAM_ALARM, 0), 6);
377 }
378
379 /**
380 * @tc.name : Test AudioStreamCollector.
381 * @tc.number: AudioStreamCollector_008
382 * @tc.desc : Test GetRunningStream.
383 */
384 HWTEST_F(AudioStreamCollectorUnitTest, AudioStreamCollector_008, TestSize.Level1)
385 {
386 AudioStreamCollector collector;
387 // Test SOURCE_TYPE_MIC
388 EXPECT_EQ(STREAM_MUSIC, collector.GetStreamTypeFromSourceType(SOURCE_TYPE_MIC));
389 // Test SOURCE_TYPE_VOICE_COMMUNICATION and SOURCE_TYPE_VOICE_CALL
390 EXPECT_EQ(STREAM_VOICE_CALL, collector.GetStreamTypeFromSourceType(SOURCE_TYPE_VOICE_COMMUNICATION));
391 EXPECT_EQ(STREAM_VOICE_CALL, collector.GetStreamTypeFromSourceType(SOURCE_TYPE_VOICE_CALL));
392 // Test SOURCE_TYPE_ULTRASONIC
393 EXPECT_EQ(STREAM_ULTRASONIC, collector.GetStreamTypeFromSourceType(SOURCE_TYPE_ULTRASONIC));
394 // Test SOURCE_TYPE_WAKEUP
395 EXPECT_EQ(STREAM_WAKEUP, collector.GetStreamTypeFromSourceType(SOURCE_TYPE_WAKEUP));
396 // Test SOURCE_TYPE_CAMCORDER
397 EXPECT_EQ(STREAM_CAMCORDER, collector.GetStreamTypeFromSourceType(SOURCE_TYPE_CAMCORDER));
398 // Test cases where sourceType is directly cast to AudioStreamType
399 EXPECT_EQ(static_cast<AudioStreamType>(SOURCE_TYPE_VOICE_RECOGNITION),
400 collector.GetStreamTypeFromSourceType(SOURCE_TYPE_VOICE_RECOGNITION));
401 EXPECT_EQ(static_cast<AudioStreamType>(SOURCE_TYPE_PLAYBACK_CAPTURE),
402 collector.GetStreamTypeFromSourceType(SOURCE_TYPE_PLAYBACK_CAPTURE));
403 EXPECT_EQ(static_cast<AudioStreamType>(SOURCE_TYPE_REMOTE_CAST),
404 collector.GetStreamTypeFromSourceType(SOURCE_TYPE_REMOTE_CAST));
405 EXPECT_EQ(static_cast<AudioStreamType>(SOURCE_TYPE_VIRTUAL_CAPTURE),
406 collector.GetStreamTypeFromSourceType(SOURCE_TYPE_VIRTUAL_CAPTURE));
407 EXPECT_EQ(static_cast<AudioStreamType>(SOURCE_TYPE_VOICE_MESSAGE),
408 collector.GetStreamTypeFromSourceType(SOURCE_TYPE_VOICE_MESSAGE));
409 // Test an invalid source type (should fall into default case)
410 EXPECT_EQ(static_cast<AudioStreamType>(SOURCE_TYPE_INVALID),
411 collector.GetStreamTypeFromSourceType(SOURCE_TYPE_INVALID));
412 }
413
414 /**
415 * @tc.name : Test AudioStreamCollector.
416 * @tc.number: AudioStreamCollector_009
417 * @tc.desc : Test UpdateCapturerInfoMuteStatus.
418 */
419 HWTEST_F(AudioStreamCollectorUnitTest, AudioStreamCollector_009, TestSize.Level1)
420 {
421 AudioStreamCollector collector;
422 auto changeInfo1 = std::make_unique<AudioCapturerChangeInfo>();
423 changeInfo1->clientUID = 1000;
424 changeInfo1->muted = false;
425 changeInfo1->sessionId = 1;
426 changeInfo1->capturerInfo.sourceType = SOURCE_TYPE_MIC;
427 changeInfo1->inputDeviceInfo.deviceType_ = DeviceType::DEVICE_TYPE_MIC;
428 auto changeInfo2 = std::make_unique<AudioCapturerChangeInfo>();
429 changeInfo2->clientUID = 2000;
430 changeInfo2->muted = false;
431 changeInfo2->sessionId = 2;
432 changeInfo2->capturerInfo.sourceType = SOURCE_TYPE_VOICE_RECOGNITION;
433 changeInfo2->inputDeviceInfo.deviceType_ = DeviceType::DEVICE_TYPE_MIC;
434 collector.audioCapturerChangeInfos_.push_back(std::move(changeInfo1));
435 collector.audioCapturerChangeInfos_.push_back(std::move(changeInfo2));
436 // Create a mock AudioPolicyServerHandler
437 collector.audioPolicyServerHandler_ = std::make_shared<AudioPolicyServerHandler>();
438 // Test updating mute status for a specific UID
439 EXPECT_EQ(SUCCESS, collector.UpdateCapturerInfoMuteStatus(1000, true));
440 EXPECT_TRUE(collector.audioCapturerChangeInfos_[0]->muted);
441 EXPECT_FALSE(collector.audioCapturerChangeInfos_[1]->muted);
442 // Test updating mute status for all UIDs (uid = 0)
443 EXPECT_EQ(SUCCESS, collector.UpdateCapturerInfoMuteStatus(0, false));
444 EXPECT_FALSE(collector.audioCapturerChangeInfos_[0]->muted);
445 EXPECT_FALSE(collector.audioCapturerChangeInfos_[1]->muted);
446 // Test updating mute status for a non-existent UID
447 EXPECT_EQ(SUCCESS, collector.UpdateCapturerInfoMuteStatus(3000, true));
448 EXPECT_FALSE(collector.audioCapturerChangeInfos_[0]->muted);
449 EXPECT_FALSE(collector.audioCapturerChangeInfos_[1]->muted);
450 // Test updating mute status with nullptr audioPolicyServerHandler_
451 collector.audioPolicyServerHandler_ = nullptr;
452 EXPECT_EQ(SUCCESS, collector.UpdateCapturerInfoMuteStatus(1000, true));
453 EXPECT_TRUE(collector.audioCapturerChangeInfos_[0]->muted);
454 EXPECT_FALSE(collector.audioCapturerChangeInfos_[1]->muted);
455 }
456
457 /**
458 * @tc.name : Test AudioStreamCollector.
459 * @tc.number: AudioStreamCollector_010
460 * @tc.desc : Test UpdateTracker.
461 */
462 HWTEST_F(AudioStreamCollectorUnitTest, AudioStreamCollector_010, TestSize.Level1)
463 {
464 AudioMode audioMode = AudioMode::AUDIO_MODE_PLAYBACK;
465 AudioDeviceDescriptor audioDev(AudioDeviceDescriptor::DEVICE_INFO);
466 AudioStreamCollector collector;
467
468 int32_t ret = collector.UpdateTracker(audioMode, audioDev);
469 EXPECT_EQ(SUCCESS, ret);
470
471 audioMode = AudioMode::AUDIO_MODE_RECORD;
472 ret = collector.UpdateTracker(audioMode, audioDev);
473 EXPECT_EQ(SUCCESS, ret);
474 }
475
476 /**
477 * @tc.name : Test AudioStreamCollector.
478 * @tc.number: AudioStreamCollector_011
479 * @tc.desc : Test UpdateTracker.
480 */
481 HWTEST_F(AudioStreamCollectorUnitTest, AudioStreamCollector_011, TestSize.Level1)
482 {
483 AudioMode audioMode = AudioMode::AUDIO_MODE_PLAYBACK;
484 AudioStreamChangeInfo streamChangeInfo;
485 streamChangeInfo.audioRendererChangeInfo.clientUID = 1001;
486 streamChangeInfo.audioRendererChangeInfo.sessionId = 2001;
487 streamChangeInfo.audioRendererChangeInfo.rendererState = RendererState::RENDERER_RUNNING;
488 sptr<IRemoteObject> clientTrackerObj = nullptr;
489 AudioStreamCollector collector;
490
491 int32_t ret = collector.RegisterTracker(audioMode, streamChangeInfo, clientTrackerObj);
492 EXPECT_EQ(ERR_INVALID_PARAM, ret);
493 ret = collector.UpdateTracker(audioMode, streamChangeInfo);
494 EXPECT_EQ(SUCCESS, ret);
495
496 audioMode = AudioMode::AUDIO_MODE_RECORD;
497 ret = collector.RegisterTracker(audioMode, streamChangeInfo, clientTrackerObj);
498 EXPECT_EQ(ERR_INVALID_PARAM, ret);
499 ret = collector.UpdateTracker(audioMode, streamChangeInfo);
500 EXPECT_EQ(SUCCESS, ret);
501 }
502
503 /**
504 * @tc.name : Test AudioStreamCollector.
505 * @tc.number: AudioStreamCollector_012
506 * @tc.desc : Test UnsetOffloadMode.
507 */
508 HWTEST_F(AudioStreamCollectorUnitTest, AudioStreamCollector_012, TestSize.Level1)
509 {
510 AudioStreamCollector collector;
511 int32_t streamId = -1;
512 AudioStreamChangeInfo streamChangeInfo;
513 streamChangeInfo.audioRendererChangeInfo.clientUID = 1001;
514 streamChangeInfo.audioRendererChangeInfo.sessionId = 2001;
515 streamChangeInfo.audioRendererChangeInfo.rendererState = RendererState::RENDERER_RUNNING;
516 sptr<IRemoteObject> object;
517 sptr<IStandardClientTracker> listener = iface_cast<IStandardClientTracker>(object);
518 std::shared_ptr<AudioClientTracker> callback = std::make_shared<ClientTrackerCallbackListener>(listener);
519 int32_t clientId = streamChangeInfo.audioRendererChangeInfo.sessionId;
520
521 collector.clientTracker_[clientId] = callback;
522
523 int32_t ret = collector.UnsetOffloadMode(streamId);
524 EXPECT_EQ(ERR_INVALID_PARAM, ret);
525
526 streamId = 2001;
527 ret = collector.UnsetOffloadMode(streamId);
528 EXPECT_EQ(SUCCESS, ret);
529 }
530
531 /**
532 * @tc.name : Test AudioStreamCollector.
533 * @tc.number: AudioStreamCollector_013
534 * @tc.desc : Test ExistStreamForPipe.
535 */
536 HWTEST_F(AudioStreamCollectorUnitTest, AudioStreamCollector_013, TestSize.Level1)
537 {
538 AudioStreamCollector collector;
539 AudioPipeType pipeType = PIPE_TYPE_UNKNOWN;
540 shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
541 AudioStreamChangeInfo streamChangeInfo;
542 streamChangeInfo.audioRendererChangeInfo.clientUID = 1001;
543 streamChangeInfo.audioRendererChangeInfo.sessionId = 2001;
544 streamChangeInfo.audioRendererChangeInfo.rendererState = RendererState::RENDERER_RUNNING;
545
546 bool result = collector.ExistStreamForPipe(pipeType);
547 EXPECT_FALSE(result);
548
549 rendererChangeInfo->createrUID = streamChangeInfo.audioRendererChangeInfo.createrUID;
550 rendererChangeInfo->clientUID = streamChangeInfo.audioRendererChangeInfo.clientUID;
551 collector.audioRendererChangeInfos_.push_back(move(rendererChangeInfo));
552 collector.audioRendererChangeInfos_[0]->rendererInfo.pipeType = PIPE_TYPE_MULTICHANNEL;
553
554 pipeType = PIPE_TYPE_MULTICHANNEL;
555 result = collector.ExistStreamForPipe(pipeType);
556 EXPECT_TRUE(result);
557 }
558
559 /**
560 * @tc.name : Test AudioStreamCollector.
561 * @tc.number: AudioStreamCollector_014
562 * @tc.desc : Test GetLastestRunningCallStreamUsage.
563 */
564 HWTEST_F(AudioStreamCollectorUnitTest, AudioStreamCollector_014, TestSize.Level1)
565 {
566 AudioStreamCollector collector;
567 StreamUsage callStreamUsage = collector.GetLastestRunningCallStreamUsage();
568 shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
569
570 EXPECT_EQ(STREAM_USAGE_UNKNOWN, callStreamUsage);
571
572 rendererChangeInfo->rendererInfo.streamUsage = STREAM_USAGE_VOICE_MODEM_COMMUNICATION;
573 rendererChangeInfo->rendererState = RENDERER_PREPARED;
574 collector.audioRendererChangeInfos_.push_back(move(rendererChangeInfo));
575
576 callStreamUsage = collector.GetLastestRunningCallStreamUsage();
577 EXPECT_EQ(STREAM_USAGE_VOICE_MODEM_COMMUNICATION, callStreamUsage);
578 }
579
580 /**
581 * @tc.name : Test AudioStreamCollector.
582 * @tc.number: AudioStreamCollector_015
583 * @tc.desc : Test RegisteredTrackerClientDied.
584 */
585 HWTEST_F(AudioStreamCollectorUnitTest, AudioStreamCollector_015, TestSize.Level1)
586 {
587 AudioStreamCollector collector;
588 int32_t uid = 1001;
589 StreamUsage callStreamUsage = collector.GetLastestRunningCallStreamUsage();
590 shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
591
592 rendererChangeInfo->clientUID = 1001;
593 rendererChangeInfo->createrUID = 1001;
594 rendererChangeInfo->sessionId = 2001;
595 collector.audioRendererChangeInfos_.push_back(move(rendererChangeInfo));
596 EXPECT_NO_THROW(
597 collector.RegisteredTrackerClientDied(uid);
598 );
599 }
600
601 /**
602 * @tc.name : Test AudioStreamCollector.
603 * @tc.number: AudioStreamCollector_016
604 * @tc.desc : Test GetCapturerStreamInfo.
605 */
606 HWTEST_F(AudioStreamCollectorUnitTest, AudioStreamCollector_016, TestSize.Level1)
607 {
608 AudioStreamCollector collector;
609 AudioStreamChangeInfo streamChangeInfo;
610 streamChangeInfo.audioCapturerChangeInfo.clientUID = 1001;
611 streamChangeInfo.audioCapturerChangeInfo.sessionId = 2001;
612 AudioCapturerChangeInfo capturerChangeInfo;
613 shared_ptr<AudioCapturerChangeInfo> rendererChangeInfo = make_shared<AudioCapturerChangeInfo>();
614
615 rendererChangeInfo->clientUID = 1001;
616 rendererChangeInfo->createrUID = 1001;
617 rendererChangeInfo->sessionId = 2001;
618 collector.audioCapturerChangeInfos_.push_back(move(rendererChangeInfo));
619
620 EXPECT_NO_THROW(
621 collector.GetCapturerStreamInfo(streamChangeInfo, capturerChangeInfo);
622 );
623 }
624
625 /**
626 * @tc.name : Test AudioStreamCollector.
627 * @tc.number: AudioStreamCollector_017
628 * @tc.desc : Test GetRendererStreamInfo.
629 */
630 HWTEST_F(AudioStreamCollectorUnitTest, AudioStreamCollector_017, TestSize.Level1)
631 {
632 AudioStreamCollector collector;
633 AudioStreamChangeInfo streamChangeInfo;
634 streamChangeInfo.audioCapturerChangeInfo.clientUID = 1001;
635 streamChangeInfo.audioCapturerChangeInfo.sessionId = 2001;
636 AudioRendererChangeInfo rendererInfo;
637 shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
638
639 rendererChangeInfo->clientUID = 1001;
640 rendererChangeInfo->createrUID = 1001;
641 rendererChangeInfo->sessionId = 2001;
642 collector.audioRendererChangeInfos_.push_back(move(rendererChangeInfo));
643 EXPECT_NO_THROW(
644 collector.GetRendererStreamInfo(streamChangeInfo, rendererInfo);
645 );
646 }
647
648 /**
649 * @tc.name : Test AudioStreamCollector.
650 * @tc.number: AudioStreamCollector_018
651 * @tc.desc : Test CheckRendererInfoChanged.
652 */
653 HWTEST_F(AudioStreamCollectorUnitTest, AudioStreamCollector_018, TestSize.Level1)
654 {
655 AudioStreamCollector collector;
656 AudioStreamChangeInfo streamChangeInfo;
657 streamChangeInfo.audioRendererChangeInfo.clientUID = 1001;
658 streamChangeInfo.audioRendererChangeInfo.sessionId = 2001;
659 streamChangeInfo.audioRendererChangeInfo.rendererState = RendererState::RENDERER_RUNNING;
660 shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
661
662 bool result = collector.CheckRendererInfoChanged(streamChangeInfo);
663 EXPECT_TRUE(result);
664
665 rendererChangeInfo->clientUID = 1001;
666 rendererChangeInfo->createrUID = 1001;
667 rendererChangeInfo->sessionId = 2001;
668 rendererChangeInfo->rendererInfo.pipeType = PIPE_TYPE_MULTICHANNEL;
669 collector.audioRendererChangeInfos_.push_back(move(rendererChangeInfo));
670
671 result = collector.CheckRendererInfoChanged(streamChangeInfo);
672 EXPECT_TRUE(result);
673 }
674
675 /**
676 * @tc.name : Test AudioStreamCollector.
677 * @tc.number: AudioStreamCollector_019
678 * @tc.desc : Test SetRendererStreamParam.
679 */
680 HWTEST_F(AudioStreamCollectorUnitTest, AudioStreamCollector_019, TestSize.Level1)
681 {
682 AudioStreamCollector collector;
683 AudioStreamChangeInfo streamChangeInfo;
684 streamChangeInfo.audioRendererChangeInfo.clientUID = 1001;
685 streamChangeInfo.audioRendererChangeInfo.sessionId = 2001;
686 streamChangeInfo.audioRendererChangeInfo.rendererState = RendererState::RENDERER_RUNNING;
687 shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
688
689 EXPECT_NO_THROW(
690 collector.SetRendererStreamParam(streamChangeInfo, rendererChangeInfo);
691 );
692 }
693
694 /**
695 * @tc.name : Test AudioStreamCollector.
696 * @tc.number: AudioStreamCollector_020
697 * @tc.desc : Test UpdateRendererStreamInternal.
698 */
699 HWTEST_F(AudioStreamCollectorUnitTest, AudioStreamCollector_020, TestSize.Level1)
700 {
701 AudioStreamCollector collector;
702 AudioStreamChangeInfo streamChangeInfo;
703 streamChangeInfo.audioRendererChangeInfo.clientUID = 1001;
704 streamChangeInfo.audioRendererChangeInfo.sessionId = 2001;
705 streamChangeInfo.audioRendererChangeInfo.rendererState = RendererState::RENDERER_RUNNING;
706 shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
707
708 int32_t ret = collector.UpdateRendererStreamInternal(streamChangeInfo);
709 EXPECT_EQ(ERROR, ret);
710
711 rendererChangeInfo->clientUID = 1001;
712 rendererChangeInfo->createrUID = 1001;
713 rendererChangeInfo->sessionId = 2001;
714 rendererChangeInfo->rendererInfo.pipeType = PIPE_TYPE_MULTICHANNEL;
715 collector.audioRendererChangeInfos_.push_back(move(rendererChangeInfo));
716
717 ret = collector.UpdateRendererStreamInternal(streamChangeInfo);
718 EXPECT_EQ(SUCCESS, ret);
719 }
720
721 /**
722 * @tc.name : Test AudioStreamCollector.
723 * @tc.number: AudioStreamCollector_021
724 * @tc.desc : Test GetPipeType.
725 */
726 HWTEST_F(AudioStreamCollectorUnitTest, AudioStreamCollector_021, TestSize.Level1)
727 {
728 AudioStreamCollector collector;
729 int32_t sessionId = -1;
730 AudioPipeType pipeType = PIPE_TYPE_UNKNOWN;
731 shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
732
733 int32_t ret = collector.GetPipeType(sessionId, pipeType);
734 EXPECT_EQ(ERROR, ret);
735
736 sessionId = 2001;
737 rendererChangeInfo->clientUID = 1001;
738 rendererChangeInfo->createrUID = 1001;
739 rendererChangeInfo->sessionId = 2001;
740 rendererChangeInfo->rendererInfo.pipeType = PIPE_TYPE_MULTICHANNEL;
741 collector.audioRendererChangeInfos_.push_back(move(rendererChangeInfo));
742
743 ret = collector.GetPipeType(sessionId, pipeType);
744 EXPECT_EQ(SUCCESS, ret);
745 }
746
747 /**
748 * @tc.name : Test AudioStreamCollector.
749 * @tc.number: AudioStreamCollector_022
750 * @tc.desc : Test GetRendererDeviceInfo.
751 */
752 HWTEST_F(AudioStreamCollectorUnitTest, AudioStreamCollector_022, TestSize.Level1)
753 {
754 AudioStreamCollector collector;
755 int32_t sessionId = -1;
756 AudioDeviceDescriptor deviceInfo(AudioDeviceDescriptor::DEVICE_INFO);
757 shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
758
759 int32_t ret = collector.GetRendererDeviceInfo(sessionId, deviceInfo);
760 EXPECT_EQ(ERROR, ret);
761
762 sessionId = 2001;
763 rendererChangeInfo->clientUID = 1001;
764 rendererChangeInfo->createrUID = 1001;
765 rendererChangeInfo->sessionId = 2001;
766 rendererChangeInfo->rendererInfo.pipeType = PIPE_TYPE_MULTICHANNEL;
767 collector.audioRendererChangeInfos_.push_back(move(rendererChangeInfo));
768
769 ret = collector.GetRendererDeviceInfo(sessionId, deviceInfo);
770 EXPECT_EQ(SUCCESS, ret);
771 }
772
773 /**
774 * @tc.name : Test AudioStreamCollector.
775 * @tc.number: AudioStreamCollector_023
776 * @tc.desc : Test UpdateRendererPipeInfo.
777 */
778 HWTEST_F(AudioStreamCollectorUnitTest, AudioStreamCollector_023, TestSize.Level1)
779 {
780 AudioStreamCollector collector;
781 int32_t sessionId = 2001;
782 AudioPipeType normalPipe = PIPE_TYPE_NORMAL_OUT;
783 shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
784
785 rendererChangeInfo->clientUID = 1001;
786 rendererChangeInfo->createrUID = 1001;
787 rendererChangeInfo->sessionId = 2001;
788 rendererChangeInfo->rendererInfo.pipeType = PIPE_TYPE_MULTICHANNEL;
789 collector.audioRendererChangeInfos_.push_back(move(rendererChangeInfo));
790
791 int32_t ret = collector.UpdateRendererPipeInfo(sessionId, normalPipe);
792 EXPECT_EQ(SUCCESS, ret);
793 }
794
795 /**
796 * @tc.name : Test AudioStreamCollector.
797 * @tc.number: AudioStreamCollector_024
798 * @tc.desc : Test GetLowPowerVolume.
799 */
800 HWTEST_F(AudioStreamCollectorUnitTest, AudioStreamCollector_024, TestSize.Level1)
801 {
802 int32_t streamId = -1;
803 AudioStreamCollector collector;
804
805 float ret = collector.GetLowPowerVolume(streamId);
806 EXPECT_EQ(1.0, ret);
807 }
808
809 /**
810 * @tc.name : Test AudioStreamCollector.
811 * @tc.number: AudioStreamCollector_025
812 * @tc.desc : Test SetOffloadMode.
813 */
814 HWTEST_F(AudioStreamCollectorUnitTest, AudioStreamCollector_025, TestSize.Level1)
815 {
816 int32_t streamId = -1;
817 int32_t state = 0;
818 bool isAppBack = false;
819 AudioStreamCollector collector;
820
821 int32_t ret = collector.SetOffloadMode(streamId, state, isAppBack);
822 EXPECT_EQ(ERR_INVALID_PARAM, ret);
823 }
824
825 /**
826 * @tc.name : Test AudioStreamCollector.
827 * @tc.number: AudioStreamCollector_026
828 * @tc.desc : Test GetSingleStreamVolume.
829 */
830 HWTEST_F(AudioStreamCollectorUnitTest, AudioStreamCollector_026, TestSize.Level1)
831 {
832 int32_t streamId = -1;
833 AudioStreamCollector collector;
834
835 float ret = collector.GetSingleStreamVolume(streamId);
836 EXPECT_EQ(1.0, ret);
837 }
838
839 /**
840 * @tc.name : Test AudioStreamCollector.
841 * @tc.number: AudioStreamCollector_027
842 * @tc.desc : Test IsCallStreamUsage.
843 */
844 HWTEST_F(AudioStreamCollectorUnitTest, AudioStreamCollector_027, TestSize.Level1)
845 {
846 StreamUsage usage = STREAM_USAGE_VOICE_COMMUNICATION;
847 AudioStreamCollector collector;
848
849 bool ret = collector.IsCallStreamUsage(usage);
850 EXPECT_TRUE(ret);
851
852 usage = STREAM_USAGE_UNKNOWN;
853 ret = collector.IsCallStreamUsage(usage);
854 EXPECT_FALSE(ret);
855 }
856
857 /**
858 * @tc.name : Test AudioStreamCollector.
859 * @tc.number: AudioStreamCollector_028
860 * @tc.desc : Test SetCapturerStreamParam.
861 */
862 HWTEST_F(AudioStreamCollectorUnitTest, AudioStreamCollector_028, TestSize.Level1)
863 {
864 AudioStreamCollector collector;
865 AudioStreamChangeInfo streamChangeInfo;
866 streamChangeInfo.audioRendererChangeInfo.clientUID = 1001;
867 streamChangeInfo.audioRendererChangeInfo.sessionId = 2001;
868 streamChangeInfo.audioRendererChangeInfo.rendererState = RendererState::RENDERER_RUNNING;
869 shared_ptr<AudioCapturerChangeInfo> rendererChangeInfo = make_shared<AudioCapturerChangeInfo>();
870
871 EXPECT_NO_THROW(
872 collector.SetCapturerStreamParam(streamChangeInfo, rendererChangeInfo);
873 );
874 }
875
876 /**
877 * @tc.name : Test AudioStreamCollector.
878 * @tc.number: AudioStreamCollector_029
879 * @tc.desc : Test ResetRendererStreamDeviceInfo.
880 */
881 HWTEST_F(AudioStreamCollectorUnitTest, AudioStreamCollector_029, TestSize.Level1)
882 {
883 AudioStreamCollector collector;
884 AudioDeviceDescriptor outputDeviceInfo(AudioDeviceDescriptor::DEVICE_INFO);
885 shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
886
887 rendererChangeInfo->clientUID = 1001;
888 rendererChangeInfo->createrUID = 1001;
889 rendererChangeInfo->sessionId = 2001;
890 rendererChangeInfo->rendererInfo.pipeType = PIPE_TYPE_MULTICHANNEL;
891 collector.audioRendererChangeInfos_.push_back(move(rendererChangeInfo));
892
893 EXPECT_NO_THROW(
894 collector.ResetRendererStreamDeviceInfo(outputDeviceInfo);
895 );
896 }
897
898 /**
899 * @tc.name : Test AudioStreamCollector.
900 * @tc.number: AudioStreamCollector_030
901 * @tc.desc : Test ResetCapturerStreamDeviceInfo.
902 */
903 HWTEST_F(AudioStreamCollectorUnitTest, AudioStreamCollector_030, TestSize.Level1)
904 {
905 AudioStreamCollector collector;
906 AudioDeviceDescriptor outputDeviceInfo(AudioDeviceDescriptor::DEVICE_INFO);
907 shared_ptr<AudioCapturerChangeInfo> rendererChangeInfo = make_shared<AudioCapturerChangeInfo>();
908
909 rendererChangeInfo->clientUID = 1001;
910 rendererChangeInfo->createrUID = 1001;
911 rendererChangeInfo->sessionId = 2001;
912 collector.audioCapturerChangeInfos_.push_back(move(rendererChangeInfo));
913
914 EXPECT_NO_THROW(
915 collector.ResetCapturerStreamDeviceInfo(outputDeviceInfo);
916 );
917 }
918
919 /**
920 * @tc.name : Test AudioStreamCollector.
921 * @tc.number: AudioStreamCollector_031
922 * @tc.desc : Test UpdateRendererDeviceInfo.
923 */
924 HWTEST_F(AudioStreamCollectorUnitTest, AudioStreamCollector_031, TestSize.Level1)
925 {
926 AudioStreamCollector collector;
927 AudioDeviceDescriptor outputDeviceInfo(AudioDeviceDescriptor::DEVICE_INFO);
928 shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
929 int32_t clientUID = 1001;
930 int32_t sessionId = 2001;
931
932 rendererChangeInfo->clientUID = 1001;
933 rendererChangeInfo->createrUID = 1001;
934 rendererChangeInfo->sessionId = 2001;
935 rendererChangeInfo->outputDeviceInfo = outputDeviceInfo;
936 collector.audioRendererChangeInfos_.push_back(move(rendererChangeInfo));
937
938 int32_t ret = collector.UpdateRendererDeviceInfo(clientUID, sessionId, outputDeviceInfo);
939 EXPECT_EQ(SUCCESS, ret);
940 }
941
942 /**
943 * @tc.name : Test AudioStreamCollector.
944 * @tc.number: AudioStreamCollector_032
945 * @tc.desc : Test UpdateCapturerDeviceInfo.
946 */
947 HWTEST_F(AudioStreamCollectorUnitTest, AudioStreamCollector_032, TestSize.Level1)
948 {
949 AudioStreamCollector collector;
950 AudioDeviceDescriptor outputDeviceInfo(AudioDeviceDescriptor::DEVICE_INFO);
951 shared_ptr<AudioCapturerChangeInfo> rendererChangeInfo = make_shared<AudioCapturerChangeInfo>();
952 int32_t clientUID = 1001;
953 int32_t sessionId = 2001;
954
955 rendererChangeInfo->clientUID = 1001;
956 rendererChangeInfo->createrUID = 1001;
957 rendererChangeInfo->sessionId = 2001;
958 rendererChangeInfo->inputDeviceInfo = outputDeviceInfo;
959 collector.audioCapturerChangeInfos_.push_back(move(rendererChangeInfo));
960
961 int32_t ret = collector.UpdateCapturerDeviceInfo(clientUID, sessionId, outputDeviceInfo);
962 EXPECT_EQ(SUCCESS, ret);
963 }
964
965 /**
966 * @tc.name : Test AudioStreamCollector.
967 * @tc.number: AudioStreamCollector_033
968 * @tc.desc : Test UpdateTrackerInternal.
969 */
970 HWTEST_F(AudioStreamCollectorUnitTest, AudioStreamCollector_033, TestSize.Level1)
971 {
972 AudioStreamCollector audioStreamCollector;
973 AudioMode mode = AUDIO_MODE_PLAYBACK;
974 AudioStreamChangeInfo streamChangeInfo;
975 streamChangeInfo.audioRendererChangeInfo.clientUID = 1001;
976 streamChangeInfo.audioRendererChangeInfo.sessionId = 2001;
977
978 int32_t ret = audioStreamCollector.UpdateTrackerInternal(mode, streamChangeInfo);
979 EXPECT_EQ(ERROR, ret);
980
981 mode = AUDIO_MODE_RECORD;
982 ret = audioStreamCollector.UpdateTrackerInternal(mode, streamChangeInfo);
983 EXPECT_EQ(SUCCESS, ret);
984 }
985
986 /**
987 * @tc.name : Test AudioStreamCollector.
988 * @tc.number: AudioStreamCollector_034
989 * @tc.desc : Test GetStreamType.
990 */
991 HWTEST_F(AudioStreamCollectorUnitTest, AudioStreamCollector_034, TestSize.Level1)
992 {
993 AudioStreamCollector audioStreamCollector;
994 ContentType contentType = CONTENT_TYPE_UNKNOWN;
995 StreamUsage streamUsage = StreamUsage::STREAM_USAGE_MEDIA;
996
997 AudioStreamType streamType = audioStreamCollector.GetStreamType(contentType, streamUsage);
998 EXPECT_EQ(STREAM_MUSIC, streamType);
999 }
1000
1001 /**
1002 * @tc.name : Test AudioStreamCollector.
1003 * @tc.number: AudioStreamCollector_035
1004 * @tc.desc : Test IsOffloadAllowed.
1005 */
1006 HWTEST_F(AudioStreamCollectorUnitTest, AudioStreamCollector_035, TestSize.Level1)
1007 {
1008 AudioStreamCollector collector;
1009 shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
1010 int32_t sessionId = -1;
1011
1012 bool ret = collector.IsOffloadAllowed(sessionId);
1013 EXPECT_FALSE(ret);
1014
1015 sessionId = 2001;
1016 rendererChangeInfo->createrUID = 1001;
1017 rendererChangeInfo->clientUID = 1001;
1018 rendererChangeInfo->sessionId = 2001;
1019 collector.audioRendererChangeInfos_.push_back(move(rendererChangeInfo));
1020
1021 ret = collector.IsOffloadAllowed(sessionId);
1022 EXPECT_TRUE(ret);
1023 }
1024
1025 /**
1026 * @tc.name : Test AudioStreamCollector.
1027 * @tc.number: AudioStreamCollector_036
1028 * @tc.desc : Test GetChannelCount.
1029 */
1030 HWTEST_F(AudioStreamCollectorUnitTest, AudioStreamCollector_036, TestSize.Level1)
1031 {
1032 AudioStreamCollector collector;
1033 shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
1034 int32_t sessionId = -1;
1035
1036 int32_t ret = collector.GetChannelCount(sessionId);
1037 EXPECT_EQ(0, ret);
1038
1039 sessionId = 2001;
1040 rendererChangeInfo->createrUID = 1001;
1041 rendererChangeInfo->clientUID = 1001;
1042 rendererChangeInfo->sessionId = 2001;
1043 collector.audioRendererChangeInfos_.push_back(move(rendererChangeInfo));
1044
1045 ret = collector.GetChannelCount(sessionId);
1046 EXPECT_EQ(0, ret);
1047 }
1048
1049 /**
1050 * @tc.name : Test AudioStreamCollector.
1051 * @tc.number: AudioStreamCollector_037
1052 * @tc.desc : Test GetCurrentRendererChangeInfos.
1053 */
1054 HWTEST_F(AudioStreamCollectorUnitTest, AudioStreamCollector_037, TestSize.Level1)
1055 {
1056 AudioStreamCollector collector;
1057 shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
1058 std::vector<shared_ptr<AudioRendererChangeInfo>> rendererChangeInfos;
1059
1060 rendererChangeInfo->createrUID = 1001;
1061 rendererChangeInfo->clientUID = 1001;
1062 rendererChangeInfo->sessionId = 2001;
1063 collector.audioRendererChangeInfos_.push_back(move(rendererChangeInfo));
1064
1065 int32_t ret = collector.GetCurrentRendererChangeInfos(rendererChangeInfos);
1066 EXPECT_EQ(SUCCESS, ret);
1067 }
1068
1069 /**
1070 * @tc.name : Test AudioStreamCollector.
1071 * @tc.number: AudioStreamCollector_038
1072 * @tc.desc : Test GetCurrentCapturerChangeInfos.
1073 */
1074 HWTEST_F(AudioStreamCollectorUnitTest, AudioStreamCollector_038, TestSize.Level1)
1075 {
1076 AudioStreamCollector collector;
1077 shared_ptr<AudioCapturerChangeInfo> rendererChangeInfo = make_shared<AudioCapturerChangeInfo>();
1078 std::vector<shared_ptr<AudioCapturerChangeInfo>> rendererChangeInfos;
1079
1080 rendererChangeInfo->createrUID = 1001;
1081 rendererChangeInfo->clientUID = 1001;
1082 rendererChangeInfo->sessionId = 2001;
1083 collector.audioCapturerChangeInfos_.push_back(move(rendererChangeInfo));
1084
1085 int32_t ret = collector.GetCurrentCapturerChangeInfos(rendererChangeInfos);
1086 EXPECT_EQ(SUCCESS, ret);
1087 }
1088
1089 /**
1090 * @tc.name : Test AudioStreamCollector.
1091 * @tc.number: AudioStreamCollector_039
1092 * @tc.desc : Test GetUid.
1093 */
1094 HWTEST_F(AudioStreamCollectorUnitTest, AudioStreamCollector_039, TestSize.Level1)
1095 {
1096 AudioStreamCollector collector;
1097 shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
1098 int32_t sessionId = -1;
1099
1100 rendererChangeInfo->createrUID = 1001;
1101 rendererChangeInfo->clientUID = 1001;
1102 rendererChangeInfo->sessionId = 2001;
1103 collector.audioRendererChangeInfos_.push_back(move(rendererChangeInfo));
1104
1105 int32_t ret = collector.GetUid(sessionId);
1106 EXPECT_EQ(-1, ret);
1107
1108 sessionId = 2001;
1109 ret = collector.GetUid(sessionId);
1110 EXPECT_EQ(1001, ret);
1111 }
1112
1113 /**
1114 * @tc.name : Test AudioStreamCollector.
1115 * @tc.number: AudioStreamCollector_040
1116 * @tc.desc : Test IsStreamActive.
1117 */
1118 HWTEST_F(AudioStreamCollectorUnitTest, AudioStreamCollector_040, TestSize.Level1)
1119 {
1120 AudioStreamCollector collector;
1121 AudioStreamType volumeType = STREAM_MUSIC;
1122 shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
1123
1124 rendererChangeInfo->createrUID = 1001;
1125 rendererChangeInfo->clientUID = 1001;
1126 rendererChangeInfo->sessionId = 2001;
1127 rendererChangeInfo->rendererState = RENDERER_RUNNING;
1128 collector.audioRendererChangeInfos_.push_back(move(rendererChangeInfo));
1129
1130 bool ret = collector.IsStreamActive(volumeType);
1131 EXPECT_TRUE(ret);
1132 }
1133
1134 /**
1135 * @tc.name : Test AudioStreamCollector.
1136 * @tc.number: AudioStreamCollector_041
1137 * @tc.desc : Test ActivateAudioConcurrency.
1138 */
1139 HWTEST_F(AudioStreamCollectorUnitTest, AudioStreamCollector_041, TestSize.Level1)
1140 {
1141 AudioStreamCollector collector;
1142 AudioPipeType pipeType = PIPE_TYPE_UNKNOWN;
1143
1144 int32_t ret = collector.ActivateAudioConcurrency(pipeType);
1145 EXPECT_EQ(SUCCESS, ret);
1146 }
1147
1148 /**
1149 * @tc.name : Test AudioStreamCollector.
1150 * @tc.number: AudioStreamCollector_042
1151 * @tc.desc : Test GetAllRendererSessionIDForUID.
1152 */
1153 HWTEST_F(AudioStreamCollectorUnitTest, AudioStreamCollector_042, TestSize.Level1)
1154 {
1155 AudioStreamCollector collector;
1156 int32_t uid = 1001;
1157 shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
1158
1159 rendererChangeInfo->clientUID = 1001;
1160 rendererChangeInfo->createrUID = 1001;
1161 rendererChangeInfo->sessionId = 2001;
1162 collector.audioRendererChangeInfos_.push_back(move(rendererChangeInfo));
1163
1164 EXPECT_NO_THROW(
1165 collector.GetAllRendererSessionIDForUID(uid);
1166 );
1167 }
1168
1169 /**
1170 * @tc.name : Test AudioStreamCollector.
1171 * @tc.number: AudioStreamCollector_043
1172 * @tc.desc : Test ChangeVoipCapturerStreamToNormal.
1173 */
1174 HWTEST_F(AudioStreamCollectorUnitTest, AudioStreamCollector_043, TestSize.Level1)
1175 {
1176 AudioStreamCollector collector;
1177 shared_ptr<AudioCapturerChangeInfo> rendererChangeInfo = make_shared<AudioCapturerChangeInfo>();
1178 shared_ptr<AudioCapturerChangeInfo> rendererChangeInfo1 = make_shared<AudioCapturerChangeInfo>();
1179
1180 rendererChangeInfo->clientUID = 1001;
1181 rendererChangeInfo->createrUID = 1001;
1182 rendererChangeInfo->sessionId = 2001;
1183 rendererChangeInfo->capturerInfo.sourceType = SOURCE_TYPE_VOICE_COMMUNICATION;
1184 collector.audioCapturerChangeInfos_.push_back(move(rendererChangeInfo));
1185
1186 rendererChangeInfo1->clientUID = 1001;
1187 rendererChangeInfo1->createrUID = 1001;
1188 rendererChangeInfo1->sessionId = 2001;
1189 rendererChangeInfo1->capturerInfo.sourceType = SOURCE_TYPE_VOICE_MESSAGE;
1190 collector.audioCapturerChangeInfos_.push_back(move(rendererChangeInfo1));
1191
1192 bool ret = collector.ChangeVoipCapturerStreamToNormal();
1193 EXPECT_TRUE(ret);
1194 }
1195
1196 /**
1197 * @tc.name : Test AudioStreamCollector.
1198 * @tc.number: AudioStreamCollector_044
1199 * @tc.desc : Test HasVoipRendererStream.
1200 */
1201 HWTEST_F(AudioStreamCollectorUnitTest, AudioStreamCollector_044, TestSize.Level1)
1202 {
1203 AudioStreamCollector collector;
1204 int32_t uid = 1001;
1205 shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
1206
1207 rendererChangeInfo->clientUID = 1001;
1208 rendererChangeInfo->createrUID = 1001;
1209 rendererChangeInfo->sessionId = 2001;
1210 rendererChangeInfo->rendererInfo.originalFlag = AUDIO_FLAG_VOIP_FAST;
1211 collector.audioRendererChangeInfos_.push_back(move(rendererChangeInfo));
1212
1213 bool ret = collector.HasVoipRendererStream();
1214 EXPECT_TRUE(ret);
1215 }
1216
1217 /**
1218 * @tc.name : IsMediaPlaying_Test01
1219 * @tc.number: AudioStreamCollectorUnitTest_IsMediaPlaying_Test01
1220 * @tc.desc : Test IsMediaPlaying function when there is at least one media renderer running.
1221 */
1222 HWTEST_F(AudioStreamCollectorUnitTest, IsMediaPlaying_Test01, TestSize.Level1)
1223 {
1224 std::unique_ptr<AudioStreamCollector> collector = std::make_unique<AudioStreamCollector>();
1225 AudioRendererInfo rendererInfo1 = {
1226 .contentType = CONTENT_TYPE_MUSIC, .streamUsage = STREAM_USAGE_MEDIA
1227 };
1228 std::unique_ptr<AudioRendererChangeInfo> info1 = std::make_unique<AudioRendererChangeInfo>();
1229 info1->sessionId = 1;
1230 info1->rendererState = RENDERER_PAUSED;
1231 info1->rendererInfo = rendererInfo1;
1232 info1->channelCount = 2;
1233 collector->audioRendererChangeInfos_.push_back(std::move(info1));
1234 bool result = collector->IsMediaPlaying();
1235 EXPECT_FALSE(result);
1236
1237 AudioRendererInfo rendererInfo2 = {
1238 .contentType = CONTENT_TYPE_SPEECH, .streamUsage = STREAM_USAGE_VOICE_COMMUNICATION
1239 };
1240 std::unique_ptr<AudioRendererChangeInfo> info2 = std::make_unique<AudioRendererChangeInfo>();
1241 info2->sessionId = 2;
1242 info2->rendererState = RENDERER_RUNNING;
1243 info2->rendererInfo = rendererInfo2;
1244 info2->channelCount = 1;
1245 collector->audioRendererChangeInfos_.push_back(std::move(info2));
1246 result = collector->IsMediaPlaying();
1247 EXPECT_FALSE(result);
1248
1249 AudioRendererInfo rendererInfo3 = {
1250 .contentType = CONTENT_TYPE_MOVIE, .streamUsage = STREAM_USAGE_MEDIA
1251 };
1252 std::unique_ptr<AudioRendererChangeInfo> info3 = std::make_unique<AudioRendererChangeInfo>();
1253 info3->sessionId = 3;
1254 info3->rendererState = RENDERER_RUNNING;
1255 info3->rendererInfo = rendererInfo3;
1256 info3->channelCount = 2;
1257 collector->audioRendererChangeInfos_.push_back(std::move(info3));
1258 result = collector->IsMediaPlaying();
1259 EXPECT_TRUE(result);
1260 }
1261 } // namespace AudioStandard
1262 } // namespace OHOS
1263