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 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 OHOS::Audio;
42
43 namespace {
44 class AudioHdiCaptureSceneTest : public testing::Test {
45 public:
46 static void SetUpTestCase(void);
47 static void TearDownTestCase(void);
48 void SetUp();
49 void TearDown();
50 int32_t AudioCaptureStart(const string path, struct AudioCapture *capture) const;
51 };
52
SetUpTestCase(void)53 void AudioHdiCaptureSceneTest::SetUpTestCase(void) {}
54
TearDownTestCase(void)55 void AudioHdiCaptureSceneTest::TearDownTestCase(void) {}
AudioCaptureStart(const string path,struct AudioCapture * capture) const56 int32_t AudioHdiCaptureSceneTest::AudioCaptureStart(const string path, struct AudioCapture *capture) const
57 {
58 int32_t ret = -1;
59 struct AudioSampleAttributes attrs = {};
60
61 ret = InitAttrs(attrs);
62 if (ret < 0) {
63 return ret;
64 }
65 FILE *file = fopen(path.c_str(), "wb+");
66 if (file == nullptr) {
67 return HDF_FAILURE;
68 }
69 ret = FrameStartCapture(capture, file, attrs);
70 (void)fclose(file);
71 return ret;
72 }
SetUp(void)73 void AudioHdiCaptureSceneTest::SetUp(void) {}
TearDown(void)74 void AudioHdiCaptureSceneTest::TearDown(void) {}
75
76 /**
77 * @tc.name Test AudioCaptureCheckSceneCapability API and check scene's capability
78 * @tc.number SUB_Audio_HDI_CaptureCheckSceneCapability_0001
79 * @tc.desc Test AudioCaptureCheckSceneCapability interface,return 0 if check scene's capability successful.
80 */
81 HWTEST_F(AudioHdiCaptureSceneTest, SUB_Audio_HDI_CaptureCheckSceneCapability_0001, Function | MediumTest | Level1)
82 {
83 int32_t ret = -1;
84 bool supported = false;
85 struct AudioSceneDescriptor scenes = {};
86 struct AudioAdapter *adapter = nullptr;
87 struct AudioCapture *capture = nullptr;
88
89 TestAudioManager* manager = GetAudioManagerFuncs();
90 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
91 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
92 scenes.scene.id = 0;
93 scenes.desc.pins = PIN_IN_MIC;
94 ret = capture->scene.CheckSceneCapability(capture, &scenes, &supported);
95 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
96 EXPECT_TRUE(supported);
97
98 adapter->DestroyCapture(adapter, capture);
99 manager->UnloadAdapter(manager, adapter);
100 }
101 /**
102 * @tc.name Test checking scene's capability where the scene is not configured in the json.
103 * @tc.number SUB_Audio_HDI_CaptureCheckSceneCapability_0002
104 * @tc.desc Test AudioCreateCapture interface,return -1 if the scene is not configured in the json.
105 */
106 HWTEST_F(AudioHdiCaptureSceneTest, SUB_Audio_HDI_CaptureCheckSceneCapability_0002, Function | MediumTest | Level1)
107 {
108 int32_t ret = -1;
109 bool supported = true;
110 struct AudioSceneDescriptor scenes = {};
111 struct AudioAdapter *adapter = nullptr;
112 struct AudioCapture *capture = nullptr;
113
114 TestAudioManager* manager = GetAudioManagerFuncs();
115 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
116 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
117 scenes.scene.id = 5;
118 scenes.desc.pins = PIN_IN_MIC;
119 ret = capture->scene.CheckSceneCapability(capture, &scenes, &supported);
120 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
121
122 adapter->DestroyCapture(adapter, capture);
123 manager->UnloadAdapter(manager, adapter);
124 }
125 /**
126 * @tc.name Test checking scene's capability where the capture is empty
127 * @tc.number SUB_Audio_HDI_CaptureCheckSceneCapability_0003
128 * @tc.desc Test AudioCreateCapture interface,return -1 if the capture is empty.
129 */
130 HWTEST_F(AudioHdiCaptureSceneTest, SUB_Audio_HDI_CaptureCheckSceneCapability_0003, Function | MediumTest | Level1)
131 {
132 int32_t ret = -1;
133 bool supported = true;
134 struct AudioSceneDescriptor scenes = {};
135 struct AudioAdapter *adapter = nullptr;
136 struct AudioCapture *capture = nullptr;
137 struct AudioCapture *captureNull = nullptr;
138
139 TestAudioManager* manager = GetAudioManagerFuncs();
140 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
141 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
142 scenes.scene.id = 0;
143 scenes.desc.pins = PIN_IN_MIC;
144 ret = capture->scene.CheckSceneCapability(captureNull, &scenes, &supported);
145 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
146
147 ret = AudioCaptureStart(AUDIO_CAPTURE_FILE, capture);
148 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
149
150 capture->control.Stop((AudioHandle)capture);
151 adapter->DestroyCapture(adapter, capture);
152 manager->UnloadAdapter(manager, adapter);
153 }
154 /**
155 * @tc.name Test checking scene's capability where the scene is empty
156 * @tc.number SUB_Audio_HDI_CaptureCheckSceneCapability_0004
157 * @tc.desc Test AudioCreateCapture interface,return -1 if the scene is empty.
158 */
159 HWTEST_F(AudioHdiCaptureSceneTest, SUB_Audio_HDI_CaptureCheckSceneCapability_0004, Function | MediumTest | Level1)
160 {
161 int32_t ret = -1;
162 bool supported = true;
163 struct AudioSceneDescriptor *scenes = nullptr;
164 struct AudioAdapter *adapter = nullptr;
165 struct AudioCapture *capture = nullptr;
166
167 TestAudioManager* manager = GetAudioManagerFuncs();
168 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
169 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
170
171 ret = capture->scene.CheckSceneCapability(capture, scenes, &supported);
172 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
173
174 ret = AudioCaptureStart(AUDIO_CAPTURE_FILE, capture);
175 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
176
177 capture->control.Stop((AudioHandle)capture);
178 adapter->DestroyCapture(adapter, capture);
179 manager->UnloadAdapter(manager, adapter);
180 }
181 /**
182 * @tc.name Test checking scene's capability where the parameter supported is empty.
183 * @tc.number SUB_Audio_HDI_CaptureCheckSceneCapability_0005
184 * @tc.desc Test AudioCreateCapture interface,return -1 if the parameter supported is empty.
185 */
186 HWTEST_F(AudioHdiCaptureSceneTest, SUB_Audio_HDI_CaptureCheckSceneCapability_0005, Function | MediumTest | Level1)
187 {
188 int32_t ret = -1;
189 struct AudioSceneDescriptor scenes = {};
190 struct AudioAdapter *adapter = nullptr;
191 struct AudioCapture *capture = nullptr;
192
193 TestAudioManager* manager = GetAudioManagerFuncs();
194 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
195 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
196
197 scenes.scene.id = 0;
198 scenes.desc.pins = PIN_IN_MIC;
199 ret = capture->scene.CheckSceneCapability(capture, &scenes, nullptr);
200 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
201
202 adapter->DestroyCapture(adapter, capture);
203 manager->UnloadAdapter(manager, adapter);
204 }
205 /**
206 * @tc.name Test AudioCaptureSelectScene API via legal input
207 * @tc.number SUB_Audio_HDI_AudioCaptureSelectScene_0001
208 * @tc.desc Test AudioCaptureSelectScene interface,return 0 if select capture's scene successful.
209 */
210 HWTEST_F(AudioHdiCaptureSceneTest, SUB_Audio_HDI_AudioCaptureSelectScene_0001, Function | MediumTest | Level1)
211 {
212 int32_t ret = -1;
213 struct AudioSceneDescriptor scenes = {};
214 struct AudioAdapter *adapter = nullptr;
215 struct AudioCapture *capture = nullptr;
216
217 TestAudioManager* manager = GetAudioManagerFuncs();
218 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
219 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
220 scenes.scene.id = 0;
221 scenes.desc.pins = PIN_IN_MIC;
222 ret = capture->scene.SelectScene(capture, &scenes);
223 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
224
225 adapter->DestroyCapture(adapter, capture);
226 manager->UnloadAdapter(manager, adapter);
227 }
228 /**
229 * @tc.name Test AudioCaptureSelectScene API after capture start.
230 * @tc.number SUB_Audio_HDI_AudioCaptureSelectScene_0002
231 * @tc.desc Test AudioCaptureSelectScene, return 0 if select capture's scene successful after capture start.
232 */
233 HWTEST_F(AudioHdiCaptureSceneTest, SUB_Audio_HDI_AudioCaptureSelectScene_0002, Function | MediumTest | Level1)
234 {
235 int32_t ret = -1;
236 struct AudioSceneDescriptor scenes = {};
237 struct AudioAdapter *adapter = nullptr;
238 struct AudioCapture *capture = nullptr;
239
240 TestAudioManager* manager = GetAudioManagerFuncs();
241 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
242 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
243
244 ret = AudioCaptureStart(AUDIO_CAPTURE_FILE, capture);
245 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
246
247 scenes.scene.id = 0;
248 scenes.desc.pins = PIN_IN_MIC;
249 ret = capture->scene.SelectScene(capture, &scenes);
250 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
251
252 capture->control.Stop((AudioHandle)capture);
253 adapter->DestroyCapture(adapter, capture);
254 manager->UnloadAdapter(manager, adapter);
255 }
256 /**
257 * @tc.name Test AudioCaptureSelectScene API where the parameter handle is empty.
258 * @tc.number SUB_Audio_HDI_AudioCaptureSelectScene_0003
259 * @tc.desc Test AudioCaptureSelectScene, return -1 if the parameter handle is empty.
260 */
261 HWTEST_F(AudioHdiCaptureSceneTest, SUB_Audio_HDI_AudioCaptureSelectScene_0003, Function | MediumTest | Level1)
262 {
263 int32_t ret = -1;
264 struct AudioSceneDescriptor scenes = {};
265 struct AudioAdapter *adapter = nullptr;
266 struct AudioCapture *capture = nullptr;
267 struct AudioCapture *captureNull = nullptr;
268
269 TestAudioManager* manager = GetAudioManagerFuncs();
270 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
271 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
272
273 scenes.scene.id = 0;
274 scenes.desc.pins = PIN_IN_MIC;
275 ret = capture->scene.SelectScene(captureNull, &scenes);
276 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
277
278 adapter->DestroyCapture(adapter, capture);
279 manager->UnloadAdapter(manager, adapter);
280 }
281 /**
282 * @tc.name Test AudioCaptureSelectScene API where the parameter scene is empty.
283 * @tc.number SUB_Audio_HDI_AudioCaptureSelectScene_0004
284 * @tc.desc Test AudioCaptureSelectScene, return -1 if the parameter scene is empty.
285 */
286 HWTEST_F(AudioHdiCaptureSceneTest, SUB_Audio_HDI_AudioCaptureSelectScene_0004, Function | MediumTest | Level1)
287 {
288 int32_t ret = -1;
289 struct AudioSceneDescriptor *scenes = nullptr;
290 struct AudioAdapter *adapter = nullptr;
291 struct AudioCapture *capture = nullptr;
292
293 TestAudioManager* manager = GetAudioManagerFuncs();
294 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
295 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
296
297 ret = capture->scene.SelectScene(capture, scenes);
298 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
299
300 adapter->DestroyCapture(adapter, capture);
301 manager->UnloadAdapter(manager, adapter);
302 }
303 /**
304 * @tc.name Test AudioCaptureSelectScene API where the scene is not configured in the json.
305 * @tc.number SUB_Audio_HDI_AudioCaptureSelectScene_0005
306 * @tc.desc Test AudioCaptureSelectScene, return -1 if the scene is not configured in the json.
307 */
308 HWTEST_F(AudioHdiCaptureSceneTest, SUB_Audio_HDI_AudioCaptureSelectScene_0005, Function | MediumTest | Level1)
309 {
310 int32_t ret = -1;
311 struct AudioSceneDescriptor scenes = {};
312 struct AudioAdapter *adapter = nullptr;
313 struct AudioCapture *capture = nullptr;
314
315 TestAudioManager* manager = GetAudioManagerFuncs();
316 ret = AudioCreateCapture(manager, PIN_IN_MIC, ADAPTER_NAME, &adapter, &capture);
317 ASSERT_EQ(AUDIO_HAL_SUCCESS, ret);
318
319 scenes.scene.id = 5;
320 scenes.desc.pins = PIN_OUT_HDMI;
321 ret = capture->scene.SelectScene(capture, &scenes);
322 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
323
324 adapter->DestroyCapture(adapter, capture);
325 manager->UnloadAdapter(manager, adapter);
326 }
327 }
328