1 /*
2 *
3 * Copyright (c) 2024-2025 Huawei Device Co., Ltd.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file expected in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "hdi_common_v1_3.h"
18 #include "camera.h"
19 #include "video_key_info.h"
20 constexpr uint32_t ITEM_CAPACITY = 100;
21 constexpr uint32_t DATA_CAPACITY = 2000;
22 constexpr uint32_t DATA_COUNT = 1;
23 constexpr uint32_t FPS_COUNT = 2;
24 constexpr uint32_t CHECK_AREA_COUNT = 4;
25 constexpr uint32_t STREAMINFO_WIDTH = 1920;
26 constexpr uint32_t STREAMINFO_HEIGHT = 1080;
27 constexpr uint32_t HIGH_RESOLUTION_PHOTO_WIDTH = 8192;
28 constexpr uint32_t HIGH_RESOLUTION_PHOTO_HEIGHT = 6144;
29 namespace OHOS::Camera {
30 Test::ResultCallback Test::resultCallback_ = 0;
31 Test::StreamResultCallback Test::streamResultCallback_ = 0;
32 OHOS::HDI::Camera::V1_0::FlashlightStatus Test::statusCallback =
33 static_cast<OHOS::HDI::Camera::V1_0::FlashlightStatus>(0);
34 constexpr uint32_t LOOP_COUNT = 12;
GetCurrentLocalTimeStamp()35 uint64_t Test::GetCurrentLocalTimeStamp()
36 {
37 std::chrono::time_point<std::chrono::system_clock, std::chrono::milliseconds> tp =
38 std::chrono::time_point_cast<std::chrono::milliseconds>(std::chrono::system_clock::now());
39 auto tmp = std::chrono::duration_cast<std::chrono::milliseconds>(tp.time_since_epoch());
40 return static_cast<uint64_t>(tmp.count());
41 }
42
DumpImageFile(int streamId,std::string suffix,const void * buffer,int32_t size)43 int32_t Test::DumpImageFile(int streamId, std::string suffix, const void* buffer, int32_t size)
44 {
45 if (imageDataSaveSwitch == SWITCH_OFF) {
46 return 0;
47 }
48 if (streamId < 0) {
49 CAMERA_LOGE("ivalid stream id: %{public}d", streamId);
50 return -1;
51 }
52 char mkdirCmd[PATH_MAX] = {0};
53 char path[PATH_MAX] = {0};
54 int ret = sprintf_s(mkdirCmd, sizeof(mkdirCmd) / sizeof(mkdirCmd[0]),
55 "mkdir -p /data/stream-%d", streamId);
56 if (ret < 0) {
57 return -1;
58 }
59 system(mkdirCmd);
60 ret = sprintf_s(path, sizeof(path) / sizeof(path[0]), "/data/stream-%d/%lld.%s",
61 streamId, GetCurrentLocalTimeStamp(), suffix.c_str());
62 if (ret < 0) {
63 return -1;
64 }
65
66 int imgFd = open(path, O_RDWR | O_CREAT, 00766);
67 if (imgFd == -1) {
68 CAMERA_LOGE("open file failed, errno: %{public}s", strerror(errno));
69 return -1;
70 }
71
72 ret = write(imgFd, buffer, size);
73 if (ret == -1) {
74 CAMERA_LOGE("write file failed, error: %{public}s", strerror(errno));
75 close(imgFd);
76 return -1;
77 }
78 close(imgFd);
79 return 0;
80 }
81
Init()82 void Test::Init()
83 {
84 uint32_t mainVer;
85 uint32_t minVer;
86 int32_t ret;
87 if (serviceV1_3 == nullptr) {
88 serviceV1_3 = OHOS::HDI::Camera::V1_3::ICameraHost::Get("camera_service", false);
89 if (serviceV1_3 == nullptr) {
90 int loopCount = 0;
91 do {
92 usleep(UT_MICROSECOND_TIMES);
93 serviceV1_3 = OHOS::HDI::Camera::V1_3::ICameraHost::Get("camera_service", false);
94 loopCount++;
95 } while (loopCount <= LOOP_COUNT || serviceV1_3 == nullptr);
96 }
97 EXPECT_NE(serviceV1_3, nullptr);
98 CAMERA_LOGI("V1_3::ICameraHost get success");
99 ret = serviceV1_3->GetVersion(mainVer, minVer);
100 EXPECT_EQ(ret, 0);
101 CAMERA_LOGI("V1_3::ICameraHost get version success, %{public}d, %{public}d", mainVer, minVer);
102 }
103
104 hostCallback = new TestCameraHostCallback();
105 ret = serviceV1_3->SetCallback(hostCallback);
106 EXPECT_EQ(ret, 0);
107 serviceV1_3->GetCameraIds(cameraIds);
108 if (cameraIds.size() <= CAMERA_ID_NUM) {
109 CAMERA_LOGE("camera device list empty");
110 GTEST_SKIP() << "No Camera Available" << std::endl;
111 return;
112 }
113 }
114
Open(int cameraId)115 void Test::Open(int cameraId)
116 {
117 if (cameraDeviceV1_3 == nullptr) {
118 if (cameraIds.size() <= CAMERA_ID_NUM) {
119 CAMERA_LOGE("camera device list empty");
120 GTEST_SKIP() << "No Camera Available" << std::endl;
121 return;
122 }
123 EXPECT_NE(serviceV1_3, nullptr);
124 EXPECT_NE(cameraIds.size(), 0);
125 GetCameraMetadata(cameraId);
126 deviceCallback = new OHOS::Camera::Test::DemoCameraDeviceCallback();
127
128 EXPECT_NE(serviceV1_3, nullptr);
129 if (DEVICE_1 == cameraId) {
130 rc = serviceV1_3->OpenCamera_V1_3(cameraIds[1], deviceCallback, cameraDeviceV1_3);
131 } else {
132 rc = serviceV1_3->OpenCamera_V1_3(cameraIds[0], deviceCallback, cameraDeviceV1_3);
133 }
134 EXPECT_EQ(rc, HDI::Camera::V1_0::NO_ERROR);
135 EXPECT_NE(cameraDeviceV1_3, nullptr);
136 CAMERA_LOGI("OpenCamera V1_2 success");
137 }
138 }
139
OpenSecureCamera(int cameraId)140 void Test::OpenSecureCamera(int cameraId)
141 {
142 if (cameraDeviceV1_3 == nullptr) {
143 serviceV1_3->GetCameraIds(cameraIds);
144 if (cameraIds.size() <= CAMERA_ID_NUM) {
145 CAMERA_LOGE("camera device list empty");
146 GTEST_SKIP() << "No Camera Available" << std::endl;
147 return;
148 }
149 EXPECT_NE(serviceV1_3, nullptr);
150 EXPECT_NE(cameraIds.size(), 0);
151 GetCameraMetadata(cameraId);
152 deviceCallback = new OHOS::Camera::Test::DemoCameraDeviceCallback();
153
154 EXPECT_NE(serviceV1_3, nullptr);
155 if (DEVICE_1 == cameraId) {
156 rc = serviceV1_3->OpenSecureCamera(cameraIds[1], deviceCallback, cameraDeviceV1_3);
157 } else {
158 rc = serviceV1_3->OpenSecureCamera(cameraIds[0], deviceCallback, cameraDeviceV1_3);
159 }
160 EXPECT_EQ(rc, HDI::Camera::V1_0::NO_ERROR);
161 EXPECT_NE(cameraDeviceV1_3, nullptr);
162 CAMERA_LOGI("OpenSecureCamera success");
163 }
164 }
165
166
GetCameraMetadata(int cameraId)167 void Test::GetCameraMetadata(int cameraId)
168 {
169 if (DEVICE_1 == cameraId) {
170 rc = serviceV1_3->GetCameraAbility(cameraIds[1], abilityVec);
171 } else {
172 rc = serviceV1_3->GetCameraAbility(cameraIds[0], abilityVec);
173 }
174 if (rc != HDI::Camera::V1_0::NO_ERROR) {
175 CAMERA_LOGE("GetCameraAbility failed, rc = %{public}d", rc);
176 }
177 MetadataUtils::ConvertVecToMetadata(abilityVec, ability);
178 EXPECT_NE(ability, nullptr);
179 }
180
PrintAllTagDataU8(std::shared_ptr<CameraMetadata> ability,uint32_t tag)181 void Test::PrintAllTagDataU8(std::shared_ptr<CameraMetadata> ability, uint32_t tag)
182 {
183 common_metadata_header_t* data = ability->get();
184 camera_metadata_item_t entry;
185 int ret = FindCameraMetadataItem(data, tag, &entry);
186 EXPECT_EQ(ret, 0);
187 EXPECT_NE(entry.count, 0);
188 std::cout << "----tag = " << tag << "count = " << entry.count << std::endl;
189 for (int i = 0; i < entry.count; i++) {
190 int v = entry.data.u8[i];
191 std::cout << "tag[" << tag << "][" << i << "] = " << v << std::endl;
192 }
193 std::cout << "--------------------------------" << std::endl;
194 }
195
Close()196 void Test::Close()
197 {
198 if (cameraDeviceV1_3 != nullptr) {
199 cameraDeviceV1_3->Close();
200 cameraDeviceV1_3 = nullptr;
201 }
202 }
203
DefaultPreview(std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> & infos)204 void Test::DefaultPreview(
205 std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> &infos)
206 {
207 infos->v1_0.streamId_ = streamIdPreview;
208 infos->v1_0.width_ = previewWidth;
209 infos->v1_0.height_ = previewHeight;
210 infos->v1_0.format_ = previewFormat;
211 infos->v1_0.dataspace_ = UT_DATA_SIZE;
212 infos->v1_0.intent_ = StreamIntent::PREVIEW;
213 infos->v1_0.tunneledMode_ = UT_TUNNEL_MODE;
214 }
215
DefaultCapture(std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> & infos)216 void Test::DefaultCapture(
217 std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> &infos)
218 {
219 infos->v1_0.streamId_ = streamIdCapture;
220 infos->v1_0.width_ = captureWidth;
221 infos->v1_0.height_ = captureHeight;
222 infos->v1_0.format_ = snapshotFormat;
223 infos->v1_0.dataspace_ = UT_DATA_SIZE;
224 infos->v1_0.intent_ = StreamIntent::STILL_CAPTURE;
225 infos->v1_0.tunneledMode_ = UT_TUNNEL_MODE;
226 }
227
CreateAndCommitStreamsForHighFrameRate(std::shared_ptr<OHOS::Camera::Test> cameraTest)228 void Test::CreateAndCommitStreamsForHighFrameRate(std::shared_ptr<OHOS::Camera::Test> cameraTest)
229 {
230 // Get stream operator
231 cameraTest->streamOperatorCallbackV1_3 = new OHOS::Camera::Test::TestStreamOperatorCallbackV1_3();
232 cameraTest->rc = cameraTest->cameraDeviceV1_3->GetStreamOperator_V1_3(cameraTest->streamOperatorCallbackV1_3,
233 cameraTest->streamOperator_V1_3);
234 EXPECT_NE(cameraTest->streamOperator_V1_3, nullptr);
235 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
236 // Preview streamInfo
237 cameraTest->streamInfoPre = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
238 cameraTest->DefaultInfosPreview(cameraTest->streamInfoPre);
239 cameraTest->streamInfoPre->v1_0.width_ = STREAMINFO_WIDTH;
240 cameraTest->streamInfoPre->v1_0.height_ = STREAMINFO_HEIGHT;
241 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoPre);
242 // Video streamInfo
243 cameraTest->streamInfoVideo = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
244 cameraTest->DefaultInfosVideo(cameraTest->streamInfoVideo);
245 cameraTest->streamInfoVideo->v1_0.width_ = STREAMINFO_WIDTH;
246 cameraTest->streamInfoVideo->v1_0.height_ = STREAMINFO_HEIGHT;
247 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoVideo);
248 // Create and commitStream
249 cameraTest->rc = cameraTest->streamOperator_V1_3->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
250 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
251 cameraTest->rc = cameraTest->streamOperator_V1_3->CommitStreams_V1_1(
252 static_cast<OHOS::HDI::Camera::V1_1::OperationMode_V1_1>(OHOS::HDI::Camera::V1_3::HIGH_FRAME_RATE),
253 cameraTest->abilityVec);
254 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
255 }
256
CreateAndCommitStreamsForSlowMotion(std::shared_ptr<OHOS::Camera::Test> cameraTest)257 void Test::CreateAndCommitStreamsForSlowMotion(std::shared_ptr<OHOS::Camera::Test> cameraTest)
258 {
259 // Get stream operator
260 cameraTest->streamOperatorCallbackV1_3 = new OHOS::Camera::Test::TestStreamOperatorCallbackV1_3();
261 cameraTest->rc = cameraTest->cameraDeviceV1_3->GetStreamOperator_V1_3(cameraTest->streamOperatorCallbackV1_3,
262 cameraTest->streamOperator_V1_3);
263 EXPECT_NE(cameraTest->streamOperator_V1_3, nullptr);
264 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
265 // Preview streamInfo
266 cameraTest->streamInfoPre = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
267 cameraTest->DefaultInfosPreview(cameraTest->streamInfoPre);
268 cameraTest->streamInfoPre->v1_0.width_ = STREAMINFO_WIDTH;
269 cameraTest->streamInfoPre->v1_0.height_ = STREAMINFO_HEIGHT;
270 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoPre);
271 // Video streamInfo
272 cameraTest->streamInfoVideo = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
273 cameraTest->DefaultInfosVideo(cameraTest->streamInfoVideo);
274 cameraTest->streamInfoVideo->v1_0.width_ = STREAMINFO_WIDTH;
275 cameraTest->streamInfoVideo->v1_0.height_ = STREAMINFO_HEIGHT;
276 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoVideo);
277 // Create and commitStream
278 cameraTest->rc = cameraTest->streamOperator_V1_3->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
279 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
280 cameraTest->rc = cameraTest->streamOperator_V1_3->CommitStreams_V1_1(
281 static_cast<OHOS::HDI::Camera::V1_1::OperationMode_V1_1>(OHOS::HDI::Camera::V1_2::SLOW_MOTION),
282 cameraTest->abilityVec);
283 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
284 }
285
UpdateSettingsForSlowMotionMode(std::shared_ptr<OHOS::Camera::Test> cameraTest)286 void Test::UpdateSettingsForSlowMotionMode(std::shared_ptr<OHOS::Camera::Test> cameraTest)
287 {
288 // Update settings
289 std::shared_ptr<CameraSetting> meta = std::make_shared<CameraSetting>(ITEM_CAPACITY, DATA_CAPACITY);
290 int32_t valueInvalid[2] = {240, 240};
291 float motionCheckArea[4] = {1, 1, 1, 1};
292 meta->addEntry(OHOS_CONTROL_FPS_RANGES, &valueInvalid, FPS_COUNT);
293 meta->addEntry(OHOS_CONTROL_MOTION_DETECTION_CHECK_AREA, &motionCheckArea, CHECK_AREA_COUNT);
294 std::vector<uint8_t> setting;
295 MetadataUtils::ConvertMetadataToVec(meta, setting);
296 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
297 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
298 int32_t slowMotionControl = OHOS_CAMERA_MOTION_DETECTION_ENABLE;
299 meta->addEntry(OHOS_CONTROL_MOTION_DETECTION, &slowMotionControl, DATA_COUNT);
300 MetadataUtils::ConvertMetadataToVec(meta, setting);
301 cameraTest->rc = (CamRetCode)cameraTest->cameraDeviceV1_3->UpdateSettings(setting);
302 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
303
304 // Start capture
305 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
306 cameraTest->StartCapture(cameraTest->streamIdVideo, cameraTest->captureIdVideo, false, true);
307 cameraTest->captureIds = {cameraTest->captureIdPreview, cameraTest->captureIdVideo};
308 cameraTest->streamIds = {cameraTest->streamIdPreview, cameraTest->streamIdVideo};
309 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
310 }
311
SuperSlowMotionStatusCallback(std::shared_ptr<OHOS::Camera::Test> cameraTest)312 void Test::SuperSlowMotionStatusCallback(std::shared_ptr<OHOS::Camera::Test> cameraTest)
313 {
314 if (cameraTest->deviceCallback->resultMeta == nullptr) {
315 CAMERA_LOGI("callback not triggered");
316 return;
317 }
318 common_metadata_header_t* data = cameraTest->deviceCallback->resultMeta->get();
319 EXPECT_NE(data, nullptr);
320 camera_metadata_item_t entry;
321 cameraTest->rc = FindCameraMetadataItem(data, OHOS_STATUS_SLOW_MOTION_DETECTION, &entry);
322 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
323 if (cameraTest->rc == HDI::Camera::V1_0::NO_ERROR && entry.data.u8 != nullptr && entry.count > 0) {
324 uint8_t value = entry.data.u8[0];
325 // Detect the state of super slow motion
326 if (value == OHOS_CONTROL_SLOW_MOTION_STATUS_DISABLE) {
327 CAMERA_LOGI("slow motion status is disabled");
328 } else if (value == OHOS_CONTROL_SLOW_MOTION_STATUS_READY) {
329 CAMERA_LOGI("slow motion status is ready");
330 } else if (value == OHOS_CONTROL_SLOW_MOTION_STATUS_START) {
331 CAMERA_LOGI("slow motion status is started");
332 } else if (value == OHOS_CONTROL_SLOW_MOTION_STATUS_RECORDING) {
333 CAMERA_LOGI("slow motion status is recording");
334 } else if (value == OHOS_CONTROL_SLOW_MOTION_STATUS_FINISH) {
335 CAMERA_LOGI("slow motion status is finished");
336 }
337 }
338 }
339
startStreamForHighResolutionPhoto(std::shared_ptr<OHOS::Camera::Test> cameraTest)340 void Test::startStreamForHighResolutionPhoto(std::shared_ptr<OHOS::Camera::Test> cameraTest)
341 {
342 // Get stream operator
343 cameraTest->streamOperatorCallbackV1_3 = new OHOS::Camera::Test::TestStreamOperatorCallbackV1_3();
344 cameraTest->rc = cameraTest->cameraDeviceV1_3->GetStreamOperator_V1_3(cameraTest->streamOperatorCallbackV1_3,
345 cameraTest->streamOperator_V1_3);
346 EXPECT_NE(cameraTest->streamOperator_V1_3, nullptr);
347 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
348
349 // Preview streamInfo
350 cameraTest->streamInfoPre = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
351 cameraTest->DefaultInfosPreview(cameraTest->streamInfoPre);
352 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoPre);
353
354 // Capture streamInfo
355 cameraTest->streamInfoCapture = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
356 cameraTest->DefaultInfosCapture(cameraTest->streamInfoCapture);
357 cameraTest->streamInfoCapture->v1_0.width_ = HIGH_RESOLUTION_PHOTO_WIDTH;
358 cameraTest->streamInfoCapture->v1_0.height_ = HIGH_RESOLUTION_PHOTO_HEIGHT;
359 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoCapture);
360
361 // Create and commit streams
362 cameraTest->rc = cameraTest->streamOperator_V1_3->CreateStreams_V1_1(cameraTest->streamInfosV1_1);
363 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
364 cameraTest->rc = cameraTest->streamOperator_V1_3->CommitStreams_V1_1(
365 static_cast<OHOS::HDI::Camera::V1_1::OperationMode_V1_1>(OHOS::HDI::Camera::V1_3::HIGH_RESOLUTION_PHOTO),
366 cameraTest->abilityVec);
367 EXPECT_EQ(HDI::Camera::V1_0::NO_ERROR, cameraTest->rc);
368 }
369
CaptureByColorSpacesWithUpdateStreams(std::vector<int32_t> captureColorSpaces,std::shared_ptr<OHOS::Camera::Test> cameraTest)370 void Test::CaptureByColorSpacesWithUpdateStreams(std::vector<int32_t> captureColorSpaces,
371 std::shared_ptr<OHOS::Camera::Test> cameraTest)
372 {
373 printf("Enter CaptureByColorSpacesWithUpdateStreams function!\n");
374 if (!captureColorSpaces.empty()) {
375 // Clear infos
376 cameraTest->streamInfosV1_1.clear();
377 // Preview streamInfo
378 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
379 cameraTest->DefaultInfosPreview(cameraTest->streamInfoV1_1);
380 cameraTest->streamInfoV1_1->v1_0.dataspace_ = captureColorSpaces[0];
381 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
382 // Capture streamInfo
383 cameraTest->streamInfoCapture = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
384 cameraTest->DefaultInfosCapture(cameraTest->streamInfoCapture);
385 cameraTest->streamInfoCapture->v1_0.dataspace_ = captureColorSpaces[0];
386 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoCapture);
387
388 // StreamInfosV1_1 should not be empty
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_V1_1(
392 OHOS::HDI::Camera::V1_1::OperationMode_V1_1::NORMAL, cameraTest->abilityVec);
393 // Start without colorspace setting
394 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
395 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
396
397 for (int32_t colorSpaces : captureColorSpaces) {
398 printf("capture colorSpaces value %d\n", colorSpaces);
399 // CancelCapture
400 cameraTest->streamOperator_V1_3->CancelCapture(cameraTest->captureIdPreview);
401 // Clear infos
402 cameraTest->streamInfosV1_1.clear();
403 // Preview streamInfo
404 cameraTest->streamInfoV1_1 = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
405 cameraTest->DefaultInfosPreview(cameraTest->streamInfoV1_1);
406 cameraTest->streamInfoV1_1->v1_0.dataspace_ = colorSpaces;
407 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoV1_1);
408 // Capture streamInfo
409 cameraTest->streamInfoCapture = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
410 cameraTest->DefaultInfosCapture(cameraTest->streamInfoCapture);
411 cameraTest->streamInfoCapture->v1_0.dataspace_ = colorSpaces;
412 cameraTest->streamInfosV1_1.push_back(*cameraTest->streamInfoCapture);
413 // UpdateStreams
414 cameraTest->rc = cameraTest->streamOperator_V1_3->UpdateStreams(cameraTest->streamInfosV1_1);
415 // Capture
416 EXPECT_EQ(cameraTest->rc, HDI::Camera::V1_0::NO_ERROR);
417 cameraTest->StartCapture(cameraTest->streamIdPreview, cameraTest->captureIdPreview, false, true);
418 cameraTest->StartCapture(cameraTest->streamIdCapture, cameraTest->captureIdCapture, false, false);
419 sleep(UT_SECOND_TIMES);
420 }
421
422 // StopStream
423 cameraTest->StopStream(cameraTest->captureIds, cameraTest->streamIds);
424 }
425 }
426
DefaultSketch(std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> & infos)427 void Test::DefaultSketch(
428 std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> &infos)
429 {
430 infos->v1_0.streamId_ = streamIdSketch;
431 infos->v1_0.width_ = sketchWidth;
432 infos->v1_0.height_ = sketchHeight;
433 infos->v1_0.format_ = previewFormat;
434 infos->v1_0.dataspace_ = UT_DATA_SIZE;
435 infos->v1_0.intent_ = StreamIntent::PREVIEW;
436 infos->v1_0.tunneledMode_ = UT_TUNNEL_MODE;
437 }
438
DefaultInfosSketch(std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> & infos)439 void Test::DefaultInfosSketch(
440 std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> &infos)
441 {
442 DefaultSketch(infos);
443 std::shared_ptr<StreamConsumer> consumer_pre = std::make_shared<StreamConsumer>();
444 infos->v1_0.bufferQueue_ = consumer_pre->CreateProducerSeq([this](void* addr, uint32_t size) {
445 DumpImageFile(streamIdSketch, "yuv", addr, size);
446 });
447 infos->v1_0.bufferQueue_->producer_->SetQueueSize(UT_DATA_SIZE);
448 consumerMap_[StreamIntent::PREVIEW] = consumer_pre;
449 }
450
DefaultInfosPreviewV1_2(std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> & infos)451 void Test::DefaultInfosPreviewV1_2(
452 std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> &infos)
453 {
454 DefaultPreview(infos);
455 std::shared_ptr<StreamConsumer> consumer_pre = std::make_shared<StreamConsumer>();
456 infos->v1_0.bufferQueue_ = consumer_pre->CreateProducerSeq([this](void* addr, uint32_t size) {
457 DumpImageFile(streamIdPreview, "yuv", addr, size);
458 });
459 infos->v1_0.bufferQueue_->producer_->SetQueueSize(UT_DATA_SIZE);
460 }
461
DefaultInfosPreview(std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> & infos)462 void Test::DefaultInfosPreview(
463 std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> &infos)
464 {
465 DefaultPreview(infos);
466 std::shared_ptr<StreamConsumer> consumer_pre = std::make_shared<StreamConsumer>();
467 infos->v1_0.bufferQueue_ = consumer_pre->CreateProducerSeq([this](void* addr, uint32_t size) {
468 DumpImageFile(streamIdPreview, "yuv", addr, size);
469 });
470 infos->v1_0.bufferQueue_->producer_->SetQueueSize(UT_DATA_SIZE);
471 consumerMap_[StreamIntent::PREVIEW] = consumer_pre;
472 }
473
DefaultInfosCapture(std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> & infos)474 void Test::DefaultInfosCapture(
475 std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> &infos)
476 {
477 DefaultCapture(infos);
478 std::shared_ptr<StreamConsumer> consumer_capture = std::make_shared<StreamConsumer>();
479 infos->v1_0.bufferQueue_ = consumer_capture->CreateProducerSeq([this](void* addr, uint32_t size) {
480 DumpImageFile(streamIdCapture, "jpeg", addr, size);
481 });
482 infos->v1_0.bufferQueue_->producer_->SetQueueSize(UT_DATA_SIZE);
483 consumerMap_[StreamIntent::STILL_CAPTURE] = consumer_capture;
484 }
485
DefaultInfosProfessionalCapture(std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> & infos)486 void Test::DefaultInfosProfessionalCapture(
487 std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> &infos)
488 {
489 DefaultCapture(infos);
490 std::shared_ptr<StreamConsumer> consumer_capture = std::make_shared<StreamConsumer>();
491 infos->v1_0.bufferQueue_ = consumer_capture->CreateProducerSeq([this](void* addr, uint32_t size) {
492 DumpImageFile(streamIdCapture, "yuv", addr, size);
493 });
494 infos->v1_0.bufferQueue_->producer_->SetQueueSize(UT_DATA_SIZE);
495 consumerMap_[StreamIntent::STILL_CAPTURE] = consumer_capture;
496 }
497
DefaultInfosVideo(std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> & infos)498 void Test::DefaultInfosVideo(
499 std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> &infos)
500 {
501 infos->v1_0.streamId_ = streamIdVideo;
502 infos->v1_0.width_ = videoWidth;
503 infos->v1_0.height_ = videoHeight;
504 infos->v1_0.format_ = videoFormat;
505 infos->v1_0.dataspace_ = UT_DATA_SIZE;
506 infos->v1_0.intent_ = StreamIntent::VIDEO;
507 infos->v1_0.encodeType_ = ENCODE_TYPE_H265;
508 infos->v1_0.tunneledMode_ = UT_TUNNEL_MODE;
509 std::shared_ptr<StreamConsumer> consumer_video = std::make_shared<StreamConsumer>();
510 infos->v1_0.bufferQueue_ = consumer_video->CreateProducerSeq([this](void* addr, uint32_t size) {
511 DumpImageFile(streamIdVideo, "yuv", addr, size);
512 });
513 infos->v1_0.bufferQueue_->producer_->SetQueueSize(UT_DATA_SIZE);
514 consumerMap_[StreamIntent::VIDEO] = consumer_video;
515 }
516
DefaultInfosAnalyze(std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> & infos)517 void Test::DefaultInfosAnalyze(
518 std::shared_ptr<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1> &infos)
519 {
520 infos->v1_0.streamId_ = streamIdAnalyze;
521 infos->v1_0.width_ = analyzeWidth;
522 infos->v1_0.height_ = analyzeHeight;
523 infos->v1_0.format_ = analyzeFormat;
524 infos->v1_0.dataspace_ = UT_DATA_SIZE;
525 infos->v1_0.intent_ = StreamIntent::ANALYZE;
526 infos->v1_0.tunneledMode_ = UT_TUNNEL_MODE;
527
528 std::shared_ptr<StreamConsumer> consumer_analyze = std::make_shared<StreamConsumer>();
529 infos->v1_0.bufferQueue_ = consumer_analyze->CreateProducerSeq([this](void* addr, uint32_t size) {
530 common_metadata_header_t *data = static_cast<common_metadata_header_t *>(addr);
531 camera_metadata_item_t entry = {};
532
533 int ret = FindCameraMetadataItem(data, OHOS_STATISTICS_FACE_IDS, &entry);
534 if (ret == 0) {
535 for (size_t i = 0; i < entry.count; i++) {
536 int id = entry.data.i32[i];
537 CAMERA_LOGI("Face ids : %{public}d", id);
538 }
539 }
540
541 ret = FindCameraMetadataItem(data, OHOS_STATISTICS_FACE_RECTANGLES, &entry);
542 if (ret == 0) {
543 for (size_t i = 0; i < entry.count; i++) {
544 int id = entry.data.i32[i];
545 CAMERA_LOGI("Face rectangles : %{public}d", id);
546 }
547 }
548 });
549 infos->v1_0.bufferQueue_->producer_->SetQueueSize(UT_DATA_SIZE);
550 consumerMap_[StreamIntent::ANALYZE] = consumer_analyze;
551 }
552
StartProfessionalStream(std::vector<StreamIntent> intents,uint8_t professionalMode)553 void Test::StartProfessionalStream(std::vector<StreamIntent> intents, uint8_t professionalMode)
554 {
555 streamOperatorCallbackV1_3 = new TestStreamOperatorCallbackV1_3();
556 uint32_t mainVersion = 1;
557 uint32_t minVersion = 0;
558 rc = cameraDeviceV1_3->GetStreamOperator_V1_3(streamOperatorCallbackV1_3, streamOperator_V1_3);
559 if (rc == HDI::Camera::V1_0::NO_ERROR) {
560 rc = streamOperator_V1_3->GetVersion(mainVersion, minVersion);
561 if (rc != HDI::Camera::V1_0::NO_ERROR) {
562 CAMERA_LOGE("streamOperator_V1_3 get version failed, rc = %{public}d", rc);
563 } else {
564 CAMERA_LOGI("streamOperator_V1_3 get version success, %{public}u, %{public}u",
565 mainVersion, minVersion);
566 }
567 CAMERA_LOGI("GetStreamOperator success");
568 } else {
569 CAMERA_LOGE("GetStreamOperator fail, rc = %{public}d", rc);
570 }
571 streamInfoPre = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
572 streamInfoVideo = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
573 streamInfoCapture = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
574 streamInfoAnalyze = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
575
576 for (auto& streamType : intents) {
577 if (streamType == StreamIntent::PREVIEW) {
578 DefaultInfosPreview(streamInfoPre);
579 streamInfos.push_back(*streamInfoPre);
580 } else if (streamType == StreamIntent::VIDEO) {
581 DefaultInfosVideo(streamInfoVideo);
582 streamInfos.push_back(*streamInfoVideo);
583 } else if (streamType == StreamIntent::ANALYZE) {
584 DefaultInfosAnalyze(streamInfoAnalyze);
585 streamInfos.push_back(*streamInfoAnalyze);
586 } else {
587 DefaultInfosProfessionalCapture(streamInfoCapture);
588 streamInfos.push_back(*streamInfoCapture);
589 }
590 }
591
592 rc = streamOperator_V1_3->CreateStreams_V1_1(streamInfos);
593 EXPECT_EQ(false, rc != HDI::Camera::V1_0::NO_ERROR);
594 rc = streamOperator_V1_3->CommitStreams_V1_1(
595 static_cast<OHOS::HDI::Camera::V1_1::OperationMode_V1_1>(professionalMode),
596 abilityVec);
597 EXPECT_EQ(false, rc != HDI::Camera::V1_0::NO_ERROR);
598 sleep(1);
599 std::vector<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>().swap(streamInfos);
600 }
601
StartStream(std::vector<StreamIntent> intents,OHOS::HDI::Camera::V1_3::OperationMode mode)602 void Test::StartStream(std::vector<StreamIntent> intents, OHOS::HDI::Camera::V1_3::OperationMode mode)
603 {
604 streamOperatorCallbackV1_3 = new TestStreamOperatorCallbackV1_3();
605 uint32_t mainVersion = 1;
606 uint32_t minVersion = 0;
607 rc = cameraDeviceV1_3->GetStreamOperator_V1_3(streamOperatorCallbackV1_3, streamOperator_V1_3);
608 if (rc == HDI::Camera::V1_0::NO_ERROR) {
609 rc = streamOperator_V1_3->GetVersion(mainVersion, minVersion);
610 if (rc != HDI::Camera::V1_0::NO_ERROR) {
611 CAMERA_LOGE("streamOperator_V1_3 get version failed, rc = %{public}d", rc);
612 } else {
613 CAMERA_LOGI("streamOperator_V1_3 get version success, %{public}u, %{public}u",
614 mainVersion, minVersion);
615 }
616 CAMERA_LOGI("GetStreamOperator success");
617 } else {
618 CAMERA_LOGE("GetStreamOperator fail, rc = %{public}d", rc);
619 }
620 streamInfoPre = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
621 streamInfoVideo = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
622 streamInfoCapture = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
623 streamInfoAnalyze = std::make_shared<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>();
624
625 for (auto& intent : intents) {
626 if (intent == StreamIntent::PREVIEW) {
627 DefaultInfosPreview(streamInfoPre);
628 streamInfos.push_back(*streamInfoPre);
629 } else if (intent == StreamIntent::VIDEO) {
630 DefaultInfosVideo(streamInfoVideo);
631 streamInfos.push_back(*streamInfoVideo);
632 } else if (intent == StreamIntent::ANALYZE) {
633 DefaultInfosAnalyze(streamInfoAnalyze);
634 streamInfos.push_back(*streamInfoAnalyze);
635 } else {
636 DefaultInfosCapture(streamInfoCapture);
637 streamInfos.push_back(*streamInfoCapture);
638 }
639 }
640
641 rc = streamOperator_V1_3->CreateStreams_V1_1(streamInfos);
642 EXPECT_EQ(false, rc != HDI::Camera::V1_0::NO_ERROR);
643 rc = streamOperator_V1_3->CommitStreams_V1_1(
644 static_cast<OHOS::HDI::Camera::V1_1::OperationMode_V1_1>(mode), abilityVec);
645 EXPECT_EQ(false, rc != HDI::Camera::V1_0::NO_ERROR);
646 sleep(1);
647 std::vector<OHOS::HDI::Camera::V1_1::StreamInfo_V1_1>().swap(streamInfos);
648 }
649
StartCapture(int streamId,int captureId,bool shutterCallback,bool isStreaming)650 void Test::StartCapture(int streamId, int captureId, bool shutterCallback, bool isStreaming)
651 {
652 captureInfo = std::make_shared<CaptureInfo>();
653 captureInfo->streamIds_ = {streamId};
654 captureInfo->captureSetting_ = abilityVec;
655 captureInfo->enableShutterCallback_ = shutterCallback;
656 EXPECT_EQ(true, streamOperator_V1_3 != nullptr);
657 rc = (CamRetCode)streamOperator_V1_3->Capture(captureId, *captureInfo, isStreaming);
658 EXPECT_EQ(true, rc == HDI::Camera::V1_0::NO_ERROR);
659 if (rc == HDI::Camera::V1_0::NO_ERROR) {
660 CAMERA_LOGI("check Capture: Capture success, %{public}d", captureId);
661 } else {
662 std::cout << "rc = " << rc << std::endl;
663 CAMERA_LOGE("check Capture: Capture fail, rc = %{public}d", rc);
664 }
665 sleep(UT_SLEEP_TIME);
666 }
667
StopStream(std::vector<int> & captureIds,std::vector<int> & streamIds)668 void Test::StopStream(std::vector<int>& captureIds, std::vector<int>& streamIds)
669 {
670 if (captureIds.size() > 0) {
671 for (auto &captureId : captureIds) {
672 EXPECT_EQ(true, streamOperator_V1_3 != nullptr);
673 rc = streamOperator_V1_3->CancelCapture(captureId);
674 EXPECT_EQ(true, rc == HDI::Camera::V1_0::NO_ERROR);
675 if (rc == HDI::Camera::V1_0::NO_ERROR) {
676 CAMERA_LOGI("check Capture: CancelCapture success, %{public}d", captureId);
677 } else {
678 CAMERA_LOGE("check Capture: CancelCapture fail, rc = %{public}d, captureId = %{public}d",
679 rc, captureId);
680 }
681 }
682 }
683 if (streamIds.size() > 0) {
684 EXPECT_EQ(true, streamOperator_V1_3 != nullptr);
685 rc = streamOperator_V1_3->ReleaseStreams(streamIds);
686 EXPECT_EQ(true, rc == HDI::Camera::V1_0::NO_ERROR);
687 if (rc == HDI::Camera::V1_0::NO_ERROR) {
688 CAMERA_LOGI("check Capture: ReleaseStream success");
689 } else {
690 CAMERA_LOGE("check Capture: ReleaseStreams fail, rc = %{public}d", rc);
691 }
692 }
693 if (cameraDeviceV1_3) {
694 cameraDeviceV1_3->Reset();
695 }
696 }
697
CalculateFps(int64_t timestamp,int32_t streamId)698 void Test::StreamConsumer::CalculateFps(int64_t timestamp, int32_t streamId)
699 {
700 if (isFirstCalculateFps_) {
701 if ((timestamp - intervalTimestamp_) >= interval_) {
702 int64_t timeInterval = timestamp - intervalTimestamp_;
703 if (timeInterval != 0) {
704 float fps = (int64_t)(100000000000 * timestampCount_ / timeInterval) / 100.0;
705 CAMERA_LOGI("Calculate FPS success, streamId: %{public}d, Fps:%{public}f", streamId, fps);
706 interval_ = ONESECOND_OF_MICROSECOND_UNIT;
707 } else {
708 CAMERA_LOGE("Calculate FPS error timeInerval is 0");
709 }
710 }
711 } else {
712 intervalTimestamp_ = timestamp;
713 isFirstCalculateFps_ = true;
714 }
715 if ((timestamp - intervalTimestamp_) >= ONESECOND_OF_MICROSECOND_UNIT * UT_SECOND_TIMES) {
716 intervalTimestamp_ = timestamp;
717 timestampCount_ = 0;
718 interval_ = ONESECOND_OF_MICROSECOND_UNIT;
719 }
720 timestampCount_++;
721 }
722
GetTimeStamp(int64_t * g_timestamp,uint32_t lenght,int64_t timestamp,int32_t gotSize)723 void Test::StreamConsumer::GetTimeStamp(int64_t *g_timestamp, uint32_t lenght, int64_t timestamp, int32_t gotSize)
724 {
725 if (gotSize != UT_PREVIEW_SIZE) {
726 if (g_timestamp[0] == 0) {
727 g_timestamp[0] = timestamp;
728 } else {
729 g_timestamp[1] = timestamp;
730 }
731 }
732 }
733
CreateProducer(std::function<void (void *,uint32_t)> callback)734 OHOS::sptr<OHOS::IBufferProducer> Test::StreamConsumer::CreateProducer(std::function<void(void*, uint32_t)> callback)
735 {
736 consumer_ = OHOS::IConsumerSurface::Create();
737 if (consumer_ == nullptr) {
738 return nullptr;
739 }
740 sptr<IBufferConsumerListener> listener = new TestBufferConsumerListener();
741 consumer_->RegisterConsumerListener(listener);
742 auto producer = consumer_->GetProducer();
743 if (producer == nullptr) {
744 return nullptr;
745 }
746
747 callback_ = callback;
748 consumerThread_ = new std::thread([this, listener] {
749 int32_t flushFence = 0;
750 int64_t timestamp = 0;
751 OHOS::Rect damage;
752 TestBufferConsumerListener* checker = static_cast<TestBufferConsumerListener*>(listener.GetRefPtr());
753 while (running_ == true) {
754 OHOS::sptr<OHOS::SurfaceBuffer> buffer = nullptr;
755 if (checker->checkBufferAvailable()) {
756 consumer_->AcquireBuffer(buffer, flushFence, timestamp, damage);
757 if (buffer != nullptr) {
758 void* addr = buffer->GetVirAddr();
759 uint32_t size = buffer->GetSize();
760 int32_t gotSize = 0;
761 int32_t isKey = 0;
762 int32_t streamId = 0;
763 int32_t captureId = 0;
764 buffer->GetExtraData()->ExtraGet(OHOS::Camera::dataSize, gotSize);
765 buffer->GetExtraData()->ExtraGet(OHOS::Camera::isKeyFrame, isKey);
766 buffer->GetExtraData()->ExtraGet(OHOS::Camera::timeStamp, timestamp);
767 buffer->GetExtraData()->ExtraGet(OHOS::Camera::streamId, streamId);
768 buffer->GetExtraData()->ExtraGet(OHOS::Camera::captureId, captureId);
769 GetTimeStamp(g_timestamp, sizeof(g_timestamp) / sizeof(g_timestamp[0]), timestamp, gotSize);
770 if (gotSize) {
771 CalculateFps(timestamp, streamId);
772 callback_(addr, gotSize);
773 } else {
774 callback_(addr, size);
775 }
776 consumer_->ReleaseBuffer(buffer, -1);
777 shotCount_--;
778 if (shotCount_ == 0) {
779 std::unique_lock<std::mutex> l(l_);
780 cv_.notify_one();
781 }
782 }
783 }
784 if (running_ == false) {
785 break;
786 }
787 usleep(1);
788 }
789 });
790
791 return producer;
792 }
793
CreateProducerSeq(std::function<void (void *,uint32_t)> callback)794 OHOS::sptr<BufferProducerSequenceable> Test::StreamConsumer::CreateProducerSeq(
795 std::function<void(void*, uint32_t)> callback)
796 {
797 OHOS::sptr<OHOS::IBufferProducer> producer = CreateProducer(callback);
798 if (producer == nullptr) {
799 return nullptr;
800 }
801
802 return new BufferProducerSequenceable(producer);
803 }
804
OnCaptureStarted(int32_t captureId,const std::vector<int32_t> & streamId)805 int32_t Test::TestStreamOperatorCallback::OnCaptureStarted(int32_t captureId, const std::vector<int32_t> &streamId)
806 {
807 for (auto it : streamId) {
808 CAMERA_LOGE("captureId: %{public}d, streamId: %{public}d", captureId, it);
809 }
810 return HDI::Camera::V1_0::NO_ERROR;
811 }
812
OnCaptureEnded(int32_t captureId,const std::vector<CaptureEndedInfo> & infos)813 int32_t Test::TestStreamOperatorCallback::OnCaptureEnded(int32_t captureId, const std::vector<CaptureEndedInfo> &infos)
814 {
815 for (auto it : infos) {
816 CAMERA_LOGE("captureId: %{public}d, streamId: %{public}d, count: %{public}d", captureId, it.streamId_,
817 it.frameCount_);
818 }
819 return HDI::Camera::V1_0::NO_ERROR;
820 }
821
OnCaptureError(int32_t captureId,const std::vector<CaptureErrorInfo> & infos)822 int32_t Test::TestStreamOperatorCallback::OnCaptureError(int32_t captureId, const std::vector<CaptureErrorInfo> &infos)
823 {
824 for (auto it : infos) {
825 CAMERA_LOGE("captureId: %{public}d, streamId: %{public}d, error: %{public}d", captureId, it.streamId_,
826 it.error_);
827 }
828 return HDI::Camera::V1_0::NO_ERROR;
829 }
830
OnFrameShutter(int32_t captureId,const std::vector<int32_t> & streamIds,uint64_t timestamp)831 int32_t Test::TestStreamOperatorCallback::OnFrameShutter(int32_t captureId,
832 const std::vector<int32_t> &streamIds, uint64_t timestamp)
833 {
834 (void)timestamp;
835 for (auto it : streamIds) {
836 CAMERA_LOGE("captureId: %{public}d, streamId: %{public}d", captureId, it);
837 }
838 return HDI::Camera::V1_0::NO_ERROR;
839 }
840
OnCaptureStarted(int32_t captureId,const std::vector<int32_t> & streamId)841 int32_t Test::TestStreamOperatorCallbackV1_2::OnCaptureStarted(int32_t captureId, const std::vector<int32_t> &streamId)
842 {
843 return instanceImpl.OnCaptureStarted(captureId, streamId);
844 }
845
OnCaptureEnded(int32_t captureId,const std::vector<CaptureEndedInfo> & infos)846 int32_t Test::TestStreamOperatorCallbackV1_2::OnCaptureEnded(int32_t captureId,
847 const std::vector<CaptureEndedInfo> &infos)
848 {
849 return instanceImpl.OnCaptureEnded(captureId, infos);
850 }
851
OnCaptureError(int32_t captureId,const std::vector<CaptureErrorInfo> & infos)852 int32_t Test::TestStreamOperatorCallbackV1_2::OnCaptureError(int32_t captureId,
853 const std::vector<CaptureErrorInfo> &infos)
854 {
855 return instanceImpl.OnCaptureError(captureId, infos);
856 }
857
OnFrameShutter(int32_t captureId,const std::vector<int32_t> & streamIds,uint64_t timestamp)858 int32_t Test::TestStreamOperatorCallbackV1_2::OnFrameShutter(int32_t captureId,
859 const std::vector<int32_t> &streamIds, uint64_t timestamp)
860 {
861 return instanceImpl.OnFrameShutter(captureId, streamIds, timestamp);
862 }
863
OnCaptureStarted_V1_2(int32_t captureId,const std::vector<HDI::Camera::V1_2::CaptureStartedInfo> & infos)864 int32_t Test::TestStreamOperatorCallbackV1_2::OnCaptureStarted_V1_2(int32_t captureId,
865 const std::vector<HDI::Camera::V1_2::CaptureStartedInfo> &infos)
866 {
867 for (auto it : infos) {
868 CAMERA_LOGI("captureId: %{public}d, streamId: %{public}d", captureId, it.streamId_);
869 }
870 return HDI::Camera::V1_0::NO_ERROR;
871 }
872
OnCaptureStarted(int32_t captureId,const std::vector<int32_t> & streamId)873 int32_t Test::TestStreamOperatorCallbackV1_3::OnCaptureStarted(int32_t captureId, const std::vector<int32_t> &streamId)
874 {
875 return instanceImpl.OnCaptureStarted(captureId, streamId);
876 }
877
OnCaptureEnded(int32_t captureId,const std::vector<CaptureEndedInfo> & infos)878 int32_t Test::TestStreamOperatorCallbackV1_3::OnCaptureEnded(int32_t captureId,
879 const std::vector<CaptureEndedInfo> &infos)
880 {
881 return instanceImpl.OnCaptureEnded(captureId, infos);
882 }
883
OnCaptureEndedExt(int32_t captureId,const std::vector<HDI::Camera::V1_3::CaptureEndedInfoExt> & infos)884 int32_t Test::TestStreamOperatorCallbackV1_3::OnCaptureEndedExt(int32_t captureId,
885 const std::vector<HDI::Camera::V1_3::CaptureEndedInfoExt> &infos)
886 {
887 for (auto it : infos) {
888 CAMERA_LOGI("OnCaptureEndedExt captureId: %{public}d, streamId: %{public}d", captureId, it.streamId_);
889 }
890 return HDI::Camera::V1_0::NO_ERROR;
891 }
892
OnCaptureError(int32_t captureId,const std::vector<CaptureErrorInfo> & infos)893 int32_t Test::TestStreamOperatorCallbackV1_3::OnCaptureError(int32_t captureId,
894 const std::vector<CaptureErrorInfo> &infos)
895 {
896 return instanceImpl.OnCaptureError(captureId, infos);
897 }
898
OnFrameShutter(int32_t captureId,const std::vector<int32_t> & streamIds,uint64_t timestamp)899 int32_t Test::TestStreamOperatorCallbackV1_3::OnFrameShutter(int32_t captureId,
900 const std::vector<int32_t> &streamIds, uint64_t timestamp)
901 {
902 (void)timestamp;
903 for (auto it : streamIds) {
904 CAMERA_LOGI("OnFrameShutter captureId: %{public}d, streamId: %{public}d", captureId, it);
905 }
906 return instanceImpl.OnFrameShutter(captureId, streamIds, timestamp);
907 }
908
OnCaptureStarted_V1_2(int32_t captureId,const std::vector<HDI::Camera::V1_2::CaptureStartedInfo> & infos)909 int32_t Test::TestStreamOperatorCallbackV1_3::OnCaptureStarted_V1_2(int32_t captureId,
910 const std::vector<HDI::Camera::V1_2::CaptureStartedInfo> &infos)
911 {
912 return instanceImpl.OnCaptureStarted_V1_2(captureId, infos);
913 }
914
OnCaptureReady(int32_t captureId,const std::vector<int32_t> & streamIds,uint64_t timestamp)915 int32_t Test::TestStreamOperatorCallbackV1_3::OnCaptureReady(int32_t captureId,
916 const std::vector<int32_t> &streamIds, uint64_t timestamp)
917 {
918 (void)timestamp;
919 for (auto it : streamIds) {
920 CAMERA_LOGI("OnCaptureReady captureId: %{public}d, streamId: %{public}d", captureId, it);
921 }
922 return HDI::Camera::V1_0::NO_ERROR;
923 }
924
OnFrameShutterEnd(int32_t captureId,const std::vector<int32_t> & streamIds,uint64_t timestamp)925 int32_t Test::TestStreamOperatorCallbackV1_3::OnFrameShutterEnd(int32_t captureId,
926 const std::vector<int32_t> &streamIds, uint64_t timestamp)
927 {
928 (void)timestamp;
929 for (auto it : streamIds) {
930 CAMERA_LOGI("OnFrameShutterEnd captureId: %{public}d, streamId: %{public}d", captureId, it);
931 }
932 return HDI::Camera::V1_0::NO_ERROR;
933 }
934
OnResult(int32_t streamId,const std::vector<uint8_t> & result)935 int32_t Test::TestStreamOperatorCallbackV1_3::OnResult(int32_t streamId, const std::vector<uint8_t> &result)
936 {
937 MetadataUtils::ConvertVecToMetadata(result, streamResultMeta);
938 if (Test::streamResultCallback_) {
939 Test::streamResultCallback_(streamId, streamResultMeta);
940 }
941 return HDI::Camera::V1_0::NO_ERROR;
942 }
943
OnError(ErrorType type,int32_t errorMsg)944 int32_t Test::DemoCameraDeviceCallback::OnError(ErrorType type, int32_t errorMsg)
945 {
946 CAMERA_LOGE("type: %{public}d, errorMsg: %{public}d", type, errorMsg);
947 return HDI::Camera::V1_0::NO_ERROR;
948 }
949
OnResult(uint64_t timestamp,const std::vector<uint8_t> & result)950 int32_t Test::DemoCameraDeviceCallback::OnResult(uint64_t timestamp, const std::vector<uint8_t> &result)
951 {
952 MetadataUtils::ConvertVecToMetadata(result, resultMeta);
953 if (Test::resultCallback_) {
954 Test::resultCallback_(timestamp, resultMeta);
955 }
956 return HDI::Camera::V1_0::NO_ERROR;
957 }
958
OnCameraStatus(const std::string & cameraId,CameraStatus status)959 int32_t Test::TestCameraHostCallback::OnCameraStatus(const std::string& cameraId, CameraStatus status)
960 {
961 CAMERA_LOGE("cameraId: %{public}s, status: %{public}d", cameraId.c_str(), status);
962 return HDI::Camera::V1_0::NO_ERROR;
963 }
964
OnFlashlightStatus(const std::string & cameraId,FlashlightStatus status)965 int32_t Test::TestCameraHostCallback::OnFlashlightStatus(const std::string& cameraId, FlashlightStatus status)
966 {
967 CAMERA_LOGE("cameraId: %{public}s, status: %{public}d", cameraId.c_str(), status);
968 return HDI::Camera::V1_0::NO_ERROR;
969 }
970
OnCameraEvent(const std::string & cameraId,CameraEvent event)971 int32_t Test::TestCameraHostCallback::OnCameraEvent(const std::string& cameraId, CameraEvent event)
972 {
973 CAMERA_LOGE("cameraId: %{public}s, status: %{public}d", cameraId.c_str(), event);
974 return HDI::Camera::V1_0::NO_ERROR;
975 }
976
OnCameraStatus(const std::string & cameraId,CameraStatus status)977 int32_t Test::TestCameraHostCallbackV1_2::OnCameraStatus(const std::string& cameraId, CameraStatus status)
978 {
979 return instanceImpl.OnCameraStatus(cameraId, status);
980 }
981
OnFlashlightStatus(const std::string & cameraId,FlashlightStatus status)982 int32_t Test::TestCameraHostCallbackV1_2::OnFlashlightStatus(const std::string& cameraId, FlashlightStatus status)
983 {
984 return instanceImpl.OnFlashlightStatus(cameraId, status);
985 }
986
OnCameraEvent(const std::string & cameraId,CameraEvent event)987 int32_t Test::TestCameraHostCallbackV1_2::OnCameraEvent(const std::string& cameraId, CameraEvent event)
988 {
989 return instanceImpl.OnCameraEvent(cameraId, event);
990 }
991
OnFlashlightStatus_V1_2(FlashlightStatus status)992 int32_t Test::TestCameraHostCallbackV1_2::OnFlashlightStatus_V1_2(FlashlightStatus status)
993 {
994 CAMERA_LOGE("status: %{public}d", status);
995 Test::statusCallback = status;
996 return HDI::Camera::V1_0::NO_ERROR;
997 }
998 } // OHOS::Camera
999