1 /*
2 * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 /**
17 * @addtogroup Audio
18 * @{
19 *
20 * @brief Defines audio-related APIs, including custom data types and functions for loading drivers,
21 * accessing a driver adapter, and rendering audios.
22 *
23 * @since 1.0
24 * @version 1.0
25 */
26
27 /**
28 * @file audio_hdi_common.h
29 *
30 * @brief Declares APIs for operations related to the audio render adapter.
31 *
32 * @since 1.0
33 * @version 1.0
34 */
35
36 #include "audio_hdi_common.h"
37 #include "audio_hdirender_scene_test.h"
38
39 using namespace std;
40 using namespace testing::ext;
41 using namespace OHOS::Audio;
42
43 namespace {
44 class AudioHdiRenderSceneTest : public testing::Test {
45 public:
46 static void SetUpTestCase(void);
47 static void TearDownTestCase(void);
48 void SetUp();
49 void TearDown();
50 static int32_t GetManager(struct PrepareAudioPara& audiopara);
51 };
52
53 using THREAD_FUNC = void *(*)(void *);
54
SetUpTestCase(void)55 void AudioHdiRenderSceneTest::SetUpTestCase(void) {}
56
TearDownTestCase(void)57 void AudioHdiRenderSceneTest::TearDownTestCase(void) {}
58
SetUp(void)59 void AudioHdiRenderSceneTest::SetUp(void) {}
60
TearDown(void)61 void AudioHdiRenderSceneTest::TearDown(void) {}
62
GetManager(struct PrepareAudioPara & audiopara)63 int32_t AudioHdiRenderSceneTest::GetManager(struct PrepareAudioPara& audiopara)
64 {
65 audiopara.manager = GetAudioManagerFuncs();
66
67 if (audiopara.manager == nullptr) {
68 return HDF_FAILURE;
69 }
70 return HDF_SUCCESS;
71 }
72 /**
73 * @tc.name Test AudioRenderCheckSceneCapability API and check scene's capability
74 * @tc.number SUB_Audio_HDI_RenderCheckSceneCapability_0001
75 * @tc.desc Test AudioRenderCheckSceneCapability interface,return 0 if check scene's capability successful.
76 */
77 HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_RenderCheckSceneCapability_0001, Function | MediumTest | Level1)
78 {
79 int32_t ret = -1;
80 bool supported = false;
81 struct AudioSceneDescriptor scenes = {};
82 struct AudioAdapter *adapter = nullptr;
83 struct AudioRender *render = nullptr;
84
85 TestAudioManager* manager = GetAudioManagerFuncs();
86 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
87 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
88
89 scenes.scene.id = 0;
90 scenes.desc.pins = PIN_OUT_SPEAKER;
91 ret = render->scene.CheckSceneCapability(render, &scenes, &supported);
92 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
93 EXPECT_TRUE(supported);
94
95 adapter->DestroyRender(adapter, render);
96 manager->UnloadAdapter(manager, adapter);
97 }
98
99 /**
100 * @tc.name Test checking scene's capability where the render is empty
101 * @tc.number SUB_Audio_HDI_RenderCheckSceneCapability_0003
102 * @tc.desc Test AudioRenderCheckSceneCapability,return -1 if the render is empty.
103 */
104 HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_RenderCheckSceneCapability_0003, Function | MediumTest | Level1)
105 {
106 int32_t ret = -1;
107 bool supported = true;
108 struct AudioSceneDescriptor scenes = {};
109 struct AudioAdapter *adapter = nullptr;
110 struct AudioRender *render = nullptr;
111 struct AudioRender *renderNull = nullptr;
112
113 TestAudioManager* manager = GetAudioManagerFuncs();
114 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
115 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
116
117 scenes.scene.id = 0;
118 scenes.desc.pins = PIN_OUT_SPEAKER;
119 ret = render->scene.CheckSceneCapability(renderNull, &scenes, &supported);
120 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
121
122 adapter->DestroyRender(adapter, render);
123 manager->UnloadAdapter(manager, adapter);
124 }
125 /**
126 * @tc.name Test AudioRenderCheckSceneCapability API and check scene's capability
127 * @tc.number SUB_Audio_HDI_RenderCheckSceneCapability_0004
128 * @tc.desc Test AudioRenderCheckSceneCapability interface,return -1 if the scene is empty.
129 */
130 HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_RenderCheckSceneCapability_0004, Function | MediumTest | Level1)
131 {
132 int32_t ret = -1;
133 bool supported = true;
134 struct AudioSceneDescriptor *scenes = nullptr;
135 struct AudioAdapter *adapter = nullptr;
136 struct AudioRender *render = nullptr;
137
138 TestAudioManager* manager = GetAudioManagerFuncs();
139 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
140 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
141
142 ret = render->scene.CheckSceneCapability(render, scenes, &supported);
143 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
144
145 adapter->DestroyRender(adapter, render);
146 manager->UnloadAdapter(manager, adapter);
147 }
148 /**
149 * @tc.name Test AudioRenderCheckSceneCapability API and check scene's capability
150 * @tc.number SUB_Audio_HDI_RenderCheckSceneCapability_0005
151 * @tc.desc Test AudioRenderCheckSceneCapability interface,return -1 if the supported is empty.
152 */
153 HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_RenderCheckSceneCapability_0005, Function | MediumTest | Level1)
154 {
155 int32_t ret = -1;
156 struct AudioSceneDescriptor scenes = {};
157 struct AudioAdapter *adapter = nullptr;
158 struct AudioRender *render = nullptr;
159
160 TestAudioManager* manager = GetAudioManagerFuncs();
161 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
162 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
163
164 scenes.scene.id = 0;
165 scenes.desc.pins = PIN_OUT_SPEAKER;
166 ret = render->scene.CheckSceneCapability(render, &scenes, nullptr);
167 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
168
169 adapter->DestroyRender(adapter, render);
170 manager->UnloadAdapter(manager, adapter);
171 }
172 /**
173 * @tc.name Test AudioRenderSelectScene API via legal input
174 * @tc.number SUB_Audio_HDI_AudioRenderSelectScene_0001
175 * @tc.desc Test AudioRenderSelectScene interface,return 0 if select Render's scene successful.
176 */
177 HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_AudioRenderSelectScene_0001, Function | MediumTest | Level1)
178 {
179 int32_t ret = -1;
180 struct AudioSceneDescriptor scenes = {};
181 struct AudioAdapter *adapter = nullptr;
182 struct AudioRender *render = nullptr;
183
184 TestAudioManager* manager = GetAudioManagerFuncs();
185 scenes.scene.id = 0;
186 scenes.desc.pins = PIN_OUT_SPEAKER;
187
188 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
189 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
190
191 ret = render->scene.SelectScene(render, &scenes);
192 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
193
194 ret = AudioRenderStartAndOneFrame(render);
195 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
196
197 ret = render->control.Stop((AudioHandle)render);
198 adapter->DestroyRender(adapter, render);
199 manager->UnloadAdapter(manager, adapter);
200 }
201 /**
202 * @tc.name Test AudioRenderSelectScene API after Render start.
203 * @tc.number SUB_Audio_HDI_AudioRenderSelectScene_0002
204 * @tc.desc Test AudioRenderSelectScene, return 0 if select Render's scene successful after Render start.
205 */
206 HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_AudioRenderSelectScene_0002, Function | MediumTest | Level1)
207 {
208 int32_t ret = -1;
209 struct AudioSceneDescriptor scenes = {};
210 TestAudioManager* manager = {};
211 struct AudioAdapter *adapter = nullptr;
212 struct AudioRender *render = nullptr;
213
214 manager = GetAudioManagerFuncs();
215 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
216 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
217
218 scenes.scene.id = 0;
219 scenes.desc.pins = PIN_OUT_SPEAKER;
220 ret = render->scene.SelectScene(render, &scenes);
221 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
222
223 ret = render->control.Stop((AudioHandle)render);
224 adapter->DestroyRender(adapter, render);
225 manager->UnloadAdapter(manager, adapter);
226 }
227 /**
228 * @tc.name Test AudioRenderSelectScene API where the parameter handle is empty.
229 * @tc.number SUB_Audio_HDI_AudioRenderSelectScene_0003
230 * @tc.desc Test AudioRenderSelectScene, return -1 if the parameter handle is empty.
231 */
232 HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_AudioRenderSelectScene_0003, Function | MediumTest | Level1)
233 {
234 int32_t ret = -1;
235 struct AudioSceneDescriptor scenes = {};
236 struct AudioAdapter *adapter = nullptr;
237 struct AudioRender *render = nullptr;
238 struct AudioRender *renderNull = nullptr;
239
240 TestAudioManager* manager = GetAudioManagerFuncs();
241 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
242 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
243
244 scenes.scene.id = 0;
245 scenes.desc.pins = PIN_IN_MIC;
246 ret = render->scene.SelectScene(renderNull, &scenes);
247 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
248
249 adapter->DestroyRender(adapter, render);
250 manager->UnloadAdapter(manager, adapter);
251 }
252 /**
253 * @tc.name Test AudioRenderSelectScene API where the parameter scene is empty.
254 * @tc.number SUB_Audio_HDI_AudioRenderSelectScene_0004
255 * @tc.desc Test AudioRenderSelectScene, return -1 if the parameter scene is empty.
256 */
257 HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_AudioRenderSelectScene_0004, Function | MediumTest | Level1)
258 {
259 int32_t ret = -1;
260 struct AudioSceneDescriptor *scenes = nullptr;
261 struct AudioAdapter *adapter = nullptr;
262 struct AudioRender *render = nullptr;
263
264 TestAudioManager* manager = GetAudioManagerFuncs();
265 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
266 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
267
268 ret = render->scene.SelectScene(render, scenes);
269 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
270
271 adapter->DestroyRender(adapter, render);
272 manager->UnloadAdapter(manager, adapter);
273 }
274 /**
275 * @tc.name Test AudioRenderSelectScene API where the scene is not configed in the josn.
276 * @tc.number SUB_Audio_HDI_AudioRenderSelectScene_0005
277 * @tc.desc Test AudioRenderSelectScene, return -1 if the scene is not configed in the josn.
278 */
279 HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_AudioRenderSelectScene_0005, Function | MediumTest | Level1)
280 {
281 int32_t ret = -1;
282 struct AudioSceneDescriptor scenes = {};
283 struct AudioAdapter *adapter = nullptr;
284 struct AudioRender *render = nullptr;
285
286 TestAudioManager* manager = GetAudioManagerFuncs();
287 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
288 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
289
290 scenes.scene.id = 5;
291 scenes.desc.pins = PIN_OUT_HDMI;
292 ret = render->scene.SelectScene(render, &scenes);
293 EXPECT_NE(AUDIO_HAL_SUCCESS, ret);
294
295 adapter->DestroyRender(adapter, render);
296 manager->UnloadAdapter(manager, adapter);
297 }
298 #ifdef AUDIO_ADM_SO
299 /**
300 * @tc.name Test AudioRenderTurnStandbyMode API via input "AUDIO_FLUSH_COMPLETED"
301 * @tc.number SUB_Audio_HDI_AudioRenderRegCallback_0001
302 * @tc.desc Test AudioRenderTurnStandbyMode interface,return 0 if the interface use correctly.
303 */
304 HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_AudioRenderRegCallback_0001, Function | MediumTest | Level1)
305 {
306 int32_t ret = -1;
307 struct AudioAdapter *adapter = nullptr;
308 struct AudioRender *render = nullptr;
309
310 ASSERT_NE(GetAudioManagerFuncs, nullptr);
311 TestAudioManager* manager = GetAudioManagerFuncs();
312 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
313 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
314
315 ret = render->RegCallback(render, AudioRenderCallback, nullptr);
316 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
317
318 ret = render->control.Flush((AudioHandle)render);
319 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
320
321 ret = CheckFlushValue();
322 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
323
324 adapter->DestroyRender(adapter, render);
325 manager->UnloadAdapter(manager, adapter);
326 }
327
328 /**
329 * @tc.name Test AudioRenderRegCallback API via input "AUDIO_NONBLOCK_WRITE_COMPELETED"
330 * @tc.number SUB_Audio_HDI_AudioRenderRegCallback_0002
331 * @tc.desc Test AudioRenderRegCallback interface,return 0 if the interface use correctly.
332 */
333 HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_AudioRenderRegCallback_0002, Function | MediumTest | Level1)
334 {
335 int32_t ret = -1;
336 struct AudioAdapter *adapter = nullptr;
337 struct AudioRender *render = nullptr;
338 struct AudioSampleAttributes attrs;
339 struct AudioHeadInfo headInfo;
340 char absPath[PATH_MAX] = {0};
341 realpath(AUDIO_FILE.c_str(), absPath);
342 ASSERT_NE(realpath(AUDIO_FILE.c_str(), absPath), nullptr);
343
344 FILE *file = fopen(absPath, "rb");
345 ASSERT_NE(file, nullptr);
346 ASSERT_NE(GetAudioManagerFuncs, nullptr);
347 TestAudioManager* manager = GetAudioManagerFuncs();
348 ret = WavHeadAnalysis(headInfo, file, attrs);
349 if (ret < 0) {
350 fclose(file);
351 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
352 }
353 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME, &adapter, &render);
354 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
355
356 ret = render->RegCallback(render, AudioRenderCallback, nullptr);
357 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
358
359 ret = FrameStart(headInfo, render, file, attrs);
360 if (ret < 0) {
361 adapter->DestroyRender(adapter, render);
362 manager->UnloadAdapter(manager, adapter);
363 fclose(file);
364 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
365 }
366
367 ret = CheckWriteCompleteValue();
368 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
369 ret = CheckRenderFullValue();
370 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
371
372 adapter->DestroyRender(adapter, render);
373 manager->UnloadAdapter(manager, adapter);
374 fclose(file);
375 }
376 /**
377 * @tc.name Test AudioRenderTurnStandbyMode API via
378 * @tc.number SUB_Audio_HDI_AudioRenderTurnStandbyMode_0001
379 * @tc.desc Test AudioRenderTurnStandbyMode interface,return 0 if the interface use correctly.
380 */
381 HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_AudioRenderTurnStandbyMode_0001, Function | MediumTest | Level1)
382 {
383 int32_t ret = -1;
384 struct AudioAdapter *adapter = nullptr;
385 struct AudioRender *render = nullptr;
386 ASSERT_NE(GetAudioManagerFuncs, nullptr);
387 TestAudioManager* manager = GetAudioManagerFuncs();
388 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME);
389 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
390
391 ret = render->control.TurnStandbyMode((AudioHandle)render);
392 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
393
394 sleep(3);
395
396 ret = render->control.Stop((AudioHandle)render);
397 adapter->DestroyRender(adapter, render);
398 manager->UnloadAdapter(manager, adapter);
399 }
400 /**
401 * @tc.name Test AudioRenderAudioDevDump API via
402 * @tc.number SUB_Audio_HDI_AudioRenderAudioDevDump_0001
403 * @tc.desc Test AudioRenderAudioDevDump interface,return 0 if the interface use correctly.
404 */
405 HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_AudioRenderAudioDevDump_0001, Function | MediumTest | Level1)
406 {
407 int32_t ret = -1;
408 char pathBuf[] = "./DevDump.log";
409 FILE *fp = fopen(pathBuf, "wb+");
410 ASSERT_NE(nullptr, fp);
411 int fd = fileno(fp);
412 if (fd == -1) {
413 fclose(fp);
414 ASSERT_NE(fd, -1);
415 }
416 struct PrepareAudioPara audiopara = {
417 .portType = PORT_OUT, .adapterName = ADAPTER_NAME.c_str(), .self = this, .pins = PIN_OUT_SPEAKER,
418 .path = AUDIO_FILE.c_str()
419 };
420 ret = GetManager(audiopara);
421 if (ret < 0) {
422 fclose(fp);
423 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
424 }
425 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara);
426 if (ret < 0) {
427 fclose(fp);
428 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
429 }
430 sleep(1);
431 ret = audiopara.render->control.Pause((AudioHandle)audiopara.render);
432 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
433 sleep(1);
434 ret = audiopara.render->control.Resume((AudioHandle)audiopara.render);
435 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
436 ret = audiopara.render->control.AudioDevDump((AudioHandle)audiopara.render, RANGE, fd);
437 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
438 fclose(fp);
439 ret = ThreadRelease(audiopara);
440 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
441 }
442 #endif
443 }