1 /*
2 * Copyright (c) 2024-2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file expected in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include "camera_hdi_test_v1_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 int64_t OHOS::Camera::Test::StreamConsumer::g_timestamp[2] = {0};
SetUpTestCase(void)28 void CameraHdiTestV1_3::SetUpTestCase(void) {}
TearDownTestCase(void)29 void CameraHdiTestV1_3::TearDownTestCase(void) {}
SetUp(void)30 void CameraHdiTestV1_3::SetUp(void)
31 {
32 cameraTest = std::make_shared<OHOS::Camera::Test>();
33 cameraTest->Init(); // assert inside
34 cameraTest->Open(DEVICE_0); // assert inside
35 }
36
TearDown(void)37 void CameraHdiTestV1_3::TearDown(void)
38 {
39 cameraTest->Close();
40 }
41
g_IsTagValueExistsU8(std::shared_ptr<CameraMetadata> ability,uint32_t tag,uint8_t value)42 bool g_IsTagValueExistsU8(std::shared_ptr<CameraMetadata> ability, uint32_t tag, uint8_t value)
43 {
44 common_metadata_header_t* data = ability->get();
45 camera_metadata_item_t entry;
46 int ret = FindCameraMetadataItem(data, tag, &entry);
47 if (ret == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) {
48 for (int i = 0; i < entry.count; i++) {
49 if (entry.data.u8[i] == value) {
50 return true;
51 }
52 }
53 } else {
54 printf("Find CameraMetadata fail!\n");
55 CAMERA_LOGE("Find CameraMetadata fail!");
56 }
57 return false;
58 }
59
60 /**
61 * @tc.name:SUB_Driver_Camera_Moon_0200
62 * @tc.desc: Update moon ability setting
63 * @tc.size:MediumTest
64 * @tc.type:Function
65 */
66 HWTEST_F(CameraHdiTestV1_3, SUB_Driver_Camera_Moon_0200, TestSize.Level1)
67 {
68 int32_t rc;
69 // step 2: set callback object
70 cameraTest->hostCallbackV1_2 = new OHOS::Camera::Test::TestCameraHostCallbackV1_2();
71 rc = cameraTest->serviceV1_3->SetCallback_V1_2(cameraTest->hostCallbackV1_2);
72 EXPECT_EQ(rc, 0);
73 // Start OHOS_ABILITY_MOON_CAPTURE_BOOST ability query
74 common_metadata_header_t* data = cameraTest->ability->get();
75 EXPECT_NE(data, nullptr);
76 camera_metadata_item_t entry;
77 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_MOON_CAPTURE_BOOST, &entry);
78
79 if (ret == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) {
80 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
81 constexpr float zoomRatio = 15;
82 uint8_t stabControl = OHOS_CAMERA_MOON_CAPTURE_BOOST_ENABLE;
83 meta->addEntry(OHOS_CONTROL_ZOOM_RATIO, &zoomRatio, DATA_COUNT);
84 meta->addEntry(OHOS_CONTROL_MOON_CAPTURE_BOOST, &stabControl, DATA_COUNT);
85 // ability meta data serialization for updating
86 std::vector<uint8_t> setting;
87 MetadataUtils::ConvertMetadataToVec(meta, setting);
88 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
89 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
90 CAMERA_LOGD("MoonCaptureBoost mode is set enabled.");
91
92 cameraTest->intents = {PREVIEW, STILL_CAPTURE};
93 cameraTest->StartStream(cameraTest->intents);
94 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
95 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
96 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, true);
97 sleep(1);
98 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdCapture};
99 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
100 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
101 sleep(UT_SECOND_TIMES);
102 common_metadata_header_t* data = cameraTest->deviceCallback->resultMeta->get();
103 EXPECT_NE(data, nullptr);
104 camera_metadata_item_t entry;
105 int ret = FindCameraMetadataItem(data, OHOS_STATUS_MOON_CAPTURE_DETECTION, &entry);
106 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, ret);
107 if (ret == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) {
108 uint8_t value = entry.data.u8[0];
109 // 查询到状态， 检测状态到 月亮模式可开启
110 if (OHOS_CAMERA_MOON_CAPTURE_BOOST_ENABLE == value) {
111 printf("Moon mode is set enabled.");
112 } else {
113 printf("Moon mode is not enabled.");
114 }
115 } else {
116 printf("Moon is not exits.");
117 }
118 }
119 }
120
121 /**
122 * @tc.name:SUB_Driver_Camera_Moon_0300
123 * @tc.desc: Update moon ability setting
124 * @tc.size:MediumTest
125 * @tc.type:Function
126 */
127 HWTEST_F(CameraHdiTestV1_3, SUB_Driver_Camera_Moon_0300, TestSize.Level1)
128 {
129 int32_t rc;
130 // step 2: set callback object
131 cameraTest->hostCallbackV1_2 = new OHOS::Camera::Test::TestCameraHostCallbackV1_2();
132 rc = cameraTest->serviceV1_3->SetCallback_V1_2(cameraTest->hostCallbackV1_2);
133 EXPECT_EQ(rc, 0);
134 // Start OHOS_ABILITY_MOON_CAPTURE_BOOST ability query
135 common_metadata_header_t* data = cameraTest->ability->get();
136 EXPECT_NE(data, nullptr);
137 camera_metadata_item_t entry;
138 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_MOON_CAPTURE_BOOST, &entry);
139
140 if (ret == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) {
141 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
142 constexpr float zoomRatio = 15;
143 uint8_t stabControl = OHOS_CAMERA_MOON_CAPTURE_BOOST_ENABLE;
144 meta->addEntry(OHOS_CONTROL_ZOOM_RATIO, &zoomRatio, DATA_COUNT);
145 meta->addEntry(OHOS_CONTROL_MOON_CAPTURE_BOOST, &stabControl, DATA_COUNT);
146 // ability meta data serialization for updating
147 std::vector<uint8_t> setting;
148 MetadataUtils::ConvertMetadataToVec(meta, setting);
149 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
150 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
151 CAMERA_LOGD("MoonCaptureBoost mode is set enabled.");
152
153 cameraTest->intents = {PREVIEW, STILL_CAPTURE};
154 cameraTest->StartStream(cameraTest->intents);
155 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
156 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
157 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, true);
158 sleep(1);
159 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdCapture};
160 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
161 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
162 }
163 }
164
165 /**
166 * @tc.name: SUB_Driver_Camera_SlowMotion_0300
167 * @tc.desc: CommitStreams_V1_1 for HIGH_FRAME_RATE, preview and video, fps is 120
168 * @tc.size: MediumTest
169 * @tc.type: Function
170 */
171 HWTEST_F(CameraHdiTestV1_3, SUB_Driver_Camera_SlowMotion_0300, TestSize.Level1)
172 {
173 if (!g_IsTagValueExistsU8(cameraTest->ability, OHOS_ABILITY_CAMERA_MODES, OHOS::HDI::Camera::V1_3::HIGH_FRAME_RATE)) {
174 cout << "skip this test, because HIGH_FRAME_RATE not in OHOS_ABILITY_CAMERA_MODES" << endl;
175 return;
176 }
177 cameraTest->CreateAndCommitStreamsForHighFrameRate(cameraTest);
178 // Update settings
179 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
180 int32_t highFrameRate[2] = {120, 120};
181 meta->addEntry(OHOS_CONTROL_FPS_RANGES, &highFrameRate, FPS_COUNT);
182 std::vector<uint8_t> setting;
183 MetadataUtils::ConvertMetadataToVec(meta, setting);
184 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
185 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
186
187 // Start capture
188 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
189 cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true);
190
191 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo};
192 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo};
193 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
194 sleep(DATA_COUNT);
195 cameraTest->streamInfosV1_1.clear();
196 }
197
198 /**
199 * @tc.name: SUB_Driver_Camera_SlowMotion_0400
200 * @tc.desc: CommitStreams_V1_1 for HIGH_FRAME_RATE, preview and video, fps is 240
201 * @tc.size: MediumTest
202 * @tc.type: Function
203 */
204 HWTEST_F(CameraHdiTestV1_3, SUB_Driver_Camera_SlowMotion_0400, TestSize.Level1)
205 {
206 if (!g_IsTagValueExistsU8(cameraTest->ability, OHOS_ABILITY_CAMERA_MODES, OHOS::HDI::Camera::V1_3::HIGH_FRAME_RATE)) {
207 cout << "skip this test, because HIGH_FRAME_RATE not in OHOS_ABILITY_CAMERA_MODES" << endl;
208 return;
209 }
210 cameraTest->CreateAndCommitStreamsForHighFrameRate(cameraTest);
211
212 // Update settings
213 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
214 int32_t highFrameRate[2] = {240, 240};
215 meta->addEntry(OHOS_CONTROL_FPS_RANGES, &highFrameRate, FPS_COUNT);
216 std::vector<uint8_t> setting;
217 MetadataUtils::ConvertMetadataToVec(meta, setting);
218 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
219 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
220
221 // Start capture
222 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
223 cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true);
224
225 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo};
226 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo};
227 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
228 sleep(DATA_COUNT);
229 cameraTest->streamInfosV1_1.clear();
230 }
231
232
233 /**
234 * @tc.name: SUB_Driver_Camera_SuperSlowMotion_0400
235 * @tc.desc: CommitStreams_V1_1 for SLOW_MOTION, preview and video, fps is 960
236 * @tc.size: MediumTest
237 * @tc.type: Function
238 */
239 HWTEST_F(CameraHdiTestV1_3, SUB_Driver_Camera_SuperSlowMotion_0400, TestSize.Level1)
240 {
241 if (!g_IsTagValueExistsU8(cameraTest->ability, OHOS_ABILITY_CAMERA_MODES, OHOS::HDI::Camera::V1_2::SLOW_MOTION)) {
242 cout << "skip this test, because SLOW_MOTION not in OHOS_ABILITY_CAMERA_MODES" << endl;
243 return;
244 }
245 cameraTest->CreateAndCommitStreamsForSlowMotion(cameraTest);
246
247 // Update settings
248 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
249 int32_t slowMotionValue[2] = {240, 240};
250 meta->addEntry(OHOS_CONTROL_FPS_RANGES, &slowMotionValue, FPS_COUNT);
251 std::vector<uint8_t> setting;
252 MetadataUtils::ConvertMetadataToVec(meta, setting);
253 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
254 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
255
256 // Start capture
257 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
258 cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true);
259
260 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo};
261 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo};
262 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
263 sleep(DATA_COUNT);
264 cameraTest->streamInfosV1_1.clear();
265 }
266
267 /**
268 * @tc.name: SUB_Driver_Camera_SuperSlowMotion_0200
269 * @tc.desc: OHOS_ABILITY_MOTION_DETECTION_SUPPORT, OHOS_CAMERA_MOTION_DETECTION_SUPPORTED
270 * @tc.size: MediumTest
271 * @tc.type: Function
272 */
273 HWTEST_F(CameraHdiTestV1_3, SUB_Driver_Camera_SuperSlowMotion_0200, TestSize.Level1)
274 {
275 if (!g_IsTagValueExistsU8(cameraTest->ability, OHOS_ABILITY_CAMERA_MODES, OHOS::HDI::Camera::V1_2::SLOW_MOTION)) {
276 cout << "skip this test, because SLOW_MOTION not in OHOS_ABILITY_CAMERA_MODES" << endl;
277 return;
278 }
279 // Set callback object
280 cameraTest->hostCallbackV1_2 = new OHOS::Camera::Test::TestCameraHostCallbackV1_2();
281 cameraTest->rc = cameraTest->serviceV1_3->SetCallback_V1_2(cameraTest->hostCallbackV1_2);
282 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
283 EXPECT_NE(cameraTest->ability, nullptr);
284 common_metadata_header_t* data = cameraTest->ability->get();
285 EXPECT_NE(data, nullptr);
286 camera_metadata_item_t entry;
287 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_MOTION_DETECTION_SUPPORT, &entry);
288 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
289 if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) {
290 EXPECT_TRUE(entry.data.u8 != nullptr);
291 if (entry.data.u8[0] == OHOS_CAMERA_MOTION_DETECTION_SUPPORTED) {
292 cameraTest->CreateAndCommitStreamsForSlowMotion(cameraTest);
293 cameraTest->UpdateSettingsForSlowMotionMode(cameraTest);
294 cameraTest->SuperSlowMotionStatusCallback(cameraTest);
295 }
296 }
297 }
298
299 /**
300 * @tc.name:SUB_Driver_Camera_PerOptimization_0100
301 * @tc.desc:CAPTURE_DURATION
302 * @tc.size:MediumTest
303 * @tc.type:Function
304 */
305 HWTEST_F(CameraHdiTestV1_3, SUB_Driver_Camera_PerOptimization_0100, TestSize.Level1)
306 {
307 EXPECT_NE(cameraTest->ability, nullptr);
308 common_metadata_header_t* data = cameraTest->ability->get();
309 EXPECT_NE(data, nullptr);
310 camera_metadata_item_t entry;
311 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_CAPTURE_DURATION_SUPPORTED, &entry);
312 if (cameraTest->rc != 0 || entry.data.u8[0] != 1) {
313 cout << "skip this test, because OHOS_ABILITY_CAPTURE_DURATION_SUPPORTED not supported now" << endl;
314 return;
315 }
316
317 // Start stream
318 cameraTest->intents = {PREVIEW, STILL_CAPTURE};
319 cameraTest->StartStream(cameraTest->intents);
320
321 // Fill capture setting
322 std::shared_ptr<CameraSetting> modeSetting = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
323 uint8_t muteMode = static_cast<uint8_t>(OHOS_CAMERA_MUTE_MODE_OFF);
324 modeSetting->addEntry(OHOS_CONTROL_MUTE_MODE, &muteMode, DATA_COUNT);
325 uint8_t deferredImage = OHOS::HDI::Camera::V1_2::STILL_IMAGE;
326 modeSetting->addEntry(OHOS_CONTROL_DEFERRED_IMAGE_DELIVERY, &deferredImage, DATA_COUNT);
327 std::vector<uint8_t> controlVec;
328 MetadataUtils::ConvertMetadataToVec(modeSetting, controlVec);
329 cameraTest->abilityVec = controlVec;
330
331 // Start preview and capture
332 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, true, true);
333 // OncaptureReady trigger
334 for (uint8_t i = 0; i < 2; i++) {
335 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
336 }
337
338 // Release stream
339 cameraTest->captureIds = {cameraTest->captureIdPreview};
340 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
341 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
342
343 sleep(UT_SECOND_TIMES);
344 common_metadata_header_t* callbackData = cameraTest->deviceCallback->resultMeta->get();
345 EXPECT_NE(callbackData, nullptr);
346 camera_metadata_item_t callbackEntry;
347 cameraTest->rc = FindCameraMetadataItem(callbackData, OHOS_CAMERA_CUSTOM_SNAPSHOT_DURATION, &callbackEntry);
348 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
349 printf("currentSnapshotDuration = %d\n", callbackEntry.data.ui32[0]);
350 }
351
352 /**
353 * @tc.name: SUB_Driver_Camera_Moving_0200
354 * @tc.desc: OHOS_CONTROL_MOVING_PHOTO OHOS_CAMERA_MOVING_PHOTO_OFF
355 * @tc.size: MediumTest
356 * @tc.type: Function
357 */
358 HWTEST_F(CameraHdiTestV1_3, SUB_Driver_Camera_Moving_0200, TestSize.Level1)
359 {
360 CAMERA_LOGI("test Camera_Device_Hdi_V1_3_013 start.");
361 cameraTest->streamOperatorCallbackV1_3 = new OHOS::Camera::Test::TestStreamOperatorCallbackV1_3();
362 cameraTest->rc = cameraTest->cameraDeviceV1_3->GetStreamOperator_V1_3(
363 cameraTest->streamOperatorCallbackV1_3, cameraTest->streamOperator_V1_3);
364 EXPECT_NE(cameraTest->streamOperator_V1_3, nullptr);
365
366 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
367 cameraTest->DefaultInfosPreview(cameraTest->streamInfoV1_1);
368 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
369
370 cameraTest->streamInfoCapture = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
371 cameraTest->DefaultInfosCapture(cameraTest->streamInfoCapture);
372 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoCapture);
373
374 std::shared_ptr<CameraSetting> modeSetting = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
375 uint8_t movingPhoto = static_cast<uint8_t>(OHOS_CAMERA_MOVING_PHOTO_OFF);
376 modeSetting->addEntry(OHOS_CONTROL_MOVING_PHOTO, &movingPhoto, 1);
377 std::vector<uint8_t> metaVec;
378 MetadataUtils::ConvertMetadataToVec(modeSetting, metaVec);
379 cameraTest->cameraDeviceV1_3->UpdateSettings(metaVec);
380
381 cameraTest->rc = cameraTest->streamOperator_V1_3->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
382 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
383 cameraTest->rc = cameraTest->streamOperator_V1_3->CommitStreams(OperationMode::NORMAL, cameraTest->abilityVec);
384 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
385
386 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
387 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
388 cameraTest->captureIds = {cameraTest->captureIdPreview};
389 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
390 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
391 }
392
393 /**
394 * @tc.name: SUB_Driver_Camera_Moving_0300
395 * @tc.desc: OHOS_CONTROL_MOVING_PHOTO OHOS_CAMERA_MOVING_PHOTO_ON
396 * @tc.size: MediumTest
397 * @tc.type: Function
398 */
399 HWTEST_F(CameraHdiTestV1_3, SUB_Driver_Camera_Moving_0300, TestSize.Level1)
400 {
401 CAMERA_LOGI("test Moving Photo Switch On");
402 cameraTest->streamOperatorCallbackV1_3 = new OHOS::Camera::Test::TestStreamOperatorCallbackV1_3();
403 cameraTest->rc = cameraTest->cameraDeviceV1_3->GetStreamOperator_V1_3(
404 cameraTest->streamOperatorCallbackV1_3, cameraTest->streamOperator_V1_3);
405 EXPECT_NE(cameraTest->streamOperator_V1_3, nullptr);
406
407 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
408 cameraTest->DefaultInfosPreview(cameraTest->streamInfoV1_1);
409 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
410
411 cameraTest->streamInfoCapture = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
412 cameraTest->DefaultInfosCapture(cameraTest->streamInfoCapture);
413 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoCapture);
414
415 std::shared_ptr<CameraSetting> modeSetting = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
416 uint8_t movingPhoto = static_cast<uint8_t>(OHOS_CAMERA_MOVING_PHOTO_ON);
417 modeSetting->addEntry(OHOS_CONTROL_MOVING_PHOTO, &movingPhoto, 1);
418 std::vector<uint8_t> metaVec;
419 MetadataUtils::ConvertMetadataToVec(modeSetting, metaVec);
420 cameraTest->cameraDeviceV1_3->UpdateSettings(metaVec);
421
422 cameraTest->rc = cameraTest->streamOperator_V1_3->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
423 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
424 cameraTest->rc = cameraTest->streamOperator_V1_3->CommitStreams(OperationMode::NORMAL, cameraTest->abilityVec);
425 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
426
427 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
428 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
429 cameraTest->captureIds = {cameraTest->captureIdPreview};
430 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
431 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
432 }
433
434 /**
435 * @tc.name: SUB_Driver_Camera_HighSolution_0200
436 * @tc.desc: CommitStreams_V1_1 for HIGH_RESOLUTION_PHOTO, preview and capture
437 * @tc.size: MediumTest
438 * @tc.type: Function
439 */
440 HWTEST_F(CameraHdiTestV1_3, SUB_Driver_Camera_HighResolution_0200, TestSize.Level1)
441 {
442 if (!g_IsTagValueExistsU8(cameraTest->ability,
443 OHOS_ABILITY_CAMERA_MODES, OHOS::HDI::Camera::V1_3::HIGH_RESOLUTION_PHOTO)) {
444 cout << "skip this test, because HIGH_RESOLUTION_PHOTO not in OHOS_ABILITY_CAMERA_MODES" << endl;
445 return;
446 }
447 EXPECT_NE(cameraTest->ability, nullptr);
448 common_metadata_header_t* data = cameraTest->ability->get();
449 EXPECT_NE(data, nullptr);
450 camera_metadata_item_t entry;
451 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_CAPTURE_EXPECT_TIME, &entry);
452 if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR) {
453 EXPECT_NE(entry.data.ui32, nullptr);
454 EXPECT_EQ(entry.count > 1, true);
455 CAMERA_LOGI("mode is %{public}u and captureExpectTime is %{public}u", entry.data.ui32[0], entry.data.ui32[1]);
456 }
457 cameraTest->startStreamForHighResolutionPhoto(cameraTest);
458
459 // Update settings
460 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
461 int32_t aeExposureCompensation = EXPOSURE_COUNT;
462 meta->addEntry(OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, &aeExposureCompensation, DATA_COUNT);
463 uint8_t focusMode = OHOS_CAMERA_FOCUS_MODE_AUTO;
464 meta->addEntry(OHOS_CONTROL_FOCUS_MODE, &focusMode, DATA_COUNT);
465 std::vector<uint8_t> setting;
466 MetadataUtils::ConvertMetadataToVec(meta, setting);
467 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
468 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
469
470 sleep(UT_SECOND_TIMES);
471 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
472 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
473 cameraTest->captureIds = {cameraTest->captureIdPreview};
474 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
475 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
476 }
477
478 /**
479 * @tc.name: SUB_Driver_Camera_SMPhoto_0200
480 * @tc.desc: CommitStreams_V1_1 for CAPTURE_MACRO, preview and capture
481 * @tc.size: MediumTest
482 * @tc.type: Function
483 */
484 HWTEST_F(CameraHdiTestV1_3, SUB_Driver_Camera_SMPhoto_0200, TestSize.Level1)
485 {
486 if (!g_IsTagValueExistsU8(cameraTest->ability, OHOS_ABILITY_CAMERA_MODES, OHOS::HDI::Camera::V1_3::CAPTURE_MACRO)) {
487 cout << "skip this test, because CAPTURE_MACRO not in OHOS_ABILITY_CAMERA_MODES" << endl;
488 return;
489 }
490 // Get stream operator
491 cameraTest->streamOperatorCallbackV1_3 = new OHOS::Camera::Test::TestStreamOperatorCallbackV1_3();
492 cameraTest->rc = cameraTest->cameraDeviceV1_3->GetStreamOperator_V1_3(cameraTest->streamOperatorCallbackV1_3,
493 cameraTest->streamOperator_V1_3);
494 EXPECT_NE(cameraTest->streamOperator_V1_3, nullptr);
495 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
496 // Preview streamInfo
497 cameraTest->streamInfoPre = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
498 cameraTest->DefaultInfosPreview(cameraTest->streamInfoPre);
499 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoPre);
500 // Capture streamInfo
501 cameraTest->streamInfoCapture = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
502 cameraTest->DefaultInfosCapture(cameraTest->streamInfoCapture);
503 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoCapture);
504 cameraTest->rc = cameraTest->streamOperator_V1_3->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
505 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
506 cameraTest->rc = cameraTest->streamOperator_V1_3->CommitStreams_V1_1(
507 static_cast<OHOS::HDI::Camera::V1_1::OperationMode_V1_1>(OHOS::HDI::Camera::V1_3::CAPTURE_MACRO),
508 cameraTest->abilityVec);
509 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
510
511 // Update settings
512 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
513 float lensFocusDistance = DATA_COUNT;
514 meta->addEntry(OHOS_CONTROL_LENS_FOCUS_DISTANCE, &lensFocusDistance, DATA_COUNT);
515 std::vector<uint8_t> setting;
516 MetadataUtils::ConvertMetadataToVec(meta, setting);
517 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
518 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
519
520 sleep(UT_SECOND_TIMES);
521 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
522 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
523
524 cameraTest->captureIds = {cameraTest->captureIdPreview};
525 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
526 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
527 }
528
529 /**
530 * @tc.name: SUB_Driver_Camera_SMVideo_0200
531 * @tc.desc: CommitStreams_V1_1 for VIDEO_MACRO, preview and capture
532 * @tc.size: MediumTest
533 * @tc.type: Function
534 */
535 HWTEST_F(CameraHdiTestV1_3, SUB_Driver_Camera_SMVideo_0200, TestSize.Level1)
536 {
537 if (!g_IsTagValueExistsU8(cameraTest->ability, OHOS_ABILITY_CAMERA_MODES, OHOS::HDI::Camera::V1_3::VIDEO_MACRO)) {
538 cout << "skip this test, because VIDEO_MACRO not in OHOS_ABILITY_CAMERA_MODES" << endl;
539 return;
540 }
541 // Get stream operator
542 cameraTest->streamOperatorCallbackV1_3 = new OHOS::Camera::Test::TestStreamOperatorCallbackV1_3();
543 cameraTest->rc = cameraTest->cameraDeviceV1_3->GetStreamOperator_V1_3(cameraTest->streamOperatorCallbackV1_3,
544 cameraTest->streamOperator_V1_3);
545 EXPECT_NE(cameraTest->streamOperator_V1_3, nullptr);
546 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
547 // Preview streamInfo
548 cameraTest->streamInfoPre = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
549 cameraTest->DefaultInfosPreview(cameraTest->streamInfoPre);
550 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoPre);
551 // Capture streamInfo
552 cameraTest->streamInfoVideo = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
553 cameraTest->DefaultInfosVideo(cameraTest->streamInfoVideo);
554 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoVideo);
555 // Create and commit streams
556 cameraTest->rc = cameraTest->streamOperator_V1_3->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
557 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
558 cameraTest->rc = cameraTest->streamOperator_V1_3->CommitStreams_V1_1(
559 static_cast<OHOS::HDI::Camera::V1_1::OperationMode_V1_1>(OHOS::HDI::Camera::V1_3::VIDEO_MACRO),
560 cameraTest->abilityVec);
561 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
562 // Update settings
563 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
564 float lensFocusDistance = DATA_COUNT;
565 meta->addEntry(OHOS_CONTROL_LENS_FOCUS_DISTANCE, &lensFocusDistance, DATA_COUNT);
566 std::vector<uint8_t> setting;
567 MetadataUtils::ConvertMetadataToVec(meta, setting);
568 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
569 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
570 sleep(UT_SECOND_TIMES);
571 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
572 cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true);
573 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo};
574 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo};
575 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
576 }
577
578 /**
579 * @tc.name:SUB_Driver_Camera_DynamicFps_0100
580 * @tc.desc:Dynamic FPS configuration, range setting, streams fps constrain
581 * @tc.size:MediumTest
582 * @tc.type:Function
583 */
584 HWTEST_F(CameraHdiTestV1_3, SUB_Driver_Camera_DynamicFps_0100, TestSize.Level1)
585 {
586 // PREVIEW and VIDEO stream
587 cameraTest->intents = {PREVIEW, VIDEO};
588 // This requirement only in VIDEO mode
589 cameraTest->StartStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::OperationMode::VIDEO);
590 // Bind fps range with preview stream and video stream
591 common_metadata_header_t* data = cameraTest->ability->get();
592 EXPECT_NE(data, nullptr);
593 camera_metadata_item_t entry;
594 cameraTest->rc = FindCameraMetadataItem(data, OHOS_CONTROL_FPS_RANGES, &entry);
595 // The FPS only valid in current release, non backward compatibility
596 int32_t fpsRanges[] = {1, 30};
597 bool result;
598 if (cameraTest->rc != CAM_META_SUCCESS) {
599 std::cout << "Not found TAG[OHOS_CONTROL_FPS_RANGES], insert one" << std::endl;
600 result = cameraTest->ability->addEntry(OHOS_CONTROL_FPS_RANGES,
601 fpsRanges, sizeof(fpsRanges) / sizeof(int32_t));
602 EXPECT_EQ(true, result);
603 } else {
604 std::cout << "Found TAG[OHOS_CONTROL_FPS_RANGES], Update it" << std::endl;
605 result = cameraTest->ability->updateEntry(OHOS_CONTROL_FPS_RANGES,
606 fpsRanges, sizeof(fpsRanges) / sizeof(int32_t));
607 EXPECT_EQ(true, result);
608 }
609 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(cameraTest->ability, cameraTest->abilityVec);
610 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
611 cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true);
612 // Release stream
613 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo};
614 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo};
615 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
616 }
617
618 /**
619 * @tc.name:SUB_Driver_Camera_DynamicFps_0200
620 * @tc.desc:Dynamic FPS configuration, range setting, streams fps constrain
621 * @tc.size:MediumTest
622 * @tc.type:Function
623 */
624 HWTEST_F(CameraHdiTestV1_3, SUB_Driver_Camera_DynamicFps_0200, TestSize.Level1)
625 {
626 // PREVIEW and VIDEO stream
627 cameraTest->intents = {PREVIEW, VIDEO};
628 // This requirement only in VIDEO mode
629 cameraTest->StartStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::OperationMode::VIDEO);
630 // Bind fps range with preview stream and video stream
631 common_metadata_header_t* data = cameraTest->ability->get();
632 EXPECT_NE(data, nullptr);
633 camera_metadata_item_t entry;
634 cameraTest->rc = FindCameraMetadataItem(data, OHOS_CONTROL_FPS_RANGES, &entry);
635 // The FPS only valid in current release, non backward compatibility
636 int32_t fpsRanges[] = {35, 60};
637 bool result;
638 if (cameraTest->rc != CAM_META_SUCCESS) {
639 std::cout << "Not found TAG[OHOS_CONTROL_FPS_RANGES], insert one" << std::endl;
640 result = cameraTest->ability->addEntry(OHOS_CONTROL_FPS_RANGES,
641 fpsRanges, sizeof(fpsRanges) / sizeof(int32_t));
642 EXPECT_EQ(true, result);
643 } else {
644 std::cout << "Found TAG[OHOS_CONTROL_FPS_RANGES], Update it" << std::endl;
645 result = cameraTest->ability->updateEntry(OHOS_CONTROL_FPS_RANGES,
646 fpsRanges, sizeof(fpsRanges) / sizeof(int32_t));
647 EXPECT_EQ(true, result);
648 }
649 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(cameraTest->ability, cameraTest->abilityVec);
650 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
651 cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true);
652 // Release stream
653 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo};
654 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo};
655 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
656 }
657
658 /**
659 + * @tc.name:SUB_Driver_Camera_DynamicFps_0300
660 + * @tc.desc:Dynamic FPS configuration, fixed fps setting, streams fps constrain
661 + * @tc.size:MediumTest
662 + * @tc.type:Function
663 +*/
664 HWTEST_F(CameraHdiTestV1_3, SUB_Driver_Camera_DynamicFps_0300, TestSize.Level1)
665 {
666 // PREVIEW and VIDEO stream
667 cameraTest->intents = {PREVIEW, VIDEO};
668 // This requirement only in VIDEO mode
669 cameraTest->StartStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::OperationMode::VIDEO);
670 // Bind fixed fps with preview stream and video stream, constraint
671 common_metadata_header_t* data = cameraTest->ability->get();
672 EXPECT_NE(data, nullptr);
673 camera_metadata_item_t entry;
674 cameraTest->rc = FindCameraMetadataItem(data, OHOS_CONTROL_FPS_RANGES, &entry);
675 // The FPS only valid in current release, non backward compatibility
676 int32_t previewFixedFps[] = {30, 30};
677 bool result;
678 if (cameraTest->rc != CAM_META_SUCCESS) {
679 std::cout << "Not found TAG[OHOS_CONTROL_FPS_RANGES], insert one" << std::endl;
680 result = cameraTest->ability->addEntry(OHOS_CONTROL_FPS_RANGES,
681 previewFixedFps, sizeof(previewFixedFps) / sizeof(int32_t));
682 EXPECT_EQ(true, result);
683 } else {
684 std::cout << "Found TAG[OHOS_CONTROL_FPS_RANGES], Update it" << std::endl;
685 result = cameraTest->ability->updateEntry(OHOS_CONTROL_FPS_RANGES,
686 previewFixedFps, sizeof(previewFixedFps) / sizeof(int32_t));
687 EXPECT_EQ(true, result);
688 }
689 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(cameraTest->ability, cameraTest->abilityVec);
690 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
691 // Update video fixed fps, constraint relationship
692 int32_t videoFixedFps[] = {60, 60};
693 std::cout << "Update fixed fps for video capture" << std::endl;
694 result = cameraTest->ability->updateEntry(OHOS_CONTROL_FPS_RANGES,
695 videoFixedFps, sizeof(videoFixedFps) / sizeof(int32_t));
696 EXPECT_EQ(true, result);
697 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(cameraTest->ability, cameraTest->abilityVec);
698 cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true);
699 // Release stream
700 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo};
701 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo};
702 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
703 }
704
705 /**
706 + * @tc.name:SUB_Driver_Camera_DynamicFps_0400
707 + * @tc.desc:Dynamic FPS configuration, fixed fps setting, streams fps constrain
708 + * @tc.size:MediumTest
709 + * @tc.type:Function
710 +*/
711 HWTEST_F(CameraHdiTestV1_3, SUB_Driver_Camera_DynamicFps_0400, TestSize.Level1)
712 {
713 // PREVIEW and VIDEO stream
714 cameraTest->intents = {PREVIEW, VIDEO};
715 // This requirement only in VIDEO mode
716 cameraTest->StartStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::OperationMode::VIDEO);
717 // Bind fixed fps with preview stream and video stream, constraint
718 common_metadata_header_t* data = cameraTest->ability->get();
719 EXPECT_NE(data, nullptr);
720 camera_metadata_item_t entry;
721 cameraTest->rc = FindCameraMetadataItem(data, OHOS_CONTROL_FPS_RANGES, &entry);
722 // The FPS only valid in current release, non backward compatibility
723 int32_t previewFixedFps[] = {45, 45};
724 bool result;
725 if (cameraTest->rc != CAM_META_SUCCESS) {
726 std::cout << "Not found TAG[OHOS_CONTROL_FPS_RANGES], insert one" << std::endl;
727 result = cameraTest->ability->addEntry(OHOS_CONTROL_FPS_RANGES,
728 previewFixedFps, sizeof(previewFixedFps) / sizeof(int32_t));
729 EXPECT_EQ(true, result);
730 } else {
731 std::cout << "Found TAG[OHOS_CONTROL_FPS_RANGES], Update it" << std::endl;
732 result = cameraTest->ability->updateEntry(OHOS_CONTROL_FPS_RANGES,
733 previewFixedFps, sizeof(previewFixedFps) / sizeof(int32_t));
734 EXPECT_EQ(true, result);
735 }
736 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(cameraTest->ability, cameraTest->abilityVec);
737 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
738 // Update video fixed fps, constraint relationship
739 int32_t videoFixedFps[] = {15, 15};
740 std::cout << "Update fixed fps for video capture" << std::endl;
741 result = cameraTest->ability->updateEntry(OHOS_CONTROL_FPS_RANGES,
742 videoFixedFps, sizeof(videoFixedFps) / sizeof(int32_t));
743 EXPECT_EQ(true, result);
744 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(cameraTest->ability, cameraTest->abilityVec);
745 cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true);
746 // Release stream
747 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo};
748 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo};
749
750 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
751 }
752
753 /**
754 * @tc.name:SUB_Driver_Camera_DynamicFps_0500
755 * @tc.desc:Dynamic FPS configuration, range setting, streams fps constrain
756 * @tc.size:MediumTest
757 * @tc.type:Function
758 */
759 HWTEST_F(CameraHdiTestV1_3, SUB_Driver_Camera_DynamicFps_0500, TestSize.Level1)
760 {
761 // PREVIEW and VIDEO stream
762 cameraTest->intents = {PREVIEW, VIDEO};
763 // This requirement only in VIDEO mode
764 cameraTest->StartStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::OperationMode::VIDEO);
765 // Bind fps range with preview stream and video stream
766 common_metadata_header_t* data = cameraTest->ability->get();
767 EXPECT_NE(data, nullptr);
768 camera_metadata_item_t entry;
769 cameraTest->rc = FindCameraMetadataItem(data, OHOS_CONTROL_FPS_RANGES, &entry);
770 // The FPS only valid in current release, non backward compatibility
771 int32_t fpsRanges[] = {30, 30};
772 bool result;
773 if (cameraTest->rc != CAM_META_SUCCESS) {
774 std::cout << "Not found TAG[OHOS_CONTROL_FPS_RANGES], insert one" << std::endl;
775 result = cameraTest->ability->addEntry(OHOS_CONTROL_FPS_RANGES,
776 fpsRanges, sizeof(fpsRanges) / sizeof(int32_t));
777 EXPECT_EQ(true, result);
778 } else {
779 std::cout << "Found TAG[OHOS_CONTROL_FPS_RANGES], Update it" << std::endl;
780 result = cameraTest->ability->updateEntry(OHOS_CONTROL_FPS_RANGES,
781 fpsRanges, sizeof(fpsRanges) / sizeof(int32_t));
782 EXPECT_EQ(true, result);
783 }
784 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(cameraTest->ability, cameraTest->abilityVec);
785 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
786 cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true);
787 // Release stream
788 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo};
789 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo};
790 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
791 }
792 /**
793 * @tc.name: SUB_Driver_Camera_HighQuality_0200
794 * @tc.desc: OHOS_CONTROL_HIGH_QUALITY_MODE OHOS_CONTROL_HIGH_QUALITY_MODE_OFF
795 * @tc.size: MediumTest
796 * @tc.type: Function
797 */
798 HWTEST_F(CameraHdiTestV1_3, SUB_Driver_Camera_HighQuality_0200, TestSize.Level1)
799 {
800 CAMERA_LOGI("test OHOS_CONTROL_HIGH_QUALITY_MODE_OFF start.");
801 cameraTest->streamOperatorCallbackV1_3 = new OHOS::Camera::Test::TestStreamOperatorCallbackV1_3();
802 cameraTest->rc = cameraTest->cameraDeviceV1_3->GetStreamOperator_V1_3(
803 cameraTest->streamOperatorCallbackV1_3, cameraTest->streamOperator_V1_3);
804 EXPECT_NE(cameraTest->streamOperator_V1_3, nullptr);
805
806 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
807 cameraTest->DefaultInfosPreview(cameraTest->streamInfoV1_1);
808 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
809
810 cameraTest->streamInfoCapture = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
811 cameraTest->DefaultInfosCapture(cameraTest->streamInfoCapture);
812 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoCapture);
813
814 std::shared_ptr<CameraSetting> modeSetting = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
815 uint8_t movingPhoto = static_cast<uint8_t>(OHOS_CONTROL_HIGH_QUALITY_MODE_OFF);
816 modeSetting->addEntry(OHOS_CONTROL_HIGH_QUALITY_MODE, &movingPhoto, 1);
817 std::vector<uint8_t> metaVec;
818 MetadataUtils::ConvertMetadataToVec(modeSetting, metaVec);
819 cameraTest->cameraDeviceV1_3->UpdateSettings(metaVec);
820
821 cameraTest->rc = cameraTest->streamOperator_V1_3->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
822 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
823 cameraTest->rc = cameraTest->streamOperator_V1_3->CommitStreams(OperationMode::NORMAL, cameraTest->abilityVec);
824 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
825
826 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
827 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
828 cameraTest->captureIds = {cameraTest->captureIdPreview};
829 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
830 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
831 }
832
833 /**
834 * @tc.name: SUB_Driver_Camera_HighQuality_0300
835 * @tc.desc: OHOS_CONTROL_HIGH_QUALITY_MODE OHOS_CONTROL_HIGH_QUALITY_MODE_ON
836 * @tc.size: MediumTest
837 * @tc.type: Function
838 */
839 HWTEST_F(CameraHdiTestV1_3, SUB_Driver_Camera_HighQuality_0300, TestSize.Level1)
840 {
841 CAMERA_LOGI("test OHOS_CONTROL_HIGH_QUALITY_MODE_ON start.");
842 cameraTest->streamOperatorCallbackV1_3 = new OHOS::Camera::Test::TestStreamOperatorCallbackV1_3();
843 cameraTest->rc = cameraTest->cameraDeviceV1_3->GetStreamOperator_V1_3(
844 cameraTest->streamOperatorCallbackV1_3, cameraTest->streamOperator_V1_3);
845 EXPECT_NE(cameraTest->streamOperator_V1_3, nullptr);
846
847 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
848 cameraTest->DefaultInfosPreview(cameraTest->streamInfoV1_1);
849 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
850
851 cameraTest->streamInfoCapture = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
852 cameraTest->DefaultInfosCapture(cameraTest->streamInfoCapture);
853 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoCapture);
854
855 std::shared_ptr<CameraSetting> modeSetting = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
856 uint8_t movingPhoto = static_cast<uint8_t>(OHOS_CONTROL_HIGH_QUALITY_MODE_ON);
857 modeSetting->addEntry(OHOS_CONTROL_HIGH_QUALITY_MODE, &movingPhoto, 1);
858 std::vector<uint8_t> metaVec;
859 MetadataUtils::ConvertMetadataToVec(modeSetting, metaVec);
860 cameraTest->cameraDeviceV1_3->UpdateSettings(metaVec);
861
862 cameraTest->rc = cameraTest->streamOperator_V1_3->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
863 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
864 cameraTest->rc = cameraTest->streamOperator_V1_3->CommitStreams(OperationMode::NORMAL, cameraTest->abilityVec);
865 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
866
867 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
868 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
869 cameraTest->captureIds = {cameraTest->captureIdPreview};
870 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
871 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
872 }
873
UpdateMetadata(std::shared_ptr<OHOS::Camera::Test> cameraTest,std::shared_ptr<CameraSetting> meta)874 void UpdateMetadata(std::shared_ptr<OHOS::Camera::Test> cameraTest, std::shared_ptr<CameraSetting> meta)
875 {
876 // 修改Zoom大于15x
877 float zoomRatio = 16.0f;
878 meta->addEntry(OHOS_CONTROL_ZOOM_RATIO, &zoomRatio, DATA_COUNT);
879 // 使能脚架检测
880 uint8_t tripoDetection = 1;
881 meta->addEntry(OHOS_CONTROL_TRIPOD_DETECTION, &tripoDetection, DATA_COUNT);
882 std::vector<uint8_t> setting;
883 MetadataUtils::ConvertMetadataToVec(meta, setting);
884 cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
885 }
886
887 /**
888 * @tc.name: SUB_Driver_Camera_Tripod_0200
889 * @tc.desc: OHOS_ABILITY_TRIPOD_DETECTION
890 * @tc.size: MediumTest
891 * @tc.type: Function
892 */
893 HWTEST_F(CameraHdiTestV1_3, SUB_Driver_Camera_Tripod_0200, TestSize.Level1)
894 {
895 CAMERA_LOGI("CameraHdiTestV1_3 SUB_Driver_Camera_Tripod_0200 start.");
896 // 查询是否支持脚架检测
897 common_metadata_header_t* data = cameraTest->ability->get();
898 ASSERT_NE(data, nullptr);
899 camera_metadata_item_t entry;
900 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_TRIPOD_DETECTION, &entry);
901 if (cameraTest->rc != HDI::Camera::V1_0::NO_ERROR || entry.data.i32 == nullptr
902 || entry.count <= 0 || entry.data.i32[0] != 1) {
903 cout << "skip this test, because OHOS_ABILITY_TRIPOD_DETECTION not supported" << endl;
904 return;
905 }
906 cameraTest->intents = {PREVIEW, STILL_CAPTURE};
907 cameraTest->StartStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::CAPTURE);
908 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
909 UpdateMetadata(cameraTest, meta);
910 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
911 sleep(UT_SECOND_TIMES);
912 if (cameraTest->deviceCallback->resultMeta == nullptr) {
913 CAMERA_LOGI("Camera_Device_Hdi_V1_3_048 onresult not be invoked.");
914 return;
915 }
916 common_metadata_header_t* resultData = cameraTest->deviceCallback->resultMeta->get();
917 if (resultData == nullptr) {
918 CAMERA_LOGI("Camera_Device_Hdi_V1_3_048 onresult be invoked but data was nullptr.");
919 return;
920 }
921 camera_metadata_item_t statusEntry;
922 cameraTest->rc = FindCameraMetadataItem(resultData, OHOS_STATUS_TRIPOD_DETECTION_STATUS, &statusEntry);
923 if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && statusEntry.data.u8 != nullptr && statusEntry.count > 0) {
924 CAMERA_LOGI("OHOS_STATUS_TRIPOD_DETECTION_STATUS value:%{public}d", statusEntry.data.u8[0]);
925 // 使能脚架检测算法
926 meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
927 uint8_t tripodStablitationAlgorithm = 1;
928 meta->addEntry(OHOS_CONTROL_TRIPOD_STABLITATION, &tripodStablitationAlgorithm, DATA_COUNT);
929 std::vector<uint8_t> pointData;
930 MetadataUtils::ConvertMetadataToVec(meta, pointData);
931 cameraTest->cameraDeviceV1_3->UpdateSettings(pointData);
932 }
933 camera_metadata_item_t pointEntry;
934 cameraTest->rc = FindCameraMetadataItem(resultData, OHOS_STATUS_SKETCH_POINT, &pointEntry);
935 if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && pointEntry.data.f != nullptr && pointEntry.count > 0) {
936 CAMERA_LOGI("OHOS_STATUS_SKETCH_POINT x:%{public}f y:%{public}f", pointEntry.data.f[0], pointEntry.data.f[1]);
937 }
938 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
939 cameraTest->captureIds = {cameraTest->captureIdPreview};
940 cameraTest->streamIds = {cameraTest->streamIdCapture, cameraTest->streamIdPreview};
941 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
942 }
943
FindHumanDetectResult(common_metadata_header_t * streamData)944 void FindHumanDetectResult(common_metadata_header_t* streamData)
945 {
946 camera_metadata_item_t faceEntry;
947 int32_t rc = FindCameraMetadataItem(streamData, OHOS_STATISTICS_DETECT_HUMAN_FACE_INFOS, &faceEntry);
948 if (rc == HDI::Camera::V1_0::NO_ERROR) {
949 if (faceEntry.data.i32 != nullptr && faceEntry.count > 0) {
950 CAMERA_LOGI("FindDetectResult human face result");
951 }
952 }
953 camera_metadata_item_t bodyEntry;
954 rc = FindCameraMetadataItem(streamData, OHOS_STATISTICS_DETECT_HUMAN_BODY_INFOS, &bodyEntry);
955 if (rc == HDI::Camera::V1_0::NO_ERROR) {
956 if (bodyEntry.data.i32 != nullptr && bodyEntry.count > 0) {
957 CAMERA_LOGI("FindDetectResult human body result");
958 }
959 }
960 camera_metadata_item_t baseFaceEntry;
961 rc = FindCameraMetadataItem(streamData, OHOS_STATISTICS_DETECT_BASE_FACE_INFO, &baseFaceEntry);
962 if (rc == HDI::Camera::V1_0::NO_ERROR) {
963 if (baseFaceEntry.data.i32 != nullptr && baseFaceEntry.count > 0) {
964 CAMERA_LOGI("FindDetectResult base face result");
965 }
966 }
967 }
968
FindOtherDetectResult(common_metadata_header_t * streamData)969 void FindOtherDetectResult(common_metadata_header_t* streamData)
970 {
971 camera_metadata_item_t catFaceEntry;
972 int32_t rc = FindCameraMetadataItem(streamData, OHOS_STATISTICS_DETECT_CAT_FACE_INFOS, &catFaceEntry);
973 if (rc == HDI::Camera::V1_0::NO_ERROR) {
974 if (catFaceEntry.data.i32 != nullptr && catFaceEntry.count > 0) {
975 CAMERA_LOGI("FindDetectResult cat face result");
976 }
977 }
978 camera_metadata_item_t catBodyEntry;
979 rc = FindCameraMetadataItem(streamData, OHOS_STATISTICS_DETECT_CAT_BODY_INFOS, &catBodyEntry);
980 if (rc == HDI::Camera::V1_0::NO_ERROR) {
981 if (catBodyEntry.data.i32 != nullptr && catBodyEntry.count > 0) {
982 CAMERA_LOGI("FindDetectResult cat body result");
983 }
984 }
985 camera_metadata_item_t dogFaceEntry;
986 rc = FindCameraMetadataItem(streamData, OHOS_STATISTICS_DETECT_DOG_FACE_INFOS, &dogFaceEntry);
987 if (rc == HDI::Camera::V1_0::NO_ERROR) {
988 if (dogFaceEntry.data.i32 != nullptr && dogFaceEntry.count > 0) {
989 CAMERA_LOGI("FindDetectResult dog face result");
990 }
991 }
992 camera_metadata_item_t dogBodyEntry;
993 rc = FindCameraMetadataItem(streamData, OHOS_STATISTICS_DETECT_DOG_BODY_INFOS, &dogBodyEntry);
994 if (rc == HDI::Camera::V1_0::NO_ERROR) {
995 if (dogBodyEntry.data.i32 != nullptr && dogBodyEntry.count > 0) {
996 CAMERA_LOGI("FindDetectResult dog body result");
997 }
998 }
999 camera_metadata_item_t salientEntry;
1000 rc = FindCameraMetadataItem(streamData, OHOS_STATISTICS_DETECT_SALIENT_INFOS, &salientEntry);
1001 if (rc == HDI::Camera::V1_0::NO_ERROR) {
1002 if (salientEntry.data.i32 != nullptr && salientEntry.count > 0) {
1003 CAMERA_LOGI("FindDetectResult salient result");
1004 }
1005 }
1006 camera_metadata_item_t barCodeEntry;
1007 rc = FindCameraMetadataItem(streamData, OHOS_STATISTICS_DETECT_BAR_CODE_INFOS, &barCodeEntry);
1008 if (rc == HDI::Camera::V1_0::NO_ERROR) {
1009 if (barCodeEntry.data.i32 != nullptr && barCodeEntry.count > 0) {
1010 CAMERA_LOGI("FindDetectResult bar code result");
1011 }
1012 }
1013 }
1014
1015 /**
1016 * @tc.name: SUB_Driver_Camera_Detect_0200
1017 * @tc.desc: OHOS_ABILITY_STATISTICS_DETECT_TYPE,EnableResult
1018 * @tc.size: MediumTest
1019 * @tc.type: Function
1020 */
1021 HWTEST_F(CameraHdiTestV1_3, SUB_Driver_Camera_Detect_0200, TestSize.Level1)
1022 {
1023 common_metadata_header_t* data = cameraTest->ability->get();
1024 ASSERT_NE(data, nullptr);
1025 camera_metadata_item_t entry;
1026 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_STATISTICS_DETECT_TYPE, &entry);
1027 if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) {
1028 cameraTest->intents = {PREVIEW, StreamIntent::VIDEO};
1029 cameraTest->StartStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::VIDEO);
1030 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
1031 cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true);
1032 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
1033 std::vector<uint8_t> detectTypes;
1034 for (int i = 0; i < entry.count; i++) {
1035 detectTypes.push_back(entry.data.u8[i]);
1036 }
1037 uint8_t* typesToEnable = detectTypes.data();
1038 meta->addEntry(OHOS_CONTROL_STATISTICS_DETECT_SETTING, typesToEnable, detectTypes.size());
1039 std::vector<uint8_t> setting;
1040 MetadataUtils::ConvertMetadataToVec(meta, setting);
1041 cameraTest->rc = (OHOS::HDI::Camera::V1_0::CamRetCode)cameraTest->streamOperator_V1_3->EnableResult(
1042 cameraTest->streamIdVideo, setting);
1043 ASSERT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1044 sleep(UT_SECOND_TIMES);
1045 if (cameraTest->streamOperatorCallbackV1_3->streamResultMeta == nullptr) {
1046 CAMERA_LOGI("Camera_Device_Hdi_V1_3_053 onresult not be invoked.");
1047 return;
1048 }
1049 common_metadata_header_t* streamData = cameraTest->streamOperatorCallbackV1_3->streamResultMeta->get();
1050 if (data == nullptr) {
1051 CAMERA_LOGI("Camera_Device_Hdi_V1_3_053 onresult be invoked but data was nullptr.");
1052 return;
1053 }
1054 FindHumanDetectResult(streamData);
1055 FindOtherDetectResult(streamData);
1056 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo};
1057 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo};
1058 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
1059 }
1060 }
1061
1062 /**
1063 * @tc.name: SUB_Driver_Camera_Detect_0300
1064 * @tc.desc: OHOS_ABILITY_STATISTICS_DETECT_TYPE,EnableResult
1065 * @tc.size: MediumTest
1066 * @tc.type: Function
1067 */
1068 HWTEST_F(CameraHdiTestV1_3, SUB_Driver_Camera_Detect_0300, TestSize.Level1)
1069 {
1070 common_metadata_header_t* data = cameraTest->ability->get();
1071 ASSERT_NE(data, nullptr);
1072 camera_metadata_item_t entry;
1073 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_STATISTICS_DETECT_TYPE, &entry);
1074 if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) {
1075 cameraTest->intents = {PREVIEW, StreamIntent::VIDEO};
1076 cameraTest->StartStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::VIDEO);
1077 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
1078 cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true);
1079 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
1080 std::vector<uint8_t> detectTypes;
1081 for (int i = 0; i < entry.count; i++) {
1082 detectTypes.push_back(entry.data.u8[i]);
1083 }
1084 uint8_t* typesToEnable = detectTypes.data();
1085 meta->addEntry(OHOS_CONTROL_STATISTICS_DETECT_SETTING, typesToEnable, detectTypes.size());
1086 std::vector<uint8_t> setting;
1087 MetadataUtils::ConvertMetadataToVec(meta, setting);
1088 cameraTest->rc = (OHOS::HDI::Camera::V1_0::CamRetCode)cameraTest->streamOperator_V1_3->DisableResult(
1089 cameraTest->streamIdVideo, setting);
1090 ASSERT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1091 sleep(UT_SECOND_TIMES);
1092 if (cameraTest->streamOperatorCallbackV1_3->streamResultMeta == nullptr) {
1093 CAMERA_LOGI("Camera_Device_Hdi_V1_3_053 onresult not be invoked.");
1094 return;
1095 }
1096 common_metadata_header_t* streamData = cameraTest->streamOperatorCallbackV1_3->streamResultMeta->get();
1097 if (data == nullptr) {
1098 CAMERA_LOGI("Camera_Device_Hdi_V1_3_053 onresult be invoked but data was nullptr.");
1099 return;
1100 }
1101 FindHumanDetectResult(streamData);
1102 FindOtherDetectResult(streamData);
1103 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo};
1104 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo};
1105 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
1106 }
1107 }
1108
1109 /**
1110 * @tc.name:SUB_MULTIMEDIA_CAMERA_OHOS_CONTROL_FOCUS_RANGE_TYPE_0100
1111 * @tc.desc: test TAG OHOS_ABILITY_FOCUS_RANGE_TYPES and OHOS_CONTROL_FOCUS_RANGE_TYPE
1112 * @tc.size:MediumTest
1113 * @tc.type:Function
1114 */
1115 HWTEST_F(CameraHdiTestV1_3, SUB_MULTIMEDIA_CAMERA_OHOS_CONTROL_FOCUS_RANGE_TYPE_0100, TestSize.Level1)
1116 {
1117 cameraTest->Close();
1118 cameraTest->Open(DEVICE_1); // front camera
1119 ASSERT_NE(cameraTest->ability, nullptr);
1120 common_metadata_header_t* data = cameraTest->ability->get();
1121 ASSERT_NE(data, nullptr);
1122 camera_metadata_item_t entry;
1123 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_FOCUS_RANGE_TYPES, &entry);
1124 if (cameraTest->rc != CAM_META_SUCCESS || entry.count == 0) {
1125 CAMERA_LOGE("OHOS_ABILITY_FOCUS_RANGE_TYPES is not supported");
1126 return;
1127 }
1128 for (int i = 0; i < entry.count; i++) {
1129 if (entry.data.u8[i] == OHOS_CAMERA_FOCUS_RANGE_NEAR) {
1130 CAMERA_LOGI("focus range type OHOS_CAMERA_FOCUS_RANGE_NEAR is supported");
1131 } else if (entry.data.u8[i] == OHOS_CAMERA_FOCUS_RANGE_AUTO) {
1132 CAMERA_LOGI("focus range type OHOS_CAMERA_FOCUS_RANGE_AUTO is supported");
1133 } else {
1134 CAMERA_LOGE("focus range type is not supported");
1135 return;
1136 }
1137 }
1138 camera_metadata_item_t item;
1139 bool status = false;
1140 uint8_t metaFocusRangeType = static_cast<uint8_t>(OHOS_CAMERA_FOCUS_RANGE_NEAR);
1141 int ret = FindCameraMetadataItem(data, OHOS_CONTROL_FOCUS_RANGE_TYPE, &item);
1142 if (ret == CAM_META_ITEM_NOT_FOUND) {
1143 status = cameraTest->ability->addEntry(OHOS_CONTROL_FOCUS_RANGE_TYPE, &metaFocusRangeType, DATA_COUNT);
1144 CAMERA_LOGI("add OHOS_CAMERA_FOCUS_RANGE_NEAR to ability");
1145 } else if (ret == CAM_META_SUCCESS) {
1146 status = cameraTest->ability->updateEntry(OHOS_CONTROL_FOCUS_RANGE_TYPE, &metaFocusRangeType, DATA_COUNT);
1147 CAMERA_LOGI("update OHOS_CAMERA_FOCUS_RANGE_NEAR to ability");
1148 }
1149 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
1150 std::vector<uint8_t> setting;
1151 uint8_t nearType = 1;
1152 meta->addEntry(OHOS_CONTROL_FOCUS_RANGE_TYPE, &nearType, DATA_COUNT);
1153 MetadataUtils::ConvertMetadataToVec(meta, setting);
1154 cameraTest->rc = (OHOS::HDI::Camera::V1_0::CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
1155 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1156 CAMERA_LOGI("first: update settings success");
1157 ret = FindCameraMetadataItem(data, OHOS_CONTROL_FOCUS_RANGE_TYPE, &item);
1158 EXPECT_EQ(ret, CAM_META_SUCCESS);
1159 EXPECT_TRUE(item.data.u8[0] == OHOS_CAMERA_FOCUS_RANGE_NEAR);
1160 }
1161
1162 /**
1163 * @tc.name:SUB_MULTIMEDIA_CAMERA_OHOS_CONTROL_FOCUS_RANGE_TYPE_0200
1164 * @tc.desc: test TAG OHOS_ABILITY_FOCUS_RANGE_TYPES and OHOS_CONTROL_FOCUS_RANGE_TYPE
1165 * @tc.size:MediumTest
1166 * @tc.type:Function
1167 */
1168 HWTEST_F(CameraHdiTestV1_3, SUB_MULTIMEDIA_CAMERA_OHOS_CONTROL_FOCUS_RANGE_TYPE_0200, TestSize.Level1)
1169 {
1170 cameraTest->Close();
1171 cameraTest->Open(DEVICE_1); // front camera
1172 ASSERT_NE(cameraTest->ability, nullptr);
1173 common_metadata_header_t* data = cameraTest->ability->get();
1174 ASSERT_NE(data, nullptr);
1175 camera_metadata_item_t entry;
1176 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_FOCUS_RANGE_TYPES, &entry);
1177 if (cameraTest->rc != CAM_META_SUCCESS || entry.count == 0) {
1178 CAMERA_LOGE("OHOS_ABILITY_FOCUS_RANGE_TYPES is not supported");
1179 return;
1180 }
1181 for (int i = 0; i < entry.count; i++) {
1182 if (entry.data.u8[i] == OHOS_CAMERA_FOCUS_RANGE_NEAR) {
1183 CAMERA_LOGI("focus range type OHOS_CAMERA_FOCUS_RANGE_NEAR is supported");
1184 } else if (entry.data.u8[i] == OHOS_CAMERA_FOCUS_RANGE_AUTO) {
1185 CAMERA_LOGI("focus range type OHOS_CAMERA_FOCUS_RANGE_AUTO is supported");
1186 } else {
1187 CAMERA_LOGE("focus range type is not supported");
1188 return;
1189 }
1190 }
1191 camera_metadata_item_t item;
1192 bool status = false;
1193 std::vector<uint8_t> setting;
1194 uint8_t metaFocusRangeType = static_cast<uint8_t>(OHOS_CAMERA_FOCUS_RANGE_AUTO);
1195 int ret = FindCameraMetadataItem(data, OHOS_CONTROL_FOCUS_RANGE_TYPE, &item);
1196 if (ret == CAM_META_ITEM_NOT_FOUND) {
1197 status = cameraTest->ability->addEntry(OHOS_CONTROL_FOCUS_RANGE_TYPE, &metaFocusRangeType, DATA_COUNT);
1198 CAMERA_LOGI("add OHOS_CAMERA_FOCUS_RANGE_AUTO to ability");
1199 } else if (ret == CAM_META_SUCCESS) {
1200 status = cameraTest->ability->updateEntry(OHOS_CONTROL_FOCUS_RANGE_TYPE, &metaFocusRangeType, DATA_COUNT);
1201 CAMERA_LOGI("update OHOS_CAMERA_FOCUS_RANGE_AUTO to ability");
1202 }
1203 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
1204 uint8_t autoType = 0;
1205 meta->addEntry(OHOS_CONTROL_FOCUS_RANGE_TYPE, &autoType, DATA_COUNT);
1206 MetadataUtils::ConvertMetadataToVec(meta, setting);
1207 cameraTest->rc = (OHOS::HDI::Camera::V1_0::CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
1208 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1209 CAMERA_LOGI("second: update settings success");
1210 ret = FindCameraMetadataItem(data, OHOS_CONTROL_FOCUS_RANGE_TYPE, &item);
1211 EXPECT_EQ(ret, CAM_META_SUCCESS);
1212 EXPECT_TRUE(item.data.u8[0] == OHOS_CAMERA_FOCUS_RANGE_AUTO);
1213 }
1214
1215 /**
1216 * @tc.name:SUB_MULTIMEDIA_CAMERA_OHOS_CONTROL_FOCUS_DRIVEN_TYPE_0100
1217 * @tc.desc: test TAG OHOS_ABILITY_FOCUS_DRIVEN_TYPES and OHOS_CONTROL_FOCUS_DRIVEN_TYPE
1218 * @tc.size:MediumTest
1219 * @tc.type:Function
1220 */
1221 HWTEST_F(CameraHdiTestV1_3, SUB_MULTIMEDIA_CAMERA_OHOS_CONTROL_FOCUS_DRIVEN_TYPE_0100, TestSize.Level1)
1222 {
1223 ASSERT_NE(cameraTest->ability, nullptr);
1224 common_metadata_header_t* data = cameraTest->ability->get();
1225 ASSERT_NE(data, nullptr);
1226 camera_metadata_item_t entry;
1227 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_FOCUS_DRIVEN_TYPES, &entry);
1228 if (cameraTest->rc != CAM_META_SUCCESS || entry.count == 0) {
1229 CAMERA_LOGE("OHOS_ABILITY_FOCUS_DRIVEN_TYPES is not supported");
1230 return;
1231 }
1232 for (int i = 0; i < entry.count; i++) {
1233 if (entry.data.u8[i] == OHOS_CAMERA_FOCUS_DRIVEN_FACE) {
1234 CAMERA_LOGI("focus driven type OHOS_CAMERA_FOCUS_DRIVEN_FACE is supported");
1235 } else if (entry.data.u8[i] == OHOS_CAMERA_FOCUS_DRIVEN_AUTO) {
1236 CAMERA_LOGI("focus driven type OHOS_CAMERA_FOCUS_DRIVEN_AUTO is supported");
1237 } else {
1238 CAMERA_LOGE("focus driven type is not supported");
1239 return;
1240 }
1241 }
1242 camera_metadata_item_t item;
1243 bool status = false;
1244 uint8_t metaFocusDrivenType = static_cast<uint8_t>(OHOS_CAMERA_FOCUS_DRIVEN_FACE);
1245 int ret = FindCameraMetadataItem(data, OHOS_CONTROL_FOCUS_DRIVEN_TYPE, &item);
1246 if (ret == CAM_META_ITEM_NOT_FOUND) {
1247 status = cameraTest->ability->addEntry(OHOS_CONTROL_FOCUS_DRIVEN_TYPE, &metaFocusDrivenType, DATA_COUNT);
1248 CAMERA_LOGI("add OHOS_CAMERA_FOCUS_DRIVEN_FACE to ability");
1249 } else if (ret == CAM_META_SUCCESS) {
1250 status = cameraTest->ability->updateEntry(OHOS_CONTROL_FOCUS_DRIVEN_TYPE, &metaFocusDrivenType, DATA_COUNT);
1251 CAMERA_LOGI("update OHOS_CAMERA_FOCUS_DRIVEN_FACE to ability");
1252 }
1253 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
1254 std::vector<uint8_t> setting;
1255 uint8_t faceType = 1;
1256 meta->addEntry(OHOS_CONTROL_FOCUS_DRIVEN_TYPE, &faceType, DATA_COUNT);
1257 MetadataUtils::ConvertMetadataToVec(meta, setting);
1258 cameraTest->rc = (OHOS::HDI::Camera::V1_0::CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
1259 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1260 CAMERA_LOGI("first: update settings success");
1261 ret = FindCameraMetadataItem(data, OHOS_CONTROL_FOCUS_DRIVEN_TYPE, &item);
1262 EXPECT_EQ(ret, CAM_META_SUCCESS);
1263 EXPECT_TRUE(item.data.u8[0] == OHOS_CAMERA_FOCUS_DRIVEN_FACE);
1264 }
1265
1266 /**
1267 * @tc.name:SUB_MULTIMEDIA_CAMERA_OHOS_CONTROL_FOCUS_DRIVEN_TYPE_0200
1268 * @tc.desc: test TAG OHOS_ABILITY_FOCUS_DRIVEN_TYPES and OHOS_CONTROL_FOCUS_DRIVEN_TYPE
1269 * @tc.size:MediumTest
1270 * @tc.type:Function
1271 */
1272 HWTEST_F(CameraHdiTestV1_3, SUB_MULTIMEDIA_CAMERA_OHOS_CONTROL_FOCUS_DRIVEN_TYPE_0200, TestSize.Level1)
1273 {
1274 ASSERT_NE(cameraTest->ability, nullptr);
1275 common_metadata_header_t* data = cameraTest->ability->get();
1276 ASSERT_NE(data, nullptr);
1277 camera_metadata_item_t entry;
1278 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_FOCUS_DRIVEN_TYPES, &entry);
1279 if (cameraTest->rc != CAM_META_SUCCESS || entry.count == 0) {
1280 CAMERA_LOGE("OHOS_ABILITY_FOCUS_DRIVEN_TYPES is not supported");
1281 return;
1282 }
1283 for (int i = 0; i < entry.count; i++) {
1284 if (entry.data.u8[i] == OHOS_CAMERA_FOCUS_DRIVEN_FACE) {
1285 CAMERA_LOGI("focus driven type OHOS_CAMERA_FOCUS_DRIVEN_FACE is supported");
1286 } else if (entry.data.u8[i] == OHOS_CAMERA_FOCUS_DRIVEN_AUTO) {
1287 CAMERA_LOGI("focus driven type OHOS_CAMERA_FOCUS_DRIVEN_AUTO is supported");
1288 } else {
1289 CAMERA_LOGE("focus driven type is not supported");
1290 return;
1291 }
1292 }
1293 camera_metadata_item_t item;
1294 bool status = false;
1295 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
1296 std::vector<uint8_t> setting;
1297 uint8_t metaFocusDrivenType = static_cast<uint8_t>(OHOS_CAMERA_FOCUS_DRIVEN_AUTO);
1298 int ret = FindCameraMetadataItem(data, OHOS_CONTROL_FOCUS_DRIVEN_TYPE, &item);
1299 if (ret == CAM_META_ITEM_NOT_FOUND) {
1300 status = cameraTest->ability->addEntry(OHOS_CONTROL_FOCUS_DRIVEN_TYPE, &metaFocusDrivenType, DATA_COUNT);
1301 CAMERA_LOGI("add OHOS_CAMERA_FOCUS_DRIVEN_AUTO to ability");
1302 } else if (ret == CAM_META_SUCCESS) {
1303 status = cameraTest->ability->updateEntry(OHOS_CONTROL_FOCUS_DRIVEN_TYPE, &metaFocusDrivenType, DATA_COUNT);
1304 CAMERA_LOGI("update OHOS_CAMERA_FOCUS_DRIVEN_AUTO to ability");
1305 }
1306 meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
1307 uint8_t autoType = 0;
1308 meta->addEntry(OHOS_CONTROL_FOCUS_DRIVEN_TYPE, &autoType, DATA_COUNT);
1309 MetadataUtils::ConvertMetadataToVec(meta, setting);
1310 cameraTest->rc = (OHOS::HDI::Camera::V1_0::CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
1311 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1312 CAMERA_LOGI("second: update settings success");
1313 ret = FindCameraMetadataItem(data, OHOS_CONTROL_FOCUS_DRIVEN_TYPE, &item);
1314 EXPECT_EQ(ret, CAM_META_SUCCESS);
1315 EXPECT_TRUE(item.data.u8[0] == OHOS_CAMERA_FOCUS_DRIVEN_AUTO);
1316 }
1317
SetFocusDrivenType(common_metadata_header_t * data,camera_focus_driven_type_t type,std::shared_ptr<OHOS::Camera::CameraSetting> & meta,std::vector<uint8_t> & setting)1318 bool CameraHdiTestV1_3::SetFocusDrivenType(common_metadata_header_t* data, camera_focus_driven_type_t type,
1319 std::shared_ptr<OHOS::Camera::CameraSetting>& meta, std::vector<uint8_t>& setting)
1320 {
1321 bool result = false;
1322 camera_metadata_item_t entry;
1323 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_FOCUS_DRIVEN_TYPES, &entry);
1324 if (cameraTest->rc != CAM_META_SUCCESS || entry.count == 0) {
1325 CAMERA_LOGE("OHOS_ABILITY_FOCUS_DRIVEN_TYPES is not supported");
1326 return result;
1327 }
1328 for (int i = 0; i < entry.count; i++) {
1329 if (entry.data.u8[i] == type) {
1330 result = true;
1331 break;
1332 }
1333 }
1334 if (result == false) {
1335 return result;
1336 }
1337 camera_metadata_item_t item;
1338 bool status = false;
1339 uint8_t metaFocusDrivenType = static_cast<uint8_t>(type);
1340 int ret = FindCameraMetadataItem(data, OHOS_CONTROL_FOCUS_DRIVEN_TYPE, &item);
1341 if (ret == CAM_META_ITEM_NOT_FOUND) {
1342 status = cameraTest->ability->addEntry(OHOS_CONTROL_FOCUS_DRIVEN_TYPE, &metaFocusDrivenType, DATA_COUNT);
1343 } else if (ret == CAM_META_SUCCESS) {
1344 status = cameraTest->ability->updateEntry(OHOS_CONTROL_FOCUS_DRIVEN_TYPE, &metaFocusDrivenType, DATA_COUNT);
1345 }
1346 meta->addEntry(OHOS_CONTROL_FOCUS_DRIVEN_TYPE, &metaFocusDrivenType, DATA_COUNT);
1347 MetadataUtils::ConvertMetadataToVec(meta, setting);
1348 cameraTest->rc = (OHOS::HDI::Camera::V1_0::CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
1349 cameraTest->rc == HDI::Camera::V1_0::NO_ERROR ? result = true : result = false;
1350 return result;
1351 }
1352
FindFocusTrackingResult(common_metadata_header_t * streamData)1353 void FindFocusTrackingResult(common_metadata_header_t* streamData)
1354 {
1355 camera_metadata_item_t modeEntry;
1356 int32_t rc = FindCameraMetadataItem(streamData, OHOS_CONTROL_FOCUS_TRACKING_MODE, &modeEntry);
1357 if (rc == HDI::Camera::V1_0::NO_ERROR) {
1358 if (modeEntry.data.u8 != nullptr && modeEntry.count > 0) {
1359 CAMERA_LOGI("FindDetectResult human face result");
1360 }
1361 }
1362 camera_metadata_item_t rectEntry;
1363 rc = FindCameraMetadataItem(streamData, OHOS_ABILITY_FOCUS_TRACKING_REGION, &rectEntry);
1364 if (rc == HDI::Camera::V1_0::NO_ERROR) {
1365 if (rectEntry.data.i32 != nullptr && rectEntry.count > 0) {
1366 CAMERA_LOGI("FindDetectResult human body result");
1367 }
1368 }
1369 }
1370
1371 /**
1372 * @tc.name:SUB_MULTIMEDIA_CAMERA_OHOS_FOCUS_TRACKING_0100
1373 * @tc.desc: test TAG OHOS_ABILITY_FOCUS_TRACKING_REGION and OHOS_CONTROL_FOCUS_TRACKING_MODE
1374 * @tc.size:MediumTest
1375 * @tc.type:Function
1376 */
1377 HWTEST_F(CameraHdiTestV1_3, SUB_MULTIMEDIA_CAMERA_OHOS_FOCUS_TRACKING_0100, TestSize.Level1)
1378 {
1379 ASSERT_NE(cameraTest->ability, nullptr);
1380 common_metadata_header_t* data = cameraTest->ability->get();
1381 ASSERT_NE(data, nullptr);
1382 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
1383 std::vector<uint8_t> setting;
1384 bool result = SetFocusDrivenType(data, OHOS_CAMERA_FOCUS_DRIVEN_FACE, meta, setting);
1385 if (result == false) {
1386 CAMERA_LOGE("SetFocusDrivenType failed");
1387 return;
1388 }
1389 cameraTest->intents = {PREVIEW, StreamIntent::VIDEO};
1390 cameraTest->StartStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::VIDEO);
1391 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
1392 cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true);
1393 cameraTest->rc = (OHOS::HDI::Camera::V1_0::CamRetCode)cameraTest->streamOperator_V1_3->EnableResult(
1394 cameraTest->streamIdVideo, setting);
1395 if (cameraTest->rc != HDI::Camera::V1_0::NO_ERROR) {
1396 return;
1397 }
1398 sleep(UT_SECOND_TIMES);
1399 if (cameraTest->streamOperatorCallbackV1_3->streamResultMeta == nullptr) {
1400 CAMERA_LOGI("onresult not be invoked.");
1401 return;
1402 }
1403 common_metadata_header_t* streamData = cameraTest->streamOperatorCallbackV1_3->streamResultMeta->get();
1404 FindFocusTrackingResult(streamData);
1405 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo};
1406 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo};
1407 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
1408 }
1409
1410 /**
1411 * @tc.name:SUB_MULTIMEDIA_CAMERA_OHOS_CONTROL_COLOR_RESERVATION_TYPE_0100
1412 * @tc.desc: test TAG OHOS_ABILITY_COLOR_RESERVATION_TYPES and OHOS_CONTROL_COLOR_RESERVATION_TYPE
1413 * @tc.size:MediumTest
1414 * @tc.type:Function
1415 */
1416 HWTEST_F(CameraHdiTestV1_3, SUB_MULTIMEDIA_CAMERA_OHOS_CONTROL_COLOR_RESERVATION_TYPE_0100, TestSize.Level1)
1417 {
1418 ASSERT_NE(cameraTest->ability, nullptr);
1419 common_metadata_header_t* data = cameraTest->ability->get();
1420 ASSERT_NE(data, nullptr);
1421 camera_metadata_item_t entry;
1422 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_COLOR_RESERVATION_TYPES, &entry);
1423 if (cameraTest->rc != CAM_META_SUCCESS || entry.count == 0) {
1424 CAMERA_LOGE("OHOS_ABILITY_COLOR_RESERVATION_TYPES is not supported");
1425 return;
1426 }
1427 for (int i = 0; i < entry.count; i++) {
1428 if (entry.data.u8[i] == OHOS_CAMERA_COLOR_RESERVATION_PORTRAIT) {
1429 CAMERA_LOGI("color reservation type OHOS_CAMERA_COLOR_RESERVATION_PORTRAIT is supported");
1430 } else if (entry.data.u8[i] == OHOS_CAMERA_COLOR_RESERVATION_NONE) {
1431 CAMERA_LOGI("color reservation type OHOS_CAMERA_COLOR_RESERVATION_NONE is supported");
1432 } else {
1433 CAMERA_LOGE("color reservation type is not supported");
1434 return;
1435 }
1436 }
1437 camera_metadata_item_t item;
1438 bool status = false;
1439 uint8_t metacolorType = static_cast<uint8_t>(OHOS_CAMERA_COLOR_RESERVATION_PORTRAIT);
1440 int ret = FindCameraMetadataItem(data, OHOS_CONTROL_COLOR_RESERVATION_TYPE, &item);
1441 if (ret == CAM_META_ITEM_NOT_FOUND) {
1442 status = cameraTest->ability->addEntry(OHOS_CONTROL_COLOR_RESERVATION_TYPE, &metacolorType, DATA_COUNT);
1443 CAMERA_LOGI("add OHOS_CAMERA_COLOR_RESERVATION_PORTRAIT to ability");
1444 } else if (ret == CAM_META_SUCCESS) {
1445 status = cameraTest->ability->updateEntry(OHOS_CONTROL_COLOR_RESERVATION_TYPE, &metacolorType, DATA_COUNT);
1446 CAMERA_LOGI("update OHOS_CAMERA_COLOR_RESERVATION_PORTRAIT to ability");
1447 }
1448 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
1449 std::vector<uint8_t> setting;
1450 uint8_t portraitType = 1;
1451 meta->addEntry(OHOS_CONTROL_COLOR_RESERVATION_TYPE, &portraitType, DATA_COUNT);
1452 MetadataUtils::ConvertMetadataToVec(meta, setting);
1453 cameraTest->rc = (OHOS::HDI::Camera::V1_0::CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
1454 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1455 CAMERA_LOGI("first: update settings success");
1456 ret = FindCameraMetadataItem(data, OHOS_CONTROL_COLOR_RESERVATION_TYPE, &item);
1457 EXPECT_EQ(ret, CAM_META_SUCCESS);
1458 EXPECT_TRUE(item.data.u8[0] == OHOS_CAMERA_COLOR_RESERVATION_PORTRAIT);
1459 }
1460
1461 /**
1462 * @tc.name:SUB_MULTIMEDIA_CAMERA_OHOS_CONTROL_COLOR_RESERVATION_TYPE_0200
1463 * @tc.desc: test TAG OHOS_ABILITY_COLOR_RESERVATION_TYPES and OHOS_CONTROL_COLOR_RESERVATION_TYPE
1464 * @tc.size:MediumTest
1465 * @tc.type:Function
1466 */
1467 HWTEST_F(CameraHdiTestV1_3, SUB_MULTIMEDIA_CAMERA_OHOS_CONTROL_COLOR_RESERVATION_TYPE_0200, TestSize.Level1)
1468 {
1469 ASSERT_NE(cameraTest->ability, nullptr);
1470 common_metadata_header_t* data = cameraTest->ability->get();
1471 ASSERT_NE(data, nullptr);
1472 camera_metadata_item_t entry;
1473 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_COLOR_RESERVATION_TYPES, &entry);
1474 if (cameraTest->rc != CAM_META_SUCCESS || entry.count == 0) {
1475 CAMERA_LOGE("OHOS_ABILITY_COLOR_RESERVATION_TYPES is not supported");
1476 return;
1477 }
1478 for (int i = 0; i < entry.count; i++) {
1479 if (entry.data.u8[i] == OHOS_CAMERA_COLOR_RESERVATION_PORTRAIT) {
1480 CAMERA_LOGI("color reservation type OHOS_CAMERA_COLOR_RESERVATION_PORTRAIT is supported");
1481 } else if (entry.data.u8[i] == OHOS_CAMERA_COLOR_RESERVATION_NONE) {
1482 CAMERA_LOGI("color reservation type OHOS_CAMERA_COLOR_RESERVATION_NONE is supported");
1483 } else {
1484 CAMERA_LOGE("color reservation type is not supported");
1485 return;
1486 }
1487 }
1488 camera_metadata_item_t item;
1489 bool status = false;
1490 uint8_t metacolorType = static_cast<uint8_t>(OHOS_CAMERA_COLOR_RESERVATION_NONE);
1491 int ret = FindCameraMetadataItem(data, OHOS_CONTROL_COLOR_RESERVATION_TYPE, &item);
1492 if (ret == CAM_META_ITEM_NOT_FOUND) {
1493 status = cameraTest->ability->addEntry(OHOS_CONTROL_COLOR_RESERVATION_TYPE, &metacolorType, DATA_COUNT);
1494 CAMERA_LOGI("add OHOS_CAMERA_COLOR_RESERVATION_NONE to ability");
1495 } else if (ret == CAM_META_SUCCESS) {
1496 status = cameraTest->ability->updateEntry(OHOS_CONTROL_COLOR_RESERVATION_TYPE, &metacolorType, DATA_COUNT);
1497 CAMERA_LOGI("update OHOS_CAMERA_COLOR_RESERVATION_NONE to ability");
1498 }
1499 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
1500 std::vector<uint8_t> setting;
1501 uint8_t noneType = 0;
1502 meta->addEntry(OHOS_CONTROL_COLOR_RESERVATION_TYPE, &noneType, DATA_COUNT);
1503 MetadataUtils::ConvertMetadataToVec(meta, setting);
1504 cameraTest->rc = (OHOS::HDI::Camera::V1_0::CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
1505 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1506 CAMERA_LOGI("second: update settings success");
1507 ret = FindCameraMetadataItem(data, OHOS_CONTROL_COLOR_RESERVATION_TYPE, &item);
1508 EXPECT_EQ(ret, CAM_META_SUCCESS);
1509 EXPECT_TRUE(item.data.u8[0] == OHOS_CAMERA_COLOR_RESERVATION_NONE);
1510 }