1 /*
2 * Copyright (c) 2024 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 #include "camera_hdi_test_v1_2.h"
16 #include <functional>
17
18 using namespace OHOS;
19 using namespace std;
20 using namespace testing::ext;
21 using namespace OHOS::Camera;
22
23 constexpr uint32_t ITEM_CAPACITY = 100;
24 constexpr uint32_t DATA_CAPACITY = 2000;
25 constexpr uint32_t DATA_COUNT = 1;
26 std::vector<std::string> pendingImagesId = {"-1", "-2"};
SetUpTestCase(void)27 void CameraHdiTestV1_2::SetUpTestCase(void) {}
TearDownTestCase(void)28 void CameraHdiTestV1_2::TearDownTestCase(void) {}
SetUp(void)29 void CameraHdiTestV1_2::SetUp(void)
30 {
31 cameraTest = std::make_shared<OHOS::Camera::Test>();
32 cameraTest->Init(); // assert inside
33 cameraTest->Open(DEVICE_0); // assert inside
34 }
35
TearDown(void)36 void CameraHdiTestV1_2::TearDown(void)
37 {
38 cameraTest->Close();
39 }
40
TakePhoteWithDefferredImage(int PhotoCount)41 void CameraHdiTestV1_2::TakePhoteWithDefferredImage(int PhotoCount)
42 {
43 auto meta = std::make_shared<CameraSetting>(100, 100);
44 uint8_t value = OHOS::HDI::Camera::V1_2::STILL_IMAGE;
45 meta->addEntry(OHOS_CONTROL_DEFERRED_IMAGE_DELIVERY, &value, sizeof(value));
46 std::vector<uint8_t> metaVec;
47 MetadataUtils::ConvertMetadataToVec(meta, metaVec);
48 cameraTest->rc = cameraTest->cameraDevice->UpdateSettings(metaVec);
49 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
50
51 // take photo
52 cameraTest->imageDataSaveSwitch = SWITCH_ON;
53 cameraTest->intents = {PREVIEW, STILL_CAPTURE};
54 cameraTest->StartStream(cameraTest->intents);
55 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
56 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
57 for (int i = 0; i < PhotoCount; i++) {
58 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
59 }
60 cameraTest->captureIds = {cameraTest->captureIdPreview};
61 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
62 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
63 }
64
RemovePendingImages()65 void CameraHdiTestV1_2::RemovePendingImages()
66 {
67 std::vector<std::string> pendingImages;
68 int ret = cameraTest->imageProcessSession_->GetPendingImages(pendingImages);
69 EXPECT_EQ(ret, 0);
70 if (pendingImages.size() != 0) {
71 for (auto imageId = pendingImages.begin(); imageId != pendingImages.end(); ++imageId) {
72 ret = cameraTest->imageProcessSession_->RemoveImage(*imageId);
73 EXPECT_EQ(ret, 0);
74 }
75 }
76 }
77
78 /**
79 * @tc.name:SUB_Driver_Camera_DefferredImage_0200
80 * @tc.desc:ProcessPendingImages
81 * @tc.size:MediumTest
82 * @tc.type:Function
83 */
84 HWTEST_F(CameraHdiTestV1_2, SUB_Driver_Camera_DefferredImage_0200, TestSize.Level1)
85 {
86 int ret = 0;
87 bool isImageProcessServiceExist = true;
88 bool isExit = cameraTest->IsTagValueExistsU8(cameraTest->ability,\
89 OHOS_ABILITY_DEFERRED_IMAGE_DELIVERY,\
90 OHOS::HDI::Camera::V1_2::STILL_IMAGE);
91 if (!isExit) {
92 GTEST_SKIP() << "skip this test, because OHOS_ABILITY_DEFERRED_IMAGE_DELIVERY not found" << std::endl;
93 return;
94 }
95 // get DefferredImageTestInit
96 ret = cameraTest->DefferredImageTestInit();
97 EXPECT_EQ(ret, 0);
98 if (ret != 0) {
99 CAMERA_LOGE("DefferredImageTestInit Fail!!!");
100 printf("DefferredImageTestInit Fail!!!\r\n");
101 isImageProcessServiceExist = false;
102 }
103 // 如果存在未处理的图片，则删除未处理的图片
104 RemovePendingImages();
105 // take photo using deferred image delivery
106 TakePhoteWithDefferredImage(1);
107 // image deferred delivery process
108 ASSERT_EQ(isImageProcessServiceExist, true);
109 int taskCount = 0;
110 ret = cameraTest->imageProcessSession_->GetCoucurrency(OHOS::HDI::Camera::V1_2::HIGH_PREFORMANCE, taskCount);
111 EXPECT_EQ(ret, 0);
112 std::vector<std::string> pendingImages;
113 ret = cameraTest->imageProcessSession_->GetPendingImages(pendingImages);
114 EXPECT_EQ(ret, 0);
115 EXPECT_GE(taskCount, 1);
116 }
117
ProcessPendingImages(int ret)118 void CameraHdiTestV1_2::ProcessPendingImages(int ret)
119 {
120 // image deferred delivery process
121 int taskCount = 0;
122 std::vector<std::string> pendingImages;
123 ret = cameraTest->imageProcessSession_->GetCoucurrency(OHOS::HDI::Camera::V1_2::BALANCED, taskCount);
124 EXPECT_EQ(ret, 0);
125 ret = cameraTest->imageProcessSession_->GetPendingImages(pendingImages);
126 EXPECT_EQ(ret, 0);
127 ret = cameraTest->imageProcessSession_->SetExecutionMode(OHOS::HDI::Camera::V1_2::BALANCED);
128 EXPECT_EQ(ret, 0);
129 ret = cameraTest->imageProcessSession_->SetExecutionMode(OHOS::HDI::Camera::V1_2::LOW_POWER);
130 EXPECT_EQ(ret, 0);
131 ret = cameraTest->imageProcessSession_->SetExecutionMode(OHOS::HDI::Camera::V1_2::HIGH_PREFORMANCE);
132 EXPECT_EQ(ret, 0);
133 // process the first image
134 ret = cameraTest->imageProcessSession_->ProcessImage(pendingImagesId[0]);
135 EXPECT_EQ(ret, 0);
136 // process the second image
137 ret = cameraTest->imageProcessSession_->ProcessImage(pendingImagesId[1]);
138 EXPECT_EQ(ret, 0);
139 // process the third image, and test the Interrupt, Reset, RemoveImage Interfaces
140 ret = cameraTest->imageProcessSession_->Interrupt();
141 EXPECT_EQ(ret, 0);
142 ret = cameraTest->imageProcessSession_->Reset();
143 EXPECT_EQ(ret, 0);
144 ret = cameraTest->imageProcessSession_->RemoveImage(pendingImagesId[0]);
145 EXPECT_EQ(ret, 0);
146 }
147
148 /**
149 * @tc.name:SUB_Driver_Camera_DefferredImage_0300
150 * @tc.desc:ProcessPendingImages
151 * @tc.size:MediumTest
152 * @tc.type:Function
153 */
154 HWTEST_F(CameraHdiTestV1_2, SUB_Driver_Camera_DefferredImage_0300, TestSize.Level1)
155 {
156 int ret = 0;
157 bool isImageProcessServiceExist = true;
158 bool isExit = cameraTest->IsTagValueExistsU8(cameraTest->ability,\
159 OHOS_ABILITY_DEFERRED_IMAGE_DELIVERY, OHOS::HDI::Camera::V1_2::STILL_IMAGE);
160 if (!isExit) {
161 GTEST_SKIP() << "skip this test, because OHOS_ABILITY_DEFERRED_IMAGE_DELIVERY not found" << std::endl;
162 return;
163 }
164 // get DefferredImageTestInit
165 ret = cameraTest->DefferredImageTestInit();
166 EXPECT_EQ(ret, 0);
167 if (ret != 0) {
168 CAMERA_LOGE("DefferredImageTestInit Fail");
169 printf("DefferredImageTestInit Fail\r\n");
170 isImageProcessServiceExist = false;
171 }
172 // 如果存在未处理的图片，则删除未处理的图片
173 RemovePendingImages();
174 // take three photo using deferred image delivery, three times
175 TakePhoteWithDefferredImage(3);
176 ASSERT_EQ(isImageProcessServiceExist, true);
177 // 进行二段式处理拍照图片
178 ProcessPendingImages(ret);
179 }
180
181 /**
182 * @tc.name: SUB_Driver_Camera_ScanMode_0100
183 * @tc.desc: CommitStreams_V1_1 for Scan code, preview and video
184 * @tc.size: MediumTest
185 * @tc.type: Function
186 */
187 HWTEST_F(CameraHdiTestV1_2, SUB_Driver_Camera_ScanMode_0100, TestSize.Level1)
188 {
189 // Get Stream Operator
190 cameraTest->streamOperatorCallback = new OHOS::Camera::Test::TestStreamOperatorCallback();
191 cameraTest->rc = cameraTest->cameraDeviceV1_1->GetStreamOperator_V1_1(cameraTest->streamOperatorCallback,
192 cameraTest->streamOperator_V1_1);
193 EXPECT_NE(cameraTest->streamOperator_V1_1, nullptr);
194 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
195
196 // preview streamInfo
197 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
198 cameraTest->DefaultInfosPreview(cameraTest->streamInfoV1_1);
199 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
200
201 // video streamInfo
202 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
203 cameraTest->DefaultInfosVideo(cameraTest->streamInfoV1_1);
204 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
205
206 // is streams supported V1_1
207 std::shared_ptr<CameraMetadata> modeSetting = std::make_shared<CameraMetadata>(2, 128);
208 int64_t expoTime = 0;
209 modeSetting->addEntry(OHOS_SENSOR_EXPOSURE_TIME, &expoTime, 1);
210 int64_t colorGains[4] = {0};
211 modeSetting->addEntry(OHOS_SENSOR_COLOR_CORRECTION_GAINS, &colorGains, 4);
212 std::vector<uint8_t> modeSettingVec;
213 MetadataUtils::ConvertMetadataToVec(modeSetting, modeSettingVec);
214 StreamSupportType pType;
215 cameraTest->rc = cameraTest->streamOperator_V1_1->IsStreamsSupported_V1_1(
216 static_cast<OHOS::HDI::Camera::V1_1::OperationMode_V1_1>(OHOS::HDI::Camera::V1_2::SCAN_CODE),
217 modeSettingVec, cameraTest->streamInfosV1_1, pType);
218 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
219
220 // create and commitstreams
221 cameraTest->rc = cameraTest->streamOperator_V1_1->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
222 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
223 cameraTest->rc = cameraTest->streamOperator_V1_1->CommitStreams_V1_1(
224 static_cast<OHOS::HDI::Camera::V1_1::OperationMode_V1_1>(OHOS::HDI::Camera::V1_2::SCAN_CODE),
225 cameraTest->abilityVec);
226 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
227 sleep(UT_SECOND_TIMES);
228
229 // start capture
230 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
231 cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true);
232 sleep(UT_SECOND_TIMES);
233
234 // stop stream
235 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo};
236 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo};
237 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
238 }
239
240 /**
241 * @tc.name: SUB_Driver_Camera_XMAGE_0200
242 * @tc.desc: UpdateSettings:CAMERA_CUSTOM_COLOR_BRIGHT
243 * @tc.size: MediumTest
244 * @tc.type: Function
245 */
246 HWTEST_F(CameraHdiTestV1_2, SUB_Driver_Camera_XMAGE_0200, TestSize.Level1)
247 {
248 // Start Xmage control setting and verify
249 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(100, 200);
250 uint8_t xmageMode = CAMERA_CUSTOM_COLOR_BRIGHT;
251 meta->addEntry(OHOS_CONTROL_SUPPORTED_COLOR_MODES, &xmageMode, 1);
252 std::vector<uint8_t> metaVec;
253 MetadataUtils::ConvertMetadataToVec(meta, metaVec);
254 cameraTest->cameraDevice->UpdateSettings(metaVec);
255 cameraTest->intents = {PREVIEW, STILL_CAPTURE};
256 cameraTest->StartStream(cameraTest->intents);
257 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
258 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
259 sleep(1);
260 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
261 cameraTest->captureIds = {cameraTest->captureIdPreview};
262 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
263 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
264 }
265
266 /**
267 * @tc.name: SUB_Driver_Camera_XMAGE_0300
268 * @tc.desc: UpdateSettings:CAMERA_CUSTOM_COLOR_NORMAL
269 * @tc.size: MediumTest
270 * @tc.type: Function
271 */
272 HWTEST_F(CameraHdiTestV1_2, SUB_Driver_Camera_XMAGE_0300, TestSize.Level1)
273 {
274 // Start Xmage control setting and verify
275 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(100, 200);
276 uint8_t xmageMode = 100;
277 meta->addEntry(OHOS_CONTROL_SUPPORTED_COLOR_MODES, &xmageMode, 1);
278 std::vector<uint8_t> metaVec;
279 MetadataUtils::ConvertMetadataToVec(meta, metaVec);
280 cameraTest->cameraDevice->UpdateSettings(metaVec);
281 cameraTest->intents = {PREVIEW, STILL_CAPTURE};
282 cameraTest->StartStream(cameraTest->intents);
283 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
284 }
285
286 #define TODEFINESTRING(x) #x
287
TranslateXMageAbilityToString(camera_xmage_color_type mode)288 static std::string TranslateXMageAbilityToString(camera_xmage_color_type mode)
289 {
290 std::string res;
291 switch (mode) {
292 case CAMERA_CUSTOM_COLOR_NORMAL:
293 {
294 res = TODEFINESTRING(CAMERA_CUSTOM_COLOR_NORMAL);
295 break;
296 }
297 case CAMERA_CUSTOM_COLOR_BRIGHT:
298 {
299 res = TODEFINESTRING(CAMERA_CUSTOM_COLOR_BRIGHT);
300 break;
301 }
302 case CAMERA_CUSTOM_COLOR_SOFT:
303 {
304 res = TODEFINESTRING(CAMERA_CUSTOM_COLOR_SOFT);
305 break;
306 }
307 default:
308 break;
309 }
310 return res;
311 }
312
313 /**
314 * @tc.name: SUB_Driver_Camera_XMAGE_0400
315 * @tc.desc: OHOS_CONTROL_SUPPORTED_COLOR_MODES,all value
316 * @tc.size: MediumTest
317 * @tc.type: Function
318 */
319 HWTEST_F(CameraHdiTestV1_2, SUB_Driver_Camera_XMAGE_0400, TestSize.Level1)
320 {
321 // Start Xmage control setting and verify
322 common_metadata_header_t* data = cameraTest->ability->get();
323 EXPECT_NE(data, nullptr);
324 camera_metadata_item_t entry;
325 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_SUPPORTED_COLOR_MODES, &entry);
326 std::vector<uint8_t> xmageAbilities;
327 // 查询支持的Xmage所有模式
328 if (ret == 0) {
329 EXPECT_TRUE(entry.data.u8 != nullptr);
330 EXPECT_NE(entry.count, 0);
331
332 for (uint32_t i = 0; i < entry.count; ++i) {
333 // 打印并保存当前相机所支持的xmage能力
334 CAMERA_LOGI("Current camera xmage ability %{public}s supported!",
335 TranslateXMageAbilityToString(static_cast<camera_xmage_color_type>(entry.data.u8[i])).c_str());
336
337 xmageAbilities.push_back(entry.data.u8[i]);
338 }
339 } else {
340 CAMERA_LOGI("XMage not supported");
341 }
342 CAMERA_LOGI("%{public}lu xmage abilities supported",
343 static_cast<unsigned long>(xmageAbilities.size()));
344 for (uint32_t i = 0; i < xmageAbilities.size(); ++i) {
345 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(100, 200);
346 // UpdateSettings mode
347 uint8_t xmageMode = xmageAbilities[i];
348 meta->addEntry(OHOS_CONTROL_SUPPORTED_COLOR_MODES, &xmageMode, 1);
349 std::vector<uint8_t> metaVec;
350 MetadataUtils::ConvertMetadataToVec(meta, metaVec);
351 cameraTest->cameraDevice->UpdateSettings(metaVec);
352 CAMERA_LOGI("Now current camera xmage ability is %{public}s !",
353 TranslateXMageAbilityToString(static_cast<camera_xmage_color_type>(xmageMode)).c_str());
354 cameraTest->intents = {PREVIEW, STILL_CAPTURE, VIDEO};
355 cameraTest->StartStream(cameraTest->intents);
356 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
357 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, true);
358 cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true);
359 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdCapture,
360 cameraTest->captureIdVideo};
361 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture, cameraTest->streamIdVideo};
362 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
363 }
364 }
365
TakePhotoWithTags(std::shared_ptr<OHOS::Camera::CameraSetting> metaDate)366 void CameraHdiTestV1_2::TakePhotoWithTags(std::shared_ptr<OHOS::Camera::CameraSetting> metaDate)
367 {
368 std::vector<uint8_t> metaVec;
369 MetadataUtils::ConvertMetadataToVec(metaDate, metaVec);
370 cameraTest->intents = {PREVIEW, STILL_CAPTURE};
371 cameraTest->StartStream(cameraTest->intents);
372 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
373 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
374 sleep(1);
375 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
376 cameraTest->captureIds = {cameraTest->captureIdPreview};
377 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
378 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
379 }
380
381 /**
382 * @tc.name:SUB_Driver_Camera_Stabilization_0200
383 * @tc.desc:OHOS_CAMERA_VIDEO_STABILIZATION_OFF
384 * @tc.size:MediumTest
385 * @tc.type:Function
386 */
387 HWTEST_F(CameraHdiTestV1_2, SUB_Driver_Camera_Stabilization_0200, TestSize.Level1)
388 {
389 //start stream
390 cameraTest->intents = {PREVIEW, VIDEO};
391 cameraTest->StartStream(cameraTest->intents);
392 //updateSettings
393 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
394 uint8_t videoStabiliMode = OHOS_CAMERA_VIDEO_STABILIZATION_OFF;
395 meta->addEntry(OHOS_CONTROL_VIDEO_STABILIZATION_MODE, &videoStabiliMode, DATA_COUNT);
396 const int32_t deviceStreamId = cameraTest->streamIdPreview;
397 meta->addEntry(OHOS_CAMERA_STREAM_ID, &deviceStreamId, DATA_COUNT);
398 std::vector<uint8_t> setting;
399 MetadataUtils::ConvertMetadataToVec(meta, setting);
400 cameraTest->rc = (CamRetCode)cameraTest->cameraDevice->UpdateSettings(setting);
401 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
402 //get preview capture and video
403 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
404 cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true);
405 //release stream
406 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo};
407 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo};
408 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
409 }
410
411 /**
412 * @tc.name:SUB_Driver_Camera_Stabilization_0300
413 * @tc.desc:OHOS_CAMERA_VIDEO_STABILIZATION_AUTO
414 * @tc.size:MediumTest
415 * @tc.type:Function
416 */
417 HWTEST_F(CameraHdiTestV1_2, SUB_Driver_Camera_Stabilization_0300, TestSize.Level1)
418 {
419 //start stream
420 cameraTest->intents = {PREVIEW, VIDEO};
421 cameraTest->StartStream(cameraTest->intents);
422
423 //updateSettings
424 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
425 uint8_t videoStabiliMode = OHOS_CAMERA_VIDEO_STABILIZATION_AUTO;
426 meta->addEntry(OHOS_CONTROL_VIDEO_STABILIZATION_MODE, &videoStabiliMode, DATA_COUNT);
427 const int32_t deviceStreamId = cameraTest->streamIdPreview;
428 meta->addEntry(OHOS_CAMERA_STREAM_ID, &deviceStreamId, DATA_COUNT);
429 std::vector<uint8_t> setting;
430 MetadataUtils::ConvertMetadataToVec(meta, setting);
431 cameraTest->rc = (CamRetCode)cameraTest->cameraDevice->UpdateSettings(setting);
432 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
433
434 //get preview capture and video
435 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
436 cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true);
437
438 //release stream
439 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo};
440 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo};
441 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
442 }
443
CaptureByColorSpaces(std::vector<int32_t> captureColorSpaces,std::shared_ptr<OHOS::Camera::Test> cameraTest)444 void CaptureByColorSpaces(std::vector<int32_t> captureColorSpaces, std::shared_ptr<OHOS::Camera::Test> cameraTest)
445 {
446 if (!captureColorSpaces.empty()) {
447 for (int32_t colorSpaces : captureColorSpaces) {
448 printf("capture colorSpaces value %d\n", colorSpaces);
449 // preview streamInfo
450 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
451 cameraTest->DefaultInfosPreview(cameraTest->streamInfoV1_1);
452 cameraTest->streamInfoV1_1->v1_0.dataspace_ = colorSpaces;
453 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
454 // capture streamInfo
455 cameraTest->streamInfoCapture = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
456 cameraTest->DefaultInfosCapture(cameraTest->streamInfoCapture);
457 cameraTest->streamInfoCapture->v1_0.dataspace_ = colorSpaces;
458 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoCapture);
459 cameraTest->rc = cameraTest->streamOperator_V1_1->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
460 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
461 cameraTest->rc = cameraTest->streamOperator_V1_1->CommitStreams(
462 OperationMode::NORMAL, cameraTest->abilityVec);
463 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
464 sleep(UT_SECOND_TIMES);
465 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
466 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
467 cameraTest->captureIds = {cameraTest->captureIdPreview};
468 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
469 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
470 cameraTest->streamInfosV1_1.clear();
471 }
472 }
473 }
474
VideoByColorSpaces(std::vector<int32_t> videoColorSpaces,std::vector<int32_t> previewColorSpaces,std::shared_ptr<OHOS::Camera::Test> cameraTest)475 void VideoByColorSpaces(std::vector<int32_t> videoColorSpaces, std::vector<int32_t> previewColorSpaces,
476 std::shared_ptr<OHOS::Camera::Test> cameraTest)
477 {
478 cameraTest->imageDataSaveSwitch = SWITCH_ON;
479
480 if (videoColorSpaces.empty() || previewColorSpaces.empty()) {
481 printf("ColorSpaces empty is null\n");
482 return;
483 }
484 for (int32_t colorSpaces : previewColorSpaces) {
485 printf("preview colorSpaces value %d\n", colorSpaces);
486
487 // preview streamInfo
488 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
489 cameraTest->DefaultInfosPreview(cameraTest->streamInfoV1_1);
490 cameraTest->streamInfoV1_1->v1_0.dataspace_ = colorSpaces;
491 if (colorSpaces == OHOS_CAMERA_BT2020_HLG_FULL) {
492 cameraTest->streamInfoV1_1->v1_0.format_ = OHOS_CAMERA_FORMAT_YCBCR_P010;
493 }
494
495 // video streamInfo
496 for (int32_t colorSpaces_ : videoColorSpaces) {
497 printf("video colorSpaces_ value %d\n", colorSpaces_);
498 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
499
500 cameraTest->streamInfoVideo = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
501 cameraTest->DefaultInfosVideo(cameraTest->streamInfoVideo);
502 cameraTest->streamInfoVideo->v1_0.dataspace_ = colorSpaces_;
503 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoVideo);
504 cameraTest->rc = cameraTest->streamOperator_V1_1->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
505 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
506 cameraTest->rc = cameraTest->streamOperator_V1_1->CommitStreams(
507 static_cast<OHOS::HDI::Camera::V1_0::OperationMode>(OHOS::HDI::Camera::V1_1::OperationMode_V1_1::VIDEO),
508 cameraTest->abilityVec);
509 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
510
511 //updateSettings
512 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
513 uint8_t videoStabiliMode = OHOS_CAMERA_VIDEO_STABILIZATION_AUTO;
514 meta->addEntry(OHOS_CONTROL_VIDEO_STABILIZATION_MODE, &videoStabiliMode, DATA_COUNT);
515 const int32_t deviceStreamId = cameraTest->streamIdPreview;
516 meta->addEntry(OHOS_CAMERA_STREAM_ID, &deviceStreamId, DATA_COUNT);
517 std::vector<uint8_t> setting;
518 MetadataUtils::ConvertMetadataToVec(meta, setting);
519 cameraTest->rc = (CamRetCode)cameraTest->cameraDevice->UpdateSettings(setting);
520 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
521 sleep(UT_SECOND_TIMES);
522
523 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
524 cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true);
525 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo};
526 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo};
527 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
528 cameraTest->streamInfosV1_1.clear();
529 sleep(1);
530 }
531 }
532 cameraTest->imageDataSaveSwitch = SWITCH_OFF;
533 }
534
SuperStubByColorSpaces(std::vector<int32_t> superStubColorSpaces,std::shared_ptr<OHOS::Camera::Test> cameraTest)535 void SuperStubByColorSpaces(std::vector<int32_t> superStubColorSpaces, std::shared_ptr<OHOS::Camera::Test> cameraTest)
536 {
537 if (!superStubColorSpaces.empty()) {
538 for (int32_t colorSpaces : superStubColorSpaces) {
539 printf("superStubColorSpaces colorSpaces value %d\n", colorSpaces);
540 // preview streamInfo
541 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
542 cameraTest->DefaultInfosPreview(cameraTest->streamInfoV1_1);
543 cameraTest->streamInfoV1_1->v1_0.dataspace_ = colorSpaces;
544 if (colorSpaces == OHOS_CAMERA_BT2020_HLG_FULL) {
545 cameraTest->streamInfoV1_1->v1_0.format_ = OHOS_CAMERA_FORMAT_YCBCR_P010;
546 }
547 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
548 // video streamInfo
549 cameraTest->streamInfoVideo = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
550 cameraTest->DefaultInfosVideo(cameraTest->streamInfoVideo);
551 cameraTest->streamInfoVideo->v1_0.dataspace_ = colorSpaces;
552 if (colorSpaces == OHOS_CAMERA_BT2020_HLG_FULL) {
553 cameraTest->streamInfoVideo->v1_0.format_ = OHOS_CAMERA_FORMAT_YCBCR_P010;
554 }
555 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoVideo);
556 cameraTest->rc = cameraTest->streamOperator_V1_1->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
557 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
558 cameraTest->rc = cameraTest->streamOperator_V1_1->CommitStreams_V1_1(
559 static_cast<OHOS::HDI::Camera::V1_1::OperationMode_V1_1>(OHOS::HDI::Camera::V1_2::SUPER_STAB),
560 cameraTest->abilityVec);
561 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
562 sleep(UT_SECOND_TIMES);
563 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
564 cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true);
565 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo};
566 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo};
567 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
568 cameraTest->streamInfosV1_1.clear();
569 }
570 }
571 }
572
573 /**
574 * @tc.name:SUB_Driver_Camera_Colorspace_0200
575 * @tc.desc: Update macro ability setting and check the callback
576 * @tc.size:MediumTest
577 * @tc.type:Function
578 */
579 HWTEST_F(CameraHdiTestV1_2, SUB_Driver_Camera_Colorspace_0200, TestSize.Level1)
580 {
581 cameraTest->streamOperatorCallback = new OHOS::Camera::Test::TestStreamOperatorCallback();
582 cameraTest->rc = cameraTest->cameraDeviceV1_1->GetStreamOperator_V1_1(
583 cameraTest->streamOperatorCallback, cameraTest->streamOperator_V1_1);
584 EXPECT_NE(cameraTest->streamOperator_V1_1, nullptr);
585 common_metadata_header_t* data = cameraTest->ability->get();
586 EXPECT_NE(data, nullptr);
587 camera_metadata_item_t entry;
588 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_AVAILABLE_COLOR_SPACES, &entry);
589 printf("OHOS_ABILITY_AVAILABLE_COLOR_SPACES value count %d\n", entry.count);
590 if (ret == HDI::Camera::V1_0::NO_ERROR && entry.data.i32 != nullptr && entry.count > 0) {
591 std::vector<int32_t> captureColorSpaces;
592 std::vector<int32_t> videoColorSpaces;
593 std::vector<int32_t> superStubColorSpaces;
594 std::vector<int32_t> previewColorSpaces;
595 int32_t operatorMode = -2;
596 for (size_t i = 0; i < entry.count - 1; i++) {
597 if (operatorMode == -2 && entry.data.i32[i] == HDI::Camera::V1_2::OperationMode_V1_2::CAPTURE) {
598 operatorMode = HDI::Camera::V1_2::OperationMode_V1_2::CAPTURE;
599 } else if (operatorMode == -2 && entry.data.i32[i] == HDI::Camera::V1_2::OperationMode_V1_2::VIDEO) {
600 operatorMode = HDI::Camera::V1_2::OperationMode_V1_2::VIDEO;
601 } else if (operatorMode == -2 && entry.data.i32[i] == HDI::Camera::V1_2::OperationMode_V1_2::SUPER_STAB) {
602 operatorMode = HDI::Camera::V1_2::OperationMode_V1_2::SUPER_STAB;
603 } else if (entry.data.i32[i] == -1 && operatorMode != -2 && entry.data.i32[i + 1] == -1) {
604 operatorMode = -2;
605 } else if (entry.data.i32[i] == -1 && operatorMode != -2 && entry.data.i32[i + 1] != -1) {
606 operatorMode = -1;
607 } else if (operatorMode == HDI::Camera::V1_2::OperationMode_V1_2::CAPTURE) {
608 captureColorSpaces.push_back(entry.data.i32[i]);
609 } else if (operatorMode == HDI::Camera::V1_2::OperationMode_V1_2::VIDEO) {
610 if (std::find(cameraTest->previewColorSpaces_.begin(), cameraTest->previewColorSpaces_.end(),
611 entry.data.i32[i]) != cameraTest->previewColorSpaces_.end()) {
612 previewColorSpaces.push_back(entry.data.i32[i]);
613 } else {
614 videoColorSpaces.push_back(entry.data.i32[i]);
615 }
616 } else if (operatorMode == HDI::Camera::V1_2::OperationMode_V1_2::SUPER_STAB) {
617 superStubColorSpaces.push_back(entry.data.i32[i]);
618 } else if (operatorMode == -2 && entry.data.i32[i] > 0) {
619 operatorMode = -1;
620 }
621 }
622 CaptureByColorSpaces(captureColorSpaces, cameraTest);
623 VideoByColorSpaces(videoColorSpaces, previewColorSpaces, cameraTest);
624 SuperStubByColorSpaces(superStubColorSpaces, cameraTest);
625 }
626 }
627
628 /**
629 * @tc.name: SUB_Driver_Camera_APERTURE_0500
630 * @tc.desc: OHOS_CONTROL_CAMERA_PHYSICAL_APERTURE_RANGE
631 * @tc.size: MediumTest
632 * @tc.type: Function
633 */
634 HWTEST_F(CameraHdiTestV1_2, SUB_Driver_Camera_APERTURE_0500, TestSize.Level1)
635 {
636 // Get Stream Operator
637 cameraTest->streamOperatorCallback = new OHOS::Camera::Test::TestStreamOperatorCallback();
638 cameraTest->rc = cameraTest->cameraDeviceV1_1->GetStreamOperator_V1_1(cameraTest->streamOperatorCallback,
639 cameraTest->streamOperator_V1_1);
640 EXPECT_NE(cameraTest->streamOperator_V1_1, nullptr);
641 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
642
643 // preview streamInfo
644 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
645 cameraTest->DefaultInfosPreview(cameraTest->streamInfoV1_1);
646 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
647
648 // capture streamInfo
649 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
650 cameraTest->DefaultInfosCapture(cameraTest->streamInfoV1_1);
651 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
652
653 // create and commitstreams
654 cameraTest->rc = cameraTest->streamOperator_V1_1->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
655 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
656 cameraTest->rc = cameraTest->streamOperator_V1_1->CommitStreams_V1_1(
657 static_cast<OHOS::HDI::Camera::V1_1::OperationMode_V1_1>(OHOS::HDI::Camera::V1_2::PORTRAIT),
658 cameraTest->abilityVec);
659 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
660
661 //update settings
662 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
663 float physicalApertureValue = 2;
664 meta->addEntry(OHOS_CONTROL_CAMERA_PHYSICAL_APERTURE_VALUE, &physicalApertureValue, DATA_COUNT);
665 std::vector<uint8_t> setting;
666 MetadataUtils::ConvertMetadataToVec(meta, setting);
667 cameraTest->rc = (CamRetCode)cameraTest->cameraDevice->UpdateSettings(setting);
668 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
669
670 // start capture
671 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
672 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, true);
673 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdCapture};
674 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
675 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
676 }
677
678 /**
679 * @tc.name: SUB_Driver_Camera_APERTURE_0600
680 * @tc.desc: OHOS_CONTROL_CAMERA_PHYSICAL_APERTURE_RANGE, all value
681 * @tc.size: MediumTest
682 * @tc.type: Function
683 */
684 HWTEST_F(CameraHdiTestV1_2, SUB_Driver_Camera_APERTURE_0600, TestSize.Level1)
685 {
686 EXPECT_NE(cameraTest->ability, nullptr);
687 common_metadata_header_t* data = cameraTest->ability->get();
688 EXPECT_NE(data, nullptr);
689 camera_metadata_item_t entry;
690 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_PHYSICAL_APERTURE_RANGE, &entry);
691 if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.f != nullptr && entry.count > 0) {
692 float entryValues[] = { entry.data.f[3], entry.data.f[7], entry.data.f[8], entry.data.f[9], entry.data.f[10],
693 entry.data.f[14], entry.data.f[18] };
694 for (size_t i = 0; i < sizeof(entryValues) / sizeof(float); i++) {
695 // Get Stream Operator
696 cameraTest->streamOperatorCallback = new OHOS::Camera::Test::TestStreamOperatorCallback();
697 cameraTest->rc = cameraTest->cameraDeviceV1_1->GetStreamOperator_V1_1(cameraTest->streamOperatorCallback,
698 cameraTest->streamOperator_V1_1);
699 EXPECT_NE(cameraTest->streamOperator_V1_1, nullptr);
700 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
701
702 // preview streamInfo
703 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
704 cameraTest->DefaultInfosPreview(cameraTest->streamInfoV1_1);
705 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
706
707 // capture streamInfo
708 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
709 cameraTest->DefaultInfosCapture(cameraTest->streamInfoV1_1);
710 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
711
712 // create and commitstreams
713 cameraTest->rc = cameraTest->streamOperator_V1_1->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
714 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
715 cameraTest->rc = cameraTest->streamOperator_V1_1->CommitStreams_V1_1(
716 static_cast<OHOS::HDI::Camera::V1_1::OperationMode_V1_1>(OHOS::HDI::Camera::V1_2::PORTRAIT),
717 cameraTest->abilityVec);
718 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
719
720 //update settings
721 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
722 float physicalApertureValue = entryValues[i];
723 meta->addEntry(OHOS_CONTROL_CAMERA_PHYSICAL_APERTURE_VALUE, &physicalApertureValue, DATA_COUNT);
724 std::vector<uint8_t> setting;
725 MetadataUtils::ConvertMetadataToVec(meta, setting);
726 cameraTest->rc = (CamRetCode)cameraTest->cameraDevice->UpdateSettings(setting);
727 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
728
729 // start capture
730 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
731 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, true);
732
733 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdCapture};
734 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
735 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
736 sleep(1);
737 cameraTest->streamInfosV1_1.clear();
738 }
739 }
740 }
741
742 /**
743 * @tc.name:SUB_Driver_Camera_Macro_0200
744 * @tc.desc: Update macro ability setting and check the callback
745 * @tc.size:MediumTest
746 * @tc.type:Function
747 */
748 HWTEST_F(CameraHdiTestV1_2, SUB_Driver_Camera_Macro_0200, TestSize.Level1)
749 {
750 int32_t rc;
751 // step 2: set callback object
752 cameraTest->hostCallbackV1_2 = new OHOS::Camera::Test::TestCameraHostCallbackV1_2();
753 rc = cameraTest->serviceV1_2->SetCallback_V1_2(cameraTest->hostCallbackV1_2);
754 EXPECT_EQ(rc, 0);
755 // Start OHOS_ABILITY_CAMERA_MACRO_SUPPORTED ability query
756 common_metadata_header_t* data = cameraTest->ability->get();
757 EXPECT_NE(data, nullptr);
758 camera_metadata_item_t entry;
759 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_MACRO_SUPPORTED, &entry);
760
761 if (ret == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) {
762 cameraTest->intents = {PREVIEW, STILL_CAPTURE, VIDEO};
763 cameraTest->StartStream(cameraTest->intents);
764 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
765 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
766 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, true);
767 cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true);
768 sleep(1);
769 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdCapture,
770 cameraTest->captureIdVideo};
771 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture,
772 cameraTest->streamIdVideo};
773 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
774 sleep(UT_SECOND_TIMES);
775 common_metadata_header_t* data = cameraTest->deviceCallback->resultMeta->get();
776 EXPECT_NE(data, nullptr);
777 camera_metadata_item_t entry;
778 int ret = FindCameraMetadataItem(data, OHOS_CAMERA_MACRO_STATUS, &entry);
779 if (ret == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) {
780 uint8_t value = entry.data.u8[0];
781 // 查询到状态， 检测状态到 微距模式可开启
782 if (OHOS_CAMERA_MACRO_ENABLE == value) {
783 printf("Macro mode is set enabled.");
784 } else {
785 printf("Macro mode is not enabled.");
786 }
787 } else {
788 printf("Macro mode is not enabled.");
789 }
790 }
791 }
792
793 /**
794 * @tc.name: SUB_Driver_Camera_Macro_0300
795 * @tc.desc: macro mode CAPTURE_MACRO
796 * @tc.size: MediumTest
797 * @tc.type: Function
798 */
799 HWTEST_F(CameraHdiTestV1_2, SUB_Driver_Camera_Macro_0300, TestSize.Level1)
800 {
801 CAMERA_LOGI("test SUB_Driver_Camera_Macro_0300 start ...");
802 // Get Stream Operator
803 cameraTest->streamOperatorCallback = new OHOS::Camera::Test::TestStreamOperatorCallback();
804 cameraTest->rc = cameraTest->cameraDeviceV1_1->GetStreamOperator_V1_1(cameraTest->streamOperatorCallback,
805 cameraTest->streamOperator_V1_1);
806 EXPECT_NE(cameraTest->streamOperator_V1_1, nullptr);
807 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
808
809 // preview streamInfo
810 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
811 cameraTest->DefaultInfosPreview(cameraTest->streamInfoV1_1);
812 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
813
814 // capture streamInfo
815 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
816 cameraTest->DefaultInfosCapture(cameraTest->streamInfoV1_1);
817 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
818
819 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
820 float zoomRatio = 15;
821 uint8_t macroControl = OHOS_CAMERA_MACRO_ENABLE;
822 meta->addEntry(OHOS_CONTROL_ZOOM_RATIO, &zoomRatio, DATA_COUNT);
823 meta->addEntry(OHOS_CONTROL_CAMERA_MACRO, ¯oControl, DATA_COUNT);
824 std::vector<uint8_t> setting;
825 MetadataUtils::ConvertMetadataToVec(meta, setting);
826 cameraTest->rc = (CamRetCode)cameraTest->cameraDevice->UpdateSettings(setting);
827 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
828 // is streams supported V1_1
829 StreamSupportType pType;
830 cameraTest->rc = cameraTest->streamOperator_V1_1->IsStreamsSupported_V1_1(
831 static_cast<OHOS::HDI::Camera::V1_1::OperationMode_V1_1>(OHOS::HDI::Camera::V1_2::CAPTURE_MACRO),
832 setting, cameraTest->streamInfosV1_1, pType);
833 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
834
835 cameraTest->rc = cameraTest->streamOperator_V1_1->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
836 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
837 cameraTest->rc = cameraTest->streamOperator_V1_1->CommitStreams_V1_1(
838 static_cast<OHOS::HDI::Camera::V1_1::OperationMode_V1_1>(OHOS::HDI::Camera::V1_2::CAPTURE_MACRO),
839 cameraTest->abilityVec);
840 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
841
842 sleep(UT_SECOND_TIMES);
843 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
844 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
845 cameraTest->captureIds = {cameraTest->captureIdPreview};
846 cameraTest->streamIds = {cameraTest->streamIdPreview};
847 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
848 }
849
850 /**
851 * @tc.name: SUB_Driver_Camera_Macro_0400
852 * @tc.desc: macro mode VIDEO_MACRO
853 * @tc.size: MediumTest
854 * @tc.type: Function
855 */
856 HWTEST_F(CameraHdiTestV1_2, SUB_Driver_Camera_Macro_0400, TestSize.Level1)
857 {
858 CAMERA_LOGI("test SUB_Driver_Camera_Macro_0400 start ...");
859 // Get Stream Operator
860 cameraTest->streamOperatorCallback = new OHOS::Camera::Test::TestStreamOperatorCallback();
861 cameraTest->rc = cameraTest->cameraDeviceV1_1->GetStreamOperator_V1_1(cameraTest->streamOperatorCallback,
862 cameraTest->streamOperator_V1_1);
863 EXPECT_NE(cameraTest->streamOperator_V1_1, nullptr);
864 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
865 // preview streamInfo
866 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
867 cameraTest->DefaultInfosPreview(cameraTest->streamInfoV1_1);
868 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
869 // video streamInfo
870 cameraTest->streamInfoVideo = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
871 cameraTest->DefaultInfosVideo(cameraTest->streamInfoVideo);
872 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoVideo);
873 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
874 float zoomRatio = 15;
875 uint8_t macroControl = OHOS_CAMERA_MACRO_ENABLE;
876 meta->addEntry(OHOS_CONTROL_ZOOM_RATIO, &zoomRatio, DATA_COUNT);
877 meta->addEntry(OHOS_CONTROL_CAMERA_MACRO, ¯oControl, DATA_COUNT);
878 std::vector<uint8_t> setting;
879 MetadataUtils::ConvertMetadataToVec(meta, setting);
880 cameraTest->rc = (CamRetCode)cameraTest->cameraDevice->UpdateSettings(setting);
881 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
882 // is streams supported V1_1
883 StreamSupportType tType;
884 cameraTest->rc = cameraTest->streamOperator_V1_1->IsStreamsSupported_V1_1(
885 static_cast<OHOS::HDI::Camera::V1_1::OperationMode_V1_1>(OHOS::HDI::Camera::V1_2::VIDEO_MACRO),
886 setting, cameraTest->streamInfosV1_1, tType);
887 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
888 cameraTest->rc = cameraTest->streamOperator_V1_1->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
889 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
890 cameraTest->rc = cameraTest->streamOperator_V1_1->CommitStreams_V1_1(
891 static_cast<OHOS::HDI::Camera::V1_1::OperationMode_V1_1>(OHOS::HDI::Camera::V1_2::VIDEO_MACRO),
892 cameraTest->abilityVec);
893 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
894 sleep(UT_SECOND_TIMES);
895 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
896 cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true);
897 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo};
898 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo};
899 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
900 }
901
902 /**
903 * @tc.name: NotifyDeviceStateChangeInfo
904 * @tc.desc: notifyType fallingState deviceState fallingState
905 * @tc.size: MediumTest
906 * @tc.type: Function
907 */
908 HWTEST_F(CameraHdiTestV1_2, SUB_Driver_Camera_NotifyDevice_0100, TestSize.Level1)
909 {
910 int32_t notifyType = 1;
911 int32_t deviceState = 1008;
912 cameraTest->rc = cameraTest->serviceV1_2->NotifyDeviceStateChangeInfo(notifyType, deviceState);
913 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
914 }
915
916 /**
917 * @tc.name: NotifyDeviceStateChangeInfo
918 * @tc.desc: notifyType foldState deviceState unknown
919 * @tc.size: MediumTest
920 * @tc.type: Function
921 */
922 HWTEST_F(CameraHdiTestV1_2, SUB_Driver_Camera_NotifyDevice_0200, TestSize.Level1)
923 {
924 int32_t notifyType = 2;
925 int32_t deviceState = 0;
926 cameraTest->rc = cameraTest->serviceV1_2->NotifyDeviceStateChangeInfo(notifyType, deviceState);
927 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
928 }
929
930 /**
931 * @tc.name: NotifyDeviceStateChangeInfo
932 * @tc.desc: notifyType foldState deviceState expand
933 * @tc.size: MediumTest
934 * @tc.type: Function
935 */
936 HWTEST_F(CameraHdiTestV1_2, SUB_Driver_Camera_NotifyDevice_0300, TestSize.Level1)
937 {
938 int32_t notifyType = 2;
939 int32_t deviceState = 1;
940 cameraTest->rc = cameraTest->serviceV1_2->NotifyDeviceStateChangeInfo(notifyType, deviceState);
941 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
942 }
943
944 /**
945 * @tc.name: NotifyDeviceStateChangeInfo
946 * @tc.desc: notifyType foldState deviceState folded
947 * @tc.size: MediumTest
948 * @tc.type: Function
949 */
950 HWTEST_F(CameraHdiTestV1_2, SUB_Driver_Camera_NotifyDevice_0400, TestSize.Level1)
951 {
952 int32_t notifyType = 2;
953 int32_t deviceState = 2;
954 cameraTest->rc = cameraTest->serviceV1_2->NotifyDeviceStateChangeInfo(notifyType, deviceState);
955 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
956 }
957
958 /**
959 * @tc.name: NotifyDeviceStateChangeInfo
960 * @tc.desc: notifyType foldState deviceState halfFolded
961 * @tc.size: MediumTest
962 * @tc.type: Function
963 */
964 HWTEST_F(CameraHdiTestV1_2, SUB_Driver_Camera_NotifyDevice_0500, TestSize.Level1)
965 {
966 int32_t notifyType = 2;
967 int32_t deviceState = 3;
968 cameraTest->rc = cameraTest->serviceV1_2->NotifyDeviceStateChangeInfo(notifyType, deviceState);
969 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::INVALID_ARGUMENT);
970 }
971
972 /**
973 * @tc.name: NotifyDeviceStateChangeInfo
974 * @tc.desc: notifyType foldState deviceState error
975 * @tc.size: MediumTest
976 * @tc.type: Function
977 */
978 HWTEST_F(CameraHdiTestV1_2, SUB_Driver_Camera_NotifyDevice_0600, TestSize.Level1)
979 {
980 int32_t notifyType = 2;
981 int32_t deviceState = 10;
982 cameraTest->rc = cameraTest->serviceV1_2->NotifyDeviceStateChangeInfo(notifyType, deviceState);
983 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::INVALID_ARGUMENT);
984 }
985
986 /**
987 * @tc.name: CommitStreams_V1_1_SUPER_STAB
988 * @tc.desc: CommitStreams_V1_1 for super stabilization mode, preview and video
989 * @tc.size: MediumTest
990 * @tc.type: Function
991 */
UpdateSettingsForSuperStabMode(std::shared_ptr<OHOS::Camera::Test> cameraTest)992 static void UpdateSettingsForSuperStabMode(std::shared_ptr<OHOS::Camera::Test> cameraTest)
993 {
994 bool isTagExitst = cameraTest->IsTagValueExistsU8(cameraTest->ability,
995 OHOS_ABILITY_VIDEO_STABILIZATION_MODES,
996 OHOS_CAMERA_VIDEO_STABILIZATION_HIGH);
997 if (!isTagExitst) {
998 GTEST_SKIP() << "skip this test, because stabilization tag not found" << std::endl;
999 return;
1000 }
1001 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
1002 uint8_t stabControl = OHOS_CAMERA_VIDEO_STABILIZATION_HIGH;
1003 meta->addEntry(OHOS_CONTROL_VIDEO_STABILIZATION_MODE, &stabControl, DATA_COUNT);
1004 // ability meta data serialization for updating
1005 std::vector<uint8_t> setting;
1006 MetadataUtils::ConvertMetadataToVec(meta, setting);
1007 cameraTest->rc = (CamRetCode)cameraTest->cameraDevice->UpdateSettings(setting);
1008 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1009 CAMERA_LOGD("Macro mode is set enabled.");
1010 }
1011
1012 HWTEST_F(CameraHdiTestV1_2, SUB_Driver_Camera_SteadyShot_0300, TestSize.Level1)
1013 {
1014 // Get Stream Operator
1015 cameraTest->streamOperatorCallback = new OHOS::Camera::Test::TestStreamOperatorCallback();
1016 cameraTest->rc = cameraTest->cameraDeviceV1_1->GetStreamOperator_V1_1(cameraTest->streamOperatorCallback,
1017 cameraTest->streamOperator_V1_1);
1018 EXPECT_NE(cameraTest->streamOperator_V1_1, nullptr);
1019 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1020 // preview streamInfo
1021 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
1022 cameraTest->DefaultInfosPreview(cameraTest->streamInfoV1_1);
1023 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
1024 // video streamInfo
1025 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
1026 cameraTest->DefaultInfosVideo(cameraTest->streamInfoV1_1);
1027 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
1028 // Capture streamInfo
1029 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
1030 cameraTest->DefaultInfosCapture(cameraTest->streamInfoV1_1);
1031 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
1032 // create and commitstreams
1033 UpdateSettingsForSuperStabMode(cameraTest);
1034 cameraTest->imageDataSaveSwitch = SWITCH_ON;
1035 cameraTest->rc = cameraTest->streamOperator_V1_1->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
1036 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1037 cameraTest->rc = cameraTest->streamOperator_V1_1->CommitStreams_V1_1(
1038 static_cast<OHOS::HDI::Camera::V1_1::OperationMode_V1_1>(OHOS::HDI::Camera::V1_2::NORMAL),
1039 cameraTest->abilityVec);
1040 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1041 // start preview, video and capture
1042 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
1043 cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true);
1044 // wait to stop
1045 uint32_t waitTime = 0;
1046 auto envStr = getenv("UT_SUPER_STAB_KEEP_SECOND");
1047 if (envStr != nullptr) {
1048 waitTime = atoi(envStr);
1049 }
1050 waitTime = (waitTime > 0 && waitTime < UT_SECOND_TIMES_MAX) ? waitTime : UT_SECOND_TIMES;
1051 sleep(waitTime);
1052 // stop stream
1053 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo};
1054 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo};
1055 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
1056 }
1057
1058 /**
1059 * @tc.name: SUB_Driver_Camera_Sketch_0300
1060 * @tc.desc: sketch
1061 * @tc.size: MediumTest
1062 * @tc.type: Function
1063 */
1064 HWTEST_F(CameraHdiTestV1_2, SUB_Driver_Camera_Sketch_0300, TestSize.Level1)
1065 {
1066 CAMERA_LOGI("test Camera_Device_Hdi_V1_2_003 start");
1067 cameraTest->streamOperatorCallback = new OHOS::Camera::Test::TestStreamOperatorCallback();
1068 cameraTest->rc = cameraTest->cameraDeviceV1_1->GetStreamOperator_V1_1(
1069 cameraTest->streamOperatorCallback, cameraTest->streamOperator_V1_1);
1070 EXPECT_NE(cameraTest->streamOperator_V1_1, nullptr);
1071 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1072
1073 // preview streamInfo
1074 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
1075 cameraTest->DefaultInfosPreviewV1_2(cameraTest->streamInfoV1_1);
1076 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
1077
1078 // sketch streamInfo
1079 cameraTest->streamInfoSketch = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
1080 // sketch extended streamInfo
1081 OHOS::HDI::Camera::V1_1::ExtendedStreamInfo extendedStreamInfo {
1082 .type = static_cast<OHOS::HDI::Camera::V1_1::ExtendedStreamInfoType>(
1083 OHOS::HDI::Camera::V1_2::EXTENDED_STREAM_INFO_SKETCH),
1084 .width = 0,
1085 .height = 0,
1086 .format = 0,
1087 .dataspace = 0,
1088 .bufferQueue = nullptr
1089 };
1090 cameraTest->streamInfoSketch->extendedStreamInfos = {extendedStreamInfo};
1091 cameraTest->DefaultInfosSketch(cameraTest->streamInfoSketch);
1092 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoSketch);
1093
1094 std::shared_ptr<CameraSetting> modeSetting = std::make_shared<CameraSetting>(100, 200);
1095 float zoomRatio = 20;
1096 modeSetting->addEntry(OHOS_CONTROL_ZOOM_RATIO, &zoomRatio, 1);
1097 std::vector<uint8_t> metaVec;
1098 MetadataUtils::ConvertMetadataToVec(modeSetting, metaVec);
1099 cameraTest->cameraDeviceV1_1->UpdateSettings(metaVec);
1100
1101 // capture streamInfo
1102 cameraTest->streamInfoCapture = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
1103 cameraTest->DefaultInfosCapture(cameraTest->streamInfoCapture);
1104 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoCapture);
1105
1106 cameraTest->rc = cameraTest->streamOperator_V1_1->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
1107 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1108 cameraTest->rc = cameraTest->streamOperator_V1_1->CommitStreams(
1109 OperationMode::NORMAL, cameraTest->abilityVec);
1110 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1111 sleep(UT_SECOND_TIMES);
1112 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
1113 cameraTest->StartCapture(cameraTest->streamIdSketch, cameraTest->captureIdSketch, false, true);
1114 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
1115 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdSketch};
1116 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdSketch};
1117 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
1118 }
1119
1120 /**
1121 * @tc.name: SUB_Driver_Camera_Sketch_0400
1122 * @tc.desc: sketch
1123 * @tc.size: MediumTest
1124 * @tc.type: Function
1125 */
1126 HWTEST_F(CameraHdiTestV1_2, SUB_Driver_Camera_Sketch_0400, TestSize.Level1)
1127 {
1128 CAMERA_LOGI("test Camera_Device_Hdi_V1_2_003 start");
1129 cameraTest->streamOperatorCallback = new OHOS::Camera::Test::TestStreamOperatorCallback();
1130 cameraTest->rc = cameraTest->cameraDeviceV1_1->GetStreamOperator_V1_1(
1131 cameraTest->streamOperatorCallback, cameraTest->streamOperator_V1_1);
1132 EXPECT_NE(cameraTest->streamOperator_V1_1, nullptr);
1133 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1134 // preview streamInfo
1135 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
1136 cameraTest->DefaultInfosPreviewV1_2(cameraTest->streamInfoV1_1);
1137 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
1138 // sketch streamInfo
1139 cameraTest->streamInfoSketch = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
1140 // sketch extended streamInfo
1141 OHOS::HDI::Camera::V1_1::ExtendedStreamInfo extendedStreamInfo {
1142 .type = static_cast<OHOS::HDI::Camera::V1_1::ExtendedStreamInfoType>(
1143 OHOS::HDI::Camera::V1_2::EXTENDED_STREAM_INFO_SKETCH),
1144 .width = 0,
1145 .height = 0,
1146 .format = 0,
1147 .dataspace = 0,
1148 .bufferQueue = nullptr
1149 };
1150 cameraTest->streamInfoSketch->extendedStreamInfos = {extendedStreamInfo};
1151 cameraTest->DefaultInfosSketch(cameraTest->streamInfoSketch);
1152 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoSketch);
1153 std::shared_ptr<CameraSetting> modeSetting = std::make_shared<CameraSetting>(100, 200);
1154 float zoomRatio = 3;
1155 modeSetting->addEntry(OHOS_CONTROL_ZOOM_RATIO, &zoomRatio, 1);
1156 std::vector<uint8_t> metaVec;
1157 MetadataUtils::ConvertMetadataToVec(modeSetting, metaVec);
1158 cameraTest->cameraDeviceV1_1->UpdateSettings(metaVec);
1159 // capture streamInfo
1160 cameraTest->streamInfoCapture = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
1161 cameraTest->DefaultInfosCapture(cameraTest->streamInfoCapture);
1162 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoCapture);
1163
1164 cameraTest->rc = cameraTest->streamOperator_V1_1->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
1165 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1166 cameraTest->rc = cameraTest->streamOperator_V1_1->CommitStreams(
1167 OperationMode::NORMAL, cameraTest->abilityVec);
1168 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1169 sleep(UT_SECOND_TIMES);
1170 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
1171 cameraTest->StartCapture(cameraTest->streamIdSketch, cameraTest->captureIdSketch, false, true);
1172 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
1173 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdSketch};
1174 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdSketch};
1175 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
1176 }