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 capture drivers function.
21 * accessing a driver adapter, and capturing 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 capturing audio adapter.
31 *
32 * @since 1.0
33 * @version 1.0
34 */
35
36 #include "audio_hdi_common.h"
37 #include "audio_hdicapture_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_HDMI = "hdmi";
45 const string ADAPTER_NAME_USB = "usb";
46 const string ADAPTER_NAME_INTERNAL = "internal";
47
48 class AudioHdiCaptureSceneTest : public testing::Test {
49 public:
50 static void SetUpTestCase(void);
51 static void TearDownTestCase(void);
52 void SetUp();
53 void TearDown();
54 static TestAudioManager *(*GetAudioManager)();
55 static void *handleSo;
56 #ifdef AUDIO_MPI_SO
57 static int32_t (*SdkInit)();
58 static void (*SdkExit)();
59 static void *sdkSo;
60 #endif
61 int32_t AudioCaptureStart(const string path, struct AudioCapture *capture) const;
62 };
63
64 TestAudioManager *(*AudioHdiCaptureSceneTest::GetAudioManager)() = nullptr;
65 void *AudioHdiCaptureSceneTest::handleSo = nullptr;
66 #ifdef AUDIO_MPI_SO
67 int32_t (*AudioHdiCaptureSceneTest::SdkInit)() = nullptr;
68 void (*AudioHdiCaptureSceneTest::SdkExit)() = nullptr;
69 void *AudioHdiCaptureSceneTest::sdkSo = nullptr;
70 #endif
71
SetUpTestCase(void)72 void AudioHdiCaptureSceneTest::SetUpTestCase(void)
73 {
74 #ifdef AUDIO_MPI_SO
75 char sdkResolvedPath[] = HDF_LIBRARY_FULL_PATH("libhdi_audio_interface_lib_render");
76 sdkSo = dlopen(sdkResolvedPath, RTLD_LAZY);
77 if (sdkSo == nullptr) {
78 return;
79 }
80 SdkInit = (int32_t (*)())(dlsym(sdkSo, "MpiSdkInit"));
81 if (SdkInit == nullptr) {
82 return;
83 }
84 SdkExit = (void (*)())(dlsym(sdkSo, "MpiSdkExit"));
85 if (SdkExit == nullptr) {
86 return;
87 }
88 SdkInit();
89 #endif
90 char absPath[PATH_MAX] = {0};
91 if (realpath(RESOLVED_PATH.c_str(), absPath) == nullptr) {
92 return;
93 }
94 handleSo = dlopen(absPath, RTLD_LAZY);
95 if (handleSo == nullptr) {
96 return;
97 }
98 GetAudioManager = (TestAudioManager *(*)())(dlsym(handleSo, FUNCTION_NAME.c_str()));
99 if (GetAudioManager == nullptr) {
100 return;
101 }
102 }
103
TearDownTestCase(void)104 void AudioHdiCaptureSceneTest::TearDownTestCase(void)
105 {
106 #ifdef AUDIO_MPI_SO
107 SdkExit();
108 if (sdkSo != nullptr) {
109 dlclose(sdkSo);
110 sdkSo = nullptr;
111 }
112 if (SdkInit != nullptr) {
113 SdkInit = nullptr;
114 }
115 if (SdkExit != nullptr) {
116 SdkExit = nullptr;
117 }
118 #endif
119 if (handleSo != nullptr) {
120 dlclose(handleSo);
121 handleSo = nullptr;
122 }
123 if (GetAudioManager != nullptr) {
124 GetAudioManager = nullptr;
125 }
126 }
AudioCaptureStart(const string path,struct AudioCapture * capture) const127 int32_t AudioHdiCaptureSceneTest::AudioCaptureStart(const string path, struct AudioCapture *capture) const
128 {
129 int32_t ret = -1;
130 struct AudioSampleAttributes attrs = {};
131
132 ret = InitAttrs(attrs);
133 if (ret < 0) {
134 return ret;
135 }
136 FILE *file = fopen(path.c_str(), "wb+");
137 if (file == nullptr) {
138 return HDF_FAILURE;
139 }
140 ret = FrameStartCapture(capture, file, attrs);
141 (void)fclose(file);
142 return ret;
143 }
SetUp(void)144 void AudioHdiCaptureSceneTest::SetUp(void) {}
TearDown(void)145 void AudioHdiCaptureSceneTest::TearDown(void) {}
146
147 /**
148 * @tc.name Test AudioCaptureCheckSceneCapability API and check scene's capability
149 * @tc.number SUB_Audio_HDI_CaptureCheckSceneCapability_0001
150 * @tc.desc Test AudioCaptureCheckSceneCapability interface,return 0 if check scene's capability successful.
151 */
152 HWTEST_F(AudioHdiCaptureSceneTest, SUB_Audio_HDI_CaptureCheckSceneCapability_0001, Function | MediumTest | Level1)
153 {
154 int32_t ret = -1;
155 bool supported = false;
156 struct AudioSceneDescriptor scenes = {};
157 struct AudioAdapter *adapter = nullptr;
158 struct AudioCapture *capture = nullptr;
159 ASSERT_NE(nullptr, GetAudioManager);
160 TestAudioManager* manager = GetAudioManager();
161 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
162 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
163 scenes.scene.id = 0;
164 scenes.desc.pins = PIN_IN_MIC;
165 ret = capture->scene.CheckSceneCapability(capture, &scenes, &supported);
166 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
167 EXPECT_TRUE(supported);
168
169 adapter->DestroyCapture(adapter, capture);
170 manager->UnloadAdapter(manager, adapter);
171 }
172 /**
173 * @tc.name Test checking scene's capability where the scene is not configured in the json.
174 * @tc.number SUB_Audio_HDI_CaptureCheckSceneCapability_0002
175 * @tc.desc Test AudioCreateCapture interface,return -1 if the scene is not configured in the json.
176 */
177 HWTEST_F(AudioHdiCaptureSceneTest, SUB_Audio_HDI_CaptureCheckSceneCapability_0002, Function | MediumTest | Level1)
178 {
179 int32_t ret = -1;
180 bool supported = true;
181 struct AudioSceneDescriptor scenes = {};
182 struct AudioAdapter *adapter = nullptr;
183 struct AudioCapture *capture = nullptr;
184 ASSERT_NE(nullptr, GetAudioManager);
185 TestAudioManager* manager = GetAudioManager();
186 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
187 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
188 scenes.scene.id = 5;
189 scenes.desc.pins = PIN_IN_MIC;
190 ret = capture->scene.CheckSceneCapability(capture, &scenes, &supported);
191 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
192
193 adapter->DestroyCapture(adapter, capture);
194 manager->UnloadAdapter(manager, adapter);
195 }
196 /**
197 * @tc.name Test checking scene's capability where the capture is empty
198 * @tc.number SUB_Audio_HDI_CaptureCheckSceneCapability_0003
199 * @tc.desc Test AudioCreateCapture interface,return -1 if the capture is empty.
200 */
201 HWTEST_F(AudioHdiCaptureSceneTest, SUB_Audio_HDI_CaptureCheckSceneCapability_0003, Function | MediumTest | Level1)
202 {
203 int32_t ret = -1;
204 bool supported = true;
205 struct AudioSceneDescriptor scenes = {};
206 struct AudioAdapter *adapter = nullptr;
207 struct AudioCapture *capture = nullptr;
208 struct AudioCapture *captureNull = nullptr;
209 ASSERT_NE(nullptr, GetAudioManager);
210 TestAudioManager* manager = GetAudioManager();
211 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
212 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
213 scenes.scene.id = 0;
214 scenes.desc.pins = PIN_IN_MIC;
215 ret = capture->scene.CheckSceneCapability(captureNull, &scenes, &supported);
216 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
217
218 ret = AudioCaptureStart(AUDIO_CAPTURE_FILE, capture);
219 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
220
221 capture->control.Stop((AudioHandle)capture);
222 adapter->DestroyCapture(adapter, capture);
223 manager->UnloadAdapter(manager, adapter);
224 }
225 /**
226 * @tc.name Test checking scene's capability where the scene is empty
227 * @tc.number SUB_Audio_HDI_CaptureCheckSceneCapability_0004
228 * @tc.desc Test AudioCreateCapture interface,return -1 if the scene is empty.
229 */
230 HWTEST_F(AudioHdiCaptureSceneTest, SUB_Audio_HDI_CaptureCheckSceneCapability_0004, Function | MediumTest | Level1)
231 {
232 int32_t ret = -1;
233 bool supported = true;
234 struct AudioSceneDescriptor *scenes = nullptr;
235 struct AudioAdapter *adapter = nullptr;
236 struct AudioCapture *capture = nullptr;
237 ASSERT_NE(nullptr, GetAudioManager);
238 TestAudioManager* manager = GetAudioManager();
239 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
240 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
241
242 ret = capture->scene.CheckSceneCapability(capture, scenes, &supported);
243 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
244
245 ret = AudioCaptureStart(AUDIO_CAPTURE_FILE, capture);
246 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
247
248 capture->control.Stop((AudioHandle)capture);
249 adapter->DestroyCapture(adapter, capture);
250 manager->UnloadAdapter(manager, adapter);
251 }
252 /**
253 * @tc.name Test checking scene's capability where the parameter supported is empty.
254 * @tc.number SUB_Audio_HDI_CaptureCheckSceneCapability_0005
255 * @tc.desc Test AudioCreateCapture interface,return -1 if the parameter supported is empty.
256 */
257 HWTEST_F(AudioHdiCaptureSceneTest, SUB_Audio_HDI_CaptureCheckSceneCapability_0005, Function | MediumTest | Level1)
258 {
259 int32_t ret = -1;
260 struct AudioSceneDescriptor scenes = {};
261 struct AudioAdapter *adapter = nullptr;
262 struct AudioCapture *capture = nullptr;
263 ASSERT_NE(nullptr, GetAudioManager);
264 TestAudioManager* manager = GetAudioManager();
265 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
266 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
267
268 scenes.scene.id = 0;
269 scenes.desc.pins = PIN_IN_MIC;
270 ret = capture->scene.CheckSceneCapability(capture, &scenes, nullptr);
271 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
272
273 adapter->DestroyCapture(adapter, capture);
274 manager->UnloadAdapter(manager, adapter);
275 }
276 /**
277 * @tc.name Test AudioCaptureSelectScene API via legal input
278 * @tc.number SUB_Audio_HDI_AudioCaptureSelectScene_0001
279 * @tc.desc Test AudioCaptureSelectScene interface,return 0 if select capture's scene successful.
280 */
281 HWTEST_F(AudioHdiCaptureSceneTest, SUB_Audio_HDI_AudioCaptureSelectScene_0001, Function | MediumTest | Level1)
282 {
283 int32_t ret = -1;
284 struct AudioSceneDescriptor scenes = {};
285 struct AudioAdapter *adapter = nullptr;
286 struct AudioCapture *capture = nullptr;
287 ASSERT_NE(nullptr, GetAudioManager);
288 TestAudioManager* manager = GetAudioManager();
289 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
290 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
291 scenes.scene.id = 0;
292 scenes.desc.pins = PIN_IN_MIC;
293 ret = capture->scene.SelectScene(capture, &scenes);
294 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
295
296 adapter->DestroyCapture(adapter, capture);
297 manager->UnloadAdapter(manager, adapter);
298 }
299 /**
300 * @tc.name Test AudioCaptureSelectScene API after capture start.
301 * @tc.number SUB_Audio_HDI_AudioCaptureSelectScene_0002
302 * @tc.desc Test AudioCaptureSelectScene, return 0 if select capture's scene successful after capture start.
303 */
304 HWTEST_F(AudioHdiCaptureSceneTest, SUB_Audio_HDI_AudioCaptureSelectScene_0002, Function | MediumTest | Level1)
305 {
306 int32_t ret = -1;
307 struct AudioSceneDescriptor scenes = {};
308 struct AudioAdapter *adapter = nullptr;
309 struct AudioCapture *capture = nullptr;
310 ASSERT_NE(nullptr, GetAudioManager);
311 TestAudioManager* manager = GetAudioManager();
312 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
313 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
314
315 ret = AudioCaptureStart(AUDIO_CAPTURE_FILE, capture);
316 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
317
318 scenes.scene.id = 0;
319 scenes.desc.pins = PIN_IN_MIC;
320 ret = capture->scene.SelectScene(capture, &scenes);
321 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
322
323 capture->control.Stop((AudioHandle)capture);
324 adapter->DestroyCapture(adapter, capture);
325 manager->UnloadAdapter(manager, adapter);
326 }
327 /**
328 * @tc.name Test AudioCaptureSelectScene API where the parameter handle is empty.
329 * @tc.number SUB_Audio_HDI_AudioCaptureSelectScene_0003
330 * @tc.desc Test AudioCaptureSelectScene, return -1 if the parameter handle is empty.
331 */
332 HWTEST_F(AudioHdiCaptureSceneTest, SUB_Audio_HDI_AudioCaptureSelectScene_0003, Function | MediumTest | Level1)
333 {
334 int32_t ret = -1;
335 struct AudioSceneDescriptor scenes = {};
336 struct AudioAdapter *adapter = nullptr;
337 struct AudioCapture *capture = nullptr;
338 struct AudioCapture *captureNull = nullptr;
339 ASSERT_NE(nullptr, GetAudioManager);
340 TestAudioManager* manager = GetAudioManager();
341 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
342 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
343
344 scenes.scene.id = 0;
345 scenes.desc.pins = PIN_IN_MIC;
346 ret = capture->scene.SelectScene(captureNull, &scenes);
347 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
348
349 adapter->DestroyCapture(adapter, capture);
350 manager->UnloadAdapter(manager, adapter);
351 }
352 /**
353 * @tc.name Test AudioCaptureSelectScene API where the parameter scene is empty.
354 * @tc.number SUB_Audio_HDI_AudioCaptureSelectScene_0004
355 * @tc.desc Test AudioCaptureSelectScene, return -1 if the parameter scene is empty.
356 */
357 HWTEST_F(AudioHdiCaptureSceneTest, SUB_Audio_HDI_AudioCaptureSelectScene_0004, Function | MediumTest | Level1)
358 {
359 int32_t ret = -1;
360 struct AudioSceneDescriptor *scenes = nullptr;
361 struct AudioAdapter *adapter = nullptr;
362 struct AudioCapture *capture = nullptr;
363 ASSERT_NE(nullptr, GetAudioManager);
364 TestAudioManager* manager = GetAudioManager();
365 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
366 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
367
368 ret = capture->scene.SelectScene(capture, scenes);
369 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
370
371 adapter->DestroyCapture(adapter, capture);
372 manager->UnloadAdapter(manager, adapter);
373 }
374 /**
375 * @tc.name Test AudioCaptureSelectScene API where the scene is not configured in the json.
376 * @tc.number SUB_Audio_HDI_AudioCaptureSelectScene_0005
377 * @tc.desc Test AudioCaptureSelectScene, return -1 if the scene is not configured in the json.
378 */
379 HWTEST_F(AudioHdiCaptureSceneTest, SUB_Audio_HDI_AudioCaptureSelectScene_0005, Function | MediumTest | Level1)
380 {
381 int32_t ret = -1;
382 struct AudioSceneDescriptor scenes = {};
383 struct AudioAdapter *adapter = nullptr;
384 struct AudioCapture *capture = nullptr;
385 ASSERT_NE(nullptr, GetAudioManager);
386 TestAudioManager* manager = GetAudioManager();
387 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME_INTERNAL, &adapter, &capture);
388 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
389
390 scenes.scene.id = 5;
391 scenes.desc.pins = PIN_OUT_HDMI;
392 ret = capture->scene.SelectScene(capture, &scenes);
393 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
394
395 adapter->DestroyCapture(adapter, capture);
396 manager->UnloadAdapter(manager, adapter);
397 }
398 }