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 expected 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 #include "camera_3a_test.h"
17
18 constexpr int ITEM_CAPACITY_SIZE = 100;
19 constexpr int DATA_CAPACITY_SIZE = 2000;
20
SetUpTestCase(void)21 void UtestCamera3ATest::SetUpTestCase(void)
22 {}
TearDownTestCase(void)23 void UtestCamera3ATest::TearDownTestCase(void)
24 {}
SetUp(void)25 void UtestCamera3ATest::SetUp(void)
26 {
27 if (display_ == nullptr)
28 display_ = std::make_shared<TestDisplay>();
29 display_->FBInit();
30 display_->Init();
31 }
TearDown(void)32 void UtestCamera3ATest::TearDown(void)
33 {
34 display_->Close();
35 }
36
37 /**
38 * @tc.name: updateSettings AE
39 * @tc.desc: Preview，updateSettings OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, success.
40 * @tc.level: Level0
41 * @tc.size: MediumTest
42 * @tc.type: Function
43 */
TEST_F(UtestCamera3ATest,camera_3a_0001)44 TEST_F(UtestCamera3ATest, camera_3a_0001)
45 {
46 std::cout << "==========[test log] Preview，";
47 std::cout << "then UpdateSettings OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, success." << std::endl;
48 EXPECT_EQ(true, display_->cameraDevice != nullptr);
49 // Get the stream manager
50 display_->AchieveStreamOperator();
51 // Configure preview stream information
52 display_->intents = {PREVIEW};
53 display_->StartStream(display_->intents);
54 // Start capture
55 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
56 // Issue 3A parameters
57 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY_SIZE, DATA_CAPACITY_SIZE);
58 int32_t expo = 0xa0;
59 meta->addEntry(OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, &expo, 1);
60 display_->cameraDevice->UpdateSettings(meta);
61 std::cout << "==========[test log] UpdateSettings, exposure for 10s." << std::endl;
62 sleep(10); // update settings, exposure for 10s
63
64 // Post action of stream operation
65 display_->captureIds = {display_->CAPTURE_ID_PREVIEW};
66 display_->streamIds = {display_->STREAM_ID_PREVIEW};
67 display_->StopStream(display_->captureIds, display_->streamIds);
68 }
69
70 /**
71 * @tc.name: updateSettings AWB
72 * @tc.desc: Preview，updateSettings OHOS_CAMERA_AWB_MODE-OHOS_CAMERA_AWB_MODE_AUTO, success.
73 * @tc.level: Level1
74 * @tc.size: MediumTest
75 * @tc.type: Function
76 */
TEST_F(UtestCamera3ATest,camera_3a_0002)77 TEST_F(UtestCamera3ATest, camera_3a_0002)
78 {
79 std::cout << "==========[test log] Preview，";
80 std::cout << "updateSettings OHOS_CAMERA_AWB_MODE-OHOS_CAMERA_AWB_MODE_AUTO, success." << std::endl;
81 EXPECT_EQ(true, display_->cameraDevice != nullptr);
82 // Get the stream manager
83 display_->AchieveStreamOperator();
84 // Configure stream information
85 // start stream
86 display_->intents = {PREVIEW, STILL_CAPTURE};
87 display_->StartStream(display_->intents);
88 // Get preview
89 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
90 display_->StartCapture(display_->STREAM_ID_CAPTURE, display_->CAPTURE_ID_CAPTURE, false, true);
91
92 // Issue 3A parameters
93 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY_SIZE, DATA_CAPACITY_SIZE);
94 uint8_t awbMode = OHOS_CAMERA_AWB_MODE_AUTO;
95 meta->addEntry(OHOS_CONTROL_AWB_MODE, &awbMode, 1);
96 std::cout << "==========[test log] UpdateSettings, awb mode: OHOS_CAMERA_AWB_MODE_AUTO." << std::endl;
97 display_->cameraDevice->UpdateSettings(meta);
98 sleep(2); // update settings, AWB mode auto for 2s.
99
100 // release stream
101 display_->captureIds = {display_->CAPTURE_ID_PREVIEW, display_->CAPTURE_ID_CAPTURE};
102 display_->streamIds = {display_->STREAM_ID_PREVIEW, display_->STREAM_ID_CAPTURE};
103 display_->StopStream(display_->captureIds, display_->streamIds);
104 }
105
106 /**
107 * @tc.name: updateSettings AWB
108 * @tc.desc: Preview，updateSettings OHOS_CAMERA_AWB_MODE-OHOS_CAMERA_AWB_MODE_INCANDESCENT, success.
109 * @tc.level: Level1
110 * @tc.size: MediumTest
111 * @tc.type: Function
112 */
TEST_F(UtestCamera3ATest,camera_3a_0003)113 TEST_F(UtestCamera3ATest, camera_3a_0003)
114 {
115 std::cout << "==========[test log] Preview，";
116 std::cout << "updateSettings OHOS_CAMERA_AWB_MODE-OHOS_CAMERA_AWB_MODE_INCANDESCENT, success." << std::endl;
117 // Create and get streamOperator information
118 display_->AchieveStreamOperator();
119 // start stream
120 display_->intents = {PREVIEW};
121 display_->StartStream(display_->intents);
122 // Start capture
123 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
124
125 // Issue 3A parameters
126 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY_SIZE, DATA_CAPACITY_SIZE);
127 uint8_t awbMode = OHOS_CAMERA_AWB_MODE_INCANDESCENT;
128 meta->addEntry(OHOS_CONTROL_AWB_MODE, &awbMode, 1);
129 std::cout << "==========[test log] UpdateSettings,";
130 std::cout << "awb mode: OHOS_CAMERA_AWB_MODE_INCANDESCENT" << std::endl;
131 display_->cameraDevice->UpdateSettings(meta);
132
133 // Post action of stream operation
134 display_->captureIds = {display_->CAPTURE_ID_PREVIEW};
135 display_->streamIds = {display_->STREAM_ID_PREVIEW};
136 display_->StopStream(display_->captureIds, display_->streamIds);
137 }
138
139 /**
140 * @tc.name: updateSettings AWB
141 * @tc.desc: Preview，updateSettings OHOS_CAMERA_AWB_MODE-OHOS_CAMERA_AWB_MODE_FLUORESCENT, success.
142 * @tc.level: Level1
143 * @tc.size: MediumTest
144 * @tc.type: Function
145 */
TEST_F(UtestCamera3ATest,camera_3a_0004)146 TEST_F(UtestCamera3ATest, camera_3a_0004) // 3A mode white balance blue scene
147 {
148 std::cout << "==========[test log] Preview，";
149 std::cout << "updateSettings OHOS_CAMERA_AWB_MODE-OHOS_CAMERA_AWB_MODE_FLUORESCENT, success." << std::endl;
150 EXPECT_EQ(true, display_->cameraDevice != nullptr);
151 // Get the stream manager
152 display_->AchieveStreamOperator();
153 // Configure stream information
154 display_->intents = {PREVIEW, STILL_CAPTURE};
155 display_->StartStream(display_->intents);
156 // Get preview
157 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
158 display_->StartCapture(display_->STREAM_ID_CAPTURE, display_->CAPTURE_ID_CAPTURE, false, true);
159
160 // Issue 3A parameters
161 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY_SIZE, DATA_CAPACITY_SIZE);
162 uint8_t awbMode = AWB_MODE_WARM_FLUORESCENT;
163 meta->addEntry(OHOS_CONTROL_AWB_MODE, &awbMode, 1);
164 std::cout << "==========[test log] UpdateSettings, awb mode: OHOS_CAMERA_AWB_MODE_AUTO." << std::endl;
165 display_->cameraDevice->UpdateSettings(meta);
166 sleep(2); // update settings, AWB mode auto for 2s.
167
168 // release stream
169 display_->captureIds = {display_->CAPTURE_ID_PREVIEW, display_->CAPTURE_ID_CAPTURE};
170 display_->streamIds = {display_->STREAM_ID_PREVIEW, display_->STREAM_ID_CAPTURE};
171 display_->StopStream(display_->captureIds, display_->streamIds);
172 }
173
174 /**
175 * @tc.name: updateSettings AWB
176 * @tc.desc: Preview，updateSettings OHOS_CAMERA_AWB_MODE-OHOS_CAMERA_AWB_MODE_WARM_FLUORESCENT, success.
177 * @tc.level: Level1
178 * @tc.size: MediumTest
179 * @tc.type: Function
180 */
TEST_F(UtestCamera3ATest,camera_3a_0005)181 TEST_F(UtestCamera3ATest, camera_3a_0005)
182 {
183 std::cout << "==========[test log] Preview，";
184 std::cout << "updateSettings OHOS_CAMERA_AWB_MODE-OHOS_CAMERA_AWB_MODE_WARM_FLUORESCENT, ";
185 std::cout << "success." << std::endl;
186 // Create and get streamOperator information
187 display_->AchieveStreamOperator();
188 // Create data stream
189 display_->intents = {PREVIEW};
190 display_->StartStream(display_->intents);
191 // Start capture
192 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
193
194 // Issue 3A parameters
195 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY_SIZE, DATA_CAPACITY_SIZE);
196 uint8_t awbMode = OHOS_CAMERA_AWB_MODE_WARM_FLUORESCENT;
197 meta->addEntry(OHOS_CONTROL_AWB_MODE, &awbMode, 1);
198 std::cout << "==========[test log] UpdateSettings, ";
199 std::cout << "awb mode: OHOS_CAMERA_AWB_MODE_WARM_FLUORESCENT" << std::endl;
200 display_->cameraDevice->UpdateSettings(meta);
201
202 // Post action of stream operation
203 display_->captureIds = {display_->CAPTURE_ID_PREVIEW};
204 display_->streamIds = {display_->STREAM_ID_PREVIEW};
205 display_->StopStream(display_->captureIds, display_->streamIds);
206 }
207
208 /**
209 * @tc.name: updateSettings AWB
210 * @tc.desc: Preview，updateSettings OHOS_CAMERA_AWB_MODE-OHOS_CAMERA_AWB_MODE_DAYLIGHT, success.
211 * @tc.level: Level1
212 * @tc.size: MediumTest
213 * @tc.type: Function
214 */
TEST_F(UtestCamera3ATest,camera_3a_0006)215 TEST_F(UtestCamera3ATest, camera_3a_0006)
216 {
217 std::cout << "==========[test log] Preview, ";
218 std::cout << "updateSettings OHOS_CAMERA_AWB_MODE-OHOS_CAMERA_AWB_MODE_DAYLIGHT, success." << std::endl;
219 // Create and get streamOperator information
220 display_->AchieveStreamOperator();
221 // Create data stream
222 display_->intents = {PREVIEW};
223 display_->StartStream(display_->intents);
224 // Start capture
225 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
226
227 // Issue 3A parameters
228 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY_SIZE, DATA_CAPACITY_SIZE);
229 uint8_t awbMode = OHOS_CAMERA_AWB_MODE_DAYLIGHT;
230 meta->addEntry(OHOS_CONTROL_AWB_MODE, &awbMode, 1);
231 std::cout << "==========[test log] UpdateSettings, awb mode: OHOS_CAMERA_AWB_MODE_DAYLIGHT" << std::endl;
232 display_->cameraDevice->UpdateSettings(meta);
233 sleep(5); // update settings, AWB mode daylight for 5s.
234
235 // Post action of stream operation
236 display_->captureIds = {display_->CAPTURE_ID_PREVIEW};
237 display_->streamIds = {display_->STREAM_ID_PREVIEW};
238 display_->StopStream(display_->captureIds, display_->streamIds);
239 }
240
241 /**
242 * @tc.name: updateSettings AWB
243 * @tc.desc: Preview，updateSettings OHOS_CAMERA_AWB_MODE-OHOS_CAMERA_AWB_MODE_CLOUDY_DAYLIGHT, success.
244 * @tc.level: Level1
245 * @tc.size: MediumTest
246 * @tc.type: Function
247 */
TEST_F(UtestCamera3ATest,camera_3a_0007)248 TEST_F(UtestCamera3ATest, camera_3a_0007) // 3A mode reset
249 {
250 std::cout << "==========[test log] Preview，";
251 std::cout << "updateSettings OHOS_CAMERA_AWB_MODE-OHOS_CAMERA_AWB_MODE_CLOUDY_DAYLIGHT,";
252 std::cout << "success." << std::endl;
253 // Create and get streamOperator information
254 display_->AchieveStreamOperator();
255 // Create data stream
256 display_->intents = {PREVIEW};
257 display_->StartStream(display_->intents);
258 // Start capture
259 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
260
261 // Issue 3A parameters
262 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY_SIZE, DATA_CAPACITY_SIZE);
263 uint8_t awbMode = OHOS_CAMERA_AWB_MODE_CLOUDY_DAYLIGHT;
264 meta->addEntry(OHOS_CONTROL_AWB_MODE, &awbMode, 1);
265 std::cout << "==========[test log] UpdateSettings, ";
266 std::cout << "awb mode: OHOS_CAMERA_AWB_MODE_CLOUDY_DAYLIGHT" << std::endl;
267 display_->cameraDevice->UpdateSettings(meta);
268
269 // Post action of stream operation
270 display_->captureIds = {display_->CAPTURE_ID_PREVIEW};
271 display_->streamIds = {display_->STREAM_ID_PREVIEW};
272 display_->StopStream(display_->captureIds, display_->streamIds);
273 }
274
275 /**
276 * @tc.name: updateSettings AWB
277 * @tc.desc: Preview，updateSettings OHOS_CAMERA_AWB_MODE-OHOS_CAMERA_AWB_MODE_WARM_FLUORESCENT, success.
278 * @tc.level: Level1
279 * @tc.size: MediumTest
280 * @tc.type: Function
281 */
TEST_F(UtestCamera3ATest,camera_3a_0008)282 TEST_F(UtestCamera3ATest, camera_3a_0008)
283 {
284 std::cout << "==========[test log] Preview，";
285 std::cout << "updateSettings OHOS_CAMERA_AWB_MODE-OHOS_CAMERA_AWB_MODE_TWILIGHT, ";
286 std::cout << "success." << std::endl;
287 EXPECT_EQ(true, display_->cameraDevice != nullptr);
288 // Get the stream manager
289 display_->AchieveStreamOperator();
290 // Configure stream information
291 // start stream
292 display_->intents = {PREVIEW, STILL_CAPTURE};
293 display_->StartStream(display_->intents);
294 // Get preview
295 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
296 display_->StartCapture(display_->STREAM_ID_CAPTURE, display_->CAPTURE_ID_CAPTURE, false, true);
297
298 // Issue 3A parameters
299 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY_SIZE, DATA_CAPACITY_SIZE);
300 uint8_t awbMode = OHOS_CAMERA_AWB_MODE_TWILIGHT;
301 meta->addEntry(OHOS_CONTROL_AWB_MODE, &awbMode, 1);
302 std::cout << "==========[test log] UpdateSettings, awb mode: OHOS_CAMERA_AWB_MODE_TWILIGHT" << std::endl;
303 display_->cameraDevice->UpdateSettings(meta);
304
305 // release stream
306 display_->captureIds = {display_->CAPTURE_ID_PREVIEW, display_->CAPTURE_ID_CAPTURE};
307 display_->streamIds = {display_->STREAM_ID_PREVIEW, display_->STREAM_ID_CAPTURE};
308 display_->StopStream(display_->captureIds, display_->streamIds);
309 }
310
311 /**
312 * @tc.name: updateSettings AWB
313 * @tc.desc: Preview，updateSettings OHOS_CAMERA_AWB_MODE-OHOS_CAMERA_AWB_MODE_WARM_FLUORESCENT, success.
314 * @tc.level: Level1
315 * @tc.size: MediumTest
316 * @tc.type: Function
317 */
TEST_F(UtestCamera3ATest,camera_3a_0009)318 TEST_F(UtestCamera3ATest, camera_3a_0009) // 3A mode white balance yellow scene
319 {
320 std::cout << "==========[test log] Preview，";
321 std::cout << "updateSettings OHOS_CAMERA_AWB_MODE-OHOS_CAMERA_AWB_MODE_SHADE, success." << std::endl;
322 // Create and get streamOperator information
323 display_->AchieveStreamOperator();
324 // Create data stream
325 display_->intents = {PREVIEW};
326 display_->StartStream(display_->intents);
327 // Start capture
328 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
329
330 // Issue 3A parameters
331 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY_SIZE, DATA_CAPACITY_SIZE);
332 uint8_t awbMode = OHOS_CAMERA_AWB_MODE_SHADE;
333 meta->addEntry(OHOS_CONTROL_AWB_MODE, &awbMode, 1);
334 std::cout << "==========[test log] UpdateSettings, awb mode: OHOS_CAMERA_AWB_MODE_SHADE" << std::endl;
335 display_->cameraDevice->UpdateSettings(meta);
336
337 // Post action of stream operation
338 display_->captureIds = {display_->CAPTURE_ID_PREVIEW};
339 display_->streamIds = {display_->STREAM_ID_PREVIEW};
340 display_->StopStream(display_->captureIds, display_->streamIds);
341 }
342
343 /**
344 * @tc.name: updateSettings AWB
345 * @tc.desc: Preview，updateSettings OHOS_CAMERA_AWB_MODE-OHOS_CAMERA_AWB_MODE_OFF, success.
346 * @tc.level: Level1
347 * @tc.size: MediumTest
348 * @tc.type: Function
349 */
TEST_F(UtestCamera3ATest,camera_3a_0010)350 TEST_F(UtestCamera3ATest, camera_3a_0010)
351 {
352 std::cout << "==========[test log] Preview，";
353 std::cout << "updateSettings OHOS_CAMERA_AWB_MODE-OHOS_CAMERA_AWB_MODE_OFF, success." << std::endl;
354 EXPECT_EQ(true, display_->cameraDevice != nullptr);
355 // Get the stream manager
356 display_->AchieveStreamOperator();
357 // start stream
358 display_->intents = {PREVIEW, STILL_CAPTURE};
359 display_->StartStream(display_->intents);
360 // Get preview
361 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
362 display_->StartCapture(display_->STREAM_ID_CAPTURE, display_->CAPTURE_ID_CAPTURE, false, true);
363
364 // Issue 3A parameters
365 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY_SIZE, DATA_CAPACITY_SIZE);
366 uint8_t awbMode = OHOS_CAMERA_AWB_MODE_OFF;
367 meta->addEntry(OHOS_CONTROL_AWB_MODE, &awbMode, 1);
368 std::cout << "==========[test log] UpdateSettings, awb mode: OHOS_CAMERA_AWB_MODE_OFF" << std::endl;
369 display_->cameraDevice->UpdateSettings(meta);
370
371 // release stream
372 display_->captureIds = {display_->CAPTURE_ID_PREVIEW, display_->CAPTURE_ID_CAPTURE};
373 display_->streamIds = {display_->STREAM_ID_PREVIEW, display_->STREAM_ID_CAPTURE};
374 display_->StopStream(display_->captureIds, display_->streamIds);
375 }
376
377 /**
378 * @tc.name: updateSettings reset
379 * @tc.desc: Preview set 3A, then close device, and preview, 3A is reset.
380 * @tc.level: Level1
381 * @tc.size: MediumTest
382 * @tc.type: Function
383 */
TEST_F(UtestCamera3ATest,camera_3a_0030)384 TEST_F(UtestCamera3ATest, camera_3a_0030)
385 {
386 std::cout << "==========[test log] Preview set 3A, then close device, and preview, 3A is reset." << std::endl;
387 std::cout << "==========[test log] The 1st time set 3A." << std::endl;
388 // Create and get streamOperator information
389 display_->AchieveStreamOperator();
390 // Create data stream
391 display_->intents = {PREVIEW};
392 display_->StartStream(display_->intents);
393 // Start capture
394 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
395 // Issue 3A parameters
396 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY_SIZE, DATA_CAPACITY_SIZE);
397 int32_t expo = 0xa0;
398 meta->addEntry(OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, &expo, 1);
399 display_->cameraDevice->UpdateSettings(meta);
400 std::cout << "==========[test log] UpdateSettings, exposure for 3s." << std::endl;
401 sleep(3); // update settings, exposure for 3s
402 // Post action of stream operation
403 display_->captureIds = {display_->CAPTURE_ID_PREVIEW};
404 display_->streamIds = {display_->STREAM_ID_PREVIEW};
405 display_->StopStream(display_->captureIds, display_->streamIds);
406
407 // Turn off the device
408 display_->Close();
409 std::cout << "cameraDevice->Close" << std::endl;
410 std::cout << "==========[test log] Close device, and preview, 3A is reset." << std::endl;
411 display_->Init();
412 // Get the stream manager
413 display_->AchieveStreamOperator();
414 // start stream
415 display_->intents = {PREVIEW};
416 display_->StartStream(display_->intents);
417 // Get preview
418 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
419 // release stream
420 display_->captureIds = {display_->CAPTURE_ID_PREVIEW};
421 display_->streamIds = {display_->STREAM_ID_PREVIEW};
422 display_->StopStream(display_->captureIds, display_->streamIds);
423 }
424
425 /**
426 * @tc.name: updateSettings different 3A params
427 * @tc.desc: Preview, updatesetting different 3A params together.
428 * @tc.level: Level1
429 * @tc.size: MediumTest
430 * @tc.type: Function
431 */
TEST_F(UtestCamera3ATest,camera_3a_0031)432 TEST_F(UtestCamera3ATest, camera_3a_0031) // 3A mode white balance green scene
433 {
434 std::cout << "==========[test log] Preview, updatesetting different 3A params together." << std::endl;
435 EXPECT_EQ(true, display_->cameraDevice != nullptr);
436 // Get the stream manager
437 display_->AchieveStreamOperator();
438 // start stream
439 display_->intents = {PREVIEW, STILL_CAPTURE};
440 display_->StartStream(display_->intents);
441 // Get preview
442 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
443 display_->StartCapture(display_->STREAM_ID_CAPTURE, display_->CAPTURE_ID_CAPTURE, false, true);
444 // Issue 3A parameters
445 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY_SIZE, DATA_CAPACITY_SIZE);
446 int32_t expo = 0xa0;
447 meta->addEntry(OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, &expo, 1);
448 uint8_t awbMode = OHOS_CAMERA_AWB_MODE_TWILIGHT;
449 meta->addEntry(OHOS_CONTROL_AWB_MODE, &awbMode, 1);
450 display_->cameraDevice->UpdateSettings(meta);
451 std::cout << "==========[test log] UpdateSettings, exposure for 10s." << std::endl;
452 sleep(10); // update settings, exposure for 10s
453 // release stream
454 display_->captureIds = {display_->CAPTURE_ID_PREVIEW, display_->CAPTURE_ID_CAPTURE};
455 display_->streamIds = {display_->STREAM_ID_PREVIEW, display_->STREAM_ID_CAPTURE};
456 display_->StopStream(display_->captureIds, display_->streamIds);
457 }
458
459 /**
460 * @tc.name: updateSettings AE
461 * @tc.desc: UpdateSettings-OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, success.
462 * @tc.level: Level1
463 * @tc.size: MediumTest
464 * @tc.type: Function
465 */
TEST_F(UtestCamera3ATest,camera_3a_0040)466 TEST_F(UtestCamera3ATest, camera_3a_0040)
467 {
468 std::cout << "UpdateSettings-OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, success." << std::endl;
469 EXPECT_EQ(true, display_->cameraDevice != nullptr);
470 // Get the stream manager
471 display_->AchieveStreamOperator();
472 // start stream
473 display_->intents = {PREVIEW, STILL_CAPTURE};
474 display_->StartStream(display_->intents);
475 // Get preview
476 display_->StartCapture(display_->STREAM_ID_PREVIEW, display_->CAPTURE_ID_PREVIEW, false, true);
477 display_->StartCapture(display_->STREAM_ID_CAPTURE, display_->CAPTURE_ID_CAPTURE, false, true);
478
479 // Issue 3A parameters
480 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY_SIZE, DATA_CAPACITY_SIZE);
481 int32_t expo = 0xa0;
482 meta->addEntry(OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, &expo, 1);
483 display_->cameraDevice->UpdateSettings(meta);
484 sleep(5); // waiting resource release for 5s.
485 }
486
487 /**
488 * @tc.name: updateSettings AWB without preview
489 * @tc.desc: UpdateSettings-OHOS_CAMERA_AWB_MODE, without preview, success.
490 * @tc.level: Level1
491 * @tc.size: MediumTest
492 * @tc.type: Function
493 */
TEST_F(UtestCamera3ATest,camera_3a_0041)494 TEST_F(UtestCamera3ATest, camera_3a_0041)
495 {
496 std::cout << "UpdateSettings-OHOS_CAMERA_AWB_MODE, success." << std::endl;
497
498 // Issue 3A parameters
499 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY_SIZE, DATA_CAPACITY_SIZE);
500 uint8_t awbMode = OHOS_CAMERA_AWB_MODE_AUTO;
501 meta->addEntry(OHOS_CONTROL_AWB_MODE, &awbMode, 1);
502 display_->cameraDevice->UpdateSettings(meta);
503 }
504