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