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_uttest_v1_3.h"
16 #include <functional>
17
18 using namespace OHOS;
19 using namespace std;
20 using namespace testing::ext;
21 using namespace OHOS::Camera;
22 constexpr uint32_t ITEM_CAPACITY = 100;
23 constexpr uint32_t DATA_CAPACITY = 2000;
24 constexpr uint32_t DATA_COUNT = 1;
25 constexpr uint32_t FPS_COUNT = 2;
26 constexpr uint32_t EXPOSURE_COUNT = 4;
27 constexpr uint32_t CHECK_AREA_COUNT = 4;
28 constexpr uint32_t STREAMINFO_WIDTH = 1920;
29 constexpr uint32_t STREAMINFO_HEIGHT = 1080;
30 constexpr uint32_t HIGH_RESOLUTION_PHOTO_WIDTH = 8192;
31 constexpr uint32_t HIGH_RESOLUTION_PHOTO_HEIGHT = 6144;
32 int64_t OHOS::Camera::Test::StreamConsumer::g_timestamp[2] = {0};
SetUpTestCase(void)33 void CameraHdiUtTestV1_3::SetUpTestCase(void) {}
TearDownTestCase(void)34 void CameraHdiUtTestV1_3::TearDownTestCase(void) {}
SetUp(void)35 void CameraHdiUtTestV1_3::SetUp(void)
36 {
37 cameraTest = std::make_shared<OHOS::Camera::Test>();
38 cameraTest->Init(); // assert inside
39 cameraTest->Open(DEVICE_0); // assert inside
40 }
41
TearDown(void)42 void CameraHdiUtTestV1_3::TearDown(void)
43 {
44 cameraTest->Close();
45 }
46
IsTagValueExistsU8(std::shared_ptr<CameraMetadata> ability,uint32_t tag,uint8_t value)47 bool IsTagValueExistsU8(std::shared_ptr<CameraMetadata> ability, uint32_t tag, uint8_t value)
48 {
49 common_metadata_header_t* data = ability->get();
50 camera_metadata_item_t entry;
51 int ret = FindCameraMetadataItem(data, tag, &entry);
52 if (ret == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) {
53 for (int i = 0; i < entry.count; i++) {
54 if (entry.data.u8[i] == value) {
55 return true;
56 }
57 }
58 } else {
59 printf("Find CameraMetadata fail!\n");
60 CAMERA_LOGE("Find CameraMetadata fail!");
61 }
62 return false;
63 }
64
PrintAllTagDataU8(std::shared_ptr<CameraMetadata> ability,uint32_t tag)65 void PrintAllTagDataU8(std::shared_ptr<CameraMetadata> ability, uint32_t tag)
66 {
67 common_metadata_header_t* data = ability->get();
68 camera_metadata_item_t entry;
69 int ret = FindCameraMetadataItem(data, tag, &entry);
70 if (ret == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) {
71 cout << "----tag = " << tag << "count = " << entry.count << endl;
72 for (int i = 0; i < entry.count; i++) {
73 int v = entry.data.u8[i];
74 cout << "tag[" << tag << "][" << i << "] = " << v << endl;
75 }
76 } else {
77 printf("Print tag data fail!\n");
78 CAMERA_LOGE("Print tag data fail!");
79 }
80 cout << "--------------------------------" << endl;
81 }
82
83 /**
84 * @tc.name: Camera_Device_Hdi_V1_3_001
85 * @tc.desc: Get and Print all data in OHOS_ABILITY_CAMERA_MODES
86 * @tc.size: MediumTest
87 * @tc.type: Function
88 */
89 HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_001, TestSize.Level1)
90 {
91 EXPECT_NE(cameraTest->ability, nullptr);
92 (void)ITEM_CAPACITY;
93 (void)DATA_CAPACITY;
94 (void)DATA_COUNT;
95 (void)FPS_COUNT;
96 (void)EXPOSURE_COUNT;
97 (void)CHECK_AREA_COUNT;
98 (void)STREAMINFO_WIDTH;
99 (void)STREAMINFO_HEIGHT;
100 (void)HIGH_RESOLUTION_PHOTO_WIDTH;
101 (void)HIGH_RESOLUTION_PHOTO_HEIGHT;
102 PrintAllTagDataU8(cameraTest->ability, OHOS_ABILITY_CAMERA_MODES);
103 }
104
CreateAndCommitStreamsForHighFrameRate(std::shared_ptr<OHOS::Camera::Test> cameraTest)105 static void CreateAndCommitStreamsForHighFrameRate(std::shared_ptr<OHOS::Camera::Test> cameraTest)
106 {
107 // Get stream operator
108 cameraTest->streamOperatorCallbackV1_3 = new OHOS::Camera::Test::TestStreamOperatorCallbackV1_3();
109 cameraTest->rc = cameraTest->cameraDeviceV1_3->GetStreamOperator_V1_3(cameraTest->streamOperatorCallbackV1_3,
110 cameraTest->streamOperator_V1_3);
111 EXPECT_NE(cameraTest->streamOperator_V1_3, nullptr);
112 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
113 // Preview streamInfo
114 cameraTest->streamInfoPre = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
115 cameraTest->DefaultInfosPreview(cameraTest->streamInfoPre);
116 cameraTest->streamInfoPre->v1_0.width_ = STREAMINFO_WIDTH;
117 cameraTest->streamInfoPre->v1_0.height_ = STREAMINFO_HEIGHT;
118 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoPre);
119 // Video streamInfo
120 cameraTest->streamInfoVideo = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
121 cameraTest->DefaultInfosVideo(cameraTest->streamInfoVideo);
122 cameraTest->streamInfoVideo->v1_0.width_ = STREAMINFO_WIDTH;
123 cameraTest->streamInfoVideo->v1_0.height_ = STREAMINFO_HEIGHT;
124 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoVideo);
125 // Create and commitStream
126 cameraTest->rc = cameraTest->streamOperator_V1_3->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
127 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
128 cameraTest->rc = cameraTest->streamOperator_V1_3->CommitStreams_V1_1(
129 static_cast<OHOS::HDI::Camera::V1_1::OperationMode_V1_1>(OHOS::HDI::Camera::V1_3::HIGH_FRAME_RATE),
130 cameraTest->abilityVec);
131 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
132 }
133
134 /**
135 * @tc.name: Camera_Device_Hdi_V1_3_002
136 * @tc.desc: Determine whether the HIGH_FRAME_RATE mode is supported
137 * @tc.size: MediumTest
138 * @tc.type: Function
139 */
140 HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_002, TestSize.Level1)
141 {
142 EXPECT_NE(cameraTest->ability, nullptr);
143 common_metadata_header_t* data = cameraTest->ability->get();
144 EXPECT_NE(data, nullptr);
145 camera_metadata_item_t entry;
146 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_MODES, &entry);
147 if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) {
148 EXPECT_TRUE(entry.data.u8 != nullptr);
149 for (size_t i = 0; i < entry.count; i++ ) {
150 uint8_t value = entry.data.u8[i];
151 if (value == OHOS::HDI::Camera::V1_3::HIGH_FRAME_RATE) {
152 CAMERA_LOGI("HIGH_FRAME_RATE mode is supported");
153 }
154 }
155 }
156 }
157
158 /**
159 * @tc.name: Camera_Device_Hdi_V1_3_003
160 * @tc.desc: CommitStreams_V1_1 for HIGH_FRAME_RATE, preview and video, fps is 120
161 * @tc.size: MediumTest
162 * @tc.type: Function
163 */
164 HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_003, TestSize.Level1)
165 {
166 if (!IsTagValueExistsU8(cameraTest->ability, OHOS_ABILITY_CAMERA_MODES, OHOS::HDI::Camera::V1_3::HIGH_FRAME_RATE)) {
167 cout << "skip this test, because HIGH_FRAME_RATE not in OHOS_ABILITY_CAMERA_MODES" << endl;
168 return;
169 }
170 cameraTest->imageDataSaveSwitch = SWITCH_ON;
171 CreateAndCommitStreamsForHighFrameRate(cameraTest);
172
173 // Update settings
174 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
175 int32_t highFrameRate[2] = {120, 120};
176 meta->addEntry(OHOS_CONTROL_FPS_RANGES, &highFrameRate, FPS_COUNT);
177 std::vector<uint8_t> setting;
178 MetadataUtils::ConvertMetadataToVec(meta, setting);
179 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
180 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
181
182 // Start capture
183 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
184 cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true);
185
186 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo};
187 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo};
188 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
189 sleep(DATA_COUNT);
190 cameraTest->streamInfosV1_1.clear();
191 cameraTest->imageDataSaveSwitch = SWITCH_OFF;
192 }
193
194 /**
195 * @tc.name: Camera_Device_Hdi_V1_3_004
196 * @tc.desc: CommitStreams_V1_1 for HIGH_FRAME_RATE, preview and video, fps is 240
197 * @tc.size: MediumTest
198 * @tc.type: Function
199 */
200 HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_004, TestSize.Level1)
201 {
202 if (!IsTagValueExistsU8(cameraTest->ability, OHOS_ABILITY_CAMERA_MODES, OHOS::HDI::Camera::V1_3::HIGH_FRAME_RATE)) {
203 cout << "skip this test, because HIGH_FRAME_RATE not in OHOS_ABILITY_CAMERA_MODES" << endl;
204 return;
205 }
206 cameraTest->imageDataSaveSwitch = SWITCH_ON;
207 CreateAndCommitStreamsForHighFrameRate(cameraTest);
208
209 // Update settings
210 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
211 int32_t highFrameRate[2] = {240, 240};
212 meta->addEntry(OHOS_CONTROL_FPS_RANGES, &highFrameRate, FPS_COUNT);
213 std::vector<uint8_t> setting;
214 MetadataUtils::ConvertMetadataToVec(meta, setting);
215 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
216 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
217
218 // Start capture
219 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
220 cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true);
221
222 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo};
223 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo};
224 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
225 sleep(DATA_COUNT);
226 cameraTest->streamInfosV1_1.clear();
227 cameraTest->imageDataSaveSwitch = SWITCH_OFF;
228 }
229
CreateAndCommitStreamsForSlowMotion(std::shared_ptr<OHOS::Camera::Test> cameraTest)230 static void CreateAndCommitStreamsForSlowMotion(std::shared_ptr<OHOS::Camera::Test> cameraTest)
231 {
232 // Get stream operator
233 cameraTest->streamOperatorCallbackV1_3 = new OHOS::Camera::Test::TestStreamOperatorCallbackV1_3();
234 cameraTest->rc = cameraTest->cameraDeviceV1_3->GetStreamOperator_V1_3(cameraTest->streamOperatorCallbackV1_3,
235 cameraTest->streamOperator_V1_3);
236 EXPECT_NE(cameraTest->streamOperator_V1_3, nullptr);
237 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
238 // Preview streamInfo
239 cameraTest->streamInfoPre = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
240 cameraTest->DefaultInfosPreview(cameraTest->streamInfoPre);
241 cameraTest->streamInfoPre->v1_0.width_ = STREAMINFO_WIDTH;
242 cameraTest->streamInfoPre->v1_0.height_ = STREAMINFO_HEIGHT;
243 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoPre);
244 // Video streamInfo
245 cameraTest->streamInfoVideo = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
246 cameraTest->DefaultInfosVideo(cameraTest->streamInfoVideo);
247 cameraTest->streamInfoVideo->v1_0.width_ = STREAMINFO_WIDTH;
248 cameraTest->streamInfoVideo->v1_0.height_ = STREAMINFO_HEIGHT;
249 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoVideo);
250 // Create and commitStream
251 cameraTest->rc = cameraTest->streamOperator_V1_3->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
252 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
253 cameraTest->rc = cameraTest->streamOperator_V1_3->CommitStreams_V1_1(
254 static_cast<OHOS::HDI::Camera::V1_1::OperationMode_V1_1>(OHOS::HDI::Camera::V1_2::SLOW_MOTION),
255 cameraTest->abilityVec);
256 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
257 }
258
UpdateSettingsForSlowMotionMode(std::shared_ptr<OHOS::Camera::Test> cameraTest)259 static void UpdateSettingsForSlowMotionMode(std::shared_ptr<OHOS::Camera::Test> cameraTest)
260 {
261 // Update settings
262 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
263 int32_t valueInvalid[2] = {240, 240};
264 float motionCheckArea[4] = {1, 1, 1, 1};
265 meta->addEntry(OHOS_CONTROL_FPS_RANGES, &valueInvalid, FPS_COUNT);
266 meta->addEntry(OHOS_CONTROL_MOTION_DETECTION_CHECK_AREA, &motionCheckArea, CHECK_AREA_COUNT);
267 std::vector<uint8_t> setting;
268 MetadataUtils::ConvertMetadataToVec(meta, setting);
269 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
270 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
271 int32_t slowMotionControl = OHOS_CAMERA_MOTION_DETECTION_ENABLE;
272 meta->addEntry(OHOS_CONTROL_MOTION_DETECTION, &slowMotionControl, DATA_COUNT);
273 MetadataUtils::ConvertMetadataToVec(meta, setting);
274 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
275 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
276
277 // Start capture
278 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
279 cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true);
280 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo};
281 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo};
282 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
283 }
284
SuperSlowMotionStatusCallback(std::shared_ptr<OHOS::Camera::Test> cameraTest)285 static void SuperSlowMotionStatusCallback(std::shared_ptr<OHOS::Camera::Test> cameraTest)
286 {
287 if (cameraTest->deviceCallback->resultMeta == nullptr) {
288 CAMERA_LOGI("callback not triggered");
289 return;
290 }
291 common_metadata_header_t* data = cameraTest->deviceCallback->resultMeta->get();
292 EXPECT_NE(data, nullptr);
293 camera_metadata_item_t entry;
294 cameraTest->rc = FindCameraMetadataItem(data, OHOS_STATUS_SLOW_MOTION_DETECTION, &entry);
295 if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) {
296 uint8_t value = entry.data.u8[0];
297 // Detect the state of super slow motion
298 if (value == OHOS_CONTROL_SLOW_MOTION_STATUS_DISABLE) {
299 CAMERA_LOGI("slow motion status is disabled");
300 } else if (value == OHOS_CONTROL_SLOW_MOTION_STATUS_READY) {
301 CAMERA_LOGI("slow motion status is ready");
302 } else if (value == OHOS_CONTROL_SLOW_MOTION_STATUS_START) {
303 CAMERA_LOGI("slow motion status is started");
304 } else if (value == OHOS_CONTROL_SLOW_MOTION_STATUS_RECORDING) {
305 CAMERA_LOGI("slow motion status is recording");
306 } else if (value == OHOS_CONTROL_SLOW_MOTION_STATUS_FINISH) {
307 CAMERA_LOGI("slow motion status is finished");
308 }
309 }
310 }
311 /**
312 * @tc.name: Camera_Device_Hdi_V1_3_005
313 * @tc.desc: Determine whether the SLOW_MOTION mode is supported
314 * @tc.size: MediumTest
315 * @tc.type: Function
316 */
317 HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_005, TestSize.Level1)
318 {
319 EXPECT_NE(cameraTest->ability, nullptr);
320 common_metadata_header_t* data = cameraTest->ability->get();
321 EXPECT_NE(data, nullptr);
322 camera_metadata_item_t entry;
323 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_MODES, &entry);
324 if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) {
325 EXPECT_TRUE(entry.data.u8 != nullptr);
326 for (size_t i = 0; i < entry.count; i++ ) {
327 uint8_t value = entry.data.u8[i];
328 if (value == OHOS::HDI::Camera::V1_2::SLOW_MOTION) {
329 CAMERA_LOGI("SLOW_MOTION mode is supported");
330 }
331 }
332 }
333 }
334
335 /**
336 * @tc.name: Camera_Device_Hdi_V1_3_006
337 * @tc.desc: CommitStreams_V1_1 for SLOW_MOTION, preview and video, fps is 960
338 * @tc.size: MediumTest
339 * @tc.type: Function
340 */
341 HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_006, TestSize.Level1)
342 {
343 if (!IsTagValueExistsU8(cameraTest->ability, OHOS_ABILITY_CAMERA_MODES, OHOS::HDI::Camera::V1_2::SLOW_MOTION)) {
344 cout << "skip this test, because SLOW_MOTION not in OHOS_ABILITY_CAMERA_MODES" << endl;
345 return;
346 }
347 cameraTest->imageDataSaveSwitch = SWITCH_ON;
348 CreateAndCommitStreamsForSlowMotion(cameraTest);
349
350 // Update settings
351 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
352 int32_t slowMotionValue[2] = {240, 240};
353 meta->addEntry(OHOS_CONTROL_FPS_RANGES, &slowMotionValue, FPS_COUNT);
354 std::vector<uint8_t> setting;
355 MetadataUtils::ConvertMetadataToVec(meta, setting);
356 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
357 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
358
359 // Start capture
360 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
361 cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true);
362
363 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo};
364 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo};
365 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
366 sleep(DATA_COUNT);
367 cameraTest->streamInfosV1_1.clear();
368 cameraTest->imageDataSaveSwitch = SWITCH_OFF;
369 }
370
371 /**
372 * @tc.name: Camera_Device_Hdi_V1_3_007
373 * @tc.desc: OHOS_ABILITY_MOTION_DETECTION_SUPPORT, OHOS_CAMERA_MOTION_DETECTION_SUPPORTED
374 * @tc.size: MediumTest
375 * @tc.type: Function
376 */
377 HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_007, TestSize.Level1)
378 {
379 if (!IsTagValueExistsU8(cameraTest->ability, OHOS_ABILITY_CAMERA_MODES, OHOS::HDI::Camera::V1_2::SLOW_MOTION)) {
380 cout << "skip this test, because SLOW_MOTION not in OHOS_ABILITY_CAMERA_MODES" << endl;
381 return;
382 }
383 // Set callback object
384 cameraTest->hostCallbackV1_2 = new OHOS::Camera::Test::TestCameraHostCallbackV1_2();
385 cameraTest->rc = cameraTest->serviceV1_3->SetCallback_V1_2(cameraTest->hostCallbackV1_2);
386 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
387 EXPECT_NE(cameraTest->ability, nullptr);
388 common_metadata_header_t* data = cameraTest->ability->get();
389 EXPECT_NE(data, nullptr);
390 camera_metadata_item_t entry;
391 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_MOTION_DETECTION_SUPPORT, &entry);
392 if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) {
393 EXPECT_TRUE(entry.data.u8 != nullptr);
394 if (entry.data.u8[0] == OHOS_CAMERA_MOTION_DETECTION_SUPPORTED) {
395 CreateAndCommitStreamsForSlowMotion(cameraTest);
396 UpdateSettingsForSlowMotionMode(cameraTest);
397 SuperSlowMotionStatusCallback(cameraTest);
398 }
399 }
400 }
401
CaptureByColorSpacesWithUpdateStreams(std::vector<int32_t> captureColorSpaces,std::shared_ptr<OHOS::Camera::Test> cameraTest)402 void CaptureByColorSpacesWithUpdateStreams(std::vector<int32_t> captureColorSpaces,
403 std::shared_ptr<OHOS::Camera::Test> cameraTest)
404 {
405 printf("Enter CaptureByColorSpacesWithUpdateStreams function!\n");
406 if (!captureColorSpaces.empty()) {
407 // Clear infos
408 cameraTest->streamInfosV1_1.clear();
409 // Preview streamInfo
410 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
411 cameraTest->DefaultInfosPreview(cameraTest->streamInfoV1_1);
412 cameraTest->streamInfoV1_1->v1_0.dataspace_ = captureColorSpaces[0];
413 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
414 // Capture streamInfo
415 cameraTest->streamInfoCapture = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
416 cameraTest->DefaultInfosCapture(cameraTest->streamInfoCapture);
417 cameraTest->streamInfoCapture->v1_0.dataspace_ = captureColorSpaces[0];
418 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoCapture);
419
420 // StreamInfosV1_1 should not be empty
421 cameraTest->rc = cameraTest->streamOperator_V1_3->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
422 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
423 cameraTest->rc = cameraTest->streamOperator_V1_3->CommitStreams_V1_1(
424 OHOS::HDI::Camera::V1_1::OperationMode_V1_1::NORMAL, cameraTest->abilityVec);
425 // Start without colorspace setting
426 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
427 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
428
429 for (int32_t colorSpaces : captureColorSpaces) {
430 printf("capture colorSpaces value %d\n", colorSpaces);
431 // CancelCapture
432 cameraTest->streamOperator_V1_3->CancelCapture(cameraTest->captureIdPreview);
433 // Clear infos
434 cameraTest->streamInfosV1_1.clear();
435 // Preview streamInfo
436 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
437 cameraTest->DefaultInfosPreview(cameraTest->streamInfoV1_1);
438 cameraTest->streamInfoV1_1->v1_0.dataspace_ = colorSpaces;
439 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
440 // Capture streamInfo
441 cameraTest->streamInfoCapture = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
442 cameraTest->DefaultInfosCapture(cameraTest->streamInfoCapture);
443 cameraTest->streamInfoCapture->v1_0.dataspace_ = colorSpaces;
444 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoCapture);
445 // UpdateStreams
446 cameraTest->rc = cameraTest->streamOperator_V1_3->UpdateStreams(cameraTest->streamInfosV1_1);
447 // Capture
448 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
449 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
450 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
451 sleep(UT_SECOND_TIMES);
452 }
453
454 // StopStream
455 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
456 }
457 }
458
459 /**
460 * @tc.name:Camera_Device_Hdi_V1_2_088
461 * @tc.desc: requirement hdr vivid ut
462 * @tc.size:MediumTest
463 * @tc.type:Function
464 */
465 HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_008, TestSize.Level1)
466 {
467 cameraTest->streamOperatorCallbackV1_3 = new OHOS::Camera::Test::TestStreamOperatorCallbackV1_3();
468 cameraTest->rc = cameraTest->cameraDeviceV1_3->GetStreamOperator_V1_3(
469 cameraTest->streamOperatorCallbackV1_3, cameraTest->streamOperator_V1_3);
470 EXPECT_NE(cameraTest->streamOperator_V1_3, nullptr);
471 common_metadata_header_t* data = cameraTest->ability->get();
472 EXPECT_NE(data, nullptr);
473 camera_metadata_item_t entry;
474 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_AVAILABLE_COLOR_SPACES, &entry);
475 printf("OHOS_ABILITY_AVAILABLE_COLOR_SPACES value count %d\n", entry.count);
476 if (ret == HDI::Camera::V1_0::NO_ERROR && entry.data.i32 != nullptr && entry.count > 0) {
477 std::vector<int32_t> captureColorSpaces;
478 int32_t operatorMode = -2;
479 for (size_t i = 0; i < entry.count - 1; i++) {
480 if (operatorMode == -2 && (entry.data.i32[i] == HDI::Camera::V1_2::OperationMode_V1_2::CAPTURE
481 || entry.data.i32[i] == HDI::Camera::V1_2::OperationMode_V1_2::VIDEO
482 || entry.data.i32[i] == HDI::Camera::V1_2::OperationMode_V1_2::SUPER_STAB)) {
483 operatorMode = entry.data.i32[i];
484 } else if (entry.data.i32[i] == -1 && operatorMode != -2 && entry.data.i32[i + 1] == -1) {
485 operatorMode = -2;
486 } else if (entry.data.i32[i] == -1 && operatorMode != -2 && entry.data.i32[i + 1] != -1) {
487 operatorMode = -1;
488 } else if (operatorMode == HDI::Camera::V1_2::OperationMode_V1_2::CAPTURE) {
489 captureColorSpaces.push_back(entry.data.i32[i]);
490 } else if (operatorMode == HDI::Camera::V1_2::OperationMode_V1_2::VIDEO ||
491 operatorMode == HDI::Camera::V1_2::OperationMode_V1_2::SUPER_STAB) {
492 continue;
493 } else if (operatorMode == -2 && entry.data.i32[i] > 0) {
494 operatorMode = -1;
495 }
496 }
497 CaptureByColorSpacesWithUpdateStreams(captureColorSpaces, cameraTest);
498 }
499 }
500
501 /**
502 * @tc.name: Camera_Device_Hdi_V1_3_008
503 * @tc.desc: OHOS_ABILITY_MOVING_PHOTO
504 * @tc.size: MediumTest
505 * @tc.type: Function
506 */
507 HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_009, TestSize.Level1)
508 {
509 EXPECT_NE(cameraTest->ability, nullptr);
510 common_metadata_header_t* data = cameraTest->ability->get();
511 EXPECT_NE(data, nullptr);
512 camera_metadata_item_t entry;
513
514 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_MOVING_PHOTO, &entry);
515 if (cameraTest->rc != HDI::Camera::V1_0::NO_ERROR) {
516 printf("OHOS_ABILITY_MOVING_PHOTO is not support");
517 return;
518 }
519 if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.i32 != nullptr && entry.count > 0) {
520 CAMERA_LOGI("print tag<OHOS_ABILITY_MOVING_PHOTO> i32 value start.");
521 printf("OHOS_ABILITY_MOVING_PHOTO i32 value count %d\n", entry.count);
522 constexpr size_t step = 10;
523 std::stringstream ss;
524 for (size_t i = 0; i < entry.count; i++) {
525 ss << entry.data.i32[i] << " ";
526 if ((i != 0) && (i % step == 0 || i == entry.count - 1)) {
527 CAMERA_LOGI("%{public}s\n", ss.str().c_str());
528 printf("OHOS_ABILITY_MOVING_PHOTO %s\n", ss.str().c_str());
529 ss.clear();
530 ss.str("");
531 }
532 }
533 CAMERA_LOGI("print tag<OHOS_ABILITY_MOVING_PHOTO> i32 value end.");
534 }
535 }
536
537 /**
538 * @tc.name:Camera_Device_Hdi_V1_3_011
539 * @tc.desc:CAPTURE_DURATION
540 * @tc.size:MediumTest
541 * @tc.type:Function
542 */
543 HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_011, TestSize.Level1)
544 {
545 EXPECT_NE(cameraTest->ability, nullptr);
546 common_metadata_header_t* data = cameraTest->ability->get();
547 EXPECT_NE(data, nullptr);
548 camera_metadata_item_t entry;
549 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_CAPTURE_DURATION_SUPPORTED, &entry);
550 if (cameraTest->rc != 0 || entry.data.u8[0] != 1) {
551 cout << "skip this test, because OHOS_ABILITY_CAPTURE_DURATION_SUPPORTED not supported now" << endl;
552 return;
553 }
554
555 // Start stream
556 cameraTest->intents = {PREVIEW, STILL_CAPTURE};
557 cameraTest->StartStream(cameraTest->intents);
558
559 // Fill capture setting
560 std::shared_ptr<CameraSetting> modeSetting = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
561 uint8_t muteMode = static_cast<uint8_t>(OHOS_CAMERA_MUTE_MODE_OFF);
562 modeSetting->addEntry(OHOS_CONTROL_MUTE_MODE, &muteMode, DATA_COUNT);
563 uint8_t deferredImage = OHOS::HDI::Camera::V1_2::STILL_IMAGE;
564 modeSetting->addEntry(OHOS_CONTROL_DEFERRED_IMAGE_DELIVERY, &deferredImage, DATA_COUNT);
565 std::vector<uint8_t> controlVec;
566 MetadataUtils::ConvertMetadataToVec(modeSetting, controlVec);
567 cameraTest->abilityVec = controlVec;
568
569 // Start preview and capture
570 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, true, true);
571 // OncaptureReady trigger
572 for (uint8_t i = 0; i < 2; i++) {
573 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
574 }
575
576 // Release stream
577 cameraTest->captureIds = {cameraTest->captureIdPreview};
578 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
579 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
580
581 sleep(UT_SECOND_TIMES);
582 common_metadata_header_t* callbackData = cameraTest->deviceCallback->resultMeta->get();
583 EXPECT_NE(callbackData, nullptr);
584 camera_metadata_item_t callbackEntry;
585 cameraTest->rc = FindCameraMetadataItem(callbackData, OHOS_CAMERA_CUSTOM_SNAPSHOT_DURATION, &callbackEntry);
586 if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.ui32 != nullptr && entry.count > 0) {
587 printf("currentSnapshotDuration = %d\n", callbackEntry.data.ui32[0]);
588 }
589 }
590
591 /**
592 * @tc.name:Camera_Device_Hdi_V1_3_012
593 * @tc.desc:OHOS_ABILITY_STREAM_AVAILABLE_EXTEND_CONFIGURATIONS
594 * @tc.size:MediumTest
595 * @tc.type:Function
596 */
597 HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_012, TestSize.Level1)
598 {
599 EXPECT_NE(cameraTest->ability, nullptr);
600 common_metadata_header_t* data = cameraTest->ability->get();
601 EXPECT_NE(data, nullptr);
602 camera_metadata_item_t entry;
603 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_STREAM_AVAILABLE_EXTEND_CONFIGURATIONS, &entry);
604 if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.i32 != nullptr && entry.count > 0) {
605 CAMERA_LOGE("print tag<OHOS_ABILITY_STREAM_AVAILABLE_EXTEND_CONFIGURATIONS> value start.");
606 constexpr size_t step = 10; // print step
607 std::stringstream ss;
608 for (size_t i = 0; i < entry.count; i++) {
609 ss << entry.data.i32[i] << " ";
610 if ((i != 0) && (i % step == 0 || i == entry.count - 1)) {
611 CAMERA_LOGE("%{public}s\n", ss.str().c_str());
612 ss.clear();
613 ss.str("");
614 }
615 }
616 CAMERA_LOGE("print tag<OHOS_ABILITY_STREAM_AVAILABLE_EXTEND_CONFIGURATIONS> value end.");
617 }
618 }
619
620 /**
621 * @tc.name: Camera_Device_Hdi_V1_3_013
622 * @tc.desc: OHOS_CONTROL_MOVING_PHOTO OHOS_CAMERA_MOVING_PHOTO_OFF
623 * @tc.size: MediumTest
624 * @tc.type: Function
625 */
626 HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_013, TestSize.Level1)
627 {
628 CAMERA_LOGI("test Camera_Device_Hdi_V1_3_013 start.");
629 cameraTest->streamOperatorCallbackV1_3 = new OHOS::Camera::Test::TestStreamOperatorCallbackV1_3();
630 cameraTest->rc = cameraTest->cameraDeviceV1_3->GetStreamOperator_V1_3(
631 cameraTest->streamOperatorCallbackV1_3, cameraTest->streamOperator_V1_3);
632 EXPECT_NE(cameraTest->streamOperator_V1_3, nullptr);
633
634 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
635 cameraTest->DefaultInfosPreview(cameraTest->streamInfoV1_1);
636 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
637
638 cameraTest->streamInfoCapture = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
639 cameraTest->DefaultInfosCapture(cameraTest->streamInfoCapture);
640 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoCapture);
641
642 std::shared_ptr<CameraSetting> modeSetting = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
643 uint8_t movingPhoto = static_cast<uint8_t>(OHOS_CAMERA_MOVING_PHOTO_OFF);
644 modeSetting->addEntry(OHOS_CONTROL_MOVING_PHOTO, &movingPhoto, 1);
645 std::vector<uint8_t> metaVec;
646 MetadataUtils::ConvertMetadataToVec(modeSetting, metaVec);
647 cameraTest->cameraDeviceV1_3->UpdateSettings(metaVec);
648
649 cameraTest->rc = cameraTest->streamOperator_V1_3->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
650 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
651 cameraTest->rc = cameraTest->streamOperator_V1_3->CommitStreams(OperationMode::NORMAL, cameraTest->abilityVec);
652 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
653
654 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
655 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
656 cameraTest->captureIds = {cameraTest->captureIdPreview};
657 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
658 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
659 }
660
661 /**
662 * @tc.name: Camera_Device_Hdi_V1_3_014
663 * @tc.desc: OHOS_CONTROL_MOVING_PHOTO OHOS_CAMERA_MOVING_PHOTO_ON
664 * @tc.size: MediumTest
665 * @tc.type: Function
666 */
667 HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_014, TestSize.Level1)
668 {
669 CAMERA_LOGI("test Camera_Device_Hdi_V1_3_014 start.");
670 cameraTest->streamOperatorCallbackV1_3 = new OHOS::Camera::Test::TestStreamOperatorCallbackV1_3();
671 cameraTest->rc = cameraTest->cameraDeviceV1_3->GetStreamOperator_V1_3(
672 cameraTest->streamOperatorCallbackV1_3, cameraTest->streamOperator_V1_3);
673 EXPECT_NE(cameraTest->streamOperator_V1_3, nullptr);
674
675 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
676 cameraTest->DefaultInfosPreview(cameraTest->streamInfoV1_1);
677 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
678
679 cameraTest->streamInfoCapture = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
680 cameraTest->DefaultInfosCapture(cameraTest->streamInfoCapture);
681 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoCapture);
682
683 std::shared_ptr<CameraSetting> modeSetting = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
684 uint8_t movingPhoto = static_cast<uint8_t>(OHOS_CAMERA_MOVING_PHOTO_ON);
685 modeSetting->addEntry(OHOS_CONTROL_MOVING_PHOTO, &movingPhoto, 1);
686 std::vector<uint8_t> metaVec;
687 MetadataUtils::ConvertMetadataToVec(modeSetting, metaVec);
688 cameraTest->cameraDeviceV1_3->UpdateSettings(metaVec);
689
690 cameraTest->rc = cameraTest->streamOperator_V1_3->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
691 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
692 cameraTest->rc = cameraTest->streamOperator_V1_3->CommitStreams(OperationMode::NORMAL, cameraTest->abilityVec);
693 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
694
695 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
696 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
697 cameraTest->captureIds = {cameraTest->captureIdPreview};
698 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
699 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
700 }
701
702 /**
703 * @tc.name:Camera_Device_Hdi_V1_3_015
704 * @tc.desc:OHOS_ABILITY_EQUIVALENT_FOCUS
705 * @tc.size:MediumTest
706 * @tc.type:Function
707 */
708 HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_015, TestSize.Level1)
709 {
710 EXPECT_NE(cameraTest->ability, nullptr);
711 common_metadata_header_t* data = cameraTest->ability->get();
712 EXPECT_NE(data, nullptr);
713 camera_metadata_item_t entry;
714 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_EQUIVALENT_FOCUS, &entry);
715 if (cameraTest->rc != HDI::Camera::V1_0::NO_ERROR) {
716 CAMERA_LOGI("OHOS_ABILITY_EQUIVALENT_FOCUS can not be find");
717 return;
718 }
719 if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR) {
720 EXPECT_NE(entry.data.i32, nullptr);
721 EXPECT_EQ(entry.count > 0, true);
722 CAMERA_LOGI("print tag<OHOS_ABILITY_EQUIVALENT_FOCUS> value start.");
723 constexpr size_t step = 10; // print step
724 std::stringstream ss;
725 for (size_t i = 0; i < entry.count; i++) {
726 ss << entry.data.i32[i] << " ";
727 if ((i != 0) && (i % step == 0 || i == entry.count - 1)) {
728 CAMERA_LOGI("%{public}s\n", ss.str().c_str());
729 ss.clear();
730 ss.str("");
731 }
732 }
733 CAMERA_LOGI("print tag<OHOS_ABILITY_EQUIVALENT_FOCUS> value end.");
734 }
735 }
736
737 /**
738 * @tc.name:Camera_Device_Hdi_V1_3_016
739 * @tc.desc:Determine whether the HIGH_RESOLUTION_PHOTO mode is supported
740 * @tc.size:MediumTest
741 * @tc.type:Function
742 */
743 HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_016, TestSize.Level1)
744 {
745 EXPECT_NE(cameraTest->ability, nullptr);
746 common_metadata_header_t* data = cameraTest->ability->get();
747 EXPECT_NE(data, nullptr);
748 camera_metadata_item_t entry;
749 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_MODES, &entry);
750 if (cameraTest->rc != HDI::Camera::V1_0::NO_ERROR) {
751 CAMERA_LOGI("OHOS_ABILITY_CAMERA_MODES is can not be found");
752 return;
753 }
754 if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR) {
755 EXPECT_NE(entry.data.u8, nullptr);
756 EXPECT_EQ(entry.count > 0, true);
757 for (size_t i = 0; i < entry.count; i++ ) {
758 uint8_t value = entry.data.u8[i];
759 if (value == OHOS::HDI::Camera::V1_3::HIGH_RESOLUTION_PHOTO) {
760 CAMERA_LOGI("HIGH_RESOLUTION_PHOTO mode is supported");
761 }
762 }
763 }
764 }
765
startStreamForHighResolutionPhoto(std::shared_ptr<OHOS::Camera::Test> cameraTest)766 static void startStreamForHighResolutionPhoto(std::shared_ptr<OHOS::Camera::Test> cameraTest)
767 {
768 // Get stream operator
769 cameraTest->streamOperatorCallbackV1_3 = new OHOS::Camera::Test::TestStreamOperatorCallbackV1_3();
770 cameraTest->rc = cameraTest->cameraDeviceV1_3->GetStreamOperator_V1_3(cameraTest->streamOperatorCallbackV1_3,
771 cameraTest->streamOperator_V1_3);
772 EXPECT_NE(cameraTest->streamOperator_V1_3, nullptr);
773 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
774
775 // Preview streamInfo
776 cameraTest->streamInfoPre = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
777 cameraTest->DefaultInfosPreview(cameraTest->streamInfoPre);
778 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoPre);
779
780 // Capture streamInfo
781 cameraTest->streamInfoCapture = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
782 cameraTest->DefaultInfosCapture(cameraTest->streamInfoCapture);
783 cameraTest->streamInfoCapture->v1_0.width_ = HIGH_RESOLUTION_PHOTO_WIDTH;
784 cameraTest->streamInfoCapture->v1_0.height_ = HIGH_RESOLUTION_PHOTO_HEIGHT;
785 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoCapture);
786
787 // Create and commit streams
788 cameraTest->rc = cameraTest->streamOperator_V1_3->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
789 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
790 cameraTest->rc = cameraTest->streamOperator_V1_3->CommitStreams_V1_1(
791 static_cast<OHOS::HDI::Camera::V1_1::OperationMode_V1_1>(OHOS::HDI::Camera::V1_3::HIGH_RESOLUTION_PHOTO),
792 cameraTest->abilityVec);
793 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
794 }
795
796 /**
797 * @tc.name: Camera_Device_Hdi_V1_3_017
798 * @tc.desc: CommitStreams_V1_1 for HIGH_RESOLUTION_PHOTO, preview and capture
799 * @tc.size: MediumTest
800 * @tc.type: Function
801 */
802 HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_017, TestSize.Level1)
803 {
804 if (!IsTagValueExistsU8(cameraTest->ability,
805 OHOS_ABILITY_CAMERA_MODES, OHOS::HDI::Camera::V1_3::HIGH_RESOLUTION_PHOTO)) {
806 cout << "skip this test, because HIGH_RESOLUTION_PHOTO not in OHOS_ABILITY_CAMERA_MODES" << endl;
807 return;
808 }
809 EXPECT_NE(cameraTest->ability, nullptr);
810 common_metadata_header_t* data = cameraTest->ability->get();
811 EXPECT_NE(data, nullptr);
812 camera_metadata_item_t entry;
813 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_CAPTURE_EXPECT_TIME, &entry);
814 if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR) {
815 EXPECT_NE(entry.data.ui32, nullptr);
816 EXPECT_EQ(entry.count > 1, true);
817 CAMERA_LOGI("mode is %{public}u and captureExpectTime is %{public}u", entry.data.ui32[0], entry.data.ui32[1]);
818 }
819 cameraTest->imageDataSaveSwitch = SWITCH_ON;
820 startStreamForHighResolutionPhoto(cameraTest);
821
822 // Update settings
823 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
824 int32_t aeExposureCompensation = EXPOSURE_COUNT;
825 meta->addEntry(OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, &aeExposureCompensation, DATA_COUNT);
826 uint8_t focusMode = OHOS_CAMERA_FOCUS_MODE_AUTO;
827 meta->addEntry(OHOS_CONTROL_FOCUS_MODE, &focusMode, DATA_COUNT);
828 std::vector<uint8_t> setting;
829 MetadataUtils::ConvertMetadataToVec(meta, setting);
830 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
831 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
832
833 sleep(UT_SECOND_TIMES);
834 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
835 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
836 cameraTest->captureIds = {cameraTest->captureIdPreview};
837 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
838 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
839 cameraTest->imageDataSaveSwitch = SWITCH_OFF;
840 }
841
842 /**
843 * @tc.name: Camera_Device_Hdi_V1_3_018
844 * @tc.desc: Determine whether the CAPTURE_MACRO mode is supported
845 * @tc.size: MediumTest
846 * @tc.type: Function
847 */
848 HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_018, TestSize.Level1)
849 {
850 EXPECT_NE(cameraTest->ability, nullptr);
851 common_metadata_header_t* data = cameraTest->ability->get();
852 EXPECT_NE(data, nullptr);
853 camera_metadata_item_t entry;
854 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_MODES, &entry);
855 if (cameraTest->rc != HDI::Camera::V1_0::NO_ERROR) {
856 CAMERA_LOGI("OHOS_ABILITY_CAMERA_MODES can not be found");
857 return;
858 }
859 if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR) {
860 EXPECT_NE(entry.data.u8, nullptr);
861 EXPECT_EQ(entry.count > 0, true);
862 for (size_t i = 0; i < entry.count; i++ ) {
863 uint8_t value = entry.data.u8[i];
864 if (value == OHOS::HDI::Camera::V1_2::CAPTURE_MACRO) {
865 CAMERA_LOGI("CAPTURE_MACRO mode is supported");
866 }
867 }
868 }
869 }
870
871 /**
872 * @tc.name: Camera_Device_Hdi_V1_3_019
873 * @tc.desc: CommitStreams_V1_1 for CAPTURE_MACRO, preview and capture
874 * @tc.size: MediumTest
875 * @tc.type: Function
876 */
877 HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_019, TestSize.Level1)
878 {
879 if (!IsTagValueExistsU8(cameraTest->ability, OHOS_ABILITY_CAMERA_MODES, OHOS::HDI::Camera::V1_3::CAPTURE_MACRO)) {
880 cout << "skip this test, because CAPTURE_MACRO not in OHOS_ABILITY_CAMERA_MODES" << endl;
881 return;
882 }
883 cameraTest->imageDataSaveSwitch = SWITCH_ON;
884 // Get stream operator
885 cameraTest->streamOperatorCallbackV1_3 = new OHOS::Camera::Test::TestStreamOperatorCallbackV1_3();
886 cameraTest->rc = cameraTest->cameraDeviceV1_3->GetStreamOperator_V1_3(cameraTest->streamOperatorCallbackV1_3,
887 cameraTest->streamOperator_V1_3);
888 EXPECT_NE(cameraTest->streamOperator_V1_3, nullptr);
889 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
890 // Preview streamInfo
891 cameraTest->streamInfoPre = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
892 cameraTest->DefaultInfosPreview(cameraTest->streamInfoPre);
893 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoPre);
894 // Capture streamInfo
895 cameraTest->streamInfoCapture = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
896 cameraTest->DefaultInfosCapture(cameraTest->streamInfoCapture);
897 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoCapture);
898 cameraTest->rc = cameraTest->streamOperator_V1_3->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
899 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
900 cameraTest->rc = cameraTest->streamOperator_V1_3->CommitStreams_V1_1(
901 static_cast<OHOS::HDI::Camera::V1_1::OperationMode_V1_1>(OHOS::HDI::Camera::V1_3::CAPTURE_MACRO),
902 cameraTest->abilityVec);
903 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
904
905 // Update settings
906 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
907 float lensFocusDistance = DATA_COUNT;
908 meta->addEntry(OHOS_CONTROL_LENS_FOCUS_DISTANCE, &lensFocusDistance, DATA_COUNT);
909 std::vector<uint8_t> setting;
910 MetadataUtils::ConvertMetadataToVec(meta, setting);
911 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
912 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
913
914 sleep(UT_SECOND_TIMES);
915 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
916 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
917
918 cameraTest->captureIds = {cameraTest->captureIdPreview};
919 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
920 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
921 cameraTest->imageDataSaveSwitch = SWITCH_OFF;
922 }
923
924 /**
925 * @tc.name: Camera_Device_Hdi_V1_3_020
926 * @tc.desc: Determine whether the VIDEO_MACRO mode is supported
927 * @tc.size: MediumTest
928 * @tc.type: Function
929 */
930 HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_020, TestSize.Level1)
931 {
932 EXPECT_NE(cameraTest->ability, nullptr);
933 common_metadata_header_t* data = cameraTest->ability->get();
934 EXPECT_NE(data, nullptr);
935 camera_metadata_item_t entry;
936 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_MODES, &entry);
937 if (cameraTest->rc != HDI::Camera::V1_0::NO_ERROR) {
938 CAMERA_LOGI("OHOS_ABILITY_CAMERA_MODES can not be find");
939 return;
940 }
941 if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR) {
942 EXPECT_NE(entry.data.u8, nullptr);
943 EXPECT_EQ(entry.count > 0, true);
944 for (size_t i = 0; i < entry.count; i++ ) {
945 uint8_t value = entry.data.u8[i];
946 if (value == OHOS::HDI::Camera::V1_2::VIDEO_MACRO) {
947 CAMERA_LOGI("VIDEO_MACRO mode is supported");
948 }
949 }
950 }
951 }
952
953 /**
954 * @tc.name: Camera_Device_Hdi_V1_3_021
955 * @tc.desc: CommitStreams_V1_1 for VIDEO_MACRO, preview and capture
956 * @tc.size: MediumTest
957 * @tc.type: Function
958 */
959 HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_021, TestSize.Level1)
960 {
961 if (!IsTagValueExistsU8(cameraTest->ability, OHOS_ABILITY_CAMERA_MODES, OHOS::HDI::Camera::V1_3::VIDEO_MACRO)) {
962 cout << "skip this test, because VIDEO_MACRO not in OHOS_ABILITY_CAMERA_MODES" << endl;
963 return;
964 }
965 cameraTest->imageDataSaveSwitch = SWITCH_ON;
966 // Get stream operator
967 cameraTest->streamOperatorCallbackV1_3 = new OHOS::Camera::Test::TestStreamOperatorCallbackV1_3();
968 cameraTest->rc = cameraTest->cameraDeviceV1_3->GetStreamOperator_V1_3(cameraTest->streamOperatorCallbackV1_3,
969 cameraTest->streamOperator_V1_3);
970 EXPECT_NE(cameraTest->streamOperator_V1_3, nullptr);
971 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
972 // Preview streamInfo
973 cameraTest->streamInfoPre = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
974 cameraTest->DefaultInfosPreview(cameraTest->streamInfoPre);
975 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoPre);
976 // Capture streamInfo
977 cameraTest->streamInfoVideo = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
978 cameraTest->DefaultInfosVideo(cameraTest->streamInfoVideo);
979 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoVideo);
980 // Create and commit streams
981 cameraTest->rc = cameraTest->streamOperator_V1_3->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
982 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
983 cameraTest->rc = cameraTest->streamOperator_V1_3->CommitStreams_V1_1(
984 static_cast<OHOS::HDI::Camera::V1_1::OperationMode_V1_1>(OHOS::HDI::Camera::V1_3::VIDEO_MACRO),
985 cameraTest->abilityVec);
986 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
987
988 // Update settings
989 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
990 float lensFocusDistance = DATA_COUNT;
991 meta->addEntry(OHOS_CONTROL_LENS_FOCUS_DISTANCE, &lensFocusDistance, DATA_COUNT);
992 std::vector<uint8_t> setting;
993 MetadataUtils::ConvertMetadataToVec(meta, setting);
994 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
995 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
996
997 sleep(UT_SECOND_TIMES);
998 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
999 cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true);
1000
1001 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo};
1002 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo};
1003 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
1004 cameraTest->imageDataSaveSwitch = SWITCH_OFF;
1005 }
1006
1007 /**
1008 * @tc.name:Camera_Device_Hdi_V1_3_025
1009 * @tc.desc:Dynamic FPS configuration, range setting, streams fps constrain
1010 * @tc.size:MediumTest
1011 * @tc.type:Function
1012 */
1013 HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_025, TestSize.Level1)
1014 {
1015 // PREVIEW and VIDEO stream
1016 cameraTest->intents = {PREVIEW, VIDEO};
1017
1018 // This requirement only in VIDEO mode
1019 cameraTest->StartStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::OperationMode::VIDEO);
1020
1021 // Bind fps range with preview stream and video stream
1022 common_metadata_header_t* data = cameraTest->ability->get();
1023 EXPECT_NE(data, nullptr);
1024 camera_metadata_item_t entry;
1025 cameraTest->rc = FindCameraMetadataItem(data, OHOS_CONTROL_FPS_RANGES, &entry);
1026 // The FPS only valid in current release, non backward compatibility
1027 int32_t fpsRanges[] = {1, 30};
1028 bool result;
1029 if (cameraTest->rc != CAM_META_SUCCESS) {
1030 std::cout << "Not found TAG[OHOS_CONTROL_FPS_RANGES], insert one" << std::endl;
1031 result = cameraTest->ability->addEntry(OHOS_CONTROL_FPS_RANGES,
1032 fpsRanges, sizeof(fpsRanges) / sizeof(int32_t));
1033 EXPECT_EQ(true, result);
1034 } else {
1035 std::cout << "Found TAG[OHOS_CONTROL_FPS_RANGES], Update it" << std::endl;
1036 result = cameraTest->ability->updateEntry(OHOS_CONTROL_FPS_RANGES,
1037 fpsRanges, sizeof(fpsRanges) / sizeof(int32_t));
1038 EXPECT_EQ(true, result);
1039 }
1040 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(cameraTest->ability, cameraTest->abilityVec);
1041
1042 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
1043 cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true);
1044
1045 // Release stream
1046 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo};
1047 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo};
1048 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
1049 }
1050
1051 /**
1052 + * @tc.name:Camera_Device_Hdi_V1_3_026
1053 + * @tc.desc:Dynamic FPS configuration, fixed fps setting, streams fps constrain
1054 + * @tc.size:MediumTest
1055 + * @tc.type:Function
1056 +*/
1057 HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_026, TestSize.Level1)
1058 {
1059 // PREVIEW and VIDEO stream
1060 cameraTest->intents = {PREVIEW, VIDEO};
1061
1062 // This requirement only in VIDEO mode
1063 cameraTest->StartStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::OperationMode::VIDEO);
1064
1065 // Bind fixed fps with preview stream and video stream, constraint
1066 common_metadata_header_t* data = cameraTest->ability->get();
1067 EXPECT_NE(data, nullptr);
1068 camera_metadata_item_t entry;
1069 cameraTest->rc = FindCameraMetadataItem(data, OHOS_CONTROL_FPS_RANGES, &entry);
1070
1071 // The FPS only valid in current release, non backward compatibility
1072 int32_t previewFixedFps[] = {30, 30};
1073 bool result;
1074 if (cameraTest->rc != CAM_META_SUCCESS) {
1075 std::cout << "Not found TAG[OHOS_CONTROL_FPS_RANGES], insert one" << std::endl;
1076 result = cameraTest->ability->addEntry(OHOS_CONTROL_FPS_RANGES,
1077 previewFixedFps, sizeof(previewFixedFps) / sizeof(int32_t));
1078 EXPECT_EQ(true, result);
1079 } else {
1080 std::cout << "Found TAG[OHOS_CONTROL_FPS_RANGES], Update it" << std::endl;
1081 result = cameraTest->ability->updateEntry(OHOS_CONTROL_FPS_RANGES,
1082 previewFixedFps, sizeof(previewFixedFps) / sizeof(int32_t));
1083 EXPECT_EQ(true, result);
1084 }
1085 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(cameraTest->ability, cameraTest->abilityVec);
1086 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
1087
1088 // Update video fixed fps, constraint relationship
1089 int32_t videoFixedFps[] = {60, 60};
1090 std::cout << "Update fixed fps for video capture" << std::endl;
1091 result = cameraTest->ability->updateEntry(OHOS_CONTROL_FPS_RANGES,
1092 videoFixedFps, sizeof(videoFixedFps) / sizeof(int32_t));
1093 EXPECT_EQ(true, result);
1094 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(cameraTest->ability, cameraTest->abilityVec);
1095 cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true);
1096
1097 // Release stream
1098 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo};
1099 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo};
1100
1101 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
1102 }
1103
1104 /**
1105 * @tc.name: Camera_Device_Hdi_V1_3_027
1106 * @tc.desc: OHOS_ABILITY_HIGH_QUALITY_SUPPORT
1107 * @tc.size: MediumTest
1108 * @tc.type: Function
1109 */
1110 HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_027, TestSize.Level1)
1111 {
1112 EXPECT_NE(cameraTest->ability, nullptr);
1113 common_metadata_header_t* data = cameraTest->ability->get();
1114 EXPECT_NE(data, nullptr);
1115 camera_metadata_item_t entry;
1116 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_HIGH_QUALITY_SUPPORT, &entry);
1117 if (cameraTest->rc != HDI::Camera::V1_0::NO_ERROR) {
1118 printf("OHOS_ABILITY_HIGH_QUALITY_SUPPORT is not support");
1119 return;
1120 }
1121 PrintAllTagDataU8(cameraTest->ability, OHOS_ABILITY_HIGH_QUALITY_SUPPORT);
1122 }
1123
1124 /**
1125 * @tc.name: Camera_Device_Hdi_V1_3_028
1126 * @tc.desc: OHOS_CONTROL_HIGH_QUALITY_MODE OHOS_CONTROL_HIGH_QUALITY_MODE_OFF
1127 * @tc.size: MediumTest
1128 * @tc.type: Function
1129 */
1130 HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_028, TestSize.Level1)
1131 {
1132 CAMERA_LOGI("test Camera_Device_Hdi_V1_3_028 start.");
1133 cameraTest->streamOperatorCallbackV1_3 = new OHOS::Camera::Test::TestStreamOperatorCallbackV1_3();
1134 cameraTest->rc = cameraTest->cameraDeviceV1_3->GetStreamOperator_V1_3(
1135 cameraTest->streamOperatorCallbackV1_3, cameraTest->streamOperator_V1_3);
1136 EXPECT_NE(cameraTest->streamOperator_V1_3, nullptr);
1137
1138 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
1139 cameraTest->DefaultInfosPreview(cameraTest->streamInfoV1_1);
1140 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
1141
1142 cameraTest->streamInfoCapture = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
1143 cameraTest->DefaultInfosCapture(cameraTest->streamInfoCapture);
1144 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoCapture);
1145
1146 std::shared_ptr<CameraSetting> modeSetting = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
1147 uint8_t movingPhoto = static_cast<uint8_t>(OHOS_CONTROL_HIGH_QUALITY_MODE_OFF);
1148 modeSetting->addEntry(OHOS_CONTROL_HIGH_QUALITY_MODE, &movingPhoto, 1);
1149 std::vector<uint8_t> metaVec;
1150 MetadataUtils::ConvertMetadataToVec(modeSetting, metaVec);
1151 cameraTest->cameraDeviceV1_3->UpdateSettings(metaVec);
1152
1153 cameraTest->rc = cameraTest->streamOperator_V1_3->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
1154 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1155 cameraTest->rc = cameraTest->streamOperator_V1_3->CommitStreams(OperationMode::NORMAL, cameraTest->abilityVec);
1156 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
1157
1158 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
1159 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
1160 cameraTest->captureIds = {cameraTest->captureIdPreview};
1161 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
1162 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
1163 }
1164
1165 /**
1166 * @tc.name: Camera_Device_Hdi_V1_3_029
1167 * @tc.desc: OHOS_CONTROL_HIGH_QUALITY_MODE OHOS_CONTROL_HIGH_QUALITY_MODE_ON
1168 * @tc.size: MediumTest
1169 * @tc.type: Function
1170 */
1171 HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_029, TestSize.Level1)
1172 {
1173 CAMERA_LOGI("test Camera_Device_Hdi_V1_3_029 start.");
1174 cameraTest->streamOperatorCallbackV1_3 = new OHOS::Camera::Test::TestStreamOperatorCallbackV1_3();
1175 cameraTest->rc = cameraTest->cameraDeviceV1_3->GetStreamOperator_V1_3(
1176 cameraTest->streamOperatorCallbackV1_3, cameraTest->streamOperator_V1_3);
1177 EXPECT_NE(cameraTest->streamOperator_V1_3, nullptr);
1178
1179 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
1180 cameraTest->DefaultInfosPreview(cameraTest->streamInfoV1_1);
1181 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
1182
1183 cameraTest->streamInfoCapture = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
1184 cameraTest->DefaultInfosCapture(cameraTest->streamInfoCapture);
1185 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoCapture);
1186
1187 std::shared_ptr<CameraSetting> modeSetting = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
1188 uint8_t movingPhoto = static_cast<uint8_t>(OHOS_CONTROL_HIGH_QUALITY_MODE_ON);
1189 modeSetting->addEntry(OHOS_CONTROL_HIGH_QUALITY_MODE, &movingPhoto, 1);
1190 std::vector<uint8_t> metaVec;
1191 MetadataUtils::ConvertMetadataToVec(modeSetting, metaVec);
1192 cameraTest->cameraDeviceV1_3->UpdateSettings(metaVec);
1193
1194 cameraTest->rc = cameraTest->streamOperator_V1_3->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
1195 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1196 cameraTest->rc = cameraTest->streamOperator_V1_3->CommitStreams(OperationMode::NORMAL, cameraTest->abilityVec);
1197 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
1198
1199 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
1200 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
1201 cameraTest->captureIds = {cameraTest->captureIdPreview};
1202 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
1203 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
1204 }
1205
1206 /**
1207 * @tc.name: Camera_Device_Hdi_V1_3_032
1208 * @tc.desc: Get and Print all data in OHOS_ABILITY_CAMERA_MODES for all cameras
1209 * @tc.size: MediumTest
1210 * @tc.type: Function
1211 */
1212 HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_032, TestSize.Level1)
1213 {
1214 cameraTest->serviceV1_3->GetCameraIds(cameraTest->cameraIds);
1215 EXPECT_NE(cameraTest->cameraIds.size(), 0);
1216
1217 for (auto &cameraId : cameraTest->cameraIds) {
1218 cameraTest->Close();
1219 cameraTest->serviceV1_3->GetCameraAbility(cameraId, cameraTest->abilityVec);
1220 MetadataUtils::ConvertVecToMetadata(cameraTest->abilityVec, cameraTest->ability);
1221 cameraTest->deviceCallback = new OHOS::Camera::Test::DemoCameraDeviceCallback();
1222 cameraTest->rc = cameraTest->serviceV1_3->OpenCamera_V1_3(cameraId,
1223 cameraTest->deviceCallback, cameraTest->cameraDeviceV1_3);
1224 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
1225
1226 common_metadata_header_t* data = cameraTest->ability->get();
1227
1228 std::string metaString = cameraTest->ability->FormatCameraMetadataToString(data);
1229
1230 std::cout << "============= camera id: " << cameraId << " =============" << std::endl;
1231 std::cout << metaString << std::endl;
1232 std::cout << "==========================" << std::endl;
1233 }
1234 }
1235
1236 /**
1237 * @tc.name:Camera_Device_Hdi_V1_3_033
1238 * @tc.desc:OHOS_ABILITY_AVAILABLE_PROFILE_LEVEL
1239 * @tc.size:MediumTest
1240 * @tc.type:Function
1241 */
1242 HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_033, TestSize.Level1)
1243 {
1244 EXPECT_NE(cameraTest->ability, nullptr);
1245 common_metadata_header_t* data = cameraTest->ability->get();
1246 EXPECT_NE(data, nullptr);
1247 camera_metadata_item_t entry;
1248 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_AVAILABLE_PROFILE_LEVEL, &entry);
1249 if (cameraTest->rc != HDI::Camera::V1_0::NO_ERROR) {
1250 CAMERA_LOGI("OHOS_ABILITY_AVAILABLE_PROFILE_LEVEL is not support");
1251 return;
1252 }
1253 CAMERA_LOGI("print tag<OHOS_ABILITY_AVAILABLE_PROFILE_LEVEL> value start.");
1254 constexpr size_t step = 20; // print step
1255 std::stringstream ss;
1256 if (entry.data.i32 != nullptr && entry.count > 0) {
1257 for (size_t i = 0; i < entry.count; i++) {
1258 ss << entry.data.i32[i] << " ";
1259 if ((i != 0) && (i % step == 0 || i == entry.count - 1)) {
1260 CAMERA_LOGI("%{public}s\n", ss.str().c_str());
1261 ss.clear();
1262 ss.str("");
1263 }
1264 }
1265 } else {
1266 printf("get tag<OHOS_ABILITY_AVAILABLE_PROFILE_LEVEL> failed.\n");
1267 CAMERA_LOGE("get tag<OHOS_ABILITY_AVAILABLE_PROFILE_LEVEL> failed.");
1268 }
1269 CAMERA_LOGI("print tag<OHOS_ABILITY_AVAILABLE_PROFILE_LEVEL> value end.");
1270 }
1271
1272 /**
1273 * @tc.name:Camera_Device_Hdi_V1_3_034
1274 * @tc.desc:OHOS_ABILITY_AVAILABLE_CONFIGURATIONS
1275 * @tc.size:MediumTest
1276 * @tc.type:Function
1277 */
1278 HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_034, TestSize.Level1)
1279 {
1280 EXPECT_NE(cameraTest->ability, nullptr);
1281 common_metadata_header_t* data = cameraTest->ability->get();
1282 EXPECT_NE(data, nullptr);
1283 camera_metadata_item_t entry;
1284 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_AVAILABLE_CONFIGURATIONS, &entry);
1285 if (cameraTest->rc != HDI::Camera::V1_0::NO_ERROR) {
1286 CAMERA_LOGI("OHOS_ABILITY_AVAILABLE_CONFIGURATIONS is not support");
1287 return;
1288 }
1289 CAMERA_LOGI("print tag<OHOS_ABILITY_AVAILABLE_CONFIGURATIONS> value start.");
1290 constexpr size_t step = 20; // print step
1291 std::stringstream ss;
1292 if (entry.data.i32 != nullptr && entry.count > 0) {
1293 for (size_t i = 0; i < entry.count; i++) {
1294 ss << entry.data.i32[i] << " ";
1295 if ((i != 0) && (i % step == 0 || i == entry.count - 1)) {
1296 CAMERA_LOGI("%{public}s\n", ss.str().c_str());
1297 ss.clear();
1298 ss.str("");
1299 }
1300 }
1301 } else {
1302 printf("get tag<OHOS_ABILITY_AVAILABLE_CONFIGURATIONS> failed.\n");
1303 CAMERA_LOGE("get tag<OHOS_ABILITY_AVAILABLE_CONFIGURATIONS> failed.");
1304 }
1305 CAMERA_LOGI("print tag<OHOS_ABILITY_AVAILABLE_CONFIGURATIONS> value end.");
1306 }
1307
1308 /**
1309 * @tc.name:Camera_Device_Hdi_V1_3_035
1310 * @tc.desc:OHOS_ABILITY_CONFLICT_CONFIGURATIONS
1311 * @tc.size:MediumTest
1312 * @tc.type:Function
1313 */
1314 HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_035, TestSize.Level1)
1315 {
1316 EXPECT_NE(cameraTest->ability, nullptr);
1317 common_metadata_header_t* data = cameraTest->ability->get();
1318 EXPECT_NE(data, nullptr);
1319 camera_metadata_item_t entry;
1320 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_CONFLICT_CONFIGURATIONS, &entry);
1321 if (cameraTest->rc != HDI::Camera::V1_0::NO_ERROR) {
1322 CAMERA_LOGI("OHOS_ABILITY_CONFLICT_CONFIGURATIONS is not support");
1323 return;
1324 }
1325 CAMERA_LOGI("print tag<OHOS_ABILITY_CONFLICT_CONFIGURATIONS> value start.");
1326 constexpr size_t step = 20; // print step
1327 std::stringstream ss;
1328 if (entry.data.i32 != nullptr && entry.count > 0) {
1329 for (size_t i = 0; i < entry.count; i++) {
1330 ss << entry.data.i32[i] << " ";
1331 if ((i != 0) && (i % step == 0 || i == entry.count - 1)) {
1332 CAMERA_LOGI("%{public}s\n", ss.str().c_str());
1333 ss.clear();
1334 ss.str("");
1335 }
1336 }
1337 } else {
1338 printf("get tag<OHOS_ABILITY_CONFLICT_CONFIGURATIONS> failed.\n");
1339 CAMERA_LOGE("get tag<OHOS_ABILITY_CONFLICT_CONFIGURATIONS> failed.");
1340 }
1341 CAMERA_LOGI("print tag<OHOS_ABILITY_CONFLICT_CONFIGURATIONS> value end.");
1342 }
1343
1344 /**
1345 * @tc.name:Camera_Device_Hdi_V1_3_036
1346 * @tc.desc:LIGHT_PAINTING mode
1347 * @tc.size:MediumTest
1348 * @tc.type:Function
1349 */
1350 HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_036, TestSize.Level1)
1351 {
1352 EXPECT_NE(cameraTest->ability, nullptr);
1353 common_metadata_header_t* data = cameraTest->ability->get();
1354 EXPECT_NE(data, nullptr);
1355 camera_metadata_item_t entry;
1356 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_MODES, &entry);
1357 if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR) {
1358 EXPECT_NE(entry.data.u8, nullptr);
1359 EXPECT_EQ(entry.count > 0, true);
1360 for (size_t i = 0; i < entry.count; i++ ) {
1361 uint8_t value = entry.data.u8[i];
1362 if (value == OHOS::HDI::Camera::V1_3::LIGHT_PAINTING) {
1363 CAMERA_LOGI("LIGHT_PAINTING mode is supported");
1364 }
1365 }
1366 }
1367 }
1368
1369 /**
1370 * @tc.name:Camera_Device_Hdi_V1_3_037
1371 * @tc.desc:Configure light painting, OHOS_CONTROL_LIGHT_PAINTING_TYPE
1372 * @tc.size:MediumTest
1373 * @tc.type:Function
1374 */
1375 HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_037, TestSize.Level1)
1376 {
1377 common_metadata_header_t* data = cameraTest->ability->get();
1378 EXPECT_NE(data, nullptr);
1379 camera_metadata_item_t entry;
1380 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_LIGHT_PAINTING_TYPE, &entry);
1381 if (cameraTest->rc != HDI::Camera::V1_0::NO_ERROR) {
1382 printf("get tag<OHOS_ABILITY_LIGHT_PAINTING_TYPE> failed.\n");
1383 return;
1384 }
1385
1386 cameraTest->imageDataSaveSwitch = SWITCH_ON;
1387 cameraTest->streamOperatorCallbackV1_3 = new OHOS::Camera::Test::TestStreamOperatorCallbackV1_3();
1388 cameraTest->rc = cameraTest->cameraDeviceV1_3->GetStreamOperator_V1_3(
1389 cameraTest->streamOperatorCallbackV1_3, cameraTest->streamOperator_V1_3);
1390 EXPECT_NE(cameraTest->streamOperator_V1_3, nullptr);
1391
1392 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
1393 cameraTest->DefaultInfosPreview(cameraTest->streamInfoV1_1);
1394 cameraTest->streamInfoV1_1->v1_0.width_ = 4096;
1395 cameraTest->streamInfoV1_1->v1_0.height_ = 3072;
1396 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
1397
1398 cameraTest->streamInfoCapture = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
1399 cameraTest->DefaultInfosCapture(cameraTest->streamInfoCapture);
1400 cameraTest->streamInfoCapture->v1_0.width_ = 4096;
1401 cameraTest->streamInfoCapture->v1_0.height_ = 3072;
1402 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoCapture);
1403
1404 cameraTest->rc = cameraTest->streamOperator_V1_3->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
1405 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1406 cameraTest->rc = cameraTest->streamOperator_V1_3->CommitStreams_V1_1(
1407 static_cast<OHOS::HDI::Camera::V1_1::OperationMode_V1_1>(OHOS::HDI::Camera::V1_3::LIGHT_PAINTING),
1408 cameraTest->abilityVec);
1409 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
1410
1411 std::shared_ptr<CameraSetting> modeSetting = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
1412 uint8_t lightPainting = OHOS_CAMERA_LIGHT_PAINTING_LIGHT;
1413 uint8_t lightFlush = 1;
1414 modeSetting->addEntry(OHOS_CONTROL_LIGHT_PAINTING_FLASH, &lightFlush, 1);
1415 modeSetting->addEntry(OHOS_CONTROL_LIGHT_PAINTING_TYPE, &lightPainting, 1);
1416 std::vector<uint8_t> metaVec;
1417 MetadataUtils::ConvertMetadataToVec(modeSetting, metaVec);
1418 cameraTest->cameraDeviceV1_3->UpdateSettings(metaVec);
1419
1420 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
1421 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, true);
1422
1423 sleep(UT_SLEEP_TIME);
1424 EXPECT_NE(cameraTest->streamOperator_V1_3, nullptr);
1425 cameraTest->streamOperator_V1_3->ConfirmCapture(cameraTest->captureIdCapture);
1426 sleep(UT_SLEEP_TIME);
1427
1428 cameraTest->captureIds = {cameraTest->captureIdPreview};
1429 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
1430 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
1431 sleep(UT_SLEEP_TIME);
1432 cameraTest->streamInfosV1_1.clear();
1433 cameraTest->imageDataSaveSwitch = SWITCH_OFF;
1434 }
1435
1436 /**
1437 * @tc.name:Camera_Device_Hdi_V1_3_038
1438 * @tc.desc:LIGHT_PAINTING and confirmCapture
1439 * @tc.size:MediumTest
1440 * @tc.type:Function
1441 */
1442 HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_038, TestSize.Level1)
1443 {
1444 if (!IsTagValueExistsU8(cameraTest->ability, OHOS_ABILITY_CAMERA_MODES, OHOS::HDI::Camera::V1_3::LIGHT_PAINTING)) {
1445 cout << "skip this test, because LIGHT_PAINTING not in OHOS_ABILITY_CAMERA_MODES" << endl;
1446 return;
1447 }
1448 CAMERA_LOGI("test Camera_Device_Hdi_V1_3_038 start.");
1449 EXPECT_NE(cameraTest->ability, nullptr);
1450 common_metadata_header_t* data = cameraTest->ability->get();
1451 EXPECT_NE(data, nullptr);
1452 camera_metadata_item_t entry;
1453 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_LIGHT_PAINTING_TYPE, &entry);
1454 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1455
1456 cameraTest->streamOperatorCallbackV1_3 = new OHOS::Camera::Test::TestStreamOperatorCallbackV1_3();
1457 cameraTest->rc = cameraTest->cameraDeviceV1_3->GetStreamOperator_V1_3(
1458 cameraTest->streamOperatorCallbackV1_3, cameraTest->streamOperator_V1_3);
1459 EXPECT_NE(cameraTest->streamOperator_V1_3, nullptr);
1460
1461 cameraTest->imageDataSaveSwitch = SWITCH_ON;
1462 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
1463 cameraTest->DefaultInfosPreview(cameraTest->streamInfoV1_1);
1464 cameraTest->streamInfoV1_1->v1_0.width_ = 4096;
1465 cameraTest->streamInfoV1_1->v1_0.height_ = 3072;
1466 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
1467
1468 cameraTest->streamInfoCapture = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
1469 cameraTest->DefaultInfosCapture(cameraTest->streamInfoCapture);
1470 cameraTest->streamInfoCapture->v1_0.width_ = 4096;
1471 cameraTest->streamInfoCapture->v1_0.height_ = 3072;
1472 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoCapture);
1473
1474 cameraTest->rc = cameraTest->streamOperator_V1_3->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
1475 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1476 cameraTest->rc = cameraTest->streamOperator_V1_3->CommitStreams_V1_1(
1477 static_cast<OHOS::HDI::Camera::V1_1::OperationMode_V1_1>(OHOS::HDI::Camera::V1_3::LIGHT_PAINTING),
1478 cameraTest->abilityVec);
1479 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
1480
1481 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
1482 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, true);
1483
1484 sleep(UT_SLEEP_TIME);
1485 EXPECT_NE(cameraTest->streamOperator_V1_3, nullptr);
1486 cameraTest->streamOperator_V1_3->ConfirmCapture(cameraTest->captureIdCapture);
1487 sleep(UT_SLEEP_TIME);
1488
1489 cameraTest->captureIds = {cameraTest->captureIdPreview};
1490 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
1491 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
1492 cameraTest->imageDataSaveSwitch = SWITCH_OFF;
1493 }
1494
1495 /**
1496 * @tc.name: Camera_Device_Hdi_V1_3_039
1497 * @tc.desc: Configure light painting, OHOS_CAMERA_FOCUS_MODE_AUTO
1498 * @tc.size: MediumTest
1499 * @tc.type: Function
1500 */
1501 HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_039, TestSize.Level1)
1502 {
1503 if (!IsTagValueExistsU8(cameraTest->ability, OHOS_ABILITY_CAMERA_MODES, OHOS::HDI::Camera::V1_3::LIGHT_PAINTING)) {
1504 cout << "skip this test, because LIGHT_PAINTING not in OHOS_ABILITY_CAMERA_MODES" << endl;
1505 return;
1506 }
1507 cameraTest->imageDataSaveSwitch = SWITCH_ON;
1508 // Get stream operator
1509 cameraTest->streamOperatorCallbackV1_3 = new OHOS::Camera::Test::TestStreamOperatorCallbackV1_3();
1510 cameraTest->rc = cameraTest->cameraDeviceV1_3->GetStreamOperator_V1_3(cameraTest->streamOperatorCallbackV1_3,
1511 cameraTest->streamOperator_V1_3);
1512 EXPECT_NE(cameraTest->streamOperator_V1_3, nullptr);
1513 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1514 // Preview streamInfo
1515 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
1516 cameraTest->DefaultInfosPreview(cameraTest->streamInfoV1_1);
1517 cameraTest->streamInfoV1_1->v1_0.width_ = 4096;
1518 cameraTest->streamInfoV1_1->v1_0.height_ = 3072;
1519 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
1520
1521 cameraTest->streamInfoCapture = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
1522 cameraTest->DefaultInfosCapture(cameraTest->streamInfoCapture);
1523 cameraTest->streamInfoCapture->v1_0.width_ = 4096;
1524 cameraTest->streamInfoCapture->v1_0.height_ = 3072;
1525 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoCapture);
1526 // Create and commitStream
1527 cameraTest->rc = cameraTest->streamOperator_V1_3->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
1528 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1529 cameraTest->rc = cameraTest->streamOperator_V1_3->CommitStreams_V1_1(
1530 static_cast<OHOS::HDI::Camera::V1_1::OperationMode_V1_1>(OHOS::HDI::Camera::V1_3::LIGHT_PAINTING),
1531 cameraTest->abilityVec);
1532 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1533
1534 // Update settings
1535 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
1536 uint8_t focusMode = OHOS_CAMERA_FOCUS_MODE_AUTO;
1537 meta->addEntry(OHOS_CONTROL_FOCUS_MODE, &focusMode, DATA_COUNT);
1538 std::vector<uint8_t> setting;
1539 MetadataUtils::ConvertMetadataToVec(meta, setting);
1540 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
1541 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1542
1543 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
1544 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, true);
1545
1546 sleep(UT_SLEEP_TIME);
1547 EXPECT_NE(cameraTest->streamOperator_V1_3, nullptr);
1548 cameraTest->streamOperator_V1_3->ConfirmCapture(cameraTest->captureIdCapture);
1549 sleep(UT_SLEEP_TIME);
1550
1551 cameraTest->captureIds = {cameraTest->captureIdPreview};
1552 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
1553 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
1554 cameraTest->imageDataSaveSwitch = SWITCH_OFF;
1555 }
1556
1557 /**
1558 * @tc.name: Camera_Device_Hdi_V1_3_040
1559 * @tc.desc: Configure light painting, CAMERA_CUSTOM_COLOR_NORMAL
1560 * @tc.size: MediumTest
1561 * @tc.type: Function
1562 */
1563 HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_040, TestSize.Level1)
1564 {
1565 EXPECT_NE(cameraTest->ability, nullptr);
1566 common_metadata_header_t* data = cameraTest->ability->get();
1567 EXPECT_NE(data, nullptr);
1568 camera_metadata_item_t entry;
1569 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_SUPPORTED_COLOR_MODES, &entry);
1570 if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) {
1571
1572 cameraTest->imageDataSaveSwitch = SWITCH_ON;
1573 for (uint8_t i = 0; i < entry.count; i++) {
1574 // Get stream operator
1575 cameraTest->streamOperatorCallbackV1_3 = new OHOS::Camera::Test::TestStreamOperatorCallbackV1_3();
1576 cameraTest->rc = cameraTest->cameraDeviceV1_3->GetStreamOperator_V1_3(
1577 cameraTest->streamOperatorCallbackV1_3, cameraTest->streamOperator_V1_3);
1578 EXPECT_NE(cameraTest->streamOperator_V1_3, nullptr);
1579 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1580 // Preview streamInfo
1581 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
1582 cameraTest->DefaultInfosPreview(cameraTest->streamInfoV1_1);
1583 cameraTest->streamInfoV1_1->v1_0.width_ = 4096;
1584 cameraTest->streamInfoV1_1->v1_0.height_ = 3072;
1585 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
1586
1587 cameraTest->streamInfoCapture = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
1588 cameraTest->DefaultInfosCapture(cameraTest->streamInfoCapture);
1589 cameraTest->streamInfoCapture->v1_0.width_ = 4096;
1590 cameraTest->streamInfoCapture->v1_0.height_ = 3072;
1591 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoCapture);
1592 // Create and commitStream
1593 cameraTest->rc = cameraTest->streamOperator_V1_3->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
1594 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1595 cameraTest->rc = cameraTest->streamOperator_V1_3->CommitStreams_V1_1(
1596 static_cast<OHOS::HDI::Camera::V1_1::OperationMode_V1_1>(OHOS::HDI::Camera::V1_3::LIGHT_PAINTING),
1597 cameraTest->abilityVec);
1598 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1599
1600 // Update settings
1601 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
1602 uint8_t xmageMode = entry.data.u8[i];
1603 meta->addEntry(OHOS_CONTROL_SUPPORTED_COLOR_MODES, &xmageMode, 1);
1604 std::vector<uint8_t> setting;
1605 MetadataUtils::ConvertMetadataToVec(meta, setting);
1606 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
1607 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1608
1609 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
1610 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, true);
1611
1612 sleep(UT_SLEEP_TIME);
1613 EXPECT_NE(cameraTest->streamOperator_V1_3, nullptr);
1614 cameraTest->streamOperator_V1_3->ConfirmCapture(cameraTest->captureIdCapture);
1615
1616 cameraTest->captureIds = {cameraTest->captureIdPreview};
1617 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
1618 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
1619 sleep(UT_SLEEP_TIME);
1620 cameraTest->streamInfosV1_1.clear();
1621 }
1622 cameraTest->imageDataSaveSwitch = SWITCH_OFF;
1623 } else {
1624 printf("get tag<OHOS_ABILITY_SUPPORTED_COLOR_MODES> failed.\n");
1625 CAMERA_LOGE("get tag<OHOS_ABILITY_SUPPORTED_COLOR_MODES> failed.");
1626 }
1627 }
1628
1629 /**
1630 * @tc.name:Camera_Device_Hdi_V1_3_041
1631 * @tc.desc:PANORAMA_PHOTO mode
1632 * @tc.size:MediumTest
1633 * @tc.type:Function
1634 */
1635 HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_041, TestSize.Level1)
1636 {
1637 EXPECT_NE(cameraTest->ability, nullptr);
1638 common_metadata_header_t* data = cameraTest->ability->get();
1639 EXPECT_NE(data, nullptr);
1640 camera_metadata_item_t entry;
1641 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_MODES, &entry);
1642 if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR) {
1643 EXPECT_NE(entry.data.u8, nullptr);
1644 EXPECT_EQ(entry.count > 0, true);
1645 for (size_t i = 0; i < entry.count; i++ ) {
1646 uint8_t value = entry.data.u8[i];
1647 if (value == OHOS::HDI::Camera::V1_3::PANORAMA_PHOTO) {
1648 CAMERA_LOGI("PANORAMA_PHOTO mode is supported");
1649 } else {
1650 CAMERA_LOGI("PANORAMA_PHOTO mode is not supported");
1651 }
1652 }
1653 }
1654 }
1655
1656 /**
1657 * @tc.name: Camera_Device_Hdi_V1_3_042
1658 * @tc.desc: Configure panorama photo, OHOS_CONTROL_FOCUSED_POINT
1659 * @tc.size: MediumTest
1660 * @tc.type: Function
1661 */
1662 HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_042, TestSize.Level1)
1663 {
1664 if (!IsTagValueExistsU8(cameraTest->ability, OHOS_ABILITY_CAMERA_MODES, OHOS::HDI::Camera::V1_3::PANORAMA_PHOTO)) {
1665 cout << "skip this test, because PANORAMA_PHOTO not in OHOS_ABILITY_CAMERA_MODES" << endl;
1666 return;
1667 }
1668 CAMERA_LOGI("test Camera_Device_Hdi_V1_3_042 start.");
1669 // Get stream operator
1670 cameraTest->streamOperatorCallbackV1_3 = new OHOS::Camera::Test::TestStreamOperatorCallbackV1_3();
1671 cameraTest->rc = cameraTest->cameraDeviceV1_3->GetStreamOperator_V1_3(cameraTest->streamOperatorCallbackV1_3,
1672 cameraTest->streamOperator_V1_3);
1673 EXPECT_NE(cameraTest->streamOperator_V1_3, nullptr);
1674 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1675 // Preview streamInfo
1676 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
1677 cameraTest->DefaultInfosPreview(cameraTest->streamInfoV1_1);
1678 cameraTest->streamInfoV1_1->v1_0.width_ = 1440;
1679 cameraTest->streamInfoV1_1->v1_0.height_ = 1080;
1680 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
1681 cameraTest->streamInfoCapture = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
1682 cameraTest->DefaultInfosCapture(cameraTest->streamInfoCapture);
1683 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoCapture);
1684 // Create and commitStream
1685 cameraTest->rc = cameraTest->streamOperator_V1_3->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
1686 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1687 cameraTest->rc = cameraTest->streamOperator_V1_3->CommitStreams_V1_1(
1688 static_cast<OHOS::HDI::Camera::V1_1::OperationMode_V1_1>(OHOS::HDI::Camera::V1_3::PANORAMA_PHOTO),
1689 cameraTest->abilityVec);
1690 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1691 // Update settings
1692 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
1693 uint8_t focusedPoint[] = {1, 1, 1, 1};
1694 uint8_t focusMode = OHOS_CAMERA_FOCUS_MODE_AUTO;
1695 meta->addEntry(OHOS_CONTROL_FOCUSED_POINT, &focusedPoint, DATA_COUNT);
1696 meta->addEntry(OHOS_CONTROL_FOCUS_MODE, &focusMode, DATA_COUNT);
1697 std::vector<uint8_t> setting;
1698 MetadataUtils::ConvertMetadataToVec(meta, setting);
1699 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
1700 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1701
1702 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
1703 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, true);
1704 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdCapture};
1705 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
1706 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
1707 }
1708
1709 /**
1710 * @tc.name: Camera_Device_Hdi_V1_3_043
1711 * @tc.desc: Configure panorama photo, OHOS_CONTROL_EXPOSUREMODE OHOS_CONTROL_SUPPORTED_COLOR_MODES
1712 * @tc.size: MediumTest
1713 * @tc.type: Function
1714 */
1715 HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_043, TestSize.Level1)
1716 {
1717 if (!IsTagValueExistsU8(cameraTest->ability, OHOS_ABILITY_CAMERA_MODES, OHOS::HDI::Camera::V1_3::PANORAMA_PHOTO)) {
1718 cout << "skip this test, because PANORAMA_PHOTO not in OHOS_ABILITY_CAMERA_MODES" << endl;
1719 return;
1720 }
1721 CAMERA_LOGI("test Camera_Device_Hdi_V1_3_043 start.");
1722 // Get stream operator
1723 cameraTest->streamOperatorCallbackV1_3 = new OHOS::Camera::Test::TestStreamOperatorCallbackV1_3();
1724 cameraTest->rc = cameraTest->cameraDeviceV1_3->GetStreamOperator_V1_3(cameraTest->streamOperatorCallbackV1_3,
1725 cameraTest->streamOperator_V1_3);
1726 EXPECT_NE(cameraTest->streamOperator_V1_3, nullptr);
1727 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1728 // Preview streamInfo
1729 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
1730 cameraTest->DefaultInfosPreview(cameraTest->streamInfoV1_1);
1731 cameraTest->streamInfoV1_1->v1_0.width_ = 3264;
1732 cameraTest->streamInfoV1_1->v1_0.height_ = 2448;
1733 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
1734 cameraTest->streamInfoCapture = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
1735 cameraTest->DefaultInfosCapture(cameraTest->streamInfoCapture);
1736 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoCapture);
1737 // Create and commitStream
1738 cameraTest->rc = cameraTest->streamOperator_V1_3->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
1739 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1740 cameraTest->rc = cameraTest->streamOperator_V1_3->CommitStreams_V1_1(
1741 static_cast<OHOS::HDI::Camera::V1_1::OperationMode_V1_1>(OHOS::HDI::Camera::V1_3::PANORAMA_PHOTO),
1742 cameraTest->abilityVec);
1743 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1744 // Update settings
1745 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
1746 uint8_t awbMode = OHOS_CAMERA_AWB_MODE_AUTO;
1747 uint8_t xmageMode = CAMERA_CUSTOM_COLOR_BRIGHT;
1748 int32_t controlExposure = OHOS_CAMERA_EXPOSURE_MODE_AUTO;
1749 meta->addEntry(OHOS_CONTROL_AWB_MODE, &awbMode, DATA_COUNT);
1750 meta->addEntry(OHOS_CONTROL_SUPPORTED_COLOR_MODES, &xmageMode, DATA_COUNT);
1751 meta->addEntry(OHOS_CONTROL_EXPOSUREMODE, &controlExposure, DATA_COUNT);
1752 std::vector<uint8_t> setting;
1753 MetadataUtils::ConvertMetadataToVec(meta, setting);
1754 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
1755 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1756
1757 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
1758 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, true);
1759 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdCapture};
1760 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
1761 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
1762 }
1763
1764 /**
1765 * @tc.name: Camera_Device_Hdi_V1_3_044
1766 * @tc.desc: Configure panorama photo, OHOS_CONTROL_AWB_LOCK
1767 * @tc.size: MediumTest
1768 * @tc.type: Function
1769 */
1770 HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_044, TestSize.Level1)
1771 {
1772 if (!IsTagValueExistsU8(cameraTest->ability, OHOS_ABILITY_CAMERA_MODES, OHOS::HDI::Camera::V1_3::PANORAMA_PHOTO)) {
1773 cout << "skip this test, because PANORAMA_PHOTO not in OHOS_ABILITY_CAMERA_MODES" << endl;
1774 return;
1775 }
1776 CAMERA_LOGI("test Camera_Device_Hdi_V1_3_044 start.");
1777 // Get stream operator
1778 cameraTest->streamOperatorCallbackV1_3 = new OHOS::Camera::Test::TestStreamOperatorCallbackV1_3();
1779 cameraTest->rc = cameraTest->cameraDeviceV1_3->GetStreamOperator_V1_3(cameraTest->streamOperatorCallbackV1_3,
1780 cameraTest->streamOperator_V1_3);
1781 EXPECT_NE(cameraTest->streamOperator_V1_3, nullptr);
1782 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1783 // Preview streamInfo
1784 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
1785 cameraTest->DefaultInfosPreview(cameraTest->streamInfoV1_1);
1786 cameraTest->streamInfoV1_1->v1_0.width_ = 320;
1787 cameraTest->streamInfoV1_1->v1_0.height_ = 240;
1788 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
1789 cameraTest->streamInfoCapture = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
1790 cameraTest->DefaultInfosCapture(cameraTest->streamInfoCapture);
1791 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoCapture);
1792 // Create and commitStream
1793 cameraTest->rc = cameraTest->streamOperator_V1_3->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
1794 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1795 cameraTest->rc = cameraTest->streamOperator_V1_3->CommitStreams_V1_1(
1796 static_cast<OHOS::HDI::Camera::V1_1::OperationMode_V1_1>(OHOS::HDI::Camera::V1_3::PANORAMA_PHOTO),
1797 cameraTest->abilityVec);
1798 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1799 // Update settings
1800 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
1801 uint8_t awbMode = OHOS_CAMERA_AWB_LOCK_ON;
1802 uint8_t xmageMode = CAMERA_CUSTOM_COLOR_SOFT;
1803 meta->addEntry(OHOS_CONTROL_AWB_LOCK, &awbMode, DATA_COUNT);
1804 meta->addEntry(OHOS_CONTROL_SUPPORTED_COLOR_MODES, &xmageMode, DATA_COUNT);
1805 std::vector<uint8_t> setting;
1806 MetadataUtils::ConvertMetadataToVec(meta, setting);
1807 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
1808 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1809
1810 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
1811 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, true);
1812 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdCapture};
1813 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
1814 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
1815 }
1816
1817 /**
1818 * @tc.name:Camera_Device_Hdi_V1_3_045
1819 * @tc.desc:OHOS_CONTROL_BURST_CAPTURE
1820 * @tc.size:MediumTest
1821 * @tc.type:Function
1822 */
1823 HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_045, TestSize.Level1)
1824 {
1825 CAMERA_LOGI("test Camera_Device_Hdi_V1_3_045 start.");
1826 cameraTest->imageDataSaveSwitch = SWITCH_ON;
1827
1828 // Get stream operator
1829 cameraTest->streamOperatorCallbackV1_3 = new OHOS::Camera::Test::TestStreamOperatorCallbackV1_3();
1830 cameraTest->rc = cameraTest->cameraDeviceV1_3->GetStreamOperator_V1_3(
1831 cameraTest->streamOperatorCallbackV1_3, cameraTest->streamOperator_V1_3);
1832 EXPECT_NE(cameraTest->streamOperator_V1_3, nullptr);
1833
1834 // Preview streamInfo
1835 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
1836 cameraTest->DefaultInfosPreview(cameraTest->streamInfoV1_1);
1837 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
1838
1839 // Capture streamInfo
1840 cameraTest->streamInfoCapture = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
1841 cameraTest->DefaultInfosCapture(cameraTest->streamInfoCapture);
1842 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoCapture);
1843
1844 // CreateStreams
1845 cameraTest->rc = cameraTest->streamOperator_V1_3->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
1846 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1847 cameraTest->rc = cameraTest->streamOperator_V1_3->CommitStreams(OperationMode::NORMAL, cameraTest->abilityVec);
1848 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
1849
1850 // Set OHOS_CONTROL_BURST_CAPTURE_BEGIN, start burst
1851 std::shared_ptr<CameraSetting> modeSetting = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
1852 uint8_t burstCapture = static_cast<uint8_t>(OHOS_CONTROL_BURST_CAPTURE_BEGIN);
1853 modeSetting->addEntry(OHOS_CONTROL_BURST_CAPTURE, &burstCapture, 1);
1854 std::vector<uint8_t> metaVec;
1855 MetadataUtils::ConvertMetadataToVec(modeSetting, metaVec);
1856 cameraTest->abilityVec = metaVec;
1857 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
1858 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
1859
1860 // Set OHOS_CONTROL_BURST_CAPTURE_END, close burst
1861 burstCapture = static_cast<uint8_t>(OHOS_CONTROL_BURST_CAPTURE_END);
1862 modeSetting->addEntry(OHOS_CONTROL_BURST_CAPTURE, &burstCapture, 1);
1863 MetadataUtils::ConvertMetadataToVec(modeSetting, metaVec);
1864 cameraTest->abilityVec = metaVec;
1865 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
1866
1867 cameraTest->captureIds = {cameraTest->captureIdPreview};
1868 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
1869 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
1870 cameraTest->imageDataSaveSwitch = SWITCH_OFF;
1871 }
1872
1873 /**
1874 * @tc.name:Camera_Device_Hdi_V1_3_046
1875 * @tc.desc:APERTURE_VIDEO mode
1876 * @tc.size:MediumTest
1877 * @tc.type:Function
1878 */
1879 HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_046, TestSize.Level1)
1880 {
1881 EXPECT_NE(cameraTest->ability, nullptr);
1882 common_metadata_header_t* data = cameraTest->ability->get();
1883 EXPECT_NE(data, nullptr);
1884 camera_metadata_item_t entry;
1885 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_CAMERA_MODES, &entry);
1886 if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR) {
1887 EXPECT_NE(entry.data.u8, nullptr);
1888 EXPECT_EQ(entry.count > 0, true);
1889 for (size_t i = 0; i < entry.count; i++ ) {
1890 uint8_t value = entry.data.u8[i];
1891 if (value == OHOS::HDI::Camera::V1_3::APERTURE_VIDEO) {
1892 CAMERA_LOGI("APERTURE_VIDEO mode is supported");
1893 } else {
1894 CAMERA_LOGI("APERTURE_VIDEO mode is not supported");
1895 }
1896 }
1897 }
1898 }
1899
1900 /**
1901 * @tc.name: Camera_Device_Hdi_V1_3_047
1902 * @tc.desc: APERTURE_VIDEO
1903 * @tc.size: MediumTest
1904 * @tc.type: Function
1905 */
1906 HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_047, TestSize.Level1)
1907 {
1908 if (!IsTagValueExistsU8(cameraTest->ability, OHOS_ABILITY_CAMERA_MODES, OHOS::HDI::Camera::V1_3::PANORAMA_PHOTO)) {
1909 cout << "skip this test, because APERTURE_VIDEO not in OHOS_ABILITY_CAMERA_MODES" << endl;
1910 return;
1911 }
1912 CAMERA_LOGI("test Camera_Device_Hdi_V1_3_047 start.");
1913
1914 // Get stream operator
1915 cameraTest->streamOperatorCallbackV1_3 = new OHOS::Camera::Test::TestStreamOperatorCallbackV1_3();
1916 cameraTest->rc = cameraTest->cameraDeviceV1_3->GetStreamOperator_V1_3(cameraTest->streamOperatorCallbackV1_3,
1917 cameraTest->streamOperator_V1_3);
1918 EXPECT_NE(cameraTest->streamOperator_V1_3, nullptr);
1919 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1920
1921 // Preview streamInfo
1922 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
1923 cameraTest->DefaultInfosPreview(cameraTest->streamInfoV1_1);
1924 cameraTest->streamInfoV1_1->v1_0.width_ = 1280;
1925 cameraTest->streamInfoV1_1->v1_0.height_ = 960;
1926 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
1927 cameraTest->streamInfoVideo = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
1928 cameraTest->DefaultInfosVideo(cameraTest->streamInfoVideo);
1929 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoVideo);
1930
1931 // Create and commitStream
1932 cameraTest->rc = cameraTest->streamOperator_V1_3->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
1933 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1934 cameraTest->rc = cameraTest->streamOperator_V1_3->CommitStreams_V1_1(
1935 static_cast<OHOS::HDI::Camera::V1_1::OperationMode_V1_1>(OHOS::HDI::Camera::V1_3::APERTURE_VIDEO),
1936 cameraTest->abilityVec);
1937 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1938
1939 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
1940 cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true);
1941 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo};
1942 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo};
1943 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
1944 }
1945
1946 /**
1947 * @tc.name: Camera_Device_Hdi_V1_3_048
1948 * @tc.desc: OHOS_CONTROL_FOCUS_ASSIST_FLASH_SUPPORTED_MODE, OHOS_CONTROL_ZOOM_RATIO, PROFESSIONAL_PHOTO
1949 * @tc.size: MediumTest
1950 * @tc.type: Function
1951 */
1952 HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_048, TestSize.Level1)
1953 {
1954 // 查询是否支持脚架检测
1955 EXPECT_NE(cameraTest->ability, nullptr);
1956 common_metadata_header_t* data = cameraTest->ability->get();
1957 EXPECT_NE(data, nullptr);
1958 camera_metadata_item_t entry;
1959 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_TRIPOD_DETECTION, &entry);
1960 if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.i32 != nullptr && entry.count > 0) {
1961 if (*entry.data.i32 == 1) {
1962 cameraTest->imageDataSaveSwitch = SWITCH_ON;
1963 cameraTest->intents = {PREVIEW, STILL_CAPTURE};
1964 cameraTest->StartStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::CAPTURE);
1965 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
1966 // 修改Zoom大于15x
1967 float zoomRatio = 15.0f;
1968 meta->addEntry(OHOS_CONTROL_ZOOM_RATIO, &zoomRatio, DATA_COUNT);
1969 // 使能脚架检测
1970 uint8_t tripoDetection = 1;
1971 meta->addEntry(OHOS_CONTROL_TRIPOD_DETECTION, &tripoDetection, DATA_COUNT);
1972 // 使能脚架检测算法
1973 uint8_t tripodStablitationAlgorithm = 1;
1974 meta->addEntry(OHOS_CONTROL_TRIPOD_STABLITATION, &tripodStablitationAlgorithm, DATA_COUNT);
1975 std::vector<uint8_t> setting;
1976 MetadataUtils::ConvertMetadataToVec(meta, setting);
1977 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
1978 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1979 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
1980 sleep(3);
1981 // 进行拍照
1982 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
1983 cameraTest->captureIds = {cameraTest->captureIdPreview};
1984 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
1985 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
1986 }
1987 }
1988 }
1989
1990 /**
1991 * @tc.name: Camera_Device_Hdi_V1_3_049
1992 * @tc.desc: OHOS_ABILITY_LCD_FLASH OHOS_CONTROL_LCD_FLASH_DETECTION OHOS_STATUS_LCD_FLASH_STATUS OHOS_CONTROL_LCD_FLASH
1993 * @tc.size: MediumTest
1994 * @tc.type: Function
1995 */
1996 HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_049, TestSize.Level1)
1997 {
1998 // 查询是否支持环形补光
1999 ASSERT_NE(cameraTest->ability, nullptr);
2000 common_metadata_header_t* data = cameraTest->ability->get();
2001 ASSERT_NE(data, nullptr);
2002 camera_metadata_item_t entry;
2003 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_LCD_FLASH, &entry);
2004 if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.i32 != nullptr && entry.count > 0) {
2005 if (*entry.data.i32 != 1) return;
2006 cameraTest->intents = {PREVIEW, STILL_CAPTURE};
2007 cameraTest->StartStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::CAPTURE);
2008 // 开启预览流
2009 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
2010 // 使能环形补光
2011 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
2012 uint8_t lcdFlashDetection = 1;
2013 meta->addEntry(OHOS_CONTROL_LCD_FLASH_DETECTION, &lcdFlashDetection, DATA_COUNT);
2014 std::vector<uint8_t> setting;
2015 MetadataUtils::ConvertMetadataToVec(meta, setting);
2016 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
2017 ASSERT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
2018 sleep(3);
2019 if (cameraTest->deviceCallback->resultMeta == nullptr) {
2020 CAMERA_LOGI("Camera_Device_Hdi_V1_3_049 onresult not be invoked.");
2021 return;
2022 }
2023 // 返回结果是否需要环形补光
2024 common_metadata_header_t* data = cameraTest->deviceCallback->resultMeta->get();
2025 if (data == nullptr) {
2026 CAMERA_LOGI("Camera_Device_Hdi_V1_3_049 onresult be invoked but data was nullptr.");
2027 return;
2028 }
2029 camera_metadata_item_t entry;
2030 cameraTest->rc = FindCameraMetadataItem(data, OHOS_STATUS_LCD_FLASH_STATUS, &entry);
2031 if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.i32 != nullptr && entry.count > 0) {
2032 if (entry.data.i32[0] != 1) return;
2033 // 使能环形补光
2034 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
2035 uint8_t lcdFlash = 1;
2036 meta->addEntry(OHOS_CONTROL_LCD_FLASH, &lcdFlash, DATA_COUNT);
2037 std::vector<uint8_t> setting;
2038 MetadataUtils::ConvertMetadataToVec(meta, setting);
2039 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
2040 ASSERT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
2041 }
2042 // 进行拍照
2043 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
2044 cameraTest->captureIds = {cameraTest->captureIdPreview};
2045 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
2046 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
2047 }
2048 }
2049
2050 /**
2051 * @tc.name: Camera_Device_Hdi_V1_3_050
2052 * @tc.desc: meta
2053 * @tc.size: MediumTest
2054 * @tc.type: Function
2055 */
2056 HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_050, TestSize.Level1)
2057 {
2058 ASSERT_NE(cameraTest->ability, nullptr);
2059 common_metadata_header_t* data = cameraTest->ability->get();
2060 ASSERT_NE(data, nullptr);
2061 cameraTest->streamOperatorCallbackV1_3 = new OHOS::Camera::Test::TestStreamOperatorCallbackV1_3();
2062 cameraTest->rc = cameraTest->cameraDeviceV1_3->GetStreamOperator_V1_3(
2063 cameraTest->streamOperatorCallbackV1_3, cameraTest->streamOperator_V1_3);
2064 ASSERT_NE(cameraTest->streamOperator_V1_3, nullptr);
2065 ASSERT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
2066
2067 // preview streamInfo
2068 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
2069 cameraTest->DefaultInfosPreviewV1_2(cameraTest->streamInfoV1_1);
2070 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
2071
2072 // meta streamInfo
2073 cameraTest->streamInfoMeta = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
2074 // meta extended streamInfo
2075 OHOS::HDI::Camera::V1_1::ExtendedStreamInfo extendedStreamInfo {
2076 .type = static_cast<OHOS::HDI::Camera::V1_1::ExtendedStreamInfoType>(
2077 OHOS::HDI::Camera::V1_3::EXTENDED_STREAM_INFO_META),
2078 .width = 0,
2079 .height = 0,
2080 .format = 0,
2081 .dataspace = 0,
2082 .bufferQueue = nullptr
2083 };
2084 cameraTest->streamInfoMeta->extendedStreamInfos = {extendedStreamInfo};
2085 cameraTest->DefaultInfosMeta(cameraTest->streamInfoMeta);
2086 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoMeta);
2087
2088 std::shared_ptr<CameraSetting> modeSetting = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
2089 uint8_t movingPhoto = static_cast<uint8_t>(OHOS_CAMERA_MOVING_PHOTO_ON);
2090 modeSetting->addEntry(OHOS_CONTROL_MOVING_PHOTO, &movingPhoto, 1);
2091 std::vector<uint8_t> metaVec;
2092 MetadataUtils::ConvertMetadataToVec(modeSetting, metaVec);
2093 cameraTest->cameraDeviceV1_3->UpdateSettings(metaVec);
2094
2095 // capture streamInfo
2096 cameraTest->streamInfoCapture = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
2097 cameraTest->DefaultInfosCapture(cameraTest->streamInfoCapture);
2098 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoCapture);
2099
2100 cameraTest->rc = cameraTest->streamOperator_V1_3->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
2101 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
2102 cameraTest->rc = cameraTest->streamOperator_V1_3->CommitStreams(
2103 OperationMode::NORMAL, cameraTest->abilityVec);
2104 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
2105 sleep(UT_SECOND_TIMES);
2106 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
2107 cameraTest->StartCapture(cameraTest->streamIdMeta, cameraTest->captureIdMeta, false, true);
2108 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
2109 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdMeta};
2110 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdMeta};
2111 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
2112 }
2113
2114 /**
2115 * @tc.name: Camera_Device_Hdi_V1_3_051
2116 * @tc.desc: OHOS_ABILITY_DEPTH_DATA_PROFILES
2117 * @tc.size: MediumTest
2118 * @tc.type: Function
2119 */
2120 HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_051, TestSize.Level1)
2121 {
2122 ASSERT_NE(cameraTest->ability, nullptr);
2123 common_metadata_header_t* data = cameraTest->ability->get();
2124 ASSERT_NE(data, nullptr);
2125 camera_metadata_item_t entry;
2126
2127 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_DEPTH_DATA_PROFILES, &entry);
2128 if (cameraTest->rc != HDI::Camera::V1_0::NO_ERROR) {
2129 CAMERA_LOGI("OHOS_ABILITY_DEPTH_DATA_PROFILES is not support.");
2130 return;
2131 }
2132 if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.i32 != nullptr && entry.count > 0) {
2133 CAMERA_LOGI("print tag<OHOS_ABILITY_DEPTH_DATA_PROFILES> i32 value start.");
2134 constexpr size_t step = 10;
2135 std::stringstream ss;
2136 for (size_t i = 0; i < entry.count; i++) {
2137 ss << entry.data.i32[i] << " ";
2138 if ((i != 0) && (i % step == 0 || i == entry.count - 1)) {
2139 CAMERA_LOGI("%{public}s\n", ss.str().c_str());
2140 printf("OHOS_ABILITY_DEPTH_DATA_PROFILES %s\n", ss.str().c_str());
2141 ss.clear();
2142 ss.str("");
2143 }
2144 }
2145 CAMERA_LOGI("print tag<OHOS_ABILITY_DEPTH_DATA_PROFILES> i32 value end.");
2146 }
2147 }
2148
2149 /**
2150 * @tc.name: Camera_Device_Hdi_V1_3_052
2151 * @tc.desc: OHOS_CONTROL_DEPTH_DATA_ACCURACY
2152 * @tc.size: MediumTest
2153 * @tc.type: Function
2154 */
2155 HWTEST_F(CameraHdiUtTestV1_3, Camera_Device_Hdi_V1_3_052, TestSize.Level1)
2156 {
2157 CAMERA_LOGI("test Camera_Device_Hdi_V1_3_052 start.");
2158 cameraTest->streamOperatorCallbackV1_3 = new OHOS::Camera::Test::TestStreamOperatorCallbackV1_3();
2159 cameraTest->rc = cameraTest->cameraDeviceV1_3->GetStreamOperator_V1_3(
2160 cameraTest->streamOperatorCallbackV1_3, cameraTest->streamOperator_V1_3);
2161 ASSERT_NE(cameraTest->streamOperator_V1_3, nullptr);
2162
2163 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
2164 cameraTest->DefaultInfosPreview(cameraTest->streamInfoV1_1);
2165 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
2166
2167 cameraTest->streamInfoCapture = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
2168 cameraTest->DefaultInfosCapture(cameraTest->streamInfoCapture);
2169 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoCapture);
2170
2171 std::shared_ptr<CameraSetting> modeSetting = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
2172 uint8_t depthDataAccuracy = static_cast<uint8_t>(OHOS_DEPTH_DATA_ACCURACY_RELATIVE);
2173 modeSetting->addEntry(OHOS_CONTROL_DEPTH_DATA_ACCURACY, &depthDataAccuracy, 1);
2174 std::vector<uint8_t> metaVec;
2175 MetadataUtils::ConvertMetadataToVec(modeSetting, metaVec);
2176 cameraTest->cameraDeviceV1_3->UpdateSettings(metaVec);
2177
2178 cameraTest->rc = cameraTest->streamOperator_V1_3->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
2179 ASSERT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
2180 cameraTest->rc = cameraTest->streamOperator_V1_3->CommitStreams(OperationMode::NORMAL, cameraTest->abilityVec);
2181 ASSERT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
2182
2183 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
2184 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
2185 cameraTest->captureIds = {cameraTest->captureIdPreview};
2186 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
2187 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
2188 }