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 EXPECT_EQ(ret, 0);
48 EXPECT_NE(entry.count, 0);
49 for (int i = 0; i < entry.count; i++) {
50 if (entry.data.u8[i] == value) {
51 return true;
52 }
53 }
54 return false;
55 }
56
57 /**
58 * @tc.name:SUB_Driver_Camera_Moon_0200
59 * @tc.desc: Update moon ability setting
60 * @tc.size:MediumTest
61 * @tc.type:Function
62 */
63 HWTEST_F(CameraHdiTestV1_3, SUB_Driver_Camera_Moon_0200, TestSize.Level1)
64 {
65 int32_t rc;
66 // step 2: set callback object
67 cameraTest->hostCallbackV1_2 = new OHOS::Camera::Test::TestCameraHostCallbackV1_2();
68 rc = cameraTest->serviceV1_3->SetCallback_V1_2(cameraTest->hostCallbackV1_2);
69 EXPECT_EQ(rc, 0);
70 // Start OHOS_ABILITY_MOON_CAPTURE_BOOST ability query
71 common_metadata_header_t* data = cameraTest->ability->get();
72 EXPECT_NE(data, nullptr);
73 camera_metadata_item_t entry;
74 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_MOON_CAPTURE_BOOST, &entry);
75
76 if (ret == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) {
77 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
78 constexpr float zoomRatio = 15;
79 uint8_t stabControl = OHOS_CAMERA_MOON_CAPTURE_BOOST_ENABLE;
80 meta->addEntry(OHOS_CONTROL_ZOOM_RATIO, &zoomRatio, DATA_COUNT);
81 meta->addEntry(OHOS_CONTROL_MOON_CAPTURE_BOOST, &stabControl, DATA_COUNT);
82 // ability meta data serialization for updating
83 std::vector<uint8_t> setting;
84 MetadataUtils::ConvertMetadataToVec(meta, setting);
85 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
86 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
87 CAMERA_LOGD("MoonCaptureBoost mode is set enabled.");
88
89 cameraTest->intents = {PREVIEW, STILL_CAPTURE};
90 cameraTest->StartStream(cameraTest->intents);
91 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
92 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
93 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, true);
94 sleep(1);
95 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdCapture};
96 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
97 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
98 sleep(UT_SECOND_TIMES);
99 common_metadata_header_t* data = cameraTest->deviceCallback->resultMeta->get();
100 EXPECT_NE(data, nullptr);
101 camera_metadata_item_t entry;
102 int ret = FindCameraMetadataItem(data, OHOS_STATUS_MOON_CAPTURE_DETECTION, &entry);
103 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, ret);
104 if (ret == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) {
105 uint8_t value = entry.data.u8[0];
106 // 查询到状态， 检测状态到 月亮模式可开启
107 if (OHOS_CAMERA_MOON_CAPTURE_BOOST_ENABLE == value) {
108 printf("Moon mode is set enabled.");
109 } else {
110 printf("Moon mode is not enabled.");
111 }
112 } else {
113 printf("Moon is not exits.");
114 }
115 }
116 }
117
118 /**
119 * @tc.name:SUB_Driver_Camera_Moon_0300
120 * @tc.desc: Update moon ability setting
121 * @tc.size:MediumTest
122 * @tc.type:Function
123 */
124 HWTEST_F(CameraHdiTestV1_3, SUB_Driver_Camera_Moon_0300, TestSize.Level1)
125 {
126 int32_t rc;
127 // step 2: set callback object
128 cameraTest->hostCallbackV1_2 = new OHOS::Camera::Test::TestCameraHostCallbackV1_2();
129 rc = cameraTest->serviceV1_3->SetCallback_V1_2(cameraTest->hostCallbackV1_2);
130 EXPECT_EQ(rc, 0);
131 // Start OHOS_ABILITY_MOON_CAPTURE_BOOST ability query
132 common_metadata_header_t* data = cameraTest->ability->get();
133 EXPECT_NE(data, nullptr);
134 camera_metadata_item_t entry;
135 int ret = FindCameraMetadataItem(data, OHOS_ABILITY_MOON_CAPTURE_BOOST, &entry);
136
137 if (ret == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) {
138 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
139 constexpr float zoomRatio = 15;
140 uint8_t stabControl = OHOS_CAMERA_MOON_CAPTURE_BOOST_ENABLE;
141 meta->addEntry(OHOS_CONTROL_ZOOM_RATIO, &zoomRatio, DATA_COUNT);
142 meta->addEntry(OHOS_CONTROL_MOON_CAPTURE_BOOST, &stabControl, DATA_COUNT);
143 // ability meta data serialization for updating
144 std::vector<uint8_t> setting;
145 MetadataUtils::ConvertMetadataToVec(meta, setting);
146 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
147 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
148 CAMERA_LOGD("MoonCaptureBoost mode is set enabled.");
149
150 cameraTest->intents = {PREVIEW, STILL_CAPTURE};
151 cameraTest->StartStream(cameraTest->intents);
152 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
153 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
154 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, true);
155 sleep(1);
156 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdCapture};
157 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
158 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
159 }
160 }
161
162 /**
163 * @tc.name: SUB_Driver_Camera_SlowMotion_0300
164 * @tc.desc: CommitStreams_V1_1 for HIGH_FRAME_RATE, preview and video, fps is 120
165 * @tc.size: MediumTest
166 * @tc.type: Function
167 */
168 HWTEST_F(CameraHdiTestV1_3, SUB_Driver_Camera_SlowMotion_0300, TestSize.Level1)
169 {
170 if (!g_IsTagValueExistsU8(cameraTest->ability, OHOS_ABILITY_CAMERA_MODES, OHOS::HDI::Camera::V1_3::HIGH_FRAME_RATE)) {
171 cout << "skip this test, because HIGH_FRAME_RATE not in OHOS_ABILITY_CAMERA_MODES" << endl;
172 return;
173 }
174 cameraTest->CreateAndCommitStreamsForHighFrameRate(cameraTest);
175 // Update settings
176 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
177 int32_t highFrameRate[2] = {120, 120};
178 meta->addEntry(OHOS_CONTROL_FPS_RANGES, &highFrameRate, FPS_COUNT);
179 std::vector<uint8_t> setting;
180 MetadataUtils::ConvertMetadataToVec(meta, setting);
181 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
182 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
183
184 // Start capture
185 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
186 cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true);
187
188 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo};
189 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo};
190 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
191 sleep(DATA_COUNT);
192 cameraTest->streamInfosV1_1.clear();
193 }
194
195 /**
196 * @tc.name: SUB_Driver_Camera_SlowMotion_0400
197 * @tc.desc: CommitStreams_V1_1 for HIGH_FRAME_RATE, preview and video, fps is 240
198 * @tc.size: MediumTest
199 * @tc.type: Function
200 */
201 HWTEST_F(CameraHdiTestV1_3, SUB_Driver_Camera_SlowMotion_0400, TestSize.Level1)
202 {
203 if (!g_IsTagValueExistsU8(cameraTest->ability, OHOS_ABILITY_CAMERA_MODES, OHOS::HDI::Camera::V1_3::HIGH_FRAME_RATE)) {
204 cout << "skip this test, because HIGH_FRAME_RATE not in OHOS_ABILITY_CAMERA_MODES" << endl;
205 return;
206 }
207 cameraTest->CreateAndCommitStreamsForHighFrameRate(cameraTest);
208
209 // Update settings
210 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
211 int32_t highFrameRate[2] = {240, 240};
212 meta->addEntry(OHOS_CONTROL_FPS_RANGES, &highFrameRate, FPS_COUNT);
213 std::vector<uint8_t> setting;
214 MetadataUtils::ConvertMetadataToVec(meta, setting);
215 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
216 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
217
218 // Start capture
219 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
220 cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true);
221
222 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo};
223 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo};
224 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
225 sleep(DATA_COUNT);
226 cameraTest->streamInfosV1_1.clear();
227 }
228
229
230 /**
231 * @tc.name: SUB_Driver_Camera_SuperSlowMotion_0400
232 * @tc.desc: CommitStreams_V1_1 for SLOW_MOTION, preview and video, fps is 960
233 * @tc.size: MediumTest
234 * @tc.type: Function
235 */
236 HWTEST_F(CameraHdiTestV1_3, SUB_Driver_Camera_SuperSlowMotion_0400, TestSize.Level1)
237 {
238 if (!g_IsTagValueExistsU8(cameraTest->ability, OHOS_ABILITY_CAMERA_MODES, OHOS::HDI::Camera::V1_2::SLOW_MOTION)) {
239 cout << "skip this test, because SLOW_MOTION not in OHOS_ABILITY_CAMERA_MODES" << endl;
240 return;
241 }
242 cameraTest->CreateAndCommitStreamsForSlowMotion(cameraTest);
243
244 // Update settings
245 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
246 int32_t slowMotionValue[2] = {240, 240};
247 meta->addEntry(OHOS_CONTROL_FPS_RANGES, &slowMotionValue, FPS_COUNT);
248 std::vector<uint8_t> setting;
249 MetadataUtils::ConvertMetadataToVec(meta, setting);
250 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
251 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
252
253 // Start capture
254 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
255 cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true);
256
257 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo};
258 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo};
259 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
260 sleep(DATA_COUNT);
261 cameraTest->streamInfosV1_1.clear();
262 }
263
264 /**
265 * @tc.name: SUB_Driver_Camera_SuperSlowMotion_0200
266 * @tc.desc: OHOS_ABILITY_MOTION_DETECTION_SUPPORT, OHOS_CAMERA_MOTION_DETECTION_SUPPORTED
267 * @tc.size: MediumTest
268 * @tc.type: Function
269 */
270 HWTEST_F(CameraHdiTestV1_3, SUB_Driver_Camera_SuperSlowMotion_0200, TestSize.Level1)
271 {
272 if (!g_IsTagValueExistsU8(cameraTest->ability, OHOS_ABILITY_CAMERA_MODES, OHOS::HDI::Camera::V1_2::SLOW_MOTION)) {
273 cout << "skip this test, because SLOW_MOTION not in OHOS_ABILITY_CAMERA_MODES" << endl;
274 return;
275 }
276 // Set callback object
277 cameraTest->hostCallbackV1_2 = new OHOS::Camera::Test::TestCameraHostCallbackV1_2();
278 cameraTest->rc = cameraTest->serviceV1_3->SetCallback_V1_2(cameraTest->hostCallbackV1_2);
279 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
280 EXPECT_NE(cameraTest->ability, nullptr);
281 common_metadata_header_t* data = cameraTest->ability->get();
282 EXPECT_NE(data, nullptr);
283 camera_metadata_item_t entry;
284 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_MOTION_DETECTION_SUPPORT, &entry);
285 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
286 if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) {
287 EXPECT_TRUE(entry.data.u8 != nullptr);
288 if (entry.data.u8[0] == OHOS_CAMERA_MOTION_DETECTION_SUPPORTED) {
289 cameraTest->CreateAndCommitStreamsForSlowMotion(cameraTest);
290 cameraTest->UpdateSettingsForSlowMotionMode(cameraTest);
291 cameraTest->SuperSlowMotionStatusCallback(cameraTest);
292 }
293 }
294 }
295
296 /**
297 * @tc.name:SUB_Driver_Camera_PerOptimization_0100
298 * @tc.desc:CAPTURE_DURATION
299 * @tc.size:MediumTest
300 * @tc.type:Function
301 */
302 HWTEST_F(CameraHdiTestV1_3, SUB_Driver_Camera_PerOptimization_0100, TestSize.Level1)
303 {
304 EXPECT_NE(cameraTest->ability, nullptr);
305 common_metadata_header_t* data = cameraTest->ability->get();
306 EXPECT_NE(data, nullptr);
307 camera_metadata_item_t entry;
308 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_CAPTURE_DURATION_SUPPORTED, &entry);
309 if (cameraTest->rc != 0 || entry.data.u8[0] != 1) {
310 cout << "skip this test, because OHOS_ABILITY_CAPTURE_DURATION_SUPPORTED not supported now" << endl;
311 return;
312 }
313
314 // Start stream
315 cameraTest->intents = {PREVIEW, STILL_CAPTURE};
316 cameraTest->StartStream(cameraTest->intents);
317
318 // Fill capture setting
319 std::shared_ptr<CameraSetting> modeSetting = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
320 uint8_t muteMode = static_cast<uint8_t>(OHOS_CAMERA_MUTE_MODE_OFF);
321 modeSetting->addEntry(OHOS_CONTROL_MUTE_MODE, &muteMode, DATA_COUNT);
322 uint8_t deferredImage = OHOS::HDI::Camera::V1_2::STILL_IMAGE;
323 modeSetting->addEntry(OHOS_CONTROL_DEFERRED_IMAGE_DELIVERY, &deferredImage, DATA_COUNT);
324 std::vector<uint8_t> controlVec;
325 MetadataUtils::ConvertMetadataToVec(modeSetting, controlVec);
326 cameraTest->abilityVec = controlVec;
327
328 // Start preview and capture
329 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, true, true);
330 // OncaptureReady trigger
331 for (uint8_t i = 0; i < 2; i++) {
332 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
333 }
334
335 // Release stream
336 cameraTest->captureIds = {cameraTest->captureIdPreview};
337 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
338 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
339
340 sleep(UT_SECOND_TIMES);
341 common_metadata_header_t* callbackData = cameraTest->deviceCallback->resultMeta->get();
342 EXPECT_NE(callbackData, nullptr);
343 camera_metadata_item_t callbackEntry;
344 cameraTest->rc = FindCameraMetadataItem(callbackData, OHOS_CAMERA_CUSTOM_SNAPSHOT_DURATION, &callbackEntry);
345 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
346 printf("currentSnapshotDuration = %d\n", callbackEntry.data.ui32[0]);
347 }
348
349 /**
350 * @tc.name: SUB_Driver_Camera_Moving_0200
351 * @tc.desc: OHOS_CONTROL_MOVING_PHOTO OHOS_CAMERA_MOVING_PHOTO_OFF
352 * @tc.size: MediumTest
353 * @tc.type: Function
354 */
355 HWTEST_F(CameraHdiTestV1_3, SUB_Driver_Camera_Moving_0200, TestSize.Level1)
356 {
357 CAMERA_LOGI("test Camera_Device_Hdi_V1_3_013 start.");
358 cameraTest->streamOperatorCallbackV1_3 = new OHOS::Camera::Test::TestStreamOperatorCallbackV1_3();
359 cameraTest->rc = cameraTest->cameraDeviceV1_3->GetStreamOperator_V1_3(
360 cameraTest->streamOperatorCallbackV1_3, cameraTest->streamOperator_V1_3);
361 EXPECT_NE(cameraTest->streamOperator_V1_3, nullptr);
362
363 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
364 cameraTest->DefaultInfosPreview(cameraTest->streamInfoV1_1);
365 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
366
367 cameraTest->streamInfoCapture = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
368 cameraTest->DefaultInfosCapture(cameraTest->streamInfoCapture);
369 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoCapture);
370
371 std::shared_ptr<CameraSetting> modeSetting = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
372 uint8_t movingPhoto = static_cast<uint8_t>(OHOS_CAMERA_MOVING_PHOTO_OFF);
373 modeSetting->addEntry(OHOS_CONTROL_MOVING_PHOTO, &movingPhoto, 1);
374 std::vector<uint8_t> metaVec;
375 MetadataUtils::ConvertMetadataToVec(modeSetting, metaVec);
376 cameraTest->cameraDeviceV1_3->UpdateSettings(metaVec);
377
378 cameraTest->rc = cameraTest->streamOperator_V1_3->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
379 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
380 cameraTest->rc = cameraTest->streamOperator_V1_3->CommitStreams(OperationMode::NORMAL, cameraTest->abilityVec);
381 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
382
383 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
384 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
385 cameraTest->captureIds = {cameraTest->captureIdPreview};
386 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
387 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
388 }
389
390 /**
391 * @tc.name: SUB_Driver_Camera_Moving_0300
392 * @tc.desc: OHOS_CONTROL_MOVING_PHOTO OHOS_CAMERA_MOVING_PHOTO_ON
393 * @tc.size: MediumTest
394 * @tc.type: Function
395 */
396 HWTEST_F(CameraHdiTestV1_3, SUB_Driver_Camera_Moving_0300, TestSize.Level1)
397 {
398 CAMERA_LOGI("test Moving Photo Switch On");
399 cameraTest->streamOperatorCallbackV1_3 = new OHOS::Camera::Test::TestStreamOperatorCallbackV1_3();
400 cameraTest->rc = cameraTest->cameraDeviceV1_3->GetStreamOperator_V1_3(
401 cameraTest->streamOperatorCallbackV1_3, cameraTest->streamOperator_V1_3);
402 EXPECT_NE(cameraTest->streamOperator_V1_3, nullptr);
403
404 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
405 cameraTest->DefaultInfosPreview(cameraTest->streamInfoV1_1);
406 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
407
408 cameraTest->streamInfoCapture = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
409 cameraTest->DefaultInfosCapture(cameraTest->streamInfoCapture);
410 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoCapture);
411
412 std::shared_ptr<CameraSetting> modeSetting = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
413 uint8_t movingPhoto = static_cast<uint8_t>(OHOS_CAMERA_MOVING_PHOTO_ON);
414 modeSetting->addEntry(OHOS_CONTROL_MOVING_PHOTO, &movingPhoto, 1);
415 std::vector<uint8_t> metaVec;
416 MetadataUtils::ConvertMetadataToVec(modeSetting, metaVec);
417 cameraTest->cameraDeviceV1_3->UpdateSettings(metaVec);
418
419 cameraTest->rc = cameraTest->streamOperator_V1_3->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
420 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
421 cameraTest->rc = cameraTest->streamOperator_V1_3->CommitStreams(OperationMode::NORMAL, cameraTest->abilityVec);
422 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
423
424 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
425 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
426 cameraTest->captureIds = {cameraTest->captureIdPreview};
427 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
428 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
429 }
430
431 /**
432 * @tc.name: SUB_Driver_Camera_HighSolution_0200
433 * @tc.desc: CommitStreams_V1_1 for HIGH_RESOLUTION_PHOTO, preview and capture
434 * @tc.size: MediumTest
435 * @tc.type: Function
436 */
437 HWTEST_F(CameraHdiTestV1_3, SUB_Driver_Camera_HighResolution_0200, TestSize.Level1)
438 {
439 if (!g_IsTagValueExistsU8(cameraTest->ability,
440 OHOS_ABILITY_CAMERA_MODES, OHOS::HDI::Camera::V1_3::HIGH_RESOLUTION_PHOTO)) {
441 cout << "skip this test, because HIGH_RESOLUTION_PHOTO not in OHOS_ABILITY_CAMERA_MODES" << endl;
442 return;
443 }
444 EXPECT_NE(cameraTest->ability, nullptr);
445 common_metadata_header_t* data = cameraTest->ability->get();
446 EXPECT_NE(data, nullptr);
447 camera_metadata_item_t entry;
448 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_CAPTURE_EXPECT_TIME, &entry);
449 if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR) {
450 EXPECT_NE(entry.data.ui32, nullptr);
451 EXPECT_EQ(entry.count > 1, true);
452 CAMERA_LOGI("mode is %{public}u and captureExpectTime is %{public}u", entry.data.ui32[0], entry.data.ui32[1]);
453 }
454 cameraTest->startStreamForHighResolutionPhoto(cameraTest);
455
456 // Update settings
457 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
458 int32_t aeExposureCompensation = EXPOSURE_COUNT;
459 meta->addEntry(OHOS_CONTROL_AE_EXPOSURE_COMPENSATION, &aeExposureCompensation, DATA_COUNT);
460 uint8_t focusMode = OHOS_CAMERA_FOCUS_MODE_AUTO;
461 meta->addEntry(OHOS_CONTROL_FOCUS_MODE, &focusMode, DATA_COUNT);
462 std::vector<uint8_t> setting;
463 MetadataUtils::ConvertMetadataToVec(meta, setting);
464 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
465 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
466
467 sleep(UT_SECOND_TIMES);
468 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
469 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
470 cameraTest->captureIds = {cameraTest->captureIdPreview};
471 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
472 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
473 }
474
475 /**
476 * @tc.name: SUB_Driver_Camera_SMPhoto_0200
477 * @tc.desc: CommitStreams_V1_1 for CAPTURE_MACRO, preview and capture
478 * @tc.size: MediumTest
479 * @tc.type: Function
480 */
481 HWTEST_F(CameraHdiTestV1_3, SUB_Driver_Camera_SMPhoto_0200, TestSize.Level1)
482 {
483 if (!g_IsTagValueExistsU8(cameraTest->ability, OHOS_ABILITY_CAMERA_MODES, OHOS::HDI::Camera::V1_3::CAPTURE_MACRO)) {
484 cout << "skip this test, because CAPTURE_MACRO not in OHOS_ABILITY_CAMERA_MODES" << endl;
485 return;
486 }
487 // Get stream operator
488 cameraTest->streamOperatorCallbackV1_3 = new OHOS::Camera::Test::TestStreamOperatorCallbackV1_3();
489 cameraTest->rc = cameraTest->cameraDeviceV1_3->GetStreamOperator_V1_3(cameraTest->streamOperatorCallbackV1_3,
490 cameraTest->streamOperator_V1_3);
491 EXPECT_NE(cameraTest->streamOperator_V1_3, nullptr);
492 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
493 // Preview streamInfo
494 cameraTest->streamInfoPre = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
495 cameraTest->DefaultInfosPreview(cameraTest->streamInfoPre);
496 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoPre);
497 // Capture streamInfo
498 cameraTest->streamInfoCapture = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
499 cameraTest->DefaultInfosCapture(cameraTest->streamInfoCapture);
500 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoCapture);
501 cameraTest->rc = cameraTest->streamOperator_V1_3->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
502 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
503 cameraTest->rc = cameraTest->streamOperator_V1_3->CommitStreams_V1_1(
504 static_cast<OHOS::HDI::Camera::V1_1::OperationMode_V1_1>(OHOS::HDI::Camera::V1_3::CAPTURE_MACRO),
505 cameraTest->abilityVec);
506 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
507
508 // Update settings
509 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
510 float lensFocusDistance = DATA_COUNT;
511 meta->addEntry(OHOS_CONTROL_LENS_FOCUS_DISTANCE, &lensFocusDistance, DATA_COUNT);
512 std::vector<uint8_t> setting;
513 MetadataUtils::ConvertMetadataToVec(meta, setting);
514 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
515 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
516
517 sleep(UT_SECOND_TIMES);
518 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
519 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
520
521 cameraTest->captureIds = {cameraTest->captureIdPreview};
522 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
523 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
524 }
525
526 /**
527 * @tc.name: SUB_Driver_Camera_SMVideo_0200
528 * @tc.desc: CommitStreams_V1_1 for VIDEO_MACRO, preview and capture
529 * @tc.size: MediumTest
530 * @tc.type: Function
531 */
532 HWTEST_F(CameraHdiTestV1_3, SUB_Driver_Camera_SMVideo_0200, TestSize.Level1)
533 {
534 if (!g_IsTagValueExistsU8(cameraTest->ability, OHOS_ABILITY_CAMERA_MODES, OHOS::HDI::Camera::V1_3::VIDEO_MACRO)) {
535 cout << "skip this test, because VIDEO_MACRO not in OHOS_ABILITY_CAMERA_MODES" << endl;
536 return;
537 }
538 // Get stream operator
539 cameraTest->streamOperatorCallbackV1_3 = new OHOS::Camera::Test::TestStreamOperatorCallbackV1_3();
540 cameraTest->rc = cameraTest->cameraDeviceV1_3->GetStreamOperator_V1_3(cameraTest->streamOperatorCallbackV1_3,
541 cameraTest->streamOperator_V1_3);
542 EXPECT_NE(cameraTest->streamOperator_V1_3, nullptr);
543 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
544 // Preview streamInfo
545 cameraTest->streamInfoPre = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
546 cameraTest->DefaultInfosPreview(cameraTest->streamInfoPre);
547 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoPre);
548 // Capture streamInfo
549 cameraTest->streamInfoVideo = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
550 cameraTest->DefaultInfosVideo(cameraTest->streamInfoVideo);
551 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoVideo);
552 // Create and commit streams
553 cameraTest->rc = cameraTest->streamOperator_V1_3->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
554 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
555 cameraTest->rc = cameraTest->streamOperator_V1_3->CommitStreams_V1_1(
556 static_cast<OHOS::HDI::Camera::V1_1::OperationMode_V1_1>(OHOS::HDI::Camera::V1_3::VIDEO_MACRO),
557 cameraTest->abilityVec);
558 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
559 // Update settings
560 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
561 float lensFocusDistance = DATA_COUNT;
562 meta->addEntry(OHOS_CONTROL_LENS_FOCUS_DISTANCE, &lensFocusDistance, DATA_COUNT);
563 std::vector<uint8_t> setting;
564 MetadataUtils::ConvertMetadataToVec(meta, setting);
565 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
566 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
567 sleep(UT_SECOND_TIMES);
568 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
569 cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true);
570 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo};
571 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo};
572 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
573 }
574
575 /**
576 * @tc.name:SUB_Driver_Camera_DynamicFps_0100
577 * @tc.desc:Dynamic FPS configuration, range setting, streams fps constrain
578 * @tc.size:MediumTest
579 * @tc.type:Function
580 */
581 HWTEST_F(CameraHdiTestV1_3, SUB_Driver_Camera_DynamicFps_0100, TestSize.Level1)
582 {
583 // PREVIEW and VIDEO stream
584 cameraTest->intents = {PREVIEW, VIDEO};
585 // This requirement only in VIDEO mode
586 cameraTest->StartStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::OperationMode::VIDEO);
587 // Bind fps range with preview stream and video stream
588 common_metadata_header_t* data = cameraTest->ability->get();
589 EXPECT_NE(data, nullptr);
590 camera_metadata_item_t entry;
591 cameraTest->rc = FindCameraMetadataItem(data, OHOS_CONTROL_FPS_RANGES, &entry);
592 // The FPS only valid in current release, non backward compatibility
593 int32_t fpsRanges[] = {1, 30};
594 bool result;
595 if (cameraTest->rc != CAM_META_SUCCESS) {
596 std::cout << "Not found TAG[OHOS_CONTROL_FPS_RANGES], insert one" << std::endl;
597 result = cameraTest->ability->addEntry(OHOS_CONTROL_FPS_RANGES,
598 fpsRanges, sizeof(fpsRanges) / sizeof(int32_t));
599 EXPECT_EQ(true, result);
600 } else {
601 std::cout << "Found TAG[OHOS_CONTROL_FPS_RANGES], Update it" << std::endl;
602 result = cameraTest->ability->updateEntry(OHOS_CONTROL_FPS_RANGES,
603 fpsRanges, sizeof(fpsRanges) / sizeof(int32_t));
604 EXPECT_EQ(true, result);
605 }
606 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(cameraTest->ability, cameraTest->abilityVec);
607 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
608 cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true);
609 // Release stream
610 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo};
611 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo};
612 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
613 }
614
615 /**
616 * @tc.name:SUB_Driver_Camera_DynamicFps_0200
617 * @tc.desc:Dynamic FPS configuration, range setting, streams fps constrain
618 * @tc.size:MediumTest
619 * @tc.type:Function
620 */
621 HWTEST_F(CameraHdiTestV1_3, SUB_Driver_Camera_DynamicFps_0200, TestSize.Level1)
622 {
623 // PREVIEW and VIDEO stream
624 cameraTest->intents = {PREVIEW, VIDEO};
625 // This requirement only in VIDEO mode
626 cameraTest->StartStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::OperationMode::VIDEO);
627 // Bind fps range with preview stream and video stream
628 common_metadata_header_t* data = cameraTest->ability->get();
629 EXPECT_NE(data, nullptr);
630 camera_metadata_item_t entry;
631 cameraTest->rc = FindCameraMetadataItem(data, OHOS_CONTROL_FPS_RANGES, &entry);
632 // The FPS only valid in current release, non backward compatibility
633 int32_t fpsRanges[] = {35, 60};
634 bool result;
635 if (cameraTest->rc != CAM_META_SUCCESS) {
636 std::cout << "Not found TAG[OHOS_CONTROL_FPS_RANGES], insert one" << std::endl;
637 result = cameraTest->ability->addEntry(OHOS_CONTROL_FPS_RANGES,
638 fpsRanges, sizeof(fpsRanges) / sizeof(int32_t));
639 EXPECT_EQ(true, result);
640 } else {
641 std::cout << "Found TAG[OHOS_CONTROL_FPS_RANGES], Update it" << std::endl;
642 result = cameraTest->ability->updateEntry(OHOS_CONTROL_FPS_RANGES,
643 fpsRanges, sizeof(fpsRanges) / sizeof(int32_t));
644 EXPECT_EQ(true, result);
645 }
646 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(cameraTest->ability, cameraTest->abilityVec);
647 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
648 cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true);
649 // Release stream
650 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo};
651 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo};
652 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
653 }
654
655 /**
656 + * @tc.name:SUB_Driver_Camera_DynamicFps_0300
657 + * @tc.desc:Dynamic FPS configuration, fixed fps setting, streams fps constrain
658 + * @tc.size:MediumTest
659 + * @tc.type:Function
660 +*/
661 HWTEST_F(CameraHdiTestV1_3, SUB_Driver_Camera_DynamicFps_0300, TestSize.Level1)
662 {
663 // PREVIEW and VIDEO stream
664 cameraTest->intents = {PREVIEW, VIDEO};
665 // This requirement only in VIDEO mode
666 cameraTest->StartStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::OperationMode::VIDEO);
667 // Bind fixed fps with preview stream and video stream, constraint
668 common_metadata_header_t* data = cameraTest->ability->get();
669 EXPECT_NE(data, nullptr);
670 camera_metadata_item_t entry;
671 cameraTest->rc = FindCameraMetadataItem(data, OHOS_CONTROL_FPS_RANGES, &entry);
672 // The FPS only valid in current release, non backward compatibility
673 int32_t previewFixedFps[] = {30, 30};
674 bool result;
675 if (cameraTest->rc != CAM_META_SUCCESS) {
676 std::cout << "Not found TAG[OHOS_CONTROL_FPS_RANGES], insert one" << std::endl;
677 result = cameraTest->ability->addEntry(OHOS_CONTROL_FPS_RANGES,
678 previewFixedFps, sizeof(previewFixedFps) / sizeof(int32_t));
679 EXPECT_EQ(true, result);
680 } else {
681 std::cout << "Found TAG[OHOS_CONTROL_FPS_RANGES], Update it" << std::endl;
682 result = cameraTest->ability->updateEntry(OHOS_CONTROL_FPS_RANGES,
683 previewFixedFps, sizeof(previewFixedFps) / sizeof(int32_t));
684 EXPECT_EQ(true, result);
685 }
686 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(cameraTest->ability, cameraTest->abilityVec);
687 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
688 // Update video fixed fps, constraint relationship
689 int32_t videoFixedFps[] = {60, 60};
690 std::cout << "Update fixed fps for video capture" << std::endl;
691 result = cameraTest->ability->updateEntry(OHOS_CONTROL_FPS_RANGES,
692 videoFixedFps, sizeof(videoFixedFps) / sizeof(int32_t));
693 EXPECT_EQ(true, result);
694 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(cameraTest->ability, cameraTest->abilityVec);
695 cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true);
696 // Release stream
697 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo};
698 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo};
699 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
700 }
701
702 /**
703 + * @tc.name:SUB_Driver_Camera_DynamicFps_0400
704 + * @tc.desc:Dynamic FPS configuration, fixed fps setting, streams fps constrain
705 + * @tc.size:MediumTest
706 + * @tc.type:Function
707 +*/
708 HWTEST_F(CameraHdiTestV1_3, SUB_Driver_Camera_DynamicFps_0400, TestSize.Level1)
709 {
710 // PREVIEW and VIDEO stream
711 cameraTest->intents = {PREVIEW, VIDEO};
712 // This requirement only in VIDEO mode
713 cameraTest->StartStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::OperationMode::VIDEO);
714 // Bind fixed fps with preview stream and video stream, constraint
715 common_metadata_header_t* data = cameraTest->ability->get();
716 EXPECT_NE(data, nullptr);
717 camera_metadata_item_t entry;
718 cameraTest->rc = FindCameraMetadataItem(data, OHOS_CONTROL_FPS_RANGES, &entry);
719 // The FPS only valid in current release, non backward compatibility
720 int32_t previewFixedFps[] = {45, 45};
721 bool result;
722 if (cameraTest->rc != CAM_META_SUCCESS) {
723 std::cout << "Not found TAG[OHOS_CONTROL_FPS_RANGES], insert one" << std::endl;
724 result = cameraTest->ability->addEntry(OHOS_CONTROL_FPS_RANGES,
725 previewFixedFps, sizeof(previewFixedFps) / sizeof(int32_t));
726 EXPECT_EQ(true, result);
727 } else {
728 std::cout << "Found TAG[OHOS_CONTROL_FPS_RANGES], Update it" << std::endl;
729 result = cameraTest->ability->updateEntry(OHOS_CONTROL_FPS_RANGES,
730 previewFixedFps, sizeof(previewFixedFps) / sizeof(int32_t));
731 EXPECT_EQ(true, result);
732 }
733 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(cameraTest->ability, cameraTest->abilityVec);
734 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
735 // Update video fixed fps, constraint relationship
736 int32_t videoFixedFps[] = {15, 15};
737 std::cout << "Update fixed fps for video capture" << std::endl;
738 result = cameraTest->ability->updateEntry(OHOS_CONTROL_FPS_RANGES,
739 videoFixedFps, sizeof(videoFixedFps) / sizeof(int32_t));
740 EXPECT_EQ(true, result);
741 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(cameraTest->ability, cameraTest->abilityVec);
742 cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true);
743 // Release stream
744 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo};
745 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo};
746
747 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
748 }
749
750 /**
751 * @tc.name:SUB_Driver_Camera_DynamicFps_0500
752 * @tc.desc:Dynamic FPS configuration, range setting, streams fps constrain
753 * @tc.size:MediumTest
754 * @tc.type:Function
755 */
756 HWTEST_F(CameraHdiTestV1_3, SUB_Driver_Camera_DynamicFps_0500, TestSize.Level1)
757 {
758 // PREVIEW and VIDEO stream
759 cameraTest->intents = {PREVIEW, VIDEO};
760 // This requirement only in VIDEO mode
761 cameraTest->StartStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::OperationMode::VIDEO);
762 // Bind fps range with preview stream and video stream
763 common_metadata_header_t* data = cameraTest->ability->get();
764 EXPECT_NE(data, nullptr);
765 camera_metadata_item_t entry;
766 cameraTest->rc = FindCameraMetadataItem(data, OHOS_CONTROL_FPS_RANGES, &entry);
767 // The FPS only valid in current release, non backward compatibility
768 int32_t fpsRanges[] = {30, 30};
769 bool result;
770 if (cameraTest->rc != CAM_META_SUCCESS) {
771 std::cout << "Not found TAG[OHOS_CONTROL_FPS_RANGES], insert one" << std::endl;
772 result = cameraTest->ability->addEntry(OHOS_CONTROL_FPS_RANGES,
773 fpsRanges, sizeof(fpsRanges) / sizeof(int32_t));
774 EXPECT_EQ(true, result);
775 } else {
776 std::cout << "Found TAG[OHOS_CONTROL_FPS_RANGES], Update it" << std::endl;
777 result = cameraTest->ability->updateEntry(OHOS_CONTROL_FPS_RANGES,
778 fpsRanges, sizeof(fpsRanges) / sizeof(int32_t));
779 EXPECT_EQ(true, result);
780 }
781 OHOS::Camera::MetadataUtils::ConvertMetadataToVec(cameraTest->ability, cameraTest->abilityVec);
782 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
783 cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true);
784 // Release stream
785 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo};
786 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo};
787 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
788 }
789 /**
790 * @tc.name: SUB_Driver_Camera_HighQuality_0200
791 * @tc.desc: OHOS_CONTROL_HIGH_QUALITY_MODE OHOS_CONTROL_HIGH_QUALITY_MODE_OFF
792 * @tc.size: MediumTest
793 * @tc.type: Function
794 */
795 HWTEST_F(CameraHdiTestV1_3, SUB_Driver_Camera_HighQuality_0200, TestSize.Level1)
796 {
797 CAMERA_LOGI("test OHOS_CONTROL_HIGH_QUALITY_MODE_OFF start.");
798 cameraTest->streamOperatorCallbackV1_3 = new OHOS::Camera::Test::TestStreamOperatorCallbackV1_3();
799 cameraTest->rc = cameraTest->cameraDeviceV1_3->GetStreamOperator_V1_3(
800 cameraTest->streamOperatorCallbackV1_3, cameraTest->streamOperator_V1_3);
801 EXPECT_NE(cameraTest->streamOperator_V1_3, nullptr);
802
803 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
804 cameraTest->DefaultInfosPreview(cameraTest->streamInfoV1_1);
805 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
806
807 cameraTest->streamInfoCapture = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
808 cameraTest->DefaultInfosCapture(cameraTest->streamInfoCapture);
809 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoCapture);
810
811 std::shared_ptr<CameraSetting> modeSetting = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
812 uint8_t movingPhoto = static_cast<uint8_t>(OHOS_CONTROL_HIGH_QUALITY_MODE_OFF);
813 modeSetting->addEntry(OHOS_CONTROL_HIGH_QUALITY_MODE, &movingPhoto, 1);
814 std::vector<uint8_t> metaVec;
815 MetadataUtils::ConvertMetadataToVec(modeSetting, metaVec);
816 cameraTest->cameraDeviceV1_3->UpdateSettings(metaVec);
817
818 cameraTest->rc = cameraTest->streamOperator_V1_3->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
819 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
820 cameraTest->rc = cameraTest->streamOperator_V1_3->CommitStreams(OperationMode::NORMAL, cameraTest->abilityVec);
821 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
822
823 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
824 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
825 cameraTest->captureIds = {cameraTest->captureIdPreview};
826 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
827 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
828 }
829
830 /**
831 * @tc.name: SUB_Driver_Camera_HighQuality_0300
832 * @tc.desc: OHOS_CONTROL_HIGH_QUALITY_MODE OHOS_CONTROL_HIGH_QUALITY_MODE_ON
833 * @tc.size: MediumTest
834 * @tc.type: Function
835 */
836 HWTEST_F(CameraHdiTestV1_3, SUB_Driver_Camera_HighQuality_0300, TestSize.Level1)
837 {
838 CAMERA_LOGI("test OHOS_CONTROL_HIGH_QUALITY_MODE_ON start.");
839 cameraTest->streamOperatorCallbackV1_3 = new OHOS::Camera::Test::TestStreamOperatorCallbackV1_3();
840 cameraTest->rc = cameraTest->cameraDeviceV1_3->GetStreamOperator_V1_3(
841 cameraTest->streamOperatorCallbackV1_3, cameraTest->streamOperator_V1_3);
842 EXPECT_NE(cameraTest->streamOperator_V1_3, nullptr);
843
844 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
845 cameraTest->DefaultInfosPreview(cameraTest->streamInfoV1_1);
846 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
847
848 cameraTest->streamInfoCapture = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
849 cameraTest->DefaultInfosCapture(cameraTest->streamInfoCapture);
850 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoCapture);
851
852 std::shared_ptr<CameraSetting> modeSetting = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
853 uint8_t movingPhoto = static_cast<uint8_t>(OHOS_CONTROL_HIGH_QUALITY_MODE_ON);
854 modeSetting->addEntry(OHOS_CONTROL_HIGH_QUALITY_MODE, &movingPhoto, 1);
855 std::vector<uint8_t> metaVec;
856 MetadataUtils::ConvertMetadataToVec(modeSetting, metaVec);
857 cameraTest->cameraDeviceV1_3->UpdateSettings(metaVec);
858
859 cameraTest->rc = cameraTest->streamOperator_V1_3->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
860 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
861 cameraTest->rc = cameraTest->streamOperator_V1_3->CommitStreams(OperationMode::NORMAL, cameraTest->abilityVec);
862 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
863
864 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
865 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
866 cameraTest->captureIds = {cameraTest->captureIdPreview};
867 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdCapture};
868 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
869 }
870
871 /**
872 * @tc.name:SUB_MULTIMEDIA_CAMERA_OHOS_CONTROL_FOCUS_RANGE_TYPE_0100
873 * @tc.desc: test TAG OHOS_ABILITY_FOCUS_RANGE_TYPES and OHOS_CONTROL_FOCUS_RANGE_TYPE
874 * @tc.size:MediumTest
875 * @tc.type:Function
876 */
877 HWTEST_F(CameraHdiTestV1_3, SUB_MULTIMEDIA_CAMERA_OHOS_CONTROL_FOCUS_RANGE_TYPE_0100, TestSize.Level1)
878 {
879 cameraTest->Close();
880 cameraTest->Open(DEVICE_1); // front camera
881 ASSERT_NE(cameraTest->ability, nullptr);
882 common_metadata_header_t* data = cameraTest->ability->get();
883 ASSERT_NE(data, nullptr);
884 camera_metadata_item_t entry;
885 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_FOCUS_RANGE_TYPES, &entry);
886 if (cameraTest->rc != CAM_META_SUCCESS || entry.count == 0) {
887 CAMERA_LOGE("OHOS_ABILITY_FOCUS_RANGE_TYPES is not supported");
888 return;
889 }
890 for (int i = 0; i < entry.count; i++) {
891 if (entry.data.u8[i] == OHOS_CAMERA_FOCUS_RANGE_NEAR) {
892 CAMERA_LOGI("focus range type OHOS_CAMERA_FOCUS_RANGE_NEAR is supported");
893 } else if (entry.data.u8[i] == OHOS_CAMERA_FOCUS_RANGE_AUTO) {
894 CAMERA_LOGI("focus range type OHOS_CAMERA_FOCUS_RANGE_AUTO is supported");
895 } else {
896 CAMERA_LOGE("focus range type is not supported");
897 return;
898 }
899 }
900 camera_metadata_item_t item;
901 bool status = false;
902 uint8_t metaFocusRangeType = static_cast<uint8_t>(OHOS_CAMERA_FOCUS_RANGE_NEAR);
903 int ret = FindCameraMetadataItem(data, OHOS_CONTROL_FOCUS_RANGE_TYPE, &item);
904 if (ret == CAM_META_ITEM_NOT_FOUND) {
905 status = cameraTest->ability->addEntry(OHOS_CONTROL_FOCUS_RANGE_TYPE, &metaFocusRangeType, DATA_COUNT);
906 CAMERA_LOGI("add OHOS_CAMERA_FOCUS_RANGE_NEAR to ability");
907 } else if (ret == CAM_META_SUCCESS) {
908 status = cameraTest->ability->updateEntry(OHOS_CONTROL_FOCUS_RANGE_TYPE, &metaFocusRangeType, DATA_COUNT);
909 CAMERA_LOGI("update OHOS_CAMERA_FOCUS_RANGE_NEAR to ability");
910 }
911 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
912 std::vector<uint8_t> setting;
913 uint8_t nearType = 1;
914 meta->addEntry(OHOS_CONTROL_FOCUS_RANGE_TYPE, &nearType, DATA_COUNT);
915 MetadataUtils::ConvertMetadataToVec(meta, setting);
916 cameraTest->rc = (OHOS::HDI::Camera::V1_0::CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
917 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
918 CAMERA_LOGI("first: update settings success");
919 ret = FindCameraMetadataItem(data, OHOS_CONTROL_FOCUS_RANGE_TYPE, &item);
920 EXPECT_EQ(ret, CAM_META_SUCCESS);
921 EXPECT_TRUE(item.data.u8[0] == OHOS_CAMERA_FOCUS_RANGE_NEAR);
922 }
923
924 /**
925 * @tc.name:SUB_MULTIMEDIA_CAMERA_OHOS_CONTROL_FOCUS_RANGE_TYPE_0200
926 * @tc.desc: test TAG OHOS_ABILITY_FOCUS_RANGE_TYPES and OHOS_CONTROL_FOCUS_RANGE_TYPE
927 * @tc.size:MediumTest
928 * @tc.type:Function
929 */
930 HWTEST_F(CameraHdiTestV1_3, SUB_MULTIMEDIA_CAMERA_OHOS_CONTROL_FOCUS_RANGE_TYPE_0200, TestSize.Level1)
931 {
932 cameraTest->Close();
933 cameraTest->Open(DEVICE_1); // front camera
934 ASSERT_NE(cameraTest->ability, nullptr);
935 common_metadata_header_t* data = cameraTest->ability->get();
936 ASSERT_NE(data, nullptr);
937 camera_metadata_item_t entry;
938 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_FOCUS_RANGE_TYPES, &entry);
939 if (cameraTest->rc != CAM_META_SUCCESS || entry.count == 0) {
940 CAMERA_LOGE("OHOS_ABILITY_FOCUS_RANGE_TYPES is not supported");
941 return;
942 }
943 for (int i = 0; i < entry.count; i++) {
944 if (entry.data.u8[i] == OHOS_CAMERA_FOCUS_RANGE_NEAR) {
945 CAMERA_LOGI("focus range type OHOS_CAMERA_FOCUS_RANGE_NEAR is supported");
946 } else if (entry.data.u8[i] == OHOS_CAMERA_FOCUS_RANGE_AUTO) {
947 CAMERA_LOGI("focus range type OHOS_CAMERA_FOCUS_RANGE_AUTO is supported");
948 } else {
949 CAMERA_LOGE("focus range type is not supported");
950 return;
951 }
952 }
953 camera_metadata_item_t item;
954 bool status = false;
955 std::vector<uint8_t> setting;
956 uint8_t metaFocusRangeType = static_cast<uint8_t>(OHOS_CAMERA_FOCUS_RANGE_AUTO);
957 int ret = FindCameraMetadataItem(data, OHOS_CONTROL_FOCUS_RANGE_TYPE, &item);
958 if (ret == CAM_META_ITEM_NOT_FOUND) {
959 status = cameraTest->ability->addEntry(OHOS_CONTROL_FOCUS_RANGE_TYPE, &metaFocusRangeType, DATA_COUNT);
960 CAMERA_LOGI("add OHOS_CAMERA_FOCUS_RANGE_AUTO to ability");
961 } else if (ret == CAM_META_SUCCESS) {
962 status = cameraTest->ability->updateEntry(OHOS_CONTROL_FOCUS_RANGE_TYPE, &metaFocusRangeType, DATA_COUNT);
963 CAMERA_LOGI("update OHOS_CAMERA_FOCUS_RANGE_AUTO to ability");
964 }
965 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
966 uint8_t autoType = 0;
967 meta->addEntry(OHOS_CONTROL_FOCUS_RANGE_TYPE, &autoType, DATA_COUNT);
968 MetadataUtils::ConvertMetadataToVec(meta, setting);
969 cameraTest->rc = (OHOS::HDI::Camera::V1_0::CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
970 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
971 CAMERA_LOGI("second: update settings success");
972 ret = FindCameraMetadataItem(data, OHOS_CONTROL_FOCUS_RANGE_TYPE, &item);
973 EXPECT_EQ(ret, CAM_META_SUCCESS);
974 EXPECT_TRUE(item.data.u8[0] == OHOS_CAMERA_FOCUS_RANGE_AUTO);
975 }
976
977 /**
978 * @tc.name:SUB_MULTIMEDIA_CAMERA_OHOS_CONTROL_FOCUS_DRIVEN_TYPE_0100
979 * @tc.desc: test TAG OHOS_ABILITY_FOCUS_DRIVEN_TYPES and OHOS_CONTROL_FOCUS_DRIVEN_TYPE
980 * @tc.size:MediumTest
981 * @tc.type:Function
982 */
983 HWTEST_F(CameraHdiTestV1_3, SUB_MULTIMEDIA_CAMERA_OHOS_CONTROL_FOCUS_DRIVEN_TYPE_0100, TestSize.Level1)
984 {
985 ASSERT_NE(cameraTest->ability, nullptr);
986 common_metadata_header_t* data = cameraTest->ability->get();
987 ASSERT_NE(data, nullptr);
988 camera_metadata_item_t entry;
989 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_FOCUS_DRIVEN_TYPES, &entry);
990 if (cameraTest->rc != CAM_META_SUCCESS || entry.count == 0) {
991 CAMERA_LOGE("OHOS_ABILITY_FOCUS_DRIVEN_TYPES is not supported");
992 return;
993 }
994 for (int i = 0; i < entry.count; i++) {
995 if (entry.data.u8[i] == OHOS_CAMERA_FOCUS_DRIVEN_FACE) {
996 CAMERA_LOGI("focus driven type OHOS_CAMERA_FOCUS_DRIVEN_FACE is supported");
997 } else if (entry.data.u8[i] == OHOS_CAMERA_FOCUS_DRIVEN_AUTO) {
998 CAMERA_LOGI("focus driven type OHOS_CAMERA_FOCUS_DRIVEN_AUTO is supported");
999 } else {
1000 CAMERA_LOGE("focus driven type is not supported");
1001 return;
1002 }
1003 }
1004 camera_metadata_item_t item;
1005 bool status = false;
1006 uint8_t metaFocusDrivenType = static_cast<uint8_t>(OHOS_CAMERA_FOCUS_DRIVEN_FACE);
1007 int ret = FindCameraMetadataItem(data, OHOS_CONTROL_FOCUS_DRIVEN_TYPE, &item);
1008 if (ret == CAM_META_ITEM_NOT_FOUND) {
1009 status = cameraTest->ability->addEntry(OHOS_CONTROL_FOCUS_DRIVEN_TYPE, &metaFocusDrivenType, DATA_COUNT);
1010 CAMERA_LOGI("add OHOS_CAMERA_FOCUS_DRIVEN_FACE to ability");
1011 } else if (ret == CAM_META_SUCCESS) {
1012 status = cameraTest->ability->updateEntry(OHOS_CONTROL_FOCUS_DRIVEN_TYPE, &metaFocusDrivenType, DATA_COUNT);
1013 CAMERA_LOGI("update OHOS_CAMERA_FOCUS_DRIVEN_FACE to ability");
1014 }
1015 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
1016 std::vector<uint8_t> setting;
1017 uint8_t faceType = 1;
1018 meta->addEntry(OHOS_CONTROL_FOCUS_DRIVEN_TYPE, &faceType, DATA_COUNT);
1019 MetadataUtils::ConvertMetadataToVec(meta, setting);
1020 cameraTest->rc = (OHOS::HDI::Camera::V1_0::CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
1021 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1022 CAMERA_LOGI("first: update settings success");
1023 ret = FindCameraMetadataItem(data, OHOS_CONTROL_FOCUS_DRIVEN_TYPE, &item);
1024 EXPECT_EQ(ret, CAM_META_SUCCESS);
1025 EXPECT_TRUE(item.data.u8[0] == OHOS_CAMERA_FOCUS_DRIVEN_FACE);
1026 }
1027
1028 /**
1029 * @tc.name:SUB_MULTIMEDIA_CAMERA_OHOS_CONTROL_FOCUS_DRIVEN_TYPE_0200
1030 * @tc.desc: test TAG OHOS_ABILITY_FOCUS_DRIVEN_TYPES and OHOS_CONTROL_FOCUS_DRIVEN_TYPE
1031 * @tc.size:MediumTest
1032 * @tc.type:Function
1033 */
1034 HWTEST_F(CameraHdiTestV1_3, SUB_MULTIMEDIA_CAMERA_OHOS_CONTROL_FOCUS_DRIVEN_TYPE_0200, TestSize.Level1)
1035 {
1036 ASSERT_NE(cameraTest->ability, nullptr);
1037 common_metadata_header_t* data = cameraTest->ability->get();
1038 ASSERT_NE(data, nullptr);
1039 camera_metadata_item_t entry;
1040 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_FOCUS_DRIVEN_TYPES, &entry);
1041 if (cameraTest->rc != CAM_META_SUCCESS || entry.count == 0) {
1042 CAMERA_LOGE("OHOS_ABILITY_FOCUS_DRIVEN_TYPES is not supported");
1043 return;
1044 }
1045 for (int i = 0; i < entry.count; i++) {
1046 if (entry.data.u8[i] == OHOS_CAMERA_FOCUS_DRIVEN_FACE) {
1047 CAMERA_LOGI("focus driven type OHOS_CAMERA_FOCUS_DRIVEN_FACE is supported");
1048 } else if (entry.data.u8[i] == OHOS_CAMERA_FOCUS_DRIVEN_AUTO) {
1049 CAMERA_LOGI("focus driven type OHOS_CAMERA_FOCUS_DRIVEN_AUTO is supported");
1050 } else {
1051 CAMERA_LOGE("focus driven type is not supported");
1052 return;
1053 }
1054 }
1055 camera_metadata_item_t item;
1056 bool status = false;
1057 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
1058 std::vector<uint8_t> setting;
1059 uint8_t metaFocusDrivenType = static_cast<uint8_t>(OHOS_CAMERA_FOCUS_DRIVEN_AUTO);
1060 int ret = FindCameraMetadataItem(data, OHOS_CONTROL_FOCUS_DRIVEN_TYPE, &item);
1061 if (ret == CAM_META_ITEM_NOT_FOUND) {
1062 status = cameraTest->ability->addEntry(OHOS_CONTROL_FOCUS_DRIVEN_TYPE, &metaFocusDrivenType, DATA_COUNT);
1063 CAMERA_LOGI("add OHOS_CAMERA_FOCUS_DRIVEN_AUTO to ability");
1064 } else if (ret == CAM_META_SUCCESS) {
1065 status = cameraTest->ability->updateEntry(OHOS_CONTROL_FOCUS_DRIVEN_TYPE, &metaFocusDrivenType, DATA_COUNT);
1066 CAMERA_LOGI("update OHOS_CAMERA_FOCUS_DRIVEN_AUTO to ability");
1067 }
1068 meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
1069 uint8_t autoType = 0;
1070 meta->addEntry(OHOS_CONTROL_FOCUS_DRIVEN_TYPE, &autoType, DATA_COUNT);
1071 MetadataUtils::ConvertMetadataToVec(meta, setting);
1072 cameraTest->rc = (OHOS::HDI::Camera::V1_0::CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
1073 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
1074 CAMERA_LOGI("second: update settings success");
1075 ret = FindCameraMetadataItem(data, OHOS_CONTROL_FOCUS_DRIVEN_TYPE, &item);
1076 EXPECT_EQ(ret, CAM_META_SUCCESS);
1077 EXPECT_TRUE(item.data.u8[0] == OHOS_CAMERA_FOCUS_DRIVEN_AUTO);
1078 }
1079
SetFocusDrivenType(common_metadata_header_t * data,camera_focus_driven_type_t type,std::shared_ptr<OHOS::Camera::CameraSetting> & meta,std::vector<uint8_t> & setting)1080 bool CameraHdiTestV1_3::SetFocusDrivenType(common_metadata_header_t* data, camera_focus_driven_type_t type,
1081 std::shared_ptr<OHOS::Camera::CameraSetting>& meta, std::vector<uint8_t>& setting)
1082 {
1083 bool result = false;
1084 camera_metadata_item_t entry;
1085 cameraTest->rc = FindCameraMetadataItem(data, OHOS_ABILITY_FOCUS_DRIVEN_TYPES, &entry);
1086 if (cameraTest->rc != CAM_META_SUCCESS || entry.count == 0) {
1087 CAMERA_LOGE("OHOS_ABILITY_FOCUS_DRIVEN_TYPES is not supported");
1088 return result;
1089 }
1090 for (int i = 0; i < entry.count; i++) {
1091 if (entry.data.u8[i] == type) {
1092 result = true;
1093 break;
1094 }
1095 }
1096 if (result == false) {
1097 return result;
1098 }
1099 camera_metadata_item_t item;
1100 bool status = false;
1101 uint8_t metaFocusDrivenType = static_cast<uint8_t>(type);
1102 int ret = FindCameraMetadataItem(data, OHOS_CONTROL_FOCUS_DRIVEN_TYPE, &item);
1103 if (ret == CAM_META_ITEM_NOT_FOUND) {
1104 status = cameraTest->ability->addEntry(OHOS_CONTROL_FOCUS_DRIVEN_TYPE, &metaFocusDrivenType, DATA_COUNT);
1105 } else if (ret == CAM_META_SUCCESS) {
1106 status = cameraTest->ability->updateEntry(OHOS_CONTROL_FOCUS_DRIVEN_TYPE, &metaFocusDrivenType, DATA_COUNT);
1107 }
1108 meta->addEntry(OHOS_CONTROL_FOCUS_DRIVEN_TYPE, &metaFocusDrivenType, DATA_COUNT);
1109 MetadataUtils::ConvertMetadataToVec(meta, setting);
1110 cameraTest->rc = (OHOS::HDI::Camera::V1_0::CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
1111 cameraTest->rc == HDI::Camera::V1_0::NO_ERROR ? result = true : result = false;
1112 return result;
1113 }
1114
FindFocusTrackingResult(common_metadata_header_t * streamData)1115 void FindFocusTrackingResult(common_metadata_header_t* streamData)
1116 {
1117 camera_metadata_item_t modeEntry;
1118 int32_t rc = FindCameraMetadataItem(streamData, OHOS_CONTROL_FOCUS_TRACKING_MODE, &modeEntry);
1119 if (rc == HDI::Camera::V1_0::NO_ERROR) {
1120 if (modeEntry.data.u8 != nullptr && modeEntry.count > 0) {
1121 CAMERA_LOGI("FindDetectResult human face result");
1122 }
1123 }
1124 camera_metadata_item_t rectEntry;
1125 rc = FindCameraMetadataItem(streamData, OHOS_ABILITY_FOCUS_TRACKING_REGION, &rectEntry);
1126 if (rc == HDI::Camera::V1_0::NO_ERROR) {
1127 if (rectEntry.data.i32 != nullptr && rectEntry.count > 0) {
1128 CAMERA_LOGI("FindDetectResult human body result");
1129 }
1130 }
1131 }
1132
1133 /**
1134 * @tc.name:SUB_MULTIMEDIA_CAMERA_OHOS_FOCUS_TRACKING_0100
1135 * @tc.desc: test TAG OHOS_ABILITY_FOCUS_TRACKING_REGION and OHOS_CONTROL_FOCUS_TRACKING_MODE
1136 * @tc.size:MediumTest
1137 * @tc.type:Function
1138 */
1139 HWTEST_F(CameraHdiTestV1_3, SUB_MULTIMEDIA_CAMERA_OHOS_FOCUS_TRACKING_0100, TestSize.Level1)
1140 {
1141 ASSERT_NE(cameraTest->ability, nullptr);
1142 common_metadata_header_t* data = cameraTest->ability->get();
1143 ASSERT_NE(data, nullptr);
1144 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
1145 std::vector<uint8_t> setting;
1146 bool result = SetFocusDrivenType(data, OHOS_CAMERA_FOCUS_DRIVEN_FACE, meta, setting);
1147 if (result == false) {
1148 CAMERA_LOGE("SetFocusDrivenType failed");
1149 return;
1150 }
1151 cameraTest->intents = {PREVIEW, StreamIntent::VIDEO};
1152 cameraTest->StartStream(cameraTest->intents, OHOS::HDI::Camera::V1_3::VIDEO);
1153 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
1154 cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true);
1155 cameraTest->rc = (OHOS::HDI::Camera::V1_0::CamRetCode)cameraTest->streamOperator_V1_3->EnableResult(
1156 cameraTest->streamIdVideo, setting);
1157 if (cameraTest->rc != HDI::Camera::V1_0::NO_ERROR) {
1158 return;
1159 }
1160 sleep(UT_SECOND_TIMES);
1161 if (cameraTest->streamOperatorCallbackV1_3->streamResultMeta == nullptr) {
1162 CAMERA_LOGI("onresult not be invoked.");
1163 return;
1164 }
1165 common_metadata_header_t* streamData = cameraTest->streamOperatorCallbackV1_3->streamResultMeta->get();
1166 FindFocusTrackingResult(streamData);
1167 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo};
1168 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo};
1169 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
1170 }
1171
1172 /**
1173 * @tc.name:SUB_MULTIMEDIA_CAMERA_OHOS_CONTROL_COLOR_RESERVATION_TYPE_0100
1174 * @tc.desc: test TAG OHOS_ABILITY_COLOR_RESERVATION_TYPES and OHOS_CONTROL_COLOR_RESERVATION_TYPE
1175 * @tc.size:MediumTest
1176 * @tc.type:Function
1177 */
1178 HWTEST_F(CameraHdiTestV1_3, SUB_MULTIMEDIA_CAMERA_OHOS_CONTROL_COLOR_RESERVATION_TYPE_0100, TestSize.Level1)
1179 {
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_COLOR_RESERVATION_TYPES, &entry);
1185 if (cameraTest->rc != CAM_META_SUCCESS || entry.count == 0) {
1186 CAMERA_LOGE("OHOS_ABILITY_COLOR_RESERVATION_TYPES is not supported");
1187 return;
1188 }
1189 for (int i = 0; i < entry.count; i++) {
1190 if (entry.data.u8[i] == OHOS_CAMERA_COLOR_RESERVATION_PORTRAIT) {
1191 CAMERA_LOGI("color reservation type OHOS_CAMERA_COLOR_RESERVATION_PORTRAIT is supported");
1192 } else if (entry.data.u8[i] == OHOS_CAMERA_COLOR_RESERVATION_NONE) {
1193 CAMERA_LOGI("color reservation type OHOS_CAMERA_COLOR_RESERVATION_NONE is supported");
1194 } else {
1195 CAMERA_LOGE("color reservation type is not supported");
1196 return;
1197 }
1198 }
1199 camera_metadata_item_t item;
1200 bool status = false;
1201 uint8_t metacolorType = static_cast<uint8_t>(OHOS_CAMERA_COLOR_RESERVATION_PORTRAIT);
1202 int ret = FindCameraMetadataItem(data, OHOS_CONTROL_COLOR_RESERVATION_TYPE, &item);
1203 if (ret == CAM_META_ITEM_NOT_FOUND) {
1204 status = cameraTest->ability->addEntry(OHOS_CONTROL_COLOR_RESERVATION_TYPE, &metacolorType, DATA_COUNT);
1205 CAMERA_LOGI("add OHOS_CAMERA_COLOR_RESERVATION_PORTRAIT to ability");
1206 } else if (ret == CAM_META_SUCCESS) {
1207 status = cameraTest->ability->updateEntry(OHOS_CONTROL_COLOR_RESERVATION_TYPE, &metacolorType, DATA_COUNT);
1208 CAMERA_LOGI("update OHOS_CAMERA_COLOR_RESERVATION_PORTRAIT to ability");
1209 }
1210 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
1211 std::vector<uint8_t> setting;
1212 uint8_t portraitType = 1;
1213 meta->addEntry(OHOS_CONTROL_COLOR_RESERVATION_TYPE, &portraitType, 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("first: update settings success");
1218 ret = FindCameraMetadataItem(data, OHOS_CONTROL_COLOR_RESERVATION_TYPE, &item);
1219 EXPECT_EQ(ret, CAM_META_SUCCESS);
1220 EXPECT_TRUE(item.data.u8[0] == OHOS_CAMERA_COLOR_RESERVATION_PORTRAIT);
1221 }
1222
1223 /**
1224 * @tc.name:SUB_MULTIMEDIA_CAMERA_OHOS_CONTROL_COLOR_RESERVATION_TYPE_0200
1225 * @tc.desc: test TAG OHOS_ABILITY_COLOR_RESERVATION_TYPES and OHOS_CONTROL_COLOR_RESERVATION_TYPE
1226 * @tc.size:MediumTest
1227 * @tc.type:Function
1228 */
1229 HWTEST_F(CameraHdiTestV1_3, SUB_MULTIMEDIA_CAMERA_OHOS_CONTROL_COLOR_RESERVATION_TYPE_0200, 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_COLOR_RESERVATION_TYPES, &entry);
1236 if (cameraTest->rc != CAM_META_SUCCESS || entry.count == 0) {
1237 CAMERA_LOGE("OHOS_ABILITY_COLOR_RESERVATION_TYPES is not supported");
1238 return;
1239 }
1240 for (int i = 0; i < entry.count; i++) {
1241 if (entry.data.u8[i] == OHOS_CAMERA_COLOR_RESERVATION_PORTRAIT) {
1242 CAMERA_LOGI("color reservation type OHOS_CAMERA_COLOR_RESERVATION_PORTRAIT is supported");
1243 } else if (entry.data.u8[i] == OHOS_CAMERA_COLOR_RESERVATION_NONE) {
1244 CAMERA_LOGI("color reservation type OHOS_CAMERA_COLOR_RESERVATION_NONE is supported");
1245 } else {
1246 CAMERA_LOGE("color reservation type is not supported");
1247 return;
1248 }
1249 }
1250 camera_metadata_item_t item;
1251 bool status = false;
1252 uint8_t metacolorType = static_cast<uint8_t>(OHOS_CAMERA_COLOR_RESERVATION_NONE);
1253 int ret = FindCameraMetadataItem(data, OHOS_CONTROL_COLOR_RESERVATION_TYPE, &item);
1254 if (ret == CAM_META_ITEM_NOT_FOUND) {
1255 status = cameraTest->ability->addEntry(OHOS_CONTROL_COLOR_RESERVATION_TYPE, &metacolorType, DATA_COUNT);
1256 CAMERA_LOGI("add OHOS_CAMERA_COLOR_RESERVATION_NONE to ability");
1257 } else if (ret == CAM_META_SUCCESS) {
1258 status = cameraTest->ability->updateEntry(OHOS_CONTROL_COLOR_RESERVATION_TYPE, &metacolorType, DATA_COUNT);
1259 CAMERA_LOGI("update OHOS_CAMERA_COLOR_RESERVATION_NONE 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 noneType = 0;
1264 meta->addEntry(OHOS_CONTROL_COLOR_RESERVATION_TYPE, &noneType, 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("second: update settings success");
1269 ret = FindCameraMetadataItem(data, OHOS_CONTROL_COLOR_RESERVATION_TYPE, &item);
1270 EXPECT_EQ(ret, CAM_META_SUCCESS);
1271 EXPECT_TRUE(item.data.u8[0] == OHOS_CAMERA_COLOR_RESERVATION_NONE);
1272 }