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