• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2022-2025 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 #include <cstddef>
16 #include <cstdint>
17 
18 #include <gtest/gtest.h>
19 #include "audio_adapter.h"
20 #include "avsession_errors.h"
21 #include "avsession_log.h"
22 #include "audio_info.h"
23 #include "audio_device_info.h"
24 
25 using namespace testing::ext;
26 using namespace OHOS::AVSession;
27 using OHOS::AudioStandard::AudioDeviceUsage;
28 using OHOS::AudioStandard::AudioRendererChangeInfo;
29 using OHOS::AudioStandard::RendererState;
30 
31 class AudioAdapterTest : public testing::Test {
32 public:
33     static void SetUpTestCase(void);
34     static void TearDownTestCase(void);
35     void SetUp();
36     void TearDown();
37 
38     static constexpr int32_t TEST_CLIENT_UID = 1;
39     static constexpr int32_t TEST_CLIENT_PID = 1;
40     static constexpr int32_t TEST_SESSION_ID = 2;
41     static constexpr int32_t TEST_SESSION_FAIL_ID = -1;
42 };
43 
SetUpTestCase()44 void AudioAdapterTest::SetUpTestCase()
45 {}
46 
TearDownTestCase()47 void AudioAdapterTest::TearDownTestCase()
48 {}
49 
SetUp()50 void AudioAdapterTest::SetUp()
51 {}
52 
TearDown()53 void AudioAdapterTest::TearDown()
54 {}
55 
56 /**
57 * @tc.name: OnRendererStateChange001
58 * @tc.desc: verifying the renderer state listener
59 * @tc.type: FUNC
60 * @tc.require: AR000H31KJ
61 */
62 static HWTEST(AudioAdapterTest, OnRendererStateChange001, TestSize.Level0)
63 {
64     SLOGI("OnRendererStateChange001 begin!");
65     std::shared_ptr<AudioRendererChangeInfo> info = std::make_shared<AudioRendererChangeInfo>();
66     info->clientUID = AudioAdapterTest::TEST_CLIENT_UID;
67     info->sessionId = AudioAdapterTest::TEST_SESSION_ID;
68     info->rendererState = RendererState::RENDERER_RELEASED;
69     AudioRendererChangeInfos infosExpected;
70     infosExpected.push_back(std::move(info));
71     AudioRendererChangeInfos infosActual;
72 
73     AudioAdapter::GetInstance().Init();
__anone79521710102(const AudioRendererChangeInfos& infos) 74     AudioAdapter::GetInstance().AddStreamRendererStateListener([&infosActual](const AudioRendererChangeInfos& infos) {
75         SLOGI("AddStreamRendererStateListener start!");
76         for (const auto& info : infos) {
77             std::shared_ptr<AudioRendererChangeInfo> infoActual = std::make_shared<AudioRendererChangeInfo>();
78             *infoActual = *info;
79             infosActual.push_back(std::move(infoActual));
80         }
81         SLOGI("AddStreamRendererStateListener end!");
82     });
83     AudioAdapter::GetInstance().OnRendererStateChange(infosExpected);
84 
85     ASSERT_NE(infosActual.size(), 0);
86     const auto& infoExpected = infosExpected[0];
87     const auto& infoActual = infosActual[0];
88     EXPECT_EQ(infoExpected->clientUID, infoActual->clientUID);
89     EXPECT_EQ(infoExpected->sessionId, infoActual->sessionId);
90     EXPECT_EQ(infoExpected->rendererState, infoActual->rendererState);
91     SLOGI("OnRendererStateChange001 end!");
92 }
93 
94 /**
95 * @tc.name: MuteAudioStream001
96 * @tc.desc: mute audio stream for valid uid TEST_CLIENT_UID
97 * @tc.type: FUNC
98 * @tc.require: AR000H31KJ
99 */
100 static HWTEST(AudioAdapterTest, MuteAudioStream001, TestSize.Level0)
101 {
102     SLOGI("MuteAudioStream001 begin!");
103     std::shared_ptr<AudioRendererChangeInfo> info = std::make_shared<AudioRendererChangeInfo>();
104     info->clientUID = AudioAdapterTest::TEST_CLIENT_UID;
105     info->clientPid = AudioAdapterTest::TEST_CLIENT_PID;
106     info->sessionId = AudioAdapterTest::TEST_SESSION_ID;
107     info->rendererState = RendererState::RENDERER_RELEASED;
108     AudioRendererChangeInfos infosExpected;
109     infosExpected.push_back(std::move(info));
110 
111     AudioAdapter::GetInstance().Init();
__anone79521710202(const AudioRendererChangeInfos& infos) 112     AudioAdapter::GetInstance().AddStreamRendererStateListener([](const AudioRendererChangeInfos& infos) {
113         SLOGI("MuteAudioStream001 AddStreamRendererStateListener start!");
114         for (const auto& info : infos) {
115             std::shared_ptr<AudioRendererChangeInfo> infoActual = std::make_shared<AudioRendererChangeInfo>();
116             *infoActual = *info;
117         }
118         SLOGI("AddStreamRendererStateListener end!");
119     });
120     auto ret = AudioAdapter::GetInstance().MuteAudioStream(AudioAdapterTest::TEST_CLIENT_UID,
121         AudioAdapterTest::TEST_CLIENT_PID);
122     EXPECT_NE(ret, AVSESSION_ERROR_BASE);
123 
124     ret = AudioAdapter::GetInstance().MuteAudioStream(AudioAdapterTest::TEST_SESSION_FAIL_ID,
125         AudioAdapterTest::TEST_SESSION_FAIL_ID);
126     EXPECT_NE(ret, AVSESSION_ERROR_BASE);
127 }
128 
129 /**
130 * @tc.name: MuteAudioStream002
131 * @tc.desc: mute audio stream for valid uid TEST_CLIENT_UID
132 * @tc.type: FUNC
133 */
134 static HWTEST(AudioAdapterTest, MuteAudioStream002, TestSize.Level0)
135 {
136     SLOGI("MuteAudioStream002 begin!");
137     std::shared_ptr<AudioRendererChangeInfo> info = std::make_shared<AudioRendererChangeInfo>();
138     info->clientUID = AudioAdapterTest::TEST_CLIENT_UID;
139     info->clientPid = AudioAdapterTest::TEST_CLIENT_PID;
140     info->sessionId = AudioAdapterTest::TEST_SESSION_ID;
141     info->rendererState = RendererState::RENDERER_RELEASED;
142     AudioRendererChangeInfos infosExpected;
143     infosExpected.push_back(std::move(info));
144 
145     AudioAdapter::GetInstance().Init();
__anone79521710302(const AudioRendererChangeInfos& infos) 146     AudioAdapter::GetInstance().AddStreamRendererStateListener([](const AudioRendererChangeInfos& infos) {
147         SLOGI("MuteAudioStream002 AddStreamRendererStateListener start!");
148         for (const auto& info : infos) {
149             std::shared_ptr<AudioRendererChangeInfo> infoActual = std::make_shared<AudioRendererChangeInfo>();
150             *infoActual = *info;
151         }
152         SLOGI("AddStreamRendererStateListener end!");
153     });
154     auto ret = AudioAdapter::GetInstance().MuteAudioStream(AudioAdapterTest::TEST_CLIENT_UID,
155         OHOS::AudioStandard::StreamUsage::STREAM_USAGE_INVALID);
156     EXPECT_EQ(ret, AVSESSION_ERROR);
157 
158     ret = AudioAdapter::GetInstance().MuteAudioStream(AudioAdapterTest::TEST_CLIENT_UID,
159         OHOS::AudioStandard::StreamUsage::STREAM_USAGE_MUSIC);
160     EXPECT_EQ(ret, AVSESSION_ERROR);
161     SLOGI("MuteAudioStream002 done!");
162 }
163 
164 /**
165 * @tc.name: MuteAudioStream003
166 * @tc.desc: mute audio stream for valid uid TEST_CLIENT_UID
167 * @tc.type: FUNC
168 * @tc.require: AR000H31KJ
169 */
170 static HWTEST(AudioAdapterTest, MuteAudioStream003, TestSize.Level0)
171 {
172     SLOGI("MuteAudioStream003 begin!");
173     std::shared_ptr<AudioRendererChangeInfo> info = std::make_shared<AudioRendererChangeInfo>();
174     info->clientUID = AudioAdapterTest::TEST_CLIENT_UID;
175     info->clientPid = AudioAdapterTest::TEST_CLIENT_PID;
176     info->sessionId = AudioAdapterTest::TEST_SESSION_ID;
177     info->rendererState = RendererState::RENDERER_RELEASED;
178     AudioRendererChangeInfos infosExpected;
179     infosExpected.push_back(std::move(info));
180 
181     AudioAdapter::GetInstance().Init();
__anone79521710402(const AudioRendererChangeInfos& infos) 182     AudioAdapter::GetInstance().AddStreamRendererStateListener([](const AudioRendererChangeInfos& infos) {
183         SLOGI("MuteAudioStream003 AddStreamRendererStateListener start!");
184         for (const auto& info : infos) {
185             std::shared_ptr<AudioRendererChangeInfo> infoActual = std::make_shared<AudioRendererChangeInfo>();
186             *infoActual = *info;
187         }
188         SLOGI("AddStreamRendererStateListener end!");
189     });
190     auto& audioAdapter = AudioAdapter::GetInstance();
191     audioAdapter.is2in1_ = true;
192     auto ret = audioAdapter.MuteAudioStream(AudioAdapterTest::TEST_CLIENT_UID,
193         OHOS::AudioStandard::StreamUsage::STREAM_USAGE_INVALID);
194     EXPECT_EQ(ret, AVSESSION_ERROR);
195 }
196 
197 /**
198 * @tc.name: MuteAudioStream004
199 * @tc.desc: mute audio stream for valid uid TEST_CLIENT_UID
200 * @tc.type: FUNC
201 * @tc.require: AR000H31KJ
202 */
203 static HWTEST(AudioAdapterTest, MuteAudioStream004, TestSize.Level0)
204 {
205     SLOGI("MuteAudioStream004 begin!");
206     std::shared_ptr<AudioRendererChangeInfo> info = std::make_shared<AudioRendererChangeInfo>();
207     info->clientUID = AudioAdapterTest::TEST_CLIENT_UID;
208     info->clientPid = AudioAdapterTest::TEST_CLIENT_PID;
209     info->sessionId = AudioAdapterTest::TEST_SESSION_ID;
210     info->rendererState = RendererState::RENDERER_RELEASED;
211     AudioRendererChangeInfos infosExpected;
212     infosExpected.push_back(std::move(info));
213 
214     AudioAdapter::GetInstance().Init();
__anone79521710502(const AudioRendererChangeInfos& infos) 215     AudioAdapter::GetInstance().AddStreamRendererStateListener([](const AudioRendererChangeInfos& infos) {
216         SLOGI("MuteAudioStream004 AddStreamRendererStateListener start!");
217         for (const auto& info : infos) {
218             std::shared_ptr<AudioRendererChangeInfo> infoActual = std::make_shared<AudioRendererChangeInfo>();
219             *infoActual = *info;
220         }
221         SLOGI("AddStreamRendererStateListener end!");
222     });
223     auto& audioAdapter = AudioAdapter::GetInstance();
224     audioAdapter.is2in1_ = true;
225     auto ret = audioAdapter.MuteAudioStream(AudioAdapterTest::TEST_SESSION_FAIL_ID,
226         AudioAdapterTest::TEST_SESSION_FAIL_ID);
227     EXPECT_EQ(ret, AVSESSION_ERROR);
228 }
229 
230 /**
231 * @tc.name: UnMuteAudioStream001
232 * @tc.desc: unmute audio stream for valid uid TEST_CLIENT_UID
233 * @tc.type: FUNC
234 * @tc.require: AR000H31KJ
235 */
236 static HWTEST(AudioAdapterTest, UnMuteAudioStream001, TestSize.Level0)
237 {
238     SLOGI("UnMuteAudioStream001 begin!");
239     std::shared_ptr<AudioRendererChangeInfo> info = std::make_shared<AudioRendererChangeInfo>();
240     info->clientUID = AudioAdapterTest::TEST_CLIENT_UID;
241     info->sessionId = AudioAdapterTest::TEST_SESSION_ID;
242     info->rendererState = RendererState::RENDERER_RELEASED;
243     AudioRendererChangeInfos infosExpected;
244     infosExpected.push_back(std::move(info));
245 
246     AudioAdapter::GetInstance().Init();
__anone79521710602(const AudioRendererChangeInfos& infos) 247     AudioAdapter::GetInstance().AddStreamRendererStateListener([](const AudioRendererChangeInfos& infos) {
248         SLOGI("UnMuteAudioStream001 AddStreamRendererStateListener start!");
249         for (const auto& info : infos) {
250             std::shared_ptr<AudioRendererChangeInfo> infoActual = std::make_shared<AudioRendererChangeInfo>();
251             *infoActual = *info;
252         }
253         SLOGI("AddStreamRendererStateListener end!");
254     });
255     auto ret = AudioAdapter::GetInstance().UnMuteAudioStream(AudioAdapterTest::TEST_CLIENT_UID);
256     EXPECT_NE(ret, AVSESSION_ERROR_BASE);
257 }
258 
259 /**
260 * @tc.name: UnMuteAudioStream002
261 * @tc.desc: unmute audio stream for valid uid TEST_CLIENT_UID
262 * @tc.type: FUNC
263 * @tc.require: AR000H31KJ
264 */
265 static HWTEST(AudioAdapterTest, UnMuteAudioStream002, TestSize.Level0)
266 {
267     SLOGI("UnMuteAudioStream002 begin!");
268     std::shared_ptr<AudioRendererChangeInfo> info = std::make_shared<AudioRendererChangeInfo>();
269     info->clientUID = AudioAdapterTest::TEST_CLIENT_UID;
270     info->sessionId = AudioAdapterTest::TEST_SESSION_ID;
271     info->rendererState = RendererState::RENDERER_RELEASED;
272     AudioRendererChangeInfos infosExpected;
273     infosExpected.push_back(std::move(info));
274 
275     AudioAdapter::GetInstance().Init();
__anone79521710702(const AudioRendererChangeInfos& infos) 276     AudioAdapter::GetInstance().AddStreamRendererStateListener([](const AudioRendererChangeInfos& infos) {
277         SLOGI("UnMuteAudioStream002 AddStreamRendererStateListener start!");
278         for (const auto& info : infos) {
279             std::shared_ptr<AudioRendererChangeInfo> infoActual = std::make_shared<AudioRendererChangeInfo>();
280             *infoActual = *info;
281         }
282         SLOGI("AddStreamRendererStateListener end!");
283     });
284     auto& audioAdapter = AudioAdapter::GetInstance();
285     audioAdapter.is2in1_ = true;
286     auto ret = audioAdapter.UnMuteAudioStream(AudioAdapterTest::TEST_CLIENT_UID,
287         OHOS::AudioStandard::StreamUsage::STREAM_USAGE_INVALID);
288     EXPECT_EQ(ret, AVSESSION_ERROR);
289 }
290 
291 /**
292 * @tc.name: UnMuteAudioStream003
293 * @tc.desc: unmute audio stream for valid uid TEST_CLIENT_UID
294 * @tc.type: FUNC
295 * @tc.require: AR000H31KJ
296 */
297 static HWTEST(AudioAdapterTest, UnMuteAudioStream003, TestSize.Level0)
298 {
299     SLOGI("UnMuteAudioStream003 begin!");
300     std::shared_ptr<AudioRendererChangeInfo> info = std::make_shared<AudioRendererChangeInfo>();
301     info->clientUID = AudioAdapterTest::TEST_CLIENT_UID;
302     info->sessionId = AudioAdapterTest::TEST_SESSION_ID;
303     info->rendererState = RendererState::RENDERER_RELEASED;
304     AudioRendererChangeInfos infosExpected;
305     infosExpected.push_back(std::move(info));
306 
307     AudioAdapter::GetInstance().Init();
__anone79521710802(const AudioRendererChangeInfos& infos) 308     AudioAdapter::GetInstance().AddStreamRendererStateListener([](const AudioRendererChangeInfos& infos) {
309         SLOGI("UnMuteAudioStream003 AddStreamRendererStateListener start!");
310         for (const auto& info : infos) {
311             std::shared_ptr<AudioRendererChangeInfo> infoActual = std::make_shared<AudioRendererChangeInfo>();
312             *infoActual = *info;
313         }
314         SLOGI("AddStreamRendererStateListener end!");
315     });
316     auto& audioAdapter = AudioAdapter::GetInstance();
317     audioAdapter.is2in1_ = true;
318     auto ret = audioAdapter.UnMuteAudioStream(AudioAdapterTest::TEST_CLIENT_UID);
319     EXPECT_EQ(ret, AVSESSION_ERROR);
320     SLOGI("UnMuteAudioStream003 done!");
321 }
322 
323 /**
324 * @tc.name: UnMuteAudioStream004
325 * @tc.desc: unmute audio stream for valid uid TEST_CLIENT_UID
326 * @tc.type: FUNC
327 * @tc.require: AR000H31KJ
328 */
329 static HWTEST(AudioAdapterTest, UnMuteAudioStream004, TestSize.Level0)
330 {
331     SLOGI("UnMuteAudioStream004 begin!");
332     std::shared_ptr<AudioRendererChangeInfo> info = std::make_shared<AudioRendererChangeInfo>();
333     info->clientUID = AudioAdapterTest::TEST_CLIENT_UID;
334     info->sessionId = AudioAdapterTest::TEST_SESSION_ID;
335     info->rendererState = RendererState::RENDERER_RELEASED;
336     AudioRendererChangeInfos infosExpected;
337     infosExpected.push_back(std::move(info));
338 
339     AudioAdapter::GetInstance().Init();
__anone79521710902(const AudioRendererChangeInfos& infos) 340     AudioAdapter::GetInstance().AddStreamRendererStateListener([](const AudioRendererChangeInfos& infos) {
341         SLOGI("UnMuteAudioStream004 AddStreamRendererStateListener start!");
342         for (const auto& info : infos) {
343             std::shared_ptr<AudioRendererChangeInfo> infoActual = std::make_shared<AudioRendererChangeInfo>();
344             *infoActual = *info;
345         }
346         SLOGI("AddStreamRendererStateListener end!");
347     });
348     auto& audioAdapter = AudioAdapter::GetInstance();
349     auto ret = audioAdapter.UnMuteAudioStream(AudioAdapterTest::TEST_CLIENT_UID,
350         OHOS::AudioStandard::StreamUsage::STREAM_USAGE_INVALID);
351     EXPECT_EQ(ret, AVSESSION_ERROR);
352 }
353 
354 /**
355 * @tc.name: GetRendererRunning001
356 * @tc.desc: Test GetRendererRunning
357 * @tc.type: FUNC
358 * @tc.require: AR000H31KJ
359 */
360 static HWTEST(AudioAdapterTest, GetRendererRunning001, TestSize.Level0)
361 {
362     SLOGI("GetRendererRunning001 begin!");
363     AudioAdapter::GetInstance().Init();
364     AudioAdapter::GetInstance().GetRendererRunning(AudioAdapterTest::TEST_CLIENT_UID,
365         AudioAdapterTest::TEST_CLIENT_PID);
366     SLOGI("GetRendererRunning001 end!");
367 }
368 
369 /**
370 * @tc.name: GetRendererRunning002
371 * @tc.desc: Test GetRendererRunning
372 * @tc.type: FUNC
373 * @tc.require: AR000H31KJ
374 */
375 static HWTEST(AudioAdapterTest, GetRendererRunning002, TestSize.Level0)
376 {
377     SLOGI("GetRendererRunning002 begin!");
378     AudioAdapter::GetInstance().Init();
379     AudioAdapter::GetInstance().GetRendererRunning(AudioAdapterTest::TEST_SESSION_FAIL_ID,
380         AudioAdapterTest::TEST_SESSION_FAIL_ID);
381     SLOGI("GetRendererRunning002 end!");
382 }
383 
384 /**
385 * @tc.name: PauseAudioStream001
386 * @tc.desc: Test GetRendererRunning
387 * @tc.type: FUNC
388 * @tc.require: AR000H31KJ
389 */
390 static HWTEST(AudioAdapterTest, PauseAudioStream001, TestSize.Level0)
391 {
392     SLOGI("PauseAudioStream001 begin!");
393     AudioAdapter::GetInstance().Init();
394     int32_t uid = 10001;
395     OHOS::AudioStandard::StreamUsage streamUsage {};
396     int32_t ret = AudioAdapter::GetInstance().PauseAudioStream(uid, streamUsage);
397     EXPECT_EQ(ret, AVSESSION_ERROR);
398     SLOGI("PauseAudioStream001 end!");
399 }
400 
401 /**
402  * @tc.name: OnPreferredOutputDeviceUpdated001
403  * @tc.desc: Notify registered listeners when the preferred audio output device is updated.
404  *           This method iterates through all registered listeners and calls their callback functions
405  *           with the updated device descriptor.
406  * @tc.type: FUNC
407  * @tc.require: AR000H31KJ
408  */
409 static HWTEST(AudioAdapterTest, OnPreferredOutputDeviceUpdated001, TestSize.Level0)
410 {
411     SLOGD("OnPreferredOutputDeviceUpdated001 begin!");
412     bool ret = false;
413     AudioAdapter::GetInstance().AddDeviceChangeListener(
__anone79521710a02(const AudioDeviceDescriptors &desc) 414         [&ret] (const AudioDeviceDescriptors &desc) {
415         ret = desc.empty();
416     });
417     AudioAdapter::GetInstance().Init();
418     auto& audioAdapter = AudioAdapter::GetInstance();
419     AudioDeviceDescriptors desc = audioAdapter.GetAvailableDevices();
420     audioAdapter.deviceChangeListeners_ =
421         std::vector<OHOS::AVSession::AudioAdapter::PreferOutputDeviceChangeListener>();
422     audioAdapter.OnPreferredOutputDeviceUpdated(desc);
423     EXPECT_FALSE(ret);
424 }
425 
426 /**
427  * @tc.name: OnAvailableDeviceChange001
428  * @tc.desc: Notify registered listener when the available audio output devices are updated.
429  *           This method calls registered listener's callback function with the device change action.
430  * @tc.type: FUNC
431  * @tc.require: AR000H31KJ
432  */
433 static HWTEST(AudioAdapterTest, OnAvailableDeviceChange001, TestSize.Level0)
434 {
435     SLOGD("OnAvailableDeviceChange001 begin!");
436     bool ret = false;
437     AudioAdapter::GetInstance().SetAvailableDeviceChangeCallback(
__anone79521710b02(const AudioDeviceDescriptors &desc) 438         [&ret] (const AudioDeviceDescriptors &desc) {
439         ret = desc.empty();
440     });
441 
442     DeviceChangeAction action = {};
443     action.type = OHOS::AudioStandard::DeviceChangeType::CONNECT;
444     auto& audioAdapter = AudioAdapter::GetInstance();
445     audioAdapter.OnAvailableDeviceChange(AudioDeviceUsage::MEDIA_OUTPUT_DEVICES, action);
446     sleep(1);
447     EXPECT_FALSE(ret);
448 }
449 
450 /**
451  * @tc.name: OnAvailableDeviceChange002
452  * @tc.desc: Notify registered listener when the available audio output devices are updated.
453  *           This method calls registered listener's callback function with the device change action.
454  * @tc.type: FUNC
455  * @tc.require: AR000H31KJ
456  */
457 static HWTEST(AudioAdapterTest, OnAvailableDeviceChange002, TestSize.Level0)
458 {
459     SLOGD("OnAvailableDeviceChange002 begin!");
460     bool ret = false;
461     AudioAdapter::GetInstance().SetAvailableDeviceChangeCallback(
__anone79521710c02(const AudioDeviceDescriptors &desc) 462         [&ret] (const AudioDeviceDescriptors &desc) {
463         ret = desc.empty();
464     });
465 
466     DeviceChangeAction action = {};
467     action.type = OHOS::AudioStandard::DeviceChangeType::DISCONNECT;
468     auto& audioAdapter = AudioAdapter::GetInstance();
469     audioAdapter.OnAvailableDeviceChange(AudioDeviceUsage::MEDIA_OUTPUT_DEVICES, action);
470     sleep(1);
471     EXPECT_FALSE(ret);
472 }
473 
474 /**
475  * @tc.name: OnAvailableDeviceChange003
476  * @tc.desc: Notify registered listener when the available audio output devices are updated.
477  *           This method calls registered listener's callback function with the device change action.
478  * @tc.type: FUNC
479  * @tc.require: AR000H31KJ
480  */
481 static HWTEST(AudioAdapterTest, OnAvailableDeviceChange003, TestSize.Level0)
482 {
483     SLOGD("OnAvailableDeviceChange003 begin!");
484     bool ret = false;
485     AudioAdapter::GetInstance().SetAvailableDeviceChangeCallback(
__anone79521710d02(const AudioDeviceDescriptors &desc) 486         [&ret] (const AudioDeviceDescriptors &desc) {
487         ret = desc.empty();
488     });
489     AudioAdapter::GetInstance().UnsetAvailableDeviceChangeCallback();
490 
491     DeviceChangeAction action = {};
492     action.type = OHOS::AudioStandard::DeviceChangeType::CONNECT;
493     auto& audioAdapter = AudioAdapter::GetInstance();
494     audioAdapter.OnAvailableDeviceChange(AudioDeviceUsage::MEDIA_OUTPUT_DEVICES, action);
495     sleep(1);
496     EXPECT_FALSE(ret);
497 }
498 
499 /**
500  * @tc.name: OnVolumeKeyEvent001
501  * @tc.desc: Notify registered listener when the volume is updated.
502  * @tc.type: FUNC
503  * @tc.require: AR000H31KJ
504  */
505 static HWTEST(AudioAdapterTest, OnVolumeKeyEvent001, TestSize.Level0)
506 {
507     SLOGD("OnVolumeKeyEvent001 begin!");
508     int32_t volume = -1;
509     AudioAdapter::GetInstance().RegisterVolumeKeyEventCallback(
__anone79521710e02(int32_t volumeNum) 510         [&volume] (int32_t volumeNum) {
511         volume = volumeNum;
512     });
513 
514     AudioAdapter::GetInstance().SetVolume(AudioAdapter::GetInstance().GetVolume());
515     sleep(1);
516     EXPECT_TRUE(volume != -1);
517 }
518 
519 /**
520  * @tc.name: OnVolumeKeyEvent002
521  * @tc.desc: Notify registered listener when the volume is updated.
522  * @tc.type: FUNC
523  * @tc.require: AR000H31KJ
524  */
525 static HWTEST(AudioAdapterTest, OnVolumeKeyEvent002, TestSize.Level0)
526 {
527     SLOGD("OnVolumeKeyEvent002 begin!");
528     int32_t volume = -1;
529     AudioAdapter::GetInstance().RegisterVolumeKeyEventCallback(
__anone79521710f02(int32_t volumeNum) 530         [&volume] (int32_t volumeNum) {
531         volume = volumeNum;
532     });
533     AudioAdapter::GetInstance().UnregisterVolumeKeyEventCallback();
534 
535     AudioAdapter::GetInstance().SetVolume(AudioAdapter::GetInstance().GetVolume());
536     sleep(1);
537     EXPECT_TRUE(volume == -1);
538 }
539 
540 /**
541 * @tc.name: OnDeviceChange001
542 * @tc.desc: Test OnDeviceChange
543 * @tc.type: FUNC
544 */
545 static HWTEST(AudioAdapterTest, OnDeviceChange001, TestSize.Level0)
546 {
547     SLOGD("OnDeviceChange001 begin!");
548     bool ret = false;
549     AudioAdapter::GetInstance().AddDeviceChangeListener(
__anone79521711002(const AudioDeviceDescriptors &desc) 550         [&ret] (const AudioDeviceDescriptors &desc) {
551         ret = desc.empty();
552     });
553     AudioAdapter::GetInstance().AddDeviceChangeListener(nullptr);
554 
555     DeviceChangeAction action = {};
556     action.type = OHOS::AudioStandard::DeviceChangeType::CONNECT;
557     AudioAdapter::GetInstance().OnDeviceChange(action);
558     EXPECT_FALSE(ret);
559 }
560 
561 /**
562  * @tc.name: OnDeviceChange002
563  * @tc.desc: Notify registered listener when the audio output devices are updated.
564  * @tc.type: FUNC
565  * @tc.require: AR000H31KJ
566  */
567 static HWTEST(AudioAdapterTest, OnDeviceChange002, TestSize.Level0)
568 {
569     SLOGD("OnDeviceChange002 begin!");
570     bool ret = OHOS::AVSession::AVSESSION_SUCCESS;
571     ret = AudioAdapter::GetInstance().SetDeviceChangeCallback();
572 
573     DeviceChangeAction action = {};
574     action.type = OHOS::AudioStandard::DeviceChangeType::CONNECT;
575     auto& audioAdapter = AudioAdapter::GetInstance();
576     audioAdapter.OnDeviceChange(action);
577     EXPECT_EQ(ret, OHOS::AVSession::AVSESSION_SUCCESS);
578 }
579 
580 /**
581  * @tc.name: OnDeviceChange003
582  * @tc.desc: Notify registered listener when the audio output devices are updated.
583  * @tc.type: FUNC
584  * @tc.require: AR000H31KJ
585  */
586 static HWTEST(AudioAdapterTest, OnDeviceChange003, TestSize.Level0)
587 {
588     SLOGD("OnDeviceChange003 begin!");
589     bool ret = OHOS::AVSession::AVSESSION_SUCCESS;
590     ret = AudioAdapter::GetInstance().SetDeviceChangeCallback();
591     EXPECT_EQ(ret, OHOS::AVSession::AVSESSION_SUCCESS);
592 
593     ret = AudioAdapter::GetInstance().UnsetDeviceChangeCallback();
594     DeviceChangeAction action = {};
595     action.type = OHOS::AudioStandard::DeviceChangeType::CONNECT;
596     auto& audioAdapter = AudioAdapter::GetInstance();
597     audioAdapter.OnDeviceChange(action);
598     EXPECT_EQ(ret, OHOS::AVSession::AVSESSION_SUCCESS);
599 }
600 
601 /**
602  * @tc.name: OnPreferredOutputDeviceChange001
603  * @tc.desc: Notify registered listener when the audio preferred device is updated.
604  * @tc.type: FUNC
605  * @tc.require: AR000H31KJ
606  */
607 static HWTEST(AudioAdapterTest, OnPreferredOutputDeviceChange001, TestSize.Level0)
608 {
609     SLOGD("OnPreferredOutputDeviceChange001 begin!");
610     bool ret = false;
611     AudioAdapter::GetInstance().SetPreferredOutputDeviceChangeCallback(
__anone79521711102(const AudioDeviceDescriptors &desc) 612         [&ret] (const AudioDeviceDescriptors &desc) {
613         auto device = AudioAdapter::GetInstance().GetPreferredOutputDeviceForRendererInfo();
614         ret = device.empty();
615     });
616 
617     auto& audioAdapter = AudioAdapter::GetInstance();
618     AudioDeviceDescriptors availableDevices = audioAdapter.GetAvailableDevices();
619     CHECK_AND_RETURN_LOG(availableDevices.size() > 0, "No available devices for testing");
620     audioAdapter.SelectOutputDevice(availableDevices[0]);
621     sleep(1);
622     EXPECT_FALSE(ret);
623 }
624 
625 /**
626  * @tc.name: OnPreferredOutputDeviceChange002
627  * @tc.desc: Notify registered listener when the audio preferred device is updated.
628  * @tc.type: FUNC
629  * @tc.require: AR000H31KJ
630  */
631 static HWTEST(AudioAdapterTest, OnPreferredOutputDeviceChange002, TestSize.Level0)
632 {
633     SLOGD("OnPreferredOutputDeviceChange002 begin!");
634     bool ret = false;
635     AudioAdapter::GetInstance().SetPreferredOutputDeviceChangeCallback(
__anone79521711202(const AudioDeviceDescriptors &desc) 636         [&ret] (const AudioDeviceDescriptors &desc) {
637         auto device = AudioAdapter::GetInstance().GetPreferredOutputDeviceForRendererInfo();
638         ret = device.empty();
639     });
640     AudioAdapter::GetInstance().UnsetPreferredOutputDeviceChangeCallback();
641 
642     auto& audioAdapter = AudioAdapter::GetInstance();
643     AudioDeviceDescriptors availableDevices = audioAdapter.GetAvailableDevices();
644     CHECK_AND_RETURN_LOG(availableDevices.size() > 0, "No available devices for testing");
645     audioAdapter.SelectOutputDevice(availableDevices[0]);
646     sleep(1);
647     EXPECT_FALSE(ret);
648 }
649 
650 /**
651  * @tc.name: SelectOutputDevice001
652  * @tc.desc: Test SelectOutputDevice with a valid device descriptor that matches one available device.
653  * @tc.type: FUNC
654  * @tc.require: AR000H31KJ
655  */
656 static HWTEST(AudioAdapterTest, SelectOutputDevice001, TestSize.Level0)
657 {
658     SLOGD("SelectOutputDevice001 begin!");
659     AudioAdapter::GetInstance().Init();
660     auto& audioAdapter = AudioAdapter::GetInstance();
661     AudioDeviceDescriptorWithSptr desc {new OHOS::AudioStandard::AudioDeviceDescriptor()};
662     auto ret = audioAdapter.SelectOutputDevice(desc);
663     EXPECT_EQ(ret, AVSESSION_ERROR);
664 }
665 
666 /**
667  * @tc.name: SelectOutputDevice002
668  * @tc.desc: Test SelectOutputDevice with a valid device descriptor that matches one available device.
669  * @tc.type: FUNC
670  * @tc.require: AR000H31KJ
671  */
672 static HWTEST(AudioAdapterTest, SelectOutputDevice002, TestSize.Level0)
673 {
674     SLOGD("SelectOutputDevice002 begin!");
675     AudioAdapter::GetInstance().Init();
676     auto& audioAdapter = AudioAdapter::GetInstance();
677     AudioDeviceDescriptors availableDevices = audioAdapter.GetAvailableDevices();
678 
679     CHECK_AND_RETURN_LOG(availableDevices.size() > 0, "No available devices for testing");
680     auto testDevice = availableDevices[0];
681     AudioDeviceDescriptorWithSptr desc {new OHOS::AudioStandard::AudioDeviceDescriptor()};
682     desc->deviceCategory_ = testDevice->deviceCategory_;
683     EXPECT_NE(desc->deviceType_, testDevice->deviceType_);
684     int32_t ret = audioAdapter.SelectOutputDevice(desc);
685     EXPECT_EQ(ret, AVSESSION_ERROR);
686 }
687