1 /*
2 * Copyright (c) 2021 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 HMOS::Audio;
42
43 namespace {
44 const string ADAPTER_NAME_USB = "usb";
45 const string ADAPTER_NAME_INTERNAL = "internal";
46
47 class AudioHdiRenderSceneTest : public testing::Test {
48 public:
49 static void SetUpTestCase(void);
50 static void TearDownTestCase(void);
51 void SetUp();
52 void TearDown();
53 static TestAudioManager *(*GetAudioManager)();
54 static void *handleSo;
55 #ifdef AUDIO_MPI_SO
56 static int32_t (*SdkInit)();
57 static void (*SdkExit)();
58 static void *sdkSo;
59 #endif
60 static int32_t GetManager(struct PrepareAudioPara& audiopara);
61 };
62
63 using THREAD_FUNC = void *(*)(void *);
64
65 TestAudioManager *(*AudioHdiRenderSceneTest::GetAudioManager)() = nullptr;
66 void *AudioHdiRenderSceneTest::handleSo = nullptr;
67 #ifdef AUDIO_MPI_SO
68 int32_t (*AudioHdiRenderSceneTest::SdkInit)() = nullptr;
69 void (*AudioHdiRenderSceneTest::SdkExit)() = nullptr;
70 void *AudioHdiRenderSceneTest::sdkSo = nullptr;
71 #endif
72
SetUpTestCase(void)73 void AudioHdiRenderSceneTest::SetUpTestCase(void)
74 {
75 #ifdef AUDIO_MPI_SO
76 char sdkResolvedPath[] = HDF_LIBRARY_FULL_PATH("libhdi_audio_interface_lib_render");
77 sdkSo = dlopen(sdkResolvedPath, RTLD_LAZY);
78 if (sdkSo == nullptr) {
79 return;
80 }
81 SdkInit = (int32_t (*)())(dlsym(sdkSo, "MpiSdkInit"));
82 if (SdkInit == nullptr) {
83 return;
84 }
85 SdkExit = (void (*)())(dlsym(sdkSo, "MpiSdkExit"));
86 if (SdkExit == nullptr) {
87 return;
88 }
89 SdkInit();
90 #endif
91 char absPath[PATH_MAX] = {0};
92 if (realpath(RESOLVED_PATH.c_str(), absPath) == nullptr) {
93 return;
94 }
95 handleSo = dlopen(absPath, RTLD_LAZY);
96 if (handleSo == nullptr) {
97 return;
98 }
99 GetAudioManager = (TestAudioManager *(*)())(dlsym(handleSo, FUNCTION_NAME.c_str()));
100 if (GetAudioManager == nullptr) {
101 return;
102 }
103 }
104
TearDownTestCase(void)105 void AudioHdiRenderSceneTest::TearDownTestCase(void)
106 {
107 #ifdef AUDIO_MPI_SO
108 SdkExit();
109 if (sdkSo != nullptr) {
110 dlclose(sdkSo);
111 sdkSo = nullptr;
112 }
113 if (SdkInit != nullptr) {
114 SdkInit = nullptr;
115 }
116 if (SdkExit != nullptr) {
117 SdkExit = nullptr;
118 }
119 #endif
120 if (handleSo != nullptr) {
121 dlclose(handleSo);
122 handleSo = nullptr;
123 }
124 if (GetAudioManager != nullptr) {
125 GetAudioManager = nullptr;
126 }
127 }
128
SetUp(void)129 void AudioHdiRenderSceneTest::SetUp(void) {}
130
TearDown(void)131 void AudioHdiRenderSceneTest::TearDown(void) {}
132
GetManager(struct PrepareAudioPara & audiopara)133 int32_t AudioHdiRenderSceneTest::GetManager(struct PrepareAudioPara& audiopara)
134 {
135 auto *inst = (AudioHdiRenderSceneTest *)audiopara.self;
136 if (inst != nullptr && inst->GetAudioManager != nullptr) {
137 audiopara.manager = inst->GetAudioManager();
138 }
139 if (audiopara.manager == nullptr) {
140 return HDF_FAILURE;
141 }
142 return HDF_SUCCESS;
143 }
144 /**
145 * @tc.name Test AudioRenderCheckSceneCapability API and check scene's capability
146 * @tc.number SUB_Audio_HDI_RenderCheckSceneCapability_0001
147 * @tc.desc Test AudioRenderCheckSceneCapability interface,return 0 if check scene's capability successful.
148 */
149 HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_RenderCheckSceneCapability_0001, Function | MediumTest | Level1)
150 {
151 int32_t ret = -1;
152 bool supported = false;
153 struct AudioSceneDescriptor scenes = {};
154 struct AudioAdapter *adapter = nullptr;
155 struct AudioRender *render = nullptr;
156 ASSERT_NE(nullptr, GetAudioManager);
157 TestAudioManager* manager = GetAudioManager();
158 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
159 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
160
161 scenes.scene.id = 0;
162 scenes.desc.pins = PIN_OUT_SPEAKER;
163 ret = render->scene.CheckSceneCapability(render, &scenes, &supported);
164 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
165 EXPECT_TRUE(supported);
166
167 adapter->DestroyRender(adapter, render);
168 manager->UnloadAdapter(manager, adapter);
169 }
170 /**
171 * @tc.name Test checking scene's capability where the scene is not configed in the josn.
172 * @tc.number SUB_Audio_HDI_RenderCheckSceneCapability_0002
173 * @tc.desc Test RenderCheckSceneCapability interface,return -1 if the scene is not configed in the josn.
174 */
175 HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_RenderCheckSceneCapability_0002, Function | MediumTest | Level1)
176 {
177 int32_t ret = -1;
178 bool supported = true;
179 struct AudioSceneDescriptor scenes = {};
180 struct AudioAdapter *adapter = nullptr;
181 struct AudioRender *render = nullptr;
182 ASSERT_NE(nullptr, GetAudioManager);
183 TestAudioManager* manager = GetAudioManager();
184 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
185 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
186
187 scenes.scene.id = 5;
188 scenes.desc.pins = PIN_OUT_SPEAKER;
189 ret = render->scene.CheckSceneCapability(render, &scenes, &supported);
190 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
191
192 adapter->DestroyRender(adapter, render);
193 manager->UnloadAdapter(manager, adapter);
194 }
195 /**
196 * @tc.name Test checking scene's capability where the render is empty
197 * @tc.number SUB_Audio_HDI_RenderCheckSceneCapability_0003
198 * @tc.desc Test AudioRenderCheckSceneCapability,return -1 if the render is empty.
199 */
200 HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_RenderCheckSceneCapability_0003, Function | MediumTest | Level1)
201 {
202 int32_t ret = -1;
203 bool supported = true;
204 struct AudioSceneDescriptor scenes = {};
205 struct AudioAdapter *adapter = nullptr;
206 struct AudioRender *render = nullptr;
207 struct AudioRender *renderNull = nullptr;
208 ASSERT_NE(nullptr, GetAudioManager);
209 TestAudioManager* manager = GetAudioManager();
210 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
211 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
212
213 scenes.scene.id = 0;
214 scenes.desc.pins = PIN_OUT_SPEAKER;
215 ret = render->scene.CheckSceneCapability(renderNull, &scenes, &supported);
216 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
217
218 adapter->DestroyRender(adapter, render);
219 manager->UnloadAdapter(manager, adapter);
220 }
221 /**
222 * @tc.name Test AudioRenderCheckSceneCapability API and check scene's capability
223 * @tc.number SUB_Audio_HDI_RenderCheckSceneCapability_0004
224 * @tc.desc Test AudioRenderCheckSceneCapability interface,return -1 if the scene is empty.
225 */
226 HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_RenderCheckSceneCapability_0004, Function | MediumTest | Level1)
227 {
228 int32_t ret = -1;
229 bool supported = true;
230 struct AudioSceneDescriptor *scenes = nullptr;
231 struct AudioAdapter *adapter = nullptr;
232 struct AudioRender *render = nullptr;
233 ASSERT_NE(nullptr, GetAudioManager);
234 TestAudioManager* manager = GetAudioManager();
235 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
236 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
237
238 ret = render->scene.CheckSceneCapability(render, scenes, &supported);
239 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
240
241 adapter->DestroyRender(adapter, render);
242 manager->UnloadAdapter(manager, adapter);
243 }
244 /**
245 * @tc.name Test AudioRenderCheckSceneCapability API and check scene's capability
246 * @tc.number SUB_Audio_HDI_RenderCheckSceneCapability_0005
247 * @tc.desc Test AudioRenderCheckSceneCapability interface,return -1 if the supported is empty.
248 */
249 HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_RenderCheckSceneCapability_0005, Function | MediumTest | Level1)
250 {
251 int32_t ret = -1;
252 struct AudioSceneDescriptor scenes = {};
253 struct AudioAdapter *adapter = nullptr;
254 struct AudioRender *render = nullptr;
255 ASSERT_NE(nullptr, GetAudioManager);
256 TestAudioManager* manager = GetAudioManager();
257 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
258 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
259
260 scenes.scene.id = 0;
261 scenes.desc.pins = PIN_OUT_SPEAKER;
262 ret = render->scene.CheckSceneCapability(render, &scenes, nullptr);
263 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
264
265 adapter->DestroyRender(adapter, render);
266 manager->UnloadAdapter(manager, adapter);
267 }
268 /**
269 * @tc.name Test AudioRenderSelectScene API via legal input
270 * @tc.number SUB_Audio_HDI_AudioRenderSelectScene_0001
271 * @tc.desc Test AudioRenderSelectScene interface,return 0 if select Render's scene successful.
272 */
273 HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_AudioRenderSelectScene_0001, Function | MediumTest | Level1)
274 {
275 int32_t ret = -1;
276 struct AudioSceneDescriptor scenes = {};
277 struct AudioAdapter *adapter = nullptr;
278 struct AudioRender *render = nullptr;
279 ASSERT_NE(nullptr, GetAudioManager);
280 TestAudioManager* manager = GetAudioManager();
281 scenes.scene.id = 0;
282 scenes.desc.pins = PIN_OUT_SPEAKER;
283
284 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
285 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
286
287 ret = render->scene.SelectScene(render, &scenes);
288 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
289
290 ret = AudioRenderStartAndOneFrame(render);
291 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
292
293 ret = render->control.Stop((AudioHandle)render);
294 adapter->DestroyRender(adapter, render);
295 manager->UnloadAdapter(manager, adapter);
296 }
297 /**
298 * @tc.name Test AudioRenderSelectScene API after Render start.
299 * @tc.number SUB_Audio_HDI_AudioRenderSelectScene_0002
300 * @tc.desc Test AudioRenderSelectScene, return 0 if select Render's scene successful after Render start.
301 */
302 HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_AudioRenderSelectScene_0002, Function | MediumTest | Level1)
303 {
304 int32_t ret = -1;
305 struct AudioSceneDescriptor scenes = {};
306 TestAudioManager* manager = {};
307 struct AudioAdapter *adapter =nullptr;
308 struct AudioRender *render = nullptr;
309 ASSERT_NE(nullptr, GetAudioManager);
310 manager = GetAudioManager();
311 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
312 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
313
314 scenes.scene.id = 0;
315 scenes.desc.pins = PIN_OUT_SPEAKER;
316 ret = render->scene.SelectScene(render, &scenes);
317 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
318
319 ret = render->control.Stop((AudioHandle)render);
320 adapter->DestroyRender(adapter, render);
321 manager->UnloadAdapter(manager, adapter);
322 }
323 /**
324 * @tc.name Test AudioRenderSelectScene API where the parameter handle is empty.
325 * @tc.number SUB_Audio_HDI_AudioRenderSelectScene_0003
326 * @tc.desc Test AudioRenderSelectScene, return -1 if the parameter handle is empty.
327 */
328 HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_AudioRenderSelectScene_0003, Function | MediumTest | Level1)
329 {
330 int32_t ret = -1;
331 struct AudioSceneDescriptor scenes = {};
332 struct AudioAdapter *adapter = nullptr;
333 struct AudioRender *render = nullptr;
334 struct AudioRender *renderNull = nullptr;
335 ASSERT_NE(nullptr, GetAudioManager);
336 TestAudioManager* manager = GetAudioManager();
337 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
338 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
339
340 scenes.scene.id = 0;
341 scenes.desc.pins = PIN_IN_MIC;
342 ret = render->scene.SelectScene(renderNull, &scenes);
343 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
344
345 adapter->DestroyRender(adapter, render);
346 manager->UnloadAdapter(manager, adapter);
347 }
348 /**
349 * @tc.name Test AudioRenderSelectScene API where the parameter scene is empty.
350 * @tc.number SUB_Audio_HDI_AudioRenderSelectScene_0004
351 * @tc.desc Test AudioRenderSelectScene, return -1 if the parameter scene is empty.
352 */
353 HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_AudioRenderSelectScene_0004, Function | MediumTest | Level1)
354 {
355 int32_t ret = -1;
356 struct AudioSceneDescriptor *scenes = nullptr;
357 struct AudioAdapter *adapter = nullptr;
358 struct AudioRender *render = nullptr;
359 ASSERT_NE(nullptr, GetAudioManager);
360 TestAudioManager* manager = GetAudioManager();
361 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
362 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
363
364 ret = render->scene.SelectScene(render, scenes);
365 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
366
367 adapter->DestroyRender(adapter, render);
368 manager->UnloadAdapter(manager, adapter);
369 }
370 /**
371 * @tc.name Test AudioRenderSelectScene API where the scene is not configed in the josn.
372 * @tc.number SUB_Audio_HDI_AudioRenderSelectScene_0005
373 * @tc.desc Test AudioRenderSelectScene, return -1 if the scene is not configed in the josn.
374 */
375 HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_AudioRenderSelectScene_0005, Function | MediumTest | Level1)
376 {
377 int32_t ret = -1;
378 struct AudioSceneDescriptor scenes = {};
379 struct AudioAdapter *adapter = nullptr;
380 struct AudioRender *render = nullptr;
381 ASSERT_NE(nullptr, GetAudioManager);
382 TestAudioManager* manager = GetAudioManager();
383 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
384 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
385
386 scenes.scene.id = 5;
387 scenes.desc.pins = PIN_OUT_HDMI;
388 ret = render->scene.SelectScene(render, &scenes);
389 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
390
391 adapter->DestroyRender(adapter, render);
392 manager->UnloadAdapter(manager, adapter);
393 }
394 #ifdef AUDIO_ADM_SO
395 /**
396 * @tc.name Test AudioRenderTurnStandbyMode API via input "AUDIO_FLUSH_COMPLETED"
397 * @tc.number SUB_Audio_HDI_AudioRenderRegCallback_0001
398 * @tc.desc Test AudioRenderTurnStandbyMode interface,return 0 if the interface use correctly.
399 */
400 HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_AudioRenderRegCallback_0001, Function | MediumTest | Level1)
401 {
402 int32_t ret = -1;
403 struct AudioAdapter *adapter = nullptr;
404 struct AudioRender *render = nullptr;
405
406 ASSERT_NE(GetAudioManager, nullptr);
407 TestAudioManager* manager = GetAudioManager();
408 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
409 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
410
411 ret = render->RegCallback(render, AudioRenderCallback, nullptr);
412 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
413
414 ret = render->control.Flush((AudioHandle)render);
415 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
416
417 ret = CheckFlushValue();
418 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
419
420 adapter->DestroyRender(adapter, render);
421 manager->UnloadAdapter(manager, adapter);
422 }
423
424 /**
425 * @tc.name Test AudioRenderRegCallback API via input "AUDIO_NONBLOCK_WRITE_COMPELETED"
426 * @tc.number SUB_Audio_HDI_AudioRenderRegCallback_0002
427 * @tc.desc Test AudioRenderRegCallback interface,return 0 if the interface use correctly.
428 */
429 HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_AudioRenderRegCallback_0002, Function | MediumTest | Level1)
430 {
431 int32_t ret = -1;
432 struct AudioAdapter *adapter = nullptr;
433 struct AudioRender *render = nullptr;
434 struct AudioSampleAttributes attrs;
435 struct AudioHeadInfo headInfo;
436 char absPath[PATH_MAX] = {0};
437 realpath(AUDIO_FILE.c_str(), absPath);
438 ASSERT_NE(realpath(AUDIO_FILE.c_str(), absPath), nullptr);
439
440 FILE *file = fopen(absPath, "rb");
441 ASSERT_NE(file, nullptr);
442 ASSERT_NE(GetAudioManager, nullptr);
443 TestAudioManager* manager = GetAudioManager();
444 ret = WavHeadAnalysis(headInfo, file, attrs);
445 if (ret < 0) {
446 fclose(file);
447 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
448 }
449 ret = AudioCreateRender(manager, PIN_OUT_SPEAKER, ADAPTER_NAME_USB, &adapter, &render);
450 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
451
452 ret = render->RegCallback(render, AudioRenderCallback, nullptr);
453 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
454
455 ret = FrameStart(headInfo, render, file, attrs);
456 if (ret < 0) {
457 adapter->DestroyRender(adapter, render);
458 manager->UnloadAdapter(manager, adapter);
459 fclose(file);
460 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
461 }
462
463 ret = CheckWriteCompleteValue();
464 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
465 ret = CheckRenderFullValue();
466 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
467
468 adapter->DestroyRender(adapter, render);
469 manager->UnloadAdapter(manager, adapter);
470 fclose(file);
471 }
472 /**
473 * @tc.name Test AudioRenderTurnStandbyMode API via
474 * @tc.number SUB_Audio_HDI_AudioRenderTurnStandbyMode_0001
475 * @tc.desc Test AudioRenderTurnStandbyMode interface,return 0 if the interface use correctly.
476 */
477 HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_AudioRenderTurnStandbyMode_0001, Function | MediumTest | Level1)
478 {
479 int32_t ret = -1;
480 struct AudioAdapter *adapter = nullptr;
481 struct AudioRender *render = nullptr;
482 ASSERT_NE(GetAudioManager, nullptr);
483 TestAudioManager* manager = GetAudioManager();
484 ret = AudioCreateStartRender(manager, &render, &adapter, ADAPTER_NAME_USB);
485 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
486
487 ret = render->control.TurnStandbyMode((AudioHandle)render);
488 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
489
490 sleep(3);
491
492 ret = render->control.Stop((AudioHandle)render);
493 adapter->DestroyRender(adapter, render);
494 manager->UnloadAdapter(manager, adapter);
495 }
496 /**
497 * @tc.name Test AudioRenderAudioDevDump API via
498 * @tc.number SUB_Audio_HDI_AudioRenderAudioDevDump_0001
499 * @tc.desc Test AudioRenderAudioDevDump interface,return 0 if the interface use correctly.
500 */
501 HWTEST_F(AudioHdiRenderSceneTest, SUB_Audio_HDI_AudioRenderAudioDevDump_0001, Function | MediumTest | Level1)
502 {
503 int32_t ret = -1;
504 char pathBuf[] = "./DevDump.log";
505 FILE *fp = fopen(pathBuf, "wb+");
506 ASSERT_NE(nullptr, fp);
507 int fd = fileno(fp);
508 if (fd == -1) {
509 fclose(fp);
510 ASSERT_NE(fd, -1);
511 }
512 struct PrepareAudioPara audiopara = {
513 .portType = PORT_OUT, .adapterName = ADAPTER_NAME_USB.c_str(), .self = this, .pins = PIN_OUT_SPEAKER,
514 .path = AUDIO_FILE.c_str()
515 };
516 ret = GetManager(audiopara);
517 if (ret < 0) {
518 fclose(fp);
519 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
520 }
521 ret = pthread_create(&audiopara.tids, NULL, (THREAD_FUNC)PlayAudioFile, &audiopara);
522 if (ret < 0) {
523 fclose(fp);
524 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
525 }
526 sleep(1);
527 ret = audiopara.render->control.Pause((AudioHandle)audiopara.render);
528 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
529 sleep(1);
530 ret = audiopara.render->control.Resume((AudioHandle)audiopara.render);
531 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
532 ret = audiopara.render->control.AudioDevDump((AudioHandle)audiopara.render, RANGE, fd);
533 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
534 fclose(fp);
535 ret = ThreadRelease(audiopara);
536 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
537 }
538 #endif
539 }