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