1 /*
2 * Copyright (c) 2024 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 <iostream>
17 #include "gtest/gtest.h"
18 #include "audio_errors.h"
19 #include "audio_offload_stream_unit_test.h"
20 #include "audio_spatialization_service.h"
21
22 using namespace testing::ext;
23
24 namespace OHOS {
25 namespace AudioStandard {
SetUpTestCase(void)26 void AudioOffloadStreamTest::SetUpTestCase(void) {}
TearDownTestCase(void)27 void AudioOffloadStreamTest::TearDownTestCase(void) {}
SetUp(void)28 void AudioOffloadStreamTest::SetUp(void)
29 {
30 audioOffloadStream_ = &AudioOffloadStream::GetInstance();
31 }
TearDown(void)32 void AudioOffloadStreamTest::TearDown(void)
33 {
34 if (audioOffloadStream_ != nullptr) {
35 audioOffloadStream_ = nullptr;
36 }
37 }
38
39 /**
40 * @tc.name : HandlePowerStateChanged_NoChange_Test
41 * @tc.number: AudioOffloadStreamTest_001
42 * @tc.desc : Test scenario where the power state does not change.
43 */
44 HWTEST_F(AudioOffloadStreamTest, HandlePowerStateChanged_NoChange_Test, TestSize.Level2)
45 {
46 audioOffloadStream_->currentPowerState_ = PowerMgr::PowerState::FREEZE;
47 PowerMgr::PowerState state = PowerMgr::PowerState::FREEZE;
48 audioOffloadStream_->HandlePowerStateChanged(state);
49 EXPECT_EQ(audioOffloadStream_->currentPowerState_, PowerMgr::PowerState::FREEZE);
50 }
51
52 /**
53 * @tc.name : HandlePowerStateChanged_ActiveToInactive_Test
54 * @tc.number: AudioOffloadStreamTest_002
55 * @tc.desc : Test scenario where the power state changes from ACTIVE to INACTIVE.
56 */
57 HWTEST_F(AudioOffloadStreamTest, HandlePowerStateChanged_ActiveToInactive_Test, TestSize.Level2)
58 {
59 audioOffloadStream_->currentPowerState_ = PowerMgr::PowerState::FREEZE;
60 PowerMgr::PowerState state = PowerMgr::PowerState::INACTIVE;
61 audioOffloadStream_->HandlePowerStateChanged(state);
62 EXPECT_EQ(audioOffloadStream_->currentPowerState_, PowerMgr::PowerState::INACTIVE);
63 }
64
65 /**
66 * @tc.name : HandlePowerStateChanged_NoOffloadSupport_Test
67 * @tc.number: AudioOffloadStreamTest_003
68 * @tc.desc : Test scenario where the device does not support offload.
69 */
70 HWTEST_F(AudioOffloadStreamTest, HandlePowerStateChanged_NoOffloadSupport_Test, TestSize.Level3)
71 {
72 audioOffloadStream_->currentPowerState_ = PowerMgr::PowerState::FREEZE;
73 PowerMgr::PowerState state = PowerMgr::PowerState::FREEZE;
74 audioOffloadStream_->HandlePowerStateChanged(state);
75 EXPECT_EQ(audioOffloadStream_->currentPowerState_, PowerMgr::PowerState::FREEZE);
76 }
77
78 /**
79 * @tc.name : HandlePowerStateChanged_OffloadSessionIDNotSet_Test
80 * @tc.number: audioOffloadStreamTest_004
81 * @tc.desc : Test scenario where the offload session ID is not set.
82 */
83 HWTEST_F(AudioOffloadStreamTest, HandlePowerStateChanged_OffloadSessionIDNotSet_Test, TestSize.Level3)
84 {
85 audioOffloadStream_->currentPowerState_ = PowerMgr::PowerState::FREEZE;
86 PowerMgr::PowerState state = PowerMgr::PowerState::FREEZE;
87 audioOffloadStream_->offloadSessionID_ = std::nullopt;
88 audioOffloadStream_->HandlePowerStateChanged(state);
89 EXPECT_EQ(audioOffloadStream_->currentPowerState_, PowerMgr::PowerState::FREEZE);
90 }
91
92 /**
93 * @tc.name : HandlePowerStateChanged_OffloadSessionIDSet_Test
94 * @tc.number: audioOffloadStreamTest_005
95 * @tc.desc : Test scenario where the offload session ID is set.
96 */
97 HWTEST_F(AudioOffloadStreamTest, HandlePowerStateChanged_OffloadSessionIDSet_Test, TestSize.Level3)
98 {
99 audioOffloadStream_->currentPowerState_ = PowerMgr::PowerState::FREEZE;
100 PowerMgr::PowerState state = PowerMgr::PowerState::FREEZE;
101 audioOffloadStream_->offloadSessionID_ = 1;
102 audioOffloadStream_->HandlePowerStateChanged(state);
103 EXPECT_EQ(audioOffloadStream_->currentPowerState_, PowerMgr::PowerState::FREEZE);
104
105 bool oldState = audioOffloadStream_->isOffloadAvailable_;
106 audioOffloadStream_->isOffloadAvailable_ = false;
107 audioOffloadStream_->audioActiveDevice_.currentActiveDevice_.deviceType_ = DEVICE_TYPE_SPEAKER;
108 audioOffloadStream_->HandlePowerStateChanged(PowerMgr::PowerState::INACTIVE);
109 audioOffloadStream_->isOffloadAvailable_ = oldState;
110 EXPECT_FALSE(audioOffloadStream_->GetOffloadAvailableFromXml());
111 }
112
113 /**
114 * @tc.name : CheckStreamOffloadMode_001
115 * @tc.number: Audio_OffloadStream_006
116 * @tc.desc : Test CheckStreamOffloadMode when offload not available from xml.
117 */
118 HWTEST_F(AudioOffloadStreamTest, CheckStreamOffloadMode_001, TestSize.Level3)
119 {
120 // 模拟GetOffloadAvailableFromXml返回false
121 audioOffloadStream_->isOffloadAvailable_ = false;
122 AudioStreamType streamType = AudioStreamType::STREAM_MUSIC;
123 int64_t activateSessionId = 1;
124
125 bool result = audioOffloadStream_->CheckStreamOffloadMode(activateSessionId, streamType);
126 EXPECT_FALSE(result);
127 }
128
129 /**
130 * @tc.name : CheckStreamOffloadMode_002
131 * @tc.number: Audio_OffloadStream_007
132 * @tc.desc : Test CheckStreamOffloadMode when offload not available on current output device.
133 */
134 HWTEST_F(AudioOffloadStreamTest, CheckStreamOffloadMode_002, TestSize.Level3)
135 {
136 // 模拟GetOffloadAvailableFromXml返回true
137 audioOffloadStream_->isOffloadAvailable_ = true;
138
139 AudioStreamType streamType = AudioStreamType::STREAM_MUSIC;
140 int64_t activateSessionId = 1;
141 bool result = audioOffloadStream_->CheckStreamOffloadMode(activateSessionId, streamType);
142 EXPECT_FALSE(result);
143 }
144
145 /**
146 * @tc.name : CheckStreamOffloadMode_003
147 * @tc.number: Audio_OffloadStream_008
148 * @tc.desc : Test CheckStreamOffloadMode when offload not available on current output device.
149 */
150 HWTEST_F(AudioOffloadStreamTest, CheckStreamOffloadMode_003, TestSize.Level3)
151 {
152 AudioStreamType streamType = AudioStreamType::STREAM_DEFAULT;
153 int64_t activateSessionId = 6;
154 AudioStreamChangeInfo streamChangeInfo;
155 streamChangeInfo.audioRendererChangeInfo.clientUID = 1;
156 streamChangeInfo.audioRendererChangeInfo.sessionId = 1;
157 streamChangeInfo.audioRendererChangeInfo.channelCount = 3;
158 streamChangeInfo.audioRendererChangeInfo.createrUID = 2;
159 streamChangeInfo.audioRendererChangeInfo.rendererState = RendererState::RENDERER_NEW;
160 streamChangeInfo.audioRendererChangeInfo.rendererInfo.pipeType = PIPE_TYPE_DIRECT_MUSIC;
161 audioOffloadStream_->streamCollector_.AddRendererStream(streamChangeInfo);
162
163 audioOffloadStream_->isOffloadAvailable_ = true;
164 audioOffloadStream_->audioActiveDevice_.currentActiveDevice_.deviceType_ = DEVICE_TYPE_SPEAKER;
165 bool result = audioOffloadStream_->CheckStreamOffloadMode(activateSessionId, streamType);
166 EXPECT_FALSE(result);
167
168 streamType = AudioStreamType::STREAM_MUSIC;
169 result = audioOffloadStream_->CheckStreamOffloadMode(activateSessionId, streamType);
170 EXPECT_FALSE(result);
171
172 streamChangeInfo.audioRendererChangeInfo.rendererInfo.pipeType = PIPE_TYPE_DIRECT_MUSIC;
173 audioOffloadStream_->streamCollector_.audioRendererChangeInfos_.clear();
174 audioOffloadStream_->streamCollector_.AddRendererStream(streamChangeInfo);
175 result = audioOffloadStream_->CheckStreamOffloadMode(activateSessionId, streamType);
176 EXPECT_FALSE(result);
177
178 streamChangeInfo.audioRendererChangeInfo.channelCount = 2;
179 audioOffloadStream_->streamCollector_.audioRendererChangeInfos_.clear();
180 audioOffloadStream_->streamCollector_.AddRendererStream(streamChangeInfo);
181 result = audioOffloadStream_->CheckStreamOffloadMode(activateSessionId, streamType);
182 EXPECT_FALSE(result);
183
184 activateSessionId = 1;
185 result = audioOffloadStream_->CheckStreamOffloadMode(activateSessionId, streamType);
186 EXPECT_FALSE(result);
187
188 streamChangeInfo.audioRendererChangeInfo.sessionId = 1041;
189 audioOffloadStream_->streamCollector_.audioRendererChangeInfos_.clear();
190 audioOffloadStream_->streamCollector_.AddRendererStream(streamChangeInfo);
191 result = audioOffloadStream_->CheckStreamOffloadMode(activateSessionId, streamType);
192 EXPECT_FALSE(result);
193
194 activateSessionId = 1041;
195 streamChangeInfo.audioRendererChangeInfo.sessionId = 1041;
196 audioOffloadStream_->streamCollector_.audioRendererChangeInfos_.clear();
197 audioOffloadStream_->streamCollector_.AddRendererStream(streamChangeInfo);
198 result = audioOffloadStream_->CheckStreamOffloadMode(activateSessionId, streamType);
199 EXPECT_EQ(audioOffloadStream_->streamCollector_.GetUid(activateSessionId), 2);
200 EXPECT_FALSE(result);
201 }
202
203 /**
204 * @tc.name : CheckStreamOffloadMode_004
205 * @tc.number: Audio_OffloadStream_008
206 * @tc.desc : Test CheckStreamOffloadMode with different offloadUID.
207 */
208 HWTEST_F(AudioOffloadStreamTest, CheckStreamOffloadMode_004, TestSize.Level3)
209 {
210 AudioOffloadStream audioOffloadStream;
211 AudioStreamType streamType = AudioStreamType::STREAM_MUSIC;
212 int64_t activateSessionId = 10;
213 AudioStreamChangeInfo streamChangeInfo{};
214 auto& audioRendererChangeInfo = streamChangeInfo.audioRendererChangeInfo;
215 audioRendererChangeInfo = {};
216 audioRendererChangeInfo.clientUID = 1;
217 audioRendererChangeInfo.sessionId = activateSessionId;
218 audioRendererChangeInfo.channelCount = AudioChannel::STEREO;
219 audioRendererChangeInfo.createrUID = 2;
220 audioRendererChangeInfo.rendererState = RendererState::RENDERER_NEW;
221 audioRendererChangeInfo.rendererInfo.pipeType = PIPE_TYPE_DIRECT_VOIP;
222 audioOffloadStream.isOffloadAvailable_ = true;
223
224 audioOffloadStream.streamCollector_.AddRendererStream(streamChangeInfo);
225 audioOffloadStream.audioActiveDevice_.currentActiveDevice_.networkId_ = LOCAL_NETWORK_ID;
226 audioOffloadStream.audioActiveDevice_.currentActiveDevice_.macAddress_ = "00:11:22:33:44:55";
227 audioOffloadStream.audioActiveDevice_.currentActiveDevice_.deviceType_ = DEVICE_TYPE_SPEAKER;
228
229 bool result = audioOffloadStream.CheckStreamOffloadMode(activateSessionId, streamType);
230 EXPECT_TRUE(result);
231
232 audioOffloadStream.streamCollector_.audioRendererChangeInfos_.back()->createrUID = -1;
233 audioOffloadStream.CheckStreamOffloadMode(activateSessionId, streamType);
234 const int32_t UID_AUDIO = 1041;
235 audioOffloadStream.streamCollector_.audioRendererChangeInfos_.back()->createrUID = UID_AUDIO;
236 result = audioOffloadStream.CheckStreamOffloadMode(activateSessionId, streamType);
237
238 audioOffloadStream.SetOffloadStatus(activateSessionId);
239 EXPECT_EQ(audioOffloadStream.offloadSessionID_, activateSessionId);
240 audioOffloadStream.SetOffloadStatus(activateSessionId);
241 audioOffloadStream.SetOffloadStatus(activateSessionId + 1);
242 EXPECT_EQ(audioOffloadStream.offloadSessionID_, activateSessionId);
243 }
244
245 /**
246 * @tc.name : MoveToNewPipe_ShouldReturnError_WhenStreamIsIllegal
247 * @tc.number: AudioOffloadStreamTest_008
248 * @tc.desc : Test if MoveToNewPipe .
249 */
250 HWTEST_F(AudioOffloadStreamTest, MoveToNewPipe_ShouldReturnError_WhenStreamIsIllegal, TestSize.Level3)
251 {
252 AudioStreamChangeInfo streamChangeInfo;
253 auto& audioRendererChangeInfo = streamChangeInfo.audioRendererChangeInfo;
254 audioRendererChangeInfo = {};
255 audioRendererChangeInfo.clientUID = 1;
256 audioRendererChangeInfo.sessionId = 1;
257 audioRendererChangeInfo.rendererState = RendererState::RENDERER_NEW;
258 int32_t ret = audioOffloadStream_->streamCollector_.AddRendererStream(streamChangeInfo);
259 EXPECT_EQ(ret, SUCCESS);
260 uint32_t sessionId = 1;
261 AudioPipeType pipeType = AudioPipeType::PIPE_TYPE_NORMAL_OUT;
262 // Arrange
263 int32_t defaultUid = -1;
264 // Act
265 auto oldDeviceType = audioOffloadStream_->audioActiveDevice_.currentActiveDevice_.deviceType_;
266 audioOffloadStream_->audioActiveDevice_.currentActiveDevice_.deviceType_ = DEVICE_TYPE_BLUETOOTH_A2DP;
267 int32_t result = audioOffloadStream_->MoveToNewPipe(sessionId, pipeType);
268 // Assert
269 EXPECT_NE(result, ERROR);
270
271 result = audioOffloadStream_->MoveToNewPipe(defaultUid, pipeType);
272 EXPECT_EQ(result, ERROR);
273
274 audioOffloadStream_->audioActiveDevice_.currentActiveDevice_.networkId_ = REMOTE_NETWORK_ID;
275 result = audioOffloadStream_->MoveToNewPipe(sessionId, PIPE_TYPE_MULTICHANNEL);
276 EXPECT_EQ(result, ERROR);
277
278 audioOffloadStream_->MoveToOutputDevice(sessionId, BLUETOOTH_SPEAKER);
279 audioOffloadStream_->audioActiveDevice_.currentActiveDevice_.deviceType_ = oldDeviceType;
280 }
281
282
283 /**
284 * @tc.name : DynamicUnloadOffloadModule_ShouldReturnSuccess_WhenOffloadIsOpened
285 * @tc.number: AudioOffloadStreamTest_009
286 * @tc.desc : Test DynamicUnloadOffloadModule function when offload is opened.
287 */
288 HWTEST_F(AudioOffloadStreamTest, DynamicUnloadOffloadModule_ShouldReturnSuccess_WhenOffloadIsOpened, TestSize.Level3)
289 {
290 // Arrange
291 audioOffloadStream_->isOffloadOpened_.store(true);
292 // Act
293 int32_t result = audioOffloadStream_->DynamicUnloadOffloadModule();
294 // Assert
295 EXPECT_EQ(result, SUCCESS);
296 EXPECT_FALSE(audioOffloadStream_->isOffloadOpened_.load());
297 }
298
299 /**
300 * @tc.name : DynamicUnloadOffloadModule_ShouldReturnSuccess_WhenOffloadIsNotOpened
301 * @tc.number: AudioOffloadStreamTest_010
302 * @tc.desc : Test DynamicUnloadOffloadModule function when offload is not opened.
303 */
304 HWTEST_F(AudioOffloadStreamTest, DynamicUnloadOffloadModule_ShouldReturnSuccess_WhenOffloadIsNotOpened, TestSize.Level3)
305 {
306 // Arrange
307 audioOffloadStream_->isOffloadOpened_.store(false);
308 // Act
309 int32_t result = audioOffloadStream_->DynamicUnloadOffloadModule();
310 // Assert
311 EXPECT_EQ(result, SUCCESS);
312 }
313
314 /**
315 * @tc.name : ReleaseOffloadStream_WhenSessionIdDoesNotMatch
316 * @tc.number: AudioOffloadStreamTest_011
317 * @tc.desc : Test if the offload stream is not released when the session ID does not match.
318 */
319 HWTEST_F(AudioOffloadStreamTest, ReleaseOffloadStream_WhenSessionIdDoesNotMatch, TestSize.Level0)
320 {
321 // Arrange
322 uint32_t sessionId = 123;
323 uint32_t differentSessionId = 456;
324 audioOffloadStream_->offloadSessionID_ = sessionId;
325 // Act
326 audioOffloadStream_->RemoteOffloadStreamRelease(differentSessionId);
327 // Assert
328 EXPECT_TRUE(audioOffloadStream_->offloadSessionID_.has_value());
329
330 audioOffloadStream_->RemoteOffloadStreamRelease(sessionId);
331 EXPECT_FALSE(audioOffloadStream_->offloadSessionID_.has_value());
332 audioOffloadStream_->offloadSessionID_ = sessionId;
333 }
334
335 /**
336 * @tc.name : SpatializationEnabledAndEffectOffloadEnabled
337 * @tc.number: AudioOffloadStreamTest_014
338 * @tc.desc : Test scenario when spatialization is enabled and effect offload is enabled.
339 */
340 HWTEST_F(AudioOffloadStreamTest, SpatializationEnabledAndEffectOffloadEnabled, TestSize.Level0)
341 {
342 AudioOffloadStream audioOffloadStream;
343 std::vector<int32_t> allSessions = {1, 2, 3};
344 audioOffloadStream.ResetOffloadModeOnSpatializationChanged(allSessions);
345
346 EXPECT_EQ(audioOffloadStream.currentPowerState_, PowerMgr::PowerState::AWAKE);
347
348 auto &service = AudioSpatializationService::GetAudioSpatializationService();
349 service.spatializationEnabledReal_ = true;
350 audioOffloadStream.ResetOffloadModeOnSpatializationChanged(allSessions);
351
352 audioOffloadStream.isOffloadAvailable_ = true;
353 audioOffloadStream.offloadSessionID_ = 1;
354 audioOffloadStream.ResetOffloadModeOnSpatializationChanged(allSessions);
355
356 audioOffloadStream.OffloadStreamReleaseCheck(0);
357 audioOffloadStream.offloadSessionID_.reset();
358 audioOffloadStream.OffloadStreamReleaseCheck(0);
359 service.spatializationEnabledReal_ = false;
360 }
361
362 /**
363 * @tc.name : SpatializationEnabledAndEffectOffloadEnabled
364 * @tc.number: AudioOffloadStreamTest_015
365 * @tc.desc : Test ConstructMchAudioModuleInfo Interface.
366 */
367 HWTEST_F(AudioOffloadStreamTest, AudioOffloadStreamTest_015, TestSize.Level0)
368 {
369 DeviceType deviceType = DeviceType::DEVICE_TYPE_SPEAKER;
370 AudioOffloadStream audioOffloadStream;
371 AudioModuleInfo ret;
372
373 ret = audioOffloadStream.ConstructMchAudioModuleInfo(deviceType);
374 EXPECT_EQ(ret.channels, "6");
375 }
376
377 /**
378 * @tc.name : SpatializationEnabledAndEffectOffloadEnabled
379 * @tc.number: AudioOffloadStreamTest_016
380 * @tc.desc : Test LoadMchModule Interface.
381 */
382 HWTEST_F(AudioOffloadStreamTest, AudioOffloadStreamTest_016, TestSize.Level0)
383 {
384 AudioOffloadStream audioOffloadStream;
385 int32_t ret;
386
387 ret = audioOffloadStream.LoadMchModule();
388 EXPECT_EQ(ret, SUCCESS);
389 }
390
391 /**
392 * @tc.name : SpatializationEnabledAndEffectOffloadEnabled
393 * @tc.number: AudioOffloadStreamTest_017
394 * @tc.desc : Test ConstructOffloadAudioModuleInfo Interface.
395 */
396 HWTEST_F(AudioOffloadStreamTest, AudioOffloadStreamTest_017, TestSize.Level0)
397 {
398 DeviceType deviceType = DeviceType::DEVICE_TYPE_SPEAKER;
399 AudioOffloadStream audioOffloadStream;
400 AudioModuleInfo ret;
401
402 ret = audioOffloadStream.ConstructOffloadAudioModuleInfo(deviceType);
403 EXPECT_EQ(ret.channels, "2");
404 }
405
406 /**
407 * @tc.name : SpatializationEnabledAndEffectOffloadEnabled
408 * @tc.number: AudioOffloadStreamTest_018
409 * @tc.desc : Test UnloadMchModule Interface.
410 */
411 HWTEST_F(AudioOffloadStreamTest, AudioOffloadStreamTest_018, TestSize.Level0)
412 {
413 AudioOffloadStream audioOffloadStream;
414 int32_t ret;
415
416 ret = audioOffloadStream.UnloadMchModule();
417 EXPECT_NE(ret, SUCCESS);
418 }
419
420 /**
421 * @tc.name : SpatializationEnabledAndEffectOffloadEnabled
422 * @tc.number: AudioOffloadStreamTest_019
423 * @tc.desc : Test LoadOffloadModule Interface.
424 */
425 HWTEST_F(AudioOffloadStreamTest, AudioOffloadStreamTest_019, TestSize.Level0)
426 {
427 AudioIOHandle audioIOHandle = 3;
428 AudioOffloadStream audioOffloadStream;
429 int32_t ret;
430
431 ret = audioOffloadStream.LoadOffloadModule();
432 EXPECT_EQ(ret, SUCCESS);
433
434 audioOffloadStream.audioIOHandleMap_.IOHandles_[OFFLOAD_PRIMARY_SPEAKER] = audioIOHandle;
435 ret = audioOffloadStream.LoadOffloadModule();
436 EXPECT_EQ(ret, SUCCESS);
437 }
438
439 /**
440 * @tc.name : SpatializationEnabledAndEffectOffloadEnabled
441 * @tc.number: AudioOffloadStreamTest_020
442 * @tc.desc : Test UnloadOffloadModule Interface.
443 */
444 HWTEST_F(AudioOffloadStreamTest, AudioOffloadStreamTest_020, TestSize.Level0)
445 {
446 AudioOffloadStream audioOffloadStream;
447 int32_t ret;
448
449 audioOffloadStream.isOffloadOpened_.store(true);
450 ret = audioOffloadStream.UnloadOffloadModule();
451 EXPECT_NE(ret, SUCCESS);
452 }
453
454 /**
455 * @tc.name : SpatializationEnabledAndEffectOffloadEnabled
456 * @tc.number: AudioOffloadStreamTest_022
457 * @tc.desc : Test OffloadStreamSetCheck Interface.
458 */
459 HWTEST_F(AudioOffloadStreamTest, AudioOffloadStreamTest_022, TestSize.Level0)
460 {
461 uint32_t sessionId = 100;
462 AudioOffloadStream audioOffloadStream;
463 AudioStreamChangeInfo streamChangeInfo;
464 audioOffloadStream.isOffloadAvailable_ = true;
465 auto& audioRendererChangeInfo = streamChangeInfo.audioRendererChangeInfo;
466 audioRendererChangeInfo = {};
467 audioRendererChangeInfo.clientUID = 1;
468 audioRendererChangeInfo.sessionId = sessionId;
469 audioRendererChangeInfo.channelCount = AudioChannel::STEREO;
470 audioRendererChangeInfo.rendererState = RendererState::RENDERER_NEW;
471 audioRendererChangeInfo.rendererInfo.pipeType = PIPE_TYPE_DIRECT_VOIP;
472
473 audioOffloadStream.streamCollector_.AddRendererStream(streamChangeInfo);
474 audioOffloadStream.audioActiveDevice_.currentActiveDevice_.networkId_ = LOCAL_NETWORK_ID;
475 audioOffloadStream.audioActiveDevice_.currentActiveDevice_.macAddress_ = "00:11:22:33:44:55";
476 audioOffloadStream.audioActiveDevice_.currentActiveDevice_.deviceType_ = DEVICE_TYPE_SPEAKER;
477 audioOffloadStream.OffloadStreamSetCheck(sessionId);
478 EXPECT_EQ(audioOffloadStream.audioActiveDevice_.GetCurrentOutputDeviceNetworkId(), LOCAL_NETWORK_ID);
479 EXPECT_EQ(audioOffloadStream.audioActiveDevice_.GetCurrentOutputDeviceType(), DEVICE_TYPE_SPEAKER);
480 audioOffloadStream.OffloadStreamSetCheck(sessionId);
481 audioOffloadStream.OffloadStreamSetCheck(1);
482
483 audioOffloadStream.streamCollector_.audioRendererChangeInfos_.back()->channelCount = AudioChannel::CHANNEL_3;
484 EXPECT_FALSE(audioOffloadStream.CheckStreamMultichannelMode(sessionId));
485 audioOffloadStream.streamCollector_.audioRendererChangeInfos_.back()->channelCount = AudioChannel::STEREO;
486
487 audioOffloadStream.audioActiveDevice_.currentActiveDevice_.networkId_ = REMOTE_NETWORK_ID;
488 audioOffloadStream.audioActiveDevice_.currentActiveDevice_.deviceType_ = DEVICE_TYPE_NONE;
489 audioOffloadStream.OffloadStreamSetCheck(sessionId);
490 EXPECT_EQ(audioOffloadStream.audioActiveDevice_.GetCurrentOutputDeviceNetworkId(), REMOTE_NETWORK_ID);
491
492 audioOffloadStream.audioActiveDevice_.currentActiveDevice_.networkId_ = "";
493 audioOffloadStream.audioActiveDevice_.currentActiveDevice_.deviceType_ = DEVICE_TYPE_NONE;
494 audioOffloadStream.OffloadStreamSetCheck(sessionId);
495 EXPECT_EQ(audioOffloadStream.audioActiveDevice_.GetCurrentOutputDeviceMacAddr(), "00:11:22:33:44:55");
496 EXPECT_FALSE(audioOffloadStream.CheckStreamMultichannelMode(sessionId));
497
498 audioOffloadStream.audioActiveDevice_.currentActiveDevice_.networkId_ = "";
499 audioOffloadStream.audioActiveDevice_.currentActiveDevice_.macAddress_ = "";
500 audioOffloadStream.audioActiveDevice_.currentActiveDevice_.deviceType_ = DEVICE_TYPE_NONE;
501 audioOffloadStream.OffloadStreamSetCheck(sessionId);
502 EXPECT_EQ(audioOffloadStream.streamCollector_.GetStreamType(sessionId), STREAM_MUSIC);
503 audioOffloadStream.ResetOffloadStatus(sessionId);
504 EXPECT_FALSE(audioOffloadStream.offloadSessionID_.has_value());
505 }
506 } // namespace AudioStandard
507 } // namespace OHOS
508