1 /*
2 * Copyright (c) 2024-2025 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_2->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 if (colorSpaces == OHOS_CAMERA_BT2020_HLG_FULL) {
453 cameraTest->streamInfoV1_1->v1_0.format_ = OHOS::GRAPHIC_PIXEL_FMT_YCBCR_P010; // 10bit
454 }
455 cameraTest->streamInfoV1_1->v1_0.dataspace_ = colorSpaces;
456 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
457 // capture streamInfo
458 cameraTest->streamInfoCapture = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
459 cameraTest->DefaultInfosCapture(cameraTest->streamInfoCapture);
460 cameraTest->streamInfoCapture->v1_0.dataspace_ = colorSpaces;
461 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoCapture);
462 cameraTest->rc = cameraTest->streamOperator_V1_1->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
463 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
464 cameraTest->rc = cameraTest->streamOperator_V1_1->CommitStreams(
465 OperationMode::NORMAL, cameraTest->abilityVec);
466 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
467 sleep(UT_SECOND_TIMES);
468 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
469 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
470 cameraTest->captureIds = {cameraTest->captureIdPreview};
471 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
472 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
473 cameraTest->streamInfosV1_1.clear();
474 }
475 }
476 }
477
VideoByColorSpaces(std::vector<int32_t> videoColorSpaces,std::vector<int32_t> previewColorSpaces,std::shared_ptr<OHOS::Camera::Test> cameraTest)478 void VideoByColorSpaces(std::vector<int32_t> videoColorSpaces, std::vector<int32_t> previewColorSpaces,
479 std::shared_ptr<OHOS::Camera::Test> cameraTest)
480 {
481 cameraTest->imageDataSaveSwitch = SWITCH_ON;
482
483 if (videoColorSpaces.empty() || previewColorSpaces.empty()) {
484 printf("ColorSpaces empty is null\n");
485 return;
486 }
487 for (int32_t colorSpaces : previewColorSpaces) {
488 printf("preview colorSpaces value %d\n", colorSpaces);
489
490 // preview streamInfo
491 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
492 cameraTest->DefaultInfosPreview(cameraTest->streamInfoV1_1);
493 cameraTest->streamInfoV1_1->v1_0.dataspace_ = colorSpaces;
494 if (colorSpaces == CM_BT2020_HLG_LIMIT) {
495 cameraTest->streamInfoV1_1->v1_0.format_ = OHOS::GRAPHIC_PIXEL_FMT_YCBCR_P010; // 10bit
496 }
497
498 // video streamInfo
499 for (int32_t colorSpaces_ : videoColorSpaces) {
500 printf("video colorSpaces_ value %d\n", colorSpaces_);
501 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
502
503 cameraTest->streamInfoVideo = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
504 cameraTest->DefaultInfosVideo(cameraTest->streamInfoVideo);
505 cameraTest->streamInfoVideo->v1_0.format_ = cameraTest->streamInfoV1_1->v1_0.format_; // equal to preview
506 cameraTest->streamInfoVideo->v1_0.dataspace_ = colorSpaces_;
507 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoVideo);
508 cameraTest->rc = cameraTest->streamOperator_V1_1->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
509 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
510 cameraTest->rc = cameraTest->streamOperator_V1_1->CommitStreams(
511 static_cast<OHOS::HDI::Camera::V1_0::OperationMode>(OHOS::HDI::Camera::V1_1::OperationMode_V1_1::VIDEO),
512 cameraTest->abilityVec);
513 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
514
515 //updateSettings
516 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
517 uint8_t videoStabiliMode = OHOS_CAMERA_VIDEO_STABILIZATION_AUTO;
518 meta->addEntry(OHOS_CONTROL_VIDEO_STABILIZATION_MODE, &videoStabiliMode, DATA_COUNT);
519 const int32_t deviceStreamId = cameraTest->streamIdPreview;
520 meta->addEntry(OHOS_CAMERA_STREAM_ID, &deviceStreamId, DATA_COUNT);
521 std::vector<uint8_t> setting;
522 MetadataUtils::ConvertMetadataToVec(meta, setting);
523 cameraTest->rc = (CamRetCode)cameraTest->cameraDevice->UpdateSettings(setting);
524 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
525 sleep(UT_SECOND_TIMES);
526
527 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
528 cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true);
529 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo};
530 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo};
531 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
532 cameraTest->streamInfosV1_1.clear();
533 sleep(1);
534 }
535 }
536 cameraTest->imageDataSaveSwitch = SWITCH_OFF;
537 }
538
SuperStubByColorSpaces(std::vector<int32_t> superStubColorSpaces,std::shared_ptr<OHOS::Camera::Test> cameraTest)539 void SuperStubByColorSpaces(std::vector<int32_t> superStubColorSpaces, std::shared_ptr<OHOS::Camera::Test> cameraTest)
540 {
541 if (!superStubColorSpaces.empty()) {
542 for (int32_t colorSpaces : superStubColorSpaces) {
543 printf("superStubColorSpaces colorSpaces value %d\n", colorSpaces);
544 // preview streamInfo
545 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
546 cameraTest->DefaultInfosPreview(cameraTest->streamInfoV1_1);
547 cameraTest->streamInfoV1_1->v1_0.dataspace_ = colorSpaces;
548 if (colorSpaces == CM_BT2020_HLG_LIMIT) {
549 cameraTest->streamInfoV1_1->v1_0.format_ = OHOS::GRAPHIC_PIXEL_FMT_YCBCR_P010; // 10bit
550 }
551 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
552 // video streamInfo
553 cameraTest->streamInfoVideo = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
554 cameraTest->DefaultInfosVideo(cameraTest->streamInfoVideo);
555 cameraTest->streamInfoVideo->v1_0.dataspace_ = colorSpaces;
556 cameraTest->streamInfoVideo->v1_0.format_ = cameraTest->streamInfoV1_1->v1_0.format_; // equal to preview
557 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoVideo);
558 cameraTest->rc = cameraTest->streamOperator_V1_1->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
559 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
560 cameraTest->rc = cameraTest->streamOperator_V1_1->CommitStreams_V1_1(
561 static_cast<OHOS::HDI::Camera::V1_1::OperationMode_V1_1>(OHOS::HDI::Camera::V1_2::SUPER_STAB),
562 cameraTest->abilityVec);
563 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
564 sleep(UT_SECOND_TIMES);
565 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
566 cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true);
567 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo};
568 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo};
569 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
570 cameraTest->streamInfosV1_1.clear();
571 }
572 }
573 }
574
575 /**
576 * @tc.name:SUB_Driver_Camera_Colorspace_0200
577 * @tc.desc: Update macro ability setting and check the callback
578 * @tc.size:MediumTest
579 * @tc.type:Function
580 */
581 HWTEST_F(CameraHdiTestV1_2, SUB_Driver_Camera_Colorspace_0200, TestSize.Level1)
582 {
583 cameraTest->streamOperatorCallback = new OHOS::Camera::Test::TestStreamOperatorCallback();
584 cameraTest->rc = cameraTest->cameraDeviceV1_2->GetStreamOperator_V1_1(
585 cameraTest->streamOperatorCallback, cameraTest->streamOperator_V1_1);
586 EXPECT_NE(cameraTest->streamOperator_V1_1, nullptr);
587 common_metadata_header_t* data = cameraTest->ability->get();
588 EXPECT_NE(data, nullptr);
589 camera_metadata_item_t entry;
590 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_AVAILABLE_COLOR_SPACES, &entry);
591 printf("OHOS_ABILITY_AVAILABLE_COLOR_SPACES value count %d\n", entry.count);
592 if (ret == HDI::Camera::V1_0::NO_ERROR && entry.data.i32 != nullptr && entry.count > 0) {
593 std::vector<int32_t> captureColorSpaces;
594 std::vector<int32_t> videoColorSpaces;
595 std::vector<int32_t> superStubColorSpaces;
596 std::vector<int32_t> previewColorSpaces;
597 int32_t operatorMode = -2;
598 for (size_t i = 0; i < entry.count - 1; i++) {
599 if (operatorMode == -2 && entry.data.i32[i] == HDI::Camera::V1_2::OperationMode_V1_2::CAPTURE) {
600 operatorMode = HDI::Camera::V1_2::OperationMode_V1_2::CAPTURE;
601 } else if (operatorMode == -2 && entry.data.i32[i] == HDI::Camera::V1_2::OperationMode_V1_2::VIDEO) {
602 operatorMode = HDI::Camera::V1_2::OperationMode_V1_2::VIDEO;
603 } else if (operatorMode == -2 && entry.data.i32[i] == HDI::Camera::V1_2::OperationMode_V1_2::SUPER_STAB) {
604 operatorMode = HDI::Camera::V1_2::OperationMode_V1_2::SUPER_STAB;
605 } else if (entry.data.i32[i] == -1 && operatorMode != -2 && entry.data.i32[i + 1] == -1) {
606 operatorMode = -2;
607 } else if (entry.data.i32[i] == -1 && operatorMode != -2 && entry.data.i32[i + 1] != -1) {
608 operatorMode = -1;
609 } else if (operatorMode == HDI::Camera::V1_2::OperationMode_V1_2::CAPTURE) {
610 captureColorSpaces.push_back(entry.data.i32[i]);
611 } else if (operatorMode == HDI::Camera::V1_2::OperationMode_V1_2::VIDEO) {
612 if (std::find(cameraTest->previewColorSpaces_.begin(), cameraTest->previewColorSpaces_.end(),
613 entry.data.i32[i]) != cameraTest->previewColorSpaces_.end()) {
614 previewColorSpaces.push_back(entry.data.i32[i]);
615 } else {
616 videoColorSpaces.push_back(entry.data.i32[i]);
617 }
618 } else if (operatorMode == HDI::Camera::V1_2::OperationMode_V1_2::SUPER_STAB) {
619 superStubColorSpaces.push_back(entry.data.i32[i]);
620 } else if (operatorMode == -2 && entry.data.i32[i] > 0) {
621 operatorMode = -1;
622 }
623 }
624 CaptureByColorSpaces(captureColorSpaces, cameraTest);
625 VideoByColorSpaces(videoColorSpaces, previewColorSpaces, cameraTest);
626 SuperStubByColorSpaces(superStubColorSpaces, cameraTest);
627 }
628 }
629
630 /**
631 * @tc.name: SUB_Driver_Camera_APERTURE_0500
632 * @tc.desc: OHOS_CONTROL_CAMERA_PHYSICAL_APERTURE_RANGE
633 * @tc.size: MediumTest
634 * @tc.type: Function
635 */
636 HWTEST_F(CameraHdiTestV1_2, SUB_Driver_Camera_APERTURE_0500, TestSize.Level1)
637 {
638 // Get Stream Operator
639 cameraTest->streamOperatorCallback = new OHOS::Camera::Test::TestStreamOperatorCallback();
640 cameraTest->rc = cameraTest->cameraDeviceV1_2->GetStreamOperator_V1_1(cameraTest->streamOperatorCallback,
641 cameraTest->streamOperator_V1_1);
642 EXPECT_NE(cameraTest->streamOperator_V1_1, nullptr);
643 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
644
645 // preview streamInfo
646 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
647 cameraTest->DefaultInfosPreview(cameraTest->streamInfoV1_1);
648 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
649
650 // capture streamInfo
651 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
652 cameraTest->DefaultInfosCapture(cameraTest->streamInfoV1_1);
653 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
654
655 // create and commitstreams
656 cameraTest->rc = cameraTest->streamOperator_V1_1->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
657 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
658 cameraTest->rc = cameraTest->streamOperator_V1_1->CommitStreams_V1_1(
659 static_cast<OHOS::HDI::Camera::V1_1::OperationMode_V1_1>(OHOS::HDI::Camera::V1_2::PORTRAIT),
660 cameraTest->abilityVec);
661 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
662
663 //update settings
664 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
665 float physicalApertureValue = 2;
666 meta->addEntry(OHOS_CONTROL_CAMERA_PHYSICAL_APERTURE_VALUE, &physicalApertureValue, DATA_COUNT);
667 std::vector<uint8_t> setting;
668 MetadataUtils::ConvertMetadataToVec(meta, setting);
669 cameraTest->rc = (CamRetCode)cameraTest->cameraDevice->UpdateSettings(setting);
670 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
671
672 // start capture
673 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
674 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, true);
675 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdCapture};
676 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
677 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
678 }
679
680 /**
681 * @tc.name: SUB_Driver_Camera_APERTURE_0600
682 * @tc.desc: OHOS_CONTROL_CAMERA_PHYSICAL_APERTURE_RANGE, all value
683 * @tc.size: MediumTest
684 * @tc.type: Function
685 */
686 HWTEST_F(CameraHdiTestV1_2, SUB_Driver_Camera_APERTURE_0600, TestSize.Level1)
687 {
688 EXPECT_NE(cameraTest->ability, nullptr);
689 common_metadata_header_t* data = cameraTest->ability->get();
690 EXPECT_NE(data, nullptr);
691 camera_metadata_item_t entry;
692 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_PHYSICAL_APERTURE_RANGE, &entry);
693 if (cameraTest->rc != 0) {
694 GTEST_SKIP() << "skip test, because OHOS_ABILITY_CAMERA_PHYSICAL_APERTURE_RANGE not supported now" << std::endl;
695 return;
696 }
697 if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.f != nullptr && entry.count > 0) {
698 float entryValues[] = { entry.data.f[3], entry.data.f[7], entry.data.f[8], entry.data.f[9], entry.data.f[10],
699 entry.data.f[14], entry.data.f[18] };
700 for (size_t i = 0; i < sizeof(entryValues) / sizeof(float); i++) {
701 // Get Stream Operator
702 cameraTest->streamOperatorCallback = new OHOS::Camera::Test::TestStreamOperatorCallback();
703 cameraTest->rc = cameraTest->cameraDeviceV1_2->GetStreamOperator_V1_1(cameraTest->streamOperatorCallback,
704 cameraTest->streamOperator_V1_1);
705 EXPECT_NE(cameraTest->streamOperator_V1_1, nullptr);
706 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
707
708 // preview streamInfo
709 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
710 cameraTest->DefaultInfosPreview(cameraTest->streamInfoV1_1);
711 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
712
713 // capture streamInfo
714 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
715 cameraTest->DefaultInfosCapture(cameraTest->streamInfoV1_1);
716 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
717
718 // create and commitstreams
719 cameraTest->rc = cameraTest->streamOperator_V1_1->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
720 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
721 cameraTest->rc = cameraTest->streamOperator_V1_1->CommitStreams_V1_1(
722 static_cast<OHOS::HDI::Camera::V1_1::OperationMode_V1_1>(OHOS::HDI::Camera::V1_2::PORTRAIT),
723 cameraTest->abilityVec);
724 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
725
726 //update settings
727 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
728 float physicalApertureValue = entryValues[i];
729 meta->addEntry(OHOS_CONTROL_CAMERA_PHYSICAL_APERTURE_VALUE, &physicalApertureValue, DATA_COUNT);
730 std::vector<uint8_t> setting;
731 MetadataUtils::ConvertMetadataToVec(meta, setting);
732 cameraTest->rc = (CamRetCode)cameraTest->cameraDevice->UpdateSettings(setting);
733 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
734
735 // start capture
736 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
737 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, true);
738
739 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdCapture};
740 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
741 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
742 sleep(1);
743 cameraTest->streamInfosV1_1.clear();
744 }
745 }
746 }
747
748 /**
749 * @tc.name:SUB_Driver_Camera_Macro_0200
750 * @tc.desc: Update macro ability setting and check the callback
751 * @tc.size:MediumTest
752 * @tc.type:Function
753 */
754 HWTEST_F(CameraHdiTestV1_2, SUB_Driver_Camera_Macro_0200, TestSize.Level1)
755 {
756 int32_t rc;
757 // step 2: set callback object
758 cameraTest->hostCallbackV1_2 = new OHOS::Camera::Test::TestCameraHostCallbackV1_2();
759 rc = cameraTest->serviceV1_2->SetCallback_V1_2(cameraTest->hostCallbackV1_2);
760 EXPECT_EQ(rc, 0);
761 // Start OHOS_ABILITY_CAMERA_MACRO_SUPPORTED ability query
762 common_metadata_header_t* data = cameraTest->ability->get();
763 EXPECT_NE(data, nullptr);
764 camera_metadata_item_t entry;
765 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_MACRO_SUPPORTED, &entry);
766
767 if (ret == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) {
768 cameraTest->intents = {PREVIEW, STILL_CAPTURE, VIDEO};
769 cameraTest->StartStream(cameraTest->intents);
770 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
771 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
772 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, true);
773 cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true);
774 sleep(1);
775 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdCapture,
776 cameraTest->captureIdVideo};
777 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture,
778 cameraTest->streamIdVideo};
779 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
780 sleep(UT_SECOND_TIMES);
781 common_metadata_header_t* data = cameraTest->deviceCallback->resultMeta->get();
782 EXPECT_NE(data, nullptr);
783 camera_metadata_item_t entry;
784 int ret = FindCameraMetadataItem(data, OHOS_CAMERA_MACRO_STATUS, &entry);
785 if (ret == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) {
786 uint8_t value = entry.data.u8[0];
787 // 查询到状态， 检测状态到 微距模式可开启
788 if (OHOS_CAMERA_MACRO_ENABLE == value) {
789 printf("Macro mode is set enabled.");
790 } else {
791 printf("Macro mode is not enabled.");
792 }
793 } else {
794 printf("Macro mode is not enabled.");
795 }
796 }
797 }
798
799 /**
800 * @tc.name: SUB_Driver_Camera_Macro_0300
801 * @tc.desc: macro mode CAPTURE_MACRO
802 * @tc.size: MediumTest
803 * @tc.type: Function
804 */
805 HWTEST_F(CameraHdiTestV1_2, SUB_Driver_Camera_Macro_0300, TestSize.Level1)
806 {
807 CAMERA_LOGI("test SUB_Driver_Camera_Macro_0300 start ...");
808 // Get Stream Operator
809 cameraTest->streamOperatorCallback = new OHOS::Camera::Test::TestStreamOperatorCallback();
810 cameraTest->rc = cameraTest->cameraDeviceV1_2->GetStreamOperator_V1_1(cameraTest->streamOperatorCallback,
811 cameraTest->streamOperator_V1_1);
812 EXPECT_NE(cameraTest->streamOperator_V1_1, nullptr);
813 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
814
815 // preview streamInfo
816 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
817 cameraTest->DefaultInfosPreview(cameraTest->streamInfoV1_1);
818 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
819
820 // capture streamInfo
821 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
822 cameraTest->DefaultInfosCapture(cameraTest->streamInfoV1_1);
823 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
824
825 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
826 float zoomRatio = 15;
827 uint8_t macroControl = OHOS_CAMERA_MACRO_ENABLE;
828 meta->addEntry(OHOS_CONTROL_ZOOM_RATIO, &zoomRatio, DATA_COUNT);
829 meta->addEntry(OHOS_CONTROL_CAMERA_MACRO, ¯oControl, DATA_COUNT);
830 std::vector<uint8_t> setting;
831 MetadataUtils::ConvertMetadataToVec(meta, setting);
832 cameraTest->rc = (CamRetCode)cameraTest->cameraDevice->UpdateSettings(setting);
833 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
834 // is streams supported V1_1
835 StreamSupportType pType;
836 cameraTest->rc = cameraTest->streamOperator_V1_1->IsStreamsSupported_V1_1(
837 static_cast<OHOS::HDI::Camera::V1_1::OperationMode_V1_1>(OHOS::HDI::Camera::V1_2::CAPTURE_MACRO),
838 setting, cameraTest->streamInfosV1_1, pType);
839 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
840
841 cameraTest->rc = cameraTest->streamOperator_V1_1->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
842 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
843 cameraTest->rc = cameraTest->streamOperator_V1_1->CommitStreams_V1_1(
844 static_cast<OHOS::HDI::Camera::V1_1::OperationMode_V1_1>(OHOS::HDI::Camera::V1_2::CAPTURE_MACRO),
845 cameraTest->abilityVec);
846 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
847
848 sleep(UT_SECOND_TIMES);
849 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
850 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
851 cameraTest->captureIds = {cameraTest->captureIdPreview};
852 cameraTest->streamIds = {cameraTest->streamIdPreview};
853 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
854 }
855
856 /**
857 * @tc.name: SUB_Driver_Camera_Macro_0400
858 * @tc.desc: macro mode VIDEO_MACRO
859 * @tc.size: MediumTest
860 * @tc.type: Function
861 */
862 HWTEST_F(CameraHdiTestV1_2, SUB_Driver_Camera_Macro_0400, TestSize.Level1)
863 {
864 CAMERA_LOGI("test SUB_Driver_Camera_Macro_0400 start ...");
865 // Get Stream Operator
866 cameraTest->streamOperatorCallback = new OHOS::Camera::Test::TestStreamOperatorCallback();
867 cameraTest->rc = cameraTest->cameraDeviceV1_2->GetStreamOperator_V1_1(cameraTest->streamOperatorCallback,
868 cameraTest->streamOperator_V1_1);
869 EXPECT_NE(cameraTest->streamOperator_V1_1, nullptr);
870 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
871 // preview streamInfo
872 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
873 cameraTest->DefaultInfosPreview(cameraTest->streamInfoV1_1);
874 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
875 // video streamInfo
876 cameraTest->streamInfoVideo = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
877 cameraTest->DefaultInfosVideo(cameraTest->streamInfoVideo);
878 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoVideo);
879 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
880 float zoomRatio = 15;
881 uint8_t macroControl = OHOS_CAMERA_MACRO_ENABLE;
882 meta->addEntry(OHOS_CONTROL_ZOOM_RATIO, &zoomRatio, DATA_COUNT);
883 meta->addEntry(OHOS_CONTROL_CAMERA_MACRO, ¯oControl, DATA_COUNT);
884 std::vector<uint8_t> setting;
885 MetadataUtils::ConvertMetadataToVec(meta, setting);
886 cameraTest->rc = (CamRetCode)cameraTest->cameraDevice->UpdateSettings(setting);
887 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
888 // is streams supported V1_1
889 StreamSupportType tType;
890 cameraTest->rc = cameraTest->streamOperator_V1_1->IsStreamsSupported_V1_1(
891 static_cast<OHOS::HDI::Camera::V1_1::OperationMode_V1_1>(OHOS::HDI::Camera::V1_2::VIDEO_MACRO),
892 setting, cameraTest->streamInfosV1_1, tType);
893 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
894 cameraTest->rc = cameraTest->streamOperator_V1_1->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
895 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
896 cameraTest->rc = cameraTest->streamOperator_V1_1->CommitStreams_V1_1(
897 static_cast<OHOS::HDI::Camera::V1_1::OperationMode_V1_1>(OHOS::HDI::Camera::V1_2::VIDEO_MACRO),
898 cameraTest->abilityVec);
899 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
900 sleep(UT_SECOND_TIMES);
901 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
902 cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true);
903 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo};
904 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo};
905 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
906 }
907
908 /**
909 * @tc.name: NotifyDeviceStateChangeInfo
910 * @tc.desc: notifyType fallingState deviceState fallingState
911 * @tc.size: MediumTest
912 * @tc.type: Function
913 */
914 HWTEST_F(CameraHdiTestV1_2, SUB_Driver_Camera_NotifyDevice_0100, TestSize.Level1)
915 {
916 int32_t notifyType = 1;
917 int32_t deviceState = 1008;
918 cameraTest->rc = cameraTest->serviceV1_2->NotifyDeviceStateChangeInfo(notifyType, deviceState);
919 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
920 }
921
922 /**
923 * @tc.name: NotifyDeviceStateChangeInfo
924 * @tc.desc: notifyType foldState deviceState unknown
925 * @tc.size: MediumTest
926 * @tc.type: Function
927 */
928 HWTEST_F(CameraHdiTestV1_2, SUB_Driver_Camera_NotifyDevice_0200, TestSize.Level1)
929 {
930 int32_t notifyType = 2;
931 int32_t deviceState = 0;
932 cameraTest->rc = cameraTest->serviceV1_2->NotifyDeviceStateChangeInfo(notifyType, deviceState);
933 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
934 }
935
936 /**
937 * @tc.name: NotifyDeviceStateChangeInfo
938 * @tc.desc: notifyType foldState deviceState expand
939 * @tc.size: MediumTest
940 * @tc.type: Function
941 */
942 HWTEST_F(CameraHdiTestV1_2, SUB_Driver_Camera_NotifyDevice_0300, TestSize.Level1)
943 {
944 int32_t notifyType = 2;
945 int32_t deviceState = 1;
946 cameraTest->rc = cameraTest->serviceV1_2->NotifyDeviceStateChangeInfo(notifyType, deviceState);
947 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
948 }
949
950 /**
951 * @tc.name: NotifyDeviceStateChangeInfo
952 * @tc.desc: notifyType foldState deviceState folded
953 * @tc.size: MediumTest
954 * @tc.type: Function
955 */
956 HWTEST_F(CameraHdiTestV1_2, SUB_Driver_Camera_NotifyDevice_0400, TestSize.Level1)
957 {
958 int32_t notifyType = 2;
959 int32_t deviceState = 2;
960 cameraTest->rc = cameraTest->serviceV1_2->NotifyDeviceStateChangeInfo(notifyType, deviceState);
961 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
962 }
963
964 /**
965 * @tc.name: NotifyDeviceStateChangeInfo
966 * @tc.desc: notifyType foldState deviceState halfFolded
967 * @tc.size: MediumTest
968 * @tc.type: Function
969 */
970 HWTEST_F(CameraHdiTestV1_2, SUB_Driver_Camera_NotifyDevice_0500, TestSize.Level1)
971 {
972 int32_t notifyType = 2;
973 int32_t deviceState = 3;
974 cameraTest->rc = cameraTest->serviceV1_2->NotifyDeviceStateChangeInfo(notifyType, deviceState);
975 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::INVALID_ARGUMENT);
976 }
977
978 /**
979 * @tc.name: NotifyDeviceStateChangeInfo
980 * @tc.desc: notifyType foldState deviceState error
981 * @tc.size: MediumTest
982 * @tc.type: Function
983 */
984 HWTEST_F(CameraHdiTestV1_2, SUB_Driver_Camera_NotifyDevice_0600, TestSize.Level1)
985 {
986 int32_t notifyType = 2;
987 int32_t deviceState = 10;
988 cameraTest->rc = cameraTest->serviceV1_2->NotifyDeviceStateChangeInfo(notifyType, deviceState);
989 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::INVALID_ARGUMENT);
990 }
991
992 /**
993 * @tc.name: CommitStreams_V1_1_SUPER_STAB
994 * @tc.desc: CommitStreams_V1_1 for super stabilization mode, preview and video
995 * @tc.size: MediumTest
996 * @tc.type: Function
997 */
UpdateSettingsForSuperStabMode(std::shared_ptr<OHOS::Camera::Test> cameraTest)998 static void UpdateSettingsForSuperStabMode(std::shared_ptr<OHOS::Camera::Test> cameraTest)
999 {
1000 bool isTagExitst = cameraTest->IsTagValueExistsU8(cameraTest->ability,
1001 OHOS_ABILITY_VIDEO_STABILIZATION_MODES,
1002 OHOS_CAMERA_VIDEO_STABILIZATION_HIGH);
1003 if (!isTagExitst) {
1004 GTEST_SKIP() << "skip this test, because stabilization tag not found" << std::endl;
1005 return;
1006 }
1007 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
1008 uint8_t stabControl = OHOS_CAMERA_VIDEO_STABILIZATION_HIGH;
1009 meta->addEntry(OHOS_CONTROL_VIDEO_STABILIZATION_MODE, &stabControl, DATA_COUNT);
1010 // ability meta data serialization for updating
1011 std::vector<uint8_t> setting;
1012 MetadataUtils::ConvertMetadataToVec(meta, setting);
1013 cameraTest->rc = (CamRetCode)cameraTest->cameraDevice->UpdateSettings(setting);
1014 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1015 CAMERA_LOGD("Macro mode is set enabled.");
1016 }
1017
1018 HWTEST_F(CameraHdiTestV1_2, SUB_Driver_Camera_SteadyShot_0300, TestSize.Level1)
1019 {
1020 // Get Stream Operator
1021 cameraTest->streamOperatorCallback = new OHOS::Camera::Test::TestStreamOperatorCallback();
1022 cameraTest->rc = cameraTest->cameraDeviceV1_2->GetStreamOperator_V1_1(cameraTest->streamOperatorCallback,
1023 cameraTest->streamOperator_V1_1);
1024 EXPECT_NE(cameraTest->streamOperator_V1_1, nullptr);
1025 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1026 // preview streamInfo
1027 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
1028 cameraTest->DefaultInfosPreview(cameraTest->streamInfoV1_1);
1029 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
1030 // video streamInfo
1031 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
1032 cameraTest->DefaultInfosVideo(cameraTest->streamInfoV1_1);
1033 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
1034 // Capture streamInfo
1035 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
1036 cameraTest->DefaultInfosCapture(cameraTest->streamInfoV1_1);
1037 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
1038 // create and commitstreams
1039 UpdateSettingsForSuperStabMode(cameraTest);
1040 cameraTest->imageDataSaveSwitch = SWITCH_ON;
1041 cameraTest->rc = cameraTest->streamOperator_V1_1->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
1042 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1043 cameraTest->rc = cameraTest->streamOperator_V1_1->CommitStreams_V1_1(
1044 static_cast<OHOS::HDI::Camera::V1_1::OperationMode_V1_1>(OHOS::HDI::Camera::V1_2::NORMAL),
1045 cameraTest->abilityVec);
1046 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1047 // start preview, video and capture
1048 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
1049 cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true);
1050 // wait to stop
1051 uint32_t waitTime = 0;
1052 auto envStr = getenv("UT_SUPER_STAB_KEEP_SECOND");
1053 if (envStr != nullptr) {
1054 waitTime = atoi(envStr);
1055 }
1056 waitTime = (waitTime > 0 && waitTime < UT_SECOND_TIMES_MAX) ? waitTime : UT_SECOND_TIMES;
1057 sleep(waitTime);
1058 // stop stream
1059 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo};
1060 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo};
1061 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
1062 }
1063
1064 /**
1065 * @tc.name: SUB_Driver_Camera_Sketch_0300
1066 * @tc.desc: sketch
1067 * @tc.size: MediumTest
1068 * @tc.type: Function
1069 */
1070 HWTEST_F(CameraHdiTestV1_2, SUB_Driver_Camera_Sketch_0300, TestSize.Level1)
1071 {
1072 CAMERA_LOGI("test Camera_Device_Hdi_V1_2_003 start");
1073 cameraTest->streamOperatorCallback = new OHOS::Camera::Test::TestStreamOperatorCallback();
1074 cameraTest->rc = cameraTest->cameraDeviceV1_2->GetStreamOperator_V1_1(
1075 cameraTest->streamOperatorCallback, cameraTest->streamOperator_V1_1);
1076 EXPECT_NE(cameraTest->streamOperator_V1_1, nullptr);
1077 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1078
1079 // preview streamInfo
1080 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
1081 cameraTest->DefaultInfosPreviewV1_2(cameraTest->streamInfoV1_1);
1082 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
1083
1084 // sketch streamInfo
1085 cameraTest->streamInfoSketch = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
1086 // sketch extended streamInfo
1087 OHOS::HDI::Camera::V1_1::ExtendedStreamInfo extendedStreamInfo {
1088 .type = static_cast<OHOS::HDI::Camera::V1_1::ExtendedStreamInfoType>(
1089 OHOS::HDI::Camera::V1_2::EXTENDED_STREAM_INFO_SKETCH),
1090 .width = 0,
1091 .height = 0,
1092 .format = 0,
1093 .dataspace = 0,
1094 .bufferQueue = nullptr
1095 };
1096 cameraTest->streamInfoSketch->extendedStreamInfos = {extendedStreamInfo};
1097 cameraTest->DefaultInfosSketch(cameraTest->streamInfoSketch);
1098 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoSketch);
1099
1100 std::shared_ptr<CameraSetting> modeSetting = std::make_shared<CameraSetting>(100, 200);
1101 float zoomRatio = 20;
1102 modeSetting->addEntry(OHOS_CONTROL_ZOOM_RATIO, &zoomRatio, 1);
1103 std::vector<uint8_t> metaVec;
1104 MetadataUtils::ConvertMetadataToVec(modeSetting, metaVec);
1105 cameraTest->cameraDeviceV1_2->UpdateSettings(metaVec);
1106
1107 // capture streamInfo
1108 cameraTest->streamInfoCapture = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
1109 cameraTest->DefaultInfosCapture(cameraTest->streamInfoCapture);
1110 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoCapture);
1111
1112 cameraTest->rc = cameraTest->streamOperator_V1_1->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
1113 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1114 cameraTest->rc = cameraTest->streamOperator_V1_1->CommitStreams(
1115 OperationMode::NORMAL, cameraTest->abilityVec);
1116 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1117 sleep(UT_SECOND_TIMES);
1118 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
1119 cameraTest->StartCapture(cameraTest->streamIdSketch, cameraTest->captureIdSketch, false, true);
1120 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
1121 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdSketch};
1122 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdSketch};
1123 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
1124 }
1125
1126 /**
1127 * @tc.name: SUB_Driver_Camera_Sketch_0400
1128 * @tc.desc: sketch
1129 * @tc.size: MediumTest
1130 * @tc.type: Function
1131 */
1132 HWTEST_F(CameraHdiTestV1_2, SUB_Driver_Camera_Sketch_0400, TestSize.Level1)
1133 {
1134 CAMERA_LOGI("test Camera_Device_Hdi_V1_2_003 start");
1135 cameraTest->streamOperatorCallback = new OHOS::Camera::Test::TestStreamOperatorCallback();
1136 cameraTest->rc = cameraTest->cameraDeviceV1_2->GetStreamOperator_V1_1(
1137 cameraTest->streamOperatorCallback, cameraTest->streamOperator_V1_1);
1138 EXPECT_NE(cameraTest->streamOperator_V1_1, nullptr);
1139 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1140 // preview streamInfo
1141 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
1142 cameraTest->DefaultInfosPreviewV1_2(cameraTest->streamInfoV1_1);
1143 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
1144 // sketch streamInfo
1145 cameraTest->streamInfoSketch = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
1146 // sketch extended streamInfo
1147 OHOS::HDI::Camera::V1_1::ExtendedStreamInfo extendedStreamInfo {
1148 .type = static_cast<OHOS::HDI::Camera::V1_1::ExtendedStreamInfoType>(
1149 OHOS::HDI::Camera::V1_2::EXTENDED_STREAM_INFO_SKETCH),
1150 .width = 0,
1151 .height = 0,
1152 .format = 0,
1153 .dataspace = 0,
1154 .bufferQueue = nullptr
1155 };
1156 cameraTest->streamInfoSketch->extendedStreamInfos = {extendedStreamInfo};
1157 cameraTest->DefaultInfosSketch(cameraTest->streamInfoSketch);
1158 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoSketch);
1159 std::shared_ptr<CameraSetting> modeSetting = std::make_shared<CameraSetting>(100, 200);
1160 float zoomRatio = 3;
1161 modeSetting->addEntry(OHOS_CONTROL_ZOOM_RATIO, &zoomRatio, 1);
1162 std::vector<uint8_t> metaVec;
1163 MetadataUtils::ConvertMetadataToVec(modeSetting, metaVec);
1164 cameraTest->cameraDeviceV1_2->UpdateSettings(metaVec);
1165 // capture streamInfo
1166 cameraTest->streamInfoCapture = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
1167 cameraTest->DefaultInfosCapture(cameraTest->streamInfoCapture);
1168 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoCapture);
1169
1170 cameraTest->rc = cameraTest->streamOperator_V1_1->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
1171 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1172 cameraTest->rc = cameraTest->streamOperator_V1_1->CommitStreams(
1173 OperationMode::NORMAL, cameraTest->abilityVec);
1174 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1175 sleep(UT_SECOND_TIMES);
1176 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
1177 cameraTest->StartCapture(cameraTest->streamIdSketch, cameraTest->captureIdSketch, false, true);
1178 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
1179 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdSketch};
1180 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdSketch};
1181 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
1182 }
1183